pgpa_scanner.l File Reference

#include "postgres.h"
#include "nodes/miscnodes.h"
#include "parser/scansup.h"
#include "utils/builtins.h"
#include "pgpa_ast.h"
#include "pgpa_parser.h"

Go to the source code of this file.

Data Structures
struct	pgpa_yy_extra_type

Macros
#define	YY_DECL
#define	YY_READ_BUF_SIZE   16777216
#define	fprintf(file, fmt, msg)   fprintf_to_ereport(fmt, msg)

Typedefs
typedef struct pgpa_yy_extra_type	pgpa_yy_extra_type

Functions
static void	fprintf_to_ereport (const char *fmt, const char *msg)
int	yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
void	pgpa_yyerror (List **result, char **parse_error_msg_p, yyscan_t yyscanner, const char *message)
void	pgpa_scanner_init (const char *str, yyscan_t *yyscannerp)
void	pgpa_scanner_finish (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 43 of file pgpa_scanner.l.

YY_DECL

#define YY_DECL

Value:

    extern int pgpa_yylex(union YYSTYPE *yylval_param, List **result, \
                          char **parse_error_msg_p, yyscan_t yyscanner)

Definition at line 34 of file pgpa_scanner.l.

YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   16777216

Definition at line 39 of file pgpa_scanner.l.

Typedef Documentation

pgpa_yy_extra_type

typedef struct pgpa_yy_extra_type pgpa_yy_extra_type

Function Documentation

fprintf_to_ereport()

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

static

Definition at line 46 of file pgpa_scanner.l.

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

References ereport, errmsg_internal(), and ERROR.

pgpa_scanner_finish()

void pgpa_scanner_finish

(

yyscan_t

yyscanner

)

Definition at line 275 of file pgpa_scanner.l.

{
    yylex_destroy(yyscanner);
}

References fb().

pgpa_scanner_init()

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

Definition at line 252 of file pgpa_scanner.l.

{
    yyscan_t    yyscanner;
    pgpa_yy_extra_type  *yyext = palloc0_object(pgpa_yy_extra_type);
 
    if (yylex_init(yyscannerp) != 0)
        elog(ERROR, "yylex_init() failed: %m");
 
    yyscanner = *yyscannerp;
 
    initStringInfo(&yyext->litbuf);
    pgpa_yyset_extra(yyext, yyscanner);
 
    yy_scan_string(str, yyscanner);
}

References elog, ERROR, fb(), initStringInfo(), palloc0_object, and str.

pgpa_yyerror()

void pgpa_yyerror	(	List **	result,
		char **	parse_error_msg_p,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 229 of file pgpa_scanner.l.

{
    struct yyguts_t *yyg = (struct yyguts_t *) yyscanner;   /* needed for yytext
                                                             * macro */
 
 
    /* report only the first error in a parse operation */
    if (*parse_error_msg_p)
        return;
 
    if (yytext[0])
        *parse_error_msg_p = psprintf("%s at or near \"%s\"", message, yytext);
    else
        *parse_error_msg_p = psprintf("%s at end of input", message);
}

References fb(), and psprintf().

yyalloc()

void * yyalloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 286 of file pgpa_scanner.l.

{
    return palloc(size);
}

References palloc().

yyfree()

void yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 301 of file pgpa_scanner.l.

{
    if (ptr)
        pfree(ptr);
}

References pfree().

yylex()

int yylex	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 100 of file pgpa_scanner.l.

{whitespace}    { /* ignore */ }
 
{identifier}    {
                    char   *str;
                    bool    fail;
                    pgpa_advice_tag_type    tag;
 
                    /*
                     * Unlike the core scanner, we don't truncate identifiers
                     * here. There is no obvious reason to do so.
                     */
                    str = downcase_identifier(yytext, yyleng, false, false);
                    yylval->str = str;
 
                    /*
                     * If it's not a tag, just return TOK_IDENT; else, return
                     * a token type based on how further parsing should
                     * proceed.
                     */
                    tag = pgpa_parse_advice_tag(str, &fail);
                    if (fail)
                        return TOK_IDENT;
                    else if (tag == PGPA_TAG_JOIN_ORDER)
                        return TOK_TAG_JOIN_ORDER;
                    else if (tag == PGPA_TAG_INDEX_SCAN ||
                             tag == PGPA_TAG_INDEX_ONLY_SCAN)
                        return TOK_TAG_INDEX;
                    else if (tag == PGPA_TAG_SEQ_SCAN ||
                             tag == PGPA_TAG_TID_SCAN ||
                             tag == PGPA_TAG_BITMAP_HEAP_SCAN ||
                             tag == PGPA_TAG_NO_GATHER ||
                             tag == PGPA_TAG_DO_NOT_SCAN)
                        return TOK_TAG_SIMPLE;
                    else
                        return TOK_TAG_GENERIC;
                }
 
{decinteger}    {
                    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
                    yylval->integer = pg_strtoint32_safe(yytext,
                                                         (Node *) &escontext);
                    if (escontext.error_occurred)
                        pgpa_yyerror(result, parse_error_msg_p, yyscanner,
                                     "integer out of range");
                    return TOK_INTEGER;
                }
 
{integer_junk}  {
                    BEGIN(INITIAL);
                    pgpa_yyerror(result, parse_error_msg_p, yyscanner,
                                 "trailing junk after numeric literal");
                }
 
{xcstart}       {
                    BEGIN(xc);
                }
 
{xdstart}       {
                    BEGIN(xd);
                    resetStringInfo(&yyextra->litbuf);
                }
 
.               { return yytext[0]; }
 
<xc>{xcstop}    {
                    BEGIN(INITIAL);
                }
 
<xc>{xcinside}  {
                    /* discard multiple characters without slash or asterisk */
                }
 
<xc>.           {
                    /*
                     * Discard any single character. flex prefers longer
                     * matches, so this rule will never be picked when we could
                     * have matched xcstop.
                     *
                     * NB: At present, we don't bother to support nested
                     * C-style comments here, but this logic could be extended
                     * if that restriction poses a problem.
                     */
                }
 
<xc><<EOF>>     {
                    BEGIN(INITIAL);
                    pgpa_yyerror(result, parse_error_msg_p, yyscanner,
                                 "unterminated comment");
                }
 
<xd>{xdstop}    {
                    BEGIN(INITIAL);
                    if (yyextra->litbuf.len == 0)
                        pgpa_yyerror(result, parse_error_msg_p, yyscanner,
                                     "zero-length delimited identifier");
                    yylval->str = pstrdup(yyextra->litbuf.data);
                    return TOK_IDENT;
                }
 
<xd>{xddouble}  {
                    appendStringInfoChar(&yyextra->litbuf, '"');
                }
 
<xd>{xdinside}  {
                    appendBinaryStringInfo(&yyextra->litbuf, yytext, yyleng);
                }
 
<xd><<EOF>>     {
                    BEGIN(INITIAL);
                    pgpa_yyerror(result, parse_error_msg_p, yyscanner,
                                 "unterminated quoted identifier");
                }
 
%%

yyrealloc()

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

Definition at line 292 of file pgpa_scanner.l.

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

References palloc(), and repalloc().