#include "postgres_fe.h"
#include "extern.h"
#include "preproc.h"

Include dependency graph for parser.c:

Functions
int	filtered_base_yylex (void)

Variables
static bool	have_lookahead

static int	lookahead_token

static YYSTYPE	lookahead_yylval

static YYLTYPE	lookahead_yylloc

static char *	lookahead_yytext

static char *	lookahead_end

static char	lookahead_hold_char

Function Documentation

int filtered_base_yylex ( void )

Definition at line 48 of file parser.c.

References Assert, base_yylex(), base_yytext, have_lookahead, lookahead_end, lookahead_hold_char, lookahead_token, lookahead_yylloc, lookahead_yylval, lookahead_yytext, next_token(), and YYLTYPE.

 {
     int         cur_token;
     int         next_token;
     int         cur_token_length;
     YYSTYPE     cur_yylval;
     YYLTYPE     cur_yylloc;
     char       *cur_yytext;
 
     /* Get next token --- we might already have it */
     if (have_lookahead)
     {
         cur_token = lookahead_token;
         base_yylval = lookahead_yylval;
         base_yylloc = lookahead_yylloc;
         base_yytext = lookahead_yytext;
         *lookahead_end = lookahead_hold_char;
         have_lookahead = false;
     }
     else
         cur_token = base_yylex();
 
     /*
      * 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.)
      */
     switch (cur_token)
     {
         case NOT:
             cur_token_length = 3;
             break;
         case NULLS_P:
             cur_token_length = 5;
             break;
         case WITH:
             cur_token_length = 4;
             break;
         default:
             return cur_token;
     }
 
     /*
      * Identify end+1 of current token.  base_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.
      */
     lookahead_end = base_yytext + cur_token_length;
     Assert(*lookahead_end == '\0');
 
     /* Save and restore lexer output variables around the call */
     cur_yylval = base_yylval;
     cur_yylloc = base_yylloc;
     cur_yytext = base_yytext;
 
     /* Get next token, saving outputs into lookahead variables */
     next_token = base_yylex();
 
     lookahead_token = next_token;
     lookahead_yylval = base_yylval;
     lookahead_yylloc = base_yylloc;
     lookahead_yytext = base_yytext;
 
     base_yylval = cur_yylval;
     base_yylloc = cur_yylloc;
     base_yytext = cur_yytext;
 
     /* Now revert the un-truncation of the current token */
     lookahead_hold_char = *lookahead_end;
     *lookahead_end = '\0';
 
     have_lookahead = true;
 
     /* Replace cur_token if needed, based on lookahead */
     switch (cur_token)
     {
         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;
     }
 
     return cur_token;
 }