/parser.c
C | 4284 lines | 3556 code | 396 blank | 332 comment | 343 complexity | 5608247565c41bf07ca2cf7580b6db9b 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 "parser.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 127
- /* YYLAST -- Last index in YYTABLE. */
- #define YYLAST 2367
- /* YYNTOKENS -- Number of terminals. */
- #define YYNTOKENS 101
- /* YYNNTS -- Number of nonterminals. */
- #define YYNNTS 61
- /* YYNRULES -- Number of rules. */
- #define YYNRULES 209
- /* YYNRULES -- Number of states. */
- #define YYNSTATES 358
- /* 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 355
- #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, 100
- };
- #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, 328, 332, 336, 338, 340,
- 350, 356, 360, 364, 369, 375, 381, 387, 393, 399,
- 405, 411, 421, 431, 441, 451, 461, 471, 477, 483,
- 486, 489, 492, 495, 501, 504, 507, 510, 513, 516,
- 519, 522, 525, 528, 531, 534, 537, 540, 543, 546,
- 549, 552, 555, 558, 561, 564, 567, 570, 572, 573,
- 575, 577, 580, 582, 585, 588, 590, 592, 595, 597,
- 599, 601, 603, 606, 609, 611, 613, 615, 617, 619,
- 621, 623, 625, 627, 629, 631, 633, 635, 637, 639,
- 641, 643, 645, 647, 649, 651, 653, 655, 657, 659
- };
- /* YYRHS -- A `-1'-separated list of the rules' RHS. */
- static const short int yyrhs[] =
- {
- 102, 0, -1, 117, 161, -1, 105, -1, 104, -1,
- 146, -1, 10, 105, -1, 10, -1, 113, -1, 106,
- -1, 105, 10, 106, -1, 114, -1, 107, 109, -1,
- 107, 109, 110, -1, 115, -1, 108, 14, -1, 116,
- -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, 137, -1, 138,
- 6, 7, -1, 52, 6, 133, 7, -1, 110, 111,
- -1, 111, -1, 21, 112, 22, -1, 117, -1, 11,
- 105, -1, 105, 11, 106, -1, 18, -1, 19, -1,
- 5, -1, -1, 6, 122, 7, -1, 126, -1, 136,
- -1, 6, 117, 7, -1, 133, -1, 134, -1, 119,
- -1, 139, 6, 120, 7, -1, 121, -1, -1, 122,
- 17, 121, -1, 122, -1, 161, 117, 161, -1, 124,
- -1, 123, 8, 124, -1, 103, -1, 125, -1, 125,
- 10, 105, -1, 125, 11, 105, -1, 118, -1, 125,
- 110, -1, 127, -1, 126, 46, 127, -1, 128, -1,
- 127, 47, 128, -1, 129, -1, 128, 27, 129, -1,
- 128, 56, 129, -1, 130, -1, 129, 161, 9, 161,
- 130, -1, 129, 161, 20, 161, 130, -1, 129, 161,
- 28, 161, 130, -1, 129, 161, 29, 161, 130, -1,
- 131, -1, 130, 161, 25, 161, 131, -1, 130, 161,
- 26, 161, 131, -1, 132, -1, 131, 161, 135, 161,
- 132, -1, 131, 161, 48, 161, 132, -1, 131, 161,
- 49, 161, 132, -1, 123, -1, 26, 132, -1, 100,
- -1, 3, -1, 3, 18, -1, 3, 18, 3, -1,
- 18, 3, -1, 24, -1, 30, 140, -1, 24, -1,
- 145, 13, 24, -1, 140, -1, 50, -1, 51, -1,
- 52, -1, 53, -1, 140, -1, 141, -1, 142, -1,
- 143, 13, 144, -1, 144, -1, 145, -1, 145, -1,
- 99, -1, 159, -1, 147, 17, 161, 146, -1, 147,
- -1, 148, -1, 148, 4, 5, 99, -1, 150, 149,
- 148, -1, 150, -1, 161, 25, 161, -1, 161, 20,
- 161, -1, 161, 23, 161, -1, 4, -1, 152, -1,
- 151, 21, 153, 161, 55, 161, 160, 161, 22, -1,
- 151, 63, 6, 146, 7, -1, 151, 16, 158, -1,
- 151, 18, 158, -1, 151, 21, 153, 22, -1, 151,
- 66, 6, 157, 7, -1, 151, 67, 6, 157, 7,
- -1, 151, 68, 6, 157, 7, -1, 151, 71, 6,
- 160, 7, -1, 151, 73, 6, 146, 7, -1, 151,
- 77, 6, 157, 7, -1, 151, 78, 6, 157, 7,
- -1, 151, 21, 153, 161, 27, 161, 160, 161, 22,
- -1, 151, 21, 153, 161, 56, 161, 160, 161, 22,
- -1, 151, 21, 153, 161, 57, 161, 160, 161, 22,
- -1, 151, 21, 153, 161, 58, 161, 160, 161, 22,
- -1, 151, 21, 153, 161, 59, 161, 160, 161, 22,
- -1, 151, 21, 153, 161, 60, 161, 160, 161, 22,
- -1, 151, 75, 6, 157, 7, -1, 151, 76, 6,
- 157, 7, -1, 151, 61, -1, 151, 62, -1, 151,
- 64, -1, 151, 65, -1, 151, 69, 6, 160, 7,
- -1, 151, 70, -1, 151, 72, -1, 151, 74, -1,
- 151, 81, -1, 151, 82, -1, 151, 84, -1, 151,
- 85, -1, 151, 95, -1, 151, 96, -1, 151, 97,
- -1, 151, 98, -1, 151, 79, -1, 151, 80, -1,
- 151, 83, -1, 151, 86, -1, 151, 87, -1, 151,
- 88, -1, 151, 89, -1, 151, 90, -1, 151, 91,
- -1, 151, 92, -1, 151, 93, -1, 151, 94, -1,
- 150, -1, -1, 153, -1, 156, -1, 154, 155, -1,
- 155, -1, 24, 8, -1, 158, 8, -1, 8, -1,
- 158, -1, 154, 24, -1, 24, -1, 3, -1, 99,
- -1, 31, -1, 99, 158, -1, 31, 158, -1, 159,
- -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, 158, -1, 100, -1, 4, -1, -1
- };
- /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
- static const unsigned short int yyrline[] =
- {
- 0, 220, 220, 224, 225, 226, 230, 231, 232, 236,
- 237, 238, 242, 243, 244, 248, 249, 252, 253, 254,
- 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
- 268, 269, 270, 274, 275, 279, 283, 287, 291, 295,
- 296, 300, 301, 304, 305, 308, 309, 310, 311, 312,
- 316, 319, 320, 323, 324, 327, 330, 331, 335, 336,
- 337, 338, 342, 343, 347, 348, 352, 353, 357, 358,
- 359, 363, 364, 365, 366, 367, 371, 372, 373, 377,
- 378, 379, 380, 384, 385, 389, 392, 393, 394, 395,
- 399, 403, 407, 408, 409, 413, 414, 415, 416, 420,
- 424, 425, 429, 433, 437, 441, 445, 446, 450, 451,
- 455, 456, 460, 461, 465, 466, 467, 468, 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, 519, 520, 524, 525, 529,
- 530, 534, 535, 539, 540, 541, 545, 549, 550, 554,
- 558, 559, 560, 561, 562, 566, 567, 568, 569, 570,
- 571, 572, 573, 574, 575, 576, 577, 578, 579, 580,
- 581, 582, 583, 584, 585, 586, 590, 591, 595, 596
- };
- #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", "CXCONTENT", "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, 101, 102, 103, 103, 103, 104, 104, 104, 105,
- 105, 105, 106, 106, 106, 107, 107, 108, 108, 108,
- 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
- 109, 109, 109, 110, 110, 111, 112, 113, 114, 115,
- 115, 116, 116, 117, 117, 118, 118, 118, 118, 118,
- 119, 120, 120, 121, 121, 122, 123, 123, 124, 124,
- 124, 124, 125, 125, 126, 126, 127, 127, 128, 128,
- 128, 129, 129, 129, 129, 129, 130, 130, 130, 131,
- 131, 131, 131, 132, 132, 133, 134, 134, 134, 134,
- 135, 136, 137, 137, 137, 138, 138, 138, 138, 139,
- 140, 140, 141, 142, 143, 144, 145, 145, 146, 146,
- 147, 147, 148, 148, 149, 149, 149, 149, 150, 150,
- 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
- 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
- 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
- 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
- 150, 150, 150, 150, 150, 150, 150, 151, 151, 152,
- 152, 153, 153, 154, 154, 154, 155, 156, 156, 157,
- 158, 158, 158, 158, 158, 159, 159, 159, 159, 159,
- 159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
- 159, 159, 159, 159, 159, 159, 160, 160, 161, 161
- };
- /* 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, 3, 3, 3, 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, 5, 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, 2, 3, 1, 3, 3, 3, 1, 2, 2,
- 2, 1, 2, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 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, 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[] =
- {
- 168, 86, 41, 168, 175, 7, 42, 39, 40, 178,
- 168, 0, 181, 185, 186, 187, 188, 189, 190, 191,
- 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
- 202, 203, 204, 205, 180, 85, 0, 58, 4, 3,
- 9, 0, 0, 8, 11, 14, 16, 209, 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, 167, 0, 118, 169, 0, 172, 170,
- 176, 184, 87, 208, 0, 0, 168, 39, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
- 29, 6, 37, 89, 173, 168, 84, 185, 186, 187,
- 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
- 106, 91, 107, 180, 183, 184, 182, 1, 42, 42,
- 92, 202, 203, 204, 205, 12, 30, 0, 94, 105,
- 15, 2, 168, 42, 42, 168, 63, 34, 168, 168,
- 168, 168, 0, 0, 0, 209, 0, 209, 0, 117,
- 168, 0, 0, 0, 0, 139, 140, 0, 141, 142,
- 0, 0, 0, 0, 144, 0, 145, 0, 146, 0,
- 0, 0, 0, 155, 156, 147, 148, 157, 149, 150,
- 158, 159, 160, 161, 162, 163, 164, 165, 166, 151,
- 152, 153, 154, 177, 171, 176, 174, 88, 46, 43,
- 209, 10, 38, 0, 13, 0, 0, 57, 60, 61,
- 0, 36, 33, 65, 67, 69, 70, 209, 209, 209,
- 209, 209, 209, 90, 209, 209, 209, 0, 51, 54,
- 102, 105, 168, 0, 112, 209, 209, 209, 121, 122,
- 0, 209, 0, 168, 0, 0, 0, 0, 0, 168,
- 0, 0, 0, 0, 55, 0, 31, 93, 35, 168,
- 168, 168, 168, 168, 168, 168, 168, 168, 50, 209,
- 108, 111, 115, 116, 114, 123, 0, 0, 179, 0,
- 0, 0, 207, 206, 0, 0, 0, 0, 0, 0,
- 0, 32, 72, 73, 74, 75, 77, 78, 81, 82,
- 80, 53, 209, 209, 209, 209, 209, 209, 209, 120,
- 124, 125, 126, 143, 127, 128, 137, 138, 129, 130,
- 0, 0, 0, 0, 0, 0, 0, 209, 209, 209,
- 209, 209, 209, 209, 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, 135, 146,
- 147, 220, 43, 44, 45, 46, 84, 48, 49, 237,
- 238, 239, 50, 51, 52, 53, 54, 55, 56, 57,
- 58, 59, 60, 61, 236, 62, 136, 137, 63, 64,
- 65, 66, 67, 68, 69, 70, 71, 72, 160, 73,
- 74, 75, 76, 77, 78, 79, 289, 80, 125, 294,
- 153
- };
- /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
- #define YYPACT_NINF -251
- static const short int yypact[] =
- {
- 436, 30, -251, 338, -251, 148, 90, 49, -251, 89,
- 507, 2191, 2084, 92, 96, 107, 122, 123, 127, 137,
- 159, 161, 164, 165, 166, 188, -251, -251, -251, -251,
- -251, -251, -251, -251, 1784, -251, 203, -251, -251, 15,
- -251, 2017, 191, -251, -251, -251, -251, 202, -251, -251,
- 204, -251, 57, 167, 169, 23, 87, 17, 16, -251,
- -251, -251, -251, 211, -251, -251, -251, 205, -251, 207,
- -251, 217, 231, 10, 1911, -251, -251, 1987, -251, -251,
- 228, 56, 234, -251, 242, 246, 578, -251, -251, -251,
- -251, -251, -251, -251, -251, -251, -251, -251, -251, -251,
- -251, 15, 15, -251, -251, 649, -251, -251, -251, -251,
- -251, -251, -251, -251, -251, -251, -251, -251, -251, -251,
- -251, -251, -251, 2124, -251, -251, -251, -251, 1765, 2240,
- -251, 235, 248, 249, 251, 237, -251, 253, -251, 247,
- -251, -251, 1714, 2281, 2322, 720, 250, -251, 791, 862,
- 933, 1004, 241, 35, -2, 8, 2191, 202, 257, 145,
- 1851, 151, 2151, 2151, 1918, -251, -251, 266, -251, -251,
- 267, 268, 269, 271, -251, 272, -251, 273, -251, 274,
- 275, 285, 286, -251, -251, -251, -251, -251, -251, -251,
- -251, -251, -251, -251, -251, -251, -251, -251, -251, -251,
- -251, -251, -251, -251, -251, -251, -251, -251, -251, -251,
- 202, -251, -251, 163, 237, 287, 276, -251, 15, 15,
- 277, -251, -251, 169, 23, 210, 236, 202, 202, 202,
- 202, 202, 202, -251, 202, 202, 202, 288, -251, 279,
- -251, -251, 1851, 194, -251, 202, 202, 202, -251, -251,
- 289, 41, 2151, 1851, 295, 295, 295, 2054, 2054, 1851,
- 295, 295, 295, 295, -251, 294, -251, -251, -251, 1075,
- 1146, 1217, 1288, 1359, 1430, 1501, 1572, 1643, -251, 202,
- -251, -251, -251, -251, -251, -251, 45, 298, -251, 299,
- 300, 301, -251, -251, 309, 310, 311, 312, 313, 314,
- 315, -251, 86, 88, 94, 134, 25, 27, -251, -251,
- -251, -251, 202, 202, 202, 202, 202, 202, 202, -251,
- -251, -251, -251, -251, -251, -251, -251, -251, -251, -251,
- 2054, 2054, 2054, 2054, 2054, 2054, 2054, 202, 202, 202,
- 202, 202, 202, 202, 280, 323, 325, 328, 329, 330,
- 331, -251, -251, -251, -251, -251, -251, -251
- };
- /* YYPGOTO[NTERM-NUM]. */
- static const short int yypgoto[] =
- {
- -251, -251, -251, -251, -1, -41, -251, -251, -251, 196,
- -137, -251, -251, -251, -251, -251, 3, -251, -251, -251,
- 44, 352, -251, 190, -251, -251, 185, 209, -57, -61,
- -124, -9, 147, -251, -251, -251, -251, -251, -251, 0,
- -251, -251, -251, 214, -34, -38, -251, 201, -251, -251,
- -251, -251, 199, 229, -75, -251, -116, -6, 13, -250,
- -3
- };
- /* 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 -210
- static const short int yytable[] =
- {
- 86, 106, 204, 47, 101, 102, 124, 139, 295, 222,
- -113, 121, 83, 81, 159, -52, 81, -113, -113, -113,
- 83, 83, 233, 81, 122, 128, 129, -113, 126, 83,
- -113, 83, -113, -209, -113, -113, -113, -113, -113, -113,
- -209, 138, -209, -209, 141, 83, 234, 235, 82, -209,
- 150, -209, 103, 152, 122, 154, -113, -113, -113, -113,
- 231, 232, -107, 285, -209, -209, -113, 143, 144, -107,
- 161, 205, 312, -209, -209, -209, -209, 222, 145, 151,
- 337, 338, 339, 340, 341, 342, 343, 211, 212, 210,
- 83, 83, 83, 225, 226, 2, -209, 104, 83, 81,
- 313, 314, 315, 316, 317, 318, -17, -209, 87, 8,
- -18, -209, -209, -209, -209, -209, -209, 126, 81, -209,
- -209, -19, 241, 88, 89, 90, 91, 92, 93, 94,
- 95, 96, 97, 98, 99, 100, -20, -21, 83, 290,
- 291, -22, 218, 219, 297, 298, 299, 300, 221, 306,
- 307, -23, 86, 2, 242, 81, 248, 249, 81, -209,
- -209, 81, 81, 81, 81, -208, 87, 8, -208, 122,
- -208, 245, -7, -24, 246, -25, 247, 204, -26, -27,
- -28, 88, 89, 90, 91, 92, 93, 94, 95, 96,
- 97, 98, 99, 100, -7, -7, -7, -7, -42, -42,
- -42, -42, -29, 127, 280, 140, 83, 264, 302, 303,
- 304, 305, 142, 148, 83, 287, 149, 155, 156, -209,
- -104, 296, 152, 152, 269, 270, 271, 272, 273, 274,
- -209, 275, 276, 277, 157, 158, 206, 207, -209, -209,
- 83, -95, 282, 283, 284, -209, 205, -42, 286, 208,
- 227, 293, 293, 209, -96, 213, -209, -98, 145, 215,
- 216, 228, 243, 35, -209, -209, 308, 309, 310, 229,
- 230, 145, 253, 254, 255, 256, 86, 257, 258, 259,
- 260, 261, 81, 81, 81, 81, 81, 81, 81, 81,
- 81, 262, 263, 281, 266, 278, 279, 104, 288, 268,
- 267, 301, 351, 154, 154, 319, 320, 321, 322, 330,
- 331, 332, 333, 334, 335, 336, 323, 324, 325, 326,
- 327, 328, 329, 311, 293, 293, 293, 293, 293, 293,
- 293, 214, 217, 223, 344, 345, 346, 347, 348, 349,
- 350, 1, 83, 2, 3, 352, 4, 353, 5, 6,
- 354, 355, 356, 357, -168, 85, 7, 8, 224, -168,
- 265, 244, 9, 251, 10, 0, 0, 0, 11, 12,
- 240, 13, 14, 15, 16, 17, 18, 19, 20, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 0, 252, 0, 0, 0, 0, 0, -168,
- -168, -168, -168, -168, -168, -168, -168, -168, -168, -168,
- -168, -168, -168, -168, -168, -168, -168, -168, -168, -168,
- -168, -168, -168, -168, -168, -168, -168, -168, -168, -168,
- -168, -168, -168, -168, -168, -168, -168, 34, 35, 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, 0, 0, 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, 0,
- 1, 0, 2, 105, 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,
- 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, 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, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105,
- 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, 0, 1, 0, 2,
- 105, 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, 0, 1, 0,
- 2, 105, 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, 0, 1,
- 0, 2, 105, 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, 0,
- 1, 0, 2, 105, 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,
- 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105, 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, 0, 1, 0, 2, 105,
- 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, 0, 1, 0, 2,
- 105, 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,
- 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 87, 8, 0, 0, 0, 0, 0,
- -106, 0, 0, 0, 0, 0, 0, -106, 88, 89,
- 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
- 100, 0, 0, 34, 35, 12, 0, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
- 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, 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, 123, 107, 108, 109, 110, 111, 112,
- 113, 114, 115, 116, 117, 118, 119, 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, 0, 4, 162, 0, 163,
- 0, 0, 164, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 250, 0, 0, 0, 0, 0, 0, 12,
- 123, 107, 108, 109, 110, 111, 112, 113, 114, 115,
- 116, 117, 118, 119, 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, 202,
- 0, 203, 0, 0, 0, 0, 0, 123, 12, 0,
- 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
- 117, 118, 119, 26, 27, 28, 29, 30, 31, 32,
- 33, 130, 0, 0, 0, 0, 0, 0, 0, 0,
- 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
- 117, 118, 119, 26, 27, 28, 29, 131, 132, 133,
- 134, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 12, 123, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
- 26, 27, 28, 29, 30, 31, 32, 33, 0, 0,
- 0, 0, 0, 0, 0, 12, 120, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
- 26, 27, 28, 29, 30, 31, 32, 33, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 123, 292, 12, 0, 107, 108, 109,
- 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
- 26, 27, 28, 29, 30, 31, 32, 33, 0, 0,
- 0, 0, 12, 123, 107, 108, 109, 110, 111, 112,
- 113, 114, 115, 116, 117, 118, 119, 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, 123, 107, 108, 109, 110, 111, 112,
- 113, 114, 115, 116, 117, 118, 119, 26, 27, 28,
- 29, 30, 31, 32, 33, 2, 0, 0, 0, 0,
- 123, 0, 0, 0, 0, 0, 0, 0, 87, 8,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 88, 89, 90, 91, 92, 93, 94,
- 95, 96, 97, 98, 99, 100, 2, 0, 0, 0,
- 120, 0, 0, 0, 0, 0, 0, 0, 0, 87,
- 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 88, 89, 90, 91, 92, 93,
- 94, 95, 96, 97, 98, 99, 100, 2, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 87, 8, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 88, 89, 90, 91, 92,
- 93, 94, 95, 96, 97, 98, 99, 100
- };
- /* 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, 361, 0, 0, 0, 0, 0,
- 355, 353, 0, 0, 0, 0, 0, 0, 0, 1315,
- 363, 1317, 0, 0, 0, 365, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 1307, 351, 1309, 0, 0, 0, 0, 285, 1311, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 259, 261, 263, 265, 267, 269, 271,
- 273, 275, 277, 279, 281, 283, 0, 0, 1313, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 223, 0, 0, 0, 0, 0, 0, 0,
- 0, 225, 227, 229, 231, 233, 235, 237, 239, 241,
- 243, 245, 247, 249, 251, 253, 255, 257, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 871, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 357, 359, 367, 0, 0, 0,
- 873, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 525, 0, 0, 0, 0,
- 527, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 677, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 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, 51, 53, 0, 55, 0, 57, 59,
- 0, 0, 0, 0, 61, 0, 63, 66, 0, 68,
- 0, 0, 70, 0, 73, 0, 0, 0, 75, 77,
- 0, 79, 82, 85, 88, 91, 94, 97, 100, 103,
- 106, 109, 112, 115, 118, 121, 124, 127, 130, 133,
- 136, 139, 0, 0, 0, 0, 0, 0, 0, 142,
- 144, 146, 148, 150, 152, 154, 156, 158, 160, 162,
- 164, 166, 168, 170, 172, 174, 176, 178, 180, 182,
- 184, 186, 188, 190, 192, 194, 196, 198, 200, 202,
- 204, 206, 208, 210, 212, 214, 216, 218, 221, 0,
- 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 287, 0, 0, 0, 0,
- 0, 289, 0, 0, 0, 47, 0, 0, 0, 0,
- 291, 293, 295, 297, 299, 301, 303, 305, 307, 309,
- 311, 313, 315, 317, 319, 321, 323, 325, 327, 329,
- 331, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 369, 0, 0, 0,
- 0, 0, 371, 0, 0, 0, 333, 0, 0, 0,
- 0, 373, 375, 377, 379, 381, 383, 385, 387, 389,
- 391, 393, 395, 397, 399, 401, 403, 405, 407, 409,
- 411, 413, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 417, 0, 0,
- 0, 0, 0, 419, 0, 0, 0, 415, 0, 0,
- 0, 0, 421, 423, 425, 427, 429, 431, 433, 435,
- 437, 439, 441, 443, 445, 447, 449, 451, 453, 455,
- 457, 459, 461, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 629, 0,
- 0, 0, 0, 0, 631, 0, 0, 0, 463, 0,
- 0, 0, 0, 633, 635, 637, 639, 641, 643, 645,
- 647, 649, 651, 653, 655, 657, 659, 661, 663, 665,
- 667, 669, 671, 673, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 679,
- 0, 0, 0, 0, 0, 681, 0, 0, 0, 675,
- 0, 0, 0, 0, 683, 685, 687, 689, 691, 693,
- 695, 697, 699, 701, 703, 705, 707, 709, 711, 713,
- 715, 717, 719, 721, 723, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 727, 0, 0, 0, 0, 0, 729, 0, 0, 0,
- 725, 0, 0, 0, 0, 731, 733, 735, 737, 739,
- 741, 743, 745, 747, 749, 751, 753, 755, 757, 759,
- 761, 763, 765, 767, 769, 771, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 775, 0, 0, 0, 0, 0, 777, 0, 0,
- 0, 773, 0, 0, 0, 0, 779, 781, 783, 785,
- 787, 789, 791, 793, 795, 797, 799, 801, 803, 805,
- 807, 809, 811, 813, 815, 817, 819, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 823, 0, 0, 0, 0, 0, 825, 0,
- 0, 0, 821, 0, 0, 0, 0, 827, 829, 831,
- 833, 835, 837, 839, 841, 843, 845, 847, 849, 851,
- 853, 855, 857, 859, 861, 863, 865, 867, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 875, 0, 0, 0, 0, 0, 877,
- 0, 0, 0, 869, 0, 0, 0, 0, 879, 881,
- 883, 885, 887, 889, 891, 893, 895, 897, 899, 901,
- 903, 905, 907, 909, 911, 913, 915, 917, 919, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 923, 0, 0, 0, 0, 0,
- 925, 0, 0, 0, 921, 0, 0, 0, 0, 927,
- 929, 931, 933, 935, 937, 939, 941, 943, 945, 947,
- 949, 951, 953, 955, 957, 959, 961, 963, 965, 967,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 971, 0, 0, 0, 0,
- 0, 973, 0, 0, 0, 969, 0, 0, 0, 0,
- 975, 977, 979, 981, 983, 985, 987, 989, 991, 993,
- 995, 997, 999, 1001, 1003, 1005, 1007, 1009, 1011, 1013,
- 1015, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 1019, 0, 0, 0,
- 0, 0, 1021, 0, 0, 0, 1017, 0, 0, 0,
- 0, 1023, 1025, 1027, 1029, 1031, 1033, 1035, 1037, 1039,
- 1041, 1043, 1045, 1047, 1049, 1051, 1053, 1055, 1057, 1059,
- 1061, 1063, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 1067, 0, 0,
- 0, 0, 0, 1069, 0, 0, 0, 1065, 0, 0,
- 0, 0, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
- 1087, 1089, 1091, 1093, 1095, 1097, 1099, 1101, 1103, 1105,
- 1107, 1109, 1111, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 1115, 0,
- 0, 0, 0, 0, 1117, 0, 0, 0, 1113, 0,
- 0, 0, 0, 1119, 1121, 1123, 1125, 1127, 1129, 1131,
- 1133, 1135, 1137, 1139, 1141, 1143, 1145, 1147, 1149, 1151,
- 1153, 1155, 1157, 1159, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1163,
- 0, 0, 0, 0, 0, 1165, 0, 0, 0, 1161,
- 0, 0, 0, 0, 1167, 1169, 1171, 1173, 1175, 1177,
- 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1193, 1195, 1197,
- 1199, 1201, 1203, 1205, 1207, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 1211, 0, 0, 0, 0, 0, 1213, 0, 0, 0,
- 1209, 0, 0, 0, 0, 1215, 1217, 1219, 1221, 1223,
- 1225, 1227, 1229, 1231, 1233, 1235, 1237, 1239, 1241, 1243,
- 1245, 1247, 1249, 1251, 1253, 1255, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 1259, 0, 0, 0, 0, 0, 1261, 0, 0,
- 0, 1257, 0, 0, 0, 0, 1263, 1265, 1267, 1269,
- 1271, 1273, 1275, 1277, 1279, 1281, 1283, 1285, 1287, 1289,
- 1291, 1293, 1295, 1297, 1299, 1301, 1303, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 529, 0, 0, 0, 0, 0, 531, 0,
- 0, 0, 1305, 0, 0, 0, 0, 533, 535, 537,
- 539, 541, 543, 545, 547, 549, 551, 553, 555, 557,
- 559, 561, 563, 565, 567, 569, 571, 573, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 473, 475,
- 477, 479, 481, 483, 485, 487, 489, 491, 493, 495,
- 497, 0, 0, 575, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 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, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 335, 337, 339, 341, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 465, 467, 469, 471, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 499, 501, 503, 505, 507, 509, 511,
- 513, 515, 517, 519, 521, 523, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 577, 579, 581, 583, 585, 587,
- 589, 591, 593, 595, 597, 599, 601, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 603, 605, 607, 609, 611,
- 613, 615, 617, 619, 621, 623, 625, 627
- };
- /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
- 0, pointed into by YYCONFLP. */
- static const short int yyconfl[] =
- {
- 0, 168, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 209,
- 0, 209, 0, 209, 0, 209, 0, 209, 0, 209,
- 0, 209, 0, 168, 209, 0, 209, 0, 209, 0,
- 42, 209, 0, 209, 0, 209, 0, 209, 0, 42,
- 209, 0, 42, 209, 0, 42, 209, 0, 42, 209,
- 0, 42, 209, 0, 42, 209, 0, 42, 209, 0,
- 42, 209, 0, 42, 209, 0, 42, 209, 0, 42,
- 209, 0, 42, 209, 0, 42, 209, 0, 42, 209,
- 0, 42, 209, 0, 42, 209, 0, 42, 209, 0,
- 42, 209, 0, 42, 209, 0, 42, 209, 0, 42,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 209, 0,
- 209, 0, 209, 0, 209, 0, 209, 0, 42, 209,
- 0, 209, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 178, 0, 168, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 181, 0, 181, 0, 181,
- 0, 181, 0, 180, 0, 180, 0, 180, 0, 180,
- 0, 68, 0, 71, 0, 76, 0, 109, 0, 110,
- 0, 113, 0, 209, 0, 209, 0, 176, 0, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 168, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 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, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 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, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 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, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 168, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 168, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 168, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 69, 0, 70, 0, 168, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 168, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 168, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 168, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 168, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 168, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 168, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 168,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 42, 0, 42, 0, 42, 0, 42,
- 0, 42, 0, 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[] =
- {
- 3, 10, 77, 0, 5, 6, 12, 41, 258, 146,
- 0, 11, 4, 0, 4, 7, 3, 7, 8, 9,
- 4, 4, 24, 10, 11, 10, 11, 17, 34, 4,
- 20, 4, 22, 23, 24, 25, 26, 27, 28, 29,
- 24, 41, 25, 26, 47, 4, 48, 49, 18, 24,
- 27, 24, 3, 56, 41, 58, 46, 47, 48, 49,
- 25, 26, 6, 22, 48, 49, 56, 10, 11, 13,
- 73, 77, 27, 48, 49, 48, 49, 214, 21, 56,
- 330, 331, 332, 333, 334, 335, 336, 128, 129, 86,
- 4, 4, 4, 150, 151, 5, 9, 8, 4, 86,
- 55, 56, 57, 58, 59, 60, 14, 20, 18, 19,
- 14, 25, 26, 25, 26, 28, 29, 123, 105, 25,
- 26, 14, 156, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 14, 14, 4, 255,
- 256, 14, 143, 144, 260, 261, 262, 263, 145, 273,
- 274, 14, 155, 5, 157, 142, 162, 163, 145, 25,
- 26, 148, 149, 150, 151, 20, 18, 19, 23, 156,
- 25, 20, 24, 14, 23, 14, 25, 252, 14, 14,
- 14, 33, 34, 35, 36, 37, 38, 39, 40, 41,
- 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
- 52, 53, 14, 0, 242, 14, 4, 210, 269, 270,
- 271, 272, 8, 46, 4, 253, 47, 6, 13, 9,
- 13, 259, 225, 226, 227, 228, 229, 230, 231, 232,
- 20, 234, 235, 236, 17, 4, 8, 3, 28, 29,
- 4, 6, 245, 246, 247, 9, 252, 99, 251, 7,
- 9, 257, 258, 7, 6, 6, 20, 6, 21, 6,
- 13, 20, 5, 100, 28, 29, 275, 276, 277, 28,
- 29, 21, 6, 6, 6, 6, 279, 6, 6, 6,
- 6, 6, 269, 270, 271, 272, 273, 274, 275, 276,
- 277, 6, 6, 99, 7, 7, 17, 8, 3, 22,
- 24, 7, 22, 306, 307, 7, 7, 7, 7, 312,
- 313, 314, 315, 316, 317, 318, 7, 7, 7, 7,
- 7, 7, 7, 279, 330, 331, 332, 333, 334, 335,
- 336, 135, 142, 148, 337, 338, 339, 340, 341, 342,
- 343, 3, 4, 5, 6, 22, 8, 22, 10, 11,
- 22, 22, 22, 22, 16, 3, 18, 19, 149, 21,
- 213, 160, 24, 164, 26, -1, -1, -1, 30, 31,
- 156, 33, 34, 35, 36, 37, 38, 39, 40, 41,
- 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
- 52, 53, -1, 164, -1, -1, -1, -1, -1, 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, 100, 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, -1, -1, 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, -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, 99, 100, 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,
- -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, 99, 100, 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, -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, 99, 100, 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, -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, 99, 100,
- 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, -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, 99,
- 100, 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, -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,
- 99, 100, 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, -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, 99, 100, 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, -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, 99, 100, 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, -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, 99, 100, 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, -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, 99, 100, 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, -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, 99, 100, 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,
- -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, 99, 100, 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, -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, 99, 100, 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, -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, 99, 100,
- 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, -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, 99,
- 100, 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, -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,
- 99, 100, 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, -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, 99, 100, 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, -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, 99, 100, 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,
- 5, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 18, 19, -1, -1, -1, -1, -1,
- 6, -1, -1, -1, -1, -1, -1, 13, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, -1, -1, 99, 100, 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, -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, 99, 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, -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,
- 99, 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, 98,
- -1, 24, -1, -1, -1, -1, -1, 99, 31, -1,
- 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
- 53, 24, -1, -1, -1, -1, -1, -1, -1, -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, 31, 99, 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, 31, 99, 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, 99, 100, 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, 31, 99, 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, 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,
- 99, -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, 5, -1, -1, -1,
- 99, -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, 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, 99, 100, 102, 103, 104, 105,
- 106, 107, 108, 113, 114, 115, 116, 117, 118, 119,
- 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
- 133, 134, 136, 139, 140, 141, 142, 143, 144, 145,
- 146, 147, 148, 150, 151, 152, 153, 154, 155, 156,
- 158, 159, 18, 4, 117, 122, 161, 18, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
- 45, 105, 105, 3, 8, 6, 132, 33, 34, 35,
- 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
- 99, 140, 159, 99, 158, 159, 158, 0, 10, 11,
- 24, 50, 51, 52, 53, 109, 137, 138, 140, 145,
- 14, 161, 8, 10, 11, 21, 110, 111, 46, 47,
- 27, 56, 161, 161, 161, 6, 13, 17, 4, 4,
- 149, 161, 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, 98, 24, 155, 158, 8, 3, 7, 7,
- 117, 106, 106, 6, 110, 6, 13, 124, 105, 105,
- 112, 117, 111, 127, 128, 129, 129, 9, 20, 28,
- 29, 25, 26, 24, 48, 49, 135, 120, 121, 122,
- 144, 145, 161, 5, 148, 20, 23, 25, 158, 158,
- 24, 153, 154, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 161, 133, 7, 24, 22, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 7, 17,
- 146, 99, 161, 161, 161, 22, 161, 146, 3, 157,
- 157, 157, 100, 158, 160, 160, 146, 157, 157, 157,
- 157, 7, 130, 130, 130, 130, 131, 131, 132, 132,
- 132, 121, 27, 55, 56, 57, 58, 59, 60, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 161, 161, 161, 161, 161, 161, 161, 160, 160, 160,
- 160, 160, 160, 160, 161, 161, 161, 161, 161, 161,
- 161, 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 220 "parser.y"
- { answer((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node)); }
- break;
- case 6:
- #line 230 "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 231 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 10:
- #line 237 "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 242 "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 243 "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 244 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 15:
- #line 248 "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 249 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 31:
- #line 269 "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 270 "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 274 "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 279 "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 287 "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 291 "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 301 "parser.y"
- { ((*yyvalp).string) = ""; }
- break;
- case 43:
- #line 304 "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 309 "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 310 "parser.y"
- { ((*yyvalp).node) = LIT((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 50:
- #line 316 "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 320 "parser.y"
- { ((*yyvalp).node) = NULL; }
- break;
- case 53:
- #line 323 "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 327 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((2) - (3))].yystate.yysemantics.yysval.node); }
- break;
- case 57:
- #line 331 "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 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 61:
- #line 338 "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 343 "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 348 "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 353 "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 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 70:
- #line 359 "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 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 73:
- #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 74:
- #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 75:
- #line 367 "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 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 78:
- #line 373 "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 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 81:
- #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 82:
- #line 380 "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 385 "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 392 "parser.y"
- { ((*yyvalp).node) = LIT((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 87:
- #line 393 "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 394 "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 395 "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 403 "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 407 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 93:
- #line 408 "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 425 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 102:
- #line 429 "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 450 "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 451 "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 456 "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 460 "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 465 "parser.y"
- { ((*yyvalp).string) = "/following-sibling::*[1]/self::"; }
- break;
- case 115:
- #line 466 "parser.y"
- { ((*yyvalp).string) = "/"; }
- break;
- case 116:
- #line 467 "parser.y"
- { ((*yyvalp).string) = "/following-sibling::*/self::"; }
- break;
- case 117:
- #line 468 "parser.y"
- { ((*yyvalp).string) = "//"; }
- break;
- case 119:
- #line 473 "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 474 "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 475 "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 476 "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 477 "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 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 125:
- #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 126:
- #line 480 "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 481 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[contains(., ", (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (5))].yystate.yysemantics.yysval.node), ")]"); }
- break;
- case 128:
- #line 482 "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 483 "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 484 "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 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 132:
- #line 486 "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 487 "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 488 "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 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 136:
- #line 490 "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 491 "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 492 "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 493 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[1]"); }
- break;
- case 140:
- #line 494 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[last()]"); }
- break;
- case 141:
- #line 495 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[position() % 2 = 0]"); }
- break;
- case 142:
- #line 496 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[position() % 2 = 1]"); }
- break;
- case 143:
- #line 497 "parser.y"
- { ((*yyvalp).node) = P4E((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (5))].yystate.yysemantics.yysval.node), "[translate(normalize-space(.), $nbsp, ' ')=", (((yyGLRStackItem const *)yyvsp)[YYFILL ((4) - (5))].yystate.yysemantics.yysval.node), "]"); }
- break;
- case 144:
- #line 498 "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 145:
- #line 499 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[not(node())]"); }
- break;
- case 146:
- #line 500 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[node()]"); }
- break;
- case 147:
- #line 501 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[1]"); }
- break;
- case 148:
- #line 502 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[last()]"); }
- break;
- case 149:
- #line 503 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[count()=1]"); }
- break;
- case 150:
- #line 504 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input']"); }
- break;
- case 151:
- #line 505 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input' and not(@disabled)]"); }
- break;
- case 152:
- #line 506 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[lower-case(name())='input' and @disabled]"); }
- break;
- case 153:
- #line 507 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[@checked]"); }
- break;
- case 154:
- #line 508 "parser.y"
- { ((*yyvalp).node) = APPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "[@selected]"); }
- break;
- case 155:
- #line 509 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[1]/self::"); }
- break;
- case 156:
- #line 510 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[last()]/self::"); }
- break;
- case 157:
- #line 511 "parser.y"
- { ((*yyvalp).node) = PREPEND((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), "*[count()=1]/self::"); }
- break;
- case 158:
- #line 512 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), text); }
- break;
- case 159:
- #line 513 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), password); }
- break;
- case 160:
- #line 514 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), radio); }
- break;
- case 161:
- #line 515 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), checkbox); }
- break;
- case 162:
- #line 516 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), submit); }
- break;
- case 163:
- #line 517 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), image); }
- break;
- case 164:
- #line 518 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), reset); }
- break;
- case 165:
- #line 519 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), button); }
- break;
- case 166:
- #line 520 "parser.y"
- { ((*yyvalp).node) = INPUT_TYPE((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node), file); }
- break;
- case 168:
- #line 525 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 171:
- #line 534 "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 173:
- #line 539 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 174:
- #line 540 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (2))].yystate.yysemantics.yysval.node); }
- break;
- case 175:
- #line 541 "parser.y"
- { ((*yyvalp).node) = PXP("*"); }
- break;
- case 176:
- #line 545 "parser.y"
- { ((*yyvalp).node) = (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.node); }
- break;
- case 177:
- #line 549 "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 178:
- #line 550 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 179:
- #line 554 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 180:
- #line 558 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 181:
- #line 559 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string) + 1); }
- break;
- case 182:
- #line 560 "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 183:
- #line 561 "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 184:
- #line 562 "parser.y"
- { ((*yyvalp).node) = PXP((((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 207:
- #line 591 "parser.y"
- { ((*yyvalp).node) = pxpath_new_literal(1, (((yyGLRStackItem const *)yyvsp)[YYFILL ((1) - (1))].yystate.yysemantics.yysval.string)); }
- break;
- case 208:
- #line 595 "parser.y"
- { ((*yyvalp).empty) = 0; }
- break;
- case 209:
- #line 596 "parser.y"
- { ((*yyvalp).empty) = 0; }
- break;
- /* Line 930 of glr.c. */
- #line 2595 "parser.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 599 "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;
- }