exprscan.l File Reference

#include "postgres_fe.h"
#include "fe_utils/psqlscan_int.h"
#include "pgbench.h"
#include "exprparse.h"

Include dependency graph for exprscan.l:

Go to the source code of this file.

Functions
int	yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
void	expr_yyerror_more (yyscan_t yyscanner, const char *message, const char *more)
void	expr_yyerror (PgBenchExpr **expr_parse_result_p, yyscan_t yyscanner, const char *message)
bool	expr_lex_one_word (PsqlScanState state, PQExpBuffer word_buf, int *offset)
yyscan_t	expr_scanner_init (PsqlScanState state, const char *source, int lineno, int start_offset, const char *command)
void	expr_scanner_finish (yyscan_t yyscanner)
char *	expr_scanner_get_substring (PsqlScanState state, int start_offset, bool chomp)

Variables
static const char *	expr_source = NULL
static int	expr_lineno = 0
static int	expr_start_offset = 0
static const char *	expr_command = NULL
static bool	last_was_newline = false

Function Documentation

expr_lex_one_word()

bool expr_lex_one_word	(	PsqlScanState	state,
		PQExpBuffer	word_buf,
		int *	offset
	)

Definition at line 318 of file exprscan.l.

{
    int         lexresult;
    YYSTYPE     lval;
 
    /* Must be scanning already */
    Assert(state->scanbufhandle != NULL);
 
    /* Set current output target */
    state->output_buf = word_buf;
    resetPQExpBuffer(word_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);
 
    /* Set start state */
    state->start_state = INITIAL;
 
    /* And lex. */
    lexresult = yylex(&lval, state->scanner);
 
    /* Save start offset of word, if any. */
    if (lexresult)
    {
        int         lineno;
        int         end_offset;
 
        psql_scan_get_location(state, &lineno, &end_offset);
        *offset = end_offset - word_buf->len;
    }
    else
        *offset = -1;
 
    /*
     * In case the caller returns to using the regular SQL lexer, reselect the
     * appropriate initial state.
     */
    psql_scan_reselect_sql_lexer(state);
 
    return (bool) lexresult;
}

References Assert(), PQExpBufferData::len, psql_scan_get_location(), psql_scan_reselect_sql_lexer(), resetPQExpBuffer(), and yylex().

Referenced by process_backslash_command().

expr_scanner_finish()

void expr_scanner_finish

(

yyscan_t

yyscanner

)

Definition at line 402 of file exprscan.l.

{
    PsqlScanState state = yyget_extra(yyscanner);
 
    /*
     * Reselect appropriate initial state for SQL lexer.
     */
    psql_scan_reselect_sql_lexer(state);
}

References psql_scan_reselect_sql_lexer().

Referenced by process_backslash_command().

expr_scanner_get_substring()

char * expr_scanner_get_substring	(	PsqlScanState	state,
		int	start_offset,
		bool	chomp
	)

Definition at line 425 of file exprscan.l.

{
    char       *result;
    const char *scanptr = state->scanbuf + start_offset;
    size_t      slen = strlen(scanptr);
 
    if (chomp)
    {
        while (slen > 0 &&
               (scanptr[slen - 1] == '\n' || scanptr[slen - 1] == '\r'))
            slen--;
    }
 
    result = (char *) pg_malloc(slen + 1);
    memcpy(result, scanptr, slen);
    result[slen] = '\0';
 
    return result;
}

References pg_malloc().

Referenced by expr_yyerror_more(), and process_backslash_command().

expr_scanner_init()

yyscan_t expr_scanner_init	(	PsqlScanState	state,
		const char *	source,
		int	lineno,
		int	start_offset,
		const char *	command
	)

Definition at line 370 of file exprscan.l.

{
    /* Save error context info */
    expr_source = source;
    expr_lineno = lineno;
    expr_start_offset = start_offset;
    expr_command = command;
 
    /* Must be scanning already */
    Assert(state->scanbufhandle != NULL);
 
    /* Set current output target */
    state->output_buf = NULL;
 
    /* 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);
 
    /* Set start state */
    state->start_state = EXPR;
 
    return state->scanner;
}

References Assert(), expr_command, expr_lineno, expr_source, expr_start_offset, and source.

Referenced by process_backslash_command().

expr_yyerror()

void expr_yyerror	(	PgBenchExpr **	expr_parse_result_p,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 307 of file exprscan.l.

{
    expr_yyerror_more(yyscanner, message, NULL);
}

References expr_yyerror_more().

expr_yyerror_more()

void expr_yyerror_more	(	yyscan_t	yyscanner,
		const char *	message,
		const char *	more
	)

Definition at line 271 of file exprscan.l.

{
    PsqlScanState state = yyget_extra(yyscanner);
    int         lineno;
    int         error_detection_offset;
    YYSTYPE     lval;
    char       *full_line;
 
    psql_scan_get_location(state, &lineno, &error_detection_offset);
    error_detection_offset--;
 
    /*
     * While parsing an expression, we may not have collected the whole line
     * yet from the input source.  Lex till EOL so we can report whole line.
     * (If we're at EOF, it's okay to call yylex() an extra time.)
     */
    if (!last_was_newline)
    {
        while (yylex(&lval, yyscanner))
             /* skip */ ;
    }
 
    /* Extract the line, trimming trailing newline if any */
    full_line = expr_scanner_get_substring(state,
                                           expr_start_offset,
                                           true);
 
    syntax_error(expr_source, expr_lineno, full_line, expr_command,
                 message, more, error_detection_offset - expr_start_offset);
}

References expr_command, expr_lineno, expr_scanner_get_substring(), expr_source, expr_start_offset, last_was_newline, psql_scan_get_location(), syntax_error(), and yylex().

Referenced by expr_yyerror().

yylex()

int yylex	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 94 of file exprscan.l.

 {
        /* Declare some local variables inside yylex(), for convenience */
        PsqlScanState cur_state = yyextra;
 
        /*
         * 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);
 
        /* Reset was-newline flag */
        last_was_newline = false;
%}
 
    /* INITIAL state */
 
{nonspace}+     {
                    /* Found a word, emit and return it */
                    psqlscan_emit(cur_state, yytext, yyleng);
                    return 1;
                }
 
    /*
     * We need this rule to avoid returning "word\" instead of recognizing
     * a continuation marker just after a word:
     */
{nonspace}+{continuation}   {
                    /* Found "word\\\r?\n", emit and return just "word" */
                    int     wordlen = yyleng - 2;
                    if (yytext[wordlen] == '\r')
                        wordlen--;
                    Assert(yytext[wordlen] == '\\');
                    psqlscan_emit(cur_state, yytext, wordlen);
                    return 1;
                }
 
{space}+        { /* ignore */ }
 
{continuation}  { /* ignore */ }
 
{newline}       {
                    /* report end of command */
                    last_was_newline = true;
                    return 0;
                }
 
    /* EXPR state */
 
<EXPR>{
 
"+"             { return '+'; }
"-"             { return '-'; }
"*"             { return '*'; }
"/"             { return '/'; }
"%"             { return '%'; } /* C version, also in Pg SQL */
"="             { return '='; }
"<>"            { return NE_OP; }
"!="            { return NE_OP; } /* C version, also in Pg SQL */
"<="            { return LE_OP; }
">="            { return GE_OP; }
"<<"            { return LS_OP; }
">>"            { return RS_OP; }
"<"             { return '<'; }
">"             { return '>'; }
"|"             { return '|'; }
"&"             { return '&'; }
"#"             { return '#'; }
"~"             { return '~'; }
 
"("             { return '('; }
")"             { return ')'; }
","             { return ','; }
 
{and}           { return AND_OP; }
{or}            { return OR_OP; }
{not}           { return NOT_OP; }
{is}            { return IS_OP; }
{isnull}        { return ISNULL_OP; }
{notnull}       { return NOTNULL_OP; }
 
{case}          { return CASE_KW; }
{when}          { return WHEN_KW; }
{then}          { return THEN_KW; }
{else}          { return ELSE_KW; }
{end}           { return END_KW; }
 
:{alnum}+       {
                    yylval->str = pg_strdup(yytext + 1);
                    return VARIABLE;
                }
 
{null}          { return NULL_CONST; }
{true}          {
                    yylval->bval = true;
                    return BOOLEAN_CONST;
                }
{false}         {
                    yylval->bval = false;
                    return BOOLEAN_CONST;
                }
"9223372036854775808" {
                    /*
                     * Special handling for PG_INT64_MIN, which can't
                     * accurately be represented here, as the minus sign is
                     * lexed separately and INT64_MIN can't be represented as
                     * a positive integer.
                     */
                    return MAXINT_PLUS_ONE_CONST;
                }
{digit}+        {
                    if (!strtoint64(yytext, true, &yylval->ival))
                        expr_yyerror_more(yyscanner, "bigint constant overflow",
                                          strdup(yytext));
                    return INTEGER_CONST;
                }
{digit}+(\.{digit}*)?([eE][-+]?{digit}+)?   {
                    if (!strtodouble(yytext, true, &yylval->dval))
                        expr_yyerror_more(yyscanner, "double constant overflow",
                                          strdup(yytext));
                    return DOUBLE_CONST;
                }
\.{digit}+([eE][-+]?{digit}+)?  {
                    if (!strtodouble(yytext, true, &yylval->dval))
                        expr_yyerror_more(yyscanner, "double constant overflow",
                                          strdup(yytext));
                    return DOUBLE_CONST;
                }
{alpha}{alnum}* {
                    yylval->str = pg_strdup(yytext);
                    return FUNCTION;
                }
 
{space}+        { /* ignore */ }
 
{continuation}  { /* ignore */ }
 
{newline}       {
                    /* report end of command */
                    last_was_newline = true;
                    return 0;
                }
 
.               {
                    /*
                     * must strdup yytext so that expr_yyerror_more doesn't
                     * change it while finding end of line
                     */
                    expr_yyerror_more(yyscanner, "unexpected character",
                                      pg_strdup(yytext));
                    /* NOTREACHED, syntax_error calls exit() */
                    return 0;
                }
 
}
 
<<EOF>>         {
                    if (cur_state->buffer_stack == NULL)
                        return 0;           /* 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 expr_lex_one_word(), and expr_yyerror_more().

Variable Documentation

expr_command

const char* expr_command = NULL

static

Definition at line 42 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

expr_lineno

int expr_lineno = 0

static

Definition at line 40 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

expr_source

const char* expr_source = NULL

static

Definition at line 39 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

expr_start_offset

int expr_start_offset = 0

static

Definition at line 41 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

last_was_newline

bool last_was_newline = false

static

Definition at line 45 of file exprscan.l.

Referenced by expr_yyerror_more().