• 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  { \
1344  YYFPRINTF Args; \
1345  } \
1346 } while (0)
1347 
1348 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1349 do { \
1350  if (yydebug) \
1351  { \
1352  YYFPRINTF (stderr, "%s ", Title); \
1353  yysymprint (stderr, \
1354  Type, Value, Location); \
1355  YYFPRINTF (stderr, "\n"); \
1356  } \
1357 } while (0)
1358 
1359 /*------------------------------------------------------------------.
1360 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1361 | TOP (included). |
1362 `------------------------------------------------------------------*/
1363 
1364 #if defined (__STDC__) || defined (__cplusplus)
1365 static void
1366 yy_stack_print (short int *bottom, short int *top)
1367 #else
1368 static void
1369 yy_stack_print (bottom, top)
1370  short int *bottom;
1371  short int *top;
1372 #endif
1373 {
1374  YYFPRINTF (stderr, "Stack now");
1375  for (/* Nothing. */; bottom <= top; ++bottom)
1376  YYFPRINTF (stderr, " %d", *bottom);
1377  YYFPRINTF (stderr, "\n");
1378 }
1379 
1380 # define YY_STACK_PRINT(Bottom, Top) \
1381 do { \
1382  if (yydebug) \
1383  yy_stack_print ((Bottom), (Top)); \
1384 } while (0)
1385 
1386 
1387 /*------------------------------------------------.
1388 | Report that the YYRULE is going to be reduced. |
1389 `------------------------------------------------*/
1390 
1391 #if defined (__STDC__) || defined (__cplusplus)
1392 static void
1393 yy_reduce_print (int yyrule)
1394 #else
1395 static void
1396 yy_reduce_print (yyrule)
1397  int yyrule;
1398 #endif
1399 {
1400  int yyi;
1401  unsigned long int yylno = yyrline[yyrule];
1402  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
1403  yyrule - 1, yylno);
1404  /* Print the symbols being reduced, and their result. */
1405  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1406  YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1407  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
1408 }
1409 
1410 # define YY_REDUCE_PRINT(Rule) \
1411 do { \
1412  if (yydebug) \
1413  yy_reduce_print (Rule); \
1414 } while (0)
1415 
1416 /* Nonzero means print parse trace. It is left uninitialized so that
1417  multiple parsers can coexist. */
1418 int yydebug;
1419 #else /* !YYDEBUG */
1420 # define YYDPRINTF(Args)
1421 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1422 # define YY_STACK_PRINT(Bottom, Top)
1423 # define YY_REDUCE_PRINT(Rule)
1424 #endif /* !YYDEBUG */
1425 
1426 
1427 /* YYINITDEPTH -- initial size of the parser's stacks. */
1428 #ifndef YYINITDEPTH
1429 # define YYINITDEPTH 200
1430 #endif
1431 
1432 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1433  if the built-in stack extension method is used).
1434 
1435  Do not make this value too large; the results are undefined if
1436  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1437  evaluated with infinite-precision integer arithmetic. */
1438 
1439 #ifndef YYMAXDEPTH
1440 # define YYMAXDEPTH 10000
1441 #endif
1442 
1443 ␌
1444 
1445 #if YYERROR_VERBOSE
1446 
1447 # ifndef yystrlen
1448 # if defined (__GLIBC__) && defined (_STRING_H)
1449 # define yystrlen strlen
1450 # else
1451 /* Return the length of YYSTR. */
1452 static YYSIZE_T
1453 # if defined (__STDC__) || defined (__cplusplus)
1454 yystrlen (const char *yystr)
1455 # else
1456 yystrlen (yystr)
1457  const char *yystr;
1458 # endif
1459 {
1460  const char *yys = yystr;
1461 
1462  while (*yys++ != '\0')
1463  continue;
1464 
1465  return yys - yystr - 1;
1466 }
1467 # endif
1468 # endif
1469 
1470 # ifndef yystpcpy
1471 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1472 # define yystpcpy stpcpy
1473 # else
1474 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1475  YYDEST. */
1476 static char *
1477 # if defined (__STDC__) || defined (__cplusplus)
1478 yystpcpy (char *yydest, const char *yysrc)
1479 # else
1480 yystpcpy (yydest, yysrc)
1481  char *yydest;
1482  const char *yysrc;
1483 # endif
1484 {
1485  char *yyd = yydest;
1486  const char *yys = yysrc;
1487 
1488  while ((*yyd++ = *yys++) != '\0')
1489  continue;
1490 
1491  return yyd - 1;
1492 }
1493 # endif
1494 # endif
1495 
1496 # ifndef yytnamerr
1497 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1498  quotes and backslashes, so that it's suitable for yyerror. The
1499  heuristic is that double-quoting is unnecessary unless the string
1500  contains an apostrophe, a comma, or backslash (other than
1501  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1502  null, do not copy; instead, return the length of what the result
1503  would have been. */
1504 static YYSIZE_T
1505 yytnamerr (char *yyres, const char *yystr)
1506 {
1507  if (*yystr == '"')
1508  {
1509  size_t yyn = 0;
1510  char const *yyp = yystr;
1511 
1512  for (;;)
1513  switch (*++yyp)
1514  {
1515  case '\'':
1516  case ',':
1517  goto do_not_strip_quotes;
1518 
1519  case '\\':
1520  if (*++yyp != '\\')
1521  goto do_not_strip_quotes;
1522  /* Fall through. */
1523  default:
1524  if (yyres)
1525  yyres[yyn] = *yyp;
1526  yyn++;
1527  break;
1528 
1529  case '"':
1530  if (yyres)
1531  yyres[yyn] = '\0';
1532  return yyn;
1533  }
1534  do_not_strip_quotes: ;
1535  }
1536 
1537  if (! yyres)
1538  return yystrlen (yystr);
1539 
1540  return yystpcpy (yyres, yystr) - yyres;
1541 }
1542 # endif
1543 
1544 #endif /* YYERROR_VERBOSE */
1545 
1546 ␌
1547 
1548 #if YYDEBUG
1549 /*--------------------------------.
1550 | Print this symbol on YYOUTPUT. |
1551 `--------------------------------*/
1552 
1553 #if defined (__STDC__) || defined (__cplusplus)
1554 static void
1555 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1556 #else
1557 static void
1558 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
1559  FILE *yyoutput;
1560  int yytype;
1561  YYSTYPE *yyvaluep;
1562  YYLTYPE *yylocationp;
1563 #endif
1564 {
1565  /* Pacify ``unused variable'' warnings. */
1566  (void) yyvaluep;
1567  (void) yylocationp;
1568 
1569  if (yytype < YYNTOKENS)
1570  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1571  else
1572  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1573 
1574  YY_LOCATION_PRINT (yyoutput, *yylocationp);
1575  YYFPRINTF (yyoutput, ": ");
1576 
1577 # ifdef YYPRINT
1578  if (yytype < YYNTOKENS)
1579  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1580 # endif
1581  switch (yytype)
1582  {
1583  default:
1584  break;
1585  }
1586  YYFPRINTF (yyoutput, ")");
1587 }
1588 
1589 #endif /* ! YYDEBUG */
1590 /*-----------------------------------------------.
1591 | Release the memory associated to this symbol. |
1592 `-----------------------------------------------*/
1593 
1594 #if defined (__STDC__) || defined (__cplusplus)
1595 static void
1596 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1597 #else
1598 static void
1599 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1600  const char *yymsg;
1601  int yytype;
1602  YYSTYPE *yyvaluep;
1603  YYLTYPE *yylocationp;
1604 #endif
1605 {
1606  /* Pacify ``unused variable'' warnings. */
1607  (void) yyvaluep;
1608  (void) yylocationp;
1609 
1610  if (!yymsg)
1611  yymsg = "Deleting";
1612  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1613 
1614  switch (yytype)
1615  {
1616 
1617  default:
1618  break;
1619  }
1620 }
1621 ␌
1622 
1623 /* Prevent warnings from -Wmissing-prototypes. */
1624 
1625 #ifdef YYPARSE_PARAM
1626 # if defined (__STDC__) || defined (__cplusplus)
1627 int yyparse (void *YYPARSE_PARAM);
1628 # else
1629 int yyparse ();
1630 # endif
1631 #else /* ! YYPARSE_PARAM */
1632 #if defined (__STDC__) || defined (__cplusplus)
1633 int yyparse (void);
1634 #else
1635 int yyparse ();
1636 #endif
1637 #endif /* ! YYPARSE_PARAM */
1638 
1639 
1640 
1641 /* The look-ahead symbol. */
1642 int yychar;
1643 
1644 /* The semantic value of the look-ahead symbol. */
1645 YYSTYPE yylval;
1646 
1647 /* Number of syntax errors so far. */
1648 int yynerrs;
1649 /* Location data for the look-ahead symbol. */
1650 YYLTYPE yylloc;
1651 
1652 
1653 
1654 /*----------.
1655 | yyparse. |
1656 `----------*/
1657 
1658 #ifdef YYPARSE_PARAM
1659 # if defined (__STDC__) || defined (__cplusplus)
1660 int yyparse (void *YYPARSE_PARAM)
1661 # else
1662 int yyparse (YYPARSE_PARAM)
1663  void *YYPARSE_PARAM;
1664 # endif
1665 #else /* ! YYPARSE_PARAM */
1666 #if defined (__STDC__) || defined (__cplusplus)
1667 int
1668 yyparse (void)
1669 #else
1670 int
1671 yyparse ()
1672  ;
1673 #endif
1674 #endif
1675 {
1676 
1677  int yystate;
1678  int yyn;
1679  int yyresult;
1680  /* Number of tokens to shift before error messages enabled. */
1681  int yyerrstatus;
1682  /* Look-ahead token as an internal (translated) token number. */
1683  int yytoken = 0;
1684 
1685  /* Three stacks and their tools:
1686  `yyss': related to states,
1687  `yyvs': related to semantic values,
1688  `yyls': related to locations.
1689 
1690  Refer to the stacks thru separate pointers, to allow yyoverflow
1691  to reallocate them elsewhere. */
1692 
1693  /* The state stack. */
1694  short int yyssa[YYINITDEPTH];
1695  short int *yyss = yyssa;
1696  short int *yyssp;
1697 
1698  /* The semantic value stack. */
1699  YYSTYPE yyvsa[YYINITDEPTH];
1700  YYSTYPE *yyvs = yyvsa;
1701  YYSTYPE *yyvsp;
1702 
1703  /* The location stack. */
1704  YYLTYPE yylsa[YYINITDEPTH];
1705  YYLTYPE *yyls = yylsa;
1706  YYLTYPE *yylsp;
1707  /* The locations where the error started and ended. */
1708  YYLTYPE yyerror_range[2];
1709 
1710 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
1711 
1712  YYSIZE_T yystacksize = YYINITDEPTH;
1713 
1714  /* The variables used to return semantic value and location from the
1715  action routines. */
1716  YYSTYPE yyval;
1717  YYLTYPE yyloc;
1718 
1719  /* When reducing, the number of symbols on the RHS of the reduced
1720  rule. */
1721  int yylen;
1722 
1723  YYDPRINTF ((stderr, "Starting parse\n"));
1724 
1725  yystate = 0;
1726  yyerrstatus = 0;
1727  yynerrs = 0;
1728  yychar = YYEMPTY; /* Cause a token to be read. */
1729 
1730  /* Initialize stack pointers.
1731  Waste one element of value and location stack
1732  so that they stay on the same level as the state stack.
1733  The wasted elements are never initialized. */
1734 
1735  yyssp = yyss;
1736  yyvsp = yyvs;
1737  yylsp = yyls;
1738 #if YYLTYPE_IS_TRIVIAL
1739  /* Initialize the default location before parsing starts. */
1740  yylloc.first_line = yylloc.last_line = 1;
1741  yylloc.first_column = yylloc.last_column = 0;
1742 #endif
1743 
1744  goto yysetstate;
1745 
1746 /*------------------------------------------------------------.
1747 | yynewstate -- Push a new state, which is found in yystate. |
1748 `------------------------------------------------------------*/
1749  yynewstate:
1750  /* In all cases, when you get here, the value and location stacks
1751  have just been pushed. so pushing a state here evens the stacks.
1752  */
1753  yyssp++;
1754 
1755  yysetstate:
1756  *yyssp = yystate;
1757 
1758  if (yyss + yystacksize - 1 <= yyssp)
1759  {
1760  /* Get the current used size of the three stacks, in elements. */
1761  YYSIZE_T yysize = yyssp - yyss + 1;
1762 
1763 #ifdef yyoverflow
1764  {
1765  /* Give user a chance to reallocate the stack. Use copies of
1766  these so that the &'s don't force the real ones into
1767  memory. */
1768  YYSTYPE *yyvs1 = yyvs;
1769  short int *yyss1 = yyss;
1770  YYLTYPE *yyls1 = yyls;
1771 
1772  /* Each stack pointer address is followed by the size of the
1773  data in use in that stack, in bytes. This used to be a
1774  conditional around just the two extra args, but that might
1775  be undefined if yyoverflow is a macro. */
1776  yyoverflow (YY_("memory exhausted"),
1777  &yyss1, yysize * sizeof (*yyssp),
1778  &yyvs1, yysize * sizeof (*yyvsp),
1779  &yyls1, yysize * sizeof (*yylsp),
1780  &yystacksize);
1781  yyls = yyls1;
1782  yyss = yyss1;
1783  yyvs = yyvs1;
1784  }
1785 #else /* no yyoverflow */
1786 # ifndef YYSTACK_RELOCATE
1787  goto yyexhaustedlab;
1788 # else
1789  /* Extend the stack our own way. */
1790  if (YYMAXDEPTH <= yystacksize)
1791  goto yyexhaustedlab;
1792  yystacksize *= 2;
1793  if (YYMAXDEPTH < yystacksize)
1794  yystacksize = YYMAXDEPTH;
1795 
1796  {
1797  short int *yyss1 = yyss;
1798  union yyalloc *yyptr =
1799  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1800  if (! yyptr)
1801  goto yyexhaustedlab;
1802  YYSTACK_RELOCATE (yyss);
1803  YYSTACK_RELOCATE (yyvs);
1804  YYSTACK_RELOCATE (yyls);
1805 # undef YYSTACK_RELOCATE
1806  if (yyss1 != yyssa)
1807  YYSTACK_FREE (yyss1);
1808  }
1809 # endif
1810 #endif /* no yyoverflow */
1811 
1812  yyssp = yyss + yysize - 1;
1813  yyvsp = yyvs + yysize - 1;
1814  yylsp = yyls + yysize - 1;
1815 
1816  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1817  (unsigned long int) yystacksize));
1818 
1819  if (yyss + yystacksize - 1 <= yyssp)
1820  YYABORT;
1821  }
1822 
1823  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1824 
1825  goto yybackup;
1826 
1827 /*-----------.
1828 | yybackup. |
1829 `-----------*/
1830 yybackup:
1831 
1832 /* Do appropriate processing given the current state. */
1833 /* Read a look-ahead token if we need one and don't already have one. */
1834 /* yyresume: */
1835 
1836  /* First try to decide what to do without reference to look-ahead token. */
1837 
1838  yyn = yypact[yystate];
1839  if (yyn == YYPACT_NINF)
1840  goto yydefault;
1841 
1842  /* Not known => get a look-ahead token if don't already have one. */
1843 
1844  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1845  if (yychar == YYEMPTY)
1846  {
1847  YYDPRINTF ((stderr, "Reading a token: "));
1848  yychar = YYLEX;
1849  }
1850 
1851  if (yychar <= YYEOF)
1852  {
1853  yychar = yytoken = YYEOF;
1854  YYDPRINTF ((stderr, "Now at end of input.\n"));
1855  }
1856  else
1857  {
1858  yytoken = YYTRANSLATE (yychar);
1859  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1860  }
1861 
1862  /* If the proper action on seeing token YYTOKEN is to reduce or to
1863  detect an error, take that action. */
1864  yyn += yytoken;
1865  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1866  goto yydefault;
1867  yyn = yytable[yyn];
1868  if (yyn <= 0)
1869  {
1870  if (yyn == 0 || yyn == YYTABLE_NINF)
1871  goto yyerrlab;
1872  yyn = -yyn;
1873  goto yyreduce;
1874  }
1875 
1876  if (yyn == YYFINAL)
1877  YYACCEPT;
1878 
1879  /* Shift the look-ahead token. */
1880  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1881 
1882  /* Discard the token being shifted unless it is eof. */
1883  if (yychar != YYEOF)
1884  yychar = YYEMPTY;
1885 
1886  *++yyvsp = yylval;
1887  *++yylsp = yylloc;
1888 
1889  /* Count tokens shifted since error; after three, turn off error
1890  status. */
1891  if (yyerrstatus)
1892  yyerrstatus--;
1893 
1894  yystate = yyn;
1895  goto yynewstate;
1896 
1897 
1898 /*-----------------------------------------------------------.
1899 | yydefault -- do the default action for the current state. |
1900 `-----------------------------------------------------------*/
1901 yydefault:
1902  yyn = yydefact[yystate];
1903  if (yyn == 0)
1904  goto yyerrlab;
1905  goto yyreduce;
1906 
1907 
1908 /*-----------------------------.
1909 | yyreduce -- Do a reduction. |
1910 `-----------------------------*/
1911 yyreduce:
1912  /* yyn is the number of a rule to reduce with. */
1913  yylen = yyr2[yyn];
1914 
1915  /* If YYLEN is nonzero, implement the default value of the action:
1916  `$$ = $1'.
1917 
1918  Otherwise, the following line sets YYVAL to garbage.
1919  This behavior is undocumented and Bison
1920  users should not rely upon it. Assigning to YYVAL
1921  unconditionally makes the parser a bit smaller, and it avoids a
1922  GCC warning that YYVAL may be used uninitialized. */
1923  yyval = yyvsp[1-yylen];
1924 
1925  /* Default location. */
1926  YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
1927  YY_REDUCE_PRINT (yyn);
1928  switch (yyn)
1929  {
1930  case 2:
1931 #line 169 "grammar.y"
1932  { (yyval.node) = new NullNode(); ;}
1933  break;
1934 
1935  case 3:
1936 #line 170 "grammar.y"
1937  { (yyval.node) = new BooleanNode(true); ;}
1938  break;
1939 
1940  case 4:
1941 #line 171 "grammar.y"
1942  { (yyval.node) = new BooleanNode(false); ;}
1943  break;
1944 
1945  case 5:
1946 #line 172 "grammar.y"
1947  { (yyval.node) = new NumberNode((yyvsp[0].dval)); ;}
1948  break;
1949 
1950  case 6:
1951 #line 173 "grammar.y"
1952  { (yyval.node) = new StringNode((yyvsp[0].ustr)); ;}
1953  break;
1954 
1955  case 7:
1956 #line 174 "grammar.y"
1957  { Lexer *l = Lexer::curr();
1958  if (!l->scanRegExp()) YYABORT;
1959  (yyval.node) = new RegExpNode(l->pattern,l->flags);;}
1960  break;
1961 
1962  case 8:
1963 #line 178 "grammar.y"
1964  { Lexer *l = Lexer::curr();
1965  if (!l->scanRegExp()) YYABORT;
1966  (yyval.node) = new RegExpNode(UString('=')+l->pattern,l->flags);;}
1967  break;
1968 
1969  case 9:
1970 #line 184 "grammar.y"
1971  { (yyval.node) = new ThisNode(); ;}
1972  break;
1973 
1974  case 10:
1975 #line 185 "grammar.y"
1976  { (yyval.node) = new ResolveNode(*(yyvsp[0].ident)); ;}
1977  break;
1978 
1979  case 13:
1980 #line 188 "grammar.y"
1981  { (yyval.node) = new GroupNode((yyvsp[-1].node)); ;}
1982  break;
1983 
1984  case 14:
1985 #line 189 "grammar.y"
1986  { (yyval.node) = new ObjectLiteralNode(); ;}
1987  break;
1988 
1989  case 15:
1990 #line 190 "grammar.y"
1991  { (yyval.node) = new ObjectLiteralNode((yyvsp[-1].plist)); ;}
1992  break;
1993 
1994  case 16:
1995 #line 191 "grammar.y"
1996  { (yyval.node) = new ObjectLiteralNode((yyvsp[-2].plist)); ;}
1997  break;
1998 
1999  case 17:
2000 #line 195 "grammar.y"
2001  { (yyval.node) = new ArrayNode((yyvsp[-1].ival)); ;}
2002  break;
2003 
2004  case 18:
2005 #line 196 "grammar.y"
2006  { (yyval.node) = new ArrayNode((yyvsp[-1].elm)); ;}
2007  break;
2008 
2009  case 19:
2010 #line 197 "grammar.y"
2011  { (yyval.node) = new ArrayNode((yyvsp[-1].ival), (yyvsp[-3].elm)); ;}
2012  break;
2013 
2014  case 20:
2015 #line 201 "grammar.y"
2016  { (yyval.elm) = new ElementNode((yyvsp[-1].ival), (yyvsp[0].node)); ;}
2017  break;
2018 
2019  case 21:
2020 #line 203 "grammar.y"
2021  { (yyval.elm) = new ElementNode((yyvsp[-3].elm), (yyvsp[-1].ival), (yyvsp[0].node)); ;}
2022  break;
2023 
2024  case 22:
2025 #line 207 "grammar.y"
2026  { (yyval.ival) = 0; ;}
2027  break;
2028 
2029  case 24:
2030 #line 212 "grammar.y"
2031  { (yyval.ival) = 1; ;}
2032  break;
2033 
2034  case 25:
2035 #line 213 "grammar.y"
2036  { (yyval.ival) = (yyvsp[-1].ival) + 1; ;}
2037  break;
2038 
2039  case 26:
2040 #line 217 "grammar.y"
2041  { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node)); ;}
2042  break;
2043 
2044  case 27:
2045 #line 219 "grammar.y"
2046  { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node), (yyvsp[-4].plist)); ;}
2047  break;
2048 
2049  case 28:
2050 #line 223 "grammar.y"
2051  { (yyval.pnode) = new PropertyNode(*(yyvsp[0].ident)); ;}
2052  break;
2053 
2054  case 29:
2055 #line 224 "grammar.y"
2056  { (yyval.pnode) = new PropertyNode(Identifier(*(yyvsp[0].ustr))); ;}
2057  break;
2058 
2059  case 30:
2060 #line 225 "grammar.y"
2061  { (yyval.pnode) = new PropertyNode((yyvsp[0].dval)); ;}
2062  break;
2063 
2064  case 33:
2065 #line 231 "grammar.y"
2066  { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
2067  break;
2068 
2069  case 34:
2070 #line 232 "grammar.y"
2071  { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
2072  break;
2073 
2074  case 35:
2075 #line 233 "grammar.y"
2076  { (yyval.node) = new NewExprNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2077  break;
2078 
2079  case 37:
2080 #line 238 "grammar.y"
2081  { (yyval.node) = new NewExprNode((yyvsp[0].node)); ;}
2082  break;
2083 
2084  case 38:
2085 #line 242 "grammar.y"
2086  { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2087  break;
2088 
2089  case 39:
2090 #line 243 "grammar.y"
2091  { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
2092  break;
2093 
2094  case 40:
2095 #line 244 "grammar.y"
2096  { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
2097  break;
2098 
2099  case 41:
2100 #line 245 "grammar.y"
2101  { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
2102  break;
2103 
2104  case 42:
2105 #line 249 "grammar.y"
2106  { (yyval.args) = new ArgumentsNode(); ;}
2107  break;
2108 
2109  case 43:
2110 #line 250 "grammar.y"
2111  { (yyval.args) = new ArgumentsNode((yyvsp[-1].alist)); ;}
2112  break;
2113 
2114  case 44:
2115 #line 254 "grammar.y"
2116  { (yyval.alist) = new ArgumentListNode((yyvsp[0].node)); ;}
2117  break;
2118 
2119  case 45:
2120 #line 255 "grammar.y"
2121  { (yyval.alist) = new ArgumentListNode((yyvsp[-2].alist), (yyvsp[0].node)); ;}
2122  break;
2123 
2124  case 49:
2125 #line 265 "grammar.y"
2126  { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpPlusPlus); ;}
2127  break;
2128 
2129  case 50:
2130 #line 266 "grammar.y"
2131  { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpMinusMinus); ;}
2132  break;
2133 
2134  case 52:
2135 #line 271 "grammar.y"
2136  { (yyval.node) = new DeleteNode((yyvsp[0].node)); ;}
2137  break;
2138 
2139  case 53:
2140 #line 272 "grammar.y"
2141  { (yyval.node) = new VoidNode((yyvsp[0].node)); ;}
2142  break;
2143 
2144  case 54:
2145 #line 273 "grammar.y"
2146  { (yyval.node) = new TypeOfNode((yyvsp[0].node)); ;}
2147  break;
2148 
2149  case 55:
2150 #line 274 "grammar.y"
2151  { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
2152  break;
2153 
2154  case 56:
2155 #line 275 "grammar.y"
2156  { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
2157  break;
2158 
2159  case 57:
2160 #line 276 "grammar.y"
2161  { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
2162  break;
2163 
2164  case 58:
2165 #line 277 "grammar.y"
2166  { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
2167  break;
2168 
2169  case 59:
2170 #line 278 "grammar.y"
2171  { (yyval.node) = new UnaryPlusNode((yyvsp[0].node)); ;}
2172  break;
2173 
2174  case 60:
2175 #line 279 "grammar.y"
2176  { (yyval.node) = new NegateNode((yyvsp[0].node)); ;}
2177  break;
2178 
2179  case 61:
2180 #line 280 "grammar.y"
2181  { (yyval.node) = new BitwiseNotNode((yyvsp[0].node)); ;}
2182  break;
2183 
2184  case 62:
2185 #line 281 "grammar.y"
2186  { (yyval.node) = new LogicalNotNode((yyvsp[0].node)); ;}
2187  break;
2188 
2189  case 64:
2190 #line 286 "grammar.y"
2191  { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '*'); ;}
2192  break;
2193 
2194  case 65:
2195 #line 287 "grammar.y"
2196  { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '/'); ;}
2197  break;
2198 
2199  case 66:
2200 #line 288 "grammar.y"
2201  { (yyval.node) = new MultNode((yyvsp[-2].node),(yyvsp[0].node),'%'); ;}
2202  break;
2203 
2204  case 68:
2205 #line 293 "grammar.y"
2206  { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '+'); ;}
2207  break;
2208 
2209  case 69:
2210 #line 294 "grammar.y"
2211  { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '-'); ;}
2212  break;
2213 
2214  case 71:
2215 #line 299 "grammar.y"
2216  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpLShift, (yyvsp[0].node)); ;}
2217  break;
2218 
2219  case 72:
2220 #line 300 "grammar.y"
2221  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpRShift, (yyvsp[0].node)); ;}
2222  break;
2223 
2224  case 73:
2225 #line 301 "grammar.y"
2226  { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpURShift, (yyvsp[0].node)); ;}
2227  break;
2228 
2229  case 75:
2230 #line 307 "grammar.y"
2231  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLess, (yyvsp[0].node)); ;}
2232  break;
2233 
2234  case 76:
2235 #line 309 "grammar.y"
2236  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreater, (yyvsp[0].node)); ;}
2237  break;
2238 
2239  case 77:
2240 #line 311 "grammar.y"
2241  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLessEq, (yyvsp[0].node)); ;}
2242  break;
2243 
2244  case 78:
2245 #line 313 "grammar.y"
2246  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreaterEq, (yyvsp[0].node)); ;}
2247  break;
2248 
2249  case 79:
2250 #line 315 "grammar.y"
2251  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpInstanceOf, (yyvsp[0].node)); ;}
2252  break;
2253 
2254  case 80:
2255 #line 317 "grammar.y"
2256  { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpIn, (yyvsp[0].node)); ;}
2257  break;
2258 
2259  case 82:
2260 #line 322 "grammar.y"
2261  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpEqEq, (yyvsp[0].node)); ;}
2262  break;
2263 
2264  case 83:
2265 #line 323 "grammar.y"
2266  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpNotEq, (yyvsp[0].node)); ;}
2267  break;
2268 
2269  case 84:
2270 #line 324 "grammar.y"
2271  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrEq, (yyvsp[0].node)); ;}
2272  break;
2273 
2274  case 85:
2275 #line 325 "grammar.y"
2276  { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrNEq, (yyvsp[0].node));;}
2277  break;
2278 
2279  case 87:
2280 #line 330 "grammar.y"
2281  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitAnd, (yyvsp[0].node)); ;}
2282  break;
2283 
2284  case 89:
2285 #line 335 "grammar.y"
2286  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitXOr, (yyvsp[0].node)); ;}
2287  break;
2288 
2289  case 91:
2290 #line 340 "grammar.y"
2291  { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitOr, (yyvsp[0].node)); ;}
2292  break;
2293 
2294  case 93:
2295 #line 346 "grammar.y"
2296  { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpAnd, (yyvsp[0].node)); ;}
2297  break;
2298 
2299  case 95:
2300 #line 352 "grammar.y"
2301  { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpOr, (yyvsp[0].node)); ;}
2302  break;
2303 
2304  case 97:
2305 #line 358 "grammar.y"
2306  { (yyval.node) = new ConditionalNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)); ;}
2307  break;
2308 
2309  case 99:
2310 #line 364 "grammar.y"
2311  { (yyval.node) = new AssignNode((yyvsp[-2].node), (yyvsp[-1].op), (yyvsp[0].node));;}
2312  break;
2313 
2314  case 100:
2315 #line 368 "grammar.y"
2316  { (yyval.op) = OpEqual; ;}
2317  break;
2318 
2319  case 101:
2320 #line 369 "grammar.y"
2321  { (yyval.op) = OpPlusEq; ;}
2322  break;
2323 
2324  case 102:
2325 #line 370 "grammar.y"
2326  { (yyval.op) = OpMinusEq; ;}
2327  break;
2328 
2329  case 103:
2330 #line 371 "grammar.y"
2331  { (yyval.op) = OpMultEq; ;}
2332  break;
2333 
2334  case 104:
2335 #line 372 "grammar.y"
2336  { (yyval.op) = OpDivEq; ;}
2337  break;
2338 
2339  case 105:
2340 #line 373 "grammar.y"
2341  { (yyval.op) = OpLShift; ;}
2342  break;
2343 
2344  case 106:
2345 #line 374 "grammar.y"
2346  { (yyval.op) = OpRShift; ;}
2347  break;
2348 
2349  case 107:
2350 #line 375 "grammar.y"
2351  { (yyval.op) = OpURShift; ;}
2352  break;
2353 
2354  case 108:
2355 #line 376 "grammar.y"
2356  { (yyval.op) = OpAndEq; ;}
2357  break;
2358 
2359  case 109:
2360 #line 377 "grammar.y"
2361  { (yyval.op) = OpXOrEq; ;}
2362  break;
2363 
2364  case 110:
2365 #line 378 "grammar.y"
2366  { (yyval.op) = OpOrEq; ;}
2367  break;
2368 
2369  case 111:
2370 #line 379 "grammar.y"
2371  { (yyval.op) = OpModEq; ;}
2372  break;
2373 
2374  case 113:
2375 #line 384 "grammar.y"
2376  { (yyval.node) = new CommaNode((yyvsp[-2].node), (yyvsp[0].node)); ;}
2377  break;
2378 
2379  case 130:
2380 #line 407 "grammar.y"
2381  { (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2382  break;
2383 
2384  case 131:
2385 #line 408 "grammar.y"
2386  { (yyval.stat) = new BlockNode((yyvsp[-1].srcs)); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2387  break;
2388 
2389  case 132:
2390 #line 412 "grammar.y"
2391  { (yyval.slist) = new StatListNode((yyvsp[0].stat)); ;}
2392  break;
2393 
2394  case 133:
2395 #line 413 "grammar.y"
2396  { (yyval.slist) = new StatListNode((yyvsp[-1].slist), (yyvsp[0].stat)); ;}
2397  break;
2398 
2399  case 134:
2400 #line 417 "grammar.y"
2401  { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2402  DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
2403  break;
2404 
2405  case 135:
2406 #line 419 "grammar.y"
2407  { if (automatic()) {
2408  (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2409  DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
2410  } else {
2411  YYABORT;
2412  }
2413  ;}
2414  break;
2415 
2416  case 136:
2417 #line 429 "grammar.y"
2418  { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
2419  break;
2420 
2421  case 137:
2422 #line 431 "grammar.y"
2423  { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
2424  break;
2425 
2426  case 138:
2427 #line 435 "grammar.y"
2428  { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Variable); ;}
2429  break;
2430 
2431  case 139:
2432 #line 436 "grammar.y"
2433  { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Variable); ;}
2434  break;
2435 
2436  case 140:
2437 #line 440 "grammar.y"
2438  { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2439  DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
2440  break;
2441 
2442  case 141:
2443 #line 442 "grammar.y"
2444  { if (automatic()) {
2445  (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
2446  DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
2447  } else {
2448  YYABORT;
2449  }
2450  ;}
2451  break;
2452 
2453  case 142:
2454 #line 452 "grammar.y"
2455  { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
2456  break;
2457 
2458  case 143:
2459 #line 454 "grammar.y"
2460  { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
2461  break;
2462 
2463  case 144:
2464 #line 458 "grammar.y"
2465  { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Constant); ;}
2466  break;
2467 
2468  case 145:
2469 #line 459 "grammar.y"
2470  { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Constant); ;}
2471  break;
2472 
2473  case 146:
2474 #line 463 "grammar.y"
2475  { (yyval.init) = new AssignExprNode((yyvsp[0].node)); ;}
2476  break;
2477 
2478  case 147:
2479 #line 467 "grammar.y"
2480  { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
2481  break;
2482 
2483  case 148:
2484 #line 471 "grammar.y"
2485  { (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
2486  DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;}
2487  break;
2488 
2489  case 149:
2490 #line 473 "grammar.y"
2491  { if (automatic()) {
2492  (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
2493  DBG((yyval.stat), (yylsp[-1]), (yylsp[-1]));
2494  } else
2495  YYABORT; ;}
2496  break;
2497 
2498  case 150:
2499 #line 481 "grammar.y"
2500  { (yyval.stat) = new IfNode((yyvsp[-2].node),(yyvsp[0].stat),0);DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
2501  break;
2502 
2503  case 151:
2504 #line 483 "grammar.y"
2505  { (yyval.stat) = new IfNode((yyvsp[-4].node),(yyvsp[-2].stat),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-6]),(yylsp[-3])); ;}
2506  break;
2507 
2508  case 152:
2509 #line 487 "grammar.y"
2510  { (yyval.stat)=new DoWhileNode((yyvsp[-4].stat),(yyvsp[-1].node));DBG((yyval.stat),(yylsp[-5]),(yylsp[-3]));;}
2511  break;
2512 
2513  case 153:
2514 #line 488 "grammar.y"
2515  { (yyval.stat) = new WhileNode((yyvsp[-2].node),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
2516  break;
2517 
2518  case 154:
2519 #line 490 "grammar.y"
2520  { (yyval.stat) = new ForNode((yyvsp[-6].node),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
2521  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
2522  break;
2523 
2524  case 155:
2525 #line 493 "grammar.y"
2526  { (yyval.stat) = new ForNode((yyvsp[-6].vlist),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
2527  DBG((yyval.stat),(yylsp[-9]),(yylsp[-1])); ;}
2528  break;
2529 
2530  case 156:
2531 #line 496 "grammar.y"
2532  { (yyval.stat) = new ForInNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].stat));
2533  DBG((yyval.stat),(yylsp[-6]),(yylsp[-1])); ;}
2534  break;
2535 
2536  case 157:
2537 #line 499 "grammar.y"
2538  { (yyval.stat) = new ForInNode(*(yyvsp[-4].ident),0,(yyvsp[-2].node),(yyvsp[0].stat));
2539  DBG((yyval.stat),(yylsp[-7]),(yylsp[-1])); ;}
2540  break;
2541 
2542  case 158:
2543 #line 502 "grammar.y"
2544  { (yyval.stat) = new ForInNode(*(yyvsp[-5].ident),(yyvsp[-4].init),(yyvsp[-2].node),(yyvsp[0].stat));
2545  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
2546  break;
2547 
2548  case 159:
2549 #line 507 "grammar.y"
2550  { (yyval.node) = 0; ;}
2551  break;
2552 
2553  case 161:
2554 #line 512 "grammar.y"
2555  { (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2556  break;
2557 
2558  case 162:
2559 #line 513 "grammar.y"
2560  { if (automatic()) {
2561  (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0]));
2562  } else
2563  YYABORT; ;}
2564  break;
2565 
2566  case 163:
2567 #line 517 "grammar.y"
2568  { (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2569  break;
2570 
2571  case 164:
2572 #line 518 "grammar.y"
2573  { if (automatic()) {
2574  (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident));DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
2575  } else
2576  YYABORT; ;}
2577  break;
2578 
2579  case 165:
2580 #line 525 "grammar.y"
2581  { (yyval.stat) = new BreakNode();DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2582  break;
2583 
2584  case 166:
2585 #line 526 "grammar.y"
2586  { if (automatic()) {
2587  (yyval.stat) = new BreakNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
2588  } else
2589  YYABORT; ;}
2590  break;
2591 
2592  case 167:
2593 #line 530 "grammar.y"
2594  { (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2595  break;
2596 
2597  case 168:
2598 #line 531 "grammar.y"
2599  { if (automatic()) {
2600  (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
2601  } else
2602  YYABORT;
2603  ;}
2604  break;
2605 
2606  case 169:
2607 #line 539 "grammar.y"
2608  { (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
2609  break;
2610 
2611  case 170:
2612 #line 540 "grammar.y"
2613  { if (automatic()) {
2614  (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
2615  } else
2616  YYABORT; ;}
2617  break;
2618 
2619  case 171:
2620 #line 544 "grammar.y"
2621  { (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2622  break;
2623 
2624  case 172:
2625 #line 545 "grammar.y"
2626  { if (automatic()) {
2627  (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
2628  }
2629  else
2630  YYABORT; ;}
2631  break;
2632 
2633  case 173:
2634 #line 553 "grammar.y"
2635  { (yyval.stat) = new WithNode((yyvsp[-2].node),(yyvsp[0].stat));
2636  DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
2637  break;
2638 
2639  case 174:
2640 #line 558 "grammar.y"
2641  { (yyval.stat) = new SwitchNode((yyvsp[-2].node), (yyvsp[0].cblk));
2642  DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
2643  break;
2644 
2645  case 175:
2646 #line 563 "grammar.y"
2647  { (yyval.cblk) = new CaseBlockNode((yyvsp[-1].clist), 0, 0); ;}
2648  break;
2649 
2650  case 176:
2651 #line 565 "grammar.y"
2652  { (yyval.cblk) = new CaseBlockNode((yyvsp[-3].clist), (yyvsp[-2].ccl), (yyvsp[-1].clist)); ;}
2653  break;
2654 
2655  case 177:
2656 #line 569 "grammar.y"
2657  { (yyval.clist) = 0; ;}
2658  break;
2659 
2660  case 179:
2661 #line 574 "grammar.y"
2662  { (yyval.clist) = new ClauseListNode((yyvsp[0].ccl)); ;}
2663  break;
2664 
2665  case 180:
2666 #line 575 "grammar.y"
2667  { (yyval.clist) = new ClauseListNode((yyvsp[-1].clist), (yyvsp[0].ccl)); ;}
2668  break;
2669 
2670  case 181:
2671 #line 579 "grammar.y"
2672  { (yyval.ccl) = new CaseClauseNode((yyvsp[-1].node)); ;}
2673  break;
2674 
2675  case 182:
2676 #line 580 "grammar.y"
2677  { (yyval.ccl) = new CaseClauseNode((yyvsp[-2].node), (yyvsp[0].slist)); ;}
2678  break;
2679 
2680  case 183:
2681 #line 584 "grammar.y"
2682  { (yyval.ccl) = new CaseClauseNode(0); ;}
2683  break;
2684 
2685  case 184:
2686 #line 585 "grammar.y"
2687  { (yyval.ccl) = new CaseClauseNode(0, (yyvsp[0].slist)); ;}
2688  break;
2689 
2690  case 185:
2691 #line 589 "grammar.y"
2692  { (yyvsp[0].stat)->pushLabel(*(yyvsp[-2].ident));
2693  (yyval.stat) = new LabelNode(*(yyvsp[-2].ident), (yyvsp[0].stat)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); ;}
2694  break;
2695 
2696  case 186:
2697 #line 594 "grammar.y"
2698  { (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
2699  break;
2700 
2701  case 187:
2702 #line 595 "grammar.y"
2703  { if (automatic()) {
2704  (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
2705  } else {
2706  YYABORT; } ;}
2707  break;
2708 
2709  case 188:
2710 #line 602 "grammar.y"
2711  { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].cnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
2712  break;
2713 
2714  case 189:
2715 #line 603 "grammar.y"
2716  { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
2717  break;
2718 
2719  case 190:
2720 #line 604 "grammar.y"
2721  { (yyval.stat) = new TryNode((yyvsp[-2].stat), (yyvsp[-1].cnode), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-3]),(yylsp[-3])); ;}
2722  break;
2723 
2724  case 191:
2725 #line 608 "grammar.y"
2726  { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;}
2727  break;
2728 
2729  case 192:
2730 #line 609 "grammar.y"
2731  { if (automatic()) {
2732  (yyval.stat) = new EmptyStatementNode();
2733  DBG((yyval.stat), (yylsp[-1]), (yylsp[-1]));
2734  } else {
2735  YYABORT; } ;}
2736  break;
2737 
2738  case 193:
2739 #line 618 "grammar.y"
2740  { CatchNode *c; (yyval.cnode) = c = new CatchNode(*(yyvsp[-2].ident), (yyvsp[0].stat));
2741  DBG(c,(yylsp[-4]),(yylsp[-1])); ;}
2742  break;
2743 
2744  case 194:
2745 #line 623 "grammar.y"
2746  { FinallyNode *f; (yyval.fnode) = f = new FinallyNode((yyvsp[0].stat)); DBG(f,(yylsp[-1]),(yylsp[-1])); ;}
2747  break;
2748 
2749  case 196:
2750 #line 629 "grammar.y"
2751  { (yyval.func) = (yyvsp[0].func); ;}
2752  break;
2753 
2754  case 197:
2755 #line 633 "grammar.y"
2756  { (yyval.func) = new FuncDeclNode(*(yyvsp[-3].ident), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-4]),(yylsp[-1])); ;}
2757  break;
2758 
2759  case 198:
2760 #line 635 "grammar.y"
2761  { (yyval.func) = new FuncDeclNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-5]),(yylsp[-1])); ;}
2762  break;
2763 
2764  case 199:
2765 #line 640 "grammar.y"
2766  { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[0].body)); ;}
2767  break;
2768 
2769  case 200:
2770 #line 642 "grammar.y"
2771  { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[-2].param), (yyvsp[0].body)); ;}
2772  break;
2773 
2774  case 201:
2775 #line 644 "grammar.y"
2776  { (yyval.node) = new FuncExprNode(*(yyvsp[-3].ident), (yyvsp[0].body)); ;}
2777  break;
2778 
2779  case 202:
2780 #line 646 "grammar.y"
2781  { (yyval.node) = new FuncExprNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); ;}
2782  break;
2783 
2784  case 203:
2785 #line 650 "grammar.y"
2786  { (yyval.param) = new ParameterNode(*(yyvsp[0].ident)); ;}
2787  break;
2788 
2789  case 204:
2790 #line 651 "grammar.y"
2791  { (yyval.param) = new ParameterNode((yyvsp[-2].param), *(yyvsp[0].ident)); ;}
2792  break;
2793 
2794  case 205:
2795 #line 655 "grammar.y"
2796  { (yyval.body) = new FunctionBodyNode(0);
2797  DBG((yyval.body), (yylsp[-1]), (yylsp[0]));;}
2798  break;
2799 
2800  case 206:
2801 #line 657 "grammar.y"
2802  { (yyval.body) = new FunctionBodyNode((yyvsp[-1].srcs));
2803  DBG((yyval.body), (yylsp[-2]), (yylsp[0]));;}
2804  break;
2805 
2806  case 207:
2807 #line 662 "grammar.y"
2808  { (yyval.prog) = new FunctionBodyNode(0);
2809  (yyval.prog)->setLoc(0, 0, Parser::source);
2810  Parser::progNode = (yyval.prog); ;}
2811  break;
2812 
2813  case 208:
2814 #line 665 "grammar.y"
2815  { (yyval.prog) = new FunctionBodyNode((yyvsp[0].srcs));
2816  Parser::progNode = (yyval.prog); ;}
2817  break;
2818 
2819  case 209:
2820 #line 670 "grammar.y"
2821  { (yyval.srcs) = new SourceElementsNode((yyvsp[0].stat)); ;}
2822  break;
2823 
2824  case 210:
2825 #line 671 "grammar.y"
2826  { (yyval.srcs) = new SourceElementsNode((yyvsp[-1].srcs), (yyvsp[0].stat)); ;}
2827  break;
2828 
2829  case 211:
2830 #line 675 "grammar.y"
2831  { (yyval.stat) = (yyvsp[0].stat); ;}
2832  break;
2833 
2834  case 212:
2835 #line 676 "grammar.y"
2836  { (yyval.stat) = (yyvsp[0].func); ;}
2837  break;
2838 
2839 
2840  default: break;
2841  }
2842 
2843 /* Line 1126 of yacc.c. */
2844 #line 2843 "grammar.tab.c"
2845 ␌
2846  yyvsp -= yylen;
2847  yyssp -= yylen;
2848  yylsp -= yylen;
2849 
2850  YY_STACK_PRINT (yyss, yyssp);
2851 
2852  *++yyvsp = yyval;
2853  *++yylsp = yyloc;
2854 
2855  /* Now `shift' the result of the reduction. Determine what state
2856  that goes to, based on the state we popped back to and the rule
2857  number reduced by. */
2858 
2859  yyn = yyr1[yyn];
2860 
2861  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2862  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2863  yystate = yytable[yystate];
2864  else
2865  yystate = yydefgoto[yyn - YYNTOKENS];
2866 
2867  goto yynewstate;
2868 
2869 
2870 /*------------------------------------.
2871 | yyerrlab -- here on detecting error |
2872 `------------------------------------*/
2873 yyerrlab:
2874  /* If not already recovering from an error, report this error. */
2875  if (!yyerrstatus)
2876  {
2877  ++yynerrs;
2878 #if YYERROR_VERBOSE
2879  yyn = yypact[yystate];
2880 
2881  if (YYPACT_NINF < yyn && yyn < YYLAST)
2882  {
2883  int yytype = YYTRANSLATE (yychar);
2884  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2885  YYSIZE_T yysize = yysize0;
2886  YYSIZE_T yysize1;
2887  int yysize_overflow = 0;
2888  char *yymsg = 0;
2889 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
2890  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2891  int yyx;
2892 
2893 #if 0
2894  /* This is so xgettext sees the translatable formats that are
2895  constructed on the fly. */
2896  YY_("syntax error, unexpected %s");
2897  YY_("syntax error, unexpected %s, expecting %s");
2898  YY_("syntax error, unexpected %s, expecting %s or %s");
2899  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2900  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2901 #endif
2902  char *yyfmt;
2903  char const *yyf;
2904  static char const yyunexpected[] = "syntax error, unexpected %s";
2905  static char const yyexpecting[] = ", expecting %s";
2906  static char const yyor[] = " or %s";
2907  char yyformat[sizeof yyunexpected
2908  + sizeof yyexpecting - 1
2909  + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2910  * (sizeof yyor - 1))];
2911  char const *yyprefix = yyexpecting;
2912 
2913  /* Start YYX at -YYN if negative to avoid negative indexes in
2914  YYCHECK. */
2915  int yyxbegin = yyn < 0 ? -yyn : 0;
2916 
2917  /* Stay within bounds of both yycheck and yytname. */
2918  int yychecklim = YYLAST - yyn;
2919  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2920  int yycount = 1;
2921 
2922  yyarg[0] = yytname[yytype];
2923  yyfmt = yystpcpy (yyformat, yyunexpected);
2924 
2925  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2926  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2927  {
2928  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2929  {
2930  yycount = 1;
2931  yysize = yysize0;
2932  yyformat[sizeof yyunexpected - 1] = '\0';
2933  break;
2934  }
2935  yyarg[yycount++] = yytname[yyx];
2936  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2937  yysize_overflow |= yysize1 < yysize;
2938  yysize = yysize1;
2939  yyfmt = yystpcpy (yyfmt, yyprefix);
2940  yyprefix = yyor;
2941  }
2942 
2943  yyf = YY_(yyformat);
2944  yysize1 = yysize + yystrlen (yyf);
2945  yysize_overflow |= yysize1 < yysize;
2946  yysize = yysize1;
2947 
2948  if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
2949  yymsg = (char *) YYSTACK_ALLOC (yysize);
2950  if (yymsg)
2951  {
2952  /* Avoid sprintf, as that infringes on the user's name space.
2953  Don't have undefined behavior even if the translation
2954  produced a string with the wrong number of "%s"s. */
2955  char *yyp = yymsg;
2956  int yyi = 0;
2957  while ((*yyp = *yyf))
2958  {
2959  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2960  {
2961  yyp += yytnamerr (yyp, yyarg[yyi++]);
2962  yyf += 2;
2963  }
2964  else
2965  {
2966  yyp++;
2967  yyf++;
2968  }
2969  }
2970  yyerror (yymsg);
2971  YYSTACK_FREE (yymsg);
2972  }
2973  else
2974  {
2975  yyerror (YY_("syntax error"));
2976  goto yyexhaustedlab;
2977  }
2978  }
2979  else
2980 #endif /* YYERROR_VERBOSE */
2981  yyerror (YY_("syntax error"));
2982  }
2983 
2984  yyerror_range[0] = yylloc;
2985 
2986  if (yyerrstatus == 3)
2987  {
2988  /* If just tried and failed to reuse look-ahead token after an
2989  error, discard it. */
2990 
2991  if (yychar <= YYEOF)
2992  {
2993  /* Return failure if at end of input. */
2994  if (yychar == YYEOF)
2995  YYABORT;
2996  }
2997  else
2998  {
2999  yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
3000  yychar = YYEMPTY;
3001  }
3002  }
3003 
3004  /* Else will try to reuse look-ahead token after shifting the error
3005  token. */
3006  goto yyerrlab1;
3007 
3008 
3009 /*---------------------------------------------------.
3010 | yyerrorlab -- error raised explicitly by YYERROR. |
3011 `---------------------------------------------------*/
3012 yyerrorlab:
3013 
3014  /* Pacify compilers like GCC when the user code never invokes
3015  YYERROR and the label yyerrorlab therefore never appears in user
3016  code. */
3017  if (0)
3018  goto yyerrorlab;
3019 
3020  yyerror_range[0] = yylsp[1-yylen];
3021  yylsp -= yylen;
3022  yyvsp -= yylen;
3023  yyssp -= yylen;
3024  yystate = *yyssp;
3025  goto yyerrlab1;
3026 
3027 
3028 /*-------------------------------------------------------------.
3029 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3030 `-------------------------------------------------------------*/
3031 yyerrlab1:
3032  yyerrstatus = 3; /* Each real token shifted decrements this. */
3033 
3034  for (;;)
3035  {
3036  yyn = yypact[yystate];
3037  if (yyn != YYPACT_NINF)
3038  {
3039  yyn += YYTERROR;
3040  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3041  {
3042  yyn = yytable[yyn];
3043  if (0 < yyn)
3044  break;
3045  }
3046  }
3047 
3048  /* Pop the current state because it cannot handle the error token. */
3049  if (yyssp == yyss)
3050  YYABORT;
3051 
3052  yyerror_range[0] = *yylsp;
3053  yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
3054  YYPOPSTACK;
3055  yystate = *yyssp;
3056  YY_STACK_PRINT (yyss, yyssp);
3057  }
3058 
3059  if (yyn == YYFINAL)
3060  YYACCEPT;
3061 
3062  *++yyvsp = yylval;
3063 
3064  yyerror_range[1] = yylloc;
3065  /* Using YYLLOC is tempting, but would change the location of
3066  the look-ahead. YYLOC is available though. */
3067  YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
3068  *++yylsp = yyloc;
3069 
3070  /* Shift the error token. */
3071  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3072 
3073  yystate = yyn;
3074  goto yynewstate;
3075 
3076 
3077 /*-------------------------------------.
3078 | yyacceptlab -- YYACCEPT comes here. |
3079 `-------------------------------------*/
3080 yyacceptlab:
3081  yyresult = 0;
3082  goto yyreturn;
3083 
3084 /*-----------------------------------.
3085 | yyabortlab -- YYABORT comes here. |
3086 `-----------------------------------*/
3087 yyabortlab:
3088  yyresult = 1;
3089  goto yyreturn;
3090 
3091 #ifndef yyoverflow
3092 /*-------------------------------------------------.
3093 | yyexhaustedlab -- memory exhaustion comes here. |
3094 `-------------------------------------------------*/
3095 yyexhaustedlab:
3096  yyerror (YY_("memory exhausted"));
3097  yyresult = 2;
3098  /* Fall through. */
3099 #endif
3100 
3101 yyreturn:
3102  if (yychar != YYEOF && yychar != YYEMPTY)
3103  yydestruct ("Cleanup: discarding lookahead",
3104  yytoken, &yylval, &yylloc);
3105  while (yyssp != yyss)
3106  {
3107  yydestruct ("Cleanup: popping",
3108  yystos[*yyssp], yyvsp, yylsp);
3109  YYPOPSTACK;
3110  }
3111 #ifndef yyoverflow
3112  if (yyss != yyssa)
3113  YYSTACK_FREE (yyss);
3114 #endif
3115  return yyresult;
3116 }
3117 
3118 
3119 #line 679 "grammar.y"
3120 
3121 
3122 int yyerror (const char * /* s */) /* Called by yyparse on error */
3123 {
3124  // fprintf(stderr, "ERROR: %s at line %d\n",
3125  // s, KJS::Lexer::curr()->lineNo());
3126  return 1;
3127 }
3128 
3129 /* may we automatically insert a semicolon ? */
3130 bool automatic()
3131 {
3132  if (Lexer::curr()->hadError())
3133  return false;
3134  if (yychar == '}' || yychar == 0)
3135  return true;
3136  else if (Lexer::curr()->prevTerminator())
3137  return true;
3138 
3139  return false;
3140 }
3141 
KJS::BinaryLogicalNode
expr1 && expr2, expr1 || expr2
Definition: nodes.h:598
KJS::ConditionalNode
The ternary operator, "logical ? expr1 : expr2".
Definition: nodes.h:614
KJS::Identifier
Represents an Identifier for a Javascript object.
Definition: identifier.h:32
KJS::Identifier::null
static const Identifier & null()
Creates an empty Identifier.
Definition: identifier.cpp:302
KJS::UString
Unicode string class.
Definition: ustring.h:189

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.9.1
This website is maintained by Timothy Pearson.