jsonpath_scan.l File Reference

#include "postgres.h"
#include "jsonpath_internal.h"
#include "jsonpath_gram.h"
#include "mb/pg_wchar.h"
#include "nodes/miscnodes.h"
#include "nodes/pg_list.h"

Go to the source code of this file.

Data Structures
struct	jsonpath_yy_extra_type
struct	JsonPathKeyword

Macros
#define	fprintf(file, fmt, msg)   fprintf_to_ereport(fmt, msg)
#define	yyextra   (((struct yyguts_t *) yyscanner)->yyextra_r)

Typedefs
typedef struct JsonPathKeyword	JsonPathKeyword

Functions
static void	addstring (bool init, char *s, int l, yyscan_t yyscanner)
static void	addchar (bool init, char c, yyscan_t yyscanner)
static enum yytokentype	checkKeyword (yyscan_t yyscanner)
static bool	parseUnicode (char *s, int l, struct Node *escontext, yyscan_t yyscanner)
static bool	parseHexChar (char *s, struct Node *escontext, yyscan_t yyscanner)
static void	fprintf_to_ereport (const char *fmt, const char *msg)
int	yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
void	jsonpath_yyerror (JsonPathParseResult **result, struct Node *escontext, yyscan_t yyscanner, const char *message)
static void	resizeString (bool init, int appendLen, yyscan_t yyscanner)
JsonPathParseResult *	parsejsonpath (const char *str, int len, struct Node *escontext)
static bool	hexval (char c, int *result, struct Node *escontext, yyscan_t yyscanner)
static bool	addUnicodeChar (char32_t ch, struct Node *escontext, yyscan_t yyscanner)
static bool	addUnicode (char32_t ch, int *hi_surrogate, struct Node *escontext, yyscan_t yyscanner)
void *	jsonpath_yyalloc (yy_size_t bytes, yyscan_t yyscanner)
void *	jsonpath_yyrealloc (void *ptr, yy_size_t bytes, yyscan_t yyscanner)
void	jsonpath_yyfree (void *ptr, yyscan_t yyscanner)

Variables
static const JsonPathKeyword	keywords []

Macro Definition Documentation

fprintf

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

Definition at line 46 of file jsonpath_scan.l.

yyextra

#define yyextra   (((struct yyguts_t *) yyscanner)->yyextra_r)

Definition at line 359 of file jsonpath_scan.l.

Typedef Documentation

JsonPathKeyword

typedef struct JsonPathKeyword JsonPathKeyword

Function Documentation

addchar()

static void addchar ( bool  init, char  c, yyscan_t  yyscanner  )

static

Definition at line 518 of file jsonpath_scan.l.

{
    resizeString(init, 1, yyscanner);
    yyextra->scanstring.val[yyextra->scanstring.len] = c;
    if (c != '\0')
        yyextra->scanstring.len++;
}

References init, resizeString(), and yyextra.

addstring()

static void addstring ( bool  init, char *  s, int  l, yyscan_t  yyscanner  )

static

Definition at line 509 of file jsonpath_scan.l.

{
    resizeString(init, l + 1, yyscanner);
    memcpy(yyextra->scanstring.val + yyextra->scanstring.len, s, l);
    yyextra->scanstring.len += l;
}

References fb(), init, resizeString(), and yyextra.

Referenced by addUnicodeChar().

addUnicode()

static bool addUnicode ( char32_t  ch, int *  hi_surrogate, struct Node *  escontext, yyscan_t  yyscanner  )

static

Definition at line 610 of file jsonpath_scan.l.

{
    if (is_utf16_surrogate_first(ch))
    {
        if (*hi_surrogate != -1)
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s", "jsonpath"),
                     errdetail("Unicode high surrogate must not follow "
                               "a high surrogate.")));
        *hi_surrogate = ch;
        return true;
    }
    else if (is_utf16_surrogate_second(ch))
    {
        if (*hi_surrogate == -1)
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s", "jsonpath"),
                     errdetail("Unicode low surrogate must follow a high "
                               "surrogate.")));
        ch = surrogate_pair_to_codepoint(*hi_surrogate, ch);
        *hi_surrogate = -1;
    }
    else if (*hi_surrogate != -1)
    {
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s", "jsonpath"),
                 errdetail("Unicode low surrogate must follow a high "
                           "surrogate.")));
    }
 
    return addUnicodeChar(ch, escontext, yyscanner);
}

References addUnicodeChar(), ereturn, errcode(), errdetail(), errmsg(), fb(), is_utf16_surrogate_first(), is_utf16_surrogate_second(), and surrogate_pair_to_codepoint().

Referenced by parseUnicode().

addUnicodeChar()

static bool addUnicodeChar ( char32_t  ch, struct Node *  escontext, yyscan_t  yyscanner  )

static

Definition at line 577 of file jsonpath_scan.l.

{
    if (ch == 0)
    {
        /* We can't allow this, since our TEXT type doesn't */
        ereturn(escontext, false,
                (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                 errmsg("unsupported Unicode escape sequence"),
                 errdetail("\\u0000 cannot be converted to text.")));
    }
    else
    {
        char        cbuf[MAX_UNICODE_EQUIVALENT_STRING + 1];
 
        /*
         * If we're trapping the error status, call the noerror form of the
         * conversion function. Otherwise call the normal form which provides
         * more detailed errors.
         */
 
        if (!escontext || !IsA(escontext, ErrorSaveContext))
            pg_unicode_to_server(ch, (unsigned char *) cbuf);
        else if (!pg_unicode_to_server_noerror(ch, (unsigned char *) cbuf))
            ereturn(escontext, false,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("could not convert Unicode to server encoding")));
        addstring(false, cbuf, strlen(cbuf), yyscanner);
    }
    return true;
}

References addstring(), ereturn, errcode(), errdetail(), errmsg(), fb(), IsA, MAX_UNICODE_EQUIVALENT_STRING, pg_unicode_to_server(), and pg_unicode_to_server_noerror().

Referenced by addUnicode(), and parseHexChar().

checkKeyword()

static enum yytokentype checkKeyword ( yyscan_t  yyscanner )

static

Definition at line 442 of file jsonpath_scan.l.

{
    int         res = IDENT_P;
    int         diff;
    const JsonPathKeyword *StopLow = keywords,
               *StopHigh = keywords + lengthof(keywords),
               *StopMiddle;
 
    if (yyextra->scanstring.len > keywords[lengthof(keywords) - 1].len)
        return res;
 
    while (StopLow < StopHigh)
    {
        StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
 
        if (StopMiddle->len == yyextra->scanstring.len)
            diff = pg_strncasecmp(StopMiddle->keyword, yyextra->scanstring.val,
                                  yyextra->scanstring.len);
        else
            diff = StopMiddle->len - yyextra->scanstring.len;
 
        if (diff < 0)
            StopLow = StopMiddle + 1;
        else if (diff > 0)
            StopHigh = StopMiddle;
        else
        {
            if (StopMiddle->lowercase)
                diff = strncmp(StopMiddle->keyword, yyextra->scanstring.val,
                               yyextra->scanstring.len);
 
            if (diff == 0)
                res = StopMiddle->val;
 
            break;
        }
    }
 
    return res;
}

References fb(), keywords, len, lengthof, pg_strncasecmp(), and yyextra.

fprintf_to_ereport()

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

static

Definition at line 49 of file jsonpath_scan.l.

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

References ereport, errmsg_internal(), and ERROR.

hexval()

static bool hexval ( char  c, int *  result, struct Node *  escontext, yyscan_t  yyscanner  )

static

Definition at line 554 of file jsonpath_scan.l.

{
    if (c >= '0' && c <= '9')
    {
        *result = c - '0';
        return true;
    }
    if (c >= 'a' && c <= 'f')
    {
        *result = c - 'a' + 0xA;
        return true;
    }
    if (c >= 'A' && c <= 'F')
    {
        *result = c - 'A' + 0xA;
        return true;
    }
    jsonpath_yyerror(NULL, escontext, yyscanner, "invalid hexadecimal digit");
    return false;
}

References fb(), and jsonpath_yyerror().

Referenced by parseHexChar(), and parseUnicode().

jsonpath_yyalloc()

void * jsonpath_yyalloc	(	yy_size_t	bytes,
		yyscan_t	yyscanner
	)

Definition at line 722 of file jsonpath_scan.l.

{
    return palloc(bytes);
}

References palloc().

jsonpath_yyerror()

void jsonpath_yyerror	(	JsonPathParseResult **	result,
		struct Node *	escontext,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 362 of file jsonpath_scan.l.

{
    struct yyguts_t *yyg = (struct yyguts_t *) yyscanner;   /* needed for yytext
                                                             * macro */
 
    /* don't overwrite escontext if it's already been set */
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    if (*yytext == YY_END_OF_BUFFER_CHAR)
    {
        errsave(escontext,
                (errcode(ERRCODE_SYNTAX_ERROR),
        /* translator: %s is typically "syntax error" */
                 errmsg("%s at end of jsonpath input", _(message))));
    }
    else
    {
        errsave(escontext,
                (errcode(ERRCODE_SYNTAX_ERROR),
        /* translator: first %s is typically "syntax error" */
                 errmsg("%s at or near \"%s\" of jsonpath input",
                        _(message), yytext)));
    }
}

References _, errcode(), errmsg(), errsave, fb(), and SOFT_ERROR_OCCURRED.

Referenced by hexval(), and parsejsonpath().

jsonpath_yyfree()

void jsonpath_yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 737 of file jsonpath_scan.l.

{
    if (ptr)
        pfree(ptr);
}

References pfree().

jsonpath_yyrealloc()

void * jsonpath_yyrealloc	(	void *	ptr,
		yy_size_t	bytes,
		yyscan_t	yyscanner
	)

Definition at line 728 of file jsonpath_scan.l.

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

References palloc(), and repalloc().

parseHexChar()

static bool parseHexChar ( char *  s, struct Node *  escontext, yyscan_t  yyscanner  )

static

Definition at line 700 of file jsonpath_scan.l.

{
    int         s2,
                s3,
                ch;
 
    if (!hexval(s[2], &s2, escontext, yyscanner))
        return false;
    if (!hexval(s[3], &s3, escontext, yyscanner))
        return false;
 
    ch = (s2 << 4) | s3;
 
    return addUnicodeChar(ch, escontext, yyscanner);
}

References addUnicodeChar(), fb(), hexval(), s2, and s3.

parsejsonpath()

JsonPathParseResult * parsejsonpath	(	const char *	str,
		int	len,
		struct Node *	escontext
	)

Definition at line 528 of file jsonpath_scan.l.

{
    JsonPathParseResult *parseresult;
    yyscan_t    scanner;
    struct jsonpath_yy_extra_type yyext;
 
    if (jsonpath_yylex_init(&scanner) != 0)
        elog(ERROR, "yylex_init() failed: %m");
 
    yyset_extra(&yyext, scanner);
 
    if (len <= 0)
        len = strlen(str);
 
    jsonpath_yy_scan_bytes(str, len, scanner);
 
    if (jsonpath_yyparse(&parseresult, escontext, scanner) != 0)
        jsonpath_yyerror(NULL, escontext, scanner, "invalid input");    /* shouldn't happen */
 
    jsonpath_yylex_destroy(scanner);
 
    return parseresult;
}

References elog, ERROR, fb(), jsonpath_yyerror(), jsonpath_yyparse(), len, parseresult, and str.

Referenced by jsonPathFromCstring().

parseUnicode()

static bool parseUnicode ( char *  s, int  l, struct Node *  escontext, yyscan_t  yyscanner  )

static

Definition at line 651 of file jsonpath_scan.l.

{
    int         i = 2;
    int         hi_surrogate = -1;
 
    for (i = 2; i < l; i += 2)  /* skip '\u' */
    {
        char32_t        ch = 0;
        int         j,
                    si;
 
        if (s[i] == '{')        /* parse '\u{XX...}' */
        {
            while (s[++i] != '}' && i < l)
            {
                if (!hexval(s[i], &si, escontext, yyscanner))
                    return false;
                ch = (ch << 4) | si;
            }
            i++;                /* skip '}' */
        }
        else                    /* parse '\uXXXX' */
        {
            for (j = 0; j < 4 && i < l; j++)
            {
                if (!hexval(s[i++], &si, escontext, yyscanner))
                    return false;
                ch = (ch << 4) | si;
            }
        }
 
        if (!addUnicode(ch, &hi_surrogate, escontext, yyscanner))
            return false;
    }
 
    if (hi_surrogate != -1)
    {
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s", "jsonpath"),
                 errdetail("Unicode low surrogate must follow a high "
                           "surrogate.")));
    }
 
    return true;
}

References addUnicode(), ereturn, errcode(), errdetail(), errmsg(), fb(), hexval(), i, and j.

resizeString()

static void resizeString ( bool  init, int  appendLen, yyscan_t  yyscanner  )

static

Definition at line 488 of file jsonpath_scan.l.

{
    if (init)
    {
        yyextra->scanstring.total = Max(32, appendLen);
        yyextra->scanstring.val = (char *) palloc(yyextra->scanstring.total);
        yyextra->scanstring.len = 0;
    }
    else
    {
        if (yyextra->scanstring.len + appendLen >= yyextra->scanstring.total)
        {
            while (yyextra->scanstring.len + appendLen >= yyextra->scanstring.total)
                yyextra->scanstring.total *= 2;
            yyextra->scanstring.val = repalloc(yyextra->scanstring.val, yyextra->scanstring.total);
        }
    }
}

References fb(), init, Max, palloc(), repalloc(), and yyextra.

Referenced by addchar(), and addstring().

yylex()

int yylex	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 120 of file jsonpath_scan.l.

     {other}+                   {
                                    addstring(false, yytext, yyleng, yyscanner);
                                }
 
<xnq>{blank}+                   {
                                    yylval->str = yyextra->scanstring;
                                    BEGIN INITIAL;
                                    return checkKeyword(yyscanner);
                                }
 
<xnq>\/\*                       {
                                    yylval->str = yyextra->scanstring;
                                    BEGIN xc;
                                }
 
<xnq>({special}|\")             {
                                    yylval->str = yyextra->scanstring;
                                    yyless(0);
                                    BEGIN INITIAL;
                                    return checkKeyword(yyscanner);
                                }
 
<xnq><<EOF>>                    {
                                    yylval->str = yyextra->scanstring;
                                    BEGIN INITIAL;
                                    return checkKeyword(yyscanner);
                                }
 
<xnq,xq,xvq>\\b             { addchar(false, '\b', yyscanner); }
 
<xnq,xq,xvq>\\f             { addchar(false, '\f', yyscanner); }
 
<xnq,xq,xvq>\\n             { addchar(false, '\n', yyscanner); }
 
<xnq,xq,xvq>\\r             { addchar(false, '\r', yyscanner); }
 
<xnq,xq,xvq>\\t             { addchar(false, '\t', yyscanner); }
 
<xnq,xq,xvq>\\v             { addchar(false, '\v', yyscanner); }
 
<xnq,xq,xvq>{unicode}+      {
                                if (!parseUnicode(yytext, yyleng, escontext, yyscanner))
                                    yyterminate();
                            }
 
<xnq,xq,xvq>{hex_char}      {
                                if (!parseHexChar(yytext, escontext, yyscanner))
                                    yyterminate();
                            }
 
<xnq,xq,xvq>{unicode}*{unicodefail} {
                                jsonpath_yyerror(NULL, escontext, yyscanner,
                                                 "invalid Unicode escape sequence");
                                yyterminate();
                            }
 
<xnq,xq,xvq>{hex_fail}      {
                                jsonpath_yyerror(NULL, escontext, yyscanner,
                                                 "invalid hexadecimal character sequence");
                                yyterminate();
                            }
 
<xnq,xq,xvq>{unicode}+\\    {
                                /* throw back the \\, and treat as unicode */
                                yyless(yyleng - 1);
                                if (!parseUnicode(yytext, yyleng, escontext, yyscanner))
                                    yyterminate();
                            }
 
<xnq,xq,xvq>\\.             { addchar(false, yytext[1], yyscanner); }
 
<xnq,xq,xvq>\\              {
                                jsonpath_yyerror(NULL, escontext, yyscanner,
                                                 "unexpected end after backslash");
                                yyterminate();
                            }
 
<xq,xvq><<EOF>>             {
                                jsonpath_yyerror(NULL, escontext, yyscanner,
                                                 "unterminated quoted string");
                                yyterminate();
                            }
 
<xq>\"                          {
                                    yylval->str = yyextra->scanstring;
                                    BEGIN INITIAL;
                                    return STRING_P;
                                }
 
<xvq>\"                         {
                                    yylval->str = yyextra->scanstring;
                                    BEGIN INITIAL;
                                    return VARIABLE_P;
                                }
 
<xq,xvq>[^\\\"]+                { addstring(false, yytext, yyleng, yyscanner); }
 
<xc>\*\/                        { BEGIN INITIAL; }
 
<xc>[^\*]+                      { }
 
<xc>\*                          { }
 
<xc><<EOF>>                     {
                                    jsonpath_yyerror(NULL, escontext, yyscanner,
                                                     "unexpected end of comment");
                                    yyterminate();
                                }
\&\&                            { return AND_P; }
 
\|\|                            { return OR_P; }
 
\!                              { return NOT_P; }
 
\*\*                            { return ANY_P; }
 
\<                              { return LESS_P; }
 
\<\=                            { return LESSEQUAL_P; }
 
\=\=                            { return EQUAL_P; }
 
\<>                         { return NOTEQUAL_P; }
 
\!\=                            { return NOTEQUAL_P; }
 
\>\=                            { return GREATEREQUAL_P; }
 
\>                              { return GREATER_P; }
 
\${other}+                      {
                                    addstring(true, yytext + 1, yyleng - 1, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return VARIABLE_P;
                                }
 
\$\"                            {
                                    addchar(true, '\0', yyscanner);
                                    BEGIN xvq;
                                }
 
{special}                       { return *yytext; }
 
{blank}+                        { /* ignore */ }
 
\/\*                            {
                                    addchar(true, '\0', yyscanner);
                                    BEGIN xc;
                                }
 
{real}                          {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return NUMERIC_P;
                                }
 
{decimal}                       {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return NUMERIC_P;
                                }
 
{decinteger}                    {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return INT_P;
                                }
 
{hexinteger}                    {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return INT_P;
                                }
 
{octinteger}                    {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return INT_P;
                                }
 
{bininteger}                    {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    addchar(false, '\0', yyscanner);
                                    yylval->str = yyextra->scanstring;
                                    return INT_P;
                                }
 
{realfail}                      {
                                    jsonpath_yyerror(NULL, escontext, yyscanner,
                                                     "invalid numeric literal");
                                    yyterminate();
                                }
{decinteger_junk}               {
                                    jsonpath_yyerror(NULL, escontext, yyscanner,
                                                     "trailing junk after numeric literal");
                                    yyterminate();
                                }
{decimal_junk}                  {
                                    jsonpath_yyerror(NULL, escontext, yyscanner,
                                                     "trailing junk after numeric literal");
                                    yyterminate();
                                }
{real_junk}                     {
                                    jsonpath_yyerror(NULL, escontext, yyscanner,
                                                     "trailing junk after numeric literal");
                                    yyterminate();
                                }
\"                              {
                                    addchar(true, '\0', yyscanner);
                                    BEGIN xq;
                                }
 
\\                              {
                                    yyless(0);
                                    addchar(true, '\0', yyscanner);
                                    BEGIN xnq;
                                }
 
{other}+                        {
                                    addstring(true, yytext, yyleng, yyscanner);
                                    BEGIN xnq;
                                }
 
<<EOF>>                         { yyterminate(); }
 
%%

Variable Documentation

keywords

const JsonPathKeyword keywords[]

static

Definition at line 402 of file jsonpath_scan.l.

                                          {
    {2, false, IS_P, "is"},
    {2, false, TO_P, "to"},
    {3, false, ABS_P, "abs"},
    {3, false, LAX_P, "lax"},
    {4, false, DATE_P, "date"},
    {4, false, FLAG_P, "flag"},
    {4, false, LAST_P, "last"},
    {4, true, NULL_P, "null"},
    {4, false, SIZE_P, "size"},
    {4, false, TIME_P, "time"},
    {4, true, TRUE_P, "true"},
    {4, false, TYPE_P, "type"},
    {4, false, WITH_P, "with"},
    {5, true, FALSE_P, "false"},
    {5, false, FLOOR_P, "floor"},
    {6, false, BIGINT_P, "bigint"},
    {6, false, DOUBLE_P, "double"},
    {6, false, EXISTS_P, "exists"},
    {6, false, NUMBER_P, "number"},
    {6, false, STARTS_P, "starts"},
    {6, false, STRICT_P, "strict"},
    {6, false, STRINGFUNC_P, "string"},
    {7, false, BOOLEAN_P, "boolean"},
    {7, false, CEILING_P, "ceiling"},
    {7, false, DECIMAL_P, "decimal"},
    {7, false, INTEGER_P, "integer"},
    {7, false, TIME_TZ_P, "time_tz"},
    {7, false, UNKNOWN_P, "unknown"},
    {8, false, DATETIME_P, "datetime"},
    {8, false, KEYVALUE_P, "keyvalue"},
    {9, false, TIMESTAMP_P, "timestamp"},
    {10, false, LIKE_REGEX_P, "like_regex"},
    {12, false, TIMESTAMP_TZ_P, "timestamp_tz"},
};

Referenced by check_conn_params(), checkKeyword(), connect_pg_server(), ConnectDatabase(), connectDatabase(), conninfo_array_parse(), constructConnStr(), copy_connection(), do_connect(), doConnect(), ExtractConnectionOptions(), GetConnection(), GetScanKeyword(), libpqsrv_connect_params(), main(), main(), pgfdw_has_required_scram_options(), pgfdw_security_check(), PQconnectdbParams(), PQconnectStartParams(), PQpingParams(), regression_main(), ScanKeywordLookup(), sql_conn(), test_protocol_version(), and vacuumlo().