PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions | Variables
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"
Include dependency graph for jsonpath_scan.l:

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 (int ch, struct Node *escontext, yyscan_t yyscanner)
 
static bool  addUnicode (int 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.

519{
520 resizeString(init, 1, yyscanner);
521 yyextra->scanstring.val[yyextra->scanstring.len] = c;
522 if (c != '0円')
523 yyextra->scanstring.len++;
int init
Definition: isn.c:79
static void resizeString(bool init, int appendLen, yyscan_t yyscanner)
Definition: jsonpath_scan.l:488
#define yyextra
Definition: jsonpath_scan.l:359
c
char * c
Definition: preproc-cursor.c:31
524}

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.

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

References init, resizeString(), and yyextra.

Referenced by addUnicodeChar().

◆ addUnicode()

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

Definition at line 610 of file jsonpath_scan.l.

611{
613 {
614 if (*hi_surrogate != -1)
615 ereturn(escontext, false,
616 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
617 errmsg("invalid input syntax for type %s", "jsonpath"),
618 errdetail("Unicode high surrogate must not follow "
619 "a high surrogate.")));
620 *hi_surrogate = ch;
621 return true;
622 }
623 else if (is_utf16_surrogate_second(ch))
624 {
625 if (*hi_surrogate == -1)
626 ereturn(escontext, false,
627 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
628 errmsg("invalid input syntax for type %s", "jsonpath"),
629 errdetail("Unicode low surrogate must follow a high "
630 "surrogate.")));
631 ch = surrogate_pair_to_codepoint(*hi_surrogate, ch);
632 *hi_surrogate = -1;
633 }
634 else if (*hi_surrogate != -1)
635 {
636 ereturn(escontext, false,
637 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
638 errmsg("invalid input syntax for type %s", "jsonpath"),
639 errdetail("Unicode low surrogate must follow a high "
640 "surrogate.")));
641 }
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ereturn(context, dummy_value,...)
Definition: elog.h:278
static pg_wchar surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second)
Definition: pg_wchar.h:537
static bool is_utf16_surrogate_first(pg_wchar c)
Definition: pg_wchar.h:525
static bool is_utf16_surrogate_second(pg_wchar c)
Definition: pg_wchar.h:531
642
643 return addUnicodeChar(ch, escontext, yyscanner);
static bool addUnicodeChar(int ch, struct Node *escontext, yyscan_t yyscanner)
Definition: jsonpath_scan.l:577
644}

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

Referenced by parseUnicode().

◆ addUnicodeChar()

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

Definition at line 577 of file jsonpath_scan.l.

578{
579 if (ch == 0)
580 {
581 /* We can't allow this, since our TEXT type doesn't */
582 ereturn(escontext, false,
583 (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
584 errmsg("unsupported Unicode escape sequence"),
585 errdetail("\\u0000 cannot be converted to text.")));
586 }
587 else
588 {
589 char cbuf[MAX_UNICODE_EQUIVALENT_STRING + 1];
#define MAX_UNICODE_EQUIVALENT_STRING
Definition: pg_wchar.h:329
590
591 /*
592 * If we're trapping the error status, call the noerror form of the
593 * conversion function. Otherwise call the normal form which provides
594 * more detailed errors.
595 */
596
597 if (!escontext || !IsA(escontext, ErrorSaveContext))
598 pg_unicode_to_server(ch, (unsigned char *) cbuf);
599 else if (!pg_unicode_to_server_noerror(ch, (unsigned char *) cbuf))
600 ereturn(escontext, false,
601 (errcode(ERRCODE_SYNTAX_ERROR),
602 errmsg("could not convert Unicode to server encoding")));
603 addstring(false, cbuf, strlen(cbuf), yyscanner);
604 }
605 return true;
static void addstring(bool init, char *s, int l, yyscan_t yyscanner)
Definition: jsonpath_scan.l:509
bool pg_unicode_to_server_noerror(pg_wchar c, unsigned char *s)
Definition: mbutils.c:927
void pg_unicode_to_server(pg_wchar c, unsigned char *s)
Definition: mbutils.c:865
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
606}

References addstring(), ereturn, errcode(), errdetail(), errmsg(), 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.

443{
444 int res = IDENT_P;
445 int diff;
446 const JsonPathKeyword *StopLow = keywords,
447 *StopHigh = keywords + lengthof(keywords),
448 *StopMiddle;
#define lengthof(array)
Definition: c.h:787
static const JsonPathKeyword keywords[]
Definition: jsonpath_scan.l:402
449
450 if (yyextra->scanstring.len > keywords[lengthof(keywords) - 1].len)
451 return res;
const void size_t len
452
453 while (StopLow < StopHigh)
454 {
455 StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
456
457 if (StopMiddle->len == yyextra->scanstring.len)
458 diff = pg_strncasecmp(StopMiddle->keyword, yyextra->scanstring.val,
459 yyextra->scanstring.len);
460 else
461 diff = StopMiddle->len - yyextra->scanstring.len;
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69
462
463 if (diff < 0)
464 StopLow = StopMiddle + 1;
465 else if (diff > 0)
466 StopHigh = StopMiddle;
467 else
468 {
469 if (StopMiddle->lowercase)
470 diff = strncmp(StopMiddle->keyword, yyextra->scanstring.val,
471 yyextra->scanstring.len);
472
473 if (diff == 0)
474 res = StopMiddle->val;
475
476 break;
477 }
478 }
479
480 return res;
481}

References 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.

50{
51 ereport(ERROR, (errmsg_internal("%s", msg)));
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1161
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:150
52}

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.

555{
556 if (c >= '0' && c <= '9')
557 {
558 *result = c - '0';
559 return true;
560 }
561 if (c >= 'a' && c <= 'f')
562 {
563 *result = c - 'a' + 0xA;
564 return true;
565 }
566 if (c >= 'A' && c <= 'F')
567 {
568 *result = c - 'A' + 0xA;
569 return true;
570 }
571 jsonpath_yyerror(NULL, escontext, yyscanner, "invalid hexadecimal digit");
572 return false;
void jsonpath_yyerror(JsonPathParseResult **result, struct Node *escontext, yyscan_t yyscanner, const char *message)
Definition: jsonpath_scan.l:362
573}

References 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.

723{
724 return palloc(bytes);
void * palloc(Size size)
Definition: mcxt.c:1365
725}

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.

365{
366 struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
367 * macro */
Definition: pl_scanner.c:141
368
369 /* don't overwrite escontext if it's already been set */
370 if (SOFT_ERROR_OCCURRED(escontext))
371 return;
#define SOFT_ERROR_OCCURRED(escontext)
Definition: miscnodes.h:53
372
373 if (*yytext == YY_END_OF_BUFFER_CHAR)
374 {
375 errsave(escontext,
376 (errcode(ERRCODE_SYNTAX_ERROR),
377 /* translator: %s is typically "syntax error" */
378 errmsg("%s at end of jsonpath input", _(message))));
379 }
380 else
381 {
382 errsave(escontext,
383 (errcode(ERRCODE_SYNTAX_ERROR),
384 /* translator: first %s is typically "syntax error" */
385 errmsg("%s at or near \"%s\" of jsonpath input",
386 _(message), yytext)));
387 }
_
#define _(x)
Definition: elog.c:91
#define errsave(context,...)
Definition: elog.h:262
388}

References _, errcode(), errmsg(), errsave, 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.

738{
739 if (ptr)
740 pfree(ptr);
void pfree(void *pointer)
Definition: mcxt.c:1594
741}

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.

729{
730 if (ptr)
731 return repalloc(ptr, bytes);
732 else
733 return palloc(bytes);
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1610
734}

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.

701{
702 int s2,
703 s3,
704 ch;
char * s2
char * s3
705
706 if (!hexval(s[2], &s2, escontext, yyscanner))
707 return false;
708 if (!hexval(s[3], &s3, escontext, yyscanner))
709 return false;
static bool hexval(char c, int *result, struct Node *escontext, yyscan_t yyscanner)
Definition: jsonpath_scan.l:554
710
711 ch = (s2 << 4) | s3;
712
713 return addUnicodeChar(ch, escontext, yyscanner);
714}

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

◆ parsejsonpath()

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

Definition at line 528 of file jsonpath_scan.l.

529{
531 yyscan_t scanner;
532 struct jsonpath_yy_extra_type yyext;
void * yyscan_t
Definition: cubedata.h:65
TestSpec parseresult
Definition: jsonpath_scan.l:34
533
534 if (jsonpath_yylex_init(&scanner) != 0)
535 elog(ERROR, "yylex_init() failed: %m");
#define elog(elevel,...)
Definition: elog.h:226
536
537 yyset_extra(&yyext, scanner);
538
539 if (len <= 0)
540 len = strlen(str);
const char * str
541
542 jsonpath_yy_scan_bytes(str, len, scanner);
543
544 if (jsonpath_yyparse(&parseresult, escontext, scanner) != 0)
545 jsonpath_yyerror(NULL, escontext, scanner, "invalid input"); /* shouldn't happen */
int jsonpath_yyparse(JsonPathParseResult **result, struct Node *escontext, yyscan_t yyscanner)
546
547 jsonpath_yylex_destroy(scanner);
548
549 return parseresult;
550}

References elog, ERROR, 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.

652{
653 int i = 2;
654 int hi_surrogate = -1;
i
int i
Definition: isn.c:77
655
656 for (i = 2; i < l; i += 2) /* skip '\u' */
657 {
658 int ch = 0;
659 int j,
660 si;
j
int j
Definition: isn.c:78
661
662 if (s[i] == '{') /* parse '\u{XX...}' */
663 {
664 while (s[++i] != '}' && i < l)
665 {
666 if (!hexval(s[i], &si, escontext, yyscanner))
667 return false;
668 ch = (ch << 4) | si;
669 }
670 i++; /* skip '}' */
671 }
672 else /* parse '\uXXXX' */
673 {
674 for (j = 0; j < 4 && i < l; j++)
675 {
676 if (!hexval(s[i++], &si, escontext, yyscanner))
677 return false;
678 ch = (ch << 4) | si;
679 }
680 }
681
682 if (!addUnicode(ch, &hi_surrogate, escontext, yyscanner))
683 return false;
684 }
static bool addUnicode(int ch, int *hi_surrogate, struct Node *escontext, yyscan_t yyscanner)
Definition: jsonpath_scan.l:610
685
686 if (hi_surrogate != -1)
687 {
688 ereturn(escontext, false,
689 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
690 errmsg("invalid input syntax for type %s", "jsonpath"),
691 errdetail("Unicode low surrogate must follow a high "
692 "surrogate.")));
693 }
694
695 return true;
696}

References addUnicode(), ereturn, errcode(), errdetail(), errmsg(), 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.

489{
490 if (init)
491 {
492 yyextra->scanstring.total = Max(32, appendLen);
493 yyextra->scanstring.val = (char *) palloc(yyextra->scanstring.total);
494 yyextra->scanstring.len = 0;
495 }
496 else
497 {
498 if (yyextra->scanstring.len + appendLen >= yyextra->scanstring.total)
499 {
500 while (yyextra->scanstring.len + appendLen >= yyextra->scanstring.total)
501 yyextra->scanstring.total *= 2;
502 yyextra->scanstring.val = repalloc(yyextra->scanstring.val, yyextra->scanstring.total);
503 }
504 }
#define Max(x, y)
Definition: c.h:997
505}

References 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.

122 {other}+ {
123 addstring(false, yytext, yyleng, yyscanner);
124 }
#define yyleng
Definition: scan.l:1124
125
126<xnq>{blank}+ {
127 yylval->str = yyextra->scanstring;
128 BEGIN INITIAL;
129 return checkKeyword(yyscanner);
130 }
static enum yytokentype checkKeyword(yyscan_t yyscanner)
Definition: jsonpath_scan.l:442
131
132<xnq>\/\* {
133 yylval->str = yyextra->scanstring;
134 BEGIN xc;
135 }
136
137<xnq>({special}|\") {
138 yylval->str = yyextra->scanstring;
139 yyless(0);
140 BEGIN INITIAL;
141 return checkKeyword(yyscanner);
142 }
143
144<xnq><<EOF>> {
145 yylval->str = yyextra->scanstring;
146 BEGIN INITIAL;
147 return checkKeyword(yyscanner);
148 }
149
150<xnq,xq,xvq>\\b { addchar(false, '\b', yyscanner); }
151
152<xnq,xq,xvq>\\f { addchar(false, '\f', yyscanner); }
153
154<xnq,xq,xvq>\\n { addchar(false, '\n', yyscanner); }
155
156<xnq,xq,xvq>\\r { addchar(false, '\r', yyscanner); }
157
158<xnq,xq,xvq>\\t { addchar(false, '\t', yyscanner); }
159
160<xnq,xq,xvq>\\v { addchar(false, '\v', yyscanner); }
161
162<xnq,xq,xvq>{unicode}+ {
163 if (!parseUnicode(yytext, yyleng, escontext, yyscanner))
164 yyterminate();
165 }
static bool parseUnicode(char *s, int l, struct Node *escontext, yyscan_t yyscanner)
Definition: jsonpath_scan.l:651
166
167<xnq,xq,xvq>{hex_char} {
168 if (!parseHexChar(yytext, escontext, yyscanner))
169 yyterminate();
170 }
static bool parseHexChar(char *s, struct Node *escontext, yyscan_t yyscanner)
Definition: jsonpath_scan.l:700
171
172<xnq,xq,xvq>{unicode}*{unicodefail} {
173 jsonpath_yyerror(NULL, escontext, yyscanner,
174 "invalid Unicode escape sequence");
175 yyterminate();
176 }
177
178<xnq,xq,xvq>{hex_fail} {
179 jsonpath_yyerror(NULL, escontext, yyscanner,
180 "invalid hexadecimal character sequence");
181 yyterminate();
182 }
183
184<xnq,xq,xvq>{unicode}+\\ {
185 /* throw back the \,円 and treat as unicode */
186 yyless(yyleng - 1);
187 if (!parseUnicode(yytext, yyleng, escontext, yyscanner))
188 yyterminate();
189 }
190
191<xnq,xq,xvq>\\. { addchar(false, yytext[1], yyscanner); }
192
193<xnq,xq,xvq>\\ {
194 jsonpath_yyerror(NULL, escontext, yyscanner,
195 "unexpected end after backslash");
196 yyterminate();
197 }
198
199<xq,xvq><<EOF>> {
200 jsonpath_yyerror(NULL, escontext, yyscanner,
201 "unterminated quoted string");
202 yyterminate();
203 }
204
205<xq>\" {
206 yylval->str = yyextra->scanstring;
207 BEGIN INITIAL;
208 return STRING_P;
209 }
210
211<xvq>\" {
212 yylval->str = yyextra->scanstring;
213 BEGIN INITIAL;
214 return VARIABLE_P;
215 }
216
217<xq,xvq>[^\\\"]+ { addstring(false, yytext, yyleng, yyscanner); }
218
219<xc>\*\/ { BEGIN INITIAL; }
220
221<xc>[^\*]+ { }
222
223<xc>\* { }
224
225<xc><<EOF>> {
226 jsonpath_yyerror(NULL, escontext, yyscanner,
227 "unexpected end of comment");
228 yyterminate();
229 }
230\&\& { return AND_P; }
231
232\|\| { return OR_P; }
233
234\! { return NOT_P; }
235
236\*\* { return ANY_P; }
237
238\< { return LESS_P; }
239
240\<\= { return LESSEQUAL_P; }
241
242\=\= { return EQUAL_P; }
243
244\<> { return NOTEQUAL_P; }
245
246\!\= { return NOTEQUAL_P; }
247
248\>\= { return GREATEREQUAL_P; }
249
250\> { return GREATER_P; }
251
252\${other}+ {
253 addstring(true, yytext + 1, yyleng - 1, yyscanner);
254 addchar(false, '0円', yyscanner);
255 yylval->str = yyextra->scanstring;
256 return VARIABLE_P;
257 }
static void addchar(bool init, char c, yyscan_t yyscanner)
Definition: jsonpath_scan.l:518
258
259\$\" {
260 addchar(true, '0円', yyscanner);
261 BEGIN xvq;
262 }
263
264{special} { return *yytext; }
265
266{blank}+ { /* ignore */ }
267
268\/\* {
269 addchar(true, '0円', yyscanner);
270 BEGIN xc;
271 }
272
273{real} {
274 addstring(true, yytext, yyleng, yyscanner);
275 addchar(false, '0円', yyscanner);
276 yylval->str = yyextra->scanstring;
277 return NUMERIC_P;
278 }
279
280{decimal} {
281 addstring(true, yytext, yyleng, yyscanner);
282 addchar(false, '0円', yyscanner);
283 yylval->str = yyextra->scanstring;
284 return NUMERIC_P;
285 }
286
287{decinteger} {
288 addstring(true, yytext, yyleng, yyscanner);
289 addchar(false, '0円', yyscanner);
290 yylval->str = yyextra->scanstring;
291 return INT_P;
292 }
293
294{hexinteger} {
295 addstring(true, yytext, yyleng, yyscanner);
296 addchar(false, '0円', yyscanner);
297 yylval->str = yyextra->scanstring;
298 return INT_P;
299 }
300
301{octinteger} {
302 addstring(true, yytext, yyleng, yyscanner);
303 addchar(false, '0円', yyscanner);
304 yylval->str = yyextra->scanstring;
305 return INT_P;
306 }
307
308{bininteger} {
309 addstring(true, yytext, yyleng, yyscanner);
310 addchar(false, '0円', yyscanner);
311 yylval->str = yyextra->scanstring;
312 return INT_P;
313 }
314
315{realfail} {
316 jsonpath_yyerror(NULL, escontext, yyscanner,
317 "invalid numeric literal");
318 yyterminate();
319 }
320{decinteger_junk} {
321 jsonpath_yyerror(NULL, escontext, yyscanner,
322 "trailing junk after numeric literal");
323 yyterminate();
324 }
325{decimal_junk} {
326 jsonpath_yyerror(NULL, escontext, yyscanner,
327 "trailing junk after numeric literal");
328 yyterminate();
329 }
330{real_junk} {
331 jsonpath_yyerror(NULL, escontext, yyscanner,
332 "trailing junk after numeric literal");
333 yyterminate();
334 }
335\" {
336 addchar(true, '0円', yyscanner);
337 BEGIN xq;
338 }
339
340\\ {
341 yyless(0);
342 addchar(true, '0円', yyscanner);
343 BEGIN xnq;
344 }
345
346{other}+ {
347 addstring(true, yytext, yyleng, yyscanner);
348 BEGIN xnq;
349 }
350
351<<EOF>> { yyterminate(); }
352
353%%

Variable Documentation

◆ keywords

const JsonPathKeyword keywords[]
static

Definition at line 402 of file jsonpath_scan.l.

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(), pgfdw_has_required_scram_options(), pgfdw_security_check(), PQconnectdbParams(), PQconnectStartParams(), PQpingParams(), regression_main(), ScanKeywordLookup(), sql_conn(), test_protocol_version(), and vacuumlo().

AltStyle によって変換されたページ (->オリジナル) /