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