ReactOS Development > Doxygen
parser.tab.c
Go to the documentation of this file.
00001 00002 /* A Bison parser, made by GNU Bison 2.4.1. */ 00003 00004 /* Skeleton implementation for Bison's Yacc-like parsers in C 00005 00006 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 00007 Free Software Foundation, Inc. 00008 00009 This program is free software: you can redistribute it and/or modify 00010 it under the terms of the GNU General Public License as published by 00011 the Free Software Foundation, either version 3 of the License, or 00012 (at your option) any later version. 00013 00014 This program is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU General Public License for more details. 00018 00019 You should have received a copy of the GNU General Public License 00020 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00021 00022 /* As a special exception, you may create a larger work that contains 00023 part or all of the Bison parser skeleton and distribute that work 00024 under terms of your choice, so long as that work isn't itself a 00025 parser generator using the skeleton or a modified version thereof 00026 as a parser skeleton. Alternatively, if you modify or redistribute 00027 the parser skeleton itself, you may (at your option) remove this 00028 special exception, which will cause the skeleton and the resulting 00029 Bison output files to be licensed under the GNU General Public 00030 License without this special exception. 00031 00032 This special exception was added by the Free Software Foundation in 00033 version 2.2 of Bison. */ 00034 00035 /* C LALR(1) parser skeleton written by Richard Stallman, by 00036 simplifying the original so-called "semantic" parser. */ 00037 00038 /* All symbols defined below should begin with yy or YY, to avoid 00039 infringing on user name space. This should be done even for local 00040 variables, as they might otherwise be expanded by user macros. 00041 There are some unavoidable exceptions within include files to 00042 define necessary library symbols; they are noted "INFRINGES ON 00043 USER NAME SPACE" below. */ 00044 00045 /* Identify Bison output. */ 00046 #define YYBISON 1 00047 00048 /* Bison version. */ 00049 #define YYBISON_VERSION "2.4.1" 00050 00051 /* Skeleton name. */ 00052 #define YYSKELETON_NAME "yacc.c" 00053 00054 /* Pure parsers. */ 00055 #define YYPURE 1 00056 00057 /* Push parsers. */ 00058 #define YYPUSH 0 00059 00060 /* Pull parsers. */ 00061 #define YYPULL 1 00062 00063 /* Using locations. */ 00064 #define YYLSP_NEEDED 0 00065 00066 /* Substitute the variable and function names. */ 00067 #define yyparse parser_parse 00068 #define yylex parser_lex 00069 #define yyerror parser_error 00070 #define yylval parser_lval 00071 #define yychar parser_char 00072 #define yydebug parser_debug 00073 #define yynerrs parser_nerrs 00074 00075 00076 /* Copy the first part of user declarations. */ 00077 00078 /* Line 189 of yacc.c */ 00079 #line 19 "parser.y" 00080 00081 00082 #include "jscript.h" 00083 #include "engine.h" 00084 00085 #define YYLEX_PARAM ctx 00086 #define YYPARSE_PARAM ctx 00087 00088 static int parser_error(const char*); 00089 static void set_error(parser_ctx_t*,UINT); 00090 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR); 00091 static BOOL allow_auto_semicolon(parser_ctx_t*); 00092 static void program_parsed(parser_ctx_t*,source_elements_t*); 00093 static source_elements_t *function_body_parsed(parser_ctx_t*,source_elements_t*); 00094 00095 typedef struct _statement_list_t { 00096 statement_t *head; 00097 statement_t *tail; 00098 } statement_list_t; 00099 00100 static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*); 00101 static literal_t *new_null_literal(parser_ctx_t*); 00102 static literal_t *new_boolean_literal(parser_ctx_t*,VARIANT_BOOL); 00103 00104 typedef struct _property_list_t { 00105 prop_val_t *head; 00106 prop_val_t *tail; 00107 } property_list_t; 00108 00109 static property_list_t *new_property_list(parser_ctx_t*,literal_t*,expression_t*); 00110 static property_list_t *property_list_add(parser_ctx_t*,property_list_t*,literal_t*,expression_t*); 00111 00112 typedef struct _element_list_t { 00113 array_element_t *head; 00114 array_element_t *tail; 00115 } element_list_t; 00116 00117 static element_list_t *new_element_list(parser_ctx_t*,int,expression_t*); 00118 static element_list_t *element_list_add(parser_ctx_t*,element_list_t*,int,expression_t*); 00119 00120 typedef struct _argument_list_t { 00121 argument_t *head; 00122 argument_t *tail; 00123 } argument_list_t; 00124 00125 static argument_list_t *new_argument_list(parser_ctx_t*,expression_t*); 00126 static argument_list_t *argument_list_add(parser_ctx_t*,argument_list_t*,expression_t*); 00127 00128 typedef struct _case_list_t { 00129 case_clausule_t *head; 00130 case_clausule_t *tail; 00131 } case_list_t; 00132 00133 static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*); 00134 static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*); 00135 static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*); 00136 static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*); 00137 static case_clausule_t *new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*); 00138 00139 typedef struct _variable_list_t { 00140 variable_declaration_t *head; 00141 variable_declaration_t *tail; 00142 } variable_list_t; 00143 00144 static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const WCHAR*,expression_t*); 00145 static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*); 00146 static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*); 00147 00148 static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*); 00149 static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*); 00150 static statement_t *new_empty_statement(parser_ctx_t*); 00151 static statement_t *new_expression_statement(parser_ctx_t*,expression_t*); 00152 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*); 00153 static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*); 00154 static statement_t *new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*, 00155 expression_t*,statement_t*); 00156 static statement_t *new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*); 00157 static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*); 00158 static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*); 00159 static statement_t *new_return_statement(parser_ctx_t*,expression_t*); 00160 static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*); 00161 static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*); 00162 static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*); 00163 static statement_t *new_throw_statement(parser_ctx_t*,expression_t*); 00164 static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*); 00165 00166 struct statement_list_t { 00167 statement_t *head; 00168 statement_t *tail; 00169 }; 00170 00171 static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*); 00172 static statement_list_t *statement_list_add(statement_list_t*,statement_t*); 00173 00174 typedef struct _parameter_list_t { 00175 parameter_t *head; 00176 parameter_t *tail; 00177 } parameter_list_t; 00178 00179 static parameter_list_t *new_parameter_list(parser_ctx_t*,const WCHAR*); 00180 static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,const WCHAR*); 00181 00182 static void push_func(parser_ctx_t*); 00183 static inline void pop_func(parser_ctx_t *ctx) 00184 { 00185 ctx->func_stack = ctx->func_stack->next; 00186 } 00187 00188 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*, 00189 source_elements_t*,const WCHAR*,DWORD); 00190 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*); 00191 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*); 00192 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*); 00193 static expression_t *new_array_expression(parser_ctx_t*,expression_t*,expression_t*); 00194 static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*); 00195 static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*); 00196 static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*); 00197 static expression_t *new_this_expression(parser_ctx_t*); 00198 static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*); 00199 static expression_t *new_literal_expression(parser_ctx_t*,literal_t*); 00200 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int); 00201 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*); 00202 00203 static source_elements_t *new_source_elements(parser_ctx_t*); 00204 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*); 00205 00206 00207 00208 /* Line 189 of yacc.c */ 00209 #line 210 "parser.tab.c" 00210 00211 /* Enabling traces. */ 00212 #ifndef YYDEBUG 00213 # define YYDEBUG 0 00214 #endif 00215 00216 /* Enabling verbose error messages. */ 00217 #ifdef YYERROR_VERBOSE 00218 # undef YYERROR_VERBOSE 00219 # define YYERROR_VERBOSE 1 00220 #else 00221 # define YYERROR_VERBOSE 0 00222 #endif 00223 00224 /* Enabling the token table. */ 00225 #ifndef YYTOKEN_TABLE 00226 # define YYTOKEN_TABLE 0 00227 #endif 00228 00229 00230 /* Tokens. */ 00231 #ifndef YYTOKENTYPE 00232 # define YYTOKENTYPE 00233 /* Put the tokens into the symbol table, so that GDB and other debuggers 00234 know about them. */ 00235 enum yytokentype { 00236 kBREAK = 258, 00237 kCASE = 259, 00238 kCATCH = 260, 00239 kCONTINUE = 261, 00240 kDEFAULT = 262, 00241 kDELETE = 263, 00242 kDO = 264, 00243 kELSE = 265, 00244 kIF = 266, 00245 kFINALLY = 267, 00246 kFOR = 268, 00247 kIN = 269, 00248 kINSTANCEOF = 270, 00249 kNEW = 271, 00250 kNULL = 272, 00251 kRETURN = 273, 00252 kSWITCH = 274, 00253 kTHIS = 275, 00254 kTHROW = 276, 00255 kTRUE = 277, 00256 kFALSE = 278, 00257 kTRY = 279, 00258 kTYPEOF = 280, 00259 kVAR = 281, 00260 kVOID = 282, 00261 kWHILE = 283, 00262 kWITH = 284, 00263 tANDAND = 285, 00264 tOROR = 286, 00265 tINC = 287, 00266 tDEC = 288, 00267 tHTMLCOMMENT = 289, 00268 kDIVEQ = 290, 00269 kFUNCTION = 291, 00270 tIdentifier = 292, 00271 tAssignOper = 293, 00272 tEqOper = 294, 00273 tShiftOper = 295, 00274 tRelOper = 296, 00275 tNumericLiteral = 297, 00276 tStringLiteral = 298, 00277 LOWER_THAN_ELSE = 299 00278 }; 00279 #endif 00280 00281 00282 00283 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 00284 typedef union YYSTYPE 00285 { 00286 00287 /* Line 214 of yacc.c */ 00288 #line 150 "parser.y" 00289 00290 int ival; 00291 const WCHAR *srcptr; 00292 LPCWSTR wstr; 00293 literal_t *literal; 00294 struct _argument_list_t *argument_list; 00295 case_clausule_t *case_clausule; 00296 struct _case_list_t *case_list; 00297 catch_block_t *catch_block; 00298 struct _element_list_t *element_list; 00299 expression_t *expr; 00300 const WCHAR *identifier; 00301 struct _parameter_list_t *parameter_list; 00302 struct _property_list_t *property_list; 00303 source_elements_t *source_elements; 00304 statement_t *statement; 00305 struct _statement_list_t *statement_list; 00306 struct _variable_list_t *variable_list; 00307 variable_declaration_t *variable_declaration; 00308 00309 00310 00311 /* Line 214 of yacc.c */ 00312 #line 313 "parser.tab.c" 00313 } YYSTYPE; 00314 # define YYSTYPE_IS_TRIVIAL 1 00315 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00316 # define YYSTYPE_IS_DECLARED 1 00317 #endif 00318 00319 00320 /* Copy the second part of user declarations. */ 00321 00322 00323 /* Line 264 of yacc.c */ 00324 #line 325 "parser.tab.c" 00325 00326 #ifdef short 00327 # undef short 00328 #endif 00329 00330 #ifdef YYTYPE_UINT8 00331 typedef YYTYPE_UINT8 yytype_uint8; 00332 #else 00333 typedef unsigned char yytype_uint8; 00334 #endif 00335 00336 #ifdef YYTYPE_INT8 00337 typedef YYTYPE_INT8 yytype_int8; 00338 #elif (defined __STDC__ || defined __C99__FUNC__ \ 00339 || defined __cplusplus || defined _MSC_VER) 00340 typedef signed char yytype_int8; 00341 #else 00342 typedef short int yytype_int8; 00343 #endif 00344 00345 #ifdef YYTYPE_UINT16 00346 typedef YYTYPE_UINT16 yytype_uint16; 00347 #else 00348 typedef unsigned short int yytype_uint16; 00349 #endif 00350 00351 #ifdef YYTYPE_INT16 00352 typedef YYTYPE_INT16 yytype_int16; 00353 #else 00354 typedef short int yytype_int16; 00355 #endif 00356 00357 #ifndef YYSIZE_T 00358 # ifdef __SIZE_TYPE__ 00359 # define YYSIZE_T __SIZE_TYPE__ 00360 # elif defined size_t 00361 # define YYSIZE_T size_t 00362 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 00363 || defined __cplusplus || defined _MSC_VER) 00364 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00365 # define YYSIZE_T size_t 00366 # else 00367 # define YYSIZE_T unsigned int 00368 # endif 00369 #endif 00370 00371 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 00372 00373 #ifndef YY_ 00374 # if YYENABLE_NLS 00375 # if ENABLE_NLS 00376 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00377 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00378 # endif 00379 # endif 00380 # ifndef YY_ 00381 # define YY_(msgid) msgid 00382 # endif 00383 #endif 00384 00385 /* Suppress unused-variable warnings by "using" E. */ 00386 #if ! defined lint || defined __GNUC__ 00387 # define YYUSE(e) ((void) (e)) 00388 #else 00389 # define YYUSE(e) /* empty */ 00390 #endif 00391 00392 /* Identity function, used to suppress warnings about constant conditions. */ 00393 #ifndef lint 00394 # define YYID(n) (n) 00395 #else 00396 #if (defined __STDC__ || defined __C99__FUNC__ \ 00397 || defined __cplusplus || defined _MSC_VER) 00398 static int 00399 YYID (int yyi) 00400 #else 00401 static int 00402 YYID (yyi) 00403 int yyi; 00404 #endif 00405 { 00406 return yyi; 00407 } 00408 #endif 00409 00410 #if ! defined yyoverflow || YYERROR_VERBOSE 00411 00412 /* The parser invokes alloca or malloc; define the necessary symbols. */ 00413 00414 # ifdef YYSTACK_USE_ALLOCA 00415 # if YYSTACK_USE_ALLOCA 00416 # ifdef __GNUC__ 00417 # define YYSTACK_ALLOC __builtin_alloca 00418 # elif defined __BUILTIN_VA_ARG_INCR 00419 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 00420 # elif defined _AIX 00421 # define YYSTACK_ALLOC __alloca 00422 # elif defined _MSC_VER 00423 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 00424 # define alloca _alloca 00425 # else 00426 # define YYSTACK_ALLOC alloca 00427 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00428 || defined __cplusplus || defined _MSC_VER) 00429 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00430 # ifndef _STDLIB_H 00431 # define _STDLIB_H 1 00432 # endif 00433 # endif 00434 # endif 00435 # endif 00436 # endif 00437 00438 # ifdef YYSTACK_ALLOC 00439 /* Pacify GCC's `empty if-body' warning. */ 00440 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 00441 # ifndef YYSTACK_ALLOC_MAXIMUM 00442 /* The OS might guarantee only one guard page at the bottom of the stack, 00443 and a page size can be as small as 4096 bytes. So we cannot safely 00444 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 00445 to allow for a few compiler-allocated temporary stack slots. */ 00446 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 00447 # endif 00448 # else 00449 # define YYSTACK_ALLOC YYMALLOC 00450 # define YYSTACK_FREE YYFREE 00451 # ifndef YYSTACK_ALLOC_MAXIMUM 00452 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 00453 # endif 00454 # if (defined __cplusplus && ! defined _STDLIB_H \ 00455 && ! ((defined YYMALLOC || defined malloc) \ 00456 && (defined YYFREE || defined free))) 00457 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00458 # ifndef _STDLIB_H 00459 # define _STDLIB_H 1 00460 # endif 00461 # endif 00462 # ifndef YYMALLOC 00463 # define YYMALLOC malloc 00464 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00465 || defined __cplusplus || defined _MSC_VER) 00466 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 00467 # endif 00468 # endif 00469 # ifndef YYFREE 00470 # define YYFREE free 00471 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00472 || defined __cplusplus || defined _MSC_VER) 00473 void free (void *); /* INFRINGES ON USER NAME SPACE */ 00474 # endif 00475 # endif 00476 # endif 00477 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 00478 00479 00480 #if (! defined yyoverflow \ 00481 && (! defined __cplusplus \ 00482 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 00483 00484 /* A type that is properly aligned for any stack member. */ 00485 union yyalloc 00486 { 00487 yytype_int16 yyss_alloc; 00488 YYSTYPE yyvs_alloc; 00489 }; 00490 00491 /* The size of the maximum gap between one aligned stack and the next. */ 00492 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 00493 00494 /* The size of an array large to enough to hold all stacks, each with 00495 N elements. */ 00496 # define YYSTACK_BYTES(N) \ 00497 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 00498 + YYSTACK_GAP_MAXIMUM) 00499 00500 /* Copy COUNT objects from FROM to TO. The source and destination do 00501 not overlap. */ 00502 # ifndef YYCOPY 00503 # if defined __GNUC__ && 1 < __GNUC__ 00504 # define YYCOPY(To, From, Count) \ 00505 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 00506 # else 00507 # define YYCOPY(To, From, Count) \ 00508 do \ 00509 { \ 00510 YYSIZE_T yyi; \ 00511 for (yyi = 0; yyi < (Count); yyi++) \ 00512 (To)[yyi] = (From)[yyi]; \ 00513 } \ 00514 while (YYID (0)) 00515 # endif 00516 # endif 00517 00518 /* Relocate STACK from its old location to the new one. The 00519 local variables YYSIZE and YYSTACKSIZE give the old and new number of 00520 elements in the stack, and YYPTR gives the new location of the 00521 stack. Advance YYPTR to a properly aligned location for the next 00522 stack. */ 00523 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 00524 do \ 00525 { \ 00526 YYSIZE_T yynewbytes; \ 00527 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 00528 Stack = &yyptr->Stack_alloc; \ 00529 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 00530 yyptr += yynewbytes / sizeof (*yyptr); \ 00531 } \ 00532 while (YYID (0)) 00533 00534 #endif 00535 00536 /* YYFINAL -- State number of the termination state. */ 00537 #define YYFINAL 3 00538 /* YYLAST -- Last index in YYTABLE. */ 00539 #define YYLAST 1030 00540 00541 /* YYNTOKENS -- Number of terminals. */ 00542 #define YYNTOKENS 67 00543 /* YYNNTS -- Number of nonterminals. */ 00544 #define YYNNTS 95 00545 /* YYNRULES -- Number of rules. */ 00546 #define YYNRULES 214 00547 /* YYNRULES -- Number of states. */ 00548 #define YYNSTATES 373 00549 00550 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 00551 #define YYUNDEFTOK 2 00552 #define YYMAXUTOK 299 00553 00554 #define YYTRANSLATE(YYX) \ 00555 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 00556 00557 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 00558 static const yytype_uint8 yytranslate[] = 00559 { 00560 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00563 2, 2, 2, 61, 2, 2, 2, 59, 54, 2, 00564 65, 66, 57, 55, 47, 56, 64, 58, 2, 2, 00565 2, 2, 2, 2, 2, 2, 2, 2, 50, 49, 00566 2, 48, 2, 51, 2, 2, 2, 2, 2, 2, 00567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00569 2, 62, 2, 63, 53, 2, 2, 2, 2, 2, 00570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00572 2, 2, 2, 46, 52, 37, 60, 2, 2, 2, 00573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00583 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00585 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 00586 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 00587 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 00588 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 00589 35, 36, 38, 39, 40, 41, 42, 43, 44, 45 00590 }; 00591 00592 #if YYDEBUG 00593 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 00594 YYRHS. */ 00595 static const yytype_uint16 yyprhs[] = 00596 { 00597 0, 0, 3, 6, 8, 9, 10, 13, 22, 24, 00598 26, 28, 32, 33, 35, 37, 39, 41, 43, 45, 00599 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 00600 67, 70, 71, 73, 77, 80, 84, 86, 90, 92, 00601 96, 99, 102, 103, 105, 108, 109, 111, 114, 116, 00602 119, 127, 133, 141, 147, 148, 149, 161, 162, 163, 00603 176, 184, 193, 197, 201, 205, 211, 215, 221, 225, 00604 231, 232, 234, 236, 239, 244, 248, 252, 256, 260, 00605 265, 271, 274, 275, 277, 279, 281, 283, 287, 288, 00606 290, 292, 296, 298, 300, 302, 306, 310, 312, 316, 00607 320, 322, 328, 330, 336, 338, 342, 344, 348, 350, 00608 354, 356, 360, 362, 366, 368, 372, 374, 378, 380, 00609 384, 386, 390, 392, 396, 398, 402, 404, 408, 410, 00610 414, 418, 422, 424, 428, 432, 434, 438, 440, 444, 00611 448, 450, 454, 458, 462, 464, 467, 470, 473, 476, 00612 479, 482, 485, 488, 491, 493, 496, 499, 501, 503, 00613 505, 508, 510, 512, 517, 521, 525, 528, 531, 536, 00614 540, 543, 547, 549, 553, 555, 557, 559, 561, 563, 00615 567, 570, 574, 578, 584, 587, 592, 594, 597, 598, 00616 600, 603, 607, 611, 617, 619, 621, 623, 624, 626, 00617 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 00618 648, 650, 652, 654, 656 00619 }; 00620 00621 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 00622 static const yytype_int16 yyrhs[] = 00623 { 00624 68, 0, -1, 70, 69, -1, 34, -1, -1, -1, 00625 70, 76, -1, 72, 155, 159, 75, 160, 46, 73, 00626 37, -1, 36, -1, 70, -1, 38, -1, 74, 47, 00627 38, -1, -1, 74, -1, 79, -1, 80, -1, 89, 00628 -1, 71, -1, 90, -1, 91, -1, 92, -1, 97, 00629 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102, 00630 -1, 108, -1, 109, -1, 76, -1, 77, 76, -1, 00631 -1, 77, -1, 46, 77, 37, -1, 46, 37, -1, 00632 26, 81, 158, -1, 83, -1, 81, 47, 83, -1, 00633 84, -1, 82, 47, 84, -1, 38, 85, -1, 38, 00634 87, -1, -1, 86, -1, 48, 118, -1, -1, 88, 00635 -1, 48, 119, -1, 49, -1, 114, 158, -1, 11, 00636 159, 113, 160, 76, 10, 76, -1, 11, 159, 113, 00637 160, 76, -1, 9, 76, 28, 159, 113, 160, 158, 00638 -1, 28, 159, 113, 160, 76, -1, -1, -1, 13, 00639 159, 115, 93, 161, 112, 94, 161, 112, 160, 76, 00640 -1, -1, -1, 13, 159, 26, 82, 95, 161, 112, 00641 96, 161, 112, 160, 76, -1, 13, 159, 141, 14, 00642 113, 160, 76, -1, 13, 159, 26, 84, 14, 113, 00643 160, 76, -1, 6, 155, 158, -1, 3, 155, 158, 00644 -1, 18, 112, 158, -1, 29, 159, 114, 160, 76, 00645 -1, 38, 50, 76, -1, 19, 159, 114, 160, 103, 00646 -1, 46, 104, 37, -1, 46, 104, 107, 104, 37, 00647 -1, -1, 105, -1, 106, -1, 105, 106, -1, 4, 00648 114, 50, 78, -1, 7, 50, 78, -1, 21, 114, 00649 158, -1, 24, 79, 110, -1, 24, 79, 111, -1, 00650 24, 79, 110, 111, -1, 5, 159, 38, 160, 79, 00651 -1, 12, 79, -1, -1, 114, -1, 114, -1, 1, 00652 -1, 118, -1, 114, 47, 118, -1, -1, 116, -1, 00653 119, -1, 116, 47, 119, -1, 39, -1, 35, -1, 00654 120, -1, 141, 48, 118, -1, 141, 117, 118, -1, 00655 121, -1, 141, 48, 119, -1, 141, 117, 119, -1, 00656 122, -1, 122, 51, 118, 50, 118, -1, 123, -1, 00657 123, 51, 119, 50, 119, -1, 124, -1, 122, 31, 00658 124, -1, 125, -1, 123, 31, 125, -1, 126, -1, 00659 124, 30, 126, -1, 127, -1, 125, 30, 127, -1, 00660 128, -1, 126, 52, 128, -1, 129, -1, 127, 52, 00661 129, -1, 130, -1, 128, 53, 130, -1, 131, -1, 00662 129, 53, 131, -1, 132, -1, 130, 54, 132, -1, 00663 133, -1, 131, 54, 133, -1, 134, -1, 132, 40, 00664 134, -1, 135, -1, 133, 40, 135, -1, 136, -1, 00665 134, 42, 136, -1, 134, 15, 136, -1, 134, 14, 00666 136, -1, 136, -1, 135, 42, 136, -1, 135, 15, 00667 136, -1, 137, -1, 136, 41, 137, -1, 138, -1, 00668 137, 55, 138, -1, 137, 56, 138, -1, 139, -1, 00669 138, 57, 139, -1, 138, 58, 139, -1, 138, 59, 00670 139, -1, 140, -1, 8, 139, -1, 27, 139, -1, 00671 25, 139, -1, 32, 139, -1, 33, 139, -1, 55, 00672 139, -1, 56, 139, -1, 60, 139, -1, 61, 139, 00673 -1, 141, -1, 141, 32, -1, 141, 33, -1, 142, 00674 -1, 144, -1, 143, -1, 16, 142, -1, 147, -1, 00675 71, -1, 143, 62, 114, 63, -1, 143, 64, 38, 00676 -1, 16, 143, 145, -1, 143, 145, -1, 144, 145, 00677 -1, 144, 62, 114, 63, -1, 144, 64, 38, -1, 00678 65, 66, -1, 65, 146, 66, -1, 118, -1, 146, 00679 47, 118, -1, 20, -1, 38, -1, 156, -1, 148, 00680 -1, 152, -1, 65, 114, 66, -1, 62, 63, -1, 00681 62, 150, 63, -1, 62, 149, 63, -1, 62, 149, 00682 47, 151, 63, -1, 151, 118, -1, 149, 47, 151, 00683 118, -1, 47, -1, 150, 47, -1, -1, 150, -1, 00684 46, 37, -1, 46, 153, 37, -1, 154, 50, 118, 00685 -1, 153, 47, 154, 50, 118, -1, 38, -1, 44, 00686 -1, 43, -1, -1, 38, -1, 17, -1, 157, -1, 00687 43, -1, 44, -1, 58, -1, 35, -1, 22, -1, 00688 23, -1, 49, -1, 1, -1, 65, -1, 1, -1, 00689 66, -1, 1, -1, 49, -1, 1, -1 00690 }; 00691 00692 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 00693 static const yytype_uint16 yyrline[] = 00694 { 00695 0, 256, 256, 260, 261, 265, 266, 271, 275, 279, 00696 283, 284, 289, 290, 294, 295, 296, 297, 298, 299, 00697 300, 301, 302, 303, 304, 305, 306, 307, 308, 312, 00698 313, 318, 319, 323, 324, 328, 333, 334, 339, 341, 00699 346, 351, 356, 357, 361, 366, 367, 371, 376, 380, 00700 385, 387, 392, 394, 397, 399, 396, 403, 405, 402, 00701 408, 410, 415, 420, 425, 430, 435, 440, 445, 447, 00702 452, 453, 457, 458, 463, 468, 473, 478, 479, 480, 00703 485, 490, 494, 495, 498, 499, 503, 504, 509, 510, 00704 514, 516, 520, 521, 525, 526, 528, 533, 535, 537, 00705 542, 543, 548, 550, 555, 556, 561, 563, 568, 569, 00706 574, 576, 581, 582, 587, 589, 594, 595, 600, 602, 00707 607, 608, 613, 615, 620, 621, 626, 627, 632, 633, 00708 635, 637, 642, 643, 645, 650, 651, 656, 658, 660, 00709 665, 666, 668, 670, 675, 676, 678, 679, 681, 682, 00710 683, 684, 685, 686, 690, 692, 694, 700, 701, 705, 00711 706, 710, 711, 712, 714, 716, 721, 723, 725, 727, 00712 732, 733, 737, 738, 743, 744, 745, 746, 747, 748, 00713 752, 753, 754, 755, 760, 762, 767, 768, 772, 773, 00714 777, 778, 783, 785, 790, 791, 792, 796, 797, 801, 00715 802, 803, 804, 805, 807, 812, 813, 816, 817, 820, 00716 821, 824, 825, 828, 829 00717 }; 00718 #endif 00719 00720 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 00721 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 00722 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 00723 static const char *const yytname[] = 00724 { 00725 "$end", "error", "$undefined", "kBREAK", "kCASE", "kCATCH", "kCONTINUE", 00726 "kDEFAULT", "kDELETE", "kDO", "kELSE", "kIF", "kFINALLY", "kFOR", "kIN", 00727 "kINSTANCEOF", "kNEW", "kNULL", "kRETURN", "kSWITCH", "kTHIS", "kTHROW", 00728 "kTRUE", "kFALSE", "kTRY", "kTYPEOF", "kVAR", "kVOID", "kWHILE", "kWITH", 00729 "tANDAND", "tOROR", "tINC", "tDEC", "tHTMLCOMMENT", "kDIVEQ", 00730 "kFUNCTION", "'}'", "tIdentifier", "tAssignOper", "tEqOper", 00731 "tShiftOper", "tRelOper", "tNumericLiteral", "tStringLiteral", 00732 "LOWER_THAN_ELSE", "'{'", "','", "'='", "';'", "':'", "'?'", "'|'", 00733 "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'!'", "'['", 00734 "']'", "'.'", "'('", "')'", "$accept", "Program", "HtmlComment", 00735 "SourceElements", "FunctionExpression", "KFunction", "FunctionBody", 00736 "FormalParameterList", "FormalParameterList_opt", "Statement", 00737 "StatementList", "StatementList_opt", "Block", "VariableStatement", 00738 "VariableDeclarationList", "VariableDeclarationListNoIn", 00739 "VariableDeclaration", "VariableDeclarationNoIn", "Initialiser_opt", 00740 "Initialiser", "InitialiserNoIn_opt", "InitialiserNoIn", 00741 "EmptyStatement", "ExpressionStatement", "IfStatement", 00742 "IterationStatement", "$@1", "$@2", "$@3", "$@4", "ContinueStatement", 00743 "BreakStatement", "ReturnStatement", "WithStatement", 00744 "LabelledStatement", "SwitchStatement", "CaseBlock", "CaseClausules_opt", 00745 "CaseClausules", "CaseClausule", "DefaultClausule", "ThrowStatement", 00746 "TryStatement", "Catch", "Finally", "Expression_opt", "Expression_err", 00747 "Expression", "ExpressionNoIn_opt", "ExpressionNoIn", "AssignOper", 00748 "AssignmentExpression", "AssignmentExpressionNoIn", 00749 "ConditionalExpression", "ConditionalExpressionNoIn", 00750 "LogicalORExpression", "LogicalORExpressionNoIn", "LogicalANDExpression", 00751 "LogicalANDExpressionNoIn", "BitwiseORExpression", 00752 "BitwiseORExpressionNoIn", "BitwiseXORExpression", 00753 "BitwiseXORExpressionNoIn", "BitwiseANDExpression", 00754 "BitwiseANDExpressionNoIn", "EqualityExpression", 00755 "EqualityExpressionNoIn", "RelationalExpression", 00756 "RelationalExpressionNoIn", "ShiftExpression", "AdditiveExpression", 00757 "MultiplicativeExpression", "UnaryExpression", "PostfixExpression", 00758 "LeftHandSideExpression", "NewExpression", "MemberExpression", 00759 "CallExpression", "Arguments", "ArgumentList", "PrimaryExpression", 00760 "ArrayLiteral", "ElementList", "Elision", "Elision_opt", "ObjectLiteral", 00761 "PropertyNameAndValueList", "PropertyName", "Identifier_opt", "Literal", 00762 "BooleanLiteral", "semicolon_opt", "left_bracket", "right_bracket", 00763 "semicolon", 0 00764 }; 00765 #endif 00766 00767 # ifdef YYPRINT 00768 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 00769 token YYLEX-NUM. */ 00770 static const yytype_uint16 yytoknum[] = 00771 { 00772 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 00773 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 00774 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 00775 285, 286, 287, 288, 289, 290, 291, 125, 292, 293, 00776 294, 295, 296, 297, 298, 299, 123, 44, 61, 59, 00777 58, 63, 124, 94, 38, 43, 45, 42, 47, 37, 00778 126, 33, 91, 93, 46, 40, 41 00779 }; 00780 # endif 00781 00782 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 00783 static const yytype_uint8 yyr1[] = 00784 { 00785 0, 67, 68, 69, 69, 70, 70, 71, 72, 73, 00786 74, 74, 75, 75, 76, 76, 76, 76, 76, 76, 00787 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, 00788 77, 78, 78, 79, 79, 80, 81, 81, 82, 82, 00789 83, 84, 85, 85, 86, 87, 87, 88, 89, 90, 00790 91, 91, 92, 92, 93, 94, 92, 95, 96, 92, 00791 92, 92, 97, 98, 99, 100, 101, 102, 103, 103, 00792 104, 104, 105, 105, 106, 107, 108, 109, 109, 109, 00793 110, 111, 112, 112, 113, 113, 114, 114, 115, 115, 00794 116, 116, 117, 117, 118, 118, 118, 119, 119, 119, 00795 120, 120, 121, 121, 122, 122, 123, 123, 124, 124, 00796 125, 125, 126, 126, 127, 127, 128, 128, 129, 129, 00797 130, 130, 131, 131, 132, 132, 133, 133, 134, 134, 00798 134, 134, 135, 135, 135, 136, 136, 137, 137, 137, 00799 138, 138, 138, 138, 139, 139, 139, 139, 139, 139, 00800 139, 139, 139, 139, 140, 140, 140, 141, 141, 142, 00801 142, 143, 143, 143, 143, 143, 144, 144, 144, 144, 00802 145, 145, 146, 146, 147, 147, 147, 147, 147, 147, 00803 148, 148, 148, 148, 149, 149, 150, 150, 151, 151, 00804 152, 152, 153, 153, 154, 154, 154, 155, 155, 156, 00805 156, 156, 156, 156, 156, 157, 157, 158, 158, 159, 00806 159, 160, 160, 161, 161 00807 }; 00808 00809 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 00810 static const yytype_uint8 yyr2[] = 00811 { 00812 0, 2, 2, 1, 0, 0, 2, 8, 1, 1, 00813 1, 3, 0, 1, 1, 1, 1, 1, 1, 1, 00814 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00815 2, 0, 1, 3, 2, 3, 1, 3, 1, 3, 00816 2, 2, 0, 1, 2, 0, 1, 2, 1, 2, 00817 7, 5, 7, 5, 0, 0, 11, 0, 0, 12, 00818 7, 8, 3, 3, 3, 5, 3, 5, 3, 5, 00819 0, 1, 1, 2, 4, 3, 3, 3, 3, 4, 00820 5, 2, 0, 1, 1, 1, 1, 3, 0, 1, 00821 1, 3, 1, 1, 1, 3, 3, 1, 3, 3, 00822 1, 5, 1, 5, 1, 3, 1, 3, 1, 3, 00823 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 00824 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 00825 3, 3, 1, 3, 3, 1, 3, 1, 3, 3, 00826 1, 3, 3, 3, 1, 2, 2, 2, 2, 2, 00827 2, 2, 2, 2, 1, 2, 2, 1, 1, 1, 00828 2, 1, 1, 4, 3, 3, 2, 2, 4, 3, 00829 2, 3, 1, 3, 1, 1, 1, 1, 1, 3, 00830 2, 3, 3, 5, 2, 4, 1, 2, 0, 1, 00831 2, 3, 3, 5, 1, 1, 1, 0, 1, 1, 00832 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00833 1, 1, 1, 1, 1 00834 }; 00835 00836 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 00837 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 00838 means the default is an error. */ 00839 static const yytype_uint8 yydefact[] = 00840 { 00841 5, 0, 4, 1, 197, 197, 0, 0, 0, 0, 00842 0, 199, 82, 0, 174, 0, 205, 206, 0, 0, 00843 0, 0, 0, 0, 0, 0, 3, 204, 8, 175, 00844 201, 202, 0, 48, 0, 0, 203, 0, 0, 188, 00845 0, 2, 17, 197, 6, 14, 15, 16, 18, 19, 00846 20, 21, 22, 23, 24, 25, 26, 27, 28, 0, 00847 86, 94, 100, 104, 108, 112, 116, 120, 124, 128, 00848 135, 137, 140, 144, 154, 157, 159, 158, 161, 177, 00849 178, 176, 200, 198, 0, 0, 175, 0, 162, 145, 00850 154, 0, 210, 209, 0, 88, 160, 159, 0, 83, 00851 0, 0, 0, 0, 147, 42, 0, 36, 146, 0, 00852 0, 148, 149, 0, 34, 175, 201, 202, 29, 0, 00853 0, 0, 150, 151, 152, 153, 186, 180, 0, 189, 00854 0, 0, 0, 208, 0, 207, 49, 0, 0, 0, 00855 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00856 0, 0, 0, 155, 156, 93, 92, 0, 0, 0, 00857 0, 0, 166, 0, 0, 167, 63, 62, 190, 194, 00858 196, 195, 0, 85, 0, 84, 0, 54, 89, 90, 00859 97, 102, 106, 110, 114, 118, 122, 126, 132, 154, 00860 165, 64, 0, 76, 34, 0, 0, 77, 78, 0, 00861 40, 43, 0, 35, 0, 0, 66, 33, 30, 191, 00862 0, 0, 188, 182, 187, 181, 184, 179, 12, 87, 00863 105, 0, 109, 113, 117, 121, 125, 131, 130, 129, 00864 136, 138, 139, 141, 142, 143, 95, 96, 0, 164, 00865 170, 172, 0, 0, 169, 0, 212, 211, 0, 45, 00866 57, 38, 0, 0, 0, 0, 0, 0, 0, 0, 00867 0, 0, 0, 0, 0, 0, 0, 0, 81, 79, 00868 44, 37, 0, 0, 0, 192, 189, 0, 10, 13, 00869 0, 0, 163, 0, 171, 168, 0, 51, 0, 41, 00870 46, 0, 0, 0, 214, 213, 82, 91, 154, 107, 00871 0, 111, 115, 119, 123, 127, 134, 133, 0, 98, 00872 99, 70, 67, 0, 53, 65, 0, 183, 185, 0, 00873 0, 101, 173, 0, 0, 47, 39, 82, 0, 55, 00874 0, 0, 0, 0, 71, 72, 0, 193, 11, 5, 00875 52, 50, 58, 0, 0, 103, 60, 0, 0, 68, 00876 70, 73, 80, 9, 0, 0, 61, 82, 31, 31, 00877 0, 7, 82, 0, 32, 74, 75, 69, 0, 0, 00878 0, 56, 59 00879 }; 00880 00881 /* YYDEFGOTO[NTERM-NUM]. */ 00882 static const yytype_int16 yydefgoto[] = 00883 { 00884 -1, 1, 41, 2, 88, 43, 354, 279, 280, 118, 00885 119, 365, 45, 46, 106, 250, 107, 251, 200, 201, 00886 289, 290, 47, 48, 49, 50, 252, 344, 292, 355, 00887 51, 52, 53, 54, 55, 56, 312, 333, 334, 335, 00888 350, 57, 58, 197, 198, 98, 174, 59, 177, 178, 00889 265, 60, 179, 61, 180, 62, 181, 63, 182, 64, 00890 183, 65, 184, 66, 185, 67, 186, 68, 187, 69, 00891 70, 71, 72, 73, 74, 75, 76, 77, 162, 242, 00892 78, 79, 128, 129, 130, 80, 120, 121, 84, 81, 00893 82, 136, 94, 248, 296 00894 }; 00895 00896 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 00897 STATE-NUM. */ 00898 #define YYPACT_NINF -287 00899 static const yytype_int16 yypact[] = 00900 { 00901 -287, 29, 490, -287, -18, -18, 934, 730, 21, 21, 00902 965, -287, 934, 21, -287, 934, -287, -287, 36, 934, 00903 89, 934, 21, 21, 934, 934, -287, -287, -287, 105, 00904 -287, -287, 550, -287, 934, 934, -287, 934, 934, 61, 00905 934, -287, 403, -18, -287, -287, -287, -287, -287, -287, 00906 -287, -287, -287, -287, -287, -287, -287, -287, -287, 15, 00907 -287, -287, 41, 106, 117, 129, 142, 158, 76, 162, 00908 131, 47, -287, -287, 141, -287, 113, 148, -287, -287, 00909 -287, -287, -287, -287, 5, 5, -287, 147, -287, -287, 00910 169, 177, -287, -287, 370, 832, -287, 113, 5, 164, 00911 934, 15, 610, 123, -287, 159, 16, -287, -287, 370, 00912 934, -287, -287, 730, 438, 105, 175, 176, -287, 670, 00913 86, 178, -287, -287, -287, -287, -287, -287, 62, 63, 00914 934, 28, 21, -287, 934, -287, -287, 934, 934, 934, 00915 934, 934, 934, 934, 934, 934, 934, 934, 934, 934, 00916 934, 934, 934, -287, -287, -287, -287, 934, 934, 934, 00917 181, 781, -287, 934, 189, -287, -287, -287, -287, -287, 00918 -287, -287, 21, -287, 8, 164, 191, -287, 183, -287, 00919 -287, 56, 201, 180, 182, 179, 194, 53, 162, 10, 00920 -287, -287, 12, -287, -287, 21, 36, 225, -287, 934, 00921 -287, -287, 89, -287, 8, 12, -287, -287, -287, -287, 00922 94, 934, 193, -287, -287, -287, -287, -287, 200, -287, 00923 106, 192, 117, 129, 142, 158, 76, 162, 162, 162, 00924 131, 47, 47, -287, -287, -287, -287, -287, 68, -287, 00925 -287, -287, 46, 109, -287, 370, -287, -287, 730, 195, 00926 197, 227, 18, 934, 934, 934, 934, 934, 934, 934, 00927 934, 934, 934, 370, 934, 934, 199, 209, -287, -287, 00928 -287, -287, 730, 730, 202, -287, 204, 883, -287, 206, 00929 8, 934, -287, 934, -287, -287, 8, 239, 934, -287, 00930 -287, 191, 18, 370, -287, -287, 934, -287, 160, 201, 00931 218, 180, 182, 179, 194, 53, 162, 162, 8, -287, 00932 -287, 250, -287, 8, -287, -287, 934, -287, -287, 231, 00933 228, -287, -287, 5, 730, -287, -287, 934, 8, -287, 00934 934, 730, 934, 66, 250, -287, 36, -287, -287, -287, 00935 -287, -287, -287, 730, 18, -287, -287, -32, 226, -287, 00936 250, -287, -287, 730, 238, 18, -287, 934, 730, 730, 00937 240, -287, 934, 8, 730, -287, -287, -287, 8, 730, 00938 730, -287, -287 00939 }; 00940 00941 /* YYPGOTO[NTERM-NUM]. */ 00942 static const yytype_int16 yypgoto[] = 00943 { 00944 -287, -287, -287, -61, -2, -287, -287, -287, -287, 0, 00945 -141, -80, -15, -287, -287, -287, 78, -10, -287, -287, 00946 -287, -287, -287, -287, -287, -287, -287, -287, -287, -287, 00947 -287, -287, -287, -287, -287, -287, -287, -68, -287, -50, 00948 -287, -287, -287, -287, 88, -286, -105, 20, -287, -287, 00949 212, -77, -209, -287, -287, -287, -287, 150, 34, 152, 00950 33, 153, 35, 154, 38, 156, 40, 151, 42, -94, 00951 157, 75, 64, -287, 2, 290, 291, -287, 19, -287, 00952 -287, -287, -287, 93, 95, -287, -287, 96, 26, -287, 00953 -287, -73, 25, 17, -278 00954 }; 00955 00956 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 00957 positive, shift that token. If negative, reduce the rule which 00958 number is the opposite. If zero, do what YYDEFACT says. 00959 If YYTABLE_NINF, syntax error. */ 00960 #define YYTABLE_NINF -197 00961 static const yytype_int16 yytable[] = 00962 { 00963 42, 188, 44, 103, 204, 42, 133, 91, 90, 246, 00964 329, 166, 167, 246, 327, 134, 133, 133, 358, 294, 00965 83, 90, 92, 90, 263, 191, 90, 90, 193, 3, 00966 42, 85, 99, 203, 95, 101, 90, 90, 100, 90, 00967 90, 342, 153, 154, 297, 155, 300, 109, 110, 156, 00968 227, 228, 229, 216, 135, 309, 310, 219, 264, 134, 00969 131, 221, 134, 202, 135, 135, 357, 295, 261, 132, 00970 89, 363, 137, 348, 247, 134, 368, 362, 247, 325, 00971 236, 237, 102, 104, 241, 108, 93, 254, 111, 112, 00972 144, 145, 138, 283, 217, 262, 165, 189, 122, 123, 00973 42, 124, 125, 349, 150, 151, 152, 255, 126, 212, 00974 214, 42, 284, 206, 175, 134, 190, 42, 146, 208, 00975 192, 345, 270, 209, 127, 213, 215, 105, 195, 175, 00976 205, 282, 169, 210, 275, 196, 139, 170, 171, 90, 00977 286, 90, 90, 90, 90, 90, 90, 90, 90, 90, 00978 90, 90, 90, 90, 90, 113, 134, 218, 308, 188, 00979 188, 188, 188, 188, 188, 188, 188, 306, 307, 140, 00980 188, 188, 285, 153, 154, 159, 155, 160, 161, 238, 00981 156, 268, 141, 243, 168, 169, 148, 149, 328, 157, 00982 170, 171, 153, 154, 188, 155, 142, 245, 143, 156, 00983 318, 153, 154, 147, 321, 172, 322, 199, 264, 266, 00984 163, 134, 164, 161, 233, 234, 235, 364, 364, 239, 00985 267, 272, 273, 231, 232, -196, -195, 244, 211, 249, 00986 253, 256, 257, 259, 260, 258, 188, 196, 278, 337, 00987 126, 293, 281, 288, 291, 311, 42, 313, 287, 324, 00988 340, 214, 316, 319, 332, 298, 90, 298, 90, 90, 00989 90, 90, 90, 90, 90, 175, 298, 298, 330, 338, 00990 42, 42, 314, 315, 339, 361, 359, 367, 353, 366, 00991 271, 326, 360, 175, 351, 269, 158, 220, 299, 301, 00992 298, 222, 302, 223, 226, 224, 303, 320, 225, 304, 00993 96, 97, 305, 323, 230, 276, 274, 277, 0, 0, 00994 0, 0, 0, 175, 0, 0, 99, 0, 0, 0, 00995 0, 352, 42, 0, 341, 331, 0, 0, 0, 42, 00996 336, 346, 298, 0, 0, 0, 0, 0, 0, 0, 00997 0, 42, 0, 356, 0, 343, 0, 99, 0, 0, 00998 0, 42, 347, 44, 0, 0, 42, 42, 0, 0, 00999 0, 0, 42, 0, 208, 0, 0, 42, 42, 371, 01000 372, 173, 0, 0, 0, 0, 0, 99, 6, 0, 01001 369, 0, 99, 0, 0, 370, 10, 11, 0, 0, 01002 14, 0, 16, 17, 0, 19, 0, 21, 0, 0, 01003 0, 0, 24, 25, -162, 27, 28, 0, 86, 0, 01004 0, 0, 0, 30, 31, 0, 87, -162, -162, 0, 01005 0, 0, 0, 0, 0, 34, 35, 0, 36, 0, 01006 37, 38, 39, -162, -162, 40, 0, 0, 0, -190, 01007 0, 0, -162, -162, -162, -162, 0, 0, 0, 0, 01008 -162, -162, -190, -190, -162, -162, -162, -162, 0, 0, 01009 -162, 0, -162, 0, 0, 0, 0, -162, -190, -190, 01010 0, 0, 0, 0, 0, 0, 0, -190, -190, -190, 01011 -190, 0, 0, 0, 0, -190, -190, 0, 0, -190, 01012 -190, -190, -190, 4, 0, -190, 5, -190, 6, 7, 01013 0, 8, -190, 9, 0, 0, 10, 11, 12, 13, 01014 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01015 0, 0, 24, 25, 26, 27, 28, 0, 29, 0, 01016 0, 0, 0, 30, 31, 0, 32, 0, 0, 33, 01017 0, 0, 0, 0, 0, 34, 35, 0, 36, 0, 01018 37, 38, 39, 4, 0, 40, 5, 0, 6, 7, 01019 0, 8, 0, 9, 0, 0, 10, 11, 12, 13, 01020 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01021 0, 0, 24, 25, 0, 27, 28, 114, 115, 0, 01022 0, 0, 0, 116, 117, 0, 32, 0, 0, 33, 01023 0, 0, 0, 0, 0, 34, 35, 0, 36, 0, 01024 37, 38, 39, 4, 0, 40, 5, 0, 6, 7, 01025 0, 8, 0, 9, 0, 0, 10, 11, 12, 13, 01026 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01027 0, 0, 24, 25, 0, 27, 28, 194, 29, 0, 01028 0, 0, 0, 30, 31, 0, 32, 0, 0, 33, 01029 0, 0, 0, 0, 0, 34, 35, 0, 36, 0, 01030 37, 38, 39, 4, 0, 40, 5, 0, 6, 7, 01031 0, 8, 0, 9, 0, 0, 10, 11, 12, 13, 01032 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01033 0, 0, 24, 25, 0, 27, 28, 207, 29, 0, 01034 0, 0, 0, 30, 31, 0, 32, 0, 0, 33, 01035 0, 0, 0, 0, 0, 34, 35, 0, 36, 0, 01036 37, 38, 39, 4, 0, 40, 5, 0, 6, 7, 01037 0, 8, 0, 9, 0, 0, 10, 11, 12, 13, 01038 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 01039 0, 0, 24, 25, 0, 27, 28, 0, 29, 0, 01040 0, 0, 0, 30, 31, 0, 32, 0, 0, 33, 01041 0, 0, 0, 0, 0, 34, 35, 0, 36, 6, 01042 37, 38, 39, 0, 0, 40, 0, 10, 11, 0, 01043 0, 14, 0, 16, 17, 0, 19, 0, 21, 0, 01044 0, 0, 0, 24, 25, 0, 27, 28, 0, 86, 01045 0, 0, 0, 0, 30, 31, 0, 87, 0, 0, 01046 0, 0, 0, 0, 0, 0, 34, 35, 0, 36, 01047 6, 37, 38, 39, 0, 0, 40, 240, 10, 11, 01048 0, 0, 14, 0, 16, 17, 0, 19, 176, 21, 01049 0, 0, 0, 0, 24, 25, 0, 27, 28, 0, 01050 86, 0, 0, 0, 0, 30, 31, 0, 87, 0, 01051 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 01052 36, 6, 37, 38, 39, 0, 0, 40, 0, 10, 01053 11, 0, 0, 14, 0, 16, 17, 0, 19, 0, 01054 21, 0, 0, 0, 0, 24, 25, 0, 27, 28, 01055 0, 86, 0, 0, 0, 0, 30, 31, 0, 87, 01056 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 01057 0, 36, 6, 37, 38, 39, 317, 0, 40, 0, 01058 10, 11, 0, 0, 14, 0, 16, 17, 0, 19, 01059 0, 21, 0, 0, 0, 0, 24, 25, 0, 27, 01060 28, 0, 86, 0, 0, 0, 0, 30, 31, 0, 01061 87, 10, 11, 0, 0, 14, 0, 16, 17, 34, 01062 35, 0, 36, 0, 37, 38, 39, 0, 0, 40, 01063 27, 28, 0, 86, 0, 0, 0, 0, 30, 31, 01064 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 01065 0, 0, 0, 36, 0, 0, 0, 39, 0, 0, 01066 40 01067 }; 01068 01069 static const yytype_int16 yycheck[] = 01070 { 01071 2, 95, 2, 18, 109, 7, 1, 7, 6, 1, 01072 296, 84, 85, 1, 292, 47, 1, 1, 50, 1, 01073 38, 19, 1, 21, 14, 98, 24, 25, 101, 0, 01074 32, 5, 12, 106, 9, 15, 34, 35, 13, 37, 01075 38, 327, 32, 33, 253, 35, 255, 22, 23, 39, 01076 144, 145, 146, 130, 49, 264, 265, 134, 48, 47, 01077 40, 138, 47, 47, 49, 49, 344, 49, 15, 43, 01078 6, 357, 31, 7, 66, 47, 362, 355, 66, 288, 01079 157, 158, 46, 19, 161, 21, 65, 31, 24, 25, 01080 14, 15, 51, 47, 66, 42, 77, 95, 34, 35, 01081 102, 37, 38, 37, 57, 58, 59, 51, 47, 47, 01082 47, 113, 66, 113, 94, 47, 97, 119, 42, 119, 01083 100, 330, 199, 37, 63, 63, 63, 38, 5, 109, 01084 110, 63, 38, 47, 211, 12, 30, 43, 44, 137, 01085 245, 139, 140, 141, 142, 143, 144, 145, 146, 147, 01086 148, 149, 150, 151, 152, 50, 47, 132, 263, 253, 01087 254, 255, 256, 257, 258, 259, 260, 261, 262, 52, 01088 264, 265, 63, 32, 33, 62, 35, 64, 65, 159, 01089 39, 196, 53, 163, 37, 38, 55, 56, 293, 48, 01090 43, 44, 32, 33, 288, 35, 54, 172, 40, 39, 01091 277, 32, 33, 41, 281, 28, 283, 48, 48, 192, 01092 62, 47, 64, 65, 150, 151, 152, 358, 359, 38, 01093 195, 204, 205, 148, 149, 50, 50, 38, 50, 38, 01094 47, 30, 52, 54, 40, 53, 330, 12, 38, 316, 01095 47, 14, 50, 48, 47, 46, 248, 38, 248, 10, 01096 323, 47, 50, 47, 4, 253, 254, 255, 256, 257, 01097 258, 259, 260, 261, 262, 245, 264, 265, 50, 38, 01098 272, 273, 272, 273, 46, 37, 50, 37, 339, 359, 01099 202, 291, 350, 263, 334, 197, 74, 137, 254, 256, 01100 288, 139, 257, 140, 143, 141, 258, 280, 142, 259, 01101 10, 10, 260, 286, 147, 212, 210, 212, -1, -1, 01102 -1, -1, -1, 293, -1, -1, 296, -1, -1, -1, 01103 -1, 336, 324, -1, 324, 308, -1, -1, -1, 331, 01104 313, 331, 330, -1, -1, -1, -1, -1, -1, -1, 01105 -1, 343, -1, 343, -1, 328, -1, 327, -1, -1, 01106 -1, 353, 332, 353, -1, -1, 358, 359, -1, -1, 01107 -1, -1, 364, -1, 364, -1, -1, 369, 370, 369, 01108 370, 1, -1, -1, -1, -1, -1, 357, 8, -1, 01109 363, -1, 362, -1, -1, 368, 16, 17, -1, -1, 01110 20, -1, 22, 23, -1, 25, -1, 27, -1, -1, 01111 -1, -1, 32, 33, 1, 35, 36, -1, 38, -1, 01112 -1, -1, -1, 43, 44, -1, 46, 14, 15, -1, 01113 -1, -1, -1, -1, -1, 55, 56, -1, 58, -1, 01114 60, 61, 62, 30, 31, 65, -1, -1, -1, 1, 01115 -1, -1, 39, 40, 41, 42, -1, -1, -1, -1, 01116 47, 48, 14, 15, 51, 52, 53, 54, -1, -1, 01117 57, -1, 59, -1, -1, -1, -1, 64, 30, 31, 01118 -1, -1, -1, -1, -1, -1, -1, 39, 40, 41, 01119 42, -1, -1, -1, -1, 47, 48, -1, -1, 51, 01120 52, 53, 54, 3, -1, 57, 6, 59, 8, 9, 01121 -1, 11, 64, 13, -1, -1, 16, 17, 18, 19, 01122 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 01123 -1, -1, 32, 33, 34, 35, 36, -1, 38, -1, 01124 -1, -1, -1, 43, 44, -1, 46, -1, -1, 49, 01125 -1, -1, -1, -1, -1, 55, 56, -1, 58, -1, 01126 60, 61, 62, 3, -1, 65, 6, -1, 8, 9, 01127 -1, 11, -1, 13, -1, -1, 16, 17, 18, 19, 01128 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 01129 -1, -1, 32, 33, -1, 35, 36, 37, 38, -1, 01130 -1, -1, -1, 43, 44, -1, 46, -1, -1, 49, 01131 -1, -1, -1, -1, -1, 55, 56, -1, 58, -1, 01132 60, 61, 62, 3, -1, 65, 6, -1, 8, 9, 01133 -1, 11, -1, 13, -1, -1, 16, 17, 18, 19, 01134 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 01135 -1, -1, 32, 33, -1, 35, 36, 37, 38, -1, 01136 -1, -1, -1, 43, 44, -1, 46, -1, -1, 49, 01137 -1, -1, -1, -1, -1, 55, 56, -1, 58, -1, 01138 60, 61, 62, 3, -1, 65, 6, -1, 8, 9, 01139 -1, 11, -1, 13, -1, -1, 16, 17, 18, 19, 01140 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 01141 -1, -1, 32, 33, -1, 35, 36, 37, 38, -1, 01142 -1, -1, -1, 43, 44, -1, 46, -1, -1, 49, 01143 -1, -1, -1, -1, -1, 55, 56, -1, 58, -1, 01144 60, 61, 62, 3, -1, 65, 6, -1, 8, 9, 01145 -1, 11, -1, 13, -1, -1, 16, 17, 18, 19, 01146 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 01147 -1, -1, 32, 33, -1, 35, 36, -1, 38, -1, 01148 -1, -1, -1, 43, 44, -1, 46, -1, -1, 49, 01149 -1, -1, -1, -1, -1, 55, 56, -1, 58, 8, 01150 60, 61, 62, -1, -1, 65, -1, 16, 17, -1, 01151 -1, 20, -1, 22, 23, -1, 25, -1, 27, -1, 01152 -1, -1, -1, 32, 33, -1, 35, 36, -1, 38, 01153 -1, -1, -1, -1, 43, 44, -1, 46, -1, -1, 01154 -1, -1, -1, -1, -1, -1, 55, 56, -1, 58, 01155 8, 60, 61, 62, -1, -1, 65, 66, 16, 17, 01156 -1, -1, 20, -1, 22, 23, -1, 25, 26, 27, 01157 -1, -1, -1, -1, 32, 33, -1, 35, 36, -1, 01158 38, -1, -1, -1, -1, 43, 44, -1, 46, -1, 01159 -1, -1, -1, -1, -1, -1, -1, 55, 56, -1, 01160 58, 8, 60, 61, 62, -1, -1, 65, -1, 16, 01161 17, -1, -1, 20, -1, 22, 23, -1, 25, -1, 01162 27, -1, -1, -1, -1, 32, 33, -1, 35, 36, 01163 -1, 38, -1, -1, -1, -1, 43, 44, -1, 46, 01164 -1, -1, -1, -1, -1, -1, -1, -1, 55, 56, 01165 -1, 58, 8, 60, 61, 62, 63, -1, 65, -1, 01166 16, 17, -1, -1, 20, -1, 22, 23, -1, 25, 01167 -1, 27, -1, -1, -1, -1, 32, 33, -1, 35, 01168 36, -1, 38, -1, -1, -1, -1, 43, 44, -1, 01169 46, 16, 17, -1, -1, 20, -1, 22, 23, 55, 01170 56, -1, 58, -1, 60, 61, 62, -1, -1, 65, 01171 35, 36, -1, 38, -1, -1, -1, -1, 43, 44, 01172 -1, 46, -1, -1, -1, -1, -1, -1, -1, -1, 01173 -1, -1, -1, 58, -1, -1, -1, 62, -1, -1, 01174 65 01175 }; 01176 01177 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 01178 symbol of state STATE-NUM. */ 01179 static const yytype_uint8 yystos[] = 01180 { 01181 0, 68, 70, 0, 3, 6, 8, 9, 11, 13, 01182 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 01183 26, 27, 28, 29, 32, 33, 34, 35, 36, 38, 01184 43, 44, 46, 49, 55, 56, 58, 60, 61, 62, 01185 65, 69, 71, 72, 76, 79, 80, 89, 90, 91, 01186 92, 97, 98, 99, 100, 101, 102, 108, 109, 114, 01187 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 01188 137, 138, 139, 140, 141, 142, 143, 144, 147, 148, 01189 152, 156, 157, 38, 155, 155, 38, 46, 71, 139, 01190 141, 76, 1, 65, 159, 159, 142, 143, 112, 114, 01191 159, 114, 46, 79, 139, 38, 81, 83, 139, 159, 01192 159, 139, 139, 50, 37, 38, 43, 44, 76, 77, 01193 153, 154, 139, 139, 139, 139, 47, 63, 149, 150, 01194 151, 114, 155, 1, 47, 49, 158, 31, 51, 30, 01195 52, 53, 54, 40, 14, 15, 42, 41, 55, 56, 01196 57, 58, 59, 32, 33, 35, 39, 48, 117, 62, 01197 64, 65, 145, 62, 64, 145, 158, 158, 37, 38, 01198 43, 44, 28, 1, 113, 114, 26, 115, 116, 119, 01199 121, 123, 125, 127, 129, 131, 133, 135, 136, 141, 01200 145, 158, 114, 158, 37, 5, 12, 110, 111, 48, 01201 85, 86, 47, 158, 113, 114, 76, 37, 76, 37, 01202 47, 50, 47, 63, 47, 63, 118, 66, 159, 118, 01203 124, 118, 126, 128, 130, 132, 134, 136, 136, 136, 01204 137, 138, 138, 139, 139, 139, 118, 118, 114, 38, 01205 66, 118, 146, 114, 38, 159, 1, 66, 160, 38, 01206 82, 84, 93, 47, 31, 51, 30, 52, 53, 54, 01207 40, 15, 42, 14, 48, 117, 160, 159, 79, 111, 01208 118, 83, 160, 160, 154, 118, 150, 151, 38, 74, 01209 75, 50, 63, 47, 66, 63, 113, 76, 48, 87, 01210 88, 47, 95, 14, 1, 49, 161, 119, 141, 125, 01211 119, 127, 129, 131, 133, 135, 136, 136, 113, 119, 01212 119, 46, 103, 38, 76, 76, 50, 63, 118, 47, 01213 160, 118, 118, 160, 10, 119, 84, 161, 113, 112, 01214 50, 160, 4, 104, 105, 106, 160, 118, 38, 46, 01215 158, 76, 112, 160, 94, 119, 76, 114, 7, 37, 01216 107, 106, 79, 70, 73, 96, 76, 161, 50, 50, 01217 104, 37, 161, 112, 77, 78, 78, 37, 112, 160, 01218 160, 76, 76 01219 }; 01220 01221 #define yyerrok (yyerrstatus = 0) 01222 #define yyclearin (yychar = YYEMPTY) 01223 #define YYEMPTY (-2) 01224 #define YYEOF 0 01225 01226 #define YYACCEPT goto yyacceptlab 01227 #define YYABORT goto yyabortlab 01228 #define YYERROR goto yyerrorlab 01229 01230 01231 /* Like YYERROR except do call yyerror. This remains here temporarily 01232 to ease the transition to the new meaning of YYERROR, for GCC. 01233 Once GCC version 2 has supplanted version 1, this can go. */ 01234 01235 #define YYFAIL goto yyerrlab 01236 01237 #define YYRECOVERING() (!!yyerrstatus) 01238 01239 #define YYBACKUP(Token, Value) \ 01240 do \ 01241 if (yychar == YYEMPTY && yylen == 1) \ 01242 { \ 01243 yychar = (Token); \ 01244 yylval = (Value); \ 01245 yytoken = YYTRANSLATE (yychar); \ 01246 YYPOPSTACK (1); \ 01247 goto yybackup; \ 01248 } \ 01249 else \ 01250 { \ 01251 yyerror (YY_("syntax error: cannot back up")); \ 01252 YYERROR; \ 01253 } \ 01254 while (YYID (0)) 01255 01256 01257 #define YYTERROR 1 01258 #define YYERRCODE 256 01259 01260 01261 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 01262 If N is 0, then set CURRENT to the empty location which ends 01263 the previous symbol: RHS[0] (always defined). */ 01264 01265 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 01266 #ifndef YYLLOC_DEFAULT 01267 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 01268 do \ 01269 if (YYID (N)) \ 01270 { \ 01271 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 01272 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 01273 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 01274 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 01275 } \ 01276 else \ 01277 { \ 01278 (Current).first_line = (Current).last_line = \ 01279 YYRHSLOC (Rhs, 0).last_line; \ 01280 (Current).first_column = (Current).last_column = \ 01281 YYRHSLOC (Rhs, 0).last_column; \ 01282 } \ 01283 while (YYID (0)) 01284 #endif 01285 01286 01287 /* YY_LOCATION_PRINT -- Print the location on the stream. 01288 This macro was not mandated originally: define only if we know 01289 we won't break user code: when these are the locations we know. */ 01290 01291 #ifndef YY_LOCATION_PRINT 01292 # if YYLTYPE_IS_TRIVIAL 01293 # define YY_LOCATION_PRINT(File, Loc) \ 01294 fprintf (File, "%d.%d-%d.%d", \ 01295 (Loc).first_line, (Loc).first_column, \ 01296 (Loc).last_line, (Loc).last_column) 01297 # else 01298 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 01299 # endif 01300 #endif 01301 01302 01303 /* YYLEX -- calling `yylex' with the right arguments. */ 01304 01305 #ifdef YYLEX_PARAM 01306 # define YYLEX yylex (&yylval, YYLEX_PARAM) 01307 #else 01308 # define YYLEX yylex (&yylval) 01309 #endif 01310 01311 /* Enable debugging if requested. */ 01312 #if YYDEBUG 01313 01314 # ifndef YYFPRINTF 01315 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 01316 # define YYFPRINTF fprintf 01317 # endif 01318 01319 # define YYDPRINTF(Args) \ 01320 do { \ 01321 if (yydebug) \ 01322 YYFPRINTF Args; \ 01323 } while (YYID (0)) 01324 01325 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 01326 do { \ 01327 if (yydebug) \ 01328 { \ 01329 YYFPRINTF (stderr, "%s ", Title); \ 01330 yy_symbol_print (stderr, \ 01331 Type, Value); \ 01332 YYFPRINTF (stderr, "\n"); \ 01333 } \ 01334 } while (YYID (0)) 01335 01336 01337 /*--------------------------------. 01338 | Print this symbol on YYOUTPUT. | 01339 `--------------------------------*/ 01340 01341 /*ARGSUSED*/ 01342 #if (defined __STDC__ || defined __C99__FUNC__ \ 01343 || defined __cplusplus || defined _MSC_VER) 01344 static void 01345 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01346 #else 01347 static void 01348 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 01349 FILE *yyoutput; 01350 int yytype; 01351 YYSTYPE const * const yyvaluep; 01352 #endif 01353 { 01354 if (!yyvaluep) 01355 return; 01356 # ifdef YYPRINT 01357 if (yytype < YYNTOKENS) 01358 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 01359 # else 01360 YYUSE (yyoutput); 01361 # endif 01362 switch (yytype) 01363 { 01364 default: 01365 break; 01366 } 01367 } 01368 01369 01370 /*--------------------------------. 01371 | Print this symbol on YYOUTPUT. | 01372 `--------------------------------*/ 01373 01374 #if (defined __STDC__ || defined __C99__FUNC__ \ 01375 || defined __cplusplus || defined _MSC_VER) 01376 static void 01377 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01378 #else 01379 static void 01380 yy_symbol_print (yyoutput, yytype, yyvaluep) 01381 FILE *yyoutput; 01382 int yytype; 01383 YYSTYPE const * const yyvaluep; 01384 #endif 01385 { 01386 if (yytype < YYNTOKENS) 01387 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 01388 else 01389 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 01390 01391 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 01392 YYFPRINTF (yyoutput, ")"); 01393 } 01394 01395 /*------------------------------------------------------------------. 01396 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 01397 | TOP (included). | 01398 `------------------------------------------------------------------*/ 01399 01400 #if (defined __STDC__ || defined __C99__FUNC__ \ 01401 || defined __cplusplus || defined _MSC_VER) 01402 static void 01403 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 01404 #else 01405 static void 01406 yy_stack_print (yybottom, yytop) 01407 yytype_int16 *yybottom; 01408 yytype_int16 *yytop; 01409 #endif 01410 { 01411 YYFPRINTF (stderr, "Stack now"); 01412 for (; yybottom <= yytop; yybottom++) 01413 { 01414 int yybot = *yybottom; 01415 YYFPRINTF (stderr, " %d", yybot); 01416 } 01417 YYFPRINTF (stderr, "\n"); 01418 } 01419 01420 # define YY_STACK_PRINT(Bottom, Top) \ 01421 do { \ 01422 if (yydebug) \ 01423 yy_stack_print ((Bottom), (Top)); \ 01424 } while (YYID (0)) 01425 01426 01427 /*------------------------------------------------. 01428 | Report that the YYRULE is going to be reduced. | 01429 `------------------------------------------------*/ 01430 01431 #if (defined __STDC__ || defined __C99__FUNC__ \ 01432 || defined __cplusplus || defined _MSC_VER) 01433 static void 01434 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 01435 #else 01436 static void 01437 yy_reduce_print (yyvsp, yyrule) 01438 YYSTYPE *yyvsp; 01439 int yyrule; 01440 #endif 01441 { 01442 int yynrhs = yyr2[yyrule]; 01443 int yyi; 01444 unsigned long int yylno = yyrline[yyrule]; 01445 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 01446 yyrule - 1, yylno); 01447 /* The symbols being reduced. */ 01448 for (yyi = 0; yyi < yynrhs; yyi++) 01449 { 01450 YYFPRINTF (stderr, " $%d = ", yyi + 1); 01451 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 01452 &(yyvsp[(yyi + 1) - (yynrhs)]) 01453 ); 01454 YYFPRINTF (stderr, "\n"); 01455 } 01456 } 01457 01458 # define YY_REDUCE_PRINT(Rule) \ 01459 do { \ 01460 if (yydebug) \ 01461 yy_reduce_print (yyvsp, Rule); \ 01462 } while (YYID (0)) 01463 01464 /* Nonzero means print parse trace. It is left uninitialized so that 01465 multiple parsers can coexist. */ 01466 int yydebug; 01467 #else /* !YYDEBUG */ 01468 # define YYDPRINTF(Args) 01469 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 01470 # define YY_STACK_PRINT(Bottom, Top) 01471 # define YY_REDUCE_PRINT(Rule) 01472 #endif /* !YYDEBUG */ 01473 01474 01475 /* YYINITDEPTH -- initial size of the parser's stacks. */ 01476 #ifndef YYINITDEPTH 01477 # define YYINITDEPTH 200 01478 #endif 01479 01480 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 01481 if the built-in stack extension method is used). 01482 01483 Do not make this value too large; the results are undefined if 01484 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 01485 evaluated with infinite-precision integer arithmetic. */ 01486 01487 #ifndef YYMAXDEPTH 01488 # define YYMAXDEPTH 10000 01489 #endif 01490 01491 01492 01493 #if YYERROR_VERBOSE 01494 01495 # ifndef yystrlen 01496 # if defined __GLIBC__ && defined _STRING_H 01497 # define yystrlen strlen 01498 # else 01499 /* Return the length of YYSTR. */ 01500 #if (defined __STDC__ || defined __C99__FUNC__ \ 01501 || defined __cplusplus || defined _MSC_VER) 01502 static YYSIZE_T 01503 yystrlen (const char *yystr) 01504 #else 01505 static YYSIZE_T 01506 yystrlen (yystr) 01507 const char *yystr; 01508 #endif 01509 { 01510 YYSIZE_T yylen; 01511 for (yylen = 0; yystr[yylen]; yylen++) 01512 continue; 01513 return yylen; 01514 } 01515 # endif 01516 # endif 01517 01518 # ifndef yystpcpy 01519 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 01520 # define yystpcpy stpcpy 01521 # else 01522 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 01523 YYDEST. */ 01524 #if (defined __STDC__ || defined __C99__FUNC__ \ 01525 || defined __cplusplus || defined _MSC_VER) 01526 static char * 01527 yystpcpy (char *yydest, const char *yysrc) 01528 #else 01529 static char * 01530 yystpcpy (yydest, yysrc) 01531 char *yydest; 01532 const char *yysrc; 01533 #endif 01534 { 01535 char *yyd = yydest; 01536 const char *yys = yysrc; 01537 01538 while ((*yyd++ = *yys++) != '\0') 01539 continue; 01540 01541 return yyd - 1; 01542 } 01543 # endif 01544 # endif 01545 01546 # ifndef yytnamerr 01547 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 01548 quotes and backslashes, so that it's suitable for yyerror. The 01549 heuristic is that double-quoting is unnecessary unless the string 01550 contains an apostrophe, a comma, or backslash (other than 01551 backslash-backslash). YYSTR is taken from yytname. If YYRES is 01552 null, do not copy; instead, return the length of what the result 01553 would have been. */ 01554 static YYSIZE_T 01555 yytnamerr (char *yyres, const char *yystr) 01556 { 01557 if (*yystr == '"') 01558 { 01559 YYSIZE_T yyn = 0; 01560 char const *yyp = yystr; 01561 01562 for (;;) 01563 switch (*++yyp) 01564 { 01565 case '\'': 01566 case ',': 01567 goto do_not_strip_quotes; 01568 01569 case '\\': 01570 if (*++yyp != '\\') 01571 goto do_not_strip_quotes; 01572 /* Fall through. */ 01573 default: 01574 if (yyres) 01575 yyres[yyn] = *yyp; 01576 yyn++; 01577 break; 01578 01579 case '"': 01580 if (yyres) 01581 yyres[yyn] = '\0'; 01582 return yyn; 01583 } 01584 do_not_strip_quotes: ; 01585 } 01586 01587 if (! yyres) 01588 return yystrlen (yystr); 01589 01590 return yystpcpy (yyres, yystr) - yyres; 01591 } 01592 # endif 01593 01594 /* Copy into YYRESULT an error message about the unexpected token 01595 YYCHAR while in state YYSTATE. Return the number of bytes copied, 01596 including the terminating null byte. If YYRESULT is null, do not 01597 copy anything; just return the number of bytes that would be 01598 copied. As a special case, return 0 if an ordinary "syntax error" 01599 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 01600 size calculation. */ 01601 static YYSIZE_T 01602 yysyntax_error (char *yyresult, int yystate, int yychar) 01603 { 01604 int yyn = yypact[yystate]; 01605 01606 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 01607 return 0; 01608 else 01609 { 01610 int yytype = YYTRANSLATE (yychar); 01611 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 01612 YYSIZE_T yysize = yysize0; 01613 YYSIZE_T yysize1; 01614 int yysize_overflow = 0; 01615 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 01616 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 01617 int yyx; 01618 01619 # if 0 01620 /* This is so xgettext sees the translatable formats that are 01621 constructed on the fly. */ 01622 YY_("syntax error, unexpected %s"); 01623 YY_("syntax error, unexpected %s, expecting %s"); 01624 YY_("syntax error, unexpected %s, expecting %s or %s"); 01625 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 01626 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 01627 # endif 01628 char *yyfmt; 01629 char const *yyf; 01630 static char const yyunexpected[] = "syntax error, unexpected %s"; 01631 static char const yyexpecting[] = ", expecting %s"; 01632 static char const yyor[] = " or %s"; 01633 char yyformat[sizeof yyunexpected 01634 + sizeof yyexpecting - 1 01635 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 01636 * (sizeof yyor - 1))]; 01637 char const *yyprefix = yyexpecting; 01638 01639 /* Start YYX at -YYN if negative to avoid negative indexes in 01640 YYCHECK. */ 01641 int yyxbegin = yyn < 0 ? -yyn : 0; 01642 01643 /* Stay within bounds of both yycheck and yytname. */ 01644 int yychecklim = YYLAST - yyn + 1; 01645 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 01646 int yycount = 1; 01647 01648 yyarg[0] = yytname[yytype]; 01649 yyfmt = yystpcpy (yyformat, yyunexpected); 01650 01651 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 01652 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 01653 { 01654 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 01655 { 01656 yycount = 1; 01657 yysize = yysize0; 01658 yyformat[sizeof yyunexpected - 1] = '\0'; 01659 break; 01660 } 01661 yyarg[yycount++] = yytname[yyx]; 01662 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 01663 yysize_overflow |= (yysize1 < yysize); 01664 yysize = yysize1; 01665 yyfmt = yystpcpy (yyfmt, yyprefix); 01666 yyprefix = yyor; 01667 } 01668 01669 yyf = YY_(yyformat); 01670 yysize1 = yysize + yystrlen (yyf); 01671 yysize_overflow |= (yysize1 < yysize); 01672 yysize = yysize1; 01673 01674 if (yysize_overflow) 01675 return YYSIZE_MAXIMUM; 01676 01677 if (yyresult) 01678 { 01679 /* Avoid sprintf, as that infringes on the user's name space. 01680 Don't have undefined behavior even if the translation 01681 produced a string with the wrong number of "%s"s. */ 01682 char *yyp = yyresult; 01683 int yyi = 0; 01684 while ((*yyp = *yyf) != '\0') 01685 { 01686 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 01687 { 01688 yyp += yytnamerr (yyp, yyarg[yyi++]); 01689 yyf += 2; 01690 } 01691 else 01692 { 01693 yyp++; 01694 yyf++; 01695 } 01696 } 01697 } 01698 return yysize; 01699 } 01700 } 01701 #endif /* YYERROR_VERBOSE */ 01702 01703 01704 /*-----------------------------------------------. 01705 | Release the memory associated to this symbol. | 01706 `-----------------------------------------------*/ 01707 01708 /*ARGSUSED*/ 01709 #if (defined __STDC__ || defined __C99__FUNC__ \ 01710 || defined __cplusplus || defined _MSC_VER) 01711 static void 01712 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 01713 #else 01714 static void 01715 yydestruct (yymsg, yytype, yyvaluep) 01716 const char *yymsg; 01717 int yytype; 01718 YYSTYPE *yyvaluep; 01719 #endif 01720 { 01721 YYUSE (yyvaluep); 01722 01723 if (!yymsg) 01724 yymsg = "Deleting"; 01725 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01726 01727 switch (yytype) 01728 { 01729 01730 default: 01731 break; 01732 } 01733 } 01734 01735 /* Prevent warnings from -Wmissing-prototypes. */ 01736 #ifdef YYPARSE_PARAM 01737 #if defined __STDC__ || defined __cplusplus 01738 int yyparse (void *YYPARSE_PARAM); 01739 #else 01740 int yyparse (); 01741 #endif 01742 #else /* ! YYPARSE_PARAM */ 01743 #if defined __STDC__ || defined __cplusplus 01744 int yyparse (void); 01745 #else 01746 int yyparse (); 01747 #endif 01748 #endif /* ! YYPARSE_PARAM */ 01749 01750 01751 01752 01753 01754 /*-------------------------. 01755 | yyparse or yypush_parse. | 01756 `-------------------------*/ 01757 01758 #ifdef YYPARSE_PARAM 01759 #if (defined __STDC__ || defined __C99__FUNC__ \ 01760 || defined __cplusplus || defined _MSC_VER) 01761 int 01762 yyparse (void *YYPARSE_PARAM) 01763 #else 01764 int 01765 yyparse (YYPARSE_PARAM) 01766 void *YYPARSE_PARAM; 01767 #endif 01768 #else /* ! YYPARSE_PARAM */ 01769 #if (defined __STDC__ || defined __C99__FUNC__ \ 01770 || defined __cplusplus || defined _MSC_VER) 01771 int 01772 yyparse (void) 01773 #else 01774 int 01775 yyparse () 01776 01777 #endif 01778 #endif 01779 { 01780 /* The lookahead symbol. */ 01781 int yychar; 01782 01783 /* The semantic value of the lookahead symbol. */ 01784 YYSTYPE yylval; 01785 01786 /* Number of syntax errors so far. */ 01787 int yynerrs; 01788 01789 int yystate; 01790 /* Number of tokens to shift before error messages enabled. */ 01791 int yyerrstatus; 01792 01793 /* The stacks and their tools: 01794 `yyss': related to states. 01795 `yyvs': related to semantic values. 01796 01797 Refer to the stacks thru separate pointers, to allow yyoverflow 01798 to reallocate them elsewhere. */ 01799 01800 /* The state stack. */ 01801 yytype_int16 yyssa[YYINITDEPTH]; 01802 yytype_int16 *yyss; 01803 yytype_int16 *yyssp; 01804 01805 /* The semantic value stack. */ 01806 YYSTYPE yyvsa[YYINITDEPTH]; 01807 YYSTYPE *yyvs; 01808 YYSTYPE *yyvsp; 01809 01810 YYSIZE_T yystacksize; 01811 01812 int yyn; 01813 int yyresult; 01814 /* Lookahead token as an internal (translated) token number. */ 01815 int yytoken; 01816 /* The variables used to return semantic value and location from the 01817 action routines. */ 01818 YYSTYPE yyval; 01819 01820 #if YYERROR_VERBOSE 01821 /* Buffer for error messages, and its allocated size. */ 01822 char yymsgbuf[128]; 01823 char *yymsg = yymsgbuf; 01824 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 01825 #endif 01826 01827 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 01828 01829 /* The number of symbols on the RHS of the reduced rule. 01830 Keep to zero when no symbol should be popped. */ 01831 int yylen = 0; 01832 01833 yytoken = 0; 01834 yyss = yyssa; 01835 yyvs = yyvsa; 01836 yystacksize = YYINITDEPTH; 01837 01838 YYDPRINTF ((stderr, "Starting parse\n")); 01839 01840 yystate = 0; 01841 yyerrstatus = 0; 01842 yynerrs = 0; 01843 yychar = YYEMPTY; /* Cause a token to be read. */ 01844 01845 /* Initialize stack pointers. 01846 Waste one element of value and location stack 01847 so that they stay on the same level as the state stack. 01848 The wasted elements are never initialized. */ 01849 yyssp = yyss; 01850 yyvsp = yyvs; 01851 01852 goto yysetstate; 01853 01854 /*------------------------------------------------------------. 01855 | yynewstate -- Push a new state, which is found in yystate. | 01856 `------------------------------------------------------------*/ 01857 yynewstate: 01858 /* In all cases, when you get here, the value and location stacks 01859 have just been pushed. So pushing a state here evens the stacks. */ 01860 yyssp++; 01861 01862 yysetstate: 01863 *yyssp = yystate; 01864 01865 if (yyss + yystacksize - 1 <= yyssp) 01866 { 01867 /* Get the current used size of the three stacks, in elements. */ 01868 YYSIZE_T yysize = yyssp - yyss + 1; 01869 01870 #ifdef yyoverflow 01871 { 01872 /* Give user a chance to reallocate the stack. Use copies of 01873 these so that the &'s don't force the real ones into 01874 memory. */ 01875 YYSTYPE *yyvs1 = yyvs; 01876 yytype_int16 *yyss1 = yyss; 01877 01878 /* Each stack pointer address is followed by the size of the 01879 data in use in that stack, in bytes. This used to be a 01880 conditional around just the two extra args, but that might 01881 be undefined if yyoverflow is a macro. */ 01882 yyoverflow (YY_("memory exhausted"), 01883 &yyss1, yysize * sizeof (*yyssp), 01884 &yyvs1, yysize * sizeof (*yyvsp), 01885 &yystacksize); 01886 01887 yyss = yyss1; 01888 yyvs = yyvs1; 01889 } 01890 #else /* no yyoverflow */ 01891 # ifndef YYSTACK_RELOCATE 01892 goto yyexhaustedlab; 01893 # else 01894 /* Extend the stack our own way. */ 01895 if (YYMAXDEPTH <= yystacksize) 01896 goto yyexhaustedlab; 01897 yystacksize *= 2; 01898 if (YYMAXDEPTH < yystacksize) 01899 yystacksize = YYMAXDEPTH; 01900 01901 { 01902 yytype_int16 *yyss1 = yyss; 01903 union yyalloc *yyptr = 01904 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 01905 if (! yyptr) 01906 goto yyexhaustedlab; 01907 YYSTACK_RELOCATE (yyss_alloc, yyss); 01908 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 01909 # undef YYSTACK_RELOCATE 01910 if (yyss1 != yyssa) 01911 YYSTACK_FREE (yyss1); 01912 } 01913 # endif 01914 #endif /* no yyoverflow */ 01915 01916 yyssp = yyss + yysize - 1; 01917 yyvsp = yyvs + yysize - 1; 01918 01919 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 01920 (unsigned long int) yystacksize)); 01921 01922 if (yyss + yystacksize - 1 <= yyssp) 01923 YYABORT; 01924 } 01925 01926 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 01927 01928 if (yystate == YYFINAL) 01929 YYACCEPT; 01930 01931 goto yybackup; 01932 01933 /*-----------. 01934 | yybackup. | 01935 `-----------*/ 01936 yybackup: 01937 01938 /* Do appropriate processing given the current state. Read a 01939 lookahead token if we need one and don't already have one. */ 01940 01941 /* First try to decide what to do without reference to lookahead token. */ 01942 yyn = yypact[yystate]; 01943 if (yyn == YYPACT_NINF) 01944 goto yydefault; 01945 01946 /* Not known => get a lookahead token if don't already have one. */ 01947 01948 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 01949 if (yychar == YYEMPTY) 01950 { 01951 YYDPRINTF ((stderr, "Reading a token: ")); 01952 yychar = YYLEX; 01953 } 01954 01955 if (yychar <= YYEOF) 01956 { 01957 yychar = yytoken = YYEOF; 01958 YYDPRINTF ((stderr, "Now at end of input.\n")); 01959 } 01960 else 01961 { 01962 yytoken = YYTRANSLATE (yychar); 01963 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 01964 } 01965 01966 /* If the proper action on seeing token YYTOKEN is to reduce or to 01967 detect an error, take that action. */ 01968 yyn += yytoken; 01969 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 01970 goto yydefault; 01971 yyn = yytable[yyn]; 01972 if (yyn <= 0) 01973 { 01974 if (yyn == 0 || yyn == YYTABLE_NINF) 01975 goto yyerrlab; 01976 yyn = -yyn; 01977 goto yyreduce; 01978 } 01979 01980 /* Count tokens shifted since error; after three, turn off error 01981 status. */ 01982 if (yyerrstatus) 01983 yyerrstatus--; 01984 01985 /* Shift the lookahead token. */ 01986 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 01987 01988 /* Discard the shifted token. */ 01989 yychar = YYEMPTY; 01990 01991 yystate = yyn; 01992 *++yyvsp = yylval; 01993 01994 goto yynewstate; 01995 01996 01997 /*-----------------------------------------------------------. 01998 | yydefault -- do the default action for the current state. | 01999 `-----------------------------------------------------------*/ 02000 yydefault: 02001 yyn = yydefact[yystate]; 02002 if (yyn == 0) 02003 goto yyerrlab; 02004 goto yyreduce; 02005 02006 02007 /*-----------------------------. 02008 | yyreduce -- Do a reduction. | 02009 `-----------------------------*/ 02010 yyreduce: 02011 /* yyn is the number of a rule to reduce with. */ 02012 yylen = yyr2[yyn]; 02013 02014 /* If YYLEN is nonzero, implement the default value of the action: 02015 `$$ = $1'. 02016 02017 Otherwise, the following line sets YYVAL to garbage. 02018 This behavior is undocumented and Bison 02019 users should not rely upon it. Assigning to YYVAL 02020 unconditionally makes the parser a bit smaller, and it avoids a 02021 GCC warning that YYVAL may be used uninitialized. */ 02022 yyval = yyvsp[1-yylen]; 02023 02024 02025 YY_REDUCE_PRINT (yyn); 02026 switch (yyn) 02027 { 02028 case 2: 02029 02030 /* Line 1455 of yacc.c */ 02031 #line 257 "parser.y" 02032 { program_parsed(ctx, (yyvsp[(1) - (2)].source_elements)); ;} 02033 break; 02034 02035 case 3: 02036 02037 /* Line 1455 of yacc.c */ 02038 #line 260 "parser.y" 02039 {;} 02040 break; 02041 02042 case 4: 02043 02044 /* Line 1455 of yacc.c */ 02045 #line 261 "parser.y" 02046 {;} 02047 break; 02048 02049 case 5: 02050 02051 /* Line 1455 of yacc.c */ 02052 #line 265 "parser.y" 02053 { (yyval.source_elements) = new_source_elements(ctx); ;} 02054 break; 02055 02056 case 6: 02057 02058 /* Line 1455 of yacc.c */ 02059 #line 267 "parser.y" 02060 { (yyval.source_elements) = source_elements_add_statement((yyvsp[(1) - (2)].source_elements), (yyvsp[(2) - (2)].statement)); ;} 02061 break; 02062 02063 case 7: 02064 02065 /* Line 1455 of yacc.c */ 02066 #line 272 "parser.y" 02067 { (yyval.expr) = new_function_expression(ctx, (yyvsp[(2) - (8)].identifier), (yyvsp[(4) - (8)].parameter_list), (yyvsp[(7) - (8)].source_elements), (yyvsp[(1) - (8)].srcptr), (yyvsp[(8) - (8)].srcptr)-(yyvsp[(1) - (8)].srcptr)+1); ;} 02068 break; 02069 02070 case 8: 02071 02072 /* Line 1455 of yacc.c */ 02073 #line 275 "parser.y" 02074 { push_func(ctx); (yyval.srcptr) = (yyvsp[(1) - (1)].srcptr); ;} 02075 break; 02076 02077 case 9: 02078 02079 /* Line 1455 of yacc.c */ 02080 #line 279 "parser.y" 02081 { (yyval.source_elements) = function_body_parsed(ctx, (yyvsp[(1) - (1)].source_elements)); ;} 02082 break; 02083 02084 case 10: 02085 02086 /* Line 1455 of yacc.c */ 02087 #line 283 "parser.y" 02088 { (yyval.parameter_list) = new_parameter_list(ctx, (yyvsp[(1) - (1)].identifier)); ;} 02089 break; 02090 02091 case 11: 02092 02093 /* Line 1455 of yacc.c */ 02094 #line 285 "parser.y" 02095 { (yyval.parameter_list) = parameter_list_add(ctx, (yyvsp[(1) - (3)].parameter_list), (yyvsp[(3) - (3)].identifier)); ;} 02096 break; 02097 02098 case 12: 02099 02100 /* Line 1455 of yacc.c */ 02101 #line 289 "parser.y" 02102 { (yyval.parameter_list) = NULL; ;} 02103 break; 02104 02105 case 13: 02106 02107 /* Line 1455 of yacc.c */ 02108 #line 290 "parser.y" 02109 { (yyval.parameter_list) = (yyvsp[(1) - (1)].parameter_list); ;} 02110 break; 02111 02112 case 14: 02113 02114 /* Line 1455 of yacc.c */ 02115 #line 294 "parser.y" 02116 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02117 break; 02118 02119 case 15: 02120 02121 /* Line 1455 of yacc.c */ 02122 #line 295 "parser.y" 02123 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02124 break; 02125 02126 case 16: 02127 02128 /* Line 1455 of yacc.c */ 02129 #line 296 "parser.y" 02130 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02131 break; 02132 02133 case 17: 02134 02135 /* Line 1455 of yacc.c */ 02136 #line 297 "parser.y" 02137 { (yyval.statement) = new_empty_statement(ctx); ;} 02138 break; 02139 02140 case 18: 02141 02142 /* Line 1455 of yacc.c */ 02143 #line 298 "parser.y" 02144 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02145 break; 02146 02147 case 19: 02148 02149 /* Line 1455 of yacc.c */ 02150 #line 299 "parser.y" 02151 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02152 break; 02153 02154 case 20: 02155 02156 /* Line 1455 of yacc.c */ 02157 #line 300 "parser.y" 02158 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02159 break; 02160 02161 case 21: 02162 02163 /* Line 1455 of yacc.c */ 02164 #line 301 "parser.y" 02165 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02166 break; 02167 02168 case 22: 02169 02170 /* Line 1455 of yacc.c */ 02171 #line 302 "parser.y" 02172 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02173 break; 02174 02175 case 23: 02176 02177 /* Line 1455 of yacc.c */ 02178 #line 303 "parser.y" 02179 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02180 break; 02181 02182 case 24: 02183 02184 /* Line 1455 of yacc.c */ 02185 #line 304 "parser.y" 02186 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02187 break; 02188 02189 case 25: 02190 02191 /* Line 1455 of yacc.c */ 02192 #line 305 "parser.y" 02193 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02194 break; 02195 02196 case 26: 02197 02198 /* Line 1455 of yacc.c */ 02199 #line 306 "parser.y" 02200 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02201 break; 02202 02203 case 27: 02204 02205 /* Line 1455 of yacc.c */ 02206 #line 307 "parser.y" 02207 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02208 break; 02209 02210 case 28: 02211 02212 /* Line 1455 of yacc.c */ 02213 #line 308 "parser.y" 02214 { (yyval.statement) = (yyvsp[(1) - (1)].statement); ;} 02215 break; 02216 02217 case 29: 02218 02219 /* Line 1455 of yacc.c */ 02220 #line 312 "parser.y" 02221 { (yyval.statement_list) = new_statement_list(ctx, (yyvsp[(1) - (1)].statement)); ;} 02222 break; 02223 02224 case 30: 02225 02226 /* Line 1455 of yacc.c */ 02227 #line 314 "parser.y" 02228 { (yyval.statement_list) = statement_list_add((yyvsp[(1) - (2)].statement_list), (yyvsp[(2) - (2)].statement)); ;} 02229 break; 02230 02231 case 31: 02232 02233 /* Line 1455 of yacc.c */ 02234 #line 318 "parser.y" 02235 { (yyval.statement_list) = NULL; ;} 02236 break; 02237 02238 case 32: 02239 02240 /* Line 1455 of yacc.c */ 02241 #line 319 "parser.y" 02242 { (yyval.statement_list) = (yyvsp[(1) - (1)].statement_list); ;} 02243 break; 02244 02245 case 33: 02246 02247 /* Line 1455 of yacc.c */ 02248 #line 323 "parser.y" 02249 { (yyval.statement) = new_block_statement(ctx, (yyvsp[(2) - (3)].statement_list)); ;} 02250 break; 02251 02252 case 34: 02253 02254 /* Line 1455 of yacc.c */ 02255 #line 324 "parser.y" 02256 { (yyval.statement) = new_block_statement(ctx, NULL); ;} 02257 break; 02258 02259 case 35: 02260 02261 /* Line 1455 of yacc.c */ 02262 #line 329 "parser.y" 02263 { (yyval.statement) = new_var_statement(ctx, (yyvsp[(2) - (3)].variable_list)); ;} 02264 break; 02265 02266 case 36: 02267 02268 /* Line 1455 of yacc.c */ 02269 #line 333 "parser.y" 02270 { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[(1) - (1)].variable_declaration)); ;} 02271 break; 02272 02273 case 37: 02274 02275 /* Line 1455 of yacc.c */ 02276 #line 335 "parser.y" 02277 { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[(1) - (3)].variable_list), (yyvsp[(3) - (3)].variable_declaration)); ;} 02278 break; 02279 02280 case 38: 02281 02282 /* Line 1455 of yacc.c */ 02283 #line 340 "parser.y" 02284 { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[(1) - (1)].variable_declaration)); ;} 02285 break; 02286 02287 case 39: 02288 02289 /* Line 1455 of yacc.c */ 02290 #line 342 "parser.y" 02291 { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[(1) - (3)].variable_list), (yyvsp[(3) - (3)].variable_declaration)); ;} 02292 break; 02293 02294 case 40: 02295 02296 /* Line 1455 of yacc.c */ 02297 #line 347 "parser.y" 02298 { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[(1) - (2)].identifier), (yyvsp[(2) - (2)].expr)); ;} 02299 break; 02300 02301 case 41: 02302 02303 /* Line 1455 of yacc.c */ 02304 #line 352 "parser.y" 02305 { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[(1) - (2)].identifier), (yyvsp[(2) - (2)].expr)); ;} 02306 break; 02307 02308 case 42: 02309 02310 /* Line 1455 of yacc.c */ 02311 #line 356 "parser.y" 02312 { (yyval.expr) = NULL; ;} 02313 break; 02314 02315 case 43: 02316 02317 /* Line 1455 of yacc.c */ 02318 #line 357 "parser.y" 02319 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02320 break; 02321 02322 case 44: 02323 02324 /* Line 1455 of yacc.c */ 02325 #line 362 "parser.y" 02326 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;} 02327 break; 02328 02329 case 45: 02330 02331 /* Line 1455 of yacc.c */ 02332 #line 366 "parser.y" 02333 { (yyval.expr) = NULL; ;} 02334 break; 02335 02336 case 46: 02337 02338 /* Line 1455 of yacc.c */ 02339 #line 367 "parser.y" 02340 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02341 break; 02342 02343 case 47: 02344 02345 /* Line 1455 of yacc.c */ 02346 #line 372 "parser.y" 02347 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;} 02348 break; 02349 02350 case 48: 02351 02352 /* Line 1455 of yacc.c */ 02353 #line 376 "parser.y" 02354 { (yyval.statement) = new_empty_statement(ctx); ;} 02355 break; 02356 02357 case 49: 02358 02359 /* Line 1455 of yacc.c */ 02360 #line 381 "parser.y" 02361 { (yyval.statement) = new_expression_statement(ctx, (yyvsp[(1) - (2)].expr)); ;} 02362 break; 02363 02364 case 50: 02365 02366 /* Line 1455 of yacc.c */ 02367 #line 386 "parser.y" 02368 { (yyval.statement) = new_if_statement(ctx, (yyvsp[(3) - (7)].expr), (yyvsp[(5) - (7)].statement), (yyvsp[(7) - (7)].statement)); ;} 02369 break; 02370 02371 case 51: 02372 02373 /* Line 1455 of yacc.c */ 02374 #line 388 "parser.y" 02375 { (yyval.statement) = new_if_statement(ctx, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].statement), NULL); ;} 02376 break; 02377 02378 case 52: 02379 02380 /* Line 1455 of yacc.c */ 02381 #line 393 "parser.y" 02382 { (yyval.statement) = new_while_statement(ctx, TRUE, (yyvsp[(5) - (7)].expr), (yyvsp[(2) - (7)].statement)); ;} 02383 break; 02384 02385 case 53: 02386 02387 /* Line 1455 of yacc.c */ 02388 #line 395 "parser.y" 02389 { (yyval.statement) = new_while_statement(ctx, FALSE, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].statement)); ;} 02390 break; 02391 02392 case 54: 02393 02394 /* Line 1455 of yacc.c */ 02395 #line 397 "parser.y" 02396 { if(!explicit_error(ctx, (yyvsp[(3) - (3)].expr), ';')) YYABORT; ;} 02397 break; 02398 02399 case 55: 02400 02401 /* Line 1455 of yacc.c */ 02402 #line 399 "parser.y" 02403 { if(!explicit_error(ctx, (yyvsp[(6) - (6)].expr), ';')) YYABORT; ;} 02404 break; 02405 02406 case 56: 02407 02408 /* Line 1455 of yacc.c */ 02409 #line 401 "parser.y" 02410 { (yyval.statement) = new_for_statement(ctx, NULL, (yyvsp[(3) - (11)].expr), (yyvsp[(6) - (11)].expr), (yyvsp[(9) - (11)].expr), (yyvsp[(11) - (11)].statement)); ;} 02411 break; 02412 02413 case 57: 02414 02415 /* Line 1455 of yacc.c */ 02416 #line 403 "parser.y" 02417 { if(!explicit_error(ctx, (yyvsp[(4) - (4)].variable_list), ';')) YYABORT; ;} 02418 break; 02419 02420 case 58: 02421 02422 /* Line 1455 of yacc.c */ 02423 #line 405 "parser.y" 02424 { if(!explicit_error(ctx, (yyvsp[(7) - (7)].expr), ';')) YYABORT; ;} 02425 break; 02426 02427 case 59: 02428 02429 /* Line 1455 of yacc.c */ 02430 #line 407 "parser.y" 02431 { (yyval.statement) = new_for_statement(ctx, (yyvsp[(4) - (12)].variable_list), NULL, (yyvsp[(7) - (12)].expr), (yyvsp[(10) - (12)].expr), (yyvsp[(12) - (12)].statement)); ;} 02432 break; 02433 02434 case 60: 02435 02436 /* Line 1455 of yacc.c */ 02437 #line 409 "parser.y" 02438 { (yyval.statement) = new_forin_statement(ctx, NULL, (yyvsp[(3) - (7)].expr), (yyvsp[(5) - (7)].expr), (yyvsp[(7) - (7)].statement)); ;} 02439 break; 02440 02441 case 61: 02442 02443 /* Line 1455 of yacc.c */ 02444 #line 411 "parser.y" 02445 { (yyval.statement) = new_forin_statement(ctx, (yyvsp[(4) - (8)].variable_declaration), NULL, (yyvsp[(6) - (8)].expr), (yyvsp[(8) - (8)].statement)); ;} 02446 break; 02447 02448 case 62: 02449 02450 /* Line 1455 of yacc.c */ 02451 #line 416 "parser.y" 02452 { (yyval.statement) = new_continue_statement(ctx, (yyvsp[(2) - (3)].identifier)); ;} 02453 break; 02454 02455 case 63: 02456 02457 /* Line 1455 of yacc.c */ 02458 #line 421 "parser.y" 02459 { (yyval.statement) = new_break_statement(ctx, (yyvsp[(2) - (3)].identifier)); ;} 02460 break; 02461 02462 case 64: 02463 02464 /* Line 1455 of yacc.c */ 02465 #line 426 "parser.y" 02466 { (yyval.statement) = new_return_statement(ctx, (yyvsp[(2) - (3)].expr)); ;} 02467 break; 02468 02469 case 65: 02470 02471 /* Line 1455 of yacc.c */ 02472 #line 431 "parser.y" 02473 { (yyval.statement) = new_with_statement(ctx, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].statement)); ;} 02474 break; 02475 02476 case 66: 02477 02478 /* Line 1455 of yacc.c */ 02479 #line 436 "parser.y" 02480 { (yyval.statement) = new_labelled_statement(ctx, (yyvsp[(1) - (3)].identifier), (yyvsp[(3) - (3)].statement)); ;} 02481 break; 02482 02483 case 67: 02484 02485 /* Line 1455 of yacc.c */ 02486 #line 441 "parser.y" 02487 { (yyval.statement) = new_switch_statement(ctx, (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].case_clausule)); ;} 02488 break; 02489 02490 case 68: 02491 02492 /* Line 1455 of yacc.c */ 02493 #line 446 "parser.y" 02494 { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[(2) - (3)].case_list), NULL, NULL); ;} 02495 break; 02496 02497 case 69: 02498 02499 /* Line 1455 of yacc.c */ 02500 #line 448 "parser.y" 02501 { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[(2) - (5)].case_list), (yyvsp[(3) - (5)].case_clausule), (yyvsp[(4) - (5)].case_list)); ;} 02502 break; 02503 02504 case 70: 02505 02506 /* Line 1455 of yacc.c */ 02507 #line 452 "parser.y" 02508 { (yyval.case_list) = NULL; ;} 02509 break; 02510 02511 case 71: 02512 02513 /* Line 1455 of yacc.c */ 02514 #line 453 "parser.y" 02515 { (yyval.case_list) = (yyvsp[(1) - (1)].case_list); ;} 02516 break; 02517 02518 case 72: 02519 02520 /* Line 1455 of yacc.c */ 02521 #line 457 "parser.y" 02522 { (yyval.case_list) = new_case_list(ctx, (yyvsp[(1) - (1)].case_clausule)); ;} 02523 break; 02524 02525 case 73: 02526 02527 /* Line 1455 of yacc.c */ 02528 #line 459 "parser.y" 02529 { (yyval.case_list) = case_list_add(ctx, (yyvsp[(1) - (2)].case_list), (yyvsp[(2) - (2)].case_clausule)); ;} 02530 break; 02531 02532 case 74: 02533 02534 /* Line 1455 of yacc.c */ 02535 #line 464 "parser.y" 02536 { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[(2) - (4)].expr), (yyvsp[(4) - (4)].statement_list)); ;} 02537 break; 02538 02539 case 75: 02540 02541 /* Line 1455 of yacc.c */ 02542 #line 469 "parser.y" 02543 { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[(3) - (3)].statement_list)); ;} 02544 break; 02545 02546 case 76: 02547 02548 /* Line 1455 of yacc.c */ 02549 #line 474 "parser.y" 02550 { (yyval.statement) = new_throw_statement(ctx, (yyvsp[(2) - (3)].expr)); ;} 02551 break; 02552 02553 case 77: 02554 02555 /* Line 1455 of yacc.c */ 02556 #line 478 "parser.y" 02557 { (yyval.statement) = new_try_statement(ctx, (yyvsp[(2) - (3)].statement), (yyvsp[(3) - (3)].catch_block), NULL); ;} 02558 break; 02559 02560 case 78: 02561 02562 /* Line 1455 of yacc.c */ 02563 #line 479 "parser.y" 02564 { (yyval.statement) = new_try_statement(ctx, (yyvsp[(2) - (3)].statement), NULL, (yyvsp[(3) - (3)].statement)); ;} 02565 break; 02566 02567 case 79: 02568 02569 /* Line 1455 of yacc.c */ 02570 #line 481 "parser.y" 02571 { (yyval.statement) = new_try_statement(ctx, (yyvsp[(2) - (4)].statement), (yyvsp[(3) - (4)].catch_block), (yyvsp[(4) - (4)].statement)); ;} 02572 break; 02573 02574 case 80: 02575 02576 /* Line 1455 of yacc.c */ 02577 #line 486 "parser.y" 02578 { (yyval.catch_block) = new_catch_block(ctx, (yyvsp[(3) - (5)].identifier), (yyvsp[(5) - (5)].statement)); ;} 02579 break; 02580 02581 case 81: 02582 02583 /* Line 1455 of yacc.c */ 02584 #line 490 "parser.y" 02585 { (yyval.statement) = (yyvsp[(2) - (2)].statement); ;} 02586 break; 02587 02588 case 82: 02589 02590 /* Line 1455 of yacc.c */ 02591 #line 494 "parser.y" 02592 { (yyval.expr) = NULL; ;} 02593 break; 02594 02595 case 83: 02596 02597 /* Line 1455 of yacc.c */ 02598 #line 495 "parser.y" 02599 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02600 break; 02601 02602 case 84: 02603 02604 /* Line 1455 of yacc.c */ 02605 #line 498 "parser.y" 02606 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02607 break; 02608 02609 case 85: 02610 02611 /* Line 1455 of yacc.c */ 02612 #line 499 "parser.y" 02613 { set_error(ctx, IDS_SYNTAX_ERROR); YYABORT; ;} 02614 break; 02615 02616 case 86: 02617 02618 /* Line 1455 of yacc.c */ 02619 #line 503 "parser.y" 02620 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02621 break; 02622 02623 case 87: 02624 02625 /* Line 1455 of yacc.c */ 02626 #line 505 "parser.y" 02627 { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02628 break; 02629 02630 case 88: 02631 02632 /* Line 1455 of yacc.c */ 02633 #line 509 "parser.y" 02634 { (yyval.expr) = NULL; ;} 02635 break; 02636 02637 case 89: 02638 02639 /* Line 1455 of yacc.c */ 02640 #line 510 "parser.y" 02641 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02642 break; 02643 02644 case 90: 02645 02646 /* Line 1455 of yacc.c */ 02647 #line 515 "parser.y" 02648 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02649 break; 02650 02651 case 91: 02652 02653 /* Line 1455 of yacc.c */ 02654 #line 517 "parser.y" 02655 { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02656 break; 02657 02658 case 92: 02659 02660 /* Line 1455 of yacc.c */ 02661 #line 520 "parser.y" 02662 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 02663 break; 02664 02665 case 93: 02666 02667 /* Line 1455 of yacc.c */ 02668 #line 521 "parser.y" 02669 { (yyval.ival) = EXPR_ASSIGNDIV; ;} 02670 break; 02671 02672 case 94: 02673 02674 /* Line 1455 of yacc.c */ 02675 #line 525 "parser.y" 02676 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02677 break; 02678 02679 case 95: 02680 02681 /* Line 1455 of yacc.c */ 02682 #line 527 "parser.y" 02683 { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02684 break; 02685 02686 case 96: 02687 02688 /* Line 1455 of yacc.c */ 02689 #line 529 "parser.y" 02690 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02691 break; 02692 02693 case 97: 02694 02695 /* Line 1455 of yacc.c */ 02696 #line 534 "parser.y" 02697 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02698 break; 02699 02700 case 98: 02701 02702 /* Line 1455 of yacc.c */ 02703 #line 536 "parser.y" 02704 { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02705 break; 02706 02707 case 99: 02708 02709 /* Line 1455 of yacc.c */ 02710 #line 538 "parser.y" 02711 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02712 break; 02713 02714 case 100: 02715 02716 /* Line 1455 of yacc.c */ 02717 #line 542 "parser.y" 02718 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02719 break; 02720 02721 case 101: 02722 02723 /* Line 1455 of yacc.c */ 02724 #line 544 "parser.y" 02725 { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;} 02726 break; 02727 02728 case 102: 02729 02730 /* Line 1455 of yacc.c */ 02731 #line 549 "parser.y" 02732 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02733 break; 02734 02735 case 103: 02736 02737 /* Line 1455 of yacc.c */ 02738 #line 551 "parser.y" 02739 { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); ;} 02740 break; 02741 02742 case 104: 02743 02744 /* Line 1455 of yacc.c */ 02745 #line 555 "parser.y" 02746 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02747 break; 02748 02749 case 105: 02750 02751 /* Line 1455 of yacc.c */ 02752 #line 557 "parser.y" 02753 { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02754 break; 02755 02756 case 106: 02757 02758 /* Line 1455 of yacc.c */ 02759 #line 562 "parser.y" 02760 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02761 break; 02762 02763 case 107: 02764 02765 /* Line 1455 of yacc.c */ 02766 #line 564 "parser.y" 02767 { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02768 break; 02769 02770 case 108: 02771 02772 /* Line 1455 of yacc.c */ 02773 #line 568 "parser.y" 02774 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02775 break; 02776 02777 case 109: 02778 02779 /* Line 1455 of yacc.c */ 02780 #line 570 "parser.y" 02781 { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02782 break; 02783 02784 case 110: 02785 02786 /* Line 1455 of yacc.c */ 02787 #line 575 "parser.y" 02788 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02789 break; 02790 02791 case 111: 02792 02793 /* Line 1455 of yacc.c */ 02794 #line 577 "parser.y" 02795 { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02796 break; 02797 02798 case 112: 02799 02800 /* Line 1455 of yacc.c */ 02801 #line 581 "parser.y" 02802 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02803 break; 02804 02805 case 113: 02806 02807 /* Line 1455 of yacc.c */ 02808 #line 583 "parser.y" 02809 { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02810 break; 02811 02812 case 114: 02813 02814 /* Line 1455 of yacc.c */ 02815 #line 588 "parser.y" 02816 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02817 break; 02818 02819 case 115: 02820 02821 /* Line 1455 of yacc.c */ 02822 #line 590 "parser.y" 02823 { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02824 break; 02825 02826 case 116: 02827 02828 /* Line 1455 of yacc.c */ 02829 #line 594 "parser.y" 02830 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02831 break; 02832 02833 case 117: 02834 02835 /* Line 1455 of yacc.c */ 02836 #line 596 "parser.y" 02837 { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02838 break; 02839 02840 case 118: 02841 02842 /* Line 1455 of yacc.c */ 02843 #line 601 "parser.y" 02844 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02845 break; 02846 02847 case 119: 02848 02849 /* Line 1455 of yacc.c */ 02850 #line 603 "parser.y" 02851 { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02852 break; 02853 02854 case 120: 02855 02856 /* Line 1455 of yacc.c */ 02857 #line 607 "parser.y" 02858 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02859 break; 02860 02861 case 121: 02862 02863 /* Line 1455 of yacc.c */ 02864 #line 609 "parser.y" 02865 { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02866 break; 02867 02868 case 122: 02869 02870 /* Line 1455 of yacc.c */ 02871 #line 614 "parser.y" 02872 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02873 break; 02874 02875 case 123: 02876 02877 /* Line 1455 of yacc.c */ 02878 #line 616 "parser.y" 02879 { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02880 break; 02881 02882 case 124: 02883 02884 /* Line 1455 of yacc.c */ 02885 #line 620 "parser.y" 02886 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02887 break; 02888 02889 case 125: 02890 02891 /* Line 1455 of yacc.c */ 02892 #line 622 "parser.y" 02893 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02894 break; 02895 02896 case 126: 02897 02898 /* Line 1455 of yacc.c */ 02899 #line 626 "parser.y" 02900 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02901 break; 02902 02903 case 127: 02904 02905 /* Line 1455 of yacc.c */ 02906 #line 628 "parser.y" 02907 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02908 break; 02909 02910 case 128: 02911 02912 /* Line 1455 of yacc.c */ 02913 #line 632 "parser.y" 02914 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02915 break; 02916 02917 case 129: 02918 02919 /* Line 1455 of yacc.c */ 02920 #line 634 "parser.y" 02921 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02922 break; 02923 02924 case 130: 02925 02926 /* Line 1455 of yacc.c */ 02927 #line 636 "parser.y" 02928 { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02929 break; 02930 02931 case 131: 02932 02933 /* Line 1455 of yacc.c */ 02934 #line 638 "parser.y" 02935 { (yyval.expr) = new_binary_expression(ctx, EXPR_IN, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02936 break; 02937 02938 case 132: 02939 02940 /* Line 1455 of yacc.c */ 02941 #line 642 "parser.y" 02942 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02943 break; 02944 02945 case 133: 02946 02947 /* Line 1455 of yacc.c */ 02948 #line 644 "parser.y" 02949 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02950 break; 02951 02952 case 134: 02953 02954 /* Line 1455 of yacc.c */ 02955 #line 646 "parser.y" 02956 { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02957 break; 02958 02959 case 135: 02960 02961 /* Line 1455 of yacc.c */ 02962 #line 650 "parser.y" 02963 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02964 break; 02965 02966 case 136: 02967 02968 /* Line 1455 of yacc.c */ 02969 #line 652 "parser.y" 02970 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[(2) - (3)].ival), (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02971 break; 02972 02973 case 137: 02974 02975 /* Line 1455 of yacc.c */ 02976 #line 657 "parser.y" 02977 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02978 break; 02979 02980 case 138: 02981 02982 /* Line 1455 of yacc.c */ 02983 #line 659 "parser.y" 02984 { (yyval.expr) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02985 break; 02986 02987 case 139: 02988 02989 /* Line 1455 of yacc.c */ 02990 #line 661 "parser.y" 02991 { (yyval.expr) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 02992 break; 02993 02994 case 140: 02995 02996 /* Line 1455 of yacc.c */ 02997 #line 665 "parser.y" 02998 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 02999 break; 03000 03001 case 141: 03002 03003 /* Line 1455 of yacc.c */ 03004 #line 667 "parser.y" 03005 { (yyval.expr) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 03006 break; 03007 03008 case 142: 03009 03010 /* Line 1455 of yacc.c */ 03011 #line 669 "parser.y" 03012 { (yyval.expr) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 03013 break; 03014 03015 case 143: 03016 03017 /* Line 1455 of yacc.c */ 03018 #line 671 "parser.y" 03019 { (yyval.expr) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); ;} 03020 break; 03021 03022 case 144: 03023 03024 /* Line 1455 of yacc.c */ 03025 #line 675 "parser.y" 03026 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03027 break; 03028 03029 case 145: 03030 03031 /* Line 1455 of yacc.c */ 03032 #line 677 "parser.y" 03033 { (yyval.expr) = new_unary_expression(ctx, EXPR_DELETE, (yyvsp[(2) - (2)].expr)); ;} 03034 break; 03035 03036 case 146: 03037 03038 /* Line 1455 of yacc.c */ 03039 #line 678 "parser.y" 03040 { (yyval.expr) = new_unary_expression(ctx, EXPR_VOID, (yyvsp[(2) - (2)].expr)); ;} 03041 break; 03042 03043 case 147: 03044 03045 /* Line 1455 of yacc.c */ 03046 #line 680 "parser.y" 03047 { (yyval.expr) = new_unary_expression(ctx, EXPR_TYPEOF, (yyvsp[(2) - (2)].expr)); ;} 03048 break; 03049 03050 case 148: 03051 03052 /* Line 1455 of yacc.c */ 03053 #line 681 "parser.y" 03054 { (yyval.expr) = new_unary_expression(ctx, EXPR_PREINC, (yyvsp[(2) - (2)].expr)); ;} 03055 break; 03056 03057 case 149: 03058 03059 /* Line 1455 of yacc.c */ 03060 #line 682 "parser.y" 03061 { (yyval.expr) = new_unary_expression(ctx, EXPR_PREDEC, (yyvsp[(2) - (2)].expr)); ;} 03062 break; 03063 03064 case 150: 03065 03066 /* Line 1455 of yacc.c */ 03067 #line 683 "parser.y" 03068 { (yyval.expr) = new_unary_expression(ctx, EXPR_PLUS, (yyvsp[(2) - (2)].expr)); ;} 03069 break; 03070 03071 case 151: 03072 03073 /* Line 1455 of yacc.c */ 03074 #line 684 "parser.y" 03075 { (yyval.expr) = new_unary_expression(ctx, EXPR_MINUS, (yyvsp[(2) - (2)].expr)); ;} 03076 break; 03077 03078 case 152: 03079 03080 /* Line 1455 of yacc.c */ 03081 #line 685 "parser.y" 03082 { (yyval.expr) = new_unary_expression(ctx, EXPR_BITNEG, (yyvsp[(2) - (2)].expr)); ;} 03083 break; 03084 03085 case 153: 03086 03087 /* Line 1455 of yacc.c */ 03088 #line 686 "parser.y" 03089 { (yyval.expr) = new_unary_expression(ctx, EXPR_LOGNEG, (yyvsp[(2) - (2)].expr)); ;} 03090 break; 03091 03092 case 154: 03093 03094 /* Line 1455 of yacc.c */ 03095 #line 691 "parser.y" 03096 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03097 break; 03098 03099 case 155: 03100 03101 /* Line 1455 of yacc.c */ 03102 #line 693 "parser.y" 03103 { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTINC, (yyvsp[(1) - (2)].expr)); ;} 03104 break; 03105 03106 case 156: 03107 03108 /* Line 1455 of yacc.c */ 03109 #line 695 "parser.y" 03110 { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTDEC, (yyvsp[(1) - (2)].expr)); ;} 03111 break; 03112 03113 case 157: 03114 03115 /* Line 1455 of yacc.c */ 03116 #line 700 "parser.y" 03117 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03118 break; 03119 03120 case 158: 03121 03122 /* Line 1455 of yacc.c */ 03123 #line 701 "parser.y" 03124 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03125 break; 03126 03127 case 159: 03128 03129 /* Line 1455 of yacc.c */ 03130 #line 705 "parser.y" 03131 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03132 break; 03133 03134 case 160: 03135 03136 /* Line 1455 of yacc.c */ 03137 #line 706 "parser.y" 03138 { (yyval.expr) = new_new_expression(ctx, (yyvsp[(2) - (2)].expr), NULL); ;} 03139 break; 03140 03141 case 161: 03142 03143 /* Line 1455 of yacc.c */ 03144 #line 710 "parser.y" 03145 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03146 break; 03147 03148 case 162: 03149 03150 /* Line 1455 of yacc.c */ 03151 #line 711 "parser.y" 03152 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03153 break; 03154 03155 case 163: 03156 03157 /* Line 1455 of yacc.c */ 03158 #line 713 "parser.y" 03159 { (yyval.expr) = new_array_expression(ctx, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;} 03160 break; 03161 03162 case 164: 03163 03164 /* Line 1455 of yacc.c */ 03165 #line 715 "parser.y" 03166 { (yyval.expr) = new_member_expression(ctx, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].identifier)); ;} 03167 break; 03168 03169 case 165: 03170 03171 /* Line 1455 of yacc.c */ 03172 #line 717 "parser.y" 03173 { (yyval.expr) = new_new_expression(ctx, (yyvsp[(2) - (3)].expr), (yyvsp[(3) - (3)].argument_list)); ;} 03174 break; 03175 03176 case 166: 03177 03178 /* Line 1455 of yacc.c */ 03179 #line 722 "parser.y" 03180 { (yyval.expr) = new_call_expression(ctx, (yyvsp[(1) - (2)].expr), (yyvsp[(2) - (2)].argument_list)); ;} 03181 break; 03182 03183 case 167: 03184 03185 /* Line 1455 of yacc.c */ 03186 #line 724 "parser.y" 03187 { (yyval.expr) = new_call_expression(ctx, (yyvsp[(1) - (2)].expr), (yyvsp[(2) - (2)].argument_list)); ;} 03188 break; 03189 03190 case 168: 03191 03192 /* Line 1455 of yacc.c */ 03193 #line 726 "parser.y" 03194 { (yyval.expr) = new_array_expression(ctx, (yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); ;} 03195 break; 03196 03197 case 169: 03198 03199 /* Line 1455 of yacc.c */ 03200 #line 728 "parser.y" 03201 { (yyval.expr) = new_member_expression(ctx, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].identifier)); ;} 03202 break; 03203 03204 case 170: 03205 03206 /* Line 1455 of yacc.c */ 03207 #line 732 "parser.y" 03208 { (yyval.argument_list) = NULL; ;} 03209 break; 03210 03211 case 171: 03212 03213 /* Line 1455 of yacc.c */ 03214 #line 733 "parser.y" 03215 { (yyval.argument_list) = (yyvsp[(2) - (3)].argument_list); ;} 03216 break; 03217 03218 case 172: 03219 03220 /* Line 1455 of yacc.c */ 03221 #line 737 "parser.y" 03222 { (yyval.argument_list) = new_argument_list(ctx, (yyvsp[(1) - (1)].expr)); ;} 03223 break; 03224 03225 case 173: 03226 03227 /* Line 1455 of yacc.c */ 03228 #line 739 "parser.y" 03229 { (yyval.argument_list) = argument_list_add(ctx, (yyvsp[(1) - (3)].argument_list), (yyvsp[(3) - (3)].expr)); ;} 03230 break; 03231 03232 case 174: 03233 03234 /* Line 1455 of yacc.c */ 03235 #line 743 "parser.y" 03236 { (yyval.expr) = new_this_expression(ctx); ;} 03237 break; 03238 03239 case 175: 03240 03241 /* Line 1455 of yacc.c */ 03242 #line 744 "parser.y" 03243 { (yyval.expr) = new_identifier_expression(ctx, (yyvsp[(1) - (1)].identifier)); ;} 03244 break; 03245 03246 case 176: 03247 03248 /* Line 1455 of yacc.c */ 03249 #line 745 "parser.y" 03250 { (yyval.expr) = new_literal_expression(ctx, (yyvsp[(1) - (1)].literal)); ;} 03251 break; 03252 03253 case 177: 03254 03255 /* Line 1455 of yacc.c */ 03256 #line 746 "parser.y" 03257 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03258 break; 03259 03260 case 178: 03261 03262 /* Line 1455 of yacc.c */ 03263 #line 747 "parser.y" 03264 { (yyval.expr) = (yyvsp[(1) - (1)].expr); ;} 03265 break; 03266 03267 case 179: 03268 03269 /* Line 1455 of yacc.c */ 03270 #line 748 "parser.y" 03271 { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;} 03272 break; 03273 03274 case 180: 03275 03276 /* Line 1455 of yacc.c */ 03277 #line 752 "parser.y" 03278 { (yyval.expr) = new_array_literal_expression(ctx, NULL, 0); ;} 03279 break; 03280 03281 case 181: 03282 03283 /* Line 1455 of yacc.c */ 03284 #line 753 "parser.y" 03285 { (yyval.expr) = new_array_literal_expression(ctx, NULL, (yyvsp[(2) - (3)].ival)+1); ;} 03286 break; 03287 03288 case 182: 03289 03290 /* Line 1455 of yacc.c */ 03291 #line 754 "parser.y" 03292 { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[(2) - (3)].element_list), 0); ;} 03293 break; 03294 03295 case 183: 03296 03297 /* Line 1455 of yacc.c */ 03298 #line 756 "parser.y" 03299 { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[(2) - (5)].element_list), (yyvsp[(4) - (5)].ival)+1); ;} 03300 break; 03301 03302 case 184: 03303 03304 /* Line 1455 of yacc.c */ 03305 #line 761 "parser.y" 03306 { (yyval.element_list) = new_element_list(ctx, (yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].expr)); ;} 03307 break; 03308 03309 case 185: 03310 03311 /* Line 1455 of yacc.c */ 03312 #line 763 "parser.y" 03313 { (yyval.element_list) = element_list_add(ctx, (yyvsp[(1) - (4)].element_list), (yyvsp[(3) - (4)].ival), (yyvsp[(4) - (4)].expr)); ;} 03314 break; 03315 03316 case 186: 03317 03318 /* Line 1455 of yacc.c */ 03319 #line 767 "parser.y" 03320 { (yyval.ival) = 1; ;} 03321 break; 03322 03323 case 187: 03324 03325 /* Line 1455 of yacc.c */ 03326 #line 768 "parser.y" 03327 { (yyval.ival) = (yyvsp[(1) - (2)].ival) + 1; ;} 03328 break; 03329 03330 case 188: 03331 03332 /* Line 1455 of yacc.c */ 03333 #line 772 "parser.y" 03334 { (yyval.ival) = 0; ;} 03335 break; 03336 03337 case 189: 03338 03339 /* Line 1455 of yacc.c */ 03340 #line 773 "parser.y" 03341 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 03342 break; 03343 03344 case 190: 03345 03346 /* Line 1455 of yacc.c */ 03347 #line 777 "parser.y" 03348 { (yyval.expr) = new_prop_and_value_expression(ctx, NULL); ;} 03349 break; 03350 03351 case 191: 03352 03353 /* Line 1455 of yacc.c */ 03354 #line 779 "parser.y" 03355 { (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[(2) - (3)].property_list)); ;} 03356 break; 03357 03358 case 192: 03359 03360 /* Line 1455 of yacc.c */ 03361 #line 784 "parser.y" 03362 { (yyval.property_list) = new_property_list(ctx, (yyvsp[(1) - (3)].literal), (yyvsp[(3) - (3)].expr)); ;} 03363 break; 03364 03365 case 193: 03366 03367 /* Line 1455 of yacc.c */ 03368 #line 786 "parser.y" 03369 { (yyval.property_list) = property_list_add(ctx, (yyvsp[(1) - (5)].property_list), (yyvsp[(3) - (5)].literal), (yyvsp[(5) - (5)].expr)); ;} 03370 break; 03371 03372 case 194: 03373 03374 /* Line 1455 of yacc.c */ 03375 #line 790 "parser.y" 03376 { (yyval.literal) = new_string_literal(ctx, (yyvsp[(1) - (1)].identifier)); ;} 03377 break; 03378 03379 case 195: 03380 03381 /* Line 1455 of yacc.c */ 03382 #line 791 "parser.y" 03383 { (yyval.literal) = new_string_literal(ctx, (yyvsp[(1) - (1)].wstr)); ;} 03384 break; 03385 03386 case 196: 03387 03388 /* Line 1455 of yacc.c */ 03389 #line 792 "parser.y" 03390 { (yyval.literal) = (yyvsp[(1) - (1)].literal); ;} 03391 break; 03392 03393 case 197: 03394 03395 /* Line 1455 of yacc.c */ 03396 #line 796 "parser.y" 03397 { (yyval.identifier) = NULL; ;} 03398 break; 03399 03400 case 198: 03401 03402 /* Line 1455 of yacc.c */ 03403 #line 797 "parser.y" 03404 { (yyval.identifier) = (yyvsp[(1) - (1)].identifier); ;} 03405 break; 03406 03407 case 199: 03408 03409 /* Line 1455 of yacc.c */ 03410 #line 801 "parser.y" 03411 { (yyval.literal) = new_null_literal(ctx); ;} 03412 break; 03413 03414 case 200: 03415 03416 /* Line 1455 of yacc.c */ 03417 #line 802 "parser.y" 03418 { (yyval.literal) = (yyvsp[(1) - (1)].literal); ;} 03419 break; 03420 03421 case 201: 03422 03423 /* Line 1455 of yacc.c */ 03424 #line 803 "parser.y" 03425 { (yyval.literal) = (yyvsp[(1) - (1)].literal); ;} 03426 break; 03427 03428 case 202: 03429 03430 /* Line 1455 of yacc.c */ 03431 #line 804 "parser.y" 03432 { (yyval.literal) = new_string_literal(ctx, (yyvsp[(1) - (1)].wstr)); ;} 03433 break; 03434 03435 case 203: 03436 03437 /* Line 1455 of yacc.c */ 03438 #line 805 "parser.y" 03439 { (yyval.literal) = parse_regexp(ctx); 03440 if(!(yyval.literal)) YYABORT; ;} 03441 break; 03442 03443 case 204: 03444 03445 /* Line 1455 of yacc.c */ 03446 #line 807 "parser.y" 03447 { (yyval.literal) = parse_regexp(ctx); 03448 if(!(yyval.literal)) YYABORT; ;} 03449 break; 03450 03451 case 205: 03452 03453 /* Line 1455 of yacc.c */ 03454 #line 812 "parser.y" 03455 { (yyval.literal) = new_boolean_literal(ctx, VARIANT_TRUE); ;} 03456 break; 03457 03458 case 206: 03459 03460 /* Line 1455 of yacc.c */ 03461 #line 813 "parser.y" 03462 { (yyval.literal) = new_boolean_literal(ctx, VARIANT_FALSE); ;} 03463 break; 03464 03465 case 208: 03466 03467 /* Line 1455 of yacc.c */ 03468 #line 817 "parser.y" 03469 { if(!allow_auto_semicolon(ctx)) {YYABORT;} ;} 03470 break; 03471 03472 case 210: 03473 03474 /* Line 1455 of yacc.c */ 03475 #line 821 "parser.y" 03476 { set_error(ctx, IDS_LBRACKET); YYABORT; ;} 03477 break; 03478 03479 case 212: 03480 03481 /* Line 1455 of yacc.c */ 03482 #line 825 "parser.y" 03483 { set_error(ctx, IDS_RBRACKET); YYABORT; ;} 03484 break; 03485 03486 case 214: 03487 03488 /* Line 1455 of yacc.c */ 03489 #line 829 "parser.y" 03490 { set_error(ctx, IDS_SEMICOLON); YYABORT; ;} 03491 break; 03492 03493 03494 03495 /* Line 1455 of yacc.c */ 03496 #line 3497 "parser.tab.c" 03497 default: break; 03498 } 03499 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 03500 03501 YYPOPSTACK (yylen); 03502 yylen = 0; 03503 YY_STACK_PRINT (yyss, yyssp); 03504 03505 *++yyvsp = yyval; 03506 03507 /* Now `shift' the result of the reduction. Determine what state 03508 that goes to, based on the state we popped back to and the rule 03509 number reduced by. */ 03510 03511 yyn = yyr1[yyn]; 03512 03513 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 03514 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 03515 yystate = yytable[yystate]; 03516 else 03517 yystate = yydefgoto[yyn - YYNTOKENS]; 03518 03519 goto yynewstate; 03520 03521 03522 /*------------------------------------. 03523 | yyerrlab -- here on detecting error | 03524 `------------------------------------*/ 03525 yyerrlab: 03526 /* If not already recovering from an error, report this error. */ 03527 if (!yyerrstatus) 03528 { 03529 ++yynerrs; 03530 #if ! YYERROR_VERBOSE 03531 yyerror (YY_("syntax error")); 03532 #else 03533 { 03534 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 03535 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 03536 { 03537 YYSIZE_T yyalloc = 2 * yysize; 03538 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 03539 yyalloc = YYSTACK_ALLOC_MAXIMUM; 03540 if (yymsg != yymsgbuf) 03541 YYSTACK_FREE (yymsg); 03542 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 03543 if (yymsg) 03544 yymsg_alloc = yyalloc; 03545 else 03546 { 03547 yymsg = yymsgbuf; 03548 yymsg_alloc = sizeof yymsgbuf; 03549 } 03550 } 03551 03552 if (0 < yysize && yysize <= yymsg_alloc) 03553 { 03554 (void) yysyntax_error (yymsg, yystate, yychar); 03555 yyerror (yymsg); 03556 } 03557 else 03558 { 03559 yyerror (YY_("syntax error")); 03560 if (yysize != 0) 03561 goto yyexhaustedlab; 03562 } 03563 } 03564 #endif 03565 } 03566 03567 03568 03569 if (yyerrstatus == 3) 03570 { 03571 /* If just tried and failed to reuse lookahead token after an 03572 error, discard it. */ 03573 03574 if (yychar <= YYEOF) 03575 { 03576 /* Return failure if at end of input. */ 03577 if (yychar == YYEOF) 03578 YYABORT; 03579 } 03580 else 03581 { 03582 yydestruct ("Error: discarding", 03583 yytoken, &yylval); 03584 yychar = YYEMPTY; 03585 } 03586 } 03587 03588 /* Else will try to reuse lookahead token after shifting the error 03589 token. */ 03590 goto yyerrlab1; 03591 03592 03593 /*---------------------------------------------------. 03594 | yyerrorlab -- error raised explicitly by YYERROR. | 03595 `---------------------------------------------------*/ 03596 yyerrorlab: 03597 03598 /* Pacify compilers like GCC when the user code never invokes 03599 YYERROR and the label yyerrorlab therefore never appears in user 03600 code. */ 03601 if (/*CONSTCOND*/ 0) 03602 goto yyerrorlab; 03603 03604 /* Do not reclaim the symbols of the rule which action triggered 03605 this YYERROR. */ 03606 YYPOPSTACK (yylen); 03607 yylen = 0; 03608 YY_STACK_PRINT (yyss, yyssp); 03609 yystate = *yyssp; 03610 goto yyerrlab1; 03611 03612 03613 /*-------------------------------------------------------------. 03614 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03615 `-------------------------------------------------------------*/ 03616 yyerrlab1: 03617 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03618 03619 for (;;) 03620 { 03621 yyn = yypact[yystate]; 03622 if (yyn != YYPACT_NINF) 03623 { 03624 yyn += YYTERROR; 03625 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03626 { 03627 yyn = yytable[yyn]; 03628 if (0 < yyn) 03629 break; 03630 } 03631 } 03632 03633 /* Pop the current state because it cannot handle the error token. */ 03634 if (yyssp == yyss) 03635 YYABORT; 03636 03637 03638 yydestruct ("Error: popping", 03639 yystos[yystate], yyvsp); 03640 YYPOPSTACK (1); 03641 yystate = *yyssp; 03642 YY_STACK_PRINT (yyss, yyssp); 03643 } 03644 03645 *++yyvsp = yylval; 03646 03647 03648 /* Shift the error token. */ 03649 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03650 03651 yystate = yyn; 03652 goto yynewstate; 03653 03654 03655 /*-------------------------------------. 03656 | yyacceptlab -- YYACCEPT comes here. | 03657 `-------------------------------------*/ 03658 yyacceptlab: 03659 yyresult = 0; 03660 goto yyreturn; 03661 03662 /*-----------------------------------. 03663 | yyabortlab -- YYABORT comes here. | 03664 `-----------------------------------*/ 03665 yyabortlab: 03666 yyresult = 1; 03667 goto yyreturn; 03668 03669 #if !defined(yyoverflow) || YYERROR_VERBOSE 03670 /*-------------------------------------------------. 03671 | yyexhaustedlab -- memory exhaustion comes here. | 03672 `-------------------------------------------------*/ 03673 yyexhaustedlab: 03674 yyerror (YY_("memory exhausted")); 03675 yyresult = 2; 03676 /* Fall through. */ 03677 #endif 03678 03679 yyreturn: 03680 if (yychar != YYEMPTY) 03681 yydestruct ("Cleanup: discarding lookahead", 03682 yytoken, &yylval); 03683 /* Do not reclaim the symbols of the rule which action triggered 03684 this YYABORT or YYACCEPT. */ 03685 YYPOPSTACK (yylen); 03686 YY_STACK_PRINT (yyss, yyssp); 03687 while (yyssp != yyss) 03688 { 03689 yydestruct ("Cleanup: popping", 03690 yystos[*yyssp], yyvsp); 03691 YYPOPSTACK (1); 03692 } 03693 #ifndef yyoverflow 03694 if (yyss != yyssa) 03695 YYSTACK_FREE (yyss); 03696 #endif 03697 #if YYERROR_VERBOSE 03698 if (yymsg != yymsgbuf) 03699 YYSTACK_FREE (yymsg); 03700 #endif 03701 /* Make sure YYID is used. */ 03702 return YYID (yyresult); 03703 } 03704 03705 03706 03707 /* Line 1675 of yacc.c */ 03708 #line 831 "parser.y" 03709 03710 03711 static BOOL allow_auto_semicolon(parser_ctx_t *ctx) 03712 { 03713 return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}'; 03714 } 03715 03716 static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str) 03717 { 03718 literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); 03719 03720 ret->type = LT_STRING; 03721 ret->u.wstr = str; 03722 03723 return ret; 03724 } 03725 03726 static literal_t *new_null_literal(parser_ctx_t *ctx) 03727 { 03728 literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); 03729 03730 ret->type = LT_NULL; 03731 03732 return ret; 03733 } 03734 03735 static literal_t *new_boolean_literal(parser_ctx_t *ctx, VARIANT_BOOL bval) 03736 { 03737 literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); 03738 03739 ret->type = LT_BOOL; 03740 ret->u.bval = bval; 03741 03742 return ret; 03743 } 03744 03745 static prop_val_t *new_prop_val(parser_ctx_t *ctx, literal_t *name, expression_t *value) 03746 { 03747 prop_val_t *ret = parser_alloc(ctx, sizeof(prop_val_t)); 03748 03749 ret->name = name; 03750 ret->value = value; 03751 ret->next = NULL; 03752 03753 return ret; 03754 } 03755 03756 static property_list_t *new_property_list(parser_ctx_t *ctx, literal_t *name, expression_t *value) 03757 { 03758 property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t)); 03759 03760 ret->head = ret->tail = new_prop_val(ctx, name, value); 03761 03762 return ret; 03763 } 03764 03765 static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list, literal_t *name, expression_t *value) 03766 { 03767 list->tail = list->tail->next = new_prop_val(ctx, name, value); 03768 03769 return list; 03770 } 03771 03772 static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr) 03773 { 03774 array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t)); 03775 03776 ret->elision = elision; 03777 ret->expr = expr; 03778 ret->next = NULL; 03779 03780 return ret; 03781 } 03782 03783 static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t *expr) 03784 { 03785 element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t)); 03786 03787 ret->head = ret->tail = new_array_element(ctx, elision, expr); 03788 03789 return ret; 03790 } 03791 03792 static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int elision, expression_t *expr) 03793 { 03794 list->tail = list->tail->next = new_array_element(ctx, elision, expr); 03795 03796 return list; 03797 } 03798 03799 static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr) 03800 { 03801 argument_t *ret = parser_alloc(ctx, sizeof(argument_t)); 03802 03803 ret->expr = expr; 03804 ret->next = NULL; 03805 03806 return ret; 03807 } 03808 03809 static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr) 03810 { 03811 argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t)); 03812 03813 ret->head = ret->tail = new_argument(ctx, expr); 03814 03815 return ret; 03816 } 03817 03818 static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list, expression_t *expr) 03819 { 03820 list->tail = list->tail->next = new_argument(ctx, expr); 03821 03822 return list; 03823 } 03824 03825 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement) 03826 { 03827 catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t)); 03828 03829 ret->identifier = identifier; 03830 ret->statement = statement; 03831 03832 return ret; 03833 } 03834 03835 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_list_t *stat_list) 03836 { 03837 case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t)); 03838 03839 ret->expr = expr; 03840 ret->stat = stat_list ? stat_list->head : NULL; 03841 ret->next = NULL; 03842 03843 return ret; 03844 } 03845 03846 static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule) 03847 { 03848 case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t)); 03849 03850 ret->head = ret->tail = case_clausule; 03851 03852 return ret; 03853 } 03854 03855 static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t *case_clausule) 03856 { 03857 list->tail = list->tail->next = case_clausule; 03858 03859 return list; 03860 } 03861 03862 static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1, 03863 case_clausule_t *default_clausule, case_list_t *case_list2) 03864 { 03865 case_clausule_t *ret = NULL, *iter = NULL, *iter2; 03866 statement_t *stat = NULL; 03867 03868 if(case_list1) { 03869 ret = case_list1->head; 03870 iter = case_list1->tail; 03871 } 03872 03873 if(default_clausule) { 03874 if(ret) 03875 iter = iter->next = default_clausule; 03876 else 03877 ret = iter = default_clausule; 03878 } 03879 03880 if(case_list2) { 03881 if(ret) 03882 iter->next = case_list2->head; 03883 else 03884 ret = case_list2->head; 03885 } 03886 03887 if(!ret) 03888 return NULL; 03889 03890 for(iter = ret; iter; iter = iter->next) { 03891 for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next); 03892 if(!iter2) 03893 break; 03894 03895 while(iter != iter2) { 03896 iter->stat = iter2->stat; 03897 iter = iter->next; 03898 } 03899 03900 if(stat) { 03901 while(stat->next) 03902 stat = stat->next; 03903 stat->next = iter->stat; 03904 }else { 03905 stat = iter->stat; 03906 } 03907 } 03908 03909 return ret; 03910 } 03911 03912 static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list) 03913 { 03914 block_statement_t *ret = parser_alloc(ctx, sizeof(block_statement_t)); 03915 03916 ret->stat.eval = block_statement_eval; 03917 ret->stat.next = NULL; 03918 ret->stat_list = list ? list->head : NULL; 03919 03920 return &ret->stat; 03921 } 03922 03923 static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *expr) 03924 { 03925 variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t)); 03926 var_list_t *var_list = parser_alloc(ctx, sizeof(var_list_t)); 03927 03928 ret->identifier = identifier; 03929 ret->expr = expr; 03930 ret->next = NULL; 03931 03932 var_list->identifier = identifier; 03933 var_list->next = NULL; 03934 03935 if(ctx->func_stack->var_tail) 03936 ctx->func_stack->var_tail = ctx->func_stack->var_tail->next = var_list; 03937 else 03938 ctx->func_stack->var_head = ctx->func_stack->var_tail = var_list; 03939 03940 return ret; 03941 } 03942 03943 static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t *decl) 03944 { 03945 variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t)); 03946 03947 ret->head = ret->tail = decl; 03948 03949 return ret; 03950 } 03951 03952 static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list, variable_declaration_t *decl) 03953 { 03954 list->tail = list->tail->next = decl; 03955 03956 return list; 03957 } 03958 03959 static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list) 03960 { 03961 var_statement_t *ret = parser_alloc(ctx, sizeof(var_statement_t)); 03962 03963 ret->stat.eval = var_statement_eval; 03964 ret->stat.next = NULL; 03965 ret->variable_list = variable_list->head; 03966 03967 return &ret->stat; 03968 } 03969 03970 static statement_t *new_empty_statement(parser_ctx_t *ctx) 03971 { 03972 statement_t *ret = parser_alloc(ctx, sizeof(statement_t)); 03973 03974 ret->eval = empty_statement_eval; 03975 ret->next = NULL; 03976 03977 return ret; 03978 } 03979 03980 static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr) 03981 { 03982 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t)); 03983 03984 ret->stat.eval = expression_statement_eval; 03985 ret->stat.next = NULL; 03986 ret->expr = expr; 03987 03988 return &ret->stat; 03989 } 03990 03991 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, statement_t *else_stat) 03992 { 03993 if_statement_t *ret = parser_alloc(ctx, sizeof(if_statement_t)); 03994 03995 ret->stat.eval = if_statement_eval; 03996 ret->stat.next = NULL; 03997 ret->expr = expr; 03998 ret->if_stat = if_stat; 03999 ret->else_stat = else_stat; 04000 04001 return &ret->stat; 04002 } 04003 04004 static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t *expr, statement_t *stat) 04005 { 04006 while_statement_t *ret = parser_alloc(ctx, sizeof(while_statement_t)); 04007 04008 ret->stat.eval = while_statement_eval; 04009 ret->stat.next = NULL; 04010 ret->do_while = dowhile; 04011 ret->expr = expr; 04012 ret->statement = stat; 04013 04014 return &ret->stat; 04015 } 04016 04017 static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr, 04018 expression_t *expr, expression_t *end_expr, statement_t *statement) 04019 { 04020 for_statement_t *ret = parser_alloc(ctx, sizeof(for_statement_t)); 04021 04022 ret->stat.eval = for_statement_eval; 04023 ret->stat.next = NULL; 04024 ret->variable_list = variable_list ? variable_list->head : NULL; 04025 ret->begin_expr = begin_expr; 04026 ret->expr = expr; 04027 ret->end_expr = end_expr; 04028 ret->statement = statement; 04029 04030 return &ret->stat; 04031 } 04032 04033 static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t *variable, expression_t *expr, 04034 expression_t *in_expr, statement_t *statement) 04035 { 04036 forin_statement_t *ret = parser_alloc(ctx, sizeof(forin_statement_t)); 04037 04038 ret->stat.eval = forin_statement_eval; 04039 ret->stat.next = NULL; 04040 ret->variable = variable; 04041 ret->expr = expr; 04042 ret->in_expr = in_expr; 04043 ret->statement = statement; 04044 04045 return &ret->stat; 04046 } 04047 04048 static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier) 04049 { 04050 branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t)); 04051 04052 ret->stat.eval = continue_statement_eval; 04053 ret->stat.next = NULL; 04054 ret->identifier = identifier; 04055 04056 return &ret->stat; 04057 } 04058 04059 static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier) 04060 { 04061 branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t)); 04062 04063 ret->stat.eval = break_statement_eval; 04064 ret->stat.next = NULL; 04065 ret->identifier = identifier; 04066 04067 return &ret->stat; 04068 } 04069 04070 static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr) 04071 { 04072 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t)); 04073 04074 ret->stat.eval = return_statement_eval; 04075 ret->stat.next = NULL; 04076 ret->expr = expr; 04077 04078 return &ret->stat; 04079 } 04080 04081 static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *statement) 04082 { 04083 with_statement_t *ret = parser_alloc(ctx, sizeof(with_statement_t)); 04084 04085 ret->stat.eval = with_statement_eval; 04086 ret->stat.next = NULL; 04087 ret->expr = expr; 04088 ret->statement = statement; 04089 04090 return &ret->stat; 04091 } 04092 04093 static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement) 04094 { 04095 labelled_statement_t *ret = parser_alloc(ctx, sizeof(labelled_statement_t)); 04096 04097 ret->stat.eval = labelled_statement_eval; 04098 ret->stat.next = NULL; 04099 ret->identifier = identifier; 04100 ret->statement = statement; 04101 04102 return &ret->stat; 04103 } 04104 04105 static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_list) 04106 { 04107 switch_statement_t *ret = parser_alloc(ctx, sizeof(switch_statement_t)); 04108 04109 ret->stat.eval = switch_statement_eval; 04110 ret->stat.next = NULL; 04111 ret->expr = expr; 04112 ret->case_list = case_list; 04113 04114 return &ret->stat; 04115 } 04116 04117 static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr) 04118 { 04119 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t)); 04120 04121 ret->stat.eval = throw_statement_eval; 04122 ret->stat.next = NULL; 04123 ret->expr = expr; 04124 04125 return &ret->stat; 04126 } 04127 04128 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement, 04129 catch_block_t *catch_block, statement_t *finally_statement) 04130 { 04131 try_statement_t *ret = parser_alloc(ctx, sizeof(try_statement_t)); 04132 04133 ret->stat.eval = try_statement_eval; 04134 ret->stat.next = NULL; 04135 ret->try_statement = try_statement; 04136 ret->catch_block = catch_block; 04137 ret->finally_statement = finally_statement; 04138 04139 return &ret->stat; 04140 } 04141 04142 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier) 04143 { 04144 parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t)); 04145 04146 ret->identifier = identifier; 04147 ret->next = NULL; 04148 04149 return ret; 04150 } 04151 04152 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier) 04153 { 04154 parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t)); 04155 04156 ret->head = ret->tail = new_parameter(ctx, identifier); 04157 04158 return ret; 04159 } 04160 04161 static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list, const WCHAR *identifier) 04162 { 04163 list->tail = list->tail->next = new_parameter(ctx, identifier); 04164 04165 return list; 04166 } 04167 04168 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier, 04169 parameter_list_t *parameter_list, source_elements_t *source_elements, const WCHAR *src_str, DWORD src_len) 04170 { 04171 function_expression_t *ret = parser_alloc(ctx, sizeof(function_expression_t)); 04172 04173 ret->expr.eval = function_expression_eval; 04174 ret->identifier = identifier; 04175 ret->parameter_list = parameter_list ? parameter_list->head : NULL; 04176 ret->source_elements = source_elements; 04177 ret->src_str = src_str; 04178 ret->src_len = src_len; 04179 04180 if(ret->identifier) { 04181 function_declaration_t *decl = parser_alloc(ctx, sizeof(function_declaration_t)); 04182 04183 decl->expr = ret; 04184 decl->next = NULL; 04185 04186 if(ctx->func_stack->func_tail) 04187 ctx->func_stack->func_tail = ctx->func_stack->func_tail->next = decl; 04188 else 04189 ctx->func_stack->func_head = ctx->func_stack->func_tail = decl; 04190 } 04191 04192 return &ret->expr; 04193 } 04194 04195 static const expression_eval_t expression_eval_table[] = { 04196 comma_expression_eval, 04197 logical_or_expression_eval, 04198 logical_and_expression_eval, 04199 binary_or_expression_eval, 04200 binary_xor_expression_eval, 04201 binary_and_expression_eval, 04202 instanceof_expression_eval, 04203 in_expression_eval, 04204 add_expression_eval, 04205 sub_expression_eval, 04206 mul_expression_eval, 04207 div_expression_eval, 04208 mod_expression_eval, 04209 delete_expression_eval, 04210 void_expression_eval, 04211 typeof_expression_eval, 04212 minus_expression_eval, 04213 plus_expression_eval, 04214 post_increment_expression_eval, 04215 post_decrement_expression_eval, 04216 pre_increment_expression_eval, 04217 pre_decrement_expression_eval, 04218 equal_expression_eval, 04219 equal2_expression_eval, 04220 not_equal_expression_eval, 04221 not_equal2_expression_eval, 04222 less_expression_eval, 04223 lesseq_expression_eval, 04224 greater_expression_eval, 04225 greatereq_expression_eval, 04226 binary_negation_expression_eval, 04227 logical_negation_expression_eval, 04228 left_shift_expression_eval, 04229 right_shift_expression_eval, 04230 right2_shift_expression_eval, 04231 assign_expression_eval, 04232 assign_lshift_expression_eval, 04233 assign_rshift_expression_eval, 04234 assign_rrshift_expression_eval, 04235 assign_add_expression_eval, 04236 assign_sub_expression_eval, 04237 assign_mul_expression_eval, 04238 assign_div_expression_eval, 04239 assign_mod_expression_eval, 04240 assign_and_expression_eval, 04241 assign_or_expression_eval, 04242 assign_xor_expression_eval, 04243 }; 04244 04245 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type, 04246 expression_t *expression1, expression_t *expression2) 04247 { 04248 binary_expression_t *ret = parser_alloc(ctx, sizeof(binary_expression_t)); 04249 04250 ret->expr.eval = expression_eval_table[type]; 04251 ret->expression1 = expression1; 04252 ret->expression2 = expression2; 04253 04254 return &ret->expr; 04255 } 04256 04257 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *expression) 04258 { 04259 unary_expression_t *ret = parser_alloc(ctx, sizeof(unary_expression_t)); 04260 04261 ret->expr.eval = expression_eval_table[type]; 04262 ret->expression = expression; 04263 04264 return &ret->expr; 04265 } 04266 04267 static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t *expression, 04268 expression_t *true_expression, expression_t *false_expression) 04269 { 04270 conditional_expression_t *ret = parser_alloc(ctx, sizeof(conditional_expression_t)); 04271 04272 ret->expr.eval = conditional_expression_eval; 04273 ret->expression = expression; 04274 ret->true_expression = true_expression; 04275 ret->false_expression = false_expression; 04276 04277 return &ret->expr; 04278 } 04279 04280 static expression_t *new_array_expression(parser_ctx_t *ctx, expression_t *member_expr, expression_t *expression) 04281 { 04282 array_expression_t *ret = parser_alloc(ctx, sizeof(array_expression_t)); 04283 04284 ret->expr.eval = array_expression_eval; 04285 ret->member_expr = member_expr; 04286 ret->expression = expression; 04287 04288 return &ret->expr; 04289 } 04290 04291 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier) 04292 { 04293 member_expression_t *ret = parser_alloc(ctx, sizeof(member_expression_t)); 04294 04295 ret->expr.eval = member_expression_eval; 04296 ret->expression = expression; 04297 ret->identifier = identifier; 04298 04299 return &ret->expr; 04300 } 04301 04302 static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list) 04303 { 04304 call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t)); 04305 04306 ret->expr.eval = new_expression_eval; 04307 ret->expression = expression; 04308 ret->argument_list = argument_list ? argument_list->head : NULL; 04309 04310 return &ret->expr; 04311 } 04312 04313 static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list) 04314 { 04315 call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t)); 04316 04317 ret->expr.eval = call_expression_eval; 04318 ret->expression = expression; 04319 ret->argument_list = argument_list ? argument_list->head : NULL; 04320 04321 return &ret->expr; 04322 } 04323 04324 static expression_t *new_this_expression(parser_ctx_t *ctx) 04325 { 04326 expression_t *ret = parser_alloc(ctx, sizeof(expression_t)); 04327 04328 ret->eval = this_expression_eval; 04329 04330 return ret; 04331 } 04332 04333 static int parser_error(const char *str) 04334 { 04335 return 0; 04336 } 04337 04338 static void set_error(parser_ctx_t *ctx, UINT error) 04339 { 04340 ctx->hres = JSCRIPT_ERROR|error; 04341 } 04342 04343 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next) 04344 { 04345 if(obj || *(ctx->ptr-1)==next) return TRUE; 04346 04347 set_error(ctx, IDS_SYNTAX_ERROR); 04348 return FALSE; 04349 } 04350 04351 04352 static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR *identifier) 04353 { 04354 identifier_expression_t *ret = parser_alloc(ctx, sizeof(identifier_expression_t)); 04355 04356 ret->expr.eval = identifier_expression_eval; 04357 ret->identifier = identifier; 04358 04359 return &ret->expr; 04360 } 04361 04362 static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t *element_list, int length) 04363 { 04364 array_literal_expression_t *ret = parser_alloc(ctx, sizeof(array_literal_expression_t)); 04365 04366 ret->expr.eval = array_literal_expression_eval; 04367 ret->element_list = element_list ? element_list->head : NULL; 04368 ret->length = length; 04369 04370 return &ret->expr; 04371 } 04372 04373 static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t *property_list) 04374 { 04375 property_value_expression_t *ret = parser_alloc(ctx, sizeof(property_value_expression_t)); 04376 04377 ret->expr.eval = property_value_expression_eval; 04378 ret->property_list = property_list ? property_list->head : NULL; 04379 04380 return &ret->expr; 04381 } 04382 04383 static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal) 04384 { 04385 literal_expression_t *ret = parser_alloc(ctx, sizeof(literal_expression_t)); 04386 04387 ret->expr.eval = literal_expression_eval; 04388 ret->literal = literal; 04389 04390 return &ret->expr; 04391 } 04392 04393 static source_elements_t *new_source_elements(parser_ctx_t *ctx) 04394 { 04395 source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t)); 04396 04397 memset(ret, 0, sizeof(*ret)); 04398 04399 return ret; 04400 } 04401 04402 static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement) 04403 { 04404 if(source_elements->statement_tail) 04405 source_elements->statement_tail = source_elements->statement_tail->next = statement; 04406 else 04407 source_elements->statement = source_elements->statement_tail = statement; 04408 04409 return source_elements; 04410 } 04411 04412 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement) 04413 { 04414 statement_list_t *ret = parser_alloc_tmp(ctx, sizeof(statement_list_t)); 04415 04416 ret->head = ret->tail = statement; 04417 04418 return ret; 04419 } 04420 04421 static statement_list_t *statement_list_add(statement_list_t *list, statement_t *statement) 04422 { 04423 list->tail = list->tail->next = statement; 04424 04425 return list; 04426 } 04427 04428 static void push_func(parser_ctx_t *ctx) 04429 { 04430 func_stack_t *new_func = parser_alloc_tmp(ctx, sizeof(func_stack_t)); 04431 04432 new_func->func_head = new_func->func_tail = NULL; 04433 new_func->var_head = new_func->var_tail = NULL; 04434 04435 new_func->next = ctx->func_stack; 04436 ctx->func_stack = new_func; 04437 } 04438 04439 static source_elements_t *function_body_parsed(parser_ctx_t *ctx, source_elements_t *source) 04440 { 04441 source->functions = ctx->func_stack->func_head; 04442 source->variables = ctx->func_stack->var_head; 04443 pop_func(ctx); 04444 04445 return source; 04446 } 04447 04448 static void program_parsed(parser_ctx_t *ctx, source_elements_t *source) 04449 { 04450 source->functions = ctx->func_stack->func_head; 04451 source->variables = ctx->func_stack->var_head; 04452 pop_func(ctx); 04453 04454 ctx->source = source; 04455 if(!ctx->lexer_error) 04456 ctx->hres = S_OK; 04457 } 04458 04459 void parser_release(parser_ctx_t *ctx) 04460 { 04461 if(--ctx->ref) 04462 return; 04463 04464 script_release(ctx->script); 04465 heap_free(ctx->begin); 04466 jsheap_free(&ctx->heap); 04467 heap_free(ctx); 04468 } 04469 04470 HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, 04471 parser_ctx_t **ret) 04472 { 04473 parser_ctx_t *parser_ctx; 04474 jsheap_t *mark; 04475 HRESULT hres; 04476 04477 const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0}; 04478 04479 parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t)); 04480 if(!parser_ctx) 04481 return E_OUTOFMEMORY; 04482 04483 parser_ctx->ref = 1; 04484 parser_ctx->hres = JSCRIPT_ERROR|IDS_SYNTAX_ERROR; 04485 parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW); 04486 04487 parser_ctx->begin = heap_strdupW(code); 04488 if(!parser_ctx->begin) { 04489 heap_free(parser_ctx); 04490 return E_OUTOFMEMORY; 04491 } 04492 04493 parser_ctx->ptr = parser_ctx->begin; 04494 parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin); 04495 04496 script_addref(ctx); 04497 parser_ctx->script = ctx; 04498 04499 mark = jsheap_mark(&ctx->tmp_heap); 04500 jsheap_init(&parser_ctx->heap); 04501 04502 push_func(parser_ctx); 04503 04504 parser_parse(parser_ctx); 04505 jsheap_clear(mark); 04506 if(FAILED(parser_ctx->hres)) { 04507 hres = parser_ctx->hres; 04508 parser_release(parser_ctx); 04509 return hres; 04510 } 04511 04512 *ret = parser_ctx; 04513 return S_OK; 04514 } 04515
Generated on Sun May 27 2012 04:24:22 for ReactOS by
1.7.6.1
