repl_scanner.l File Reference

#include "postgres.h"
#include "nodes/parsenodes.h"
#include "utils/builtins.h"
#include "parser/scansup.h"
#include "replication/walsender_private.h"
#include "repl_gram.h"

Include dependency graph for repl_scanner.l:

Go to the source code of this file.

Data Structures
struct	replication_yy_extra_type

Macros
#define	fprintf(file, fmt, msg)   fprintf_to_ereport(fmt, msg)

Functions
static void	fprintf_to_ereport (const char *fmt, const char *msg)
static void	startlit (yyscan_t yyscanner)
static char *	litbufdup (yyscan_t yyscanner)
static void	addlit (char *ytext, int yleng, yyscan_t yyscanner)
static void	addlitchar (unsigned char ychar, yyscan_t yyscanner)
int	yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
void	replication_yyerror (Node **replication_parse_result_p, yyscan_t yyscanner, const char *message)
void	replication_scanner_init (const char *str, yyscan_t *yyscannerp)
void	replication_scanner_finish (yyscan_t yyscanner)
bool	replication_scanner_is_replication_command (yyscan_t yyscanner)
void *	yyalloc (yy_size_t size, yyscan_t yyscanner)
void *	yyrealloc (void *ptr, yy_size_t size, yyscan_t yyscanner)
void	yyfree (void *ptr, yyscan_t yyscanner)

Macro Definition Documentation

fprintf

#define fprintf	(		file,
			fmt,
			msg
	)		fprintf_to_ereport(fmt, msg)

Definition at line 33 of file repl_scanner.l.

Function Documentation

addlit()

static void addlit ( char *  ytext, int  yleng, yyscan_t  yyscanner  )

static

Definition at line 244 of file repl_scanner.l.

{
    appendBinaryStringInfo(&yyextra->litbuf, ytext, yleng);
}

References appendBinaryStringInfo(), and yyextra.

addlitchar()

static void addlitchar ( unsigned char  ychar, yyscan_t  yyscanner  )

static

Definition at line 250 of file repl_scanner.l.

{
    appendStringInfoChar(&yyextra->litbuf, ychar);
}

References appendStringInfoChar(), and yyextra.

fprintf_to_ereport()

static void fprintf_to_ereport ( const char *  fmt, const char *  msg  )

static

Definition at line 36 of file repl_scanner.l.

{
    ereport(ERROR, (errmsg_internal("%s", msg)));
}

References ereport, errmsg_internal(), and ERROR.

litbufdup()

static char * litbufdup ( yyscan_t  yyscanner )

static

Definition at line 238 of file repl_scanner.l.

{
    return yyextra->litbuf.data;
}

References yyextra.

replication_scanner_finish()

void replication_scanner_finish

(

yyscan_t

yyscanner

)

Definition at line 284 of file repl_scanner.l.

{
    pfree(yyextra);
    yylex_destroy(yyscanner);
}

References pfree(), and yyextra.

Referenced by exec_replication_command().

replication_scanner_init()

void replication_scanner_init	(	const char *	str,
		yyscan_t *	yyscannerp
	)

Definition at line 268 of file repl_scanner.l.

{
    yyscan_t    yyscanner;
    struct replication_yy_extra_type *yyext = palloc0_object(struct replication_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);
}

References elog, ERROR, palloc0_object, and str.

Referenced by exec_replication_command().

replication_scanner_is_replication_command()

bool replication_scanner_is_replication_command

(

yyscan_t

yyscanner

)

Definition at line 299 of file repl_scanner.l.

{
    YYSTYPE     dummy;
    int         first_token = replication_yylex(&dummy, yyscanner);
 
    switch (first_token)
    {
        case K_IDENTIFY_SYSTEM:
        case K_BASE_BACKUP:
        case K_START_REPLICATION:
        case K_CREATE_REPLICATION_SLOT:
        case K_DROP_REPLICATION_SLOT:
        case K_ALTER_REPLICATION_SLOT:
        case K_READ_REPLICATION_SLOT:
        case K_TIMELINE_HISTORY:
        case K_UPLOAD_MANIFEST:
        case K_SHOW:
            /* Yes; push back the first token so we can parse later. */
            yyextra->repl_pushed_back_token = first_token;
            return true;
        default:
            /* Nope; we don't bother to push back the token. */
            return false;
    }
}

References replication_yylex(), and yyextra.

Referenced by exec_replication_command().

replication_yyerror()

void replication_yyerror	(	Node **	replication_parse_result_p,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 260 of file repl_scanner.l.

{
    ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg_internal("%s", message)));
}

References ereport, errcode(), errmsg_internal(), and ERROR.

startlit()

static void startlit ( yyscan_t  yyscanner )

static

Definition at line 232 of file repl_scanner.l.

{
    initStringInfo(&yyextra->litbuf);
}

References initStringInfo(), and yyextra.

yyalloc()

void * yyalloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 331 of file repl_scanner.l.

{
    return palloc(size);
}

References palloc(), and size.

yyfree()

void yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 346 of file repl_scanner.l.

{
    if (ptr)
        pfree(ptr);
}

References pfree().

yylex()

int yylex	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 111 of file repl_scanner.l.

 {
    /* This code is inserted at the start of replication_yylex() */
 
    /* If we have a pushed-back token, return that. */
    if (yyextra->repl_pushed_back_token)
    {
        int         result = yyextra->repl_pushed_back_token;
 
        yyextra->repl_pushed_back_token = 0;
        return result;
    }
%}
 
BASE_BACKUP         { return K_BASE_BACKUP; }
IDENTIFY_SYSTEM     { return K_IDENTIFY_SYSTEM; }
READ_REPLICATION_SLOT   { return K_READ_REPLICATION_SLOT; }
SHOW        { return K_SHOW; }
TIMELINE            { return K_TIMELINE; }
START_REPLICATION   { return K_START_REPLICATION; }
CREATE_REPLICATION_SLOT     { return K_CREATE_REPLICATION_SLOT; }
DROP_REPLICATION_SLOT       { return K_DROP_REPLICATION_SLOT; }
ALTER_REPLICATION_SLOT      { return K_ALTER_REPLICATION_SLOT; }
TIMELINE_HISTORY    { return K_TIMELINE_HISTORY; }
PHYSICAL            { return K_PHYSICAL; }
RESERVE_WAL         { return K_RESERVE_WAL; }
LOGICAL             { return K_LOGICAL; }
SLOT                { return K_SLOT; }
TEMPORARY           { return K_TEMPORARY; }
TWO_PHASE           { return K_TWO_PHASE; }
EXPORT_SNAPSHOT     { return K_EXPORT_SNAPSHOT; }
NOEXPORT_SNAPSHOT   { return K_NOEXPORT_SNAPSHOT; }
USE_SNAPSHOT        { return K_USE_SNAPSHOT; }
WAIT                { return K_WAIT; }
UPLOAD_MANIFEST     { return K_UPLOAD_MANIFEST; }
 
{space}+        { /* do nothing */ }
 
{digit}+        {
                    yylval->uintval = strtoul(yytext, NULL, 10);
                    return UCONST;
                }
 
{hexdigit}+\/{hexdigit}+        {
                    uint32  hi,
                            lo;
                    if (sscanf(yytext, "%X/%X", &hi, &lo) != 2)
                        replication_yyerror(NULL, yyscanner, "invalid streaming start location");
                    yylval->recptr = ((uint64) hi) << 32 | lo;
                    return RECPTR;
                }
 
{xqstart}       {
                    BEGIN(xq);
                    startlit(yyscanner);
                }
 
<xq>{quotestop} {
                    yyless(1);
                    BEGIN(INITIAL);
                    yylval->str = litbufdup(yyscanner);
                    return SCONST;
                }
 
<xq>{xqdouble}  {
                    addlitchar('\'', yyscanner);
                }
 
<xq>{xqinside}  {
                    addlit(yytext, yyleng, yyscanner);
                }
 
{xdstart}       {
                    BEGIN(xd);
                    startlit(yyscanner);
                }
 
<xd>{xdstop}    {
                    int         len;
 
                    yyless(1);
                    BEGIN(INITIAL);
                    yylval->str = litbufdup(yyscanner);
                    len = strlen(yylval->str);
                    truncate_identifier(yylval->str, len, true);
                    return IDENT;
                }
 
<xd>{xdinside}  {
                    addlit(yytext, yyleng, yyscanner);
                }
 
{identifier}    {
                    int         len = strlen(yytext);
 
                    yylval->str = downcase_truncate_identifier(yytext, len, true);
                    return IDENT;
                }
 
.               {
                    /* Any char not recognized above is returned as itself */
                    return yytext[0];
                }
 
<xq,xd><<EOF>>  { replication_yyerror(NULL, yyscanner, "unterminated quoted string"); }
 
 
<<EOF>>         {
                    yyterminate();
                }
 
%%

yyrealloc()

void * yyrealloc	(	void *	ptr,
		yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 337 of file repl_scanner.l.

{
    if (ptr)
        return repalloc(ptr, size);
    else
        return palloc(size);
}

References palloc(), repalloc(), and size.