Decouple psqlscan.l from surrounding program.

Remove assorted external references from psqlscan.l in preparation for
making it usable by other frontend programs.  This mostly involves
getting rid of direct calls to psql_error() and GetVariable() in favor
of introducing a callback-functions struct to encapsulate variable
fetching and error printing.  In addition, pass the current encoding
and standard-strings status as additional parameters to psql_scan_setup
instead of looking directly at "pset" or calling additional functions.

I did not bother to change some references to psql_error that are in
functions that will soon migrate to a psql-specific backslash-command
lexer.  Other than that, this version of psqlscan.l is capable of
compiling standalone.  It still depends on assorted src/common functions
as well as some encoding-related libpq functions, but we expect that
all programs using it will be happy with those dependencies.

Kyotaro Horiguchi, somewhat editorialized on by me

Author: tglsfdc

src/bin/psql/common.c

@@ -107,6 +107,65 @@ setQFout(const char *fname)
 }
 
 
+/*
+ * Variable-fetching callback for flex lexer
+ *
+ * If the specified variable exists, return its value as a string (malloc'd
+ * and expected to be freed by the caller); else return NULL.
+ *
+ * If "escape" is true, return the value suitably quoted and escaped,
+ * as an identifier or string literal depending on "as_ident".
+ * (Failure in escaping should lead to returning NULL.)
+ */
+char *
+psql_get_variable(const char *varname, bool escape, bool as_ident)
+{
+	char	   *result;
+	const char *value;
+
+	value = GetVariable(pset.vars, varname);
+	if (!value)
+		return NULL;
+
+	if (escape)
+	{
+		char	   *escaped_value;
+
+		if (!pset.db)
+		{
+			psql_error("can't escape without active connection\n");
+			return NULL;
+		}
+
+		if (as_ident)
+			escaped_value =
+				PQescapeIdentifier(pset.db, value, strlen(value));
+		else
+			escaped_value =
+				PQescapeLiteral(pset.db, value, strlen(value));
+
+		if (escaped_value == NULL)
+		{
+			const char *error = PQerrorMessage(pset.db);
+
+			psql_error("%s", error);
+			return NULL;
+		}
+
+		/*
+		 * Rather than complicate the lexer's API with a notion of which
+		 * free() routine to use, just pay the price of an extra strdup().
+		 */
+		result = pg_strdup(escaped_value);
+		PQfreemem(escaped_value);
+	}
+	else
+		result = pg_strdup(value);
+
+	return result;
+}
+
+
 /*
  * Error reporting for scripts. Errors should look like
  *	 psql:filename:lineno: message

src/bin/psql/common.h

@@ -18,6 +18,8 @@
 extern bool openQueryOutputFile(const char *fname, FILE **fout, bool *is_pipe);
 extern bool setQFout(const char *fname);
 
+extern char *psql_get_variable(const char *varname, bool escape, bool as_ident);
+
 extern void psql_error(const char *fmt,...) pg_attribute_printf(1, 2);
 
 extern void NoticeProcessor(void *arg, const char *message);

src/bin/psql/mainloop.c

@@ -8,7 +8,6 @@
 #include "postgres_fe.h"
 #include "mainloop.h"
 
-
 #include "command.h"
 #include "common.h"
 #include "input.h"
@@ -17,6 +16,13 @@
 #include "mb/pg_wchar.h"
 
 
+/* callback functions for our flex lexer */
+const PsqlScanCallbacks psqlscan_callbacks = {
+	psql_get_variable,
+	psql_error
+};
+
+
 /*
  * Main processing loop for reading lines of input
  *	and sending them to the backend.
@@ -61,7 +67,7 @@ MainLoop(FILE *source)
 	pset.stmt_lineno = 1;
 
 	/* Create working state */
-	scan_state = psql_scan_create();
+	scan_state = psql_scan_create(&psqlscan_callbacks);
 
 	query_buf = createPQExpBuffer();
 	previous_buf = createPQExpBuffer();
@@ -233,7 +239,8 @@ MainLoop(FILE *source)
 		/*
 		 * Parse line, looking for command separators.
 		 */
-		psql_scan_setup(scan_state, line, strlen(line));
+		psql_scan_setup(scan_state, line, strlen(line),
+						pset.encoding, standard_strings());
 		success = true;
 		line_saved_in_history = false;
 
@@ -373,7 +380,8 @@ MainLoop(FILE *source)
 					resetPQExpBuffer(query_buf);
 					/* reset parsing state since we are rescanning whole line */
 					psql_scan_reset(scan_state);
-					psql_scan_setup(scan_state, line, strlen(line));
+					psql_scan_setup(scan_state, line, strlen(line),
+									pset.encoding, standard_strings());
 					line_saved_in_history = false;
 					prompt_status = PROMPT_READY;
 				}

src/bin/psql/mainloop.h

@@ -8,6 +8,10 @@
 #ifndef MAINLOOP_H
 #define MAINLOOP_H
 
+#include "psqlscan.h"
+
+extern const PsqlScanCallbacks psqlscan_callbacks;
+
 extern int	MainLoop(FILE *source);
 
 #endif   /* MAINLOOP_H */

src/bin/psql/psqlscan.h

@@ -36,12 +36,23 @@ enum slash_option_type
 	OT_NO_EVAL					/* no expansion of backticks or variables */
 };
 
+/* Callback functions to be used by the lexer */
+typedef struct PsqlScanCallbacks
+{
+	/* Fetch value of a variable, as a pfree'able string; NULL if unknown */
+	/* This pointer can be NULL if no variable substitution is wanted */
+	char	   *(*get_variable) (const char *varname, bool escape, bool as_ident);
+	/* Print an error message someplace appropriate */
+	void		(*write_error) (const char *fmt,...) pg_attribute_printf(1, 2);
+} PsqlScanCallbacks;
+
 
-extern PsqlScanState psql_scan_create(void);
+extern PsqlScanState psql_scan_create(const PsqlScanCallbacks *callbacks);
 extern void psql_scan_destroy(PsqlScanState state);
 
 extern void psql_scan_setup(PsqlScanState state,
-				const char *line, int line_len);
+				const char *line, int line_len,
+				int encoding, bool std_strings);
 extern void psql_scan_finish(PsqlScanState state);
 
 extern PsqlScanResult psql_scan(PsqlScanState state,