1
2 /* A Bison parser, made by GNU Bison 2.4.1. */
3
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
5
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
8
9 This program is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* As a special exception, you may create a larger work that contains
23 part or all of the Bison parser skeleton and distribute that work
24 under terms of your choice, so long as that work isn't itself a
25 parser generator using the skeleton or a modified version thereof
26 as a parser skeleton. Alternatively, if you modify or redistribute
27 the parser skeleton itself, you may (at your option) remove this
28 special exception, which will cause the skeleton and the resulting
29 Bison output files to be licensed under the GNU General Public
30 License without this special exception.
31
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
34
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
37
38 /* All symbols defined below should begin with yy or YY, to avoid
39 infringing on user name space. This should be done even for local
40 variables, as they might otherwise be expanded by user macros.
41 There are some unavoidable exceptions within include files to
42 define necessary library symbols; they are noted "INFRINGES ON
43 USER NAME SPACE" below. */
44
45 /* Identify Bison output. */
46 #define YYBISON 1
47
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
50
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
53
54 /* Pure parsers. */
55 #define YYPURE 1
56
57 /* Push parsers. */
58 #define YYPUSH 1
59
60 /* Pull parsers. */
61 #define YYPULL 1
62
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
65
66
67
68 /* Copy the first part of user declarations. */
69
70 /* Line 189 of yacc.c */
71 #line 3 "./js-parser/Grammar.y"
72
73
74 /*
75 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
76 * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
77 * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
78 * Copyright (C) 2009 Maxim Ermilov <zaspire@rambler.ru>
79 *
80 * This library is free software; you can redistribute it and/or
81 * modify it under the terms of the GNU Lesser General Public
82 * License as published by the Free Software Foundation; either
83 * version 2 of the License, or (at your option) any later version.
84 *
85 * This library is distributed in the hope that it will be useful,
86 * but WITHOUT ANY WARRANTY; without even the implied warranty of
87 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
88 * Lesser General Public License for more details.
89 *
90 * You should have received a copy of the GNU Lesser General Public
91 * License along with this library; if not, write to the Free Software
92 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
93 *
94 */
95
96 #include <string.h>
97 #include <stdlib.h>
98 #include <stdio.h>
99
100 #include <glib.h>
101
102 #include "jstypes.h"
103 #include "js-node.h"
104 #define YYMAXDEPTH 10000
105 #define YYENABLE_NLS 0
106
107 /* default values for bison */
108
109 void yyerror (char* msg);
110 int yylex(void *a);
111
112 #define YYERROR_VERBOSE 1 // SHOW NORMAL ERROR MESSAGE
113 #define YYDEBUG 1 // Set to 1 to debug a parse error.
114 #define jscyydebug 1 // Set to 1 to debug a parse error.
115
116 JSNode *global = NULL;
117 GList *line_missed_semicolon = NULL;
118
119 static JSNode*
node_new(int type,int arity)120 node_new (int type, int arity)
121 {
122 JSNode *node = g_object_new (JS_TYPE_NODE, NULL);
123 node->pn_type = type;
124 node->pn_arity = arity;
125
126 return node;
127 }
128
129 static void
node_correct_position(JSNode * self,JSNode * inner)130 node_correct_position (JSNode *self, JSNode *inner)
131 {
132 if (!self)
133 return;
134 if (!inner)
135 return;
136 if (!self->pn_pos.begin)
137 self->pn_pos.begin = inner->pn_pos.begin;
138 if (!self->pn_pos.end)
139 self->pn_pos.end = inner->pn_pos.end;
140 if (inner->pn_pos.begin && self->pn_pos.begin > inner->pn_pos.begin)
141 self->pn_pos.begin = inner->pn_pos.begin;
142 if (self->pn_pos.end < inner->pn_pos.end)
143 self->pn_pos.end = inner->pn_pos.end;
144 }
145
146 static int
node_get_line(JSNode * self)147 node_get_line (JSNode *self)
148 {
149 if (!self)
150 return 0;
151 return self->pn_pos.end;
152 }
153
154 static void
node_correct_position_end(JSNode * self,int end)155 node_correct_position_end (JSNode *self, int end)
156 {
157 if (!self->pn_pos.begin)
158 self->pn_pos.begin = end;
159 if (self->pn_pos.end < end)
160 self->pn_pos.end = end;
161 }
162
163 static void
AUTO_SEMICOLON(int line)164 AUTO_SEMICOLON (int line)
165 {
166 line_missed_semicolon = g_list_append (line_missed_semicolon, GINT_TO_POINTER (line));
167 }
168
169 #define PRINT_LINE /*printf("%s(%d)\n", __FILE__ , __LINE__)*/
170 #define PRINT_LINE_TODO /*printf("TODO:%s(%d)\n", __FILE__ , __LINE__)*/
171 #define PRINT_LINE_NOTNEED /*printf("NOTNEED:%s(%d)\n", __FILE__ , __LINE__)*/
172
173 //#define YYPARSE_PARAM globalPtr
174 //#define YYLEX_PARAM globalPtr
175
176
177
178 /* Line 189 of yacc.c */
179 #line 180 "./js-parser/js-parser-y-tab.c"
180
181 /* Enabling traces. */
182 #ifndef YYDEBUG
183 # define YYDEBUG 0
184 #endif
185
186 /* Enabling verbose error messages. */
187 #ifdef YYERROR_VERBOSE
188 # undef YYERROR_VERBOSE
189 # define YYERROR_VERBOSE 1
190 #else
191 # define YYERROR_VERBOSE 0
192 #endif
193
194 /* Enabling the token table. */
195 #ifndef YYTOKEN_TABLE
196 # define YYTOKEN_TABLE 0
197 #endif
198
199
200 /* Tokens. */
201 #ifndef YYTOKENTYPE
202 # define YYTOKENTYPE
203 /* Put the tokens into the symbol table, so that GDB and other debuggers
204 know about them. */
205 enum yytokentype {
206 NULLTOKEN = 258,
207 TRUETOKEN = 259,
208 FALSETOKEN = 260,
209 BREAK = 261,
210 CASE = 262,
211 DEFAULT = 263,
212 FOR = 264,
213 NEW = 265,
214 VAR = 266,
215 CONSTTOKEN = 267,
216 CONTINUE = 268,
217 FUNCTION = 269,
218 RETURN = 270,
219 VOIDTOKEN = 271,
220 DELETETOKEN = 272,
221 IF = 273,
222 THISTOKEN = 274,
223 DO = 275,
224 WHILE = 276,
225 INTOKEN = 277,
226 INSTANCEOF = 278,
227 TYPEOF = 279,
228 SWITCH = 280,
229 WITH = 281,
230 RESERVED = 282,
231 THROW = 283,
232 TRY = 284,
233 CATCH = 285,
234 FINALLY = 286,
235 DEBUGGER = 287,
236 IF_WITHOUT_ELSE = 288,
237 ELSE = 289,
238 EQEQ = 290,
239 NE = 291,
240 STREQ = 292,
241 STRNEQ = 293,
242 LE = 294,
243 GE = 295,
244 OR = 296,
245 AND = 297,
246 PLUSPLUS = 298,
247 MINUSMINUS = 299,
248 LSHIFT = 300,
249 RSHIFT = 301,
250 URSHIFT = 302,
251 PLUSEQUAL = 303,
252 MINUSEQUAL = 304,
253 MULTEQUAL = 305,
254 DIVEQUAL = 306,
255 LSHIFTEQUAL = 307,
256 RSHIFTEQUAL = 308,
257 URSHIFTEQUAL = 309,
258 ANDEQUAL = 310,
259 MODEQUAL = 311,
260 XOREQUAL = 312,
261 OREQUAL = 313,
262 OPENBRACE = 314,
263 CLOSEBRACE = 315,
264 IDENT_IN = 316,
265 NUMBER = 317,
266 STRING = 318,
267 AUTOPLUSPLUS = 319,
268 AUTOMINUSMINUS = 320
269 };
270 #endif
271
272
273
274 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
275 typedef union YYSTYPE
276 {
277
278 /* Line 214 of yacc.c */
279 #line 109 "./js-parser/Grammar.y"
280
281 int intValue;
282 JSNode* node;
283 struct {
284 char *iname;
285 JSTokenPos pos;
286 } name;
287
288
289
290 /* Line 214 of yacc.c */
291 #line 292 "./js-parser/js-parser-y-tab.c"
292 } YYSTYPE;
293 # define YYSTYPE_IS_TRIVIAL 1
294 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
295 # define YYSTYPE_IS_DECLARED 1
296 #endif
297
298 #ifndef YYPUSH_DECLS
299 # define YYPUSH_DECLS
300 struct yypstate;
301 typedef struct yypstate yypstate;
302 enum { YYPUSH_MORE = 4 };
303
304 #if defined __STDC__ || defined __cplusplus
305 int yyparse (void);
306 #else
307 int yyparse ();
308 #endif
309 #if defined __STDC__ || defined __cplusplus
310 int yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val);
311 #else
312 int yypush_parse ();
313 #endif
314 #if defined __STDC__ || defined __cplusplus
315 int yypull_parse (yypstate *yyps);
316 #else
317 int yypull_parse ();
318 #endif
319 #if defined __STDC__ || defined __cplusplus
320 yypstate * yypstate_new (void);
321 #else
322 yypstate * yypstate_new ();
323 #endif
324 #if defined __STDC__ || defined __cplusplus
325 void yypstate_delete (yypstate *yyps);
326 #else
327 void yypstate_delete ();
328 #endif
329 #endif
330
331
332 /* Copy the second part of user declarations. */
333
334
335 /* Line 264 of yacc.c */
336 #line 337 "./js-parser/js-parser-y-tab.c"
337
338 #ifdef short
339 # undef short
340 #endif
341
342 #ifdef YYTYPE_UINT8
343 typedef YYTYPE_UINT8 yytype_uint8;
344 #else
345 typedef unsigned char yytype_uint8;
346 #endif
347
348 #ifdef YYTYPE_INT8
349 typedef YYTYPE_INT8 yytype_int8;
350 #elif (defined __STDC__ || defined __C99__FUNC__ \
351 || defined __cplusplus || defined _MSC_VER)
352 typedef signed char yytype_int8;
353 #else
354 typedef short int yytype_int8;
355 #endif
356
357 #ifdef YYTYPE_UINT16
358 typedef YYTYPE_UINT16 yytype_uint16;
359 #else
360 typedef unsigned short int yytype_uint16;
361 #endif
362
363 #ifdef YYTYPE_INT16
364 typedef YYTYPE_INT16 yytype_int16;
365 #else
366 typedef short int yytype_int16;
367 #endif
368
369 #ifndef YYSIZE_T
370 # ifdef __SIZE_TYPE__
371 # define YYSIZE_T __SIZE_TYPE__
372 # elif defined size_t
373 # define YYSIZE_T size_t
374 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
375 || defined __cplusplus || defined _MSC_VER)
376 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
377 # define YYSIZE_T size_t
378 # else
379 # define YYSIZE_T unsigned int
380 # endif
381 #endif
382
383 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
384
385 #ifndef YY_
386 # if YYENABLE_NLS
387 # if ENABLE_NLS
388 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
389 # define YY_(msgid) dgettext ("bison-runtime", msgid)
390 # endif
391 # endif
392 # ifndef YY_
393 # define YY_(msgid) msgid
394 # endif
395 #endif
396
397 /* Suppress unused-variable warnings by "using" E. */
398 #if ! defined lint || defined __GNUC__
399 # define YYUSE(e) ((void) (e))
400 #else
401 # define YYUSE(e) /* empty */
402 #endif
403
404 /* Identity function, used to suppress warnings about constant conditions. */
405 #ifndef lint
406 # define YYID(n) (n)
407 #else
408 #if (defined __STDC__ || defined __C99__FUNC__ \
409 || defined __cplusplus || defined _MSC_VER)
410 static int
YYID(int yyi)411 YYID (int yyi)
412 #else
413 static int
414 YYID (yyi)
415 int yyi;
416 #endif
417 {
418 return yyi;
419 }
420 #endif
421
422 #if ! defined yyoverflow || YYERROR_VERBOSE
423
424 # ifdef YYSTACK_ALLOC
425 /* Pacify GCC's `empty if-body' warning. */
426 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
427 # ifndef YYSTACK_ALLOC_MAXIMUM
428 /* The OS might guarantee only one guard page at the bottom of the stack,
429 and a page size can be as small as 4096 bytes. So we cannot safely
430 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
431 to allow for a few compiler-allocated temporary stack slots. */
432 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
433 # endif
434 # else
435 # define YYSTACK_ALLOC YYMALLOC
436 # define YYSTACK_FREE YYFREE
437 # ifndef YYSTACK_ALLOC_MAXIMUM
438 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
439 # endif
440 # if (defined __cplusplus && ! defined _STDLIB_H \
441 && ! ((defined YYMALLOC || defined malloc) \
442 && (defined YYFREE || defined free)))
443 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
444 # ifndef _STDLIB_H
445 # define _STDLIB_H 1
446 # endif
447 # endif
448 # ifndef YYMALLOC
449 # define YYMALLOC malloc
450 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
451 || defined __cplusplus || defined _MSC_VER)
452 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
453 # endif
454 # endif
455 # ifndef YYFREE
456 # define YYFREE free
457 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
458 || defined __cplusplus || defined _MSC_VER)
459 void free (void *); /* INFRINGES ON USER NAME SPACE */
460 # endif
461 # endif
462 # endif
463 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
464
465
466 #if (! defined yyoverflow \
467 && (! defined __cplusplus \
468 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
469
470 /* A type that is properly aligned for any stack member. */
471 union yyalloc
472 {
473 yytype_int16 yyss_alloc;
474 YYSTYPE yyvs_alloc;
475 };
476
477 /* The size of the maximum gap between one aligned stack and the next. */
478 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
479
480 /* The size of an array large to enough to hold all stacks, each with
481 N elements. */
482 # define YYSTACK_BYTES(N) \
483 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
484 + YYSTACK_GAP_MAXIMUM)
485
486 /* Copy COUNT objects from FROM to TO. The source and destination do
487 not overlap. */
488 # ifndef YYCOPY
489 # if defined __GNUC__ && 1 < __GNUC__
490 # define YYCOPY(To, From, Count) \
491 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
492 # else
493 # define YYCOPY(To, From, Count) \
494 do \
495 { \
496 YYSIZE_T yyi; \
497 for (yyi = 0; yyi < (Count); yyi++) \
498 (To)[yyi] = (From)[yyi]; \
499 } \
500 while (YYID (0))
501 # endif
502 # endif
503
504 /* Relocate STACK from its old location to the new one. The
505 local variables YYSIZE and YYSTACKSIZE give the old and new number of
506 elements in the stack, and YYPTR gives the new location of the
507 stack. Advance YYPTR to a properly aligned location for the next
508 stack. */
509 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
510 do \
511 { \
512 YYSIZE_T yynewbytes; \
513 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
514 Stack = &yyptr->Stack_alloc; \
515 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
516 yyptr += yynewbytes / sizeof (*yyptr); \
517 } \
518 while (YYID (0))
519
520 #endif
521
522 /* YYFINAL -- State number of the termination state. */
523 #define YYFINAL 207
524 /* YYLAST -- Last index in YYTABLE. */
525 #define YYLAST 1389
526
527 /* YYNTOKENS -- Number of terminals. */
528 #define YYNTOKENS 92
529 /* YYNNTS -- Number of nonterminals. */
530 #define YYNNTS 110
531 /* YYNRULES -- Number of rules. */
532 #define YYNRULES 335
533 /* YYNRULES -- Number of states. */
534 #define YYNSTATES 599
535
536 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
537 #define YYUNDEFTOK 2
538 #define YYMAXUTOK 320
539
540 #define YYTRANSLATE(YYX) \
541 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
542
543 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
544 static const yytype_uint8 yytranslate[] =
545 {
546 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
549 2, 2, 2, 82, 2, 2, 69, 87, 90, 2,
550 78, 79, 71, 72, 75, 85, 76, 67, 2, 2,
551 2, 2, 2, 2, 2, 2, 2, 2, 80, 91,
552 88, 81, 89, 70, 2, 2, 2, 2, 2, 2,
553 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
554 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
555 2, 83, 77, 84, 68, 2, 2, 2, 2, 2,
556 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
558 2, 2, 2, 73, 66, 74, 86, 2, 2, 2,
559 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
566 2, 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, 2, 2, 2, 2, 2, 2, 2,
570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
572 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
573 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
574 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
575 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
576 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
577 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
578 65
579 };
580
581 #if YYDEBUG
582 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
583 YYRHS. */
584 static const yytype_uint16 yyprhs[] =
585 {
586 0, 0, 3, 5, 7, 11, 15, 20, 21, 24,
587 26, 28, 31, 33, 35, 37, 40, 42, 44, 46,
588 50, 55, 61, 63, 65, 68, 71, 73, 77, 83,
589 89, 95, 97, 101, 106, 108, 110, 114, 117, 119,
590 121, 123, 125, 127, 131, 135, 139, 147, 156, 158,
591 162, 164, 167, 171, 176, 178, 180, 182, 184, 188,
592 192, 196, 202, 205, 210, 211, 213, 215, 218, 220,
593 222, 224, 229, 233, 237, 239, 244, 248, 252, 254,
594 257, 259, 262, 265, 268, 273, 277, 280, 283, 288,
595 292, 295, 299, 301, 305, 307, 309, 311, 313, 315,
596 318, 321, 323, 326, 329, 332, 335, 338, 341, 344,
597 347, 350, 353, 356, 359, 362, 364, 366, 368, 370,
598 372, 376, 380, 384, 386, 390, 394, 398, 400, 404,
599 408, 410, 414, 418, 420, 424, 428, 432, 434, 438,
600 442, 446, 448, 452, 456, 460, 464, 468, 472, 474,
601 478, 482, 486, 490, 494, 496, 500, 504, 508, 512,
602 516, 520, 522, 526, 530, 534, 538, 540, 544, 548,
603 552, 556, 558, 562, 566, 570, 574, 576, 580, 582,
604 586, 588, 592, 594, 598, 600, 604, 606, 610, 612,
605 616, 618, 622, 624, 628, 630, 634, 636, 640, 642,
606 646, 648, 652, 654, 658, 660, 664, 666, 672, 674,
607 680, 682, 688, 690, 694, 696, 700, 702, 706, 708,
608 710, 712, 714, 716, 718, 720, 722, 724, 726, 728,
609 730, 732, 736, 738, 742, 744, 748, 750, 752, 754,
610 756, 758, 760, 762, 764, 766, 768, 770, 772, 774,
611 776, 778, 780, 782, 785, 789, 793, 797, 799, 802,
612 806, 811, 813, 816, 820, 825, 829, 833, 835, 839,
613 841, 844, 847, 850, 852, 855, 858, 864, 872, 880,
614 888, 894, 904, 915, 923, 932, 942, 943, 945, 946,
615 948, 951, 954, 958, 962, 965, 968, 972, 976, 979,
616 982, 986, 990, 996, 1002, 1006, 1012, 1013, 1015, 1017,
617 1020, 1024, 1029, 1032, 1036, 1040, 1044, 1048, 1053, 1061,
618 1071, 1074, 1077, 1085, 1094, 1101, 1109, 1117, 1126, 1128,
619 1132, 1133, 1135, 1136, 1138, 1140
620 };
621
622 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
623 static const yytype_int16 yyrhs[] =
624 {
625 200, 0, -1, 61, -1, 96, -1, 96, 66, 94,
626 -1, 67, 94, 67, -1, 67, 94, 67, 93, -1,
627 -1, 96, 97, -1, 98, -1, 101, -1, 101, 99,
628 -1, 68, -1, 69, -1, 100, -1, 100, 70, -1,
629 71, -1, 72, -1, 70, -1, 73, 62, 74, -1,
630 73, 62, 75, 74, -1, 73, 62, 75, 62, 74,
631 -1, 102, -1, 76, -1, 77, 93, -1, 77, 76,
632 -1, 103, -1, 78, 94, 79, -1, 78, 70, 80,
633 94, 79, -1, 78, 70, 81, 94, 79, -1, 78,
634 70, 82, 94, 79, -1, 93, -1, 83, 104, 84,
635 -1, 83, 68, 104, 84, -1, 62, -1, 93, -1,
636 104, 85, 104, -1, 104, 104, -1, 3, -1, 4,
637 -1, 5, -1, 62, -1, 63, -1, 93, 80, 159,
638 -1, 63, 80, 159, -1, 62, 80, 159, -1, 93,
639 93, 78, 79, 59, 199, 60, -1, 93, 93, 78,
640 198, 79, 59, 199, 60, -1, 106, -1, 107, 75,
641 106, -1, 109, -1, 59, 60, -1, 59, 107, 60,
642 -1, 59, 107, 75, 60, -1, 19, -1, 105, -1,
643 110, -1, 93, -1, 78, 163, 79, -1, 83, 112,
644 84, -1, 83, 111, 84, -1, 83, 111, 75, 112,
645 84, -1, 112, 159, -1, 111, 75, 112, 159, -1,
646 -1, 113, -1, 75, -1, 113, 75, -1, 108, -1,
647 95, -1, 197, -1, 114, 83, 163, 84, -1, 114,
648 76, 93, -1, 10, 114, 120, -1, 109, -1, 115,
649 83, 163, 84, -1, 115, 76, 93, -1, 10, 114,
650 120, -1, 114, -1, 10, 116, -1, 115, -1, 10,
651 116, -1, 114, 120, -1, 118, 120, -1, 118, 83,
652 163, 84, -1, 118, 76, 93, -1, 115, 120, -1,
653 119, 120, -1, 119, 83, 163, 84, -1, 119, 76,
654 93, -1, 78, 79, -1, 78, 121, 79, -1, 159,
655 -1, 121, 75, 159, -1, 116, -1, 118, -1, 117,
656 -1, 119, -1, 122, -1, 122, 43, -1, 122, 44,
657 -1, 123, -1, 123, 43, -1, 123, 44, -1, 17,
658 127, -1, 16, 127, -1, 24, 127, -1, 43, 127,
659 -1, 64, 127, -1, 44, 127, -1, 65, 127, -1,
660 72, 127, -1, 85, 127, -1, 86, 127, -1, 82,
661 127, -1, 124, -1, 126, -1, 125, -1, 126, -1,
662 127, -1, 129, 71, 127, -1, 129, 67, 127, -1,
663 129, 87, 127, -1, 128, -1, 130, 71, 127, -1,
664 130, 67, 127, -1, 130, 87, 127, -1, 129, -1,
665 131, 72, 129, -1, 131, 85, 129, -1, 130, -1,
666 132, 72, 129, -1, 132, 85, 129, -1, 131, -1,
667 133, 45, 131, -1, 133, 46, 131, -1, 133, 47,
668 131, -1, 132, -1, 134, 45, 131, -1, 134, 46,
669 131, -1, 134, 47, 131, -1, 133, -1, 135, 88,
670 133, -1, 135, 89, 133, -1, 135, 39, 133, -1,
671 135, 40, 133, -1, 135, 23, 133, -1, 135, 22,
672 133, -1, 133, -1, 136, 88, 133, -1, 136, 89,
673 133, -1, 136, 39, 133, -1, 136, 40, 133, -1,
674 136, 23, 133, -1, 134, -1, 137, 88, 133, -1,
675 137, 89, 133, -1, 137, 39, 133, -1, 137, 40,
676 133, -1, 137, 23, 133, -1, 137, 22, 133, -1,
677 135, -1, 138, 35, 135, -1, 138, 36, 135, -1,
678 138, 37, 135, -1, 138, 38, 135, -1, 136, -1,
679 139, 35, 136, -1, 139, 36, 136, -1, 139, 37,
680 136, -1, 139, 38, 136, -1, 137, -1, 140, 35,
681 135, -1, 140, 36, 135, -1, 140, 37, 135, -1,
682 140, 38, 135, -1, 138, -1, 141, 90, 138, -1,
683 139, -1, 142, 90, 139, -1, 140, -1, 143, 90,
684 138, -1, 141, -1, 144, 68, 141, -1, 142, -1,
685 145, 68, 142, -1, 143, -1, 146, 68, 141, -1,
686 144, -1, 147, 66, 144, -1, 145, -1, 148, 66,
687 145, -1, 146, -1, 149, 66, 144, -1, 147, -1,
688 150, 42, 147, -1, 148, -1, 151, 42, 148, -1,
689 149, -1, 152, 42, 147, -1, 150, -1, 153, 41,
690 150, -1, 151, -1, 154, 41, 151, -1, 152, -1,
691 155, 41, 150, -1, 153, -1, 153, 70, 159, 80,
692 159, -1, 154, -1, 154, 70, 160, 80, 160, -1,
693 155, -1, 155, 70, 159, 80, 159, -1, 156, -1,
694 122, 162, 159, -1, 157, -1, 122, 162, 160, -1,
695 158, -1, 123, 162, 159, -1, 81, -1, 48, -1,
696 49, -1, 50, -1, 51, -1, 52, -1, 53, -1,
697 54, -1, 55, -1, 57, -1, 58, -1, 56, -1,
698 159, -1, 163, 75, 159, -1, 160, -1, 164, 75,
699 160, -1, 161, -1, 165, 75, 159, -1, 167, -1,
700 168, -1, 171, -1, 196, -1, 176, -1, 177, -1,
701 178, -1, 179, -1, 182, -1, 183, -1, 184, -1,
702 185, -1, 186, -1, 192, -1, 193, -1, 194, -1,
703 195, -1, 59, 60, -1, 59, 201, 60, -1, 11,
704 169, 91, -1, 11, 169, 1, -1, 93, -1, 93,
705 174, -1, 169, 75, 93, -1, 169, 75, 93, 174,
706 -1, 93, -1, 93, 175, -1, 170, 75, 93, -1,
707 170, 75, 93, 175, -1, 12, 172, 91, -1, 12,
708 172, 1, -1, 173, -1, 172, 75, 173, -1, 93,
709 -1, 93, 174, -1, 81, 159, -1, 81, 160, -1,
710 91, -1, 165, 91, -1, 165, 1, -1, 18, 78,
711 163, 79, 166, -1, 18, 78, 163, 79, 166, 34,
712 166, -1, 20, 166, 21, 78, 163, 79, 91, -1,
713 20, 166, 21, 78, 163, 79, 1, -1, 21, 78,
714 163, 79, 166, -1, 9, 78, 181, 91, 180, 91,
715 180, 79, 166, -1, 9, 78, 11, 170, 91, 180,
716 91, 180, 79, 166, -1, 9, 78, 122, 22, 163,
717 79, 166, -1, 9, 78, 11, 93, 22, 163, 79,
718 166, -1, 9, 78, 11, 93, 175, 22, 163, 79,
719 166, -1, -1, 163, -1, -1, 164, -1, 13, 91,
720 -1, 13, 1, -1, 13, 93, 91, -1, 13, 93,
721 1, -1, 6, 91, -1, 6, 1, -1, 6, 93,
722 91, -1, 6, 93, 1, -1, 15, 91, -1, 15,
723 1, -1, 15, 163, 91, -1, 15, 163, 1, -1,
724 26, 78, 163, 79, 166, -1, 25, 78, 163, 79,
725 187, -1, 59, 188, 60, -1, 59, 188, 191, 188,
726 60, -1, -1, 189, -1, 190, -1, 189, 190, -1,
727 7, 163, 80, -1, 7, 163, 80, 201, -1, 8,
728 80, -1, 8, 80, 201, -1, 93, 80, 166, -1,
729 28, 163, 91, -1, 28, 163, 1, -1, 29, 167,
730 31, 167, -1, 29, 167, 30, 78, 93, 79, 167,
731 -1, 29, 167, 30, 78, 93, 79, 167, 31, 167,
732 -1, 32, 91, -1, 32, 1, -1, 14, 93, 78,
733 79, 59, 199, 60, -1, 14, 93, 78, 198, 79,
734 59, 199, 60, -1, 14, 78, 79, 59, 199, 60,
735 -1, 14, 78, 198, 79, 59, 199, 60, -1, 14,
736 93, 78, 79, 59, 199, 60, -1, 14, 93, 78,
737 198, 79, 59, 199, 60, -1, 93, -1, 198, 75,
738 93, -1, -1, 201, -1, -1, 201, -1, 166, -1,
739 201, 166, -1
740 };
741
742 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
743 static const yytype_uint16 yyrline[] =
744 {
745 0, 215, 215, 219, 220, 224, 225, 229, 230, 234,
746 235, 236, 240, 241, 246, 247, 251, 252, 253, 254,
747 255, 256, 260, 261, 262, 263, 264, 265, 266, 267,
748 268, 272, 276, 277, 281, 282, 283, 284, 288, 289,
749 290, 291, 292, 296, 303, 309, 315, 316, 321, 326,
750 340, 341, 342, 347, 354, 355, 356, 357, 358, 362,
751 363, 364, 368, 369, 374, 375, 379, 380, 384, 385,
752 386, 387, 388, 395, 405, 406, 407, 414, 418, 419,
753 423, 424, 428, 435, 442, 443, 453, 460, 467, 468,
754 478, 479, 483, 484, 493, 494, 498, 499, 503, 504,
755 505, 509, 510, 511, 515, 516, 517, 518, 519, 520,
756 521, 522, 523, 524, 525, 528, 529, 533, 534, 538,
757 539, 540, 541, 545, 546, 548, 550, 555, 556, 557,
758 561, 562, 564, 569, 570, 571, 572, 576, 577, 578,
759 579, 583, 584, 585, 586, 587, 588, 589, 593, 594,
760 595, 596, 597, 598, 603, 604, 605, 606, 607, 608,
761 610, 615, 616, 617, 618, 619, 623, 624, 626, 628,
762 630, 635, 636, 638, 639, 641, 646, 647, 651, 652,
763 657, 658, 662, 663, 667, 668, 673, 674, 679, 680,
764 684, 685, 690, 691, 696, 697, 701, 702, 707, 708,
765 713, 714, 718, 719, 724, 725, 729, 730, 735, 736,
766 741, 742, 747, 748, 759, 760, 771, 772, 783, 784,
767 785, 786, 787, 788, 789, 790, 791, 792, 793, 794,
768 798, 799, 803, 804, 808, 809, 813, 814, 815, 816,
769 817, 818, 819, 820, 821, 822, 823, 824, 825, 826,
770 827, 828, 829, 833, 838, 847, 848, 852, 857, 864,
771 874, 889, 894, 901, 903, 908, 909, 914, 919, 932,
772 933, 941, 945, 949, 953, 954, 958, 960, 965, 966,
773 967, 968, 970, 972, 974, 976, 981, 982, 986, 987,
774 991, 992, 993, 994, 998, 999, 1000, 1001, 1005, 1006,
775 1007, 1012, 1021, 1025, 1029, 1030, 1035, 1036, 1040, 1041,
776 1045, 1046, 1050, 1051, 1055, 1059, 1060, 1064, 1065, 1066,
777 1071, 1072, 1076, 1085, 1099, 1107, 1117, 1126, 1140, 1145,
778 1159, 1160, 1164, 1165, 1169, 1174
779 };
780 #endif
781
782 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
783 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
784 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
785 static const char *const yytname[] =
786 {
787 "$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN",
788 "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR", "CONSTTOKEN",
789 "CONTINUE", "FUNCTION", "RETURN", "VOIDTOKEN", "DELETETOKEN", "IF",
790 "THISTOKEN", "DO", "WHILE", "INTOKEN", "INSTANCEOF", "TYPEOF", "SWITCH",
791 "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "DEBUGGER",
792 "IF_WITHOUT_ELSE", "ELSE", "EQEQ", "NE", "STREQ", "STRNEQ", "LE", "GE",
793 "OR", "AND", "PLUSPLUS", "MINUSMINUS", "LSHIFT", "RSHIFT", "URSHIFT",
794 "PLUSEQUAL", "MINUSEQUAL", "MULTEQUAL", "DIVEQUAL", "LSHIFTEQUAL",
795 "RSHIFTEQUAL", "URSHIFTEQUAL", "ANDEQUAL", "MODEQUAL", "XOREQUAL",
796 "OREQUAL", "OPENBRACE", "CLOSEBRACE", "IDENT_IN", "NUMBER", "STRING",
797 "AUTOPLUSPLUS", "AUTOMINUSMINUS", "'|'", "'/'", "'^'", "'$'", "'?'",
798 "'*'", "'+'", "'{'", "'}'", "','", "'.'", "'\\\\'", "'('", "')'", "':'",
799 "'='", "'!'", "'['", "']'", "'-'", "'~'", "'%'", "'<'", "'>'", "'&'",
800 "';'", "$accept", "IDENT", "Disjunction", "RegExp", "Alternative",
801 "Term", "Assertion", "Quantifier", "QuantifierPrefix", "RAtom",
802 "PatternCharacter", "CharacterClass", "ClassRanges", "Literal",
803 "Property", "PropertyList", "PrimaryExpr", "PrimaryExprNoBrace",
804 "ArrayLiteral", "ElementList", "ElisionOpt", "Elision", "MemberExpr",
805 "MemberExprNoBF", "NewExpr", "NewExprNoBF", "CallExpr", "CallExprNoBF",
806 "Arguments", "ArgumentList", "LeftHandSideExpr", "LeftHandSideExprNoBF",
807 "PostfixExpr", "PostfixExprNoBF", "UnaryExprCommon", "UnaryExpr",
808 "UnaryExprNoBF", "MultiplicativeExpr", "MultiplicativeExprNoBF",
809 "AdditiveExpr", "AdditiveExprNoBF", "ShiftExpr", "ShiftExprNoBF",
810 "RelationalExpr", "RelationalExprNoIn", "RelationalExprNoBF",
811 "EqualityExpr", "EqualityExprNoIn", "EqualityExprNoBF", "BitwiseANDExpr",
812 "BitwiseANDExprNoIn", "BitwiseANDExprNoBF", "BitwiseXORExpr",
813 "BitwiseXORExprNoIn", "BitwiseXORExprNoBF", "BitwiseORExpr",
814 "BitwiseORExprNoIn", "BitwiseORExprNoBF", "LogicalANDExpr",
815 "LogicalANDExprNoIn", "LogicalANDExprNoBF", "LogicalORExpr",
816 "LogicalORExprNoIn", "LogicalORExprNoBF", "ConditionalExpr",
817 "ConditionalExprNoIn", "ConditionalExprNoBF", "AssignmentExpr",
818 "AssignmentExprNoIn", "AssignmentExprNoBF", "AssignmentOperator", "Expr",
819 "ExprNoIn", "ExprNoBF", "Statement", "Block", "VariableStatement",
820 "VariableDeclarationList", "VariableDeclarationListNoIn",
821 "ConstStatement", "ConstDeclarationList", "ConstDeclaration",
822 "Initializer", "InitializerNoIn", "EmptyStatement", "ExprStatement",
823 "IfStatement", "IterationStatement", "ExprOpt", "ExprNoInOpt",
824 "ContinueStatement", "BreakStatement", "ReturnStatement",
825 "WithStatement", "SwitchStatement", "CaseBlock", "CaseClausesOpt",
826 "CaseClauses", "CaseClause", "DefaultClause", "LabelledStatement",
827 "ThrowStatement", "TryStatement", "DebuggerStatement",
828 "FunctionDeclaration", "FunctionExpr", "FormalParameterList",
829 "FunctionBody", "Program", "SourceElements", 0
830 };
831 #endif
832
833 # ifdef YYPRINT
834 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
835 token YYLEX-NUM. */
836 static const yytype_uint16 yytoknum[] =
837 {
838 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
839 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
840 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
841 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
842 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
843 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
844 315, 316, 317, 318, 319, 320, 124, 47, 94, 36,
845 63, 42, 43, 123, 125, 44, 46, 92, 40, 41,
846 58, 61, 33, 91, 93, 45, 126, 37, 60, 62,
847 38, 59
848 };
849 # endif
850
851 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
852 static const yytype_uint8 yyr1[] =
853 {
854 0, 92, 93, 94, 94, 95, 95, 96, 96, 97,
855 97, 97, 98, 98, 99, 99, 100, 100, 100, 100,
856 100, 100, 101, 101, 101, 101, 101, 101, 101, 101,
857 101, 102, 103, 103, 104, 104, 104, 104, 105, 105,
858 105, 105, 105, 106, 106, 106, 106, 106, 107, 107,
859 108, 108, 108, 108, 109, 109, 109, 109, 109, 110,
860 110, 110, 111, 111, 112, 112, 113, 113, 114, 114,
861 114, 114, 114, 114, 115, 115, 115, 115, 116, 116,
862 117, 117, 118, 118, 118, 118, 119, 119, 119, 119,
863 120, 120, 121, 121, 122, 122, 123, 123, 124, 124,
864 124, 125, 125, 125, 126, 126, 126, 126, 126, 126,
865 126, 126, 126, 126, 126, 127, 127, 128, 128, 129,
866 129, 129, 129, 130, 130, 130, 130, 131, 131, 131,
867 132, 132, 132, 133, 133, 133, 133, 134, 134, 134,
868 134, 135, 135, 135, 135, 135, 135, 135, 136, 136,
869 136, 136, 136, 136, 137, 137, 137, 137, 137, 137,
870 137, 138, 138, 138, 138, 138, 139, 139, 139, 139,
871 139, 140, 140, 140, 140, 140, 141, 141, 142, 142,
872 143, 143, 144, 144, 145, 145, 146, 146, 147, 147,
873 148, 148, 149, 149, 150, 150, 151, 151, 152, 152,
874 153, 153, 154, 154, 155, 155, 156, 156, 157, 157,
875 158, 158, 159, 159, 160, 160, 161, 161, 162, 162,
876 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
877 163, 163, 164, 164, 165, 165, 166, 166, 166, 166,
878 166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
879 166, 166, 166, 167, 167, 168, 168, 169, 169, 169,
880 169, 170, 170, 170, 170, 171, 171, 172, 172, 173,
881 173, 174, 175, 176, 177, 177, 178, 178, 179, 179,
882 179, 179, 179, 179, 179, 179, 180, 180, 181, 181,
883 182, 182, 182, 182, 183, 183, 183, 183, 184, 184,
884 184, 184, 185, 186, 187, 187, 188, 188, 189, 189,
885 190, 190, 191, 191, 192, 193, 193, 194, 194, 194,
886 195, 195, 196, 196, 197, 197, 197, 197, 198, 198,
887 199, 199, 200, 200, 201, 201
888 };
889
890 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
891 static const yytype_uint8 yyr2[] =
892 {
893 0, 2, 1, 1, 3, 3, 4, 0, 2, 1,
894 1, 2, 1, 1, 1, 2, 1, 1, 1, 3,
895 4, 5, 1, 1, 2, 2, 1, 3, 5, 5,
896 5, 1, 3, 4, 1, 1, 3, 2, 1, 1,
897 1, 1, 1, 3, 3, 3, 7, 8, 1, 3,
898 1, 2, 3, 4, 1, 1, 1, 1, 3, 3,
899 3, 5, 2, 4, 0, 1, 1, 2, 1, 1,
900 1, 4, 3, 3, 1, 4, 3, 3, 1, 2,
901 1, 2, 2, 2, 4, 3, 2, 2, 4, 3,
902 2, 3, 1, 3, 1, 1, 1, 1, 1, 2,
903 2, 1, 2, 2, 2, 2, 2, 2, 2, 2,
904 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
905 3, 3, 3, 1, 3, 3, 3, 1, 3, 3,
906 1, 3, 3, 1, 3, 3, 3, 1, 3, 3,
907 3, 1, 3, 3, 3, 3, 3, 3, 1, 3,
908 3, 3, 3, 3, 1, 3, 3, 3, 3, 3,
909 3, 1, 3, 3, 3, 3, 1, 3, 3, 3,
910 3, 1, 3, 3, 3, 3, 1, 3, 1, 3,
911 1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
912 1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
913 1, 3, 1, 3, 1, 3, 1, 5, 1, 5,
914 1, 5, 1, 3, 1, 3, 1, 3, 1, 1,
915 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
916 1, 3, 1, 3, 1, 3, 1, 1, 1, 1,
917 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
918 1, 1, 1, 2, 3, 3, 3, 1, 2, 3,
919 4, 1, 2, 3, 4, 3, 3, 1, 3, 1,
920 2, 2, 2, 1, 2, 2, 5, 7, 7, 7,
921 5, 9, 10, 7, 8, 9, 0, 1, 0, 1,
922 2, 2, 3, 3, 2, 2, 3, 3, 2, 2,
923 3, 3, 5, 5, 3, 5, 0, 1, 1, 2,
924 3, 4, 2, 3, 3, 3, 3, 4, 7, 9,
925 2, 2, 7, 8, 6, 7, 7, 8, 1, 3,
926 0, 1, 0, 1, 1, 2
927 };
928
929 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
930 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
931 means the default is an error. */
932 static const yytype_uint16 yydefact[] =
933 {
934 332, 38, 39, 40, 0, 0, 0, 0, 0, 0,
935 0, 0, 0, 0, 0, 54, 0, 0, 0, 0,
936 0, 0, 0, 0, 0, 0, 0, 2, 41, 42,
937 0, 0, 0, 0, 0, 64, 0, 0, 273, 57,
938 55, 74, 56, 80, 96, 97, 101, 117, 118, 123,
939 130, 137, 154, 171, 180, 186, 192, 198, 204, 210,
940 216, 234, 0, 334, 236, 237, 238, 240, 241, 242,
941 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
942 239, 0, 333, 295, 294, 0, 288, 0, 0, 0,
943 7, 57, 69, 68, 50, 78, 81, 70, 257, 0,
944 269, 0, 267, 291, 290, 0, 0, 299, 298, 78,
945 94, 95, 98, 115, 116, 119, 127, 133, 141, 161,
946 176, 182, 188, 194, 200, 206, 212, 230, 0, 98,
947 105, 104, 0, 0, 0, 106, 0, 0, 0, 0,
948 321, 320, 107, 109, 253, 0, 108, 110, 111, 0,
949 114, 66, 0, 0, 65, 112, 113, 0, 0, 0,
950 0, 86, 0, 0, 87, 102, 103, 219, 220, 221,
951 222, 223, 224, 225, 226, 229, 227, 228, 218, 0,
952 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
953 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
954 0, 0, 0, 0, 275, 0, 274, 1, 335, 297,
955 296, 0, 98, 148, 166, 178, 184, 190, 196, 202,
956 208, 214, 232, 289, 0, 78, 79, 0, 0, 51,
957 0, 0, 0, 48, 0, 0, 3, 0, 0, 77,
958 0, 258, 256, 0, 255, 270, 266, 0, 265, 293,
959 292, 0, 82, 0, 0, 83, 99, 100, 0, 0,
960 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
961 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
962 0, 0, 0, 301, 0, 300, 0, 0, 0, 0,
963 0, 316, 315, 0, 0, 254, 58, 64, 60, 59,
964 62, 67, 314, 76, 90, 0, 92, 0, 89, 0,
965 217, 125, 124, 126, 131, 132, 138, 139, 140, 160,
966 159, 157, 158, 155, 156, 172, 173, 174, 175, 181,
967 187, 193, 199, 205, 0, 235, 261, 0, 0, 0,
968 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
969 0, 0, 0, 0, 0, 0, 286, 73, 0, 328,
970 0, 0, 0, 0, 0, 0, 52, 0, 5, 7,
971 12, 13, 23, 0, 7, 0, 31, 8, 9, 10,
972 22, 26, 72, 0, 271, 259, 268, 0, 0, 85,
973 0, 213, 121, 120, 122, 128, 129, 134, 135, 136,
974 147, 146, 144, 145, 142, 143, 162, 163, 164, 165,
975 177, 183, 189, 195, 201, 0, 231, 0, 0, 0,
976 0, 0, 0, 317, 0, 0, 91, 75, 88, 0,
977 0, 0, 262, 0, 286, 0, 98, 215, 153, 151,
978 152, 149, 150, 167, 168, 169, 170, 179, 185, 191,
979 197, 203, 0, 233, 287, 0, 330, 0, 0, 0,
980 0, 45, 44, 43, 0, 53, 49, 6, 4, 25,
981 24, 0, 0, 34, 0, 35, 0, 18, 16, 17,
982 0, 11, 14, 71, 260, 330, 0, 84, 0, 276,
983 0, 280, 306, 303, 302, 0, 61, 63, 93, 211,
984 0, 272, 0, 263, 0, 0, 0, 286, 0, 331,
985 329, 330, 330, 0, 0, 0, 7, 7, 7, 27,
986 0, 32, 0, 37, 0, 15, 0, 330, 207, 0,
987 0, 0, 0, 307, 308, 0, 0, 0, 264, 286,
988 283, 209, 0, 324, 0, 0, 330, 330, 0, 0,
989 0, 0, 33, 36, 19, 0, 322, 0, 277, 279,
990 278, 0, 0, 304, 306, 309, 318, 284, 0, 0,
991 0, 325, 326, 0, 0, 330, 28, 29, 30, 0,
992 20, 323, 310, 312, 0, 0, 285, 0, 281, 327,
993 46, 0, 21, 311, 313, 305, 319, 282, 47
994 };
995
996 /* YYDEFGOTO[NTERM-NUM]. */
997 static const yytype_int16 yydefgoto[] =
998 {
999 -1, 91, 235, 92, 236, 377, 378, 481, 482, 379,
1000 380, 381, 523, 40, 233, 234, 93, 94, 42, 152,
1001 153, 154, 109, 43, 110, 44, 111, 45, 161, 305,
1002 129, 46, 113, 47, 114, 115, 49, 116, 50, 117,
1003 51, 118, 52, 119, 214, 53, 120, 215, 54, 121,
1004 216, 55, 122, 217, 56, 123, 218, 57, 124, 219,
1005 58, 125, 220, 59, 126, 221, 60, 127, 222, 61,
1006 339, 454, 223, 62, 63, 64, 65, 99, 337, 66,
1007 101, 102, 241, 432, 67, 68, 69, 70, 455, 224,
1008 71, 72, 73, 74, 75, 493, 532, 533, 534, 564,
1009 76, 77, 78, 79, 80, 97, 360, 508, 81, 509
1010 };
1011
1012 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1013 STATE-NUM. */
1014 #define YYPACT_NINF -423
1015 static const yytype_int16 yypact[] =
1016 {
1017 1073, -423, -423, -423, 5, -33, 367, -6, -6, 23,
1018 -6, 260, 1303, 1303, 16, -423, 1073, 20, 1303, 85,
1019 116, 1303, 137, 18, 1303, 1303, 842, -423, -423, -423,
1020 1303, 1303, 1303, 1303, 1303, 138, 1303, 1303, -423, 175,
1021 -423, -423, -423, 218, -423, 219, 440, -423, -423, -423,
1022 10, 114, 312, 150, 368, 151, 190, 209, 230, -21,
1023 -423, -423, 12, -423, -423, -423, -423, -423, -423, -423,
1024 -423, -423, -423, -423, -423, -423, -423, -423, -423, -423,
1025 -423, 282, 1073, -423, -423, 35, 719, 367, 127, 347,
1026 -423, -423, -423, -423, -423, 235, -423, -423, 211, 24,
1027 211, 31, -423, -423, -423, 36, 239, -423, -423, 235,
1028 -423, 250, 886, -423, -423, -423, 94, 121, 420, 178,
1029 376, 249, 280, 263, 340, 13, -423, -423, 43, 271,
1030 -423, -423, 1303, 370, 1303, -423, 1303, 1303, 46, -8,
1031 -423, -423, -423, -423, -423, 984, -423, -423, -423, 177,
1032 -423, -423, 132, 1104, 290, -423, -423, 1073, -6, 1188,
1033 1303, -423, -6, 1303, -423, -423, -423, -423, -423, -423,
1034 -423, -423, -423, -423, -423, -423, -423, -423, -423, 1303,
1035 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303,
1036 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303,
1037 1303, 1303, 1303, 1303, -423, 1303, -423, -423, -423, -423,
1038 -423, -6, 344, 420, 19, 402, 325, 348, 352, 378,
1039 78, -423, -423, 356, 332, 235, -423, -18, 349, -423,
1040 355, 366, 25, -423, 135, 365, 286, -6, 1303, -423,
1041 1303, -423, -423, -6, -423, -423, -423, -6, -423, -423,
1042 -423, 95, -423, -6, 1303, -423, -423, -423, 1303, 1303,
1043 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303,
1044 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303,
1045 1303, 1303, 1303, -423, 1303, -423, 194, 384, 206, 214,
1046 241, -423, -423, 385, 137, -423, -423, 138, -423, -423,
1047 -423, -423, -423, -423, -423, 255, -423, 165, -423, 173,
1048 -423, -423, -423, -423, 94, 94, 121, 121, 121, 420,
1049 420, 420, 420, 420, 420, 178, 178, 178, 178, 376,
1050 249, 280, 263, 340, 388, -423, 9, 117, 1303, 1303,
1051 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303, 1303,
1052 1303, 1303, 1303, 1303, 1303, 1303, 1303, -423, 389, -423,
1053 256, 99, 1303, 1303, 1303, 391, -423, 381, -6, -423,
1054 -423, -423, -423, 136, 400, 244, -423, -423, -423, 382,
1055 -423, -423, -423, 184, -423, 211, -423, 412, 261, -423,
1056 196, -423, -423, -423, -423, 94, 94, 121, 121, 121,
1057 420, 420, 420, 420, 420, 420, 178, 178, 178, 178,
1058 376, 249, 280, 263, 340, 392, -423, 1073, 1303, 1073,
1059 414, 1073, -6, -423, 1219, 1303, -423, -423, -423, 1303,
1060 1303, 1303, 453, -6, 1303, 262, 886, -423, 420, 420,
1061 420, 420, 420, 19, 19, 19, 19, 402, 325, 348,
1062 352, 378, 397, -423, 403, 390, 1073, -6, 421, 423,
1063 274, -423, -423, -423, 119, -423, -423, -423, -423, -423,
1064 -423, 153, 408, -423, 323, -423, 92, -423, -423, -423,
1065 417, -423, 429, -423, -423, 1073, 441, -423, 1303, 467,
1066 281, -423, 495, -423, -423, 424, -423, -423, -423, -423,
1067 299, -423, 1303, 425, 413, 1073, 1303, 1303, 447, 1073,
1068 -423, 1073, 1073, 451, 454, 301, -423, -423, -423, -423,
1069 161, -423, 323, 106, 315, -423, 457, 1073, -423, 1073,
1070 37, 1303, 70, 495, -423, 137, 1073, 304, -423, 1303,
1071 -423, -423, 446, -423, 459, 466, 1073, 1073, 469, 452,
1072 455, 461, -423, 106, -423, 188, -423, 470, -423, -423,
1073 -423, 75, 458, -423, 495, -423, 501, -423, 1073, 464,
1074 1073, -423, -423, 473, 484, 1073, -423, -423, -423, 474,
1075 -423, -423, 1073, 1073, 489, 137, -423, 1073, -423, -423,
1076 -423, 491, -423, 1073, 1073, -423, -423, -423, -423
1077 };
1078
1079 /* YYPGOTO[NTERM-NUM]. */
1080 static const yytype_int16 yypgoto[] =
1081 {
1082 -423, 0, -334, -423, -423, -423, -423, -423, -423, -423,
1083 -423, -423, -370, -423, 189, -423, -423, 30, -423, -423,
1084 264, -423, 42, -423, 44, -423, -423, -423, -16, -423,
1085 534, -423, -423, -423, 133, 39, -423, -92, -423, -62,
1086 -423, 485, -423, 34, 113, -423, -145, 213, -423, -139,
1087 208, -423, -132, 212, -423, -129, 217, -423, -140, 207,
1088 -423, -423, -423, -423, -423, -423, -423, -138, -321, -423,
1089 -32, 6, -423, -423, 97, -11, -423, -423, -423, -423,
1090 -423, 317, -97, 62, -423, -423, -423, -423, -422, -423,
1091 -423, -423, -423, -423, -423, -423, 8, -423, 40, -423,
1092 -423, -423, -423, -423, -423, -423, -250, -411, -423, 2
1093 };
1094
1095 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1096 positive, shift that token. If negative, reduce the rule which
1097 number is the opposite. If zero, do what YYDEFACT says.
1098 If YYTABLE_NINF, syntax error. */
1099 #define YYTABLE_NINF -1
1100 static const yytype_uint16 yytable[] =
1101 {
1102 39, 388, 82, 245, 85, 476, 83, 98, 100, 105,
1103 106, 139, 504, 204, 179, 300, 39, 128, 437, 140,
1104 202, 306, 293, 294, 103, 242, 39, 138, 145, 164,
1105 41, 430, 246, 452, 453, 468, 209, 249, 559, 149,
1106 472, 310, 340, 27, 283, 86, 41, 291, 95, 203,
1107 96, 130, 131, 329, 281, 27, 41, 135, 341, 342,
1108 330, 358, 333, 142, 143, 334, 27, 335, 331, 146,
1109 147, 148, 332, 150, 526, 155, 156, 180, 562, 239,
1110 258, 181, 39, 282, 27, 542, 27, 205, 228, 232,
1111 431, 314, 315, 252, 132, 255, 84, 182, 134, 243,
1112 544, 545, 384, 206, 520, 364, 247, 343, 344, 141,
1113 501, 460, 41, 133, 104, 244, 557, 569, 284, 353,
1114 391, 284, 248, 316, 317, 318, 210, 250, 560, 225,
1115 563, 226, 410, 48, 285, 573, 574, 292, 286, 411,
1116 288, 414, 289, 290, 415, 39, 416, 412, 354, 48,
1117 284, 413, 553, 27, 473, 582, 27, 39, 303, 48,
1118 27, 259, 308, 136, 591, 260, 307, 27, 473, 309,
1119 395, 396, 188, 189, 387, 41, 521, 522, 459, 208,
1120 27, 261, 549, 550, 551, 541, 183, 41, 27, 190,
1121 191, 522, 433, 262, 137, 366, 26, 27, 514, 184,
1122 267, 268, 397, 398, 399, 227, 263, 297, 434, 357,
1123 367, 336, 469, 151, 515, 48, 298, 269, 270, 311,
1124 312, 313, 27, 473, 461, 462, 463, 359, 325, 326,
1125 327, 328, 365, 516, 517, 518, 376, 382, 192, 193,
1126 284, 198, 208, 385, 383, 552, 522, 100, 284, 427,
1127 579, 359, 284, 389, 302, 157, 296, 428, 199, 284,
1128 390, 107, 580, 1, 2, 3, 271, 272, 483, 284,
1129 87, 284, 201, 417, 88, 200, 12, 13, 48, 15,
1130 487, 284, 207, 423, 18, 419, 497, 498, 484, 284,
1131 48, 499, 240, 420, 158, 162, 159, 159, 392, 393,
1132 394, 160, 163, 24, 25, 27, 473, 406, 407, 408,
1133 409, 237, 474, 159, 256, 257, 284, 251, 238, 89,
1134 421, 27, 28, 29, 30, 31, 253, 90, 159, 279,
1135 425, 457, 32, 254, 426, 458, 457, 284, 33, 277,
1136 486, 505, 34, 35, 435, 36, 37, 27, 278, 457,
1137 528, 108, 369, 513, 370, 371, 284, 185, 186, 187,
1138 530, 359, 372, 373, 374, 301, 338, 232, 467, 375,
1139 1, 2, 3, 470, 284, 475, 457, 87, 536, 284,
1140 548, 88, 280, 568, 27, 473, 15, 256, 257, 554,
1141 555, 287, 167, 168, 169, 170, 171, 172, 173, 174,
1142 175, 176, 177, 194, 195, 196, 197, 229, 27, 230,
1143 231, 273, 274, 275, 276, 349, 350, 39, 351, 39,
1144 352, 39, 495, 356, 490, 178, 89, 361, 27, 28,
1145 29, 355, 368, 503, 90, 362, 500, 345, 346, 347,
1146 348, 465, 27, 230, 231, 33, 363, 41, 456, 41,
1147 35, 41, 477, 478, 479, 480, 39, 510, 443, 444,
1148 445, 446, 418, 422, 359, 264, 265, 266, 429, 464,
1149 471, 485, 488, 492, 475, 502, 475, 506, 284, 524,
1150 511, 507, 512, 165, 166, 39, 41, 519, 167, 168,
1151 169, 170, 171, 172, 173, 174, 175, 176, 177, 525,
1152 527, 529, 531, 535, 539, 39, 431, 543, 537, 39,
1153 546, 39, 39, 547, 489, 41, 491, 556, 494, 571,
1154 475, 178, 475, 475, 566, 570, 572, 39, 575, 39,
1155 581, 576, 585, 589, 577, 41, 39, 561, 583, 41,
1156 578, 41, 41, 587, 590, 112, 39, 39, 592, 595,
1157 48, 598, 48, 475, 48, 112, 466, 41, 448, 41,
1158 451, 424, 447, 449, 386, 538, 41, 112, 39, 450,
1159 39, 213, 584, 565, 596, 39, 41, 41, 0, 0,
1160 0, 0, 39, 39, 593, 594, 0, 39, 0, 48,
1161 0, 0, 0, 39, 39, 0, 0, 0, 41, 0,
1162 41, 0, 540, 0, 0, 41, 208, 0, 0, 0,
1163 0, 0, 41, 41, 0, 0, 0, 41, 48, 0,
1164 212, 0, 0, 41, 41, 0, 558, 0, 0, 0,
1165 0, 0, 0, 567, 0, 0, 0, 0, 48, 0,
1166 0, 0, 48, 0, 48, 48, 0, 0, 0, 0,
1167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1168 48, 0, 48, 0, 0, 586, 112, 588, 112, 48,
1169 112, 112, 0, 319, 320, 321, 322, 323, 324, 48,
1170 48, 0, 0, 0, 597, 0, 0, 112, 0, 0,
1171 208, 208, 0, 112, 112, 0, 0, 112, 0, 0,
1172 0, 48, 0, 48, 0, 0, 0, 0, 48, 0,
1173 0, 0, 0, 112, 0, 48, 48, 0, 0, 0,
1174 48, 0, 1, 2, 3, 0, 48, 48, 0, 87,
1175 211, 0, 0, 88, 0, 12, 13, 112, 15, 112,
1176 0, 0, 0, 18, 0, 0, 0, 0, 0, 0,
1177 0, 0, 400, 401, 402, 403, 404, 405, 0, 0,
1178 0, 0, 24, 25, 0, 0, 0, 0, 0, 0,
1179 0, 0, 112, 0, 112, 0, 0, 0, 89, 0,
1180 27, 28, 29, 30, 31, 0, 90, 0, 112, 0,
1181 0, 32, 112, 0, 0, 0, 0, 33, 0, 0,
1182 0, 34, 35, 0, 36, 37, 0, 0, 0, 0,
1183 0, 0, 0, 0, 0, 0, 112, 0, 112, 0,
1184 0, 0, 0, 0, 213, 438, 439, 440, 441, 442,
1185 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1186 213, 0, 0, 0, 0, 1, 2, 3, 4, 0,
1187 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1188 14, 15, 16, 17, 0, 0, 18, 19, 20, 0,
1189 21, 22, 112, 436, 23, 0, 0, 0, 0, 0,
1190 0, 0, 0, 0, 0, 24, 25, 0, 436, 436,
1191 112, 0, 0, 0, 0, 0, 112, 112, 112, 0,
1192 0, 26, 144, 27, 28, 29, 30, 31, 0, 0,
1193 0, 0, 0, 0, 32, 0, 213, 0, 0, 0,
1194 33, 0, 0, 0, 34, 35, 0, 36, 37, 256,
1195 257, 0, 0, 38, 167, 168, 169, 170, 171, 172,
1196 173, 174, 175, 176, 177, 0, 0, 0, 0, 0,
1197 0, 0, 112, 0, 0, 0, 0, 0, 112, 112,
1198 0, 0, 0, 112, 112, 436, 0, 178, 112, 0,
1199 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1200 0, 0, 0, 0, 0, 0, 0, 1, 2, 3,
1201 4, 213, 0, 5, 6, 7, 8, 9, 10, 11,
1202 12, 13, 14, 15, 16, 17, 0, 0, 18, 19,
1203 20, 0, 21, 22, 0, 0, 23, 0, 0, 0,
1204 0, 0, 112, 0, 0, 0, 0, 24, 25, 0,
1205 0, 0, 0, 0, 0, 0, 112, 0, 0, 0,
1206 436, 112, 0, 26, 295, 27, 28, 29, 30, 31,
1207 0, 0, 0, 0, 0, 0, 32, 0, 0, 0,
1208 0, 0, 33, 0, 0, 112, 34, 35, 0, 36,
1209 37, 0, 0, 112, 0, 38, 1, 2, 3, 4,
1210 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
1211 13, 14, 15, 16, 17, 0, 0, 18, 19, 20,
1212 0, 21, 22, 0, 0, 23, 0, 1, 2, 3,
1213 0, 0, 0, 0, 87, 0, 24, 25, 88, 0,
1214 12, 13, 0, 15, 0, 0, 0, 0, 18, 0,
1215 0, 0, 26, 0, 27, 28, 29, 30, 31, 0,
1216 0, 0, 0, 0, 0, 32, 0, 24, 25, 0,
1217 0, 33, 0, 0, 0, 34, 35, 0, 36, 37,
1218 0, 0, 0, 89, 38, 27, 28, 29, 30, 31,
1219 0, 90, 0, 0, 0, 0, 32, 0, 0, 0,
1220 0, 0, 33, 0, 0, 0, 34, 35, 299, 36,
1221 37, 1, 2, 3, 0, 0, 0, 0, 87, 0,
1222 0, 0, 88, 0, 12, 13, 0, 15, 0, 0,
1223 0, 0, 18, 0, 0, 0, 0, 0, 0, 0,
1224 0, 0, 1, 2, 3, 0, 0, 0, 0, 87,
1225 0, 24, 25, 88, 0, 12, 13, 0, 15, 0,
1226 0, 0, 0, 18, 0, 0, 0, 89, 0, 27,
1227 28, 29, 30, 31, 0, 90, 0, 0, 0, 0,
1228 32, 0, 24, 25, 0, 0, 33, 304, 0, 0,
1229 34, 35, 0, 36, 37, 0, 0, 0, 89, 0,
1230 27, 28, 29, 30, 31, 0, 90, 0, 0, 0,
1231 0, 32, 0, 0, 0, 0, 0, 33, 0, 0,
1232 0, 34, 35, 496, 36, 37, 1, 2, 3, 0,
1233 0, 0, 0, 87, 0, 0, 0, 88, 0, 12,
1234 13, 0, 15, 0, 0, 0, 0, 18, 0, 0,
1235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1236 0, 0, 0, 0, 0, 0, 24, 25, 0, 0,
1237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1238 0, 0, 89, 0, 27, 28, 29, 30, 31, 0,
1239 90, 0, 0, 0, 0, 32, 0, 0, 0, 0,
1240 0, 33, 0, 0, 0, 34, 35, 0, 36, 37
1241 };
1242
1243 static const yytype_int16 yycheck[] =
1244 {
1245 0, 251, 0, 100, 4, 375, 1, 7, 8, 9,
1246 10, 22, 434, 1, 46, 153, 16, 11, 339, 1,
1247 41, 159, 30, 31, 1, 1, 26, 21, 26, 45,
1248 0, 22, 1, 354, 355, 369, 1, 1, 1, 33,
1249 374, 179, 23, 61, 1, 78, 16, 1, 6, 70,
1250 6, 12, 13, 198, 41, 61, 26, 18, 39, 40,
1251 199, 79, 202, 24, 25, 203, 61, 205, 200, 30,
1252 31, 32, 201, 34, 485, 36, 37, 67, 8, 95,
1253 112, 71, 82, 70, 61, 507, 61, 75, 88, 89,
1254 81, 183, 184, 109, 78, 111, 91, 87, 78, 75,
1255 511, 512, 240, 91, 474, 80, 75, 88, 89, 91,
1256 431, 361, 82, 16, 91, 91, 527, 539, 75, 41,
1257 258, 75, 91, 185, 186, 187, 91, 91, 91, 87,
1258 60, 87, 277, 0, 91, 546, 547, 91, 132, 278,
1259 134, 281, 136, 137, 282, 145, 284, 279, 70, 16,
1260 75, 280, 522, 61, 62, 80, 61, 157, 158, 26,
1261 61, 67, 162, 78, 575, 71, 160, 61, 62, 163,
1262 262, 263, 22, 23, 79, 145, 84, 85, 79, 82,
1263 61, 87, 516, 517, 518, 506, 72, 157, 61, 39,
1264 40, 85, 75, 72, 78, 60, 59, 61, 79, 85,
1265 22, 23, 264, 265, 266, 78, 85, 75, 91, 225,
1266 75, 211, 76, 75, 464, 82, 84, 39, 40, 180,
1267 181, 182, 61, 62, 362, 363, 364, 227, 194, 195,
1268 196, 197, 232, 80, 81, 82, 236, 237, 88, 89,
1269 75, 90, 145, 243, 238, 84, 85, 247, 75, 84,
1270 62, 251, 75, 253, 157, 80, 79, 84, 68, 75,
1271 254, 1, 74, 3, 4, 5, 88, 89, 84, 75,
1272 10, 75, 42, 79, 14, 66, 16, 17, 145, 19,
1273 84, 75, 0, 294, 24, 79, 424, 425, 385, 75,
1274 157, 429, 81, 79, 76, 76, 78, 78, 259, 260,
1275 261, 83, 83, 43, 44, 61, 62, 273, 274, 275,
1276 276, 76, 68, 78, 43, 44, 75, 78, 83, 59,
1277 79, 61, 62, 63, 64, 65, 76, 67, 78, 66,
1278 75, 75, 72, 83, 79, 79, 75, 75, 78, 90,
1279 79, 79, 82, 83, 338, 85, 86, 61, 68, 75,
1280 488, 91, 66, 79, 68, 69, 75, 45, 46, 47,
1281 79, 361, 76, 77, 78, 75, 22, 367, 368, 83,
1282 3, 4, 5, 373, 75, 375, 75, 10, 79, 75,
1283 79, 14, 42, 79, 61, 62, 19, 43, 44, 74,
1284 75, 21, 48, 49, 50, 51, 52, 53, 54, 55,
1285 56, 57, 58, 35, 36, 37, 38, 60, 61, 62,
1286 63, 35, 36, 37, 38, 90, 68, 417, 66, 419,
1287 42, 421, 422, 91, 418, 81, 59, 78, 61, 62,
1288 63, 75, 67, 433, 67, 80, 430, 35, 36, 37,
1289 38, 60, 61, 62, 63, 78, 80, 417, 59, 419,
1290 83, 421, 70, 71, 72, 73, 456, 457, 345, 346,
1291 347, 348, 78, 78, 464, 45, 46, 47, 80, 78,
1292 70, 59, 80, 59, 474, 22, 476, 80, 75, 62,
1293 59, 91, 59, 43, 44, 485, 456, 79, 48, 49,
1294 50, 51, 52, 53, 54, 55, 56, 57, 58, 70,
1295 59, 34, 7, 79, 91, 505, 81, 60, 502, 509,
1296 59, 511, 512, 59, 417, 485, 419, 60, 421, 60,
1297 520, 81, 522, 523, 535, 79, 60, 527, 59, 529,
1298 60, 79, 31, 60, 79, 505, 536, 531, 80, 509,
1299 79, 511, 512, 79, 60, 11, 546, 547, 74, 60,
1300 417, 60, 419, 553, 421, 21, 367, 527, 350, 529,
1301 353, 297, 349, 351, 247, 503, 536, 33, 568, 352,
1302 570, 86, 564, 533, 585, 575, 546, 547, -1, -1,
1303 -1, -1, 582, 583, 582, 583, -1, 587, -1, 456,
1304 -1, -1, -1, 593, 594, -1, -1, -1, 568, -1,
1305 570, -1, 505, -1, -1, 575, 509, -1, -1, -1,
1306 -1, -1, 582, 583, -1, -1, -1, 587, 485, -1,
1307 86, -1, -1, 593, 594, -1, 529, -1, -1, -1,
1308 -1, -1, -1, 536, -1, -1, -1, -1, 505, -1,
1309 -1, -1, 509, -1, 511, 512, -1, -1, -1, -1,
1310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1311 527, -1, 529, -1, -1, 568, 132, 570, 134, 536,
1312 136, 137, -1, 188, 189, 190, 191, 192, 193, 546,
1313 547, -1, -1, -1, 587, -1, -1, 153, -1, -1,
1314 593, 594, -1, 159, 160, -1, -1, 163, -1, -1,
1315 -1, 568, -1, 570, -1, -1, -1, -1, 575, -1,
1316 -1, -1, -1, 179, -1, 582, 583, -1, -1, -1,
1317 587, -1, 3, 4, 5, -1, 593, 594, -1, 10,
1318 11, -1, -1, 14, -1, 16, 17, 203, 19, 205,
1319 -1, -1, -1, 24, -1, -1, -1, -1, -1, -1,
1320 -1, -1, 267, 268, 269, 270, 271, 272, -1, -1,
1321 -1, -1, 43, 44, -1, -1, -1, -1, -1, -1,
1322 -1, -1, 238, -1, 240, -1, -1, -1, 59, -1,
1323 61, 62, 63, 64, 65, -1, 67, -1, 254, -1,
1324 -1, 72, 258, -1, -1, -1, -1, 78, -1, -1,
1325 -1, 82, 83, -1, 85, 86, -1, -1, -1, -1,
1326 -1, -1, -1, -1, -1, -1, 282, -1, 284, -1,
1327 -1, -1, -1, -1, 339, 340, 341, 342, 343, 344,
1328 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1329 355, -1, -1, -1, -1, 3, 4, 5, 6, -1,
1330 -1, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1331 18, 19, 20, 21, -1, -1, 24, 25, 26, -1,
1332 28, 29, 338, 339, 32, -1, -1, -1, -1, -1,
1333 -1, -1, -1, -1, -1, 43, 44, -1, 354, 355,
1334 356, -1, -1, -1, -1, -1, 362, 363, 364, -1,
1335 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
1336 -1, -1, -1, -1, 72, -1, 431, -1, -1, -1,
1337 78, -1, -1, -1, 82, 83, -1, 85, 86, 43,
1338 44, -1, -1, 91, 48, 49, 50, 51, 52, 53,
1339 54, 55, 56, 57, 58, -1, -1, -1, -1, -1,
1340 -1, -1, 418, -1, -1, -1, -1, -1, 424, 425,
1341 -1, -1, -1, 429, 430, 431, -1, 81, 434, -1,
1342 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1343 -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
1344 6, 506, -1, 9, 10, 11, 12, 13, 14, 15,
1345 16, 17, 18, 19, 20, 21, -1, -1, 24, 25,
1346 26, -1, 28, 29, -1, -1, 32, -1, -1, -1,
1347 -1, -1, 488, -1, -1, -1, -1, 43, 44, -1,
1348 -1, -1, -1, -1, -1, -1, 502, -1, -1, -1,
1349 506, 507, -1, 59, 60, 61, 62, 63, 64, 65,
1350 -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
1351 -1, -1, 78, -1, -1, 531, 82, 83, -1, 85,
1352 86, -1, -1, 539, -1, 91, 3, 4, 5, 6,
1353 -1, -1, 9, 10, 11, 12, 13, 14, 15, 16,
1354 17, 18, 19, 20, 21, -1, -1, 24, 25, 26,
1355 -1, 28, 29, -1, -1, 32, -1, 3, 4, 5,
1356 -1, -1, -1, -1, 10, -1, 43, 44, 14, -1,
1357 16, 17, -1, 19, -1, -1, -1, -1, 24, -1,
1358 -1, -1, 59, -1, 61, 62, 63, 64, 65, -1,
1359 -1, -1, -1, -1, -1, 72, -1, 43, 44, -1,
1360 -1, 78, -1, -1, -1, 82, 83, -1, 85, 86,
1361 -1, -1, -1, 59, 91, 61, 62, 63, 64, 65,
1362 -1, 67, -1, -1, -1, -1, 72, -1, -1, -1,
1363 -1, -1, 78, -1, -1, -1, 82, 83, 84, 85,
1364 86, 3, 4, 5, -1, -1, -1, -1, 10, -1,
1365 -1, -1, 14, -1, 16, 17, -1, 19, -1, -1,
1366 -1, -1, 24, -1, -1, -1, -1, -1, -1, -1,
1367 -1, -1, 3, 4, 5, -1, -1, -1, -1, 10,
1368 -1, 43, 44, 14, -1, 16, 17, -1, 19, -1,
1369 -1, -1, -1, 24, -1, -1, -1, 59, -1, 61,
1370 62, 63, 64, 65, -1, 67, -1, -1, -1, -1,
1371 72, -1, 43, 44, -1, -1, 78, 79, -1, -1,
1372 82, 83, -1, 85, 86, -1, -1, -1, 59, -1,
1373 61, 62, 63, 64, 65, -1, 67, -1, -1, -1,
1374 -1, 72, -1, -1, -1, -1, -1, 78, -1, -1,
1375 -1, 82, 83, 84, 85, 86, 3, 4, 5, -1,
1376 -1, -1, -1, 10, -1, -1, -1, 14, -1, 16,
1377 17, -1, 19, -1, -1, -1, -1, 24, -1, -1,
1378 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1379 -1, -1, -1, -1, -1, -1, 43, 44, -1, -1,
1380 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1381 -1, -1, 59, -1, 61, 62, 63, 64, 65, -1,
1382 67, -1, -1, -1, -1, 72, -1, -1, -1, -1,
1383 -1, 78, -1, -1, -1, 82, 83, -1, 85, 86
1384 };
1385
1386 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1387 symbol of state STATE-NUM. */
1388 static const yytype_uint8 yystos[] =
1389 {
1390 0, 3, 4, 5, 6, 9, 10, 11, 12, 13,
1391 14, 15, 16, 17, 18, 19, 20, 21, 24, 25,
1392 26, 28, 29, 32, 43, 44, 59, 61, 62, 63,
1393 64, 65, 72, 78, 82, 83, 85, 86, 91, 93,
1394 105, 109, 110, 115, 117, 119, 123, 125, 126, 128,
1395 130, 132, 134, 137, 140, 143, 146, 149, 152, 155,
1396 158, 161, 165, 166, 167, 168, 171, 176, 177, 178,
1397 179, 182, 183, 184, 185, 186, 192, 193, 194, 195,
1398 196, 200, 201, 1, 91, 93, 78, 10, 14, 59,
1399 67, 93, 95, 108, 109, 114, 116, 197, 93, 169,
1400 93, 172, 173, 1, 91, 93, 93, 1, 91, 114,
1401 116, 118, 122, 124, 126, 127, 129, 131, 133, 135,
1402 138, 141, 144, 147, 150, 153, 156, 159, 163, 122,
1403 127, 127, 78, 166, 78, 127, 78, 78, 163, 167,
1404 1, 91, 127, 127, 60, 201, 127, 127, 127, 163,
1405 127, 75, 111, 112, 113, 127, 127, 80, 76, 78,
1406 83, 120, 76, 83, 120, 43, 44, 48, 49, 50,
1407 51, 52, 53, 54, 55, 56, 57, 58, 81, 162,
1408 67, 71, 87, 72, 85, 45, 46, 47, 22, 23,
1409 39, 40, 88, 89, 35, 36, 37, 38, 90, 68,
1410 66, 42, 41, 70, 1, 75, 91, 0, 166, 1,
1411 91, 11, 122, 133, 136, 139, 142, 145, 148, 151,
1412 154, 157, 160, 164, 181, 114, 116, 78, 93, 60,
1413 62, 63, 93, 106, 107, 94, 96, 76, 83, 120,
1414 81, 174, 1, 75, 91, 174, 1, 75, 91, 1,
1415 91, 78, 120, 76, 83, 120, 43, 44, 162, 67,
1416 71, 87, 72, 85, 45, 46, 47, 22, 23, 39,
1417 40, 88, 89, 35, 36, 37, 38, 90, 68, 66,
1418 42, 41, 70, 1, 75, 91, 163, 21, 163, 163,
1419 163, 1, 91, 30, 31, 60, 79, 75, 84, 84,
1420 159, 75, 166, 93, 79, 121, 159, 163, 93, 163,
1421 159, 127, 127, 127, 129, 129, 131, 131, 131, 133,
1422 133, 133, 133, 133, 133, 135, 135, 135, 135, 138,
1423 141, 144, 147, 150, 159, 159, 93, 170, 22, 162,
1424 23, 39, 40, 88, 89, 35, 36, 37, 38, 90,
1425 68, 66, 42, 41, 70, 75, 91, 120, 79, 93,
1426 198, 78, 80, 80, 80, 93, 60, 75, 67, 66,
1427 68, 69, 76, 77, 78, 83, 93, 97, 98, 101,
1428 102, 103, 93, 163, 159, 93, 173, 79, 198, 93,
1429 163, 159, 127, 127, 127, 129, 129, 131, 131, 131,
1430 133, 133, 133, 133, 133, 133, 135, 135, 135, 135,
1431 138, 141, 144, 147, 150, 159, 159, 79, 78, 79,
1432 79, 79, 78, 167, 112, 75, 79, 84, 84, 80,
1433 22, 81, 175, 75, 91, 163, 122, 160, 133, 133,
1434 133, 133, 133, 136, 136, 136, 136, 139, 142, 145,
1435 148, 151, 160, 160, 163, 180, 59, 75, 79, 79,
1436 198, 159, 159, 159, 78, 60, 106, 93, 94, 76,
1437 93, 70, 94, 62, 68, 93, 104, 70, 71, 72,
1438 73, 99, 100, 84, 174, 59, 79, 84, 80, 166,
1439 163, 166, 59, 187, 166, 93, 84, 159, 159, 159,
1440 163, 160, 22, 93, 180, 79, 80, 91, 199, 201,
1441 93, 59, 59, 79, 79, 198, 80, 81, 82, 79,
1442 104, 84, 85, 104, 62, 70, 199, 59, 159, 34,
1443 79, 7, 188, 189, 190, 79, 79, 163, 175, 91,
1444 166, 160, 180, 60, 199, 199, 59, 59, 79, 94,
1445 94, 94, 84, 104, 74, 75, 60, 199, 166, 1,
1446 91, 163, 8, 60, 191, 190, 167, 166, 79, 180,
1447 79, 60, 60, 199, 199, 59, 79, 79, 79, 62,
1448 74, 60, 80, 80, 188, 31, 166, 79, 166, 60,
1449 60, 199, 74, 201, 201, 60, 167, 166, 60
1450 };
1451
1452 #define yyerrok (yyerrstatus = 0)
1453 #define yyclearin (yychar = YYEMPTY)
1454 #define YYEMPTY (-2)
1455 #define YYEOF 0
1456
1457 #define YYACCEPT goto yyacceptlab
1458 #define YYABORT goto yyabortlab
1459 #define YYERROR goto yyerrorlab
1460
1461
1462 /* Like YYERROR except do call yyerror. This remains here temporarily
1463 to ease the transition to the new meaning of YYERROR, for GCC.
1464 Once GCC version 2 has supplanted version 1, this can go. */
1465
1466 #define YYFAIL goto yyerrlab
1467
1468 #define YYRECOVERING() (!!yyerrstatus)
1469
1470 #define YYBACKUP(Token, Value) \
1471 do \
1472 if (yychar == YYEMPTY && yylen == 1) \
1473 { \
1474 yychar = (Token); \
1475 yylval = (Value); \
1476 yytoken = YYTRANSLATE (yychar); \
1477 YYPOPSTACK (1); \
1478 goto yybackup; \
1479 } \
1480 else \
1481 { \
1482 yyerror (YY_("syntax error: cannot back up")); \
1483 YYERROR; \
1484 } \
1485 while (YYID (0))
1486
1487
1488 #define YYTERROR 1
1489 #define YYERRCODE 256
1490
1491
1492 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1493 If N is 0, then set CURRENT to the empty location which ends
1494 the previous symbol: RHS[0] (always defined). */
1495
1496 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1497 #ifndef YYLLOC_DEFAULT
1498 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1499 do \
1500 if (YYID (N)) \
1501 { \
1502 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1503 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1504 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1505 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1506 } \
1507 else \
1508 { \
1509 (Current).first_line = (Current).last_line = \
1510 YYRHSLOC (Rhs, 0).last_line; \
1511 (Current).first_column = (Current).last_column = \
1512 YYRHSLOC (Rhs, 0).last_column; \
1513 } \
1514 while (YYID (0))
1515 #endif
1516
1517
1518 /* YY_LOCATION_PRINT -- Print the location on the stream.
1519 This macro was not mandated originally: define only if we know
1520 we won't break user code: when these are the locations we know. */
1521
1522 #ifndef YY_LOCATION_PRINT
1523 # if YYLTYPE_IS_TRIVIAL
1524 # define YY_LOCATION_PRINT(File, Loc) \
1525 fprintf (File, "%d.%d-%d.%d", \
1526 (Loc).first_line, (Loc).first_column, \
1527 (Loc).last_line, (Loc).last_column)
1528 # else
1529 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1530 # endif
1531 #endif
1532
1533
1534 /* YYLEX -- calling `yylex' with the right arguments. */
1535
1536 #ifdef YYLEX_PARAM
1537 # define YYLEX yylex (&yylval, YYLEX_PARAM)
1538 #else
1539 # define YYLEX yylex (&yylval)
1540 #endif
1541
1542 /* Enable debugging if requested. */
1543 #if YYDEBUG
1544
1545 # ifndef YYFPRINTF
1546 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1547 # define YYFPRINTF fprintf
1548 # endif
1549
1550 # define YYDPRINTF(Args) \
1551 do { \
1552 if (yydebug) \
1553 YYFPRINTF Args; \
1554 } while (YYID (0))
1555
1556 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1557 do { \
1558 if (yydebug) \
1559 { \
1560 YYFPRINTF (stderr, "%s ", Title); \
1561 yy_symbol_print (stderr, \
1562 Type, Value); \
1563 YYFPRINTF (stderr, "\n"); \
1564 } \
1565 } while (YYID (0))
1566
1567
1568 /*--------------------------------.
1569 | Print this symbol on YYOUTPUT. |
1570 `--------------------------------*/
1571
1572 /*ARGSUSED*/
1573 #if (defined __STDC__ || defined __C99__FUNC__ \
1574 || defined __cplusplus || defined _MSC_VER)
1575 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)1576 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1577 #else
1578 static void
1579 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1580 FILE *yyoutput;
1581 int yytype;
1582 YYSTYPE const * const yyvaluep;
1583 #endif
1584 {
1585 if (!yyvaluep)
1586 return;
1587 # ifdef YYPRINT
1588 if (yytype < YYNTOKENS)
1589 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1590 # else
1591 YYUSE (yyoutput);
1592 # endif
1593 switch (yytype)
1594 {
1595 default:
1596 break;
1597 }
1598 }
1599
1600
1601 /*--------------------------------.
1602 | Print this symbol on YYOUTPUT. |
1603 `--------------------------------*/
1604
1605 #if (defined __STDC__ || defined __C99__FUNC__ \
1606 || defined __cplusplus || defined _MSC_VER)
1607 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)1608 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1609 #else
1610 static void
1611 yy_symbol_print (yyoutput, yytype, yyvaluep)
1612 FILE *yyoutput;
1613 int yytype;
1614 YYSTYPE const * const yyvaluep;
1615 #endif
1616 {
1617 if (yytype < YYNTOKENS)
1618 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1619 else
1620 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1621
1622 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1623 YYFPRINTF (yyoutput, ")");
1624 }
1625
1626 /*------------------------------------------------------------------.
1627 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1628 | TOP (included). |
1629 `------------------------------------------------------------------*/
1630
1631 #if (defined __STDC__ || defined __C99__FUNC__ \
1632 || defined __cplusplus || defined _MSC_VER)
1633 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1634 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1635 #else
1636 static void
1637 yy_stack_print (yybottom, yytop)
1638 yytype_int16 *yybottom;
1639 yytype_int16 *yytop;
1640 #endif
1641 {
1642 YYFPRINTF (stderr, "Stack now");
1643 for (; yybottom <= yytop; yybottom++)
1644 {
1645 int yybot = *yybottom;
1646 YYFPRINTF (stderr, " %d", yybot);
1647 }
1648 YYFPRINTF (stderr, "\n");
1649 }
1650
1651 # define YY_STACK_PRINT(Bottom, Top) \
1652 do { \
1653 if (yydebug) \
1654 yy_stack_print ((Bottom), (Top)); \
1655 } while (YYID (0))
1656
1657
1658 /*------------------------------------------------.
1659 | Report that the YYRULE is going to be reduced. |
1660 `------------------------------------------------*/
1661
1662 #if (defined __STDC__ || defined __C99__FUNC__ \
1663 || defined __cplusplus || defined _MSC_VER)
1664 static void
yy_reduce_print(YYSTYPE * yyvsp,int yyrule)1665 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1666 #else
1667 static void
1668 yy_reduce_print (yyvsp, yyrule)
1669 YYSTYPE *yyvsp;
1670 int yyrule;
1671 #endif
1672 {
1673 int yynrhs = yyr2[yyrule];
1674 int yyi;
1675 unsigned long int yylno = yyrline[yyrule];
1676 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1677 yyrule - 1, yylno);
1678 /* The symbols being reduced. */
1679 for (yyi = 0; yyi < yynrhs; yyi++)
1680 {
1681 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1682 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1683 &(yyvsp[(yyi + 1) - (yynrhs)])
1684 );
1685 YYFPRINTF (stderr, "\n");
1686 }
1687 }
1688
1689 # define YY_REDUCE_PRINT(Rule) \
1690 do { \
1691 if (yydebug) \
1692 yy_reduce_print (yyvsp, Rule); \
1693 } while (YYID (0))
1694
1695 /* Nonzero means print parse trace. It is left uninitialized so that
1696 multiple parsers can coexist. */
1697 int yydebug;
1698 #else /* !YYDEBUG */
1699 # define YYDPRINTF(Args)
1700 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1701 # define YY_STACK_PRINT(Bottom, Top)
1702 # define YY_REDUCE_PRINT(Rule)
1703 #endif /* !YYDEBUG */
1704
1705
1706 /* YYINITDEPTH -- initial size of the parser's stacks. */
1707 #ifndef YYINITDEPTH
1708 # define YYINITDEPTH 200
1709 #endif
1710
1711 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1712 if the built-in stack extension method is used).
1713
1714 Do not make this value too large; the results are undefined if
1715 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1716 evaluated with infinite-precision integer arithmetic. */
1717
1718 #ifndef YYMAXDEPTH
1719 # define YYMAXDEPTH 10000
1720 #endif
1721
1722
1723
1724 #if YYERROR_VERBOSE
1725
1726 # ifndef yystrlen
1727 # if defined __GLIBC__ && defined _STRING_H
1728 # define yystrlen strlen
1729 # else
1730 /* Return the length of YYSTR. */
1731 #if (defined __STDC__ || defined __C99__FUNC__ \
1732 || defined __cplusplus || defined _MSC_VER)
1733 static YYSIZE_T
yystrlen(const char * yystr)1734 yystrlen (const char *yystr)
1735 #else
1736 static YYSIZE_T
1737 yystrlen (yystr)
1738 const char *yystr;
1739 #endif
1740 {
1741 YYSIZE_T yylen;
1742 for (yylen = 0; yystr[yylen]; yylen++)
1743 continue;
1744 return yylen;
1745 }
1746 # endif
1747 # endif
1748
1749 # ifndef yystpcpy
1750 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1751 # define yystpcpy stpcpy
1752 # else
1753 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1754 YYDEST. */
1755 #if (defined __STDC__ || defined __C99__FUNC__ \
1756 || defined __cplusplus || defined _MSC_VER)
1757 static char *
yystpcpy(char * yydest,const char * yysrc)1758 yystpcpy (char *yydest, const char *yysrc)
1759 #else
1760 static char *
1761 yystpcpy (yydest, yysrc)
1762 char *yydest;
1763 const char *yysrc;
1764 #endif
1765 {
1766 char *yyd = yydest;
1767 const char *yys = yysrc;
1768
1769 while ((*yyd++ = *yys++) != '\0')
1770 continue;
1771
1772 return yyd - 1;
1773 }
1774 # endif
1775 # endif
1776
1777 # ifndef yytnamerr
1778 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1779 quotes and backslashes, so that it's suitable for yyerror. The
1780 heuristic is that double-quoting is unnecessary unless the string
1781 contains an apostrophe, a comma, or backslash (other than
1782 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1783 null, do not copy; instead, return the length of what the result
1784 would have been. */
1785 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1786 yytnamerr (char *yyres, const char *yystr)
1787 {
1788 if (*yystr == '"')
1789 {
1790 YYSIZE_T yyn = 0;
1791 char const *yyp = yystr;
1792
1793 for (;;)
1794 switch (*++yyp)
1795 {
1796 case '\'':
1797 case ',':
1798 goto do_not_strip_quotes;
1799
1800 case '\\':
1801 if (*++yyp != '\\')
1802 goto do_not_strip_quotes;
1803 /* Fall through. */
1804 default:
1805 if (yyres)
1806 yyres[yyn] = *yyp;
1807 yyn++;
1808 break;
1809
1810 case '"':
1811 if (yyres)
1812 yyres[yyn] = '\0';
1813 return yyn;
1814 }
1815 do_not_strip_quotes: ;
1816 }
1817
1818 if (! yyres)
1819 return yystrlen (yystr);
1820
1821 return yystpcpy (yyres, yystr) - yyres;
1822 }
1823 # endif
1824
1825 /* Copy into YYRESULT an error message about the unexpected token
1826 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1827 including the terminating null byte. If YYRESULT is null, do not
1828 copy anything; just return the number of bytes that would be
1829 copied. As a special case, return 0 if an ordinary "syntax error"
1830 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1831 size calculation. */
1832 static YYSIZE_T
yysyntax_error(char * yyresult,int yystate,int yychar)1833 yysyntax_error (char *yyresult, int yystate, int yychar)
1834 {
1835 int yyn = yypact[yystate];
1836
1837 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1838 return 0;
1839 else
1840 {
1841 int yytype = YYTRANSLATE (yychar);
1842 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1843 YYSIZE_T yysize = yysize0;
1844 YYSIZE_T yysize1;
1845 int yysize_overflow = 0;
1846 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1847 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1848 int yyx;
1849
1850 # if 0
1851 /* This is so xgettext sees the translatable formats that are
1852 constructed on the fly. */
1853 YY_("syntax error, unexpected %s");
1854 YY_("syntax error, unexpected %s, expecting %s");
1855 YY_("syntax error, unexpected %s, expecting %s or %s");
1856 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1857 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1858 # endif
1859 char *yyfmt;
1860 char const *yyf;
1861 static char const yyunexpected[] = "syntax error, unexpected %s";
1862 static char const yyexpecting[] = ", expecting %s";
1863 static char const yyor[] = " or %s";
1864 char yyformat[sizeof yyunexpected
1865 + sizeof yyexpecting - 1
1866 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1867 * (sizeof yyor - 1))];
1868 char const *yyprefix = yyexpecting;
1869
1870 /* Start YYX at -YYN if negative to avoid negative indexes in
1871 YYCHECK. */
1872 int yyxbegin = yyn < 0 ? -yyn : 0;
1873
1874 /* Stay within bounds of both yycheck and yytname. */
1875 int yychecklim = YYLAST - yyn + 1;
1876 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1877 int yycount = 1;
1878
1879 yyarg[0] = yytname[yytype];
1880 yyfmt = yystpcpy (yyformat, yyunexpected);
1881
1882 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1883 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1884 {
1885 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1886 {
1887 yycount = 1;
1888 yysize = yysize0;
1889 yyformat[sizeof yyunexpected - 1] = '\0';
1890 break;
1891 }
1892 yyarg[yycount++] = yytname[yyx];
1893 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1894 yysize_overflow |= (yysize1 < yysize);
1895 yysize = yysize1;
1896 yyfmt = yystpcpy (yyfmt, yyprefix);
1897 yyprefix = yyor;
1898 }
1899
1900 yyf = YY_(yyformat);
1901 yysize1 = yysize + yystrlen (yyf);
1902 yysize_overflow |= (yysize1 < yysize);
1903 yysize = yysize1;
1904
1905 if (yysize_overflow)
1906 return YYSIZE_MAXIMUM;
1907
1908 if (yyresult)
1909 {
1910 /* Avoid sprintf, as that infringes on the user's name space.
1911 Don't have undefined behavior even if the translation
1912 produced a string with the wrong number of "%s"s. */
1913 char *yyp = yyresult;
1914 int yyi = 0;
1915 while ((*yyp = *yyf) != '\0')
1916 {
1917 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1918 {
1919 yyp += yytnamerr (yyp, yyarg[yyi++]);
1920 yyf += 2;
1921 }
1922 else
1923 {
1924 yyp++;
1925 yyf++;
1926 }
1927 }
1928 }
1929 return yysize;
1930 }
1931 }
1932 #endif /* YYERROR_VERBOSE */
1933
1934
1935 /*-----------------------------------------------.
1936 | Release the memory associated to this symbol. |
1937 `-----------------------------------------------*/
1938
1939 /*ARGSUSED*/
1940 #if (defined __STDC__ || defined __C99__FUNC__ \
1941 || defined __cplusplus || defined _MSC_VER)
1942 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1943 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1944 #else
1945 static void
1946 yydestruct (yymsg, yytype, yyvaluep)
1947 const char *yymsg;
1948 int yytype;
1949 YYSTYPE *yyvaluep;
1950 #endif
1951 {
1952 YYUSE (yyvaluep);
1953
1954 if (!yymsg)
1955 yymsg = "Deleting";
1956 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1957
1958 switch (yytype)
1959 {
1960
1961 default:
1962 break;
1963 }
1964 }
1965
1966
1967
1968
1969
1970
1971 struct yypstate
1972 {
1973 /* Number of syntax errors so far. */
1974 int yynerrs;
1975
1976 int yystate;
1977 /* Number of tokens to shift before error messages enabled. */
1978 int yyerrstatus;
1979
1980 /* The stacks and their tools:
1981 `yyss': related to states.
1982 `yyvs': related to semantic values.
1983
1984 Refer to the stacks thru separate pointers, to allow yyoverflow
1985 to reallocate them elsewhere. */
1986
1987 /* The state stack. */
1988 yytype_int16 yyssa[YYINITDEPTH];
1989 yytype_int16 *yyss;
1990 yytype_int16 *yyssp;
1991
1992 /* The semantic value stack. */
1993 YYSTYPE yyvsa[YYINITDEPTH];
1994 YYSTYPE *yyvs;
1995 YYSTYPE *yyvsp;
1996
1997 YYSIZE_T yystacksize;
1998
1999 /* Used to determine if this is the first time this instance has
2000 been used. */
2001 int yynew;
2002 };
2003
2004 #if (defined __STDC__ || defined __C99__FUNC__ \
2005 || defined __cplusplus || defined _MSC_VER)
2006 int
yyparse(void)2007 yyparse (void)
2008 #else
2009 int
2010 yyparse ()
2011
2012 #endif
2013 {
2014 return yypull_parse (0);
2015 }
2016
2017 #if (defined __STDC__ || defined __C99__FUNC__ \
2018 || defined __cplusplus || defined _MSC_VER)
2019 int
yypull_parse(yypstate * yyps)2020 yypull_parse (yypstate *yyps)
2021 #else
2022 int
2023 yypull_parse (yyps)
2024 yypstate *yyps;
2025 #endif
2026 {
2027 int yystatus;
2028 yypstate *yyps_local;
2029 int yychar;
2030 YYSTYPE yylval;
2031 if (yyps == 0)
2032 {
2033 yyps_local = yypstate_new ();
2034 if (!yyps_local)
2035 {
2036 yyerror (YY_("memory exhausted"));
2037 return 2;
2038 }
2039 }
2040 else
2041 yyps_local = yyps;
2042 do {
2043 yychar = YYLEX;
2044 yystatus =
2045 yypush_parse (yyps_local, yychar, &yylval);
2046 } while (yystatus == YYPUSH_MORE);
2047 if (yyps == 0)
2048 yypstate_delete (yyps_local);
2049 return yystatus;
2050 }
2051
2052 /* Initialize the parser data structure. */
2053 #if (defined __STDC__ || defined __C99__FUNC__ \
2054 || defined __cplusplus || defined _MSC_VER)
2055 yypstate *
yypstate_new(void)2056 yypstate_new (void)
2057 #else
2058 yypstate *
2059 yypstate_new ()
2060
2061 #endif
2062 {
2063 yypstate *yyps;
2064 yyps = (yypstate *) malloc (sizeof *yyps);
2065 if (!yyps)
2066 return 0;
2067 yyps->yynew = 1;
2068 return yyps;
2069 }
2070
2071 #if (defined __STDC__ || defined __C99__FUNC__ \
2072 || defined __cplusplus || defined _MSC_VER)
2073 void
yypstate_delete(yypstate * yyps)2074 yypstate_delete (yypstate *yyps)
2075 #else
2076 void
2077 yypstate_delete (yyps)
2078 yypstate *yyps;
2079 #endif
2080 {
2081 #ifndef yyoverflow
2082 /* If the stack was reallocated but the parse did not complete, then the
2083 stack still needs to be freed. */
2084 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
2085 YYSTACK_FREE (yyps->yyss);
2086 #endif
2087 free (yyps);
2088 }
2089
2090 #define yynerrs yyps->yynerrs
2091 #define yystate yyps->yystate
2092 #define yyerrstatus yyps->yyerrstatus
2093 #define yyssa yyps->yyssa
2094 #define yyss yyps->yyss
2095 #define yyssp yyps->yyssp
2096 #define yyvsa yyps->yyvsa
2097 #define yyvs yyps->yyvs
2098 #define yyvsp yyps->yyvsp
2099 #define yystacksize yyps->yystacksize
2100
2101 /*-------------------------.
2102 | yyparse or yypush_parse. |
2103 `-------------------------*/
2104
2105 #if (defined __STDC__ || defined __C99__FUNC__ \
2106 || defined __cplusplus || defined _MSC_VER)
2107 int
yypush_parse(yypstate * yyps,int yypushed_char,YYSTYPE const * yypushed_val)2108 yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val)
2109 #else
2110 int
2111 yypush_parse (yyps, yypushed_char, yypushed_val)
2112 yypstate *yyps;
2113 int yypushed_char;
2114 YYSTYPE const *yypushed_val;
2115 #endif
2116 {
2117 /* The lookahead symbol. */
2118 int yychar;
2119
2120 /* The semantic value of the lookahead symbol. */
2121 YYSTYPE yylval;
2122
2123
2124 int yyn;
2125 int yyresult;
2126 /* Lookahead token as an internal (translated) token number. */
2127 int yytoken;
2128 /* The variables used to return semantic value and location from the
2129 action routines. */
2130 YYSTYPE yyval;
2131
2132 #if YYERROR_VERBOSE
2133 /* Buffer for error messages, and its allocated size. */
2134 char yymsgbuf[128];
2135 char *yymsg = yymsgbuf;
2136 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2137 #endif
2138
2139 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2140
2141 /* The number of symbols on the RHS of the reduced rule.
2142 Keep to zero when no symbol should be popped. */
2143 int yylen = 0;
2144
2145 if (!yyps->yynew)
2146 {
2147 yyn = yypact[yystate];
2148 goto yyread_pushed_token;
2149 }
2150
2151 yytoken = 0;
2152 yyss = yyssa;
2153 yyvs = yyvsa;
2154 yystacksize = YYINITDEPTH;
2155
2156 YYDPRINTF ((stderr, "Starting parse\n"));
2157
2158 yystate = 0;
2159 yyerrstatus = 0;
2160 yynerrs = 0;
2161 yychar = YYEMPTY; /* Cause a token to be read. */
2162
2163 /* Initialize stack pointers.
2164 Waste one element of value and location stack
2165 so that they stay on the same level as the state stack.
2166 The wasted elements are never initialized. */
2167 yyssp = yyss;
2168 yyvsp = yyvs;
2169
2170 goto yysetstate;
2171
2172 /*------------------------------------------------------------.
2173 | yynewstate -- Push a new state, which is found in yystate. |
2174 `------------------------------------------------------------*/
2175 yynewstate:
2176 /* In all cases, when you get here, the value and location stacks
2177 have just been pushed. So pushing a state here evens the stacks. */
2178 yyssp++;
2179
2180 yysetstate:
2181 *yyssp = yystate;
2182
2183 if (yyss + yystacksize - 1 <= yyssp)
2184 {
2185 /* Get the current used size of the three stacks, in elements. */
2186 YYSIZE_T yysize = yyssp - yyss + 1;
2187
2188 #ifdef yyoverflow
2189 {
2190 /* Give user a chance to reallocate the stack. Use copies of
2191 these so that the &'s don't force the real ones into
2192 memory. */
2193 YYSTYPE *yyvs1 = yyvs;
2194 yytype_int16 *yyss1 = yyss;
2195
2196 /* Each stack pointer address is followed by the size of the
2197 data in use in that stack, in bytes. This used to be a
2198 conditional around just the two extra args, but that might
2199 be undefined if yyoverflow is a macro. */
2200 yyoverflow (YY_("memory exhausted"),
2201 &yyss1, yysize * sizeof (*yyssp),
2202 &yyvs1, yysize * sizeof (*yyvsp),
2203 &yystacksize);
2204
2205 yyss = yyss1;
2206 yyvs = yyvs1;
2207 }
2208 #else /* no yyoverflow */
2209 # ifndef YYSTACK_RELOCATE
2210 goto yyexhaustedlab;
2211 # else
2212 /* Extend the stack our own way. */
2213 if (YYMAXDEPTH <= yystacksize)
2214 goto yyexhaustedlab;
2215 yystacksize *= 2;
2216 if (YYMAXDEPTH < yystacksize)
2217 yystacksize = YYMAXDEPTH;
2218
2219 {
2220 yytype_int16 *yyss1 = yyss;
2221 union yyalloc *yyptr =
2222 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2223 if (! yyptr)
2224 goto yyexhaustedlab;
2225 YYSTACK_RELOCATE (yyss_alloc, yyss);
2226 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2227 # undef YYSTACK_RELOCATE
2228 if (yyss1 != yyssa)
2229 YYSTACK_FREE (yyss1);
2230 }
2231 # endif
2232 #endif /* no yyoverflow */
2233
2234 yyssp = yyss + yysize - 1;
2235 yyvsp = yyvs + yysize - 1;
2236
2237 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2238 (unsigned long int) yystacksize));
2239
2240 if (yyss + yystacksize - 1 <= yyssp)
2241 YYABORT;
2242 }
2243
2244 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2245
2246 if (yystate == YYFINAL)
2247 YYACCEPT;
2248
2249 goto yybackup;
2250
2251 /*-----------.
2252 | yybackup. |
2253 `-----------*/
2254 yybackup:
2255
2256 /* Do appropriate processing given the current state. Read a
2257 lookahead token if we need one and don't already have one. */
2258
2259 /* First try to decide what to do without reference to lookahead token. */
2260 yyn = yypact[yystate];
2261 if (yyn == YYPACT_NINF)
2262 goto yydefault;
2263
2264 /* Not known => get a lookahead token if don't already have one. */
2265
2266 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2267 if (yychar == YYEMPTY)
2268 {
2269 if (!yyps->yynew)
2270 {
2271 YYDPRINTF ((stderr, "Return for a new token:\n"));
2272 yyresult = YYPUSH_MORE;
2273 goto yypushreturn;
2274 }
2275 yyps->yynew = 0;
2276 yyread_pushed_token:
2277 YYDPRINTF ((stderr, "Reading a token: "));
2278 yychar = yypushed_char;
2279 if (yypushed_val)
2280 yylval = *yypushed_val;
2281 }
2282
2283 if (yychar <= YYEOF)
2284 {
2285 yychar = yytoken = YYEOF;
2286 YYDPRINTF ((stderr, "Now at end of input.\n"));
2287 }
2288 else
2289 {
2290 yytoken = YYTRANSLATE (yychar);
2291 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2292 }
2293
2294 /* If the proper action on seeing token YYTOKEN is to reduce or to
2295 detect an error, take that action. */
2296 yyn += yytoken;
2297 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2298 goto yydefault;
2299 yyn = yytable[yyn];
2300 if (yyn <= 0)
2301 {
2302 if (yyn == 0 || yyn == YYTABLE_NINF)
2303 goto yyerrlab;
2304 yyn = -yyn;
2305 goto yyreduce;
2306 }
2307
2308 /* Count tokens shifted since error; after three, turn off error
2309 status. */
2310 if (yyerrstatus)
2311 yyerrstatus--;
2312
2313 /* Shift the lookahead token. */
2314 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2315
2316 /* Discard the shifted token. */
2317 yychar = YYEMPTY;
2318
2319 yystate = yyn;
2320 *++yyvsp = yylval;
2321
2322 goto yynewstate;
2323
2324
2325 /*-----------------------------------------------------------.
2326 | yydefault -- do the default action for the current state. |
2327 `-----------------------------------------------------------*/
2328 yydefault:
2329 yyn = yydefact[yystate];
2330 if (yyn == 0)
2331 goto yyerrlab;
2332 goto yyreduce;
2333
2334
2335 /*-----------------------------.
2336 | yyreduce -- Do a reduction. |
2337 `-----------------------------*/
2338 yyreduce:
2339 /* yyn is the number of a rule to reduce with. */
2340 yylen = yyr2[yyn];
2341
2342 /* If YYLEN is nonzero, implement the default value of the action:
2343 `$$ = $1'.
2344
2345 Otherwise, the following line sets YYVAL to garbage.
2346 This behavior is undocumented and Bison
2347 users should not rely upon it. Assigning to YYVAL
2348 unconditionally makes the parser a bit smaller, and it avoids a
2349 GCC warning that YYVAL may be used uninitialized. */
2350 yyval = yyvsp[1-yylen];
2351
2352
2353 YY_REDUCE_PRINT (yyn);
2354 switch (yyn)
2355 {
2356 case 2:
2357
2358 /* Line 1455 of yacc.c */
2359 #line 215 "./js-parser/Grammar.y"
2360 { PRINT_LINE; (yyval.node) = node_new (TOK_NAME, PN_NAME); (yyval.node)->pn_u.name.name = (yyvsp[(1) - (1)].name).iname; (yyval.node)->pn_pos = (yyvsp[(1) - (1)].name).pos; (yyval.node)->pn_u.name.isconst = 0;;}
2361 break;
2362
2363 case 3:
2364
2365 /* Line 1455 of yacc.c */
2366 #line 219 "./js-parser/Grammar.y"
2367 { PRINT_LINE; (yyval.node) = NULL;;}
2368 break;
2369
2370 case 4:
2371
2372 /* Line 1455 of yacc.c */
2373 #line 220 "./js-parser/Grammar.y"
2374 { PRINT_LINE; (yyval.node) = NULL;;}
2375 break;
2376
2377 case 5:
2378
2379 /* Line 1455 of yacc.c */
2380 #line 224 "./js-parser/Grammar.y"
2381 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2382 break;
2383
2384 case 6:
2385
2386 /* Line 1455 of yacc.c */
2387 #line 225 "./js-parser/Grammar.y"
2388 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2389 break;
2390
2391 case 7:
2392
2393 /* Line 1455 of yacc.c */
2394 #line 229 "./js-parser/Grammar.y"
2395 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2396 break;
2397
2398 case 8:
2399
2400 /* Line 1455 of yacc.c */
2401 #line 230 "./js-parser/Grammar.y"
2402 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2403 break;
2404
2405 case 9:
2406
2407 /* Line 1455 of yacc.c */
2408 #line 234 "./js-parser/Grammar.y"
2409 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2410 break;
2411
2412 case 10:
2413
2414 /* Line 1455 of yacc.c */
2415 #line 235 "./js-parser/Grammar.y"
2416 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2417 break;
2418
2419 case 11:
2420
2421 /* Line 1455 of yacc.c */
2422 #line 236 "./js-parser/Grammar.y"
2423 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2424 break;
2425
2426 case 12:
2427
2428 /* Line 1455 of yacc.c */
2429 #line 240 "./js-parser/Grammar.y"
2430 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2431 break;
2432
2433 case 13:
2434
2435 /* Line 1455 of yacc.c */
2436 #line 241 "./js-parser/Grammar.y"
2437 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2438 break;
2439
2440 case 16:
2441
2442 /* Line 1455 of yacc.c */
2443 #line 251 "./js-parser/Grammar.y"
2444 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2445 break;
2446
2447 case 17:
2448
2449 /* Line 1455 of yacc.c */
2450 #line 252 "./js-parser/Grammar.y"
2451 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2452 break;
2453
2454 case 18:
2455
2456 /* Line 1455 of yacc.c */
2457 #line 253 "./js-parser/Grammar.y"
2458 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2459 break;
2460
2461 case 19:
2462
2463 /* Line 1455 of yacc.c */
2464 #line 254 "./js-parser/Grammar.y"
2465 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2466 break;
2467
2468 case 20:
2469
2470 /* Line 1455 of yacc.c */
2471 #line 255 "./js-parser/Grammar.y"
2472 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2473 break;
2474
2475 case 21:
2476
2477 /* Line 1455 of yacc.c */
2478 #line 256 "./js-parser/Grammar.y"
2479 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2480 break;
2481
2482 case 22:
2483
2484 /* Line 1455 of yacc.c */
2485 #line 260 "./js-parser/Grammar.y"
2486 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2487 break;
2488
2489 case 23:
2490
2491 /* Line 1455 of yacc.c */
2492 #line 261 "./js-parser/Grammar.y"
2493 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2494 break;
2495
2496 case 24:
2497
2498 /* Line 1455 of yacc.c */
2499 #line 262 "./js-parser/Grammar.y"
2500 { PRINT_LINE_TODO; (yyval.node) = NULL;/* TODO: FIX AtomEscape = IDENT*/ ;}
2501 break;
2502
2503 case 25:
2504
2505 /* Line 1455 of yacc.c */
2506 #line 263 "./js-parser/Grammar.y"
2507 { PRINT_LINE_TODO; (yyval.node) = NULL;/* TODO: FIX AtomEscape = IDENT*/ ;}
2508 break;
2509
2510 case 26:
2511
2512 /* Line 1455 of yacc.c */
2513 #line 264 "./js-parser/Grammar.y"
2514 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2515 break;
2516
2517 case 27:
2518
2519 /* Line 1455 of yacc.c */
2520 #line 265 "./js-parser/Grammar.y"
2521 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2522 break;
2523
2524 case 28:
2525
2526 /* Line 1455 of yacc.c */
2527 #line 266 "./js-parser/Grammar.y"
2528 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2529 break;
2530
2531 case 29:
2532
2533 /* Line 1455 of yacc.c */
2534 #line 267 "./js-parser/Grammar.y"
2535 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2536 break;
2537
2538 case 30:
2539
2540 /* Line 1455 of yacc.c */
2541 #line 268 "./js-parser/Grammar.y"
2542 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2543 break;
2544
2545 case 31:
2546
2547 /* Line 1455 of yacc.c */
2548 #line 272 "./js-parser/Grammar.y"
2549 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2550 break;
2551
2552 case 32:
2553
2554 /* Line 1455 of yacc.c */
2555 #line 276 "./js-parser/Grammar.y"
2556 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2557 break;
2558
2559 case 33:
2560
2561 /* Line 1455 of yacc.c */
2562 #line 277 "./js-parser/Grammar.y"
2563 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2564 break;
2565
2566 case 34:
2567
2568 /* Line 1455 of yacc.c */
2569 #line 281 "./js-parser/Grammar.y"
2570 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2571 break;
2572
2573 case 35:
2574
2575 /* Line 1455 of yacc.c */
2576 #line 282 "./js-parser/Grammar.y"
2577 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2578 break;
2579
2580 case 36:
2581
2582 /* Line 1455 of yacc.c */
2583 #line 283 "./js-parser/Grammar.y"
2584 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2585 break;
2586
2587 case 37:
2588
2589 /* Line 1455 of yacc.c */
2590 #line 284 "./js-parser/Grammar.y"
2591 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2592 break;
2593
2594 case 38:
2595
2596 /* Line 1455 of yacc.c */
2597 #line 288 "./js-parser/Grammar.y"
2598 { PRINT_LINE; (yyval.node) = node_new (TOK_PRIMARY, PN_NULLARY); (yyval.node)->pn_op = JSOP_NULL;;}
2599 break;
2600
2601 case 39:
2602
2603 /* Line 1455 of yacc.c */
2604 #line 289 "./js-parser/Grammar.y"
2605 { PRINT_LINE; (yyval.node) = node_new (TOK_PRIMARY, PN_NULLARY); (yyval.node)->pn_op = JSOP_TRUE;;}
2606 break;
2607
2608 case 40:
2609
2610 /* Line 1455 of yacc.c */
2611 #line 290 "./js-parser/Grammar.y"
2612 { PRINT_LINE; (yyval.node) = node_new (TOK_PRIMARY, PN_NULLARY); (yyval.node)->pn_op = JSOP_FALSE;;}
2613 break;
2614
2615 case 41:
2616
2617 /* Line 1455 of yacc.c */
2618 #line 291 "./js-parser/Grammar.y"
2619 { PRINT_LINE; (yyval.node) = node_new (TOK_NUMBER, PN_NULLARY);;}
2620 break;
2621
2622 case 42:
2623
2624 /* Line 1455 of yacc.c */
2625 #line 292 "./js-parser/Grammar.y"
2626 { PRINT_LINE; (yyval.node) = node_new (TOK_STRING, PN_NULLARY);;}
2627 break;
2628
2629 case 43:
2630
2631 /* Line 1455 of yacc.c */
2632 #line 296 "./js-parser/Grammar.y"
2633 { PRINT_LINE;
2634 (yyval.node) = node_new (TOK_COLON, PN_BINARY);
2635 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
2636 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
2637 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
2638 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2639 ;}
2640 break;
2641
2642 case 44:
2643
2644 /* Line 1455 of yacc.c */
2645 #line 303 "./js-parser/Grammar.y"
2646 { PRINT_LINE;
2647 (yyval.node) = node_new (TOK_COLON, PN_BINARY);
2648 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
2649 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
2650 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2651 ;}
2652 break;
2653
2654 case 45:
2655
2656 /* Line 1455 of yacc.c */
2657 #line 309 "./js-parser/Grammar.y"
2658 { PRINT_LINE;
2659 (yyval.node) = node_new (TOK_COLON, PN_BINARY);
2660 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
2661 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
2662 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2663 ;}
2664 break;
2665
2666 case 46:
2667
2668 /* Line 1455 of yacc.c */
2669 #line 315 "./js-parser/Grammar.y"
2670 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2671 break;
2672
2673 case 47:
2674
2675 /* Line 1455 of yacc.c */
2676 #line 317 "./js-parser/Grammar.y"
2677 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2678 break;
2679
2680 case 48:
2681
2682 /* Line 1455 of yacc.c */
2683 #line 321 "./js-parser/Grammar.y"
2684 { PRINT_LINE;
2685 (yyval.node) = node_new (TOK_RC, PN_LIST);
2686 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
2687 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
2688 ;}
2689 break;
2690
2691 case 49:
2692
2693 /* Line 1455 of yacc.c */
2694 #line 326 "./js-parser/Grammar.y"
2695 { PRINT_LINE;
2696 (yyval.node) = (yyvsp[(1) - (3)].node);
2697 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2698 g_assert ((yyvsp[(1) - (3)].node)->pn_arity == PN_LIST);
2699 if ((yyvsp[(1) - (3)].node)->pn_u.list.head) {
2700 JSNode *i;
2701 for (i = (yyvsp[(1) - (3)].node)->pn_u.list.head; i->pn_next != NULL; i = i->pn_next)
2702 ;
2703 i->pn_next = (yyvsp[(3) - (3)].node);
2704 } else (yyvsp[(1) - (3)].node)->pn_u.list.head = (yyvsp[(3) - (3)].node);
2705 ;}
2706 break;
2707
2708 case 51:
2709
2710 /* Line 1455 of yacc.c */
2711 #line 341 "./js-parser/Grammar.y"
2712 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2713 break;
2714
2715 case 52:
2716
2717 /* Line 1455 of yacc.c */
2718 #line 342 "./js-parser/Grammar.y"
2719 { PRINT_LINE;
2720 (yyval.node) = (yyvsp[(2) - (3)].node);
2721 node_correct_position_end ((yyval.node), (yyvsp[(3) - (3)].intValue));
2722 ;}
2723 break;
2724
2725 case 53:
2726
2727 /* Line 1455 of yacc.c */
2728 #line 347 "./js-parser/Grammar.y"
2729 { PRINT_LINE;
2730 (yyval.node) = (yyvsp[(2) - (4)].node);
2731 node_correct_position_end ((yyval.node), (yyvsp[(4) - (4)].intValue));
2732 ;}
2733 break;
2734
2735 case 54:
2736
2737 /* Line 1455 of yacc.c */
2738 #line 354 "./js-parser/Grammar.y"
2739 { PRINT_LINE; (yyval.node) = node_new (TOK_PRIMARY, PN_NULLARY); (yyval.node)->pn_op = JSOP_THIS;;}
2740 break;
2741
2742 case 57:
2743
2744 /* Line 1455 of yacc.c */
2745 #line 357 "./js-parser/Grammar.y"
2746 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (1)].node);;}
2747 break;
2748
2749 case 58:
2750
2751 /* Line 1455 of yacc.c */
2752 #line 358 "./js-parser/Grammar.y"
2753 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node);;}
2754 break;
2755
2756 case 59:
2757
2758 /* Line 1455 of yacc.c */
2759 #line 362 "./js-parser/Grammar.y"
2760 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2761 break;
2762
2763 case 60:
2764
2765 /* Line 1455 of yacc.c */
2766 #line 363 "./js-parser/Grammar.y"
2767 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2768 break;
2769
2770 case 61:
2771
2772 /* Line 1455 of yacc.c */
2773 #line 364 "./js-parser/Grammar.y"
2774 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2775 break;
2776
2777 case 62:
2778
2779 /* Line 1455 of yacc.c */
2780 #line 368 "./js-parser/Grammar.y"
2781 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2782 break;
2783
2784 case 63:
2785
2786 /* Line 1455 of yacc.c */
2787 #line 370 "./js-parser/Grammar.y"
2788 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2789 break;
2790
2791 case 64:
2792
2793 /* Line 1455 of yacc.c */
2794 #line 374 "./js-parser/Grammar.y"
2795 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2796 break;
2797
2798 case 66:
2799
2800 /* Line 1455 of yacc.c */
2801 #line 379 "./js-parser/Grammar.y"
2802 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2803 break;
2804
2805 case 67:
2806
2807 /* Line 1455 of yacc.c */
2808 #line 380 "./js-parser/Grammar.y"
2809 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2810 break;
2811
2812 case 70:
2813
2814 /* Line 1455 of yacc.c */
2815 #line 386 "./js-parser/Grammar.y"
2816 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (1)].node);;}
2817 break;
2818
2819 case 71:
2820
2821 /* Line 1455 of yacc.c */
2822 #line 387 "./js-parser/Grammar.y"
2823 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2824 break;
2825
2826 case 72:
2827
2828 /* Line 1455 of yacc.c */
2829 #line 388 "./js-parser/Grammar.y"
2830 { PRINT_LINE;
2831 (yyval.node) = node_new ( TOK_DOT, PN_NAME);
2832 (yyval.node)->pn_u.name.expr = (yyvsp[(1) - (3)].node);
2833 (yyval.node)->pn_u.name.name = (yyvsp[(3) - (3)].node);
2834 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
2835 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2836 ;}
2837 break;
2838
2839 case 73:
2840
2841 /* Line 1455 of yacc.c */
2842 #line 395 "./js-parser/Grammar.y"
2843 { PRINT_LINE;
2844 (yyval.node) = node_new ( TOK_NEW, PN_LIST);
2845 (yyval.node)->pn_u.list.head = (yyvsp[(2) - (3)].node);
2846 (yyvsp[(2) - (3)].node)->pn_next = (yyvsp[(3) - (3)].node);
2847 node_correct_position ((yyval.node), (yyvsp[(2) - (3)].node));
2848 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2849 ;}
2850 break;
2851
2852 case 75:
2853
2854 /* Line 1455 of yacc.c */
2855 #line 406 "./js-parser/Grammar.y"
2856 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2857 break;
2858
2859 case 76:
2860
2861 /* Line 1455 of yacc.c */
2862 #line 407 "./js-parser/Grammar.y"
2863 { PRINT_LINE;
2864 (yyval.node) = node_new ( TOK_DOT, PN_NAME);
2865 (yyval.node)->pn_u.name.expr = (yyvsp[(1) - (3)].node);
2866 (yyval.node)->pn_u.name.name = (yyvsp[(3) - (3)].node);
2867 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
2868 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2869 ;}
2870 break;
2871
2872 case 77:
2873
2874 /* Line 1455 of yacc.c */
2875 #line 414 "./js-parser/Grammar.y"
2876 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2877 break;
2878
2879 case 79:
2880
2881 /* Line 1455 of yacc.c */
2882 #line 419 "./js-parser/Grammar.y"
2883 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2884 break;
2885
2886 case 81:
2887
2888 /* Line 1455 of yacc.c */
2889 #line 424 "./js-parser/Grammar.y"
2890 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2891 break;
2892
2893 case 82:
2894
2895 /* Line 1455 of yacc.c */
2896 #line 428 "./js-parser/Grammar.y"
2897 { PRINT_LINE;
2898 (yyval.node) = node_new ( TOK_LP, PN_LIST);
2899 (yyvsp[(1) - (2)].node)->pn_next = (yyvsp[(2) - (2)].node);
2900 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
2901 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
2902 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
2903 ;}
2904 break;
2905
2906 case 83:
2907
2908 /* Line 1455 of yacc.c */
2909 #line 435 "./js-parser/Grammar.y"
2910 { PRINT_LINE;
2911 (yyval.node) = node_new ( TOK_LP, PN_LIST);
2912 (yyvsp[(1) - (2)].node)->pn_next = (yyvsp[(2) - (2)].node);
2913 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
2914 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
2915 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
2916 ;}
2917 break;
2918
2919 case 84:
2920
2921 /* Line 1455 of yacc.c */
2922 #line 442 "./js-parser/Grammar.y"
2923 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2924 break;
2925
2926 case 85:
2927
2928 /* Line 1455 of yacc.c */
2929 #line 443 "./js-parser/Grammar.y"
2930 { PRINT_LINE;
2931 (yyval.node) = node_new ( TOK_DOT, PN_NAME);
2932 (yyval.node)->pn_u.name.expr = (yyvsp[(1) - (3)].node);
2933 (yyval.node)->pn_u.name.name = (yyvsp[(3) - (3)].node);
2934 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
2935 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2936 ;}
2937 break;
2938
2939 case 86:
2940
2941 /* Line 1455 of yacc.c */
2942 #line 453 "./js-parser/Grammar.y"
2943 { PRINT_LINE;
2944 (yyval.node) = node_new ( TOK_LP, PN_LIST);
2945 (yyvsp[(1) - (2)].node)->pn_next = (yyvsp[(2) - (2)].node);
2946 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
2947 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
2948 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
2949 ;}
2950 break;
2951
2952 case 87:
2953
2954 /* Line 1455 of yacc.c */
2955 #line 460 "./js-parser/Grammar.y"
2956 { PRINT_LINE;
2957 (yyval.node) = node_new ( TOK_LP, PN_LIST);
2958 (yyvsp[(1) - (2)].node)->pn_next = (yyvsp[(2) - (2)].node);
2959 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
2960 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
2961 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
2962 ;}
2963 break;
2964
2965 case 88:
2966
2967 /* Line 1455 of yacc.c */
2968 #line 467 "./js-parser/Grammar.y"
2969 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
2970 break;
2971
2972 case 89:
2973
2974 /* Line 1455 of yacc.c */
2975 #line 468 "./js-parser/Grammar.y"
2976 { PRINT_LINE;
2977 (yyval.node) = node_new ( TOK_DOT, PN_NAME);
2978 (yyval.node)->pn_u.name.expr = (yyvsp[(1) - (3)].node);
2979 (yyval.node)->pn_u.name.name = (yyvsp[(3) - (3)].node);
2980 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
2981 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
2982 ;}
2983 break;
2984
2985 case 90:
2986
2987 /* Line 1455 of yacc.c */
2988 #line 478 "./js-parser/Grammar.y"
2989 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
2990 break;
2991
2992 case 91:
2993
2994 /* Line 1455 of yacc.c */
2995 #line 479 "./js-parser/Grammar.y"
2996 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node);;}
2997 break;
2998
2999 case 92:
3000
3001 /* Line 1455 of yacc.c */
3002 #line 483 "./js-parser/Grammar.y"
3003 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (1)].node);;}
3004 break;
3005
3006 case 93:
3007
3008 /* Line 1455 of yacc.c */
3009 #line 484 "./js-parser/Grammar.y"
3010 { PRINT_LINE;
3011 (yyval.node) = (yyvsp[(1) - (3)].node);
3012 if ((yyvsp[(1) - (3)].node)) (yyvsp[(1) - (3)].node)->pn_next = (yyvsp[(3) - (3)].node);
3013 else (yyval.node) = (yyvsp[(3) - (3)].node);
3014 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3015 ;}
3016 break;
3017
3018 case 99:
3019
3020 /* Line 1455 of yacc.c */
3021 #line 504 "./js-parser/Grammar.y"
3022 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (2)].node);;}
3023 break;
3024
3025 case 100:
3026
3027 /* Line 1455 of yacc.c */
3028 #line 505 "./js-parser/Grammar.y"
3029 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (2)].node);;}
3030 break;
3031
3032 case 102:
3033
3034 /* Line 1455 of yacc.c */
3035 #line 510 "./js-parser/Grammar.y"
3036 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3037 break;
3038
3039 case 103:
3040
3041 /* Line 1455 of yacc.c */
3042 #line 511 "./js-parser/Grammar.y"
3043 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3044 break;
3045
3046 case 104:
3047
3048 /* Line 1455 of yacc.c */
3049 #line 515 "./js-parser/Grammar.y"
3050 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3051 break;
3052
3053 case 105:
3054
3055 /* Line 1455 of yacc.c */
3056 #line 516 "./js-parser/Grammar.y"
3057 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3058 break;
3059
3060 case 106:
3061
3062 /* Line 1455 of yacc.c */
3063 #line 517 "./js-parser/Grammar.y"
3064 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3065 break;
3066
3067 case 107:
3068
3069 /* Line 1455 of yacc.c */
3070 #line 518 "./js-parser/Grammar.y"
3071 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3072 break;
3073
3074 case 108:
3075
3076 /* Line 1455 of yacc.c */
3077 #line 519 "./js-parser/Grammar.y"
3078 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3079 break;
3080
3081 case 109:
3082
3083 /* Line 1455 of yacc.c */
3084 #line 520 "./js-parser/Grammar.y"
3085 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3086 break;
3087
3088 case 110:
3089
3090 /* Line 1455 of yacc.c */
3091 #line 521 "./js-parser/Grammar.y"
3092 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3093 break;
3094
3095 case 111:
3096
3097 /* Line 1455 of yacc.c */
3098 #line 522 "./js-parser/Grammar.y"
3099 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3100 break;
3101
3102 case 112:
3103
3104 /* Line 1455 of yacc.c */
3105 #line 523 "./js-parser/Grammar.y"
3106 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3107 break;
3108
3109 case 113:
3110
3111 /* Line 1455 of yacc.c */
3112 #line 524 "./js-parser/Grammar.y"
3113 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3114 break;
3115
3116 case 114:
3117
3118 /* Line 1455 of yacc.c */
3119 #line 525 "./js-parser/Grammar.y"
3120 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3121 break;
3122
3123 case 120:
3124
3125 /* Line 1455 of yacc.c */
3126 #line 539 "./js-parser/Grammar.y"
3127 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3128 break;
3129
3130 case 121:
3131
3132 /* Line 1455 of yacc.c */
3133 #line 540 "./js-parser/Grammar.y"
3134 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3135 break;
3136
3137 case 122:
3138
3139 /* Line 1455 of yacc.c */
3140 #line 541 "./js-parser/Grammar.y"
3141 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3142 break;
3143
3144 case 124:
3145
3146 /* Line 1455 of yacc.c */
3147 #line 547 "./js-parser/Grammar.y"
3148 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3149 break;
3150
3151 case 125:
3152
3153 /* Line 1455 of yacc.c */
3154 #line 549 "./js-parser/Grammar.y"
3155 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3156 break;
3157
3158 case 126:
3159
3160 /* Line 1455 of yacc.c */
3161 #line 551 "./js-parser/Grammar.y"
3162 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3163 break;
3164
3165 case 128:
3166
3167 /* Line 1455 of yacc.c */
3168 #line 556 "./js-parser/Grammar.y"
3169 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3170 break;
3171
3172 case 129:
3173
3174 /* Line 1455 of yacc.c */
3175 #line 557 "./js-parser/Grammar.y"
3176 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3177 break;
3178
3179 case 131:
3180
3181 /* Line 1455 of yacc.c */
3182 #line 563 "./js-parser/Grammar.y"
3183 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3184 break;
3185
3186 case 132:
3187
3188 /* Line 1455 of yacc.c */
3189 #line 565 "./js-parser/Grammar.y"
3190 { PRINT_LINE; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3191 break;
3192
3193 case 134:
3194
3195 /* Line 1455 of yacc.c */
3196 #line 570 "./js-parser/Grammar.y"
3197 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3198 break;
3199
3200 case 135:
3201
3202 /* Line 1455 of yacc.c */
3203 #line 571 "./js-parser/Grammar.y"
3204 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3205 break;
3206
3207 case 136:
3208
3209 /* Line 1455 of yacc.c */
3210 #line 572 "./js-parser/Grammar.y"
3211 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3212 break;
3213
3214 case 138:
3215
3216 /* Line 1455 of yacc.c */
3217 #line 577 "./js-parser/Grammar.y"
3218 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3219 break;
3220
3221 case 139:
3222
3223 /* Line 1455 of yacc.c */
3224 #line 578 "./js-parser/Grammar.y"
3225 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3226 break;
3227
3228 case 140:
3229
3230 /* Line 1455 of yacc.c */
3231 #line 579 "./js-parser/Grammar.y"
3232 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3233 break;
3234
3235 case 142:
3236
3237 /* Line 1455 of yacc.c */
3238 #line 584 "./js-parser/Grammar.y"
3239 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3240 break;
3241
3242 case 143:
3243
3244 /* Line 1455 of yacc.c */
3245 #line 585 "./js-parser/Grammar.y"
3246 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3247 break;
3248
3249 case 144:
3250
3251 /* Line 1455 of yacc.c */
3252 #line 586 "./js-parser/Grammar.y"
3253 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3254 break;
3255
3256 case 145:
3257
3258 /* Line 1455 of yacc.c */
3259 #line 587 "./js-parser/Grammar.y"
3260 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3261 break;
3262
3263 case 146:
3264
3265 /* Line 1455 of yacc.c */
3266 #line 588 "./js-parser/Grammar.y"
3267 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3268 break;
3269
3270 case 147:
3271
3272 /* Line 1455 of yacc.c */
3273 #line 589 "./js-parser/Grammar.y"
3274 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3275 break;
3276
3277 case 149:
3278
3279 /* Line 1455 of yacc.c */
3280 #line 594 "./js-parser/Grammar.y"
3281 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3282 break;
3283
3284 case 150:
3285
3286 /* Line 1455 of yacc.c */
3287 #line 595 "./js-parser/Grammar.y"
3288 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3289 break;
3290
3291 case 151:
3292
3293 /* Line 1455 of yacc.c */
3294 #line 596 "./js-parser/Grammar.y"
3295 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3296 break;
3297
3298 case 152:
3299
3300 /* Line 1455 of yacc.c */
3301 #line 597 "./js-parser/Grammar.y"
3302 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3303 break;
3304
3305 case 153:
3306
3307 /* Line 1455 of yacc.c */
3308 #line 599 "./js-parser/Grammar.y"
3309 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3310 break;
3311
3312 case 155:
3313
3314 /* Line 1455 of yacc.c */
3315 #line 604 "./js-parser/Grammar.y"
3316 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3317 break;
3318
3319 case 156:
3320
3321 /* Line 1455 of yacc.c */
3322 #line 605 "./js-parser/Grammar.y"
3323 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3324 break;
3325
3326 case 157:
3327
3328 /* Line 1455 of yacc.c */
3329 #line 606 "./js-parser/Grammar.y"
3330 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3331 break;
3332
3333 case 158:
3334
3335 /* Line 1455 of yacc.c */
3336 #line 607 "./js-parser/Grammar.y"
3337 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3338 break;
3339
3340 case 159:
3341
3342 /* Line 1455 of yacc.c */
3343 #line 609 "./js-parser/Grammar.y"
3344 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3345 break;
3346
3347 case 160:
3348
3349 /* Line 1455 of yacc.c */
3350 #line 611 "./js-parser/Grammar.y"
3351 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3352 break;
3353
3354 case 162:
3355
3356 /* Line 1455 of yacc.c */
3357 #line 616 "./js-parser/Grammar.y"
3358 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3359 break;
3360
3361 case 163:
3362
3363 /* Line 1455 of yacc.c */
3364 #line 617 "./js-parser/Grammar.y"
3365 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3366 break;
3367
3368 case 164:
3369
3370 /* Line 1455 of yacc.c */
3371 #line 618 "./js-parser/Grammar.y"
3372 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3373 break;
3374
3375 case 165:
3376
3377 /* Line 1455 of yacc.c */
3378 #line 619 "./js-parser/Grammar.y"
3379 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3380 break;
3381
3382 case 167:
3383
3384 /* Line 1455 of yacc.c */
3385 #line 625 "./js-parser/Grammar.y"
3386 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3387 break;
3388
3389 case 168:
3390
3391 /* Line 1455 of yacc.c */
3392 #line 627 "./js-parser/Grammar.y"
3393 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3394 break;
3395
3396 case 169:
3397
3398 /* Line 1455 of yacc.c */
3399 #line 629 "./js-parser/Grammar.y"
3400 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3401 break;
3402
3403 case 170:
3404
3405 /* Line 1455 of yacc.c */
3406 #line 631 "./js-parser/Grammar.y"
3407 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3408 break;
3409
3410 case 172:
3411
3412 /* Line 1455 of yacc.c */
3413 #line 637 "./js-parser/Grammar.y"
3414 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3415 break;
3416
3417 case 173:
3418
3419 /* Line 1455 of yacc.c */
3420 #line 638 "./js-parser/Grammar.y"
3421 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3422 break;
3423
3424 case 174:
3425
3426 /* Line 1455 of yacc.c */
3427 #line 640 "./js-parser/Grammar.y"
3428 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3429 break;
3430
3431 case 175:
3432
3433 /* Line 1455 of yacc.c */
3434 #line 642 "./js-parser/Grammar.y"
3435 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3436 break;
3437
3438 case 177:
3439
3440 /* Line 1455 of yacc.c */
3441 #line 647 "./js-parser/Grammar.y"
3442 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3443 break;
3444
3445 case 179:
3446
3447 /* Line 1455 of yacc.c */
3448 #line 653 "./js-parser/Grammar.y"
3449 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3450 break;
3451
3452 case 181:
3453
3454 /* Line 1455 of yacc.c */
3455 #line 658 "./js-parser/Grammar.y"
3456 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3457 break;
3458
3459 case 183:
3460
3461 /* Line 1455 of yacc.c */
3462 #line 663 "./js-parser/Grammar.y"
3463 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3464 break;
3465
3466 case 185:
3467
3468 /* Line 1455 of yacc.c */
3469 #line 669 "./js-parser/Grammar.y"
3470 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3471 break;
3472
3473 case 187:
3474
3475 /* Line 1455 of yacc.c */
3476 #line 675 "./js-parser/Grammar.y"
3477 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3478 break;
3479
3480 case 189:
3481
3482 /* Line 1455 of yacc.c */
3483 #line 680 "./js-parser/Grammar.y"
3484 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3485 break;
3486
3487 case 191:
3488
3489 /* Line 1455 of yacc.c */
3490 #line 686 "./js-parser/Grammar.y"
3491 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3492 break;
3493
3494 case 193:
3495
3496 /* Line 1455 of yacc.c */
3497 #line 692 "./js-parser/Grammar.y"
3498 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3499 break;
3500
3501 case 195:
3502
3503 /* Line 1455 of yacc.c */
3504 #line 697 "./js-parser/Grammar.y"
3505 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3506 break;
3507
3508 case 197:
3509
3510 /* Line 1455 of yacc.c */
3511 #line 703 "./js-parser/Grammar.y"
3512 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3513 break;
3514
3515 case 199:
3516
3517 /* Line 1455 of yacc.c */
3518 #line 709 "./js-parser/Grammar.y"
3519 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3520 break;
3521
3522 case 201:
3523
3524 /* Line 1455 of yacc.c */
3525 #line 714 "./js-parser/Grammar.y"
3526 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3527 break;
3528
3529 case 203:
3530
3531 /* Line 1455 of yacc.c */
3532 #line 720 "./js-parser/Grammar.y"
3533 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3534 break;
3535
3536 case 205:
3537
3538 /* Line 1455 of yacc.c */
3539 #line 725 "./js-parser/Grammar.y"
3540 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3541 break;
3542
3543 case 207:
3544
3545 /* Line 1455 of yacc.c */
3546 #line 731 "./js-parser/Grammar.y"
3547 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3548 break;
3549
3550 case 209:
3551
3552 /* Line 1455 of yacc.c */
3553 #line 737 "./js-parser/Grammar.y"
3554 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3555 break;
3556
3557 case 211:
3558
3559 /* Line 1455 of yacc.c */
3560 #line 743 "./js-parser/Grammar.y"
3561 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3562 break;
3563
3564 case 213:
3565
3566 /* Line 1455 of yacc.c */
3567 #line 749 "./js-parser/Grammar.y"
3568 { PRINT_LINE;
3569 (yyval.node) = node_new (TOK_ASSIGN, PN_BINARY);
3570 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
3571 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
3572 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
3573 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3574 ;}
3575 break;
3576
3577 case 215:
3578
3579 /* Line 1455 of yacc.c */
3580 #line 761 "./js-parser/Grammar.y"
3581 { PRINT_LINE;
3582 (yyval.node) = node_new (TOK_ASSIGN, PN_BINARY);
3583 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
3584 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
3585 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
3586 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3587 ;}
3588 break;
3589
3590 case 217:
3591
3592 /* Line 1455 of yacc.c */
3593 #line 773 "./js-parser/Grammar.y"
3594 { PRINT_LINE;
3595 (yyval.node) = node_new (TOK_ASSIGN, PN_BINARY);
3596 (yyval.node)->pn_u.binary.left = (yyvsp[(1) - (3)].node);
3597 (yyval.node)->pn_u.binary.right = (yyvsp[(3) - (3)].node);
3598 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
3599 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3600 ;}
3601 break;
3602
3603 case 218:
3604
3605 /* Line 1455 of yacc.c */
3606 #line 783 "./js-parser/Grammar.y"
3607 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3608 break;
3609
3610 case 219:
3611
3612 /* Line 1455 of yacc.c */
3613 #line 784 "./js-parser/Grammar.y"
3614 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3615 break;
3616
3617 case 220:
3618
3619 /* Line 1455 of yacc.c */
3620 #line 785 "./js-parser/Grammar.y"
3621 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3622 break;
3623
3624 case 221:
3625
3626 /* Line 1455 of yacc.c */
3627 #line 786 "./js-parser/Grammar.y"
3628 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3629 break;
3630
3631 case 222:
3632
3633 /* Line 1455 of yacc.c */
3634 #line 787 "./js-parser/Grammar.y"
3635 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3636 break;
3637
3638 case 223:
3639
3640 /* Line 1455 of yacc.c */
3641 #line 788 "./js-parser/Grammar.y"
3642 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3643 break;
3644
3645 case 224:
3646
3647 /* Line 1455 of yacc.c */
3648 #line 789 "./js-parser/Grammar.y"
3649 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3650 break;
3651
3652 case 225:
3653
3654 /* Line 1455 of yacc.c */
3655 #line 790 "./js-parser/Grammar.y"
3656 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3657 break;
3658
3659 case 226:
3660
3661 /* Line 1455 of yacc.c */
3662 #line 791 "./js-parser/Grammar.y"
3663 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3664 break;
3665
3666 case 227:
3667
3668 /* Line 1455 of yacc.c */
3669 #line 792 "./js-parser/Grammar.y"
3670 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3671 break;
3672
3673 case 228:
3674
3675 /* Line 1455 of yacc.c */
3676 #line 793 "./js-parser/Grammar.y"
3677 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3678 break;
3679
3680 case 229:
3681
3682 /* Line 1455 of yacc.c */
3683 #line 794 "./js-parser/Grammar.y"
3684 { PRINT_LINE_NOTNEED; (yyval.node) = NULL;;}
3685 break;
3686
3687 case 231:
3688
3689 /* Line 1455 of yacc.c */
3690 #line 799 "./js-parser/Grammar.y"
3691 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3692 break;
3693
3694 case 233:
3695
3696 /* Line 1455 of yacc.c */
3697 #line 804 "./js-parser/Grammar.y"
3698 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3699 break;
3700
3701 case 235:
3702
3703 /* Line 1455 of yacc.c */
3704 #line 809 "./js-parser/Grammar.y"
3705 { PRINT_LINE_TODO; (yyval.node) = (yyvsp[(3) - (3)].node);;}
3706 break;
3707
3708 case 253:
3709
3710 /* Line 1455 of yacc.c */
3711 #line 833 "./js-parser/Grammar.y"
3712 { PRINT_LINE;
3713 (yyval.node) = node_new (TOK_LC, PN_LIST);
3714 (yyval.node)->pn_u.list.head = NULL;
3715 node_correct_position_end ((yyval.node), (yyvsp[(2) - (2)].intValue));
3716 ;}
3717 break;
3718
3719 case 254:
3720
3721 /* Line 1455 of yacc.c */
3722 #line 838 "./js-parser/Grammar.y"
3723 { PRINT_LINE;
3724 (yyval.node) = node_new (TOK_LC, PN_LIST);
3725 (yyval.node)->pn_u.list.head = (yyvsp[(2) - (3)].node);
3726 node_correct_position ((yyval.node), (yyvsp[(2) - (3)].node));
3727 node_correct_position_end ((yyval.node), (yyvsp[(3) - (3)].intValue));
3728 ;}
3729 break;
3730
3731 case 255:
3732
3733 /* Line 1455 of yacc.c */
3734 #line 847 "./js-parser/Grammar.y"
3735 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node);;}
3736 break;
3737
3738 case 256:
3739
3740 /* Line 1455 of yacc.c */
3741 #line 848 "./js-parser/Grammar.y"
3742 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node); AUTO_SEMICOLON (node_get_line ((yyvsp[(2) - (3)].node))); ;}
3743 break;
3744
3745 case 257:
3746
3747 /* Line 1455 of yacc.c */
3748 #line 852 "./js-parser/Grammar.y"
3749 { PRINT_LINE;
3750 (yyval.node) = node_new (TOK_VAR, PN_LIST);
3751 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
3752 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
3753 ;}
3754 break;
3755
3756 case 258:
3757
3758 /* Line 1455 of yacc.c */
3759 #line 857 "./js-parser/Grammar.y"
3760 { PRINT_LINE;
3761 (yyval.node) = node_new (TOK_VAR, PN_LIST);
3762 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
3763 (yyvsp[(1) - (2)].node)->pn_u.name.expr = (yyvsp[(2) - (2)].node);
3764 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
3765 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
3766 ;}
3767 break;
3768
3769 case 259:
3770
3771 /* Line 1455 of yacc.c */
3772 #line 865 "./js-parser/Grammar.y"
3773 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (3)].node);
3774 if ((yyvsp[(3) - (3)].node)) {
3775 g_assert ((yyvsp[(1) - (3)].node)->pn_arity == PN_LIST);
3776 (yyvsp[(3) - (3)].node)->pn_next = (yyvsp[(1) - (3)].node)->pn_u.list.head;
3777 (yyvsp[(1) - (3)].node)->pn_u.list.head = (yyvsp[(3) - (3)].node);
3778 }
3779 node_correct_position ((yyval.node), (yyvsp[(1) - (3)].node));
3780 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3781 ;}
3782 break;
3783
3784 case 260:
3785
3786 /* Line 1455 of yacc.c */
3787 #line 875 "./js-parser/Grammar.y"
3788 { PRINT_LINE;
3789 if ((yyvsp[(3) - (4)].node)) {
3790 g_assert ((yyvsp[(1) - (4)].node)->pn_arity == PN_LIST);
3791 (yyvsp[(3) - (4)].node)->pn_next = (yyvsp[(1) - (4)].node)->pn_u.list.head;
3792 (yyvsp[(1) - (4)].node)->pn_u.list.head = (yyvsp[(3) - (4)].node);
3793 (yyvsp[(3) - (4)].node)->pn_u.name.expr = (yyvsp[(4) - (4)].node);
3794 }
3795 node_correct_position ((yyval.node), (yyvsp[(1) - (4)].node));
3796 node_correct_position ((yyval.node), (yyvsp[(3) - (4)].node));
3797 node_correct_position ((yyval.node), (yyvsp[(4) - (4)].node));
3798 ;}
3799 break;
3800
3801 case 261:
3802
3803 /* Line 1455 of yacc.c */
3804 #line 889 "./js-parser/Grammar.y"
3805 { PRINT_LINE;
3806 (yyval.node) = node_new (TOK_VAR, PN_LIST);
3807 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
3808 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
3809 ;}
3810 break;
3811
3812 case 262:
3813
3814 /* Line 1455 of yacc.c */
3815 #line 894 "./js-parser/Grammar.y"
3816 { PRINT_LINE;
3817 (yyval.node) = node_new (TOK_VAR, PN_LIST);
3818 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (2)].node);
3819 (yyvsp[(1) - (2)].node)->pn_u.name.expr = (yyvsp[(2) - (2)].node);
3820 node_correct_position ((yyval.node), (yyvsp[(1) - (2)].node));
3821 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
3822 ;}
3823 break;
3824
3825 case 263:
3826
3827 /* Line 1455 of yacc.c */
3828 #line 902 "./js-parser/Grammar.y"
3829 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3830 break;
3831
3832 case 264:
3833
3834 /* Line 1455 of yacc.c */
3835 #line 904 "./js-parser/Grammar.y"
3836 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3837 break;
3838
3839 case 265:
3840
3841 /* Line 1455 of yacc.c */
3842 #line 908 "./js-parser/Grammar.y"
3843 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node);;}
3844 break;
3845
3846 case 266:
3847
3848 /* Line 1455 of yacc.c */
3849 #line 910 "./js-parser/Grammar.y"
3850 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (3)].node); AUTO_SEMICOLON (node_get_line ((yyvsp[(2) - (3)].node)));; ;}
3851 break;
3852
3853 case 267:
3854
3855 /* Line 1455 of yacc.c */
3856 #line 914 "./js-parser/Grammar.y"
3857 { PRINT_LINE;
3858 (yyval.node) = node_new (TOK_VAR, PN_LIST);
3859 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
3860 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
3861 ;}
3862 break;
3863
3864 case 268:
3865
3866 /* Line 1455 of yacc.c */
3867 #line 920 "./js-parser/Grammar.y"
3868 { PRINT_LINE;
3869 (yyval.node) = (yyvsp[(1) - (3)].node);
3870 if ((yyvsp[(3) - (3)].node)) {
3871 g_assert ((yyvsp[(1) - (3)].node)->pn_arity == PN_LIST);
3872 (yyvsp[(3) - (3)].node)->pn_next = (yyvsp[(1) - (3)].node)->pn_u.list.head;
3873 (yyvsp[(1) - (3)].node)->pn_u.list.head = (yyvsp[(3) - (3)].node);
3874 }
3875 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
3876 ;}
3877 break;
3878
3879 case 269:
3880
3881 /* Line 1455 of yacc.c */
3882 #line 932 "./js-parser/Grammar.y"
3883 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (1)].node); (yyvsp[(1) - (1)].node)->pn_u.name.isconst = 1;;}
3884 break;
3885
3886 case 270:
3887
3888 /* Line 1455 of yacc.c */
3889 #line 933 "./js-parser/Grammar.y"
3890 { PRINT_LINE_TODO;
3891 (yyval.node) = (yyvsp[(1) - (2)].node);
3892 (yyval.node)->pn_u.name.expr = (yyvsp[(2) - (2)].node);
3893 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
3894 ;}
3895 break;
3896
3897 case 271:
3898
3899 /* Line 1455 of yacc.c */
3900 #line 941 "./js-parser/Grammar.y"
3901 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (2)].node);;}
3902 break;
3903
3904 case 272:
3905
3906 /* Line 1455 of yacc.c */
3907 #line 945 "./js-parser/Grammar.y"
3908 { PRINT_LINE; (yyval.node) = (yyvsp[(2) - (2)].node);;}
3909 break;
3910
3911 case 273:
3912
3913 /* Line 1455 of yacc.c */
3914 #line 949 "./js-parser/Grammar.y"
3915 { PRINT_LINE; (yyval.node) = node_new (TOK_SEMI, PN_UNARY); (yyval.node)->pn_u.unary.kid = NULL;;}
3916 break;
3917
3918 case 274:
3919
3920 /* Line 1455 of yacc.c */
3921 #line 953 "./js-parser/Grammar.y"
3922 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (2)].node);;}
3923 break;
3924
3925 case 275:
3926
3927 /* Line 1455 of yacc.c */
3928 #line 954 "./js-parser/Grammar.y"
3929 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (2)].node); AUTO_SEMICOLON (node_get_line ((yyvsp[(1) - (2)].node)));; ;}
3930 break;
3931
3932 case 276:
3933
3934 /* Line 1455 of yacc.c */
3935 #line 959 "./js-parser/Grammar.y"
3936 { PRINT_LINE; (yyval.node) = (yyvsp[(5) - (5)].node);;}
3937 break;
3938
3939 case 277:
3940
3941 /* Line 1455 of yacc.c */
3942 #line 961 "./js-parser/Grammar.y"
3943 { PRINT_LINE; (yyval.node) = (yyvsp[(5) - (7)].node);;}
3944 break;
3945
3946 case 278:
3947
3948 /* Line 1455 of yacc.c */
3949 #line 965 "./js-parser/Grammar.y"
3950 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3951 break;
3952
3953 case 279:
3954
3955 /* Line 1455 of yacc.c */
3956 #line 966 "./js-parser/Grammar.y"
3957 { PRINT_LINE; (yyval.node) = NULL; AUTO_SEMICOLON (node_get_line ((yyvsp[(5) - (7)].node)));;}
3958 break;
3959
3960 case 280:
3961
3962 /* Line 1455 of yacc.c */
3963 #line 967 "./js-parser/Grammar.y"
3964 { PRINT_LINE; (yyval.node) = (yyvsp[(5) - (5)].node);;}
3965 break;
3966
3967 case 281:
3968
3969 /* Line 1455 of yacc.c */
3970 #line 969 "./js-parser/Grammar.y"
3971 { PRINT_LINE; (yyval.node) = (yyvsp[(9) - (9)].node);;}
3972 break;
3973
3974 case 282:
3975
3976 /* Line 1455 of yacc.c */
3977 #line 971 "./js-parser/Grammar.y"
3978 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
3979 break;
3980
3981 case 283:
3982
3983 /* Line 1455 of yacc.c */
3984 #line 973 "./js-parser/Grammar.y"
3985 { PRINT_LINE; (yyval.node) = (yyvsp[(7) - (7)].node);;}
3986 break;
3987
3988 case 284:
3989
3990 /* Line 1455 of yacc.c */
3991 #line 975 "./js-parser/Grammar.y"
3992 { PRINT_LINE; (yyval.node) = (yyvsp[(8) - (8)].node);;}
3993 break;
3994
3995 case 285:
3996
3997 /* Line 1455 of yacc.c */
3998 #line 977 "./js-parser/Grammar.y"
3999 { PRINT_LINE; (yyval.node) = (yyvsp[(9) - (9)].node);;}
4000 break;
4001
4002 case 286:
4003
4004 /* Line 1455 of yacc.c */
4005 #line 981 "./js-parser/Grammar.y"
4006 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4007 break;
4008
4009 case 288:
4010
4011 /* Line 1455 of yacc.c */
4012 #line 986 "./js-parser/Grammar.y"
4013 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4014 break;
4015
4016 case 290:
4017
4018 /* Line 1455 of yacc.c */
4019 #line 991 "./js-parser/Grammar.y"
4020 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4021 break;
4022
4023 case 291:
4024
4025 /* Line 1455 of yacc.c */
4026 #line 992 "./js-parser/Grammar.y"
4027 { PRINT_LINE; AUTO_SEMICOLON (0); ;}
4028 break;
4029
4030 case 292:
4031
4032 /* Line 1455 of yacc.c */
4033 #line 993 "./js-parser/Grammar.y"
4034 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4035 break;
4036
4037 case 293:
4038
4039 /* Line 1455 of yacc.c */
4040 #line 994 "./js-parser/Grammar.y"
4041 { PRINT_LINE; AUTO_SEMICOLON (node_get_line ((yyvsp[(2) - (3)].node))); ;}
4042 break;
4043
4044 case 294:
4045
4046 /* Line 1455 of yacc.c */
4047 #line 998 "./js-parser/Grammar.y"
4048 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4049 break;
4050
4051 case 295:
4052
4053 /* Line 1455 of yacc.c */
4054 #line 999 "./js-parser/Grammar.y"
4055 { PRINT_LINE_TODO; (yyval.node) = NULL; AUTO_SEMICOLON (0);;}
4056 break;
4057
4058 case 296:
4059
4060 /* Line 1455 of yacc.c */
4061 #line 1000 "./js-parser/Grammar.y"
4062 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4063 break;
4064
4065 case 297:
4066
4067 /* Line 1455 of yacc.c */
4068 #line 1001 "./js-parser/Grammar.y"
4069 { PRINT_LINE; AUTO_SEMICOLON (node_get_line ((yyvsp[(2) - (3)].node))); ;}
4070 break;
4071
4072 case 298:
4073
4074 /* Line 1455 of yacc.c */
4075 #line 1005 "./js-parser/Grammar.y"
4076 { PRINT_LINE; (yyval.node) = node_new (TOK_RETURN, PN_UNARY); (yyval.node)->pn_u.unary.kid = NULL;;}
4077 break;
4078
4079 case 299:
4080
4081 /* Line 1455 of yacc.c */
4082 #line 1006 "./js-parser/Grammar.y"
4083 { PRINT_LINE; (yyval.node) = node_new (TOK_RETURN, PN_UNARY); (yyval.node)->pn_u.unary.kid = NULL; AUTO_SEMICOLON (0); ;}
4084 break;
4085
4086 case 300:
4087
4088 /* Line 1455 of yacc.c */
4089 #line 1007 "./js-parser/Grammar.y"
4090 { PRINT_LINE;
4091 (yyval.node) = node_new (TOK_RETURN, PN_UNARY);
4092 (yyval.node)->pn_u.unary.kid = (yyvsp[(2) - (3)].node);
4093 node_correct_position ((yyval.node), (yyvsp[(2) - (3)].node));
4094 ;}
4095 break;
4096
4097 case 301:
4098
4099 /* Line 1455 of yacc.c */
4100 #line 1012 "./js-parser/Grammar.y"
4101 { PRINT_LINE;
4102 (yyval.node) = node_new (TOK_RETURN, PN_UNARY);
4103 (yyval.node)->pn_u.unary.kid = (yyvsp[(2) - (3)].node);
4104 node_correct_position ((yyval.node), (yyvsp[(2) - (3)].node));
4105 AUTO_SEMICOLON (node_get_line ((yyvsp[(2) - (3)].node)));
4106 ;}
4107 break;
4108
4109 case 302:
4110
4111 /* Line 1455 of yacc.c */
4112 #line 1021 "./js-parser/Grammar.y"
4113 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4114 break;
4115
4116 case 303:
4117
4118 /* Line 1455 of yacc.c */
4119 #line 1025 "./js-parser/Grammar.y"
4120 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4121 break;
4122
4123 case 304:
4124
4125 /* Line 1455 of yacc.c */
4126 #line 1029 "./js-parser/Grammar.y"
4127 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4128 break;
4129
4130 case 305:
4131
4132 /* Line 1455 of yacc.c */
4133 #line 1031 "./js-parser/Grammar.y"
4134 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4135 break;
4136
4137 case 306:
4138
4139 /* Line 1455 of yacc.c */
4140 #line 1035 "./js-parser/Grammar.y"
4141 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4142 break;
4143
4144 case 308:
4145
4146 /* Line 1455 of yacc.c */
4147 #line 1040 "./js-parser/Grammar.y"
4148 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4149 break;
4150
4151 case 309:
4152
4153 /* Line 1455 of yacc.c */
4154 #line 1041 "./js-parser/Grammar.y"
4155 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4156 break;
4157
4158 case 310:
4159
4160 /* Line 1455 of yacc.c */
4161 #line 1045 "./js-parser/Grammar.y"
4162 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4163 break;
4164
4165 case 311:
4166
4167 /* Line 1455 of yacc.c */
4168 #line 1046 "./js-parser/Grammar.y"
4169 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4170 break;
4171
4172 case 312:
4173
4174 /* Line 1455 of yacc.c */
4175 #line 1050 "./js-parser/Grammar.y"
4176 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4177 break;
4178
4179 case 313:
4180
4181 /* Line 1455 of yacc.c */
4182 #line 1051 "./js-parser/Grammar.y"
4183 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4184 break;
4185
4186 case 314:
4187
4188 /* Line 1455 of yacc.c */
4189 #line 1055 "./js-parser/Grammar.y"
4190 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4191 break;
4192
4193 case 315:
4194
4195 /* Line 1455 of yacc.c */
4196 #line 1059 "./js-parser/Grammar.y"
4197 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4198 break;
4199
4200 case 316:
4201
4202 /* Line 1455 of yacc.c */
4203 #line 1060 "./js-parser/Grammar.y"
4204 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4205 break;
4206
4207 case 317:
4208
4209 /* Line 1455 of yacc.c */
4210 #line 1064 "./js-parser/Grammar.y"
4211 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4212 break;
4213
4214 case 318:
4215
4216 /* Line 1455 of yacc.c */
4217 #line 1065 "./js-parser/Grammar.y"
4218 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4219 break;
4220
4221 case 319:
4222
4223 /* Line 1455 of yacc.c */
4224 #line 1067 "./js-parser/Grammar.y"
4225 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4226 break;
4227
4228 case 320:
4229
4230 /* Line 1455 of yacc.c */
4231 #line 1071 "./js-parser/Grammar.y"
4232 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4233 break;
4234
4235 case 321:
4236
4237 /* Line 1455 of yacc.c */
4238 #line 1072 "./js-parser/Grammar.y"
4239 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4240 break;
4241
4242 case 322:
4243
4244 /* Line 1455 of yacc.c */
4245 #line 1076 "./js-parser/Grammar.y"
4246 { PRINT_LINE;
4247 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4248 (yyval.node)->pn_u.func.name = (yyvsp[(2) - (7)].node);
4249 (yyval.node)->pn_u.func.body = (yyvsp[(6) - (7)].node);
4250 (yyval.node)->pn_u.func.args = NULL;
4251 node_correct_position ((yyval.node), (yyvsp[(2) - (7)].node));
4252 node_correct_position ((yyval.node), (yyvsp[(6) - (7)].node));
4253 node_correct_position_end ((yyval.node), (yyvsp[(7) - (7)].intValue));
4254 ;}
4255 break;
4256
4257 case 323:
4258
4259 /* Line 1455 of yacc.c */
4260 #line 1086 "./js-parser/Grammar.y"
4261 { PRINT_LINE;
4262 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4263 (yyval.node)->pn_u.func.name = (yyvsp[(2) - (8)].node);
4264 (yyval.node)->pn_u.func.body = (yyvsp[(7) - (8)].node);
4265 (yyval.node)->pn_u.func.args = (yyvsp[(4) - (8)].node);
4266 node_correct_position ((yyval.node), (yyvsp[(2) - (8)].node));
4267 node_correct_position ((yyval.node), (yyvsp[(7) - (8)].node));
4268 node_correct_position ((yyval.node), (yyvsp[(4) - (8)].node));
4269 node_correct_position_end ((yyval.node), (yyvsp[(8) - (8)].intValue));
4270 ;}
4271 break;
4272
4273 case 324:
4274
4275 /* Line 1455 of yacc.c */
4276 #line 1099 "./js-parser/Grammar.y"
4277 { PRINT_LINE;
4278 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4279 (yyval.node)->pn_u.func.name = NULL;
4280 (yyval.node)->pn_u.func.body = (yyvsp[(5) - (6)].node);
4281 (yyval.node)->pn_u.func.args = NULL;
4282 node_correct_position ((yyval.node), (yyvsp[(5) - (6)].node));
4283 node_correct_position_end ((yyval.node), (yyvsp[(6) - (6)].intValue));
4284 ;}
4285 break;
4286
4287 case 325:
4288
4289 /* Line 1455 of yacc.c */
4290 #line 1108 "./js-parser/Grammar.y"
4291 { PRINT_LINE;
4292 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4293 (yyval.node)->pn_u.func.name = NULL;
4294 (yyval.node)->pn_u.func.body = (yyvsp[(6) - (7)].node);
4295 (yyval.node)->pn_u.func.args = (yyvsp[(3) - (7)].node);
4296 node_correct_position ((yyval.node), (yyvsp[(3) - (7)].node));
4297 node_correct_position ((yyval.node), (yyvsp[(6) - (7)].node));
4298 node_correct_position_end ((yyval.node), (yyvsp[(7) - (7)].intValue));
4299 ;}
4300 break;
4301
4302 case 326:
4303
4304 /* Line 1455 of yacc.c */
4305 #line 1117 "./js-parser/Grammar.y"
4306 { PRINT_LINE;
4307 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4308 (yyval.node)->pn_u.func.name = (yyvsp[(2) - (7)].node);
4309 (yyval.node)->pn_u.func.body = (yyvsp[(6) - (7)].node);
4310 (yyval.node)->pn_u.func.args = NULL;
4311 node_correct_position ((yyval.node), (yyvsp[(2) - (7)].node));
4312 node_correct_position ((yyval.node), (yyvsp[(6) - (7)].node));
4313 node_correct_position_end ((yyval.node), (yyvsp[(7) - (7)].intValue));
4314 ;}
4315 break;
4316
4317 case 327:
4318
4319 /* Line 1455 of yacc.c */
4320 #line 1127 "./js-parser/Grammar.y"
4321 { PRINT_LINE;
4322 (yyval.node) = node_new ( TOK_FUNCTION, PN_FUNC);
4323 (yyval.node)->pn_u.func.name = (yyvsp[(2) - (8)].node);
4324 (yyval.node)->pn_u.func.body = (yyvsp[(7) - (8)].node);
4325 (yyval.node)->pn_u.func.args = (yyvsp[(4) - (8)].node);
4326 node_correct_position ((yyval.node), (yyvsp[(2) - (8)].node));
4327 node_correct_position ((yyval.node), (yyvsp[(4) - (8)].node));
4328 node_correct_position ((yyval.node), (yyvsp[(7) - (8)].node));
4329 node_correct_position_end ((yyval.node), (yyvsp[(8) - (8)].intValue));
4330 ;}
4331 break;
4332
4333 case 328:
4334
4335 /* Line 1455 of yacc.c */
4336 #line 1140 "./js-parser/Grammar.y"
4337 { PRINT_LINE;
4338 (yyval.node) = node_new (TOK_LC, PN_LIST);
4339 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
4340 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
4341 ;}
4342 break;
4343
4344 case 329:
4345
4346 /* Line 1455 of yacc.c */
4347 #line 1145 "./js-parser/Grammar.y"
4348 { PRINT_LINE;
4349 (yyval.node) = (yyvsp[(1) - (3)].node);
4350 g_assert ((yyvsp[(1) - (3)].node)->pn_arity == PN_LIST);
4351 if ((yyvsp[(1) - (3)].node)->pn_u.list.head) {
4352 JSNode *i;
4353 for (i = (yyvsp[(1) - (3)].node)->pn_u.list.head; i->pn_next != NULL; i = i->pn_next)
4354 ;
4355 i->pn_next = (yyvsp[(3) - (3)].node);
4356 } else (yyvsp[(1) - (3)].node)->pn_u.list.head = (yyvsp[(3) - (3)].node);
4357 node_correct_position ((yyval.node), (yyvsp[(3) - (3)].node));
4358 ;}
4359 break;
4360
4361 case 330:
4362
4363 /* Line 1455 of yacc.c */
4364 #line 1159 "./js-parser/Grammar.y"
4365 { PRINT_LINE_TODO; (yyval.node) = NULL;;}
4366 break;
4367
4368 case 331:
4369
4370 /* Line 1455 of yacc.c */
4371 #line 1160 "./js-parser/Grammar.y"
4372 { PRINT_LINE; (yyval.node) = (yyvsp[(1) - (1)].node);;}
4373 break;
4374
4375 case 332:
4376
4377 /* Line 1455 of yacc.c */
4378 #line 1164 "./js-parser/Grammar.y"
4379 { PRINT_LINE; global = NULL;;}
4380 break;
4381
4382 case 333:
4383
4384 /* Line 1455 of yacc.c */
4385 #line 1165 "./js-parser/Grammar.y"
4386 { PRINT_LINE; global = (yyvsp[(1) - (1)].node);;}
4387 break;
4388
4389 case 334:
4390
4391 /* Line 1455 of yacc.c */
4392 #line 1169 "./js-parser/Grammar.y"
4393 { PRINT_LINE;
4394 (yyval.node) = node_new (TOK_LC, PN_LIST);
4395 (yyval.node)->pn_u.list.head = (yyvsp[(1) - (1)].node);
4396 node_correct_position ((yyval.node), (yyvsp[(1) - (1)].node));
4397 ;}
4398 break;
4399
4400 case 335:
4401
4402 /* Line 1455 of yacc.c */
4403 #line 1174 "./js-parser/Grammar.y"
4404 { PRINT_LINE;
4405 (yyval.node) = (yyvsp[(1) - (2)].node);
4406 g_assert ((yyvsp[(1) - (2)].node)->pn_arity == PN_LIST);
4407 if ((yyvsp[(1) - (2)].node)->pn_u.list.head) {
4408 JSNode *i;
4409 for (i = (yyvsp[(1) - (2)].node)->pn_u.list.head; i->pn_next != NULL; i = i->pn_next) {
4410 }
4411 i->pn_next = (yyvsp[(2) - (2)].node);
4412 } else (yyvsp[(1) - (2)].node)->pn_u.list.head = (yyvsp[(2) - (2)].node);
4413 node_correct_position ((yyval.node), (yyvsp[(2) - (2)].node));
4414 ;}
4415 break;
4416
4417
4418
4419 /* Line 1455 of yacc.c */
4420 #line 4421 "./js-parser/js-parser-y-tab.c"
4421 default: break;
4422 }
4423 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4424
4425 YYPOPSTACK (yylen);
4426 yylen = 0;
4427 YY_STACK_PRINT (yyss, yyssp);
4428
4429 *++yyvsp = yyval;
4430
4431 /* Now `shift' the result of the reduction. Determine what state
4432 that goes to, based on the state we popped back to and the rule
4433 number reduced by. */
4434
4435 yyn = yyr1[yyn];
4436
4437 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4438 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4439 yystate = yytable[yystate];
4440 else
4441 yystate = yydefgoto[yyn - YYNTOKENS];
4442
4443 goto yynewstate;
4444
4445
4446 /*------------------------------------.
4447 | yyerrlab -- here on detecting error |
4448 `------------------------------------*/
4449 yyerrlab:
4450 /* If not already recovering from an error, report this error. */
4451 if (!yyerrstatus)
4452 {
4453 ++yynerrs;
4454 #if ! YYERROR_VERBOSE
4455 yyerror (YY_("syntax error"));
4456 #else
4457 {
4458 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4459 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4460 {
4461 YYSIZE_T yyalloc = 2 * yysize;
4462 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4463 yyalloc = YYSTACK_ALLOC_MAXIMUM;
4464 if (yymsg != yymsgbuf)
4465 YYSTACK_FREE (yymsg);
4466 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4467 if (yymsg)
4468 yymsg_alloc = yyalloc;
4469 else
4470 {
4471 yymsg = yymsgbuf;
4472 yymsg_alloc = sizeof yymsgbuf;
4473 }
4474 }
4475
4476 if (0 < yysize && yysize <= yymsg_alloc)
4477 {
4478 (void) yysyntax_error (yymsg, yystate, yychar);
4479 yyerror (yymsg);
4480 }
4481 else
4482 {
4483 yyerror (YY_("syntax error"));
4484 if (yysize != 0)
4485 goto yyexhaustedlab;
4486 }
4487 }
4488 #endif
4489 }
4490
4491
4492
4493 if (yyerrstatus == 3)
4494 {
4495 /* If just tried and failed to reuse lookahead token after an
4496 error, discard it. */
4497
4498 if (yychar <= YYEOF)
4499 {
4500 /* Return failure if at end of input. */
4501 if (yychar == YYEOF)
4502 YYABORT;
4503 }
4504 else
4505 {
4506 yydestruct ("Error: discarding",
4507 yytoken, &yylval);
4508 yychar = YYEMPTY;
4509 }
4510 }
4511
4512 /* Else will try to reuse lookahead token after shifting the error
4513 token. */
4514 goto yyerrlab1;
4515
4516
4517 /*---------------------------------------------------.
4518 | yyerrorlab -- error raised explicitly by YYERROR. |
4519 `---------------------------------------------------*/
4520 yyerrorlab:
4521
4522 /* Pacify compilers like GCC when the user code never invokes
4523 YYERROR and the label yyerrorlab therefore never appears in user
4524 code. */
4525 if (/*CONSTCOND*/ 0)
4526 goto yyerrorlab;
4527
4528 /* Do not reclaim the symbols of the rule which action triggered
4529 this YYERROR. */
4530 YYPOPSTACK (yylen);
4531 yylen = 0;
4532 YY_STACK_PRINT (yyss, yyssp);
4533 yystate = *yyssp;
4534 goto yyerrlab1;
4535
4536
4537 /*-------------------------------------------------------------.
4538 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4539 `-------------------------------------------------------------*/
4540 yyerrlab1:
4541 yyerrstatus = 3; /* Each real token shifted decrements this. */
4542
4543 for (;;)
4544 {
4545 yyn = yypact[yystate];
4546 if (yyn != YYPACT_NINF)
4547 {
4548 yyn += YYTERROR;
4549 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4550 {
4551 yyn = yytable[yyn];
4552 if (0 < yyn)
4553 break;
4554 }
4555 }
4556
4557 /* Pop the current state because it cannot handle the error token. */
4558 if (yyssp == yyss)
4559 YYABORT;
4560
4561
4562 yydestruct ("Error: popping",
4563 yystos[yystate], yyvsp);
4564 YYPOPSTACK (1);
4565 yystate = *yyssp;
4566 YY_STACK_PRINT (yyss, yyssp);
4567 }
4568
4569 *++yyvsp = yylval;
4570
4571
4572 /* Shift the error token. */
4573 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4574
4575 yystate = yyn;
4576 goto yynewstate;
4577
4578
4579 /*-------------------------------------.
4580 | yyacceptlab -- YYACCEPT comes here. |
4581 `-------------------------------------*/
4582 yyacceptlab:
4583 yyresult = 0;
4584 goto yyreturn;
4585
4586 /*-----------------------------------.
4587 | yyabortlab -- YYABORT comes here. |
4588 `-----------------------------------*/
4589 yyabortlab:
4590 yyresult = 1;
4591 goto yyreturn;
4592
4593 #if !defined(yyoverflow) || YYERROR_VERBOSE
4594 /*-------------------------------------------------.
4595 | yyexhaustedlab -- memory exhaustion comes here. |
4596 `-------------------------------------------------*/
4597 yyexhaustedlab:
4598 yyerror (YY_("memory exhausted"));
4599 yyresult = 2;
4600 /* Fall through. */
4601 #endif
4602
4603 yyreturn:
4604 if (yychar != YYEMPTY)
4605 yydestruct ("Cleanup: discarding lookahead",
4606 yytoken, &yylval);
4607 /* Do not reclaim the symbols of the rule which action triggered
4608 this YYABORT or YYACCEPT. */
4609 YYPOPSTACK (yylen);
4610 YY_STACK_PRINT (yyss, yyssp);
4611 while (yyssp != yyss)
4612 {
4613 yydestruct ("Cleanup: popping",
4614 yystos[*yyssp], yyvsp);
4615 YYPOPSTACK (1);
4616 }
4617 #ifndef yyoverflow
4618 if (yyss != yyssa)
4619 YYSTACK_FREE (yyss);
4620 #endif
4621 yyps->yynew = 1;
4622
4623 yypushreturn:
4624 #if YYERROR_VERBOSE
4625 if (yymsg != yymsgbuf)
4626 YYSTACK_FREE (yymsg);
4627 #endif
4628 /* Make sure YYID is used. */
4629 return YYID (yyresult);
4630 }
4631
4632
4633
4634 /* Line 1675 of yacc.c */
4635 #line 1187 "./js-parser/Grammar.y"
4636
4637 #undef GLOBAL_DATA
4638
yyerror(char * msg)4639 void yyerror (char* msg)
4640 {
4641 // puts (msg);
4642 }
4643
4644