ReactOS  0.4.14-dev-77-gd9e7c48
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 parser_parse
64 #define yylex parser_lex
65 #define yyerror parser_error
66 #define yydebug parser_debug
67 #define yynerrs parser_nerrs
68 
69 
70 /* Copy the first part of user declarations. */
71 #line 19 "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 static int parser_error(parser_ctx_t*,const char*);
83 static void set_error(parser_ctx_t*,UINT);
84 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR);
87 
88 typedef struct _statement_list_t {
92 
95 
96 typedef struct _property_list_t {
100 
105 
106 typedef struct _element_list_t {
110 
113 
114 typedef struct _argument_list_t {
118 
121 
122 typedef struct _case_list_t {
125 } case_list_t;
126 
132 
133 typedef struct _variable_list_t {
137 
141 
142 static void *new_statement(parser_ctx_t*,statement_type_t,size_t);
159 
163 };
164 
167 
168 typedef struct _parameter_list_t {
172 
175 
176 static void *new_expression(parser_ctx_t *ctx,expression_type_t,size_t);
178  source_elements_t*,const WCHAR*,const WCHAR*,DWORD);
189 
192 
193 
194 #line 195 "parser.tab.c" /* yacc.c:339 */
195 
196 # ifndef YY_NULL
197 # if defined __cplusplus && 201103L <= __cplusplus
198 # define YY_NULL nullptr
199 # else
200 # define YY_NULL 0
201 # endif
202 # endif
203 
204 /* Enabling verbose error messages. */
205 #ifdef YYERROR_VERBOSE
206 # undef YYERROR_VERBOSE
207 # define YYERROR_VERBOSE 1
208 #else
209 # define YYERROR_VERBOSE 0
210 #endif
211 
212 /* In a future release of Bison, this section will be replaced
213  by #include "parser.tab.h". */
214 #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
215 # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
216 /* Debug traces. */
217 #ifndef YYDEBUG
218 # define YYDEBUG 0
219 #endif
220 #if YYDEBUG
221 extern int parser_debug;
222 #endif
223 
224 /* Token type. */
225 #ifndef YYTOKENTYPE
226 # define YYTOKENTYPE
228  {
229  kBREAK = 258,
230  kCASE = 259,
231  kCATCH = 260,
232  kCONTINUE = 261,
233  kDEFAULT = 262,
234  kDELETE = 263,
235  kDO = 264,
236  kELSE = 265,
237  kFUNCTION = 266,
238  kIF = 267,
239  kFINALLY = 268,
240  kFOR = 269,
241  kGET = 270,
242  kIN = 271,
243  kSET = 272,
244  kINSTANCEOF = 273,
245  kNEW = 274,
246  kNULL = 275,
247  kRETURN = 276,
248  kSWITCH = 277,
249  kTHIS = 278,
250  kTHROW = 279,
251  kTRUE = 280,
252  kFALSE = 281,
253  kTRY = 282,
254  kTYPEOF = 283,
255  kVAR = 284,
256  kVOID = 285,
257  kWHILE = 286,
258  kWITH = 287,
259  tANDAND = 288,
260  tOROR = 289,
261  tINC = 290,
262  tDEC = 291,
264  kDIVEQ = 293,
265  kDCOL = 294,
266  tIdentifier = 295,
267  tAssignOper = 296,
268  tEqOper = 297,
269  tShiftOper = 298,
270  tRelOper = 299,
274  tEOF = 303,
276  };
277 #endif
278 
279 /* Value type. */
280 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
281 typedef union YYSTYPE YYSTYPE;
282 union YYSTYPE
283 {
284 #line 147 "parser.y" /* yacc.c:355 */
285 
286  int ival;
287  const WCHAR *srcptr;
305 
306 #line 307 "parser.tab.c" /* yacc.c:355 */
307 };
308 # define YYSTYPE_IS_TRIVIAL 1
309 # define YYSTYPE_IS_DECLARED 1
310 #endif
311 
312 
313 
314 int parser_parse (parser_ctx_t *ctx);
315 
316 #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED */
317 
318 /* Copy the second part of user declarations. */
319 
320 #line 321 "parser.tab.c" /* yacc.c:358 */
321 
322 #ifdef short
323 # undef short
324 #endif
325 
326 #ifdef YYTYPE_UINT8
327 typedef YYTYPE_UINT8 yytype_uint8;
328 #else
329 typedef unsigned char yytype_uint8;
330 #endif
331 
332 #ifdef YYTYPE_INT8
333 typedef YYTYPE_INT8 yytype_int8;
334 #else
335 typedef signed char yytype_int8;
336 #endif
337 
338 #ifdef YYTYPE_UINT16
339 typedef YYTYPE_UINT16 yytype_uint16;
340 #else
341 typedef unsigned short int yytype_uint16;
342 #endif
343 
344 #ifdef YYTYPE_INT16
345 typedef YYTYPE_INT16 yytype_int16;
346 #else
347 typedef short int yytype_int16;
348 #endif
349 
350 #ifndef YYSIZE_T
351 # ifdef __SIZE_TYPE__
352 # define YYSIZE_T __SIZE_TYPE__
353 # elif defined size_t
354 # define YYSIZE_T size_t
355 # elif ! defined YYSIZE_T
356 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
357 # define YYSIZE_T size_t
358 # else
359 # define YYSIZE_T unsigned int
360 # endif
361 #endif
362 
363 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
364 
365 #ifndef YY_
366 # if defined YYENABLE_NLS && YYENABLE_NLS
367 # if ENABLE_NLS
368 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
369 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
370 # endif
371 # endif
372 # ifndef YY_
373 # define YY_(Msgid) Msgid
374 # endif
375 #endif
376 
377 #ifndef __attribute__
378 /* This feature is available in gcc versions 2.5 and later. */
379 # if (! defined __GNUC__ || __GNUC__ < 2 \
380  || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
381 # define __attribute__(Spec) /* empty */
382 # endif
383 #endif
384 
385 /* Suppress unused-variable warnings by "using" E. */
386 #if ! defined lint || defined __GNUC__
387 # define YYUSE(E) ((void) (E))
388 #else
389 # define YYUSE(E) /* empty */
390 #endif
391 
392 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
393 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
394 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
395  _Pragma ("GCC diagnostic push") \
396  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
397  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
398 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
399  _Pragma ("GCC diagnostic pop")
400 #else
401 # define YY_INITIAL_VALUE(Value) Value
402 #endif
403 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
404 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
405 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
406 #endif
407 #ifndef YY_INITIAL_VALUE
408 # define YY_INITIAL_VALUE(Value) /* Nothing. */
409 #endif
410 
411 
412 #if ! defined yyoverflow || YYERROR_VERBOSE
413 
414 /* The parser invokes alloca or malloc; define the necessary symbols. */
415 
416 # ifdef YYSTACK_USE_ALLOCA
417 # if YYSTACK_USE_ALLOCA
418 # ifdef __GNUC__
419 # define YYSTACK_ALLOC __builtin_alloca
420 # elif defined __BUILTIN_VA_ARG_INCR
421 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
422 # elif defined _AIX
423 # define YYSTACK_ALLOC __alloca
424 # elif defined _MSC_VER
425 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
426 # define alloca _alloca
427 # else
428 # define YYSTACK_ALLOC alloca
429 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
430 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
431  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
432 # ifndef EXIT_SUCCESS
433 # define EXIT_SUCCESS 0
434 # endif
435 # endif
436 # endif
437 # endif
438 # endif
439 
440 # ifdef YYSTACK_ALLOC
441  /* Pacify GCC's 'empty if-body' warning. */
442 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
443 # ifndef YYSTACK_ALLOC_MAXIMUM
444  /* The OS might guarantee only one guard page at the bottom of the stack,
445  and a page size can be as small as 4096 bytes. So we cannot safely
446  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
447  to allow for a few compiler-allocated temporary stack slots. */
448 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
449 # endif
450 # else
451 # define YYSTACK_ALLOC YYMALLOC
452 # define YYSTACK_FREE YYFREE
453 # ifndef YYSTACK_ALLOC_MAXIMUM
454 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
455 # endif
456 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
457  && ! ((defined YYMALLOC || defined malloc) \
458  && (defined YYFREE || defined free)))
459 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
460 # ifndef EXIT_SUCCESS
461 # define EXIT_SUCCESS 0
462 # endif
463 # endif
464 # ifndef YYMALLOC
465 # define YYMALLOC malloc
466 # if ! defined malloc && ! defined EXIT_SUCCESS
467 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
468 # endif
469 # endif
470 # ifndef YYFREE
471 # define YYFREE free
472 # if ! defined free && ! defined EXIT_SUCCESS
473 void free (void *); /* INFRINGES ON USER NAME SPACE */
474 # endif
475 # endif
476 # endif
477 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
478 
479 
480 #if (! defined yyoverflow \
481  && (! defined __cplusplus \
482  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
483 
484 /* A type that is properly aligned for any stack member. */
485 union yyalloc
486 {
489 };
490 
491 /* The size of the maximum gap between one aligned stack and the next. */
492 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
493 
494 /* The size of an array large to enough to hold all stacks, each with
495  N elements. */
496 # define YYSTACK_BYTES(N) \
497  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
498  + YYSTACK_GAP_MAXIMUM)
499 
500 # define YYCOPY_NEEDED 1
501 
502 /* Relocate STACK from its old location to the new one. The
503  local variables YYSIZE and YYSTACKSIZE give the old and new number of
504  elements in the stack, and YYPTR gives the new location of the
505  stack. Advance YYPTR to a properly aligned location for the next
506  stack. */
507 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
508  do \
509  { \
510  YYSIZE_T yynewbytes; \
511  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
512  Stack = &yyptr->Stack_alloc; \
513  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
514  yyptr += yynewbytes / sizeof (*yyptr); \
515  } \
516  while (0)
517 
518 #endif
519 
520 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
521 /* Copy COUNT objects from SRC to DST. The source and destination do
522  not overlap. */
523 # ifndef YYCOPY
524 # if defined __GNUC__ && 1 < __GNUC__
525 # define YYCOPY(Dst, Src, Count) \
526  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
527 # else
528 # define YYCOPY(Dst, Src, Count) \
529  do \
530  { \
531  YYSIZE_T yyi; \
532  for (yyi = 0; yyi < (Count); yyi++) \
533  (Dst)[yyi] = (Src)[yyi]; \
534  } \
535  while (0)
536 # endif
537 # endif
538 #endif /* !YYCOPY_NEEDED */
539 
540 /* YYFINAL -- State number of the termination state. */
541 #define YYFINAL 3
542 /* YYLAST -- Last index in YYTABLE. */
543 #define YYLAST 1393
544 
545 /* YYNTOKENS -- Number of terminals. */
546 #define YYNTOKENS 72
547 /* YYNNTS -- Number of nonterminals. */
548 #define YYNNTS 99
549 /* YYNRULES -- Number of rules. */
550 #define YYNRULES 254
551 /* YYNSTATES -- Number of states. */
552 #define YYNSTATES 454
553 
554 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
555  by yylex, with out-of-bounds checking. */
556 #define YYUNDEFTOK 2
557 #define YYMAXUTOK 304
558 
559 #define YYTRANSLATE(YYX) \
560  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
561 
562 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
563  as returned by yylex, without out-of-bounds checking. */
564 static const yytype_uint8 yytranslate[] =
565 {
566  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
568  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
569  2, 2, 2, 66, 2, 2, 2, 64, 59, 2,
570  70, 71, 62, 60, 52, 61, 69, 63, 2, 2,
571  2, 2, 2, 2, 2, 2, 2, 2, 55, 54,
572  2, 53, 2, 56, 2, 2, 2, 2, 2, 2,
573  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575  2, 67, 2, 68, 58, 2, 2, 2, 2, 2,
576  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578  2, 2, 2, 51, 57, 40, 65, 2, 2, 2,
579  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
592  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
593  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
594  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
595  35, 36, 37, 38, 39, 41, 42, 43, 44, 45,
596  46, 47, 48, 49, 50
597 };
598 
599 #if YYDEBUG
600  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
601 static const yytype_uint16 yyrline[] =
602 {
603  0, 258, 258, 262, 263, 267, 268, 273, 275, 277,
604  281, 285, 289, 290, 295, 296, 300, 301, 302, 303,
605  304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
606  314, 318, 319, 324, 325, 329, 330, 334, 339, 340,
607  345, 347, 352, 357, 362, 363, 367, 372, 373, 377,
608  382, 386, 391, 393, 398, 400, 403, 405, 402, 409,
609  411, 408, 414, 416, 421, 426, 431, 436, 441, 446,
610  451, 453, 458, 459, 463, 464, 469, 474, 479, 484,
611  485, 486, 491, 496, 500, 501, 504, 505, 509, 510,
612  515, 516, 520, 522, 526, 527, 531, 532, 534, 539,
613  541, 543, 548, 549, 554, 556, 561, 562, 567, 569,
614  574, 575, 580, 582, 587, 588, 593, 595, 600, 601,
615  606, 608, 613, 614, 619, 621, 626, 627, 632, 633,
616  638, 639, 641, 643, 648, 649, 651, 656, 657, 662,
617  664, 666, 671, 672, 674, 676, 681, 682, 684, 685,
618  687, 688, 689, 690, 691, 692, 696, 698, 700, 706,
619  707, 711, 712, 716, 717, 718, 720, 722, 727, 729,
620  731, 733, 738, 739, 743, 744, 749, 750, 751, 752,
621  753, 754, 758, 759, 760, 761, 766, 768, 773, 774,
622  778, 779, 783, 784, 786, 797, 798, 803, 805, 807,
623  811, 816, 817, 818, 822, 823, 827, 828, 839, 840,
624  841, 842, 843, 844, 845, 846, 847, 848, 849, 850,
625  851, 852, 853, 854, 855, 856, 857, 858, 859, 860,
626  861, 862, 863, 864, 865, 866, 867, 868, 872, 873,
627  874, 875, 876, 878, 883, 884, 885, 888, 889, 892,
628  893, 896, 897, 900, 901
629 };
630 #endif
631 
632 #if YYDEBUG || YYERROR_VERBOSE || 0
633 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
634  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
635 static const char *const yytname[] =
636 {
637  "$end", "error", "$undefined", "kBREAK", "kCASE", "kCATCH", "kCONTINUE",
638  "kDEFAULT", "kDELETE", "kDO", "kELSE", "kFUNCTION", "kIF", "kFINALLY",
639  "kFOR", "kGET", "kIN", "kSET", "kINSTANCEOF", "kNEW", "kNULL", "kRETURN",
640  "kSWITCH", "kTHIS", "kTHROW", "kTRUE", "kFALSE", "kTRY", "kTYPEOF",
641  "kVAR", "kVOID", "kWHILE", "kWITH", "tANDAND", "tOROR", "tINC", "tDEC",
642  "tHTMLCOMMENT", "kDIVEQ", "kDCOL", "'}'", "tIdentifier", "tAssignOper",
643  "tEqOper", "tShiftOper", "tRelOper", "tNumericLiteral",
644  "tBooleanLiteral", "tStringLiteral", "tEOF", "LOWER_THAN_ELSE", "'{'",
645  "','", "'='", "';'", "':'", "'?'", "'|'", "'^'", "'&'", "'+'", "'-'",
646  "'*'", "'/'", "'%'", "'~'", "'!'", "'['", "']'", "'.'", "'('", "')'",
647  "$accept", "Program", "HtmlComment", "SourceElements",
648  "FunctionExpression", "KFunction", "FunctionBody", "FormalParameterList",
649  "FormalParameterList_opt", "Statement", "StatementList",
650  "StatementList_opt", "Block", "VariableStatement",
651  "VariableDeclarationList", "VariableDeclarationListNoIn",
652  "VariableDeclaration", "VariableDeclarationNoIn", "Initialiser_opt",
653  "Initialiser", "InitialiserNoIn_opt", "InitialiserNoIn",
654  "EmptyStatement", "ExpressionStatement", "IfStatement",
655  "IterationStatement", "$@1", "$@2", "$@3", "$@4", "ContinueStatement",
656  "BreakStatement", "ReturnStatement", "WithStatement",
657  "LabelledStatement", "SwitchStatement", "CaseBlock", "CaseClausules_opt",
658  "CaseClausules", "CaseClausule", "DefaultClausule", "ThrowStatement",
659  "TryStatement", "Catch", "Finally", "Expression_opt", "Expression_err",
660  "Expression", "ExpressionNoIn_opt", "ExpressionNoIn", "AssignOper",
661  "AssignmentExpression", "AssignmentExpressionNoIn",
662  "ConditionalExpression", "ConditionalExpressionNoIn",
663  "LogicalORExpression", "LogicalORExpressionNoIn", "LogicalANDExpression",
664  "LogicalANDExpressionNoIn", "BitwiseORExpression",
665  "BitwiseORExpressionNoIn", "BitwiseXORExpression",
666  "BitwiseXORExpressionNoIn", "BitwiseANDExpression",
667  "BitwiseANDExpressionNoIn", "EqualityExpression",
668  "EqualityExpressionNoIn", "RelationalExpression",
669  "RelationalExpressionNoIn", "ShiftExpression", "AdditiveExpression",
670  "MultiplicativeExpression", "UnaryExpression", "PostfixExpression",
671  "LeftHandSideExpression", "NewExpression", "MemberExpression",
672  "CallExpression", "Arguments", "ArgumentList", "PrimaryExpression",
673  "ArrayLiteral", "ElementList", "Elision", "Elision_opt", "ObjectLiteral",
674  "PropertyNameAndValueList", "PropertyDefinition", "GetterSetterMethod",
675  "PropertyName", "Identifier_opt", "IdentifierName",
676  "ReservedAsIdentifier", "Literal", "BooleanLiteral", "semicolon_opt",
677  "left_bracket", "right_bracket", "semicolon", YY_NULL
678 };
679 #endif
680 
681 # ifdef YYPRINT
682 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
683  (internal) symbol number NUM (which must be that of a token). */
684 static const yytype_uint16 yytoknum[] =
685 {
686  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
687  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
688  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
689  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
690  125, 295, 296, 297, 298, 299, 300, 301, 302, 303,
691  304, 123, 44, 61, 59, 58, 63, 124, 94, 38,
692  43, 45, 42, 47, 37, 126, 33, 91, 93, 46,
693  40, 41
694 };
695 # endif
696 
697 #define YYPACT_NINF -361
698 
699 #define yypact_value_is_default(Yystate) \
700  (!!((Yystate) == (-361)))
701 
702 #define YYTABLE_NINF -238
703 
704 #define yytable_value_is_error(Yytable_value) \
705  0
706 
707  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
708  STATE-NUM. */
709 static const yytype_int16 yypact[] =
710 {
711  -361, 82, 649, -361, -15, -15, 1146, 844, -361, 60,
712  60, 236, -361, 1146, 60, -361, 1146, -361, -361, 14,
713  1146, 73, 1146, 60, 60, 1146, 1146, -361, -361, 72,
714  -361, -361, -361, 584, -361, 1146, 1146, -361, 1146, 1146,
715  94, 1146, 88, 472, 36, -361, -361, -361, -361, -361,
716  -361, -361, -361, -361, -361, -361, -361, -361, -361, -361,
717  51, -361, -361, 86, 123, 124, 130, 145, 163, 22,
718  183, -5, 182, -361, -361, 155, -361, 219, 224, -361,
719  -361, -361, -361, -361, -361, 31, 31, -361, 1214, -361,
720  -361, 230, 217, -361, -361, 434, 965, -361, 219, 31,
721  205, 1146, 51, 714, 198, -361, 197, 59, -361, -361,
722  434, 1146, -361, -361, 844, 9, -361, -361, 114, -361,
723  1146, 844, -361, 212, 38, -361, 79, 1306, -361, 1306,
724  -361, 236, 221, 1025, 83, 223, 1146, 226, 246, 14,
725  1146, 73, 1146, 95, 103, 517, 72, 249, 250, -361,
726  779, 149, -361, 252, -361, -361, -361, -361, -361, -361,
727  -361, -361, 102, 107, 1146, 17, -361, 93, 244, -361,
728  1146, -361, -361, 1146, 1146, 1146, 1146, 1146, 1146, 1146,
729  1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, -361,
730  -361, -361, -361, 1146, 1146, 1146, 1352, 904, -361, 1146,
731  1352, -361, -361, -361, -361, -361, -361, -361, -361, -361,
732  -361, -361, -361, -361, -361, -361, -361, -361, -361, -361,
733  -361, -361, -361, -361, -361, -361, -361, -361, -361, 60,
734  -361, 24, 205, 251, -361, 256, -361, -361, 111, 276,
735  253, 255, 258, 272, 98, 183, 237, -361, -361, 16,
736  -361, -361, 60, 14, 305, -361, 1146, -361, -361, 73,
737  -361, 24, 16, -361, -361, -361, 60, 60, -361, -361,
738  -361, 1260, 1146, 267, -361, -361, -361, -361, -361, 279,
739  244, -361, 269, 24, -361, 123, 270, 124, 130, 145,
740  163, 22, 183, 183, 183, -5, 182, 182, -361, -361,
741  -361, -361, -361, 108, -361, -361, -361, 26, 116, -361,
742  434, -361, -361, 844, 271, 274, 306, 48, 1146, 1146,
743  1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 434, 1146,
744  1146, 277, 286, -361, -361, -361, -361, 844, 844, -361,
745  244, -361, -361, -361, -361, 278, 1085, 60, 24, 288,
746  280, 1146, -361, 1146, -361, -361, 24, 322, 1146, -361,
747  -361, 251, 48, 434, -361, -361, 1146, -361, 216, 276,
748  282, 253, 255, 258, 272, 98, 183, 183, 24, -361,
749  -361, 329, -361, 24, -361, -361, 24, -361, -361, 244,
750  283, -361, -361, -361, -361, 31, 844, -361, -361, 1146,
751  24, -361, 1146, 844, 1146, 46, 329, -361, 14, 289,
752  24, -361, 844, 301, -361, -361, -361, 844, 48, -361,
753  -361, 186, 287, -361, 329, -361, -361, -361, 292, 309,
754  -361, 48, -361, 1146, 844, 844, 310, 312, -361, -361,
755  1146, 24, 844, -361, -361, -361, -361, 313, 24, 844,
756  -361, 844, -361, -361
757 };
758 
759  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
760  Performed when YYTABLE does not specify something else to do. Zero
761  means the default is an error. */
762 static const yytype_uint8 yydefact[] =
763 {
764  5, 0, 4, 1, 204, 204, 0, 0, 10, 0,
765  0, 0, 238, 84, 0, 176, 0, 244, 245, 0,
766  0, 0, 0, 0, 0, 0, 0, 3, 243, 177,
767  240, 246, 241, 0, 50, 0, 0, 242, 0, 0,
768  190, 0, 0, 19, 0, 6, 16, 17, 18, 20,
769  21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
770  0, 88, 96, 102, 106, 110, 114, 118, 122, 126,
771  130, 137, 139, 142, 146, 156, 159, 161, 160, 163,
772  179, 180, 178, 239, 205, 0, 0, 177, 0, 164,
773  147, 156, 0, 250, 249, 0, 90, 162, 161, 0,
774  85, 0, 0, 0, 0, 149, 44, 0, 38, 148,
775  0, 0, 150, 151, 0, 204, 209, 210, 204, 212,
776  213, 214, 215, 10, 0, 217, 0, 220, 222, 227,
777  223, 224, 238, 84, 0, 176, 230, 244, 245, 232,
778  233, 234, 235, 0, 0, 36, 177, 240, 241, 31,
779  0, 0, 195, 0, 201, 207, 152, 153, 154, 155,
780  188, 182, 0, 191, 0, 0, 2, 0, 14, 248,
781  0, 247, 51, 0, 0, 0, 0, 0, 0, 0,
782  0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
783  158, 95, 94, 0, 0, 0, 0, 0, 168, 0,
784  0, 169, 65, 64, 208, 211, 213, 214, 219, 221,
785  218, 224, 225, 226, 228, 229, 230, 231, 216, 232,
786  233, 234, 235, 236, 237, 192, 206, 203, 202, 0,
787  87, 0, 86, 0, 56, 91, 92, 99, 104, 108,
788  112, 116, 120, 124, 128, 134, 156, 167, 66, 0,
789  78, 36, 0, 0, 79, 80, 0, 42, 45, 0,
790  37, 0, 0, 68, 220, 227, 0, 0, 35, 32,
791  193, 0, 0, 190, 184, 189, 183, 186, 181, 0,
792  14, 12, 15, 0, 89, 107, 0, 111, 115, 119,
793  123, 127, 133, 132, 131, 138, 140, 141, 143, 144,
794  145, 97, 98, 0, 166, 172, 174, 0, 0, 171,
795  0, 252, 251, 0, 47, 59, 40, 0, 0, 0,
796  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
797  0, 0, 0, 83, 81, 46, 39, 0, 0, 198,
798  14, 199, 194, 196, 197, 191, 0, 0, 0, 0,
799  0, 0, 165, 0, 173, 170, 0, 53, 0, 43,
800  48, 0, 0, 0, 254, 253, 84, 93, 156, 109,
801  0, 113, 117, 121, 125, 129, 136, 135, 0, 100,
802  101, 72, 69, 0, 55, 67, 0, 185, 187, 14,
803  0, 13, 5, 103, 175, 0, 0, 49, 41, 84,
804  0, 57, 0, 0, 0, 0, 73, 74, 0, 0,
805  0, 5, 11, 0, 54, 52, 60, 0, 0, 105,
806  62, 0, 0, 70, 72, 75, 82, 5, 0, 0,
807  7, 0, 63, 84, 33, 33, 0, 0, 5, 8,
808  84, 0, 34, 76, 77, 71, 200, 0, 0, 0,
809  9, 0, 58, 61
810 };
811 
812  /* YYPGOTO[NTERM-NUM]. */
813 static const yytype_int16 yypgoto[] =
814 {
815  -361, -361, -361, 345, -2, -361, -357, -361, -261, 1,
816  -164, -70, -10, -361, -361, -361, 109, 8, -361, -361,
817  -361, -361, -361, -361, -361, -361, -361, -361, -361, -361,
818  -361, -361, -361, -361, -361, -361, -361, -54, -361, -35,
819  -361, -361, -361, -361, 118, -333, -68, -12, -361, -361,
820  298, -146, -284, -361, -361, -361, -361, 201, 56, 202,
821  55, 203, 58, 204, 61, 200, 62, 206, 57, -90,
822  207, 112, 160, -361, 37, 4, 5, -361, 74, -361,
823  -361, -361, -361, 110, 115, -361, -361, 120, 122, 65,
824  7, -22, -361, -361, -361, -72, -3, -239, -360
825 };
826 
827  /* YYDEFGOTO[NTERM-NUM]. */
828 static const yytype_int16 yydefgoto[] =
829 {
830  -1, 1, 42, 412, 89, 44, 413, 282, 283, 149,
831  150, 443, 46, 47, 107, 315, 108, 316, 257, 258,
832  359, 360, 48, 49, 50, 51, 317, 418, 362, 431,
833  52, 53, 54, 55, 56, 57, 382, 405, 406, 407,
834  424, 58, 59, 254, 255, 99, 231, 60, 234, 235,
835  330, 61, 236, 62, 237, 63, 238, 64, 239, 65,
836  240, 66, 241, 67, 242, 68, 243, 69, 244, 70,
837  71, 72, 73, 74, 75, 76, 77, 78, 198, 307,
838  79, 80, 162, 163, 164, 81, 151, 152, 339, 153,
839  85, 154, 155, 82, 83, 172, 95, 313, 366
840 };
841 
842  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
843  positive, shift that token. If negative, reduce the rule whose
844  number is the opposite. If YYTABLE_NINF, syntax error. */
845 static const yytype_int16 yytable[] =
846 {
847  43, 100, 399, 45, 102, 43, 245, 96, 92, 104,
848  331, 101, 86, 202, 203, 97, 98, 311, 277, 348,
849  110, 111, 337, 338, 284, 311, 84, 248, 286, 165,
850  250, 43, 169, 401, 367, 260, 370, 93, 180, 93,
851  181, 168, 261, 91, 350, 379, 380, 301, 302, 364,
852  84, 306, 169, 422, 429, 184, 185, 91, 433, 91,
853  169, 93, 91, 91, -208, 103, 416, 182, 170, 170,
854  437, 440, 91, 91, 397, 91, 91, 167, 353, 386,
855  93, 447, 3, 232, 93, 171, 423, 312, 278, 249,
856  292, 293, 294, -221, 93, 312, 93, 354, 232, 262,
857  441, 43, 365, 170, 93, 171, 94, 448, 94, 390,
858  335, 259, 43, 171, 106, 263, 326, 395, 419, 43,
859  173, 100, 92, 96, 102, 86, 344, 114, 410, 104,
860  94, 101, 279, 246, -218, 97, 98, 166, -228, 403,
861  110, 111, 174, 327, 408, 319, 160, 409, 43, 94,
862  -236, 269, 201, 94, 273, 84, 175, 91, -237, 275,
863  170, 417, 161, 94, 280, 94, 90, 320, 170, -211,
864  274, 428, 247, 94, 304, 276, 352, 91, 309, 91,
865  105, 176, 109, 303, 355, 112, 113, 308, 177, 270,
866  189, 190, 266, 191, 267, 156, 157, 192, 158, 159,
867  388, 271, 449, 252, 178, 393, 179, 394, 193, 451,
868  91, 253, 91, 91, 91, 91, 91, 91, 91, 91,
869  91, 91, 91, 91, 91, 91, 310, 183, 245, 245,
870  245, 245, 245, 245, 245, 245, 376, 377, 170, 245,
871  245, 434, 356, 333, 186, 187, 188, 8, 229, 332,
872  256, 189, 190, 328, 191, 11, 12, 170, 192, 15,
873  378, 17, 18, 340, 340, 189, 190, -219, 245, 329,
874  442, 442, 189, 190, 28, 191, -225, 87, -229, 192,
875  90, -231, 30, 31, 32, 281, 195, 88, 196, 197,
876  329, 199, 314, 200, 197, 400, 296, 297, 232, 37,
877  105, -216, 109, 40, -203, -202, 41, 272, 318, 321,
878  322, 43, 245, 323, 357, 325, 232, 324, 253, 160,
879  347, 349, 363, 414, 358, 351, 361, 383, 381, 391,
880  275, 392, 396, 404, 411, 43, 43, 402, 384, 385,
881  427, 430, 435, 438, 389, 2, 298, 299, 300, 439,
882  445, 232, 446, 450, 100, 368, 91, 368, 91, 91,
883  91, 91, 91, 91, 91, 444, 368, 368, 336, 398,
884  436, 425, 334, 194, 285, 369, 371, 287, 290, 288,
885  372, 289, 375, 345, 373, 291, 374, 100, 346, 341,
886  295, 343, 421, 0, 43, 368, 0, 415, 426, 0,
887  0, 43, 0, 0, 420, 0, 0, 0, 0, 0,
888  43, 0, 0, 45, 0, 43, 0, 0, 432, 0,
889  0, 100, 0, 0, 0, 0, 0, 0, 100, 0,
890  0, 0, 43, 43, 0, 230, 0, 0, 0, 368,
891  43, 0, 6, 269, 0, 8, 0, 43, 0, 43,
892  452, 0, 453, 11, 12, 0, 0, 15, 0, 17,
893  18, 0, 20, 0, 22, 0, 0, 0, 0, 25,
894  26, 0, 28, -164, 0, 87, 0, 0, 0, 0,
895  30, 31, 32, 0, 0, 88, 0, 0, -164, 0,
896  -164, 0, 0, 0, 35, 36, 0, 37, 0, 38,
897  39, 40, 0, 0, 41, -164, -164, 0, 0, 0,
898  0, 0, 0, 0, -164, -164, -164, -164, -192, 0,
899  0, 0, 0, 0, -164, -164, 0, 0, -164, -164,
900  -164, -164, 0, -192, -164, -192, -164, 0, 0, 0,
901  0, -164, 0, 0, 0, 0, 0, 0, 0, 0,
902  -192, -192, 0, 0, 0, 0, 0, 0, 0, -192,
903  -192, -192, -192, 0, 0, 0, 0, 0, 0, -192,
904  -192, 0, 0, -192, -192, -192, -192, 0, 0, -192,
905  0, -192, 0, 0, 0, 0, -192, 115, 116, 117,
906  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
907  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
908  138, 139, 140, 141, 142, 143, 144, 0, 0, 25,
909  26, 0, 28, 0, 145, 146, 0, 0, 0, 0,
910  147, 31, 148, 0, 0, 33, 0, 0, 34, 0,
911  0, 0, 0, 0, 35, 36, 0, 37, 0, 38,
912  39, 40, 4, 0, 41, 5, 0, 6, 7, 0,
913  8, 9, 0, 10, 0, 0, 0, 0, 11, 12,
914  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
915  23, 24, 0, 0, 25, 26, 27, 28, 0, 0,
916  29, 0, 0, 0, 0, 30, 31, 32, 0, 0,
917  33, 0, 0, 34, 0, 0, 0, 0, 0, 35,
918  36, 0, 37, 0, 38, 39, 40, 4, 0, 41,
919  5, 0, 6, 7, 0, 8, 9, 0, 10, 0,
920  0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
921  18, 19, 20, 21, 22, 23, 24, 0, 0, 25,
922  26, 0, 28, 0, 251, 29, 0, 0, 0, 0,
923  30, 31, 32, 0, 0, 33, 0, 0, 34, 0,
924  0, 0, 0, 0, 35, 36, 0, 37, 0, 38,
925  39, 40, 4, 0, 41, 5, 0, 6, 7, 0,
926  8, 9, 0, 10, 0, 0, 0, 0, 11, 12,
927  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
928  23, 24, 0, 0, 25, 26, 0, 28, 0, 268,
929  29, 0, 0, 0, 0, 30, 31, 32, 0, 0,
930  33, 0, 0, 34, 0, 0, 0, 0, 0, 35,
931  36, 0, 37, 0, 38, 39, 40, 4, 0, 41,
932  5, 0, 6, 7, 0, 8, 9, 0, 10, 0,
933  0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
934  18, 19, 20, 21, 22, 23, 24, 0, 0, 25,
935  26, 0, 28, 0, 0, 29, 0, 0, 0, 0,
936  30, 31, 32, 0, 0, 33, 0, 0, 34, 0,
937  0, 0, 0, 0, 35, 36, 0, 37, 0, 38,
938  39, 40, 6, 0, 41, 8, 0, 0, 0, 0,
939  0, 0, 0, 11, 12, 0, 0, 15, 0, 17,
940  18, 0, 20, 0, 22, 0, 0, 0, 0, 25,
941  26, 0, 28, 0, 0, 87, 0, 0, 0, 0,
942  30, 31, 32, 0, 0, 88, 0, 0, 0, 0,
943  0, 0, 0, 0, 35, 36, 0, 37, 0, 38,
944  39, 40, 0, 6, 41, 305, 8, 0, 0, 0,
945  0, 0, 0, 0, 11, 12, 0, 0, 15, 0,
946  17, 18, 0, 20, 233, 22, 0, 0, 0, 0,
947  25, 26, 0, 28, 0, 0, 87, 0, 0, 0,
948  0, 30, 31, 32, 0, 0, 88, 0, 0, 0,
949  0, 0, 0, 0, 0, 35, 36, 0, 37, 0,
950  38, 39, 40, 6, 0, 41, 8, 0, 0, 0,
951  0, 0, 0, 0, 11, 12, 0, 0, 15, 0,
952  17, 18, 0, 20, 0, 22, 0, 0, 0, 0,
953  25, 26, 0, 28, 0, 0, 87, 0, 0, 0,
954  0, 30, 31, 32, 0, 0, 88, 0, 0, 0,
955  -226, 0, 0, 0, 0, 35, 36, 0, 37, 0,
956  38, 39, 40, 6, 0, 41, 8, 0, 0, 0,
957  0, 0, 0, 0, 11, 12, 0, 0, 15, 0,
958  17, 18, 0, 20, 0, 22, 0, 0, 0, 0,
959  25, 26, 0, 28, 0, 0, 87, 0, 0, 0,
960  0, 30, 31, 32, 0, 0, 88, 0, 0, 0,
961  0, 0, 0, 0, 0, 35, 36, 0, 37, 0,
962  38, 39, 40, 387, 6, 41, 0, 8, 0, 0,
963  0, 0, 0, 0, 0, 11, 12, 0, 0, 15,
964  0, 17, 18, 0, 20, 0, 22, 0, 0, 0,
965  0, 25, 26, 0, 28, 0, 0, 87, 0, 0,
966  0, 0, 30, 31, 32, 0, 0, 88, 0, 0,
967  0, 0, 0, 0, 0, 0, 35, 36, 0, 37,
968  0, 38, 39, 40, 0, 0, 41, 204, 116, 117,
969  205, 119, 206, 207, 122, 208, 209, 125, 210, 127,
970  128, 129, 130, 211, 212, 213, 214, 215, 216, 217,
971  218, 219, 220, 221, 222, 223, 224, 0, 0, 0,
972  0, 0, 0, 0, 225, 226, 0, 0, 0, 0,
973  227, 0, 228, 204, 116, 117, 205, 119, 206, 207,
974  122, 208, 209, 125, 210, 127, 128, 129, 130, 211,
975  212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
976  222, 223, 224, 0, 0, 0, 0, 0, 0, 0,
977  342, 226, 0, 0, 0, 0, 227, 0, 228, 204,
978  116, 117, 205, 119, 206, 207, 122, 208, 209, 125,
979  210, 264, 128, 265, 130, 211, 212, 213, 214, 215,
980  216, 217, 218, 219, 220, 221, 222, 223, 224, 0,
981  0, 0, 0, 0, 0, 0, 0, 226, 0, 0,
982  0, 0, 227, 0, 228, 204, 116, 117, 205, 119,
983  206, 207, 122, 208, 209, 125, 210, 264, 128, 265,
984  130, 211, 212, 213, 214, 215, 216, 217, 218, 219,
985  220, 221, 222, 223, 224, 0, 0, 0, 0, 0,
986  0, 0, 0, 226
987 };
988 
989 static const yytype_int16 yycheck[] =
990 {
991  2, 13, 362, 2, 16, 7, 96, 10, 7, 19,
992  249, 14, 5, 85, 86, 11, 11, 1, 164, 280,
993  23, 24, 261, 262, 170, 1, 41, 99, 174, 41,
994  102, 33, 1, 366, 318, 107, 320, 1, 16, 1,
995  18, 44, 110, 6, 283, 329, 330, 193, 194, 1,
996  41, 197, 1, 7, 411, 60, 61, 20, 418, 22,
997  1, 1, 25, 26, 55, 51, 399, 45, 52, 52,
998  427, 431, 35, 36, 358, 38, 39, 41, 52, 340,
999  1, 438, 0, 95, 1, 54, 40, 71, 71, 101,
1000  180, 181, 182, 55, 1, 71, 1, 71, 110, 111,
1001  433, 103, 54, 52, 1, 54, 70, 440, 70, 348,
1002  256, 52, 114, 54, 41, 114, 18, 356, 402, 121,
1003  34, 133, 121, 126, 136, 118, 272, 55, 389, 139,
1004  70, 134, 39, 96, 55, 131, 131, 49, 55, 378,
1005  143, 144, 56, 45, 383, 34, 52, 386, 150, 70,
1006  55, 150, 78, 70, 52, 41, 33, 120, 55, 52,
1007  52, 400, 68, 70, 167, 70, 6, 56, 52, 55,
1008  68, 410, 98, 70, 196, 68, 68, 140, 200, 142,
1009  20, 57, 22, 195, 68, 25, 26, 199, 58, 40,
1010  35, 36, 127, 38, 129, 35, 36, 42, 38, 39,
1011  346, 52, 441, 5, 59, 351, 43, 353, 53, 448,
1012  173, 13, 175, 176, 177, 178, 179, 180, 181, 182,
1013  183, 184, 185, 186, 187, 188, 229, 44, 318, 319,
1014  320, 321, 322, 323, 324, 325, 326, 327, 52, 329,
1015  330, 55, 310, 253, 62, 63, 64, 11, 31, 252,
1016  53, 35, 36, 16, 38, 19, 20, 52, 42, 23,
1017  328, 25, 26, 266, 267, 35, 36, 55, 358, 53,
1018  434, 435, 35, 36, 38, 38, 55, 41, 55, 42,
1019  120, 55, 46, 47, 48, 41, 67, 51, 69, 70,
1020  53, 67, 41, 69, 70, 363, 184, 185, 310, 63,
1021  140, 55, 142, 67, 55, 55, 70, 55, 52, 33,
1022  57, 313, 402, 58, 313, 43, 328, 59, 13, 52,
1023  41, 52, 16, 395, 53, 55, 52, 41, 51, 41,
1024  52, 51, 10, 4, 51, 337, 338, 55, 337, 338,
1025  51, 40, 55, 51, 347, 0, 186, 187, 188, 40,
1026  40, 363, 40, 40, 366, 318, 319, 320, 321, 322,
1027  323, 324, 325, 326, 327, 435, 329, 330, 259, 361,
1028  424, 406, 254, 75, 173, 319, 321, 175, 178, 176,
1029  322, 177, 325, 273, 323, 179, 324, 399, 273, 267,
1030  183, 271, 404, -1, 396, 358, -1, 396, 408, -1,
1031  -1, 403, -1, -1, 403, -1, -1, -1, -1, -1,
1032  412, -1, -1, 412, -1, 417, -1, -1, 417, -1,
1033  -1, 433, -1, -1, -1, -1, -1, -1, 440, -1,
1034  -1, -1, 434, 435, -1, 1, -1, -1, -1, 402,
1035  442, -1, 8, 442, -1, 11, -1, 449, -1, 451,
1036  449, -1, 451, 19, 20, -1, -1, 23, -1, 25,
1037  26, -1, 28, -1, 30, -1, -1, -1, -1, 35,
1038  36, -1, 38, 1, -1, 41, -1, -1, -1, -1,
1039  46, 47, 48, -1, -1, 51, -1, -1, 16, -1,
1040  18, -1, -1, -1, 60, 61, -1, 63, -1, 65,
1041  66, 67, -1, -1, 70, 33, 34, -1, -1, -1,
1042  -1, -1, -1, -1, 42, 43, 44, 45, 1, -1,
1043  -1, -1, -1, -1, 52, 53, -1, -1, 56, 57,
1044  58, 59, -1, 16, 62, 18, 64, -1, -1, -1,
1045  -1, 69, -1, -1, -1, -1, -1, -1, -1, -1,
1046  33, 34, -1, -1, -1, -1, -1, -1, -1, 42,
1047  43, 44, 45, -1, -1, -1, -1, -1, -1, 52,
1048  53, -1, -1, 56, 57, 58, 59, -1, -1, 62,
1049  -1, 64, -1, -1, -1, -1, 69, 3, 4, 5,
1050  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1051  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1052  26, 27, 28, 29, 30, 31, 32, -1, -1, 35,
1053  36, -1, 38, -1, 40, 41, -1, -1, -1, -1,
1054  46, 47, 48, -1, -1, 51, -1, -1, 54, -1,
1055  -1, -1, -1, -1, 60, 61, -1, 63, -1, 65,
1056  66, 67, 3, -1, 70, 6, -1, 8, 9, -1,
1057  11, 12, -1, 14, -1, -1, -1, -1, 19, 20,
1058  21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1059  31, 32, -1, -1, 35, 36, 37, 38, -1, -1,
1060  41, -1, -1, -1, -1, 46, 47, 48, -1, -1,
1061  51, -1, -1, 54, -1, -1, -1, -1, -1, 60,
1062  61, -1, 63, -1, 65, 66, 67, 3, -1, 70,
1063  6, -1, 8, 9, -1, 11, 12, -1, 14, -1,
1064  -1, -1, -1, 19, 20, 21, 22, 23, 24, 25,
1065  26, 27, 28, 29, 30, 31, 32, -1, -1, 35,
1066  36, -1, 38, -1, 40, 41, -1, -1, -1, -1,
1067  46, 47, 48, -1, -1, 51, -1, -1, 54, -1,
1068  -1, -1, -1, -1, 60, 61, -1, 63, -1, 65,
1069  66, 67, 3, -1, 70, 6, -1, 8, 9, -1,
1070  11, 12, -1, 14, -1, -1, -1, -1, 19, 20,
1071  21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1072  31, 32, -1, -1, 35, 36, -1, 38, -1, 40,
1073  41, -1, -1, -1, -1, 46, 47, 48, -1, -1,
1074  51, -1, -1, 54, -1, -1, -1, -1, -1, 60,
1075  61, -1, 63, -1, 65, 66, 67, 3, -1, 70,
1076  6, -1, 8, 9, -1, 11, 12, -1, 14, -1,
1077  -1, -1, -1, 19, 20, 21, 22, 23, 24, 25,
1078  26, 27, 28, 29, 30, 31, 32, -1, -1, 35,
1079  36, -1, 38, -1, -1, 41, -1, -1, -1, -1,
1080  46, 47, 48, -1, -1, 51, -1, -1, 54, -1,
1081  -1, -1, -1, -1, 60, 61, -1, 63, -1, 65,
1082  66, 67, 8, -1, 70, 11, -1, -1, -1, -1,
1083  -1, -1, -1, 19, 20, -1, -1, 23, -1, 25,
1084  26, -1, 28, -1, 30, -1, -1, -1, -1, 35,
1085  36, -1, 38, -1, -1, 41, -1, -1, -1, -1,
1086  46, 47, 48, -1, -1, 51, -1, -1, -1, -1,
1087  -1, -1, -1, -1, 60, 61, -1, 63, -1, 65,
1088  66, 67, -1, 8, 70, 71, 11, -1, -1, -1,
1089  -1, -1, -1, -1, 19, 20, -1, -1, 23, -1,
1090  25, 26, -1, 28, 29, 30, -1, -1, -1, -1,
1091  35, 36, -1, 38, -1, -1, 41, -1, -1, -1,
1092  -1, 46, 47, 48, -1, -1, 51, -1, -1, -1,
1093  -1, -1, -1, -1, -1, 60, 61, -1, 63, -1,
1094  65, 66, 67, 8, -1, 70, 11, -1, -1, -1,
1095  -1, -1, -1, -1, 19, 20, -1, -1, 23, -1,
1096  25, 26, -1, 28, -1, 30, -1, -1, -1, -1,
1097  35, 36, -1, 38, -1, -1, 41, -1, -1, -1,
1098  -1, 46, 47, 48, -1, -1, 51, -1, -1, -1,
1099  55, -1, -1, -1, -1, 60, 61, -1, 63, -1,
1100  65, 66, 67, 8, -1, 70, 11, -1, -1, -1,
1101  -1, -1, -1, -1, 19, 20, -1, -1, 23, -1,
1102  25, 26, -1, 28, -1, 30, -1, -1, -1, -1,
1103  35, 36, -1, 38, -1, -1, 41, -1, -1, -1,
1104  -1, 46, 47, 48, -1, -1, 51, -1, -1, -1,
1105  -1, -1, -1, -1, -1, 60, 61, -1, 63, -1,
1106  65, 66, 67, 68, 8, 70, -1, 11, -1, -1,
1107  -1, -1, -1, -1, -1, 19, 20, -1, -1, 23,
1108  -1, 25, 26, -1, 28, -1, 30, -1, -1, -1,
1109  -1, 35, 36, -1, 38, -1, -1, 41, -1, -1,
1110  -1, -1, 46, 47, 48, -1, -1, 51, -1, -1,
1111  -1, -1, -1, -1, -1, -1, 60, 61, -1, 63,
1112  -1, 65, 66, 67, -1, -1, 70, 3, 4, 5,
1113  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1114  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1115  26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
1116  -1, -1, -1, -1, 40, 41, -1, -1, -1, -1,
1117  46, -1, 48, 3, 4, 5, 6, 7, 8, 9,
1118  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1119  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1120  30, 31, 32, -1, -1, -1, -1, -1, -1, -1,
1121  40, 41, -1, -1, -1, -1, 46, -1, 48, 3,
1122  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1123  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1124  24, 25, 26, 27, 28, 29, 30, 31, 32, -1,
1125  -1, -1, -1, -1, -1, -1, -1, 41, -1, -1,
1126  -1, -1, 46, -1, 48, 3, 4, 5, 6, 7,
1127  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1128  18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1129  28, 29, 30, 31, 32, -1, -1, -1, -1, -1,
1130  -1, -1, -1, 41
1131 };
1132 
1133  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1134  symbol of state STATE-NUM. */
1135 static const yytype_uint8 yystos[] =
1136 {
1137  0, 73, 75, 0, 3, 6, 8, 9, 11, 12,
1138  14, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1139  28, 29, 30, 31, 32, 35, 36, 37, 38, 41,
1140  46, 47, 48, 51, 54, 60, 61, 63, 65, 66,
1141  67, 70, 74, 76, 77, 81, 84, 85, 94, 95,
1142  96, 97, 102, 103, 104, 105, 106, 107, 113, 114,
1143  119, 123, 125, 127, 129, 131, 133, 135, 137, 139,
1144  141, 142, 143, 144, 145, 146, 147, 148, 149, 152,
1145  153, 157, 165, 166, 41, 162, 162, 41, 51, 76,
1146  144, 146, 81, 1, 70, 168, 168, 147, 148, 117,
1147  119, 168, 119, 51, 84, 144, 41, 86, 88, 144,
1148  168, 168, 144, 144, 55, 3, 4, 5, 6, 7,
1149  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1150  18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1151  28, 29, 30, 31, 32, 40, 41, 46, 48, 81,
1152  82, 158, 159, 161, 163, 164, 144, 144, 144, 144,
1153  52, 68, 154, 155, 156, 119, 49, 41, 168, 1,
1154  52, 54, 167, 34, 56, 33, 57, 58, 59, 43,
1155  16, 18, 45, 44, 60, 61, 62, 63, 64, 35,
1156  36, 38, 42, 53, 122, 67, 69, 70, 150, 67,
1157  69, 150, 167, 167, 3, 6, 8, 9, 11, 12,
1158  14, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1159  28, 29, 30, 31, 32, 40, 41, 46, 48, 31,
1160  1, 118, 119, 29, 120, 121, 124, 126, 128, 130,
1161  132, 134, 136, 138, 140, 141, 146, 150, 167, 119,
1162  167, 40, 5, 13, 115, 116, 53, 90, 91, 52,
1163  167, 118, 119, 81, 15, 17, 161, 161, 40, 81,
1164  40, 52, 55, 52, 68, 52, 68, 123, 71, 39,
1165  168, 41, 79, 80, 123, 129, 123, 131, 133, 135,
1166  137, 139, 141, 141, 141, 142, 143, 143, 144, 144,
1167  144, 123, 123, 119, 163, 71, 123, 151, 119, 163,
1168  168, 1, 71, 169, 41, 87, 89, 98, 52, 34,
1169  56, 33, 57, 58, 59, 43, 18, 45, 16, 53,
1170  122, 169, 168, 84, 116, 123, 88, 169, 169, 160,
1171  168, 160, 40, 159, 123, 155, 156, 41, 80, 52,
1172  169, 55, 68, 52, 71, 68, 118, 81, 53, 92,
1173  93, 52, 100, 16, 1, 54, 170, 124, 146, 130,
1174  124, 132, 134, 136, 138, 140, 141, 141, 118, 124,
1175  124, 51, 108, 41, 81, 81, 80, 68, 123, 168,
1176  169, 41, 51, 123, 123, 169, 10, 124, 89, 170,
1177  118, 117, 55, 169, 4, 109, 110, 111, 169, 169,
1178  80, 51, 75, 78, 167, 81, 117, 169, 99, 124,
1179  81, 119, 7, 40, 112, 111, 84, 51, 169, 78,
1180  40, 101, 81, 170, 55, 55, 109, 78, 51, 40,
1181  170, 117, 82, 83, 83, 40, 40, 78, 117, 169,
1182  40, 169, 81, 81
1183 };
1184 
1185  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1186 static const yytype_uint8 yyr1[] =
1187 {
1188  0, 72, 73, 74, 74, 75, 75, 76, 76, 76,
1189  77, 78, 79, 79, 80, 80, 81, 81, 81, 81,
1190  81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
1191  81, 82, 82, 83, 83, 84, 84, 85, 86, 86,
1192  87, 87, 88, 89, 90, 90, 91, 92, 92, 93,
1193  94, 95, 96, 96, 97, 97, 98, 99, 97, 100,
1194  101, 97, 97, 97, 102, 103, 104, 105, 106, 107,
1195  108, 108, 109, 109, 110, 110, 111, 112, 113, 114,
1196  114, 114, 115, 116, 117, 117, 118, 118, 119, 119,
1197  120, 120, 121, 121, 122, 122, 123, 123, 123, 124,
1198  124, 124, 125, 125, 126, 126, 127, 127, 128, 128,
1199  129, 129, 130, 130, 131, 131, 132, 132, 133, 133,
1200  134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
1201  139, 139, 139, 139, 140, 140, 140, 141, 141, 142,
1202  142, 142, 143, 143, 143, 143, 144, 144, 144, 144,
1203  144, 144, 144, 144, 144, 144, 145, 145, 145, 146,
1204  146, 147, 147, 148, 148, 148, 148, 148, 149, 149,
1205  149, 149, 150, 150, 151, 151, 152, 152, 152, 152,
1206  152, 152, 153, 153, 153, 153, 154, 154, 155, 155,
1207  156, 156, 157, 157, 157, 158, 158, 159, 159, 159,
1208  160, 161, 161, 161, 162, 162, 163, 163, 164, 164,
1209  164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
1210  164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
1211  164, 164, 164, 164, 164, 164, 164, 164, 165, 165,
1212  165, 165, 165, 165, 166, 166, 166, 167, 167, 168,
1213  168, 169, 169, 170, 170
1214 };
1215 
1216  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1217 static const yytype_uint8 yyr2[] =
1218 {
1219  0, 2, 3, 1, 0, 0, 2, 7, 8, 10,
1220  1, 1, 1, 3, 0, 1, 1, 1, 1, 1,
1221  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1222  1, 1, 2, 0, 1, 3, 2, 3, 1, 3,
1223  1, 3, 2, 2, 0, 1, 2, 0, 1, 2,
1224  1, 2, 7, 5, 7, 5, 0, 0, 11, 0,
1225  0, 12, 7, 8, 3, 3, 3, 5, 3, 5,
1226  3, 5, 0, 1, 1, 2, 4, 3, 3, 3,
1227  3, 4, 5, 2, 0, 1, 1, 1, 1, 3,
1228  0, 1, 1, 3, 1, 1, 1, 3, 3, 1,
1229  3, 3, 1, 5, 1, 5, 1, 3, 1, 3,
1230  1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
1231  1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
1232  1, 3, 3, 3, 1, 3, 3, 1, 3, 1,
1233  3, 3, 1, 3, 3, 3, 1, 2, 2, 2,
1234  2, 2, 2, 2, 2, 2, 1, 2, 2, 1,
1235  1, 1, 2, 1, 1, 4, 3, 3, 2, 2,
1236  4, 3, 2, 3, 1, 3, 1, 1, 1, 1,
1237  1, 3, 2, 3, 3, 5, 2, 4, 1, 2,
1238  0, 1, 2, 3, 4, 1, 3, 3, 3, 3,
1239  6, 1, 1, 1, 0, 1, 1, 1, 1, 1,
1240  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1241  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1242  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1243  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1244  1, 1, 1, 1, 1
1245 };
1246 
1247 
1248 #define yyerrok (yyerrstatus = 0)
1249 #define yyclearin (yychar = YYEMPTY)
1250 #define YYEMPTY (-2)
1251 #define YYEOF 0
1252 
1253 #define YYACCEPT goto yyacceptlab
1254 #define YYABORT goto yyabortlab
1255 #define YYERROR goto yyerrorlab
1256 
1257 
1258 #define YYRECOVERING() (!!yyerrstatus)
1259 
1260 #define YYBACKUP(Token, Value) \
1261 do \
1262  if (yychar == YYEMPTY) \
1263  { \
1264  yychar = (Token); \
1265  yylval = (Value); \
1266  YYPOPSTACK (yylen); \
1267  yystate = *yyssp; \
1268  goto yybackup; \
1269  } \
1270  else \
1271  { \
1272  yyerror (ctx, YY_("syntax error: cannot back up")); \
1273  YYERROR; \
1274  } \
1275 while (0)
1276 
1277 /* Error token number */
1278 #define YYTERROR 1
1279 #define YYERRCODE 256
1280 
1281 
1282 
1283 /* Enable debugging if requested. */
1284 #if YYDEBUG
1285 
1286 # ifndef YYFPRINTF
1287 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1288 # define YYFPRINTF fprintf
1289 # endif
1290 
1291 # define YYDPRINTF(Args) \
1292 do { \
1293  if (yydebug) \
1294  YYFPRINTF Args; \
1295 } while (0)
1296 
1297 /* This macro is provided for backward compatibility. */
1298 #ifndef YY_LOCATION_PRINT
1299 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1300 #endif
1301 
1302 
1303 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1304 do { \
1305  if (yydebug) \
1306  { \
1307  YYFPRINTF (stderr, "%s ", Title); \
1308  yy_symbol_print (stderr, \
1309  Type, Value, ctx); \
1310  YYFPRINTF (stderr, "\n"); \
1311  } \
1312 } while (0)
1313 
1314 
1315 /*----------------------------------------.
1316 | Print this symbol's value on YYOUTPUT. |
1317 `----------------------------------------*/
1318 
1319 static void
1320 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
1321 {
1322  FILE *yyo = yyoutput;
1323  YYUSE (yyo);
1324  YYUSE (ctx);
1325  if (!yyvaluep)
1326  return;
1327 # ifdef YYPRINT
1328  if (yytype < YYNTOKENS)
1329  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1330 # endif
1331  YYUSE (yytype);
1332 }
1333 
1334 
1335 /*--------------------------------.
1336 | Print this symbol on YYOUTPUT. |
1337 `--------------------------------*/
1338 
1339 static void
1340 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
1341 {
1342  YYFPRINTF (yyoutput, "%s %s (",
1343  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1344 
1345  yy_symbol_value_print (yyoutput, yytype, yyvaluep, ctx);
1346  YYFPRINTF (yyoutput, ")");
1347 }
1348 
1349 /*------------------------------------------------------------------.
1350 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1351 | TOP (included). |
1352 `------------------------------------------------------------------*/
1353 
1354 static void
1355 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1356 {
1357  YYFPRINTF (stderr, "Stack now");
1358  for (; yybottom <= yytop; yybottom++)
1359  {
1360  int yybot = *yybottom;
1361  YYFPRINTF (stderr, " %d", yybot);
1362  }
1363  YYFPRINTF (stderr, "\n");
1364 }
1365 
1366 # define YY_STACK_PRINT(Bottom, Top) \
1367 do { \
1368  if (yydebug) \
1369  yy_stack_print ((Bottom), (Top)); \
1370 } while (0)
1371 
1372 
1373 /*------------------------------------------------.
1374 | Report that the YYRULE is going to be reduced. |
1375 `------------------------------------------------*/
1376 
1377 static void
1378 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parser_ctx_t *ctx)
1379 {
1380  unsigned long int yylno = yyrline[yyrule];
1381  int yynrhs = yyr2[yyrule];
1382  int yyi;
1383  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1384  yyrule - 1, yylno);
1385  /* The symbols being reduced. */
1386  for (yyi = 0; yyi < yynrhs; yyi++)
1387  {
1388  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1389  yy_symbol_print (stderr,
1390  yystos[yyssp[yyi + 1 - yynrhs]],
1391  &(yyvsp[(yyi + 1) - (yynrhs)])
1392  , ctx);
1393  YYFPRINTF (stderr, "\n");
1394  }
1395 }
1396 
1397 # define YY_REDUCE_PRINT(Rule) \
1398 do { \
1399  if (yydebug) \
1400  yy_reduce_print (yyssp, yyvsp, Rule, ctx); \
1401 } while (0)
1402 
1403 /* Nonzero means print parse trace. It is left uninitialized so that
1404  multiple parsers can coexist. */
1405 int yydebug;
1406 #else /* !YYDEBUG */
1407 # define YYDPRINTF(Args)
1408 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1409 # define YY_STACK_PRINT(Bottom, Top)
1410 # define YY_REDUCE_PRINT(Rule)
1411 #endif /* !YYDEBUG */
1412 
1413 
1414 /* YYINITDEPTH -- initial size of the parser's stacks. */
1415 #ifndef YYINITDEPTH
1416 # define YYINITDEPTH 200
1417 #endif
1418 
1419 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1420  if the built-in stack extension method is used).
1421 
1422  Do not make this value too large; the results are undefined if
1423  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1424  evaluated with infinite-precision integer arithmetic. */
1425 
1426 #ifndef YYMAXDEPTH
1427 # define YYMAXDEPTH 10000
1428 #endif
1429 
1430 
1431 #if YYERROR_VERBOSE
1432 
1433 # ifndef yystrlen
1434 # if defined __GLIBC__ && defined _STRING_H
1435 # define yystrlen strlen
1436 # else
1437 /* Return the length of YYSTR. */
1438 static YYSIZE_T
1439 yystrlen (const char *yystr)
1440 {
1441  YYSIZE_T yylen;
1442  for (yylen = 0; yystr[yylen]; yylen++)
1443  continue;
1444  return yylen;
1445 }
1446 # endif
1447 # endif
1448 
1449 # ifndef yystpcpy
1450 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1451 # define yystpcpy stpcpy
1452 # else
1453 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1454  YYDEST. */
1455 static char *
1456 yystpcpy (char *yydest, const char *yysrc)
1457 {
1458  char *yyd = yydest;
1459  const char *yys = yysrc;
1460 
1461  while ((*yyd++ = *yys++) != '\0')
1462  continue;
1463 
1464  return yyd - 1;
1465 }
1466 # endif
1467 # endif
1468 
1469 # ifndef yytnamerr
1470 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1471  quotes and backslashes, so that it's suitable for yyerror. The
1472  heuristic is that double-quoting is unnecessary unless the string
1473  contains an apostrophe, a comma, or backslash (other than
1474  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1475  null, do not copy; instead, return the length of what the result
1476  would have been. */
1477 static YYSIZE_T
1478 yytnamerr (char *yyres, const char *yystr)
1479 {
1480  if (*yystr == '"')
1481  {
1482  YYSIZE_T yyn = 0;
1483  char const *yyp = yystr;
1484 
1485  for (;;)
1486  switch (*++yyp)
1487  {
1488  case '\'':
1489  case ',':
1490  goto do_not_strip_quotes;
1491 
1492  case '\\':
1493  if (*++yyp != '\\')
1494  goto do_not_strip_quotes;
1495  /* Fall through. */
1496  default:
1497  if (yyres)
1498  yyres[yyn] = *yyp;
1499  yyn++;
1500  break;
1501 
1502  case '"':
1503  if (yyres)
1504  yyres[yyn] = '\0';
1505  return yyn;
1506  }
1507  do_not_strip_quotes: ;
1508  }
1509 
1510  if (! yyres)
1511  return yystrlen (yystr);
1512 
1513  return yystpcpy (yyres, yystr) - yyres;
1514 }
1515 # endif
1516 
1517 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1518  about the unexpected token YYTOKEN for the state stack whose top is
1519  YYSSP.
1520 
1521  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1522  not large enough to hold the message. In that case, also set
1523  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1524  required number of bytes is too large to store. */
1525 static int
1526 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1527  yytype_int16 *yyssp, int yytoken)
1528 {
1529  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1530  YYSIZE_T yysize = yysize0;
1531  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1532  /* Internationalized format string. */
1533  const char *yyformat = YY_NULL;
1534  /* Arguments of yyformat. */
1535  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1536  /* Number of reported tokens (one for the "unexpected", one per
1537  "expected"). */
1538  int yycount = 0;
1539 
1540  /* There are many possibilities here to consider:
1541  - If this state is a consistent state with a default action, then
1542  the only way this function was invoked is if the default action
1543  is an error action. In that case, don't check for expected
1544  tokens because there are none.
1545  - The only way there can be no lookahead present (in yychar) is if
1546  this state is a consistent state with a default action. Thus,
1547  detecting the absence of a lookahead is sufficient to determine
1548  that there is no unexpected or expected token to report. In that
1549  case, just report a simple "syntax error".
1550  - Don't assume there isn't a lookahead just because this state is a
1551  consistent state with a default action. There might have been a
1552  previous inconsistent state, consistent state with a non-default
1553  action, or user semantic action that manipulated yychar.
1554  - Of course, the expected token list depends on states to have
1555  correct lookahead information, and it depends on the parser not
1556  to perform extra reductions after fetching a lookahead from the
1557  scanner and before detecting a syntax error. Thus, state merging
1558  (from LALR or IELR) and default reductions corrupt the expected
1559  token list. However, the list is correct for canonical LR with
1560  one exception: it will still contain any token that will not be
1561  accepted due to an error action in a later state.
1562  */
1563  if (yytoken != YYEMPTY)
1564  {
1565  int yyn = yypact[*yyssp];
1566  yyarg[yycount++] = yytname[yytoken];
1567  if (!yypact_value_is_default (yyn))
1568  {
1569  /* Start YYX at -YYN if negative to avoid negative indexes in
1570  YYCHECK. In other words, skip the first -YYN actions for
1571  this state because they are default actions. */
1572  int yyxbegin = yyn < 0 ? -yyn : 0;
1573  /* Stay within bounds of both yycheck and yytname. */
1574  int yychecklim = YYLAST - yyn + 1;
1575  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1576  int yyx;
1577 
1578  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1579  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1580  && !yytable_value_is_error (yytable[yyx + yyn]))
1581  {
1582  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1583  {
1584  yycount = 1;
1585  yysize = yysize0;
1586  break;
1587  }
1588  yyarg[yycount++] = yytname[yyx];
1589  {
1590  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1591  if (! (yysize <= yysize1
1592  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1593  return 2;
1594  yysize = yysize1;
1595  }
1596  }
1597  }
1598  }
1599 
1600  switch (yycount)
1601  {
1602 # define YYCASE_(N, S) \
1603  case N: \
1604  yyformat = S; \
1605  break
1606  YYCASE_(0, YY_("syntax error"));
1607  YYCASE_(1, YY_("syntax error, unexpected %s"));
1608  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1609  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1610  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1611  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1612 # undef YYCASE_
1613  }
1614 
1615  {
1616  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1617  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1618  return 2;
1619  yysize = yysize1;
1620  }
1621 
1622  if (*yymsg_alloc < yysize)
1623  {
1624  *yymsg_alloc = 2 * yysize;
1625  if (! (yysize <= *yymsg_alloc
1626  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1627  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1628  return 1;
1629  }
1630 
1631  /* Avoid sprintf, as that infringes on the user's name space.
1632  Don't have undefined behavior even if the translation
1633  produced a string with the wrong number of "%s"s. */
1634  {
1635  char *yyp = *yymsg;
1636  int yyi = 0;
1637  while ((*yyp = *yyformat) != '\0')
1638  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1639  {
1640  yyp += yytnamerr (yyp, yyarg[yyi++]);
1641  yyformat += 2;
1642  }
1643  else
1644  {
1645  yyp++;
1646  yyformat++;
1647  }
1648  }
1649  return 0;
1650 }
1651 #endif /* YYERROR_VERBOSE */
1652 
1653 /*-----------------------------------------------.
1654 | Release the memory associated to this symbol. |
1655 `-----------------------------------------------*/
1656 
1657 static void
1658 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx)
1659 {
1660  YYUSE (yyvaluep);
1661  YYUSE (ctx);
1662  if (!yymsg)
1663  yymsg = "Deleting";
1664  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1665 
1667  YYUSE (yytype);
1669 }
1670 
1671 
1672 
1673 
1674 /*----------.
1675 | yyparse. |
1676 `----------*/
1677 
1678 int
1680 {
1681 /* The lookahead symbol. */
1682 int yychar;
1683 
1684 
1685 /* The semantic value of the lookahead symbol. */
1686 /* Default value used for initialization, for pacifying older GCCs
1687  or non-GCC compilers. */
1688 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1689 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1690 
1691  /* Number of syntax errors so far. */
1692  int yynerrs;
1693 
1694  int yystate;
1695  /* Number of tokens to shift before error messages enabled. */
1696  int yyerrstatus;
1697 
1698  /* The stacks and their tools:
1699  'yyss': related to states.
1700  'yyvs': related to semantic values.
1701 
1702  Refer to the stacks through separate pointers, to allow yyoverflow
1703  to reallocate them elsewhere. */
1704 
1705  /* The state stack. */
1706  yytype_int16 yyssa[YYINITDEPTH];
1707  yytype_int16 *yyss;
1708  yytype_int16 *yyssp;
1709 
1710  /* The semantic value stack. */
1711  YYSTYPE yyvsa[YYINITDEPTH];
1712  YYSTYPE *yyvs;
1713  YYSTYPE *yyvsp;
1714 
1715  YYSIZE_T yystacksize;
1716 
1717  int yyn;
1718  int yyresult;
1719  /* Lookahead token as an internal (translated) token number. */
1720  int yytoken = 0;
1721  /* The variables used to return semantic value and location from the
1722  action routines. */
1723  YYSTYPE yyval;
1724 
1725 #if YYERROR_VERBOSE
1726  /* Buffer for error messages, and its allocated size. */
1727  char yymsgbuf[128];
1728  char *yymsg = yymsgbuf;
1729  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1730 #endif
1731 
1732 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1733 
1734  /* The number of symbols on the RHS of the reduced rule.
1735  Keep to zero when no symbol should be popped. */
1736  int yylen = 0;
1737 
1738  yyssp = yyss = yyssa;
1739  yyvsp = yyvs = yyvsa;
1740  yystacksize = YYINITDEPTH;
1741 
1742  YYDPRINTF ((stderr, "Starting parse\n"));
1743 
1744  yystate = 0;
1745  yyerrstatus = 0;
1746  yynerrs = 0;
1747  yychar = YYEMPTY; /* Cause a token to be read. */
1748  goto yysetstate;
1749 
1750 /*------------------------------------------------------------.
1751 | yynewstate -- Push a new state, which is found in yystate. |
1752 `------------------------------------------------------------*/
1753  yynewstate:
1754  /* In all cases, when you get here, the value and location stacks
1755  have just been pushed. So pushing a state here evens the stacks. */
1756  yyssp++;
1757 
1758  yysetstate:
1759  *yyssp = yystate;
1760 
1761  if (yyss + yystacksize - 1 <= yyssp)
1762  {
1763  /* Get the current used size of the three stacks, in elements. */
1764  YYSIZE_T yysize = yyssp - yyss + 1;
1765 
1766 #ifdef yyoverflow
1767  {
1768  /* Give user a chance to reallocate the stack. Use copies of
1769  these so that the &'s don't force the real ones into
1770  memory. */
1771  YYSTYPE *yyvs1 = yyvs;
1772  yytype_int16 *yyss1 = yyss;
1773 
1774  /* Each stack pointer address is followed by the size of the
1775  data in use in that stack, in bytes. This used to be a
1776  conditional around just the two extra args, but that might
1777  be undefined if yyoverflow is a macro. */
1778  yyoverflow (YY_("memory exhausted"),
1779  &yyss1, yysize * sizeof (*yyssp),
1780  &yyvs1, yysize * sizeof (*yyvsp),
1781  &yystacksize);
1782 
1783  yyss = yyss1;
1784  yyvs = yyvs1;
1785  }
1786 #else /* no yyoverflow */
1787 # ifndef YYSTACK_RELOCATE
1788  goto yyexhaustedlab;
1789 # else
1790  /* Extend the stack our own way. */
1791  if (YYMAXDEPTH <= yystacksize)
1792  goto yyexhaustedlab;
1793  yystacksize *= 2;
1794  if (YYMAXDEPTH < yystacksize)
1795  yystacksize = YYMAXDEPTH;
1796 
1797  {
1798  yytype_int16 *yyss1 = yyss;
1799  union yyalloc *yyptr =
1800  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1801  if (! yyptr)
1802  goto yyexhaustedlab;
1803  YYSTACK_RELOCATE (yyss_alloc, yyss);
1804  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1805 # undef YYSTACK_RELOCATE
1806  if (yyss1 != yyssa)
1807  YYSTACK_FREE (yyss1);
1808  }
1809 # endif
1810 #endif /* no yyoverflow */
1811 
1812  yyssp = yyss + yysize - 1;
1813  yyvsp = yyvs + yysize - 1;
1814 
1815  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1816  (unsigned long int) yystacksize));
1817 
1818  if (yyss + yystacksize - 1 <= yyssp)
1819  YYABORT;
1820  }
1821 
1822  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1823 
1824  if (yystate == YYFINAL)
1825  YYACCEPT;
1826 
1827  goto yybackup;
1828 
1829 /*-----------.
1830 | yybackup. |
1831 `-----------*/
1832 yybackup:
1833 
1834  /* Do appropriate processing given the current state. Read a
1835  lookahead token if we need one and don't already have one. */
1836 
1837  /* First try to decide what to do without reference to lookahead token. */
1838  yyn = yypact[yystate];
1839  if (yypact_value_is_default (yyn))
1840  goto yydefault;
1841 
1842  /* Not known => get a lookahead token if don't already have one. */
1843 
1844  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1845  if (yychar == YYEMPTY)
1846  {
1847  YYDPRINTF ((stderr, "Reading a token: "));
1848  yychar = yylex (&yylval, ctx);
1849  }
1850 
1851  if (yychar <= YYEOF)
1852  {
1853  yychar = yytoken = YYEOF;
1854  YYDPRINTF ((stderr, "Now at end of input.\n"));
1855  }
1856  else
1857  {
1858  yytoken = YYTRANSLATE (yychar);
1859  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1860  }
1861 
1862  /* If the proper action on seeing token YYTOKEN is to reduce or to
1863  detect an error, take that action. */
1864  yyn += yytoken;
1865  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1866  goto yydefault;
1867  yyn = yytable[yyn];
1868  if (yyn <= 0)
1869  {
1870  if (yytable_value_is_error (yyn))
1871  goto yyerrlab;
1872  yyn = -yyn;
1873  goto yyreduce;
1874  }
1875 
1876  /* Count tokens shifted since error; after three, turn off error
1877  status. */
1878  if (yyerrstatus)
1879  yyerrstatus--;
1880 
1881  /* Shift the lookahead token. */
1882  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1883 
1884  /* Discard the shifted token. */
1885  yychar = YYEMPTY;
1886 
1887  yystate = yyn;
1889  *++yyvsp = yylval;
1891 
1892  goto yynewstate;
1893 
1894 
1895 /*-----------------------------------------------------------.
1896 | yydefault -- do the default action for the current state. |
1897 `-----------------------------------------------------------*/
1898 yydefault:
1899  yyn = yydefact[yystate];
1900  if (yyn == 0)
1901  goto yyerrlab;
1902  goto yyreduce;
1903 
1904 
1905 /*-----------------------------.
1906 | yyreduce -- Do a reduction. |
1907 `-----------------------------*/
1908 yyreduce:
1909  /* yyn is the number of a rule to reduce with. */
1910  yylen = yyr2[yyn];
1911 
1912  /* If YYLEN is nonzero, implement the default value of the action:
1913  '$$ = $1'.
1914 
1915  Otherwise, the following line sets YYVAL to garbage.
1916  This behavior is undocumented and Bison
1917  users should not rely upon it. Assigning to YYVAL
1918  unconditionally makes the parser a bit smaller, and it avoids a
1919  GCC warning that YYVAL may be used uninitialized. */
1920  yyval = yyvsp[1-yylen];
1921 
1922 
1923  YY_REDUCE_PRINT (yyn);
1924  switch (yyn)
1925  {
1926  case 2:
1927 #line 259 "parser.y" /* yacc.c:1646 */
1928  { program_parsed(ctx, (yyvsp[-2].source_elements)); }
1929 #line 1930 "parser.tab.c" /* yacc.c:1646 */
1930  break;
1931 
1932  case 3:
1933 #line 262 "parser.y" /* yacc.c:1646 */
1934  {}
1935 #line 1936 "parser.tab.c" /* yacc.c:1646 */
1936  break;
1937 
1938  case 4:
1939 #line 263 "parser.y" /* yacc.c:1646 */
1940  {}
1941 #line 1942 "parser.tab.c" /* yacc.c:1646 */
1942  break;
1943 
1944  case 5:
1945 #line 267 "parser.y" /* yacc.c:1646 */
1946  { (yyval.source_elements) = new_source_elements(ctx); }
1947 #line 1948 "parser.tab.c" /* yacc.c:1646 */
1948  break;
1949 
1950  case 6:
1951 #line 269 "parser.y" /* yacc.c:1646 */
1952  { (yyval.source_elements) = source_elements_add_statement((yyvsp[-1].source_elements), (yyvsp[0].statement)); }
1953 #line 1954 "parser.tab.c" /* yacc.c:1646 */
1954  break;
1955 
1956  case 7:
1957 #line 274 "parser.y" /* yacc.c:1646 */
1958  { (yyval.expr) = new_function_expression(ctx, NULL, (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-6].srcptr), (yyvsp[0].srcptr)-(yyvsp[-6].srcptr)+1); }
1959 #line 1960 "parser.tab.c" /* yacc.c:1646 */
1960  break;
1961 
1962  case 8:
1963 #line 276 "parser.y" /* yacc.c:1646 */
1964  { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-7].srcptr), (yyvsp[0].srcptr)-(yyvsp[-7].srcptr)+1); }
1965 #line 1966 "parser.tab.c" /* yacc.c:1646 */
1966  break;
1967 
1968  case 9:
1969 #line 278 "parser.y" /* yacc.c:1646 */
1970  { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), (yyvsp[-8].identifier), (yyvsp[-9].srcptr), (yyvsp[0].srcptr)-(yyvsp[-9].srcptr)+1); }
1971 #line 1972 "parser.tab.c" /* yacc.c:1646 */
1972  break;
1973 
1974  case 10:
1975 #line 281 "parser.y" /* yacc.c:1646 */
1976  { (yyval.srcptr) = ctx->ptr - 8; }
1977 #line 1978 "parser.tab.c" /* yacc.c:1646 */
1978  break;
1979 
1980  case 11:
1981 #line 285 "parser.y" /* yacc.c:1646 */
1982  { (yyval.source_elements) = (yyvsp[0].source_elements); }
1983 #line 1984 "parser.tab.c" /* yacc.c:1646 */
1984  break;
1985 
1986  case 12:
1987 #line 289 "parser.y" /* yacc.c:1646 */
1988  { (yyval.parameter_list) = new_parameter_list(ctx, (yyvsp[0].identifier)); }
1989 #line 1990 "parser.tab.c" /* yacc.c:1646 */
1990  break;
1991 
1992  case 13:
1993 #line 291 "parser.y" /* yacc.c:1646 */
1994  { (yyval.parameter_list) = parameter_list_add(ctx, (yyvsp[-2].parameter_list), (yyvsp[0].identifier)); }
1995 #line 1996 "parser.tab.c" /* yacc.c:1646 */
1996  break;
1997 
1998  case 14:
1999 #line 295 "parser.y" /* yacc.c:1646 */
2000  { (yyval.parameter_list) = NULL; }
2001 #line 2002 "parser.tab.c" /* yacc.c:1646 */
2002  break;
2003 
2004  case 15:
2005 #line 296 "parser.y" /* yacc.c:1646 */
2006  { (yyval.parameter_list) = (yyvsp[0].parameter_list); }
2007 #line 2008 "parser.tab.c" /* yacc.c:1646 */
2008  break;
2009 
2010  case 16:
2011 #line 300 "parser.y" /* yacc.c:1646 */
2012  { (yyval.statement) = (yyvsp[0].statement); }
2013 #line 2014 "parser.tab.c" /* yacc.c:1646 */
2014  break;
2015 
2016  case 17:
2017 #line 301 "parser.y" /* yacc.c:1646 */
2018  { (yyval.statement) = (yyvsp[0].statement); }
2019 #line 2020 "parser.tab.c" /* yacc.c:1646 */
2020  break;
2021 
2022  case 18:
2023 #line 302 "parser.y" /* yacc.c:1646 */
2024  { (yyval.statement) = (yyvsp[0].statement); }
2025 #line 2026 "parser.tab.c" /* yacc.c:1646 */
2026  break;
2027 
2028  case 19:
2029 #line 303 "parser.y" /* yacc.c:1646 */
2030  { (yyval.statement) = new_expression_statement(ctx, (yyvsp[0].expr)); }
2031 #line 2032 "parser.tab.c" /* yacc.c:1646 */
2032  break;
2033 
2034  case 20:
2035 #line 304 "parser.y" /* yacc.c:1646 */
2036  { (yyval.statement) = (yyvsp[0].statement); }
2037 #line 2038 "parser.tab.c" /* yacc.c:1646 */
2038  break;
2039 
2040  case 21:
2041 #line 305 "parser.y" /* yacc.c:1646 */
2042  { (yyval.statement) = (yyvsp[0].statement); }
2043 #line 2044 "parser.tab.c" /* yacc.c:1646 */
2044  break;
2045 
2046  case 22:
2047 #line 306 "parser.y" /* yacc.c:1646 */
2048  { (yyval.statement) = (yyvsp[0].statement); }
2049 #line 2050 "parser.tab.c" /* yacc.c:1646 */
2050  break;
2051 
2052  case 23:
2053 #line 307 "parser.y" /* yacc.c:1646 */
2054  { (yyval.statement) = (yyvsp[0].statement); }
2055 #line 2056 "parser.tab.c" /* yacc.c:1646 */
2056  break;
2057 
2058  case 24:
2059 #line 308 "parser.y" /* yacc.c:1646 */
2060  { (yyval.statement) = (yyvsp[0].statement); }
2061 #line 2062 "parser.tab.c" /* yacc.c:1646 */
2062  break;
2063 
2064  case 25:
2065 #line 309 "parser.y" /* yacc.c:1646 */
2066  { (yyval.statement) = (yyvsp[0].statement); }
2067 #line 2068 "parser.tab.c" /* yacc.c:1646 */
2068  break;
2069 
2070  case 26:
2071 #line 310 "parser.y" /* yacc.c:1646 */
2072  { (yyval.statement) = (yyvsp[0].statement); }
2073 #line 2074 "parser.tab.c" /* yacc.c:1646 */
2074  break;
2075 
2076  case 27:
2077 #line 311 "parser.y" /* yacc.c:1646 */
2078  { (yyval.statement) = (yyvsp[0].statement); }
2079 #line 2080 "parser.tab.c" /* yacc.c:1646 */
2080  break;
2081 
2082  case 28:
2083 #line 312 "parser.y" /* yacc.c:1646 */
2084  { (yyval.statement) = (yyvsp[0].statement); }
2085 #line 2086 "parser.tab.c" /* yacc.c:1646 */
2086  break;
2087 
2088  case 29:
2089 #line 313 "parser.y" /* yacc.c:1646 */
2090  { (yyval.statement) = (yyvsp[0].statement); }
2091 #line 2092 "parser.tab.c" /* yacc.c:1646 */
2092  break;
2093 
2094  case 30:
2095 #line 314 "parser.y" /* yacc.c:1646 */
2096  { (yyval.statement) = (yyvsp[0].statement); }
2097 #line 2098 "parser.tab.c" /* yacc.c:1646 */
2098  break;
2099 
2100  case 31:
2101 #line 318 "parser.y" /* yacc.c:1646 */
2102  { (yyval.statement_list) = new_statement_list(ctx, (yyvsp[0].statement)); }
2103 #line 2104 "parser.tab.c" /* yacc.c:1646 */
2104  break;
2105 
2106  case 32:
2107 #line 320 "parser.y" /* yacc.c:1646 */
2108  { (yyval.statement_list) = statement_list_add((yyvsp[-1].statement_list), (yyvsp[0].statement)); }
2109 #line 2110 "parser.tab.c" /* yacc.c:1646 */
2110  break;
2111 
2112  case 33:
2113 #line 324 "parser.y" /* yacc.c:1646 */
2114  { (yyval.statement_list) = NULL; }
2115 #line 2116 "parser.tab.c" /* yacc.c:1646 */
2116  break;
2117 
2118  case 34:
2119 #line 325 "parser.y" /* yacc.c:1646 */
2120  { (yyval.statement_list) = (yyvsp[0].statement_list); }
2121 #line 2122 "parser.tab.c" /* yacc.c:1646 */
2122  break;
2123 
2124  case 35:
2125 #line 329 "parser.y" /* yacc.c:1646 */
2126  { (yyval.statement) = new_block_statement(ctx, (yyvsp[-1].statement_list)); }
2127 #line 2128 "parser.tab.c" /* yacc.c:1646 */
2128  break;
2129 
2130  case 36:
2131 #line 330 "parser.y" /* yacc.c:1646 */
2132  { (yyval.statement) = new_block_statement(ctx, NULL); }
2133 #line 2134 "parser.tab.c" /* yacc.c:1646 */
2134  break;
2135 
2136  case 37:
2137 #line 335 "parser.y" /* yacc.c:1646 */
2138  { (yyval.statement) = new_var_statement(ctx, (yyvsp[-1].variable_list)); }
2139 #line 2140 "parser.tab.c" /* yacc.c:1646 */
2140  break;
2141 
2142  case 38:
2143 #line 339 "parser.y" /* yacc.c:1646 */
2144  { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); }
2145 #line 2146 "parser.tab.c" /* yacc.c:1646 */
2146  break;
2147 
2148  case 39:
2149 #line 341 "parser.y" /* yacc.c:1646 */
2150  { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); }
2151 #line 2152 "parser.tab.c" /* yacc.c:1646 */
2152  break;
2153 
2154  case 40:
2155 #line 346 "parser.y" /* yacc.c:1646 */
2156  { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); }
2157 #line 2158 "parser.tab.c" /* yacc.c:1646 */
2158  break;
2159 
2160  case 41:
2161 #line 348 "parser.y" /* yacc.c:1646 */
2162  { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); }
2163 #line 2164 "parser.tab.c" /* yacc.c:1646 */
2164  break;
2165 
2166  case 42:
2167 #line 353 "parser.y" /* yacc.c:1646 */
2168  { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); }
2169 #line 2170 "parser.tab.c" /* yacc.c:1646 */
2170  break;
2171 
2172  case 43:
2173 #line 358 "parser.y" /* yacc.c:1646 */
2174  { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); }
2175 #line 2176 "parser.tab.c" /* yacc.c:1646 */
2176  break;
2177 
2178  case 44:
2179 #line 362 "parser.y" /* yacc.c:1646 */
2180  { (yyval.expr) = NULL; }
2181 #line 2182 "parser.tab.c" /* yacc.c:1646 */
2182  break;
2183 
2184  case 45:
2185 #line 363 "parser.y" /* yacc.c:1646 */
2186  { (yyval.expr) = (yyvsp[0].expr); }
2187 #line 2188 "parser.tab.c" /* yacc.c:1646 */
2188  break;
2189 
2190  case 46:
2191 #line 368 "parser.y" /* yacc.c:1646 */
2192  { (yyval.expr) = (yyvsp[0].expr); }
2193 #line 2194 "parser.tab.c" /* yacc.c:1646 */
2194  break;
2195 
2196  case 47:
2197 #line 372 "parser.y" /* yacc.c:1646 */
2198  { (yyval.expr) = NULL; }
2199 #line 2200 "parser.tab.c" /* yacc.c:1646 */
2200  break;
2201 
2202  case 48:
2203 #line 373 "parser.y" /* yacc.c:1646 */
2204  { (yyval.expr) = (yyvsp[0].expr); }
2205 #line 2206 "parser.tab.c" /* yacc.c:1646 */
2206  break;
2207 
2208  case 49:
2209 #line 378 "parser.y" /* yacc.c:1646 */
2210  { (yyval.expr) = (yyvsp[0].expr); }
2211 #line 2212 "parser.tab.c" /* yacc.c:1646 */
2212  break;
2213 
2214  case 50:
2215 #line 382 "parser.y" /* yacc.c:1646 */
2216  { (yyval.statement) = new_statement(ctx, STAT_EMPTY, 0); }
2217 #line 2218 "parser.tab.c" /* yacc.c:1646 */
2218  break;
2219 
2220  case 51:
2221 #line 387 "parser.y" /* yacc.c:1646 */
2222  { (yyval.statement) = new_expression_statement(ctx, (yyvsp[-1].expr)); }
2223 #line 2224 "parser.tab.c" /* yacc.c:1646 */
2224  break;
2225 
2226  case 52:
2227 #line 392 "parser.y" /* yacc.c:1646 */
2228  { (yyval.statement) = new_if_statement(ctx, (yyvsp[-4].expr), (yyvsp[-2].statement), (yyvsp[0].statement)); }
2229 #line 2230 "parser.tab.c" /* yacc.c:1646 */
2230  break;
2231 
2232  case 53:
2233 #line 394 "parser.y" /* yacc.c:1646 */
2234  { (yyval.statement) = new_if_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement), NULL); }
2235 #line 2236 "parser.tab.c" /* yacc.c:1646 */
2236  break;
2237 
2238  case 54:
2239 #line 399 "parser.y" /* yacc.c:1646 */
2240  { (yyval.statement) = new_while_statement(ctx, TRUE, (yyvsp[-2].expr), (yyvsp[-5].statement)); }
2241 #line 2242 "parser.tab.c" /* yacc.c:1646 */
2242  break;
2243 
2244  case 55:
2245 #line 401 "parser.y" /* yacc.c:1646 */
2246  { (yyval.statement) = new_while_statement(ctx, FALSE, (yyvsp[-2].expr), (yyvsp[0].statement)); }
2247 #line 2248 "parser.tab.c" /* yacc.c:1646 */
2248  break;
2249 
2250  case 56:
2251 #line 403 "parser.y" /* yacc.c:1646 */
2252  { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
2253 #line 2254 "parser.tab.c" /* yacc.c:1646 */
2254  break;
2255 
2256  case 57:
2257 #line 405 "parser.y" /* yacc.c:1646 */
2258  { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
2259 #line 2260 "parser.tab.c" /* yacc.c:1646 */
2260  break;
2261 
2262  case 58:
2263 #line 407 "parser.y" /* yacc.c:1646 */
2264  { (yyval.statement) = new_for_statement(ctx, NULL, (yyvsp[-8].expr), (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
2265 #line 2266 "parser.tab.c" /* yacc.c:1646 */
2266  break;
2267 
2268  case 59:
2269 #line 409 "parser.y" /* yacc.c:1646 */
2270  { if(!explicit_error(ctx, (yyvsp[0].variable_list), ';')) YYABORT; }
2271 #line 2272 "parser.tab.c" /* yacc.c:1646 */
2272  break;
2273 
2274  case 60:
2275 #line 411 "parser.y" /* yacc.c:1646 */
2276  { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
2277 #line 2278 "parser.tab.c" /* yacc.c:1646 */
2278  break;
2279 
2280  case 61:
2281 #line 413 "parser.y" /* yacc.c:1646 */
2282  { (yyval.statement) = new_for_statement(ctx, (yyvsp[-8].variable_list), NULL, (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
2283 #line 2284 "parser.tab.c" /* yacc.c:1646 */
2284  break;
2285 
2286  case 62:
2287 #line 415 "parser.y" /* yacc.c:1646 */
2288  { (yyval.statement) = new_forin_statement(ctx, NULL, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
2289 #line 2290 "parser.tab.c" /* yacc.c:1646 */
2290  break;
2291 
2292  case 63:
2293 #line 417 "parser.y" /* yacc.c:1646 */
2294  { (yyval.statement) = new_forin_statement(ctx, (yyvsp[-4].variable_declaration), NULL, (yyvsp[-2].expr), (yyvsp[0].statement)); }
2295 #line 2296 "parser.tab.c" /* yacc.c:1646 */
2296  break;
2297 
2298  case 64:
2299 #line 422 "parser.y" /* yacc.c:1646 */
2300  { (yyval.statement) = new_continue_statement(ctx, (yyvsp[-1].identifier)); }
2301 #line 2302 "parser.tab.c" /* yacc.c:1646 */
2302  break;
2303 
2304  case 65:
2305 #line 427 "parser.y" /* yacc.c:1646 */
2306  { (yyval.statement) = new_break_statement(ctx, (yyvsp[-1].identifier)); }
2307 #line 2308 "parser.tab.c" /* yacc.c:1646 */
2308  break;
2309 
2310  case 66:
2311 #line 432 "parser.y" /* yacc.c:1646 */
2312  { (yyval.statement) = new_return_statement(ctx, (yyvsp[-1].expr)); }
2313 #line 2314 "parser.tab.c" /* yacc.c:1646 */
2314  break;
2315 
2316  case 67:
2317 #line 437 "parser.y" /* yacc.c:1646 */
2318  { (yyval.statement) = new_with_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement)); }
2319 #line 2320 "parser.tab.c" /* yacc.c:1646 */
2320  break;
2321 
2322  case 68:
2323 #line 442 "parser.y" /* yacc.c:1646 */
2324  { (yyval.statement) = new_labelled_statement(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); }
2325 #line 2326 "parser.tab.c" /* yacc.c:1646 */
2326  break;
2327 
2328  case 69:
2329 #line 447 "parser.y" /* yacc.c:1646 */
2330  { (yyval.statement) = new_switch_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].case_clausule)); }
2331 #line 2332 "parser.tab.c" /* yacc.c:1646 */
2332  break;
2333 
2334  case 70:
2335 #line 452 "parser.y" /* yacc.c:1646 */
2336  { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-1].case_list), NULL, NULL); }
2337 #line 2338 "parser.tab.c" /* yacc.c:1646 */
2338  break;
2339 
2340  case 71:
2341 #line 454 "parser.y" /* yacc.c:1646 */
2342  { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-3].case_list), (yyvsp[-2].case_clausule), (yyvsp[-1].case_list)); }
2343 #line 2344 "parser.tab.c" /* yacc.c:1646 */
2344  break;
2345 
2346  case 72:
2347 #line 458 "parser.y" /* yacc.c:1646 */
2348  { (yyval.case_list) = NULL; }
2349 #line 2350 "parser.tab.c" /* yacc.c:1646 */
2350  break;
2351 
2352  case 73:
2353 #line 459 "parser.y" /* yacc.c:1646 */
2354  { (yyval.case_list) = (yyvsp[0].case_list); }
2355 #line 2356 "parser.tab.c" /* yacc.c:1646 */
2356  break;
2357 
2358  case 74:
2359 #line 463 "parser.y" /* yacc.c:1646 */
2360  { (yyval.case_list) = new_case_list(ctx, (yyvsp[0].case_clausule)); }
2361 #line 2362 "parser.tab.c" /* yacc.c:1646 */
2362  break;
2363 
2364  case 75:
2365 #line 465 "parser.y" /* yacc.c:1646 */
2366  { (yyval.case_list) = case_list_add(ctx, (yyvsp[-1].case_list), (yyvsp[0].case_clausule)); }
2367 #line 2368 "parser.tab.c" /* yacc.c:1646 */
2368  break;
2369 
2370  case 76:
2371 #line 470 "parser.y" /* yacc.c:1646 */
2372  { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[-2].expr), (yyvsp[0].statement_list)); }
2373 #line 2374 "parser.tab.c" /* yacc.c:1646 */
2374  break;
2375 
2376  case 77:
2377 #line 475 "parser.y" /* yacc.c:1646 */
2378  { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[0].statement_list)); }
2379 #line 2380 "parser.tab.c" /* yacc.c:1646 */
2380  break;
2381 
2382  case 78:
2383 #line 480 "parser.y" /* yacc.c:1646 */
2384  { (yyval.statement) = new_throw_statement(ctx, (yyvsp[-1].expr)); }
2385 #line 2386 "parser.tab.c" /* yacc.c:1646 */
2386  break;
2387 
2388  case 79:
2389 #line 484 "parser.y" /* yacc.c:1646 */
2390  { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), (yyvsp[0].catch_block), NULL); }
2391 #line 2392 "parser.tab.c" /* yacc.c:1646 */
2392  break;
2393 
2394  case 80:
2395 #line 485 "parser.y" /* yacc.c:1646 */
2396  { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), NULL, (yyvsp[0].statement)); }
2397 #line 2398 "parser.tab.c" /* yacc.c:1646 */
2398  break;
2399 
2400  case 81:
2401 #line 487 "parser.y" /* yacc.c:1646 */
2402  { (yyval.statement) = new_try_statement(ctx, (yyvsp[-2].statement), (yyvsp[-1].catch_block), (yyvsp[0].statement)); }
2403 #line 2404 "parser.tab.c" /* yacc.c:1646 */
2404  break;
2405 
2406  case 82:
2407 #line 492 "parser.y" /* yacc.c:1646 */
2408  { (yyval.catch_block) = new_catch_block(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); }
2409 #line 2410 "parser.tab.c" /* yacc.c:1646 */
2410  break;
2411 
2412  case 83:
2413 #line 496 "parser.y" /* yacc.c:1646 */
2414  { (yyval.statement) = (yyvsp[0].statement); }
2415 #line 2416 "parser.tab.c" /* yacc.c:1646 */
2416  break;
2417 
2418  case 84:
2419 #line 500 "parser.y" /* yacc.c:1646 */
2420  { (yyval.expr) = NULL; }
2421 #line 2422 "parser.tab.c" /* yacc.c:1646 */
2422  break;
2423 
2424  case 85:
2425 #line 501 "parser.y" /* yacc.c:1646 */
2426  { (yyval.expr) = (yyvsp[0].expr); }
2427 #line 2428 "parser.tab.c" /* yacc.c:1646 */
2428  break;
2429 
2430  case 86:
2431 #line 504 "parser.y" /* yacc.c:1646 */
2432  { (yyval.expr) = (yyvsp[0].expr); }
2433 #line 2434 "parser.tab.c" /* yacc.c:1646 */
2434  break;
2435 
2436  case 87:
2437 #line 505 "parser.y" /* yacc.c:1646 */
2438  { set_error(ctx, JS_E_SYNTAX); YYABORT; }
2439 #line 2440 "parser.tab.c" /* yacc.c:1646 */
2440  break;
2441 
2442  case 88:
2443 #line 509 "parser.y" /* yacc.c:1646 */
2444  { (yyval.expr) = (yyvsp[0].expr); }
2445 #line 2446 "parser.tab.c" /* yacc.c:1646 */
2446  break;
2447 
2448  case 89:
2449 #line 511 "parser.y" /* yacc.c:1646 */
2450  { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2451 #line 2452 "parser.tab.c" /* yacc.c:1646 */
2452  break;
2453 
2454  case 90:
2455 #line 515 "parser.y" /* yacc.c:1646 */
2456  { (yyval.expr) = NULL; }
2457 #line 2458 "parser.tab.c" /* yacc.c:1646 */
2458  break;
2459 
2460  case 91:
2461 #line 516 "parser.y" /* yacc.c:1646 */
2462  { (yyval.expr) = (yyvsp[0].expr); }
2463 #line 2464 "parser.tab.c" /* yacc.c:1646 */
2464  break;
2465 
2466  case 92:
2467 #line 521 "parser.y" /* yacc.c:1646 */
2468  { (yyval.expr) = (yyvsp[0].expr); }
2469 #line 2470 "parser.tab.c" /* yacc.c:1646 */
2470  break;
2471 
2472  case 93:
2473 #line 523 "parser.y" /* yacc.c:1646 */
2474  { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2475 #line 2476 "parser.tab.c" /* yacc.c:1646 */
2476  break;
2477 
2478  case 94:
2479 #line 526 "parser.y" /* yacc.c:1646 */
2480  { (yyval.ival) = (yyvsp[0].ival); }
2481 #line 2482 "parser.tab.c" /* yacc.c:1646 */
2482  break;
2483 
2484  case 95:
2485 #line 527 "parser.y" /* yacc.c:1646 */
2486  { (yyval.ival) = EXPR_ASSIGNDIV; }
2487 #line 2488 "parser.tab.c" /* yacc.c:1646 */
2488  break;
2489 
2490  case 96:
2491 #line 531 "parser.y" /* yacc.c:1646 */
2492  { (yyval.expr) = (yyvsp[0].expr); }
2493 #line 2494 "parser.tab.c" /* yacc.c:1646 */
2494  break;
2495 
2496  case 97:
2497 #line 533 "parser.y" /* yacc.c:1646 */
2498  { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2499 #line 2500 "parser.tab.c" /* yacc.c:1646 */
2500  break;
2501 
2502  case 98:
2503 #line 535 "parser.y" /* yacc.c:1646 */
2504  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2505 #line 2506 "parser.tab.c" /* yacc.c:1646 */
2506  break;
2507 
2508  case 99:
2509 #line 540 "parser.y" /* yacc.c:1646 */
2510  { (yyval.expr) = (yyvsp[0].expr); }
2511 #line 2512 "parser.tab.c" /* yacc.c:1646 */
2512  break;
2513 
2514  case 100:
2515 #line 542 "parser.y" /* yacc.c:1646 */
2516  { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2517 #line 2518 "parser.tab.c" /* yacc.c:1646 */
2518  break;
2519 
2520  case 101:
2521 #line 544 "parser.y" /* yacc.c:1646 */
2522  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2523 #line 2524 "parser.tab.c" /* yacc.c:1646 */
2524  break;
2525 
2526  case 102:
2527 #line 548 "parser.y" /* yacc.c:1646 */
2528  { (yyval.expr) = (yyvsp[0].expr); }
2529 #line 2530 "parser.tab.c" /* yacc.c:1646 */
2530  break;
2531 
2532  case 103:
2533 #line 550 "parser.y" /* yacc.c:1646 */
2534  { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2535 #line 2536 "parser.tab.c" /* yacc.c:1646 */
2536  break;
2537 
2538  case 104:
2539 #line 555 "parser.y" /* yacc.c:1646 */
2540  { (yyval.expr) = (yyvsp[0].expr); }
2541 #line 2542 "parser.tab.c" /* yacc.c:1646 */
2542  break;
2543 
2544  case 105:
2545 #line 557 "parser.y" /* yacc.c:1646 */
2546  { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2547 #line 2548 "parser.tab.c" /* yacc.c:1646 */
2548  break;
2549 
2550  case 106:
2551 #line 561 "parser.y" /* yacc.c:1646 */
2552  { (yyval.expr) = (yyvsp[0].expr); }
2553 #line 2554 "parser.tab.c" /* yacc.c:1646 */
2554  break;
2555 
2556  case 107:
2557 #line 563 "parser.y" /* yacc.c:1646 */
2558  { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2559 #line 2560 "parser.tab.c" /* yacc.c:1646 */
2560  break;
2561 
2562  case 108:
2563 #line 568 "parser.y" /* yacc.c:1646 */
2564  { (yyval.expr) = (yyvsp[0].expr); }
2565 #line 2566 "parser.tab.c" /* yacc.c:1646 */
2566  break;
2567 
2568  case 109:
2569 #line 570 "parser.y" /* yacc.c:1646 */
2570  { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2571 #line 2572 "parser.tab.c" /* yacc.c:1646 */
2572  break;
2573 
2574  case 110:
2575 #line 574 "parser.y" /* yacc.c:1646 */
2576  { (yyval.expr) = (yyvsp[0].expr); }
2577 #line 2578 "parser.tab.c" /* yacc.c:1646 */
2578  break;
2579 
2580  case 111:
2581 #line 576 "parser.y" /* yacc.c:1646 */
2582  { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2583 #line 2584 "parser.tab.c" /* yacc.c:1646 */
2584  break;
2585 
2586  case 112:
2587 #line 581 "parser.y" /* yacc.c:1646 */
2588  { (yyval.expr) = (yyvsp[0].expr); }
2589 #line 2590 "parser.tab.c" /* yacc.c:1646 */
2590  break;
2591 
2592  case 113:
2593 #line 583 "parser.y" /* yacc.c:1646 */
2594  { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2595 #line 2596 "parser.tab.c" /* yacc.c:1646 */
2596  break;
2597 
2598  case 114:
2599 #line 587 "parser.y" /* yacc.c:1646 */
2600  { (yyval.expr) = (yyvsp[0].expr); }
2601 #line 2602 "parser.tab.c" /* yacc.c:1646 */
2602  break;
2603 
2604  case 115:
2605 #line 589 "parser.y" /* yacc.c:1646 */
2606  { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2607 #line 2608 "parser.tab.c" /* yacc.c:1646 */
2608  break;
2609 
2610  case 116:
2611 #line 594 "parser.y" /* yacc.c:1646 */
2612  { (yyval.expr) = (yyvsp[0].expr); }
2613 #line 2614 "parser.tab.c" /* yacc.c:1646 */
2614  break;
2615 
2616  case 117:
2617 #line 596 "parser.y" /* yacc.c:1646 */
2618  { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2619 #line 2620 "parser.tab.c" /* yacc.c:1646 */
2620  break;
2621 
2622  case 118:
2623 #line 600 "parser.y" /* yacc.c:1646 */
2624  { (yyval.expr) = (yyvsp[0].expr); }
2625 #line 2626 "parser.tab.c" /* yacc.c:1646 */
2626  break;
2627 
2628  case 119:
2629 #line 602 "parser.y" /* yacc.c:1646 */
2630  { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2631 #line 2632 "parser.tab.c" /* yacc.c:1646 */
2632  break;
2633 
2634  case 120:
2635 #line 607 "parser.y" /* yacc.c:1646 */
2636  { (yyval.expr) = (yyvsp[0].expr); }
2637 #line 2638 "parser.tab.c" /* yacc.c:1646 */
2638  break;
2639 
2640  case 121:
2641 #line 609 "parser.y" /* yacc.c:1646 */
2642  { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2643 #line 2644 "parser.tab.c" /* yacc.c:1646 */
2644  break;
2645 
2646  case 122:
2647 #line 613 "parser.y" /* yacc.c:1646 */
2648  { (yyval.expr) = (yyvsp[0].expr); }
2649 #line 2650 "parser.tab.c" /* yacc.c:1646 */
2650  break;
2651 
2652  case 123:
2653 #line 615 "parser.y" /* yacc.c:1646 */
2654  { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2655 #line 2656 "parser.tab.c" /* yacc.c:1646 */
2656  break;
2657 
2658  case 124:
2659 #line 620 "parser.y" /* yacc.c:1646 */
2660  { (yyval.expr) = (yyvsp[0].expr); }
2661 #line 2662 "parser.tab.c" /* yacc.c:1646 */
2662  break;
2663 
2664  case 125:
2665 #line 622 "parser.y" /* yacc.c:1646 */
2666  { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2667 #line 2668 "parser.tab.c" /* yacc.c:1646 */
2668  break;
2669 
2670  case 126:
2671 #line 626 "parser.y" /* yacc.c:1646 */
2672  { (yyval.expr) = (yyvsp[0].expr); }
2673 #line 2674 "parser.tab.c" /* yacc.c:1646 */
2674  break;
2675 
2676  case 127:
2677 #line 628 "parser.y" /* yacc.c:1646 */
2678  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2679 #line 2680 "parser.tab.c" /* yacc.c:1646 */
2680  break;
2681 
2682  case 128:
2683 #line 632 "parser.y" /* yacc.c:1646 */
2684  { (yyval.expr) = (yyvsp[0].expr); }
2685 #line 2686 "parser.tab.c" /* yacc.c:1646 */
2686  break;
2687 
2688  case 129:
2689 #line 634 "parser.y" /* yacc.c:1646 */
2690  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2691 #line 2692 "parser.tab.c" /* yacc.c:1646 */
2692  break;
2693 
2694  case 130:
2695 #line 638 "parser.y" /* yacc.c:1646 */
2696  { (yyval.expr) = (yyvsp[0].expr); }
2697 #line 2698 "parser.tab.c" /* yacc.c:1646 */
2698  break;
2699 
2700  case 131:
2701 #line 640 "parser.y" /* yacc.c:1646 */
2702  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2703 #line 2704 "parser.tab.c" /* yacc.c:1646 */
2704  break;
2705 
2706  case 132:
2707 #line 642 "parser.y" /* yacc.c:1646 */
2708  { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2709 #line 2710 "parser.tab.c" /* yacc.c:1646 */
2710  break;
2711 
2712  case 133:
2713 #line 644 "parser.y" /* yacc.c:1646 */
2714  { (yyval.expr) = new_binary_expression(ctx, EXPR_IN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2715 #line 2716 "parser.tab.c" /* yacc.c:1646 */
2716  break;
2717 
2718  case 134:
2719 #line 648 "parser.y" /* yacc.c:1646 */
2720  { (yyval.expr) = (yyvsp[0].expr); }
2721 #line 2722 "parser.tab.c" /* yacc.c:1646 */
2722  break;
2723 
2724  case 135:
2725 #line 650 "parser.y" /* yacc.c:1646 */
2726  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2727 #line 2728 "parser.tab.c" /* yacc.c:1646 */
2728  break;
2729 
2730  case 136:
2731 #line 652 "parser.y" /* yacc.c:1646 */
2732  { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2733 #line 2734 "parser.tab.c" /* yacc.c:1646 */
2734  break;
2735 
2736  case 137:
2737 #line 656 "parser.y" /* yacc.c:1646 */
2738  { (yyval.expr) = (yyvsp[0].expr); }
2739 #line 2740 "parser.tab.c" /* yacc.c:1646 */
2740  break;
2741 
2742  case 138:
2743 #line 658 "parser.y" /* yacc.c:1646 */
2744  { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
2745 #line 2746 "parser.tab.c" /* yacc.c:1646 */
2746  break;
2747 
2748  case 139:
2749 #line 663 "parser.y" /* yacc.c:1646 */
2750  { (yyval.expr) = (yyvsp[0].expr); }
2751 #line 2752 "parser.tab.c" /* yacc.c:1646 */
2752  break;
2753 
2754  case 140:
2755 #line 665 "parser.y" /* yacc.c:1646 */
2756  { (yyval.expr) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2757 #line 2758 "parser.tab.c" /* yacc.c:1646 */
2758  break;
2759 
2760  case 141:
2761 #line 667 "parser.y" /* yacc.c:1646 */
2762  { (yyval.expr) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2763 #line 2764 "parser.tab.c" /* yacc.c:1646 */
2764  break;
2765 
2766  case 142:
2767 #line 671 "parser.y" /* yacc.c:1646 */
2768  { (yyval.expr) = (yyvsp[0].expr); }
2769 #line 2770 "parser.tab.c" /* yacc.c:1646 */
2770  break;
2771 
2772  case 143:
2773 #line 673 "parser.y" /* yacc.c:1646 */
2774  { (yyval.expr) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2775 #line 2776 "parser.tab.c" /* yacc.c:1646 */
2776  break;
2777 
2778  case 144:
2779 #line 675 "parser.y" /* yacc.c:1646 */
2780  { (yyval.expr) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2781 #line 2782 "parser.tab.c" /* yacc.c:1646 */
2782  break;
2783 
2784  case 145:
2785 #line 677 "parser.y" /* yacc.c:1646 */
2786  { (yyval.expr) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
2787 #line 2788 "parser.tab.c" /* yacc.c:1646 */
2788  break;
2789 
2790  case 146:
2791 #line 681 "parser.y" /* yacc.c:1646 */
2792  { (yyval.expr) = (yyvsp[0].expr); }
2793 #line 2794 "parser.tab.c" /* yacc.c:1646 */
2794  break;
2795 
2796  case 147:
2797 #line 683 "parser.y" /* yacc.c:1646 */
2798  { (yyval.expr) = new_unary_expression(ctx, EXPR_DELETE, (yyvsp[0].expr)); }
2799 #line 2800 "parser.tab.c" /* yacc.c:1646 */
2800  break;
2801 
2802  case 148:
2803 #line 684 "parser.y" /* yacc.c:1646 */
2804  { (yyval.expr) = new_unary_expression(ctx, EXPR_VOID, (yyvsp[0].expr)); }
2805 #line 2806 "parser.tab.c" /* yacc.c:1646 */
2806  break;
2807 
2808  case 149:
2809 #line 686 "parser.y" /* yacc.c:1646 */
2810  { (yyval.expr) = new_unary_expression(ctx, EXPR_TYPEOF, (yyvsp[0].expr)); }
2811 #line 2812 "parser.tab.c" /* yacc.c:1646 */
2812  break;
2813 
2814  case 150:
2815 #line 687 "parser.y" /* yacc.c:1646 */
2816  { (yyval.expr) = new_unary_expression(ctx, EXPR_PREINC, (yyvsp[0].expr)); }
2817 #line 2818 "parser.tab.c" /* yacc.c:1646 */
2818  break;
2819 
2820  case 151:
2821 #line 688 "parser.y" /* yacc.c:1646 */
2822  { (yyval.expr) = new_unary_expression(ctx, EXPR_PREDEC, (yyvsp[0].expr)); }
2823 #line 2824 "parser.tab.c" /* yacc.c:1646 */
2824  break;
2825 
2826  case 152:
2827 #line 689 "parser.y" /* yacc.c:1646 */
2828  { (yyval.expr) = new_unary_expression(ctx, EXPR_PLUS, (yyvsp[0].expr)); }
2829 #line 2830 "parser.tab.c" /* yacc.c:1646 */
2830  break;
2831 
2832  case 153:
2833 #line 690 "parser.y" /* yacc.c:1646 */
2834  { (yyval.expr) = new_unary_expression(ctx, EXPR_MINUS, (yyvsp[0].expr)); }
2835 #line 2836 "parser.tab.c" /* yacc.c:1646 */
2836  break;
2837 
2838  case 154:
2839 #line 691 "parser.y" /* yacc.c:1646 */
2840  { (yyval.expr) = new_unary_expression(ctx, EXPR_BITNEG, (yyvsp[0].expr)); }
2841 #line 2842 "parser.tab.c" /* yacc.c:1646 */
2842  break;
2843 
2844  case 155:
2845 #line 692 "parser.y" /* yacc.c:1646 */
2846  { (yyval.expr) = new_unary_expression(ctx, EXPR_LOGNEG, (yyvsp[0].expr)); }
2847 #line 2848 "parser.tab.c" /* yacc.c:1646 */
2848  break;
2849 
2850  case 156:
2851 #line 697 "parser.y" /* yacc.c:1646 */
2852  { (yyval.expr) = (yyvsp[0].expr); }
2853 #line 2854 "parser.tab.c" /* yacc.c:1646 */
2854  break;
2855 
2856  case 157:
2857 #line 699 "parser.y" /* yacc.c:1646 */
2858  { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTINC, (yyvsp[-1].expr)); }
2859 #line 2860 "parser.tab.c" /* yacc.c:1646 */
2860  break;
2861 
2862  case 158:
2863 #line 701 "parser.y" /* yacc.c:1646 */
2864  { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTDEC, (yyvsp[-1].expr)); }
2865 #line 2866 "parser.tab.c" /* yacc.c:1646 */
2866  break;
2867 
2868  case 159:
2869 #line 706 "parser.y" /* yacc.c:1646 */
2870  { (yyval.expr) = (yyvsp[0].expr); }
2871 #line 2872 "parser.tab.c" /* yacc.c:1646 */
2872  break;
2873 
2874  case 160:
2875 #line 707 "parser.y" /* yacc.c:1646 */
2876  { (yyval.expr) = (yyvsp[0].expr); }
2877 #line 2878 "parser.tab.c" /* yacc.c:1646 */
2878  break;
2879 
2880  case 161:
2881 #line 711 "parser.y" /* yacc.c:1646 */
2882  { (yyval.expr) = (yyvsp[0].expr); }
2883 #line 2884 "parser.tab.c" /* yacc.c:1646 */
2884  break;
2885 
2886  case 162:
2887 #line 712 "parser.y" /* yacc.c:1646 */
2888  { (yyval.expr) = new_new_expression(ctx, (yyvsp[0].expr), NULL); }
2889 #line 2890 "parser.tab.c" /* yacc.c:1646 */
2890  break;
2891 
2892  case 163:
2893 #line 716 "parser.y" /* yacc.c:1646 */
2894  { (yyval.expr) = (yyvsp[0].expr); }
2895 #line 2896 "parser.tab.c" /* yacc.c:1646 */
2896  break;
2897 
2898  case 164:
2899 #line 717 "parser.y" /* yacc.c:1646 */
2900  { (yyval.expr) = (yyvsp[0].expr); }
2901 #line 2902 "parser.tab.c" /* yacc.c:1646 */
2902  break;
2903 
2904  case 165:
2905 #line 719 "parser.y" /* yacc.c:1646 */
2906  { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); }
2907 #line 2908 "parser.tab.c" /* yacc.c:1646 */
2908  break;
2909 
2910  case 166:
2911 #line 721 "parser.y" /* yacc.c:1646 */
2912  { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); }
2913 #line 2914 "parser.tab.c" /* yacc.c:1646 */
2914  break;
2915 
2916  case 167:
2917 #line 723 "parser.y" /* yacc.c:1646 */
2918  { (yyval.expr) = new_new_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
2919 #line 2920 "parser.tab.c" /* yacc.c:1646 */
2920  break;
2921 
2922  case 168:
2923 #line 728 "parser.y" /* yacc.c:1646 */
2924  { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
2925 #line 2926 "parser.tab.c" /* yacc.c:1646 */
2926  break;
2927 
2928  case 169:
2929 #line 730 "parser.y" /* yacc.c:1646 */
2930  { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
2931 #line 2932 "parser.tab.c" /* yacc.c:1646 */
2932  break;
2933 
2934  case 170:
2935 #line 732 "parser.y" /* yacc.c:1646 */
2936  { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); }
2937 #line 2938 "parser.tab.c" /* yacc.c:1646 */
2938  break;
2939 
2940  case 171:
2941 #line 734 "parser.y" /* yacc.c:1646 */
2942  { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); }
2943 #line 2944 "parser.tab.c" /* yacc.c:1646 */
2944  break;
2945 
2946  case 172:
2947 #line 738 "parser.y" /* yacc.c:1646 */
2948  { (yyval.argument_list) = NULL; }
2949 #line 2950 "parser.tab.c" /* yacc.c:1646 */
2950  break;
2951 
2952  case 173:
2953 #line 739 "parser.y" /* yacc.c:1646 */
2954  { (yyval.argument_list) = (yyvsp[-1].argument_list); }
2955 #line 2956 "parser.tab.c" /* yacc.c:1646 */
2956  break;
2957 
2958  case 174:
2959 #line 743 "parser.y" /* yacc.c:1646 */
2960  { (yyval.argument_list) = new_argument_list(ctx, (yyvsp[0].expr)); }
2961 #line 2962 "parser.tab.c" /* yacc.c:1646 */
2962  break;
2963 
2964  case 175:
2965 #line 745 "parser.y" /* yacc.c:1646 */
2966  { (yyval.argument_list) = argument_list_add(ctx, (yyvsp[-2].argument_list), (yyvsp[0].expr)); }
2967 #line 2968 "parser.tab.c" /* yacc.c:1646 */
2968  break;
2969 
2970  case 176:
2971 #line 749 "parser.y" /* yacc.c:1646 */
2972  { (yyval.expr) = new_expression(ctx, EXPR_THIS, 0); }
2973 #line 2974 "parser.tab.c" /* yacc.c:1646 */
2974  break;
2975 
2976  case 177:
2977 #line 750 "parser.y" /* yacc.c:1646 */
2978  { (yyval.expr) = new_identifier_expression(ctx, (yyvsp[0].identifier)); }
2979 #line 2980 "parser.tab.c" /* yacc.c:1646 */
2980  break;
2981 
2982  case 178:
2983 #line 751 "parser.y" /* yacc.c:1646 */
2984  { (yyval.expr) = new_literal_expression(ctx, (yyvsp[0].literal)); }
2985 #line 2986 "parser.tab.c" /* yacc.c:1646 */
2986  break;
2987 
2988  case 179:
2989 #line 752 "parser.y" /* yacc.c:1646 */
2990  { (yyval.expr) = (yyvsp[0].expr); }
2991 #line 2992 "parser.tab.c" /* yacc.c:1646 */
2992  break;
2993 
2994  case 180:
2995 #line 753 "parser.y" /* yacc.c:1646 */
2996  { (yyval.expr) = (yyvsp[0].expr); }
2997 #line 2998 "parser.tab.c" /* yacc.c:1646 */
2998  break;
2999 
3000  case 181:
3001 #line 754 "parser.y" /* yacc.c:1646 */
3002  { (yyval.expr) = (yyvsp[-1].expr); }
3003 #line 3004 "parser.tab.c" /* yacc.c:1646 */
3004  break;
3005 
3006  case 182:
3007 #line 758 "parser.y" /* yacc.c:1646 */
3008  { (yyval.expr) = new_array_literal_expression(ctx, NULL, 0); }
3009 #line 3010 "parser.tab.c" /* yacc.c:1646 */
3010  break;
3011 
3012  case 183:
3013 #line 759 "parser.y" /* yacc.c:1646 */
3014  { (yyval.expr) = new_array_literal_expression(ctx, NULL, (yyvsp[-1].ival)+1); }
3015 #line 3016 "parser.tab.c" /* yacc.c:1646 */
3016  break;
3017 
3018  case 184:
3019 #line 760 "parser.y" /* yacc.c:1646 */
3020  { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-1].element_list), 0); }
3021 #line 3022 "parser.tab.c" /* yacc.c:1646 */
3022  break;
3023 
3024  case 185:
3025 #line 762 "parser.y" /* yacc.c:1646 */
3026  { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival)+1); }
3027 #line 3028 "parser.tab.c" /* yacc.c:1646 */
3028  break;
3029 
3030  case 186:
3031 #line 767 "parser.y" /* yacc.c:1646 */
3032  { (yyval.element_list) = new_element_list(ctx, (yyvsp[-1].ival), (yyvsp[0].expr)); }
3033 #line 3034 "parser.tab.c" /* yacc.c:1646 */
3034  break;
3035 
3036  case 187:
3037 #line 769 "parser.y" /* yacc.c:1646 */
3038  { (yyval.element_list) = element_list_add(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival), (yyvsp[0].expr)); }
3039 #line 3040 "parser.tab.c" /* yacc.c:1646 */
3040  break;
3041 
3042  case 188:
3043 #line 773 "parser.y" /* yacc.c:1646 */
3044  { (yyval.ival) = 1; }
3045 #line 3046 "parser.tab.c" /* yacc.c:1646 */
3046  break;
3047 
3048  case 189:
3049 #line 774 "parser.y" /* yacc.c:1646 */
3050  { (yyval.ival) = (yyvsp[-1].ival) + 1; }
3051 #line 3052 "parser.tab.c" /* yacc.c:1646 */
3052  break;
3053 
3054  case 190:
3055 #line 778 "parser.y" /* yacc.c:1646 */
3056  { (yyval.ival) = 0; }
3057 #line 3058 "parser.tab.c" /* yacc.c:1646 */
3058  break;
3059 
3060  case 191:
3061 #line 779 "parser.y" /* yacc.c:1646 */
3062  { (yyval.ival) = (yyvsp[0].ival); }
3063 #line 3064 "parser.tab.c" /* yacc.c:1646 */
3064  break;
3065 
3066  case 192:
3067 #line 783 "parser.y" /* yacc.c:1646 */
3068  { (yyval.expr) = new_prop_and_value_expression(ctx, NULL); }
3069 #line 3070 "parser.tab.c" /* yacc.c:1646 */
3070  break;
3071 
3072  case 193:
3073 #line 785 "parser.y" /* yacc.c:1646 */
3074  { (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-1].property_list)); }
3075 #line 3076 "parser.tab.c" /* yacc.c:1646 */
3076  break;
3077 
3078  case 194:
3079 #line 787 "parser.y" /* yacc.c:1646 */
3080  {
3081  if(ctx->script->version < 2) {
3082  WARN("Trailing comma in object literal is illegal in legacy mode.\n");
3083  YYABORT;
3084  }
3085  (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-2].property_list));
3086  }
3087 #line 3088 "parser.tab.c" /* yacc.c:1646 */
3088  break;
3089 
3090  case 195:
3091 #line 797 "parser.y" /* yacc.c:1646 */
3092  { (yyval.property_list) = new_property_list(ctx, (yyvsp[0].property_definition)); }
3093 #line 3094 "parser.tab.c" /* yacc.c:1646 */
3094  break;
3095 
3096  case 196:
3097 #line 799 "parser.y" /* yacc.c:1646 */
3098  { (yyval.property_list) = property_list_add(ctx, (yyvsp[-2].property_list), (yyvsp[0].property_definition)); }
3099 #line 3100 "parser.tab.c" /* yacc.c:1646 */
3100  break;
3101 
3102  case 197:
3103 #line 804 "parser.y" /* yacc.c:1646 */
3104  { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_VALUE, (yyvsp[-2].literal), (yyvsp[0].expr)); }
3105 #line 3106 "parser.tab.c" /* yacc.c:1646 */
3106  break;
3107 
3108  case 198:
3109 #line 806 "parser.y" /* yacc.c:1646 */
3110  { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_GETTER, (yyvsp[-1].literal), (yyvsp[0].expr)); }
3111 #line 3112 "parser.tab.c" /* yacc.c:1646 */
3112  break;
3113 
3114  case 199:
3115 #line 808 "parser.y" /* yacc.c:1646 */
3116  { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_SETTER, (yyvsp[-1].literal), (yyvsp[0].expr)); }
3117 #line 3118 "parser.tab.c" /* yacc.c:1646 */
3118  break;
3119 
3120  case 200:
3121 #line 812 "parser.y" /* yacc.c:1646 */
3122  { (yyval.expr) = new_function_expression(ctx, NULL, (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-5].srcptr), (yyvsp[0].srcptr)-(yyvsp[-5].srcptr)); }
3123 #line 3124 "parser.tab.c" /* yacc.c:1646 */
3124  break;
3125 
3126  case 201:
3127 #line 816 "parser.y" /* yacc.c:1646 */
3128  { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].identifier)); }
3129 #line 3130 "parser.tab.c" /* yacc.c:1646 */
3130  break;
3131 
3132  case 202:
3133 #line 817 "parser.y" /* yacc.c:1646 */
3134  { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); }
3135 #line 3136 "parser.tab.c" /* yacc.c:1646 */
3136  break;
3137 
3138  case 203:
3139 #line 818 "parser.y" /* yacc.c:1646 */
3140  { (yyval.literal) = (yyvsp[0].literal); }
3141 #line 3142 "parser.tab.c" /* yacc.c:1646 */
3142  break;
3143 
3144  case 204:
3145 #line 822 "parser.y" /* yacc.c:1646 */
3146  { (yyval.identifier) = NULL; }
3147 #line 3148 "parser.tab.c" /* yacc.c:1646 */
3148  break;
3149 
3150  case 205:
3151 #line 823 "parser.y" /* yacc.c:1646 */
3152  { (yyval.identifier) = (yyvsp[0].identifier); }
3153 #line 3154 "parser.tab.c" /* yacc.c:1646 */
3154  break;
3155 
3156  case 206:
3157 #line 827 "parser.y" /* yacc.c:1646 */
3158  { (yyval.identifier) = (yyvsp[0].identifier); }
3159 #line 3160 "parser.tab.c" /* yacc.c:1646 */
3160  break;
3161 
3162  case 207:
3163 #line 829 "parser.y" /* yacc.c:1646 */
3164  {
3165  if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
3166  WARN("%s keyword used as an identifier in legacy mode.\n",
3167  debugstr_w((yyvsp[0].identifier)));
3168  YYABORT;
3169  }
3170  (yyval.identifier) = (yyvsp[0].identifier);
3171  }
3172 #line 3173 "parser.tab.c" /* yacc.c:1646 */
3173  break;
3174 
3175  case 208:
3176 #line 839 "parser.y" /* yacc.c:1646 */
3177  { (yyval.identifier) = (yyvsp[0].identifier); }
3178 #line 3179 "parser.tab.c" /* yacc.c:1646 */
3179  break;
3180 
3181  case 209:
3182 #line 840 "parser.y" /* yacc.c:1646 */
3183  { (yyval.identifier) = (yyvsp[0].identifier); }
3184 #line 3185 "parser.tab.c" /* yacc.c:1646 */
3185  break;
3186 
3187  case 210:
3188 #line 841 "parser.y" /* yacc.c:1646 */
3189  { (yyval.identifier) = (yyvsp[0].identifier); }
3190 #line 3191 "parser.tab.c" /* yacc.c:1646 */
3191  break;
3192 
3193  case 211:
3194 #line 842 "parser.y" /* yacc.c:1646 */
3195  { (yyval.identifier) = (yyvsp[0].identifier); }
3196 #line 3197 "parser.tab.c" /* yacc.c:1646 */
3197  break;
3198 
3199  case 212:
3200 #line 843 "parser.y" /* yacc.c:1646 */
3201  { (yyval.identifier) = (yyvsp[0].identifier); }
3202 #line 3203 "parser.tab.c" /* yacc.c:1646 */
3203  break;
3204 
3205  case 213:
3206 #line 844 "parser.y" /* yacc.c:1646 */
3207  { (yyval.identifier) = (yyvsp[0].identifier); }
3208 #line 3209 "parser.tab.c" /* yacc.c:1646 */
3209  break;
3210 
3211  case 214:
3212 #line 845 "parser.y" /* yacc.c:1646 */
3213  { (yyval.identifier) = (yyvsp[0].identifier); }
3214 #line 3215 "parser.tab.c" /* yacc.c:1646 */
3215  break;
3216 
3217  case 215:
3218 #line 846 "parser.y" /* yacc.c:1646 */
3219  { (yyval.identifier) = (yyvsp[0].identifier); }
3220 #line 3221 "parser.tab.c" /* yacc.c:1646 */
3221  break;
3222 
3223  case 216:
3224 #line 847 "parser.y" /* yacc.c:1646 */
3225  { (yyval.identifier) = (yyvsp[0].identifier); }
3226 #line 3227 "parser.tab.c" /* yacc.c:1646 */
3227  break;
3228 
3229  case 217:
3230 #line 848 "parser.y" /* yacc.c:1646 */
3231  { (yyval.identifier) = (yyvsp[0].identifier); }
3232 #line 3233 "parser.tab.c" /* yacc.c:1646 */
3233  break;
3234 
3235  case 218:
3236 #line 849 "parser.y" /* yacc.c:1646 */
3237  { (yyval.identifier) = (yyvsp[0].identifier); }
3238 #line 3239 "parser.tab.c" /* yacc.c:1646 */
3239  break;
3240 
3241  case 219:
3242 #line 850 "parser.y" /* yacc.c:1646 */
3243  { (yyval.identifier) = (yyvsp[0].identifier); }
3244 #line 3245 "parser.tab.c" /* yacc.c:1646 */
3245  break;
3246 
3247  case 220:
3248 #line 851 "parser.y" /* yacc.c:1646 */
3249  { (yyval.identifier) = (yyvsp[0].identifier); }
3250 #line 3251 "parser.tab.c" /* yacc.c:1646 */
3251  break;
3252 
3253  case 221:
3254 #line 852 "parser.y" /* yacc.c:1646 */
3255  { (yyval.identifier) = (yyvsp[0].identifier); }
3256 #line 3257 "parser.tab.c" /* yacc.c:1646 */
3257  break;
3258 
3259  case 222:
3260 #line 853 "parser.y" /* yacc.c:1646 */
3261  { (yyval.identifier) = (yyvsp[0].identifier); }
3262 #line 3263 "parser.tab.c" /* yacc.c:1646 */
3263  break;
3264 
3265  case 223:
3266 #line 854 "parser.y" /* yacc.c:1646 */
3267  { (yyval.identifier) = (yyvsp[0].identifier); }
3268 #line 3269 "parser.tab.c" /* yacc.c:1646 */
3269  break;
3270 
3271  case 224:
3272 #line 855 "parser.y" /* yacc.c:1646 */
3273  { (yyval.identifier) = (yyvsp[0].identifier); }
3274 #line 3275 "parser.tab.c" /* yacc.c:1646 */
3275  break;
3276 
3277  case 225:
3278 #line 856 "parser.y" /* yacc.c:1646 */
3279  { (yyval.identifier) = (yyvsp[0].identifier); }
3280 #line 3281 "parser.tab.c" /* yacc.c:1646 */
3281  break;
3282 
3283  case 226:
3284 #line 857 "parser.y" /* yacc.c:1646 */
3285  { (yyval.identifier) = (yyvsp[0].identifier); }
3286 #line 3287 "parser.tab.c" /* yacc.c:1646 */
3287  break;
3288 
3289  case 227:
3290 #line 858 "parser.y" /* yacc.c:1646 */
3291  { (yyval.identifier) = (yyvsp[0].identifier); }
3292 #line 3293 "parser.tab.c" /* yacc.c:1646 */
3293  break;
3294 
3295  case 228:
3296 #line 859 "parser.y" /* yacc.c:1646 */
3297  { (yyval.identifier) = (yyvsp[0].identifier); }
3298 #line 3299 "parser.tab.c" /* yacc.c:1646 */
3299  break;
3300 
3301  case 229:
3302 #line 860 "parser.y" /* yacc.c:1646 */
3303  { (yyval.identifier) = (yyvsp[0].identifier); }
3304 #line 3305 "parser.tab.c" /* yacc.c:1646 */
3305  break;
3306 
3307  case 230:
3308 #line 861 "parser.y" /* yacc.c:1646 */
3309  { (yyval.identifier) = (yyvsp[0].identifier); }
3310 #line 3311 "parser.tab.c" /* yacc.c:1646 */
3311  break;
3312 
3313  case 231:
3314 #line 862 "parser.y" /* yacc.c:1646 */
3315  { (yyval.identifier) = (yyvsp[0].identifier); }
3316 #line 3317 "parser.tab.c" /* yacc.c:1646 */
3317  break;
3318 
3319  case 232:
3320 #line 863 "parser.y" /* yacc.c:1646 */
3321  { (yyval.identifier) = (yyvsp[0].identifier); }
3322 #line 3323 "parser.tab.c" /* yacc.c:1646 */
3323  break;
3324 
3325  case 233:
3326 #line 864 "parser.y" /* yacc.c:1646 */
3327  { (yyval.identifier) = (yyvsp[0].identifier); }
3328 #line 3329 "parser.tab.c" /* yacc.c:1646 */
3329  break;
3330 
3331  case 234:
3332 #line 865 "parser.y" /* yacc.c:1646 */
3333  { (yyval.identifier) = (yyvsp[0].identifier); }
3334 #line 3335 "parser.tab.c" /* yacc.c:1646 */
3335  break;
3336 
3337  case 235:
3338 #line 866 "parser.y" /* yacc.c:1646 */
3339  { (yyval.identifier) = (yyvsp[0].identifier); }
3340 #line 3341 "parser.tab.c" /* yacc.c:1646 */
3341  break;
3342 
3343  case 236:
3344 #line 867 "parser.y" /* yacc.c:1646 */
3345  { (yyval.identifier) = (yyvsp[0].identifier); }
3346 #line 3347 "parser.tab.c" /* yacc.c:1646 */
3347  break;
3348 
3349  case 237:
3350 #line 868 "parser.y" /* yacc.c:1646 */
3351  { (yyval.identifier) = (yyvsp[0].identifier); }
3352 #line 3353 "parser.tab.c" /* yacc.c:1646 */
3353  break;
3354 
3355  case 238:
3356 #line 872 "parser.y" /* yacc.c:1646 */
3357  { (yyval.literal) = new_null_literal(ctx); }
3358 #line 3359 "parser.tab.c" /* yacc.c:1646 */
3359  break;
3360 
3361  case 239:
3362 #line 873 "parser.y" /* yacc.c:1646 */
3363  { (yyval.literal) = (yyvsp[0].literal); }
3364 #line 3365 "parser.tab.c" /* yacc.c:1646 */
3365  break;
3366 
3367  case 240:
3368 #line 874 "parser.y" /* yacc.c:1646 */
3369  { (yyval.literal) = (yyvsp[0].literal); }
3370 #line 3371 "parser.tab.c" /* yacc.c:1646 */
3371  break;
3372 
3373  case 241:
3374 #line 875 "parser.y" /* yacc.c:1646 */
3375  { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); }
3376 #line 3377 "parser.tab.c" /* yacc.c:1646 */
3377  break;
3378 
3379  case 242:
3380 #line 876 "parser.y" /* yacc.c:1646 */
3381  { (yyval.literal) = parse_regexp(ctx);
3382  if(!(yyval.literal)) YYABORT; }
3383 #line 3384 "parser.tab.c" /* yacc.c:1646 */
3384  break;
3385 
3386  case 243:
3387 #line 878 "parser.y" /* yacc.c:1646 */
3388  { (yyval.literal) = parse_regexp(ctx);
3389  if(!(yyval.literal)) YYABORT; }
3390 #line 3391 "parser.tab.c" /* yacc.c:1646 */
3391  break;
3392 
3393  case 244:
3394 #line 883 "parser.y" /* yacc.c:1646 */
3395  { (yyval.literal) = new_boolean_literal(ctx, VARIANT_TRUE); }
3396 #line 3397 "parser.tab.c" /* yacc.c:1646 */
3397  break;
3398 
3399  case 245:
3400 #line 884 "parser.y" /* yacc.c:1646 */
3401  { (yyval.literal) = new_boolean_literal(ctx, VARIANT_FALSE); }
3402 #line 3403 "parser.tab.c" /* yacc.c:1646 */
3403  break;
3404 
3405  case 246:
3406 #line 885 "parser.y" /* yacc.c:1646 */
3407  { (yyval.literal) = (yyvsp[0].literal); }
3408 #line 3409 "parser.tab.c" /* yacc.c:1646 */
3409  break;
3410 
3411  case 248:
3412 #line 889 "parser.y" /* yacc.c:1646 */
3413  { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
3414 #line 3415 "parser.tab.c" /* yacc.c:1646 */
3415  break;
3416 
3417  case 249:
3418 #line 892 "parser.y" /* yacc.c:1646 */
3419  { (yyval.srcptr) = ctx->ptr; }
3420 #line 3421 "parser.tab.c" /* yacc.c:1646 */
3421  break;
3422 
3423  case 250:
3424 #line 893 "parser.y" /* yacc.c:1646 */
3426 #line 3427 "parser.tab.c" /* yacc.c:1646 */
3427  break;
3428 
3429  case 252:
3430 #line 897 "parser.y" /* yacc.c:1646 */
3432 #line 3433 "parser.tab.c" /* yacc.c:1646 */
3433  break;
3434 
3435  case 254:
3436 #line 901 "parser.y" /* yacc.c:1646 */
3438 #line 3439 "parser.tab.c" /* yacc.c:1646 */
3439  break;
3440 
3441 
3442 #line 3443 "parser.tab.c" /* yacc.c:1646 */
3443  default: break;
3444  }
3445  /* User semantic actions sometimes alter yychar, and that requires
3446  that yytoken be updated with the new translation. We take the
3447  approach of translating immediately before every use of yytoken.
3448  One alternative is translating here after every semantic action,
3449  but that translation would be missed if the semantic action invokes
3450  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3451  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3452  incorrect destructor might then be invoked immediately. In the
3453  case of YYERROR or YYBACKUP, subsequent parser actions might lead
3454  to an incorrect destructor call or verbose syntax error message
3455  before the lookahead is translated. */
3456  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3457 
3458  YYPOPSTACK (yylen);
3459  yylen = 0;
3460  YY_STACK_PRINT (yyss, yyssp);
3461 
3462  *++yyvsp = yyval;
3463 
3464  /* Now 'shift' the result of the reduction. Determine what state
3465  that goes to, based on the state we popped back to and the rule
3466  number reduced by. */
3467 
3468  yyn = yyr1[yyn];
3469 
3470  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3471  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3472  yystate = yytable[yystate];
3473  else
3474  yystate = yydefgoto[yyn - YYNTOKENS];
3475 
3476  goto yynewstate;
3477 
3478 
3479 /*--------------------------------------.
3480 | yyerrlab -- here on detecting error. |
3481 `--------------------------------------*/
3482 yyerrlab:
3483  /* Make sure we have latest lookahead translation. See comments at
3484  user semantic actions for why this is necessary. */
3485  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3486 
3487  /* If not already recovering from an error, report this error. */
3488  if (!yyerrstatus)
3489  {
3490  ++yynerrs;
3491 #if ! YYERROR_VERBOSE
3492  yyerror (ctx, YY_("syntax error"));
3493 #else
3494 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3495  yyssp, yytoken)
3496  {
3497  char const *yymsgp = YY_("syntax error");
3498  int yysyntax_error_status;
3499  yysyntax_error_status = YYSYNTAX_ERROR;
3500  if (yysyntax_error_status == 0)
3501  yymsgp = yymsg;
3502  else if (yysyntax_error_status == 1)
3503  {
3504  if (yymsg != yymsgbuf)
3505  YYSTACK_FREE (yymsg);
3506  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3507  if (!yymsg)
3508  {
3509  yymsg = yymsgbuf;
3510  yymsg_alloc = sizeof yymsgbuf;
3511  yysyntax_error_status = 2;
3512  }
3513  else
3514  {
3515  yysyntax_error_status = YYSYNTAX_ERROR;
3516  yymsgp = yymsg;
3517  }
3518  }
3519  yyerror (ctx, yymsgp);
3520  if (yysyntax_error_status == 2)
3521  goto yyexhaustedlab;
3522  }
3523 # undef YYSYNTAX_ERROR
3524 #endif
3525  }
3526 
3527 
3528 
3529  if (yyerrstatus == 3)
3530  {
3531  /* If just tried and failed to reuse lookahead token after an
3532  error, discard it. */
3533 
3534  if (yychar <= YYEOF)
3535  {
3536  /* Return failure if at end of input. */
3537  if (yychar == YYEOF)
3538  YYABORT;
3539  }
3540  else
3541  {
3542  yydestruct ("Error: discarding",
3543  yytoken, &yylval, ctx);
3544  yychar = YYEMPTY;
3545  }
3546  }
3547 
3548  /* Else will try to reuse lookahead token after shifting the error
3549  token. */
3550  goto yyerrlab1;
3551 
3552 
3553 /*---------------------------------------------------.
3554 | yyerrorlab -- error raised explicitly by YYERROR. |
3555 `---------------------------------------------------*/
3556 yyerrorlab:
3557 
3558  /* Pacify compilers like GCC when the user code never invokes
3559  YYERROR and the label yyerrorlab therefore never appears in user
3560  code. */
3561  if (/*CONSTCOND*/ 0)
3562  goto yyerrorlab;
3563 
3564  /* Do not reclaim the symbols of the rule whose action triggered
3565  this YYERROR. */
3566  YYPOPSTACK (yylen);
3567  yylen = 0;
3568  YY_STACK_PRINT (yyss, yyssp);
3569  yystate = *yyssp;
3570  goto yyerrlab1;
3571 
3572 
3573 /*-------------------------------------------------------------.
3574 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3575 `-------------------------------------------------------------*/
3576 yyerrlab1:
3577  yyerrstatus = 3; /* Each real token shifted decrements this. */
3578 
3579  for (;;)
3580  {
3581  yyn = yypact[yystate];
3582  if (!yypact_value_is_default (yyn))
3583  {
3584  yyn += YYTERROR;
3585  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3586  {
3587  yyn = yytable[yyn];
3588  if (0 < yyn)
3589  break;
3590  }
3591  }
3592 
3593  /* Pop the current state because it cannot handle the error token. */
3594  if (yyssp == yyss)
3595  YYABORT;
3596 
3597 
3598  yydestruct ("Error: popping",
3599  yystos[yystate], yyvsp, ctx);
3600  YYPOPSTACK (1);
3601  yystate = *yyssp;
3602  YY_STACK_PRINT (yyss, yyssp);
3603  }
3604 
3606  *++yyvsp = yylval;
3608 
3609 
3610  /* Shift the error token. */
3611  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3612 
3613  yystate = yyn;
3614  goto yynewstate;
3615 
3616 
3617 /*-------------------------------------.
3618 | yyacceptlab -- YYACCEPT comes here. |
3619 `-------------------------------------*/
3620 yyacceptlab:
3621  yyresult = 0;
3622  goto yyreturn;
3623 
3624 /*-----------------------------------.
3625 | yyabortlab -- YYABORT comes here. |
3626 `-----------------------------------*/
3627 yyabortlab:
3628  yyresult = 1;
3629  goto yyreturn;
3630 
3631 #if !defined yyoverflow || YYERROR_VERBOSE
3632 /*-------------------------------------------------.
3633 | yyexhaustedlab -- memory exhaustion comes here. |
3634 `-------------------------------------------------*/
3635 yyexhaustedlab:
3636  yyerror (ctx, YY_("memory exhausted"));
3637  yyresult = 2;
3638  /* Fall through. */
3639 #endif
3640 
3641 yyreturn:
3642  if (yychar != YYEMPTY)
3643  {
3644  /* Make sure we have latest lookahead translation. See comments at
3645  user semantic actions for why this is necessary. */
3646  yytoken = YYTRANSLATE (yychar);
3647  yydestruct ("Cleanup: discarding lookahead",
3648  yytoken, &yylval, ctx);
3649  }
3650  /* Do not reclaim the symbols of the rule whose action triggered
3651  this YYABORT or YYACCEPT. */
3652  YYPOPSTACK (yylen);
3653  YY_STACK_PRINT (yyss, yyssp);
3654  while (yyssp != yyss)
3655  {
3656  yydestruct ("Cleanup: popping",
3657  yystos[*yyssp], yyvsp, ctx);
3658  YYPOPSTACK (1);
3659  }
3660 #ifndef yyoverflow
3661  if (yyss != yyssa)
3662  YYSTACK_FREE (yyss);
3663 #endif
3664 #if YYERROR_VERBOSE
3665  if (yymsg != yymsgbuf)
3666  YYSTACK_FREE (yymsg);
3667 #endif
3668  return yyresult;
3669 }
3670 #line 903 "parser.y" /* yacc.c:1906 */
3671 
3672 
3674 {
3675  return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
3676 }
3677 
3679 {
3680  statement_t *stat;
3681 
3682  stat = parser_alloc(ctx, size ? size : sizeof(*stat));
3683  if(!stat)
3684  return NULL;
3685 
3686  stat->type = type;
3687  stat->next = NULL;
3688 
3689  return stat;
3690 }
3691 
3693 {
3694  literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
3695 
3696  ret->type = LT_STRING;
3697  ret->u.wstr = str;
3698 
3699  return ret;
3700 }
3701 
3703 {
3704  literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
3705 
3706  ret->type = LT_NULL;
3707 
3708  return ret;
3709 }
3710 
3713 {
3715 
3716  ret->type = type;
3717  ret->name = name;
3718  ret->value = value;
3719  ret->next = NULL;
3720 
3721  return ret;
3722 }
3723 
3725 {
3727  ret->head = ret->tail = prop;
3728  return ret;
3729 }
3730 
3732 {
3733  list->tail = list->tail->next = prop;
3734  return list;
3735 }
3736 
3738 {
3740 
3741  ret->elision = elision;
3742  ret->expr = expr;
3743  ret->next = NULL;
3744 
3745  return ret;
3746 }
3747 
3749 {
3751 
3752  ret->head = ret->tail = new_array_element(ctx, elision, expr);
3753 
3754  return ret;
3755 }
3756 
3758 {
3759  list->tail = list->tail->next = new_array_element(ctx, elision, expr);
3760 
3761  return list;
3762 }
3763 
3765 {
3766  argument_t *ret = parser_alloc(ctx, sizeof(argument_t));
3767 
3768  ret->expr = expr;
3769  ret->next = NULL;
3770 
3771  return ret;
3772 }
3773 
3775 {
3777 
3778  ret->head = ret->tail = new_argument(ctx, expr);
3779 
3780  return ret;
3781 }
3782 
3784 {
3785  list->tail = list->tail->next = new_argument(ctx, expr);
3786 
3787  return list;
3788 }
3789 
3790 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
3791 {
3792  catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t));
3793 
3794  ret->identifier = identifier;
3795  ret->statement = statement;
3796 
3797  return ret;
3798 }
3799 
3801 {
3803 
3804  ret->expr = expr;
3805  ret->stat = stat_list ? stat_list->head : NULL;
3806  ret->next = NULL;
3807 
3808  return ret;
3809 }
3810 
3812 {
3813  case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t));
3814 
3815  ret->head = ret->tail = case_clausule;
3816 
3817  return ret;
3818 }
3819 
3821 {
3822  list->tail = list->tail->next = case_clausule;
3823 
3824  return list;
3825 }
3826 
3828  case_clausule_t *default_clausule, case_list_t *case_list2)
3829 {
3830  case_clausule_t *ret = NULL, *iter = NULL, *iter2;
3831  statement_t *stat = NULL;
3832 
3833  if(case_list1) {
3834  ret = case_list1->head;
3835  iter = case_list1->tail;
3836  }
3837 
3838  if(default_clausule) {
3839  if(ret)
3840  iter = iter->next = default_clausule;
3841  else
3842  ret = iter = default_clausule;
3843  }
3844 
3845  if(case_list2) {
3846  if(ret)
3847  iter->next = case_list2->head;
3848  else
3849  ret = case_list2->head;
3850  }
3851 
3852  if(!ret)
3853  return NULL;
3854 
3855  for(iter = ret; iter; iter = iter->next) {
3856  for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next);
3857  if(!iter2)
3858  break;
3859 
3860  while(iter != iter2) {
3861  iter->stat = iter2->stat;
3862  iter = iter->next;
3863  }
3864 
3865  if(stat) {
3866  while(stat->next)
3867  stat = stat->next;
3868  stat->next = iter->stat;
3869  }else {
3870  stat = iter->stat;
3871  }
3872  }
3873 
3874  return ret;
3875 }
3876 
3878 {
3880 
3881  ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret));
3882  if(!ret)
3883  return NULL;
3884 
3885  ret->stat_list = list ? list->head : NULL;
3886 
3887  return &ret->stat;
3888 }
3889 
3891 {
3893 
3894  ret->identifier = identifier;
3895  ret->expr = expr;
3896  ret->next = NULL;
3897  ret->global_next = NULL;
3898 
3899  return ret;
3900 }
3901 
3903 {
3905 
3906  ret->head = ret->tail = decl;
3907 
3908  return ret;
3909 }
3910 
3912 {
3913  list->tail = list->tail->next = decl;
3914 
3915  return list;
3916 }
3917 
3919 {
3921 
3922  ret = new_statement(ctx, STAT_VAR, sizeof(*ret));
3923  if(!ret)
3924  return NULL;
3925 
3926  ret->variable_list = variable_list->head;
3927 
3928  return &ret->stat;
3929 }
3930 
3932 {
3934 
3935  ret = new_statement(ctx, STAT_EXPR, sizeof(*ret));
3936  if(!ret)
3937  return NULL;
3938 
3939  ret->expr = expr;
3940 
3941  return &ret->stat;
3942 }
3943 
3945 {
3947 
3948  ret = new_statement(ctx, STAT_IF, sizeof(*ret));
3949  if(!ret)
3950  return NULL;
3951 
3952  ret->expr = expr;
3953  ret->if_stat = if_stat;
3954  ret->else_stat = else_stat;
3955 
3956  return &ret->stat;
3957 }
3958 
3960 {
3962 
3963  ret = new_statement(ctx, STAT_WHILE, sizeof(*ret));
3964  if(!ret)
3965  return NULL;
3966 
3967  ret->do_while = dowhile;
3968  ret->expr = expr;
3969  ret->statement = stat;
3970 
3971  return &ret->stat;
3972 }
3973 
3974 static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr,
3975  expression_t *expr, expression_t *end_expr, statement_t *statement)
3976 {
3978 
3979  ret = new_statement(ctx, STAT_FOR, sizeof(*ret));
3980  if(!ret)
3981  return NULL;
3982 
3983  ret->variable_list = variable_list ? variable_list->head : NULL;
3984  ret->begin_expr = begin_expr;
3985  ret->expr = expr;
3986  ret->end_expr = end_expr;
3987  ret->statement = statement;
3988 
3989  return &ret->stat;
3990 }
3991 
3993  expression_t *in_expr, statement_t *statement)
3994 {
3996 
3997  ret = new_statement(ctx, STAT_FORIN, sizeof(*ret));
3998  if(!ret)
3999  return NULL;
4000 
4001  ret->variable = variable;
4002  ret->expr = expr;
4003  ret->in_expr = in_expr;
4004  ret->statement = statement;
4005 
4006  return &ret->stat;
4007 }
4008 
4009 static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier)
4010 {
4012 
4013  ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret));
4014  if(!ret)
4015  return NULL;
4016 
4017  ret->identifier = identifier;
4018 
4019  return &ret->stat;
4020 }
4021 
4022 static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier)
4023 {
4025 
4026  ret = new_statement(ctx, STAT_BREAK, sizeof(*ret));
4027  if(!ret)
4028  return NULL;
4029 
4030  ret->identifier = identifier;
4031 
4032  return &ret->stat;
4033 }
4034 
4036 {
4038 
4039  ret = new_statement(ctx, STAT_RETURN, sizeof(*ret));
4040  if(!ret)
4041  return NULL;
4042 
4043  ret->expr = expr;
4044 
4045  return &ret->stat;
4046 }
4047 
4049 {
4051 
4052  ret = new_statement(ctx, STAT_WITH, sizeof(*ret));
4053  if(!ret)
4054  return NULL;
4055 
4056  ret->expr = expr;
4057  ret->statement = statement;
4058 
4059  return &ret->stat;
4060 }
4061 
4062 static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
4063 {
4065 
4066  ret = new_statement(ctx, STAT_LABEL, sizeof(*ret));
4067  if(!ret)
4068  return NULL;
4069 
4070  ret->identifier = identifier;
4071  ret->statement = statement;
4072 
4073  return &ret->stat;
4074 }
4075 
4077 {
4079 
4080  ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret));
4081  if(!ret)
4082  return NULL;
4083 
4084  ret->expr = expr;
4085  ret->case_list = case_list;
4086 
4087  return &ret->stat;
4088 }
4089 
4091 {
4093 
4094  ret = new_statement(ctx, STAT_THROW, sizeof(*ret));
4095  if(!ret)
4096  return NULL;
4097 
4098  ret->expr = expr;
4099 
4100  return &ret->stat;
4101 }
4102 
4104  catch_block_t *catch_block, statement_t *finally_statement)
4105 {
4107 
4108  ret = new_statement(ctx, STAT_TRY, sizeof(*ret));
4109  if(!ret)
4110  return NULL;
4111 
4112  ret->try_statement = try_statement;
4113  ret->catch_block = catch_block;
4114  ret->finally_statement = finally_statement;
4115 
4116  return &ret->stat;
4117 }
4118 
4119 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
4120 {
4121  parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t));
4122 
4123  ret->identifier = identifier;
4124  ret->next = NULL;
4125 
4126  return ret;
4127 }
4128 
4129 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier)
4130 {
4132 
4133  ret->head = ret->tail = new_parameter(ctx, identifier);
4134 
4135  return ret;
4136 }
4137 
4139 {
4140  list->tail = list->tail->next = new_parameter(ctx, identifier);
4141 
4142  return list;
4143 }
4144 
4145 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier, parameter_list_t *parameter_list,
4146  source_elements_t *source_elements, const WCHAR *event_target, const WCHAR *src_str, DWORD src_len)
4147 {
4149 
4150  ret->identifier = identifier;
4151  ret->parameter_list = parameter_list ? parameter_list->head : NULL;
4152  ret->source_elements = source_elements;
4153  ret->event_target = event_target;
4154  ret->src_str = src_str;
4155  ret->src_len = src_len;
4156  ret->next = NULL;
4157 
4158  return &ret->expr;
4159 }
4160 
4162 {
4163  expression_t *ret = parser_alloc(ctx, size ? size : sizeof(*ret));
4164 
4165  ret->type = type;
4166 
4167  return ret;
4168 }
4169 
4171  expression_t *expression1, expression_t *expression2)
4172 {
4173  binary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
4174 
4175  ret->expression1 = expression1;
4176  ret->expression2 = expression2;
4177 
4178  return &ret->expr;
4179 }
4180 
4182 {
4183  unary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
4184 
4185  ret->expression = expression;
4186 
4187  return &ret->expr;
4188 }
4189 
4191  expression_t *true_expression, expression_t *false_expression)
4192 {
4194 
4195  ret->expression = expression;
4196  ret->true_expression = true_expression;
4197  ret->false_expression = false_expression;
4198 
4199  return &ret->expr;
4200 }
4201 
4202 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier)
4203 {
4205 
4206  ret->expression = expression;
4207  ret->identifier = identifier;
4208 
4209  return &ret->expr;
4210 }
4211 
4213 {
4214  call_expression_t *ret = new_expression(ctx, EXPR_NEW, sizeof(*ret));
4215 
4216  ret->expression = expression;
4217  ret->argument_list = argument_list ? argument_list->head : NULL;
4218 
4219  return &ret->expr;
4220 }
4221 
4223 {
4224  call_expression_t *ret = new_expression(ctx, EXPR_CALL, sizeof(*ret));
4225 
4226  ret->expression = expression;
4227  ret->argument_list = argument_list ? argument_list->head : NULL;
4228 
4229  return &ret->expr;
4230 }
4231 
4232 static int parser_error(parser_ctx_t *ctx, const char *str)
4233 {
4234  return 0;
4235 }
4236 
4237 static void set_error(parser_ctx_t *ctx, UINT error)
4238 {
4239  ctx->hres = error;
4240 }
4241 
4243 {
4244  if(obj || *(ctx->ptr-1)==next) return TRUE;
4245 
4246  set_error(ctx, JS_E_SYNTAX);
4247  return FALSE;
4248 }
4249 
4250 
4252 {
4254 
4255  ret->identifier = identifier;
4256 
4257  return &ret->expr;
4258 }
4259 
4261 {
4263 
4264  ret->element_list = element_list ? element_list->head : NULL;
4265  ret->length = length;
4266 
4267  return &ret->expr;
4268 }
4269 
4271 {
4273 
4274  ret->property_list = property_list ? property_list->head : NULL;
4275 
4276  return &ret->expr;
4277 }
4278 
4280 {
4282 
4283  ret->literal = literal;
4284 
4285  return &ret->expr;
4286 }
4287 
4289 {
4291 
4292  memset(ret, 0, sizeof(*ret));
4293 
4294  return ret;
4295 }
4296 
4298 {
4299  if(source_elements->statement_tail)
4300  source_elements->statement_tail = source_elements->statement_tail->next = statement;
4301  else
4302  source_elements->statement = source_elements->statement_tail = statement;
4303 
4304  return source_elements;
4305 }
4306 
4308 {
4310 
4311  ret->head = ret->tail = statement;
4312 
4313  return ret;
4314 }
4315 
4317 {
4318  list->tail = list->tail->next = statement;
4319 
4320  return list;
4321 }
4322 
4324 {
4325  ctx->source = source;
4326  if(!ctx->lexer_error)
4327  ctx->hres = S_OK;
4328 }
4329 
4331 {
4332  script_release(ctx->script);
4333  heap_pool_free(&ctx->heap);
4334  heap_free(ctx);
4335 }
4336 
4337 HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
4338  parser_ctx_t **ret)
4339 {
4340  parser_ctx_t *parser_ctx;
4341  heap_pool_t *mark;
4342  HRESULT hres;
4343 
4344  const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0};
4345 
4346  parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
4347  if(!parser_ctx)
4348  return E_OUTOFMEMORY;
4349 
4350  parser_ctx->hres = JS_E_SYNTAX;
4351  parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
4352 
4353  parser_ctx->begin = parser_ctx->ptr = code;
4354  parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin);
4355 
4356  script_addref(ctx);
4357  parser_ctx->script = ctx;
4358 
4359  mark = heap_pool_mark(&ctx->tmp_heap);
4360  heap_pool_init(&parser_ctx->heap);
4361 
4362  parser_parse(parser_ctx);
4363  heap_pool_clear(mark);
4364  hres = parser_ctx->hres;
4365  if(FAILED(hres)) {
4366  WARN("parser failed around %s\n",
4367  debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20));
4368  parser_release(parser_ctx);
4369  return hres;
4370  }
4371 
4372  *ret = parser_ctx;
4373  return S_OK;
4374 }
#define YYSIZE_T
Definition: parser.tab.c:357
property_definition_t * property_definition
Definition: parser.tab.c:299
literal_t * literal
Definition: parser.tab.c:289
static case_list_t * case_list_add(parser_ctx_t *, case_list_t *, case_clausule_t *)
Definition: parser.tab.c:3820
property_definition_type_t
Definition: engine.h:134
array_element_t * tail
Definition: parser.tab.c:108
static statement_t * new_labelled_statement(parser_ctx_t *, const WCHAR *, statement_t *)
Definition: parser.tab.c:4062
static statement_t * new_continue_statement(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:4009
#define yyparse
Definition: parser.tab.c:63
static parameter_list_t * parameter_list_add(parser_ctx_t *, parameter_list_t *, const WCHAR *)
Definition: parser.tab.c:4138
expression_type_t
Definition: parser.h:216
struct _property_list_t property_list_t
static expression_t * new_unary_expression(parser_ctx_t *, expression_type_t, expression_t *)
Definition: parser.tab.c:4181
property_definition_t * tail
Definition: parser.tab.c:98
#define TRUE
Definition: types.h:120
static variable_list_t * new_variable_list(parser_ctx_t *, variable_declaration_t *)
Definition: parser.tab.c:3902
static int parser_error(parser_ctx_t *, const char *)
Definition: parser.tab.c:4232
#define YYSTACK_BYTES(N)
Definition: parser.tab.c:496
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx)
Definition: parser.tab.c:1658
#define yynerrs
Definition: parser.tab.c:67
#define error(str)
Definition: mkdosfs.c:1605
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
static argument_list_t * argument_list_add(parser_ctx_t *, argument_list_t *, expression_t *)
Definition: parser.tab.c:3783
void * malloc(YYSIZE_T)
#define YYEMPTY
Definition: parser.tab.c:1250
static expression_t * new_prop_and_value_expression(parser_ctx_t *, property_list_t *)
Definition: parser.tab.c:4270
static const yytype_int16 yypact[]
Definition: parser.tab.c:709
YYLTYPE yylloc
Definition: hlsl.tab.c:2412
#define yyerror
Definition: parser.tab.c:65
#define YYMAXDEPTH
Definition: parser.tab.c:1427
short int yytype_int16
Definition: parser.tab.c:347
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parser.tab.c:507
static statement_t * new_break_statement(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:4022
static statement_t * new_throw_statement(parser_ctx_t *, expression_t *)
Definition: parser.tab.c:4090
#define WARN(fmt,...)
Definition: debug.h:111
static void * new_expression(parser_ctx_t *ctx, expression_type_t, size_t)
Definition: parser.tab.c:4161
#define yylex
Definition: parser.tab.c:64
static const char *const yytname[]
Definition: parser.tab.c:834
statement_t * statement
Definition: parser.h:287
static statement_list_t * new_statement_list(parser_ctx_t *, statement_t *)
Definition: parser.tab.c:4307
statement_t * statement_tail
Definition: parser.h:288
YYSTYPE yylval
Definition: parser.tab.c:2356
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
struct _parameter_list_t * parameter_list
Definition: parser.tab.c:297
#define JS_E_MISSING_RBRACKET
Definition: jscript.h:543
void parser_release(parser_ctx_t *ctx)
Definition: parser.tab.c:4330
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parser.tab.c:2135
static const yytype_uint8 yyr2[]
Definition: parser.tab.c:1217
literal_t * new_boolean_literal(parser_ctx_t *ctx, BOOL bval)
Definition: lex.c:416
void free(void *)
Definition: cabinet.c:147
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3678
#define YYSYNTAX_ERROR
static property_definition_t * new_property_definition(parser_ctx_t *ctx, property_definition_type_t, literal_t *name, expression_t *value)
Definition: parser.tab.c:3711
static argument_t * new_argument(parser_ctx_t *ctx, expression_t *expr)
Definition: parser.tab.c:3764
static expression_t * new_call_expression(parser_ctx_t *, expression_t *, argument_list_t *)
Definition: parser.tab.c:4222
source_elements_t * source_elements
Definition: parser.tab.c:300
#define yypact_value_is_default(Yystate)
Definition: parser.tab.c:699
#define YY_NULL
Definition: parser.tab.c:200
static case_clausule_t * new_case_clausule(parser_ctx_t *, expression_t *, statement_list_t *)
Definition: parser.tab.c:3800
static YYSIZE_T yystrlen(const char *yystr)
Definition: parser.tab.c:2118
static const yytype_int16 yycheck[]
Definition: parser.tab.c:989
static source_elements_t * new_source_elements(parser_ctx_t *)
Definition: parser.tab.c:4288
static statement_t * new_with_statement(parser_ctx_t *, expression_t *, statement_t *)
Definition: parser.tab.c:4048
Definition: query.h:86
#define yytable_value_is_error(Yytable_value)
Definition: parser.tab.c:704
static const yytype_int16 yypgoto[]
Definition: parser.tab.c:813
#define YYSTACK_ALLOC
Definition: parser.tab.c:451
HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval, parser_ctx_t **ret)
Definition: parser.tab.c:4337
short int yytype_int16
statement_t * next
Definition: parser.h:125
static statement_list_t * statement_list_add(statement_list_t *, statement_t *)
Definition: parser.tab.c:4316
static expression_t * new_array_literal_expression(parser_ctx_t *, element_list_t *, int)
Definition: parser.tab.c:4260
Definition: parser.h:75
#define YYTERROR
Definition: parser.tab.c:1278
static expression_t * new_conditional_expression(parser_ctx_t *, expression_t *, expression_t *, expression_t *)
Definition: parser.tab.c:4190
case_clausule_t * head
Definition: parser.tab.c:123
case_clausule_t * case_clausule
Definition: parser.tab.c:291
static const yytype_int16 yytable[]
Definition: parser.tab.c:845
static catch_block_t * new_catch_block(parser_ctx_t *, const WCHAR *, statement_t *)
Definition: parser.tab.c:3790
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
int parser_parse(parser_ctx_t *ctx)
static element_list_t * new_element_list(parser_ctx_t *, int, expression_t *)
Definition: parser.tab.c:3748
static parameter_t * new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
Definition: parser.tab.c:4119
static BOOL explicit_error(parser_ctx_t *, void *, WCHAR)
Definition: parser.tab.c:4242
#define YY_STACK_PRINT(Bottom, Top)
Definition: parser.tab.c:1409
unsigned int BOOL
Definition: ntddk_ex.h:94
catch_block_t * catch_block
Definition: parser.tab.c:293
static property_list_t * new_property_list(parser_ctx_t *, property_definition_t *)
Definition: parser.tab.c:3724
#define debugstr_w
Definition: kernel32.h:32
static const yytype_uint8 yystos[]
Definition: parser.tab.c:1135
statement_t * head
Definition: parser.tab.c:161
parameter_t * tail
Definition: parser.tab.c:170
#define YY_(Msgid)
Definition: parser.tab.c:373
struct _element_list_t * element_list
Definition: parser.tab.c:294
#define YYINITDEPTH
Definition: parser.tab.c:1416
WINE_DEFAULT_DEBUG_CHANNEL(jscript)
parameter_t * head
Definition: parser.tab.c:169
const WCHAR * str
const WCHAR * ptr
Definition: parse.h:256
static case_list_t * new_case_list(parser_ctx_t *, case_clausule_t *)
Definition: parser.tab.c:3811
static literal_t * new_string_literal(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:3692
smooth NULL
Definition: ftsmooth.c:416
const char * delimiter
Definition: string.c:1523
property_definition_t * head
Definition: parser.tab.c:97
struct _case_clausule_t * next
Definition: parser.h:195
void script_release(script_ctx_t *ctx)
Definition: jscript.c:67
#define YYABORT
Definition: parser.tab.c:1254
#define JS_E_MISSING_LBRACKET
Definition: jscript.h:542
#define YYUSE(E)
Definition: parser.tab.c:387
literal_t * parse_regexp(parser_ctx_t *ctx)
Definition: lex.c:1155
case_clausule_t * tail
Definition: parser.tab.c:124
static literal_t * new_null_literal(parser_ctx_t *)
Definition: parser.tab.c:3702
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
static element_list_t * element_list_add(parser_ctx_t *, element_list_t *, int, expression_t *)
Definition: parser.tab.c:3757
static parameter_list_t * new_parameter_list(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:4129
static argument_list_t * new_argument_list(parser_ctx_t *, expression_t *)
Definition: parser.tab.c:3774
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: parser.tab.c:405
static array_element_t * new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr)
Definition: parser.tab.c:3737
#define YY_INITIAL_VALUE(Value)
Definition: parser.tab.c:401
static statement_t * new_try_statement(parser_ctx_t *, statement_t *, catch_block_t *, statement_t *)
Definition: parser.tab.c:4103
static expression_t * new_member_expression(parser_ctx_t *, expression_t *, const WCHAR *)
Definition: parser.tab.c:4202
variable_declaration_t * tail
Definition: parser.tab.c:135
yytype_int16 yyss_alloc
static expression_t * new_identifier_expression(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:4251
struct _case_list_t * case_list
Definition: parser.tab.c:292
GLenum GLenum variable
Definition: glext.h:9031
heap_pool_t heap
Definition: parse.h:271
signed char yytype_int8
Definition: parser.tab.c:335
static const yytype_uint8 yydefact[]
Definition: parser.tab.c:762
yytokentype
unsigned short int yytype_uint16
Definition: parser.tab.c:341
#define YYPOPSTACK(N)
GLsizeiptr size
Definition: glext.h:5919
HRESULT hres
Definition: protocol.c:465
struct _case_list_t case_list_t
__wchar_t WCHAR
Definition: xmlstorage.h:180
statement_t * statement
Definition: parser.tab.c:301
LONG HRESULT
Definition: typedefs.h:77
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
YYSTYPE yyvs_alloc
#define yydebug
Definition: parser.tab.c:66
static case_clausule_t * new_case_block(parser_ctx_t *, case_list_t *, case_clausule_t *, case_list_t *)
Definition: parser.tab.c:3827
#define YYSTACK_ALLOC_MAXIMUM
Definition: parser.tab.c:454
struct list * next
Definition: list.h:38
unsigned char yytype_uint8
Definition: parser.tab.c:329
unsigned long DWORD
Definition: ntddk_ex.h:95
static const yytype_uint8 yytranslate[]
Definition: parser.tab.c:564
static source_elements_t * source_elements_add_statement(source_elements_t *, statement_t *)
Definition: parser.tab.c:4297
struct _variable_list_t * variable_list
Definition: parser.tab.c:303
static void program_parsed(parser_ctx_t *, source_elements_t *)
Definition: parser.tab.c:4323
struct _property_list_t * property_list
Definition: parser.tab.c:298
statement_type_t
Definition: parser.h:104
#define SCRIPTLANGUAGEVERSION_ES5
Definition: jscript.h:49
#define JS_E_MISSING_SEMICOLON
Definition: jscript.h:541
struct _argument_list_t argument_list_t
#define YYNTOKENS
Definition: parser.tab.c:546
int ret
const WCHAR * identifier
Definition: parser.tab.c:296
static void * parser_alloc_tmp(parser_ctx_t *ctx, DWORD size)
Definition: parser.h:62
static variable_list_t * variable_list_add(parser_ctx_t *, variable_list_t *, variable_declaration_t *)
Definition: parser.tab.c:3911
Definition: stat.h:55
int parser_debug
Definition: widl.c:111
static statement_t * new_expression_statement(parser_ctx_t *, expression_t *)
Definition: parser.tab.c:3931
Definition: _list.h:228
static statement_t * new_switch_statement(parser_ctx_t *, expression_t *, case_clausule_t *)
Definition: parser.tab.c:4076
const WCHAR * end
Definition: parse.h:257
heap_pool_t tmp_heap
Definition: jscript.h:423
struct _element_list_t element_list_t
int code
Definition: i386-dis.c:3591
GLsizei const GLfloat * value
Definition: glext.h:6069
void heap_pool_init(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:69
statement_t * tail
Definition: parser.tab.c:162
static statement_t * new_var_statement(parser_ctx_t *, variable_list_t *)
Definition: parser.tab.c:3918
static BOOL allow_auto_semicolon(parser_ctx_t *)
Definition: parser.tab.c:3673
#define strcmpiW(s1, s2)
Definition: unicode.h:39
static expression_t * new_new_expression(parser_ctx_t *, expression_t *, argument_list_t *)
Definition: parser.tab.c:4212
static expression_t * new_function_expression(parser_ctx_t *, const WCHAR *, parameter_list_t *, source_elements_t *, const WCHAR *, const WCHAR *, DWORD)
Definition: parser.tab.c:4145
const WCHAR * srcptr
Definition: parser.tab.c:287
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static property_list_t * property_list_add(parser_ctx_t *, property_list_t *, property_definition_t *)
Definition: parser.tab.c:3731
#define S_OK
Definition: intsafe.h:59
struct _statement_list_t statement_list_t
static statement_t * new_block_statement(parser_ctx_t *, statement_list_t *)
Definition: parser.tab.c:3877
static unsigned __int64 next
Definition: rand_nt.c:6
static expression_t * new_literal_expression(parser_ctx_t *, literal_t *)
Definition: parser.tab.c:4279
int yychar
Definition: parser.tab.c:2353
static const yytype_int16 yydefgoto[]
Definition: parser.tab.c:828
static statement_t * new_while_statement(parser_ctx_t *, BOOL, expression_t *, statement_t *)
Definition: parser.tab.c:3959
GLsizei GLsizei GLchar * source
Definition: glext.h:6048
variable_declaration_t * variable_declaration
Definition: parser.tab.c:304
#define YYLAST
Definition: parser.tab.c:543
struct _variable_list_t variable_list_t
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: parser.tab.c:2205
argument_t * head
Definition: parser.tab.c:115
#define list
Definition: rosglue.h:35
unsigned short int yytype_uint16
unsigned int UINT
Definition: ndis.h:50
static statement_t * new_if_statement(parser_ctx_t *, expression_t *, statement_t *, statement_t *)
Definition: parser.tab.c:3944
#define YYTRANSLATE(YYX)
Definition: parser.tab.c:559
variable_declaration_t * head
Definition: parser.tab.c:134
static void script_addref(script_ctx_t *ctx)
Definition: jscript.h:461
expression_t * expr
Definition: parser.tab.c:295
#define YYFINAL
Definition: parser.tab.c:541
statement_t * head
Definition: parser.tab.c:89
LPCWSTR wstr
Definition: parser.tab.c:288
void heap_pool_free(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:167
struct _statement_list_t * statement_list
Definition: parser.tab.c:302
static statement_t * new_forin_statement(parser_ctx_t *, variable_declaration_t *, expression_t *, expression_t *, statement_t *)
Definition: parser.tab.c:3992
#define JS_E_SYNTAX
Definition: jscript.h:540
Definition: name.c:36
static statement_t * new_return_statement(parser_ctx_t *, expression_t *)
Definition: parser.tab.c:4035
#define YYDPRINTF(Args)
Definition: parser.tab.c:1407
#define YYSTACK_FREE
Definition: parser.tab.c:452
int ival
Definition: parser.tab.c:286
FILE * stderr
array_element_t * head
Definition: parser.tab.c:107
#define YYCASE_(N, S)
#define YYACCEPT
Definition: parser.tab.c:1253
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parser.tab.c:1408
struct _parameter_list_t parameter_list_t
statement_t * tail
Definition: parser.tab.c:90
HRESULT hres
Definition: parse.h:262
BOOL is_html
Definition: parse.h:261
heap_pool_t * heap_pool_mark(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:180
struct _argument_list_t * argument_list
Definition: parser.tab.c:290
static const yytype_uint8 yyr1[]
Definition: parser.tab.c:1186
static statement_t * new_for_statement(parser_ctx_t *, variable_list_t *, expression_t *, expression_t *, expression_t *, statement_t *)
Definition: parser.tab.c:3974
#define memset(x, y, z)
Definition: compat.h:39
static variable_declaration_t * new_variable_declaration(parser_ctx_t *, const WCHAR *, expression_t *)
Definition: parser.tab.c:3890
argument_t * tail
Definition: parser.tab.c:116
#define YY_REDUCE_PRINT(Rule)
Definition: parser.tab.c:1410
static expression_t * new_binary_expression(parser_ctx_t *, expression_type_t, expression_t *, expression_t *)
Definition: parser.tab.c:4170
static void set_error(parser_ctx_t *, UINT)
Definition: parser.tab.c:4237
#define YYEOF
Definition: parser.tab.c:1251
unsigned char yytype_uint8
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: parser.tab.c:404
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parser.tab.c:2157
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
void heap_pool_clear(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:144
GLuint const GLchar * name
Definition: glext.h:6031