gramparse.h File Reference

#include "nodes/parsenodes.h"
#include "parser/scanner.h"
#include "gram.h"

Include dependency graph for gramparse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	base_yy_extra_type

Macros
#define	pg_yyget_extra(yyscanner)   (*((base_yy_extra_type **) (yyscanner)))

Typedefs
typedef struct base_yy_extra_type	base_yy_extra_type

Functions
int	base_yylex (YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
void	parser_init (base_yy_extra_type *yyext)
int	base_yyparse (core_yyscan_t yyscanner)

Macro Definition Documentation

pg_yyget_extra

#define pg_yyget_extra

(

yyscanner

)

(*((base_yy_extra_type **) (yyscanner)))

Definition at line 64 of file gramparse.h.

Typedef Documentation

base_yy_extra_type

typedef struct base_yy_extra_type base_yy_extra_type

Function Documentation

base_yylex()

int base_yylex ( YYSTYPE *  lvalp, YYLTYPE *  llocp, core_yyscan_t  yyscanner  )

extern

Definition at line 111 of file parser.c.

{
    base_yy_extra_type *yyextra = pg_yyget_extra(yyscanner);
    int         cur_token;
    int         next_token;
    int         cur_token_length;
    YYLTYPE     cur_yylloc;
 
    /* Get next token --- we might already have it */
    if (yyextra->have_lookahead)
    {
        cur_token = yyextra->lookahead_token;
        lvalp->core_yystype = yyextra->lookahead_yylval;
        *llocp = yyextra->lookahead_yylloc;
        if (yyextra->lookahead_end)
            *(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
        yyextra->have_lookahead = false;
    }
    else
        cur_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
 
    /*
     * If this token isn't one that requires lookahead, just return it.  If it
     * does, determine the token length.  (We could get that via strlen(), but
     * since we have such a small set of possibilities, hardwiring seems
     * feasible and more efficient --- at least for the fixed-length cases.)
     */
    switch (cur_token)
    {
        case FORMAT:
            cur_token_length = 6;
            break;
        case NOT:
            cur_token_length = 3;
            break;
        case NULLS_P:
            cur_token_length = 5;
            break;
        case WITH:
            cur_token_length = 4;
            break;
        case UIDENT:
        case USCONST:
            cur_token_length = strlen(yyextra->core_yy_extra.scanbuf + *llocp);
            break;
        case WITHOUT:
            cur_token_length = 7;
            break;
        default:
            return cur_token;
    }
 
    /*
     * Identify end+1 of current token.  core_yylex() has temporarily stored a
     * '\0' here, and will undo that when we call it again.  We need to redo
     * it to fully revert the lookahead call for error reporting purposes.
     */
    yyextra->lookahead_end = yyextra->core_yy_extra.scanbuf +
        *llocp + cur_token_length;
    Assert(*(yyextra->lookahead_end) == '\0');
 
    /*
     * Save and restore *llocp around the call.  It might look like we could
     * avoid this by just passing &lookahead_yylloc to core_yylex(), but that
     * does not work because flex actually holds onto the last-passed pointer
     * internally, and will use that for error reporting.  We need any error
     * reports to point to the current token, not the next one.
     */
    cur_yylloc = *llocp;
 
    /* Get next token, saving outputs into lookahead variables */
    next_token = core_yylex(&(yyextra->lookahead_yylval), llocp, yyscanner);
    yyextra->lookahead_token = next_token;
    yyextra->lookahead_yylloc = *llocp;
 
    *llocp = cur_yylloc;
 
    /* Now revert the un-truncation of the current token */
    yyextra->lookahead_hold_char = *(yyextra->lookahead_end);
    *(yyextra->lookahead_end) = '\0';
 
    yyextra->have_lookahead = true;
 
    /* Replace cur_token if needed, based on lookahead */
    switch (cur_token)
    {
        case FORMAT:
            /* Replace FORMAT by FORMAT_LA if it's followed by JSON */
            switch (next_token)
            {
                case JSON:
                    cur_token = FORMAT_LA;
                    break;
            }
            break;
 
        case NOT:
            /* Replace NOT by NOT_LA if it's followed by BETWEEN, IN, etc */
            switch (next_token)
            {
                case BETWEEN:
                case IN_P:
                case LIKE:
                case ILIKE:
                case SIMILAR:
                    cur_token = NOT_LA;
                    break;
            }
            break;
 
        case NULLS_P:
            /* Replace NULLS_P by NULLS_LA if it's followed by FIRST or LAST */
            switch (next_token)
            {
                case FIRST_P:
                case LAST_P:
                    cur_token = NULLS_LA;
                    break;
            }
            break;
 
        case WITH:
            /* Replace WITH by WITH_LA if it's followed by TIME or ORDINALITY */
            switch (next_token)
            {
                case TIME:
                case ORDINALITY:
                    cur_token = WITH_LA;
                    break;
            }
            break;
 
        case WITHOUT:
            /* Replace WITHOUT by WITHOUT_LA if it's followed by TIME */
            switch (next_token)
            {
                case TIME:
                    cur_token = WITHOUT_LA;
                    break;
            }
            break;
 
        case UIDENT:
        case USCONST:
            /* Look ahead for UESCAPE */
            if (next_token == UESCAPE)
            {
                /* Yup, so get third token, which had better be SCONST */
                const char *escstr;
 
                /* Again save and restore *llocp */
                cur_yylloc = *llocp;
 
                /* Un-truncate current token so errors point to third token */
                *(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
 
                /* Get third token */
                next_token = core_yylex(&(yyextra->lookahead_yylval),
                                        llocp, yyscanner);
 
                /* If we throw error here, it will point to third token */
                if (next_token != SCONST)
                    scanner_yyerror("UESCAPE must be followed by a simple string literal",
                                    yyscanner);
 
                escstr = yyextra->lookahead_yylval.str;
                if (strlen(escstr) != 1 || !check_uescapechar(escstr[0]))
                    scanner_yyerror("invalid Unicode escape character",
                                    yyscanner);
 
                /* Now restore *llocp; errors will point to first token */
                *llocp = cur_yylloc;
 
                /* Apply Unicode conversion */
                lvalp->core_yystype.str =
                    str_udeescape(lvalp->core_yystype.str,
                                  escstr[0],
                                  *llocp,
                                  yyscanner);
 
                /*
                 * We don't need to revert the un-truncation of UESCAPE.  What
                 * we do want to do is clear have_lookahead, thereby consuming
                 * all three tokens.
                 */
                yyextra->have_lookahead = false;
            }
            else
            {
                /* No UESCAPE, so convert using default escape character */
                lvalp->core_yystype.str =
                    str_udeescape(lvalp->core_yystype.str,
                                  '\\',
                                  *llocp,
                                  yyscanner);
            }
 
            if (cur_token == UIDENT)
            {
                /* It's an identifier, so truncate as appropriate */
                truncate_identifier(lvalp->core_yystype.str,
                                    strlen(lvalp->core_yystype.str),
                                    true);
                cur_token = IDENT;
            }
            else if (cur_token == USCONST)
            {
                cur_token = SCONST;
            }
            break;
    }
 
    return cur_token;
}

References Assert, check_uescapechar(), core_yylex(), fb(), next_token(), pg_yyget_extra, scanner_yyerror(), str_udeescape(), truncate_identifier(), and yyextra.

base_yyparse()

int base_yyparse ( core_yyscan_t  yyscanner )

extern

parser_init()

void parser_init ( base_yy_extra_type *  yyext )

extern