• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • kjs
 

kjs

  • kjs
grammar.cpp
1 /* A Bison parser, made by GNU Bison 2.1. */
2 
3 /* Skeleton parser for Yacc-like parsing with Bison,
4  Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2, or (at your option)
9  any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program; if not, write to the Free Software
18  Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  Boston, MA 02110-1301, USA. */
20 
21 /* As a special exception, when this file is copied by Bison into a
22  Bison output file, you may use that output file without restriction.
23  This special exception was added by the Free Software Foundation
24  in version 1.24 of Bison. */
25 
26 /* Written by Richard Stallman by simplifying the original so called
27  ``semantic'' parser. */
28 
29 /* All symbols defined below should begin with yy or YY, to avoid
30  infringing on user name space. This should be done even for local
31  variables, as they might otherwise be expanded by user macros.
32  There are some unavoidable exceptions within include files to
33  define necessary library symbols; they are noted "INFRINGES ON
34  USER NAME SPACE" below. */
35 
36 /* Identify Bison output. */
37 #define YYBISON 1
38 
39 /* Bison version. */
40 #define YYBISON_VERSION "2.1"
41 
42 /* Skeleton name. */
43 #define YYSKELETON_NAME "yacc.c"
44 
45 /* Pure parsers. */
46 #define YYPURE 0
47 
48 /* Using locations. */
49 #define YYLSP_NEEDED 1
50 
51 /* Substitute the variable and function names. */
52 #define yyparse kjsyyparse
53 #define yylex kjsyylex
54 #define yyerror kjsyyerror
55 #define yylval kjsyylval
56 #define yychar kjsyychar
57 #define yydebug kjsyydebug
58 #define yynerrs kjsyynerrs
59 #define yylloc kjsyylloc
60 
61 /* Tokens. */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64  /* Put the tokens into the symbol table, so that GDB and other debuggers
65  know about them. */
66  enum yytokentype {
67  NULLTOKEN = 258,
68  TRUETOKEN = 259,
69  FALSETOKEN = 260,
70  STRING = 261,
71  NUMBER = 262,
72  BREAK = 263,
73  CASE = 264,
74  DEFAULT = 265,
75  FOR = 266,
76  NEW = 267,
77  VAR = 268,
78  CONST = 269,
79  CONTINUE = 270,
80  FUNCTION = 271,
81  RETURN = 272,
82  VOID = 273,
83  DELETE = 274,
84  IF = 275,
85  THIS = 276,
86  DO = 277,
87  WHILE = 278,
88  ELSE = 279,
89  IN = 280,
90  INSTANCEOF = 281,
91  TYPEOF = 282,
92  SWITCH = 283,
93  WITH = 284,
94  RESERVED = 285,
95  THROW = 286,
96  TRY = 287,
97  CATCH = 288,
98  FINALLY = 289,
99  DEBUGGER = 290,
100  EQEQ = 291,
101  NE = 292,
102  STREQ = 293,
103  STRNEQ = 294,
104  LE = 295,
105  GE = 296,
106  OR = 297,
107  AND = 298,
108  PLUSPLUS = 299,
109  MINUSMINUS = 300,
110  LSHIFT = 301,
111  RSHIFT = 302,
112  URSHIFT = 303,
113  PLUSEQUAL = 304,
114  MINUSEQUAL = 305,
115  MULTEQUAL = 306,
116  DIVEQUAL = 307,
117  LSHIFTEQUAL = 308,
118  RSHIFTEQUAL = 309,
119  URSHIFTEQUAL = 310,
120  ANDEQUAL = 311,
121  MODEQUAL = 312,
122  XOREQUAL = 313,
123  OREQUAL = 314,
124  IDENT = 315,
125  FUNCEXPRIDENT = 316,
126  AUTOPLUSPLUS = 317,
127  AUTOMINUSMINUS = 318
128  };
129 #endif
130 /* Tokens. */
131 #define NULLTOKEN 258
132 #define TRUETOKEN 259
133 #define FALSETOKEN 260
134 #define STRING 261
135 #define NUMBER 262
136 #define BREAK 263
137 #define CASE 264
138 #define DEFAULT 265
139 #define FOR 266
140 #define NEW 267
141 #define VAR 268
142 #define CONST 269
143 #define CONTINUE 270
144 #define FUNCTION 271
145 #define RETURN 272
146 #define VOID 273
147 #define DELETE 274
148 #define IF 275
149 #define THIS 276
150 #define DO 277
151 #define WHILE 278
152 #define ELSE 279
153 #define IN 280
154 #define INSTANCEOF 281
155 #define TYPEOF 282
156 #define SWITCH 283
157 #define WITH 284
158 #define RESERVED 285
159 #define THROW 286
160 #define TRY 287
161 #define CATCH 288
162 #define FINALLY 289
163 #define DEBUGGER 290
164 #define EQEQ 291
165 #define NE 292
166 #define STREQ 293
167 #define STRNEQ 294
168 #define LE 295
169 #define GE 296
170 #define OR 297
171 #define AND 298
172 #define PLUSPLUS 299
173 #define MINUSMINUS 300
174 #define LSHIFT 301
175 #define RSHIFT 302
176 #define URSHIFT 303
177 #define PLUSEQUAL 304
178 #define MINUSEQUAL 305
179 #define MULTEQUAL 306
180 #define DIVEQUAL 307
181 #define LSHIFTEQUAL 308
182 #define RSHIFTEQUAL 309
183 #define URSHIFTEQUAL 310
184 #define ANDEQUAL 311
185 #define MODEQUAL 312
186 #define XOREQUAL 313
187 #define OREQUAL 314
188 #define IDENT 315
189 #define FUNCEXPRIDENT 316
190 #define AUTOPLUSPLUS 317
191 #define AUTOMINUSMINUS 318
192 
193 
194 
195 
196 /* Copy the first part of user declarations. */
197 #line 1 "grammar.y"
198 
199 
200 /*
201  * This file is part of the KDE libraries
202  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
203  *
204  * This library is free software; you can redistribute it and/or
205  * modify it under the terms of the GNU Lesser General Public
206  * License as published by the Free Software Foundation; either
207  * version 2 of the License, or (at your option) any later version.
208  *
209  * This library is distributed in the hope that it will be useful,
210  * but WITHOUT ANY WARRANTY; without even the implied warranty of
211  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
212  * Lesser General Public License for more details.
213  *
214  * You should have received a copy of the GNU Lesser General Public
215  * License along with this library; if not, write to the Free Software
216  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
217  *
218  */
219 
220 #ifdef HAVE_CONFIG_H
221 #include <config.h>
222 #endif
223 #include <string.h>
224 #include <stdlib.h>
225 #include "value.h"
226 #include "object.h"
227 #include "types.h"
228 #include "interpreter.h"
229 #include "nodes.h"
230 #include "lexer.h"
231 #include "internal.h"
232 
233 /* default values for bison */
234 #define YYDEBUG 0
235 #ifdef YYMAXDEPTH
236 #undef YYMAXDEPTH
237 #endif
238 #define YYERROR_VERBOSE
239 #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::source); } // location
240 
241 extern int yylex();
242 static int yyerror (const char *);
243 static bool automatic();
244 
245 using namespace KJS;
246 
247 
248 
249 /* Enabling traces. */
250 #ifndef YYDEBUG
251 # define YYDEBUG 0
252 #endif
253 
254 /* Enabling verbose error messages. */
255 #ifdef YYERROR_VERBOSE
256 # undef YYERROR_VERBOSE
257 # define YYERROR_VERBOSE 1
258 #else
259 # define YYERROR_VERBOSE 0
260 #endif
261 
262 /* Enabling the token table. */
263 #ifndef YYTOKEN_TABLE
264 # define YYTOKEN_TABLE 0
265 #endif
266 
267 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
268 #line 52 "grammar.y"
269 typedef union YYSTYPE {
270  int ival;
271  double dval;
272  UString *ustr;
273  Identifier *ident;
274  Node *node;
275  StatementNode *stat;
276  ParameterNode *param;
277  FunctionBodyNode *body;
278  FuncDeclNode *func;
279  FunctionBodyNode *prog;
280  AssignExprNode *init;
281  SourceElementsNode *srcs;
282  StatListNode *slist;
283  ArgumentsNode *args;
284  ArgumentListNode *alist;
285  VarDeclNode *decl;
286  VarDeclListNode *vlist;
287  CaseBlockNode *cblk;
288  ClauseListNode *clist;
289  CaseClauseNode *ccl;
290  ElementNode *elm;
291  Operator op;
292  PropertyValueNode *plist;
293  PropertyNode *pnode;
294  CatchNode *cnode;
295  FinallyNode *fnode;
296 } YYSTYPE;
297 /* Line 196 of yacc.c. */
298 #line 299 "grammar.tab.c"
299 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
300 # define YYSTYPE_IS_DECLARED 1
301 # define YYSTYPE_IS_TRIVIAL 1
302 #endif
303 
304 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
305 typedef struct YYLTYPE
306 {
307  int first_line;
308  int first_column;
309  int last_line;
310  int last_column;
311 } YYLTYPE;
312 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
313 # define YYLTYPE_IS_DECLARED 1
314 # define YYLTYPE_IS_TRIVIAL 1
315 #endif
316 
317 
318 /* Copy the second part of user declarations. */
319 
320 
321 /* Line 219 of yacc.c. */
322 #line 323 "grammar.tab.c"
323 
324 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
325 # define YYSIZE_T __SIZE_TYPE__
326 #endif
327 #if ! defined (YYSIZE_T) && defined (size_t)
328 # define YYSIZE_T size_t
329 #endif
330 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
331 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
332 # define YYSIZE_T size_t
333 #endif
334 #if ! defined (YYSIZE_T)
335 # define YYSIZE_T unsigned int
336 #endif
337 
338 #ifndef YY_
339 # if YYENABLE_NLS
340 # if ENABLE_NLS
341 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
342 # define YY_(msgid) dgettext ("bison-runtime", msgid)
343 # endif
344 # endif
345 # ifndef YY_
346 # define YY_(msgid) msgid
347 # endif
348 #endif
349 
350 #if ! defined (yyoverflow) || YYERROR_VERBOSE
351 
352 /* The parser invokes alloca or malloc; define the necessary symbols. */
353 
354 # ifdef YYSTACK_USE_ALLOCA
355 # if YYSTACK_USE_ALLOCA
356 # ifdef __GNUC__
357 # define YYSTACK_ALLOC __builtin_alloca
358 # else
359 # define YYSTACK_ALLOC alloca
360 # if defined (__STDC__) || defined (__cplusplus)
361 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
362 # define YYINCLUDED_STDLIB_H
363 # endif
364 # endif
365 # endif
366 # endif
367 
368 # ifdef YYSTACK_ALLOC
369  /* Pacify GCC's `empty if-body' warning. */
370 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
371 # ifndef YYSTACK_ALLOC_MAXIMUM
372  /* The OS might guarantee only one guard page at the bottom of the stack,
373  and a page size can be as small as 4096 bytes. So we cannot safely
374  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
375  to allow for a few compiler-allocated temporary stack slots. */
376 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
377 # endif
378 # else
379 # define YYSTACK_ALLOC YYMALLOC
380 # define YYSTACK_FREE YYFREE
381 # ifndef YYSTACK_ALLOC_MAXIMUM
382 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
383 # endif
384 # ifdef __cplusplus
385 extern "C" {
386 # endif
387 # ifndef YYMALLOC
388 # define YYMALLOC malloc
389 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
390  && (defined (__STDC__) || defined (__cplusplus)))
391 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
392 # endif
393 # endif
394 # ifndef YYFREE
395 # define YYFREE free
396 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
397  && (defined (__STDC__) || defined (__cplusplus)))
398 void free (void *); /* INFRINGES ON USER NAME SPACE */
399 # endif
400 # endif
401 # ifdef __cplusplus
402 }
403 # endif
404 # endif
405 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
406 
407 
408 #if (! defined (yyoverflow) \
409  && (! defined (__cplusplus) \
410  || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
411  && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
412 
413 /* A type that is properly aligned for any stack member. */
414 union yyalloc
415 {
416  short int yyss;
417  YYSTYPE yyvs;
418  YYLTYPE yyls;
419 };
420 
421 /* The size of the maximum gap between one aligned stack and the next. */
422 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
423 
424 /* The size of an array large to enough to hold all stacks, each with
425  N elements. */
426 # define YYSTACK_BYTES(N) \
427  ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
428  + 2 * YYSTACK_GAP_MAXIMUM)
429 
430 /* Copy COUNT objects from FROM to TO. The source and destination do
431  not overlap. */
432 # ifndef YYCOPY
433 # if defined (__GNUC__) && 1 < __GNUC__
434 # define YYCOPY(To, From, Count) \
435  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
436 # else
437 # define YYCOPY(To, From, Count) \
438  do \
439  { \
440  YYSIZE_T yyi; \
441  for (yyi = 0; yyi < (Count); yyi++) \
442  (To)[yyi] = (From)[yyi]; \
443  } \
444  while (0)
445 # endif
446 # endif
447 
448 /* Relocate STACK from its old location to the new one. The
449  local variables YYSIZE and YYSTACKSIZE give the old and new number of
450  elements in the stack, and YYPTR gives the new location of the
451  stack. Advance YYPTR to a properly aligned location for the next
452  stack. */
453 # define YYSTACK_RELOCATE(Stack) \
454  do \
455  { \
456  YYSIZE_T yynewbytes; \
457  YYCOPY (&yyptr->Stack, Stack, yysize); \
458  Stack = &yyptr->Stack; \
459  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
460  yyptr += yynewbytes / sizeof (*yyptr); \
461  } \
462  while (0)
463 
464 #endif
465 
466 #if defined (__STDC__) || defined (__cplusplus)
467  typedef signed char yysigned_char;
468 #else
469  typedef short int yysigned_char;
470 #endif
471 
472 /* YYFINAL -- State number of the termination state. */
473 #define YYFINAL 196
474 /* YYLAST -- Last index in YYTABLE. */
475 #define YYLAST 1472
476 
477 /* YYNTOKENS -- Number of terminals. */
478 #define YYNTOKENS 88
479 /* YYNNTS -- Number of nonterminals. */
480 #define YYNNTS 70
481 /* YYNRULES -- Number of rules. */
482 #define YYNRULES 212
483 /* YYNRULES -- Number of states. */
484 #define YYNSTATES 384
485 
486 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
487 #define YYUNDEFTOK 2
488 #define YYMAXUTOK 318
489 
490 #define YYTRANSLATE(YYX) \
491  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
492 
493 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
494 static const unsigned char yytranslate[] =
495 {
496  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
497  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
498  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
499  2, 2, 2, 77, 2, 2, 2, 79, 82, 2,
500  65, 66, 78, 74, 69, 75, 73, 64, 2, 2,
501  2, 2, 2, 2, 2, 2, 2, 2, 72, 87,
502  80, 86, 81, 85, 2, 2, 2, 2, 2, 2,
503  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
504  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
505  2, 70, 2, 71, 83, 2, 2, 2, 2, 2,
506  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
507  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
508  2, 2, 2, 67, 84, 68, 76, 2, 2, 2,
509  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
510  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
511  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
512  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
513  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
514  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
515  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
516  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
517  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
518  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
519  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
520  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
521  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
522  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
523  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
524  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
525  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
526  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
527  55, 56, 57, 58, 59, 60, 61, 62, 63
528 };
529 
530 #if YYDEBUG
531 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
532  YYRHS. */
533 static const unsigned short int yyprhs[] =
534 {
535  0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
536  19, 21, 23, 25, 29, 32, 36, 41, 45, 49,
537  55, 58, 63, 64, 66, 68, 71, 75, 81, 83,
538  85, 87, 89, 91, 96, 100, 104, 106, 109, 112,
539  115, 120, 124, 127, 131, 133, 137, 139, 141, 143,
540  146, 149, 151, 154, 157, 160, 163, 166, 169, 172,
541  175, 178, 181, 184, 186, 190, 194, 198, 200, 204,
542  208, 210, 214, 218, 222, 224, 228, 232, 236, 240,
543  244, 248, 250, 254, 258, 262, 266, 268, 272, 274,
544  278, 280, 284, 286, 290, 292, 296, 298, 304, 306,
545  310, 312, 314, 316, 318, 320, 322, 324, 326, 328,
546  330, 332, 334, 336, 340, 342, 344, 346, 348, 350,
547  352, 354, 356, 358, 360, 362, 364, 366, 368, 370,
548  372, 375, 379, 381, 384, 388, 392, 394, 398, 400,
549  403, 407, 411, 413, 417, 419, 422, 425, 427, 430,
550  433, 439, 447, 454, 460, 470, 481, 489, 498, 508,
551  509, 511, 514, 517, 521, 525, 528, 531, 535, 539,
552  542, 545, 549, 553, 559, 565, 569, 575, 576, 578,
553  580, 583, 587, 592, 595, 599, 603, 607, 611, 615,
554  619, 624, 627, 630, 636, 639, 641, 644, 650, 657,
555  662, 668, 674, 681, 683, 687, 690, 694, 695, 697,
556  699, 702, 704
557 };
558 
559 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
560 static const short int yyrhs[] =
561 {
562  155, 0, -1, 3, -1, 4, -1, 5, -1, 7,
563  -1, 6, -1, 64, -1, 52, -1, 21, -1, 60,
564  -1, 89, -1, 91, -1, 65, 118, 66, -1, 67,
565  68, -1, 67, 95, 68, -1, 67, 95, 69, 68,
566  -1, 70, 93, 71, -1, 70, 92, 71, -1, 70,
567  92, 69, 93, 71, -1, 93, 116, -1, 92, 69,
568  93, 116, -1, -1, 94, -1, 69, -1, 94, 69,
569  -1, 96, 72, 116, -1, 95, 69, 96, 72, 116,
570  -1, 60, -1, 6, -1, 7, -1, 90, -1, 152,
571  -1, 97, 70, 118, 71, -1, 97, 73, 60, -1,
572  12, 97, 100, -1, 97, -1, 12, 98, -1, 97,
573  100, -1, 99, 100, -1, 99, 70, 118, 71, -1,
574  99, 73, 60, -1, 65, 66, -1, 65, 101, 66,
575  -1, 116, -1, 101, 69, 116, -1, 98, -1, 99,
576  -1, 102, -1, 102, 44, -1, 102, 45, -1, 103,
577  -1, 19, 104, -1, 18, 104, -1, 27, 104, -1,
578  44, 104, -1, 62, 104, -1, 45, 104, -1, 63,
579  104, -1, 74, 104, -1, 75, 104, -1, 76, 104,
580  -1, 77, 104, -1, 104, -1, 105, 78, 104, -1,
581  105, 64, 104, -1, 105, 79, 104, -1, 105, -1,
582  106, 74, 105, -1, 106, 75, 105, -1, 106, -1,
583  107, 46, 106, -1, 107, 47, 106, -1, 107, 48,
584  106, -1, 107, -1, 108, 80, 107, -1, 108, 81,
585  107, -1, 108, 40, 107, -1, 108, 41, 107, -1,
586  108, 26, 107, -1, 108, 25, 107, -1, 108, -1,
587  109, 36, 108, -1, 109, 37, 108, -1, 109, 38,
588  108, -1, 109, 39, 108, -1, 109, -1, 110, 82,
589  109, -1, 110, -1, 111, 83, 110, -1, 111, -1,
590  112, 84, 111, -1, 112, -1, 113, 43, 112, -1,
591  113, -1, 114, 42, 113, -1, 114, -1, 114, 85,
592  116, 72, 116, -1, 115, -1, 102, 117, 116, -1,
593  86, -1, 49, -1, 50, -1, 51, -1, 52, -1,
594  53, -1, 54, -1, 55, -1, 56, -1, 58, -1,
595  59, -1, 57, -1, 116, -1, 118, 69, 116, -1,
596  120, -1, 122, -1, 125, -1, 129, -1, 130, -1,
597  131, -1, 132, -1, 134, -1, 135, -1, 136, -1,
598  137, -1, 138, -1, 144, -1, 145, -1, 146, -1,
599  147, -1, 67, 68, -1, 67, 156, 68, -1, 119,
600  -1, 121, 119, -1, 13, 123, 87, -1, 13, 123,
601  1, -1, 124, -1, 123, 69, 124, -1, 60, -1,
602  60, 128, -1, 14, 126, 87, -1, 14, 126, 1,
603  -1, 127, -1, 126, 69, 124, -1, 60, -1, 60,
604  128, -1, 86, 116, -1, 87, -1, 118, 87, -1,
605  118, 1, -1, 20, 65, 118, 66, 119, -1, 20,
606  65, 118, 66, 119, 24, 119, -1, 22, 119, 23,
607  65, 118, 66, -1, 23, 65, 118, 66, 119, -1,
608  11, 65, 133, 87, 133, 87, 133, 66, 119, -1,
609  11, 65, 13, 123, 87, 133, 87, 133, 66, 119,
610  -1, 11, 65, 102, 25, 118, 66, 119, -1, 11,
611  65, 13, 60, 25, 118, 66, 119, -1, 11, 65,
612  13, 60, 128, 25, 118, 66, 119, -1, -1, 118,
613  -1, 15, 87, -1, 15, 1, -1, 15, 60, 87,
614  -1, 15, 60, 1, -1, 8, 87, -1, 8, 1,
615  -1, 8, 60, 87, -1, 8, 60, 1, -1, 17,
616  87, -1, 17, 1, -1, 17, 118, 87, -1, 17,
617  118, 1, -1, 29, 65, 118, 66, 119, -1, 28,
618  65, 118, 66, 139, -1, 67, 140, 68, -1, 67,
619  140, 143, 140, 68, -1, -1, 141, -1, 142, -1,
620  141, 142, -1, 9, 118, 72, -1, 9, 118, 72,
621  121, -1, 10, 72, -1, 10, 72, 121, -1, 60,
622  72, 119, -1, 31, 118, 87, -1, 31, 118, 1,
623  -1, 32, 120, 148, -1, 32, 120, 149, -1, 32,
624  120, 148, 149, -1, 35, 87, -1, 35, 1, -1,
625  33, 65, 60, 66, 120, -1, 34, 120, -1, 151,
626  -1, 18, 151, -1, 16, 60, 65, 66, 154, -1,
627  16, 60, 65, 153, 66, 154, -1, 16, 65, 66,
628  154, -1, 16, 65, 153, 66, 154, -1, 16, 61,
629  65, 66, 154, -1, 16, 61, 65, 153, 66, 154,
630  -1, 60, -1, 153, 69, 60, -1, 67, 68, -1,
631  67, 156, 68, -1, -1, 156, -1, 157, -1, 156,
632  157, -1, 119, -1, 150, -1
633 };
634 
635 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
636 static const unsigned short int yyrline[] =
637 {
638  0, 169, 169, 170, 171, 172, 173, 174, 177, 184,
639  185, 186, 187, 188, 189, 190, 191, 195, 196, 197,
640  201, 202, 207, 208, 212, 213, 217, 218, 223, 224,
641  225, 229, 230, 231, 232, 233, 237, 238, 242, 243,
642  244, 245, 249, 250, 254, 255, 259, 260, 264, 265,
643  266, 270, 271, 272, 273, 274, 275, 276, 277, 278,
644  279, 280, 281, 285, 286, 287, 288, 292, 293, 294,
645  298, 299, 300, 301, 305, 306, 308, 310, 312, 314,
646  316, 321, 322, 323, 324, 325, 329, 330, 334, 335,
647  339, 340, 344, 345, 350, 351, 356, 357, 362, 363,
648  368, 369, 370, 371, 372, 373, 374, 375, 376, 377,
649  378, 379, 383, 384, 388, 389, 390, 391, 392, 393,
650  394, 395, 396, 397, 398, 399, 400, 401, 402, 403,
651  407, 408, 412, 413, 417, 419, 429, 430, 435, 436,
652  440, 442, 452, 453, 458, 459, 463, 467, 471, 473,
653  481, 482, 487, 488, 489, 492, 495, 498, 501, 507,
654  508, 512, 513, 517, 518, 525, 526, 530, 531, 539,
655  540, 544, 545, 553, 558, 563, 564, 569, 570, 574,
656  575, 579, 580, 584, 585, 589, 594, 595, 602, 603,
657  604, 608, 609, 618, 623, 627, 629, 633, 634, 639,
658  641, 643, 645, 650, 651, 655, 657, 662, 665, 670,
659  671, 675, 676
660 };
661 #endif
662 
663 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
664 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
665  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
666 static const char *const yytname[] =
667 {
668  "$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN",
669  "STRING", "NUMBER", "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR",
670  "CONST", "CONTINUE", "FUNCTION", "RETURN", "VOID", "DELETE", "IF",
671  "THIS", "DO", "WHILE", "ELSE", "IN", "INSTANCEOF", "TYPEOF", "SWITCH",
672  "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "DEBUGGER",
673  "EQEQ", "NE", "STREQ", "STRNEQ", "LE", "GE", "OR", "AND", "PLUSPLUS",
674  "MINUSMINUS", "LSHIFT", "RSHIFT", "URSHIFT", "PLUSEQUAL", "MINUSEQUAL",
675  "MULTEQUAL", "DIVEQUAL", "LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL",
676  "ANDEQUAL", "MODEQUAL", "XOREQUAL", "OREQUAL", "IDENT", "FUNCEXPRIDENT",
677  "AUTOPLUSPLUS", "AUTOMINUSMINUS", "'/'", "'('", "')'", "'{'", "'}'",
678  "','", "'['", "']'", "':'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'",
679  "'%'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept",
680  "Literal", "PrimaryExpr", "ArrayLiteral", "ElementList", "ElisionOpt",
681  "Elision", "PropertyNameAndValueList", "PropertyName", "MemberExpr",
682  "NewExpr", "CallExpr", "Arguments", "ArgumentList", "LeftHandSideExpr",
683  "PostfixExpr", "UnaryExpr", "MultiplicativeExpr", "AdditiveExpr",
684  "ShiftExpr", "RelationalExpr", "EqualityExpr", "BitwiseANDExpr",
685  "BitwiseXORExpr", "BitwiseORExpr", "LogicalANDExpr", "LogicalORExpr",
686  "ConditionalExpr", "AssignmentExpr", "AssignmentOperator", "Expr",
687  "Statement", "Block", "StatementList", "VariableStatement",
688  "VariableDeclarationList", "VariableDeclaration", "ConstStatement",
689  "ConstDeclarationList", "ConstDeclaration", "Initializer",
690  "EmptyStatement", "ExprStatement", "IfStatement", "IterationStatement",
691  "ExprOpt", "ContinueStatement", "BreakStatement", "ReturnStatement",
692  "WithStatement", "SwitchStatement", "CaseBlock", "CaseClausesOpt",
693  "CaseClauses", "CaseClause", "DefaultClause", "LabelledStatement",
694  "ThrowStatement", "TryStatement", "DebuggerStatement", "Catch",
695  "Finally", "FunctionDeclaration", "FunctionDeclarationInternal",
696  "FunctionExpr", "FormalParameterList", "FunctionBody", "Program",
697  "SourceElements", "SourceElement", 0
698 };
699 #endif
700 
701 # ifdef YYPRINT
702 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
703  token YYLEX-NUM. */
704 static const unsigned short int yytoknum[] =
705 {
706  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
707  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
708  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
709  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
710  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
711  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
712  315, 316, 317, 318, 47, 40, 41, 123, 125, 44,
713  91, 93, 58, 46, 43, 45, 126, 33, 42, 37,
714  60, 62, 38, 94, 124, 63, 61, 59
715 };
716 # endif
717 
718 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
719 static const unsigned char yyr1[] =
720 {
721  0, 88, 89, 89, 89, 89, 89, 89, 89, 90,
722  90, 90, 90, 90, 90, 90, 90, 91, 91, 91,
723  92, 92, 93, 93, 94, 94, 95, 95, 96, 96,
724  96, 97, 97, 97, 97, 97, 98, 98, 99, 99,
725  99, 99, 100, 100, 101, 101, 102, 102, 103, 103,
726  103, 104, 104, 104, 104, 104, 104, 104, 104, 104,
727  104, 104, 104, 105, 105, 105, 105, 106, 106, 106,
728  107, 107, 107, 107, 108, 108, 108, 108, 108, 108,
729  108, 109, 109, 109, 109, 109, 110, 110, 111, 111,
730  112, 112, 113, 113, 114, 114, 115, 115, 116, 116,
731  117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
732  117, 117, 118, 118, 119, 119, 119, 119, 119, 119,
733  119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
734  120, 120, 121, 121, 122, 122, 123, 123, 124, 124,
735  125, 125, 126, 126, 127, 127, 128, 129, 130, 130,
736  131, 131, 132, 132, 132, 132, 132, 132, 132, 133,
737  133, 134, 134, 134, 134, 135, 135, 135, 135, 136,
738  136, 136, 136, 137, 138, 139, 139, 140, 140, 141,
739  141, 142, 142, 143, 143, 144, 145, 145, 146, 146,
740  146, 147, 147, 148, 149, 150, 150, 151, 151, 152,
741  152, 152, 152, 153, 153, 154, 154, 155, 155, 156,
742  156, 157, 157
743 };
744 
745 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
746 static const unsigned char yyr2[] =
747 {
748  0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
749  1, 1, 1, 3, 2, 3, 4, 3, 3, 5,
750  2, 4, 0, 1, 1, 2, 3, 5, 1, 1,
751  1, 1, 1, 4, 3, 3, 1, 2, 2, 2,
752  4, 3, 2, 3, 1, 3, 1, 1, 1, 2,
753  2, 1, 2, 2, 2, 2, 2, 2, 2, 2,
754  2, 2, 2, 1, 3, 3, 3, 1, 3, 3,
755  1, 3, 3, 3, 1, 3, 3, 3, 3, 3,
756  3, 1, 3, 3, 3, 3, 1, 3, 1, 3,
757  1, 3, 1, 3, 1, 3, 1, 5, 1, 3,
758  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
759  1, 1, 1, 3, 1, 1, 1, 1, 1, 1,
760  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
761  2, 3, 1, 2, 3, 3, 1, 3, 1, 2,
762  3, 3, 1, 3, 1, 2, 2, 1, 2, 2,
763  5, 7, 6, 5, 9, 10, 7, 8, 9, 0,
764  1, 2, 2, 3, 3, 2, 2, 3, 3, 2,
765  2, 3, 3, 5, 5, 3, 5, 0, 1, 1,
766  2, 3, 4, 2, 3, 3, 3, 3, 3, 3,
767  4, 2, 2, 5, 2, 1, 2, 5, 6, 4,
768  5, 5, 6, 1, 3, 2, 3, 0, 1, 1,
769  2, 1, 1
770 };
771 
772 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
773  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
774  means the default is an error. */
775 static const unsigned char yydefact[] =
776 {
777  207, 2, 3, 4, 6, 5, 0, 0, 0, 0,
778  0, 0, 0, 0, 0, 0, 0, 9, 0, 0,
779  0, 0, 0, 0, 0, 0, 0, 0, 8, 10,
780  0, 0, 7, 0, 0, 22, 0, 0, 0, 0,
781  147, 11, 31, 12, 36, 46, 47, 48, 51, 63,
782  67, 70, 74, 81, 86, 88, 90, 92, 94, 96,
783  98, 112, 0, 211, 114, 115, 116, 117, 118, 119,
784  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
785  212, 195, 32, 0, 208, 209, 166, 0, 165, 159,
786  0, 10, 0, 36, 37, 138, 0, 136, 144, 0,
787  142, 162, 0, 161, 0, 0, 0, 170, 0, 169,
788  0, 48, 53, 196, 52, 0, 0, 0, 54, 0,
789  0, 0, 0, 0, 192, 191, 55, 57, 0, 56,
790  58, 0, 6, 5, 10, 14, 0, 0, 0, 24,
791  0, 0, 23, 59, 60, 61, 62, 0, 0, 0,
792  38, 0, 0, 39, 49, 50, 101, 102, 103, 104,
793  105, 106, 107, 108, 111, 109, 110, 100, 0, 0,
794  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
795  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
796  0, 0, 0, 149, 0, 148, 1, 210, 168, 167,
797  0, 48, 160, 0, 29, 30, 28, 14, 35, 0,
798  139, 135, 0, 134, 145, 141, 0, 140, 164, 163,
799  0, 0, 203, 0, 0, 172, 171, 0, 0, 0,
800  0, 0, 187, 186, 130, 0, 0, 188, 189, 185,
801  13, 15, 0, 0, 131, 22, 18, 17, 20, 25,
802  42, 0, 44, 0, 34, 0, 41, 99, 65, 64,
803  66, 68, 69, 71, 72, 73, 80, 79, 77, 78,
804  75, 76, 82, 83, 84, 85, 87, 89, 91, 93,
805  95, 0, 113, 138, 0, 0, 159, 146, 137, 143,
806  0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
807  0, 0, 0, 0, 194, 190, 16, 0, 26, 0,
808  43, 0, 33, 40, 0, 0, 139, 159, 0, 0,
809  197, 0, 201, 0, 205, 0, 200, 204, 150, 0,
810  153, 177, 174, 173, 0, 0, 19, 21, 45, 97,
811  0, 0, 0, 0, 159, 198, 202, 206, 0, 152,
812  0, 0, 178, 179, 0, 27, 0, 0, 159, 156,
813  0, 151, 0, 0, 175, 177, 180, 193, 157, 0,
814  0, 0, 181, 183, 0, 158, 0, 154, 132, 182,
815  184, 176, 155, 133
816 };
817 
818 /* YYDEFGOTO[NTERM-NUM]. */
819 static const short int yydefgoto[] =
820 {
821  -1, 41, 42, 43, 140, 141, 142, 136, 137, 44,
822  45, 46, 150, 251, 47, 48, 49, 50, 51, 52,
823  53, 54, 55, 56, 57, 58, 59, 60, 61, 168,
824  62, 63, 64, 379, 65, 96, 97, 66, 99, 100,
825  210, 67, 68, 69, 70, 203, 71, 72, 73, 74,
826  75, 332, 351, 352, 353, 365, 76, 77, 78, 79,
827  237, 238, 80, 81, 82, 224, 295, 83, 138, 85
828 };
829 
830 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
831  STATE-NUM. */
832 #define YYPACT_NINF -271
833 static const short int yypact[] =
834 {
835  824, -271, -271, -271, -271, -271, 5, -12, 118, 15,
836  45, 8, -6, 362, 1320, 1395, 81, -271, 901, 92,
837  1395, 96, 104, 1395, 106, 13, 1395, 1395, -271, -14,
838  1395, 1395, -271, 1395, 439, 111, 1395, 1395, 1395, 1395,
839  -271, -271, -271, -271, -25, -271, 71, 197, -271, -271,
840  -27, 63, 227, 91, 129, 194, 103, 130, 166, -15,
841  -271, -271, 9, -271, -271, -271, -271, -271, -271, -271,
842  -271, -271, -271, -271, -271, -271, -271, -271, -271, -271,
843  -271, -271, -271, 279, 824, -271, -271, 27, -271, 1020,
844  -19, -271, 29, -25, -271, 208, 11, -271, 208, 17,
845  -271, -271, 32, -271, 216, 230, -17, -271, 1395, -271,
846  21, 195, -271, -271, -271, 1395, 274, 1395, -271, 1395,
847  1395, 33, 516, 252, -271, -271, -271, -271, 901, -271,
848  -271, 37, 226, 228, -14, 986, 219, 229, 593, -271,
849  57, 1095, 233, -271, -271, -271, -271, 1170, 1395, 243,
850  -271, 1395, 244, -271, -271, -271, -271, -271, -271, -271,
851  -271, -271, -271, -271, -271, -271, -271, -271, 1395, 1395,
852  1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395,
853  1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395,
854  1395, 1395, 1395, -271, 1395, -271, -271, -271, -271, -271,
855  245, 213, 237, 221, -271, -271, -271, -271, -271, 1395,
856  -271, -271, 15, -271, -271, -271, 15, -271, -271, -271,
857  -10, 3, -271, 246, 49, -271, -271, 76, 247, 90,
858  121, 125, -271, -271, -271, 249, 106, 276, -271, -271,
859  -271, -271, 87, 1395, -271, 111, -271, -271, -271, -271,
860  -271, 126, -271, 141, -271, 174, -271, -271, -271, -271,
861  -271, -27, -27, 63, 63, 63, 227, 227, 227, 227,
862  227, 227, 91, 91, 91, 91, 129, 194, 103, 130,
863  166, 239, -271, 1, -48, 1395, 1395, -271, -271, -271,
864  246, 127, 246, 131, 670, -271, 246, 255, 901, 1395,
865  901, 250, 901, 256, -271, -271, -271, 248, -271, 1245,
866  -271, 1395, -271, -271, 1395, 1395, 293, 1395, 132, 232,
867  -271, 246, -271, 246, -271, 747, -271, -271, 297, 133,
868  -271, 313, -271, -271, 257, 1395, -271, -271, -271, -271,
869  137, 1395, 240, 901, 1395, -271, -271, -271, 901, -271,
870  1395, 31, 313, -271, 106, -271, 901, 138, 1395, -271,
871  258, -271, 139, 254, -271, 313, -271, -271, -271, 901,
872  262, 901, 901, 901, 261, -271, 901, -271, -271, 901,
873  901, -271, -271, -271
874 };
875 
876 /* YYPGOTO[NTERM-NUM]. */
877 static const short int yypgoto[] =
878 {
879  -271, -271, -271, -271, -271, 89, -271, -271, 93, 324,
880  329, -271, -2, -271, 46, -271, -7, 117, 85, -29,
881  -9, 152, 153, 151, 154, 155, -271, -271, -130, -271,
882  -8, -18, -23, -30, -271, 145, -145, -271, -271, -271,
883  -94, -271, -271, -271, -271, -270, -271, -271, -271, -271,
884  -271, -271, -16, -271, -5, -271, -271, -271, -271, -271,
885  -271, 115, -271, 334, -271, 72, -163, -271, 2, -81
886 };
887 
888 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
889  positive, shift that token. If negative, reduce the rule which
890  number is the opposite. If zero, do what YYDEFACT says.
891  If YYTABLE_NINF, syntax error. */
892 #define YYTABLE_NINF -131
893 static const short int yytable[] =
894 {
895  116, 123, 84, 197, 214, 110, 86, 112, 114, 101,
896  193, 248, 211, 118, 124, 121, 319, 252, 215, 126,
897  127, 212, 225, 129, 130, 131, 315, 191, 198, 143,
898  144, 145, 146, 218, 232, 204, 205, 169, 257, 317,
899  147, 363, 105, 222, 153, 148, 106, 342, 149, 223,
900  222, 170, 171, 89, 104, 105, 290, 197, 128, 106,
901  111, 111, 281, 222, 282, 87, 111, 288, 102, 292,
902  192, 289, 111, 111, 360, 95, 111, 111, 194, 287,
903  212, 202, 111, 111, 111, 111, 216, 209, 370, 206,
904  194, 208, 88, 204, 205, 103, 195, 207, 213, 364,
905  125, 112, 194, 240, 217, 98, 194, 227, 226, 229,
906  239, 230, 231, 308, 199, 296, 177, 178, 297, 219,
907  233, 1, 2, 3, 4, 5, 245, 320, 246, 322,
908  8, 179, 180, 326, 90, 201, 147, 172, 173, 17,
909  253, 151, 298, 255, 152, 194, 115, 206, 266, 267,
910  268, 269, 270, 271, 111, 306, 300, 117, 345, 194,
911  346, 119, 258, 259, 260, 183, 184, 185, 186, 120,
912  28, 181, 182, 122, 272, 273, 274, 275, 91, 337,
913  139, 338, 32, 33, 339, 92, 188, 301, 35, 316,
914  194, 302, 310, 321, 194, 311, 297, 323, 343, 349,
915  297, 194, 194, 356, 369, 355, 194, 194, 194, 190,
916  194, 372, 312, 304, 189, 111, 111, 111, 111, 111,
917  111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
918  111, 111, 111, 111, 111, 111, 111, 111, 285, 154,
919  155, 154, 155, 194, 197, 313, 156, 157, 158, 159,
920  160, 161, 162, 163, 164, 165, 166, 154, 155, 263,
921  264, 265, 156, 157, 158, 159, 160, 161, 162, 163,
922  164, 165, 166, 174, 175, 176, 187, 318, 202, 196,
923  328, 220, 330, 167, 333, 235, 236, 241, 242, 261,
924  262, 329, 291, 293, 209, 221, 325, 228, -29, 167,
925  -30, 243, 249, 254, 256, 283, 194, 340, 286, 202,
926  236, 314, 299, 294, 303, 327, 334, 331, 341, 344,
927  335, 348, 350, 354, 371, 359, 373, 358, 376, 381,
928  361, 367, 93, 357, 309, 307, 202, 94, 368, 276,
929  278, 277, 362, 380, 279, 284, 280, 366, 113, 374,
930  202, 375, 305, 377, 378, 378, 0, 0, 382, 0,
931  0, 383, 383, 107, 0, 1, 2, 3, 4, 5,
932  0, 0, 0, 0, 8, 0, 0, 0, 90, 0,
933  108, 15, 0, 17, 0, 0, 0, 0, 0, 20,
934  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
935  0, 0, 0, 0, 0, 0, 26, 27, 0, 0,
936  0, 0, 0, 0, 28, 0, 0, 0, 0, 0,
937  0, 0, 91, 0, 30, 31, 32, 33, 0, 92,
938  0, 0, 35, 0, 0, 0, 36, 37, 38, 39,
939  0, 0, 1, 2, 3, 132, 133, 6, 0, 109,
940  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
941  17, 18, 19, 0, 0, 0, 20, 21, 22, 0,
942  23, 24, 0, 0, 25, 0, 0, 0, 0, 0,
943  0, 0, 0, 26, 27, 0, 0, 0, 0, 0,
944  0, 28, 0, 0, 0, 0, 0, 0, 0, 134,
945  0, 30, 31, 32, 33, 0, 34, 135, 0, 35,
946  0, 0, 0, 36, 37, 38, 39, 0, 0, 1,
947  2, 3, 4, 5, 6, 0, 40, 7, 8, 9,
948  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
949  0, 0, 0, 20, 21, 22, 0, 23, 24, 0,
950  0, 25, 0, 0, 0, 0, 0, 0, 0, 0,
951  26, 27, 0, 0, 0, 0, 0, 0, 28, 0,
952  0, 0, 0, 0, 0, 0, 29, 0, 30, 31,
953  32, 33, 0, 34, 234, 0, 35, 0, 0, 0,
954  36, 37, 38, 39, 0, 0, 1, 2, 3, 4,
955  5, 6, 0, 40, 7, 8, 9, 10, 11, 12,
956  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
957  20, 21, 22, 0, 23, 24, 0, 0, 25, 0,
958  0, 0, 0, 0, 0, 0, 0, 26, 27, 0,
959  0, 0, 0, 0, 0, 28, 0, 0, 0, 0,
960  0, 0, 0, 29, 0, 30, 31, 32, 33, 0,
961  34, 244, 0, 35, 0, 0, 0, 36, 37, 38,
962  39, 0, 0, 1, 2, 3, 4, 5, 6, 0,
963  40, 7, 8, 9, 10, 11, 12, 13, 14, 15,
964  16, 17, 18, 19, 0, 0, 0, 20, 21, 22,
965  0, 23, 24, 0, 0, 25, 0, 0, 0, 0,
966  0, 0, 0, 0, 26, 27, 0, 0, 0, 0,
967  0, 0, 28, 0, 0, 0, 0, 0, 0, 0,
968  29, 0, 30, 31, 32, 33, 0, 34, 324, 0,
969  35, 0, 0, 0, 36, 37, 38, 39, 0, 0,
970  1, 2, 3, 4, 5, 6, 0, 40, 7, 8,
971  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
972  19, 0, 0, 0, 20, 21, 22, 0, 23, 24,
973  0, 0, 25, 0, 0, 0, 0, 0, 0, 0,
974  0, 26, 27, 0, 0, 0, 0, 0, 0, 28,
975  0, 0, 0, 0, 0, 0, 0, 29, 0, 30,
976  31, 32, 33, 0, 34, 347, 0, 35, 0, 0,
977  0, 36, 37, 38, 39, 0, 0, 1, 2, 3,
978  4, 5, 6, 0, 40, 7, 8, 9, 10, 11,
979  12, 13, 14, 15, 16, 17, 18, 19, 0, 0,
980  0, 20, 21, 22, 0, 23, 24, 0, 0, 25,
981  0, 0, 0, 0, 0, 0, 0, 0, 26, 27,
982  0, 0, 0, 0, 0, 0, 28, 0, 0, 0,
983  0, 0, 0, 0, 29, 0, 30, 31, 32, 33,
984  0, 34, 0, 0, 35, 0, 0, 0, 36, 37,
985  38, 39, 0, 0, 1, 2, 3, 4, 5, 6,
986  0, 40, 7, 8, 9, 10, 11, 90, 13, 108,
987  15, 16, 17, 18, 19, 0, 0, 0, 20, 21,
988  22, 0, 23, 24, 0, 0, 25, 0, 0, 0,
989  0, 0, 0, 0, 0, 26, 27, 0, 0, 0,
990  0, 0, 0, 28, 0, 0, 0, 0, 0, 0,
991  0, 29, 0, 30, 31, 32, 33, 0, 34, 0,
992  0, 35, 0, 0, 0, 36, 37, 38, 39, 0,
993  0, 0, 0, 0, 0, 0, -130, 0, 40, -130,
994  -130, -130, -130, -130, -130, -130, -130, -130, -130, -130,
995  -130, -130, -130, -130, -130, -130, -130, -130, -130, -130,
996  -130, 0, 0, -130, -130, -130, 0, -130, -130, 0,
997  0, -130, 0, 1, 2, 3, 4, 5, 0, 0,
998  0, 0, 8, 200, 0, 0, 90, 0, 108, 15,
999  0, 17, 0, 0, 0, 0, -130, 20, -130, -130,
1000  0, 0, 0, -130, -130, 0, 0, 0, 0, 0,
1001  0, 0, -130, -130, 26, 27, 0, 0, 0, 0,
1002  0, 0, 28, 0, 0, 0, 0, 0, 0, 0,
1003  91, 0, 30, 31, 32, 33, 0, 92, 0, 0,
1004  35, 0, 0, 0, 36, 37, 38, 39, 1, 2,
1005  3, 4, 5, 0, 0, 0, 0, 8, 0, 0,
1006  0, 90, 0, 108, 15, 0, 17, 0, 0, 0,
1007  0, 0, 20, 0, 0, 0, 0, 0, 0, 0,
1008  0, 0, 0, 0, 0, 0, 0, 0, 0, 26,
1009  27, 0, 0, 0, 0, 0, 0, 28, 0, 0,
1010  0, 0, 0, 0, 0, 91, 0, 30, 31, 32,
1011  33, 0, 92, 0, 0, 35, 247, 0, 0, 36,
1012  37, 38, 39, 1, 2, 3, 4, 5, 0, 0,
1013  0, 0, 8, 0, 0, 0, 90, 0, 108, 15,
1014  0, 17, 0, 0, 0, 0, 0, 20, 0, 0,
1015  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1016  0, 0, 0, 0, 26, 27, 0, 0, 0, 0,
1017  0, 0, 28, 0, 0, 0, 0, 0, 0, 0,
1018  91, 0, 30, 31, 32, 33, 250, 92, 0, 0,
1019  35, 0, 0, 0, 36, 37, 38, 39, 1, 2,
1020  3, 4, 5, 0, 0, 0, 0, 8, 0, 0,
1021  0, 90, 0, 108, 15, 0, 17, 0, 0, 0,
1022  0, 0, 20, 0, 0, 0, 0, 0, 0, 0,
1023  0, 0, 0, 0, 0, 0, 0, 0, 0, 26,
1024  27, 0, 0, 0, 0, 0, 0, 28, 0, 0,
1025  0, 0, 0, 0, 0, 91, 0, 30, 31, 32,
1026  33, 0, 92, 0, 0, 35, 336, 0, 0, 36,
1027  37, 38, 39, 1, 2, 3, 4, 5, 0, 0,
1028  0, 0, 8, 0, 0, 0, 12, 0, 108, 15,
1029  0, 17, 0, 0, 0, 0, 0, 20, 0, 0,
1030  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1031  0, 0, 0, 0, 26, 27, 0, 0, 0, 0,
1032  0, 0, 28, 0, 0, 0, 0, 0, 0, 0,
1033  91, 0, 30, 31, 32, 33, 0, 92, 0, 0,
1034  35, 0, 0, 0, 36, 37, 38, 39, 1, 2,
1035  3, 4, 5, 0, 0, 0, 0, 8, 0, 0,
1036  0, 90, 0, 108, 15, 0, 17, 0, 0, 0,
1037  0, 0, 20, 0, 0, 0, 0, 0, 0, 0,
1038  0, 0, 0, 0, 0, 0, 0, 0, 0, 26,
1039  27, 0, 0, 0, 0, 0, 0, 28, 0, 0,
1040  0, 0, 0, 0, 0, 91, 0, 30, 31, 32,
1041  33, 0, 92, 0, 0, 35, 0, 0, 0, 36,
1042  37, 38, 39
1043 };
1044 
1045 static const short int yycheck[] =
1046 {
1047  18, 24, 0, 84, 98, 13, 1, 14, 15, 1,
1048  1, 141, 1, 20, 1, 23, 286, 147, 1, 26,
1049  27, 69, 1, 30, 31, 33, 25, 42, 1, 36,
1050  37, 38, 39, 1, 1, 6, 7, 64, 168, 87,
1051  65, 10, 61, 60, 46, 70, 65, 317, 73, 66,
1052  60, 78, 79, 65, 60, 61, 66, 138, 72, 65,
1053  14, 15, 192, 60, 194, 60, 20, 212, 60, 66,
1054  85, 216, 26, 27, 344, 60, 30, 31, 69, 209,
1055  69, 89, 36, 37, 38, 39, 69, 86, 358, 60,
1056  69, 93, 87, 6, 7, 87, 87, 68, 87, 68,
1057  87, 108, 69, 66, 87, 60, 69, 115, 87, 117,
1058  128, 119, 120, 243, 87, 66, 25, 26, 69, 87,
1059  87, 3, 4, 5, 6, 7, 69, 290, 71, 292,
1060  12, 40, 41, 296, 16, 89, 65, 74, 75, 21,
1061  148, 70, 66, 151, 73, 69, 65, 60, 177, 178,
1062  179, 180, 181, 182, 108, 68, 66, 65, 321, 69,
1063  323, 65, 169, 170, 171, 36, 37, 38, 39, 65,
1064  52, 80, 81, 67, 183, 184, 185, 186, 60, 309,
1065  69, 311, 64, 65, 314, 67, 83, 66, 70, 283,
1066  69, 66, 66, 66, 69, 69, 69, 66, 66, 66,
1067  69, 69, 69, 66, 66, 335, 69, 69, 69, 43,
1068  69, 72, 71, 236, 84, 169, 170, 171, 172, 173,
1069  174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
1070  184, 185, 186, 187, 188, 189, 190, 191, 25, 44,
1071  45, 44, 45, 69, 325, 71, 49, 50, 51, 52,
1072  53, 54, 55, 56, 57, 58, 59, 44, 45, 174,
1073  175, 176, 49, 50, 51, 52, 53, 54, 55, 56,
1074  57, 58, 59, 46, 47, 48, 82, 285, 286, 0,
1075  298, 65, 300, 86, 302, 33, 34, 68, 69, 172,
1076  173, 299, 220, 221, 86, 65, 294, 23, 72, 86,
1077  72, 72, 69, 60, 60, 60, 69, 315, 87, 317,
1078  34, 72, 65, 67, 65, 60, 60, 67, 25, 87,
1079  72, 24, 9, 66, 66, 343, 72, 87, 66, 68,
1080  348, 354, 8, 341, 245, 242, 344, 8, 356, 187,
1081  189, 188, 350, 373, 190, 200, 191, 352, 14, 365,
1082  358, 369, 237, 371, 372, 373, -1, -1, 376, -1,
1083  -1, 379, 380, 1, -1, 3, 4, 5, 6, 7,
1084  -1, -1, -1, -1, 12, -1, -1, -1, 16, -1,
1085  18, 19, -1, 21, -1, -1, -1, -1, -1, 27,
1086  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1087  -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
1088  -1, -1, -1, -1, 52, -1, -1, -1, -1, -1,
1089  -1, -1, 60, -1, 62, 63, 64, 65, -1, 67,
1090  -1, -1, 70, -1, -1, -1, 74, 75, 76, 77,
1091  -1, -1, 3, 4, 5, 6, 7, 8, -1, 87,
1092  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1093  21, 22, 23, -1, -1, -1, 27, 28, 29, -1,
1094  31, 32, -1, -1, 35, -1, -1, -1, -1, -1,
1095  -1, -1, -1, 44, 45, -1, -1, -1, -1, -1,
1096  -1, 52, -1, -1, -1, -1, -1, -1, -1, 60,
1097  -1, 62, 63, 64, 65, -1, 67, 68, -1, 70,
1098  -1, -1, -1, 74, 75, 76, 77, -1, -1, 3,
1099  4, 5, 6, 7, 8, -1, 87, 11, 12, 13,
1100  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1101  -1, -1, -1, 27, 28, 29, -1, 31, 32, -1,
1102  -1, 35, -1, -1, -1, -1, -1, -1, -1, -1,
1103  44, 45, -1, -1, -1, -1, -1, -1, 52, -1,
1104  -1, -1, -1, -1, -1, -1, 60, -1, 62, 63,
1105  64, 65, -1, 67, 68, -1, 70, -1, -1, -1,
1106  74, 75, 76, 77, -1, -1, 3, 4, 5, 6,
1107  7, 8, -1, 87, 11, 12, 13, 14, 15, 16,
1108  17, 18, 19, 20, 21, 22, 23, -1, -1, -1,
1109  27, 28, 29, -1, 31, 32, -1, -1, 35, -1,
1110  -1, -1, -1, -1, -1, -1, -1, 44, 45, -1,
1111  -1, -1, -1, -1, -1, 52, -1, -1, -1, -1,
1112  -1, -1, -1, 60, -1, 62, 63, 64, 65, -1,
1113  67, 68, -1, 70, -1, -1, -1, 74, 75, 76,
1114  77, -1, -1, 3, 4, 5, 6, 7, 8, -1,
1115  87, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1116  20, 21, 22, 23, -1, -1, -1, 27, 28, 29,
1117  -1, 31, 32, -1, -1, 35, -1, -1, -1, -1,
1118  -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
1119  -1, -1, 52, -1, -1, -1, -1, -1, -1, -1,
1120  60, -1, 62, 63, 64, 65, -1, 67, 68, -1,
1121  70, -1, -1, -1, 74, 75, 76, 77, -1, -1,
1122  3, 4, 5, 6, 7, 8, -1, 87, 11, 12,
1123  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1124  23, -1, -1, -1, 27, 28, 29, -1, 31, 32,
1125  -1, -1, 35, -1, -1, -1, -1, -1, -1, -1,
1126  -1, 44, 45, -1, -1, -1, -1, -1, -1, 52,
1127  -1, -1, -1, -1, -1, -1, -1, 60, -1, 62,
1128  63, 64, 65, -1, 67, 68, -1, 70, -1, -1,
1129  -1, 74, 75, 76, 77, -1, -1, 3, 4, 5,
1130  6, 7, 8, -1, 87, 11, 12, 13, 14, 15,
1131  16, 17, 18, 19, 20, 21, 22, 23, -1, -1,
1132  -1, 27, 28, 29, -1, 31, 32, -1, -1, 35,
1133  -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
1134  -1, -1, -1, -1, -1, -1, 52, -1, -1, -1,
1135  -1, -1, -1, -1, 60, -1, 62, 63, 64, 65,
1136  -1, 67, -1, -1, 70, -1, -1, -1, 74, 75,
1137  76, 77, -1, -1, 3, 4, 5, 6, 7, 8,
1138  -1, 87, 11, 12, 13, 14, 15, 16, 17, 18,
1139  19, 20, 21, 22, 23, -1, -1, -1, 27, 28,
1140  29, -1, 31, 32, -1, -1, 35, -1, -1, -1,
1141  -1, -1, -1, -1, -1, 44, 45, -1, -1, -1,
1142  -1, -1, -1, 52, -1, -1, -1, -1, -1, -1,
1143  -1, 60, -1, 62, 63, 64, 65, -1, 67, -1,
1144  -1, 70, -1, -1, -1, 74, 75, 76, 77, -1,
1145  -1, -1, -1, -1, -1, -1, 0, -1, 87, 3,
1146  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1147  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1148  24, -1, -1, 27, 28, 29, -1, 31, 32, -1,
1149  -1, 35, -1, 3, 4, 5, 6, 7, -1, -1,
1150  -1, -1, 12, 13, -1, -1, 16, -1, 18, 19,
1151  -1, 21, -1, -1, -1, -1, 60, 27, 62, 63,
1152  -1, -1, -1, 67, 68, -1, -1, -1, -1, -1,
1153  -1, -1, 76, 77, 44, 45, -1, -1, -1, -1,
1154  -1, -1, 52, -1, -1, -1, -1, -1, -1, -1,
1155  60, -1, 62, 63, 64, 65, -1, 67, -1, -1,
1156  70, -1, -1, -1, 74, 75, 76, 77, 3, 4,
1157  5, 6, 7, -1, -1, -1, -1, 12, -1, -1,
1158  -1, 16, -1, 18, 19, -1, 21, -1, -1, -1,
1159  -1, -1, 27, -1, -1, -1, -1, -1, -1, -1,
1160  -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
1161  45, -1, -1, -1, -1, -1, -1, 52, -1, -1,
1162  -1, -1, -1, -1, -1, 60, -1, 62, 63, 64,
1163  65, -1, 67, -1, -1, 70, 71, -1, -1, 74,
1164  75, 76, 77, 3, 4, 5, 6, 7, -1, -1,
1165  -1, -1, 12, -1, -1, -1, 16, -1, 18, 19,
1166  -1, 21, -1, -1, -1, -1, -1, 27, -1, -1,
1167  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1168  -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
1169  -1, -1, 52, -1, -1, -1, -1, -1, -1, -1,
1170  60, -1, 62, 63, 64, 65, 66, 67, -1, -1,
1171  70, -1, -1, -1, 74, 75, 76, 77, 3, 4,
1172  5, 6, 7, -1, -1, -1, -1, 12, -1, -1,
1173  -1, 16, -1, 18, 19, -1, 21, -1, -1, -1,
1174  -1, -1, 27, -1, -1, -1, -1, -1, -1, -1,
1175  -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
1176  45, -1, -1, -1, -1, -1, -1, 52, -1, -1,
1177  -1, -1, -1, -1, -1, 60, -1, 62, 63, 64,
1178  65, -1, 67, -1, -1, 70, 71, -1, -1, 74,
1179  75, 76, 77, 3, 4, 5, 6, 7, -1, -1,
1180  -1, -1, 12, -1, -1, -1, 16, -1, 18, 19,
1181  -1, 21, -1, -1, -1, -1, -1, 27, -1, -1,
1182  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1183  -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
1184  -1, -1, 52, -1, -1, -1, -1, -1, -1, -1,
1185  60, -1, 62, 63, 64, 65, -1, 67, -1, -1,
1186  70, -1, -1, -1, 74, 75, 76, 77, 3, 4,
1187  5, 6, 7, -1, -1, -1, -1, 12, -1, -1,
1188  -1, 16, -1, 18, 19, -1, 21, -1, -1, -1,
1189  -1, -1, 27, -1, -1, -1, -1, -1, -1, -1,
1190  -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
1191  45, -1, -1, -1, -1, -1, -1, 52, -1, -1,
1192  -1, -1, -1, -1, -1, 60, -1, 62, 63, 64,
1193  65, -1, 67, -1, -1, 70, -1, -1, -1, 74,
1194  75, 76, 77
1195 };
1196 
1197 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1198  symbol of state STATE-NUM. */
1199 static const unsigned char yystos[] =
1200 {
1201  0, 3, 4, 5, 6, 7, 8, 11, 12, 13,
1202  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1203  27, 28, 29, 31, 32, 35, 44, 45, 52, 60,
1204  62, 63, 64, 65, 67, 70, 74, 75, 76, 77,
1205  87, 89, 90, 91, 97, 98, 99, 102, 103, 104,
1206  105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1207  115, 116, 118, 119, 120, 122, 125, 129, 130, 131,
1208  132, 134, 135, 136, 137, 138, 144, 145, 146, 147,
1209  150, 151, 152, 155, 156, 157, 1, 60, 87, 65,
1210  16, 60, 67, 97, 98, 60, 123, 124, 60, 126,
1211  127, 1, 60, 87, 60, 61, 65, 1, 18, 87,
1212  118, 102, 104, 151, 104, 65, 119, 65, 104, 65,
1213  65, 118, 67, 120, 1, 87, 104, 104, 72, 104,
1214  104, 118, 6, 7, 60, 68, 95, 96, 156, 69,
1215  92, 93, 94, 104, 104, 104, 104, 65, 70, 73,
1216  100, 70, 73, 100, 44, 45, 49, 50, 51, 52,
1217  53, 54, 55, 56, 57, 58, 59, 86, 117, 64,
1218  78, 79, 74, 75, 46, 47, 48, 25, 26, 40,
1219  41, 80, 81, 36, 37, 38, 39, 82, 83, 84,
1220  43, 42, 85, 1, 69, 87, 0, 157, 1, 87,
1221  13, 102, 118, 133, 6, 7, 60, 68, 100, 86,
1222  128, 1, 69, 87, 128, 1, 69, 87, 1, 87,
1223  65, 65, 60, 66, 153, 1, 87, 118, 23, 118,
1224  118, 118, 1, 87, 68, 33, 34, 148, 149, 119,
1225  66, 68, 69, 72, 68, 69, 71, 71, 116, 69,
1226  66, 101, 116, 118, 60, 118, 60, 116, 104, 104,
1227  104, 105, 105, 106, 106, 106, 107, 107, 107, 107,
1228  107, 107, 108, 108, 108, 108, 109, 110, 111, 112,
1229  113, 116, 116, 60, 123, 25, 87, 116, 124, 124,
1230  66, 153, 66, 153, 67, 154, 66, 69, 66, 65,
1231  66, 66, 66, 65, 120, 149, 68, 96, 116, 93,
1232  66, 69, 71, 71, 72, 25, 128, 87, 118, 133,
1233  154, 66, 154, 66, 68, 156, 154, 60, 119, 118,
1234  119, 67, 139, 119, 60, 72, 71, 116, 116, 116,
1235  118, 25, 133, 66, 87, 154, 154, 68, 24, 66,
1236  9, 140, 141, 142, 66, 116, 66, 118, 87, 119,
1237  133, 119, 118, 10, 68, 143, 142, 120, 119, 66,
1238  133, 66, 72, 72, 140, 119, 66, 119, 119, 121,
1239  121, 68, 119, 119
1240 };
1241 
1242 #define yyerrok (yyerrstatus = 0)
1243 #define yyclearin (yychar = YYEMPTY)
1244 #define YYEMPTY (-2)
1245 #define YYEOF 0
1246 
1247 #define YYACCEPT goto yyacceptlab
1248 #define YYABORT goto yyabortlab
1249 #define YYERROR goto yyerrorlab
1250 
1251 
1252 /* Like YYERROR except do call yyerror. This remains here temporarily
1253  to ease the transition to the new meaning of YYERROR, for GCC.
1254  Once GCC version 2 has supplanted version 1, this can go. */
1255 
1256 #define YYFAIL goto yyerrlab
1257 
1258 #define YYRECOVERING() (!!yyerrstatus)
1259 
1260 #define YYBACKUP(Token, Value) \
1261 do \
1262  if (yychar == YYEMPTY && yylen == 1) \
1263  { \
1264  yychar = (Token); \
1265  yylval = (Value); \
1266  yytoken = YYTRANSLATE (yychar); \
1267  YYPOPSTACK; \
1268  goto yybackup; \
1269  } \
1270  else \
1271  { \
1272  yyerror (YY_("syntax error: cannot back up")); \
1273  YYERROR; \
1274  } \
1275 while (0)
1276 
1277 
1278 #define YYTERROR 1
1279 #define YYERRCODE 256
1280 
1281 
1282 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1283  If N is 0, then set CURRENT to the empty location which ends
1284  the previous symbol: RHS[0] (always defined). */
1285 
1286 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1287 #ifndef YYLLOC_DEFAULT
1288 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1289  do \
1290  if (N) \
1291  { \
1292  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1293  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1294  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1295  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1296  } \
1297  else \
1298  { \
1299  (Current).first_line = (Current).last_line = \
1300  YYRHSLOC (Rhs, 0).last_line; \
1301  (Current).first_column = (Current).last_column = \
1302  YYRHSLOC (Rhs, 0).last_column; \
1303  } \
1304  while (0)
1305 #endif
1306 
1307 
1308 /* YY_LOCATION_PRINT -- Print the location on the stream.
1309  This macro was not mandated originally: define only if we know
1310  we won't break user code: when these are the locations we know. */
1311 
1312 #ifndef YY_LOCATION_PRINT
1313 # if YYLTYPE_IS_TRIVIAL
1314 # define YY_LOCATION_PRINT(File, Loc) \
1315  fprintf (File, "%d.%d-%d.%d", \
1316  (Loc).first_line, (Loc).first_column, \
1317  (Loc).last_line, (Loc).last_column)
1318 # else
1319 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1320 # endif
1321 #endif
1322 
1323 
1324 /* YYLEX -- calling `yylex' with the right arguments. */
1325 
1326 #ifdef YYLEX_PARAM
1327 # define YYLEX yylex (YYLEX_PARAM)
1328 #else
1329 # define YYLEX yylex ()
1330 #endif
1331 
1332 /* Enable debugging if requested. */
1333 #if YYDEBUG
1334 
1335 # ifndef YYFPRINTF
1336 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1337 # define YYFPRINTF fprintf
1338 # endif
1339 
1340 # define YYDPRINTF(Args) \
1341 do { \
1342  if (yydebug) \
1343  YYFPRINTF Args; \
1344 } while (0)
1345 
1346 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1347 do { \
1348  if (yydebug) \
1349  { \
1350  YYFPRINTF (stderr, "%s ", Title); \
1351  yysymprint (stderr, \
1352  Type, Value, Location); \
1353  YYFPRINTF (stderr, "\n"); \
1354  } \
1355 } while (0)
1356 
1357 /*------------------------------------------------------------------.
1358 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1359 | TOP (included). |
1360 `------------------------------------------------------------------*/
1361 
1362 #if defined (__STDC__) || defined (__cplusplus)
1363 static void
1364 yy_stack_print (short int *bottom, short int *top)
1365 #else
1366 static void
1367 yy_stack_print (bottom, top)
1368  short int *bottom;
1369  short int *top;
1370 #endif
1371 {
1372  YYFPRINTF (stderr, "Stack now");
1373  for (/* Nothing. */; bottom <= top; ++bottom)
1374  YYFPRINTF (stderr, " %d", *bottom);
1375  YYFPRINTF (stderr, "\n");
1376 }
1377 
1378 # define YY_STACK_PRINT(Bottom, Top) \
1379 do { \
1380  if (yydebug) \
1381  yy_stack_print ((Bottom), (Top)); \
1382 } while (0)
1383 
1384 
1385 /*------------------------------------------------.
1386 | Report that the YYRULE is going to be reduced. |
1387 `------------------------------------------------*/
1388 
1389 #if defined (__STDC__) || defined (__cplusplus)
1390 static void
1391 yy_reduce_print (int yyrule)
1392 #else
1393 static void
1394 yy_reduce_print (yyrule)
1395  int yyrule;
1396 #endif
1397 {
1398  int yyi;
1399  unsigned long int yylno = yyrline[yyrule];
1400  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
1401  yyrule - 1, yylno);
1402  /* Print the symbols being reduced, and their result. */
1403  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1404  YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1405  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
1406 }
1407 
1408 # define YY_REDUCE_PRINT(Rule) \
1409 do { \
1410  if (yydebug) \
1411  yy_reduce_print (Rule); \
1412 } while (0)
1413 
1414 /* Nonzero means print parse trace. It is left uninitialized so that
1415  multiple parsers can coexist. */
1416 int yydebug;
1417 #else /* !YYDEBUG */
1418 # define YYDPRINTF(Args)
1419 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1420 # define YY_STACK_PRINT(Bottom, Top)
1421 # define YY_REDUCE_PRINT(Rule)
1422 #endif /* !YYDEBUG */
1423 
1424 
1425 /* YYINITDEPTH -- initial size of the parser's stacks. */
1426 #ifndef YYINITDEPTH
1427 # define YYINITDEPTH 200
1428 #endif
1429 
1430 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1431  if the built-in stack extension method is used).
1432 
1433  Do not make this value too large; the results are undefined if
1434  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1435  evaluated with infinite-precision integer arithmetic. */
1436 
1437 #ifndef YYMAXDEPTH
1438 # define YYMAXDEPTH 10000
1439 #endif
1440 
1441 
1442 
1443 #if YYERROR_VERBOSE
1444 
1445 # ifndef yystrlen
1446 # if defined (__GLIBC__) && defined (_STRING_H)
1447 # define yystrlen strlen
1448 # else
1449 /* Return the length of YYSTR. */
1450 static YYSIZE_T
1451 # if defined (__STDC__) || defined (__cplusplus)
1452 yystrlen (const char *yystr)
1453 # else
1454 yystrlen (yystr)
1455  const char *yystr;
1456 # endif
1457 {
1458  const char *yys = yystr;
1459 
1460  while (*yys++ != '\0')
1461  continue;
1462 
1463  return yys - yystr - 1;
1464 }
1465 # endif
1466 # endif
1467 
1468 # ifndef yystpcpy
1469 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1470 # define yystpcpy stpcpy
1471 # else
1472 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1473  YYDEST. */
1474 static char *
1475 # if defined (__STDC__) || defined (__cplusplus)
1476 yystpcpy (char *yydest, const char *yysrc)
1477 # else
1478 yystpcpy (yydest, yysrc)
1479  char *yydest;
1480  const char *yysrc;
1481 # endif
1482 {
1483  char *yyd = yydest;
1484  const char *yys = yysrc;
1485 
1486  while ((*yyd++ = *yys++) != '\0')
1487  continue;
1488 
1489  return yyd - 1;
1490 }
1491 # endif
1492 # endif
1493 
1494 # ifndef yytnamerr
1495 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1496  quotes and backslashes, so that it's suitable for yyerror. The
1497  heuristic is that double-quoting is unnecessary unless the string
1498  contains an apostrophe, a comma, or backslash (other than
1499  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1500  null, do not copy; instead, return the length of what the result
1501  would have been. */
1502 static YYSIZE_T
1503 yytnamerr (char *yyres, const char *yystr)
1504 {
1505  if (*yystr == '"')
1506  {
1507  size_t yyn = 0;
1508  char const *yyp = yystr;
1509 
1510  for (;;)
1511  switch (*++yyp)
1512  {
1513  case '\'':
1514  case ',':
1515  goto do_not_strip_quotes;
1516 
1517  case '\\':
1518  if (*++yyp != '\\')
1519  goto do_not_strip_quotes;
1520  /* Fall through. */
1521  default:
1522  if (yyres)
1523  yyres[yyn] = *yyp;
1524  yyn++;
1525  break;
1526 
1527  case '"':
1528  if (yyres)
1529  yyres[yyn] = '\0';
1530  return yyn;
1531  }
1532  do_not_strip_quotes: ;
1533  }
1534 
1535  if (! yyres)
1536  return yystrlen (yystr);
1537 
1538  return yystpcpy (yyres, yystr) - yyres;
1539 }
1540 # endif
1541 
1542 #endif /* YYERROR_VERBOSE */
1543 
1544 
1545 
1546 #if YYDEBUG
1547 /*--------------------------------.
1548 | Print this symbol on YYOUTPUT. |
1549 `--------------------------------*/
1550 
1551 #if defined (__STDC__) || defined (__cplusplus)
1552 static void
1553 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1554 #else
1555 static void
1556 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
1557  FILE *yyoutput;
1558  int yytype;
1559  YYSTYPE *yyvaluep;
1560  YYLTYPE *yylocationp;
1561 #endif
1562 {
1563  /* Pacify ``unused variable'' warnings. */
1564  (void) yyvaluep;
1565  (void) yylocationp;
1566 
1567  if (yytype < YYNTOKENS)
1568  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1569  else
1570  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1571 
1572  YY_LOCATION_PRINT (yyoutput, *yylocationp);
1573  YYFPRINTF (yyoutput, ": ");
1574 
1575 # ifdef YYPRINT
1576  if (yytype < YYNTOKENS)
1577  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1578 # endif
1579  switch (yytype)
1580  {
1581  default:
1582  break;
1583  }
1584  YYFPRINTF (yyoutput, ")");
1585 }
1586 
1587 #endif /* ! YYDEBUG */
1588 /*-----------------------------------------------.
1589 | Release the memory associated to this symbol. |
1590 `-----------------------------------------------*/
1591 
1592 #if defined (__STDC__) || defined (__cplusplus)
1593 static void
1594 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1595 #else
1596 static void
1597 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1598  const char *yymsg;
1599  int yytype;
1600  YYSTYPE *yyvaluep;
1601  YYLTYPE *yylocationp;
1602 #endif
1603 {
1604  /* Pacify ``unused variable'' warnings. */
1605  (void) yyvaluep;
1606  (void) yylocationp;
1607 
1608  if (!yymsg)
1609  yymsg = "Deleting";
1610  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1611 
1612  switch (yytype)
1613  {
1614 
1615  default:
1616  break;
1617  }
1618 }
1619 
1620 
1621 /* Prevent warnings from -Wmissing-prototypes. */
1622 
1623 #ifdef YYPARSE_PARAM
1624 # if defined (__STDC__) || defined (__cplusplus)
1625 int yyparse (void *YYPARSE_PARAM);
1626 # else
1627 int yyparse ();
1628 # endif
1629 #else /* ! YYPARSE_PARAM */
1630 #if defined (__STDC__) || defined (__cplusplus)
1631 int yyparse (void);
1632 #else
1633 int yyparse ();
1634 #endif
1635 #endif /* ! YYPARSE_PARAM */
1636 
1637 
1638 
1639 /* The look-ahead symbol. */
1640 int yychar;
1641 
1642 /* The semantic value of the look-ahead symbol. */
1643 YYSTYPE yylval;
1644 
1645 /* Number of syntax errors so far. */
1646 int yynerrs;
1647 /* Location data for the look-ahead symbol. */
1648 YYLTYPE yylloc;
1649 
1650 
1651 
1652 /*----------.
1653 | yyparse. |
1654 `----------*/
1655 
1656 #ifdef YYPARSE_PARAM
1657 # if defined (__STDC__) || defined (__cplusplus)
1658 int yyparse (void *YYPARSE_PARAM)
1659 # else
1660 int yyparse (YYPARSE_PARAM)
1661  void *YYPARSE_PARAM;
1662 # endif
1663 #else /* ! YYPARSE_PARAM */
1664 #if defined (__STDC__) || defined (__cplusplus)
1665 int
1666 yyparse (void)
1667 #else
1668 int
1669 yyparse ()
1670  ;
1671 #endif
1672 #endif
1673 {
1674 
1675  int yystate;
1676  int yyn;
1677  int yyresult;
1678  /* Number of tokens to shift before error messages enabled. */
1679  int yyerrstatus;
1680  /* Look-ahead token as an internal (translated) token number. */
1681  int yytoken = 0;
1682 
1683  /* Three stacks and their tools:
1684  `yyss': related to states,
1685  `yyvs': related to semantic values,
1686  `yyls': related to locations.
1687 
1688  Refer to the stacks thru separate pointers, to allow yyoverflow
1689  to reallocate them elsewhere. */
1690 
1691  /* The state stack. */
1692  short int yyssa[YYINITDEPTH];
1693  short int *yyss = yyssa;
1694  short int *yyssp;
1695 
1696  /* The semantic value stack. */
1697  YYSTYPE yyvsa[YYINITDEPTH];
1698  YYSTYPE *yyvs = yyvsa;
1699  YYSTYPE *yyvsp;
1700 
1701  /* The location stack. */
1702  YYLTYPE yylsa[YYINITDEPTH];
1703  YYLTYPE *yyls = yylsa;
1704  YYLTYPE *yylsp;
1705  /* The locations where the error started and ended. */
1706  YYLTYPE yyerror_range[2];
1707 
1708 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
1709 
1710  YYSIZE_T yystacksize = YYINITDEPTH;
1711 
1712  /* The variables used to return semantic value and location from the
1713  action routines. */
1714  YYSTYPE yyval;
1715  YYLTYPE yyloc;
1716 
1717  /* When reducing, the number of symbols on the RHS of the reduced
1718  rule. */
1719  int yylen;
1720 
1721  YYDPRINTF ((stderr, "Starting parse\n"));
1722 
1723  yystate = 0;
1724  yyerrstatus = 0;
1725  yynerrs = 0;
1726  yychar = YYEMPTY; /* Cause a token to be read. */
1727 
1728  /* Initialize stack pointers.
1729  Waste one element of value and location stack
1730  so that they stay on the same level as the state stack.
1731  The wasted elements are never initialized. */
1732 
1733  yyssp = yyss;
1734  yyvsp = yyvs;
1735  yylsp = yyls;
1736 #if YYLTYPE_IS_TRIVIAL
1737  /* Initialize the default location before parsing starts. */
1738  yylloc.first_line = yylloc.last_line = 1;
1739  yylloc.first_column = yylloc.last_column = 0;
1740 #endif
1741 
1742  goto yysetstate;
1743 
1744 /*------------------------------------------------------------.
1745 | yynewstate -- Push a new state, which is found in yystate. |
1746 `------------------------------------------------------------*/
1747  yynewstate:
1748  /* In all cases, when you get here, the value and location stacks
1749  have just been pushed. so pushing a state here evens the stacks.
1750  */
1751  yyssp++;
1752 
1753  yysetstate:
1754  *yyssp = yystate;
1755 
1756  if (yyss + yystacksize - 1 <= yyssp)
1757  {
1758  /* Get the current used size of the three stacks, in elements. */
1759  YYSIZE_T yysize = yyssp - yyss + 1;
1760 
1761 #ifdef yyoverflow
1762  {
1763  /* Give user a chance to reallocate the stack. Use copies of
1764  these so that the &'s don't force the real ones into
1765  memory. */
1766  YYSTYPE *yyvs1 = yyvs;
1767  short int *yyss1 = yyss;
1768  YYLTYPE *yyls1 = yyls;
1769 
1770  /* Each stack pointer address is followed by the size of the
1771  data in use in that stack, in bytes. This used to be a
1772  conditional around just the two extra args, but that might
1773  be undefined if yyoverflow is a macro. */
1774  yyoverflow (YY_("memory exhausted"),
1775  &yyss1, yysize * sizeof (*yyssp),
1776  &yyvs1, yysize * sizeof (*yyvsp),
1777  &yyls1, yysize * sizeof (*yylsp),
1778  &yystacksize);
1779  yyls = yyls1;
1780  yyss = yyss1;
1781  yyvs = yyvs1;
1782  }
1783 #else /* no yyoverflow */
1784 # ifndef YYSTACK_RELOCATE
1785  goto yyexhaustedlab;
1786 # else
1787  /* Extend the stack our own way. */
1788  if (YYMAXDEPTH <= yystacksize)
1789  goto yyexhaustedlab;
1790  yystacksize *= 2;
1791  if (YYMAXDEPTH < yystacksize)
1792  yystacksize = YYMAXDEPTH;
1793 
1794  {
1795  short int *yyss1 = yyss;
1796  union yyalloc *yyptr =
1797  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1798  if (! yyptr)
1799  goto yyexhaustedlab;
1800  YYSTACK_RELOCATE (yyss);
1801  YYSTACK_RELOCATE (yyvs);
1802  YYSTACK_RELOCATE (yyls);
1803 # undef YYSTACK_RELOCATE
1804  if (yyss1 != yyssa)
1805  YYSTACK_FREE (yyss1);
1806  }
1807 # endif
1808 #endif /* no yyoverflow */
1809 
1810  yyssp = yyss + yysize - 1;
1811  yyvsp = yyvs + yysize - 1;
1812  yylsp = yyls + yysize - 1;
1813 
1814  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1815  (unsigned long int) yystacksize));
1816 
1817  if (yyss + yystacksize - 1 <= yyssp)
1818  YYABORT;
1819  }
1820 
1821  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1822 
1823  goto yybackup;
1824 
1825 /*-----------.
1826 | yybackup. |
1827 `-----------*/
1828 yybackup:
1829 
1830 /* Do appropriate processing given the current state. */
1831 /* Read a look-ahead token if we need one and don't already have one. */
1832 /* yyresume: */
1833 
1834  /* First try to decide what to do without reference to look-ahead token. */
1835 
1836  yyn = yypact[yystate];
1837  if (yyn == YYPACT_NINF)
1838  goto yydefault;
1839 
1840  /* Not known => get a look-ahead token if don't already have one. */
1841 
1842  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1843  if (yychar == YYEMPTY)
1844  {
1845  YYDPRINTF ((stderr, "Reading a token: "));
1846  yychar = YYLEX;
1847  }
1848 
1849  if (yychar <= YYEOF)
1850  {
1851  yychar = yytoken = YYEOF;
1852  YYDPRINTF ((stderr, "Now at end of input.\n"));
1853  }
1854  else
1855  {
1856  yytoken = YYTRANSLATE (yychar);
1857  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1858  }
1859 
1860  /* If the proper action on seeing token YYTOKEN is to reduce or to
1861  detect an error, take that action. */
1862  yyn += yytoken;
1863  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1864  goto yydefault;
1865  yyn = yytable[yyn];
1866  if (yyn <= 0)
1867  {
1868  if (yyn == 0 || yyn == YYTABLE_NINF)
1869  goto yyerrlab;
1870  yyn = -yyn;
1871  goto yyreduce;
1872  }
1873 
1874  if (yyn == YYFINAL)
1875  YYACCEPT;
1876 
1877  /* Shift the look-ahead token. */
1878  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1879 
1880  /* Discard the token being shifted unless it is eof. */
1881  if (yychar != YYEOF)
1882  yychar = YYEMPTY;
1883 
1884  *++yyvsp = yylval;
1885  *++yylsp = yylloc;
1886 
1887  /* Count tokens shifted since error; after three, turn off error
1888  status. */
1889  if (yyerrstatus)
1890  yyerrstatus--;
1891 
1892  yystate = yyn;
1893  goto yynewstate;
1894 
1895 
1896 /*-----------------------------------------------------------.
1897 | yydefault -- do the default action for the current state. |
1898 `-----------------------------------------------------------*/
1899 yydefault:
1900  yyn = yydefact[yystate];
1901  if (yyn == 0)
1902  goto yyerrlab;
1903  goto yyreduce;
1904 
1905 
1906 /*-----------------------------.
1907 | yyreduce -- Do a reduction. |
1908 `-----------------------------*/
1909 yyreduce:
1910  /* yyn is the number of a rule to reduce with. */
1911  yylen = yyr2[yyn];
1912 
1913  /* If YYLEN is nonzero, implement the default value of the action:
1914  `$$ = $1'.
1915 
1916  Otherwise, the following line sets YYVAL to garbage.
1917  This behavior is undocumented and Bison
1918  users should not rely upon it. Assigning to YYVAL
1919  unconditionally makes the parser a bit smaller, and it avoids a
1920  GCC warning that YYVAL may be used uninitialized. */
1921  yyval = yyvsp[1-yylen];
1922 
1923  /* Default location. */
1924  YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
1925  YY_REDUCE_PRINT (yyn);
1926  switch (yyn)
1927  {
1928  case 2:
1929 #line 169 "grammar.y"
1930  { (yyval.node) = new NullNode(); ;}
1931  break;
1932 
1933  case 3:
1934 #line 170 "grammar.y"
1935  { (yyval.node) = new BooleanNode(true); ;}
1936  break;
1937 
1938  case 4:
1939 #line 171 "grammar.y"
1940  { (yyval.node) = new BooleanNode(false); ;}
1941  break;
1942 
1943  case 5:
1944 #line 172 "grammar.y"
1945  { (yyval.node) = new NumberNode((yyvsp[0].dval)); ;}
1946  break;
1947 
1948  case 6:
1949 #line 173 "grammar.y"
1950  { (yyval.node) = new StringNode((yyvsp[0].ustr)); ;}
1951  break;
1952 
1953  case 7:
1954 #line 174 "grammar.y"
1955  { Lexer *l = Lexer::curr();
1956  if (!l->scanRegExp()) YYABORT;
1957  (yyval.node) = new RegExpNode(l->pattern,l->flags);;}
1958  break;
1959 
1960  case 8:
1961 #line 178 "grammar.y"
1962  { Lexer *l = Lexer::curr();
1963  if (!l->scanRegExp()) YYABORT;
1964  (yyval.node) = new RegExpNode(UString('=')+l->pattern,l->flags);;}
1965  break;
1966 
1967  case 9:
1968 #line 184 "grammar.y"
1969  { (yyval.node) = new ThisNode(); ;}
1970  break;
1971 
1972  case 10:
1973 #line 185 "grammar.y"
1974  { (yyval.node) = new ResolveNode(*(yyvsp[0].ident)); ;}
1975  break;
1976 
1977  case 13:
1978 #line 188 "grammar.y"
1979  { (yyval.node) = new GroupNode((yyvsp[-1].node)); ;}
1980  break;
1981 
1982  case 14:
1983 #line 189 "grammar.y"
1984  { (yyval.node) = new ObjectLiteralNode(); ;}
1985  break;
1986 
1987  case 15:
1988 #line 190 "grammar.y"
1989  { (yyval.node) = new ObjectLiteralNode((yyvsp[-1].plist)); ;}
1990  break;
1991 
1992  case 16:
1993 #line 191 "grammar.y"
1994  { (yyval.node) = new ObjectLiteralNode((yyvsp[-2].plist)); ;}
1995  break;
1996 
1997  case 17:
1998 #line 195 "grammar.y"
1999  { (yyval.node) = new ArrayNode((yyvsp[-1].ival)); ;}
2000  break;
2001 
2002  case 18:
2003 #line 196 "grammar.y"
2004  { (yyval.node) = new ArrayNode((yyvsp[-1].elm)); ;}
2005  break;
2006 
2007  case 19:
2008 #line 197 "grammar.y"
2009  { (yyval.node) = new ArrayNode((yyvsp[-1].ival), (yyvsp[-3].elm)); ;}
2010  break;
2011 
2012  case 20:
2013 #line 201 "grammar.y"
2014  { (yyval.elm) = new ElementNode((yyvsp[-1].ival), (yyvsp[0].node)); ;}
2015  break;
2016 
2017  case 21:
2018 #line 203 "grammar.y"
2019  { (yyval.elm) = new ElementNode((yyvsp[-3].elm), (yyvsp[-1].ival), (yyvsp[0].node)); ;}
2020  break;
2021 
2022  case 22:
2023 #line 207 "grammar.y"
2024  { (yyval.ival) = 0; ;}
2025  break;
2026 
2027  case 24:
2028 #line 212 "grammar.y"
2029  { (yyval.ival) = 1; ;}
2030  break;
2031 
2032  case 25:
2033 #line 213 "grammar.y"
2034  { (yyval.ival) = (yyvsp[-1].ival) + 1; ;}
2035  break;
2036 
2037  case 26:
2038 #line 217 "grammar.y"
2039  { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node)); ;}
2040  break;
2041 
2042  case 27:
2043 #line 219 "grammar.y"
2044  { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node), (yyvsp[-4].plist)); ;}
2045  break;
2046 
2047  case 28:
2048 #line 223 "grammar.y"
2049  { (yyval.pnode) = new PropertyNode(*(yyvsp[0].ident)); ;}
2050  break;
2051 
2052  case 29:
2053 #line 224 "grammar.y"
2054  { (yyval.pnode) = new PropertyNode(Identifier(*(yyvsp[0].ustr))); ;}
2055  break;
2056 
2057  case 30:
2058 #line 225 "grammar.y"
2059  { (yyval.pnode) = new PropertyNode((yyvsp[0].dval)); ;}
2060  break;
2061 
2062  case 33:
2063 #line 231 "grammar.y"
2064  { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
2065  break;
2066 
2067  case 34:
2068 #line 232 "grammar.y"
2069  { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
2070  break;
2071 
2072  case 35:
2073 #line 233 "grammar.y"
2074  { (yyval.node) = new NewExprNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2075  break;
2076 
2077  case 37:
2078 #line 238 "grammar.y"
2079  { (yyval.node) = new NewExprNode((yyvsp[0].node)); ;}
2080  break;
2081 
2082  case 38:
2083 #line 242 "grammar.y"
2084  { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2085  break;
2086 
2087  case 39:
2088 #line 243 "grammar.y"
2089  { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2090  break;
2091 
2092  case 40:
2093 #line 244 "grammar.y"
2094  { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
2095  break;
2096 
2097  case 41:
2098 #line 245 "grammar.y"
2099  { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
2100  break;
2101 
2102  case 42:
2103 #line 249 "grammar.y"
2104  { (yyval.args) = new ArgumentsNode(); ;}
2105  break;
2106 
2107  case 43:
2108 #line 250 "grammar.y"
2109  { (yyval.args) = new ArgumentsNode((yyvsp[-1].alist)); ;}
2110  break;
2111 
2112  case 44:
2113 #line 254 "grammar.y"
2114  { (yyval.alist) = new ArgumentListNode((yyvsp[0].node)); ;}
2115  break;
2116 
2117  case 45:
2118 #line 255 "grammar.y"
2119  { (yyval.alist) = new ArgumentListNode((yyvsp[-2].alist), (yyvsp[0].node)); ;}
2120  break;
2121 
2122  case 49:
2123 #line 265 "grammar.y"
2124  { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpPlusPlus); ;}
2125  break;
2126 
2127  case 50:
2128 #line 266 "grammar.y"
2129  { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpMinusMinus); ;}
2130  break;
2131 
2132  case 52:
2133 #line 271 "grammar.y"
2134  { (yyval.node) = new DeleteNode((yyvsp[0].node)); ;}
2135  break;
2136 
2137  case 53:
2138 #line 272 "grammar.y"
2139  { (yyval.node) = new VoidNode((yyvsp[0].node)); ;}
2140  break;
2141 
2142  case 54:
2143 #line 273 "grammar.y"
2144  { (yyval.node) = new TypeOfNode((yyvsp[0].node)); ;}
2145  break;
2146 
2147  case 55:
2148 #line 274 "grammar.y"
2149  { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
2150  break;
2151 
2152  case 56:
2153 #line 275 "grammar.y"
2154  { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
2155  break;
2156 
2157  case 57:
2158 #line 276 "grammar.y"
2159  { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
2160  break;
2161 
2162  case 58:
2163 #line 277 "grammar.y"
2164  { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
2165  break;
2166 
2167  case 59:
2168 #line 278 "grammar.y"
2169  { (yyval.node) = new UnaryPlusNode((yyvsp[0].node)); ;}
2170  break;
2171 
2172  case 60:
2173 #line 279 "grammar.y"
2174  { (yyval.node) = new NegateNode((yyvsp[0].node)); ;}
2175  break;
2176 
2177  case 61:
2178 #line 280 "grammar.y"
2179  { (yyval.node) = new BitwiseNotNode((yyvsp[0].node)); ;}
2180  break;
2181 
2182  case 62:
2183 #line 281 "grammar.y"
2184  { (yyval.node) = new LogicalNotNode((yyvsp[0].node)); ;}
2185  break;
2186 
2187  case 64:
2188 #line 286 "grammar.y"
2189  { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '*'); ;}
2190  break;
2191 
2192  case 65:
2193 #line 287 "grammar.y"
2194  { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '/'); ;}
2195  break;
2196 
2197  case 66:
2198 #line 288 "grammar.y"
2199  { (yyval.node) = new MultNode((yyvsp[-2].node),(yyvsp[0].node),'%'); ;}
2200  break;
2201 
2202  case 68:
2203 #line 293 "grammar.y"
2204  { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '+'); ;}
2205  break;
2206 
2207  case 69:
2208 #line 294 "grammar.y"
2209  { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '-'); ;}
2210  break;
2211 
2212  case 71:
2213 #line 299 "grammar.y"
2214  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpLShift, (yyvsp[0].node)); ;}
2215  break;
2216 
2217  case 72:
2218 #line 300 "grammar.y"
2219  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpRShift, (yyvsp[0].node)); ;}
2220  break;
2221 
2222  case 73:
2223 #line 301 "grammar.y"
2224  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpURShift, (yyvsp[0].node)); ;}
2225  break;
2226 
2227  case 75:
2228 #line 307 "grammar.y"
2229  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLess, (yyvsp[0].node)); ;}
2230  break;
2231 
2232  case 76:
2233 #line 309 "grammar.y"
2234  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreater, (yyvsp[0].node)); ;}
2235  break;
2236 
2237  case 77:
2238 #line 311 "grammar.y"
2239  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLessEq, (yyvsp[0].node)); ;}
2240  break;
2241 
2242  case 78:
2243 #line 313 "grammar.y"
2244  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreaterEq, (yyvsp[0].node)); ;}
2245  break;
2246 
2247  case 79:
2248 #line 315 "grammar.y"
2249  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpInstanceOf, (yyvsp[0].node)); ;}
2250  break;
2251 
2252  case 80:
2253 #line 317 "grammar.y"
2254  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpIn, (yyvsp[0].node)); ;}
2255  break;
2256 
2257  case 82:
2258 #line 322 "grammar.y"
2259  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpEqEq, (yyvsp[0].node)); ;}
2260  break;
2261 
2262  case 83:
2263 #line 323 "grammar.y"
2264  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpNotEq, (yyvsp[0].node)); ;}
2265  break;
2266 
2267  case 84:
2268 #line 324 "grammar.y"
2269  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrEq, (yyvsp[0].node)); ;}
2270  break;
2271 
2272  case 85:
2273 #line 325 "grammar.y"
2274  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrNEq, (yyvsp[0].node));;}
2275  break;
2276 
2277  case 87:
2278 #line 330 "grammar.y"
2279  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitAnd, (yyvsp[0].node)); ;}
2280  break;
2281 
2282  case 89:
2283 #line 335 "grammar.y"
2284  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitXOr, (yyvsp[0].node)); ;}
2285  break;
2286 
2287  case 91:
2288 #line 340 "grammar.y"
2289  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitOr, (yyvsp[0].node)); ;}
2290  break;
2291 
2292  case 93:
2293 #line 346 "grammar.y"
2294  { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpAnd, (yyvsp[0].node)); ;}
2295  break;
2296 
2297  case 95:
2298 #line 352 "grammar.y"
2299  { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpOr, (yyvsp[0].node)); ;}
2300  break;
2301 
2302  case 97:
2303 #line 358 "grammar.y"
2304  { (yyval.node) = new ConditionalNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)); ;}
2305  break;
2306 
2307  case 99:
2308 #line 364 "grammar.y"
2309  { (yyval.node) = new AssignNode((yyvsp[-2].node), (yyvsp[-1].op), (yyvsp[0].node));;}
2310  break;
2311 
2312  case 100:
2313 #line 368 "grammar.y"
2314  { (yyval.op) = OpEqual; ;}
2315  break;
2316 
2317  case 101:
2318 #line 369 "grammar.y"
2319  { (yyval.op) = OpPlusEq; ;}
2320  break;
2321 
2322  case 102:
2323 #line 370 "grammar.y"
2324  { (yyval.op) = OpMinusEq; ;}
2325  break;
2326 
2327  case 103:
2328 #line 371 "grammar.y"
2329  { (yyval.op) = OpMultEq; ;}
2330  break;
2331 
2332  case 104:
2333 #line 372 "grammar.y"
2334  { (yyval.op) = OpDivEq; ;}
2335  break;
2336 
2337  case 105:
2338 #line 373 "grammar.y"
2339  { (yyval.op) = OpLShift; ;}
2340  break;
2341 
2342  case 106:
2343 #line 374 "grammar.y"
2344  { (yyval.op) = OpRShift; ;}
2345  break;
2346 
2347  case 107:
2348 #line 375 "grammar.y"
2349  { (yyval.op) = OpURShift; ;}
2350  break;
2351 
2352  case 108:
2353 #line 376 "grammar.y"
2354  { (yyval.op) = OpAndEq; ;}
2355  break;
2356 
2357  case 109:
2358 #line 377 "grammar.y"
2359  { (yyval.op) = OpXOrEq; ;}
2360  break;
2361 
2362  case 110:
2363 #line 378 "grammar.y"
2364  { (yyval.op) = OpOrEq; ;}
2365  break;
2366 
2367  case 111:
2368 #line 379 "grammar.y"
2369  { (yyval.op) = OpModEq; ;}
2370  break;
2371 
2372  case 113:
2373 #line 384 "grammar.y"
2374  { (yyval.node) = new CommaNode((yyvsp[-2].node), (yyvsp[0].node)); ;}
2375  break;
2376 
2377  case 130:
2378 #line 407 "grammar.y"
2379  { (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2380  break;
2381 
2382  case 131:
2383 #line 408 "grammar.y"
2384  { (yyval.stat) = new BlockNode((yyvsp[-1].srcs)); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2385  break;
2386 
2387  case 132:
2388 #line 412 "grammar.y"
2389  { (yyval.slist) = new StatListNode((yyvsp[0].stat)); ;}
2390  break;
2391 
2392  case 133:
2393 #line 413 "grammar.y"
2394  { (yyval.slist) = new StatListNode((yyvsp[-1].slist), (yyvsp[0].stat)); ;}
2395  break;
2396 
2397  case 134:
2398 #line 417 "grammar.y"
2399  { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2400  DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
2401  break;
2402 
2403  case 135:
2404 #line 419 "grammar.y"
2405  { if (automatic()) {
2406  (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2407  DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
2408  } else {
2409  YYABORT;
2410  }
2411  ;}
2412  break;
2413 
2414  case 136:
2415 #line 429 "grammar.y"
2416  { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
2417  break;
2418 
2419  case 137:
2420 #line 431 "grammar.y"
2421  { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
2422  break;
2423 
2424  case 138:
2425 #line 435 "grammar.y"
2426  { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Variable); ;}
2427  break;
2428 
2429  case 139:
2430 #line 436 "grammar.y"
2431  { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Variable); ;}
2432  break;
2433 
2434  case 140:
2435 #line 440 "grammar.y"
2436  { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2437  DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
2438  break;
2439 
2440  case 141:
2441 #line 442 "grammar.y"
2442  { if (automatic()) {
2443  (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2444  DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
2445  } else {
2446  YYABORT;
2447  }
2448  ;}
2449  break;
2450 
2451  case 142:
2452 #line 452 "grammar.y"
2453  { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
2454  break;
2455 
2456  case 143:
2457 #line 454 "grammar.y"
2458  { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
2459  break;
2460 
2461  case 144:
2462 #line 458 "grammar.y"
2463  { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Constant); ;}
2464  break;
2465 
2466  case 145:
2467 #line 459 "grammar.y"
2468  { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Constant); ;}
2469  break;
2470 
2471  case 146:
2472 #line 463 "grammar.y"
2473  { (yyval.init) = new AssignExprNode((yyvsp[0].node)); ;}
2474  break;
2475 
2476  case 147:
2477 #line 467 "grammar.y"
2478  { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2479  break;
2480 
2481  case 148:
2482 #line 471 "grammar.y"
2483  { (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
2484  DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;}
2485  break;
2486 
2487  case 149:
2488 #line 473 "grammar.y"
2489  { if (automatic()) {
2490  (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
2491  DBG((yyval.stat), (yylsp[-1]), (yylsp[-1]));
2492  } else
2493  YYABORT; ;}
2494  break;
2495 
2496  case 150:
2497 #line 481 "grammar.y"
2498  { (yyval.stat) = new IfNode((yyvsp[-2].node),(yyvsp[0].stat),0);DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
2499  break;
2500 
2501  case 151:
2502 #line 483 "grammar.y"
2503  { (yyval.stat) = new IfNode((yyvsp[-4].node),(yyvsp[-2].stat),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-6]),(yylsp[-3])); ;}
2504  break;
2505 
2506  case 152:
2507 #line 487 "grammar.y"
2508  { (yyval.stat)=new DoWhileNode((yyvsp[-4].stat),(yyvsp[-1].node));DBG((yyval.stat),(yylsp[-5]),(yylsp[-3]));;}
2509  break;
2510 
2511  case 153:
2512 #line 488 "grammar.y"
2513  { (yyval.stat) = new WhileNode((yyvsp[-2].node),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
2514  break;
2515 
2516  case 154:
2517 #line 490 "grammar.y"
2518  { (yyval.stat) = new ForNode((yyvsp[-6].node),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
2519  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
2520  break;
2521 
2522  case 155:
2523 #line 493 "grammar.y"
2524  { (yyval.stat) = new ForNode((yyvsp[-6].vlist),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
2525  DBG((yyval.stat),(yylsp[-9]),(yylsp[-1])); ;}
2526  break;
2527 
2528  case 156:
2529 #line 496 "grammar.y"
2530  { (yyval.stat) = new ForInNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].stat));
2531  DBG((yyval.stat),(yylsp[-6]),(yylsp[-1])); ;}
2532  break;
2533 
2534  case 157:
2535 #line 499 "grammar.y"
2536  { (yyval.stat) = new ForInNode(*(yyvsp[-4].ident),0,(yyvsp[-2].node),(yyvsp[0].stat));
2537  DBG((yyval.stat),(yylsp[-7]),(yylsp[-1])); ;}
2538  break;
2539 
2540  case 158:
2541 #line 502 "grammar.y"
2542  { (yyval.stat) = new ForInNode(*(yyvsp[-5].ident),(yyvsp[-4].init),(yyvsp[-2].node),(yyvsp[0].stat));
2543  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
2544  break;
2545 
2546  case 159:
2547 #line 507 "grammar.y"
2548  { (yyval.node) = 0; ;}
2549  break;
2550 
2551  case 161:
2552 #line 512 "grammar.y"
2553  { (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2554  break;
2555 
2556  case 162:
2557 #line 513 "grammar.y"
2558  { if (automatic()) {
2559  (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0]));
2560  } else
2561  YYABORT; ;}
2562  break;
2563 
2564  case 163:
2565 #line 517 "grammar.y"
2566  { (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2567  break;
2568 
2569  case 164:
2570 #line 518 "grammar.y"
2571  { if (automatic()) {
2572  (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident));DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
2573  } else
2574  YYABORT; ;}
2575  break;
2576 
2577  case 165:
2578 #line 525 "grammar.y"
2579  { (yyval.stat) = new BreakNode();DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2580  break;
2581 
2582  case 166:
2583 #line 526 "grammar.y"
2584  { if (automatic()) {
2585  (yyval.stat) = new BreakNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
2586  } else
2587  YYABORT; ;}
2588  break;
2589 
2590  case 167:
2591 #line 530 "grammar.y"
2592  { (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2593  break;
2594 
2595  case 168:
2596 #line 531 "grammar.y"
2597  { if (automatic()) {
2598  (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
2599  } else
2600  YYABORT;
2601  ;}
2602  break;
2603 
2604  case 169:
2605 #line 539 "grammar.y"
2606  { (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2607  break;
2608 
2609  case 170:
2610 #line 540 "grammar.y"
2611  { if (automatic()) {
2612  (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
2613  } else
2614  YYABORT; ;}
2615  break;
2616 
2617  case 171:
2618 #line 544 "grammar.y"
2619  { (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2620  break;
2621 
2622  case 172:
2623 #line 545 "grammar.y"
2624  { if (automatic()) {
2625  (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
2626  }
2627  else
2628  YYABORT; ;}
2629  break;
2630 
2631  case 173:
2632 #line 553 "grammar.y"
2633  { (yyval.stat) = new WithNode((yyvsp[-2].node),(yyvsp[0].stat));
2634  DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
2635  break;
2636 
2637  case 174:
2638 #line 558 "grammar.y"
2639  { (yyval.stat) = new SwitchNode((yyvsp[-2].node), (yyvsp[0].cblk));
2640  DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
2641  break;
2642 
2643  case 175:
2644 #line 563 "grammar.y"
2645  { (yyval.cblk) = new CaseBlockNode((yyvsp[-1].clist), 0, 0); ;}
2646  break;
2647 
2648  case 176:
2649 #line 565 "grammar.y"
2650  { (yyval.cblk) = new CaseBlockNode((yyvsp[-3].clist), (yyvsp[-2].ccl), (yyvsp[-1].clist)); ;}
2651  break;
2652 
2653  case 177:
2654 #line 569 "grammar.y"
2655  { (yyval.clist) = 0; ;}
2656  break;
2657 
2658  case 179:
2659 #line 574 "grammar.y"
2660  { (yyval.clist) = new ClauseListNode((yyvsp[0].ccl)); ;}
2661  break;
2662 
2663  case 180:
2664 #line 575 "grammar.y"
2665  { (yyval.clist) = new ClauseListNode((yyvsp[-1].clist), (yyvsp[0].ccl)); ;}
2666  break;
2667 
2668  case 181:
2669 #line 579 "grammar.y"
2670  { (yyval.ccl) = new CaseClauseNode((yyvsp[-1].node)); ;}
2671  break;
2672 
2673  case 182:
2674 #line 580 "grammar.y"
2675  { (yyval.ccl) = new CaseClauseNode((yyvsp[-2].node), (yyvsp[0].slist)); ;}
2676  break;
2677 
2678  case 183:
2679 #line 584 "grammar.y"
2680  { (yyval.ccl) = new CaseClauseNode(0); ;}
2681  break;
2682 
2683  case 184:
2684 #line 585 "grammar.y"
2685  { (yyval.ccl) = new CaseClauseNode(0, (yyvsp[0].slist)); ;}
2686  break;
2687 
2688  case 185:
2689 #line 589 "grammar.y"
2690  { (yyvsp[0].stat)->pushLabel(*(yyvsp[-2].ident));
2691  (yyval.stat) = new LabelNode(*(yyvsp[-2].ident), (yyvsp[0].stat)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); ;}
2692  break;
2693 
2694  case 186:
2695 #line 594 "grammar.y"
2696  { (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2697  break;
2698 
2699  case 187:
2700 #line 595 "grammar.y"
2701  { if (automatic()) {
2702  (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
2703  } else {
2704  YYABORT; } ;}
2705  break;
2706 
2707  case 188:
2708 #line 602 "grammar.y"
2709  { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].cnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
2710  break;
2711 
2712  case 189:
2713 #line 603 "grammar.y"
2714  { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
2715  break;
2716 
2717  case 190:
2718 #line 604 "grammar.y"
2719  { (yyval.stat) = new TryNode((yyvsp[-2].stat), (yyvsp[-1].cnode), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-3]),(yylsp[-3])); ;}
2720  break;
2721 
2722  case 191:
2723 #line 608 "grammar.y"
2724  { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;}
2725  break;
2726 
2727  case 192:
2728 #line 609 "grammar.y"
2729  { if (automatic()) {
2730  (yyval.stat) = new EmptyStatementNode();
2731  DBG((yyval.stat), (yylsp[-1]), (yylsp[-1]));
2732  } else {
2733  YYABORT; } ;}
2734  break;
2735 
2736  case 193:
2737 #line 618 "grammar.y"
2738  { CatchNode *c; (yyval.cnode) = c = new CatchNode(*(yyvsp[-2].ident), (yyvsp[0].stat));
2739  DBG(c,(yylsp[-4]),(yylsp[-1])); ;}
2740  break;
2741 
2742  case 194:
2743 #line 623 "grammar.y"
2744  { FinallyNode *f; (yyval.fnode) = f = new FinallyNode((yyvsp[0].stat)); DBG(f,(yylsp[-1]),(yylsp[-1])); ;}
2745  break;
2746 
2747  case 196:
2748 #line 629 "grammar.y"
2749  { (yyval.func) = (yyvsp[0].func); ;}
2750  break;
2751 
2752  case 197:
2753 #line 633 "grammar.y"
2754  { (yyval.func) = new FuncDeclNode(*(yyvsp[-3].ident), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-4]),(yylsp[-1])); ;}
2755  break;
2756 
2757  case 198:
2758 #line 635 "grammar.y"
2759  { (yyval.func) = new FuncDeclNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-5]),(yylsp[-1])); ;}
2760  break;
2761 
2762  case 199:
2763 #line 640 "grammar.y"
2764  { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[0].body)); ;}
2765  break;
2766 
2767  case 200:
2768 #line 642 "grammar.y"
2769  { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[-2].param), (yyvsp[0].body)); ;}
2770  break;
2771 
2772  case 201:
2773 #line 644 "grammar.y"
2774  { (yyval.node) = new FuncExprNode(*(yyvsp[-3].ident), (yyvsp[0].body)); ;}
2775  break;
2776 
2777  case 202:
2778 #line 646 "grammar.y"
2779  { (yyval.node) = new FuncExprNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); ;}
2780  break;
2781 
2782  case 203:
2783 #line 650 "grammar.y"
2784  { (yyval.param) = new ParameterNode(*(yyvsp[0].ident)); ;}
2785  break;
2786 
2787  case 204:
2788 #line 651 "grammar.y"
2789  { (yyval.param) = new ParameterNode((yyvsp[-2].param), *(yyvsp[0].ident)); ;}
2790  break;
2791 
2792  case 205:
2793 #line 655 "grammar.y"
2794  { (yyval.body) = new FunctionBodyNode(0);
2795  DBG((yyval.body), (yylsp[-1]), (yylsp[0]));;}
2796  break;
2797 
2798  case 206:
2799 #line 657 "grammar.y"
2800  { (yyval.body) = new FunctionBodyNode((yyvsp[-1].srcs));
2801  DBG((yyval.body), (yylsp[-2]), (yylsp[0]));;}
2802  break;
2803 
2804  case 207:
2805 #line 662 "grammar.y"
2806  { (yyval.prog) = new FunctionBodyNode(0);
2807  (yyval.prog)->setLoc(0, 0, Parser::source);
2808  Parser::progNode = (yyval.prog); ;}
2809  break;
2810 
2811  case 208:
2812 #line 665 "grammar.y"
2813  { (yyval.prog) = new FunctionBodyNode((yyvsp[0].srcs));
2814  Parser::progNode = (yyval.prog); ;}
2815  break;
2816 
2817  case 209:
2818 #line 670 "grammar.y"
2819  { (yyval.srcs) = new SourceElementsNode((yyvsp[0].stat)); ;}
2820  break;
2821 
2822  case 210:
2823 #line 671 "grammar.y"
2824  { (yyval.srcs) = new SourceElementsNode((yyvsp[-1].srcs), (yyvsp[0].stat)); ;}
2825  break;
2826 
2827  case 211:
2828 #line 675 "grammar.y"
2829  { (yyval.stat) = (yyvsp[0].stat); ;}
2830  break;
2831 
2832  case 212:
2833 #line 676 "grammar.y"
2834  { (yyval.stat) = (yyvsp[0].func); ;}
2835  break;
2836 
2837 
2838  default: break;
2839  }
2840 
2841 /* Line 1126 of yacc.c. */
2842 #line 2843 "grammar.tab.c"
2843 
2844  yyvsp -= yylen;
2845  yyssp -= yylen;
2846  yylsp -= yylen;
2847 
2848  YY_STACK_PRINT (yyss, yyssp);
2849 
2850  *++yyvsp = yyval;
2851  *++yylsp = yyloc;
2852 
2853  /* Now `shift' the result of the reduction. Determine what state
2854  that goes to, based on the state we popped back to and the rule
2855  number reduced by. */
2856 
2857  yyn = yyr1[yyn];
2858 
2859  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2860  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2861  yystate = yytable[yystate];
2862  else
2863  yystate = yydefgoto[yyn - YYNTOKENS];
2864 
2865  goto yynewstate;
2866 
2867 
2868 /*------------------------------------.
2869 | yyerrlab -- here on detecting error |
2870 `------------------------------------*/
2871 yyerrlab:
2872  /* If not already recovering from an error, report this error. */
2873  if (!yyerrstatus)
2874  {
2875  ++yynerrs;
2876 #if YYERROR_VERBOSE
2877  yyn = yypact[yystate];
2878 
2879  if (YYPACT_NINF < yyn && yyn < YYLAST)
2880  {
2881  int yytype = YYTRANSLATE (yychar);
2882  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2883  YYSIZE_T yysize = yysize0;
2884  YYSIZE_T yysize1;
2885  int yysize_overflow = 0;
2886  char *yymsg = 0;
2887 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
2888  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2889  int yyx;
2890 
2891 #if 0
2892  /* This is so xgettext sees the translatable formats that are
2893  constructed on the fly. */
2894  YY_("syntax error, unexpected %s");
2895  YY_("syntax error, unexpected %s, expecting %s");
2896  YY_("syntax error, unexpected %s, expecting %s or %s");
2897  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2898  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2899 #endif
2900  char *yyfmt;
2901  char const *yyf;
2902  static char const yyunexpected[] = "syntax error, unexpected %s";
2903  static char const yyexpecting[] = ", expecting %s";
2904  static char const yyor[] = " or %s";
2905  char yyformat[sizeof yyunexpected
2906  + sizeof yyexpecting - 1
2907  + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2908  * (sizeof yyor - 1))];
2909  char const *yyprefix = yyexpecting;
2910 
2911  /* Start YYX at -YYN if negative to avoid negative indexes in
2912  YYCHECK. */
2913  int yyxbegin = yyn < 0 ? -yyn : 0;
2914 
2915  /* Stay within bounds of both yycheck and yytname. */
2916  int yychecklim = YYLAST - yyn;
2917  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2918  int yycount = 1;
2919 
2920  yyarg[0] = yytname[yytype];
2921  yyfmt = yystpcpy (yyformat, yyunexpected);
2922 
2923  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2924  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2925  {
2926  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2927  {
2928  yycount = 1;
2929  yysize = yysize0;
2930  yyformat[sizeof yyunexpected - 1] = '\0';
2931  break;
2932  }
2933  yyarg[yycount++] = yytname[yyx];
2934  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2935  yysize_overflow |= yysize1 < yysize;
2936  yysize = yysize1;
2937  yyfmt = yystpcpy (yyfmt, yyprefix);
2938  yyprefix = yyor;
2939  }
2940 
2941  yyf = YY_(yyformat);
2942  yysize1 = yysize + yystrlen (yyf);
2943  yysize_overflow |= yysize1 < yysize;
2944  yysize = yysize1;
2945 
2946  if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
2947  yymsg = (char *) YYSTACK_ALLOC (yysize);
2948  if (yymsg)
2949  {
2950  /* Avoid sprintf, as that infringes on the user's name space.
2951  Don't have undefined behavior even if the translation
2952  produced a string with the wrong number of "%s"s. */
2953  char *yyp = yymsg;
2954  int yyi = 0;
2955  while ((*yyp = *yyf))
2956  {
2957  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2958  {
2959  yyp += yytnamerr (yyp, yyarg[yyi++]);
2960  yyf += 2;
2961  }
2962  else
2963  {
2964  yyp++;
2965  yyf++;
2966  }
2967  }
2968  yyerror (yymsg);
2969  YYSTACK_FREE (yymsg);
2970  }
2971  else
2972  {
2973  yyerror (YY_("syntax error"));
2974  goto yyexhaustedlab;
2975  }
2976  }
2977  else
2978 #endif /* YYERROR_VERBOSE */
2979  yyerror (YY_("syntax error"));
2980  }
2981 
2982  yyerror_range[0] = yylloc;
2983 
2984  if (yyerrstatus == 3)
2985  {
2986  /* If just tried and failed to reuse look-ahead token after an
2987  error, discard it. */
2988 
2989  if (yychar <= YYEOF)
2990  {
2991  /* Return failure if at end of input. */
2992  if (yychar == YYEOF)
2993  YYABORT;
2994  }
2995  else
2996  {
2997  yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
2998  yychar = YYEMPTY;
2999  }
3000  }
3001 
3002  /* Else will try to reuse look-ahead token after shifting the error
3003  token. */
3004  goto yyerrlab1;
3005 
3006 
3007 /*---------------------------------------------------.
3008 | yyerrorlab -- error raised explicitly by YYERROR. |
3009 `---------------------------------------------------*/
3010 yyerrorlab:
3011 
3012  /* Pacify compilers like GCC when the user code never invokes
3013  YYERROR and the label yyerrorlab therefore never appears in user
3014  code. */
3015  if (0)
3016  goto yyerrorlab;
3017 
3018  yyerror_range[0] = yylsp[1-yylen];
3019  yylsp -= yylen;
3020  yyvsp -= yylen;
3021  yyssp -= yylen;
3022  yystate = *yyssp;
3023  goto yyerrlab1;
3024 
3025 
3026 /*-------------------------------------------------------------.
3027 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3028 `-------------------------------------------------------------*/
3029 yyerrlab1:
3030  yyerrstatus = 3; /* Each real token shifted decrements this. */
3031 
3032  for (;;)
3033  {
3034  yyn = yypact[yystate];
3035  if (yyn != YYPACT_NINF)
3036  {
3037  yyn += YYTERROR;
3038  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3039  {
3040  yyn = yytable[yyn];
3041  if (0 < yyn)
3042  break;
3043  }
3044  }
3045 
3046  /* Pop the current state because it cannot handle the error token. */
3047  if (yyssp == yyss)
3048  YYABORT;
3049 
3050  yyerror_range[0] = *yylsp;
3051  yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
3052  YYPOPSTACK;
3053  yystate = *yyssp;
3054  YY_STACK_PRINT (yyss, yyssp);
3055  }
3056 
3057  if (yyn == YYFINAL)
3058  YYACCEPT;
3059 
3060  *++yyvsp = yylval;
3061 
3062  yyerror_range[1] = yylloc;
3063  /* Using YYLLOC is tempting, but would change the location of
3064  the look-ahead. YYLOC is available though. */
3065  YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
3066  *++yylsp = yyloc;
3067 
3068  /* Shift the error token. */
3069  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3070 
3071  yystate = yyn;
3072  goto yynewstate;
3073 
3074 
3075 /*-------------------------------------.
3076 | yyacceptlab -- YYACCEPT comes here. |
3077 `-------------------------------------*/
3078 yyacceptlab:
3079  yyresult = 0;
3080  goto yyreturn;
3081 
3082 /*-----------------------------------.
3083 | yyabortlab -- YYABORT comes here. |
3084 `-----------------------------------*/
3085 yyabortlab:
3086  yyresult = 1;
3087  goto yyreturn;
3088 
3089 #ifndef yyoverflow
3090 /*-------------------------------------------------.
3091 | yyexhaustedlab -- memory exhaustion comes here. |
3092 `-------------------------------------------------*/
3093 yyexhaustedlab:
3094  yyerror (YY_("memory exhausted"));
3095  yyresult = 2;
3096  /* Fall through. */
3097 #endif
3098 
3099 yyreturn:
3100  if (yychar != YYEOF && yychar != YYEMPTY)
3101  yydestruct ("Cleanup: discarding lookahead",
3102  yytoken, &yylval, &yylloc);
3103  while (yyssp != yyss)
3104  {
3105  yydestruct ("Cleanup: popping",
3106  yystos[*yyssp], yyvsp, yylsp);
3107  YYPOPSTACK;
3108  }
3109 #ifndef yyoverflow
3110  if (yyss != yyssa)
3111  YYSTACK_FREE (yyss);
3112 #endif
3113  return yyresult;
3114 }
3115 
3116 
3117 #line 679 "grammar.y"
3118 
3119 
3120 int yyerror (const char * /* s */) /* Called by yyparse on error */
3121 {
3122  // fprintf(stderr, "ERROR: %s at line %d\n",
3123  // s, KJS::Lexer::curr()->lineNo());
3124  return 1;
3125 }
3126 
3127 /* may we automatically insert a semicolon ? */
3128 bool automatic()
3129 {
3130  if (Lexer::curr()->hadError())
3131  return false;
3132  if (yychar == '}' || yychar == 0)
3133  return true;
3134  else if (Lexer::curr()->prevTerminator())
3135  return true;
3136 
3137  return false;
3138 }
3139 
KJS::UString
Unicode string class.
Definition: ustring.h:190
KJS
Definition: array_instance.h:28
KJS::BinaryLogicalNode
expr1 && expr2, expr1 || expr2
Definition: nodes.h:599
KJS::ConditionalNode
The ternary operator, "logical ? expr1 : expr2".
Definition: nodes.h:615
KJS::Identifier::null
static const Identifier & null()
Creates an empty Identifier.
Definition: identifier.cpp:302
KJS::Identifier
Represents an Identifier for a Javascript object.
Definition: identifier.h:32

kjs

Skip menu "kjs"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

kjs

Skip menu "kjs"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for kjs by doxygen 1.8.11
This website is maintained by Timothy Pearson.