syncrep_scanner.l

Go to the documentation of this file.

%top{
/*-------------------------------------------------------------------------
 *
 * syncrep_scanner.l
 *    a lexical scanner for synchronous_standby_names
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/replication/syncrep_scanner.l
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include "lib/stringinfo.h"
#include "nodes/pg_list.h"
 
/*
 * NB: include syncrep_gram.h only AFTER including syncrep.h, because syncrep.h
 * includes node definitions needed for YYSTYPE.
 */
#include "replication/syncrep.h"
#include "syncrep_gram.h"
}
 
%{
/* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
#undef fprintf
#define fprintf(file, fmt, msg)  fprintf_to_ereport(fmt, msg)
 
static void
fprintf_to_ereport(const char *fmt, const char *msg)
{
    ereport(ERROR, (errmsg_internal("%s", msg)));
}
 
struct syncrep_yy_extra_type
{
    StringInfoData xdbuf;
};
 
/*
 * Better keep this definition here than put it in replication/syncrep.h and
 * save a bit of duplication.  Putting it in replication/syncrep.h would leak
 * the definition to other parts and possibly affect other scanners.
*/
#define YY_DECL extern int  syncrep_yylex(union YYSTYPE *yylval_param, char **syncrep_parse_error_msg_p, yyscan_t yyscanner)
 
/* LCOV_EXCL_START */
 
%}
 
%option reentrant
%option bison-bridge
%option 8bit
%option never-interactive
%option nodefault
%option noinput
%option nounput
%option noyywrap
%option noyyalloc
%option noyyrealloc
%option noyyfree
%option warn
%option prefix="syncrep_yy"
%option extra-type="struct syncrep_yy_extra_type *"
 
/*
 * <xd> delimited identifiers (double-quoted identifiers)
 */
%x xd
 
space           [ \t\n\r\f\v]
 
digit           [0-9]
ident_start     [A-Za-z\200-\377_]
ident_cont      [A-Za-z\200-\377_0-9\$]
identifier      {ident_start}{ident_cont}*
 
dquote          \"
xdstart         {dquote}
xdstop          {dquote}
xddouble        {dquote}{dquote}
xdinside        [^"]+
 
%%
{space}+    { /* ignore */ }
 
    /* brute-force case insensitivity is safer than relying on flex -i */
 
[Aa][Nn][Yy]            { return ANY; }
[Ff][Ii][Rr][Ss][Tt]    { return FIRST; }
 
{xdstart}   {
                initStringInfo(&yyextra->xdbuf);
                BEGIN(xd);
        }
<xd>{xddouble} {
                appendStringInfoChar(&yyextra->xdbuf, '"');
        }
<xd>{xdinside} {
                appendStringInfoString(&yyextra->xdbuf, yytext);
        }
<xd>{xdstop} {
                yylval->str = yyextra->xdbuf.data;
                yyextra->xdbuf.data = NULL;
                BEGIN(INITIAL);
                return NAME;
        }
<xd><<EOF>> {
                syncrep_yyerror(NULL, syncrep_parse_error_msg_p, yyscanner, "unterminated quoted identifier");
                return JUNK;
        }
 
{identifier} {
                yylval->str = pstrdup(yytext);
                return NAME;
        }
 
{digit}+    {
                yylval->str = pstrdup(yytext);
                return NUM;
        }
 
"*"     {
                yylval->str = "*";
                return NAME;
        }
 
","         { return ','; }
"("         { return '('; }
")"         { return ')'; }
 
.           { return JUNK; }
%%
 
/* LCOV_EXCL_STOP */
 
/* see scan.l */
#undef yyextra
#define yyextra (((struct yyguts_t *) yyscanner)->yyextra_r)
 
/*
 * This yyerror() function does not raise an error (elog or similar), it just
 * collects the error message in *syncrep_parse_error_msg_p and leaves it to
 * the ultimate caller of the syncrep parser to raise the error.  (The
 * ultimate caller will do that with special GUC error functions.)
 *
 * (The first argument is enforced by Bison to match the first argument of
 * yyparse(), but it is not used here.)
 */
void
syncrep_yyerror(SyncRepConfigData **syncrep_parse_result_p, char **syncrep_parse_error_msg_p, yyscan_t yyscanner, const char *message)
{
    struct yyguts_t *yyg = (struct yyguts_t *) yyscanner;   /* needed for yytext
                                                             * macro */
 
    /* report only the first error in a parse operation */
    if (*syncrep_parse_error_msg_p)
        return;
    if (yytext[0])
        *syncrep_parse_error_msg_p = psprintf("%s at or near \"%s\"",
                                              message, yytext);
    else
        *syncrep_parse_error_msg_p = psprintf("%s at end of input",
                                              message);
}
 
void
syncrep_scanner_init(const char *str, yyscan_t *yyscannerp)
{
    yyscan_t    yyscanner;
    struct syncrep_yy_extra_type *yyext = palloc0_object(struct syncrep_yy_extra_type);
 
    if (yylex_init(yyscannerp) != 0)
        elog(ERROR, "yylex_init() failed: %m");
 
    yyscanner = *yyscannerp;
 
    yyset_extra(yyext, yyscanner);
 
    yy_scan_string(str, yyscanner);
}
 
void
syncrep_scanner_finish(yyscan_t yyscanner)
{
    pfree(yyextra);
    yylex_destroy(yyscanner);
}
 
/*
 * Interface functions to make flex use palloc() instead of malloc().
 * It'd be better to make these static, but flex insists otherwise.
 */
 
void *
yyalloc(yy_size_t size, yyscan_t yyscanner)
{
    return palloc(size);
}
 
void *
yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
{
    if (ptr)
        return repalloc(ptr, size);
    else
        return palloc(size);
}
 
void
yyfree(void *ptr, yyscan_t yyscanner)
{
    if (ptr)
        pfree(ptr);
}