psqlscan.l File Reference

#include "postgres_fe.h"
#include "common/logging.h"
#include "fe_utils/psqlscan.h"
#include "libpq-fe.h"
#include "fe_utils/psqlscan_int.h"

Include dependency graph for psqlscan.l:

Go to the source code of this file.

Macros
#define	LEXRES_EOL   0 /* end of input */
#define	LEXRES_SEMI   1 /* command-terminating semicolon found */
#define	LEXRES_BACKSLASH   2 /* backslash command start */
#define	ECHO   psqlscan_emit(cur_state, yytext, yyleng)

Typedefs
typedef int	YYSTYPE

Functions
int	yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
PsqlScanState	psql_scan_create (const PsqlScanCallbacks *callbacks)
void	psql_scan_destroy (PsqlScanState state)
void	psql_scan_set_passthrough (PsqlScanState state, void *passthrough)
void	psql_scan_setup (PsqlScanState state, const char *line, int line_len, int encoding, bool std_strings)
PsqlScanResult	psql_scan (PsqlScanState state, PQExpBuffer query_buf, promptStatus_t *prompt)
void	psql_scan_finish (PsqlScanState state)
void	psql_scan_reset (PsqlScanState state)
void	psql_scan_reselect_sql_lexer (PsqlScanState state)
bool	psql_scan_in_quote (PsqlScanState state)
void	psql_scan_get_location (PsqlScanState state, int *lineno, int *offset)
void	psqlscan_push_new_buffer (PsqlScanState state, const char *newstr, const char *varname)
void	psqlscan_pop_buffer_stack (PsqlScanState state)
void	psqlscan_select_top_buffer (PsqlScanState state)
bool	psqlscan_var_is_current_source (PsqlScanState state, const char *varname)
YY_BUFFER_STATE	psqlscan_prepare_buffer (PsqlScanState state, const char *txt, int len, char **txtcopy)
void	psqlscan_emit (PsqlScanState state, const char *txt, int len)
char *	psqlscan_extract_substring (PsqlScanState state, const char *txt, int len)
void	psqlscan_escape_variable (PsqlScanState state, const char *txt, int len, PsqlScanQuoteType quote)
void	psqlscan_test_variable (PsqlScanState state, const char *txt, int len)

Macro Definition Documentation

ECHO

#define ECHO   psqlscan_emit(cur_state, yytext, yyleng)

Definition at line 62 of file psqlscan.l.

LEXRES_BACKSLASH

#define LEXRES_BACKSLASH   2 /* backslash command start */

Definition at line 59 of file psqlscan.l.

LEXRES_EOL

#define LEXRES_EOL   0 /* end of input */

Definition at line 57 of file psqlscan.l.

LEXRES_SEMI

#define LEXRES_SEMI   1 /* command-terminating semicolon found */

Definition at line 58 of file psqlscan.l.

Typedef Documentation

YYSTYPE

typedef int YYSTYPE

Definition at line 53 of file psqlscan.l.

Function Documentation

psql_scan()

PsqlScanResult psql_scan	(	PsqlScanState	state,
		PQExpBuffer	query_buf,
		promptStatus_t *	prompt
	)

Definition at line 1121 of file psqlscan.l.

{
    PsqlScanResult result;
    int         lexresult;
 
    /* Must be scanning already */
    Assert(state->scanbufhandle != NULL);
 
    /* Set current output target */
    state->output_buf = query_buf;
 
    /* Set input source */
    if (state->buffer_stack != NULL)
        yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
    else
        yy_switch_to_buffer(state->scanbufhandle, state->scanner);
 
    /* And lex. */
    lexresult = yylex(NULL, state->scanner);
 
    /* Notify psql_scan_get_location() that a yylex call has been made. */
    if (state->cur_line_no == 0)
        state->cur_line_no = 1;
 
    /*
     * Check termination state and return appropriate result info.
     */
    switch (lexresult)
    {
        case LEXRES_EOL:        /* end of input */
            switch (state->start_state)
            {
                case INITIAL:
                case xqs:       /* we treat this like INITIAL */
                    if (state->paren_depth > 0)
                    {
                        result = PSCAN_INCOMPLETE;
                        *prompt = PROMPT_PAREN;
                    }
                    else if (state->begin_depth > 0)
                    {
                        result = PSCAN_INCOMPLETE;
                        *prompt = PROMPT_CONTINUE;
                    }
                    else if (query_buf->len > 0)
                    {
                        result = PSCAN_EOL;
                        *prompt = PROMPT_CONTINUE;
                    }
                    else
                    {
                        /* never bother to send an empty buffer */
                        result = PSCAN_INCOMPLETE;
                        *prompt = PROMPT_READY;
                    }
                    break;
                case xb:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_SINGLEQUOTE;
                    break;
                case xc:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_COMMENT;
                    break;
                case xd:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_DOUBLEQUOTE;
                    break;
                case xh:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_SINGLEQUOTE;
                    break;
                case xe:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_SINGLEQUOTE;
                    break;
                case xq:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_SINGLEQUOTE;
                    break;
                case xdolq:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_DOLLARQUOTE;
                    break;
                case xui:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_DOUBLEQUOTE;
                    break;
                case xus:
                    result = PSCAN_INCOMPLETE;
                    *prompt = PROMPT_SINGLEQUOTE;
                    break;
                default:
                    /* can't get here */
                    fprintf(stderr, "invalid YY_START\n");
                    exit(1);
            }
            break;
        case LEXRES_SEMI:       /* semicolon */
            result = PSCAN_SEMICOLON;
            *prompt = PROMPT_READY;
            break;
        case LEXRES_BACKSLASH:  /* backslash */
            result = PSCAN_BACKSLASH;
            *prompt = PROMPT_READY;
            break;
        default:
            /* can't get here */
            fprintf(stderr, "invalid yylex result\n");
            exit(1);
    }
 
    return result;
}

References Assert(), fprintf, PQExpBufferData::len, LEXRES_BACKSLASH, LEXRES_EOL, LEXRES_SEMI, PROMPT_COMMENT, PROMPT_CONTINUE, PROMPT_DOLLARQUOTE, PROMPT_DOUBLEQUOTE, PROMPT_PAREN, PROMPT_READY, PROMPT_SINGLEQUOTE, PSCAN_BACKSLASH, PSCAN_EOL, PSCAN_INCOMPLETE, PSCAN_SEMICOLON, and yylex().

Referenced by MainLoop(), ParseScript(), and test_psql_parse().

psql_scan_create()

PsqlScanState psql_scan_create

(

const PsqlScanCallbacks *

callbacks

)

Definition at line 1001 of file psqlscan.l.

{
    PsqlScanState state;
 
    state = (PsqlScanStateData *) pg_malloc0(sizeof(PsqlScanStateData));
 
    state->callbacks = callbacks;
 
    yylex_init(&state->scanner);
 
    yyset_extra(state, state->scanner);
 
    psql_scan_reset(state);
 
    return state;
}

References pg_malloc0(), and psql_scan_reset().

Referenced by main(), MainLoop(), ParseScript(), and test_psql_parse().

psql_scan_destroy()

void psql_scan_destroy

(

PsqlScanState

state

)

Definition at line 1022 of file psqlscan.l.

{
    psql_scan_finish(state);
 
    psql_scan_reset(state);
 
    yylex_destroy(state->scanner);
 
    free(state);
}

References free, psql_scan_finish(), and psql_scan_reset().

Referenced by main(), MainLoop(), ParseScript(), and test_psql_parse().

psql_scan_finish()

void psql_scan_finish

(

PsqlScanState

state

)

Definition at line 1248 of file psqlscan.l.

{
    /* Drop any incomplete variable expansions. */
    while (state->buffer_stack != NULL)
        psqlscan_pop_buffer_stack(state);
 
    /* Done with the outer scan buffer, too */
    if (state->scanbufhandle)
        yy_delete_buffer(state->scanbufhandle, state->scanner);
    state->scanbufhandle = NULL;
    if (state->scanbuf)
        free(state->scanbuf);
    state->scanbuf = NULL;
}

References free, and psqlscan_pop_buffer_stack().

Referenced by MainLoop(), ParseScript(), and psql_scan_destroy().

psql_scan_get_location()

void psql_scan_get_location	(	PsqlScanState	state,
		int *	lineno,
		int *	offset
	)

Definition at line 1335 of file psqlscan.l.

{
    const char *line_end;
 
    /*
     * We rely on flex's having stored a NUL after the current token in
     * scanbuf.  Therefore we must specially handle the state before yylex()
     * has been called, when obviously that won't have happened yet.
     */
    if (state->cur_line_no == 0)
    {
        *lineno = 1;
        *offset = 0;
        return;
    }
 
    /*
     * Advance cur_line_no/cur_line_ptr past whatever has been lexed so far.
     * Doing this prevents repeated calls from being O(N^2) for long inputs.
     */
    while ((line_end = strchr(state->cur_line_ptr, '\n')) != NULL)
    {
        state->cur_line_no++;
        state->cur_line_ptr = line_end + 1;
    }
    state->cur_line_ptr += strlen(state->cur_line_ptr);
 
    /* Report current location. */
    *lineno = state->cur_line_no;
    *offset = state->cur_line_ptr - state->scanbuf;
}

Referenced by expr_lex_one_word(), expr_yyerror_more(), and ParseScript().

psql_scan_in_quote()

bool psql_scan_in_quote

(

PsqlScanState

state

)

Definition at line 1316 of file psqlscan.l.

{
    return state->start_state != INITIAL &&
        state->start_state != xqs;
}

Referenced by MainLoop().

psql_scan_reselect_sql_lexer()

void psql_scan_reselect_sql_lexer

(

PsqlScanState

state

)

Definition at line 1303 of file psqlscan.l.

{
    state->start_state = INITIAL;
}

Referenced by expr_lex_one_word(), expr_scanner_finish(), psql_scan_slash_command(), psql_scan_slash_command_end(), and psql_scan_slash_option().

psql_scan_reset()

void psql_scan_reset

(

PsqlScanState

state

)

Definition at line 1275 of file psqlscan.l.

{
    state->start_state = INITIAL;
    state->paren_depth = 0;
    state->xcdepth = 0;         /* not really necessary */
    if (state->dolqstart)
        free(state->dolqstart);
    state->dolqstart = NULL;
    state->identifier_count = 0;
    state->begin_depth = 0;
}

References free.

Referenced by exec_command_reset(), exec_command_watch(), MainLoop(), psql_scan_create(), and psql_scan_destroy().

psql_scan_set_passthrough()

void psql_scan_set_passthrough	(	PsqlScanState	state,
		void *	passthrough
	)

Definition at line 1041 of file psqlscan.l.

{
    state->cb_passthrough = passthrough;
}

Referenced by main(), and MainLoop().

psql_scan_setup()

void psql_scan_setup	(	PsqlScanState	state,
		const char *	line,
		int	line_len,
		int	encoding,
		bool	std_strings
	)

Definition at line 1059 of file psqlscan.l.

{
    /* Mustn't be scanning already */
    Assert(state->scanbufhandle == NULL);
    Assert(state->buffer_stack == NULL);
 
    /* Do we need to hack the character set encoding? */
    state->encoding = encoding;
    state->safe_encoding = pg_valid_server_encoding_id(encoding);
 
    /* Save standard-strings flag as well */
    state->std_strings = std_strings;
 
    /* Set up flex input buffer with appropriate translation and padding */
    state->scanbufhandle = psqlscan_prepare_buffer(state, line, line_len,
                                                   &state->scanbuf);
    state->scanline = line;
 
    /* Set lookaside data in case we have to map unsafe encoding */
    state->curline = state->scanbuf;
    state->refline = state->scanline;
 
    /* Initialize state for psql_scan_get_location() */
    state->cur_line_no = 0;     /* yylex not called yet */
    state->cur_line_ptr = state->scanbuf;
}

References Assert(), encoding, pg_valid_server_encoding_id, and psqlscan_prepare_buffer().

Referenced by main(), MainLoop(), ParseScript(), and test_psql_parse().

psqlscan_emit()

void psqlscan_emit	(	PsqlScanState	state,
		const char *	txt,
		int	len
	)

Definition at line 1517 of file psqlscan.l.

{
    PQExpBuffer output_buf = state->output_buf;
 
    if (state->safe_encoding)
        appendBinaryPQExpBuffer(output_buf, txt, len);
    else
    {
        /* Gotta do it the hard way */
        const char *reference = state->refline;
        int         i;
 
        reference += (txt - state->curline);
 
        for (i = 0; i < len; i++)
        {
            char        ch = txt[i];
 
            if (ch == (char) 0xFF)
                ch = reference[i];
            appendPQExpBufferChar(output_buf, ch);
        }
    }
}

References appendBinaryPQExpBuffer(), appendPQExpBufferChar(), i, and len.

Referenced by psqlscan_escape_variable().

psqlscan_escape_variable()

void psqlscan_escape_variable	(	PsqlScanState	state,
		const char *	txt,
		int	len,
		PsqlScanQuoteType	quote
	)

Definition at line 1585 of file psqlscan.l.

{
    char       *varname;
    char       *value;
 
    /* Variable lookup. */
    varname = psqlscan_extract_substring(state, txt + 2, len - 3);
    if (state->callbacks->get_variable)
        value = state->callbacks->get_variable(varname, quote,
                                               state->cb_passthrough);
    else
        value = NULL;
    free(varname);
 
    if (value)
    {
        /* Emit the suitably-escaped value */
        appendPQExpBufferStr(state->output_buf, value);
        free(value);
    }
    else
    {
        /* Emit original token as-is */
        psqlscan_emit(state, txt, len);
    }
}

References appendPQExpBufferStr(), free, len, psqlscan_emit(), psqlscan_extract_substring(), and value.

psqlscan_extract_substring()

char * psqlscan_extract_substring	(	PsqlScanState	state,
		const char *	txt,
		int	len
	)

Definition at line 1549 of file psqlscan.l.

{
    char       *result = (char *) pg_malloc(len + 1);
 
    if (state->safe_encoding)
        memcpy(result, txt, len);
    else
    {
        /* Gotta do it the hard way */
        const char *reference = state->refline;
        int         i;
 
        reference += (txt - state->curline);
 
        for (i = 0; i < len; i++)
        {
            char        ch = txt[i];
 
            if (ch == (char) 0xFF)
                ch = reference[i];
            result[i] = ch;
        }
    }
    result[len] = '\0';
    return result;
}

References i, len, and pg_malloc().

Referenced by psqlscan_escape_variable(), and psqlscan_test_variable().

psqlscan_pop_buffer_stack()

void psqlscan_pop_buffer_stack

(

PsqlScanState

state

)

Definition at line 1413 of file psqlscan.l.

{
    StackElem  *stackelem = state->buffer_stack;
 
    state->buffer_stack = stackelem->next;
    yy_delete_buffer(stackelem->buf, state->scanner);
    free(stackelem->bufstring);
    if (stackelem->origstring)
        free(stackelem->origstring);
    if (stackelem->varname)
        free(stackelem->varname);
    free(stackelem);
}

References StackElem::buf, StackElem::bufstring, free, StackElem::next, StackElem::origstring, and StackElem::varname.

Referenced by psql_scan_finish().

psqlscan_prepare_buffer()

YY_BUFFER_STATE psqlscan_prepare_buffer	(	PsqlScanState	state,
		const char *	txt,
		int	len,
		char **	txtcopy
	)

Definition at line 1476 of file psqlscan.l.

{
    char       *newtxt;
 
    /* Flex wants two \0 characters after the actual data */
    newtxt = pg_malloc(len + 2);
    *txtcopy = newtxt;
    newtxt[len] = newtxt[len + 1] = YY_END_OF_BUFFER_CHAR;
 
    if (state->safe_encoding)
        memcpy(newtxt, txt, len);
    else
    {
        /* Gotta do it the hard way */
        int         i = 0;
 
        while (i < len)
        {
            int         thislen = PQmblen(txt + i, state->encoding);
 
            /* first byte should always be okay... */
            newtxt[i] = txt[i];
            i++;
            while (--thislen > 0 && i < len)
                newtxt[i++] = (char) 0xFF;
        }
    }
 
    return yy_scan_buffer(newtxt, len + 2, state->scanner);
}

References i, len, pg_malloc(), and PQmblen().

Referenced by psql_scan_setup(), and psqlscan_push_new_buffer().

psqlscan_push_new_buffer()

void psqlscan_push_new_buffer	(	PsqlScanState	state,
		const char *	newstr,
		const char *	varname
	)

Definition at line 1374 of file psqlscan.l.

{
    StackElem  *stackelem;
 
    stackelem = (StackElem *) pg_malloc(sizeof(StackElem));
 
    /*
     * In current usage, the passed varname points at the current flex input
     * buffer; we must copy it before calling psqlscan_prepare_buffer()
     * because that will change the buffer state.
     */
    stackelem->varname = varname ? pg_strdup(varname) : NULL;
 
    stackelem->buf = psqlscan_prepare_buffer(state, newstr, strlen(newstr),
                                             &stackelem->bufstring);
    state->curline = stackelem->bufstring;
    if (state->safe_encoding)
    {
        stackelem->origstring = NULL;
        state->refline = stackelem->bufstring;
    }
    else
    {
        stackelem->origstring = pg_strdup(newstr);
        state->refline = stackelem->origstring;
    }
    stackelem->next = state->buffer_stack;
    state->buffer_stack = stackelem;
}

References StackElem::buf, StackElem::bufstring, StackElem::next, StackElem::origstring, pg_malloc(), pg_strdup(), psqlscan_prepare_buffer(), and StackElem::varname.

psqlscan_select_top_buffer()

void psqlscan_select_top_buffer

(

PsqlScanState

state

)

Definition at line 1431 of file psqlscan.l.

{
    StackElem  *stackelem = state->buffer_stack;
 
    if (stackelem != NULL)
    {
        yy_switch_to_buffer(stackelem->buf, state->scanner);
        state->curline = stackelem->bufstring;
        state->refline = stackelem->origstring ? stackelem->origstring : stackelem->bufstring;
    }
    else
    {
        yy_switch_to_buffer(state->scanbufhandle, state->scanner);
        state->curline = state->scanbuf;
        state->refline = state->scanline;
    }
}

References StackElem::buf, StackElem::bufstring, and StackElem::origstring.

psqlscan_test_variable()

void psqlscan_test_variable	(	PsqlScanState	state,
		const char *	txt,
		int	len
	)

Definition at line 1614 of file psqlscan.l.

{
    char       *varname;
    char       *value;
 
    varname = psqlscan_extract_substring(state, txt + 3, len - 4);
    if (state->callbacks->get_variable)
        value = state->callbacks->get_variable(varname, PQUOTE_PLAIN,
                                               state->cb_passthrough);
    else
        value = NULL;
    free(varname);
 
    if (value != NULL)
    {
        appendPQExpBufferStr(state->output_buf, "TRUE");
        free(value);
    }
    else
    {
        appendPQExpBufferStr(state->output_buf, "FALSE");
    }
}

References appendPQExpBufferStr(), free, len, PQUOTE_PLAIN, psqlscan_extract_substring(), and value.

psqlscan_var_is_current_source()

bool psqlscan_var_is_current_source	(	PsqlScanState	state,
		const char *	varname
	)

Definition at line 1454 of file psqlscan.l.

{
    StackElem  *stackelem;
 
    for (stackelem = state->buffer_stack;
         stackelem != NULL;
         stackelem = stackelem->next)
    {
        if (stackelem->varname && strcmp(stackelem->varname, varname) == 0)
            return true;
    }
    return false;
}

References StackElem::next, and StackElem::varname.

yylex()

int yylex	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 385 of file psqlscan.l.

 {
        /* Declare some local variables inside yylex(), for convenience */
        PsqlScanState cur_state = yyextra;
        PQExpBuffer output_buf = cur_state->output_buf;
 
        /*
         * Force flex into the state indicated by start_state.  This has a
         * couple of purposes: it lets some of the functions below set a new
         * starting state without ugly direct access to flex variables, and it
         * allows us to transition from one flex lexer to another so that we
         * can lex different parts of the source string using separate lexers.
         */
        BEGIN(cur_state->start_state);
%}
 
{whitespace}    {
                    /*
                     * Note that the whitespace rule includes both true
                     * whitespace and single-line ("--" style) comments.
                     * We suppress whitespace until we have collected some
                     * non-whitespace data.  (This interacts with some
                     * decisions in MainLoop(); see there for details.)
                     */
                    if (output_buf->len > 0)
                        ECHO;
                }
 
{xcstart}       {
                    cur_state->xcdepth = 0;
                    BEGIN(xc);
                    /* Put back any characters past slash-star; see above */
                    yyless(2);
                    ECHO;
                }
 
<xc>{
{xcstart}       {
                    cur_state->xcdepth++;
                    /* Put back any characters past slash-star; see above */
                    yyless(2);
                    ECHO;
                }
 
{xcstop}        {
                    if (cur_state->xcdepth <= 0)
                        BEGIN(INITIAL);
                    else
                        cur_state->xcdepth--;
                    ECHO;
                }
 
{xcinside}      {
                    ECHO;
                }
 
{op_chars}      {
                    ECHO;
                }
 
\*+             {
                    ECHO;
                }
} /* <xc> */
 
{xbstart}       {
                    BEGIN(xb);
                    ECHO;
                }
<xh>{xhinside}  |
<xb>{xbinside}  {
                    ECHO;
                }
 
{xhstart}       {
                    /* Hexadecimal bit type.
                     * At some point we should simply pass the string
                     * forward to the parser and label it there.
                     * In the meantime, place a leading "x" on the string
                     * to mark it for the input routine as a hex string.
                     */
                    BEGIN(xh);
                    ECHO;
                }
 
{xnstart}       {
                    yyless(1);  /* eat only 'n' this time */
                    ECHO;
                }
 
{xqstart}       {
                    if (cur_state->std_strings)
                        BEGIN(xq);
                    else
                        BEGIN(xe);
                    ECHO;
                }
{xestart}       {
                    BEGIN(xe);
                    ECHO;
                }
{xusstart}      {
                    BEGIN(xus);
                    ECHO;
                }
 
<xb,xh,xq,xe,xus>{quote} {
                    /*
                     * When we are scanning a quoted string and see an end
                     * quote, we must look ahead for a possible continuation.
                     * If we don't see one, we know the end quote was in fact
                     * the end of the string.  To reduce the lexer table size,
                     * we use a single "xqs" state to do the lookahead for all
                     * types of strings.
                     */
                    cur_state->state_before_str_stop = YYSTATE;
                    BEGIN(xqs);
                    ECHO;
                }
<xqs>{quotecontinue} {
                    /*
                     * Found a quote continuation, so return to the in-quote
                     * state and continue scanning the literal.  Nothing is
                     * added to the literal's contents.
                     */
                    BEGIN(cur_state->state_before_str_stop);
                    ECHO;
                }
<xqs>{quotecontinuefail} |
<xqs>{other}    {
                    /*
                     * Failed to see a quote continuation.  Throw back
                     * everything after the end quote, and handle the string
                     * according to the state we were in previously.
                     */
                    yyless(0);
                    BEGIN(INITIAL);
                    /* There's nothing to echo ... */
                }
 
<xq,xe,xus>{xqdouble} {
                    ECHO;
                }
<xq,xus>{xqinside}  {
                    ECHO;
                }
<xe>{xeinside}  {
                    ECHO;
                }
<xe>{xeunicode} {
                    ECHO;
                }
<xe>{xeunicodefail} {
                    ECHO;
                }
<xe>{xeescape}  {
                    ECHO;
                }
<xe>{xeoctesc}  {
                    ECHO;
                }
<xe>{xehexesc}  {
                    ECHO;
                }
<xe>.           {
                    /* This is only needed for \ just before EOF */
                    ECHO;
                }
 
{dolqdelim}     {
                    cur_state->dolqstart = pg_strdup(yytext);
                    BEGIN(xdolq);
                    ECHO;
                }
{dolqfailed}    {
                    /* throw back all but the initial "$" */
                    yyless(1);
                    ECHO;
                }
<xdolq>{dolqdelim} {
                    if (strcmp(yytext, cur_state->dolqstart) == 0)
                    {
                        free(cur_state->dolqstart);
                        cur_state->dolqstart = NULL;
                        BEGIN(INITIAL);
                    }
                    else
                    {
                        /*
                         * When we fail to match $...$ to dolqstart, transfer
                         * the $... part to the output, but put back the final
                         * $ for rescanning.  Consider $delim$...$junk$delim$
                         */
                        yyless(yyleng - 1);
                    }
                    ECHO;
                }
<xdolq>{dolqinside} {
                    ECHO;
                }
<xdolq>{dolqfailed} {
                    ECHO;
                }
<xdolq>.        {
                    /* This is only needed for $ inside the quoted text */
                    ECHO;
                }
 
{xdstart}       {
                    BEGIN(xd);
                    ECHO;
                }
{xuistart}      {
                    BEGIN(xui);
                    ECHO;
                }
<xd>{xdstop}    {
                    BEGIN(INITIAL);
                    ECHO;
                }
<xui>{dquote}   {
                    BEGIN(INITIAL);
                    ECHO;
                }
<xd,xui>{xddouble}  {
                    ECHO;
                }
<xd,xui>{xdinside}  {
                    ECHO;
                }
 
{xufailed}  {
                    /* throw back all but the initial u/U */
                    yyless(1);
                    ECHO;
                }
 
{typecast}      {
                    ECHO;
                }
 
{dot_dot}       {
                    ECHO;
                }
 
{colon_equals}  {
                    ECHO;
                }
 
{equals_greater} {
                    ECHO;
                }
 
{less_equals}   {
                    ECHO;
                }
 
{greater_equals} {
                    ECHO;
                }
 
{less_greater}  {
                    ECHO;
                }
 
{not_equals}    {
                    ECHO;
                }
 
    /*
     * These rules are specific to psql --- they implement parenthesis
     * counting and detection of command-ending semicolon.  These must
     * appear before the {self} rule so that they take precedence over it.
     */
 
"("             {
                    cur_state->paren_depth++;
                    ECHO;
                }
 
")"             {
                    if (cur_state->paren_depth > 0)
                        cur_state->paren_depth--;
                    ECHO;
                }
 
";"             {
                    ECHO;
                    if (cur_state->paren_depth == 0 && cur_state->begin_depth == 0)
                    {
                        /* Terminate lexing temporarily */
                        cur_state->start_state = YY_START;
                        cur_state->identifier_count = 0;
                        return LEXRES_SEMI;
                    }
                }
 
    /*
     * psql-specific rules to handle backslash commands and variable
     * substitution.  We want these before {self}, also.
     */
 
"\\"[;:]        {
                    /* Force a semi-colon or colon into the query buffer */
                    psqlscan_emit(cur_state, yytext + 1, 1);
                    if (yytext[1] == ';')
                        cur_state->identifier_count = 0;
                }
 
"\\"            {
                    /* Terminate lexing temporarily */
                    cur_state->start_state = YY_START;
                    return LEXRES_BACKSLASH;
                }
 
:{variable_char}+   {
                    /* Possible psql variable substitution */
                    char       *varname;
                    char       *value;
 
                    varname = psqlscan_extract_substring(cur_state,
                                                         yytext + 1,
                                                         yyleng - 1);
                    if (cur_state->callbacks->get_variable)
                        value = cur_state->callbacks->get_variable(varname,
                                                                   PQUOTE_PLAIN,
                                                                   cur_state->cb_passthrough);
                    else
                        value = NULL;
 
                    if (value)
                    {
                        /* It is a variable, check for recursion */
                        if (psqlscan_var_is_current_source(cur_state, varname))
                        {
                            /* Recursive expansion --- don't go there */
                            pg_log_warning("skipping recursive expansion of variable \"%s\"",
                                                              varname);
                            /* Instead copy the string as is */
                            ECHO;
                        }
                        else
                        {
                            /* OK, perform substitution */
                            psqlscan_push_new_buffer(cur_state, value, varname);
                            /* yy_scan_string already made buffer active */
                        }
                        free(value);
                    }
                    else
                    {
                        /*
                         * if the variable doesn't exist we'll copy the string
                         * as is
                         */
                        ECHO;
                    }
 
                    free(varname);
                }
 
:'{variable_char}+' {
                    psqlscan_escape_variable(cur_state, yytext, yyleng,
                                             PQUOTE_SQL_LITERAL);
                }
 
:\"{variable_char}+\"   {
                    psqlscan_escape_variable(cur_state, yytext, yyleng,
                                             PQUOTE_SQL_IDENT);
                }
 
:\{\?{variable_char}+\} {
                    psqlscan_test_variable(cur_state, yytext, yyleng);
                }
 
    /*
     * These rules just avoid the need for scanner backup if one of the
     * three rules above fails to match completely.
     */
 
:'{variable_char}*  {
                    /* Throw back everything but the colon */
                    yyless(1);
                    ECHO;
                }
 
:\"{variable_char}* {
                    /* Throw back everything but the colon */
                    yyless(1);
                    ECHO;
                }
 
:\{\?{variable_char}*   {
                    /* Throw back everything but the colon */
                    yyless(1);
                    ECHO;
                }
:\{ {
                    /* Throw back everything but the colon */
                    yyless(1);
                    ECHO;
                }
 
    /*
     * Back to backend-compatible rules.
     */
 
{self}          {
                    ECHO;
                }
 
{operator}      {
                    /*
                     * Check for embedded slash-star or dash-dash; those
                     * are comment starts, so operator must stop there.
                     * Note that slash-star or dash-dash at the first
                     * character will match a prior rule, not this one.
                     */
                    int         nchars = yyleng;
                    char       *slashstar = strstr(yytext, "/*");
                    char       *dashdash = strstr(yytext, "--");
 
                    if (slashstar && dashdash)
                    {
                        /* if both appear, take the first one */
                        if (slashstar > dashdash)
                            slashstar = dashdash;
                    }
                    else if (!slashstar)
                        slashstar = dashdash;
                    if (slashstar)
                        nchars = slashstar - yytext;
 
                    /*
                     * For SQL compatibility, '+' and '-' cannot be the
                     * last char of a multi-char operator unless the operator
                     * contains chars that are not in SQL operators.
                     * The idea is to lex '=-' as two operators, but not
                     * to forbid operator names like '?-' that could not be
                     * sequences of SQL operators.
                     */
                    if (nchars > 1 &&
                        (yytext[nchars - 1] == '+' ||
                         yytext[nchars - 1] == '-'))
                    {
                        int         ic;
 
                        for (ic = nchars - 2; ic >= 0; ic--)
                        {
                            char c = yytext[ic];
                            if (c == '~' || c == '!' || c == '@' ||
                                c == '#' || c == '^' || c == '&' ||
                                c == '|' || c == '`' || c == '?' ||
                                c == '%')
                                break;
                        }
                        if (ic < 0)
                        {
                            /*
                             * didn't find a qualifying character, so remove
                             * all trailing [+-]
                             */
                            do {
                                nchars--;
                            } while (nchars > 1 &&
                                 (yytext[nchars - 1] == '+' ||
                                  yytext[nchars - 1] == '-'));
                        }
                    }
 
                    if (nchars < yyleng)
                    {
                        /* Strip the unwanted chars from the token */
                        yyless(nchars);
                    }
                    ECHO;
                }
 
{param}         {
                    ECHO;
                }
{param_junk}    {
                    ECHO;
                }
 
{decinteger}    {
                    ECHO;
                }
{hexinteger}    {
                    ECHO;
                }
{octinteger}    {
                    ECHO;
                }
{bininteger}    {
                    ECHO;
                }
{hexfail}       {
                    ECHO;
                }
{octfail}       {
                    ECHO;
                }
{binfail}       {
                    ECHO;
                }
{numeric}       {
                    ECHO;
                }
{numericfail}   {
                    /* throw back the .., and treat as integer */
                    yyless(yyleng - 2);
                    ECHO;
                }
{real}          {
                    ECHO;
                }
{realfail}      {
                    ECHO;
                }
{integer_junk}  {
                    ECHO;
                }
{numeric_junk}  {
                    ECHO;
                }
{real_junk}     {
                    ECHO;
                }
 
 
{identifier}    {
                    /*
                     * We need to track if we are inside a BEGIN .. END block
                     * in a function definition, so that semicolons contained
                     * therein don't terminate the whole statement.  Short of
                     * writing a full parser here, the following heuristic
                     * should work.  First, we track whether the beginning of
                     * the statement matches CREATE [OR REPLACE]
                     * {FUNCTION|PROCEDURE}
                     */
 
                    if (cur_state->identifier_count == 0)
                        memset(cur_state->identifiers, 0, sizeof(cur_state->identifiers));
 
                    if (pg_strcasecmp(yytext, "create") == 0 ||
                        pg_strcasecmp(yytext, "function") == 0 ||
                        pg_strcasecmp(yytext, "procedure") == 0 ||
                        pg_strcasecmp(yytext, "or") == 0 ||
                        pg_strcasecmp(yytext, "replace") == 0)
                    {
                        if (cur_state->identifier_count < sizeof(cur_state->identifiers))
                            cur_state->identifiers[cur_state->identifier_count] = pg_tolower((unsigned char) yytext[0]);
                    }
 
                    cur_state->identifier_count++;
 
                    if (cur_state->identifiers[0] == 'c' &&
                        (cur_state->identifiers[1] == 'f' || cur_state->identifiers[1] == 'p' ||
                         (cur_state->identifiers[1] == 'o' && cur_state->identifiers[2] == 'r' &&
                          (cur_state->identifiers[3] == 'f' || cur_state->identifiers[3] == 'p'))) &&
                        cur_state->paren_depth == 0)
                    {
                        if (pg_strcasecmp(yytext, "begin") == 0)
                            cur_state->begin_depth++;
                        else if (pg_strcasecmp(yytext, "case") == 0)
                        {
                            /*
                             * CASE also ends with END.  We only need to track
                             * this if we are already inside a BEGIN.
                             */
                            if (cur_state->begin_depth >= 1)
                                cur_state->begin_depth++;
                        }
                        else if (pg_strcasecmp(yytext, "end") == 0)
                        {
                            if (cur_state->begin_depth > 0)
                                cur_state->begin_depth--;
                        }
                    }
 
                    ECHO;
                }
 
{other}         {
                    ECHO;
                }
 
<<EOF>>         {
                    if (cur_state->buffer_stack == NULL)
                    {
                        cur_state->start_state = YY_START;
                        return LEXRES_EOL;      /* end of input reached */
                    }
 
                    /*
                     * We were expanding a variable, so pop the inclusion
                     * stack and keep lexing
                     */
                    psqlscan_pop_buffer_stack(cur_state);
                    psqlscan_select_top_buffer(cur_state);
                }
 
%%

Referenced by psql_scan().