grammar.cpp
00001 /* A Bison parser, made by GNU Bison 2.1. */ 00002 00003 /* Skeleton parser for Yacc-like parsing with Bison, 00004 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 00005 00006 This program is free software; you can redistribute it and/or modify 00007 it under the terms of the GNU General Public License as published by 00008 the Free Software Foundation; either version 2, or (at your option) 00009 any later version. 00010 00011 This program is distributed in the hope that it will be useful, 00012 but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 GNU General Public License for more details. 00015 00016 You should have received a copy of the GNU General Public License 00017 along with this program; if not, write to the Free Software 00018 Foundation, Inc., 51 Franklin Street, Fifth Floor, 00019 Boston, MA 02110-1301, USA. */ 00020 00021 /* As a special exception, when this file is copied by Bison into a 00022 Bison output file, you may use that output file without restriction. 00023 This special exception was added by the Free Software Foundation 00024 in version 1.24 of Bison. */ 00025 00026 /* Written by Richard Stallman by simplifying the original so called 00027 ``semantic'' parser. */ 00028 00029 /* All symbols defined below should begin with yy or YY, to avoid 00030 infringing on user name space. This should be done even for local 00031 variables, as they might otherwise be expanded by user macros. 00032 There are some unavoidable exceptions within include files to 00033 define necessary library symbols; they are noted "INFRINGES ON 00034 USER NAME SPACE" below. */ 00035 00036 /* Identify Bison output. */ 00037 #define YYBISON 1 00038 00039 /* Bison version. */ 00040 #define YYBISON_VERSION "2.1" 00041 00042 /* Skeleton name. */ 00043 #define YYSKELETON_NAME "yacc.c" 00044 00045 /* Pure parsers. */ 00046 #define YYPURE 0 00047 00048 /* Using locations. */ 00049 #define YYLSP_NEEDED 1 00050 00051 /* Substitute the variable and function names. */ 00052 #define yyparse kjsyyparse 00053 #define yylex kjsyylex 00054 #define yyerror kjsyyerror 00055 #define yylval kjsyylval 00056 #define yychar kjsyychar 00057 #define yydebug kjsyydebug 00058 #define yynerrs kjsyynerrs 00059 #define yylloc kjsyylloc 00060 00061 /* Tokens. */ 00062 #ifndef YYTOKENTYPE 00063 # define YYTOKENTYPE 00064 /* Put the tokens into the symbol table, so that GDB and other debuggers 00065 know about them. */ 00066 enum yytokentype { 00067 NULLTOKEN = 258, 00068 TRUETOKEN = 259, 00069 FALSETOKEN = 260, 00070 STRING = 261, 00071 NUMBER = 262, 00072 BREAK = 263, 00073 CASE = 264, 00074 DEFAULT = 265, 00075 FOR = 266, 00076 NEW = 267, 00077 VAR = 268, 00078 CONST = 269, 00079 CONTINUE = 270, 00080 FUNCTION = 271, 00081 RETURN = 272, 00082 VOID = 273, 00083 DELETE = 274, 00084 IF = 275, 00085 THIS = 276, 00086 DO = 277, 00087 WHILE = 278, 00088 ELSE = 279, 00089 IN = 280, 00090 INSTANCEOF = 281, 00091 TYPEOF = 282, 00092 SWITCH = 283, 00093 WITH = 284, 00094 RESERVED = 285, 00095 THROW = 286, 00096 TRY = 287, 00097 CATCH = 288, 00098 FINALLY = 289, 00099 DEBUGGER = 290, 00100 EQEQ = 291, 00101 NE = 292, 00102 STREQ = 293, 00103 STRNEQ = 294, 00104 LE = 295, 00105 GE = 296, 00106 OR = 297, 00107 AND = 298, 00108 PLUSPLUS = 299, 00109 MINUSMINUS = 300, 00110 LSHIFT = 301, 00111 RSHIFT = 302, 00112 URSHIFT = 303, 00113 PLUSEQUAL = 304, 00114 MINUSEQUAL = 305, 00115 MULTEQUAL = 306, 00116 DIVEQUAL = 307, 00117 LSHIFTEQUAL = 308, 00118 RSHIFTEQUAL = 309, 00119 URSHIFTEQUAL = 310, 00120 ANDEQUAL = 311, 00121 MODEQUAL = 312, 00122 XOREQUAL = 313, 00123 OREQUAL = 314, 00124 IDENT = 315, 00125 FUNCEXPRIDENT = 316, 00126 AUTOPLUSPLUS = 317, 00127 AUTOMINUSMINUS = 318 00128 }; 00129 #endif 00130 /* Tokens. */ 00131 #define NULLTOKEN 258 00132 #define TRUETOKEN 259 00133 #define FALSETOKEN 260 00134 #define STRING 261 00135 #define NUMBER 262 00136 #define BREAK 263 00137 #define CASE 264 00138 #define DEFAULT 265 00139 #define FOR 266 00140 #define NEW 267 00141 #define VAR 268 00142 #define CONST 269 00143 #define CONTINUE 270 00144 #define FUNCTION 271 00145 #define RETURN 272 00146 #define VOID 273 00147 #define DELETE 274 00148 #define IF 275 00149 #define THIS 276 00150 #define DO 277 00151 #define WHILE 278 00152 #define ELSE 279 00153 #define IN 280 00154 #define INSTANCEOF 281 00155 #define TYPEOF 282 00156 #define SWITCH 283 00157 #define WITH 284 00158 #define RESERVED 285 00159 #define THROW 286 00160 #define TRY 287 00161 #define CATCH 288 00162 #define FINALLY 289 00163 #define DEBUGGER 290 00164 #define EQEQ 291 00165 #define NE 292 00166 #define STREQ 293 00167 #define STRNEQ 294 00168 #define LE 295 00169 #define GE 296 00170 #define OR 297 00171 #define AND 298 00172 #define PLUSPLUS 299 00173 #define MINUSMINUS 300 00174 #define LSHIFT 301 00175 #define RSHIFT 302 00176 #define URSHIFT 303 00177 #define PLUSEQUAL 304 00178 #define MINUSEQUAL 305 00179 #define MULTEQUAL 306 00180 #define DIVEQUAL 307 00181 #define LSHIFTEQUAL 308 00182 #define RSHIFTEQUAL 309 00183 #define URSHIFTEQUAL 310 00184 #define ANDEQUAL 311 00185 #define MODEQUAL 312 00186 #define XOREQUAL 313 00187 #define OREQUAL 314 00188 #define IDENT 315 00189 #define FUNCEXPRIDENT 316 00190 #define AUTOPLUSPLUS 317 00191 #define AUTOMINUSMINUS 318 00192 00193 00194 00195 00196 /* Copy the first part of user declarations. */ 00197 #line 1 "grammar.y" 00198 00199 00200 /* 00201 * This file is part of the KDE libraries 00202 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) 00203 * 00204 * This library is free software; you can redistribute it and/or 00205 * modify it under the terms of the GNU Lesser General Public 00206 * License as published by the Free Software Foundation; either 00207 * version 2 of the License, or (at your option) any later version. 00208 * 00209 * This library is distributed in the hope that it will be useful, 00210 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00211 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00212 * Lesser General Public License for more details. 00213 * 00214 * You should have received a copy of the GNU Lesser General Public 00215 * License along with this library; if not, write to the Free Software 00216 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00217 * 00218 */ 00219 00220 #ifdef HAVE_CONFIG_H 00221 #include <config.h> 00222 #endif 00223 #include <string.h> 00224 #include <stdlib.h> 00225 #include "value.h" 00226 #include "object.h" 00227 #include "types.h" 00228 #include "interpreter.h" 00229 #include "nodes.h" 00230 #include "lexer.h" 00231 #include "internal.h" 00232 00233 /* default values for bison */ 00234 #define YYDEBUG 0 00235 #ifdef YYMAXDEPTH 00236 #undef YYMAXDEPTH 00237 #endif 00238 #define YYERROR_VERBOSE 00239 #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::source); } // location 00240 00241 extern int yylex(); 00242 static int yyerror (const char *); 00243 static bool automatic(); 00244 00245 using namespace KJS; 00246 00247 00248 00249 /* Enabling traces. */ 00250 #ifndef YYDEBUG 00251 # define YYDEBUG 0 00252 #endif 00253 00254 /* Enabling verbose error messages. */ 00255 #ifdef YYERROR_VERBOSE 00256 # undef YYERROR_VERBOSE 00257 # define YYERROR_VERBOSE 1 00258 #else 00259 # define YYERROR_VERBOSE 0 00260 #endif 00261 00262 /* Enabling the token table. */ 00263 #ifndef YYTOKEN_TABLE 00264 # define YYTOKEN_TABLE 0 00265 #endif 00266 00267 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 00268 #line 52 "grammar.y" 00269 typedef union YYSTYPE { 00270 int ival; 00271 double dval; 00272 UString *ustr; 00273 Identifier *ident; 00274 Node *node; 00275 StatementNode *stat; 00276 ParameterNode *param; 00277 FunctionBodyNode *body; 00278 FuncDeclNode *func; 00279 FunctionBodyNode *prog; 00280 AssignExprNode *init; 00281 SourceElementsNode *srcs; 00282 StatListNode *slist; 00283 ArgumentsNode *args; 00284 ArgumentListNode *alist; 00285 VarDeclNode *decl; 00286 VarDeclListNode *vlist; 00287 CaseBlockNode *cblk; 00288 ClauseListNode *clist; 00289 CaseClauseNode *ccl; 00290 ElementNode *elm; 00291 Operator op; 00292 PropertyValueNode *plist; 00293 PropertyNode *pnode; 00294 CatchNode *cnode; 00295 FinallyNode *fnode; 00296 } YYSTYPE; 00297 /* Line 196 of yacc.c. */ 00298 #line 299 "grammar.tab.c" 00299 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00300 # define YYSTYPE_IS_DECLARED 1 00301 # define YYSTYPE_IS_TRIVIAL 1 00302 #endif 00303 00304 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) 00305 typedef struct YYLTYPE 00306 { 00307 int first_line; 00308 int first_column; 00309 int last_line; 00310 int last_column; 00311 } YYLTYPE; 00312 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ 00313 # define YYLTYPE_IS_DECLARED 1 00314 # define YYLTYPE_IS_TRIVIAL 1 00315 #endif 00316 00317 00318 /* Copy the second part of user declarations. */ 00319 00320 00321 /* Line 219 of yacc.c. */ 00322 #line 323 "grammar.tab.c" 00323 00324 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 00325 # define YYSIZE_T __SIZE_TYPE__ 00326 #endif 00327 #if ! defined (YYSIZE_T) && defined (size_t) 00328 # define YYSIZE_T size_t 00329 #endif 00330 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus)) 00331 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00332 # define YYSIZE_T size_t 00333 #endif 00334 #if ! defined (YYSIZE_T) 00335 # define YYSIZE_T unsigned int 00336 #endif 00337 00338 #ifndef YY_ 00339 # if YYENABLE_NLS 00340 # if ENABLE_NLS 00341 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00342 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00343 # endif 00344 # endif 00345 # ifndef YY_ 00346 # define YY_(msgid) msgid 00347 # endif 00348 #endif 00349 00350 #if ! defined (yyoverflow) || YYERROR_VERBOSE 00351 00352 /* The parser invokes alloca or malloc; define the necessary symbols. */ 00353 00354 # ifdef YYSTACK_USE_ALLOCA 00355 # if YYSTACK_USE_ALLOCA 00356 # ifdef __GNUC__ 00357 # define YYSTACK_ALLOC __builtin_alloca 00358 # else 00359 # define YYSTACK_ALLOC alloca 00360 # if defined (__STDC__) || defined (__cplusplus) 00361 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00362 # define YYINCLUDED_STDLIB_H 00363 # endif 00364 # endif 00365 # endif 00366 # endif 00367 00368 # ifdef YYSTACK_ALLOC 00369 /* Pacify GCC's `empty if-body' warning. */ 00370 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 00371 # ifndef YYSTACK_ALLOC_MAXIMUM 00372 /* The OS might guarantee only one guard page at the bottom of the stack, 00373 and a page size can be as small as 4096 bytes. So we cannot safely 00374 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 00375 to allow for a few compiler-allocated temporary stack slots. */ 00376 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */ 00377 # endif 00378 # else 00379 # define YYSTACK_ALLOC YYMALLOC 00380 # define YYSTACK_FREE YYFREE 00381 # ifndef YYSTACK_ALLOC_MAXIMUM 00382 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1) 00383 # endif 00384 # ifdef __cplusplus 00385 extern "C" { 00386 # endif 00387 # ifndef YYMALLOC 00388 # define YYMALLOC malloc 00389 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \ 00390 && (defined (__STDC__) || defined (__cplusplus))) 00391 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 00392 # endif 00393 # endif 00394 # ifndef YYFREE 00395 # define YYFREE free 00396 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \ 00397 && (defined (__STDC__) || defined (__cplusplus))) 00398 void free (void *); /* INFRINGES ON USER NAME SPACE */ 00399 # endif 00400 # endif 00401 # ifdef __cplusplus 00402 } 00403 # endif 00404 # endif 00405 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 00406 00407 00408 #if (! defined (yyoverflow) \ 00409 && (! defined (__cplusplus) \ 00410 || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ 00411 && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 00412 00413 /* A type that is properly aligned for any stack member. */ 00414 union yyalloc 00415 { 00416 short int yyss; 00417 YYSTYPE yyvs; 00418 YYLTYPE yyls; 00419 }; 00420 00421 /* The size of the maximum gap between one aligned stack and the next. */ 00422 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 00423 00424 /* The size of an array large to enough to hold all stacks, each with 00425 N elements. */ 00426 # define YYSTACK_BYTES(N) \ 00427 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ 00428 + 2 * YYSTACK_GAP_MAXIMUM) 00429 00430 /* Copy COUNT objects from FROM to TO. The source and destination do 00431 not overlap. */ 00432 # ifndef YYCOPY 00433 # if defined (__GNUC__) && 1 < __GNUC__ 00434 # define YYCOPY(To, From, Count) \ 00435 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 00436 # else 00437 # define YYCOPY(To, From, Count) \ 00438 do \ 00439 { \ 00440 YYSIZE_T yyi; \ 00441 for (yyi = 0; yyi < (Count); yyi++) \ 00442 (To)[yyi] = (From)[yyi]; \ 00443 } \ 00444 while (0) 00445 # endif 00446 # endif 00447 00448 /* Relocate STACK from its old location to the new one. The 00449 local variables YYSIZE and YYSTACKSIZE give the old and new number of 00450 elements in the stack, and YYPTR gives the new location of the 00451 stack. Advance YYPTR to a properly aligned location for the next 00452 stack. */ 00453 # define YYSTACK_RELOCATE(Stack) \ 00454 do \ 00455 { \ 00456 YYSIZE_T yynewbytes; \ 00457 YYCOPY (&yyptr->Stack, Stack, yysize); \ 00458 Stack = &yyptr->Stack; \ 00459 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 00460 yyptr += yynewbytes / sizeof (*yyptr); \ 00461 } \ 00462 while (0) 00463 00464 #endif 00465 00466 #if defined (__STDC__) || defined (__cplusplus) 00467 typedef signed char yysigned_char; 00468 #else 00469 typedef short int yysigned_char; 00470 #endif 00471 00472 /* YYFINAL -- State number of the termination state. */ 00473 #define YYFINAL 196 00474 /* YYLAST -- Last index in YYTABLE. */ 00475 #define YYLAST 1472 00476 00477 /* YYNTOKENS -- Number of terminals. */ 00478 #define YYNTOKENS 88 00479 /* YYNNTS -- Number of nonterminals. */ 00480 #define YYNNTS 70 00481 /* YYNRULES -- Number of rules. */ 00482 #define YYNRULES 212 00483 /* YYNRULES -- Number of states. */ 00484 #define YYNSTATES 384 00485 00486 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 00487 #define YYUNDEFTOK 2 00488 #define YYMAXUTOK 318 00489 00490 #define YYTRANSLATE(YYX) \ 00491 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 00492 00493 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 00494 static const unsigned char yytranslate[] = 00495 { 00496 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00499 2, 2, 2, 77, 2, 2, 2, 79, 82, 2, 00500 65, 66, 78, 74, 69, 75, 73, 64, 2, 2, 00501 2, 2, 2, 2, 2, 2, 2, 2, 72, 87, 00502 80, 86, 81, 85, 2, 2, 2, 2, 2, 2, 00503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00505 2, 70, 2, 71, 83, 2, 2, 2, 2, 2, 00506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00507 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00508 2, 2, 2, 67, 84, 68, 76, 2, 2, 2, 00509 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00512 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00521 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 00522 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 00523 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 00524 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 00525 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 00526 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 00527 55, 56, 57, 58, 59, 60, 61, 62, 63 00528 }; 00529 00530 #if YYDEBUG 00531 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 00532 YYRHS. */ 00533 static const unsigned short int yyprhs[] = 00534 { 00535 0, 0, 3, 5, 7, 9, 11, 13, 15, 17, 00536 19, 21, 23, 25, 29, 32, 36, 41, 45, 49, 00537 55, 58, 63, 64, 66, 68, 71, 75, 81, 83, 00538 85, 87, 89, 91, 96, 100, 104, 106, 109, 112, 00539 115, 120, 124, 127, 131, 133, 137, 139, 141, 143, 00540 146, 149, 151, 154, 157, 160, 163, 166, 169, 172, 00541 175, 178, 181, 184, 186, 190, 194, 198, 200, 204, 00542 208, 210, 214, 218, 222, 224, 228, 232, 236, 240, 00543 244, 248, 250, 254, 258, 262, 266, 268, 272, 274, 00544 278, 280, 284, 286, 290, 292, 296, 298, 304, 306, 00545 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 00546 330, 332, 334, 336, 340, 342, 344, 346, 348, 350, 00547 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 00548 372, 375, 379, 381, 384, 388, 392, 394, 398, 400, 00549 403, 407, 411, 413, 417, 419, 422, 425, 427, 430, 00550 433, 439, 447, 454, 460, 470, 481, 489, 498, 508, 00551 509, 511, 514, 517, 521, 525, 528, 531, 535, 539, 00552 542, 545, 549, 553, 559, 565, 569, 575, 576, 578, 00553 580, 583, 587, 592, 595, 599, 603, 607, 611, 615, 00554 619, 624, 627, 630, 636, 639, 641, 644, 650, 657, 00555 662, 668, 674, 681, 683, 687, 690, 694, 695, 697, 00556 699, 702, 704 00557 }; 00558 00559 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 00560 static const short int yyrhs[] = 00561 { 00562 155, 0, -1, 3, -1, 4, -1, 5, -1, 7, 00563 -1, 6, -1, 64, -1, 52, -1, 21, -1, 60, 00564 -1, 89, -1, 91, -1, 65, 118, 66, -1, 67, 00565 68, -1, 67, 95, 68, -1, 67, 95, 69, 68, 00566 -1, 70, 93, 71, -1, 70, 92, 71, -1, 70, 00567 92, 69, 93, 71, -1, 93, 116, -1, 92, 69, 00568 93, 116, -1, -1, 94, -1, 69, -1, 94, 69, 00569 -1, 96, 72, 116, -1, 95, 69, 96, 72, 116, 00570 -1, 60, -1, 6, -1, 7, -1, 90, -1, 152, 00571 -1, 97, 70, 118, 71, -1, 97, 73, 60, -1, 00572 12, 97, 100, -1, 97, -1, 12, 98, -1, 97, 00573 100, -1, 99, 100, -1, 99, 70, 118, 71, -1, 00574 99, 73, 60, -1, 65, 66, -1, 65, 101, 66, 00575 -1, 116, -1, 101, 69, 116, -1, 98, -1, 99, 00576 -1, 102, -1, 102, 44, -1, 102, 45, -1, 103, 00577 -1, 19, 104, -1, 18, 104, -1, 27, 104, -1, 00578 44, 104, -1, 62, 104, -1, 45, 104, -1, 63, 00579 104, -1, 74, 104, -1, 75, 104, -1, 76, 104, 00580 -1, 77, 104, -1, 104, -1, 105, 78, 104, -1, 00581 105, 64, 104, -1, 105, 79, 104, -1, 105, -1, 00582 106, 74, 105, -1, 106, 75, 105, -1, 106, -1, 00583 107, 46, 106, -1, 107, 47, 106, -1, 107, 48, 00584 106, -1, 107, -1, 108, 80, 107, -1, 108, 81, 00585 107, -1, 108, 40, 107, -1, 108, 41, 107, -1, 00586 108, 26, 107, -1, 108, 25, 107, -1, 108, -1, 00587 109, 36, 108, -1, 109, 37, 108, -1, 109, 38, 00588 108, -1, 109, 39, 108, -1, 109, -1, 110, 82, 00589 109, -1, 110, -1, 111, 83, 110, -1, 111, -1, 00590 112, 84, 111, -1, 112, -1, 113, 43, 112, -1, 00591 113, -1, 114, 42, 113, -1, 114, -1, 114, 85, 00592 116, 72, 116, -1, 115, -1, 102, 117, 116, -1, 00593 86, -1, 49, -1, 50, -1, 51, -1, 52, -1, 00594 53, -1, 54, -1, 55, -1, 56, -1, 58, -1, 00595 59, -1, 57, -1, 116, -1, 118, 69, 116, -1, 00596 120, -1, 122, -1, 125, -1, 129, -1, 130, -1, 00597 131, -1, 132, -1, 134, -1, 135, -1, 136, -1, 00598 137, -1, 138, -1, 144, -1, 145, -1, 146, -1, 00599 147, -1, 67, 68, -1, 67, 156, 68, -1, 119, 00600 -1, 121, 119, -1, 13, 123, 87, -1, 13, 123, 00601 1, -1, 124, -1, 123, 69, 124, -1, 60, -1, 00602 60, 128, -1, 14, 126, 87, -1, 14, 126, 1, 00603 -1, 127, -1, 126, 69, 124, -1, 60, -1, 60, 00604 128, -1, 86, 116, -1, 87, -1, 118, 87, -1, 00605 118, 1, -1, 20, 65, 118, 66, 119, -1, 20, 00606 65, 118, 66, 119, 24, 119, -1, 22, 119, 23, 00607 65, 118, 66, -1, 23, 65, 118, 66, 119, -1, 00608 11, 65, 133, 87, 133, 87, 133, 66, 119, -1, 00609 11, 65, 13, 123, 87, 133, 87, 133, 66, 119, 00610 -1, 11, 65, 102, 25, 118, 66, 119, -1, 11, 00611 65, 13, 60, 25, 118, 66, 119, -1, 11, 65, 00612 13, 60, 128, 25, 118, 66, 119, -1, -1, 118, 00613 -1, 15, 87, -1, 15, 1, -1, 15, 60, 87, 00614 -1, 15, 60, 1, -1, 8, 87, -1, 8, 1, 00615 -1, 8, 60, 87, -1, 8, 60, 1, -1, 17, 00616 87, -1, 17, 1, -1, 17, 118, 87, -1, 17, 00617 118, 1, -1, 29, 65, 118, 66, 119, -1, 28, 00618 65, 118, 66, 139, -1, 67, 140, 68, -1, 67, 00619 140, 143, 140, 68, -1, -1, 141, -1, 142, -1, 00620 141, 142, -1, 9, 118, 72, -1, 9, 118, 72, 00621 121, -1, 10, 72, -1, 10, 72, 121, -1, 60, 00622 72, 119, -1, 31, 118, 87, -1, 31, 118, 1, 00623 -1, 32, 120, 148, -1, 32, 120, 149, -1, 32, 00624 120, 148, 149, -1, 35, 87, -1, 35, 1, -1, 00625 33, 65, 60, 66, 120, -1, 34, 120, -1, 151, 00626 -1, 18, 151, -1, 16, 60, 65, 66, 154, -1, 00627 16, 60, 65, 153, 66, 154, -1, 16, 65, 66, 00628 154, -1, 16, 65, 153, 66, 154, -1, 16, 61, 00629 65, 66, 154, -1, 16, 61, 65, 153, 66, 154, 00630 -1, 60, -1, 153, 69, 60, -1, 67, 68, -1, 00631 67, 156, 68, -1, -1, 156, -1, 157, -1, 156, 00632 157, -1, 119, -1, 150, -1 00633 }; 00634 00635 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 00636 static const unsigned short int yyrline[] = 00637 { 00638 0, 169, 169, 170, 171, 172, 173, 174, 177, 184, 00639 185, 186, 187, 188, 189, 190, 191, 195, 196, 197, 00640 201, 202, 207, 208, 212, 213, 217, 218, 223, 224, 00641 225, 229, 230, 231, 232, 233, 237, 238, 242, 243, 00642 244, 245, 249, 250, 254, 255, 259, 260, 264, 265, 00643 266, 270, 271, 272, 273, 274, 275, 276, 277, 278, 00644 279, 280, 281, 285, 286, 287, 288, 292, 293, 294, 00645 298, 299, 300, 301, 305, 306, 308, 310, 312, 314, 00646 316, 321, 322, 323, 324, 325, 329, 330, 334, 335, 00647 339, 340, 344, 345, 350, 351, 356, 357, 362, 363, 00648 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 00649 378, 379, 383, 384, 388, 389, 390, 391, 392, 393, 00650 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 00651 407, 408, 412, 413, 417, 419, 429, 430, 435, 436, 00652 440, 442, 452, 453, 458, 459, 463, 467, 471, 473, 00653 481, 482, 487, 488, 489, 492, 495, 498, 501, 507, 00654 508, 512, 513, 517, 518, 525, 526, 530, 531, 539, 00655 540, 544, 545, 553, 558, 563, 564, 569, 570, 574, 00656 575, 579, 580, 584, 585, 589, 594, 595, 602, 603, 00657 604, 608, 609, 618, 623, 627, 629, 633, 634, 639, 00658 641, 643, 645, 650, 651, 655, 657, 662, 665, 670, 00659 671, 675, 676 00660 }; 00661 #endif 00662 00663 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 00664 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 00665 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 00666 static const char *const yytname[] = 00667 { 00668 "$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN", 00669 "STRING", "NUMBER", "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR", 00670 "CONST", "CONTINUE", "FUNCTION", "RETURN", "VOID", "DELETE", "IF", 00671 "THIS", "DO", "WHILE", "ELSE", "IN", "INSTANCEOF", "TYPEOF", "SWITCH", 00672 "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "DEBUGGER", 00673 "EQEQ", "NE", "STREQ", "STRNEQ", "LE", "GE", "OR", "AND", "PLUSPLUS", 00674 "MINUSMINUS", "LSHIFT", "RSHIFT", "URSHIFT", "PLUSEQUAL", "MINUSEQUAL", 00675 "MULTEQUAL", "DIVEQUAL", "LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL", 00676 "ANDEQUAL", "MODEQUAL", "XOREQUAL", "OREQUAL", "IDENT", "FUNCEXPRIDENT", 00677 "AUTOPLUSPLUS", "AUTOMINUSMINUS", "'/'", "'('", "')'", "'{'", "'}'", 00678 "','", "'['", "']'", "':'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", 00679 "'%'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept", 00680 "Literal", "PrimaryExpr", "ArrayLiteral", "ElementList", "ElisionOpt", 00681 "Elision", "PropertyNameAndValueList", "PropertyName", "MemberExpr", 00682 "NewExpr", "CallExpr", "Arguments", "ArgumentList", "LeftHandSideExpr", 00683 "PostfixExpr", "UnaryExpr", "MultiplicativeExpr", "AdditiveExpr", 00684 "ShiftExpr", "RelationalExpr", "EqualityExpr", "BitwiseANDExpr", 00685 "BitwiseXORExpr", "BitwiseORExpr", "LogicalANDExpr", "LogicalORExpr", 00686 "ConditionalExpr", "AssignmentExpr", "AssignmentOperator", "Expr", 00687 "Statement", "Block", "StatementList", "VariableStatement", 00688 "VariableDeclarationList", "VariableDeclaration", "ConstStatement", 00689 "ConstDeclarationList", "ConstDeclaration", "Initializer", 00690 "EmptyStatement", "ExprStatement", "IfStatement", "IterationStatement", 00691 "ExprOpt", "ContinueStatement", "BreakStatement", "ReturnStatement", 00692 "WithStatement", "SwitchStatement", "CaseBlock", "CaseClausesOpt", 00693 "CaseClauses", "CaseClause", "DefaultClause", "LabelledStatement", 00694 "ThrowStatement", "TryStatement", "DebuggerStatement", "Catch", 00695 "Finally", "FunctionDeclaration", "FunctionDeclarationInternal", 00696 "FunctionExpr", "FormalParameterList", "FunctionBody", "Program", 00697 "SourceElements", "SourceElement", 0 00698 }; 00699 #endif 00700 00701 # ifdef YYPRINT 00702 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 00703 token YYLEX-NUM. */ 00704 static const unsigned short int yytoknum[] = 00705 { 00706 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 00707 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 00708 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 00709 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 00710 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 00711 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 00712 315, 316, 317, 318, 47, 40, 41, 123, 125, 44, 00713 91, 93, 58, 46, 43, 45, 126, 33, 42, 37, 00714 60, 62, 38, 94, 124, 63, 61, 59 00715 }; 00716 # endif 00717 00718 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 00719 static const unsigned char yyr1[] = 00720 { 00721 0, 88, 89, 89, 89, 89, 89, 89, 89, 90, 00722 90, 90, 90, 90, 90, 90, 90, 91, 91, 91, 00723 92, 92, 93, 93, 94, 94, 95, 95, 96, 96, 00724 96, 97, 97, 97, 97, 97, 98, 98, 99, 99, 00725 99, 99, 100, 100, 101, 101, 102, 102, 103, 103, 00726 103, 104, 104, 104, 104, 104, 104, 104, 104, 104, 00727 104, 104, 104, 105, 105, 105, 105, 106, 106, 106, 00728 107, 107, 107, 107, 108, 108, 108, 108, 108, 108, 00729 108, 109, 109, 109, 109, 109, 110, 110, 111, 111, 00730 112, 112, 113, 113, 114, 114, 115, 115, 116, 116, 00731 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 00732 117, 117, 118, 118, 119, 119, 119, 119, 119, 119, 00733 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 00734 120, 120, 121, 121, 122, 122, 123, 123, 124, 124, 00735 125, 125, 126, 126, 127, 127, 128, 129, 130, 130, 00736 131, 131, 132, 132, 132, 132, 132, 132, 132, 133, 00737 133, 134, 134, 134, 134, 135, 135, 135, 135, 136, 00738 136, 136, 136, 137, 138, 139, 139, 140, 140, 141, 00739 141, 142, 142, 143, 143, 144, 145, 145, 146, 146, 00740 146, 147, 147, 148, 149, 150, 150, 151, 151, 152, 00741 152, 152, 152, 153, 153, 154, 154, 155, 155, 156, 00742 156, 157, 157 00743 }; 00744 00745 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 00746 static const unsigned char yyr2[] = 00747 { 00748 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 00749 1, 1, 1, 3, 2, 3, 4, 3, 3, 5, 00750 2, 4, 0, 1, 1, 2, 3, 5, 1, 1, 00751 1, 1, 1, 4, 3, 3, 1, 2, 2, 2, 00752 4, 3, 2, 3, 1, 3, 1, 1, 1, 2, 00753 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 00754 2, 2, 2, 1, 3, 3, 3, 1, 3, 3, 00755 1, 3, 3, 3, 1, 3, 3, 3, 3, 3, 00756 3, 1, 3, 3, 3, 3, 1, 3, 1, 3, 00757 1, 3, 1, 3, 1, 3, 1, 5, 1, 3, 00758 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00759 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 00760 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00761 2, 3, 1, 2, 3, 3, 1, 3, 1, 2, 00762 3, 3, 1, 3, 1, 2, 2, 1, 2, 2, 00763 5, 7, 6, 5, 9, 10, 7, 8, 9, 0, 00764 1, 2, 2, 3, 3, 2, 2, 3, 3, 2, 00765 2, 3, 3, 5, 5, 3, 5, 0, 1, 1, 00766 2, 3, 4, 2, 3, 3, 3, 3, 3, 3, 00767 4, 2, 2, 5, 2, 1, 2, 5, 6, 4, 00768 5, 5, 6, 1, 3, 2, 3, 0, 1, 1, 00769 2, 1, 1 00770 }; 00771 00772 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 00773 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 00774 means the default is an error. */ 00775 static const unsigned char yydefact[] = 00776 { 00777 207, 2, 3, 4, 6, 5, 0, 0, 0, 0, 00778 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 00779 0, 0, 0, 0, 0, 0, 0, 0, 8, 10, 00780 0, 0, 7, 0, 0, 22, 0, 0, 0, 0, 00781 147, 11, 31, 12, 36, 46, 47, 48, 51, 63, 00782 67, 70, 74, 81, 86, 88, 90, 92, 94, 96, 00783 98, 112, 0, 211, 114, 115, 116, 117, 118, 119, 00784 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 00785 212, 195, 32, 0, 208, 209, 166, 0, 165, 159, 00786 0, 10, 0, 36, 37, 138, 0, 136, 144, 0, 00787 142, 162, 0, 161, 0, 0, 0, 170, 0, 169, 00788 0, 48, 53, 196, 52, 0, 0, 0, 54, 0, 00789 0, 0, 0, 0, 192, 191, 55, 57, 0, 56, 00790 58, 0, 6, 5, 10, 14, 0, 0, 0, 24, 00791 0, 0, 23, 59, 60, 61, 62, 0, 0, 0, 00792 38, 0, 0, 39, 49, 50, 101, 102, 103, 104, 00793 105, 106, 107, 108, 111, 109, 110, 100, 0, 0, 00794 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00795 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00796 0, 0, 0, 149, 0, 148, 1, 210, 168, 167, 00797 0, 48, 160, 0, 29, 30, 28, 14, 35, 0, 00798 139, 135, 0, 134, 145, 141, 0, 140, 164, 163, 00799 0, 0, 203, 0, 0, 172, 171, 0, 0, 0, 00800 0, 0, 187, 186, 130, 0, 0, 188, 189, 185, 00801 13, 15, 0, 0, 131, 22, 18, 17, 20, 25, 00802 42, 0, 44, 0, 34, 0, 41, 99, 65, 64, 00803 66, 68, 69, 71, 72, 73, 80, 79, 77, 78, 00804 75, 76, 82, 83, 84, 85, 87, 89, 91, 93, 00805 95, 0, 113, 138, 0, 0, 159, 146, 137, 143, 00806 0, 0, 0, 0, 0, 199, 0, 0, 0, 0, 00807 0, 0, 0, 0, 194, 190, 16, 0, 26, 0, 00808 43, 0, 33, 40, 0, 0, 139, 159, 0, 0, 00809 197, 0, 201, 0, 205, 0, 200, 204, 150, 0, 00810 153, 177, 174, 173, 0, 0, 19, 21, 45, 97, 00811 0, 0, 0, 0, 159, 198, 202, 206, 0, 152, 00812 0, 0, 178, 179, 0, 27, 0, 0, 159, 156, 00813 0, 151, 0, 0, 175, 177, 180, 193, 157, 0, 00814 0, 0, 181, 183, 0, 158, 0, 154, 132, 182, 00815 184, 176, 155, 133 00816 }; 00817 00818 /* YYDEFGOTO[NTERM-NUM]. */ 00819 static const short int yydefgoto[] = 00820 { 00821 -1, 41, 42, 43, 140, 141, 142, 136, 137, 44, 00822 45, 46, 150, 251, 47, 48, 49, 50, 51, 52, 00823 53, 54, 55, 56, 57, 58, 59, 60, 61, 168, 00824 62, 63, 64, 379, 65, 96, 97, 66, 99, 100, 00825 210, 67, 68, 69, 70, 203, 71, 72, 73, 74, 00826 75, 332, 351, 352, 353, 365, 76, 77, 78, 79, 00827 237, 238, 80, 81, 82, 224, 295, 83, 138, 85 00828 }; 00829 00830 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 00831 STATE-NUM. */ 00832 #define YYPACT_NINF -271 00833 static const short int yypact[] = 00834 { 00835 824, -271, -271, -271, -271, -271, 5, -12, 118, 15, 00836 45, 8, -6, 362, 1320, 1395, 81, -271, 901, 92, 00837 1395, 96, 104, 1395, 106, 13, 1395, 1395, -271, -14, 00838 1395, 1395, -271, 1395, 439, 111, 1395, 1395, 1395, 1395, 00839 -271, -271, -271, -271, -25, -271, 71, 197, -271, -271, 00840 -27, 63, 227, 91, 129, 194, 103, 130, 166, -15, 00841 -271, -271, 9, -271, -271, -271, -271, -271, -271, -271, 00842 -271, -271, -271, -271, -271, -271, -271, -271, -271, -271, 00843 -271, -271, -271, 279, 824, -271, -271, 27, -271, 1020, 00844 -19, -271, 29, -25, -271, 208, 11, -271, 208, 17, 00845 -271, -271, 32, -271, 216, 230, -17, -271, 1395, -271, 00846 21, 195, -271, -271, -271, 1395, 274, 1395, -271, 1395, 00847 1395, 33, 516, 252, -271, -271, -271, -271, 901, -271, 00848 -271, 37, 226, 228, -14, 986, 219, 229, 593, -271, 00849 57, 1095, 233, -271, -271, -271, -271, 1170, 1395, 243, 00850 -271, 1395, 244, -271, -271, -271, -271, -271, -271, -271, 00851 -271, -271, -271, -271, -271, -271, -271, -271, 1395, 1395, 00852 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 00853 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 00854 1395, 1395, 1395, -271, 1395, -271, -271, -271, -271, -271, 00855 245, 213, 237, 221, -271, -271, -271, -271, -271, 1395, 00856 -271, -271, 15, -271, -271, -271, 15, -271, -271, -271, 00857 -10, 3, -271, 246, 49, -271, -271, 76, 247, 90, 00858 121, 125, -271, -271, -271, 249, 106, 276, -271, -271, 00859 -271, -271, 87, 1395, -271, 111, -271, -271, -271, -271, 00860 -271, 126, -271, 141, -271, 174, -271, -271, -271, -271, 00861 -271, -27, -27, 63, 63, 63, 227, 227, 227, 227, 00862 227, 227, 91, 91, 91, 91, 129, 194, 103, 130, 00863 166, 239, -271, 1, -48, 1395, 1395, -271, -271, -271, 00864 246, 127, 246, 131, 670, -271, 246, 255, 901, 1395, 00865 901, 250, 901, 256, -271, -271, -271, 248, -271, 1245, 00866 -271, 1395, -271, -271, 1395, 1395, 293, 1395, 132, 232, 00867 -271, 246, -271, 246, -271, 747, -271, -271, 297, 133, 00868 -271, 313, -271, -271, 257, 1395, -271, -271, -271, -271, 00869 137, 1395, 240, 901, 1395, -271, -271, -271, 901, -271, 00870 1395, 31, 313, -271, 106, -271, 901, 138, 1395, -271, 00871 258, -271, 139, 254, -271, 313, -271, -271, -271, 901, 00872 262, 901, 901, 901, 261, -271, 901, -271, -271, 901, 00873 901, -271, -271, -271 00874 }; 00875 00876 /* YYPGOTO[NTERM-NUM]. */ 00877 static const short int yypgoto[] = 00878 { 00879 -271, -271, -271, -271, -271, 89, -271, -271, 93, 324, 00880 329, -271, -2, -271, 46, -271, -7, 117, 85, -29, 00881 -9, 152, 153, 151, 154, 155, -271, -271, -130, -271, 00882 -8, -18, -23, -30, -271, 145, -145, -271, -271, -271, 00883 -94, -271, -271, -271, -271, -270, -271, -271, -271, -271, 00884 -271, -271, -16, -271, -5, -271, -271, -271, -271, -271, 00885 -271, 115, -271, 334, -271, 72, -163, -271, 2, -81 00886 }; 00887 00888 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 00889 positive, shift that token. If negative, reduce the rule which 00890 number is the opposite. If zero, do what YYDEFACT says. 00891 If YYTABLE_NINF, syntax error. */ 00892 #define YYTABLE_NINF -131 00893 static const short int yytable[] = 00894 { 00895 116, 123, 84, 197, 214, 110, 86, 112, 114, 101, 00896 193, 248, 211, 118, 124, 121, 319, 252, 215, 126, 00897 127, 212, 225, 129, 130, 131, 315, 191, 198, 143, 00898 144, 145, 146, 218, 232, 204, 205, 169, 257, 317, 00899 147, 363, 105, 222, 153, 148, 106, 342, 149, 223, 00900 222, 170, 171, 89, 104, 105, 290, 197, 128, 106, 00901 111, 111, 281, 222, 282, 87, 111, 288, 102, 292, 00902 192, 289, 111, 111, 360, 95, 111, 111, 194, 287, 00903 212, 202, 111, 111, 111, 111, 216, 209, 370, 206, 00904 194, 208, 88, 204, 205, 103, 195, 207, 213, 364, 00905 125, 112, 194, 240, 217, 98, 194, 227, 226, 229, 00906 239, 230, 231, 308, 199, 296, 177, 178, 297, 219, 00907 233, 1, 2, 3, 4, 5, 245, 320, 246, 322, 00908 8, 179, 180, 326, 90, 201, 147, 172, 173, 17, 00909 253, 151, 298, 255, 152, 194, 115, 206, 266, 267, 00910 268, 269, 270, 271, 111, 306, 300, 117, 345, 194, 00911 346, 119, 258, 259, 260, 183, 184, 185, 186, 120, 00912 28, 181, 182, 122, 272, 273, 274, 275, 91, 337, 00913 139, 338, 32, 33, 339, 92, 188, 301, 35, 316, 00914 194, 302, 310, 321, 194, 311, 297, 323, 343, 349, 00915 297, 194, 194, 356, 369, 355, 194, 194, 194, 190, 00916 194, 372, 312, 304, 189, 111, 111, 111, 111, 111, 00917 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 00918 111, 111, 111, 111, 111, 111, 111, 111, 285, 154, 00919 155, 154, 155, 194, 197, 313, 156, 157, 158, 159, 00920 160, 161, 162, 163, 164, 165, 166, 154, 155, 263, 00921 264, 265, 156, 157, 158, 159, 160, 161, 162, 163, 00922 164, 165, 166, 174, 175, 176, 187, 318, 202, 196, 00923 328, 220, 330, 167, 333, 235, 236, 241, 242, 261, 00924 262, 329, 291, 293, 209, 221, 325, 228, -29, 167, 00925 -30, 243, 249, 254, 256, 283, 194, 340, 286, 202, 00926 236, 314, 299, 294, 303, 327, 334, 331, 341, 344, 00927 335, 348, 350, 354, 371, 359, 373, 358, 376, 381, 00928 361, 367, 93, 357, 309, 307, 202, 94, 368, 276, 00929 278, 277, 362, 380, 279, 284, 280, 366, 113, 374, 00930 202, 375, 305, 377, 378, 378, 0, 0, 382, 0, 00931 0, 383, 383, 107, 0, 1, 2, 3, 4, 5, 00932 0, 0, 0, 0, 8, 0, 0, 0, 90, 0, 00933 108, 15, 0, 17, 0, 0, 0, 0, 0, 20, 00934 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00935 0, 0, 0, 0, 0, 0, 26, 27, 0, 0, 00936 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 00937 0, 0, 91, 0, 30, 31, 32, 33, 0, 92, 00938 0, 0, 35, 0, 0, 0, 36, 37, 38, 39, 00939 0, 0, 1, 2, 3, 132, 133, 6, 0, 109, 00940 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 00941 17, 18, 19, 0, 0, 0, 20, 21, 22, 0, 00942 23, 24, 0, 0, 25, 0, 0, 0, 0, 0, 00943 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 00944 0, 28, 0, 0, 0, 0, 0, 0, 0, 134, 00945 0, 30, 31, 32, 33, 0, 34, 135, 0, 35, 00946 0, 0, 0, 36, 37, 38, 39, 0, 0, 1, 00947 2, 3, 4, 5, 6, 0, 40, 7, 8, 9, 00948 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 00949 0, 0, 0, 20, 21, 22, 0, 23, 24, 0, 00950 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 00951 26, 27, 0, 0, 0, 0, 0, 0, 28, 0, 00952 0, 0, 0, 0, 0, 0, 29, 0, 30, 31, 00953 32, 33, 0, 34, 234, 0, 35, 0, 0, 0, 00954 36, 37, 38, 39, 0, 0, 1, 2, 3, 4, 00955 5, 6, 0, 40, 7, 8, 9, 10, 11, 12, 00956 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 00957 20, 21, 22, 0, 23, 24, 0, 0, 25, 0, 00958 0, 0, 0, 0, 0, 0, 0, 26, 27, 0, 00959 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 00960 0, 0, 0, 29, 0, 30, 31, 32, 33, 0, 00961 34, 244, 0, 35, 0, 0, 0, 36, 37, 38, 00962 39, 0, 0, 1, 2, 3, 4, 5, 6, 0, 00963 40, 7, 8, 9, 10, 11, 12, 13, 14, 15, 00964 16, 17, 18, 19, 0, 0, 0, 20, 21, 22, 00965 0, 23, 24, 0, 0, 25, 0, 0, 0, 0, 00966 0, 0, 0, 0, 26, 27, 0, 0, 0, 0, 00967 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 00968 29, 0, 30, 31, 32, 33, 0, 34, 324, 0, 00969 35, 0, 0, 0, 36, 37, 38, 39, 0, 0, 00970 1, 2, 3, 4, 5, 6, 0, 40, 7, 8, 00971 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 00972 19, 0, 0, 0, 20, 21, 22, 0, 23, 24, 00973 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 00974 0, 26, 27, 0, 0, 0, 0, 0, 0, 28, 00975 0, 0, 0, 0, 0, 0, 0, 29, 0, 30, 00976 31, 32, 33, 0, 34, 347, 0, 35, 0, 0, 00977 0, 36, 37, 38, 39, 0, 0, 1, 2, 3, 00978 4, 5, 6, 0, 40, 7, 8, 9, 10, 11, 00979 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 00980 0, 20, 21, 22, 0, 23, 24, 0, 0, 25, 00981 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 00982 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 00983 0, 0, 0, 0, 29, 0, 30, 31, 32, 33, 00984 0, 34, 0, 0, 35, 0, 0, 0, 36, 37, 00985 38, 39, 0, 0, 1, 2, 3, 4, 5, 6, 00986 0, 40, 7, 8, 9, 10, 11, 90, 13, 108, 00987 15, 16, 17, 18, 19, 0, 0, 0, 20, 21, 00988 22, 0, 23, 24, 0, 0, 25, 0, 0, 0, 00989 0, 0, 0, 0, 0, 26, 27, 0, 0, 0, 00990 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 00991 0, 29, 0, 30, 31, 32, 33, 0, 34, 0, 00992 0, 35, 0, 0, 0, 36, 37, 38, 39, 0, 00993 0, 0, 0, 0, 0, 0, -130, 0, 40, -130, 00994 -130, -130, -130, -130, -130, -130, -130, -130, -130, -130, 00995 -130, -130, -130, -130, -130, -130, -130, -130, -130, -130, 00996 -130, 0, 0, -130, -130, -130, 0, -130, -130, 0, 00997 0, -130, 0, 1, 2, 3, 4, 5, 0, 0, 00998 0, 0, 8, 200, 0, 0, 90, 0, 108, 15, 00999 0, 17, 0, 0, 0, 0, -130, 20, -130, -130, 01000 0, 0, 0, -130, -130, 0, 0, 0, 0, 0, 01001 0, 0, -130, -130, 26, 27, 0, 0, 0, 0, 01002 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 01003 91, 0, 30, 31, 32, 33, 0, 92, 0, 0, 01004 35, 0, 0, 0, 36, 37, 38, 39, 1, 2, 01005 3, 4, 5, 0, 0, 0, 0, 8, 0, 0, 01006 0, 90, 0, 108, 15, 0, 17, 0, 0, 0, 01007 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 01008 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 01009 27, 0, 0, 0, 0, 0, 0, 28, 0, 0, 01010 0, 0, 0, 0, 0, 91, 0, 30, 31, 32, 01011 33, 0, 92, 0, 0, 35, 247, 0, 0, 36, 01012 37, 38, 39, 1, 2, 3, 4, 5, 0, 0, 01013 0, 0, 8, 0, 0, 0, 90, 0, 108, 15, 01014 0, 17, 0, 0, 0, 0, 0, 20, 0, 0, 01015 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01016 0, 0, 0, 0, 26, 27, 0, 0, 0, 0, 01017 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 01018 91, 0, 30, 31, 32, 33, 250, 92, 0, 0, 01019 35, 0, 0, 0, 36, 37, 38, 39, 1, 2, 01020 3, 4, 5, 0, 0, 0, 0, 8, 0, 0, 01021 0, 90, 0, 108, 15, 0, 17, 0, 0, 0, 01022 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 01023 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 01024 27, 0, 0, 0, 0, 0, 0, 28, 0, 0, 01025 0, 0, 0, 0, 0, 91, 0, 30, 31, 32, 01026 33, 0, 92, 0, 0, 35, 336, 0, 0, 36, 01027 37, 38, 39, 1, 2, 3, 4, 5, 0, 0, 01028 0, 0, 8, 0, 0, 0, 12, 0, 108, 15, 01029 0, 17, 0, 0, 0, 0, 0, 20, 0, 0, 01030 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01031 0, 0, 0, 0, 26, 27, 0, 0, 0, 0, 01032 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 01033 91, 0, 30, 31, 32, 33, 0, 92, 0, 0, 01034 35, 0, 0, 0, 36, 37, 38, 39, 1, 2, 01035 3, 4, 5, 0, 0, 0, 0, 8, 0, 0, 01036 0, 90, 0, 108, 15, 0, 17, 0, 0, 0, 01037 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 01038 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 01039 27, 0, 0, 0, 0, 0, 0, 28, 0, 0, 01040 0, 0, 0, 0, 0, 91, 0, 30, 31, 32, 01041 33, 0, 92, 0, 0, 35, 0, 0, 0, 36, 01042 37, 38, 39 01043 }; 01044 01045 static const short int yycheck[] = 01046 { 01047 18, 24, 0, 84, 98, 13, 1, 14, 15, 1, 01048 1, 141, 1, 20, 1, 23, 286, 147, 1, 26, 01049 27, 69, 1, 30, 31, 33, 25, 42, 1, 36, 01050 37, 38, 39, 1, 1, 6, 7, 64, 168, 87, 01051 65, 10, 61, 60, 46, 70, 65, 317, 73, 66, 01052 60, 78, 79, 65, 60, 61, 66, 138, 72, 65, 01053 14, 15, 192, 60, 194, 60, 20, 212, 60, 66, 01054 85, 216, 26, 27, 344, 60, 30, 31, 69, 209, 01055 69, 89, 36, 37, 38, 39, 69, 86, 358, 60, 01056 69, 93, 87, 6, 7, 87, 87, 68, 87, 68, 01057 87, 108, 69, 66, 87, 60, 69, 115, 87, 117, 01058 128, 119, 120, 243, 87, 66, 25, 26, 69, 87, 01059 87, 3, 4, 5, 6, 7, 69, 290, 71, 292, 01060 12, 40, 41, 296, 16, 89, 65, 74, 75, 21, 01061 148, 70, 66, 151, 73, 69, 65, 60, 177, 178, 01062 179, 180, 181, 182, 108, 68, 66, 65, 321, 69, 01063 323, 65, 169, 170, 171, 36, 37, 38, 39, 65, 01064 52, 80, 81, 67, 183, 184, 185, 186, 60, 309, 01065 69, 311, 64, 65, 314, 67, 83, 66, 70, 283, 01066 69, 66, 66, 66, 69, 69, 69, 66, 66, 66, 01067 69, 69, 69, 66, 66, 335, 69, 69, 69, 43, 01068 69, 72, 71, 236, 84, 169, 170, 171, 172, 173, 01069 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 01070 184, 185, 186, 187, 188, 189, 190, 191, 25, 44, 01071 45, 44, 45, 69, 325, 71, 49, 50, 51, 52, 01072 53, 54, 55, 56, 57, 58, 59, 44, 45, 174, 01073 175, 176, 49, 50, 51, 52, 53, 54, 55, 56, 01074 57, 58, 59, 46, 47, 48, 82, 285, 286, 0, 01075 298, 65, 300, 86, 302, 33, 34, 68, 69, 172, 01076 173, 299, 220, 221, 86, 65, 294, 23, 72, 86, 01077 72, 72, 69, 60, 60, 60, 69, 315, 87, 317, 01078 34, 72, 65, 67, 65, 60, 60, 67, 25, 87, 01079 72, 24, 9, 66, 66, 343, 72, 87, 66, 68, 01080 348, 354, 8, 341, 245, 242, 344, 8, 356, 187, 01081 189, 188, 350, 373, 190, 200, 191, 352, 14, 365, 01082 358, 369, 237, 371, 372, 373, -1, -1, 376, -1, 01083 -1, 379, 380, 1, -1, 3, 4, 5, 6, 7, 01084 -1, -1, -1, -1, 12, -1, -1, -1, 16, -1, 01085 18, 19, -1, 21, -1, -1, -1, -1, -1, 27, 01086 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01087 -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 01088 -1, -1, -1, -1, 52, -1, -1, -1, -1, -1, 01089 -1, -1, 60, -1, 62, 63, 64, 65, -1, 67, 01090 -1, -1, 70, -1, -1, -1, 74, 75, 76, 77, 01091 -1, -1, 3, 4, 5, 6, 7, 8, -1, 87, 01092 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 01093 21, 22, 23, -1, -1, -1, 27, 28, 29, -1, 01094 31, 32, -1, -1, 35, -1, -1, -1, -1, -1, 01095 -1, -1, -1, 44, 45, -1, -1, -1, -1, -1, 01096 -1, 52, -1, -1, -1, -1, -1, -1, -1, 60, 01097 -1, 62, 63, 64, 65, -1, 67, 68, -1, 70, 01098 -1, -1, -1, 74, 75, 76, 77, -1, -1, 3, 01099 4, 5, 6, 7, 8, -1, 87, 11, 12, 13, 01100 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01101 -1, -1, -1, 27, 28, 29, -1, 31, 32, -1, 01102 -1, 35, -1, -1, -1, -1, -1, -1, -1, -1, 01103 44, 45, -1, -1, -1, -1, -1, -1, 52, -1, 01104 -1, -1, -1, -1, -1, -1, 60, -1, 62, 63, 01105 64, 65, -1, 67, 68, -1, 70, -1, -1, -1, 01106 74, 75, 76, 77, -1, -1, 3, 4, 5, 6, 01107 7, 8, -1, 87, 11, 12, 13, 14, 15, 16, 01108 17, 18, 19, 20, 21, 22, 23, -1, -1, -1, 01109 27, 28, 29, -1, 31, 32, -1, -1, 35, -1, 01110 -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, 01111 -1, -1, -1, -1, -1, 52, -1, -1, -1, -1, 01112 -1, -1, -1, 60, -1, 62, 63, 64, 65, -1, 01113 67, 68, -1, 70, -1, -1, -1, 74, 75, 76, 01114 77, -1, -1, 3, 4, 5, 6, 7, 8, -1, 01115 87, 11, 12, 13, 14, 15, 16, 17, 18, 19, 01116 20, 21, 22, 23, -1, -1, -1, 27, 28, 29, 01117 -1, 31, 32, -1, -1, 35, -1, -1, -1, -1, 01118 -1, -1, -1, -1, 44, 45, -1, -1, -1, -1, 01119 -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, 01120 60, -1, 62, 63, 64, 65, -1, 67, 68, -1, 01121 70, -1, -1, -1, 74, 75, 76, 77, -1, -1, 01122 3, 4, 5, 6, 7, 8, -1, 87, 11, 12, 01123 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 01124 23, -1, -1, -1, 27, 28, 29, -1, 31, 32, 01125 -1, -1, 35, -1, -1, -1, -1, -1, -1, -1, 01126 -1, 44, 45, -1, -1, -1, -1, -1, -1, 52, 01127 -1, -1, -1, -1, -1, -1, -1, 60, -1, 62, 01128 63, 64, 65, -1, 67, 68, -1, 70, -1, -1, 01129 -1, 74, 75, 76, 77, -1, -1, 3, 4, 5, 01130 6, 7, 8, -1, 87, 11, 12, 13, 14, 15, 01131 16, 17, 18, 19, 20, 21, 22, 23, -1, -1, 01132 -1, 27, 28, 29, -1, 31, 32, -1, -1, 35, 01133 -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, 01134 -1, -1, -1, -1, -1, -1, 52, -1, -1, -1, 01135 -1, -1, -1, -1, 60, -1, 62, 63, 64, 65, 01136 -1, 67, -1, -1, 70, -1, -1, -1, 74, 75, 01137 76, 77, -1, -1, 3, 4, 5, 6, 7, 8, 01138 -1, 87, 11, 12, 13, 14, 15, 16, 17, 18, 01139 19, 20, 21, 22, 23, -1, -1, -1, 27, 28, 01140 29, -1, 31, 32, -1, -1, 35, -1, -1, -1, 01141 -1, -1, -1, -1, -1, 44, 45, -1, -1, -1, 01142 -1, -1, -1, 52, -1, -1, -1, -1, -1, -1, 01143 -1, 60, -1, 62, 63, 64, 65, -1, 67, -1, 01144 -1, 70, -1, -1, -1, 74, 75, 76, 77, -1, 01145 -1, -1, -1, -1, -1, -1, 0, -1, 87, 3, 01146 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 01147 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01148 24, -1, -1, 27, 28, 29, -1, 31, 32, -1, 01149 -1, 35, -1, 3, 4, 5, 6, 7, -1, -1, 01150 -1, -1, 12, 13, -1, -1, 16, -1, 18, 19, 01151 -1, 21, -1, -1, -1, -1, 60, 27, 62, 63, 01152 -1, -1, -1, 67, 68, -1, -1, -1, -1, -1, 01153 -1, -1, 76, 77, 44, 45, -1, -1, -1, -1, 01154 -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, 01155 60, -1, 62, 63, 64, 65, -1, 67, -1, -1, 01156 70, -1, -1, -1, 74, 75, 76, 77, 3, 4, 01157 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 01158 -1, 16, -1, 18, 19, -1, 21, -1, -1, -1, 01159 -1, -1, 27, -1, -1, -1, -1, -1, -1, -1, 01160 -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 01161 45, -1, -1, -1, -1, -1, -1, 52, -1, -1, 01162 -1, -1, -1, -1, -1, 60, -1, 62, 63, 64, 01163 65, -1, 67, -1, -1, 70, 71, -1, -1, 74, 01164 75, 76, 77, 3, 4, 5, 6, 7, -1, -1, 01165 -1, -1, 12, -1, -1, -1, 16, -1, 18, 19, 01166 -1, 21, -1, -1, -1, -1, -1, 27, -1, -1, 01167 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01168 -1, -1, -1, -1, 44, 45, -1, -1, -1, -1, 01169 -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, 01170 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, 01171 70, -1, -1, -1, 74, 75, 76, 77, 3, 4, 01172 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 01173 -1, 16, -1, 18, 19, -1, 21, -1, -1, -1, 01174 -1, -1, 27, -1, -1, -1, -1, -1, -1, -1, 01175 -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 01176 45, -1, -1, -1, -1, -1, -1, 52, -1, -1, 01177 -1, -1, -1, -1, -1, 60, -1, 62, 63, 64, 01178 65, -1, 67, -1, -1, 70, 71, -1, -1, 74, 01179 75, 76, 77, 3, 4, 5, 6, 7, -1, -1, 01180 -1, -1, 12, -1, -1, -1, 16, -1, 18, 19, 01181 -1, 21, -1, -1, -1, -1, -1, 27, -1, -1, 01182 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 01183 -1, -1, -1, -1, 44, 45, -1, -1, -1, -1, 01184 -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, 01185 60, -1, 62, 63, 64, 65, -1, 67, -1, -1, 01186 70, -1, -1, -1, 74, 75, 76, 77, 3, 4, 01187 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 01188 -1, 16, -1, 18, 19, -1, 21, -1, -1, -1, 01189 -1, -1, 27, -1, -1, -1, -1, -1, -1, -1, 01190 -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 01191 45, -1, -1, -1, -1, -1, -1, 52, -1, -1, 01192 -1, -1, -1, -1, -1, 60, -1, 62, 63, 64, 01193 65, -1, 67, -1, -1, 70, -1, -1, -1, 74, 01194 75, 76, 77 01195 }; 01196 01197 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 01198 symbol of state STATE-NUM. */ 01199 static const unsigned char yystos[] = 01200 { 01201 0, 3, 4, 5, 6, 7, 8, 11, 12, 13, 01202 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01203 27, 28, 29, 31, 32, 35, 44, 45, 52, 60, 01204 62, 63, 64, 65, 67, 70, 74, 75, 76, 77, 01205 87, 89, 90, 91, 97, 98, 99, 102, 103, 104, 01206 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 01207 115, 116, 118, 119, 120, 122, 125, 129, 130, 131, 01208 132, 134, 135, 136, 137, 138, 144, 145, 146, 147, 01209 150, 151, 152, 155, 156, 157, 1, 60, 87, 65, 01210 16, 60, 67, 97, 98, 60, 123, 124, 60, 126, 01211 127, 1, 60, 87, 60, 61, 65, 1, 18, 87, 01212 118, 102, 104, 151, 104, 65, 119, 65, 104, 65, 01213 65, 118, 67, 120, 1, 87, 104, 104, 72, 104, 01214 104, 118, 6, 7, 60, 68, 95, 96, 156, 69, 01215 92, 93, 94, 104, 104, 104, 104, 65, 70, 73, 01216 100, 70, 73, 100, 44, 45, 49, 50, 51, 52, 01217 53, 54, 55, 56, 57, 58, 59, 86, 117, 64, 01218 78, 79, 74, 75, 46, 47, 48, 25, 26, 40, 01219 41, 80, 81, 36, 37, 38, 39, 82, 83, 84, 01220 43, 42, 85, 1, 69, 87, 0, 157, 1, 87, 01221 13, 102, 118, 133, 6, 7, 60, 68, 100, 86, 01222 128, 1, 69, 87, 128, 1, 69, 87, 1, 87, 01223 65, 65, 60, 66, 153, 1, 87, 118, 23, 118, 01224 118, 118, 1, 87, 68, 33, 34, 148, 149, 119, 01225 66, 68, 69, 72, 68, 69, 71, 71, 116, 69, 01226 66, 101, 116, 118, 60, 118, 60, 116, 104, 104, 01227 104, 105, 105, 106, 106, 106, 107, 107, 107, 107, 01228 107, 107, 108, 108, 108, 108, 109, 110, 111, 112, 01229 113, 116, 116, 60, 123, 25, 87, 116, 124, 124, 01230 66, 153, 66, 153, 67, 154, 66, 69, 66, 65, 01231 66, 66, 66, 65, 120, 149, 68, 96, 116, 93, 01232 66, 69, 71, 71, 72, 25, 128, 87, 118, 133, 01233 154, 66, 154, 66, 68, 156, 154, 60, 119, 118, 01234 119, 67, 139, 119, 60, 72, 71, 116, 116, 116, 01235 118, 25, 133, 66, 87, 154, 154, 68, 24, 66, 01236 9, 140, 141, 142, 66, 116, 66, 118, 87, 119, 01237 133, 119, 118, 10, 68, 143, 142, 120, 119, 66, 01238 133, 66, 72, 72, 140, 119, 66, 119, 119, 121, 01239 121, 68, 119, 119 01240 }; 01241 01242 #define yyerrok (yyerrstatus = 0) 01243 #define yyclearin (yychar = YYEMPTY) 01244 #define YYEMPTY (-2) 01245 #define YYEOF 0 01246 01247 #define YYACCEPT goto yyacceptlab 01248 #define YYABORT goto yyabortlab 01249 #define YYERROR goto yyerrorlab 01250 01251 01252 /* Like YYERROR except do call yyerror. This remains here temporarily 01253 to ease the transition to the new meaning of YYERROR, for GCC. 01254 Once GCC version 2 has supplanted version 1, this can go. */ 01255 01256 #define YYFAIL goto yyerrlab 01257 01258 #define YYRECOVERING() (!!yyerrstatus) 01259 01260 #define YYBACKUP(Token, Value) \ 01261 do \ 01262 if (yychar == YYEMPTY && yylen == 1) \ 01263 { \ 01264 yychar = (Token); \ 01265 yylval = (Value); \ 01266 yytoken = YYTRANSLATE (yychar); \ 01267 YYPOPSTACK; \ 01268 goto yybackup; \ 01269 } \ 01270 else \ 01271 { \ 01272 yyerror (YY_("syntax error: cannot back up")); \ 01273 YYERROR; \ 01274 } \ 01275 while (0) 01276 01277 01278 #define YYTERROR 1 01279 #define YYERRCODE 256 01280 01281 01282 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 01283 If N is 0, then set CURRENT to the empty location which ends 01284 the previous symbol: RHS[0] (always defined). */ 01285 01286 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 01287 #ifndef YYLLOC_DEFAULT 01288 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 01289 do \ 01290 if (N) \ 01291 { \ 01292 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 01293 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 01294 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 01295 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 01296 } \ 01297 else \ 01298 { \ 01299 (Current).first_line = (Current).last_line = \ 01300 YYRHSLOC (Rhs, 0).last_line; \ 01301 (Current).first_column = (Current).last_column = \ 01302 YYRHSLOC (Rhs, 0).last_column; \ 01303 } \ 01304 while (0) 01305 #endif 01306 01307 01308 /* YY_LOCATION_PRINT -- Print the location on the stream. 01309 This macro was not mandated originally: define only if we know 01310 we won't break user code: when these are the locations we know. */ 01311 01312 #ifndef YY_LOCATION_PRINT 01313 # if YYLTYPE_IS_TRIVIAL 01314 # define YY_LOCATION_PRINT(File, Loc) \ 01315 fprintf (File, "%d.%d-%d.%d", \ 01316 (Loc).first_line, (Loc).first_column, \ 01317 (Loc).last_line, (Loc).last_column) 01318 # else 01319 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 01320 # endif 01321 #endif 01322 01323 01324 /* YYLEX -- calling `yylex' with the right arguments. */ 01325 01326 #ifdef YYLEX_PARAM 01327 # define YYLEX yylex (YYLEX_PARAM) 01328 #else 01329 # define YYLEX yylex () 01330 #endif 01331 01332 /* Enable debugging if requested. */ 01333 #if YYDEBUG 01334 01335 # ifndef YYFPRINTF 01336 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 01337 # define YYFPRINTF fprintf 01338 # endif 01339 01340 # define YYDPRINTF(Args) \ 01341 do { \ 01342 if (yydebug) \ 01343 YYFPRINTF Args; \ 01344 } while (0) 01345 01346 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 01347 do { \ 01348 if (yydebug) \ 01349 { \ 01350 YYFPRINTF (stderr, "%s ", Title); \ 01351 yysymprint (stderr, \ 01352 Type, Value, Location); \ 01353 YYFPRINTF (stderr, "\n"); \ 01354 } \ 01355 } while (0) 01356 01357 /*------------------------------------------------------------------. 01358 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 01359 | TOP (included). | 01360 `------------------------------------------------------------------*/ 01361 01362 #if defined (__STDC__) || defined (__cplusplus) 01363 static void 01364 yy_stack_print (short int *bottom, short int *top) 01365 #else 01366 static void 01367 yy_stack_print (bottom, top) 01368 short int *bottom; 01369 short int *top; 01370 #endif 01371 { 01372 YYFPRINTF (stderr, "Stack now"); 01373 for (/* Nothing. */; bottom <= top; ++bottom) 01374 YYFPRINTF (stderr, " %d", *bottom); 01375 YYFPRINTF (stderr, "\n"); 01376 } 01377 01378 # define YY_STACK_PRINT(Bottom, Top) \ 01379 do { \ 01380 if (yydebug) \ 01381 yy_stack_print ((Bottom), (Top)); \ 01382 } while (0) 01383 01384 01385 /*------------------------------------------------. 01386 | Report that the YYRULE is going to be reduced. | 01387 `------------------------------------------------*/ 01388 01389 #if defined (__STDC__) || defined (__cplusplus) 01390 static void 01391 yy_reduce_print (int yyrule) 01392 #else 01393 static void 01394 yy_reduce_print (yyrule) 01395 int yyrule; 01396 #endif 01397 { 01398 int yyi; 01399 unsigned long int yylno = yyrline[yyrule]; 01400 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ", 01401 yyrule - 1, yylno); 01402 /* Print the symbols being reduced, and their result. */ 01403 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 01404 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); 01405 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]); 01406 } 01407 01408 # define YY_REDUCE_PRINT(Rule) \ 01409 do { \ 01410 if (yydebug) \ 01411 yy_reduce_print (Rule); \ 01412 } while (0) 01413 01414 /* Nonzero means print parse trace. It is left uninitialized so that 01415 multiple parsers can coexist. */ 01416 int yydebug; 01417 #else /* !YYDEBUG */ 01418 # define YYDPRINTF(Args) 01419 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 01420 # define YY_STACK_PRINT(Bottom, Top) 01421 # define YY_REDUCE_PRINT(Rule) 01422 #endif /* !YYDEBUG */ 01423 01424 01425 /* YYINITDEPTH -- initial size of the parser's stacks. */ 01426 #ifndef YYINITDEPTH 01427 # define YYINITDEPTH 200 01428 #endif 01429 01430 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 01431 if the built-in stack extension method is used). 01432 01433 Do not make this value too large; the results are undefined if 01434 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 01435 evaluated with infinite-precision integer arithmetic. */ 01436 01437 #ifndef YYMAXDEPTH 01438 # define YYMAXDEPTH 10000 01439 #endif 01440 01441 01442 01443 #if YYERROR_VERBOSE 01444 01445 # ifndef yystrlen 01446 # if defined (__GLIBC__) && defined (_STRING_H) 01447 # define yystrlen strlen 01448 # else 01449 /* Return the length of YYSTR. */ 01450 static YYSIZE_T 01451 # if defined (__STDC__) || defined (__cplusplus) 01452 yystrlen (const char *yystr) 01453 # else 01454 yystrlen (yystr) 01455 const char *yystr; 01456 # endif 01457 { 01458 const char *yys = yystr; 01459 01460 while (*yys++ != '\0') 01461 continue; 01462 01463 return yys - yystr - 1; 01464 } 01465 # endif 01466 # endif 01467 01468 # ifndef yystpcpy 01469 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 01470 # define yystpcpy stpcpy 01471 # else 01472 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 01473 YYDEST. */ 01474 static char * 01475 # if defined (__STDC__) || defined (__cplusplus) 01476 yystpcpy (char *yydest, const char *yysrc) 01477 # else 01478 yystpcpy (yydest, yysrc) 01479 char *yydest; 01480 const char *yysrc; 01481 # endif 01482 { 01483 char *yyd = yydest; 01484 const char *yys = yysrc; 01485 01486 while ((*yyd++ = *yys++) != '\0') 01487 continue; 01488 01489 return yyd - 1; 01490 } 01491 # endif 01492 # endif 01493 01494 # ifndef yytnamerr 01495 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 01496 quotes and backslashes, so that it's suitable for yyerror. The 01497 heuristic is that double-quoting is unnecessary unless the string 01498 contains an apostrophe, a comma, or backslash (other than 01499 backslash-backslash). YYSTR is taken from yytname. If YYRES is 01500 null, do not copy; instead, return the length of what the result 01501 would have been. */ 01502 static YYSIZE_T 01503 yytnamerr (char *yyres, const char *yystr) 01504 { 01505 if (*yystr == '"') 01506 { 01507 size_t yyn = 0; 01508 char const *yyp = yystr; 01509 01510 for (;;) 01511 switch (*++yyp) 01512 { 01513 case '\'': 01514 case ',': 01515 goto do_not_strip_quotes; 01516 01517 case '\\': 01518 if (*++yyp != '\\') 01519 goto do_not_strip_quotes; 01520 /* Fall through. */ 01521 default: 01522 if (yyres) 01523 yyres[yyn] = *yyp; 01524 yyn++; 01525 break; 01526 01527 case '"': 01528 if (yyres) 01529 yyres[yyn] = '\0'; 01530 return yyn; 01531 } 01532 do_not_strip_quotes: ; 01533 } 01534 01535 if (! yyres) 01536 return yystrlen (yystr); 01537 01538 return yystpcpy (yyres, yystr) - yyres; 01539 } 01540 # endif 01541 01542 #endif /* YYERROR_VERBOSE */ 01543 01544 01545 01546 #if YYDEBUG 01547 /*--------------------------------. 01548 | Print this symbol on YYOUTPUT. | 01549 `--------------------------------*/ 01550 01551 #if defined (__STDC__) || defined (__cplusplus) 01552 static void 01553 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp) 01554 #else 01555 static void 01556 yysymprint (yyoutput, yytype, yyvaluep, yylocationp) 01557 FILE *yyoutput; 01558 int yytype; 01559 YYSTYPE *yyvaluep; 01560 YYLTYPE *yylocationp; 01561 #endif 01562 { 01563 /* Pacify ``unused variable'' warnings. */ 01564 (void) yyvaluep; 01565 (void) yylocationp; 01566 01567 if (yytype < YYNTOKENS) 01568 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 01569 else 01570 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 01571 01572 YY_LOCATION_PRINT (yyoutput, *yylocationp); 01573 YYFPRINTF (yyoutput, ": "); 01574 01575 # ifdef YYPRINT 01576 if (yytype < YYNTOKENS) 01577 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 01578 # endif 01579 switch (yytype) 01580 { 01581 default: 01582 break; 01583 } 01584 YYFPRINTF (yyoutput, ")"); 01585 } 01586 01587 #endif /* ! YYDEBUG */ 01588 /*-----------------------------------------------. 01589 | Release the memory associated to this symbol. | 01590 `-----------------------------------------------*/ 01591 01592 #if defined (__STDC__) || defined (__cplusplus) 01593 static void 01594 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp) 01595 #else 01596 static void 01597 yydestruct (yymsg, yytype, yyvaluep, yylocationp) 01598 const char *yymsg; 01599 int yytype; 01600 YYSTYPE *yyvaluep; 01601 YYLTYPE *yylocationp; 01602 #endif 01603 { 01604 /* Pacify ``unused variable'' warnings. */ 01605 (void) yyvaluep; 01606 (void) yylocationp; 01607 01608 if (!yymsg) 01609 yymsg = "Deleting"; 01610 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01611 01612 switch (yytype) 01613 { 01614 01615 default: 01616 break; 01617 } 01618 } 01619 01620 01621 /* Prevent warnings from -Wmissing-prototypes. */ 01622 01623 #ifdef YYPARSE_PARAM 01624 # if defined (__STDC__) || defined (__cplusplus) 01625 int yyparse (void *YYPARSE_PARAM); 01626 # else 01627 int yyparse (); 01628 # endif 01629 #else /* ! YYPARSE_PARAM */ 01630 #if defined (__STDC__) || defined (__cplusplus) 01631 int yyparse (void); 01632 #else 01633 int yyparse (); 01634 #endif 01635 #endif /* ! YYPARSE_PARAM */ 01636 01637 01638 01639 /* The look-ahead symbol. */ 01640 int yychar; 01641 01642 /* The semantic value of the look-ahead symbol. */ 01643 YYSTYPE yylval; 01644 01645 /* Number of syntax errors so far. */ 01646 int yynerrs; 01647 /* Location data for the look-ahead symbol. */ 01648 YYLTYPE yylloc; 01649 01650 01651 01652 /*----------. 01653 | yyparse. | 01654 `----------*/ 01655 01656 #ifdef YYPARSE_PARAM 01657 # if defined (__STDC__) || defined (__cplusplus) 01658 int yyparse (void *YYPARSE_PARAM) 01659 # else 01660 int yyparse (YYPARSE_PARAM) 01661 void *YYPARSE_PARAM; 01662 # endif 01663 #else /* ! YYPARSE_PARAM */ 01664 #if defined (__STDC__) || defined (__cplusplus) 01665 int 01666 yyparse (void) 01667 #else 01668 int 01669 yyparse () 01670 ; 01671 #endif 01672 #endif 01673 { 01674 01675 int yystate; 01676 int yyn; 01677 int yyresult; 01678 /* Number of tokens to shift before error messages enabled. */ 01679 int yyerrstatus; 01680 /* Look-ahead token as an internal (translated) token number. */ 01681 int yytoken = 0; 01682 01683 /* Three stacks and their tools: 01684 `yyss': related to states, 01685 `yyvs': related to semantic values, 01686 `yyls': related to locations. 01687 01688 Refer to the stacks thru separate pointers, to allow yyoverflow 01689 to reallocate them elsewhere. */ 01690 01691 /* The state stack. */ 01692 short int yyssa[YYINITDEPTH]; 01693 short int *yyss = yyssa; 01694 short int *yyssp; 01695 01696 /* The semantic value stack. */ 01697 YYSTYPE yyvsa[YYINITDEPTH]; 01698 YYSTYPE *yyvs = yyvsa; 01699 YYSTYPE *yyvsp; 01700 01701 /* The location stack. */ 01702 YYLTYPE yylsa[YYINITDEPTH]; 01703 YYLTYPE *yyls = yylsa; 01704 YYLTYPE *yylsp; 01705 /* The locations where the error started and ended. */ 01706 YYLTYPE yyerror_range[2]; 01707 01708 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) 01709 01710 YYSIZE_T yystacksize = YYINITDEPTH; 01711 01712 /* The variables used to return semantic value and location from the 01713 action routines. */ 01714 YYSTYPE yyval; 01715 YYLTYPE yyloc; 01716 01717 /* When reducing, the number of symbols on the RHS of the reduced 01718 rule. */ 01719 int yylen; 01720 01721 YYDPRINTF ((stderr, "Starting parse\n")); 01722 01723 yystate = 0; 01724 yyerrstatus = 0; 01725 yynerrs = 0; 01726 yychar = YYEMPTY; /* Cause a token to be read. */ 01727 01728 /* Initialize stack pointers. 01729 Waste one element of value and location stack 01730 so that they stay on the same level as the state stack. 01731 The wasted elements are never initialized. */ 01732 01733 yyssp = yyss; 01734 yyvsp = yyvs; 01735 yylsp = yyls; 01736 #if YYLTYPE_IS_TRIVIAL 01737 /* Initialize the default location before parsing starts. */ 01738 yylloc.first_line = yylloc.last_line = 1; 01739 yylloc.first_column = yylloc.last_column = 0; 01740 #endif 01741 01742 goto yysetstate; 01743 01744 /*------------------------------------------------------------. 01745 | yynewstate -- Push a new state, which is found in yystate. | 01746 `------------------------------------------------------------*/ 01747 yynewstate: 01748 /* In all cases, when you get here, the value and location stacks 01749 have just been pushed. so pushing a state here evens the stacks. 01750 */ 01751 yyssp++; 01752 01753 yysetstate: 01754 *yyssp = yystate; 01755 01756 if (yyss + yystacksize - 1 <= yyssp) 01757 { 01758 /* Get the current used size of the three stacks, in elements. */ 01759 YYSIZE_T yysize = yyssp - yyss + 1; 01760 01761 #ifdef yyoverflow 01762 { 01763 /* Give user a chance to reallocate the stack. Use copies of 01764 these so that the &'s don't force the real ones into 01765 memory. */ 01766 YYSTYPE *yyvs1 = yyvs; 01767 short int *yyss1 = yyss; 01768 YYLTYPE *yyls1 = yyls; 01769 01770 /* Each stack pointer address is followed by the size of the 01771 data in use in that stack, in bytes. This used to be a 01772 conditional around just the two extra args, but that might 01773 be undefined if yyoverflow is a macro. */ 01774 yyoverflow (YY_("memory exhausted"), 01775 &yyss1, yysize * sizeof (*yyssp), 01776 &yyvs1, yysize * sizeof (*yyvsp), 01777 &yyls1, yysize * sizeof (*yylsp), 01778 &yystacksize); 01779 yyls = yyls1; 01780 yyss = yyss1; 01781 yyvs = yyvs1; 01782 } 01783 #else /* no yyoverflow */ 01784 # ifndef YYSTACK_RELOCATE 01785 goto yyexhaustedlab; 01786 # else 01787 /* Extend the stack our own way. */ 01788 if (YYMAXDEPTH <= yystacksize) 01789 goto yyexhaustedlab; 01790 yystacksize *= 2; 01791 if (YYMAXDEPTH < yystacksize) 01792 yystacksize = YYMAXDEPTH; 01793 01794 { 01795 short int *yyss1 = yyss; 01796 union yyalloc *yyptr = 01797 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 01798 if (! yyptr) 01799 goto yyexhaustedlab; 01800 YYSTACK_RELOCATE (yyss); 01801 YYSTACK_RELOCATE (yyvs); 01802 YYSTACK_RELOCATE (yyls); 01803 # undef YYSTACK_RELOCATE 01804 if (yyss1 != yyssa) 01805 YYSTACK_FREE (yyss1); 01806 } 01807 # endif 01808 #endif /* no yyoverflow */ 01809 01810 yyssp = yyss + yysize - 1; 01811 yyvsp = yyvs + yysize - 1; 01812 yylsp = yyls + yysize - 1; 01813 01814 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 01815 (unsigned long int) yystacksize)); 01816 01817 if (yyss + yystacksize - 1 <= yyssp) 01818 YYABORT; 01819 } 01820 01821 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 01822 01823 goto yybackup; 01824 01825 /*-----------. 01826 | yybackup. | 01827 `-----------*/ 01828 yybackup: 01829 01830 /* Do appropriate processing given the current state. */ 01831 /* Read a look-ahead token if we need one and don't already have one. */ 01832 /* yyresume: */ 01833 01834 /* First try to decide what to do without reference to look-ahead token. */ 01835 01836 yyn = yypact[yystate]; 01837 if (yyn == YYPACT_NINF) 01838 goto yydefault; 01839 01840 /* Not known => get a look-ahead token if don't already have one. */ 01841 01842 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 01843 if (yychar == YYEMPTY) 01844 { 01845 YYDPRINTF ((stderr, "Reading a token: ")); 01846 yychar = YYLEX; 01847 } 01848 01849 if (yychar <= YYEOF) 01850 { 01851 yychar = yytoken = YYEOF; 01852 YYDPRINTF ((stderr, "Now at end of input.\n")); 01853 } 01854 else 01855 { 01856 yytoken = YYTRANSLATE (yychar); 01857 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 01858 } 01859 01860 /* If the proper action on seeing token YYTOKEN is to reduce or to 01861 detect an error, take that action. */ 01862 yyn += yytoken; 01863 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 01864 goto yydefault; 01865 yyn = yytable[yyn]; 01866 if (yyn <= 0) 01867 { 01868 if (yyn == 0 || yyn == YYTABLE_NINF) 01869 goto yyerrlab; 01870 yyn = -yyn; 01871 goto yyreduce; 01872 } 01873 01874 if (yyn == YYFINAL) 01875 YYACCEPT; 01876 01877 /* Shift the look-ahead token. */ 01878 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 01879 01880 /* Discard the token being shifted unless it is eof. */ 01881 if (yychar != YYEOF) 01882 yychar = YYEMPTY; 01883 01884 *++yyvsp = yylval; 01885 *++yylsp = yylloc; 01886 01887 /* Count tokens shifted since error; after three, turn off error 01888 status. */ 01889 if (yyerrstatus) 01890 yyerrstatus--; 01891 01892 yystate = yyn; 01893 goto yynewstate; 01894 01895 01896 /*-----------------------------------------------------------. 01897 | yydefault -- do the default action for the current state. | 01898 `-----------------------------------------------------------*/ 01899 yydefault: 01900 yyn = yydefact[yystate]; 01901 if (yyn == 0) 01902 goto yyerrlab; 01903 goto yyreduce; 01904 01905 01906 /*-----------------------------. 01907 | yyreduce -- Do a reduction. | 01908 `-----------------------------*/ 01909 yyreduce: 01910 /* yyn is the number of a rule to reduce with. */ 01911 yylen = yyr2[yyn]; 01912 01913 /* If YYLEN is nonzero, implement the default value of the action: 01914 `$$ = $1'. 01915 01916 Otherwise, the following line sets YYVAL to garbage. 01917 This behavior is undocumented and Bison 01918 users should not rely upon it. Assigning to YYVAL 01919 unconditionally makes the parser a bit smaller, and it avoids a 01920 GCC warning that YYVAL may be used uninitialized. */ 01921 yyval = yyvsp[1-yylen]; 01922 01923 /* Default location. */ 01924 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen); 01925 YY_REDUCE_PRINT (yyn); 01926 switch (yyn) 01927 { 01928 case 2: 01929 #line 169 "grammar.y" 01930 { (yyval.node) = new NullNode(); ;} 01931 break; 01932 01933 case 3: 01934 #line 170 "grammar.y" 01935 { (yyval.node) = new BooleanNode(true); ;} 01936 break; 01937 01938 case 4: 01939 #line 171 "grammar.y" 01940 { (yyval.node) = new BooleanNode(false); ;} 01941 break; 01942 01943 case 5: 01944 #line 172 "grammar.y" 01945 { (yyval.node) = new NumberNode((yyvsp[0].dval)); ;} 01946 break; 01947 01948 case 6: 01949 #line 173 "grammar.y" 01950 { (yyval.node) = new StringNode((yyvsp[0].ustr)); ;} 01951 break; 01952 01953 case 7: 01954 #line 174 "grammar.y" 01955 { Lexer *l = Lexer::curr(); 01956 if (!l->scanRegExp()) YYABORT; 01957 (yyval.node) = new RegExpNode(l->pattern,l->flags);;} 01958 break; 01959 01960 case 8: 01961 #line 178 "grammar.y" 01962 { Lexer *l = Lexer::curr(); 01963 if (!l->scanRegExp()) YYABORT; 01964 (yyval.node) = new RegExpNode(UString('=')+l->pattern,l->flags);;} 01965 break; 01966 01967 case 9: 01968 #line 184 "grammar.y" 01969 { (yyval.node) = new ThisNode(); ;} 01970 break; 01971 01972 case 10: 01973 #line 185 "grammar.y" 01974 { (yyval.node) = new ResolveNode(*(yyvsp[0].ident)); ;} 01975 break; 01976 01977 case 13: 01978 #line 188 "grammar.y" 01979 { (yyval.node) = new GroupNode((yyvsp[-1].node)); ;} 01980 break; 01981 01982 case 14: 01983 #line 189 "grammar.y" 01984 { (yyval.node) = new ObjectLiteralNode(); ;} 01985 break; 01986 01987 case 15: 01988 #line 190 "grammar.y" 01989 { (yyval.node) = new ObjectLiteralNode((yyvsp[-1].plist)); ;} 01990 break; 01991 01992 case 16: 01993 #line 191 "grammar.y" 01994 { (yyval.node) = new ObjectLiteralNode((yyvsp[-2].plist)); ;} 01995 break; 01996 01997 case 17: 01998 #line 195 "grammar.y" 01999 { (yyval.node) = new ArrayNode((yyvsp[-1].ival)); ;} 02000 break; 02001 02002 case 18: 02003 #line 196 "grammar.y" 02004 { (yyval.node) = new ArrayNode((yyvsp[-1].elm)); ;} 02005 break; 02006 02007 case 19: 02008 #line 197 "grammar.y" 02009 { (yyval.node) = new ArrayNode((yyvsp[-1].ival), (yyvsp[-3].elm)); ;} 02010 break; 02011 02012 case 20: 02013 #line 201 "grammar.y" 02014 { (yyval.elm) = new ElementNode((yyvsp[-1].ival), (yyvsp[0].node)); ;} 02015 break; 02016 02017 case 21: 02018 #line 203 "grammar.y" 02019 { (yyval.elm) = new ElementNode((yyvsp[-3].elm), (yyvsp[-1].ival), (yyvsp[0].node)); ;} 02020 break; 02021 02022 case 22: 02023 #line 207 "grammar.y" 02024 { (yyval.ival) = 0; ;} 02025 break; 02026 02027 case 24: 02028 #line 212 "grammar.y" 02029 { (yyval.ival) = 1; ;} 02030 break; 02031 02032 case 25: 02033 #line 213 "grammar.y" 02034 { (yyval.ival) = (yyvsp[-1].ival) + 1; ;} 02035 break; 02036 02037 case 26: 02038 #line 217 "grammar.y" 02039 { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node)); ;} 02040 break; 02041 02042 case 27: 02043 #line 219 "grammar.y" 02044 { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node), (yyvsp[-4].plist)); ;} 02045 break; 02046 02047 case 28: 02048 #line 223 "grammar.y" 02049 { (yyval.pnode) = new PropertyNode(*(yyvsp[0].ident)); ;} 02050 break; 02051 02052 case 29: 02053 #line 224 "grammar.y" 02054 { (yyval.pnode) = new PropertyNode(Identifier(*(yyvsp[0].ustr))); ;} 02055 break; 02056 02057 case 30: 02058 #line 225 "grammar.y" 02059 { (yyval.pnode) = new PropertyNode((yyvsp[0].dval)); ;} 02060 break; 02061 02062 case 33: 02063 #line 231 "grammar.y" 02064 { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;} 02065 break; 02066 02067 case 34: 02068 #line 232 "grammar.y" 02069 { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;} 02070 break; 02071 02072 case 35: 02073 #line 233 "grammar.y" 02074 { (yyval.node) = new NewExprNode((yyvsp[-1].node), (yyvsp[0].args)); ;} 02075 break; 02076 02077 case 37: 02078 #line 238 "grammar.y" 02079 { (yyval.node) = new NewExprNode((yyvsp[0].node)); ;} 02080 break; 02081 02082 case 38: 02083 #line 242 "grammar.y" 02084 { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;} 02085 break; 02086 02087 case 39: 02088 #line 243 "grammar.y" 02089 { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;} 02090 break; 02091 02092 case 40: 02093 #line 244 "grammar.y" 02094 { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;} 02095 break; 02096 02097 case 41: 02098 #line 245 "grammar.y" 02099 { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;} 02100 break; 02101 02102 case 42: 02103 #line 249 "grammar.y" 02104 { (yyval.args) = new ArgumentsNode(); ;} 02105 break; 02106 02107 case 43: 02108 #line 250 "grammar.y" 02109 { (yyval.args) = new ArgumentsNode((yyvsp[-1].alist)); ;} 02110 break; 02111 02112 case 44: 02113 #line 254 "grammar.y" 02114 { (yyval.alist) = new ArgumentListNode((yyvsp[0].node)); ;} 02115 break; 02116 02117 case 45: 02118 #line 255 "grammar.y" 02119 { (yyval.alist) = new ArgumentListNode((yyvsp[-2].alist), (yyvsp[0].node)); ;} 02120 break; 02121 02122 case 49: 02123 #line 265 "grammar.y" 02124 { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpPlusPlus); ;} 02125 break; 02126 02127 case 50: 02128 #line 266 "grammar.y" 02129 { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpMinusMinus); ;} 02130 break; 02131 02132 case 52: 02133 #line 271 "grammar.y" 02134 { (yyval.node) = new DeleteNode((yyvsp[0].node)); ;} 02135 break; 02136 02137 case 53: 02138 #line 272 "grammar.y" 02139 { (yyval.node) = new VoidNode((yyvsp[0].node)); ;} 02140 break; 02141 02142 case 54: 02143 #line 273 "grammar.y" 02144 { (yyval.node) = new TypeOfNode((yyvsp[0].node)); ;} 02145 break; 02146 02147 case 55: 02148 #line 274 "grammar.y" 02149 { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;} 02150 break; 02151 02152 case 56: 02153 #line 275 "grammar.y" 02154 { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;} 02155 break; 02156 02157 case 57: 02158 #line 276 "grammar.y" 02159 { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;} 02160 break; 02161 02162 case 58: 02163 #line 277 "grammar.y" 02164 { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;} 02165 break; 02166 02167 case 59: 02168 #line 278 "grammar.y" 02169 { (yyval.node) = new UnaryPlusNode((yyvsp[0].node)); ;} 02170 break; 02171 02172 case 60: 02173 #line 279 "grammar.y" 02174 { (yyval.node) = new NegateNode((yyvsp[0].node)); ;} 02175 break; 02176 02177 case 61: 02178 #line 280 "grammar.y" 02179 { (yyval.node) = new BitwiseNotNode((yyvsp[0].node)); ;} 02180 break; 02181 02182 case 62: 02183 #line 281 "grammar.y" 02184 { (yyval.node) = new LogicalNotNode((yyvsp[0].node)); ;} 02185 break; 02186 02187 case 64: 02188 #line 286 "grammar.y" 02189 { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '*'); ;} 02190 break; 02191 02192 case 65: 02193 #line 287 "grammar.y" 02194 { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '/'); ;} 02195 break; 02196 02197 case 66: 02198 #line 288 "grammar.y" 02199 { (yyval.node) = new MultNode((yyvsp[-2].node),(yyvsp[0].node),'%'); ;} 02200 break; 02201 02202 case 68: 02203 #line 293 "grammar.y" 02204 { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '+'); ;} 02205 break; 02206 02207 case 69: 02208 #line 294 "grammar.y" 02209 { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '-'); ;} 02210 break; 02211 02212 case 71: 02213 #line 299 "grammar.y" 02214 { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpLShift, (yyvsp[0].node)); ;} 02215 break; 02216 02217 case 72: 02218 #line 300 "grammar.y" 02219 { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpRShift, (yyvsp[0].node)); ;} 02220 break; 02221 02222 case 73: 02223 #line 301 "grammar.y" 02224 { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpURShift, (yyvsp[0].node)); ;} 02225 break; 02226 02227 case 75: 02228 #line 307 "grammar.y" 02229 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLess, (yyvsp[0].node)); ;} 02230 break; 02231 02232 case 76: 02233 #line 309 "grammar.y" 02234 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreater, (yyvsp[0].node)); ;} 02235 break; 02236 02237 case 77: 02238 #line 311 "grammar.y" 02239 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLessEq, (yyvsp[0].node)); ;} 02240 break; 02241 02242 case 78: 02243 #line 313 "grammar.y" 02244 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreaterEq, (yyvsp[0].node)); ;} 02245 break; 02246 02247 case 79: 02248 #line 315 "grammar.y" 02249 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpInstanceOf, (yyvsp[0].node)); ;} 02250 break; 02251 02252 case 80: 02253 #line 317 "grammar.y" 02254 { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpIn, (yyvsp[0].node)); ;} 02255 break; 02256 02257 case 82: 02258 #line 322 "grammar.y" 02259 { (yyval.node) = new EqualNode((yyvsp[-2].node), OpEqEq, (yyvsp[0].node)); ;} 02260 break; 02261 02262 case 83: 02263 #line 323 "grammar.y" 02264 { (yyval.node) = new EqualNode((yyvsp[-2].node), OpNotEq, (yyvsp[0].node)); ;} 02265 break; 02266 02267 case 84: 02268 #line 324 "grammar.y" 02269 { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrEq, (yyvsp[0].node)); ;} 02270 break; 02271 02272 case 85: 02273 #line 325 "grammar.y" 02274 { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrNEq, (yyvsp[0].node));;} 02275 break; 02276 02277 case 87: 02278 #line 330 "grammar.y" 02279 { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitAnd, (yyvsp[0].node)); ;} 02280 break; 02281 02282 case 89: 02283 #line 335 "grammar.y" 02284 { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitXOr, (yyvsp[0].node)); ;} 02285 break; 02286 02287 case 91: 02288 #line 340 "grammar.y" 02289 { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitOr, (yyvsp[0].node)); ;} 02290 break; 02291 02292 case 93: 02293 #line 346 "grammar.y" 02294 { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpAnd, (yyvsp[0].node)); ;} 02295 break; 02296 02297 case 95: 02298 #line 352 "grammar.y" 02299 { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpOr, (yyvsp[0].node)); ;} 02300 break; 02301 02302 case 97: 02303 #line 358 "grammar.y" 02304 { (yyval.node) = new ConditionalNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)); ;} 02305 break; 02306 02307 case 99: 02308 #line 364 "grammar.y" 02309 { (yyval.node) = new AssignNode((yyvsp[-2].node), (yyvsp[-1].op), (yyvsp[0].node));;} 02310 break; 02311 02312 case 100: 02313 #line 368 "grammar.y" 02314 { (yyval.op) = OpEqual; ;} 02315 break; 02316 02317 case 101: 02318 #line 369 "grammar.y" 02319 { (yyval.op) = OpPlusEq; ;} 02320 break; 02321 02322 case 102: 02323 #line 370 "grammar.y" 02324 { (yyval.op) = OpMinusEq; ;} 02325 break; 02326 02327 case 103: 02328 #line 371 "grammar.y" 02329 { (yyval.op) = OpMultEq; ;} 02330 break; 02331 02332 case 104: 02333 #line 372 "grammar.y" 02334 { (yyval.op) = OpDivEq; ;} 02335 break; 02336 02337 case 105: 02338 #line 373 "grammar.y" 02339 { (yyval.op) = OpLShift; ;} 02340 break; 02341 02342 case 106: 02343 #line 374 "grammar.y" 02344 { (yyval.op) = OpRShift; ;} 02345 break; 02346 02347 case 107: 02348 #line 375 "grammar.y" 02349 { (yyval.op) = OpURShift; ;} 02350 break; 02351 02352 case 108: 02353 #line 376 "grammar.y" 02354 { (yyval.op) = OpAndEq; ;} 02355 break; 02356 02357 case 109: 02358 #line 377 "grammar.y" 02359 { (yyval.op) = OpXOrEq; ;} 02360 break; 02361 02362 case 110: 02363 #line 378 "grammar.y" 02364 { (yyval.op) = OpOrEq; ;} 02365 break; 02366 02367 case 111: 02368 #line 379 "grammar.y" 02369 { (yyval.op) = OpModEq; ;} 02370 break; 02371 02372 case 113: 02373 #line 384 "grammar.y" 02374 { (yyval.node) = new CommaNode((yyvsp[-2].node), (yyvsp[0].node)); ;} 02375 break; 02376 02377 case 130: 02378 #line 407 "grammar.y" 02379 { (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;} 02380 break; 02381 02382 case 131: 02383 #line 408 "grammar.y" 02384 { (yyval.stat) = new BlockNode((yyvsp[-1].srcs)); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;} 02385 break; 02386 02387 case 132: 02388 #line 412 "grammar.y" 02389 { (yyval.slist) = new StatListNode((yyvsp[0].stat)); ;} 02390 break; 02391 02392 case 133: 02393 #line 413 "grammar.y" 02394 { (yyval.slist) = new StatListNode((yyvsp[-1].slist), (yyvsp[0].stat)); ;} 02395 break; 02396 02397 case 134: 02398 #line 417 "grammar.y" 02399 { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist)); 02400 DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;} 02401 break; 02402 02403 case 135: 02404 #line 419 "grammar.y" 02405 { if (automatic()) { 02406 (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist)); 02407 DBG((yyval.stat), (yylsp[-2]), (yylsp[-1])); 02408 } else { 02409 YYABORT; 02410 } 02411 ;} 02412 break; 02413 02414 case 136: 02415 #line 429 "grammar.y" 02416 { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;} 02417 break; 02418 02419 case 137: 02420 #line 431 "grammar.y" 02421 { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;} 02422 break; 02423 02424 case 138: 02425 #line 435 "grammar.y" 02426 { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Variable); ;} 02427 break; 02428 02429 case 139: 02430 #line 436 "grammar.y" 02431 { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Variable); ;} 02432 break; 02433 02434 case 140: 02435 #line 440 "grammar.y" 02436 { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist)); 02437 DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;} 02438 break; 02439 02440 case 141: 02441 #line 442 "grammar.y" 02442 { if (automatic()) { 02443 (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist)); 02444 DBG((yyval.stat), (yylsp[-2]), (yylsp[-1])); 02445 } else { 02446 YYABORT; 02447 } 02448 ;} 02449 break; 02450 02451 case 142: 02452 #line 452 "grammar.y" 02453 { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;} 02454 break; 02455 02456 case 143: 02457 #line 454 "grammar.y" 02458 { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;} 02459 break; 02460 02461 case 144: 02462 #line 458 "grammar.y" 02463 { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Constant); ;} 02464 break; 02465 02466 case 145: 02467 #line 459 "grammar.y" 02468 { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Constant); ;} 02469 break; 02470 02471 case 146: 02472 #line 463 "grammar.y" 02473 { (yyval.init) = new AssignExprNode((yyvsp[0].node)); ;} 02474 break; 02475 02476 case 147: 02477 #line 467 "grammar.y" 02478 { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;} 02479 break; 02480 02481 case 148: 02482 #line 471 "grammar.y" 02483 { (yyval.stat) = new ExprStatementNode((yyvsp[-1].node)); 02484 DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;} 02485 break; 02486 02487 case 149: 02488 #line 473 "grammar.y" 02489 { if (automatic()) { 02490 (yyval.stat) = new ExprStatementNode((yyvsp[-1].node)); 02491 DBG((yyval.stat), (yylsp[-1]), (yylsp[-1])); 02492 } else 02493 YYABORT; ;} 02494 break; 02495 02496 case 150: 02497 #line 481 "grammar.y" 02498 { (yyval.stat) = new IfNode((yyvsp[-2].node),(yyvsp[0].stat),0);DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;} 02499 break; 02500 02501 case 151: 02502 #line 483 "grammar.y" 02503 { (yyval.stat) = new IfNode((yyvsp[-4].node),(yyvsp[-2].stat),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-6]),(yylsp[-3])); ;} 02504 break; 02505 02506 case 152: 02507 #line 487 "grammar.y" 02508 { (yyval.stat)=new DoWhileNode((yyvsp[-4].stat),(yyvsp[-1].node));DBG((yyval.stat),(yylsp[-5]),(yylsp[-3]));;} 02509 break; 02510 02511 case 153: 02512 #line 488 "grammar.y" 02513 { (yyval.stat) = new WhileNode((yyvsp[-2].node),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;} 02514 break; 02515 02516 case 154: 02517 #line 490 "grammar.y" 02518 { (yyval.stat) = new ForNode((yyvsp[-6].node),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat)); 02519 DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;} 02520 break; 02521 02522 case 155: 02523 #line 493 "grammar.y" 02524 { (yyval.stat) = new ForNode((yyvsp[-6].vlist),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat)); 02525 DBG((yyval.stat),(yylsp[-9]),(yylsp[-1])); ;} 02526 break; 02527 02528 case 156: 02529 #line 496 "grammar.y" 02530 { (yyval.stat) = new ForInNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].stat)); 02531 DBG((yyval.stat),(yylsp[-6]),(yylsp[-1])); ;} 02532 break; 02533 02534 case 157: 02535 #line 499 "grammar.y" 02536 { (yyval.stat) = new ForInNode(*(yyvsp[-4].ident),0,(yyvsp[-2].node),(yyvsp[0].stat)); 02537 DBG((yyval.stat),(yylsp[-7]),(yylsp[-1])); ;} 02538 break; 02539 02540 case 158: 02541 #line 502 "grammar.y" 02542 { (yyval.stat) = new ForInNode(*(yyvsp[-5].ident),(yyvsp[-4].init),(yyvsp[-2].node),(yyvsp[0].stat)); 02543 DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;} 02544 break; 02545 02546 case 159: 02547 #line 507 "grammar.y" 02548 { (yyval.node) = 0; ;} 02549 break; 02550 02551 case 161: 02552 #line 512 "grammar.y" 02553 { (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;} 02554 break; 02555 02556 case 162: 02557 #line 513 "grammar.y" 02558 { if (automatic()) { 02559 (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); 02560 } else 02561 YYABORT; ;} 02562 break; 02563 02564 case 163: 02565 #line 517 "grammar.y" 02566 { (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;} 02567 break; 02568 02569 case 164: 02570 #line 518 "grammar.y" 02571 { if (automatic()) { 02572 (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident));DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); 02573 } else 02574 YYABORT; ;} 02575 break; 02576 02577 case 165: 02578 #line 525 "grammar.y" 02579 { (yyval.stat) = new BreakNode();DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;} 02580 break; 02581 02582 case 166: 02583 #line 526 "grammar.y" 02584 { if (automatic()) { 02585 (yyval.stat) = new BreakNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1])); 02586 } else 02587 YYABORT; ;} 02588 break; 02589 02590 case 167: 02591 #line 530 "grammar.y" 02592 { (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;} 02593 break; 02594 02595 case 168: 02596 #line 531 "grammar.y" 02597 { if (automatic()) { 02598 (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); 02599 } else 02600 YYABORT; 02601 ;} 02602 break; 02603 02604 case 169: 02605 #line 539 "grammar.y" 02606 { (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;} 02607 break; 02608 02609 case 170: 02610 #line 540 "grammar.y" 02611 { if (automatic()) { 02612 (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1])); 02613 } else 02614 YYABORT; ;} 02615 break; 02616 02617 case 171: 02618 #line 544 "grammar.y" 02619 { (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;} 02620 break; 02621 02622 case 172: 02623 #line 545 "grammar.y" 02624 { if (automatic()) { 02625 (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); 02626 } 02627 else 02628 YYABORT; ;} 02629 break; 02630 02631 case 173: 02632 #line 553 "grammar.y" 02633 { (yyval.stat) = new WithNode((yyvsp[-2].node),(yyvsp[0].stat)); 02634 DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;} 02635 break; 02636 02637 case 174: 02638 #line 558 "grammar.y" 02639 { (yyval.stat) = new SwitchNode((yyvsp[-2].node), (yyvsp[0].cblk)); 02640 DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;} 02641 break; 02642 02643 case 175: 02644 #line 563 "grammar.y" 02645 { (yyval.cblk) = new CaseBlockNode((yyvsp[-1].clist), 0, 0); ;} 02646 break; 02647 02648 case 176: 02649 #line 565 "grammar.y" 02650 { (yyval.cblk) = new CaseBlockNode((yyvsp[-3].clist), (yyvsp[-2].ccl), (yyvsp[-1].clist)); ;} 02651 break; 02652 02653 case 177: 02654 #line 569 "grammar.y" 02655 { (yyval.clist) = 0; ;} 02656 break; 02657 02658 case 179: 02659 #line 574 "grammar.y" 02660 { (yyval.clist) = new ClauseListNode((yyvsp[0].ccl)); ;} 02661 break; 02662 02663 case 180: 02664 #line 575 "grammar.y" 02665 { (yyval.clist) = new ClauseListNode((yyvsp[-1].clist), (yyvsp[0].ccl)); ;} 02666 break; 02667 02668 case 181: 02669 #line 579 "grammar.y" 02670 { (yyval.ccl) = new CaseClauseNode((yyvsp[-1].node)); ;} 02671 break; 02672 02673 case 182: 02674 #line 580 "grammar.y" 02675 { (yyval.ccl) = new CaseClauseNode((yyvsp[-2].node), (yyvsp[0].slist)); ;} 02676 break; 02677 02678 case 183: 02679 #line 584 "grammar.y" 02680 { (yyval.ccl) = new CaseClauseNode(0); ;} 02681 break; 02682 02683 case 184: 02684 #line 585 "grammar.y" 02685 { (yyval.ccl) = new CaseClauseNode(0, (yyvsp[0].slist)); ;} 02686 break; 02687 02688 case 185: 02689 #line 589 "grammar.y" 02690 { (yyvsp[0].stat)->pushLabel(*(yyvsp[-2].ident)); 02691 (yyval.stat) = new LabelNode(*(yyvsp[-2].ident), (yyvsp[0].stat)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); ;} 02692 break; 02693 02694 case 186: 02695 #line 594 "grammar.y" 02696 { (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;} 02697 break; 02698 02699 case 187: 02700 #line 595 "grammar.y" 02701 { if (automatic()) { 02702 (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); 02703 } else { 02704 YYABORT; } ;} 02705 break; 02706 02707 case 188: 02708 #line 602 "grammar.y" 02709 { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].cnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;} 02710 break; 02711 02712 case 189: 02713 #line 603 "grammar.y" 02714 { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;} 02715 break; 02716 02717 case 190: 02718 #line 604 "grammar.y" 02719 { (yyval.stat) = new TryNode((yyvsp[-2].stat), (yyvsp[-1].cnode), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-3]),(yylsp[-3])); ;} 02720 break; 02721 02722 case 191: 02723 #line 608 "grammar.y" 02724 { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;} 02725 break; 02726 02727 case 192: 02728 #line 609 "grammar.y" 02729 { if (automatic()) { 02730 (yyval.stat) = new EmptyStatementNode(); 02731 DBG((yyval.stat), (yylsp[-1]), (yylsp[-1])); 02732 } else { 02733 YYABORT; } ;} 02734 break; 02735 02736 case 193: 02737 #line 618 "grammar.y" 02738 { CatchNode *c; (yyval.cnode) = c = new CatchNode(*(yyvsp[-2].ident), (yyvsp[0].stat)); 02739 DBG(c,(yylsp[-4]),(yylsp[-1])); ;} 02740 break; 02741 02742 case 194: 02743 #line 623 "grammar.y" 02744 { FinallyNode *f; (yyval.fnode) = f = new FinallyNode((yyvsp[0].stat)); DBG(f,(yylsp[-1]),(yylsp[-1])); ;} 02745 break; 02746 02747 case 196: 02748 #line 629 "grammar.y" 02749 { (yyval.func) = (yyvsp[0].func); ;} 02750 break; 02751 02752 case 197: 02753 #line 633 "grammar.y" 02754 { (yyval.func) = new FuncDeclNode(*(yyvsp[-3].ident), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-4]),(yylsp[-1])); ;} 02755 break; 02756 02757 case 198: 02758 #line 635 "grammar.y" 02759 { (yyval.func) = new FuncDeclNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-5]),(yylsp[-1])); ;} 02760 break; 02761 02762 case 199: 02763 #line 640 "grammar.y" 02764 { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[0].body)); ;} 02765 break; 02766 02767 case 200: 02768 #line 642 "grammar.y" 02769 { (yyval.node) = new FuncExprNode(Identifier::null(), (yyvsp[-2].param), (yyvsp[0].body)); ;} 02770 break; 02771 02772 case 201: 02773 #line 644 "grammar.y" 02774 { (yyval.node) = new FuncExprNode(*(yyvsp[-3].ident), (yyvsp[0].body)); ;} 02775 break; 02776 02777 case 202: 02778 #line 646 "grammar.y" 02779 { (yyval.node) = new FuncExprNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); ;} 02780 break; 02781 02782 case 203: 02783 #line 650 "grammar.y" 02784 { (yyval.param) = new ParameterNode(*(yyvsp[0].ident)); ;} 02785 break; 02786 02787 case 204: 02788 #line 651 "grammar.y" 02789 { (yyval.param) = new ParameterNode((yyvsp[-2].param), *(yyvsp[0].ident)); ;} 02790 break; 02791 02792 case 205: 02793 #line 655 "grammar.y" 02794 { (yyval.body) = new FunctionBodyNode(0); 02795 DBG((yyval.body), (yylsp[-1]), (yylsp[0]));;} 02796 break; 02797 02798 case 206: 02799 #line 657 "grammar.y" 02800 { (yyval.body) = new FunctionBodyNode((yyvsp[-1].srcs)); 02801 DBG((yyval.body), (yylsp[-2]), (yylsp[0]));;} 02802 break; 02803 02804 case 207: 02805 #line 662 "grammar.y" 02806 { (yyval.prog) = new FunctionBodyNode(0); 02807 (yyval.prog)->setLoc(0, 0, Parser::source); 02808 Parser::progNode = (yyval.prog); ;} 02809 break; 02810 02811 case 208: 02812 #line 665 "grammar.y" 02813 { (yyval.prog) = new FunctionBodyNode((yyvsp[0].srcs)); 02814 Parser::progNode = (yyval.prog); ;} 02815 break; 02816 02817 case 209: 02818 #line 670 "grammar.y" 02819 { (yyval.srcs) = new SourceElementsNode((yyvsp[0].stat)); ;} 02820 break; 02821 02822 case 210: 02823 #line 671 "grammar.y" 02824 { (yyval.srcs) = new SourceElementsNode((yyvsp[-1].srcs), (yyvsp[0].stat)); ;} 02825 break; 02826 02827 case 211: 02828 #line 675 "grammar.y" 02829 { (yyval.stat) = (yyvsp[0].stat); ;} 02830 break; 02831 02832 case 212: 02833 #line 676 "grammar.y" 02834 { (yyval.stat) = (yyvsp[0].func); ;} 02835 break; 02836 02837 02838 default: break; 02839 } 02840 02841 /* Line 1126 of yacc.c. */ 02842 #line 2843 "grammar.tab.c" 02843 02844 yyvsp -= yylen; 02845 yyssp -= yylen; 02846 yylsp -= yylen; 02847 02848 YY_STACK_PRINT (yyss, yyssp); 02849 02850 *++yyvsp = yyval; 02851 *++yylsp = yyloc; 02852 02853 /* Now `shift' the result of the reduction. Determine what state 02854 that goes to, based on the state we popped back to and the rule 02855 number reduced by. */ 02856 02857 yyn = yyr1[yyn]; 02858 02859 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 02860 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 02861 yystate = yytable[yystate]; 02862 else 02863 yystate = yydefgoto[yyn - YYNTOKENS]; 02864 02865 goto yynewstate; 02866 02867 02868 /*------------------------------------. 02869 | yyerrlab -- here on detecting error | 02870 `------------------------------------*/ 02871 yyerrlab: 02872 /* If not already recovering from an error, report this error. */ 02873 if (!yyerrstatus) 02874 { 02875 ++yynerrs; 02876 #if YYERROR_VERBOSE 02877 yyn = yypact[yystate]; 02878 02879 if (YYPACT_NINF < yyn && yyn < YYLAST) 02880 { 02881 int yytype = YYTRANSLATE (yychar); 02882 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 02883 YYSIZE_T yysize = yysize0; 02884 YYSIZE_T yysize1; 02885 int yysize_overflow = 0; 02886 char *yymsg = 0; 02887 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5 02888 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 02889 int yyx; 02890 02891 #if 0 02892 /* This is so xgettext sees the translatable formats that are 02893 constructed on the fly. */ 02894 YY_("syntax error, unexpected %s"); 02895 YY_("syntax error, unexpected %s, expecting %s"); 02896 YY_("syntax error, unexpected %s, expecting %s or %s"); 02897 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 02898 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 02899 #endif 02900 char *yyfmt; 02901 char const *yyf; 02902 static char const yyunexpected[] = "syntax error, unexpected %s"; 02903 static char const yyexpecting[] = ", expecting %s"; 02904 static char const yyor[] = " or %s"; 02905 char yyformat[sizeof yyunexpected 02906 + sizeof yyexpecting - 1 02907 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 02908 * (sizeof yyor - 1))]; 02909 char const *yyprefix = yyexpecting; 02910 02911 /* Start YYX at -YYN if negative to avoid negative indexes in 02912 YYCHECK. */ 02913 int yyxbegin = yyn < 0 ? -yyn : 0; 02914 02915 /* Stay within bounds of both yycheck and yytname. */ 02916 int yychecklim = YYLAST - yyn; 02917 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 02918 int yycount = 1; 02919 02920 yyarg[0] = yytname[yytype]; 02921 yyfmt = yystpcpy (yyformat, yyunexpected); 02922 02923 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 02924 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 02925 { 02926 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 02927 { 02928 yycount = 1; 02929 yysize = yysize0; 02930 yyformat[sizeof yyunexpected - 1] = '\0'; 02931 break; 02932 } 02933 yyarg[yycount++] = yytname[yyx]; 02934 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 02935 yysize_overflow |= yysize1 < yysize; 02936 yysize = yysize1; 02937 yyfmt = yystpcpy (yyfmt, yyprefix); 02938 yyprefix = yyor; 02939 } 02940 02941 yyf = YY_(yyformat); 02942 yysize1 = yysize + yystrlen (yyf); 02943 yysize_overflow |= yysize1 < yysize; 02944 yysize = yysize1; 02945 02946 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM) 02947 yymsg = (char *) YYSTACK_ALLOC (yysize); 02948 if (yymsg) 02949 { 02950 /* Avoid sprintf, as that infringes on the user's name space. 02951 Don't have undefined behavior even if the translation 02952 produced a string with the wrong number of "%s"s. */ 02953 char *yyp = yymsg; 02954 int yyi = 0; 02955 while ((*yyp = *yyf)) 02956 { 02957 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 02958 { 02959 yyp += yytnamerr (yyp, yyarg[yyi++]); 02960 yyf += 2; 02961 } 02962 else 02963 { 02964 yyp++; 02965 yyf++; 02966 } 02967 } 02968 yyerror (yymsg); 02969 YYSTACK_FREE (yymsg); 02970 } 02971 else 02972 { 02973 yyerror (YY_("syntax error")); 02974 goto yyexhaustedlab; 02975 } 02976 } 02977 else 02978 #endif /* YYERROR_VERBOSE */ 02979 yyerror (YY_("syntax error")); 02980 } 02981 02982 yyerror_range[0] = yylloc; 02983 02984 if (yyerrstatus == 3) 02985 { 02986 /* If just tried and failed to reuse look-ahead token after an 02987 error, discard it. */ 02988 02989 if (yychar <= YYEOF) 02990 { 02991 /* Return failure if at end of input. */ 02992 if (yychar == YYEOF) 02993 YYABORT; 02994 } 02995 else 02996 { 02997 yydestruct ("Error: discarding", yytoken, &yylval, &yylloc); 02998 yychar = YYEMPTY; 02999 } 03000 } 03001 03002 /* Else will try to reuse look-ahead token after shifting the error 03003 token. */ 03004 goto yyerrlab1; 03005 03006 03007 /*---------------------------------------------------. 03008 | yyerrorlab -- error raised explicitly by YYERROR. | 03009 `---------------------------------------------------*/ 03010 yyerrorlab: 03011 03012 /* Pacify compilers like GCC when the user code never invokes 03013 YYERROR and the label yyerrorlab therefore never appears in user 03014 code. */ 03015 if (0) 03016 goto yyerrorlab; 03017 03018 yyerror_range[0] = yylsp[1-yylen]; 03019 yylsp -= yylen; 03020 yyvsp -= yylen; 03021 yyssp -= yylen; 03022 yystate = *yyssp; 03023 goto yyerrlab1; 03024 03025 03026 /*-------------------------------------------------------------. 03027 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03028 `-------------------------------------------------------------*/ 03029 yyerrlab1: 03030 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03031 03032 for (;;) 03033 { 03034 yyn = yypact[yystate]; 03035 if (yyn != YYPACT_NINF) 03036 { 03037 yyn += YYTERROR; 03038 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03039 { 03040 yyn = yytable[yyn]; 03041 if (0 < yyn) 03042 break; 03043 } 03044 } 03045 03046 /* Pop the current state because it cannot handle the error token. */ 03047 if (yyssp == yyss) 03048 YYABORT; 03049 03050 yyerror_range[0] = *yylsp; 03051 yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp); 03052 YYPOPSTACK; 03053 yystate = *yyssp; 03054 YY_STACK_PRINT (yyss, yyssp); 03055 } 03056 03057 if (yyn == YYFINAL) 03058 YYACCEPT; 03059 03060 *++yyvsp = yylval; 03061 03062 yyerror_range[1] = yylloc; 03063 /* Using YYLLOC is tempting, but would change the location of 03064 the look-ahead. YYLOC is available though. */ 03065 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2); 03066 *++yylsp = yyloc; 03067 03068 /* Shift the error token. */ 03069 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03070 03071 yystate = yyn; 03072 goto yynewstate; 03073 03074 03075 /*-------------------------------------. 03076 | yyacceptlab -- YYACCEPT comes here. | 03077 `-------------------------------------*/ 03078 yyacceptlab: 03079 yyresult = 0; 03080 goto yyreturn; 03081 03082 /*-----------------------------------. 03083 | yyabortlab -- YYABORT comes here. | 03084 `-----------------------------------*/ 03085 yyabortlab: 03086 yyresult = 1; 03087 goto yyreturn; 03088 03089 #ifndef yyoverflow 03090 /*-------------------------------------------------. 03091 | yyexhaustedlab -- memory exhaustion comes here. | 03092 `-------------------------------------------------*/ 03093 yyexhaustedlab: 03094 yyerror (YY_("memory exhausted")); 03095 yyresult = 2; 03096 /* Fall through. */ 03097 #endif 03098 03099 yyreturn: 03100 if (yychar != YYEOF && yychar != YYEMPTY) 03101 yydestruct ("Cleanup: discarding lookahead", 03102 yytoken, &yylval, &yylloc); 03103 while (yyssp != yyss) 03104 { 03105 yydestruct ("Cleanup: popping", 03106 yystos[*yyssp], yyvsp, yylsp); 03107 YYPOPSTACK; 03108 } 03109 #ifndef yyoverflow 03110 if (yyss != yyssa) 03111 YYSTACK_FREE (yyss); 03112 #endif 03113 return yyresult; 03114 } 03115 03116 03117 #line 679 "grammar.y" 03118 03119 03120 int yyerror (const char * /* s */) /* Called by yyparse on error */ 03121 { 03122 // fprintf(stderr, "ERROR: %s at line %d\n", 03123 // s, KJS::Lexer::curr()->lineNo()); 03124 return 1; 03125 } 03126 03127 /* may we automatically insert a semicolon ? */ 03128 bool automatic() 03129 { 03130 if (Lexer::curr()->hadError()) 03131 return false; 03132 if (yychar == '}' || yychar == 0) 03133 return true; 03134 else if (Lexer::curr()->prevTerminator()) 03135 return true; 03136 03137 return false; 03138 } 03139