cprover
xml_y.tab.cpp
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.5. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
6  Inc.
7 
8  This program is free software: you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 
21 /* As a special exception, you may create a larger work that contains
22  part or all of the Bison parser skeleton and distribute that work
23  under terms of your choice, so long as that work isn't itself a
24  parser generator using the skeleton or a modified version thereof
25  as a parser skeleton. Alternatively, if you modify or redistribute
26  the parser skeleton itself, you may (at your option) remove this
27  special exception, which will cause the skeleton and the resulting
28  Bison output files to be licensed under the GNU General Public
29  License without this special exception.
30 
31  This special exception was added by the Free Software Foundation in
32  version 2.2 of Bison. */
33 
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35  simplifying the original so-called "semantic" parser. */
36 
37 /* All symbols defined below should begin with yy or YY, to avoid
38  infringing on user name space. This should be done even for local
39  variables, as they might otherwise be expanded by user macros.
40  There are some unavoidable exceptions within include files to
41  define necessary library symbols; they are noted "INFRINGES ON
42  USER NAME SPACE" below. */
43 
44 /* Undocumented macros, especially those whose name start with YY_,
45  are private implementation details. Do not rely on them. */
46 
47 /* Identify Bison output. */
48 #define YYBISON 1
49 
50 /* Bison version. */
51 #define YYBISON_VERSION "3.5"
52 
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55 
56 /* Pure parsers. */
57 #define YYPURE 0
58 
59 /* Push parsers. */
60 #define YYPUSH 0
61 
62 /* Pull parsers. */
63 #define YYPULL 1
64 
65 
66 /* Substitute the variable and function names. */
67 #define yyparse yyxmlparse
68 #define yylex yyxmllex
69 #define yyerror yyxmlerror
70 #define yydebug yyxmldebug
71 #define yynerrs yyxmlnerrs
72 #define yylval yyxmllval
73 #define yychar yyxmlchar
74 
75 /* First part of user prologue. */
76 #line 1 "parser.y"
77 
78 #include <cstring>
79 
80 #include "xml_parser.h"
81 
82 int yyxmllex();
83 extern char *yyxmltext;
84 
85 int yyxmlerror(const std::string &error)
86 {
88  return 0;
89 }
90 
91 
92 #line 93 "xml_y.tab.cpp"
93 
94 # ifndef YY_CAST
95 # ifdef __cplusplus
96 # define YY_CAST(Type, Val) static_cast<Type> (Val)
97 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
98 # else
99 # define YY_CAST(Type, Val) ((Type) (Val))
100 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
101 # endif
102 # endif
103 # ifndef YY_NULLPTR
104 # if defined __cplusplus
105 # if 201103L <= __cplusplus
106 # define YY_NULLPTR nullptr
107 # else
108 # define YY_NULLPTR 0
109 # endif
110 # else
111 # define YY_NULLPTR ((void*)0)
112 # endif
113 # endif
114 
115 /* Enabling verbose error messages. */
116 #ifdef YYERROR_VERBOSE
117 # undef YYERROR_VERBOSE
118 # define YYERROR_VERBOSE 1
119 #else
120 # define YYERROR_VERBOSE 1
121 #endif
122 
123 /* Use api.header.include to #include this header
124  instead of duplicating it here. */
125 #ifndef YY_YYXML_XML_Y_TAB_HPP_INCLUDED
126 # define YY_YYXML_XML_Y_TAB_HPP_INCLUDED
127 /* Debug traces. */
128 #ifndef YYDEBUG
129 # define YYDEBUG 0
130 #endif
131 #if YYDEBUG
132 extern int yyxmldebug;
133 #endif
134 
135 /* Token type. */
136 #ifndef YYTOKENTYPE
137 # define YYTOKENTYPE
139  {
141  VERSION = 259,
142  STARTPI = 260,
143  ENDPI = 261,
144  EQ = 262,
145  SLASH = 263,
146  CLOSE = 264,
147  END = 265,
148  ENCODING = 266,
149  NAME = 267,
150  VALUE = 268,
151  DATA = 269,
152  COMMENT = 270,
153  START = 271
154  };
155 #endif
156 /* Tokens. */
157 #define STARTXMLDECL 258
158 #define VERSION 259
159 #define STARTPI 260
160 #define ENDPI 261
161 #define EQ 262
162 #define SLASH 263
163 #define CLOSE 264
164 #define END 265
165 #define ENCODING 266
166 #define NAME 267
167 #define VALUE 268
168 #define DATA 269
169 #define COMMENT 270
170 #define START 271
171 
172 /* Value type. */
173 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
174 union YYSTYPE
175 {
176 #line 19 "parser.y"
177 char *s;
178 
179 #line 180 "xml_y.tab.cpp"
180 
181 };
182 typedef union YYSTYPE YYSTYPE;
183 # define YYSTYPE_IS_TRIVIAL 1
184 # define YYSTYPE_IS_DECLARED 1
185 #endif
186 
187 
188 extern YYSTYPE yyxmllval;
189 
190 int yyxmlparse (void);
191 
192 #endif /* !YY_YYXML_XML_Y_TAB_HPP_INCLUDED */
193 
194 
195 
196 #ifdef short
197 # undef short
198 #endif
199 
200 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
201  <limits.h> and (if available) <stdint.h> are included
202  so that the code can choose integer types of a good width. */
203 
204 #ifndef __PTRDIFF_MAX__
205 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
206 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
207 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
208 # define YY_STDINT_H
209 # endif
210 #endif
211 
212 /* Narrow types that promote to a signed type and that can represent a
213  signed or unsigned integer of at least N bits. In tables they can
214  save space and decrease cache pressure. Promoting to a signed type
215  helps avoid bugs in integer arithmetic. */
216 
217 #ifdef __INT_LEAST8_MAX__
218 typedef __INT_LEAST8_TYPE__ yytype_int8;
219 #elif defined YY_STDINT_H
220 typedef int_least8_t yytype_int8;
221 #else
222 typedef signed char yytype_int8;
223 #endif
224 
225 #ifdef __INT_LEAST16_MAX__
226 typedef __INT_LEAST16_TYPE__ yytype_int16;
227 #elif defined YY_STDINT_H
228 typedef int_least16_t yytype_int16;
229 #else
230 typedef short yytype_int16;
231 #endif
232 
233 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
234 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
235 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
236  && UINT_LEAST8_MAX <= INT_MAX)
237 typedef uint_least8_t yytype_uint8;
238 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
239 typedef unsigned char yytype_uint8;
240 #else
241 typedef short yytype_uint8;
242 #endif
243 
244 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
245 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
246 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
247  && UINT_LEAST16_MAX <= INT_MAX)
248 typedef uint_least16_t yytype_uint16;
249 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
250 typedef unsigned short yytype_uint16;
251 #else
252 typedef int yytype_uint16;
253 #endif
254 
255 #ifndef YYPTRDIFF_T
256 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
257 # define YYPTRDIFF_T __PTRDIFF_TYPE__
258 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
259 # elif defined PTRDIFF_MAX
260 # ifndef ptrdiff_t
261 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
262 # endif
263 # define YYPTRDIFF_T ptrdiff_t
264 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
265 # else
266 # define YYPTRDIFF_T long
267 # define YYPTRDIFF_MAXIMUM LONG_MAX
268 # endif
269 #endif
270 
271 #ifndef YYSIZE_T
272 # ifdef __SIZE_TYPE__
273 # define YYSIZE_T __SIZE_TYPE__
274 # elif defined size_t
275 # define YYSIZE_T size_t
276 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
277 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
278 # define YYSIZE_T size_t
279 # else
280 # define YYSIZE_T unsigned
281 # endif
282 #endif
283 
284 #define YYSIZE_MAXIMUM \
285  YY_CAST (YYPTRDIFF_T, \
286  (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
287  ? YYPTRDIFF_MAXIMUM \
288  : YY_CAST (YYSIZE_T, -1)))
289 
290 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
291 
292 /* Stored state numbers (used for stacks). */
294 
295 /* State numbers in computations. */
296 typedef int yy_state_fast_t;
297 
298 #ifndef YY_
299 # if defined YYENABLE_NLS && YYENABLE_NLS
300 # if ENABLE_NLS
301 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
302 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
303 # endif
304 # endif
305 # ifndef YY_
306 # define YY_(Msgid) Msgid
307 # endif
308 #endif
309 
310 #ifndef YY_ATTRIBUTE_PURE
311 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
312 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
313 # else
314 # define YY_ATTRIBUTE_PURE
315 # endif
316 #endif
317 
318 #ifndef YY_ATTRIBUTE_UNUSED
319 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
320 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
321 # else
322 # define YY_ATTRIBUTE_UNUSED
323 # endif
324 #endif
325 
326 /* Suppress unused-variable warnings by "using" E. */
327 #if ! defined lint || defined __GNUC__
328 # define YYUSE(E) ((void) (E))
329 #else
330 # define YYUSE(E) /* empty */
331 #endif
332 
333 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
334 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
335 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
336  _Pragma ("GCC diagnostic push") \
337  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
338  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
339 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
340  _Pragma ("GCC diagnostic pop")
341 #else
342 # define YY_INITIAL_VALUE(Value) Value
343 #endif
344 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
345 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
346 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
347 #endif
348 #ifndef YY_INITIAL_VALUE
349 # define YY_INITIAL_VALUE(Value) /* Nothing. */
350 #endif
351 
352 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
353 # define YY_IGNORE_USELESS_CAST_BEGIN \
354  _Pragma ("GCC diagnostic push") \
355  _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
356 # define YY_IGNORE_USELESS_CAST_END \
357  _Pragma ("GCC diagnostic pop")
358 #endif
359 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
360 # define YY_IGNORE_USELESS_CAST_BEGIN
361 # define YY_IGNORE_USELESS_CAST_END
362 #endif
363 
364 
365 #define YY_ASSERT(E) ((void) (0 && (E)))
366 
367 #if ! defined yyoverflow || YYERROR_VERBOSE
368 
369 /* The parser invokes alloca or malloc; define the necessary symbols. */
370 
371 # ifdef YYSTACK_USE_ALLOCA
372 # if YYSTACK_USE_ALLOCA
373 # ifdef __GNUC__
374 # define YYSTACK_ALLOC __builtin_alloca
375 # elif defined __BUILTIN_VA_ARG_INCR
376 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
377 # elif defined _AIX
378 # define YYSTACK_ALLOC __alloca
379 # elif defined _MSC_VER
380 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
381 # define alloca _alloca
382 # else
383 # define YYSTACK_ALLOC alloca
384 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
385 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
386  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
387 # ifndef EXIT_SUCCESS
388 # define EXIT_SUCCESS 0
389 # endif
390 # endif
391 # endif
392 # endif
393 # endif
394 
395 # ifdef YYSTACK_ALLOC
396  /* Pacify GCC's 'empty if-body' warning. */
397 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
398 # ifndef YYSTACK_ALLOC_MAXIMUM
399  /* The OS might guarantee only one guard page at the bottom of the stack,
400  and a page size can be as small as 4096 bytes. So we cannot safely
401  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
402  to allow for a few compiler-allocated temporary stack slots. */
403 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
404 # endif
405 # else
406 # define YYSTACK_ALLOC YYMALLOC
407 # define YYSTACK_FREE YYFREE
408 # ifndef YYSTACK_ALLOC_MAXIMUM
409 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
410 # endif
411 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
412  && ! ((defined YYMALLOC || defined malloc) \
413  && (defined YYFREE || defined free)))
414 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
415 # ifndef EXIT_SUCCESS
416 # define EXIT_SUCCESS 0
417 # endif
418 # endif
419 # ifndef YYMALLOC
420 # define YYMALLOC malloc
421 # if ! defined malloc && ! defined EXIT_SUCCESS
422 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
423 # endif
424 # endif
425 # ifndef YYFREE
426 # define YYFREE free
427 # if ! defined free && ! defined EXIT_SUCCESS
428 void free (void *); /* INFRINGES ON USER NAME SPACE */
429 # endif
430 # endif
431 # endif
432 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
433 
434 
435 #if (! defined yyoverflow \
436  && (! defined __cplusplus \
437  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
438 
439 /* A type that is properly aligned for any stack member. */
440 union yyalloc
441 {
444 };
445 
446 /* The size of the maximum gap between one aligned stack and the next. */
447 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
448 
449 /* The size of an array large to enough to hold all stacks, each with
450  N elements. */
451 # define YYSTACK_BYTES(N) \
452  ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
453  + YYSTACK_GAP_MAXIMUM)
454 
455 # define YYCOPY_NEEDED 1
456 
457 /* Relocate STACK from its old location to the new one. The
458  local variables YYSIZE and YYSTACKSIZE give the old and new number of
459  elements in the stack, and YYPTR gives the new location of the
460  stack. Advance YYPTR to a properly aligned location for the next
461  stack. */
462 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
463  do \
464  { \
465  YYPTRDIFF_T yynewbytes; \
466  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
467  Stack = &yyptr->Stack_alloc; \
468  yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
469  yyptr += yynewbytes / YYSIZEOF (*yyptr); \
470  } \
471  while (0)
472 
473 #endif
474 
475 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
476 /* Copy COUNT objects from SRC to DST. The source and destination do
477  not overlap. */
478 # ifndef YYCOPY
479 # if defined __GNUC__ && 1 < __GNUC__
480 # define YYCOPY(Dst, Src, Count) \
481  __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
482 # else
483 # define YYCOPY(Dst, Src, Count) \
484  do \
485  { \
486  YYPTRDIFF_T yyi; \
487  for (yyi = 0; yyi < (Count); yyi++) \
488  (Dst)[yyi] = (Src)[yyi]; \
489  } \
490  while (0)
491 # endif
492 # endif
493 #endif /* !YYCOPY_NEEDED */
494 
495 /* YYFINAL -- State number of the termination state. */
496 #define YYFINAL 6
497 /* YYLAST -- Last index in YYTABLE. */
498 #define YYLAST 25
499 
500 /* YYNTOKENS -- Number of terminals. */
501 #define YYNTOKENS 17
502 /* YYNNTS -- Number of nonterminals. */
503 #define YYNNTS 20
504 /* YYNRULES -- Number of rules. */
505 #define YYNRULES 29
506 /* YYNSTATES -- Number of states. */
507 #define YYNSTATES 43
508 
509 #define YYUNDEFTOK 2
510 #define YYMAXUTOK 271
511 
512 
513 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
514  as returned by yylex, with out-of-bounds checking. */
515 #define YYTRANSLATE(YYX) \
516  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
517 
518 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
519  as returned by yylex. */
520 static const yytype_int8 yytranslate[] =
521 {
522  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
523  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
524  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
525  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
527  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
528  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
529  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
530  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
531  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
532  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
535  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
537  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
538  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
539  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
540  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
541  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
542  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
543  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
545  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
546  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
547  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
548  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
549  15, 16
550 };
551 
552 #if YYDEBUG
553  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
554 static const yytype_int8 yyrline[] =
555 {
556  0, 29, 29, 33, 38, 40, 37, 42, 46, 47,
557  51, 52, 57, 59, 56, 64, 64, 72, 73, 73,
558  78, 79, 81, 80, 84, 88, 89, 93, 94, 98
559 };
560 #endif
561 
562 #if YYDEBUG || YYERROR_VERBOSE || 1
563 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
564  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
565 static const char *const yytname[] =
566 {
567  "$end", "error", "$undefined", "STARTXMLDECL", "VERSION", "STARTPI",
568  "ENDPI", "EQ", "SLASH", "CLOSE", "END", "ENCODING", "NAME", "VALUE",
569  "DATA", "COMMENT", "START", "$accept", "document", "prolog",
570  "XMLDecl_opt", "$@1", "$@2", "misc_seq_opt", "misc", "PI", "$@3", "$@4",
571  "element", "$@5", "empty_or_content", "$@6", "content", "$@7",
572  "name_opt", "attribute_seq_opt", "attribute", YY_NULLPTR
573 };
574 #endif
575 
576 # ifdef YYPRINT
577 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
578  (internal) symbol number NUM (which must be that of a token). */
579 static const yytype_int16 yytoknum[] =
580 {
581  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
582  265, 266, 267, 268, 269, 270, 271
583 };
584 # endif
585 
586 #define YYPACT_NINF (-13)
587 
588 #define yypact_value_is_default(Yyn) \
589  ((Yyn) == YYPACT_NINF)
590 
591 #define YYTABLE_NINF (-1)
592 
593 #define yytable_value_is_error(Yyn) \
594  0
595 
596  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
597  STATE-NUM. */
598 static const yytype_int8 yypact[] =
599 {
600  2, -13, 8, -7, -13, -13, -13, -13, -13, -3,
601  1, -13, -3, 3, -13, -13, -13, 7, 11, -13,
602  -5, -13, 5, -13, 10, -13, -13, -13, -13, -13,
603  -13, 1, -4, 14, 9, -13, -13, -7, -13, -13,
604  13, -13, -13
605 };
606 
607  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
608  Performed when YYTABLE does not specify something else to do. Zero
609  means the default is an error. */
610 static const yytype_int8 yydefact[] =
611 {
612  7, 4, 0, 0, 9, 28, 1, 15, 9, 3,
613  5, 28, 2, 0, 10, 8, 11, 0, 0, 27,
614  0, 12, 0, 6, 0, 18, 16, 28, 29, 17,
615  24, 13, 22, 0, 26, 20, 21, 0, 14, 25,
616  0, 23, 19
617 };
618 
619  /* YYPGOTO[NTERM-NUM]. */
620 static const yytype_int8 yypgoto[] =
621 {
622  -13, -13, -13, -13, -13, -13, 15, -8, -13, -13,
623  -13, -12, -13, -13, -13, -13, -13, -13, -11, -13
624 };
625 
626  /* YYDEFGOTO[NTERM-NUM]. */
627 static const yytype_int8 yydefgoto[] =
628 {
629  -1, 2, 3, 4, 5, 18, 9, 15, 16, 27,
630  33, 8, 11, 26, 30, 32, 37, 40, 10, 19
631 };
632 
633  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
634  positive, shift that token. If negative, reduce the rule whose
635  number is the opposite. If YYTABLE_NINF, syntax error. */
636 static const yytype_int8 yytable[] =
637 {
638  20, 13, 13, 24, 25, 1, 34, 17, 6, 7,
639  35, 14, 14, 17, 22, 21, 31, 23, 28, 29,
640  38, 39, 42, 12, 36, 41
641 };
642 
643 static const yytype_int8 yycheck[] =
644 {
645  11, 5, 5, 8, 9, 3, 10, 12, 0, 16,
646  14, 15, 15, 12, 7, 12, 27, 6, 13, 9,
647  6, 12, 9, 8, 32, 37
648 };
649 
650  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
651  symbol of state STATE-NUM. */
652 static const yytype_int8 yystos[] =
653 {
654  0, 3, 18, 19, 20, 21, 0, 16, 28, 23,
655  35, 29, 23, 5, 15, 24, 25, 12, 22, 36,
656  35, 12, 7, 6, 8, 9, 30, 26, 13, 9,
657  31, 35, 32, 27, 10, 14, 24, 33, 6, 12,
658  34, 28, 9
659 };
660 
661  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
662 static const yytype_int8 yyr1[] =
663 {
664  0, 17, 18, 19, 21, 22, 20, 20, 23, 23,
665  24, 24, 26, 27, 25, 29, 28, 30, 31, 30,
666  32, 32, 33, 32, 32, 34, 34, 35, 35, 36
667 };
668 
669  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
670 static const yytype_int8 yyr2[] =
671 {
672  0, 2, 3, 2, 0, 0, 5, 0, 2, 0,
673  1, 1, 0, 0, 6, 0, 4, 2, 0, 6,
674  2, 2, 0, 3, 0, 1, 0, 2, 0, 3
675 };
676 
677 
678 #define yyerrok (yyerrstatus = 0)
679 #define yyclearin (yychar = YYEMPTY)
680 #define YYEMPTY (-2)
681 #define YYEOF 0
682 
683 #define YYACCEPT goto yyacceptlab
684 #define YYABORT goto yyabortlab
685 #define YYERROR goto yyerrorlab
686 
687 
688 #define YYRECOVERING() (!!yyerrstatus)
689 
690 #define YYBACKUP(Token, Value) \
691  do \
692  if (yychar == YYEMPTY) \
693  { \
694  yychar = (Token); \
695  yylval = (Value); \
696  YYPOPSTACK (yylen); \
697  yystate = *yyssp; \
698  goto yybackup; \
699  } \
700  else \
701  { \
702  yyerror (YY_("syntax error: cannot back up")); \
703  YYERROR; \
704  } \
705  while (0)
706 
707 /* Error token number */
708 #define YYTERROR 1
709 #define YYERRCODE 256
710 
711 
712 
713 /* Enable debugging if requested. */
714 #if YYDEBUG
715 
716 # ifndef YYFPRINTF
717 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
718 # define YYFPRINTF fprintf
719 # endif
720 
721 # define YYDPRINTF(Args) \
722 do { \
723  if (yydebug) \
724  YYFPRINTF Args; \
725 } while (0)
726 
727 /* This macro is provided for backward compatibility. */
728 #ifndef YY_LOCATION_PRINT
729 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
730 #endif
731 
732 
733 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
734 do { \
735  if (yydebug) \
736  { \
737  YYFPRINTF (stderr, "%s ", Title); \
738  yy_symbol_print (stderr, \
739  Type, Value); \
740  YYFPRINTF (stderr, "\n"); \
741  } \
742 } while (0)
743 
744 
745 /*-----------------------------------.
746 | Print this symbol's value on YYO. |
747 `-----------------------------------*/
748 
749 static void
750 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
751 {
752  FILE *yyoutput = yyo;
753  YYUSE (yyoutput);
754  if (!yyvaluep)
755  return;
756 # ifdef YYPRINT
757  if (yytype < YYNTOKENS)
758  YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
759 # endif
761  YYUSE (yytype);
763 }
764 
765 
766 /*---------------------------.
767 | Print this symbol on YYO. |
768 `---------------------------*/
769 
770 static void
771 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
772 {
773  YYFPRINTF (yyo, "%s %s (",
774  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
775 
776  yy_symbol_value_print (yyo, yytype, yyvaluep);
777  YYFPRINTF (yyo, ")");
778 }
779 
780 /*------------------------------------------------------------------.
781 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
782 | TOP (included). |
783 `------------------------------------------------------------------*/
784 
785 static void
786 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
787 {
788  YYFPRINTF (stderr, "Stack now");
789  for (; yybottom <= yytop; yybottom++)
790  {
791  int yybot = *yybottom;
792  YYFPRINTF (stderr, " %d", yybot);
793  }
794  YYFPRINTF (stderr, "\n");
795 }
796 
797 # define YY_STACK_PRINT(Bottom, Top) \
798 do { \
799  if (yydebug) \
800  yy_stack_print ((Bottom), (Top)); \
801 } while (0)
802 
803 
804 /*------------------------------------------------.
805 | Report that the YYRULE is going to be reduced. |
806 `------------------------------------------------*/
807 
808 static void
809 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
810 {
811  int yylno = yyrline[yyrule];
812  int yynrhs = yyr2[yyrule];
813  int yyi;
814  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
815  yyrule - 1, yylno);
816  /* The symbols being reduced. */
817  for (yyi = 0; yyi < yynrhs; yyi++)
818  {
819  YYFPRINTF (stderr, " $%d = ", yyi + 1);
820  yy_symbol_print (stderr,
821  yystos[yyssp[yyi + 1 - yynrhs]],
822  &yyvsp[(yyi + 1) - (yynrhs)]
823  );
824  YYFPRINTF (stderr, "\n");
825  }
826 }
827 
828 # define YY_REDUCE_PRINT(Rule) \
829 do { \
830  if (yydebug) \
831  yy_reduce_print (yyssp, yyvsp, Rule); \
832 } while (0)
833 
834 /* Nonzero means print parse trace. It is left uninitialized so that
835  multiple parsers can coexist. */
836 int yydebug;
837 #else /* !YYDEBUG */
838 # define YYDPRINTF(Args)
839 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
840 # define YY_STACK_PRINT(Bottom, Top)
841 # define YY_REDUCE_PRINT(Rule)
842 #endif /* !YYDEBUG */
843 
844 
845 /* YYINITDEPTH -- initial size of the parser's stacks. */
846 #ifndef YYINITDEPTH
847 # define YYINITDEPTH 200
848 #endif
849 
850 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
851  if the built-in stack extension method is used).
852 
853  Do not make this value too large; the results are undefined if
854  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
855  evaluated with infinite-precision integer arithmetic. */
856 
857 #ifndef YYMAXDEPTH
858 # define YYMAXDEPTH 10000
859 #endif
860 
861 
862 #if YYERROR_VERBOSE
863 
864 # ifndef yystrlen
865 # if defined __GLIBC__ && defined _STRING_H
866 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
867 # else
868 /* Return the length of YYSTR. */
869 static YYPTRDIFF_T
870 yystrlen (const char *yystr)
871 {
872  YYPTRDIFF_T yylen;
873  for (yylen = 0; yystr[yylen]; yylen++)
874  continue;
875  return yylen;
876 }
877 # endif
878 # endif
879 
880 # ifndef yystpcpy
881 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
882 # define yystpcpy stpcpy
883 # else
884 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
885  YYDEST. */
886 static char *
887 yystpcpy (char *yydest, const char *yysrc)
888 {
889  char *yyd = yydest;
890  const char *yys = yysrc;
891 
892  while ((*yyd++ = *yys++) != '\0')
893  continue;
894 
895  return yyd - 1;
896 }
897 # endif
898 # endif
899 
900 # ifndef yytnamerr
901 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
902  quotes and backslashes, so that it's suitable for yyerror. The
903  heuristic is that double-quoting is unnecessary unless the string
904  contains an apostrophe, a comma, or backslash (other than
905  backslash-backslash). YYSTR is taken from yytname. If YYRES is
906  null, do not copy; instead, return the length of what the result
907  would have been. */
908 static YYPTRDIFF_T
909 yytnamerr (char *yyres, const char *yystr)
910 {
911  if (*yystr == '"')
912  {
913  YYPTRDIFF_T yyn = 0;
914  char const *yyp = yystr;
915 
916  for (;;)
917  switch (*++yyp)
918  {
919  case '\'':
920  case ',':
921  goto do_not_strip_quotes;
922 
923  case '\\':
924  if (*++yyp != '\\')
925  goto do_not_strip_quotes;
926  else
927  goto append;
928 
929  append:
930  default:
931  if (yyres)
932  yyres[yyn] = *yyp;
933  yyn++;
934  break;
935 
936  case '"':
937  if (yyres)
938  yyres[yyn] = '\0';
939  return yyn;
940  }
941  do_not_strip_quotes: ;
942  }
943 
944  if (yyres)
945  return yystpcpy (yyres, yystr) - yyres;
946  else
947  return yystrlen (yystr);
948 }
949 # endif
950 
951 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
952  about the unexpected token YYTOKEN for the state stack whose top is
953  YYSSP.
954 
955  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
956  not large enough to hold the message. In that case, also set
957  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
958  required number of bytes is too large to store. */
959 static int
960 yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
961  yy_state_t *yyssp, int yytoken)
962 {
963  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
964  /* Internationalized format string. */
965  const char *yyformat = YY_NULLPTR;
966  /* Arguments of yyformat: reported tokens (one for the "unexpected",
967  one per "expected"). */
968  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
969  /* Actual size of YYARG. */
970  int yycount = 0;
971  /* Cumulated lengths of YYARG. */
972  YYPTRDIFF_T yysize = 0;
973 
974  /* There are many possibilities here to consider:
975  - If this state is a consistent state with a default action, then
976  the only way this function was invoked is if the default action
977  is an error action. In that case, don't check for expected
978  tokens because there are none.
979  - The only way there can be no lookahead present (in yychar) is if
980  this state is a consistent state with a default action. Thus,
981  detecting the absence of a lookahead is sufficient to determine
982  that there is no unexpected or expected token to report. In that
983  case, just report a simple "syntax error".
984  - Don't assume there isn't a lookahead just because this state is a
985  consistent state with a default action. There might have been a
986  previous inconsistent state, consistent state with a non-default
987  action, or user semantic action that manipulated yychar.
988  - Of course, the expected token list depends on states to have
989  correct lookahead information, and it depends on the parser not
990  to perform extra reductions after fetching a lookahead from the
991  scanner and before detecting a syntax error. Thus, state merging
992  (from LALR or IELR) and default reductions corrupt the expected
993  token list. However, the list is correct for canonical LR with
994  one exception: it will still contain any token that will not be
995  accepted due to an error action in a later state.
996  */
997  if (yytoken != YYEMPTY)
998  {
999  int yyn = yypact[*yyssp];
1000  YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1001  yysize = yysize0;
1002  yyarg[yycount++] = yytname[yytoken];
1003  if (!yypact_value_is_default (yyn))
1004  {
1005  /* Start YYX at -YYN if negative to avoid negative indexes in
1006  YYCHECK. In other words, skip the first -YYN actions for
1007  this state because they are default actions. */
1008  int yyxbegin = yyn < 0 ? -yyn : 0;
1009  /* Stay within bounds of both yycheck and yytname. */
1010  int yychecklim = YYLAST - yyn + 1;
1011  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1012  int yyx;
1013 
1014  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1015  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1016  && !yytable_value_is_error (yytable[yyx + yyn]))
1017  {
1018  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1019  {
1020  yycount = 1;
1021  yysize = yysize0;
1022  break;
1023  }
1024  yyarg[yycount++] = yytname[yyx];
1025  {
1026  YYPTRDIFF_T yysize1
1027  = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1028  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1029  yysize = yysize1;
1030  else
1031  return 2;
1032  }
1033  }
1034  }
1035  }
1036 
1037  switch (yycount)
1038  {
1039 # define YYCASE_(N, S) \
1040  case N: \
1041  yyformat = S; \
1042  break
1043  default: /* Avoid compiler warnings. */
1044  YYCASE_(0, YY_("syntax error"));
1045  YYCASE_(1, YY_("syntax error, unexpected %s"));
1046  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1047  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1048  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1049  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1050 # undef YYCASE_
1051  }
1052 
1053  {
1054  /* Don't count the "%s"s in the final size, but reserve room for
1055  the terminator. */
1056  YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
1057  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1058  yysize = yysize1;
1059  else
1060  return 2;
1061  }
1062 
1063  if (*yymsg_alloc < yysize)
1064  {
1065  *yymsg_alloc = 2 * yysize;
1066  if (! (yysize <= *yymsg_alloc
1067  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1068  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1069  return 1;
1070  }
1071 
1072  /* Avoid sprintf, as that infringes on the user's name space.
1073  Don't have undefined behavior even if the translation
1074  produced a string with the wrong number of "%s"s. */
1075  {
1076  char *yyp = *yymsg;
1077  int yyi = 0;
1078  while ((*yyp = *yyformat) != '\0')
1079  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1080  {
1081  yyp += yytnamerr (yyp, yyarg[yyi++]);
1082  yyformat += 2;
1083  }
1084  else
1085  {
1086  ++yyp;
1087  ++yyformat;
1088  }
1089  }
1090  return 0;
1091 }
1092 #endif /* YYERROR_VERBOSE */
1093 
1094 /*-----------------------------------------------.
1095 | Release the memory associated to this symbol. |
1096 `-----------------------------------------------*/
1097 
1098 static void
1099 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1100 {
1101  YYUSE (yyvaluep);
1102  if (!yymsg)
1103  yymsg = "Deleting";
1104  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1105 
1107  YYUSE (yytype);
1109 }
1110 
1111 
1112 
1113 
1114 /* The lookahead symbol. */
1116 
1117 /* The semantic value of the lookahead symbol. */
1119 /* Number of syntax errors so far. */
1121 
1122 
1123 /*----------.
1124 | yyparse. |
1125 `----------*/
1126 
1127 int
1128 yyparse (void)
1129 {
1130  yy_state_fast_t yystate;
1131  /* Number of tokens to shift before error messages enabled. */
1132  int yyerrstatus;
1133 
1134  /* The stacks and their tools:
1135  'yyss': related to states.
1136  'yyvs': related to semantic values.
1137 
1138  Refer to the stacks through separate pointers, to allow yyoverflow
1139  to reallocate them elsewhere. */
1140 
1141  /* The state stack. */
1142  yy_state_t yyssa[YYINITDEPTH];
1143  yy_state_t *yyss;
1144  yy_state_t *yyssp;
1145 
1146  /* The semantic value stack. */
1147  YYSTYPE yyvsa[YYINITDEPTH];
1148  YYSTYPE *yyvs;
1149  YYSTYPE *yyvsp;
1150 
1151  YYPTRDIFF_T yystacksize;
1152 
1153  int yyn;
1154  int yyresult;
1155  /* Lookahead token as an internal (translated) token number. */
1156  int yytoken = 0;
1157  /* The variables used to return semantic value and location from the
1158  action routines. */
1159  YYSTYPE yyval;
1160 
1161 #if YYERROR_VERBOSE
1162  /* Buffer for error messages, and its allocated size. */
1163  char yymsgbuf[128];
1164  char *yymsg = yymsgbuf;
1165  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1166 #endif
1167 
1168 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1169 
1170  /* The number of symbols on the RHS of the reduced rule.
1171  Keep to zero when no symbol should be popped. */
1172  int yylen = 0;
1173 
1174  yyssp = yyss = yyssa;
1175  yyvsp = yyvs = yyvsa;
1176  yystacksize = YYINITDEPTH;
1177 
1178  YYDPRINTF ((stderr, "Starting parse\n"));
1179 
1180  yystate = 0;
1181  yyerrstatus = 0;
1182  yynerrs = 0;
1183  yychar = YYEMPTY; /* Cause a token to be read. */
1184  goto yysetstate;
1185 
1186 
1187 /*------------------------------------------------------------.
1188 | yynewstate -- push a new state, which is found in yystate. |
1189 `------------------------------------------------------------*/
1190 yynewstate:
1191  /* In all cases, when you get here, the value and location stacks
1192  have just been pushed. So pushing a state here evens the stacks. */
1193  yyssp++;
1194 
1195 
1196 /*--------------------------------------------------------------------.
1197 | yysetstate -- set current state (the top of the stack) to yystate. |
1198 `--------------------------------------------------------------------*/
1199 yysetstate:
1200  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1201  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1203  *yyssp = YY_CAST (yy_state_t, yystate);
1205 
1206  if (yyss + yystacksize - 1 <= yyssp)
1207 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1208  goto yyexhaustedlab;
1209 #else
1210  {
1211  /* Get the current used size of the three stacks, in elements. */
1212  YYPTRDIFF_T yysize = yyssp - yyss + 1;
1213 
1214 # if defined yyoverflow
1215  {
1216  /* Give user a chance to reallocate the stack. Use copies of
1217  these so that the &'s don't force the real ones into
1218  memory. */
1219  yy_state_t *yyss1 = yyss;
1220  YYSTYPE *yyvs1 = yyvs;
1221 
1222  /* Each stack pointer address is followed by the size of the
1223  data in use in that stack, in bytes. This used to be a
1224  conditional around just the two extra args, but that might
1225  be undefined if yyoverflow is a macro. */
1226  yyoverflow (YY_("memory exhausted"),
1227  &yyss1, yysize * YYSIZEOF (*yyssp),
1228  &yyvs1, yysize * YYSIZEOF (*yyvsp),
1229  &yystacksize);
1230  yyss = yyss1;
1231  yyvs = yyvs1;
1232  }
1233 # else /* defined YYSTACK_RELOCATE */
1234  /* Extend the stack our own way. */
1235  if (YYMAXDEPTH <= yystacksize)
1236  goto yyexhaustedlab;
1237  yystacksize *= 2;
1238  if (YYMAXDEPTH < yystacksize)
1239  yystacksize = YYMAXDEPTH;
1240 
1241  {
1242  yy_state_t *yyss1 = yyss;
1243  union yyalloc *yyptr =
1244  YY_CAST (union yyalloc *,
1245  YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1246  if (! yyptr)
1247  goto yyexhaustedlab;
1248  YYSTACK_RELOCATE (yyss_alloc, yyss);
1249  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1250 # undef YYSTACK_RELOCATE
1251  if (yyss1 != yyssa)
1252  YYSTACK_FREE (yyss1);
1253  }
1254 # endif
1255 
1256  yyssp = yyss + yysize - 1;
1257  yyvsp = yyvs + yysize - 1;
1258 
1260  YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1261  YY_CAST (long, yystacksize)));
1263 
1264  if (yyss + yystacksize - 1 <= yyssp)
1265  YYABORT;
1266  }
1267 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1268 
1269  if (yystate == YYFINAL)
1270  YYACCEPT;
1271 
1272  goto yybackup;
1273 
1274 
1275 /*-----------.
1276 | yybackup. |
1277 `-----------*/
1278 yybackup:
1279  /* Do appropriate processing given the current state. Read a
1280  lookahead token if we need one and don't already have one. */
1281 
1282  /* First try to decide what to do without reference to lookahead token. */
1283  yyn = yypact[yystate];
1284  if (yypact_value_is_default (yyn))
1285  goto yydefault;
1286 
1287  /* Not known => get a lookahead token if don't already have one. */
1288 
1289  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1290  if (yychar == YYEMPTY)
1291  {
1292  YYDPRINTF ((stderr, "Reading a token: "));
1293  yychar = yylex ();
1294  }
1295 
1296  if (yychar <= YYEOF)
1297  {
1298  yychar = yytoken = YYEOF;
1299  YYDPRINTF ((stderr, "Now at end of input.\n"));
1300  }
1301  else
1302  {
1303  yytoken = YYTRANSLATE (yychar);
1304  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1305  }
1306 
1307  /* If the proper action on seeing token YYTOKEN is to reduce or to
1308  detect an error, take that action. */
1309  yyn += yytoken;
1310  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1311  goto yydefault;
1312  yyn = yytable[yyn];
1313  if (yyn <= 0)
1314  {
1315  if (yytable_value_is_error (yyn))
1316  goto yyerrlab;
1317  yyn = -yyn;
1318  goto yyreduce;
1319  }
1320 
1321  /* Count tokens shifted since error; after three, turn off error
1322  status. */
1323  if (yyerrstatus)
1324  yyerrstatus--;
1325 
1326  /* Shift the lookahead token. */
1327  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1328  yystate = yyn;
1330  *++yyvsp = yylval;
1332 
1333  /* Discard the shifted token. */
1334  yychar = YYEMPTY;
1335  goto yynewstate;
1336 
1337 
1338 /*-----------------------------------------------------------.
1339 | yydefault -- do the default action for the current state. |
1340 `-----------------------------------------------------------*/
1341 yydefault:
1342  yyn = yydefact[yystate];
1343  if (yyn == 0)
1344  goto yyerrlab;
1345  goto yyreduce;
1346 
1347 
1348 /*-----------------------------.
1349 | yyreduce -- do a reduction. |
1350 `-----------------------------*/
1351 yyreduce:
1352  /* yyn is the number of a rule to reduce with. */
1353  yylen = yyr2[yyn];
1354 
1355  /* If YYLEN is nonzero, implement the default value of the action:
1356  '$$ = $1'.
1357 
1358  Otherwise, the following line sets YYVAL to garbage.
1359  This behavior is undocumented and Bison
1360  users should not rely upon it. Assigning to YYVAL
1361  unconditionally makes the parser a bit smaller, and it avoids a
1362  GCC warning that YYVAL may be used uninitialized. */
1363  yyval = yyvsp[1-yylen];
1364 
1365 
1366  YY_REDUCE_PRINT (yyn);
1367  switch (yyn)
1368  {
1369  case 4:
1370 #line 38 "parser.y"
1371  { xml_parser.stack.push_back(&xml_parser.parse_tree.xml); }
1372 #line 1373 "xml_y.tab.cpp"
1373  break;
1374 
1375  case 5:
1376 #line 40 "parser.y"
1377  { xml_parser.stack.pop_back(); }
1378 #line 1379 "xml_y.tab.cpp"
1379  break;
1380 
1381  case 10:
1382 #line 51 "parser.y"
1383  { free((yyvsp[0].s)); }
1384 #line 1385 "xml_y.tab.cpp"
1385  break;
1386 
1387  case 12:
1388 #line 57 "parser.y"
1389  { free((yyvsp[0].s)); xml_parser.stack.push_back(&xml_parser.parse_tree.xml); }
1390 #line 1391 "xml_y.tab.cpp"
1391  break;
1392 
1393  case 13:
1394 #line 59 "parser.y"
1395  { xml_parser.stack.pop_back(); }
1396 #line 1397 "xml_y.tab.cpp"
1397  break;
1398 
1399  case 15:
1400 #line 64 "parser.y"
1401  { xml_parser.current().name=(yyvsp[0].s);
1402  free((yyvsp[0].s));
1403  }
1404 #line 1405 "xml_y.tab.cpp"
1405  break;
1406 
1407  case 17:
1408 #line 72 "parser.y"
1409  { }
1410 #line 1411 "xml_y.tab.cpp"
1411  break;
1412 
1413  case 18:
1414 #line 73 "parser.y"
1415  { }
1416 #line 1417 "xml_y.tab.cpp"
1417  break;
1418 
1419  case 19:
1420 #line 74 "parser.y"
1421  { free((yyvsp[-1].s)); }
1422 #line 1423 "xml_y.tab.cpp"
1423  break;
1424 
1425  case 20:
1426 #line 78 "parser.y"
1427  { xml_parser.current().data+=xmlt::unescape((yyvsp[0].s)); free((yyvsp[0].s)); }
1428 #line 1429 "xml_y.tab.cpp"
1429  break;
1430 
1431  case 22:
1432 #line 81 "parser.y"
1433  { xml_parser.new_level(); }
1434 #line 1435 "xml_y.tab.cpp"
1435  break;
1436 
1437  case 23:
1438 #line 83 "parser.y"
1439  { xml_parser.stack.pop_back(); }
1440 #line 1441 "xml_y.tab.cpp"
1441  break;
1442 
1443  case 25:
1444 #line 88 "parser.y"
1445  { (yyval.s)=(yyvsp[0].s); }
1446 #line 1447 "xml_y.tab.cpp"
1447  break;
1448 
1449  case 26:
1450 #line 89 "parser.y"
1451  { (yyval.s)=strdup(""); }
1452 #line 1453 "xml_y.tab.cpp"
1453  break;
1454 
1455  case 29:
1456 #line 98 "parser.y"
1458  xmlt::unescape((yyvsp[-2].s)), xmlt::unescape((yyvsp[0].s)));
1459  free((yyvsp[-2].s)); free((yyvsp[0].s));}
1460 #line 1461 "xml_y.tab.cpp"
1461  break;
1462 
1463 
1464 #line 1465 "xml_y.tab.cpp"
1465 
1466  default: break;
1467  }
1468  /* User semantic actions sometimes alter yychar, and that requires
1469  that yytoken be updated with the new translation. We take the
1470  approach of translating immediately before every use of yytoken.
1471  One alternative is translating here after every semantic action,
1472  but that translation would be missed if the semantic action invokes
1473  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1474  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1475  incorrect destructor might then be invoked immediately. In the
1476  case of YYERROR or YYBACKUP, subsequent parser actions might lead
1477  to an incorrect destructor call or verbose syntax error message
1478  before the lookahead is translated. */
1479  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1480 
1481  YYPOPSTACK (yylen);
1482  yylen = 0;
1483  YY_STACK_PRINT (yyss, yyssp);
1484 
1485  *++yyvsp = yyval;
1486 
1487  /* Now 'shift' the result of the reduction. Determine what state
1488  that goes to, based on the state we popped back to and the rule
1489  number reduced by. */
1490  {
1491  const int yylhs = yyr1[yyn] - YYNTOKENS;
1492  const int yyi = yypgoto[yylhs] + *yyssp;
1493  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1494  ? yytable[yyi]
1495  : yydefgoto[yylhs]);
1496  }
1497 
1498  goto yynewstate;
1499 
1500 
1501 /*--------------------------------------.
1502 | yyerrlab -- here on detecting error. |
1503 `--------------------------------------*/
1504 yyerrlab:
1505  /* Make sure we have latest lookahead translation. See comments at
1506  user semantic actions for why this is necessary. */
1507  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1508 
1509  /* If not already recovering from an error, report this error. */
1510  if (!yyerrstatus)
1511  {
1512  ++yynerrs;
1513 #if ! YYERROR_VERBOSE
1514  yyerror (YY_("syntax error"));
1515 #else
1516 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1517  yyssp, yytoken)
1518  {
1519  char const *yymsgp = YY_("syntax error");
1520  int yysyntax_error_status;
1521  yysyntax_error_status = YYSYNTAX_ERROR;
1522  if (yysyntax_error_status == 0)
1523  yymsgp = yymsg;
1524  else if (yysyntax_error_status == 1)
1525  {
1526  if (yymsg != yymsgbuf)
1527  YYSTACK_FREE (yymsg);
1528  yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
1529  if (!yymsg)
1530  {
1531  yymsg = yymsgbuf;
1532  yymsg_alloc = sizeof yymsgbuf;
1533  yysyntax_error_status = 2;
1534  }
1535  else
1536  {
1537  yysyntax_error_status = YYSYNTAX_ERROR;
1538  yymsgp = yymsg;
1539  }
1540  }
1541  yyerror (yymsgp);
1542  if (yysyntax_error_status == 2)
1543  goto yyexhaustedlab;
1544  }
1545 # undef YYSYNTAX_ERROR
1546 #endif
1547  }
1548 
1549 
1550 
1551  if (yyerrstatus == 3)
1552  {
1553  /* If just tried and failed to reuse lookahead token after an
1554  error, discard it. */
1555 
1556  if (yychar <= YYEOF)
1557  {
1558  /* Return failure if at end of input. */
1559  if (yychar == YYEOF)
1560  YYABORT;
1561  }
1562  else
1563  {
1564  yydestruct ("Error: discarding",
1565  yytoken, &yylval);
1566  yychar = YYEMPTY;
1567  }
1568  }
1569 
1570  /* Else will try to reuse lookahead token after shifting the error
1571  token. */
1572  goto yyerrlab1;
1573 
1574 
1575 /*---------------------------------------------------.
1576 | yyerrorlab -- error raised explicitly by YYERROR. |
1577 `---------------------------------------------------*/
1578 yyerrorlab:
1579  /* Pacify compilers when the user code never invokes YYERROR and the
1580  label yyerrorlab therefore never appears in user code. */
1581  if (0)
1582  YYERROR;
1583 
1584  /* Do not reclaim the symbols of the rule whose action triggered
1585  this YYERROR. */
1586  YYPOPSTACK (yylen);
1587  yylen = 0;
1588  YY_STACK_PRINT (yyss, yyssp);
1589  yystate = *yyssp;
1590  goto yyerrlab1;
1591 
1592 
1593 /*-------------------------------------------------------------.
1594 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1595 `-------------------------------------------------------------*/
1596 yyerrlab1:
1597  yyerrstatus = 3; /* Each real token shifted decrements this. */
1598 
1599  for (;;)
1600  {
1601  yyn = yypact[yystate];
1602  if (!yypact_value_is_default (yyn))
1603  {
1604  yyn += YYTERROR;
1605  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1606  {
1607  yyn = yytable[yyn];
1608  if (0 < yyn)
1609  break;
1610  }
1611  }
1612 
1613  /* Pop the current state because it cannot handle the error token. */
1614  if (yyssp == yyss)
1615  YYABORT;
1616 
1617 
1618  yydestruct ("Error: popping",
1619  yystos[yystate], yyvsp);
1620  YYPOPSTACK (1);
1621  yystate = *yyssp;
1622  YY_STACK_PRINT (yyss, yyssp);
1623  }
1624 
1626  *++yyvsp = yylval;
1628 
1629 
1630  /* Shift the error token. */
1631  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1632 
1633  yystate = yyn;
1634  goto yynewstate;
1635 
1636 
1637 /*-------------------------------------.
1638 | yyacceptlab -- YYACCEPT comes here. |
1639 `-------------------------------------*/
1640 yyacceptlab:
1641  yyresult = 0;
1642  goto yyreturn;
1643 
1644 
1645 /*-----------------------------------.
1646 | yyabortlab -- YYABORT comes here. |
1647 `-----------------------------------*/
1648 yyabortlab:
1649  yyresult = 1;
1650  goto yyreturn;
1651 
1652 
1653 #if !defined yyoverflow || YYERROR_VERBOSE
1654 /*-------------------------------------------------.
1655 | yyexhaustedlab -- memory exhaustion comes here. |
1656 `-------------------------------------------------*/
1657 yyexhaustedlab:
1658  yyerror (YY_("memory exhausted"));
1659  yyresult = 2;
1660  /* Fall through. */
1661 #endif
1662 
1663 
1664 /*-----------------------------------------------------.
1665 | yyreturn -- parsing is finished, return the result. |
1666 `-----------------------------------------------------*/
1667 yyreturn:
1668  if (yychar != YYEMPTY)
1669  {
1670  /* Make sure we have latest lookahead translation. See comments at
1671  user semantic actions for why this is necessary. */
1672  yytoken = YYTRANSLATE (yychar);
1673  yydestruct ("Cleanup: discarding lookahead",
1674  yytoken, &yylval);
1675  }
1676  /* Do not reclaim the symbols of the rule whose action triggered
1677  this YYABORT or YYACCEPT. */
1678  YYPOPSTACK (yylen);
1679  YY_STACK_PRINT (yyss, yyssp);
1680  while (yyssp != yyss)
1681  {
1682  yydestruct ("Cleanup: popping",
1683  yystos[*yyssp], yyvsp);
1684  YYPOPSTACK (1);
1685  }
1686 #ifndef yyoverflow
1687  if (yyss != yyssa)
1688  YYSTACK_FREE (yyss);
1689 #endif
1690 #if YYERROR_VERBOSE
1691  if (yymsg != yymsgbuf)
1692  YYSTACK_FREE (yymsg);
1693 #endif
1694  return yyresult;
1695 }
yyxmlerror
int yyxmlerror(const std::string &error)
Definition: xml_y.tab.cpp:85
YYSTYPE::s
char * s
Definition: xml_y.tab.cpp:177
YYSIZE_T
#define YYSIZE_T
Definition: xml_y.tab.cpp:280
YYCASE_
#define YYCASE_(N, S)
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: xml_y.tab.cpp:1099
YYSIZEOF
#define YYSIZEOF(X)
Definition: xml_y.tab.cpp:290
YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: xml_y.tab.cpp:360
COMMENT
#define COMMENT
Definition: xml_y.tab.cpp:169
yytname
static const char *const yytname[]
Definition: xml_y.tab.cpp:565
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: xml_y.tab.cpp:462
malloc
void * malloc(unsigned)
yystrlen
static long yystrlen(const char *yystr)
Definition: xml_y.tab.cpp:870
YYEMPTY
#define YYEMPTY
Definition: xml_y.tab.cpp:680
YYUSE
#define YYUSE(E)
Definition: xml_y.tab.cpp:328
yycheck
static const yytype_int8 yycheck[]
Definition: xml_y.tab.cpp:643
YY_IGNORE_USELESS_CAST_END
#define YY_IGNORE_USELESS_CAST_END
Definition: xml_y.tab.cpp:361
yytable
static const yytype_int8 yytable[]
Definition: xml_y.tab.cpp:636
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: xml_y.tab.cpp:345
yytype_uint8
unsigned char yytype_uint8
Definition: xml_y.tab.cpp:239
xml_parsert::parse_tree
xml_parse_treet parse_tree
Definition: xml_parser.h:22
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
EQ
#define EQ
Definition: xml_y.tab.cpp:161
yytype_int16
short yytype_int16
Definition: xml_y.tab.cpp:230
yydefact
static const yytype_int8 yydefact[]
Definition: xml_y.tab.cpp:610
yyparse
#define yyparse
Definition: xml_y.tab.cpp:67
yyxmllex
int yyxmllex()
The main scanner function which does all the work.
Definition: xml_lex.yy.cpp:1042
yyalloc::yyss_alloc
yy_state_t yyss_alloc
Definition: ansi_c_y.tab.cpp:818
yy_state_t
yytype_int16 yy_state_t
Definition: ansi_c_y.tab.cpp:669
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: xml_y.tab.cpp:839
YYNTOKENS
#define YYNTOKENS
Definition: xml_y.tab.cpp:501
NAME
#define NAME
Definition: xml_y.tab.cpp:166
SLASH
#define SLASH
Definition: xml_y.tab.cpp:162
yysyntax_error
static int yysyntax_error(long *yymsg_alloc, char **yymsg, yy_state_t *yyssp, int yytoken)
Definition: xml_y.tab.cpp:960
xml_parsert::current
xmlt & current()
Definition: xml_parser.h:26
yytranslate
static const yytype_int8 yytranslate[]
Definition: xml_y.tab.cpp:520
xml_parser
xml_parsert xml_parser
Definition: xml_parser.cpp:15
yyerror
#define yyerror
Definition: xml_y.tab.cpp:69
YYSTYPE
Definition: xml_y.tab.cpp:174
ENCODING
#define ENCODING
Definition: xml_y.tab.cpp:165
yychar
#define yychar
Definition: xml_y.tab.cpp:73
yypgoto
static const yytype_int8 yypgoto[]
Definition: xml_y.tab.cpp:620
yylex
#define yylex
Definition: xml_y.tab.cpp:68
YY_CAST
#define YY_CAST(Type, Val)
Definition: xml_y.tab.cpp:99
yytokentype
yytokentype
Definition: ansi_c_y.tab.h:50
YYERROR
#define YYERROR
Definition: xml_y.tab.cpp:685
YYACCEPT
#define YYACCEPT
Definition: xml_y.tab.cpp:683
YYABORT
#define YYABORT
Definition: xml_y.tab.cpp:684
VERSION
#define VERSION
Definition: xml_y.tab.cpp:158
yynerrs
#define yynerrs
Definition: xml_y.tab.cpp:71
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: xml_y.tab.cpp:346
xmlt::name
std::string name
Definition: xml.h:30
YY_NULLPTR
#define YY_NULLPTR
Definition: xml_y.tab.cpp:111
STARTXMLDECL
#define STARTXMLDECL
Definition: xml_y.tab.cpp:157
yydebug
#define yydebug
Definition: xml_y.tab.cpp:70
free
void free(void *)
yy_state_fast_t
int yy_state_fast_t
Definition: xml_y.tab.cpp:296
yyxmllval
YYSTYPE yyxmllval
Definition: xml_y.tab.cpp:1118
yystos
static const yytype_int8 yystos[]
Definition: xml_y.tab.cpp:652
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: xml_y.tab.cpp:409
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: xml_y.tab.cpp:841
CLOSE
#define CLOSE
Definition: xml_y.tab.cpp:163
YYEOF
#define YYEOF
Definition: xml_y.tab.cpp:681
YYTERROR
#define YYTERROR
Definition: xml_y.tab.cpp:708
YYLAST
#define YYLAST
Definition: xml_y.tab.cpp:498
yypact_value_is_default
#define yypact_value_is_default(Yyn)
Definition: xml_y.tab.cpp:588
YYFINAL
#define YYFINAL
Definition: xml_y.tab.cpp:496
YY_
#define YY_(Msgid)
Definition: xml_y.tab.cpp:306
yytype_int8
signed char yytype_int8
Definition: xml_y.tab.cpp:222
yyalloc::yyvs_alloc
unsigned yyvs_alloc
Definition: ansi_c_y.tab.cpp:819
yytype_uint16
unsigned short yytype_uint16
Definition: xml_y.tab.cpp:250
parsert::parse_error
void parse_error(const std::string &message, const std::string &before)
Definition: parser.cpp:30
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: xml_y.tab.cpp:451
yy_state_t
yytype_int8 yy_state_t
Definition: xml_y.tab.cpp:293
xml_parse_treet::xml
xmlt xml
Definition: xml_parse_tree.h:18
START
#define START
Definition: xml_y.tab.cpp:170
ENDPI
#define ENDPI
Definition: xml_y.tab.cpp:160
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: xml_y.tab.cpp:406
xml_parsert::new_level
void new_level()
Definition: xml_parser.h:36
yylval
#define yylval
Definition: xml_y.tab.cpp:72
yytype_int8
signed char yytype_int8
Definition: ansi_c_y.tab.cpp:598
YY_ASSERT
#define YY_ASSERT(E)
Definition: xml_y.tab.cpp:365
xmlt::set_attribute
void set_attribute(const std::string &attribute, unsigned value)
Definition: xml.cpp:175
STARTPI
#define STARTPI
Definition: xml_y.tab.cpp:159
yyxmltext
char * yyxmltext
Definition: xml_lex.yy.cpp:816
yyxmlparse
int yyxmlparse(void)
Definition: xml_y.tab.cpp:1128
YYDPRINTF
#define YYDPRINTF(Args)
Definition: xml_y.tab.cpp:838
DATA
#define DATA
Definition: xml_y.tab.cpp:168
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: xml_y.tab.cpp:840
xml_parsert::stack
std::list< xmlt * > stack
Definition: xml_parser.h:24
yyalloc
Definition: ansi_c_y.tab.cpp:816
YYPOPSTACK
#define YYPOPSTACK(N)
YYNSTATES
#define YYNSTATES
Definition: xml_y.tab.cpp:507
yytable_value_is_error
#define yytable_value_is_error(Yyn)
Definition: xml_y.tab.cpp:593
yypact
static const yytype_int8 yypact[]
Definition: xml_y.tab.cpp:598
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: xml_y.tab.cpp:515
YYMAXDEPTH
#define YYMAXDEPTH
Definition: xml_y.tab.cpp:858
yydefgoto
static const yytype_int8 yydefgoto[]
Definition: xml_y.tab.cpp:627
xmlt::data
std::string data
Definition: xml.h:30
YYSTACK_FREE
#define YYSTACK_FREE
Definition: xml_y.tab.cpp:407
yyr1
static const yytype_int8 yyr1[]
Definition: xml_y.tab.cpp:662
YYINITDEPTH
#define YYINITDEPTH
Definition: xml_y.tab.cpp:847
yystpcpy
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: xml_y.tab.cpp:887
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: xml_y.tab.cpp:266
xmlt::unescape
static std::string unescape(const std::string &s)
takes a string and unescapes any xml style escaped symbols
Definition: xml.cpp:214
yytnamerr
static long yytnamerr(char *yyres, const char *yystr)
Definition: xml_y.tab.cpp:909
END
#define END
Definition: xml_y.tab.cpp:164
xml_parser.h
yytype_int16
short yytype_int16
Definition: ansi_c_y.tab.cpp:606
yy_state_fast_t
int yy_state_fast_t
Definition: ansi_c_y.tab.cpp:672
yyr2
static const yytype_int8 yyr2[]
Definition: xml_y.tab.cpp:670
VALUE
#define VALUE
Definition: xml_y.tab.cpp:167