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