Unreviewed, rolling out r219178.
[WebKit-https.git] / Source / WebCore / xml / XPathGrammar.cpp
1 /* This file is generated using the following command:
2    bison -d -p xpathyy XPathGrammar.y -o XPathGrammar.cpp 
3  */
4
5 /* A Bison parser, made by GNU Bison 2.3.  */
6
7 /* Skeleton implementation for Bison's Yacc-like parsers in C
8
9    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
10    Free Software Foundation, Inc.
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2, or (at your option)
15    any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 51 Franklin Street, Fifth Floor,
25    Boston, MA 02110-1301, USA.  */
26
27 /* As a special exception, you may create a larger work that contains
28    part or all of the Bison parser skeleton and distribute that work
29    under terms of your choice, so long as that work isn't itself a
30    parser generator using the skeleton or a modified version thereof
31    as a parser skeleton.  Alternatively, if you modify or redistribute
32    the parser skeleton itself, you may (at your option) remove this
33    special exception, which will cause the skeleton and the resulting
34    Bison output files to be licensed under the GNU General Public
35    License without this special exception.
36
37    This special exception was added by the Free Software Foundation in
38    version 2.2 of Bison.  */
39
40 /* C LALR(1) parser skeleton written by Richard Stallman, by
41    simplifying the original so-called "semantic" parser.  */
42
43 /* All symbols defined below should begin with yy or YY, to avoid
44    infringing on user name space.  This should be done even for local
45    variables, as they might otherwise be expanded by user macros.
46    There are some unavoidable exceptions within include files to
47    define necessary library symbols; they are noted "INFRINGES ON
48    USER NAME SPACE" below.  */
49
50 /* Identify Bison output.  */
51 #define YYBISON 1
52
53 /* Bison version.  */
54 #define YYBISON_VERSION "2.3"
55
56 /* Skeleton name.  */
57 #define YYSKELETON_NAME "yacc.c"
58
59 /* Pure parsers.  */
60 #define YYPURE 1
61
62 /* Using locations.  */
63 #define YYLSP_NEEDED 0
64
65 /* Substitute the variable and function names.  */
66 #define yyparse xpathyyparse
67 #define yylex   xpathyylex
68 #define yyerror xpathyyerror
69 #define yylval  xpathyylval
70 #define yychar  xpathyychar
71 #define yydebug xpathyydebug
72 #define yynerrs xpathyynerrs
73
74
75 /* Tokens.  */
76 #ifndef YYTOKENTYPE
77 # define YYTOKENTYPE
78    /* Put the tokens into the symbol table, so that GDB and other debuggers
79       know about them.  */
80    enum yytokentype {
81      MULOP = 258,
82      RELOP = 259,
83      EQOP = 260,
84      MINUS = 261,
85      PLUS = 262,
86      AND = 263,
87      OR = 264,
88      FUNCTIONNAME = 265,
89      LITERAL = 266,
90      NAMETEST = 267,
91      NUMBER = 268,
92      NODETYPE = 269,
93      VARIABLEREFERENCE = 270,
94      AXISNAME = 271,
95      COMMENT = 272,
96      DOTDOT = 273,
97      PI = 274,
98      NODE = 275,
99      SLASHSLASH = 276,
100      TEXT_ = 277,
101      XPATH_ERROR = 278
102    };
103 #endif
104 /* Tokens.  */
105 #define MULOP 258
106 #define RELOP 259
107 #define EQOP 260
108 #define MINUS 261
109 #define PLUS 262
110 #define AND 263
111 #define OR 264
112 #define FUNCTIONNAME 265
113 #define LITERAL 266
114 #define NAMETEST 267
115 #define NUMBER 268
116 #define NODETYPE 269
117 #define VARIABLEREFERENCE 270
118 #define AXISNAME 271
119 #define COMMENT 272
120 #define DOTDOT 273
121 #define PI 274
122 #define NODE 275
123 #define SLASHSLASH 276
124 #define TEXT_ 277
125 #define XPATH_ERROR 278
126
127
128
129 /* Copy the first part of user declarations.  */
130 #line 28 "WebCore/xml/XPathGrammar.y"
131
132
133 #include "config.h"
134
135 #include "XPathFunctions.h"
136 #include "XPathParser.h"
137 #include "XPathPath.h"
138 #include "XPathStep.h"
139 #include "XPathVariableReference.h"
140
141
142 #if COMPILER(MSVC)
143 // See https://msdn.microsoft.com/en-us/library/1wea5zwe.aspx
144 #pragma warning(disable: 4701)
145 #endif
146
147 #define YYMALLOC fastMalloc
148 #define YYFREE fastFree
149
150 #define YYENABLE_NLS 0
151 #define YYLTYPE_IS_TRIVIAL 1
152 #define YYDEBUG 0
153 #define YYMAXDEPTH 10000
154
155 using namespace WebCore;
156 using namespace XPath;
157
158
159
160 /* Enabling traces.  */
161 #ifndef YYDEBUG
162 # define YYDEBUG 0
163 #endif
164
165 /* Enabling verbose error messages.  */
166 #ifdef YYERROR_VERBOSE
167 # undef YYERROR_VERBOSE
168 # define YYERROR_VERBOSE 1
169 #else
170 # define YYERROR_VERBOSE 0
171 #endif
172
173 /* Enabling the token table.  */
174 #ifndef YYTOKEN_TABLE
175 # define YYTOKEN_TABLE 0
176 #endif
177
178 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
179 typedef union YYSTYPE
180 #line 60 "WebCore/xml/XPathGrammar.y"
181
182     NumericOp::Opcode numericOpcode; 
183     EqTestOp::Opcode equalityTestOpcode;
184     StringImpl* string;
185     Step::Axis axis;
186     LocationPath* locationPath;
187     Step::NodeTest* nodeTest;
188     Vector<std::unique_ptr<Expression>>* expressionVector;
189     Step* step;
190     Expression* expression; 
191 }
192 /* Line 193 of yacc.c.  */
193 #line 190 "./XPathGrammar.cpp"
194     YYSTYPE;
195 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
196 # define YYSTYPE_IS_DECLARED 1
197 # define YYSTYPE_IS_TRIVIAL 1
198 #endif
199
200
201
202 /* Copy the second part of user declarations.  */
203 #line 104 "WebCore/xml/XPathGrammar.y"
204
205
206 static int xpathyylex(YYSTYPE* yylval, Parser& parser) { return parser.lex(*yylval); }
207 static void xpathyyerror(Parser&, const char*) { }
208
209
210
211 /* Line 216 of yacc.c.  */
212 #line 209 "./XPathGrammar.cpp"
213
214 #ifdef short
215 # undef short
216 #endif
217
218 #ifdef YYTYPE_UINT8
219 typedef YYTYPE_UINT8 yytype_uint8;
220 #else
221 typedef unsigned char yytype_uint8;
222 #endif
223
224 #ifdef YYTYPE_INT8
225 typedef YYTYPE_INT8 yytype_int8;
226 #elif (defined __STDC__ || defined __C99__FUNC__ \
227      || defined __cplusplus || defined _MSC_VER)
228 typedef signed char yytype_int8;
229 #else
230 typedef short int yytype_int8;
231 #endif
232
233 #ifdef YYTYPE_UINT16
234 typedef YYTYPE_UINT16 yytype_uint16;
235 #else
236 typedef unsigned short int yytype_uint16;
237 #endif
238
239 #ifdef YYTYPE_INT16
240 typedef YYTYPE_INT16 yytype_int16;
241 #else
242 typedef short int yytype_int16;
243 #endif
244
245 #ifndef YYSIZE_T
246 # ifdef __SIZE_TYPE__
247 #  define YYSIZE_T __SIZE_TYPE__
248 # elif defined size_t
249 #  define YYSIZE_T size_t
250 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
251      || defined __cplusplus || defined _MSC_VER)
252 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
253 #  define YYSIZE_T size_t
254 # else
255 #  define YYSIZE_T unsigned int
256 # endif
257 #endif
258
259 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
260
261 #ifndef YY_
262 # if defined YYENABLE_NLS && YYENABLE_NLS
263 #  if ENABLE_NLS
264 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
265 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
266 #  endif
267 # endif
268 # ifndef YY_
269 #  define YY_(msgid) msgid
270 # endif
271 #endif
272
273 /* Suppress unused-variable warnings by "using" E.  */
274 #if ! defined lint || defined __GNUC__
275 # define YYUSE(e) ((void) (e))
276 #else
277 # define YYUSE(e) /* empty */
278 #endif
279
280 /* Identity function, used to suppress warnings about constant conditions.  */
281 #ifndef lint
282 # define YYID(n) (n)
283 #else
284 #if (defined __STDC__ || defined __C99__FUNC__ \
285      || defined __cplusplus || defined _MSC_VER)
286 static int
287 YYID (int i)
288 #else
289 static int
290 YYID (i)
291     int i;
292 #endif
293 {
294   return i;
295 }
296 #endif
297
298 #if ! defined yyoverflow || YYERROR_VERBOSE
299
300 /* The parser invokes alloca or malloc; define the necessary symbols.  */
301
302 # ifdef YYSTACK_USE_ALLOCA
303 #  if YYSTACK_USE_ALLOCA
304 #   ifdef __GNUC__
305 #    define YYSTACK_ALLOC __builtin_alloca
306 #   elif defined __BUILTIN_VA_ARG_INCR
307 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
308 #   elif defined _AIX
309 #    define YYSTACK_ALLOC __alloca
310 #   elif defined _MSC_VER
311 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
312 #    define alloca _alloca
313 #   else
314 #    define YYSTACK_ALLOC alloca
315 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
316      || defined __cplusplus || defined _MSC_VER)
317 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
318 #     ifndef _STDLIB_H
319 #      define _STDLIB_H 1
320 #     endif
321 #    endif
322 #   endif
323 #  endif
324 # endif
325
326 # ifdef YYSTACK_ALLOC
327    /* Pacify GCC's `empty if-body' warning.  */
328 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
329 #  ifndef YYSTACK_ALLOC_MAXIMUM
330     /* The OS might guarantee only one guard page at the bottom of the stack,
331        and a page size can be as small as 4096 bytes.  So we cannot safely
332        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
333        to allow for a few compiler-allocated temporary stack slots.  */
334 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
335 #  endif
336 # else
337 #  define YYSTACK_ALLOC YYMALLOC
338 #  define YYSTACK_FREE YYFREE
339 #  ifndef YYSTACK_ALLOC_MAXIMUM
340 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
341 #  endif
342 #  if (defined __cplusplus && ! defined _STDLIB_H \
343        && ! ((defined YYMALLOC || defined malloc) \
344          && (defined YYFREE || defined free)))
345 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
346 #   ifndef _STDLIB_H
347 #    define _STDLIB_H 1
348 #   endif
349 #  endif
350 #  ifndef YYMALLOC
351 #   define YYMALLOC malloc
352 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
353      || defined __cplusplus || defined _MSC_VER)
354 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
355 #   endif
356 #  endif
357 #  ifndef YYFREE
358 #   define YYFREE free
359 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
360      || defined __cplusplus || defined _MSC_VER)
361 void free (void *); /* INFRINGES ON USER NAME SPACE */
362 #   endif
363 #  endif
364 # endif
365 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
366
367
368 #if (! defined yyoverflow \
369      && (! defined __cplusplus \
370      || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
371
372 /* A type that is properly aligned for any stack member.  */
373 union yyalloc
374 {
375   yytype_int16 yyss;
376   YYSTYPE yyvs;
377   };
378
379 /* The size of the maximum gap between one aligned stack and the next.  */
380 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
381
382 /* The size of an array large to enough to hold all stacks, each with
383    N elements.  */
384 # define YYSTACK_BYTES(N) \
385      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
386       + YYSTACK_GAP_MAXIMUM)
387
388 /* Copy COUNT objects from FROM to TO.  The source and destination do
389    not overlap.  */
390 # ifndef YYCOPY
391 #  if defined __GNUC__ && 1 < __GNUC__
392 #   define YYCOPY(To, From, Count) \
393       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
394 #  else
395 #   define YYCOPY(To, From, Count)        \
396       do                    \
397     {                    \
398       YYSIZE_T yyi;                \
399       for (yyi = 0; yyi < (Count); yyi++)    \
400         (To)[yyi] = (From)[yyi];        \
401     }                    \
402       while (YYID (0))
403 #  endif
404 # endif
405
406 /* Relocate STACK from its old location to the new one.  The
407    local variables YYSIZE and YYSTACKSIZE give the old and new number of
408    elements in the stack, and YYPTR gives the new location of the
409    stack.  Advance YYPTR to a properly aligned location for the next
410    stack.  */
411 # define YYSTACK_RELOCATE(Stack)                    \
412     do                                    \
413       {                                    \
414     YYSIZE_T yynewbytes;                        \
415     YYCOPY (&yyptr->Stack, Stack, yysize);                \
416     Stack = &yyptr->Stack;                        \
417     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
418     yyptr += yynewbytes / sizeof (*yyptr);                \
419       }                                    \
420     while (YYID (0))
421
422 #endif
423
424 /* YYFINAL -- State number of the termination state.  */
425 #define YYFINAL  52
426 /* YYLAST -- Last index in YYTABLE.  */
427 #define YYLAST   132
428
429 /* YYNTOKENS -- Number of terminals.  */
430 #define YYNTOKENS  33
431 /* YYNNTS -- Number of nonterminals.  */
432 #define YYNNTS  28
433 /* YYNRULES -- Number of rules.  */
434 #define YYNRULES  64
435 /* YYNRULES -- Number of states.  */
436 #define YYNSTATES  101
437
438 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
439 #define YYUNDEFTOK  2
440 #define YYMAXUTOK   278
441
442 #define YYTRANSLATE(YYX)                        \
443   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
444
445 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
446 static const yytype_uint8 yytranslate[] =
447 {
448        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
452       26,    27,     2,     2,    31,     2,    30,    24,     2,     2,
453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
454        2,     2,     2,     2,    25,     2,     2,     2,     2,     2,
455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
457        2,    28,     2,    29,     2,     2,     2,     2,     2,     2,
458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
459        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
460        2,     2,     2,     2,    32,     2,     2,     2,     2,     2,
461        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
462        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
463        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
464        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
465        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
466        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
467        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
468        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
469        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
470        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
471        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
472        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
473        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
474        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
475       15,    16,    17,    18,    19,    20,    21,    22,    23
476 };
477
478 #if YYDEBUG
479 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
480    YYRHS.  */
481 static const yytype_uint8 yyprhs[] =
482 {
483        0,     0,     3,     5,     7,     9,    11,    13,    16,    19,
484       21,    25,    29,    32,    35,    39,    43,    45,    47,    49,
485       53,    57,    61,    65,    70,    71,    73,    75,    78,    82,
486       84,    86,    88,    90,    94,    96,    98,   100,   104,   109,
487      111,   115,   117,   119,   123,   125,   127,   131,   135,   137,
488      140,   142,   146,   148,   152,   154,   158,   160,   164,   166,
489      170,   174,   176,   180,   182
490 };
491
492 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
493 static const yytype_int8 yyrhs[] =
494 {
495       34,     0,    -1,    35,    -1,    54,    -1,    37,    -1,    38,
496       -1,    24,    -1,    24,    38,    -1,    45,    38,    -1,    39,
497       -1,    38,    24,    39,    -1,    38,    45,    39,    -1,    41,
498       42,    -1,    12,    42,    -1,    40,    41,    42,    -1,    40,
499       12,    42,    -1,    46,    -1,    16,    -1,    25,    -1,    20,
500       26,    27,    -1,    22,    26,    27,    -1,    17,    26,    27,
501       -1,    19,    26,    27,    -1,    19,    26,    11,    27,    -1,
502       -1,    43,    -1,    44,    -1,    43,    44,    -1,    28,    35,
503       29,    -1,    21,    -1,    30,    -1,    18,    -1,    15,    -1,
504       26,    35,    27,    -1,    11,    -1,    13,    -1,    48,    -1,
505       10,    26,    27,    -1,    10,    26,    49,    27,    -1,    50,
506       -1,    49,    31,    50,    -1,    35,    -1,    52,    -1,    51,
507       32,    52,    -1,    36,    -1,    53,    -1,    53,    24,    38,
508       -1,    53,    45,    38,    -1,    47,    -1,    47,    43,    -1,
509       55,    -1,    54,     9,    55,    -1,    56,    -1,    55,     8,
510       56,    -1,    57,    -1,    56,     5,    57,    -1,    58,    -1,
511       57,     4,    58,    -1,    59,    -1,    58,     7,    59,    -1,
512       58,     6,    59,    -1,    60,    -1,    59,     3,    60,    -1,
513       51,    -1,     6,    60,    -1
514 };
515
516 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
517 static const yytype_uint16 yyrline[] =
518 {
519        0,   114,   114,   121,   125,   131,   135,   140,   145,   153,
520      159,   165,   174,   184,   202,   213,   231,   235,   237,   244,
521      249,   254,   259,   264,   273,   277,   281,   287,   295,   302,
522      309,   314,   321,   327,   332,   338,   344,   348,   356,   367,
523      373,   381,   385,   387,   394,   399,   401,   407,   416,   418,
524      426,   428,   435,   437,   444,   446,   453,   455,   462,   464,
525      469,   476,   478,   485,   487
526 };
527 #endif
528
529 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
530 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
531    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
532 static const char *const yytname[] =
533 {
534   "$end", "error", "$undefined", "MULOP", "RELOP", "EQOP", "MINUS",
535   "PLUS", "AND", "OR", "FUNCTIONNAME", "LITERAL", "NAMETEST", "NUMBER",
536   "NODETYPE", "VARIABLEREFERENCE", "AXISNAME", "COMMENT", "DOTDOT", "PI",
537   "NODE", "SLASHSLASH", "TEXT", "XPATH_ERROR", "'/'", "'@'", "'('", "')'",
538   "'['", "']'", "'.'", "','", "'|'", "$accept", "Top", "Expr",
539   "LocationPath", "AbsoluteLocationPath", "RelativeLocationPath", "Step",
540   "AxisSpecifier", "NodeTest", "OptionalPredicateList", "PredicateList",
541   "Predicate", "DescendantOrSelf", "AbbreviatedStep", "PrimaryExpr",
542   "FunctionCall", "ArgumentList", "Argument", "UnionExpr", "PathExpr",
543   "FilterExpr", "OrExpr", "AndExpr", "EqualityExpr", "RelationalExpr",
544   "AdditiveExpr", "MultiplicativeExpr", "UnaryExpr", 0
545 };
546 #endif
547
548 # ifdef YYPRINT
549 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
550    token YYLEX-NUM.  */
551 static const yytype_uint16 yytoknum[] =
552 {
553        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
554      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
555      275,   276,   277,   278,    47,    64,    40,    41,    91,    93,
556       46,    44,   124
557 };
558 # endif
559
560 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
561 static const yytype_uint8 yyr1[] =
562 {
563        0,    33,    34,    35,    36,    36,    37,    37,    37,    38,
564       38,    38,    39,    39,    39,    39,    39,    40,    40,    41,
565       41,    41,    41,    41,    42,    42,    43,    43,    44,    45,
566       46,    46,    47,    47,    47,    47,    47,    48,    48,    49,
567       49,    50,    51,    51,    52,    52,    52,    52,    53,    53,
568       54,    54,    55,    55,    56,    56,    57,    57,    58,    58,
569       58,    59,    59,    60,    60
570 };
571
572 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
573 static const yytype_uint8 yyr2[] =
574 {
575        0,     2,     1,     1,     1,     1,     1,     2,     2,     1,
576        3,     3,     2,     2,     3,     3,     1,     1,     1,     3,
577        3,     3,     3,     4,     0,     1,     1,     2,     3,     1,
578        1,     1,     1,     3,     1,     1,     1,     3,     4,     1,
579        3,     1,     1,     3,     1,     1,     3,     3,     1,     2,
580        1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
581        3,     1,     3,     1,     2
582 };
583
584 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
585    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
586    means the default is an error.  */
587 static const yytype_uint8 yydefact[] =
588 {
589        0,     0,     0,    34,    24,    35,    32,    17,     0,    31,
590        0,     0,    29,     0,     6,    18,     0,    30,     0,     2,
591       44,     4,     5,     9,     0,    24,     0,    16,    48,    36,
592       63,    42,    45,     3,    50,    52,    54,    56,    58,    61,
593       64,     0,     0,    13,    25,    26,     0,     0,     0,     0,
594        7,     0,     1,     0,     0,    24,    24,    12,     8,    49,
595        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
596       37,    41,     0,    39,     0,    27,    21,     0,    22,    19,
597       20,    33,    10,    11,    15,    14,    43,    46,    47,    51,
598       53,    55,    57,    60,    59,    62,    38,     0,    28,    23,
599       40
600 };
601
602 /* YYDEFGOTO[NTERM-NUM].  */
603 static const yytype_int8 yydefgoto[] =
604 {
605       -1,    18,    71,    20,    21,    22,    23,    24,    25,    43,
606       44,    45,    26,    27,    28,    29,    72,    73,    30,    31,
607       32,    33,    34,    35,    36,    37,    38,    39
608 };
609
610 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
611    STATE-NUM.  */
612 #define YYPACT_NINF -37
613 static const yytype_int8 yypact[] =
614 {
615       81,    81,    -8,   -37,    -7,   -37,   -37,   -37,    14,   -37,
616       17,    20,   -37,    21,     8,   -37,    81,   -37,    48,   -37,
617      -37,   -37,   -17,   -37,    22,    -7,     8,   -37,    -7,   -37,
618       23,   -37,    -9,     1,    45,    49,    52,    10,    54,   -37,
619      -37,    59,    81,   -37,    -7,   -37,    31,    -5,    32,    33,
620      -17,    34,   -37,     8,     8,    -7,    -7,   -37,   -17,    -7,
621      102,     8,     8,    81,    81,    81,    81,    81,    81,    81,
622      -37,   -37,   -18,   -37,    35,   -37,   -37,    36,   -37,   -37,
623      -37,   -37,   -37,   -37,   -37,   -37,   -37,   -17,   -17,    45,
624       49,    52,    10,    54,    54,   -37,   -37,    81,   -37,   -37,
625      -37
626 };
627
628 /* YYPGOTO[NTERM-NUM].  */
629 static const yytype_int8 yypgoto[] =
630 {
631      -37,   -37,     3,   -37,   -37,   -12,   -22,   -37,    38,   -20,
632       60,   -36,   -21,   -37,   -37,   -37,   -37,   -24,   -37,    30,
633      -37,   -37,    19,    40,    43,    29,   -16,    -1
634 };
635
636 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
637    positive, shift that token.  If negative, reduce the rule which
638    number is the opposite.  If zero, do what YYDEFACT says.
639    If YYTABLE_NINF, syntax error.  */
640 #define YYTABLE_NINF -1
641 static const yytype_uint8 yytable[] =
642 {
643       40,    54,    50,    19,    12,    57,    77,    53,    75,    96,
644       63,    62,    12,    97,    58,    61,    67,    68,    41,    51,
645        4,    42,    78,    75,     7,     8,     9,    10,    11,    54,
646       13,    82,    83,    15,    55,    84,    85,    54,    17,     8,
647       46,    10,    11,    47,    13,    74,    48,    49,    52,    87,
648       88,    93,    94,    64,    65,    60,    66,    69,    76,    79,
649       80,    81,    56,    99,    98,     1,    54,    54,    95,     2,
650        3,     4,     5,   100,     6,     7,     8,     9,    10,    11,
651       12,    13,    89,    14,    15,    16,    70,     1,    59,    17,
652       86,     2,     3,     4,     5,    92,     6,     7,     8,     9,
653       10,    11,    12,    13,    90,    14,    15,    16,    91,     0,
654        0,    17,     2,     3,     4,     5,     0,     6,     7,     8,
655        9,    10,    11,    12,    13,     0,    14,    15,    16,     0,
656        0,     0,    17
657 };
658
659 static const yytype_int8 yycheck[] =
660 {
661        1,    22,    14,     0,    21,    25,    11,    24,    44,    27,
662        9,    32,    21,    31,    26,    24,     6,     7,    26,    16,
663       12,    28,    27,    59,    16,    17,    18,    19,    20,    50,
664       22,    53,    54,    25,    12,    55,    56,    58,    30,    17,
665       26,    19,    20,    26,    22,    42,    26,    26,     0,    61,
666       62,    67,    68,     8,     5,    32,     4,     3,    27,    27,
667       27,    27,    24,    27,    29,     6,    87,    88,    69,    10,
668       11,    12,    13,    97,    15,    16,    17,    18,    19,    20,
669       21,    22,    63,    24,    25,    26,    27,     6,    28,    30,
670       60,    10,    11,    12,    13,    66,    15,    16,    17,    18,
671       19,    20,    21,    22,    64,    24,    25,    26,    65,    -1,
672       -1,    30,    10,    11,    12,    13,    -1,    15,    16,    17,
673       18,    19,    20,    21,    22,    -1,    24,    25,    26,    -1,
674       -1,    -1,    30
675 };
676
677 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
678    symbol of state STATE-NUM.  */
679 static const yytype_uint8 yystos[] =
680 {
681        0,     6,    10,    11,    12,    13,    15,    16,    17,    18,
682       19,    20,    21,    22,    24,    25,    26,    30,    34,    35,
683       36,    37,    38,    39,    40,    41,    45,    46,    47,    48,
684       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
685       60,    26,    28,    42,    43,    44,    26,    26,    26,    26,
686       38,    35,     0,    24,    45,    12,    41,    42,    38,    43,
687       32,    24,    45,     9,     8,     5,     4,     6,     7,     3,
688       27,    35,    49,    50,    35,    44,    27,    11,    27,    27,
689       27,    27,    39,    39,    42,    42,    52,    38,    38,    55,
690       56,    57,    58,    59,    59,    60,    27,    31,    29,    27,
691       50
692 };
693
694 #define yyerrok        (yyerrstatus = 0)
695 #define yyclearin    (yychar = YYEMPTY)
696 #define YYEMPTY        (-2)
697 #define YYEOF        0
698
699 #define YYACCEPT    goto yyacceptlab
700 #define YYABORT        goto yyabortlab
701 #define YYERROR        goto yyerrorlab
702
703
704 /* Like YYERROR except do call yyerror.  This remains here temporarily
705    to ease the transition to the new meaning of YYERROR, for GCC.
706    Once GCC version 2 has supplanted version 1, this can go.  */
707
708 #define YYFAIL        goto yyerrlab
709
710 #define YYRECOVERING()  (!!yyerrstatus)
711
712 #define YYBACKUP(Token, Value)                    \
713 do                                \
714   if (yychar == YYEMPTY && yylen == 1)                \
715     {                                \
716       yychar = (Token);                        \
717       yylval = (Value);                        \
718       yytoken = YYTRANSLATE (yychar);                \
719       YYPOPSTACK (1);                        \
720       goto yybackup;                        \
721     }                                \
722   else                                \
723     {                                \
724       yyerror (parser, YY_("syntax error: cannot back up")); \
725       YYERROR;                            \
726     }                                \
727 while (YYID (0))
728
729
730 #define YYTERROR    1
731 #define YYERRCODE    256
732
733
734 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
735    If N is 0, then set CURRENT to the empty location which ends
736    the previous symbol: RHS[0] (always defined).  */
737
738 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
739 #ifndef YYLLOC_DEFAULT
740 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
741     do                                    \
742       if (YYID (N))                                                    \
743     {                                \
744       (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
745       (Current).first_column = YYRHSLOC (Rhs, 1).first_column;    \
746       (Current).last_line    = YYRHSLOC (Rhs, N).last_line;        \
747       (Current).last_column  = YYRHSLOC (Rhs, N).last_column;    \
748     }                                \
749       else                                \
750     {                                \
751       (Current).first_line   = (Current).last_line   =        \
752         YYRHSLOC (Rhs, 0).last_line;                \
753       (Current).first_column = (Current).last_column =        \
754         YYRHSLOC (Rhs, 0).last_column;                \
755     }                                \
756     while (YYID (0))
757 #endif
758
759
760 /* YY_LOCATION_PRINT -- Print the location on the stream.
761    This macro was not mandated originally: define only if we know
762    we won't break user code: when these are the locations we know.  */
763
764 #ifndef YY_LOCATION_PRINT
765 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
766 #  define YY_LOCATION_PRINT(File, Loc)            \
767      fprintf (File, "%d.%d-%d.%d",            \
768           (Loc).first_line, (Loc).first_column,    \
769           (Loc).last_line,  (Loc).last_column)
770 # else
771 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
772 # endif
773 #endif
774
775
776 /* YYLEX -- calling `yylex' with the right arguments.  */
777
778 #ifdef YYLEX_PARAM
779 # define YYLEX yylex (&yylval, YYLEX_PARAM)
780 #else
781 # define YYLEX yylex (&yylval, parser)
782 #endif
783
784 /* Enable debugging if requested.  */
785 #if YYDEBUG
786
787 # ifndef YYFPRINTF
788 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
789 #  define YYFPRINTF fprintf
790 # endif
791
792 # define YYDPRINTF(Args)            \
793 do {                        \
794   if (yydebug)                    \
795     YYFPRINTF Args;                \
796 } while (YYID (0))
797
798 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)              \
799 do {                                      \
800   if (yydebug)                                  \
801     {                                      \
802       YYFPRINTF (stderr, "%s ", Title);                      \
803       yy_symbol_print (stderr,                          \
804           Type, Value, parser); \
805       YYFPRINTF (stderr, "\n");                          \
806     }                                      \
807 } while (YYID (0))
808
809
810 /*--------------------------------.
811 | Print this symbol on YYOUTPUT.  |
812 `--------------------------------*/
813
814 /*ARGSUSED*/
815 #if (defined __STDC__ || defined __C99__FUNC__ \
816      || defined __cplusplus || defined _MSC_VER)
817 static void
818 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, Parser& parser)
819 #else
820 static void
821 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
822     FILE *yyoutput;
823     int yytype;
824     YYSTYPE const * const yyvaluep;
825     Parser& parser;
826 #endif
827 {
828   if (!yyvaluep)
829     return;
830   YYUSE (parser);
831 # ifdef YYPRINT
832   if (yytype < YYNTOKENS)
833     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
834 # else
835   YYUSE (yyoutput);
836 # endif
837   switch (yytype)
838     {
839       default:
840     break;
841     }
842 }
843
844
845 /*--------------------------------.
846 | Print this symbol on YYOUTPUT.  |
847 `--------------------------------*/
848
849 #if (defined __STDC__ || defined __C99__FUNC__ \
850      || defined __cplusplus || defined _MSC_VER)
851 static void
852 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, Parser& parser)
853 #else
854 static void
855 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
856     FILE *yyoutput;
857     int yytype;
858     YYSTYPE const * const yyvaluep;
859     Parser& parser;
860 #endif
861 {
862   if (yytype < YYNTOKENS)
863     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
864   else
865     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
866
867   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
868   YYFPRINTF (yyoutput, ")");
869 }
870
871 /*------------------------------------------------------------------.
872 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
873 | TOP (included).                                                   |
874 `------------------------------------------------------------------*/
875
876 #if (defined __STDC__ || defined __C99__FUNC__ \
877      || defined __cplusplus || defined _MSC_VER)
878 static void
879 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
880 #else
881 static void
882 yy_stack_print (bottom, top)
883     yytype_int16 *bottom;
884     yytype_int16 *top;
885 #endif
886 {
887   YYFPRINTF (stderr, "Stack now");
888   for (; bottom <= top; ++bottom)
889     YYFPRINTF (stderr, " %d", *bottom);
890   YYFPRINTF (stderr, "\n");
891 }
892
893 # define YY_STACK_PRINT(Bottom, Top)                \
894 do {                                \
895   if (yydebug)                            \
896     yy_stack_print ((Bottom), (Top));                \
897 } while (YYID (0))
898
899
900 /*------------------------------------------------.
901 | Report that the YYRULE is going to be reduced.  |
902 `------------------------------------------------*/
903
904 #if (defined __STDC__ || defined __C99__FUNC__ \
905      || defined __cplusplus || defined _MSC_VER)
906 static void
907 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, Parser& parser)
908 #else
909 static void
910 yy_reduce_print (yyvsp, yyrule, parser)
911     YYSTYPE *yyvsp;
912     int yyrule;
913     Parser& parser;
914 #endif
915 {
916   int yynrhs = yyr2[yyrule];
917   int yyi;
918   unsigned long int yylno = yyrline[yyrule];
919   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
920          yyrule - 1, yylno);
921   /* The symbols being reduced.  */
922   for (yyi = 0; yyi < yynrhs; yyi++)
923     {
924       fprintf (stderr, "   $%d = ", yyi + 1);
925       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
926                &(yyvsp[(yyi + 1) - (yynrhs)])
927                               , parser);
928       fprintf (stderr, "\n");
929     }
930 }
931
932 # define YY_REDUCE_PRINT(Rule)        \
933 do {                    \
934   if (yydebug)                \
935     yy_reduce_print (yyvsp, Rule, parser); \
936 } while (YYID (0))
937
938 /* Nonzero means print parse trace.  It is left uninitialized so that
939    multiple parsers can coexist.  */
940 int yydebug;
941 #else /* !YYDEBUG */
942 # define YYDPRINTF(Args)
943 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
944 # define YY_STACK_PRINT(Bottom, Top)
945 # define YY_REDUCE_PRINT(Rule)
946 #endif /* !YYDEBUG */
947
948
949 /* YYINITDEPTH -- initial size of the parser's stacks.  */
950 #ifndef    YYINITDEPTH
951 # define YYINITDEPTH 200
952 #endif
953
954 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
955    if the built-in stack extension method is used).
956
957    Do not make this value too large; the results are undefined if
958    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
959    evaluated with infinite-precision integer arithmetic.  */
960
961 #ifndef YYMAXDEPTH
962 # define YYMAXDEPTH 10000
963 #endif
964
965 \f
966
967 #if YYERROR_VERBOSE
968
969 # ifndef yystrlen
970 #  if defined __GLIBC__ && defined _STRING_H
971 #   define yystrlen strlen
972 #  else
973 /* Return the length of YYSTR.  */
974 #if (defined __STDC__ || defined __C99__FUNC__ \
975      || defined __cplusplus || defined _MSC_VER)
976 static YYSIZE_T
977 yystrlen (const char *yystr)
978 #else
979 static YYSIZE_T
980 yystrlen (yystr)
981     const char *yystr;
982 #endif
983 {
984   YYSIZE_T yylen;
985   for (yylen = 0; yystr[yylen]; yylen++)
986     continue;
987   return yylen;
988 }
989 #  endif
990 # endif
991
992 # ifndef yystpcpy
993 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
994 #   define yystpcpy stpcpy
995 #  else
996 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
997    YYDEST.  */
998 #if (defined __STDC__ || defined __C99__FUNC__ \
999      || defined __cplusplus || defined _MSC_VER)
1000 static char *
1001 yystpcpy (char *yydest, const char *yysrc)
1002 #else
1003 static char *
1004 yystpcpy (yydest, yysrc)
1005     char *yydest;
1006     const char *yysrc;
1007 #endif
1008 {
1009   char *yyd = yydest;
1010   const char *yys = yysrc;
1011
1012   while ((*yyd++ = *yys++) != '\0')
1013     continue;
1014
1015   return yyd - 1;
1016 }
1017 #  endif
1018 # endif
1019
1020 # ifndef yytnamerr
1021 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1022    quotes and backslashes, so that it's suitable for yyerror.  The
1023    heuristic is that double-quoting is unnecessary unless the string
1024    contains an apostrophe, a comma, or backslash (other than
1025    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1026    null, do not copy; instead, return the length of what the result
1027    would have been.  */
1028 static YYSIZE_T
1029 yytnamerr (char *yyres, const char *yystr)
1030 {
1031   if (*yystr == '"')
1032     {
1033       YYSIZE_T yyn = 0;
1034       char const *yyp = yystr;
1035
1036       for (;;)
1037     switch (*++yyp)
1038       {
1039       case '\'':
1040       case ',':
1041         goto do_not_strip_quotes;
1042
1043       case '\\':
1044         if (*++yyp != '\\')
1045           goto do_not_strip_quotes;
1046         /* Fall through.  */
1047       default:
1048         if (yyres)
1049           yyres[yyn] = *yyp;
1050         yyn++;
1051         break;
1052
1053       case '"':
1054         if (yyres)
1055           yyres[yyn] = '\0';
1056         return yyn;
1057       }
1058     do_not_strip_quotes: ;
1059     }
1060
1061   if (! yyres)
1062     return yystrlen (yystr);
1063
1064   return yystpcpy (yyres, yystr) - yyres;
1065 }
1066 # endif
1067
1068 /* Copy into YYRESULT an error message about the unexpected token
1069    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1070    including the terminating null byte.  If YYRESULT is null, do not
1071    copy anything; just return the number of bytes that would be
1072    copied.  As a special case, return 0 if an ordinary "syntax error"
1073    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1074    size calculation.  */
1075 static YYSIZE_T
1076 yysyntax_error (char *yyresult, int yystate, int yychar)
1077 {
1078   int yyn = yypact[yystate];
1079
1080   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1081     return 0;
1082   else
1083     {
1084       int yytype = YYTRANSLATE (yychar);
1085       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1086       YYSIZE_T yysize = yysize0;
1087       YYSIZE_T yysize1;
1088       int yysize_overflow = 0;
1089       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1090       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1091       int yyx;
1092
1093 # if 0
1094       /* This is so xgettext sees the translatable formats that are
1095      constructed on the fly.  */
1096       YY_("syntax error, unexpected %s");
1097       YY_("syntax error, unexpected %s, expecting %s");
1098       YY_("syntax error, unexpected %s, expecting %s or %s");
1099       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1100       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1101 # endif
1102       char *yyfmt;
1103       char const *yyf;
1104       static char const yyunexpected[] = "syntax error, unexpected %s";
1105       static char const yyexpecting[] = ", expecting %s";
1106       static char const yyor[] = " or %s";
1107       char yyformat[sizeof yyunexpected
1108             + sizeof yyexpecting - 1
1109             + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1110                * (sizeof yyor - 1))];
1111       char const *yyprefix = yyexpecting;
1112
1113       /* Start YYX at -YYN if negative to avoid negative indexes in
1114      YYCHECK.  */
1115       int yyxbegin = yyn < 0 ? -yyn : 0;
1116
1117       /* Stay within bounds of both yycheck and yytname.  */
1118       int yychecklim = YYLAST - yyn + 1;
1119       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1120       int yycount = 1;
1121
1122       yyarg[0] = yytname[yytype];
1123       yyfmt = yystpcpy (yyformat, yyunexpected);
1124
1125       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1126     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1127       {
1128         if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1129           {
1130         yycount = 1;
1131         yysize = yysize0;
1132         yyformat[sizeof yyunexpected - 1] = '\0';
1133         break;
1134           }
1135         yyarg[yycount++] = yytname[yyx];
1136         yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1137         yysize_overflow |= (yysize1 < yysize);
1138         yysize = yysize1;
1139         yyfmt = yystpcpy (yyfmt, yyprefix);
1140         yyprefix = yyor;
1141       }
1142
1143       yyf = YY_(yyformat);
1144       yysize1 = yysize + yystrlen (yyf);
1145       yysize_overflow |= (yysize1 < yysize);
1146       yysize = yysize1;
1147
1148       if (yysize_overflow)
1149     return YYSIZE_MAXIMUM;
1150
1151       if (yyresult)
1152     {
1153       /* Avoid sprintf, as that infringes on the user's name space.
1154          Don't have undefined behavior even if the translation
1155          produced a string with the wrong number of "%s"s.  */
1156       char *yyp = yyresult;
1157       int yyi = 0;
1158       while ((*yyp = *yyf) != '\0')
1159         {
1160           if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1161         {
1162           yyp += yytnamerr (yyp, yyarg[yyi++]);
1163           yyf += 2;
1164         }
1165           else
1166         {
1167           yyp++;
1168           yyf++;
1169         }
1170         }
1171     }
1172       return yysize;
1173     }
1174 }
1175 #endif /* YYERROR_VERBOSE */
1176 \f
1177
1178 /*-----------------------------------------------.
1179 | Release the memory associated to this symbol.  |
1180 `-----------------------------------------------*/
1181
1182 /*ARGSUSED*/
1183 #if (defined __STDC__ || defined __C99__FUNC__ \
1184      || defined __cplusplus || defined _MSC_VER)
1185 static void
1186 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, Parser& parser)
1187 #else
1188 static void
1189 yydestruct (yymsg, yytype, yyvaluep, parser)
1190     const char *yymsg;
1191     int yytype;
1192     YYSTYPE *yyvaluep;
1193     Parser& parser;
1194 #endif
1195 {
1196   YYUSE (yyvaluep);
1197   YYUSE (parser);
1198
1199   if (!yymsg)
1200     yymsg = "Deleting";
1201   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1202
1203   switch (yytype)
1204     {
1205       case 10: /* "FUNCTIONNAME" */
1206 #line 80 "WebCore/xml/XPathGrammar.y"
1207     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1208 #line 1205 "./XPathGrammar.cpp"
1209     break;
1210       case 11: /* "LITERAL" */
1211 #line 80 "WebCore/xml/XPathGrammar.y"
1212     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1213 #line 1210 "./XPathGrammar.cpp"
1214     break;
1215       case 12: /* "NAMETEST" */
1216 #line 80 "WebCore/xml/XPathGrammar.y"
1217     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1218 #line 1215 "./XPathGrammar.cpp"
1219     break;
1220       case 13: /* "NUMBER" */
1221 #line 80 "WebCore/xml/XPathGrammar.y"
1222     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1223 #line 1220 "./XPathGrammar.cpp"
1224     break;
1225       case 14: /* "NODETYPE" */
1226 #line 80 "WebCore/xml/XPathGrammar.y"
1227     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1228 #line 1225 "./XPathGrammar.cpp"
1229     break;
1230       case 15: /* "VARIABLEREFERENCE" */
1231 #line 80 "WebCore/xml/XPathGrammar.y"
1232     { if ((yyvaluep->string)) (yyvaluep->string)->deref(); };
1233 #line 1230 "./XPathGrammar.cpp"
1234     break;
1235       case 35: /* "Expr" */
1236 #line 100 "WebCore/xml/XPathGrammar.y"
1237     { delete (yyvaluep->expression); };
1238 #line 1235 "./XPathGrammar.cpp"
1239     break;
1240       case 36: /* "LocationPath" */
1241 #line 88 "WebCore/xml/XPathGrammar.y"
1242     { delete (yyvaluep->locationPath); };
1243 #line 1240 "./XPathGrammar.cpp"
1244     break;
1245       case 37: /* "AbsoluteLocationPath" */
1246 #line 88 "WebCore/xml/XPathGrammar.y"
1247     { delete (yyvaluep->locationPath); };
1248 #line 1245 "./XPathGrammar.cpp"
1249     break;
1250       case 38: /* "RelativeLocationPath" */
1251 #line 88 "WebCore/xml/XPathGrammar.y"
1252     { delete (yyvaluep->locationPath); };
1253 #line 1250 "./XPathGrammar.cpp"
1254     break;
1255       case 39: /* "Step" */
1256 #line 97 "WebCore/xml/XPathGrammar.y"
1257     { delete (yyvaluep->step); };
1258 #line 1255 "./XPathGrammar.cpp"
1259     break;
1260       case 41: /* "NodeTest" */
1261 #line 91 "WebCore/xml/XPathGrammar.y"
1262     { delete (yyvaluep->nodeTest); };
1263 #line 1260 "./XPathGrammar.cpp"
1264     break;
1265       case 42: /* "OptionalPredicateList" */
1266 #line 94 "WebCore/xml/XPathGrammar.y"
1267     { delete (yyvaluep->expressionVector); };
1268 #line 1265 "./XPathGrammar.cpp"
1269     break;
1270       case 43: /* "PredicateList" */
1271 #line 94 "WebCore/xml/XPathGrammar.y"
1272     { delete (yyvaluep->expressionVector); };
1273 #line 1270 "./XPathGrammar.cpp"
1274     break;
1275       case 44: /* "Predicate" */
1276 #line 100 "WebCore/xml/XPathGrammar.y"
1277     { delete (yyvaluep->expression); };
1278 #line 1275 "./XPathGrammar.cpp"
1279     break;
1280       case 45: /* "DescendantOrSelf" */
1281 #line 97 "WebCore/xml/XPathGrammar.y"
1282     { delete (yyvaluep->step); };
1283 #line 1280 "./XPathGrammar.cpp"
1284     break;
1285       case 46: /* "AbbreviatedStep" */
1286 #line 97 "WebCore/xml/XPathGrammar.y"
1287     { delete (yyvaluep->step); };
1288 #line 1285 "./XPathGrammar.cpp"
1289     break;
1290       case 47: /* "PrimaryExpr" */
1291 #line 100 "WebCore/xml/XPathGrammar.y"
1292     { delete (yyvaluep->expression); };
1293 #line 1290 "./XPathGrammar.cpp"
1294     break;
1295       case 48: /* "FunctionCall" */
1296 #line 100 "WebCore/xml/XPathGrammar.y"
1297     { delete (yyvaluep->expression); };
1298 #line 1295 "./XPathGrammar.cpp"
1299     break;
1300       case 49: /* "ArgumentList" */
1301 #line 94 "WebCore/xml/XPathGrammar.y"
1302     { delete (yyvaluep->expressionVector); };
1303 #line 1300 "./XPathGrammar.cpp"
1304     break;
1305       case 50: /* "Argument" */
1306 #line 100 "WebCore/xml/XPathGrammar.y"
1307     { delete (yyvaluep->expression); };
1308 #line 1305 "./XPathGrammar.cpp"
1309     break;
1310       case 51: /* "UnionExpr" */
1311 #line 100 "WebCore/xml/XPathGrammar.y"
1312     { delete (yyvaluep->expression); };
1313 #line 1310 "./XPathGrammar.cpp"
1314     break;
1315       case 52: /* "PathExpr" */
1316 #line 100 "WebCore/xml/XPathGrammar.y"
1317     { delete (yyvaluep->expression); };
1318 #line 1315 "./XPathGrammar.cpp"
1319     break;
1320       case 53: /* "FilterExpr" */
1321 #line 100 "WebCore/xml/XPathGrammar.y"
1322     { delete (yyvaluep->expression); };
1323 #line 1320 "./XPathGrammar.cpp"
1324     break;
1325       case 54: /* "OrExpr" */
1326 #line 100 "WebCore/xml/XPathGrammar.y"
1327     { delete (yyvaluep->expression); };
1328 #line 1325 "./XPathGrammar.cpp"
1329     break;
1330       case 55: /* "AndExpr" */
1331 #line 100 "WebCore/xml/XPathGrammar.y"
1332     { delete (yyvaluep->expression); };
1333 #line 1330 "./XPathGrammar.cpp"
1334     break;
1335       case 56: /* "EqualityExpr" */
1336 #line 100 "WebCore/xml/XPathGrammar.y"
1337     { delete (yyvaluep->expression); };
1338 #line 1335 "./XPathGrammar.cpp"
1339     break;
1340       case 57: /* "RelationalExpr" */
1341 #line 100 "WebCore/xml/XPathGrammar.y"
1342     { delete (yyvaluep->expression); };
1343 #line 1340 "./XPathGrammar.cpp"
1344     break;
1345       case 58: /* "AdditiveExpr" */
1346 #line 100 "WebCore/xml/XPathGrammar.y"
1347     { delete (yyvaluep->expression); };
1348 #line 1345 "./XPathGrammar.cpp"
1349     break;
1350       case 59: /* "MultiplicativeExpr" */
1351 #line 100 "WebCore/xml/XPathGrammar.y"
1352     { delete (yyvaluep->expression); };
1353 #line 1350 "./XPathGrammar.cpp"
1354     break;
1355       case 60: /* "UnaryExpr" */
1356 #line 100 "WebCore/xml/XPathGrammar.y"
1357     { delete (yyvaluep->expression); };
1358 #line 1355 "./XPathGrammar.cpp"
1359     break;
1360
1361       default:
1362     break;
1363     }
1364 }
1365 \f
1366
1367 /* Prevent warnings from -Wmissing-prototypes.  */
1368
1369 #ifdef YYPARSE_PARAM
1370 #if defined __STDC__ || defined __cplusplus
1371 int yyparse (void *YYPARSE_PARAM);
1372 #else
1373 int yyparse ();
1374 #endif
1375 #else /* ! YYPARSE_PARAM */
1376 #if defined __STDC__ || defined __cplusplus
1377 int yyparse (Parser& parser);
1378 #else
1379 int yyparse ();
1380 #endif
1381 #endif /* ! YYPARSE_PARAM */
1382
1383
1384
1385
1386
1387
1388 /*----------.
1389 | yyparse.  |
1390 `----------*/
1391
1392 #ifdef YYPARSE_PARAM
1393 #if (defined __STDC__ || defined __C99__FUNC__ \
1394      || defined __cplusplus || defined _MSC_VER)
1395 int
1396 yyparse (void *YYPARSE_PARAM)
1397 #else
1398 int
1399 yyparse (YYPARSE_PARAM)
1400     void *YYPARSE_PARAM;
1401 #endif
1402 #else /* ! YYPARSE_PARAM */
1403 #if (defined __STDC__ || defined __C99__FUNC__ \
1404      || defined __cplusplus || defined _MSC_VER)
1405 int
1406 yyparse (Parser& parser)
1407 #else
1408 int
1409 yyparse (parser)
1410     Parser& parser;
1411 #endif
1412 #endif
1413 {
1414   /* The look-ahead symbol.  */
1415 int yychar;
1416
1417 /* The semantic value of the look-ahead symbol.  */
1418 YYSTYPE yylval;
1419
1420 /* Number of syntax errors so far.  */
1421 int yynerrs;
1422
1423   int yystate;
1424   int yyn;
1425   int yyresult;
1426   /* Number of tokens to shift before error messages enabled.  */
1427   int yyerrstatus;
1428   /* Look-ahead token as an internal (translated) token number.  */
1429   int yytoken = 0;
1430 #if YYERROR_VERBOSE
1431   /* Buffer for error messages, and its allocated size.  */
1432   char yymsgbuf[128];
1433   char *yymsg = yymsgbuf;
1434   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1435 #endif
1436
1437   /* Three stacks and their tools:
1438      `yyss': related to states,
1439      `yyvs': related to semantic values,
1440      `yyls': related to locations.
1441
1442      Refer to the stacks thru separate pointers, to allow yyoverflow
1443      to reallocate them elsewhere.  */
1444
1445   /* The state stack.  */
1446   yytype_int16 yyssa[YYINITDEPTH];
1447   yytype_int16 *yyss = yyssa;
1448   yytype_int16 *yyssp;
1449
1450   /* The semantic value stack.  */
1451   YYSTYPE yyvsa[YYINITDEPTH];
1452   YYSTYPE *yyvs = yyvsa;
1453   YYSTYPE *yyvsp;
1454
1455
1456
1457 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1458
1459   YYSIZE_T yystacksize = YYINITDEPTH;
1460
1461   /* The variables used to return semantic value and location from the
1462      action routines.  */
1463   YYSTYPE yyval;
1464
1465
1466   /* The number of symbols on the RHS of the reduced rule.
1467      Keep to zero when no symbol should be popped.  */
1468   int yylen = 0;
1469
1470   YYDPRINTF ((stderr, "Starting parse\n"));
1471
1472   yystate = 0;
1473   yyerrstatus = 0;
1474   yynerrs = 0;
1475   yychar = YYEMPTY;        /* Cause a token to be read.  */
1476
1477   /* Initialize stack pointers.
1478      Waste one element of value and location stack
1479      so that they stay on the same level as the state stack.
1480      The wasted elements are never initialized.  */
1481
1482   yyssp = yyss;
1483   yyvsp = yyvs;
1484
1485   goto yysetstate;
1486
1487 /*------------------------------------------------------------.
1488 | yynewstate -- Push a new state, which is found in yystate.  |
1489 `------------------------------------------------------------*/
1490  yynewstate:
1491   /* In all cases, when you get here, the value and location stacks
1492      have just been pushed.  So pushing a state here evens the stacks.  */
1493   yyssp++;
1494
1495  yysetstate:
1496   *yyssp = yystate;
1497
1498   if (yyss + yystacksize - 1 <= yyssp)
1499     {
1500       /* Get the current used size of the three stacks, in elements.  */
1501       YYSIZE_T yysize = yyssp - yyss + 1;
1502
1503 #ifdef yyoverflow
1504       {
1505     /* Give user a chance to reallocate the stack.  Use copies of
1506        these so that the &'s don't force the real ones into
1507        memory.  */
1508     YYSTYPE *yyvs1 = yyvs;
1509     yytype_int16 *yyss1 = yyss;
1510
1511
1512     /* Each stack pointer address is followed by the size of the
1513        data in use in that stack, in bytes.  This used to be a
1514        conditional around just the two extra args, but that might
1515        be undefined if yyoverflow is a macro.  */
1516     yyoverflow (YY_("memory exhausted"),
1517             &yyss1, yysize * sizeof (*yyssp),
1518             &yyvs1, yysize * sizeof (*yyvsp),
1519
1520             &yystacksize);
1521
1522     yyss = yyss1;
1523     yyvs = yyvs1;
1524       }
1525 #else /* no yyoverflow */
1526 # ifndef YYSTACK_RELOCATE
1527       goto yyexhaustedlab;
1528 # else
1529       /* Extend the stack our own way.  */
1530       if (YYMAXDEPTH <= yystacksize)
1531     goto yyexhaustedlab;
1532       yystacksize *= 2;
1533       if (YYMAXDEPTH < yystacksize)
1534     yystacksize = YYMAXDEPTH;
1535
1536       {
1537     yytype_int16 *yyss1 = yyss;
1538     union yyalloc *yyptr =
1539       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1540     if (! yyptr)
1541       goto yyexhaustedlab;
1542     YYSTACK_RELOCATE (yyss);
1543     YYSTACK_RELOCATE (yyvs);
1544
1545 #  undef YYSTACK_RELOCATE
1546     if (yyss1 != yyssa)
1547       YYSTACK_FREE (yyss1);
1548       }
1549 # endif
1550 #endif /* no yyoverflow */
1551
1552       yyssp = yyss + yysize - 1;
1553       yyvsp = yyvs + yysize - 1;
1554
1555
1556       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1557           (unsigned long int) yystacksize));
1558
1559       if (yyss + yystacksize - 1 <= yyssp)
1560     YYABORT;
1561     }
1562
1563   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1564
1565   goto yybackup;
1566
1567 /*-----------.
1568 | yybackup.  |
1569 `-----------*/
1570 yybackup:
1571
1572   /* Do appropriate processing given the current state.  Read a
1573      look-ahead token if we need one and don't already have one.  */
1574
1575   /* First try to decide what to do without reference to look-ahead token.  */
1576   yyn = yypact[yystate];
1577   if (yyn == YYPACT_NINF)
1578     goto yydefault;
1579
1580   /* Not known => get a look-ahead token if don't already have one.  */
1581
1582   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1583   if (yychar == YYEMPTY)
1584     {
1585       YYDPRINTF ((stderr, "Reading a token: "));
1586       yychar = YYLEX;
1587     }
1588
1589   if (yychar <= YYEOF)
1590     {
1591       yychar = yytoken = YYEOF;
1592       YYDPRINTF ((stderr, "Now at end of input.\n"));
1593     }
1594   else
1595     {
1596       yytoken = YYTRANSLATE (yychar);
1597       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1598     }
1599
1600   /* If the proper action on seeing token YYTOKEN is to reduce or to
1601      detect an error, take that action.  */
1602   yyn += yytoken;
1603   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1604     goto yydefault;
1605   yyn = yytable[yyn];
1606   if (yyn <= 0)
1607     {
1608       if (yyn == 0 || yyn == YYTABLE_NINF)
1609     goto yyerrlab;
1610       yyn = -yyn;
1611       goto yyreduce;
1612     }
1613
1614   if (yyn == YYFINAL)
1615     YYACCEPT;
1616
1617   /* Count tokens shifted since error; after three, turn off error
1618      status.  */
1619   if (yyerrstatus)
1620     yyerrstatus--;
1621
1622   /* Shift the look-ahead token.  */
1623   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1624
1625   /* Discard the shifted token unless it is eof.  */
1626   if (yychar != YYEOF)
1627     yychar = YYEMPTY;
1628
1629   yystate = yyn;
1630   *++yyvsp = yylval;
1631
1632   goto yynewstate;
1633
1634
1635 /*-----------------------------------------------------------.
1636 | yydefault -- do the default action for the current state.  |
1637 `-----------------------------------------------------------*/
1638 yydefault:
1639   yyn = yydefact[yystate];
1640   if (yyn == 0)
1641     goto yyerrlab;
1642   goto yyreduce;
1643
1644
1645 /*-----------------------------.
1646 | yyreduce -- Do a reduction.  |
1647 `-----------------------------*/
1648 yyreduce:
1649   /* yyn is the number of a rule to reduce with.  */
1650   yylen = yyr2[yyn];
1651
1652   /* If YYLEN is nonzero, implement the default value of the action:
1653      `$$ = $1'.
1654
1655      Otherwise, the following line sets YYVAL to garbage.
1656      This behavior is undocumented and Bison
1657      users should not rely upon it.  Assigning to YYVAL
1658      unconditionally makes the parser a bit smaller, and it avoids a
1659      GCC warning that YYVAL may be used uninitialized.  */
1660   yyval = yyvsp[1-yylen];
1661
1662
1663   YY_REDUCE_PRINT (yyn);
1664   switch (yyn)
1665     {
1666         case 2:
1667 #line 115 "WebCore/xml/XPathGrammar.y"
1668     {
1669         parser.setParseResult(std::unique_ptr<Expression>((yyvsp[(1) - (1)].expression)));
1670     ;}
1671     break;
1672
1673   case 4:
1674 #line 126 "WebCore/xml/XPathGrammar.y"
1675     {
1676         (yyval.locationPath) = (yyvsp[(1) - (1)].locationPath);
1677         (yyval.locationPath)->setAbsolute();
1678     ;}
1679     break;
1680
1681   case 6:
1682 #line 136 "WebCore/xml/XPathGrammar.y"
1683     {
1684         (yyval.locationPath) = new LocationPath;
1685     ;}
1686     break;
1687
1688   case 7:
1689 #line 141 "WebCore/xml/XPathGrammar.y"
1690     {
1691         (yyval.locationPath) = (yyvsp[(2) - (2)].locationPath);
1692     ;}
1693     break;
1694
1695   case 8:
1696 #line 146 "WebCore/xml/XPathGrammar.y"
1697     {
1698         (yyval.locationPath) = (yyvsp[(2) - (2)].locationPath);
1699         (yyval.locationPath)->prependStep(std::unique_ptr<Step>((yyvsp[(1) - (2)].step)));
1700     ;}
1701     break;
1702
1703   case 9:
1704 #line 154 "WebCore/xml/XPathGrammar.y"
1705     {
1706         (yyval.locationPath) = new LocationPath;
1707         (yyval.locationPath)->appendStep(std::unique_ptr<Step>((yyvsp[(1) - (1)].step)));
1708     ;}
1709     break;
1710
1711   case 10:
1712 #line 160 "WebCore/xml/XPathGrammar.y"
1713     {
1714         (yyval.locationPath) = (yyvsp[(1) - (3)].locationPath);
1715         (yyval.locationPath)->appendStep(std::unique_ptr<Step>((yyvsp[(3) - (3)].step)));
1716     ;}
1717     break;
1718
1719   case 11:
1720 #line 166 "WebCore/xml/XPathGrammar.y"
1721     {
1722         (yyval.locationPath) = (yyvsp[(1) - (3)].locationPath);
1723         (yyval.locationPath)->appendStep(std::unique_ptr<Step>((yyvsp[(2) - (3)].step)));
1724         (yyval.locationPath)->appendStep(std::unique_ptr<Step>((yyvsp[(3) - (3)].step)));
1725     ;}
1726     break;
1727
1728   case 12:
1729 #line 175 "WebCore/xml/XPathGrammar.y"
1730     {
1731         std::unique_ptr<Step::NodeTest> nodeTest((yyvsp[(1) - (2)].nodeTest));
1732         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList((yyvsp[(2) - (2)].expressionVector));
1733         if (predicateList)
1734             (yyval.step) = new Step(Step::ChildAxis, WTFMove(*nodeTest), WTFMove(*predicateList));
1735         else
1736             (yyval.step) = new Step(Step::ChildAxis, WTFMove(*nodeTest));
1737     ;}
1738     break;
1739
1740   case 13:
1741 #line 185 "WebCore/xml/XPathGrammar.y"
1742     {
1743         String nametest = adoptRef((yyvsp[(1) - (2)].string));
1744         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList((yyvsp[(2) - (2)].expressionVector));
1745
1746         String localName;
1747         String namespaceURI;
1748         if (!parser.expandQualifiedName(nametest, localName, namespaceURI)) {
1749             (yyval.step) = nullptr;
1750             YYABORT;
1751         }
1752
1753         if (predicateList)
1754             (yyval.step) = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), WTFMove(*predicateList));
1755         else
1756             (yyval.step) = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
1757     ;}
1758     break;
1759
1760   case 14:
1761 #line 203 "WebCore/xml/XPathGrammar.y"
1762     {
1763         std::unique_ptr<Step::NodeTest> nodeTest((yyvsp[(2) - (3)].nodeTest));
1764         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList((yyvsp[(3) - (3)].expressionVector));
1765
1766         if (predicateList)
1767             (yyval.step) = new Step((yyvsp[(1) - (3)].axis), WTFMove(*nodeTest), WTFMove(*predicateList));
1768         else
1769             (yyval.step) = new Step((yyvsp[(1) - (3)].axis), WTFMove(*nodeTest));
1770     ;}
1771     break;
1772
1773   case 15:
1774 #line 214 "WebCore/xml/XPathGrammar.y"
1775     {
1776         String nametest = adoptRef((yyvsp[(2) - (3)].string));
1777         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList((yyvsp[(3) - (3)].expressionVector));
1778
1779         String localName;
1780         String namespaceURI;
1781         if (!parser.expandQualifiedName(nametest, localName, namespaceURI)) {
1782             (yyval.step) = nullptr;
1783             YYABORT;
1784         }
1785
1786         if (predicateList)
1787             (yyval.step) = new Step((yyvsp[(1) - (3)].axis), Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), WTFMove(*predicateList));
1788         else
1789             (yyval.step) = new Step((yyvsp[(1) - (3)].axis), Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
1790     ;}
1791     break;
1792
1793   case 18:
1794 #line 238 "WebCore/xml/XPathGrammar.y"
1795     {
1796         (yyval.axis) = Step::AttributeAxis;
1797     ;}
1798     break;
1799
1800   case 19:
1801 #line 245 "WebCore/xml/XPathGrammar.y"
1802     {
1803         (yyval.nodeTest) = new Step::NodeTest(Step::NodeTest::AnyNodeTest);
1804     ;}
1805     break;
1806
1807   case 20:
1808 #line 250 "WebCore/xml/XPathGrammar.y"
1809     {
1810         (yyval.nodeTest) = new Step::NodeTest(Step::NodeTest::TextNodeTest);
1811     ;}
1812     break;
1813
1814   case 21:
1815 #line 255 "WebCore/xml/XPathGrammar.y"
1816     {
1817         (yyval.nodeTest) = new Step::NodeTest(Step::NodeTest::CommentNodeTest);
1818     ;}
1819     break;
1820
1821   case 22:
1822 #line 260 "WebCore/xml/XPathGrammar.y"
1823     {
1824         (yyval.nodeTest) = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest);
1825     ;}
1826     break;
1827
1828   case 23:
1829 #line 265 "WebCore/xml/XPathGrammar.y"
1830     {
1831         String literal = adoptRef((yyvsp[(3) - (4)].string));
1832         (yyval.nodeTest) = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest, literal.stripWhiteSpace());
1833     ;}
1834     break;
1835
1836   case 24:
1837 #line 273 "WebCore/xml/XPathGrammar.y"
1838     {
1839         (yyval.expressionVector) = nullptr;
1840     ;}
1841     break;
1842
1843   case 26:
1844 #line 282 "WebCore/xml/XPathGrammar.y"
1845     {
1846         (yyval.expressionVector) = new Vector<std::unique_ptr<Expression>>;
1847         (yyval.expressionVector)->append(std::unique_ptr<Expression>((yyvsp[(1) - (1)].expression)));
1848     ;}
1849     break;
1850
1851   case 27:
1852 #line 288 "WebCore/xml/XPathGrammar.y"
1853     {
1854         (yyval.expressionVector) = (yyvsp[(1) - (2)].expressionVector);
1855         (yyval.expressionVector)->append(std::unique_ptr<Expression>((yyvsp[(2) - (2)].expression)));
1856     ;}
1857     break;
1858
1859   case 28:
1860 #line 296 "WebCore/xml/XPathGrammar.y"
1861     {
1862         (yyval.expression) = (yyvsp[(2) - (3)].expression);
1863     ;}
1864     break;
1865
1866   case 29:
1867 #line 303 "WebCore/xml/XPathGrammar.y"
1868     {
1869         (yyval.step) = new Step(Step::DescendantOrSelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
1870     ;}
1871     break;
1872
1873   case 30:
1874 #line 310 "WebCore/xml/XPathGrammar.y"
1875     {
1876         (yyval.step) = new Step(Step::SelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
1877     ;}
1878     break;
1879
1880   case 31:
1881 #line 315 "WebCore/xml/XPathGrammar.y"
1882     {
1883         (yyval.step) = new Step(Step::ParentAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
1884     ;}
1885     break;
1886
1887   case 32:
1888 #line 322 "WebCore/xml/XPathGrammar.y"
1889     {
1890         String name = adoptRef((yyvsp[(1) - (1)].string));
1891         (yyval.expression) = new VariableReference(name);
1892     ;}
1893     break;
1894
1895   case 33:
1896 #line 328 "WebCore/xml/XPathGrammar.y"
1897     {
1898         (yyval.expression) = (yyvsp[(2) - (3)].expression);
1899     ;}
1900     break;
1901
1902   case 34:
1903 #line 333 "WebCore/xml/XPathGrammar.y"
1904     {
1905         String literal = adoptRef((yyvsp[(1) - (1)].string));
1906         (yyval.expression) = new StringExpression(WTFMove(literal));
1907     ;}
1908     break;
1909
1910   case 35:
1911 #line 339 "WebCore/xml/XPathGrammar.y"
1912     {
1913         String numeral = adoptRef((yyvsp[(1) - (1)].string));
1914         (yyval.expression) = new Number(numeral.toDouble());
1915     ;}
1916     break;
1917
1918   case 37:
1919 #line 349 "WebCore/xml/XPathGrammar.y"
1920     {
1921         String name = adoptRef((yyvsp[(1) - (3)].string));
1922         (yyval.expression) = XPath::Function::create(name).release();
1923         if (!(yyval.expression))
1924             YYABORT;
1925     ;}
1926     break;
1927
1928   case 38:
1929 #line 357 "WebCore/xml/XPathGrammar.y"
1930     {
1931         String name = adoptRef((yyvsp[(1) - (4)].string));
1932         std::unique_ptr<Vector<std::unique_ptr<Expression>>> argumentList((yyvsp[(3) - (4)].expressionVector));
1933         (yyval.expression) = XPath::Function::create(name, WTFMove(*argumentList)).release();
1934         if (!(yyval.expression))
1935             YYABORT;
1936     ;}
1937     break;
1938
1939   case 39:
1940 #line 368 "WebCore/xml/XPathGrammar.y"
1941     {
1942         (yyval.expressionVector) = new Vector<std::unique_ptr<Expression>>;
1943         (yyval.expressionVector)->append(std::unique_ptr<Expression>((yyvsp[(1) - (1)].expression)));
1944     ;}
1945     break;
1946
1947   case 40:
1948 #line 374 "WebCore/xml/XPathGrammar.y"
1949     {
1950         (yyval.expressionVector) = (yyvsp[(1) - (3)].expressionVector);
1951         (yyval.expressionVector)->append(std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
1952     ;}
1953     break;
1954
1955   case 43:
1956 #line 388 "WebCore/xml/XPathGrammar.y"
1957     {
1958         (yyval.expression) = new Union(std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
1959     ;}
1960     break;
1961
1962   case 44:
1963 #line 395 "WebCore/xml/XPathGrammar.y"
1964     {
1965         (yyval.expression) = (yyvsp[(1) - (1)].locationPath);
1966     ;}
1967     break;
1968
1969   case 46:
1970 #line 402 "WebCore/xml/XPathGrammar.y"
1971     {
1972         (yyvsp[(3) - (3)].locationPath)->setAbsolute();
1973         (yyval.expression) = new Path(std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<LocationPath>((yyvsp[(3) - (3)].locationPath)));
1974     ;}
1975     break;
1976
1977   case 47:
1978 #line 408 "WebCore/xml/XPathGrammar.y"
1979     {
1980         (yyvsp[(3) - (3)].locationPath)->prependStep(std::unique_ptr<Step>((yyvsp[(2) - (3)].step)));
1981         (yyvsp[(3) - (3)].locationPath)->setAbsolute();
1982         (yyval.expression) = new Path(std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<LocationPath>((yyvsp[(3) - (3)].locationPath)));
1983     ;}
1984     break;
1985
1986   case 49:
1987 #line 419 "WebCore/xml/XPathGrammar.y"
1988     {
1989         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList((yyvsp[(2) - (2)].expressionVector));
1990         (yyval.expression) = new Filter(std::unique_ptr<Expression>((yyvsp[(1) - (2)].expression)), WTFMove(*predicateList));
1991     ;}
1992     break;
1993
1994   case 51:
1995 #line 429 "WebCore/xml/XPathGrammar.y"
1996     {
1997         (yyval.expression) = new LogicalOp(LogicalOp::OP_Or, std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
1998     ;}
1999     break;
2000
2001   case 53:
2002 #line 438 "WebCore/xml/XPathGrammar.y"
2003     {
2004         (yyval.expression) = new LogicalOp(LogicalOp::OP_And, std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2005     ;}
2006     break;
2007
2008   case 55:
2009 #line 447 "WebCore/xml/XPathGrammar.y"
2010     {
2011         (yyval.expression) = new EqTestOp((yyvsp[(2) - (3)].equalityTestOpcode), std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2012     ;}
2013     break;
2014
2015   case 57:
2016 #line 456 "WebCore/xml/XPathGrammar.y"
2017     {
2018         (yyval.expression) = new EqTestOp((yyvsp[(2) - (3)].equalityTestOpcode), std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2019     ;}
2020     break;
2021
2022   case 59:
2023 #line 465 "WebCore/xml/XPathGrammar.y"
2024     {
2025         (yyval.expression) = new NumericOp(NumericOp::OP_Add, std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2026     ;}
2027     break;
2028
2029   case 60:
2030 #line 470 "WebCore/xml/XPathGrammar.y"
2031     {
2032         (yyval.expression) = new NumericOp(NumericOp::OP_Sub, std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2033     ;}
2034     break;
2035
2036   case 62:
2037 #line 479 "WebCore/xml/XPathGrammar.y"
2038     {
2039         (yyval.expression) = new NumericOp((yyvsp[(2) - (3)].numericOpcode), std::unique_ptr<Expression>((yyvsp[(1) - (3)].expression)), std::unique_ptr<Expression>((yyvsp[(3) - (3)].expression)));
2040     ;}
2041     break;
2042
2043   case 64:
2044 #line 488 "WebCore/xml/XPathGrammar.y"
2045     {
2046         (yyval.expression) = new Negative(std::unique_ptr<Expression>((yyvsp[(2) - (2)].expression)));
2047     ;}
2048     break;
2049
2050
2051 /* Line 1267 of yacc.c.  */
2052 #line 2049 "./XPathGrammar.cpp"
2053       default: break;
2054     }
2055   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2056
2057   YYPOPSTACK (yylen);
2058   yylen = 0;
2059   YY_STACK_PRINT (yyss, yyssp);
2060
2061   *++yyvsp = yyval;
2062
2063
2064   /* Now `shift' the result of the reduction.  Determine what state
2065      that goes to, based on the state we popped back to and the rule
2066      number reduced by.  */
2067
2068   yyn = yyr1[yyn];
2069
2070   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2071   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2072     yystate = yytable[yystate];
2073   else
2074     yystate = yydefgoto[yyn - YYNTOKENS];
2075
2076   goto yynewstate;
2077
2078
2079 /*------------------------------------.
2080 | yyerrlab -- here on detecting error |
2081 `------------------------------------*/
2082 yyerrlab:
2083   /* If not already recovering from an error, report this error.  */
2084   if (!yyerrstatus)
2085     {
2086       ++yynerrs;
2087 #if ! YYERROR_VERBOSE
2088       yyerror (parser, YY_("syntax error"));
2089 #else
2090       {
2091     YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2092     if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2093       {
2094         YYSIZE_T yyalloc = 2 * yysize;
2095         if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2096           yyalloc = YYSTACK_ALLOC_MAXIMUM;
2097         if (yymsg != yymsgbuf)
2098           YYSTACK_FREE (yymsg);
2099         yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2100         if (yymsg)
2101           yymsg_alloc = yyalloc;
2102         else
2103           {
2104         yymsg = yymsgbuf;
2105         yymsg_alloc = sizeof yymsgbuf;
2106           }
2107       }
2108
2109     if (0 < yysize && yysize <= yymsg_alloc)
2110       {
2111         (void) yysyntax_error (yymsg, yystate, yychar);
2112         yyerror (parser, yymsg);
2113       }
2114     else
2115       {
2116         yyerror (parser, YY_("syntax error"));
2117         if (yysize != 0)
2118           goto yyexhaustedlab;
2119       }
2120       }
2121 #endif
2122     }
2123
2124
2125
2126   if (yyerrstatus == 3)
2127     {
2128       /* If just tried and failed to reuse look-ahead token after an
2129      error, discard it.  */
2130
2131       if (yychar <= YYEOF)
2132     {
2133       /* Return failure if at end of input.  */
2134       if (yychar == YYEOF)
2135         YYABORT;
2136     }
2137       else
2138     {
2139       yydestruct ("Error: discarding",
2140               yytoken, &yylval, parser);
2141       yychar = YYEMPTY;
2142     }
2143     }
2144
2145   /* Else will try to reuse look-ahead token after shifting the error
2146      token.  */
2147   goto yyerrlab1;
2148
2149
2150 /*---------------------------------------------------.
2151 | yyerrorlab -- error raised explicitly by YYERROR.  |
2152 `---------------------------------------------------*/
2153 yyerrorlab:
2154
2155   /* Pacify compilers like GCC when the user code never invokes
2156      YYERROR and the label yyerrorlab therefore never appears in user
2157      code.  */
2158 #if COMPILER(CLANG)
2159 #pragma clang diagnostic push
2160 #pragma clang diagnostic ignored "-Wunreachable-code"
2161 #endif
2162   if (/*CONSTCOND*/ 0)
2163      goto yyerrorlab;
2164 #if COMPILER(CLANG)
2165 #pragma clang diagnostic pop
2166 #endif
2167
2168   /* Do not reclaim the symbols of the rule which action triggered
2169      this YYERROR.  */
2170   YYPOPSTACK (yylen);
2171   yylen = 0;
2172   YY_STACK_PRINT (yyss, yyssp);
2173   yystate = *yyssp;
2174   goto yyerrlab1;
2175
2176
2177 /*-------------------------------------------------------------.
2178 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
2179 `-------------------------------------------------------------*/
2180 yyerrlab1:
2181   yyerrstatus = 3;    /* Each real token shifted decrements this.  */
2182
2183   for (;;)
2184     {
2185       yyn = yypact[yystate];
2186       if (yyn != YYPACT_NINF)
2187     {
2188       yyn += YYTERROR;
2189       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2190         {
2191           yyn = yytable[yyn];
2192           if (0 < yyn)
2193         break;
2194         }
2195     }
2196
2197       /* Pop the current state because it cannot handle the error token.  */
2198       if (yyssp == yyss)
2199     YYABORT;
2200
2201
2202       yydestruct ("Error: popping",
2203           yystos[yystate], yyvsp, parser);
2204       YYPOPSTACK (1);
2205       yystate = *yyssp;
2206       YY_STACK_PRINT (yyss, yyssp);
2207     }
2208
2209   if (yyn == YYFINAL)
2210     YYACCEPT;
2211
2212   *++yyvsp = yylval;
2213
2214
2215   /* Shift the error token.  */
2216   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2217
2218   yystate = yyn;
2219   goto yynewstate;
2220
2221
2222 /*-------------------------------------.
2223 | yyacceptlab -- YYACCEPT comes here.  |
2224 `-------------------------------------*/
2225 yyacceptlab:
2226   yyresult = 0;
2227   goto yyreturn;
2228
2229 /*-----------------------------------.
2230 | yyabortlab -- YYABORT comes here.  |
2231 `-----------------------------------*/
2232 yyabortlab:
2233   yyresult = 1;
2234   goto yyreturn;
2235
2236 #ifndef yyoverflow
2237 /*-------------------------------------------------.
2238 | yyexhaustedlab -- memory exhaustion comes here.  |
2239 `-------------------------------------------------*/
2240 yyexhaustedlab:
2241   yyerror (parser, YY_("memory exhausted"));
2242   yyresult = 2;
2243   /* Fall through.  */
2244 #endif
2245
2246 yyreturn:
2247   if (yychar != YYEOF && yychar != YYEMPTY)
2248      yydestruct ("Cleanup: discarding lookahead",
2249          yytoken, &yylval, parser);
2250   /* Do not reclaim the symbols of the rule which action triggered
2251      this YYABORT or YYACCEPT.  */
2252   YYPOPSTACK (yylen);
2253   YY_STACK_PRINT (yyss, yyssp);
2254   while (yyssp != yyss)
2255     {
2256       yydestruct ("Cleanup: popping",
2257           yystos[*yyssp], yyvsp, parser);
2258       YYPOPSTACK (1);
2259     }
2260 #ifndef yyoverflow
2261   if (yyss != yyssa)
2262     YYSTACK_FREE (yyss);
2263 #endif
2264 #if YYERROR_VERBOSE
2265   if (yymsg != yymsgbuf)
2266     YYSTACK_FREE (yymsg);
2267 #endif
2268   /* Make sure YYID is used.  */
2269   return YYID (yyresult);
2270 }
2271
2272
2273 #line 493 "WebCore/xml/XPathGrammar.y"
2274
2275