#include "postgres_fe.h"
#include "preproc_extern.h"
#include "preproc.h"

Include dependency graph for parser.c:

Functions
static bool	check_uescapechar (unsigned char escape)

static bool	ecpg_isspace (char ch)

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

Function Documentation

◆ check_uescapechar()

static bool check_uescapechar ( unsigned char escape )

static

Definition at line 228 of file parser.c.

 {
     if (isxdigit(escape)
         || escape == '+'
         || escape == '\''
         || escape == '"'
         || ecpg_isspace(escape))
         return false;
     else
         return true;
 }

References ecpg_isspace().

Referenced by filtered_base_yylex().

◆ ecpg_isspace()

static bool ecpg_isspace ( char ch )

static

Definition at line 244 of file parser.c.

 {
     if (ch == ' ' ||
         ch == '\t' ||
         ch == '\n' ||
         ch == '\r' ||
         ch == '\f')
         return true;
     return false;
 }

Referenced by check_uescapechar().

◆ filtered_base_yylex()

int filtered_base_yylex ( void )

Definition at line 56 of file parser.c.

 {
     int         cur_token;
     int         next_token;
     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;
         have_lookahead = false;
     }
     else
         cur_token = base_yylex();
  
     /*
      * If this token isn't one that requires lookahead, just return it.
      */
     switch (cur_token)
     {
         case FORMAT:
         case NOT:
         case NULLS_P:
         case WITH:
         case WITHOUT:
         case UIDENT:
         case USCONST:
             break;
         default:
             return cur_token;
     }
  
     /* 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;
  
     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 lexer output variables around the
                  * call
                  */
                 cur_yylval = base_yylval;
                 cur_yylloc = base_yylloc;
                 cur_yytext = base_yytext;
  
                 /* Get third token */
                 next_token = base_yylex();
  
                 if (next_token != SCONST)
                     mmerror(PARSE_ERROR, ET_ERROR, "UESCAPE must be followed by a simple string literal");
  
                 /*
                  * Save and check escape string, which the scanner returns
                  * with quotes
                  */
                 escstr = base_yylval.str;
                 if (strlen(escstr) != 3 || !check_uescapechar(escstr[1]))
                     mmerror(PARSE_ERROR, ET_ERROR, "invalid Unicode escape character");
  
                 base_yylval = cur_yylval;
                 base_yylloc = cur_yylloc;
                 base_yytext = cur_yytext;
  
                 /* Combine 3 tokens into 1 */
                 base_yylval.str = psprintf("%s UESCAPE %s", base_yylval.str, escstr);
  
                 /* Clear have_lookahead, thereby consuming all three tokens */
                 have_lookahead = false;
             }
  
             if (cur_token == UIDENT)
                 cur_token = IDENT;
             else if (cur_token == USCONST)
                 cur_token = SCONST;
             break;
     }
  
     return cur_token;
 }