File indexing completed on 2024-05-12 15:43:22
0001 /* A Bison parser, made by GNU Bison 2.7. */ 0002 0003 /* Bison implementation for Yacc-like parsers in C 0004 0005 Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. 0006 0007 This program is free software: you can redistribute it and/or modify 0008 it under the terms of the GNU General Public License as published by 0009 the Free Software Foundation, either version 3 of the License, or 0010 (at your option) any later version. 0011 0012 This program is distributed in the hope that it will be useful, 0013 but WITHOUT ANY WARRANTY; without even the implied warranty of 0014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 0015 GNU General Public License for more details. 0016 0017 You should have received a copy of the GNU General Public License 0018 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 0019 0020 /* As a special exception, you may create a larger work that contains 0021 part or all of the Bison parser skeleton and distribute that work 0022 under terms of your choice, so long as that work isn't itself a 0023 parser generator using the skeleton or a modified version thereof 0024 as a parser skeleton. Alternatively, if you modify or redistribute 0025 the parser skeleton itself, you may (at your option) remove this 0026 special exception, which will cause the skeleton and the resulting 0027 Bison output files to be licensed under the GNU General Public 0028 License without this special exception. 0029 0030 This special exception was added by the Free Software Foundation in 0031 version 2.2 of Bison. */ 0032 0033 /* C LALR(1) parser skeleton written by Richard Stallman, by 0034 simplifying the original so-called "semantic" parser. */ 0035 0036 /* All symbols defined below should begin with yy or YY, to avoid 0037 infringing on user name space. This should be done even for local 0038 variables, as they might otherwise be expanded by user macros. 0039 There are some unavoidable exceptions within include files to 0040 define necessary library symbols; they are noted "INFRINGES ON 0041 USER NAME SPACE" below. */ 0042 0043 /* Identify Bison output. */ 0044 #define YYBISON 1 0045 0046 /* Bison version. */ 0047 #define YYBISON_VERSION "2.7" 0048 0049 /* Skeleton name. */ 0050 #define YYSKELETON_NAME "yacc.c" 0051 0052 /* Pure parsers. */ 0053 #define YYPURE 0 0054 0055 /* Push parsers. */ 0056 #define YYPUSH 0 0057 0058 /* Pull parsers. */ 0059 #define YYPULL 1 0060 0061 /* Substitute the variable and function names. */ 0062 #define yyparse kjsyyparse 0063 #define yylex kjsyylex 0064 #define yyerror kjsyyerror 0065 #define yylval kjsyylval 0066 #define yychar kjsyychar 0067 #define yydebug kjsyydebug 0068 #define yynerrs kjsyynerrs 0069 #define yylloc kjsyylloc 0070 0071 /* Copy the first part of user declarations. */ 0072 /* Line 371 of yacc.c */ 0073 #line 1 "grammar.y" 0074 0075 /* 0076 * This file is part of the KDE libraries 0077 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) 0078 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved. 0079 * Copyright (C) 2019 froglogic GmbH (contact@froglogic.com) 0080 * 0081 * This library is free software; you can redistribute it and/or 0082 * modify it under the terms of the GNU Lesser General Public 0083 * License as published by the Free Software Foundation; either 0084 * version 2 of the License, or (at your option) any later version. 0085 * 0086 * This library is distributed in the hope that it will be useful, 0087 * but WITHOUT ANY WARRANTY; without even the implied warranty of 0088 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 0089 * Lesser General Public License for more details. 0090 * 0091 * You should have received a copy of the GNU Lesser General Public 0092 * License along with this library; if not, write to the Free Software 0093 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 0094 * 0095 */ 0096 0097 #include <string.h> 0098 #include <stdlib.h> 0099 #include <stdio.h> 0100 #include "value.h" 0101 #include "object.h" 0102 #include "types.h" 0103 #include "interpreter.h" 0104 #include "nodes.h" 0105 #include "makenodes.h" 0106 #include "lexer.h" 0107 #include "internal.h" 0108 0109 // Not sure why, but yacc doesn't add this define along with the others. 0110 #define yylloc kjsyylloc 0111 0112 /* default values for bison */ 0113 #define YYDEBUG 0 // Set to 1 to debug a parse error. 0114 #define kjsyydebug 0 // Set to 1 to debug a parse error. 0115 #if !PLATFORM(DARWIN) 0116 // avoid triggering warnings in older bison 0117 #define YYERROR_VERBOSE 0118 #endif 0119 0120 extern int kjsyylex(); 0121 int kjsyyerror(const char *); 0122 static bool allowAutomaticSemicolon(); 0123 0124 #define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0) 0125 #define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line) 0126 0127 #ifndef __GNUC__ 0128 # define __attribute__(x) 0129 #endif 0130 0131 using namespace KJS; 0132 0133 /* Line 371 of yacc.c */ 0134 #line 138 "grammar.cpp" 0135 0136 # ifndef YY_NULL 0137 # if defined __cplusplus && 201103L <= __cplusplus 0138 # define YY_NULL nullptr 0139 # else 0140 # define YY_NULL 0 0141 # endif 0142 # endif 0143 0144 /* Enabling verbose error messages. */ 0145 #ifdef YYERROR_VERBOSE 0146 # undef YYERROR_VERBOSE 0147 # define YYERROR_VERBOSE 1 0148 #else 0149 # define YYERROR_VERBOSE 0 0150 #endif 0151 0152 /* In a future release of Bison, this section will be replaced 0153 by #include "grammar.h". */ 0154 #ifndef YY_KJSYY_GRAMMAR_H_INCLUDED 0155 # define YY_KJSYY_GRAMMAR_H_INCLUDED 0156 /* Enabling traces. */ 0157 #ifndef YYDEBUG 0158 # define YYDEBUG 0 0159 #endif 0160 #if YYDEBUG 0161 extern int kjsyydebug; 0162 #endif 0163 0164 /* Tokens. */ 0165 #ifndef YYTOKENTYPE 0166 # define YYTOKENTYPE 0167 /* Put the tokens into the symbol table, so that GDB and other debuggers 0168 know about them. */ 0169 enum yytokentype { 0170 NULLTOKEN = 258, 0171 TRUETOKEN = 259, 0172 FALSETOKEN = 260, 0173 BREAK = 261, 0174 CASE = 262, 0175 DEFAULT = 263, 0176 FOR = 264, 0177 NEW = 265, 0178 VAR = 266, 0179 CONSTTOKEN = 267, 0180 CONTINUE = 268, 0181 FUNCTION = 269, 0182 RETURN = 270, 0183 VOIDTOKEN = 271, 0184 DELETETOKEN = 272, 0185 IF = 273, 0186 THISTOKEN = 274, 0187 DO = 275, 0188 WHILE = 276, 0189 INTOKEN = 277, 0190 INSTANCEOF = 278, 0191 TYPEOF = 279, 0192 SWITCH = 280, 0193 WITH = 281, 0194 RESERVED = 282, 0195 THROW = 283, 0196 TRY = 284, 0197 CATCH = 285, 0198 FINALLY = 286, 0199 DEBUGGER = 287, 0200 IMPORT = 288, 0201 IF_WITHOUT_ELSE = 289, 0202 ELSE = 290, 0203 EQEQ = 291, 0204 NE = 292, 0205 STREQ = 293, 0206 STRNEQ = 294, 0207 LE = 295, 0208 GE = 296, 0209 OR = 297, 0210 AND = 298, 0211 PLUSPLUS = 299, 0212 MINUSMINUS = 300, 0213 LSHIFT = 301, 0214 RSHIFT = 302, 0215 URSHIFT = 303, 0216 T_EXP = 304, 0217 PLUSEQUAL = 305, 0218 MINUSEQUAL = 306, 0219 MULTEQUAL = 307, 0220 DIVEQUAL = 308, 0221 EXPEQUAL = 309, 0222 LSHIFTEQUAL = 310, 0223 RSHIFTEQUAL = 311, 0224 URSHIFTEQUAL = 312, 0225 ANDEQUAL = 313, 0226 MODEQUAL = 314, 0227 XOREQUAL = 315, 0228 OREQUAL = 316, 0229 NUMBER = 317, 0230 STRING = 318, 0231 IDENT = 319, 0232 AUTOPLUSPLUS = 320, 0233 AUTOMINUSMINUS = 321 0234 }; 0235 #endif 0236 0237 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 0238 typedef union YYSTYPE { 0239 /* Line 387 of yacc.c */ 0240 #line 63 "grammar.y" 0241 0242 int ival; 0243 double dval; 0244 UString *ustr; 0245 Identifier *ident; 0246 Node *node; 0247 StatementNode *stat; 0248 ParameterNode *param; 0249 FunctionBodyNode *body; 0250 FuncDeclNode *func; 0251 FuncExprNode *funcExpr; 0252 ProgramNode *prog; 0253 AssignExprNode *init; 0254 SourceElementsNode *srcs; 0255 ArgumentsNode *args; 0256 ArgumentListNode *alist; 0257 VarDeclNode *decl; 0258 VarDeclListNode *vlist; 0259 CaseBlockNode *cblk; 0260 ClauseListNode *clist; 0261 CaseClauseNode *ccl; 0262 ElementNode *elm; 0263 Operator op; 0264 PropertyListNode *plist; 0265 PropertyNode *pnode; 0266 PropertyNameNode *pname; 0267 PackageNameNode *pkgn; 0268 0269 /* Line 387 of yacc.c */ 0270 #line 277 "grammar.cpp" 0271 } YYSTYPE; 0272 # define YYSTYPE_IS_TRIVIAL 1 0273 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 0274 # define YYSTYPE_IS_DECLARED 1 0275 #endif 0276 0277 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 0278 typedef struct YYLTYPE { 0279 int first_line; 0280 int first_column; 0281 int last_line; 0282 int last_column; 0283 } YYLTYPE; 0284 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ 0285 # define YYLTYPE_IS_DECLARED 1 0286 # define YYLTYPE_IS_TRIVIAL 1 0287 #endif 0288 0289 extern YYSTYPE kjsyylval; 0290 extern YYLTYPE kjsyylloc; 0291 #ifdef YYPARSE_PARAM 0292 #if defined __STDC__ || defined __cplusplus 0293 int kjsyyparse(void *YYPARSE_PARAM); 0294 #else 0295 int kjsyyparse(); 0296 #endif 0297 #else /* ! YYPARSE_PARAM */ 0298 #if defined __STDC__ || defined __cplusplus 0299 int kjsyyparse(void); 0300 #else 0301 int kjsyyparse(); 0302 #endif 0303 #endif /* ! YYPARSE_PARAM */ 0304 0305 #endif /* !YY_KJSYY_GRAMMAR_H_INCLUDED */ 0306 0307 /* Copy the second part of user declarations. */ 0308 0309 /* Line 390 of yacc.c */ 0310 #line 318 "grammar.cpp" 0311 0312 #ifdef short 0313 # undef short 0314 #endif 0315 0316 #ifdef YYTYPE_UINT8 0317 typedef YYTYPE_UINT8 yytype_uint8; 0318 #else 0319 typedef unsigned char yytype_uint8; 0320 #endif 0321 0322 #ifdef YYTYPE_INT8 0323 typedef YYTYPE_INT8 yytype_int8; 0324 #elif (defined __STDC__ || defined __C99__FUNC__ \ 0325 || defined __cplusplus || defined _MSC_VER) 0326 typedef signed char yytype_int8; 0327 #else 0328 typedef short int yytype_int8; 0329 #endif 0330 0331 #ifdef YYTYPE_UINT16 0332 typedef YYTYPE_UINT16 yytype_uint16; 0333 #else 0334 typedef unsigned short int yytype_uint16; 0335 #endif 0336 0337 #ifdef YYTYPE_INT16 0338 typedef YYTYPE_INT16 yytype_int16; 0339 #else 0340 typedef short int yytype_int16; 0341 #endif 0342 0343 #ifndef YYSIZE_T 0344 # ifdef __SIZE_TYPE__ 0345 # define YYSIZE_T __SIZE_TYPE__ 0346 # elif defined size_t 0347 # define YYSIZE_T size_t 0348 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 0349 || defined __cplusplus || defined _MSC_VER) 0350 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 0351 # define YYSIZE_T size_t 0352 # else 0353 # define YYSIZE_T unsigned int 0354 # endif 0355 #endif 0356 0357 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 0358 0359 #ifndef YY_ 0360 # if defined YYENABLE_NLS && YYENABLE_NLS 0361 # if ENABLE_NLS 0362 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 0363 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 0364 # endif 0365 # endif 0366 # ifndef YY_ 0367 # define YY_(Msgid) Msgid 0368 # endif 0369 #endif 0370 0371 /* Suppress unused-variable warnings by "using" E. */ 0372 #if ! defined lint || defined __GNUC__ 0373 # define YYUSE(E) ((void) (E)) 0374 #else 0375 # define YYUSE(E) /* empty */ 0376 #endif 0377 0378 /* Identity function, used to suppress warnings about constant conditions. */ 0379 #ifndef lint 0380 # define YYID(N) (N) 0381 #else 0382 #if (defined __STDC__ || defined __C99__FUNC__ \ 0383 || defined __cplusplus || defined _MSC_VER) 0384 static int 0385 YYID(int yyi) 0386 #else 0387 static int 0388 YYID(yyi) 0389 int yyi; 0390 #endif 0391 { 0392 return yyi; 0393 } 0394 #endif 0395 0396 #if ! defined yyoverflow || YYERROR_VERBOSE 0397 0398 /* The parser invokes alloca or malloc; define the necessary symbols. */ 0399 0400 # ifdef YYSTACK_USE_ALLOCA 0401 # if YYSTACK_USE_ALLOCA 0402 # ifdef __GNUC__ 0403 # define YYSTACK_ALLOC __builtin_alloca 0404 # elif defined __BUILTIN_VA_ARG_INCR 0405 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 0406 # elif defined _AIX 0407 # define YYSTACK_ALLOC __alloca 0408 # elif defined _MSC_VER 0409 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 0410 # define alloca _alloca 0411 # else 0412 # define YYSTACK_ALLOC alloca 0413 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 0414 || defined __cplusplus || defined _MSC_VER) 0415 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 0416 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 0417 # ifndef EXIT_SUCCESS 0418 # define EXIT_SUCCESS 0 0419 # endif 0420 # endif 0421 # endif 0422 # endif 0423 # endif 0424 0425 # ifdef YYSTACK_ALLOC 0426 /* Pacify GCC's `empty if-body' warning. */ 0427 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 0428 # ifndef YYSTACK_ALLOC_MAXIMUM 0429 /* The OS might guarantee only one guard page at the bottom of the stack, 0430 and a page size can be as small as 4096 bytes. So we cannot safely 0431 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 0432 to allow for a few compiler-allocated temporary stack slots. */ 0433 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 0434 # endif 0435 # else 0436 # define YYSTACK_ALLOC YYMALLOC 0437 # define YYSTACK_FREE YYFREE 0438 # ifndef YYSTACK_ALLOC_MAXIMUM 0439 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 0440 # endif 0441 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 0442 && ! ((defined YYMALLOC || defined malloc) \ 0443 && (defined YYFREE || defined free))) 0444 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 0445 # ifndef EXIT_SUCCESS 0446 # define EXIT_SUCCESS 0 0447 # endif 0448 # endif 0449 # ifndef YYMALLOC 0450 # define YYMALLOC malloc 0451 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 0452 || defined __cplusplus || defined _MSC_VER) 0453 void *malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 0454 # endif 0455 # endif 0456 # ifndef YYFREE 0457 # define YYFREE free 0458 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 0459 || defined __cplusplus || defined _MSC_VER) 0460 void free(void *); /* INFRINGES ON USER NAME SPACE */ 0461 # endif 0462 # endif 0463 # endif 0464 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 0465 0466 #if (! defined yyoverflow \ 0467 && (! defined __cplusplus \ 0468 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ 0469 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 0470 0471 /* A type that is properly aligned for any stack member. */ 0472 union yyalloc { 0473 yytype_int16 yyss_alloc; 0474 YYSTYPE yyvs_alloc; 0475 YYLTYPE yyls_alloc; 0476 }; 0477 0478 /* The size of the maximum gap between one aligned stack and the next. */ 0479 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 0480 0481 /* The size of an array large to enough to hold all stacks, each with 0482 N elements. */ 0483 # define YYSTACK_BYTES(N) \ 0484 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ 0485 + 2 * YYSTACK_GAP_MAXIMUM) 0486 0487 # define YYCOPY_NEEDED 1 0488 0489 /* Relocate STACK from its old location to the new one. The 0490 local variables YYSIZE and YYSTACKSIZE give the old and new number of 0491 elements in the stack, and YYPTR gives the new location of the 0492 stack. Advance YYPTR to a properly aligned location for the next 0493 stack. */ 0494 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 0495 do \ 0496 { \ 0497 YYSIZE_T yynewbytes; \ 0498 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 0499 Stack = &yyptr->Stack_alloc; \ 0500 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 0501 yyptr += yynewbytes / sizeof (*yyptr); \ 0502 } \ 0503 while (YYID (0)) 0504 0505 #endif 0506 0507 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 0508 /* Copy COUNT objects from SRC to DST. The source and destination do 0509 not overlap. */ 0510 # ifndef YYCOPY 0511 # if defined __GNUC__ && 1 < __GNUC__ 0512 # define YYCOPY(Dst, Src, Count) \ 0513 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 0514 # else 0515 # define YYCOPY(Dst, Src, Count) \ 0516 do \ 0517 { \ 0518 YYSIZE_T yyi; \ 0519 for (yyi = 0; yyi < (Count); yyi++) \ 0520 (Dst)[yyi] = (Src)[yyi]; \ 0521 } \ 0522 while (YYID (0)) 0523 # endif 0524 # endif 0525 #endif /* !YYCOPY_NEEDED */ 0526 0527 /* YYFINAL -- State number of the termination state. */ 0528 #define YYFINAL 219 0529 /* YYLAST -- Last index in YYTABLE. */ 0530 #define YYLAST 1750 0531 0532 /* YYNTOKENS -- Number of terminals. */ 0533 #define YYNTOKENS 91 0534 /* YYNNTS -- Number of nonterminals. */ 0535 #define YYNNTS 117 0536 /* YYNRULES -- Number of rules. */ 0537 #define YYNRULES 359 0538 /* YYNRULES -- Number of states. */ 0539 #define YYNSTATES 599 0540 0541 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 0542 #define YYUNDEFTOK 2 0543 #define YYMAXUTOK 321 0544 0545 #define YYTRANSLATE(YYX) \ 0546 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 0547 0548 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 0549 static const yytype_uint8 yytranslate[] = { 0550 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0552 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0553 2, 2, 2, 80, 2, 2, 2, 82, 85, 2, 0554 69, 70, 81, 77, 71, 78, 76, 67, 2, 2, 0555 2, 2, 2, 2, 2, 2, 2, 2, 68, 90, 0556 83, 89, 84, 88, 2, 2, 2, 2, 2, 2, 0557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0559 2, 74, 2, 75, 86, 2, 2, 2, 2, 2, 0560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0562 2, 2, 2, 72, 87, 73, 79, 2, 2, 2, 0563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0575 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 0576 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0577 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 0578 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 0579 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 0580 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 0581 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0582 65, 66 0583 }; 0584 0585 #if YYDEBUG 0586 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 0587 YYRHS. */ 0588 static const yytype_uint16 yyprhs[] = { 0589 0, 0, 3, 5, 7, 9, 11, 13, 15, 17, 0590 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 0591 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 0592 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 0593 79, 81, 83, 85, 87, 89, 93, 94, 101, 102, 0594 110, 112, 116, 118, 121, 125, 130, 132, 134, 136, 0595 138, 142, 146, 150, 156, 159, 164, 165, 167, 169, 0596 172, 174, 176, 181, 185, 189, 191, 196, 200, 204, 0597 206, 209, 211, 214, 217, 220, 225, 229, 232, 235, 0598 240, 244, 247, 251, 253, 257, 259, 261, 263, 265, 0599 268, 271, 274, 277, 279, 282, 285, 287, 289, 292, 0600 295, 297, 300, 303, 306, 309, 312, 315, 318, 320, 0601 322, 324, 326, 328, 332, 334, 338, 340, 344, 348, 0602 352, 354, 358, 362, 366, 368, 372, 376, 378, 382, 0603 386, 388, 392, 396, 400, 402, 406, 410, 414, 416, 0604 420, 424, 428, 432, 436, 440, 442, 446, 450, 454, 0605 458, 462, 464, 468, 472, 476, 480, 484, 488, 490, 0606 494, 498, 502, 506, 508, 512, 516, 520, 524, 526, 0607 530, 534, 538, 542, 544, 548, 550, 554, 556, 560, 0608 562, 566, 568, 572, 574, 578, 580, 584, 586, 590, 0609 592, 596, 598, 602, 604, 608, 610, 614, 616, 620, 0610 622, 626, 628, 632, 634, 640, 642, 648, 650, 656, 0611 658, 662, 664, 668, 670, 674, 676, 678, 680, 682, 0612 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 0613 706, 708, 712, 714, 718, 720, 722, 724, 726, 728, 0614 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 0615 750, 752, 755, 759, 763, 767, 769, 773, 775, 779, 0616 781, 784, 786, 789, 793, 797, 799, 803, 805, 808, 0617 811, 814, 816, 819, 822, 828, 836, 844, 852, 858, 0618 868, 879, 887, 896, 906, 907, 909, 910, 912, 915, 0619 918, 922, 926, 929, 932, 936, 940, 943, 946, 950, 0620 954, 960, 966, 970, 976, 977, 979, 981, 984, 988, 0621 993, 996, 1000, 1004, 1008, 1012, 1017, 1025, 1035, 1038, 0622 1041, 1043, 1047, 1053, 1059, 1063, 1067, 1073, 1079, 1080, 0623 1087, 1088, 1096, 1097, 1103, 1104, 1111, 1112, 1119, 1120, 0624 1128, 1130, 1134, 1137, 1141, 1142, 1144, 1146, 1149, 1151 0625 }; 0626 0627 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 0628 static const yytype_int16 yyrhs[] = { 0629 205, 0, -1, 6, -1, 7, -1, 8, -1, 9, 0630 -1, 10, -1, 11, -1, 12, -1, 13, -1, 14, 0631 -1, 15, -1, 16, -1, 17, -1, 18, -1, 19, 0632 -1, 20, -1, 21, -1, 22, -1, 23, -1, 24, 0633 -1, 25, -1, 26, -1, 28, -1, 29, -1, 30, 0634 -1, 31, -1, 32, -1, 33, -1, 3, -1, 4, 0635 -1, 5, -1, 35, -1, 64, -1, 92, -1, 3, 0636 -1, 4, -1, 5, -1, 62, -1, 63, -1, 67, 0637 -1, 53, -1, 93, -1, 63, -1, 62, -1, 95, 0638 68, 154, -1, -1, 64, 93, 69, 70, 97, 204, 0639 -1, -1, 64, 93, 69, 203, 70, 98, 204, -1, 0640 96, -1, 99, 71, 96, -1, 101, -1, 72, 73, 0641 -1, 72, 99, 73, -1, 72, 99, 71, 73, -1, 0642 19, -1, 94, -1, 102, -1, 64, -1, 69, 158, 0643 70, -1, 74, 104, 75, -1, 74, 103, 75, -1, 0644 74, 103, 71, 104, 75, -1, 104, 154, -1, 103, 0645 71, 104, 154, -1, -1, 105, -1, 71, -1, 105, 0646 71, -1, 100, -1, 198, -1, 106, 74, 158, 75, 0647 -1, 106, 76, 93, -1, 10, 106, 112, -1, 101, 0648 -1, 107, 74, 158, 75, -1, 107, 76, 93, -1, 0649 10, 106, 112, -1, 106, -1, 10, 108, -1, 107, 0650 -1, 10, 108, -1, 106, 112, -1, 110, 112, -1, 0651 110, 74, 158, 75, -1, 110, 76, 93, -1, 107, 0652 112, -1, 111, 112, -1, 111, 74, 158, 75, -1, 0653 111, 76, 93, -1, 69, 70, -1, 69, 113, 70, 0654 -1, 154, -1, 113, 71, 154, -1, 108, -1, 110, 0655 -1, 109, -1, 111, -1, 44, 120, -1, 65, 120, 0656 -1, 45, 120, -1, 66, 120, -1, 114, -1, 114, 0657 44, -1, 114, 45, -1, 116, -1, 115, -1, 115, 0658 44, -1, 115, 45, -1, 116, -1, 17, 120, -1, 0659 16, 120, -1, 24, 120, -1, 77, 120, -1, 78, 0660 120, -1, 79, 120, -1, 80, 120, -1, 117, -1, 0661 119, -1, 118, -1, 119, -1, 120, -1, 117, 49, 0662 122, -1, 121, -1, 118, 49, 122, -1, 122, -1, 0663 124, 81, 122, -1, 124, 67, 122, -1, 124, 82, 0664 122, -1, 123, -1, 125, 81, 122, -1, 125, 67, 0665 122, -1, 125, 82, 122, -1, 124, -1, 126, 77, 0666 124, -1, 126, 78, 124, -1, 125, -1, 127, 77, 0667 124, -1, 127, 78, 124, -1, 126, -1, 128, 46, 0668 126, -1, 128, 47, 126, -1, 128, 48, 126, -1, 0669 127, -1, 129, 46, 126, -1, 129, 47, 126, -1, 0670 129, 48, 126, -1, 128, -1, 130, 83, 128, -1, 0671 130, 84, 128, -1, 130, 40, 128, -1, 130, 41, 0672 128, -1, 130, 23, 128, -1, 130, 22, 128, -1, 0673 128, -1, 131, 83, 128, -1, 131, 84, 128, -1, 0674 131, 40, 128, -1, 131, 41, 128, -1, 131, 23, 0675 128, -1, 129, -1, 132, 83, 128, -1, 132, 84, 0676 128, -1, 132, 40, 128, -1, 132, 41, 128, -1, 0677 132, 23, 128, -1, 132, 22, 128, -1, 130, -1, 0678 133, 36, 130, -1, 133, 37, 130, -1, 133, 38, 0679 130, -1, 133, 39, 130, -1, 131, -1, 134, 36, 0680 131, -1, 134, 37, 131, -1, 134, 38, 131, -1, 0681 134, 39, 131, -1, 132, -1, 135, 36, 130, -1, 0682 135, 37, 130, -1, 135, 38, 130, -1, 135, 39, 0683 130, -1, 133, -1, 136, 85, 133, -1, 134, -1, 0684 137, 85, 134, -1, 135, -1, 138, 85, 133, -1, 0685 136, -1, 139, 86, 136, -1, 137, -1, 140, 86, 0686 137, -1, 138, -1, 141, 86, 136, -1, 139, -1, 0687 142, 87, 139, -1, 140, -1, 143, 87, 140, -1, 0688 141, -1, 144, 87, 139, -1, 142, -1, 145, 43, 0689 142, -1, 143, -1, 146, 43, 143, -1, 144, -1, 0690 147, 43, 142, -1, 145, -1, 148, 42, 145, -1, 0691 146, -1, 149, 42, 146, -1, 147, -1, 150, 42, 0692 145, -1, 148, -1, 148, 88, 154, 68, 154, -1, 0693 149, -1, 149, 88, 155, 68, 155, -1, 150, -1, 0694 150, 88, 154, 68, 154, -1, 151, -1, 114, 157, 0695 154, -1, 152, -1, 114, 157, 155, -1, 153, -1, 0696 115, 157, 154, -1, 89, -1, 50, -1, 51, -1, 0697 52, -1, 53, -1, 54, -1, 55, -1, 56, -1, 0698 57, -1, 58, -1, 60, -1, 61, -1, 59, -1, 0699 154, -1, 158, 71, 154, -1, 155, -1, 159, 71, 0700 155, -1, 156, -1, 160, 71, 154, -1, 162, -1, 0701 163, -1, 168, -1, 173, -1, 174, -1, 175, -1, 0702 176, -1, 179, -1, 180, -1, 181, -1, 182, -1, 0703 183, -1, 189, -1, 190, -1, 191, -1, 192, -1, 0704 194, -1, 72, 73, -1, 72, 206, 73, -1, 11, 0705 164, 90, -1, 11, 164, 1, -1, 166, -1, 164, 0706 71, 166, -1, 167, -1, 165, 71, 167, -1, 64, 0707 -1, 64, 171, -1, 64, -1, 64, 172, -1, 12, 0708 169, 90, -1, 12, 169, 1, -1, 170, -1, 169, 0709 71, 170, -1, 64, -1, 64, 171, -1, 89, 154, 0710 -1, 89, 155, -1, 90, -1, 160, 90, -1, 160, 0711 1, -1, 18, 69, 158, 70, 161, -1, 18, 69, 0712 158, 70, 161, 35, 161, -1, 20, 161, 21, 69, 0713 158, 70, 90, -1, 20, 161, 21, 69, 158, 70, 0714 1, -1, 21, 69, 158, 70, 161, -1, 9, 69, 0715 178, 90, 177, 90, 177, 70, 161, -1, 9, 69, 0716 11, 165, 90, 177, 90, 177, 70, 161, -1, 9, 0717 69, 114, 22, 158, 70, 161, -1, 9, 69, 11, 0718 64, 22, 158, 70, 161, -1, 9, 69, 11, 64, 0719 172, 22, 158, 70, 161, -1, -1, 158, -1, -1, 0720 159, -1, 13, 90, -1, 13, 1, -1, 13, 64, 0721 90, -1, 13, 64, 1, -1, 6, 90, -1, 6, 0722 1, -1, 6, 64, 90, -1, 6, 64, 1, -1, 0723 15, 90, -1, 15, 1, -1, 15, 158, 90, -1, 0724 15, 158, 1, -1, 26, 69, 158, 70, 161, -1, 0725 25, 69, 158, 70, 184, -1, 72, 185, 73, -1, 0726 72, 185, 188, 185, 73, -1, -1, 186, -1, 187, 0727 -1, 186, 187, -1, 7, 158, 68, -1, 7, 158, 0728 68, 206, -1, 8, 68, -1, 8, 68, 206, -1, 0729 64, 68, 161, -1, 28, 158, 90, -1, 28, 158, 0730 1, -1, 29, 162, 31, 162, -1, 29, 162, 30, 0731 69, 64, 70, 162, -1, 29, 162, 30, 69, 64, 0732 70, 162, 31, 162, -1, 32, 90, -1, 32, 1, 0733 -1, 64, -1, 193, 76, 64, -1, 33, 193, 76, 0734 81, 90, -1, 33, 193, 76, 81, 1, -1, 33, 0735 193, 90, -1, 33, 193, 1, -1, 33, 64, 89, 0736 193, 90, -1, 33, 64, 89, 193, 1, -1, -1, 0737 14, 64, 69, 70, 196, 204, -1, -1, 14, 64, 0738 69, 203, 70, 197, 204, -1, -1, 14, 69, 70, 0739 199, 204, -1, -1, 14, 69, 203, 70, 200, 204, 0740 -1, -1, 14, 64, 69, 70, 201, 204, -1, -1, 0741 14, 64, 69, 203, 70, 202, 204, -1, 64, -1, 0742 203, 71, 64, -1, 72, 73, -1, 72, 206, 73, 0743 -1, -1, 206, -1, 207, -1, 206, 207, -1, 195, 0744 -1, 161, -1 0745 }; 0746 0747 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 0748 static const yytype_uint16 yyrline[] = { 0749 0, 194, 194, 195, 196, 197, 198, 199, 200, 201, 0750 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 0751 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 0752 222, 223, 224, 228, 229, 233, 234, 235, 236, 237, 0753 238, 244, 253, 254, 255, 259, 260, 260, 264, 264, 0754 271, 272, 276, 277, 278, 280, 284, 285, 286, 287, 0755 288, 293, 294, 295, 299, 300, 305, 306, 310, 311, 0756 315, 316, 317, 318, 319, 323, 324, 325, 326, 330, 0757 331, 335, 336, 340, 341, 342, 343, 347, 348, 349, 0758 350, 354, 355, 359, 360, 364, 365, 369, 370, 374, 0759 375, 376, 377, 381, 382, 383, 384, 388, 389, 390, 0760 391, 395, 396, 397, 398, 399, 400, 401, 404, 405, 0761 409, 410, 414, 415, 419, 420, 424, 425, 426, 427, 0762 431, 432, 434, 436, 441, 442, 443, 447, 448, 450, 0763 455, 456, 457, 458, 462, 463, 464, 465, 469, 470, 0764 471, 472, 473, 474, 475, 479, 480, 481, 482, 483, 0765 484, 489, 490, 491, 492, 493, 494, 496, 500, 501, 0766 502, 503, 504, 508, 509, 511, 513, 515, 520, 521, 0767 523, 524, 526, 531, 532, 536, 537, 542, 543, 547, 0768 548, 552, 553, 558, 559, 564, 565, 569, 570, 575, 0769 576, 581, 582, 586, 587, 592, 593, 598, 599, 603, 0770 604, 609, 610, 614, 615, 620, 621, 626, 627, 632, 0771 633, 638, 639, 644, 645, 650, 651, 652, 653, 654, 0772 655, 656, 657, 658, 659, 660, 661, 662, 666, 667, 0773 671, 672, 676, 677, 681, 682, 683, 684, 685, 686, 0774 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 0775 697, 701, 702, 706, 707, 711, 712, 717, 718, 723, 0776 724, 728, 729, 733, 734, 739, 740, 745, 746, 750, 0777 754, 758, 762, 763, 767, 769, 774, 775, 776, 777, 0778 779, 781, 789, 791, 796, 797, 801, 802, 806, 807, 0779 808, 809, 813, 814, 815, 816, 820, 821, 822, 823, 0780 827, 831, 835, 836, 841, 842, 846, 847, 851, 852, 0781 856, 857, 861, 865, 866, 870, 871, 872, 877, 878, 0782 882, 883, 887, 889, 891, 893, 895, 897, 902, 902, 0783 903, 903, 908, 908, 911, 911, 914, 914, 915, 915, 0784 921, 922, 926, 927, 931, 932, 936, 937, 941, 942 0785 }; 0786 #endif 0787 0788 #if YYDEBUG || YYERROR_VERBOSE || 0 0789 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 0790 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 0791 static const char *const yytname[] = { 0792 "$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN", 0793 "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR", "CONSTTOKEN", 0794 "CONTINUE", "FUNCTION", "RETURN", "VOIDTOKEN", "DELETETOKEN", "IF", 0795 "THISTOKEN", "DO", "WHILE", "INTOKEN", "INSTANCEOF", "TYPEOF", "SWITCH", 0796 "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "DEBUGGER", 0797 "IMPORT", "IF_WITHOUT_ELSE", "ELSE", "EQEQ", "NE", "STREQ", "STRNEQ", 0798 "LE", "GE", "OR", "AND", "PLUSPLUS", "MINUSMINUS", "LSHIFT", "RSHIFT", 0799 "URSHIFT", "T_EXP", "PLUSEQUAL", "MINUSEQUAL", "MULTEQUAL", "DIVEQUAL", 0800 "EXPEQUAL", "LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL", "ANDEQUAL", 0801 "MODEQUAL", "XOREQUAL", "OREQUAL", "NUMBER", "STRING", "IDENT", 0802 "AUTOPLUSPLUS", "AUTOMINUSMINUS", "'/'", "':'", "'('", "')'", "','", 0803 "'{'", "'}'", "'['", "']'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", 0804 "'%'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept", 0805 "Keywords", "IdentifierName", "Literal", "PropertyName", "Property", 0806 "$@1", "$@2", "PropertyList", "PrimaryExpr", "PrimaryExprNoBrace", 0807 "ArrayLiteral", "ElementList", "ElisionOpt", "Elision", "MemberExpr", 0808 "MemberExprNoBF", "NewExpr", "NewExprNoBF", "CallExpr", "CallExprNoBF", 0809 "Arguments", "ArgumentList", "LeftHandSideExpr", "LeftHandSideExprNoBF", 0810 "UpdateExprCommon", "UpdateExpr", "UpdateExprNoBF", "UnaryExprCommon", 0811 "UnaryExpr", "UnaryExprNoBF", "ExponentiationExpr", 0812 "ExponentiationExprNoBF", "MultiplicativeExpr", "MultiplicativeExprNoBF", 0813 "AdditiveExpr", "AdditiveExprNoBF", "ShiftExpr", "ShiftExprNoBF", 0814 "RelationalExpr", "RelationalExprNoIn", "RelationalExprNoBF", 0815 "EqualityExpr", "EqualityExprNoIn", "EqualityExprNoBF", "BitwiseANDExpr", 0816 "BitwiseANDExprNoIn", "BitwiseANDExprNoBF", "BitwiseXORExpr", 0817 "BitwiseXORExprNoIn", "BitwiseXORExprNoBF", "BitwiseORExpr", 0818 "BitwiseORExprNoIn", "BitwiseORExprNoBF", "LogicalANDExpr", 0819 "LogicalANDExprNoIn", "LogicalANDExprNoBF", "LogicalORExpr", 0820 "LogicalORExprNoIn", "LogicalORExprNoBF", "ConditionalExpr", 0821 "ConditionalExprNoIn", "ConditionalExprNoBF", "AssignmentExpr", 0822 "AssignmentExprNoIn", "AssignmentExprNoBF", "AssignmentOperator", "Expr", 0823 "ExprNoIn", "ExprNoBF", "Statement", "Block", "VariableStatement", 0824 "VariableDeclarationList", "VariableDeclarationListNoIn", 0825 "VariableDeclaration", "VariableDeclarationNoIn", "ConstStatement", 0826 "ConstDeclarationList", "ConstDeclaration", "Initializer", 0827 "InitializerNoIn", "EmptyStatement", "ExprStatement", "IfStatement", 0828 "IterationStatement", "ExprOpt", "ExprNoInOpt", "ContinueStatement", 0829 "BreakStatement", "ReturnStatement", "WithStatement", "SwitchStatement", 0830 "CaseBlock", "CaseClausesOpt", "CaseClauses", "CaseClause", 0831 "DefaultClause", "LabelledStatement", "ThrowStatement", "TryStatement", 0832 "DebuggerStatement", "PackageName", "ImportStatement", 0833 "FunctionDeclaration", "$@3", "$@4", "FunctionExpr", "$@5", "$@6", "$@7", 0834 "$@8", "FormalParameterList", "FunctionBody", "Program", 0835 "SourceElements", "SourceElement", YY_NULL 0836 }; 0837 #endif 0838 0839 # ifdef YYPRINT 0840 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 0841 token YYLEX-NUM. */ 0842 static const yytype_uint16 yytoknum[] = { 0843 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0844 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 0845 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 0846 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 0847 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 0848 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 0849 315, 316, 317, 318, 319, 320, 321, 47, 58, 40, 0850 41, 44, 123, 125, 91, 93, 46, 43, 45, 126, 0851 33, 42, 37, 60, 62, 38, 94, 124, 63, 61, 0852 59 0853 }; 0854 # endif 0855 0856 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 0857 static const yytype_uint8 yyr1[] = { 0858 0, 91, 92, 92, 92, 92, 92, 92, 92, 92, 0859 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0860 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0861 92, 92, 92, 93, 93, 94, 94, 94, 94, 94, 0862 94, 94, 95, 95, 95, 96, 97, 96, 98, 96, 0863 99, 99, 100, 100, 100, 100, 101, 101, 101, 101, 0864 101, 102, 102, 102, 103, 103, 104, 104, 105, 105, 0865 106, 106, 106, 106, 106, 107, 107, 107, 107, 108, 0866 108, 109, 109, 110, 110, 110, 110, 111, 111, 111, 0867 111, 112, 112, 113, 113, 114, 114, 115, 115, 116, 0868 116, 116, 116, 117, 117, 117, 117, 118, 118, 118, 0869 118, 119, 119, 119, 119, 119, 119, 119, 120, 120, 0870 121, 121, 122, 122, 123, 123, 124, 124, 124, 124, 0871 125, 125, 125, 125, 126, 126, 126, 127, 127, 127, 0872 128, 128, 128, 128, 129, 129, 129, 129, 130, 130, 0873 130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 0874 131, 132, 132, 132, 132, 132, 132, 132, 133, 133, 0875 133, 133, 133, 134, 134, 134, 134, 134, 135, 135, 0876 135, 135, 135, 136, 136, 137, 137, 138, 138, 139, 0877 139, 140, 140, 141, 141, 142, 142, 143, 143, 144, 0878 144, 145, 145, 146, 146, 147, 147, 148, 148, 149, 0879 149, 150, 150, 151, 151, 152, 152, 153, 153, 154, 0880 154, 155, 155, 156, 156, 157, 157, 157, 157, 157, 0881 157, 157, 157, 157, 157, 157, 157, 157, 158, 158, 0882 159, 159, 160, 160, 161, 161, 161, 161, 161, 161, 0883 161, 161, 161, 161, 161, 161, 161, 161, 161, 161, 0884 161, 162, 162, 163, 163, 164, 164, 165, 165, 166, 0885 166, 167, 167, 168, 168, 169, 169, 170, 170, 171, 0886 172, 173, 174, 174, 175, 175, 176, 176, 176, 176, 0887 176, 176, 176, 176, 177, 177, 178, 178, 179, 179, 0888 179, 179, 180, 180, 180, 180, 181, 181, 181, 181, 0889 182, 183, 184, 184, 185, 185, 186, 186, 187, 187, 0890 188, 188, 189, 190, 190, 191, 191, 191, 192, 192, 0891 193, 193, 194, 194, 194, 194, 194, 194, 196, 195, 0892 197, 195, 199, 198, 200, 198, 201, 198, 202, 198, 0893 203, 203, 204, 204, 205, 205, 206, 206, 207, 207 0894 }; 0895 0896 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 0897 static const yytype_uint8 yyr2[] = { 0898 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0899 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0900 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0901 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0902 1, 1, 1, 1, 1, 3, 0, 6, 0, 7, 0903 1, 3, 1, 2, 3, 4, 1, 1, 1, 1, 0904 3, 3, 3, 5, 2, 4, 0, 1, 1, 2, 0905 1, 1, 4, 3, 3, 1, 4, 3, 3, 1, 0906 2, 1, 2, 2, 2, 4, 3, 2, 2, 4, 0907 3, 2, 3, 1, 3, 1, 1, 1, 1, 2, 0908 2, 2, 2, 1, 2, 2, 1, 1, 2, 2, 0909 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0910 1, 1, 1, 3, 1, 3, 1, 3, 3, 3, 0911 1, 3, 3, 3, 1, 3, 3, 1, 3, 3, 0912 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 0913 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 0914 3, 1, 3, 3, 3, 3, 3, 3, 1, 3, 0915 3, 3, 3, 1, 3, 3, 3, 3, 1, 3, 0916 3, 3, 3, 1, 3, 1, 3, 1, 3, 1, 0917 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 0918 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 0919 3, 1, 3, 1, 5, 1, 5, 1, 5, 1, 0920 3, 1, 3, 1, 3, 1, 1, 1, 1, 1, 0921 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 0922 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 0923 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0924 1, 2, 3, 3, 3, 1, 3, 1, 3, 1, 0925 2, 1, 2, 3, 3, 1, 3, 1, 2, 2, 0926 2, 1, 2, 2, 5, 7, 7, 7, 5, 9, 0927 10, 7, 8, 9, 0, 1, 0, 1, 2, 2, 0928 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 0929 5, 5, 3, 5, 0, 1, 1, 2, 3, 4, 0930 2, 3, 3, 3, 3, 4, 7, 9, 2, 2, 0931 1, 3, 5, 5, 3, 3, 5, 5, 0, 6, 0932 0, 7, 0, 5, 0, 6, 0, 6, 0, 7, 0933 1, 3, 2, 3, 0, 1, 1, 2, 1, 1 0934 }; 0935 0936 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 0937 Performed when YYTABLE doesn't specify something else to do. Zero 0938 means the default is an error. */ 0939 static const yytype_uint16 yydefact[] = { 0940 354, 35, 36, 37, 0, 0, 0, 0, 0, 0, 0941 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0942 0, 0, 0, 0, 0, 0, 0, 41, 38, 39, 0943 59, 0, 0, 40, 0, 0, 66, 0, 0, 0, 0944 0, 281, 57, 75, 58, 81, 97, 98, 107, 110, 0945 120, 121, 124, 130, 137, 144, 161, 178, 187, 193, 0946 199, 205, 211, 217, 223, 242, 0, 359, 244, 245, 0947 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0948 256, 257, 258, 259, 260, 358, 0, 355, 356, 303, 0949 0, 302, 296, 0, 0, 59, 0, 70, 52, 79, 0950 82, 71, 269, 0, 265, 277, 0, 275, 299, 0, 0951 298, 0, 307, 306, 79, 95, 96, 103, 106, 118, 0952 119, 122, 126, 134, 140, 148, 168, 183, 189, 195, 0953 201, 207, 213, 219, 238, 0, 103, 118, 112, 111, 0954 0, 0, 0, 113, 0, 0, 0, 0, 329, 328, 0955 330, 0, 99, 101, 0, 100, 102, 0, 261, 0, 0956 68, 0, 0, 67, 114, 115, 116, 117, 0, 0, 0957 0, 87, 0, 0, 88, 108, 109, 226, 227, 228, 0958 229, 230, 231, 232, 233, 234, 237, 235, 236, 225, 0959 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0960 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0961 0, 0, 0, 0, 0, 0, 283, 0, 282, 1, 0962 357, 305, 304, 0, 103, 155, 173, 185, 191, 197, 0963 203, 209, 215, 221, 240, 297, 0, 79, 80, 0, 0964 0, 29, 30, 31, 2, 3, 4, 5, 6, 7, 0965 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0966 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 0967 28, 32, 44, 43, 33, 53, 34, 42, 0, 50, 0968 0, 0, 0, 78, 0, 270, 264, 0, 263, 278, 0969 274, 0, 273, 301, 300, 0, 83, 0, 0, 84, 0970 104, 105, 0, 0, 0, 0, 0, 0, 0, 0, 0971 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0972 0, 0, 0, 0, 0, 0, 0, 0, 309, 0, 0973 308, 0, 0, 0, 0, 0, 324, 323, 0, 0, 0974 0, 335, 0, 334, 322, 60, 262, 66, 62, 61, 0975 64, 69, 91, 0, 93, 0, 33, 77, 0, 90, 0976 224, 125, 132, 131, 133, 138, 139, 145, 146, 147, 0977 167, 166, 164, 165, 162, 163, 179, 180, 181, 182, 0978 188, 194, 200, 206, 212, 0, 243, 271, 0, 267, 0979 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0980 0, 0, 0, 0, 0, 0, 0, 0, 294, 74, 0981 0, 350, 342, 0, 0, 0, 0, 54, 0, 73, 0982 279, 266, 276, 338, 0, 0, 86, 220, 123, 128, 0983 127, 129, 135, 136, 141, 142, 143, 154, 153, 151, 0984 152, 149, 150, 169, 170, 171, 172, 184, 190, 196, 0985 202, 208, 0, 239, 0, 0, 0, 0, 0, 0, 0986 325, 330, 0, 331, 0, 0, 92, 0, 76, 89, 0987 0, 0, 0, 272, 0, 294, 0, 103, 222, 160, 0988 158, 159, 156, 157, 174, 175, 176, 177, 186, 192, 0989 198, 204, 210, 0, 241, 295, 0, 346, 0, 0, 0990 344, 0, 0, 45, 55, 51, 72, 0, 340, 85, 0991 0, 284, 0, 288, 314, 311, 310, 0, 337, 0, 0992 336, 333, 332, 63, 65, 94, 218, 0, 280, 0, 0993 271, 268, 0, 0, 0, 294, 0, 348, 0, 343, 0994 0, 351, 46, 0, 339, 0, 214, 0, 0, 0, 0995 0, 315, 316, 0, 0, 0, 272, 294, 291, 216, 0996 0, 347, 0, 352, 0, 345, 0, 48, 341, 285, 0997 287, 286, 0, 0, 312, 314, 317, 326, 292, 0, 0998 0, 0, 349, 353, 47, 0, 318, 320, 0, 0, 0999 293, 0, 289, 49, 319, 321, 313, 327, 290 1000 }; 1001 1002 /* YYDEFGOTO[NTERM-NUM]. */ 1003 static const yytype_int16 yydefgoto[] = { 1004 -1, 276, 277, 42, 278, 279, 566, 585, 280, 97, 1005 98, 44, 161, 162, 163, 114, 45, 115, 46, 116, 1006 47, 171, 353, 136, 48, 118, 119, 50, 120, 121, 1007 52, 122, 53, 123, 54, 124, 55, 125, 56, 126, 1008 226, 57, 127, 227, 58, 128, 228, 59, 129, 229, 1009 60, 130, 230, 61, 131, 231, 62, 132, 232, 63, 1010 133, 233, 64, 134, 234, 65, 391, 495, 235, 66, 1011 67, 68, 69, 103, 388, 104, 389, 70, 106, 107, 1012 285, 473, 71, 72, 73, 74, 496, 236, 75, 76, 1013 77, 78, 79, 515, 550, 551, 552, 575, 80, 81, 1014 82, 83, 151, 84, 85, 507, 545, 101, 499, 540, 1015 536, 562, 413, 539, 86, 87, 88 1016 }; 1017 1018 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1019 STATE-NUM. */ 1020 #define YYPACT_NINF -377 1021 static const yytype_int16 yypact[] = { 1022 994, -377, -377, -377, 7, -22, 197, 3, 5, 20, 1023 13, 354, 1466, 1466, 16, -377, 1076, 70, 1466, 86, 1024 112, 1466, 9, 58, 63, 1466, 1466, -377, -377, -377, 1025 118, 1466, 1466, -377, 1466, 636, 123, 1466, 1466, 1466, 1026 1466, -377, -377, -377, -377, -4, -377, 32, 1135, -377, 1027 159, -377, -377, -377, 117, 156, 230, 234, 215, 129, 1028 157, 178, 195, -9, -377, -377, 21, -377, -377, -377, 1029 -377, -377, -377, -377, -377, -377, -377, -377, -377, -377, 1030 -377, -377, -377, -377, -377, -377, 267, 994, -377, -377, 1031 59, -377, 1154, 197, 36, -377, 1544, -377, -377, 113, 1032 -377, -377, 179, 24, -377, 179, 33, -377, -377, 60, 1033 -377, 201, -377, -377, 113, -377, 116, 1213, -377, 223, 1034 -377, -377, -377, 139, 163, 242, 365, 248, 209, 214, 1035 229, 279, -5, -377, -377, 85, 186, -377, -377, -377, 1036 1466, 321, 1466, -377, 1466, 1466, 101, 232, -377, -377, 1037 271, 27, -377, -377, 1076, -377, -377, 211, -377, 748, 1038 -377, 122, 1232, 285, -377, -377, -377, -377, 1310, 1466, 1039 1686, -377, 1466, 1686, -377, -377, -377, -377, -377, -377, 1040 -377, -377, -377, -377, -377, -377, -377, -377, -377, -377, 1041 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1042 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1043 1466, 1466, 1466, 1466, 1466, 1466, -377, 1466, -377, -377, 1044 -377, -377, -377, 298, 251, 242, 196, 311, 282, 283, 1045 294, 329, 6, -377, -377, 320, 292, 113, -377, 339, 1046 12, -377, -377, -377, -377, -377, -377, -377, -377, -377, 1047 -377, -377, -377, -377, -377, -377, -377, -377, -377, -377, 1048 -377, -377, -377, -377, -377, -377, -377, -377, -377, -377, 1049 -377, -377, -377, -377, 1686, -377, -377, -377, 341, -377, 1050 144, 1466, 1686, -377, 1466, -377, -377, 3, -377, -377, 1051 -377, 5, -377, -377, -377, 45, -377, 1466, 1686, -377, 1052 -377, -377, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1053 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1054 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, -377, 1466, 1055 -377, 222, 343, 227, 244, 249, -377, -377, 344, 9, 1056 346, -377, -1, -377, -377, -377, -377, 123, -377, -377, 1057 -377, -377, -377, 274, -377, 151, -377, -377, 152, -377, 1058 -377, -377, -377, -377, -377, 139, 139, 163, 163, 163, 1059 242, 242, 242, 242, 242, 242, 365, 365, 365, 365, 1060 248, 209, 214, 229, 279, 347, -377, 10, -28, -377, 1061 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1062 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, 1466, -377, 1063 48, -377, -377, 304, 345, 1466, 1615, -377, 153, -377, 1064 -377, -377, -377, -377, 306, 154, -377, -377, -377, -377, 1065 -377, -377, 139, 139, 163, 163, 163, 242, 242, 242, 1066 242, 242, 242, 365, 365, 365, 365, 248, 209, 214, 1067 229, 279, 356, -377, 1076, 1466, 1076, 350, 1076, 361, 1068 -377, -377, 67, -377, 87, 1388, -377, 1466, -377, -377, 1069 1466, 1466, 1466, 405, 366, 1466, 309, 1213, -377, 242, 1070 242, 242, 242, 242, 196, 196, 196, 196, 311, 282, 1071 283, 294, 329, 367, -377, 358, 349, -377, 314, 368, 1072 -377, 373, 140, -377, -377, -377, -377, 368, -377, -377, 1073 1466, 407, 324, -377, 439, -377, -377, 377, -377, 386, 1074 -377, -377, -377, -377, -377, -377, -377, 326, -377, 1466, 1075 362, -377, 363, 1076, 1466, 1466, 368, -377, 830, -377, 1076 368, -377, -377, 330, -377, 368, -377, 1076, 89, 1466, 1077 34, 439, -377, 9, 1076, 332, -377, 1466, -377, -377, 1078 382, -377, 368, -377, 912, -377, 368, -377, -377, -377, 1079 -377, -377, 57, 387, -377, 439, -377, 428, -377, 1076, 1080 390, 1076, -377, -377, -377, 368, 994, 994, 388, 9, 1081 -377, 1076, -377, -377, 994, 994, -377, -377, -377 1082 }; 1083 1084 /* YYPGOTO[NTERM-NUM]. */ 1085 static const yytype_int16 yypgoto[] = { 1086 -377, -377, -153, -377, -377, 46, -377, -377, -377, -377, 1087 0, -377, -377, 121, -377, 47, -377, 83, -377, -377, 1088 -377, -41, -377, 221, -377, 11, 707, -377, 29, 1305, 1089 -377, -142, -377, -177, -377, -158, -377, -68, -377, -152, 1090 -46, -377, -203, 62, -377, -201, 68, -377, -200, 61, 1091 -377, -199, 71, -377, -188, 66, -377, -377, -377, -377, 1092 -377, -377, -377, -124, -376, -377, -39, 2, -377, -377, 1093 -13, -18, -377, -377, -377, 185, 4, -377, -377, 183, 1094 371, -53, -377, -377, -377, -377, -362, -377, -377, -377, 1095 -377, -377, -377, -377, -95, -377, -70, -377, -377, -377, 1096 -377, -377, 142, -377, -377, -377, -377, -377, -377, -377, 1097 -377, -377, -290, -327, -377, -34, -85 1098 }; 1099 1100 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1101 positive, shift that token. If negative, reduce the rule which 1102 number is the opposite. If YYTABLE_NINF, syntax error. */ 1103 #define YYTABLE_NINF -1 1104 static const yytype_uint16 yytable[] = { 1105 43, 159, 220, 141, 147, 424, 174, 380, 89, 190, 1106 381, 49, 382, 135, 383, 478, 43, 357, 365, 366, 1107 359, 108, 216, 146, 225, 286, 384, 49, 341, 51, 1108 493, 494, 471, 214, 290, 43, 157, 326, 350, 367, 1109 368, 369, 573, 474, 354, 51, 49, 92, 405, 361, 1110 362, 363, 364, 99, 376, 377, 378, 379, 283, 148, 1111 221, 293, 475, 463, 51, 168, 360, 102, 518, 105, 1112 169, 90, 170, 296, 220, 299, 411, 111, 302, 215, 1113 464, 35, 412, 327, 109, 140, 328, 43, 521, 100, 1114 570, 385, 217, 386, 406, 287, 528, 91, 49, 472, 1115 239, 168, 336, 342, 291, 240, 172, 574, 173, 411, 1116 110, 218, 411, 532, 288, 423, 51, 343, 497, 447, 1117 498, 414, 448, 292, 449, 586, 450, 150, 329, 419, 1118 432, 433, 370, 371, 372, 373, 374, 375, 451, 142, 1119 237, 344, 331, 519, 333, 426, 334, 335, 149, 222, 1120 294, 434, 435, 436, 43, 144, 329, 520, 559, 43, 1121 420, 428, 429, 430, 431, 49, 443, 444, 445, 446, 1122 49, 355, 329, 560, 358, 330, 238, 522, 427, 571, 1123 544, 145, 168, 51, 192, 168, 154, 281, 51, 282, 1124 297, 337, 298, 347, 160, 580, 409, 348, 193, 194, 1125 1, 2, 3, 452, 411, 453, 304, 93, 191, 561, 1126 542, 94, 543, 565, 210, 416, 15, 417, 568, 392, 1127 305, 306, 329, 329, 329, 329, 468, 469, 506, 509, 1128 300, 301, 117, 195, 196, 582, 393, 394, 213, 584, 1129 307, 308, 117, 211, 437, 438, 439, 440, 441, 442, 1130 27, 206, 207, 208, 209, 117, 200, 201, 593, 28, 1131 29, 95, 338, 339, 33, 212, 34, 219, 284, 96, 1132 295, 36, 303, 390, 202, 203, 197, 198, 199, 395, 1133 396, 345, 329, 418, 318, 319, 320, 321, 309, 310, 1134 311, 503, 454, 329, 322, 300, 301, 456, 329, 425, 1135 323, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1136 186, 187, 188, 224, 457, 329, 324, 204, 205, 458, 1137 329, 460, 325, 225, 479, 480, 481, 482, 483, 225, 1138 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 1139 189, 524, 332, 525, 466, 467, 526, 397, 398, 399, 1140 400, 484, 485, 486, 487, 112, 351, 1, 2, 3, 1141 340, 117, 387, 117, 93, 117, 117, 401, 94, 402, 1142 12, 13, 404, 15, 500, 501, 508, 501, 18, 533, 1143 329, 403, 408, 117, 537, 501, 546, 312, 313, 117, 1144 117, 407, 476, 117, 548, 329, 554, 329, 25, 26, 1145 567, 501, 579, 329, 225, 314, 315, 27, 410, 415, 1146 461, 117, 455, 459, 502, 470, 28, 29, 95, 31, 1147 32, 33, 514, 34, 510, 517, 96, 529, 36, 329, 1148 530, 37, 38, 39, 40, 534, 117, 541, 117, 535, 1149 538, 511, 547, 513, 113, 516, 549, 553, 316, 317, 1150 463, 472, 581, 557, 43, 587, 43, 512, 43, 589, 1151 591, 596, 505, 488, 490, 49, 225, 49, 465, 49, 1152 489, 492, 421, 527, 422, 491, 289, 556, 531, 220, 1153 588, 576, 462, 51, 0, 51, 0, 51, 0, 0, 1154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1155 0, 0, 117, 0, 564, 117, 0, 0, 0, 220, 1156 220, 0, 0, 0, 0, 0, 0, 0, 117, 0, 1157 558, 0, 0, 117, 0, 0, 0, 0, 0, 0, 1158 0, 555, 0, 43, 569, 577, 0, 0, 43, 0, 1159 0, 578, 0, 0, 49, 0, 0, 43, 117, 49, 1160 117, 572, 594, 595, 43, 0, 0, 0, 49, 0, 1161 0, 0, 51, 0, 43, 49, 590, 51, 592, 0, 1162 0, 597, 0, 0, 0, 49, 51, 0, 598, 43, 1163 0, 43, 0, 51, 0, 0, 43, 43, 0, 0, 1164 49, 43, 49, 51, 43, 43, 0, 49, 49, 0, 1165 0, 0, 49, 0, 0, 49, 49, 0, 51, 0, 1166 51, 117, 477, 0, 0, 51, 51, 0, 0, 0, 1167 51, 0, 0, 51, 51, 0, 0, 477, 477, 117, 1168 0, 0, 0, 0, 0, 0, 117, 0, 0, 1, 1169 2, 3, 4, 0, 0, 5, 6, 7, 8, 9, 1170 10, 11, 12, 13, 14, 15, 16, 17, 0, 0, 1171 18, 19, 20, 0, 21, 22, 0, 0, 23, 24, 1172 0, 0, 0, 0, 0, 0, 117, 0, 0, 0, 1173 25, 26, 0, 0, 0, 0, 117, 0, 117, 27, 1174 0, 117, 117, 477, 0, 0, 117, 0, 28, 29, 1175 30, 31, 32, 33, 0, 34, 0, 0, 35, 158, 1176 36, 0, 0, 37, 38, 39, 40, 0, 0, 137, 1177 137, 0, 0, 0, 0, 137, 41, 0, 0, 0, 1178 0, 117, 137, 137, 0, 0, 0, 0, 137, 137, 1179 0, 0, 0, 0, 137, 137, 137, 137, 0, 0, 1180 117, 1, 2, 3, 4, 477, 117, 5, 6, 7, 1181 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1182 117, 0, 18, 19, 20, 0, 21, 22, 117, 0, 1183 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 1184 0, 0, 25, 26, 0, 0, 0, 0, 0, 0, 1185 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 1186 28, 29, 30, 31, 32, 33, 0, 34, 0, 0, 1187 35, 346, 36, 0, 0, 37, 38, 39, 40, 0, 1188 0, 0, 0, 1, 2, 3, 4, 0, 41, 5, 1189 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1190 16, 17, 0, 0, 18, 19, 20, 0, 21, 22, 1191 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 1192 0, 0, 0, 0, 25, 26, 0, 0, 0, 0, 1193 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 1194 0, 0, 28, 29, 30, 31, 32, 33, 0, 34, 1195 0, 0, 35, 563, 36, 0, 0, 37, 38, 39, 1196 40, 0, 0, 0, 0, 1, 2, 3, 4, 0, 1197 41, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1198 14, 15, 16, 17, 0, 0, 18, 19, 20, 0, 1199 21, 22, 0, 0, 23, 24, 0, 0, 0, 0, 1200 0, 0, 0, 0, 0, 0, 25, 26, 0, 0, 1201 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 1202 0, 0, 0, 0, 28, 29, 30, 31, 32, 33, 1203 0, 34, 0, 0, 35, 583, 36, 0, 0, 37, 1204 38, 39, 40, 0, 0, 0, 0, 1, 2, 3, 1205 4, 0, 41, 5, 6, 7, 8, 9, 10, 11, 1206 12, 13, 14, 15, 16, 17, 0, 0, 18, 19, 1207 20, 0, 21, 22, 0, 0, 23, 24, 0, 0, 1208 0, 0, 0, 0, 0, 0, 0, 0, 25, 26, 1209 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 1210 0, 0, 0, 0, 0, 0, 28, 29, 30, 31, 1211 32, 33, 0, 34, 0, 0, 35, 0, 36, 0, 1212 0, 37, 38, 39, 40, 0, 0, 0, 0, 1, 1213 2, 3, 4, 0, 41, 5, 6, 7, 8, 9, 1214 0, 11, 12, 13, 14, 15, 16, 17, 0, 0, 1215 18, 19, 20, 0, 21, 22, 0, 0, 23, 24, 1216 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1217 25, 26, 0, 0, 0, 0, 0, 0, 0, 27, 1218 0, 0, 0, 0, 0, 0, 0, 0, 28, 29, 1219 30, 31, 32, 33, 0, 34, 0, 0, 35, 0, 1220 36, 0, 0, 37, 38, 39, 40, 1, 2, 3, 1221 0, 0, 0, 0, 93, 223, 41, 0, 94, 0, 1222 12, 13, 0, 15, 0, 0, 0, 0, 18, 175, 1223 176, 0, 0, 0, 0, 177, 178, 179, 180, 181, 1224 182, 183, 184, 185, 186, 187, 188, 0, 25, 26, 1225 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 1226 0, 0, 0, 0, 0, 0, 28, 29, 95, 31, 1227 32, 33, 0, 34, 189, 0, 96, 0, 36, 0, 1228 0, 37, 38, 39, 40, 1, 2, 3, 0, 0, 1229 0, 0, 93, 0, 0, 0, 94, 0, 12, 13, 1230 0, 15, 0, 0, 0, 0, 18, 300, 301, 0, 1231 0, 0, 0, 177, 178, 179, 180, 181, 182, 183, 1232 184, 185, 186, 187, 188, 0, 25, 26, 0, 0, 1233 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 1234 0, 0, 0, 0, 28, 29, 95, 31, 32, 33, 1235 0, 34, 189, 0, 96, 0, 36, 349, 0, 37, 1236 38, 39, 40, 1, 2, 3, 0, 138, 139, 0, 1237 93, 0, 0, 143, 94, 0, 12, 13, 0, 15, 1238 152, 153, 0, 0, 18, 0, 155, 156, 0, 0, 1239 0, 0, 164, 165, 166, 167, 0, 0, 0, 0, 1240 0, 0, 0, 0, 25, 26, 0, 0, 0, 0, 1241 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 1242 0, 0, 28, 29, 95, 31, 32, 33, 0, 34, 1243 352, 0, 96, 0, 36, 0, 0, 37, 38, 39, 1244 40, 1, 2, 3, 0, 0, 0, 0, 93, 0, 1245 0, 0, 94, 0, 12, 13, 0, 15, 0, 0, 1246 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 1247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1248 0, 0, 25, 26, 0, 0, 0, 0, 0, 0, 1249 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 1250 28, 29, 95, 31, 32, 33, 0, 34, 0, 0, 1251 96, 0, 36, 523, 0, 37, 38, 39, 40, 1, 1252 2, 3, 0, 0, 0, 0, 93, 0, 0, 0, 1253 94, 0, 12, 13, 0, 15, 0, 0, 0, 0, 1254 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1256 25, 26, 0, 0, 0, 0, 0, 0, 0, 27, 1257 0, 0, 0, 0, 0, 0, 0, 0, 28, 29, 1258 95, 31, 32, 33, 0, 34, 0, 0, 96, 0, 1259 36, 0, 0, 37, 38, 39, 40, 241, 242, 243, 1260 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 1261 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 1262 264, 0, 265, 266, 267, 268, 269, 270, 0, 271, 1263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1265 0, 0, 0, 0, 0, 0, 272, 273, 274, 0, 1266 0, 0, 0, 0, 0, 0, 0, 275, 241, 242, 1267 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 1268 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 1269 263, 264, 0, 265, 266, 267, 268, 269, 270, 0, 1270 271, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1271 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1272 0, 0, 0, 0, 0, 0, 0, 272, 273, 274, 1273 0, 0, 0, 0, 0, 0, 0, 0, 504, 241, 1274 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 1275 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 1276 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 1277 0, 271, 0, 0, 0, 0, 0, 0, 0, 0, 1278 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1280 356 1281 }; 1282 1283 #define yypact_value_is_default(Yystate) \ 1284 (!!((Yystate) == (-377))) 1285 1286 #define yytable_value_is_error(Yytable_value) \ 1287 YYID (0) 1288 1289 static const yytype_int16 yycheck[] = { 1290 0, 35, 87, 16, 22, 295, 47, 210, 1, 48, 1291 211, 0, 212, 11, 213, 391, 16, 170, 195, 196, 1292 173, 1, 1, 21, 92, 1, 214, 16, 1, 0, 1293 406, 407, 22, 42, 1, 35, 34, 42, 162, 197, 1294 198, 199, 8, 71, 168, 16, 35, 69, 42, 191, 1295 192, 193, 194, 6, 206, 207, 208, 209, 99, 1, 1296 1, 1, 90, 64, 35, 69, 190, 64, 1, 64, 1297 74, 64, 76, 114, 159, 116, 64, 64, 117, 88, 1298 81, 72, 70, 88, 64, 69, 1, 87, 1, 6, 1299 1, 215, 71, 217, 88, 71, 472, 90, 87, 89, 1300 64, 69, 1, 76, 71, 69, 74, 73, 76, 64, 1301 90, 90, 64, 475, 90, 70, 87, 90, 70, 322, 1302 410, 274, 323, 90, 324, 68, 325, 64, 71, 282, 1303 307, 308, 200, 201, 202, 203, 204, 205, 326, 69, 1304 93, 154, 140, 76, 142, 298, 144, 145, 90, 90, 1305 90, 309, 310, 311, 154, 69, 71, 90, 534, 159, 1306 284, 303, 304, 305, 306, 154, 318, 319, 320, 321, 1307 159, 169, 71, 535, 172, 90, 93, 90, 302, 90, 1308 507, 69, 69, 154, 67, 69, 68, 74, 159, 76, 1309 74, 90, 76, 71, 71, 557, 237, 75, 81, 82, 1310 3, 4, 5, 327, 64, 329, 67, 10, 49, 536, 1311 70, 14, 502, 540, 85, 71, 19, 73, 545, 23, 1312 81, 82, 71, 71, 71, 71, 75, 75, 75, 75, 1313 44, 45, 11, 77, 78, 562, 40, 41, 43, 566, 1314 77, 78, 21, 86, 312, 313, 314, 315, 316, 317, 1315 53, 36, 37, 38, 39, 34, 22, 23, 585, 62, 1316 63, 64, 30, 31, 67, 87, 69, 0, 89, 72, 1317 69, 74, 49, 22, 40, 41, 46, 47, 48, 83, 1318 84, 70, 71, 281, 36, 37, 38, 39, 46, 47, 1319 48, 415, 70, 71, 85, 44, 45, 70, 71, 297, 1320 86, 50, 51, 52, 53, 54, 55, 56, 57, 58, 1321 59, 60, 61, 92, 70, 71, 87, 83, 84, 70, 1322 71, 339, 43, 391, 392, 393, 394, 395, 396, 397, 1323 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 1324 89, 465, 21, 467, 70, 71, 470, 36, 37, 38, 1325 39, 397, 398, 399, 400, 1, 71, 3, 4, 5, 1326 89, 140, 64, 142, 10, 144, 145, 85, 14, 86, 1327 16, 17, 43, 19, 70, 71, 70, 71, 24, 70, 1328 71, 87, 90, 162, 70, 71, 510, 22, 23, 168, 1329 169, 71, 390, 172, 70, 71, 70, 71, 44, 45, 1330 70, 71, 70, 71, 472, 40, 41, 53, 69, 68, 1331 64, 190, 69, 69, 69, 68, 62, 63, 64, 65, 1332 66, 67, 72, 69, 68, 64, 72, 22, 74, 71, 1333 64, 77, 78, 79, 80, 68, 215, 64, 217, 90, 1334 72, 454, 35, 456, 90, 458, 7, 70, 83, 84, 1335 64, 89, 70, 90, 454, 68, 456, 455, 458, 31, 1336 70, 73, 416, 401, 403, 454, 534, 456, 347, 458, 1337 402, 405, 287, 471, 291, 404, 105, 530, 474, 564, 1338 575, 551, 340, 454, -1, 456, -1, 458, -1, -1, 1339 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1340 -1, -1, 281, -1, 538, 284, -1, -1, -1, 594, 1341 595, -1, -1, -1, -1, -1, -1, -1, 297, -1, 1342 533, -1, -1, 302, -1, -1, -1, -1, -1, -1, 1343 -1, 529, -1, 533, 547, 553, -1, -1, 538, -1, 1344 -1, 554, -1, -1, 533, -1, -1, 547, 327, 538, 1345 329, 549, 586, 587, 554, -1, -1, -1, 547, -1, 1346 -1, -1, 533, -1, 564, 554, 579, 538, 581, -1, 1347 -1, 589, -1, -1, -1, 564, 547, -1, 591, 579, 1348 -1, 581, -1, 554, -1, -1, 586, 587, -1, -1, 1349 579, 591, 581, 564, 594, 595, -1, 586, 587, -1, 1350 -1, -1, 591, -1, -1, 594, 595, -1, 579, -1, 1351 581, 390, 391, -1, -1, 586, 587, -1, -1, -1, 1352 591, -1, -1, 594, 595, -1, -1, 406, 407, 408, 1353 -1, -1, -1, -1, -1, -1, 415, -1, -1, 3, 1354 4, 5, 6, -1, -1, 9, 10, 11, 12, 13, 1355 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, 1356 24, 25, 26, -1, 28, 29, -1, -1, 32, 33, 1357 -1, -1, -1, -1, -1, -1, 455, -1, -1, -1, 1358 44, 45, -1, -1, -1, -1, 465, -1, 467, 53, 1359 -1, 470, 471, 472, -1, -1, 475, -1, 62, 63, 1360 64, 65, 66, 67, -1, 69, -1, -1, 72, 73, 1361 74, -1, -1, 77, 78, 79, 80, -1, -1, 12, 1362 13, -1, -1, -1, -1, 18, 90, -1, -1, -1, 1363 -1, 510, 25, 26, -1, -1, -1, -1, 31, 32, 1364 -1, -1, -1, -1, 37, 38, 39, 40, -1, -1, 1365 529, 3, 4, 5, 6, 534, 535, 9, 10, 11, 1366 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 1367 549, -1, 24, 25, 26, -1, 28, 29, 557, -1, 1368 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, 1369 -1, -1, 44, 45, -1, -1, -1, -1, -1, -1, 1370 -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 1371 62, 63, 64, 65, 66, 67, -1, 69, -1, -1, 1372 72, 73, 74, -1, -1, 77, 78, 79, 80, -1, 1373 -1, -1, -1, 3, 4, 5, 6, -1, 90, 9, 1374 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1375 20, 21, -1, -1, 24, 25, 26, -1, 28, 29, 1376 -1, -1, 32, 33, -1, -1, -1, -1, -1, -1, 1377 -1, -1, -1, -1, 44, 45, -1, -1, -1, -1, 1378 -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, 1379 -1, -1, 62, 63, 64, 65, 66, 67, -1, 69, 1380 -1, -1, 72, 73, 74, -1, -1, 77, 78, 79, 1381 80, -1, -1, -1, -1, 3, 4, 5, 6, -1, 1382 90, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1383 18, 19, 20, 21, -1, -1, 24, 25, 26, -1, 1384 28, 29, -1, -1, 32, 33, -1, -1, -1, -1, 1385 -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 1386 -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, 1387 -1, -1, -1, -1, 62, 63, 64, 65, 66, 67, 1388 -1, 69, -1, -1, 72, 73, 74, -1, -1, 77, 1389 78, 79, 80, -1, -1, -1, -1, 3, 4, 5, 1390 6, -1, 90, 9, 10, 11, 12, 13, 14, 15, 1391 16, 17, 18, 19, 20, 21, -1, -1, 24, 25, 1392 26, -1, 28, 29, -1, -1, 32, 33, -1, -1, 1393 -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, 1394 -1, -1, -1, -1, -1, -1, -1, 53, -1, -1, 1395 -1, -1, -1, -1, -1, -1, 62, 63, 64, 65, 1396 66, 67, -1, 69, -1, -1, 72, -1, 74, -1, 1397 -1, 77, 78, 79, 80, -1, -1, -1, -1, 3, 1398 4, 5, 6, -1, 90, 9, 10, 11, 12, 13, 1399 -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, 1400 24, 25, 26, -1, 28, 29, -1, -1, 32, 33, 1401 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1402 44, 45, -1, -1, -1, -1, -1, -1, -1, 53, 1403 -1, -1, -1, -1, -1, -1, -1, -1, 62, 63, 1404 64, 65, 66, 67, -1, 69, -1, -1, 72, -1, 1405 74, -1, -1, 77, 78, 79, 80, 3, 4, 5, 1406 -1, -1, -1, -1, 10, 11, 90, -1, 14, -1, 1407 16, 17, -1, 19, -1, -1, -1, -1, 24, 44, 1408 45, -1, -1, -1, -1, 50, 51, 52, 53, 54, 1409 55, 56, 57, 58, 59, 60, 61, -1, 44, 45, 1410 -1, -1, -1, -1, -1, -1, -1, 53, -1, -1, 1411 -1, -1, -1, -1, -1, -1, 62, 63, 64, 65, 1412 66, 67, -1, 69, 89, -1, 72, -1, 74, -1, 1413 -1, 77, 78, 79, 80, 3, 4, 5, -1, -1, 1414 -1, -1, 10, -1, -1, -1, 14, -1, 16, 17, 1415 -1, 19, -1, -1, -1, -1, 24, 44, 45, -1, 1416 -1, -1, -1, 50, 51, 52, 53, 54, 55, 56, 1417 57, 58, 59, 60, 61, -1, 44, 45, -1, -1, 1418 -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, 1419 -1, -1, -1, -1, 62, 63, 64, 65, 66, 67, 1420 -1, 69, 89, -1, 72, -1, 74, 75, -1, 77, 1421 78, 79, 80, 3, 4, 5, -1, 12, 13, -1, 1422 10, -1, -1, 18, 14, -1, 16, 17, -1, 19, 1423 25, 26, -1, -1, 24, -1, 31, 32, -1, -1, 1424 -1, -1, 37, 38, 39, 40, -1, -1, -1, -1, 1425 -1, -1, -1, -1, 44, 45, -1, -1, -1, -1, 1426 -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, 1427 -1, -1, 62, 63, 64, 65, 66, 67, -1, 69, 1428 70, -1, 72, -1, 74, -1, -1, 77, 78, 79, 1429 80, 3, 4, 5, -1, -1, -1, -1, 10, -1, 1430 -1, -1, 14, -1, 16, 17, -1, 19, -1, -1, 1431 -1, -1, 24, -1, -1, -1, -1, -1, -1, -1, 1432 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1433 -1, -1, 44, 45, -1, -1, -1, -1, -1, -1, 1434 -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 1435 62, 63, 64, 65, 66, 67, -1, 69, -1, -1, 1436 72, -1, 74, 75, -1, 77, 78, 79, 80, 3, 1437 4, 5, -1, -1, -1, -1, 10, -1, -1, -1, 1438 14, -1, 16, 17, -1, 19, -1, -1, -1, -1, 1439 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1440 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1441 44, 45, -1, -1, -1, -1, -1, -1, -1, 53, 1442 -1, -1, -1, -1, -1, -1, -1, -1, 62, 63, 1443 64, 65, 66, 67, -1, 69, -1, -1, 72, -1, 1444 74, -1, -1, 77, 78, 79, 80, 3, 4, 5, 1445 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1446 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1447 26, -1, 28, 29, 30, 31, 32, 33, -1, 35, 1448 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1449 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1450 -1, -1, -1, -1, -1, -1, 62, 63, 64, -1, 1451 -1, -1, -1, -1, -1, -1, -1, 73, 3, 4, 1452 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1453 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1454 25, 26, -1, 28, 29, 30, 31, 32, 33, -1, 1455 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1456 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1457 -1, -1, -1, -1, -1, -1, -1, 62, 63, 64, 1458 -1, -1, -1, -1, -1, -1, -1, -1, 73, 3, 1459 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1460 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1461 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, 1462 -1, 35, -1, -1, -1, -1, -1, -1, -1, -1, 1463 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1464 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1465 64 1466 }; 1467 1468 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1469 symbol of state STATE-NUM. */ 1470 static const yytype_uint8 yystos[] = { 1471 0, 3, 4, 5, 6, 9, 10, 11, 12, 13, 1472 14, 15, 16, 17, 18, 19, 20, 21, 24, 25, 1473 26, 28, 29, 32, 33, 44, 45, 53, 62, 63, 1474 64, 65, 66, 67, 69, 72, 74, 77, 78, 79, 1475 80, 90, 94, 101, 102, 107, 109, 111, 115, 116, 1476 118, 119, 121, 123, 125, 127, 129, 132, 135, 138, 1477 141, 144, 147, 150, 153, 156, 160, 161, 162, 163, 1478 168, 173, 174, 175, 176, 179, 180, 181, 182, 183, 1479 189, 190, 191, 192, 194, 195, 205, 206, 207, 1, 1480 64, 90, 69, 10, 14, 64, 72, 100, 101, 106, 1481 108, 198, 64, 164, 166, 64, 169, 170, 1, 64, 1482 90, 64, 1, 90, 106, 108, 110, 114, 116, 117, 1483 119, 120, 122, 124, 126, 128, 130, 133, 136, 139, 1484 142, 145, 148, 151, 154, 158, 114, 117, 120, 120, 1485 69, 161, 69, 120, 69, 69, 158, 162, 1, 90, 1486 64, 193, 120, 120, 68, 120, 120, 158, 73, 206, 1487 71, 103, 104, 105, 120, 120, 120, 120, 69, 74, 1488 76, 112, 74, 76, 112, 44, 45, 50, 51, 52, 1489 53, 54, 55, 56, 57, 58, 59, 60, 61, 89, 1490 157, 49, 67, 81, 82, 77, 78, 46, 47, 48, 1491 22, 23, 40, 41, 83, 84, 36, 37, 38, 39, 1492 85, 86, 87, 43, 42, 88, 1, 71, 90, 0, 1493 207, 1, 90, 11, 114, 128, 131, 134, 137, 140, 1494 143, 146, 149, 152, 155, 159, 178, 106, 108, 64, 1495 69, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1496 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 1497 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 1498 33, 35, 62, 63, 64, 73, 92, 93, 95, 96, 1499 99, 74, 76, 112, 89, 171, 1, 71, 90, 171, 1500 1, 71, 90, 1, 90, 69, 112, 74, 76, 112, 1501 44, 45, 157, 49, 67, 81, 82, 77, 78, 46, 1502 47, 48, 22, 23, 40, 41, 83, 84, 36, 37, 1503 38, 39, 85, 86, 87, 43, 42, 88, 1, 71, 1504 90, 158, 21, 158, 158, 158, 1, 90, 30, 31, 1505 89, 1, 76, 90, 161, 70, 73, 71, 75, 75, 1506 154, 71, 70, 113, 154, 158, 64, 93, 158, 93, 1507 154, 122, 122, 122, 122, 124, 124, 126, 126, 126, 1508 128, 128, 128, 128, 128, 128, 130, 130, 130, 130, 1509 133, 136, 139, 142, 145, 154, 154, 64, 165, 167, 1510 22, 157, 23, 40, 41, 83, 84, 36, 37, 38, 1511 39, 85, 86, 87, 43, 42, 88, 71, 90, 112, 1512 69, 64, 70, 203, 93, 68, 71, 73, 158, 93, 1513 154, 166, 170, 70, 203, 158, 93, 154, 122, 122, 1514 122, 122, 124, 124, 126, 126, 126, 128, 128, 128, 1515 128, 128, 128, 130, 130, 130, 130, 133, 136, 139, 1516 142, 145, 154, 154, 70, 69, 70, 70, 70, 69, 1517 162, 64, 193, 64, 81, 104, 70, 71, 75, 75, 1518 68, 22, 89, 172, 71, 90, 158, 114, 155, 128, 1519 128, 128, 128, 128, 131, 131, 131, 131, 134, 137, 1520 140, 143, 146, 155, 155, 158, 177, 70, 203, 199, 1521 70, 71, 69, 154, 73, 96, 75, 196, 70, 75, 1522 68, 161, 158, 161, 72, 184, 161, 64, 1, 76, 1523 90, 1, 90, 75, 154, 154, 154, 158, 155, 22, 1524 64, 167, 177, 70, 68, 90, 201, 70, 72, 204, 1525 200, 64, 70, 203, 204, 197, 154, 35, 70, 7, 1526 185, 186, 187, 70, 70, 158, 172, 90, 161, 155, 1527 177, 204, 202, 73, 206, 204, 97, 70, 204, 161, 1528 1, 90, 158, 8, 73, 188, 187, 162, 161, 70, 1529 177, 70, 204, 73, 204, 98, 68, 68, 185, 31, 1530 161, 70, 161, 204, 206, 206, 73, 162, 161 1531 }; 1532 1533 #define yyerrok (yyerrstatus = 0) 1534 #define yyclearin (yychar = YYEMPTY) 1535 #define YYEMPTY (-2) 1536 #define YYEOF 0 1537 1538 #define YYACCEPT goto yyacceptlab 1539 #define YYABORT goto yyabortlab 1540 #define YYERROR goto yyerrorlab 1541 1542 /* Like YYERROR except do call yyerror. This remains here temporarily 1543 to ease the transition to the new meaning of YYERROR, for GCC. 1544 Once GCC version 2 has supplanted version 1, this can go. However, 1545 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1546 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1547 discussed. */ 1548 1549 #define YYFAIL goto yyerrlab 1550 #if defined YYFAIL 1551 /* This is here to suppress warnings from the GCC cpp's 1552 -Wunused-macros. Normally we don't worry about that warning, but 1553 some users do, and we want to make it easy for users to remove 1554 YYFAIL uses, which will produce warnings from Bison 2.5. */ 1555 #endif 1556 1557 #define YYRECOVERING() (!!yyerrstatus) 1558 1559 #define YYBACKUP(Token, Value) \ 1560 do \ 1561 if (yychar == YYEMPTY) \ 1562 { \ 1563 yychar = (Token); \ 1564 yylval = (Value); \ 1565 YYPOPSTACK (yylen); \ 1566 yystate = *yyssp; \ 1567 goto yybackup; \ 1568 } \ 1569 else \ 1570 { \ 1571 yyerror (YY_("syntax error: cannot back up")); \ 1572 YYERROR; \ 1573 } \ 1574 while (YYID (0)) 1575 1576 /* Error token number */ 1577 #define YYTERROR 1 1578 #define YYERRCODE 256 1579 1580 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1581 If N is 0, then set CURRENT to the empty location which ends 1582 the previous symbol: RHS[0] (always defined). */ 1583 1584 #ifndef YYLLOC_DEFAULT 1585 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1586 do \ 1587 if (YYID (N)) \ 1588 { \ 1589 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1590 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1591 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1592 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1593 } \ 1594 else \ 1595 { \ 1596 (Current).first_line = (Current).last_line = \ 1597 YYRHSLOC (Rhs, 0).last_line; \ 1598 (Current).first_column = (Current).last_column = \ 1599 YYRHSLOC (Rhs, 0).last_column; \ 1600 } \ 1601 while (YYID (0)) 1602 #endif 1603 1604 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1605 1606 /* YY_LOCATION_PRINT -- Print the location on the stream. 1607 This macro was not mandated originally: define only if we know 1608 we won't break user code: when these are the locations we know. */ 1609 1610 #ifndef YY_LOCATION_PRINT 1611 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1612 1613 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */ 1614 1615 __attribute__((__unused__)) 1616 #if (defined __STDC__ || defined __C99__FUNC__ \ 1617 || defined __cplusplus || defined _MSC_VER) 1618 static unsigned 1619 yy_location_print_(FILE *yyo, YYLTYPE const *const yylocp) 1620 #else 1621 static unsigned 1622 yy_location_print_(yyo, yylocp) 1623 FILE *yyo; 1624 YYLTYPE const *const yylocp; 1625 #endif 1626 { 1627 unsigned res = 0; 1628 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; 1629 if (0 <= yylocp->first_line) { 1630 res += fprintf(yyo, "%d", yylocp->first_line); 1631 if (0 <= yylocp->first_column) { 1632 res += fprintf(yyo, ".%d", yylocp->first_column); 1633 } 1634 } 1635 if (0 <= yylocp->last_line) { 1636 if (yylocp->first_line < yylocp->last_line) { 1637 res += fprintf(yyo, "-%d", yylocp->last_line); 1638 if (0 <= end_col) { 1639 res += fprintf(yyo, ".%d", end_col); 1640 } 1641 } else if (0 <= end_col && yylocp->first_column < end_col) { 1642 res += fprintf(yyo, "-%d", end_col); 1643 } 1644 } 1645 return res; 1646 } 1647 1648 # define YY_LOCATION_PRINT(File, Loc) \ 1649 yy_location_print_ (File, &(Loc)) 1650 1651 # else 1652 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1653 # endif 1654 #endif 1655 1656 /* YYLEX -- calling `yylex' with the right arguments. */ 1657 #ifdef YYLEX_PARAM 1658 # define YYLEX yylex (YYLEX_PARAM) 1659 #else 1660 # define YYLEX yylex () 1661 #endif 1662 1663 /* Enable debugging if requested. */ 1664 #if YYDEBUG 1665 1666 # ifndef YYFPRINTF 1667 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1668 # define YYFPRINTF fprintf 1669 # endif 1670 1671 # define YYDPRINTF(Args) \ 1672 do { \ 1673 if (yydebug) \ 1674 YYFPRINTF Args; \ 1675 } while (YYID (0)) 1676 1677 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1678 do { \ 1679 if (yydebug) \ 1680 { \ 1681 YYFPRINTF (stderr, "%s ", Title); \ 1682 yy_symbol_print (stderr, \ 1683 Type, Value, Location); \ 1684 YYFPRINTF (stderr, "\n"); \ 1685 } \ 1686 } while (YYID (0)) 1687 1688 /*--------------------------------. 1689 | Print this symbol on YYOUTPUT. | 1690 `--------------------------------*/ 1691 1692 /*ARGSUSED*/ 1693 #if (defined __STDC__ || defined __C99__FUNC__ \ 1694 || defined __cplusplus || defined _MSC_VER) 1695 static void 1696 yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, YYLTYPE const *const yylocationp) 1697 #else 1698 static void 1699 yy_symbol_value_print(yyoutput, yytype, yyvaluep, yylocationp) 1700 FILE *yyoutput; 1701 int yytype; 1702 YYSTYPE const *const yyvaluep; 1703 YYLTYPE const *const yylocationp; 1704 #endif 1705 { 1706 FILE *yyo = yyoutput; 1707 YYUSE(yyo); 1708 if (!yyvaluep) { 1709 return; 1710 } 1711 YYUSE(yylocationp); 1712 # ifdef YYPRINT 1713 if (yytype < YYNTOKENS) { 1714 YYPRINT(yyoutput, yytoknum[yytype], *yyvaluep); 1715 } 1716 # else 1717 YYUSE(yyoutput); 1718 # endif 1719 switch (yytype) { 1720 default: 1721 break; 1722 } 1723 } 1724 1725 /*--------------------------------. 1726 | Print this symbol on YYOUTPUT. | 1727 `--------------------------------*/ 1728 1729 #if (defined __STDC__ || defined __C99__FUNC__ \ 1730 || defined __cplusplus || defined _MSC_VER) 1731 static void 1732 yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, YYLTYPE const *const yylocationp) 1733 #else 1734 static void 1735 yy_symbol_print(yyoutput, yytype, yyvaluep, yylocationp) 1736 FILE *yyoutput; 1737 int yytype; 1738 YYSTYPE const *const yyvaluep; 1739 YYLTYPE const *const yylocationp; 1740 #endif 1741 { 1742 if (yytype < YYNTOKENS) { 1743 YYFPRINTF(yyoutput, "token %s (", yytname[yytype]); 1744 } else { 1745 YYFPRINTF(yyoutput, "nterm %s (", yytname[yytype]); 1746 } 1747 1748 YY_LOCATION_PRINT(yyoutput, *yylocationp); 1749 YYFPRINTF(yyoutput, ": "); 1750 yy_symbol_value_print(yyoutput, yytype, yyvaluep, yylocationp); 1751 YYFPRINTF(yyoutput, ")"); 1752 } 1753 1754 /*------------------------------------------------------------------. 1755 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1756 | TOP (included). | 1757 `------------------------------------------------------------------*/ 1758 1759 #if (defined __STDC__ || defined __C99__FUNC__ \ 1760 || defined __cplusplus || defined _MSC_VER) 1761 static void 1762 yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop) 1763 #else 1764 static void 1765 yy_stack_print(yybottom, yytop) 1766 yytype_int16 *yybottom; 1767 yytype_int16 *yytop; 1768 #endif 1769 { 1770 YYFPRINTF(stderr, "Stack now"); 1771 for (; yybottom <= yytop; yybottom++) { 1772 int yybot = *yybottom; 1773 YYFPRINTF(stderr, " %d", yybot); 1774 } 1775 YYFPRINTF(stderr, "\n"); 1776 } 1777 1778 # define YY_STACK_PRINT(Bottom, Top) \ 1779 do { \ 1780 if (yydebug) \ 1781 yy_stack_print ((Bottom), (Top)); \ 1782 } while (YYID (0)) 1783 1784 /*------------------------------------------------. 1785 | Report that the YYRULE is going to be reduced. | 1786 `------------------------------------------------*/ 1787 1788 #if (defined __STDC__ || defined __C99__FUNC__ \ 1789 || defined __cplusplus || defined _MSC_VER) 1790 static void 1791 yy_reduce_print(YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule) 1792 #else 1793 static void 1794 yy_reduce_print(yyvsp, yylsp, yyrule) 1795 YYSTYPE *yyvsp; 1796 YYLTYPE *yylsp; 1797 int yyrule; 1798 #endif 1799 { 1800 int yynrhs = yyr2[yyrule]; 1801 int yyi; 1802 unsigned long int yylno = yyrline[yyrule]; 1803 YYFPRINTF(stderr, "Reducing stack by rule %d (line %lu):\n", 1804 yyrule - 1, yylno); 1805 /* The symbols being reduced. */ 1806 for (yyi = 0; yyi < yynrhs; yyi++) { 1807 YYFPRINTF(stderr, " $%d = ", yyi + 1); 1808 yy_symbol_print(stderr, yyrhs[yyprhs[yyrule] + yyi], 1809 &(yyvsp[(yyi + 1) - (yynrhs)]) 1810 , &(yylsp[(yyi + 1) - (yynrhs)])); 1811 YYFPRINTF(stderr, "\n"); 1812 } 1813 } 1814 1815 # define YY_REDUCE_PRINT(Rule) \ 1816 do { \ 1817 if (yydebug) \ 1818 yy_reduce_print (yyvsp, yylsp, Rule); \ 1819 } while (YYID (0)) 1820 1821 /* Nonzero means print parse trace. It is left uninitialized so that 1822 multiple parsers can coexist. */ 1823 int yydebug; 1824 #else /* !YYDEBUG */ 1825 # define YYDPRINTF(Args) 1826 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1827 # define YY_STACK_PRINT(Bottom, Top) 1828 # define YY_REDUCE_PRINT(Rule) 1829 #endif /* !YYDEBUG */ 1830 1831 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1832 #ifndef YYINITDEPTH 1833 # define YYINITDEPTH 200 1834 #endif 1835 1836 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1837 if the built-in stack extension method is used). 1838 1839 Do not make this value too large; the results are undefined if 1840 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1841 evaluated with infinite-precision integer arithmetic. */ 1842 1843 #ifndef YYMAXDEPTH 1844 # define YYMAXDEPTH 10000 1845 #endif 1846 1847 #if YYERROR_VERBOSE 1848 1849 # ifndef yystrlen 1850 # if defined __GLIBC__ && defined _STRING_H 1851 # define yystrlen strlen 1852 # else 1853 /* Return the length of YYSTR. */ 1854 #if (defined __STDC__ || defined __C99__FUNC__ \ 1855 || defined __cplusplus || defined _MSC_VER) 1856 static YYSIZE_T 1857 yystrlen(const char *yystr) 1858 #else 1859 static YYSIZE_T 1860 yystrlen(yystr) 1861 const char *yystr; 1862 #endif 1863 { 1864 YYSIZE_T yylen; 1865 for (yylen = 0; yystr[yylen]; yylen++) { 1866 continue; 1867 } 1868 return yylen; 1869 } 1870 # endif 1871 # endif 1872 1873 # ifndef yystpcpy 1874 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1875 # define yystpcpy stpcpy 1876 # else 1877 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1878 YYDEST. */ 1879 #if (defined __STDC__ || defined __C99__FUNC__ \ 1880 || defined __cplusplus || defined _MSC_VER) 1881 static char * 1882 yystpcpy(char *yydest, const char *yysrc) 1883 #else 1884 static char * 1885 yystpcpy(yydest, yysrc) 1886 char *yydest; 1887 const char *yysrc; 1888 #endif 1889 { 1890 char *yyd = yydest; 1891 const char *yys = yysrc; 1892 1893 while ((*yyd++ = *yys++) != '\0') { 1894 continue; 1895 } 1896 1897 return yyd - 1; 1898 } 1899 # endif 1900 # endif 1901 1902 # ifndef yytnamerr 1903 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1904 quotes and backslashes, so that it's suitable for yyerror. The 1905 heuristic is that double-quoting is unnecessary unless the string 1906 contains an apostrophe, a comma, or backslash (other than 1907 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1908 null, do not copy; instead, return the length of what the result 1909 would have been. */ 1910 static YYSIZE_T 1911 yytnamerr(char *yyres, const char *yystr) 1912 { 1913 if (*yystr == '"') { 1914 YYSIZE_T yyn = 0; 1915 char const *yyp = yystr; 1916 1917 for (;;) 1918 switch (*++yyp) { 1919 case '\'': 1920 case ',': 1921 goto do_not_strip_quotes; 1922 1923 case '\\': 1924 if (*++yyp != '\\') { 1925 goto do_not_strip_quotes; 1926 } 1927 /* Fall through. */ 1928 default: 1929 if (yyres) { 1930 yyres[yyn] = *yyp; 1931 } 1932 yyn++; 1933 break; 1934 1935 case '"': 1936 if (yyres) { 1937 yyres[yyn] = '\0'; 1938 } 1939 return yyn; 1940 } 1941 do_not_strip_quotes: ; 1942 } 1943 1944 if (! yyres) { 1945 return yystrlen(yystr); 1946 } 1947 1948 return yystpcpy(yyres, yystr) - yyres; 1949 } 1950 # endif 1951 1952 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1953 about the unexpected token YYTOKEN for the state stack whose top is 1954 YYSSP. 1955 1956 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1957 not large enough to hold the message. In that case, also set 1958 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1959 required number of bytes is too large to store. */ 1960 static int 1961 yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, 1962 yytype_int16 *yyssp, int yytoken) 1963 { 1964 YYSIZE_T yysize0 = yytnamerr(YY_NULL, yytname[yytoken]); 1965 YYSIZE_T yysize = yysize0; 1966 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1967 /* Internationalized format string. */ 1968 const char *yyformat = YY_NULL; 1969 /* Arguments of yyformat. */ 1970 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1971 /* Number of reported tokens (one for the "unexpected", one per 1972 "expected"). */ 1973 int yycount = 0; 1974 1975 /* There are many possibilities here to consider: 1976 - Assume YYFAIL is not used. It's too flawed to consider. See 1977 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1978 for details. YYERROR is fine as it does not invoke this 1979 function. 1980 - If this state is a consistent state with a default action, then 1981 the only way this function was invoked is if the default action 1982 is an error action. In that case, don't check for expected 1983 tokens because there are none. 1984 - The only way there can be no lookahead present (in yychar) is if 1985 this state is a consistent state with a default action. Thus, 1986 detecting the absence of a lookahead is sufficient to determine 1987 that there is no unexpected or expected token to report. In that 1988 case, just report a simple "syntax error". 1989 - Don't assume there isn't a lookahead just because this state is a 1990 consistent state with a default action. There might have been a 1991 previous inconsistent state, consistent state with a non-default 1992 action, or user semantic action that manipulated yychar. 1993 - Of course, the expected token list depends on states to have 1994 correct lookahead information, and it depends on the parser not 1995 to perform extra reductions after fetching a lookahead from the 1996 scanner and before detecting a syntax error. Thus, state merging 1997 (from LALR or IELR) and default reductions corrupt the expected 1998 token list. However, the list is correct for canonical LR with 1999 one exception: it will still contain any token that will not be 2000 accepted due to an error action in a later state. 2001 */ 2002 if (yytoken != YYEMPTY) { 2003 int yyn = yypact[*yyssp]; 2004 yyarg[yycount++] = yytname[yytoken]; 2005 if (!yypact_value_is_default(yyn)) { 2006 /* Start YYX at -YYN if negative to avoid negative indexes in 2007 YYCHECK. In other words, skip the first -YYN actions for 2008 this state because they are default actions. */ 2009 int yyxbegin = yyn < 0 ? -yyn : 0; 2010 /* Stay within bounds of both yycheck and yytname. */ 2011 int yychecklim = YYLAST - yyn + 1; 2012 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2013 int yyx; 2014 2015 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2016 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 2017 && !yytable_value_is_error(yytable[yyx + yyn])) { 2018 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { 2019 yycount = 1; 2020 yysize = yysize0; 2021 break; 2022 } 2023 yyarg[yycount++] = yytname[yyx]; 2024 { 2025 YYSIZE_T yysize1 = yysize + yytnamerr(YY_NULL, yytname[yyx]); 2026 if (!(yysize <= yysize1 2027 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) { 2028 return 2; 2029 } 2030 yysize = yysize1; 2031 } 2032 } 2033 } 2034 } 2035 2036 switch (yycount) { 2037 # define YYCASE_(N, S) \ 2038 case N: \ 2039 yyformat = S; \ 2040 break 2041 YYCASE_(0, YY_("syntax error")); 2042 YYCASE_(1, YY_("syntax error, unexpected %s")); 2043 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 2044 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 2045 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 2046 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 2047 # undef YYCASE_ 2048 } 2049 2050 { 2051 YYSIZE_T yysize1 = yysize + yystrlen(yyformat); 2052 if (!(yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) { 2053 return 2; 2054 } 2055 yysize = yysize1; 2056 } 2057 2058 if (*yymsg_alloc < yysize) { 2059 *yymsg_alloc = 2 * yysize; 2060 if (!(yysize <= *yymsg_alloc 2061 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) { 2062 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 2063 } 2064 return 1; 2065 } 2066 2067 /* Avoid sprintf, as that infringes on the user's name space. 2068 Don't have undefined behavior even if the translation 2069 produced a string with the wrong number of "%s"s. */ 2070 { 2071 char *yyp = *yymsg; 2072 int yyi = 0; 2073 while ((*yyp = *yyformat) != '\0') 2074 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) { 2075 yyp += yytnamerr(yyp, yyarg[yyi++]); 2076 yyformat += 2; 2077 } else { 2078 yyp++; 2079 yyformat++; 2080 } 2081 } 2082 return 0; 2083 } 2084 #endif /* YYERROR_VERBOSE */ 2085 2086 /*-----------------------------------------------. 2087 | Release the memory associated to this symbol. | 2088 `-----------------------------------------------*/ 2089 2090 /*ARGSUSED*/ 2091 #if (defined __STDC__ || defined __C99__FUNC__ \ 2092 || defined __cplusplus || defined _MSC_VER) 2093 static void 2094 yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp) 2095 #else 2096 static void 2097 yydestruct(yymsg, yytype, yyvaluep, yylocationp) 2098 const char *yymsg; 2099 int yytype; 2100 YYSTYPE *yyvaluep; 2101 YYLTYPE *yylocationp; 2102 #endif 2103 { 2104 YYUSE(yyvaluep); 2105 YYUSE(yylocationp); 2106 2107 if (!yymsg) { 2108 yymsg = "Deleting"; 2109 } 2110 YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp); 2111 2112 switch (yytype) { 2113 2114 default: 2115 break; 2116 } 2117 } 2118 2119 /* The lookahead symbol. */ 2120 int yychar; 2121 2122 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2123 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2124 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 2125 #endif 2126 #ifndef YY_INITIAL_VALUE 2127 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 2128 #endif 2129 2130 /* The semantic value of the lookahead symbol. */ 2131 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default); 2132 2133 /* Location data for the lookahead symbol. */ 2134 YYLTYPE yylloc 2135 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2136 = { 1, 1, 1, 1 } 2137 # endif 2138 ; 2139 2140 /* Number of syntax errors so far. */ 2141 int yynerrs; 2142 2143 /*----------. 2144 | yyparse. | 2145 `----------*/ 2146 2147 #ifdef YYPARSE_PARAM 2148 #if (defined __STDC__ || defined __C99__FUNC__ \ 2149 || defined __cplusplus || defined _MSC_VER) 2150 int 2151 yyparse(void *YYPARSE_PARAM) 2152 #else 2153 int 2154 yyparse(YYPARSE_PARAM) 2155 void *YYPARSE_PARAM; 2156 #endif 2157 #else /* ! YYPARSE_PARAM */ 2158 #if (defined __STDC__ || defined __C99__FUNC__ \ 2159 || defined __cplusplus || defined _MSC_VER) 2160 int 2161 yyparse(void) 2162 #else 2163 int 2164 yyparse() 2165 2166 #endif 2167 #endif 2168 { 2169 int yystate; 2170 /* Number of tokens to shift before error messages enabled. */ 2171 int yyerrstatus; 2172 2173 /* The stacks and their tools: 2174 `yyss': related to states. 2175 `yyvs': related to semantic values. 2176 `yyls': related to locations. 2177 2178 Refer to the stacks through separate pointers, to allow yyoverflow 2179 to reallocate them elsewhere. */ 2180 2181 /* The state stack. */ 2182 yytype_int16 yyssa[YYINITDEPTH]; 2183 yytype_int16 *yyss; 2184 yytype_int16 *yyssp; 2185 2186 /* The semantic value stack. */ 2187 YYSTYPE yyvsa[YYINITDEPTH]; 2188 YYSTYPE *yyvs; 2189 YYSTYPE *yyvsp; 2190 2191 /* The location stack. */ 2192 YYLTYPE yylsa[YYINITDEPTH]; 2193 YYLTYPE *yyls; 2194 YYLTYPE *yylsp; 2195 2196 /* The locations where the error started and ended. */ 2197 YYLTYPE yyerror_range[3]; 2198 2199 YYSIZE_T yystacksize; 2200 2201 int yyn; 2202 int yyresult; 2203 /* Lookahead token as an internal (translated) token number. */ 2204 int yytoken = 0; 2205 /* The variables used to return semantic value and location from the 2206 action routines. */ 2207 YYSTYPE yyval; 2208 YYLTYPE yyloc; 2209 2210 #if YYERROR_VERBOSE 2211 /* Buffer for error messages, and its allocated size. */ 2212 char yymsgbuf[128]; 2213 char *yymsg = yymsgbuf; 2214 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2215 #endif 2216 2217 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2218 2219 /* The number of symbols on the RHS of the reduced rule. 2220 Keep to zero when no symbol should be popped. */ 2221 int yylen = 0; 2222 2223 yyssp = yyss = yyssa; 2224 yyvsp = yyvs = yyvsa; 2225 yylsp = yyls = yylsa; 2226 yystacksize = YYINITDEPTH; 2227 2228 YYDPRINTF((stderr, "Starting parse\n")); 2229 2230 yystate = 0; 2231 yyerrstatus = 0; 2232 yynerrs = 0; 2233 yychar = YYEMPTY; /* Cause a token to be read. */ 2234 yylsp[0] = yylloc; 2235 goto yysetstate; 2236 2237 /*------------------------------------------------------------. 2238 | yynewstate -- Push a new state, which is found in yystate. | 2239 `------------------------------------------------------------*/ 2240 yynewstate: 2241 /* In all cases, when you get here, the value and location stacks 2242 have just been pushed. So pushing a state here evens the stacks. */ 2243 yyssp++; 2244 2245 yysetstate: 2246 *yyssp = yystate; 2247 2248 if (yyss + yystacksize - 1 <= yyssp) { 2249 /* Get the current used size of the three stacks, in elements. */ 2250 YYSIZE_T yysize = yyssp - yyss + 1; 2251 2252 #ifdef yyoverflow 2253 { 2254 /* Give user a chance to reallocate the stack. Use copies of 2255 these so that the &'s don't force the real ones into 2256 memory. */ 2257 YYSTYPE *yyvs1 = yyvs; 2258 yytype_int16 *yyss1 = yyss; 2259 YYLTYPE *yyls1 = yyls; 2260 2261 /* Each stack pointer address is followed by the size of the 2262 data in use in that stack, in bytes. This used to be a 2263 conditional around just the two extra args, but that might 2264 be undefined if yyoverflow is a macro. */ 2265 yyoverflow(YY_("memory exhausted"), 2266 &yyss1, yysize * sizeof(*yyssp), 2267 &yyvs1, yysize * sizeof(*yyvsp), 2268 &yyls1, yysize * sizeof(*yylsp), 2269 &yystacksize); 2270 2271 yyls = yyls1; 2272 yyss = yyss1; 2273 yyvs = yyvs1; 2274 } 2275 #else /* no yyoverflow */ 2276 # ifndef YYSTACK_RELOCATE 2277 goto yyexhaustedlab; 2278 # else 2279 /* Extend the stack our own way. */ 2280 if (YYMAXDEPTH <= yystacksize) { 2281 goto yyexhaustedlab; 2282 } 2283 yystacksize *= 2; 2284 if (YYMAXDEPTH < yystacksize) { 2285 yystacksize = YYMAXDEPTH; 2286 } 2287 2288 { 2289 yytype_int16 *yyss1 = yyss; 2290 union yyalloc *yyptr = 2291 (union yyalloc *) YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize)); 2292 if (! yyptr) { 2293 goto yyexhaustedlab; 2294 } 2295 YYSTACK_RELOCATE(yyss_alloc, yyss); 2296 YYSTACK_RELOCATE(yyvs_alloc, yyvs); 2297 YYSTACK_RELOCATE(yyls_alloc, yyls); 2298 # undef YYSTACK_RELOCATE 2299 if (yyss1 != yyssa) { 2300 YYSTACK_FREE(yyss1); 2301 } 2302 } 2303 # endif 2304 #endif /* no yyoverflow */ 2305 2306 yyssp = yyss + yysize - 1; 2307 yyvsp = yyvs + yysize - 1; 2308 yylsp = yyls + yysize - 1; 2309 2310 YYDPRINTF((stderr, "Stack size increased to %lu\n", 2311 (unsigned long int) yystacksize)); 2312 2313 if (yyss + yystacksize - 1 <= yyssp) { 2314 YYABORT; 2315 } 2316 } 2317 2318 YYDPRINTF((stderr, "Entering state %d\n", yystate)); 2319 2320 if (yystate == YYFINAL) { 2321 YYACCEPT; 2322 } 2323 2324 goto yybackup; 2325 2326 /*-----------. 2327 | yybackup. | 2328 `-----------*/ 2329 yybackup: 2330 2331 /* Do appropriate processing given the current state. Read a 2332 lookahead token if we need one and don't already have one. */ 2333 2334 /* First try to decide what to do without reference to lookahead token. */ 2335 yyn = yypact[yystate]; 2336 if (yypact_value_is_default(yyn)) { 2337 goto yydefault; 2338 } 2339 2340 /* Not known => get a lookahead token if don't already have one. */ 2341 2342 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2343 if (yychar == YYEMPTY) { 2344 YYDPRINTF((stderr, "Reading a token: ")); 2345 yychar = YYLEX; 2346 } 2347 2348 if (yychar <= YYEOF) { 2349 yychar = yytoken = YYEOF; 2350 YYDPRINTF((stderr, "Now at end of input.\n")); 2351 } else { 2352 yytoken = YYTRANSLATE(yychar); 2353 YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc); 2354 } 2355 2356 /* If the proper action on seeing token YYTOKEN is to reduce or to 2357 detect an error, take that action. */ 2358 yyn += yytoken; 2359 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) { 2360 goto yydefault; 2361 } 2362 yyn = yytable[yyn]; 2363 if (yyn <= 0) { 2364 if (yytable_value_is_error(yyn)) { 2365 goto yyerrlab; 2366 } 2367 yyn = -yyn; 2368 goto yyreduce; 2369 } 2370 2371 /* Count tokens shifted since error; after three, turn off error 2372 status. */ 2373 if (yyerrstatus) { 2374 yyerrstatus--; 2375 } 2376 2377 /* Shift the lookahead token. */ 2378 YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc); 2379 2380 /* Discard the shifted token. */ 2381 yychar = YYEMPTY; 2382 2383 yystate = yyn; 2384 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2385 *++yyvsp = yylval; 2386 YY_IGNORE_MAYBE_UNINITIALIZED_END 2387 *++yylsp = yylloc; 2388 goto yynewstate; 2389 2390 /*-----------------------------------------------------------. 2391 | yydefault -- do the default action for the current state. | 2392 `-----------------------------------------------------------*/ 2393 yydefault: 2394 yyn = yydefact[yystate]; 2395 if (yyn == 0) { 2396 goto yyerrlab; 2397 } 2398 goto yyreduce; 2399 2400 /*-----------------------------. 2401 | yyreduce -- Do a reduction. | 2402 `-----------------------------*/ 2403 yyreduce: 2404 /* yyn is the number of a rule to reduce with. */ 2405 yylen = yyr2[yyn]; 2406 2407 /* If YYLEN is nonzero, implement the default value of the action: 2408 `$$ = $1'. 2409 2410 Otherwise, the following line sets YYVAL to garbage. 2411 This behavior is undocumented and Bison 2412 users should not rely upon it. Assigning to YYVAL 2413 unconditionally makes the parser a bit smaller, and it avoids a 2414 GCC warning that YYVAL may be used uninitialized. */ 2415 yyval = yyvsp[1 - yylen]; 2416 2417 /* Default location. */ 2418 YYLLOC_DEFAULT(yyloc, (yylsp - yylen), yylen); 2419 YY_REDUCE_PRINT(yyn); 2420 switch (yyn) { 2421 case 2: 2422 /* Line 1792 of yacc.c */ 2423 #line 194 "grammar.y" 2424 { 2425 (yyval.ident) = new Identifier("break"); 2426 } 2427 break; 2428 2429 case 3: 2430 /* Line 1792 of yacc.c */ 2431 #line 195 "grammar.y" 2432 { 2433 (yyval.ident) = new Identifier("case"); 2434 } 2435 break; 2436 2437 case 4: 2438 /* Line 1792 of yacc.c */ 2439 #line 196 "grammar.y" 2440 { 2441 (yyval.ident) = new Identifier("default"); 2442 } 2443 break; 2444 2445 case 5: 2446 /* Line 1792 of yacc.c */ 2447 #line 197 "grammar.y" 2448 { 2449 (yyval.ident) = new Identifier("for"); 2450 } 2451 break; 2452 2453 case 6: 2454 /* Line 1792 of yacc.c */ 2455 #line 198 "grammar.y" 2456 { 2457 (yyval.ident) = new Identifier("new"); 2458 } 2459 break; 2460 2461 case 7: 2462 /* Line 1792 of yacc.c */ 2463 #line 199 "grammar.y" 2464 { 2465 (yyval.ident) = new Identifier("var"); 2466 } 2467 break; 2468 2469 case 8: 2470 /* Line 1792 of yacc.c */ 2471 #line 200 "grammar.y" 2472 { 2473 (yyval.ident) = new Identifier("const"); 2474 } 2475 break; 2476 2477 case 9: 2478 /* Line 1792 of yacc.c */ 2479 #line 201 "grammar.y" 2480 { 2481 (yyval.ident) = new Identifier("continue"); 2482 } 2483 break; 2484 2485 case 10: 2486 /* Line 1792 of yacc.c */ 2487 #line 202 "grammar.y" 2488 { 2489 (yyval.ident) = new Identifier("function"); 2490 } 2491 break; 2492 2493 case 11: 2494 /* Line 1792 of yacc.c */ 2495 #line 203 "grammar.y" 2496 { 2497 (yyval.ident) = new Identifier("return"); 2498 } 2499 break; 2500 2501 case 12: 2502 /* Line 1792 of yacc.c */ 2503 #line 204 "grammar.y" 2504 { 2505 (yyval.ident) = new Identifier("void"); 2506 } 2507 break; 2508 2509 case 13: 2510 /* Line 1792 of yacc.c */ 2511 #line 205 "grammar.y" 2512 { 2513 (yyval.ident) = new Identifier("delete"); 2514 } 2515 break; 2516 2517 case 14: 2518 /* Line 1792 of yacc.c */ 2519 #line 206 "grammar.y" 2520 { 2521 (yyval.ident) = new Identifier("if"); 2522 } 2523 break; 2524 2525 case 15: 2526 /* Line 1792 of yacc.c */ 2527 #line 207 "grammar.y" 2528 { 2529 (yyval.ident) = new Identifier("this"); 2530 } 2531 break; 2532 2533 case 16: 2534 /* Line 1792 of yacc.c */ 2535 #line 208 "grammar.y" 2536 { 2537 (yyval.ident) = new Identifier("do"); 2538 } 2539 break; 2540 2541 case 17: 2542 /* Line 1792 of yacc.c */ 2543 #line 209 "grammar.y" 2544 { 2545 (yyval.ident) = new Identifier("while"); 2546 } 2547 break; 2548 2549 case 18: 2550 /* Line 1792 of yacc.c */ 2551 #line 210 "grammar.y" 2552 { 2553 (yyval.ident) = new Identifier("in"); 2554 } 2555 break; 2556 2557 case 19: 2558 /* Line 1792 of yacc.c */ 2559 #line 211 "grammar.y" 2560 { 2561 (yyval.ident) = new Identifier("instanceof"); 2562 } 2563 break; 2564 2565 case 20: 2566 /* Line 1792 of yacc.c */ 2567 #line 212 "grammar.y" 2568 { 2569 (yyval.ident) = new Identifier("typeof"); 2570 } 2571 break; 2572 2573 case 21: 2574 /* Line 1792 of yacc.c */ 2575 #line 213 "grammar.y" 2576 { 2577 (yyval.ident) = new Identifier("switch"); 2578 } 2579 break; 2580 2581 case 22: 2582 /* Line 1792 of yacc.c */ 2583 #line 214 "grammar.y" 2584 { 2585 (yyval.ident) = new Identifier("with"); 2586 } 2587 break; 2588 2589 case 23: 2590 /* Line 1792 of yacc.c */ 2591 #line 215 "grammar.y" 2592 { 2593 (yyval.ident) = new Identifier("throw"); 2594 } 2595 break; 2596 2597 case 24: 2598 /* Line 1792 of yacc.c */ 2599 #line 216 "grammar.y" 2600 { 2601 (yyval.ident) = new Identifier("try"); 2602 } 2603 break; 2604 2605 case 25: 2606 /* Line 1792 of yacc.c */ 2607 #line 217 "grammar.y" 2608 { 2609 (yyval.ident) = new Identifier("catch"); 2610 } 2611 break; 2612 2613 case 26: 2614 /* Line 1792 of yacc.c */ 2615 #line 218 "grammar.y" 2616 { 2617 (yyval.ident) = new Identifier("finally"); 2618 } 2619 break; 2620 2621 case 27: 2622 /* Line 1792 of yacc.c */ 2623 #line 219 "grammar.y" 2624 { 2625 (yyval.ident) = new Identifier("debugger"); 2626 } 2627 break; 2628 2629 case 28: 2630 /* Line 1792 of yacc.c */ 2631 #line 220 "grammar.y" 2632 { 2633 (yyval.ident) = new Identifier("import"); 2634 } 2635 break; 2636 2637 case 29: 2638 /* Line 1792 of yacc.c */ 2639 #line 221 "grammar.y" 2640 { 2641 (yyval.ident) = new Identifier("null"); 2642 } 2643 break; 2644 2645 case 30: 2646 /* Line 1792 of yacc.c */ 2647 #line 222 "grammar.y" 2648 { 2649 (yyval.ident) = new Identifier("true"); 2650 } 2651 break; 2652 2653 case 31: 2654 /* Line 1792 of yacc.c */ 2655 #line 223 "grammar.y" 2656 { 2657 (yyval.ident) = new Identifier("false"); 2658 } 2659 break; 2660 2661 case 32: 2662 /* Line 1792 of yacc.c */ 2663 #line 224 "grammar.y" 2664 { 2665 (yyval.ident) = new Identifier("else"); 2666 } 2667 break; 2668 2669 case 33: 2670 /* Line 1792 of yacc.c */ 2671 #line 228 "grammar.y" 2672 { 2673 (yyval.ident) = (yyvsp[(1) - (1)].ident); 2674 } 2675 break; 2676 2677 case 34: 2678 /* Line 1792 of yacc.c */ 2679 #line 229 "grammar.y" 2680 { 2681 (yyval.ident) = (yyvsp[(1) - (1)].ident); 2682 } 2683 break; 2684 2685 case 35: 2686 /* Line 1792 of yacc.c */ 2687 #line 233 "grammar.y" 2688 { 2689 (yyval.node) = new NullNode(); 2690 } 2691 break; 2692 2693 case 36: 2694 /* Line 1792 of yacc.c */ 2695 #line 234 "grammar.y" 2696 { 2697 (yyval.node) = new BooleanNode(true); 2698 } 2699 break; 2700 2701 case 37: 2702 /* Line 1792 of yacc.c */ 2703 #line 235 "grammar.y" 2704 { 2705 (yyval.node) = new BooleanNode(false); 2706 } 2707 break; 2708 2709 case 38: 2710 /* Line 1792 of yacc.c */ 2711 #line 236 "grammar.y" 2712 { 2713 (yyval.node) = new NumberNode((yyvsp[(1) - (1)].dval)); 2714 } 2715 break; 2716 2717 case 39: 2718 /* Line 1792 of yacc.c */ 2719 #line 237 "grammar.y" 2720 { 2721 (yyval.node) = new StringNode((yyvsp[(1) - (1)].ustr)); 2722 } 2723 break; 2724 2725 case 40: 2726 /* Line 1792 of yacc.c */ 2727 #line 238 "grammar.y" 2728 { 2729 Lexer &l = lexer(); 2730 if (!l.scanRegExp()) { 2731 YYABORT; 2732 } 2733 (yyval.node) = new RegExpNode(l.pattern(), l.flags()); 2734 } 2735 break; 2736 2737 case 41: 2738 /* Line 1792 of yacc.c */ 2739 #line 244 "grammar.y" 2740 { 2741 Lexer &l = lexer(); 2742 if (!l.scanRegExp()) { 2743 YYABORT; 2744 } 2745 (yyval.node) = new RegExpNode("=" + l.pattern(), l.flags()); 2746 } 2747 break; 2748 2749 case 42: 2750 /* Line 1792 of yacc.c */ 2751 #line 253 "grammar.y" 2752 { 2753 (yyval.pname) = new PropertyNameNode(*(yyvsp[(1) - (1)].ident)); 2754 } 2755 break; 2756 2757 case 43: 2758 /* Line 1792 of yacc.c */ 2759 #line 254 "grammar.y" 2760 { 2761 (yyval.pname) = new PropertyNameNode(Identifier(*(yyvsp[(1) - (1)].ustr))); 2762 } 2763 break; 2764 2765 case 44: 2766 /* Line 1792 of yacc.c */ 2767 #line 255 "grammar.y" 2768 { 2769 (yyval.pname) = new PropertyNameNode(Identifier(UString::from((yyvsp[(1) - (1)].dval)))); 2770 } 2771 break; 2772 2773 case 45: 2774 /* Line 1792 of yacc.c */ 2775 #line 259 "grammar.y" 2776 { 2777 (yyval.pnode) = new PropertyNode((yyvsp[(1) - (3)].pname), (yyvsp[(3) - (3)].node), PropertyNode::Constant); 2778 } 2779 break; 2780 2781 case 46: 2782 /* Line 1792 of yacc.c */ 2783 #line 260 "grammar.y" 2784 { 2785 inFuncExpr(); 2786 } 2787 break; 2788 2789 case 47: 2790 /* Line 1792 of yacc.c */ 2791 #line 260 "grammar.y" 2792 { 2793 if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (6)].ident), *(yyvsp[(2) - (6)].ident), nullptr, (yyvsp[(6) - (6)].body))) { 2794 YYABORT; 2795 } 2796 } 2797 break; 2798 2799 case 48: 2800 /* Line 1792 of yacc.c */ 2801 #line 264 "grammar.y" 2802 { 2803 inFuncExpr(); 2804 } 2805 break; 2806 2807 case 49: 2808 /* Line 1792 of yacc.c */ 2809 #line 264 "grammar.y" 2810 { 2811 if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (7)].ident), *(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body))) { 2812 YYABORT; 2813 } 2814 } 2815 break; 2816 2817 case 50: 2818 /* Line 1792 of yacc.c */ 2819 #line 271 "grammar.y" 2820 { 2821 (yyval.plist) = new PropertyListNode((yyvsp[(1) - (1)].pnode)); 2822 } 2823 break; 2824 2825 case 51: 2826 /* Line 1792 of yacc.c */ 2827 #line 272 "grammar.y" 2828 { 2829 (yyval.plist) = new PropertyListNode((yyvsp[(3) - (3)].pnode), (yyvsp[(1) - (3)].plist)); 2830 } 2831 break; 2832 2833 case 53: 2834 /* Line 1792 of yacc.c */ 2835 #line 277 "grammar.y" 2836 { 2837 (yyval.node) = new ObjectLiteralNode(); 2838 } 2839 break; 2840 2841 case 54: 2842 /* Line 1792 of yacc.c */ 2843 #line 278 "grammar.y" 2844 { 2845 (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (3)].plist)); 2846 } 2847 break; 2848 2849 case 55: 2850 /* Line 1792 of yacc.c */ 2851 #line 280 "grammar.y" 2852 { 2853 (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (4)].plist)); 2854 } 2855 break; 2856 2857 case 56: 2858 /* Line 1792 of yacc.c */ 2859 #line 284 "grammar.y" 2860 { 2861 (yyval.node) = new ThisNode(); 2862 } 2863 break; 2864 2865 case 59: 2866 /* Line 1792 of yacc.c */ 2867 #line 287 "grammar.y" 2868 { 2869 (yyval.node) = new VarAccessNode(*(yyvsp[(1) - (1)].ident)); 2870 } 2871 break; 2872 2873 case 60: 2874 /* Line 1792 of yacc.c */ 2875 #line 288 "grammar.y" 2876 { 2877 (yyval.node) = makeGroupNode((yyvsp[(2) - (3)].node)); 2878 } 2879 break; 2880 2881 case 61: 2882 /* Line 1792 of yacc.c */ 2883 #line 293 "grammar.y" 2884 { 2885 (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].ival)); 2886 } 2887 break; 2888 2889 case 62: 2890 /* Line 1792 of yacc.c */ 2891 #line 294 "grammar.y" 2892 { 2893 (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].elm)); 2894 } 2895 break; 2896 2897 case 63: 2898 /* Line 1792 of yacc.c */ 2899 #line 295 "grammar.y" 2900 { 2901 (yyval.node) = new ArrayNode((yyvsp[(4) - (5)].ival), (yyvsp[(2) - (5)].elm)); 2902 } 2903 break; 2904 2905 case 64: 2906 /* Line 1792 of yacc.c */ 2907 #line 299 "grammar.y" 2908 { 2909 (yyval.elm) = new ElementNode((yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].node)); 2910 } 2911 break; 2912 2913 case 65: 2914 /* Line 1792 of yacc.c */ 2915 #line 301 "grammar.y" 2916 { 2917 (yyval.elm) = new ElementNode((yyvsp[(1) - (4)].elm), (yyvsp[(3) - (4)].ival), (yyvsp[(4) - (4)].node)); 2918 } 2919 break; 2920 2921 case 66: 2922 /* Line 1792 of yacc.c */ 2923 #line 305 "grammar.y" 2924 { 2925 (yyval.ival) = 0; 2926 } 2927 break; 2928 2929 case 68: 2930 /* Line 1792 of yacc.c */ 2931 #line 310 "grammar.y" 2932 { 2933 (yyval.ival) = 1; 2934 } 2935 break; 2936 2937 case 69: 2938 /* Line 1792 of yacc.c */ 2939 #line 311 "grammar.y" 2940 { 2941 (yyval.ival) = (yyvsp[(1) - (2)].ival) + 1; 2942 } 2943 break; 2944 2945 case 71: 2946 /* Line 1792 of yacc.c */ 2947 #line 316 "grammar.y" 2948 { 2949 (yyval.node) = (yyvsp[(1) - (1)].funcExpr); 2950 } 2951 break; 2952 2953 case 72: 2954 /* Line 1792 of yacc.c */ 2955 #line 317 "grammar.y" 2956 { 2957 (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2958 } 2959 break; 2960 2961 case 73: 2962 /* Line 1792 of yacc.c */ 2963 #line 318 "grammar.y" 2964 { 2965 (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); 2966 } 2967 break; 2968 2969 case 74: 2970 /* Line 1792 of yacc.c */ 2971 #line 319 "grammar.y" 2972 { 2973 (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); 2974 } 2975 break; 2976 2977 case 76: 2978 /* Line 1792 of yacc.c */ 2979 #line 324 "grammar.y" 2980 { 2981 (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 2982 } 2983 break; 2984 2985 case 77: 2986 /* Line 1792 of yacc.c */ 2987 #line 325 "grammar.y" 2988 { 2989 (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); 2990 } 2991 break; 2992 2993 case 78: 2994 /* Line 1792 of yacc.c */ 2995 #line 326 "grammar.y" 2996 { 2997 (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); 2998 } 2999 break; 3000 3001 case 80: 3002 /* Line 1792 of yacc.c */ 3003 #line 331 "grammar.y" 3004 { 3005 (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); 3006 } 3007 break; 3008 3009 case 82: 3010 /* Line 1792 of yacc.c */ 3011 #line 336 "grammar.y" 3012 { 3013 (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); 3014 } 3015 break; 3016 3017 case 83: 3018 /* Line 1792 of yacc.c */ 3019 #line 340 "grammar.y" 3020 { 3021 (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); 3022 } 3023 break; 3024 3025 case 84: 3026 /* Line 1792 of yacc.c */ 3027 #line 341 "grammar.y" 3028 { 3029 (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); 3030 } 3031 break; 3032 3033 case 85: 3034 /* Line 1792 of yacc.c */ 3035 #line 342 "grammar.y" 3036 { 3037 (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 3038 } 3039 break; 3040 3041 case 86: 3042 /* Line 1792 of yacc.c */ 3043 #line 343 "grammar.y" 3044 { 3045 (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); 3046 } 3047 break; 3048 3049 case 87: 3050 /* Line 1792 of yacc.c */ 3051 #line 347 "grammar.y" 3052 { 3053 (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); 3054 } 3055 break; 3056 3057 case 88: 3058 /* Line 1792 of yacc.c */ 3059 #line 348 "grammar.y" 3060 { 3061 (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); 3062 } 3063 break; 3064 3065 case 89: 3066 /* Line 1792 of yacc.c */ 3067 #line 349 "grammar.y" 3068 { 3069 (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); 3070 } 3071 break; 3072 3073 case 90: 3074 /* Line 1792 of yacc.c */ 3075 #line 350 "grammar.y" 3076 { 3077 (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); 3078 } 3079 break; 3080 3081 case 91: 3082 /* Line 1792 of yacc.c */ 3083 #line 354 "grammar.y" 3084 { 3085 (yyval.args) = new ArgumentsNode(); 3086 } 3087 break; 3088 3089 case 92: 3090 /* Line 1792 of yacc.c */ 3091 #line 355 "grammar.y" 3092 { 3093 (yyval.args) = new ArgumentsNode((yyvsp[(2) - (3)].alist)); 3094 } 3095 break; 3096 3097 case 93: 3098 /* Line 1792 of yacc.c */ 3099 #line 359 "grammar.y" 3100 { 3101 (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (1)].node)); 3102 } 3103 break; 3104 3105 case 94: 3106 /* Line 1792 of yacc.c */ 3107 #line 360 "grammar.y" 3108 { 3109 (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (3)].alist), (yyvsp[(3) - (3)].node)); 3110 } 3111 break; 3112 3113 case 99: 3114 /* Line 1792 of yacc.c */ 3115 #line 374 "grammar.y" 3116 { 3117 (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); 3118 } 3119 break; 3120 3121 case 100: 3122 /* Line 1792 of yacc.c */ 3123 #line 375 "grammar.y" 3124 { 3125 (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); 3126 } 3127 break; 3128 3129 case 101: 3130 /* Line 1792 of yacc.c */ 3131 #line 376 "grammar.y" 3132 { 3133 (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); 3134 } 3135 break; 3136 3137 case 102: 3138 /* Line 1792 of yacc.c */ 3139 #line 377 "grammar.y" 3140 { 3141 (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); 3142 } 3143 break; 3144 3145 case 104: 3146 /* Line 1792 of yacc.c */ 3147 #line 382 "grammar.y" 3148 { 3149 (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); 3150 } 3151 break; 3152 3153 case 105: 3154 /* Line 1792 of yacc.c */ 3155 #line 383 "grammar.y" 3156 { 3157 (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); 3158 } 3159 break; 3160 3161 case 108: 3162 /* Line 1792 of yacc.c */ 3163 #line 389 "grammar.y" 3164 { 3165 (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); 3166 } 3167 break; 3168 3169 case 109: 3170 /* Line 1792 of yacc.c */ 3171 #line 390 "grammar.y" 3172 { 3173 (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); 3174 } 3175 break; 3176 3177 case 111: 3178 /* Line 1792 of yacc.c */ 3179 #line 395 "grammar.y" 3180 { 3181 (yyval.node) = makeDeleteNode((yyvsp[(2) - (2)].node)); 3182 } 3183 break; 3184 3185 case 112: 3186 /* Line 1792 of yacc.c */ 3187 #line 396 "grammar.y" 3188 { 3189 (yyval.node) = new VoidNode((yyvsp[(2) - (2)].node)); 3190 } 3191 break; 3192 3193 case 113: 3194 /* Line 1792 of yacc.c */ 3195 #line 397 "grammar.y" 3196 { 3197 (yyval.node) = makeTypeOfNode((yyvsp[(2) - (2)].node)); 3198 } 3199 break; 3200 3201 case 114: 3202 /* Line 1792 of yacc.c */ 3203 #line 398 "grammar.y" 3204 { 3205 (yyval.node) = makeUnaryPlusNode((yyvsp[(2) - (2)].node)); 3206 } 3207 break; 3208 3209 case 115: 3210 /* Line 1792 of yacc.c */ 3211 #line 399 "grammar.y" 3212 { 3213 (yyval.node) = makeNegateNode((yyvsp[(2) - (2)].node)); 3214 } 3215 break; 3216 3217 case 116: 3218 /* Line 1792 of yacc.c */ 3219 #line 400 "grammar.y" 3220 { 3221 (yyval.node) = makeBitwiseNotNode((yyvsp[(2) - (2)].node)); 3222 } 3223 break; 3224 3225 case 117: 3226 /* Line 1792 of yacc.c */ 3227 #line 401 "grammar.y" 3228 { 3229 (yyval.node) = makeLogicalNotNode((yyvsp[(2) - (2)].node)); 3230 } 3231 break; 3232 3233 case 123: 3234 /* Line 1792 of yacc.c */ 3235 #line 415 "grammar.y" 3236 { 3237 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpExp); 3238 } 3239 break; 3240 3241 case 125: 3242 /* Line 1792 of yacc.c */ 3243 #line 420 "grammar.y" 3244 { 3245 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpExp); 3246 } 3247 break; 3248 3249 case 127: 3250 /* Line 1792 of yacc.c */ 3251 #line 425 "grammar.y" 3252 { 3253 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); 3254 } 3255 break; 3256 3257 case 128: 3258 /* Line 1792 of yacc.c */ 3259 #line 426 "grammar.y" 3260 { 3261 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); 3262 } 3263 break; 3264 3265 case 129: 3266 /* Line 1792 of yacc.c */ 3267 #line 427 "grammar.y" 3268 { 3269 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); 3270 } 3271 break; 3272 3273 case 131: 3274 /* Line 1792 of yacc.c */ 3275 #line 433 "grammar.y" 3276 { 3277 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); 3278 } 3279 break; 3280 3281 case 132: 3282 /* Line 1792 of yacc.c */ 3283 #line 435 "grammar.y" 3284 { 3285 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); 3286 } 3287 break; 3288 3289 case 133: 3290 /* Line 1792 of yacc.c */ 3291 #line 437 "grammar.y" 3292 { 3293 (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); 3294 } 3295 break; 3296 3297 case 135: 3298 /* Line 1792 of yacc.c */ 3299 #line 442 "grammar.y" 3300 { 3301 (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); 3302 } 3303 break; 3304 3305 case 136: 3306 /* Line 1792 of yacc.c */ 3307 #line 443 "grammar.y" 3308 { 3309 (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); 3310 } 3311 break; 3312 3313 case 138: 3314 /* Line 1792 of yacc.c */ 3315 #line 449 "grammar.y" 3316 { 3317 (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); 3318 } 3319 break; 3320 3321 case 139: 3322 /* Line 1792 of yacc.c */ 3323 #line 451 "grammar.y" 3324 { 3325 (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); 3326 } 3327 break; 3328 3329 case 141: 3330 /* Line 1792 of yacc.c */ 3331 #line 456 "grammar.y" 3332 { 3333 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); 3334 } 3335 break; 3336 3337 case 142: 3338 /* Line 1792 of yacc.c */ 3339 #line 457 "grammar.y" 3340 { 3341 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); 3342 } 3343 break; 3344 3345 case 143: 3346 /* Line 1792 of yacc.c */ 3347 #line 458 "grammar.y" 3348 { 3349 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); 3350 } 3351 break; 3352 3353 case 145: 3354 /* Line 1792 of yacc.c */ 3355 #line 463 "grammar.y" 3356 { 3357 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); 3358 } 3359 break; 3360 3361 case 146: 3362 /* Line 1792 of yacc.c */ 3363 #line 464 "grammar.y" 3364 { 3365 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); 3366 } 3367 break; 3368 3369 case 147: 3370 /* Line 1792 of yacc.c */ 3371 #line 465 "grammar.y" 3372 { 3373 (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); 3374 } 3375 break; 3376 3377 case 149: 3378 /* Line 1792 of yacc.c */ 3379 #line 470 "grammar.y" 3380 { 3381 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); 3382 } 3383 break; 3384 3385 case 150: 3386 /* Line 1792 of yacc.c */ 3387 #line 471 "grammar.y" 3388 { 3389 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); 3390 } 3391 break; 3392 3393 case 151: 3394 /* Line 1792 of yacc.c */ 3395 #line 472 "grammar.y" 3396 { 3397 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); 3398 } 3399 break; 3400 3401 case 152: 3402 /* Line 1792 of yacc.c */ 3403 #line 473 "grammar.y" 3404 { 3405 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); 3406 } 3407 break; 3408 3409 case 153: 3410 /* Line 1792 of yacc.c */ 3411 #line 474 "grammar.y" 3412 { 3413 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); 3414 } 3415 break; 3416 3417 case 154: 3418 /* Line 1792 of yacc.c */ 3419 #line 475 "grammar.y" 3420 { 3421 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); 3422 } 3423 break; 3424 3425 case 156: 3426 /* Line 1792 of yacc.c */ 3427 #line 480 "grammar.y" 3428 { 3429 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); 3430 } 3431 break; 3432 3433 case 157: 3434 /* Line 1792 of yacc.c */ 3435 #line 481 "grammar.y" 3436 { 3437 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); 3438 } 3439 break; 3440 3441 case 158: 3442 /* Line 1792 of yacc.c */ 3443 #line 482 "grammar.y" 3444 { 3445 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); 3446 } 3447 break; 3448 3449 case 159: 3450 /* Line 1792 of yacc.c */ 3451 #line 483 "grammar.y" 3452 { 3453 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); 3454 } 3455 break; 3456 3457 case 160: 3458 /* Line 1792 of yacc.c */ 3459 #line 485 "grammar.y" 3460 { 3461 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); 3462 } 3463 break; 3464 3465 case 162: 3466 /* Line 1792 of yacc.c */ 3467 #line 490 "grammar.y" 3468 { 3469 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); 3470 } 3471 break; 3472 3473 case 163: 3474 /* Line 1792 of yacc.c */ 3475 #line 491 "grammar.y" 3476 { 3477 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); 3478 } 3479 break; 3480 3481 case 164: 3482 /* Line 1792 of yacc.c */ 3483 #line 492 "grammar.y" 3484 { 3485 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); 3486 } 3487 break; 3488 3489 case 165: 3490 /* Line 1792 of yacc.c */ 3491 #line 493 "grammar.y" 3492 { 3493 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); 3494 } 3495 break; 3496 3497 case 166: 3498 /* Line 1792 of yacc.c */ 3499 #line 495 "grammar.y" 3500 { 3501 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); 3502 } 3503 break; 3504 3505 case 167: 3506 /* Line 1792 of yacc.c */ 3507 #line 496 "grammar.y" 3508 { 3509 (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); 3510 } 3511 break; 3512 3513 case 169: 3514 /* Line 1792 of yacc.c */ 3515 #line 501 "grammar.y" 3516 { 3517 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); 3518 } 3519 break; 3520 3521 case 170: 3522 /* Line 1792 of yacc.c */ 3523 #line 502 "grammar.y" 3524 { 3525 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); 3526 } 3527 break; 3528 3529 case 171: 3530 /* Line 1792 of yacc.c */ 3531 #line 503 "grammar.y" 3532 { 3533 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); 3534 } 3535 break; 3536 3537 case 172: 3538 /* Line 1792 of yacc.c */ 3539 #line 504 "grammar.y" 3540 { 3541 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node)); 3542 } 3543 break; 3544 3545 case 174: 3546 /* Line 1792 of yacc.c */ 3547 #line 510 "grammar.y" 3548 { 3549 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); 3550 } 3551 break; 3552 3553 case 175: 3554 /* Line 1792 of yacc.c */ 3555 #line 512 "grammar.y" 3556 { 3557 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); 3558 } 3559 break; 3560 3561 case 176: 3562 /* Line 1792 of yacc.c */ 3563 #line 514 "grammar.y" 3564 { 3565 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); 3566 } 3567 break; 3568 3569 case 177: 3570 /* Line 1792 of yacc.c */ 3571 #line 516 "grammar.y" 3572 { 3573 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node)); 3574 } 3575 break; 3576 3577 case 179: 3578 /* Line 1792 of yacc.c */ 3579 #line 522 "grammar.y" 3580 { 3581 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); 3582 } 3583 break; 3584 3585 case 180: 3586 /* Line 1792 of yacc.c */ 3587 #line 523 "grammar.y" 3588 { 3589 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); 3590 } 3591 break; 3592 3593 case 181: 3594 /* Line 1792 of yacc.c */ 3595 #line 525 "grammar.y" 3596 { 3597 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); 3598 } 3599 break; 3600 3601 case 182: 3602 /* Line 1792 of yacc.c */ 3603 #line 527 "grammar.y" 3604 { 3605 (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node)); 3606 } 3607 break; 3608 3609 case 184: 3610 /* Line 1792 of yacc.c */ 3611 #line 532 "grammar.y" 3612 { 3613 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); 3614 } 3615 break; 3616 3617 case 186: 3618 /* Line 1792 of yacc.c */ 3619 #line 538 "grammar.y" 3620 { 3621 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); 3622 } 3623 break; 3624 3625 case 188: 3626 /* Line 1792 of yacc.c */ 3627 #line 543 "grammar.y" 3628 { 3629 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); 3630 } 3631 break; 3632 3633 case 190: 3634 /* Line 1792 of yacc.c */ 3635 #line 548 "grammar.y" 3636 { 3637 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); 3638 } 3639 break; 3640 3641 case 192: 3642 /* Line 1792 of yacc.c */ 3643 #line 554 "grammar.y" 3644 { 3645 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); 3646 } 3647 break; 3648 3649 case 194: 3650 /* Line 1792 of yacc.c */ 3651 #line 560 "grammar.y" 3652 { 3653 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); 3654 } 3655 break; 3656 3657 case 196: 3658 /* Line 1792 of yacc.c */ 3659 #line 565 "grammar.y" 3660 { 3661 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); 3662 } 3663 break; 3664 3665 case 198: 3666 /* Line 1792 of yacc.c */ 3667 #line 571 "grammar.y" 3668 { 3669 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); 3670 } 3671 break; 3672 3673 case 200: 3674 /* Line 1792 of yacc.c */ 3675 #line 577 "grammar.y" 3676 { 3677 (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); 3678 } 3679 break; 3680 3681 case 202: 3682 /* Line 1792 of yacc.c */ 3683 #line 582 "grammar.y" 3684 { 3685 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); 3686 } 3687 break; 3688 3689 case 204: 3690 /* Line 1792 of yacc.c */ 3691 #line 588 "grammar.y" 3692 { 3693 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); 3694 } 3695 break; 3696 3697 case 206: 3698 /* Line 1792 of yacc.c */ 3699 #line 594 "grammar.y" 3700 { 3701 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); 3702 } 3703 break; 3704 3705 case 208: 3706 /* Line 1792 of yacc.c */ 3707 #line 599 "grammar.y" 3708 { 3709 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); 3710 } 3711 break; 3712 3713 case 210: 3714 /* Line 1792 of yacc.c */ 3715 #line 605 "grammar.y" 3716 { 3717 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); 3718 } 3719 break; 3720 3721 case 212: 3722 /* Line 1792 of yacc.c */ 3723 #line 610 "grammar.y" 3724 { 3725 (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); 3726 } 3727 break; 3728 3729 case 214: 3730 /* Line 1792 of yacc.c */ 3731 #line 616 "grammar.y" 3732 { 3733 (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 3734 } 3735 break; 3736 3737 case 216: 3738 /* Line 1792 of yacc.c */ 3739 #line 622 "grammar.y" 3740 { 3741 (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 3742 } 3743 break; 3744 3745 case 218: 3746 /* Line 1792 of yacc.c */ 3747 #line 628 "grammar.y" 3748 { 3749 (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); 3750 } 3751 break; 3752 3753 case 220: 3754 /* Line 1792 of yacc.c */ 3755 #line 634 "grammar.y" 3756 { 3757 (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); 3758 } 3759 break; 3760 3761 case 222: 3762 /* Line 1792 of yacc.c */ 3763 #line 640 "grammar.y" 3764 { 3765 (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); 3766 } 3767 break; 3768 3769 case 224: 3770 /* Line 1792 of yacc.c */ 3771 #line 646 "grammar.y" 3772 { 3773 (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); 3774 } 3775 break; 3776 3777 case 225: 3778 /* Line 1792 of yacc.c */ 3779 #line 650 "grammar.y" 3780 { 3781 (yyval.op) = OpEqual; 3782 } 3783 break; 3784 3785 case 226: 3786 /* Line 1792 of yacc.c */ 3787 #line 651 "grammar.y" 3788 { 3789 (yyval.op) = OpPlusEq; 3790 } 3791 break; 3792 3793 case 227: 3794 /* Line 1792 of yacc.c */ 3795 #line 652 "grammar.y" 3796 { 3797 (yyval.op) = OpMinusEq; 3798 } 3799 break; 3800 3801 case 228: 3802 /* Line 1792 of yacc.c */ 3803 #line 653 "grammar.y" 3804 { 3805 (yyval.op) = OpMultEq; 3806 } 3807 break; 3808 3809 case 229: 3810 /* Line 1792 of yacc.c */ 3811 #line 654 "grammar.y" 3812 { 3813 (yyval.op) = OpDivEq; 3814 } 3815 break; 3816 3817 case 230: 3818 /* Line 1792 of yacc.c */ 3819 #line 655 "grammar.y" 3820 { 3821 (yyval.op) = OpExpEq; 3822 } 3823 break; 3824 3825 case 231: 3826 /* Line 1792 of yacc.c */ 3827 #line 656 "grammar.y" 3828 { 3829 (yyval.op) = OpLShift; 3830 } 3831 break; 3832 3833 case 232: 3834 /* Line 1792 of yacc.c */ 3835 #line 657 "grammar.y" 3836 { 3837 (yyval.op) = OpRShift; 3838 } 3839 break; 3840 3841 case 233: 3842 /* Line 1792 of yacc.c */ 3843 #line 658 "grammar.y" 3844 { 3845 (yyval.op) = OpURShift; 3846 } 3847 break; 3848 3849 case 234: 3850 /* Line 1792 of yacc.c */ 3851 #line 659 "grammar.y" 3852 { 3853 (yyval.op) = OpAndEq; 3854 } 3855 break; 3856 3857 case 235: 3858 /* Line 1792 of yacc.c */ 3859 #line 660 "grammar.y" 3860 { 3861 (yyval.op) = OpXOrEq; 3862 } 3863 break; 3864 3865 case 236: 3866 /* Line 1792 of yacc.c */ 3867 #line 661 "grammar.y" 3868 { 3869 (yyval.op) = OpOrEq; 3870 } 3871 break; 3872 3873 case 237: 3874 /* Line 1792 of yacc.c */ 3875 #line 662 "grammar.y" 3876 { 3877 (yyval.op) = OpModEq; 3878 } 3879 break; 3880 3881 case 239: 3882 /* Line 1792 of yacc.c */ 3883 #line 667 "grammar.y" 3884 { 3885 (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3886 } 3887 break; 3888 3889 case 241: 3890 /* Line 1792 of yacc.c */ 3891 #line 672 "grammar.y" 3892 { 3893 (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3894 } 3895 break; 3896 3897 case 243: 3898 /* Line 1792 of yacc.c */ 3899 #line 677 "grammar.y" 3900 { 3901 (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 3902 } 3903 break; 3904 3905 case 261: 3906 /* Line 1792 of yacc.c */ 3907 #line 701 "grammar.y" 3908 { 3909 (yyval.stat) = new BlockNode(nullptr); 3910 DBG((yyval.stat), (yylsp[(2) - (2)]), (yylsp[(2) - (2)])); 3911 } 3912 break; 3913 3914 case 262: 3915 /* Line 1792 of yacc.c */ 3916 #line 702 "grammar.y" 3917 { 3918 (yyval.stat) = new BlockNode((yyvsp[(2) - (3)].srcs)); 3919 DBG((yyval.stat), (yylsp[(3) - (3)]), (yylsp[(3) - (3)])); 3920 } 3921 break; 3922 3923 case 263: 3924 /* Line 1792 of yacc.c */ 3925 #line 706 "grammar.y" 3926 { 3927 (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); 3928 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 3929 } 3930 break; 3931 3932 case 264: 3933 /* Line 1792 of yacc.c */ 3934 #line 707 "grammar.y" 3935 { 3936 (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); 3937 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 3938 AUTO_SEMICOLON; 3939 } 3940 break; 3941 3942 case 265: 3943 /* Line 1792 of yacc.c */ 3944 #line 711 "grammar.y" 3945 { 3946 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); 3947 } 3948 break; 3949 3950 case 266: 3951 /* Line 1792 of yacc.c */ 3952 #line 713 "grammar.y" 3953 { 3954 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); 3955 } 3956 break; 3957 3958 case 267: 3959 /* Line 1792 of yacc.c */ 3960 #line 717 "grammar.y" 3961 { 3962 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); 3963 } 3964 break; 3965 3966 case 268: 3967 /* Line 1792 of yacc.c */ 3968 #line 719 "grammar.y" 3969 { 3970 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); 3971 } 3972 break; 3973 3974 case 269: 3975 /* Line 1792 of yacc.c */ 3976 #line 723 "grammar.y" 3977 { 3978 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), nullptr, VarDeclNode::Variable); 3979 } 3980 break; 3981 3982 case 270: 3983 /* Line 1792 of yacc.c */ 3984 #line 724 "grammar.y" 3985 { 3986 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); 3987 } 3988 break; 3989 3990 case 271: 3991 /* Line 1792 of yacc.c */ 3992 #line 728 "grammar.y" 3993 { 3994 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), nullptr, VarDeclNode::Variable); 3995 } 3996 break; 3997 3998 case 272: 3999 /* Line 1792 of yacc.c */ 4000 #line 729 "grammar.y" 4001 { 4002 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); 4003 } 4004 break; 4005 4006 case 273: 4007 /* Line 1792 of yacc.c */ 4008 #line 733 "grammar.y" 4009 { 4010 (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); 4011 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4012 } 4013 break; 4014 4015 case 274: 4016 /* Line 1792 of yacc.c */ 4017 #line 735 "grammar.y" 4018 { 4019 (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); 4020 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 4021 AUTO_SEMICOLON; 4022 } 4023 break; 4024 4025 case 275: 4026 /* Line 1792 of yacc.c */ 4027 #line 739 "grammar.y" 4028 { 4029 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); 4030 } 4031 break; 4032 4033 case 276: 4034 /* Line 1792 of yacc.c */ 4035 #line 741 "grammar.y" 4036 { 4037 (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); 4038 } 4039 break; 4040 4041 case 277: 4042 /* Line 1792 of yacc.c */ 4043 #line 745 "grammar.y" 4044 { 4045 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), nullptr, VarDeclNode::Constant); 4046 } 4047 break; 4048 4049 case 278: 4050 /* Line 1792 of yacc.c */ 4051 #line 746 "grammar.y" 4052 { 4053 (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Constant); 4054 } 4055 break; 4056 4057 case 279: 4058 /* Line 1792 of yacc.c */ 4059 #line 750 "grammar.y" 4060 { 4061 (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); 4062 } 4063 break; 4064 4065 case 280: 4066 /* Line 1792 of yacc.c */ 4067 #line 754 "grammar.y" 4068 { 4069 (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); 4070 } 4071 break; 4072 4073 case 281: 4074 /* Line 1792 of yacc.c */ 4075 #line 758 "grammar.y" 4076 { 4077 (yyval.stat) = new EmptyStatementNode(); 4078 } 4079 break; 4080 4081 case 282: 4082 /* Line 1792 of yacc.c */ 4083 #line 762 "grammar.y" 4084 { 4085 (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); 4086 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4087 } 4088 break; 4089 4090 case 283: 4091 /* Line 1792 of yacc.c */ 4092 #line 763 "grammar.y" 4093 { 4094 (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); 4095 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); 4096 AUTO_SEMICOLON; 4097 } 4098 break; 4099 4100 case 284: 4101 /* Line 1792 of yacc.c */ 4102 #line 768 "grammar.y" 4103 { 4104 (yyval.stat) = makeIfNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat), nullptr); 4105 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); 4106 } 4107 break; 4108 4109 case 285: 4110 /* Line 1792 of yacc.c */ 4111 #line 770 "grammar.y" 4112 { 4113 (yyval.stat) = makeIfNode((yyvsp[(3) - (7)].node), (yyvsp[(5) - (7)].stat), (yyvsp[(7) - (7)].stat)); 4114 DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(4) - (7)])); 4115 } 4116 break; 4117 4118 case 286: 4119 /* Line 1792 of yacc.c */ 4120 #line 774 "grammar.y" 4121 { 4122 (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); 4123 DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)])); 4124 } 4125 break; 4126 4127 case 287: 4128 /* Line 1792 of yacc.c */ 4129 #line 775 "grammar.y" 4130 { 4131 (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); 4132 DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)])); 4133 AUTO_SEMICOLON; 4134 } 4135 break; 4136 4137 case 288: 4138 /* Line 1792 of yacc.c */ 4139 #line 776 "grammar.y" 4140 { 4141 (yyval.stat) = new WhileNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); 4142 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); 4143 } 4144 break; 4145 4146 case 289: 4147 /* Line 1792 of yacc.c */ 4148 #line 778 "grammar.y" 4149 { 4150 (yyval.stat) = new ForNode((yyvsp[(3) - (9)].node), (yyvsp[(5) - (9)].node), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); 4151 DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); 4152 } 4153 break; 4154 4155 case 290: 4156 /* Line 1792 of yacc.c */ 4157 #line 780 "grammar.y" 4158 { 4159 (yyval.stat) = new ForNode((yyvsp[(4) - (10)].vlist), (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].node), (yyvsp[(10) - (10)].stat)); 4160 DBG((yyval.stat), (yylsp[(1) - (10)]), (yylsp[(9) - (10)])); 4161 } 4162 break; 4163 4164 case 291: 4165 /* Line 1792 of yacc.c */ 4166 #line 782 "grammar.y" 4167 { 4168 Node *n = (yyvsp[(3) - (7)].node)->nodeInsideAllParens(); 4169 if (!n->isLocation()) { 4170 YYABORT; 4171 } 4172 (yyval.stat) = new ForInNode(n, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].stat)); 4173 DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(6) - (7)])); 4174 } 4175 break; 4176 4177 case 292: 4178 /* Line 1792 of yacc.c */ 4179 #line 790 "grammar.y" 4180 { 4181 (yyval.stat) = new ForInNode(*(yyvsp[(4) - (8)].ident), nullptr, (yyvsp[(6) - (8)].node), (yyvsp[(8) - (8)].stat)); 4182 DBG((yyval.stat), (yylsp[(1) - (8)]), (yylsp[(7) - (8)])); 4183 } 4184 break; 4185 4186 case 293: 4187 /* Line 1792 of yacc.c */ 4188 #line 792 "grammar.y" 4189 { 4190 (yyval.stat) = new ForInNode(*(yyvsp[(4) - (9)].ident), (yyvsp[(5) - (9)].init), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); 4191 DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); 4192 } 4193 break; 4194 4195 case 294: 4196 /* Line 1792 of yacc.c */ 4197 #line 796 "grammar.y" 4198 { 4199 (yyval.node) = nullptr; 4200 } 4201 break; 4202 4203 case 296: 4204 /* Line 1792 of yacc.c */ 4205 #line 801 "grammar.y" 4206 { 4207 (yyval.node) = nullptr; 4208 } 4209 break; 4210 4211 case 298: 4212 /* Line 1792 of yacc.c */ 4213 #line 806 "grammar.y" 4214 { 4215 (yyval.stat) = new ContinueNode(); 4216 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4217 } 4218 break; 4219 4220 case 299: 4221 /* Line 1792 of yacc.c */ 4222 #line 807 "grammar.y" 4223 { 4224 (yyval.stat) = new ContinueNode(); 4225 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); 4226 AUTO_SEMICOLON; 4227 } 4228 break; 4229 4230 case 300: 4231 /* Line 1792 of yacc.c */ 4232 #line 808 "grammar.y" 4233 { 4234 (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); 4235 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4236 } 4237 break; 4238 4239 case 301: 4240 /* Line 1792 of yacc.c */ 4241 #line 809 "grammar.y" 4242 { 4243 (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); 4244 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 4245 AUTO_SEMICOLON; 4246 } 4247 break; 4248 4249 case 302: 4250 /* Line 1792 of yacc.c */ 4251 #line 813 "grammar.y" 4252 { 4253 (yyval.stat) = new BreakNode(); 4254 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4255 } 4256 break; 4257 4258 case 303: 4259 /* Line 1792 of yacc.c */ 4260 #line 814 "grammar.y" 4261 { 4262 (yyval.stat) = new BreakNode(); 4263 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); 4264 AUTO_SEMICOLON; 4265 } 4266 break; 4267 4268 case 304: 4269 /* Line 1792 of yacc.c */ 4270 #line 815 "grammar.y" 4271 { 4272 (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); 4273 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4274 } 4275 break; 4276 4277 case 305: 4278 /* Line 1792 of yacc.c */ 4279 #line 816 "grammar.y" 4280 { 4281 (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); 4282 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 4283 AUTO_SEMICOLON; 4284 } 4285 break; 4286 4287 case 306: 4288 /* Line 1792 of yacc.c */ 4289 #line 820 "grammar.y" 4290 { 4291 (yyval.stat) = new ReturnNode(nullptr); 4292 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4293 } 4294 break; 4295 4296 case 307: 4297 /* Line 1792 of yacc.c */ 4298 #line 821 "grammar.y" 4299 { 4300 (yyval.stat) = new ReturnNode(nullptr); 4301 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); 4302 AUTO_SEMICOLON; 4303 } 4304 break; 4305 4306 case 308: 4307 /* Line 1792 of yacc.c */ 4308 #line 822 "grammar.y" 4309 { 4310 (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); 4311 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4312 } 4313 break; 4314 4315 case 309: 4316 /* Line 1792 of yacc.c */ 4317 #line 823 "grammar.y" 4318 { 4319 (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); 4320 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 4321 AUTO_SEMICOLON; 4322 } 4323 break; 4324 4325 case 310: 4326 /* Line 1792 of yacc.c */ 4327 #line 827 "grammar.y" 4328 { 4329 (yyval.stat) = new WithNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); 4330 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); 4331 } 4332 break; 4333 4334 case 311: 4335 /* Line 1792 of yacc.c */ 4336 #line 831 "grammar.y" 4337 { 4338 (yyval.stat) = new SwitchNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].cblk)); 4339 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); 4340 } 4341 break; 4342 4343 case 312: 4344 /* Line 1792 of yacc.c */ 4345 #line 835 "grammar.y" 4346 { 4347 (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (3)].clist), nullptr, nullptr); 4348 } 4349 break; 4350 4351 case 313: 4352 /* Line 1792 of yacc.c */ 4353 #line 837 "grammar.y" 4354 { 4355 (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (5)].clist), (yyvsp[(3) - (5)].ccl), (yyvsp[(4) - (5)].clist)); 4356 } 4357 break; 4358 4359 case 314: 4360 /* Line 1792 of yacc.c */ 4361 #line 841 "grammar.y" 4362 { 4363 (yyval.clist) = nullptr; 4364 } 4365 break; 4366 4367 case 316: 4368 /* Line 1792 of yacc.c */ 4369 #line 846 "grammar.y" 4370 { 4371 (yyval.clist) = new ClauseListNode((yyvsp[(1) - (1)].ccl)); 4372 } 4373 break; 4374 4375 case 317: 4376 /* Line 1792 of yacc.c */ 4377 #line 847 "grammar.y" 4378 { 4379 (yyval.clist) = new ClauseListNode((yyvsp[(1) - (2)].clist), (yyvsp[(2) - (2)].ccl)); 4380 } 4381 break; 4382 4383 case 318: 4384 /* Line 1792 of yacc.c */ 4385 #line 851 "grammar.y" 4386 { 4387 (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (3)].node)); 4388 } 4389 break; 4390 4391 case 319: 4392 /* Line 1792 of yacc.c */ 4393 #line 852 "grammar.y" 4394 { 4395 (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].srcs)); 4396 } 4397 break; 4398 4399 case 320: 4400 /* Line 1792 of yacc.c */ 4401 #line 856 "grammar.y" 4402 { 4403 (yyval.ccl) = new CaseClauseNode(nullptr); 4404 } 4405 break; 4406 4407 case 321: 4408 /* Line 1792 of yacc.c */ 4409 #line 857 "grammar.y" 4410 { 4411 (yyval.ccl) = new CaseClauseNode(nullptr, (yyvsp[(3) - (3)].srcs)); 4412 } 4413 break; 4414 4415 case 322: 4416 /* Line 1792 of yacc.c */ 4417 #line 861 "grammar.y" 4418 { 4419 (yyval.stat) = makeLabelNode(*(yyvsp[(1) - (3)].ident), (yyvsp[(3) - (3)].stat)); 4420 } 4421 break; 4422 4423 case 323: 4424 /* Line 1792 of yacc.c */ 4425 #line 865 "grammar.y" 4426 { 4427 (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); 4428 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4429 } 4430 break; 4431 4432 case 324: 4433 /* Line 1792 of yacc.c */ 4434 #line 866 "grammar.y" 4435 { 4436 (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); 4437 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); 4438 AUTO_SEMICOLON; 4439 } 4440 break; 4441 4442 case 325: 4443 /* Line 1792 of yacc.c */ 4444 #line 870 "grammar.y" 4445 { 4446 (yyval.stat) = new TryNode((yyvsp[(2) - (4)].stat), CommonIdentifiers::shared()->nullIdentifier, nullptr, (yyvsp[(4) - (4)].stat)); 4447 DBG((yyval.stat), (yylsp[(1) - (4)]), (yylsp[(2) - (4)])); 4448 } 4449 break; 4450 4451 case 326: 4452 /* Line 1792 of yacc.c */ 4453 #line 871 "grammar.y" 4454 { 4455 (yyval.stat) = new TryNode((yyvsp[(2) - (7)].stat), *(yyvsp[(5) - (7)].ident), (yyvsp[(7) - (7)].stat), nullptr); 4456 DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(2) - (7)])); 4457 } 4458 break; 4459 4460 case 327: 4461 /* Line 1792 of yacc.c */ 4462 #line 873 "grammar.y" 4463 { 4464 (yyval.stat) = new TryNode((yyvsp[(2) - (9)].stat), *(yyvsp[(5) - (9)].ident), (yyvsp[(7) - (9)].stat), (yyvsp[(9) - (9)].stat)); 4465 DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(2) - (9)])); 4466 } 4467 break; 4468 4469 case 328: 4470 /* Line 1792 of yacc.c */ 4471 #line 877 "grammar.y" 4472 { 4473 (yyval.stat) = new EmptyStatementNode(); 4474 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4475 } 4476 break; 4477 4478 case 329: 4479 /* Line 1792 of yacc.c */ 4480 #line 878 "grammar.y" 4481 { 4482 (yyval.stat) = new EmptyStatementNode(); 4483 DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); 4484 AUTO_SEMICOLON; 4485 } 4486 break; 4487 4488 case 330: 4489 /* Line 1792 of yacc.c */ 4490 #line 882 "grammar.y" 4491 { 4492 (yyval.pkgn) = new PackageNameNode(*(yyvsp[(1) - (1)].ident)); 4493 } 4494 break; 4495 4496 case 331: 4497 /* Line 1792 of yacc.c */ 4498 #line 883 "grammar.y" 4499 { 4500 (yyval.pkgn) = new PackageNameNode((yyvsp[(1) - (3)].pkgn), *(yyvsp[(3) - (3)].ident)); 4501 } 4502 break; 4503 4504 case 332: 4505 /* Line 1792 of yacc.c */ 4506 #line 887 "grammar.y" 4507 { 4508 (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, nullptr); 4509 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); 4510 } 4511 break; 4512 4513 case 333: 4514 /* Line 1792 of yacc.c */ 4515 #line 889 "grammar.y" 4516 { 4517 (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, nullptr); 4518 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; 4519 } 4520 break; 4521 4522 case 334: 4523 /* Line 1792 of yacc.c */ 4524 #line 891 "grammar.y" 4525 { 4526 (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, nullptr); 4527 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4528 } 4529 break; 4530 4531 case 335: 4532 /* Line 1792 of yacc.c */ 4533 #line 893 "grammar.y" 4534 { 4535 (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, nullptr); 4536 DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); AUTO_SEMICOLON; 4537 } 4538 break; 4539 4540 case 336: 4541 /* Line 1792 of yacc.c */ 4542 #line 895 "grammar.y" 4543 { 4544 (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident)); 4545 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); 4546 } 4547 break; 4548 4549 case 337: 4550 /* Line 1792 of yacc.c */ 4551 #line 897 "grammar.y" 4552 { 4553 (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident)); 4554 DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; 4555 } 4556 break; 4557 4558 case 338: 4559 /* Line 1792 of yacc.c */ 4560 #line 902 "grammar.y" 4561 { 4562 inFuncDecl(); 4563 } 4564 break; 4565 4566 case 339: 4567 /* Line 1792 of yacc.c */ 4568 #line 902 "grammar.y" 4569 { 4570 (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); 4571 } 4572 break; 4573 4574 case 340: 4575 /* Line 1792 of yacc.c */ 4576 #line 903 "grammar.y" 4577 { 4578 inFuncDecl(); 4579 } 4580 break; 4581 4582 case 341: 4583 /* Line 1792 of yacc.c */ 4584 #line 904 "grammar.y" 4585 { 4586 (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)); 4587 } 4588 break; 4589 4590 case 342: 4591 /* Line 1792 of yacc.c */ 4592 #line 908 "grammar.y" 4593 { 4594 inFuncExpr(); 4595 } 4596 break; 4597 4598 case 343: 4599 /* Line 1792 of yacc.c */ 4600 #line 908 "grammar.y" 4601 { 4602 (yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(5) - (5)].body)); 4603 } 4604 break; 4605 4606 case 344: 4607 /* Line 1792 of yacc.c */ 4608 #line 911 "grammar.y" 4609 { 4610 inFuncExpr(); 4611 } 4612 break; 4613 4614 case 345: 4615 /* Line 1792 of yacc.c */ 4616 #line 911 "grammar.y" 4617 { 4618 (yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(6) - (6)].body), (yyvsp[(3) - (6)].param)); 4619 } 4620 break; 4621 4622 case 346: 4623 /* Line 1792 of yacc.c */ 4624 #line 914 "grammar.y" 4625 { 4626 inFuncExpr(); 4627 } 4628 break; 4629 4630 case 347: 4631 /* Line 1792 of yacc.c */ 4632 #line 914 "grammar.y" 4633 { 4634 (yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); 4635 } 4636 break; 4637 4638 case 348: 4639 /* Line 1792 of yacc.c */ 4640 #line 915 "grammar.y" 4641 { 4642 inFuncExpr(); 4643 } 4644 break; 4645 4646 case 349: 4647 /* Line 1792 of yacc.c */ 4648 #line 915 "grammar.y" 4649 { 4650 (yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(7) - (7)].body), (yyvsp[(4) - (7)].param)); 4651 } 4652 break; 4653 4654 case 350: 4655 /* Line 1792 of yacc.c */ 4656 #line 921 "grammar.y" 4657 { 4658 (yyval.param) = new ParameterNode(*(yyvsp[(1) - (1)].ident)); 4659 } 4660 break; 4661 4662 case 351: 4663 /* Line 1792 of yacc.c */ 4664 #line 922 "grammar.y" 4665 { 4666 (yyval.param) = new ParameterNode((yyvsp[(1) - (3)].param), *(yyvsp[(3) - (3)].ident)); 4667 } 4668 break; 4669 4670 case 352: 4671 /* Line 1792 of yacc.c */ 4672 #line 926 "grammar.y" 4673 { 4674 (yyval.body) = new FunctionBodyNode(nullptr); 4675 DBG((yyval.body), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); 4676 } 4677 break; 4678 4679 case 353: 4680 /* Line 1792 of yacc.c */ 4681 #line 927 "grammar.y" 4682 { 4683 (yyval.body) = new FunctionBodyNode((yyvsp[(2) - (3)].srcs)); 4684 DBG((yyval.body), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); 4685 } 4686 break; 4687 4688 case 354: 4689 /* Line 1792 of yacc.c */ 4690 #line 931 "grammar.y" 4691 { 4692 parser().didFinishParsing(new ProgramNode(nullptr)); 4693 } 4694 break; 4695 4696 case 355: 4697 /* Line 1792 of yacc.c */ 4698 #line 932 "grammar.y" 4699 { 4700 parser().didFinishParsing(new ProgramNode((yyvsp[(1) - (1)].srcs))); 4701 } 4702 break; 4703 4704 case 356: 4705 /* Line 1792 of yacc.c */ 4706 #line 936 "grammar.y" 4707 { 4708 (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (1)].stat)); 4709 } 4710 break; 4711 4712 case 357: 4713 /* Line 1792 of yacc.c */ 4714 #line 937 "grammar.y" 4715 { 4716 (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (2)].srcs), (yyvsp[(2) - (2)].stat)); 4717 } 4718 break; 4719 4720 case 358: 4721 /* Line 1792 of yacc.c */ 4722 #line 941 "grammar.y" 4723 { 4724 (yyval.stat) = (yyvsp[(1) - (1)].func); 4725 } 4726 break; 4727 4728 case 359: 4729 /* Line 1792 of yacc.c */ 4730 #line 942 "grammar.y" 4731 { 4732 (yyval.stat) = (yyvsp[(1) - (1)].stat); 4733 } 4734 break; 4735 4736 /* Line 1792 of yacc.c */ 4737 #line 4178 "grammar.cpp" 4738 default: break; 4739 } 4740 /* User semantic actions sometimes alter yychar, and that requires 4741 that yytoken be updated with the new translation. We take the 4742 approach of translating immediately before every use of yytoken. 4743 One alternative is translating here after every semantic action, 4744 but that translation would be missed if the semantic action invokes 4745 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 4746 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 4747 incorrect destructor might then be invoked immediately. In the 4748 case of YYERROR or YYBACKUP, subsequent parser actions might lead 4749 to an incorrect destructor call or verbose syntax error message 4750 before the lookahead is translated. */ 4751 YY_SYMBOL_PRINT("-> $$ =", yyr1[yyn], &yyval, &yyloc); 4752 4753 YYPOPSTACK(yylen); 4754 yylen = 0; 4755 YY_STACK_PRINT(yyss, yyssp); 4756 4757 *++yyvsp = yyval; 4758 *++yylsp = yyloc; 4759 4760 /* Now `shift' the result of the reduction. Determine what state 4761 that goes to, based on the state we popped back to and the rule 4762 number reduced by. */ 4763 4764 yyn = yyr1[yyn]; 4765 4766 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 4767 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) { 4768 yystate = yytable[yystate]; 4769 } else { 4770 yystate = yydefgoto[yyn - YYNTOKENS]; 4771 } 4772 4773 goto yynewstate; 4774 4775 /*------------------------------------. 4776 | yyerrlab -- here on detecting error | 4777 `------------------------------------*/ 4778 yyerrlab: 4779 /* Make sure we have latest lookahead translation. See comments at 4780 user semantic actions for why this is necessary. */ 4781 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE(yychar); 4782 4783 /* If not already recovering from an error, report this error. */ 4784 if (!yyerrstatus) { 4785 ++yynerrs; 4786 #if ! YYERROR_VERBOSE 4787 yyerror(YY_("syntax error")); 4788 #else 4789 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 4790 yyssp, yytoken) 4791 { 4792 char const *yymsgp = YY_("syntax error"); 4793 int yysyntax_error_status; 4794 yysyntax_error_status = YYSYNTAX_ERROR; 4795 if (yysyntax_error_status == 0) { 4796 yymsgp = yymsg; 4797 } else if (yysyntax_error_status == 1) { 4798 if (yymsg != yymsgbuf) { 4799 YYSTACK_FREE(yymsg); 4800 } 4801 yymsg = (char *) YYSTACK_ALLOC(yymsg_alloc); 4802 if (!yymsg) { 4803 yymsg = yymsgbuf; 4804 yymsg_alloc = sizeof yymsgbuf; 4805 yysyntax_error_status = 2; 4806 } else { 4807 yysyntax_error_status = YYSYNTAX_ERROR; 4808 yymsgp = yymsg; 4809 } 4810 } 4811 yyerror(yymsgp); 4812 if (yysyntax_error_status == 2) { 4813 goto yyexhaustedlab; 4814 } 4815 } 4816 # undef YYSYNTAX_ERROR 4817 #endif 4818 } 4819 4820 yyerror_range[1] = yylloc; 4821 4822 if (yyerrstatus == 3) { 4823 /* If just tried and failed to reuse lookahead token after an 4824 error, discard it. */ 4825 4826 if (yychar <= YYEOF) { 4827 /* Return failure if at end of input. */ 4828 if (yychar == YYEOF) { 4829 YYABORT; 4830 } 4831 } else { 4832 yydestruct("Error: discarding", 4833 yytoken, &yylval, &yylloc); 4834 yychar = YYEMPTY; 4835 } 4836 } 4837 4838 /* Else will try to reuse lookahead token after shifting the error 4839 token. */ 4840 goto yyerrlab1; 4841 4842 /*---------------------------------------------------. 4843 | yyerrorlab -- error raised explicitly by YYERROR. | 4844 `---------------------------------------------------*/ 4845 yyerrorlab: 4846 4847 /* Pacify compilers like GCC when the user code never invokes 4848 YYERROR and the label yyerrorlab therefore never appears in user 4849 code. */ 4850 if (/*CONSTCOND*/ 0) { 4851 goto yyerrorlab; 4852 } 4853 4854 yyerror_range[1] = yylsp[1 - yylen]; 4855 /* Do not reclaim the symbols of the rule which action triggered 4856 this YYERROR. */ 4857 YYPOPSTACK(yylen); 4858 yylen = 0; 4859 YY_STACK_PRINT(yyss, yyssp); 4860 yystate = *yyssp; 4861 goto yyerrlab1; 4862 4863 /*-------------------------------------------------------------. 4864 | yyerrlab1 -- common code for both syntax error and YYERROR. | 4865 `-------------------------------------------------------------*/ 4866 yyerrlab1: 4867 yyerrstatus = 3; /* Each real token shifted decrements this. */ 4868 4869 for (;;) { 4870 yyn = yypact[yystate]; 4871 if (!yypact_value_is_default(yyn)) { 4872 yyn += YYTERROR; 4873 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { 4874 yyn = yytable[yyn]; 4875 if (0 < yyn) { 4876 break; 4877 } 4878 } 4879 } 4880 4881 /* Pop the current state because it cannot handle the error token. */ 4882 if (yyssp == yyss) { 4883 YYABORT; 4884 } 4885 4886 yyerror_range[1] = *yylsp; 4887 yydestruct("Error: popping", 4888 yystos[yystate], yyvsp, yylsp); 4889 YYPOPSTACK(1); 4890 yystate = *yyssp; 4891 YY_STACK_PRINT(yyss, yyssp); 4892 } 4893 4894 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 4895 *++yyvsp = yylval; 4896 YY_IGNORE_MAYBE_UNINITIALIZED_END 4897 4898 yyerror_range[2] = yylloc; 4899 /* Using YYLLOC is tempting, but would change the location of 4900 the lookahead. YYLOC is available though. */ 4901 YYLLOC_DEFAULT(yyloc, yyerror_range, 2); 4902 *++yylsp = yyloc; 4903 4904 /* Shift the error token. */ 4905 YY_SYMBOL_PRINT("Shifting", yystos[yyn], yyvsp, yylsp); 4906 4907 yystate = yyn; 4908 goto yynewstate; 4909 4910 /*-------------------------------------. 4911 | yyacceptlab -- YYACCEPT comes here. | 4912 `-------------------------------------*/ 4913 yyacceptlab: 4914 yyresult = 0; 4915 goto yyreturn; 4916 4917 /*-----------------------------------. 4918 | yyabortlab -- YYABORT comes here. | 4919 `-----------------------------------*/ 4920 yyabortlab: 4921 yyresult = 1; 4922 goto yyreturn; 4923 4924 #if !defined yyoverflow || YYERROR_VERBOSE 4925 /*-------------------------------------------------. 4926 | yyexhaustedlab -- memory exhaustion comes here. | 4927 `-------------------------------------------------*/ 4928 yyexhaustedlab: 4929 yyerror(YY_("memory exhausted")); 4930 yyresult = 2; 4931 /* Fall through. */ 4932 #endif 4933 4934 yyreturn: 4935 if (yychar != YYEMPTY) { 4936 /* Make sure we have latest lookahead translation. See comments at 4937 user semantic actions for why this is necessary. */ 4938 yytoken = YYTRANSLATE(yychar); 4939 yydestruct("Cleanup: discarding lookahead", 4940 yytoken, &yylval, &yylloc); 4941 } 4942 /* Do not reclaim the symbols of the rule which action triggered 4943 this YYABORT or YYACCEPT. */ 4944 YYPOPSTACK(yylen); 4945 YY_STACK_PRINT(yyss, yyssp); 4946 while (yyssp != yyss) { 4947 yydestruct("Cleanup: popping", 4948 yystos[*yyssp], yyvsp, yylsp); 4949 YYPOPSTACK(1); 4950 } 4951 #ifndef yyoverflow 4952 if (yyss != yyssa) { 4953 YYSTACK_FREE(yyss); 4954 } 4955 #endif 4956 #if YYERROR_VERBOSE 4957 if (yymsg != yymsgbuf) { 4958 YYSTACK_FREE(yymsg); 4959 } 4960 #endif 4961 /* Make sure YYID is used. */ 4962 return YYID(yyresult); 4963 } 4964 4965 /* Line 2055 of yacc.c */ 4966 #line 945 "grammar.y" 4967 4968 /* called by yyparse on error */ 4969 int yyerror(const char *) 4970 { 4971 // fprintf(stderr, "ERROR: %s at line %d\n", s, KJS::Lexer::curr()->lineNo()); 4972 return 1; 4973 } 4974 4975 /* may we automatically insert a semicolon ? */ 4976 static bool allowAutomaticSemicolon() 4977 { 4978 return yychar == '}' || yychar == 0 || lexer().prevTerminator(); 4979 } 4980