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