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