diff --git a/reactos/dll/win32/jscript/CMakeLists.txt b/reactos/dll/win32/jscript/CMakeLists.txt index 88074750c9f..e7dde3cd261 100644 --- a/reactos/dll/win32/jscript/CMakeLists.txt +++ b/reactos/dll/win32/jscript/CMakeLists.txt @@ -10,6 +10,7 @@ list(APPEND SOURCE activex.c array.c bool.c + cc_parser.tab.c compile.c date.c decode.c diff --git a/reactos/dll/win32/jscript/array.c b/reactos/dll/win32/jscript/array.c index 8d488274f51..41204b0b5a9 100644 --- a/reactos/dll/win32/jscript/array.c +++ b/reactos/dll/win32/jscript/array.c @@ -40,9 +40,14 @@ static const WCHAR unshiftW[] = {'u','n','s','h','i','f','t',0}; static const WCHAR default_separatorW[] = {',',0}; +static inline ArrayInstance *array_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, ArrayInstance, dispex); +} + static inline ArrayInstance *array_from_vdisp(vdisp_t *vdisp) { - return (ArrayInstance*)vdisp->u.jsdisp; + return array_from_jsdisp(vdisp->u.jsdisp); } static inline ArrayInstance *array_this(vdisp_t *jsthis) @@ -104,44 +109,38 @@ static WCHAR *idx_to_str(DWORD idx, WCHAR *ptr) return ptr+1; } -static HRESULT Array_length(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Array_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { - ArrayInstance *This = array_from_vdisp(jsthis); + TRACE("%p\n", jsthis); + + *r = jsval_number(array_from_jsdisp(jsthis)->length); + return S_OK; +} + +static HRESULT Array_set_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + ArrayInstance *This = array_from_jsdisp(jsthis); + DOUBLE len = -1; + DWORD i; + HRESULT hres; TRACE("%p %d\n", This, This->length); - switch(flags) { - case DISPATCH_PROPERTYGET: - *r = jsval_number(This->length); - break; - case DISPATCH_PROPERTYPUT: { - DOUBLE len = -1; - DWORD i; - HRESULT hres; + hres = to_number(ctx, value, &len); + if(FAILED(hres)) + return hres; - hres = to_number(ctx, argv[0], &len); + len = floor(len); + if(len!=(DWORD)len) + return throw_range_error(ctx, JS_E_INVALID_LENGTH, NULL); + + for(i=len; i < This->length; i++) { + hres = jsdisp_delete_idx(&This->dispex, i); if(FAILED(hres)) return hres; - - len = floor(len); - if(len!=(DWORD)len) - return throw_range_error(ctx, JS_E_INVALID_LENGTH, NULL); - - for(i=len; ilength; i++) { - hres = jsdisp_delete_idx(&This->dispex, i); - if(FAILED(hres)) - return hres; - } - - This->length = len; - break; - } - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; } + This->length = len; return S_OK; } @@ -496,9 +495,7 @@ static HRESULT Array_shift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsign hres = set_length(jsthis, 0); if(FAILED(hres)) return hres; - } - if(!length) { if(r) *r = jsval_undefined(); return S_OK; @@ -995,22 +992,13 @@ static HRESULT Array_unshift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsi return S_OK; } -static HRESULT Array_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Array_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + ArrayInstance *array = array_from_jsdisp(jsthis); + TRACE("\n"); - switch(flags) { - case INVOKE_FUNC: - return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL); - case INVOKE_PROPERTYGET: - return array_join(ctx, jsthis->u.jsdisp, array_from_vdisp(jsthis)->length, default_separatorW, r); - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; - } - - return S_OK; + return array_join(ctx, &array->dispex, array->length, default_separatorW, r); } static void Array_destructor(jsdisp_t *dispex) @@ -1042,7 +1030,7 @@ static void Array_on_put(jsdisp_t *dispex, const WCHAR *name) static const builtin_prop_t Array_props[] = { {concatW, Array_concat, PROPF_METHOD|1}, {joinW, Array_join, PROPF_METHOD|1}, - {lengthW, Array_length, 0}, + {lengthW, NULL,0, Array_get_length, Array_set_length}, {popW, Array_pop, PROPF_METHOD}, {pushW, Array_push, PROPF_METHOD|1}, {reverseW, Array_reverse, PROPF_METHOD}, @@ -1057,7 +1045,7 @@ static const builtin_prop_t Array_props[] = { static const builtin_info_t Array_info = { JSCLASS_ARRAY, - {NULL, Array_value, 0}, + {NULL, NULL,0, Array_get_value}, sizeof(Array_props)/sizeof(*Array_props), Array_props, Array_destructor, @@ -1065,12 +1053,12 @@ static const builtin_info_t Array_info = { }; static const builtin_prop_t ArrayInst_props[] = { - {lengthW, Array_length, 0} + {lengthW, NULL,0, Array_get_length, Array_set_length} }; static const builtin_info_t ArrayInst_info = { JSCLASS_ARRAY, - {NULL, Array_value, 0}, + {NULL, NULL,0, Array_get_value}, sizeof(ArrayInst_props)/sizeof(*ArrayInst_props), ArrayInst_props, Array_destructor, diff --git a/reactos/dll/win32/jscript/cc_parser.tab.c b/reactos/dll/win32/jscript/cc_parser.tab.c new file mode 100644 index 00000000000..264d0719b76 --- /dev/null +++ b/reactos/dll/win32/jscript/cc_parser.tab.c @@ -0,0 +1,1820 @@ +/* A Bison parser, made by GNU Bison 3.0.2. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "3.0.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + +/* Substitute the variable and function names. */ +#define yyparse cc_parser_parse +#define yylex cc_parser_lex +#define yyerror cc_parser_error +#define yydebug cc_parser_debug +#define yynerrs cc_parser_nerrs + + +/* Copy the first part of user declarations. */ +#line 19 "cc_parser.y" /* yacc.c:339 */ + +#include "jscript.h" + +#line 84 "cc_parser.tab.c" /* yacc.c:339 */ + +# ifndef YY_NULLPTR +# if defined __cplusplus && 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + + +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int cc_parser_debug; +#endif + +/* Token type. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + tEQ = 258, + tEQEQ = 259, + tNEQ = 260, + tNEQEQ = 261, + tLSHIFT = 262, + tRSHIFT = 263, + tRRSHIFT = 264, + tOR = 265, + tAND = 266, + tLEQ = 267, + tGEQ = 268, + tCCValue = 269 + }; +#endif + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE YYSTYPE; +union YYSTYPE +{ +#line 36 "cc_parser.y" /* yacc.c:355 */ + + ccval_t ccval; + +#line 140 "cc_parser.tab.c" /* yacc.c:355 */ +}; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + + +int cc_parser_parse (parser_ctx_t *ctx); + + + +/* Copy the second part of user declarations. */ +#line 47 "cc_parser.y" /* yacc.c:358 */ + + +static int cc_parser_error(parser_ctx_t *ctx, const char *str) +{ + if(SUCCEEDED(ctx->hres)) { + WARN("%s\n", str); + ctx->hres = JS_E_SYNTAX; + } + + return 0; +} + +static int cc_parser_lex(void *lval, parser_ctx_t *ctx) +{ + int r; + + r = try_parse_ccval(ctx, lval); + if(r) + return r > 0 ? tCCValue : -1; + + switch(*ctx->ptr) { + case '(': + case ')': + case '+': + case '-': + case '*': + case '/': + case '~': + case '%': + case '^': + return *ctx->ptr++; + case '=': + if(*++ctx->ptr == '=') { + if(*++ctx->ptr == '=') { + ctx->ptr++; + return tEQEQ; + } + return tEQ; + } + break; + case '!': + if(*++ctx->ptr == '=') { + if(*++ctx->ptr == '=') { + ctx->ptr++; + return tNEQEQ; + } + return tNEQ; + } + return '!'; + case '<': + switch(*++ctx->ptr) { + case '<': + ctx->ptr++; + return tLSHIFT; + case '=': + ctx->ptr++; + return tLEQ; + default: + return '<'; + } + case '>': + switch(*++ctx->ptr) { + case '>': + if(*++ctx->ptr == '>') { + ctx->ptr++; + return tRRSHIFT; + } + return tRSHIFT; + case '=': + ctx->ptr++; + return tGEQ; + default: + return '>'; + } + case '|': + if(*++ctx->ptr == '|') { + ctx->ptr++; + return tOR; + } + return '|'; + case '&': + if(*++ctx->ptr == '&') { + ctx->ptr++; + return tAND; + } + return '&'; + } + + WARN("Failed to interpret %s\n", debugstr_w(ctx->ptr)); + return -1; +} + + +#line 247 "cc_parser.tab.c" /* yacc.c:358 */ + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +#ifndef YY_ATTRIBUTE +# if (defined __GNUC__ \ + && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ + || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C +# define YY_ATTRIBUTE(Spec) __attribute__(Spec) +# else +# define YY_ATTRIBUTE(Spec) /* empty */ +# endif +#endif + +#ifndef YY_ATTRIBUTE_PURE +# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) +#endif + +#if !defined _Noreturn \ + && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) +# if defined _MSC_VER && 1200 <= _MSC_VER +# define _Noreturn __declspec (noreturn) +# else +# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 24 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 57 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 29 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 13 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 39 +/* YYNSTATES -- Number of states. */ +#define YYNSTATES 69 + +/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned + by yylex, with out-of-bounds checking. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 269 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, without out-of-bounds checking. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 17, 2, 2, 2, 28, 23, 2, + 15, 16, 26, 19, 2, 20, 2, 27, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 24, 2, 25, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 22, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 21, 2, 18, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 +}; + +#if YYDEBUG + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +static const yytype_uint8 yyrline[] = +{ + 0, 146, 146, 149, 150, 151, 152, 153, 154, 157, + 158, 162, 163, 167, 168, 172, 173, 177, 178, 182, + 183, 185, 187, 189, 193, 194, 196, 198, 200, 204, + 205, 207, 209, 213, 214, 216, 220, 221, 223, 225 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || 0 +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "tEQ", "tEQEQ", "tNEQ", "tNEQEQ", + "tLSHIFT", "tRSHIFT", "tRRSHIFT", "tOR", "tAND", "tLEQ", "tGEQ", + "tCCValue", "'('", "')'", "'!'", "'~'", "'+'", "'-'", "'|'", "'^'", + "'&'", "'<'", "'>'", "'*'", "'/'", "'%'", "$accept", "CCExpr", + "CCUnaryExpression", "CCLogicalORExpression", "CCLogicalANDExpression", + "CCBitwiseORExpression", "CCBitwiseXORExpression", + "CCBitwiseANDExpression", "CCEqualityExpression", + "CCRelationalExpression", "CCShiftExpression", "CCAdditiveExpression", + "CCMultiplicativeExpression", YY_NULLPTR +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[NUM] -- (External) token number corresponding to the + (internal) symbol number NUM (which must be that of a token). */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 40, 41, 33, 126, 43, + 45, 124, 94, 38, 60, 62, 42, 47, 37 +}; +# endif + +#define YYPACT_NINF -17 + +#define yypact_value_is_default(Yystate) \ + (!!((Yystate) == (-17))) + +#define YYTABLE_NINF -1 + +#define yytable_value_is_error(Yytable_value) \ + 0 + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int8 yypact[] = +{ + 3, -17, 3, 3, 3, 3, 3, 16, -17, -17, + -1, -17, -13, 32, -4, 21, -11, 30, 31, -16, + -17, -17, -17, -17, -17, 3, -17, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, -17, 32, 9, + 9, -13, 21, -11, -11, -11, -11, 30, 30, 30, + 30, 31, 31, 31, -16, -16, -17, -17, -17 +}; + + /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 0, 3, 0, 0, 0, 0, 0, 0, 2, 36, + 0, 9, 11, 13, 15, 17, 19, 24, 29, 33, + 5, 6, 7, 8, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 14, 15, + 16, 12, 18, 20, 22, 21, 23, 26, 28, 25, + 27, 30, 31, 32, 34, 35, 37, 38, 39 +}; + + /* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -17, -17, 0, -17, 18, 26, 29, 13, 27, -3, + -2, 8, 10 +}; + + /* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + -1, 7, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19 +}; + + /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ +static const yytype_uint8 yytable[] = +{ + 8, 35, 36, 20, 21, 22, 23, 29, 27, 25, + 44, 45, 46, 37, 38, 26, 24, 1, 2, 30, + 3, 4, 5, 6, 31, 32, 33, 34, 53, 54, + 55, 56, 30, 57, 58, 59, 60, 39, 40, 41, + 49, 50, 49, 47, 66, 67, 68, 61, 62, 63, + 42, 43, 64, 65, 28, 51, 48, 52 +}; + +static const yytype_uint8 yycheck[] = +{ + 0, 12, 13, 3, 4, 5, 6, 11, 21, 10, + 26, 27, 28, 24, 25, 16, 0, 14, 15, 23, + 17, 18, 19, 20, 3, 4, 5, 6, 31, 32, + 33, 34, 23, 35, 36, 37, 38, 7, 8, 9, + 27, 28, 29, 25, 44, 45, 46, 39, 40, 41, + 19, 20, 42, 43, 22, 29, 27, 30 +}; + + /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 14, 15, 17, 18, 19, 20, 30, 31, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 31, 31, 31, 31, 0, 10, 16, 21, 22, 11, + 23, 3, 4, 5, 6, 12, 13, 24, 25, 7, + 8, 9, 19, 20, 26, 27, 28, 33, 35, 36, + 36, 34, 37, 38, 38, 38, 38, 39, 39, 39, + 39, 40, 40, 40, 41, 41, 31, 31, 31 +}; + + /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 29, 30, 31, 31, 31, 31, 31, 31, 32, + 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, + 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, + 39, 39, 39, 40, 40, 40, 41, 41, 41, 41 +}; + + /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 1, 3, 2, 2, 2, 2, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 3, 3, 3, 1, 3, 3, 3, 3, 1, + 3, 3, 3, 1, 3, 3, 1, 3, 3, 3 +}; + + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (ctx, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (0) + +/* Error token number */ +#define YYTERROR 1 +#define YYERRCODE 256 + + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +/* This macro is provided for backward compatibility. */ +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, ctx); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + + +/*----------------------------------------. +| Print this symbol's value on YYOUTPUT. | +`----------------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx) +{ + FILE *yyo = yyoutput; + YYUSE (yyo); + YYUSE (ctx); + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + YYUSE (yytype); +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx) +{ + YYFPRINTF (yyoutput, "%s %s (", + yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep, ctx); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parser_ctx_t *ctx) +{ + unsigned long int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + yystos[yyssp[yyi + 1 - yynrhs]], + &(yyvsp[(yyi + 1) - (yynrhs)]) + , ctx); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, Rule, ctx); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +yystrlen (const char *yystr) +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + { + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + { + YYSIZE_T yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx) +{ + YYUSE (yyvaluep); + YYUSE (ctx); + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YYUSE (yytype); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (parser_ctx_t *ctx) +{ +/* The lookahead symbol. */ +int yychar; + + +/* The semantic value of the lookahead symbol. */ +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +YY_INITIAL_VALUE (static YYSTYPE yyval_default;) +YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); + + /* Number of syntax errors so far. */ + int yynerrs; + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + 'yyss': related to states. + 'yyvs': related to semantic values. + + Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yyssp = yyss = yyssa; + yyvsp = yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = yylex (&yylval, ctx); + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +#line 146 "cc_parser.y" /* yacc.c:1646 */ + { ctx->ccval = (yyvsp[0].ccval); YYACCEPT; } +#line 1367 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 3: +#line 149 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1373 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 4: +#line 150 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[-1].ccval); } +#line 1379 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 5: +#line 151 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(!get_ccbool((yyvsp[0].ccval))); } +#line 1385 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 6: +#line 152 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'~' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1391 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 7: +#line 153 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'+' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1397 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 8: +#line 154 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'-' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1403 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 9: +#line 157 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1409 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 10: +#line 159 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'||' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1415 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 11: +#line 162 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1421 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 12: +#line 164 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'&&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1427 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 13: +#line 167 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1433 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 14: +#line 169 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'|' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1439 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 15: +#line 172 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1445 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 16: +#line 174 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'^' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1451 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 17: +#line 177 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1457 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 18: +#line 179 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1463 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 19: +#line 182 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1469 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 20: +#line 184 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) == get_ccnum((yyvsp[0].ccval))); } +#line 1475 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 21: +#line 186 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) != get_ccnum((yyvsp[0].ccval))); } +#line 1481 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 22: +#line 188 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'===' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1487 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 23: +#line 190 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'!==' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1493 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 24: +#line 193 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1499 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 25: +#line 195 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) < get_ccnum((yyvsp[0].ccval))); } +#line 1505 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 26: +#line 197 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) <= get_ccnum((yyvsp[0].ccval))); } +#line 1511 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 27: +#line 199 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) > get_ccnum((yyvsp[0].ccval))); } +#line 1517 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 28: +#line 201 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) >= get_ccnum((yyvsp[0].ccval))); } +#line 1523 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 29: +#line 204 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1529 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 30: +#line 206 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'<<' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1535 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 31: +#line 208 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1541 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 32: +#line 210 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'>>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1547 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 33: +#line 213 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1553 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 34: +#line 215 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) + get_ccnum((yyvsp[0].ccval))); } +#line 1559 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 35: +#line 217 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) - get_ccnum((yyvsp[0].ccval))); } +#line 1565 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 36: +#line 220 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = (yyvsp[0].ccval); } +#line 1571 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 37: +#line 222 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) * get_ccnum((yyvsp[0].ccval))); } +#line 1577 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 38: +#line 224 "cc_parser.y" /* yacc.c:1646 */ + { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) / get_ccnum((yyvsp[0].ccval))); } +#line 1583 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + case 39: +#line 226 "cc_parser.y" /* yacc.c:1646 */ + { FIXME("'%%' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } +#line 1589 "cc_parser.tab.c" /* yacc.c:1646 */ + break; + + +#line 1593 "cc_parser.tab.c" /* yacc.c:1646 */ + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (ctx, YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (ctx, yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval, ctx); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp, ctx); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined yyoverflow || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (ctx, YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, ctx); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp, ctx); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + return yyresult; +} +#line 228 "cc_parser.y" /* yacc.c:1906 */ + + +BOOL parse_cc_expr(parser_ctx_t *ctx) +{ + ctx->hres = S_OK; + cc_parser_parse(ctx); + return SUCCEEDED(ctx->hres); +} diff --git a/reactos/dll/win32/jscript/cc_parser.y b/reactos/dll/win32/jscript/cc_parser.y new file mode 100644 index 00000000000..d06ba7c703f --- /dev/null +++ b/reactos/dll/win32/jscript/cc_parser.y @@ -0,0 +1,229 @@ +/* + * Copyright 2014 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +%{ + +#include "jscript.h" + +%} + +%lex-param { parser_ctx_t *ctx } +%parse-param { parser_ctx_t *ctx } +%pure-parser +%start CCExpr + +%union { + ccval_t ccval; +} + +%token tEQ tEQEQ tNEQ tNEQEQ tLSHIFT tRSHIFT tRRSHIFT tOR tAND tLEQ tGEQ +%token tCCValue + +%type CCUnaryExpression CCLogicalORExpression CCLogicalANDExpression +%type CCBitwiseORExpression CCBitwiseXORExpression CCBitwiseANDExpression +%type CCEqualityExpression CCRelationalExpression CCShiftExpression CCAdditiveExpression CCMultiplicativeExpression + +%{ + +static int cc_parser_error(parser_ctx_t *ctx, const char *str) +{ + if(SUCCEEDED(ctx->hres)) { + WARN("%s\n", str); + ctx->hres = JS_E_SYNTAX; + } + + return 0; +} + +static int cc_parser_lex(void *lval, parser_ctx_t *ctx) +{ + int r; + + r = try_parse_ccval(ctx, lval); + if(r) + return r > 0 ? tCCValue : -1; + + switch(*ctx->ptr) { + case '(': + case ')': + case '+': + case '-': + case '*': + case '/': + case '~': + case '%': + case '^': + return *ctx->ptr++; + case '=': + if(*++ctx->ptr == '=') { + if(*++ctx->ptr == '=') { + ctx->ptr++; + return tEQEQ; + } + return tEQ; + } + break; + case '!': + if(*++ctx->ptr == '=') { + if(*++ctx->ptr == '=') { + ctx->ptr++; + return tNEQEQ; + } + return tNEQ; + } + return '!'; + case '<': + switch(*++ctx->ptr) { + case '<': + ctx->ptr++; + return tLSHIFT; + case '=': + ctx->ptr++; + return tLEQ; + default: + return '<'; + } + case '>': + switch(*++ctx->ptr) { + case '>': + if(*++ctx->ptr == '>') { + ctx->ptr++; + return tRRSHIFT; + } + return tRSHIFT; + case '=': + ctx->ptr++; + return tGEQ; + default: + return '>'; + } + case '|': + if(*++ctx->ptr == '|') { + ctx->ptr++; + return tOR; + } + return '|'; + case '&': + if(*++ctx->ptr == '&') { + ctx->ptr++; + return tAND; + } + return '&'; + } + + WARN("Failed to interpret %s\n", debugstr_w(ctx->ptr)); + return -1; +} + +%} + +%% + +/* FIXME: Implement missing expressions. */ + +CCExpr + : CCUnaryExpression { ctx->ccval = $1; YYACCEPT; } + +CCUnaryExpression + : tCCValue { $$ = $1; } + | '(' CCLogicalORExpression ')' { $$ = $2; } + | '!' CCUnaryExpression { $$ = ccval_bool(!get_ccbool($2)); }; + | '~' CCUnaryExpression { FIXME("'~' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + | '+' CCUnaryExpression { FIXME("'+' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + | '-' CCUnaryExpression { FIXME("'-' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCLogicalORExpression + : CCLogicalANDExpression { $$ = $1; } + | CCLogicalORExpression tOR CCLogicalANDExpression + { FIXME("'||' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCLogicalANDExpression + : CCBitwiseORExpression { $$ = $1; } + | CCBitwiseANDExpression tAND CCBitwiseORExpression + { FIXME("'&&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCBitwiseORExpression + : CCBitwiseXORExpression { $$ = $1; } + | CCBitwiseORExpression '|' CCBitwiseXORExpression + { FIXME("'|' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCBitwiseXORExpression + : CCBitwiseANDExpression { $$ = $1; } + | CCBitwiseXORExpression '^' CCBitwiseANDExpression + { FIXME("'^' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCBitwiseANDExpression + : CCEqualityExpression { $$ = $1; } + | CCBitwiseANDExpression '&' CCEqualityExpression + { FIXME("'&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCEqualityExpression + : CCRelationalExpression { $$ = $1; } + | CCEqualityExpression tEQ CCRelationalExpression + { $$ = ccval_bool(get_ccnum($1) == get_ccnum($3)); } + | CCEqualityExpression tNEQ CCRelationalExpression + { $$ = ccval_bool(get_ccnum($1) != get_ccnum($3)); } + | CCEqualityExpression tEQEQ CCRelationalExpression + { FIXME("'===' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + | CCEqualityExpression tNEQEQ CCRelationalExpression + { FIXME("'!==' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCRelationalExpression + : CCShiftExpression { $$ = $1; } + | CCRelationalExpression '<' CCShiftExpression + { $$ = ccval_bool(get_ccnum($1) < get_ccnum($3)); } + | CCRelationalExpression tLEQ CCShiftExpression + { $$ = ccval_bool(get_ccnum($1) <= get_ccnum($3)); } + | CCRelationalExpression '>' CCShiftExpression + { $$ = ccval_bool(get_ccnum($1) > get_ccnum($3)); } + | CCRelationalExpression tGEQ CCShiftExpression + { $$ = ccval_bool(get_ccnum($1) >= get_ccnum($3)); } + +CCShiftExpression + : CCAdditiveExpression { $$ = $1; } + | CCShiftExpression tLSHIFT CCAdditiveExpression + { FIXME("'<<' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + | CCShiftExpression tRSHIFT CCAdditiveExpression + { FIXME("'>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + | CCShiftExpression tRRSHIFT CCAdditiveExpression + { FIXME("'>>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +CCAdditiveExpression + : CCMultiplicativeExpression { $$ = $1; } + | CCAdditiveExpression '+' CCMultiplicativeExpression + { $$ = ccval_num(get_ccnum($1) + get_ccnum($3)); } + | CCAdditiveExpression '-' CCMultiplicativeExpression + { $$ = ccval_num(get_ccnum($1) - get_ccnum($3)); } + +CCMultiplicativeExpression + : CCUnaryExpression { $$ = $1; } + | CCMultiplicativeExpression '*' CCUnaryExpression + { $$ = ccval_num(get_ccnum($1) * get_ccnum($3)); } + | CCMultiplicativeExpression '/' CCUnaryExpression + { $$ = ccval_num(get_ccnum($1) / get_ccnum($3)); } + | CCMultiplicativeExpression '%' CCUnaryExpression + { FIXME("'%%' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; } + +%% + +BOOL parse_cc_expr(parser_ctx_t *ctx) +{ + ctx->hres = S_OK; + cc_parser_parse(ctx); + return SUCCEEDED(ctx->hres); +} diff --git a/reactos/dll/win32/jscript/date.c b/reactos/dll/win32/jscript/date.c index d794a991990..5513deff791 100644 --- a/reactos/dll/win32/jscript/date.c +++ b/reactos/dll/win32/jscript/date.c @@ -83,9 +83,14 @@ static const WCHAR setYearW[] = {'s','e','t','Y','e','a','r',0}; static const WCHAR UTCW[] = {'U','T','C',0}; static const WCHAR parseW[] = {'p','a','r','s','e',0}; +static inline DateInstance *date_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, DateInstance, dispex); +} + static inline DateInstance *date_this(vdisp_t *jsthis) { - return is_vclass(jsthis, JSCLASS_DATE) ? (DateInstance*)jsthis->u.jsdisp : NULL; + return is_vclass(jsthis, JSCLASS_DATE) ? date_from_jsdisp(jsthis->u.jsdisp) : NULL; } /*ECMA-262 3rd Edition 15.9.1.2 */ @@ -1906,20 +1911,11 @@ static HRESULT Date_setYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi return S_OK; } -static HRESULT Date_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Date_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - switch(flags) { - case INVOKE_FUNC: - return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL); - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; - } - - return S_OK; + return dateobj_to_string(date_from_jsdisp(jsthis), r); } static const builtin_prop_t Date_props[] = { @@ -1971,7 +1967,7 @@ static const builtin_prop_t Date_props[] = { static const builtin_info_t Date_info = { JSCLASS_DATE, - {NULL, Date_value, 0}, + {NULL, NULL,0, Date_get_value}, sizeof(Date_props)/sizeof(*Date_props), Date_props, NULL, @@ -1980,7 +1976,7 @@ static const builtin_info_t Date_info = { static const builtin_info_t DateInst_info = { JSCLASS_DATE, - {NULL, Date_value, 0}, + {NULL, NULL,0, Date_get_value}, 0, NULL, NULL, NULL @@ -2495,7 +2491,7 @@ static const builtin_prop_t DateConstr_props[] = { static const builtin_info_t DateConstr_info = { JSCLASS_FUNCTION, - {NULL, Function_value, 0}, + DEFAULT_FUNCTION_VALUE, sizeof(DateConstr_props)/sizeof(*DateConstr_props), DateConstr_props, NULL, diff --git a/reactos/dll/win32/jscript/dispex.c b/reactos/dll/win32/jscript/dispex.c index e8416a6b7d8..20740e9d9d7 100644 --- a/reactos/dll/win32/jscript/dispex.c +++ b/reactos/dll/win32/jscript/dispex.c @@ -413,8 +413,12 @@ static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp, switch(prop->type) { case PROP_BUILTIN: - if(prop->u.p->flags & PROPF_METHOD) { + if(prop->u.p->getter) { + hres = prop->u.p->getter(This->ctx, This, r); + }else { jsdisp_t *obj; + + assert(prop->u.p->invoke != NULL); hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->name, NULL, prop->u.p->flags, NULL, &obj); if(FAILED(hres)) @@ -425,12 +429,6 @@ static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp, jsdisp_addref(obj); *r = jsval_obj(obj); - }else { - vdisp_t vthis; - - set_jsdisp(&vthis, This); - hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYGET, 0, NULL, r); - vdisp_release(&vthis); } break; case PROP_PROTREF: @@ -465,13 +463,12 @@ static HRESULT prop_put(jsdisp_t *This, dispex_prop_t *prop, jsval_t val, IServi switch(prop->type) { case PROP_BUILTIN: - if(!(prop->flags & PROPF_METHOD)) { - vdisp_t vthis; + if(prop->u.p->setter) + return prop->u.p->setter(This->ctx, This, val); - set_jsdisp(&vthis, This); - hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYPUT, 1, &val, NULL); - vdisp_release(&vthis); - return hres; + if(prop->u.p->setter) { + FIXME("getter with no setter\n"); + return E_FAIL; } /* fall through */ case PROP_PROTREF: @@ -503,6 +500,12 @@ static HRESULT prop_put(jsdisp_t *This, dispex_prop_t *prop, jsval_t val, IServi return S_OK; } +HRESULT builtin_set_const(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + TRACE("%p %s\n", jsthis, debugstr_jsval(value)); + return S_OK; +} + static HRESULT fill_protrefs(jsdisp_t *This) { dispex_prop_t *iter, *prop; @@ -900,7 +903,7 @@ HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *b jsdisp_addref(prototype); dispex->prop_cnt = 1; - if(builtin_info->value_prop.invoke) { + if(builtin_info->value_prop.invoke || builtin_info->value_prop.getter) { dispex->props[0].type = PROP_BUILTIN; dispex->props[0].u.p = &builtin_info->value_prop; }else { @@ -1050,11 +1053,18 @@ HRESULT jsdisp_call_value(jsdisp_t *jsfunc, IDispatch *jsthis, WORD flags, unsig { HRESULT hres; + assert(!(flags & ~(DISPATCH_METHOD|DISPATCH_CONSTRUCT))); + if(is_class(jsfunc, JSCLASS_FUNCTION)) { hres = Function_invoke(jsfunc, jsthis, flags, argc, argv, r); }else { vdisp_t vdisp; + if(!jsfunc->builtin_info->value_prop.invoke) { + WARN("Not a function\n"); + return throw_type_error(jsfunc->ctx, JS_E_FUNCTION_EXPECTED, NULL); + } + set_disp(&vdisp, jsthis); hres = jsfunc->builtin_info->value_prop.invoke(jsfunc->ctx, &vdisp, flags, argc, argv, r); vdisp_release(&vdisp); @@ -1183,13 +1193,10 @@ HRESULT disp_call_value(script_ctx_t *ctx, IDispatch *disp, IDispatch *jsthis, W unsigned i; HRESULT hres; + assert(!(flags & ~(DISPATCH_METHOD|DISPATCH_CONSTRUCT))); + jsdisp = iface_to_jsdisp((IUnknown*)disp); if(jsdisp) { - if(flags & DISPATCH_PROPERTYPUT) { - FIXME("disp_call(propput) on builtin object\n"); - return E_FAIL; - } - hres = jsdisp_call_value(jsdisp, jsthis, flags, argc, argv, r); jsdisp_release(jsdisp); return hres; @@ -1339,6 +1346,7 @@ HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val) jsdisp_release(jsdisp); }else { DISPID dispid = DISPID_PROPERTYPUT; + DWORD flags = DISPATCH_PROPERTYPUT; VARIANT var; DISPPARAMS dp = {&var, &dispid, 1, 1}; IDispatchEx *dispex; @@ -1347,17 +1355,20 @@ HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val) if(FAILED(hres)) return hres; + if(V_VT(&var) == VT_DISPATCH) + flags |= DISPATCH_PROPERTYPUTREF; + clear_ei(ctx); hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { - hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ctx->ei.ei, + hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, &dp, NULL, &ctx->ei.ei, &ctx->jscaller->IServiceProvider_iface); IDispatchEx_Release(dispex); }else { ULONG err = 0; TRACE("using IDispatch\n"); - hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ctx->ei.ei, &err); + hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, &dp, NULL, &ctx->ei.ei, &err); } VariantClear(&var); diff --git a/reactos/dll/win32/jscript/engine.c b/reactos/dll/win32/jscript/engine.c index 6ee34da436c..34a7eaedd3c 100644 --- a/reactos/dll/win32/jscript/engine.c +++ b/reactos/dll/win32/jscript/engine.c @@ -35,6 +35,21 @@ struct _except_frame_t { except_frame_t *next; }; +typedef struct { + enum { + EXPRVAL_JSVAL, + EXPRVAL_IDREF, + EXPRVAL_INVALID + } type; + union { + jsval_t val; + struct { + IDispatch *disp; + DISPID id; + } idref; + } u; +} exprval_t; + static HRESULT stack_push(exec_ctx_t *ctx, jsval_t v) { if(!ctx->stack_size) { @@ -372,11 +387,6 @@ static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, const WCHAR *name return hres; } -static inline BOOL var_is_null(const VARIANT *v) -{ - return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v)); -} - static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret) { IObjectIdentity *identity; diff --git a/reactos/dll/win32/jscript/engine.h b/reactos/dll/win32/jscript/engine.h index cb135bdca00..a32a197ee7c 100644 --- a/reactos/dll/win32/jscript/engine.h +++ b/reactos/dll/win32/jscript/engine.h @@ -18,26 +18,6 @@ #pragma once -typedef struct _source_elements_t source_elements_t; -typedef struct _expression_t expression_t; -typedef struct _statement_t statement_t; - -typedef struct { - const WCHAR *begin; - const WCHAR *end; - const WCHAR *ptr; - - script_ctx_t *script; - source_elements_t *source; - BOOL nl; - BOOL implicit_nl_semicolon; - BOOL is_html; - BOOL lexer_error; - HRESULT hres; - - heap_pool_t heap; -} parser_ctx_t; - #define OP_LIST \ X(add, 1, 0,0) \ X(and, 1, 0,0) \ @@ -193,21 +173,6 @@ static inline void bytecode_addref(bytecode_t *code) code->ref++; } -HRESULT script_parse(script_ctx_t*,const WCHAR*,const WCHAR*,BOOL,parser_ctx_t**) DECLSPEC_HIDDEN; -void parser_release(parser_ctx_t*) DECLSPEC_HIDDEN; - -int parser_lex(void*,parser_ctx_t*) DECLSPEC_HIDDEN; - -static inline void *parser_alloc(parser_ctx_t *ctx, DWORD size) -{ - return heap_pool_alloc(&ctx->heap, size); -} - -static inline void *parser_alloc_tmp(parser_ctx_t *ctx, DWORD size) -{ - return heap_pool_alloc(&ctx->script->tmp_heap, size); -} - typedef struct _scope_chain_t { LONG ref; jsdisp_t *jsobj; @@ -224,11 +189,12 @@ static inline void scope_addref(scope_chain_t *scope) } typedef struct _except_frame_t except_frame_t; +struct _parser_ctx_t; struct _exec_ctx_t { LONG ref; - parser_ctx_t *parser; + struct _parser_ctx_t *parser; bytecode_t *code; script_ctx_t *script; scope_chain_t *scope_chain; @@ -255,320 +221,3 @@ void exec_release(exec_ctx_t*) DECLSPEC_HIDDEN; HRESULT create_exec_ctx(script_ctx_t*,IDispatch*,jsdisp_t*,scope_chain_t*,BOOL,exec_ctx_t**) DECLSPEC_HIDDEN; HRESULT exec_source(exec_ctx_t*,bytecode_t*,function_code_t*,BOOL,jsval_t*) DECLSPEC_HIDDEN; HRESULT create_source_function(script_ctx_t*,bytecode_t*,function_code_t*,scope_chain_t*,jsdisp_t**) DECLSPEC_HIDDEN; - -typedef enum { - LT_DOUBLE, - LT_STRING, - LT_BOOL, - LT_NULL, - LT_REGEXP -}literal_type_t; - -typedef struct { - literal_type_t type; - union { - double dval; - const WCHAR *wstr; - BOOL bval; - struct { - const WCHAR *str; - DWORD str_len; - DWORD flags; - } regexp; - } u; -} literal_t; - -literal_t *parse_regexp(parser_ctx_t*) DECLSPEC_HIDDEN; -literal_t *new_boolean_literal(parser_ctx_t*,BOOL) DECLSPEC_HIDDEN; - -typedef struct _variable_declaration_t { - const WCHAR *identifier; - expression_t *expr; - - struct _variable_declaration_t *next; - struct _variable_declaration_t *global_next; /* for compiler */ -} variable_declaration_t; - -typedef enum { - STAT_BLOCK, - STAT_BREAK, - STAT_CONTINUE, - STAT_EMPTY, - STAT_EXPR, - STAT_FOR, - STAT_FORIN, - STAT_IF, - STAT_LABEL, - STAT_RETURN, - STAT_SWITCH, - STAT_THROW, - STAT_TRY, - STAT_VAR, - STAT_WHILE, - STAT_WITH -} statement_type_t; - -struct _statement_t { - statement_type_t type; - statement_t *next; -}; - -typedef struct { - statement_t stat; - statement_t *stat_list; -} block_statement_t; - -typedef struct { - statement_t stat; - variable_declaration_t *variable_list; -} var_statement_t; - -typedef struct { - statement_t stat; - expression_t *expr; -} expression_statement_t; - -typedef struct { - statement_t stat; - expression_t *expr; - statement_t *if_stat; - statement_t *else_stat; -} if_statement_t; - -typedef struct { - statement_t stat; - BOOL do_while; - expression_t *expr; - statement_t *statement; -} while_statement_t; - -typedef struct { - statement_t stat; - variable_declaration_t *variable_list; - expression_t *begin_expr; - expression_t *expr; - expression_t *end_expr; - statement_t *statement; -} for_statement_t; - -typedef struct { - statement_t stat; - variable_declaration_t *variable; - expression_t *expr; - expression_t *in_expr; - statement_t *statement; -} forin_statement_t; - -typedef struct { - statement_t stat; - const WCHAR *identifier; -} branch_statement_t; - -typedef struct { - statement_t stat; - expression_t *expr; - statement_t *statement; -} with_statement_t; - -typedef struct { - statement_t stat; - const WCHAR *identifier; - statement_t *statement; -} labelled_statement_t; - -typedef struct _case_clausule_t { - expression_t *expr; - statement_t *stat; - - struct _case_clausule_t *next; -} case_clausule_t; - -typedef struct { - statement_t stat; - expression_t *expr; - case_clausule_t *case_list; -} switch_statement_t; - -typedef struct { - const WCHAR *identifier; - statement_t *statement; -} catch_block_t; - -typedef struct { - statement_t stat; - statement_t *try_statement; - catch_block_t *catch_block; - statement_t *finally_statement; -} try_statement_t; - -typedef struct { - enum { - EXPRVAL_JSVAL, - EXPRVAL_IDREF, - EXPRVAL_INVALID - } type; - union { - jsval_t val; - struct { - IDispatch *disp; - DISPID id; - } idref; - } u; -} exprval_t; - -typedef enum { - EXPR_COMMA, - EXPR_OR, - EXPR_AND, - EXPR_BOR, - EXPR_BXOR, - EXPR_BAND, - EXPR_INSTANCEOF, - EXPR_IN, - EXPR_ADD, - EXPR_SUB, - EXPR_MUL, - EXPR_DIV, - EXPR_MOD, - EXPR_DELETE, - EXPR_VOID, - EXPR_TYPEOF, - EXPR_MINUS, - EXPR_PLUS, - EXPR_POSTINC, - EXPR_POSTDEC, - EXPR_PREINC, - EXPR_PREDEC, - EXPR_EQ, - EXPR_EQEQ, - EXPR_NOTEQ, - EXPR_NOTEQEQ, - EXPR_LESS, - EXPR_LESSEQ, - EXPR_GREATER, - EXPR_GREATEREQ, - EXPR_BITNEG, - EXPR_LOGNEG, - EXPR_LSHIFT, - EXPR_RSHIFT, - EXPR_RRSHIFT, - EXPR_ASSIGN, - EXPR_ASSIGNLSHIFT, - EXPR_ASSIGNRSHIFT, - EXPR_ASSIGNRRSHIFT, - EXPR_ASSIGNADD, - EXPR_ASSIGNSUB, - EXPR_ASSIGNMUL, - EXPR_ASSIGNDIV, - EXPR_ASSIGNMOD, - EXPR_ASSIGNAND, - EXPR_ASSIGNOR, - EXPR_ASSIGNXOR, - EXPR_COND, - EXPR_ARRAY, - EXPR_MEMBER, - EXPR_NEW, - EXPR_CALL, - EXPR_THIS, - EXPR_FUNC, - EXPR_IDENT, - EXPR_ARRAYLIT, - EXPR_PROPVAL, - EXPR_LITERAL -} expression_type_t; - -struct _expression_t { - expression_type_t type; -}; - -typedef struct _parameter_t { - const WCHAR *identifier; - struct _parameter_t *next; -} parameter_t; - -struct _source_elements_t { - statement_t *statement; - statement_t *statement_tail; -}; - -typedef struct _function_expression_t { - expression_t expr; - const WCHAR *identifier; - parameter_t *parameter_list; - source_elements_t *source_elements; - const WCHAR *src_str; - DWORD src_len; - - struct _function_expression_t *next; /* for compiler */ -} function_expression_t; - -typedef struct { - expression_t expr; - expression_t *expression1; - expression_t *expression2; -} binary_expression_t; - -typedef struct { - expression_t expr; - expression_t *expression; -} unary_expression_t; - -typedef struct { - expression_t expr; - expression_t *expression; - expression_t *true_expression; - expression_t *false_expression; -} conditional_expression_t; - -typedef struct { - expression_t expr; - expression_t *expression; - const WCHAR *identifier; -} member_expression_t; - -typedef struct _argument_t { - expression_t *expr; - - struct _argument_t *next; -} argument_t; - -typedef struct { - expression_t expr; - expression_t *expression; - argument_t *argument_list; -} call_expression_t; - -typedef struct { - expression_t expr; - const WCHAR *identifier; -} identifier_expression_t; - -typedef struct { - expression_t expr; - literal_t *literal; -} literal_expression_t; - -typedef struct _array_element_t { - int elision; - expression_t *expr; - - struct _array_element_t *next; -} array_element_t; - -typedef struct { - expression_t expr; - array_element_t *element_list; - int length; -} array_literal_expression_t; - -typedef struct _prop_val_t { - literal_t *name; - expression_t *value; - - struct _prop_val_t *next; -} prop_val_t; - -typedef struct { - expression_t expr; - prop_val_t *property_list; -} property_value_expression_t; diff --git a/reactos/dll/win32/jscript/function.c b/reactos/dll/win32/jscript/function.c index b397957cb47..52481c11d8b 100644 --- a/reactos/dll/win32/jscript/function.c +++ b/reactos/dll/win32/jscript/function.c @@ -36,9 +36,14 @@ typedef struct { jsdisp_t *var_obj; } ArgumentsInstance; +static inline FunctionInstance *function_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, FunctionInstance, dispex); +} + static inline FunctionInstance *function_from_vdisp(vdisp_t *vdisp) { - return (FunctionInstance*)vdisp->u.jsdisp; + return function_from_jsdisp(vdisp->u.jsdisp); } static inline FunctionInstance *function_this(vdisp_t *jsthis) @@ -198,6 +203,11 @@ static HRESULT invoke_source(script_ctx_t *ctx, FunctionInstance *function, IDis scope_chain_t *scope; HRESULT hres; + if(ctx->state == SCRIPTSTATE_UNINITIALIZED || ctx->state == SCRIPTSTATE_CLOSED) { + WARN("Script engine state does not allow running code.\n"); + return E_UNEXPECTED; + } + if(!function->func_code) { FIXME("no source\n"); return E_FAIL; @@ -350,25 +360,20 @@ HRESULT Function_invoke(jsdisp_t *func_this, IDispatch *jsthis, WORD flags, unsi return invoke_source(function->dispex.ctx, function, jsthis, argc, argv, r); } -static HRESULT Function_length(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Function_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { - FunctionInstance *This = function_from_vdisp(jsthis); - - TRACE("%p %d\n", This, This->length); - - switch(flags) { - case DISPATCH_PROPERTYGET: - *r = jsval_number(This->length); - break; - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; - } + TRACE("%p\n", jsthis); + *r = jsval_number(function_from_jsdisp(jsthis)->length); return S_OK; } +static HRESULT Function_set_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + FIXME("\n"); + return E_NOTIMPL; +} + static HRESULT Function_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { @@ -525,56 +530,33 @@ HRESULT Function_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned function = (FunctionInstance*)jsthis->u.jsdisp; - switch(flags) { - case DISPATCH_METHOD: - assert(function->value_proc != NULL); - return invoke_value_proc(ctx, function, NULL, flags, argc, argv, r); - - case DISPATCH_PROPERTYGET: { - HRESULT hres; - jsstr_t *str; - - hres = function_to_string(function, &str); - if(FAILED(hres)) - return hres; - - *r = jsval_string(str); - break; - } - - case DISPATCH_CONSTRUCT: - assert(function->value_proc != NULL); - return invoke_value_proc(ctx, function, NULL, flags, argc, argv, r); - - default: - FIXME("not implemented flags %x\n", flags); - return E_NOTIMPL; - } - - return S_OK; + assert(function->value_proc != NULL); + return invoke_value_proc(ctx, function, NULL, flags, argc, argv, r); } -static HRESULT Function_arguments(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +HRESULT Function_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { - FunctionInstance *function = (FunctionInstance*)jsthis->u.jsdisp; - HRESULT hres = S_OK; + jsstr_t *str; + HRESULT hres; TRACE("\n"); - switch(flags) { - case DISPATCH_PROPERTYGET: { - *r = function->arguments ? jsval_obj(jsdisp_addref(function->arguments)) : jsval_null(); - break; - } - case DISPATCH_PROPERTYPUT: - break; - default: - FIXME("unimplemented flags %x\n", flags); - hres = E_NOTIMPL; - } + hres = function_to_string(function_from_jsdisp(jsthis), &str); + if(FAILED(hres)) + return hres; - return hres; + *r = jsval_string(str); + return S_OK; +} + +static HRESULT Function_get_arguments(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) +{ + FunctionInstance *function = function_from_jsdisp(jsthis); + + TRACE("\n"); + + *r = function->arguments ? jsval_obj(jsdisp_addref(function->arguments)) : jsval_null(); + return S_OK; } static void Function_destructor(jsdisp_t *dispex) @@ -590,15 +572,15 @@ static void Function_destructor(jsdisp_t *dispex) static const builtin_prop_t Function_props[] = { {applyW, Function_apply, PROPF_METHOD|2}, - {argumentsW, Function_arguments, 0}, + {argumentsW, NULL, 0, Function_get_arguments, builtin_set_const}, {callW, Function_call, PROPF_METHOD|1}, - {lengthW, Function_length, 0}, + {lengthW, NULL, 0, Function_get_length, Function_set_length}, {toStringW, Function_toString, PROPF_METHOD} }; static const builtin_info_t Function_info = { JSCLASS_FUNCTION, - {NULL, Function_value, 0}, + DEFAULT_FUNCTION_VALUE, sizeof(Function_props)/sizeof(*Function_props), Function_props, Function_destructor, @@ -606,13 +588,13 @@ static const builtin_info_t Function_info = { }; static const builtin_prop_t FunctionInst_props[] = { - {argumentsW, Function_arguments, 0}, - {lengthW, Function_length, 0} + {argumentsW, NULL, 0, Function_get_arguments, builtin_set_const}, + {lengthW, NULL, 0, Function_get_length, Function_set_length} }; static const builtin_info_t FunctionInst_info = { JSCLASS_FUNCTION, - {NULL, Function_value, 0}, + DEFAULT_FUNCTION_VALUE, sizeof(FunctionInst_props)/sizeof(*FunctionInst_props), FunctionInst_props, Function_destructor, diff --git a/reactos/dll/win32/jscript/global.c b/reactos/dll/win32/jscript/global.c index 2085aca760f..f7caf1117e2 100644 --- a/reactos/dll/win32/jscript/global.c +++ b/reactos/dll/win32/jscript/global.c @@ -102,159 +102,6 @@ static WCHAR int_to_char(int i) return 'A'+i-10; } -static HRESULT constructor_call(jsdisp_t *constr, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) -{ - if(flags != DISPATCH_PROPERTYGET) - return jsdisp_call_value(constr, NULL, flags, argc, argv, r); - - *r = jsval_obj(jsdisp_addref(constr)); - return S_OK; -} - -static HRESULT JSGlobal_Array(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->array_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Boolean(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->bool_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Date(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->date_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Error(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_EvalError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->eval_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_RangeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->range_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_RegExpError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->regexp_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_ReferenceError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->reference_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_SyntaxError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->syntax_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_TypeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->type_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_URIError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->uri_error_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Function(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->function_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Number(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->number_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_Object(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->object_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_String(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->string_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_RegExp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->regexp_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_ActiveXObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->activex_constr, flags, argc, argv, r); -} - -static HRESULT JSGlobal_VBArray(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) -{ - TRACE("\n"); - - return constructor_call(ctx->vbarray_constr, flags, argc, argv, r); -} - static HRESULT JSGlobal_Enumerator(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { @@ -1077,31 +924,13 @@ static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, W } static const builtin_prop_t JSGlobal_props[] = { - {ActiveXObjectW, JSGlobal_ActiveXObject, PROPF_CONSTR|1}, - {ArrayW, JSGlobal_Array, PROPF_CONSTR|1}, - {BooleanW, JSGlobal_Boolean, PROPF_CONSTR|1}, {CollectGarbageW, JSGlobal_CollectGarbage, PROPF_METHOD}, - {DateW, JSGlobal_Date, PROPF_CONSTR|7}, {EnumeratorW, JSGlobal_Enumerator, PROPF_METHOD|7}, - {ErrorW, JSGlobal_Error, PROPF_CONSTR|1}, - {EvalErrorW, JSGlobal_EvalError, PROPF_CONSTR|1}, - {FunctionW, JSGlobal_Function, PROPF_CONSTR|1}, {_GetObjectW, JSGlobal_GetObject, PROPF_METHOD|2}, - {NumberW, JSGlobal_Number, PROPF_CONSTR|1}, - {ObjectW, JSGlobal_Object, PROPF_CONSTR|1}, - {RangeErrorW, JSGlobal_RangeError, PROPF_CONSTR|1}, - {ReferenceErrorW, JSGlobal_ReferenceError, PROPF_CONSTR|1}, - {RegExpW, JSGlobal_RegExp, PROPF_CONSTR|2}, - {RegExpErrorW, JSGlobal_RegExpError, PROPF_CONSTR|1}, {ScriptEngineW, JSGlobal_ScriptEngine, PROPF_METHOD}, {ScriptEngineBuildVersionW, JSGlobal_ScriptEngineBuildVersion, PROPF_METHOD}, {ScriptEngineMajorVersionW, JSGlobal_ScriptEngineMajorVersion, PROPF_METHOD}, {ScriptEngineMinorVersionW, JSGlobal_ScriptEngineMinorVersion, PROPF_METHOD}, - {StringW, JSGlobal_String, PROPF_CONSTR|1}, - {SyntaxErrorW, JSGlobal_SyntaxError, PROPF_CONSTR|1}, - {TypeErrorW, JSGlobal_TypeError, PROPF_CONSTR|1}, - {URIErrorW, JSGlobal_URIError, PROPF_CONSTR|1}, - {VBArrayW, JSGlobal_VBArray, PROPF_CONSTR|1}, {decodeURIW, JSGlobal_decodeURI, PROPF_METHOD|1}, {decodeURIComponentW, JSGlobal_decodeURIComponent, PROPF_METHOD|1}, {encodeURIW, JSGlobal_encodeURI, PROPF_METHOD|1}, @@ -1132,11 +961,15 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype) if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, FunctionW, jsval_obj(ctx->function_constr)); + if(FAILED(hres)) + return hres; + hres = create_object_constr(ctx, object_prototype, &ctx->object_constr); if(FAILED(hres)) return hres; - hres = create_activex_constr(ctx, &ctx->activex_constr); + hres = jsdisp_propput_dontenum(ctx->global, ObjectW, jsval_obj(ctx->object_constr)); if(FAILED(hres)) return hres; @@ -1144,45 +977,109 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype) if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, ArrayW, jsval_obj(ctx->array_constr)); + if(FAILED(hres)) + return hres; + hres = create_bool_constr(ctx, object_prototype, &ctx->bool_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, BooleanW, jsval_obj(ctx->bool_constr)); + if(FAILED(hres)) + return hres; + hres = create_date_constr(ctx, object_prototype, &ctx->date_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, DateW, jsval_obj(ctx->date_constr)); + if(FAILED(hres)) + return hres; + hres = init_error_constr(ctx, object_prototype); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, ErrorW, jsval_obj(ctx->error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, EvalErrorW, jsval_obj(ctx->eval_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, RangeErrorW, jsval_obj(ctx->range_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, ReferenceErrorW, jsval_obj(ctx->reference_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, RegExpErrorW, jsval_obj(ctx->regexp_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, SyntaxErrorW, jsval_obj(ctx->syntax_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, TypeErrorW, jsval_obj(ctx->type_error_constr)); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, URIErrorW, jsval_obj(ctx->uri_error_constr)); + if(FAILED(hres)) + return hres; + hres = create_number_constr(ctx, object_prototype, &ctx->number_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, NumberW, jsval_obj(ctx->number_constr)); + if(FAILED(hres)) + return hres; + hres = create_regexp_constr(ctx, object_prototype, &ctx->regexp_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, RegExpW, jsval_obj(ctx->regexp_constr)); + if(FAILED(hres)) + return hres; + hres = create_string_constr(ctx, object_prototype, &ctx->string_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, StringW, jsval_obj(ctx->string_constr)); + if(FAILED(hres)) + return hres; + hres = create_vbarray_constr(ctx, object_prototype, &ctx->vbarray_constr); if(FAILED(hres)) return hres; + hres = jsdisp_propput_dontenum(ctx->global, VBArrayW, jsval_obj(ctx->vbarray_constr)); + if(FAILED(hres)) + return hres; + return S_OK; } HRESULT init_global(script_ctx_t *ctx) { - jsdisp_t *math, *object_prototype; + jsdisp_t *math, *object_prototype, *constr; HRESULT hres; if(ctx->global) return S_OK; + hres = create_dispex(ctx, &JSGlobal_info, NULL, &ctx->global); + if(FAILED(hres)) + return hres; + hres = create_object_prototype(ctx, &object_prototype); if(FAILED(hres)) return hres; @@ -1192,10 +1089,6 @@ HRESULT init_global(script_ctx_t *ctx) if(FAILED(hres)) return hres; - hres = create_dispex(ctx, &JSGlobal_info, NULL, &ctx->global); - if(FAILED(hres)) - return hres; - hres = create_math(ctx, &math); if(FAILED(hres)) return hres; @@ -1205,6 +1098,15 @@ HRESULT init_global(script_ctx_t *ctx) if(FAILED(hres)) return hres; + hres = create_activex_constr(ctx, &constr); + if(FAILED(hres)) + return hres; + + hres = jsdisp_propput_dontenum(ctx->global, ActiveXObjectW, jsval_obj(constr)); + jsdisp_release(constr); + if(FAILED(hres)) + return hres; + hres = jsdisp_propput_dontenum(ctx->global, undefinedW, jsval_undefined()); if(FAILED(hres)) return hres; diff --git a/reactos/dll/win32/jscript/jscript.h b/reactos/dll/win32/jscript/jscript.h index 3d1d5b27aef..8c2b561e9b5 100644 --- a/reactos/dll/win32/jscript/jscript.h +++ b/reactos/dll/win32/jscript/jscript.h @@ -201,11 +201,17 @@ static inline jsdisp_t *get_jsdisp(vdisp_t *vdisp) } typedef HRESULT (*builtin_invoke_t)(script_ctx_t*,vdisp_t*,WORD,unsigned,jsval_t*,jsval_t*); +typedef HRESULT (*builtin_getter_t)(script_ctx_t*,jsdisp_t*,jsval_t*); +typedef HRESULT (*builtin_setter_t)(script_ctx_t*,jsdisp_t*,jsval_t); + +HRESULT builtin_set_const(script_ctx_t*,jsdisp_t*,jsval_t) DECLSPEC_HIDDEN; typedef struct { const WCHAR *name; builtin_invoke_t invoke; DWORD flags; + builtin_getter_t getter; + builtin_setter_t setter; } builtin_prop_t; typedef struct { @@ -301,9 +307,12 @@ HRESULT create_builtin_function(script_ctx_t*,builtin_invoke_t,const WCHAR*,cons jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN; HRESULT create_builtin_constructor(script_ctx_t*,builtin_invoke_t,const WCHAR*,const builtin_info_t*,DWORD, jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN; -HRESULT Function_value(script_ctx_t*,vdisp_t*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN; HRESULT Function_invoke(jsdisp_t*,IDispatch*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN; +HRESULT Function_value(script_ctx_t*,vdisp_t*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN; +HRESULT Function_get_value(script_ctx_t*,jsdisp_t*,jsval_t*) DECLSPEC_HIDDEN; +#define DEFAULT_FUNCTION_VALUE {NULL, Function_value,0, Function_get_value} + HRESULT throw_eval_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN; HRESULT throw_generic_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN; HRESULT throw_range_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN; @@ -409,7 +418,6 @@ struct _script_ctx_t { jsdisp_t *global; jsdisp_t *function_constr; - jsdisp_t *activex_constr; jsdisp_t *array_constr; jsdisp_t *bool_constr; jsdisp_t *date_constr; @@ -508,6 +516,8 @@ static inline DWORD make_grfdex(script_ctx_t *ctx, DWORD flags) #define JS_E_MISSING_SEMICOLON MAKE_JSERROR(IDS_SEMICOLON) #define JS_E_MISSING_LBRACKET MAKE_JSERROR(IDS_LBRACKET) #define JS_E_MISSING_RBRACKET MAKE_JSERROR(IDS_RBRACKET) +#define JS_E_EXPECTED_IDENTIFIER MAKE_JSERROR(IDS_EXPECTED_IDENTIFIER) +#define JS_E_EXPECTED_ASSIGN MAKE_JSERROR(IDS_EXPECTED_ASSIGN) #define JS_E_INVALID_CHAR MAKE_JSERROR(IDS_INVALID_CHAR) #define JS_E_UNTERMINATED_STRING MAKE_JSERROR(IDS_UNTERMINATED_STR) #define JS_E_MISPLACED_RETURN MAKE_JSERROR(IDS_MISPLACED_RETURN) @@ -515,7 +525,9 @@ static inline DWORD make_grfdex(script_ctx_t *ctx, DWORD flags) #define JS_E_INVALID_CONTINUE MAKE_JSERROR(IDS_INVALID_CONTINUE) #define JS_E_LABEL_REDEFINED MAKE_JSERROR(IDS_LABEL_REDEFINED) #define JS_E_LABEL_NOT_FOUND MAKE_JSERROR(IDS_LABEL_NOT_FOUND) +#define JS_E_EXPECTED_CCEND MAKE_JSERROR(IDS_EXPECTED_CCEND) #define JS_E_DISABLED_CC MAKE_JSERROR(IDS_DISABLED_CC) +#define JS_E_EXPECTED_AT MAKE_JSERROR(IDS_EXPECTED_AT) #define JS_E_FUNCTION_EXPECTED MAKE_JSERROR(IDS_NOT_FUNC) #define JS_E_DATE_EXPECTED MAKE_JSERROR(IDS_NOT_DATE) #define JS_E_NUMBER_EXPECTED MAKE_JSERROR(IDS_NOT_NUM) @@ -556,6 +568,7 @@ static inline void unlock_module(void) } #include "engine.h" +#include "parser.h" #include "regexp.h" #endif /* _WINE_JSCRIPT_H */ diff --git a/reactos/dll/win32/jscript/jsregexp.c b/reactos/dll/win32/jscript/jsregexp.c index 49da0e7c97c..8920c11cdc7 100644 --- a/reactos/dll/win32/jscript/jsregexp.c +++ b/reactos/dll/win32/jscript/jsregexp.c @@ -51,11 +51,14 @@ static const WCHAR idx7W[] = {'$','7',0}; static const WCHAR idx8W[] = {'$','8',0}; static const WCHAR idx9W[] = {'$','9',0}; -static const WCHAR emptyW[] = {0}; +static inline RegExpInstance *regexp_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, RegExpInstance, dispex); +} static inline RegExpInstance *regexp_from_vdisp(vdisp_t *vdisp) { - return (RegExpInstance*)vdisp->u.jsdisp; + return regexp_from_jsdisp(vdisp->u.jsdisp); } static void set_last_index(RegExpInstance *This, DWORD last_index) @@ -238,41 +241,51 @@ static HRESULT regexp_match(script_ctx_t *ctx, jsdisp_t *dispex, jsstr_t *jsstr, return S_OK; } -static HRESULT RegExp_source(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT RegExp_get_source(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - switch(flags) { - case DISPATCH_PROPERTYGET: { - RegExpInstance *This = regexp_from_vdisp(jsthis); - *r = jsval_string(jsstr_addref(This->str)); - break; - } - default: - FIXME("Unimplemented flags %x\n", flags); - return E_NOTIMPL; - } - + *r = jsval_string(jsstr_addref(regexp_from_jsdisp(jsthis)->str)); return S_OK; } -static HRESULT RegExp_global(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT RegExp_set_source(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) { FIXME("\n"); return E_NOTIMPL; } -static HRESULT RegExp_ignoreCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT RegExp_get_global(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { FIXME("\n"); return E_NOTIMPL; } -static HRESULT RegExp_multiline(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT RegExp_set_global(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + FIXME("\n"); + return E_NOTIMPL; +} + +static HRESULT RegExp_get_ignoreCase(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) +{ + FIXME("\n"); + return E_NOTIMPL; +} + +static HRESULT RegExp_set_ignoreCase(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + FIXME("\n"); + return E_NOTIMPL; +} + +static HRESULT RegExp_get_multiline(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) +{ + FIXME("\n"); + return E_NOTIMPL; +} + +static HRESULT RegExp_set_multiline(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) { FIXME("\n"); return E_NOTIMPL; @@ -293,33 +306,27 @@ static INT index_from_val(script_ctx_t *ctx, jsval_t v) return is_int32(n) ? n : 0; } -static HRESULT RegExp_lastIndex(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT RegExp_get_lastIndex(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + RegExpInstance *regexp = regexp_from_jsdisp(jsthis); + TRACE("\n"); - switch(flags) { - case DISPATCH_PROPERTYGET: { - RegExpInstance *regexp = regexp_from_vdisp(jsthis); + return jsval_copy(regexp->last_index_val, r); +} - return jsval_copy(regexp->last_index_val, r); - } - case DISPATCH_PROPERTYPUT: { - RegExpInstance *regexp = regexp_from_vdisp(jsthis); - HRESULT hres; +static HRESULT RegExp_set_lastIndex(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + RegExpInstance *regexp = regexp_from_jsdisp(jsthis); + HRESULT hres; - hres = jsval_copy(argv[0], ®exp->last_index_val); - if(FAILED(hres)) - return hres; + TRACE("\n"); - regexp->last_index = index_from_val(ctx, argv[0]); - break; - } - default: - FIXME("unimplemented flags: %x\n", flags); - return E_NOTIMPL; - } + hres = jsval_copy(value, ®exp->last_index_val); + if(FAILED(hres)) + return hres; + regexp->last_index = index_from_val(ctx, value); return S_OK; } @@ -586,11 +593,11 @@ static void RegExp_destructor(jsdisp_t *dispex) static const builtin_prop_t RegExp_props[] = { {execW, RegExp_exec, PROPF_METHOD|1}, - {globalW, RegExp_global, 0}, - {ignoreCaseW, RegExp_ignoreCase, 0}, - {lastIndexW, RegExp_lastIndex, 0}, - {multilineW, RegExp_multiline, 0}, - {sourceW, RegExp_source, 0}, + {globalW, NULL,0, RegExp_get_global, RegExp_set_global}, + {ignoreCaseW, NULL,0, RegExp_get_ignoreCase, RegExp_set_ignoreCase}, + {lastIndexW, NULL,0, RegExp_get_lastIndex, RegExp_set_lastIndex}, + {multilineW, NULL,0, RegExp_get_multiline, RegExp_set_multiline}, + {sourceW, NULL,0, RegExp_get_source, RegExp_set_source}, {testW, RegExp_test, PROPF_METHOD|1}, {toStringW, RegExp_toString, PROPF_METHOD} }; @@ -605,11 +612,11 @@ static const builtin_info_t RegExp_info = { }; static const builtin_prop_t RegExpInst_props[] = { - {globalW, RegExp_global, 0}, - {ignoreCaseW, RegExp_ignoreCase, 0}, - {lastIndexW, RegExp_lastIndex, 0}, - {multilineW, RegExp_multiline, 0}, - {sourceW, RegExp_source, 0} + {globalW, NULL,0, RegExp_get_global, RegExp_set_global}, + {ignoreCaseW, NULL,0, RegExp_get_ignoreCase, RegExp_set_ignoreCase}, + {lastIndexW, NULL,0, RegExp_get_lastIndex, RegExp_set_lastIndex}, + {multilineW, NULL,0, RegExp_get_multiline, RegExp_set_multiline}, + {sourceW, NULL,0, RegExp_get_source, RegExp_set_source} }; static const builtin_info_t RegExpInst_info = { @@ -831,142 +838,98 @@ HRESULT regexp_string_match(script_ctx_t *ctx, jsdisp_t *re, jsstr_t *jsstr, jsv return hres; } -static HRESULT global_idx(script_ctx_t *ctx, DWORD flags, DWORD idx, jsval_t *r) +static HRESULT global_idx(script_ctx_t *ctx, DWORD idx, jsval_t *r) { - switch(flags) { - case DISPATCH_PROPERTYGET: { - jsstr_t *ret; + jsstr_t *ret; - ret = jsstr_substr(ctx->last_match, ctx->match_parens[idx].index, ctx->match_parens[idx].length); - if(!ret) - return E_OUTOFMEMORY; - - *r = jsval_string(ret); - break; - } - case DISPATCH_PROPERTYPUT: - break; - default: - FIXME("unsupported flags\n"); - return E_NOTIMPL; - } + ret = jsstr_substr(ctx->last_match, ctx->match_parens[idx].index, ctx->match_parens[idx].length); + if(!ret) + return E_OUTOFMEMORY; + *r = jsval_string(ret); return S_OK; } -static HRESULT RegExpConstr_idx1(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx1(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 0, r); + return global_idx(ctx, 0, r); } -static HRESULT RegExpConstr_idx2(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx2(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 1, r); + return global_idx(ctx, 1, r); } -static HRESULT RegExpConstr_idx3(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx3(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 2, r); + return global_idx(ctx, 2, r); } -static HRESULT RegExpConstr_idx4(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx4(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 3, r); + return global_idx(ctx, 3, r); } -static HRESULT RegExpConstr_idx5(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx5(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 4, r); + return global_idx(ctx, 4, r); } -static HRESULT RegExpConstr_idx6(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx6(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 5, r); + return global_idx(ctx, 5, r); } -static HRESULT RegExpConstr_idx7(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx7(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 6, r); + return global_idx(ctx, 6, r); } -static HRESULT RegExpConstr_idx8(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx8(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 7, r); + return global_idx(ctx, 7, r); } -static HRESULT RegExpConstr_idx9(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_idx9(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { TRACE("\n"); - return global_idx(ctx, flags, 8, r); + return global_idx(ctx, 8, r); } -static HRESULT RegExpConstr_leftContext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_leftContext(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + jsstr_t *ret; + TRACE("\n"); - switch(flags) { - case DISPATCH_PROPERTYGET: { - jsstr_t *ret; - - ret = jsstr_substr(ctx->last_match, 0, ctx->last_match_index); - if(!ret) - return E_OUTOFMEMORY; - - *r = jsval_string(ret); - break; - } - case DISPATCH_PROPERTYPUT: - break; - default: - FIXME("unsupported flags\n"); - return E_NOTIMPL; - } + ret = jsstr_substr(ctx->last_match, 0, ctx->last_match_index); + if(!ret) + return E_OUTOFMEMORY; + *r = jsval_string(ret); return S_OK; } -static HRESULT RegExpConstr_rightContext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, - unsigned argc, jsval_t *argv, jsval_t *r) +static HRESULT RegExpConstr_get_rightContext(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + jsstr_t *ret; + TRACE("\n"); - switch(flags) { - case DISPATCH_PROPERTYGET: { - jsstr_t *ret; - - ret = jsstr_substr(ctx->last_match, ctx->last_match_index+ctx->last_match_length, - jsstr_length(ctx->last_match) - ctx->last_match_index - ctx->last_match_length); - if(!ret) - return E_OUTOFMEMORY; - - *r = jsval_string(ret); - break; - } - case DISPATCH_PROPERTYPUT: - break; - default: - FIXME("unsupported flags\n"); - return E_NOTIMPL; - } + ret = jsstr_substr(ctx->last_match, ctx->last_match_index+ctx->last_match_length, + jsstr_length(ctx->last_match) - ctx->last_match_index - ctx->last_match_length); + if(!ret) + return E_OUTOFMEMORY; + *r = jsval_string(ret); return S_OK; } @@ -1026,22 +989,22 @@ static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags } static const builtin_prop_t RegExpConstr_props[] = { - {idx1W, RegExpConstr_idx1, 0}, - {idx2W, RegExpConstr_idx2, 0}, - {idx3W, RegExpConstr_idx3, 0}, - {idx4W, RegExpConstr_idx4, 0}, - {idx5W, RegExpConstr_idx5, 0}, - {idx6W, RegExpConstr_idx6, 0}, - {idx7W, RegExpConstr_idx7, 0}, - {idx8W, RegExpConstr_idx8, 0}, - {idx9W, RegExpConstr_idx9, 0}, - {leftContextW, RegExpConstr_leftContext, 0}, - {rightContextW, RegExpConstr_rightContext, 0} + {idx1W, NULL,0, RegExpConstr_get_idx1, builtin_set_const}, + {idx2W, NULL,0, RegExpConstr_get_idx2, builtin_set_const}, + {idx3W, NULL,0, RegExpConstr_get_idx3, builtin_set_const}, + {idx4W, NULL,0, RegExpConstr_get_idx4, builtin_set_const}, + {idx5W, NULL,0, RegExpConstr_get_idx5, builtin_set_const}, + {idx6W, NULL,0, RegExpConstr_get_idx6, builtin_set_const}, + {idx7W, NULL,0, RegExpConstr_get_idx7, builtin_set_const}, + {idx8W, NULL,0, RegExpConstr_get_idx8, builtin_set_const}, + {idx9W, NULL,0, RegExpConstr_get_idx9, builtin_set_const}, + {leftContextW, NULL,0, RegExpConstr_get_leftContext, builtin_set_const}, + {rightContextW, NULL,0, RegExpConstr_get_rightContext, builtin_set_const} }; static const builtin_info_t RegExpConstr_info = { JSCLASS_FUNCTION, - {NULL, Function_value, 0}, + DEFAULT_FUNCTION_VALUE, sizeof(RegExpConstr_props)/sizeof(*RegExpConstr_props), RegExpConstr_props, NULL, diff --git a/reactos/dll/win32/jscript/jsutils.c b/reactos/dll/win32/jscript/jsutils.c index dfdd09058d9..ca12592bd96 100644 --- a/reactos/dll/win32/jscript/jsutils.c +++ b/reactos/dll/win32/jscript/jsutils.c @@ -236,6 +236,9 @@ HRESULT jsval_copy(jsval_t v, jsval_t *r) HRESULT variant_to_jsval(VARIANT *var, jsval_t *r) { + if(V_VT(var) == (VT_VARIANT|VT_BYREF)) + var = V_VARIANTREF(var); + switch(V_VT(var)) { case VT_EMPTY: *r = jsval_undefined(); @@ -278,6 +281,9 @@ HRESULT variant_to_jsval(VARIANT *var, jsval_t *r) case VT_INT: *r = jsval_number(V_INT(var)); return S_OK; + case VT_UI4: + *r = jsval_number(V_UI4(var)); + return S_OK; case VT_UNKNOWN: if(V_UNKNOWN(var)) { IDispatch *disp; diff --git a/reactos/dll/win32/jscript/lang/jscript_Da.rc b/reactos/dll/win32/jscript/lang/jscript_Da.rc index 91a0b03eed3..966c28afcf1 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Da.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Da.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "Forventet ';'" IDS_LBRACKET "Forventet '('" IDS_RBRACKET "Forventet ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Uafsluttet streng konstant" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Funktion forventet" IDS_NOT_DATE "[objekt]' er ikke en dato objekt" IDS_NOT_NUM "Nummer forventet" diff --git a/reactos/dll/win32/jscript/lang/jscript_De.rc b/reactos/dll/win32/jscript/lang/jscript_De.rc index d7b351e8661..013437ae0d9 100644 --- a/reactos/dll/win32/jscript/lang/jscript_De.rc +++ b/reactos/dll/win32/jscript/lang/jscript_De.rc @@ -34,6 +34,8 @@ STRINGTABLE IDS_SEMICOLON "';' erwartet" IDS_LBRACKET "'(' erwartet" IDS_RBRACKET "')' erwartet" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "konstante Zeichenkette wurde nicht abgeschlossen" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -41,7 +43,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Funktion erwartet" IDS_NOT_DATE "'[Objekt]' ist kein Datums-Objekt" IDS_NOT_NUM "Zahl erwartet" diff --git a/reactos/dll/win32/jscript/lang/jscript_En.rc b/reactos/dll/win32/jscript/lang/jscript_En.rc index a92303b67d0..9a2bff86957 100644 --- a/reactos/dll/win32/jscript/lang/jscript_En.rc +++ b/reactos/dll/win32/jscript/lang/jscript_En.rc @@ -32,6 +32,8 @@ STRINGTABLE IDS_SEMICOLON "Expected ';'" IDS_LBRACKET "Expected '('" IDS_RBRACKET "Expected ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Unterminated string constant" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -39,7 +41,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Function expected" IDS_NOT_DATE "'[object]' is not a date object" IDS_NOT_NUM "Number expected" diff --git a/reactos/dll/win32/jscript/lang/jscript_Es.rc b/reactos/dll/win32/jscript/lang/jscript_Es.rc index 25a755d428e..2fe3ac4ef1d 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Es.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Es.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "Esperado ';'" IDS_LBRACKET "Esperado '('" IDS_RBRACKET "Esperado ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Constante de cadena no terminada" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Función esperada" IDS_NOT_DATE "'[objeto]' no es un objeto fecha" IDS_NOT_NUM "Numero esperado" diff --git a/reactos/dll/win32/jscript/lang/jscript_Fr.rc b/reactos/dll/win32/jscript/lang/jscript_Fr.rc index 9cbcdcd4728..edbf23b5b31 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Fr.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Fr.rc @@ -37,6 +37,8 @@ STRINGTABLE IDS_SEMICOLON "« ; » attendu" IDS_LBRACKET "« ( » attendu" IDS_RBRACKET "« ) » attendu" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Constante chaîne de caractères non clôturée" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -44,7 +46,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Fonction attendue" IDS_NOT_DATE "« [objet] » n'est pas un objet de type date" IDS_NOT_NUM "Nombre attendu" diff --git a/reactos/dll/win32/jscript/lang/jscript_He.rc b/reactos/dll/win32/jscript/lang/jscript_He.rc index 0a2a8094f97..52331c9b6a9 100644 --- a/reactos/dll/win32/jscript/lang/jscript_He.rc +++ b/reactos/dll/win32/jscript/lang/jscript_He.rc @@ -34,6 +34,8 @@ STRINGTABLE IDS_SEMICOLON "צפוי ';'" IDS_LBRACKET "צפוי '('" IDS_RBRACKET "צפוי ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Unterminated string constant" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -41,7 +43,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "פונקציה הייתה צפוייה" IDS_NOT_DATE "'[object]' is not a date object" IDS_NOT_NUM "מספר היה צפוי" diff --git a/reactos/dll/win32/jscript/lang/jscript_Hu.rc b/reactos/dll/win32/jscript/lang/jscript_Hu.rc index 0f7ed5cdd54..34232eb20bb 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Hu.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Hu.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "Hiányzó ';'" IDS_LBRACKET "Hiányzó '('" IDS_RBRACKET "Hiányzó ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Lezáratlan sztring konstans" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Függvényt vártam" IDS_NOT_DATE "'Az [object]' nem egy date (dátum) objektum" IDS_NOT_NUM "Számot vártam" diff --git a/reactos/dll/win32/jscript/lang/jscript_It.rc b/reactos/dll/win32/jscript/lang/jscript_It.rc index 0575da8990b..1382333a193 100644 --- a/reactos/dll/win32/jscript/lang/jscript_It.rc +++ b/reactos/dll/win32/jscript/lang/jscript_It.rc @@ -36,6 +36,8 @@ STRINGTABLE IDS_SEMICOLON "Richiesto ';'" IDS_LBRACKET "Richiesto '('" IDS_RBRACKET "Richiesto ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Costante stringa non terminata" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -43,7 +45,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Richiesta una funzione" IDS_NOT_DATE "'[oggetto]' non è un oggetto data" IDS_NOT_NUM "Richiesto un numero" diff --git a/reactos/dll/win32/jscript/lang/jscript_Ja.rc b/reactos/dll/win32/jscript/lang/jscript_Ja.rc index 77eb22128c7..c27a38862f1 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Ja.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Ja.rc @@ -36,6 +36,8 @@ STRINGTABLE IDS_SEMICOLON "';'を期待していました" IDS_LBRACKET "'('を期待していました" IDS_RBRACKET "')'を期待していました" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "文字列定数が終端していません" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -43,7 +45,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "関数を期待していました" IDS_NOT_DATE "'[object]' は日付オブジェクトではありません" IDS_NOT_NUM "数値を期待していました" diff --git a/reactos/dll/win32/jscript/lang/jscript_Ko.rc b/reactos/dll/win32/jscript/lang/jscript_Ko.rc index b2fe6f0797a..3e16b2b5ff8 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Ko.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Ko.rc @@ -36,6 +36,8 @@ STRINGTABLE IDS_SEMICOLON "';' 가 필요합니다" IDS_LBRACKET "'(' 가 필요합니다" IDS_RBRACKET "')' 가 필요합니다" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "띁나지 않은 문자열 상수" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -43,7 +45,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "함수가 필요합니다" IDS_NOT_DATE "'[객체]' 는 날짜 객체가 아닙니다" IDS_NOT_NUM "숫자가 필요합니다" diff --git a/reactos/dll/win32/jscript/lang/jscript_Lt.rc b/reactos/dll/win32/jscript/lang/jscript_Lt.rc index 443196e5517..8b8ef968dc2 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Lt.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Lt.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "Tikėtasi „;“" IDS_LBRACKET "Tikėtasi „(“" IDS_RBRACKET "Tikėtasi „)“" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Nebaigta eilutės konstanta" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Tikėtasi funkcijos" IDS_NOT_DATE "„[objektas]“ nėra datos objektas" IDS_NOT_NUM "Tikėtasi skaičiaus" diff --git a/reactos/dll/win32/jscript/lang/jscript_Nl.rc b/reactos/dll/win32/jscript/lang/jscript_Nl.rc index 107929a761b..cc6d6cde938 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Nl.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Nl.rc @@ -34,6 +34,8 @@ STRINGTABLE IDS_SEMICOLON "';' verwacht" IDS_LBRACKET "'(' verwacht" IDS_RBRACKET "')' verwacht" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Onafgesloten tekenreeksconstante" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -41,7 +43,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Functie verwacht" IDS_NOT_DATE "'[object]' is geen datum object" IDS_NOT_NUM "Getal verwacht" diff --git a/reactos/dll/win32/jscript/lang/jscript_No.rc b/reactos/dll/win32/jscript/lang/jscript_No.rc index 2171c26d93f..fe4cd2cf976 100644 --- a/reactos/dll/win32/jscript/lang/jscript_No.rc +++ b/reactos/dll/win32/jscript/lang/jscript_No.rc @@ -34,6 +34,8 @@ STRINGTABLE IDS_SEMICOLON "Forventet ';'" IDS_LBRACKET "Forventet '('" IDS_RBRACKET "Forventet ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Uavsluttet strengkonstant" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -41,7 +43,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Forventet funksjon" IDS_NOT_DATE "'[object]' er ikke et dataobjekt" IDS_NOT_NUM "Forventet nummer" diff --git a/reactos/dll/win32/jscript/lang/jscript_Pl.rc b/reactos/dll/win32/jscript/lang/jscript_Pl.rc index 41f050d55fd..98ea4c78262 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Pl.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Pl.rc @@ -32,6 +32,8 @@ STRINGTABLE IDS_SEMICOLON "Oczekiwane ';'" IDS_LBRACKET "Oczekiwane '('" IDS_RBRACKET "Oczekiwane ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Niezakończona stała znakowa" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -39,7 +41,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Oczekiwana funkcja" IDS_NOT_DATE "'[obiekt]' nie jest obiektem daty" IDS_NOT_NUM "Oczekiwana liczba" diff --git a/reactos/dll/win32/jscript/lang/jscript_Pt.rc b/reactos/dll/win32/jscript/lang/jscript_Pt.rc index 1b1f27a25fa..b8fac6c3561 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Pt.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Pt.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "';' esperado" IDS_LBRACKET "'(' esperado" IDS_RBRACKET "')' esperado" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Constante de string não terminada" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Função esperada" IDS_NOT_DATE "'[object]' não é um objeto de data" IDS_NOT_NUM "Número esperado" @@ -78,6 +82,8 @@ STRINGTABLE IDS_SEMICOLON "';' esperado" IDS_LBRACKET "'(' esperado" IDS_RBRACKET "')' esperado" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Constante de string não terminada" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -85,7 +91,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Função esperada" IDS_NOT_DATE "'[object]' não é um objecto de data" IDS_NOT_NUM "Número esperado" diff --git a/reactos/dll/win32/jscript/lang/jscript_Ro.rc b/reactos/dll/win32/jscript/lang/jscript_Ro.rc index 55c027c524a..dcd9cda9ad5 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Ro.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Ro.rc @@ -37,6 +37,8 @@ STRINGTABLE IDS_SEMICOLON "Se așteaptă „;”" IDS_LBRACKET "Se așteaptă „(”" IDS_RBRACKET "Se așteaptă „)”" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Caracter nevalid" IDS_UNTERMINATED_STR "Șir constant neterminat" IDS_MISPLACED_RETURN "Poziția 'return' este în afara funcției" @@ -44,7 +46,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Nu se poate admite 'continue' în afara buclelor" IDS_LABEL_REDEFINED "Eticheta este redefinită" IDS_LABEL_NOT_FOUND "Etichetă nu este găsită" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Compilarea condițională este dezactivată" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Se așteaptă o funcție" IDS_NOT_DATE "„[obiect]” nu este un obiect de tip dată" IDS_NOT_NUM "Se așteaptă un număr" diff --git a/reactos/dll/win32/jscript/lang/jscript_Ru.rc b/reactos/dll/win32/jscript/lang/jscript_Ru.rc index 3c2967d37ab..fb04683e0b9 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Ru.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Ru.rc @@ -36,6 +36,8 @@ STRINGTABLE IDS_SEMICOLON "Предполагается наличие ';'" IDS_LBRACKET "Предполагается наличие '('" IDS_RBRACKET "Предполагается наличие ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Недопустимый символ" IDS_UNTERMINATED_STR "Незавершённая строковая константа" IDS_MISPLACED_RETURN "Инструкция 'return' вне функции" @@ -43,7 +45,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Инструкция 'continue' не может находиться вне блока loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Ожидается функция" IDS_NOT_DATE "'[object]' не объект типа 'date'" IDS_NOT_NUM "Ожидается число" diff --git a/reactos/dll/win32/jscript/lang/jscript_Si.rc b/reactos/dll/win32/jscript/lang/jscript_Si.rc index 8983be21d86..001ec769c33 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Si.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Si.rc @@ -34,6 +34,8 @@ STRINGTABLE IDS_SEMICOLON "Pričakujem ';'" IDS_LBRACKET "Pričakujem '('" IDS_RBRACKET "Pričakujem ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Nezaključen niz" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -41,7 +43,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Pričakujem funkcijo" IDS_NOT_DATE "'[object]' ni date objekt" IDS_NOT_NUM "Pričakujem število" diff --git a/reactos/dll/win32/jscript/lang/jscript_Sq.rc b/reactos/dll/win32/jscript/lang/jscript_Sq.rc index 4a1cf8b335e..6d0dacf04df 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Sq.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Sq.rc @@ -35,6 +35,8 @@ STRINGTABLE IDS_SEMICOLON "Pritej ';'" IDS_LBRACKET "Pritej '('" IDS_RBRACKET "Pritej ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "String i pambyllur konstant" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -42,7 +44,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Funksioni Pritej" IDS_NOT_DATE "'[objekt]' nuk eshte nje objekt date" IDS_NOT_NUM "Numri Pritej" diff --git a/reactos/dll/win32/jscript/lang/jscript_Tr.rc b/reactos/dll/win32/jscript/lang/jscript_Tr.rc index dd78eb0a3a0..040fa9d650a 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Tr.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Tr.rc @@ -32,6 +32,8 @@ STRINGTABLE IDS_SEMICOLON """;"" bekleniyordu." IDS_LBRACKET """("" bekleniyordu." IDS_RBRACKET """)"" bekleniyordu." + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Geçersiz damga." IDS_UNTERMINATED_STR "Sonlandırılmamış dizgi değişmezi." IDS_MISPLACED_RETURN """return"" deyişi işlecin dışında." @@ -39,7 +41,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Döngü dışında ""continue"" olamaz." IDS_LABEL_REDEFINED "Etiket yeniden tanımlandı." IDS_LABEL_NOT_FOUND "Etiket bulunamadı." + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Şartlı derleme kapalı." + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "İşleç bekleniyordu." IDS_NOT_DATE """[nesne]"" bir zaman nesnesi değil." IDS_NOT_NUM "Sayı bekleniyordu." diff --git a/reactos/dll/win32/jscript/lang/jscript_Uk.rc b/reactos/dll/win32/jscript/lang/jscript_Uk.rc index 34b00942a03..bc6a2b7bbf5 100644 --- a/reactos/dll/win32/jscript/lang/jscript_Uk.rc +++ b/reactos/dll/win32/jscript/lang/jscript_Uk.rc @@ -36,6 +36,8 @@ STRINGTABLE IDS_SEMICOLON "Очікується ';'" IDS_LBRACKET "Очікується '('" IDS_RBRACKET "Очікується ')'" + IDS_EXPECTED_IDENTIFIER "Expected identifier" + IDS_EXPECTED_ASSIGN "Expected '='" IDS_INVALID_CHAR "Invalid character" IDS_UNTERMINATED_STR "Незавершена рядкова константа" IDS_MISPLACED_RETURN "'return' statement outside of function" @@ -43,7 +45,9 @@ STRINGTABLE IDS_INVALID_CONTINUE "Can't have 'continue' outside of loop" IDS_LABEL_REDEFINED "Label redefined" IDS_LABEL_NOT_FOUND "Label not found" + IDS_EXPECTED_CCEND "Expected '@end'" IDS_DISABLED_CC "Conditional compilation is turned off" + IDS_EXPECTED_AT "Expected '@'" IDS_NOT_FUNC "Очікується функція" IDS_NOT_DATE "'[object]' не об'єкт типу date" IDS_NOT_NUM "Очікується число" diff --git a/reactos/dll/win32/jscript/lex.c b/reactos/dll/win32/jscript/lex.c index 3d55845ad1b..e02764f47a1 100644 --- a/reactos/dll/win32/jscript/lex.c +++ b/reactos/dll/win32/jscript/lex.c @@ -51,6 +51,9 @@ static const WCHAR voidW[] = {'v','o','i','d',0}; static const WCHAR whileW[] = {'w','h','i','l','e',0}; static const WCHAR withW[] = {'w','i','t','h',0}; +static const WCHAR elifW[] = {'e','l','i','f',0}; +static const WCHAR endW[] = {'e','n','d',0}; + static const struct { const WCHAR *word; int token; @@ -99,6 +102,11 @@ static BOOL is_identifier_char(WCHAR c) return isalnumW(c) || c == '$' || c == '_' || c == '\\'; } +static BOOL is_identifier_first_char(WCHAR c) +{ + return isalphaW(c) || c == '$' || c == '_' || c == '\\'; +} + static int check_keyword(parser_ctx_t *ctx, const WCHAR *word, const WCHAR **lval) { const WCHAR *p1 = ctx->ptr; @@ -219,6 +227,16 @@ static BOOL skip_comment(parser_ctx_t *ctx) return TRUE; } +static BOOL skip_spaces(parser_ctx_t *ctx) +{ + while(ctx->ptr < ctx->end && (isspaceW(*ctx->ptr) || *ctx->ptr == 0xFEFF /* UTF16 BOM */)) { + if(is_endline(*ctx->ptr++)) + ctx->nl = TRUE; + } + + return ctx->ptr != ctx->end; +} + static BOOL unescape(WCHAR *str) { WCHAR *pd, *p, c; @@ -376,7 +394,7 @@ literal_t *new_boolean_literal(parser_ctx_t *ctx, BOOL bval) return ret; } -static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **literal) +static BOOL parse_double_literal(parser_ctx_t *ctx, LONG int_part, double *ret) { LONGLONG d, hlp; int exp = 0; @@ -423,13 +441,15 @@ static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **li ctx->ptr++; }else if(!isdigitW(*ctx->ptr)) { WARN("Expected exponent part\n"); - return lex_error(ctx, E_FAIL); + lex_error(ctx, E_FAIL); + return FALSE; } } if(ctx->ptr == ctx->end) { WARN("unexpected end of file\n"); - return lex_error(ctx, E_FAIL); + lex_error(ctx, E_FAIL); + return FALSE; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { @@ -445,14 +465,15 @@ static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **li if(is_identifier_char(*ctx->ptr)) { WARN("wrong char after zero\n"); - return lex_error(ctx, JS_E_MISSING_SEMICOLON); + lex_error(ctx, JS_E_MISSING_SEMICOLON); + return FALSE; } - *literal = new_double_literal(ctx, exp>=0 ? d*pow(10, exp) : d/pow(10, -exp)); - return tNumericLiteral; + *ret = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp); + return TRUE; } -static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) +static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret) { LONG l, d; @@ -461,7 +482,7 @@ static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) if(*ctx->ptr == 'x' || *ctx->ptr == 'X') { if(++ctx->ptr == ctx->end) { ERR("unexpected end of file\n"); - return 0; + return FALSE; } while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) { @@ -471,11 +492,12 @@ static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) { WARN("unexpected identifier char\n"); - return lex_error(ctx, JS_E_MISSING_SEMICOLON); + lex_error(ctx, JS_E_MISSING_SEMICOLON); + return FALSE; } - *literal = new_double_literal(ctx, l); - return tNumericLiteral; + *ret = l; + return TRUE; } if(isdigitW(*ctx->ptr)) { @@ -497,30 +519,28 @@ static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) /* FIXME: Do we need it here? */ if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) { WARN("wrong char after octal literal: '%c'\n", *ctx->ptr); - return lex_error(ctx, JS_E_MISSING_SEMICOLON); + lex_error(ctx, JS_E_MISSING_SEMICOLON); + return FALSE; } - *literal = new_double_literal(ctx, val); - return tNumericLiteral; + *ret = val; + return TRUE; } if(is_identifier_char(*ctx->ptr)) { WARN("wrong char after zero\n"); - return lex_error(ctx, JS_E_MISSING_SEMICOLON); + lex_error(ctx, JS_E_MISSING_SEMICOLON); + return FALSE; } } - return parse_double_literal(ctx, l, literal); + return parse_double_literal(ctx, l, ret); } static int next_token(parser_ctx_t *ctx, void *lval) { do { - while(ctx->ptr < ctx->end && isspaceW(*ctx->ptr)) { - if(is_endline(*ctx->ptr++)) - ctx->nl = TRUE; - } - if(ctx->ptr == ctx->end) + if(!skip_spaces(ctx)) return tEOF; }while(skip_comment(ctx) || skip_html_comment(ctx)); @@ -538,8 +558,15 @@ static int next_token(parser_ctx_t *ctx, void *lval) return parse_identifier(ctx, lval); } - if(isdigitW(*ctx->ptr)) - return parse_numeric_literal(ctx, lval); + if(isdigitW(*ctx->ptr)) { + double n; + + if(!parse_numeric_literal(ctx, &n)) + return -1; + + *(literal_t**)lval = new_double_literal(ctx, n); + return tNumericLiteral; + } switch(*ctx->ptr) { case '{': @@ -559,8 +586,13 @@ static int next_token(parser_ctx_t *ctx, void *lval) return '}'; case '.': - if(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) - return parse_double_literal(ctx, 0, lval); + if(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { + double n; + if(!parse_double_literal(ctx, 0, &n)) + return -1; + *(literal_t**)lval = new_double_literal(ctx, n); + return tNumericLiteral; + } return '.'; case '<': @@ -759,11 +791,7 @@ static int next_token(parser_ctx_t *ctx, void *lval) } struct _cc_var_t { - BOOL is_num; - union { - BOOL b; - DOUBLE n; - } u; + ccval_t val; struct _cc_var_t *next; unsigned name_len; WCHAR name[0]; @@ -781,18 +809,18 @@ void release_cc(cc_ctx_t *cc) heap_free(cc); } -static BOOL add_cc_var(cc_ctx_t *cc, const WCHAR *name, cc_var_t *v) +static BOOL new_cc_var(cc_ctx_t *cc, const WCHAR *name, int len, ccval_t v) { cc_var_t *new_v; - unsigned len; - len = strlenW(name); + if(len == -1) + len = strlenW(name); new_v = heap_alloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR)); if(!new_v) return FALSE; - memcpy(new_v, v, sizeof(*v)); + new_v->val = v; memcpy(new_v->name, name, (len+1)*sizeof(WCHAR)); new_v->name_len = len; new_v->next = cc->vars; @@ -812,10 +840,9 @@ static cc_var_t *find_cc_var(cc_ctx_t *cc, const WCHAR *name, unsigned name_len) return NULL; } -static int init_cc(parser_ctx_t *ctx) +static BOOL init_cc(parser_ctx_t *ctx) { cc_ctx_t *cc; - cc_var_t v; static const WCHAR _win32W[] = {'_','w','i','n','3','2',0}; static const WCHAR _win64W[] = {'_','w','i','n','6','4',0}; @@ -826,39 +853,144 @@ static int init_cc(parser_ctx_t *ctx) static const WCHAR _jscript_versionW[] = {'_','j','s','c','r','i','p','t','_','v','e','r','s','i','o','n',0}; if(ctx->script->cc) - return 0; + return TRUE; cc = heap_alloc(sizeof(cc_ctx_t)); - if(!cc) - return lex_error(ctx, E_OUTOFMEMORY); + if(!cc) { + lex_error(ctx, E_OUTOFMEMORY); + return FALSE; + } cc->vars = NULL; - v.is_num = FALSE; - v.u.b = TRUE; - if(!add_cc_var(cc, _jscriptW, &v) - || !add_cc_var(cc, sizeof(void*) == 8 ? _win64W : _win32W, &v) - || !add_cc_var(cc, sizeof(void*) == 8 ? _amd64W : _x86W, &v)) { - release_cc(cc); - return lex_error(ctx, E_OUTOFMEMORY); - } - v.is_num = TRUE; - v.u.n = JSCRIPT_BUILD_VERSION; - if(!add_cc_var(cc, _jscript_buildW, &v)) { + if(!new_cc_var(cc, _jscriptW, -1, ccval_bool(TRUE)) + || !new_cc_var(cc, sizeof(void*) == 8 ? _win64W : _win32W, -1, ccval_bool(TRUE)) + || !new_cc_var(cc, sizeof(void*) == 8 ? _amd64W : _x86W, -1, ccval_bool(TRUE)) + || !new_cc_var(cc, _jscript_versionW, -1, ccval_num(JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0)) + || !new_cc_var(cc, _jscript_buildW, -1, ccval_num(JSCRIPT_BUILD_VERSION))) { release_cc(cc); - return lex_error(ctx, E_OUTOFMEMORY); - } - - v.u.n = JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0; - if(!add_cc_var(cc, _jscript_versionW, &v)) { - release_cc(cc); - return lex_error(ctx, E_OUTOFMEMORY); + lex_error(ctx, E_OUTOFMEMORY); + return FALSE; } ctx->script->cc = cc; + return TRUE; +} + +static BOOL parse_cc_identifier(parser_ctx_t *ctx, const WCHAR **ret, unsigned *ret_len) +{ + if(*ctx->ptr != '@') { + lex_error(ctx, JS_E_EXPECTED_AT); + return FALSE; + } + + if(!is_identifier_first_char(*++ctx->ptr)) { + lex_error(ctx, JS_E_EXPECTED_IDENTIFIER); + return FALSE; + } + + *ret = ctx->ptr; + while(++ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)); + *ret_len = ctx->ptr - *ret; + return TRUE; +} + +int try_parse_ccval(parser_ctx_t *ctx, ccval_t *r) +{ + if(!skip_spaces(ctx)) + return -1; + + if(isdigitW(*ctx->ptr)) { + double n; + + if(!parse_numeric_literal(ctx, &n)) + return -1; + + *r = ccval_num(n); + return 1; + } + + if(*ctx->ptr == '@') { + const WCHAR *ident; + unsigned ident_len; + cc_var_t *cc_var; + + if(!parse_cc_identifier(ctx, &ident, &ident_len)) + return -1; + + cc_var = find_cc_var(ctx->script->cc, ident, ident_len); + *r = cc_var ? cc_var->val : ccval_num(NAN); + return 1; + } + + if(!check_keyword(ctx, trueW, NULL)) { + *r = ccval_bool(TRUE); + return 1; + } + + if(!check_keyword(ctx, falseW, NULL)) { + *r = ccval_bool(FALSE); + return 1; + } + return 0; } +static int skip_code(parser_ctx_t *ctx, BOOL exec_else) +{ + int if_depth = 1; + const WCHAR *ptr; + + while(1) { + ptr = strchrW(ctx->ptr, '@'); + if(!ptr) { + WARN("No @end\n"); + return lex_error(ctx, JS_E_EXPECTED_CCEND); + } + ctx->ptr = ptr+1; + + if(!check_keyword(ctx, endW, NULL)) { + if(--if_depth) + continue; + return 0; + } + + if(exec_else && !check_keyword(ctx, elifW, NULL)) { + if(if_depth > 1) + continue; + + if(!skip_spaces(ctx) || *ctx->ptr != '(') + return lex_error(ctx, JS_E_MISSING_LBRACKET); + + if(!parse_cc_expr(ctx)) + return -1; + + if(!get_ccbool(ctx->ccval)) + continue; /* skip block of code */ + + /* continue parsing */ + ctx->cc_if_depth++; + return 0; + } + + if(exec_else && !check_keyword(ctx, elseW, NULL)) { + if(if_depth > 1) + continue; + + /* parse else block */ + ctx->cc_if_depth++; + return 0; + } + + if(!check_keyword(ctx, ifW, NULL)) { + if_depth++; + continue; + } + + ctx->ptr++; + } +} + static int cc_token(parser_ctx_t *ctx, void *lval) { unsigned id_len = 0; @@ -866,37 +998,78 @@ static int cc_token(parser_ctx_t *ctx, void *lval) static const WCHAR cc_onW[] = {'c','c','_','o','n',0}; static const WCHAR setW[] = {'s','e','t',0}; - static const WCHAR elifW[] = {'e','l','i','f',0}; - static const WCHAR endW[] = {'e','n','d',0}; ctx->ptr++; if(!check_keyword(ctx, cc_onW, NULL)) - return init_cc(ctx); + return init_cc(ctx) ? 0 : -1; if(!check_keyword(ctx, setW, NULL)) { - FIXME("@set not implemented\n"); - return lex_error(ctx, E_NOTIMPL); + const WCHAR *ident; + unsigned ident_len; + cc_var_t *var; + + if(!init_cc(ctx)) + return -1; + + if(!skip_spaces(ctx)) + return lex_error(ctx, JS_E_EXPECTED_AT); + + if(!parse_cc_identifier(ctx, &ident, &ident_len)) + return -1; + + if(!skip_spaces(ctx) || *ctx->ptr != '=') + return lex_error(ctx, JS_E_EXPECTED_ASSIGN); + ctx->ptr++; + + if(!parse_cc_expr(ctx)) { + WARN("parsing CC expression failed\n"); + return -1; + } + + var = find_cc_var(ctx->script->cc, ident, ident_len); + if(var) { + var->val = ctx->ccval; + }else { + if(!new_cc_var(ctx->script->cc, ident, ident_len, ctx->ccval)) + return lex_error(ctx, E_OUTOFMEMORY); + } + + return 0; } if(!check_keyword(ctx, ifW, NULL)) { - FIXME("@if not implemented\n"); - return lex_error(ctx, E_NOTIMPL); + if(!init_cc(ctx)) + return -1; + + if(!skip_spaces(ctx) || *ctx->ptr != '(') + return lex_error(ctx, JS_E_MISSING_LBRACKET); + + if(!parse_cc_expr(ctx)) + return -1; + + if(get_ccbool(ctx->ccval)) { + /* continue parsing block inside if */ + ctx->cc_if_depth++; + return 0; + } + + return skip_code(ctx, TRUE); } - if(!check_keyword(ctx, elifW, NULL)) { - FIXME("@elif not implemented\n"); - return lex_error(ctx, E_NOTIMPL); - } + if(!check_keyword(ctx, elifW, NULL) || !check_keyword(ctx, elseW, NULL)) { + if(!ctx->cc_if_depth) + return lex_error(ctx, JS_E_SYNTAX); - if(!check_keyword(ctx, elseW, NULL)) { - FIXME("@else not implemented\n"); - return lex_error(ctx, E_NOTIMPL); + return skip_code(ctx, FALSE); } if(!check_keyword(ctx, endW, NULL)) { - FIXME("@end not implemented\n"); - return lex_error(ctx, E_NOTIMPL); + if(!ctx->cc_if_depth) + return lex_error(ctx, JS_E_SYNTAX); + + ctx->cc_if_depth--; + return 0; } if(!ctx->script->cc) @@ -911,12 +1084,12 @@ static int cc_token(parser_ctx_t *ctx, void *lval) var = find_cc_var(ctx->script->cc, ctx->ptr, id_len); ctx->ptr += id_len; - if(!var || var->is_num) { - *(literal_t**)lval = new_double_literal(ctx, var ? var->u.n : NAN); + if(!var || var->val.is_num) { + *(literal_t**)lval = new_double_literal(ctx, var ? var->val.u.n : NAN); return tNumericLiteral; } - *(literal_t**)lval = new_boolean_literal(ctx, var->u.b); + *(literal_t**)lval = new_boolean_literal(ctx, var->val.u.b); return tBooleanLiteral; } diff --git a/reactos/dll/win32/jscript/number.c b/reactos/dll/win32/jscript/number.c index 7b5a46de3be..cebcc9f3ef7 100644 --- a/reactos/dll/win32/jscript/number.c +++ b/reactos/dll/win32/jscript/number.c @@ -34,9 +34,14 @@ static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0}; #define NUMBER_TOSTRING_BUF_SIZE 64 #define NUMBER_DTOA_SIZE 18 +static inline NumberInstance *number_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, NumberInstance, dispex); +} + static inline NumberInstance *number_from_vdisp(vdisp_t *vdisp) { - return (NumberInstance*)vdisp->u.jsdisp; + return number_from_jsdisp(vdisp->u.jsdisp); } static inline NumberInstance *number_this(vdisp_t *jsthis) @@ -490,23 +495,13 @@ static HRESULT Number_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un return S_OK; } -static HRESULT Number_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Number_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { - NumberInstance *number = number_from_vdisp(jsthis); + NumberInstance *number = number_from_jsdisp(jsthis); - switch(flags) { - case INVOKE_FUNC: - return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL); - case DISPATCH_PROPERTYGET: - *r = jsval_number(number->value); - break; - - default: - FIXME("flags %x\n", flags); - return E_NOTIMPL; - } + TRACE("(%p)\n", number); + *r = jsval_number(number->value); return S_OK; } @@ -521,7 +516,7 @@ static const builtin_prop_t Number_props[] = { static const builtin_info_t Number_info = { JSCLASS_NUMBER, - {NULL, Number_value, 0}, + {NULL, NULL,0, Number_get_value}, sizeof(Number_props)/sizeof(*Number_props), Number_props, NULL, @@ -530,7 +525,7 @@ static const builtin_info_t Number_info = { static const builtin_info_t NumberInst_info = { JSCLASS_NUMBER, - {NULL, Number_value, 0}, + {NULL, NULL,0, Number_get_value}, 0, NULL, NULL, NULL diff --git a/reactos/dll/win32/jscript/object.c b/reactos/dll/win32/jscript/object.c index daa026f1196..457bc859bf0 100644 --- a/reactos/dll/win32/jscript/object.c +++ b/reactos/dll/win32/jscript/object.c @@ -201,26 +201,17 @@ static HRESULT Object_isPrototypeOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla return E_NOTIMPL; } -static HRESULT Object_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT Object_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + jsstr_t *ret; + TRACE("\n"); - switch(flags) { - case INVOKE_FUNC: - return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL); - case DISPATCH_PROPERTYGET: { - jsstr_t *ret = jsstr_alloc(default_valueW); - if(!ret) - return E_OUTOFMEMORY; - *r = jsval_string(ret); - break; - } - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; - } + ret = jsstr_alloc(default_valueW); + if(!ret) + return E_OUTOFMEMORY; + *r = jsval_string(ret); return S_OK; } @@ -240,7 +231,7 @@ static const builtin_prop_t Object_props[] = { static const builtin_info_t Object_info = { JSCLASS_OBJECT, - {NULL, Object_value, 0}, + {NULL, NULL,0, Object_get_value}, sizeof(Object_props)/sizeof(*Object_props), Object_props, Object_destructor, @@ -249,7 +240,7 @@ static const builtin_info_t Object_info = { static const builtin_info_t ObjectInst_info = { JSCLASS_OBJECT, - {NULL, Object_value, 0}, + {NULL, NULL,0, Object_get_value}, 0, NULL, Object_destructor, NULL diff --git a/reactos/dll/win32/jscript/parser.h b/reactos/dll/win32/jscript/parser.h new file mode 100644 index 00000000000..d572ab66a46 --- /dev/null +++ b/reactos/dll/win32/jscript/parser.h @@ -0,0 +1,396 @@ +/* + * Copyright 2014 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#pragma once + +typedef struct _source_elements_t source_elements_t; +typedef struct _expression_t expression_t; +typedef struct _statement_t statement_t; + +typedef struct { + BOOL is_num; + union { + BOOL b; + double n; + } u; +} ccval_t; + +typedef struct _parser_ctx_t { + const WCHAR *begin; + const WCHAR *end; + const WCHAR *ptr; + + script_ctx_t *script; + source_elements_t *source; + BOOL nl; + BOOL implicit_nl_semicolon; + BOOL is_html; + BOOL lexer_error; + HRESULT hres; + + ccval_t ccval; + unsigned cc_if_depth; + + heap_pool_t heap; +} parser_ctx_t; + +HRESULT script_parse(script_ctx_t*,const WCHAR*,const WCHAR*,BOOL,parser_ctx_t**) DECLSPEC_HIDDEN; +void parser_release(parser_ctx_t*) DECLSPEC_HIDDEN; + +int parser_lex(void*,parser_ctx_t*) DECLSPEC_HIDDEN; + +static inline void *parser_alloc(parser_ctx_t *ctx, DWORD size) +{ + return heap_pool_alloc(&ctx->heap, size); +} + +static inline void *parser_alloc_tmp(parser_ctx_t *ctx, DWORD size) +{ + return heap_pool_alloc(&ctx->script->tmp_heap, size); +} + +typedef enum { + LT_DOUBLE, + LT_STRING, + LT_BOOL, + LT_NULL, + LT_REGEXP +}literal_type_t; + +typedef struct { + literal_type_t type; + union { + double dval; + const WCHAR *wstr; + BOOL bval; + struct { + const WCHAR *str; + DWORD str_len; + DWORD flags; + } regexp; + } u; +} literal_t; + +literal_t *parse_regexp(parser_ctx_t*) DECLSPEC_HIDDEN; +literal_t *new_boolean_literal(parser_ctx_t*,BOOL) DECLSPEC_HIDDEN; + +typedef struct _variable_declaration_t { + const WCHAR *identifier; + expression_t *expr; + + struct _variable_declaration_t *next; + struct _variable_declaration_t *global_next; /* for compiler */ +} variable_declaration_t; + +typedef enum { + STAT_BLOCK, + STAT_BREAK, + STAT_CONTINUE, + STAT_EMPTY, + STAT_EXPR, + STAT_FOR, + STAT_FORIN, + STAT_IF, + STAT_LABEL, + STAT_RETURN, + STAT_SWITCH, + STAT_THROW, + STAT_TRY, + STAT_VAR, + STAT_WHILE, + STAT_WITH +} statement_type_t; + +struct _statement_t { + statement_type_t type; + statement_t *next; +}; + +typedef struct { + statement_t stat; + statement_t *stat_list; +} block_statement_t; + +typedef struct { + statement_t stat; + variable_declaration_t *variable_list; +} var_statement_t; + +typedef struct { + statement_t stat; + expression_t *expr; +} expression_statement_t; + +typedef struct { + statement_t stat; + expression_t *expr; + statement_t *if_stat; + statement_t *else_stat; +} if_statement_t; + +typedef struct { + statement_t stat; + BOOL do_while; + expression_t *expr; + statement_t *statement; +} while_statement_t; + +typedef struct { + statement_t stat; + variable_declaration_t *variable_list; + expression_t *begin_expr; + expression_t *expr; + expression_t *end_expr; + statement_t *statement; +} for_statement_t; + +typedef struct { + statement_t stat; + variable_declaration_t *variable; + expression_t *expr; + expression_t *in_expr; + statement_t *statement; +} forin_statement_t; + +typedef struct { + statement_t stat; + const WCHAR *identifier; +} branch_statement_t; + +typedef struct { + statement_t stat; + expression_t *expr; + statement_t *statement; +} with_statement_t; + +typedef struct { + statement_t stat; + const WCHAR *identifier; + statement_t *statement; +} labelled_statement_t; + +typedef struct _case_clausule_t { + expression_t *expr; + statement_t *stat; + + struct _case_clausule_t *next; +} case_clausule_t; + +typedef struct { + statement_t stat; + expression_t *expr; + case_clausule_t *case_list; +} switch_statement_t; + +typedef struct { + const WCHAR *identifier; + statement_t *statement; +} catch_block_t; + +typedef struct { + statement_t stat; + statement_t *try_statement; + catch_block_t *catch_block; + statement_t *finally_statement; +} try_statement_t; + +typedef enum { + EXPR_COMMA, + EXPR_OR, + EXPR_AND, + EXPR_BOR, + EXPR_BXOR, + EXPR_BAND, + EXPR_INSTANCEOF, + EXPR_IN, + EXPR_ADD, + EXPR_SUB, + EXPR_MUL, + EXPR_DIV, + EXPR_MOD, + EXPR_DELETE, + EXPR_VOID, + EXPR_TYPEOF, + EXPR_MINUS, + EXPR_PLUS, + EXPR_POSTINC, + EXPR_POSTDEC, + EXPR_PREINC, + EXPR_PREDEC, + EXPR_EQ, + EXPR_EQEQ, + EXPR_NOTEQ, + EXPR_NOTEQEQ, + EXPR_LESS, + EXPR_LESSEQ, + EXPR_GREATER, + EXPR_GREATEREQ, + EXPR_BITNEG, + EXPR_LOGNEG, + EXPR_LSHIFT, + EXPR_RSHIFT, + EXPR_RRSHIFT, + EXPR_ASSIGN, + EXPR_ASSIGNLSHIFT, + EXPR_ASSIGNRSHIFT, + EXPR_ASSIGNRRSHIFT, + EXPR_ASSIGNADD, + EXPR_ASSIGNSUB, + EXPR_ASSIGNMUL, + EXPR_ASSIGNDIV, + EXPR_ASSIGNMOD, + EXPR_ASSIGNAND, + EXPR_ASSIGNOR, + EXPR_ASSIGNXOR, + EXPR_COND, + EXPR_ARRAY, + EXPR_MEMBER, + EXPR_NEW, + EXPR_CALL, + EXPR_THIS, + EXPR_FUNC, + EXPR_IDENT, + EXPR_ARRAYLIT, + EXPR_PROPVAL, + EXPR_LITERAL +} expression_type_t; + +struct _expression_t { + expression_type_t type; +}; + +typedef struct _parameter_t { + const WCHAR *identifier; + struct _parameter_t *next; +} parameter_t; + +struct _source_elements_t { + statement_t *statement; + statement_t *statement_tail; +}; + +typedef struct _function_expression_t { + expression_t expr; + const WCHAR *identifier; + parameter_t *parameter_list; + source_elements_t *source_elements; + const WCHAR *src_str; + DWORD src_len; + + struct _function_expression_t *next; /* for compiler */ +} function_expression_t; + +typedef struct { + expression_t expr; + expression_t *expression1; + expression_t *expression2; +} binary_expression_t; + +typedef struct { + expression_t expr; + expression_t *expression; +} unary_expression_t; + +typedef struct { + expression_t expr; + expression_t *expression; + expression_t *true_expression; + expression_t *false_expression; +} conditional_expression_t; + +typedef struct { + expression_t expr; + expression_t *expression; + const WCHAR *identifier; +} member_expression_t; + +typedef struct _argument_t { + expression_t *expr; + + struct _argument_t *next; +} argument_t; + +typedef struct { + expression_t expr; + expression_t *expression; + argument_t *argument_list; +} call_expression_t; + +typedef struct { + expression_t expr; + const WCHAR *identifier; +} identifier_expression_t; + +typedef struct { + expression_t expr; + literal_t *literal; +} literal_expression_t; + +typedef struct _array_element_t { + int elision; + expression_t *expr; + + struct _array_element_t *next; +} array_element_t; + +typedef struct { + expression_t expr; + array_element_t *element_list; + int length; +} array_literal_expression_t; + +typedef struct _prop_val_t { + literal_t *name; + expression_t *value; + + struct _prop_val_t *next; +} prop_val_t; + +typedef struct { + expression_t expr; + prop_val_t *property_list; +} property_value_expression_t; + +BOOL try_parse_ccval(parser_ctx_t*,ccval_t*) DECLSPEC_HIDDEN; +BOOL parse_cc_expr(parser_ctx_t*) DECLSPEC_HIDDEN; + +static inline ccval_t ccval_num(double n) +{ + ccval_t r; + r.is_num = TRUE; + r.u.n = n; + return r; +} + +static inline ccval_t ccval_bool(BOOL b) +{ + ccval_t r; + r.is_num = FALSE; + r.u.b = b; + return r; +} + +static inline BOOL get_ccbool(ccval_t v) +{ + return v.is_num ? v.u.n != 0 : v.u.b; +} + +static inline double get_ccnum(ccval_t v) +{ + return v.is_num ? v.u.n : v.u.b; +} diff --git a/reactos/dll/win32/jscript/parser.tab.c b/reactos/dll/win32/jscript/parser.tab.c index dd3d65778c2..66d9d0b2496 100644 --- a/reactos/dll/win32/jscript/parser.tab.c +++ b/reactos/dll/win32/jscript/parser.tab.c @@ -183,7 +183,7 @@ static source_elements_t *new_source_elements(parser_ctx_t*); static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*); -#line 192 "parser.tab.c" /* yacc.c:339 */ +#line 193 "parser.tab.c" /* yacc.c:339 */ # ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus @@ -267,7 +267,7 @@ extern int parser_debug; typedef union YYSTYPE YYSTYPE; union YYSTYPE { -#line 144 "parser.y" /* yacc.c:355 */ +#line 145 "parser.y" /* yacc.c:355 */ int ival; const WCHAR *srcptr; @@ -288,7 +288,7 @@ union YYSTYPE struct _variable_list_t *variable_list; variable_declaration_t *variable_declaration; -#line 297 "parser.tab.c" /* yacc.c:355 */ +#line 298 "parser.tab.c" /* yacc.c:355 */ }; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -302,7 +302,7 @@ int parser_parse (parser_ctx_t *ctx); /* Copy the second part of user declarations. */ -#line 311 "parser.tab.c" /* yacc.c:358 */ +#line 312 "parser.tab.c" /* yacc.c:358 */ #ifdef short # undef short @@ -604,28 +604,28 @@ static const yytype_uint8 yytranslate[] = /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 251, 251, 255, 256, 260, 261, 266, 270, 274, - 278, 279, 284, 285, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 307, - 308, 313, 314, 318, 319, 323, 328, 329, 334, 336, - 341, 346, 351, 352, 356, 361, 362, 366, 371, 375, - 380, 382, 387, 389, 392, 394, 391, 398, 400, 397, - 403, 405, 410, 415, 420, 425, 430, 435, 440, 442, - 447, 448, 452, 453, 458, 463, 468, 473, 474, 475, - 480, 485, 489, 490, 493, 494, 498, 499, 504, 505, - 509, 511, 515, 516, 520, 521, 523, 528, 530, 532, - 537, 538, 543, 545, 550, 551, 556, 558, 563, 564, - 569, 571, 576, 577, 582, 584, 589, 590, 595, 597, - 602, 603, 608, 610, 615, 616, 621, 622, 627, 628, - 630, 632, 637, 638, 640, 645, 646, 651, 653, 655, - 660, 661, 663, 665, 670, 671, 673, 674, 676, 677, - 678, 679, 680, 681, 685, 687, 689, 695, 696, 700, - 701, 705, 706, 707, 709, 711, 716, 718, 720, 722, - 727, 728, 732, 733, 738, 739, 740, 741, 742, 743, - 747, 748, 749, 750, 755, 757, 762, 763, 767, 768, - 772, 773, 778, 780, 785, 786, 787, 791, 792, 796, - 797, 798, 799, 800, 802, 807, 808, 809, 812, 813, - 816, 817, 820, 821, 824, 825 + 0, 252, 252, 256, 257, 261, 262, 267, 271, 275, + 279, 280, 285, 286, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 308, + 309, 314, 315, 319, 320, 324, 329, 330, 335, 337, + 342, 347, 352, 353, 357, 362, 363, 367, 372, 376, + 381, 383, 388, 390, 393, 395, 392, 399, 401, 398, + 404, 406, 411, 416, 421, 426, 431, 436, 441, 443, + 448, 449, 453, 454, 459, 464, 469, 474, 475, 476, + 481, 486, 490, 491, 494, 495, 499, 500, 505, 506, + 510, 512, 516, 517, 521, 522, 524, 529, 531, 533, + 538, 539, 544, 546, 551, 552, 557, 559, 564, 565, + 570, 572, 577, 578, 583, 585, 590, 591, 596, 598, + 603, 604, 609, 611, 616, 617, 622, 623, 628, 629, + 631, 633, 638, 639, 641, 646, 647, 652, 654, 656, + 661, 662, 664, 666, 671, 672, 674, 675, 677, 678, + 679, 680, 681, 682, 686, 688, 690, 696, 697, 701, + 702, 706, 707, 708, 710, 712, 717, 719, 721, 723, + 728, 729, 733, 734, 739, 740, 741, 742, 743, 744, + 748, 749, 750, 751, 756, 758, 763, 764, 768, 769, + 773, 774, 779, 781, 786, 787, 788, 792, 793, 797, + 798, 799, 800, 801, 803, 808, 809, 810, 813, 814, + 817, 818, 821, 822, 825, 826 }; #endif @@ -1821,1269 +1821,1269 @@ yyreduce: switch (yyn) { case 2: -#line 252 "parser.y" /* yacc.c:1646 */ +#line 253 "parser.y" /* yacc.c:1646 */ { program_parsed(ctx, (yyvsp[-2].source_elements)); } -#line 1832 "parser.tab.c" /* yacc.c:1646 */ +#line 1833 "parser.tab.c" /* yacc.c:1646 */ break; case 3: -#line 255 "parser.y" /* yacc.c:1646 */ +#line 256 "parser.y" /* yacc.c:1646 */ {} -#line 1838 "parser.tab.c" /* yacc.c:1646 */ +#line 1839 "parser.tab.c" /* yacc.c:1646 */ break; case 4: -#line 256 "parser.y" /* yacc.c:1646 */ +#line 257 "parser.y" /* yacc.c:1646 */ {} -#line 1844 "parser.tab.c" /* yacc.c:1646 */ +#line 1845 "parser.tab.c" /* yacc.c:1646 */ break; case 5: -#line 260 "parser.y" /* yacc.c:1646 */ +#line 261 "parser.y" /* yacc.c:1646 */ { (yyval.source_elements) = new_source_elements(ctx); } -#line 1850 "parser.tab.c" /* yacc.c:1646 */ +#line 1851 "parser.tab.c" /* yacc.c:1646 */ break; case 6: -#line 262 "parser.y" /* yacc.c:1646 */ +#line 263 "parser.y" /* yacc.c:1646 */ { (yyval.source_elements) = source_elements_add_statement((yyvsp[-1].source_elements), (yyvsp[0].statement)); } -#line 1856 "parser.tab.c" /* yacc.c:1646 */ +#line 1857 "parser.tab.c" /* yacc.c:1646 */ break; case 7: -#line 267 "parser.y" /* yacc.c:1646 */ +#line 268 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), (yyvsp[-7].srcptr), (yyvsp[0].srcptr)-(yyvsp[-7].srcptr)+1); } -#line 1862 "parser.tab.c" /* yacc.c:1646 */ +#line 1863 "parser.tab.c" /* yacc.c:1646 */ break; case 8: -#line 270 "parser.y" /* yacc.c:1646 */ +#line 271 "parser.y" /* yacc.c:1646 */ { (yyval.srcptr) = (yyvsp[0].srcptr); } -#line 1868 "parser.tab.c" /* yacc.c:1646 */ +#line 1869 "parser.tab.c" /* yacc.c:1646 */ break; case 9: -#line 274 "parser.y" /* yacc.c:1646 */ +#line 275 "parser.y" /* yacc.c:1646 */ { (yyval.source_elements) = (yyvsp[0].source_elements); } -#line 1874 "parser.tab.c" /* yacc.c:1646 */ +#line 1875 "parser.tab.c" /* yacc.c:1646 */ break; case 10: -#line 278 "parser.y" /* yacc.c:1646 */ +#line 279 "parser.y" /* yacc.c:1646 */ { (yyval.parameter_list) = new_parameter_list(ctx, (yyvsp[0].identifier)); } -#line 1880 "parser.tab.c" /* yacc.c:1646 */ +#line 1881 "parser.tab.c" /* yacc.c:1646 */ break; case 11: -#line 280 "parser.y" /* yacc.c:1646 */ +#line 281 "parser.y" /* yacc.c:1646 */ { (yyval.parameter_list) = parameter_list_add(ctx, (yyvsp[-2].parameter_list), (yyvsp[0].identifier)); } -#line 1886 "parser.tab.c" /* yacc.c:1646 */ +#line 1887 "parser.tab.c" /* yacc.c:1646 */ break; case 12: -#line 284 "parser.y" /* yacc.c:1646 */ +#line 285 "parser.y" /* yacc.c:1646 */ { (yyval.parameter_list) = NULL; } -#line 1892 "parser.tab.c" /* yacc.c:1646 */ +#line 1893 "parser.tab.c" /* yacc.c:1646 */ break; case 13: -#line 285 "parser.y" /* yacc.c:1646 */ +#line 286 "parser.y" /* yacc.c:1646 */ { (yyval.parameter_list) = (yyvsp[0].parameter_list); } -#line 1898 "parser.tab.c" /* yacc.c:1646 */ +#line 1899 "parser.tab.c" /* yacc.c:1646 */ break; case 14: -#line 289 "parser.y" /* yacc.c:1646 */ +#line 290 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1904 "parser.tab.c" /* yacc.c:1646 */ +#line 1905 "parser.tab.c" /* yacc.c:1646 */ break; case 15: -#line 290 "parser.y" /* yacc.c:1646 */ +#line 291 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1910 "parser.tab.c" /* yacc.c:1646 */ +#line 1911 "parser.tab.c" /* yacc.c:1646 */ break; case 16: -#line 291 "parser.y" /* yacc.c:1646 */ +#line 292 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1916 "parser.tab.c" /* yacc.c:1646 */ +#line 1917 "parser.tab.c" /* yacc.c:1646 */ break; case 17: -#line 292 "parser.y" /* yacc.c:1646 */ +#line 293 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_expression_statement(ctx, (yyvsp[0].expr)); } -#line 1922 "parser.tab.c" /* yacc.c:1646 */ +#line 1923 "parser.tab.c" /* yacc.c:1646 */ break; case 18: -#line 293 "parser.y" /* yacc.c:1646 */ +#line 294 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1928 "parser.tab.c" /* yacc.c:1646 */ +#line 1929 "parser.tab.c" /* yacc.c:1646 */ break; case 19: -#line 294 "parser.y" /* yacc.c:1646 */ +#line 295 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1934 "parser.tab.c" /* yacc.c:1646 */ +#line 1935 "parser.tab.c" /* yacc.c:1646 */ break; case 20: -#line 295 "parser.y" /* yacc.c:1646 */ +#line 296 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1940 "parser.tab.c" /* yacc.c:1646 */ +#line 1941 "parser.tab.c" /* yacc.c:1646 */ break; case 21: -#line 296 "parser.y" /* yacc.c:1646 */ +#line 297 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1946 "parser.tab.c" /* yacc.c:1646 */ +#line 1947 "parser.tab.c" /* yacc.c:1646 */ break; case 22: -#line 297 "parser.y" /* yacc.c:1646 */ +#line 298 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1952 "parser.tab.c" /* yacc.c:1646 */ +#line 1953 "parser.tab.c" /* yacc.c:1646 */ break; case 23: -#line 298 "parser.y" /* yacc.c:1646 */ +#line 299 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1958 "parser.tab.c" /* yacc.c:1646 */ +#line 1959 "parser.tab.c" /* yacc.c:1646 */ break; case 24: -#line 299 "parser.y" /* yacc.c:1646 */ +#line 300 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1964 "parser.tab.c" /* yacc.c:1646 */ +#line 1965 "parser.tab.c" /* yacc.c:1646 */ break; case 25: -#line 300 "parser.y" /* yacc.c:1646 */ +#line 301 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1970 "parser.tab.c" /* yacc.c:1646 */ +#line 1971 "parser.tab.c" /* yacc.c:1646 */ break; case 26: -#line 301 "parser.y" /* yacc.c:1646 */ +#line 302 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1976 "parser.tab.c" /* yacc.c:1646 */ +#line 1977 "parser.tab.c" /* yacc.c:1646 */ break; case 27: -#line 302 "parser.y" /* yacc.c:1646 */ +#line 303 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1982 "parser.tab.c" /* yacc.c:1646 */ +#line 1983 "parser.tab.c" /* yacc.c:1646 */ break; case 28: -#line 303 "parser.y" /* yacc.c:1646 */ +#line 304 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 1988 "parser.tab.c" /* yacc.c:1646 */ +#line 1989 "parser.tab.c" /* yacc.c:1646 */ break; case 29: -#line 307 "parser.y" /* yacc.c:1646 */ +#line 308 "parser.y" /* yacc.c:1646 */ { (yyval.statement_list) = new_statement_list(ctx, (yyvsp[0].statement)); } -#line 1994 "parser.tab.c" /* yacc.c:1646 */ +#line 1995 "parser.tab.c" /* yacc.c:1646 */ break; case 30: -#line 309 "parser.y" /* yacc.c:1646 */ +#line 310 "parser.y" /* yacc.c:1646 */ { (yyval.statement_list) = statement_list_add((yyvsp[-1].statement_list), (yyvsp[0].statement)); } -#line 2000 "parser.tab.c" /* yacc.c:1646 */ +#line 2001 "parser.tab.c" /* yacc.c:1646 */ break; case 31: -#line 313 "parser.y" /* yacc.c:1646 */ +#line 314 "parser.y" /* yacc.c:1646 */ { (yyval.statement_list) = NULL; } -#line 2006 "parser.tab.c" /* yacc.c:1646 */ +#line 2007 "parser.tab.c" /* yacc.c:1646 */ break; case 32: -#line 314 "parser.y" /* yacc.c:1646 */ +#line 315 "parser.y" /* yacc.c:1646 */ { (yyval.statement_list) = (yyvsp[0].statement_list); } -#line 2012 "parser.tab.c" /* yacc.c:1646 */ +#line 2013 "parser.tab.c" /* yacc.c:1646 */ break; case 33: -#line 318 "parser.y" /* yacc.c:1646 */ +#line 319 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_block_statement(ctx, (yyvsp[-1].statement_list)); } -#line 2018 "parser.tab.c" /* yacc.c:1646 */ +#line 2019 "parser.tab.c" /* yacc.c:1646 */ break; case 34: -#line 319 "parser.y" /* yacc.c:1646 */ +#line 320 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_block_statement(ctx, NULL); } -#line 2024 "parser.tab.c" /* yacc.c:1646 */ +#line 2025 "parser.tab.c" /* yacc.c:1646 */ break; case 35: -#line 324 "parser.y" /* yacc.c:1646 */ +#line 325 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_var_statement(ctx, (yyvsp[-1].variable_list)); } -#line 2030 "parser.tab.c" /* yacc.c:1646 */ +#line 2031 "parser.tab.c" /* yacc.c:1646 */ break; case 36: -#line 328 "parser.y" /* yacc.c:1646 */ +#line 329 "parser.y" /* yacc.c:1646 */ { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); } -#line 2036 "parser.tab.c" /* yacc.c:1646 */ +#line 2037 "parser.tab.c" /* yacc.c:1646 */ break; case 37: -#line 330 "parser.y" /* yacc.c:1646 */ +#line 331 "parser.y" /* yacc.c:1646 */ { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); } -#line 2042 "parser.tab.c" /* yacc.c:1646 */ +#line 2043 "parser.tab.c" /* yacc.c:1646 */ break; case 38: -#line 335 "parser.y" /* yacc.c:1646 */ +#line 336 "parser.y" /* yacc.c:1646 */ { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); } -#line 2048 "parser.tab.c" /* yacc.c:1646 */ +#line 2049 "parser.tab.c" /* yacc.c:1646 */ break; case 39: -#line 337 "parser.y" /* yacc.c:1646 */ +#line 338 "parser.y" /* yacc.c:1646 */ { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); } -#line 2054 "parser.tab.c" /* yacc.c:1646 */ +#line 2055 "parser.tab.c" /* yacc.c:1646 */ break; case 40: -#line 342 "parser.y" /* yacc.c:1646 */ +#line 343 "parser.y" /* yacc.c:1646 */ { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); } -#line 2060 "parser.tab.c" /* yacc.c:1646 */ +#line 2061 "parser.tab.c" /* yacc.c:1646 */ break; case 41: -#line 347 "parser.y" /* yacc.c:1646 */ +#line 348 "parser.y" /* yacc.c:1646 */ { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); } -#line 2066 "parser.tab.c" /* yacc.c:1646 */ +#line 2067 "parser.tab.c" /* yacc.c:1646 */ break; case 42: -#line 351 "parser.y" /* yacc.c:1646 */ +#line 352 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = NULL; } -#line 2072 "parser.tab.c" /* yacc.c:1646 */ +#line 2073 "parser.tab.c" /* yacc.c:1646 */ break; case 43: -#line 352 "parser.y" /* yacc.c:1646 */ +#line 353 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2078 "parser.tab.c" /* yacc.c:1646 */ +#line 2079 "parser.tab.c" /* yacc.c:1646 */ break; case 44: -#line 357 "parser.y" /* yacc.c:1646 */ +#line 358 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2084 "parser.tab.c" /* yacc.c:1646 */ +#line 2085 "parser.tab.c" /* yacc.c:1646 */ break; case 45: -#line 361 "parser.y" /* yacc.c:1646 */ +#line 362 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = NULL; } -#line 2090 "parser.tab.c" /* yacc.c:1646 */ +#line 2091 "parser.tab.c" /* yacc.c:1646 */ break; case 46: -#line 362 "parser.y" /* yacc.c:1646 */ +#line 363 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2096 "parser.tab.c" /* yacc.c:1646 */ +#line 2097 "parser.tab.c" /* yacc.c:1646 */ break; case 47: -#line 367 "parser.y" /* yacc.c:1646 */ +#line 368 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2102 "parser.tab.c" /* yacc.c:1646 */ +#line 2103 "parser.tab.c" /* yacc.c:1646 */ break; case 48: -#line 371 "parser.y" /* yacc.c:1646 */ +#line 372 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_statement(ctx, STAT_EMPTY, 0); } -#line 2108 "parser.tab.c" /* yacc.c:1646 */ +#line 2109 "parser.tab.c" /* yacc.c:1646 */ break; case 49: -#line 376 "parser.y" /* yacc.c:1646 */ +#line 377 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_expression_statement(ctx, (yyvsp[-1].expr)); } -#line 2114 "parser.tab.c" /* yacc.c:1646 */ +#line 2115 "parser.tab.c" /* yacc.c:1646 */ break; case 50: -#line 381 "parser.y" /* yacc.c:1646 */ +#line 382 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_if_statement(ctx, (yyvsp[-4].expr), (yyvsp[-2].statement), (yyvsp[0].statement)); } -#line 2120 "parser.tab.c" /* yacc.c:1646 */ +#line 2121 "parser.tab.c" /* yacc.c:1646 */ break; case 51: -#line 383 "parser.y" /* yacc.c:1646 */ +#line 384 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_if_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement), NULL); } -#line 2126 "parser.tab.c" /* yacc.c:1646 */ +#line 2127 "parser.tab.c" /* yacc.c:1646 */ break; case 52: -#line 388 "parser.y" /* yacc.c:1646 */ +#line 389 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_while_statement(ctx, TRUE, (yyvsp[-2].expr), (yyvsp[-5].statement)); } -#line 2132 "parser.tab.c" /* yacc.c:1646 */ +#line 2133 "parser.tab.c" /* yacc.c:1646 */ break; case 53: -#line 390 "parser.y" /* yacc.c:1646 */ +#line 391 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_while_statement(ctx, FALSE, (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2138 "parser.tab.c" /* yacc.c:1646 */ +#line 2139 "parser.tab.c" /* yacc.c:1646 */ break; case 54: -#line 392 "parser.y" /* yacc.c:1646 */ +#line 393 "parser.y" /* yacc.c:1646 */ { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } -#line 2144 "parser.tab.c" /* yacc.c:1646 */ +#line 2145 "parser.tab.c" /* yacc.c:1646 */ break; case 55: -#line 394 "parser.y" /* yacc.c:1646 */ +#line 395 "parser.y" /* yacc.c:1646 */ { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } -#line 2150 "parser.tab.c" /* yacc.c:1646 */ +#line 2151 "parser.tab.c" /* yacc.c:1646 */ break; case 56: -#line 396 "parser.y" /* yacc.c:1646 */ +#line 397 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_for_statement(ctx, NULL, (yyvsp[-8].expr), (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2156 "parser.tab.c" /* yacc.c:1646 */ +#line 2157 "parser.tab.c" /* yacc.c:1646 */ break; case 57: -#line 398 "parser.y" /* yacc.c:1646 */ +#line 399 "parser.y" /* yacc.c:1646 */ { if(!explicit_error(ctx, (yyvsp[0].variable_list), ';')) YYABORT; } -#line 2162 "parser.tab.c" /* yacc.c:1646 */ +#line 2163 "parser.tab.c" /* yacc.c:1646 */ break; case 58: -#line 400 "parser.y" /* yacc.c:1646 */ +#line 401 "parser.y" /* yacc.c:1646 */ { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; } -#line 2168 "parser.tab.c" /* yacc.c:1646 */ +#line 2169 "parser.tab.c" /* yacc.c:1646 */ break; case 59: -#line 402 "parser.y" /* yacc.c:1646 */ +#line 403 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_for_statement(ctx, (yyvsp[-8].variable_list), NULL, (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2174 "parser.tab.c" /* yacc.c:1646 */ +#line 2175 "parser.tab.c" /* yacc.c:1646 */ break; case 60: -#line 404 "parser.y" /* yacc.c:1646 */ +#line 405 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_forin_statement(ctx, NULL, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2180 "parser.tab.c" /* yacc.c:1646 */ +#line 2181 "parser.tab.c" /* yacc.c:1646 */ break; case 61: -#line 406 "parser.y" /* yacc.c:1646 */ +#line 407 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_forin_statement(ctx, (yyvsp[-4].variable_declaration), NULL, (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2186 "parser.tab.c" /* yacc.c:1646 */ +#line 2187 "parser.tab.c" /* yacc.c:1646 */ break; case 62: -#line 411 "parser.y" /* yacc.c:1646 */ +#line 412 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_continue_statement(ctx, (yyvsp[-1].identifier)); } -#line 2192 "parser.tab.c" /* yacc.c:1646 */ +#line 2193 "parser.tab.c" /* yacc.c:1646 */ break; case 63: -#line 416 "parser.y" /* yacc.c:1646 */ +#line 417 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_break_statement(ctx, (yyvsp[-1].identifier)); } -#line 2198 "parser.tab.c" /* yacc.c:1646 */ +#line 2199 "parser.tab.c" /* yacc.c:1646 */ break; case 64: -#line 421 "parser.y" /* yacc.c:1646 */ +#line 422 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_return_statement(ctx, (yyvsp[-1].expr)); } -#line 2204 "parser.tab.c" /* yacc.c:1646 */ +#line 2205 "parser.tab.c" /* yacc.c:1646 */ break; case 65: -#line 426 "parser.y" /* yacc.c:1646 */ +#line 427 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_with_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement)); } -#line 2210 "parser.tab.c" /* yacc.c:1646 */ +#line 2211 "parser.tab.c" /* yacc.c:1646 */ break; case 66: -#line 431 "parser.y" /* yacc.c:1646 */ +#line 432 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_labelled_statement(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); } -#line 2216 "parser.tab.c" /* yacc.c:1646 */ +#line 2217 "parser.tab.c" /* yacc.c:1646 */ break; case 67: -#line 436 "parser.y" /* yacc.c:1646 */ +#line 437 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_switch_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].case_clausule)); } -#line 2222 "parser.tab.c" /* yacc.c:1646 */ +#line 2223 "parser.tab.c" /* yacc.c:1646 */ break; case 68: -#line 441 "parser.y" /* yacc.c:1646 */ +#line 442 "parser.y" /* yacc.c:1646 */ { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-1].case_list), NULL, NULL); } -#line 2228 "parser.tab.c" /* yacc.c:1646 */ +#line 2229 "parser.tab.c" /* yacc.c:1646 */ break; case 69: -#line 443 "parser.y" /* yacc.c:1646 */ +#line 444 "parser.y" /* yacc.c:1646 */ { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-3].case_list), (yyvsp[-2].case_clausule), (yyvsp[-1].case_list)); } -#line 2234 "parser.tab.c" /* yacc.c:1646 */ +#line 2235 "parser.tab.c" /* yacc.c:1646 */ break; case 70: -#line 447 "parser.y" /* yacc.c:1646 */ +#line 448 "parser.y" /* yacc.c:1646 */ { (yyval.case_list) = NULL; } -#line 2240 "parser.tab.c" /* yacc.c:1646 */ +#line 2241 "parser.tab.c" /* yacc.c:1646 */ break; case 71: -#line 448 "parser.y" /* yacc.c:1646 */ +#line 449 "parser.y" /* yacc.c:1646 */ { (yyval.case_list) = (yyvsp[0].case_list); } -#line 2246 "parser.tab.c" /* yacc.c:1646 */ +#line 2247 "parser.tab.c" /* yacc.c:1646 */ break; case 72: -#line 452 "parser.y" /* yacc.c:1646 */ +#line 453 "parser.y" /* yacc.c:1646 */ { (yyval.case_list) = new_case_list(ctx, (yyvsp[0].case_clausule)); } -#line 2252 "parser.tab.c" /* yacc.c:1646 */ +#line 2253 "parser.tab.c" /* yacc.c:1646 */ break; case 73: -#line 454 "parser.y" /* yacc.c:1646 */ +#line 455 "parser.y" /* yacc.c:1646 */ { (yyval.case_list) = case_list_add(ctx, (yyvsp[-1].case_list), (yyvsp[0].case_clausule)); } -#line 2258 "parser.tab.c" /* yacc.c:1646 */ +#line 2259 "parser.tab.c" /* yacc.c:1646 */ break; case 74: -#line 459 "parser.y" /* yacc.c:1646 */ +#line 460 "parser.y" /* yacc.c:1646 */ { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[-2].expr), (yyvsp[0].statement_list)); } -#line 2264 "parser.tab.c" /* yacc.c:1646 */ +#line 2265 "parser.tab.c" /* yacc.c:1646 */ break; case 75: -#line 464 "parser.y" /* yacc.c:1646 */ +#line 465 "parser.y" /* yacc.c:1646 */ { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[0].statement_list)); } -#line 2270 "parser.tab.c" /* yacc.c:1646 */ +#line 2271 "parser.tab.c" /* yacc.c:1646 */ break; case 76: -#line 469 "parser.y" /* yacc.c:1646 */ +#line 470 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_throw_statement(ctx, (yyvsp[-1].expr)); } -#line 2276 "parser.tab.c" /* yacc.c:1646 */ +#line 2277 "parser.tab.c" /* yacc.c:1646 */ break; case 77: -#line 473 "parser.y" /* yacc.c:1646 */ +#line 474 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), (yyvsp[0].catch_block), NULL); } -#line 2282 "parser.tab.c" /* yacc.c:1646 */ +#line 2283 "parser.tab.c" /* yacc.c:1646 */ break; case 78: -#line 474 "parser.y" /* yacc.c:1646 */ +#line 475 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), NULL, (yyvsp[0].statement)); } -#line 2288 "parser.tab.c" /* yacc.c:1646 */ +#line 2289 "parser.tab.c" /* yacc.c:1646 */ break; case 79: -#line 476 "parser.y" /* yacc.c:1646 */ +#line 477 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = new_try_statement(ctx, (yyvsp[-2].statement), (yyvsp[-1].catch_block), (yyvsp[0].statement)); } -#line 2294 "parser.tab.c" /* yacc.c:1646 */ +#line 2295 "parser.tab.c" /* yacc.c:1646 */ break; case 80: -#line 481 "parser.y" /* yacc.c:1646 */ +#line 482 "parser.y" /* yacc.c:1646 */ { (yyval.catch_block) = new_catch_block(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); } -#line 2300 "parser.tab.c" /* yacc.c:1646 */ +#line 2301 "parser.tab.c" /* yacc.c:1646 */ break; case 81: -#line 485 "parser.y" /* yacc.c:1646 */ +#line 486 "parser.y" /* yacc.c:1646 */ { (yyval.statement) = (yyvsp[0].statement); } -#line 2306 "parser.tab.c" /* yacc.c:1646 */ +#line 2307 "parser.tab.c" /* yacc.c:1646 */ break; case 82: -#line 489 "parser.y" /* yacc.c:1646 */ +#line 490 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = NULL; } -#line 2312 "parser.tab.c" /* yacc.c:1646 */ +#line 2313 "parser.tab.c" /* yacc.c:1646 */ break; case 83: -#line 490 "parser.y" /* yacc.c:1646 */ +#line 491 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2318 "parser.tab.c" /* yacc.c:1646 */ +#line 2319 "parser.tab.c" /* yacc.c:1646 */ break; case 84: -#line 493 "parser.y" /* yacc.c:1646 */ +#line 494 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2324 "parser.tab.c" /* yacc.c:1646 */ +#line 2325 "parser.tab.c" /* yacc.c:1646 */ break; case 85: -#line 494 "parser.y" /* yacc.c:1646 */ +#line 495 "parser.y" /* yacc.c:1646 */ { set_error(ctx, JS_E_SYNTAX); YYABORT; } -#line 2330 "parser.tab.c" /* yacc.c:1646 */ +#line 2331 "parser.tab.c" /* yacc.c:1646 */ break; case 86: -#line 498 "parser.y" /* yacc.c:1646 */ +#line 499 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2336 "parser.tab.c" /* yacc.c:1646 */ +#line 2337 "parser.tab.c" /* yacc.c:1646 */ break; case 87: -#line 500 "parser.y" /* yacc.c:1646 */ +#line 501 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2342 "parser.tab.c" /* yacc.c:1646 */ +#line 2343 "parser.tab.c" /* yacc.c:1646 */ break; case 88: -#line 504 "parser.y" /* yacc.c:1646 */ +#line 505 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = NULL; } -#line 2348 "parser.tab.c" /* yacc.c:1646 */ +#line 2349 "parser.tab.c" /* yacc.c:1646 */ break; case 89: -#line 505 "parser.y" /* yacc.c:1646 */ +#line 506 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2354 "parser.tab.c" /* yacc.c:1646 */ +#line 2355 "parser.tab.c" /* yacc.c:1646 */ break; case 90: -#line 510 "parser.y" /* yacc.c:1646 */ +#line 511 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2360 "parser.tab.c" /* yacc.c:1646 */ +#line 2361 "parser.tab.c" /* yacc.c:1646 */ break; case 91: -#line 512 "parser.y" /* yacc.c:1646 */ +#line 513 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2366 "parser.tab.c" /* yacc.c:1646 */ +#line 2367 "parser.tab.c" /* yacc.c:1646 */ break; case 92: -#line 515 "parser.y" /* yacc.c:1646 */ +#line 516 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = (yyvsp[0].ival); } -#line 2372 "parser.tab.c" /* yacc.c:1646 */ +#line 2373 "parser.tab.c" /* yacc.c:1646 */ break; case 93: -#line 516 "parser.y" /* yacc.c:1646 */ +#line 517 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = EXPR_ASSIGNDIV; } -#line 2378 "parser.tab.c" /* yacc.c:1646 */ +#line 2379 "parser.tab.c" /* yacc.c:1646 */ break; case 94: -#line 520 "parser.y" /* yacc.c:1646 */ +#line 521 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2384 "parser.tab.c" /* yacc.c:1646 */ +#line 2385 "parser.tab.c" /* yacc.c:1646 */ break; case 95: -#line 522 "parser.y" /* yacc.c:1646 */ +#line 523 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2390 "parser.tab.c" /* yacc.c:1646 */ +#line 2391 "parser.tab.c" /* yacc.c:1646 */ break; case 96: -#line 524 "parser.y" /* yacc.c:1646 */ +#line 525 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2396 "parser.tab.c" /* yacc.c:1646 */ +#line 2397 "parser.tab.c" /* yacc.c:1646 */ break; case 97: -#line 529 "parser.y" /* yacc.c:1646 */ +#line 530 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2402 "parser.tab.c" /* yacc.c:1646 */ +#line 2403 "parser.tab.c" /* yacc.c:1646 */ break; case 98: -#line 531 "parser.y" /* yacc.c:1646 */ +#line 532 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2408 "parser.tab.c" /* yacc.c:1646 */ +#line 2409 "parser.tab.c" /* yacc.c:1646 */ break; case 99: -#line 533 "parser.y" /* yacc.c:1646 */ +#line 534 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2414 "parser.tab.c" /* yacc.c:1646 */ +#line 2415 "parser.tab.c" /* yacc.c:1646 */ break; case 100: -#line 537 "parser.y" /* yacc.c:1646 */ +#line 538 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2420 "parser.tab.c" /* yacc.c:1646 */ +#line 2421 "parser.tab.c" /* yacc.c:1646 */ break; case 101: -#line 539 "parser.y" /* yacc.c:1646 */ +#line 540 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2426 "parser.tab.c" /* yacc.c:1646 */ +#line 2427 "parser.tab.c" /* yacc.c:1646 */ break; case 102: -#line 544 "parser.y" /* yacc.c:1646 */ +#line 545 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2432 "parser.tab.c" /* yacc.c:1646 */ +#line 2433 "parser.tab.c" /* yacc.c:1646 */ break; case 103: -#line 546 "parser.y" /* yacc.c:1646 */ +#line 547 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2438 "parser.tab.c" /* yacc.c:1646 */ +#line 2439 "parser.tab.c" /* yacc.c:1646 */ break; case 104: -#line 550 "parser.y" /* yacc.c:1646 */ +#line 551 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2444 "parser.tab.c" /* yacc.c:1646 */ +#line 2445 "parser.tab.c" /* yacc.c:1646 */ break; case 105: -#line 552 "parser.y" /* yacc.c:1646 */ +#line 553 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2450 "parser.tab.c" /* yacc.c:1646 */ +#line 2451 "parser.tab.c" /* yacc.c:1646 */ break; case 106: -#line 557 "parser.y" /* yacc.c:1646 */ +#line 558 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2456 "parser.tab.c" /* yacc.c:1646 */ +#line 2457 "parser.tab.c" /* yacc.c:1646 */ break; case 107: -#line 559 "parser.y" /* yacc.c:1646 */ +#line 560 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2462 "parser.tab.c" /* yacc.c:1646 */ +#line 2463 "parser.tab.c" /* yacc.c:1646 */ break; case 108: -#line 563 "parser.y" /* yacc.c:1646 */ +#line 564 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2468 "parser.tab.c" /* yacc.c:1646 */ +#line 2469 "parser.tab.c" /* yacc.c:1646 */ break; case 109: -#line 565 "parser.y" /* yacc.c:1646 */ +#line 566 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2474 "parser.tab.c" /* yacc.c:1646 */ +#line 2475 "parser.tab.c" /* yacc.c:1646 */ break; case 110: -#line 570 "parser.y" /* yacc.c:1646 */ +#line 571 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2480 "parser.tab.c" /* yacc.c:1646 */ +#line 2481 "parser.tab.c" /* yacc.c:1646 */ break; case 111: -#line 572 "parser.y" /* yacc.c:1646 */ +#line 573 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2486 "parser.tab.c" /* yacc.c:1646 */ +#line 2487 "parser.tab.c" /* yacc.c:1646 */ break; case 112: -#line 576 "parser.y" /* yacc.c:1646 */ +#line 577 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2492 "parser.tab.c" /* yacc.c:1646 */ +#line 2493 "parser.tab.c" /* yacc.c:1646 */ break; case 113: -#line 578 "parser.y" /* yacc.c:1646 */ +#line 579 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2498 "parser.tab.c" /* yacc.c:1646 */ +#line 2499 "parser.tab.c" /* yacc.c:1646 */ break; case 114: -#line 583 "parser.y" /* yacc.c:1646 */ +#line 584 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2504 "parser.tab.c" /* yacc.c:1646 */ +#line 2505 "parser.tab.c" /* yacc.c:1646 */ break; case 115: -#line 585 "parser.y" /* yacc.c:1646 */ +#line 586 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2510 "parser.tab.c" /* yacc.c:1646 */ +#line 2511 "parser.tab.c" /* yacc.c:1646 */ break; case 116: -#line 589 "parser.y" /* yacc.c:1646 */ +#line 590 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2516 "parser.tab.c" /* yacc.c:1646 */ +#line 2517 "parser.tab.c" /* yacc.c:1646 */ break; case 117: -#line 591 "parser.y" /* yacc.c:1646 */ +#line 592 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2522 "parser.tab.c" /* yacc.c:1646 */ +#line 2523 "parser.tab.c" /* yacc.c:1646 */ break; case 118: -#line 596 "parser.y" /* yacc.c:1646 */ +#line 597 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2528 "parser.tab.c" /* yacc.c:1646 */ +#line 2529 "parser.tab.c" /* yacc.c:1646 */ break; case 119: -#line 598 "parser.y" /* yacc.c:1646 */ +#line 599 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2534 "parser.tab.c" /* yacc.c:1646 */ +#line 2535 "parser.tab.c" /* yacc.c:1646 */ break; case 120: -#line 602 "parser.y" /* yacc.c:1646 */ +#line 603 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2540 "parser.tab.c" /* yacc.c:1646 */ +#line 2541 "parser.tab.c" /* yacc.c:1646 */ break; case 121: -#line 604 "parser.y" /* yacc.c:1646 */ +#line 605 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2546 "parser.tab.c" /* yacc.c:1646 */ +#line 2547 "parser.tab.c" /* yacc.c:1646 */ break; case 122: -#line 609 "parser.y" /* yacc.c:1646 */ +#line 610 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2552 "parser.tab.c" /* yacc.c:1646 */ +#line 2553 "parser.tab.c" /* yacc.c:1646 */ break; case 123: -#line 611 "parser.y" /* yacc.c:1646 */ +#line 612 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2558 "parser.tab.c" /* yacc.c:1646 */ +#line 2559 "parser.tab.c" /* yacc.c:1646 */ break; case 124: -#line 615 "parser.y" /* yacc.c:1646 */ +#line 616 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2564 "parser.tab.c" /* yacc.c:1646 */ +#line 2565 "parser.tab.c" /* yacc.c:1646 */ break; case 125: -#line 617 "parser.y" /* yacc.c:1646 */ +#line 618 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2570 "parser.tab.c" /* yacc.c:1646 */ +#line 2571 "parser.tab.c" /* yacc.c:1646 */ break; case 126: -#line 621 "parser.y" /* yacc.c:1646 */ +#line 622 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2576 "parser.tab.c" /* yacc.c:1646 */ +#line 2577 "parser.tab.c" /* yacc.c:1646 */ break; case 127: -#line 623 "parser.y" /* yacc.c:1646 */ +#line 624 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2582 "parser.tab.c" /* yacc.c:1646 */ +#line 2583 "parser.tab.c" /* yacc.c:1646 */ break; case 128: -#line 627 "parser.y" /* yacc.c:1646 */ +#line 628 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2588 "parser.tab.c" /* yacc.c:1646 */ +#line 2589 "parser.tab.c" /* yacc.c:1646 */ break; case 129: -#line 629 "parser.y" /* yacc.c:1646 */ +#line 630 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2594 "parser.tab.c" /* yacc.c:1646 */ +#line 2595 "parser.tab.c" /* yacc.c:1646 */ break; case 130: -#line 631 "parser.y" /* yacc.c:1646 */ +#line 632 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2600 "parser.tab.c" /* yacc.c:1646 */ +#line 2601 "parser.tab.c" /* yacc.c:1646 */ break; case 131: -#line 633 "parser.y" /* yacc.c:1646 */ +#line 634 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_IN, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2606 "parser.tab.c" /* yacc.c:1646 */ +#line 2607 "parser.tab.c" /* yacc.c:1646 */ break; case 132: -#line 637 "parser.y" /* yacc.c:1646 */ +#line 638 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2612 "parser.tab.c" /* yacc.c:1646 */ +#line 2613 "parser.tab.c" /* yacc.c:1646 */ break; case 133: -#line 639 "parser.y" /* yacc.c:1646 */ +#line 640 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2618 "parser.tab.c" /* yacc.c:1646 */ +#line 2619 "parser.tab.c" /* yacc.c:1646 */ break; case 134: -#line 641 "parser.y" /* yacc.c:1646 */ +#line 642 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2624 "parser.tab.c" /* yacc.c:1646 */ +#line 2625 "parser.tab.c" /* yacc.c:1646 */ break; case 135: -#line 645 "parser.y" /* yacc.c:1646 */ +#line 646 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2630 "parser.tab.c" /* yacc.c:1646 */ +#line 2631 "parser.tab.c" /* yacc.c:1646 */ break; case 136: -#line 647 "parser.y" /* yacc.c:1646 */ +#line 648 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2636 "parser.tab.c" /* yacc.c:1646 */ +#line 2637 "parser.tab.c" /* yacc.c:1646 */ break; case 137: -#line 652 "parser.y" /* yacc.c:1646 */ +#line 653 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2642 "parser.tab.c" /* yacc.c:1646 */ +#line 2643 "parser.tab.c" /* yacc.c:1646 */ break; case 138: -#line 654 "parser.y" /* yacc.c:1646 */ +#line 655 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2648 "parser.tab.c" /* yacc.c:1646 */ +#line 2649 "parser.tab.c" /* yacc.c:1646 */ break; case 139: -#line 656 "parser.y" /* yacc.c:1646 */ +#line 657 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2654 "parser.tab.c" /* yacc.c:1646 */ +#line 2655 "parser.tab.c" /* yacc.c:1646 */ break; case 140: -#line 660 "parser.y" /* yacc.c:1646 */ +#line 661 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2660 "parser.tab.c" /* yacc.c:1646 */ +#line 2661 "parser.tab.c" /* yacc.c:1646 */ break; case 141: -#line 662 "parser.y" /* yacc.c:1646 */ +#line 663 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2666 "parser.tab.c" /* yacc.c:1646 */ +#line 2667 "parser.tab.c" /* yacc.c:1646 */ break; case 142: -#line 664 "parser.y" /* yacc.c:1646 */ +#line 665 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2672 "parser.tab.c" /* yacc.c:1646 */ +#line 2673 "parser.tab.c" /* yacc.c:1646 */ break; case 143: -#line 666 "parser.y" /* yacc.c:1646 */ +#line 667 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 2678 "parser.tab.c" /* yacc.c:1646 */ +#line 2679 "parser.tab.c" /* yacc.c:1646 */ break; case 144: -#line 670 "parser.y" /* yacc.c:1646 */ +#line 671 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2684 "parser.tab.c" /* yacc.c:1646 */ +#line 2685 "parser.tab.c" /* yacc.c:1646 */ break; case 145: -#line 672 "parser.y" /* yacc.c:1646 */ +#line 673 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_DELETE, (yyvsp[0].expr)); } -#line 2690 "parser.tab.c" /* yacc.c:1646 */ +#line 2691 "parser.tab.c" /* yacc.c:1646 */ break; case 146: -#line 673 "parser.y" /* yacc.c:1646 */ +#line 674 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_VOID, (yyvsp[0].expr)); } -#line 2696 "parser.tab.c" /* yacc.c:1646 */ +#line 2697 "parser.tab.c" /* yacc.c:1646 */ break; case 147: -#line 675 "parser.y" /* yacc.c:1646 */ +#line 676 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_TYPEOF, (yyvsp[0].expr)); } -#line 2702 "parser.tab.c" /* yacc.c:1646 */ +#line 2703 "parser.tab.c" /* yacc.c:1646 */ break; case 148: -#line 676 "parser.y" /* yacc.c:1646 */ +#line 677 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_PREINC, (yyvsp[0].expr)); } -#line 2708 "parser.tab.c" /* yacc.c:1646 */ +#line 2709 "parser.tab.c" /* yacc.c:1646 */ break; case 149: -#line 677 "parser.y" /* yacc.c:1646 */ +#line 678 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_PREDEC, (yyvsp[0].expr)); } -#line 2714 "parser.tab.c" /* yacc.c:1646 */ +#line 2715 "parser.tab.c" /* yacc.c:1646 */ break; case 150: -#line 678 "parser.y" /* yacc.c:1646 */ +#line 679 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_PLUS, (yyvsp[0].expr)); } -#line 2720 "parser.tab.c" /* yacc.c:1646 */ +#line 2721 "parser.tab.c" /* yacc.c:1646 */ break; case 151: -#line 679 "parser.y" /* yacc.c:1646 */ +#line 680 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_MINUS, (yyvsp[0].expr)); } -#line 2726 "parser.tab.c" /* yacc.c:1646 */ +#line 2727 "parser.tab.c" /* yacc.c:1646 */ break; case 152: -#line 680 "parser.y" /* yacc.c:1646 */ +#line 681 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_BITNEG, (yyvsp[0].expr)); } -#line 2732 "parser.tab.c" /* yacc.c:1646 */ +#line 2733 "parser.tab.c" /* yacc.c:1646 */ break; case 153: -#line 681 "parser.y" /* yacc.c:1646 */ +#line 682 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_LOGNEG, (yyvsp[0].expr)); } -#line 2738 "parser.tab.c" /* yacc.c:1646 */ +#line 2739 "parser.tab.c" /* yacc.c:1646 */ break; case 154: -#line 686 "parser.y" /* yacc.c:1646 */ +#line 687 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2744 "parser.tab.c" /* yacc.c:1646 */ +#line 2745 "parser.tab.c" /* yacc.c:1646 */ break; case 155: -#line 688 "parser.y" /* yacc.c:1646 */ +#line 689 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTINC, (yyvsp[-1].expr)); } -#line 2750 "parser.tab.c" /* yacc.c:1646 */ +#line 2751 "parser.tab.c" /* yacc.c:1646 */ break; case 156: -#line 690 "parser.y" /* yacc.c:1646 */ +#line 691 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTDEC, (yyvsp[-1].expr)); } -#line 2756 "parser.tab.c" /* yacc.c:1646 */ +#line 2757 "parser.tab.c" /* yacc.c:1646 */ break; case 157: -#line 695 "parser.y" /* yacc.c:1646 */ +#line 696 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2762 "parser.tab.c" /* yacc.c:1646 */ +#line 2763 "parser.tab.c" /* yacc.c:1646 */ break; case 158: -#line 696 "parser.y" /* yacc.c:1646 */ +#line 697 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2768 "parser.tab.c" /* yacc.c:1646 */ +#line 2769 "parser.tab.c" /* yacc.c:1646 */ break; case 159: -#line 700 "parser.y" /* yacc.c:1646 */ +#line 701 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2774 "parser.tab.c" /* yacc.c:1646 */ +#line 2775 "parser.tab.c" /* yacc.c:1646 */ break; case 160: -#line 701 "parser.y" /* yacc.c:1646 */ +#line 702 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_new_expression(ctx, (yyvsp[0].expr), NULL); } -#line 2780 "parser.tab.c" /* yacc.c:1646 */ +#line 2781 "parser.tab.c" /* yacc.c:1646 */ break; case 161: -#line 705 "parser.y" /* yacc.c:1646 */ +#line 706 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2786 "parser.tab.c" /* yacc.c:1646 */ +#line 2787 "parser.tab.c" /* yacc.c:1646 */ break; case 162: -#line 706 "parser.y" /* yacc.c:1646 */ +#line 707 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2792 "parser.tab.c" /* yacc.c:1646 */ +#line 2793 "parser.tab.c" /* yacc.c:1646 */ break; case 163: -#line 708 "parser.y" /* yacc.c:1646 */ +#line 709 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } -#line 2798 "parser.tab.c" /* yacc.c:1646 */ +#line 2799 "parser.tab.c" /* yacc.c:1646 */ break; case 164: -#line 710 "parser.y" /* yacc.c:1646 */ +#line 711 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); } -#line 2804 "parser.tab.c" /* yacc.c:1646 */ +#line 2805 "parser.tab.c" /* yacc.c:1646 */ break; case 165: -#line 712 "parser.y" /* yacc.c:1646 */ +#line 713 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_new_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } -#line 2810 "parser.tab.c" /* yacc.c:1646 */ +#line 2811 "parser.tab.c" /* yacc.c:1646 */ break; case 166: -#line 717 "parser.y" /* yacc.c:1646 */ +#line 718 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } -#line 2816 "parser.tab.c" /* yacc.c:1646 */ +#line 2817 "parser.tab.c" /* yacc.c:1646 */ break; case 167: -#line 719 "parser.y" /* yacc.c:1646 */ +#line 720 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); } -#line 2822 "parser.tab.c" /* yacc.c:1646 */ +#line 2823 "parser.tab.c" /* yacc.c:1646 */ break; case 168: -#line 721 "parser.y" /* yacc.c:1646 */ +#line 722 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); } -#line 2828 "parser.tab.c" /* yacc.c:1646 */ +#line 2829 "parser.tab.c" /* yacc.c:1646 */ break; case 169: -#line 723 "parser.y" /* yacc.c:1646 */ +#line 724 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); } -#line 2834 "parser.tab.c" /* yacc.c:1646 */ +#line 2835 "parser.tab.c" /* yacc.c:1646 */ break; case 170: -#line 727 "parser.y" /* yacc.c:1646 */ +#line 728 "parser.y" /* yacc.c:1646 */ { (yyval.argument_list) = NULL; } -#line 2840 "parser.tab.c" /* yacc.c:1646 */ +#line 2841 "parser.tab.c" /* yacc.c:1646 */ break; case 171: -#line 728 "parser.y" /* yacc.c:1646 */ +#line 729 "parser.y" /* yacc.c:1646 */ { (yyval.argument_list) = (yyvsp[-1].argument_list); } -#line 2846 "parser.tab.c" /* yacc.c:1646 */ +#line 2847 "parser.tab.c" /* yacc.c:1646 */ break; case 172: -#line 732 "parser.y" /* yacc.c:1646 */ +#line 733 "parser.y" /* yacc.c:1646 */ { (yyval.argument_list) = new_argument_list(ctx, (yyvsp[0].expr)); } -#line 2852 "parser.tab.c" /* yacc.c:1646 */ +#line 2853 "parser.tab.c" /* yacc.c:1646 */ break; case 173: -#line 734 "parser.y" /* yacc.c:1646 */ +#line 735 "parser.y" /* yacc.c:1646 */ { (yyval.argument_list) = argument_list_add(ctx, (yyvsp[-2].argument_list), (yyvsp[0].expr)); } -#line 2858 "parser.tab.c" /* yacc.c:1646 */ +#line 2859 "parser.tab.c" /* yacc.c:1646 */ break; case 174: -#line 738 "parser.y" /* yacc.c:1646 */ +#line 739 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_expression(ctx, EXPR_THIS, 0); } -#line 2864 "parser.tab.c" /* yacc.c:1646 */ +#line 2865 "parser.tab.c" /* yacc.c:1646 */ break; case 175: -#line 739 "parser.y" /* yacc.c:1646 */ +#line 740 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_identifier_expression(ctx, (yyvsp[0].identifier)); } -#line 2870 "parser.tab.c" /* yacc.c:1646 */ +#line 2871 "parser.tab.c" /* yacc.c:1646 */ break; case 176: -#line 740 "parser.y" /* yacc.c:1646 */ +#line 741 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_literal_expression(ctx, (yyvsp[0].literal)); } -#line 2876 "parser.tab.c" /* yacc.c:1646 */ +#line 2877 "parser.tab.c" /* yacc.c:1646 */ break; case 177: -#line 741 "parser.y" /* yacc.c:1646 */ +#line 742 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2882 "parser.tab.c" /* yacc.c:1646 */ +#line 2883 "parser.tab.c" /* yacc.c:1646 */ break; case 178: -#line 742 "parser.y" /* yacc.c:1646 */ +#line 743 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[0].expr); } -#line 2888 "parser.tab.c" /* yacc.c:1646 */ +#line 2889 "parser.tab.c" /* yacc.c:1646 */ break; case 179: -#line 743 "parser.y" /* yacc.c:1646 */ +#line 744 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = (yyvsp[-1].expr); } -#line 2894 "parser.tab.c" /* yacc.c:1646 */ +#line 2895 "parser.tab.c" /* yacc.c:1646 */ break; case 180: -#line 747 "parser.y" /* yacc.c:1646 */ +#line 748 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_array_literal_expression(ctx, NULL, 0); } -#line 2900 "parser.tab.c" /* yacc.c:1646 */ +#line 2901 "parser.tab.c" /* yacc.c:1646 */ break; case 181: -#line 748 "parser.y" /* yacc.c:1646 */ +#line 749 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_array_literal_expression(ctx, NULL, (yyvsp[-1].ival)+1); } -#line 2906 "parser.tab.c" /* yacc.c:1646 */ +#line 2907 "parser.tab.c" /* yacc.c:1646 */ break; case 182: -#line 749 "parser.y" /* yacc.c:1646 */ +#line 750 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-1].element_list), 0); } -#line 2912 "parser.tab.c" /* yacc.c:1646 */ +#line 2913 "parser.tab.c" /* yacc.c:1646 */ break; case 183: -#line 751 "parser.y" /* yacc.c:1646 */ +#line 752 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival)+1); } -#line 2918 "parser.tab.c" /* yacc.c:1646 */ +#line 2919 "parser.tab.c" /* yacc.c:1646 */ break; case 184: -#line 756 "parser.y" /* yacc.c:1646 */ +#line 757 "parser.y" /* yacc.c:1646 */ { (yyval.element_list) = new_element_list(ctx, (yyvsp[-1].ival), (yyvsp[0].expr)); } -#line 2924 "parser.tab.c" /* yacc.c:1646 */ +#line 2925 "parser.tab.c" /* yacc.c:1646 */ break; case 185: -#line 758 "parser.y" /* yacc.c:1646 */ +#line 759 "parser.y" /* yacc.c:1646 */ { (yyval.element_list) = element_list_add(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival), (yyvsp[0].expr)); } -#line 2930 "parser.tab.c" /* yacc.c:1646 */ +#line 2931 "parser.tab.c" /* yacc.c:1646 */ break; case 186: -#line 762 "parser.y" /* yacc.c:1646 */ +#line 763 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = 1; } -#line 2936 "parser.tab.c" /* yacc.c:1646 */ +#line 2937 "parser.tab.c" /* yacc.c:1646 */ break; case 187: -#line 763 "parser.y" /* yacc.c:1646 */ +#line 764 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = (yyvsp[-1].ival) + 1; } -#line 2942 "parser.tab.c" /* yacc.c:1646 */ +#line 2943 "parser.tab.c" /* yacc.c:1646 */ break; case 188: -#line 767 "parser.y" /* yacc.c:1646 */ +#line 768 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = 0; } -#line 2948 "parser.tab.c" /* yacc.c:1646 */ +#line 2949 "parser.tab.c" /* yacc.c:1646 */ break; case 189: -#line 768 "parser.y" /* yacc.c:1646 */ +#line 769 "parser.y" /* yacc.c:1646 */ { (yyval.ival) = (yyvsp[0].ival); } -#line 2954 "parser.tab.c" /* yacc.c:1646 */ +#line 2955 "parser.tab.c" /* yacc.c:1646 */ break; case 190: -#line 772 "parser.y" /* yacc.c:1646 */ +#line 773 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_prop_and_value_expression(ctx, NULL); } -#line 2960 "parser.tab.c" /* yacc.c:1646 */ +#line 2961 "parser.tab.c" /* yacc.c:1646 */ break; case 191: -#line 774 "parser.y" /* yacc.c:1646 */ +#line 775 "parser.y" /* yacc.c:1646 */ { (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-1].property_list)); } -#line 2966 "parser.tab.c" /* yacc.c:1646 */ +#line 2967 "parser.tab.c" /* yacc.c:1646 */ break; case 192: -#line 779 "parser.y" /* yacc.c:1646 */ +#line 780 "parser.y" /* yacc.c:1646 */ { (yyval.property_list) = new_property_list(ctx, (yyvsp[-2].literal), (yyvsp[0].expr)); } -#line 2972 "parser.tab.c" /* yacc.c:1646 */ +#line 2973 "parser.tab.c" /* yacc.c:1646 */ break; case 193: -#line 781 "parser.y" /* yacc.c:1646 */ +#line 782 "parser.y" /* yacc.c:1646 */ { (yyval.property_list) = property_list_add(ctx, (yyvsp[-4].property_list), (yyvsp[-2].literal), (yyvsp[0].expr)); } -#line 2978 "parser.tab.c" /* yacc.c:1646 */ +#line 2979 "parser.tab.c" /* yacc.c:1646 */ break; case 194: -#line 785 "parser.y" /* yacc.c:1646 */ +#line 786 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].identifier)); } -#line 2984 "parser.tab.c" /* yacc.c:1646 */ +#line 2985 "parser.tab.c" /* yacc.c:1646 */ break; case 195: -#line 786 "parser.y" /* yacc.c:1646 */ +#line 787 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); } -#line 2990 "parser.tab.c" /* yacc.c:1646 */ +#line 2991 "parser.tab.c" /* yacc.c:1646 */ break; case 196: -#line 787 "parser.y" /* yacc.c:1646 */ +#line 788 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = (yyvsp[0].literal); } -#line 2996 "parser.tab.c" /* yacc.c:1646 */ +#line 2997 "parser.tab.c" /* yacc.c:1646 */ break; case 197: -#line 791 "parser.y" /* yacc.c:1646 */ +#line 792 "parser.y" /* yacc.c:1646 */ { (yyval.identifier) = NULL; } -#line 3002 "parser.tab.c" /* yacc.c:1646 */ +#line 3003 "parser.tab.c" /* yacc.c:1646 */ break; case 198: -#line 792 "parser.y" /* yacc.c:1646 */ +#line 793 "parser.y" /* yacc.c:1646 */ { (yyval.identifier) = (yyvsp[0].identifier); } -#line 3008 "parser.tab.c" /* yacc.c:1646 */ +#line 3009 "parser.tab.c" /* yacc.c:1646 */ break; case 199: -#line 796 "parser.y" /* yacc.c:1646 */ +#line 797 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_null_literal(ctx); } -#line 3014 "parser.tab.c" /* yacc.c:1646 */ +#line 3015 "parser.tab.c" /* yacc.c:1646 */ break; case 200: -#line 797 "parser.y" /* yacc.c:1646 */ +#line 798 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = (yyvsp[0].literal); } -#line 3020 "parser.tab.c" /* yacc.c:1646 */ +#line 3021 "parser.tab.c" /* yacc.c:1646 */ break; case 201: -#line 798 "parser.y" /* yacc.c:1646 */ +#line 799 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = (yyvsp[0].literal); } -#line 3026 "parser.tab.c" /* yacc.c:1646 */ +#line 3027 "parser.tab.c" /* yacc.c:1646 */ break; case 202: -#line 799 "parser.y" /* yacc.c:1646 */ +#line 800 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); } -#line 3032 "parser.tab.c" /* yacc.c:1646 */ +#line 3033 "parser.tab.c" /* yacc.c:1646 */ break; case 203: -#line 800 "parser.y" /* yacc.c:1646 */ +#line 801 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = parse_regexp(ctx); if(!(yyval.literal)) YYABORT; } -#line 3039 "parser.tab.c" /* yacc.c:1646 */ +#line 3040 "parser.tab.c" /* yacc.c:1646 */ break; case 204: -#line 802 "parser.y" /* yacc.c:1646 */ +#line 803 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = parse_regexp(ctx); if(!(yyval.literal)) YYABORT; } -#line 3046 "parser.tab.c" /* yacc.c:1646 */ +#line 3047 "parser.tab.c" /* yacc.c:1646 */ break; case 205: -#line 807 "parser.y" /* yacc.c:1646 */ +#line 808 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_boolean_literal(ctx, VARIANT_TRUE); } -#line 3052 "parser.tab.c" /* yacc.c:1646 */ +#line 3053 "parser.tab.c" /* yacc.c:1646 */ break; case 206: -#line 808 "parser.y" /* yacc.c:1646 */ +#line 809 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = new_boolean_literal(ctx, VARIANT_FALSE); } -#line 3058 "parser.tab.c" /* yacc.c:1646 */ +#line 3059 "parser.tab.c" /* yacc.c:1646 */ break; case 207: -#line 809 "parser.y" /* yacc.c:1646 */ +#line 810 "parser.y" /* yacc.c:1646 */ { (yyval.literal) = (yyvsp[0].literal); } -#line 3064 "parser.tab.c" /* yacc.c:1646 */ +#line 3065 "parser.tab.c" /* yacc.c:1646 */ break; case 209: -#line 813 "parser.y" /* yacc.c:1646 */ +#line 814 "parser.y" /* yacc.c:1646 */ { if(!allow_auto_semicolon(ctx)) {YYABORT;} } -#line 3070 "parser.tab.c" /* yacc.c:1646 */ +#line 3071 "parser.tab.c" /* yacc.c:1646 */ break; case 211: -#line 817 "parser.y" /* yacc.c:1646 */ +#line 818 "parser.y" /* yacc.c:1646 */ { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; } -#line 3076 "parser.tab.c" /* yacc.c:1646 */ +#line 3077 "parser.tab.c" /* yacc.c:1646 */ break; case 213: -#line 821 "parser.y" /* yacc.c:1646 */ +#line 822 "parser.y" /* yacc.c:1646 */ { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; } -#line 3082 "parser.tab.c" /* yacc.c:1646 */ +#line 3083 "parser.tab.c" /* yacc.c:1646 */ break; case 215: -#line 825 "parser.y" /* yacc.c:1646 */ +#line 826 "parser.y" /* yacc.c:1646 */ { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; } -#line 3088 "parser.tab.c" /* yacc.c:1646 */ +#line 3089 "parser.tab.c" /* yacc.c:1646 */ break; -#line 3092 "parser.tab.c" /* yacc.c:1646 */ +#line 3093 "parser.tab.c" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -3311,7 +3311,7 @@ yyreturn: #endif return yyresult; } -#line 827 "parser.y" /* yacc.c:1906 */ +#line 828 "parser.y" /* yacc.c:1906 */ static BOOL allow_auto_semicolon(parser_ctx_t *ctx) diff --git a/reactos/dll/win32/jscript/parser.tab.h b/reactos/dll/win32/jscript/parser.tab.h index 0912321b01c..1f66563788c 100644 --- a/reactos/dll/win32/jscript/parser.tab.h +++ b/reactos/dll/win32/jscript/parser.tab.h @@ -97,7 +97,7 @@ extern int parser_debug; typedef union YYSTYPE YYSTYPE; union YYSTYPE { -#line 144 "parser.y" /* yacc.c:1909 */ +#line 145 "parser.y" /* yacc.c:1909 */ int ival; const WCHAR *srcptr; diff --git a/reactos/dll/win32/jscript/parser.y b/reactos/dll/win32/jscript/parser.y index 327366a7f8e..73cffd80ca6 100644 --- a/reactos/dll/win32/jscript/parser.y +++ b/reactos/dll/win32/jscript/parser.y @@ -19,11 +19,6 @@ %{ #include "jscript.h" -#include "engine.h" - -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(jscript); static int parser_error(parser_ctx_t*,const char*); static void set_error(parser_ctx_t*,UINT); diff --git a/reactos/dll/win32/jscript/resource.h b/reactos/dll/win32/jscript/resource.h index cfe0881eef5..f5184bd4839 100644 --- a/reactos/dll/win32/jscript/resource.h +++ b/reactos/dll/win32/jscript/resource.h @@ -34,6 +34,8 @@ #define IDS_SEMICOLON 0x03EC #define IDS_LBRACKET 0x03ED #define IDS_RBRACKET 0x03EE +#define IDS_EXPECTED_IDENTIFIER 0x03f2 +#define IDS_EXPECTED_ASSIGN 0x03f3 #define IDS_INVALID_CHAR 0x03F6 #define IDS_UNTERMINATED_STR 0x03F7 #define IDS_MISPLACED_RETURN 0x03FA @@ -41,7 +43,9 @@ #define IDS_INVALID_CONTINUE 0x03FC #define IDS_LABEL_REDEFINED 0x0401 #define IDS_LABEL_NOT_FOUND 0x0402 +#define IDS_EXPECTED_CCEND 0x0405 #define IDS_DISABLED_CC 0x0406 +#define IDS_EXPECTED_AT 0x0408 #define IDS_NOT_FUNC 0x138A #define IDS_NOT_DATE 0x138E #define IDS_NOT_NUM 0x1389 diff --git a/reactos/dll/win32/jscript/string.c b/reactos/dll/win32/jscript/string.c index e2df888faa8..501a2025233 100644 --- a/reactos/dll/win32/jscript/string.c +++ b/reactos/dll/win32/jscript/string.c @@ -60,9 +60,14 @@ static const WCHAR toLocaleUpperCaseW[] = {'t','o','L','o','c','a','l','e','U',' static const WCHAR localeCompareW[] = {'l','o','c','a','l','e','C','o','m','p','a','r','e',0}; static const WCHAR fromCharCodeW[] = {'f','r','o','m','C','h','a','r','C','o','d','e',0}; +static inline StringInstance *string_from_jsdisp(jsdisp_t *jsdisp) +{ + return CONTAINING_RECORD(jsdisp, StringInstance, dispex); +} + static inline StringInstance *string_from_vdisp(vdisp_t *vdisp) { - return (StringInstance*)vdisp->u.jsdisp; + return string_from_jsdisp(vdisp->u.jsdisp); } static inline StringInstance *string_this(vdisp_t *jsthis) @@ -98,26 +103,22 @@ static HRESULT get_string_flat_val(script_ctx_t *ctx, vdisp_t *jsthis, jsstr_t * return E_OUTOFMEMORY; } -static HRESULT String_length(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT String_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { + StringInstance *string = (StringInstance*)jsthis; + TRACE("%p\n", jsthis); - switch(flags) { - case DISPATCH_PROPERTYGET: { - StringInstance *string = string_from_vdisp(jsthis); - - *r = jsval_number(jsstr_length(string->str)); - break; - } - default: - FIXME("unimplemented flags %x\n", flags); - return E_NOTIMPL; - } - + *r = jsval_number(jsstr_length(string->str)); return S_OK; } +static HRESULT String_set_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value) +{ + FIXME("%p\n", jsthis); + return E_NOTIMPL; +} + static HRESULT stringobj_to_string(vdisp_t *jsthis, jsval_t *r) { StringInstance *string; @@ -1463,25 +1464,13 @@ static HRESULT String_localeCompare(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla return E_NOTIMPL; } -static HRESULT String_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, - jsval_t *r) +static HRESULT String_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) { - StringInstance *This = string_from_vdisp(jsthis); + StringInstance *This = (StringInstance*)jsthis; TRACE("\n"); - switch(flags) { - case INVOKE_FUNC: - return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL); - case DISPATCH_PROPERTYGET: { - *r = jsval_string(jsstr_addref(This->str)); - break; - } - default: - FIXME("flags %x\n", flags); - return E_NOTIMPL; - } - + *r = jsval_string(jsstr_addref(This->str)); return S_OK; } @@ -1536,7 +1525,7 @@ static const builtin_prop_t String_props[] = { {indexOfW, String_indexOf, PROPF_METHOD|2}, {italicsW, String_italics, PROPF_METHOD}, {lastIndexOfW, String_lastIndexOf, PROPF_METHOD|2}, - {lengthW, String_length, 0}, + {lengthW, NULL,0, String_get_length, String_set_length}, {linkW, String_link, PROPF_METHOD|1}, {localeCompareW, String_localeCompare, PROPF_METHOD|1}, {matchW, String_match, PROPF_METHOD|1}, @@ -1560,7 +1549,7 @@ static const builtin_prop_t String_props[] = { static const builtin_info_t String_info = { JSCLASS_STRING, - {NULL, String_value, 0}, + {NULL, NULL,0, String_get_value}, sizeof(String_props)/sizeof(*String_props), String_props, String_destructor, @@ -1568,12 +1557,12 @@ static const builtin_info_t String_info = { }; static const builtin_prop_t StringInst_props[] = { - {lengthW, String_length, 0} + {lengthW, NULL,0, String_get_length, String_set_length} }; static const builtin_info_t StringInst_info = { JSCLASS_STRING, - {NULL, String_value, 0}, + {NULL, NULL,0, String_get_value}, sizeof(StringInst_props)/sizeof(*StringInst_props), StringInst_props, String_destructor, @@ -1691,7 +1680,7 @@ static const builtin_prop_t StringConstr_props[] = { static const builtin_info_t StringConstr_info = { JSCLASS_FUNCTION, - {NULL, Function_value, 0}, + DEFAULT_FUNCTION_VALUE, sizeof(StringConstr_props)/sizeof(*StringConstr_props), StringConstr_props, NULL, diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE index 0b5ffb8e9fc..4fa8900770b 100644 --- a/reactos/media/doc/README.WINE +++ b/reactos/media/doc/README.WINE @@ -94,7 +94,7 @@ reactos/dll/win32/inseng # Synced to Wine-1.7.27 reactos/dll/win32/iphlpapi # Out of sync reactos/dll/win32/itircl # Synced to Wine-1.7.27 reactos/dll/win32/itss # Synced to Wine-1.7.27 -reactos/dll/win32/jscript # Synced to Wine-1.7.27 +reactos/dll/win32/jscript # Synced to WineStaging-1.7.37 reactos/dll/win32/jsproxy # Synced to Wine-1.7.27 reactos/dll/win32/loadperf # Synced to Wine-1.7.27 reactos/dll/win32/localspl # Synced to Wine-1.7.27