1 /* A Bison parser, made by GNU Bison 3.3.2. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, 6 Inc. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 /* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34 /* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 36 37 /* All symbols defined below should begin with yy or YY, to avoid 38 infringing on user name space. This should be done even for local 39 variables, as they might otherwise be expanded by user macros. 40 There are some unavoidable exceptions within include files to 41 define necessary library symbols; they are noted "INFRINGES ON 42 USER NAME SPACE" below. */ 43 44 /* Undocumented macros, especially those whose name start with YY_, 45 are private implementation details. Do not rely on them. */ 46 47 /* Identify Bison output. */ 48 #define YYBISON 1 49 50 /* Bison version. */ 51 #define YYBISON_VERSION "3.3.2" 52 53 /* Skeleton name. */ 54 #define YYSKELETON_NAME "yacc.c" 55 56 /* Pure parsers. */ 57 #define YYPURE 1 58 59 /* Push parsers. */ 60 #define YYPUSH 0 61 62 /* Pull parsers. */ 63 #define YYPULL 1 64 65 66 /* Substitute the variable and function names. */ 67 #define yyparse jsonpath_yyparse 68 #define yylex jsonpath_yylex 69 #define yyerror jsonpath_yyerror 70 #define yydebug jsonpath_yydebug 71 #define yynerrs jsonpath_yynerrs 72 73 74 /* First part of user prologue. */ 75 #line 1 "jsonpath_gram.y" /* yacc.c:337 */ 76 77 /*------------------------------------------------------------------------- 78 * 79 * jsonpath_gram.y 80 * Grammar definitions for jsonpath datatype 81 * 82 * Transforms tokenized jsonpath into tree of JsonPathParseItem structs. 83 * 84 * Copyright (c) 2019-2020, PostgreSQL Global Development Group 85 * 86 * IDENTIFICATION 87 * src/backend/utils/adt/jsonpath_gram.y 88 * 89 *------------------------------------------------------------------------- 90 */ 91 92 #include "postgres.h" 93 94 #include "catalog/pg_collation.h" 95 #include "fmgr.h" 96 #include "miscadmin.h" 97 #include "nodes/pg_list.h" 98 #include "regex/regex.h" 99 #include "utils/builtins.h" 100 #include "utils/jsonpath.h" 101 102 /* struct JsonPathString is shared between scan and gram */ 103 typedef struct JsonPathString 104 { 105 char *val; 106 int len; 107 int total; 108 } JsonPathString; 109 110 union YYSTYPE; 111 112 /* flex 2.5.4 doesn't bother with a decl for this */ 113 int jsonpath_yylex(union YYSTYPE *yylval_param); 114 int jsonpath_yyparse(JsonPathParseResult **result); 115 void jsonpath_yyerror(JsonPathParseResult **result, const char *message); 116 117 static JsonPathParseItem *makeItemType(JsonPathItemType type); 118 static JsonPathParseItem *makeItemString(JsonPathString *s); 119 static JsonPathParseItem *makeItemVariable(JsonPathString *s); 120 static JsonPathParseItem *makeItemKey(JsonPathString *s); 121 static JsonPathParseItem *makeItemNumeric(JsonPathString *s); 122 static JsonPathParseItem *makeItemBool(bool val); 123 static JsonPathParseItem *makeItemBinary(JsonPathItemType type, 124 JsonPathParseItem *la, 125 JsonPathParseItem *ra); 126 static JsonPathParseItem *makeItemUnary(JsonPathItemType type, 127 JsonPathParseItem *a); 128 static JsonPathParseItem *makeItemList(List *list); 129 static JsonPathParseItem *makeIndexArray(List *list); 130 static JsonPathParseItem *makeAny(int first, int last); 131 static JsonPathParseItem *makeItemLikeRegex(JsonPathParseItem *expr, 132 JsonPathString *pattern, 133 JsonPathString *flags); 134 135 /* 136 * Bison doesn't allocate anything that needs to live across parser calls, 137 * so we can easily have it use palloc instead of malloc. This prevents 138 * memory leaks if we error out during parsing. Note this only works with 139 * bison >= 2.0. However, in bison 1.875 the default is to use alloca() 140 * if possible, so there's not really much problem anyhow, at least if 141 * you're building with gcc. 142 */ 143 #define YYMALLOC palloc 144 #define YYFREE pfree 145 146 147 #line 148 "jsonpath_gram.c" /* yacc.c:337 */ 148 # ifndef YY_NULLPTR 149 # if defined __cplusplus 150 # if 201103L <= __cplusplus 151 # define YY_NULLPTR nullptr 152 # else 153 # define YY_NULLPTR 0 154 # endif 155 # else 156 # define YY_NULLPTR ((void*)0) 157 # endif 158 # endif 159 160 /* Enabling verbose error messages. */ 161 #ifdef YYERROR_VERBOSE 162 # undef YYERROR_VERBOSE 163 # define YYERROR_VERBOSE 1 164 #else 165 # define YYERROR_VERBOSE 1 166 #endif 167 168 169 /* Debug traces. */ 170 #ifndef YYDEBUG 171 # define YYDEBUG 0 172 #endif 173 #if YYDEBUG 174 extern int jsonpath_yydebug; 175 #endif 176 177 /* Token type. */ 178 #ifndef YYTOKENTYPE 179 # define YYTOKENTYPE 180 enum yytokentype 181 { 182 TO_P = 258, 183 NULL_P = 259, 184 TRUE_P = 260, 185 FALSE_P = 261, 186 IS_P = 262, 187 UNKNOWN_P = 263, 188 EXISTS_P = 264, 189 IDENT_P = 265, 190 STRING_P = 266, 191 NUMERIC_P = 267, 192 INT_P = 268, 193 VARIABLE_P = 269, 194 OR_P = 270, 195 AND_P = 271, 196 NOT_P = 272, 197 LESS_P = 273, 198 LESSEQUAL_P = 274, 199 EQUAL_P = 275, 200 NOTEQUAL_P = 276, 201 GREATEREQUAL_P = 277, 202 GREATER_P = 278, 203 ANY_P = 279, 204 STRICT_P = 280, 205 LAX_P = 281, 206 LAST_P = 282, 207 STARTS_P = 283, 208 WITH_P = 284, 209 LIKE_REGEX_P = 285, 210 FLAG_P = 286, 211 ABS_P = 287, 212 SIZE_P = 288, 213 TYPE_P = 289, 214 FLOOR_P = 290, 215 DOUBLE_P = 291, 216 CEILING_P = 292, 217 KEYVALUE_P = 293, 218 DATETIME_P = 294, 219 UMINUS = 295 220 }; 221 #endif 222 223 /* Value type. */ 224 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 225 226 union YYSTYPE 227 { 228 #line 80 "jsonpath_gram.y" /* yacc.c:352 */ 229 230 JsonPathString str; 231 List *elems; /* list of JsonPathParseItem */ 232 List *indexs; /* list of integers */ 233 JsonPathParseItem *value; 234 JsonPathParseResult *result; 235 JsonPathItemType optype; 236 bool boolean; 237 int integer; 238 239 #line 240 "jsonpath_gram.c" /* yacc.c:352 */ 240 }; 241 242 typedef union YYSTYPE YYSTYPE; 243 # define YYSTYPE_IS_TRIVIAL 1 244 # define YYSTYPE_IS_DECLARED 1 245 #endif 246 247 248 249 int jsonpath_yyparse (JsonPathParseResult **result); 250 251 252 253 254 255 #ifdef short 256 # undef short 257 #endif 258 259 #ifdef YYTYPE_UINT8 260 typedef YYTYPE_UINT8 yytype_uint8; 261 #else 262 typedef unsigned char yytype_uint8; 263 #endif 264 265 #ifdef YYTYPE_INT8 266 typedef YYTYPE_INT8 yytype_int8; 267 #else 268 typedef signed char yytype_int8; 269 #endif 270 271 #ifdef YYTYPE_UINT16 272 typedef YYTYPE_UINT16 yytype_uint16; 273 #else 274 typedef unsigned short yytype_uint16; 275 #endif 276 277 #ifdef YYTYPE_INT16 278 typedef YYTYPE_INT16 yytype_int16; 279 #else 280 typedef short yytype_int16; 281 #endif 282 283 #ifndef YYSIZE_T 284 # ifdef __SIZE_TYPE__ 285 # define YYSIZE_T __SIZE_TYPE__ 286 # elif defined size_t 287 # define YYSIZE_T size_t 288 # elif ! defined YYSIZE_T 289 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 290 # define YYSIZE_T size_t 291 # else 292 # define YYSIZE_T unsigned 293 # endif 294 #endif 295 296 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 297 298 #ifndef YY_ 299 # if defined YYENABLE_NLS && YYENABLE_NLS 300 # if ENABLE_NLS 301 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 302 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 303 # endif 304 # endif 305 # ifndef YY_ 306 # define YY_(Msgid) Msgid 307 # endif 308 #endif 309 310 #ifndef YY_ATTRIBUTE 311 # if (defined __GNUC__ \ 312 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 313 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 314 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 315 # else 316 # define YY_ATTRIBUTE(Spec) /* empty */ 317 # endif 318 #endif 319 320 #ifndef YY_ATTRIBUTE_PURE 321 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 322 #endif 323 324 #ifndef YY_ATTRIBUTE_UNUSED 325 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 326 #endif 327 328 /* Suppress unused-variable warnings by "using" E. */ 329 #if ! defined lint || defined __GNUC__ 330 # define YYUSE(E) ((void) (E)) 331 #else 332 # define YYUSE(E) /* empty */ 333 #endif 334 335 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 336 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 337 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 338 _Pragma ("GCC diagnostic push") \ 339 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 340 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 341 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 342 _Pragma ("GCC diagnostic pop") 343 #else 344 # define YY_INITIAL_VALUE(Value) Value 345 #endif 346 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 347 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 348 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 349 #endif 350 #ifndef YY_INITIAL_VALUE 351 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 352 #endif 353 354 355 #if ! defined yyoverflow || YYERROR_VERBOSE 356 357 /* The parser invokes alloca or malloc; define the necessary symbols. */ 358 359 # ifdef YYSTACK_USE_ALLOCA 360 # if YYSTACK_USE_ALLOCA 361 # ifdef __GNUC__ 362 # define YYSTACK_ALLOC __builtin_alloca 363 # elif defined __BUILTIN_VA_ARG_INCR 364 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 365 # elif defined _AIX 366 # define YYSTACK_ALLOC __alloca 367 # elif defined _MSC_VER 368 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 369 # define alloca _alloca 370 # else 371 # define YYSTACK_ALLOC alloca 372 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 373 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 374 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 375 # ifndef EXIT_SUCCESS 376 # define EXIT_SUCCESS 0 377 # endif 378 # endif 379 # endif 380 # endif 381 # endif 382 383 # ifdef YYSTACK_ALLOC 384 /* Pacify GCC's 'empty if-body' warning. */ 385 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 386 # ifndef YYSTACK_ALLOC_MAXIMUM 387 /* The OS might guarantee only one guard page at the bottom of the stack, 388 and a page size can be as small as 4096 bytes. So we cannot safely 389 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 390 to allow for a few compiler-allocated temporary stack slots. */ 391 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 392 # endif 393 # else 394 # define YYSTACK_ALLOC YYMALLOC 395 # define YYSTACK_FREE YYFREE 396 # ifndef YYSTACK_ALLOC_MAXIMUM 397 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 398 # endif 399 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 400 && ! ((defined YYMALLOC || defined malloc) \ 401 && (defined YYFREE || defined free))) 402 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 403 # ifndef EXIT_SUCCESS 404 # define EXIT_SUCCESS 0 405 # endif 406 # endif 407 # ifndef YYMALLOC 408 # define YYMALLOC malloc 409 # if ! defined malloc && ! defined EXIT_SUCCESS 410 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 411 # endif 412 # endif 413 # ifndef YYFREE 414 # define YYFREE free 415 # if ! defined free && ! defined EXIT_SUCCESS 416 void free (void *); /* INFRINGES ON USER NAME SPACE */ 417 # endif 418 # endif 419 # endif 420 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 421 422 423 #if (! defined yyoverflow \ 424 && (! defined __cplusplus \ 425 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 426 427 /* A type that is properly aligned for any stack member. */ 428 union yyalloc 429 { 430 yytype_int16 yyss_alloc; 431 YYSTYPE yyvs_alloc; 432 }; 433 434 /* The size of the maximum gap between one aligned stack and the next. */ 435 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 436 437 /* The size of an array large to enough to hold all stacks, each with 438 N elements. */ 439 # define YYSTACK_BYTES(N) \ 440 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 441 + YYSTACK_GAP_MAXIMUM) 442 443 # define YYCOPY_NEEDED 1 444 445 /* Relocate STACK from its old location to the new one. The 446 local variables YYSIZE and YYSTACKSIZE give the old and new number of 447 elements in the stack, and YYPTR gives the new location of the 448 stack. Advance YYPTR to a properly aligned location for the next 449 stack. */ 450 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 451 do \ 452 { \ 453 YYSIZE_T yynewbytes; \ 454 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 455 Stack = &yyptr->Stack_alloc; \ 456 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 457 yyptr += yynewbytes / sizeof (*yyptr); \ 458 } \ 459 while (0) 460 461 #endif 462 463 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 464 /* Copy COUNT objects from SRC to DST. The source and destination do 465 not overlap. */ 466 # ifndef YYCOPY 467 # if defined __GNUC__ && 1 < __GNUC__ 468 # define YYCOPY(Dst, Src, Count) \ 469 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 470 # else 471 # define YYCOPY(Dst, Src, Count) \ 472 do \ 473 { \ 474 YYSIZE_T yyi; \ 475 for (yyi = 0; yyi < (Count); yyi++) \ 476 (Dst)[yyi] = (Src)[yyi]; \ 477 } \ 478 while (0) 479 # endif 480 # endif 481 #endif /* !YYCOPY_NEEDED */ 482 483 /* YYFINAL -- State number of the termination state. */ 484 #define YYFINAL 5 485 /* YYLAST -- Last index in YYTABLE. */ 486 #define YYLAST 239 487 488 /* YYNTOKENS -- Number of terminals. */ 489 #define YYNTOKENS 57 490 /* YYNNTS -- Number of nonterminals. */ 491 #define YYNNTS 23 492 /* YYNRULES -- Number of rules. */ 493 #define YYNRULES 104 494 /* YYNSTATES -- Number of states. */ 495 #define YYNSTATES 143 496 497 #define YYUNDEFTOK 2 498 #define YYMAXUTOK 295 499 500 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 501 as returned by yylex, with out-of-bounds checking. */ 502 #define YYTRANSLATE(YYX) \ 503 ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 504 505 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 506 as returned by yylex. */ 507 static const yytype_uint8 yytranslate[] = 508 { 509 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 512 2, 2, 2, 2, 2, 2, 48, 44, 2, 2, 513 46, 47, 42, 40, 50, 41, 55, 43, 2, 2, 514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 515 2, 2, 2, 56, 49, 2, 2, 2, 2, 2, 516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 518 2, 51, 2, 52, 2, 2, 2, 2, 2, 2, 519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 521 2, 2, 2, 53, 2, 54, 2, 2, 2, 2, 522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 523 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 535 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 536 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 537 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 538 35, 36, 37, 38, 39, 45 539 }; 540 541 #if YYDEBUG 542 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 543 static const yytype_uint16 yyrline[] = 544 { 545 0, 130, 130, 135, 139, 140, 144, 145, 146, 150, 546 151, 152, 153, 154, 155, 156, 160, 161, 162, 163, 547 164, 165, 169, 170, 174, 175, 176, 177, 178, 179, 548 181, 183, 184, 189, 190, 194, 195, 196, 197, 201, 549 202, 203, 204, 208, 209, 210, 211, 212, 213, 214, 550 215, 216, 220, 221, 225, 226, 230, 231, 235, 236, 551 240, 241, 242, 247, 248, 249, 250, 251, 252, 254, 552 258, 262, 263, 267, 271, 272, 273, 274, 275, 276, 553 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 554 287, 288, 289, 290, 291, 292, 293, 294, 298, 299, 555 300, 301, 302, 303, 304 556 }; 557 #endif 558 559 #if YYDEBUG || YYERROR_VERBOSE || 1 560 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 561 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 562 static const char *const yytname[] = 563 { 564 "$end", "error", "$undefined", "TO_P", "NULL_P", "TRUE_P", "FALSE_P", 565 "IS_P", "UNKNOWN_P", "EXISTS_P", "IDENT_P", "STRING_P", "NUMERIC_P", 566 "INT_P", "VARIABLE_P", "OR_P", "AND_P", "NOT_P", "LESS_P", "LESSEQUAL_P", 567 "EQUAL_P", "NOTEQUAL_P", "GREATEREQUAL_P", "GREATER_P", "ANY_P", 568 "STRICT_P", "LAX_P", "LAST_P", "STARTS_P", "WITH_P", "LIKE_REGEX_P", 569 "FLAG_P", "ABS_P", "SIZE_P", "TYPE_P", "FLOOR_P", "DOUBLE_P", 570 "CEILING_P", "KEYVALUE_P", "DATETIME_P", "'+'", "'-'", "'*'", "'/'", 571 "'%'", "UMINUS", "'('", "')'", "'$'", "'@'", "','", "'['", "']'", "'{'", 572 "'}'", "'.'", "'?'", "$accept", "result", "expr_or_predicate", "mode", 573 "scalar_value", "comp_op", "delimited_predicate", "predicate", 574 "starts_with_initial", "path_primary", "accessor_expr", "expr", 575 "index_elem", "index_list", "array_accessor", "any_level", "any_path", 576 "accessor_op", "datetime_template", "opt_datetime_template", "key", 577 "key_name", "method", YY_NULLPTR 578 }; 579 #endif 580 581 # ifdef YYPRINT 582 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 583 (internal) symbol number NUM (which must be that of a token). */ 584 static const yytype_uint16 yytoknum[] = 585 { 586 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 587 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 588 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 589 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 590 43, 45, 42, 47, 37, 295, 40, 41, 36, 64, 591 44, 91, 93, 123, 125, 46, 63 592 }; 593 # endif 594 595 #define YYPACT_NINF -44 596 597 #define yypact_value_is_default(Yystate) \ 598 (!!((Yystate) == (-44))) 599 600 #define YYTABLE_NINF -105 601 602 #define yytable_value_is_error(Yytable_value) \ 603 0 604 605 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 606 STATE-NUM. */ 607 static const yytype_int16 yypact[] = 608 { 609 7, -44, -44, 18, 51, -44, -44, -44, -44, -43, 610 -44, -44, -44, -44, -3, -44, 114, 114, 51, -44, 611 -44, -44, -44, -44, 10, -44, -35, 195, 114, 51, 612 -44, 51, -44, -44, 14, 165, 51, 51, 68, 140, 613 -9, -44, -44, -44, -44, -44, -44, -44, -44, 37, 614 60, 114, 114, 114, 114, 114, 114, 46, 20, 195, 615 30, 3, -35, 59, -44, 24, -2, -44, -41, -44, 616 -44, -44, -44, -44, -44, -44, -44, -44, 31, -44, 617 -44, -44, -44, -44, -44, -44, 48, 50, 52, 61, 618 67, 69, 78, 83, -44, -44, -44, -44, 84, 51, 619 17, 100, 79, 79, -44, -44, -44, 62, -44, -44, 620 -35, 75, -44, -44, -44, 114, 114, -44, -8, 121, 621 86, 54, -44, -44, -44, 123, -44, 62, -44, -44, 622 -44, -1, -44, -44, 88, -44, -44, -44, -8, -44, 623 -44, 82, -44 624 }; 625 626 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 627 Performed when YYTABLE does not specify something else to do. Zero 628 means the default is an error. */ 629 static const yytype_uint8 yydefact[] = 630 { 631 8, 6, 7, 0, 0, 1, 10, 11, 12, 0, 632 9, 13, 14, 15, 0, 38, 0, 0, 0, 36, 633 37, 2, 35, 24, 5, 39, 43, 4, 0, 0, 634 28, 0, 45, 46, 0, 0, 0, 0, 0, 0, 635 0, 65, 42, 18, 20, 16, 17, 21, 19, 0, 636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 637 0, 22, 44, 27, 26, 0, 52, 54, 0, 76, 638 77, 78, 79, 80, 81, 82, 74, 75, 60, 83, 639 84, 93, 94, 95, 96, 97, 85, 86, 87, 88, 640 89, 90, 92, 91, 64, 66, 63, 73, 0, 0, 641 0, 31, 47, 48, 49, 50, 51, 25, 23, 22, 642 0, 0, 41, 40, 56, 0, 0, 57, 0, 72, 643 0, 0, 33, 34, 30, 0, 29, 53, 55, 58, 644 59, 0, 70, 71, 0, 67, 69, 32, 0, 61, 645 68, 0, 62 646 }; 647 648 /* YYPGOTO[NTERM-NUM]. */ 649 static const yytype_int8 yypgoto[] = 650 { 651 -44, -44, -44, -44, -44, -44, 124, -14, -44, -44, 652 -44, -4, 21, -44, -44, 1, -44, -18, -44, -44, 653 -44, -44, -44 654 }; 655 656 /* YYDEFGOTO[NTERM-NUM]. */ 657 static const yytype_int16 yydefgoto[] = 658 { 659 -1, 3, 21, 4, 22, 56, 23, 24, 124, 25, 660 26, 59, 67, 68, 41, 131, 95, 112, 133, 134, 661 96, 97, 98 662 }; 663 664 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 665 positive, shift that token. If negative, reduce the rule whose 666 number is the opposite. If YYTABLE_NINF, syntax error. */ 667 static const yytype_int16 yytable[] = 668 { 669 27, 115, 138, 28, 34, 129, 9, -3, 42, 116, 670 111, 117, 32, 33, 35, 58, 38, 60, 5, 130, 671 39, 40, 63, 64, 57, 36, 37, 35, 122, 36, 672 37, 123, 1, 2, 66, 36, 37, 99, 51, 52, 673 53, 54, 55, 29, 113, 36, 37, 102, 103, 104, 674 105, 106, 107, 139, 38, 6, 7, 8, 39, 40, 675 9, 61, 10, 11, 12, 13, 100, 109, 14, 36, 676 37, 101, 6, 7, 8, 37, 114, 110, 15, 10, 677 11, 12, 13, 126, 118, 121, 51, 52, 53, 54, 678 55, 16, 17, 108, -98, 15, -99, 18, -100, 19, 679 20, 136, 51, 52, 53, 54, 55, -101, 16, 17, 680 65, 127, 66, -102, 31, -103, 19, 20, 6, 7, 681 8, 53, 54, 55, -104, 10, 11, 12, 13, 119, 682 120, 125, 132, 135, 137, 140, 142, 128, 30, 141, 683 0, 15, 0, 69, 70, 71, 72, 73, 74, 75, 684 76, 77, 0, 0, 16, 17, 0, 0, 0, 0, 685 31, 0, 19, 20, 78, 79, 80, 81, 82, 83, 686 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 687 0, 0, 94, 43, 44, 45, 46, 47, 48, 0, 688 0, 0, 0, 49, 0, 50, 0, 0, 0, 0, 689 0, 0, 0, 0, 0, 51, 52, 53, 54, 55, 690 0, 0, 62, 43, 44, 45, 46, 47, 48, 0, 691 0, 0, 0, 49, 0, 50, 0, 0, 0, 0, 692 0, 0, 0, 0, 0, 51, 52, 53, 54, 55 693 }; 694 695 static const yytype_int16 yycheck[] = 696 { 697 4, 3, 3, 46, 18, 13, 9, 0, 26, 50, 698 7, 52, 16, 17, 18, 29, 51, 31, 0, 27, 699 55, 56, 36, 37, 28, 15, 16, 31, 11, 15, 700 16, 14, 25, 26, 38, 15, 16, 46, 40, 41, 701 42, 43, 44, 46, 62, 15, 16, 51, 52, 53, 702 54, 55, 56, 54, 51, 4, 5, 6, 55, 56, 703 9, 47, 11, 12, 13, 14, 29, 47, 17, 15, 704 16, 11, 4, 5, 6, 16, 52, 47, 27, 11, 705 12, 13, 14, 8, 53, 99, 40, 41, 42, 43, 706 44, 40, 41, 47, 46, 27, 46, 46, 46, 48, 707 49, 47, 40, 41, 42, 43, 44, 46, 40, 41, 708 42, 115, 116, 46, 46, 46, 48, 49, 4, 5, 709 6, 42, 43, 44, 46, 11, 12, 13, 14, 46, 710 46, 31, 11, 47, 11, 47, 54, 116, 14, 138, 711 -1, 27, -1, 3, 4, 5, 6, 7, 8, 9, 712 10, 11, -1, -1, 40, 41, -1, -1, -1, -1, 713 46, -1, 48, 49, 24, 25, 26, 27, 28, 29, 714 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 715 -1, -1, 42, 18, 19, 20, 21, 22, 23, -1, 716 -1, -1, -1, 28, -1, 30, -1, -1, -1, -1, 717 -1, -1, -1, -1, -1, 40, 41, 42, 43, 44, 718 -1, -1, 47, 18, 19, 20, 21, 22, 23, -1, 719 -1, -1, -1, 28, -1, 30, -1, -1, -1, -1, 720 -1, -1, -1, -1, -1, 40, 41, 42, 43, 44 721 }; 722 723 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 724 symbol of state STATE-NUM. */ 725 static const yytype_uint8 yystos[] = 726 { 727 0, 25, 26, 58, 60, 0, 4, 5, 6, 9, 728 11, 12, 13, 14, 17, 27, 40, 41, 46, 48, 729 49, 59, 61, 63, 64, 66, 67, 68, 46, 46, 730 63, 46, 68, 68, 64, 68, 15, 16, 51, 55, 731 56, 71, 74, 18, 19, 20, 21, 22, 23, 28, 732 30, 40, 41, 42, 43, 44, 62, 68, 64, 68, 733 64, 47, 47, 64, 64, 42, 68, 69, 70, 3, 734 4, 5, 6, 7, 8, 9, 10, 11, 24, 25, 735 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 736 36, 37, 38, 39, 42, 73, 77, 78, 79, 46, 737 29, 11, 68, 68, 68, 68, 68, 68, 47, 47, 738 47, 7, 74, 74, 52, 3, 50, 52, 53, 46, 739 46, 64, 11, 14, 65, 31, 8, 68, 69, 13, 740 27, 72, 11, 75, 76, 47, 47, 11, 3, 54, 741 47, 72, 54 742 }; 743 744 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 745 static const yytype_uint8 yyr1[] = 746 { 747 0, 57, 58, 58, 59, 59, 60, 60, 60, 61, 748 61, 61, 61, 61, 61, 61, 62, 62, 62, 62, 749 62, 62, 63, 63, 64, 64, 64, 64, 64, 64, 750 64, 64, 64, 65, 65, 66, 66, 66, 66, 67, 751 67, 67, 67, 68, 68, 68, 68, 68, 68, 68, 752 68, 68, 69, 69, 70, 70, 71, 71, 72, 72, 753 73, 73, 73, 74, 74, 74, 74, 74, 74, 74, 754 75, 76, 76, 77, 78, 78, 78, 78, 78, 78, 755 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 756 78, 78, 78, 78, 78, 78, 78, 78, 79, 79, 757 79, 79, 79, 79, 79 758 }; 759 760 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 761 static const yytype_uint8 yyr2[] = 762 { 763 0, 2, 2, 0, 1, 1, 1, 1, 0, 1, 764 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 765 1, 1, 3, 4, 1, 3, 3, 3, 2, 5, 766 4, 3, 5, 1, 1, 1, 1, 1, 1, 1, 767 4, 4, 2, 1, 3, 2, 2, 3, 3, 3, 768 3, 3, 1, 3, 1, 3, 3, 3, 1, 1, 769 1, 4, 6, 2, 2, 1, 2, 4, 5, 4, 770 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 771 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 772 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 773 1, 1, 1, 1, 1 774 }; 775 776 777 #define yyerrok (yyerrstatus = 0) 778 #define yyclearin (yychar = YYEMPTY) 779 #define YYEMPTY (-2) 780 #define YYEOF 0 781 782 #define YYACCEPT goto yyacceptlab 783 #define YYABORT goto yyabortlab 784 #define YYERROR goto yyerrorlab 785 786 787 #define YYRECOVERING() (!!yyerrstatus) 788 789 #define YYBACKUP(Token, Value) \ 790 do \ 791 if (yychar == YYEMPTY) \ 792 { \ 793 yychar = (Token); \ 794 yylval = (Value); \ 795 YYPOPSTACK (yylen); \ 796 yystate = *yyssp; \ 797 goto yybackup; \ 798 } \ 799 else \ 800 { \ 801 yyerror (result, YY_("syntax error: cannot back up")); \ 802 YYERROR; \ 803 } \ 804 while (0) 805 806 /* Error token number */ 807 #define YYTERROR 1 808 #define YYERRCODE 256 809 810 811 812 /* Enable debugging if requested. */ 813 #if YYDEBUG 814 815 # ifndef YYFPRINTF 816 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 817 # define YYFPRINTF fprintf 818 # endif 819 820 # define YYDPRINTF(Args) \ 821 do { \ 822 if (yydebug) \ 823 YYFPRINTF Args; \ 824 } while (0) 825 826 /* This macro is provided for backward compatibility. */ 827 #ifndef YY_LOCATION_PRINT 828 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 829 #endif 830 831 832 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 833 do { \ 834 if (yydebug) \ 835 { \ 836 YYFPRINTF (stderr, "%s ", Title); \ 837 yy_symbol_print (stderr, \ 838 Type, Value, result); \ 839 YYFPRINTF (stderr, "\n"); \ 840 } \ 841 } while (0) 842 843 844 /*-----------------------------------. 845 | Print this symbol's value on YYO. | 846 `-----------------------------------*/ 847 848 static void 849 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, JsonPathParseResult **result) 850 { 851 FILE *yyoutput = yyo; 852 YYUSE (yyoutput); 853 YYUSE (result); 854 if (!yyvaluep) 855 return; 856 # ifdef YYPRINT 857 if (yytype < YYNTOKENS) 858 YYPRINT (yyo, yytoknum[yytype], *yyvaluep); 859 # endif 860 YYUSE (yytype); 861 } 862 863 864 /*---------------------------. 865 | Print this symbol on YYO. | 866 `---------------------------*/ 867 868 static void 869 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, JsonPathParseResult **result) 870 { 871 YYFPRINTF (yyo, "%s %s (", 872 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 873 874 yy_symbol_value_print (yyo, yytype, yyvaluep, result); 875 YYFPRINTF (yyo, ")"); 876 } 877 878 /*------------------------------------------------------------------. 879 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 880 | TOP (included). | 881 `------------------------------------------------------------------*/ 882 883 static void 884 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 885 { 886 YYFPRINTF (stderr, "Stack now"); 887 for (; yybottom <= yytop; yybottom++) 888 { 889 int yybot = *yybottom; 890 YYFPRINTF (stderr, " %d", yybot); 891 } 892 YYFPRINTF (stderr, "\n"); 893 } 894 895 # define YY_STACK_PRINT(Bottom, Top) \ 896 do { \ 897 if (yydebug) \ 898 yy_stack_print ((Bottom), (Top)); \ 899 } while (0) 900 901 902 /*------------------------------------------------. 903 | Report that the YYRULE is going to be reduced. | 904 `------------------------------------------------*/ 905 906 static void 907 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, JsonPathParseResult **result) 908 { 909 unsigned long yylno = yyrline[yyrule]; 910 int yynrhs = yyr2[yyrule]; 911 int yyi; 912 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 913 yyrule - 1, yylno); 914 /* The symbols being reduced. */ 915 for (yyi = 0; yyi < yynrhs; yyi++) 916 { 917 YYFPRINTF (stderr, " $%d = ", yyi + 1); 918 yy_symbol_print (stderr, 919 yystos[yyssp[yyi + 1 - yynrhs]], 920 &yyvsp[(yyi + 1) - (yynrhs)] 921 , result); 922 YYFPRINTF (stderr, "\n"); 923 } 924 } 925 926 # define YY_REDUCE_PRINT(Rule) \ 927 do { \ 928 if (yydebug) \ 929 yy_reduce_print (yyssp, yyvsp, Rule, result); \ 930 } while (0) 931 932 /* Nonzero means print parse trace. It is left uninitialized so that 933 multiple parsers can coexist. */ 934 int yydebug; 935 #else /* !YYDEBUG */ 936 # define YYDPRINTF(Args) 937 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 938 # define YY_STACK_PRINT(Bottom, Top) 939 # define YY_REDUCE_PRINT(Rule) 940 #endif /* !YYDEBUG */ 941 942 943 /* YYINITDEPTH -- initial size of the parser's stacks. */ 944 #ifndef YYINITDEPTH 945 # define YYINITDEPTH 200 946 #endif 947 948 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 949 if the built-in stack extension method is used). 950 951 Do not make this value too large; the results are undefined if 952 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 953 evaluated with infinite-precision integer arithmetic. */ 954 955 #ifndef YYMAXDEPTH 956 # define YYMAXDEPTH 10000 957 #endif 958 959 960 #if YYERROR_VERBOSE 961 962 # ifndef yystrlen 963 # if defined __GLIBC__ && defined _STRING_H 964 # define yystrlen strlen 965 # else 966 /* Return the length of YYSTR. */ 967 static YYSIZE_T 968 yystrlen (const char *yystr) 969 { 970 YYSIZE_T yylen; 971 for (yylen = 0; yystr[yylen]; yylen++) 972 continue; 973 return yylen; 974 } 975 # endif 976 # endif 977 978 # ifndef yystpcpy 979 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 980 # define yystpcpy stpcpy 981 # else 982 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 983 YYDEST. */ 984 static char * 985 yystpcpy (char *yydest, const char *yysrc) 986 { 987 char *yyd = yydest; 988 const char *yys = yysrc; 989 990 while ((*yyd++ = *yys++) != '\0') 991 continue; 992 993 return yyd - 1; 994 } 995 # endif 996 # endif 997 998 # ifndef yytnamerr 999 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1000 quotes and backslashes, so that it's suitable for yyerror. The 1001 heuristic is that double-quoting is unnecessary unless the string 1002 contains an apostrophe, a comma, or backslash (other than 1003 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1004 null, do not copy; instead, return the length of what the result 1005 would have been. */ 1006 static YYSIZE_T 1007 yytnamerr (char *yyres, const char *yystr) 1008 { 1009 if (*yystr == '"') 1010 { 1011 YYSIZE_T yyn = 0; 1012 char const *yyp = yystr; 1013 1014 for (;;) 1015 switch (*++yyp) 1016 { 1017 case '\'': 1018 case ',': 1019 goto do_not_strip_quotes; 1020 1021 case '\\': 1022 if (*++yyp != '\\') 1023 goto do_not_strip_quotes; 1024 else 1025 goto append; 1026 1027 append: 1028 default: 1029 if (yyres) 1030 yyres[yyn] = *yyp; 1031 yyn++; 1032 break; 1033 1034 case '"': 1035 if (yyres) 1036 yyres[yyn] = '\0'; 1037 return yyn; 1038 } 1039 do_not_strip_quotes: ; 1040 } 1041 1042 if (! yyres) 1043 return yystrlen (yystr); 1044 1045 return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); 1046 } 1047 # endif 1048 1049 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1050 about the unexpected token YYTOKEN for the state stack whose top is 1051 YYSSP. 1052 1053 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1054 not large enough to hold the message. In that case, also set 1055 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1056 required number of bytes is too large to store. */ 1057 static int 1058 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1059 yytype_int16 *yyssp, int yytoken) 1060 { 1061 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 1062 YYSIZE_T yysize = yysize0; 1063 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1064 /* Internationalized format string. */ 1065 const char *yyformat = YY_NULLPTR; 1066 /* Arguments of yyformat. */ 1067 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1068 /* Number of reported tokens (one for the "unexpected", one per 1069 "expected"). */ 1070 int yycount = 0; 1071 1072 /* There are many possibilities here to consider: 1073 - If this state is a consistent state with a default action, then 1074 the only way this function was invoked is if the default action 1075 is an error action. In that case, don't check for expected 1076 tokens because there are none. 1077 - The only way there can be no lookahead present (in yychar) is if 1078 this state is a consistent state with a default action. Thus, 1079 detecting the absence of a lookahead is sufficient to determine 1080 that there is no unexpected or expected token to report. In that 1081 case, just report a simple "syntax error". 1082 - Don't assume there isn't a lookahead just because this state is a 1083 consistent state with a default action. There might have been a 1084 previous inconsistent state, consistent state with a non-default 1085 action, or user semantic action that manipulated yychar. 1086 - Of course, the expected token list depends on states to have 1087 correct lookahead information, and it depends on the parser not 1088 to perform extra reductions after fetching a lookahead from the 1089 scanner and before detecting a syntax error. Thus, state merging 1090 (from LALR or IELR) and default reductions corrupt the expected 1091 token list. However, the list is correct for canonical LR with 1092 one exception: it will still contain any token that will not be 1093 accepted due to an error action in a later state. 1094 */ 1095 if (yytoken != YYEMPTY) 1096 { 1097 int yyn = yypact[*yyssp]; 1098 yyarg[yycount++] = yytname[yytoken]; 1099 if (!yypact_value_is_default (yyn)) 1100 { 1101 /* Start YYX at -YYN if negative to avoid negative indexes in 1102 YYCHECK. In other words, skip the first -YYN actions for 1103 this state because they are default actions. */ 1104 int yyxbegin = yyn < 0 ? -yyn : 0; 1105 /* Stay within bounds of both yycheck and yytname. */ 1106 int yychecklim = YYLAST - yyn + 1; 1107 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1108 int yyx; 1109 1110 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1111 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1112 && !yytable_value_is_error (yytable[yyx + yyn])) 1113 { 1114 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1115 { 1116 yycount = 1; 1117 yysize = yysize0; 1118 break; 1119 } 1120 yyarg[yycount++] = yytname[yyx]; 1121 { 1122 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1123 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) 1124 yysize = yysize1; 1125 else 1126 return 2; 1127 } 1128 } 1129 } 1130 } 1131 1132 switch (yycount) 1133 { 1134 # define YYCASE_(N, S) \ 1135 case N: \ 1136 yyformat = S; \ 1137 break 1138 default: /* Avoid compiler warnings. */ 1139 YYCASE_(0, YY_("syntax error")); 1140 YYCASE_(1, YY_("syntax error, unexpected %s")); 1141 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1142 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1143 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1144 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1145 # undef YYCASE_ 1146 } 1147 1148 { 1149 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1150 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) 1151 yysize = yysize1; 1152 else 1153 return 2; 1154 } 1155 1156 if (*yymsg_alloc < yysize) 1157 { 1158 *yymsg_alloc = 2 * yysize; 1159 if (! (yysize <= *yymsg_alloc 1160 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1161 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1162 return 1; 1163 } 1164 1165 /* Avoid sprintf, as that infringes on the user's name space. 1166 Don't have undefined behavior even if the translation 1167 produced a string with the wrong number of "%s"s. */ 1168 { 1169 char *yyp = *yymsg; 1170 int yyi = 0; 1171 while ((*yyp = *yyformat) != '\0') 1172 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1173 { 1174 yyp += yytnamerr (yyp, yyarg[yyi++]); 1175 yyformat += 2; 1176 } 1177 else 1178 { 1179 yyp++; 1180 yyformat++; 1181 } 1182 } 1183 return 0; 1184 } 1185 #endif /* YYERROR_VERBOSE */ 1186 1187 /*-----------------------------------------------. 1188 | Release the memory associated to this symbol. | 1189 `-----------------------------------------------*/ 1190 1191 static void 1192 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, JsonPathParseResult **result) 1193 { 1194 YYUSE (yyvaluep); 1195 YYUSE (result); 1196 if (!yymsg) 1197 yymsg = "Deleting"; 1198 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1199 1200 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1201 YYUSE (yytype); 1202 YY_IGNORE_MAYBE_UNINITIALIZED_END 1203 } 1204 1205 1206 1207 1208 /*----------. 1209 | yyparse. | 1210 `----------*/ 1211 1212 int 1213 yyparse (JsonPathParseResult **result) 1214 { 1215 /* The lookahead symbol. */ 1216 int yychar; 1217 1218 1219 /* The semantic value of the lookahead symbol. */ 1220 /* Default value used for initialization, for pacifying older GCCs 1221 or non-GCC compilers. */ 1222 YY_INITIAL_VALUE (static YYSTYPE yyval_default;) 1223 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); 1224 1225 /* Number of syntax errors so far. */ 1226 int yynerrs; 1227 1228 int yystate; 1229 /* Number of tokens to shift before error messages enabled. */ 1230 int yyerrstatus; 1231 1232 /* The stacks and their tools: 1233 'yyss': related to states. 1234 'yyvs': related to semantic values. 1235 1236 Refer to the stacks through separate pointers, to allow yyoverflow 1237 to reallocate them elsewhere. */ 1238 1239 /* The state stack. */ 1240 yytype_int16 yyssa[YYINITDEPTH]; 1241 yytype_int16 *yyss; 1242 yytype_int16 *yyssp; 1243 1244 /* The semantic value stack. */ 1245 YYSTYPE yyvsa[YYINITDEPTH]; 1246 YYSTYPE *yyvs; 1247 YYSTYPE *yyvsp; 1248 1249 YYSIZE_T yystacksize; 1250 1251 int yyn; 1252 int yyresult; 1253 /* Lookahead token as an internal (translated) token number. */ 1254 int yytoken = 0; 1255 /* The variables used to return semantic value and location from the 1256 action routines. */ 1257 YYSTYPE yyval; 1258 1259 #if YYERROR_VERBOSE 1260 /* Buffer for error messages, and its allocated size. */ 1261 char yymsgbuf[128]; 1262 char *yymsg = yymsgbuf; 1263 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1264 #endif 1265 1266 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1267 1268 /* The number of symbols on the RHS of the reduced rule. 1269 Keep to zero when no symbol should be popped. */ 1270 int yylen = 0; 1271 1272 yyssp = yyss = yyssa; 1273 yyvsp = yyvs = yyvsa; 1274 yystacksize = YYINITDEPTH; 1275 1276 YYDPRINTF ((stderr, "Starting parse\n")); 1277 1278 yystate = 0; 1279 yyerrstatus = 0; 1280 yynerrs = 0; 1281 yychar = YYEMPTY; /* Cause a token to be read. */ 1282 goto yysetstate; 1283 1284 1285 /*------------------------------------------------------------. 1286 | yynewstate -- push a new state, which is found in yystate. | 1287 `------------------------------------------------------------*/ 1288 yynewstate: 1289 /* In all cases, when you get here, the value and location stacks 1290 have just been pushed. So pushing a state here evens the stacks. */ 1291 yyssp++; 1292 1293 1294 /*--------------------------------------------------------------------. 1295 | yynewstate -- set current state (the top of the stack) to yystate. | 1296 `--------------------------------------------------------------------*/ 1297 yysetstate: 1298 *yyssp = (yytype_int16) yystate; 1299 1300 if (yyss + yystacksize - 1 <= yyssp) 1301 #if !defined yyoverflow && !defined YYSTACK_RELOCATE 1302 goto yyexhaustedlab; 1303 #else 1304 { 1305 /* Get the current used size of the three stacks, in elements. */ 1306 YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); 1307 1308 # if defined yyoverflow 1309 { 1310 /* Give user a chance to reallocate the stack. Use copies of 1311 these so that the &'s don't force the real ones into 1312 memory. */ 1313 YYSTYPE *yyvs1 = yyvs; 1314 yytype_int16 *yyss1 = yyss; 1315 1316 /* Each stack pointer address is followed by the size of the 1317 data in use in that stack, in bytes. This used to be a 1318 conditional around just the two extra args, but that might 1319 be undefined if yyoverflow is a macro. */ 1320 yyoverflow (YY_("memory exhausted"), 1321 &yyss1, yysize * sizeof (*yyssp), 1322 &yyvs1, yysize * sizeof (*yyvsp), 1323 &yystacksize); 1324 yyss = yyss1; 1325 yyvs = yyvs1; 1326 } 1327 # else /* defined YYSTACK_RELOCATE */ 1328 /* Extend the stack our own way. */ 1329 if (YYMAXDEPTH <= yystacksize) 1330 goto yyexhaustedlab; 1331 yystacksize *= 2; 1332 if (YYMAXDEPTH < yystacksize) 1333 yystacksize = YYMAXDEPTH; 1334 1335 { 1336 yytype_int16 *yyss1 = yyss; 1337 union yyalloc *yyptr = 1338 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1339 if (! yyptr) 1340 goto yyexhaustedlab; 1341 YYSTACK_RELOCATE (yyss_alloc, yyss); 1342 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1343 # undef YYSTACK_RELOCATE 1344 if (yyss1 != yyssa) 1345 YYSTACK_FREE (yyss1); 1346 } 1347 # endif 1348 1349 yyssp = yyss + yysize - 1; 1350 yyvsp = yyvs + yysize - 1; 1351 1352 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1353 (unsigned long) yystacksize)); 1354 1355 if (yyss + yystacksize - 1 <= yyssp) 1356 YYABORT; 1357 } 1358 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1359 1360 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1361 1362 if (yystate == YYFINAL) 1363 YYACCEPT; 1364 1365 goto yybackup; 1366 1367 1368 /*-----------. 1369 | yybackup. | 1370 `-----------*/ 1371 yybackup: 1372 /* Do appropriate processing given the current state. Read a 1373 lookahead token if we need one and don't already have one. */ 1374 1375 /* First try to decide what to do without reference to lookahead token. */ 1376 yyn = yypact[yystate]; 1377 if (yypact_value_is_default (yyn)) 1378 goto yydefault; 1379 1380 /* Not known => get a lookahead token if don't already have one. */ 1381 1382 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1383 if (yychar == YYEMPTY) 1384 { 1385 YYDPRINTF ((stderr, "Reading a token: ")); 1386 yychar = yylex (&yylval); 1387 } 1388 1389 if (yychar <= YYEOF) 1390 { 1391 yychar = yytoken = YYEOF; 1392 YYDPRINTF ((stderr, "Now at end of input.\n")); 1393 } 1394 else 1395 { 1396 yytoken = YYTRANSLATE (yychar); 1397 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1398 } 1399 1400 /* If the proper action on seeing token YYTOKEN is to reduce or to 1401 detect an error, take that action. */ 1402 yyn += yytoken; 1403 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1404 goto yydefault; 1405 yyn = yytable[yyn]; 1406 if (yyn <= 0) 1407 { 1408 if (yytable_value_is_error (yyn)) 1409 goto yyerrlab; 1410 yyn = -yyn; 1411 goto yyreduce; 1412 } 1413 1414 /* Count tokens shifted since error; after three, turn off error 1415 status. */ 1416 if (yyerrstatus) 1417 yyerrstatus--; 1418 1419 /* Shift the lookahead token. */ 1420 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1421 1422 /* Discard the shifted token. */ 1423 yychar = YYEMPTY; 1424 1425 yystate = yyn; 1426 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1427 *++yyvsp = yylval; 1428 YY_IGNORE_MAYBE_UNINITIALIZED_END 1429 1430 goto yynewstate; 1431 1432 1433 /*-----------------------------------------------------------. 1434 | yydefault -- do the default action for the current state. | 1435 `-----------------------------------------------------------*/ 1436 yydefault: 1437 yyn = yydefact[yystate]; 1438 if (yyn == 0) 1439 goto yyerrlab; 1440 goto yyreduce; 1441 1442 1443 /*-----------------------------. 1444 | yyreduce -- do a reduction. | 1445 `-----------------------------*/ 1446 yyreduce: 1447 /* yyn is the number of a rule to reduce with. */ 1448 yylen = yyr2[yyn]; 1449 1450 /* If YYLEN is nonzero, implement the default value of the action: 1451 '$$ = $1'. 1452 1453 Otherwise, the following line sets YYVAL to garbage. 1454 This behavior is undocumented and Bison 1455 users should not rely upon it. Assigning to YYVAL 1456 unconditionally makes the parser a bit smaller, and it avoids a 1457 GCC warning that YYVAL may be used uninitialized. */ 1458 yyval = yyvsp[1-yylen]; 1459 1460 1461 YY_REDUCE_PRINT (yyn); 1462 switch (yyn) 1463 { 1464 case 2: 1465 #line 130 "jsonpath_gram.y" /* yacc.c:1652 */ 1466 { 1467 *result = palloc(sizeof(JsonPathParseResult)); 1468 (*result)->expr = (yyvsp[0].value); 1469 (*result)->lax = (yyvsp[-1].boolean); 1470 } 1471 #line 1472 "jsonpath_gram.c" /* yacc.c:1652 */ 1472 break; 1473 1474 case 3: 1475 #line 135 "jsonpath_gram.y" /* yacc.c:1652 */ 1476 { *result = NULL; } 1477 #line 1478 "jsonpath_gram.c" /* yacc.c:1652 */ 1478 break; 1479 1480 case 4: 1481 #line 139 "jsonpath_gram.y" /* yacc.c:1652 */ 1482 { (yyval.value) = (yyvsp[0].value); } 1483 #line 1484 "jsonpath_gram.c" /* yacc.c:1652 */ 1484 break; 1485 1486 case 5: 1487 #line 140 "jsonpath_gram.y" /* yacc.c:1652 */ 1488 { (yyval.value) = (yyvsp[0].value); } 1489 #line 1490 "jsonpath_gram.c" /* yacc.c:1652 */ 1490 break; 1491 1492 case 6: 1493 #line 144 "jsonpath_gram.y" /* yacc.c:1652 */ 1494 { (yyval.boolean) = false; } 1495 #line 1496 "jsonpath_gram.c" /* yacc.c:1652 */ 1496 break; 1497 1498 case 7: 1499 #line 145 "jsonpath_gram.y" /* yacc.c:1652 */ 1500 { (yyval.boolean) = true; } 1501 #line 1502 "jsonpath_gram.c" /* yacc.c:1652 */ 1502 break; 1503 1504 case 8: 1505 #line 146 "jsonpath_gram.y" /* yacc.c:1652 */ 1506 { (yyval.boolean) = true; } 1507 #line 1508 "jsonpath_gram.c" /* yacc.c:1652 */ 1508 break; 1509 1510 case 9: 1511 #line 150 "jsonpath_gram.y" /* yacc.c:1652 */ 1512 { (yyval.value) = makeItemString(&(yyvsp[0].str)); } 1513 #line 1514 "jsonpath_gram.c" /* yacc.c:1652 */ 1514 break; 1515 1516 case 10: 1517 #line 151 "jsonpath_gram.y" /* yacc.c:1652 */ 1518 { (yyval.value) = makeItemString(NULL); } 1519 #line 1520 "jsonpath_gram.c" /* yacc.c:1652 */ 1520 break; 1521 1522 case 11: 1523 #line 152 "jsonpath_gram.y" /* yacc.c:1652 */ 1524 { (yyval.value) = makeItemBool(true); } 1525 #line 1526 "jsonpath_gram.c" /* yacc.c:1652 */ 1526 break; 1527 1528 case 12: 1529 #line 153 "jsonpath_gram.y" /* yacc.c:1652 */ 1530 { (yyval.value) = makeItemBool(false); } 1531 #line 1532 "jsonpath_gram.c" /* yacc.c:1652 */ 1532 break; 1533 1534 case 13: 1535 #line 154 "jsonpath_gram.y" /* yacc.c:1652 */ 1536 { (yyval.value) = makeItemNumeric(&(yyvsp[0].str)); } 1537 #line 1538 "jsonpath_gram.c" /* yacc.c:1652 */ 1538 break; 1539 1540 case 14: 1541 #line 155 "jsonpath_gram.y" /* yacc.c:1652 */ 1542 { (yyval.value) = makeItemNumeric(&(yyvsp[0].str)); } 1543 #line 1544 "jsonpath_gram.c" /* yacc.c:1652 */ 1544 break; 1545 1546 case 15: 1547 #line 156 "jsonpath_gram.y" /* yacc.c:1652 */ 1548 { (yyval.value) = makeItemVariable(&(yyvsp[0].str)); } 1549 #line 1550 "jsonpath_gram.c" /* yacc.c:1652 */ 1550 break; 1551 1552 case 16: 1553 #line 160 "jsonpath_gram.y" /* yacc.c:1652 */ 1554 { (yyval.optype) = jpiEqual; } 1555 #line 1556 "jsonpath_gram.c" /* yacc.c:1652 */ 1556 break; 1557 1558 case 17: 1559 #line 161 "jsonpath_gram.y" /* yacc.c:1652 */ 1560 { (yyval.optype) = jpiNotEqual; } 1561 #line 1562 "jsonpath_gram.c" /* yacc.c:1652 */ 1562 break; 1563 1564 case 18: 1565 #line 162 "jsonpath_gram.y" /* yacc.c:1652 */ 1566 { (yyval.optype) = jpiLess; } 1567 #line 1568 "jsonpath_gram.c" /* yacc.c:1652 */ 1568 break; 1569 1570 case 19: 1571 #line 163 "jsonpath_gram.y" /* yacc.c:1652 */ 1572 { (yyval.optype) = jpiGreater; } 1573 #line 1574 "jsonpath_gram.c" /* yacc.c:1652 */ 1574 break; 1575 1576 case 20: 1577 #line 164 "jsonpath_gram.y" /* yacc.c:1652 */ 1578 { (yyval.optype) = jpiLessOrEqual; } 1579 #line 1580 "jsonpath_gram.c" /* yacc.c:1652 */ 1580 break; 1581 1582 case 21: 1583 #line 165 "jsonpath_gram.y" /* yacc.c:1652 */ 1584 { (yyval.optype) = jpiGreaterOrEqual; } 1585 #line 1586 "jsonpath_gram.c" /* yacc.c:1652 */ 1586 break; 1587 1588 case 22: 1589 #line 169 "jsonpath_gram.y" /* yacc.c:1652 */ 1590 { (yyval.value) = (yyvsp[-1].value); } 1591 #line 1592 "jsonpath_gram.c" /* yacc.c:1652 */ 1592 break; 1593 1594 case 23: 1595 #line 170 "jsonpath_gram.y" /* yacc.c:1652 */ 1596 { (yyval.value) = makeItemUnary(jpiExists, (yyvsp[-1].value)); } 1597 #line 1598 "jsonpath_gram.c" /* yacc.c:1652 */ 1598 break; 1599 1600 case 24: 1601 #line 174 "jsonpath_gram.y" /* yacc.c:1652 */ 1602 { (yyval.value) = (yyvsp[0].value); } 1603 #line 1604 "jsonpath_gram.c" /* yacc.c:1652 */ 1604 break; 1605 1606 case 25: 1607 #line 175 "jsonpath_gram.y" /* yacc.c:1652 */ 1608 { (yyval.value) = makeItemBinary((yyvsp[-1].optype), (yyvsp[-2].value), (yyvsp[0].value)); } 1609 #line 1610 "jsonpath_gram.c" /* yacc.c:1652 */ 1610 break; 1611 1612 case 26: 1613 #line 176 "jsonpath_gram.y" /* yacc.c:1652 */ 1614 { (yyval.value) = makeItemBinary(jpiAnd, (yyvsp[-2].value), (yyvsp[0].value)); } 1615 #line 1616 "jsonpath_gram.c" /* yacc.c:1652 */ 1616 break; 1617 1618 case 27: 1619 #line 177 "jsonpath_gram.y" /* yacc.c:1652 */ 1620 { (yyval.value) = makeItemBinary(jpiOr, (yyvsp[-2].value), (yyvsp[0].value)); } 1621 #line 1622 "jsonpath_gram.c" /* yacc.c:1652 */ 1622 break; 1623 1624 case 28: 1625 #line 178 "jsonpath_gram.y" /* yacc.c:1652 */ 1626 { (yyval.value) = makeItemUnary(jpiNot, (yyvsp[0].value)); } 1627 #line 1628 "jsonpath_gram.c" /* yacc.c:1652 */ 1628 break; 1629 1630 case 29: 1631 #line 180 "jsonpath_gram.y" /* yacc.c:1652 */ 1632 { (yyval.value) = makeItemUnary(jpiIsUnknown, (yyvsp[-3].value)); } 1633 #line 1634 "jsonpath_gram.c" /* yacc.c:1652 */ 1634 break; 1635 1636 case 30: 1637 #line 182 "jsonpath_gram.y" /* yacc.c:1652 */ 1638 { (yyval.value) = makeItemBinary(jpiStartsWith, (yyvsp[-3].value), (yyvsp[0].value)); } 1639 #line 1640 "jsonpath_gram.c" /* yacc.c:1652 */ 1640 break; 1641 1642 case 31: 1643 #line 183 "jsonpath_gram.y" /* yacc.c:1652 */ 1644 { (yyval.value) = makeItemLikeRegex((yyvsp[-2].value), &(yyvsp[0].str), NULL); } 1645 #line 1646 "jsonpath_gram.c" /* yacc.c:1652 */ 1646 break; 1647 1648 case 32: 1649 #line 185 "jsonpath_gram.y" /* yacc.c:1652 */ 1650 { (yyval.value) = makeItemLikeRegex((yyvsp[-4].value), &(yyvsp[-2].str), &(yyvsp[0].str)); } 1651 #line 1652 "jsonpath_gram.c" /* yacc.c:1652 */ 1652 break; 1653 1654 case 33: 1655 #line 189 "jsonpath_gram.y" /* yacc.c:1652 */ 1656 { (yyval.value) = makeItemString(&(yyvsp[0].str)); } 1657 #line 1658 "jsonpath_gram.c" /* yacc.c:1652 */ 1658 break; 1659 1660 case 34: 1661 #line 190 "jsonpath_gram.y" /* yacc.c:1652 */ 1662 { (yyval.value) = makeItemVariable(&(yyvsp[0].str)); } 1663 #line 1664 "jsonpath_gram.c" /* yacc.c:1652 */ 1664 break; 1665 1666 case 35: 1667 #line 194 "jsonpath_gram.y" /* yacc.c:1652 */ 1668 { (yyval.value) = (yyvsp[0].value); } 1669 #line 1670 "jsonpath_gram.c" /* yacc.c:1652 */ 1670 break; 1671 1672 case 36: 1673 #line 195 "jsonpath_gram.y" /* yacc.c:1652 */ 1674 { (yyval.value) = makeItemType(jpiRoot); } 1675 #line 1676 "jsonpath_gram.c" /* yacc.c:1652 */ 1676 break; 1677 1678 case 37: 1679 #line 196 "jsonpath_gram.y" /* yacc.c:1652 */ 1680 { (yyval.value) = makeItemType(jpiCurrent); } 1681 #line 1682 "jsonpath_gram.c" /* yacc.c:1652 */ 1682 break; 1683 1684 case 38: 1685 #line 197 "jsonpath_gram.y" /* yacc.c:1652 */ 1686 { (yyval.value) = makeItemType(jpiLast); } 1687 #line 1688 "jsonpath_gram.c" /* yacc.c:1652 */ 1688 break; 1689 1690 case 39: 1691 #line 201 "jsonpath_gram.y" /* yacc.c:1652 */ 1692 { (yyval.elems) = list_make1((yyvsp[0].value)); } 1693 #line 1694 "jsonpath_gram.c" /* yacc.c:1652 */ 1694 break; 1695 1696 case 40: 1697 #line 202 "jsonpath_gram.y" /* yacc.c:1652 */ 1698 { (yyval.elems) = list_make2((yyvsp[-2].value), (yyvsp[0].value)); } 1699 #line 1700 "jsonpath_gram.c" /* yacc.c:1652 */ 1700 break; 1701 1702 case 41: 1703 #line 203 "jsonpath_gram.y" /* yacc.c:1652 */ 1704 { (yyval.elems) = list_make2((yyvsp[-2].value), (yyvsp[0].value)); } 1705 #line 1706 "jsonpath_gram.c" /* yacc.c:1652 */ 1706 break; 1707 1708 case 42: 1709 #line 204 "jsonpath_gram.y" /* yacc.c:1652 */ 1710 { (yyval.elems) = lappend((yyvsp[-1].elems), (yyvsp[0].value)); } 1711 #line 1712 "jsonpath_gram.c" /* yacc.c:1652 */ 1712 break; 1713 1714 case 43: 1715 #line 208 "jsonpath_gram.y" /* yacc.c:1652 */ 1716 { (yyval.value) = makeItemList((yyvsp[0].elems)); } 1717 #line 1718 "jsonpath_gram.c" /* yacc.c:1652 */ 1718 break; 1719 1720 case 44: 1721 #line 209 "jsonpath_gram.y" /* yacc.c:1652 */ 1722 { (yyval.value) = (yyvsp[-1].value); } 1723 #line 1724 "jsonpath_gram.c" /* yacc.c:1652 */ 1724 break; 1725 1726 case 45: 1727 #line 210 "jsonpath_gram.y" /* yacc.c:1652 */ 1728 { (yyval.value) = makeItemUnary(jpiPlus, (yyvsp[0].value)); } 1729 #line 1730 "jsonpath_gram.c" /* yacc.c:1652 */ 1730 break; 1731 1732 case 46: 1733 #line 211 "jsonpath_gram.y" /* yacc.c:1652 */ 1734 { (yyval.value) = makeItemUnary(jpiMinus, (yyvsp[0].value)); } 1735 #line 1736 "jsonpath_gram.c" /* yacc.c:1652 */ 1736 break; 1737 1738 case 47: 1739 #line 212 "jsonpath_gram.y" /* yacc.c:1652 */ 1740 { (yyval.value) = makeItemBinary(jpiAdd, (yyvsp[-2].value), (yyvsp[0].value)); } 1741 #line 1742 "jsonpath_gram.c" /* yacc.c:1652 */ 1742 break; 1743 1744 case 48: 1745 #line 213 "jsonpath_gram.y" /* yacc.c:1652 */ 1746 { (yyval.value) = makeItemBinary(jpiSub, (yyvsp[-2].value), (yyvsp[0].value)); } 1747 #line 1748 "jsonpath_gram.c" /* yacc.c:1652 */ 1748 break; 1749 1750 case 49: 1751 #line 214 "jsonpath_gram.y" /* yacc.c:1652 */ 1752 { (yyval.value) = makeItemBinary(jpiMul, (yyvsp[-2].value), (yyvsp[0].value)); } 1753 #line 1754 "jsonpath_gram.c" /* yacc.c:1652 */ 1754 break; 1755 1756 case 50: 1757 #line 215 "jsonpath_gram.y" /* yacc.c:1652 */ 1758 { (yyval.value) = makeItemBinary(jpiDiv, (yyvsp[-2].value), (yyvsp[0].value)); } 1759 #line 1760 "jsonpath_gram.c" /* yacc.c:1652 */ 1760 break; 1761 1762 case 51: 1763 #line 216 "jsonpath_gram.y" /* yacc.c:1652 */ 1764 { (yyval.value) = makeItemBinary(jpiMod, (yyvsp[-2].value), (yyvsp[0].value)); } 1765 #line 1766 "jsonpath_gram.c" /* yacc.c:1652 */ 1766 break; 1767 1768 case 52: 1769 #line 220 "jsonpath_gram.y" /* yacc.c:1652 */ 1770 { (yyval.value) = makeItemBinary(jpiSubscript, (yyvsp[0].value), NULL); } 1771 #line 1772 "jsonpath_gram.c" /* yacc.c:1652 */ 1772 break; 1773 1774 case 53: 1775 #line 221 "jsonpath_gram.y" /* yacc.c:1652 */ 1776 { (yyval.value) = makeItemBinary(jpiSubscript, (yyvsp[-2].value), (yyvsp[0].value)); } 1777 #line 1778 "jsonpath_gram.c" /* yacc.c:1652 */ 1778 break; 1779 1780 case 54: 1781 #line 225 "jsonpath_gram.y" /* yacc.c:1652 */ 1782 { (yyval.indexs) = list_make1((yyvsp[0].value)); } 1783 #line 1784 "jsonpath_gram.c" /* yacc.c:1652 */ 1784 break; 1785 1786 case 55: 1787 #line 226 "jsonpath_gram.y" /* yacc.c:1652 */ 1788 { (yyval.indexs) = lappend((yyvsp[-2].indexs), (yyvsp[0].value)); } 1789 #line 1790 "jsonpath_gram.c" /* yacc.c:1652 */ 1790 break; 1791 1792 case 56: 1793 #line 230 "jsonpath_gram.y" /* yacc.c:1652 */ 1794 { (yyval.value) = makeItemType(jpiAnyArray); } 1795 #line 1796 "jsonpath_gram.c" /* yacc.c:1652 */ 1796 break; 1797 1798 case 57: 1799 #line 231 "jsonpath_gram.y" /* yacc.c:1652 */ 1800 { (yyval.value) = makeIndexArray((yyvsp[-1].indexs)); } 1801 #line 1802 "jsonpath_gram.c" /* yacc.c:1652 */ 1802 break; 1803 1804 case 58: 1805 #line 235 "jsonpath_gram.y" /* yacc.c:1652 */ 1806 { (yyval.integer) = pg_atoi((yyvsp[0].str).val, 4, 0); } 1807 #line 1808 "jsonpath_gram.c" /* yacc.c:1652 */ 1808 break; 1809 1810 case 59: 1811 #line 236 "jsonpath_gram.y" /* yacc.c:1652 */ 1812 { (yyval.integer) = -1; } 1813 #line 1814 "jsonpath_gram.c" /* yacc.c:1652 */ 1814 break; 1815 1816 case 60: 1817 #line 240 "jsonpath_gram.y" /* yacc.c:1652 */ 1818 { (yyval.value) = makeAny(0, -1); } 1819 #line 1820 "jsonpath_gram.c" /* yacc.c:1652 */ 1820 break; 1821 1822 case 61: 1823 #line 241 "jsonpath_gram.y" /* yacc.c:1652 */ 1824 { (yyval.value) = makeAny((yyvsp[-1].integer), (yyvsp[-1].integer)); } 1825 #line 1826 "jsonpath_gram.c" /* yacc.c:1652 */ 1826 break; 1827 1828 case 62: 1829 #line 243 "jsonpath_gram.y" /* yacc.c:1652 */ 1830 { (yyval.value) = makeAny((yyvsp[-3].integer), (yyvsp[-1].integer)); } 1831 #line 1832 "jsonpath_gram.c" /* yacc.c:1652 */ 1832 break; 1833 1834 case 63: 1835 #line 247 "jsonpath_gram.y" /* yacc.c:1652 */ 1836 { (yyval.value) = (yyvsp[0].value); } 1837 #line 1838 "jsonpath_gram.c" /* yacc.c:1652 */ 1838 break; 1839 1840 case 64: 1841 #line 248 "jsonpath_gram.y" /* yacc.c:1652 */ 1842 { (yyval.value) = makeItemType(jpiAnyKey); } 1843 #line 1844 "jsonpath_gram.c" /* yacc.c:1652 */ 1844 break; 1845 1846 case 65: 1847 #line 249 "jsonpath_gram.y" /* yacc.c:1652 */ 1848 { (yyval.value) = (yyvsp[0].value); } 1849 #line 1850 "jsonpath_gram.c" /* yacc.c:1652 */ 1850 break; 1851 1852 case 66: 1853 #line 250 "jsonpath_gram.y" /* yacc.c:1652 */ 1854 { (yyval.value) = (yyvsp[0].value); } 1855 #line 1856 "jsonpath_gram.c" /* yacc.c:1652 */ 1856 break; 1857 1858 case 67: 1859 #line 251 "jsonpath_gram.y" /* yacc.c:1652 */ 1860 { (yyval.value) = makeItemType((yyvsp[-2].optype)); } 1861 #line 1862 "jsonpath_gram.c" /* yacc.c:1652 */ 1862 break; 1863 1864 case 68: 1865 #line 253 "jsonpath_gram.y" /* yacc.c:1652 */ 1866 { (yyval.value) = makeItemUnary(jpiDatetime, (yyvsp[-1].value)); } 1867 #line 1868 "jsonpath_gram.c" /* yacc.c:1652 */ 1868 break; 1869 1870 case 69: 1871 #line 254 "jsonpath_gram.y" /* yacc.c:1652 */ 1872 { (yyval.value) = makeItemUnary(jpiFilter, (yyvsp[-1].value)); } 1873 #line 1874 "jsonpath_gram.c" /* yacc.c:1652 */ 1874 break; 1875 1876 case 70: 1877 #line 258 "jsonpath_gram.y" /* yacc.c:1652 */ 1878 { (yyval.value) = makeItemString(&(yyvsp[0].str)); } 1879 #line 1880 "jsonpath_gram.c" /* yacc.c:1652 */ 1880 break; 1881 1882 case 71: 1883 #line 262 "jsonpath_gram.y" /* yacc.c:1652 */ 1884 { (yyval.value) = (yyvsp[0].value); } 1885 #line 1886 "jsonpath_gram.c" /* yacc.c:1652 */ 1886 break; 1887 1888 case 72: 1889 #line 263 "jsonpath_gram.y" /* yacc.c:1652 */ 1890 { (yyval.value) = NULL; } 1891 #line 1892 "jsonpath_gram.c" /* yacc.c:1652 */ 1892 break; 1893 1894 case 73: 1895 #line 267 "jsonpath_gram.y" /* yacc.c:1652 */ 1896 { (yyval.value) = makeItemKey(&(yyvsp[0].str)); } 1897 #line 1898 "jsonpath_gram.c" /* yacc.c:1652 */ 1898 break; 1899 1900 case 98: 1901 #line 298 "jsonpath_gram.y" /* yacc.c:1652 */ 1902 { (yyval.optype) = jpiAbs; } 1903 #line 1904 "jsonpath_gram.c" /* yacc.c:1652 */ 1904 break; 1905 1906 case 99: 1907 #line 299 "jsonpath_gram.y" /* yacc.c:1652 */ 1908 { (yyval.optype) = jpiSize; } 1909 #line 1910 "jsonpath_gram.c" /* yacc.c:1652 */ 1910 break; 1911 1912 case 100: 1913 #line 300 "jsonpath_gram.y" /* yacc.c:1652 */ 1914 { (yyval.optype) = jpiType; } 1915 #line 1916 "jsonpath_gram.c" /* yacc.c:1652 */ 1916 break; 1917 1918 case 101: 1919 #line 301 "jsonpath_gram.y" /* yacc.c:1652 */ 1920 { (yyval.optype) = jpiFloor; } 1921 #line 1922 "jsonpath_gram.c" /* yacc.c:1652 */ 1922 break; 1923 1924 case 102: 1925 #line 302 "jsonpath_gram.y" /* yacc.c:1652 */ 1926 { (yyval.optype) = jpiDouble; } 1927 #line 1928 "jsonpath_gram.c" /* yacc.c:1652 */ 1928 break; 1929 1930 case 103: 1931 #line 303 "jsonpath_gram.y" /* yacc.c:1652 */ 1932 { (yyval.optype) = jpiCeiling; } 1933 #line 1934 "jsonpath_gram.c" /* yacc.c:1652 */ 1934 break; 1935 1936 case 104: 1937 #line 304 "jsonpath_gram.y" /* yacc.c:1652 */ 1938 { (yyval.optype) = jpiKeyValue; } 1939 #line 1940 "jsonpath_gram.c" /* yacc.c:1652 */ 1940 break; 1941 1942 1943 #line 1944 "jsonpath_gram.c" /* yacc.c:1652 */ 1944 default: break; 1945 } 1946 /* User semantic actions sometimes alter yychar, and that requires 1947 that yytoken be updated with the new translation. We take the 1948 approach of translating immediately before every use of yytoken. 1949 One alternative is translating here after every semantic action, 1950 but that translation would be missed if the semantic action invokes 1951 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1952 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1953 incorrect destructor might then be invoked immediately. In the 1954 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1955 to an incorrect destructor call or verbose syntax error message 1956 before the lookahead is translated. */ 1957 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1958 1959 YYPOPSTACK (yylen); 1960 yylen = 0; 1961 YY_STACK_PRINT (yyss, yyssp); 1962 1963 *++yyvsp = yyval; 1964 1965 /* Now 'shift' the result of the reduction. Determine what state 1966 that goes to, based on the state we popped back to and the rule 1967 number reduced by. */ 1968 { 1969 const int yylhs = yyr1[yyn] - YYNTOKENS; 1970 const int yyi = yypgoto[yylhs] + *yyssp; 1971 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 1972 ? yytable[yyi] 1973 : yydefgoto[yylhs]); 1974 } 1975 1976 goto yynewstate; 1977 1978 1979 /*--------------------------------------. 1980 | yyerrlab -- here on detecting error. | 1981 `--------------------------------------*/ 1982 yyerrlab: 1983 /* Make sure we have latest lookahead translation. See comments at 1984 user semantic actions for why this is necessary. */ 1985 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1986 1987 /* If not already recovering from an error, report this error. */ 1988 if (!yyerrstatus) 1989 { 1990 ++yynerrs; 1991 #if ! YYERROR_VERBOSE 1992 yyerror (result, YY_("syntax error")); 1993 #else 1994 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1995 yyssp, yytoken) 1996 { 1997 char const *yymsgp = YY_("syntax error"); 1998 int yysyntax_error_status; 1999 yysyntax_error_status = YYSYNTAX_ERROR; 2000 if (yysyntax_error_status == 0) 2001 yymsgp = yymsg; 2002 else if (yysyntax_error_status == 1) 2003 { 2004 if (yymsg != yymsgbuf) 2005 YYSTACK_FREE (yymsg); 2006 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2007 if (!yymsg) 2008 { 2009 yymsg = yymsgbuf; 2010 yymsg_alloc = sizeof yymsgbuf; 2011 yysyntax_error_status = 2; 2012 } 2013 else 2014 { 2015 yysyntax_error_status = YYSYNTAX_ERROR; 2016 yymsgp = yymsg; 2017 } 2018 } 2019 yyerror (result, yymsgp); 2020 if (yysyntax_error_status == 2) 2021 goto yyexhaustedlab; 2022 } 2023 # undef YYSYNTAX_ERROR 2024 #endif 2025 } 2026 2027 2028 2029 if (yyerrstatus == 3) 2030 { 2031 /* If just tried and failed to reuse lookahead token after an 2032 error, discard it. */ 2033 2034 if (yychar <= YYEOF) 2035 { 2036 /* Return failure if at end of input. */ 2037 if (yychar == YYEOF) 2038 YYABORT; 2039 } 2040 else 2041 { 2042 yydestruct ("Error: discarding", 2043 yytoken, &yylval, result); 2044 yychar = YYEMPTY; 2045 } 2046 } 2047 2048 /* Else will try to reuse lookahead token after shifting the error 2049 token. */ 2050 goto yyerrlab1; 2051 2052 2053 /*---------------------------------------------------. 2054 | yyerrorlab -- error raised explicitly by YYERROR. | 2055 `---------------------------------------------------*/ 2056 yyerrorlab: 2057 /* Pacify compilers when the user code never invokes YYERROR and the 2058 label yyerrorlab therefore never appears in user code. */ 2059 if (0) 2060 YYERROR; 2061 2062 /* Do not reclaim the symbols of the rule whose action triggered 2063 this YYERROR. */ 2064 YYPOPSTACK (yylen); 2065 yylen = 0; 2066 YY_STACK_PRINT (yyss, yyssp); 2067 yystate = *yyssp; 2068 goto yyerrlab1; 2069 2070 2071 /*-------------------------------------------------------------. 2072 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2073 `-------------------------------------------------------------*/ 2074 yyerrlab1: 2075 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2076 2077 for (;;) 2078 { 2079 yyn = yypact[yystate]; 2080 if (!yypact_value_is_default (yyn)) 2081 { 2082 yyn += YYTERROR; 2083 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2084 { 2085 yyn = yytable[yyn]; 2086 if (0 < yyn) 2087 break; 2088 } 2089 } 2090 2091 /* Pop the current state because it cannot handle the error token. */ 2092 if (yyssp == yyss) 2093 YYABORT; 2094 2095 2096 yydestruct ("Error: popping", 2097 yystos[yystate], yyvsp, result); 2098 YYPOPSTACK (1); 2099 yystate = *yyssp; 2100 YY_STACK_PRINT (yyss, yyssp); 2101 } 2102 2103 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2104 *++yyvsp = yylval; 2105 YY_IGNORE_MAYBE_UNINITIALIZED_END 2106 2107 2108 /* Shift the error token. */ 2109 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2110 2111 yystate = yyn; 2112 goto yynewstate; 2113 2114 2115 /*-------------------------------------. 2116 | yyacceptlab -- YYACCEPT comes here. | 2117 `-------------------------------------*/ 2118 yyacceptlab: 2119 yyresult = 0; 2120 goto yyreturn; 2121 2122 2123 /*-----------------------------------. 2124 | yyabortlab -- YYABORT comes here. | 2125 `-----------------------------------*/ 2126 yyabortlab: 2127 yyresult = 1; 2128 goto yyreturn; 2129 2130 2131 #if !defined yyoverflow || YYERROR_VERBOSE 2132 /*-------------------------------------------------. 2133 | yyexhaustedlab -- memory exhaustion comes here. | 2134 `-------------------------------------------------*/ 2135 yyexhaustedlab: 2136 yyerror (result, YY_("memory exhausted")); 2137 yyresult = 2; 2138 /* Fall through. */ 2139 #endif 2140 2141 2142 /*-----------------------------------------------------. 2143 | yyreturn -- parsing is finished, return the result. | 2144 `-----------------------------------------------------*/ 2145 yyreturn: 2146 if (yychar != YYEMPTY) 2147 { 2148 /* Make sure we have latest lookahead translation. See comments at 2149 user semantic actions for why this is necessary. */ 2150 yytoken = YYTRANSLATE (yychar); 2151 yydestruct ("Cleanup: discarding lookahead", 2152 yytoken, &yylval, result); 2153 } 2154 /* Do not reclaim the symbols of the rule whose action triggered 2155 this YYABORT or YYACCEPT. */ 2156 YYPOPSTACK (yylen); 2157 YY_STACK_PRINT (yyss, yyssp); 2158 while (yyssp != yyss) 2159 { 2160 yydestruct ("Cleanup: popping", 2161 yystos[*yyssp], yyvsp, result); 2162 YYPOPSTACK (1); 2163 } 2164 #ifndef yyoverflow 2165 if (yyss != yyssa) 2166 YYSTACK_FREE (yyss); 2167 #endif 2168 #if YYERROR_VERBOSE 2169 if (yymsg != yymsgbuf) 2170 YYSTACK_FREE (yymsg); 2171 #endif 2172 return yyresult; 2173 } 2174 #line 306 "jsonpath_gram.y" /* yacc.c:1918 */ 2175 2176 2177 /* 2178 * The helper functions below allocate and fill JsonPathParseItem's of various 2179 * types. 2180 */ 2181 2182 static JsonPathParseItem * 2183 makeItemType(JsonPathItemType type) 2184 { 2185 JsonPathParseItem *v = palloc(sizeof(*v)); 2186 2187 CHECK_FOR_INTERRUPTS(); 2188 2189 v->type = type; 2190 v->next = NULL; 2191 2192 return v; 2193 } 2194 2195 static JsonPathParseItem * 2196 makeItemString(JsonPathString *s) 2197 { 2198 JsonPathParseItem *v; 2199 2200 if (s == NULL) 2201 { 2202 v = makeItemType(jpiNull); 2203 } 2204 else 2205 { 2206 v = makeItemType(jpiString); 2207 v->value.string.val = s->val; 2208 v->value.string.len = s->len; 2209 } 2210 2211 return v; 2212 } 2213 2214 static JsonPathParseItem * 2215 makeItemVariable(JsonPathString *s) 2216 { 2217 JsonPathParseItem *v; 2218 2219 v = makeItemType(jpiVariable); 2220 v->value.string.val = s->val; 2221 v->value.string.len = s->len; 2222 2223 return v; 2224 } 2225 2226 static JsonPathParseItem * 2227 makeItemKey(JsonPathString *s) 2228 { 2229 JsonPathParseItem *v; 2230 2231 v = makeItemString(s); 2232 v->type = jpiKey; 2233 2234 return v; 2235 } 2236 2237 static JsonPathParseItem * 2238 makeItemNumeric(JsonPathString *s) 2239 { 2240 JsonPathParseItem *v; 2241 2242 v = makeItemType(jpiNumeric); 2243 v->value.numeric = 2244 DatumGetNumeric(DirectFunctionCall3(numeric_in, 2245 CStringGetDatum(s->val), 2246 ObjectIdGetDatum(InvalidOid), 2247 Int32GetDatum(-1))); 2248 2249 return v; 2250 } 2251 2252 static JsonPathParseItem * 2253 makeItemBool(bool val) 2254 { 2255 JsonPathParseItem *v = makeItemType(jpiBool); 2256 2257 v->value.boolean = val; 2258 2259 return v; 2260 } 2261 2262 static JsonPathParseItem * 2263 makeItemBinary(JsonPathItemType type, JsonPathParseItem *la, JsonPathParseItem *ra) 2264 { 2265 JsonPathParseItem *v = makeItemType(type); 2266 2267 v->value.args.left = la; 2268 v->value.args.right = ra; 2269 2270 return v; 2271 } 2272 2273 static JsonPathParseItem * 2274 makeItemUnary(JsonPathItemType type, JsonPathParseItem *a) 2275 { 2276 JsonPathParseItem *v; 2277 2278 if (type == jpiPlus && a->type == jpiNumeric && !a->next) 2279 return a; 2280 2281 if (type == jpiMinus && a->type == jpiNumeric && !a->next) 2282 { 2283 v = makeItemType(jpiNumeric); 2284 v->value.numeric = 2285 DatumGetNumeric(DirectFunctionCall1(numeric_uminus, 2286 NumericGetDatum(a->value.numeric))); 2287 return v; 2288 } 2289 2290 v = makeItemType(type); 2291 2292 v->value.arg = a; 2293 2294 return v; 2295 } 2296 2297 static JsonPathParseItem * 2298 makeItemList(List *list) 2299 { 2300 JsonPathParseItem *head, 2301 *end; 2302 ListCell *cell; 2303 2304 head = end = (JsonPathParseItem *) linitial(list); 2305 2306 if (list_length(list) == 1) 2307 return head; 2308 2309 /* append items to the end of already existing list */ 2310 while (end->next) 2311 end = end->next; 2312 2313 for_each_from(cell, list, 1) 2314 { 2315 JsonPathParseItem *c = (JsonPathParseItem *) lfirst(cell); 2316 2317 end->next = c; 2318 end = c; 2319 } 2320 2321 return head; 2322 } 2323 2324 static JsonPathParseItem * 2325 makeIndexArray(List *list) 2326 { 2327 JsonPathParseItem *v = makeItemType(jpiIndexArray); 2328 ListCell *cell; 2329 int i = 0; 2330 2331 Assert(list_length(list) > 0); 2332 v->value.array.nelems = list_length(list); 2333 2334 v->value.array.elems = palloc(sizeof(v->value.array.elems[0]) * 2335 v->value.array.nelems); 2336 2337 foreach(cell, list) 2338 { 2339 JsonPathParseItem *jpi = lfirst(cell); 2340 2341 Assert(jpi->type == jpiSubscript); 2342 2343 v->value.array.elems[i].from = jpi->value.args.left; 2344 v->value.array.elems[i++].to = jpi->value.args.right; 2345 } 2346 2347 return v; 2348 } 2349 2350 static JsonPathParseItem * 2351 makeAny(int first, int last) 2352 { 2353 JsonPathParseItem *v = makeItemType(jpiAny); 2354 2355 v->value.anybounds.first = (first >= 0) ? first : PG_UINT32_MAX; 2356 v->value.anybounds.last = (last >= 0) ? last : PG_UINT32_MAX; 2357 2358 return v; 2359 } 2360 2361 static JsonPathParseItem * 2362 makeItemLikeRegex(JsonPathParseItem *expr, JsonPathString *pattern, 2363 JsonPathString *flags) 2364 { 2365 JsonPathParseItem *v = makeItemType(jpiLikeRegex); 2366 int i; 2367 int cflags; 2368 2369 v->value.like_regex.expr = expr; 2370 v->value.like_regex.pattern = pattern->val; 2371 v->value.like_regex.patternlen = pattern->len; 2372 2373 /* Parse the flags string, convert to bitmask. Duplicate flags are OK. */ 2374 v->value.like_regex.flags = 0; 2375 for (i = 0; flags && i < flags->len; i++) 2376 { 2377 switch (flags->val[i]) 2378 { 2379 case 'i': 2380 v->value.like_regex.flags |= JSP_REGEX_ICASE; 2381 break; 2382 case 's': 2383 v->value.like_regex.flags |= JSP_REGEX_DOTALL; 2384 break; 2385 case 'm': 2386 v->value.like_regex.flags |= JSP_REGEX_MLINE; 2387 break; 2388 case 'x': 2389 v->value.like_regex.flags |= JSP_REGEX_WSPACE; 2390 break; 2391 case 'q': 2392 v->value.like_regex.flags |= JSP_REGEX_QUOTE; 2393 break; 2394 default: 2395 ereport(ERROR, 2396 (errcode(ERRCODE_SYNTAX_ERROR), 2397 errmsg("invalid input syntax for type %s", "jsonpath"), 2398 errdetail("unrecognized flag character \"%c\" in LIKE_REGEX predicate", 2399 flags->val[i]))); 2400 break; 2401 } 2402 } 2403 2404 /* Convert flags to what RE_compile_and_cache needs */ 2405 cflags = jspConvertRegexFlags(v->value.like_regex.flags); 2406 2407 /* check regex validity */ 2408 (void) RE_compile_and_cache(cstring_to_text_with_len(pattern->val, 2409 pattern->len), 2410 cflags, DEFAULT_COLLATION_OID); 2411 2412 return v; 2413 } 2414 2415 /* 2416 * Convert from XQuery regex flags to those recognized by our regex library. 2417 */ 2418 int 2419 jspConvertRegexFlags(uint32 xflags) 2420 { 2421 /* By default, XQuery is very nearly the same as Spencer's AREs */ 2422 int cflags = REG_ADVANCED; 2423 2424 /* Ignore-case means the same thing, too, modulo locale issues */ 2425 if (xflags & JSP_REGEX_ICASE) 2426 cflags |= REG_ICASE; 2427 2428 /* Per XQuery spec, if 'q' is specified then 'm', 's', 'x' are ignored */ 2429 if (xflags & JSP_REGEX_QUOTE) 2430 { 2431 cflags &= ~REG_ADVANCED; 2432 cflags |= REG_QUOTE; 2433 } 2434 else 2435 { 2436 /* Note that dotall mode is the default in POSIX */ 2437 if (!(xflags & JSP_REGEX_DOTALL)) 2438 cflags |= REG_NLSTOP; 2439 if (xflags & JSP_REGEX_MLINE) 2440 cflags |= REG_NLANCH; 2441 2442 /* 2443 * XQuery's 'x' mode is related to Spencer's expanded mode, but it's 2444 * not really enough alike to justify treating JSP_REGEX_WSPACE as 2445 * REG_EXPANDED. For now we treat 'x' as unimplemented; perhaps in 2446 * future we'll modify the regex library to have an option for 2447 * XQuery-style ignore-whitespace mode. 2448 */ 2449 if (xflags & JSP_REGEX_WSPACE) 2450 ereport(ERROR, 2451 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 2452 errmsg("XQuery \"x\" flag (expanded regular expressions) is not implemented"))); 2453 } 2454 2455 return cflags; 2456 } 2457 2458 /* 2459 * jsonpath_scan.l is compiled as part of jsonpath_gram.y. Currently, this is 2460 * unavoidable because jsonpath_gram does not create a .h file to export its 2461 * token symbols. If these files ever grow large enough to be worth compiling 2462 * separately, that could be fixed; but for now it seems like useless 2463 * complication. 2464 */ 2465 2466 #include "jsonpath_scan.c" 2467