[JSCRIPT] Sync with Wine Staging 4.18. CORE-16441

dll/win32/jscript/activex.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
 
 #include "jscript.h"
 #include "objsafe.h"

dll/win32/jscript/array.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 #include <assert.h>
···
 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
 static const WCHAR unshiftW[] = {'u','n','s','h','i','f','t',0};
 static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0};
+static const WCHAR mapW[] = {'m','a','p',0};
 
 static const WCHAR default_separatorW[] = {',',0};
 
···
 
         jsstr_release(sep_str);
     }else {
-        hres = array_join(ctx, jsthis, length, default_separatorW, strlenW(default_separatorW), r);
+        hres = array_join(ctx, jsthis, length, default_separatorW, lstrlenW(default_separatorW), r);
     }
 
     return hres;
···
         return throw_type_error(ctx, JS_E_ARRAY_EXPECTED, NULL);
 
     return array_join(ctx, &array->dispex, array->length, default_separatorW,
-                      strlenW(default_separatorW), r);
+                      lstrlenW(default_separatorW), r);
 }
 
 static HRESULT Array_toLocaleString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
···
 
     TRACE("\n");
 
-    /* FIXME: Check IsCallable */
-    if(argc != 1 || !is_object_instance(argv[0])) {
-        FIXME("Unsupported arguments\n");
-        return E_NOTIMPL;
-    }
-
     hres = get_length(ctx, vthis, &jsthis, &length);
     if(FAILED(hres))
         return hres;
+
+    /* Fixme check IsCallable */
+    if(!argc || !is_object_instance(argv[0]) || !get_object(argv[0])) {
+        FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
+        return E_INVALIDARG;
+    }
+
+    if(argc > 1 && !is_undefined(argv[1])) {
+        FIXME("Unsupported context this %s\n", debugstr_jsval(argv[1]));
+        return E_NOTIMPL;
+    }
 
     for(i = 0; i < length; i++) {
         hres = jsdisp_get_idx(jsthis, i, &value);
···
     return S_OK;
 }
 
+static HRESULT Array_map(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    IDispatch *context_this = NULL, *callback;
+    jsval_t callback_args[3], mapped_value;
+    jsdisp_t *jsthis, *array;
+    DWORD length, k;
+    HRESULT hres;
+
+    TRACE("\n");
+
+    hres = get_length(ctx, vthis, &jsthis, &length);
+    if(FAILED(hres)) {
+        FIXME("Could not get length\n");
+        return hres;
+    }
+
+    /* Fixme check IsCallable */
+    if(!argc || !is_object_instance(argv[0]) || !get_object(argv[0])) {
+        FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
+        return E_INVALIDARG;
+    }
+    callback = get_object(argv[0]);
+
+    if(argc > 1) {
+        if(is_object_instance(argv[1]) && get_object(argv[1])) {
+            context_this = get_object(argv[1]);
+        }else if(!is_undefined(argv[1])) {
+            FIXME("Unsupported context this %s\n", debugstr_jsval(argv[1]));
+            return E_NOTIMPL;
+        }
+    }
+
+    hres = create_array(ctx, length, &array);
+    if(FAILED(hres))
+        return hres;
+
+    for(k = 0; k < length; k++) {
+        hres = jsdisp_get_idx(jsthis, k, &callback_args[0]);
+        if(hres == DISP_E_UNKNOWNNAME)
+            continue;
+        if(FAILED(hres))
+            break;
+
+        callback_args[1] = jsval_number(k);
+        callback_args[2] = jsval_obj(jsthis);
+        hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, 3, callback_args, &mapped_value);
+        jsval_release(callback_args[0]);
+        if(FAILED(hres))
+            break;
+
+        hres = jsdisp_propput_idx(array, k, mapped_value);
+        if(FAILED(hres))
+            break;
+    }
+
+    if(SUCCEEDED(hres) && r)
+        *r = jsval_obj(array);
+    else
+        jsdisp_release(array);
+    return hres;
+}
+
 /* ECMA-262 3rd Edition    15.4.4.13 */
 static HRESULT Array_unshift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
···
     TRACE("\n");
 
     return array_join(ctx, &array->dispex, array->length, default_separatorW,
-                      strlenW(default_separatorW), r);
+                      lstrlenW(default_separatorW), r);
 }
 
 static void Array_destructor(jsdisp_t *dispex)
···
     const WCHAR *ptr = name;
     DWORD id = 0;
 
-    if(!isdigitW(*ptr))
+    if(!iswdigit(*ptr))
         return;
 
-    while(*ptr && isdigitW(*ptr)) {
+    while(*ptr && iswdigit(*ptr)) {
         id = id*10 + (*ptr-'0');
         ptr++;
     }
···
     {indexOfW,               Array_indexOf,              PROPF_METHOD|PROPF_ES5|1},
     {joinW,                  Array_join,                 PROPF_METHOD|1},
     {lengthW,                NULL,0,                     Array_get_length, Array_set_length},
+    {mapW,                   Array_map,                  PROPF_METHOD|PROPF_ES5|1},
     {popW,                   Array_pop,                  PROPF_METHOD},
     {pushW,                  Array_push,                 PROPF_METHOD|1},
     {reverseW,               Array_reverse,              PROPF_METHOD},

dll/win32/jscript/cc_parser.tab.c

···
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.4.1.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
···
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+
 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.0"
+#define YYBISON_VERSION "3.4.1"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
···
 #define yynerrs         cc_parser_nerrs
 
 
-/* Copy the first part of user declarations.  */
-#line 19 "cc_parser.y" /* yacc.c:339  */
+/* First part of user prologue.  */
+#line 19 "cc_parser.y"
 
 
 #include "jscript.h"
···
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
 
-#line 84 "cc_parser.tab.c" /* yacc.c:339  */
+#line 88 "cc_parser.tab.c"
 
-# ifndef YY_NULL
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
 #  else
-#   define YY_NULL 0
+#   define YY_NULLPTR ((void*)0)
 #  endif
 # endif
 
···
 # define YYERROR_VERBOSE 0
 #endif
 
-/* In a future release of Bison, this section will be replaced
-   by #include "cc_parser.tab.h".  */
+/* Use api.header.include to #include this header
+   instead of duplicating it here.  */
 #ifndef YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED
 # define YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED
 /* Debug traces.  */
···
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
 union YYSTYPE
 {
-#line 36 "cc_parser.y" /* yacc.c:355  */
+#line 36 "cc_parser.y"
 
     ccval_t ccval;
 
-#line 143 "cc_parser.tab.c" /* yacc.c:355  */
+#line 150 "cc_parser.tab.c"
+
 };
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif
···
 
 #endif /* !YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED  */
 
-/* Copy the second part of user declarations.  */
-#line 47 "cc_parser.y" /* yacc.c:358  */
+/* Second part of user prologue.  */
+#line 47 "cc_parser.y"
 
 
 static int cc_parser_error(parser_ctx_t *ctx, const char *str)
···
 }
 
 
-#line 250 "cc_parser.tab.c" /* yacc.c:358  */
+#line 259 "cc_parser.tab.c"
+
 
 #ifdef short
 # undef short
···
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else
-typedef unsigned short int yytype_uint16;
+typedef unsigned short yytype_uint16;
 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else
-typedef short int yytype_int16;
+typedef short yytype_int16;
 #endif
 
 #ifndef YYSIZE_T
···
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else
-#  define YYSIZE_T unsigned int
+#  define YYSIZE_T unsigned
 # endif
 #endif
 
···
 # endif
 #endif
 
-#ifndef __attribute__
-/* This feature is available in gcc versions 2.5 and later.  */
-# if (! defined __GNUC__ || __GNUC__ < 2 \
-      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
-#  define __attribute__(Spec) /* empty */
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
 # endif
 #endif
 
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
···
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
···
 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 #endif
 
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
 
 #if ! defined yyoverflow || YYERROR_VERBOSE
 
···
 /* YYNSTATES -- Number of states.  */
 #define YYNSTATES  69
 
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
-   by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   269
 
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
 #define YYTRANSLATE(YYX)                                                \
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, without out-of-bounds checking.  */
+   as returned by yylex.  */
 static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
···
   "CCBitwiseORExpression", "CCBitwiseXORExpression",
   "CCBitwiseANDExpression", "CCEqualityExpression",
   "CCRelationalExpression", "CCShiftExpression", "CCAdditiveExpression",
-  "CCMultiplicativeExpression", YY_NULL
+  "CCMultiplicativeExpression", YY_NULLPTR
 };
 #endif
 
···
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
-      yyerror (ctx, YY_("syntax error: cannot back up")); \
-      YYERROR;                                                  \
-    }                                                           \
-while (0)
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (ctx, YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
 
 /* Error token number */
 #define YYTERROR        1
···
 } while (0)
 
 
-/*----------------------------------------.
-| Print this symbol's value on YYOUTPUT.  |
-`----------------------------------------*/
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
 
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
+  FILE *yyoutput = yyo;
+  YYUSE (yyoutput);
   YYUSE (ctx);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
 # endif
   YYUSE (yytype);
 }
 
 
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
 
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
 {
-  YYFPRINTF (yyoutput, "%s %s (",
+  YYFPRINTF (yyo, "%s %s (",
              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, ctx);
-  YYFPRINTF (yyoutput, ")");
+  yy_symbol_value_print (yyo, yytype, yyvaluep, ctx);
+  YYFPRINTF (yyo, ")");
 }
 
 /*------------------------------------------------------------------.
···
 static void
 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parser_ctx_t *ctx)
 {
-  unsigned long int yylno = yyrline[yyrule];
+  unsigned long yylno = yyrline[yyrule];
   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
···
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr,
                        yystos[yyssp[yyi + 1 - yynrhs]],
-                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                       &yyvsp[(yyi + 1) - (yynrhs)]
                                               , ctx);
       YYFPRINTF (stderr, "\n");
     }
···
           case '\\':
             if (*++yyp != '\\')
               goto do_not_strip_quotes;
-            /* Fall through.  */
+            else
+              goto append;
+
+          append:
           default:
             if (yyres)
               yyres[yyn] = *yyp;
···
   if (! yyres)
     return yystrlen (yystr);
 
-  return yystpcpy (yyres, yystr) - yyres;
+  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
 }
 # endif
 
···
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
+  const char *yyformat = YY_NULLPTR;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
···
                   }
                 yyarg[yycount++] = yytname[yyx];
                 {
-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+                    yysize = yysize1;
+                  else
                     return 2;
-                  yysize = yysize1;
                 }
               }
         }
···
       case N:                               \
         yyformat = S;                       \
       break
+    default: /* Avoid compiler warnings. */
       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
···
 
   {
     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+      yysize = yysize1;
+    else
       return 2;
-    yysize = yysize1;
   }
 
   if (*yymsg_alloc < yysize)
···
   yychar = YYEMPTY; /* Cause a token to be read.  */
   goto yysetstate;
 
+
 /*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
+| yynewstate -- push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
- yynewstate:
+yynewstate:
   /* In all cases, when you get here, the value and location stacks
      have just been pushed.  So pushing a state here evens the stacks.  */
   yyssp++;
 
- yysetstate:
-  *yyssp = yystate;
+
+/*--------------------------------------------------------------------.
+| yynewstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  *yyssp = (yytype_int16) yystate;
 
   if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    goto yyexhaustedlab;
+#else
     {
       /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
+      YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
 
-#ifdef yyoverflow
+# if defined yyoverflow
       {
         /* Give user a chance to reallocate the stack.  Use copies of
            these so that the &'s don't force the real ones into
···
                     &yyss1, yysize * sizeof (*yyssp),
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yystacksize);
-
         yyss = yyss1;
         yyvs = yyvs1;
       }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
+# else /* defined YYSTACK_RELOCATE */
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
         goto yyexhaustedlab;
···
           goto yyexhaustedlab;
         YYSTACK_RELOCATE (yyss_alloc, yyss);
         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-#  undef YYSTACK_RELOCATE
+# undef YYSTACK_RELOCATE
         if (yyss1 != yyssa)
           YYSTACK_FREE (yyss1);
       }
 # endif
-#endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-                  (unsigned long int) yystacksize));
+                  (unsigned long) yystacksize));
 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
     }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
   if (yystate == YYFINAL)
     YYACCEPT;
 
   goto yybackup;
 
+
 /*-----------.
 | yybackup.  |
 `-----------*/
 yybackup:
-
   /* Do appropriate processing given the current state.  Read a
      lookahead token if we need one and don't already have one.  */
 
···
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
   YY_IGNORE_MAYBE_UNINITIALIZED_END
-
   goto yynewstate;
 
 
···
 
 
 /*-----------------------------.
-| yyreduce -- Do a reduction.  |
+| yyreduce -- do a reduction.  |
 `-----------------------------*/
 yyreduce:
   /* yyn is the number of a rule to reduce with.  */
···
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 2:
-#line 146 "cc_parser.y" /* yacc.c:1646  */
+  case 2:
+#line 146 "cc_parser.y"
     { ctx->ccval = (yyvsp[0].ccval); YYACCEPT; }
-#line 1351 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1381 "cc_parser.tab.c"
     break;
 
   case 3:
-#line 149 "cc_parser.y" /* yacc.c:1646  */
+#line 149 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1357 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1387 "cc_parser.tab.c"
     break;
 
   case 4:
-#line 150 "cc_parser.y" /* yacc.c:1646  */
+#line 150 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[-1].ccval); }
-#line 1363 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1393 "cc_parser.tab.c"
     break;
 
   case 5:
-#line 151 "cc_parser.y" /* yacc.c:1646  */
+#line 151 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(!get_ccbool((yyvsp[0].ccval))); }
-#line 1369 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1399 "cc_parser.tab.c"
     break;
 
   case 6:
-#line 152 "cc_parser.y" /* yacc.c:1646  */
+#line 152 "cc_parser.y"
     { FIXME("'~' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1375 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1405 "cc_parser.tab.c"
     break;
 
   case 7:
-#line 153 "cc_parser.y" /* yacc.c:1646  */
+#line 153 "cc_parser.y"
     { FIXME("'+' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1381 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1411 "cc_parser.tab.c"
     break;
 
   case 8:
-#line 154 "cc_parser.y" /* yacc.c:1646  */
+#line 154 "cc_parser.y"
     { FIXME("'-' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1387 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1417 "cc_parser.tab.c"
     break;
 
   case 9:
-#line 157 "cc_parser.y" /* yacc.c:1646  */
+#line 157 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1393 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1423 "cc_parser.tab.c"
     break;
 
   case 10:
-#line 159 "cc_parser.y" /* yacc.c:1646  */
+#line 159 "cc_parser.y"
     { FIXME("'||' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1399 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1429 "cc_parser.tab.c"
     break;
 
   case 11:
-#line 162 "cc_parser.y" /* yacc.c:1646  */
+#line 162 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1405 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1435 "cc_parser.tab.c"
     break;
 
   case 12:
-#line 164 "cc_parser.y" /* yacc.c:1646  */
+#line 164 "cc_parser.y"
     { FIXME("'&&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1411 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1441 "cc_parser.tab.c"
     break;
 
   case 13:
-#line 167 "cc_parser.y" /* yacc.c:1646  */
+#line 167 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1417 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1447 "cc_parser.tab.c"
     break;
 
   case 14:
-#line 169 "cc_parser.y" /* yacc.c:1646  */
+#line 169 "cc_parser.y"
     { FIXME("'|' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1423 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1453 "cc_parser.tab.c"
     break;
 
   case 15:
-#line 172 "cc_parser.y" /* yacc.c:1646  */
+#line 172 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1429 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1459 "cc_parser.tab.c"
     break;
 
   case 16:
-#line 174 "cc_parser.y" /* yacc.c:1646  */
+#line 174 "cc_parser.y"
     { FIXME("'^' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1435 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1465 "cc_parser.tab.c"
     break;
 
   case 17:
-#line 177 "cc_parser.y" /* yacc.c:1646  */
+#line 177 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1441 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1471 "cc_parser.tab.c"
     break;
 
   case 18:
-#line 179 "cc_parser.y" /* yacc.c:1646  */
+#line 179 "cc_parser.y"
     { FIXME("'&' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1447 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1477 "cc_parser.tab.c"
     break;
 
   case 19:
-#line 182 "cc_parser.y" /* yacc.c:1646  */
+#line 182 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1453 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1483 "cc_parser.tab.c"
     break;
 
   case 20:
-#line 184 "cc_parser.y" /* yacc.c:1646  */
+#line 184 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) == get_ccnum((yyvsp[0].ccval))); }
-#line 1459 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1489 "cc_parser.tab.c"
     break;
 
   case 21:
-#line 186 "cc_parser.y" /* yacc.c:1646  */
+#line 186 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) != get_ccnum((yyvsp[0].ccval))); }
-#line 1465 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1495 "cc_parser.tab.c"
     break;
 
   case 22:
-#line 188 "cc_parser.y" /* yacc.c:1646  */
+#line 188 "cc_parser.y"
     { FIXME("'===' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1471 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1501 "cc_parser.tab.c"
     break;
 
   case 23:
-#line 190 "cc_parser.y" /* yacc.c:1646  */
+#line 190 "cc_parser.y"
     { FIXME("'!==' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1477 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1507 "cc_parser.tab.c"
     break;
 
   case 24:
-#line 193 "cc_parser.y" /* yacc.c:1646  */
+#line 193 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1483 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1513 "cc_parser.tab.c"
     break;
 
   case 25:
-#line 195 "cc_parser.y" /* yacc.c:1646  */
+#line 195 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) < get_ccnum((yyvsp[0].ccval))); }
-#line 1489 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1519 "cc_parser.tab.c"
     break;
 
   case 26:
-#line 197 "cc_parser.y" /* yacc.c:1646  */
+#line 197 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) <= get_ccnum((yyvsp[0].ccval))); }
-#line 1495 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1525 "cc_parser.tab.c"
     break;
 
   case 27:
-#line 199 "cc_parser.y" /* yacc.c:1646  */
+#line 199 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) > get_ccnum((yyvsp[0].ccval))); }
-#line 1501 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1531 "cc_parser.tab.c"
     break;
 
   case 28:
-#line 201 "cc_parser.y" /* yacc.c:1646  */
+#line 201 "cc_parser.y"
     { (yyval.ccval) = ccval_bool(get_ccnum((yyvsp[-2].ccval)) >= get_ccnum((yyvsp[0].ccval))); }
-#line 1507 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1537 "cc_parser.tab.c"
     break;
 
   case 29:
-#line 204 "cc_parser.y" /* yacc.c:1646  */
+#line 204 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1513 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1543 "cc_parser.tab.c"
     break;
 
   case 30:
-#line 206 "cc_parser.y" /* yacc.c:1646  */
+#line 206 "cc_parser.y"
     { FIXME("'<<' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1519 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1549 "cc_parser.tab.c"
     break;
 
   case 31:
-#line 208 "cc_parser.y" /* yacc.c:1646  */
+#line 208 "cc_parser.y"
     { FIXME("'>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1525 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1555 "cc_parser.tab.c"
     break;
 
   case 32:
-#line 210 "cc_parser.y" /* yacc.c:1646  */
+#line 210 "cc_parser.y"
     { FIXME("'>>>' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1531 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1561 "cc_parser.tab.c"
     break;
 
   case 33:
-#line 213 "cc_parser.y" /* yacc.c:1646  */
+#line 213 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1537 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1567 "cc_parser.tab.c"
     break;
 
   case 34:
-#line 215 "cc_parser.y" /* yacc.c:1646  */
+#line 215 "cc_parser.y"
     { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) + get_ccnum((yyvsp[0].ccval))); }
-#line 1543 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1573 "cc_parser.tab.c"
     break;
 
   case 35:
-#line 217 "cc_parser.y" /* yacc.c:1646  */
+#line 217 "cc_parser.y"
     { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) - get_ccnum((yyvsp[0].ccval))); }
-#line 1549 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1579 "cc_parser.tab.c"
     break;
 
   case 36:
-#line 220 "cc_parser.y" /* yacc.c:1646  */
+#line 220 "cc_parser.y"
     { (yyval.ccval) = (yyvsp[0].ccval); }
-#line 1555 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1585 "cc_parser.tab.c"
     break;
 
   case 37:
-#line 222 "cc_parser.y" /* yacc.c:1646  */
+#line 222 "cc_parser.y"
     { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) * get_ccnum((yyvsp[0].ccval))); }
-#line 1561 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1591 "cc_parser.tab.c"
     break;
 
   case 38:
-#line 224 "cc_parser.y" /* yacc.c:1646  */
+#line 224 "cc_parser.y"
     { (yyval.ccval) = ccval_num(get_ccnum((yyvsp[-2].ccval)) / get_ccnum((yyvsp[0].ccval))); }
-#line 1567 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1597 "cc_parser.tab.c"
     break;
 
   case 39:
-#line 226 "cc_parser.y" /* yacc.c:1646  */
+#line 226 "cc_parser.y"
     { FIXME("'%%' expression not implemented\n"); ctx->hres = E_NOTIMPL; YYABORT; }
-#line 1573 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1603 "cc_parser.tab.c"
     break;
 
 
-#line 1577 "cc_parser.tab.c" /* yacc.c:1646  */
+#line 1607 "cc_parser.tab.c"
+
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
···
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
 
   goto yynewstate;
 
···
 | yyerrorlab -- error raised explicitly by YYERROR.  |
 `---------------------------------------------------*/
 yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
 
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
···
   yyresult = 0;
   goto yyreturn;
 
+
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
   yyresult = 1;
   goto yyreturn;
+
 
 #if !defined yyoverflow || YYERROR_VERBOSE
 /*-------------------------------------------------.
···
   /* Fall through.  */
 #endif
 
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result.  |
+`-----------------------------------------------------*/
 yyreturn:
   if (yychar != YYEMPTY)
     {
···
 #endif
   return yyresult;
 }
-#line 228 "cc_parser.y" /* yacc.c:1906  */
+#line 228 "cc_parser.y"
 
 
 BOOL parse_cc_expr(parser_ctx_t *ctx)

dll/win32/jscript/cc_parser.tab.h

···
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.4.1.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
···
 
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
+
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
 
 #ifndef YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED
 # define YY_CC_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_CC_PARSER_TAB_H_INCLUDED
···
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
 union YYSTYPE
 {
-#line 36 "cc_parser.y" /* yacc.c:1909  */
+#line 36 "cc_parser.y"
 
     ccval_t ccval;
 
-#line 73 "cc_parser.tab.h" /* yacc.c:1909  */
+#line 76 "cc_parser.tab.h"
+
 };
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif

dll/win32/jscript/cc_parser.y

···
 
 %lex-param { parser_ctx_t *ctx }
 %parse-param { parser_ctx_t *ctx }
-%pure-parser
+%define api.pure
 %start CCExpr
 
 %union {

dll/win32/jscript/compile.c

···
     int ref;
 } function_local_t;
 
-typedef struct {
+typedef struct _compiler_ctx_t {
     parser_ctx_t *parser;
     bytecode_t *code;
 
···
     return heap_pool_alloc(&code->heap, size);
 }
 
-static jsstr_t *compiler_alloc_string_len(compiler_ctx_t *ctx, const WCHAR *str, unsigned len)
+jsstr_t *compiler_alloc_string_len(compiler_ctx_t *ctx, const WCHAR *str, unsigned len)
 {
     jsstr_t *new_str;
 
···
 
 static jsstr_t *compiler_alloc_string(compiler_ctx_t *ctx, const WCHAR *str)
 {
-    return compiler_alloc_string_len(ctx, str, strlenW(str));
+    return compiler_alloc_string_len(ctx, str, lstrlenW(str));
 }
 
 static BOOL ensure_bstr_slot(compiler_ctx_t *ctx)
···
     return S_OK;
 }
 
-static HRESULT push_instr_str(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
+static HRESULT push_instr_str(compiler_ctx_t *ctx, jsop_t op, jsstr_t *str)
 {
     unsigned instr;
-    jsstr_t *str;
 
-    str = compiler_alloc_string(ctx, arg);
-    if(!str)
+    instr = push_instr(ctx, op);
+    if(!instr)
         return E_OUTOFMEMORY;
 
+    instr_ptr(ctx, instr)->u.arg->str = str;
+    return S_OK;
+}
+
+static HRESULT push_instr_str_uint(compiler_ctx_t *ctx, jsop_t op, jsstr_t *str, unsigned arg2)
+{
+    unsigned instr;
+
     instr = push_instr(ctx, op);
     if(!instr)
         return E_OUTOFMEMORY;
 
-    instr_ptr(ctx, instr)->u.arg->str = str;
+    instr_ptr(ctx, instr)->u.arg[0].str = str;
+    instr_ptr(ctx, instr)->u.arg[1].uint = arg2;
     return S_OK;
 }
 
···
     }
     case EXPR_MEMBER: {
         member_expression_t *member_expr = (member_expression_t*)expr;
+        jsstr_t *jsstr;
 
         hres = compile_expression(ctx, member_expr->expression, TRUE);
         if(FAILED(hres))
             return hres;
 
         /* FIXME: Potential optimization */
-        hres = push_instr_str(ctx, OP_str, member_expr->identifier);
+        jsstr = compiler_alloc_string(ctx, member_expr->identifier);
+        if(!jsstr)
+            return E_OUTOFMEMORY;
+
+        hres = push_instr_str(ctx, OP_str, jsstr);
         if(FAILED(hres))
             return hres;
 
···
     }
     case EXPR_MEMBER: {
         member_expression_t *member_expr = (member_expression_t*)expr->expression;
+        jsstr_t *jsstr;
 
         hres = compile_expression(ctx, member_expr->expression, TRUE);
         if(FAILED(hres))
             return hres;
 
         /* FIXME: Potential optimization */
-        hres = push_instr_str(ctx, OP_str, member_expr->identifier);
+        jsstr = compiler_alloc_string(ctx, member_expr->identifier);
+        if(!jsstr)
+            return E_OUTOFMEMORY;
+
+        hres = push_instr_str(ctx, OP_str, jsstr);
         if(FAILED(hres))
             return hres;
 
···
         call_expression_t *call_expr = (call_expression_t*)expr->expression1;
         argument_t *arg;
 
-        if(op != OP_LAST) {
-            FIXME("op %d not supported on parametrized assign expressions\n", op);
-            return E_NOTIMPL;
-        }
-
         if(is_memberid_expr(call_expr->expression->type) && call_expr->argument_list) {
             hres = compile_memberid_expression(ctx, call_expr->expression, fdexNameEnsure);
             if(FAILED(hres))
···
                     return hres;
                 arg_cnt++;
             }
+
+            if(op != OP_LAST) {
+                unsigned instr;
+
+                /* We need to call the functions twice: to get the value and to set it.
+                 * JavaScript interpreted functions may to modify value on the stack,
+                 * but assignment calls are allowed only on external functions, so we
+                 * may reuse the stack here. */
+                instr = push_instr(ctx, OP_call_member);
+                if(!instr)
+                    return E_OUTOFMEMORY;
+                instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
+                instr_ptr(ctx, instr)->u.arg[1].lng = 1;
+
+                if(!push_instr(ctx, OP_push_acc))
+                    return E_OUTOFMEMORY;
+            }
         }else {
             use_throw_path = TRUE;
         }
···
         hres = compile_memberid_expression(ctx, expr->expression1, fdexNameEnsure);
         if(FAILED(hres))
             return hres;
+        if(op != OP_LAST && !push_instr(ctx, OP_refval))
+            return E_OUTOFMEMORY;
     }else {
         use_throw_path = TRUE;
     }
···
 
         return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
     }
-
-    if(op != OP_LAST && !push_instr(ctx, OP_refval))
-        return E_OUTOFMEMORY;
 
     hres = compile_expression(ctx, expr->expression2, TRUE);
     if(FAILED(hres))
···
     case LT_NULL:
         return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
     case LT_STRING:
-        return push_instr_str(ctx, OP_str, literal->u.wstr);
-    case LT_REGEXP: {
-        unsigned instr;
-        jsstr_t *str;
-
-        str = compiler_alloc_string_len(ctx, literal->u.regexp.str, literal->u.regexp.str_len);
-        if(!str)
-            return E_OUTOFMEMORY;
-
-        instr = push_instr(ctx, OP_regexp);
-        if(!instr)
-            return E_OUTOFMEMORY;
-
-        instr_ptr(ctx, instr)->u.arg[0].str = str;
-        instr_ptr(ctx, instr)->u.arg[1].uint = literal->u.regexp.flags;
-        return S_OK;
-    }
+        return push_instr_str(ctx, OP_str, literal->u.str);
+    case LT_REGEXP:
+        return push_instr_str_uint(ctx, OP_regexp, literal->u.regexp.str, literal->u.regexp.flags);
     DEFAULT_UNREACHABLE;
     }
     return E_FAIL;
 }
 
-static HRESULT literal_as_bstr(compiler_ctx_t *ctx, literal_t *literal, BSTR *str)
+static HRESULT literal_as_string(compiler_ctx_t *ctx, literal_t *literal, jsstr_t **str)
 {
     switch(literal->type) {
     case LT_STRING:
-        *str = compiler_alloc_bstr(ctx, literal->u.wstr);
-        break;
-    case LT_DOUBLE: {
-        jsstr_t *jsstr;
-        HRESULT hres;
-
-        hres = double_to_string(literal->u.dval, &jsstr);
-        if(FAILED(hres))
-            return hres;
-
-        *str = compiler_alloc_bstr_len(ctx, NULL, jsstr_length(jsstr));
-        if(*str)
-            jsstr_flush(jsstr, *str);
-        jsstr_release(jsstr);
+        *str = literal->u.str;
         break;
-    }
+    case LT_DOUBLE:
+        return double_to_string(literal->u.dval, str);
     DEFAULT_UNREACHABLE;
     }
 
···
 static HRESULT compile_object_literal(compiler_ctx_t *ctx, property_value_expression_t *expr)
 {
     property_definition_t *iter;
-    BSTR name;
+    jsstr_t *name;
     HRESULT hres;
 
     if(!push_instr(ctx, OP_new_obj))
         return E_OUTOFMEMORY;
 
     for(iter = expr->property_list; iter; iter = iter->next) {
-        hres = literal_as_bstr(ctx, iter->name, &name);
+        hres = literal_as_string(ctx, iter->name, &name);
         if(FAILED(hres))
             return hres;
 
···
         if(FAILED(hres))
             return hres;
 
-        hres = push_instr_bstr_uint(ctx, OP_obj_prop, name, iter->type);
+        hres = push_instr_str_uint(ctx, OP_obj_prop, name, iter->type);
         if(FAILED(hres))
             return hres;
     }
···
         for(iter = ctx->stat_ctx; iter; iter = iter->next) {
             if(iter->continue_label)
                 pop_ctx = iter;
-            if(iter->labelled_stat && !strcmpW(iter->labelled_stat->identifier, stat->identifier))
+            if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier))
                 break;
         }
 
···
 
     if(stat->identifier) {
         for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
-            if(pop_ctx->labelled_stat && !strcmpW(pop_ctx->labelled_stat->identifier, stat->identifier)) {
+            if(pop_ctx->labelled_stat && !wcscmp(pop_ctx->labelled_stat->identifier, stat->identifier)) {
                 assert(pop_ctx->break_label);
                 break;
             }
···
     HRESULT hres;
 
     for(iter = ctx->stat_ctx; iter; iter = iter->next) {
-        if(iter->labelled_stat && !strcmpW(iter->labelled_stat->identifier, stat->identifier)) {
+        if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier)) {
             WARN("Label %s redefined\n", debugstr_w(stat->identifier));
             return JS_E_LABEL_REDEFINED;
         }
···
 static int function_local_cmp(const void *key, const struct wine_rb_entry *entry)
 {
     function_local_t *local = WINE_RB_ENTRY_VALUE(entry, function_local_t, entry);
-    return strcmpW(key, local->name);
+    return wcscmp(key, local->name);
 }
 
 static inline function_local_t *find_local(compiler_ctx_t *ctx, const WCHAR *name)
···
     const WCHAR *ptr = args, *ptr2;
     unsigned arg_cnt = 0;
 
-    while(isspaceW(*ptr))
+    while(iswspace(*ptr))
         ptr++;
     if(!*ptr) {
         if(args_size)
···
     }
 
     while(1) {
-        if(!isalphaW(*ptr) && *ptr != '_') {
+        if(!iswalpha(*ptr) && *ptr != '_') {
             FIXME("expected alpha or '_': %s\n", debugstr_w(ptr));
             return E_FAIL;
         }
 
         ptr2 = ptr;
-        while(isalnumW(*ptr) || *ptr == '_')
+        while(iswalnum(*ptr) || *ptr == '_')
             ptr++;
 
-        if(*ptr && *ptr != ',' && !isspaceW(*ptr)) {
+        if(*ptr && *ptr != ',' && !iswspace(*ptr)) {
             FIXME("unexpected har %s\n", debugstr_w(ptr));
             return E_FAIL;
         }
···
         }
         arg_cnt++;
 
-        while(isspaceW(*ptr))
+        while(iswspace(*ptr))
             ptr++;
         if(!*ptr)
             break;
···
         }
 
         ptr++;
-        while(isspaceW(*ptr))
+        while(iswspace(*ptr))
             ptr++;
     }
 
···
         }
     }
 
-    hres = script_parse(ctx, compiler.code->source, delimiter, from_eval, &compiler.parser);
+    hres = script_parse(ctx, &compiler, compiler.code->source, delimiter, from_eval, &compiler.parser);
     if(FAILED(hres)) {
         release_bytecode(compiler.code);
         return hres;

dll/win32/jscript/date.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <limits.h>
 #include <math.h>
···
         }
 
         if(!show_offset)
-            sprintfW(buf, formatNoOffsetW, week, month, day,
+            swprintf(buf, formatNoOffsetW, week, month, day,
                     (int)hour_from_time(time), (int)min_from_time(time),
                     (int)sec_from_time(time), year, formatAD?ADW:BCW);
         else if(offset)
-            sprintfW(buf, formatW, week, month, day,
+            swprintf(buf, formatW, week, month, day,
                     (int)hour_from_time(time), (int)min_from_time(time),
                     (int)sec_from_time(time), sign, offset/60, offset%60,
                     year, formatAD?ADW:BCW);
         else
-            sprintfW(buf, formatUTCW, week, month, day,
+            swprintf(buf, formatUTCW, week, month, day,
                     (int)hour_from_time(time), (int)min_from_time(time),
                     (int)sec_from_time(time), year, formatAD?ADW:BCW);
 
···
 
     if(year < 0) {
         *p++ = '-';
-        p += sprintfW(p, long_year_formatW, -(int)year);
+        p += swprintf(p, long_year_formatW, -(int)year);
     }else if(year > 9999) {
         *p++ = '+';
-        p += sprintfW(p, long_year_formatW, (int)year);
+        p += swprintf(p, long_year_formatW, (int)year);
     }else {
-        p += sprintfW(p, short_year_formatW, (int)year);
+        p += swprintf(p, short_year_formatW, (int)year);
     }
 
-    sprintfW(p, formatW, (int)month_from_time(date->time) + 1, (int)date_from_time(date->time),
+    swprintf(p, formatW,
+             (int)month_from_time(date->time) + 1, (int)date_from_time(date->time),
              (int)hour_from_time(date->time), (int)min_from_time(date->time),
              (int)sec_from_time(date->time), (int)ms_from_time(date->time));
 
···
 
         day = date_from_time(date->time);
 
-        sprintfW(buf, formatAD ? formatADW : formatBCW, week, day, month, year,
+        swprintf(buf, formatAD ? formatADW : formatBCW, week, day, month, year,
                 (int)hour_from_time(date->time), (int)min_from_time(date->time),
                 (int)sec_from_time(date->time));
 
···
 
         day = date_from_time(time);
 
-        sprintfW(buf, formatAD ? formatADW : formatBCW, week, month, day, year);
+        swprintf(buf, formatAD ? formatADW : formatBCW, week, month, day, year);
 
         date_str = jsstr_alloc(buf);
         if(!date_str)
···
         else sign = '-';
 
         if(offset)
-            sprintfW(buf, formatW, (int)hour_from_time(time),
+            swprintf(buf, formatW, (int)hour_from_time(time),
                     (int)min_from_time(time), (int)sec_from_time(time),
                     sign, offset/60, offset%60);
         else
-            sprintfW(buf, formatUTCW, (int)hour_from_time(time),
+            swprintf(buf, formatUTCW, (int)hour_from_time(time),
                     (int)min_from_time(time), (int)sec_from_time(time));
 
         date_str = jsstr_alloc(buf);
···
     for(i=0; i<input_len; i++) {
         if(input[i] == '(') nest_level++;
         else if(input[i] == ')') nest_level--;
-        else if(!nest_level) parse[parse_len++] = toupperW(input[i]);
+        else if(!nest_level) parse[parse_len++] = towupper(input[i]);
     }
     parse[parse_len] = 0;
 
···
     }
 
     for(i=0; i<parse_len;) {
-        while(isspaceW(parse[i])) i++;
+        while(iswspace(parse[i])) i++;
         if(parse[i] == ',') {
             while(parse[i] == ',') i++;
             continue;
         }
 
         if(parse[i]>='0' && parse[i]<='9') {
-            int tmp = atoiW(&parse[i]);
+            int tmp = wcstol(&parse[i], NULL, 10);
             while(parse[i]>='0' && parse[i]<='9') i++;
-            while(isspaceW(parse[i])) i++;
+            while(iswspace(parse[i])) i++;
 
             if(parse[i] == ':') {
                 /* Time */
···
                 hour = tmp;
 
                 while(parse[i] == ':') i++;
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 if(parse[i]>='0' && parse[i]<='9') {
-                    min = atoiW(&parse[i]);
+                    min = wcstol(&parse[i], NULL, 10);
                     while(parse[i]>='0' && parse[i]<='9') i++;
                 }
 
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 while(parse[i] == ':') i++;
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 if(parse[i]>='0' && parse[i]<='9') {
-                    sec = atoiW(&parse[i]);
+                    sec = wcstol(&parse[i], NULL, 10);
                     while(parse[i]>='0' && parse[i]<='9') i++;
                 }
             }
···
 
                 month = tmp-1;
 
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 while(parse[i]=='-' || parse[i]=='/') i++;
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 if(parse[i]<'0' || parse[i]>'9') break;
-                day = atoiW(&parse[i]);
+                day = wcstol(&parse[i], NULL, 10);
                 while(parse[i]>='0' && parse[i]<='9') i++;
 
                 while(parse[i]=='-' || parse[i]=='/') i++;
-                while(isspaceW(parse[i])) i++;
+                while(iswspace(parse[i])) i++;
                 if(parse[i]<'0' || parse[i]>'9') break;
-                year = atoiW(&parse[i]);
+                year = wcstol(&parse[i], NULL, 10);
                 while(parse[i]>='0' && parse[i]<='9') i++;
 
                 if(tmp >= 70){
···
             if(parse[i] == '-')  positive = FALSE;
 
             i++;
-            while(isspaceW(parse[i])) i++;
+            while(iswspace(parse[i])) i++;
             if(parse[i]<'0' || parse[i]>'9') break;
-            offset = atoiW(&parse[i]);
+            offset = wcstol(&parse[i], NULL, 10);
             while(parse[i]>='0' && parse[i]<='9') i++;
 
             if(offset<24) offset *= 60;
···
                 size -= i;
 
                 for(j=0; j<ARRAY_SIZE(string_ids); j++)
-                    if(!strncmpiW(&parse[i], strings[j], size)) break;
+                    if(!_wcsnicmp(&parse[i], strings[j], size)) break;
 
                 if(j < 12) {
                     if(set_month) break;

dll/win32/jscript/decode.c

···
     static const WCHAR decode_endW[] = {'^','#','~','@'};
 
     while(*src) {
-        if(!strncmpW(src, decode_beginW, ARRAY_SIZE(decode_beginW))) {
+        if(!wcsncmp(src, decode_beginW, ARRAY_SIZE(decode_beginW))) {
             DWORD len, i, j=0, csum, s=0;
 
             src += ARRAY_SIZE(decode_beginW);
···
                 return JS_E_INVALID_CHAR;
             src += 8;
 
-            if(strncmpW(src, decode_endW, ARRAY_SIZE(decode_endW)))
+            if(wcsncmp(src, decode_endW, ARRAY_SIZE(decode_endW)))
                 return JS_E_INVALID_CHAR;
             src += ARRAY_SIZE(decode_endW);
         }else {

dll/win32/jscript/dispex.c

···
 
 #include "jscript.h"
 
-#include "wine/unicode.h"
 #include "wine/debug.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
···
     while(min <= max) {
         i = (min+max)/2;
 
-        r = strcmpW(name, This->builtin_info->props[i].name);
+        r = wcscmp(name, This->builtin_info->props[i].name);
         if(!r) {
             /* Skip prop if it's available only in higher compatibility mode. */
             unsigned version = (This->builtin_info->props[i].flags & PROPF_VERSION_MASK)
···
 {
     unsigned h = 0;
     for(; *name; name++)
-        h = (h>>(sizeof(unsigned)*8-4)) ^ (h<<4) ^ tolowerW(*name);
+        h = (h>>(sizeof(unsigned)*8-4)) ^ (h<<4) ^ towlower(*name);
     return h;
 }
 
···
     bucket = get_props_idx(This, hash);
     pos = This->props[bucket].bucket_head;
     while(pos != 0) {
-        if(!strcmpW(name, This->props[pos].name)) {
+        if(!wcscmp(name, This->props[pos].name)) {
             if(prev != 0) {
                 This->props[prev].bucket_next = This->props[pos].bucket_next;
                 This->props[pos].bucket_next = This->props[bucket].bucket_head;
···
         const WCHAR *ptr;
         unsigned idx = 0;
 
-        for(ptr = name; isdigitW(*ptr) && idx < 0x10000; ptr++)
+        for(ptr = name; iswdigit(*ptr) && idx < 0x10000; ptr++)
             idx = idx*10 + (*ptr-'0');
         if(!*ptr && idx < This->builtin_info->idx_length(This)) {
             prop = alloc_prop(This, name, PROP_IDX, This->builtin_info->idx_put ? PROPF_WRITABLE : 0);
···
 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 {
     jsdisp_t *This = impl_from_IDispatchEx(iface);
-    dispex_prop_t *iter;
     HRESULT hres;
 
     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 
-    if(id == DISPID_STARTENUM) {
-        hres = fill_protrefs(This);
-        if(FAILED(hres))
-            return hres;
-    }
-
-    if(id+1>=0 && id+1<This->prop_cnt) {
-        iter = &This->props[id+1];
-    }else {
+    hres = jsdisp_next_prop(This, id, FALSE, pid);
+    if(hres == S_FALSE)
         *pid = DISPID_STARTENUM;
-        return S_FALSE;
-    }
-
-    while(iter < This->props + This->prop_cnt) {
-        if(iter->name && (get_flags(This, iter) & PROPF_ENUMERABLE) && iter->type!=PROP_DELETED) {
-            *pid = prop_to_id(This, iter);
-            return S_OK;
-        }
-        iter++;
-    }
-
-    *pid = DISPID_STARTENUM;
-    return S_FALSE;
+    return hres;
 }
 
 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
···
 
     static const WCHAR formatW[] = {'%','d',0};
 
-    sprintfW(buf, formatW, idx);
+    swprintf(buf, formatW, idx);
     return jsdisp_propput_name(obj, buf, val);
 }
 
···
 
     static const WCHAR formatW[] = {'%','d',0};
 
-    sprintfW(name, formatW, idx);
+    swprintf(name, formatW, idx);
 
     hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
     if(FAILED(hres))
···
     BOOL b;
     HRESULT hres;
 
-    sprintfW(buf, formatW, idx);
+    swprintf(buf, formatW, idx);
 
     hres = find_prop_name(obj, string_hash(buf), buf, &prop);
     if(FAILED(hres) || !prop)
···
 
     *ret = hres == S_OK;
     return S_OK;
+}
+
+HRESULT jsdisp_next_prop(jsdisp_t *obj, DISPID id, BOOL own_only, DISPID *ret)
+{
+    dispex_prop_t *iter;
+    HRESULT hres;
+
+    if(id == DISPID_STARTENUM && !own_only) {
+        hres = fill_protrefs(obj);
+        if(FAILED(hres))
+            return hres;
+    }
+
+    if(id + 1 < 0 || id+1 >= obj->prop_cnt)
+        return S_FALSE;
+
+    for(iter = &obj->props[id + 1]; iter < obj->props + obj->prop_cnt; iter++) {
+        if(!iter->name || iter->type == PROP_DELETED)
+            continue;
+        if(own_only && iter->type == PROP_PROTREF)
+            continue;
+        if(!(get_flags(obj, iter) & PROPF_ENUMERABLE))
+            continue;
+        *ret = prop_to_id(obj, iter);
+        return S_OK;
+    }
+
+    return S_FALSE;
 }
 
 HRESULT disp_delete_name(script_ctx_t *ctx, IDispatch *disp, jsstr_t *name, BOOL *ret)

dll/win32/jscript/engine.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 #include <assert.h>
···
     return FALSE;
 }
 
-static int local_ref_cmp(const void *key, const void *ref)
+static int __cdecl local_ref_cmp(const void *key, const void *ref)
 {
-    return strcmpW((const WCHAR*)key, ((const local_ref_t*)ref)->name);
+    return wcscmp((const WCHAR*)key, ((const local_ref_t*)ref)->name);
 }
 
 local_ref_t *lookup_local(const function_code_t *function, const WCHAR *identifier)
···
                     return S_OK;
                 }
 
-                if(!strcmpW(identifier, argumentsW)) {
+                if(!wcscmp(identifier, argumentsW)) {
                     hres = detach_variable_object(ctx, scope->frame, FALSE);
                     if(FAILED(hres))
                         return hres;
···
     }
 
     for(item = ctx->named_items; item; item = item->next) {
-        if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
+        if((item->flags & SCRIPTITEM_ISVISIBLE) && !wcscmp(item->name, identifier)) {
             if(!item->disp) {
                 IUnknown *unk;
 
···
 /* ECMA-262 3rd Edition    11.1.5 */
 static HRESULT interp_obj_prop(script_ctx_t *ctx)
 {
-    const BSTR name = get_op_bstr(ctx, 0);
+    jsstr_t *name_arg = get_op_str(ctx, 0);
     unsigned type = get_op_uint(ctx, 1);
+    const WCHAR *name;
     jsdisp_t *obj;
     jsval_t val;
     HRESULT hres;
 
-    TRACE("%s\n", debugstr_w(name));
+    TRACE("%s\n", debugstr_jsstr(name_arg));
 
     val = stack_pop(ctx);
+
+    /* FIXME: we should pass it as jsstr_t */
+    name = jsstr_flatten(name_arg);
 
     assert(is_object_instance(stack_top(ctx)));
     obj = as_jsdisp(get_object(stack_top(ctx)));

dll/win32/jscript/engine.h

···
     X(new,        1, ARG_UINT,   0)        \
     X(new_obj,    1, 0,0)                  \
     X(null,       1, 0,0)                  \
-    X(obj_prop,   1, ARG_BSTR,   ARG_UINT) \
+    X(obj_prop,   1, ARG_STR,    ARG_UINT) \
     X(or,         1, 0,0)                  \
     X(pop,        1, ARG_UINT,   0)        \
     X(pop_except, 0, ARG_ADDR,   0)        \

dll/win32/jscript/enumerator.c

···
     if (This->atend)
         return S_OK;
 
-    /* dont leak pervious value */
+    /* don't leak previous value */
     jsval_release(This->item);
 
     /* not at end ... get next item */
···
         VariantClear(&nextitem);
         if (FAILED(hres))
         {
-            WARN("failed to convert jsval to variant!");
+            WARN("failed to convert jsval to variant!\n");
             This->item = jsval_undefined();
             return hres;
         }

dll/win32/jscript/error.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 
···
     buf[0] = '\0';
     LoadStringW(jscript_hinstance, HRESULT_CODE(error), buf, ARRAY_SIZE(buf));
 
-    if(str) pos = strchrW(buf, '|');
+    if(str) pos = wcschr(buf, '|');
     if(pos) {
-        int len = strlenW(str);
-        memmove(pos+len, pos+1, (strlenW(pos+1)+1)*sizeof(WCHAR));
+        int len = lstrlenW(str);
+        memmove(pos+len, pos+1, (lstrlenW(pos+1)+1)*sizeof(WCHAR));
         memcpy(pos, str, len*sizeof(WCHAR));
     }
 

dll/win32/jscript/function.c

···
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
+typedef struct _function_vtbl_t function_vtbl_t;
+
 typedef struct {
     jsdisp_t dispex;
-    builtin_invoke_t value_proc;
-    const WCHAR *name;
+    const function_vtbl_t *vtbl;
     DWORD flags;
+    DWORD length;
+} FunctionInstance;
+
+struct _function_vtbl_t {
+    HRESULT (*call)(script_ctx_t*,FunctionInstance*,IDispatch*,unsigned,unsigned,jsval_t*,jsval_t*);
+    HRESULT (*toString)(FunctionInstance*,jsstr_t**);
+    void (*destructor)(FunctionInstance*);
+};
+
+typedef struct {
+    FunctionInstance function;
     scope_chain_t *scope_chain;
     bytecode_t *code;
     function_code_t *func_code;
-    DWORD length;
-} FunctionInstance;
+} InterpretedFunction;
+
+typedef struct {
+    FunctionInstance function;
+    builtin_invoke_t proc;
+    const WCHAR *name;
+} NativeFunction;
+
+typedef struct {
+    FunctionInstance function;
+    FunctionInstance *target;
+    IDispatch *this;
+    unsigned argc;
+    jsval_t args[1];
+} BindFunction;
 
 typedef struct {
     jsdisp_t jsdisp;
-    FunctionInstance *function;
+    InterpretedFunction *function;
     jsval_t *buf;
     call_frame_t *frame;
     unsigned argc;
 } ArgumentsInstance;
 
+static HRESULT create_bind_function(script_ctx_t*,FunctionInstance*,IDispatch*,unsigned,jsval_t*,jsdisp_t**r);
+
 static inline FunctionInstance *function_from_jsdisp(jsdisp_t *jsdisp)
 {
     return CONTAINING_RECORD(jsdisp, FunctionInstance, dispex);
···
 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 applyW[] = {'a','p','p','l','y',0};
+static const WCHAR bindW[] = {'b','i','n','d',0};
 static const WCHAR callW[] = {'c','a','l','l',0};
 static const WCHAR argumentsW[] = {'a','r','g','u','m','e','n','t','s',0};
 
···
         heap_free(arguments->buf);
     }
 
-    jsdisp_release(&arguments->function->dispex);
+    jsdisp_release(&arguments->function->function.dispex);
     heap_free(arguments);
 }
 
···
         return jsval_copy(*ref, r);
 
     /* FIXME: Accessing by name won't work for duplicated argument names */
-    return jsdisp_propget_name(arguments->frame->base_scope->jsobj, arguments->function->func_code->params[idx], r);
+    return jsdisp_propget_name(arguments->frame->base_scope->jsobj,
+                               arguments->function->func_code->params[idx], r);
 }
 
 static HRESULT Arguments_idx_put(jsdisp_t *jsdisp, unsigned idx, jsval_t val)
···
     }
 
     /* FIXME: Accessing by name won't work for duplicated argument names */
-    return jsdisp_propput_name(arguments->frame->base_scope->jsobj, arguments->function->func_code->params[idx], val);
+    return jsdisp_propput_name(arguments->frame->base_scope->jsobj,
+                               arguments->function->func_code->params[idx], val);
 }
 
 static const builtin_info_t Arguments_info = {
···
         return hres;
     }
 
-    args->function = function_from_jsdisp(jsdisp_addref(frame->function_instance));
+    args->function = (InterpretedFunction*)function_from_jsdisp(jsdisp_addref(frame->function_instance));
     args->argc = frame->argc;
     args->frame = frame;
 
···
                                        jsval_number(args->argc));
     if(SUCCEEDED(hres))
         hres = jsdisp_define_data_property(&args->jsdisp, caleeW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
-                                           jsval_obj(&args->function->dispex));
+                                           jsval_obj(&args->function->function.dispex));
     if(SUCCEEDED(hres))
         hres = jsdisp_propput(frame->base_scope->jsobj, argumentsW, PROPF_WRITABLE, jsval_obj(&args->jsdisp));
     if(FAILED(hres)) {
···
     jsdisp_release(frame->arguments_obj);
 }
 
-static HRESULT invoke_source(script_ctx_t *ctx, FunctionInstance *function, IDispatch *this_obj, unsigned argc, jsval_t *argv,
-        BOOL is_constructor, BOOL caller_execs_source, jsval_t *r)
-{
-    jsdisp_t *var_disp;
-    DWORD exec_flags = 0;
-    HRESULT hres;
-
-    if(ctx->state == SCRIPTSTATE_UNINITIALIZED || ctx->state == SCRIPTSTATE_CLOSED) {
-        WARN("Script engine state does not allow running code.\n");
-        return E_UNEXPECTED;
-    }
-
-    if(!function->func_code) {
-        FIXME("no source\n");
-        return E_FAIL;
-    }
-
-    hres = create_dispex(ctx, NULL, NULL, &var_disp);
-    if(FAILED(hres))
-        return hres;
-
-    if(caller_execs_source)
-        exec_flags |= EXEC_RETURN_TO_INTERP;
-    if(is_constructor)
-        exec_flags |= EXEC_CONSTRUCTOR;
-    hres = exec_source(ctx, exec_flags, function->code, function->func_code, function->scope_chain, this_obj,
-            &function->dispex, var_disp, argc, argv, r);
-
-    jsdisp_release(var_disp);
-    return hres;
-}
-
-static HRESULT invoke_value_proc(script_ctx_t *ctx, FunctionInstance *function, IDispatch *this_disp, WORD flags,
-        unsigned argc, jsval_t *argv, jsval_t *r)
-{
-    vdisp_t vthis;
-    HRESULT hres;
-
-    if(this_disp)
-        set_disp(&vthis, this_disp);
-    else if(ctx->host_global)
-        set_disp(&vthis, ctx->host_global);
-    else
-        set_jsdisp(&vthis, ctx->global);
-
-    hres = function->value_proc(ctx, &vthis, flags, argc, argv, r);
-
-    vdisp_release(&vthis);
-    return hres;
-}
-
-static HRESULT call_function(script_ctx_t *ctx, FunctionInstance *function, IDispatch *this_obj,
-        unsigned argc, jsval_t *argv, BOOL caller_execs_source, jsval_t *r)
-{
-    if(function->value_proc)
-        return invoke_value_proc(ctx, function, this_obj, DISPATCH_METHOD, argc, argv, r);
-
-    return invoke_source(ctx, function, this_obj, argc, argv, FALSE, caller_execs_source, r);
-}
-
-static HRESULT function_to_string(FunctionInstance *function, jsstr_t **ret)
-{
-    jsstr_t *str;
-
-    static const WCHAR native_prefixW[] = {'\n','f','u','n','c','t','i','o','n',' '};
-    static const WCHAR native_suffixW[] =
-        {'(',')',' ','{','\n',' ',' ',' ',' ','[','n','a','t','i','v','e',' ','c','o','d','e',']','\n','}','\n'};
-
-    if(function->value_proc) {
-        DWORD name_len;
-        WCHAR *ptr;
-
-        name_len = strlenW(function->name);
-        str = jsstr_alloc_buf(ARRAY_SIZE(native_prefixW) + ARRAY_SIZE(native_suffixW) + name_len, &ptr);
-        if(!str)
-            return E_OUTOFMEMORY;
-
-        memcpy(ptr, native_prefixW, sizeof(native_prefixW));
-        memcpy(ptr += ARRAY_SIZE(native_prefixW), function->name, name_len*sizeof(WCHAR));
-        memcpy(ptr + name_len, native_suffixW, sizeof(native_suffixW));
-    }else {
-        str = jsstr_alloc_len(function->func_code->source, function->func_code->source_len);
-        if(!str)
-            return E_OUTOFMEMORY;
-    }
-
-    *ret = str;
-    return S_OK;
-}
-
 HRESULT Function_invoke(jsdisp_t *func_this, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    const BOOL caller_execs_source = (flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE) != 0;
     FunctionInstance *function;
 
     TRACE("func %p this %p\n", func_this, jsthis);
···
     assert(is_class(func_this, JSCLASS_FUNCTION));
     function = function_from_jsdisp(func_this);
 
-    flags &= ~DISPATCH_JSCRIPT_INTERNAL_MASK;
-    if(function->value_proc)
-        return invoke_value_proc(function->dispex.ctx, function, jsthis, flags, argc, argv, r);
-
-    if(flags == DISPATCH_CONSTRUCT) {
-        jsdisp_t *this_obj;
-        HRESULT hres;
-
-        hres = create_object(function->dispex.ctx, &function->dispex, &this_obj);
-        if(FAILED(hres))
-            return hres;
-
-        hres = invoke_source(function->dispex.ctx, function, to_disp(this_obj), argc, argv, TRUE, caller_execs_source, r);
-        jsdisp_release(this_obj);
-        return hres;
-    }
-
-    assert(flags == DISPATCH_METHOD);
-    return invoke_source(function->dispex.ctx, function, jsthis, argc, argv, FALSE, caller_execs_source, r);
+    return function->vtbl->call(function->dispex.ctx, function, jsthis, flags, argc, argv, r);
 }
 
 static HRESULT Function_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
···
     if(!(function = function_this(jsthis)))
         return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
 
-    hres = function_to_string(function, &str);
+    hres = function->vtbl->toString(function, &str);
     if(FAILED(hres))
         return hres;
 
···
 
     if(SUCCEEDED(hres)) {
         if(function) {
-            hres = call_function(ctx, function, this_obj, cnt, args, (flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE) != 0, r);
+            hres = function->vtbl->call(ctx, function, this_obj, flags, cnt, args, r);
         }else {
             jsval_t res;
             hres = disp_call_value(ctx, jsthis->u.disp, this_obj, DISPATCH_METHOD, cnt, args, &res);
···
         cnt = argc-1;
     }
 
-    hres = call_function(ctx, function, this_obj, cnt, argv+1, (flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE) != 0, r);
+    hres = function->vtbl->call(ctx, function, this_obj, flags, cnt, argv + 1, r);
 
     if(this_obj)
         IDispatch_Release(this_obj);
     return hres;
 }
 
+static HRESULT Function_bind(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
+        jsval_t *r)
+{
+    FunctionInstance *function;
+    jsdisp_t *new_function;
+    HRESULT hres;
+
+    TRACE("\n");
+
+    if(!(function = function_this(jsthis)))
+        return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
+
+    if(argc < 1) {
+        FIXME("no this argument\n");
+        return E_NOTIMPL;
+    }
+
+    if(!is_object_instance(argv[0]) || !get_object(argv[0])) {
+        FIXME("%s is not an object instance\n", debugstr_jsval(argv[0]));
+        return E_NOTIMPL;
+    }
+
+    hres = create_bind_function(ctx, function, get_object(argv[0]), argc - 1, argv + 1, &new_function);
+    if(FAILED(hres))
+        return hres;
+
+    if(r)
+        *r = jsval_obj(new_function);
+    else
+        jsdisp_release(new_function);
+    return S_OK;
+}
+
 HRESULT Function_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
···
     }
 
     function = function_from_jsdisp(jsthis->u.jsdisp);
-
-    assert(function->value_proc != NULL);
-    return invoke_value_proc(ctx, function, NULL, flags, argc, argv, r);
+    return function->vtbl->call(ctx, function, NULL, flags, argc, argv, r);
 }
 
 HRESULT Function_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
 {
+    FunctionInstance *function = function_from_jsdisp(jsthis);
     jsstr_t *str;
     HRESULT hres;
 
     TRACE("\n");
 
-    hres = function_to_string(function_from_jsdisp(jsthis), &str);
+    hres = function->vtbl->toString(function, &str);
     if(FAILED(hres))
         return hres;
 
···
 
 static void Function_destructor(jsdisp_t *dispex)
 {
-    FunctionInstance *This = function_from_jsdisp(dispex);
-
-    if(This->code)
-        release_bytecode(This->code);
-    if(This->scope_chain)
-        scope_release(This->scope_chain);
-    heap_free(This);
+    FunctionInstance *function = function_from_jsdisp(dispex);
+    function->vtbl->destructor(function);
+    heap_free(function);
 }
 
 static const builtin_prop_t Function_props[] = {
     {applyW,                 Function_apply,                 PROPF_METHOD|2},
     {argumentsW,             NULL, 0,                        Function_get_arguments},
+    {bindW,                  Function_bind,                  PROPF_METHOD|PROPF_ES5|1},
     {callW,                  Function_call,                  PROPF_METHOD|1},
     {lengthW,                NULL, 0,                        Function_get_length},
     {toStringW,              Function_toString,              PROPF_METHOD}
···
     NULL
 };
 
-static HRESULT create_function(script_ctx_t *ctx, const builtin_info_t *builtin_info, DWORD flags,
-        BOOL funcprot, jsdisp_t *prototype, FunctionInstance **ret)
+static HRESULT create_function(script_ctx_t *ctx, const builtin_info_t *builtin_info, const function_vtbl_t *vtbl, size_t size,
+        DWORD flags, BOOL funcprot, jsdisp_t *prototype, void **ret)
 {
     FunctionInstance *function;
     HRESULT hres;
 
-    function = heap_alloc_zero(sizeof(FunctionInstance));
+    function = heap_alloc_zero(size);
     if(!function)
         return E_OUTOFMEMORY;
 
···
         return hres;
     }
 
+    function->vtbl = vtbl;
     function->flags = flags;
     function->length = flags & PROPF_ARGMASK;
 
···
     return S_OK;
 }
 
+static HRESULT NativeFunction_call(script_ctx_t *ctx, FunctionInstance *func, IDispatch *this_disp, unsigned flags,
+        unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    NativeFunction *function = (NativeFunction*)func;
+    vdisp_t vthis;
+    HRESULT hres;
+
+    if(this_disp)
+        set_disp(&vthis, this_disp);
+    else if(ctx->host_global)
+        set_disp(&vthis, ctx->host_global);
+    else
+        set_jsdisp(&vthis, ctx->global);
+
+    hres = function->proc(ctx, &vthis, flags & ~DISPATCH_JSCRIPT_INTERNAL_MASK, argc, argv, r);
+
+    vdisp_release(&vthis);
+    return hres;
+}
+
+static HRESULT NativeFunction_toString(FunctionInstance *func, jsstr_t **ret)
+{
+    NativeFunction *function = (NativeFunction*)func;
+    DWORD name_len;
+    jsstr_t *str;
+    WCHAR *ptr;
+
+    static const WCHAR native_prefixW[] = {'\n','f','u','n','c','t','i','o','n',' '};
+    static const WCHAR native_suffixW[] =
+        {'(',')',' ','{','\n',' ',' ',' ',' ','[','n','a','t','i','v','e',' ','c','o','d','e',']','\n','}','\n'};
+
+    name_len = function->name ? lstrlenW(function->name) : 0;
+    str = jsstr_alloc_buf(ARRAY_SIZE(native_prefixW) + ARRAY_SIZE(native_suffixW) + name_len, &ptr);
+    if(!str)
+        return E_OUTOFMEMORY;
+
+    memcpy(ptr, native_prefixW, sizeof(native_prefixW));
+    ptr += ARRAY_SIZE(native_prefixW);
+    memcpy(ptr, function->name, name_len*sizeof(WCHAR));
+    ptr += name_len;
+    memcpy(ptr, native_suffixW, sizeof(native_suffixW));
+
+    *ret = str;
+    return S_OK;
+}
+
+static void NativeFunction_destructor(FunctionInstance *function)
+{
+}
+
+static const function_vtbl_t NativeFunctionVtbl = {
+    NativeFunction_call,
+    NativeFunction_toString,
+    NativeFunction_destructor
+};
+
 HRESULT create_builtin_function(script_ctx_t *ctx, builtin_invoke_t value_proc, const WCHAR *name,
         const builtin_info_t *builtin_info, DWORD flags, jsdisp_t *prototype, jsdisp_t **ret)
 {
-    FunctionInstance *function;
+    NativeFunction *function;
     HRESULT hres;
 
-    hres = create_function(ctx, builtin_info, flags, FALSE, NULL, &function);
+    hres = create_function(ctx, builtin_info, &NativeFunctionVtbl, sizeof(NativeFunction), flags, FALSE, NULL, (void**)&function);
     if(FAILED(hres))
         return hres;
 
     if(builtin_info)
-        hres = jsdisp_define_data_property(&function->dispex, lengthW, 0,
-                                           jsval_number(function->length));
+        hres = jsdisp_define_data_property(&function->function.dispex, lengthW, 0,
+                                           jsval_number(function->function.length));
     if(SUCCEEDED(hres))
-        hres = jsdisp_define_data_property(&function->dispex, prototypeW, 0, jsval_obj(prototype));
+        hres = jsdisp_define_data_property(&function->function.dispex, prototypeW, 0, jsval_obj(prototype));
     if(FAILED(hres)) {
-        jsdisp_release(&function->dispex);
+        jsdisp_release(&function->function.dispex);
         return hres;
     }
 
-    function->value_proc = value_proc;
+    function->proc = value_proc;
     function->name = name;
 
-    *ret = &function->dispex;
+    *ret = &function->function.dispex;
     return S_OK;
 }
 
···
     return S_OK;
 }
 
+static HRESULT InterpretedFunction_call(script_ctx_t *ctx, FunctionInstance *func, IDispatch *this_obj, unsigned flags,
+         unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    InterpretedFunction *function = (InterpretedFunction*)func;
+    jsdisp_t *var_disp, *new_obj = NULL;
+    DWORD exec_flags = 0;
+    HRESULT hres;
+
+    TRACE("%p\n", function);
+
+    if(ctx->state == SCRIPTSTATE_UNINITIALIZED || ctx->state == SCRIPTSTATE_CLOSED) {
+        WARN("Script engine state does not allow running code.\n");
+        return E_UNEXPECTED;
+    }
+
+    if(flags & DISPATCH_CONSTRUCT) {
+        hres = create_object(ctx, &function->function.dispex, &new_obj);
+        if(FAILED(hres))
+            return hres;
+        this_obj = to_disp(new_obj);
+    }
+
+    if(flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE)
+        exec_flags |= EXEC_RETURN_TO_INTERP;
+    if(flags & DISPATCH_CONSTRUCT)
+        exec_flags |= EXEC_CONSTRUCTOR;
+
+    hres = create_dispex(ctx, NULL, NULL, &var_disp);
+    if(SUCCEEDED(hres))
+        hres = exec_source(ctx, exec_flags, function->code, function->func_code, function->scope_chain, this_obj,
+                           &function->function.dispex, var_disp, argc, argv, r);
+    if(new_obj)
+        jsdisp_release(new_obj);
+
+    jsdisp_release(var_disp);
+    return hres;
+}
+
+static HRESULT InterpretedFunction_toString(FunctionInstance *func, jsstr_t **ret)
+{
+    InterpretedFunction *function = (InterpretedFunction*)func;
+
+    *ret = jsstr_alloc_len(function->func_code->source, function->func_code->source_len);
+    return *ret ? S_OK : E_OUTOFMEMORY;
+}
+
+static void InterpretedFunction_destructor(FunctionInstance *func)
+{
+    InterpretedFunction *function = (InterpretedFunction*)func;
+
+    release_bytecode(function->code);
+    if(function->scope_chain)
+        scope_release(function->scope_chain);
+}
+
+static const function_vtbl_t InterpretedFunctionVtbl = {
+    InterpretedFunction_call,
+    InterpretedFunction_toString,
+    InterpretedFunction_destructor
+};
+
 HRESULT create_source_function(script_ctx_t *ctx, bytecode_t *code, function_code_t *func_code,
         scope_chain_t *scope_chain, jsdisp_t **ret)
 {
-    FunctionInstance *function;
+    InterpretedFunction *function;
     jsdisp_t *prototype;
     HRESULT hres;
 
···
     if(FAILED(hres))
         return hres;
 
-    hres = create_function(ctx, NULL, PROPF_CONSTR, FALSE, NULL, &function);
+    hres = create_function(ctx, NULL, &InterpretedFunctionVtbl, sizeof(InterpretedFunction), PROPF_CONSTR,
+                           FALSE, NULL, (void**)&function);
     if(SUCCEEDED(hres)) {
-        hres = jsdisp_define_data_property(&function->dispex, prototypeW, PROPF_WRITABLE,
+        hres = jsdisp_define_data_property(&function->function.dispex, prototypeW, PROPF_WRITABLE,
                                            jsval_obj(prototype));
         if(SUCCEEDED(hres))
-            hres = set_constructor_prop(ctx, &function->dispex, prototype);
+            hres = set_constructor_prop(ctx, &function->function.dispex, prototype);
         if(FAILED(hres))
-            jsdisp_release(&function->dispex);
+            jsdisp_release(&function->function.dispex);
     }
     jsdisp_release(prototype);
     if(FAILED(hres))
···
     bytecode_addref(code);
     function->code = code;
     function->func_code = func_code;
-    function->length = function->func_code->param_cnt;
+    function->function.length = function->func_code->param_cnt;
 
-    *ret = &function->dispex;
+    *ret = &function->function.dispex;
+    return S_OK;
+}
+
+static HRESULT BindFunction_call(script_ctx_t *ctx, FunctionInstance *func, IDispatch *this_obj, unsigned flags,
+         unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    BindFunction *function = (BindFunction*)func;
+    jsval_t *call_args = NULL;
+    unsigned call_argc;
+    HRESULT hres;
+
+    TRACE("%p\n", function);
+
+    call_argc = function->argc + argc;
+    if(call_argc) {
+        call_args = heap_alloc(function->argc * sizeof(*function->args));
+        if(!call_args)
+            return E_OUTOFMEMORY;
+
+        if(function->argc)
+            memcpy(call_args, function->args, function->argc * sizeof(*call_args));
+        if(argc)
+            memcpy(call_args + function->argc, argv, argc * sizeof(*call_args));
+    }
+
+    hres = function->target->vtbl->call(ctx, function->target, function->this, flags, call_argc, call_args, r);
+
+    heap_free(call_args);
+    return hres;
+}
+
+static HRESULT BindFunction_toString(FunctionInstance *function, jsstr_t **ret)
+{
+    static const WCHAR native_functionW[] =
+        {'\n','f','u','n','c','t','i','o','n','(',')',' ','{','\n',
+         ' ',' ',' ',' ','[','n','a','t','i','v','e',' ','c','o','d','e',']','\n',
+         '}','\n',0};
+
+    *ret = jsstr_alloc(native_functionW);
+    return *ret ? S_OK : E_OUTOFMEMORY;
+}
+
+static void BindFunction_destructor(FunctionInstance *func)
+{
+    BindFunction *function = (BindFunction*)func;
+    unsigned i;
+
+    TRACE("%p\n", function);
+
+    for(i = 0; i < function->argc; i++)
+        jsval_release(function->args[i]);
+    jsdisp_release(&function->target->dispex);
+    IDispatch_Release(function->this);
+}
+
+static const function_vtbl_t BindFunctionVtbl = {
+    BindFunction_call,
+    BindFunction_toString,
+    BindFunction_destructor
+};
+
+static HRESULT create_bind_function(script_ctx_t *ctx, FunctionInstance *target, IDispatch *bound_this, unsigned argc,
+                                    jsval_t *argv, jsdisp_t **ret)
+{
+    BindFunction *function;
+    HRESULT hres;
+
+    hres = create_function(ctx, NULL, &BindFunctionVtbl, FIELD_OFFSET(BindFunction, args[argc]), PROPF_METHOD,
+                           FALSE, NULL, (void**)&function);
+    if(FAILED(hres))
+        return hres;
+
+    jsdisp_addref(&target->dispex);
+    function->target = target;
+
+    IDispatch_AddRef(function->this = bound_this);
+
+    for(function->argc = 0; function->argc < argc; function->argc++) {
+        hres = jsval_copy(argv[function->argc], function->args + function->argc);
+        if(FAILED(hres)) {
+            jsdisp_release(&function->function.dispex);
+            return hres;
+        }
+    }
+
+    function->function.length = target->length > argc ? target->length - argc : 0;
+
+    *ret = &function->function.dispex;
     return S_OK;
 }
 
···
 
 HRESULT init_function_constr(script_ctx_t *ctx, jsdisp_t *object_prototype)
 {
-    FunctionInstance *prot, *constr;
+    NativeFunction *prot, *constr;
     HRESULT hres;
 
     static const WCHAR FunctionW[] = {'F','u','n','c','t','i','o','n',0};
 
-    hres = create_function(ctx, &Function_info, PROPF_CONSTR, TRUE, object_prototype, &prot);
+    hres = create_function(ctx, &Function_info, &NativeFunctionVtbl, sizeof(NativeFunction), PROPF_CONSTR,
+                           TRUE, object_prototype, (void**)&prot);
     if(FAILED(hres))
         return hres;
 
-    prot->value_proc = FunctionProt_value;
+    prot->proc = FunctionProt_value;
     prot->name = prototypeW;
 
-    hres = create_function(ctx, &FunctionInst_info, PROPF_CONSTR|1, TRUE, &prot->dispex, &constr);
+    hres = create_function(ctx, &FunctionInst_info, &NativeFunctionVtbl, sizeof(NativeFunction), PROPF_CONSTR|1,
+                           TRUE, &prot->function.dispex, (void**)&constr);
     if(SUCCEEDED(hres)) {
-        constr->value_proc = FunctionConstr_value;
+        constr->proc = FunctionConstr_value;
         constr->name = FunctionW;
-        hres = jsdisp_define_data_property(&constr->dispex, prototypeW, 0, jsval_obj(&prot->dispex));
+        hres = jsdisp_define_data_property(&constr->function.dispex, prototypeW, 0, jsval_obj(&prot->function.dispex));
         if(SUCCEEDED(hres))
-            hres = set_constructor_prop(ctx, &constr->dispex, &prot->dispex);
+            hres = set_constructor_prop(ctx, &constr->function.dispex, &prot->function.dispex);
         if(FAILED(hres))
-            jsdisp_release(&constr->dispex);
+            jsdisp_release(&constr->function.dispex);
     }
-    jsdisp_release(&prot->dispex);
+    jsdisp_release(&prot->function.dispex);
     if(FAILED(hres))
         return hres;
 
-    ctx->function_constr = &constr->dispex;
+    ctx->function_constr = &constr->function.dispex;
     return S_OK;
 }

dll/win32/jscript/global.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 #include <limits.h>
···
 HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
         jsval_t *r)
 {
-    call_frame_t *frame;
+    call_frame_t *frame = ctx->call_ctx;
     DWORD exec_flags = EXEC_EVAL;
     bytecode_t *code;
     const WCHAR *src;
···
         return S_OK;
     }
 
-    if(!(frame = ctx->call_ctx)) {
-        FIXME("No active exec_ctx\n");
-        return E_UNEXPECTED;
-    }
-
     src = jsstr_flatten(get_string(argv[0]));
     if(!src)
         return E_OUTOFMEMORY;
···
         return throw_syntax_error(ctx, hres, NULL);
     }
 
-    if(frame->flags & EXEC_GLOBAL)
+    if(!frame || (frame->flags & EXEC_GLOBAL))
         exec_flags |= EXEC_GLOBAL;
     if(flags & DISPATCH_JSCRIPT_CALLEREXECSSOURCE)
         exec_flags |= EXEC_RETURN_TO_INTERP;
-    hres = exec_source(ctx, exec_flags, code, &code->global_code, frame->scope,
-            frame->this_obj, NULL, frame->variable_obj, 0, NULL, r);
+    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);
     release_bytecode(code);
     return hres;
 }
···
     if(FAILED(hres))
         return hres;
 
-    while(isspaceW(*ptr))
+    while(iswspace(*ptr))
         ptr++;
 
     switch(*ptr) {
···
         }else {
             radix = 10;
         }
+    }else if(radix == 16 && *ptr == '0' && (ptr[1] == 'x' || ptr[1] == 'X')) {
+        ptr += 2;
     }
 
     i = char_to_int(*ptr++);
···
     if(FAILED(hres))
         return hres;
 
-    while(isspaceW(*str)) str++;
+    while(iswspace(*str)) str++;
 
     if(*str == '+')
         str++;
···
         str++;
     }
 
-    if(isdigitW(*str))
+    if(iswdigit(*str))
         ret_nan = FALSE;
 
-    while(isdigitW(*str)) {
+    while(iswdigit(*str)) {
         hlp = d*10 + *(str++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0) {
             exp++;
···
         else
             d = hlp;
     }
-    while(isdigitW(*str)) {
+    while(iswdigit(*str)) {
         exp++;
         str++;
     }
 
     if(*str == '.') str++;
 
-    if(isdigitW(*str))
+    if(iswdigit(*str))
         ret_nan = FALSE;
 
-    while(isdigitW(*str)) {
+    while(iswdigit(*str)) {
         hlp = d*10 + *(str++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0)
             break;
···
         d = hlp;
         exp--;
     }
-    while(isdigitW(*str))
+    while(iswdigit(*str))
         str++;
 
     if(*str && !ret_nan && (*str=='e' || *str=='E')) {
···
             str++;
         }
 
-        while(isdigitW(*str)) {
+        while(iswdigit(*str)) {
             if(e>INT_MAX/10 || (e = e*10 + *str++ - '0')<0)
                 e = INT_MAX;
         }
···
 }
 
 static inline int hex_to_int(const WCHAR wch) {
-    if(toupperW(wch)>='A' && toupperW(wch)<='F') return toupperW(wch)-'A'+10;
-    if(isdigitW(wch)) return wch-'0';
+    if(towupper(wch)>='A' && towupper(wch)<='F') return towupper(wch)-'A'+10;
+    if(iswdigit(wch)) return wch-'0';
     return -1;
 }
 

dll/win32/jscript/jscript.h

···
 
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdint.h>
 
 #define COBJMACROS
 
 #include "windef.h"
 #include "winbase.h"
 #include "winuser.h"
+#ifdef __REACTOS__
+#include "winnls.h"
+#endif
 #include "ole2.h"
 #include "dispex.h"
 #include "activscp.h"
 
 #include "resource.h"
 
-#include "wine/unicode.h"
 #include "wine/heap.h"
 #include "wine/list.h"
 
···
     if(str) {
         DWORD size;
 
-        size = (strlenW(str)+1)*sizeof(WCHAR);
+        size = (lstrlenW(str)+1)*sizeof(WCHAR);
         ret = heap_alloc(size);
         if(ret)
             memcpy(ret, str, size);
···
 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 create_builtin_function(script_ctx_t*,builtin_invoke_t,const WCHAR*,const builtin_info_t*,DWORD,
         jsdisp_t*,jsdisp_t**) DECLSPEC_HIDDEN;
···
 {
     return is_jsdisp(vdisp) && is_class(vdisp->u.jsdisp, class);
 }
-
-#ifndef INT32_MIN
-#define INT32_MIN (-2147483647-1)
-#endif
-
-#ifndef INT32_MAX
-#define INT32_MAX (2147483647)
-#endif
 
 static inline BOOL is_int32(double d)
 {

dll/win32/jscript/json.c

···
 #include "parser.h"
 
 #include "wine/debug.h"
-#include "wine/unicode.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
···
         return E_OUTOFMEMORY;
     if(len)
         memcpy(buf, ptr, len*sizeof(WCHAR));
-    buf[len] = 0;
 
-    if(!unescape(buf)) {
+    if(!unescape(buf, &len)) {
         FIXME("unescape failed\n");
         heap_free(buf);
         return E_FAIL;
     }
 
+    buf[len] = 0;
     ctx->ptr++;
     *r = buf;
     return S_OK;
···
             skip_spaces(ctx);
         }
 
-        if(!isdigitW(*ctx->ptr))
+        if(*ctx->ptr == '0' && ctx->ptr + 1 < ctx->end && iswdigit(ctx->ptr[1]))
             break;
 
-        if(*ctx->ptr == '0') {
-            ctx->ptr++;
-            n = 0;
-            if(is_identifier_char(*ctx->ptr))
-                break;
-        }else {
-            hres = parse_decimal(&ctx->ptr, ctx->end, &n);
-            if(FAILED(hres))
-                return hres;
-        }
+        hres = parse_decimal(&ctx->ptr, ctx->end, &n);
+        if(FAILED(hres))
+            break;
 
         *r = jsval_number(sign*n);
         return S_OK;
···
 
 static inline BOOL append_string(stringify_ctx_t *ctx, const WCHAR *str)
 {
-    return append_string_len(ctx, str, strlenW(str));
+    return append_string_len(ctx, str, lstrlenW(str));
 }
 
 static inline BOOL append_char(stringify_ctx_t *ctx, WCHAR c)
···
             if(*ptr < ' ') {
                 static const WCHAR formatW[] = {'\\','u','%','0','4','x',0};
                 WCHAR buf[7];
-                sprintfW(buf, formatW, *ptr);
+                swprintf(buf, formatW, *ptr);
                 if(!append_string(ctx, buf))
                     return E_OUTOFMEMORY;
             }else {

dll/win32/jscript/jsregexp.c

···
     const WCHAR *str;
     HRESULT hres;
 
-    TRACE("%s %x\n", debugstr_jsstr(src), flags);
-
     str = jsstr_flatten(src);
     if(!str)
         return E_OUTOFMEMORY;
+
+    TRACE("%s %x\n", debugstr_wn(str, jsstr_length(src)), flags);
 
     hres = alloc_regexp(ctx, NULL, &regexp);
     if(FAILED(hres))

dll/win32/jscript/jsstr.h

···
 
 static inline jsstr_t *jsstr_alloc(const WCHAR *str)
 {
-    return jsstr_alloc_len(str, strlenW(str));
+    return jsstr_alloc_len(str, lstrlenW(str));
 }
 
 void jsstr_free(jsstr_t*) DECLSPEC_HIDDEN;

dll/win32/jscript/jsutils.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 #include <assert.h>
···
         *r = jsval_disp(V_DISPATCH(var));
         return S_OK;
     }
+    case VT_I1:
+        *r = jsval_number(V_I1(var));
+        return S_OK;
+    case VT_UI1:
+        *r = jsval_number(V_UI1(var));
+        return S_OK;
     case VT_I2:
         *r = jsval_number(V_I2(var));
         return S_OK;
···
     if(!ptr)
         return E_OUTOFMEMORY;
 
-    while(isspaceW(*ptr))
+    while(iswspace(*ptr))
         ptr++;
 
     if(*ptr == '-') {
···
         ptr++;
     }
 
-    if(!strncmpW(ptr, infinityW, ARRAY_SIZE(infinityW))) {
+    if(!wcsncmp(ptr, infinityW, ARRAY_SIZE(infinityW))) {
         ptr += ARRAY_SIZE(infinityW);
-        while(*ptr && isspaceW(*ptr))
+        while(*ptr && iswspace(*ptr))
             ptr++;
 
         if(*ptr)
···
         return S_OK;
     }
 
-    while(isdigitW(*ptr))
+    while(iswdigit(*ptr))
         d = d*10 + (*ptr++ - '0');
 
     if(*ptr == 'e' || *ptr == 'E') {
···
             ptr++;
         }
 
-        while(isdigitW(*ptr))
+        while(iswdigit(*ptr))
             l = l*10 + (*ptr++ - '0');
         if(eneg)
             l = -l;
···
         DOUBLE dec = 0.1;
 
         ptr++;
-        while(isdigitW(*ptr)) {
+        while(iswdigit(*ptr)) {
             d += dec * (*ptr++ - '0');
             dec *= 0.1;
         }
     }
 
-    while(isspaceW(*ptr))
+    while(iswspace(*ptr))
         ptr++;
 
     if(*ptr) {
···
             else
                 V_I2(dst) = i;
         }
+        break;
+    }
+    case VT_UI2: {
+        UINT32 i;
+
+        hres = to_uint32(ctx, val, &i);
+        if(SUCCEEDED(hres))
+            V_UI2(dst) = i;
         break;
     }
     case VT_R8: {

dll/win32/jscript/lex.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
 
 #include <limits.h>
+#include <math.h>
 
 #include "jscript.h"
 #include "activscp.h"
···
 #include "parser.tab.h"
 
 #include "wine/debug.h"
-#include "wine/unicode.h"
-
-#ifdef __REACTOS__
-/* FIXME: Inspect - For some reason these exist in the generated header but are not picked up */
-#define kGET (270)
-#define kSET (272)
-#endif
 
 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
 
-static const WCHAR breakW[] = {'b','r','e','a','k',0};
-static const WCHAR caseW[] = {'c','a','s','e',0};
-static const WCHAR catchW[] = {'c','a','t','c','h',0};
-static const WCHAR continueW[] = {'c','o','n','t','i','n','u','e',0};
-static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
-static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
-static const WCHAR doW[] = {'d','o',0};
-static const WCHAR elseW[] = {'e','l','s','e',0};
-static const WCHAR falseW[] = {'f','a','l','s','e',0};
-static const WCHAR finallyW[] = {'f','i','n','a','l','l','y',0};
-static const WCHAR forW[] = {'f','o','r',0};
-static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
-static const WCHAR getW[] = {'g','e','t',0};
-static const WCHAR ifW[] = {'i','f',0};
-static const WCHAR inW[] = {'i','n',0};
-static const WCHAR instanceofW[] = {'i','n','s','t','a','n','c','e','o','f',0};
-static const WCHAR newW[] = {'n','e','w',0};
-static const WCHAR nullW[] = {'n','u','l','l',0};
-static const WCHAR returnW[] = {'r','e','t','u','r','n',0};
-static const WCHAR setW[] = {'s','e','t',0};
-static const WCHAR switchW[] = {'s','w','i','t','c','h',0};
-static const WCHAR thisW[] = {'t','h','i','s',0};
-static const WCHAR throwW[] = {'t','h','r','o','w',0};
-static const WCHAR trueW[] = {'t','r','u','e',0};
-static const WCHAR tryW[] = {'t','r','y',0};
-static const WCHAR typeofW[] = {'t','y','p','e','o','f',0};
-static const WCHAR varW[] = {'v','a','r',0};
-static const WCHAR voidW[] = {'v','o','i','d',0};
-static const WCHAR whileW[] = {'w','h','i','l','e',0};
-static const WCHAR withW[] = {'w','i','t','h',0};
-
-static const WCHAR elifW[] = {'e','l','i','f',0};
-static const WCHAR endW[] = {'e','n','d',0};
-
 static const struct {
     const WCHAR *word;
     int token;
     BOOL no_nl;
     unsigned min_version;
 } keywords[] = {
-    {breakW,       kBREAK,       TRUE},
-    {caseW,        kCASE},
-    {catchW,       kCATCH},
-    {continueW,    kCONTINUE,    TRUE},
-    {defaultW,     kDEFAULT},
-    {deleteW,      kDELETE},
-    {doW,          kDO},
-    {elseW,        kELSE},
-    {falseW,       kFALSE},
-    {finallyW,     kFINALLY},
-    {forW,         kFOR},
-    {functionW,    kFUNCTION},
-    {getW,         kGET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
-    {ifW,          kIF},
-    {inW,          kIN},
-    {instanceofW,  kINSTANCEOF},
-    {newW,         kNEW},
-    {nullW,        kNULL},
-    {returnW,      kRETURN,      TRUE},
-    {setW,         kSET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
-    {switchW,      kSWITCH},
-    {thisW,        kTHIS},
-    {throwW,       kTHROW},
-    {trueW,        kTRUE},
-    {tryW,         kTRY},
-    {typeofW,      kTYPEOF},
-    {varW,         kVAR},
-    {voidW,        kVOID},
-    {whileW,       kWHILE},
-    {withW,        kWITH}
+    {L"break",       kBREAK,       TRUE},
+    {L"case",        kCASE},
+    {L"catch",       kCATCH},
+    {L"continue",    kCONTINUE,    TRUE},
+    {L"default",     kDEFAULT},
+    {L"delete",      kDELETE},
+    {L"do",          kDO},
+    {L"else",        kELSE},
+    {L"false",       kFALSE},
+    {L"finally",     kFINALLY},
+    {L"for",         kFOR},
+    {L"function",    kFUNCTION},
+    {L"get",         kGET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
+    {L"if",          kIF},
+    {L"in",          kIN},
+    {L"instanceof",  kINSTANCEOF},
+    {L"new",         kNEW},
+    {L"null",        kNULL},
+    {L"return",      kRETURN,      TRUE},
+    {L"set",         kSET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
+    {L"switch",      kSWITCH},
+    {L"this",        kTHIS},
+    {L"throw",       kTHROW},
+    {L"true",        kTRUE},
+    {L"try",         kTRY},
+    {L"typeof",      kTYPEOF},
+    {L"var",         kVAR},
+    {L"void",        kVOID},
+    {L"while",       kWHILE},
+    {L"with",        kWITH}
 };
 
 static int lex_error(parser_ctx_t *ctx, HRESULT hres)
···
 /* ECMA-262 3rd Edition    7.6 */
 BOOL is_identifier_char(WCHAR c)
 {
-    return isalnumW(c) || c == '$' || c == '_' || c == '\\';
+    return iswalnum(c) || c == '$' || c == '_' || c == '\\';
 }
 
 static BOOL is_identifier_first_char(WCHAR c)
 {
-    return isalphaW(c) || c == '$' || c == '_' || c == '\\';
+    return iswalpha(c) || c == '$' || c == '_' || c == '\\';
 }
 
 static int check_keyword(parser_ctx_t *ctx, const WCHAR *word, const WCHAR **lval)
···
             if(ctx->script->version < keywords[i].min_version) {
                 TRACE("ignoring keyword %s in incompatible mode\n",
                       debugstr_w(keywords[i].word));
-                ctx->ptr -= strlenW(keywords[i].word);
+                ctx->ptr -= lstrlenW(keywords[i].word);
                 return 0;
             }
             ctx->implicit_nl_semicolon = keywords[i].no_nl;
···
 
 static BOOL skip_spaces(parser_ctx_t *ctx)
 {
-    while(ctx->ptr < ctx->end && (isspaceW(*ctx->ptr) || *ctx->ptr == 0xFEFF /* UTF16 BOM */)) {
+    while(ctx->ptr < ctx->end && (iswspace(*ctx->ptr) || *ctx->ptr == 0xFEFF /* UTF16 BOM */)) {
         if(is_endline(*ctx->ptr++))
             ctx->nl = TRUE;
     }
···
     return ctx->ptr != ctx->end;
 }
 
-BOOL unescape(WCHAR *str)
+BOOL unescape(WCHAR *str, size_t *len)
 {
-    WCHAR *pd, *p, c;
+    WCHAR *pd, *p, c, *end = str + *len;
     int i;
 
     pd = p = str;
-    while(*p) {
+    while(p < end) {
         if(*p != '\\') {
             *pd++ = *p++;
             continue;
         }
 
-        p++;
+        if(++p == end)
+            return FALSE;
 
         switch(*p) {
         case '\'':
···
             c = '\r';
             break;
         case 'x':
+            if(p + 2 >= end)
+                return FALSE;
             i = hex_to_int(*++p);
             if(i == -1)
                 return FALSE;
···
             c += i;
             break;
         case 'u':
+            if(p + 4 >= end)
+                return FALSE;
             i = hex_to_int(*++p);
             if(i == -1)
                 return FALSE;
···
             c += i;
             break;
         default:
-            if(isdigitW(*p)) {
+            if(iswdigit(*p)) {
                 c = *p++ - '0';
-                if(isdigitW(*p)) {
+                if(p < end && iswdigit(*p)) {
                     c = c*8 + (*p++ - '0');
-                    if(isdigitW(*p))
+                    if(p < end && iswdigit(*p))
                         c = c*8 + (*p++ - '0');
                 }
                 p--;
···
         p++;
     }
 
-    *pd = 0;
+    *len = pd - str;
     return TRUE;
 }
 
···
     return tIdentifier;
 }
 
-static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret, WCHAR endch)
+static int parse_string_literal(parser_ctx_t *ctx, jsstr_t **ret, WCHAR endch)
 {
-    const WCHAR *ptr = ++ctx->ptr;
-    WCHAR *wstr;
-    int len;
+    const WCHAR *ptr = ++ctx->ptr, *ret_str = ptr;
+    BOOL needs_unescape = FALSE;
+    WCHAR *unescape_str;
+    size_t len;
 
     while(ctx->ptr < ctx->end && *ctx->ptr != endch) {
-        if(*ctx->ptr++ == '\\')
+        if(*ctx->ptr++ == '\\') {
             ctx->ptr++;
+            needs_unescape = TRUE;
+        }
     }
 
     if(ctx->ptr == ctx->end)
         return lex_error(ctx, JS_E_UNTERMINATED_STRING);
 
-    len = ctx->ptr-ptr;
-
-    *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
-    memcpy(wstr, ptr, len*sizeof(WCHAR));
-    wstr[len] = 0;
-
+    len = ctx->ptr - ptr;
     ctx->ptr++;
 
-    if(!unescape(wstr)) {
-        WARN("unescape failed\n");
-        return lex_error(ctx, E_FAIL);
+    if(needs_unescape) {
+        ret_str = unescape_str = parser_alloc(ctx, len * sizeof(WCHAR));
+        if(!unescape_str)
+            return lex_error(ctx, E_OUTOFMEMORY);
+        memcpy(unescape_str, ptr, len * sizeof(WCHAR));
+        if(!unescape(unescape_str, &len)) {
+            WARN("unescape failed\n");
+            return lex_error(ctx, E_FAIL);
+        }
     }
 
+    if(!(*ret = compiler_alloc_string_len(ctx->compiler, ret_str, len)))
+        return lex_error(ctx, E_OUTOFMEMORY);
+
+    /* FIXME: leaking string */
     return tStringLiteral;
 }
 
···
     LONGLONG d = 0, hlp;
     int exp = 0;
 
-    while(ptr < end && isdigitW(*ptr)) {
+    while(ptr < end && iswdigit(*ptr)) {
         hlp = d*10 + *(ptr++) - '0';
         if(d>MAXLONGLONG/10 || hlp<0) {
             exp++;
···
         else
             d = hlp;
     }
-    while(ptr < end && isdigitW(*ptr)) {
+    while(ptr < end && iswdigit(*ptr)) {
         exp++;
         ptr++;
     }
···
     if(*ptr == '.') {
         ptr++;
 
-        while(ptr < end && isdigitW(*ptr)) {
+        while(ptr < end && iswdigit(*ptr)) {
             hlp = d*10 + *(ptr++) - '0';
             if(d>MAXLONGLONG/10 || hlp<0)
                 break;
···
             d = hlp;
             exp--;
         }
-        while(ptr < end && isdigitW(*ptr))
+        while(ptr < end && iswdigit(*ptr))
             ptr++;
     }
 
···
             }else if(*ptr == '-') {
                 sign = -1;
                 ptr++;
-            }else if(!isdigitW(*ptr)) {
+            }else if(!iswdigit(*ptr)) {
                 WARN("Expected exponent part\n");
                 return E_FAIL;
             }
···
             return E_FAIL;
         }
 
-        while(ptr < end && isdigitW(*ptr)) {
+        while(ptr < end && iswdigit(*ptr)) {
             if(e > INT_MAX/10 || (e = e*10 + *ptr++ - '0')<0)
                 e = INT_MAX;
         }
···
             return TRUE;
         }
 
-        if(isdigitW(*ctx->ptr)) {
+        if(iswdigit(*ctx->ptr)) {
             unsigned base = 8;
             const WCHAR *ptr;
             double val = 0;
 
-            for(ptr = ctx->ptr; ptr < ctx->end && isdigitW(*ptr); ptr++) {
+            for(ptr = ctx->ptr; ptr < ctx->end && iswdigit(*ptr); ptr++) {
                 if(*ptr > '7') {
                     base = 10;
                     break;
···
 
             do {
                 val = val*base + *ctx->ptr-'0';
-            }while(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr));
+            }while(++ctx->ptr < ctx->end && iswdigit(*ctx->ptr));
 
             /* FIXME: Do we need it here? */
             if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) {
···
         ctx->implicit_nl_semicolon = FALSE;
     }
 
-    if(isalphaW(*ctx->ptr)) {
+    if(iswalpha(*ctx->ptr)) {
         int ret = check_keywords(ctx, lval);
         if(ret)
             return ret;
···
         return parse_identifier(ctx, lval);
     }
 
-    if(isdigitW(*ctx->ptr)) {
+    if(iswdigit(*ctx->ptr)) {
         double n;
 
         if(!parse_numeric_literal(ctx, &n))
···
         return '}';
 
     case '.':
-        if(ctx->ptr+1 < ctx->end && isdigitW(ctx->ptr[1])) {
+        if(ctx->ptr+1 < ctx->end && iswdigit(ctx->ptr[1])) {
             double n;
             HRESULT hres;
             hres = parse_decimal(&ctx->ptr, ctx->end, &n);
···
     cc_var_t *new_v;
 
     if(len == -1)
-        len = strlenW(name);
+        len = lstrlenW(name);
 
     new_v = heap_alloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR));
     if(!new_v)
···
 {
     cc_ctx_t *cc;
 
-    static const WCHAR _win32W[] = {'_','w','i','n','3','2',0};
-    static const WCHAR _win64W[] = {'_','w','i','n','6','4',0};
-    static const WCHAR _x86W[] = {'_','x','8','6',0};
-    static const WCHAR _amd64W[] = {'_','a','m','d','6','4',0};
-    static const WCHAR _jscriptW[] = {'_','j','s','c','r','i','p','t',0};
-    static const WCHAR _jscript_buildW[] = {'_','j','s','c','r','i','p','t','_','b','u','i','l','d',0};
-    static const WCHAR _jscript_versionW[] = {'_','j','s','c','r','i','p','t','_','v','e','r','s','i','o','n',0};
-
     if(ctx->script->cc)
         return TRUE;
 
···
 
     cc->vars = NULL;
 
-    if(!new_cc_var(cc, _jscriptW, -1, ccval_bool(TRUE))
-       || !new_cc_var(cc, sizeof(void*) == 8 ? _win64W : _win32W, -1, ccval_bool(TRUE))
-       || !new_cc_var(cc, sizeof(void*) == 8 ? _amd64W : _x86W, -1, ccval_bool(TRUE))
-       || !new_cc_var(cc, _jscript_versionW, -1, ccval_num(JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0))
-       || !new_cc_var(cc, _jscript_buildW, -1, ccval_num(JSCRIPT_BUILD_VERSION))) {
+    if(!new_cc_var(cc, L"_jscript", -1, ccval_bool(TRUE))
+       || !new_cc_var(cc, sizeof(void*) == 8 ? L"_win64" : L"_win32", -1, ccval_bool(TRUE))
+       || !new_cc_var(cc, sizeof(void*) == 8 ? L"_amd64" : L"_x86", -1, ccval_bool(TRUE))
+       || !new_cc_var(cc, L"_jscript_version", -1, ccval_num(JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0))
+       || !new_cc_var(cc, L"_jscript_build", -1, ccval_num(JSCRIPT_BUILD_VERSION))) {
         release_cc(cc);
         lex_error(ctx, E_OUTOFMEMORY);
         return FALSE;
···
     if(!skip_spaces(ctx))
         return -1;
 
-    if(isdigitW(*ctx->ptr)) {
+    if(iswdigit(*ctx->ptr)) {
         double n;
 
         if(!parse_numeric_literal(ctx, &n))
···
         return 1;
     }
 
-    if(!check_keyword(ctx, trueW, NULL)) {
+    if(!check_keyword(ctx, L"true", NULL)) {
         *r = ccval_bool(TRUE);
         return 1;
     }
 
-    if(!check_keyword(ctx, falseW, NULL)) {
+    if(!check_keyword(ctx, L"false", NULL)) {
         *r = ccval_bool(FALSE);
         return 1;
     }
···
     const WCHAR *ptr;
 
     while(1) {
-        ptr = strchrW(ctx->ptr, '@');
+        ptr = wcschr(ctx->ptr, '@');
         if(!ptr) {
             WARN("No @end\n");
             return lex_error(ctx, JS_E_EXPECTED_CCEND);
         }
         ctx->ptr = ptr+1;
 
-        if(!check_keyword(ctx, endW, NULL)) {
+        if(!check_keyword(ctx, L"end", NULL)) {
             if(--if_depth)
                 continue;
             return 0;
         }
 
-        if(exec_else && !check_keyword(ctx, elifW, NULL)) {
+        if(exec_else && !check_keyword(ctx, L"elif", NULL)) {
             if(if_depth > 1)
                 continue;
 
···
             return 0;
         }
 
-        if(exec_else && !check_keyword(ctx, elseW, NULL)) {
+        if(exec_else && !check_keyword(ctx, L"else", NULL)) {
             if(if_depth > 1)
                 continue;
 
···
             return 0;
         }
 
-        if(!check_keyword(ctx, ifW, NULL)) {
+        if(!check_keyword(ctx, L"if", NULL)) {
             if_depth++;
             continue;
         }
···
 {
     unsigned id_len = 0;
     cc_var_t *var;
-
-    static const WCHAR cc_onW[] = {'c','c','_','o','n',0};
-    static const WCHAR setW[] = {'s','e','t',0};
 
     ctx->ptr++;
 
-    if(!check_keyword(ctx, cc_onW, NULL))
+    if(!check_keyword(ctx, L"cc_on", NULL))
         return init_cc(ctx) ? 0 : -1;
 
-    if(!check_keyword(ctx, setW, NULL)) {
+    if(!check_keyword(ctx, L"set", NULL)) {
         const WCHAR *ident;
         unsigned ident_len;
         cc_var_t *var;
···
         return 0;
     }
 
-    if(!check_keyword(ctx, ifW, NULL)) {
+    if(!check_keyword(ctx, L"if", NULL)) {
         if(!init_cc(ctx))
             return -1;
 
···
         return skip_code(ctx, TRUE);
     }
 
-    if(!check_keyword(ctx, elifW, NULL) || !check_keyword(ctx, elseW, NULL)) {
+    if(!check_keyword(ctx, L"elif", NULL) || !check_keyword(ctx, L"else", NULL)) {
         if(!ctx->cc_if_depth)
             return lex_error(ctx, JS_E_SYNTAX);
 
         return skip_code(ctx, FALSE);
     }
 
-    if(!check_keyword(ctx, endW, NULL)) {
+    if(!check_keyword(ctx, L"end", NULL)) {
         if(!ctx->cc_if_depth)
             return lex_error(ctx, JS_E_SYNTAX);
 
···
     re_len = ctx->ptr-re;
 
     flags_ptr = ++ctx->ptr;
-    while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr))
+    while(ctx->ptr < ctx->end && iswalnum(*ctx->ptr))
         ctx->ptr++;
 
     hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
···
 
     ret = parser_alloc(ctx, sizeof(literal_t));
     ret->type = LT_REGEXP;
-    ret->u.regexp.str = re;
-    ret->u.regexp.str_len = re_len;
+    ret->u.regexp.str = compiler_alloc_string_len(ctx->compiler, re, re_len);
     ret->u.regexp.flags = flags;
     return ret;
 }

dll/win32/jscript/math.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+#ifdef __REACTOS__
+#include <wine/config.h>
+#include <wine/port.h>
+#endif
 
 #include <math.h>
 #include <limits.h>

dll/win32/jscript/number.c

···
                     ch = '-';
                 }
                 else ch = '+';
-                sprintfW(&buf[idx], formatW, ch, (int)log_radix);
+                swprintf(&buf[idx], formatW, ch, (int)log_radix);
             }
         }
         else buf[idx] = '\0';

dll/win32/jscript/object.c

···
     {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0};
 static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0};
 
+static const WCHAR createW[] = {'c','r','e','a','t','e',0};
 static const WCHAR getOwnPropertyDescriptorW[] =
     {'g','e','t','O','w','n','P','r','o','p','e','r','t','y','D','e','s','c','r','i','p','t','o','r',0};
+static const WCHAR getPrototypeOfW[] =
+    {'g','e','t','P','r','o','t','o','t','y','p','e','O','f',0};
 static const WCHAR definePropertyW[] = {'d','e','f','i','n','e','P','r','o','p','e','r','t','y',0};
 
 static const WCHAR definePropertiesW[] = {'d','e','f','i','n','e','P','r','o','p','e','r','t','i','e','s',0};
···
         jsstr_t *ret;
         WCHAR *ptr;
 
-        ret = jsstr_alloc_buf(9+strlenW(str), &ptr);
+        ret = jsstr_alloc_buf(9+lstrlenW(str), &ptr);
         if(!ret)
             return E_OUTOFMEMORY;
 
-        sprintfW(ptr, formatW, str);
+        swprintf(ptr, formatW, str);
         *r = jsval_string(ret);
     }
 
···
     return hres;
 }
 
+static HRESULT jsdisp_define_properties(script_ctx_t *ctx, jsdisp_t *obj, jsval_t list_val)
+{
+    DISPID id = DISPID_STARTENUM;
+    property_desc_t prop_desc;
+    IDispatch *list_disp;
+    jsdisp_t *list_obj, *desc_obj;
+    jsval_t desc_val;
+    BSTR name;
+    HRESULT hres;
+
+    hres = to_object(ctx, list_val, &list_disp);
+    if(FAILED(hres))
+        return hres;
+
+    if(!(list_obj = to_jsdisp(list_disp))) {
+        FIXME("non-JS list obj\n");
+        IDispatch_Release(list_disp);
+        return E_NOTIMPL;
+    }
+
+    while(1) {
+        hres = jsdisp_next_prop(list_obj, id, TRUE, &id);
+        if(hres != S_OK)
+            break;
+
+        hres = jsdisp_propget(list_obj, id, &desc_val);
+        if(FAILED(hres))
+            break;
+
+        if(!is_object_instance(desc_val) || !get_object(desc_val) || !(desc_obj = to_jsdisp(get_object(desc_val)))) {
+            jsval_release(desc_val);
+            break;
+        }
+
+        hres = to_property_descriptor(ctx, desc_obj, &prop_desc);
+        jsdisp_release(desc_obj);
+        if(FAILED(hres))
+            break;
+
+        hres = IDispatchEx_GetMemberName(&list_obj->IDispatchEx_iface, id, &name);
+        if(SUCCEEDED(hres))
+            hres = jsdisp_define_property(obj, name, &prop_desc);
+        release_property_descriptor(&prop_desc);
+        if(FAILED(hres))
+            break;
+    }
+
+    jsdisp_release(list_obj);
+    return FAILED(hres) ? hres : S_OK;
+}
+
 static HRESULT Object_defineProperty(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
                                      unsigned argc, jsval_t *argv, jsval_t *r)
 {
···
 
     hres = jsdisp_define_property(obj, name, &prop_desc);
     release_property_descriptor(&prop_desc);
+    if(SUCCEEDED(hres) && r)
+        *r = jsval_obj(jsdisp_addref(obj));
     return hres;
 }
 
 static HRESULT Object_defineProperties(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
                                      unsigned argc, jsval_t *argv, jsval_t *r)
 {
-    FIXME("\n");
-    return E_NOTIMPL;
+    jsdisp_t *obj;
+    HRESULT hres;
+
+    if(argc < 1 || !is_object_instance(argv[0]) || !get_object(argv[0]) || !(obj = to_jsdisp(get_object(argv[0])))) {
+        FIXME("not an object\n");
+        return E_NOTIMPL;
+    }
+
+    TRACE("%p\n", obj);
+
+    hres = jsdisp_define_properties(ctx, obj, argc >= 2 ? argv[1] : jsval_undefined());
+    if(SUCCEEDED(hres) && r)
+        *r = jsval_obj(jsdisp_addref(obj));
+    return hres;
 }
 
 static HRESULT Object_getOwnPropertyDescriptor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
···
     return hres;
 }
 
+static HRESULT Object_create(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+                             unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    jsdisp_t *proto = NULL, *obj;
+    HRESULT hres;
+
+    if(!argc || (!is_object_instance(argv[0]) && !is_null(argv[0]))) {
+        FIXME("Invalid arg\n");
+        return E_INVALIDARG;
+    }
+
+    TRACE("(%s)\n", debugstr_jsval(argv[0]));
+
+    if(argc && is_object_instance(argv[0])) {
+        if(get_object(argv[0]))
+            proto = to_jsdisp(get_object(argv[0]));
+        if(!proto) {
+            FIXME("Non-JS prototype\n");
+            return E_NOTIMPL;
+        }
+    }else if(!is_null(argv[0])) {
+        FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
+        return E_INVALIDARG;
+    }
+
+    hres = create_dispex(ctx, NULL, proto, &obj);
+    if(FAILED(hres))
+        return hres;
+
+    if(argc >= 2 && !is_undefined(argv[1]))
+        hres = jsdisp_define_properties(ctx, obj, argv[1]);
+
+    if(SUCCEEDED(hres) && r)
+        *r = jsval_obj(obj);
+    else
+        jsdisp_release(obj);
+    return hres;
+}
+
+static HRESULT Object_getPrototypeOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
+                                     unsigned argc, jsval_t *argv, jsval_t *r)
+{
+    jsdisp_t *obj;
+
+    if(!argc || !is_object_instance(argv[0])) {
+        FIXME("invalid arguments\n");
+        return E_NOTIMPL;
+    }
+
+    TRACE("(%s)\n", debugstr_jsval(argv[1]));
+
+    obj = to_jsdisp(get_object(argv[0]));
+    if(!obj) {
+        FIXME("Non-JS object\n");
+        return E_NOTIMPL;
+    }
+
+    if(r)
+        *r = obj->prototype
+            ? jsval_obj(jsdisp_addref(obj->prototype))
+            : jsval_null();
+    return S_OK;
+}
+
 static const builtin_prop_t ObjectConstr_props[] = {
+    {createW,                   Object_create,                      PROPF_ES5|PROPF_METHOD|2},
     {definePropertiesW,         Object_defineProperties,            PROPF_ES5|PROPF_METHOD|2},
     {definePropertyW,           Object_defineProperty,              PROPF_ES5|PROPF_METHOD|2},
-    {getOwnPropertyDescriptorW, Object_getOwnPropertyDescriptor,    PROPF_ES5|PROPF_METHOD|2}
+    {getOwnPropertyDescriptorW, Object_getOwnPropertyDescriptor,    PROPF_ES5|PROPF_METHOD|2},
+    {getPrototypeOfW,           Object_getPrototypeOf,              PROPF_ES5|PROPF_METHOD|1}
 };
 
 static const builtin_info_t ObjectConstr_info = {

dll/win32/jscript/parser.h

···
     const WCHAR *ptr;
 
     script_ctx_t *script;
+    struct _compiler_ctx_t *compiler;
     source_elements_t *source;
     BOOL nl;
     BOOL implicit_nl_semicolon;
···
     heap_pool_t heap;
 } parser_ctx_t;
 
-HRESULT script_parse(script_ctx_t*,const WCHAR*,const WCHAR*,BOOL,parser_ctx_t**) DECLSPEC_HIDDEN;
+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;
 
 int parser_lex(void*,parser_ctx_t*) DECLSPEC_HIDDEN;
···
 }
 
 BOOL is_identifier_char(WCHAR) DECLSPEC_HIDDEN;
-BOOL unescape(WCHAR*) DECLSPEC_HIDDEN;
+BOOL unescape(WCHAR*,size_t*) DECLSPEC_HIDDEN;
 HRESULT parse_decimal(const WCHAR**,const WCHAR*,double*) DECLSPEC_HIDDEN;
 
 typedef enum {
···
     literal_type_t type;
     union {
         double dval;
-        const WCHAR *wstr;
+        jsstr_t *str;
         BOOL bval;
         struct {
-            const WCHAR *str;
-            DWORD str_len;
+            jsstr_t *str;
             DWORD flags;
         } regexp;
     } u;
···
 {
     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;

dll/win32/jscript/parser.tab.c

···
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.4.1.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
···
    There are some unavoidable exceptions within include files to
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
+
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
 
 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.0"
+#define YYBISON_VERSION "3.4.1"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
···
 #define yynerrs         parser_nerrs
 
 
-/* Copy the first part of user declarations.  */
-#line 19 "parser.y" /* yacc.c:339  */
+/* First part of user prologue.  */
+#line 19 "parser.y"
 
 
 #include "jscript.h"
···
     statement_t *tail;
 } statement_list_t;
 
-static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*);
+static literal_t *new_string_literal(parser_ctx_t*,jsstr_t*);
 static literal_t *new_null_literal(parser_ctx_t*);
 
 typedef struct _property_list_t {
···
 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*);
 
 
-#line 195 "parser.tab.c" /* yacc.c:339  */
+#line 199 "parser.tab.c"
 
-# ifndef YY_NULL
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
 #  else
-#   define YY_NULL 0
+#   define YY_NULLPTR ((void*)0)
 #  endif
 # endif
 
···
 # define YYERROR_VERBOSE 0
 #endif
 
-/* In a future release of Bison, this section will be replaced
-   by #include "parser.tab.h".  */
+/* Use api.header.include to #include this header
+   instead of duplicating it here.  */
 #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
 # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
 /* Debug traces.  */
···
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
 union YYSTYPE
 {
-#line 147 "parser.y" /* yacc.c:355  */
+#line 147 "parser.y"
 
     int                     ival;
     const WCHAR             *srcptr;
-    LPCWSTR                 wstr;
+    jsstr_t                 *str;
     literal_t               *literal;
     struct _argument_list_t *argument_list;
     case_clausule_t         *case_clausule;
···
     struct _variable_list_t *variable_list;
     variable_declaration_t  *variable_declaration;
 
-#line 307 "parser.tab.c" /* yacc.c:355  */
+#line 314 "parser.tab.c"
+
 };
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif
···
 
 #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED  */
 
-/* Copy the second part of user declarations.  */
 
-#line 321 "parser.tab.c" /* yacc.c:358  */
 
 #ifdef short
 # undef short
···
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else
-typedef unsigned short int yytype_uint16;
+typedef unsigned short yytype_uint16;
 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else
-typedef short int yytype_int16;
+typedef short yytype_int16;
 #endif
 
 #ifndef YYSIZE_T
···
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else
-#  define YYSIZE_T unsigned int
+#  define YYSIZE_T unsigned
 # endif
 #endif
 
···
 # endif
 #endif
 
-#ifndef __attribute__
-/* This feature is available in gcc versions 2.5 and later.  */
-# if (! defined __GNUC__ || __GNUC__ < 2 \
-      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
-#  define __attribute__(Spec) /* empty */
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
 # endif
 #endif
 
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
···
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
···
 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 #endif
 
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
 
 #if ! defined yyoverflow || YYERROR_VERBOSE
 
···
 /* YYNSTATES -- Number of states.  */
 #define YYNSTATES  454
 
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
-   by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   304
 
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
 #define YYTRANSLATE(YYX)                                                \
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, without out-of-bounds checking.  */
+   as returned by yylex.  */
 static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
···
   "PropertyNameAndValueList", "PropertyDefinition", "GetterSetterMethod",
   "PropertyName", "Identifier_opt", "IdentifierName",
   "ReservedAsIdentifier", "Literal", "BooleanLiteral", "semicolon_opt",
-  "left_bracket", "right_bracket", "semicolon", YY_NULL
+  "left_bracket", "right_bracket", "semicolon", YY_NULLPTR
 };
 #endif
 
···
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
-      yyerror (ctx, YY_("syntax error: cannot back up")); \
-      YYERROR;                                                  \
-    }                                                           \
-while (0)
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (ctx, YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
 
 /* Error token number */
 #define YYTERROR        1
···
 } while (0)
 
 
-/*----------------------------------------.
-| Print this symbol's value on YYOUTPUT.  |
-`----------------------------------------*/
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
 
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
+  FILE *yyoutput = yyo;
+  YYUSE (yyoutput);
   YYUSE (ctx);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
 # endif
   YYUSE (yytype);
 }
 
 
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
 
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
 {
-  YYFPRINTF (yyoutput, "%s %s (",
+  YYFPRINTF (yyo, "%s %s (",
              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, ctx);
-  YYFPRINTF (yyoutput, ")");
+  yy_symbol_value_print (yyo, yytype, yyvaluep, ctx);
+  YYFPRINTF (yyo, ")");
 }
 
 /*------------------------------------------------------------------.
···
 static void
 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parser_ctx_t *ctx)
 {
-  unsigned long int yylno = yyrline[yyrule];
+  unsigned long yylno = yyrline[yyrule];
   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
···
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr,
                        yystos[yyssp[yyi + 1 - yynrhs]],
-                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                       &yyvsp[(yyi + 1) - (yynrhs)]
                                               , ctx);
       YYFPRINTF (stderr, "\n");
     }
···
           case '\\':
             if (*++yyp != '\\')
               goto do_not_strip_quotes;
-            /* Fall through.  */
+            else
+              goto append;
+
+          append:
           default:
             if (yyres)
               yyres[yyn] = *yyp;
···
   if (! yyres)
     return yystrlen (yystr);
 
-  return yystpcpy (yyres, yystr) - yyres;
+  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
 }
 # endif
 
···
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
+  const char *yyformat = YY_NULLPTR;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
···
                   }
                 yyarg[yycount++] = yytname[yyx];
                 {
-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+                    yysize = yysize1;
+                  else
                     return 2;
-                  yysize = yysize1;
                 }
               }
         }
···
       case N:                               \
         yyformat = S;                       \
       break
+    default: /* Avoid compiler warnings. */
       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
···
 
   {
     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+      yysize = yysize1;
+    else
       return 2;
-    yysize = yysize1;
   }
 
   if (*yymsg_alloc < yysize)
···
   yychar = YYEMPTY; /* Cause a token to be read.  */
   goto yysetstate;
 
+
 /*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
+| yynewstate -- push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
- yynewstate:
+yynewstate:
   /* In all cases, when you get here, the value and location stacks
      have just been pushed.  So pushing a state here evens the stacks.  */
   yyssp++;
 
- yysetstate:
-  *yyssp = yystate;
+
+/*--------------------------------------------------------------------.
+| yynewstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  *yyssp = (yytype_int16) yystate;
 
   if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    goto yyexhaustedlab;
+#else
     {
       /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
+      YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
 
-#ifdef yyoverflow
+# if defined yyoverflow
       {
         /* Give user a chance to reallocate the stack.  Use copies of
            these so that the &'s don't force the real ones into
···
                     &yyss1, yysize * sizeof (*yyssp),
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yystacksize);
-
         yyss = yyss1;
         yyvs = yyvs1;
       }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
+# else /* defined YYSTACK_RELOCATE */
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
         goto yyexhaustedlab;
···
           goto yyexhaustedlab;
         YYSTACK_RELOCATE (yyss_alloc, yyss);
         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-#  undef YYSTACK_RELOCATE
+# undef YYSTACK_RELOCATE
         if (yyss1 != yyssa)
           YYSTACK_FREE (yyss1);
       }
 # endif
-#endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-                  (unsigned long int) yystacksize));
+                  (unsigned long) yystacksize));
 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
     }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
   if (yystate == YYFINAL)
     YYACCEPT;
 
   goto yybackup;
 
+
 /*-----------.
 | yybackup.  |
 `-----------*/
 yybackup:
-
   /* Do appropriate processing given the current state.  Read a
      lookahead token if we need one and don't already have one.  */
 
···
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
   YY_IGNORE_MAYBE_UNINITIALIZED_END
-
   goto yynewstate;
 
 
···
 
 
 /*-----------------------------.
-| yyreduce -- Do a reduction.  |
+| yyreduce -- do a reduction.  |
 `-----------------------------*/
 yyreduce:
   /* yyn is the number of a rule to reduce with.  */
···
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 2:
-#line 259 "parser.y" /* yacc.c:1646  */
+  case 2:
+#line 259 "parser.y"
     { program_parsed(ctx, (yyvsp[-2].source_elements)); }
-#line 1930 "parser.tab.c" /* yacc.c:1646  */
+#line 1957 "parser.tab.c"
     break;
 
   case 3:
-#line 262 "parser.y" /* yacc.c:1646  */
+#line 262 "parser.y"
     {}
-#line 1936 "parser.tab.c" /* yacc.c:1646  */
+#line 1963 "parser.tab.c"
     break;
 
   case 4:
-#line 263 "parser.y" /* yacc.c:1646  */
+#line 263 "parser.y"
     {}
-#line 1942 "parser.tab.c" /* yacc.c:1646  */
+#line 1969 "parser.tab.c"
     break;
 
   case 5:
-#line 267 "parser.y" /* yacc.c:1646  */
+#line 267 "parser.y"
     { (yyval.source_elements) = new_source_elements(ctx); }
-#line 1948 "parser.tab.c" /* yacc.c:1646  */
+#line 1975 "parser.tab.c"
     break;
 
   case 6:
-#line 269 "parser.y" /* yacc.c:1646  */
+#line 269 "parser.y"
     { (yyval.source_elements) = source_elements_add_statement((yyvsp[-1].source_elements), (yyvsp[0].statement)); }
-#line 1954 "parser.tab.c" /* yacc.c:1646  */
+#line 1981 "parser.tab.c"
     break;
 
   case 7:
-#line 274 "parser.y" /* yacc.c:1646  */
+#line 274 "parser.y"
     { (yyval.expr) = new_function_expression(ctx, NULL, (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-6].srcptr), (yyvsp[0].srcptr)-(yyvsp[-6].srcptr)+1); }
-#line 1960 "parser.tab.c" /* yacc.c:1646  */
+#line 1987 "parser.tab.c"
     break;
 
   case 8:
-#line 276 "parser.y" /* yacc.c:1646  */
+#line 276 "parser.y"
     { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-7].srcptr), (yyvsp[0].srcptr)-(yyvsp[-7].srcptr)+1); }
-#line 1966 "parser.tab.c" /* yacc.c:1646  */
+#line 1993 "parser.tab.c"
     break;
 
   case 9:
-#line 278 "parser.y" /* yacc.c:1646  */
+#line 278 "parser.y"
     { (yyval.expr) = new_function_expression(ctx, (yyvsp[-6].identifier), (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), (yyvsp[-8].identifier), (yyvsp[-9].srcptr), (yyvsp[0].srcptr)-(yyvsp[-9].srcptr)+1); }
-#line 1972 "parser.tab.c" /* yacc.c:1646  */
+#line 1999 "parser.tab.c"
     break;
 
   case 10:
-#line 281 "parser.y" /* yacc.c:1646  */
+#line 281 "parser.y"
     { (yyval.srcptr) = ctx->ptr - 8; }
-#line 1978 "parser.tab.c" /* yacc.c:1646  */
+#line 2005 "parser.tab.c"
     break;
 
   case 11:
-#line 285 "parser.y" /* yacc.c:1646  */
+#line 285 "parser.y"
     { (yyval.source_elements) = (yyvsp[0].source_elements); }
-#line 1984 "parser.tab.c" /* yacc.c:1646  */
+#line 2011 "parser.tab.c"
     break;
 
   case 12:
-#line 289 "parser.y" /* yacc.c:1646  */
+#line 289 "parser.y"
     { (yyval.parameter_list) = new_parameter_list(ctx, (yyvsp[0].identifier)); }
-#line 1990 "parser.tab.c" /* yacc.c:1646  */
+#line 2017 "parser.tab.c"
     break;
 
   case 13:
-#line 291 "parser.y" /* yacc.c:1646  */
+#line 291 "parser.y"
     { (yyval.parameter_list) = parameter_list_add(ctx, (yyvsp[-2].parameter_list), (yyvsp[0].identifier)); }
-#line 1996 "parser.tab.c" /* yacc.c:1646  */
+#line 2023 "parser.tab.c"
     break;
 
   case 14:
-#line 295 "parser.y" /* yacc.c:1646  */
+#line 295 "parser.y"
     { (yyval.parameter_list) = NULL; }
-#line 2002 "parser.tab.c" /* yacc.c:1646  */
+#line 2029 "parser.tab.c"
     break;
 
   case 15:
-#line 296 "parser.y" /* yacc.c:1646  */
+#line 296 "parser.y"
     { (yyval.parameter_list) = (yyvsp[0].parameter_list); }
-#line 2008 "parser.tab.c" /* yacc.c:1646  */
+#line 2035 "parser.tab.c"
     break;
 
   case 16:
-#line 300 "parser.y" /* yacc.c:1646  */
+#line 300 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2014 "parser.tab.c" /* yacc.c:1646  */
+#line 2041 "parser.tab.c"
     break;
 
   case 17:
-#line 301 "parser.y" /* yacc.c:1646  */
+#line 301 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2020 "parser.tab.c" /* yacc.c:1646  */
+#line 2047 "parser.tab.c"
     break;
 
   case 18:
-#line 302 "parser.y" /* yacc.c:1646  */
+#line 302 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2026 "parser.tab.c" /* yacc.c:1646  */
+#line 2053 "parser.tab.c"
     break;
 
   case 19:
-#line 303 "parser.y" /* yacc.c:1646  */
+#line 303 "parser.y"
     { (yyval.statement) = new_expression_statement(ctx, (yyvsp[0].expr)); }
-#line 2032 "parser.tab.c" /* yacc.c:1646  */
+#line 2059 "parser.tab.c"
     break;
 
   case 20:
-#line 304 "parser.y" /* yacc.c:1646  */
+#line 304 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2038 "parser.tab.c" /* yacc.c:1646  */
+#line 2065 "parser.tab.c"
     break;
 
   case 21:
-#line 305 "parser.y" /* yacc.c:1646  */
+#line 305 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2044 "parser.tab.c" /* yacc.c:1646  */
+#line 2071 "parser.tab.c"
     break;
 
   case 22:
-#line 306 "parser.y" /* yacc.c:1646  */
+#line 306 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2050 "parser.tab.c" /* yacc.c:1646  */
+#line 2077 "parser.tab.c"
     break;
 
   case 23:
-#line 307 "parser.y" /* yacc.c:1646  */
+#line 307 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2056 "parser.tab.c" /* yacc.c:1646  */
+#line 2083 "parser.tab.c"
     break;
 
   case 24:
-#line 308 "parser.y" /* yacc.c:1646  */
+#line 308 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2062 "parser.tab.c" /* yacc.c:1646  */
+#line 2089 "parser.tab.c"
     break;
 
   case 25:
-#line 309 "parser.y" /* yacc.c:1646  */
+#line 309 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2068 "parser.tab.c" /* yacc.c:1646  */
+#line 2095 "parser.tab.c"
     break;
 
   case 26:
-#line 310 "parser.y" /* yacc.c:1646  */
+#line 310 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2074 "parser.tab.c" /* yacc.c:1646  */
+#line 2101 "parser.tab.c"
     break;
 
   case 27:
-#line 311 "parser.y" /* yacc.c:1646  */
+#line 311 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2080 "parser.tab.c" /* yacc.c:1646  */
+#line 2107 "parser.tab.c"
     break;
 
   case 28:
-#line 312 "parser.y" /* yacc.c:1646  */
+#line 312 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2086 "parser.tab.c" /* yacc.c:1646  */
+#line 2113 "parser.tab.c"
     break;
 
   case 29:
-#line 313 "parser.y" /* yacc.c:1646  */
+#line 313 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2092 "parser.tab.c" /* yacc.c:1646  */
+#line 2119 "parser.tab.c"
     break;
 
   case 30:
-#line 314 "parser.y" /* yacc.c:1646  */
+#line 314 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2098 "parser.tab.c" /* yacc.c:1646  */
+#line 2125 "parser.tab.c"
     break;
 
   case 31:
-#line 318 "parser.y" /* yacc.c:1646  */
+#line 318 "parser.y"
     { (yyval.statement_list) = new_statement_list(ctx, (yyvsp[0].statement)); }
-#line 2104 "parser.tab.c" /* yacc.c:1646  */
+#line 2131 "parser.tab.c"
     break;
 
   case 32:
-#line 320 "parser.y" /* yacc.c:1646  */
+#line 320 "parser.y"
     { (yyval.statement_list) = statement_list_add((yyvsp[-1].statement_list), (yyvsp[0].statement)); }
-#line 2110 "parser.tab.c" /* yacc.c:1646  */
+#line 2137 "parser.tab.c"
     break;
 
   case 33:
-#line 324 "parser.y" /* yacc.c:1646  */
+#line 324 "parser.y"
     { (yyval.statement_list) = NULL; }
-#line 2116 "parser.tab.c" /* yacc.c:1646  */
+#line 2143 "parser.tab.c"
     break;
 
   case 34:
-#line 325 "parser.y" /* yacc.c:1646  */
+#line 325 "parser.y"
     { (yyval.statement_list) = (yyvsp[0].statement_list); }
-#line 2122 "parser.tab.c" /* yacc.c:1646  */
+#line 2149 "parser.tab.c"
     break;
 
   case 35:
-#line 329 "parser.y" /* yacc.c:1646  */
+#line 329 "parser.y"
     { (yyval.statement) = new_block_statement(ctx, (yyvsp[-1].statement_list)); }
-#line 2128 "parser.tab.c" /* yacc.c:1646  */
+#line 2155 "parser.tab.c"
     break;
 
   case 36:
-#line 330 "parser.y" /* yacc.c:1646  */
+#line 330 "parser.y"
     { (yyval.statement) = new_block_statement(ctx, NULL); }
-#line 2134 "parser.tab.c" /* yacc.c:1646  */
+#line 2161 "parser.tab.c"
     break;
 
   case 37:
-#line 335 "parser.y" /* yacc.c:1646  */
+#line 335 "parser.y"
     { (yyval.statement) = new_var_statement(ctx, (yyvsp[-1].variable_list)); }
-#line 2140 "parser.tab.c" /* yacc.c:1646  */
+#line 2167 "parser.tab.c"
     break;
 
   case 38:
-#line 339 "parser.y" /* yacc.c:1646  */
+#line 339 "parser.y"
     { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); }
-#line 2146 "parser.tab.c" /* yacc.c:1646  */
+#line 2173 "parser.tab.c"
     break;
 
   case 39:
-#line 341 "parser.y" /* yacc.c:1646  */
+#line 341 "parser.y"
     { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); }
-#line 2152 "parser.tab.c" /* yacc.c:1646  */
+#line 2179 "parser.tab.c"
     break;
 
   case 40:
-#line 346 "parser.y" /* yacc.c:1646  */
+#line 346 "parser.y"
     { (yyval.variable_list) = new_variable_list(ctx, (yyvsp[0].variable_declaration)); }
-#line 2158 "parser.tab.c" /* yacc.c:1646  */
+#line 2185 "parser.tab.c"
     break;
 
   case 41:
-#line 348 "parser.y" /* yacc.c:1646  */
+#line 348 "parser.y"
     { (yyval.variable_list) = variable_list_add(ctx, (yyvsp[-2].variable_list), (yyvsp[0].variable_declaration)); }
-#line 2164 "parser.tab.c" /* yacc.c:1646  */
+#line 2191 "parser.tab.c"
     break;
 
   case 42:
-#line 353 "parser.y" /* yacc.c:1646  */
+#line 353 "parser.y"
     { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); }
-#line 2170 "parser.tab.c" /* yacc.c:1646  */
+#line 2197 "parser.tab.c"
     break;
 
   case 43:
-#line 358 "parser.y" /* yacc.c:1646  */
+#line 358 "parser.y"
     { (yyval.variable_declaration) = new_variable_declaration(ctx, (yyvsp[-1].identifier), (yyvsp[0].expr)); }
-#line 2176 "parser.tab.c" /* yacc.c:1646  */
+#line 2203 "parser.tab.c"
     break;
 
   case 44:
-#line 362 "parser.y" /* yacc.c:1646  */
+#line 362 "parser.y"
     { (yyval.expr) = NULL; }
-#line 2182 "parser.tab.c" /* yacc.c:1646  */
+#line 2209 "parser.tab.c"
     break;
 
   case 45:
-#line 363 "parser.y" /* yacc.c:1646  */
+#line 363 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2188 "parser.tab.c" /* yacc.c:1646  */
+#line 2215 "parser.tab.c"
     break;
 
   case 46:
-#line 368 "parser.y" /* yacc.c:1646  */
+#line 368 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2194 "parser.tab.c" /* yacc.c:1646  */
+#line 2221 "parser.tab.c"
     break;
 
   case 47:
-#line 372 "parser.y" /* yacc.c:1646  */
+#line 372 "parser.y"
     { (yyval.expr) = NULL; }
-#line 2200 "parser.tab.c" /* yacc.c:1646  */
+#line 2227 "parser.tab.c"
     break;
 
   case 48:
-#line 373 "parser.y" /* yacc.c:1646  */
+#line 373 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2206 "parser.tab.c" /* yacc.c:1646  */
+#line 2233 "parser.tab.c"
     break;
 
   case 49:
-#line 378 "parser.y" /* yacc.c:1646  */
+#line 378 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2212 "parser.tab.c" /* yacc.c:1646  */
+#line 2239 "parser.tab.c"
     break;
 
   case 50:
-#line 382 "parser.y" /* yacc.c:1646  */
+#line 382 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EMPTY, 0); }
-#line 2218 "parser.tab.c" /* yacc.c:1646  */
+#line 2245 "parser.tab.c"
     break;
 
   case 51:
-#line 387 "parser.y" /* yacc.c:1646  */
+#line 387 "parser.y"
     { (yyval.statement) = new_expression_statement(ctx, (yyvsp[-1].expr)); }
-#line 2224 "parser.tab.c" /* yacc.c:1646  */
+#line 2251 "parser.tab.c"
     break;
 
   case 52:
-#line 392 "parser.y" /* yacc.c:1646  */
+#line 392 "parser.y"
     { (yyval.statement) = new_if_statement(ctx, (yyvsp[-4].expr), (yyvsp[-2].statement), (yyvsp[0].statement)); }
-#line 2230 "parser.tab.c" /* yacc.c:1646  */
+#line 2257 "parser.tab.c"
     break;
 
   case 53:
-#line 394 "parser.y" /* yacc.c:1646  */
+#line 394 "parser.y"
     { (yyval.statement) = new_if_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement), NULL); }
-#line 2236 "parser.tab.c" /* yacc.c:1646  */
+#line 2263 "parser.tab.c"
     break;
 
   case 54:
-#line 399 "parser.y" /* yacc.c:1646  */
+#line 399 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, TRUE, (yyvsp[-2].expr), (yyvsp[-5].statement)); }
-#line 2242 "parser.tab.c" /* yacc.c:1646  */
+#line 2269 "parser.tab.c"
     break;
 
   case 55:
-#line 401 "parser.y" /* yacc.c:1646  */
+#line 401 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, FALSE, (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2248 "parser.tab.c" /* yacc.c:1646  */
+#line 2275 "parser.tab.c"
     break;
 
   case 56:
-#line 403 "parser.y" /* yacc.c:1646  */
+#line 403 "parser.y"
     { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
-#line 2254 "parser.tab.c" /* yacc.c:1646  */
+#line 2281 "parser.tab.c"
     break;
 
   case 57:
-#line 405 "parser.y" /* yacc.c:1646  */
+#line 405 "parser.y"
     { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
-#line 2260 "parser.tab.c" /* yacc.c:1646  */
+#line 2287 "parser.tab.c"
     break;
 
   case 58:
-#line 407 "parser.y" /* yacc.c:1646  */
+#line 407 "parser.y"
     { (yyval.statement) = new_for_statement(ctx, NULL, (yyvsp[-8].expr), (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2266 "parser.tab.c" /* yacc.c:1646  */
+#line 2293 "parser.tab.c"
     break;
 
   case 59:
-#line 409 "parser.y" /* yacc.c:1646  */
+#line 409 "parser.y"
     { if(!explicit_error(ctx, (yyvsp[0].variable_list), ';')) YYABORT; }
-#line 2272 "parser.tab.c" /* yacc.c:1646  */
+#line 2299 "parser.tab.c"
     break;
 
   case 60:
-#line 411 "parser.y" /* yacc.c:1646  */
+#line 411 "parser.y"
     { if(!explicit_error(ctx, (yyvsp[0].expr), ';')) YYABORT; }
-#line 2278 "parser.tab.c" /* yacc.c:1646  */
+#line 2305 "parser.tab.c"
     break;
 
   case 61:
-#line 413 "parser.y" /* yacc.c:1646  */
+#line 413 "parser.y"
     { (yyval.statement) = new_for_statement(ctx, (yyvsp[-8].variable_list), NULL, (yyvsp[-5].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2284 "parser.tab.c" /* yacc.c:1646  */
+#line 2311 "parser.tab.c"
     break;
 
   case 62:
-#line 415 "parser.y" /* yacc.c:1646  */
+#line 415 "parser.y"
     { (yyval.statement) = new_forin_statement(ctx, NULL, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2290 "parser.tab.c" /* yacc.c:1646  */
+#line 2317 "parser.tab.c"
     break;
 
   case 63:
-#line 417 "parser.y" /* yacc.c:1646  */
+#line 417 "parser.y"
     { (yyval.statement) = new_forin_statement(ctx, (yyvsp[-4].variable_declaration), NULL, (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2296 "parser.tab.c" /* yacc.c:1646  */
+#line 2323 "parser.tab.c"
     break;
 
   case 64:
-#line 422 "parser.y" /* yacc.c:1646  */
+#line 422 "parser.y"
     { (yyval.statement) = new_continue_statement(ctx, (yyvsp[-1].identifier)); }
-#line 2302 "parser.tab.c" /* yacc.c:1646  */
+#line 2329 "parser.tab.c"
     break;
 
   case 65:
-#line 427 "parser.y" /* yacc.c:1646  */
+#line 427 "parser.y"
     { (yyval.statement) = new_break_statement(ctx, (yyvsp[-1].identifier)); }
-#line 2308 "parser.tab.c" /* yacc.c:1646  */
+#line 2335 "parser.tab.c"
     break;
 
   case 66:
-#line 432 "parser.y" /* yacc.c:1646  */
+#line 432 "parser.y"
     { (yyval.statement) = new_return_statement(ctx, (yyvsp[-1].expr)); }
-#line 2314 "parser.tab.c" /* yacc.c:1646  */
+#line 2341 "parser.tab.c"
     break;
 
   case 67:
-#line 437 "parser.y" /* yacc.c:1646  */
+#line 437 "parser.y"
     { (yyval.statement) = new_with_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].statement)); }
-#line 2320 "parser.tab.c" /* yacc.c:1646  */
+#line 2347 "parser.tab.c"
     break;
 
   case 68:
-#line 442 "parser.y" /* yacc.c:1646  */
+#line 442 "parser.y"
     { (yyval.statement) = new_labelled_statement(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); }
-#line 2326 "parser.tab.c" /* yacc.c:1646  */
+#line 2353 "parser.tab.c"
     break;
 
   case 69:
-#line 447 "parser.y" /* yacc.c:1646  */
+#line 447 "parser.y"
     { (yyval.statement) = new_switch_statement(ctx, (yyvsp[-2].expr), (yyvsp[0].case_clausule)); }
-#line 2332 "parser.tab.c" /* yacc.c:1646  */
+#line 2359 "parser.tab.c"
     break;
 
   case 70:
-#line 452 "parser.y" /* yacc.c:1646  */
+#line 452 "parser.y"
     { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-1].case_list), NULL, NULL); }
-#line 2338 "parser.tab.c" /* yacc.c:1646  */
+#line 2365 "parser.tab.c"
     break;
 
   case 71:
-#line 454 "parser.y" /* yacc.c:1646  */
+#line 454 "parser.y"
     { (yyval.case_clausule) = new_case_block(ctx, (yyvsp[-3].case_list), (yyvsp[-2].case_clausule), (yyvsp[-1].case_list)); }
-#line 2344 "parser.tab.c" /* yacc.c:1646  */
+#line 2371 "parser.tab.c"
     break;
 
   case 72:
-#line 458 "parser.y" /* yacc.c:1646  */
+#line 458 "parser.y"
     { (yyval.case_list) = NULL; }
-#line 2350 "parser.tab.c" /* yacc.c:1646  */
+#line 2377 "parser.tab.c"
     break;
 
   case 73:
-#line 459 "parser.y" /* yacc.c:1646  */
+#line 459 "parser.y"
     { (yyval.case_list) = (yyvsp[0].case_list); }
-#line 2356 "parser.tab.c" /* yacc.c:1646  */
+#line 2383 "parser.tab.c"
     break;
 
   case 74:
-#line 463 "parser.y" /* yacc.c:1646  */
+#line 463 "parser.y"
     { (yyval.case_list) = new_case_list(ctx, (yyvsp[0].case_clausule)); }
-#line 2362 "parser.tab.c" /* yacc.c:1646  */
+#line 2389 "parser.tab.c"
     break;
 
   case 75:
-#line 465 "parser.y" /* yacc.c:1646  */
+#line 465 "parser.y"
     { (yyval.case_list) = case_list_add(ctx, (yyvsp[-1].case_list), (yyvsp[0].case_clausule)); }
-#line 2368 "parser.tab.c" /* yacc.c:1646  */
+#line 2395 "parser.tab.c"
     break;
 
   case 76:
-#line 470 "parser.y" /* yacc.c:1646  */
+#line 470 "parser.y"
     { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[-2].expr), (yyvsp[0].statement_list)); }
-#line 2374 "parser.tab.c" /* yacc.c:1646  */
+#line 2401 "parser.tab.c"
     break;
 
   case 77:
-#line 475 "parser.y" /* yacc.c:1646  */
+#line 475 "parser.y"
     { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[0].statement_list)); }
-#line 2380 "parser.tab.c" /* yacc.c:1646  */
+#line 2407 "parser.tab.c"
     break;
 
   case 78:
-#line 480 "parser.y" /* yacc.c:1646  */
+#line 480 "parser.y"
     { (yyval.statement) = new_throw_statement(ctx, (yyvsp[-1].expr)); }
-#line 2386 "parser.tab.c" /* yacc.c:1646  */
+#line 2413 "parser.tab.c"
     break;
 
   case 79:
-#line 484 "parser.y" /* yacc.c:1646  */
+#line 484 "parser.y"
     { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), (yyvsp[0].catch_block), NULL); }
-#line 2392 "parser.tab.c" /* yacc.c:1646  */
+#line 2419 "parser.tab.c"
     break;
 
   case 80:
-#line 485 "parser.y" /* yacc.c:1646  */
+#line 485 "parser.y"
     { (yyval.statement) = new_try_statement(ctx, (yyvsp[-1].statement), NULL, (yyvsp[0].statement)); }
-#line 2398 "parser.tab.c" /* yacc.c:1646  */
+#line 2425 "parser.tab.c"
     break;
 
   case 81:
-#line 487 "parser.y" /* yacc.c:1646  */
+#line 487 "parser.y"
     { (yyval.statement) = new_try_statement(ctx, (yyvsp[-2].statement), (yyvsp[-1].catch_block), (yyvsp[0].statement)); }
-#line 2404 "parser.tab.c" /* yacc.c:1646  */
+#line 2431 "parser.tab.c"
     break;
 
   case 82:
-#line 492 "parser.y" /* yacc.c:1646  */
+#line 492 "parser.y"
     { (yyval.catch_block) = new_catch_block(ctx, (yyvsp[-2].identifier), (yyvsp[0].statement)); }
-#line 2410 "parser.tab.c" /* yacc.c:1646  */
+#line 2437 "parser.tab.c"
     break;
 
   case 83:
-#line 496 "parser.y" /* yacc.c:1646  */
+#line 496 "parser.y"
     { (yyval.statement) = (yyvsp[0].statement); }
-#line 2416 "parser.tab.c" /* yacc.c:1646  */
+#line 2443 "parser.tab.c"
     break;
 
   case 84:
-#line 500 "parser.y" /* yacc.c:1646  */
+#line 500 "parser.y"
     { (yyval.expr) = NULL; }
-#line 2422 "parser.tab.c" /* yacc.c:1646  */
+#line 2449 "parser.tab.c"
     break;
 
   case 85:
-#line 501 "parser.y" /* yacc.c:1646  */
+#line 501 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2428 "parser.tab.c" /* yacc.c:1646  */
+#line 2455 "parser.tab.c"
     break;
 
   case 86:
-#line 504 "parser.y" /* yacc.c:1646  */
+#line 504 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2434 "parser.tab.c" /* yacc.c:1646  */
+#line 2461 "parser.tab.c"
     break;
 
   case 87:
-#line 505 "parser.y" /* yacc.c:1646  */
+#line 505 "parser.y"
     { set_error(ctx, JS_E_SYNTAX); YYABORT; }
-#line 2440 "parser.tab.c" /* yacc.c:1646  */
+#line 2467 "parser.tab.c"
     break;
 
   case 88:
-#line 509 "parser.y" /* yacc.c:1646  */
+#line 509 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2446 "parser.tab.c" /* yacc.c:1646  */
+#line 2473 "parser.tab.c"
     break;
 
   case 89:
-#line 511 "parser.y" /* yacc.c:1646  */
+#line 511 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2452 "parser.tab.c" /* yacc.c:1646  */
+#line 2479 "parser.tab.c"
     break;
 
   case 90:
-#line 515 "parser.y" /* yacc.c:1646  */
+#line 515 "parser.y"
     { (yyval.expr) = NULL; }
-#line 2458 "parser.tab.c" /* yacc.c:1646  */
+#line 2485 "parser.tab.c"
     break;
 
   case 91:
-#line 516 "parser.y" /* yacc.c:1646  */
+#line 516 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2464 "parser.tab.c" /* yacc.c:1646  */
+#line 2491 "parser.tab.c"
     break;
 
   case 92:
-#line 521 "parser.y" /* yacc.c:1646  */
+#line 521 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2470 "parser.tab.c" /* yacc.c:1646  */
+#line 2497 "parser.tab.c"
     break;
 
   case 93:
-#line 523 "parser.y" /* yacc.c:1646  */
+#line 523 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_COMMA, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2476 "parser.tab.c" /* yacc.c:1646  */
+#line 2503 "parser.tab.c"
     break;
 
   case 94:
-#line 526 "parser.y" /* yacc.c:1646  */
+#line 526 "parser.y"
     { (yyval.ival) = (yyvsp[0].ival); }
-#line 2482 "parser.tab.c" /* yacc.c:1646  */
+#line 2509 "parser.tab.c"
     break;
 
   case 95:
-#line 527 "parser.y" /* yacc.c:1646  */
+#line 527 "parser.y"
     { (yyval.ival) = EXPR_ASSIGNDIV; }
-#line 2488 "parser.tab.c" /* yacc.c:1646  */
+#line 2515 "parser.tab.c"
     break;
 
   case 96:
-#line 531 "parser.y" /* yacc.c:1646  */
+#line 531 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2494 "parser.tab.c" /* yacc.c:1646  */
+#line 2521 "parser.tab.c"
     break;
 
   case 97:
-#line 533 "parser.y" /* yacc.c:1646  */
+#line 533 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2500 "parser.tab.c" /* yacc.c:1646  */
+#line 2527 "parser.tab.c"
     break;
 
   case 98:
-#line 535 "parser.y" /* yacc.c:1646  */
+#line 535 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2506 "parser.tab.c" /* yacc.c:1646  */
+#line 2533 "parser.tab.c"
     break;
 
   case 99:
-#line 540 "parser.y" /* yacc.c:1646  */
+#line 540 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2512 "parser.tab.c" /* yacc.c:1646  */
+#line 2539 "parser.tab.c"
     break;
 
   case 100:
-#line 542 "parser.y" /* yacc.c:1646  */
+#line 542 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2518 "parser.tab.c" /* yacc.c:1646  */
+#line 2545 "parser.tab.c"
     break;
 
   case 101:
-#line 544 "parser.y" /* yacc.c:1646  */
+#line 544 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2524 "parser.tab.c" /* yacc.c:1646  */
+#line 2551 "parser.tab.c"
     break;
 
   case 102:
-#line 548 "parser.y" /* yacc.c:1646  */
+#line 548 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2530 "parser.tab.c" /* yacc.c:1646  */
+#line 2557 "parser.tab.c"
     break;
 
   case 103:
-#line 550 "parser.y" /* yacc.c:1646  */
+#line 550 "parser.y"
     { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2536 "parser.tab.c" /* yacc.c:1646  */
+#line 2563 "parser.tab.c"
     break;
 
   case 104:
-#line 555 "parser.y" /* yacc.c:1646  */
+#line 555 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2542 "parser.tab.c" /* yacc.c:1646  */
+#line 2569 "parser.tab.c"
     break;
 
   case 105:
-#line 557 "parser.y" /* yacc.c:1646  */
+#line 557 "parser.y"
     { (yyval.expr) = new_conditional_expression(ctx, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2548 "parser.tab.c" /* yacc.c:1646  */
+#line 2575 "parser.tab.c"
     break;
 
   case 106:
-#line 561 "parser.y" /* yacc.c:1646  */
+#line 561 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2554 "parser.tab.c" /* yacc.c:1646  */
+#line 2581 "parser.tab.c"
     break;
 
   case 107:
-#line 563 "parser.y" /* yacc.c:1646  */
+#line 563 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2560 "parser.tab.c" /* yacc.c:1646  */
+#line 2587 "parser.tab.c"
     break;
 
   case 108:
-#line 568 "parser.y" /* yacc.c:1646  */
+#line 568 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2566 "parser.tab.c" /* yacc.c:1646  */
+#line 2593 "parser.tab.c"
     break;
 
   case 109:
-#line 570 "parser.y" /* yacc.c:1646  */
+#line 570 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2572 "parser.tab.c" /* yacc.c:1646  */
+#line 2599 "parser.tab.c"
     break;
 
   case 110:
-#line 574 "parser.y" /* yacc.c:1646  */
+#line 574 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2578 "parser.tab.c" /* yacc.c:1646  */
+#line 2605 "parser.tab.c"
     break;
 
   case 111:
-#line 576 "parser.y" /* yacc.c:1646  */
+#line 576 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2584 "parser.tab.c" /* yacc.c:1646  */
+#line 2611 "parser.tab.c"
     break;
 
   case 112:
-#line 581 "parser.y" /* yacc.c:1646  */
+#line 581 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2590 "parser.tab.c" /* yacc.c:1646  */
+#line 2617 "parser.tab.c"
     break;
 
   case 113:
-#line 583 "parser.y" /* yacc.c:1646  */
+#line 583 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2596 "parser.tab.c" /* yacc.c:1646  */
+#line 2623 "parser.tab.c"
     break;
 
   case 114:
-#line 587 "parser.y" /* yacc.c:1646  */
+#line 587 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2602 "parser.tab.c" /* yacc.c:1646  */
+#line 2629 "parser.tab.c"
     break;
 
   case 115:
-#line 589 "parser.y" /* yacc.c:1646  */
+#line 589 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2608 "parser.tab.c" /* yacc.c:1646  */
+#line 2635 "parser.tab.c"
     break;
 
   case 116:
-#line 594 "parser.y" /* yacc.c:1646  */
+#line 594 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2614 "parser.tab.c" /* yacc.c:1646  */
+#line 2641 "parser.tab.c"
     break;
 
   case 117:
-#line 596 "parser.y" /* yacc.c:1646  */
+#line 596 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2620 "parser.tab.c" /* yacc.c:1646  */
+#line 2647 "parser.tab.c"
     break;
 
   case 118:
-#line 600 "parser.y" /* yacc.c:1646  */
+#line 600 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2626 "parser.tab.c" /* yacc.c:1646  */
+#line 2653 "parser.tab.c"
     break;
 
   case 119:
-#line 602 "parser.y" /* yacc.c:1646  */
+#line 602 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2632 "parser.tab.c" /* yacc.c:1646  */
+#line 2659 "parser.tab.c"
     break;
 
   case 120:
-#line 607 "parser.y" /* yacc.c:1646  */
+#line 607 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2638 "parser.tab.c" /* yacc.c:1646  */
+#line 2665 "parser.tab.c"
     break;
 
   case 121:
-#line 609 "parser.y" /* yacc.c:1646  */
+#line 609 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BXOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2644 "parser.tab.c" /* yacc.c:1646  */
+#line 2671 "parser.tab.c"
     break;
 
   case 122:
-#line 613 "parser.y" /* yacc.c:1646  */
+#line 613 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2650 "parser.tab.c" /* yacc.c:1646  */
+#line 2677 "parser.tab.c"
     break;
 
   case 123:
-#line 615 "parser.y" /* yacc.c:1646  */
+#line 615 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2656 "parser.tab.c" /* yacc.c:1646  */
+#line 2683 "parser.tab.c"
     break;
 
   case 124:
-#line 620 "parser.y" /* yacc.c:1646  */
+#line 620 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2662 "parser.tab.c" /* yacc.c:1646  */
+#line 2689 "parser.tab.c"
     break;
 
   case 125:
-#line 622 "parser.y" /* yacc.c:1646  */
+#line 622 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_BAND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2668 "parser.tab.c" /* yacc.c:1646  */
+#line 2695 "parser.tab.c"
     break;
 
   case 126:
-#line 626 "parser.y" /* yacc.c:1646  */
+#line 626 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2674 "parser.tab.c" /* yacc.c:1646  */
+#line 2701 "parser.tab.c"
     break;
 
   case 127:
-#line 628 "parser.y" /* yacc.c:1646  */
+#line 628 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2680 "parser.tab.c" /* yacc.c:1646  */
+#line 2707 "parser.tab.c"
     break;
 
   case 128:
-#line 632 "parser.y" /* yacc.c:1646  */
+#line 632 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2686 "parser.tab.c" /* yacc.c:1646  */
+#line 2713 "parser.tab.c"
     break;
 
   case 129:
-#line 634 "parser.y" /* yacc.c:1646  */
+#line 634 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2692 "parser.tab.c" /* yacc.c:1646  */
+#line 2719 "parser.tab.c"
     break;
 
   case 130:
-#line 638 "parser.y" /* yacc.c:1646  */
+#line 638 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2698 "parser.tab.c" /* yacc.c:1646  */
+#line 2725 "parser.tab.c"
     break;
 
   case 131:
-#line 640 "parser.y" /* yacc.c:1646  */
+#line 640 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2704 "parser.tab.c" /* yacc.c:1646  */
+#line 2731 "parser.tab.c"
     break;
 
   case 132:
-#line 642 "parser.y" /* yacc.c:1646  */
+#line 642 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2710 "parser.tab.c" /* yacc.c:1646  */
+#line 2737 "parser.tab.c"
     break;
 
   case 133:
-#line 644 "parser.y" /* yacc.c:1646  */
+#line 644 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_IN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2716 "parser.tab.c" /* yacc.c:1646  */
+#line 2743 "parser.tab.c"
     break;
 
   case 134:
-#line 648 "parser.y" /* yacc.c:1646  */
+#line 648 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2722 "parser.tab.c" /* yacc.c:1646  */
+#line 2749 "parser.tab.c"
     break;
 
   case 135:
-#line 650 "parser.y" /* yacc.c:1646  */
+#line 650 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2728 "parser.tab.c" /* yacc.c:1646  */
+#line 2755 "parser.tab.c"
     break;
 
   case 136:
-#line 652 "parser.y" /* yacc.c:1646  */
+#line 652 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_INSTANCEOF, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2734 "parser.tab.c" /* yacc.c:1646  */
+#line 2761 "parser.tab.c"
     break;
 
   case 137:
-#line 656 "parser.y" /* yacc.c:1646  */
+#line 656 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2740 "parser.tab.c" /* yacc.c:1646  */
+#line 2767 "parser.tab.c"
     break;
 
   case 138:
-#line 658 "parser.y" /* yacc.c:1646  */
+#line 658 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, (yyvsp[-1].ival), (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2746 "parser.tab.c" /* yacc.c:1646  */
+#line 2773 "parser.tab.c"
     break;
 
   case 139:
-#line 663 "parser.y" /* yacc.c:1646  */
+#line 663 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2752 "parser.tab.c" /* yacc.c:1646  */
+#line 2779 "parser.tab.c"
     break;
 
   case 140:
-#line 665 "parser.y" /* yacc.c:1646  */
+#line 665 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2758 "parser.tab.c" /* yacc.c:1646  */
+#line 2785 "parser.tab.c"
     break;
 
   case 141:
-#line 667 "parser.y" /* yacc.c:1646  */
+#line 667 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2764 "parser.tab.c" /* yacc.c:1646  */
+#line 2791 "parser.tab.c"
     break;
 
   case 142:
-#line 671 "parser.y" /* yacc.c:1646  */
+#line 671 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2770 "parser.tab.c" /* yacc.c:1646  */
+#line 2797 "parser.tab.c"
     break;
 
   case 143:
-#line 673 "parser.y" /* yacc.c:1646  */
+#line 673 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2776 "parser.tab.c" /* yacc.c:1646  */
+#line 2803 "parser.tab.c"
     break;
 
   case 144:
-#line 675 "parser.y" /* yacc.c:1646  */
+#line 675 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2782 "parser.tab.c" /* yacc.c:1646  */
+#line 2809 "parser.tab.c"
     break;
 
   case 145:
-#line 677 "parser.y" /* yacc.c:1646  */
+#line 677 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
-#line 2788 "parser.tab.c" /* yacc.c:1646  */
+#line 2815 "parser.tab.c"
     break;
 
   case 146:
-#line 681 "parser.y" /* yacc.c:1646  */
+#line 681 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2794 "parser.tab.c" /* yacc.c:1646  */
+#line 2821 "parser.tab.c"
     break;
 
   case 147:
-#line 683 "parser.y" /* yacc.c:1646  */
+#line 683 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_DELETE, (yyvsp[0].expr)); }
-#line 2800 "parser.tab.c" /* yacc.c:1646  */
+#line 2827 "parser.tab.c"
     break;
 
   case 148:
-#line 684 "parser.y" /* yacc.c:1646  */
+#line 684 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_VOID, (yyvsp[0].expr)); }
-#line 2806 "parser.tab.c" /* yacc.c:1646  */
+#line 2833 "parser.tab.c"
     break;
 
   case 149:
-#line 686 "parser.y" /* yacc.c:1646  */
+#line 686 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_TYPEOF, (yyvsp[0].expr)); }
-#line 2812 "parser.tab.c" /* yacc.c:1646  */
+#line 2839 "parser.tab.c"
     break;
 
   case 150:
-#line 687 "parser.y" /* yacc.c:1646  */
+#line 687 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_PREINC, (yyvsp[0].expr)); }
-#line 2818 "parser.tab.c" /* yacc.c:1646  */
+#line 2845 "parser.tab.c"
     break;
 
   case 151:
-#line 688 "parser.y" /* yacc.c:1646  */
+#line 688 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_PREDEC, (yyvsp[0].expr)); }
-#line 2824 "parser.tab.c" /* yacc.c:1646  */
+#line 2851 "parser.tab.c"
     break;
 
   case 152:
-#line 689 "parser.y" /* yacc.c:1646  */
+#line 689 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_PLUS, (yyvsp[0].expr)); }
-#line 2830 "parser.tab.c" /* yacc.c:1646  */
+#line 2857 "parser.tab.c"
     break;
 
   case 153:
-#line 690 "parser.y" /* yacc.c:1646  */
+#line 690 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_MINUS, (yyvsp[0].expr)); }
-#line 2836 "parser.tab.c" /* yacc.c:1646  */
+#line 2863 "parser.tab.c"
     break;
 
   case 154:
-#line 691 "parser.y" /* yacc.c:1646  */
+#line 691 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_BITNEG, (yyvsp[0].expr)); }
-#line 2842 "parser.tab.c" /* yacc.c:1646  */
+#line 2869 "parser.tab.c"
     break;
 
   case 155:
-#line 692 "parser.y" /* yacc.c:1646  */
+#line 692 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_LOGNEG, (yyvsp[0].expr)); }
-#line 2848 "parser.tab.c" /* yacc.c:1646  */
+#line 2875 "parser.tab.c"
     break;
 
   case 156:
-#line 697 "parser.y" /* yacc.c:1646  */
+#line 697 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2854 "parser.tab.c" /* yacc.c:1646  */
+#line 2881 "parser.tab.c"
     break;
 
   case 157:
-#line 699 "parser.y" /* yacc.c:1646  */
+#line 699 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTINC, (yyvsp[-1].expr)); }
-#line 2860 "parser.tab.c" /* yacc.c:1646  */
+#line 2887 "parser.tab.c"
     break;
 
   case 158:
-#line 701 "parser.y" /* yacc.c:1646  */
+#line 701 "parser.y"
     { (yyval.expr) = new_unary_expression(ctx, EXPR_POSTDEC, (yyvsp[-1].expr)); }
-#line 2866 "parser.tab.c" /* yacc.c:1646  */
+#line 2893 "parser.tab.c"
     break;
 
   case 159:
-#line 706 "parser.y" /* yacc.c:1646  */
+#line 706 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2872 "parser.tab.c" /* yacc.c:1646  */
+#line 2899 "parser.tab.c"
     break;
 
   case 160:
-#line 707 "parser.y" /* yacc.c:1646  */
+#line 707 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2878 "parser.tab.c" /* yacc.c:1646  */
+#line 2905 "parser.tab.c"
     break;
 
   case 161:
-#line 711 "parser.y" /* yacc.c:1646  */
+#line 711 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2884 "parser.tab.c" /* yacc.c:1646  */
+#line 2911 "parser.tab.c"
     break;
 
   case 162:
-#line 712 "parser.y" /* yacc.c:1646  */
+#line 712 "parser.y"
     { (yyval.expr) = new_new_expression(ctx, (yyvsp[0].expr), NULL); }
-#line 2890 "parser.tab.c" /* yacc.c:1646  */
+#line 2917 "parser.tab.c"
     break;
 
   case 163:
-#line 716 "parser.y" /* yacc.c:1646  */
+#line 716 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2896 "parser.tab.c" /* yacc.c:1646  */
+#line 2923 "parser.tab.c"
     break;
 
   case 164:
-#line 717 "parser.y" /* yacc.c:1646  */
+#line 717 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2902 "parser.tab.c" /* yacc.c:1646  */
+#line 2929 "parser.tab.c"
     break;
 
   case 165:
-#line 719 "parser.y" /* yacc.c:1646  */
+#line 719 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); }
-#line 2908 "parser.tab.c" /* yacc.c:1646  */
+#line 2935 "parser.tab.c"
     break;
 
   case 166:
-#line 721 "parser.y" /* yacc.c:1646  */
+#line 721 "parser.y"
     { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); }
-#line 2914 "parser.tab.c" /* yacc.c:1646  */
+#line 2941 "parser.tab.c"
     break;
 
   case 167:
-#line 723 "parser.y" /* yacc.c:1646  */
+#line 723 "parser.y"
     { (yyval.expr) = new_new_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
-#line 2920 "parser.tab.c" /* yacc.c:1646  */
+#line 2947 "parser.tab.c"
     break;
 
   case 168:
-#line 728 "parser.y" /* yacc.c:1646  */
+#line 728 "parser.y"
     { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
-#line 2926 "parser.tab.c" /* yacc.c:1646  */
+#line 2953 "parser.tab.c"
     break;
 
   case 169:
-#line 730 "parser.y" /* yacc.c:1646  */
+#line 730 "parser.y"
     { (yyval.expr) = new_call_expression(ctx, (yyvsp[-1].expr), (yyvsp[0].argument_list)); }
-#line 2932 "parser.tab.c" /* yacc.c:1646  */
+#line 2959 "parser.tab.c"
     break;
 
   case 170:
-#line 732 "parser.y" /* yacc.c:1646  */
+#line 732 "parser.y"
     { (yyval.expr) = new_binary_expression(ctx, EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); }
-#line 2938 "parser.tab.c" /* yacc.c:1646  */
+#line 2965 "parser.tab.c"
     break;
 
   case 171:
-#line 734 "parser.y" /* yacc.c:1646  */
+#line 734 "parser.y"
     { (yyval.expr) = new_member_expression(ctx, (yyvsp[-2].expr), (yyvsp[0].identifier)); }
-#line 2944 "parser.tab.c" /* yacc.c:1646  */
+#line 2971 "parser.tab.c"
     break;
 
   case 172:
-#line 738 "parser.y" /* yacc.c:1646  */
+#line 738 "parser.y"
     { (yyval.argument_list) = NULL; }
-#line 2950 "parser.tab.c" /* yacc.c:1646  */
+#line 2977 "parser.tab.c"
     break;
 
   case 173:
-#line 739 "parser.y" /* yacc.c:1646  */
+#line 739 "parser.y"
     { (yyval.argument_list) = (yyvsp[-1].argument_list); }
-#line 2956 "parser.tab.c" /* yacc.c:1646  */
+#line 2983 "parser.tab.c"
     break;
 
   case 174:
-#line 743 "parser.y" /* yacc.c:1646  */
+#line 743 "parser.y"
     { (yyval.argument_list) = new_argument_list(ctx, (yyvsp[0].expr)); }
-#line 2962 "parser.tab.c" /* yacc.c:1646  */
+#line 2989 "parser.tab.c"
     break;
 
   case 175:
-#line 745 "parser.y" /* yacc.c:1646  */
+#line 745 "parser.y"
     { (yyval.argument_list) = argument_list_add(ctx, (yyvsp[-2].argument_list), (yyvsp[0].expr)); }
-#line 2968 "parser.tab.c" /* yacc.c:1646  */
+#line 2995 "parser.tab.c"
     break;
 
   case 176:
-#line 749 "parser.y" /* yacc.c:1646  */
+#line 749 "parser.y"
     { (yyval.expr) = new_expression(ctx, EXPR_THIS, 0); }
-#line 2974 "parser.tab.c" /* yacc.c:1646  */
+#line 3001 "parser.tab.c"
     break;
 
   case 177:
-#line 750 "parser.y" /* yacc.c:1646  */
+#line 750 "parser.y"
     { (yyval.expr) = new_identifier_expression(ctx, (yyvsp[0].identifier)); }
-#line 2980 "parser.tab.c" /* yacc.c:1646  */
+#line 3007 "parser.tab.c"
     break;
 
   case 178:
-#line 751 "parser.y" /* yacc.c:1646  */
+#line 751 "parser.y"
     { (yyval.expr) = new_literal_expression(ctx, (yyvsp[0].literal)); }
-#line 2986 "parser.tab.c" /* yacc.c:1646  */
+#line 3013 "parser.tab.c"
     break;
 
   case 179:
-#line 752 "parser.y" /* yacc.c:1646  */
+#line 752 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2992 "parser.tab.c" /* yacc.c:1646  */
+#line 3019 "parser.tab.c"
     break;
 
   case 180:
-#line 753 "parser.y" /* yacc.c:1646  */
+#line 753 "parser.y"
     { (yyval.expr) = (yyvsp[0].expr); }
-#line 2998 "parser.tab.c" /* yacc.c:1646  */
+#line 3025 "parser.tab.c"
     break;
 
   case 181:
-#line 754 "parser.y" /* yacc.c:1646  */
+#line 754 "parser.y"
     { (yyval.expr) = (yyvsp[-1].expr); }
-#line 3004 "parser.tab.c" /* yacc.c:1646  */
+#line 3031 "parser.tab.c"
     break;
 
   case 182:
-#line 758 "parser.y" /* yacc.c:1646  */
+#line 758 "parser.y"
     { (yyval.expr) = new_array_literal_expression(ctx, NULL, 0); }
-#line 3010 "parser.tab.c" /* yacc.c:1646  */
+#line 3037 "parser.tab.c"
     break;
 
   case 183:
-#line 759 "parser.y" /* yacc.c:1646  */
+#line 759 "parser.y"
     { (yyval.expr) = new_array_literal_expression(ctx, NULL, (yyvsp[-1].ival)+1); }
-#line 3016 "parser.tab.c" /* yacc.c:1646  */
+#line 3043 "parser.tab.c"
     break;
 
   case 184:
-#line 760 "parser.y" /* yacc.c:1646  */
+#line 760 "parser.y"
     { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-1].element_list), 0); }
-#line 3022 "parser.tab.c" /* yacc.c:1646  */
+#line 3049 "parser.tab.c"
     break;
 
   case 185:
-#line 762 "parser.y" /* yacc.c:1646  */
+#line 762 "parser.y"
     { (yyval.expr) = new_array_literal_expression(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival)+1); }
-#line 3028 "parser.tab.c" /* yacc.c:1646  */
+#line 3055 "parser.tab.c"
     break;
 
   case 186:
-#line 767 "parser.y" /* yacc.c:1646  */
+#line 767 "parser.y"
     { (yyval.element_list) = new_element_list(ctx, (yyvsp[-1].ival), (yyvsp[0].expr)); }
-#line 3034 "parser.tab.c" /* yacc.c:1646  */
+#line 3061 "parser.tab.c"
     break;
 
   case 187:
-#line 769 "parser.y" /* yacc.c:1646  */
+#line 769 "parser.y"
     { (yyval.element_list) = element_list_add(ctx, (yyvsp[-3].element_list), (yyvsp[-1].ival), (yyvsp[0].expr)); }
-#line 3040 "parser.tab.c" /* yacc.c:1646  */
+#line 3067 "parser.tab.c"
     break;
 
   case 188:
-#line 773 "parser.y" /* yacc.c:1646  */
+#line 773 "parser.y"
     { (yyval.ival) = 1; }
-#line 3046 "parser.tab.c" /* yacc.c:1646  */
+#line 3073 "parser.tab.c"
     break;
 
   case 189:
-#line 774 "parser.y" /* yacc.c:1646  */
+#line 774 "parser.y"
     { (yyval.ival) = (yyvsp[-1].ival) + 1; }
-#line 3052 "parser.tab.c" /* yacc.c:1646  */
+#line 3079 "parser.tab.c"
     break;
 
   case 190:
-#line 778 "parser.y" /* yacc.c:1646  */
+#line 778 "parser.y"
     { (yyval.ival) = 0; }
-#line 3058 "parser.tab.c" /* yacc.c:1646  */
+#line 3085 "parser.tab.c"
     break;
 
   case 191:
-#line 779 "parser.y" /* yacc.c:1646  */
+#line 779 "parser.y"
     { (yyval.ival) = (yyvsp[0].ival); }
-#line 3064 "parser.tab.c" /* yacc.c:1646  */
+#line 3091 "parser.tab.c"
     break;
 
   case 192:
-#line 783 "parser.y" /* yacc.c:1646  */
+#line 783 "parser.y"
     { (yyval.expr) = new_prop_and_value_expression(ctx, NULL); }
-#line 3070 "parser.tab.c" /* yacc.c:1646  */
+#line 3097 "parser.tab.c"
     break;
 
   case 193:
-#line 785 "parser.y" /* yacc.c:1646  */
+#line 785 "parser.y"
     { (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-1].property_list)); }
-#line 3076 "parser.tab.c" /* yacc.c:1646  */
+#line 3103 "parser.tab.c"
     break;
 
   case 194:
-#line 787 "parser.y" /* yacc.c:1646  */
+#line 787 "parser.y"
     {
             if(ctx->script->version < 2) {
                 WARN("Trailing comma in object literal is illegal in legacy mode.\n");
···
             }
             (yyval.expr) = new_prop_and_value_expression(ctx, (yyvsp[-2].property_list));
         }
-#line 3088 "parser.tab.c" /* yacc.c:1646  */
+#line 3115 "parser.tab.c"
     break;
 
   case 195:
-#line 797 "parser.y" /* yacc.c:1646  */
+#line 797 "parser.y"
     { (yyval.property_list) = new_property_list(ctx, (yyvsp[0].property_definition)); }
-#line 3094 "parser.tab.c" /* yacc.c:1646  */
+#line 3121 "parser.tab.c"
     break;
 
   case 196:
-#line 799 "parser.y" /* yacc.c:1646  */
+#line 799 "parser.y"
     { (yyval.property_list) = property_list_add(ctx, (yyvsp[-2].property_list), (yyvsp[0].property_definition)); }
-#line 3100 "parser.tab.c" /* yacc.c:1646  */
+#line 3127 "parser.tab.c"
     break;
 
   case 197:
-#line 804 "parser.y" /* yacc.c:1646  */
+#line 804 "parser.y"
     { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_VALUE, (yyvsp[-2].literal), (yyvsp[0].expr)); }
-#line 3106 "parser.tab.c" /* yacc.c:1646  */
+#line 3133 "parser.tab.c"
     break;
 
   case 198:
-#line 806 "parser.y" /* yacc.c:1646  */
+#line 806 "parser.y"
     { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_GETTER, (yyvsp[-1].literal), (yyvsp[0].expr)); }
-#line 3112 "parser.tab.c" /* yacc.c:1646  */
+#line 3139 "parser.tab.c"
     break;
 
   case 199:
-#line 808 "parser.y" /* yacc.c:1646  */
+#line 808 "parser.y"
     { (yyval.property_definition) = new_property_definition(ctx, PROPERTY_DEFINITION_SETTER, (yyvsp[-1].literal), (yyvsp[0].expr)); }
-#line 3118 "parser.tab.c" /* yacc.c:1646  */
+#line 3145 "parser.tab.c"
     break;
 
   case 200:
-#line 812 "parser.y" /* yacc.c:1646  */
+#line 812 "parser.y"
     { (yyval.expr) = new_function_expression(ctx, NULL, (yyvsp[-4].parameter_list), (yyvsp[-1].source_elements), NULL, (yyvsp[-5].srcptr), (yyvsp[0].srcptr)-(yyvsp[-5].srcptr)); }
-#line 3124 "parser.tab.c" /* yacc.c:1646  */
+#line 3151 "parser.tab.c"
     break;
 
   case 201:
-#line 816 "parser.y" /* yacc.c:1646  */
-    { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].identifier)); }
-#line 3130 "parser.tab.c" /* yacc.c:1646  */
+#line 816 "parser.y"
+    { (yyval.literal) = new_string_literal(ctx, compiler_alloc_string_len(ctx->compiler, (yyvsp[0].identifier), lstrlenW((yyvsp[0].identifier)))); }
+#line 3157 "parser.tab.c"
     break;
 
   case 202:
-#line 817 "parser.y" /* yacc.c:1646  */
-    { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); }
-#line 3136 "parser.tab.c" /* yacc.c:1646  */
+#line 817 "parser.y"
+    { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].str)); }
+#line 3163 "parser.tab.c"
     break;
 
   case 203:
-#line 818 "parser.y" /* yacc.c:1646  */
+#line 818 "parser.y"
     { (yyval.literal) = (yyvsp[0].literal); }
-#line 3142 "parser.tab.c" /* yacc.c:1646  */
+#line 3169 "parser.tab.c"
     break;
 
   case 204:
-#line 822 "parser.y" /* yacc.c:1646  */
+#line 822 "parser.y"
     { (yyval.identifier) = NULL; }
-#line 3148 "parser.tab.c" /* yacc.c:1646  */
+#line 3175 "parser.tab.c"
     break;
 
   case 205:
-#line 823 "parser.y" /* yacc.c:1646  */
+#line 823 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3154 "parser.tab.c" /* yacc.c:1646  */
+#line 3181 "parser.tab.c"
     break;
 
   case 206:
-#line 827 "parser.y" /* yacc.c:1646  */
+#line 827 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3160 "parser.tab.c" /* yacc.c:1646  */
+#line 3187 "parser.tab.c"
     break;
 
   case 207:
-#line 829 "parser.y" /* yacc.c:1646  */
+#line 829 "parser.y"
     {
             if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
                 WARN("%s keyword used as an identifier in legacy mode.\n",
···
             }
             (yyval.identifier) = (yyvsp[0].identifier);
         }
-#line 3173 "parser.tab.c" /* yacc.c:1646  */
+#line 3200 "parser.tab.c"
     break;
 
   case 208:
-#line 839 "parser.y" /* yacc.c:1646  */
+#line 839 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3179 "parser.tab.c" /* yacc.c:1646  */
+#line 3206 "parser.tab.c"
     break;
 
   case 209:
-#line 840 "parser.y" /* yacc.c:1646  */
+#line 840 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3185 "parser.tab.c" /* yacc.c:1646  */
+#line 3212 "parser.tab.c"
     break;
 
   case 210:
-#line 841 "parser.y" /* yacc.c:1646  */
+#line 841 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3191 "parser.tab.c" /* yacc.c:1646  */
+#line 3218 "parser.tab.c"
     break;
 
   case 211:
-#line 842 "parser.y" /* yacc.c:1646  */
+#line 842 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3197 "parser.tab.c" /* yacc.c:1646  */
+#line 3224 "parser.tab.c"
     break;
 
   case 212:
-#line 843 "parser.y" /* yacc.c:1646  */
+#line 843 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3203 "parser.tab.c" /* yacc.c:1646  */
+#line 3230 "parser.tab.c"
     break;
 
   case 213:
-#line 844 "parser.y" /* yacc.c:1646  */
+#line 844 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3209 "parser.tab.c" /* yacc.c:1646  */
+#line 3236 "parser.tab.c"
     break;
 
   case 214:
-#line 845 "parser.y" /* yacc.c:1646  */
+#line 845 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3215 "parser.tab.c" /* yacc.c:1646  */
+#line 3242 "parser.tab.c"
     break;
 
   case 215:
-#line 846 "parser.y" /* yacc.c:1646  */
+#line 846 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3221 "parser.tab.c" /* yacc.c:1646  */
+#line 3248 "parser.tab.c"
     break;
 
   case 216:
-#line 847 "parser.y" /* yacc.c:1646  */
+#line 847 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3227 "parser.tab.c" /* yacc.c:1646  */
+#line 3254 "parser.tab.c"
     break;
 
   case 217:
-#line 848 "parser.y" /* yacc.c:1646  */
+#line 848 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3233 "parser.tab.c" /* yacc.c:1646  */
+#line 3260 "parser.tab.c"
     break;
 
   case 218:
-#line 849 "parser.y" /* yacc.c:1646  */
+#line 849 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3239 "parser.tab.c" /* yacc.c:1646  */
+#line 3266 "parser.tab.c"
     break;
 
   case 219:
-#line 850 "parser.y" /* yacc.c:1646  */
+#line 850 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3245 "parser.tab.c" /* yacc.c:1646  */
+#line 3272 "parser.tab.c"
     break;
 
   case 220:
-#line 851 "parser.y" /* yacc.c:1646  */
+#line 851 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3251 "parser.tab.c" /* yacc.c:1646  */
+#line 3278 "parser.tab.c"
     break;
 
   case 221:
-#line 852 "parser.y" /* yacc.c:1646  */
+#line 852 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3257 "parser.tab.c" /* yacc.c:1646  */
+#line 3284 "parser.tab.c"
     break;
 
   case 222:
-#line 853 "parser.y" /* yacc.c:1646  */
+#line 853 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3263 "parser.tab.c" /* yacc.c:1646  */
+#line 3290 "parser.tab.c"
     break;
 
   case 223:
-#line 854 "parser.y" /* yacc.c:1646  */
+#line 854 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3269 "parser.tab.c" /* yacc.c:1646  */
+#line 3296 "parser.tab.c"
     break;
 
   case 224:
-#line 855 "parser.y" /* yacc.c:1646  */
+#line 855 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3275 "parser.tab.c" /* yacc.c:1646  */
+#line 3302 "parser.tab.c"
     break;
 
   case 225:
-#line 856 "parser.y" /* yacc.c:1646  */
+#line 856 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3281 "parser.tab.c" /* yacc.c:1646  */
+#line 3308 "parser.tab.c"
     break;
 
   case 226:
-#line 857 "parser.y" /* yacc.c:1646  */
+#line 857 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3287 "parser.tab.c" /* yacc.c:1646  */
+#line 3314 "parser.tab.c"
     break;
 
   case 227:
-#line 858 "parser.y" /* yacc.c:1646  */
+#line 858 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3293 "parser.tab.c" /* yacc.c:1646  */
+#line 3320 "parser.tab.c"
     break;
 
   case 228:
-#line 859 "parser.y" /* yacc.c:1646  */
+#line 859 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3299 "parser.tab.c" /* yacc.c:1646  */
+#line 3326 "parser.tab.c"
     break;
 
   case 229:
-#line 860 "parser.y" /* yacc.c:1646  */
+#line 860 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3305 "parser.tab.c" /* yacc.c:1646  */
+#line 3332 "parser.tab.c"
     break;
 
   case 230:
-#line 861 "parser.y" /* yacc.c:1646  */
+#line 861 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3311 "parser.tab.c" /* yacc.c:1646  */
+#line 3338 "parser.tab.c"
     break;
 
   case 231:
-#line 862 "parser.y" /* yacc.c:1646  */
+#line 862 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3317 "parser.tab.c" /* yacc.c:1646  */
+#line 3344 "parser.tab.c"
     break;
 
   case 232:
-#line 863 "parser.y" /* yacc.c:1646  */
+#line 863 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3323 "parser.tab.c" /* yacc.c:1646  */
+#line 3350 "parser.tab.c"
     break;
 
   case 233:
-#line 864 "parser.y" /* yacc.c:1646  */
+#line 864 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3329 "parser.tab.c" /* yacc.c:1646  */
+#line 3356 "parser.tab.c"
     break;
 
   case 234:
-#line 865 "parser.y" /* yacc.c:1646  */
+#line 865 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3335 "parser.tab.c" /* yacc.c:1646  */
+#line 3362 "parser.tab.c"
     break;
 
   case 235:
-#line 866 "parser.y" /* yacc.c:1646  */
+#line 866 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3341 "parser.tab.c" /* yacc.c:1646  */
+#line 3368 "parser.tab.c"
     break;
 
   case 236:
-#line 867 "parser.y" /* yacc.c:1646  */
+#line 867 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3347 "parser.tab.c" /* yacc.c:1646  */
+#line 3374 "parser.tab.c"
     break;
 
   case 237:
-#line 868 "parser.y" /* yacc.c:1646  */
+#line 868 "parser.y"
     { (yyval.identifier) = (yyvsp[0].identifier); }
-#line 3353 "parser.tab.c" /* yacc.c:1646  */
+#line 3380 "parser.tab.c"
     break;
 
   case 238:
-#line 872 "parser.y" /* yacc.c:1646  */
+#line 872 "parser.y"
     { (yyval.literal) = new_null_literal(ctx); }
-#line 3359 "parser.tab.c" /* yacc.c:1646  */
+#line 3386 "parser.tab.c"
     break;
 
   case 239:
-#line 873 "parser.y" /* yacc.c:1646  */
+#line 873 "parser.y"
     { (yyval.literal) = (yyvsp[0].literal); }
-#line 3365 "parser.tab.c" /* yacc.c:1646  */
+#line 3392 "parser.tab.c"
     break;
 
   case 240:
-#line 874 "parser.y" /* yacc.c:1646  */
+#line 874 "parser.y"
     { (yyval.literal) = (yyvsp[0].literal); }
-#line 3371 "parser.tab.c" /* yacc.c:1646  */
+#line 3398 "parser.tab.c"
     break;
 
   case 241:
-#line 875 "parser.y" /* yacc.c:1646  */
-    { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].wstr)); }
-#line 3377 "parser.tab.c" /* yacc.c:1646  */
+#line 875 "parser.y"
+    { (yyval.literal) = new_string_literal(ctx, (yyvsp[0].str)); }
+#line 3404 "parser.tab.c"
     break;
 
   case 242:
-#line 876 "parser.y" /* yacc.c:1646  */
+#line 876 "parser.y"
     { (yyval.literal) = parse_regexp(ctx);
                                   if(!(yyval.literal)) YYABORT; }
-#line 3384 "parser.tab.c" /* yacc.c:1646  */
+#line 3411 "parser.tab.c"
     break;
 
   case 243:
-#line 878 "parser.y" /* yacc.c:1646  */
+#line 878 "parser.y"
     { (yyval.literal) = parse_regexp(ctx);
                                   if(!(yyval.literal)) YYABORT; }
-#line 3391 "parser.tab.c" /* yacc.c:1646  */
+#line 3418 "parser.tab.c"
     break;
 
   case 244:
-#line 883 "parser.y" /* yacc.c:1646  */
+#line 883 "parser.y"
     { (yyval.literal) = new_boolean_literal(ctx, VARIANT_TRUE); }
-#line 3397 "parser.tab.c" /* yacc.c:1646  */
+#line 3424 "parser.tab.c"
     break;
 
   case 245:
-#line 884 "parser.y" /* yacc.c:1646  */
+#line 884 "parser.y"
     { (yyval.literal) = new_boolean_literal(ctx, VARIANT_FALSE); }
-#line 3403 "parser.tab.c" /* yacc.c:1646  */
+#line 3430 "parser.tab.c"
     break;
 
   case 246:
-#line 885 "parser.y" /* yacc.c:1646  */
+#line 885 "parser.y"
     { (yyval.literal) = (yyvsp[0].literal); }
-#line 3409 "parser.tab.c" /* yacc.c:1646  */
+#line 3436 "parser.tab.c"
     break;
 
   case 248:
-#line 889 "parser.y" /* yacc.c:1646  */
+#line 889 "parser.y"
     { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
-#line 3415 "parser.tab.c" /* yacc.c:1646  */
+#line 3442 "parser.tab.c"
     break;
 
   case 249:
-#line 892 "parser.y" /* yacc.c:1646  */
+#line 892 "parser.y"
     { (yyval.srcptr) = ctx->ptr; }
-#line 3421 "parser.tab.c" /* yacc.c:1646  */
+#line 3448 "parser.tab.c"
     break;
 
   case 250:
-#line 893 "parser.y" /* yacc.c:1646  */
+#line 893 "parser.y"
     { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; }
-#line 3427 "parser.tab.c" /* yacc.c:1646  */
+#line 3454 "parser.tab.c"
     break;
 
   case 252:
-#line 897 "parser.y" /* yacc.c:1646  */
+#line 897 "parser.y"
     { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; }
-#line 3433 "parser.tab.c" /* yacc.c:1646  */
+#line 3460 "parser.tab.c"
     break;
 
   case 254:
-#line 901 "parser.y" /* yacc.c:1646  */
+#line 901 "parser.y"
     { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; }
-#line 3439 "parser.tab.c" /* yacc.c:1646  */
+#line 3466 "parser.tab.c"
     break;
 
 
-#line 3443 "parser.tab.c" /* yacc.c:1646  */
+#line 3470 "parser.tab.c"
+
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
···
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
 
   goto yynewstate;
 
···
 | yyerrorlab -- error raised explicitly by YYERROR.  |
 `---------------------------------------------------*/
 yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
 
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
···
   yyresult = 0;
   goto yyreturn;
 
+
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
   yyresult = 1;
   goto yyreturn;
+
 
 #if !defined yyoverflow || YYERROR_VERBOSE
 /*-------------------------------------------------.
···
   /* Fall through.  */
 #endif
 
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result.  |
+`-----------------------------------------------------*/
 yyreturn:
   if (yychar != YYEMPTY)
     {
···
 #endif
   return yyresult;
 }
-#line 903 "parser.y" /* yacc.c:1906  */
+#line 903 "parser.y"
 
 
 static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
···
     return stat;
 }
 
-static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str)
+static literal_t *new_string_literal(parser_ctx_t *ctx, jsstr_t *str)
 {
     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 
     ret->type = LT_STRING;
-    ret->u.wstr = str;
+    ret->u.str = str;
 
     return ret;
 }
···
     heap_free(ctx);
 }
 
-HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
+HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
         parser_ctx_t **ret)
 {
     parser_ctx_t *parser_ctx;
···
         return E_OUTOFMEMORY;
 
     parser_ctx->hres = JS_E_SYNTAX;
-    parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
+    parser_ctx->is_html = delimiter && !wcsicmp(delimiter, html_tagW);
 
     parser_ctx->begin = parser_ctx->ptr = code;
-    parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin);
+    parser_ctx->end = parser_ctx->begin + lstrlenW(parser_ctx->begin);
 
     script_addref(ctx);
     parser_ctx->script = ctx;
···
     mark = heap_pool_mark(&ctx->tmp_heap);
     heap_pool_init(&parser_ctx->heap);
 
+    parser_ctx->compiler = compiler;
     parser_parse(parser_ctx);
+    parser_ctx->compiler = NULL;
+
     heap_pool_clear(mark);
     hres = parser_ctx->hres;
     if(FAILED(hres)) {

dll/win32/jscript/parser.tab.h

···
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.4.1.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
···
 
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
+
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
 
 #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
 # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_JSCRIPT_PARSER_TAB_H_INCLUDED
···
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
 union YYSTYPE
 {
-#line 147 "parser.y" /* yacc.c:1909  */
+#line 147 "parser.y"
 
     int                     ival;
     const WCHAR             *srcptr;
-    LPCWSTR                 wstr;
+    jsstr_t                 *str;
     literal_t               *literal;
     struct _argument_list_t *argument_list;
     case_clausule_t         *case_clausule;
···
     struct _variable_list_t *variable_list;
     variable_declaration_t  *variable_declaration;
 
-#line 126 "parser.tab.h" /* yacc.c:1909  */
+#line 129 "parser.tab.h"
+
 };
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif

dll/win32/jscript/parser.y

···
     statement_t *tail;
 } statement_list_t;
 
-static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*);
+static literal_t *new_string_literal(parser_ctx_t*,jsstr_t*);
 static literal_t *new_null_literal(parser_ctx_t*);
 
 typedef struct _property_list_t {
···
 
 %lex-param { parser_ctx_t *ctx }
 %parse-param { parser_ctx_t *ctx }
-%pure-parser
+%define api.pure
 %start Program
 
 %union {
     int                     ival;
     const WCHAR             *srcptr;
-    LPCWSTR                 wstr;
+    jsstr_t                 *str;
     literal_t               *literal;
     struct _argument_list_t *argument_list;
     case_clausule_t         *case_clausule;
···
 %token <identifier> tIdentifier
 %token <ival> tAssignOper tEqOper tShiftOper tRelOper
 %token <literal> tNumericLiteral tBooleanLiteral
-%token <wstr> tStringLiteral
+%token <str> tStringLiteral
 %token tEOF
 
 %type <source_elements> SourceElements
···
 
 /* Ecma-262 3rd Edition    11.1.5 */
 PropertyName
-        : IdentifierName        { $$ = new_string_literal(ctx, $1); }
+        : IdentifierName        { $$ = new_string_literal(ctx, compiler_alloc_string_len(ctx->compiler, $1, lstrlenW($1))); }
         | tStringLiteral        { $$ = new_string_literal(ctx, $1); }
         | tNumericLiteral       { $$ = $1; }
 
···
     return stat;
 }
 
-static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str)
+static literal_t *new_string_literal(parser_ctx_t *ctx, jsstr_t *str)
 {
     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 
     ret->type = LT_STRING;
-    ret->u.wstr = str;
+    ret->u.str = str;
 
     return ret;
 }
···
     heap_free(ctx);
 }
 
-HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
+HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval,
         parser_ctx_t **ret)
 {
     parser_ctx_t *parser_ctx;
···
         return E_OUTOFMEMORY;
 
     parser_ctx->hres = JS_E_SYNTAX;
-    parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
+    parser_ctx->is_html = delimiter && !wcsicmp(delimiter, html_tagW);
 
     parser_ctx->begin = parser_ctx->ptr = code;
-    parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin);
+    parser_ctx->end = parser_ctx->begin + lstrlenW(parser_ctx->begin);
 
     script_addref(ctx);
     parser_ctx->script = ctx;
···
     mark = heap_pool_mark(&ctx->tmp_heap);
     heap_pool_init(&parser_ctx->heap);
 
+    parser_ctx->compiler = compiler;
     parser_parse(parser_ctx);
+    parser_ctx->compiler = NULL;
+
     heap_pool_clear(mark);
     hres = parser_ctx->hres;
     if(FAILED(hres)) {

dll/win32/jscript/regexp.c

···
             for (i = rangeStart; i <= localMax; i++) {
                 WCHAR uch, dch;
 
-                uch = toupperW(i);
-                dch = tolowerW(i);
+                uch = towupper(i);
+                dch = towlower(i);
                 if(maxch < uch)
                     maxch = uch;
                 if(maxch < dch)
···
     if (length > (size_t)(gData->cpend - x->cp))
         return NULL;
     for (i = 0; i != length; i++) {
-        if (toupperW(matchChars[i]) != toupperW(x->cp[i]))
+        if (towupper(matchChars[i]) != towupper(x->cp[i]))
             return NULL;
     }
     x->cp += length;
···
     parenContent = &gData->cpbegin[cap->index];
     if (gData->regexp->flags & REG_FOLD) {
         for (i = 0; i < len; i++) {
-            if (toupperW(parenContent[i]) != toupperW(x->cp[i]))
+            if (towupper(parenContent[i]) != towupper(x->cp[i]))
                 return NULL;
         }
     } else {
···
                 continue;
               case 's':
                 for (i = (INT)charSet->length; i >= 0; i--)
-                    if (isspaceW(i))
+                    if (iswspace(i))
                         AddCharacterToCharSet(charSet, (WCHAR)i);
                 continue;
               case 'S':
                 for (i = (INT)charSet->length; i >= 0; i--)
-                    if (!isspaceW(i))
+                    if (!iswspace(i))
                         AddCharacterToCharSet(charSet, (WCHAR)i);
                 continue;
               case 'w':
···
                     WCHAR uch, dch;
 
                     AddCharacterToCharSet(charSet, i);
-                    uch = toupperW(i);
-                    dch = tolowerW(i);
+                    uch = towupper(i);
+                    dch = towlower(i);
                     if (i != uch)
                         AddCharacterToCharSet(charSet, uch);
                     if (i != dch)
···
             inRange = FALSE;
         } else {
             if (gData->regexp->flags & REG_FOLD) {
-                AddCharacterToCharSet(charSet, toupperW(thisCh));
-                AddCharacterToCharSet(charSet, tolowerW(thisCh));
+                AddCharacterToCharSet(charSet, towupper(thisCh));
+                AddCharacterToCharSet(charSet, towlower(thisCh));
             } else {
                 AddCharacterToCharSet(charSet, thisCh);
             }
···
         }
         break;
       case REOP_SPACE:
-        if (x->cp != gData->cpend && isspaceW(*x->cp)) {
+        if (x->cp != gData->cpend && iswspace(*x->cp)) {
             result = x;
             result->cp++;
         }
         break;
       case REOP_NONSPACE:
-        if (x->cp != gData->cpend && !isspaceW(*x->cp)) {
+        if (x->cp != gData->cpend && !iswspace(*x->cp)) {
             result = x;
             result->cp++;
         }
···
         break;
       case REOP_FLAT1i:
         matchCh = *pc++;
-        if (x->cp != gData->cpend && toupperW(*x->cp) == toupperW(matchCh)) {
+        if (x->cp != gData->cpend && towupper(*x->cp) == towupper(matchCh)) {
             result = x;
             result->cp++;
         }
···
       case REOP_UCFLAT1i:
         matchCh = GET_ARG(pc);
         pc += ARG_LEN;
-        if (x->cp != gData->cpend && toupperW(*x->cp) == toupperW(matchCh)) {
+        if (x->cp != gData->cpend && towupper(*x->cp) == towupper(matchCh)) {
             result = x;
             result->cp++;
         }

dll/win32/jscript/string.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
-#include "wine/port.h"
+
+#include <math.h>
 
 #include "jscript.h"
 #include "regexp.h"
···
         return S_OK;
     }
 
-    tagname_len = strlenW(tagname);
+    tagname_len = lstrlenW(tagname);
 
     ret = jsstr_alloc_buf(jsstr_length(str) + 2*tagname_len + 5, &ptr);
     if(!ret) {
···
     }
 
     if(r) {
-        unsigned attrname_len = strlenW(attrname);
-        unsigned tagname_len = strlenW(tagname);
+        unsigned attrname_len = lstrlenW(attrname);
+        unsigned tagname_len = lstrlenW(tagname);
         jsstr_t *ret;
         WCHAR *ptr;
 
···
                     match->cp = str;
                 }
 
-                match->cp = strstrW(match->cp, match_str);
+                match->cp = wcsstr(match->cp, match_str);
                 if(!match->cp)
                     break;
                 match->match_len = jsstr_length(match_jsstr);
···
             }else if(rep_str && regexp) {
                 const WCHAR *ptr = rep_str, *ptr2;
 
-                while((ptr2 = strchrW(ptr, '$'))) {
+                while((ptr2 = wcschr(ptr, '$'))) {
                     hres = strbuf_append(&ret, ptr, ptr2-ptr);
                     if(FAILED(hres))
                         break;
···
                     default: {
                         DWORD idx;
 
-                        if(!isdigitW(ptr2[1])) {
+                        if(!iswdigit(ptr2[1])) {
                             hres = strbuf_append(&ret, ptr2, 1);
                             ptr = ptr2+1;
                             break;
                         }
 
                         idx = ptr2[1] - '0';
-                        if(isdigitW(ptr2[2]) && idx*10 + (ptr2[2]-'0') <= match->paren_count) {
+                        if(iswdigit(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) {
···
         jsval_t *r)
 {
     match_state_t match_result, *match_ptr = &match_result;
-    DWORD length, i, match_len = 0;
+    size_t length, i = 0, match_len = 0;
     const WCHAR *ptr, *ptr2, *str, *match_str = NULL;
     unsigned limit = ~0u;
     jsdisp_t *array, *regexp = NULL;
     jsstr_t *jsstr, *match_jsstr, *tmp_str;
     HRESULT hres;
-
-    TRACE("\n");
 
     hres = get_string_flat_val(ctx, jsthis, &jsstr, &str);
     if(FAILED(hres))
         return hres;
+    length = jsstr_length(jsstr);
 
-    length = jsstr_length(jsstr);
+    TRACE("%s\n", debugstr_wn(str, length));
 
     if(!argc || (is_undefined(argv[0]) && ctx->version >= SCRIPTLANGUAGEVERSION_ES5)) {
         if(!r)
···
     if(SUCCEEDED(hres)) {
         ptr = str;
         match_result.cp = str;
-        for(i=0; i<limit; i++) {
+        while(i < limit) {
             if(regexp) {
                 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);
+                if(!match_result.match_len) {
+                    /* If an empty string is matched, prevent including any match in the result */
+                    if(!length) {
+                        limit = 0;
+                        break;
+                    }
+                    if(match_result.cp == ptr) {
+                        match_result.cp++;
+                        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),
+                              match_result.match_len);
+                    }
+                    if(!match_result.match_len && match_result.cp == str + length)
+                        break;
+                }
                 ptr2 = match_result.cp - match_result.match_len;
             }else if(match_str) {
-                ptr2 = strstrW(ptr, match_str);
+                ptr2 = wcsstr(ptr, match_str);
                 if(!ptr2)
                     break;
             }else {
···
                 ptr2 = ptr+1;
             }
 
-            tmp_str = jsstr_alloc_len(ptr, ptr2-ptr);
-            if(!tmp_str) {
-                hres = E_OUTOFMEMORY;
-                break;
-            }
+            if(!regexp || ptr2 > ptr || ctx->version >= SCRIPTLANGUAGEVERSION_ES5) {
+                tmp_str = jsstr_alloc_len(ptr, ptr2-ptr);
+                if(!tmp_str) {
+                    hres = E_OUTOFMEMORY;
+                    break;
+                }
 
-            hres = jsdisp_propput_idx(array, i, jsval_string(tmp_str));
-            jsstr_release(tmp_str);
-            if(FAILED(hres))
-                break;
+                hres = jsdisp_propput_idx(array, i++, jsval_string(tmp_str));
+                jsstr_release(tmp_str);
+                if(FAILED(hres))
+                    break;
+            }
 
             if(regexp)
                 ptr = match_result.cp;
···
     if(SUCCEEDED(hres) && (match_str || regexp) && i<limit) {
         DWORD len = (str+length) - ptr;
 
-        if(len || match_str) {
+        if(len || match_str || !length || ctx->version >= SCRIPTLANGUAGEVERSION_ES5) {
             tmp_str = jsstr_alloc_len(ptr, len);
 
             if(tmp_str) {
···
         }
 
         jsstr_flush(str, buf);
-        for (; len--; buf++) *buf = tolowerW(*buf);
+        for (; len--; buf++) *buf = towlower(*buf);
 
         *r = jsval_string(ret);
     }
···
         }
 
         jsstr_flush(str, buf);
-        for (; len--; buf++) *buf = toupperW(*buf);
+        for (; len--; buf++) *buf = towupper(*buf);
 
         *r = jsval_string(ret);
     }
···
     len = jsstr_length(jsstr);
     TRACE("%s\n", debugstr_wn(str, len));
 
-    for(begin = str, end = str + len; begin < end && isspaceW(*begin); begin++);
-    while(end > begin + 1 && isspaceW(*(end-1))) end--;
+    for(begin = str, end = str + len; begin < end && iswspace(*begin); begin++);
+    while(end > begin + 1 && iswspace(*(end-1))) end--;
 
     if(r) {
         jsstr_t *ret;

media/doc/README.WINE

···
 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.0
+dll/win32/jscript             # Synced to WineStaging-4.18
 dll/win32/jsproxy             # Synced to WineStaging-4.0
 dll/win32/loadperf            # Synced to WineStaging-3.3
 dll/win32/lz32                # Synced to WineStaging-3.3