[JSCRIPT] Sync with Wine 10.0. CORE-20605

dll/win32/jscript/CMakeLists.txt

@@ -1,14 +1,10 @@
 
-add_definitions(
-    -D__WINESRC__
-    -D__ROS_LONG64__
-    -D_USE_MATH_DEFINES)
-
 spec2def(jscript.dll jscript.spec)
 
 list(APPEND SOURCE
     activex.c
     array.c
+    arraybuf.c
     bool.c
     compile.c
     date.c
@@ -30,21 +26,20 @@ list(APPEND SOURCE
     number.c
     object.c
     regexp.c
+    set.c
     string.c
     vbarray.c)
 
-BISON_TARGET(cc_parser cc_parser.y ${CMAKE_CURRENT_BINARY_DIR}/cc_parser.tab.c COMPILE_FLAGS "-p cc_parser_")
-BISON_TARGET(parser parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.tab.c COMPILE_FLAGS "-p parser_")
+BISON_TARGET(cc_parser cc_parser.y ${CMAKE_CURRENT_BINARY_DIR}/cc_parser.tab.c)
+BISON_TARGET(parser parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.tab.c)
 
 list(APPEND PCH_SKIP_SOURCE
+    guid.c
     ${BISON_cc_parser_OUTPUTS}
     ${BISON_parser_OUTPUTS})
 
 list(APPEND jscript_rc_deps
-    ${CMAKE_CURRENT_SOURCE_DIR}/jscript.rgs
-    ${CMAKE_CURRENT_SOURCE_DIR}/jscript_classes.rgs
-    ${CMAKE_CURRENT_SOURCE_DIR}/jsglobal.rgs
-    ${CMAKE_CURRENT_BINARY_DIR}/jsglobal.tlb)
+    ${CMAKE_CURRENT_SOURCE_DIR}/jscript.rgs)
 
 set_source_files_properties(rsrc.rc PROPERTIES OBJECT_DEPENDS "${jscript_rc_deps}")
 
@@ -54,8 +49,6 @@ add_library(jscript MODULE
     rsrc.rc
     ${CMAKE_CURRENT_BINARY_DIR}/jscript.def)
 
-target_compile_definitions(jscript PRIVATE _CRT_NON_CONFORMING_SWPRINTFS)
-
 if(MSVC)
     # Disable warning C4146: unary minus operator applied to unsigned type, result still unsigned
     # Disable warning C4267: '=': conversion from 'size_t' to 'WCHAR', possible loss of data
@@ -63,10 +56,13 @@ if(MSVC)
 endif()
 
 add_idl_headers(jscript_idlheader jscript_classes.idl)
-add_typelib(jsglobal.idl)
-add_dependencies(jscript jscript_idlheader stdole2)
+add_idl_headers(jscript_jsdisp_header jsdisp.idl)
+add_idl_reg_scripts(jscript registry jscript_classes.idl)
+add_idl_reg_scripts(jscript regtypelib jsglobal.idl)
+add_dependencies(jscript jscript_idlheader jscript_jsdisp_header stdole2)
 set_module_type(jscript win32dll)
-target_link_libraries(jscript uuid wine oldnames)
+target_link_libraries(jscript uuid wine oldnames wine_dll_register)
 add_importlibs(jscript user32 ole32 oleaut32 advapi32 msvcrt kernel32 ntdll)
 add_pch(jscript precomp.h "${PCH_SKIP_SOURCE}")
 add_cd_file(TARGET jscript DESTINATION reactos/system32 FOR all)
+set_wine_module_FIXME(jscript) # CORE-5743: No ARRAY_SIZE nor CONST_VTABLE

dll/win32/jscript/activex.c

@@ -138,7 +138,7 @@ static IUnknown *create_activex_object(script_ctx_t *ctx, const WCHAR *progid)
     return obj;
 }
 
-static HRESULT ActiveXObject_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT ActiveXObject_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t * progid_str;
@@ -156,7 +156,7 @@ static HRESULT ActiveXObject_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
 
     if(ctx->safeopt != (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER)
         && ctx->safeopt != INTERFACE_USES_DISPEX) {
-        FIXME("Unsupported safeopt %x\n", ctx->safeopt);
+        FIXME("Unsupported safeopt %lx\n", ctx->safeopt);
         return E_NOTIMPL;
     }
 
@@ -172,7 +172,7 @@ static HRESULT ActiveXObject_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
     obj = create_activex_object(ctx, progid);
     jsstr_release(progid_str);
     if(!obj)
-        return throw_generic_error(ctx, JS_E_CANNOT_CREATE_OBJ, NULL);
+        return JS_E_CANNOT_CREATE_OBJ;
 
     hres = IUnknown_QueryInterface(obj, &IID_IDispatch, (void**)&disp);
     IUnknown_Release(obj);
@@ -181,7 +181,8 @@ static HRESULT ActiveXObject_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
         return E_NOTIMPL;
     }
 
-    *r = jsval_disp(disp);
+    if(r) *r = jsval_disp(disp);
+    else  IDispatch_Release(disp);
     return S_OK;
 }
 
@@ -190,13 +191,11 @@ HRESULT create_activex_constr(script_ctx_t *ctx, jsdisp_t **ret)
     jsdisp_t *prototype;
     HRESULT hres;
 
-    static const WCHAR ActiveXObjectW[] = {'A','c','t','i','v','e','X','O','b','j','e','c','t',0};
-
     hres = create_object(ctx, NULL, &prototype);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_function(ctx, ActiveXObject_value, ActiveXObjectW, NULL,
+    hres = create_builtin_function(ctx, ActiveXObject_value, L"ActiveXObject", NULL,
             PROPF_CONSTR|1, prototype, ret);
 
     jsdisp_release(prototype);

dll/win32/jscript/arraybuf.c

@@ -0,0 +1,776 @@
+/*
+ * Copyright 2024 Gabriel Ivăncescu 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 <limits.h>
+
+#include "jscript.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(jscript);
+
+typedef struct {
+    jsdisp_t dispex;
+    DWORD size;
+/* FIXME: Inspect */
+#if defined(__REACTOS__) && defined(_MSC_VER)
+    DECLSPEC_ALIGN(8) BYTE buf[];
+#else
+    DECLSPEC_ALIGN(sizeof(double)) BYTE buf[];
+#endif
+} ArrayBufferInstance;
+
+typedef struct {
+    jsdisp_t dispex;
+
+    ArrayBufferInstance *buffer;
+    DWORD offset;
+    DWORD size;
+} DataViewInstance;
+
+static inline ArrayBufferInstance *arraybuf_from_jsdisp(jsdisp_t *jsdisp)
+{
+    return CONTAINING_RECORD(jsdisp, ArrayBufferInstance, dispex);
+}
+
+static inline DataViewInstance *dataview_from_jsdisp(jsdisp_t *jsdisp)
+{
+    return CONTAINING_RECORD(jsdisp, DataViewInstance, dispex);
+}
+
+static inline ArrayBufferInstance *arraybuf_this(jsval_t vthis)
+{
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_ARRAYBUFFER)) ? arraybuf_from_jsdisp(jsdisp) : NULL;
+}
+
+static HRESULT create_arraybuf(script_ctx_t*,DWORD,ArrayBufferInstance**);
+
+static HRESULT ArrayBuffer_get_byteLength(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
+{
+    TRACE("%p\n", jsthis);
+
+    *r = jsval_number(arraybuf_from_jsdisp(jsthis)->size);
+    return S_OK;
+}
+
+static HRESULT ArrayBuffer_slice(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    ArrayBufferInstance *arraybuf, *ret;
+    DWORD begin = 0, end, size;
+    HRESULT hres;
+    double n;
+
+    TRACE("\n");
+
+    if(!(arraybuf = arraybuf_this(vthis)))
+        return JS_E_ARRAYBUFFER_EXPECTED;
+    end = arraybuf->size;
+    if(!r)
+        return S_OK;
+
+    if(argc) {
+        hres = to_integer(ctx, argv[0], &n);
+        if(FAILED(hres))
+            return hres;
+        if(n < 0.0)
+            n += arraybuf->size;
+        if(n >= 0.0 && n < arraybuf->size) {
+            begin = n;
+            if(argc > 1 && !is_undefined(argv[1])) {
+                hres = to_integer(ctx, argv[1], &n);
+                if(FAILED(hres))
+                    return hres;
+                if(n < 0.0)
+                    n += arraybuf->size;
+                if(n >= 0.0) {
+                    end = n < arraybuf->size ? n : arraybuf->size;
+                    end = end < begin ? begin : end;
+                }else
+                    end = begin;
+            }
+        }else
+            end = 0;
+    }
+
+    size = end - begin;
+    hres = create_arraybuf(ctx, size, &ret);
+    if(FAILED(hres))
+        return hres;
+    memcpy(ret->buf, arraybuf->buf + begin, size);
+
+    *r = jsval_obj(&ret->dispex);
+    return S_OK;
+}
+
+static const builtin_prop_t ArrayBuffer_props[] = {
+    {L"byteLength",            NULL, 0,                    ArrayBuffer_get_byteLength},
+    {L"slice",                 ArrayBuffer_slice,          PROPF_METHOD|2},
+};
+
+static const builtin_info_t ArrayBuffer_info = {
+    .class     = JSCLASS_ARRAYBUFFER,
+    .props_cnt = ARRAY_SIZE(ArrayBuffer_props),
+    .props     = ArrayBuffer_props,
+};
+
+static const builtin_prop_t ArrayBufferInst_props[] = {
+    {L"byteLength",            NULL, 0,                    ArrayBuffer_get_byteLength},
+};
+
+static const builtin_info_t ArrayBufferInst_info = {
+    .class     = JSCLASS_ARRAYBUFFER,
+    .props_cnt = ARRAY_SIZE(ArrayBufferInst_props),
+    .props     = ArrayBufferInst_props,
+};
+
+static HRESULT create_arraybuf(script_ctx_t *ctx, DWORD size, ArrayBufferInstance **ret)
+{
+    ArrayBufferInstance *arraybuf;
+    HRESULT hres;
+
+    if(!(arraybuf = calloc(1, FIELD_OFFSET(ArrayBufferInstance, buf[size]))))
+        return E_OUTOFMEMORY;
+
+    hres = init_dispex_from_constr(&arraybuf->dispex, ctx, &ArrayBufferInst_info, ctx->arraybuf_constr);
+    if(FAILED(hres)) {
+        free(arraybuf);
+        return hres;
+    }
+    arraybuf->size = size;
+
+    *ret = arraybuf;
+    return S_OK;
+}
+
+static HRESULT ArrayBufferConstr_isView(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    FIXME("not implemented\n");
+
+    return E_NOTIMPL;
+}
+
+static HRESULT ArrayBufferConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    ArrayBufferInstance *arraybuf;
+    DWORD size = 0;
+    HRESULT hres;
+
+    TRACE("\n");
+
+    switch(flags) {
+    case DISPATCH_METHOD:
+    case DISPATCH_CONSTRUCT: {
+        if(argc) {
+            double n;
+            hres = to_integer(ctx, argv[0], &n);
+            if(FAILED(hres))
+                return hres;
+            if(n < 0.0)
+                return JS_E_INVALID_LENGTH;
+            if(n > (UINT_MAX - FIELD_OFFSET(ArrayBufferInstance, buf[0])))
+                return E_OUTOFMEMORY;
+            size = n;
+        }
+
+        if(r) {
+            hres = create_arraybuf(ctx, size, &arraybuf);
+            if(FAILED(hres))
+                return hres;
+            *r = jsval_obj(&arraybuf->dispex);
+        }
+        break;
+    }
+    default:
+        FIXME("unimplemented flags: %x\n", flags);
+        return E_NOTIMPL;
+    }
+
+    return S_OK;
+}
+
+static const builtin_prop_t ArrayBufferConstr_props[] = {
+    {L"isView",                ArrayBufferConstr_isView,   PROPF_METHOD|1},
+};
+
+static const builtin_info_t ArrayBufferConstr_info = {
+    .class     = JSCLASS_FUNCTION,
+    .call      = Function_value,
+    .props_cnt = ARRAY_SIZE(ArrayBufferConstr_props),
+    .props     = ArrayBufferConstr_props,
+};
+
+static inline DataViewInstance *dataview_this(jsval_t vthis)
+{
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_DATAVIEW)) ? dataview_from_jsdisp(jsdisp) : NULL;
+}
+
+static HRESULT DataView_get_buffer(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    DataViewInstance *view;
+
+    TRACE("\n");
+
+    if(!(view = dataview_this(vthis)))
+        return JS_E_NOT_DATAVIEW;
+    if(r) *r = jsval_obj(jsdisp_addref(&view->buffer->dispex));
+    return S_OK;
+}
+
+static HRESULT DataView_get_byteLength(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    DataViewInstance *view;
+
+    TRACE("\n");
+
+    if(!(view = dataview_this(vthis)))
+        return JS_E_NOT_DATAVIEW;
+    if(r) *r = jsval_number(view->size);
+    return S_OK;
+}
+
+static HRESULT DataView_get_byteOffset(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    DataViewInstance *view;
+
+    TRACE("\n");
+
+    if(!(view = dataview_this(vthis)))
+        return JS_E_NOT_DATAVIEW;
+    if(r) *r = jsval_number(view->offset);
+    return S_OK;
+}
+
+static inline void copy_type_data(void *dst, const void *src, unsigned type_size, BOOL little_endian)
+{
+    const BYTE *in = src;
+    BYTE *out = dst;
+    unsigned i;
+
+    if(little_endian)
+        memcpy(out, in, type_size);
+    else
+        for(i = 0; i < type_size; i++)
+            out[i] = in[type_size - i - 1];
+}
+
+static HRESULT get_data(script_ctx_t *ctx, jsval_t vthis, unsigned argc, jsval_t *argv, unsigned type_size, void *ret)
+{
+    BOOL little_endian = FALSE;
+    DataViewInstance *view;
+    HRESULT hres;
+    DWORD offset;
+    BYTE *data;
+    double n;
+
+    if(!(view = dataview_this(vthis)))
+        return JS_E_NOT_DATAVIEW;
+    if(!argc || is_undefined(argv[0]))
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+
+    hres = to_integer(ctx, argv[0], &n);
+    if(FAILED(hres))
+        return hres;
+
+    if(n < 0.0 || n + type_size > view->size)
+        return JS_E_DATAVIEW_INVALID_ACCESS;
+
+    offset = n;
+    data = &view->buffer->buf[view->offset + offset];
+
+    if(type_size == 1) {
+        *(BYTE*)ret = data[0];
+        return S_OK;
+    }
+
+    if(argc > 1) {
+        hres = to_boolean(argv[1], &little_endian);
+        if(FAILED(hres))
+            return hres;
+    }
+
+    copy_type_data(ret, data, type_size, little_endian);
+    return S_OK;
+}
+
+static HRESULT set_data(script_ctx_t *ctx, jsval_t vthis, unsigned argc, jsval_t *argv, unsigned type_size, const void *val)
+{
+    BOOL little_endian = FALSE;
+    DataViewInstance *view;
+    HRESULT hres;
+    DWORD offset;
+    BYTE *data;
+    double n;
+
+    if(!(view = dataview_this(vthis)))
+        return JS_E_NOT_DATAVIEW;
+    if(is_undefined(argv[0]) || is_undefined(argv[1]))
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+
+    hres = to_integer(ctx, argv[0], &n);
+    if(FAILED(hres))
+        return hres;
+
+    if(n < 0.0 || n + type_size > view->size)
+        return JS_E_DATAVIEW_INVALID_ACCESS;
+
+    offset = n;
+    data = &view->buffer->buf[view->offset + offset];
+
+    if(type_size == 1) {
+        data[0] = *(const BYTE*)val;
+        return S_OK;
+    }
+
+    if(argc > 2) {
+        hres = to_boolean(argv[2], &little_endian);
+        if(FAILED(hres))
+            return hres;
+    }
+
+    copy_type_data(data, val, type_size, little_endian);
+    return S_OK;
+}
+
+static HRESULT DataView_getFloat32(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    float v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getFloat64(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    double v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getInt8(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT8 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getInt16(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT16 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getInt32(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT32 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getUint8(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    UINT8 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getUint16(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    UINT16 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_getUint32(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    UINT32 v;
+
+    TRACE("\n");
+
+    hres = get_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_number(v);
+    return S_OK;
+}
+
+static HRESULT DataView_setFloat32(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    double n;
+    float v;
+
+    TRACE("\n");
+
+    if(argc < 2)
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+    hres = to_number(ctx, argv[1], &n);
+    if(FAILED(hres))
+        return hres;
+    v = n;  /* FIXME: don't assume rounding mode is round-to-nearest ties-to-even */
+
+    hres = set_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT DataView_setFloat64(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    double v;
+
+    TRACE("\n");
+
+    if(argc < 2)
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+    hres = to_number(ctx, argv[1], &v);
+    if(FAILED(hres))
+        return hres;
+
+    hres = set_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT DataView_setInt8(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT32 n;
+    INT8 v;
+
+    TRACE("\n");
+
+    if(argc < 2)
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+    hres = to_int32(ctx, argv[1], &n);
+    if(FAILED(hres))
+        return hres;
+    v = n;
+
+    hres = set_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT DataView_setInt16(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT32 n;
+    INT16 v;
+
+    TRACE("\n");
+
+    if(argc < 2)
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+    hres = to_int32(ctx, argv[1], &n);
+    if(FAILED(hres))
+        return hres;
+    v = n;
+
+    hres = set_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT DataView_setInt32(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    HRESULT hres;
+    INT32 v;
+
+    TRACE("\n");
+
+    if(argc < 2)
+        return JS_E_DATAVIEW_NO_ARGUMENT;
+    hres = to_int32(ctx, argv[1], &v);
+    if(FAILED(hres))
+        return hres;
+
+    hres = set_data(ctx, vthis, argc, argv, sizeof(v), &v);
+    if(FAILED(hres))
+        return hres;
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static const builtin_prop_t DataView_props[] = {
+    {L"getFloat32",            DataView_getFloat32,        PROPF_METHOD|1},
+    {L"getFloat64",            DataView_getFloat64,        PROPF_METHOD|1},
+    {L"getInt16",              DataView_getInt16,          PROPF_METHOD|1},
+    {L"getInt32",              DataView_getInt32,          PROPF_METHOD|1},
+    {L"getInt8",               DataView_getInt8,           PROPF_METHOD|1},
+    {L"getUint16",             DataView_getUint16,         PROPF_METHOD|1},
+    {L"getUint32",             DataView_getUint32,         PROPF_METHOD|1},
+    {L"getUint8",              DataView_getUint8,          PROPF_METHOD|1},
+    {L"setFloat32",            DataView_setFloat32,        PROPF_METHOD|1},
+    {L"setFloat64",            DataView_setFloat64,        PROPF_METHOD|1},
+    {L"setInt16",              DataView_setInt16,          PROPF_METHOD|1},
+    {L"setInt32",              DataView_setInt32,          PROPF_METHOD|1},
+    {L"setInt8",               DataView_setInt8,           PROPF_METHOD|1},
+    {L"setUint16",             DataView_setInt16,          PROPF_METHOD|1},
+    {L"setUint32",             DataView_setInt32,          PROPF_METHOD|1},
+    {L"setUint8",              DataView_setInt8,           PROPF_METHOD|1},
+};
+
+static void DataView_destructor(jsdisp_t *dispex)
+{
+    DataViewInstance *view = dataview_from_jsdisp(dispex);
+    if(view->buffer)
+        jsdisp_release(&view->buffer->dispex);
+}
+
+static HRESULT DataView_gc_traverse(struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
+{
+    DataViewInstance *view = dataview_from_jsdisp(dispex);
+    return gc_process_linked_obj(gc_ctx, op, dispex, &view->buffer->dispex, (void**)&view->buffer);
+}
+
+static const builtin_info_t DataView_info = {
+    .class       = JSCLASS_DATAVIEW,
+    .props_cnt   = ARRAY_SIZE(DataView_props),
+    .props       = DataView_props,
+    .destructor  = DataView_destructor,
+    .gc_traverse = DataView_gc_traverse
+};
+
+static const builtin_info_t DataViewInst_info = {
+    .class       = JSCLASS_DATAVIEW,
+    .destructor  = DataView_destructor,
+    .gc_traverse = DataView_gc_traverse
+};
+
+static HRESULT DataViewConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    ArrayBufferInstance *arraybuf;
+    DataViewInstance *view;
+    DWORD offset = 0, size;
+    HRESULT hres;
+
+    TRACE("\n");
+
+    switch(flags) {
+    case DISPATCH_METHOD:
+    case DISPATCH_CONSTRUCT: {
+        if(!argc || !(arraybuf = arraybuf_this(argv[0])))
+            return JS_E_DATAVIEW_NO_ARGUMENT;
+        size = arraybuf->size;
+
+        if(argc > 1) {
+            double offs, len, maxsize = size;
+            hres = to_integer(ctx, argv[1], &offs);
+            if(FAILED(hres))
+                return hres;
+            if(offs < 0.0 || offs > maxsize)
+                return JS_E_DATAVIEW_INVALID_OFFSET;
+            offset = offs;
+
+            if(argc > 2 && !is_undefined(argv[2])) {
+                hres = to_integer(ctx, argv[2], &len);
+                if(FAILED(hres))
+                    return hres;
+                if(len < 0.0 || offs+len > maxsize)
+                    return JS_E_DATAVIEW_INVALID_OFFSET;
+                size = len;
+            }else
+                size -= offset;
+        }
+
+        if(!r)
+            return S_OK;
+
+        if(!(view = calloc(1, sizeof(DataViewInstance))))
+            return E_OUTOFMEMORY;
+
+        hres = init_dispex_from_constr(&view->dispex, ctx, &DataViewInst_info, ctx->dataview_constr);
+        if(FAILED(hres)) {
+            free(view);
+            return hres;
+        }
+
+        jsdisp_addref(&arraybuf->dispex);
+        view->buffer = arraybuf;
+        view->offset = offset;
+        view->size = size;
+
+        *r = jsval_obj(&view->dispex);
+        break;
+    }
+    default:
+        FIXME("unimplemented flags: %x\n", flags);
+        return E_NOTIMPL;
+    }
+
+    return S_OK;
+}
+
+static const builtin_info_t DataViewConstr_info = {
+    .class = JSCLASS_FUNCTION,
+    .call  = Function_value,
+};
+
+HRESULT init_arraybuf_constructors(script_ctx_t *ctx)
+{
+    static const struct {
+        const WCHAR *name;
+        builtin_invoke_t get;
+    } DataView_getters[] = {
+        { L"buffer",        DataView_get_buffer },
+        { L"byteLength",    DataView_get_byteLength },
+        { L"byteOffset",    DataView_get_byteOffset },
+    };
+    ArrayBufferInstance *arraybuf;
+    DataViewInstance *view;
+    property_desc_t desc;
+    HRESULT hres;
+    unsigned i;
+
+    if(ctx->version < SCRIPTLANGUAGEVERSION_ES5)
+        return S_OK;
+
+    if(!(arraybuf = calloc(1, FIELD_OFFSET(ArrayBufferInstance, buf[0]))))
+        return E_OUTOFMEMORY;
+
+    hres = init_dispex(&arraybuf->dispex, ctx, &ArrayBuffer_info, ctx->object_prototype);
+    if(FAILED(hres)) {
+        free(arraybuf);
+        return hres;
+    }
+
+    hres = create_builtin_constructor(ctx, ArrayBufferConstr_value, L"ArrayBuffer", &ArrayBufferConstr_info,
+                                      PROPF_CONSTR|1, &arraybuf->dispex, &ctx->arraybuf_constr);
+    jsdisp_release(&arraybuf->dispex);
+    if(FAILED(hres))
+        return hres;
+
+    hres = jsdisp_define_data_property(ctx->global, L"ArrayBuffer", PROPF_CONFIGURABLE | PROPF_WRITABLE,
+                                       jsval_obj(ctx->arraybuf_constr));
+    if(FAILED(hres))
+        return hres;
+
+    if(!(view = calloc(1, sizeof(DataViewInstance))))
+        return E_OUTOFMEMORY;
+
+    hres = create_arraybuf(ctx, 0, &view->buffer);
+    if(FAILED(hres)) {
+        free(view);
+        return hres;
+    }
+
+    hres = init_dispex(&view->dispex, ctx, &DataView_info, ctx->object_prototype);
+    if(FAILED(hres)) {
+        jsdisp_release(&view->buffer->dispex);
+        free(view);
+        return hres;
+    }
+
+    desc.flags = PROPF_CONFIGURABLE;
+    desc.mask  = PROPF_CONFIGURABLE | PROPF_ENUMERABLE;
+    desc.explicit_getter = desc.explicit_setter = TRUE;
+    desc.explicit_value = FALSE;
+    desc.setter = NULL;
+
+    /* FIXME: If we find we need builtin accessors in other places, we should consider a more generic solution */
+    for(i = 0; i < ARRAY_SIZE(DataView_getters); i++) {
+        hres = create_builtin_function(ctx, DataView_getters[i].get, NULL, NULL, PROPF_METHOD, NULL, &desc.getter);
+        if(SUCCEEDED(hres)) {
+            hres = jsdisp_define_property(&view->dispex, DataView_getters[i].name, &desc);
+            jsdisp_release(desc.getter);
+        }
+        if(FAILED(hres)) {
+            jsdisp_release(&view->dispex);
+            return hres;
+        }
+    }
+
+    hres = create_builtin_constructor(ctx, DataViewConstr_value, L"DataView", &DataViewConstr_info,
+                                      PROPF_CONSTR|1, &view->dispex, &ctx->dataview_constr);
+    jsdisp_release(&view->dispex);
+    if(FAILED(hres))
+        return hres;
+
+    hres = jsdisp_define_data_property(ctx->global, L"DataView", PROPF_CONFIGURABLE | PROPF_WRITABLE,
+                                       jsval_obj(ctx->dataview_constr));
+
+    return hres;
+}

dll/win32/jscript/bool.c

@@ -31,22 +31,21 @@ typedef struct {
     BOOL val;
 } BoolInstance;
 
-static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
-
 static inline BoolInstance *bool_from_jsdisp(jsdisp_t *jsdisp)
 {
     return CONTAINING_RECORD(jsdisp, BoolInstance, dispex);
 }
 
-static inline BoolInstance *bool_from_vdisp(vdisp_t *vdisp)
+static inline HRESULT boolval_this(jsval_t vthis, BOOL *ret)
 {
-    return bool_from_jsdisp(vdisp->u.jsdisp);
-}
-
-static inline BoolInstance *bool_this(vdisp_t *jsthis)
-{
-    return is_vclass(jsthis, JSCLASS_BOOLEAN) ? bool_from_vdisp(jsthis) : NULL;
+    jsdisp_t *jsdisp;
+    if(is_bool(vthis))
+        *ret = get_bool(vthis);
+    else if(is_object_instance(vthis) && (jsdisp = to_jsdisp(get_object(vthis))) && is_class(jsdisp, JSCLASS_BOOLEAN))
+        *ret = bool_from_jsdisp(jsdisp)->val;
+    else
+        return JS_E_BOOLEAN_EXPECTED;
+    return S_OK;
 }
 
 BOOL bool_obj_value(jsdisp_t *obj)
@@ -56,22 +55,21 @@ BOOL bool_obj_value(jsdisp_t *obj)
 }
 
 /* ECMA-262 3rd Edition    15.6.4.2 */
-static HRESULT Bool_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+static HRESULT Bool_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    BoolInstance *bool;
-
-    static const WCHAR trueW[] = {'t','r','u','e',0};
-    static const WCHAR falseW[] = {'f','a','l','s','e',0};
+    BOOL boolval;
+    HRESULT hres;
 
     TRACE("\n");
 
-    if(!(bool = bool_this(jsthis)))
-        return throw_type_error(ctx, JS_E_BOOLEAN_EXPECTED, NULL);
+    hres = boolval_this(vthis, &boolval);
+    if(FAILED(hres))
+        return hres;
 
     if(r) {
         jsstr_t *val;
 
-        val = jsstr_alloc(bool->val ? trueW : falseW);
+        val = jsstr_alloc(boolval ? L"true" : L"false");
         if(!val)
             return E_OUTOFMEMORY;
 
@@ -82,28 +80,30 @@ static HRESULT Bool_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 }
 
 /* ECMA-262 3rd Edition    15.6.4.3 */
-static HRESULT Bool_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+static HRESULT Bool_valueOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    BoolInstance *bool;
+    BOOL boolval;
+    HRESULT hres;
 
     TRACE("\n");
 
-    if(!(bool = bool_this(jsthis)))
-        return throw_type_error(ctx, JS_E_BOOLEAN_EXPECTED, NULL);
+    hres = boolval_this(vthis, &boolval);
+    if(FAILED(hres))
+        return hres;
 
     if(r)
-        *r = jsval_bool(bool->val);
+        *r = jsval_bool(boolval);
     return S_OK;
 }
 
-static HRESULT Bool_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Bool_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
 
     switch(flags) {
     case INVOKE_FUNC:
-        return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
+        return JS_E_FUNCTION_EXPECTED;
     default:
         FIXME("unimplemented flags %x\n", flags);
         return E_NOTIMPL;
@@ -114,28 +114,23 @@ static HRESULT Bool_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsign
 }
 
 static const builtin_prop_t Bool_props[] = {
-    {toStringW,              Bool_toString,             PROPF_METHOD},
-    {valueOfW,               Bool_valueOf,              PROPF_METHOD}
+    {L"toString",            Bool_toString,             PROPF_METHOD},
+    {L"valueOf",             Bool_valueOf,              PROPF_METHOD}
 };
 
 static const builtin_info_t Bool_info = {
-    JSCLASS_BOOLEAN,
-    {NULL, Bool_value, 0},
-    ARRAY_SIZE(Bool_props),
-    Bool_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_BOOLEAN,
+    .call      = Bool_value,
+    .props_cnt = ARRAY_SIZE(Bool_props),
+    .props     = Bool_props,
 };
 
 static const builtin_info_t BoolInst_info = {
-    JSCLASS_BOOLEAN,
-    {NULL, Bool_value, 0},
-    0, NULL,
-    NULL,
-    NULL
+    .class = JSCLASS_BOOLEAN,
+    .call  = Bool_value,
 };
 
-static HRESULT BoolConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT BoolConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     BOOL value = FALSE;
@@ -149,13 +144,16 @@ static HRESULT BoolConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 
     switch(flags) {
     case DISPATCH_CONSTRUCT: {
-        jsdisp_t *bool;
+        jsdisp_t *b;
 
-        hres = create_bool(ctx, value, &bool);
+        if(!r)
+            return S_OK;
+
+        hres = create_bool(ctx, value, &b);
         if(FAILED(hres))
             return hres;
 
-        *r = jsval_obj(bool);
+        *r = jsval_obj(b);
         return S_OK;
     }
 
@@ -174,56 +172,54 @@ static HRESULT BoolConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 
 static HRESULT alloc_bool(script_ctx_t *ctx, jsdisp_t *object_prototype, BoolInstance **ret)
 {
-    BoolInstance *bool;
+    BoolInstance *b;
     HRESULT hres;
 
-    bool = heap_alloc_zero(sizeof(BoolInstance));
-    if(!bool)
+    b = calloc(1, sizeof(BoolInstance));
+    if(!b)
         return E_OUTOFMEMORY;
 
     if(object_prototype)
-        hres = init_dispex(&bool->dispex, ctx, &Bool_info, object_prototype);
+        hres = init_dispex(&b->dispex, ctx, &Bool_info, object_prototype);
     else
-        hres = init_dispex_from_constr(&bool->dispex, ctx, &BoolInst_info, ctx->bool_constr);
+        hres = init_dispex_from_constr(&b->dispex, ctx, &BoolInst_info, ctx->bool_constr);
 
     if(FAILED(hres)) {
-        heap_free(bool);
+        free(b);
         return hres;
     }
 
-    *ret = bool;
+    *ret = b;
     return S_OK;
 }
 
 HRESULT create_bool_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
 {
-    BoolInstance *bool;
+    BoolInstance *b;
     HRESULT hres;
 
-    static const WCHAR BooleanW[] = {'B','o','o','l','e','a','n',0};
-
-    hres = alloc_bool(ctx, object_prototype, &bool);
+    hres = alloc_bool(ctx, object_prototype, &b);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_constructor(ctx, BoolConstr_value, BooleanW, NULL,
-            PROPF_CONSTR|1, &bool->dispex, ret);
+    hres = create_builtin_constructor(ctx, BoolConstr_value, L"Boolean", NULL,
+            PROPF_CONSTR|1, &b->dispex, ret);
 
-    jsdisp_release(&bool->dispex);
+    jsdisp_release(&b->dispex);
     return hres;
 }
 
-HRESULT create_bool(script_ctx_t *ctx, BOOL b, jsdisp_t **ret)
+HRESULT create_bool(script_ctx_t *ctx, BOOL bval, jsdisp_t **ret)
 {
-    BoolInstance *bool;
+    BoolInstance *b;
     HRESULT hres;
 
-    hres = alloc_bool(ctx, NULL, &bool);
+    hres = alloc_bool(ctx, NULL, &b);
     if(FAILED(hres))
         return hres;
 
-    bool->val = b;
+    b->val = bval;
 
-    *ret = &bool->dispex;
+    *ret = &b->dispex;
     return S_OK;
 }

dll/win32/jscript/cc_parser.y

@@ -30,6 +30,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
 %lex-param { parser_ctx_t *ctx }
 %parse-param { parser_ctx_t *ctx }
+%define api.prefix {cc_parser_}
 %define api.pure
 %start CCExpr
 
@@ -143,7 +144,9 @@ static int cc_parser_lex(void *lval, parser_ctx_t *ctx)
 /* FIXME: Implement missing expressions. */
 
 CCExpr
-    : CCUnaryExpression { ctx->ccval = $1; YYACCEPT; }
+    : CCUnaryExpression { ctx->ccval = $1;
+                          (void)cc_parser_nerrs; /* avoid unused variable warning */
+                          YYACCEPT; }
 
 CCUnaryExpression
     : tCCValue                      { $$ = $1; }
@@ -161,7 +164,7 @@ CCLogicalORExpression
 CCLogicalANDExpression
     : CCBitwiseORExpression         { $$ = $1; }
     | CCBitwiseANDExpression tAND CCBitwiseORExpression
-                                    { FIXME("'&&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
+                                    { $$ = ccval_bool(get_ccbool($1) && get_ccbool($3)); }
 
 CCBitwiseORExpression
     : CCBitwiseXORExpression        { $$ = $1; }

dll/win32/jscript/decode.c

@@ -113,14 +113,14 @@ HRESULT decode_source(WCHAR *code)
     const WCHAR *src = code;
     WCHAR *dst = code;
 
-    static const WCHAR decode_beginW[] = {'#','@','~','^'};
-    static const WCHAR decode_endW[] = {'^','#','~','@'};
+    static const WCHAR decode_beginW[] = L"#@~^";
+    static const WCHAR decode_endW[] = L"^#~@";
 
     while(*src) {
-        if(!wcsncmp(src, decode_beginW, ARRAY_SIZE(decode_beginW))) {
+        if(!wcsncmp(src, decode_beginW, ARRAY_SIZE(decode_beginW)-1)) {
             DWORD len, i, j=0, csum, s=0;
 
-            src += ARRAY_SIZE(decode_beginW);
+            src += ARRAY_SIZE(decode_beginW) - 1;
 
             if(!decode_dword(src, &len))
                 return JS_E_INVALID_CHAR;
@@ -165,9 +165,9 @@ HRESULT decode_source(WCHAR *code)
                 return JS_E_INVALID_CHAR;
             src += 8;
 
-            if(wcsncmp(src, decode_endW, ARRAY_SIZE(decode_endW)))
+            if(wcsncmp(src, decode_endW, ARRAY_SIZE(decode_endW)-1))
                 return JS_E_INVALID_CHAR;
-            src += ARRAY_SIZE(decode_endW);
+            src += ARRAY_SIZE(decode_endW) - 1;
         }else {
             *dst++ = *src++;
         }

dll/win32/jscript/engine.h

@@ -27,6 +27,7 @@
     X(bool,       1, ARG_INT,    0)        \
     X(bneg,       1, 0,0)                  \
     X(call,       1, ARG_UINT,   ARG_UINT) \
+    X(call_eval,  1, ARG_UINT,   ARG_UINT) \
     X(call_member,1, ARG_UINT,   ARG_UINT) \
     X(carray,     1, ARG_UINT,   0)        \
     X(carray_set, 1, ARG_UINT,   0)        \
@@ -77,7 +78,8 @@
     X(preinc,     1, ARG_INT,    0)        \
     X(push_acc,   1, 0,0)                  \
     X(push_except,1, ARG_ADDR,   ARG_UINT) \
-    X(push_scope, 1, 0,0)                  \
+    X(push_block_scope, 1, ARG_UINT, 0)    \
+    X(push_with_scope,  1, 0,0)            \
     X(regexp,     1, ARG_STR,    ARG_UINT) \
     X(rshift,     1, 0,0)                  \
     X(rshift2,    1, 0,0)                  \
@@ -92,8 +94,10 @@
     X(typeofident,1, 0,0)                  \
     X(refval,     1, 0,0)                  \
     X(ret,        0, ARG_UINT,   0)        \
+    X(set_member, 1, 0,0)                  \
     X(setret,     1, 0,0)                  \
     X(sub,        1, 0,0)                  \
+    X(to_string,  1, 0,0)                  \
     X(undefined,  1, 0,0)                  \
     X(void,       1, 0,0)                  \
     X(xor,        1, 0,0)
@@ -105,6 +109,8 @@ OP_LIST
     OP_LAST
 } jsop_t;
 
+typedef struct _bytecode_t bytecode_t;
+
 typedef union {
     BSTR bstr;
     LONG lng;
@@ -125,6 +131,7 @@ typedef enum {
 
 typedef struct {
     jsop_t op;
+    unsigned loc;
     union {
         instr_arg_t arg[2];
         double dbl;
@@ -142,6 +149,13 @@ typedef struct {
     int ref;
 } local_ref_t;
 
+#define INVALID_LOCAL_REF 0x7fffffff
+
+typedef struct {
+    unsigned locals_cnt;
+    local_ref_t *locals;
+} local_ref_scopes_t;
+
 typedef struct _function_code_t {
     BSTR name;
     int local_ref;
@@ -163,21 +177,30 @@ typedef struct _function_code_t {
     unsigned param_cnt;
     BSTR *params;
 
-    unsigned locals_cnt;
-    local_ref_t *locals;
+    local_ref_scopes_t *local_scopes;
+    unsigned local_scope_count;
+
+    unsigned int scope_index; /* index of scope in the parent function where the function is defined */
+
+    bytecode_t *bytecode;
 } function_code_t;
 
-local_ref_t *lookup_local(const function_code_t*,const WCHAR*) DECLSPEC_HIDDEN;
+IDispatch *lookup_global_host(script_ctx_t*);
+local_ref_t *lookup_local(const function_code_t*,const WCHAR*,unsigned int);
 
-typedef struct _bytecode_t {
+struct _bytecode_t {
     LONG ref;
+    BOOL is_persistent;
 
     instr_t *instrs;
     heap_pool_t heap;
 
     function_code_t global_code;
+    named_item_t *named_item;
 
     WCHAR *source;
+    UINT64 source_context;
+    unsigned start_line;
 
     BSTR *bstr_pool;
     unsigned bstr_pool_size;
@@ -187,11 +210,13 @@ typedef struct _bytecode_t {
     unsigned str_pool_size;
     unsigned str_cnt;
 
-    struct _bytecode_t *next;
-} bytecode_t;
+    struct list entry;
+};
 
-HRESULT compile_script(script_ctx_t*,const WCHAR*,const WCHAR*,const WCHAR*,BOOL,BOOL,bytecode_t**) DECLSPEC_HIDDEN;
-void release_bytecode(bytecode_t*) DECLSPEC_HIDDEN;
+HRESULT compile_script(script_ctx_t*,const WCHAR*,UINT64,unsigned,const WCHAR*,const WCHAR*,BOOL,BOOL,named_item_t*,bytecode_t**);
+void release_bytecode(bytecode_t*);
+
+unsigned get_location_line(bytecode_t *code, unsigned loc, unsigned *char_pos);
 
 static inline bytecode_t *bytecode_addref(bytecode_t *code)
 {
@@ -199,22 +224,54 @@ static inline bytecode_t *bytecode_addref(bytecode_t *code)
     return code;
 }
 
+struct vars_buffer {
+    function_code_t *func_code;
+    unsigned argc;
+    jsval_t var[];
+};
+
 typedef struct _scope_chain_t {
-    LONG ref;
-    jsdisp_t *jsobj;
+    jsdisp_t dispex;
     IDispatch *obj;
+    unsigned int scope_index;
+    struct vars_buffer *detached_vars;
     struct _call_frame_t *frame;
     struct _scope_chain_t *next;
 } scope_chain_t;
 
-void scope_release(scope_chain_t*) DECLSPEC_HIDDEN;
-
 static inline scope_chain_t *scope_addref(scope_chain_t *scope)
 {
-    scope->ref++;
+    jsdisp_addref(&scope->dispex);
     return scope;
 }
 
+static inline void scope_release(scope_chain_t *scope)
+{
+    jsdisp_release(&scope->dispex);
+}
+
+struct _jsexcept_t {
+    HRESULT error;
+
+    BOOL valid_value;
+    jsval_t value;
+
+    jsstr_t *source;
+    jsstr_t *message;
+    jsstr_t *line;
+
+    bytecode_t *code;
+    unsigned loc;
+
+    BOOL enter_notified;
+    jsexcept_t *prev;
+};
+
+void enter_script(script_ctx_t*,jsexcept_t*);
+HRESULT leave_script(script_ctx_t*,HRESULT);
+void reset_ei(jsexcept_t*);
+void set_error_location(jsexcept_t*,bytecode_t*,unsigned,unsigned,jsstr_t*);
+
 typedef struct _except_frame_t except_frame_t;
 struct _parser_ctx_t;
 
@@ -251,8 +308,8 @@ typedef struct _call_frame_t {
 #define EXEC_EVAL              0x0008
 
 HRESULT exec_source(script_ctx_t*,DWORD,bytecode_t*,function_code_t*,scope_chain_t*,IDispatch*,
-        jsdisp_t*,jsdisp_t*,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
+        jsdisp_t*,unsigned,jsval_t*,jsval_t*);
 
-HRESULT create_source_function(script_ctx_t*,bytecode_t*,function_code_t*,scope_chain_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT setup_arguments_object(script_ctx_t*,call_frame_t*) DECLSPEC_HIDDEN;
-void detach_arguments_object(jsdisp_t*) DECLSPEC_HIDDEN;
+HRESULT create_source_function(script_ctx_t*,bytecode_t*,function_code_t*,scope_chain_t*,jsdisp_t**);
+HRESULT setup_arguments_object(script_ctx_t*,call_frame_t*);
+void detach_arguments_object(call_frame_t*);

dll/win32/jscript/enumerator.c

@@ -33,27 +33,18 @@ typedef struct {
     BOOL atend;
 } EnumeratorInstance;
 
-static const WCHAR atEndW[] = {'a','t','E','n','d',0};
-static const WCHAR itemW[] = {'i','t','e','m',0};
-static const WCHAR moveFirstW[] = {'m','o','v','e','F','i','r','s','t',0};
-static const WCHAR moveNextW[] = {'m','o','v','e','N','e','x','t',0};
-
 static inline EnumeratorInstance *enumerator_from_jsdisp(jsdisp_t *jsdisp)
 {
     return CONTAINING_RECORD(jsdisp, EnumeratorInstance, dispex);
 }
 
-static inline EnumeratorInstance *enumerator_from_vdisp(vdisp_t *vdisp)
+static inline EnumeratorInstance *enumerator_this(jsval_t vthis)
 {
-    return enumerator_from_jsdisp(vdisp->u.jsdisp);
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_ENUMERATOR)) ? enumerator_from_jsdisp(jsdisp) : NULL;
 }
 
-static inline EnumeratorInstance *enumerator_this(vdisp_t *jsthis)
-{
-    return is_vclass(jsthis, JSCLASS_ENUMERATOR) ? enumerator_from_vdisp(jsthis) : NULL;
-}
-
-static inline HRESULT enumvar_get_next_item(EnumeratorInstance *This)
+static inline HRESULT enumvar_get_next_item(EnumeratorInstance *This, script_ctx_t *ctx)
 {
     HRESULT hres;
     VARIANT nextitem;
@@ -69,7 +60,7 @@ static inline HRESULT enumvar_get_next_item(EnumeratorInstance *This)
     hres = IEnumVARIANT_Next(This->enumvar, 1, &nextitem, NULL);
     if (hres == S_OK)
     {
-        hres = variant_to_jsval(&nextitem, &This->item);
+        hres = variant_to_jsval(ctx, &nextitem, &This->item);
         VariantClear(&nextitem);
         if (FAILED(hres))
         {
@@ -93,17 +84,23 @@ static void Enumerator_destructor(jsdisp_t *dispex)
 
     TRACE("\n");
 
+    if(This->enumvar)
+        IEnumVARIANT_Release(This->enumvar);
     jsval_release(This->item);
-    heap_free(dispex);
 }
 
-static HRESULT Enumerator_atEnd(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Enumerator_gc_traverse(struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
+{
+    return gc_process_linked_val(gc_ctx, op, dispex, &enumerator_from_jsdisp(dispex)->item);
+}
+
+static HRESULT Enumerator_atEnd(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     EnumeratorInstance *This;
 
-    if (!(This = enumerator_this(jsthis)))
-        return throw_type_error(ctx, JS_E_ENUMERATOR_EXPECTED, NULL);
+    if (!(This = enumerator_this(vthis)))
+        return JS_E_ENUMERATOR_EXPECTED;
 
     TRACE("%d\n", This->atend);
 
@@ -112,20 +109,20 @@ static HRESULT Enumerator_atEnd(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
     return S_OK;
 }
 
-static HRESULT Enumerator_item(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Enumerator_item(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     EnumeratorInstance *This;
 
     TRACE("\n");
 
-    if (!(This = enumerator_this(jsthis)))
-        return throw_type_error(ctx, JS_E_ENUMERATOR_EXPECTED, NULL);
+    if (!(This = enumerator_this(vthis)))
+        return JS_E_ENUMERATOR_EXPECTED;
 
     return r ? jsval_copy(This->item, r) : S_OK;
 }
 
-static HRESULT Enumerator_moveFirst(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Enumerator_moveFirst(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     EnumeratorInstance *This;
@@ -133,8 +130,8 @@ static HRESULT Enumerator_moveFirst(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
 
     TRACE("\n");
 
-    if (!(This = enumerator_this(jsthis)))
-        return throw_type_error(ctx, JS_E_ENUMERATOR_EXPECTED, NULL);
+    if (!(This = enumerator_this(vthis)))
+        return JS_E_ENUMERATOR_EXPECTED;
 
     if (This->enumvar)
     {
@@ -143,7 +140,7 @@ static HRESULT Enumerator_moveFirst(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
             return hres;
 
         This->atend = FALSE;
-        hres = enumvar_get_next_item(This);
+        hres = enumvar_get_next_item(This, ctx);
         if(FAILED(hres))
             return hres;
     }
@@ -153,7 +150,7 @@ static HRESULT Enumerator_moveFirst(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
     return S_OK;
 }
 
-static HRESULT Enumerator_moveNext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Enumerator_moveNext(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     EnumeratorInstance *This;
@@ -161,12 +158,12 @@ static HRESULT Enumerator_moveNext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
 
     TRACE("\n");
 
-    if (!(This = enumerator_this(jsthis)))
-        return throw_type_error(ctx, JS_E_ENUMERATOR_EXPECTED, NULL);
+    if (!(This = enumerator_this(vthis)))
+        return JS_E_ENUMERATOR_EXPECTED;
 
     if (This->enumvar)
     {
-        hres = enumvar_get_next_item(This);
+        hres = enumvar_get_next_item(This, ctx);
         if (FAILED(hres))
             return hres;
     }
@@ -177,28 +174,22 @@ static HRESULT Enumerator_moveNext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
 }
 
 static const builtin_prop_t Enumerator_props[] = {
-    {atEndW,     Enumerator_atEnd,     PROPF_METHOD},
-    {itemW,      Enumerator_item,      PROPF_METHOD},
-    {moveFirstW, Enumerator_moveFirst, PROPF_METHOD},
-    {moveNextW,  Enumerator_moveNext,  PROPF_METHOD},
+    {L"atEnd",     Enumerator_atEnd,     PROPF_METHOD},
+    {L"item",      Enumerator_item,      PROPF_METHOD},
+    {L"moveFirst", Enumerator_moveFirst, PROPF_METHOD},
+    {L"moveNext",  Enumerator_moveNext,  PROPF_METHOD},
 };
 
 static const builtin_info_t Enumerator_info = {
-    JSCLASS_ENUMERATOR,
-    {NULL, NULL, 0},
-    ARRAY_SIZE(Enumerator_props),
-    Enumerator_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_ENUMERATOR,
+    .props_cnt = ARRAY_SIZE(Enumerator_props),
+    .props     = Enumerator_props,
 };
 
 static const builtin_info_t EnumeratorInst_info = {
-    JSCLASS_ENUMERATOR,
-    {NULL, NULL, 0, NULL},
-    0,
-    NULL,
-    Enumerator_destructor,
-    NULL
+    .class       = JSCLASS_ENUMERATOR,
+    .destructor  = Enumerator_destructor,
+    .gc_traverse = Enumerator_gc_traverse
 };
 
 static HRESULT alloc_enumerator(script_ctx_t *ctx, jsdisp_t *object_prototype, EnumeratorInstance **ret)
@@ -206,7 +197,7 @@ static HRESULT alloc_enumerator(script_ctx_t *ctx, jsdisp_t *object_prototype, E
     EnumeratorInstance *enumerator;
     HRESULT hres;
 
-    enumerator = heap_alloc_zero(sizeof(EnumeratorInstance));
+    enumerator = calloc(1, sizeof(EnumeratorInstance));
     if(!enumerator)
         return E_OUTOFMEMORY;
 
@@ -218,7 +209,7 @@ static HRESULT alloc_enumerator(script_ctx_t *ctx, jsdisp_t *object_prototype, E
 
     if(FAILED(hres))
     {
-        heap_free(enumerator);
+        free(enumerator);
         return hres;
     }
 
@@ -249,11 +240,11 @@ static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **re
         /* Try to get a IEnumVARIANT by _NewEnum */
         VariantInit(&varresult);
         hres = IDispatch_Invoke(obj, DISPID_NEWENUM, &IID_NULL, LOCALE_NEUTRAL,
-                DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
+                DISPATCH_METHOD | DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
         if (FAILED(hres))
         {
             WARN("Enumerator: no DISPID_NEWENUM.\n");
-            return E_INVALIDARG;
+            return JS_E_OBJECT_NOT_COLLECTION;
         }
 
         if ((V_VT(&varresult) == VT_DISPATCH) || (V_VT(&varresult) == VT_UNKNOWN))
@@ -264,7 +255,7 @@ static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **re
         else
         {
             FIXME("Enumerator: NewEnum unexpected type of varresult (%d).\n", V_VT(&varresult));
-            hres = E_INVALIDARG;
+            hres = JS_E_OBJECT_NOT_COLLECTION;
         }
         VariantClear(&varresult);
         if (FAILED(hres))
@@ -281,7 +272,7 @@ static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **re
 
     enumerator->enumvar = enumvar;
     enumerator->atend = !enumvar;
-    hres = enumvar_get_next_item(enumerator);
+    hres = enumvar_get_next_item(enumerator, ctx);
     if (FAILED(hres))
     {
         jsdisp_release(&enumerator->dispex);
@@ -292,7 +283,7 @@ static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **re
     return S_OK;
 }
 
-static HRESULT EnumeratorConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT EnumeratorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsdisp_t *obj;
@@ -303,13 +294,14 @@ static HRESULT EnumeratorConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD fl
     switch(flags) {
     case DISPATCH_CONSTRUCT: {
         if (argc > 1)
-            return throw_syntax_error(ctx, JS_E_INVALIDARG, NULL);
+            return JS_E_INVALIDARG;
 
         hres = create_enumerator(ctx, (argc == 1) ? &argv[0] : 0, &obj);
         if(FAILED(hres))
             return hres;
 
-        *r = jsval_obj(obj);
+        if(r) *r = jsval_obj(obj);
+        else  jsdisp_release(obj);
         break;
     }
     default:
@@ -321,27 +313,21 @@ static HRESULT EnumeratorConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD fl
 }
 
 static const builtin_info_t EnumeratorConstr_info = {
-    JSCLASS_FUNCTION,
-    DEFAULT_FUNCTION_VALUE,
-    0,
-    NULL,
-    NULL,
-    NULL
+    .class = JSCLASS_FUNCTION,
+    .call  = Function_value,
 };
 
 HRESULT create_enumerator_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
 {
     EnumeratorInstance *enumerator;
     HRESULT hres;
-    static const WCHAR EnumeratorW[] = {'E','n','u','m','e','r','a','t','o','r',0};
 
     hres = alloc_enumerator(ctx, object_prototype, &enumerator);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_constructor(ctx, EnumeratorConstr_value,
-                                     EnumeratorW, &EnumeratorConstr_info,
-                                     PROPF_CONSTR|7, &enumerator->dispex, ret);
+    hres = create_builtin_constructor(ctx, EnumeratorConstr_value, L"Enumerator",
+            &EnumeratorConstr_info, PROPF_CONSTR|7, &enumerator->dispex, ret);
     jsdisp_release(&enumerator->dispex);
 
     return hres;

dll/win32/jscript/error.c

@@ -22,38 +22,37 @@
 #endif
 
 #include <math.h>
+#include <assert.h>
+#include <wchar.h>
 
 #include "jscript.h"
+#include "engine.h"
 
 #include "wine/debug.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
-static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
-static const WCHAR nameW[] = {'n','a','m','e',0};
-static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
-static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-
 /* ECMA-262 3rd Edition    15.11.4.4 */
-static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
+static HRESULT Error_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    jsdisp_t *jsthis;
     jsstr_t *name = NULL, *msg = NULL, *ret = NULL;
+    jsdisp_t *jsthis = NULL;
     jsval_t v;
     HRESULT hres;
 
-    static const WCHAR object_errorW[] = {'[','o','b','j','e','c','t',' ','E','r','r','o','r',']',0};
-
     TRACE("\n");
 
-    jsthis = get_jsdisp(vthis);
+    if(is_object_instance(vthis))
+        jsthis = to_jsdisp(get_object(vthis));
+    else if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5)
+        return JS_E_OBJECT_EXPECTED;
+
     if(!jsthis || ctx->version < 2) {
         if(r) {
             jsstr_t *str;
 
-            str = jsstr_alloc(object_errorW);
+            str = jsstr_alloc(L"[object Error]");
             if(!str)
                 return E_OUTOFMEMORY;
             *r = jsval_string(str);
@@ -61,7 +60,7 @@ static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
         return S_OK;
     }
 
-    hres = jsdisp_propget_name(jsthis, nameW, &v);
+    hres = jsdisp_propget_name(jsthis, L"name", &v);
     if(FAILED(hres))
         return hres;
 
@@ -72,7 +71,7 @@ static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
             return hres;
     }
 
-    hres = jsdisp_propget_name(jsthis, messageW, &v);
+    hres = jsdisp_propget_name(jsthis, L"message", &v);
     if(SUCCEEDED(hres)) {
         if(!is_undefined(v)) {
             hres = to_string(ctx, v, &msg);
@@ -103,7 +102,7 @@ static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
             ret = msg;
             msg = NULL;
         }else {
-            ret = jsstr_alloc(object_errorW);
+            ret = jsstr_alloc(L"[object Error]");
         }
     }
 
@@ -123,14 +122,14 @@ static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
     return S_OK;
 }
 
-static HRESULT Error_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT Error_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
 
     switch(flags) {
     case INVOKE_FUNC:
-        return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
+        return JS_E_FUNCTION_EXPECTED;
     default:
         FIXME("unimplemented flags %x\n", flags);
         return E_NOTIMPL;
@@ -140,25 +139,19 @@ static HRESULT Error_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 }
 
 static const builtin_prop_t Error_props[] = {
-    {toStringW,                 Error_toString,                     PROPF_METHOD}
+    {L"toString",               Error_toString,                     PROPF_METHOD}
 };
 
 static const builtin_info_t Error_info = {
-    JSCLASS_ERROR,
-    {NULL, Error_value, 0},
-    ARRAY_SIZE(Error_props),
-    Error_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_ERROR,
+    .call      = Error_value,
+    .props_cnt = ARRAY_SIZE(Error_props),
+    .props     = Error_props,
 };
 
 static const builtin_info_t ErrorInst_info = {
-    JSCLASS_ERROR,
-    {NULL, Error_value, 0},
-    0,
-    NULL,
-    NULL,
-    NULL
+    .class = JSCLASS_ERROR,
+    .call  = Error_value,
 };
 
 static HRESULT alloc_error(script_ctx_t *ctx, jsdisp_t *prototype,
@@ -167,7 +160,7 @@ static HRESULT alloc_error(script_ctx_t *ctx, jsdisp_t *prototype,
     jsdisp_t *err;
     HRESULT hres;
 
-    err = heap_alloc_zero(sizeof(*err));
+    err = calloc(1, sizeof(*err));
     if(!err)
         return E_OUTOFMEMORY;
 
@@ -177,7 +170,7 @@ static HRESULT alloc_error(script_ctx_t *ctx, jsdisp_t *prototype,
         hres = init_dispex_from_constr(err, ctx, &ErrorInst_info,
             constr ? constr : ctx->error_constr);
     if(FAILED(hres)) {
-        heap_free(err);
+        free(err);
         return hres;
     }
 
@@ -195,18 +188,18 @@ static HRESULT create_error(script_ctx_t *ctx, jsdisp_t *constr,
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(err, numberW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
+    hres = jsdisp_define_data_property(err, L"number", PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                        jsval_number((INT)number));
     if(FAILED(hres)) {
         jsdisp_release(err);
         return hres;
     }
 
-    hres = jsdisp_define_data_property(err, messageW,
+    hres = jsdisp_define_data_property(err, L"message",
                                        PROPF_WRITABLE | PROPF_ENUMERABLE | PROPF_CONFIGURABLE,
                                        jsval_string(msg));
     if(SUCCEEDED(hres))
-        hres = jsdisp_define_data_property(err, descriptionW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
+        hres = jsdisp_define_data_property(err, L"description", PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                            jsval_string(msg));
     if(FAILED(hres)) {
         jsdisp_release(err);
@@ -269,56 +262,56 @@ static HRESULT error_constr(script_ctx_t *ctx, WORD flags, unsigned argc, jsval_
     }
 }
 
-static HRESULT ErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT ErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->error_constr);
 }
 
-static HRESULT EvalErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT EvalErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->eval_error_constr);
 }
 
-static HRESULT RangeErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT RangeErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->range_error_constr);
 }
 
-static HRESULT ReferenceErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT ReferenceErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->reference_error_constr);
 }
 
-static HRESULT RegExpErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT RegExpErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->regexp_error_constr);
 }
 
-static HRESULT SyntaxErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT SyntaxErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->syntax_error_constr);
 }
 
-static HRESULT TypeErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT TypeErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
     return error_constr(ctx, flags, argc, argv, r, ctx->type_error_constr);
 }
 
-static HRESULT URIErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT URIErrorConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     TRACE("\n");
@@ -327,16 +320,8 @@ static HRESULT URIErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
 
 HRESULT init_error_constr(script_ctx_t *ctx, jsdisp_t *object_prototype)
 {
-    static const WCHAR ErrorW[] = {'E','r','r','o','r',0};
-    static const WCHAR EvalErrorW[] = {'E','v','a','l','E','r','r','o','r',0};
-    static const WCHAR RangeErrorW[] = {'R','a','n','g','e','E','r','r','o','r',0};
-    static const WCHAR ReferenceErrorW[] = {'R','e','f','e','r','e','n','c','e','E','r','r','o','r',0};
-    static const WCHAR RegExpErrorW[] = {'R','e','g','E','x','p','E','r','r','o','r',0};
-    static const WCHAR SyntaxErrorW[] = {'S','y','n','t','a','x','E','r','r','o','r',0};
-    static const WCHAR TypeErrorW[] = {'T','y','p','e','E','r','r','o','r',0};
-    static const WCHAR URIErrorW[] = {'U','R','I','E','r','r','o','r',0};
-    static const WCHAR *names[] = {ErrorW, EvalErrorW, RangeErrorW,
-        ReferenceErrorW, RegExpErrorW, SyntaxErrorW, TypeErrorW, URIErrorW};
+    static const WCHAR *names[] = {L"Error", L"EvalError", L"RangeError",
+        L"ReferenceError", L"RegExpError", L"SyntaxError", L"TypeError", L"URIError"};
     jsdisp_t **constr_addr[] = {&ctx->error_constr, &ctx->eval_error_constr,
         &ctx->range_error_constr, &ctx->reference_error_constr, &ctx->regexp_error_constr,
         &ctx->syntax_error_constr, &ctx->type_error_constr,
@@ -361,7 +346,7 @@ HRESULT init_error_constr(script_ctx_t *ctx, jsdisp_t *object_prototype)
             return E_OUTOFMEMORY;
         }
 
-        hres = jsdisp_define_data_property(err, nameW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
+        hres = jsdisp_define_data_property(err, L"name", PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                            jsval_string(str));
         jsstr_release(str);
         if(SUCCEEDED(hres))
@@ -376,73 +361,178 @@ HRESULT init_error_constr(script_ctx_t *ctx, jsdisp_t *object_prototype)
     return S_OK;
 }
 
-static HRESULT throw_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str, jsdisp_t *constr)
+static jsstr_t *format_error_message(HRESULT error, const WCHAR *arg)
 {
-    WCHAR buf[1024], *pos = NULL;
-    jsdisp_t *err;
-    jsstr_t *msg;
-    HRESULT hres;
+    size_t len, arg_len = 0;
+    const WCHAR *res, *pos;
+    WCHAR *buf, *p;
+    jsstr_t *r;
 
     if(!is_jscript_error(error))
-        return error;
+        return jsstr_empty();
 
-    buf[0] = '\0';
-    LoadStringW(jscript_hinstance, HRESULT_CODE(error), buf, ARRAY_SIZE(buf));
+    len = LoadStringW(jscript_hinstance, HRESULT_CODE(error), (WCHAR*)&res, 0);
 
-    if(str) pos = wcschr(buf, '|');
-    if(pos) {
-        int len = lstrlenW(str);
-        memmove(pos+len, pos+1, (lstrlenW(pos+1)+1)*sizeof(WCHAR));
-        memcpy(pos, str, len*sizeof(WCHAR));
+    pos = wmemchr(res, '|', len);
+    if(pos && arg)
+        arg_len = lstrlenW(arg);
+    r = jsstr_alloc_buf(len + arg_len - (pos ? 1 : 0), &buf);
+    if(!r)
+        return jsstr_empty();
+
+    p = buf;
+    if(pos > res) {
+        memcpy(p, res, (pos - res) * sizeof(WCHAR));
+        p += pos - res;
+    }
+    pos = pos ? pos + 1 : res;
+    if(arg_len) {
+        memcpy(p, arg, arg_len * sizeof(WCHAR));
+        p += arg_len;
+    }
+    if(pos != res + len)
+        memcpy(p, pos, (res + len - pos) * sizeof(WCHAR));
+    return r;
+}
+
+HRESULT throw_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
+{
+    jsexcept_t *ei = ctx->ei;
+    TRACE("%08lx\n", error);
+    reset_ei(ei);
+    ei->error = error;
+    if(str)
+        ei->message = format_error_message(error, str);
+    return DISP_E_EXCEPTION;
+}
+
+void handle_dispatch_exception(script_ctx_t *ctx, EXCEPINFO *ei)
+{
+    TRACE("%08lx %s %s\n", ei->scode, debugstr_w(ei->bstrSource), debugstr_w(ei->bstrDescription));
+
+    reset_ei(ctx->ei);
+    if(ei->pfnDeferredFillIn)
+        ei->pfnDeferredFillIn(ei);
+    ctx->ei->error = (SUCCEEDED(ei->scode) || ei->scode == DISP_E_EXCEPTION) ? E_FAIL : ei->scode;
+    if(ei->bstrSource)
+        ctx->ei->source = jsstr_alloc_len(ei->bstrSource, SysStringLen(ei->bstrSource));
+    if(ei->bstrDescription)
+        ctx->ei->message = jsstr_alloc_len(ei->bstrDescription, SysStringLen(ei->bstrDescription));
+    SysFreeString(ei->bstrSource);
+    SysFreeString(ei->bstrDescription);
+    SysFreeString(ei->bstrHelpFile);
+}
+
+void set_error_location(jsexcept_t *ei, bytecode_t *code, unsigned loc, unsigned source_id, jsstr_t *line)
+{
+    if(is_jscript_error(ei->error)) {
+        if(!ei->source) {
+            const WCHAR *res;
+            size_t len;
+
+            len = LoadStringW(jscript_hinstance, source_id, (WCHAR*)&res, 0);
+            ei->source = jsstr_alloc_len(res, len);
+        }
+        if(!ei->message)
+            ei->message = format_error_message(ei->error, NULL);
     }
 
-    WARN("%s\n", debugstr_w(buf));
+    TRACE("source %s in %s\n", debugstr_w(code->source + loc), debugstr_w(code->source));
 
-    msg = jsstr_alloc(buf);
-    if(!msg)
-        return E_OUTOFMEMORY;
-
-    hres = create_error(ctx, constr, error, msg, &err);
-    jsstr_release(msg);
-    if(FAILED(hres))
-        return hres;
-
-    jsval_release(ctx->ei.val);
-    ctx->ei.val = jsval_obj(err);
-    return error;
+    ei->code = bytecode_addref(code);
+    ei->loc = loc;
+    if(line)
+        ei->line = jsstr_addref(line);
 }
 
-HRESULT throw_generic_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
+jsdisp_t *create_builtin_error(script_ctx_t *ctx)
 {
-    return throw_error(ctx, error, str, ctx->error_constr);
-}
+    jsdisp_t *constr = ctx->error_constr, *r;
+    jsexcept_t *ei = ctx->ei;
+    HRESULT hres;
 
-HRESULT throw_range_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->range_error_constr);
-}
+    assert(FAILED(ei->error) && ei->error != DISP_E_EXCEPTION);
 
-HRESULT throw_reference_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->reference_error_constr);
-}
+    if(is_jscript_error(ei->error)) {
+        switch(ei->error) {
+        case JS_E_SYNTAX:
+        case JS_E_MISSING_SEMICOLON:
+        case JS_E_MISSING_LBRACKET:
+        case JS_E_MISSING_RBRACKET:
+        case JS_E_EXPECTED_IDENTIFIER:
+        case JS_E_EXPECTED_ASSIGN:
+        case JS_E_INVALID_CHAR:
+        case JS_E_UNTERMINATED_STRING:
+        case JS_E_MISPLACED_RETURN:
+        case JS_E_INVALID_BREAK:
+        case JS_E_INVALID_CONTINUE:
+        case JS_E_LABEL_REDEFINED:
+        case JS_E_LABEL_NOT_FOUND:
+        case JS_E_EXPECTED_CCEND:
+        case JS_E_DISABLED_CC:
+        case JS_E_EXPECTED_AT:
+        case JS_E_UNEXPECTED_QUANTIFIER:
+            constr = ctx->syntax_error_constr;
+            break;
 
-HRESULT throw_regexp_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->regexp_error_constr);
-}
+        case JS_E_TO_PRIMITIVE:
+        case JS_E_INVALIDARG:
+        case JS_E_OBJECT_REQUIRED:
+        case JS_E_INVALID_PROPERTY:
+        case JS_E_INVALID_ACTION:
+        case JS_E_MISSING_ARG:
+        case JS_E_OBJECT_NOT_COLLECTION:
+        case JS_E_FUNCTION_EXPECTED:
+        case JS_E_DATE_EXPECTED:
+        case JS_E_NUMBER_EXPECTED:
+        case JS_E_OBJECT_EXPECTED:
+        case JS_E_UNDEFINED_VARIABLE:
+        case JS_E_BOOLEAN_EXPECTED:
+        case JS_E_VBARRAY_EXPECTED:
+        case JS_E_INVALID_DELETE:
+        case JS_E_JSCRIPT_EXPECTED:
+        case JS_E_ENUMERATOR_EXPECTED:
+        case JS_E_REGEXP_EXPECTED:
+        case JS_E_ARRAY_EXPECTED:
+        case JS_E_CYCLIC_PROTO_VALUE:
+        case JS_E_CANNOT_CREATE_FOR_NONEXTENSIBLE:
+        case JS_E_OBJECT_NONEXTENSIBLE:
+        case JS_E_NONCONFIGURABLE_REDEFINED:
+        case JS_E_NONWRITABLE_MODIFIED:
+        case JS_E_NOT_DATAVIEW:
+        case JS_E_DATAVIEW_NO_ARGUMENT:
+        case JS_E_WRONG_THIS:
+        case JS_E_KEY_NOT_OBJECT:
+        case JS_E_ARRAYBUFFER_EXPECTED:
+        case JS_E_PROP_DESC_MISMATCH:
+        case JS_E_INVALID_WRITABLE_PROP_DESC:
+            constr = ctx->type_error_constr;
+            break;
 
-HRESULT throw_syntax_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->syntax_error_constr);
-}
+        case JS_E_SUBSCRIPT_OUT_OF_RANGE:
+        case JS_E_FRACTION_DIGITS_OUT_OF_RANGE:
+        case JS_E_PRECISION_OUT_OF_RANGE:
+        case JS_E_INVALID_LENGTH:
+        case JS_E_DATAVIEW_INVALID_ACCESS:
+        case JS_E_DATAVIEW_INVALID_OFFSET:
+            constr = ctx->range_error_constr;
+            break;
 
-HRESULT throw_type_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->type_error_constr);
-}
+        case JS_E_ILLEGAL_ASSIGN:
+            constr = ctx->reference_error_constr;
+            break;
 
-HRESULT throw_uri_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
-{
-    return throw_error(ctx, error, str, ctx->uri_error_constr);
+        case JS_E_REGEXP_SYNTAX:
+            constr = ctx->regexp_error_constr;
+            break;
+
+        case JS_E_INVALID_URI_CODING:
+        case JS_E_INVALID_URI_CHAR:
+            constr = ctx->uri_error_constr;
+            break;
+        }
+    }
+
+    hres = create_error(ctx, constr, ei->error, ei->message ? ei->message : jsstr_empty(), &r);
+    return SUCCEEDED(hres) ? r : NULL;
 }

dll/win32/jscript/global.c

@@ -31,52 +31,6 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static const WCHAR NaNW[] = {'N','a','N',0};
-static const WCHAR InfinityW[] = {'I','n','f','i','n','i','t','y',0};
-static const WCHAR ArrayW[] = {'A','r','r','a','y',0};
-static const WCHAR BooleanW[] = {'B','o','o','l','e','a','n',0};
-static const WCHAR DateW[] = {'D','a','t','e',0};
-static const WCHAR ErrorW[] = {'E','r','r','o','r',0};
-static const WCHAR EvalErrorW[] = {'E','v','a','l','E','r','r','o','r',0};
-static const WCHAR RangeErrorW[] = {'R','a','n','g','e','E','r','r','o','r',0};
-static const WCHAR ReferenceErrorW[] = {'R','e','f','e','r','e','n','c','e','E','r','r','o','r',0};
-static const WCHAR SyntaxErrorW[] = {'S','y','n','t','a','x','E','r','r','o','r',0};
-static const WCHAR TypeErrorW[] = {'T','y','p','e','E','r','r','o','r',0};
-static const WCHAR URIErrorW[] = {'U','R','I','E','r','r','o','r',0};
-static const WCHAR FunctionW[] = {'F','u','n','c','t','i','o','n',0};
-static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
-static const WCHAR ObjectW[] = {'O','b','j','e','c','t',0};
-static const WCHAR StringW[] = {'S','t','r','i','n','g',0};
-static const WCHAR RegExpW[] = {'R','e','g','E','x','p',0};
-static const WCHAR RegExpErrorW[] = {'R','e','g','E','x','p','E','r','r','o','r',0};
-static const WCHAR ActiveXObjectW[] = {'A','c','t','i','v','e','X','O','b','j','e','c','t',0};
-static const WCHAR VBArrayW[] = {'V','B','A','r','r','a','y',0};
-static const WCHAR EnumeratorW[] = {'E','n','u','m','e','r','a','t','o','r',0};
-static const WCHAR escapeW[] = {'e','s','c','a','p','e',0};
-static const WCHAR evalW[] = {'e','v','a','l',0};
-static const WCHAR isNaNW[] = {'i','s','N','a','N',0};
-static const WCHAR isFiniteW[] = {'i','s','F','i','n','i','t','e',0};
-static const WCHAR parseIntW[] = {'p','a','r','s','e','I','n','t',0};
-static const WCHAR parseFloatW[] = {'p','a','r','s','e','F','l','o','a','t',0};
-static const WCHAR unescapeW[] = {'u','n','e','s','c','a','p','e',0};
-static const WCHAR _GetObjectW[] = {'G','e','t','O','b','j','e','c','t',0};
-static const WCHAR ScriptEngineW[] = {'S','c','r','i','p','t','E','n','g','i','n','e',0};
-static const WCHAR ScriptEngineMajorVersionW[] =
-    {'S','c','r','i','p','t','E','n','g','i','n','e','M','a','j','o','r','V','e','r','s','i','o','n',0};
-static const WCHAR ScriptEngineMinorVersionW[] =
-    {'S','c','r','i','p','t','E','n','g','i','n','e','M','i','n','o','r','V','e','r','s','i','o','n',0};
-static const WCHAR ScriptEngineBuildVersionW[] =
-    {'S','c','r','i','p','t','E','n','g','i','n','e','B','u','i','l','d','V','e','r','s','i','o','n',0};
-static const WCHAR CollectGarbageW[] = {'C','o','l','l','e','c','t','G','a','r','b','a','g','e',0};
-static const WCHAR MathW[] = {'M','a','t','h',0};
-static const WCHAR JSONW[] = {'J','S','O','N',0};
-static const WCHAR encodeURIW[] = {'e','n','c','o','d','e','U','R','I',0};
-static const WCHAR decodeURIW[] = {'d','e','c','o','d','e','U','R','I',0};
-static const WCHAR encodeURIComponentW[] = {'e','n','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
-static const WCHAR decodeURIComponentW[] = {'d','e','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
-
-static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
-
 static int uri_char_table[] = {
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 00-0f */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 10-1f */
@@ -115,7 +69,7 @@ static WCHAR int_to_char(int i)
     return 'A'+i-10;
 }
 
-static HRESULT JSGlobal_escape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_escape(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *ret_str, *str;
@@ -180,10 +134,9 @@ static HRESULT JSGlobal_escape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
 }
 
 /* ECMA-262 3rd Edition    15.1.2.1 */
-HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+HRESULT builtin_eval(script_ctx_t *ctx, call_frame_t *frame, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    call_frame_t *frame = ctx->call_ctx;
     DWORD exec_flags = EXEC_EVAL;
     bytecode_t *code;
     const WCHAR *src;
@@ -208,10 +161,10 @@ HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned a
         return E_OUTOFMEMORY;
 
     TRACE("parsing %s\n", debugstr_jsval(argv[0]));
-    hres = compile_script(ctx, src, NULL, NULL, TRUE, FALSE, &code);
+    hres = compile_script(ctx, src, 0, 0, NULL, NULL, TRUE, FALSE, frame ? frame->bytecode->named_item : NULL, &code);
     if(FAILED(hres)) {
-        WARN("parse (%s) failed: %08x\n", debugstr_jsval(argv[0]), hres);
-        return throw_syntax_error(ctx, hres, NULL);
+        WARN("parse (%s) failed: %08lx\n", debugstr_jsval(argv[0]), hres);
+        return hres;
     }
 
     if(!frame || (frame->flags & EXEC_GLOBAL))
@@ -219,12 +172,18 @@ HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned a
     if(flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE)
         exec_flags |= EXEC_RETURN_TO_INTERP;
     hres = exec_source(ctx, exec_flags, code, &code->global_code, frame ? frame->scope : NULL,
-            frame ? frame->this_obj : NULL, NULL, frame ? frame->variable_obj : ctx->global, 0, NULL, r);
+            frame ? frame->this_obj : NULL, NULL, 0, NULL, r);
     release_bytecode(code);
     return hres;
 }
 
-static HRESULT JSGlobal_isNaN(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+HRESULT JSGlobal_eval(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    return builtin_eval(ctx, ctx->version < SCRIPTLANGUAGEVERSION_ES5 ? ctx->call_ctx : NULL, flags, argc, argv, r);
+}
+
+static HRESULT JSGlobal_isNaN(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     BOOL ret = TRUE;
@@ -247,7 +206,7 @@ static HRESULT JSGlobal_isNaN(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
     return S_OK;
 }
 
-static HRESULT JSGlobal_isFinite(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_isFinite(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     BOOL ret = FALSE;
@@ -262,7 +221,7 @@ static HRESULT JSGlobal_isFinite(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
         if(FAILED(hres))
             return hres;
 
-        ret = is_finite(n);
+        ret = isfinite(n);
     }
 
     if(r)
@@ -281,7 +240,7 @@ static INT char_to_int(WCHAR c)
     return 100;
 }
 
-static HRESULT JSGlobal_parseInt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_parseInt(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     BOOL neg = FALSE, empty = TRUE;
@@ -364,7 +323,7 @@ static HRESULT JSGlobal_parseInt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
     return S_OK;
 }
 
-static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     LONGLONG d = 0, hlp;
@@ -380,6 +339,8 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
         return S_OK;
     }
 
+    TRACE("%s\n", debugstr_jsval(argv[0]));
+
     hres = to_flat_string(ctx, argv[0], &val_str, &str);
     if(FAILED(hres))
         return hres;
@@ -393,10 +354,10 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
         str++;
     }
 
-    if(iswdigit(*str))
+    if(is_digit(*str))
         ret_nan = FALSE;
 
-    while(iswdigit(*str)) {
+    while(is_digit(*str)) {
         hlp = d*10 + *(str++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0) {
             exp++;
@@ -405,17 +366,17 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
         else
             d = hlp;
     }
-    while(iswdigit(*str)) {
+    while(is_digit(*str)) {
         exp++;
         str++;
     }
 
     if(*str == '.') str++;
 
-    if(iswdigit(*str))
+    if(is_digit(*str))
         ret_nan = FALSE;
 
-    while(iswdigit(*str)) {
+    while(is_digit(*str)) {
         hlp = d*10 + *(str++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0)
             break;
@@ -423,7 +384,7 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
         d = hlp;
         exp--;
     }
-    while(iswdigit(*str))
+    while(is_digit(*str))
         str++;
 
     if(*str && !ret_nan && (*str=='e' || *str=='E')) {
@@ -437,7 +398,7 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
             str++;
         }
 
-        while(iswdigit(*str)) {
+        while(is_digit(*str)) {
             if(e>INT_MAX/10 || (e = e*10 + *str++ - '0')<0)
                 e = INT_MAX;
         }
@@ -463,13 +424,17 @@ static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flag
     return S_OK;
 }
 
+#if defined(__REACTOS__) && defined(__clang__)
+static inline __attribute__((always_inline)) int hex_to_int(WCHAR wch) {
+#else
 static inline int hex_to_int(const WCHAR wch) {
+#endif
     if(towupper(wch)>='A' && towupper(wch)<='F') return towupper(wch)-'A'+10;
-    if(iswdigit(wch)) return wch-'0';
+    if(is_digit(wch)) return wch-'0';
     return -1;
 }
 
-static HRESULT JSGlobal_unescape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_unescape(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *ret_str, *str;
@@ -539,24 +504,22 @@ static HRESULT JSGlobal_unescape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
     return S_OK;
 }
 
-static HRESULT JSGlobal_GetObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_GetObject(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     FIXME("\n");
     return E_NOTIMPL;
 }
 
-static HRESULT JSGlobal_ScriptEngine(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_ScriptEngine(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR JScriptW[] = {'J','S','c','r','i','p','t',0};
-
     TRACE("\n");
 
     if(r) {
         jsstr_t *ret;
 
-        ret = jsstr_alloc(JScriptW);
+        ret = jsstr_alloc(L"JScript");
         if(!ret)
             return E_OUTOFMEMORY;
 
@@ -566,7 +529,7 @@ static HRESULT JSGlobal_ScriptEngine(script_ctx_t *ctx, vdisp_t *jsthis, WORD fl
     return S_OK;
 }
 
-static HRESULT JSGlobal_ScriptEngineMajorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_ScriptEngineMajorVersion(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
@@ -576,7 +539,7 @@ static HRESULT JSGlobal_ScriptEngineMajorVersion(script_ctx_t *ctx, vdisp_t *jst
     return S_OK;
 }
 
-static HRESULT JSGlobal_ScriptEngineMinorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_ScriptEngineMinorVersion(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
@@ -586,7 +549,7 @@ static HRESULT JSGlobal_ScriptEngineMinorVersion(script_ctx_t *ctx, vdisp_t *jst
     return S_OK;
 }
 
-static HRESULT JSGlobal_ScriptEngineBuildVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_ScriptEngineBuildVersion(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
@@ -596,16 +559,13 @@ static HRESULT JSGlobal_ScriptEngineBuildVersion(script_ctx_t *ctx, vdisp_t *jst
     return S_OK;
 }
 
-static HRESULT JSGlobal_CollectGarbage(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_CollectGarbage(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static int once = 0;
-    if (!once++)
-        FIXME(": stub\n");
-    return S_OK;
+    return gc_run(ctx);
 }
 
-static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     const WCHAR *ptr, *uri;
@@ -631,10 +591,10 @@ static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
         if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
             len++;
         }else {
-            i = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL)*3;
+            i = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, 1, NULL, 0, NULL, NULL)*3;
             if(!i) {
                 jsstr_release(str);
-                return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
+                return JS_E_INVALID_URI_CHAR;
             }
 
             len += i;
@@ -651,7 +611,7 @@ static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
         if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
             *rptr++ = *ptr;
         }else {
-            len = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
+            len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, 1, buf, sizeof(buf), NULL, NULL);
             for(i=0; i<len; i++) {
                 *rptr++ = '%';
                 *rptr++ = int_to_char((BYTE)buf[i] >> 4);
@@ -670,7 +630,7 @@ static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     return S_OK;
 }
 
-static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     const WCHAR *ptr, *uri;
@@ -705,14 +665,14 @@ static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
                 val += hex_to_int(ptr[i*3+1])<<4;
                 buf[i] = val;
 
-                res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, &out, 1);
+                res = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buf, i+1, &out, 1);
                 if(res)
                     break;
             }
 
             if(!res) {
                 jsstr_release(str);
-                return throw_uri_error(ctx, JS_E_INVALID_URI_CODING, NULL);
+                return JS_E_INVALID_URI_CODING;
             }
 
             ptr += i*3+2;
@@ -736,7 +696,7 @@ static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
                 val += hex_to_int(ptr[i*3+1])<<4;
                 buf[i] = val;
 
-                res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, ret, 1);
+                res = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buf, i+1, ret, 1);
                 if(res)
                     break;
             }
@@ -756,7 +716,7 @@ static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     return S_OK;
 }
 
-static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *str, *ret_str;
@@ -782,10 +742,10 @@ static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, W
         if(is_uri_unescaped(*ptr))
             len++;
         else {
-            size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL);
+            size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, 1, NULL, 0, NULL, NULL);
             if(!size) {
                 jsstr_release(str);
-                return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
+                return JS_E_INVALID_URI_CHAR;
             }
             len += size*3;
         }
@@ -801,7 +761,7 @@ static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, W
         if(is_uri_unescaped(*ptr)) {
             *ret++ = *ptr;
         }else {
-            size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
+            size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, 1, buf, sizeof(buf), NULL, NULL);
             for(i=0; i<size; i++) {
                 *ret++ = '%';
                 *ret++ = int_to_char((BYTE)buf[i] >> 4);
@@ -820,7 +780,7 @@ static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, W
 }
 
 /* ECMA-262 3rd Edition    15.1.3.2 */
-static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     const WCHAR *ptr, *uri;
@@ -933,34 +893,56 @@ static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, W
 }
 
 static const builtin_prop_t JSGlobal_props[] = {
-    {CollectGarbageW,            JSGlobal_CollectGarbage,            PROPF_METHOD},
-    {_GetObjectW,                JSGlobal_GetObject,                 PROPF_METHOD|2},
-    {ScriptEngineW,              JSGlobal_ScriptEngine,              PROPF_METHOD},
-    {ScriptEngineBuildVersionW,  JSGlobal_ScriptEngineBuildVersion,  PROPF_METHOD},
-    {ScriptEngineMajorVersionW,  JSGlobal_ScriptEngineMajorVersion,  PROPF_METHOD},
-    {ScriptEngineMinorVersionW,  JSGlobal_ScriptEngineMinorVersion,  PROPF_METHOD},
-    {decodeURIW,                 JSGlobal_decodeURI,                 PROPF_METHOD|1},
-    {decodeURIComponentW,        JSGlobal_decodeURIComponent,        PROPF_METHOD|1},
-    {encodeURIW,                 JSGlobal_encodeURI,                 PROPF_METHOD|1},
-    {encodeURIComponentW,        JSGlobal_encodeURIComponent,        PROPF_METHOD|1},
-    {escapeW,                    JSGlobal_escape,                    PROPF_METHOD|1},
-    {evalW,                      JSGlobal_eval,                      PROPF_METHOD|1},
-    {isFiniteW,                  JSGlobal_isFinite,                  PROPF_METHOD|1},
-    {isNaNW,                     JSGlobal_isNaN,                     PROPF_METHOD|1},
-    {parseFloatW,                JSGlobal_parseFloat,                PROPF_METHOD|1},
-    {parseIntW,                  JSGlobal_parseInt,                  PROPF_METHOD|2},
-    {unescapeW,                  JSGlobal_unescape,                  PROPF_METHOD|1}
+    {L"CollectGarbage",            JSGlobal_CollectGarbage,            PROPF_METHOD},
+    {L"GetObject",                 JSGlobal_GetObject,                 PROPF_METHOD|2},
+    {L"ScriptEngine",              JSGlobal_ScriptEngine,              PROPF_METHOD},
+    {L"ScriptEngineBuildVersion",  JSGlobal_ScriptEngineBuildVersion,  PROPF_METHOD},
+    {L"ScriptEngineMajorVersion",  JSGlobal_ScriptEngineMajorVersion,  PROPF_METHOD},
+    {L"ScriptEngineMinorVersion",  JSGlobal_ScriptEngineMinorVersion,  PROPF_METHOD},
+    {L"decodeURI",                 JSGlobal_decodeURI,                 PROPF_METHOD|1},
+    {L"decodeURIComponent",        JSGlobal_decodeURIComponent,        PROPF_METHOD|1},
+    {L"encodeURI",                 JSGlobal_encodeURI,                 PROPF_METHOD|1},
+    {L"encodeURIComponent",        JSGlobal_encodeURIComponent,        PROPF_METHOD|1},
+    {L"escape",                    JSGlobal_escape,                    PROPF_METHOD|1},
+    {L"eval",                      JSGlobal_eval,                      PROPF_METHOD|1},
+    {L"isFinite",                  JSGlobal_isFinite,                  PROPF_METHOD|1},
+    {L"isNaN",                     JSGlobal_isNaN,                     PROPF_METHOD|1},
+    {L"parseFloat",                JSGlobal_parseFloat,                PROPF_METHOD|1},
+    {L"parseInt",                  JSGlobal_parseInt,                  PROPF_METHOD|2},
+    {L"unescape",                  JSGlobal_unescape,                  PROPF_METHOD|1}
 };
 
 static const builtin_info_t JSGlobal_info = {
-    JSCLASS_GLOBAL,
-    {NULL, NULL, 0},
-    ARRAY_SIZE(JSGlobal_props),
-    JSGlobal_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_GLOBAL,
+    .props_cnt = ARRAY_SIZE(JSGlobal_props),
+    .props     = JSGlobal_props,
 };
 
+static HRESULT init_object_prototype_accessors(script_ctx_t *ctx, jsdisp_t *object_prototype)
+{
+    property_desc_t desc;
+    HRESULT hres = S_OK;
+
+    /* __proto__ is an actual accessor on native, despite being a builtin */
+    if(ctx->version >= SCRIPTLANGUAGEVERSION_ES6) {
+        desc.flags = PROPF_CONFIGURABLE;
+        desc.mask  = PROPF_CONFIGURABLE | PROPF_ENUMERABLE;
+        desc.explicit_getter = desc.explicit_setter = TRUE;
+        desc.explicit_value = FALSE;
+
+        hres = create_builtin_function(ctx, Object_get_proto_, NULL, NULL, PROPF_METHOD, NULL, &desc.getter);
+        if(SUCCEEDED(hres)) {
+            hres = create_builtin_function(ctx, Object_set_proto_, NULL, NULL, PROPF_METHOD|1, NULL, &desc.setter);
+            if(SUCCEEDED(hres)) {
+                hres = jsdisp_define_property(object_prototype, L"__proto__", &desc);
+                jsdisp_release(desc.setter);
+            }
+            jsdisp_release(desc.getter);
+        }
+    }
+    return hres;
+}
+
 static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
 {
     HRESULT hres;
@@ -969,7 +951,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, FunctionW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Function", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->function_constr));
     if(FAILED(hres))
         return hres;
@@ -978,7 +960,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, ObjectW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Object", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->object_constr));
     if(FAILED(hres))
         return hres;
@@ -987,7 +969,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, ArrayW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Array", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->array_constr));
     if(FAILED(hres))
         return hres;
@@ -996,7 +978,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, BooleanW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Boolean", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->bool_constr));
     if(FAILED(hres))
         return hres;
@@ -1005,7 +987,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, DateW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Date", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->date_constr));
     if(FAILED(hres))
         return hres;
@@ -1014,7 +996,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, EnumeratorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Enumerator", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->enumerator_constr));
     if(FAILED(hres))
         return hres;
@@ -1023,42 +1005,42 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, ErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Error", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, EvalErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"EvalError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->eval_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, RangeErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"RangeError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->range_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, ReferenceErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"ReferenceError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->reference_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, RegExpErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"RegExpError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->regexp_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, SyntaxErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"SyntaxError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->syntax_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, TypeErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"TypeError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->type_error_constr));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, URIErrorW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"URIError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->uri_error_constr));
     if(FAILED(hres))
         return hres;
@@ -1067,7 +1049,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, NumberW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"Number", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->number_constr));
     if(FAILED(hres))
         return hres;
@@ -1076,7 +1058,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, RegExpW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"RegExp", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->regexp_constr));
     if(FAILED(hres))
         return hres;
@@ -1085,7 +1067,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, StringW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"String", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->string_constr));
     if(FAILED(hres))
         return hres;
@@ -1094,7 +1076,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, VBArrayW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"VBArray", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(ctx->vbarray_constr));
     if(FAILED(hres))
         return hres;
@@ -1105,7 +1087,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
 HRESULT init_global(script_ctx_t *ctx)
 {
     unsigned const_flags = ctx->version >= SCRIPTLANGUAGEVERSION_ES5 ? 0 : PROPF_WRITABLE;
-    jsdisp_t *math, *object_prototype, *constr;
+    jsdisp_t *math, *constr;
     HRESULT hres;
 
     if(ctx->global)
@@ -1115,12 +1097,15 @@ HRESULT init_global(script_ctx_t *ctx)
     if(FAILED(hres))
         return hres;
 
-    hres = create_object_prototype(ctx, &object_prototype);
+    hres = create_object_prototype(ctx, &ctx->object_prototype);
     if(FAILED(hres))
         return hres;
 
-    hres = init_constructors(ctx, object_prototype);
-    jsdisp_release(object_prototype);
+    hres = init_constructors(ctx, ctx->object_prototype);
+    if(FAILED(hres))
+        return hres;
+
+    hres = init_object_prototype_accessors(ctx, ctx->object_prototype);
     if(FAILED(hres))
         return hres;
 
@@ -1128,7 +1113,7 @@ HRESULT init_global(script_ctx_t *ctx)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, MathW, PROPF_WRITABLE, jsval_obj(math));
+    hres = jsdisp_define_data_property(ctx->global, L"Math", PROPF_CONFIGURABLE | PROPF_WRITABLE, jsval_obj(math));
     jsdisp_release(math);
     if(FAILED(hres))
         return hres;
@@ -1140,7 +1125,7 @@ HRESULT init_global(script_ctx_t *ctx)
         if(FAILED(hres))
             return hres;
 
-        hres = jsdisp_define_data_property(ctx->global, JSONW, PROPF_WRITABLE, jsval_obj(json));
+        hres = jsdisp_define_data_property(ctx->global, L"JSON", PROPF_CONFIGURABLE | PROPF_WRITABLE, jsval_obj(json));
         jsdisp_release(json);
         if(FAILED(hres))
             return hres;
@@ -1150,20 +1135,27 @@ HRESULT init_global(script_ctx_t *ctx)
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, ActiveXObjectW, PROPF_WRITABLE,
+    hres = jsdisp_define_data_property(ctx->global, L"ActiveXObject", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                        jsval_obj(constr));
     jsdisp_release(constr);
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, undefinedW, const_flags, jsval_undefined());
+    hres = jsdisp_define_data_property(ctx->global, L"undefined", const_flags, jsval_undefined());
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, NaNW, const_flags, jsval_number(NAN));
+    hres = jsdisp_define_data_property(ctx->global, L"NaN", const_flags, jsval_number(NAN));
     if(FAILED(hres))
         return hres;
 
-    hres = jsdisp_define_data_property(ctx->global, InfinityW, const_flags, jsval_number(INFINITY));
-    return hres;
+    hres = jsdisp_define_data_property(ctx->global, L"Infinity", const_flags, jsval_number(INFINITY));
+    if(FAILED(hres))
+        return hres;
+
+    hres = init_arraybuf_constructors(ctx);
+    if(FAILED(hres))
+        return hres;
+
+    return init_set_constructor(ctx);
 }

dll/win32/jscript/guid.c

@@ -0,0 +1,15 @@
+/* DO NOT USE THE PRECOMPILED HEADER FOR THIS FILE! */
+
+#include <stdarg.h>
+
+#define WIN32_NO_STATUS
+#define _INC_WINDOWS
+
+#include <windef.h>
+#include <winbase.h>
+#include <wingdi.h>
+#include <objbase.h>
+#include <initguid.h>
+#include <jsdisp.h>
+
+/* NO CODE HERE, THIS IS JUST REQUIRED FOR THE GUID DEFINITIONS */

dll/win32/jscript/jscript.h

@@ -28,16 +28,17 @@
 #include "winbase.h"
 #include "winuser.h"
 #ifdef __REACTOS__
-#include "winnls.h"
+#include <winnls.h>
 #endif
 #include "ole2.h"
 #include "dispex.h"
 #include "activscp.h"
+#include "jsdisp.h"
 
 #include "resource.h"
 
-#include "wine/heap.h"
 #include "wine/list.h"
+#include "wine/rbtree.h"
 
 /*
  * This is Wine jscript extension for ES5 compatible mode. Native IE9+ implements
@@ -47,12 +48,14 @@
 #define SCRIPTLANGUAGEVERSION_HTML 0x400
 
 /*
- * This is Wine jscript extension for ES5 compatible mode. Allowed only in HTML mode.
+ * This is Wine jscript extension for ES5 and ES6 compatible mode. Allowed only in HTML mode.
  */
 #define SCRIPTLANGUAGEVERSION_ES5  0x102
+#define SCRIPTLANGUAGEVERSION_ES6  0x103
 
 typedef struct _jsval_t jsval_t;
 typedef struct _jsstr_t jsstr_t;
+typedef struct _jsexcept_t jsexcept_t;
 typedef struct _script_ctx_t script_ctx_t;
 typedef struct _dispex_prop_t dispex_prop_t;
 typedef struct _property_desc_t property_desc_t;
@@ -66,46 +69,26 @@ typedef struct {
     struct list custom_blocks;
 } heap_pool_t;
 
-void heap_pool_init(heap_pool_t*) DECLSPEC_HIDDEN;
-void *heap_pool_alloc(heap_pool_t*,DWORD) __WINE_ALLOC_SIZE(2) DECLSPEC_HIDDEN;
-void *heap_pool_grow(heap_pool_t*,void*,DWORD,DWORD) DECLSPEC_HIDDEN;
-void heap_pool_clear(heap_pool_t*) DECLSPEC_HIDDEN;
-void heap_pool_free(heap_pool_t*) DECLSPEC_HIDDEN;
-heap_pool_t *heap_pool_mark(heap_pool_t*) DECLSPEC_HIDDEN;
-
-static inline LPWSTR heap_strdupW(LPCWSTR str)
-{
-    LPWSTR ret = NULL;
-
-    if(str) {
-        DWORD size;
-
-        size = (lstrlenW(str)+1)*sizeof(WCHAR);
-        ret = heap_alloc(size);
-        if(ret)
-            memcpy(ret, str, size);
-    }
-
-    return ret;
-}
+void heap_pool_init(heap_pool_t*);
+void *heap_pool_alloc(heap_pool_t*,DWORD) __WINE_ALLOC_SIZE(2);
+void *heap_pool_grow(heap_pool_t*,void*,DWORD,DWORD);
+void heap_pool_clear(heap_pool_t*);
+void heap_pool_free(heap_pool_t*);
+heap_pool_t *heap_pool_mark(heap_pool_t*);
 
 typedef struct jsdisp_t jsdisp_t;
 
-extern HINSTANCE jscript_hinstance DECLSPEC_HIDDEN;
+extern HINSTANCE jscript_hinstance ;
+HRESULT get_dispatch_typeinfo(ITypeInfo**);
 
-#define PROPF_ARGMASK       0x00ff
-#define PROPF_METHOD        0x0100
-#define PROPF_CONSTR        0x0200
-
-#define PROPF_ENUMERABLE    0x0400
-#define PROPF_WRITABLE      0x0800
-#define PROPF_CONFIGURABLE  0x1000
 #define PROPF_ALL           (PROPF_ENUMERABLE | PROPF_WRITABLE | PROPF_CONFIGURABLE)
 
+#define PROPF_ARGMASK       0x000000ff
 #define PROPF_VERSION_MASK  0x01ff0000
 #define PROPF_VERSION_SHIFT 16
 #define PROPF_HTML          (SCRIPTLANGUAGEVERSION_HTML << PROPF_VERSION_SHIFT)
 #define PROPF_ES5           ((SCRIPTLANGUAGEVERSION_HTML|SCRIPTLANGUAGEVERSION_ES5) << PROPF_VERSION_SHIFT)
+#define PROPF_ES6           ((SCRIPTLANGUAGEVERSION_HTML|SCRIPTLANGUAGEVERSION_ES6) << PROPF_VERSION_SHIFT)
 
 /*
  * This is our internal dispatch flag informing calee that it's called directly from interpreter.
@@ -132,80 +115,61 @@ typedef enum {
     JSCLASS_STRING,
     JSCLASS_ARGUMENTS,
     JSCLASS_VBARRAY,
-    JSCLASS_JSON
+    JSCLASS_JSON,
+    JSCLASS_ARRAYBUFFER,
+    JSCLASS_DATAVIEW,
+    JSCLASS_MAP,
+    JSCLASS_SET,
+    JSCLASS_WEAKMAP,
+    JSCLASS_HOST,
 } jsclass_t;
 
-jsdisp_t *iface_to_jsdisp(IDispatch*) DECLSPEC_HIDDEN;
+jsdisp_t *iface_to_jsdisp(IDispatch*);
 
-typedef struct {
-    union {
-        IDispatch *disp;
-        IDispatchEx *dispex;
-        jsdisp_t *jsdisp;
-    } u;
-    DWORD flags;
-} vdisp_t;
-
-#define VDISP_DISPEX  0x0001
-#define VDISP_JSDISP  0x0002
-
-static inline void vdisp_release(vdisp_t *vdisp)
-{
-    IDispatch_Release(vdisp->u.disp);
-}
-
-static inline BOOL is_jsdisp(vdisp_t *vdisp)
-{
-    return (vdisp->flags & VDISP_JSDISP) != 0;
-}
-
-static inline BOOL is_dispex(vdisp_t *vdisp)
-{
-    return (vdisp->flags & VDISP_DISPEX) != 0;
-}
-
-static inline void set_jsdisp(vdisp_t *vdisp, jsdisp_t *jsdisp)
-{
-    vdisp->u.jsdisp = jsdisp;
-    vdisp->flags = VDISP_JSDISP | VDISP_DISPEX;
-    IDispatch_AddRef(vdisp->u.disp);
-}
-
-static inline void set_disp(vdisp_t *vdisp, IDispatch *disp)
-{
-    IDispatchEx *dispex;
-    jsdisp_t *jsdisp;
-    HRESULT hres;
-
-    jsdisp = iface_to_jsdisp(disp);
-    if(jsdisp) {
-        vdisp->u.jsdisp = jsdisp;
-        vdisp->flags = VDISP_JSDISP | VDISP_DISPEX;
-        return;
-    }
-
-    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
-    if(SUCCEEDED(hres)) {
-        vdisp->u.dispex = dispex;
-        vdisp->flags = VDISP_DISPEX;
-        return;
-    }
-
-    IDispatch_AddRef(disp);
-    vdisp->u.disp = disp;
-    vdisp->flags = 0;
-}
-
-static inline jsdisp_t *get_jsdisp(vdisp_t *vdisp)
-{
-    return is_jsdisp(vdisp) ? vdisp->u.jsdisp : NULL;
-}
-
-typedef HRESULT (*builtin_invoke_t)(script_ctx_t*,vdisp_t*,WORD,unsigned,jsval_t*,jsval_t*);
+typedef HRESULT (*builtin_invoke_t)(script_ctx_t*,jsval_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;
+HRESULT builtin_set_const(script_ctx_t*,jsdisp_t*,jsval_t);
+
+struct thread_data {
+    LONG ref;
+    LONG thread_id;
+
+    BOOL gc_is_unlinking;
+    DWORD gc_last_tick;
+
+    struct list objects;
+    struct rb_tree weak_refs;
+};
+
+struct thread_data *get_thread_data(void);
+void release_thread_data(struct thread_data*);
+
+typedef struct named_item_t {
+    jsdisp_t *script_obj;
+    IDispatch *disp;
+    unsigned ref;
+    DWORD flags;
+    LPWSTR name;
+
+    struct list entry;
+} named_item_t;
+
+struct gc_ctx;
+
+enum gc_traverse_op {
+    GC_TRAVERSE_UNLINK,
+    GC_TRAVERSE_SPECULATIVELY,
+    GC_TRAVERSE
+};
+
+HRESULT create_named_item_script_obj(script_ctx_t*,named_item_t*);
+named_item_t *lookup_named_item(script_ctx_t*,const WCHAR*,unsigned);
+void release_named_item(named_item_t*);
+HRESULT gc_run(script_ctx_t*);
+HRESULT gc_process_linked_obj(struct gc_ctx*,enum gc_traverse_op,jsdisp_t*,jsdisp_t*,void**);
+HRESULT gc_process_linked_val(struct gc_ctx*,enum gc_traverse_op,jsdisp_t*,jsval_t*);
 
 typedef struct {
     const WCHAR *name;
@@ -217,21 +181,33 @@ typedef struct {
 
 typedef struct {
     jsclass_t class;
-    builtin_prop_t value_prop;
+    builtin_invoke_t call;
     DWORD props_cnt;
     const builtin_prop_t *props;
     void (*destructor)(jsdisp_t*);
+    ULONG (*addref)(jsdisp_t*);
+    ULONG (*release)(jsdisp_t*);
     void (*on_put)(jsdisp_t*,const WCHAR*);
-    unsigned (*idx_length)(jsdisp_t*);
-    HRESULT (*idx_get)(jsdisp_t*,unsigned,jsval_t*);
-    HRESULT (*idx_put)(jsdisp_t*,unsigned,jsval_t);
+    HRESULT (*lookup_prop)(jsdisp_t*,const WCHAR*,unsigned,struct property_info*);
+    HRESULT (*next_prop)(jsdisp_t*,unsigned,struct property_info*);
+    HRESULT (*prop_get)(jsdisp_t*,unsigned,jsval_t*);
+    HRESULT (*prop_put)(jsdisp_t*,unsigned,jsval_t);
+    HRESULT (*prop_delete)(jsdisp_t*,unsigned);
+    HRESULT (*prop_config)(jsdisp_t*,unsigned,unsigned);
+    HRESULT (*to_string)(jsdisp_t*,jsstr_t**);
+    HRESULT (*gc_traverse)(struct gc_ctx*,enum gc_traverse_op,jsdisp_t*);
 } builtin_info_t;
 
 struct jsdisp_t {
-    IDispatchEx IDispatchEx_iface;
+    IWineJSDispatch IWineJSDispatch_iface;
 
     LONG ref;
 
+    BOOLEAN has_weak_refs;
+    BOOLEAN extensible;
+    BOOLEAN gc_marked;
+    BOOLEAN is_constructor;
+
     DWORD buf_size;
     DWORD prop_cnt;
     dispex_prop_t *props;
@@ -240,99 +216,94 @@ struct jsdisp_t {
     jsdisp_t *prototype;
 
     const builtin_info_t *builtin_info;
+    struct list entry;
 };
 
 static inline IDispatch *to_disp(jsdisp_t *jsdisp)
 {
-    return (IDispatch*)&jsdisp->IDispatchEx_iface;
+    return (IDispatch *)&jsdisp->IWineJSDispatch_iface;
 }
 
-jsdisp_t *as_jsdisp(IDispatch*) DECLSPEC_HIDDEN;
-jsdisp_t *to_jsdisp(IDispatch*) DECLSPEC_HIDDEN;
-void jsdisp_free(jsdisp_t*) DECLSPEC_HIDDEN;
-
-#ifndef TRACE_REFCNT
-
-/*
- * We do a lot of refcount calls during script execution, so having an inline
- * version is a nice perf win. Define TRACE_REFCNT macro when debugging
- * refcount bugs to have traces. Also, since jsdisp_t is not thread safe anyways,
- * there is no point in using atomic operations.
- */
-static inline jsdisp_t *jsdisp_addref(jsdisp_t *jsdisp)
+static inline IDispatchEx *to_dispex(jsdisp_t *jsdisp)
 {
-    jsdisp->ref++;
-    return jsdisp;
+    return (IDispatchEx *)&jsdisp->IWineJSDispatch_iface;
 }
 
-static inline void jsdisp_release(jsdisp_t *jsdisp)
-{
-    if(!--jsdisp->ref)
-        jsdisp_free(jsdisp);
-}
+jsdisp_t *as_jsdisp(IDispatch*);
+jsdisp_t *to_jsdisp(IDispatch*);
+IWineJSDispatchHost *get_host_dispatch(IDispatch*);
 
-#else
+jsdisp_t *jsdisp_addref(jsdisp_t*);
+ULONG jsdisp_release(jsdisp_t*);
 
-jsdisp_t *jsdisp_addref(jsdisp_t*) DECLSPEC_HIDDEN;
-void jsdisp_release(jsdisp_t*) DECLSPEC_HIDDEN;
+enum jsdisp_enum_type {
+    JSDISP_ENUM_ALL,
+    JSDISP_ENUM_OWN,
+    JSDISP_ENUM_OWN_ENUMERABLE
+};
 
-#endif
+HRESULT create_dispex(script_ctx_t*,const builtin_info_t*,jsdisp_t*,jsdisp_t**);
+HRESULT init_dispex(jsdisp_t*,script_ctx_t*,const builtin_info_t*,jsdisp_t*);
+HRESULT init_dispex_from_constr(jsdisp_t*,script_ctx_t*,const builtin_info_t*,jsdisp_t*);
+HRESULT init_host_object(script_ctx_t*,IWineJSDispatchHost*,IWineJSDispatch*,UINT32,IWineJSDispatch**);
+HRESULT init_host_constructor(script_ctx_t*,IWineJSDispatchHost*,IWineJSDispatch*,IWineJSDispatch**);
 
-HRESULT create_dispex(script_ctx_t*,const builtin_info_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT init_dispex(jsdisp_t*,script_ctx_t*,const builtin_info_t*,jsdisp_t*) DECLSPEC_HIDDEN;
-HRESULT init_dispex_from_constr(jsdisp_t*,script_ctx_t*,const builtin_info_t*,jsdisp_t*) DECLSPEC_HIDDEN;
-
-HRESULT disp_call(script_ctx_t*,IDispatch*,DISPID,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT disp_call_value(script_ctx_t*,IDispatch*,IDispatch*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_call_value(jsdisp_t*,IDispatch*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_call(jsdisp_t*,DISPID,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_call_name(jsdisp_t*,const WCHAR*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT disp_propget(script_ctx_t*,IDispatch*,DISPID,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT disp_propput(script_ctx_t*,IDispatch*,DISPID,jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsdisp_propget(jsdisp_t*,DISPID,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_propput(jsdisp_t*,const WCHAR*,DWORD,jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsdisp_propput_name(jsdisp_t*,const WCHAR*,jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsdisp_propput_idx(jsdisp_t*,DWORD,jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsdisp_propget_name(jsdisp_t*,LPCWSTR,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_get_idx(jsdisp_t*,DWORD,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_get_id(jsdisp_t*,const WCHAR*,DWORD,DISPID*) DECLSPEC_HIDDEN;
-HRESULT disp_delete(IDispatch*,DISPID,BOOL*) DECLSPEC_HIDDEN;
-HRESULT disp_delete_name(script_ctx_t*,IDispatch*,jsstr_t*,BOOL*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_delete_idx(jsdisp_t*,DWORD) DECLSPEC_HIDDEN;
-HRESULT jsdisp_get_own_property(jsdisp_t*,const WCHAR*,BOOL,property_desc_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_define_property(jsdisp_t*,const WCHAR*,property_desc_t*) DECLSPEC_HIDDEN;
-HRESULT jsdisp_define_data_property(jsdisp_t*,const WCHAR*,unsigned,jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsdisp_next_prop(jsdisp_t*,DISPID,BOOL,DISPID*) DECLSPEC_HIDDEN;
+HRESULT disp_call(script_ctx_t*,IDispatch*,DISPID,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT disp_call_name(script_ctx_t*,IDispatch*,const WCHAR*,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT disp_call_value_with_caller(script_ctx_t*,IDispatch*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*,IServiceProvider*);
+HRESULT jsdisp_call_value(jsdisp_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT jsdisp_call(jsdisp_t*,DISPID,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT jsdisp_call_name(jsdisp_t*,const WCHAR*,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT disp_propget(script_ctx_t*,IDispatch*,DISPID,jsval_t*);
+HRESULT disp_propput(script_ctx_t*,IDispatch*,DISPID,jsval_t);
+HRESULT disp_propput_name(script_ctx_t*,IDispatch*,const WCHAR*,jsval_t);
+HRESULT jsdisp_propget(jsdisp_t*,DISPID,jsval_t*);
+HRESULT jsdisp_propput(jsdisp_t*,const WCHAR*,DWORD,BOOL,jsval_t);
+HRESULT jsdisp_propput_name(jsdisp_t*,const WCHAR*,jsval_t);
+HRESULT jsdisp_propput_idx(jsdisp_t*,DWORD,jsval_t);
+HRESULT jsdisp_propget_name(jsdisp_t*,LPCWSTR,jsval_t*);
+HRESULT jsdisp_get_idx(jsdisp_t*,DWORD,jsval_t*);
+HRESULT jsdisp_get_id(jsdisp_t*,const WCHAR*,DWORD,DISPID*);
+HRESULT jsdisp_get_idx_id(jsdisp_t*,DWORD,DISPID*);
+HRESULT disp_delete(IDispatch*,DISPID,BOOL*);
+HRESULT disp_delete_name(script_ctx_t*,IDispatch*,jsstr_t*,BOOL*);
+HRESULT jsdisp_index_lookup(jsdisp_t*,const WCHAR*,unsigned,struct property_info*);
+HRESULT jsdisp_next_index(jsdisp_t*,unsigned,unsigned,struct property_info*);
+HRESULT jsdisp_delete_idx(jsdisp_t*,DWORD);
+HRESULT jsdisp_get_own_property(jsdisp_t*,const WCHAR*,BOOL,property_desc_t*);
+HRESULT jsdisp_define_property(jsdisp_t*,const WCHAR*,property_desc_t*);
+HRESULT jsdisp_define_data_property(jsdisp_t*,const WCHAR*,unsigned,jsval_t);
+HRESULT jsdisp_next_prop(jsdisp_t*,DISPID,enum jsdisp_enum_type,DISPID*);
+HRESULT jsdisp_get_prop_name(jsdisp_t*,DISPID,jsstr_t**);
+HRESULT jsdisp_change_prototype(jsdisp_t*,jsdisp_t*);
+void jsdisp_freeze(jsdisp_t*,BOOL);
+BOOL jsdisp_is_frozen(jsdisp_t*,BOOL);
 
 HRESULT create_builtin_function(script_ctx_t*,builtin_invoke_t,const WCHAR*,const builtin_info_t*,DWORD,
-        jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
+        jsdisp_t*,jsdisp_t**);
 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_invoke(jsdisp_t*,IDispatch*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
+        jsdisp_t*,jsdisp_t**);
+HRESULT create_host_function(script_ctx_t*,const struct property_info*,DWORD,jsdisp_t**);
+HRESULT Function_invoke(jsdisp_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
 
-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 Function_value(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT Function_get_value(script_ctx_t*,jsdisp_t*,jsval_t*);
+struct _function_code_t *Function_get_code(jsdisp_t*);
 
-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;
-HRESULT throw_reference_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN;
-HRESULT throw_regexp_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN;
-HRESULT throw_syntax_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN;
-HRESULT throw_type_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN;
-HRESULT throw_uri_error(script_ctx_t*,HRESULT,const WCHAR*) DECLSPEC_HIDDEN;
+HRESULT throw_error(script_ctx_t*,HRESULT,const WCHAR*);
+jsdisp_t *create_builtin_error(script_ctx_t *ctx);
+void handle_dispatch_exception(script_ctx_t *ctx, EXCEPINFO *ei);
 
-HRESULT create_object(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_math(script_ctx_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_array(script_ctx_t*,DWORD,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_regexp(script_ctx_t*,jsstr_t*,DWORD,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_regexp_var(script_ctx_t*,jsval_t,jsval_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_string(script_ctx_t*,jsstr_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_bool(script_ctx_t*,BOOL,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_number(script_ctx_t*,double,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_vbarray(script_ctx_t*,SAFEARRAY*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_json(script_ctx_t*,jsdisp_t**) DECLSPEC_HIDDEN;
+HRESULT create_object(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_math(script_ctx_t*,jsdisp_t**);
+HRESULT create_array(script_ctx_t*,DWORD,jsdisp_t**);
+HRESULT create_regexp(script_ctx_t*,jsstr_t*,DWORD,jsdisp_t**);
+HRESULT create_regexp_var(script_ctx_t*,jsval_t,jsval_t*,jsdisp_t**);
+HRESULT create_string(script_ctx_t*,jsstr_t*,jsdisp_t**);
+HRESULT create_bool(script_ctx_t*,BOOL,jsdisp_t**);
+HRESULT create_number(script_ctx_t*,double,jsdisp_t**);
+HRESULT create_vbarray(script_ctx_t*,SAFEARRAY*,jsdisp_t**);
+HRESULT create_json(script_ctx_t*,jsdisp_t**);
 
 typedef enum {
     NO_HINT,
@@ -340,32 +311,32 @@ typedef enum {
     HINT_NUMBER
 } hint_t;
 
-HRESULT to_primitive(script_ctx_t*,jsval_t,jsval_t*, hint_t) DECLSPEC_HIDDEN;
-HRESULT to_boolean(jsval_t,BOOL*) DECLSPEC_HIDDEN;
-HRESULT to_number(script_ctx_t*,jsval_t,double*) DECLSPEC_HIDDEN;
-HRESULT to_integer(script_ctx_t*,jsval_t,double*) DECLSPEC_HIDDEN;
-HRESULT to_int32(script_ctx_t*,jsval_t,INT*) DECLSPEC_HIDDEN;
-HRESULT to_uint32(script_ctx_t*,jsval_t,UINT32*) DECLSPEC_HIDDEN;
-HRESULT to_string(script_ctx_t*,jsval_t,jsstr_t**) DECLSPEC_HIDDEN;
-HRESULT to_flat_string(script_ctx_t*,jsval_t,jsstr_t**,const WCHAR**) DECLSPEC_HIDDEN;
-HRESULT to_object(script_ctx_t*,jsval_t,IDispatch**) DECLSPEC_HIDDEN;
+HRESULT to_primitive(script_ctx_t*,jsval_t,jsval_t*, hint_t);
+HRESULT to_boolean(jsval_t,BOOL*);
+HRESULT to_number(script_ctx_t*,jsval_t,double*);
+HRESULT to_integer(script_ctx_t*,jsval_t,double*);
+HRESULT to_int32(script_ctx_t*,jsval_t,INT*);
+HRESULT to_long(script_ctx_t*,jsval_t,LONG*);
+HRESULT to_uint32(script_ctx_t*,jsval_t,UINT32*);
+HRESULT to_string(script_ctx_t*,jsval_t,jsstr_t**);
+HRESULT to_flat_string(script_ctx_t*,jsval_t,jsstr_t**,const WCHAR**);
+HRESULT to_object(script_ctx_t*,jsval_t,IDispatch**);
 
-HRESULT jsval_strict_equal(jsval_t,jsval_t,BOOL*) DECLSPEC_HIDDEN;
+HRESULT jsval_strict_equal(jsval_t,jsval_t,BOOL*);
 
-HRESULT variant_change_type(script_ctx_t*,VARIANT*,VARIANT*,VARTYPE) DECLSPEC_HIDDEN;
+HRESULT variant_change_type(script_ctx_t*,VARIANT*,VARIANT*,VARTYPE);
+HRESULT variant_date_to_number(double,double*);
+HRESULT variant_date_to_string(script_ctx_t*,double,jsstr_t**);
 
-HRESULT decode_source(WCHAR*) DECLSPEC_HIDDEN;
+HRESULT decode_source(WCHAR*);
 
-HRESULT double_to_string(double,jsstr_t**) DECLSPEC_HIDDEN;
-BOOL is_finite(double) DECLSPEC_HIDDEN;
+HRESULT double_to_string(double,jsstr_t**);
+WCHAR *idx_to_str(DWORD,WCHAR*);
 
-typedef struct named_item_t {
-    IDispatch *disp;
-    DWORD flags;
-    LPWSTR name;
-
-    struct named_item_t *next;
-} named_item_t;
+static inline BOOL is_digit(WCHAR c)
+{
+    return '0' <= c && c <= '9';
+}
 
 typedef struct _cc_var_t cc_var_t;
 
@@ -373,7 +344,9 @@ typedef struct {
     cc_var_t *vars;
 } cc_ctx_t;
 
-void release_cc(cc_ctx_t*) DECLSPEC_HIDDEN;
+void release_cc(cc_ctx_t*);
+
+#define SP_CALLER_UNINITIALIZED ((IServiceProvider*)IntToPtr(-1))
 
 typedef struct {
     IServiceProvider IServiceProvider_iface;
@@ -381,6 +354,7 @@ typedef struct {
     LONG ref;
 
     script_ctx_t *ctx;
+    IServiceProvider *caller;
 } JSCaller;
 
 #include "jsval.h"
@@ -396,24 +370,25 @@ struct _property_desc_t {
     jsdisp_t *setter;
 };
 
-typedef struct {
-    EXCEPINFO ei;
-    jsval_t val;
-} jsexcept_t;
-
 typedef struct {
     unsigned index;
     unsigned length;
 } match_result_t;
 
+struct weak_refs_entry {
+    struct rb_entry entry;
+    struct list list;
+};
+
 struct _script_ctx_t {
     LONG ref;
 
     SCRIPTSTATE state;
     IActiveScript *active_script;
 
+    struct thread_data *thread_data;
     struct _call_frame_t *call_ctx;
-    named_item_t *named_items;
+    struct list named_items;
     IActiveScriptSite *site;
     IInternetHostSecurityManager *secmgr;
     DWORD safeopt;
@@ -422,14 +397,11 @@ struct _script_ctx_t {
     LCID lcid;
     cc_ctx_t *cc;
     JSCaller *jscaller;
-    jsexcept_t ei;
+    jsexcept_t *ei;
 
     heap_pool_t tmp_heap;
 
-    IDispatch *host_global;
-
     jsval_t *stack;
-    unsigned stack_size;
     unsigned stack_top;
     jsval_t acc;
 
@@ -438,53 +410,75 @@ struct _script_ctx_t {
     DWORD last_match_index;
     DWORD last_match_length;
 
-    jsdisp_t *global;
-    jsdisp_t *function_constr;
-    jsdisp_t *array_constr;
-    jsdisp_t *bool_constr;
-    jsdisp_t *date_constr;
-    jsdisp_t *enumerator_constr;
-    jsdisp_t *error_constr;
-    jsdisp_t *eval_error_constr;
-    jsdisp_t *range_error_constr;
-    jsdisp_t *reference_error_constr;
-    jsdisp_t *regexp_error_constr;
-    jsdisp_t *syntax_error_constr;
-    jsdisp_t *type_error_constr;
-    jsdisp_t *uri_error_constr;
-    jsdisp_t *number_constr;
-    jsdisp_t *object_constr;
-    jsdisp_t *regexp_constr;
-    jsdisp_t *string_constr;
-    jsdisp_t *vbarray_constr;
+    union {
+        struct {
+            jsdisp_t *global;
+            jsdisp_t *function_constr;
+            jsdisp_t *array_constr;
+            jsdisp_t *bool_constr;
+            jsdisp_t *date_constr;
+            jsdisp_t *enumerator_constr;
+            jsdisp_t *error_constr;
+            jsdisp_t *eval_error_constr;
+            jsdisp_t *range_error_constr;
+            jsdisp_t *reference_error_constr;
+            jsdisp_t *regexp_error_constr;
+            jsdisp_t *syntax_error_constr;
+            jsdisp_t *type_error_constr;
+            jsdisp_t *uri_error_constr;
+            jsdisp_t *number_constr;
+            jsdisp_t *object_constr;
+            jsdisp_t *object_prototype;
+            jsdisp_t *regexp_constr;
+            jsdisp_t *string_constr;
+            jsdisp_t *vbarray_constr;
+            jsdisp_t *arraybuf_constr;
+            jsdisp_t *dataview_constr;
+            jsdisp_t *map_prototype;
+            jsdisp_t *set_prototype;
+            jsdisp_t *weakmap_prototype;
+        };
+        jsdisp_t *global_objects[25];
+    };
 };
+C_ASSERT(RTL_SIZEOF_THROUGH_FIELD(script_ctx_t, weakmap_prototype) == RTL_SIZEOF_THROUGH_FIELD(script_ctx_t, global_objects));
 
-void script_release(script_ctx_t*) DECLSPEC_HIDDEN;
-void clear_ei(script_ctx_t*) DECLSPEC_HIDDEN;
+struct weakmap_entry {
+    struct rb_entry entry;
+    jsdisp_t *key;
+    jsval_t value;
+    jsdisp_t *weakmap;
+    struct list weak_refs_entry;
+};
+void remove_weakmap_entry(struct weakmap_entry*);
+
+void script_release(script_ctx_t*);
 
 static inline void script_addref(script_ctx_t *ctx)
 {
     ctx->ref++;
 }
 
-HRESULT init_global(script_ctx_t*) DECLSPEC_HIDDEN;
-HRESULT init_function_constr(script_ctx_t*,jsdisp_t*) DECLSPEC_HIDDEN;
-HRESULT create_object_prototype(script_ctx_t*,jsdisp_t**) DECLSPEC_HIDDEN;
+HRESULT init_global(script_ctx_t*);
+HRESULT init_function_constr(script_ctx_t*,jsdisp_t*);
+HRESULT create_object_prototype(script_ctx_t*,jsdisp_t**);
+HRESULT init_set_constructor(script_ctx_t*);
+HRESULT init_arraybuf_constructors(script_ctx_t*);
 
-HRESULT create_activex_constr(script_ctx_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_array_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_bool_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_date_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT init_error_constr(script_ctx_t*,jsdisp_t*) DECLSPEC_HIDDEN;
-HRESULT create_enumerator_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_number_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_object_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_regexp_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_string_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
-HRESULT create_vbarray_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
+HRESULT create_activex_constr(script_ctx_t*,jsdisp_t**);
+HRESULT create_array_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_bool_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_date_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT init_error_constr(script_ctx_t*,jsdisp_t*);
+HRESULT create_enumerator_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_number_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_object_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_regexp_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_string_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
+HRESULT create_vbarray_constr(script_ctx_t*,jsdisp_t*,jsdisp_t**);
 
-IUnknown *create_ax_site(script_ctx_t*) DECLSPEC_HIDDEN;
-HRESULT create_jscaller(script_ctx_t*) DECLSPEC_HIDDEN;
+IUnknown *create_ax_site(script_ctx_t*);
+HRESULT create_jscaller(script_ctx_t*);
 
 #define REM_CHECK_GLOBAL   0x0001
 #define REM_RESET_INDEX    0x0002
@@ -492,25 +486,25 @@ HRESULT create_jscaller(script_ctx_t*) DECLSPEC_HIDDEN;
 #define REM_ALLOC_RESULT   0x0008
 #define REM_NO_PARENS      0x0010
 struct match_state_t;
-HRESULT regexp_match_next(script_ctx_t*,jsdisp_t*,DWORD,jsstr_t*,struct match_state_t**) DECLSPEC_HIDDEN;
-HRESULT parse_regexp_flags(const WCHAR*,DWORD,DWORD*) DECLSPEC_HIDDEN;
-HRESULT regexp_string_match(script_ctx_t*,jsdisp_t*,jsstr_t*,jsval_t*) DECLSPEC_HIDDEN;
+HRESULT regexp_match_next(script_ctx_t*,jsdisp_t*,DWORD,jsstr_t*,struct match_state_t**);
+HRESULT parse_regexp_flags(const WCHAR*,DWORD,DWORD*);
+HRESULT regexp_string_match(script_ctx_t*,jsdisp_t*,jsstr_t*,jsval_t*);
 
-BOOL bool_obj_value(jsdisp_t*) DECLSPEC_HIDDEN;
-unsigned array_get_length(jsdisp_t*) DECLSPEC_HIDDEN;
+BOOL bool_obj_value(jsdisp_t*);
+unsigned array_get_length(jsdisp_t*);
+HRESULT localize_number(script_ctx_t*,DOUBLE,BOOL,jsstr_t**);
 
-HRESULT JSGlobal_eval(script_ctx_t*,vdisp_t*,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN;
+BOOL is_builtin_eval_func(jsdisp_t*);
+HRESULT builtin_eval(script_ctx_t*,struct _call_frame_t*,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT JSGlobal_eval(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT Object_get_proto_(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
+HRESULT Object_set_proto_(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*);
 
 static inline BOOL is_class(jsdisp_t *jsdisp, jsclass_t class)
 {
     return jsdisp->builtin_info->class == class;
 }
 
-static inline BOOL is_vclass(vdisp_t *vdisp, jsclass_t class)
-{
-    return is_jsdisp(vdisp) && is_class(vdisp->u.jsdisp, class);
-}
-
 static inline BOOL is_int32(double d)
 {
     return INT32_MIN <= d && d <= INT32_MAX && (double)(int)d == d;
@@ -521,16 +515,24 @@ static inline DWORD make_grfdex(script_ctx_t *ctx, DWORD flags)
     return ((ctx->version & 0xff) << 28) | flags;
 }
 
-#define MAKE_JSERROR(code) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_JSCRIPT, code)
+static inline HRESULT disp_call_value(script_ctx_t *ctx, IDispatch *disp, jsval_t vthis, WORD flags, unsigned argc,
+        jsval_t *argv, jsval_t *r)
+{
+    return disp_call_value_with_caller(ctx, disp, vthis, flags, argc, argv, r, &ctx->jscaller->IServiceProvider_iface);
+}
+
+#define MAKE_JSERROR(code) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_CONTROL, code)
 
 #define JS_E_TO_PRIMITIVE            MAKE_JSERROR(IDS_TO_PRIMITIVE)
 #define JS_E_INVALIDARG              MAKE_JSERROR(IDS_INVALID_CALL_ARG)
 #define JS_E_SUBSCRIPT_OUT_OF_RANGE  MAKE_JSERROR(IDS_SUBSCRIPT_OUT_OF_RANGE)
+#define JS_E_STACK_OVERFLOW          MAKE_JSERROR(IDS_STACK_OVERFLOW)
 #define JS_E_OBJECT_REQUIRED         MAKE_JSERROR(IDS_OBJECT_REQUIRED)
 #define JS_E_CANNOT_CREATE_OBJ       MAKE_JSERROR(IDS_CREATE_OBJ_ERROR)
 #define JS_E_INVALID_PROPERTY        MAKE_JSERROR(IDS_NO_PROPERTY)
 #define JS_E_INVALID_ACTION          MAKE_JSERROR(IDS_UNSUPPORTED_ACTION)
 #define JS_E_MISSING_ARG             MAKE_JSERROR(IDS_ARG_NOT_OPT)
+#define JS_E_OBJECT_NOT_COLLECTION   MAKE_JSERROR(IDS_OBJECT_NOT_COLLECTION)
 #define JS_E_SYNTAX                  MAKE_JSERROR(IDS_SYNTAX_ERROR)
 #define JS_E_MISSING_SEMICOLON       MAKE_JSERROR(IDS_SEMICOLON)
 #define JS_E_MISSING_LBRACKET        MAKE_JSERROR(IDS_LBRACKET)
@@ -557,29 +559,42 @@ static inline DWORD make_grfdex(script_ctx_t *ctx, DWORD flags)
 #define JS_E_VBARRAY_EXPECTED        MAKE_JSERROR(IDS_NOT_VBARRAY)
 #define JS_E_INVALID_DELETE          MAKE_JSERROR(IDS_INVALID_DELETE)
 #define JS_E_JSCRIPT_EXPECTED        MAKE_JSERROR(IDS_JSCRIPT_EXPECTED)
-#define JS_E_ENUMERATOR_EXPECTED     MAKE_JSERROR(IDS_NOT_ENUMERATOR)
+#define JS_E_ENUMERATOR_EXPECTED     MAKE_JSERROR(IDS_ENUMERATOR_EXPECTED)
+#define JS_E_REGEXP_EXPECTED         MAKE_JSERROR(IDS_REGEXP_EXPECTED)
 #define JS_E_REGEXP_SYNTAX           MAKE_JSERROR(IDS_REGEXP_SYNTAX_ERROR)
+#define JS_E_UNEXPECTED_QUANTIFIER   MAKE_JSERROR(IDS_UNEXPECTED_QUANTIFIER)
+#define JS_E_EXCEPTION_THROWN        MAKE_JSERROR(IDS_EXCEPTION_THROWN)
 #define JS_E_INVALID_URI_CODING      MAKE_JSERROR(IDS_URI_INVALID_CODING)
 #define JS_E_INVALID_URI_CHAR        MAKE_JSERROR(IDS_URI_INVALID_CHAR)
 #define JS_E_FRACTION_DIGITS_OUT_OF_RANGE MAKE_JSERROR(IDS_FRACTION_DIGITS_OUT_OF_RANGE)
 #define JS_E_PRECISION_OUT_OF_RANGE  MAKE_JSERROR(IDS_PRECISION_OUT_OF_RANGE)
 #define JS_E_INVALID_LENGTH          MAKE_JSERROR(IDS_INVALID_LENGTH)
 #define JS_E_ARRAY_EXPECTED          MAKE_JSERROR(IDS_ARRAY_EXPECTED)
+#define JS_E_CYCLIC_PROTO_VALUE      MAKE_JSERROR(IDS_CYCLIC_PROTO_VALUE)
+#define JS_E_CANNOT_CREATE_FOR_NONEXTENSIBLE MAKE_JSERROR(IDS_CREATE_FOR_NONEXTENSIBLE)
+#define JS_E_OBJECT_NONEXTENSIBLE    MAKE_JSERROR(IDS_OBJECT_NONEXTENSIBLE)
 #define JS_E_NONCONFIGURABLE_REDEFINED MAKE_JSERROR(IDS_NONCONFIGURABLE_REDEFINED)
 #define JS_E_NONWRITABLE_MODIFIED    MAKE_JSERROR(IDS_NONWRITABLE_MODIFIED)
+#define JS_E_NOT_DATAVIEW            MAKE_JSERROR(IDS_NOT_DATAVIEW)
+#define JS_E_DATAVIEW_NO_ARGUMENT    MAKE_JSERROR(IDS_DATAVIEW_NO_ARGUMENT)
+#define JS_E_DATAVIEW_INVALID_ACCESS MAKE_JSERROR(IDS_DATAVIEW_INVALID_ACCESS)
+#define JS_E_DATAVIEW_INVALID_OFFSET MAKE_JSERROR(IDS_DATAVIEW_INVALID_OFFSET)
+#define JS_E_WRONG_THIS              MAKE_JSERROR(IDS_WRONG_THIS)
+#define JS_E_KEY_NOT_OBJECT          MAKE_JSERROR(IDS_KEY_NOT_OBJECT)
+#define JS_E_ARRAYBUFFER_EXPECTED    MAKE_JSERROR(IDS_ARRAYBUFFER_EXPECTED)
 #define JS_E_PROP_DESC_MISMATCH      MAKE_JSERROR(IDS_PROP_DESC_MISMATCH)
 #define JS_E_INVALID_WRITABLE_PROP_DESC MAKE_JSERROR(IDS_INVALID_WRITABLE_PROP_DESC)
 
 static inline BOOL is_jscript_error(HRESULT hres)
 {
-    return HRESULT_FACILITY(hres) == FACILITY_JSCRIPT;
+    return HRESULT_FACILITY(hres) == FACILITY_CONTROL;
 }
 
-const char *debugstr_jsval(const jsval_t) DECLSPEC_HIDDEN;
+const char *debugstr_jsval(const jsval_t);
 
-HRESULT create_jscript_object(BOOL,REFIID,void**) DECLSPEC_HIDDEN;
+HRESULT create_jscript_object(BOOL,REFIID,void**);
 
-extern LONG module_ref DECLSPEC_HIDDEN;
+extern LONG module_ref ;
 
 static inline void lock_module(void)
 {

dll/win32/jscript/jscript_classes.rgs

@@ -1,36 +0,0 @@
-HKCR
-{
-    NoRemove Interface
-    {
-    }
-    NoRemove CLSID
-    {
-        '{F414C260-6AC0-11CF-B6D1-00AA00BBBB58}' = s 'JScript Language'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-            ProgId = s 'JScript'
-        }
-        '{F414C261-6AC0-11CF-B6D1-00AA00BBBB58}' = s 'JScript Language Authoring'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-            ProgId = s 'JScript Author'
-        }
-        '{F414C262-6AC0-11CF-B6D1-00AA00BBBB58}' = s 'JScript Language Encoding'
-        {
-            InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Both' }
-            ProgId = s 'JScript.Encode'
-        }
-    }
-    'JScript' = s 'JScript Language'
-    {
-        CLSID = s '{F414C260-6AC0-11CF-B6D1-00AA00BBBB58}'
-    }
-    'JScript Author' = s 'JScript Language Authoring'
-    {
-        CLSID = s '{F414C261-6AC0-11CF-B6D1-00AA00BBBB58}'
-    }
-    'JScript.Encode' = s 'JScript Language Encoding'
-    {
-        CLSID = s '{F414C262-6AC0-11CF-B6D1-00AA00BBBB58}'
-    }
-}

dll/win32/jscript/jscript_main.c

@@ -27,6 +27,7 @@
 #include "mshtmhst.h"
 #include "rpcproxy.h"
 #include "jscript_classes.h"
+#include "jsdisp.h"
 
 #include "wine/debug.h"
 
@@ -37,6 +38,65 @@ LONG module_ref = 0;
 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 
 HINSTANCE jscript_hinstance;
+static DWORD jscript_tls;
+static ITypeInfo *dispatch_typeinfo;
+
+static int weak_refs_compare(const void *key, const struct rb_entry *entry)
+{
+    const struct weak_refs_entry *weak_refs_entry = RB_ENTRY_VALUE(entry, const struct weak_refs_entry, entry);
+    ULONG_PTR a = (ULONG_PTR)key, b = (ULONG_PTR)LIST_ENTRY(weak_refs_entry->list.next, struct weakmap_entry, weak_refs_entry)->key;
+    return (a > b) - (a < b);
+}
+
+struct thread_data *get_thread_data(void)
+{
+    struct thread_data *thread_data = TlsGetValue(jscript_tls);
+
+    if(!thread_data) {
+        thread_data = calloc(1, sizeof(struct thread_data));
+        if(!thread_data)
+            return NULL;
+        thread_data->thread_id = GetCurrentThreadId();
+        list_init(&thread_data->objects);
+        rb_init(&thread_data->weak_refs, weak_refs_compare);
+        TlsSetValue(jscript_tls, thread_data);
+    }
+
+    thread_data->ref++;
+    return thread_data;
+}
+
+void release_thread_data(struct thread_data *thread_data)
+{
+    if(--thread_data->ref)
+        return;
+
+    free(thread_data);
+    TlsSetValue(jscript_tls, NULL);
+}
+
+HRESULT get_dispatch_typeinfo(ITypeInfo **out)
+{
+    ITypeInfo *typeinfo;
+    ITypeLib *typelib;
+    HRESULT hr;
+
+    if (!dispatch_typeinfo)
+    {
+        hr = LoadRegTypeLib(&IID_StdOle, STDOLE_MAJORVERNUM, STDOLE_MINORVERNUM, STDOLE_LCID, &typelib);
+        if (FAILED(hr)) return hr;
+
+        hr = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IDispatch, &typeinfo);
+        ITypeLib_Release(typelib);
+        if (FAILED(hr)) return hr;
+
+        if (InterlockedCompareExchangePointer((void**)&dispatch_typeinfo, typeinfo, NULL))
+            ITypeInfo_Release(typeinfo);
+    }
+
+    *out = dispatch_typeinfo;
+    return S_OK;
+}
 
 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 {
@@ -134,18 +194,22 @@ static IClassFactory JScriptEncodeFactory = { &JScriptEncodeFactoryVtbl };
  */
 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 {
-    TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv);
+    TRACE("(%p %ld %p)\n", hInstDLL, fdwReason, lpv);
 
     switch(fdwReason) {
     case DLL_PROCESS_ATTACH:
         DisableThreadLibraryCalls(hInstDLL);
         jscript_hinstance = hInstDLL;
-        if(!init_strings())
+        jscript_tls = TlsAlloc();
+        if(jscript_tls == TLS_OUT_OF_INDEXES || !init_strings())
             return FALSE;
         break;
     case DLL_PROCESS_DETACH:
         if (lpv) break;
+        if (dispatch_typeinfo) ITypeInfo_Release(dispatch_typeinfo);
+        if(jscript_tls != TLS_OUT_OF_INDEXES) TlsFree(jscript_tls);
         free_strings();
+        break;
     }
 
     return TRUE;
@@ -175,25 +239,7 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
  */
 HRESULT WINAPI DllCanUnloadNow(void)
 {
-    TRACE("() ref=%d\n", module_ref);
+    TRACE("() ref=%ld\n", module_ref);
 
     return module_ref ? S_FALSE : S_OK;
 }
-
-/***********************************************************************
- *          DllRegisterServer (jscript.@)
- */
-HRESULT WINAPI DllRegisterServer(void)
-{
-    TRACE("()\n");
-    return __wine_register_resources(jscript_hinstance);
-}
-
-/***********************************************************************
- *          DllUnregisterServer (jscript.@)
- */
-HRESULT WINAPI DllUnregisterServer(void)
-{
-    TRACE("()\n");
-    return __wine_unregister_resources(jscript_hinstance);
-}

dll/win32/jscript/jsdisp.idl

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2024 Gabriel Ivăncescu for CodeWeavers
+ * Copyright 2024 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 makedep header
+
+import "dispex.idl";
+
+struct property_info
+{
+    UINT32 id;
+    UINT32 flags;
+    const WCHAR *name;
+    UINT32 index;
+    UINT32 iid;
+};
+
+const unsigned int PROPF_METHOD       = 0x0100;
+const unsigned int PROPF_CONSTR       = 0x0200;
+
+const unsigned int PROPF_ENUMERABLE   = 0x0400;
+const unsigned int PROPF_WRITABLE     = 0x0800;
+const unsigned int PROPF_CONFIGURABLE = 0x1000;
+
+const unsigned int PROPF_PUBLIC_MASK = PROPF_ENUMERABLE | PROPF_WRITABLE | PROPF_CONFIGURABLE;
+
+const unsigned int HOSTOBJ_CONSTRUCTOR = 0x0001;
+
+interface IWineJSDispatchHost;
+
+[
+    object,
+    uuid(d359f2fe-5531-741b-a41a-5cf92edc971c),
+    local
+]
+interface IWineJSDispatch : IDispatchEx
+{
+    void Free();
+    HRESULT GetPropertyFlags(DISPID id, UINT32 *ret);
+    HRESULT GetScriptGlobal(IWineJSDispatchHost **ret);
+}
+
+[
+    object,
+    uuid(b1ebc544-6644-40c6-97f6-ccd9cc32bfba),
+    local
+]
+interface IWineJSDispatchHost : IDispatchEx
+{
+    HRESULT GetJSDispatch(IWineJSDispatch **ret);
+    HRESULT LookupProperty(const WCHAR *name, DWORD flags, struct property_info *desc);
+    HRESULT NextProperty(DISPID id, struct property_info *desc);
+    HRESULT GetProperty(DISPID id, LCID lcid, VARIANT *r, EXCEPINFO *ei, IServiceProvider *caller);
+    HRESULT SetProperty(DISPID id, LCID lcid, VARIANT *v, EXCEPINFO *ei, IServiceProvider *caller);
+    HRESULT DeleteProperty(DISPID id);
+    HRESULT ConfigureProperty(DISPID id, UINT32 flags);
+    HRESULT CallFunction(DISPID id, UINT32 iid, DWORD flags, DISPPARAMS *dp, VARIANT *ret, EXCEPINFO *ei, IServiceProvider *caller);
+    HRESULT Construct(LCID lcid, DWORD flags, DISPPARAMS *dp, VARIANT *ret, EXCEPINFO *ei, IServiceProvider *caller);
+    HRESULT GetOuterDispatch(IWineJSDispatchHost **ret);
+    HRESULT ToString(BSTR *str);
+}
+
+[
+    object,
+    uuid(d359f2fe-5531-741b-a41a-5cf92edc971d),
+    local
+]
+interface IWineJScript : IUnknown
+{
+    HRESULT InitHostObject(IWineJSDispatchHost *host_obj, IWineJSDispatch *prototype, UINT32 flags, IWineJSDispatch **ret);
+    HRESULT InitHostConstructor(IWineJSDispatchHost *constr, IWineJSDispatch *prototype, IWineJSDispatch **ret);
+}

dll/win32/jscript/jsglobal.rgs

@@ -1,146 +0,0 @@
-HKCR
-{
-    NoRemove Typelib
-    {
-        NoRemove '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}'
-        {
-            '1.0' = s 'JSGlobal'
-            {
-                '0' { win32 = s '%MODULE%' }
-                FLAGS = s '0'
-            }
-        }
-    }
-    NoRemove Interface
-    {
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B086}' = s 'GlobalObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B087}' = s 'DateObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B088}' = s 'MathObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B089}' = s 'NumberObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B090}' = s 'RegExpObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B091}' = s 'StringObj'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B092}' = s 'ArrayInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B093}' = s 'FunctionInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B094}' = s 'StringInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B095}' = s 'BoolInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B096}' = s 'NumberInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B097}' = s 'ObjectInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B098}' = s 'DateInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B099}' = s 'RegExpInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09A}' = s 'ErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09B}' = s 'EvalErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09C}' = s 'RangeErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09D}' = s 'ReferenceErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09E}' = s 'SyntaxErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B09F}' = s 'TypeErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-        '{3EEF9758-35FC-11D1-8CE4-00C04FC2B0A0}' = s 'URIErrorInstance'
-        {
-            ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'
-            ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'
-            TypeLib = s '{3EEF9759-35FC-11D1-8CE4-00C04FC2B085}' { val Version = s '1.0' }
-        }
-    }
-    NoRemove CLSID
-    {
-    }
-}

dll/win32/jscript/json.c

@@ -16,6 +16,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
+
 #include <math.h>
 #include <assert.h>
 
@@ -26,15 +31,6 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static const WCHAR parseW[] = {'p','a','r','s','e',0};
-static const WCHAR stringifyW[] = {'s','t','r','i','n','g','i','f','y',0};
-
-static const WCHAR nullW[] = {'n','u','l','l',0};
-static const WCHAR trueW[] = {'t','r','u','e',0};
-static const WCHAR falseW[] = {'f','a','l','s','e',0};
-
-static const WCHAR toJSONW[] = {'t','o','J','S','O','N',0};
-
 typedef struct {
     const WCHAR *ptr;
     const WCHAR *end;
@@ -66,6 +62,77 @@ static BOOL is_keyword(json_parse_ctx_t *ctx, const WCHAR *keyword)
     return TRUE;
 }
 
+static BOOL unescape_json_string(WCHAR *str, size_t *len)
+{
+    WCHAR *pd, *p, c, *end = str + *len;
+    int i;
+
+    pd = p = str;
+    while(p < end) {
+        if(*p != '\\') {
+            *pd++ = *p++;
+            continue;
+        }
+
+        if(++p == end)
+            return FALSE;
+
+        switch(*p) {
+        case '\"':
+        case '\\':
+        case '/':
+            c = *p;
+            break;
+        case 'b':
+            c = '\b';
+            break;
+        case 't':
+            c = '\t';
+            break;
+        case 'n':
+            c = '\n';
+            break;
+        case 'f':
+            c = '\f';
+            break;
+        case 'r':
+            c = '\r';
+            break;
+        case 'u':
+            if(p + 4 >= end)
+                return FALSE;
+            i = hex_to_int(*++p);
+            if(i == -1)
+                return FALSE;
+            c = i << 12;
+
+            i = hex_to_int(*++p);
+            if(i == -1)
+                return FALSE;
+            c += i << 8;
+
+            i = hex_to_int(*++p);
+            if(i == -1)
+                return FALSE;
+            c += i << 4;
+
+            i = hex_to_int(*++p);
+            if(i == -1)
+                return FALSE;
+            c += i;
+            break;
+        default:
+            return FALSE;
+        }
+
+        *pd++ = c;
+        p++;
+    }
+
+    *len = pd - str;
+    return TRUE;
+}
+
 /* ECMA-262 5.1 Edition    15.12.1.1 */
 static HRESULT parse_json_string(json_parse_ctx_t *ctx, WCHAR **r)
 {
@@ -83,16 +150,16 @@ static HRESULT parse_json_string(json_parse_ctx_t *ctx, WCHAR **r)
     }
 
     len = ctx->ptr-ptr;
-    buf = heap_alloc((len+1)*sizeof(WCHAR));
+    buf = malloc((len+1)*sizeof(WCHAR));
     if(!buf)
         return E_OUTOFMEMORY;
     if(len)
         memcpy(buf, ptr, len*sizeof(WCHAR));
 
-    if(!unescape(buf, &len)) {
-        FIXME("unescape failed\n");
-        heap_free(buf);
-        return E_FAIL;
+    if(!(ctx->ctx->html_mode ? unescape_json_string(buf, &len) : unescape(buf, &len))) {
+        WARN("unescape failed\n");
+        free(buf);
+        return JS_E_INVALID_CHAR;
     }
 
     buf[len] = 0;
@@ -110,19 +177,19 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
 
     /* JSONNullLiteral */
     case 'n':
-        if(!is_keyword(ctx, nullW))
+        if(!is_keyword(ctx, L"null"))
             break;
         *r = jsval_null();
         return S_OK;
 
     /* JSONBooleanLiteral */
     case 't':
-        if(!is_keyword(ctx, trueW))
+        if(!is_keyword(ctx, L"true"))
             break;
         *r = jsval_bool(TRUE);
         return S_OK;
     case 'f':
-        if(!is_keyword(ctx, falseW))
+        if(!is_keyword(ctx, L"false"))
             break;
         *r = jsval_bool(FALSE);
         return S_OK;
@@ -153,7 +220,7 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
 
             if(skip_spaces(ctx) != ':') {
                 FIXME("missing ':'\n");
-                heap_free(prop_name);
+                free(prop_name);
                 break;
             }
 
@@ -163,7 +230,7 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
                 hres = jsdisp_propput_name(obj, prop_name, val);
                 jsval_release(val);
             }
-            heap_free(prop_name);
+            free(prop_name);
             if(FAILED(hres))
                 break;
 
@@ -195,7 +262,7 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
 
         /* FIXME: avoid reallocation */
         str = jsstr_alloc(string);
-        heap_free(string);
+        free(string);
         if(!str)
             return E_OUTOFMEMORY;
 
@@ -260,7 +327,7 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
             skip_spaces(ctx);
         }
 
-        if(*ctx->ptr == '0' && ctx->ptr + 1 < ctx->end && iswdigit(ctx->ptr[1]))
+        if(*ctx->ptr == '0' && ctx->ptr + 1 < ctx->end && is_digit(ctx->ptr[1]))
             break;
 
         hres = parse_decimal(&ctx->ptr, ctx->end, &n);
@@ -276,20 +343,106 @@ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r)
     return E_FAIL;
 }
 
+struct transform_json_object_ctx
+{
+    script_ctx_t *ctx;
+    IDispatch *reviver;
+    HRESULT hres;
+};
+
+static jsval_t transform_json_object(struct transform_json_object_ctx *proc_ctx, jsdisp_t *holder, jsstr_t *name)
+{
+    jsval_t res, args[2];
+    const WCHAR *str;
+
+    if(!(str = jsstr_flatten(name)))
+        proc_ctx->hres = E_OUTOFMEMORY;
+    else
+        proc_ctx->hres = jsdisp_propget_name(holder, str, &args[1]);
+    if(FAILED(proc_ctx->hres))
+        return jsval_undefined();
+
+    if(is_object_instance(args[1])) {
+        jsdisp_t *obj = to_jsdisp(get_object(args[1]));
+        jsstr_t *jsstr;
+        DISPID id;
+        BOOL b;
+
+        if(!obj) {
+            FIXME("non-JS obj in JSON object: %p\n", get_object(args[1]));
+            proc_ctx->hres = E_NOTIMPL;
+            goto ret;
+        }else if(is_class(obj, JSCLASS_ARRAY)) {
+            unsigned i, length = array_get_length(obj);
+            WCHAR buf[14], *buf_end;
+
+            buf_end = buf + ARRAY_SIZE(buf) - 1;
+            *buf_end-- = 0;
+            for(i = 0; i < length; i++) {
+                str = idx_to_str(i, buf_end);
+                if(!(jsstr = jsstr_alloc(str))) {
+                    proc_ctx->hres = E_OUTOFMEMORY;
+                    goto ret;
+                }
+                res = transform_json_object(proc_ctx, obj, jsstr);
+                jsstr_release(jsstr);
+                if(is_undefined(res)) {
+                    if(FAILED(proc_ctx->hres))
+                        goto ret;
+                    if(FAILED(jsdisp_get_id(obj, str, 0, &id)))
+                        continue;
+                    proc_ctx->hres = disp_delete(to_disp(obj), id, &b);
+                }else {
+                    proc_ctx->hres = jsdisp_define_data_property(obj, str, PROPF_WRITABLE | PROPF_ENUMERABLE | PROPF_CONFIGURABLE, res);
+                    jsval_release(res);
+                }
+                if(FAILED(proc_ctx->hres))
+                    goto ret;
+            }
+        }else {
+            id = DISPID_STARTENUM;
+            for(;;) {
+                proc_ctx->hres = jsdisp_next_prop(obj, id, JSDISP_ENUM_OWN_ENUMERABLE, &id);
+                if(proc_ctx->hres == S_FALSE)
+                    break;
+                if(FAILED(proc_ctx->hres) || FAILED(proc_ctx->hres = jsdisp_get_prop_name(obj, id, &jsstr)))
+                    goto ret;
+                res = transform_json_object(proc_ctx, obj, jsstr);
+                if(is_undefined(res)) {
+                    if(SUCCEEDED(proc_ctx->hres))
+                        proc_ctx->hres = disp_delete(to_disp(obj), id, &b);
+                }else {
+                    if(!(str = jsstr_flatten(jsstr)))
+                        proc_ctx->hres = E_OUTOFMEMORY;
+                    else
+                        proc_ctx->hres = jsdisp_define_data_property(obj, str, PROPF_WRITABLE | PROPF_ENUMERABLE | PROPF_CONFIGURABLE, res);
+                    jsval_release(res);
+                }
+                jsstr_release(jsstr);
+                if(FAILED(proc_ctx->hres))
+                    goto ret;
+            }
+        }
+    }
+
+    args[0] = jsval_string(name);
+    proc_ctx->hres = disp_call_value(proc_ctx->ctx, proc_ctx->reviver, jsval_obj(holder),
+                                     DISPATCH_METHOD, ARRAY_SIZE(args), args, &res);
+ret:
+    jsval_release(args[1]);
+    return FAILED(proc_ctx->hres) ? jsval_undefined() : res;
+}
+
 /* ECMA-262 5.1 Edition    15.12.2 */
-static HRESULT JSON_parse(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+static HRESULT JSON_parse(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 {
     json_parse_ctx_t parse_ctx;
     const WCHAR *buf;
+    jsdisp_t *root;
     jsstr_t *str;
     jsval_t ret;
     HRESULT hres;
 
-    if(argc != 1) {
-        FIXME("Unsupported args\n");
-        return E_INVALIDARG;
-    }
-
     hres = to_flat_string(ctx, argv[0], &str, &buf);
     if(FAILED(hres))
         return hres;
@@ -300,14 +453,36 @@ static HRESULT JSON_parse(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsign
     parse_ctx.end = buf + jsstr_length(str);
     parse_ctx.ctx = ctx;
     hres = parse_json_value(&parse_ctx, &ret);
+    if(SUCCEEDED(hres) && skip_spaces(&parse_ctx)) {
+        FIXME("syntax error\n");
+        jsval_release(ret);
+        hres = E_FAIL;
+    }
     jsstr_release(str);
     if(FAILED(hres))
         return hres;
 
-    if(skip_spaces(&parse_ctx)) {
-        FIXME("syntax error\n");
+    /* FIXME: check IsCallable */
+    if(argc > 1 && is_object_instance(argv[1])) {
+        hres = create_object(ctx, NULL, &root);
+        if(FAILED(hres)) {
+            jsval_release(ret);
+            return hres;
+        }
+        hres = jsdisp_define_data_property(root, L"", PROPF_WRITABLE | PROPF_ENUMERABLE | PROPF_CONFIGURABLE, ret);
         jsval_release(ret);
-        return E_FAIL;
+
+        if(SUCCEEDED(hres)) {
+            struct transform_json_object_ctx proc_ctx = { ctx, get_object(argv[1]), S_OK };
+
+            str = jsstr_empty();
+            ret = transform_json_object(&proc_ctx, root, str);
+            jsstr_release(str);
+            hres = proc_ctx.hres;
+        }
+        jsdisp_release(root);
+        if(FAILED(hres))
+            return hres;
     }
 
     if(r)
@@ -329,19 +504,21 @@ typedef struct {
     size_t stack_size;
 
     WCHAR gap[11]; /* according to the spec, it's no longer than 10 chars */
+
+    jsdisp_t *replacer;
 } stringify_ctx_t;
 
 static BOOL stringify_push_obj(stringify_ctx_t *ctx, jsdisp_t *obj)
 {
     if(!ctx->stack_size) {
-        ctx->stack = heap_alloc(4*sizeof(*ctx->stack));
+        ctx->stack = malloc(4*sizeof(*ctx->stack));
         if(!ctx->stack)
             return FALSE;
         ctx->stack_size = 4;
     }else if(ctx->stack_top == ctx->stack_size) {
         jsdisp_t **new_stack;
 
-        new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack));
+        new_stack = realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack));
         if(!new_stack)
             return FALSE;
         ctx->stack = new_stack;
@@ -370,7 +547,7 @@ static BOOL is_on_stack(stringify_ctx_t *ctx, jsdisp_t *obj)
 static BOOL append_string_len(stringify_ctx_t *ctx, const WCHAR *str, size_t len)
 {
     if(!ctx->buf_size) {
-        ctx->buf = heap_alloc(len*2*sizeof(WCHAR));
+        ctx->buf = malloc(len*2*sizeof(WCHAR));
         if(!ctx->buf)
             return FALSE;
         ctx->buf_size = len*2;
@@ -379,7 +556,7 @@ static BOOL append_string_len(stringify_ctx_t *ctx, const WCHAR *str, size_t len
         size_t new_size;
 
         new_size = ctx->buf_size * 2 + len;
-        new_buf = heap_realloc(ctx->buf, new_size*sizeof(WCHAR));
+        new_buf = realloc(ctx->buf, new_size*sizeof(WCHAR));
         if(!new_buf)
             return FALSE;
         ctx->buf = new_buf;
@@ -413,7 +590,7 @@ static HRESULT maybe_to_primitive(script_ctx_t *ctx, jsval_t val, jsval_t *r)
     jsdisp_t *obj;
     HRESULT hres;
 
-    if(!is_object_instance(val) || !get_object(val) || !(obj = iface_to_jsdisp(get_object(val))))
+    if(!is_object_instance(val) || !(obj = iface_to_jsdisp(get_object(val))))
         return jsval_copy(val, r);
 
     if(is_class(obj, JSCLASS_NUMBER)) {
@@ -479,9 +656,8 @@ static HRESULT json_quote(stringify_ctx_t *ctx, const WCHAR *ptr, size_t len)
             break;
         default:
             if(*ptr < ' ') {
-                static const WCHAR formatW[] = {'\\','u','%','0','4','x',0};
                 WCHAR buf[7];
-                swprintf(buf, formatW, *ptr);
+                swprintf(buf, ARRAY_SIZE(buf), L"\\u%04x", *ptr);
                 if(!append_string(ctx, buf))
                     return E_OUTOFMEMORY;
             }else {
@@ -500,13 +676,13 @@ static inline BOOL is_callable(jsdisp_t *obj)
     return is_class(obj, JSCLASS_FUNCTION);
 }
 
-static HRESULT stringify(stringify_ctx_t *ctx, jsval_t val);
+static HRESULT stringify(stringify_ctx_t *ctx, jsdisp_t *object, const WCHAR *name);
 
 /* ECMA-262 5.1 Edition    15.12.3 (abstract operation JA) */
 static HRESULT stringify_array(stringify_ctx_t *ctx, jsdisp_t *obj)
 {
     unsigned length, i, j;
-    jsval_t val;
+    WCHAR name[16];
     HRESULT hres;
 
     if(is_on_stack(ctx, obj)) {
@@ -536,19 +712,12 @@ static HRESULT stringify_array(stringify_ctx_t *ctx, jsdisp_t *obj)
             }
         }
 
-        hres = jsdisp_get_idx(obj, i, &val);
-        if(SUCCEEDED(hres)) {
-            hres = stringify(ctx, val);
-            if(FAILED(hres))
-                return hres;
-            if(hres == S_FALSE && !append_string(ctx, nullW))
-                return E_OUTOFMEMORY;
-        }else if(hres == DISP_E_UNKNOWNNAME) {
-            if(!append_string(ctx, nullW))
-                return E_OUTOFMEMORY;
-        }else {
+        _itow(i, name, ARRAY_SIZE(name));
+        hres = stringify(ctx, obj, name);
+        if(FAILED(hres))
             return hres;
-        }
+        if(hres == S_FALSE && !append_string(ctx, L"null"))
+            return E_OUTOFMEMORY;
     }
 
     if((length && *ctx->gap && !append_char(ctx, '\n')) || !append_char(ctx, ']'))
@@ -562,7 +731,6 @@ static HRESULT stringify_array(stringify_ctx_t *ctx, jsdisp_t *obj)
 static HRESULT stringify_object(stringify_ctx_t *ctx, jsdisp_t *obj)
 {
     DISPID dispid = DISPID_STARTENUM;
-    jsval_t val = jsval_undefined();
     unsigned prop_cnt = 0, i;
     size_t stepback;
     BSTR prop_name;
@@ -579,15 +747,7 @@ static HRESULT stringify_object(stringify_ctx_t *ctx, jsdisp_t *obj)
     if(!append_char(ctx, '{'))
         return E_OUTOFMEMORY;
 
-    while((hres = IDispatchEx_GetNextDispID(&obj->IDispatchEx_iface, fdexEnumDefault, dispid, &dispid)) == S_OK) {
-        jsval_release(val);
-        hres = jsdisp_propget(obj, dispid, &val);
-        if(FAILED(hres))
-            return hres;
-
-        if(is_undefined(val))
-            continue;
-
+    while((hres = IDispatchEx_GetNextDispID(to_dispex(obj), fdexEnumDefault, dispid, &dispid)) == S_OK) {
         stepback = ctx->buf_len;
 
         if(prop_cnt && !append_char(ctx, ',')) {
@@ -609,23 +769,25 @@ static HRESULT stringify_object(stringify_ctx_t *ctx, jsdisp_t *obj)
             }
         }
 
-        hres = IDispatchEx_GetMemberName(&obj->IDispatchEx_iface, dispid, &prop_name);
+        hres = IDispatchEx_GetMemberName(to_dispex(obj), dispid, &prop_name);
         if(FAILED(hres))
-            break;
+            return hres;
 
         hres = json_quote(ctx, prop_name, SysStringLen(prop_name));
-        SysFreeString(prop_name);
-        if(FAILED(hres))
-            break;
-
-        if(!append_char(ctx, ':') || (*ctx->gap && !append_char(ctx, ' '))) {
-            hres = E_OUTOFMEMORY;
-            break;
+        if(FAILED(hres)) {
+            SysFreeString(prop_name);
+            return hres;
         }
 
-        hres = stringify(ctx, val);
+        if(!append_char(ctx, ':') || (*ctx->gap && !append_char(ctx, ' '))) {
+            SysFreeString(prop_name);
+            return E_OUTOFMEMORY;
+        }
+
+        hres = stringify(ctx, obj, prop_name);
+        SysFreeString(prop_name);
         if(FAILED(hres))
-            break;
+            return hres;
 
         if(hres == S_FALSE) {
             ctx->buf_len = stepback;
@@ -634,9 +796,6 @@ static HRESULT stringify_object(stringify_ctx_t *ctx, jsdisp_t *obj)
 
         prop_cnt++;
     }
-    jsval_release(val);
-    if(FAILED(hres))
-        return hres;
 
     if(prop_cnt && *ctx->gap) {
         if(!append_char(ctx, '\n'))
@@ -658,38 +817,62 @@ static HRESULT stringify_object(stringify_ctx_t *ctx, jsdisp_t *obj)
 }
 
 /* ECMA-262 5.1 Edition    15.12.3 (abstract operation Str) */
-static HRESULT stringify(stringify_ctx_t *ctx, jsval_t val)
+static HRESULT stringify(stringify_ctx_t *ctx, jsdisp_t *object, const WCHAR *name)
 {
-    jsval_t value;
+    jsval_t value, v;
     HRESULT hres;
 
-    if(is_object_instance(val) && get_object(val)) {
+    hres = jsdisp_propget_name(object, name, &value);
+    if(FAILED(hres))
+        return hres == DISP_E_UNKNOWNNAME ? S_FALSE : hres;
+
+    if(is_object_instance(value)) {
         jsdisp_t *obj;
         DISPID id;
 
-        obj = iface_to_jsdisp(get_object(val));
-        if(!obj)
+        obj = to_jsdisp(get_object(value));
+        if(!obj) {
+            jsval_release(value);
             return S_FALSE;
+        }
 
-        hres = jsdisp_get_id(obj, toJSONW, 0, &id);
-        jsdisp_release(obj);
+        hres = jsdisp_get_id(obj, L"toJSON", 0, &id);
         if(hres == S_OK)
             FIXME("Use toJSON.\n");
     }
 
-    /* FIXME: Support replacer replacer. */
+    if(ctx->replacer) {
+        jsstr_t *name_str;
+        jsval_t args[2];
+        if(!(name_str = jsstr_alloc(name))) {
+            jsval_release(value);
+            return E_OUTOFMEMORY;
+        }
+        args[0] = jsval_string(name_str);
+        args[1] = value;
+        hres = jsdisp_call_value(ctx->replacer, jsval_obj(object), DISPATCH_METHOD, ARRAY_SIZE(args), args, &v);
+        jsstr_release(name_str);
+        jsval_release(value);
+        if(FAILED(hres))
+            return hres;
+        value = v;
+    }
 
-    hres = maybe_to_primitive(ctx->ctx, val, &value);
+    v = value;
+    hres = maybe_to_primitive(ctx->ctx, v, &value);
+    jsval_release(v);
     if(FAILED(hres))
         return hres;
 
     switch(jsval_type(value)) {
     case JSV_NULL:
-        if(!append_string(ctx, nullW))
+        if(is_null_disp(value))
+            hres = S_FALSE;
+        else if(!append_string(ctx, L"null"))
             hres = E_OUTOFMEMORY;
         break;
     case JSV_BOOL:
-        if(!append_string(ctx, get_bool(value) ? trueW : falseW))
+        if(!append_string(ctx, get_bool(value) ? L"true" : L"false"))
             hres = E_OUTOFMEMORY;
         break;
     case JSV_STRING: {
@@ -703,7 +886,7 @@ static HRESULT stringify(stringify_ctx_t *ctx, jsval_t val)
     }
     case JSV_NUMBER: {
         double n = get_number(value);
-        if(is_finite(n)) {
+        if(isfinite(n)) {
             const WCHAR *ptr;
             jsstr_t *str;
 
@@ -717,7 +900,7 @@ static HRESULT stringify(stringify_ctx_t *ctx, jsval_t val)
             hres = ptr && !append_string_len(ctx, ptr, jsstr_length(str)) ? E_OUTOFMEMORY : S_OK;
             jsstr_release(str);
         }else {
-            if(!append_string(ctx, nullW))
+            if(!append_string(ctx, L"null"))
                 hres = E_OUTOFMEMORY;
         }
         break;
@@ -753,9 +936,10 @@ static HRESULT stringify(stringify_ctx_t *ctx, jsval_t val)
 }
 
 /* ECMA-262 5.1 Edition    15.12.3 */
-static HRESULT JSON_stringify(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+static HRESULT JSON_stringify(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    stringify_ctx_t stringify_ctx = {ctx, NULL,0,0, NULL,0,0, {0}};
+    stringify_ctx_t stringify_ctx = { ctx };
+    jsdisp_t *obj = NULL, *replacer;
     HRESULT hres;
 
     TRACE("\n");
@@ -766,9 +950,13 @@ static HRESULT JSON_stringify(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
         return S_OK;
     }
 
-    if(argc >= 2 && is_object_instance(argv[1])) {
-        FIXME("Replacer %s not yet supported\n", debugstr_jsval(argv[1]));
-        return E_NOTIMPL;
+    if(argc >= 2 && is_object_instance(argv[1]) && (replacer = to_jsdisp(get_object(argv[1])))) {
+        if(is_callable(replacer)) {
+            stringify_ctx.replacer = jsdisp_addref(replacer);
+        }else if(is_class(replacer, JSCLASS_ARRAY)) {
+            FIXME("Array replacer not yet supported\n");
+            return E_NOTIMPL;
+        }
     }
 
     if(argc >= 3) {
@@ -776,7 +964,7 @@ static HRESULT JSON_stringify(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
 
         hres = maybe_to_primitive(ctx, argv[2], &space_val);
         if(FAILED(hres))
-            return hres;
+            goto fail;
 
         if(is_number(space_val)) {
             double n = get_number(space_val);
@@ -800,7 +988,12 @@ static HRESULT JSON_stringify(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
         jsval_release(space_val);
     }
 
-    hres = stringify(&stringify_ctx, argv[0]);
+    if(FAILED(hres = create_object(ctx, NULL, &obj)))
+        goto fail;
+    if(FAILED(hres = jsdisp_propput_name(obj, L"", argv[0])))
+        goto fail;
+
+    hres = stringify(&stringify_ctx, obj, L"");
     if(SUCCEEDED(hres) && r) {
         assert(!stringify_ctx.stack_top);
 
@@ -815,23 +1008,25 @@ static HRESULT JSON_stringify(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
         }
     }
 
-    heap_free(stringify_ctx.buf);
-    heap_free(stringify_ctx.stack);
+fail:
+    if(obj)
+        jsdisp_release(obj);
+    if(stringify_ctx.replacer)
+        jsdisp_release(stringify_ctx.replacer);
+    free(stringify_ctx.buf);
+    free(stringify_ctx.stack);
     return hres;
 }
 
 static const builtin_prop_t JSON_props[] = {
-    {parseW,     JSON_parse,     PROPF_METHOD|2},
-    {stringifyW, JSON_stringify, PROPF_METHOD|3}
+    {L"parse",     JSON_parse,     PROPF_METHOD|2},
+    {L"stringify", JSON_stringify, PROPF_METHOD|3}
 };
 
 static const builtin_info_t JSON_info = {
-    JSCLASS_JSON,
-    {NULL, NULL, 0},
-    ARRAY_SIZE(JSON_props),
-    JSON_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_JSON,
+    .props_cnt = ARRAY_SIZE(JSON_props),
+    .props     = JSON_props,
 };
 
 HRESULT create_json(script_ctx_t *ctx, jsdisp_t **ret)
@@ -839,13 +1034,13 @@ HRESULT create_json(script_ctx_t *ctx, jsdisp_t **ret)
     jsdisp_t *json;
     HRESULT hres;
 
-    json = heap_alloc_zero(sizeof(*json));
+    json = calloc(1, sizeof(*json));
     if(!json)
         return E_OUTOFMEMORY;
 
     hres = init_dispex_from_constr(json, ctx, &JSON_info, ctx->object_constr);
     if(FAILED(hres)) {
-        heap_free(json);
+        free(json);
         return hres;
     }
 

dll/win32/jscript/jsregexp.c

@@ -34,38 +34,15 @@ typedef struct {
     jsval_t last_index_val;
 } RegExpInstance;
 
-static const WCHAR sourceW[] = {'s','o','u','r','c','e',0};
-static const WCHAR globalW[] = {'g','l','o','b','a','l',0};
-static const WCHAR ignoreCaseW[] = {'i','g','n','o','r','e','C','a','s','e',0};
-static const WCHAR multilineW[] = {'m','u','l','t','i','l','i','n','e',0};
-static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
-static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-static const WCHAR execW[] = {'e','x','e','c',0};
-static const WCHAR testW[] = {'t','e','s','t',0};
-
-static const WCHAR leftContextW[] =
-    {'l','e','f','t','C','o','n','t','e','x','t',0};
-static const WCHAR rightContextW[] =
-    {'r','i','g','h','t','C','o','n','t','e','x','t',0};
-
-static const WCHAR idx1W[] = {'$','1',0};
-static const WCHAR idx2W[] = {'$','2',0};
-static const WCHAR idx3W[] = {'$','3',0};
-static const WCHAR idx4W[] = {'$','4',0};
-static const WCHAR idx5W[] = {'$','5',0};
-static const WCHAR idx6W[] = {'$','6',0};
-static const WCHAR idx7W[] = {'$','7',0};
-static const WCHAR idx8W[] = {'$','8',0};
-static const WCHAR idx9W[] = {'$','9',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)
+static inline RegExpInstance *regexp_this(jsval_t vthis)
 {
-    return regexp_from_jsdisp(vdisp->u.jsdisp);
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_REGEXP)) ? regexp_from_jsdisp(jsdisp) : NULL;
 }
 
 static void set_last_index(RegExpInstance *This, DWORD last_index)
@@ -172,7 +149,7 @@ HRESULT regexp_match_next(script_ctx_t *ctx, jsdisp_t *dispex,
     heap_pool_clear(mark);
 
     if(hres != S_OK && (rem_flags & REM_ALLOC_RESULT)) {
-        heap_free(match);
+        free(match);
         *ret = NULL;
     }
 
@@ -216,11 +193,11 @@ static HRESULT regexp_match(script_ctx_t *ctx, jsdisp_t *dispex, jsstr_t *jsstr,
             if(ret) {
                 match_result_t *old_ret = ret;
 
-                ret = heap_realloc(old_ret, (ret_size <<= 1) * sizeof(match_result_t));
+                ret = realloc(old_ret, (ret_size <<= 1) * sizeof(match_result_t));
                 if(!ret)
-                    heap_free(old_ret);
+                    free(old_ret);
             }else {
-                ret = heap_alloc((ret_size=4) * sizeof(match_result_t));
+                ret = malloc((ret_size=4) * sizeof(match_result_t));
             }
             if(!ret) {
                 hres = E_OUTOFMEMORY;
@@ -231,6 +208,9 @@ static HRESULT regexp_match(script_ctx_t *ctx, jsdisp_t *dispex, jsstr_t *jsstr,
         ret[i].index = result->cp - str - result->match_len;
         ret[i++].length = result->match_len;
 
+        if (result->match_len == 0)
+	    result->cp++;
+
         if(!gflag && !(This->jsregexp->flags & REG_GLOB)) {
             hres = S_OK;
             break;
@@ -239,7 +219,7 @@ static HRESULT regexp_match(script_ctx_t *ctx, jsdisp_t *dispex, jsstr_t *jsstr,
 
     heap_pool_clear(mark);
     if(FAILED(hres)) {
-        heap_free(ret);
+        free(ret);
         return hres;
     }
 
@@ -286,10 +266,8 @@ static INT index_from_val(script_ctx_t *ctx, jsval_t v)
     HRESULT hres;
 
     hres = to_number(ctx, v, &n);
-    if(FAILED(hres)) {
-        clear_ei(ctx); /* FIXME: Move ignoring exceptions to to_primitive */
+    if(FAILED(hres))
         return 0;
-    }
 
     n = floor(n);
     return is_int32(n) ? n : 0;
@@ -320,7 +298,7 @@ static HRESULT RegExp_set_lastIndex(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t
     return S_OK;
 }
 
-static HRESULT RegExp_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT RegExp_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     RegExpInstance *regexp;
@@ -330,12 +308,11 @@ static HRESULT RegExp_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
 
     TRACE("\n");
 
-    if(!is_vclass(jsthis, JSCLASS_REGEXP)) {
-        FIXME("Not a RegExp\n");
-        return E_NOTIMPL;
+    if(!(regexp = regexp_this(vthis))) {
+        WARN("Not a RegExp\n");
+        return JS_E_REGEXP_EXPECTED;
     }
 
-    regexp = regexp_from_vdisp(jsthis);
 
     if(!r)
         return S_OK;
@@ -378,11 +355,6 @@ static HRESULT create_match_array(script_ctx_t *ctx, jsstr_t *input_str,
     DWORD i;
     HRESULT hres = S_OK;
 
-    static const WCHAR indexW[] = {'i','n','d','e','x',0};
-    static const WCHAR inputW[] = {'i','n','p','u','t',0};
-    static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
-    static const WCHAR zeroW[] = {'0',0};
-
     input = jsstr_flatten(input_str);
     if(!input)
         return E_OUTOFMEMORY;
@@ -392,31 +364,36 @@ static HRESULT create_match_array(script_ctx_t *ctx, jsstr_t *input_str,
         return hres;
 
     for(i=0; i < result->paren_count; i++) {
-        if(result->parens[i].index != -1)
-            str = jsstr_substr(input_str, result->parens[i].index, result->parens[i].length);
-        else
-            str = jsstr_empty();
-        if(!str) {
-            hres = E_OUTOFMEMORY;
-            break;
+        jsval_t val;
+
+        if(result->parens[i].index != -1) {
+            if(!(str = jsstr_substr(input_str, result->parens[i].index, result->parens[i].length))) {
+                hres = E_OUTOFMEMORY;
+                break;
+            }
+            val = jsval_string(str);
+        }else if(ctx->version < SCRIPTLANGUAGEVERSION_ES5) {
+            val = jsval_string(jsstr_empty());
+        }else {
+            val = jsval_undefined();
         }
 
-        hres = jsdisp_propput_idx(array, i+1, jsval_string(str));
-        jsstr_release(str);
+        hres = jsdisp_propput_idx(array, i+1, val);
+        jsval_release(val);
         if(FAILED(hres))
             break;
     }
 
     while(SUCCEEDED(hres)) {
-        hres = jsdisp_propput_name(array, indexW, jsval_number(result->cp-input-result->match_len));
+        hres = jsdisp_propput_name(array, L"index", jsval_number(result->cp-input-result->match_len));
         if(FAILED(hres))
             break;
 
-        hres = jsdisp_propput_name(array, lastIndexW, jsval_number(result->cp-input));
+        hres = jsdisp_propput_name(array, L"lastIndex", jsval_number(result->cp-input));
         if(FAILED(hres))
             break;
 
-        hres = jsdisp_propput_name(array, inputW, jsval_string(jsstr_addref(input_str)));
+        hres = jsdisp_propput_name(array, L"input", jsval_string(input_str));
         if(FAILED(hres))
             break;
 
@@ -425,7 +402,7 @@ static HRESULT create_match_array(script_ctx_t *ctx, jsstr_t *input_str,
             hres = E_OUTOFMEMORY;
             break;
         }
-        hres = jsdisp_propput_name(array, zeroW, jsval_string(str));
+        hres = jsdisp_propput_name(array, L"0", jsval_string(str));
         jsstr_release(str);
         break;
     }
@@ -439,7 +416,7 @@ static HRESULT create_match_array(script_ctx_t *ctx, jsstr_t *input_str,
     return S_OK;
 }
 
-static HRESULT run_exec(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t arg,
+static HRESULT run_exec(script_ctx_t *ctx, jsval_t vthis, jsval_t arg,
         jsstr_t **input, match_state_t **result, BOOL *ret)
 {
     RegExpInstance *regexp;
@@ -449,13 +426,11 @@ static HRESULT run_exec(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t arg,
     jsstr_t *jsstr;
     HRESULT hres;
 
-    if(!is_vclass(jsthis, JSCLASS_REGEXP)) {
-        FIXME("Not a RegExp\n");
-        return E_NOTIMPL;
+    if(!(regexp = regexp_this(vthis))) {
+        WARN("Not a RegExp\n");
+        return JS_E_REGEXP_EXPECTED;
     }
 
-    regexp = regexp_from_vdisp(jsthis);
-
     hres = to_flat_string(ctx, arg, &jsstr, &string);
     if(FAILED(hres))
         return hres;
@@ -494,7 +469,7 @@ static HRESULT run_exec(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t arg,
     return S_OK;
 }
 
-static HRESULT RegExp_exec(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT RegExp_exec(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     match_state_t *match;
@@ -507,7 +482,7 @@ static HRESULT RegExp_exec(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
 
     mark = heap_pool_mark(&ctx->tmp_heap);
 
-    hres = run_exec(ctx, jsthis, argc ? argv[0] : jsval_string(jsstr_empty()), &string, &match, &b);
+    hres = run_exec(ctx, vthis, argc ? argv[0] : jsval_string(jsstr_empty()), &string, &match, &b);
     if(FAILED(hres)) {
         heap_pool_clear(mark);
         return hres;
@@ -530,7 +505,7 @@ static HRESULT RegExp_exec(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
     return hres;
 }
 
-static HRESULT RegExp_test(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT RegExp_test(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     match_state_t *match;
@@ -542,7 +517,7 @@ static HRESULT RegExp_test(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
     TRACE("\n");
 
     mark = heap_pool_mark(&ctx->tmp_heap);
-    hres = run_exec(ctx, jsthis, argc ? argv[0] : jsval_string(undef_str = jsstr_undefined()), NULL, &match, &b);
+    hres = run_exec(ctx, vthis, argc ? argv[0] : jsval_string(undef_str = jsstr_undefined()), NULL, &match, &b);
     heap_pool_clear(mark);
     if(!argc)
         jsstr_release(undef_str);
@@ -554,14 +529,14 @@ static HRESULT RegExp_test(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
     return S_OK;
 }
 
-static HRESULT RegExp_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT RegExp_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
 
     switch(flags) {
     case INVOKE_FUNC:
-        return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
+        return JS_E_FUNCTION_EXPECTED;
     default:
         FIXME("unimplemented flags %x\n", flags);
         return E_NOTIMPL;
@@ -578,52 +553,56 @@ static void RegExp_destructor(jsdisp_t *dispex)
         regexp_destroy(This->jsregexp);
     jsval_release(This->last_index_val);
     jsstr_release(This->str);
-    heap_free(This);
+}
+
+static HRESULT RegExp_gc_traverse(struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
+{
+    return gc_process_linked_val(gc_ctx, op, dispex, &regexp_from_jsdisp(dispex)->last_index_val);
 }
 
 static const builtin_prop_t RegExp_props[] = {
-    {execW,                  RegExp_exec,                  PROPF_METHOD|1},
-    {globalW,                NULL,0,                       RegExp_get_global},
-    {ignoreCaseW,            NULL,0,                       RegExp_get_ignoreCase},
-    {lastIndexW,             NULL,0,                       RegExp_get_lastIndex,  RegExp_set_lastIndex},
-    {multilineW,             NULL,0,                       RegExp_get_multiline},
-    {sourceW,                NULL,0,                       RegExp_get_source},
-    {testW,                  RegExp_test,                  PROPF_METHOD|1},
-    {toStringW,              RegExp_toString,              PROPF_METHOD}
+    {L"exec",                RegExp_exec,                  PROPF_METHOD|1},
+    {L"global",              NULL,0,                       RegExp_get_global},
+    {L"ignoreCase",          NULL,0,                       RegExp_get_ignoreCase},
+    {L"lastIndex",           NULL,0,                       RegExp_get_lastIndex,  RegExp_set_lastIndex},
+    {L"multiline",           NULL,0,                       RegExp_get_multiline},
+    {L"source",              NULL,0,                       RegExp_get_source},
+    {L"test",                RegExp_test,                  PROPF_METHOD|1},
+    {L"toString",            RegExp_toString,              PROPF_METHOD}
 };
 
 static const builtin_info_t RegExp_info = {
-    JSCLASS_REGEXP,
-    {NULL, RegExp_value, 0},
-    ARRAY_SIZE(RegExp_props),
-    RegExp_props,
-    RegExp_destructor,
-    NULL
+    .class       = JSCLASS_REGEXP,
+    .call        = RegExp_value,
+    .props_cnt   = ARRAY_SIZE(RegExp_props),
+    .props       = RegExp_props,
+    .destructor  = RegExp_destructor,
+    .gc_traverse = RegExp_gc_traverse
 };
 
 static const builtin_prop_t RegExpInst_props[] = {
-    {globalW,                NULL,0,                       RegExp_get_global},
-    {ignoreCaseW,            NULL,0,                       RegExp_get_ignoreCase},
-    {lastIndexW,             NULL,0,                       RegExp_get_lastIndex,  RegExp_set_lastIndex},
-    {multilineW,             NULL,0,                       RegExp_get_multiline},
-    {sourceW,                NULL,0,                       RegExp_get_source}
+    {L"global",              NULL,0,                       RegExp_get_global},
+    {L"ignoreCase",          NULL,0,                       RegExp_get_ignoreCase},
+    {L"lastIndex",           NULL,0,                       RegExp_get_lastIndex,  RegExp_set_lastIndex},
+    {L"multiline",           NULL,0,                       RegExp_get_multiline},
+    {L"source",              NULL,0,                       RegExp_get_source}
 };
 
 static const builtin_info_t RegExpInst_info = {
-    JSCLASS_REGEXP,
-    {NULL, RegExp_value, 0},
-    ARRAY_SIZE(RegExpInst_props),
-    RegExpInst_props,
-    RegExp_destructor,
-    NULL
+    .class       = JSCLASS_REGEXP,
+    .call        = RegExp_value,
+    .props_cnt   = ARRAY_SIZE(RegExpInst_props),
+    .props       = RegExpInst_props,
+    .destructor  = RegExp_destructor,
+    .gc_traverse = RegExp_gc_traverse
 };
 
-static HRESULT alloc_regexp(script_ctx_t *ctx, jsdisp_t *object_prototype, RegExpInstance **ret)
+static HRESULT alloc_regexp(script_ctx_t *ctx, jsstr_t *str, jsdisp_t *object_prototype, RegExpInstance **ret)
 {
     RegExpInstance *regexp;
     HRESULT hres;
 
-    regexp = heap_alloc_zero(sizeof(RegExpInstance));
+    regexp = calloc(1, sizeof(RegExpInstance));
     if(!regexp)
         return E_OUTOFMEMORY;
 
@@ -633,10 +612,13 @@ static HRESULT alloc_regexp(script_ctx_t *ctx, jsdisp_t *object_prototype, RegEx
         hres = init_dispex_from_constr(&regexp->dispex, ctx, &RegExpInst_info, ctx->regexp_constr);
 
     if(FAILED(hres)) {
-        heap_free(regexp);
+        free(regexp);
         return hres;
     }
 
+    regexp->str = jsstr_addref(str);
+    regexp->last_index_val = jsval_number(0);
+
     *ret = regexp;
     return S_OK;
 }
@@ -651,20 +633,17 @@ HRESULT create_regexp(script_ctx_t *ctx, jsstr_t *src, DWORD flags, jsdisp_t **r
     if(!str)
         return E_OUTOFMEMORY;
 
-    TRACE("%s %x\n", debugstr_wn(str, jsstr_length(src)), flags);
+    TRACE("%s %lx\n", debugstr_wn(str, jsstr_length(src)), flags);
 
-    hres = alloc_regexp(ctx, NULL, &regexp);
+    hres = alloc_regexp(ctx, src, NULL, &regexp);
     if(FAILED(hres))
         return hres;
 
-    regexp->str = jsstr_addref(src);
-    regexp->last_index_val = jsval_number(0);
-
     regexp->jsregexp = regexp_new(ctx, &ctx->tmp_heap, str, jsstr_length(regexp->str), flags, FALSE);
     if(!regexp->jsregexp) {
         WARN("regexp_new failed\n");
         jsdisp_release(&regexp->dispex);
-        return E_FAIL;
+        return DISP_E_EXCEPTION;
     }
 
     *ret = &regexp->dispex;
@@ -673,66 +652,57 @@ HRESULT create_regexp(script_ctx_t *ctx, jsstr_t *src, DWORD flags, jsdisp_t **r
 
 HRESULT create_regexp_var(script_ctx_t *ctx, jsval_t src_arg, jsval_t *flags_arg, jsdisp_t **ret)
 {
-    unsigned flags, opt_len = 0;
+    DWORD flags = 0;
     const WCHAR *opt = NULL;
     jsstr_t *src;
-    HRESULT hres;
+    HRESULT hres = S_OK;
 
     if(is_object_instance(src_arg)) {
         jsdisp_t *obj;
 
-        obj = iface_to_jsdisp(get_object(src_arg));
+        obj = to_jsdisp(get_object(src_arg));
         if(obj) {
             if(is_class(obj, JSCLASS_REGEXP)) {
                 RegExpInstance *regexp = regexp_from_jsdisp(obj);
 
                 hres = create_regexp(ctx, regexp->str, regexp->jsregexp->flags, ret);
-                jsdisp_release(obj);
                 return hres;
             }
-
-            jsdisp_release(obj);
         }
     }
 
-    if(!is_string(src_arg)) {
-        FIXME("src_arg = %s\n", debugstr_jsval(src_arg));
-        return E_NOTIMPL;
-    }
-
-    src = get_string(src_arg);
-
-    if(flags_arg) {
-        jsstr_t *opt_str;
-
-        if(!is_string(*flags_arg)) {
-            FIXME("unimplemented for %s\n", debugstr_jsval(*flags_arg));
-            return E_NOTIMPL;
-        }
-
-        opt_str = get_string(*flags_arg);
-        opt = jsstr_flatten(opt_str);
-        if(!opt)
-            return E_OUTOFMEMORY;
-        opt_len = jsstr_length(opt_str);
-    }
-
-    hres = parse_regexp_flags(opt, opt_len, &flags);
+    if(is_undefined(src_arg))
+        src = jsstr_empty();
+    else
+        hres = to_string(ctx, src_arg, &src);
     if(FAILED(hres))
         return hres;
 
-    return create_regexp(ctx, src, flags, ret);
+    if(flags_arg && !is_undefined(*flags_arg)) {
+        jsstr_t *opt_str;
+
+        hres = to_string(ctx, *flags_arg, &opt_str);
+        if(SUCCEEDED(hres)) {
+            opt = jsstr_flatten(opt_str);
+            if(opt)
+                hres = parse_regexp_flags(opt, jsstr_length(opt_str), &flags);
+            else
+                hres = E_OUTOFMEMORY;
+            jsstr_release(opt_str);
+        }
+    }
+
+    if(SUCCEEDED(hres))
+        hres = create_regexp(ctx, src, flags, ret);
+    jsstr_release(src);
+    return hres;
 }
 
 HRESULT regexp_string_match(script_ctx_t *ctx, jsdisp_t *re, jsstr_t *jsstr, jsval_t *r)
 {
-    static const WCHAR indexW[] = {'i','n','d','e','x',0};
-    static const WCHAR inputW[] = {'i','n','p','u','t',0};
-    static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
-
     RegExpInstance *regexp = regexp_from_jsdisp(re);
     match_result_t *match_result;
-    unsigned match_cnt, i;
+    DWORD match_cnt, i;
     const WCHAR *str;
     jsdisp_t *array;
     HRESULT hres;
@@ -787,8 +757,10 @@ HRESULT regexp_string_match(script_ctx_t *ctx, jsdisp_t *re, jsstr_t *jsstr, jsv
     }
 
     hres = create_array(ctx, match_cnt, &array);
-    if(FAILED(hres))
+    if(FAILED(hres)) {
+        free(match_result);
         return hres;
+    }
 
     for(i=0; i < match_cnt; i++) {
         jsstr_t *tmp_str;
@@ -806,20 +778,20 @@ HRESULT regexp_string_match(script_ctx_t *ctx, jsdisp_t *re, jsstr_t *jsstr, jsv
     }
 
     while(SUCCEEDED(hres)) {
-        hres = jsdisp_propput_name(array, indexW, jsval_number(match_result[match_cnt-1].index));
+        hres = jsdisp_propput_name(array, L"index", jsval_number(match_result[match_cnt-1].index));
         if(FAILED(hres))
             break;
 
-        hres = jsdisp_propput_name(array, lastIndexW,
+        hres = jsdisp_propput_name(array, L"lastIndex",
                 jsval_number(match_result[match_cnt-1].index + match_result[match_cnt-1].length));
         if(FAILED(hres))
             break;
 
-        hres = jsdisp_propput_name(array, inputW, jsval_string(jsstr));
+        hres = jsdisp_propput_name(array, L"input", jsval_string(jsstr));
         break;
     }
 
-    heap_free(match_result);
+    free(match_result);
 
     if(SUCCEEDED(hres) && r)
         *r = jsval_obj(array);
@@ -923,7 +895,7 @@ static HRESULT RegExpConstr_get_rightContext(script_ctx_t *ctx, jsdisp_t *jsthis
     return S_OK;
 }
 
-static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT RegExpConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
@@ -932,21 +904,16 @@ static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     case DISPATCH_METHOD:
         if(argc) {
             if(is_object_instance(argv[0])) {
-                jsdisp_t *jsdisp = iface_to_jsdisp(get_object(argv[0]));
+                jsdisp_t *jsdisp = to_jsdisp(get_object(argv[0]));
                 if(jsdisp) {
                     if(is_class(jsdisp, JSCLASS_REGEXP)) {
-                        if(argc > 1 && !is_undefined(argv[1])) {
-                            jsdisp_release(jsdisp);
-                            return throw_regexp_error(ctx, JS_E_REGEXP_SYNTAX, NULL);
-                        }
+                        if(argc > 1 && !is_undefined(argv[1]))
+                            return JS_E_REGEXP_SYNTAX;
 
                         if(r)
-                            *r = jsval_obj(jsdisp);
-                        else
-                            jsdisp_release(jsdisp);
+                            *r = jsval_obj(jsdisp_addref(jsdisp));
                         return S_OK;
                     }
-                    jsdisp_release(jsdisp);
                 }
             }
         }
@@ -955,12 +922,7 @@ static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
         jsdisp_t *ret;
         HRESULT hres;
 
-        if(!argc) {
-            FIXME("no args\n");
-            return E_NOTIMPL;
-        }
-
-        hres = create_regexp_var(ctx, argv[0], argc > 1 ? argv+1 : NULL, &ret);
+        hres = create_regexp_var(ctx, argc ? argv[0] : jsval_undefined(), argc > 1 ? argv+1 : NULL, &ret);
         if(FAILED(hres))
             return hres;
 
@@ -979,40 +941,38 @@ static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
 }
 
 static const builtin_prop_t RegExpConstr_props[] = {
-    {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}
+    {L"$1",           NULL,0,  RegExpConstr_get_idx1,         builtin_set_const},
+    {L"$2",           NULL,0,  RegExpConstr_get_idx2,         builtin_set_const},
+    {L"$3",           NULL,0,  RegExpConstr_get_idx3,         builtin_set_const},
+    {L"$4",           NULL,0,  RegExpConstr_get_idx4,         builtin_set_const},
+    {L"$5",           NULL,0,  RegExpConstr_get_idx5,         builtin_set_const},
+    {L"$6",           NULL,0,  RegExpConstr_get_idx6,         builtin_set_const},
+    {L"$7",           NULL,0,  RegExpConstr_get_idx7,         builtin_set_const},
+    {L"$8",           NULL,0,  RegExpConstr_get_idx8,         builtin_set_const},
+    {L"$9",           NULL,0,  RegExpConstr_get_idx9,         builtin_set_const},
+    {L"leftContext",  NULL,0,  RegExpConstr_get_leftContext,  builtin_set_const},
+    {L"rightContext", NULL,0,  RegExpConstr_get_rightContext, builtin_set_const}
 };
 
 static const builtin_info_t RegExpConstr_info = {
-    JSCLASS_FUNCTION,
-    DEFAULT_FUNCTION_VALUE,
-    ARRAY_SIZE(RegExpConstr_props),
-    RegExpConstr_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_FUNCTION,
+    .call      = Function_value,
+    .props_cnt = ARRAY_SIZE(RegExpConstr_props),
+    .props     = RegExpConstr_props,
 };
 
 HRESULT create_regexp_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
 {
+    jsstr_t *str = jsstr_empty();
     RegExpInstance *regexp;
     HRESULT hres;
 
-    static const WCHAR RegExpW[] = {'R','e','g','E','x','p',0};
-
-    hres = alloc_regexp(ctx, object_prototype, &regexp);
+    hres = alloc_regexp(ctx, str, object_prototype, &regexp);
+    jsstr_release(str);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_constructor(ctx, RegExpConstr_value, RegExpW, &RegExpConstr_info,
+    hres = create_builtin_constructor(ctx, RegExpConstr_value, L"RegExp", &RegExpConstr_info,
             PROPF_CONSTR|2, &regexp->dispex, ret);
 
     jsdisp_release(&regexp->dispex);

dll/win32/jscript/jsstr.c

@@ -45,7 +45,7 @@ void jsstr_free(jsstr_t *str)
 {
     switch(jsstr_tag(str)) {
     case JSSTR_HEAP:
-        heap_free(jsstr_as_heap(str)->buf);
+        free(jsstr_as_heap(str)->buf);
         break;
     case JSSTR_ROPE: {
         jsstr_rope_t *rope = jsstr_as_rope(str);
@@ -57,7 +57,7 @@ void jsstr_free(jsstr_t *str)
         break;
     }
 
-    heap_free(str);
+    free(str);
 }
 
 static inline void jsstr_init(jsstr_t *str, unsigned len, jsstr_tag_t tag)
@@ -73,7 +73,7 @@ jsstr_t *jsstr_alloc_buf(unsigned len, WCHAR **buf)
     if(len > JSSTR_MAX_LENGTH)
         return NULL;
 
-    ret = heap_alloc(FIELD_OFFSET(jsstr_inline_t, buf[len+1]));
+    ret = malloc(FIELD_OFFSET(jsstr_inline_t, buf[len+1]));
     if(!ret)
         return NULL;
 
@@ -120,8 +120,11 @@ void jsstr_extract(jsstr_t *str, unsigned off, unsigned len, WCHAR *buf)
         memcpy(buf, jsstr_as_heap(str)->buf+off, len*sizeof(WCHAR));
         return;
     case JSSTR_ROPE:
+#ifdef __REACTOS__
         jsstr_rope_extract(jsstr_as_rope(str), off, len, buf);
-        return;
+#else
+        return jsstr_rope_extract(jsstr_as_rope(str), off, len, buf);
+#endif
     }
 }
 
@@ -235,7 +238,7 @@ jsstr_t *jsstr_concat(jsstr_t *str1, jsstr_t *str2)
             if(len1+len2 > JSSTR_MAX_LENGTH)
                 return NULL;
 
-            rope = heap_alloc(sizeof(*rope));
+            rope = malloc(sizeof(*rope));
             if(!rope)
                 return NULL;
 
@@ -263,7 +266,7 @@ const WCHAR *jsstr_rope_flatten(jsstr_rope_t *str)
 {
     WCHAR *buf;
 
-    buf = heap_alloc((jsstr_length(&str->str)+1) * sizeof(WCHAR));
+    buf = malloc((jsstr_length(&str->str)+1) * sizeof(WCHAR));
     if(!buf)
         return NULL;
 
@@ -300,22 +303,29 @@ jsstr_t *jsstr_null_bstr(void)
     return jsstr_addref(null_bstr_str);
 }
 
-BOOL is_null_bstr(jsstr_t *str)
+HRESULT jsstr_to_bstr(jsstr_t *str, BSTR *r)
 {
-    return str == null_bstr_str;
+    if(str == null_bstr_str) {
+        *r = NULL;
+        return S_OK;
+    }
+
+    if(!(*r = SysAllocStringLen(NULL, jsstr_length(str))))
+        return E_OUTOFMEMORY;
+
+    jsstr_flush(str, *r);
+    return S_OK;
 }
 
 BOOL init_strings(void)
 {
-    static const WCHAR NaNW[] = { 'N','a','N',0 };
-    static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
     WCHAR *ptr;
 
     if(!(empty_str = jsstr_alloc_buf(0, &ptr)))
         return FALSE;
-    if(!(nan_str = jsstr_alloc(NaNW)))
+    if(!(nan_str = jsstr_alloc(L"NaN")))
         return FALSE;
-    if(!(undefined_str = jsstr_alloc(undefinedW)))
+    if(!(undefined_str = jsstr_alloc(L"undefined")))
         return FALSE;
     if(!(null_bstr_str = jsstr_alloc_buf(0, &ptr)))
         return FALSE;

dll/win32/jscript/jsstr.h

@@ -33,9 +33,6 @@
  *
  * In the future more layouts and transformations may be added.
  */
-
-#pragma once
-
 struct _jsstr_t {
     unsigned length_flags;
     unsigned ref;
@@ -82,7 +79,7 @@ static inline BOOL jsstr_is_rope(jsstr_t *str)
 
 typedef struct {
     jsstr_t str;
-    WCHAR buf[1];
+    WCHAR buf[];
 } jsstr_inline_t;
 
 typedef struct {
@@ -97,15 +94,15 @@ typedef struct {
     unsigned depth;
 } jsstr_rope_t;
 
-jsstr_t *jsstr_alloc_len(const WCHAR*,unsigned) DECLSPEC_HIDDEN;
-jsstr_t *jsstr_alloc_buf(unsigned,WCHAR**) DECLSPEC_HIDDEN;
+jsstr_t *jsstr_alloc_len(const WCHAR*,unsigned);
+jsstr_t *jsstr_alloc_buf(unsigned,WCHAR**);
 
 static inline jsstr_t *jsstr_alloc(const WCHAR *str)
 {
     return jsstr_alloc_len(str, lstrlenW(str));
 }
 
-void jsstr_free(jsstr_t*) DECLSPEC_HIDDEN;
+void jsstr_free(jsstr_t*);
 
 static inline void jsstr_release(jsstr_t *str)
 {
@@ -134,7 +131,7 @@ static inline jsstr_rope_t *jsstr_as_rope(jsstr_t *str)
     return CONTAINING_RECORD(str, jsstr_rope_t, str);
 }
 
-const WCHAR *jsstr_rope_flatten(jsstr_rope_t*) DECLSPEC_HIDDEN;
+const WCHAR *jsstr_rope_flatten(jsstr_rope_t*);
 
 static inline const WCHAR *jsstr_flatten(jsstr_t *str)
 {
@@ -143,7 +140,7 @@ static inline const WCHAR *jsstr_flatten(jsstr_t *str)
         : jsstr_rope_flatten(jsstr_as_rope(str));
 }
 
-void jsstr_extract(jsstr_t*,unsigned,unsigned,WCHAR*) DECLSPEC_HIDDEN;
+void jsstr_extract(jsstr_t*,unsigned,unsigned,WCHAR*);
 
 static inline unsigned jsstr_flush(jsstr_t *str, WCHAR *buf)
 {
@@ -171,23 +168,23 @@ static inline jsstr_t *jsstr_substr(jsstr_t *str, unsigned off, unsigned len)
     return ret;
 }
 
-int jsstr_cmp(jsstr_t*,jsstr_t*) DECLSPEC_HIDDEN;
+int jsstr_cmp(jsstr_t*,jsstr_t*);
 
 static inline BOOL jsstr_eq(jsstr_t *left, jsstr_t *right)
 {
     return jsstr_length(left) == jsstr_length(right) && !jsstr_cmp(left, right);
 }
 
-jsstr_t *jsstr_concat(jsstr_t*,jsstr_t*) DECLSPEC_HIDDEN;
+jsstr_t *jsstr_concat(jsstr_t*,jsstr_t*);
 
-jsstr_t *jsstr_nan(void) DECLSPEC_HIDDEN;
-jsstr_t *jsstr_empty(void) DECLSPEC_HIDDEN;
-jsstr_t *jsstr_undefined(void) DECLSPEC_HIDDEN;
+jsstr_t *jsstr_nan(void);
+jsstr_t *jsstr_empty(void);
+jsstr_t *jsstr_undefined(void);
 
-jsstr_t *jsstr_null_bstr(void) DECLSPEC_HIDDEN;
-BOOL is_null_bstr(jsstr_t*) DECLSPEC_HIDDEN;
+jsstr_t *jsstr_null_bstr(void);
+HRESULT jsstr_to_bstr(jsstr_t *str, BSTR *r);
 
-BOOL init_strings(void) DECLSPEC_HIDDEN;
-void free_strings(void) DECLSPEC_HIDDEN;
+BOOL init_strings(void);
+void free_strings(void);
 
-const char *debugstr_jsstr(jsstr_t*) DECLSPEC_HIDDEN;
+const char *debugstr_jsstr(jsstr_t*);

dll/win32/jscript/jsutils.c

@@ -55,11 +55,6 @@ const char *debugstr_jsval(const jsval_t v)
     return NULL;
 }
 
-BOOL is_finite(double n)
-{
-    return !isnan(n) && !isinf(n);
-}
-
 #define MIN_BLOCK_SIZE  128
 #define ARENA_FREE_FILLER  0xaa
 
@@ -81,12 +76,12 @@ void *heap_pool_alloc(heap_pool_t *heap, DWORD size)
 
     if(!heap->block_cnt) {
         if(!heap->blocks) {
-            heap->blocks = heap_alloc(sizeof(void*));
+            heap->blocks = malloc(sizeof(void*));
             if(!heap->blocks)
                 return NULL;
         }
 
-        tmp = heap_alloc(block_size(0));
+        tmp = malloc(block_size(0));
         if(!tmp)
             return NULL;
 
@@ -102,12 +97,12 @@ void *heap_pool_alloc(heap_pool_t *heap, DWORD size)
 
     if(size <= block_size(heap->last_block+1)) {
         if(heap->last_block+1 == heap->block_cnt) {
-            tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
+            tmp = realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
             if(!tmp)
                 return NULL;
 
             heap->blocks = tmp;
-            heap->blocks[heap->block_cnt] = heap_alloc(block_size(heap->block_cnt));
+            heap->blocks[heap->block_cnt] = malloc(block_size(heap->block_cnt));
             if(!heap->blocks[heap->block_cnt])
                 return NULL;
 
@@ -119,7 +114,7 @@ void *heap_pool_alloc(heap_pool_t *heap, DWORD size)
         return heap->blocks[heap->last_block];
     }
 
-    list = heap_alloc(size + sizeof(struct list));
+    list = malloc(size + sizeof(struct list));
     if(!list)
         return NULL;
 
@@ -152,7 +147,7 @@ void heap_pool_clear(heap_pool_t *heap)
 
     while((tmp = list_head(&heap->custom_blocks))) {
         list_remove(tmp);
-        heap_free(tmp);
+        free(tmp);
     }
 
     if(WARN_ON(heap)) {
@@ -173,8 +168,8 @@ void heap_pool_free(heap_pool_t *heap)
     heap_pool_clear(heap);
 
     for(i=0; i < heap->block_cnt; i++)
-        heap_free(heap->blocks[i]);
-    heap_free(heap->blocks);
+        free(heap->blocks[i]);
+    free(heap->blocks);
 
     heap_pool_init(heap);
 }
@@ -192,15 +187,14 @@ void jsval_release(jsval_t val)
 {
     switch(jsval_type(val)) {
     case JSV_OBJECT:
-        if(get_object(val))
-            IDispatch_Release(get_object(val));
+        IDispatch_Release(get_object(val));
         break;
     case JSV_STRING:
         jsstr_release(get_string(val));
         break;
     case JSV_VARIANT:
         VariantClear(get_variant(val));
-        heap_free(get_variant(val));
+        free(get_variant(val));
         break;
     default:
         break;
@@ -213,7 +207,7 @@ static HRESULT jsval_variant(jsval_t *val, VARIANT *var)
     HRESULT hres;
 
     __JSVAL_TYPE(*val) = JSV_VARIANT;
-    __JSVAL_VAR(*val) = v = heap_alloc(sizeof(VARIANT));
+    __JSVAL_VAR(*val) = v = malloc(sizeof(VARIANT));
     if(!v) {
         *val = jsval_undefined();
         return E_OUTOFMEMORY;
@@ -223,7 +217,7 @@ static HRESULT jsval_variant(jsval_t *val, VARIANT *var)
     hres = VariantCopy(v, var);
     if(FAILED(hres)) {
         *val = jsval_undefined();
-        heap_free(v);
+        free(v);
     }
     return hres;
 }
@@ -238,8 +232,7 @@ HRESULT jsval_copy(jsval_t v, jsval_t *r)
         *r = v;
         return S_OK;
     case JSV_OBJECT:
-        if(get_object(v))
-            IDispatch_AddRef(get_object(v));
+        IDispatch_AddRef(get_object(v));
         *r = v;
         return S_OK;
     case JSV_STRING: {
@@ -255,7 +248,7 @@ HRESULT jsval_copy(jsval_t v, jsval_t *r)
     return E_FAIL;
 }
 
-HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
+HRESULT variant_to_jsval(script_ctx_t *ctx, VARIANT *var, jsval_t *r)
 {
     if(V_VT(var) == (VT_VARIANT|VT_BYREF))
         var = V_VARIANTREF(var);
@@ -290,12 +283,33 @@ HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
         *r = jsval_string(str);
         return S_OK;
     }
-    case VT_DISPATCH: {
-        if(V_DISPATCH(var))
-            IDispatch_AddRef(V_DISPATCH(var));
+    case VT_DISPATCH:
+        if(!V_DISPATCH(var)) {
+            *r = ctx->html_mode ? jsval_null() : jsval_null_disp();
+            return S_OK;
+        }
+        if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5) {
+            IWineJSDispatchHost *disp_host;
+            HRESULT hres;
+            hres = IDispatch_QueryInterface(V_DISPATCH(var), &IID_IWineJSDispatchHost, (void **)&disp_host);
+            if(SUCCEEDED(hres)) {
+                IWineJSDispatch *jsdisp_iface;
+                hres = IWineJSDispatchHost_GetJSDispatch(disp_host, &jsdisp_iface);
+                IWineJSDispatchHost_Release(disp_host);
+                if(SUCCEEDED(hres)) {
+                    jsdisp_t *jsdisp = to_jsdisp((IDispatch *)jsdisp_iface);
+                    if(jsdisp->ctx == ctx) {
+                        *r = jsval_obj(jsdisp);
+                        return S_OK;
+                    }else {
+                        jsdisp_release(jsdisp);
+                    }
+                }
+            }
+        }
+        IDispatch_AddRef(V_DISPATCH(var));
         *r = jsval_disp(V_DISPATCH(var));
         return S_OK;
-    }
     case VT_I1:
         *r = jsval_number(V_I1(var));
         return S_OK;
@@ -324,6 +338,12 @@ HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
     case VT_R4:
         *r = jsval_number(V_R4(var));
         return S_OK;
+    case VT_CY:
+        /* FIXME: Native converts VT_CY to a special kind number type, which is
+         * never converted to VT_I4 when it's converted back to VARIANT. */
+        *r = jsval_number((double)V_CY(var).int64 / 10000.0);
+        WARN("VT_CY: %lf\n", get_number(*r));
+        return S_OK;
     case VT_UNKNOWN:
         if(V_UNKNOWN(var)) {
             IDispatch *disp;
@@ -335,7 +355,7 @@ HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
                 return S_OK;
             }
         }else {
-            *r = jsval_disp(NULL);
+            *r = ctx->html_mode ? jsval_null() : jsval_null_disp();
             return S_OK;
         }
         /* fall through */
@@ -351,29 +371,28 @@ HRESULT jsval_to_variant(jsval_t val, VARIANT *retv)
         V_VT(retv) = VT_EMPTY;
         return S_OK;
     case JSV_NULL:
+        if(get_bool(val)) {
+            V_VT(retv) = VT_DISPATCH;
+            V_DISPATCH(retv) = NULL;
+            return S_OK;
+        }
         V_VT(retv) = VT_NULL;
         return S_OK;
-    case JSV_OBJECT:
+    case JSV_OBJECT: {
+        IWineJSDispatchHost *host_disp = get_host_dispatch(get_object(val));
         V_VT(retv) = VT_DISPATCH;
-        if(get_object(val))
-            IDispatch_AddRef(get_object(val));
-        V_DISPATCH(retv) = get_object(val);
-        return S_OK;
-    case JSV_STRING: {
-        jsstr_t *str = get_string(val);
-
-        V_VT(retv) = VT_BSTR;
-        if(is_null_bstr(str)) {
-            V_BSTR(retv) = NULL;
-        }else {
-            V_BSTR(retv) = SysAllocStringLen(NULL, jsstr_length(str));
-            if(V_BSTR(retv))
-                jsstr_flush(str, V_BSTR(retv));
-            else
-                return E_OUTOFMEMORY;
+        if(host_disp) {
+            V_DISPATCH(retv) = (IDispatch *)host_disp;
+            return S_OK;
         }
+
+        V_DISPATCH(retv) = get_object(val);
+        IDispatch_AddRef(get_object(val));
         return S_OK;
     }
+    case JSV_STRING:
+        V_VT(retv) = VT_BSTR;
+        return jsstr_to_bstr(get_string(val), &V_BSTR(retv));
     case JSV_NUMBER: {
         double n = get_number(val);
 
@@ -409,14 +428,6 @@ HRESULT to_primitive(script_ctx_t *ctx, jsval_t val, jsval_t *ret, hint_t hint)
         DISPID id;
         HRESULT hres;
 
-        static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-        static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
-
-        if(!get_object(val)) {
-            *ret = jsval_null();
-            return S_OK;
-        }
-
         jsdisp = iface_to_jsdisp(get_object(val));
         if(!jsdisp)
             return disp_propget(ctx, get_object(val), DISPID_VALUE, ret);
@@ -426,7 +437,7 @@ HRESULT to_primitive(script_ctx_t *ctx, jsval_t val, jsval_t *ret, hint_t hint)
 
         /* Native implementation doesn't throw TypeErrors, returns strange values */
 
-        hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? toStringW : valueOfW, 0, &id);
+        hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? L"toString" : L"valueOf", 0, &id);
         if(SUCCEEDED(hres)) {
             hres = jsdisp_call(jsdisp, id, DISPATCH_METHOD, 0, NULL, &prim);
             if(FAILED(hres)) {
@@ -440,9 +451,12 @@ HRESULT to_primitive(script_ctx_t *ctx, jsval_t val, jsval_t *ret, hint_t hint)
             }else {
                 IDispatch_Release(get_object(prim));
             }
+        }else if(hres != DISP_E_UNKNOWNNAME) {
+            jsdisp_release(jsdisp);
+            return hres;
         }
 
-        hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? valueOfW : toStringW, 0, &id);
+        hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? L"valueOf" : L"toString", 0, &id);
         if(SUCCEEDED(hres)) {
             hres = jsdisp_call(jsdisp, id, DISPATCH_METHOD, 0, NULL, &prim);
             if(FAILED(hres)) {
@@ -456,12 +470,15 @@ HRESULT to_primitive(script_ctx_t *ctx, jsval_t val, jsval_t *ret, hint_t hint)
             }else {
                 IDispatch_Release(get_object(prim));
             }
+        }else if(hres != DISP_E_UNKNOWNNAME) {
+            jsdisp_release(jsdisp);
+            return hres;
         }
 
         jsdisp_release(jsdisp);
 
         WARN("failed\n");
-        return throw_type_error(ctx, JS_E_TO_PRIMITIVE, NULL);
+        return JS_E_TO_PRIMITIVE;
     }
 
     return jsval_copy(val, ret);
@@ -477,7 +494,7 @@ HRESULT to_boolean(jsval_t val, BOOL *ret)
         *ret = FALSE;
         return S_OK;
     case JSV_OBJECT:
-        *ret = get_object(val) != NULL;
+        *ret = TRUE;
         return S_OK;
     case JSV_STRING:
         *ret = jsstr_length(get_string(val)) != 0;
@@ -497,7 +514,11 @@ HRESULT to_boolean(jsval_t val, BOOL *ret)
     return E_FAIL;
 }
 
+#if defined(__REACTOS__) && defined(__clang__)
+static inline __attribute__((always_inline)) int hex_to_int(WCHAR c)
+#else
 static int hex_to_int(WCHAR c)
+#endif
 {
     if('0' <= c && c <= '9')
         return c-'0';
@@ -518,7 +539,7 @@ static HRESULT str_to_number(jsstr_t *str, double *ret)
     BOOL neg = FALSE;
     DOUBLE d = 0.0;
 
-    static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'};
+    static const WCHAR infinityW[] = L"Infinity";
 
     ptr = jsstr_flatten(str);
     if(!ptr)
@@ -534,8 +555,8 @@ static HRESULT str_to_number(jsstr_t *str, double *ret)
         ptr++;
     }
 
-    if(!wcsncmp(ptr, infinityW, ARRAY_SIZE(infinityW))) {
-        ptr += ARRAY_SIZE(infinityW);
+    if(!wcsncmp(ptr, infinityW, ARRAY_SIZE(infinityW)-1)) {
+        ptr += ARRAY_SIZE(infinityW) - 1;
         while(*ptr && iswspace(*ptr))
             ptr++;
 
@@ -559,7 +580,7 @@ static HRESULT str_to_number(jsstr_t *str, double *ret)
         return S_OK;
     }
 
-    while(iswdigit(*ptr))
+    while(is_digit(*ptr))
         d = d*10 + (*ptr++ - '0');
 
     if(*ptr == 'e' || *ptr == 'E') {
@@ -574,7 +595,7 @@ static HRESULT str_to_number(jsstr_t *str, double *ret)
             ptr++;
         }
 
-        while(iswdigit(*ptr))
+        while(is_digit(*ptr))
             l = l*10 + (*ptr++ - '0');
         if(eneg)
             l = -l;
@@ -584,7 +605,7 @@ static HRESULT str_to_number(jsstr_t *str, double *ret)
         DOUBLE dec = 0.1;
 
         ptr++;
-        while(iswdigit(*ptr)) {
+        while(is_digit(*ptr)) {
             d += dec * (*ptr++ - '0');
             dec *= 0.1;
         }
@@ -635,9 +656,16 @@ HRESULT to_number(script_ctx_t *ctx, jsval_t val, double *ret)
     case JSV_BOOL:
         *ret = get_bool(val) ? 1 : 0;
         return S_OK;
-    case JSV_VARIANT:
-        FIXME("unimplemented for variant %s\n", debugstr_variant(get_variant(val)));
-        return E_NOTIMPL;
+    case JSV_VARIANT: {
+        const VARIANT *v = get_variant(val);
+        switch(V_VT(v)) {
+        case VT_DATE:
+            return variant_date_to_number(V_DATE(v), ret);
+        default:
+            FIXME("unimplemented for variant %s\n", debugstr_variant(v));
+            return E_NOTIMPL;
+        }
+    }
     };
 
     assert(0);
@@ -661,79 +689,95 @@ HRESULT to_integer(script_ctx_t *ctx, jsval_t v, double *ret)
     return S_OK;
 }
 
+static INT32 double_to_int32(double number)
+{
+    INT32 exp, result;
+    union {
+        double d;
+        INT64 n;
+    } bits;
+
+    bits.d = number;
+    exp = ((INT32)(bits.n >> 52) & 0x7ff) - 0x3ff;
+
+    /* If exponent < 0 there will be no bits to the left of the decimal point
+     * after rounding; if the exponent is > 83 then no bits of precision can be
+     * left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
+     * of fractional precision).
+     * Note this case handles 0, -0, and all infinite, NaN & denormal values. */
+    if(exp < 0 || exp > 83)
+        return 0;
+
+    /* Select the appropriate 32-bits from the floating point mantissa.  If the
+     * exponent is 52 then the bits we need to select are already aligned to the
+     * lowest bits of the 64-bit integer representation of the number, no need
+     * to shift.  If the exponent is greater than 52 we need to shift the value
+     * left by (exp - 52), if the value is less than 52 we need to shift right
+     * accordingly. */
+    result = (exp > 52) ? bits.n << (exp - 52) : bits.n >> (52 - exp);
+
+    /* IEEE-754 double precision values are stored omitting an implicit 1 before
+     * the decimal point; we need to reinsert this now.  We may also the shifted
+     * invalid bits into the result that are not a part of the mantissa (the sign
+     * and exponent bits from the floatingpoint representation); mask these out. */
+    if(exp < 32) {
+        INT32 missing_one = 1 << exp;
+        result &= missing_one - 1;
+        result += missing_one;
+    }
+
+    /* If the input value was negative (we could test either 'number' or 'bits',
+     * but testing 'bits' is likely faster) invert the result appropriately. */
+    return bits.n < 0 ? -result : result;
+}
+
 /* ECMA-262 3rd Edition    9.5 */
 HRESULT to_int32(script_ctx_t *ctx, jsval_t v, INT *ret)
 {
     double n;
     HRESULT hres;
 
-    const double p32 = (double)0xffffffff + 1;
-
     hres = to_number(ctx, v, &n);
     if(FAILED(hres))
         return hres;
 
-    if(is_finite(n))
-        n = n > 0 ? fmod(n, p32) : -fmod(-n, p32);
-    else
-        n = 0;
-
-    *ret = (UINT32)n;
+    *ret = double_to_int32(n);
     return S_OK;
 }
 
+HRESULT to_long(script_ctx_t *ctx, jsval_t v, LONG *ret)
+{
+    return to_int32(ctx, v, (INT*)ret);
+}
+
 /* ECMA-262 3rd Edition    9.6 */
 HRESULT to_uint32(script_ctx_t *ctx, jsval_t val, UINT32 *ret)
 {
-    INT32 n;
+    double n;
     HRESULT hres;
 
-    hres = to_int32(ctx, val, &n);
-    if(SUCCEEDED(hres))
-        *ret = n;
-    return hres;
-}
+    hres = to_number(ctx, val, &n);
+    if(FAILED(hres))
+        return hres;
 
-static jsstr_t *int_to_string(int i)
-{
-    WCHAR buf[12], *p;
-    BOOL neg = FALSE;
-
-    if(!i) {
-        static const WCHAR zeroW[] = {'0',0};
-        return jsstr_alloc(zeroW);
-    }
-
-    if(i < 0) {
-        neg = TRUE;
-        i = -i;
-    }
-
-    p = buf + ARRAY_SIZE(buf)-1;
-    *p-- = 0;
-    while(i) {
-        *p-- = i%10 + '0';
-        i /= 10;
-    }
-
-    if(neg)
-        *p = '-';
-    else
-        p++;
-
-    return jsstr_alloc(p);
+    *ret = double_to_int32(n);
+    return S_OK;
 }
 
 HRESULT double_to_string(double n, jsstr_t **str)
 {
-    static const WCHAR InfinityW[] = {'-','I','n','f','i','n','i','t','y',0};
-
     if(isnan(n)) {
         *str = jsstr_nan();
     }else if(isinf(n)) {
-        *str = jsstr_alloc(n<0 ? InfinityW : InfinityW+1);
+        *str = jsstr_alloc(n<0 ? L"-Infinity" : L"Infinity");
     }else if(is_int32(n)) {
-        *str = int_to_string(n);
+        WCHAR buf[12];
+#ifdef __REACTOS__ /* FIXME: Inspect */
+        swprintf(buf, ARRAY_SIZE(buf), L"%d", (int)n);
+#else
+        _ltow_s(n, buf, ARRAY_SIZE(buf), 10);
+#endif
+        *str = jsstr_alloc(buf);
     }else {
         VARIANT strv, v;
         HRESULT hres;
@@ -756,16 +800,12 @@ HRESULT double_to_string(double n, jsstr_t **str)
 /* ECMA-262 3rd Edition    9.8 */
 HRESULT to_string(script_ctx_t *ctx, jsval_t val, jsstr_t **str)
 {
-    static const WCHAR nullW[] = {'n','u','l','l',0};
-    static const WCHAR trueW[] = {'t','r','u','e',0};
-    static const WCHAR falseW[] = {'f','a','l','s','e',0};
-
     switch(jsval_type(val)) {
     case JSV_UNDEFINED:
         *str = jsstr_undefined();
         return S_OK;
     case JSV_NULL:
-        *str = jsstr_alloc(nullW);
+        *str = jsstr_alloc(L"null");
         break;
     case JSV_NUMBER:
         return double_to_string(get_number(val), str);
@@ -785,11 +825,19 @@ HRESULT to_string(script_ctx_t *ctx, jsval_t val, jsstr_t **str)
         return hres;
     }
     case JSV_BOOL:
-        *str = jsstr_alloc(get_bool(val) ? trueW : falseW);
+        *str = jsstr_alloc(get_bool(val) ? L"true" : L"false");
         break;
-    default:
-        FIXME("unsupported %s\n", debugstr_jsval(val));
-        return E_NOTIMPL;
+    default: {
+        const VARIANT *v = get_variant(val);
+        switch(V_VT(v))
+        {
+        case VT_DATE:
+            return variant_date_to_string(ctx, V_DATE(v), str);
+        default:
+            FIXME("unsupported %s\n", debugstr_variant(v));
+            return E_NOTIMPL;
+        }
+    }
     }
 
     return *str ? S_OK : E_OUTOFMEMORY;
@@ -834,18 +882,8 @@ HRESULT to_object(script_ctx_t *ctx, jsval_t val, IDispatch **disp)
         *disp = to_disp(dispex);
         break;
     case JSV_OBJECT:
-        if(get_object(val)) {
-            *disp = get_object(val);
-            IDispatch_AddRef(*disp);
-        }else {
-            jsdisp_t *obj;
-
-            hres = create_object(ctx, NULL, &obj);
-            if(FAILED(hres))
-                return hres;
-
-            *disp = to_disp(obj);
-        }
+        *disp = get_object(val);
+        IDispatch_AddRef(*disp);
         break;
     case JSV_BOOL:
         hres = create_bool(ctx, get_bool(val), &dispex);
@@ -854,10 +892,13 @@ HRESULT to_object(script_ctx_t *ctx, jsval_t val, IDispatch **disp)
 
         *disp = to_disp(dispex);
         break;
-    case JSV_UNDEFINED:
     case JSV_NULL:
+        if(is_null_disp(val))
+            return JS_E_OBJECT_REQUIRED;
+        /* fall through */
+    case JSV_UNDEFINED:
         WARN("object expected\n");
-        return throw_type_error(ctx, JS_E_OBJECT_EXPECTED, NULL);
+        return JS_E_OBJECT_EXPECTED;
     case JSV_VARIANT:
         switch(V_VT(get_variant(val))) {
         case VT_ARRAY|VT_VARIANT:
@@ -880,14 +921,16 @@ HRESULT to_object(script_ctx_t *ctx, jsval_t val, IDispatch **disp)
 
 HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTYPE vt)
 {
+    jsexcept_t ei;
     jsval_t val;
     HRESULT hres;
 
-    clear_ei(ctx);
-    hres = variant_to_jsval(src, &val);
+    hres = variant_to_jsval(ctx, src, &val);
     if(FAILED(hres))
         return hres;
 
+    enter_script(ctx, &ei);
+
     switch(vt) {
     case VT_I2:
     case VT_I4: {
@@ -940,16 +983,8 @@ HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTY
         if(FAILED(hres))
             break;
 
-        if(is_null_bstr(str)) {
-            V_BSTR(dst) = NULL;
-            break;
-        }
-
-        V_BSTR(dst) = SysAllocStringLen(NULL, jsstr_length(str));
-        if(V_BSTR(dst))
-            jsstr_flush(str, V_BSTR(dst));
-        else
-            hres = E_OUTOFMEMORY;
+        hres = jsstr_to_bstr(str, &V_BSTR(dst));
+        jsstr_release(str);
         break;
     }
     case VT_EMPTY:
@@ -958,12 +993,23 @@ HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTY
     case VT_NULL:
         hres = V_VT(src) == VT_NULL ? S_OK : E_NOTIMPL;
         break;
+    case VT_UNKNOWN:
+    case VT_DISPATCH:
+        if(V_VT(src) != vt)
+            hres = E_NOTIMPL;
+        else {
+            IUnknown_AddRef(V_UNKNOWN(src));
+            V_UNKNOWN(dst) = V_UNKNOWN(src);
+            hres = S_OK;
+        }
+        break;
     default:
         FIXME("vt %d not implemented\n", vt);
         hres = E_NOTIMPL;
     }
 
     jsval_release(val);
+    leave_script(ctx, hres);
     if(FAILED(hres))
         return hres;
 
@@ -1001,7 +1047,7 @@ static ULONG WINAPI JSCaller_AddRef(IServiceProvider *iface)
     JSCaller *This = impl_from_IServiceProvider(iface);
     LONG ref = InterlockedIncrement(&This->ref);
 
-    TRACE("(%p) ref=%d\n", This, ref);
+    TRACE("(%p) ref=%ld\n", This, ref);
 
     return ref;
 }
@@ -1009,13 +1055,13 @@ static ULONG WINAPI JSCaller_AddRef(IServiceProvider *iface)
 static ULONG WINAPI JSCaller_Release(IServiceProvider *iface)
 {
     JSCaller *This = impl_from_IServiceProvider(iface);
-    LONG ref = InterlockedIncrement(&This->ref);
+    LONG ref = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p) ref=%d\n", This, ref);
+    TRACE("(%p) ref=%ld\n", This, ref);
 
     if(!ref) {
         assert(!This->ctx);
-        heap_free(This);
+        free(This);
     }
 
     return ref;
@@ -1026,6 +1072,22 @@ static HRESULT WINAPI JSCaller_QueryService(IServiceProvider *iface, REFGUID gui
 {
     JSCaller *This = impl_from_IServiceProvider(iface);
 
+    if(IsEqualGUID(guidService, &IID_IActiveScriptSite)) {
+        TRACE("(%p)->(IID_IActiveScriptSite)\n", This);
+        if(This->ctx && This->ctx->site)
+            return IActiveScriptSite_QueryInterface(This->ctx->site, riid, ppv);
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    if(IsEqualGUID(guidService, &SID_GetCaller)) {
+        TRACE("(%p)->(SID_GetCaller)\n", This);
+        *ppv = NULL;
+        if(!This->caller)
+            return S_OK;
+        return (This->caller == SP_CALLER_UNINITIALIZED) ? E_NOINTERFACE : IServiceProvider_QueryInterface(This->caller, riid, ppv);
+    }
+
     if(IsEqualGUID(guidService, &SID_VariantConversion) && This->ctx && This->ctx->active_script) {
         TRACE("(%p)->(SID_VariantConversion)\n", This);
         return IActiveScript_QueryInterface(This->ctx->active_script, riid, ppv);
@@ -1048,13 +1110,14 @@ HRESULT create_jscaller(script_ctx_t *ctx)
 {
     JSCaller *ret;
 
-    ret = heap_alloc(sizeof(*ret));
+    ret = malloc(sizeof(*ret));
     if(!ret)
         return E_OUTOFMEMORY;
 
     ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
     ret->ref = 1;
     ret->ctx = ctx;
+    ret->caller = SP_CALLER_UNINITIALIZED;
 
     ctx->jscaller = ret;
     return S_OK;

dll/win32/jscript/jsval.h

@@ -35,8 +35,8 @@
 #endif
 
 #ifdef JSVAL_DOUBLE_LAYOUT_PTR32
-/* NaN exponent and our 0x80000 marker */
-#define JSV_VAL(x) (0x7ff80000|x)
+/* NaN exponent, quiet bit 0x80000 and our 0x10000 marker */
+#define JSV_VAL(x) (0x7ff90000|x)
 #else
 #define JSV_VAL(x) x
 #endif
@@ -131,6 +131,15 @@ static inline jsval_t jsval_null(void)
 {
     jsval_t ret;
     __JSVAL_TYPE(ret) = JSV_NULL;
+    __JSVAL_BOOL(ret) = FALSE;
+    return ret;
+}
+
+static inline jsval_t jsval_null_disp(void)
+{
+    jsval_t ret;
+    __JSVAL_TYPE(ret) = JSV_NULL;
+    __JSVAL_BOOL(ret) = TRUE;
     return ret;
 }
 
@@ -150,10 +159,10 @@ static inline jsval_t jsval_number(double n)
     if((ret.u.s.tag & 0x7ff00000) == 0x7ff00000) {
         /* isinf */
         if(ret.u.s.tag & 0xfffff) {
-            ret.u.s.tag = 0x7ff00000;
+            ret.u.s.tag = 0x7ff80000;
             ret.u.s.u.as_uintptr = ~0;
         }else if(ret.u.s.u.as_uintptr) {
-            ret.u.s.tag = 0x7ff00000;
+            ret.u.s.tag = 0x7ff80000;
         }
     }
 #else
@@ -178,9 +187,9 @@ static inline BOOL is_null(jsval_t v)
     return __JSVAL_TYPE(v) == JSV_NULL;
 }
 
-static inline BOOL is_null_instance(jsval_t v)
+static inline BOOL is_null_disp(jsval_t v)
 {
-    return is_null(v) || (is_object_instance(v) && !__JSVAL_OBJ(v));
+    return is_null(v) && __JSVAL_BOOL(v);
 }
 
 static inline BOOL is_string(jsval_t v)
@@ -191,7 +200,7 @@ static inline BOOL is_string(jsval_t v)
 static inline BOOL is_number(jsval_t v)
 {
 #ifdef JSVAL_DOUBLE_LAYOUT_PTR32
-    return (v.u.s.tag & 0x7ff80000) != 0x7ff80000;
+    return (v.u.s.tag & 0x7ff10000) != 0x7ff10000;
 #else
     return v.type == JSV_NUMBER;
 #endif
@@ -241,9 +250,9 @@ static inline BOOL get_bool(jsval_t v)
     return __JSVAL_BOOL(v);
 }
 
-HRESULT variant_to_jsval(VARIANT*,jsval_t*) DECLSPEC_HIDDEN;
-HRESULT jsval_to_variant(jsval_t,VARIANT*) DECLSPEC_HIDDEN;
-void jsval_release(jsval_t) DECLSPEC_HIDDEN;
-HRESULT jsval_copy(jsval_t,jsval_t*) DECLSPEC_HIDDEN;
+HRESULT variant_to_jsval(script_ctx_t*,VARIANT*,jsval_t*);
+HRESULT jsval_to_variant(jsval_t,VARIANT*);
+void jsval_release(jsval_t);
+HRESULT jsval_copy(jsval_t,jsval_t*);
 
 #endif

dll/win32/jscript/lang/jscript_Da.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Fejl ved konvertering af objekt til primitiv type"
     IDS_INVALID_CALL_ARG    "Ugyldig procedure kald eller argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automations-serveren kan ikke oprette objektet"
     IDS_NO_PROPERTY         "Objektet understøtter ikke denne egenskab eller metode"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument ikke valgfrit"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Syntaksfejl"
     IDS_SEMICOLON           "Forventet ';'"
     IDS_LBRACKET            "Forventet '('"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript objekt forventet"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntax fejl i regulært udtryk"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI, der skal kodes indeholder ugyldige tegn"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Array længde skal være et endeligt positivt heltal"
     IDS_ARRAY_EXPECTED      "Array objekt forventet"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_De.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Fehler beim Umwandeln des Objektes in einen Grundtyp"
     IDS_INVALID_CALL_ARG    "Ungültiger Funktionsaufruf oder ungültiges Argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automatisierungsserver konnte das Objekt nicht erstellen"
     IDS_NO_PROPERTY         "Das Objekt unterstützt diese Eigenschaft oder Methode nicht"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Dieses Argument ist nicht optional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Syntaxfehler"
     IDS_SEMICOLON           "';' erwartet"
     IDS_LBRACKET            "'(' erwartet"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript-Objekt erwartet"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntaxfehler in regulärem Ausdruck"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "Zu verschlüsselnde URI enthält ungültige Zeichen"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Größe des Array muss eine endliche, positive Ganzzahl sein"
     IDS_ARRAY_EXPECTED      "Array-Objekt erwartet"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_En.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Error converting object to primitive type"
     IDS_INVALID_CALL_ARG    "Invalid procedure call or argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automation server can't create object"
     IDS_NO_PROPERTY         "Object doesn't support this property or method"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument not optional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Syntax error"
     IDS_SEMICOLON           "Expected ';'"
     IDS_LBRACKET            "Expected '('"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript object expected"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntax error in regular expression"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI to be encoded contains invalid characters"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Array length must be a finite positive integer"
     IDS_ARRAY_EXPECTED      "Array object expected"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Es.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Error al convertir objeto a tipo primitivo"
     IDS_INVALID_CALL_ARG    "Llamada a procedimiento no válido o argumento"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Servidor de automatización no puede crear el objeto"
     IDS_NO_PROPERTY         "El objeto no acepta esta propiedad o método"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argumento no opcional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Error de sintaxis"
     IDS_SEMICOLON           "Esperado ';'"
     IDS_LBRACKET            "Esperado '('"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Objeto JScript esperado"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Error de sintaxis en la expresion regular"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI a codificar contiene caracteres no válidos"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "La longitud del arreglo debe ser un entero positivo finito"
     IDS_ARRAY_EXPECTED      "Objeto Arreglo esperado"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Fr.rc

@@ -25,11 +25,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Erreur lors de la conversion de l'objet vers un type primitif"
     IDS_INVALID_CALL_ARG    "Appel de procédure ou argument invalide"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Le serveur d'automatisation ne peut créer l'objet"
     IDS_NO_PROPERTY         "Cet objet ne supporte pas cette propriété ou méthode"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument non optionnel"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Erreur de syntaxe"
     IDS_SEMICOLON           "« ; » attendu"
     IDS_LBRACKET            "« ( » attendu"
@@ -56,7 +58,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Objet JScript attendu"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Erreur de syntaxe dans l'expression rationnelle"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "L'URI à coder contient des caractères invalides"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -64,7 +70,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "La longueur d'un tableau doit être un entier positif"
     IDS_ARRAY_EXPECTED      "Objet tableau attendu"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_He.rc

@@ -25,11 +25,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Error converting object to primitive type"
     IDS_INVALID_CALL_ARG    "Invalid procedure call or argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automation server can't create object"
     IDS_NO_PROPERTY         "Object doesn't support this property or method"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument not optional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "שגיאת תחביר"
     IDS_SEMICOLON           "צפוי ';'"
     IDS_LBRACKET            "צפוי '('"
@@ -56,7 +58,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "אובייקט JScript היה צפוי"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntax error in regular expression"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI to be encoded contains invalid characters"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -64,7 +70,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Array length must be a finite positive integer"
     IDS_ARRAY_EXPECTED      "אובייקט מערך היה צפוי"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Hu.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Hiba az objektum primitív típusra való konvertálásánál"
     IDS_INVALID_CALL_ARG    "Érvénytelen eljáráshívás vagy argmentum"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Az automatizáló (automation) kiszolgáló nem tud objektumot létrehozni"
     IDS_NO_PROPERTY         "Az objektum nem támogatja ezt a tulajdonságot vagy metódust"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Az argumentum nem opcionális"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Szinttaktikai hiba"
     IDS_SEMICOLON           "Hiányzó ';'"
     IDS_LBRACKET            "Hiányzó '('"
@@ -54,6 +56,8 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript objektumot vártam"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Szinttaktikai hiba a reguláris kifejezésben"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "A kódolandó URI érvénytelen karaktereket tartalmaz"
@@ -62,7 +66,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "A tömb hosszának egy véges pozitív egész számnak kell lennie"
     IDS_ARRAY_EXPECTED      "Tömb objektumot vártam"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_It.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Errore nel convertire un oggetto ad un tipo primitivo"
     IDS_INVALID_CALL_ARG    "Chiamata o argomento di procedura non valido"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Il server di automazione non può creare l'oggetto"
     IDS_NO_PROPERTY         "L'oggetto non supporta questa proprietà o metodo"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argomento non opzionale"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Errore di sintassi"
     IDS_SEMICOLON           "Richiesto ';'"
     IDS_LBRACKET            "Richiesto '('"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Richiesto un oggetto JScript"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Errore di sintassi nell'espressione regolare"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "L'URI da codificare contiene caratteri non validi"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "La lunghezza dell'array deve essere un intero finito e positivo"
     IDS_ARRAY_EXPECTED      "Richiesto un oggetto array"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Ja.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "オブジェクトを基本型に変換できません"
     IDS_INVALID_CALL_ARG    "手続き呼び出しまたは引数が無効です"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "オートメーション サーバはオブジェクトを生成できません"
     IDS_NO_PROPERTY         "オブジェクトはこのプロパティまたはメソッドをサポートしていません"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "引数は省略できません"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "文法エラー"
     IDS_SEMICOLON           "';'を期待していました"
     IDS_LBRACKET            "'('を期待していました"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScriptオブジェクトを期待していました"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "正規表現に文法誤りがあります"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "エンコードされるURIに無効な文字が含まれています"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "配列の長さは有限の正整数でなければなりません"
     IDS_ARRAY_EXPECTED      "配列オブジェクトを期待していました"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Ko.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "객페를 기본 형식으로 변환하는 중에 에러 발생"
     IDS_INVALID_CALL_ARG    "올바르지 않은 프로시져 호출이나 인수"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "자동화 서버가 객체를 만들 수 없습니다"
     IDS_NO_PROPERTY         "객체는 이 속성이나 메소드를 지원하지 않습니다"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "인수는 옵션이 아닙니다"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "문법 에러"
     IDS_SEMICOLON           "';' 가 필요합니다"
     IDS_LBRACKET            "'(' 가 필요합니다"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript 객체가 필요합니다"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "정규 표현식에 문법에러가 있습니다"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI 는 올바르지 않은 문자를 포함해서 인코딩되었습니다"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "배열 길이는 반드시  한정된 양의 정수이어야 합니다"
     IDS_ARRAY_EXPECTED      "배열 객체가 필요합니다"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Lt.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Klaida keičiant objektą į primityvų tipą"
     IDS_INVALID_CALL_ARG    "Netinkamas kreipinys į procedūrą ar argumentas"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automatizacijos serveriui nepavyko sukurti objekto"
     IDS_NO_PROPERTY         "Objektas nepalaiko šios savybės ar metodo"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argumentas nėra neprivalomas"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Sintaksės klaida"
     IDS_SEMICOLON           "Tikėtasi „;“"
     IDS_LBRACKET            "Tikėtasi „(“"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Tikėtasi JScript objekto"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Sintaksės klaida reguliariajame reiškinyje"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "Koduotiname URI yra netinkamų simbolių"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Masyvo dydis turi būti teigiamas sveikasis skaičius"
     IDS_ARRAY_EXPECTED      "Tikėtasi masyvo objekto"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Nl.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Fout bij het omzetten van het object naar een primitief type"
     IDS_INVALID_CALL_ARG    "Ongeldige procedure-aanroep of argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automatiseringsserver kan het object niet creëren"
     IDS_NO_PROPERTY         "Dit object ondersteunt deze eigenschap of methode niet"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument is niet optioneel"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Syntax fout"
     IDS_SEMICOLON           "';' verwacht"
     IDS_LBRACKET            "'(' verwacht"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "JScript object verwacht"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntax fout in reguliere expressie"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "De te coderen URI bevat ongeldige tekens"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Array lengte moet een eindig, positief geheel getal zijn"
     IDS_ARRAY_EXPECTED      "Array object verwacht"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_No.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Klarte ikke konvertere objekt til primitiv type"
     IDS_INVALID_CALL_ARG    "Ugyldig funksjonskall eller argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Automatiseringstjeneren klarte ikke opprette objekt"
     IDS_NO_PROPERTY         "Objektet støtter ikke denne egenskapen eller metoden"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argumentet er ikke valgfritt"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Syntaksfeil"
     IDS_SEMICOLON           "Forventet ';'"
     IDS_LBRACKET            "Forventet '('"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Forventet JScript-objekt"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Syntaksfeil i regulært uttrykk"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI'en som skulle kodes inneholder ugyldige tegn"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Rekkens lengde må være et endelig, positivt tall"
     IDS_ARRAY_EXPECTED      "Forventet rekke-objekt"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Pl.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Błąd przy przekształcaniu obiektu do typu podstawowego"
     IDS_INVALID_CALL_ARG    "Nieprawidłowe wywołanie procedury lub nieprawidłowy argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Indeks poza zakresem"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Wymagany jest obiekt"
     IDS_CREATE_OBJ_ERROR    "Serwer automatyzacji nie może utworzyć obiektu"
     IDS_NO_PROPERTY         "Obiekt nie obsługuje tej właściwości lub metody"
     IDS_UNSUPPORTED_ACTION  "Obiekt nie obsługuje tej operacji"
     IDS_ARG_NOT_OPT         "Argument nie jest opcjonalny"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Błąd składni"
     IDS_SEMICOLON           "Oczekiwano znaku ':'"
     IDS_LBRACKET            "Oczekiwano znaku '('"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Nie można usunąć '|'"
     IDS_NOT_VBARRAY         "Oczekiwano obiektu typu VBArray"
     IDS_JSCRIPT_EXPECTED    "Oczekiwano obiektu typu JScript"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Błąd składniowy w wyrażeniu zwykłym"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI do zdekodowania jest nieprawidłowy"
     IDS_URI_INVALID_CHAR    "URI do zakodowania zawiera nieprawidłowe znaki"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Liczba miejsc po przecinku jest poza zakresem"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Długość tablicy musi być skończoną dodatnią liczbą całkowitą"
     IDS_ARRAY_EXPECTED      "Oczekiwano obiektu tablicy"
     IDS_INVALID_WRITABLE_PROP_DESC "Atrybut 'writable' dotyczący deskryptora właściwości nie może mieć wartości 'true' dla tego obiektu"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Nie można ponownie zdefiniować niekonfigurowalnej właściwości '|'"
     IDS_NONWRITABLE_MODIFIED       "Nie można zdefiniować niezapisywalnej właściwości '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Właściwość nie może mieć jednocześnie metod dostępu i wartości"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Pt.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Erro ao converter objeto em tipo primitivo"
     IDS_INVALID_CALL_ARG    "Argumento ou chamada de procedimento inválida"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "O servidor de automação não conseguiu criar o objeto"
     IDS_NO_PROPERTY         "O objeto não suporta esta propriedade ou método"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argumento não opcional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Erro de sintaxe"
     IDS_SEMICOLON           "';' esperado"
     IDS_LBRACKET            "'(' esperado"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Objeto JScript esperado"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Erro de sintaxe na expressão regular"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI a ser codificado contém caracteres inválidos"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,9 +69,23 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Tamanho do vetor tem que ser um inteiro finito positivo"
     IDS_ARRAY_EXPECTED      "Objeto Array esperado"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }
 
 LANGUAGE LANG_PORTUGUESE, SUBLANG_PORTUGUESE
@@ -75,11 +95,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Erro ao converter objecto em tipo primitivo"
     IDS_INVALID_CALL_ARG    "Argumento ou chamada de procedimento inválido"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Inscrito fora do intervalo"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Objecto necessário"
     IDS_CREATE_OBJ_ERROR    "O servidor de automação não conseguiu criar o objecto"
     IDS_NO_PROPERTY         "O objecto não suporta esta propriedade ou método"
     IDS_UNSUPPORTED_ACTION  "O objecto não suporta esta acção"
     IDS_ARG_NOT_OPT         "Argumento não opcional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Erro de sintaxe"
     IDS_SEMICOLON           "';' esperado"
     IDS_LBRACKET            "'(' esperado"
@@ -106,7 +128,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Não é possível excluir '|'"
     IDS_NOT_VBARRAY         "Objecto VBArray esperado"
     IDS_JSCRIPT_EXPECTED    "Objecto JScript esperado"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Erro de sintaxe na expressão regular"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "O URI a ser decodificado está incorrecto"
     IDS_URI_INVALID_CHAR    "O URI a ser codificado contém caracteres inválidos"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "O número de dígitos da fracção está fora do intervalo"
@@ -114,7 +140,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Tamanho do vector deverá ser um número inteiro positivo"
     IDS_ARRAY_EXPECTED      "Objecto Array esperado"
     IDS_INVALID_WRITABLE_PROP_DESC "O atributo 'gravável' no descritor de propriedades não pode ser definido como 'true' neste objecto"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Não é possível redefinir a propriedade não configurável '|'"
     IDS_NONWRITABLE_MODIFIED       "Não é possível modificar a propriedade não gravável '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "A propriedade não pode ter acessadores e um valor"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Ro.rc

@@ -27,11 +27,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Eroare la convertirea obiectului la un tip primitiv"
     IDS_INVALID_CALL_ARG    "Apel de procedură sau argument nevalid"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript în afara limitelor admise"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Obiect necesar"
     IDS_CREATE_OBJ_ERROR    "Serverul de automatizare nu poate crea obiectul"
     IDS_NO_PROPERTY         "Proprietatea sau metoda este neaplicabilă obiectului"
     IDS_UNSUPPORTED_ACTION  "Acțiunea este neaplicabilă obiectului"
     IDS_ARG_NOT_OPT         "Argumentul nu este opțional"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Eroare de sintaxă"
     IDS_SEMICOLON           "Era așteptat „;”"
     IDS_LBRACKET            "Era așteptat „(”"
@@ -58,7 +60,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "„|” nu poate fi șters"
     IDS_NOT_VBARRAY         "Era așteptat un obiect de tip VBArray"
     IDS_JSCRIPT_EXPECTED    "Era așteptat un obiect JScript"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Eroare de sintaxă în expresia regulată"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI ce urmează a fi decodificat nu este corect"
     IDS_URI_INVALID_CHAR    "URI care trebuie codificat conține caractere nevalide"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Numărul cifrelor fracționare este în afara limitelor admise"
@@ -66,7 +72,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Lungimea unei matrice trebuie să fie un număr întreg pozitiv"
     IDS_ARRAY_EXPECTED      "Era așteptat un obiect matrice"
     IDS_INVALID_WRITABLE_PROP_DESC "„inscriptibil” de pe descriptorul de proprietate nu poate fi setat la „adevărat” pe acest obiect"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Nu se poate redefini proprietatea neconfigurabilă „|”"
     IDS_NONWRITABLE_MODIFIED       "Nu se poate modifica proprietatea neinscriptibilă „|”"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Proprietatea nu poate avea atât accesori, cât și o valoare"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Ru.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Ошибка конвертирования объекта в примитивный тип"
     IDS_INVALID_CALL_ARG    "Недопустимый вызов или аргумент процедуры"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Нижний индекс вне диапазона"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Требуется объект"
     IDS_CREATE_OBJ_ERROR    "Сервер автоматизации не может создать объект"
     IDS_NO_PROPERTY         "Объект не поддерживает это свойство или метод"
     IDS_UNSUPPORTED_ACTION  "Объект не поддерживает это действие"
     IDS_ARG_NOT_OPT         "Отсутствует обязательный аргумент"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Синтаксическая ошибка"
     IDS_SEMICOLON           "Предполагается наличие ';'"
     IDS_LBRACKET            "Предполагается наличие '('"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Не удается удалить '|'"
     IDS_NOT_VBARRAY         "Предполагается наличие VBArray"
     IDS_JSCRIPT_EXPECTED    "Предполагается наличие объекта 'JScript'"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Синтаксическая ошибка в регулярном выражении"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "Обнаружена недопустимая кодировка при попытке декодирования URI"
     IDS_URI_INVALID_CHAR    "Обнаружен недопустимый знак при попытке кодирования URI"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Количество цифр дробной части числа вышла из диапазона"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Длиной массива должно быть конечное положительное число"
     IDS_ARRAY_EXPECTED      "Предполагается наличие объекта 'Array'"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Si.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Napaka med spreminjanjem v primitivni tip"
     IDS_INVALID_CALL_ARG    "Napačen klic postopka ali argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Avtomatizacijski server ne more ustvariti objekta"
     IDS_NO_PROPERTY         "Objekt ne podpira atributa ali metode"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argument je obvezen"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Napačna sintaksa"
     IDS_SEMICOLON           "Pričakujem ';'"
     IDS_LBRACKET            "Pričakujem '('"
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Pričakujem JScript objekt"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Napačna sintaksa v regularnem izrazu"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI vsebuje neveljavne znake"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Dožina polja mora bit pozitivno celo število"
     IDS_ARRAY_EXPECTED      "Pričakujem Array objekt"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Sq.rc

@@ -26,11 +26,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Gabim ne konvertimin e subjektit te tipit primitiv"
     IDS_INVALID_CALL_ARG    "Procedure a pavlefshme ne thirrje apo argument"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Serveri i Automatizuar nuk mund te krijoje objektin"
     IDS_NO_PROPERTY         "Objekti nuk mbeshtet kete tipar apo metode"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Argumente jo opsionale"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "GAbim Sintaksi"
     IDS_SEMICOLON           "Pritej ';'"
     IDS_LBRACKET            "Pritej '('"
@@ -57,7 +59,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Objekti JScript Pritej"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Gabim sintaksti ne shprehjen e rregullt"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI për tu koduar përmban shenja të pavlefshme"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -65,7 +71,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Gjatësia e një grupi duhet të jetë një numër i plotë pozitiv i caktuar"
     IDS_ARRAY_EXPECTED      "Objekti Array Pritej"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Tr.rc

@@ -23,11 +23,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Nesneyi ilk türe dönüştürmede hata."
     IDS_INVALID_CALL_ARG    "Geçersiz yordam çağrısı ya da değişkeni."
     IDS_SUBSCRIPT_OUT_OF_RANGE "Alt indis aralık dışında."
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Nesne gerekli."
     IDS_CREATE_OBJ_ERROR    "Otomasyon sunucusu nesne oluşturamıyor."
     IDS_NO_PROPERTY         "Nesne bu özelliği/yöntemi desteklemiyor."
     IDS_UNSUPPORTED_ACTION  "Nesne bu işlemi desteklemiyor."
     IDS_ARG_NOT_OPT         "Değişken seçimlik değil."
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Söz dizimi hatası."
     IDS_SEMICOLON           """;"" bekleniyordu."
     IDS_LBRACKET            """("" bekleniyordu."
@@ -54,7 +56,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      """|"" silinemez."
     IDS_NOT_VBARRAY         "VBArray nesnesi bekleniyordu."
     IDS_JSCRIPT_EXPECTED    "JScript nesnesi bekleniyordu."
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Düzenli deyişte söz dizimi hatası."
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "Çözülecek URI geçersiz."
     IDS_URI_INVALID_CHAR    "Kodlanacak URI geçersiz karakterler içeriyor."
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Kesir basamaklarının sayısı aralık dışında."
@@ -62,7 +68,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Dizi büyüklüğü bir sonlu artı tam sayı olmalı."
     IDS_ARRAY_EXPECTED      "Dizi nesnesi bekleniyordu."
     IDS_INVALID_WRITABLE_PROP_DESC "Nesne açıklayıcısındaki 'yazılabilir' özelliği bu nesnede 'doğru' olarak ayarlanamaz."
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "'|' yapılandırılamayan nesnesi yeniden tanımlanamaz."
     IDS_NONWRITABLE_MODIFIED       "'|' yazılamayan nesnesi değiştirilemez."
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Nesnenin aynı anda erişeni ve değeri olamaz."
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Uk.rc

@@ -24,11 +24,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "Помилка конвертування об'єкту в примітивний тип"
     IDS_INVALID_CALL_ARG    "Невірний виклик процедури або аргумент"
     IDS_SUBSCRIPT_OUT_OF_RANGE "Subscript out of range"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "Object required"
     IDS_CREATE_OBJ_ERROR    "Сервер автоматизації не може створити об'єкт"
     IDS_NO_PROPERTY         "Об'єкт не підтримує цю властивість чи метод"
     IDS_UNSUPPORTED_ACTION  "Object doesn't support this action"
     IDS_ARG_NOT_OPT         "Відсутній обов'язковий аргумент"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "Синтаксична помилка"
     IDS_SEMICOLON           "Очікується ';'"
     IDS_LBRACKET            "Очікується '('"
@@ -55,7 +57,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "Cannot delete '|'"
     IDS_NOT_VBARRAY         "VBArray object expected"
     IDS_JSCRIPT_EXPECTED    "Очікується об'єкт JScript"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "Синтаксична помилка в регулярному виразі"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "URI to be decoded is incorrect"
     IDS_URI_INVALID_CHAR    "URI, що буде закодований, містить неприпустимі символи"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "Number of fraction digits is out of range"
@@ -63,7 +69,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "Довжиною масиву повинне бути скінченне додатнє ціле число"
     IDS_ARRAY_EXPECTED      "Очікується об'єкт Array"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lang/jscript_Zh.rc

@@ -26,11 +26,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "将对象转换为原始类型的错误"
     IDS_INVALID_CALL_ARG    "无效的过程调用或参数"
     IDS_SUBSCRIPT_OUT_OF_RANGE "下标超出范围"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "所需的对象"
     IDS_CREATE_OBJ_ERROR    "自动化服务器不能创建对象"
     IDS_NO_PROPERTY         "对象不支持此属性或方法"
     IDS_UNSUPPORTED_ACTION  "对象不支持此操作"
     IDS_ARG_NOT_OPT         "参数不可选"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "语法错误"
     IDS_SEMICOLON           "预期 ';'"
     IDS_LBRACKET            "预期 '('"
@@ -57,7 +59,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "不能删除 '|'"
     IDS_NOT_VBARRAY         "VBArray 对象预期"
     IDS_JSCRIPT_EXPECTED    "JScript 对象预期"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "正则表达式中的语法错误"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "被解码的 URI 不正确"
     IDS_URI_INVALID_CHAR    "要编码的 URI 包含无效的字符"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "数字的小数部分的位数是超出范围"
@@ -65,9 +71,23 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "数组长度必须为一个有限的正整数"
     IDS_ARRAY_EXPECTED      "预期的数组对象"
     IDS_INVALID_WRITABLE_PROP_DESC "'writable' attribute on the property descriptor cannot be set to 'true' on this object"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "Cannot redefine non-configurable property '|'"
     IDS_NONWRITABLE_MODIFIED       "Cannot modify non-writable property '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "Property cannot have both accessors and a value"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }
 
 LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL
@@ -77,11 +97,13 @@ STRINGTABLE
     IDS_TO_PRIMITIVE        "轉換物件到基本類型時發生錯誤"
     IDS_INVALID_CALL_ARG    "無效的程序呼叫或引數"
     IDS_SUBSCRIPT_OUT_OF_RANGE "註標超出範圍"
+    IDS_STACK_OVERFLOW      "Out of stack space"
     IDS_OBJECT_REQUIRED     "需要物件"
     IDS_CREATE_OBJ_ERROR    "自動作業伺服器無法建立物件"
     IDS_NO_PROPERTY         "物件不支援這個屬性或方法"
     IDS_UNSUPPORTED_ACTION  "物件不支援這個操作"
     IDS_ARG_NOT_OPT         "這個"
+    IDS_OBJECT_NOT_COLLECTION "Object not a collection"
     IDS_SYNTAX_ERROR        "語法錯誤"
     IDS_SEMICOLON           "預期為 ';'"
     IDS_LBRACKET            "預期為 '('"
@@ -108,7 +130,11 @@ STRINGTABLE
     IDS_INVALID_DELETE      "無法刪除 '|'"
     IDS_NOT_VBARRAY         "預期為 VBArray 物件"
     IDS_JSCRIPT_EXPECTED    "預期為 JScript 物件"
+    IDS_ENUMERATOR_EXPECTED "Enumerator object expected"
+    IDS_REGEXP_EXPECTED     "Regular Expression object expected"
     IDS_REGEXP_SYNTAX_ERROR "正規表示式語法發生錯誤"
+    IDS_UNEXPECTED_QUANTIFIER "Unexpected quantifier"
+    IDS_EXCEPTION_THROWN    "Exception thrown and not caught"
     IDS_URI_INVALID_CODING  "要編碼的 URI 內含無效字元"
     IDS_URI_INVALID_CHAR    "要編碼的 URI 內含無效字元"
     IDS_FRACTION_DIGITS_OUT_OF_RANGE "要編碼的 URI 內含無效字元"
@@ -116,7 +142,21 @@ STRINGTABLE
     IDS_INVALID_LENGTH      "陣列長度必須是有限正整數"
     IDS_ARRAY_EXPECTED      "預期為陣列物件"
     IDS_INVALID_WRITABLE_PROP_DESC "無法在這個物件更改屬性描述符中的 'writable' 屬性為 'true'"
+    IDS_CYCLIC_PROTO_VALUE         "Cyclic __proto__ value"
+    IDS_CREATE_FOR_NONEXTENSIBLE   "Cannot create property for a non-extensible object"
+    IDS_OBJECT_NONEXTENSIBLE       "Cannot define property '|': object is not extensible"
     IDS_NONCONFIGURABLE_REDEFINED  "無法重新定義不可設定的屬性 '|'"
     IDS_NONWRITABLE_MODIFIED       "無法修改不可寫入的屬性 '|'"
+    IDS_NOT_DATAVIEW               "'this' is not a DataView object"
+    IDS_DATAVIEW_NO_ARGUMENT       "Required argument offset or value in DataView method is not specified"
+    IDS_DATAVIEW_INVALID_ACCESS    "DataView operation access beyond specified buffer length"
+    IDS_DATAVIEW_INVALID_OFFSET    "DataView constructor argument offset is invalid"
+    IDS_WRONG_THIS                 "'this' is not a | object"
+    IDS_KEY_NOT_OBJECT             "'key' is not an object"
+    IDS_ARRAYBUFFER_EXPECTED       "ArrayBuffer object expected"
     IDS_PROP_DESC_MISMATCH         "屬性不可同時有存取子和值"
+
+    IDS_COMPILATION_ERROR   "Microsoft JScript compilation error"
+    IDS_RUNTIME_ERROR       "Microsoft JScript runtime error"
+    IDS_UNKNOWN_ERROR       "Unknown runtime error"
 }

dll/win32/jscript/lex.c

@@ -41,6 +41,7 @@ static const struct {
     {L"break",       kBREAK,       TRUE},
     {L"case",        kCASE},
     {L"catch",       kCATCH},
+    {L"const",       kCONST},
     {L"continue",    kCONTINUE,    TRUE},
     {L"default",     kDEFAULT},
     {L"delete",      kDELETE},
@@ -54,6 +55,7 @@ static const struct {
     {L"if",          kIF},
     {L"in",          kIN},
     {L"instanceof",  kINSTANCEOF},
+    {L"let",         kLET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
     {L"new",         kNEW},
     {L"null",        kNULL},
     {L"return",      kRETURN,      TRUE},
@@ -115,7 +117,7 @@ static BOOL is_endline(WCHAR c)
     return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;
 }
 
-static int hex_to_int(WCHAR c)
+int hex_to_int(WCHAR c)
 {
     if('0' <= c && c <= '9')
         return c-'0';
@@ -159,10 +161,8 @@ static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
 
 static BOOL skip_html_comment(parser_ctx_t *ctx)
 {
-    const WCHAR html_commentW[] = {'<','!','-','-',0};
-
     if(!ctx->is_html || ctx->ptr+3 >= ctx->end ||
-        memcmp(ctx->ptr, html_commentW, sizeof(WCHAR)*4))
+        memcmp(ctx->ptr, L"<!--", sizeof(WCHAR)*4))
         return FALSE;
 
     ctx->nl = TRUE;
@@ -297,11 +297,11 @@ BOOL unescape(WCHAR *str, size_t *len)
             c += i;
             break;
         default:
-            if(iswdigit(*p)) {
+            if(is_digit(*p)) {
                 c = *p++ - '0';
-                if(p < end && iswdigit(*p)) {
+                if(p < end && is_digit(*p)) {
                     c = c*8 + (*p++ - '0');
-                    if(p < end && iswdigit(*p))
+                    if(p < end && is_digit(*p))
                         c = c*8 + (*p++ - '0');
                 }
                 p--;
@@ -400,7 +400,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
     LONGLONG d = 0, hlp;
     int exp = 0;
 
-    while(ptr < end && iswdigit(*ptr)) {
+    while(ptr < end && is_digit(*ptr)) {
         hlp = d*10 + *(ptr++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0) {
             exp++;
@@ -409,7 +409,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
         else
             d = hlp;
     }
-    while(ptr < end && iswdigit(*ptr)) {
+    while(ptr < end && is_digit(*ptr)) {
         exp++;
         ptr++;
     }
@@ -417,7 +417,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
     if(*ptr == '.') {
         ptr++;
 
-        while(ptr < end && iswdigit(*ptr)) {
+        while(ptr < end && is_digit(*ptr)) {
             hlp = d*10 + *(ptr++) - '0';
             if(d>MAXLONGLONG/10 || hlp<0)
                 break;
@@ -425,7 +425,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
             d = hlp;
             exp--;
         }
-        while(ptr < end && iswdigit(*ptr))
+        while(ptr < end && is_digit(*ptr))
             ptr++;
     }
 
@@ -438,7 +438,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
             }else if(*ptr == '-') {
                 sign = -1;
                 ptr++;
-            }else if(!iswdigit(*ptr)) {
+            }else if(!is_digit(*ptr)) {
                 WARN("Expected exponent part\n");
                 return E_FAIL;
             }
@@ -449,7 +449,7 @@ HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
             return E_FAIL;
         }
 
-        while(ptr < end && iswdigit(*ptr)) {
+        while(ptr < end && is_digit(*ptr)) {
             if(e > INT_MAX/10 || (e = e*10 + *ptr++ - '0')<0)
                 e = INT_MAX;
         }
@@ -500,12 +500,12 @@ static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret)
             return TRUE;
         }
 
-        if(iswdigit(*ctx->ptr)) {
+        if(is_digit(*ctx->ptr)) {
             unsigned base = 8;
             const WCHAR *ptr;
             double val = 0;
 
-            for(ptr = ctx->ptr; ptr < ctx->end && iswdigit(*ptr); ptr++) {
+            for(ptr = ctx->ptr; ptr < ctx->end && is_digit(*ptr); ptr++) {
                 if(*ptr > '7') {
                     base = 10;
                     break;
@@ -514,7 +514,7 @@ static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret)
 
             do {
                 val = val*base + *ctx->ptr-'0';
-            }while(++ctx->ptr < ctx->end && iswdigit(*ctx->ptr));
+            }while(++ctx->ptr < ctx->end && is_digit(*ctx->ptr));
 
             /* FIXME: Do we need it here? */
             if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) {
@@ -543,12 +543,15 @@ static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret)
     return TRUE;
 }
 
-static int next_token(parser_ctx_t *ctx, void *lval)
+static int next_token(parser_ctx_t *ctx, unsigned *loc, void *lval)
 {
     do {
-        if(!skip_spaces(ctx))
-            return tEOF;
+        if(!skip_spaces(ctx)) {
+            *loc  = ctx->ptr - ctx->begin;
+            return 0;
+        }
     }while(skip_comment(ctx) || skip_html_comment(ctx));
+    *loc  = ctx->ptr - ctx->begin;
 
     if(ctx->implicit_nl_semicolon) {
         if(ctx->nl)
@@ -564,7 +567,7 @@ static int next_token(parser_ctx_t *ctx, void *lval)
         return parse_identifier(ctx, lval);
     }
 
-    if(iswdigit(*ctx->ptr)) {
+    if(is_digit(*ctx->ptr)) {
         double n;
 
         if(!parse_numeric_literal(ctx, &n))
@@ -576,6 +579,7 @@ static int next_token(parser_ctx_t *ctx, void *lval)
 
     switch(*ctx->ptr) {
     case '{':
+    case '}':
     case '(':
     case ')':
     case '[':
@@ -586,12 +590,8 @@ static int next_token(parser_ctx_t *ctx, void *lval)
     case '?':
         return *ctx->ptr++;
 
-    case '}':
-        *(const WCHAR**)lval = ctx->ptr++;
-        return '}';
-
     case '.':
-        if(ctx->ptr+1 < ctx->end && iswdigit(ctx->ptr[1])) {
+        if(ctx->ptr+1 < ctx->end && is_digit(ctx->ptr[1])) {
             double n;
             HRESULT hres;
             hres = parse_decimal(&ctx->ptr, ctx->end, &n);
@@ -820,10 +820,10 @@ void release_cc(cc_ctx_t *cc)
 
     for(iter = cc->vars; iter; iter = next) {
         next = iter->next;
-        heap_free(iter);
+        free(iter);
     }
 
-    heap_free(cc);
+    free(cc);
 }
 
 static BOOL new_cc_var(cc_ctx_t *cc, const WCHAR *name, int len, ccval_t v)
@@ -833,7 +833,7 @@ static BOOL new_cc_var(cc_ctx_t *cc, const WCHAR *name, int len, ccval_t v)
     if(len == -1)
         len = lstrlenW(name);
 
-    new_v = heap_alloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR));
+    new_v = malloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR));
     if(!new_v)
         return FALSE;
 
@@ -864,7 +864,7 @@ static BOOL init_cc(parser_ctx_t *ctx)
     if(ctx->script->cc)
         return TRUE;
 
-    cc = heap_alloc(sizeof(cc_ctx_t));
+    cc = malloc(sizeof(cc_ctx_t));
     if(!cc) {
         lex_error(ctx, E_OUTOFMEMORY);
         return FALSE;
@@ -909,7 +909,7 @@ int try_parse_ccval(parser_ctx_t *ctx, ccval_t *r)
     if(!skip_spaces(ctx))
         return -1;
 
-    if(iswdigit(*ctx->ptr)) {
+    if(is_digit(*ctx->ptr)) {
         double n;
 
         if(!parse_numeric_literal(ctx, &n))
@@ -1099,14 +1099,14 @@ static int cc_token(parser_ctx_t *ctx, void *lval)
     return tBooleanLiteral;
 }
 
-int parser_lex(void *lval, parser_ctx_t *ctx)
+int parser_lex(void *lval, unsigned *loc, parser_ctx_t *ctx)
 {
     int ret;
 
     ctx->nl = ctx->ptr == ctx->begin;
 
     do {
-        ret = next_token(ctx, lval);
+        ret = next_token(ctx, loc, lval);
     } while(ret == '@' && !(ret = cc_token(ctx, lval)));
 
     return ret;
@@ -1118,7 +1118,6 @@ literal_t *parse_regexp(parser_ctx_t *ctx)
     BOOL in_class = FALSE;
     DWORD re_len, flags;
     literal_t *ret;
-    HRESULT hres;
 
     TRACE("\n");
 
@@ -1147,6 +1146,7 @@ literal_t *parse_regexp(parser_ctx_t *ctx)
 
     if(ctx->ptr == ctx->end || *ctx->ptr != '/') {
         WARN("pre-parsing failed\n");
+        ctx->hres = JS_E_SYNTAX;
         return NULL;
     }
 
@@ -1156,8 +1156,8 @@ literal_t *parse_regexp(parser_ctx_t *ctx)
     while(ctx->ptr < ctx->end && iswalnum(*ctx->ptr))
         ctx->ptr++;
 
-    hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
-    if(FAILED(hres))
+    ctx->hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
+    if(FAILED(ctx->hres))
         return NULL;
 
     ret = parser_alloc(ctx, sizeof(literal_t));

dll/win32/jscript/math.c

@@ -18,6 +18,7 @@
  */
 
 #ifdef __REACTOS__
+#define _USE_MATH_DEFINES
 #include <wine/config.h>
 #include <wine/port.h>
 #endif
@@ -32,35 +33,8 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static const WCHAR EW[] = {'E',0};
-static const WCHAR LOG2EW[] = {'L','O','G','2','E',0};
-static const WCHAR LOG10EW[] = {'L','O','G','1','0','E',0};
-static const WCHAR LN2W[] = {'L','N','2',0};
-static const WCHAR LN10W[] = {'L','N','1','0',0};
-static const WCHAR PIW[] = {'P','I',0};
-static const WCHAR SQRT2W[] = {'S','Q','R','T','2',0};
-static const WCHAR SQRT1_2W[] = {'S','Q','R','T','1','_','2',0};
-static const WCHAR absW[] = {'a','b','s',0};
-static const WCHAR acosW[] = {'a','c','o','s',0};
-static const WCHAR asinW[] = {'a','s','i','n',0};
-static const WCHAR atanW[] = {'a','t','a','n',0};
-static const WCHAR atan2W[] = {'a','t','a','n','2',0};
-static const WCHAR ceilW[] = {'c','e','i','l',0};
-static const WCHAR cosW[] = {'c','o','s',0};
-static const WCHAR expW[] = {'e','x','p',0};
-static const WCHAR floorW[] = {'f','l','o','o','r',0};
-static const WCHAR logW[] = {'l','o','g',0};
-static const WCHAR maxW[] = {'m','a','x',0};
-static const WCHAR minW[] = {'m','i','n',0};
-static const WCHAR powW[] = {'p','o','w',0};
-static const WCHAR randomW[] = {'r','a','n','d','o','m',0};
-static const WCHAR roundW[] = {'r','o','u','n','d',0};
-static const WCHAR sinW[] = {'s','i','n',0};
-static const WCHAR sqrtW[] = {'s','q','r','t',0};
-static const WCHAR tanW[] = {'t','a','n',0};
-
 /* ECMA-262 3rd Edition    15.8.2.12 */
-static HRESULT Math_abs(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_abs(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double d;
@@ -83,7 +57,7 @@ static HRESULT Math_abs(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
     return S_OK;
 }
 
-static HRESULT Math_acos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_acos(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -106,7 +80,7 @@ static HRESULT Math_acos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigne
     return S_OK;
 }
 
-static HRESULT Math_asin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_asin(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -129,7 +103,7 @@ static HRESULT Math_asin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigne
     return S_OK;
 }
 
-static HRESULT Math_atan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_atan(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -152,7 +126,7 @@ static HRESULT Math_atan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigne
     return S_OK;
 }
 
-static HRESULT Math_atan2(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_atan2(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x, y;
@@ -180,7 +154,7 @@ static HRESULT Math_atan2(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsign
 }
 
 /* ECMA-262 3rd Edition    15.8.2.6 */
-static HRESULT Math_ceil(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_ceil(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -203,7 +177,7 @@ static HRESULT Math_ceil(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigne
     return S_OK;
 }
 
-static HRESULT Math_cos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_cos(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -226,7 +200,7 @@ static HRESULT Math_cos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
     return S_OK;
 }
 
-static HRESULT Math_exp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_exp(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -249,7 +223,7 @@ static HRESULT Math_exp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
     return S_OK;
 }
 
-static HRESULT Math_floor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_floor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -272,7 +246,7 @@ static HRESULT Math_floor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsign
     return S_OK;
 }
 
-static HRESULT Math_log(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_log(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -296,7 +270,7 @@ static HRESULT Math_log(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
 }
 
 /* ECMA-262 3rd Edition    15.8.2.11 */
-static HRESULT Math_max(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_max(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     DOUBLE max, d;
@@ -330,7 +304,7 @@ static HRESULT Math_max(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
 }
 
 /* ECMA-262 3rd Edition    15.8.2.12 */
-static HRESULT Math_min(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_min(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     DOUBLE min, d;
@@ -364,7 +338,7 @@ static HRESULT Math_min(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
 }
 
 /* ECMA-262 3rd Edition    15.8.2.13 */
-static HRESULT Math_pow(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_pow(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x, y;
@@ -392,7 +366,7 @@ static HRESULT Math_pow(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
 }
 
 /* ECMA-262 3rd Edition    15.8.2.14 */
-static HRESULT Math_random(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_random(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     UINT x;
@@ -408,7 +382,7 @@ static HRESULT Math_random(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
 }
 
 /* ECMA-262 3rd Edition    15.8.2.15 */
-static HRESULT Math_round(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_round(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -431,7 +405,7 @@ static HRESULT Math_round(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsign
     return S_OK;
 }
 
-static HRESULT Math_sin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_sin(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -454,7 +428,7 @@ static HRESULT Math_sin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
     return S_OK;
 }
 
-static HRESULT Math_sqrt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_sqrt(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -477,7 +451,7 @@ static HRESULT Math_sqrt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigne
     return S_OK;
 }
 
-static HRESULT Math_tan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Math_tan(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double x;
@@ -501,33 +475,29 @@ static HRESULT Math_tan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned
 }
 
 static const builtin_prop_t Math_props[] = {
-    {absW,      Math_abs,      PROPF_METHOD|1},
-    {acosW,     Math_acos,     PROPF_METHOD|1},
-    {asinW,     Math_asin,     PROPF_METHOD|1},
-    {atanW,     Math_atan,     PROPF_METHOD|1},
-    {atan2W,    Math_atan2,    PROPF_METHOD|2},
-    {ceilW,     Math_ceil,     PROPF_METHOD|1},
-    {cosW,      Math_cos,      PROPF_METHOD|1},
-    {expW,      Math_exp,      PROPF_METHOD|1},
-    {floorW,    Math_floor,    PROPF_METHOD|1},
-    {logW,      Math_log,      PROPF_METHOD|1},
-    {maxW,      Math_max,      PROPF_METHOD|2},
-    {minW,      Math_min,      PROPF_METHOD|2},
-    {powW,      Math_pow,      PROPF_METHOD|2},
-    {randomW,   Math_random,   PROPF_METHOD},
-    {roundW,    Math_round,    PROPF_METHOD|1},
-    {sinW,      Math_sin,      PROPF_METHOD|1},
-    {sqrtW,     Math_sqrt,     PROPF_METHOD|1},
-    {tanW,      Math_tan,      PROPF_METHOD|1}
+    {L"abs",      Math_abs,      PROPF_METHOD|1},
+    {L"acos",     Math_acos,     PROPF_METHOD|1},
+    {L"asin",     Math_asin,     PROPF_METHOD|1},
+    {L"atan",     Math_atan,     PROPF_METHOD|1},
+    {L"atan2",    Math_atan2,    PROPF_METHOD|2},
+    {L"ceil",     Math_ceil,     PROPF_METHOD|1},
+    {L"cos",      Math_cos,      PROPF_METHOD|1},
+    {L"exp",      Math_exp,      PROPF_METHOD|1},
+    {L"floor",    Math_floor,    PROPF_METHOD|1},
+    {L"log",      Math_log,      PROPF_METHOD|1},
+    {L"max",      Math_max,      PROPF_METHOD|2},
+    {L"min",      Math_min,      PROPF_METHOD|2},
+    {L"pow",      Math_pow,      PROPF_METHOD|2},
+    {L"random",   Math_random,   PROPF_METHOD},
+    {L"round",    Math_round,    PROPF_METHOD|1},
+    {L"sin",      Math_sin,      PROPF_METHOD|1},
+    {L"sqrt",     Math_sqrt,     PROPF_METHOD|1},
+    {L"tan",      Math_tan,      PROPF_METHOD|1}
 };
 
 static const builtin_info_t Math_info = {
-    JSCLASS_MATH,
-    {NULL, NULL, 0},
-    ARRAY_SIZE(Math_props),
-    Math_props,
-    NULL,
-    NULL
+    .class = JSCLASS_MATH,    .props_cnt = ARRAY_SIZE(Math_props),
+    .props = Math_props,
 };
 
 HRESULT create_math(script_ctx_t *ctx, jsdisp_t **ret)
@@ -540,23 +510,23 @@ HRESULT create_math(script_ctx_t *ctx, jsdisp_t **ret)
         const WCHAR *name;
         DOUBLE val;
     }constants[] = {
-        {EW,        M_E},        /* ECMA-262 3rd Edition    15.8.1.1 */
-        {LN10W,     M_LN10},     /* ECMA-262 3rd Edition    15.8.1.2 */
-        {LN2W,      M_LN2},      /* ECMA-262 3rd Edition    15.8.1.3 */
-        {LOG2EW,    M_LOG2E},    /* ECMA-262 3rd Edition    15.8.1.4 */
-        {LOG10EW,   M_LOG10E},   /* ECMA-262 3rd Edition    15.8.1.5 */
-        {PIW,       M_PI},       /* ECMA-262 3rd Edition    15.8.1.6 */
-        {SQRT1_2W,  M_SQRT1_2},  /* ECMA-262 3rd Edition    15.8.1.7 */
-        {SQRT2W,    M_SQRT2},    /* ECMA-262 3rd Edition    15.8.1.8 */
+        {L"E",        M_E},        /* ECMA-262 3rd Edition    15.8.1.1 */
+        {L"LN10",     M_LN10},     /* ECMA-262 3rd Edition    15.8.1.2 */
+        {L"LN2",      M_LN2},      /* ECMA-262 3rd Edition    15.8.1.3 */
+        {L"LOG2E",    M_LOG2E},    /* ECMA-262 3rd Edition    15.8.1.4 */
+        {L"LOG10E",   M_LOG10E},   /* ECMA-262 3rd Edition    15.8.1.5 */
+        {L"PI",       M_PI},       /* ECMA-262 3rd Edition    15.8.1.6 */
+        {L"SQRT1_2",  M_SQRT1_2},  /* ECMA-262 3rd Edition    15.8.1.7 */
+        {L"SQRT2",    M_SQRT2},    /* ECMA-262 3rd Edition    15.8.1.8 */
     };
 
-    math = heap_alloc_zero(sizeof(jsdisp_t));
+    math = calloc(1, sizeof(jsdisp_t));
     if(!math)
         return E_OUTOFMEMORY;
 
     hres = init_dispex_from_constr(math, ctx, &Math_info, ctx->object_constr);
     if(FAILED(hres)) {
-        heap_free(math);
+        free(math);
         return hres;
     }
 

dll/win32/jscript/number.c

@@ -16,7 +16,13 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
+
 #include <math.h>
+#include <locale.h>
 #include <assert.h>
 
 #include "jscript.h"
@@ -31,13 +37,6 @@ typedef struct {
     double value;
 } NumberInstance;
 
-static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
-static const WCHAR toFixedW[] = {'t','o','F','i','x','e','d',0};
-static const WCHAR toExponentialW[] = {'t','o','E','x','p','o','n','e','n','t','i','a','l',0};
-static const WCHAR toPrecisionW[] = {'t','o','P','r','e','c','i','s','i','o','n',0};
-static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
-
 #define NUMBER_TOSTRING_BUF_SIZE 64
 #define NUMBER_DTOA_SIZE 18
 
@@ -46,14 +45,16 @@ static inline NumberInstance *number_from_jsdisp(jsdisp_t *jsdisp)
     return CONTAINING_RECORD(jsdisp, NumberInstance, dispex);
 }
 
-static inline NumberInstance *number_from_vdisp(vdisp_t *vdisp)
+static inline HRESULT numberval_this(jsval_t vthis, DOUBLE *ret)
 {
-    return number_from_jsdisp(vdisp->u.jsdisp);
-}
-
-static inline NumberInstance *number_this(vdisp_t *jsthis)
-{
-    return is_vclass(jsthis, JSCLASS_NUMBER) ? number_from_vdisp(jsthis) : NULL;
+    jsdisp_t *jsdisp;
+    if(is_number(vthis))
+        *ret = get_number(vthis);
+    else if(is_object_instance(vthis) && (jsdisp = to_jsdisp(get_object(vthis))) && is_class(jsdisp, JSCLASS_NUMBER))
+        *ret = number_from_jsdisp(jsdisp)->value;
+    else
+        return JS_E_NUMBER_EXPECTED;
+    return S_OK;
 }
 
 static inline void number_to_str(double d, WCHAR *buf, int size, int *dec_point)
@@ -229,10 +230,9 @@ static inline jsstr_t *number_to_exponential(double val, int prec)
 }
 
 /* ECMA-262 3rd Edition    15.7.4.2 */
-static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Number_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    NumberInstance *number;
     INT radix = 10;
     DOUBLE val;
     jsstr_t *str;
@@ -240,21 +240,20 @@ static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
 
     TRACE("\n");
 
-    if(!(number = number_this(jsthis)))
-        return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL);
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres))
+        return hres;
 
-    if(argc) {
+    if(argc && (ctx->version < SCRIPTLANGUAGEVERSION_ES5 || !is_undefined(argv[0]))) {
         hres = to_int32(ctx, argv[0], &radix);
         if(FAILED(hres))
             return hres;
 
-        if(radix<2 || radix>36)
-            return throw_type_error(ctx, JS_E_INVALIDARG, NULL);
+        if(radix < 2 || radix > 36)
+            return JS_E_INVALIDARG;
     }
 
-    val = number->value;
-
-    if(radix==10 || !is_finite(val)) {
+    if(radix==10 || !isfinite(val)) {
         hres = to_string(ctx, jsval_number(val), &str);
         if(FAILED(hres))
             return hres;
@@ -324,7 +323,6 @@ static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
             if(log_radix==0)
                 buf[idx] = 0;
             else {
-                static const WCHAR formatW[] = {'(','e','%','c','%','d',')',0};
                 WCHAR ch;
 
                 if(log_radix<0) {
@@ -332,7 +330,7 @@ static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
                     ch = '-';
                 }
                 else ch = '+';
-                swprintf(&buf[idx], formatW, ch, (int)log_radix);
+                swprintf(&buf[idx], ARRAY_SIZE(buf) - idx, L"(e%c%d)", ch, (int)log_radix);
             }
         }
         else buf[idx] = '\0';
@@ -349,17 +347,104 @@ static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, u
     return S_OK;
 }
 
-static HRESULT Number_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
-        jsval_t *r)
+HRESULT localize_number(script_ctx_t *ctx, DOUBLE val, BOOL new_format, jsstr_t **ret)
 {
-    FIXME("\n");
-    return E_NOTIMPL;
+    WCHAR buf[316], decimal[8], thousands[8], *numstr;
+    NUMBERFMTW *format = NULL, format_buf;
+    LCID lcid = ctx->lcid;
+#ifndef __REACTOS__
+    _locale_t locale;
+#endif
+    unsigned convlen;
+    jsstr_t *str;
+    int len;
+
+    /* FIXME: Localize this */
+    if(!isfinite(val))
+        return to_string(ctx, jsval_number(val), ret);
+
+    /* Native never uses an exponent, even if the number is very large, it will in fact
+       return all the digits (with thousands separators). jscript.dll uses two digits for
+       fraction even if they are zero (likely default numDigits) and always returns them,
+       while mshtml's jscript uses 3 digits and trims trailing zeros (on same locale).
+       This is even for very small numbers, such as 0.0000999, which will simply be 0. */
+#ifdef __REACTOS__ /* FIXME: Inspect */
+    len = swprintf(buf, ARRAY_SIZE(buf), L"%.3f", val);
+#else
+    if(!(locale = _create_locale(LC_ALL, "C")))
+        return E_OUTOFMEMORY;
+    len = _swprintf_l(buf, ARRAY_SIZE(buf), L"%.3f", locale, val);
+    _free_locale(locale);
+#endif
+
+    if(new_format) {
+        WCHAR grouping[10];
+
+        format = &format_buf;
+        format->NumDigits = 3;
+        while(buf[--len] == '0')
+            format->NumDigits--;
+
+        /* same logic as VarFormatNumber */
+        grouping[2] = '\0';
+        if(!GetLocaleInfoW(lcid, LOCALE_SGROUPING, grouping, ARRAY_SIZE(grouping)))
+            format->Grouping = 3;
+        else
+            format->Grouping = (grouping[2] == '2' ? 32 : grouping[0] - '0');
+
+        if(!GetLocaleInfoW(lcid, LOCALE_ILZERO | LOCALE_RETURN_NUMBER, (WCHAR*)&format->LeadingZero, 2))
+            format->LeadingZero = 0;
+        if(!GetLocaleInfoW(lcid, LOCALE_INEGNUMBER | LOCALE_RETURN_NUMBER, (WCHAR*)&format->NegativeOrder, 2))
+            format->NegativeOrder = 1;
+        format->lpDecimalSep = decimal;
+        if(!GetLocaleInfoW(lcid, LOCALE_SDECIMAL, decimal, ARRAY_SIZE(decimal)))
+            wcscpy(decimal, L".");
+        format->lpThousandSep = thousands;
+        if(!GetLocaleInfoW(lcid, LOCALE_STHOUSAND, thousands, ARRAY_SIZE(thousands)))
+            wcscpy(thousands, L",");
+    }
+
+    if(!(convlen = GetNumberFormatW(lcid, 0, buf, format, NULL, 0)) ||
+       !(str = jsstr_alloc_buf(convlen - 1, &numstr)))
+        return E_OUTOFMEMORY;
+
+    if(!GetNumberFormatW(lcid, 0, buf, format, numstr, convlen)) {
+        jsstr_release(str);
+        return E_OUTOFMEMORY;
+    }
+
+    *ret = str;
+    return S_OK;
 }
 
-static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Number_toLocaleString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsstr_t *str;
+    HRESULT hres;
+    DOUBLE val;
+
+    TRACE("\n");
+
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres)) {
+        if(hres == JS_E_NUMBER_EXPECTED && ctx->version >= SCRIPTLANGUAGEVERSION_ES5)
+            return throw_error(ctx, JS_E_WRONG_THIS, L"Number");
+        return hres;
+    }
+
+    if(r) {
+        hres = localize_number(ctx, val, ctx->version >= SCRIPTLANGUAGEVERSION_ES5, &str);
+        if(FAILED(hres))
+            return hres;
+        *r = jsval_string(str);
+    }
+    return S_OK;
+}
+
+static HRESULT Number_toFixed(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    NumberInstance *number;
     DOUBLE val;
     INT prec = 0;
     jsstr_t *str;
@@ -367,20 +452,20 @@ static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
 
     TRACE("\n");
 
-    if(!(number = number_this(jsthis)))
-        return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL);
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres))
+        return hres;
 
     if(argc) {
         hres = to_int32(ctx, argv[0], &prec);
         if(FAILED(hres))
             return hres;
 
-        if(prec<0 || prec>20)
-            return throw_range_error(ctx, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
+        if(prec < 0 || prec > 20)
+            return JS_E_FRACTION_DIGITS_OUT_OF_RANGE;
     }
 
-    val = number->value;
-    if(!is_finite(val)) {
+    if(!isfinite(val)) {
         hres = to_string(ctx, jsval_number(val), &str);
         if(FAILED(hres))
             return hres;
@@ -397,10 +482,9 @@ static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
     return S_OK;
 }
 
-static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Number_toExponential(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    NumberInstance *number;
     DOUBLE val;
     INT prec = 0;
     jsstr_t *str;
@@ -408,20 +492,20 @@ static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
 
     TRACE("\n");
 
-    if(!(number = number_this(jsthis)))
-        return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL);
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres))
+        return hres;
 
     if(argc) {
         hres = to_int32(ctx, argv[0], &prec);
         if(FAILED(hres))
             return hres;
 
-        if(prec<0 || prec>20)
-            return throw_range_error(ctx, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
+        if(prec < 0 || prec > 20)
+            return JS_E_FRACTION_DIGITS_OUT_OF_RANGE;
     }
 
-    val = number->value;
-    if(!is_finite(val)) {
+    if(!isfinite(val)) {
         hres = to_string(ctx, jsval_number(val), &str);
         if(FAILED(hres))
             return hres;
@@ -440,29 +524,28 @@ static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD fla
     return S_OK;
 }
 
-static HRESULT Number_toPrecision(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Number_toPrecision(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    NumberInstance *number;
     INT prec = 0, size;
     jsstr_t *str;
     DOUBLE val;
     HRESULT hres;
 
-    if(!(number = number_this(jsthis)))
-        return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL);
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres))
+        return hres;
 
-    if(argc) {
+    if(argc && (ctx->version < 2 || !is_undefined(argv[0]))) {
         hres = to_int32(ctx, argv[0], &prec);
         if(FAILED(hres))
             return hres;
 
         if(prec<1 || prec>21)
-            return throw_range_error(ctx, JS_E_PRECISION_OUT_OF_RANGE, NULL);
+            return JS_E_PRECISION_OUT_OF_RANGE;
     }
 
-    val = number->value;
-    if(!is_finite(val) || !prec) {
+    if(!isfinite(val) || !prec) {
         hres = to_string(ctx, jsval_number(val), &str);
         if(FAILED(hres))
             return hres;
@@ -487,58 +570,43 @@ static HRESULT Number_toPrecision(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     return S_OK;
 }
 
-static HRESULT Number_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT Number_valueOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    NumberInstance *number;
+    HRESULT hres;
+    DOUBLE val;
 
     TRACE("\n");
 
-    if(!(number = number_this(jsthis)))
-        return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL);
+    hres = numberval_this(vthis, &val);
+    if(FAILED(hres))
+        return hres;
 
     if(r)
-        *r = jsval_number(number->value);
-    return S_OK;
-}
-
-static HRESULT Number_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
-{
-    NumberInstance *number = number_from_jsdisp(jsthis);
-
-    TRACE("(%p)\n", number);
-
-    *r = jsval_number(number->value);
+        *r = jsval_number(val);
     return S_OK;
 }
 
 static const builtin_prop_t Number_props[] = {
-    {toExponentialW,         Number_toExponential,         PROPF_METHOD|1},
-    {toFixedW,               Number_toFixed,               PROPF_METHOD},
-    {toLocaleStringW,        Number_toLocaleString,        PROPF_METHOD},
-    {toPrecisionW,           Number_toPrecision,           PROPF_METHOD|1},
-    {toStringW,              Number_toString,              PROPF_METHOD|1},
-    {valueOfW,               Number_valueOf,               PROPF_METHOD}
+    {L"toExponential",       Number_toExponential,         PROPF_METHOD|1},
+    {L"toFixed",             Number_toFixed,               PROPF_METHOD},
+    {L"toLocaleString",      Number_toLocaleString,        PROPF_METHOD},
+    {L"toPrecision",         Number_toPrecision,           PROPF_METHOD|1},
+    {L"toString",            Number_toString,              PROPF_METHOD|1},
+    {L"valueOf",             Number_valueOf,               PROPF_METHOD}
 };
 
 static const builtin_info_t Number_info = {
-    JSCLASS_NUMBER,
-    {NULL, NULL,0, Number_get_value},
-    ARRAY_SIZE(Number_props),
-    Number_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_NUMBER,
+    .props_cnt = ARRAY_SIZE(Number_props),
+    .props     = Number_props,
 };
 
 static const builtin_info_t NumberInst_info = {
-    JSCLASS_NUMBER,
-    {NULL, NULL,0, Number_get_value},
-    0, NULL,
-    NULL,
-    NULL
+    .class = JSCLASS_NUMBER,
 };
 
-static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT NumberConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     double n;
@@ -573,11 +641,12 @@ static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
             n = 0;
         }
 
-        hres = create_number(ctx, n, &obj);
-        if(FAILED(hres))
-            return hres;
-
-        *r = jsval_obj(obj);
+        if(r) {
+            hres = create_number(ctx, n, &obj);
+            if(FAILED(hres))
+                return hres;
+            *r = jsval_obj(obj);
+        }
         break;
     }
     default:
@@ -593,7 +662,7 @@ static HRESULT alloc_number(script_ctx_t *ctx, jsdisp_t *object_prototype, Numbe
     NumberInstance *number;
     HRESULT hres;
 
-    number = heap_alloc_zero(sizeof(NumberInstance));
+    number = calloc(1, sizeof(NumberInstance));
     if(!number)
         return E_OUTOFMEMORY;
 
@@ -602,7 +671,7 @@ static HRESULT alloc_number(script_ctx_t *ctx, jsdisp_t *object_prototype, Numbe
     else
         hres = init_dispex_from_constr(&number->dispex, ctx, &NumberInst_info, ctx->number_constr);
     if(FAILED(hres)) {
-        heap_free(number);
+        free(number);
         return hres;
     }
 
@@ -615,14 +684,12 @@ HRESULT create_number_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdi
     NumberInstance *number;
     HRESULT hres;
 
-    static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
-
     hres = alloc_number(ctx, object_prototype, &number);
     if(FAILED(hres))
         return hres;
 
     number->value = 0;
-    hres = create_builtin_constructor(ctx, NumberConstr_value, NumberW, NULL,
+    hres = create_builtin_constructor(ctx, NumberConstr_value, L"Number", NULL,
             PROPF_CONSTR|1, &number->dispex, ret);
 
     jsdisp_release(&number->dispex);

dll/win32/jscript/parser.h

@@ -18,10 +18,11 @@
 
 #pragma once
 
-typedef struct _source_elements_t source_elements_t;
 typedef struct _expression_t expression_t;
 typedef struct _statement_t statement_t;
 
+struct _bytecode_t;
+
 typedef struct {
     BOOL is_num;
     union {
@@ -37,12 +38,13 @@ typedef struct _parser_ctx_t {
 
     script_ctx_t *script;
     struct _compiler_ctx_t *compiler;
-    source_elements_t *source;
+    statement_t *source;
     BOOL nl;
     BOOL implicit_nl_semicolon;
     BOOL is_html;
     BOOL lexer_error;
     HRESULT hres;
+    unsigned error_loc;
 
     ccval_t ccval;
     unsigned cc_if_depth;
@@ -50,10 +52,10 @@ typedef struct _parser_ctx_t {
     heap_pool_t heap;
 } parser_ctx_t;
 
-HRESULT script_parse(script_ctx_t*,struct _compiler_ctx_t*,const WCHAR*,const WCHAR*,BOOL,parser_ctx_t**) DECLSPEC_HIDDEN;
-void parser_release(parser_ctx_t*) DECLSPEC_HIDDEN;
+HRESULT script_parse(script_ctx_t*,struct _compiler_ctx_t*,struct _bytecode_t*,const WCHAR*,BOOL,parser_ctx_t**);
+void parser_release(parser_ctx_t*);
 
-int parser_lex(void*,parser_ctx_t*) DECLSPEC_HIDDEN;
+int parser_lex(void*,unsigned*,parser_ctx_t*);
 
 static inline void *parser_alloc(parser_ctx_t *ctx, DWORD size)
 {
@@ -65,9 +67,10 @@ static inline void *parser_alloc_tmp(parser_ctx_t *ctx, DWORD size)
     return heap_pool_alloc(&ctx->script->tmp_heap, size);
 }
 
-BOOL is_identifier_char(WCHAR) DECLSPEC_HIDDEN;
-BOOL unescape(WCHAR*,size_t*) DECLSPEC_HIDDEN;
-HRESULT parse_decimal(const WCHAR**,const WCHAR*,double*) DECLSPEC_HIDDEN;
+int hex_to_int(WCHAR);
+BOOL is_identifier_char(WCHAR);
+BOOL unescape(WCHAR*,size_t*);
+HRESULT parse_decimal(const WCHAR**,const WCHAR*,double*);
 
 typedef enum {
     LT_DOUBLE,
@@ -90,11 +93,12 @@ typedef struct {
     } u;
 } literal_t;
 
-literal_t *parse_regexp(parser_ctx_t*) DECLSPEC_HIDDEN;
-literal_t *new_boolean_literal(parser_ctx_t*,BOOL) DECLSPEC_HIDDEN;
+literal_t *parse_regexp(parser_ctx_t*);
+literal_t *new_boolean_literal(parser_ctx_t*,BOOL);
 
 typedef struct _variable_declaration_t {
     const WCHAR *identifier;
+    BOOL block_scope, constant;
     expression_t *expr;
 
     struct _variable_declaration_t *next;
@@ -123,10 +127,12 @@ typedef enum {
 struct _statement_t {
     statement_type_t type;
     statement_t *next;
+    unsigned loc;
 };
 
 typedef struct {
     statement_t stat;
+    unsigned int scope_index;
     statement_t *stat_list;
 } block_statement_t;
 
@@ -159,8 +165,11 @@ typedef struct {
     variable_declaration_t *variable_list;
     expression_t *begin_expr;
     expression_t *expr;
+    unsigned expr_loc;
     expression_t *end_expr;
+    unsigned end_loc;
     statement_t *statement;
+    unsigned int scope_index;
 } for_statement_t;
 
 typedef struct {
@@ -190,6 +199,7 @@ typedef struct {
 
 typedef struct _case_clausule_t {
     expression_t *expr;
+    unsigned loc;
     statement_t *stat;
 
     struct _case_clausule_t *next;
@@ -211,6 +221,7 @@ typedef struct {
     statement_t *try_statement;
     catch_block_t *catch_block;
     statement_t *finally_statement;
+    unsigned finally_loc;
 } try_statement_t;
 
 typedef enum {
@@ -283,20 +294,17 @@ typedef struct _parameter_t {
     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;
     const WCHAR *event_target;
     parameter_t *parameter_list;
-    source_elements_t *source_elements;
+    statement_t *statement_list;
     const WCHAR *src_str;
     DWORD src_len;
     unsigned func_id;
+    BOOL is_statement;
+    unsigned int scope_index;
 
     struct _function_expression_t *next; /* for compiler */
 } function_expression_t;
@@ -373,8 +381,8 @@ typedef struct {
     property_definition_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;
+BOOL try_parse_ccval(parser_ctx_t*,ccval_t*);
+BOOL parse_cc_expr(parser_ctx_t*);
 
 static inline ccval_t ccval_num(double n)
 {
@@ -402,4 +410,4 @@ static inline double get_ccnum(ccval_t v)
     return v.is_num ? v.u.n : v.u.b;
 }
 
-jsstr_t *compiler_alloc_string_len(struct _compiler_ctx_t*,const WCHAR *,unsigned) DECLSPEC_HIDDEN;
+jsstr_t *compiler_alloc_string_len(struct _compiler_ctx_t*,const WCHAR *,unsigned);

dll/win32/jscript/parser.y

@@ -26,16 +26,10 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static int parser_error(parser_ctx_t*,const char*);
-static void set_error(parser_ctx_t*,UINT);
+static int parser_error(unsigned*,parser_ctx_t*,const char*);
+static void set_error(parser_ctx_t*,unsigned,HRESULT);
 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR);
 static BOOL allow_auto_semicolon(parser_ctx_t*);
-static void program_parsed(parser_ctx_t*,source_elements_t*);
-
-typedef struct _statement_list_t {
-    statement_t *head;
-    statement_t *tail;
-} statement_list_t;
 
 static literal_t *new_string_literal(parser_ctx_t*,jsstr_t*);
 static literal_t *new_null_literal(parser_ctx_t*);
@@ -71,8 +65,13 @@ typedef struct _case_list_t {
     case_clausule_t *tail;
 } case_list_t;
 
+typedef struct _statement_list_t {
+   statement_t *head;
+   statement_t *tail;
+} statement_list_t;
+
 static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*);
-static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*);
+static case_clausule_t *new_case_clausule(parser_ctx_t*,unsigned,expression_t*,statement_list_t*);
 static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*);
 static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*);
 static case_clausule_t *new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*);
@@ -86,28 +85,23 @@ static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const WCHA
 static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*);
 static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*);
 
-static void *new_statement(parser_ctx_t*,statement_type_t,size_t);
-static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*);
-static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*);
-static statement_t *new_expression_statement(parser_ctx_t*,expression_t*);
-static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*);
-static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*);
-static statement_t *new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*,
-        expression_t*,statement_t*);
-static statement_t *new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
-static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*);
-static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*);
-static statement_t *new_return_statement(parser_ctx_t*,expression_t*);
-static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*);
-static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*);
-static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
-static statement_t *new_throw_statement(parser_ctx_t*,expression_t*);
-static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*);
-
-struct statement_list_t {
-   statement_t *head;
-   statement_t *tail;
-};
+static void *new_statement(parser_ctx_t*,statement_type_t,size_t,unsigned);
+static statement_t *new_block_statement(parser_ctx_t*,unsigned,statement_list_t*);
+static statement_t *new_var_statement(parser_ctx_t*,BOOL,BOOL,unsigned,variable_list_t*);
+static statement_t *new_expression_statement(parser_ctx_t*,unsigned,expression_t*);
+static statement_t *new_if_statement(parser_ctx_t*,unsigned,expression_t*,statement_t*,statement_t*);
+static statement_t *new_while_statement(parser_ctx_t*,unsigned,BOOL,expression_t*,statement_t*);
+static statement_t *new_for_statement(parser_ctx_t*,unsigned,variable_declaration_t*,expression_t*,expression_t*,unsigned,
+                                      expression_t*,unsigned,statement_t*);
+static statement_t *new_forin_statement(parser_ctx_t*,unsigned,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
+static statement_t *new_continue_statement(parser_ctx_t*,unsigned,const WCHAR*);
+static statement_t *new_break_statement(parser_ctx_t*,unsigned,const WCHAR*);
+static statement_t *new_return_statement(parser_ctx_t*,unsigned,expression_t*);
+static statement_t *new_with_statement(parser_ctx_t*,unsigned,expression_t*,statement_t*);
+static statement_t *new_labelled_statement(parser_ctx_t*,unsigned,const WCHAR*,statement_t*);
+static statement_t *new_switch_statement(parser_ctx_t*,unsigned,expression_t*,case_clausule_t*);
+static statement_t *new_throw_statement(parser_ctx_t*,unsigned,expression_t*);
+static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*,unsigned);
 
 static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*);
 static statement_list_t *statement_list_add(statement_list_t*,statement_t*);
@@ -122,7 +116,7 @@ static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,cons
 
 static void *new_expression(parser_ctx_t *ctx,expression_type_t,size_t);
 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*,
-        source_elements_t*,const WCHAR*,const WCHAR*,DWORD);
+        statement_list_t*,const WCHAR*,const WCHAR*,DWORD);
 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*);
@@ -134,19 +128,19 @@ static expression_t *new_literal_expression(parser_ctx_t*,literal_t*);
 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int);
 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*);
 
-static source_elements_t *new_source_elements(parser_ctx_t*);
-static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*);
+#define PARSER_LTYPE unsigned
+#define YYLLOC_DEFAULT(Cur, Rhs, N) Cur = YYRHSLOC((Rhs), (N) ? 1 : 0)
 
 %}
 
 %lex-param { parser_ctx_t *ctx }
 %parse-param { parser_ctx_t *ctx }
+%define api.prefix {parser_}
 %define api.pure
-%start Program
+%start Script
 
 %union {
     int                     ival;
-    const WCHAR             *srcptr;
     jsstr_t                 *str;
     literal_t               *literal;
     struct _argument_list_t *argument_list;
@@ -159,7 +153,6 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state
     struct _parameter_list_t *parameter_list;
     struct _property_list_t *property_list;
     property_definition_t   *property_definition;
-    source_elements_t       *source_elements;
     statement_t             *statement;
     struct _statement_list_t *statement_list;
     struct _variable_list_t *variable_list;
@@ -167,23 +160,25 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state
 }
 
 /* keywords */
-%token <identifier> kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kFUNCTION kIF kFINALLY kFOR kGET kIN kSET
-%token <identifier> kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH
+%token <identifier> kBREAK kCASE kCATCH kCONST kCONTINUE kDEFAULT kDELETE kDO kELSE kFUNCTION kIF kFINALLY kFOR
+%token <identifier> kGET kIN kLET kSET kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE
+%token <identifier> kTRY kTYPEOF kVAR kVOID kWHILE kWITH
 %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ kDCOL
 
-%token <srcptr> '}'
-
 /* tokens */
 %token <identifier> tIdentifier
 %token <ival> tAssignOper tEqOper tShiftOper tRelOper
 %token <literal> tNumericLiteral tBooleanLiteral
 %token <str> tStringLiteral
-%token tEOF
 
-%type <source_elements> SourceElements
-%type <source_elements> FunctionBody
+%type <statement_list> FunctionBody
+%type <statement_list> ScriptBody
+%type <statement_list> FunctionStatementList
 %type <statement> Statement
+%type <statement> Declaration
 %type <statement> Block
+%type <statement> LexicalDeclaration
+%type <statement> LexicalDeclarationNoIn
 %type <statement> VariableStatement
 %type <statement> EmptyStatement
 %type <statement> ExpressionStatement
@@ -198,6 +193,7 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state
 %type <statement> ThrowStatement
 %type <statement> TryStatement
 %type <statement> Finally
+%type <statement> StatementListItem
 %type <statement_list> StatementList StatementList_opt
 %type <parameter_list> FormalParameterList FormalParameterList_opt
 %type <expr> Expression Expression_opt Expression_err
@@ -225,7 +221,7 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state
 %type <expr> MemberExpression
 %type <expr> PrimaryExpression
 %type <expr> GetterSetterMethod
-%type <identifier> Identifier_opt
+%type <identifier> Identifier Identifier_opt
 %type <variable_list> VariableDeclarationList
 %type <variable_list> VariableDeclarationListNoIn
 %type <variable_declaration> VariableDeclaration
@@ -244,50 +240,49 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state
 %type <property_definition> PropertyDefinition
 %type <literal> PropertyName
 %type <literal> BooleanLiteral
-%type <srcptr> KFunction left_bracket
 %type <ival> AssignOper
-%type <identifier> IdentifierName ReservedAsIdentifier
+%type <identifier> IdentifierName ReservedAsIdentifier ES5Keyword
 
 %nonassoc LOWER_THAN_ELSE
-%nonassoc kELSE
+%nonassoc kELSE kIN kINSTANCEOF ':'
+%nonassoc kGET kLET kSET
 
 %%
 
-/* ECMA-262 3rd Edition    14 */
-Program
-       : SourceElements HtmlComment tEOF
-                                { program_parsed(ctx, $1); }
+/* ECMA-262 10th Edition    15.1 */
+Script
+       : ScriptBody HtmlComment { ctx->source = $1 ? $1->head : NULL;
+                                  (void)parser_nerrs; /* avoid unused variable warning */ }
+
+/* ECMA-262 10th Edition    15.1 */
+ScriptBody
+        : StatementList_opt     { $$ = $1; }
 
 HtmlComment
-        : tHTMLCOMMENT          {}
-        | /* empty */           {}
+        : tHTMLCOMMENT
+        | /* empty */
 
-/* ECMA-262 3rd Edition    14 */
-SourceElements
-        : /* empty */           { $$ = new_source_elements(ctx); }
-        | SourceElements Statement
-                                { $$ = source_elements_add_statement($1, $2); }
+/* ECMA-262 10th Edition   14.1 */
+FunctionStatementList
+        : StatementList_opt     { $$ = $1; }
 
 /* ECMA-262 3rd Edition    13 */
 FunctionExpression
-        : KFunction left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
-                                { $$ = new_function_expression(ctx, NULL, $3, $6, NULL, $1, $7-$1+1); }
-        | KFunction tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
-                                { $$ = new_function_expression(ctx, $2, $4, $7, NULL, $1, $8-$1+1); }
-        | KFunction tIdentifier kDCOL tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
-                                { $$ = new_function_expression(ctx, $4, $6, $9, $2, $1, $10-$1+1); }
+        : kFUNCTION left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
+                                { $$ = new_function_expression(ctx, NULL, $3, $6, NULL, ctx->begin + @1, @7 - @1 + 1); }
+        | kFUNCTION Identifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
+                                { $$ = new_function_expression(ctx, $2, $4, $7, NULL, ctx->begin + @1, @8 - @1 + 1); }
+        | kFUNCTION Identifier kDCOL Identifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
+                                { $$ = new_function_expression(ctx, $4, $6, $9, $2, ctx->begin + @1, @10 - @1 + 1); }
 
-KFunction
-        : kFUNCTION             { $$ = ctx->ptr - 8; }
-
-/* ECMA-262 3rd Edition    13 */
+/* ECMA-262 10th Edition   14.1 */
 FunctionBody
-        : SourceElements        { $$ = $1; }
+        : FunctionStatementList { $$ = $1; }
 
 /* ECMA-262 3rd Edition    13 */
 FormalParameterList
-        : tIdentifier           { $$ = new_parameter_list(ctx, $1); }
-        | FormalParameterList ',' tIdentifier
+        : Identifier            { $$ = new_parameter_list(ctx, $1); }
+        | FormalParameterList ',' Identifier
                                 { $$ = parameter_list_add(ctx, $1, $3); }
 
 /* ECMA-262 3rd Edition    13 */
@@ -300,7 +295,7 @@ Statement
         : Block                 { $$ = $1; }
         | VariableStatement     { $$ = $1; }
         | EmptyStatement        { $$ = $1; }
-        | FunctionExpression    { $$ = new_expression_statement(ctx, $1); }
+        | FunctionExpression    { $$ = new_expression_statement(ctx, @$, $1); }
         | ExpressionStatement   { $$ = $1; }
         | IfStatement           { $$ = $1; }
         | IterationStatement    { $$ = $1; }
@@ -313,10 +308,19 @@ Statement
         | ThrowStatement        { $$ = $1; }
         | TryStatement          { $$ = $1; }
 
-/* ECMA-262 3rd Edition    12.2 */
+/* ECMA-262 10th Edition   13. TODO: HoistableDeclaration */
+Declaration
+        : LexicalDeclaration    { $$ = $1; }
+
+/* ECMA-262 10th Edition    13.2 */
+StatementListItem
+        : Statement             { $$ = $1; }
+        | Declaration           { $$ = $1; }
+
+/* ECMA-262 10th Edition    13.2 */
 StatementList
-        : Statement             { $$ = new_statement_list(ctx, $1); }
-        | StatementList Statement
+        : StatementListItem     { $$ = new_statement_list(ctx, $1); }
+        | StatementList StatementListItem
                                 { $$ = statement_list_add($1, $2); }
 
 /* ECMA-262 3rd Edition    12.2 */
@@ -326,13 +330,43 @@ StatementList_opt
 
 /* ECMA-262 3rd Edition    12.1 */
 Block
-        : '{' StatementList '}' { $$ = new_block_statement(ctx, $2); }
-        | '{' '}'               { $$ = new_block_statement(ctx, NULL); }
+        : '{' StatementList '}' { $$ = new_block_statement(ctx, @2, $2); }
+        | '{' '}'               { $$ = new_block_statement(ctx, @$, NULL); }
+
+/* ECMA-262 10th Edition   13.3.1, TODO:  BindingList*/
+LexicalDeclaration
+        : kLET VariableDeclarationList semicolon_opt
+                                { $$ = new_var_statement(ctx, TRUE, FALSE, @$, $2); }
+        | kCONST VariableDeclarationList semicolon_opt
+                                {
+                                    if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
+                                        WARN("const var declaration %s in legacy mode.\n",
+                                                debugstr_w($1));
+                                        set_error(ctx, @$, JS_E_SYNTAX);
+                                        YYABORT;
+                                    }
+                                    $$ = new_var_statement(ctx, TRUE, TRUE, @$, $2);
+                                }
+
+/* ECMA-262 10th Edition   13.3.1, TODO:  BindingList*/
+LexicalDeclarationNoIn
+        : kLET VariableDeclarationListNoIn semicolon_opt
+                                { $$ = new_var_statement(ctx, TRUE, FALSE, @$, $2); }
+        | kCONST VariableDeclarationListNoIn semicolon_opt
+                                {
+                                    if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
+                                        WARN("const var declaration %s in legacy mode.\n",
+                                                debugstr_w($1));
+                                        set_error(ctx, @$, JS_E_SYNTAX);
+                                        YYABORT;
+                                    }
+                                    $$ = new_var_statement(ctx, TRUE, TRUE, @$, $2);
+                                }
 
 /* ECMA-262 3rd Edition    12.2 */
 VariableStatement
         : kVAR VariableDeclarationList semicolon_opt
-                                { $$ = new_var_statement(ctx, $2); }
+                                { $$ = new_var_statement(ctx, FALSE, FALSE, @$, $2); }
 
 /* ECMA-262 3rd Edition    12.2 */
 VariableDeclarationList
@@ -349,12 +383,12 @@ VariableDeclarationListNoIn
 
 /* ECMA-262 3rd Edition    12.2 */
 VariableDeclaration
-        : tIdentifier Initialiser_opt
+        : Identifier Initialiser_opt
                                 { $$ = new_variable_declaration(ctx, $1, $2); }
 
 /* ECMA-262 3rd Edition    12.2 */
 VariableDeclarationNoIn
-        : tIdentifier InitialiserNoIn_opt
+        : Identifier InitialiserNoIn_opt
                                 { $$ = new_variable_declaration(ctx, $1, $2); }
 
 /* ECMA-262 3rd Edition    12.2 */
@@ -379,72 +413,87 @@ InitialiserNoIn
 
 /* ECMA-262 3rd Edition    12.3 */
 EmptyStatement
-        : ';'                   { $$ = new_statement(ctx, STAT_EMPTY, 0); }
+        : ';'                   { $$ = new_statement(ctx, STAT_EMPTY, 0, @$); }
 
 /* ECMA-262 3rd Edition    12.4 */
 ExpressionStatement
         : Expression semicolon_opt
-                                { $$ = new_expression_statement(ctx, $1); }
+                                { $$ = new_expression_statement(ctx, @$,  $1); }
 
 /* ECMA-262 3rd Edition    12.5 */
 IfStatement
         : kIF left_bracket Expression_err right_bracket Statement kELSE Statement
-                                { $$ = new_if_statement(ctx, $3, $5, $7); }
+                                { $$ = new_if_statement(ctx, @$, $3, $5, $7); }
         | kIF left_bracket Expression_err right_bracket Statement %prec LOWER_THAN_ELSE
-                                { $$ = new_if_statement(ctx, $3, $5, NULL); }
+                                { $$ = new_if_statement(ctx, @$, $3, $5, NULL); }
 
-/* ECMA-262 3rd Edition    12.6 */
+/* ECMA-262 10th Edition   13.7 */
 IterationStatement
         : kDO Statement kWHILE left_bracket Expression_err right_bracket semicolon_opt
-                                { $$ = new_while_statement(ctx, TRUE, $5, $2); }
+                                { $$ = new_while_statement(ctx, @3, TRUE, $5, $2); }
         | kWHILE left_bracket Expression_err right_bracket Statement
-                                { $$ = new_while_statement(ctx, FALSE, $3, $5); }
+                                { $$ = new_while_statement(ctx, @$, FALSE, $3, $5); }
         | kFOR left_bracket ExpressionNoIn_opt
                                 { if(!explicit_error(ctx, $3, ';')) YYABORT; }
-        semicolon  Expression_opt
+          semicolon  Expression_opt
                                 { if(!explicit_error(ctx, $6, ';')) YYABORT; }
-        semicolon Expression_opt right_bracket Statement
-                                { $$ = new_for_statement(ctx, NULL, $3, $6, $9, $11); }
+          semicolon Expression_opt right_bracket Statement
+                                { $$ = new_for_statement(ctx, @3, NULL, $3, $6, @6, $9, @9, $11); }
         | kFOR left_bracket kVAR VariableDeclarationListNoIn
                                 { if(!explicit_error(ctx, $4, ';')) YYABORT; }
-        semicolon Expression_opt
+          semicolon Expression_opt
                                 { if(!explicit_error(ctx, $7, ';')) YYABORT; }
-        semicolon Expression_opt right_bracket Statement
-                                { $$ = new_for_statement(ctx, $4, NULL, $7, $10, $12); }
+          semicolon Expression_opt right_bracket Statement
+                                { $$ = new_for_statement(ctx, @3, $4 ? $4->head : NULL, NULL, $7, @7, $10, @10, $12); }
         | kFOR left_bracket LeftHandSideExpression kIN Expression_err right_bracket Statement
-                                { $$ = new_forin_statement(ctx, NULL, $3, $5, $7); }
+                                { $$ = new_forin_statement(ctx, @$, NULL, $3, $5, $7); }
         | kFOR left_bracket kVAR VariableDeclarationNoIn kIN Expression_err right_bracket Statement
-                                { $$ = new_forin_statement(ctx, $4, NULL, $6, $8); }
+                                { $$ = new_forin_statement(ctx, @$,  $4, NULL, $6, $8); }
+        | kFOR left_bracket LexicalDeclarationNoIn
+                                { if(!explicit_error(ctx, $3, ';')) YYABORT; }
+          Expression_opt
+                                { if(!explicit_error(ctx, $5, ';')) YYABORT; }
+          semicolon Expression_opt right_bracket Statement
+                                { $$ = new_for_statement(ctx, @3, ((var_statement_t *)$3)->variable_list,
+                                  NULL, $5, @5, $8, @8, $10); }
 
 /* ECMA-262 3rd Edition    12.7 */
 ContinueStatement
         : kCONTINUE /* NONL */ Identifier_opt semicolon_opt
-                                { $$ = new_continue_statement(ctx, $2); }
+                                { $$ = new_continue_statement(ctx, @$, $2); }
 
 /* ECMA-262 3rd Edition    12.8 */
 BreakStatement
         : kBREAK /* NONL */ Identifier_opt semicolon_opt
-                                { $$ = new_break_statement(ctx, $2); }
+                                { $$ = new_break_statement(ctx, @$, $2); }
 
 /* ECMA-262 3rd Edition    12.9 */
 ReturnStatement
         : kRETURN /* NONL */ Expression_opt semicolon_opt
-                                { $$ = new_return_statement(ctx, $2); }
+                                { $$ = new_return_statement(ctx, @$, $2); }
 
 /* ECMA-262 3rd Edition    12.10 */
 WithStatement
         : kWITH left_bracket Expression right_bracket Statement
-                                { $$ = new_with_statement(ctx, $3, $5); }
+                                { $$ = new_with_statement(ctx, @$, $3, $5); }
 
 /* ECMA-262 3rd Edition    12.12 */
 LabelledStatement
         : tIdentifier ':' Statement
-                                { $$ = new_labelled_statement(ctx, $1, $3); }
+                                { $$ = new_labelled_statement(ctx, @$, $1, $3); }
+
+        /* We have to lay out the keywords explicitly instead of using Identifier, as otherwise bison's parser
+         * wouldn't be able to figure out whether to reduce the Identifier or shift the colon (following the
+         * label and thus treating it as a label). This happens because the parser has only one lookahead token
+         * that can be used to decide a shift/reduce and would introduce a conflict in this case... */
+        | kGET ':' Statement    { $$ = new_labelled_statement(ctx, @$, $1, $3); }
+        | kSET ':' Statement    { $$ = new_labelled_statement(ctx, @$, $1, $3); }
+        | kLET ':' Statement    { $$ = new_labelled_statement(ctx, @$, $1, $3); }
 
 /* ECMA-262 3rd Edition    12.11 */
 SwitchStatement
         : kSWITCH left_bracket Expression right_bracket CaseBlock
-                                { $$ = new_switch_statement(ctx, $3, $5); }
+                                { $$ = new_switch_statement(ctx, @$, $3, $5); }
 
 /* ECMA-262 3rd Edition    12.11 */
 CaseBlock
@@ -467,33 +516,33 @@ CaseClausules
 /* ECMA-262 3rd Edition    12.11 */
 CaseClausule
         : kCASE Expression ':' StatementList_opt
-                                 { $$ = new_case_clausule(ctx, $2, $4); }
+                                 { $$ = new_case_clausule(ctx, @$, $2, $4); }
 
 /* ECMA-262 3rd Edition    12.11 */
 DefaultClausule
         : kDEFAULT ':' StatementList_opt
-                                 { $$ = new_case_clausule(ctx, NULL, $3); }
+                                 { $$ = new_case_clausule(ctx, @$, NULL, $3); }
 
 /* ECMA-262 3rd Edition    12.13 */
 ThrowStatement
         : kTHROW /* NONL */ Expression semicolon_opt
-                                { $$ = new_throw_statement(ctx, $2); }
+                                { $$ = new_throw_statement(ctx, @$, $2); }
 
 /* ECMA-262 3rd Edition    12.14 */
 TryStatement
-        : kTRY Block Catch      { $$ = new_try_statement(ctx, $2, $3, NULL); }
-        | kTRY Block Finally    { $$ = new_try_statement(ctx, $2, NULL, $3); }
+        : kTRY Block Catch      { $$ = new_try_statement(ctx, $2, $3, NULL, 0); }
+        | kTRY Block Finally    { $$ = new_try_statement(ctx, $2, NULL, $3, @3); }
         | kTRY Block Catch Finally
-                                { $$ = new_try_statement(ctx, $2, $3, $4); }
+                                { $$ = new_try_statement(ctx, $2, $3, $4, @4); }
 
 /* ECMA-262 3rd Edition    12.14 */
 Catch
-        : kCATCH left_bracket tIdentifier right_bracket Block
+        : kCATCH left_bracket Identifier right_bracket Block
                                 { $$ = new_catch_block(ctx, $3, $5); }
 
 /* ECMA-262 3rd Edition    12.14 */
 Finally
-        : kFINALLY Block        { $$ = $2; }
+        : kFINALLY Block        { @$ = @2; $$ = $2; }
 
 /* ECMA-262 3rd Edition    11.14 */
 Expression_opt
@@ -502,7 +551,7 @@ Expression_opt
 
 Expression_err
         : Expression            { $$ = $1; }
-        | error                 { set_error(ctx, JS_E_SYNTAX); YYABORT; }
+        | error                 { set_error(ctx, @$, JS_E_SYNTAX); YYABORT; }
 
 /* ECMA-262 3rd Edition    11.14 */
 Expression
@@ -747,7 +796,11 @@ ArgumentList
 /* ECMA-262 3rd Edition    11.1 */
 PrimaryExpression
         : kTHIS                 { $$ = new_expression(ctx, EXPR_THIS, 0); }
+        /* We have to lay out the keywords explicitly instead of using Identifier, see LabelledStatement. */
         | tIdentifier           { $$ = new_identifier_expression(ctx, $1); }
+        | kGET                  { $$ = new_identifier_expression(ctx, $1); }
+        | kSET                  { $$ = new_identifier_expression(ctx, $1); }
+        | kLET                  { $$ = new_identifier_expression(ctx, $1); }
         | Literal               { $$ = new_literal_expression(ctx, $1); }
         | ArrayLiteral          { $$ = $1; }
         | ObjectLiteral         { $$ = $1; }
@@ -787,6 +840,7 @@ ObjectLiteral
         {
             if(ctx->script->version < 2) {
                 WARN("Trailing comma in object literal is illegal in legacy mode.\n");
+                set_error(ctx, @3, JS_E_SYNTAX);
                 YYABORT;
             }
             $$ = new_prop_and_value_expression(ctx, $2);
@@ -809,7 +863,7 @@ PropertyDefinition
 
 GetterSetterMethod
         : left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
-                                { $$ = new_function_expression(ctx, NULL, $2, $5, NULL, $1, $6-$1); }
+                                { $$ = new_function_expression(ctx, NULL, $2, $5, NULL, ctx->begin + @1, @6 - @1 + 1); }
 
 /* Ecma-262 3rd Edition    11.1.5 */
 PropertyName
@@ -820,7 +874,11 @@ PropertyName
 /* ECMA-262 3rd Edition    7.6 */
 Identifier_opt
         : /* empty*/            { $$ = NULL; }
-        | tIdentifier           { $$ = $1; }
+        | Identifier            { $$ = $1; }
+
+Identifier
+        : tIdentifier           { $$ = $1; }
+        | ES5Keyword            { $$ = $1; }
 
 /* ECMA-262 5.1 Edition    7.6 */
 IdentifierName
@@ -830,6 +888,7 @@ IdentifierName
             if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
                 WARN("%s keyword used as an identifier in legacy mode.\n",
                      debugstr_w($1));
+                set_error(ctx, @$, JS_E_SYNTAX);
                 YYABORT;
             }
             $$ = $1;
@@ -839,6 +898,7 @@ ReservedAsIdentifier
         : kBREAK                { $$ = $1; }
         | kCASE                 { $$ = $1; }
         | kCATCH                { $$ = $1; }
+        | kCONST                { $$ = $1; }
         | kCONTINUE             { $$ = $1; }
         | kDEFAULT              { $$ = $1; }
         | kDELETE               { $$ = $1; }
@@ -848,14 +908,12 @@ ReservedAsIdentifier
         | kFINALLY              { $$ = $1; }
         | kFOR                  { $$ = $1; }
         | kFUNCTION             { $$ = $1; }
-        | kGET                  { $$ = $1; }
         | kIF                   { $$ = $1; }
         | kIN                   { $$ = $1; }
         | kINSTANCEOF           { $$ = $1; }
         | kNEW                  { $$ = $1; }
         | kNULL                 { $$ = $1; }
         | kRETURN               { $$ = $1; }
-        | kSET                  { $$ = $1; }
         | kSWITCH               { $$ = $1; }
         | kTHIS                 { $$ = $1; }
         | kTHROW                { $$ = $1; }
@@ -866,6 +924,12 @@ ReservedAsIdentifier
         | kVOID                 { $$ = $1; }
         | kWHILE                { $$ = $1; }
         | kWITH                 { $$ = $1; }
+        | ES5Keyword            { $$ = $1; }
+
+ES5Keyword
+        : kGET                  { $$ = $1; }
+        | kLET                  { $$ = $1; }
+        | kSET                  { $$ = $1; }
 
 /* ECMA-262 3rd Edition    7.8 */
 Literal
@@ -886,19 +950,19 @@ BooleanLiteral
 
 semicolon_opt
         : ';'
-        | error                 { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
+        | error                 { if(!allow_auto_semicolon(ctx)) {YYABORT;} else { ctx->hres = S_OK; ctx->error_loc = -1; } }
 
 left_bracket
-        : '('                   { $$ = ctx->ptr; }
-        | error                 { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; }
+        : '('
+        | error                 { set_error(ctx, @$, JS_E_MISSING_LBRACKET); YYABORT; }
 
 right_bracket
         : ')'
-        | error                 { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; }
+        | error                 { set_error(ctx, @$, JS_E_MISSING_RBRACKET); YYABORT; }
 
 semicolon
         : ';'
-        | error                 { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; }
+        | error                 { set_error(ctx,  @$, JS_E_MISSING_SEMICOLON); YYABORT; }
 
 %%
 
@@ -907,7 +971,7 @@ static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
     return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
 }
 
-static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size)
+static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size, unsigned loc)
 {
     statement_t *stat;
 
@@ -916,6 +980,7 @@ static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size
         return NULL;
 
     stat->type = type;
+    stat->loc  = loc;
     stat->next = NULL;
 
     return stat;
@@ -1029,12 +1094,13 @@ static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier
     return ret;
 }
 
-static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_list_t *stat_list)
+static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, unsigned loc, expression_t *expr, statement_list_t *stat_list)
 {
     case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t));
 
     ret->expr = expr;
     ret->stat = stat_list ? stat_list->head : NULL;
+    ret->loc = loc;
     ret->next = NULL;
 
     return ret;
@@ -1106,14 +1172,15 @@ static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list
     return ret;
 }
 
-static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list)
+static statement_t *new_block_statement(parser_ctx_t *ctx, unsigned loc, statement_list_t *list)
 {
     block_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret));
+    ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
+    ret->scope_index = 0;
     ret->stat_list = list ? list->head : NULL;
 
     return &ret->stat;
@@ -1127,6 +1194,8 @@ static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const
     ret->expr = expr;
     ret->next = NULL;
     ret->global_next = NULL;
+    ret->block_scope = FALSE;
+    ret->constant = FALSE;
 
     return ret;
 }
@@ -1147,24 +1216,31 @@ static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *li
     return list;
 }
 
-static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list)
+static statement_t *new_var_statement(parser_ctx_t *ctx, BOOL block_scope, BOOL constant, unsigned loc,
+        variable_list_t *variable_list)
 {
+    variable_declaration_t *var;
     var_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_VAR, sizeof(*ret));
+    ret = new_statement(ctx, STAT_VAR, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
     ret->variable_list = variable_list->head;
+    for (var = ret->variable_list; var; var = var->next)
+    {
+        var->block_scope = block_scope;
+        var->constant = constant;
+    }
 
     return &ret->stat;
 }
 
-static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr)
+static statement_t *new_expression_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
 {
     expression_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_EXPR, sizeof(*ret));
+    ret = new_statement(ctx, STAT_EXPR, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1173,11 +1249,12 @@ static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *ex
     return &ret->stat;
 }
 
-static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, statement_t *else_stat)
+static statement_t *new_if_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr,
+                                     statement_t *if_stat, statement_t *else_stat)
 {
     if_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_IF, sizeof(*ret));
+    ret = new_statement(ctx, STAT_IF, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1188,11 +1265,11 @@ static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, stat
     return &ret->stat;
 }
 
-static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t *expr, statement_t *stat)
+static statement_t *new_while_statement(parser_ctx_t *ctx, unsigned loc, BOOL dowhile, expression_t *expr, statement_t *stat)
 {
     while_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_WHILE, sizeof(*ret));
+    ret = new_statement(ctx, STAT_WHILE, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1203,30 +1280,33 @@ static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, express
     return &ret->stat;
 }
 
-static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr,
-        expression_t *expr, expression_t *end_expr, statement_t *statement)
+static statement_t *new_for_statement(parser_ctx_t *ctx, unsigned loc, variable_declaration_t *variable_list, expression_t *begin_expr,
+        expression_t *expr, unsigned expr_loc, expression_t *end_expr, unsigned end_loc, statement_t *statement)
 {
     for_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_FOR, sizeof(*ret));
+    ret = new_statement(ctx, STAT_FOR, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
-    ret->variable_list = variable_list ? variable_list->head : NULL;
+    ret->variable_list = variable_list;
     ret->begin_expr = begin_expr;
     ret->expr = expr;
+    ret->expr_loc = expr_loc;
     ret->end_expr = end_expr;
+    ret->end_loc = end_loc;
     ret->statement = statement;
+    ret->scope_index = 0;
 
     return &ret->stat;
 }
 
-static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t *variable, expression_t *expr,
+static statement_t *new_forin_statement(parser_ctx_t *ctx, unsigned loc, variable_declaration_t *variable, expression_t *expr,
         expression_t *in_expr, statement_t *statement)
 {
     forin_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_FORIN, sizeof(*ret));
+    ret = new_statement(ctx, STAT_FORIN, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1238,11 +1318,11 @@ static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_
     return &ret->stat;
 }
 
-static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier)
+static statement_t *new_continue_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier)
 {
     branch_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret));
+    ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1251,11 +1331,11 @@ static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *ident
     return &ret->stat;
 }
 
-static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier)
+static statement_t *new_break_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier)
 {
     branch_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_BREAK, sizeof(*ret));
+    ret = new_statement(ctx, STAT_BREAK, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1264,11 +1344,11 @@ static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifi
     return &ret->stat;
 }
 
-static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr)
+static statement_t *new_return_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
 {
     expression_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_RETURN, sizeof(*ret));
+    ret = new_statement(ctx, STAT_RETURN, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1277,11 +1357,11 @@ static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr)
     return &ret->stat;
 }
 
-static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *statement)
+static statement_t *new_with_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr, statement_t *statement)
 {
     with_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_WITH, sizeof(*ret));
+    ret = new_statement(ctx, STAT_WITH, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1291,11 +1371,11 @@ static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, st
     return &ret->stat;
 }
 
-static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
+static statement_t *new_labelled_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier, statement_t *statement)
 {
     labelled_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_LABEL, sizeof(*ret));
+    ret = new_statement(ctx, STAT_LABEL, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1305,11 +1385,11 @@ static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *ident
     return &ret->stat;
 }
 
-static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_list)
+static statement_t *new_switch_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr, case_clausule_t *case_list)
 {
     switch_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret));
+    ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1319,11 +1399,11 @@ static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr,
     return &ret->stat;
 }
 
-static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr)
+static statement_t *new_throw_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
 {
     expression_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_THROW, sizeof(*ret));
+    ret = new_statement(ctx, STAT_THROW, sizeof(*ret), loc);
     if(!ret)
         return NULL;
 
@@ -1333,17 +1413,18 @@ static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr)
 }
 
 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement,
-       catch_block_t *catch_block, statement_t *finally_statement)
+        catch_block_t *catch_block, statement_t *finally_statement, unsigned finally_loc)
 {
     try_statement_t *ret;
 
-    ret = new_statement(ctx, STAT_TRY, sizeof(*ret));
+    ret = new_statement(ctx, STAT_TRY, sizeof(*ret), try_statement->loc);
     if(!ret)
         return NULL;
 
     ret->try_statement = try_statement;
     ret->catch_block = catch_block;
     ret->finally_statement = finally_statement;
+    ret->finally_loc = finally_loc;
 
     return &ret->stat;
 }
@@ -1375,16 +1456,18 @@ static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t
 }
 
 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier, parameter_list_t *parameter_list,
-    source_elements_t *source_elements, const WCHAR *event_target, const WCHAR *src_str, DWORD src_len)
+    statement_list_t *statement_list, const WCHAR *event_target, const WCHAR *src_str, DWORD src_len)
 {
     function_expression_t *ret = new_expression(ctx, EXPR_FUNC, sizeof(*ret));
 
     ret->identifier = identifier;
     ret->parameter_list = parameter_list ? parameter_list->head : NULL;
-    ret->source_elements = source_elements;
+    ret->statement_list = statement_list ? statement_list->head : NULL;
     ret->event_target = event_target;
     ret->src_str = src_str;
     ret->src_len = src_len;
+    ret->is_statement = FALSE;
+    ret->scope_index = 0;
     ret->next = NULL;
 
     return &ret->expr;
@@ -1461,21 +1544,26 @@ static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expres
     return &ret->expr;
 }
 
-static int parser_error(parser_ctx_t *ctx, const char *str)
+static int parser_error(unsigned *loc, parser_ctx_t *ctx, const char *str)
 {
+    if(ctx->error_loc == -1)
+        ctx->error_loc = *loc;
+    if(ctx->hres == S_OK)
+        ctx->hres = JS_E_SYNTAX;
     return 0;
 }
 
-static void set_error(parser_ctx_t *ctx, UINT error)
+static void set_error(parser_ctx_t *ctx, unsigned loc, HRESULT error)
 {
     ctx->hres = error;
+    ctx->error_loc = loc;
 }
 
 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next)
 {
     if(obj || *(ctx->ptr-1)==next) return TRUE;
 
-    set_error(ctx, JS_E_SYNTAX);
+    set_error(ctx, ctx->ptr - ctx->begin /* FIXME */, JS_E_SYNTAX);
     return FALSE;
 }
 
@@ -1517,25 +1605,6 @@ static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *litera
     return &ret->expr;
 }
 
-static source_elements_t *new_source_elements(parser_ctx_t *ctx)
-{
-    source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t));
-
-    memset(ret, 0, sizeof(*ret));
-
-    return ret;
-}
-
-static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement)
-{
-    if(source_elements->statement_tail)
-        source_elements->statement_tail = source_elements->statement_tail->next = statement;
-    else
-        source_elements->statement = source_elements->statement_tail = statement;
-
-    return source_elements;
-}
-
 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement)
 {
     statement_list_t *ret =  parser_alloc_tmp(ctx, sizeof(statement_list_t));
@@ -1552,37 +1621,28 @@ static statement_list_t *statement_list_add(statement_list_t *list, statement_t
     return list;
 }
 
-static void program_parsed(parser_ctx_t *ctx, source_elements_t *source)
-{
-    ctx->source = source;
-    if(!ctx->lexer_error)
-        ctx->hres = S_OK;
-}
-
 void parser_release(parser_ctx_t *ctx)
 {
     script_release(ctx->script);
     heap_pool_free(&ctx->heap);
-    heap_free(ctx);
+    free(ctx);
 }
 
-HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
+HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, bytecode_t *code, const WCHAR *delimiter, BOOL from_eval,
         parser_ctx_t **ret)
 {
     parser_ctx_t *parser_ctx;
     heap_pool_t *mark;
     HRESULT hres;
 
-    const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0};
-
-    parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
+    parser_ctx = calloc(1, sizeof(parser_ctx_t));
     if(!parser_ctx)
         return E_OUTOFMEMORY;
 
-    parser_ctx->hres = JS_E_SYNTAX;
-    parser_ctx->is_html = delimiter && !wcsicmp(delimiter, html_tagW);
+    parser_ctx->error_loc = -1;
+    parser_ctx->is_html = delimiter && !wcsicmp(delimiter, L"</script>");
 
-    parser_ctx->begin = parser_ctx->ptr = code;
+    parser_ctx->begin = parser_ctx->ptr = code->source;
     parser_ctx->end = parser_ctx->begin + lstrlenW(parser_ctx->begin);
 
     script_addref(ctx);
@@ -1598,10 +1658,26 @@ HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, const
     heap_pool_clear(mark);
     hres = parser_ctx->hres;
     if(FAILED(hres)) {
-        WARN("parser failed around %s\n",
-            debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20));
+        unsigned int error_loc = parser_ctx->error_loc == -1 ? 0 : parser_ctx->error_loc;
+        const WCHAR *line_start = code->source + error_loc, *line_end = line_start;
+        jsstr_t *line_str;
+
+        while(line_start > code->source && line_start[-1] != '\n')
+            line_start--;
+        while(*line_end && *line_end != '\n')
+            line_end++;
+        line_str = jsstr_alloc_len(line_start, line_end - line_start);
+
+        WARN("parser failed around %s in line %s\n",
+             debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20),
+             debugstr_jsstr(line_str));
+
+        throw_error(ctx, hres, NULL);
+        set_error_location(ctx->ei, code, error_loc, IDS_COMPILATION_ERROR, line_str);
         parser_release(parser_ctx);
-        return hres;
+        if(line_str)
+            jsstr_release(line_str);
+        return DISP_E_EXCEPTION;
     }
 
     *ret = parser_ctx;

dll/win32/jscript/precomp.h

@@ -2,9 +2,6 @@
 #ifndef _JSCRIPT_PRECOMP_H
 #define _JSCRIPT_PRECOMP_H
 
-#include <wine/config.h>
-#include <wine/port.h>
-
 #include <assert.h>
 
 #define WIN32_NO_STATUS

dll/win32/jscript/regexp.c

@@ -41,13 +41,11 @@
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
 /* FIXME: Better error handling */
-#define ReportRegExpError(a,b,c)
-#define ReportRegExpErrorHelper(a,b,c,d)
-#define JS_ReportErrorNumber(a,b,c,d)
-#define JS_ReportErrorFlagsAndNumber(a,b,c,d,e,f)
-#define js_ReportOutOfScriptQuota(a)
-#define JS_ReportOutOfMemory(a)
-#define JS_COUNT_OPERATION(a,b)
+#define ReportRegExpError(a,b,c) throw_error((a)->context, E_FAIL, L"")
+#define ReportRegExpErrorHelper(a,b,c,d) throw_error((a)->context, E_FAIL, L"")
+#define JS_ReportErrorNumber(a,b,c,d) throw_error((a), E_FAIL, L"")
+#define JS_ReportErrorFlagsAndNumber(a,b,c,d,e,f) throw_error((a), E_FAIL, L"")
+#define JS_COUNT_OPERATION(a,b) do { } while(0)
 
 
 typedef BYTE JSPackedBool;
@@ -292,7 +290,7 @@ struct RENode {
 #define CLASS_CACHE_SIZE    4
 
 typedef struct CompilerState {
-    void            *context;
+    script_ctx_t    *context;
     const WCHAR     *cpbegin;
     const WCHAR     *cpend;
     const WCHAR     *cp;
@@ -412,7 +410,7 @@ NewRENode(CompilerState *state, REOp op)
 
     ren = heap_pool_alloc(state->pool, sizeof(*ren));
     if (!ren) {
-        /* js_ReportOutOfScriptQuota(cx); */
+        throw_error(state->context, E_OUTOFMEMORY, L"");
         return NULL;
     }
     ren->op = op;
@@ -482,7 +480,7 @@ EmitREBytecode(CompilerState *state, regexp_t *re, size_t treeDepth,
     if (treeDepth == 0) {
         emitStateStack = NULL;
     } else {
-        emitStateStack = heap_alloc(sizeof(EmitStateStackEntry) * treeDepth);
+        emitStateStack = malloc(sizeof(EmitStateStackEntry) * treeDepth);
         if (!emitStateStack)
             return NULL;
     }
@@ -788,7 +786,7 @@ EmitREBytecode(CompilerState *state, regexp_t *re, size_t treeDepth,
     }
 
   cleanup:
-    heap_free(emitStateStack);
+    free(emitStateStack);
     return pc;
 
   jump_too_big:
@@ -1622,8 +1620,7 @@ doSimple:
       case '*':
       case '+':
       case '?':
-        ReportRegExpErrorHelper(state, JSREPORT_ERROR,
-                                JSMSG_BAD_QUANTIFIER, state->cp - 1);
+        throw_error(state->context, state->context->version < SCRIPTLANGUAGEVERSION_ES5 ? JS_E_REGEXP_SYNTAX : JS_E_UNEXPECTED_QUANTIFIER, L"");
         return FALSE;
       default:
 asFlat:
@@ -1667,11 +1664,11 @@ ParseRegExp(CompilerState *state)
         return (state->result != NULL);
     }
 
-    operatorStack = heap_alloc(sizeof(REOpData) * operatorStackSize);
+    operatorStack = malloc(sizeof(REOpData) * operatorStackSize);
     if (!operatorStack)
         return FALSE;
 
-    operandStack = heap_alloc(sizeof(RENode *) * operandStackSize);
+    operandStack = malloc(sizeof(RENode *) * operandStackSize);
     if (!operandStack)
         goto out;
 
@@ -1762,7 +1759,7 @@ pushOperand:
                 if (operandSP == operandStackSize) {
                     RENode **tmp;
                     operandStackSize += operandStackSize;
-                    tmp = heap_realloc(operandStack, sizeof(RENode *) * operandStackSize);
+                    tmp = realloc(operandStack, sizeof(RENode *) * operandStackSize);
                     if (!tmp)
                         goto out;
                     operandStack = tmp;
@@ -1895,7 +1892,7 @@ pushOperator:
             if (operatorSP == operatorStackSize) {
                 REOpData *tmp;
                 operatorStackSize += operatorStackSize;
-                tmp = heap_realloc(operatorStack, sizeof(REOpData) * operatorStackSize);
+                tmp = realloc(operatorStack, sizeof(REOpData) * operatorStackSize);
                 if (!tmp)
                     goto out;
                 operatorStack = tmp;
@@ -1907,8 +1904,8 @@ pushOperator:
         }
     }
 out:
-    heap_free(operatorStack);
-    heap_free(operandStack);
+    free(operatorStack);
+    free(operandStack);
     return result;
 }
 
@@ -1935,7 +1932,7 @@ PushBackTrackState(REGlobalData *gData, REOp op,
     ptrdiff_t btincr = ((char *)result + sz) -
                        ((char *)gData->backTrackStack + btsize);
 
-    TRACE("\tBT_Push: %lu,%lu\n", (ULONG_PTR)parenIndex, (ULONG_PTR)parenCount);
+    TRACE("\tBT_Push: %Iu,%Iu\n", (ULONG_PTR)parenIndex, (ULONG_PTR)parenCount);
 
     JS_COUNT_OPERATION(gData->cx, JSOW_JUMP * (1 + parenCount));
     if (btincr > 0) {
@@ -1945,7 +1942,7 @@ PushBackTrackState(REGlobalData *gData, REOp op,
         btincr = ((btincr+btsize-1)/btsize)*btsize;
         gData->backTrackStack = heap_pool_grow(gData->pool, gData->backTrackStack, btsize, btincr);
         if (!gData->backTrackStack) {
-            js_ReportOutOfScriptQuota(gData->cx);
+            throw_error(gData->cx, E_OUTOFMEMORY, L"");
             gData->ok = FALSE;
             return NULL;
         }
@@ -2111,9 +2108,9 @@ ProcessCharSet(REGlobalData *gData, RECharSet *charSet)
     assert(src[-1] == '[' && end[0] == ']');
 
     byteLength = (charSet->length >> 3) + 1;
-    charSet->u.bits = heap_alloc(byteLength);
+    charSet->u.bits = malloc(byteLength);
     if (!charSet->u.bits) {
-        JS_ReportOutOfMemory(gData->cx);
+        throw_error(gData->cx, E_OUTOFMEMORY, L"");
         gData->ok = FALSE;
         return FALSE;
     }
@@ -2301,7 +2298,7 @@ ReallocStateStack(REGlobalData *gData)
 
     gData->stateStack = heap_pool_grow(gData->pool, gData->stateStack, sz, sz);
     if (!gData->stateStack) {
-        js_ReportOutOfScriptQuota(gData->cx);
+        throw_error(gData->cx, E_OUTOFMEMORY, L"");
         gData->ok = FALSE;
         return FALSE;
     }
@@ -2684,7 +2681,7 @@ ExecuteREBytecode(REGlobalData *gData, match_state_t *x)
 
               case REOP_LPAREN:
                 pc = ReadCompactIndex(pc, &parenIndex);
-                TRACE("[ %lu ]\n", (ULONG_PTR)parenIndex);
+                TRACE("[ %Iu ]\n", (ULONG_PTR)parenIndex);
                 assert(parenIndex < gData->regexp->parenCount);
                 if (parenIndex + 1 > parenSoFar)
                     parenSoFar = parenIndex + 1;
@@ -3047,7 +3044,7 @@ ExecuteREBytecode(REGlobalData *gData, match_state_t *x)
                 parenSoFar = curState->parenSoFar;
             }
 
-            TRACE("\tBT_Pop: %ld,%ld\n",
+            TRACE("\tBT_Pop: %Id,%Id\n",
                      (ULONG_PTR)backTrackData->parenIndex,
                      (ULONG_PTR)backTrackData->parenCount);
             continue;
@@ -3132,7 +3129,6 @@ static HRESULT InitMatch(regexp_t *re, void *cx, heap_pool_t *pool, REGlobalData
     return S_OK;
 
 bad:
-    js_ReportOutOfScriptQuota(cx);
     gData->ok = FALSE;
     return E_OUTOFMEMORY;
 }
@@ -3184,12 +3180,12 @@ void regexp_destroy(regexp_t *re)
         UINT i;
         for (i = 0; i < re->classCount; i++) {
             if (re->classList[i].converted)
-                heap_free(re->classList[i].u.bits);
+                free(re->classList[i].u.bits);
             re->classList[i].u.bits = NULL;
         }
-        heap_free(re->classList);
+        free(re->classList);
     }
-    heap_free(re);
+    free(re);
 }
 
 regexp_t* regexp_new(void *cx, heap_pool_t *pool, const WCHAR *str,
@@ -3238,14 +3234,14 @@ regexp_t* regexp_new(void *cx, heap_pool_t *pool, const WCHAR *str,
             goto out;
     }
     resize = offsetof(regexp_t, program) + state.progLength + 1;
-    re = heap_alloc(resize);
+    re = malloc(resize);
     if (!re)
         goto out;
 
     assert(state.classBitmapsMem <= CLASS_BITMAPS_MEM_LIMIT);
     re->classCount = state.classCount;
     if (re->classCount) {
-        re->classList = heap_alloc(re->classCount * sizeof(RECharSet));
+        re->classList = malloc(re->classCount * sizeof(RECharSet));
         if (!re->classList) {
             regexp_destroy(re);
             re = NULL;
@@ -3272,7 +3268,7 @@ regexp_t* regexp_new(void *cx, heap_pool_t *pool, const WCHAR *str,
         regexp_t *tmp;
         assert((size_t)(endPC - re->program) < state.progLength + 1);
         resize = offsetof(regexp_t, program) + (endPC - re->program);
-        tmp = heap_realloc(re, resize);
+        tmp = realloc(re, resize);
         if (tmp)
             re = tmp;
     }

dll/win32/jscript/regexp.h

@@ -63,10 +63,10 @@ typedef struct regexp_t {
     jsbytecode          program[1];    /* regular expression bytecode */
 } regexp_t;
 
-regexp_t* regexp_new(void*, heap_pool_t*, const WCHAR*, DWORD, WORD, BOOL) DECLSPEC_HIDDEN;
-void regexp_destroy(regexp_t*) DECLSPEC_HIDDEN;
+regexp_t* regexp_new(void*, heap_pool_t*, const WCHAR*, DWORD, WORD, BOOL);
+void regexp_destroy(regexp_t*);
 HRESULT regexp_execute(regexp_t*, void*, heap_pool_t*, const WCHAR*,
-        DWORD, match_state_t*) DECLSPEC_HIDDEN;
+        DWORD, match_state_t*);
 
 static inline match_state_t* alloc_match_state(regexp_t *regexp,
         heap_pool_t *pool, const WCHAR *pos)
@@ -74,7 +74,7 @@ static inline match_state_t* alloc_match_state(regexp_t *regexp,
     size_t size = offsetof(match_state_t, parens) + regexp->parenCount*sizeof(RECapture);
     match_state_t *ret;
 
-    ret = pool ? heap_pool_alloc(pool, size) : heap_alloc(size);
+    ret = pool ? heap_pool_alloc(pool, size) : malloc(size);
     if(!ret)
         return NULL;
 

dll/win32/jscript/resource.h

@@ -16,8 +16,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#pragma once
-
 #include <windef.h>
 
 #define JSCRIPT_MAJOR_VERSION 5
@@ -27,11 +25,13 @@
 #define IDS_TO_PRIMITIVE                    0x0001
 #define IDS_INVALID_CALL_ARG                0x0005
 #define IDS_SUBSCRIPT_OUT_OF_RANGE          0x0009
+#define IDS_STACK_OVERFLOW                  0x001C
 #define IDS_OBJECT_REQUIRED                 0x01A8
 #define IDS_CREATE_OBJ_ERROR                0x01AD
 #define IDS_NO_PROPERTY                     0x01B6
 #define IDS_UNSUPPORTED_ACTION              0x01BD
 #define IDS_ARG_NOT_OPT                     0x01c1
+#define IDS_OBJECT_NOT_COLLECTION           0x01c3
 #define IDS_SYNTAX_ERROR                    0x03EA
 #define IDS_SEMICOLON                       0x03EC
 #define IDS_LBRACKET                        0x03ED
@@ -58,8 +58,11 @@
 #define IDS_INVALID_DELETE                  0x1394
 #define IDS_NOT_VBARRAY                     0x1395
 #define IDS_JSCRIPT_EXPECTED                0x1396
-#define IDS_NOT_ENUMERATOR                  0x1397
+#define IDS_ENUMERATOR_EXPECTED             0x1397
+#define IDS_REGEXP_EXPECTED                 0x1398
 #define IDS_REGEXP_SYNTAX_ERROR             0x1399
+#define IDS_UNEXPECTED_QUANTIFIER           0x139A
+#define IDS_EXCEPTION_THROWN                0x139E
 #define IDS_URI_INVALID_CHAR                0x13A0
 #define IDS_URI_INVALID_CODING              0x13A1
 #define IDS_FRACTION_DIGITS_OUT_OF_RANGE    0x13A2
@@ -67,8 +70,22 @@
 #define IDS_INVALID_LENGTH                  0x13A5
 #define IDS_ARRAY_EXPECTED                  0x13A7
 #define IDS_INVALID_WRITABLE_PROP_DESC      0x13AC
+#define IDS_CYCLIC_PROTO_VALUE              0x13B0
+#define IDS_CREATE_FOR_NONEXTENSIBLE        0x13B6
+#define IDS_OBJECT_NONEXTENSIBLE            0x13D5
 #define IDS_NONCONFIGURABLE_REDEFINED       0x13D6
 #define IDS_NONWRITABLE_MODIFIED            0x13D7
+#define IDS_NOT_DATAVIEW                    0x13DF
+#define IDS_DATAVIEW_NO_ARGUMENT            0x13E0
+#define IDS_DATAVIEW_INVALID_ACCESS         0x13E1
+#define IDS_DATAVIEW_INVALID_OFFSET         0x13E2
+#define IDS_WRONG_THIS                      0x13FC
+#define IDS_KEY_NOT_OBJECT                  0x13FD
+#define IDS_ARRAYBUFFER_EXPECTED            0x15E4
 /* FIXME: This is not compatible with native, but we would
  * conflict with IDS_UNSUPPORTED_ACTION otherwise */
 #define IDS_PROP_DESC_MISMATCH              0x1F00
+
+#define IDS_COMPILATION_ERROR               0x1000
+#define IDS_RUNTIME_ERROR                   0x1001
+#define IDS_UNKNOWN_ERROR                   0x1002

dll/win32/jscript/rsrc.rc

@@ -21,11 +21,6 @@
 /* @makedep: jscript.rgs */
 2 WINE_REGISTRY jscript.rgs
 
-3 WINE_REGISTRY jscript_classes.rgs
-
-/* @makedep: jsglobal.tlb */
-1 TYPELIB jsglobal.tlb
-
 #define WINE_FILEDESCRIPTION_STR "Wine JScript"
 #define WINE_FILENAME_STR "jscript.dll"
 #define WINE_FILEVERSION 5,7,7601,16982

dll/win32/jscript/set.c

@@ -0,0 +1,945 @@
+/*
+ * Copyright 2021 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
+ */
+
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
+
+#include <assert.h>
+#include <math.h>
+
+#include "jscript.h"
+
+#include "wine/rbtree.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(jscript);
+
+typedef struct {
+    jsdisp_t dispex;
+    struct wine_rb_tree map;
+    struct list entries;
+    size_t size;
+} MapInstance;
+
+struct jsval_map_entry {
+    struct wine_rb_entry entry;
+    jsval_t key;
+    jsval_t value;
+
+    /*
+     * We need to maintain a list as well to support traversal in forEach.
+     * If the entry is removed while being processed by forEach, it's
+     * still kept in the list and released later, when it's safe.
+     */
+    struct list list_entry;
+    unsigned int ref;
+    BOOL deleted;
+};
+
+static int jsval_map_compare(const void *k, const struct wine_rb_entry *e)
+{
+    const struct jsval_map_entry *entry = WINE_RB_ENTRY_VALUE(e, const struct jsval_map_entry, entry);
+    const jsval_t *key = k;
+    union {
+        double d;
+        INT64 n;
+    } bits1, bits2;
+
+    if(jsval_type(entry->key) != jsval_type(*key))
+        return (int)jsval_type(entry->key) - (int)jsval_type(*key);
+
+    switch(jsval_type(*key)) {
+    case JSV_UNDEFINED:
+    case JSV_NULL:
+        return 0;
+    case JSV_OBJECT:
+        if(get_object(*key) == get_object(entry->key)) return 0;
+        return get_object(*key) < get_object(entry->key) ? -1 : 1;
+    case JSV_STRING:
+        return jsstr_cmp(get_string(*key), get_string(entry->key));
+    case JSV_NUMBER:
+        if(isnan(get_number(*key))) return isnan(get_number(entry->key)) ? 0 : -1;
+        if(isnan(get_number(entry->key))) return 1;
+
+        /* native treats -0 differently than 0, so need to compare bitwise */
+        bits1.d = get_number(*key);
+        bits2.d = get_number(entry->key);
+        return (bits1.n == bits2.n) ? 0 : (bits1.n < bits2.n ? -1 : 1);
+    case JSV_BOOL:
+        if(get_bool(*key) == get_bool(entry->key)) return 0;
+        return get_bool(*key) ? 1 : -1;
+    default:
+        assert(0);
+        return 0;
+    }
+}
+
+static HRESULT get_map_this(script_ctx_t *ctx, jsval_t vthis, MapInstance **ret)
+{
+    jsdisp_t *jsdisp;
+
+    if(!is_object_instance(vthis))
+        return JS_E_OBJECT_EXPECTED;
+    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_MAP)) {
+        WARN("not a Map object passed as 'this'\n");
+        return throw_error(ctx, JS_E_WRONG_THIS, L"Map");
+    }
+
+    *ret = CONTAINING_RECORD(jsdisp, MapInstance, dispex);
+    return S_OK;
+}
+
+static HRESULT get_set_this(script_ctx_t *ctx, jsval_t vthis, MapInstance **ret)
+{
+    jsdisp_t *jsdisp;
+
+    if(!is_object_instance(vthis))
+        return JS_E_OBJECT_EXPECTED;
+    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_SET)) {
+        WARN("not a Set object passed as 'this'\n");
+        return throw_error(ctx, JS_E_WRONG_THIS, L"Set");
+    }
+
+    *ret = CONTAINING_RECORD(jsdisp, MapInstance, dispex);
+    return S_OK;
+}
+
+static struct jsval_map_entry *get_map_entry(MapInstance *map, jsval_t key)
+{
+    struct wine_rb_entry *entry;
+    if(!(entry = wine_rb_get(&map->map, &key))) return NULL;
+    return CONTAINING_RECORD(entry, struct jsval_map_entry, entry);
+}
+
+static void grab_map_entry(struct jsval_map_entry *entry)
+{
+    entry->ref++;
+}
+
+static void release_map_entry(struct jsval_map_entry *entry)
+{
+    if(--entry->ref) return;
+    jsval_release(entry->key);
+    jsval_release(entry->value);
+    list_remove(&entry->list_entry);
+    free(entry);
+}
+
+static void delete_map_entry(MapInstance *map, struct jsval_map_entry *entry)
+{
+    map->size--;
+    wine_rb_remove(&map->map, &entry->entry);
+    entry->deleted = TRUE;
+    release_map_entry(entry);
+}
+
+static HRESULT set_map_entry(MapInstance *map, jsval_t key, jsval_t value, jsval_t *r)
+{
+    struct jsval_map_entry *entry;
+    HRESULT hres;
+
+    if((entry = get_map_entry(map, key))) {
+        jsval_t val;
+        hres = jsval_copy(value, &val);
+        if(FAILED(hres))
+            return hres;
+
+        jsval_release(entry->value);
+        entry->value = val;
+    }else {
+        if(!(entry = calloc(1, sizeof(*entry)))) return E_OUTOFMEMORY;
+
+        hres = jsval_copy(key, &entry->key);
+        if(SUCCEEDED(hres)) {
+            hres = jsval_copy(value, &entry->value);
+            if(FAILED(hres))
+                jsval_release(entry->key);
+        }
+        if(FAILED(hres)) {
+            free(entry);
+            return hres;
+        }
+        grab_map_entry(entry);
+        wine_rb_put(&map->map, &entry->key, &entry->entry);
+        list_add_tail(&map->entries, &entry->list_entry);
+        map->size++;
+    }
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT iterate_map(MapInstance *map, script_ctx_t *ctx, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    struct list *iter = list_head(&map->entries);
+    jsval_t context_this = jsval_undefined();
+    HRESULT hres;
+
+    if(!argc || !is_object_instance(argv[0])) {
+        FIXME("invalid callback %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
+        return E_FAIL;
+    }
+
+    if(argc > 1)
+        context_this = argv[1];
+
+    while(iter) {
+        struct jsval_map_entry *entry = LIST_ENTRY(iter, struct jsval_map_entry, list_entry);
+        jsval_t args[3], v;
+
+        if(entry->deleted) {
+            iter = list_next(&map->entries, iter);
+            continue;
+        }
+
+        args[0] = entry->value;
+        args[1] = entry->key;
+        args[2] = jsval_obj(&map->dispex);
+        grab_map_entry(entry);
+        hres = disp_call_value(ctx, get_object(argv[0]), context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &v);
+        iter = list_next(&map->entries, iter);
+        release_map_entry(entry);
+        if(FAILED(hres))
+            return hres;
+        jsval_release(v);
+    }
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT Map_clear(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    struct jsval_map_entry *entry, *entry2;
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p\n", map);
+
+    LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &map->entries, struct jsval_map_entry, list_entry)
+        delete_map_entry(map, entry);
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT Map_delete(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
+    struct jsval_map_entry *entry;
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", map, debugstr_jsval(key));
+
+    if((entry = get_map_entry(map, key))) delete_map_entry(map, entry);
+    if(r) *r = jsval_bool(!!entry);
+    return S_OK;
+}
+
+static HRESULT Map_forEach(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", map, debugstr_jsval(argc >= 1 ? argv[0] : jsval_undefined()));
+
+    return iterate_map(map, ctx, argc, argv, r);
+}
+
+static HRESULT Map_get(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
+    struct jsval_map_entry *entry;
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", map, debugstr_jsval(key));
+
+    if(!(entry = get_map_entry(map, key))) {
+        if(r) *r = jsval_undefined();
+        return S_OK;
+    }
+
+    return r ? jsval_copy(entry->value, r) : S_OK;
+}
+
+static HRESULT Map_set(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
+    jsval_t value = argc >= 2 ? argv[1] : jsval_undefined();
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s %s)\n", map, debugstr_jsval(key), debugstr_jsval(value));
+
+    return set_map_entry(map, key, value, r);
+}
+
+static HRESULT Map_has(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
+    struct jsval_map_entry *entry;
+    MapInstance *map;
+    HRESULT hres;
+
+    hres = get_map_this(ctx, vthis, &map);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", map, debugstr_jsval(key));
+
+    entry = get_map_entry(map, key);
+    if(r) *r = jsval_bool(!!entry);
+    return S_OK;
+}
+
+static HRESULT Map_get_size(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
+{
+    MapInstance *map = (MapInstance*)jsthis;
+
+    TRACE("%p\n", map);
+
+    *r = jsval_number(map->size);
+    return S_OK;
+}
+
+static HRESULT Map_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static void Map_destructor(jsdisp_t *dispex)
+{
+    MapInstance *map = (MapInstance*)dispex;
+
+    while(!list_empty(&map->entries)) {
+        struct jsval_map_entry *entry = LIST_ENTRY(list_head(&map->entries),
+                                                   struct jsval_map_entry, list_entry);
+        assert(!entry->deleted);
+        release_map_entry(entry);
+    }
+}
+
+static HRESULT Map_gc_traverse(struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
+{
+    MapInstance *map = (MapInstance*)dispex;
+    struct jsval_map_entry *entry, *entry2;
+    HRESULT hres;
+
+    if(op == GC_TRAVERSE_UNLINK) {
+        LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &map->entries, struct jsval_map_entry, list_entry)
+            release_map_entry(entry);
+        wine_rb_destroy(&map->map, NULL, NULL);
+        return S_OK;
+    }
+
+    LIST_FOR_EACH_ENTRY(entry, &map->entries, struct jsval_map_entry, list_entry) {
+        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->key);
+        if(FAILED(hres))
+            return hres;
+        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->value);
+        if(FAILED(hres))
+            return hres;
+    }
+    return S_OK;
+}
+
+static const builtin_prop_t Map_prototype_props[] = {
+    {L"clear",      Map_clear,     PROPF_METHOD},
+    {L"delete" ,    Map_delete,    PROPF_METHOD|1},
+    {L"forEach",    Map_forEach,   PROPF_METHOD|1},
+    {L"get",        Map_get,       PROPF_METHOD|1},
+    {L"has",        Map_has,       PROPF_METHOD|1},
+    {L"set",        Map_set,       PROPF_METHOD|2},
+};
+
+static const builtin_prop_t Map_props[] = {
+    {L"size",       NULL,0,        Map_get_size, builtin_set_const},
+};
+
+static const builtin_info_t Map_prototype_info = {
+    .class     = JSCLASS_OBJECT,
+    .call      = Map_value,
+    .props_cnt = ARRAY_SIZE(Map_prototype_props),
+    .props     = Map_prototype_props,
+};
+
+static const builtin_info_t Map_info = {
+    .class       = JSCLASS_MAP,
+    .call        = Map_value,
+    .props_cnt   = ARRAY_SIZE(Map_props),
+    .props       = Map_props,
+    .destructor  = Map_destructor,
+    .gc_traverse = Map_gc_traverse,
+};
+
+static HRESULT Map_constructor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    MapInstance *map;
+    HRESULT hres;
+
+    switch(flags) {
+    case DISPATCH_CONSTRUCT:
+        TRACE("\n");
+
+        if(!r)
+            return S_OK;
+        if(!(map = calloc(1, sizeof(*map))))
+            return E_OUTOFMEMORY;
+
+        hres = init_dispex(&map->dispex, ctx, &Map_info, ctx->map_prototype);
+        if(FAILED(hres))
+            return hres;
+
+        wine_rb_init(&map->map, jsval_map_compare);
+        list_init(&map->entries);
+        *r = jsval_obj(&map->dispex);
+        return S_OK;
+
+    case DISPATCH_METHOD:
+        return throw_error(ctx, JS_E_WRONG_THIS, L"Map");
+
+    default:
+        FIXME("unimplemented flags %x\n", flags);
+        return E_NOTIMPL;
+    }
+}
+
+static HRESULT Set_add(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc ? argv[0] : jsval_undefined();
+    MapInstance *set;
+    HRESULT hres;
+
+    hres = get_set_this(ctx, vthis, &set);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", set, debugstr_jsval(key));
+
+    return set_map_entry(set, key, key, r);
+}
+
+static HRESULT Set_clear(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    struct jsval_map_entry *entry, *entry2;
+    MapInstance *set;
+    HRESULT hres;
+
+    hres = get_set_this(ctx, vthis, &set);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p\n", set);
+
+    LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &set->entries, struct jsval_map_entry, list_entry)
+        delete_map_entry(set, entry);
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT Set_delete(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc ? argv[0] : jsval_undefined();
+    struct jsval_map_entry *entry;
+    MapInstance *set;
+    HRESULT hres;
+
+    hres = get_set_this(ctx, vthis, &set);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", set, debugstr_jsval(key));
+
+    if((entry = get_map_entry(set, key))) delete_map_entry(set, entry);
+    if(r) *r = jsval_bool(!!entry);
+    return S_OK;
+}
+
+static HRESULT Set_forEach(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    MapInstance *set;
+    HRESULT hres;
+
+    hres = get_set_this(ctx, vthis, &set);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", set, debugstr_jsval(argc ? argv[0] : jsval_undefined()));
+
+    return iterate_map(set, ctx, argc, argv, r);
+}
+
+static HRESULT Set_has(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsval_t key = argc ? argv[0] : jsval_undefined();
+    struct jsval_map_entry *entry;
+    MapInstance *set;
+    HRESULT hres;
+
+    hres = get_set_this(ctx, vthis, &set);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%s)\n", set, debugstr_jsval(key));
+
+    entry = get_map_entry(set, key);
+    if(r) *r = jsval_bool(!!entry);
+    return S_OK;
+}
+
+static HRESULT Set_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const builtin_prop_t Set_prototype_props[] = {
+    {L"add",        Set_add,       PROPF_METHOD|1},
+    {L"clear",      Set_clear,     PROPF_METHOD},
+    {L"delete" ,    Set_delete,    PROPF_METHOD|1},
+    {L"forEach",    Set_forEach,   PROPF_METHOD|1},
+    {L"has",        Set_has,       PROPF_METHOD|1},
+};
+
+static const builtin_info_t Set_prototype_info = {
+    .class     = JSCLASS_OBJECT,
+    .call      = Set_value,
+    .props_cnt = ARRAY_SIZE(Set_prototype_props),
+    .props     = Set_prototype_props,
+};
+
+static const builtin_info_t Set_info = {
+    .class       = JSCLASS_SET,
+    .call        = Set_value,
+    .props_cnt   = ARRAY_SIZE(Map_props),
+    .props       = Map_props,
+    .destructor  = Map_destructor,
+    .gc_traverse = Map_gc_traverse,
+};
+
+static HRESULT Set_constructor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    MapInstance *set;
+    HRESULT hres;
+
+    switch(flags) {
+    case DISPATCH_CONSTRUCT:
+        TRACE("\n");
+
+        if(!r)
+            return S_OK;
+        if(!(set = calloc(1, sizeof(*set))))
+            return E_OUTOFMEMORY;
+
+        hres = init_dispex(&set->dispex, ctx, &Set_info, ctx->set_prototype);
+        if(FAILED(hres))
+            return hres;
+
+        wine_rb_init(&set->map, jsval_map_compare);
+        list_init(&set->entries);
+        *r = jsval_obj(&set->dispex);
+        return S_OK;
+
+    case DISPATCH_METHOD:
+        return throw_error(ctx, JS_E_WRONG_THIS, L"Set");
+
+    default:
+        FIXME("unimplemented flags %x\n", flags);
+        return E_NOTIMPL;
+    }
+}
+
+typedef struct {
+    jsdisp_t dispex;
+    struct rb_tree map;
+} WeakMapInstance;
+
+static int weakmap_compare(const void *k, const struct rb_entry *e)
+{
+    ULONG_PTR a = (ULONG_PTR)k, b = (ULONG_PTR)RB_ENTRY_VALUE(e, const struct weakmap_entry, entry)->key;
+    return (a > b) - (a < b);
+}
+
+static HRESULT get_weakmap_this(script_ctx_t *ctx, jsval_t vthis, WeakMapInstance **ret)
+{
+    jsdisp_t *jsdisp;
+
+    if(!is_object_instance(vthis))
+        return JS_E_OBJECT_EXPECTED;
+    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_WEAKMAP)) {
+        WARN("not a WeakMap object passed as 'this'\n");
+        throw_error(ctx, JS_E_WRONG_THIS, L"WeakMap");
+        return DISP_E_EXCEPTION;
+    }
+
+    *ret = CONTAINING_RECORD(jsdisp, WeakMapInstance, dispex);
+    return S_OK;
+}
+
+static struct weakmap_entry *get_weakmap_entry(WeakMapInstance *weakmap, jsdisp_t *key)
+{
+    struct rb_entry *entry;
+    if(!(entry = rb_get(&weakmap->map, key))) return NULL;
+    return CONTAINING_RECORD(entry, struct weakmap_entry, entry);
+}
+
+void remove_weakmap_entry(struct weakmap_entry *entry)
+{
+    WeakMapInstance *weakmap = (WeakMapInstance*)entry->weakmap;
+    struct list *next = entry->weak_refs_entry.next;
+
+    if(next->next != &entry->weak_refs_entry)
+        list_remove(&entry->weak_refs_entry);
+    else {
+        struct weak_refs_entry *weak_refs_entry = LIST_ENTRY(next, struct weak_refs_entry, list);
+        entry->key->has_weak_refs = FALSE;
+        rb_remove(&entry->key->ctx->thread_data->weak_refs, &weak_refs_entry->entry);
+        free(weak_refs_entry);
+    }
+    rb_remove(&weakmap->map, &entry->entry);
+    jsval_release(entry->value);
+    free(entry);
+}
+
+static HRESULT WeakMap_clear(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    hres = get_weakmap_this(ctx, vthis, &weakmap);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p\n", weakmap);
+
+    while(weakmap->map.root)
+        remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT WeakMap_delete(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
+    struct weakmap_entry *entry;
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    hres = get_weakmap_this(ctx, vthis, &weakmap);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%p)\n", weakmap, key);
+
+    if((entry = get_weakmap_entry(weakmap, key)))
+        remove_weakmap_entry(entry);
+    if(r) *r = jsval_bool(!!entry);
+    return S_OK;
+}
+
+static HRESULT WeakMap_get(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
+    struct weakmap_entry *entry;
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    hres = get_weakmap_this(ctx, vthis, &weakmap);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%p)\n", weakmap, key);
+
+    if(!(entry = get_weakmap_entry(weakmap, key))) {
+        if(r) *r = jsval_undefined();
+        return S_OK;
+    }
+
+    return r ? jsval_copy(entry->value, r) : S_OK;
+}
+
+static HRESULT WeakMap_set(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
+    jsval_t value = argc >= 2 ? argv[1] : jsval_undefined();
+    struct weakmap_entry *entry;
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    hres = get_weakmap_this(ctx, vthis, &weakmap);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%p %s)\n", weakmap, key, debugstr_jsval(value));
+
+    if(!key)
+        return JS_E_KEY_NOT_OBJECT;
+
+    if((entry = get_weakmap_entry(weakmap, key))) {
+        jsval_t val;
+        hres = jsval_copy(value, &val);
+        if(FAILED(hres))
+            return hres;
+
+        jsval_release(entry->value);
+        entry->value = val;
+    }else {
+        struct weak_refs_entry *weak_refs_entry;
+
+        if(!(entry = malloc(sizeof(*entry))))
+            return E_OUTOFMEMORY;
+
+        hres = jsval_copy(value, &entry->value);
+        if(FAILED(hres)) {
+            free(entry);
+            return hres;
+        }
+
+        if(key->has_weak_refs)
+            weak_refs_entry = RB_ENTRY_VALUE(rb_get(&ctx->thread_data->weak_refs, key), struct weak_refs_entry, entry);
+        else {
+            if(!(weak_refs_entry = malloc(sizeof(*weak_refs_entry)))) {
+                jsval_release(entry->value);
+                free(entry);
+                return E_OUTOFMEMORY;
+            }
+            rb_put(&ctx->thread_data->weak_refs, key, &weak_refs_entry->entry);
+            list_init(&weak_refs_entry->list);
+            key->has_weak_refs = TRUE;
+        }
+        list_add_tail(&weak_refs_entry->list, &entry->weak_refs_entry);
+
+        entry->key = key;
+        entry->weakmap = &weakmap->dispex;
+        rb_put(&weakmap->map, key, &entry->entry);
+    }
+
+    if(r) *r = jsval_undefined();
+    return S_OK;
+}
+
+static HRESULT WeakMap_has(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    hres = get_weakmap_this(ctx, vthis, &weakmap);
+    if(FAILED(hres))
+        return hres;
+
+    TRACE("%p (%p)\n", weakmap, key);
+
+    if(r) *r = jsval_bool(!!get_weakmap_entry(weakmap, key));
+    return S_OK;
+}
+
+static HRESULT WeakMap_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static void WeakMap_destructor(jsdisp_t *dispex)
+{
+    WeakMapInstance *weakmap = (WeakMapInstance*)dispex;
+
+    while(weakmap->map.root)
+        remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
+}
+
+static HRESULT WeakMap_gc_traverse(struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
+{
+    WeakMapInstance *weakmap = (WeakMapInstance*)dispex;
+    struct weakmap_entry *entry;
+    HRESULT hres;
+
+    if(op == GC_TRAVERSE_UNLINK) {
+        while(weakmap->map.root)
+            remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
+        return S_OK;
+    }
+
+    RB_FOR_EACH_ENTRY(entry, &weakmap->map, struct weakmap_entry, entry) {
+        /* Only traverse the values if the key turned out to be alive, which means it might not have traversed
+           the associated values with it from this WeakMap yet (because it wasn't considered alive back then).
+           We need both the key and the WeakMap for the entry to actually be accessible (and thus traversed). */
+        if(op == GC_TRAVERSE && entry->key->gc_marked)
+            continue;
+
+        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->value);
+        if(FAILED(hres))
+            return hres;
+    }
+    return S_OK;
+}
+
+static const builtin_prop_t WeakMap_prototype_props[] = {
+    {L"clear",      WeakMap_clear,     PROPF_METHOD},
+    {L"delete",     WeakMap_delete,    PROPF_METHOD|1},
+    {L"get",        WeakMap_get,       PROPF_METHOD|1},
+    {L"has",        WeakMap_has,       PROPF_METHOD|1},
+    {L"set",        WeakMap_set,       PROPF_METHOD|2},
+};
+
+static const builtin_info_t WeakMap_prototype_info = {
+    .class     = JSCLASS_OBJECT,
+    .call      = WeakMap_value,
+    .props_cnt = ARRAY_SIZE(WeakMap_prototype_props),
+    .props     = WeakMap_prototype_props,
+};
+
+static const builtin_info_t WeakMap_info = {
+    .class       = JSCLASS_WEAKMAP,
+    .call        = WeakMap_value,
+    .destructor  = WeakMap_destructor,
+    .gc_traverse = WeakMap_gc_traverse,
+};
+
+static HRESULT WeakMap_constructor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    WeakMapInstance *weakmap;
+    HRESULT hres;
+
+    switch(flags) {
+    case DISPATCH_CONSTRUCT:
+        TRACE("\n");
+
+        if(!r)
+            return S_OK;
+        if(!(weakmap = calloc(1, sizeof(*weakmap))))
+            return E_OUTOFMEMORY;
+
+        hres = init_dispex(&weakmap->dispex, ctx, &WeakMap_info, ctx->weakmap_prototype);
+        if(FAILED(hres))
+            return hres;
+
+        rb_init(&weakmap->map, weakmap_compare);
+        *r = jsval_obj(&weakmap->dispex);
+        return S_OK;
+
+    case DISPATCH_METHOD:
+        return throw_error(ctx, JS_E_WRONG_THIS, L"WeakMap");
+
+    default:
+        FIXME("unimplemented flags %x\n", flags);
+        return E_NOTIMPL;
+    }
+}
+
+HRESULT init_set_constructor(script_ctx_t *ctx)
+{
+    jsdisp_t *constructor;
+    HRESULT hres;
+
+    if(ctx->version < SCRIPTLANGUAGEVERSION_ES6)
+        return S_OK;
+
+    hres = create_dispex(ctx, &Set_prototype_info, ctx->object_prototype, &ctx->set_prototype);
+    if(FAILED(hres))
+        return hres;
+
+    hres = create_builtin_constructor(ctx, Set_constructor, L"Set", NULL,
+                                      PROPF_CONSTR, ctx->set_prototype, &constructor);
+    if(FAILED(hres))
+        return hres;
+
+    hres = jsdisp_define_data_property(ctx->global, L"Set", PROPF_CONFIGURABLE | PROPF_WRITABLE,
+                                       jsval_obj(constructor));
+    jsdisp_release(constructor);
+    if(FAILED(hres))
+        return hres;
+
+    hres = create_dispex(ctx, &Map_prototype_info, ctx->object_prototype, &ctx->map_prototype);
+    if(FAILED(hres))
+        return hres;
+
+    hres = create_builtin_constructor(ctx, Map_constructor, L"Map", NULL,
+                                      PROPF_CONSTR, ctx->map_prototype, &constructor);
+    if(FAILED(hres))
+        return hres;
+
+    hres = jsdisp_define_data_property(ctx->global, L"Map", PROPF_CONFIGURABLE | PROPF_WRITABLE,
+                                       jsval_obj(constructor));
+    jsdisp_release(constructor);
+    if(FAILED(hres))
+        return hres;
+
+    hres = create_dispex(ctx, &WeakMap_prototype_info, ctx->object_prototype, &ctx->weakmap_prototype);
+    if(FAILED(hres))
+        return hres;
+
+    hres = create_builtin_constructor(ctx, WeakMap_constructor, L"WeakMap", NULL,
+                                      PROPF_CONSTR, ctx->weakmap_prototype, &constructor);
+    if(FAILED(hres))
+        return hres;
+
+    hres = jsdisp_define_data_property(ctx->global, L"WeakMap", PROPF_CONFIGURABLE | PROPF_WRITABLE,
+                                       jsval_obj(constructor));
+    jsdisp_release(constructor);
+    return hres;
+}

dll/win32/jscript/string.c

@@ -31,74 +31,37 @@ typedef struct {
     jsstr_t *str;
 } StringInstance;
 
-static const WCHAR lengthW[] = {'l','e','n','g','t','h',0};
-static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
-static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
-static const WCHAR anchorW[] = {'a','n','c','h','o','r',0};
-static const WCHAR bigW[] = {'b','i','g',0};
-static const WCHAR blinkW[] = {'b','l','i','n','k',0};
-static const WCHAR boldW[] = {'b','o','l','d',0};
-static const WCHAR charAtW[] = {'c','h','a','r','A','t',0};
-static const WCHAR charCodeAtW[] = {'c','h','a','r','C','o','d','e','A','t',0};
-static const WCHAR concatW[] = {'c','o','n','c','a','t',0};
-static const WCHAR fixedW[] = {'f','i','x','e','d',0};
-static const WCHAR fontcolorW[] = {'f','o','n','t','c','o','l','o','r',0};
-static const WCHAR fontsizeW[] = {'f','o','n','t','s','i','z','e',0};
-static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0};
-static const WCHAR italicsW[] = {'i','t','a','l','i','c','s',0};
-static const WCHAR lastIndexOfW[] = {'l','a','s','t','I','n','d','e','x','O','f',0};
-static const WCHAR linkW[] = {'l','i','n','k',0};
-static const WCHAR matchW[] = {'m','a','t','c','h',0};
-static const WCHAR replaceW[] = {'r','e','p','l','a','c','e',0};
-static const WCHAR searchW[] = {'s','e','a','r','c','h',0};
-static const WCHAR sliceW[] = {'s','l','i','c','e',0};
-static const WCHAR smallW[] = {'s','m','a','l','l',0};
-static const WCHAR splitW[] = {'s','p','l','i','t',0};
-static const WCHAR strikeW[] = {'s','t','r','i','k','e',0};
-static const WCHAR subW[] = {'s','u','b',0};
-static const WCHAR substringW[] = {'s','u','b','s','t','r','i','n','g',0};
-static const WCHAR substrW[] = {'s','u','b','s','t','r',0};
-static const WCHAR supW[] = {'s','u','p',0};
-static const WCHAR toLowerCaseW[] = {'t','o','L','o','w','e','r','C','a','s','e',0};
-static const WCHAR toUpperCaseW[] = {'t','o','U','p','p','e','r','C','a','s','e',0};
-static const WCHAR toLocaleLowerCaseW[] = {'t','o','L','o','c','a','l','e','L','o','w','e','r','C','a','s','e',0};
-static const WCHAR toLocaleUpperCaseW[] = {'t','o','L','o','c','a','l','e','U','p','p','e','r','C','a','s','e',0};
-static const WCHAR trimW[] = {'t','r','i','m',0};
-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)
+static inline StringInstance *string_this(jsval_t vthis)
 {
-    return string_from_jsdisp(vdisp->u.jsdisp);
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_STRING)) ? string_from_jsdisp(jsdisp) : NULL;
 }
 
-static inline StringInstance *string_this(vdisp_t *jsthis)
-{
-    return is_vclass(jsthis, JSCLASS_STRING) ? string_from_vdisp(jsthis) : NULL;
-}
-
-static HRESULT get_string_val(script_ctx_t *ctx, vdisp_t *jsthis, jsstr_t **val)
+static HRESULT get_string_val(script_ctx_t *ctx, jsval_t vthis, jsstr_t **val)
 {
     StringInstance *string;
 
-    if((string = string_this(jsthis))) {
+    if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5 && (is_undefined(vthis) || is_null(vthis)))
+        return JS_E_OBJECT_EXPECTED;
+
+    if((string = string_this(vthis))) {
         *val = jsstr_addref(string->str);
         return S_OK;
     }
 
-    return to_string(ctx, jsval_disp(jsthis->u.disp), val);
+    return to_string(ctx, vthis, val);
 }
 
-static HRESULT get_string_flat_val(script_ctx_t *ctx, vdisp_t *jsthis, jsstr_t **jsval, const WCHAR **val)
+static HRESULT get_string_flat_val(script_ctx_t *ctx, jsval_t vthis, jsstr_t **jsval, const WCHAR **val)
 {
     HRESULT hres;
 
-    hres = get_string_val(ctx, jsthis, jsval);
+    hres = get_string_val(ctx, vthis, jsval);
     if(FAILED(hres))
         return hres;
 
@@ -120,11 +83,11 @@ static HRESULT String_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r
     return S_OK;
 }
 
-static HRESULT stringobj_to_string(vdisp_t *jsthis, jsval_t *r)
+static HRESULT stringobj_to_string(jsval_t vthis, jsval_t *r)
 {
     StringInstance *string;
 
-    if(!(string = string_this(jsthis))) {
+    if(!(string = string_this(vthis))) {
         WARN("this is not a string object\n");
         return E_FAIL;
     }
@@ -135,31 +98,31 @@ static HRESULT stringobj_to_string(vdisp_t *jsthis, jsval_t *r)
 }
 
 /* ECMA-262 3rd Edition    15.5.4.2 */
-static HRESULT String_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
 
-    return stringobj_to_string(jsthis, r);
+    return stringobj_to_string(vthis, r);
 }
 
 /* ECMA-262 3rd Edition    15.5.4.2 */
-static HRESULT String_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_valueOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     TRACE("\n");
 
-    return stringobj_to_string(jsthis, r);
+    return stringobj_to_string(vthis, r);
 }
 
-static HRESULT do_attributeless_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t *r, const WCHAR *tagname)
+static HRESULT do_attributeless_tag_format(script_ctx_t *ctx, jsval_t vthis, jsval_t *r, const WCHAR *tagname)
 {
     unsigned tagname_len;
     jsstr_t *str, *ret;
     WCHAR *ptr;
     HRESULT hres;
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -194,13 +157,13 @@ static HRESULT do_attributeless_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, j
     return S_OK;
 }
 
-static HRESULT do_attribute_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, unsigned argc, jsval_t *argv, jsval_t *r,
+static HRESULT do_attribute_tag_format(script_ctx_t *ctx, jsval_t vthis, unsigned argc, jsval_t *argv, jsval_t *r,
         const WCHAR *tagname, const WCHAR *attrname)
 {
     jsstr_t *str, *attr_value = NULL;
     HRESULT hres;
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -252,38 +215,32 @@ static HRESULT do_attribute_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, unsig
     return hres;
 }
 
-static HRESULT String_anchor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_anchor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR fontW[] = {'A',0};
-    static const WCHAR colorW[] = {'N','A','M','E',0};
-
-    return do_attribute_tag_format(ctx, jsthis, argc, argv, r, fontW, colorW);
+    return do_attribute_tag_format(ctx, vthis, argc, argv, r, L"A", L"NAME");
 }
 
-static HRESULT String_big(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_big(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR bigtagW[] = {'B','I','G',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, bigtagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"BIG");
 }
 
-static HRESULT String_blink(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_blink(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR blinktagW[] = {'B','L','I','N','K',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, blinktagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"BLINK");
 }
 
-static HRESULT String_bold(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_bold(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR boldtagW[] = {'B',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, boldtagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"B");
 }
 
 /* ECMA-262 3rd Edition    15.5.4.5 */
-static HRESULT String_charAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_charAt(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *str, *ret;
@@ -292,7 +249,7 @@ static HRESULT String_charAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -325,7 +282,7 @@ static HRESULT String_charAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 }
 
 /* ECMA-262 3rd Edition    15.5.4.5 */
-static HRESULT String_charCodeAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_charCodeAt(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *str;
@@ -334,7 +291,7 @@ static HRESULT String_charCodeAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -368,7 +325,7 @@ static HRESULT String_charCodeAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 }
 
 /* ECMA-262 3rd Edition    15.5.4.6 */
-static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_concat(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsstr_t *ret = NULL, *str;
@@ -376,7 +333,7 @@ static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -405,7 +362,7 @@ static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
         jsstr_t **strs;
         WCHAR *ptr;
 
-        strs = heap_alloc_zero(str_cnt * sizeof(*strs));
+        strs = calloc(str_cnt, sizeof(*strs));
         if(!strs) {
             jsstr_release(str);
             return E_OUTOFMEMORY;
@@ -440,7 +397,7 @@ static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 
         while(i--)
             jsstr_release(strs[i]);
-        heap_free(strs);
+        free(strs);
         if(FAILED(hres))
             return hres;
     }
@@ -453,32 +410,25 @@ static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
     return S_OK;
 }
 
-static HRESULT String_fixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_fixed(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR fixedtagW[] = {'T','T',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, fixedtagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"TT");
 }
 
-static HRESULT String_fontcolor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_fontcolor(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR fontW[] = {'F','O','N','T',0};
-    static const WCHAR colorW[] = {'C','O','L','O','R',0};
-
-    return do_attribute_tag_format(ctx, jsthis, argc, argv, r, fontW, colorW);
+    return do_attribute_tag_format(ctx, vthis, argc, argv, r, L"FONT", L"COLOR");
 }
 
-static HRESULT String_fontsize(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_fontsize(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR fontW[] = {'F','O','N','T',0};
-    static const WCHAR colorW[] = {'S','I','Z','E',0};
-
-    return do_attribute_tag_format(ctx, jsthis, argc, argv, r, fontW, colorW);
+    return do_attribute_tag_format(ctx, vthis, argc, argv, r, L"FONT", L"SIZE");
 }
 
-static HRESULT String_indexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_indexOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     unsigned pos = 0, search_len, length;
@@ -489,7 +439,7 @@ static HRESULT String_indexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
 
     TRACE("\n");
 
-    hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
+    hres = get_string_flat_val(ctx, vthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
 
@@ -539,15 +489,14 @@ static HRESULT String_indexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
     return S_OK;
 }
 
-static HRESULT String_italics(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_italics(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR italicstagW[] = {'I',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, italicstagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"I");
 }
 
 /* ECMA-262 3rd Edition    15.5.4.8 */
-static HRESULT String_lastIndexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_lastIndexOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     unsigned pos = 0, search_len, length;
@@ -558,7 +507,7 @@ static HRESULT String_lastIndexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
 
     TRACE("\n");
 
-    hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
+    hres = get_string_flat_val(ctx, vthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
 
@@ -609,17 +558,14 @@ static HRESULT String_lastIndexOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     return S_OK;
 }
 
-static HRESULT String_link(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_link(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR fontW[] = {'A',0};
-    static const WCHAR colorW[] = {'H','R','E','F',0};
-
-    return do_attribute_tag_format(ctx, jsthis, argc, argv, r, fontW, colorW);
+    return do_attribute_tag_format(ctx, vthis, argc, argv, r, L"A", L"HREF");
 }
 
 /* ECMA-262 3rd Edition    15.5.4.10 */
-static HRESULT String_match(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_match(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsdisp_t *regexp = NULL;
@@ -655,7 +601,7 @@ static HRESULT String_match(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
             return hres;
     }
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(SUCCEEDED(hres))
         hres = regexp_string_match(ctx, regexp, str, r);
 
@@ -681,10 +627,7 @@ static BOOL strbuf_ensure_size(strbuf_t *buf, unsigned len)
     new_size = buf->size ? buf->size<<1 : 16;
     if(new_size < len)
         new_size = len;
-    if(buf->buf)
-        new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR));
-    else
-        new_buf = heap_alloc(new_size*sizeof(WCHAR));
+    new_buf = realloc(buf->buf, new_size * sizeof(WCHAR));
     if(!new_buf)
         return FALSE;
 
@@ -727,7 +670,7 @@ static HRESULT rep_call(script_ctx_t *ctx, jsdisp_t *func,
     HRESULT hres = S_OK;
 
     argc = match->paren_count+3;
-    argv = heap_alloc_zero(sizeof(*argv)*argc);
+    argv = calloc(argc, sizeof(*argv));
     if(!argv)
         return E_OUTOFMEMORY;
 
@@ -756,11 +699,11 @@ static HRESULT rep_call(script_ctx_t *ctx, jsdisp_t *func,
     }
 
     if(SUCCEEDED(hres))
-        hres = jsdisp_call_value(func, NULL, DISPATCH_METHOD, argc, argv, &val);
+        hres = jsdisp_call_value(func, jsval_undefined(), DISPATCH_METHOD, argc, argv, &val);
 
     for(i=0; i <= match->paren_count; i++)
         jsstr_release(get_string(argv[i]));
-    heap_free(argv);
+    free(argv);
 
     if(FAILED(hres))
         return hres;
@@ -771,7 +714,7 @@ static HRESULT rep_call(script_ctx_t *ctx, jsdisp_t *func,
 }
 
 /* ECMA-262 3rd Edition    15.5.4.11 */
-static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_replace(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     const WCHAR *str, *match_str = NULL, *rep_str = NULL;
@@ -785,7 +728,7 @@ static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
 
     TRACE("\n");
 
-    hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
+    hres = get_string_flat_val(ctx, vthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
 
@@ -904,14 +847,14 @@ static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
                     default: {
                         DWORD idx;
 
-                        if(!iswdigit(ptr2[1])) {
+                        if(!is_digit(ptr2[1])) {
                             hres = strbuf_append(&ret, ptr2, 1);
                             ptr = ptr2+1;
                             break;
                         }
 
                         idx = ptr2[1] - '0';
-                        if(iswdigit(ptr2[2]) && idx*10 + (ptr2[2]-'0') <= match->paren_count) {
+                        if(is_digit(ptr2[2]) && idx*10 + (ptr2[2]-'0') <= match->paren_count) {
                             idx = idx*10 + (ptr[2]-'0');
                             ptr = ptr2+3;
                         }else if(idx && idx <= match->paren_count) {
@@ -941,9 +884,7 @@ static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
                 if(FAILED(hres))
                     break;
             }else {
-                static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'};
-
-                hres = strbuf_append(&ret, undefinedW, ARRAY_SIZE(undefinedW));
+                hres = strbuf_append(&ret, L"undefined", ARRAY_SIZE(L"undefined")-1);
                 if(FAILED(hres))
                     break;
             }
@@ -965,7 +906,7 @@ static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
     if(match_str)
         jsstr_release(match_jsstr);
     if(regexp)
-        heap_free(match);
+        free(match);
 
     if(SUCCEEDED(hres) && last_match.cp && regexp) {
         jsstr_release(ctx->last_match);
@@ -982,18 +923,20 @@ static HRESULT String_replace(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, un
         jsstr_t *ret_str;
 
         ret_str = jsstr_alloc_len(ret.buf, ret.len);
-        if(!ret_str)
+        if(!ret_str) {
+            free(ret.buf);
             return E_OUTOFMEMORY;
+        }
 
         TRACE("= %s\n", debugstr_jsstr(ret_str));
         *r = jsval_string(ret_str);
     }
 
-    heap_free(ret.buf);
+    free(ret.buf);
     return hres;
 }
 
-static HRESULT String_search(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_search(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     jsdisp_t *regexp = NULL;
@@ -1004,7 +947,7 @@ static HRESULT String_search(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 
     TRACE("\n");
 
-    hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
+    hres = get_string_flat_val(ctx, vthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
 
@@ -1044,7 +987,7 @@ static HRESULT String_search(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 }
 
 /* ECMA-262 3rd Edition    15.5.4.13 */
-static HRESULT String_slice(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_slice(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     int start=0, end, length;
@@ -1054,7 +997,7 @@ static HRESULT String_slice(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -1120,14 +1063,13 @@ static HRESULT String_slice(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
     return S_OK;
 }
 
-static HRESULT String_small(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_small(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR smalltagW[] = {'S','M','A','L','L',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, smalltagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"SMALL");
 }
 
-static HRESULT String_split(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_split(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     match_state_t match_result, *match_ptr = &match_result;
@@ -1138,7 +1080,7 @@ static HRESULT String_split(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
     jsstr_t *jsstr, *match_jsstr, *tmp_str;
     HRESULT hres;
 
-    hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
+    hres = get_string_flat_val(ctx, vthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
     length = jsstr_length(jsstr);
@@ -1207,7 +1149,7 @@ static HRESULT String_split(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
                 hres = regexp_match_next(ctx, regexp, REM_NO_PARENS, jsstr, &match_ptr);
                 if(hres != S_OK)
                     break;
-                TRACE("got match %d %d\n", (int)(match_result.cp - match_result.match_len - str), match_result.match_len);
+                TRACE("got match %d %ld\n", (int)(match_result.cp - match_result.match_len - str), match_result.match_len);
                 if(!match_result.match_len) {
                     /* If an empty string is matched, prevent including any match in the result */
                     if(!length) {
@@ -1219,7 +1161,7 @@ static HRESULT String_split(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
                         hres = regexp_match_next(ctx, regexp, REM_NO_PARENS, jsstr, &match_ptr);
                         if(hres != S_OK)
                             break;
-                        TRACE("retried, got match %d %d\n", (int)(match_result.cp - match_result.match_len - str),
+                        TRACE("retried, got match %d %ld\n", (int)(match_result.cp - match_result.match_len - str),
                               match_result.match_len);
                     }
                     if(!match_result.match_len && match_result.cp == str + length)
@@ -1287,22 +1229,20 @@ static HRESULT String_split(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsi
     return hres;
 }
 
-static HRESULT String_strike(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_strike(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR striketagW[] = {'S','T','R','I','K','E',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, striketagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"STRIKE");
 }
 
-static HRESULT String_sub(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_sub(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR subtagW[] = {'S','U','B',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, subtagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"SUB");
 }
 
 /* ECMA-262 3rd Edition    15.5.4.15 */
-static HRESULT String_substring(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_substring(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     INT start=0, end, length;
@@ -1312,7 +1252,7 @@ static HRESULT String_substring(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -1361,7 +1301,7 @@ static HRESULT String_substring(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 }
 
 /* ECMA-262 3rd Edition    B.2.3 */
-static HRESULT String_substr(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_substr(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     int start=0, len, length;
@@ -1371,7 +1311,7 @@ static HRESULT String_substr(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
 
     TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -1415,54 +1355,19 @@ static HRESULT String_substr(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, uns
     return hres;
 }
 
-static HRESULT String_sup(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_sup(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    static const WCHAR suptagW[] = {'S','U','P',0};
-    return do_attributeless_tag_format(ctx, jsthis, r, suptagW);
+    return do_attributeless_tag_format(ctx, vthis, r, L"SUP");
 }
 
-static HRESULT String_toLowerCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
-        jsval_t *r)
-{
-    jsstr_t *str;
-    HRESULT  hres;
-
-    TRACE("\n");
-
-    hres = get_string_val(ctx, jsthis, &str);
-    if(FAILED(hres))
-        return hres;
-
-    if(r) {
-        unsigned len = jsstr_length(str);
-        jsstr_t *ret;
-        WCHAR *buf;
-
-        ret = jsstr_alloc_buf(len, &buf);
-        if(!ret) {
-            jsstr_release(str);
-            return E_OUTOFMEMORY;
-        }
-
-        jsstr_flush(str, buf);
-        for (; len--; buf++) *buf = towlower(*buf);
-
-        *r = jsval_string(ret);
-    }
-    jsstr_release(str);
-    return S_OK;
-}
-
-static HRESULT String_toUpperCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
-        jsval_t *r)
+static HRESULT to_upper_case(script_ctx_t *ctx, jsval_t vthis, jsval_t *r)
 {
     jsstr_t *str;
     HRESULT hres;
 
-    TRACE("\n");
 
-    hres = get_string_val(ctx, jsthis, &str);
+    hres = get_string_val(ctx, vthis, &str);
     if(FAILED(hres))
         return hres;
 
@@ -1486,21 +1391,65 @@ static HRESULT String_toUpperCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
     return S_OK;
 }
 
-static HRESULT String_toLocaleLowerCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
-        jsval_t *r)
+static HRESULT to_lower_case(script_ctx_t *ctx, jsval_t vthis, jsval_t *r)
 {
-    FIXME("\n");
-    return E_NOTIMPL;
+    jsstr_t *str;
+    HRESULT hres;
+
+
+    hres = get_string_val(ctx, vthis, &str);
+    if(FAILED(hres))
+        return hres;
+
+    if(r) {
+        unsigned len = jsstr_length(str);
+        jsstr_t *ret;
+        WCHAR *buf;
+
+        ret = jsstr_alloc_buf(len, &buf);
+        if(!ret) {
+            jsstr_release(str);
+            return E_OUTOFMEMORY;
+        }
+
+        jsstr_flush(str, buf);
+        for (; len--; buf++) *buf = towlower(*buf);
+
+        *r = jsval_string(ret);
+    }
+    jsstr_release(str);
+    return S_OK;
 }
 
-static HRESULT String_toLocaleUpperCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_toLowerCase(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    FIXME("\n");
-    return E_NOTIMPL;
+    TRACE("\n");
+    return to_lower_case(ctx, vthis, r);
 }
 
-static HRESULT String_trim(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc,
+static HRESULT String_toUpperCase(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    TRACE("\n");
+    return to_upper_case(ctx, vthis, r);
+}
+
+static HRESULT String_toLocaleLowerCase(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    TRACE("\n");
+    return to_lower_case(ctx, vthis, r);
+}
+
+static HRESULT String_toLocaleUpperCase(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    TRACE("\n");
+    return to_upper_case(ctx, vthis, r);
+}
+
+static HRESULT String_trim(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc,
         jsval_t *argv, jsval_t *r)
 {
     const WCHAR *str, *begin, *end;
@@ -1508,9 +1457,12 @@ static HRESULT String_trim(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
     unsigned len;
     HRESULT hres;
 
-    hres = to_flat_string(ctx, jsval_disp(jsthis->u.disp), &jsstr, &str);
+    if(is_undefined(vthis) || is_null(vthis))
+        return JS_E_OBJECT_EXPECTED;
+
+    hres = to_flat_string(ctx, vthis, &jsstr, &str);
     if(FAILED(hres)) {
-        WARN("to_flat_string failed: %08x\n", hres);
+        WARN("to_flat_string failed: %08lx\n", hres);
         return hres;
     }
     len = jsstr_length(jsstr);
@@ -1535,46 +1487,47 @@ static HRESULT String_trim(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsig
     return hres;
 }
 
-static HRESULT String_localeCompare(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT String_localeCompare(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     FIXME("\n");
     return E_NOTIMPL;
 }
 
-static HRESULT String_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
-{
-    StringInstance *This = string_from_jsdisp(jsthis);
-
-    TRACE("\n");
-
-    *r = jsval_string(jsstr_addref(This->str));
-    return S_OK;
-}
-
 static void String_destructor(jsdisp_t *dispex)
 {
     StringInstance *This = string_from_jsdisp(dispex);
 
     jsstr_release(This->str);
-    heap_free(This);
 }
 
-static unsigned String_idx_length(jsdisp_t *jsdisp)
+static HRESULT String_lookup_prop(jsdisp_t *jsdisp, const WCHAR *name, unsigned flags, struct property_info *desc)
 {
     StringInstance *string = string_from_jsdisp(jsdisp);
 
     /*
      * NOTE: For invoke version < 2, indexed array is not implemented at all.
      * Newer jscript.dll versions implement it on string type, not class,
-     * which is not how it should work according to spec. IE9 implements it
-     * properly, but it uses its own JavaScript engine inside MSHTML. We
-     * implement it here, but in the way IE9 and spec work.
+     * which is not how it should work according to spec. IE9+ implements it
+     * properly.
      */
-    return string->dispex.ctx->version < 2 ? 0 : jsstr_length(string->str);
+    if(string->dispex.ctx->version < 2)
+        return DISP_E_UNKNOWNNAME;
+
+    return jsdisp_index_lookup(&string->dispex, name, jsstr_length(string->str), desc);
 }
 
-static HRESULT String_idx_get(jsdisp_t *jsdisp, unsigned idx, jsval_t *r)
+static HRESULT String_next_prop(jsdisp_t *jsdisp, unsigned id, struct property_info *desc)
+{
+    StringInstance *string = string_from_jsdisp(jsdisp);
+
+    if(string->dispex.ctx->version < 2)
+        return S_FALSE;
+
+    return jsdisp_next_index(&string->dispex, jsstr_length(string->str), id, desc);
+}
+
+static HRESULT String_prop_get(jsdisp_t *jsdisp, unsigned idx, jsval_t *r)
 {
     StringInstance *string = string_from_jsdisp(jsdisp);
     jsstr_t *ret;
@@ -1590,72 +1543,69 @@ static HRESULT String_idx_get(jsdisp_t *jsdisp, unsigned idx, jsval_t *r)
 }
 
 static const builtin_prop_t String_props[] = {
-    {anchorW,                String_anchor,                PROPF_METHOD|1},
-    {bigW,                   String_big,                   PROPF_METHOD},
-    {blinkW,                 String_blink,                 PROPF_METHOD},
-    {boldW,                  String_bold,                  PROPF_METHOD},
-    {charAtW,                String_charAt,                PROPF_METHOD|1},
-    {charCodeAtW,            String_charCodeAt,            PROPF_METHOD|1},
-    {concatW,                String_concat,                PROPF_METHOD|1},
-    {fixedW,                 String_fixed,                 PROPF_METHOD},
-    {fontcolorW,             String_fontcolor,             PROPF_METHOD|1},
-    {fontsizeW,              String_fontsize,              PROPF_METHOD|1},
-    {indexOfW,               String_indexOf,               PROPF_METHOD|2},
-    {italicsW,               String_italics,               PROPF_METHOD},
-    {lastIndexOfW,           String_lastIndexOf,           PROPF_METHOD|2},
-    {lengthW,                NULL,0,                       String_get_length},
-    {linkW,                  String_link,                  PROPF_METHOD|1},
-    {localeCompareW,         String_localeCompare,         PROPF_METHOD|1},
-    {matchW,                 String_match,                 PROPF_METHOD|1},
-    {replaceW,               String_replace,               PROPF_METHOD|1},
-    {searchW,                String_search,                PROPF_METHOD},
-    {sliceW,                 String_slice,                 PROPF_METHOD},
-    {smallW,                 String_small,                 PROPF_METHOD},
-    {splitW,                 String_split,                 PROPF_METHOD|2},
-    {strikeW,                String_strike,                PROPF_METHOD},
-    {subW,                   String_sub,                   PROPF_METHOD},
-    {substrW,                String_substr,                PROPF_METHOD|2},
-    {substringW,             String_substring,             PROPF_METHOD|2},
-    {supW,                   String_sup,                   PROPF_METHOD},
-    {toLocaleLowerCaseW,     String_toLocaleLowerCase,     PROPF_METHOD},
-    {toLocaleUpperCaseW,     String_toLocaleUpperCase,     PROPF_METHOD},
-    {toLowerCaseW,           String_toLowerCase,           PROPF_METHOD},
-    {toStringW,              String_toString,              PROPF_METHOD},
-    {toUpperCaseW,           String_toUpperCase,           PROPF_METHOD},
-    {trimW,                  String_trim,                  PROPF_ES5|PROPF_METHOD},
-    {valueOfW,               String_valueOf,               PROPF_METHOD}
+    {L"anchor",                String_anchor,                PROPF_METHOD|1},
+    {L"big",                   String_big,                   PROPF_METHOD},
+    {L"blink",                 String_blink,                 PROPF_METHOD},
+    {L"bold",                  String_bold,                  PROPF_METHOD},
+    {L"charAt",                String_charAt,                PROPF_METHOD|1},
+    {L"charCodeAt",            String_charCodeAt,            PROPF_METHOD|1},
+    {L"concat",                String_concat,                PROPF_METHOD|1},
+    {L"fixed",                 String_fixed,                 PROPF_METHOD},
+    {L"fontcolor",             String_fontcolor,             PROPF_METHOD|1},
+    {L"fontsize",              String_fontsize,              PROPF_METHOD|1},
+    {L"indexOf",               String_indexOf,               PROPF_METHOD|2},
+    {L"italics",               String_italics,               PROPF_METHOD},
+    {L"lastIndexOf",           String_lastIndexOf,           PROPF_METHOD|2},
+    {L"length",                NULL,0,                       String_get_length},
+    {L"link",                  String_link,                  PROPF_METHOD|1},
+    {L"localeCompare",         String_localeCompare,         PROPF_METHOD|1},
+    {L"match",                 String_match,                 PROPF_METHOD|1},
+    {L"replace",               String_replace,               PROPF_METHOD|1},
+    {L"search",                String_search,                PROPF_METHOD},
+    {L"slice",                 String_slice,                 PROPF_METHOD},
+    {L"small",                 String_small,                 PROPF_METHOD},
+    {L"split",                 String_split,                 PROPF_METHOD|2},
+    {L"strike",                String_strike,                PROPF_METHOD},
+    {L"sub",                   String_sub,                   PROPF_METHOD},
+    {L"substr",                String_substr,                PROPF_METHOD|2},
+    {L"substring",             String_substring,             PROPF_METHOD|2},
+    {L"sup",                   String_sup,                   PROPF_METHOD},
+    {L"toLocaleLowerCase",     String_toLocaleLowerCase,     PROPF_METHOD},
+    {L"toLocaleUpperCase",     String_toLocaleUpperCase,     PROPF_METHOD},
+    {L"toLowerCase",           String_toLowerCase,           PROPF_METHOD},
+    {L"toString",              String_toString,              PROPF_METHOD},
+    {L"toUpperCase",           String_toUpperCase,           PROPF_METHOD},
+    {L"trim",                  String_trim,                  PROPF_ES5|PROPF_METHOD},
+    {L"valueOf",               String_valueOf,               PROPF_METHOD}
 };
 
 static const builtin_info_t String_info = {
-    JSCLASS_STRING,
-    {NULL, NULL,0, String_get_value},
-    ARRAY_SIZE(String_props),
-    String_props,
-    String_destructor,
-    NULL
+    .class      = JSCLASS_STRING,
+    .props_cnt  = ARRAY_SIZE(String_props),
+    .props      = String_props,
+    .destructor = String_destructor,
 };
 
 static const builtin_prop_t StringInst_props[] = {
-    {lengthW,                NULL,0,                       String_get_length}
+    {L"length",                NULL,0,                       String_get_length}
 };
 
 static const builtin_info_t StringInst_info = {
-    JSCLASS_STRING,
-    {NULL, NULL,0, String_get_value},
-    ARRAY_SIZE(StringInst_props),
-    StringInst_props,
-    String_destructor,
-    NULL,
-    String_idx_length,
-    String_idx_get
+    .class       = JSCLASS_STRING,
+    .props_cnt   = ARRAY_SIZE(StringInst_props),
+    .props       = StringInst_props,
+    .destructor  = String_destructor,
+    .lookup_prop = String_lookup_prop,
+    .next_prop   = String_next_prop,
+    .prop_get    = String_prop_get,
 };
 
 /* ECMA-262 3rd Edition    15.5.3.2 */
-static HRESULT StringConstr_fromCharCode(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+static HRESULT StringConstr_fromCharCode(script_ctx_t *ctx, jsval_t vthis, WORD flags,
         unsigned argc, jsval_t *argv, jsval_t *r)
 {
     WCHAR *ret_str;
-    DWORD i, code;
+    UINT32 i, code;
     jsstr_t *ret;
     HRESULT hres;
 
@@ -1682,10 +1632,10 @@ static HRESULT StringConstr_fromCharCode(script_ctx_t *ctx, vdisp_t *jsthis, WOR
     return S_OK;
 }
 
-static HRESULT StringConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT StringConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    HRESULT hres;
+    HRESULT hres = S_OK;
 
     TRACE("\n");
 
@@ -1701,7 +1651,8 @@ static HRESULT StringConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
             str = jsstr_empty();
         }
 
-        *r = jsval_string(str);
+        if(r) *r = jsval_string(str);
+        else  jsstr_release(str);
         break;
     }
     case DISPATCH_CONSTRUCT: {
@@ -1716,8 +1667,10 @@ static HRESULT StringConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags
             str = jsstr_empty();
         }
 
-        hres = create_string(ctx, str, &ret);
-        if (SUCCEEDED(hres)) *r = jsval_obj(ret);
+        if(r) {
+            hres = create_string(ctx, str, &ret);
+            if(SUCCEEDED(hres)) *r = jsval_obj(ret);
+        }
         jsstr_release(str);
         return hres;
     }
@@ -1735,7 +1688,7 @@ static HRESULT string_alloc(script_ctx_t *ctx, jsdisp_t *object_prototype, jsstr
     StringInstance *string;
     HRESULT hres;
 
-    string = heap_alloc_zero(sizeof(StringInstance));
+    string = calloc(1, sizeof(StringInstance));
     if(!string)
         return E_OUTOFMEMORY;
 
@@ -1744,7 +1697,7 @@ static HRESULT string_alloc(script_ctx_t *ctx, jsdisp_t *object_prototype, jsstr
     else
         hres = init_dispex_from_constr(&string->dispex, ctx, &StringInst_info, ctx->string_constr);
     if(FAILED(hres)) {
-        heap_free(string);
+        free(string);
         return hres;
     }
 
@@ -1754,16 +1707,14 @@ static HRESULT string_alloc(script_ctx_t *ctx, jsdisp_t *object_prototype, jsstr
 }
 
 static const builtin_prop_t StringConstr_props[] = {
-    {fromCharCodeW,    StringConstr_fromCharCode,    PROPF_METHOD},
+    {L"fromCharCode",    StringConstr_fromCharCode,    PROPF_METHOD},
 };
 
 static const builtin_info_t StringConstr_info = {
-    JSCLASS_FUNCTION,
-    DEFAULT_FUNCTION_VALUE,
-    ARRAY_SIZE(StringConstr_props),
-    StringConstr_props,
-    NULL,
-    NULL
+    .class     = JSCLASS_FUNCTION,
+    .call      = Function_value,
+    .props_cnt = ARRAY_SIZE(StringConstr_props),
+    .props     = StringConstr_props,
 };
 
 HRESULT create_string_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
@@ -1771,13 +1722,11 @@ HRESULT create_string_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdi
     StringInstance *string;
     HRESULT hres;
 
-    static const WCHAR StringW[] = {'S','t','r','i','n','g',0};
-
     hres = string_alloc(ctx, object_prototype, jsstr_empty(), &string);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_constructor(ctx, StringConstr_value, StringW, &StringConstr_info,
+    hres = create_builtin_constructor(ctx, StringConstr_value, L"String", &StringConstr_info,
             PROPF_CONSTR|1, &string->dispex, ret);
 
     jsdisp_release(&string->dispex);

dll/win32/jscript/vbarray.c

@@ -28,28 +28,18 @@ typedef struct {
     SAFEARRAY *safearray;
 } VBArrayInstance;
 
-static const WCHAR dimensionsW[] = {'d','i','m','e','n','s','i','o','n','s',0};
-static const WCHAR getItemW[] = {'g','e','t','I','t','e','m',0};
-static const WCHAR lboundW[] = {'l','b','o','u','n','d',0};
-static const WCHAR toArrayW[] = {'t','o','A','r','r','a','y',0};
-static const WCHAR uboundW[] = {'u','b','o','u','n','d',0};
-
 static inline VBArrayInstance *vbarray_from_jsdisp(jsdisp_t *jsdisp)
 {
     return CONTAINING_RECORD(jsdisp, VBArrayInstance, dispex);
 }
 
-static inline VBArrayInstance *vbarray_from_vdisp(vdisp_t *vdisp)
+static inline VBArrayInstance *vbarray_this(jsval_t vthis)
 {
-    return vbarray_from_jsdisp(vdisp->u.jsdisp);
+    jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
+    return (jsdisp && is_class(jsdisp, JSCLASS_VBARRAY)) ? vbarray_from_jsdisp(jsdisp) : NULL;
 }
 
-static inline VBArrayInstance *vbarray_this(vdisp_t *jsthis)
-{
-    return is_vclass(jsthis, JSCLASS_VBARRAY) ? vbarray_from_vdisp(jsthis) : NULL;
-}
-
-static HRESULT VBArray_dimensions(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_dimensions(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
@@ -58,18 +48,19 @@ static HRESULT VBArray_dimensions(script_ctx_t *ctx, vdisp_t *vthis, WORD flags,
 
     vbarray = vbarray_this(vthis);
     if(!vbarray)
-        return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+        return JS_E_VBARRAY_EXPECTED;
 
     if(r)
         *r = jsval_number(SafeArrayGetDim(vbarray->safearray));
     return S_OK;
 }
 
-static HRESULT VBArray_getItem(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_getItem(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
-    int i, *indexes;
+    unsigned i;
+    LONG *indexes;
     VARIANT out;
     HRESULT hres;
 
@@ -77,52 +68,52 @@ static HRESULT VBArray_getItem(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, un
 
     vbarray = vbarray_this(vthis);
     if(!vbarray)
-        return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+        return JS_E_VBARRAY_EXPECTED;
 
     if(argc < SafeArrayGetDim(vbarray->safearray))
-        return throw_range_error(ctx, JS_E_SUBSCRIPT_OUT_OF_RANGE, NULL);
+        return JS_E_SUBSCRIPT_OUT_OF_RANGE;
 
-    indexes = heap_alloc(sizeof(int)*argc);
+    indexes = malloc(sizeof(indexes[0])*argc);
     if(!indexes)
         return E_OUTOFMEMORY;
 
     for(i=0; i<argc; i++) {
-        hres = to_int32(ctx, argv[i], indexes+i);
+        hres = to_long(ctx, argv[i], indexes + i);
         if(FAILED(hres)) {
-            heap_free(indexes);
+            free(indexes);
             return hres;
         }
     }
 
     hres = SafeArrayGetElement(vbarray->safearray, indexes, (void*)&out);
-    heap_free(indexes);
+    free(indexes);
     if(hres == DISP_E_BADINDEX)
-        return throw_range_error(ctx, JS_E_SUBSCRIPT_OUT_OF_RANGE, NULL);
+        return JS_E_SUBSCRIPT_OUT_OF_RANGE;
     else if(FAILED(hres))
         return hres;
 
     if(r) {
-        hres = variant_to_jsval(&out, r);
+        hres = variant_to_jsval(ctx, &out, r);
         VariantClear(&out);
     }
     return hres;
 }
 
-static HRESULT VBArray_lbound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_lbound(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
-    int dim;
+    LONG dim;
     HRESULT hres;
 
     TRACE("\n");
 
     vbarray = vbarray_this(vthis);
     if(!vbarray)
-        return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+        return JS_E_VBARRAY_EXPECTED;
 
     if(argc) {
-        hres = to_int32(ctx, argv[0], &dim);
+        hres = to_long(ctx, argv[0], &dim);
         if(FAILED(hres))
             return hres;
     } else
@@ -130,7 +121,7 @@ static HRESULT VBArray_lbound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, uns
 
     hres = SafeArrayGetLBound(vbarray->safearray, dim, &dim);
     if(hres == DISP_E_BADINDEX)
-        return throw_range_error(ctx, JS_E_SUBSCRIPT_OUT_OF_RANGE, NULL);
+        return JS_E_SUBSCRIPT_OUT_OF_RANGE;
     else if(FAILED(hres))
         return hres;
 
@@ -139,21 +130,21 @@ static HRESULT VBArray_lbound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, uns
     return S_OK;
 }
 
-static HRESULT VBArray_toArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_toArray(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
     jsdisp_t *array;
     jsval_t val;
     VARIANT *v;
-    int i, size = 1, ubound, lbound;
+    LONG i, size = 1, ubound, lbound;
     HRESULT hres;
 
     TRACE("\n");
 
     vbarray = vbarray_this(vthis);
     if(!vbarray)
-        return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+        return JS_E_VBARRAY_EXPECTED;
 
     for(i=1; i<=SafeArrayGetDim(vbarray->safearray); i++) {
         SafeArrayGetLBound(vbarray->safearray, i, &lbound);
@@ -172,7 +163,7 @@ static HRESULT VBArray_toArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, un
     }
 
     for(i=0; i<size; i++) {
-        hres = variant_to_jsval(v, &val);
+        hres = variant_to_jsval(ctx, v, &val);
         if(SUCCEEDED(hres)) {
             hres = jsdisp_propput_idx(array, i, val);
             jsval_release(val);
@@ -194,21 +185,21 @@ static HRESULT VBArray_toArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, un
     return S_OK;
 }
 
-static HRESULT VBArray_ubound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_ubound(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
-    int dim;
+    LONG dim;
     HRESULT hres;
 
     TRACE("\n");
 
     vbarray = vbarray_this(vthis);
     if(!vbarray)
-        return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+        return JS_E_VBARRAY_EXPECTED;
 
     if(argc) {
-        hres = to_int32(ctx, argv[0], &dim);
+        hres = to_long(ctx, argv[0], &dim);
         if(FAILED(hres))
             return hres;
     } else
@@ -216,7 +207,7 @@ static HRESULT VBArray_ubound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, uns
 
     hres = SafeArrayGetUBound(vbarray->safearray, dim, &dim);
     if(hres == DISP_E_BADINDEX)
-        return throw_range_error(ctx, JS_E_SUBSCRIPT_OUT_OF_RANGE, NULL);
+        return JS_E_SUBSCRIPT_OUT_OF_RANGE;
     else if(FAILED(hres))
         return hres;
 
@@ -225,7 +216,7 @@ static HRESULT VBArray_ubound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, uns
     return S_OK;
 }
 
-static HRESULT VBArray_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArray_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     FIXME("\n");
@@ -244,24 +235,22 @@ static void VBArray_destructor(jsdisp_t *dispex)
     VBArrayInstance *vbarray = vbarray_from_jsdisp(dispex);
 
     SafeArrayDestroy(vbarray->safearray);
-    heap_free(vbarray);
 }
 
 static const builtin_prop_t VBArray_props[] = {
-    {dimensionsW,           VBArray_dimensions,         PROPF_METHOD},
-    {getItemW,              VBArray_getItem,            PROPF_METHOD|1},
-    {lboundW,               VBArray_lbound,             PROPF_METHOD},
-    {toArrayW,              VBArray_toArray,            PROPF_METHOD},
-    {uboundW,               VBArray_ubound,             PROPF_METHOD}
+    {L"dimensions",         VBArray_dimensions,         PROPF_METHOD},
+    {L"getItem",            VBArray_getItem,            PROPF_METHOD|1},
+    {L"lbound",             VBArray_lbound,             PROPF_METHOD},
+    {L"toArray",            VBArray_toArray,            PROPF_METHOD},
+    {L"ubound",             VBArray_ubound,             PROPF_METHOD}
 };
 
 static const builtin_info_t VBArray_info = {
-    JSCLASS_VBARRAY,
-    {NULL, VBArray_value, 0},
-    ARRAY_SIZE(VBArray_props),
-    VBArray_props,
-    VBArray_destructor,
-    NULL
+    .class      = JSCLASS_VBARRAY,
+    .call       = VBArray_value,
+    .props_cnt  = ARRAY_SIZE(VBArray_props),
+    .props      = VBArray_props,
+    .destructor = VBArray_destructor,
 };
 
 static HRESULT alloc_vbarray(script_ctx_t *ctx, jsdisp_t *object_prototype, VBArrayInstance **ret)
@@ -269,7 +258,7 @@ static HRESULT alloc_vbarray(script_ctx_t *ctx, jsdisp_t *object_prototype, VBAr
     VBArrayInstance *vbarray;
     HRESULT hres;
 
-    vbarray = heap_alloc_zero(sizeof(VBArrayInstance));
+    vbarray = calloc(1, sizeof(VBArrayInstance));
     if(!vbarray)
         return E_OUTOFMEMORY;
 
@@ -279,7 +268,7 @@ static HRESULT alloc_vbarray(script_ctx_t *ctx, jsdisp_t *object_prototype, VBAr
         hres = init_dispex_from_constr(&vbarray->dispex, ctx, &VBArray_info, ctx->vbarray_constr);
 
     if(FAILED(hres)) {
-        heap_free(vbarray);
+        free(vbarray);
         return hres;
     }
 
@@ -287,7 +276,7 @@ static HRESULT alloc_vbarray(script_ctx_t *ctx, jsdisp_t *object_prototype, VBAr
     return S_OK;
 }
 
-static HRESULT VBArrayConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
+static HRESULT VBArrayConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
     VBArrayInstance *vbarray;
@@ -298,13 +287,15 @@ static HRESULT VBArrayConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags
     switch(flags) {
     case DISPATCH_METHOD:
         if(argc<1 || !is_variant(argv[0]) || V_VT(get_variant(argv[0])) != (VT_ARRAY|VT_VARIANT))
-            return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+            return JS_E_VBARRAY_EXPECTED;
 
-        return jsval_copy(argv[0], r);
+        return r ? jsval_copy(argv[0], r) : S_OK;
 
     case DISPATCH_CONSTRUCT:
         if(argc<1 || !is_variant(argv[0]) || V_VT(get_variant(argv[0])) != (VT_ARRAY|VT_VARIANT))
-            return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
+            return JS_E_VBARRAY_EXPECTED;
+        if(!r)
+            return S_OK;
 
         hres = alloc_vbarray(ctx, NULL, &vbarray);
         if(FAILED(hres))
@@ -332,13 +323,11 @@ HRESULT create_vbarray_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsd
     VBArrayInstance *vbarray;
     HRESULT hres;
 
-    static const WCHAR VBArrayW[] = {'V','B','A','r','r','a','y',0};
-
     hres = alloc_vbarray(ctx, object_prototype, &vbarray);
     if(FAILED(hres))
         return hres;
 
-    hres = create_builtin_constructor(ctx, VBArrayConstr_value, VBArrayW, NULL, PROPF_CONSTR|1, &vbarray->dispex, ret);
+    hres = create_builtin_constructor(ctx, VBArrayConstr_value, L"VBArray", NULL, PROPF_CONSTR|1, &vbarray->dispex, ret);
 
     jsdisp_release(&vbarray->dispex);
     return hres;

media/doc/WINESYNC.txt

@@ -98,7 +98,7 @@ dll/win32/inseng              # Synced to WineStaging-4.18
 dll/win32/iphlpapi            # Out of sync
 dll/win32/itircl              # Synced to WineStaging-4.18
 dll/win32/itss                # Synced to WineStaging-4.18
-dll/win32/jscript             # Synced to WineStaging-4.18
+dll/win32/jscript             # Synced to Wine-10.0
 dll/win32/jsproxy             # Synced to WineStaging-4.18
 dll/win32/loadperf            # Synced to WineStaging-4.18
 dll/win32/lz32                # Synced to WineStaging-3.3