Quelle  parser.c

/*-------------------------------------------------------------------------
 *
 * parser.c
 *  Main entry point/driver for PostgreSQL grammar
 *
 * Note that the grammar is not allowed to perform any table access
 * (since we need to be able to do basic parsing even while inside an
 * aborted transaction).  Therefore, the data structures returned by
 * the grammar are "raw" parsetrees that still need to be analyzed by
 * analyze.c and related files.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/parser/parser.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "gramparse.h"
#include "mb/pg_wchar.h"
#include "parser/parser.h"
#include "parser/scansup.h"

static bool check_uescapechar(unsigned char escape);
static char *str_udeescape(const char *str, char escape,
         int position, core_yyscan_t yyscanner);


/*
 * raw_parser
 *  Given a query in string form, do lexical and grammatical analysis.
 *
 * Returns a list of raw (un-analyzed) parse trees.  The contents of the
 * list have the form required by the specified RawParseMode.
 */
List *
raw_parser(const char *str, RawParseMode mode)
{
 core_yyscan_t yyscanner;
 base_yy_extra_type yyextra;
 int   yyresult;

 /* initialize the flex scanner */
 yyscanner = scanner_init(str, &yyextra.core_yy_extra,
        &ScanKeywords, ScanKeywordTokens);

 /* base_yylex() only needs us to initialize the lookahead token, if any */
 if (mode == RAW_PARSE_DEFAULT)
  yyextra.have_lookahead = false;
 else
 {
  /* this array is indexed by RawParseMode enum */
  static const int mode_token[] = {
   [RAW_PARSE_DEFAULT] = 0,
   [RAW_PARSE_TYPE_NAME] = MODE_TYPE_NAME,
   [RAW_PARSE_PLPGSQL_EXPR] = MODE_PLPGSQL_EXPR,
   [RAW_PARSE_PLPGSQL_ASSIGN1] = MODE_PLPGSQL_ASSIGN1,
   [RAW_PARSE_PLPGSQL_ASSIGN2] = MODE_PLPGSQL_ASSIGN2,
   [RAW_PARSE_PLPGSQL_ASSIGN3] = MODE_PLPGSQL_ASSIGN3,
  };

  yyextra.have_lookahead = true;
  yyextra.lookahead_token = mode_token[mode];
  yyextra.lookahead_yylloc = 0;
  yyextra.lookahead_end = NULL;
 }

 /* initialize the bison parser */
 parser_init(&yyextra);

 /* Parse! */
 yyresult = base_yyparse(yyscanner);

 /* Clean up (release memory) */
 scanner_finish(yyscanner);

 if (yyresult)    /* error */
  return NIL;

 return yyextra.parsetree;
}


/*
 * Intermediate filter between parser and core lexer (core_yylex in scan.l).
 *
 * This filter is needed because in some cases the standard SQL grammar
 * requires more than one token lookahead.  We reduce these cases to one-token
 * lookahead by replacing tokens here, in order to keep the grammar LALR(1).
 *
 * Using a filter is simpler than trying to recognize multiword tokens
 * directly in scan.l, because we'd have to allow for comments between the
 * words.  Furthermore it's not clear how to do that without re-introducing
 * scanner backtrack, which would cost more performance than this filter
 * layer does.
 *
 * We also use this filter to convert UIDENT and USCONST sequences into
 * plain IDENT and SCONST tokens.  While that could be handled by additional
 * productions in the main grammar, it's more efficient to do it like this.
 *
 * The filter also provides a convenient place to translate between
 * the core_YYSTYPE and YYSTYPE representations (which are really the
 * same thing anyway, but notationally they're different).
 */
int
base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
{
 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;
}

/* convert hex digit (caller should have verified that) to value */
static unsigned int
hexval(unsigned char c)
{
 if (c >= '0' && c <= '9')
  return c - '0';
 if (c >= 'a' && c <= 'f')
  return c - 'a' + 0xA;
 if (c >= 'A' && c <= 'F')
  return c - 'A' + 0xA;
 elog(ERROR, "invalid hexadecimal digit");
 return 0;     /* not reached */
}

/* is Unicode code point acceptable? */
static void
check_unicode_value(pg_wchar c)
{
 if (!is_valid_unicode_codepoint(c))
  ereport(ERROR,
    (errcode(ERRCODE_SYNTAX_ERROR),
     errmsg("invalid Unicode escape value")));
}

/* is 'escape' acceptable as Unicode escape character (UESCAPE syntax) ? */
static bool
check_uescapechar(unsigned char escape)
{
 if (isxdigit(escape)
  || escape == '+'
  || escape == '\''
  || escape == '"'
  || scanner_isspace(escape))
  return false;
 else
  return true;
}

/*
 * Process Unicode escapes in "str", producing a palloc'd plain string
 *
 * escape: the escape character to use
 * position: start position of U&'' or U&"" string token
 * yyscanner: context information needed for error reports
 */
static char *
str_udeescape(const char *str, char escape,
     int position, core_yyscan_t yyscanner)
{
 const char *in;
 char    *new,
      *out;
 size_t  new_len;
 pg_wchar pair_first = 0;
 ScannerCallbackState scbstate;

 /*
  * Guesstimate that result will be no longer than input, but allow enough
  * padding for Unicode conversion.
 */
 new_len = strlen(str) + MAX_UNICODE_EQUIVALENT_STRING + 1;
 new = palloc(new_len);

 in = str;
 out = new;
 while (*in)
 {
  /* Enlarge string if needed */
  size_t  out_dist = out - new;

  if (out_dist > new_len - (MAX_UNICODE_EQUIVALENT_STRING + 1))
  {
   new_len *= 2;
   new = repalloc(new, new_len);
   out = new + out_dist;
  }

  if (in[0] == escape)
  {
   /*
    * Any errors reported while processing this escape sequence will
    * have an error cursor pointing at the escape.
 */
   setup_scanner_errposition_callback(&scbstate, yyscanner,
              in - str + position + 3); /* 3 for U&" */
   if (in[1] == escape)
   {
    if (pair_first)
     goto invalid_pair;
    *out++ = escape;
    in += 2;
   }
   else if (isxdigit((unsigned char) in[1]) &&
      isxdigit((unsigned char) in[2]) &&
      isxdigit((unsigned char) in[3]) &&
      isxdigit((unsigned char) in[4]))
   {
    pg_wchar unicode;

    unicode = (hexval(in[1]) << 12) +
     (hexval(in[2]) << 8) +
     (hexval(in[3]) << 4) +
     hexval(in[4]);
    check_unicode_value(unicode);
    if (pair_first)
    {
     if (is_utf16_surrogate_second(unicode))
     {
      unicode = surrogate_pair_to_codepoint(pair_first, unicode);
      pair_first = 0;
     }
     else
      goto invalid_pair;
    }
    else if (is_utf16_surrogate_second(unicode))
     goto invalid_pair;

    if (is_utf16_surrogate_first(unicode))
     pair_first = unicode;
    else
    {
     pg_unicode_to_server(unicode, (unsigned char *) out);
     out += strlen(out);
    }
    in += 5;
   }
   else if (in[1] == '+' &&
      isxdigit((unsigned char) in[2]) &&
      isxdigit((unsigned char) in[3]) &&
      isxdigit((unsigned char) in[4]) &&
      isxdigit((unsigned char) in[5]) &&
      isxdigit((unsigned char) in[6]) &&
      isxdigit((unsigned char) in[7]))
   {
    pg_wchar unicode;

    unicode = (hexval(in[2]) << 20) +
     (hexval(in[3]) << 16) +
     (hexval(in[4]) << 12) +
     (hexval(in[5]) << 8) +
     (hexval(in[6]) << 4) +
     hexval(in[7]);
    check_unicode_value(unicode);
    if (pair_first)
    {
     if (is_utf16_surrogate_second(unicode))
     {
      unicode = surrogate_pair_to_codepoint(pair_first, unicode);
      pair_first = 0;
     }
     else
      goto invalid_pair;
    }
    else if (is_utf16_surrogate_second(unicode))
     goto invalid_pair;

    if (is_utf16_surrogate_first(unicode))
     pair_first = unicode;
    else
    {
     pg_unicode_to_server(unicode, (unsigned char *) out);
     out += strlen(out);
    }
    in += 8;
   }
   else
    ereport(ERROR,
      (errcode(ERRCODE_SYNTAX_ERROR),
       errmsg("invalid Unicode escape"),
       errhint("Unicode escapes must be \\XXXX or \\+XXXXXX.")));

   cancel_scanner_errposition_callback(&scbstate);
  }
  else
  {
   if (pair_first)
    goto invalid_pair;

   *out++ = *in++;
  }
 }

 /* unfinished surrogate pair? */
 if (pair_first)
  goto invalid_pair;

 *out = '\0';
 return new;

 /*
  * We might get here with the error callback active, or not.  Call
  * scanner_errposition to make sure an error cursor appears; if the
  * callback is active, this is duplicative but harmless.
 */
invalid_pair:
 ereport(ERROR,
   (errcode(ERRCODE_SYNTAX_ERROR),
    errmsg("invalid Unicode surrogate pair"),
    scanner_errposition(in - str + position + 3, /* 3 for U&" */
         yyscanner)));
 return NULL;    /* keep compiler quiet */
}