/y.tab.c
C | 4235 lines | 3508 code | 395 blank | 332 comment | 343 complexity | 88b75aaf8e1e50a5b88e2f32a247915d MD5 | raw file
- /* A Bison parser, made by GNU Bison 2.3. */
- /* Skeleton implementation for Bison GLR parsers in C
- Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
- /* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
- /* C GLR parser skeleton written by Paul Hilfinger. */
- /* Identify Bison output. */
- #define YYBISON 1
- /* Bison version. */
- #define YYBISON_VERSION "2.3"
- /* Skeleton name. */
- #define YYSKELETON_NAME "glr.c"
- /* Pure parsers. */
- #define YYPURE 0
- /* Using locations. */
- #define YYLSP_NEEDED 0
- #include "y.tab.h"
- /* Enabling traces. */
- #ifndef YYDEBUG
- # define YYDEBUG 1
- #endif
- /* Enabling verbose error messages. */
- #ifdef YYERROR_VERBOSE
- # undef YYERROR_VERBOSE
- # define YYERROR_VERBOSE 1
- #else
- # define YYERROR_VERBOSE 0
- #endif
- /* Enabling the token table. */
- #ifndef YYTOKEN_TABLE
- # define YYTOKEN_TABLE 1
- #endif
- /* Default (constant) value used for initialization for null
- right-hand sides. Unlike the standard yacc.c template,
- here we set the default value of $$ to a zeroed-out value.
- Since the default value is undefined, this behavior is
- technically correct. */
- static YYSTYPE yyval_default;
- /* Copy the second part of user declarations. */
- /* Line 234 of glr.c. */
- #line 89 "y.tab.c"
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <stdarg.h>
- #ifndef YY_
- # if defined YYENABLE_NLS && YYENABLE_NLS
- # if ENABLE_NLS
- # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
- # define YY_(msgid) dgettext ("bison-runtime", msgid)
- # endif
- # endif
- # ifndef YY_
- # define YY_(msgid) msgid
- # endif
- #endif
- /* Suppress unused-variable warnings by "using" E. */
- #if ! defined lint || defined __GNUC__
- # define YYUSE(e) ((void) (e))
- #else
- # define YYUSE(e) /* empty */
- #endif
- /* Identity function, used to suppress warnings about constant conditions. */
- #ifndef lint
- # define YYID(n) (n)
- #else
- #if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
- static int
- YYID (int i)
- #else
- static int
- YYID (i)
- int i;
- #endif
- {
- return i;
- }
- #endif
- #ifndef YYFREE
- # define YYFREE free
- #endif
- #ifndef YYMALLOC
- # define YYMALLOC malloc
- #endif
- #ifndef YYREALLOC
- # define YYREALLOC realloc
- #endif
- #define YYSIZEMAX ((size_t) -1)
- #ifdef __cplusplus
- typedef bool yybool;
- #else
- typedef unsigned char yybool;
- #endif
- #define yytrue 1
- #define yyfalse 0
- #ifndef YYSETJMP
- # include <setjmp.h>
- # define YYJMP_BUF jmp_buf
- # define YYSETJMP(env) setjmp (env)
- # define YYLONGJMP(env, val) longjmp (env, val)
- #endif
- /*-----------------.
- | GCC extensions. |
- `-----------------*/
- #ifndef __attribute__
- /* This feature is available in gcc versions 2.5 and later. */
- # if (! defined __GNUC__ || __GNUC__ < 2 \
- || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)
- # define __attribute__(Spec) /* empty */
- # endif
- #endif
- #ifdef __cplusplus
- # define YYOPTIONAL_LOC(Name) /* empty */
- #else
- # define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__))
- #endif
- #ifndef YYASSERT
- # define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
- #endif
- /* YYFINAL -- State number of the termination state. */
- #define YYFINAL 124
- /* YYLAST -- Last index in YYTABLE. */
- #define YYLAST 2256
- /* YYNTOKENS -- Number of terminals. */
- #define YYNTOKENS 100
- /* YYNNTS -- Number of nonterminals. */
- #define YYNNTS 61
- /* YYNRULES -- Number of rules. */
- #define YYNRULES 208
- /* YYNRULES -- Number of states. */
- #define YYNSTATES 353
- /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
- #define YYMAXRHS 9
- /* YYMAXLEFT -- Maximum number of symbols to the left of a handle
- accessed by $0, $-1, etc., in any rule. */
- #define YYMAXLEFT 0
- /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */
- #define YYUNDEFTOK 2
- #define YYMAXUTOK 354
- #define YYTRANSLATE(YYX) \
- ((YYX <= 0) ? YYEOF : \
- (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
- /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
- static const unsigned char yytranslate[] =
- {
- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
- 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
- 95, 96, 97, 98, 99
- };
- #if YYDEBUG
- /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
- YYRHS. */
- static const unsigned short int yyprhs[] =
- {
- 0, 0, 3, 6, 8, 10, 12, 15, 17, 19,
- 21, 25, 27, 30, 34, 36, 39, 41, 43, 45,
- 47, 49, 51, 53, 55, 57, 59, 61, 63, 65,
- 67, 69, 73, 78, 81, 83, 87, 89, 92, 96,
- 98, 100, 102, 103, 107, 109, 111, 115, 117, 119,
- 121, 126, 128, 129, 133, 135, 139, 141, 145, 147,
- 149, 153, 157, 159, 162, 164, 168, 170, 174, 176,
- 180, 184, 186, 192, 198, 204, 210, 212, 218, 224,
- 226, 232, 238, 244, 246, 249, 251, 253, 256, 260,
- 263, 265, 268, 270, 274, 276, 278, 280, 282, 284,
- 286, 288, 290, 294, 296, 298, 300, 302, 304, 309,
- 311, 313, 318, 322, 324, 327, 330, 333, 335, 337,
- 347, 353, 357, 361, 366, 372, 378, 384, 390, 396,
- 402, 408, 418, 428, 438, 448, 458, 468, 474, 480,
- 483, 486, 489, 492, 495, 498, 501, 504, 507, 510,
- 513, 516, 519, 522, 525, 528, 531, 534, 537, 540,
- 543, 546, 549, 552, 555, 558, 561, 563, 564, 566,
- 568, 571, 573, 576, 579, 581, 583, 586, 588, 590,
- 592, 594, 597, 600, 602, 604, 606, 608, 610, 612,
- 614, 616, 618, 620, 622, 624, 626, 628, 630, 632,
- 634, 636, 638, 640, 642, 644, 646, 648, 650
- };
- /* YYRHS -- A `-1'-separated list of the rules' RHS. */
- static const short int yyrhs[] =
- {
- 101, 0, -1, 116, 160, -1, 104, -1, 103, -1,
- 145, -1, 10, 104, -1, 10, -1, 112, -1, 105,
- -1, 104, 10, 105, -1, 113, -1, 106, 108, -1,
- 106, 108, 109, -1, 114, -1, 107, 14, -1, 115,
- -1, 33, -1, 34, -1, 35, -1, 36, -1, 37,
- -1, 38, -1, 39, -1, 40, -1, 41, -1, 42,
- -1, 43, -1, 44, -1, 45, -1, 136, -1, 137,
- 6, 7, -1, 52, 6, 132, 7, -1, 109, 110,
- -1, 110, -1, 21, 111, 22, -1, 116, -1, 11,
- 104, -1, 104, 11, 105, -1, 18, -1, 19, -1,
- 5, -1, -1, 6, 116, 7, -1, 125, -1, 135,
- -1, 6, 116, 7, -1, 132, -1, 133, -1, 118,
- -1, 138, 6, 119, 7, -1, 120, -1, -1, 121,
- 17, 120, -1, 121, -1, 160, 116, 160, -1, 123,
- -1, 122, 8, 123, -1, 102, -1, 124, -1, 124,
- 10, 104, -1, 124, 11, 104, -1, 117, -1, 124,
- 109, -1, 126, -1, 125, 46, 126, -1, 127, -1,
- 126, 47, 127, -1, 128, -1, 127, 27, 128, -1,
- 127, 56, 128, -1, 129, -1, 128, 160, 9, 160,
- 129, -1, 128, 160, 20, 160, 129, -1, 128, 160,
- 28, 160, 129, -1, 128, 160, 29, 160, 129, -1,
- 130, -1, 129, 160, 25, 160, 130, -1, 129, 160,
- 26, 160, 130, -1, 131, -1, 130, 160, 134, 160,
- 131, -1, 130, 160, 48, 160, 131, -1, 130, 160,
- 49, 160, 131, -1, 122, -1, 26, 131, -1, 99,
- -1, 3, -1, 3, 18, -1, 3, 18, 3, -1,
- 18, 3, -1, 24, -1, 30, 139, -1, 24, -1,
- 144, 13, 24, -1, 139, -1, 50, -1, 51, -1,
- 52, -1, 53, -1, 139, -1, 140, -1, 141, -1,
- 142, 13, 143, -1, 143, -1, 144, -1, 144, -1,
- 98, -1, 158, -1, 146, 17, 160, 145, -1, 146,
- -1, 147, -1, 147, 4, 5, 98, -1, 149, 148,
- 147, -1, 149, -1, 25, 160, -1, 20, 160, -1,
- 23, 160, -1, 4, -1, 151, -1, 150, 21, 152,
- 160, 55, 160, 159, 160, 22, -1, 150, 63, 6,
- 145, 7, -1, 150, 16, 157, -1, 150, 18, 157,
- -1, 150, 21, 152, 22, -1, 150, 66, 6, 156,
- 7, -1, 150, 67, 6, 156, 7, -1, 150, 68,
- 6, 156, 7, -1, 150, 70, 6, 159, 7, -1,
- 150, 72, 6, 145, 7, -1, 150, 76, 6, 156,
- 7, -1, 150, 77, 6, 156, 7, -1, 150, 21,
- 152, 160, 27, 160, 159, 160, 22, -1, 150, 21,
- 152, 160, 56, 160, 159, 160, 22, -1, 150, 21,
- 152, 160, 57, 160, 159, 160, 22, -1, 150, 21,
- 152, 160, 58, 160, 159, 160, 22, -1, 150, 21,
- 152, 160, 59, 160, 159, 160, 22, -1, 150, 21,
- 152, 160, 60, 160, 159, 160, 22, -1, 150, 74,
- 6, 156, 7, -1, 150, 75, 6, 156, 7, -1,
- 150, 61, -1, 150, 62, -1, 150, 64, -1, 150,
- 65, -1, 150, 69, -1, 150, 71, -1, 150, 73,
- -1, 150, 80, -1, 150, 81, -1, 150, 83, -1,
- 150, 84, -1, 150, 94, -1, 150, 95, -1, 150,
- 96, -1, 150, 97, -1, 150, 78, -1, 150, 79,
- -1, 150, 82, -1, 150, 85, -1, 150, 86, -1,
- 150, 87, -1, 150, 88, -1, 150, 89, -1, 150,
- 90, -1, 150, 91, -1, 150, 92, -1, 150, 93,
- -1, 149, -1, -1, 152, -1, 155, -1, 153, 154,
- -1, 154, -1, 24, 8, -1, 157, 8, -1, 8,
- -1, 157, -1, 153, 24, -1, 24, -1, 3, -1,
- 98, -1, 31, -1, 98, 157, -1, 31, 157, -1,
- 158, -1, 33, -1, 34, -1, 35, -1, 36, -1,
- 37, -1, 38, -1, 39, -1, 40, -1, 41, -1,
- 42, -1, 43, -1, 44, -1, 45, -1, 46, -1,
- 47, -1, 48, -1, 49, -1, 50, -1, 51, -1,
- 52, -1, 53, -1, 157, -1, 99, -1, 4, -1,
- -1
- };
- /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
- static const unsigned short int yyrline[] =
- {
- 0, 219, 219, 223, 224, 225, 229, 230, 231, 235,
- 236, 237, 241, 242, 243, 247, 248, 251, 252, 253,
- 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
- 267, 268, 269, 273, 274, 278, 282, 286, 290, 294,
- 295, 299, 300, 303, 304, 307, 308, 309, 310, 311,
- 315, 318, 319, 322, 323, 326, 329, 330, 334, 335,
- 336, 337, 341, 342, 346, 347, 351, 352, 356, 357,
- 358, 362, 363, 364, 365, 366, 370, 371, 372, 376,
- 377, 378, 379, 383, 384, 388, 391, 392, 393, 394,
- 398, 402, 406, 407, 408, 412, 413, 414, 415, 419,
- 423, 424, 428, 432, 436, 440, 444, 445, 449, 450,
- 454, 455, 459, 460, 464, 465, 466, 467, 471, 472,
- 473, 474, 475, 476, 477, 478, 479, 480, 481, 482,
- 483, 484, 485, 486, 487, 488, 489, 490, 491, 492,
- 493, 494, 495, 496, 497, 498, 499, 500, 501, 502,
- 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
- 513, 514, 515, 516, 517, 518, 522, 523, 527, 528,
- 532, 533, 537, 538, 539, 543, 547, 548, 552, 556,
- 557, 558, 559, 560, 564, 565, 566, 567, 568, 569,
- 570, 571, 572, 573, 574, 575, 576, 577, 578, 579,
- 580, 581, 582, 583, 584, 588, 589, 593, 594
- };
- #endif
- #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
- /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
- static const char *const yytname[] =
- {
- "$end", "error", "$undefined", "NUMBER", "S", "AT", "LPAREN", "RPAREN",
- "PIPE", "LT", "SLASH", "DBLSLASH", "BANG", "COLON", "DBLCOLON", "QUERY",
- "HASH", "COMMA", "DOT", "DBLDOT", "GT", "LBRA", "RBRA", "TILDE", "SPLAT",
- "PLUS", "DASH", "EQ", "LTE", "GTE", "DOLLAR", "BSLASHLIT", "OTHER",
- "XANCESTOR", "XANCESTORSELF", "XATTR", "XCHILD", "XDESC", "XDESCSELF",
- "XFOLLOW", "XFOLLOWSIB", "XNS", "XPARENT", "XPRE", "XPRESIB", "XSELF",
- "XOR", "XAND", "XDIV", "XMOD", "XCOMMENT", "XTEXT", "XPI", "XNODE",
- "CXEQUATION", "CXOPHE", "CXOPNE", "CXOPSTARTEQ", "CXOPENDEQ",
- "CXOPCONTAINS", "CXOPCONTAINS2", "CXFIRST", "CXLAST", "CXNOT", "CXEVEN",
- "CXODD", "CXEQ", "CXGT", "CXLT", "CXHEADER", "CXCONTAINS", "CXEMPTY",
- "CXHAS", "CXPARENT", "CXNTHCH", "CXNTHLASTCH", "CXNTHTYPE",
- "CXNTHLASTTYPE", "CXFIRSTCH", "CXLASTCH", "CXFIRSTTYPE", "CXLASTTYPE",
- "CXONLYCH", "CXONLYTYPE", "CXINPUT", "CXTEXT", "CXPASSWORD", "CXRADIO",
- "CXCHECKBOX", "CXSUBMIT", "CXIMAGE", "CXRESET", "CXBUTTON", "CXFILE",
- "CXENABLED", "CXDISABLED", "CXCHECKED", "CXSELECTED", "NAME", "STRING",
- "$accept", "Root", "LocationPath", "AbsoluteLocationPath",
- "RelativeLocationPath", "Step", "AxisSpecifier", "AxisName", "NodeTest",
- "Predicates", "Predicate", "PredicateExpr",
- "AbbreviatedAbsoluteLocationPath", "AbbreviatedRelativeLocationPath",
- "AbbreviatedStep", "AbbreviatedAxisSpecifier", "Expr", "PrimaryExpr",
- "FunctionCall", "Arguments", "ArgumentSet", "Argument", "UnionExpr",
- "PathExpr", "FilterExpr", "OrExpr", "AndExpr", "EqualityExpr",
- "RelationalExpr", "AdditiveExpr", "MultiplicativeExpr", "UnaryExpr",
- "Literal", "Number", "MultiplyOperator", "VariableReference", "NameTest",
- "NodeType", "FunctionName", "QName", "PrefixedName", "UnprefixedName",
- "Prefix", "LocalPart", "NCName", "selectors_group",
- "attribute_extended_selector", "selector", "combinator",
- "simple_selector_sequence", "possibly_empty_sequence",
- "simple_selector_anchor", "type_selector", "namespace_prefix",
- "element_name", "universal", "NumberLike", "Ident", "keyword",
- "StringLike", "OptS", 0
- };
- #endif
- /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
- static const unsigned char yyr1[] =
- {
- 0, 100, 101, 102, 102, 102, 103, 103, 103, 104,
- 104, 104, 105, 105, 105, 106, 106, 107, 107, 107,
- 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
- 108, 108, 108, 109, 109, 110, 111, 112, 113, 114,
- 114, 115, 115, 116, 116, 117, 117, 117, 117, 117,
- 118, 119, 119, 120, 120, 121, 122, 122, 123, 123,
- 123, 123, 124, 124, 125, 125, 126, 126, 127, 127,
- 127, 128, 128, 128, 128, 128, 129, 129, 129, 130,
- 130, 130, 130, 131, 131, 132, 133, 133, 133, 133,
- 134, 135, 136, 136, 136, 137, 137, 137, 137, 138,
- 139, 139, 140, 141, 142, 143, 144, 144, 145, 145,
- 146, 146, 147, 147, 148, 148, 148, 148, 149, 149,
- 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
- 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
- 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
- 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
- 149, 149, 149, 149, 149, 149, 150, 150, 151, 151,
- 152, 152, 153, 153, 153, 154, 155, 155, 156, 157,
- 157, 157, 157, 157, 158, 158, 158, 158, 158, 158,
- 158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
- 158, 158, 158, 158, 158, 159, 159, 160, 160
- };
- /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
- static const unsigned char yyr2[] =
- {
- 0, 2, 2, 1, 1, 1, 2, 1, 1, 1,
- 3, 1, 2, 3, 1, 2, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 3, 4, 2, 1, 3, 1, 2, 3, 1,
- 1, 1, 0, 3, 1, 1, 3, 1, 1, 1,
- 4, 1, 0, 3, 1, 3, 1, 3, 1, 1,
- 3, 3, 1, 2, 1, 3, 1, 3, 1, 3,
- 3, 1, 5, 5, 5, 5, 1, 5, 5, 1,
- 5, 5, 5, 1, 2, 1, 1, 2, 3, 2,
- 1, 2, 1, 3, 1, 1, 1, 1, 1, 1,
- 1, 1, 3, 1, 1, 1, 1, 1, 4, 1,
- 1, 4, 3, 1, 2, 2, 2, 1, 1, 9,
- 5, 3, 3, 4, 5, 5, 5, 5, 5, 5,
- 5, 9, 9, 9, 9, 9, 9, 5, 5, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 1, 0, 1, 1,
- 2, 1, 2, 2, 1, 1, 2, 1, 1, 1,
- 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 0
- };
- /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
- static const unsigned char yydprec[] =
- {
- 0, 0, 0, 1, 2, 3, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 2, 1, 0, 0, 0, 0, 0,
- 0, 0, 0, 2, 1, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0
- };
- /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
- static const unsigned char yymerger[] =
- {
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0
- };
- /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
- doesn't specify something else to do. Zero means the default is an
- error. */
- static const unsigned char yydefact[] =
- {
- 167, 86, 41, 167, 174, 7, 42, 39, 40, 177,
- 167, 0, 180, 184, 185, 186, 187, 188, 189, 190,
- 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
- 201, 202, 203, 204, 179, 85, 0, 58, 4, 3,
- 9, 0, 0, 8, 11, 14, 16, 208, 62, 49,
- 83, 56, 59, 44, 64, 66, 68, 71, 76, 79,
- 47, 48, 45, 0, 99, 100, 101, 0, 103, 105,
- 5, 109, 110, 166, 0, 118, 168, 0, 171, 169,
- 175, 183, 87, 0, 39, 17, 18, 19, 20, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 6, 37,
- 89, 172, 167, 84, 184, 185, 186, 187, 188, 189,
- 190, 191, 192, 193, 194, 195, 196, 106, 91, 107,
- 179, 182, 183, 181, 1, 42, 42, 92, 201, 202,
- 203, 204, 12, 30, 0, 94, 105, 15, 207, 2,
- 167, 42, 42, 167, 63, 34, 167, 167, 167, 167,
- 0, 0, 0, 208, 0, 208, 0, 117, 208, 208,
- 208, 167, 0, 0, 0, 139, 140, 0, 141, 142,
- 0, 0, 0, 143, 0, 144, 0, 145, 0, 0,
- 0, 0, 154, 155, 146, 147, 156, 148, 149, 157,
- 158, 159, 160, 161, 162, 163, 164, 165, 150, 151,
- 152, 153, 176, 170, 175, 173, 88, 46, 0, 10,
- 38, 0, 13, 0, 0, 57, 60, 61, 0, 36,
- 33, 65, 67, 69, 70, 208, 208, 208, 208, 208,
- 208, 90, 208, 208, 208, 0, 51, 54, 167, 102,
- 105, 167, 0, 115, 116, 114, 112, 121, 122, 0,
- 208, 0, 167, 0, 0, 0, 0, 167, 0, 0,
- 0, 0, 46, 0, 31, 93, 35, 167, 167, 167,
- 167, 167, 167, 167, 167, 167, 50, 208, 208, 108,
- 111, 123, 0, 0, 178, 0, 0, 0, 206, 205,
- 0, 0, 0, 0, 0, 0, 32, 72, 73, 74,
- 75, 77, 78, 81, 82, 80, 53, 55, 208, 208,
- 208, 208, 208, 208, 208, 120, 124, 125, 126, 127,
- 128, 137, 138, 129, 130, 0, 0, 0, 0, 0,
- 0, 0, 208, 208, 208, 208, 208, 208, 208, 0,
- 0, 0, 0, 0, 0, 0, 131, 119, 132, 133,
- 134, 135, 136
- };
- /* YYPDEFGOTO[NTERM-NUM]. */
- static const short int yydefgoto[] =
- {
- -1, 36, 37, 38, 39, 40, 41, 42, 132, 144,
- 145, 218, 43, 44, 45, 46, 47, 48, 49, 235,
- 236, 237, 50, 51, 52, 53, 54, 55, 56, 57,
- 58, 59, 60, 61, 234, 62, 133, 134, 63, 64,
- 65, 66, 67, 68, 69, 70, 71, 72, 161, 73,
- 74, 75, 76, 77, 78, 79, 285, 80, 81, 290,
- 151
- };
- /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
- #define YYPACT_NINF -226
- static const short int yypact[] =
- {
- 49, 4, -226, 326, -226, 1653, 265, 30, -226, 34,
- 396, 2076, 1984, 42, 57, 67, 91, 93, 98, 105,
- 109, 113, 118, 153, 154, 156, -226, -226, -226, -226,
- -226, -226, -226, -226, 1719, -226, 116, -226, -226, 18,
- -226, 1918, 172, -226, -226, -226, -226, 190, -226, -226,
- 187, -226, 151, 160, 149, -15, 102, 114, 13, -226,
- -226, -226, -226, 193, -226, -226, -226, 195, -226, 218,
- -226, 217, 231, 2130, 1844, -226, -226, 176, -226, -226,
- 228, 59, 234, 235, -226, -226, -226, -226, -226, -226,
- -226, -226, -226, -226, -226, -226, -226, -226, 18, 18,
- -226, -226, 466, -226, -226, -226, -226, -226, -226, -226,
- -226, -226, -226, -226, -226, -226, -226, -226, -226, -226,
- 2010, -226, -226, -226, -226, 1702, 2127, -226, 232, 237,
- 238, 241, 229, -226, 243, -226, 239, -226, -226, -226,
- 1586, 2170, 2211, 536, 230, -226, 606, 676, 746, 816,
- 6, 51, 80, 17, 2076, 190, 249, -226, 190, 190,
- 190, 1785, 2050, 2050, 1851, -226, -226, 252, -226, -226,
- 253, 254, 255, -226, 256, -226, 276, -226, 279, 280,
- 288, 289, -226, -226, -226, -226, -226, -226, -226, -226,
- -226, -226, -226, -226, -226, -226, -226, -226, -226, -226,
- -226, -226, -226, -226, -226, -226, -226, 36, 248, -226,
- -226, 197, 229, 290, 287, -226, 18, 18, 291, -226,
- -226, 149, -15, 117, 129, 190, 190, 190, 190, 190,
- 190, -226, 190, 190, 190, 305, -226, 304, 886, -226,
- -226, 1785, 240, -226, -226, -226, -226, -226, -226, 322,
- 16, 2050, 1785, 330, 330, 330, 1941, 1785, 330, 330,
- 330, 330, -226, 328, -226, -226, -226, 956, 1026, 1096,
- 1166, 1236, 1306, 1376, 1446, 1516, -226, 190, 190, -226,
- -226, -226, -9, 332, -226, 333, 334, 335, -226, -226,
- 336, 339, 340, 341, 342, 344, -226, 130, 150, 165,
- 167, 15, 21, -226, -226, -226, -226, -226, 190, 190,
- 190, 190, 190, 190, 190, -226, -226, -226, -226, -226,
- -226, -226, -226, -226, -226, 1941, 1941, 1941, 1941, 1941,
- 1941, 1941, 190, 190, 190, 190, 190, 190, 190, 331,
- 358, 359, 360, 361, 362, 363, -226, -226, -226, -226,
- -226, -226, -226
- };
- /* YYPGOTO[NTERM-NUM]. */
- static const short int yypgoto[] =
- {
- -226, -226, -226, -226, 0, -1, -226, -226, -226, 222,
- -134, -226, -226, -226, -226, -226, 1, -226, -226, -226,
- 78, -226, -226, 246, -226, -226, 212, 242, -13, -104,
- -98, -2, 177, -226, -226, -226, -226, -226, -226, 3,
- -226, -226, -226, 233, -34, -225, -226, 236, -226, -226,
- -226, -226, 226, 227, -74, -226, -57, -3, -11, -50,
- -45
- };
- /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule which
- number is the opposite. If zero, do what YYDEFACT says.
- If YYTABLE_NINF, syntax error. */
- #define YYTABLE_NINF -209
- static const short int yytable[] =
- {
- 119, 122, 139, 203, 83, 98, 99, 136, 103, 121,
- 220, 150, 148, 152, 118, 225, 279, 138, 308, 138,
- 138, 138, 82, 122, -52, 138, 226, 283, 125, 126,
- 119, 123, 291, 100, 227, 228, -43, -208, 281, -208,
- -43, 149, 101, -43, 135, -208, 309, 310, 311, 312,
- 313, 314, 1, -43, 2, 3, -17, 4, -43, 5,
- 6, -208, -208, -208, -208, -107, 122, 7, 8, -208,
- -208, -18, -107, 9, 204, 10, 229, 230, 220, 11,
- 12, -19, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, 33, 208, 231, -20, 138, -21, 238, 122,
- 241, -208, -22, 243, 244, 245, 124, 123, 138, -23,
- 240, 138, -208, -24, 209, 210, -208, -25, 232, 233,
- -208, -208, -26, 138, 138, 223, 224, -208, -208, -208,
- -208, 216, 217, 119, 219, -208, -208, 34, 35, -208,
- 122, 122, 122, 122, 138, -208, -208, -208, -208, 247,
- 248, 141, 142, 297, 298, 299, 300, -27, -28, 138,
- -29, 138, 143, 301, 302, -208, -208, 203, 150, 150,
- 267, 268, 269, 270, 271, 272, 137, 273, 274, 275,
- -208, -208, -208, -208, 138, 140, 147, 286, 287, 153,
- 202, 292, 293, 294, 295, 282, 146, 12, 154, 104,
- 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
- 115, 116, 26, 27, 28, 29, 30, 31, 32, 33,
- 122, -104, 238, 307, 155, 156, 205, 206, -95, 278,
- 122, 122, 207, -96, 211, 122, 122, -98, 204, 213,
- 143, 143, 214, 289, 242, 262, 152, 152, 252, 253,
- 254, 255, 256, 325, 326, 327, 328, 329, 330, 331,
- 2, 303, 304, 305, 120, 332, 333, 334, 335, 336,
- 337, 338, 257, 84, 8, 258, 259, 339, 340, 341,
- 342, 343, 344, 345, 260, 261, 35, 264, 85, 86,
- 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
- 97, 265, 276, 266, 122, 122, 122, 122, 122, 122,
- 122, 277, 289, 289, 289, 289, 289, 289, 289, 1,
- 101, 2, 3, 284, 4, 296, 5, 6, 280, 315,
- 316, 317, 318, 319, 7, 8, 320, 321, 322, 323,
- 9, 324, 10, 346, 212, 306, 11, 12, 221, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 347, 348, 349, 350, 351, 352, 215, 239, 263, 222,
- 250, 251, 0, 0, 0, 0, 0, 246, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 3, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 3, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 3, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 10, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
- 0, 2, 102, 0, 4, 0, 5, 6, 0, 0,
- 0, 0, 0, 0, 7, 8, 0, 0, 0, 0,
- 9, 0, 0, 0, 34, 35, 11, 12, 0, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 2, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 84, 8, 0, 0, 0, 0, -7, 0, 0,
- 0, 0, 0, 0, 34, 35, 85, 86, 87, 88,
- 89, 90, 91, 92, 93, 94, 95, 96, 97, -7,
- -7, -7, -7, -42, -42, -42, -42, 2, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 84, 8, 0, 0, 0, -106, 0, 0, 0, 0,
- 0, 0, -106, 0, 0, 85, 86, 87, 88, 89,
- 90, 91, 92, 93, 94, 95, 96, 97, 0, 0,
- 12, -42, 104, 105, 106, 107, 108, 109, 110, 111,
- 112, 113, 114, 115, 116, 26, 27, 28, 29, 30,
- 31, 32, 33, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 4, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
- 0, 0, 0, 0, 0, 0, 12, 120, 104, 105,
- 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
- 116, 26, 27, 28, 29, 30, 31, 32, 33, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 4,
- 162, 0, 163, 0, 0, 164, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 249, 0, 0, 0, 0,
- 0, 0, 12, 120, 104, 105, 106, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 26, 27, 28,
- 29, 30, 31, 32, 33, 165, 166, 167, 168, 169,
- 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
- 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
- 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
- 200, 201, 127, 0, 0, 0, 0, 0, 0, 120,
- 0, 104, 105, 106, 107, 108, 109, 110, 111, 112,
- 113, 114, 115, 116, 26, 27, 28, 29, 128, 129,
- 130, 131, 12, 0, 104, 105, 106, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 26, 27, 28,
- 29, 30, 31, 32, 33, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 12, 117, 104, 105, 106,
- 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
- 26, 27, 28, 29, 30, 31, 32, 33, 0, 120,
- 288, 12, 0, 104, 105, 106, 107, 108, 109, 110,
- 111, 112, 113, 114, 115, 116, 26, 27, 28, 29,
- 30, 31, 32, 33, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 12, 120, 104, 105, 106, 107, 108, 109, 110,
- 111, 112, 113, 114, 115, 116, 26, 27, 28, 29,
- 30, 31, 32, 33, 0, 0, 0, 0, 120, 104,
- 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
- 115, 116, 26, 27, 28, 29, 30, 31, 32, 33,
- -113, 0, 2, 0, 157, 0, 0, -113, -113, -113,
- 0, 0, 0, 0, 0, 84, 8, -113, 120, 0,
- 158, 0, -113, 159, -113, 160, -113, -113, -113, -113,
- 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
- 95, 96, 97, 0, 117, 2, -113, -113, -113, -113,
- 0, 0, 0, 0, 0, 0, -113, 0, 84, 8,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 85, 86, 87, 88, 89, 90, 91,
- 92, 93, 94, 95, 96, 97, 2, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 84,
- 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 85, 86, 87, 88, 89, 90,
- 91, 92, 93, 94, 95, 96, 97
- };
- /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
- list of conflicting reductions corresponding to action entry for
- state STATE-NUM in yytable. 0 means no conflicts. The list in
- yyconfl is terminated by a rule number of 0. */
- static const unsigned short int yyconflp[] =
- {
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 229, 0, 1199,
- 0, 0, 0, 0, 0, 1201, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 697, 0, 0, 0,
- 699, 0, 159, 701, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 703, 0, 0, 0, 0, 705, 0,
- 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
- 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
- 0, 0, 5, 7, 9, 11, 13, 15, 17, 19,
- 21, 23, 25, 27, 29, 31, 33, 35, 37, 39,
- 41, 43, 45, 0, 0, 0, 225, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 227, 0,
- 0, 707, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 709, 1191, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 47, 0, 0,
- 0, 0, 0, 0, 1193, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1195,
- 0, 1197, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 231, 233, 241, 0, 0, 0,
- 0, 0, 0, 0, 351, 0, 0, 0, 0, 0,
- 0, 503, 353, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 133, 135,
- 137, 139, 141, 143, 145, 147, 149, 151, 153, 155,
- 157, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 49, 0, 0, 0, 0, 0,
- 51, 0, 0, 0, 0, 0, 0, 0, 0, 53,
- 55, 57, 59, 61, 63, 65, 67, 69, 71, 73,
- 75, 77, 79, 81, 83, 85, 87, 89, 91, 93,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 161, 0, 0, 0, 0, 0,
- 163, 0, 0, 0, 95, 0, 0, 0, 0, 165,
- 167, 169, 171, 173, 175, 177, 179, 181, 183, 185,
- 187, 189, 191, 193, 195, 197, 199, 201, 203, 205,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 243, 0, 0, 0, 0, 0,
- 245, 0, 0, 0, 207, 0, 0, 0, 0, 247,
- 249, 251, 253, 255, 257, 259, 261, 263, 265, 267,
- 269, 271, 273, 275, 277, 279, 281, 283, 285, 287,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 455, 0, 0, 0, 0, 0,
- 457, 0, 0, 0, 289, 0, 0, 0, 0, 459,
- 461, 463, 465, 467, 469, 471, 473, 475, 477, 479,
- 481, 483, 485, 487, 489, 491, 493, 495, 497, 499,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 505, 0, 0, 0, 0, 0,
- 507, 0, 0, 0, 501, 0, 0, 0, 0, 509,
- 511, 513, 515, 517, 519, 521, 523, 525, 527, 529,
- 531, 533, 535, 537, 539, 541, 543, 545, 547, 549,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 553, 0, 0, 0, 0, 0,
- 555, 0, 0, 0, 551, 0, 0, 0, 0, 557,
- 559, 561, 563, 565, 567, 569, 571, 573, 575, 577,
- 579, 581, 583, 585, 587, 589, 591, 593, 595, 597,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 601, 0, 0, 0, 0, 0,
- 603, 0, 0, 0, 599, 0, 0, 0, 0, 605,
- 607, 609, 611, 613, 615, 617, 619, 621, 623, 625,
- 627, 629, 631, 633, 635, 637, 639, 641, 643, 645,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 649, 0, 0, 0, 0, 0,
- 651, 0, 0, 0, 647, 0, 0, 0, 0, 653,
- 655, 657, 659, 661, 663, 665, 667, 669, 671, 673,
- 675, 677, 679, 681, 683, 685, 687, 689, 691, 693,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 711, 0, 0, 0, 0, 0,
- 713, 0, 0, 0, 695, 0, 0, 0, 0, 715,
- 717, 719, 721, 723, 725, 727, 729, 731, 733, 735,
- 737, 739, 741, 743, 745, 747, 749, 751, 753, 755,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 759, 0, 0, 0, 0, 0,
- 761, 0, 0, 0, 757, 0, 0, 0, 0, 763,
- 765, 767, 769, 771, 773, 775, 777, 779, 781, 783,
- 785, 787, 789, 791, 793, 795, 797, 799, 801, 803,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 807, 0, 0, 0, 0, 0,
- 809, 0, 0, 0, 805, 0, 0, 0, 0, 811,
- 813, 815, 817, 819, 821, 823, 825, 827, 829, 831,
- 833, 835, 837, 839, 841, 843, 845, 847, 849, 851,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 855, 0, 0, 0, 0, 0,
- 857, 0, 0, 0, 853, 0, 0, 0, 0, 859,
- 861, 863, 865, 867, 869, 871, 873, 875, 877, 879,
- 881, 883, 885, 887, 889, 891, 893, 895, 897, 899,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 903, 0, 0, 0, 0, 0,
- 905, 0, 0, 0, 901, 0, 0, 0, 0, 907,
- 909, 911, 913, 915, 917, 919, 921, 923, 925, 927,
- 929, 931, 933, 935, 937, 939, 941, 943, 945, 947,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 951, 0, 0, 0, 0, 0,
- 953, 0, 0, 0, 949, 0, 0, 0, 0, 955,
- 957, 959, 961, 963, 965, 967, 969, 971, 973, 975,
- 977, 979, 981, 983, 985, 987, 989, 991, 993, 995,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 999, 0, 0, 0, 0, 0,
- 1001, 0, 0, 0, 997, 0, 0, 0, 0, 1003,
- 1005, 1007, 1009, 1011, 1013, 1015, 1017, 1019, 1021, 1023,
- 1025, 1027, 1029, 1031, 1033, 1035, 1037, 1039, 1041, 1043,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 1047, 0, 0, 0, 0, 0,
- 1049, 0, 0, 0, 1045, 0, 0, 0, 0, 1051,
- 1053, 1055, 1057, 1059, 1061, 1063, 1065, 1067, 1069, 1071,
- 1073, 1075, 1077, 1079, 1081, 1083, 1085, 1087, 1089, 1091,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 1095, 0, 0, 0, 0, 0,
- 1097, 0, 0, 0, 1093, 0, 0, 0, 0, 1099,
- 1101, 1103, 1105, 1107, 1109, 1111, 1113, 1115, 1117, 1119,
- 1121, 1123, 1125, 1127, 1129, 1131, 1133, 1135, 1137, 1139,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 1143, 0, 0, 0, 0, 0,
- 1145, 0, 0, 0, 1141, 0, 0, 0, 0, 1147,
- 1149, 1151, 1153, 1155, 1157, 1159, 1161, 1163, 1165, 1167,
- 1169, 1171, 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 355, 0, 0, 0, 0, 0,
- 357, 0, 0, 0, 1189, 0, 0, 0, 0, 359,
- 361, 363, 365, 367, 369, 371, 373, 375, 377, 379,
- 381, 383, 385, 387, 389, 391, 393, 395, 397, 399,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 97, 0, 0,
- 0, 0, 0, 0, 401, 0, 99, 101, 103, 105,
- 107, 109, 111, 113, 115, 117, 119, 121, 123, 125,
- 127, 129, 131, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 299, 301, 303, 305, 307,
- 309, 311, 313, 315, 317, 319, 321, 323, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 217, 219, 221, 223, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 209, 211, 213, 215, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 291, 293, 295, 297,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 235, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 237, 0, 0, 0, 0, 239, 0, 0, 0, 0,
- 325, 327, 329, 331, 333, 335, 337, 339, 341, 343,
- 345, 347, 349, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 403, 405, 407, 409, 411, 413, 415,
- 417, 419, 421, 423, 425, 427, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 429, 431, 433, 435, 437, 439,
- 441, 443, 445, 447, 449, 451, 453
- };
- /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
- 0, pointed into by YYCONFLP. */
- static const short int yyconfl[] =
- {
- 0, 167, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 167,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 177,
- 0, 167, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 180,
- 0, 180, 0, 180, 0, 180, 0, 179, 0, 179,
- 0, 179, 0, 179, 0, 68, 0, 71, 0, 76,
- 0, 109, 0, 110, 0, 113, 0, 113, 0, 113,
- 0, 175, 0, 167, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 179, 0, 179, 0, 179, 0, 179, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 97, 0, 104, 0, 167, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 167, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 63, 0, 167, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 167, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 167, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 167,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 46, 0, 46,
- 0, 46, 0, 46, 0, 46, 0, 69, 0, 70,
- 0, 167, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 167,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 167, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 167, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 167, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 167, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 167,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 167, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 167, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 167, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 72, 0, 73, 0, 74, 0, 75, 0, 77,
- 0, 78, 0
- };
- static const short int yycheck[] =
- {
- 11, 12, 47, 77, 3, 5, 6, 41, 10, 12,
- 144, 56, 27, 58, 11, 9, 241, 4, 27, 4,
- 4, 4, 18, 34, 7, 4, 20, 252, 10, 11,
- 41, 34, 257, 3, 28, 29, 0, 24, 22, 24,
- 4, 56, 8, 7, 41, 24, 55, 56, 57, 58,
- 59, 60, 3, 17, 5, 6, 14, 8, 22, 10,
- 11, 48, 49, 48, 49, 6, 77, 18, 19, 48,
- 49, 14, 13, 24, 77, 26, 25, 26, 212, 30,
- 31, 14, 33, 34, 35, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
- 51, 52, 53, 102, 24, 14, 4, 14, 153, 120,
- 155, 9, 14, 158, 159, 160, 0, 120, 4, 14,
- 154, 4, 20, 14, 125, 126, 9, 14, 48, 49,
- 28, 29, 14, 4, 4, 148, 149, 20, 9, 25,
- 26, 141, 142, 154, 143, 28, 29, 98, 99, 20,
- 161, 162, 163, 164, 4, 25, 26, 28, 29, 162,
- 163, 10, 11, 267, 268, 269, 270, 14, 14, 4,
- 14, 4, 21, 271, 272, 25, 26, 251, 223, 224,
- 225, 226, 227, 228, 229, 230, 14, 232, 233, 234,
- 25, 26, 25, 26, 4, 8, 47, 254, 255, 6,
- 24, 258, 259, 260, 261, 250, 46, 31, 13, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- 241, 13, 277, 278, 17, 4, 8, 3, 6, 238,
- 251, 252, 7, 6, 6, 256, 257, 6, 251, 6,
- 21, 21, 13, 256, 5, 7, 301, 302, 6, 6,
- 6, 6, 6, 308, 309, 310, 311, 312, 313, 314,
- 5, 273, 274, 275, 98, 325, 326, 327, 328, 329,
- 330, 331, 6, 18, 19, 6, 6, 332, 333, 334,
- 335, 336, 337, 338, 6, 6, 99, 7, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, 24, 7, 22, 325, 326, 327, 328, 329, 330,
- 331, 17, 325, 326, 327, 328, 329, 330, 331, 3,
- 8, 5, 6, 3, 8, 7, 10, 11, 98, 7,
- 7, 7, 7, 7, 18, 19, 7, 7, 7, 7,
- 24, 7, 26, 22, 132, 277, 30, 31, 146, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- 22, 22, 22, 22, 22, 22, 140, 154, 211, 147,
- 164, 164, -1, -1, -1, -1, -1, 161, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, 26, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
- -1, 5, 6, -1, 8, -1, 10, 11, -1, -1,
- -1, -1, -1, -1, 18, 19, -1, -1, -1, -1,
- 24, -1, -1, -1, 98, 99, 30, 31, -1, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 5, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 18, 19, -1, -1, -1, -1, 24, -1, -1,
- -1, -1, -1, -1, 98, 99, 33, 34, 35, 36,
- 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
- 47, 48, 49, 50, 51, 52, 53, 5, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 18, 19, -1, -1, -1, 6, -1, -1, -1, -1,
- -1, -1, 13, -1, -1, 33, 34, 35, 36, 37,
- 38, 39, 40, 41, 42, 43, 44, 45, -1, -1,
- 31, 98, 33, 34, 35, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
- 51, 52, 53, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 8, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 24,
- -1, -1, -1, -1, -1, -1, 31, 98, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 8,
- 16, -1, 18, -1, -1, 21, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 24, -1, -1, -1, -1,
- -1, -1, 31, 98, 33, 34, 35, 36, 37, 38,
- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
- 49, 50, 51, 52, 53, 61, 62, 63, 64, 65,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
- 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
- 96, 97, 24, -1, -1, -1, -1, -1, -1, 98,
- -1, 33, 34, 35, 36, 37, 38, 39, 40, 41,
- 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
- 52, 53, 31, -1, 33, 34, 35, 36, 37, 38,
- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
- 49, 50, 51, 52, 53, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 31, 98, 33, 34, 35,
- 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
- 46, 47, 48, 49, 50, 51, 52, 53, -1, 98,
- 99, 31, -1, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
- 50, 51, 52, 53, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 31, 98, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
- 50, 51, 52, 53, -1, -1, -1, -1, 98, 33,
- 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
- 0, -1, 5, -1, 4, -1, -1, 7, 8, 9,
- -1, -1, -1, -1, -1, 18, 19, 17, 98, -1,
- 20, -1, 22, 23, 24, 25, 26, 27, 28, 29,
- 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
- 43, 44, 45, -1, 98, 5, 46, 47, 48, 49,
- -1, -1, -1, -1, -1, -1, 56, -1, 18, 19,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 5, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 18,
- 19, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
- 39, 40, 41, 42, 43, 44, 45
- };
- /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
- symbol of state STATE-NUM. */
- static const unsigned char yystos[] =
- {
- 0, 3, 5, 6, 8, 10, 11, 18, 19, 24,
- 26, 30, 31, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
- 50, 51, 52, 53, 98, 99, 101, 102, 103, 104,
- 105, 106, 107, 112, 113, 114, 115, 116, 117, 118,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- 132, 133, 135, 138, 139, 140, 141, 142, 143, 144,
- 145, 146, 147, 149, 150, 151, 152, 153, 154, 155,
- 157, 158, 18, 116, 18, 33, 34, 35, 36, 37,
- 38, 39, 40, 41, 42, 43, 44, 45, 104, 104,
- 3, 8, 6, 131, 33, 34, 35, 36, 37, 38,
- 39, 40, 41, 42, 43, 44, 45, 98, 139, 158,
- 98, 157, 158, 157, 0, 10, 11, 24, 50, 51,
- 52, 53, 108, 136, 137, 139, 144, 14, 4, 160,
- 8, 10, 11, 21, 109, 110, 46, 47, 27, 56,
- 160, 160, 160, 6, 13, 17, 4, 4, 20, 23,
- 25, 148, 16, 18, 21, 61, 62, 63, 64, 65,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
- 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
- 96, 97, 24, 154, 157, 8, 3, 7, 116, 105,
- 105, 6, 109, 6, 13, 123, 104, 104, 111, 116,
- 110, 126, 127, 128, 128, 9, 20, 28, 29, 25,
- 26, 24, 48, 49, 134, 119, 120, 121, 160, 143,
- 144, 160, 5, 160, 160, 160, 147, 157, 157, 24,
- 152, 153, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 7, 132, 7, 24, 22, 160, 160, 160,
- 160, 160, 160, 160, 160, 160, 7, 17, 116, 145,
- 98, 22, 160, 145, 3, 156, 156, 156, 99, 157,
- 159, 145, 156, 156, 156, 156, 7, 129, 129, 129,
- 129, 130, 130, 131, 131, 131, 120, 160, 27, 55,
- 56, 57, 58, 59, 60, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 160, 160, 160, 160, 160,
- 160, 160, 159, 159, 159, 159, 159, 159, 159, 160,
- 160, 160, 160, 160, 160, 160, 22, 22, 22, 22,
- 22, 22, 22
- };
-
- /* Prevent warning if -Wmissing-prototypes. */
- int yyparse (void);
- /* Error token number */
- #define YYTERROR 1
- /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
- If N is 0, then set CURRENT to the empty location which ends
- the previous symbol: RHS[0] (always defined). */
- #ifndef YYLLOC_DEFAULT
- # define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)
- #endif
- #ifndef YY_LOCATION_PRINT
- # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
- #endif
- /* YYLEX -- calling `yylex' with the right arguments. */
- #define YYLEX yylex ()
- YYSTYPE yylval;
- YYLTYPE yylloc;
- int yynerrs;
- int yychar;
- static const int YYEOF = 0;
- static const int YYEMPTY = -2;
- typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
- #define YYCHK(YYE) \
- do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \
- while (YYID (0))
- #if YYDEBUG
- # ifndef YYFPRINTF
- # define YYFPRINTF fprintf
- # endif
- # define YYDPRINTF(Args) \
- do { \
- if (yydebug) \
- YYFPRINTF Args; \
- } while (YYID (0))
- /*--------------------------------.
- | Print this symbol on YYOUTPUT. |
- `--------------------------------*/
- /*ARGSUSED*/
- static void
- yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
- {
- if (!yyvaluep)
- return;
- # ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
- # else
- YYUSE (yyoutput);
- # endif
- switch (yytype)
- {
- default:
- break;
- }
- }
- /*--------------------------------.
- | Print this symbol on YYOUTPUT. |
- `--------------------------------*/
- static void
- yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
- {
- if (yytype < YYNTOKENS)
- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
- else
- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
- yy_symbol_value_print (yyoutput, yytype, yyvaluep);
- YYFPRINTF (yyoutput, ")");
- }
- # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
- do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, Type, \
- Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
- } while (YYID (0))
- /* Nonzero means print parse trace. It is left uninitialized so that
- multiple parsers can coexist. */
- int yydebug;
- #else /* !YYDEBUG */
- # define YYDPRINTF(Args)
- # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
- #endif /* !YYDEBUG */
- /* YYINITDEPTH -- initial size of the parser's stacks. */
- #ifndef YYINITDEPTH
- # define YYINITDEPTH 200
- #endif
- /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
- if the built-in stack extension method is used).
- Do not make this value too large; the results are undefined if
- SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem)
- evaluated with infinite-precision integer arithmetic. */
- #ifndef YYMAXDEPTH
- # define YYMAXDEPTH 10000
- #endif
- /* Minimum number of free items on the stack allowed after an
- allocation. This is to allow allocation and initialization
- to be completed by functions that call yyexpandGLRStack before the
- stack is expanded, thus insuring that all necessary pointers get
- properly redirected to new data. */
- #define YYHEADROOM 2
- #ifndef YYSTACKEXPANDABLE
- # if (! defined __cplusplus \
- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
- # define YYSTACKEXPANDABLE 1
- # else
- # define YYSTACKEXPANDABLE 0
- # endif
- #endif
- #if YYSTACKEXPANDABLE
- # define YY_RESERVE_GLRSTACK(Yystack) \
- do { \
- if (Yystack->yyspaceLeft < YYHEADROOM) \
- yyexpandGLRStack (Yystack); \
- } while (YYID (0))
- #else
- # define YY_RESERVE_GLRSTACK(Yystack) \
- do { \
- if (Yystack->yyspaceLeft < YYHEADROOM) \
- yyMemoryExhausted (Yystack); \
- } while (YYID (0))
- #endif
- #if YYERROR_VERBOSE
- # ifndef yystpcpy
- # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
- # define yystpcpy stpcpy
- # else
- /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
- YYDEST. */
- static char *
- yystpcpy (char *yydest, const char *yysrc)
- {
- char *yyd = yydest;
- const char *yys = yysrc;
- while ((*yyd++ = *yys++) != '\0')
- continue;
- return yyd - 1;
- }
- # endif
- # endif
- # ifndef yytnamerr
- /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
- quotes and backslashes, so that it's suitable for yyerror. The
- heuristic is that double-quoting is unnecessary unless the string
- contains an apostrophe, a comma, or backslash (other than
- backslash-backslash). YYSTR is taken from yytname. If YYRES is
- null, do not copy; instead, return the length of what the result
- would have been. */
- static size_t
- yytnamerr (char *yyres, const char *yystr)
- {
- if (*yystr == '"')
- {
- size_t yyn = 0;
- char const *yyp = yystr;
- for (;;)
- switch (*++yyp)
- {
- case '\'':
- case ',':
- goto do_not_strip_quotes;
- case '\\':
- if (*++yyp != '\\')
- goto do_not_strip_quotes;
- /* Fall through. */
- default:
- if (yyres)
- yyres[yyn] = *yyp;
- yyn++;
- break;
- case '"':
- if (yyres)
- yyres[yyn] = '\0';
- return yyn;
- }
- do_not_strip_quotes: ;
- }
- if (! yyres)
- return strlen (yystr);
- return yystpcpy (yyres, yystr) - yyres;
- }
- # endif
- #endif /* !YYERROR_VERBOSE */
- /** State numbers, as in LALR(1) machine */
- typedef int yyStateNum;
- /** Rule numbers, as in LALR(1) machine */
- typedef int yyRuleNum;
- /** Grammar symbol */
- typedef short int yySymbol;
- /** Item references, as in LALR(1) machine */
- typedef short int yyItemNum;
- typedef struct yyGLRState yyGLRState;
- typedef struct yyGLRStateSet yyGLRStateSet;
- typedef struct yySemanticOption yySemanticOption;
- typedef union yyGLRStackItem yyGLRStackItem;
- typedef struct yyGLRStack yyGLRStack;
- struct yyGLRState {
- /** Type tag: always true. */
- yybool yyisState;
- /** Type tag for yysemantics. If true, yysval applies, otherwise
- * yyfirstVal applies. */
- yybool yyresolved;
- /** Number of corresponding LALR(1) machine state. */
- yyStateNum yylrState;
- /** Preceding state in this stack */
- yyGLRState* yypred;
- /** Source position of the first token produced by my symbol */
- size_t yyposn;
- union {
- /** First in a chain of alternative reductions producing the
- * non-terminal corresponding to this state, threaded through
- * yynext. */
- yySemanticOption* yyfirstVal;
- /** Semantic value for this state. */
- YYSTYPE yysval;
- } yysemantics;
- /** Source location for this state. */
- YYLTYPE yyloc;
- };
- struct yyGLRStateSet {
- yyGLRState** yystates;
- /** During nondeterministic operation, yylookaheadNeeds tracks which
- * stacks have actually needed the current lookahead. During deterministic
- * operation, yylookaheadNeeds[0] is not maintained since it would merely
- * duplicate yychar != YYEMPTY. */
- yybool* yylookaheadNeeds;
- size_t yysize, yycapacity;
- };
- struct yySemanticOption {
- /** Type tag: always false. */
- yybool yyisState;
- /** Rule number for this reduction */
- yyRuleNum yyrule;
- /** The last RHS state in the list of states to be reduced. */
- yyGLRState* yystate;
- /** The lookahead for this reduction. */
- int yyrawchar;
- YYSTYPE yyval;
- YYLTYPE yyloc;
- /** Next sibling in chain of options. To facilitate merging,
- * options are chained in decreasing order by address. */
- yySemanticOption* yynext;
- };
- /** Type of the items in the GLR stack. The yyisState field
- * indicates which item of the union is valid. */
- union yyGLRStackItem {
- yyGLRState yystate;
- yySemanticOption yyoption;
- };
- struct yyGLRStack {
- int yyerrState;
- YYJMP_BUF yyexception_buffer;
- yyGLRStackItem* yyitems;
- yyGLRStackItem* yynextFree;
- size_t yyspaceLeft;
- yyGLRState* yysplitPoint;
- yyGLRState* yylastDeleted;
- yyGLRStateSet yytops;
- };
- #if YYSTACKEXPANDABLE
- static void yyexpandGLRStack (yyGLRStack* yystackp);
- #endif
- static void yyFail (yyGLRStack* yystackp, const char* yymsg)
- __attribute__ ((__noreturn__));
- static void
- yyFail (yyGLRStack* yystackp, const char* yymsg)
- {
- if (yymsg != NULL)
- yyerror (yymsg);
- YYLONGJMP (yystackp->yyexception_buffer, 1);
- }
- static void yyMemoryExhausted (yyGLRStack* yystackp)
- __attribute__ ((__noreturn__));
- static void
- yyMemoryExhausted (yyGLRStack* yystackp)
- {
- YYLONGJMP (yystackp->yyexception_buffer, 2);
- }
- #if YYDEBUG || YYERROR_VERBOSE
- /** A printable representation of TOKEN. */
- static inline const char*
- yytokenName (yySymbol yytoken)
- {
- if (yytoken == YYEMPTY)
- return "";
- return yytname[yytoken];
- }
- #endif
- /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
- * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred
- * containing the pointer to the next state in the chain. */
- static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__));
- static void
- yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
- {
- yyGLRState* s;
- int i;
- s = yyvsp[yylow0].yystate.yypred;
- for (i = yylow0-1; i >= yylow1; i -= 1)
- {
- YYASSERT (s->yyresolved);
- yyvsp[i].yystate.yyresolved = yytrue;
- yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
- yyvsp[i].yystate.yyloc = s->yyloc;
- s = yyvsp[i].yystate.yypred = s->yypred;
- }
- }
- /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in
- * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
- * For convenience, always return YYLOW1. */
- static inline int yyfill (yyGLRStackItem *, int *, int, yybool)
- __attribute__ ((__unused__));
- static inline int
- yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
- {
- if (!yynormal && yylow1 < *yylow)
- {
- yyfillin (yyvsp, *yylow, yylow1);
- *yylow = yylow1;
- }
- return yylow1;
- }
- /** Perform user action for rule number YYN, with RHS length YYRHSLEN,
- * and top stack item YYVSP. YYLVALP points to place to put semantic
- * value ($$), and yylocp points to place for location information
- * (@$). Returns yyok for normal return, yyaccept for YYACCEPT,
- * yyerr for YYERROR, yyabort for YYABORT. */
- /*ARGSUSED*/ static YYRESULTTAG
- yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
- YYSTYPE* yyvalp,
- YYLTYPE* YYOPTIONAL_LOC (yylocp),
- yyGLRStack* yystackp
- )
- {
- yybool yynormal __attribute__ ((__unused__)) =
- (yystackp->yysplitPoint == NULL);
- int yylow;
- # undef yyerrok
- # define yyerrok (yystackp->yyerrState = 0)
- # undef YYACCEPT
- # define YYACCEPT return yyaccept
- # undef YYABORT
- # define YYABORT return yyabort
- # undef YYERROR
- # define YYERROR return yyerrok, yyerr
- # undef YYRECOVERING
- # define YYRECOVERING() (yystackp->yyerrState != 0)
- # undef yyclearin
- # define yyclearin (yychar = YYEMPTY)
- # undef YYFILL
- # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
- # undef YYBACKUP
- # define YYBACKUP(Token, Value) \
- return yyerror (YY_("syntax error: cannot back up")), \
- yyerrok, yyerr
- yylow = 1;
- if (yyrhslen == 0)
- *yyvalp = yyval_default;
- else
- *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
- YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
- switch (yyn)
- {
- case 2:
- #line 219 "parser.y"
- { answer((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 6:
- #line 229 "parser.y"
- { ((*yyvalp).node) = PREP_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 7:
- #line 230 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 10:
- #line 236 "parser.y"
- { ((*yyvalp).node) = BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 12:
- #line 241 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 13:
- #line 242 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 14:
- #line 243 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 15:
- #line 247 "parser.y"
- { ((*yyvalp).node) = pxpath_new_path(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.string)); }
- break;
- case 16:
- #line 248 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 31:
- #line 268 "parser.y"
- { ((*yyvalp).node) = pxpath_new_path(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 32:
- #line 269 "parser.y"
- { ((*yyvalp).node) = pxpath_new_path(4, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (4))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (4))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (4))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (4))].yystate.yysemantics.yysval.string)); }
- break;
- case 33:
- #line 273 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 35:
- #line 278 "parser.y"
- { ((*yyvalp).node) = PXPWRAP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 37:
- #line 286 "parser.y"
- { ((*yyvalp).node) = PREP_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 38:
- #line 290 "parser.y"
- { ((*yyvalp).node) = BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 42:
- #line 300 "parser.y"
- { ((*yyvalp).string) = ""; }
- break;
- case 43:
- #line 303 "parser.y"
- { ((*yyvalp).node) = PXPWRAP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 46:
- #line 308 "parser.y"
- { ((*yyvalp).node) = PXPWRAP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 47:
- #line 309 "parser.y"
- { ((*yyvalp).node) = LIT((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 50:
- #line 315 "parser.y"
- { ((*yyvalp).node) = pxpath_new_func(xpath_alias(pxpath_to_string((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (4))].yystate.yysemantics.yysval.node))), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (4))].yystate.yysemantics.yysval.node)); }
- break;
- case 52:
- #line 319 "parser.y"
- { ((*yyvalp).node) = NULL; }
- break;
- case 53:
- #line 322 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node); (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node)->next = (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node); }
- break;
- case 55:
- #line 326 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node); }
- break;
- case 57:
- #line 330 "parser.y"
- { ((*yyvalp).node) = BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 60:
- #line 336 "parser.y"
- { ((*yyvalp).node) = BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 61:
- #line 337 "parser.y"
- { ((*yyvalp).node) = BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 63:
- #line 342 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 65:
- #line 347 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 67:
- #line 352 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 69:
- #line 357 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 70:
- #line 358 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 72:
- #line 363 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 73:
- #line 364 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 74:
- #line 365 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 75:
- #line 366 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 77:
- #line 371 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 78:
- #line 372 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 80:
- #line 377 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 81:
- #line 378 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 82:
- #line 379 "parser.y"
- { ((*yyvalp).node) = LIT_BIN_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((5) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 84:
- #line 384 "parser.y"
- { ((*yyvalp).node) = PREP_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 86:
- #line 391 "parser.y"
- { ((*yyvalp).node) = LIT((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 87:
- #line 392 "parser.y"
- { ((*yyvalp).node) = pxpath_new_literal(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.string)); }
- break;
- case 88:
- #line 393 "parser.y"
- { ((*yyvalp).node) = pxpath_new_literal(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 89:
- #line 394 "parser.y"
- { ((*yyvalp).node) = pxpath_new_literal(2, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.string)); }
- break;
- case 91:
- #line 402 "parser.y"
- { ((*yyvalp).node) = PREP_OP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 92:
- #line 406 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 93:
- #line 407 "parser.y"
- { ((*yyvalp).node) = pxpath_new_path(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 101:
- #line 424 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 102:
- #line 428 "parser.y"
- { ((*yyvalp).node) = pxpath_new_path(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.string)); }
- break;
- case 108:
- #line 449 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(4, pxpath_new_literal(1, ".//"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (4))].yystate.yysemantics.yysval.node), pxpath_new_literal(1, "|"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (4))].yystate.yysemantics.yysval.node)); }
- break;
- case 109:
- #line 450 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, pxpath_new_literal(1, ".//"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.node)); }
- break;
- case 111:
- #line 455 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (4))].yystate.yysemantics.yysval.node), PXP("/@"), PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (4))].yystate.yysemantics.yysval.string))); }
- break;
- case 112:
- #line 459 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.string)), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node)); }
- break;
- case 114:
- #line 464 "parser.y"
- { ((*yyvalp).string) = "/following-sibling::*[1]/self::"; }
- break;
- case 115:
- #line 465 "parser.y"
- { ((*yyvalp).string) = "/"; }
- break;
- case 116:
- #line 466 "parser.y"
- { ((*yyvalp).string) = "/following-sibling::*/self::"; }
- break;
- case 117:
- #line 467 "parser.y"
- { ((*yyvalp).string) = "//"; }
- break;
- case 119:
- #line 472 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(10, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), PXP("[@"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), PXP(" = "), (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), PXP(" or starts-with(@"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), PXP(", concat("), (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), PXP(", '-' ))]")); }
- break;
- case 120:
- #line 473 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(5, PXP("set-difference("), (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), PXP(", "), (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (5))].yystate.yysemantics.yysval.node), PXP(")")); }
- break;
- case 121:
- #line 474 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), "[@id='", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node), "']"); }
- break;
- case 122:
- #line 475 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (3))].yystate.yysemantics.yysval.node), "[contains(concat( ' ', @class, ' ' ), concat( ' ', '", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (3))].yystate.yysemantics.yysval.node), "', ' ' ))]"); }
- break;
- case 123:
- #line 476 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (4))].yystate.yysemantics.yysval.node), "[@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (4))].yystate.yysemantics.yysval.node), "]"); }
- break;
- case 124:
- #line 477 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[position() = ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 125:
- #line 478 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[position() > ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 126:
- #line 479 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[position() < ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 127:
- #line 480 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[contains(., ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 128:
- #line 481 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 129:
- #line 482 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[position() = ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 130:
- #line 483 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[position() = last() - ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (5))].yystate.yysemantics.yysval.string), "]"); }
- break;
- case 131:
- #line 484 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), " = ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), "]"); }
- break;
- case 132:
- #line 485 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), " != ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), "]"); }
- break;
- case 133:
- #line 486 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[starts-with(@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), ", ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), ")]"); }
- break;
- case 134:
- #line 487 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[ends-with(@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), ", ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), ")]"); }
- break;
- case 135:
- #line 488 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[contains(@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), ", ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), ")]"); }
- break;
- case 136:
- #line 489 "parser.y"
- { ((*yyvalp).node) = P6E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (9))].yystate.yysemantics.yysval.node), "[contains(@", (((yyGLRStackItem const *)yyvsp)[YYFILL ((3) - (9))].yystate.yysemantics.yysval.node), ", ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((7) - (9))].yystate.yysemantics.yysval.node), ")]"); }
- break;
- case 137:
- #line 490 "parser.y"
- { ((*yyvalp).node) = P4O("*[", (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (5))].yystate.yysemantics.yysval.node), "]/self::", (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 138:
- #line 491 "parser.y"
- { ((*yyvalp).node) = P4O("*[last() - ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (5))].yystate.yysemantics.yysval.node), "]/self::", (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node)); }
- break;
- case 139:
- #line 492 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[1]"); }
- break;
- case 140:
- #line 493 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[last()]"); }
- break;
- case 141:
- #line 494 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[position() % 2 = 0]"); }
- break;
- case 142:
- #line 495 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[position() % 2 = 1]"); }
- break;
- case 143:
- #line 496 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[contains('h1 h2 h3 h4 h5 h6', lower-case(local-name()))]"); }
- break;
- case 144:
- #line 497 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[not(node())]"); }
- break;
- case 145:
- #line 498 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[node()]"); }
- break;
- case 146:
- #line 499 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[1]"); }
- break;
- case 147:
- #line 500 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[last()]"); }
- break;
- case 148:
- #line 501 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[count()=1]"); }
- break;
- case 149:
- #line 502 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input']"); }
- break;
- case 150:
- #line 503 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input' and not(@disabled)]"); }
- break;
- case 151:
- #line 504 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input' and @disabled]"); }
- break;
- case 152:
- #line 505 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[@checked]"); }
- break;
- case 153:
- #line 506 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[@selected]"); }
- break;
- case 154:
- #line 507 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[1]/self::"); }
- break;
- case 155:
- #line 508 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[last()]/self::"); }
- break;
- case 156:
- #line 509 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[count()=1]/self::"); }
- break;
- case 157:
- #line 510 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), text); }
- break;
- case 158:
- #line 511 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), password); }
- break;
- case 159:
- #line 512 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), radio); }
- break;
- case 160:
- #line 513 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), checkbox); }
- break;
- case 161:
- #line 514 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), submit); }
- break;
- case 162:
- #line 515 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), image); }
- break;
- case 163:
- #line 516 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), reset); }
- break;
- case 164:
- #line 517 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), button); }
- break;
- case 165:
- #line 518 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), file); }
- break;
- case 167:
- #line 523 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 170:
- #line 532 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), PXP(":"), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 172:
- #line 537 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 173:
- #line 538 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node); }
- break;
- case 174:
- #line 539 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 175:
- #line 543 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.node); }
- break;
- case 176:
- #line 547 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(3, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), PXP(":"), PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.string))); }
- break;
- case 177:
- #line 548 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 178:
- #line 552 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 179:
- #line 556 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 180:
- #line 557 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string) + 1); }
- break;
- case 181:
- #line 558 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string)), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 182:
- #line 559 "parser.y"
- { ((*yyvalp).node) = pxpath_cat_paths(2, PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.string) + 1), (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 183:
- #line 560 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 206:
- #line 589 "parser.y"
- { ((*yyvalp).node) = pxpath_new_literal(1, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 207:
- #line 593 "parser.y"
- { ((*yyvalp).empty) = 0; }
- break;
- case 208:
- #line 594 "parser.y"
- { ((*yyvalp).empty) = 0; }
- break;
- /* Line 930 of glr.c. */
- #line 2546 "y.tab.c"
- default: break;
- }
- return yyok;
- # undef yyerrok
- # undef YYABORT
- # undef YYACCEPT
- # undef YYERROR
- # undef YYBACKUP
- # undef yyclearin
- # undef YYRECOVERING
- }
-
- /*ARGSUSED*/ static void
- yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
- {
- YYUSE (yy0);
- YYUSE (yy1);
- switch (yyn)
- {
-
- default: break;
- }
- }
- /* Bison grammar-table manipulation. */
- /*-----------------------------------------------.
- | Release the memory associated to this symbol. |
- `-----------------------------------------------*/
- /*ARGSUSED*/
- static void
- yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
- {
- YYUSE (yyvaluep);
- if (!yymsg)
- yymsg = "Deleting";
- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
- switch (yytype)
- {
- default:
- break;
- }
- }
- /** Number of symbols composing the right hand side of rule #RULE. */
- static inline int
- yyrhsLength (yyRuleNum yyrule)
- {
- return yyr2[yyrule];
- }
- static void
- yydestroyGLRState (char const *yymsg, yyGLRState *yys)
- {
- if (yys->yyresolved)
- yydestruct (yymsg, yystos[yys->yylrState],
- &yys->yysemantics.yysval);
- else
- {
- #if YYDEBUG
- if (yydebug)
- {
- if (yys->yysemantics.yyfirstVal)
- YYFPRINTF (stderr, "%s unresolved ", yymsg);
- else
- YYFPRINTF (stderr, "%s incomplete ", yymsg);
- yy_symbol_print (stderr, yystos[yys->yylrState],
- NULL);
- YYFPRINTF (stderr, "\n");
- }
- #endif
- if (yys->yysemantics.yyfirstVal)
- {
- yySemanticOption *yyoption = yys->yysemantics.yyfirstVal;
- yyGLRState *yyrh;
- int yyn;
- for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule);
- yyn > 0;
- yyrh = yyrh->yypred, yyn -= 1)
- yydestroyGLRState (yymsg, yyrh);
- }
- }
- }
- /** Left-hand-side symbol for rule #RULE. */
- static inline yySymbol
- yylhsNonterm (yyRuleNum yyrule)
- {
- return yyr1[yyrule];
- }
- #define yyis_pact_ninf(yystate) \
- ((yystate) == YYPACT_NINF)
- /** True iff LR state STATE has only a default reduction (regardless
- * of token). */
- static inline yybool
- yyisDefaultedState (yyStateNum yystate)
- {
- return yyis_pact_ninf (yypact[yystate]);
- }
- /** The default reduction for STATE, assuming it has one. */
- static inline yyRuleNum
- yydefaultAction (yyStateNum yystate)
- {
- return yydefact[yystate];
- }
- #define yyis_table_ninf(yytable_value) \
- YYID (0)
- /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
- * Result R means
- * R < 0: Reduce on rule -R.
- * R = 0: Error.
- * R > 0: Shift to state R.
- * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
- * conflicting reductions.
- */
- static inline void
- yygetLRActions (yyStateNum yystate, int yytoken,
- int* yyaction, const short int** yyconflicts)
- {
- int yyindex = yypact[yystate] + yytoken;
- if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
- {
- *yyaction = -yydefact[yystate];
- *yyconflicts = yyconfl;
- }
- else if (! yyis_table_ninf (yytable[yyindex]))
- {
- *yyaction = yytable[yyindex];
- *yyconflicts = yyconfl + yyconflp[yyindex];
- }
- else
- {
- *yyaction = 0;
- *yyconflicts = yyconfl + yyconflp[yyindex];
- }
- }
- static inline yyStateNum
- yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
- {
- int yyr;
- yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
- if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
- return yytable[yyr];
- else
- return yydefgoto[yylhs - YYNTOKENS];
- }
- static inline yybool
- yyisShiftAction (int yyaction)
- {
- return 0 < yyaction;
- }
- static inline yybool
- yyisErrorAction (int yyaction)
- {
- return yyaction == 0;
- }
- /* GLRStates */
- /** Return a fresh GLRStackItem. Callers should call
- * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
- * headroom. */
- static inline yyGLRStackItem*
- yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
- {
- yyGLRStackItem* yynewItem = yystackp->yynextFree;
- yystackp->yyspaceLeft -= 1;
- yystackp->yynextFree += 1;
- yynewItem->yystate.yyisState = yyisState;
- return yynewItem;
- }
- /** Add a new semantic action that will execute the action for rule
- * RULENUM on the semantic values in RHS to the list of
- * alternative actions for STATE. Assumes that RHS comes from
- * stack #K of *STACKP. */
- static void
- yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
- yyGLRState* rhs, yyRuleNum yyrule)
- {
- yySemanticOption* yynewOption =
- &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
- yynewOption->yystate = rhs;
- yynewOption->yyrule = yyrule;
- if (yystackp->yytops.yylookaheadNeeds[yyk])
- {
- yynewOption->yyrawchar = yychar;
- yynewOption->yyval = yylval;
- yynewOption->yyloc = yylloc;
- }
- else
- yynewOption->yyrawchar = YYEMPTY;
- yynewOption->yynext = yystate->yysemantics.yyfirstVal;
- yystate->yysemantics.yyfirstVal = yynewOption;
- YY_RESERVE_GLRSTACK (yystackp);
- }
- /* GLRStacks */
- /** Initialize SET to a singleton set containing an empty stack. */
- static yybool
- yyinitStateSet (yyGLRStateSet* yyset)
- {
- yyset->yysize = 1;
- yyset->yycapacity = 16;
- yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
- if (! yyset->yystates)
- return yyfalse;
- yyset->yystates[0] = NULL;
- yyset->yylookaheadNeeds =
- (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
- if (! yyset->yylookaheadNeeds)
- {
- YYFREE (yyset->yystates);
- return yyfalse;
- }
- return yytrue;
- }
- static void yyfreeStateSet (yyGLRStateSet* yyset)
- {
- YYFREE (yyset->yystates);
- YYFREE (yyset->yylookaheadNeeds);
- }
- /** Initialize STACK to a single empty stack, with total maximum
- * capacity for all stacks of SIZE. */
- static yybool
- yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
- {
- yystackp->yyerrState = 0;
- yynerrs = 0;
- yystackp->yyspaceLeft = yysize;
- yystackp->yyitems =
- (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]);
- if (!yystackp->yyitems)
- return yyfalse;
- yystackp->yynextFree = yystackp->yyitems;
- yystackp->yysplitPoint = NULL;
- yystackp->yylastDeleted = NULL;
- return yyinitStateSet (&yystackp->yytops);
- }
- #if YYSTACKEXPANDABLE
- # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
- &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
- /** If STACK is expandable, extend it. WARNING: Pointers into the
- stack from outside should be considered invalid after this call.
- We always expand when there are 1 or fewer items left AFTER an
- allocation, so that we can avoid having external pointers exist
- across an allocation. */
- static void
- yyexpandGLRStack (yyGLRStack* yystackp)
- {
- yyGLRStackItem* yynewItems;
- yyGLRStackItem* yyp0, *yyp1;
- size_t yysize, yynewSize;
- size_t yyn;
- yysize = yystackp->yynextFree - yystackp->yyitems;
- if (YYMAXDEPTH - YYHEADROOM < yysize)
- yyMemoryExhausted (yystackp);
- yynewSize = 2*yysize;
- if (YYMAXDEPTH < yynewSize)
- yynewSize = YYMAXDEPTH;
- yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
- if (! yynewItems)
- yyMemoryExhausted (yystackp);
- for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize;
- 0 < yyn;
- yyn -= 1, yyp0 += 1, yyp1 += 1)
- {
- *yyp1 = *yyp0;
- if (*(yybool *) yyp0)
- {
- yyGLRState* yys0 = &yyp0->yystate;
- yyGLRState* yys1 = &yyp1->yystate;
- if (yys0->yypred != NULL)
- yys1->yypred =
- YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
- if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
- yys1->yysemantics.yyfirstVal =
- YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
- }
- else
- {
- yySemanticOption* yyv0 = &yyp0->yyoption;
- yySemanticOption* yyv1 = &yyp1->yyoption;
- if (yyv0->yystate != NULL)
- yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
- if (yyv0->yynext != NULL)
- yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
- }
- }
- if (yystackp->yysplitPoint != NULL)
- yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
- yystackp->yysplitPoint, yystate);
- for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
- if (yystackp->yytops.yystates[yyn] != NULL)
- yystackp->yytops.yystates[yyn] =
- YYRELOC (yystackp->yyitems, yynewItems,
- yystackp->yytops.yystates[yyn], yystate);
- YYFREE (yystackp->yyitems);
- yystackp->yyitems = yynewItems;
- yystackp->yynextFree = yynewItems + yysize;
- yystackp->yyspaceLeft = yynewSize - yysize;
- }
- #endif
- static void
- yyfreeGLRStack (yyGLRStack* yystackp)
- {
- YYFREE (yystackp->yyitems);
- yyfreeStateSet (&yystackp->yytops);
- }
- /** Assuming that S is a GLRState somewhere on STACK, update the
- * splitpoint of STACK, if needed, so that it is at least as deep as
- * S. */
- static inline void
- yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
- {
- if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys)
- yystackp->yysplitPoint = yys;
- }
- /** Invalidate stack #K in STACK. */
- static inline void
- yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
- {
- if (yystackp->yytops.yystates[yyk] != NULL)
- yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
- yystackp->yytops.yystates[yyk] = NULL;
- }
- /** Undelete the last stack that was marked as deleted. Can only be
- done once after a deletion, and only when all other stacks have
- been deleted. */
- static void
- yyundeleteLastStack (yyGLRStack* yystackp)
- {
- if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0)
- return;
- yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
- yystackp->yytops.yysize = 1;
- YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
- yystackp->yylastDeleted = NULL;
- }
- static inline void
- yyremoveDeletes (yyGLRStack* yystackp)
- {
- size_t yyi, yyj;
- yyi = yyj = 0;
- while (yyj < yystackp->yytops.yysize)
- {
- if (yystackp->yytops.yystates[yyi] == NULL)
- {
- if (yyi == yyj)
- {
- YYDPRINTF ((stderr, "Removing dead stacks.\n"));
- }
- yystackp->yytops.yysize -= 1;
- }
- else
- {
- yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
- /* In the current implementation, it's unnecessary to copy
- yystackp->yytops.yylookaheadNeeds[yyi] since, after
- yyremoveDeletes returns, the parser immediately either enters
- deterministic operation or shifts a token. However, it doesn't
- hurt, and the code might evolve to need it. */
- yystackp->yytops.yylookaheadNeeds[yyj] =
- yystackp->yytops.yylookaheadNeeds[yyi];
- if (yyj != yyi)
- {
- YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
- (unsigned long int) yyi, (unsigned long int) yyj));
- }
- yyj += 1;
- }
- yyi += 1;
- }
- }
- /** Shift to a new state on stack #K of STACK, corresponding to LR state
- * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
- static inline void
- yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
- size_t yyposn,
- YYSTYPE* yyvalp, YYLTYPE* yylocp)
- {
- yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
- yynewState->yylrState = yylrState;
- yynewState->yyposn = yyposn;
- yynewState->yyresolved = yytrue;
- yynewState->yypred = yystackp->yytops.yystates[yyk];
- yynewState->yysemantics.yysval = *yyvalp;
- yynewState->yyloc = *yylocp;
- yystackp->yytops.yystates[yyk] = yynewState;
- YY_RESERVE_GLRSTACK (yystackp);
- }
- /** Shift stack #K of YYSTACK, to a new state corresponding to LR
- * state YYLRSTATE, at input position YYPOSN, with the (unresolved)
- * semantic value of YYRHS under the action for YYRULE. */
- static inline void
- yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
- size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)
- {
- yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
- yynewState->yylrState = yylrState;
- yynewState->yyposn = yyposn;
- yynewState->yyresolved = yyfalse;
- yynewState->yypred = yystackp->yytops.yystates[yyk];
- yynewState->yysemantics.yyfirstVal = NULL;
- yystackp->yytops.yystates[yyk] = yynewState;
- /* Invokes YY_RESERVE_GLRSTACK. */
- yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
- }
- /** Pop the symbols consumed by reduction #RULE from the top of stack
- * #K of STACK, and perform the appropriate semantic action on their
- * semantic values. Assumes that all ambiguities in semantic values
- * have been previously resolved. Set *VALP to the resulting value,
- * and *LOCP to the computed location (if any). Return value is as
- * for userAction. */
- static inline YYRESULTTAG
- yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
- YYSTYPE* yyvalp, YYLTYPE* yylocp)
- {
- int yynrhs = yyrhsLength (yyrule);
- if (yystackp->yysplitPoint == NULL)
- {
- /* Standard special case: single stack. */
- yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
- YYASSERT (yyk == 0);
- yystackp->yynextFree -= yynrhs;
- yystackp->yyspaceLeft += yynrhs;
- yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
- return yyuserAction (yyrule, yynrhs, rhs,
- yyvalp, yylocp, yystackp);
- }
- else
- {
- /* At present, doAction is never called in nondeterministic
- * mode, so this branch is never taken. It is here in
- * anticipation of a future feature that will allow immediate
- * evaluation of selected actions in nondeterministic mode. */
- int yyi;
- yyGLRState* yys;
- yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
- yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
- = yystackp->yytops.yystates[yyk];
- for (yyi = 0; yyi < yynrhs; yyi += 1)
- {
- yys = yys->yypred;
- YYASSERT (yys);
- }
- yyupdateSplit (yystackp, yys);
- yystackp->yytops.yystates[yyk] = yys;
- return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
- yyvalp, yylocp, yystackp);
- }
- }
- #if !YYDEBUG
- # define YY_REDUCE_PRINT(Args)
- #else
- # define YY_REDUCE_PRINT(Args) \
- do { \
- if (yydebug) \
- yy_reduce_print Args; \
- } while (YYID (0))
- /*----------------------------------------------------------.
- | Report that the RULE is going to be reduced on stack #K. |
- `----------------------------------------------------------*/
- /*ARGSUSED*/ static inline void
- yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
- YYSTYPE* yyvalp, YYLTYPE* yylocp)
- {
- int yynrhs = yyrhsLength (yyrule);
- yybool yynormal __attribute__ ((__unused__)) =
- (yystackp->yysplitPoint == NULL);
- yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
- int yylow = 1;
- int yyi;
- YYUSE (yyvalp);
- YYUSE (yylocp);
- YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
- (unsigned long int) yyk, yyrule - 1,
- (unsigned long int) yyrline[yyrule]);
- /* The symbols being reduced. */
- for (yyi = 0; yyi < yynrhs; yyi++)
- {
- fprintf (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
- &(((yyGLRStackItem const *)yyvsp)[YYFILL ((yyi + 1) - (yynrhs))].yystate.yysemantics.yysval)
- );
- fprintf (stderr, "\n");
- }
- }
- #endif
- /** Pop items off stack #K of STACK according to grammar rule RULE,
- * and push back on the resulting nonterminal symbol. Perform the
- * semantic action associated with RULE and store its value with the
- * newly pushed state, if FORCEEVAL or if STACK is currently
- * unambiguous. Otherwise, store the deferred semantic action with
- * the new state. If the new state would have an identical input
- * position, LR state, and predecessor to an existing state on the stack,
- * it is identified with that existing state, eliminating stack #K from
- * the STACK. In this case, the (necessarily deferred) semantic value is
- * added to the options for the existing state's semantic value.
- */
- static inline YYRESULTTAG
- yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
- yybool yyforceEval)
- {
- size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
- if (yyforceEval || yystackp->yysplitPoint == NULL)
- {
- YYSTYPE yysval;
- YYLTYPE yyloc;
- YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc));
- YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval,
- &yyloc));
- YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
- yyglrShift (yystackp, yyk,
- yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
- yylhsNonterm (yyrule)),
- yyposn, &yysval, &yyloc);
- }
- else
- {
- size_t yyi;
- int yyn;
- yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
- yyStateNum yynewLRState;
- for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
- 0 < yyn; yyn -= 1)
- {
- yys = yys->yypred;
- YYASSERT (yys);
- }
- yyupdateSplit (yystackp, yys);
- yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
- YYDPRINTF ((stderr,
- "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
- (unsigned long int) yyk, yyrule - 1, yynewLRState));
- for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
- if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
- {
- yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
- yyp = yystackp->yytops.yystates[yyi];
- while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
- {
- if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
- {
- yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
- yymarkStackDeleted (yystackp, yyk);
- YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
- (unsigned long int) yyk,
- (unsigned long int) yyi));
- return yyok;
- }
- yyp = yyp->yypred;
- }
- }
- yystackp->yytops.yystates[yyk] = yys;
- yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule);
- }
- return yyok;
- }
- static size_t
- yysplitStack (yyGLRStack* yystackp, size_t yyk)
- {
- if (yystackp->yysplitPoint == NULL)
- {
- YYASSERT (yyk == 0);
- yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
- }
- if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
- {
- yyGLRState** yynewStates;
- yybool* yynewLookaheadNeeds;
- yynewStates = NULL;
- if (yystackp->yytops.yycapacity
- > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
- yyMemoryExhausted (yystackp);
- yystackp->yytops.yycapacity *= 2;
- yynewStates =
- (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
- (yystackp->yytops.yycapacity
- * sizeof yynewStates[0]));
- if (yynewStates == NULL)
- yyMemoryExhausted (yystackp);
- yystackp->yytops.yystates = yynewStates;
- yynewLookaheadNeeds =
- (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
- (yystackp->yytops.yycapacity
- * sizeof yynewLookaheadNeeds[0]));
- if (yynewLookaheadNeeds == NULL)
- yyMemoryExhausted (yystackp);
- yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
- }
- yystackp->yytops.yystates[yystackp->yytops.yysize]
- = yystackp->yytops.yystates[yyk];
- yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
- = yystackp->yytops.yylookaheadNeeds[yyk];
- yystackp->yytops.yysize += 1;
- return yystackp->yytops.yysize-1;
- }
- /** True iff Y0 and Y1 represent identical options at the top level.
- * That is, they represent the same rule applied to RHS symbols
- * that produce the same terminal symbols. */
- static yybool
- yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
- {
- if (yyy0->yyrule == yyy1->yyrule)
- {
- yyGLRState *yys0, *yys1;
- int yyn;
- for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
- yyn = yyrhsLength (yyy0->yyrule);
- yyn > 0;
- yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
- if (yys0->yyposn != yys1->yyposn)
- return yyfalse;
- return yytrue;
- }
- else
- return yyfalse;
- }
- /** Assuming identicalOptions (Y0,Y1), destructively merge the
- * alternative semantic values for the RHS-symbols of Y1 and Y0. */
- static void
- yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
- {
- yyGLRState *yys0, *yys1;
- int yyn;
- for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
- yyn = yyrhsLength (yyy0->yyrule);
- yyn > 0;
- yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
- {
- if (yys0 == yys1)
- break;
- else if (yys0->yyresolved)
- {
- yys1->yyresolved = yytrue;
- yys1->yysemantics.yysval = yys0->yysemantics.yysval;
- }
- else if (yys1->yyresolved)
- {
- yys0->yyresolved = yytrue;
- yys0->yysemantics.yysval = yys1->yysemantics.yysval;
- }
- else
- {
- yySemanticOption** yyz0p;
- yySemanticOption* yyz1;
- yyz0p = &yys0->yysemantics.yyfirstVal;
- yyz1 = yys1->yysemantics.yyfirstVal;
- while (YYID (yytrue))
- {
- if (yyz1 == *yyz0p || yyz1 == NULL)
- break;
- else if (*yyz0p == NULL)
- {
- *yyz0p = yyz1;
- break;
- }
- else if (*yyz0p < yyz1)
- {
- yySemanticOption* yyz = *yyz0p;
- *yyz0p = yyz1;
- yyz1 = yyz1->yynext;
- (*yyz0p)->yynext = yyz;
- }
- yyz0p = &(*yyz0p)->yynext;
- }
- yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal;
- }
- }
- }
- /** Y0 and Y1 represent two possible actions to take in a given
- * parsing state; return 0 if no combination is possible,
- * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
- static int
- yypreference (yySemanticOption* y0, yySemanticOption* y1)
- {
- yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
- int p0 = yydprec[r0], p1 = yydprec[r1];
- if (p0 == p1)
- {
- if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
- return 0;
- else
- return 1;
- }
- if (p0 == 0 || p1 == 0)
- return 0;
- if (p0 < p1)
- return 3;
- if (p1 < p0)
- return 2;
- return 0;
- }
- static YYRESULTTAG yyresolveValue (yyGLRState* yys,
- yyGLRStack* yystackp);
- /** Resolve the previous N states starting at and including state S. If result
- * != yyok, some states may have been left unresolved possibly with empty
- * semantic option chains. Regardless of whether result = yyok, each state
- * has been left with consistent data so that yydestroyGLRState can be invoked
- * if necessary. */
- static YYRESULTTAG
- yyresolveStates (yyGLRState* yys, int yyn,
- yyGLRStack* yystackp)
- {
- if (0 < yyn)
- {
- YYASSERT (yys->yypred);
- YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp));
- if (! yys->yyresolved)
- YYCHK (yyresolveValue (yys, yystackp));
- }
- return yyok;
- }
- /** Resolve the states for the RHS of OPT, perform its user action, and return
- * the semantic value and location. Regardless of whether result = yyok, all
- * RHS states have been destroyed (assuming the user action destroys all RHS
- * semantic values if invoked). */
- static YYRESULTTAG
- yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
- YYSTYPE* yyvalp, YYLTYPE* yylocp)
- {
- yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
- int yynrhs;
- int yychar_current;
- YYSTYPE yylval_current;
- YYLTYPE yylloc_current;
- YYRESULTTAG yyflag;
- yynrhs = yyrhsLength (yyopt->yyrule);
- yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp);
- if (yyflag != yyok)
- {
- yyGLRState *yys;
- for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
- yydestroyGLRState ("Cleanup: popping", yys);
- return yyflag;
- }
- yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;
- yychar_current = yychar;
- yylval_current = yylval;
- yylloc_current = yylloc;
- yychar = yyopt->yyrawchar;
- yylval = yyopt->yyval;
- yylloc = yyopt->yyloc;
- yyflag = yyuserAction (yyopt->yyrule, yynrhs,
- yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
- yyvalp, yylocp, yystackp);
- yychar = yychar_current;
- yylval = yylval_current;
- yylloc = yylloc_current;
- return yyflag;
- }
- #if YYDEBUG
- static void
- yyreportTree (yySemanticOption* yyx, int yyindent)
- {
- int yynrhs = yyrhsLength (yyx->yyrule);
- int yyi;
- yyGLRState* yys;
- yyGLRState* yystates[1 + YYMAXRHS];
- yyGLRState yyleftmost_state;
- for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
- yystates[yyi] = yys;
- if (yys == NULL)
- {
- yyleftmost_state.yyposn = 0;
- yystates[0] = &yyleftmost_state;
- }
- else
- yystates[0] = yys;
- if (yyx->yystate->yyposn < yys->yyposn + 1)
- YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
- yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule - 1);
- else
- YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
- yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
- (unsigned long int) yyx->yystate->yyposn);
- for (yyi = 1; yyi <= yynrhs; yyi += 1)
- {
- if (yystates[yyi]->yyresolved)
- {
- if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
- YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
- yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
- else
- YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
- yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
- (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
- (unsigned long int) yystates[yyi]->yyposn);
- }
- else
- yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
- }
- }
- #endif
- /*ARGSUSED*/ static YYRESULTTAG
- yyreportAmbiguity (yySemanticOption* yyx0,
- yySemanticOption* yyx1)
- {
- YYUSE (yyx0);
- YYUSE (yyx1);
- #if YYDEBUG
- YYFPRINTF (stderr, "Ambiguity detected.\n");
- YYFPRINTF (stderr, "Option 1,\n");
- yyreportTree (yyx0, 2);
- YYFPRINTF (stderr, "\nOption 2,\n");
- yyreportTree (yyx1, 2);
- YYFPRINTF (stderr, "\n");
- #endif
- yyerror (YY_("syntax is ambiguous"));
- return yyabort;
- }
- /** Starting at and including state S1, resolve the location for each of the
- * previous N1 states that is unresolved. The first semantic option of a state
- * is always chosen. */
- static void
- yyresolveLocations (yyGLRState* yys1, int yyn1,
- yyGLRStack *yystackp)
- {
- if (0 < yyn1)
- {
- yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp);
- if (!yys1->yyresolved)
- {
- yySemanticOption *yyoption;
- yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
- int yynrhs;
- int yychar_current;
- YYSTYPE yylval_current;
- YYLTYPE yylloc_current;
- yyoption = yys1->yysemantics.yyfirstVal;
- YYASSERT (yyoption != NULL);
- yynrhs = yyrhsLength (yyoption->yyrule);
- if (yynrhs > 0)
- {
- yyGLRState *yys;
- int yyn;
- yyresolveLocations (yyoption->yystate, yynrhs,
- yystackp);
- for (yys = yyoption->yystate, yyn = yynrhs;
- yyn > 0;
- yys = yys->yypred, yyn -= 1)
- yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
- }
- else
- {
- /* Both yyresolveAction and yyresolveLocations traverse the GSS
- in reverse rightmost order. It is only necessary to invoke
- yyresolveLocations on a subforest for which yyresolveAction
- would have been invoked next had an ambiguity not been
- detected. Thus the location of the previous state (but not
- necessarily the previous state itself) is guaranteed to be
- resolved already. */
- yyGLRState *yyprevious = yyoption->yystate;
- yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
- }
- yychar_current = yychar;
- yylval_current = yylval;
- yylloc_current = yylloc;
- yychar = yyoption->yyrawchar;
- yylval = yyoption->yyval;
- yylloc = yyoption->yyloc;
- YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
- yychar = yychar_current;
- yylval = yylval_current;
- yylloc = yylloc_current;
- }
- }
- }
- /** Resolve the ambiguity represented in state S, perform the indicated
- * actions, and set the semantic value of S. If result != yyok, the chain of
- * semantic options in S has been cleared instead or it has been left
- * unmodified except that redundant options may have been removed. Regardless
- * of whether result = yyok, S has been left with consistent data so that
- * yydestroyGLRState can be invoked if necessary. */
- static YYRESULTTAG
- yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp)
- {
- yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
- yySemanticOption* yybest;
- yySemanticOption** yypp;
- yybool yymerge;
- YYSTYPE yysval;
- YYRESULTTAG yyflag;
- YYLTYPE *yylocp = &yys->yyloc;
- yybest = yyoptionList;
- yymerge = yyfalse;
- for (yypp = &yyoptionList->yynext; *yypp != NULL; )
- {
- yySemanticOption* yyp = *yypp;
- if (yyidenticalOptions (yybest, yyp))
- {
- yymergeOptionSets (yybest, yyp);
- *yypp = yyp->yynext;
- }
- else
- {
- switch (yypreference (yybest, yyp))
- {
- case 0:
- yyresolveLocations (yys, 1, yystackp);
- return yyreportAmbiguity (yybest, yyp);
- break;
- case 1:
- yymerge = yytrue;
- break;
- case 2:
- break;
- case 3:
- yybest = yyp;
- yymerge = yyfalse;
- break;
- default:
- /* This cannot happen so it is not worth a YYASSERT (yyfalse),
- but some compilers complain if the default case is
- omitted. */
- break;
- }
- yypp = &yyp->yynext;
- }
- }
- if (yymerge)
- {
- yySemanticOption* yyp;
- int yyprec = yydprec[yybest->yyrule];
- yyflag = yyresolveAction (yybest, yystackp, &yysval,
- yylocp);
- if (yyflag == yyok)
- for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
- {
- if (yyprec == yydprec[yyp->yyrule])
- {
- YYSTYPE yysval_other;
- YYLTYPE yydummy;
- yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
- &yydummy);
- if (yyflag != yyok)
- {
- yydestruct ("Cleanup: discarding incompletely merged value for",
- yystos[yys->yylrState],
- &yysval);
- break;
- }
- yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
- }
- }
- }
- else
- yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp);
- if (yyflag == yyok)
- {
- yys->yyresolved = yytrue;
- yys->yysemantics.yysval = yysval;
- }
- else
- yys->yysemantics.yyfirstVal = NULL;
- return yyflag;
- }
- static YYRESULTTAG
- yyresolveStack (yyGLRStack* yystackp)
- {
- if (yystackp->yysplitPoint != NULL)
- {
- yyGLRState* yys;
- int yyn;
- for (yyn = 0, yys = yystackp->yytops.yystates[0];
- yys != yystackp->yysplitPoint;
- yys = yys->yypred, yyn += 1)
- continue;
- YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
- ));
- }
- return yyok;
- }
- static void
- yycompressStack (yyGLRStack* yystackp)
- {
- yyGLRState* yyp, *yyq, *yyr;
- if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
- return;
- for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
- yyp != yystackp->yysplitPoint;
- yyr = yyp, yyp = yyq, yyq = yyp->yypred)
- yyp->yypred = yyr;
- yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
- yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
- yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
- yystackp->yysplitPoint = NULL;
- yystackp->yylastDeleted = NULL;
- while (yyr != NULL)
- {
- yystackp->yynextFree->yystate = *yyr;
- yyr = yyr->yypred;
- yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
- yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
- yystackp->yynextFree += 1;
- yystackp->yyspaceLeft -= 1;
- }
- }
- static YYRESULTTAG
- yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
- size_t yyposn)
- {
- int yyaction;
- const short int* yyconflicts;
- yyRuleNum yyrule;
- while (yystackp->yytops.yystates[yyk] != NULL)
- {
- yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
- YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
- (unsigned long int) yyk, yystate));
- YYASSERT (yystate != YYFINAL);
- if (yyisDefaultedState (yystate))
- {
- yyrule = yydefaultAction (yystate);
- if (yyrule == 0)
- {
- YYDPRINTF ((stderr, "Stack %lu dies.\n",
- (unsigned long int) yyk));
- yymarkStackDeleted (yystackp, yyk);
- return yyok;
- }
- YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse));
- }
- else
- {
- yySymbol yytoken;
- yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = YYLEX;
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- }
- else
- yytoken = YYTRANSLATE (yychar);
- yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
- while (*yyconflicts != 0)
- {
- size_t yynewStack = yysplitStack (yystackp, yyk);
- YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
- (unsigned long int) yynewStack,
- (unsigned long int) yyk));
- YYCHK (yyglrReduce (yystackp, yynewStack,
- *yyconflicts, yyfalse));
- YYCHK (yyprocessOneStack (yystackp, yynewStack,
- yyposn));
- yyconflicts += 1;
- }
- if (yyisShiftAction (yyaction))
- break;
- else if (yyisErrorAction (yyaction))
- {
- YYDPRINTF ((stderr, "Stack %lu dies.\n",
- (unsigned long int) yyk));
- yymarkStackDeleted (yystackp, yyk);
- break;
- }
- else
- YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
- yyfalse));
- }
- }
- return yyok;
- }
- /*ARGSUSED*/ static void
- yyreportSyntaxError (yyGLRStack* yystackp)
- {
- if (yystackp->yyerrState == 0)
- {
- #if YYERROR_VERBOSE
- int yyn;
- yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
- if (YYPACT_NINF < yyn && yyn <= YYLAST)
- {
- yySymbol yytoken = YYTRANSLATE (yychar);
- size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
- size_t yysize = yysize0;
- size_t yysize1;
- yybool yysize_overflow = yyfalse;
- char* yymsg = NULL;
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- int yyx;
- char *yyfmt;
- char const *yyf;
- static char const yyunexpected[] = "syntax error, unexpected %s";
- static char const yyexpecting[] = ", expecting %s";
- static char const yyor[] = " or %s";
- char yyformat[sizeof yyunexpected
- + sizeof yyexpecting - 1
- + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
- * (sizeof yyor - 1))];
- char const *yyprefix = yyexpecting;
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yycount = 1;
- yyarg[0] = yytokenName (yytoken);
- yyfmt = yystpcpy (yyformat, yyunexpected);
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- yyformat[sizeof yyunexpected - 1] = '\0';
- break;
- }
- yyarg[yycount++] = yytokenName (yyx);
- yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
- yyfmt = yystpcpy (yyfmt, yyprefix);
- yyprefix = yyor;
- }
- yyf = YY_(yyformat);
- yysize1 = yysize + strlen (yyf);
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
- if (!yysize_overflow)
- yymsg = (char *) YYMALLOC (yysize);
- if (yymsg)
- {
- char *yyp = yymsg;
- int yyi = 0;
- while ((*yyp = *yyf))
- {
- if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyf += 2;
- }
- else
- {
- yyp++;
- yyf++;
- }
- }
- yyerror (yymsg);
- YYFREE (yymsg);
- }
- else
- {
- yyerror (YY_("syntax error"));
- yyMemoryExhausted (yystackp);
- }
- }
- else
- #endif /* YYERROR_VERBOSE */
- yyerror (YY_("syntax error"));
- yynerrs += 1;
- }
- }
- /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
- yylval, and yylloc are the syntactic category, semantic value, and location
- of the look-ahead. */
- /*ARGSUSED*/ static void
- yyrecoverSyntaxError (yyGLRStack* yystackp)
- {
- size_t yyk;
- int yyj;
- if (yystackp->yyerrState == 3)
- /* We just shifted the error token and (perhaps) took some
- reductions. Skip tokens until we can proceed. */
- while (YYID (yytrue))
- {
- yySymbol yytoken;
- if (yychar == YYEOF)
- yyFail (yystackp, NULL);
- if (yychar != YYEMPTY)
- {
- yytoken = YYTRANSLATE (yychar);
- yydestruct ("Error: discarding",
- yytoken, &yylval);
- }
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = YYLEX;
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
- if (yyis_pact_ninf (yyj))
- return;
- yyj += yytoken;
- if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
- {
- if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
- return;
- }
- else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
- return;
- }
- /* Reduce to one stack. */
- for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
- if (yystackp->yytops.yystates[yyk] != NULL)
- break;
- if (yyk >= yystackp->yytops.yysize)
- yyFail (yystackp, NULL);
- for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
- yymarkStackDeleted (yystackp, yyk);
- yyremoveDeletes (yystackp);
- yycompressStack (yystackp);
- /* Now pop stack until we find a state that shifts the error token. */
- yystackp->yyerrState = 3;
- while (yystackp->yytops.yystates[0] != NULL)
- {
- yyGLRState *yys = yystackp->yytops.yystates[0];
- yyj = yypact[yys->yylrState];
- if (! yyis_pact_ninf (yyj))
- {
- yyj += YYTERROR;
- if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
- && yyisShiftAction (yytable[yyj]))
- {
- /* Shift the error token having adjusted its location. */
- YYLTYPE yyerrloc;
- YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
- &yylval, &yyerrloc);
- yyglrShift (yystackp, 0, yytable[yyj],
- yys->yyposn, &yylval, &yyerrloc);
- yys = yystackp->yytops.yystates[0];
- break;
- }
- }
- yydestroyGLRState ("Error: popping", yys);
- yystackp->yytops.yystates[0] = yys->yypred;
- yystackp->yynextFree -= 1;
- yystackp->yyspaceLeft += 1;
- }
- if (yystackp->yytops.yystates[0] == NULL)
- yyFail (yystackp, NULL);
- }
- #define YYCHK1(YYE) \
- do { \
- switch (YYE) { \
- case yyok: \
- break; \
- case yyabort: \
- goto yyabortlab; \
- case yyaccept: \
- goto yyacceptlab; \
- case yyerr: \
- goto yyuser_error; \
- default: \
- goto yybuglab; \
- } \
- } while (YYID (0))
- /*----------.
- | yyparse. |
- `----------*/
- int
- yyparse (void)
- {
- int yyresult;
- yyGLRStack yystack;
- yyGLRStack* const yystackp = &yystack;
- size_t yyposn;
- YYDPRINTF ((stderr, "Starting parse\n"));
- yychar = YYEMPTY;
- yylval = yyval_default;
- if (! yyinitGLRStack (yystackp, YYINITDEPTH))
- goto yyexhaustedlab;
- switch (YYSETJMP (yystack.yyexception_buffer))
- {
- case 0: break;
- case 1: goto yyabortlab;
- case 2: goto yyexhaustedlab;
- default: goto yybuglab;
- }
- yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
- yyposn = 0;
- while (YYID (yytrue))
- {
- /* For efficiency, we have two loops, the first of which is
- specialized to deterministic operation (single stack, no
- potential ambiguity). */
- /* Standard mode */
- while (YYID (yytrue))
- {
- yyRuleNum yyrule;
- int yyaction;
- const short int* yyconflicts;
- yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
- if (yystate == YYFINAL)
- goto yyacceptlab;
- if (yyisDefaultedState (yystate))
- {
- yyrule = yydefaultAction (yystate);
- if (yyrule == 0)
- {
- yyreportSyntaxError (&yystack);
- goto yyuser_error;
- }
- YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue));
- }
- else
- {
- yySymbol yytoken;
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = YYLEX;
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- }
- else
- yytoken = YYTRANSLATE (yychar);
- yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
- if (*yyconflicts != 0)
- break;
- if (yyisShiftAction (yyaction))
- {
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- if (yychar != YYEOF)
- yychar = YYEMPTY;
- yyposn += 1;
- yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
- if (0 < yystack.yyerrState)
- yystack.yyerrState -= 1;
- }
- else if (yyisErrorAction (yyaction))
- {
- yyreportSyntaxError (&yystack);
- goto yyuser_error;
- }
- else
- YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue));
- }
- }
- while (YYID (yytrue))
- {
- yySymbol yytoken_to_shift;
- size_t yys;
- for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
- yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
- /* yyprocessOneStack returns one of three things:
- - An error flag. If the caller is yyprocessOneStack, it
- immediately returns as well. When the caller is finally
- yyparse, it jumps to an error label via YYCHK1.
- - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
- (&yystack, yys), which sets the top state of yys to NULL. Thus,
- yyparse's following invocation of yyremoveDeletes will remove
- the stack.
- - yyok, when ready to shift a token.
- Except in the first case, yyparse will invoke yyremoveDeletes and
- then shift the next token onto all remaining stacks. This
- synchronization of the shift (that is, after all preceding
- reductions on all stacks) helps prevent double destructor calls
- on yylval in the event of memory exhaustion. */
- for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
- YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn));
- yyremoveDeletes (&yystack);
- if (yystack.yytops.yysize == 0)
- {
- yyundeleteLastStack (&yystack);
- if (yystack.yytops.yysize == 0)
- yyFail (&yystack, YY_("syntax error"));
- YYCHK1 (yyresolveStack (&yystack));
- YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
- yyreportSyntaxError (&yystack);
- goto yyuser_error;
- }
- /* If any yyglrShift call fails, it will fail after shifting. Thus,
- a copy of yylval will already be on stack 0 in the event of a
- failure in the following loop. Thus, yychar is set to YYEMPTY
- before the loop to make sure the user destructor for yylval isn't
- called twice. */
- yytoken_to_shift = YYTRANSLATE (yychar);
- yychar = YYEMPTY;
- yyposn += 1;
- for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
- {
- int yyaction;
- const short int* yyconflicts;
- yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
- yygetLRActions (yystate, yytoken_to_shift, &yyaction,
- &yyconflicts);
- /* Note that yyconflicts were handled by yyprocessOneStack. */
- YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
- YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
- yyglrShift (&yystack, yys, yyaction, yyposn,
- &yylval, &yylloc);
- YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
- (unsigned long int) yys,
- yystack.yytops.yystates[yys]->yylrState));
- }
- if (yystack.yytops.yysize == 1)
- {
- YYCHK1 (yyresolveStack (&yystack));
- YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
- yycompressStack (&yystack);
- break;
- }
- }
- continue;
- yyuser_error:
- yyrecoverSyntaxError (&yystack);
- yyposn = yystack.yytops.yystates[0]->yyposn;
- }
- yyacceptlab:
- yyresult = 0;
- goto yyreturn;
- yybuglab:
- YYASSERT (yyfalse);
- goto yyabortlab;
- yyabortlab:
- yyresult = 1;
- goto yyreturn;
- yyexhaustedlab:
- yyerror (YY_("memory exhausted"));
- yyresult = 2;
- goto yyreturn;
- yyreturn:
- if (yychar != YYEOF && yychar != YYEMPTY)
- yydestruct ("Cleanup: discarding lookahead",
- YYTRANSLATE (yychar),
- &yylval);
- /* If the stack is well-formed, pop the stack until it is empty,
- destroying its entries as we go. But free the stack regardless
- of whether it is well-formed. */
- if (yystack.yyitems)
- {
- yyGLRState** yystates = yystack.yytops.yystates;
- if (yystates)
- {
- size_t yysize = yystack.yytops.yysize;
- size_t yyk;
- for (yyk = 0; yyk < yysize; yyk += 1)
- if (yystates[yyk])
- {
- while (yystates[yyk])
- {
- yyGLRState *yys = yystates[yyk];
- yydestroyGLRState ("Cleanup: popping", yys);
- yystates[yyk] = yys->yypred;
- yystack.yynextFree -= 1;
- yystack.yyspaceLeft += 1;
- }
- break;
- }
- }
- yyfreeGLRStack (&yystack);
- }
- /* Make sure YYID is used. */
- return YYID (yyresult);
- }
- /* DEBUGGING ONLY */
- #ifdef YYDEBUG
- static void yypstack (yyGLRStack* yystackp, size_t yyk)
- __attribute__ ((__unused__));
- static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
- static void
- yy_yypstack (yyGLRState* yys)
- {
- if (yys->yypred)
- {
- yy_yypstack (yys->yypred);
- fprintf (stderr, " -> ");
- }
- fprintf (stderr, "%d@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
- }
- static void
- yypstates (yyGLRState* yyst)
- {
- if (yyst == NULL)
- fprintf (stderr, "<null>");
- else
- yy_yypstack (yyst);
- fprintf (stderr, "\n");
- }
- static void
- yypstack (yyGLRStack* yystackp, size_t yyk)
- {
- yypstates (yystackp->yytops.yystates[yyk]);
- }
- #define YYINDEX(YYX) \
- ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
- static void
- yypdumpstack (yyGLRStack* yystackp)
- {
- yyGLRStackItem* yyp;
- size_t yyi;
- for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
- {
- fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
- if (*(yybool *) yyp)
- {
- fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
- yyp->yystate.yyresolved, yyp->yystate.yylrState,
- (unsigned long int) yyp->yystate.yyposn,
- (long int) YYINDEX (yyp->yystate.yypred));
- if (! yyp->yystate.yyresolved)
- fprintf (stderr, ", firstVal: %ld",
- (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
- }
- else
- {
- fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
- yyp->yyoption.yyrule - 1,
- (long int) YYINDEX (yyp->yyoption.yystate),
- (long int) YYINDEX (yyp->yyoption.yynext));
- }
- fprintf (stderr, "\n");
- }
- fprintf (stderr, "Tops:");
- for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
- fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
- (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
- fprintf (stderr, "\n");
- }
- #endif
- #line 597 "parser.y"
- char* xpath_alias(char* key) {
- char* value = (char*) xmlHashLookup(alias_hash, key);
- return value == NULL ? key : value;
- }
- void init_xpath_alias() {
- alias_hash = xmlHashCreate(100);
- xmlHashAddEntry(alias_hash, "html", "lib:html-document");
- xmlHashAddEntry(alias_hash, "match", "regexp:match");
- xmlHashAddEntry(alias_hash, "replace", "regexp:replace");
- xmlHashAddEntry(alias_hash, "test", "regexp:test");
- xmlHashAddEntry(alias_hash, "with-newlines", "lib:nl");
- }
- pxpathPtr myparse(char* string){
- // start_debugging();
- parsed_answer = NULL;
- prepare_parse(string);
- yyparse();
- cleanup_parse();
- return parsed_answer;
- }
- void answer(pxpathPtr a){
- parsed_answer = a;
- }
- void start_debugging(){
- yydebug = 1;
- return;
- }