KHtml

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

KDE's Doxygen guidelines are available online.