huwcampbell.com / reactos
Reactos
fork atom

[JSCRIPT] Sync with Wine Staging 3.3. CORE-14434

Amine Khaldi 8dba275b 919215fd

+853 -447
+2 -2
dll/win32/jscript/CMakeLists.txt
··· 33 33 regexp.c 34 34 string.c 35 35 vbarray.c 36 - jscript.h) 36 + precomp.h) 37 37 38 38 list(APPEND jscript_rc_deps 39 39 ${CMAKE_CURRENT_SOURCE_DIR}/jscript.rgs ··· 54 54 set_module_type(jscript win32dll) 55 55 target_link_libraries(jscript uuid wine) 56 56 add_importlibs(jscript user32 ole32 oleaut32 advapi32 msvcrt kernel32 ntdll) 57 - add_pch(jscript jscript.h SOURCE) 57 + add_pch(jscript precomp.h SOURCE) 58 58 add_cd_file(TARGET jscript DESTINATION reactos/system32 FOR all)
+8 -1
dll/win32/jscript/activex.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 19 22 #include "jscript.h" 23 + #include "objsafe.h" 24 + #include "mshtmhst.h" 20 25 21 - #include <mshtmhst.h> 26 + #include "wine/debug.h" 27 + 28 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 22 29 23 30 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */ 24 31 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
+104 -3
dll/win32/jscript/array.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <math.h> 23 + #include <assert.h> 24 + 19 25 #include "jscript.h" 26 + 27 + #include "wine/debug.h" 28 + 29 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 30 21 31 typedef struct { 22 32 jsdisp_t dispex; ··· 37 47 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0}; 38 48 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0}; 39 49 static const WCHAR unshiftW[] = {'u','n','s','h','i','f','t',0}; 50 + static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0}; 40 51 41 52 static const WCHAR default_separatorW[] = {',',0}; 42 53 ··· 377 388 hres = jsdisp_get_idx(jsthis, length, &val); 378 389 if(SUCCEEDED(hres)) 379 390 hres = jsdisp_delete_idx(jsthis, length); 380 - else if(hres == DISP_E_UNKNOWNNAME) 391 + else if(hres == DISP_E_UNKNOWNNAME) { 381 392 val = jsval_undefined(); 382 - else 393 + hres = S_OK; 394 + }else 383 395 return hres; 384 396 385 397 if(SUCCEEDED(hres)) ··· 938 950 return E_NOTIMPL; 939 951 } 940 952 953 + static HRESULT Array_indexOf(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, 954 + jsval_t *r) 955 + { 956 + jsdisp_t *jsthis; 957 + unsigned length, i, from = 0; 958 + jsval_t search, value; 959 + BOOL eq; 960 + HRESULT hres; 961 + 962 + TRACE("\n"); 963 + 964 + hres = get_length(ctx, vthis, &jsthis, &length); 965 + if(FAILED(hres)) 966 + return hres; 967 + if(!length) { 968 + if(r) *r = jsval_number(-1); 969 + return S_OK; 970 + } 971 + 972 + search = argc ? argv[0] : jsval_undefined(); 973 + 974 + if(argc > 1) { 975 + double from_arg; 976 + 977 + hres = to_integer(ctx, argv[1], &from_arg); 978 + if(FAILED(hres)) 979 + return hres; 980 + 981 + if(from_arg >= 0) 982 + from = min(from_arg, length); 983 + else 984 + from = max(from_arg + length, 0); 985 + } 986 + 987 + for(i = from; i < length; i++) { 988 + hres = jsdisp_get_idx(jsthis, i, &value); 989 + if(hres == DISP_E_UNKNOWNNAME) 990 + continue; 991 + if(FAILED(hres)) 992 + return hres; 993 + 994 + hres = jsval_strict_equal(value, search, &eq); 995 + jsval_release(value); 996 + if(FAILED(hres)) 997 + return hres; 998 + if(eq) { 999 + if(r) *r = jsval_number(i); 1000 + return S_OK; 1001 + } 1002 + } 1003 + 1004 + if(r) *r = jsval_number(-1); 1005 + return S_OK; 1006 + } 1007 + 941 1008 /* ECMA-262 3rd Edition 15.4.4.13 */ 942 1009 static HRESULT Array_unshift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, 943 1010 jsval_t *r) ··· 1036 1103 1037 1104 static const builtin_prop_t Array_props[] = { 1038 1105 {concatW, Array_concat, PROPF_METHOD|1}, 1106 + {indexOfW, Array_indexOf, PROPF_ES5|PROPF_METHOD|1}, 1039 1107 {joinW, Array_join, PROPF_METHOD|1}, 1040 1108 {lengthW, NULL,0, Array_get_length, Array_set_length}, 1041 1109 {popW, Array_pop, PROPF_METHOD}, ··· 1072 1140 Array_on_put 1073 1141 }; 1074 1142 1143 + /* ECMA-262 5.1 Edition 15.4.3.2 */ 1144 + static HRESULT ArrayConstr_isArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) 1145 + { 1146 + jsdisp_t *obj; 1147 + 1148 + TRACE("\n"); 1149 + 1150 + if(!argc || !is_object_instance(argv[0])) { 1151 + if(r) *r = jsval_bool(FALSE); 1152 + return S_OK; 1153 + } 1154 + 1155 + obj = iface_to_jsdisp(get_object(argv[0])); 1156 + if(r) *r = jsval_bool(obj && is_class(obj, JSCLASS_ARRAY)); 1157 + if(obj) jsdisp_release(obj); 1158 + return S_OK; 1159 + } 1160 + 1075 1161 static HRESULT ArrayConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, 1076 1162 jsval_t *r) 1077 1163 { ··· 1146 1232 return S_OK; 1147 1233 } 1148 1234 1235 + static const WCHAR isArrayW[] = {'i','s','A','r','r','a','y',0}; 1236 + 1237 + static const builtin_prop_t ArrayConstr_props[] = { 1238 + {isArrayW, ArrayConstr_isArray, PROPF_ES5|PROPF_METHOD|1} 1239 + }; 1240 + 1241 + static const builtin_info_t ArrayConstr_info = { 1242 + JSCLASS_FUNCTION, 1243 + DEFAULT_FUNCTION_VALUE, 1244 + sizeof(ArrayConstr_props)/sizeof(*ArrayConstr_props), 1245 + ArrayConstr_props, 1246 + NULL, 1247 + NULL 1248 + }; 1249 + 1149 1250 HRESULT create_array_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret) 1150 1251 { 1151 1252 ArrayInstance *array; ··· 1157 1258 if(FAILED(hres)) 1158 1259 return hres; 1159 1260 1160 - hres = create_builtin_constructor(ctx, ArrayConstr_value, ArrayW, NULL, PROPF_CONSTR|1, &array->dispex, ret); 1261 + hres = create_builtin_constructor(ctx, ArrayConstr_value, ArrayW, &ArrayConstr_info, PROPF_CONSTR|1, &array->dispex, ret); 1161 1262 1162 1263 jsdisp_release(&array->dispex); 1163 1264 return hres;
+6
dll/win32/jscript/bool.c
··· 17 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 18 18 */ 19 19 20 + #include <assert.h> 21 + 20 22 #include "jscript.h" 23 + 24 + #include "wine/debug.h" 25 + 26 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 21 27 22 28 typedef struct { 23 29 jsdisp_t dispex;
+68 -76
dll/win32/jscript/cc_parser.tab.c
··· 1 - /* A Bison parser, made by GNU Bison 3.0.2. */ 1 + /* A Bison parser, made by GNU Bison 3.0. */ 2 2 3 3 /* Bison implementation for Yacc-like parsers in C 4 4 ··· 44 44 #define YYBISON 1 45 45 46 46 /* Bison version. */ 47 - #define YYBISON_VERSION "3.0.2" 47 + #define YYBISON_VERSION "3.0" 48 48 49 49 /* Skeleton name. */ 50 50 #define YYSKELETON_NAME "yacc.c" ··· 70 70 /* Copy the first part of user declarations. */ 71 71 #line 19 "cc_parser.y" /* yacc.c:339 */ 72 72 73 + 73 74 #include "jscript.h" 75 + #include "engine.h" 76 + #include "parser.h" 77 + 78 + #include "wine/debug.h" 79 + 80 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 81 + 74 82 75 83 #line 84 "cc_parser.tab.c" /* yacc.c:339 */ 76 84 77 - # ifndef YY_NULLPTR 85 + # ifndef YY_NULL 78 86 # if defined __cplusplus && 201103L <= __cplusplus 79 - # define YY_NULLPTR nullptr 87 + # define YY_NULL nullptr 80 88 # else 81 - # define YY_NULLPTR 0 89 + # define YY_NULL 0 82 90 # endif 83 91 # endif 84 92 ··· 90 98 # define YYERROR_VERBOSE 0 91 99 #endif 92 100 93 - 101 + /* In a future release of Bison, this section will be replaced 102 + by #include "cc_parser.tab.h". */ 103 + #ifndef YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED 104 + # define YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED 94 105 /* Debug traces. */ 95 106 #ifndef YYDEBUG 96 107 # define YYDEBUG 0 ··· 128 139 129 140 ccval_t ccval; 130 141 131 - #line 140 "cc_parser.tab.c" /* yacc.c:355 */ 142 + #line 143 "cc_parser.tab.c" /* yacc.c:355 */ 132 143 }; 133 144 # define YYSTYPE_IS_TRIVIAL 1 134 145 # define YYSTYPE_IS_DECLARED 1 ··· 138 149 139 150 int cc_parser_parse (parser_ctx_t *ctx); 140 151 141 - 152 + #endif /* !YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED */ 142 153 143 154 /* Copy the second part of user declarations. */ 144 155 #line 47 "cc_parser.y" /* yacc.c:358 */ ··· 235 246 } 236 247 237 248 238 - #line 247 "cc_parser.tab.c" /* yacc.c:358 */ 249 + #line 250 "cc_parser.tab.c" /* yacc.c:358 */ 239 250 240 251 #ifdef short 241 252 # undef short ··· 292 303 # endif 293 304 #endif 294 305 295 - #ifndef YY_ATTRIBUTE 296 - # if (defined __GNUC__ \ 297 - && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 298 - || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 299 - # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 300 - # else 301 - # define YY_ATTRIBUTE(Spec) /* empty */ 302 - # endif 303 - #endif 304 - 305 - #ifndef YY_ATTRIBUTE_PURE 306 - # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 307 - #endif 308 - 309 - #ifndef YY_ATTRIBUTE_UNUSED 310 - # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 311 - #endif 312 - 313 - #if !defined _Noreturn \ 314 - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 315 - # if defined _MSC_VER && 1200 <= _MSC_VER 316 - # define _Noreturn __declspec (noreturn) 317 - # else 318 - # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 306 + #ifndef __attribute__ 307 + /* This feature is available in gcc versions 2.5 and later. */ 308 + # if (! defined __GNUC__ || __GNUC__ < 2 \ 309 + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) 310 + # define __attribute__(Spec) /* empty */ 319 311 # endif 320 312 #endif 321 313 ··· 553 545 "CCBitwiseORExpression", "CCBitwiseXORExpression", 554 546 "CCBitwiseANDExpression", "CCEqualityExpression", 555 547 "CCRelationalExpression", "CCShiftExpression", "CCAdditiveExpression", 556 - "CCMultiplicativeExpression", YY_NULLPTR 548 + "CCMultiplicativeExpression", YY_NULL 557 549 }; 558 550 #endif 559 551 ··· 955 947 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 956 948 yytype_int16 *yyssp, int yytoken) 957 949 { 958 - YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 950 + YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); 959 951 YYSIZE_T yysize = yysize0; 960 952 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 961 953 /* Internationalized format string. */ 962 - const char *yyformat = YY_NULLPTR; 954 + const char *yyformat = YY_NULL; 963 955 /* Arguments of yyformat. */ 964 956 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 965 957 /* Number of reported tokens (one for the "unexpected", one per ··· 1016 1008 } 1017 1009 yyarg[yycount++] = yytname[yyx]; 1018 1010 { 1019 - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1011 + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); 1020 1012 if (! (yysize <= yysize1 1021 1013 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1022 1014 return 2; ··· 1355 1347 case 2: 1356 1348 #line 146 "cc_parser.y" /* yacc.c:1646 */ 1357 1349 { ctx->ccval = (yyvsp[0].ccval); YYACCEPT; } 1358 - #line 1367 "cc_parser.tab.c" /* yacc.c:1646 */ 1350 + #line 1351 "cc_parser.tab.c" /* yacc.c:1646 */ 1359 1351 break; 1360 1352 1361 1353 case 3: 1362 1354 #line 149 "cc_parser.y" /* yacc.c:1646 */ 1363 1355 { (yyval.ccval) = (yyvsp[0].ccval); } 1364 - #line 1373 "cc_parser.tab.c" /* yacc.c:1646 */ 1356 + #line 1357 "cc_parser.tab.c" /* yacc.c:1646 */ 1365 1357 break; 1366 1358 1367 1359 case 4: 1368 1360 #line 150 "cc_parser.y" /* yacc.c:1646 */ 1369 1361 { (yyval.ccval) = (yyvsp[-1].ccval); } 1370 - #line 1379 "cc_parser.tab.c" /* yacc.c:1646 */ 1362 + #line 1363 "cc_parser.tab.c" /* yacc.c:1646 */ 1371 1363 break; 1372 1364 1373 1365 case 5: 1374 1366 #line 151 "cc_parser.y" /* yacc.c:1646 */ 1375 1367 { (yyval.ccval) = ccval_bool(!get_ccbool((yyvsp[0].ccval))); } 1376 - #line 1385 "cc_parser.tab.c" /* yacc.c:1646 */ 1368 + #line 1369 "cc_parser.tab.c" /* yacc.c:1646 */ 1377 1369 break; 1378 1370 1379 1371 case 6: 1380 1372 #line 152 "cc_parser.y" /* yacc.c:1646 */ 1381 1373 { FIXME("'~' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1382 - #line 1391 "cc_parser.tab.c" /* yacc.c:1646 */ 1374 + #line 1375 "cc_parser.tab.c" /* yacc.c:1646 */ 1383 1375 break; 1384 1376 1385 1377 case 7: 1386 1378 #line 153 "cc_parser.y" /* yacc.c:1646 */ 1387 1379 { FIXME("'+' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1388 - #line 1397 "cc_parser.tab.c" /* yacc.c:1646 */ 1380 + #line 1381 "cc_parser.tab.c" /* yacc.c:1646 */ 1389 1381 break; 1390 1382 1391 1383 case 8: 1392 1384 #line 154 "cc_parser.y" /* yacc.c:1646 */ 1393 1385 { FIXME("'-' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1394 - #line 1403 "cc_parser.tab.c" /* yacc.c:1646 */ 1386 + #line 1387 "cc_parser.tab.c" /* yacc.c:1646 */ 1395 1387 break; 1396 1388 1397 1389 case 9: 1398 1390 #line 157 "cc_parser.y" /* yacc.c:1646 */ 1399 1391 { (yyval.ccval) = (yyvsp[0].ccval); } 1400 - #line 1409 "cc_parser.tab.c" /* yacc.c:1646 */ 1392 + #line 1393 "cc_parser.tab.c" /* yacc.c:1646 */ 1401 1393 break; 1402 1394 1403 1395 case 10: 1404 1396 #line 159 "cc_parser.y" /* yacc.c:1646 */ 1405 1397 { FIXME("'||' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1406 - #line 1415 "cc_parser.tab.c" /* yacc.c:1646 */ 1398 + #line 1399 "cc_parser.tab.c" /* yacc.c:1646 */ 1407 1399 break; 1408 1400 1409 1401 case 11: 1410 1402 #line 162 "cc_parser.y" /* yacc.c:1646 */ 1411 1403 { (yyval.ccval) = (yyvsp[0].ccval); } 1412 - #line 1421 "cc_parser.tab.c" /* yacc.c:1646 */ 1404 + #line 1405 "cc_parser.tab.c" /* yacc.c:1646 */ 1413 1405 break; 1414 1406 1415 1407 case 12: 1416 1408 #line 164 "cc_parser.y" /* yacc.c:1646 */ 1417 1409 { FIXME("'&&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1418 - #line 1427 "cc_parser.tab.c" /* yacc.c:1646 */ 1410 + #line 1411 "cc_parser.tab.c" /* yacc.c:1646 */ 1419 1411 break; 1420 1412 1421 1413 case 13: 1422 1414 #line 167 "cc_parser.y" /* yacc.c:1646 */ 1423 1415 { (yyval.ccval) = (yyvsp[0].ccval); } 1424 - #line 1433 "cc_parser.tab.c" /* yacc.c:1646 */ 1416 + #line 1417 "cc_parser.tab.c" /* yacc.c:1646 */ 1425 1417 break; 1426 1418 1427 1419 case 14: 1428 1420 #line 169 "cc_parser.y" /* yacc.c:1646 */ 1429 1421 { FIXME("'|' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1430 - #line 1439 "cc_parser.tab.c" /* yacc.c:1646 */ 1422 + #line 1423 "cc_parser.tab.c" /* yacc.c:1646 */ 1431 1423 break; 1432 1424 1433 1425 case 15: 1434 1426 #line 172 "cc_parser.y" /* yacc.c:1646 */ 1435 1427 { (yyval.ccval) = (yyvsp[0].ccval); } 1436 - #line 1445 "cc_parser.tab.c" /* yacc.c:1646 */ 1428 + #line 1429 "cc_parser.tab.c" /* yacc.c:1646 */ 1437 1429 break; 1438 1430 1439 1431 case 16: 1440 1432 #line 174 "cc_parser.y" /* yacc.c:1646 */ 1441 1433 { FIXME("'^' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1442 - #line 1451 "cc_parser.tab.c" /* yacc.c:1646 */ 1434 + #line 1435 "cc_parser.tab.c" /* yacc.c:1646 */ 1443 1435 break; 1444 1436 1445 1437 case 17: 1446 1438 #line 177 "cc_parser.y" /* yacc.c:1646 */ 1447 1439 { (yyval.ccval) = (yyvsp[0].ccval); } 1448 - #line 1457 "cc_parser.tab.c" /* yacc.c:1646 */ 1440 + #line 1441 "cc_parser.tab.c" /* yacc.c:1646 */ 1449 1441 break; 1450 1442 1451 1443 case 18: 1452 1444 #line 179 "cc_parser.y" /* yacc.c:1646 */ 1453 1445 { FIXME("'&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1454 - #line 1463 "cc_parser.tab.c" /* yacc.c:1646 */ 1446 + #line 1447 "cc_parser.tab.c" /* yacc.c:1646 */ 1455 1447 break; 1456 1448 1457 1449 case 19: 1458 1450 #line 182 "cc_parser.y" /* yacc.c:1646 */ 1459 1451 { (yyval.ccval) = (yyvsp[0].ccval); } 1460 - #line 1469 "cc_parser.tab.c" /* yacc.c:1646 */ 1452 + #line 1453 "cc_parser.tab.c" /* yacc.c:1646 */ 1461 1453 break; 1462 1454 1463 1455 case 20: 1464 1456 #line 184 "cc_parser.y" /* yacc.c:1646 */ 1465 1457 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) == get_ccnum((yyvsp[0].ccval))); } 1466 - #line 1475 "cc_parser.tab.c" /* yacc.c:1646 */ 1458 + #line 1459 "cc_parser.tab.c" /* yacc.c:1646 */ 1467 1459 break; 1468 1460 1469 1461 case 21: 1470 1462 #line 186 "cc_parser.y" /* yacc.c:1646 */ 1471 1463 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) != get_ccnum((yyvsp[0].ccval))); } 1472 - #line 1481 "cc_parser.tab.c" /* yacc.c:1646 */ 1464 + #line 1465 "cc_parser.tab.c" /* yacc.c:1646 */ 1473 1465 break; 1474 1466 1475 1467 case 22: 1476 1468 #line 188 "cc_parser.y" /* yacc.c:1646 */ 1477 1469 { FIXME("'===' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1478 - #line 1487 "cc_parser.tab.c" /* yacc.c:1646 */ 1470 + #line 1471 "cc_parser.tab.c" /* yacc.c:1646 */ 1479 1471 break; 1480 1472 1481 1473 case 23: 1482 1474 #line 190 "cc_parser.y" /* yacc.c:1646 */ 1483 1475 { FIXME("'!==' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1484 - #line 1493 "cc_parser.tab.c" /* yacc.c:1646 */ 1476 + #line 1477 "cc_parser.tab.c" /* yacc.c:1646 */ 1485 1477 break; 1486 1478 1487 1479 case 24: 1488 1480 #line 193 "cc_parser.y" /* yacc.c:1646 */ 1489 1481 { (yyval.ccval) = (yyvsp[0].ccval); } 1490 - #line 1499 "cc_parser.tab.c" /* yacc.c:1646 */ 1482 + #line 1483 "cc_parser.tab.c" /* yacc.c:1646 */ 1491 1483 break; 1492 1484 1493 1485 case 25: 1494 1486 #line 195 "cc_parser.y" /* yacc.c:1646 */ 1495 1487 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) < get_ccnum((yyvsp[0].ccval))); } 1496 - #line 1505 "cc_parser.tab.c" /* yacc.c:1646 */ 1488 + #line 1489 "cc_parser.tab.c" /* yacc.c:1646 */ 1497 1489 break; 1498 1490 1499 1491 case 26: 1500 1492 #line 197 "cc_parser.y" /* yacc.c:1646 */ 1501 1493 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) <= get_ccnum((yyvsp[0].ccval))); } 1502 - #line 1511 "cc_parser.tab.c" /* yacc.c:1646 */ 1494 + #line 1495 "cc_parser.tab.c" /* yacc.c:1646 */ 1503 1495 break; 1504 1496 1505 1497 case 27: 1506 1498 #line 199 "cc_parser.y" /* yacc.c:1646 */ 1507 1499 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) > get_ccnum((yyvsp[0].ccval))); } 1508 - #line 1517 "cc_parser.tab.c" /* yacc.c:1646 */ 1500 + #line 1501 "cc_parser.tab.c" /* yacc.c:1646 */ 1509 1501 break; 1510 1502 1511 1503 case 28: 1512 1504 #line 201 "cc_parser.y" /* yacc.c:1646 */ 1513 1505 { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) >= get_ccnum((yyvsp[0].ccval))); } 1514 - #line 1523 "cc_parser.tab.c" /* yacc.c:1646 */ 1506 + #line 1507 "cc_parser.tab.c" /* yacc.c:1646 */ 1515 1507 break; 1516 1508 1517 1509 case 29: 1518 1510 #line 204 "cc_parser.y" /* yacc.c:1646 */ 1519 1511 { (yyval.ccval) = (yyvsp[0].ccval); } 1520 - #line 1529 "cc_parser.tab.c" /* yacc.c:1646 */ 1512 + #line 1513 "cc_parser.tab.c" /* yacc.c:1646 */ 1521 1513 break; 1522 1514 1523 1515 case 30: 1524 1516 #line 206 "cc_parser.y" /* yacc.c:1646 */ 1525 1517 { FIXME("'<<' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1526 - #line 1535 "cc_parser.tab.c" /* yacc.c:1646 */ 1518 + #line 1519 "cc_parser.tab.c" /* yacc.c:1646 */ 1527 1519 break; 1528 1520 1529 1521 case 31: 1530 1522 #line 208 "cc_parser.y" /* yacc.c:1646 */ 1531 1523 { FIXME("'>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1532 - #line 1541 "cc_parser.tab.c" /* yacc.c:1646 */ 1524 + #line 1525 "cc_parser.tab.c" /* yacc.c:1646 */ 1533 1525 break; 1534 1526 1535 1527 case 32: 1536 1528 #line 210 "cc_parser.y" /* yacc.c:1646 */ 1537 1529 { FIXME("'>>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1538 - #line 1547 "cc_parser.tab.c" /* yacc.c:1646 */ 1530 + #line 1531 "cc_parser.tab.c" /* yacc.c:1646 */ 1539 1531 break; 1540 1532 1541 1533 case 33: 1542 1534 #line 213 "cc_parser.y" /* yacc.c:1646 */ 1543 1535 { (yyval.ccval) = (yyvsp[0].ccval); } 1544 - #line 1553 "cc_parser.tab.c" /* yacc.c:1646 */ 1536 + #line 1537 "cc_parser.tab.c" /* yacc.c:1646 */ 1545 1537 break; 1546 1538 1547 1539 case 34: 1548 1540 #line 215 "cc_parser.y" /* yacc.c:1646 */ 1549 1541 { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) + get_ccnum((yyvsp[0].ccval))); } 1550 - #line 1559 "cc_parser.tab.c" /* yacc.c:1646 */ 1542 + #line 1543 "cc_parser.tab.c" /* yacc.c:1646 */ 1551 1543 break; 1552 1544 1553 1545 case 35: 1554 1546 #line 217 "cc_parser.y" /* yacc.c:1646 */ 1555 1547 { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) - get_ccnum((yyvsp[0].ccval))); } 1556 - #line 1565 "cc_parser.tab.c" /* yacc.c:1646 */ 1548 + #line 1549 "cc_parser.tab.c" /* yacc.c:1646 */ 1557 1549 break; 1558 1550 1559 1551 case 36: 1560 1552 #line 220 "cc_parser.y" /* yacc.c:1646 */ 1561 1553 { (yyval.ccval) = (yyvsp[0].ccval); } 1562 - #line 1571 "cc_parser.tab.c" /* yacc.c:1646 */ 1554 + #line 1555 "cc_parser.tab.c" /* yacc.c:1646 */ 1563 1555 break; 1564 1556 1565 1557 case 37: 1566 1558 #line 222 "cc_parser.y" /* yacc.c:1646 */ 1567 1559 { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) * get_ccnum((yyvsp[0].ccval))); } 1568 - #line 1577 "cc_parser.tab.c" /* yacc.c:1646 */ 1560 + #line 1561 "cc_parser.tab.c" /* yacc.c:1646 */ 1569 1561 break; 1570 1562 1571 1563 case 38: 1572 1564 #line 224 "cc_parser.y" /* yacc.c:1646 */ 1573 1565 { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) / get_ccnum((yyvsp[0].ccval))); } 1574 - #line 1583 "cc_parser.tab.c" /* yacc.c:1646 */ 1566 + #line 1567 "cc_parser.tab.c" /* yacc.c:1646 */ 1575 1567 break; 1576 1568 1577 1569 case 39: 1578 1570 #line 226 "cc_parser.y" /* yacc.c:1646 */ 1579 1571 { FIXME("'%%' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } 1580 - #line 1589 "cc_parser.tab.c" /* yacc.c:1646 */ 1572 + #line 1573 "cc_parser.tab.c" /* yacc.c:1646 */ 1581 1573 break; 1582 1574 1583 1575 1584 - #line 1593 "cc_parser.tab.c" /* yacc.c:1646 */ 1576 + #line 1577 "cc_parser.tab.c" /* yacc.c:1646 */ 1585 1577 default: break; 1586 1578 } 1587 1579 /* User semantic actions sometimes alter yychar, and that requires
+82
dll/win32/jscript/cc_parser.tab.h
··· 1 + /* A Bison parser, made by GNU Bison 3.0. */ 2 + 3 + /* Bison interface for Yacc-like parsers in C 4 + 5 + Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc. 6 + 7 + This program is free software: you can redistribute it and/or modify 8 + it under the terms of the GNU General Public License as published by 9 + the Free Software Foundation, either version 3 of the License, or 10 + (at your option) any later version. 11 + 12 + This program is distributed in the hope that it will be useful, 13 + but WITHOUT ANY WARRANTY; without even the implied warranty of 14 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 + GNU General Public License for more details. 16 + 17 + You should have received a copy of the GNU General Public License 18 + along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 + 20 + /* As a special exception, you may create a larger work that contains 21 + part or all of the Bison parser skeleton and distribute that work 22 + under terms of your choice, so long as that work isn't itself a 23 + parser generator using the skeleton or a modified version thereof 24 + as a parser skeleton. Alternatively, if you modify or redistribute 25 + the parser skeleton itself, you may (at your option) remove this 26 + special exception, which will cause the skeleton and the resulting 27 + Bison output files to be licensed under the GNU General Public 28 + License without this special exception. 29 + 30 + This special exception was added by the Free Software Foundation in 31 + version 2.2 of Bison. */ 32 + 33 + #ifndef YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED 34 + # define YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED 35 + /* Debug traces. */ 36 + #ifndef YYDEBUG 37 + # define YYDEBUG 0 38 + #endif 39 + #if YYDEBUG 40 + extern int cc_parser_debug; 41 + #endif 42 + 43 + /* Token type. */ 44 + #ifndef YYTOKENTYPE 45 + # define YYTOKENTYPE 46 + enum yytokentype 47 + { 48 + tEQ = 258, 49 + tEQEQ = 259, 50 + tNEQ = 260, 51 + tNEQEQ = 261, 52 + tLSHIFT = 262, 53 + tRSHIFT = 263, 54 + tRRSHIFT = 264, 55 + tOR = 265, 56 + tAND = 266, 57 + tLEQ = 267, 58 + tGEQ = 268, 59 + tCCValue = 269 60 + }; 61 + #endif 62 + 63 + /* Value type. */ 64 + #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 65 + typedef union YYSTYPE YYSTYPE; 66 + union YYSTYPE 67 + { 68 + #line 36 "cc_parser.y" /* yacc.c:1909 */ 69 + 70 + ccval_t ccval; 71 + 72 + #line 73 "cc_parser.tab.h" /* yacc.c:1909 */ 73 + }; 74 + # define YYSTYPE_IS_TRIVIAL 1 75 + # define YYSTYPE_IS_DECLARED 1 76 + #endif 77 + 78 + 79 + 80 + int cc_parser_parse (parser_ctx_t *ctx); 81 + 82 + #endif /* !YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED */
+6
dll/win32/jscript/cc_parser.y
··· 19 19 %{ 20 20 21 21 #include "jscript.h" 22 + #include "engine.h" 23 + #include "parser.h" 24 + 25 + #include "wine/debug.h" 26 + 27 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 22 28 23 29 %} 24 30
+20 -13
dll/win32/jscript/compile.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <math.h> 20 + #include <assert.h> 21 + 19 22 #include "jscript.h" 23 + #include "engine.h" 24 + #include "parser.h" 20 25 21 - #include <wine/rbtree.h> 26 + #include "wine/rbtree.h" 27 + #include "wine/debug.h" 22 28 29 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 23 30 WINE_DECLARE_DEBUG_CHANNEL(jscript_disas); 24 31 25 32 typedef struct _statement_ctx_t { ··· 854 861 855 862 static HRESULT compile_array_literal(compiler_ctx_t *ctx, array_literal_expression_t *expr) 856 863 { 857 - unsigned i, elem_cnt = expr->length; 864 + unsigned length = 0; 858 865 array_element_t *iter; 866 + unsigned array_instr; 859 867 HRESULT hres; 860 868 861 - for(iter = expr->element_list; iter; iter = iter->next) { 862 - elem_cnt += iter->elision+1; 869 + array_instr = push_instr(ctx, OP_carray); 863 870 864 - for(i=0; i < iter->elision; i++) { 865 - if(!push_instr(ctx, OP_undefined)) 866 - return E_OUTOFMEMORY; 867 - } 871 + for(iter = expr->element_list; iter; iter = iter->next) { 872 + length += iter->elision; 868 873 869 874 hres = compile_expression(ctx, iter->expr, TRUE); 870 875 if(FAILED(hres)) 871 876 return hres; 872 - } 873 877 874 - for(i=0; i < expr->length; i++) { 875 - if(!push_instr(ctx, OP_undefined)) 876 - return E_OUTOFMEMORY; 878 + hres = push_instr_uint(ctx, OP_carray_set, length); 879 + if(FAILED(hres)) 880 + return hres; 881 + 882 + length++; 877 883 } 878 884 879 - return push_instr_uint(ctx, OP_carray, elem_cnt); 885 + instr_ptr(ctx, array_instr)->u.arg[0].uint = length + expr->length; 886 + return S_OK; 880 887 } 881 888 882 889 static HRESULT compile_object_literal(compiler_ctx_t *ctx, property_value_expression_t *expr)
+35 -10
dll/win32/jscript/date.c
··· 17 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 18 18 */ 19 19 20 + #include "config.h" 21 + #include "wine/port.h" 22 + 23 + #include <limits.h> 24 + #include <math.h> 25 + #include <assert.h> 26 + 20 27 #include "jscript.h" 28 + 29 + #include "wine/debug.h" 30 + 31 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 21 32 22 33 /* 1601 to 1970 is 369 years plus 89 leap days */ 23 34 #define TIME_EPOCH ((ULONGLONG)(369 * 365 + 89) * 86400 * 1000) ··· 81 92 static const WCHAR setYearW[] = {'s','e','t','Y','e','a','r',0}; 82 93 83 94 static const WCHAR UTCW[] = {'U','T','C',0}; 95 + static const WCHAR nowW[] = {'n','o','w',0}; 84 96 static const WCHAR parseW[] = {'p','a','r','s','e',0}; 85 97 86 98 static inline DateInstance *date_from_jsdisp(jsdisp_t *jsdisp) ··· 439 451 } 440 452 441 453 return floor(time); 454 + } 455 + 456 + static double date_now(void) 457 + { 458 + FILETIME ftime; 459 + LONGLONG time; 460 + 461 + GetSystemTimeAsFileTime(&ftime); 462 + time = ((LONGLONG)ftime.dwHighDateTime << 32) + ftime.dwLowDateTime; 463 + 464 + return time/10000 - TIME_EPOCH; 442 465 } 443 466 444 467 static SYSTEMTIME create_systemtime(DOUBLE time) ··· 2350 2373 return hres; 2351 2374 } 2352 2375 2376 + /* ECMA-262 5.1 Edition 15.9.4.4 */ 2377 + static HRESULT DateConstr_now(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) 2378 + { 2379 + TRACE("\n"); 2380 + 2381 + if(r) *r = jsval_number(date_now()); 2382 + return S_OK; 2383 + } 2384 + 2353 2385 static HRESULT DateConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, 2354 2386 jsval_t *r) 2355 2387 { ··· 2362 2394 case DISPATCH_CONSTRUCT: 2363 2395 switch(argc) { 2364 2396 /* ECMA-262 3rd Edition 15.9.3.3 */ 2365 - case 0: { 2366 - FILETIME time; 2367 - LONGLONG lltime; 2368 - 2369 - GetSystemTimeAsFileTime(&time); 2370 - lltime = ((LONGLONG)time.dwHighDateTime<<32) 2371 - + time.dwLowDateTime; 2372 - 2373 - hres = create_date(ctx, NULL, lltime/10000-TIME_EPOCH, &date); 2397 + case 0: 2398 + hres = create_date(ctx, NULL, date_now(), &date); 2374 2399 if(FAILED(hres)) 2375 2400 return hres; 2376 2401 break; 2377 - } 2378 2402 2379 2403 /* ECMA-262 3rd Edition 15.9.3.2 */ 2380 2404 case 1: { ··· 2443 2467 2444 2468 static const builtin_prop_t DateConstr_props[] = { 2445 2469 {UTCW, DateConstr_UTC, PROPF_METHOD}, 2470 + {nowW, DateConstr_now, PROPF_HTML|PROPF_METHOD}, 2446 2471 {parseW, DateConstr_parse, PROPF_METHOD} 2447 2472 }; 2448 2473
+4
dll/win32/jscript/decode.c
··· 18 18 19 19 #include "jscript.h" 20 20 21 + #include "wine/debug.h" 22 + 23 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 24 + 21 25 /* 22 26 * This file implements algorithm for decoding scripts encoded by 23 27 * screnc.exe. The 'secret' algorithm that's well documented here:
+19 -1
dll/win32/jscript/dispex.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <assert.h> 20 + 19 21 #include "jscript.h" 22 + 23 + #include "wine/unicode.h" 24 + #include "wine/debug.h" 25 + 26 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 27 21 28 #define FDEX_VERSION_MASK 0xf0000000 22 29 #define GOLDEN_RATIO 0x9E3779B9U ··· 83 90 i = (min+max)/2; 84 91 85 92 r = strcmpW(name, This->builtin_info->props[i].name); 86 - if(!r) 93 + if(!r) { 94 + /* Skip prop if it's available only in higher compatibility mode. */ 95 + unsigned version = (This->builtin_info->props[i].flags & PROPF_VERSION_MASK) 96 + >> PROPF_VERSION_SHIFT; 97 + if(version && version > This->ctx->version) 98 + return NULL; 99 + 100 + /* Skip prop if it's available only in HTML mode and we're not running in HTML mode. */ 101 + if((This->builtin_info->props[i].flags & PROPF_HTML) && !This->ctx->html_mode) 102 + return NULL; 103 + 87 104 return This->builtin_info->props + i; 105 + } 88 106 89 107 if(r < 0) 90 108 max = i-1;
+35 -19
dll/win32/jscript/engine.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <math.h> 23 + #include <assert.h> 24 + 19 25 #include "jscript.h" 26 + #include "engine.h" 27 + 28 + #include "wine/debug.h" 29 + 30 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 31 21 32 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0}; 22 33 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0}; ··· 514 525 } 515 526 516 527 /* ECMA-262 3rd Edition 11.9.6 */ 517 - static HRESULT equal2_values(jsval_t lval, jsval_t rval, BOOL *ret) 528 + HRESULT jsval_strict_equal(jsval_t lval, jsval_t rval, BOOL *ret) 518 529 { 519 530 jsval_type_t type = jsval_type(lval); 520 531 ··· 843 854 TRACE("\n"); 844 855 845 856 v = stack_pop(ctx); 846 - hres = equal2_values(stack_top(ctx), v, &b); 857 + hres = jsval_strict_equal(stack_top(ctx), v, &b); 847 858 jsval_release(v); 848 859 if(FAILED(hres)) 849 860 return hres; ··· 1290 1301 jsval_t copy; 1291 1302 HRESULT hres; 1292 1303 1293 - TRACE("%d\n", arg); 1304 + TRACE("%d: %s\n", arg, debugstr_w(local_name(frame, arg))); 1294 1305 1295 1306 if(!frame->base_scope || !frame->base_scope->frame) 1296 1307 return identifier_value(ctx, local_name(frame, arg)); ··· 1393 1404 { 1394 1405 const unsigned arg = get_op_uint(ctx, 0); 1395 1406 jsdisp_t *array; 1396 - jsval_t val; 1397 - unsigned i; 1398 1407 HRESULT hres; 1399 1408 1400 1409 TRACE("%u\n", arg); ··· 1403 1412 if(FAILED(hres)) 1404 1413 return hres; 1405 1414 1406 - i = arg; 1407 - while(i--) { 1408 - val = stack_pop(ctx); 1409 - hres = jsdisp_propput_idx(array, i, val); 1410 - jsval_release(val); 1411 - if(FAILED(hres)) { 1412 - jsdisp_release(array); 1413 - return hres; 1414 - } 1415 - } 1415 + return stack_push(ctx, jsval_obj(array)); 1416 + } 1417 + 1418 + static HRESULT interp_carray_set(script_ctx_t *ctx) 1419 + { 1420 + const unsigned index = get_op_uint(ctx, 0); 1421 + jsval_t value, array; 1422 + HRESULT hres; 1423 + 1424 + value = stack_pop(ctx); 1425 + 1426 + TRACE("[%u] = %s\n", index, debugstr_jsval(value)); 1416 1427 1417 - return stack_push(ctx, jsval_obj(array)); 1428 + array = stack_top(ctx); 1429 + assert(is_object_instance(array)); 1430 + 1431 + hres = jsdisp_propput_idx(iface_to_jsdisp(get_object(array)), index, value); 1432 + jsval_release(value); 1433 + return hres; 1418 1434 } 1419 1435 1420 1436 /* ECMA-262 3rd Edition 11.1.5 */ ··· 2092 2108 static HRESULT equal_values(script_ctx_t *ctx, jsval_t lval, jsval_t rval, BOOL *ret) 2093 2109 { 2094 2110 if(jsval_type(lval) == jsval_type(rval) || (is_number(lval) && is_number(rval))) 2095 - return equal2_values(lval, rval, ret); 2111 + return jsval_strict_equal(lval, rval, ret); 2096 2112 2097 2113 /* FIXME: NULL disps should be handled in more general way */ 2098 2114 if(is_object_instance(lval) && !get_object(lval)) ··· 2222 2238 2223 2239 TRACE("%s === %s\n", debugstr_jsval(l), debugstr_jsval(r)); 2224 2240 2225 - hres = equal2_values(r, l, &b); 2241 + hres = jsval_strict_equal(r, l, &b); 2226 2242 jsval_release(l); 2227 2243 jsval_release(r); 2228 2244 if(FAILED(hres)) ··· 2243 2259 r = stack_pop(ctx); 2244 2260 l = stack_pop(ctx); 2245 2261 2246 - hres = equal2_values(r, l, &b); 2262 + hres = jsval_strict_equal(r, l, &b); 2247 2263 jsval_release(l); 2248 2264 jsval_release(r); 2249 2265 if(FAILED(hres))
+2 -1
dll/win32/jscript/engine.h
··· 23 23 X(and, 1, 0,0) \ 24 24 X(array, 1, 0,0) \ 25 25 X(assign, 1, 0,0) \ 26 - X(assign_call,1, ARG_UINT, 0) \ 26 + X(assign_call,1, ARG_UINT, 0) \ 27 27 X(bool, 1, ARG_INT, 0) \ 28 28 X(bneg, 1, 0,0) \ 29 29 X(call, 1, ARG_UINT, ARG_UINT) \ 30 30 X(call_member,1, ARG_UINT, ARG_UINT) \ 31 31 X(carray, 1, ARG_UINT, 0) \ 32 + X(carray_set, 1, ARG_UINT, 0) \ 32 33 X(case, 0, ARG_ADDR, 0) \ 33 34 X(cnd_nz, 0, ARG_ADDR, 0) \ 34 35 X(cnd_z, 0, ARG_ADDR, 0) \
+9
dll/win32/jscript/error.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <math.h> 23 + 19 24 #include "jscript.h" 25 + 26 + #include "wine/debug.h" 27 + 28 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 29 21 30 static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0}; 22 31 static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
+7
dll/win32/jscript/function.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <assert.h> 20 + 19 21 #include "jscript.h" 22 + #include "engine.h" 23 + 24 + #include "wine/debug.h" 25 + 26 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 27 21 28 typedef struct { 22 29 jsdisp_t dispex;
+10
dll/win32/jscript/global.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <math.h> 23 + #include <limits.h> 24 + 19 25 #include "jscript.h" 26 + #include "engine.h" 20 27 28 + #include "wine/debug.h" 29 + 30 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 21 31 22 32 static const WCHAR NaNW[] = {'N','a','N',0}; 23 33 static const WCHAR InfinityW[] = {'I','n','f','i','n','i','t','y',0};
+14 -2
dll/win32/jscript/jscript.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <assert.h> 20 + 19 21 #include "jscript.h" 22 + #include "engine.h" 23 + #include "objsafe.h" 24 + 25 + #include "wine/debug.h" 26 + 27 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 28 21 29 #ifdef _WIN64 22 30 ··· 47 55 LONG thread_id; 48 56 LCID lcid; 49 57 DWORD version; 58 + BOOL html_mode; 50 59 BOOL is_encode; 51 60 52 61 IActiveScriptSite *site; ··· 704 713 ctx->active_script = &This->IActiveScript_iface; 705 714 ctx->safeopt = This->safeopt; 706 715 ctx->version = This->version; 716 + ctx->html_mode = This->html_mode; 707 717 ctx->ei.val = jsval_undefined(); 708 718 heap_pool_init(&ctx->tmp_heap); 709 719 ··· 912 922 913 923 switch(dwProperty) { 914 924 case SCRIPTPROP_INVOKEVERSIONING: 915 - if(V_VT(pvarValue) != VT_I4 || V_I4(pvarValue) < 0 || V_I4(pvarValue) > 15) { 925 + if(V_VT(pvarValue) != VT_I4 || V_I4(pvarValue) < 0 926 + || (V_I4(pvarValue) > 15 && !(V_I4(pvarValue) & SCRIPTLANGUAGEVERSION_HTML))) { 916 927 WARN("invalid value %s\n", debugstr_variant(pvarValue)); 917 928 return E_INVALIDARG; 918 929 } 919 930 920 - This->version = V_I4(pvarValue); 931 + This->version = V_I4(pvarValue) & 0x1ff; 932 + This->html_mode = (V_I4(pvarValue) & SCRIPTLANGUAGEVERSION_HTML) != 0; 921 933 break; 922 934 default: 923 935 FIXME("Unimplemented property %x\n", dwProperty);
+32 -49
dll/win32/jscript/jscript.h
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 - #ifndef _WINE_JSCRIPT_H 20 - #define _WINE_JSCRIPT_H 21 - 22 - #include <wine/config.h> 23 - #include <wine/port.h> 19 + #pragma once 24 20 25 - #include <assert.h> 26 21 #include <stdarg.h> 22 + #include <stdio.h> 27 23 28 - #define WIN32_NO_STATUS 29 - #define _INC_WINDOWS 30 - #define COM_NO_WINDOWS_H 24 + #define COBJMACROS 31 25 32 - #define COBJMACROS 26 + #include "windef.h" 27 + #include "winbase.h" 28 + #include "winuser.h" 29 + #include "ole2.h" 30 + #include "dispex.h" 31 + #include "activscp.h" 33 32 34 - #include <windef.h> 35 - #include <winbase.h> 36 - #include <objbase.h> 37 - #include <oleauto.h> 38 - #include <dispex.h> 39 - #include <activscp.h> 40 - #include <objsafe.h> 33 + #include "resource.h" 41 34 42 - #include <wine/debug.h> 43 - #include <wine/list.h> 44 - #include <wine/unicode.h> 35 + #include "wine/unicode.h" 36 + #include "wine/heap.h" 37 + #include "wine/list.h" 45 38 46 - WINE_DEFAULT_DEBUG_CHANNEL(jscript); 39 + /* 40 + * This is Wine jscript extension for ES5 compatible mode. Native IE9+ implements 41 + * a separated JavaScript enging in side MSHTML. We implement its features here 42 + * and enable it when HTML flag is specified in SCRIPTPROP_INVOKEVERSIONING property. 43 + */ 44 + #define SCRIPTLANGUAGEVERSION_HTML 0x400 47 45 48 - #include "resource.h" 46 + /* 47 + * This is Wine jscript extension for ES5 compatible mode. Allowed only in HTML mode. 48 + */ 49 + #define SCRIPTLANGUAGEVERSION_ES5 0x102 49 50 50 51 typedef struct _jsval_t jsval_t; 51 52 typedef struct _jsstr_t jsstr_t; ··· 68 69 void heap_pool_free(heap_pool_t*) DECLSPEC_HIDDEN; 69 70 heap_pool_t *heap_pool_mark(heap_pool_t*) DECLSPEC_HIDDEN; 70 71 71 - static inline void* __WINE_ALLOC_SIZE(1) heap_alloc(size_t size) 72 - { 73 - return HeapAlloc(GetProcessHeap(), 0, size); 74 - } 75 - 76 - static inline void* __WINE_ALLOC_SIZE(1) heap_alloc_zero(size_t size) 77 - { 78 - return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); 79 - } 80 - 81 - static inline void* __WINE_ALLOC_SIZE(2) heap_realloc(void *mem, size_t size) 82 - { 83 - return HeapReAlloc(GetProcessHeap(), 0, mem, size); 84 - } 85 - 86 - static inline BOOL heap_free(void *mem) 87 - { 88 - return HeapFree(GetProcessHeap(), 0, mem); 89 - } 90 - 91 72 static inline LPWSTR heap_strdupW(LPCWSTR str) 92 73 { 93 74 LPWSTR ret = NULL; ··· 114 95 #define PROPF_CONSTR 0x0400 115 96 #define PROPF_CONST 0x0800 116 97 #define PROPF_DONTDELETE 0x1000 98 + 99 + #define PROPF_VERSION_MASK 0x01ff0000 100 + #define PROPF_VERSION_SHIFT 16 101 + #define PROPF_HTML (SCRIPTLANGUAGEVERSION_HTML << PROPF_VERSION_SHIFT) 102 + #define PROPF_ES5 ((SCRIPTLANGUAGEVERSION_HTML|SCRIPTLANGUAGEVERSION_ES5) << PROPF_VERSION_SHIFT) 117 103 118 104 /* 119 105 * This is our internal dispatch flag informing calee that it's called directly from interpreter. ··· 357 343 HRESULT to_flat_string(script_ctx_t*,jsval_t,jsstr_t**,const WCHAR**) DECLSPEC_HIDDEN; 358 344 HRESULT to_object(script_ctx_t*,jsval_t,IDispatch**) DECLSPEC_HIDDEN; 359 345 346 + HRESULT jsval_strict_equal(jsval_t,jsval_t,BOOL*) DECLSPEC_HIDDEN; 347 + 360 348 HRESULT variant_change_type(script_ctx_t*,VARIANT*,VARIANT*,VARTYPE) DECLSPEC_HIDDEN; 361 349 362 350 HRESULT decode_source(WCHAR*) DECLSPEC_HIDDEN; ··· 412 400 IInternetHostSecurityManager *secmgr; 413 401 DWORD safeopt; 414 402 DWORD version; 403 + BOOL html_mode; 415 404 LCID lcid; 416 405 cc_ctx_t *cc; 417 406 JSCaller *jscaller; ··· 516 505 517 506 static inline DWORD make_grfdex(script_ctx_t *ctx, DWORD flags) 518 507 { 519 - return (ctx->version << 28) | flags; 508 + return ((ctx->version & 0xff) << 28) | flags; 520 509 } 521 510 522 511 #define FACILITY_JSCRIPT 10 ··· 585 574 { 586 575 InterlockedDecrement(&module_ref); 587 576 } 588 - 589 - #include "engine.h" 590 - #include "parser.h" 591 - #include "regexp.h" 592 - 593 - #endif /* _WINE_JSCRIPT_H */
+15 -3
dll/win32/jscript/jscript_main.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "initguid.h" 20 + 19 21 #include "jscript.h" 20 22 21 - #include <rpcproxy.h> 22 - #include <initguid.h> 23 - #include <jscript_classes.h> 23 + #include "winreg.h" 24 + #include "advpub.h" 25 + #include "activaut.h" 26 + #include "objsafe.h" 27 + #include "mshtmhst.h" 28 + #include "rpcproxy.h" 29 + #include "jscript_classes.h" 30 + 31 + #include "wine/debug.h" 32 + 33 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 24 34 25 35 LONG module_ref = 0; 36 + 37 + DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0); 26 38 27 39 HINSTANCE jscript_hinstance; 28 40
+20 -8
dll/win32/jscript/json.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <math.h> 20 + #include <assert.h> 21 + 19 22 #include "jscript.h" 23 + #include "parser.h" 24 + 25 + #include "wine/debug.h" 26 + #include "wine/unicode.h" 27 + 28 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 29 21 30 static const WCHAR parseW[] = {'p','a','r','s','e',0}; 22 31 static const WCHAR stringifyW[] = {'s','t','r','i','n','g','i','f','y',0}; ··· 536 545 } 537 546 538 547 hres = jsdisp_get_idx(obj, i, &val); 539 - if(FAILED(hres)) 548 + if(SUCCEEDED(hres)) { 549 + hres = stringify(ctx, val); 550 + if(FAILED(hres)) 551 + return hres; 552 + if(hres == S_FALSE && !append_string(ctx, nullW)) 553 + return E_OUTOFMEMORY; 554 + }else if(hres == DISP_E_UNKNOWNNAME) { 555 + if(!append_string(ctx, nullW)) 556 + return E_OUTOFMEMORY; 557 + }else { 540 558 return hres; 541 - 542 - hres = stringify(ctx, val); 543 - if(FAILED(hres)) 544 - return hres; 545 - 546 - if(hres == S_FALSE && !append_string(ctx, nullW)) 547 - return E_OUTOFMEMORY; 559 + } 548 560 } 549 561 550 562 if((length && *ctx->gap && !append_char(ctx, '\n')) || !append_char(ctx, ']'))
+7
dll/win32/jscript/jsregexp.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <math.h> 20 + 19 21 #include "jscript.h" 22 + #include "regexp.h" 23 + 24 + #include "wine/debug.h" 25 + 26 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 27 21 28 typedef struct { 22 29 jsdisp_t dispex;
+4
dll/win32/jscript/jsstr.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <assert.h> 20 + 19 21 #include "jscript.h" 22 + 23 + #include "wine/debug.h" 20 24 21 25 /* 22 26 * This is the length of a string that is considered to be long enough to be
+10
dll/win32/jscript/jsutils.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <math.h> 23 + #include <assert.h> 24 + 19 25 #include "jscript.h" 26 + #include "engine.h" 20 27 28 + #include "wine/debug.h" 29 + 30 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 21 31 WINE_DECLARE_DEBUG_CHANNEL(heap); 22 32 23 33 const char *debugstr_jsval(const jsval_t v)
+1 -1
dll/win32/jscript/jsval.h
··· 246 246 void jsval_release(jsval_t) DECLSPEC_HIDDEN; 247 247 HRESULT jsval_copy(jsval_t,jsval_t*) DECLSPEC_HIDDEN; 248 248 249 - #endif /* JSVAL_H */ 249 + #endif
+14
dll/win32/jscript/lex.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 22 + #include <limits.h> 23 + 19 24 #include "jscript.h" 25 + #include "activscp.h" 26 + #include "objsafe.h" 27 + #include "engine.h" 28 + #include "parser.h" 20 29 21 30 #include "parser.tab.h" 31 + 32 + #include "wine/debug.h" 33 + #include "wine/unicode.h" 34 + 35 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 22 36 23 37 static const WCHAR breakW[] = {'b','r','e','a','k',0}; 24 38 static const WCHAR caseW[] = {'c','a','s','e',0};
+10 -1
dll/win32/jscript/math.c
··· 17 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 18 18 */ 19 19 20 + #include "config.h" 21 + #include "wine/port.h" 22 + 23 + #include <math.h> 24 + #include <limits.h> 25 + 20 26 #include "jscript.h" 27 + #include "ntsecapi.h" 28 + 29 + #include "wine/debug.h" 21 30 22 - #include <ntsecapi.h> 31 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 23 32 24 33 static const WCHAR EW[] = {'E',0}; 25 34 static const WCHAR LOG2EW[] = {'L','O','G','2','E',0};
+7
dll/win32/jscript/number.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <math.h> 20 + #include <assert.h> 21 + 19 22 #include "jscript.h" 23 + 24 + #include "wine/debug.h" 25 + 26 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 27 21 28 typedef struct { 22 29 jsdisp_t dispex;
+6
dll/win32/jscript/object.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include <assert.h> 20 + 19 21 #include "jscript.h" 22 + 23 + #include "wine/debug.h" 24 + 25 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 26 21 27 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0}; 22 28 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
+240 -250
dll/win32/jscript/parser.tab.c
··· 1 - /* A Bison parser, made by GNU Bison 3.0.2. */ 1 + /* A Bison parser, made by GNU Bison 3.0. */ 2 2 3 3 /* Bison implementation for Yacc-like parsers in C 4 4 ··· 44 44 #define YYBISON 1 45 45 46 46 /* Bison version. */ 47 - #define YYBISON_VERSION "3.0.2" 47 + #define YYBISON_VERSION "3.0" 48 48 49 49 /* Skeleton name. */ 50 50 #define YYSKELETON_NAME "yacc.c" ··· 72 72 73 73 74 74 #include "jscript.h" 75 + #include "engine.h" 76 + #include "parser.h" 77 + 78 + #include "wine/debug.h" 79 + 80 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 75 81 76 82 static int parser_error(parser_ctx_t*,const char*); 77 83 static void set_error(parser_ctx_t*,UINT); ··· 185 191 186 192 #line 193 "parser.tab.c" /* yacc.c:339 */ 187 193 188 - # ifndef YY_NULLPTR 194 + # ifndef YY_NULL 189 195 # if defined __cplusplus && 201103L <= __cplusplus 190 - # define YY_NULLPTR nullptr 196 + # define YY_NULL nullptr 191 197 # else 192 - # define YY_NULLPTR 0 198 + # define YY_NULL 0 193 199 # endif 194 200 # endif 195 201 ··· 201 207 # define YYERROR_VERBOSE 0 202 208 #endif 203 209 204 - 210 + /* In a future release of Bison, this section will be replaced 211 + by #include "parser.tab.h". */ 212 + #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED 213 + # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED 205 214 /* Debug traces. */ 206 215 #ifndef YYDEBUG 207 216 # define YYDEBUG 0 ··· 289 298 struct _variable_list_t *variable_list; 290 299 variable_declaration_t *variable_declaration; 291 300 292 - #line 299 "parser.tab.c" /* yacc.c:355 */ 301 + #line 302 "parser.tab.c" /* yacc.c:355 */ 293 302 }; 294 303 # define YYSTYPE_IS_TRIVIAL 1 295 304 # define YYSTYPE_IS_DECLARED 1 ··· 299 308 300 309 int parser_parse (parser_ctx_t *ctx); 301 310 302 - 311 + #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED */ 303 312 304 313 /* Copy the second part of user declarations. */ 305 314 306 - #line 313 "parser.tab.c" /* yacc.c:358 */ 315 + #line 316 "parser.tab.c" /* yacc.c:358 */ 307 316 308 317 #ifdef short 309 318 # undef short ··· 360 369 # endif 361 370 #endif 362 371 363 - #ifndef YY_ATTRIBUTE 364 - # if (defined __GNUC__ \ 365 - && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 366 - || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 367 - # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 368 - # else 369 - # define YY_ATTRIBUTE(Spec) /* empty */ 370 - # endif 371 - #endif 372 - 373 - #ifndef YY_ATTRIBUTE_PURE 374 - # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 375 - #endif 376 - 377 - #ifndef YY_ATTRIBUTE_UNUSED 378 - # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 379 - #endif 380 - 381 - #if !defined _Noreturn \ 382 - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 383 - # if defined _MSC_VER && 1200 <= _MSC_VER 384 - # define _Noreturn __declspec (noreturn) 385 - # else 386 - # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 372 + #ifndef __attribute__ 373 + /* This feature is available in gcc versions 2.5 and later. */ 374 + # if (! defined __GNUC__ || __GNUC__ < 2 \ 375 + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) 376 + # define __attribute__(Spec) /* empty */ 387 377 # endif 388 378 #endif 389 379 ··· 673 663 "ArrayLiteral", "ElementList", "Elision", "Elision_opt", "ObjectLiteral", 674 664 "PropertyNameAndValueList", "PropertyName", "Identifier_opt", "Literal", 675 665 "BooleanLiteral", "semicolon_opt", "left_bracket", "right_bracket", 676 - "semicolon", YY_NULLPTR 666 + "semicolon", YY_NULL 677 667 }; 678 668 #endif 679 669 ··· 1433 1423 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1434 1424 yytype_int16 *yyssp, int yytoken) 1435 1425 { 1436 - YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 1426 + YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); 1437 1427 YYSIZE_T yysize = yysize0; 1438 1428 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1439 1429 /* Internationalized format string. */ 1440 - const char *yyformat = YY_NULLPTR; 1430 + const char *yyformat = YY_NULL; 1441 1431 /* Arguments of yyformat. */ 1442 1432 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1443 1433 /* Number of reported tokens (one for the "unexpected", one per ··· 1494 1484 } 1495 1485 yyarg[yycount++] = yytname[yyx]; 1496 1486 { 1497 - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1487 + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); 1498 1488 if (! (yysize <= yysize1 1499 1489 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1500 1490 return 2; ··· 1833 1823 case 2: 1834 1824 #line 253 "parser.y" /* yacc.c:1646 */ 1835 1825 { program_parsed(ctx, (yyvsp[-2].source_elements)); } 1836 - #line 1843 "parser.tab.c" /* yacc.c:1646 */ 1826 + #line 1827 "parser.tab.c" /* yacc.c:1646 */ 1837 1827 break; 1838 1828 1839 1829 case 3: 1840 1830 #line 256 "parser.y" /* yacc.c:1646 */ 1841 1831 {} 1842 - #line 1849 "parser.tab.c" /* yacc.c:1646 */ 1832 + #line 1833 "parser.tab.c" /* yacc.c:1646 */ 1843 1833 break; 1844 1834 1845 1835 case 4: 1846 1836 #line 257 "parser.y" /* yacc.c:1646 */ 1847 1837 {} 1848 - #line 1855 "parser.tab.c" /* yacc.c:1646 */ 1838 + #line 1839 "parser.tab.c" /* yacc.c:1646 */ 1849 1839 break; 1850 1840 1851 1841 case 5: 1852 1842 #line 261 "parser.y" /* yacc.c:1646 */ 1853 1843 { (yyval.source_elements) = new_source_elements(ctx); } 1854 - #line 1861 "parser.tab.c" /* yacc.c:1646 */ 1844 + #line 1845 "parser.tab.c" /* yacc.c:1646 */ 1855 1845 break; 1856 1846 1857 1847 case 6: 1858 1848 #line 263 "parser.y" /* yacc.c:1646 */ 1859 1849 { (yyval.source_elements) = source_elements_add_statement((yyvsp[-1].source_elements), (yyvsp[0].statement)); } 1860 - #line 1867 "parser.tab.c" /* yacc.c:1646 */ 1850 + #line 1851 "parser.tab.c" /* yacc.c:1646 */ 1861 1851 break; 1862 1852 1863 1853 case 7: 1864 1854 #line 268 "parser.y" /* yacc.c:1646 */ 1865 1855 { (yyval.expr) = new_function_expression(ctx, NULL, (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-6].srcptr), (yyvsp[0].srcptr)-(yyvsp[-6].srcptr)+1); } 1866 - #line 1873 "parser.tab.c" /* yacc.c:1646 */ 1856 + #line 1857 "parser.tab.c" /* yacc.c:1646 */ 1867 1857 break; 1868 1858 1869 1859 case 8: 1870 1860 #line 270 "parser.y" /* yacc.c:1646 */ 1871 1861 { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-7].srcptr), (yyvsp[0].srcptr)-(yyvsp[-7].srcptr)+1); } 1872 - #line 1879 "parser.tab.c" /* yacc.c:1646 */ 1862 + #line 1863 "parser.tab.c" /* yacc.c:1646 */ 1873 1863 break; 1874 1864 1875 1865 case 9: 1876 1866 #line 272 "parser.y" /* yacc.c:1646 */ 1877 1867 { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), (yyvsp[-8].identifier), (yyvsp[-9].srcptr), (yyvsp[0].srcptr)-(yyvsp[-9].srcptr)+1); } 1878 - #line 1885 "parser.tab.c" /* yacc.c:1646 */ 1868 + #line 1869 "parser.tab.c" /* yacc.c:1646 */ 1879 1869 break; 1880 1870 1881 1871 case 10: 1882 1872 #line 275 "parser.y" /* yacc.c:1646 */ 1883 1873 { (yyval.srcptr) = (yyvsp[0].srcptr); } 1884 - #line 1891 "parser.tab.c" /* yacc.c:1646 */ 1874 + #line 1875 "parser.tab.c" /* yacc.c:1646 */ 1885 1875 break; 1886 1876 1887 1877 case 11: 1888 1878 #line 279 "parser.y" /* yacc.c:1646 */ 1889 1879 { (yyval.source_elements) = (yyvsp[0].source_elements); } 1890 - #line 1897 "parser.tab.c" /* yacc.c:1646 */ 1880 + #line 1881 "parser.tab.c" /* yacc.c:1646 */ 1891 1881 break; 1892 1882 1893 1883 case 12: 1894 1884 #line 283 "parser.y" /* yacc.c:1646 */ 1895 1885 { (yyval.parameter_list) = new_parameter_list(ctx, (yyvsp[0].identifier)); } 1896 - #line 1903 "parser.tab.c" /* yacc.c:1646 */ 1886 + #line 1887 "parser.tab.c" /* yacc.c:1646 */ 1897 1887 break; 1898 1888 1899 1889 case 13: 1900 1890 #line 285 "parser.y" /* yacc.c:1646 */ 1901 1891 { (yyval.parameter_list) = parameter_list_add(ctx, (yyvsp[-2].parameter_list), (yyvsp[0].identifier)); } 1902 - #line 1909 "parser.tab.c" /* yacc.c:1646 */ 1892 + #line 1893 "parser.tab.c" /* yacc.c:1646 */ 1903 1893 break; 1904 1894 1905 1895 case 14: 1906 1896 #line 289 "parser.y" /* yacc.c:1646 */ 1907 1897 { (yyval.parameter_list) = NULL; } 1908 - #line 1915 "parser.tab.c" /* yacc.c:1646 */ 1898 + #line 1899 "parser.tab.c" /* yacc.c:1646 */ 1909 1899 break; 1910 1900 1911 1901 case 15: 1912 1902 #line 290 "parser.y" /* yacc.c:1646 */ 1913 1903 { (yyval.parameter_list) = (yyvsp[0].parameter_list); } 1914 - #line 1921 "parser.tab.c" /* yacc.c:1646 */ 1904 + #line 1905 "parser.tab.c" /* yacc.c:1646 */ 1915 1905 break; 1916 1906 1917 1907 case 16: 1918 1908 #line 294 "parser.y" /* yacc.c:1646 */ 1919 1909 { (yyval.statement) = (yyvsp[0].statement); } 1920 - #line 1927 "parser.tab.c" /* yacc.c:1646 */ 1910 + #line 1911 "parser.tab.c" /* yacc.c:1646 */ 1921 1911 break; 1922 1912 1923 1913 case 17: 1924 1914 #line 295 "parser.y" /* yacc.c:1646 */ 1925 1915 { (yyval.statement) = (yyvsp[0].statement); } 1926 - #line 1933 "parser.tab.c" /* yacc.c:1646 */ 1916 + #line 1917 "parser.tab.c" /* yacc.c:1646 */ 1927 1917 break; 1928 1918 1929 1919 case 18: 1930 1920 #line 296 "parser.y" /* yacc.c:1646 */ 1931 1921 { (yyval.statement) = (yyvsp[0].statement); } 1932 - #line 1939 "parser.tab.c" /* yacc.c:1646 */ 1922 + #line 1923 "parser.tab.c" /* yacc.c:1646 */ 1933 1923 break; 1934 1924 1935 1925 case 19: 1936 1926 #line 297 "parser.y" /* yacc.c:1646 */ 1937 1927 { (yyval.statement) = new_expression_statement(ctx, (yyvsp[0].expr)); } 1938 - #line 1945 "parser.tab.c" /* yacc.c:1646 */ 1928 + #line 1929 "parser.tab.c" /* yacc.c:1646 */ 1939 1929 break; 1940 1930 1941 1931 case 20: 1942 1932 #line 298 "parser.y" /* yacc.c:1646 */ 1943 1933 { (yyval.statement) = (yyvsp[0].statement); } 1944 - #line 1951 "parser.tab.c" /* yacc.c:1646 */ 1934 + #line 1935 "parser.tab.c" /* yacc.c:1646 */ 1945 1935 break; 1946 1936 1947 1937 case 21: 1948 1938 #line 299 "parser.y" /* yacc.c:1646 */ 1949 1939 { (yyval.statement) = (yyvsp[0].statement); } 1950 - #line 1957 "parser.tab.c" /* yacc.c:1646 */ 1940 + #line 1941 "parser.tab.c" /* yacc.c:1646 */ 1951 1941 break; 1952 1942 1953 1943 case 22: 1954 1944 #line 300 "parser.y" /* yacc.c:1646 */ 1955 1945 { (yyval.statement) = (yyvsp[0].statement); } 1956 - #line 1963 "parser.tab.c" /* yacc.c:1646 */ 1946 + #line 1947 "parser.tab.c" /* yacc.c:1646 */ 1957 1947 break; 1958 1948 1959 1949 case 23: 1960 1950 #line 301 "parser.y" /* yacc.c:1646 */ 1961 1951 { (yyval.statement) = (yyvsp[0].statement); } 1962 - #line 1969 "parser.tab.c" /* yacc.c:1646 */ 1952 + #line 1953 "parser.tab.c" /* yacc.c:1646 */ 1963 1953 break; 1964 1954 1965 1955 case 24: 1966 1956 #line 302 "parser.y" /* yacc.c:1646 */ 1967 1957 { (yyval.statement) = (yyvsp[0].statement); } 1968 - #line 1975 "parser.tab.c" /* yacc.c:1646 */ 1958 + #line 1959 "parser.tab.c" /* yacc.c:1646 */ 1969 1959 break; 1970 1960 1971 1961 case 25: 1972 1962 #line 303 "parser.y" /* yacc.c:1646 */ 1973 1963 { (yyval.statement) = (yyvsp[0].statement); } 1974 - #line 1981 "parser.tab.c" /* yacc.c:1646 */ 1964 + #line 1965 "parser.tab.c" /* yacc.c:1646 */ 1975 1965 break; 1976 1966 1977 1967 case 26: 1978 1968 #line 304 "parser.y" /* yacc.c:1646 */ 1979 1969 { (yyval.statement) = (yyvsp[0].statement); } 1980 - #line 1987 "parser.tab.c" /* yacc.c:1646 */ 1970 + #line 1971 "parser.tab.c" /* yacc.c:1646 */ 1981 1971 break; 1982 1972 1983 1973 case 27: 1984 1974 #line 305 "parser.y" /* yacc.c:1646 */ 1985 1975 { (yyval.statement) = (yyvsp[0].statement); } 1986 - #line 1993 "parser.tab.c" /* yacc.c:1646 */ 1976 + #line 1977 "parser.tab.c" /* yacc.c:1646 */ 1987 1977 break; 1988 1978 1989 1979 case 28: 1990 1980 #line 306 "parser.y" /* yacc.c:1646 */ 1991 1981 { (yyval.statement) = (yyvsp[0].statement); } 1992 - #line 1999 "parser.tab.c" /* yacc.c:1646 */ 1982 + #line 1983 "parser.tab.c" /* yacc.c:1646 */ 1993 1983 break; 1994 1984 1995 1985 case 29: 1996 1986 #line 307 "parser.y" /* yacc.c:1646 */ 1997 1987 { (yyval.statement) = (yyvsp[0].statement); } 1998 - #line 2005 "parser.tab.c" /* yacc.c:1646 */ 1988 + #line 1989 "parser.tab.c" /* yacc.c:1646 */ 1999 1989 break; 2000 1990 2001 1991 case 30: 2002 1992 #line 308 "parser.y" /* yacc.c:1646 */ 2003 1993 { (yyval.statement) = (yyvsp[0].statement); } 2004 - #line 2011 "parser.tab.c" /* yacc.c:1646 */ 1994 + #line 1995 "parser.tab.c" /* yacc.c:1646 */ 2005 1995 break; 2006 1996 2007 1997 case 31: 2008 1998 #line 312 "parser.y" /* yacc.c:1646 */ 2009 1999 { (yyval.statement_list) = new_statement_list(ctx, (yyvsp[0].statement)); } 2010 - #line 2017 "parser.tab.c" /* yacc.c:1646 */ 2000 + #line 2001 "parser.tab.c" /* yacc.c:1646 */ 2011 2001 break; 2012 2002 2013 2003 case 32: 2014 2004 #line 314 "parser.y" /* yacc.c:1646 */ 2015 2005 { (yyval.statement_list) = statement_list_add((yyvsp[-1].statement_list), (yyvsp[0].statement)); } 2016 - #line 2023 "parser.tab.c" /* yacc.c:1646 */ 2006 + #line 2007 "parser.tab.c" /* yacc.c:1646 */ 2017 2007 break; 2018 2008 2019 2009 case 33: 2020 2010 #line 318 "parser.y" /* yacc.c:1646 */ 2021 2011 { (yyval.statement_list) = NULL; } 2022 - #line 2029 "parser.tab.c" /* yacc.c:1646 */ 2012 + #line 2013 "parser.tab.c" /* yacc.c:1646 */ 2023 2013 break; 2024 2014 2025 2015 case 34: 2026 2016 #line 319 "parser.y" /* yacc.c:1646 */ 2027 2017 { (yyval.statement_list) = (yyvsp[0].statement_list); } 2028 - #line 2035 "parser.tab.c" /* yacc.c:1646 */ 2018 + #line 2019 "parser.tab.c" /* yacc.c:1646 */ 2029 2019 break; 2030 2020 2031 2021 case 35: 2032 2022 #line 323 "parser.y" /* yacc.c:1646 */ 2033 2023 { (yyval.statement) = new_block_statement(ctx, (yyvsp[-1].statement_list)); } 2034 - #line 2041 "parser.tab.c" /* yacc.c:1646 */ 2024 + #line 2025 "parser.tab.c" /* yacc.c:1646 */ 2035 2025 break; 2036 2026 2037 2027 case 36: 2038 2028 #line 324 "parser.y" /* yacc.c:1646 */ 2039 2029 { (yyval.statement) = new_block_statement(ctx, NULL); } 2040 - #line 2047 "parser.tab.c" /* yacc.c:1646 */ 2030 + #line 2031 "parser.tab.c" /* yacc.c:1646 */ 2041 2031 break; 2042 2032 2043 2033 case 37: 2044 2034 #line 329 "parser.y" /* yacc.c:1646 */ 2045 2035 { (yyval.statement) = new_var_statement(ctx, (yyvsp[-1].variable_list)); } 2046 - #line 2053 "parser.tab.c" /* yacc.c:1646 */ 2036 + #line 2037 "parser.tab.c" /* yacc.c:1646 */ 2047 2037 break; 2048 2038 2049 2039 case 38: 2050 2040 #line 333 "parser.y" /* yacc.c:1646 */ 2051 2041 { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); } 2052 - #line 2059 "parser.tab.c" /* yacc.c:1646 */ 2042 + #line 2043 "parser.tab.c" /* yacc.c:1646 */ 2053 2043 break; 2054 2044 2055 2045 case 39: 2056 2046 #line 335 "parser.y" /* yacc.c:1646 */ 2057 2047 { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); } 2058 - #line 2065 "parser.tab.c" /* yacc.c:1646 */ 2048 + #line 2049 "parser.tab.c" /* yacc.c:1646 */ 2059 2049 break; 2060 2050 2061 2051 case 40: 2062 2052 #line 340 "parser.y" /* yacc.c:1646 */ 2063 2053 { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); } 2064 - #line 2071 "parser.tab.c" /* yacc.c:1646 */ 2054 + #line 2055 "parser.tab.c" /* yacc.c:1646 */ 2065 2055 break; 2066 2056 2067 2057 case 41: 2068 2058 #line 342 "parser.y" /* yacc.c:1646 */ 2069 2059 { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); } 2070 - #line 2077 "parser.tab.c" /* yacc.c:1646 */ 2060 + #line 2061 "parser.tab.c" /* yacc.c:1646 */ 2071 2061 break; 2072 2062 2073 2063 case 42: 2074 2064 #line 347 "parser.y" /* yacc.c:1646 */ 2075 2065 { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); } 2076 - #line 2083 "parser.tab.c" /* yacc.c:1646 */ 2066 + #line 2067 "parser.tab.c" /* yacc.c:1646 */ 2077 2067 break; 2078 2068 2079 2069 case 43: 2080 2070 #line 352 "parser.y" /* yacc.c:1646 */ 2081 2071 { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); } 2082 - #line 2089 "parser.tab.c" /* yacc.c:1646 */ 2072 + #line 2073 "parser.tab.c" /* yacc.c:1646 */ 2083 2073 break; 2084 2074 2085 2075 case 44: 2086 2076 #line 356 "parser.y" /* yacc.c:1646 */ 2087 2077 { (yyval.expr) = NULL; } 2088 - #line 2095 "parser.tab.c" /* yacc.c:1646 */ 2078 + #line 2079 "parser.tab.c" /* yacc.c:1646 */ 2089 2079 break; 2090 2080 2091 2081 case 45: 2092 2082 #line 357 "parser.y" /* yacc.c:1646 */ 2093 2083 { (yyval.expr) = (yyvsp[0].expr); } 2094 - #line 2101 "parser.tab.c" /* yacc.c:1646 */ 2084 + #line 2085 "parser.tab.c" /* yacc.c:1646 */ 2095 2085 break; 2096 2086 2097 2087 case 46: 2098 2088 #line 362 "parser.y" /* yacc.c:1646 */ 2099 2089 { (yyval.expr) = (yyvsp[0].expr); } 2100 - #line 2107 "parser.tab.c" /* yacc.c:1646 */ 2090 + #line 2091 "parser.tab.c" /* yacc.c:1646 */ 2101 2091 break; 2102 2092 2103 2093 case 47: 2104 2094 #line 366 "parser.y" /* yacc.c:1646 */ 2105 2095 { (yyval.expr) = NULL; } 2106 - #line 2113 "parser.tab.c" /* yacc.c:1646 */ 2096 + #line 2097 "parser.tab.c" /* yacc.c:1646 */ 2107 2097 break; 2108 2098 2109 2099 case 48: 2110 2100 #line 367 "parser.y" /* yacc.c:1646 */ 2111 2101 { (yyval.expr) = (yyvsp[0].expr); } 2112 - #line 2119 "parser.tab.c" /* yacc.c:1646 */ 2102 + #line 2103 "parser.tab.c" /* yacc.c:1646 */ 2113 2103 break; 2114 2104 2115 2105 case 49: 2116 2106 #line 372 "parser.y" /* yacc.c:1646 */ 2117 2107 { (yyval.expr) = (yyvsp[0].expr); } 2118 - #line 2125 "parser.tab.c" /* yacc.c:1646 */ 2108 + #line 2109 "parser.tab.c" /* yacc.c:1646 */ 2119 2109 break; 2120 2110 2121 2111 case 50: 2122 2112 #line 376 "parser.y" /* yacc.c:1646 */ 2123 2113 { (yyval.statement) = new_statement(ctx, STAT_EMPTY, 0); } 2124 - #line 2131 "parser.tab.c" /* yacc.c:1646 */ 2114 + #line 2115 "parser.tab.c" /* yacc.c:1646 */ 2125 2115 break; 2126 2116 2127 2117 case 51: 2128 2118 #line 381 "parser.y" /* yacc.c:1646 */ 2129 2119 { (yyval.statement) = new_expression_statement(ctx, (yyvsp[-1].expr)); } 2130 - #line 2137 "parser.tab.c" /* yacc.c:1646 */ 2120 + #line 2121 "parser.tab.c" /* yacc.c:1646 */ 2131 2121 break; 2132 2122 2133 2123 case 52: 2134 2124 #line 386 "parser.y" /* yacc.c:1646 */ 2135 2125 { (yyval.statement) = new_if_statement(ctx, (yyvsp[-4].expr), (yyvsp[-2].statement), (yyvsp[0].statement)); } 2136 - #line 2143 "parser.tab.c" /* yacc.c:1646 */ 2126 + #line 2127 "parser.tab.c" /* yacc.c:1646 */ 2137 2127 break; 2138 2128 2139 2129 case 53: 2140 2130 #line 388 "parser.y" /* yacc.c:1646 */ 2141 2131 { (yyval.statement) = new_if_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement), NULL); } 2142 - #line 2149 "parser.tab.c" /* yacc.c:1646 */ 2132 + #line 2133 "parser.tab.c" /* yacc.c:1646 */ 2143 2133 break; 2144 2134 2145 2135 case 54: 2146 2136 #line 393 "parser.y" /* yacc.c:1646 */ 2147 2137 { (yyval.statement) = new_while_statement(ctx, TRUE, (yyvsp[-2].expr), (yyvsp[-5].statement)); } 2148 - #line 2155 "parser.tab.c" /* yacc.c:1646 */ 2138 + #line 2139 "parser.tab.c" /* yacc.c:1646 */ 2149 2139 break; 2150 2140 2151 2141 case 55: 2152 2142 #line 395 "parser.y" /* yacc.c:1646 */ 2153 2143 { (yyval.statement) = new_while_statement(ctx, FALSE, (yyvsp[-2].expr), (yyvsp[0].statement)); } 2154 - #line 2161 "parser.tab.c" /* yacc.c:1646 */ 2144 + #line 2145 "parser.tab.c" /* yacc.c:1646 */ 2155 2145 break; 2156 2146 2157 2147 case 56: 2158 2148 #line 397 "parser.y" /* yacc.c:1646 */ 2159 2149 { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } 2160 - #line 2167 "parser.tab.c" /* yacc.c:1646 */ 2150 + #line 2151 "parser.tab.c" /* yacc.c:1646 */ 2161 2151 break; 2162 2152 2163 2153 case 57: 2164 2154 #line 399 "parser.y" /* yacc.c:1646 */ 2165 2155 { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } 2166 - #line 2173 "parser.tab.c" /* yacc.c:1646 */ 2156 + #line 2157 "parser.tab.c" /* yacc.c:1646 */ 2167 2157 break; 2168 2158 2169 2159 case 58: 2170 2160 #line 401 "parser.y" /* yacc.c:1646 */ 2171 2161 { (yyval.statement) = new_for_statement(ctx, NULL, (yyvsp[-8].expr), (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } 2172 - #line 2179 "parser.tab.c" /* yacc.c:1646 */ 2162 + #line 2163 "parser.tab.c" /* yacc.c:1646 */ 2173 2163 break; 2174 2164 2175 2165 case 59: 2176 2166 #line 403 "parser.y" /* yacc.c:1646 */ 2177 2167 { if(!explicit_error(ctx, (yyvsp[0].variable_list), ';')) YYABORT; } 2178 - #line 2185 "parser.tab.c" /* yacc.c:1646 */ 2168 + #line 2169 "parser.tab.c" /* yacc.c:1646 */ 2179 2169 break; 2180 2170 2181 2171 case 60: 2182 2172 #line 405 "parser.y" /* yacc.c:1646 */ 2183 2173 { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } 2184 - #line 2191 "parser.tab.c" /* yacc.c:1646 */ 2174 + #line 2175 "parser.tab.c" /* yacc.c:1646 */ 2185 2175 break; 2186 2176 2187 2177 case 61: 2188 2178 #line 407 "parser.y" /* yacc.c:1646 */ 2189 2179 { (yyval.statement) = new_for_statement(ctx, (yyvsp[-8].variable_list), NULL, (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } 2190 - #line 2197 "parser.tab.c" /* yacc.c:1646 */ 2180 + #line 2181 "parser.tab.c" /* yacc.c:1646 */ 2191 2181 break; 2192 2182 2193 2183 case 62: 2194 2184 #line 409 "parser.y" /* yacc.c:1646 */ 2195 2185 { (yyval.statement) = new_forin_statement(ctx, NULL, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } 2196 - #line 2203 "parser.tab.c" /* yacc.c:1646 */ 2186 + #line 2187 "parser.tab.c" /* yacc.c:1646 */ 2197 2187 break; 2198 2188 2199 2189 case 63: 2200 2190 #line 411 "parser.y" /* yacc.c:1646 */ 2201 2191 { (yyval.statement) = new_forin_statement(ctx, (yyvsp[-4].variable_declaration), NULL, (yyvsp[-2].expr), (yyvsp[0].statement)); } 2202 - #line 2209 "parser.tab.c" /* yacc.c:1646 */ 2192 + #line 2193 "parser.tab.c" /* yacc.c:1646 */ 2203 2193 break; 2204 2194 2205 2195 case 64: 2206 2196 #line 416 "parser.y" /* yacc.c:1646 */ 2207 2197 { (yyval.statement) = new_continue_statement(ctx, (yyvsp[-1].identifier)); } 2208 - #line 2215 "parser.tab.c" /* yacc.c:1646 */ 2198 + #line 2199 "parser.tab.c" /* yacc.c:1646 */ 2209 2199 break; 2210 2200 2211 2201 case 65: 2212 2202 #line 421 "parser.y" /* yacc.c:1646 */ 2213 2203 { (yyval.statement) = new_break_statement(ctx, (yyvsp[-1].identifier)); } 2214 - #line 2221 "parser.tab.c" /* yacc.c:1646 */ 2204 + #line 2205 "parser.tab.c" /* yacc.c:1646 */ 2215 2205 break; 2216 2206 2217 2207 case 66: 2218 2208 #line 426 "parser.y" /* yacc.c:1646 */ 2219 2209 { (yyval.statement) = new_return_statement(ctx, (yyvsp[-1].expr)); } 2220 - #line 2227 "parser.tab.c" /* yacc.c:1646 */ 2210 + #line 2211 "parser.tab.c" /* yacc.c:1646 */ 2221 2211 break; 2222 2212 2223 2213 case 67: 2224 2214 #line 431 "parser.y" /* yacc.c:1646 */ 2225 2215 { (yyval.statement) = new_with_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement)); } 2226 - #line 2233 "parser.tab.c" /* yacc.c:1646 */ 2216 + #line 2217 "parser.tab.c" /* yacc.c:1646 */ 2227 2217 break; 2228 2218 2229 2219 case 68: 2230 2220 #line 436 "parser.y" /* yacc.c:1646 */ 2231 2221 { (yyval.statement) = new_labelled_statement(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); } 2232 - #line 2239 "parser.tab.c" /* yacc.c:1646 */ 2222 + #line 2223 "parser.tab.c" /* yacc.c:1646 */ 2233 2223 break; 2234 2224 2235 2225 case 69: 2236 2226 #line 441 "parser.y" /* yacc.c:1646 */ 2237 2227 { (yyval.statement) = new_switch_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].case_clausule)); } 2238 - #line 2245 "parser.tab.c" /* yacc.c:1646 */ 2228 + #line 2229 "parser.tab.c" /* yacc.c:1646 */ 2239 2229 break; 2240 2230 2241 2231 case 70: 2242 2232 #line 446 "parser.y" /* yacc.c:1646 */ 2243 2233 { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-1].case_list), NULL, NULL); } 2244 - #line 2251 "parser.tab.c" /* yacc.c:1646 */ 2234 + #line 2235 "parser.tab.c" /* yacc.c:1646 */ 2245 2235 break; 2246 2236 2247 2237 case 71: 2248 2238 #line 448 "parser.y" /* yacc.c:1646 */ 2249 2239 { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-3].case_list), (yyvsp[-2].case_clausule), (yyvsp[-1].case_list)); } 2250 - #line 2257 "parser.tab.c" /* yacc.c:1646 */ 2240 + #line 2241 "parser.tab.c" /* yacc.c:1646 */ 2251 2241 break; 2252 2242 2253 2243 case 72: 2254 2244 #line 452 "parser.y" /* yacc.c:1646 */ 2255 2245 { (yyval.case_list) = NULL; } 2256 - #line 2263 "parser.tab.c" /* yacc.c:1646 */ 2246 + #line 2247 "parser.tab.c" /* yacc.c:1646 */ 2257 2247 break; 2258 2248 2259 2249 case 73: 2260 2250 #line 453 "parser.y" /* yacc.c:1646 */ 2261 2251 { (yyval.case_list) = (yyvsp[0].case_list); } 2262 - #line 2269 "parser.tab.c" /* yacc.c:1646 */ 2252 + #line 2253 "parser.tab.c" /* yacc.c:1646 */ 2263 2253 break; 2264 2254 2265 2255 case 74: 2266 2256 #line 457 "parser.y" /* yacc.c:1646 */ 2267 2257 { (yyval.case_list) = new_case_list(ctx, (yyvsp[0].case_clausule)); } 2268 - #line 2275 "parser.tab.c" /* yacc.c:1646 */ 2258 + #line 2259 "parser.tab.c" /* yacc.c:1646 */ 2269 2259 break; 2270 2260 2271 2261 case 75: 2272 2262 #line 459 "parser.y" /* yacc.c:1646 */ 2273 2263 { (yyval.case_list) = case_list_add(ctx, (yyvsp[-1].case_list), (yyvsp[0].case_clausule)); } 2274 - #line 2281 "parser.tab.c" /* yacc.c:1646 */ 2264 + #line 2265 "parser.tab.c" /* yacc.c:1646 */ 2275 2265 break; 2276 2266 2277 2267 case 76: 2278 2268 #line 464 "parser.y" /* yacc.c:1646 */ 2279 2269 { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[-2].expr), (yyvsp[0].statement_list)); } 2280 - #line 2287 "parser.tab.c" /* yacc.c:1646 */ 2270 + #line 2271 "parser.tab.c" /* yacc.c:1646 */ 2281 2271 break; 2282 2272 2283 2273 case 77: 2284 2274 #line 469 "parser.y" /* yacc.c:1646 */ 2285 2275 { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[0].statement_list)); } 2286 - #line 2293 "parser.tab.c" /* yacc.c:1646 */ 2276 + #line 2277 "parser.tab.c" /* yacc.c:1646 */ 2287 2277 break; 2288 2278 2289 2279 case 78: 2290 2280 #line 474 "parser.y" /* yacc.c:1646 */ 2291 2281 { (yyval.statement) = new_throw_statement(ctx, (yyvsp[-1].expr)); } 2292 - #line 2299 "parser.tab.c" /* yacc.c:1646 */ 2282 + #line 2283 "parser.tab.c" /* yacc.c:1646 */ 2293 2283 break; 2294 2284 2295 2285 case 79: 2296 2286 #line 478 "parser.y" /* yacc.c:1646 */ 2297 2287 { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), (yyvsp[0].catch_block), NULL); } 2298 - #line 2305 "parser.tab.c" /* yacc.c:1646 */ 2288 + #line 2289 "parser.tab.c" /* yacc.c:1646 */ 2299 2289 break; 2300 2290 2301 2291 case 80: 2302 2292 #line 479 "parser.y" /* yacc.c:1646 */ 2303 2293 { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), NULL, (yyvsp[0].statement)); } 2304 - #line 2311 "parser.tab.c" /* yacc.c:1646 */ 2294 + #line 2295 "parser.tab.c" /* yacc.c:1646 */ 2305 2295 break; 2306 2296 2307 2297 case 81: 2308 2298 #line 481 "parser.y" /* yacc.c:1646 */ 2309 2299 { (yyval.statement) = new_try_statement(ctx, (yyvsp[-2].statement), (yyvsp[-1].catch_block), (yyvsp[0].statement)); } 2310 - #line 2317 "parser.tab.c" /* yacc.c:1646 */ 2300 + #line 2301 "parser.tab.c" /* yacc.c:1646 */ 2311 2301 break; 2312 2302 2313 2303 case 82: 2314 2304 #line 486 "parser.y" /* yacc.c:1646 */ 2315 2305 { (yyval.catch_block) = new_catch_block(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); } 2316 - #line 2323 "parser.tab.c" /* yacc.c:1646 */ 2306 + #line 2307 "parser.tab.c" /* yacc.c:1646 */ 2317 2307 break; 2318 2308 2319 2309 case 83: 2320 2310 #line 490 "parser.y" /* yacc.c:1646 */ 2321 2311 { (yyval.statement) = (yyvsp[0].statement); } 2322 - #line 2329 "parser.tab.c" /* yacc.c:1646 */ 2312 + #line 2313 "parser.tab.c" /* yacc.c:1646 */ 2323 2313 break; 2324 2314 2325 2315 case 84: 2326 2316 #line 494 "parser.y" /* yacc.c:1646 */ 2327 2317 { (yyval.expr) = NULL; } 2328 - #line 2335 "parser.tab.c" /* yacc.c:1646 */ 2318 + #line 2319 "parser.tab.c" /* yacc.c:1646 */ 2329 2319 break; 2330 2320 2331 2321 case 85: 2332 2322 #line 495 "parser.y" /* yacc.c:1646 */ 2333 2323 { (yyval.expr) = (yyvsp[0].expr); } 2334 - #line 2341 "parser.tab.c" /* yacc.c:1646 */ 2324 + #line 2325 "parser.tab.c" /* yacc.c:1646 */ 2335 2325 break; 2336 2326 2337 2327 case 86: 2338 2328 #line 498 "parser.y" /* yacc.c:1646 */ 2339 2329 { (yyval.expr) = (yyvsp[0].expr); } 2340 - #line 2347 "parser.tab.c" /* yacc.c:1646 */ 2330 + #line 2331 "parser.tab.c" /* yacc.c:1646 */ 2341 2331 break; 2342 2332 2343 2333 case 87: 2344 2334 #line 499 "parser.y" /* yacc.c:1646 */ 2345 2335 { set_error(ctx, JS_E_SYNTAX); YYABORT; } 2346 - #line 2353 "parser.tab.c" /* yacc.c:1646 */ 2336 + #line 2337 "parser.tab.c" /* yacc.c:1646 */ 2347 2337 break; 2348 2338 2349 2339 case 88: 2350 2340 #line 503 "parser.y" /* yacc.c:1646 */ 2351 2341 { (yyval.expr) = (yyvsp[0].expr); } 2352 - #line 2359 "parser.tab.c" /* yacc.c:1646 */ 2342 + #line 2343 "parser.tab.c" /* yacc.c:1646 */ 2353 2343 break; 2354 2344 2355 2345 case 89: 2356 2346 #line 505 "parser.y" /* yacc.c:1646 */ 2357 2347 { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2358 - #line 2365 "parser.tab.c" /* yacc.c:1646 */ 2348 + #line 2349 "parser.tab.c" /* yacc.c:1646 */ 2359 2349 break; 2360 2350 2361 2351 case 90: 2362 2352 #line 509 "parser.y" /* yacc.c:1646 */ 2363 2353 { (yyval.expr) = NULL; } 2364 - #line 2371 "parser.tab.c" /* yacc.c:1646 */ 2354 + #line 2355 "parser.tab.c" /* yacc.c:1646 */ 2365 2355 break; 2366 2356 2367 2357 case 91: 2368 2358 #line 510 "parser.y" /* yacc.c:1646 */ 2369 2359 { (yyval.expr) = (yyvsp[0].expr); } 2370 - #line 2377 "parser.tab.c" /* yacc.c:1646 */ 2360 + #line 2361 "parser.tab.c" /* yacc.c:1646 */ 2371 2361 break; 2372 2362 2373 2363 case 92: 2374 2364 #line 515 "parser.y" /* yacc.c:1646 */ 2375 2365 { (yyval.expr) = (yyvsp[0].expr); } 2376 - #line 2383 "parser.tab.c" /* yacc.c:1646 */ 2366 + #line 2367 "parser.tab.c" /* yacc.c:1646 */ 2377 2367 break; 2378 2368 2379 2369 case 93: 2380 2370 #line 517 "parser.y" /* yacc.c:1646 */ 2381 2371 { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2382 - #line 2389 "parser.tab.c" /* yacc.c:1646 */ 2372 + #line 2373 "parser.tab.c" /* yacc.c:1646 */ 2383 2373 break; 2384 2374 2385 2375 case 94: 2386 2376 #line 520 "parser.y" /* yacc.c:1646 */ 2387 2377 { (yyval.ival) = (yyvsp[0].ival); } 2388 - #line 2395 "parser.tab.c" /* yacc.c:1646 */ 2378 + #line 2379 "parser.tab.c" /* yacc.c:1646 */ 2389 2379 break; 2390 2380 2391 2381 case 95: 2392 2382 #line 521 "parser.y" /* yacc.c:1646 */ 2393 2383 { (yyval.ival) = EXPR_ASSIGNDIV; } 2394 - #line 2401 "parser.tab.c" /* yacc.c:1646 */ 2384 + #line 2385 "parser.tab.c" /* yacc.c:1646 */ 2395 2385 break; 2396 2386 2397 2387 case 96: 2398 2388 #line 525 "parser.y" /* yacc.c:1646 */ 2399 2389 { (yyval.expr) = (yyvsp[0].expr); } 2400 - #line 2407 "parser.tab.c" /* yacc.c:1646 */ 2390 + #line 2391 "parser.tab.c" /* yacc.c:1646 */ 2401 2391 break; 2402 2392 2403 2393 case 97: 2404 2394 #line 527 "parser.y" /* yacc.c:1646 */ 2405 2395 { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2406 - #line 2413 "parser.tab.c" /* yacc.c:1646 */ 2396 + #line 2397 "parser.tab.c" /* yacc.c:1646 */ 2407 2397 break; 2408 2398 2409 2399 case 98: 2410 2400 #line 529 "parser.y" /* yacc.c:1646 */ 2411 2401 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2412 - #line 2419 "parser.tab.c" /* yacc.c:1646 */ 2402 + #line 2403 "parser.tab.c" /* yacc.c:1646 */ 2413 2403 break; 2414 2404 2415 2405 case 99: 2416 2406 #line 534 "parser.y" /* yacc.c:1646 */ 2417 2407 { (yyval.expr) = (yyvsp[0].expr); } 2418 - #line 2425 "parser.tab.c" /* yacc.c:1646 */ 2408 + #line 2409 "parser.tab.c" /* yacc.c:1646 */ 2419 2409 break; 2420 2410 2421 2411 case 100: 2422 2412 #line 536 "parser.y" /* yacc.c:1646 */ 2423 2413 { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2424 - #line 2431 "parser.tab.c" /* yacc.c:1646 */ 2414 + #line 2415 "parser.tab.c" /* yacc.c:1646 */ 2425 2415 break; 2426 2416 2427 2417 case 101: 2428 2418 #line 538 "parser.y" /* yacc.c:1646 */ 2429 2419 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2430 - #line 2437 "parser.tab.c" /* yacc.c:1646 */ 2420 + #line 2421 "parser.tab.c" /* yacc.c:1646 */ 2431 2421 break; 2432 2422 2433 2423 case 102: 2434 2424 #line 542 "parser.y" /* yacc.c:1646 */ 2435 2425 { (yyval.expr) = (yyvsp[0].expr); } 2436 - #line 2443 "parser.tab.c" /* yacc.c:1646 */ 2426 + #line 2427 "parser.tab.c" /* yacc.c:1646 */ 2437 2427 break; 2438 2428 2439 2429 case 103: 2440 2430 #line 544 "parser.y" /* yacc.c:1646 */ 2441 2431 { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2442 - #line 2449 "parser.tab.c" /* yacc.c:1646 */ 2432 + #line 2433 "parser.tab.c" /* yacc.c:1646 */ 2443 2433 break; 2444 2434 2445 2435 case 104: 2446 2436 #line 549 "parser.y" /* yacc.c:1646 */ 2447 2437 { (yyval.expr) = (yyvsp[0].expr); } 2448 - #line 2455 "parser.tab.c" /* yacc.c:1646 */ 2438 + #line 2439 "parser.tab.c" /* yacc.c:1646 */ 2449 2439 break; 2450 2440 2451 2441 case 105: 2452 2442 #line 551 "parser.y" /* yacc.c:1646 */ 2453 2443 { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2454 - #line 2461 "parser.tab.c" /* yacc.c:1646 */ 2444 + #line 2445 "parser.tab.c" /* yacc.c:1646 */ 2455 2445 break; 2456 2446 2457 2447 case 106: 2458 2448 #line 555 "parser.y" /* yacc.c:1646 */ 2459 2449 { (yyval.expr) = (yyvsp[0].expr); } 2460 - #line 2467 "parser.tab.c" /* yacc.c:1646 */ 2450 + #line 2451 "parser.tab.c" /* yacc.c:1646 */ 2461 2451 break; 2462 2452 2463 2453 case 107: 2464 2454 #line 557 "parser.y" /* yacc.c:1646 */ 2465 2455 { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2466 - #line 2473 "parser.tab.c" /* yacc.c:1646 */ 2456 + #line 2457 "parser.tab.c" /* yacc.c:1646 */ 2467 2457 break; 2468 2458 2469 2459 case 108: 2470 2460 #line 562 "parser.y" /* yacc.c:1646 */ 2471 2461 { (yyval.expr) = (yyvsp[0].expr); } 2472 - #line 2479 "parser.tab.c" /* yacc.c:1646 */ 2462 + #line 2463 "parser.tab.c" /* yacc.c:1646 */ 2473 2463 break; 2474 2464 2475 2465 case 109: 2476 2466 #line 564 "parser.y" /* yacc.c:1646 */ 2477 2467 { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2478 - #line 2485 "parser.tab.c" /* yacc.c:1646 */ 2468 + #line 2469 "parser.tab.c" /* yacc.c:1646 */ 2479 2469 break; 2480 2470 2481 2471 case 110: 2482 2472 #line 568 "parser.y" /* yacc.c:1646 */ 2483 2473 { (yyval.expr) = (yyvsp[0].expr); } 2484 - #line 2491 "parser.tab.c" /* yacc.c:1646 */ 2474 + #line 2475 "parser.tab.c" /* yacc.c:1646 */ 2485 2475 break; 2486 2476 2487 2477 case 111: 2488 2478 #line 570 "parser.y" /* yacc.c:1646 */ 2489 2479 { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2490 - #line 2497 "parser.tab.c" /* yacc.c:1646 */ 2480 + #line 2481 "parser.tab.c" /* yacc.c:1646 */ 2491 2481 break; 2492 2482 2493 2483 case 112: 2494 2484 #line 575 "parser.y" /* yacc.c:1646 */ 2495 2485 { (yyval.expr) = (yyvsp[0].expr); } 2496 - #line 2503 "parser.tab.c" /* yacc.c:1646 */ 2486 + #line 2487 "parser.tab.c" /* yacc.c:1646 */ 2497 2487 break; 2498 2488 2499 2489 case 113: 2500 2490 #line 577 "parser.y" /* yacc.c:1646 */ 2501 2491 { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2502 - #line 2509 "parser.tab.c" /* yacc.c:1646 */ 2492 + #line 2493 "parser.tab.c" /* yacc.c:1646 */ 2503 2493 break; 2504 2494 2505 2495 case 114: 2506 2496 #line 581 "parser.y" /* yacc.c:1646 */ 2507 2497 { (yyval.expr) = (yyvsp[0].expr); } 2508 - #line 2515 "parser.tab.c" /* yacc.c:1646 */ 2498 + #line 2499 "parser.tab.c" /* yacc.c:1646 */ 2509 2499 break; 2510 2500 2511 2501 case 115: 2512 2502 #line 583 "parser.y" /* yacc.c:1646 */ 2513 2503 { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2514 - #line 2521 "parser.tab.c" /* yacc.c:1646 */ 2504 + #line 2505 "parser.tab.c" /* yacc.c:1646 */ 2515 2505 break; 2516 2506 2517 2507 case 116: 2518 2508 #line 588 "parser.y" /* yacc.c:1646 */ 2519 2509 { (yyval.expr) = (yyvsp[0].expr); } 2520 - #line 2527 "parser.tab.c" /* yacc.c:1646 */ 2510 + #line 2511 "parser.tab.c" /* yacc.c:1646 */ 2521 2511 break; 2522 2512 2523 2513 case 117: 2524 2514 #line 590 "parser.y" /* yacc.c:1646 */ 2525 2515 { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2526 - #line 2533 "parser.tab.c" /* yacc.c:1646 */ 2516 + #line 2517 "parser.tab.c" /* yacc.c:1646 */ 2527 2517 break; 2528 2518 2529 2519 case 118: 2530 2520 #line 594 "parser.y" /* yacc.c:1646 */ 2531 2521 { (yyval.expr) = (yyvsp[0].expr); } 2532 - #line 2539 "parser.tab.c" /* yacc.c:1646 */ 2522 + #line 2523 "parser.tab.c" /* yacc.c:1646 */ 2533 2523 break; 2534 2524 2535 2525 case 119: 2536 2526 #line 596 "parser.y" /* yacc.c:1646 */ 2537 2527 { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2538 - #line 2545 "parser.tab.c" /* yacc.c:1646 */ 2528 + #line 2529 "parser.tab.c" /* yacc.c:1646 */ 2539 2529 break; 2540 2530 2541 2531 case 120: 2542 2532 #line 601 "parser.y" /* yacc.c:1646 */ 2543 2533 { (yyval.expr) = (yyvsp[0].expr); } 2544 - #line 2551 "parser.tab.c" /* yacc.c:1646 */ 2534 + #line 2535 "parser.tab.c" /* yacc.c:1646 */ 2545 2535 break; 2546 2536 2547 2537 case 121: 2548 2538 #line 603 "parser.y" /* yacc.c:1646 */ 2549 2539 { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2550 - #line 2557 "parser.tab.c" /* yacc.c:1646 */ 2540 + #line 2541 "parser.tab.c" /* yacc.c:1646 */ 2551 2541 break; 2552 2542 2553 2543 case 122: 2554 2544 #line 607 "parser.y" /* yacc.c:1646 */ 2555 2545 { (yyval.expr) = (yyvsp[0].expr); } 2556 - #line 2563 "parser.tab.c" /* yacc.c:1646 */ 2546 + #line 2547 "parser.tab.c" /* yacc.c:1646 */ 2557 2547 break; 2558 2548 2559 2549 case 123: 2560 2550 #line 609 "parser.y" /* yacc.c:1646 */ 2561 2551 { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2562 - #line 2569 "parser.tab.c" /* yacc.c:1646 */ 2552 + #line 2553 "parser.tab.c" /* yacc.c:1646 */ 2563 2553 break; 2564 2554 2565 2555 case 124: 2566 2556 #line 614 "parser.y" /* yacc.c:1646 */ 2567 2557 { (yyval.expr) = (yyvsp[0].expr); } 2568 - #line 2575 "parser.tab.c" /* yacc.c:1646 */ 2558 + #line 2559 "parser.tab.c" /* yacc.c:1646 */ 2569 2559 break; 2570 2560 2571 2561 case 125: 2572 2562 #line 616 "parser.y" /* yacc.c:1646 */ 2573 2563 { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2574 - #line 2581 "parser.tab.c" /* yacc.c:1646 */ 2564 + #line 2565 "parser.tab.c" /* yacc.c:1646 */ 2575 2565 break; 2576 2566 2577 2567 case 126: 2578 2568 #line 620 "parser.y" /* yacc.c:1646 */ 2579 2569 { (yyval.expr) = (yyvsp[0].expr); } 2580 - #line 2587 "parser.tab.c" /* yacc.c:1646 */ 2570 + #line 2571 "parser.tab.c" /* yacc.c:1646 */ 2581 2571 break; 2582 2572 2583 2573 case 127: 2584 2574 #line 622 "parser.y" /* yacc.c:1646 */ 2585 2575 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2586 - #line 2593 "parser.tab.c" /* yacc.c:1646 */ 2576 + #line 2577 "parser.tab.c" /* yacc.c:1646 */ 2587 2577 break; 2588 2578 2589 2579 case 128: 2590 2580 #line 626 "parser.y" /* yacc.c:1646 */ 2591 2581 { (yyval.expr) = (yyvsp[0].expr); } 2592 - #line 2599 "parser.tab.c" /* yacc.c:1646 */ 2582 + #line 2583 "parser.tab.c" /* yacc.c:1646 */ 2593 2583 break; 2594 2584 2595 2585 case 129: 2596 2586 #line 628 "parser.y" /* yacc.c:1646 */ 2597 2587 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2598 - #line 2605 "parser.tab.c" /* yacc.c:1646 */ 2588 + #line 2589 "parser.tab.c" /* yacc.c:1646 */ 2599 2589 break; 2600 2590 2601 2591 case 130: 2602 2592 #line 632 "parser.y" /* yacc.c:1646 */ 2603 2593 { (yyval.expr) = (yyvsp[0].expr); } 2604 - #line 2611 "parser.tab.c" /* yacc.c:1646 */ 2594 + #line 2595 "parser.tab.c" /* yacc.c:1646 */ 2605 2595 break; 2606 2596 2607 2597 case 131: 2608 2598 #line 634 "parser.y" /* yacc.c:1646 */ 2609 2599 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2610 - #line 2617 "parser.tab.c" /* yacc.c:1646 */ 2600 + #line 2601 "parser.tab.c" /* yacc.c:1646 */ 2611 2601 break; 2612 2602 2613 2603 case 132: 2614 2604 #line 636 "parser.y" /* yacc.c:1646 */ 2615 2605 { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2616 - #line 2623 "parser.tab.c" /* yacc.c:1646 */ 2606 + #line 2607 "parser.tab.c" /* yacc.c:1646 */ 2617 2607 break; 2618 2608 2619 2609 case 133: 2620 2610 #line 638 "parser.y" /* yacc.c:1646 */ 2621 2611 { (yyval.expr) = new_binary_expression(ctx, EXPR_IN, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2622 - #line 2629 "parser.tab.c" /* yacc.c:1646 */ 2612 + #line 2613 "parser.tab.c" /* yacc.c:1646 */ 2623 2613 break; 2624 2614 2625 2615 case 134: 2626 2616 #line 642 "parser.y" /* yacc.c:1646 */ 2627 2617 { (yyval.expr) = (yyvsp[0].expr); } 2628 - #line 2635 "parser.tab.c" /* yacc.c:1646 */ 2618 + #line 2619 "parser.tab.c" /* yacc.c:1646 */ 2629 2619 break; 2630 2620 2631 2621 case 135: 2632 2622 #line 644 "parser.y" /* yacc.c:1646 */ 2633 2623 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2634 - #line 2641 "parser.tab.c" /* yacc.c:1646 */ 2624 + #line 2625 "parser.tab.c" /* yacc.c:1646 */ 2635 2625 break; 2636 2626 2637 2627 case 136: 2638 2628 #line 646 "parser.y" /* yacc.c:1646 */ 2639 2629 { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2640 - #line 2647 "parser.tab.c" /* yacc.c:1646 */ 2630 + #line 2631 "parser.tab.c" /* yacc.c:1646 */ 2641 2631 break; 2642 2632 2643 2633 case 137: 2644 2634 #line 650 "parser.y" /* yacc.c:1646 */ 2645 2635 { (yyval.expr) = (yyvsp[0].expr); } 2646 - #line 2653 "parser.tab.c" /* yacc.c:1646 */ 2636 + #line 2637 "parser.tab.c" /* yacc.c:1646 */ 2647 2637 break; 2648 2638 2649 2639 case 138: 2650 2640 #line 652 "parser.y" /* yacc.c:1646 */ 2651 2641 { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } 2652 - #line 2659 "parser.tab.c" /* yacc.c:1646 */ 2642 + #line 2643 "parser.tab.c" /* yacc.c:1646 */ 2653 2643 break; 2654 2644 2655 2645 case 139: 2656 2646 #line 657 "parser.y" /* yacc.c:1646 */ 2657 2647 { (yyval.expr) = (yyvsp[0].expr); } 2658 - #line 2665 "parser.tab.c" /* yacc.c:1646 */ 2648 + #line 2649 "parser.tab.c" /* yacc.c:1646 */ 2659 2649 break; 2660 2650 2661 2651 case 140: 2662 2652 #line 659 "parser.y" /* yacc.c:1646 */ 2663 2653 { (yyval.expr) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2664 - #line 2671 "parser.tab.c" /* yacc.c:1646 */ 2654 + #line 2655 "parser.tab.c" /* yacc.c:1646 */ 2665 2655 break; 2666 2656 2667 2657 case 141: 2668 2658 #line 661 "parser.y" /* yacc.c:1646 */ 2669 2659 { (yyval.expr) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2670 - #line 2677 "parser.tab.c" /* yacc.c:1646 */ 2660 + #line 2661 "parser.tab.c" /* yacc.c:1646 */ 2671 2661 break; 2672 2662 2673 2663 case 142: 2674 2664 #line 665 "parser.y" /* yacc.c:1646 */ 2675 2665 { (yyval.expr) = (yyvsp[0].expr); } 2676 - #line 2683 "parser.tab.c" /* yacc.c:1646 */ 2666 + #line 2667 "parser.tab.c" /* yacc.c:1646 */ 2677 2667 break; 2678 2668 2679 2669 case 143: 2680 2670 #line 667 "parser.y" /* yacc.c:1646 */ 2681 2671 { (yyval.expr) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2682 - #line 2689 "parser.tab.c" /* yacc.c:1646 */ 2672 + #line 2673 "parser.tab.c" /* yacc.c:1646 */ 2683 2673 break; 2684 2674 2685 2675 case 144: 2686 2676 #line 669 "parser.y" /* yacc.c:1646 */ 2687 2677 { (yyval.expr) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2688 - #line 2695 "parser.tab.c" /* yacc.c:1646 */ 2678 + #line 2679 "parser.tab.c" /* yacc.c:1646 */ 2689 2679 break; 2690 2680 2691 2681 case 145: 2692 2682 #line 671 "parser.y" /* yacc.c:1646 */ 2693 2683 { (yyval.expr) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); } 2694 - #line 2701 "parser.tab.c" /* yacc.c:1646 */ 2684 + #line 2685 "parser.tab.c" /* yacc.c:1646 */ 2695 2685 break; 2696 2686 2697 2687 case 146: 2698 2688 #line 675 "parser.y" /* yacc.c:1646 */ 2699 2689 { (yyval.expr) = (yyvsp[0].expr); } 2700 - #line 2707 "parser.tab.c" /* yacc.c:1646 */ 2690 + #line 2691 "parser.tab.c" /* yacc.c:1646 */ 2701 2691 break; 2702 2692 2703 2693 case 147: 2704 2694 #line 677 "parser.y" /* yacc.c:1646 */ 2705 2695 { (yyval.expr) = new_unary_expression(ctx, EXPR_DELETE, (yyvsp[0].expr)); } 2706 - #line 2713 "parser.tab.c" /* yacc.c:1646 */ 2696 + #line 2697 "parser.tab.c" /* yacc.c:1646 */ 2707 2697 break; 2708 2698 2709 2699 case 148: 2710 2700 #line 678 "parser.y" /* yacc.c:1646 */ 2711 2701 { (yyval.expr) = new_unary_expression(ctx, EXPR_VOID, (yyvsp[0].expr)); } 2712 - #line 2719 "parser.tab.c" /* yacc.c:1646 */ 2702 + #line 2703 "parser.tab.c" /* yacc.c:1646 */ 2713 2703 break; 2714 2704 2715 2705 case 149: 2716 2706 #line 680 "parser.y" /* yacc.c:1646 */ 2717 2707 { (yyval.expr) = new_unary_expression(ctx, EXPR_TYPEOF, (yyvsp[0].expr)); } 2718 - #line 2725 "parser.tab.c" /* yacc.c:1646 */ 2708 + #line 2709 "parser.tab.c" /* yacc.c:1646 */ 2719 2709 break; 2720 2710 2721 2711 case 150: 2722 2712 #line 681 "parser.y" /* yacc.c:1646 */ 2723 2713 { (yyval.expr) = new_unary_expression(ctx, EXPR_PREINC, (yyvsp[0].expr)); } 2724 - #line 2731 "parser.tab.c" /* yacc.c:1646 */ 2714 + #line 2715 "parser.tab.c" /* yacc.c:1646 */ 2725 2715 break; 2726 2716 2727 2717 case 151: 2728 2718 #line 682 "parser.y" /* yacc.c:1646 */ 2729 2719 { (yyval.expr) = new_unary_expression(ctx, EXPR_PREDEC, (yyvsp[0].expr)); } 2730 - #line 2737 "parser.tab.c" /* yacc.c:1646 */ 2720 + #line 2721 "parser.tab.c" /* yacc.c:1646 */ 2731 2721 break; 2732 2722 2733 2723 case 152: 2734 2724 #line 683 "parser.y" /* yacc.c:1646 */ 2735 2725 { (yyval.expr) = new_unary_expression(ctx, EXPR_PLUS, (yyvsp[0].expr)); } 2736 - #line 2743 "parser.tab.c" /* yacc.c:1646 */ 2726 + #line 2727 "parser.tab.c" /* yacc.c:1646 */ 2737 2727 break; 2738 2728 2739 2729 case 153: 2740 2730 #line 684 "parser.y" /* yacc.c:1646 */ 2741 2731 { (yyval.expr) = new_unary_expression(ctx, EXPR_MINUS, (yyvsp[0].expr)); } 2742 - #line 2749 "parser.tab.c" /* yacc.c:1646 */ 2732 + #line 2733 "parser.tab.c" /* yacc.c:1646 */ 2743 2733 break; 2744 2734 2745 2735 case 154: 2746 2736 #line 685 "parser.y" /* yacc.c:1646 */ 2747 2737 { (yyval.expr) = new_unary_expression(ctx, EXPR_BITNEG, (yyvsp[0].expr)); } 2748 - #line 2755 "parser.tab.c" /* yacc.c:1646 */ 2738 + #line 2739 "parser.tab.c" /* yacc.c:1646 */ 2749 2739 break; 2750 2740 2751 2741 case 155: 2752 2742 #line 686 "parser.y" /* yacc.c:1646 */ 2753 2743 { (yyval.expr) = new_unary_expression(ctx, EXPR_LOGNEG, (yyvsp[0].expr)); } 2754 - #line 2761 "parser.tab.c" /* yacc.c:1646 */ 2744 + #line 2745 "parser.tab.c" /* yacc.c:1646 */ 2755 2745 break; 2756 2746 2757 2747 case 156: 2758 2748 #line 691 "parser.y" /* yacc.c:1646 */ 2759 2749 { (yyval.expr) = (yyvsp[0].expr); } 2760 - #line 2767 "parser.tab.c" /* yacc.c:1646 */ 2750 + #line 2751 "parser.tab.c" /* yacc.c:1646 */ 2761 2751 break; 2762 2752 2763 2753 case 157: 2764 2754 #line 693 "parser.y" /* yacc.c:1646 */ 2765 2755 { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTINC, (yyvsp[-1].expr)); } 2766 - #line 2773 "parser.tab.c" /* yacc.c:1646 */ 2756 + #line 2757 "parser.tab.c" /* yacc.c:1646 */ 2767 2757 break; 2768 2758 2769 2759 case 158: 2770 2760 #line 695 "parser.y" /* yacc.c:1646 */ 2771 2761 { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTDEC, (yyvsp[-1].expr)); } 2772 - #line 2779 "parser.tab.c" /* yacc.c:1646 */ 2762 + #line 2763 "parser.tab.c" /* yacc.c:1646 */ 2773 2763 break; 2774 2764 2775 2765 case 159: 2776 2766 #line 700 "parser.y" /* yacc.c:1646 */ 2777 2767 { (yyval.expr) = (yyvsp[0].expr); } 2778 - #line 2785 "parser.tab.c" /* yacc.c:1646 */ 2768 + #line 2769 "parser.tab.c" /* yacc.c:1646 */ 2779 2769 break; 2780 2770 2781 2771 case 160: 2782 2772 #line 701 "parser.y" /* yacc.c:1646 */ 2783 2773 { (yyval.expr) = (yyvsp[0].expr); } 2784 - #line 2791 "parser.tab.c" /* yacc.c:1646 */ 2774 + #line 2775 "parser.tab.c" /* yacc.c:1646 */ 2785 2775 break; 2786 2776 2787 2777 case 161: 2788 2778 #line 705 "parser.y" /* yacc.c:1646 */ 2789 2779 { (yyval.expr) = (yyvsp[0].expr); } 2790 - #line 2797 "parser.tab.c" /* yacc.c:1646 */ 2780 + #line 2781 "parser.tab.c" /* yacc.c:1646 */ 2791 2781 break; 2792 2782 2793 2783 case 162: 2794 2784 #line 706 "parser.y" /* yacc.c:1646 */ 2795 2785 { (yyval.expr) = new_new_expression(ctx, (yyvsp[0].expr), NULL); } 2796 - #line 2803 "parser.tab.c" /* yacc.c:1646 */ 2786 + #line 2787 "parser.tab.c" /* yacc.c:1646 */ 2797 2787 break; 2798 2788 2799 2789 case 163: 2800 2790 #line 710 "parser.y" /* yacc.c:1646 */ 2801 2791 { (yyval.expr) = (yyvsp[0].expr); } 2802 - #line 2809 "parser.tab.c" /* yacc.c:1646 */ 2792 + #line 2793 "parser.tab.c" /* yacc.c:1646 */ 2803 2793 break; 2804 2794 2805 2795 case 164: 2806 2796 #line 711 "parser.y" /* yacc.c:1646 */ 2807 2797 { (yyval.expr) = (yyvsp[0].expr); } 2808 - #line 2815 "parser.tab.c" /* yacc.c:1646 */ 2798 + #line 2799 "parser.tab.c" /* yacc.c:1646 */ 2809 2799 break; 2810 2800 2811 2801 case 165: 2812 2802 #line 713 "parser.y" /* yacc.c:1646 */ 2813 2803 { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 2814 - #line 2821 "parser.tab.c" /* yacc.c:1646 */ 2804 + #line 2805 "parser.tab.c" /* yacc.c:1646 */ 2815 2805 break; 2816 2806 2817 2807 case 166: 2818 2808 #line 715 "parser.y" /* yacc.c:1646 */ 2819 2809 { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); } 2820 - #line 2827 "parser.tab.c" /* yacc.c:1646 */ 2810 + #line 2811 "parser.tab.c" /* yacc.c:1646 */ 2821 2811 break; 2822 2812 2823 2813 case 167: 2824 2814 #line 717 "parser.y" /* yacc.c:1646 */ 2825 2815 { (yyval.expr) = new_new_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } 2826 - #line 2833 "parser.tab.c" /* yacc.c:1646 */ 2816 + #line 2817 "parser.tab.c" /* yacc.c:1646 */ 2827 2817 break; 2828 2818 2829 2819 case 168: 2830 2820 #line 722 "parser.y" /* yacc.c:1646 */ 2831 2821 { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } 2832 - #line 2839 "parser.tab.c" /* yacc.c:1646 */ 2822 + #line 2823 "parser.tab.c" /* yacc.c:1646 */ 2833 2823 break; 2834 2824 2835 2825 case 169: 2836 2826 #line 724 "parser.y" /* yacc.c:1646 */ 2837 2827 { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } 2838 - #line 2845 "parser.tab.c" /* yacc.c:1646 */ 2828 + #line 2829 "parser.tab.c" /* yacc.c:1646 */ 2839 2829 break; 2840 2830 2841 2831 case 170: 2842 2832 #line 726 "parser.y" /* yacc.c:1646 */ 2843 2833 { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 2844 - #line 2851 "parser.tab.c" /* yacc.c:1646 */ 2834 + #line 2835 "parser.tab.c" /* yacc.c:1646 */ 2845 2835 break; 2846 2836 2847 2837 case 171: 2848 2838 #line 728 "parser.y" /* yacc.c:1646 */ 2849 2839 { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); } 2850 - #line 2857 "parser.tab.c" /* yacc.c:1646 */ 2840 + #line 2841 "parser.tab.c" /* yacc.c:1646 */ 2851 2841 break; 2852 2842 2853 2843 case 172: 2854 2844 #line 732 "parser.y" /* yacc.c:1646 */ 2855 2845 { (yyval.argument_list) = NULL; } 2856 - #line 2863 "parser.tab.c" /* yacc.c:1646 */ 2846 + #line 2847 "parser.tab.c" /* yacc.c:1646 */ 2857 2847 break; 2858 2848 2859 2849 case 173: 2860 2850 #line 733 "parser.y" /* yacc.c:1646 */ 2861 2851 { (yyval.argument_list) = (yyvsp[-1].argument_list); } 2862 - #line 2869 "parser.tab.c" /* yacc.c:1646 */ 2852 + #line 2853 "parser.tab.c" /* yacc.c:1646 */ 2863 2853 break; 2864 2854 2865 2855 case 174: 2866 2856 #line 737 "parser.y" /* yacc.c:1646 */ 2867 2857 { (yyval.argument_list) = new_argument_list(ctx, (yyvsp[0].expr)); } 2868 - #line 2875 "parser.tab.c" /* yacc.c:1646 */ 2858 + #line 2859 "parser.tab.c" /* yacc.c:1646 */ 2869 2859 break; 2870 2860 2871 2861 case 175: 2872 2862 #line 739 "parser.y" /* yacc.c:1646 */ 2873 2863 { (yyval.argument_list) = argument_list_add(ctx, (yyvsp[-2].argument_list), (yyvsp[0].expr)); } 2874 - #line 2881 "parser.tab.c" /* yacc.c:1646 */ 2864 + #line 2865 "parser.tab.c" /* yacc.c:1646 */ 2875 2865 break; 2876 2866 2877 2867 case 176: 2878 2868 #line 743 "parser.y" /* yacc.c:1646 */ 2879 2869 { (yyval.expr) = new_expression(ctx, EXPR_THIS, 0); } 2880 - #line 2887 "parser.tab.c" /* yacc.c:1646 */ 2870 + #line 2871 "parser.tab.c" /* yacc.c:1646 */ 2881 2871 break; 2882 2872 2883 2873 case 177: 2884 2874 #line 744 "parser.y" /* yacc.c:1646 */ 2885 2875 { (yyval.expr) = new_identifier_expression(ctx, (yyvsp[0].identifier)); } 2886 - #line 2893 "parser.tab.c" /* yacc.c:1646 */ 2876 + #line 2877 "parser.tab.c" /* yacc.c:1646 */ 2887 2877 break; 2888 2878 2889 2879 case 178: 2890 2880 #line 745 "parser.y" /* yacc.c:1646 */ 2891 2881 { (yyval.expr) = new_literal_expression(ctx, (yyvsp[0].literal)); } 2892 - #line 2899 "parser.tab.c" /* yacc.c:1646 */ 2882 + #line 2883 "parser.tab.c" /* yacc.c:1646 */ 2893 2883 break; 2894 2884 2895 2885 case 179: 2896 2886 #line 746 "parser.y" /* yacc.c:1646 */ 2897 2887 { (yyval.expr) = (yyvsp[0].expr); } 2898 - #line 2905 "parser.tab.c" /* yacc.c:1646 */ 2888 + #line 2889 "parser.tab.c" /* yacc.c:1646 */ 2899 2889 break; 2900 2890 2901 2891 case 180: 2902 2892 #line 747 "parser.y" /* yacc.c:1646 */ 2903 2893 { (yyval.expr) = (yyvsp[0].expr); } 2904 - #line 2911 "parser.tab.c" /* yacc.c:1646 */ 2894 + #line 2895 "parser.tab.c" /* yacc.c:1646 */ 2905 2895 break; 2906 2896 2907 2897 case 181: 2908 2898 #line 748 "parser.y" /* yacc.c:1646 */ 2909 2899 { (yyval.expr) = (yyvsp[-1].expr); } 2910 - #line 2917 "parser.tab.c" /* yacc.c:1646 */ 2900 + #line 2901 "parser.tab.c" /* yacc.c:1646 */ 2911 2901 break; 2912 2902 2913 2903 case 182: 2914 2904 #line 752 "parser.y" /* yacc.c:1646 */ 2915 2905 { (yyval.expr) = new_array_literal_expression(ctx, NULL, 0); } 2916 - #line 2923 "parser.tab.c" /* yacc.c:1646 */ 2906 + #line 2907 "parser.tab.c" /* yacc.c:1646 */ 2917 2907 break; 2918 2908 2919 2909 case 183: 2920 2910 #line 753 "parser.y" /* yacc.c:1646 */ 2921 2911 { (yyval.expr) = new_array_literal_expression(ctx, NULL, (yyvsp[-1].ival)+1); } 2922 - #line 2929 "parser.tab.c" /* yacc.c:1646 */ 2912 + #line 2913 "parser.tab.c" /* yacc.c:1646 */ 2923 2913 break; 2924 2914 2925 2915 case 184: 2926 2916 #line 754 "parser.y" /* yacc.c:1646 */ 2927 2917 { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-1].element_list), 0); } 2928 - #line 2935 "parser.tab.c" /* yacc.c:1646 */ 2918 + #line 2919 "parser.tab.c" /* yacc.c:1646 */ 2929 2919 break; 2930 2920 2931 2921 case 185: 2932 2922 #line 756 "parser.y" /* yacc.c:1646 */ 2933 2923 { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival)+1); } 2934 - #line 2941 "parser.tab.c" /* yacc.c:1646 */ 2924 + #line 2925 "parser.tab.c" /* yacc.c:1646 */ 2935 2925 break; 2936 2926 2937 2927 case 186: 2938 2928 #line 761 "parser.y" /* yacc.c:1646 */ 2939 2929 { (yyval.element_list) = new_element_list(ctx, (yyvsp[-1].ival), (yyvsp[0].expr)); } 2940 - #line 2947 "parser.tab.c" /* yacc.c:1646 */ 2930 + #line 2931 "parser.tab.c" /* yacc.c:1646 */ 2941 2931 break; 2942 2932 2943 2933 case 187: 2944 2934 #line 763 "parser.y" /* yacc.c:1646 */ 2945 2935 { (yyval.element_list) = element_list_add(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival), (yyvsp[0].expr)); } 2946 - #line 2953 "parser.tab.c" /* yacc.c:1646 */ 2936 + #line 2937 "parser.tab.c" /* yacc.c:1646 */ 2947 2937 break; 2948 2938 2949 2939 case 188: 2950 2940 #line 767 "parser.y" /* yacc.c:1646 */ 2951 2941 { (yyval.ival) = 1; } 2952 - #line 2959 "parser.tab.c" /* yacc.c:1646 */ 2942 + #line 2943 "parser.tab.c" /* yacc.c:1646 */ 2953 2943 break; 2954 2944 2955 2945 case 189: 2956 2946 #line 768 "parser.y" /* yacc.c:1646 */ 2957 2947 { (yyval.ival) = (yyvsp[-1].ival) + 1; } 2958 - #line 2965 "parser.tab.c" /* yacc.c:1646 */ 2948 + #line 2949 "parser.tab.c" /* yacc.c:1646 */ 2959 2949 break; 2960 2950 2961 2951 case 190: 2962 2952 #line 772 "parser.y" /* yacc.c:1646 */ 2963 2953 { (yyval.ival) = 0; } 2964 - #line 2971 "parser.tab.c" /* yacc.c:1646 */ 2954 + #line 2955 "parser.tab.c" /* yacc.c:1646 */ 2965 2955 break; 2966 2956 2967 2957 case 191: 2968 2958 #line 773 "parser.y" /* yacc.c:1646 */ 2969 2959 { (yyval.ival) = (yyvsp[0].ival); } 2970 - #line 2977 "parser.tab.c" /* yacc.c:1646 */ 2960 + #line 2961 "parser.tab.c" /* yacc.c:1646 */ 2971 2961 break; 2972 2962 2973 2963 case 192: 2974 2964 #line 777 "parser.y" /* yacc.c:1646 */ 2975 2965 { (yyval.expr) = new_prop_and_value_expression(ctx, NULL); } 2976 - #line 2983 "parser.tab.c" /* yacc.c:1646 */ 2966 + #line 2967 "parser.tab.c" /* yacc.c:1646 */ 2977 2967 break; 2978 2968 2979 2969 case 193: 2980 2970 #line 779 "parser.y" /* yacc.c:1646 */ 2981 2971 { (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-1].property_list)); } 2982 - #line 2989 "parser.tab.c" /* yacc.c:1646 */ 2972 + #line 2973 "parser.tab.c" /* yacc.c:1646 */ 2983 2973 break; 2984 2974 2985 2975 case 194: 2986 2976 #line 784 "parser.y" /* yacc.c:1646 */ 2987 2977 { (yyval.property_list) = new_property_list(ctx, (yyvsp[-2].literal), (yyvsp[0].expr)); } 2988 - #line 2995 "parser.tab.c" /* yacc.c:1646 */ 2978 + #line 2979 "parser.tab.c" /* yacc.c:1646 */ 2989 2979 break; 2990 2980 2991 2981 case 195: 2992 2982 #line 786 "parser.y" /* yacc.c:1646 */ 2993 2983 { (yyval.property_list) = property_list_add(ctx, (yyvsp[-4].property_list), (yyvsp[-2].literal), (yyvsp[0].expr)); } 2994 - #line 3001 "parser.tab.c" /* yacc.c:1646 */ 2984 + #line 2985 "parser.tab.c" /* yacc.c:1646 */ 2995 2985 break; 2996 2986 2997 2987 case 196: 2998 2988 #line 790 "parser.y" /* yacc.c:1646 */ 2999 2989 { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].identifier)); } 3000 - #line 3007 "parser.tab.c" /* yacc.c:1646 */ 2990 + #line 2991 "parser.tab.c" /* yacc.c:1646 */ 3001 2991 break; 3002 2992 3003 2993 case 197: 3004 2994 #line 791 "parser.y" /* yacc.c:1646 */ 3005 2995 { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); } 3006 - #line 3013 "parser.tab.c" /* yacc.c:1646 */ 2996 + #line 2997 "parser.tab.c" /* yacc.c:1646 */ 3007 2997 break; 3008 2998 3009 2999 case 198: 3010 3000 #line 792 "parser.y" /* yacc.c:1646 */ 3011 3001 { (yyval.literal) = (yyvsp[0].literal); } 3012 - #line 3019 "parser.tab.c" /* yacc.c:1646 */ 3002 + #line 3003 "parser.tab.c" /* yacc.c:1646 */ 3013 3003 break; 3014 3004 3015 3005 case 199: 3016 3006 #line 796 "parser.y" /* yacc.c:1646 */ 3017 3007 { (yyval.identifier) = NULL; } 3018 - #line 3025 "parser.tab.c" /* yacc.c:1646 */ 3008 + #line 3009 "parser.tab.c" /* yacc.c:1646 */ 3019 3009 break; 3020 3010 3021 3011 case 200: 3022 3012 #line 797 "parser.y" /* yacc.c:1646 */ 3023 3013 { (yyval.identifier) = (yyvsp[0].identifier); } 3024 - #line 3031 "parser.tab.c" /* yacc.c:1646 */ 3014 + #line 3015 "parser.tab.c" /* yacc.c:1646 */ 3025 3015 break; 3026 3016 3027 3017 case 201: 3028 3018 #line 801 "parser.y" /* yacc.c:1646 */ 3029 3019 { (yyval.literal) = new_null_literal(ctx); } 3030 - #line 3037 "parser.tab.c" /* yacc.c:1646 */ 3020 + #line 3021 "parser.tab.c" /* yacc.c:1646 */ 3031 3021 break; 3032 3022 3033 3023 case 202: 3034 3024 #line 802 "parser.y" /* yacc.c:1646 */ 3035 3025 { (yyval.literal) = (yyvsp[0].literal); } 3036 - #line 3043 "parser.tab.c" /* yacc.c:1646 */ 3026 + #line 3027 "parser.tab.c" /* yacc.c:1646 */ 3037 3027 break; 3038 3028 3039 3029 case 203: 3040 3030 #line 803 "parser.y" /* yacc.c:1646 */ 3041 3031 { (yyval.literal) = (yyvsp[0].literal); } 3042 - #line 3049 "parser.tab.c" /* yacc.c:1646 */ 3032 + #line 3033 "parser.tab.c" /* yacc.c:1646 */ 3043 3033 break; 3044 3034 3045 3035 case 204: 3046 3036 #line 804 "parser.y" /* yacc.c:1646 */ 3047 3037 { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); } 3048 - #line 3055 "parser.tab.c" /* yacc.c:1646 */ 3038 + #line 3039 "parser.tab.c" /* yacc.c:1646 */ 3049 3039 break; 3050 3040 3051 3041 case 205: 3052 3042 #line 805 "parser.y" /* yacc.c:1646 */ 3053 3043 { (yyval.literal) = parse_regexp(ctx); 3054 3044 if(!(yyval.literal)) YYABORT; } 3055 - #line 3062 "parser.tab.c" /* yacc.c:1646 */ 3045 + #line 3046 "parser.tab.c" /* yacc.c:1646 */ 3056 3046 break; 3057 3047 3058 3048 case 206: 3059 3049 #line 807 "parser.y" /* yacc.c:1646 */ 3060 3050 { (yyval.literal) = parse_regexp(ctx); 3061 3051 if(!(yyval.literal)) YYABORT; } 3062 - #line 3069 "parser.tab.c" /* yacc.c:1646 */ 3052 + #line 3053 "parser.tab.c" /* yacc.c:1646 */ 3063 3053 break; 3064 3054 3065 3055 case 207: 3066 3056 #line 812 "parser.y" /* yacc.c:1646 */ 3067 3057 { (yyval.literal) = new_boolean_literal(ctx, VARIANT_TRUE); } 3068 - #line 3075 "parser.tab.c" /* yacc.c:1646 */ 3058 + #line 3059 "parser.tab.c" /* yacc.c:1646 */ 3069 3059 break; 3070 3060 3071 3061 case 208: 3072 3062 #line 813 "parser.y" /* yacc.c:1646 */ 3073 3063 { (yyval.literal) = new_boolean_literal(ctx, VARIANT_FALSE); } 3074 - #line 3081 "parser.tab.c" /* yacc.c:1646 */ 3064 + #line 3065 "parser.tab.c" /* yacc.c:1646 */ 3075 3065 break; 3076 3066 3077 3067 case 209: 3078 3068 #line 814 "parser.y" /* yacc.c:1646 */ 3079 3069 { (yyval.literal) = (yyvsp[0].literal); } 3080 - #line 3087 "parser.tab.c" /* yacc.c:1646 */ 3070 + #line 3071 "parser.tab.c" /* yacc.c:1646 */ 3081 3071 break; 3082 3072 3083 3073 case 211: 3084 3074 #line 818 "parser.y" /* yacc.c:1646 */ 3085 3075 { if(!allow_auto_semicolon(ctx)) {YYABORT;} } 3086 - #line 3093 "parser.tab.c" /* yacc.c:1646 */ 3076 + #line 3077 "parser.tab.c" /* yacc.c:1646 */ 3087 3077 break; 3088 3078 3089 3079 case 213: 3090 3080 #line 822 "parser.y" /* yacc.c:1646 */ 3091 3081 { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; } 3092 - #line 3099 "parser.tab.c" /* yacc.c:1646 */ 3082 + #line 3083 "parser.tab.c" /* yacc.c:1646 */ 3093 3083 break; 3094 3084 3095 3085 case 215: 3096 3086 #line 826 "parser.y" /* yacc.c:1646 */ 3097 3087 { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; } 3098 - #line 3105 "parser.tab.c" /* yacc.c:1646 */ 3088 + #line 3089 "parser.tab.c" /* yacc.c:1646 */ 3099 3089 break; 3100 3090 3101 3091 case 217: 3102 3092 #line 830 "parser.y" /* yacc.c:1646 */ 3103 3093 { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; } 3104 - #line 3111 "parser.tab.c" /* yacc.c:1646 */ 3094 + #line 3095 "parser.tab.c" /* yacc.c:1646 */ 3105 3095 break; 3106 3096 3107 3097 3108 - #line 3115 "parser.tab.c" /* yacc.c:1646 */ 3098 + #line 3099 "parser.tab.c" /* yacc.c:1646 */ 3109 3099 default: break; 3110 3100 } 3111 3101 /* User semantic actions sometimes alter yychar, and that requires
+4 -4
dll/win32/jscript/parser.tab.h
··· 1 - /* A Bison parser, made by GNU Bison 3.0.2. */ 1 + /* A Bison parser, made by GNU Bison 3.0. */ 2 2 3 3 /* Bison interface for Yacc-like parsers in C 4 4 ··· 30 30 This special exception was added by the Free Software Foundation in 31 31 version 2.2 of Bison. */ 32 32 33 - #ifndef YY_PARSER_PARSER_TAB_H_INCLUDED 34 - # define YY_PARSER_PARSER_TAB_H_INCLUDED 33 + #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED 34 + # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED 35 35 /* Debug traces. */ 36 36 #ifndef YYDEBUG 37 37 # define YYDEBUG 0 ··· 129 129 130 130 int parser_parse (parser_ctx_t *ctx); 131 131 132 - #endif /* !YY_PARSER_PARSER_TAB_H_INCLUDED */ 132 + #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED */
+6
dll/win32/jscript/parser.y
··· 19 19 %{ 20 20 21 21 #include "jscript.h" 22 + #include "engine.h" 23 + #include "parser.h" 24 + 25 + #include "wine/debug.h" 26 + 27 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 22 28 23 29 static int parser_error(parser_ctx_t*,const char*); 24 30 static void set_error(parser_ctx_t*,UINT);
+24
dll/win32/jscript/precomp.h
··· 1 + 2 + #ifndef _JSCRIPT_PRECOMP_H 3 + #define _JSCRIPT_PRECOMP_H 4 + 5 + #include <wine/config.h> 6 + #include <wine/port.h> 7 + 8 + #include <assert.h> 9 + 10 + #define WIN32_NO_STATUS 11 + #define _INC_WINDOWS 12 + #define COM_NO_WINDOWS_H 13 + 14 + #include "jscript.h" 15 + 16 + #include <objsafe.h> 17 + 18 + #include <wine/debug.h> 19 + 20 + #include "engine.h" 21 + #include "parser.h" 22 + #include "regexp.h" 23 + 24 + #endif /* !_JSCRIPT_PRECOMP_H */
+7
dll/win32/jscript/regexp.c
··· 31 31 * the Initial Developer. All Rights Reserved. 32 32 */ 33 33 34 + #include <assert.h> 35 + 34 36 #include "jscript.h" 37 + #include "regexp.h" 38 + 39 + #include "wine/debug.h" 40 + 41 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 35 42 36 43 /* FIXME: Better error handling */ 37 44 #define ReportRegExpError(a,b,c)
+2
dll/win32/jscript/resource.h
··· 18 18 19 19 #pragma once 20 20 21 + #include <windef.h> 22 + 21 23 #define JSCRIPT_MAJOR_VERSION 5 22 24 #define JSCRIPT_MINOR_VERSION 8 23 25 #define JSCRIPT_BUILD_VERSION 16475
-2
dll/win32/jscript/rsrc.rc
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 - #include <windef.h> 20 - 21 19 #include "resource.h" 22 20 23 21 /* @makedep: jscript.rgs */
+8
dll/win32/jscript/string.c
··· 16 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 17 */ 18 18 19 + #include "config.h" 20 + #include "wine/port.h" 21 + 19 22 #include "jscript.h" 23 + #include "regexp.h" 24 + 25 + #include "wine/debug.h" 26 + 27 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 20 28 21 29 typedef struct { 22 30 jsdisp_t dispex;
+4
dll/win32/jscript/vbarray.c
··· 18 18 19 19 #include "jscript.h" 20 20 21 + #include "wine/debug.h" 22 + 23 + WINE_DEFAULT_DEBUG_CHANNEL(jscript); 24 + 21 25 typedef struct { 22 26 jsdisp_t dispex; 23 27
+1 -1
media/doc/README.WINE
··· 85 85 reactos/dll/win32/iphlpapi # Out of sync 86 86 reactos/dll/win32/itircl # Synced to WineStaging-3.3 87 87 reactos/dll/win32/itss # Synced to WineStaging-3.3 88 - reactos/dll/win32/jscript # Synced to Wine-3.0 88 + reactos/dll/win32/jscript # Synced to WineStaging-3.3 89 89 reactos/dll/win32/jsproxy # Synced to WineStaging-2.16 90 90 reactos/dll/win32/loadperf # Synced to WineStaging-2.9 91 91 reactos/dll/win32/lz32 # Synced to WineStaging-2.9