#include "postgres.h"
#include "mb/pg_wchar.h"
#include "parser/scanner.h"
#include "plpgsql.h"
#include "pl_gram.h"
#include "pl_reserved_kwlist_d.h"
#include "pl_unreserved_kwlist_d.h"
#include "pl_reserved_kwlist.h"
#include "pl_unreserved_kwlist.h"

Include dependency graph for pl_scanner.c:

Data Structures
struct	TokenAuxData

Macros
#define	PG_KEYWORD(kwname, value) value,

#define	AT_STMT_START(prev_token)

#define	MAX_PUSHBACKS 4

Functions
static int	internal_yylex (TokenAuxData *auxdata)

static void	push_back_token (int token, TokenAuxData *auxdata)

static void	location_lineno_init (void)

int	plpgsql_yylex (void)

void	plpgsql_push_back_token (int token)

bool	plpgsql_token_is_unreserved_keyword (int token)

void	plpgsql_append_source_text (StringInfo buf, int startlocation, int endlocation)

int	plpgsql_peek (void)

void	plpgsql_peek2 (int tok1_p, int tok2_p, int tok1_loc, int tok2_loc)

int	plpgsql_scanner_errposition (int location)

void	plpgsql_yyerror (const char *message)

int	plpgsql_location_to_lineno (int location)

int	plpgsql_latest_lineno (void)

void	plpgsql_scanner_init (const char *str)

void	plpgsql_scanner_finish (void)

Variables
IdentifierLookup	plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL

static const uint16	ReservedPLKeywordTokens []

static const uint16	UnreservedPLKeywordTokens []

static core_yyscan_t	yyscanner = NULL

static core_yy_extra_type	core_yy

static const char *	scanorig

static int	plpgsql_yyleng

static int	plpgsql_yytoken

static int	num_pushbacks

static int	pushback_token [MAX_PUSHBACKS]

static TokenAuxData	pushback_auxdata [MAX_PUSHBACKS]

static const char *	cur_line_start

static const char *	cur_line_end

static int	cur_line_num

Macro Definition Documentation

◆ AT_STMT_START

#define AT_STMT_START ( prev_token )

Value:

    ((prev_token) == ';' || \
     (prev_token) == K_BEGIN || \
     (prev_token) == K_THEN || \
     (prev_token) == K_ELSE || \
     (prev_token) == K_LOOP)

Definition at line 82 of file pl_scanner.c.

◆ MAX_PUSHBACKS

#define MAX_PUSHBACKS 4

Definition at line 119 of file pl_scanner.c.

◆ PG_KEYWORD

#define PG_KEYWORD	(	kwname,
		value
	)	value,

Definition at line 64 of file pl_scanner.c.

Function Documentation

◆ internal_yylex()

static int internal_yylex ( TokenAuxData * auxdata )

static

Definition at line 308 of file pl_scanner.c.

 {
     int         token;
     const char *yytext;
  
     if (num_pushbacks > 0)
     {
         num_pushbacks--;
         token = pushback_token[num_pushbacks];
         *auxdata = pushback_auxdata[num_pushbacks];
     }
     else
     {
         token = core_yylex(&auxdata->lval.core_yystype,
                            &auxdata->lloc,
                            yyscanner);
  
         /* remember the length of yytext before it gets changed */
         yytext = core_yy.scanbuf + auxdata->lloc;
         auxdata->leng = strlen(yytext);
  
         /* Check for << >> and #, which the core considers operators */
         if (token == Op)
         {
             if (strcmp(auxdata->lval.str, "<<") == 0)
                 token = LESS_LESS;
             else if (strcmp(auxdata->lval.str, ">>") == 0)
                 token = GREATER_GREATER;
             else if (strcmp(auxdata->lval.str, "#") == 0)
                 token = '#';
         }
  
         /* The core returns PARAM as ival, but we treat it like IDENT */
         else if (token == PARAM)
         {
             auxdata->lval.str = pstrdup(yytext);
         }
     }
  
     return token;
 }

References core_yy, core_yylex(), TokenAuxData::leng, TokenAuxData::lloc, TokenAuxData::lval, num_pushbacks, pstrdup(), pushback_auxdata, pushback_token, core_yy_extra_type::scanbuf, token, and yyscanner.

Referenced by plpgsql_peek(), plpgsql_peek2(), and plpgsql_yylex().

◆ location_lineno_init()

static void location_lineno_init ( void )

static

Definition at line 562 of file pl_scanner.c.

 {
     cur_line_start = scanorig;
     cur_line_num = 1;
  
     cur_line_end = strchr(cur_line_start, '\n');
 }

References cur_line_end, cur_line_num, cur_line_start, and scanorig.

Referenced by plpgsql_location_to_lineno(), and plpgsql_scanner_init().

◆ plpgsql_append_source_text()

void plpgsql_append_source_text	(	StringInfo	buf,
		int	startlocation,
		int	endlocation
	)

Definition at line 404 of file pl_scanner.c.

 {
     Assert(startlocation <= endlocation);
     appendBinaryStringInfo(buf, scanorig + startlocation,
                            endlocation - startlocation);
 }

References appendBinaryStringInfo(), Assert(), buf, and scanorig.

◆ plpgsql_latest_lineno()

int plpgsql_latest_lineno ( void )

Definition at line 572 of file pl_scanner.c.

 {
     return cur_line_num;
 }

References cur_line_num.

Referenced by plpgsql_compile_error_callback().

◆ plpgsql_location_to_lineno()

int plpgsql_location_to_lineno ( int location )

Definition at line 538 of file pl_scanner.c.

 {
     const char *loc;
  
     if (location < 0 || scanorig == NULL)
         return 0;               /* garbage in, garbage out */
     loc = scanorig + location;
  
     /* be correct, but not fast, if input location goes backwards */
     if (loc < cur_line_start)
         location_lineno_init();
  
     while (cur_line_end != NULL && loc > cur_line_end)
     {
         cur_line_start = cur_line_end + 1;
         cur_line_num++;
         cur_line_end = strchr(cur_line_start, '\n');
     }
  
     return cur_line_num;
 }

References cur_line_end, cur_line_num, cur_line_start, location_lineno_init(), and scanorig.

◆ plpgsql_peek()

int plpgsql_peek ( void )

Definition at line 420 of file pl_scanner.c.

 {
     int         tok1;
     TokenAuxData aux1;
  
     tok1 = internal_yylex(&aux1);
     push_back_token(tok1, &aux1);
     return tok1;
 }

References internal_yylex(), and push_back_token().

◆ plpgsql_peek2()

void plpgsql_peek2	(	int *	tok1_p,
		int *	tok2_p,
		int *	tok1_loc,
		int *	tok2_loc
	)

Definition at line 439 of file pl_scanner.c.

 {
     int         tok1,
                 tok2;
     TokenAuxData aux1,
                 aux2;
  
     tok1 = internal_yylex(&aux1);
     tok2 = internal_yylex(&aux2);
  
     *tok1_p = tok1;
     if (tok1_loc)
         *tok1_loc = aux1.lloc;
     *tok2_p = tok2;
     if (tok2_loc)
         *tok2_loc = aux2.lloc;
  
     push_back_token(tok2, &aux2);
     push_back_token(tok1, &aux1);
 }

References internal_yylex(), TokenAuxData::lloc, and push_back_token().

◆ plpgsql_push_back_token()

void plpgsql_push_back_token ( int token )

Definition at line 370 of file pl_scanner.c.

 {
     TokenAuxData auxdata;
  
     auxdata.lval = plpgsql_yylval;
     auxdata.lloc = plpgsql_yylloc;
     auxdata.leng = plpgsql_yyleng;
     push_back_token(token, &auxdata);
 }

References TokenAuxData::leng, TokenAuxData::lloc, TokenAuxData::lval, plpgsql_yyleng, push_back_token(), and token.

◆ plpgsql_scanner_errposition()

int plpgsql_scanner_errposition ( int location )

Definition at line 472 of file pl_scanner.c.

 {
     int         pos;
  
     if (location < 0 || scanorig == NULL)
         return 0;               /* no-op if location is unknown */
  
     /* Convert byte offset to character number */
     pos = pg_mbstrlen_with_len(scanorig, location) + 1;
     /* And pass it to the ereport mechanism */
     (void) internalerrposition(pos);
     /* Also pass the function body string */
     return internalerrquery(scanorig);
 }

References internalerrposition(), internalerrquery(), pg_mbstrlen_with_len(), and scanorig.

Referenced by plpgsql_yyerror().

◆ plpgsql_scanner_finish()

void plpgsql_scanner_finish ( void )

Definition at line 613 of file pl_scanner.c.

 {
     /* release storage */
     scanner_finish(yyscanner);
     /* avoid leaving any dangling pointers */
     yyscanner = NULL;
     scanorig = NULL;
 }

References scanner_finish(), scanorig, and yyscanner.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_scanner_init()

void plpgsql_scanner_init ( const char * str )

Definition at line 586 of file pl_scanner.c.

 {
     /* Start up the core scanner */
     yyscanner = scanner_init(str, &core_yy,
                              &ReservedPLKeywords, ReservedPLKeywordTokens);
  
     /*
      * scanorig points to the original string, which unlike the scanner's
      * scanbuf won't be modified on-the-fly by flex.  Notice that although
      * yytext points into scanbuf, we rely on being able to apply locations
      * (offsets from string start) to scanorig as well.
      */
     scanorig = str;
  
     /* Other setup */
     plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL;
     plpgsql_yytoken = 0;
  
     num_pushbacks = 0;
  
     location_lineno_init();
 }

References core_yy, IDENTIFIER_LOOKUP_NORMAL, location_lineno_init(), num_pushbacks, plpgsql_IdentifierLookup, plpgsql_yytoken, ReservedPLKeywordTokens, scanner_init(), scanorig, generate_unaccent_rules::str, and yyscanner.

Referenced by do_compile(), and plpgsql_compile_inline().

◆ plpgsql_token_is_unreserved_keyword()

bool plpgsql_token_is_unreserved_keyword ( int token )

Definition at line 387 of file pl_scanner.c.

 {
     int         i;
  
     for (i = 0; i < lengthof(UnreservedPLKeywordTokens); i++)
     {
         if (UnreservedPLKeywordTokens[i] == token)
             return true;
     }
     return false;
 }

References i, lengthof, token, and UnreservedPLKeywordTokens.

◆ plpgsql_yyerror()

void plpgsql_yyerror ( const char * message )

Definition at line 499 of file pl_scanner.c.

 {
     char       *yytext = core_yy.scanbuf + plpgsql_yylloc;
  
     if (*yytext == '\0')
     {
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
         /* translator: %s is typically the translation of "syntax error" */
                  errmsg("%s at end of input", _(message)),
                  plpgsql_scanner_errposition(plpgsql_yylloc)));
     }
     else
     {
         /*
          * If we have done any lookahead then flex will have restored the
          * character after the end-of-token.  Zap it again so that we report
          * only the single token here.  This modifies scanbuf but we no longer
          * care about that.
          */
         yytext[plpgsql_yyleng] = '\0';
  
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
         /* translator: first %s is typically the translation of "syntax error" */
                  errmsg("%s at or near \"%s\"", _(message), yytext),
                  plpgsql_scanner_errposition(plpgsql_yylloc)));
     }
 }

References _, core_yy, ereport, errcode(), errmsg(), ERROR, plpgsql_scanner_errposition(), plpgsql_yyleng, and core_yy_extra_type::scanbuf.

◆ plpgsql_yylex()

int plpgsql_yylex ( void )

Definition at line 146 of file pl_scanner.c.

 {
     int         tok1;
     TokenAuxData aux1;
     int         kwnum;
  
     tok1 = internal_yylex(&aux1);
     if (tok1 == IDENT || tok1 == PARAM)
     {
         int         tok2;
         TokenAuxData aux2;
  
         tok2 = internal_yylex(&aux2);
         if (tok2 == '.')
         {
             int         tok3;
             TokenAuxData aux3;
  
             tok3 = internal_yylex(&aux3);
             if (tok3 == IDENT)
             {
                 int         tok4;
                 TokenAuxData aux4;
  
                 tok4 = internal_yylex(&aux4);
                 if (tok4 == '.')
                 {
                     int         tok5;
                     TokenAuxData aux5;
  
                     tok5 = internal_yylex(&aux5);
                     if (tok5 == IDENT)
                     {
                         if (plpgsql_parse_tripword(aux1.lval.str,
                                                    aux3.lval.str,
                                                    aux5.lval.str,
                                                    &aux1.lval.wdatum,
                                                    &aux1.lval.cword))
                             tok1 = T_DATUM;
                         else
                             tok1 = T_CWORD;
                     }
                     else
                     {
                         /* not A.B.C, so just process A.B */
                         push_back_token(tok5, &aux5);
                         push_back_token(tok4, &aux4);
                         if (plpgsql_parse_dblword(aux1.lval.str,
                                                   aux3.lval.str,
                                                   &aux1.lval.wdatum,
                                                   &aux1.lval.cword))
                             tok1 = T_DATUM;
                         else
                             tok1 = T_CWORD;
                     }
                 }
                 else
                 {
                     /* not A.B.C, so just process A.B */
                     push_back_token(tok4, &aux4);
                     if (plpgsql_parse_dblword(aux1.lval.str,
                                               aux3.lval.str,
                                               &aux1.lval.wdatum,
                                               &aux1.lval.cword))
                         tok1 = T_DATUM;
                     else
                         tok1 = T_CWORD;
                 }
             }
             else
             {
                 /* not A.B, so just process A */
                 push_back_token(tok3, &aux3);
                 push_back_token(tok2, &aux2);
                 if (plpgsql_parse_word(aux1.lval.str,
                                        core_yy.scanbuf + aux1.lloc,
                                        true,
                                        &aux1.lval.wdatum,
                                        &aux1.lval.word))
                     tok1 = T_DATUM;
                 else if (!aux1.lval.word.quoted &&
                          (kwnum = ScanKeywordLookup(aux1.lval.word.ident,
                                                     &UnreservedPLKeywords)) >= 0)
                 {
                     aux1.lval.keyword = GetScanKeyword(kwnum,
                                                        &UnreservedPLKeywords);
                     tok1 = UnreservedPLKeywordTokens[kwnum];
                 }
                 else
                     tok1 = T_WORD;
             }
         }
         else
         {
             /* not A.B, so just process A */
             push_back_token(tok2, &aux2);
  
             /*
              * See if it matches a variable name, except in the context where
              * we are at start of statement and the next token isn't
              * assignment or '['.  In that case, it couldn't validly be a
              * variable name, and skipping the lookup allows variable names to
              * be used that would conflict with plpgsql or core keywords that
              * introduce statements (e.g., "comment").  Without this special
              * logic, every statement-introducing keyword would effectively be
              * reserved in PL/pgSQL, which would be unpleasant.
              *
              * If it isn't a variable name, try to match against unreserved
              * plpgsql keywords.  If not one of those either, it's T_WORD.
              *
              * Note: we must call plpgsql_parse_word even if we don't want to
              * do variable lookup, because it sets up aux1.lval.word for the
              * non-variable cases.
              */
             if (plpgsql_parse_word(aux1.lval.str,
                                    core_yy.scanbuf + aux1.lloc,
                                    (!AT_STMT_START(plpgsql_yytoken) ||
                                     (tok2 == '=' || tok2 == COLON_EQUALS ||
                                      tok2 == '[')),
                                    &aux1.lval.wdatum,
                                    &aux1.lval.word))
                 tok1 = T_DATUM;
             else if (!aux1.lval.word.quoted &&
                      (kwnum = ScanKeywordLookup(aux1.lval.word.ident,
                                                 &UnreservedPLKeywords)) >= 0)
             {
                 aux1.lval.keyword = GetScanKeyword(kwnum,
                                                    &UnreservedPLKeywords);
                 tok1 = UnreservedPLKeywordTokens[kwnum];
             }
             else
                 tok1 = T_WORD;
         }
     }
     else
     {
         /*
          * Not a potential plpgsql variable name, just return the data.
          *
          * Note that we also come through here if the grammar pushed back a
          * T_DATUM, T_CWORD, T_WORD, or unreserved-keyword token returned by a
          * previous lookup cycle; thus, pushbacks do not incur extra lookup
          * work, since we'll never do the above code twice for the same token.
          * This property also makes it safe to rely on the old value of
          * plpgsql_yytoken in the is-this-start-of-statement test above.
          */
     }
  
     plpgsql_yylval = aux1.lval;
     plpgsql_yylloc = aux1.lloc;
     plpgsql_yyleng = aux1.leng;
     plpgsql_yytoken = tok1;
     return tok1;
 }

References AT_STMT_START, core_yy, GetScanKeyword(), internal_yylex(), TokenAuxData::leng, TokenAuxData::lloc, TokenAuxData::lval, plpgsql_parse_dblword(), plpgsql_parse_tripword(), plpgsql_parse_word(), plpgsql_yyleng, plpgsql_yytoken, push_back_token(), core_yy_extra_type::scanbuf, ScanKeywordLookup(), and UnreservedPLKeywordTokens.

◆ push_back_token()

static void push_back_token	(	int	token,
		TokenAuxData *	auxdata
	)

static

Definition at line 354 of file pl_scanner.c.

 {
     if (num_pushbacks >= MAX_PUSHBACKS)
         elog(ERROR, "too many tokens pushed back");
     pushback_token[num_pushbacks] = token;
     pushback_auxdata[num_pushbacks] = *auxdata;
     num_pushbacks++;
 }