[VBSCRIPT]
authorAmine Khaldi <amine.khaldi@reactos.org>
Wed, 23 Apr 2014 18:05:58 +0000 (18:05 +0000)
committerAmine Khaldi <amine.khaldi@reactos.org>
Wed, 23 Apr 2014 18:05:58 +0000 (18:05 +0000)
* Sync with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62931

18 files changed:
reactos/dll/win32/vbscript/CMakeLists.txt
reactos/dll/win32/vbscript/compile.c
reactos/dll/win32/vbscript/error.c [deleted file]
reactos/dll/win32/vbscript/global.c
reactos/dll/win32/vbscript/interp.c
reactos/dll/win32/vbscript/parse.h
reactos/dll/win32/vbscript/parser.tab.c
reactos/dll/win32/vbscript/parser.tab.h
reactos/dll/win32/vbscript/parser.y
reactos/dll/win32/vbscript/regexp.c
reactos/dll/win32/vbscript/vbdisp.c
reactos/dll/win32/vbscript/vbregexp.c
reactos/dll/win32/vbscript/vbscript.h
reactos/dll/win32/vbscript/vbscript_classes.idl
reactos/dll/win32/vbscript/vbsglobal.idl
reactos/dll/win32/vbscript/vbsregexp10.idl
reactos/dll/win32/vbscript/vbsregexp55.idl
reactos/media/doc/README.WINE

index 83d3557..ace3186 100644 (file)
@@ -5,7 +5,6 @@ spec2def(vbscript.dll vbscript.spec)
 
 list(APPEND SOURCE
     compile.c
-    error.c
     global.c
     interp.c
     lex.c
index 8ee9831..d61c649 100644 (file)
@@ -47,6 +47,7 @@ typedef struct {
     unsigned prop_end_label;
 
     dim_decl_t *dim_decls;
+    dim_decl_t *dim_decls_tail;
     dynamic_var_t *global_vars;
 
     const_decl_t *const_decls;
@@ -338,6 +339,35 @@ static inline void label_set_addr(compile_ctx_t *ctx, unsigned label)
     ctx->labels[label & ~LABEL_FLAG] = ctx->instr_cnt;
 }
 
+static inline unsigned stack_offset(compile_ctx_t *ctx)
+{
+    statement_ctx_t *iter;
+    unsigned ret = 0;
+
+    for(iter = ctx->stat_ctx; iter; iter = iter->next)
+        ret += iter->stack_use;
+
+    return ret;
+}
+
+static BOOL emit_catch_jmp(compile_ctx_t *ctx, unsigned stack_off, unsigned code_off)
+{
+    unsigned code;
+
+    code = push_instr(ctx, OP_catch);
+    if(!code)
+        return FALSE;
+
+    instr_ptr(ctx, code)->arg1.uint = code_off;
+    instr_ptr(ctx, code)->arg2.uint = stack_off + stack_offset(ctx);
+    return TRUE;
+}
+
+static inline BOOL emit_catch(compile_ctx_t *ctx, unsigned off)
+{
+    return emit_catch_jmp(ctx, off, ctx->instr_cnt);
+}
+
 static expression_t *lookup_const_decls(compile_ctx_t *ctx, const WCHAR *name, BOOL lookup_global)
 {
     const_decl_t *decl;
@@ -525,6 +555,9 @@ static HRESULT compile_if_statement(compile_ctx_t *ctx, if_statement_t *stat)
     if(!cnd_jmp)
         return E_OUTOFMEMORY;
 
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
     hres = compile_statement(ctx, NULL, stat->if_stat);
     if(FAILED(hres))
         return hres;
@@ -550,6 +583,9 @@ static HRESULT compile_if_statement(compile_ctx_t *ctx, if_statement_t *stat)
         if(!cnd_jmp)
             return E_OUTOFMEMORY;
 
+        if(!emit_catch(ctx, 0))
+            return E_OUTOFMEMORY;
+
         hres = compile_statement(ctx, NULL, elseif_decl->stat);
         if(FAILED(hres))
             return hres;
@@ -589,6 +625,9 @@ static HRESULT compile_while_statement(compile_ctx_t *ctx, while_statement_t *st
     if(!jmp_end)
         return E_OUTOFMEMORY;
 
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
     if(stat->stat.type == STAT_WHILE) {
         loop_ctx = NULL;
     }else {
@@ -644,6 +683,10 @@ static HRESULT compile_dowhile_statement(compile_ctx_t *ctx, while_statement_t *
         return hres;
 
     label_set_addr(ctx, loop_ctx.while_end_label);
+
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
     return S_OK;
 }
 
@@ -653,6 +696,10 @@ static HRESULT compile_foreach_statement(compile_ctx_t *ctx, foreach_statement_t
     unsigned loop_start;
     HRESULT hres;
 
+    /* Preserve a place on the stack in case we throw before having proper enum collection. */
+    if(!push_instr(ctx, OP_empty))
+        return E_OUTOFMEMORY;
+
     hres = compile_expression(ctx, stat->group_expr);
     if(FAILED(hres))
         return hres;
@@ -660,7 +707,6 @@ static HRESULT compile_foreach_statement(compile_ctx_t *ctx, foreach_statement_t
     if(!push_instr(ctx, OP_newenum))
         return E_OUTOFMEMORY;
 
-    loop_start = ctx->instr_cnt;
     if(!(loop_ctx.for_end_label = alloc_label(ctx)))
         return E_OUTOFMEMORY;
 
@@ -668,10 +714,19 @@ static HRESULT compile_foreach_statement(compile_ctx_t *ctx, foreach_statement_t
     if(FAILED(hres))
         return hres;
 
+    if(!emit_catch(ctx, 1))
+        return E_OUTOFMEMORY;
+
+    loop_start = ctx->instr_cnt;
     hres = compile_statement(ctx, &loop_ctx, stat->body);
     if(FAILED(hres))
         return hres;
 
+    /* We need a separated enumnext here, because we need to jump out of the loop on exception. */
+    hres = push_instr_uint_bstr(ctx, OP_enumnext, loop_ctx.for_end_label, stat->identifier);
+    if(FAILED(hres))
+        return hres;
+
     hres = push_instr_addr(ctx, OP_jmp, loop_start);
     if(FAILED(hres))
         return hres;
@@ -695,6 +750,7 @@ static HRESULT compile_forto_statement(compile_ctx_t *ctx, forto_statement_t *st
     if(FAILED(hres))
         return hres;
 
+    /* FIXME: Assign should happen after both expressions evaluation. */
     instr = push_instr(ctx, OP_assign_ident);
     if(!instr)
         return E_OUTOFMEMORY;
@@ -731,10 +787,14 @@ static HRESULT compile_forto_statement(compile_ctx_t *ctx, forto_statement_t *st
     instr_ptr(ctx, step_instr)->arg2.bstr = identifier;
     instr_ptr(ctx, step_instr)->arg1.uint = loop_ctx.for_end_label;
 
+    if(!emit_catch(ctx, 2))
+        return E_OUTOFMEMORY;
+
     hres = compile_statement(ctx, &loop_ctx, stat->body);
     if(FAILED(hres))
         return hres;
 
+    /* FIXME: Error handling can't be done compatible with native using OP_incc here. */
     instr = push_instr(ctx, OP_incc);
     if(!instr)
         return E_OUTOFMEMORY;
@@ -749,6 +809,11 @@ static HRESULT compile_forto_statement(compile_ctx_t *ctx, forto_statement_t *st
         return hres;
 
     label_set_addr(ctx, loop_ctx.for_end_label);
+
+    /* FIXME: reconsider after OP_incc fixup. */
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
     return S_OK;
 }
 
@@ -770,6 +835,9 @@ static HRESULT compile_select_statement(compile_ctx_t *ctx, select_statement_t *
     if(!end_label)
         return E_OUTOFMEMORY;
 
+    if(!emit_catch_jmp(ctx, 0, end_label))
+        return E_OUTOFMEMORY;
+
     for(case_iter = stat->case_clausules; case_iter; case_iter = case_iter->next)
         case_cnt++;
 
@@ -797,6 +865,11 @@ static HRESULT compile_select_statement(compile_ctx_t *ctx, select_statement_t *
             hres = push_instr_addr(ctx, OP_case, case_labels[i]);
             if(FAILED(hres))
                 break;
+
+            if(!emit_catch_jmp(ctx, 0, case_labels[i])) {
+                hres = E_OUTOFMEMORY;
+                break;
+            }
         }
     }
 
@@ -863,7 +936,14 @@ static HRESULT compile_assignment(compile_ctx_t *ctx, member_expression_t *membe
     if(FAILED(hres))
         return hres;
 
-    return push_instr_bstr_uint(ctx, op, member_expr->identifier, args_cnt);
+    hres = push_instr_bstr_uint(ctx, op, member_expr->identifier, args_cnt);
+    if(FAILED(hres))
+        return hres;
+
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
+    return S_OK;
 }
 
 static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *stat, BOOL is_set)
@@ -873,6 +953,8 @@ static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *
 
 static HRESULT compile_call_statement(compile_ctx_t *ctx, call_statement_t *stat)
 {
+    HRESULT hres;
+
     /* It's challenging for parser to distinguish parameterized assignment with one argument from call
      * with equality expression argument, so we do it in compiler. */
     if(!stat->is_strict && stat->expr->args && !stat->expr->args->next && stat->expr->args->type == EXPR_EQUAL) {
@@ -888,7 +970,14 @@ static HRESULT compile_call_statement(compile_ctx_t *ctx, call_statement_t *stat
         }
     }
 
-    return compile_member_expression(ctx, stat->expr, FALSE);
+    hres = compile_member_expression(ctx, stat->expr, FALSE);
+    if(FAILED(hres))
+        return hres;
+
+    if(!emit_catch(ctx, 0))
+        return E_OUTOFMEMORY;
+
+    return S_OK;
 }
 
 static BOOL lookup_dim_decls(compile_ctx_t *ctx, const WCHAR *name)
@@ -927,13 +1016,26 @@ static HRESULT compile_dim_statement(compile_ctx_t *ctx, dim_statement_t *stat)
         }
 
         ctx->func->var_cnt++;
+
+        if(dim_decl->is_array) {
+            HRESULT hres = push_instr_bstr_uint(ctx, OP_dim, dim_decl->name, ctx->func->array_cnt++);
+            if(FAILED(hres))
+                return hres;
+
+            if(!emit_catch(ctx, 0))
+                return E_OUTOFMEMORY;
+        }
+
         if(!dim_decl->next)
             break;
         dim_decl = dim_decl->next;
     }
 
-    dim_decl->next = ctx->dim_decls;
-    ctx->dim_decls = stat->dim_decls;
+    if(ctx->dim_decls_tail)
+        ctx->dim_decls_tail->next = stat->dim_decls;
+    else
+        ctx->dim_decls = stat->dim_decls;
+    ctx->dim_decls_tail = dim_decl;
     return S_OK;
 }
 
@@ -960,6 +1062,9 @@ static HRESULT compile_const_statement(compile_ctx_t *ctx, const_statement_t *st
             hres = push_instr_bstr(ctx, OP_const, decl->name);
             if(FAILED(hres))
                 return hres;
+
+            if(!emit_catch(ctx, 0))
+                return E_OUTOFMEMORY;
         }
 
         next_decl = decl->next;
@@ -1036,11 +1141,7 @@ static HRESULT compile_exitfor_statement(compile_ctx_t *ctx)
 
 static HRESULT exit_label(compile_ctx_t *ctx, unsigned jmp_label)
 {
-    statement_ctx_t *iter;
-    unsigned pop_cnt = 0;
-
-    for(iter = ctx->stat_ctx; iter; iter = iter->next)
-        pop_cnt += iter->stack_use;
+    unsigned pop_cnt = stack_offset(ctx);
 
     if(pop_cnt) {
         HRESULT hres;
@@ -1192,6 +1293,28 @@ static void resolve_labels(compile_ctx_t *ctx, unsigned off)
     ctx->labels_cnt = 0;
 }
 
+static HRESULT fill_array_desc(compile_ctx_t *ctx, dim_decl_t *dim_decl, array_desc_t *array_desc)
+{
+    unsigned dim_cnt = 0, i;
+    dim_list_t *iter;
+
+    for(iter = dim_decl->dims; iter; iter = iter->next)
+        dim_cnt++;
+
+    array_desc->bounds = compiler_alloc(ctx->code, dim_cnt * sizeof(SAFEARRAYBOUND));
+    if(!array_desc->bounds)
+        return E_OUTOFMEMORY;
+
+    array_desc->dim_cnt = dim_cnt;
+
+    for(iter = dim_decl->dims, i=0; iter; iter = iter->next, i++) {
+        array_desc->bounds[i].cElements = iter->val+1;
+        array_desc->bounds[i].lLbound = 0;
+    }
+
+    return S_OK;
+}
+
 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
 {
     HRESULT hres;
@@ -1226,7 +1349,7 @@ static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *f
     }
 
     ctx->func = func;
-    ctx->dim_decls = NULL;
+    ctx->dim_decls = ctx->dim_decls_tail = NULL;
     ctx->const_decls = NULL;
     hres = compile_statement(ctx, NULL, stat);
     ctx->func = NULL;
@@ -1285,6 +1408,25 @@ static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *f
         }
     }
 
+    if(func->array_cnt) {
+        unsigned array_id = 0;
+        dim_decl_t *dim_decl;
+
+        func->array_descs = compiler_alloc(ctx->code, func->array_cnt * sizeof(array_desc_t));
+        if(!func->array_descs)
+            return E_OUTOFMEMORY;
+
+        for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
+            if(dim_decl->is_array) {
+                hres = fill_array_desc(ctx, dim_decl, func->array_descs + array_id++);
+                if(FAILED(hres))
+                    return hres;
+            }
+        }
+
+        assert(array_id == func->array_cnt);
+    }
+
     return S_OK;
 }
 
@@ -1320,6 +1462,7 @@ static HRESULT create_function(compile_ctx_t *ctx, function_decl_t *decl, functi
 
     func->vars = NULL;
     func->var_cnt = 0;
+    func->array_cnt = 0;
     func->code_ctx = ctx->code;
     func->type = decl->type;
     func->is_public = decl->is_public;
@@ -1421,8 +1564,8 @@ static BOOL lookup_class_funcs(class_desc_t *class_desc, const WCHAR *name)
 static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
 {
     function_decl_t *func_decl, *func_prop_decl;
-    class_prop_decl_t *prop_decl;
     class_desc_t *class_desc;
+    dim_decl_t *prop_decl;
     unsigned i;
     HRESULT hres;
 
@@ -1506,6 +1649,25 @@ static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
             return E_OUTOFMEMORY;
 
         class_desc->props[i].is_public = prop_decl->is_public;
+
+        if(prop_decl->is_array) {
+            class_desc->props[i].is_array = TRUE;
+            class_desc->array_cnt++;
+        }
+    }
+
+    if(class_desc->array_cnt) {
+        class_desc->array_descs = compiler_alloc(ctx->code, class_desc->array_cnt*sizeof(*class_desc->array_descs));
+        if(!class_desc->array_descs)
+            return E_OUTOFMEMORY;
+
+        for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next) {
+            if(prop_decl->is_array) {
+                hres = fill_array_desc(ctx, prop_decl, class_desc->array_descs + i++);
+                if(FAILED(hres))
+                    return hres;
+            }
+        }
     }
 
     class_desc->next = ctx->classes;
@@ -1620,6 +1782,7 @@ static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source)
     ret->main_code.code_ctx = ret;
     ret->main_code.vars = NULL;
     ret->main_code.var_cnt = 0;
+    ret->main_code.array_cnt = 0;
     ret->main_code.arg_cnt = 0;
     ret->main_code.args = NULL;
 
@@ -1655,7 +1818,6 @@ HRESULT compile_script(script_ctx_t *script, const WCHAR *src, const WCHAR *deli
     ctx.funcs = NULL;
     ctx.func_decls = NULL;
     ctx.global_vars = NULL;
-    ctx.dim_decls = NULL;
     ctx.classes = NULL;
     ctx.labels = NULL;
     ctx.global_consts = NULL;
diff --git a/reactos/dll/win32/vbscript/error.c b/reactos/dll/win32/vbscript/error.c
deleted file mode 100644 (file)
index 12c2680..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2011 Jacek Caban for CodeWeavers
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include "vbscript.h"
-
-static HRESULT Err_Description(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_HelpContext(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_HelpFile(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_Number(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_Source(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_Clear(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT Err_Raise(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
-{
-    FIXME("\n");
-    return E_NOTIMPL;
-}
-
-static const builtin_prop_t err_props[] = {
-    {DISPID_ERR_DESCRIPTION,  Err_Description, BP_GETPUT},
-    {DISPID_ERR_HELPCONTEXT,  Err_HelpContext, BP_GETPUT},
-    {DISPID_ERR_HELPFILE,     Err_HelpFile, BP_GETPUT},
-    {DISPID_ERR_NUMBER,       Err_Number, BP_GETPUT},
-    {DISPID_ERR_SOURCE,       Err_Source, BP_GETPUT},
-    {DISPID_ERR_CLEAR,        Err_Clear},
-    {DISPID_ERR_RAISE,        Err_Raise, 0, 5},
-};
-
-HRESULT init_err(script_ctx_t *ctx)
-{
-    HRESULT hres;
-
-    ctx->err_desc.ctx = ctx;
-    ctx->err_desc.builtin_prop_cnt = sizeof(err_props)/sizeof(*err_props);
-    ctx->err_desc.builtin_props = err_props;
-
-    hres = get_typeinfo(ErrObj_tid, &ctx->err_desc.typeinfo);
-    if(FAILED(hres))
-        return hres;
-
-    return create_vbdisp(&ctx->err_desc, &ctx->err_obj);
-}
index d171f56..206afc5 100644 (file)
@@ -144,8 +144,11 @@ static inline HRESULT return_date(VARIANT *res, double date)
     return S_OK;
 }
 
-static HRESULT to_int(VARIANT *v, int *ret)
+HRESULT to_int(VARIANT *v, int *ret)
 {
+    if(V_VT(v) == (VT_BYREF|VT_VARIANT))
+        v = V_VARIANTREF(v);
+
     switch(V_VT(v)) {
     case VT_I2:
         *ret = V_I2(v);
@@ -1857,6 +1860,75 @@ static const builtin_prop_t global_props[] = {
     {DISPID_GLOBAL_VBMSGBOXRTLREADING,     NULL, BP_GET, VT_I4, MB_RTLREADING}
 };
 
+static HRESULT Err_Description(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT Err_HelpContext(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT Err_HelpFile(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT Err_Number(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    HRESULT hres;
+
+    TRACE("\n");
+
+    if(!This->desc)
+        return E_UNEXPECTED;
+
+    if(args_cnt) {
+        FIXME("setter not implemented\n");
+        return E_NOTIMPL;
+    }
+
+    hres = This->desc->ctx->err_number;
+    return return_int(res, HRESULT_FACILITY(hres) == FACILITY_VBS ? HRESULT_CODE(hres) : hres);
+}
+
+static HRESULT Err_Source(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT Err_Clear(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    TRACE("\n");
+
+    if(!This->desc)
+        return E_UNEXPECTED;
+
+    This->desc->ctx->err_number = S_OK;
+    return S_OK;
+}
+
+static HRESULT Err_Raise(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const builtin_prop_t err_props[] = {
+    {DISPID_ERR_DESCRIPTION,  Err_Description, BP_GETPUT},
+    {DISPID_ERR_HELPCONTEXT,  Err_HelpContext, BP_GETPUT},
+    {DISPID_ERR_HELPFILE,     Err_HelpFile, BP_GETPUT},
+    {DISPID_ERR_NUMBER,       Err_Number, BP_GETPUT},
+    {DISPID_ERR_SOURCE,       Err_Source, BP_GETPUT},
+    {DISPID_ERR_CLEAR,        Err_Clear},
+    {DISPID_ERR_RAISE,        Err_Raise, 0, 5},
+};
+
 HRESULT init_global(script_ctx_t *ctx)
 {
     HRESULT hres;
@@ -1877,5 +1949,13 @@ HRESULT init_global(script_ctx_t *ctx)
     if(FAILED(hres))
         return hres;
 
-    return init_err(ctx);
+    ctx->err_desc.ctx = ctx;
+    ctx->err_desc.builtin_prop_cnt = sizeof(err_props)/sizeof(*err_props);
+    ctx->err_desc.builtin_props = err_props;
+
+    hres = get_typeinfo(ErrObj_tid, &ctx->err_desc.typeinfo);
+    if(FAILED(hres))
+        return hres;
+
+    return create_vbdisp(&ctx->err_desc, &ctx->err_obj);
 }
index 4223a7f..4a7624b 100644 (file)
@@ -26,9 +26,11 @@ typedef struct {
     script_ctx_t *script;
     function_t *func;
     IDispatch *this_obj;
+    vbdisp_t *vbthis;
 
     VARIANT *args;
     VARIANT *vars;
+    SAFEARRAY **arrays;
 
     dynamic_var_t *dynamic_vars;
     heap_pool_t heap;
@@ -125,6 +127,17 @@ static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_
         return S_OK;
 
     if(ctx->func->type != FUNC_GLOBAL) {
+        if(ctx->vbthis) {
+            /* FIXME: Bind such identifier while generating bytecode. */
+            for(i=0; i < ctx->vbthis->desc->prop_cnt; i++) {
+                if(!strcmpiW(ctx->vbthis->desc->props[i].name, name)) {
+                    ref->type = REF_VAR;
+                    ref->u.v = ctx->vbthis->props+i;
+                    return S_OK;
+                }
+            }
+        }
+
         hres = disp_get_id(ctx->this_obj, name, invoke_type, TRUE, &id);
         if(SUCCEEDED(hres)) {
             ref->type = REF_DISP;
@@ -290,33 +303,42 @@ static void stack_popn(exec_ctx_t *ctx, unsigned n)
         VariantClear(stack_pop(ctx));
 }
 
-static HRESULT stack_pop_val(exec_ctx_t *ctx, variant_val_t *v)
+static void stack_pop_deref(exec_ctx_t *ctx, variant_val_t *r)
 {
-    VARIANT *var;
-
-    var = stack_pop(ctx);
+    VARIANT *v;
 
-    if(V_VT(var) == (VT_BYREF|VT_VARIANT)) {
-        v->owned = FALSE;
-        var = V_VARIANTREF(var);
+    v = stack_pop(ctx);
+    if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
+        r->owned = FALSE;
+        r->v = V_VARIANTREF(v);
     }else {
-        v->owned = TRUE;
+        r->owned = TRUE;
+        r->v = v;
     }
+}
 
-    if(V_VT(var) == VT_DISPATCH) {
+static inline void release_val(variant_val_t *v)
+{
+    if(v->owned)
+        VariantClear(v->v);
+}
+
+static HRESULT stack_pop_val(exec_ctx_t *ctx, variant_val_t *r)
+{
+    stack_pop_deref(ctx, r);
+
+    if(V_VT(r->v) == VT_DISPATCH) {
         DISPPARAMS dp = {0};
         HRESULT hres;
 
-        hres = disp_call(ctx->script, V_DISPATCH(var), DISPID_VALUE, &dp, &v->store);
-        if(v->owned)
-            IDispatch_Release(V_DISPATCH(var));
+        hres = disp_call(ctx->script, V_DISPATCH(r->v), DISPID_VALUE, &dp, &r->store);
+        if(r->owned)
+            IDispatch_Release(V_DISPATCH(r->v));
         if(FAILED(hres))
             return hres;
 
-        v->owned = TRUE;
-        v->v = &v->store;
-    }else {
-        v->v = var;
+        r->owned = TRUE;
+        r->v = &r->store;
     }
 
     return S_OK;
@@ -351,12 +373,6 @@ static HRESULT stack_assume_val(exec_ctx_t *ctx, unsigned n)
     return S_OK;
 }
 
-static inline void release_val(variant_val_t *v)
-{
-    if(v->owned)
-        VariantClear(v->v);
-}
-
 static int stack_pop_bool(exec_ctx_t *ctx, BOOL *b)
 {
     variant_val_t val;
@@ -471,6 +487,49 @@ static void vbstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, BOOL is_propput, DI
     }
 }
 
+static HRESULT array_access(exec_ctx_t *ctx, SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
+{
+    unsigned cell_off = 0, dim_size = 1, i;
+    unsigned argc = arg_cnt(dp);
+    VARIANT *data;
+    LONG idx;
+    HRESULT hres;
+
+    if(!array) {
+        FIXME("NULL array\n");
+        return E_FAIL;
+    }
+
+    if(array->cDims != argc) {
+        FIXME("argc %d does not match cDims %d\n", dp->cArgs, array->cDims);
+        return E_FAIL;
+    }
+
+    for(i=0; i < argc; i++) {
+        hres = to_int(get_arg(dp, i), &idx);
+        if(FAILED(hres))
+            return hres;
+
+        idx -= array->rgsabound[i].lLbound;
+        if(idx >= array->rgsabound[i].cElements) {
+            FIXME("out of bound element %d in dim %d of size %d\n", idx, i+1, array->rgsabound[i].cElements);
+            return E_FAIL;
+        }
+
+        cell_off += idx*dim_size;
+        dim_size *= array->rgsabound[i].cElements;
+    }
+
+    hres = SafeArrayAccessData(array, (void**)&data);
+    if(FAILED(hres))
+        return hres;
+
+    *ret = data+cell_off;
+
+    SafeArrayUnaccessData(array);
+    return S_OK;
+}
+
 static HRESULT do_icall(exec_ctx_t *ctx, VARIANT *res)
 {
     BSTR identifier = ctx->instr->arg1.bstr;
@@ -483,30 +542,51 @@ static HRESULT do_icall(exec_ctx_t *ctx, VARIANT *res)
     if(FAILED(hres))
         return hres;
 
-    vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
-
     switch(ref.type) {
     case REF_VAR:
-    case REF_CONST:
+    case REF_CONST: {
+        VARIANT *v;
+
         if(!res) {
             FIXME("REF_VAR no res\n");
             return E_NOTIMPL;
         }
 
+        v = V_VT(ref.u.v) == (VT_VARIANT|VT_BYREF) ? V_VARIANTREF(ref.u.v) : ref.u.v;
+
         if(arg_cnt) {
-            FIXME("arguments not implemented\n");
-            return E_NOTIMPL;
+            SAFEARRAY *array;
+
+            switch(V_VT(v)) {
+            case VT_ARRAY|VT_BYREF|VT_VARIANT:
+                array = *V_ARRAYREF(ref.u.v);
+                break;
+            case VT_ARRAY|VT_VARIANT:
+                array = V_ARRAY(ref.u.v);
+                break;
+            default:
+                FIXME("arguments not implemented\n");
+                return E_NOTIMPL;
+            }
+
+            vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
+            hres = array_access(ctx, array, &dp, &v);
+            if(FAILED(hres))
+                return hres;
         }
 
         V_VT(res) = VT_BYREF|VT_VARIANT;
-        V_BYREF(res) = V_VT(ref.u.v) == (VT_VARIANT|VT_BYREF) ? V_VARIANTREF(ref.u.v) : ref.u.v;
+        V_BYREF(res) = v;
         break;
+    }
     case REF_DISP:
+        vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
         hres = disp_call(ctx->script, ref.u.d.disp, ref.u.d.id, &dp, res);
         if(FAILED(hres))
             return hres;
         break;
     case REF_FUNC:
+        vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
         hres = exec_script(ctx->script, ref.u.f, NULL, &dp, res);
         if(FAILED(hres))
             return hres;
@@ -627,15 +707,43 @@ static HRESULT assign_ident(exec_ctx_t *ctx, BSTR name, DISPPARAMS *dp)
     case REF_VAR: {
         VARIANT *v = ref.u.v;
 
+        if(V_VT(v) == (VT_VARIANT|VT_BYREF))
+            v = V_VARIANTREF(v);
+
         if(arg_cnt(dp)) {
-            FIXME("arg_cnt %d not supported\n", arg_cnt(dp));
+            SAFEARRAY *array;
+
+            if(!(V_VT(v) & VT_ARRAY)) {
+                FIXME("array assign on type %d\n", V_VT(v));
+                return E_FAIL;
+            }
+
+            switch(V_VT(v)) {
+            case VT_ARRAY|VT_BYREF|VT_VARIANT:
+                array = *V_ARRAYREF(v);
+                break;
+            case VT_ARRAY|VT_VARIANT:
+                array = V_ARRAY(v);
+                break;
+            default:
+                FIXME("Unsupported array type %x\n", V_VT(v));
+                return E_NOTIMPL;
+            }
+
+            if(!array) {
+                FIXME("null array\n");
+                return E_FAIL;
+            }
+
+            hres = array_access(ctx, array, dp, &v);
+            if(FAILED(hres))
+                return hres;
+        }else if(V_VT(v) == (VT_ARRAY|VT_BYREF|VT_VARIANT)) {
+            FIXME("non-array assign\n");
             return E_NOTIMPL;
         }
 
-        if(V_VT(v) == (VT_VARIANT|VT_BYREF))
-            v = V_VARIANTREF(v);
-
-        hres = VariantCopy(v, dp->rgvarg);
+        hres = VariantCopyInd(v, dp->rgvarg);
         break;
     }
     case REF_DISP:
@@ -861,8 +969,19 @@ static HRESULT interp_new(exec_ctx_t *ctx)
     VARIANT v;
     HRESULT hres;
 
+    static const WCHAR regexpW[] = {'r','e','g','e','x','p',0};
+
     TRACE("%s\n", debugstr_w(arg));
 
+    if(!strcmpiW(arg, regexpW)) {
+        V_VT(&v) = VT_DISPATCH;
+        hres = create_regexp(&V_DISPATCH(&v));
+        if(FAILED(hres))
+            return hres;
+
+        return stack_push(ctx, &v);
+    }
+
     for(class_desc = ctx->script->classes; class_desc; class_desc = class_desc->next) {
         if(!strcmpiW(class_desc->name, arg))
             break;
@@ -881,6 +1000,51 @@ static HRESULT interp_new(exec_ctx_t *ctx)
     return stack_push(ctx, &v);
 }
 
+static HRESULT interp_dim(exec_ctx_t *ctx)
+{
+    const BSTR ident = ctx->instr->arg1.bstr;
+    const unsigned array_id = ctx->instr->arg2.uint;
+    const array_desc_t *array_desc;
+    ref_t ref;
+    HRESULT hres;
+
+    TRACE("%s\n", debugstr_w(ident));
+
+    assert(array_id < ctx->func->array_cnt);
+    if(!ctx->arrays) {
+        ctx->arrays = heap_alloc_zero(ctx->func->array_cnt * sizeof(SAFEARRAY*));
+        if(!ctx->arrays)
+            return E_OUTOFMEMORY;
+    }
+
+    hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
+    if(FAILED(hres)) {
+        FIXME("lookup %s failed: %08x\n", debugstr_w(ident), hres);
+        return hres;
+    }
+
+    if(ref.type != REF_VAR) {
+        FIXME("got ref.type = %d\n", ref.type);
+        return E_FAIL;
+    }
+
+    if(ctx->arrays[array_id]) {
+        FIXME("Array already initialized\n");
+        return E_FAIL;
+    }
+
+    array_desc = ctx->func->array_descs + array_id;
+    if(array_desc->dim_cnt) {
+        ctx->arrays[array_id] = SafeArrayCreate(VT_VARIANT, array_desc->dim_cnt, array_desc->bounds);
+        if(!ctx->arrays[array_id])
+            return E_OUTOFMEMORY;
+    }
+
+    V_VT(ref.u.v) = VT_ARRAY|VT_BYREF|VT_VARIANT;
+    V_ARRAYREF(ref.u.v) = ctx->arrays+array_id;
+    return S_OK;
+}
+
 static HRESULT interp_step(exec_ctx_t *ctx)
 {
     const BSTR ident = ctx->instr->arg2.bstr;
@@ -923,20 +1087,25 @@ static HRESULT interp_step(exec_ctx_t *ctx)
 
 static HRESULT interp_newenum(exec_ctx_t *ctx)
 {
-    VARIANT *v, r;
+    variant_val_t v;
+    VARIANT *r;
     HRESULT hres;
 
     TRACE("\n");
 
-    v = stack_pop(ctx);
-    switch(V_VT(v)) {
+    stack_pop_deref(ctx, &v);
+    assert(V_VT(stack_top(ctx, 0)) == VT_EMPTY);
+    r = stack_top(ctx, 0);
+
+    switch(V_VT(v.v)) {
+    case VT_DISPATCH|VT_BYREF:
     case VT_DISPATCH: {
         IEnumVARIANT *iter;
         DISPPARAMS dp = {0};
         VARIANT iterv;
 
-        hres = disp_call(ctx->script, V_DISPATCH(v), DISPID_NEWENUM, &dp, &iterv);
-        VariantClear(v);
+        hres = disp_call(ctx->script, V_ISBYREF(v.v) ? *V_DISPATCHREF(v.v) : V_DISPATCH(v.v), DISPID_NEWENUM, &dp, &iterv);
+        release_val(&v);
         if(FAILED(hres))
             return hres;
 
@@ -953,17 +1122,17 @@ static HRESULT interp_newenum(exec_ctx_t *ctx)
             return hres;
         }
 
-        V_VT(&r) = VT_UNKNOWN;
-        V_UNKNOWN(&r) = (IUnknown*)iter;
+        V_VT(r) = VT_UNKNOWN;
+        V_UNKNOWN(r) = (IUnknown*)iter;
         break;
     }
     default:
-        FIXME("Unsupported for %s\n", debugstr_variant(v));
-        VariantClear(v);
+        FIXME("Unsupported for %s\n", debugstr_variant(v.v));
+        release_val(&v);
         return E_NOTIMPL;
     }
 
-    return stack_push(ctx, &r);
+    return S_OK;
 }
 
 static HRESULT interp_enumnext(exec_ctx_t *ctx)
@@ -978,6 +1147,11 @@ static HRESULT interp_enumnext(exec_ctx_t *ctx)
 
     TRACE("\n");
 
+    if(V_VT(stack_top(ctx, 0)) == VT_EMPTY) {
+        FIXME("uninitialized\n");
+        return E_FAIL;
+    }
+
     assert(V_VT(stack_top(ctx, 0)) == VT_UNKNOWN);
     iter = (IEnumVARIANT*)V_UNKNOWN(stack_top(ctx, 0));
 
@@ -1787,6 +1961,12 @@ static HRESULT interp_incc(exec_ctx_t *ctx)
     return S_OK;
 }
 
+static HRESULT interp_catch(exec_ctx_t *ctx)
+{
+    /* Nothing to do here, the OP is for unwinding only. */
+    return S_OK;
+}
+
 static const instr_func_t op_funcs[] = {
 #define X(x,n,a,b) interp_ ## x,
 OP_LIST
@@ -1827,13 +2007,21 @@ static void release_exec(exec_ctx_t *ctx)
             VariantClear(ctx->vars+i);
     }
 
+    if(ctx->arrays) {
+        for(i=0; i < ctx->func->var_cnt; i++) {
+            if(ctx->arrays[i])
+                SafeArrayDestroy(ctx->arrays[i]);
+        }
+        heap_free(ctx->arrays);
+    }
+
     heap_pool_free(&ctx->heap);
     heap_free(ctx->args);
     heap_free(ctx->vars);
     heap_free(ctx->stack);
 }
 
-HRESULT exec_script(script_ctx_t *ctx, function_t *func, IDispatch *this_obj, DISPPARAMS *dp, VARIANT *res)
+HRESULT exec_script(script_ctx_t *ctx, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
 {
     exec_ctx_t exec = {func->code_ctx};
     vbsop_t op;
@@ -1864,9 +2052,9 @@ HRESULT exec_script(script_ctx_t *ctx, function_t *func, IDispatch *this_obj, DI
                 if(func->args[i].by_ref)
                     exec.args[i] = *v;
                 else
-                    hres = VariantCopy(exec.args+i, V_VARIANTREF(v));
+                    hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
             }else {
-                hres = VariantCopy(exec.args+i, v);
+                hres = VariantCopyInd(exec.args+i, v);
             }
             if(FAILED(hres)) {
                 release_exec(&exec);
@@ -1895,12 +2083,14 @@ HRESULT exec_script(script_ctx_t *ctx, function_t *func, IDispatch *this_obj, DI
         return E_OUTOFMEMORY;
     }
 
-    if(this_obj)
-        exec.this_obj = this_obj;
-    else if (ctx->host_global)
+    if(vbthis) {
+        exec.this_obj = (IDispatch*)&vbthis->IDispatchEx_iface;
+        exec.vbthis = vbthis;
+    }else if (ctx->host_global) {
         exec.this_obj = ctx->host_global;
-    else
+    }else {
         exec.this_obj = (IDispatch*)&ctx->script_obj->IDispatchEx_iface;
+    }
     IDispatch_AddRef(exec.this_obj);
 
     exec.instr = exec.code->instrs + func->code_off;
@@ -1911,12 +2101,45 @@ HRESULT exec_script(script_ctx_t *ctx, function_t *func, IDispatch *this_obj, DI
         op = exec.instr->op;
         hres = op_funcs[op](&exec);
         if(FAILED(hres)) {
-            if(exec.resume_next)
-                FIXME("Failed %08x in resume next mode\n", hres);
-            else
+            ctx->err_number = hres = map_hres(hres);
+
+            if(exec.resume_next) {
+                unsigned stack_off;
+
+                WARN("Failed %08x in resume next mode\n", hres);
+
+                /*
+                 * Unwinding here is simple. We need to find the next OP_catch, which contains
+                 * information about expected stack size and jump offset on error. Generated
+                 * bytecode needs to guarantee, that simple jump and stack adjustment will
+                 * guarantee proper execution continuation.
+                 */
+                while((++exec.instr)->op != OP_catch);
+
+                TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
+
+                stack_off = exec.instr->arg2.uint;
+                instr_jmp(&exec, exec.instr->arg1.uint);
+
+                if(exec.top > stack_off) {
+                    stack_popn(&exec, exec.top-stack_off);
+                }else if(exec.top < stack_off) {
+                    VARIANT v;
+
+                    V_VT(&v) = VT_EMPTY;
+                    while(exec.top < stack_off) {
+                        hres = stack_push(&exec, &v);
+                        if(FAILED(hres))
+                            break;
+                    }
+                }
+
+                continue;
+            }else {
                 WARN("Failed %08x\n", hres);
-            stack_popn(&exec, exec.top);
-            break;
+                stack_popn(&exec, exec.top);
+                break;
+            }
         }
 
         exec.instr += op_move[op];
index ba1a311..2a49703 100644 (file)
@@ -138,8 +138,16 @@ typedef struct {
     expression_t *value_expr;
 } assign_statement_t;
 
+typedef struct _dim_list_t {
+    unsigned val;
+    struct _dim_list_t *next;
+} dim_list_t;
+
 typedef struct _dim_decl_t {
     const WCHAR *name;
+    BOOL is_array;
+    BOOL is_public; /* Used only for class members. */
+    dim_list_t *dims;
     struct _dim_decl_t *next;
 } dim_decl_t;
 
@@ -169,16 +177,10 @@ typedef struct {
     function_decl_t *func_decl;
 } function_statement_t;
 
-typedef struct _class_prop_decl_t {
-    BOOL is_public;
-    const WCHAR *name;
-    struct _class_prop_decl_t *next;
-} class_prop_decl_t;
-
 typedef struct _class_decl_t {
     const WCHAR *name;
     function_decl_t *funcs;
-    class_prop_decl_t *props;
+    dim_decl_t *props;
     struct _class_decl_t *next;
 } class_decl_t;
 
index 87caa7a..18ac409 100644 (file)
@@ -110,7 +110,8 @@ static statement_t *new_onerror_statement(parser_ctx_t*,BOOL);
 static statement_t *new_const_statement(parser_ctx_t*,const_decl_t*);
 static statement_t *new_select_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
 
-static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,dim_decl_t*);
+static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,BOOL,dim_list_t*);
+static dim_list_t *new_dim(parser_ctx_t*,unsigned,dim_list_t*);
 static elseif_decl_t *new_elseif_decl(parser_ctx_t*,expression_t*,statement_t*);
 static function_decl_t *new_function_decl(parser_ctx_t*,const WCHAR*,function_type_t,unsigned,arg_decl_t*,statement_t*);
 static arg_decl_t *new_argument_decl(parser_ctx_t*,const WCHAR*,BOOL);
@@ -119,7 +120,7 @@ static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_
 
 static class_decl_t *new_class_decl(parser_ctx_t*);
 static class_decl_t *add_class_function(parser_ctx_t*,class_decl_t*,function_decl_t*);
-static class_decl_t *add_variant_prop(parser_ctx_t*,class_decl_t*,const WCHAR*,unsigned);
+static class_decl_t *add_dim_prop(parser_ctx_t*,class_decl_t*,dim_decl_t*,unsigned);
 
 static statement_t *link_statements(statement_t*,statement_t*);
 
@@ -133,7 +134,7 @@ static const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0};
 
 
 /* Line 268 of yacc.c  */
-#line 143 "parser.tab.c"
+#line 144 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -238,7 +239,7 @@ typedef union YYSTYPE
 {
 
 /* Line 293 of yacc.c  */
-#line 87 "parser.y"
+#line 88 "parser.y"
 
     const WCHAR *string;
     statement_t *statement;
@@ -246,6 +247,7 @@ typedef union YYSTYPE
     member_expression_t *member;
     elseif_decl_t *elseif;
     dim_decl_t *dim_decl;
+    dim_list_t *dim_list;
     function_decl_t *func_decl;
     arg_decl_t *arg_decl;
     class_decl_t *class_decl;
@@ -259,7 +261,7 @@ typedef union YYSTYPE
 
 
 /* Line 293 of yacc.c  */
-#line 269 "parser.tab.c"
+#line 271 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -271,7 +273,7 @@ typedef union YYSTYPE
 
 
 /* Line 343 of yacc.c  */
-#line 281 "parser.tab.c"
+#line 283 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -490,16 +492,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  5
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   800
+#define YYLAST   862
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  87
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  55
+#define YYNNTS  59
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  153
+#define YYNRULES  164
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  315
+#define YYNSTATES  335
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
@@ -515,7 +517,7 @@ static const yytype_uint8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,    81,     2,
-      77,    78,    84,    82,    75,    76,    74,    85,    73,     2,
+      76,    77,    84,    82,    75,    78,    74,    85,    73,     2,
        2,     2,     2,     2,     2,     2,     2,     2,    71,     2,
       80,    72,    79,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -555,97 +557,102 @@ static const yytype_uint16 yyprhs[] =
       22,    24,    27,    30,    32,    35,    37,    41,    44,    47,
       51,    56,    59,    61,    67,    74,    81,    86,    88,    91,
       94,    97,   100,   103,   109,   111,   116,   121,   124,   135,
-     144,   152,   154,   158,   160,   164,   166,   170,   174,   176,
-     179,   181,   183,   184,   187,   197,   202,   210,   211,   214,
-     215,   217,   219,   222,   228,   229,   233,   234,   239,   245,
-     247,   251,   253,   255,   256,   258,   260,   264,   266,   270,
-     272,   276,   278,   282,   284,   288,   290,   294,   296,   299,
-     301,   305,   309,   313,   317,   321,   325,   329,   331,   335,
-     337,   341,   345,   347,   351,   353,   357,   359,   363,   367,
-     369,   373,   375,   377,   380,   383,   385,   388,   390,   392,
-     394,   396,   398,   400,   402,   404,   406,   408,   410,   414,
-     416,   424,   425,   429,   434,   438,   448,   460,   472,   481,
-     490,   491,   493,   496,   498,   500,   502,   506,   508,   512,
-     514,   517,   520,   522
+     144,   152,   154,   158,   160,   164,   166,   171,   174,   176,
+     180,   182,   186,   190,   192,   195,   197,   199,   200,   203,
+     213,   218,   226,   227,   230,   231,   233,   235,   238,   244,
+     245,   249,   250,   255,   261,   263,   267,   269,   271,   272,
+     274,   276,   280,   282,   286,   288,   292,   294,   298,   300,
+     304,   306,   310,   312,   315,   317,   321,   325,   329,   333,
+     337,   341,   345,   347,   351,   353,   357,   361,   363,   367,
+     369,   373,   375,   379,   383,   385,   389,   391,   393,   396,
+     399,   401,   404,   406,   408,   410,   412,   414,   416,   418,
+     420,   422,   424,   426,   428,   430,   432,   436,   438,   446,
+     447,   451,   456,   461,   465,   475,   487,   499,   508,   517,
+     518,   520,   523,   525,   527,   529,   533,   535,   539,   542,
+     546,   550,   552,   554,   556
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
       88,     0,    -1,    89,    90,     3,    -1,    -1,    48,    49,
-       4,    -1,    -1,    90,    93,    -1,    90,   132,    -1,    -1,
+       4,    -1,    -1,    90,    93,    -1,    90,   135,    -1,    -1,
       92,    -1,    93,    -1,    93,    92,    -1,    94,     4,    -1,
       71,    -1,    71,    94,    -1,    95,    -1,    95,    71,    94,
-      -1,    95,    71,    -1,    96,   111,    -1,    20,    96,   110,
-      -1,    96,   110,    72,   114,    -1,    21,    97,    -1,   103,
-      -1,    34,   114,     4,    91,    35,    -1,    36,   101,   114,
-       4,    91,    37,    -1,    36,     4,    91,    37,   101,   114,
-      -1,    36,     4,    91,    37,    -1,   135,    -1,    33,    36,
+      -1,    95,    71,    -1,    96,   113,    -1,    20,    96,   112,
+      -1,    96,   112,    72,   116,    -1,    21,    97,    -1,   105,
+      -1,    34,   116,     4,    91,    35,    -1,    36,   103,   116,
+       4,    91,    37,    -1,    36,     4,    91,    37,   103,   116,
+      -1,    36,     4,    91,    37,    -1,   138,    -1,    33,    36,
       -1,    33,    39,    -1,    33,    23,    -1,    33,    24,    -1,
-      33,    22,    -1,    55,    96,   110,    72,   114,    -1,    50,
+      33,    22,    -1,    55,    96,   112,    72,   116,    -1,    50,
       -1,    63,    61,    64,    62,    -1,    63,    61,    65,    73,
-      -1,    27,    98,    -1,    39,   141,    72,   114,    40,   114,
-     102,     4,    91,    62,    -1,    39,    42,   141,    43,   114,
-       4,    91,    62,    -1,    44,    45,   114,     4,   109,    31,
-      44,    -1,   141,    -1,   128,    74,   141,    -1,   141,    -1,
-     141,    75,    97,    -1,    99,    -1,    99,    75,    98,    -1,
-     141,    72,   100,    -1,   129,    -1,    76,   130,    -1,    34,
-      -1,    38,    -1,    -1,    41,   114,    -1,    28,   114,    32,
-       4,    91,   105,   108,    31,    28,    -1,    28,   114,    32,
-      94,    -1,    28,   114,    32,    94,    29,    94,   104,    -1,
-      -1,    31,    28,    -1,    -1,   106,    -1,   107,    -1,   107,
-     106,    -1,    30,   114,    32,     4,    91,    -1,    -1,    29,
-       4,    91,    -1,    -1,    45,    29,     4,    92,    -1,    45,
-     113,     4,    91,   109,    -1,   112,    -1,    77,   113,    78,
-      -1,   112,    -1,   113,    -1,    -1,     6,    -1,   114,    -1,
-     114,    75,   113,    -1,   115,    -1,   114,    14,   115,    -1,
-     116,    -1,   115,    13,   116,    -1,   117,    -1,   116,    12,
-     117,    -1,   118,    -1,   117,    11,   118,    -1,   119,    -1,
-     118,    10,   119,    -1,   120,    -1,     9,   119,    -1,   121,
-      -1,   120,    72,   121,    -1,   120,    15,   121,    -1,   120,
-      79,   121,    -1,   120,    80,   121,    -1,   120,    18,   121,
-      -1,   120,    17,   121,    -1,   120,    16,   121,    -1,   122,
-      -1,   121,    81,   122,    -1,   123,    -1,   122,    82,   123,
-      -1,   122,    76,   123,    -1,   124,    -1,   123,    19,   124,
-      -1,   125,    -1,   124,    83,   125,    -1,   126,    -1,   125,
-      84,   126,    -1,   125,    85,   126,    -1,   127,    -1,   126,
-      86,   127,    -1,   129,    -1,   128,    -1,    56,   141,    -1,
-      76,   127,    -1,   131,    -1,    96,   110,    -1,     7,    -1,
-       8,    -1,    67,    -1,   130,    -1,    52,    -1,    53,    -1,
-      51,    -1,    69,    -1,    73,    -1,    68,    -1,    70,    -1,
-      77,   114,    78,    -1,    60,    -1,    54,   141,     4,   133,
-      31,    54,     4,    -1,    -1,   135,     4,   133,    -1,   137,
-      66,     4,   133,    -1,   134,     4,   133,    -1,   136,    24,
-      25,    66,   112,     4,    91,    31,    24,    -1,   136,    24,
-      26,    66,    77,   140,    78,     4,    91,    31,    24,    -1,
-     136,    24,    55,    66,    77,   140,    78,     4,    91,    31,
-      24,    -1,   136,    22,   141,   138,     4,    91,    31,    22,
-      -1,   136,    23,   141,   138,     4,    91,    31,    23,    -1,
-      -1,   137,    -1,    57,    59,    -1,    57,    -1,    58,    -1,
-     112,    -1,    77,   139,    78,    -1,   140,    -1,   140,    75,
-     139,    -1,   141,    -1,    46,   141,    -1,    47,   141,    -1,
-      66,    -1,    24,    -1
+      -1,    27,   100,    -1,    39,   144,    72,   116,    40,   116,
+     104,     4,    91,    62,    -1,    39,    42,   144,    43,   116,
+       4,    91,    62,    -1,    44,    45,   116,   145,   111,    31,
+      44,    -1,   144,    -1,   130,    74,   144,    -1,    98,    -1,
+      98,    75,    97,    -1,   144,    -1,   144,    76,    99,    77,
+      -1,   144,     6,    -1,   133,    -1,   133,    75,    99,    -1,
+     101,    -1,   101,    75,   100,    -1,   144,    72,   102,    -1,
+     131,    -1,    78,   132,    -1,    34,    -1,    38,    -1,    -1,
+      41,   116,    -1,    28,   116,    32,     4,    91,   107,   110,
+      31,    28,    -1,    28,   116,    32,    94,    -1,    28,   116,
+      32,    94,    29,    94,   106,    -1,    -1,    31,    28,    -1,
+      -1,   108,    -1,   109,    -1,   109,   108,    -1,    30,   116,
+      32,     4,    91,    -1,    -1,    29,     4,    91,    -1,    -1,
+      45,    29,   145,    92,    -1,    45,   115,   145,    91,   111,
+      -1,   114,    -1,    76,   115,    77,    -1,   114,    -1,   115,
+      -1,    -1,     6,    -1,   116,    -1,   116,    75,   115,    -1,
+     117,    -1,   116,    14,   117,    -1,   118,    -1,   117,    13,
+     118,    -1,   119,    -1,   118,    12,   119,    -1,   120,    -1,
+     119,    11,   120,    -1,   121,    -1,   120,    10,   121,    -1,
+     122,    -1,     9,   121,    -1,   123,    -1,   122,    72,   123,
+      -1,   122,    15,   123,    -1,   122,    79,   123,    -1,   122,
+      80,   123,    -1,   122,    18,   123,    -1,   122,    17,   123,
+      -1,   122,    16,   123,    -1,   124,    -1,   123,    81,   124,
+      -1,   125,    -1,   124,    82,   125,    -1,   124,    78,   125,
+      -1,   126,    -1,   125,    19,   126,    -1,   127,    -1,   126,
+      83,   127,    -1,   128,    -1,   127,    84,   128,    -1,   127,
+      85,   128,    -1,   129,    -1,   128,    86,   129,    -1,   131,
+      -1,   130,    -1,    56,   144,    -1,    78,   129,    -1,   134,
+      -1,    96,   112,    -1,     7,    -1,     8,    -1,    67,    -1,
+     132,    -1,    52,    -1,    53,    -1,    51,    -1,    69,    -1,
+      73,    -1,    68,    -1,    70,    -1,    69,    -1,    73,    -1,
+      68,    -1,    76,   116,    77,    -1,    60,    -1,    54,   144,
+       4,   136,    31,    54,     4,    -1,    -1,   138,     4,   136,
+      -1,   140,    66,     4,   136,    -1,    21,    98,     4,   136,
+      -1,   137,     4,   136,    -1,   139,    24,    25,    66,   114,
+       4,    91,    31,    24,    -1,   139,    24,    26,    66,    76,
+     143,    77,     4,    91,    31,    24,    -1,   139,    24,    55,
+      66,    76,   143,    77,     4,    91,    31,    24,    -1,   139,
+      22,   144,   141,     4,    91,    31,    22,    -1,   139,    23,
+     144,   141,     4,    91,    31,    23,    -1,    -1,   140,    -1,
+      57,    59,    -1,    57,    -1,    58,    -1,   114,    -1,    76,
+     142,    77,    -1,   143,    -1,   143,    75,   142,    -1,   144,
+     114,    -1,    46,   144,   114,    -1,    47,   144,   114,    -1,
+      66,    -1,    24,    -1,     4,    -1,    71,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   144,   144,   147,   148,   150,   152,   153,   156,   157,
-     160,   161,   164,   167,   168,   169,   170,   171,   174,   175,
-     176,   178,   179,   180,   182,   185,   188,   189,   190,   191,
-     192,   193,   194,   195,   197,   198,   199,   200,   201,   203,
-     205,   209,   210,   213,   214,   217,   218,   221,   224,   225,
-     228,   229,   232,   233,   236,   238,   239,   242,   244,   247,
-     248,   251,   252,   255,   259,   260,   263,   264,   265,   269,
-     270,   273,   274,   276,   278,   281,   282,   285,   286,   289,
-     290,   293,   294,   297,   298,   301,   302,   305,   306,   309,
-     310,   311,   312,   313,   314,   315,   316,   319,   320,   323,
-     324,   325,   328,   329,   332,   333,   337,   338,   340,   344,
-     345,   348,   349,   350,   351,   354,   355,   358,   359,   360,
-     361,   362,   363,   364,   367,   368,   369,   370,   374,   375,
-     378,   381,   382,   383,   384,   387,   389,   391,   395,   397,
-     401,   402,   405,   406,   407,   410,   411,   414,   415,   418,
-     419,   420,   424,   425
+       0,   147,   147,   150,   151,   153,   155,   156,   159,   160,
+     163,   164,   167,   170,   171,   172,   173,   174,   177,   178,
+     179,   181,   182,   183,   185,   188,   191,   192,   193,   194,
+     195,   196,   197,   198,   200,   201,   202,   203,   204,   206,
+     208,   212,   213,   216,   217,   220,   221,   222,   225,   226,
+     229,   230,   233,   236,   237,   240,   241,   244,   245,   248,
+     250,   251,   254,   256,   259,   260,   263,   264,   267,   271,
+     272,   275,   276,   277,   281,   282,   285,   286,   288,   290,
+     293,   294,   297,   298,   301,   302,   305,   306,   309,   310,
+     313,   314,   317,   318,   321,   322,   323,   324,   325,   326,
+     327,   328,   331,   332,   335,   336,   337,   340,   341,   344,
+     345,   349,   350,   352,   356,   357,   360,   361,   362,   363,
+     366,   367,   370,   371,   372,   373,   374,   375,   376,   379,
+     380,   381,   382,   385,   386,   387,   390,   391,   394,   397,
+     398,   400,   402,   403,   406,   408,   410,   414,   416,   420,
+     421,   424,   425,   426,   429,   430,   433,   434,   437,   438,
+     439,   443,   444,   448,   449
 };
 #endif
 
@@ -663,23 +670,24 @@ static const char *const yytname[] =
   "tOPTION", "tEXPLICIT", "tSTOP", "tNOTHING", "tEMPTY", "tNULL", "tCLASS",
   "tSET", "tNEW", "tPUBLIC", "tPRIVATE", "tDEFAULT", "tME", "tERROR",
   "tNEXT", "tON", "tRESUME", "tGOTO", "tIdentifier", "tString", "tLong",
-  "tShort", "tDouble", "':'", "'='", "'0'", "'.'", "','", "'-'", "'('",
-  "')'", "'>'", "'<'", "'&'", "'+'", "'\\\\'", "'*'", "'/'", "'^'",
+  "tShort", "tDouble", "':'", "'='", "'0'", "'.'", "','", "'('", "')'",
+  "'-'", "'>'", "'<'", "'&'", "'+'", "'\\\\'", "'*'", "'/'", "'^'",
   "$accept", "Program", "OptionExplicit_opt", "SourceElements",
   "StatementsNl_opt", "StatementsNl", "StatementNl", "Statement",
-  "SimpleStatement", "MemberExpression", "DimDeclList", "ConstDeclList",
-  "ConstDecl", "ConstExpression", "DoType", "Step_opt", "IfStatement",
-  "EndIf_opt", "ElseIfs_opt", "ElseIfs", "ElseIf", "Else_opt",
-  "CaseClausules", "Arguments_opt", "ArgumentList_opt",
-  "EmptyBrackets_opt", "ExpressionList", "Expression", "EqvExpression",
-  "XorExpression", "OrExpression", "AndExpression", "NotExpression",
-  "EqualityExpression", "ConcatExpression", "AdditiveExpression",
-  "ModExpression", "IntdivExpression", "MultiplicativeExpression",
-  "ExpExpression", "UnaryExpression", "CallExpression",
-  "LiteralExpression", "NumericLiteralExpression", "PrimaryExpression",
-  "ClassDeclaration", "ClassBody", "PropertyDecl", "FunctionDecl",
-  "Storage_opt", "Storage", "ArgumentsDecl_opt", "ArgumentDeclList",
-  "ArgumentDecl", "Identifier", 0
+  "SimpleStatement", "MemberExpression", "DimDeclList", "DimDecl",
+  "DimList", "ConstDeclList", "ConstDecl", "ConstExpression", "DoType",
+  "Step_opt", "IfStatement", "EndIf_opt", "ElseIfs_opt", "ElseIfs",
+  "ElseIf", "Else_opt", "CaseClausules", "Arguments_opt",
+  "ArgumentList_opt", "EmptyBrackets_opt", "ExpressionList", "Expression",
+  "EqvExpression", "XorExpression", "OrExpression", "AndExpression",
+  "NotExpression", "EqualityExpression", "ConcatExpression",
+  "AdditiveExpression", "ModExpression", "IntdivExpression",
+  "MultiplicativeExpression", "ExpExpression", "UnaryExpression",
+  "CallExpression", "LiteralExpression", "NumericLiteralExpression",
+  "IntegerValue", "PrimaryExpression", "ClassDeclaration", "ClassBody",
+  "PropertyDecl", "FunctionDecl", "Storage_opt", "Storage",
+  "ArgumentsDecl_opt", "ArgumentDeclList", "ArgumentDecl", "Identifier",
+  "StSep", 0
 };
 #endif
 
@@ -695,7 +703,7 @@ static const yytype_uint16 yytoknum[] =
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,    58,    61,    48,    46,    44,    45,    40,    41,    62,
+     325,    58,    61,    48,    46,    44,    40,    41,    45,    62,
       60,    38,    43,    92,    42,    47,    94
 };
 # endif
@@ -707,18 +715,19 @@ static const yytype_uint8 yyr1[] =
       92,    92,    93,    94,    94,    94,    94,    94,    95,    95,
       95,    95,    95,    95,    95,    95,    95,    95,    95,    95,
       95,    95,    95,    95,    95,    95,    95,    95,    95,    95,
-      95,    96,    96,    97,    97,    98,    98,    99,   100,   100,
-     101,   101,   102,   102,   103,   103,   103,   104,   104,   105,
-     105,   106,   106,   107,   108,   108,   109,   109,   109,   110,
-     110,   111,   111,   112,   112,   113,   113,   114,   114,   115,
-     115,   116,   116,   117,   117,   118,   118,   119,   119,   120,
-     120,   120,   120,   120,   120,   120,   120,   121,   121,   122,
-     122,   122,   123,   123,   124,   124,   125,   125,   125,   126,
-     126,   127,   127,   127,   127,   128,   128,   129,   129,   129,
-     129,   129,   129,   129,   130,   130,   130,   130,   131,   131,
-     132,   133,   133,   133,   133,   134,   134,   134,   135,   135,
-     136,   136,   137,   137,   137,   138,   138,   139,   139,   140,
-     140,   140,   141,   141
+      95,    96,    96,    97,    97,    98,    98,    98,    99,    99,
+     100,   100,   101,   102,   102,   103,   103,   104,   104,   105,
+     105,   105,   106,   106,   107,   107,   108,   108,   109,   110,
+     110,   111,   111,   111,   112,   112,   113,   113,   114,   114,
+     115,   115,   116,   116,   117,   117,   118,   118,   119,   119,
+     120,   120,   121,   121,   122,   122,   122,   122,   122,   122,
+     122,   122,   123,   123,   124,   124,   124,   125,   125,   126,
+     126,   127,   127,   127,   128,   128,   129,   129,   129,   129,
+     130,   130,   131,   131,   131,   131,   131,   131,   131,   132,
+     132,   132,   132,   133,   133,   133,   134,   134,   135,   136,
+     136,   136,   136,   136,   137,   137,   137,   138,   138,   139,
+     139,   140,   140,   140,   141,   141,   142,   142,   143,   143,
+     143,   144,   144,   145,   145
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -728,18 +737,19 @@ static const yytype_uint8 yyr2[] =
        1,     2,     2,     1,     2,     1,     3,     2,     2,     3,
        4,     2,     1,     5,     6,     6,     4,     1,     2,     2,
        2,     2,     2,     5,     1,     4,     4,     2,    10,     8,
-       7,     1,     3,     1,     3,     1,     3,     3,     1,     2,
-       1,     1,     0,     2,     9,     4,     7,     0,     2,     0,
-       1,     1,     2,     5,     0,     3,     0,     4,     5,     1,
-       3,     1,     1,     0,     1,     1,     3,     1,     3,     1,
-       3,     1,     3,     1,     3,     1,     3,     1,     2,     1,
-       3,     3,     3,     3,     3,     3,     3,     1,     3,     1,
-       3,     3,     1,     3,     1,     3,     1,     3,     3,     1,
-       3,     1,     1,     2,     2,     1,     2,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     3,     1,
-       7,     0,     3,     4,     3,     9,    11,    11,     8,     8,
-       0,     1,     2,     1,     1,     1,     3,     1,     3,     1,
-       2,     2,     1,     1
+       7,     1,     3,     1,     3,     1,     4,     2,     1,     3,
+       1,     3,     3,     1,     2,     1,     1,     0,     2,     9,
+       4,     7,     0,     2,     0,     1,     1,     2,     5,     0,
+       3,     0,     4,     5,     1,     3,     1,     1,     0,     1,
+       1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
+       1,     3,     1,     2,     1,     3,     3,     3,     3,     3,
+       3,     3,     1,     3,     1,     3,     3,     1,     3,     1,
+       3,     1,     3,     3,     1,     3,     1,     1,     2,     2,
+       1,     2,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     3,     1,     7,     0,
+       3,     4,     4,     3,     9,    11,    11,     8,     8,     0,
+       1,     2,     1,     1,     1,     3,     1,     3,     2,     3,
+       3,     1,     1,     1,     1
 };
 
 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
@@ -747,279 +757,295 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       3,     0,     0,     5,     0,     1,   140,     4,     2,     0,
-       0,   153,     0,     0,     0,     0,     0,     0,     0,    34,
-       0,     0,   143,   144,   129,     0,   152,    13,     0,     6,
-       0,    15,    73,    22,     0,   115,     7,    27,     0,   141,
-      41,    73,    21,    43,    37,    45,     0,   117,   118,     0,
-     123,   121,   122,     0,   119,   126,   124,   127,   125,     0,
-      73,     0,    77,    79,    81,    83,    85,    87,    89,    97,
-      99,   102,   104,   106,   109,   112,   111,   120,    32,    30,
-      31,    28,    29,     0,   140,    50,    51,     0,     0,     0,
-       0,     0,    73,   142,     0,    14,     0,    12,    17,    74,
-       0,   116,    18,    71,    72,    75,     0,     0,     0,     0,
-      19,    69,     0,     0,     0,    88,   113,   114,   116,     0,
-     140,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       3,     0,     0,     5,     0,     1,   149,     4,     2,     0,
+       0,   162,     0,     0,     0,     0,     0,     0,     0,    34,
+       0,     0,   152,   153,   137,     0,   161,    13,     0,     6,
+       0,    15,    78,    22,     0,   120,     7,    27,     0,   150,
+      41,    78,    21,    43,    45,    37,    50,     0,   122,   123,
+       0,   128,   126,   127,     0,   124,   131,   129,   132,   130,
+       0,    78,     0,    82,    84,    86,    88,    90,    92,    94,
+     102,   104,   107,   109,   111,   114,   117,   116,   125,    32,
+      30,    31,    28,    29,     0,   149,    55,    56,     0,     0,
+       0,     0,     0,    78,   151,     0,    14,     0,    12,    17,
+      79,     0,   121,    18,    76,    77,    80,     0,     0,     0,
+       0,    19,    74,     0,    47,     0,     0,     0,    93,   118,
+     119,   121,     0,   149,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     140,     0,     9,    10,     0,     0,     0,     0,   140,   116,
-       0,     0,   128,    16,     0,     0,     0,     0,    42,    73,
-      73,    44,    46,     0,    47,    48,    78,     8,    55,    80,
-      82,    84,    86,    91,    96,    95,    94,    90,    92,    93,
-      98,   101,   100,   103,   105,   107,   108,   110,     0,    26,
-      11,   140,     0,     0,    66,     0,     0,     0,     0,   141,
-       0,    35,    36,    70,    20,    76,     0,   145,     0,     0,
-      49,    59,   140,    23,     0,     0,     0,     0,     0,     0,
-       0,   140,   140,     0,     0,    33,     0,     0,     0,   147,
-     149,   140,   140,     0,    64,    60,    61,    57,    25,    24,
-     140,    52,     0,     0,     0,     0,   134,   132,     0,     0,
-       0,   140,   150,   151,   146,     0,     0,     0,     0,     0,
-       0,    62,     0,    56,     0,     0,     0,   140,     8,    40,
-     130,    73,     0,     0,   133,   148,     0,     0,     0,   140,
-       0,    58,    39,    53,   140,    67,    66,     0,     0,     0,
-     138,   139,     8,    65,    54,     0,    68,   140,     0,     0,
-      63,    38,     0,     0,     0,     0,   140,   140,   135,     0,
-       0,     0,     0,   136,   137
+       0,     0,     0,   149,     0,     9,    10,     0,     0,     0,
+       0,   149,   121,     0,     0,   136,    16,     0,     0,     0,
+       0,    42,    78,    78,    44,   135,   133,   134,     0,    48,
+      51,     0,    52,    53,    83,     8,    60,    85,    87,    89,
+      91,    96,   101,   100,    99,    95,    97,    98,   103,   106,
+     105,   108,   110,   112,   113,   115,     0,    26,    11,   149,
+       0,     0,   163,   164,    71,     0,     0,     0,     0,     0,
+     150,     0,    35,    36,    75,    20,    81,     0,   154,     0,
+       0,    46,     0,    54,    64,   149,    23,     0,     0,     0,
+       0,     0,     0,     0,     0,   149,   149,     0,     0,    33,
+       0,     0,     0,   156,    78,   149,   149,    49,     0,    69,
+      65,    66,    62,    25,    24,   149,    57,     0,     0,     0,
+     149,     0,   143,   140,     0,     0,     0,   149,    78,    78,
+     155,     0,   158,     0,     0,     0,     0,     0,    67,     0,
+      61,     0,     0,     0,   149,     8,    40,   142,   138,    78,
+       0,     0,   141,   159,   160,   157,     0,     0,     0,   149,
+       0,    63,    39,    58,   149,    72,    71,     0,     0,     0,
+     147,   148,     8,    70,    59,     0,    73,   149,     0,     0,
+      68,    38,     0,     0,     0,     0,   149,   149,   144,     0,
+       0,     0,     0,   145,   146
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,     2,     3,     6,   141,   142,   143,    30,    31,    60,
-      42,    44,    45,   164,    87,   266,    33,   263,   234,   235,
-     236,   260,   219,   101,   102,   111,   154,   105,    62,    63,
-      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
-      74,    75,    76,    77,    35,    36,   195,   196,    37,    38,
-      39,   208,   228,   229,    40
+      -1,     2,     3,     6,   144,   145,   146,    30,    31,    61,
+      42,    43,   168,    45,    46,   172,    88,   283,    33,   280,
+     249,   250,   251,   277,   232,   102,   103,   112,   157,   106,
+      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,   169,    35,    36,   206,
+     207,    37,    38,    39,   219,   242,   243,    40,   204
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -184
+#define YYPACT_NINF -146
 static const yytype_int16 yypact[] =
 {
-     -21,   -15,    46,  -184,    51,  -184,   287,  -184,  -184,    82,
-      17,  -184,    17,   395,   147,   395,    20,     7,    14,  -184,
-      17,    82,    11,  -184,  -184,    34,  -184,   483,   395,  -184,
-      70,    29,   144,  -184,    56,  -184,  -184,  -184,    44,  -184,
-    -184,     0,  -184,    43,  -184,    80,    31,  -184,  -184,   395,
-    -184,  -184,  -184,    17,  -184,  -184,  -184,  -184,  -184,   425,
-       0,    21,    66,   168,   173,   178,  -184,    47,   122,    84,
-     186,   124,    62,   123,  -184,    56,  -184,  -184,  -184,  -184,
-    -184,  -184,  -184,    36,   531,  -184,  -184,   395,    17,   146,
-     395,   215,     0,  -184,   126,  -184,     6,  -184,   483,  -184,
-     395,   151,  -184,    61,  -184,    -3,    17,    17,    17,   395,
-     150,  -184,    17,    17,   105,  -184,  -184,  -184,  -184,   395,
-     335,   395,   395,   395,   395,   425,   425,   425,   425,   425,
-     425,   425,   425,   425,   425,   425,   425,   425,   425,   425,
-     579,   192,  -184,   483,    94,   190,   395,    95,    -1,   165,
-     177,   167,  -184,  -184,   163,    18,   395,   395,  -184,    13,
-      13,  -184,  -184,   162,  -184,  -184,    66,   483,   216,   168,
-     173,   178,  -184,   122,   122,   122,   122,   122,   122,   122,
-      84,   186,   186,   124,    62,   123,   123,  -184,   209,     9,
-    -184,   531,   395,     8,   201,   218,   243,   246,   121,   185,
-     395,  -184,  -184,  -184,   251,  -184,     5,  -184,   256,   262,
-    -184,   237,   723,  -184,   395,   231,   117,   395,   358,   238,
-     220,    -1,    -1,   139,   266,   251,    17,    17,   194,   202,
-    -184,   627,   627,   395,   247,  -184,   237,   248,   251,  -184,
-     675,     4,   277,   278,   239,   281,  -184,  -184,   221,   223,
-     228,    -1,  -184,  -184,  -184,     5,   264,   265,    28,   293,
-     267,  -184,   271,  -184,   250,   395,   306,   723,   483,  -184,
-    -184,   307,   240,   241,  -184,  -184,   294,   296,   318,   627,
-     299,  -184,  -184,   251,   675,  -184,   201,   320,     5,     5,
-    -184,  -184,   483,  -184,  -184,   268,  -184,   627,   254,   255,
-    -184,  -184,   297,   325,   330,   311,   627,   627,  -184,   305,
-     309,   314,   319,  -184,  -184
+     -13,     2,    57,  -146,    39,  -146,   307,  -146,  -146,     1,
+      -2,  -146,    -2,   468,   184,   468,    20,   -11,    15,  -146,
+      -2,     1,    40,  -146,  -146,    62,  -146,   557,   468,  -146,
+      59,    84,   388,  -146,    94,  -146,  -146,  -146,   109,  -146,
+    -146,     4,  -146,   101,     8,  -146,   106,   111,  -146,  -146,
+     468,  -146,  -146,  -146,    -2,  -146,  -146,  -146,  -146,  -146,
+     498,     4,    27,   175,   182,   188,   191,  -146,    29,   124,
+      38,   193,   130,    68,   129,  -146,    94,  -146,  -146,  -146,
+    -146,  -146,  -146,  -146,    24,   598,  -146,  -146,   468,    -2,
+     145,   468,   214,     4,  -146,    95,  -146,     5,  -146,   557,
+    -146,   468,   152,  -146,    64,  -146,    19,    -2,    -2,    -2,
+     468,   161,  -146,    -2,  -146,    45,    -2,    97,  -146,  -146,
+    -146,  -146,   468,   348,   468,   468,   468,   468,   498,   498,
+     498,   498,   498,   498,   498,   498,   498,   498,   498,   498,
+     498,   498,   498,   651,   199,  -146,   557,    48,   194,   468,
+      16,   120,   166,   181,   172,  -146,  -146,   169,    35,   468,
+     468,  -146,    10,    10,  -146,  -146,  -146,  -146,   170,   173,
+    -146,   117,  -146,  -146,   175,   557,   221,   182,   188,   191,
+    -146,   124,   124,   124,   124,   124,   124,   124,    38,   193,
+     193,   130,    68,   129,   129,  -146,   217,    73,  -146,   598,
+     468,   121,  -146,  -146,   208,    -2,   223,   252,   255,   150,
+     195,   468,  -146,  -146,  -146,   246,  -146,    26,  -146,   258,
+     259,  -146,    45,  -146,   234,   786,  -146,   468,   228,    61,
+     468,   418,   236,   266,   218,   120,   120,    14,   267,   246,
+      -2,    -2,   196,   200,   268,   692,   692,  -146,   468,   247,
+    -146,   234,   253,   246,  -146,   733,    12,     7,     7,   233,
+     120,   279,  -146,  -146,   220,   224,   225,   120,   268,   268,
+    -146,    26,  -146,   256,   261,    34,   290,   265,  -146,   269,
+    -146,   237,   468,   297,   786,   557,  -146,  -146,  -146,   268,
+     226,   229,  -146,  -146,  -146,  -146,   282,   284,   305,   692,
+     286,  -146,  -146,   246,   733,  -146,   208,   308,    26,    26,
+    -146,  -146,   557,  -146,  -146,   254,  -146,   692,   238,   240,
+    -146,  -146,   287,   315,   320,   306,   692,   692,  -146,   298,
+     301,   309,   312,  -146,  -146
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -184,  -184,  -184,  -184,  -130,  -142,   340,   -23,  -184,    -6,
-     236,   257,  -184,  -184,   160,  -184,  -184,  -184,  -184,   115,
-    -184,  -184,    68,   -16,  -184,   -19,   -25,    92,   233,   252,
-     253,   249,   -33,  -184,   128,   229,    65,   225,   242,    64,
-     -50,    -4,   263,   213,  -184,  -184,  -183,  -184,  -140,  -136,
-    -134,   224,   125,   -73,    16
+    -146,  -146,  -146,  -146,  -101,  -137,   332,   -23,  -146,    -6,
+     231,   134,   123,   232,  -146,  -146,   153,  -146,  -146,  -146,
+    -146,    91,  -146,  -146,    41,    -5,  -146,     0,   -31,    55,
+     227,   230,   235,   245,   -42,  -146,    99,   239,    43,   215,
+     216,    51,   -53,    -4,   241,   185,  -146,  -146,  -146,   -78,
+    -146,  -145,  -139,  -133,   203,    88,  -112,    17,   -48
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -141
+#define YYTABLE_NINF -150
 static const yytype_int16 yytable[] =
 {
-      32,   190,    34,    41,    95,    34,    99,   104,   197,   117,
-     188,   119,   198,   103,   199,    92,   115,    34,   119,    99,
-     119,    32,   119,    34,    84,   110,    43,     1,    46,    11,
-    -131,    11,   119,    89,     4,   119,    91,   211,   246,   247,
-     140,    11,   119,    85,   118,   265,     5,    86,   217,    88,
-     119,   226,   227,   120,    85,     7,    22,    23,    86,    90,
-     278,   215,   125,   126,   127,   128,   107,   108,   274,   116,
-      93,    26,   157,    26,    97,   153,   149,   109,    32,   121,
-      34,   197,   197,    26,   152,   198,   198,   199,   199,   187,
-     206,   172,    32,   157,    34,    94,   152,   168,   191,   194,
-      98,   256,   257,   114,   145,    61,    11,    83,   119,   119,
-     264,   197,    47,    48,    32,   198,    34,   199,   112,   129,
-      96,   240,   158,   159,   160,   285,   130,   131,    43,    46,
-     106,   119,   205,   -69,    32,   -69,    34,    32,   286,    34,
-     207,   207,    24,   107,   108,   223,   137,   138,    26,   293,
-      99,    47,    48,    49,   295,   113,    50,    51,    52,    28,
-     133,    32,   300,    34,   248,   249,   134,   302,    11,    78,
-      79,    80,    54,    55,    56,    57,   309,   310,    58,   144,
-     122,   163,   147,    81,   123,    32,    82,    34,   124,   237,
-     150,   151,   155,   243,   250,    50,    51,    52,   181,   182,
-      53,   185,   186,   132,    24,   135,    32,   136,    34,   139,
-      26,    54,    55,    56,    57,   298,   299,    58,   146,   148,
-      59,   100,   230,   156,  -116,    32,    32,    34,    34,   189,
-      55,    56,    57,   192,    32,    58,    34,   200,   193,   201,
-     202,   203,   252,   253,   213,   212,   218,   221,   204,   220,
-     222,   224,   287,   173,   174,   175,   176,   177,   178,   179,
-     231,    32,    32,    34,    34,   119,   232,   233,   239,   244,
-     251,   230,   254,    32,   245,    34,   259,   255,    32,   262,
-      34,   267,   268,   269,   216,   270,    32,   271,    34,   272,
-       8,    32,   225,    34,   273,   276,   277,   279,   280,   281,
-      32,    32,    34,    34,   230,   230,   238,     9,    10,   241,
-     284,    11,   282,    99,    12,    13,   290,   288,   289,   291,
-      14,    15,   292,    16,   297,   258,    17,   294,   305,   306,
-     301,    18,   303,   304,   307,   308,   311,    19,   313,   167,
-     312,    20,    21,   314,    22,    23,    29,    24,   161,   214,
-      25,   261,   166,    26,   296,     9,    10,   283,    27,    11,
-     183,   180,    12,    13,    28,    47,    48,    49,    14,    15,
-     162,    16,   171,   169,    17,   170,   210,   165,   184,    18,
-     275,     0,    11,     0,   209,    19,     0,   242,     0,     0,
-      21,     0,    22,    23,     0,    24,     0,     0,    25,     0,
-       0,    26,    47,    48,    49,     0,    27,     0,     0,    50,
-      51,    52,    28,     0,    53,     0,     0,     0,    24,    11,
-       0,     0,     0,     0,    26,    54,    55,    56,    57,     0,
-       0,    58,    47,    48,    59,    28,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    50,    51,    52,    11,
-       0,    53,     0,     0,     0,    24,     0,     0,     0,     0,
-       0,    26,    54,    55,    56,    57,     0,     0,    58,     0,
-       0,    59,    28,     0,     0,     0,    50,    51,    52,     0,
-       0,    53,     0,     0,     0,    24,     0,     0,     0,     0,
-       0,    26,    54,    55,    56,    57,     0,     0,    58,     0,
-       0,    59,    28,     9,    10,  -140,  -140,    11,     0,     0,
-      12,    13,     0,     0,     0,     0,    14,    15,     0,    16,
-       0,     0,    17,     0,     0,     0,     0,    18,     0,     0,
-       0,     0,     0,    19,     0,     0,     0,     0,    21,     0,
-      22,    23,     0,    24,     0,     0,    25,     0,     0,    26,
-       0,     9,    10,     0,    27,    11,     0,     0,    12,    13,
-      28,     0,     0,     0,    14,    15,     0,    16,    -8,     0,
-      17,     0,     0,     0,     0,    18,     0,     0,     0,     0,
-       0,    19,     0,     0,     0,     0,    21,     0,    22,    23,
-       0,    24,     0,     0,    25,     0,     0,    26,     0,     9,
-      10,     0,    27,    11,     0,     0,    12,    13,    28,     0,
-       0,     0,    14,    15,    -8,    16,     0,     0,    17,     0,
-       0,     0,     0,    18,     0,     0,     0,     0,     0,    19,
-       0,     0,     0,     0,    21,     0,    22,    23,     0,    24,
-       0,     0,    25,     0,     0,    26,     0,     9,    10,     0,
-      27,    11,     0,     0,    12,    13,    28,     0,    -8,     0,
+      32,   105,    34,    41,    96,    34,   208,   120,   118,   198,
+     100,   202,   209,    11,   114,    93,   100,    34,   210,   122,
+     202,    32,    11,    34,    85,    11,   122,    44,   143,    47,
+     122,    89,   104,   122,    90,     1,   111,    92,   122,   264,
+     265,   122,   196,     7,   128,   129,   130,   131,   122,   122,
+      11,     4,   199,   282,    86,    26,   121,     5,    87,   123,
+      91,    24,   122,    98,    26,   255,   298,    26,    62,   266,
+      84,   119,   240,   241,   224,   122,   156,    28,   203,    32,
+     110,    34,   155,    97,   115,   180,   217,   203,   152,   195,
+     208,   208,    26,    32,   160,    34,   209,   209,   228,    94,
+     176,   132,   210,   210,    48,    49,   148,    86,   133,   134,
+     160,    87,   155,   165,   166,   208,   136,    32,   167,    34,
+     137,   209,   208,    95,   161,   162,   163,   210,   209,   216,
+      44,   108,   109,    47,   210,   122,   -74,    32,   -74,    34,
+      32,   205,    34,   147,   273,   274,   150,   305,    51,    52,
+      53,  -139,   140,   141,   281,    99,   158,   262,   263,   153,
+     154,   230,   218,   218,    55,    56,    57,    58,   107,    32,
+      59,    34,   108,   109,   237,   171,   113,    22,    23,   189,
+     190,   116,   287,   117,   306,    56,    57,    58,   124,   292,
+      59,   193,   194,    32,   125,    34,   318,   319,   313,   126,
+     258,   127,   252,   315,   201,   135,    79,    80,    81,   284,
+     285,   320,   138,   139,   215,   142,   322,   149,   151,    32,
+      82,    34,    44,    83,   159,   329,   330,   181,   182,   183,
+     184,   185,   186,   187,   244,  -121,   197,   200,   211,    32,
+      32,    34,    34,   212,   272,   213,   214,   221,   222,    32,
+     225,    34,   226,   231,   234,   229,   235,   268,   269,   236,
+     122,   238,   245,   246,   248,   254,   239,   259,   293,   294,
+     260,   267,   261,   270,   100,   271,   276,   286,    32,    32,
+      34,    34,   253,   288,   279,   256,   289,   296,   244,   307,
+     290,   291,   297,    32,   299,    34,   300,   301,    32,   302,
+      34,   304,   308,   275,   310,   309,    32,   311,    34,   312,
+       8,    32,   317,    34,   314,   323,   321,   324,   325,   326,
+      32,    32,    34,    34,   327,   244,   244,     9,    10,   331,
+     328,    11,   332,   333,    12,    13,   334,   303,    29,   233,
+      14,    15,   278,    16,   164,   247,    17,   316,   170,   174,
+     227,    18,   175,   191,   177,   192,   223,    19,   173,   295,
+     178,    20,    21,     0,    22,    23,   220,    24,     9,    10,
+      25,   179,    11,    26,   188,    12,    13,     0,    27,     0,
+       0,    14,    15,    28,    16,     0,     0,    17,     0,     0,
+       0,     0,    18,     0,   100,    48,    49,    50,    19,     0,
+       0,     0,     0,    21,     0,    22,    23,     0,    24,     0,
+       0,    25,    11,     0,    26,     0,     0,     0,     0,    27,
+       0,     0,     0,     0,    28,    48,    49,    50,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    51,
+      52,    53,    11,     0,    54,     0,     0,   257,    24,     0,
+       0,     0,     0,     0,    26,    55,    56,    57,    58,     0,
+       0,    59,     0,     0,   101,     0,    60,     0,     0,    51,
+      52,    53,     0,     0,    54,    48,    49,    50,    24,     0,
+       0,     0,     0,     0,    26,    55,    56,    57,    58,     0,
+       0,    59,    11,     0,    28,     0,    60,     0,     0,     0,
+       0,     0,     0,     0,     0,    48,    49,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    51,
+      52,    53,    11,     0,    54,     0,     0,     0,    24,     0,
+       0,     0,     0,     0,    26,    55,    56,    57,    58,     0,
+       0,    59,     0,     0,    28,     0,    60,     0,     0,    51,
+      52,    53,     0,     0,    54,     0,     0,     0,    24,     0,
+       0,     0,     0,     0,    26,    55,    56,    57,    58,     0,
+       0,    59,     0,     0,    28,     0,    60,     9,    10,  -149,
+    -149,    11,     0,     0,    12,    13,     0,     0,     0,     0,
       14,    15,     0,    16,     0,     0,    17,     0,     0,     0,
        0,    18,     0,     0,     0,     0,     0,    19,     0,     0,
-       0,     0,    21,     0,    22,    23,     0,    24,     0,     0,
-      25,     0,     0,    26,     0,     9,    10,     0,    27,    11,
-       0,     0,    12,    13,    28,     0,     0,     0,    14,    15,
-       0,    16,     0,     0,    17,     0,     0,     0,     0,    18,
-       0,     0,     0,     0,     0,    19,     0,     0,     0,     0,
-      21,     0,    22,    23,     0,    24,     0,    -8,    25,     0,
-       0,    26,     0,     9,    10,     0,    27,    11,     0,     0,
-      12,    13,    28,     0,     0,     0,    14,    15,     0,    16,
+       0,     0,    21,     0,    22,    23,     0,    24,     9,    10,
+      25,     0,    11,    26,     0,    12,    13,     0,    27,     0,
+       0,    14,    15,    28,    16,    -8,     0,    17,     0,     0,
+       0,     0,    18,     0,     0,     0,     0,     0,    19,     0,
+       0,     0,     0,    21,     0,    22,    23,     0,    24,     0,
+       0,    25,     0,     0,    26,     0,     0,     0,     0,    27,
+       0,     9,    10,     0,    28,    11,     0,     0,    12,    13,
+       0,     0,     0,     0,    14,    15,    -8,    16,     0,     0,
+      17,     0,     0,     0,     0,    18,     0,     0,     0,     0,
+       0,    19,     0,     0,     0,     0,    21,     0,    22,    23,
+       0,    24,     9,    10,    25,     0,    11,    26,     0,    12,
+      13,     0,    27,    -8,     0,    14,    15,    28,    16,     0,
+       0,    17,     0,     0,     0,     0,    18,     0,     0,     0,
+       0,     0,    19,     0,     0,     0,     0,    21,     0,    22,
+      23,     0,    24,     9,    10,    25,     0,    11,    26,     0,
+      12,    13,     0,    27,     0,     0,    14,    15,    28,    16,
        0,     0,    17,     0,     0,     0,     0,    18,     0,     0,
        0,     0,     0,    19,     0,     0,     0,     0,    21,     0,
-      22,    23,     0,    24,     0,     0,    25,     0,     0,    26,
-       0,     0,     0,     0,    27,     0,     0,     0,     0,     0,
-      28
+      22,    23,     0,    24,     0,    -8,    25,     0,     0,    26,
+       0,     0,     0,     0,    27,     0,     9,    10,     0,    28,
+      11,     0,     0,    12,    13,     0,     0,     0,     0,    14,
+      15,     0,    16,     0,     0,    17,     0,     0,     0,     0,
+      18,     0,     0,     0,     0,     0,    19,     0,     0,     0,
+       0,    21,     0,    22,    23,     0,    24,     0,     0,    25,
+       0,     0,    26,     0,     0,     0,     0,    27,     0,     0,
+       0,     0,    28
 };
 
 #define yypact_value_is_default(yystate) \
-  ((yystate) == (-184))
+  ((yystate) == (-146))
 
 #define yytable_value_is_error(yytable_value) \
   YYID (0)
 
 static const yytype_int16 yycheck[] =
 {
-       6,   143,     6,     9,    27,     9,     6,    32,   148,    59,
-     140,    14,   148,    32,   148,    21,    49,    21,    14,     6,
-      14,    27,    14,    27,     4,    41,    10,    48,    12,    24,
-      31,    24,    14,    17,    49,    14,    20,   167,   221,   222,
-       4,    24,    14,    34,    60,    41,     0,    38,    40,    42,
-      14,    46,    47,    32,    34,     4,    57,    58,    38,    45,
-      32,   191,    15,    16,    17,    18,    22,    23,   251,    53,
-      59,    66,    75,    66,     4,    98,    92,    77,    84,    13,
-      84,   221,   222,    66,    78,   221,   222,   221,   222,   139,
-      77,   124,    98,    75,    98,    61,    78,   120,     4,     4,
-      71,   231,   232,    72,    88,    13,    24,    15,    14,    14,
-     240,   251,     7,     8,   120,   251,   120,   251,    75,    72,
-      28,     4,   106,   107,   108,   267,    79,    80,   112,   113,
-      74,    14,   157,    72,   140,    74,   140,   143,   268,   143,
-     159,   160,    60,    22,    23,    24,    84,    85,    66,   279,
-       6,     7,     8,     9,   284,    75,    51,    52,    53,    77,
-      76,   167,   292,   167,    25,    26,    82,   297,    24,    22,
-      23,    24,    67,    68,    69,    70,   306,   307,    73,    87,
-      12,    76,    90,    36,    11,   191,    39,   191,    10,   212,
-      64,    65,   100,   218,    55,    51,    52,    53,   133,   134,
-      56,   137,   138,    81,    60,    19,   212,    83,   212,    86,
-      66,    67,    68,    69,    70,   288,   289,    73,    72,     4,
-      76,    77,   206,    72,    74,   231,   232,   231,   232,    37,
-      68,    69,    70,    43,   240,    73,   240,    72,   146,    62,
-      73,    78,   226,   227,    35,    29,    45,     4,   156,    31,
-       4,    66,   271,   125,   126,   127,   128,   129,   130,   131,
-       4,   267,   268,   267,   268,    14,     4,    30,    37,    31,
-       4,   255,    78,   279,    54,   279,    29,    75,   284,    31,
-     284,     4,     4,    44,   192,     4,   292,    66,   292,    66,
-       3,   297,   200,   297,    66,    31,    31,     4,    31,    28,
-     306,   307,   306,   307,   288,   289,   214,    20,    21,   217,
-       4,    24,    62,     6,    27,    28,    22,    77,    77,    23,
-      33,    34,     4,    36,     4,   233,    39,    28,    31,     4,
-      62,    44,    78,    78,     4,    24,    31,    50,    24,     4,
-      31,    54,    55,    24,    57,    58,     6,    60,   112,   189,
-      63,   236,   119,    66,   286,    20,    21,   265,    71,    24,
-     135,   132,    27,    28,    77,     7,     8,     9,    33,    34,
-     113,    36,   123,   121,    39,   122,   163,   114,   136,    44,
-     255,    -1,    24,    -1,   160,    50,    -1,    29,    -1,    -1,
-      55,    -1,    57,    58,    -1,    60,    -1,    -1,    63,    -1,
-      -1,    66,     7,     8,     9,    -1,    71,    -1,    -1,    51,
-      52,    53,    77,    -1,    56,    -1,    -1,    -1,    60,    24,
+       6,    32,     6,     9,    27,     9,   151,    60,    50,   146,
+       6,     4,   151,    24,     6,    21,     6,    21,   151,    14,
+       4,    27,    24,    27,     4,    24,    14,    10,     4,    12,
+      14,    42,    32,    14,    17,    48,    41,    20,    14,    25,
+      26,    14,   143,     4,    15,    16,    17,    18,    14,    14,
+      24,    49,     4,    41,    34,    66,    61,     0,    38,    32,
+      45,    60,    14,     4,    66,     4,    32,    66,    13,    55,
+      15,    54,    46,    47,   175,    14,    99,    76,    71,    85,
+      76,    85,    77,    28,    76,   127,    76,    71,    93,   142,
+     235,   236,    66,    99,    75,    99,   235,   236,   199,    59,
+     123,    72,   235,   236,     7,     8,    89,    34,    79,    80,
+      75,    38,    77,    68,    69,   260,    78,   123,    73,   123,
+      82,   260,   267,    61,   107,   108,   109,   260,   267,   160,
+     113,    22,    23,   116,   267,    14,    72,   143,    74,   143,
+     146,    21,   146,    88,   245,   246,    91,   284,    51,    52,
+      53,    31,    84,    85,   255,    71,   101,   235,   236,    64,
+      65,    40,   162,   163,    67,    68,    69,    70,    74,   175,
+      73,   175,    22,    23,    24,    78,    75,    57,    58,   136,
+     137,    75,   260,    72,   285,    68,    69,    70,    13,   267,
+      73,   140,   141,   199,    12,   199,   308,   309,   299,    11,
+     231,    10,   225,   304,   149,    81,    22,    23,    24,   257,
+     258,   312,    19,    83,   159,    86,   317,    72,     4,   225,
+      36,   225,   205,    39,    72,   326,   327,   128,   129,   130,
+     131,   132,   133,   134,   217,    74,    37,    43,    72,   245,
+     246,   245,   246,    62,   244,    73,    77,    77,    75,   255,
+      29,   255,    35,    45,    31,   200,     4,   240,   241,     4,
+      14,    66,     4,     4,    30,    37,   211,    31,   268,   269,
+       4,     4,    54,    77,     6,    75,    29,    44,   284,   285,
+     284,   285,   227,     4,    31,   230,    66,    31,   271,   289,
+      66,    66,    31,   299,     4,   299,    31,    28,   304,    62,
+     304,     4,    76,   248,    22,    76,   312,    23,   312,     4,
+       3,   317,     4,   317,    28,    77,    62,    77,    31,     4,
+     326,   327,   326,   327,     4,   308,   309,    20,    21,    31,
+      24,    24,    31,    24,    27,    28,    24,   282,     6,   205,
+      33,    34,   251,    36,   113,   222,    39,   306,   116,   122,
+     197,    44,     4,   138,   124,   139,   171,    50,   117,   271,
+     125,    54,    55,    -1,    57,    58,   163,    60,    20,    21,
+      63,   126,    24,    66,   135,    27,    28,    -1,    71,    -1,
+      -1,    33,    34,    76,    36,    -1,    -1,    39,    -1,    -1,
+      -1,    -1,    44,    -1,     6,     7,     8,     9,    50,    -1,
+      -1,    -1,    -1,    55,    -1,    57,    58,    -1,    60,    -1,
+      -1,    63,    24,    -1,    66,    -1,    -1,    -1,    -1,    71,
+      -1,    -1,    -1,    -1,    76,     7,     8,     9,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,
+      52,    53,    24,    -1,    56,    -1,    -1,    29,    60,    -1,
       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    -1,
-      -1,    73,     7,     8,    76,    77,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    51,    52,    53,    24,
-      -1,    56,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      -1,    66,    67,    68,    69,    70,    -1,    -1,    73,    -1,
-      -1,    76,    77,    -1,    -1,    -1,    51,    52,    53,    -1,
-      -1,    56,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      -1,    66,    67,    68,    69,    70,    -1,    -1,    73,    -1,
-      -1,    76,    77,    20,    21,    22,    23,    24,    -1,    -1,
-      27,    28,    -1,    -1,    -1,    -1,    33,    34,    -1,    36,
-      -1,    -1,    39,    -1,    -1,    -1,    -1,    44,    -1,    -1,
-      -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    55,    -1,
-      57,    58,    -1,    60,    -1,    -1,    63,    -1,    -1,    66,
-      -1,    20,    21,    -1,    71,    24,    -1,    -1,    27,    28,
-      77,    -1,    -1,    -1,    33,    34,    -1,    36,    37,    -1,
-      39,    -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,
-      -1,    50,    -1,    -1,    -1,    -1,    55,    -1,    57,    58,
-      -1,    60,    -1,    -1,    63,    -1,    -1,    66,    -1,    20,
-      21,    -1,    71,    24,    -1,    -1,    27,    28,    77,    -1,
-      -1,    -1,    33,    34,    35,    36,    -1,    -1,    39,    -1,
-      -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,    50,
-      -1,    -1,    -1,    -1,    55,    -1,    57,    58,    -1,    60,
-      -1,    -1,    63,    -1,    -1,    66,    -1,    20,    21,    -1,
-      71,    24,    -1,    -1,    27,    28,    77,    -1,    31,    -1,
+      -1,    73,    -1,    -1,    76,    -1,    78,    -1,    -1,    51,
+      52,    53,    -1,    -1,    56,     7,     8,     9,    60,    -1,
+      -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    -1,
+      -1,    73,    24,    -1,    76,    -1,    78,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,     7,     8,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,
+      52,    53,    24,    -1,    56,    -1,    -1,    -1,    60,    -1,
+      -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    -1,
+      -1,    73,    -1,    -1,    76,    -1,    78,    -1,    -1,    51,
+      52,    53,    -1,    -1,    56,    -1,    -1,    -1,    60,    -1,
+      -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    -1,
+      -1,    73,    -1,    -1,    76,    -1,    78,    20,    21,    22,
+      23,    24,    -1,    -1,    27,    28,    -1,    -1,    -1,    -1,
       33,    34,    -1,    36,    -1,    -1,    39,    -1,    -1,    -1,
       -1,    44,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,
-      -1,    -1,    55,    -1,    57,    58,    -1,    60,    -1,    -1,
-      63,    -1,    -1,    66,    -1,    20,    21,    -1,    71,    24,
-      -1,    -1,    27,    28,    77,    -1,    -1,    -1,    33,    34,
-      -1,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    44,
-      -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
-      55,    -1,    57,    58,    -1,    60,    -1,    62,    63,    -1,
-      -1,    66,    -1,    20,    21,    -1,    71,    24,    -1,    -1,
-      27,    28,    77,    -1,    -1,    -1,    33,    34,    -1,    36,
+      -1,    -1,    55,    -1,    57,    58,    -1,    60,    20,    21,
+      63,    -1,    24,    66,    -1,    27,    28,    -1,    71,    -1,
+      -1,    33,    34,    76,    36,    37,    -1,    39,    -1,    -1,
+      -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,    50,    -1,
+      -1,    -1,    -1,    55,    -1,    57,    58,    -1,    60,    -1,
+      -1,    63,    -1,    -1,    66,    -1,    -1,    -1,    -1,    71,
+      -1,    20,    21,    -1,    76,    24,    -1,    -1,    27,    28,
+      -1,    -1,    -1,    -1,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,
+      -1,    50,    -1,    -1,    -1,    -1,    55,    -1,    57,    58,
+      -1,    60,    20,    21,    63,    -1,    24,    66,    -1,    27,
+      28,    -1,    71,    31,    -1,    33,    34,    76,    36,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,
+      -1,    -1,    50,    -1,    -1,    -1,    -1,    55,    -1,    57,
+      58,    -1,    60,    20,    21,    63,    -1,    24,    66,    -1,
+      27,    28,    -1,    71,    -1,    -1,    33,    34,    76,    36,
       -1,    -1,    39,    -1,    -1,    -1,    -1,    44,    -1,    -1,
       -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    55,    -1,
-      57,    58,    -1,    60,    -1,    -1,    63,    -1,    -1,    66,
-      -1,    -1,    -1,    -1,    71,    -1,    -1,    -1,    -1,    -1,
-      77
+      57,    58,    -1,    60,    -1,    62,    63,    -1,    -1,    66,
+      -1,    -1,    -1,    -1,    71,    -1,    20,    21,    -1,    76,
+      24,    -1,    -1,    27,    28,    -1,    -1,    -1,    -1,    33,
+      34,    -1,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
+      44,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,
+      -1,    55,    -1,    57,    58,    -1,    60,    -1,    -1,    63,
+      -1,    -1,    66,    -1,    -1,    -1,    -1,    71,    -1,    -1,
+      -1,    -1,    76
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1028,35 +1054,37 @@ static const yytype_uint8 yystos[] =
 {
        0,    48,    88,    89,    49,     0,    90,     4,     3,    20,
       21,    24,    27,    28,    33,    34,    36,    39,    44,    50,
-      54,    55,    57,    58,    60,    63,    66,    71,    77,    93,
-      94,    95,    96,   103,   128,   131,   132,   135,   136,   137,
-     141,    96,    97,   141,    98,    99,   141,     7,     8,     9,
-      51,    52,    53,    56,    67,    68,    69,    70,    73,    76,
-      96,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,    22,    23,
-      24,    36,    39,   114,     4,    34,    38,   101,    42,   141,
-      45,   141,    96,    59,    61,    94,   114,     4,    71,     6,
-      77,   110,   111,   112,   113,   114,    74,    22,    23,    77,
-     110,   112,    75,    75,    72,   119,   141,   127,   110,    14,
-      32,    13,    12,    11,    10,    15,    16,    17,    18,    72,
-      79,    80,    81,    76,    82,    19,    83,    84,    85,    86,
-       4,    91,    92,    93,   114,   141,    72,   114,     4,   110,
-      64,    65,    78,    94,   113,   114,    72,    75,   141,   141,
-     141,    97,    98,    76,   100,   129,   115,     4,    94,   116,
-     117,   118,   119,   121,   121,   121,   121,   121,   121,   121,
-     122,   123,   123,   124,   125,   126,   126,   127,    91,    37,
-      92,     4,    43,   114,     4,   133,   134,   135,   136,   137,
-      72,    62,    73,    78,   114,   113,    77,   112,   138,   138,
-     130,    91,    29,    35,   101,    91,   114,    40,    45,   109,
-      31,     4,     4,    24,    66,   114,    46,    47,   139,   140,
-     141,     4,     4,    30,   105,   106,   107,    94,   114,    37,
-       4,   114,    29,   113,    31,    54,   133,   133,    25,    26,
-      55,     4,   141,   141,    78,    75,    91,    91,   114,    29,
-     108,   106,    31,   104,    91,    41,   102,     4,     4,    44,
-       4,    66,    66,    66,   133,   139,    31,    31,    32,     4,
-      31,    28,    62,   114,     4,    92,    91,   112,    77,    77,
-      22,    23,     4,    91,    28,    91,   109,     4,   140,   140,
-      91,    62,    91,    78,    78,    31,     4,     4,    24,    91,
+      54,    55,    57,    58,    60,    63,    66,    71,    76,    93,
+      94,    95,    96,   105,   130,   134,   135,   138,   139,   140,
+     144,    96,    97,    98,   144,   100,   101,   144,     7,     8,
+       9,    51,    52,    53,    56,    67,    68,    69,    70,    73,
+      78,    96,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,    22,
+      23,    24,    36,    39,   116,     4,    34,    38,   103,    42,
+     144,    45,   144,    96,    59,    61,    94,   116,     4,    71,
+       6,    76,   112,   113,   114,   115,   116,    74,    22,    23,
+      76,   112,   114,    75,     6,    76,    75,    72,   121,   144,
+     129,   112,    14,    32,    13,    12,    11,    10,    15,    16,
+      17,    18,    72,    79,    80,    81,    78,    82,    19,    83,
+      84,    85,    86,     4,    91,    92,    93,   116,   144,    72,
+     116,     4,   112,    64,    65,    77,    94,   115,   116,    72,
+      75,   144,   144,   144,    97,    68,    69,    73,    99,   133,
+     100,    78,   102,   131,   117,     4,    94,   118,   119,   120,
+     121,   123,   123,   123,   123,   123,   123,   123,   124,   125,
+     125,   126,   127,   128,   128,   129,    91,    37,    92,     4,
+      43,   116,     4,    71,   145,    21,   136,   137,   138,   139,
+     140,    72,    62,    73,    77,   116,   115,    76,   114,   141,
+     141,    77,    75,   132,    91,    29,    35,   103,    91,   116,
+      40,    45,   111,    98,    31,     4,     4,    24,    66,   116,
+      46,    47,   142,   143,   144,     4,     4,    99,    30,   107,
+     108,   109,    94,   116,    37,     4,   116,    29,   115,    31,
+       4,    54,   136,   136,    25,    26,    55,     4,   144,   144,
+      77,    75,   114,    91,    91,   116,    29,   110,   108,    31,
+     106,    91,    41,   104,   145,   145,    44,   136,     4,    66,
+      66,    66,   136,   114,   114,   142,    31,    31,    32,     4,
+      31,    28,    62,   116,     4,    92,    91,   114,    76,    76,
+      22,    23,     4,    91,    28,    91,   111,     4,   143,   143,
+      91,    62,    91,    77,    77,    31,     4,     4,    24,    91,
       91,    31,    31,    24,    24
 };
 
@@ -1899,154 +1927,154 @@ yyreduce:
         case 2:
 
 /* Line 1806 of yacc.c  */
-#line 144 "parser.y"
+#line 147 "parser.y"
     { parse_complete(ctx, (yyvsp[(1) - (3)].bool)); }
     break;
 
   case 3:
 
 /* Line 1806 of yacc.c  */
-#line 147 "parser.y"
+#line 150 "parser.y"
     { (yyval.bool) = FALSE; }
     break;
 
   case 4:
 
 /* Line 1806 of yacc.c  */
-#line 148 "parser.y"
+#line 151 "parser.y"
     { (yyval.bool) = TRUE; }
     break;
 
   case 6:
 
 /* Line 1806 of yacc.c  */
-#line 152 "parser.y"
+#line 155 "parser.y"
     { source_add_statement(ctx, (yyvsp[(2) - (2)].statement)); }
     break;
 
   case 7:
 
 /* Line 1806 of yacc.c  */
-#line 153 "parser.y"
+#line 156 "parser.y"
     { source_add_class(ctx, (yyvsp[(2) - (2)].class_decl)); }
     break;
 
   case 8:
 
 /* Line 1806 of yacc.c  */
-#line 156 "parser.y"
+#line 159 "parser.y"
     { (yyval.statement) = NULL; }
     break;
 
   case 9:
 
 /* Line 1806 of yacc.c  */
-#line 157 "parser.y"
+#line 160 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (1)].statement); }
     break;
 
   case 10:
 
 /* Line 1806 of yacc.c  */
-#line 160 "parser.y"
+#line 163 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (1)].statement); }
     break;
 
   case 11:
 
 /* Line 1806 of yacc.c  */
-#line 161 "parser.y"
+#line 164 "parser.y"
     { (yyval.statement) = link_statements((yyvsp[(1) - (2)].statement), (yyvsp[(2) - (2)].statement)); }
     break;
 
   case 12:
 
 /* Line 1806 of yacc.c  */
-#line 164 "parser.y"
+#line 167 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (2)].statement); }
     break;
 
   case 13:
 
 /* Line 1806 of yacc.c  */
-#line 167 "parser.y"
+#line 170 "parser.y"
     { (yyval.statement) = NULL; }
     break;
 
   case 14:
 
 /* Line 1806 of yacc.c  */
-#line 168 "parser.y"
+#line 171 "parser.y"
     { (yyval.statement) = (yyvsp[(2) - (2)].statement); }
     break;
 
   case 15:
 
 /* Line 1806 of yacc.c  */
-#line 169 "parser.y"
+#line 172 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (1)].statement); }
     break;
 
   case 16:
 
 /* Line 1806 of yacc.c  */
-#line 170 "parser.y"
+#line 173 "parser.y"
     { (yyvsp[(1) - (3)].statement)->next = (yyvsp[(3) - (3)].statement); (yyval.statement) = (yyvsp[(1) - (3)].statement); }
     break;
 
   case 17:
 
 /* Line 1806 of yacc.c  */
-#line 171 "parser.y"
+#line 174 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (2)].statement); }
     break;
 
   case 18:
 
 /* Line 1806 of yacc.c  */
-#line 174 "parser.y"
+#line 177 "parser.y"
     { (yyvsp[(1) - (2)].member)->args = (yyvsp[(2) - (2)].expression); (yyval.statement) = new_call_statement(ctx, FALSE, (yyvsp[(1) - (2)].member)); CHECK_ERROR; }
     break;
 
   case 19:
 
 /* Line 1806 of yacc.c  */
-#line 175 "parser.y"
+#line 178 "parser.y"
     { (yyvsp[(2) - (3)].member)->args = (yyvsp[(3) - (3)].expression); (yyval.statement) = new_call_statement(ctx, TRUE, (yyvsp[(2) - (3)].member)); CHECK_ERROR; }
     break;
 
   case 20:
 
 /* Line 1806 of yacc.c  */
-#line 177 "parser.y"
+#line 180 "parser.y"
     { (yyvsp[(1) - (4)].member)->args = (yyvsp[(2) - (4)].expression); (yyval.statement) = new_assign_statement(ctx, (yyvsp[(1) - (4)].member), (yyvsp[(4) - (4)].expression)); CHECK_ERROR; }
     break;
 
   case 21:
 
 /* Line 1806 of yacc.c  */
-#line 178 "parser.y"
+#line 181 "parser.y"
     { (yyval.statement) = new_dim_statement(ctx, (yyvsp[(2) - (2)].dim_decl)); CHECK_ERROR; }
     break;
 
   case 22:
 
 /* Line 1806 of yacc.c  */
-#line 179 "parser.y"
+#line 182 "parser.y"
     { (yyval.statement) = (yyvsp[(1) - (1)].statement); }
     break;
 
   case 23:
 
 /* Line 1806 of yacc.c  */
-#line 181 "parser.y"
+#line 184 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, STAT_WHILE, (yyvsp[(2) - (5)].expression), (yyvsp[(4) - (5)].statement)); CHECK_ERROR; }
     break;
 
   case 24:
 
 /* Line 1806 of yacc.c  */
-#line 183 "parser.y"
+#line 186 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, (yyvsp[(2) - (6)].bool) ? STAT_WHILELOOP : STAT_UNTIL, (yyvsp[(3) - (6)].expression), (yyvsp[(5) - (6)].statement));
                                               CHECK_ERROR; }
     break;
@@ -2054,7 +2082,7 @@ yyreduce:
   case 25:
 
 /* Line 1806 of yacc.c  */
-#line 186 "parser.y"
+#line 189 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, (yyvsp[(5) - (6)].bool) ? STAT_DOWHILE : STAT_DOUNTIL, (yyvsp[(6) - (6)].expression), (yyvsp[(3) - (6)].statement));
                                               CHECK_ERROR; }
     break;
@@ -2062,554 +2090,554 @@ yyreduce:
   case 26:
 
 /* Line 1806 of yacc.c  */
-#line 188 "parser.y"
+#line 191 "parser.y"
     { (yyval.statement) = new_while_statement(ctx, STAT_DOWHILE, NULL, (yyvsp[(3) - (4)].statement)); CHECK_ERROR; }
     break;
 
   case 27:
 
 /* Line 1806 of yacc.c  */
-#line 189 "parser.y"
+#line 192 "parser.y"
     { (yyval.statement) = new_function_statement(ctx, (yyvsp[(1) - (1)].func_decl)); CHECK_ERROR; }
     break;
 
   case 28:
 
 /* Line 1806 of yacc.c  */
-#line 190 "parser.y"
+#line 193 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EXITDO, 0); CHECK_ERROR; }
     break;
 
   case 29:
 
 /* Line 1806 of yacc.c  */
-#line 191 "parser.y"
+#line 194 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EXITFOR, 0); CHECK_ERROR; }
     break;
 
   case 30:
 
 /* Line 1806 of yacc.c  */
-#line 192 "parser.y"
+#line 195 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EXITFUNC, 0); CHECK_ERROR; }
     break;
 
   case 31:
 
 /* Line 1806 of yacc.c  */
-#line 193 "parser.y"
+#line 196 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EXITPROP, 0); CHECK_ERROR; }
     break;
 
   case 32:
 
 /* Line 1806 of yacc.c  */
-#line 194 "parser.y"
+#line 197 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_EXITSUB, 0); CHECK_ERROR; }
     break;
 
   case 33:
 
 /* Line 1806 of yacc.c  */
-#line 196 "parser.y"
+#line 199 "parser.y"
     { (yyvsp[(2) - (5)].member)->args = (yyvsp[(3) - (5)].expression); (yyval.statement) = new_set_statement(ctx, (yyvsp[(2) - (5)].member), (yyvsp[(5) - (5)].expression)); CHECK_ERROR; }
     break;
 
   case 34:
 
 /* Line 1806 of yacc.c  */
-#line 197 "parser.y"
+#line 200 "parser.y"
     { (yyval.statement) = new_statement(ctx, STAT_STOP, 0); CHECK_ERROR; }
     break;
 
   case 35:
 
 /* Line 1806 of yacc.c  */
-#line 198 "parser.y"
+#line 201 "parser.y"
     { (yyval.statement) = new_onerror_statement(ctx, TRUE); CHECK_ERROR; }
     break;
 
   case 36:
 
 /* Line 1806 of yacc.c  */
-#line 199 "parser.y"
+#line 202 "parser.y"
     { (yyval.statement) = new_onerror_statement(ctx, FALSE); CHECK_ERROR; }
     break;
 
   case 37:
 
 /* Line 1806 of yacc.c  */
-#line 200 "parser.y"
+#line 203 "parser.y"
     { (yyval.statement) = new_const_statement(ctx, (yyvsp[(2) - (2)].const_decl)); CHECK_ERROR; }
     break;
 
   case 38:
 
 /* Line 1806 of yacc.c  */
-#line 202 "parser.y"
+#line 205 "parser.y"
     { (yyval.statement) = new_forto_statement(ctx, (yyvsp[(2) - (10)].string), (yyvsp[(4) - (10)].expression), (yyvsp[(6) - (10)].expression), (yyvsp[(7) - (10)].expression), (yyvsp[(9) - (10)].statement)); CHECK_ERROR; }
     break;
 
   case 39:
 
 /* Line 1806 of yacc.c  */
-#line 204 "parser.y"
+#line 207 "parser.y"
     { (yyval.statement) = new_foreach_statement(ctx, (yyvsp[(3) - (8)].string), (yyvsp[(5) - (8)].expression), (yyvsp[(7) - (8)].statement)); }
     break;
 
   case 40:
 
 /* Line 1806 of yacc.c  */
-#line 206 "parser.y"
+#line 209 "parser.y"
     { (yyval.statement) = new_select_statement(ctx, (yyvsp[(3) - (7)].expression), (yyvsp[(5) - (7)].case_clausule)); }
     break;
 
   case 41:
 
 /* Line 1806 of yacc.c  */
-#line 209 "parser.y"
+#line 212 "parser.y"
     { (yyval.member) = new_member_expression(ctx, NULL, (yyvsp[(1) - (1)].string)); CHECK_ERROR; }
     break;
 
   case 42:
 
 /* Line 1806 of yacc.c  */
-#line 210 "parser.y"
+#line 213 "parser.y"
     { (yyval.member) = new_member_expression(ctx, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].string)); CHECK_ERROR; }
     break;
 
   case 43:
 
 /* Line 1806 of yacc.c  */
-#line 213 "parser.y"
-    { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[(1) - (1)].string), NULL); CHECK_ERROR; }
+#line 216 "parser.y"
+    { (yyval.dim_decl) = (yyvsp[(1) - (1)].dim_decl); }
     break;
 
   case 44:
 
 /* Line 1806 of yacc.c  */
-#line 214 "parser.y"
-    { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[(1) - (3)].string), (yyvsp[(3) - (3)].dim_decl)); CHECK_ERROR; }
+#line 217 "parser.y"
+    { (yyvsp[(1) - (3)].dim_decl)->next = (yyvsp[(3) - (3)].dim_decl); (yyval.dim_decl) = (yyvsp[(1) - (3)].dim_decl); }
     break;
 
   case 45:
 
 /* Line 1806 of yacc.c  */
-#line 217 "parser.y"
-    { (yyval.const_decl) = (yyvsp[(1) - (1)].const_decl); }
+#line 220 "parser.y"
+    { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[(1) - (1)].string), FALSE, NULL); CHECK_ERROR; }
     break;
 
   case 46:
 
 /* Line 1806 of yacc.c  */
-#line 218 "parser.y"
-    { (yyvsp[(1) - (3)].const_decl)->next = (yyvsp[(3) - (3)].const_decl); (yyval.const_decl) = (yyvsp[(1) - (3)].const_decl); }
+#line 221 "parser.y"
+    { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[(1) - (4)].string), TRUE, (yyvsp[(3) - (4)].dim_list)); CHECK_ERROR; }
     break;
 
   case 47:
 
 /* Line 1806 of yacc.c  */
-#line 221 "parser.y"
-    { (yyval.const_decl) = new_const_decl(ctx, (yyvsp[(1) - (3)].string), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 222 "parser.y"
+    { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[(1) - (2)].string), TRUE, NULL); CHECK_ERROR; }
     break;
 
   case 48:
 
 /* Line 1806 of yacc.c  */
-#line 224 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 225 "parser.y"
+    { (yyval.dim_list) = new_dim(ctx, (yyvsp[(1) - (1)].uint), NULL); }
     break;
 
   case 49:
 
 /* Line 1806 of yacc.c  */
-#line 225 "parser.y"
-    { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
+#line 226 "parser.y"
+    { (yyval.dim_list) = new_dim(ctx, (yyvsp[(1) - (3)].uint), (yyvsp[(3) - (3)].dim_list)); }
     break;
 
   case 50:
 
 /* Line 1806 of yacc.c  */
-#line 228 "parser.y"
-    { (yyval.bool) = TRUE; }
+#line 229 "parser.y"
+    { (yyval.const_decl) = (yyvsp[(1) - (1)].const_decl); }
     break;
 
   case 51:
 
 /* Line 1806 of yacc.c  */
-#line 229 "parser.y"
-    { (yyval.bool) = FALSE; }
+#line 230 "parser.y"
+    { (yyvsp[(1) - (3)].const_decl)->next = (yyvsp[(3) - (3)].const_decl); (yyval.const_decl) = (yyvsp[(1) - (3)].const_decl); }
     break;
 
   case 52:
 
 /* Line 1806 of yacc.c  */
-#line 232 "parser.y"
-    { (yyval.expression) = NULL;}
+#line 233 "parser.y"
+    { (yyval.const_decl) = new_const_decl(ctx, (yyvsp[(1) - (3)].string), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 53:
 
 /* Line 1806 of yacc.c  */
-#line 233 "parser.y"
-    { (yyval.expression) = (yyvsp[(2) - (2)].expression); }
+#line 236 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 54:
 
 /* Line 1806 of yacc.c  */
 #line 237 "parser.y"
-    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (9)].expression), (yyvsp[(5) - (9)].statement), (yyvsp[(6) - (9)].elseif), (yyvsp[(7) - (9)].statement)); CHECK_ERROR; }
+    { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
     break;
 
   case 55:
 
 /* Line 1806 of yacc.c  */
-#line 238 "parser.y"
-    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (4)].expression), (yyvsp[(4) - (4)].statement), NULL, NULL); CHECK_ERROR; }
+#line 240 "parser.y"
+    { (yyval.bool) = TRUE; }
     break;
 
   case 56:
 
 /* Line 1806 of yacc.c  */
-#line 240 "parser.y"
-    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (7)].expression), (yyvsp[(4) - (7)].statement), NULL, (yyvsp[(6) - (7)].statement)); CHECK_ERROR; }
+#line 241 "parser.y"
+    { (yyval.bool) = FALSE; }
     break;
 
-  case 59:
+  case 57:
 
 /* Line 1806 of yacc.c  */
-#line 247 "parser.y"
-    { (yyval.elseif) = NULL; }
+#line 244 "parser.y"
+    { (yyval.expression) = NULL;}
     break;
 
-  case 60:
+  case 58:
 
 /* Line 1806 of yacc.c  */
-#line 248 "parser.y"
-    { (yyval.elseif) = (yyvsp[(1) - (1)].elseif); }
+#line 245 "parser.y"
+    { (yyval.expression) = (yyvsp[(2) - (2)].expression); }
     break;
 
-  case 61:
+  case 59:
 
 /* Line 1806 of yacc.c  */
-#line 251 "parser.y"
-    { (yyval.elseif) = (yyvsp[(1) - (1)].elseif); }
+#line 249 "parser.y"
+    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (9)].expression), (yyvsp[(5) - (9)].statement), (yyvsp[(6) - (9)].elseif), (yyvsp[(7) - (9)].statement)); CHECK_ERROR; }
     break;
 
-  case 62:
+  case 60:
 
 /* Line 1806 of yacc.c  */
-#line 252 "parser.y"
-    { (yyvsp[(1) - (2)].elseif)->next = (yyvsp[(2) - (2)].elseif); (yyval.elseif) = (yyvsp[(1) - (2)].elseif); }
+#line 250 "parser.y"
+    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (4)].expression), (yyvsp[(4) - (4)].statement), NULL, NULL); CHECK_ERROR; }
     break;
 
-  case 63:
+  case 61:
 
 /* Line 1806 of yacc.c  */
-#line 256 "parser.y"
-    { (yyval.elseif) = new_elseif_decl(ctx, (yyvsp[(2) - (5)].expression), (yyvsp[(5) - (5)].statement)); }
+#line 252 "parser.y"
+    { (yyval.statement) = new_if_statement(ctx, (yyvsp[(2) - (7)].expression), (yyvsp[(4) - (7)].statement), NULL, (yyvsp[(6) - (7)].statement)); CHECK_ERROR; }
     break;
 
   case 64:
 
 /* Line 1806 of yacc.c  */
 #line 259 "parser.y"
-    { (yyval.statement) = NULL; }
+    { (yyval.elseif) = NULL; }
     break;
 
   case 65:
 
 /* Line 1806 of yacc.c  */
 #line 260 "parser.y"
-    { (yyval.statement) = (yyvsp[(3) - (3)].statement); }
+    { (yyval.elseif) = (yyvsp[(1) - (1)].elseif); }
     break;
 
   case 66:
 
 /* Line 1806 of yacc.c  */
 #line 263 "parser.y"
-    { (yyval.case_clausule) = NULL; }
+    { (yyval.elseif) = (yyvsp[(1) - (1)].elseif); }
     break;
 
   case 67:
 
 /* Line 1806 of yacc.c  */
 #line 264 "parser.y"
-    { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[(4) - (4)].statement), NULL); }
+    { (yyvsp[(1) - (2)].elseif)->next = (yyvsp[(2) - (2)].elseif); (yyval.elseif) = (yyvsp[(1) - (2)].elseif); }
     break;
 
   case 68:
 
 /* Line 1806 of yacc.c  */
-#line 266 "parser.y"
-    { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[(2) - (5)].expression), (yyvsp[(4) - (5)].statement), (yyvsp[(5) - (5)].case_clausule)); }
+#line 268 "parser.y"
+    { (yyval.elseif) = new_elseif_decl(ctx, (yyvsp[(2) - (5)].expression), (yyvsp[(5) - (5)].statement)); }
     break;
 
   case 69:
 
 /* Line 1806 of yacc.c  */
-#line 269 "parser.y"
-    { (yyval.expression) = NULL; }
+#line 271 "parser.y"
+    { (yyval.statement) = NULL; }
     break;
 
   case 70:
 
 /* Line 1806 of yacc.c  */
-#line 270 "parser.y"
-    { (yyval.expression) = (yyvsp[(2) - (3)].expression); }
+#line 272 "parser.y"
+    { (yyval.statement) = (yyvsp[(3) - (3)].statement); }
     break;
 
   case 71:
 
 /* Line 1806 of yacc.c  */
-#line 273 "parser.y"
-    { (yyval.expression) = NULL; }
+#line 275 "parser.y"
+    { (yyval.case_clausule) = NULL; }
     break;
 
   case 72:
 
 /* Line 1806 of yacc.c  */
-#line 274 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 276 "parser.y"
+    { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[(4) - (4)].statement), NULL); }
     break;
 
-  case 75:
+  case 73:
 
 /* Line 1806 of yacc.c  */
-#line 281 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 278 "parser.y"
+    { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[(2) - (5)].expression), (yyvsp[(4) - (5)].statement), (yyvsp[(5) - (5)].case_clausule)); }
     break;
 
-  case 76:
+  case 74:
 
 /* Line 1806 of yacc.c  */
-#line 282 "parser.y"
-    { (yyvsp[(1) - (3)].expression)->next = (yyvsp[(3) - (3)].expression); (yyval.expression) = (yyvsp[(1) - (3)].expression); }
+#line 281 "parser.y"
+    { (yyval.expression) = NULL; }
     break;
 
-  case 77:
+  case 75:
 
 /* Line 1806 of yacc.c  */
-#line 285 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 282 "parser.y"
+    { (yyval.expression) = (yyvsp[(2) - (3)].expression); }
     break;
 
-  case 78:
+  case 76:
 
 /* Line 1806 of yacc.c  */
-#line 286 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_IMP, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 285 "parser.y"
+    { (yyval.expression) = NULL; }
     break;
 
-  case 79:
+  case 77:
 
 /* Line 1806 of yacc.c  */
-#line 289 "parser.y"
+#line 286 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 80:
 
-/* Line 1806 of yacc.c  */
-#line 290 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_EQV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
-    break;
-
-  case 81:
-
 /* Line 1806 of yacc.c  */
 #line 293 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
-  case 82:
+  case 81:
 
 /* Line 1806 of yacc.c  */
 #line 294 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_XOR, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    { (yyvsp[(1) - (3)].expression)->next = (yyvsp[(3) - (3)].expression); (yyval.expression) = (yyvsp[(1) - (3)].expression); }
     break;
 
-  case 83:
+  case 82:
 
 /* Line 1806 of yacc.c  */
 #line 297 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
-  case 84:
+  case 83:
 
 /* Line 1806 of yacc.c  */
 #line 298 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_OR, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_IMP, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
-  case 85:
+  case 84:
 
 /* Line 1806 of yacc.c  */
 #line 301 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
-  case 86:
+  case 85:
 
 /* Line 1806 of yacc.c  */
 #line 302 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_AND, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_EQV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
-  case 87:
+  case 86:
 
 /* Line 1806 of yacc.c  */
 #line 305 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
-  case 88:
+  case 87:
 
 /* Line 1806 of yacc.c  */
 #line 306 "parser.y"
-    { (yyval.expression) = new_unary_expression(ctx, EXPR_NOT, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_XOR, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
-  case 89:
+  case 88:
 
 /* Line 1806 of yacc.c  */
 #line 309 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
-  case 90:
+  case 89:
 
 /* Line 1806 of yacc.c  */
 #line 310 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_EQUAL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_OR, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    break;
+
+  case 90:
+
+/* Line 1806 of yacc.c  */
+#line 313 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 91:
 
 /* Line 1806 of yacc.c  */
-#line 311 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_NEQUAL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 314 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_AND, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 92:
 
 /* Line 1806 of yacc.c  */
-#line 312 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_GT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 317 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 93:
 
 /* Line 1806 of yacc.c  */
-#line 313 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_LT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 318 "parser.y"
+    { (yyval.expression) = new_unary_expression(ctx, EXPR_NOT, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
     break;
 
   case 94:
 
 /* Line 1806 of yacc.c  */
-#line 314 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_GTEQ, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 321 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 95:
 
 /* Line 1806 of yacc.c  */
-#line 315 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_LTEQ, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 322 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_EQUAL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 96:
 
 /* Line 1806 of yacc.c  */
-#line 316 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_IS, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 323 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_NEQUAL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 97:
 
 /* Line 1806 of yacc.c  */
-#line 319 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 324 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_GT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 98:
 
 /* Line 1806 of yacc.c  */
-#line 320 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_CONCAT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 325 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_LT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 99:
 
 /* Line 1806 of yacc.c  */
-#line 323 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 326 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_GTEQ, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 100:
 
 /* Line 1806 of yacc.c  */
-#line 324 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 327 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_LTEQ, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 101:
 
 /* Line 1806 of yacc.c  */
-#line 325 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 328 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_IS, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 102:
 
 /* Line 1806 of yacc.c  */
-#line 328 "parser.y"
+#line 331 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 103:
 
 /* Line 1806 of yacc.c  */
-#line 329 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 332 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_CONCAT, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 104:
 
 /* Line 1806 of yacc.c  */
-#line 332 "parser.y"
+#line 335 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 105:
 
 /* Line 1806 of yacc.c  */
-#line 334 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_IDIV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 336 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 106:
 
 /* Line 1806 of yacc.c  */
 #line 337 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 107:
 
 /* Line 1806 of yacc.c  */
-#line 339 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 340 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 108:
 
 /* Line 1806 of yacc.c  */
 #line 341 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 109:
@@ -2622,315 +2650,379 @@ yyreduce:
   case 110:
 
 /* Line 1806 of yacc.c  */
-#line 345 "parser.y"
-    { (yyval.expression) = new_binary_expression(ctx, EXPR_EXP, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
+#line 346 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_IDIV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 111:
 
 /* Line 1806 of yacc.c  */
-#line 348 "parser.y"
+#line 349 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 112:
 
 /* Line 1806 of yacc.c  */
-#line 349 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 351 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 113:
 
 /* Line 1806 of yacc.c  */
-#line 350 "parser.y"
-    { (yyval.expression) = new_new_expression(ctx, (yyvsp[(2) - (2)].string)); CHECK_ERROR; }
+#line 353 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 114:
 
 /* Line 1806 of yacc.c  */
-#line 351 "parser.y"
-    { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
+#line 356 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 115:
 
 /* Line 1806 of yacc.c  */
-#line 354 "parser.y"
-    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
+#line 357 "parser.y"
+    { (yyval.expression) = new_binary_expression(ctx, EXPR_EXP, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); CHECK_ERROR; }
     break;
 
   case 116:
 
 /* Line 1806 of yacc.c  */
-#line 355 "parser.y"
-    { (yyvsp[(1) - (2)].member)->args = (yyvsp[(2) - (2)].expression); (yyval.expression) = &(yyvsp[(1) - (2)].member)->expr; }
+#line 360 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 117:
 
 /* Line 1806 of yacc.c  */
-#line 358 "parser.y"
-    { (yyval.expression) = new_bool_expression(ctx, VARIANT_TRUE); CHECK_ERROR; }
+#line 361 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 118:
 
 /* Line 1806 of yacc.c  */
-#line 359 "parser.y"
-    { (yyval.expression) = new_bool_expression(ctx, VARIANT_FALSE); CHECK_ERROR; }
+#line 362 "parser.y"
+    { (yyval.expression) = new_new_expression(ctx, (yyvsp[(2) - (2)].string)); CHECK_ERROR; }
     break;
 
   case 119:
 
 /* Line 1806 of yacc.c  */
-#line 360 "parser.y"
-    { (yyval.expression) = new_string_expression(ctx, (yyvsp[(1) - (1)].string)); CHECK_ERROR; }
+#line 363 "parser.y"
+    { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[(2) - (2)].expression)); CHECK_ERROR; }
     break;
 
   case 120:
 
 /* Line 1806 of yacc.c  */
-#line 361 "parser.y"
+#line 366 "parser.y"
     { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 121:
 
 /* Line 1806 of yacc.c  */
-#line 362 "parser.y"
-    { (yyval.expression) = new_expression(ctx, EXPR_EMPTY, 0); CHECK_ERROR; }
+#line 367 "parser.y"
+    { (yyvsp[(1) - (2)].member)->args = (yyvsp[(2) - (2)].expression); (yyval.expression) = &(yyvsp[(1) - (2)].member)->expr; }
     break;
 
   case 122:
 
 /* Line 1806 of yacc.c  */
-#line 363 "parser.y"
-    { (yyval.expression) = new_expression(ctx, EXPR_NULL, 0); CHECK_ERROR; }
+#line 370 "parser.y"
+    { (yyval.expression) = new_bool_expression(ctx, VARIANT_TRUE); CHECK_ERROR; }
     break;
 
   case 123:
 
 /* Line 1806 of yacc.c  */
-#line 364 "parser.y"
-    { (yyval.expression) = new_expression(ctx, EXPR_NOTHING, 0); CHECK_ERROR; }
+#line 371 "parser.y"
+    { (yyval.expression) = new_bool_expression(ctx, VARIANT_FALSE); CHECK_ERROR; }
     break;
 
   case 124:
 
 /* Line 1806 of yacc.c  */
-#line 367 "parser.y"
-    { (yyval.expression) = new_long_expression(ctx, EXPR_USHORT, (yyvsp[(1) - (1)].lng)); CHECK_ERROR; }
+#line 372 "parser.y"
+    { (yyval.expression) = new_string_expression(ctx, (yyvsp[(1) - (1)].string)); CHECK_ERROR; }
     break;
 
   case 125:
 
 /* Line 1806 of yacc.c  */
-#line 368 "parser.y"
-    { (yyval.expression) = new_long_expression(ctx, EXPR_USHORT, 0); CHECK_ERROR; }
+#line 373 "parser.y"
+    { (yyval.expression) = (yyvsp[(1) - (1)].expression); }
     break;
 
   case 126:
 
 /* Line 1806 of yacc.c  */
-#line 369 "parser.y"
-    { (yyval.expression) = new_long_expression(ctx, EXPR_ULONG, (yyvsp[(1) - (1)].lng)); CHECK_ERROR; }
+#line 374 "parser.y"
+    { (yyval.expression) = new_expression(ctx, EXPR_EMPTY, 0); CHECK_ERROR; }
     break;
 
   case 127:
 
 /* Line 1806 of yacc.c  */
-#line 370 "parser.y"
-    { (yyval.expression) = new_double_expression(ctx, (yyvsp[(1) - (1)].dbl)); CHECK_ERROR; }
+#line 375 "parser.y"
+    { (yyval.expression) = new_expression(ctx, EXPR_NULL, 0); CHECK_ERROR; }
     break;
 
   case 128:
 
 /* Line 1806 of yacc.c  */
-#line 374 "parser.y"
-    { (yyval.expression) = new_unary_expression(ctx, EXPR_BRACKETS, (yyvsp[(2) - (3)].expression)); }
+#line 376 "parser.y"
+    { (yyval.expression) = new_expression(ctx, EXPR_NOTHING, 0); CHECK_ERROR; }
     break;
 
   case 129:
 
 /* Line 1806 of yacc.c  */
-#line 375 "parser.y"
-    { (yyval.expression) = new_expression(ctx, EXPR_ME, 0); CHECK_ERROR; }
+#line 379 "parser.y"
+    { (yyval.expression) = new_long_expression(ctx, EXPR_USHORT, (yyvsp[(1) - (1)].lng)); CHECK_ERROR; }
     break;
 
   case 130:
 
 /* Line 1806 of yacc.c  */
-#line 378 "parser.y"
-    { (yyvsp[(4) - (7)].class_decl)->name = (yyvsp[(2) - (7)].string); (yyval.class_decl) = (yyvsp[(4) - (7)].class_decl); }
+#line 380 "parser.y"
+    { (yyval.expression) = new_long_expression(ctx, EXPR_USHORT, 0); CHECK_ERROR; }
     break;
 
   case 131:
 
 /* Line 1806 of yacc.c  */
 #line 381 "parser.y"
-    { (yyval.class_decl) = new_class_decl(ctx); }
+    { (yyval.expression) = new_long_expression(ctx, EXPR_ULONG, (yyvsp[(1) - (1)].lng)); CHECK_ERROR; }
     break;
 
   case 132:
 
 /* Line 1806 of yacc.c  */
 #line 382 "parser.y"
-    { (yyval.class_decl) = add_class_function(ctx, (yyvsp[(3) - (3)].class_decl), (yyvsp[(1) - (3)].func_decl)); CHECK_ERROR; }
+    { (yyval.expression) = new_double_expression(ctx, (yyvsp[(1) - (1)].dbl)); CHECK_ERROR; }
     break;
 
   case 133:
 
 /* Line 1806 of yacc.c  */
-#line 383 "parser.y"
-    { (yyval.class_decl) = add_variant_prop(ctx, (yyvsp[(4) - (4)].class_decl), (yyvsp[(2) - (4)].string), (yyvsp[(1) - (4)].uint)); CHECK_ERROR; }
+#line 385 "parser.y"
+    { (yyval.uint) = (yyvsp[(1) - (1)].lng); }
     break;
 
   case 134:
 
 /* Line 1806 of yacc.c  */
-#line 384 "parser.y"
-    { (yyval.class_decl) = add_class_function(ctx, (yyvsp[(3) - (3)].class_decl), (yyvsp[(1) - (3)].func_decl)); CHECK_ERROR; }
+#line 386 "parser.y"
+    { (yyval.uint) = 0; }
     break;
 
   case 135:
 
 /* Line 1806 of yacc.c  */
-#line 388 "parser.y"
-    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (9)].string), FUNC_PROPGET, (yyvsp[(1) - (9)].uint), NULL, (yyvsp[(7) - (9)].statement)); CHECK_ERROR; }
+#line 387 "parser.y"
+    { (yyval.uint) = (yyvsp[(1) - (1)].lng); }
     break;
 
   case 136:
 
 /* Line 1806 of yacc.c  */
 #line 390 "parser.y"
-    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (11)].string), FUNC_PROPLET, (yyvsp[(1) - (11)].uint), (yyvsp[(6) - (11)].arg_decl), (yyvsp[(9) - (11)].statement)); CHECK_ERROR; }
+    { (yyval.expression) = new_unary_expression(ctx, EXPR_BRACKETS, (yyvsp[(2) - (3)].expression)); }
     break;
 
   case 137:
 
 /* Line 1806 of yacc.c  */
-#line 392 "parser.y"
-    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (11)].string), FUNC_PROPSET, (yyvsp[(1) - (11)].uint), (yyvsp[(6) - (11)].arg_decl), (yyvsp[(9) - (11)].statement)); CHECK_ERROR; }
+#line 391 "parser.y"
+    { (yyval.expression) = new_expression(ctx, EXPR_ME, 0); CHECK_ERROR; }
     break;
 
   case 138:
 
 /* Line 1806 of yacc.c  */
-#line 396 "parser.y"
-    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(3) - (8)].string), FUNC_SUB, (yyvsp[(1) - (8)].uint), (yyvsp[(4) - (8)].arg_decl), (yyvsp[(6) - (8)].statement)); CHECK_ERROR; }
+#line 394 "parser.y"
+    { (yyvsp[(4) - (7)].class_decl)->name = (yyvsp[(2) - (7)].string); (yyval.class_decl) = (yyvsp[(4) - (7)].class_decl); }
     break;
 
   case 139:
 
 /* Line 1806 of yacc.c  */
-#line 398 "parser.y"
-    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(3) - (8)].string), FUNC_FUNCTION, (yyvsp[(1) - (8)].uint), (yyvsp[(4) - (8)].arg_decl), (yyvsp[(6) - (8)].statement)); CHECK_ERROR; }
+#line 397 "parser.y"
+    { (yyval.class_decl) = new_class_decl(ctx); }
     break;
 
   case 140:
 
 /* Line 1806 of yacc.c  */
-#line 401 "parser.y"
-    { (yyval.uint) = 0; }
+#line 398 "parser.y"
+    { (yyval.class_decl) = add_class_function(ctx, (yyvsp[(3) - (3)].class_decl), (yyvsp[(1) - (3)].func_decl)); CHECK_ERROR; }
     break;
 
   case 141:
 
 /* Line 1806 of yacc.c  */
-#line 402 "parser.y"
-    { (yyval.uint) = (yyvsp[(1) - (1)].uint); }
+#line 400 "parser.y"
+    { dim_decl_t *dim_decl = new_dim_decl(ctx, (yyvsp[(2) - (4)].string), FALSE, NULL); CHECK_ERROR;
+                                                  (yyval.class_decl) = add_dim_prop(ctx, (yyvsp[(4) - (4)].class_decl), dim_decl, (yyvsp[(1) - (4)].uint)); CHECK_ERROR; }
     break;
 
   case 142:
 
 /* Line 1806 of yacc.c  */
-#line 405 "parser.y"
-    { (yyval.uint) = STORAGE_IS_DEFAULT; }
+#line 402 "parser.y"
+    { (yyval.class_decl) = add_dim_prop(ctx, (yyvsp[(4) - (4)].class_decl), (yyvsp[(2) - (4)].dim_decl), 0); CHECK_ERROR; }
     break;
 
   case 143:
 
 /* Line 1806 of yacc.c  */
-#line 406 "parser.y"
-    { (yyval.uint) = 0; }
+#line 403 "parser.y"
+    { (yyval.class_decl) = add_class_function(ctx, (yyvsp[(3) - (3)].class_decl), (yyvsp[(1) - (3)].func_decl)); CHECK_ERROR; }
     break;
 
   case 144:
 
 /* Line 1806 of yacc.c  */
 #line 407 "parser.y"
-    { (yyval.uint) = STORAGE_IS_PRIVATE; }
+    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (9)].string), FUNC_PROPGET, (yyvsp[(1) - (9)].uint), NULL, (yyvsp[(7) - (9)].statement)); CHECK_ERROR; }
     break;
 
   case 145:
 
 /* Line 1806 of yacc.c  */
-#line 410 "parser.y"
-    { (yyval.arg_decl) = NULL; }
+#line 409 "parser.y"
+    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (11)].string), FUNC_PROPLET, (yyvsp[(1) - (11)].uint), (yyvsp[(6) - (11)].arg_decl), (yyvsp[(9) - (11)].statement)); CHECK_ERROR; }
     break;
 
   case 146:
 
 /* Line 1806 of yacc.c  */
 #line 411 "parser.y"
-    { (yyval.arg_decl) = (yyvsp[(2) - (3)].arg_decl); }
+    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(4) - (11)].string), FUNC_PROPSET, (yyvsp[(1) - (11)].uint), (yyvsp[(6) - (11)].arg_decl), (yyvsp[(9) - (11)].statement)); CHECK_ERROR; }
     break;
 
   case 147:
 
 /* Line 1806 of yacc.c  */
-#line 414 "parser.y"
-    { (yyval.arg_decl) = (yyvsp[(1) - (1)].arg_decl); }
+#line 415 "parser.y"
+    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(3) - (8)].string), FUNC_SUB, (yyvsp[(1) - (8)].uint), (yyvsp[(4) - (8)].arg_decl), (yyvsp[(6) - (8)].statement)); CHECK_ERROR; }
     break;
 
   case 148:
 
 /* Line 1806 of yacc.c  */
-#line 415 "parser.y"
-    { (yyvsp[(1) - (3)].arg_decl)->next = (yyvsp[(3) - (3)].arg_decl); (yyval.arg_decl) = (yyvsp[(1) - (3)].arg_decl); }
+#line 417 "parser.y"
+    { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[(3) - (8)].string), FUNC_FUNCTION, (yyvsp[(1) - (8)].uint), (yyvsp[(4) - (8)].arg_decl), (yyvsp[(6) - (8)].statement)); CHECK_ERROR; }
     break;
 
   case 149:
 
 /* Line 1806 of yacc.c  */
-#line 418 "parser.y"
-    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(1) - (1)].string), TRUE); }
+#line 420 "parser.y"
+    { (yyval.uint) = 0; }
     break;
 
   case 150:
 
 /* Line 1806 of yacc.c  */
-#line 419 "parser.y"
-    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(2) - (2)].string), TRUE); }
+#line 421 "parser.y"
+    { (yyval.uint) = (yyvsp[(1) - (1)].uint); }
     break;
 
   case 151:
 
 /* Line 1806 of yacc.c  */
-#line 420 "parser.y"
-    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(2) - (2)].string), FALSE); }
+#line 424 "parser.y"
+    { (yyval.uint) = STORAGE_IS_DEFAULT; }
     break;
 
   case 152:
 
 /* Line 1806 of yacc.c  */
-#line 424 "parser.y"
-    { (yyval.string) = (yyvsp[(1) - (1)].string); }
+#line 425 "parser.y"
+    { (yyval.uint) = 0; }
     break;
 
   case 153:
 
 /* Line 1806 of yacc.c  */
-#line 425 "parser.y"
+#line 426 "parser.y"
+    { (yyval.uint) = STORAGE_IS_PRIVATE; }
+    break;
+
+  case 154:
+
+/* Line 1806 of yacc.c  */
+#line 429 "parser.y"
+    { (yyval.arg_decl) = NULL; }
+    break;
+
+  case 155:
+
+/* Line 1806 of yacc.c  */
+#line 430 "parser.y"
+    { (yyval.arg_decl) = (yyvsp[(2) - (3)].arg_decl); }
+    break;
+
+  case 156:
+
+/* Line 1806 of yacc.c  */
+#line 433 "parser.y"
+    { (yyval.arg_decl) = (yyvsp[(1) - (1)].arg_decl); }
+    break;
+
+  case 157:
+
+/* Line 1806 of yacc.c  */
+#line 434 "parser.y"
+    { (yyvsp[(1) - (3)].arg_decl)->next = (yyvsp[(3) - (3)].arg_decl); (yyval.arg_decl) = (yyvsp[(1) - (3)].arg_decl); }
+    break;
+
+  case 158:
+
+/* Line 1806 of yacc.c  */
+#line 437 "parser.y"
+    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(1) - (2)].string), TRUE); }
+    break;
+
+  case 159:
+
+/* Line 1806 of yacc.c  */
+#line 438 "parser.y"
+    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(2) - (3)].string), TRUE); }
+    break;
+
+  case 160:
+
+/* Line 1806 of yacc.c  */
+#line 439 "parser.y"
+    { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[(2) - (3)].string), FALSE); }
+    break;
+
+  case 161:
+
+/* Line 1806 of yacc.c  */
+#line 443 "parser.y"
+    { (yyval.string) = (yyvsp[(1) - (1)].string); }
+    break;
+
+  case 162:
+
+/* Line 1806 of yacc.c  */
+#line 444 "parser.y"
     { (yyval.string) = propertyW; }
     break;
 
 
 
 /* Line 1806 of yacc.c  */
-#line 2940 "parser.tab.c"
+#line 3032 "parser.tab.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -3161,7 +3253,7 @@ yyreturn:
 
 
 /* Line 2067 of yacc.c  */
-#line 426 "parser.y"
+#line 451 "parser.y"
 
 
 static int parser_error(parser_ctx_t *ctx, const char *str)
@@ -3358,7 +3450,7 @@ static statement_t *new_set_statement(parser_ctx_t *ctx, member_expression_t *le
     return &stat->stat;
 }
 
-static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, dim_decl_t *next)
+static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, BOOL is_array, dim_list_t *dims)
 {
     dim_decl_t *decl;
 
@@ -3367,10 +3459,25 @@ static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, dim_decl_t
         return NULL;
 
     decl->name = name;
-    decl->next = next;
+    decl->is_array = is_array;
+    decl->dims = dims;
+    decl->next = NULL;
     return decl;
 }
 
+static dim_list_t *new_dim(parser_ctx_t *ctx, unsigned val, dim_list_t *next)
+{
+    dim_list_t *ret;
+
+    ret = parser_alloc(ctx, sizeof(*ret));
+    if(!ret)
+        return NULL;
+
+    ret->val = val;
+    ret->next = next;
+    return ret;
+}
+
 static statement_t *new_dim_statement(parser_ctx_t *ctx, dim_decl_t *decls)
 {
     dim_statement_t *stat;
@@ -3599,24 +3706,17 @@ static class_decl_t *add_class_function(parser_ctx_t *ctx, class_decl_t *class_d
     return class_decl;
 }
 
-static class_decl_t *add_variant_prop(parser_ctx_t *ctx, class_decl_t *class_decl, const WCHAR *identifier, unsigned storage_flags)
+static class_decl_t *add_dim_prop(parser_ctx_t *ctx, class_decl_t *class_decl, dim_decl_t *dim_decl, unsigned storage_flags)
 {
-    class_prop_decl_t *prop;
-
     if(storage_flags & STORAGE_IS_DEFAULT) {
         FIXME("variant prop van't be default value\n");
         ctx->hres = E_FAIL;
         return NULL;
     }
 
-    prop = parser_alloc(ctx, sizeof(*prop));
-    if(!prop)
-        return NULL;
-
-    prop->name = identifier;
-    prop->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
-    prop->next = class_decl->props;
-    class_decl->props = prop;
+    dim_decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
+    dim_decl->next = class_decl->props;
+    class_decl->props = dim_decl;
     return class_decl;
 }
 
index fd4b235..7313fd9 100644 (file)
@@ -115,7 +115,7 @@ typedef union YYSTYPE
 {
 
 /* Line 2068 of yacc.c  */
-#line 87 "parser.y"
+#line 88 "parser.y"
 
     const WCHAR *string;
     statement_t *statement;
@@ -123,6 +123,7 @@ typedef union YYSTYPE
     member_expression_t *member;
     elseif_decl_t *elseif;
     dim_decl_t *dim_decl;
+    dim_list_t *dim_list;
     function_decl_t *func_decl;
     arg_decl_t *arg_decl;
     class_decl_t *class_decl;
@@ -136,7 +137,7 @@ typedef union YYSTYPE
 
 
 /* Line 2068 of yacc.c  */
-#line 140 "parser.tab.h"
+#line 141 "parser.tab.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
index 3c54fd8..6bd4907 100644 (file)
@@ -57,7 +57,8 @@ static statement_t *new_onerror_statement(parser_ctx_t*,BOOL);
 static statement_t *new_const_statement(parser_ctx_t*,const_decl_t*);
 static statement_t *new_select_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
 
-static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,dim_decl_t*);
+static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,BOOL,dim_list_t*);
+static dim_list_t *new_dim(parser_ctx_t*,unsigned,dim_list_t*);
 static elseif_decl_t *new_elseif_decl(parser_ctx_t*,expression_t*,statement_t*);
 static function_decl_t *new_function_decl(parser_ctx_t*,const WCHAR*,function_type_t,unsigned,arg_decl_t*,statement_t*);
 static arg_decl_t *new_argument_decl(parser_ctx_t*,const WCHAR*,BOOL);
@@ -66,7 +67,7 @@ static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_
 
 static class_decl_t *new_class_decl(parser_ctx_t*);
 static class_decl_t *add_class_function(parser_ctx_t*,class_decl_t*,function_decl_t*);
-static class_decl_t *add_variant_prop(parser_ctx_t*,class_decl_t*,const WCHAR*,unsigned);
+static class_decl_t *add_dim_prop(parser_ctx_t*,class_decl_t*,dim_decl_t*,unsigned);
 
 static statement_t *link_statements(statement_t*,statement_t*);
 
@@ -91,6 +92,7 @@ static const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0};
     member_expression_t *member;
     elseif_decl_t *elseif;
     dim_decl_t *dim_decl;
+    dim_list_t *dim_list;
     function_decl_t *func_decl;
     arg_decl_t *arg_decl;
     class_decl_t *class_decl;
@@ -132,8 +134,9 @@ static const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0};
 %type <func_decl> FunctionDecl PropertyDecl
 %type <elseif> ElseIfs_opt ElseIfs ElseIf
 %type <class_decl> ClassDeclaration ClassBody
-%type <uint> Storage Storage_opt
-%type <dim_decl> DimDeclList
+%type <uint> Storage Storage_opt IntegerValue
+%type <dim_decl> DimDeclList DimDecl
+%type <dim_list> DimList
 %type <const_decl> ConstDecl ConstDeclList
 %type <string> Identifier
 %type <case_clausule> CaseClausules
@@ -202,16 +205,25 @@ SimpleStatement
                                             { $$ = new_forto_statement(ctx, $2, $4, $6, $7, $9); CHECK_ERROR; }
     | tFOR tEACH Identifier tIN Expression tNL StatementsNl_opt tNEXT
                                             { $$ = new_foreach_statement(ctx, $3, $5, $7); }
-    | tSELECT tCASE Expression tNL CaseClausules tEND tSELECT
+    | tSELECT tCASE Expression StSep CaseClausules tEND tSELECT
                                             { $$ = new_select_statement(ctx, $3, $5); }
 
 MemberExpression
     : Identifier                            { $$ = new_member_expression(ctx, NULL, $1); CHECK_ERROR; }
     | CallExpression '.' Identifier         { $$ = new_member_expression(ctx, $1, $3); CHECK_ERROR; }
 
-DimDeclList /* FIXME: Support arrays */
-    : Identifier                            { $$ = new_dim_decl(ctx, $1, NULL); CHECK_ERROR; }
-    | Identifier ',' DimDeclList            { $$ = new_dim_decl(ctx, $1, $3); CHECK_ERROR; }
+DimDeclList
+    : DimDecl                               { $$ = $1; }
+    | DimDecl ',' DimDeclList               { $1->next = $3; $$ = $1; }
+
+DimDecl
+    : Identifier                            { $$ = new_dim_decl(ctx, $1, FALSE, NULL); CHECK_ERROR; }
+    | Identifier '(' DimList ')'            { $$ = new_dim_decl(ctx, $1, TRUE, $3); CHECK_ERROR; }
+    | Identifier tEMPTYBRACKETS             { $$ = new_dim_decl(ctx, $1, TRUE, NULL); CHECK_ERROR; }
+
+DimList
+    : IntegerValue                          { $$ = new_dim(ctx, $1, NULL); }
+    | IntegerValue ',' DimList              { $$ = new_dim(ctx, $1, $3); }
 
 ConstDeclList
     : ConstDecl                             { $$ = $1; }
@@ -261,8 +273,8 @@ Else_opt
 
 CaseClausules
     : /* empty */                          { $$ = NULL; }
-    | tCASE tELSE tNL StatementsNl         { $$ = new_case_clausule(ctx, NULL, $4, NULL); }
-    | tCASE ExpressionList tNL StatementsNl_opt CaseClausules
+    | tCASE tELSE StSep StatementsNl       { $$ = new_case_clausule(ctx, NULL, $4, NULL); }
+    | tCASE ExpressionList StSep StatementsNl_opt CaseClausules
                                            { $$ = new_case_clausule(ctx, $2, $4, $5); }
 
 Arguments_opt
@@ -369,6 +381,10 @@ NumericLiteralExpression
     | tLong                         { $$ = new_long_expression(ctx, EXPR_ULONG, $1); CHECK_ERROR; }
     | tDouble                       { $$ = new_double_expression(ctx, $1); CHECK_ERROR; }
 
+IntegerValue
+    : tShort                        { $$ = $1; }
+    | '0'                           { $$ = 0; }
+    | tLong                         { $$ = $1; }
 
 PrimaryExpression
     : '(' Expression ')'            { $$ = new_unary_expression(ctx, EXPR_BRACKETS, $2); }
@@ -380,7 +396,10 @@ ClassDeclaration
 ClassBody
     : /* empty */                               { $$ = new_class_decl(ctx); }
     | FunctionDecl tNL ClassBody                { $$ = add_class_function(ctx, $3, $1); CHECK_ERROR; }
-    | Storage tIdentifier tNL ClassBody         { $$ = add_variant_prop(ctx, $4, $2, $1); CHECK_ERROR; }
+    /* FIXME: We should use DimDecl here to support arrays, but that conflicts with PropertyDecl. */
+    | Storage tIdentifier tNL ClassBody         { dim_decl_t *dim_decl = new_dim_decl(ctx, $2, FALSE, NULL); CHECK_ERROR;
+                                                  $$ = add_dim_prop(ctx, $4, dim_decl, $1); CHECK_ERROR; }
+    | tDIM DimDecl tNL ClassBody                { $$ = add_dim_prop(ctx, $4, $2, 0); CHECK_ERROR; }
     | PropertyDecl tNL ClassBody                { $$ = add_class_function(ctx, $3, $1); CHECK_ERROR; }
 
 PropertyDecl
@@ -415,14 +434,20 @@ ArgumentDeclList
     | ArgumentDecl ',' ArgumentDeclList         { $1->next = $3; $$ = $1; }
 
 ArgumentDecl
-    : Identifier                                { $$ = new_argument_decl(ctx, $1, TRUE); }
-    | tBYREF Identifier                         { $$ = new_argument_decl(ctx, $2, TRUE); }
-    | tBYVAL Identifier                         { $$ = new_argument_decl(ctx, $2, FALSE); }
+    : Identifier EmptyBrackets_opt              { $$ = new_argument_decl(ctx, $1, TRUE); }
+    | tBYREF Identifier EmptyBrackets_opt       { $$ = new_argument_decl(ctx, $2, TRUE); }
+    | tBYVAL Identifier EmptyBrackets_opt       { $$ = new_argument_decl(ctx, $2, FALSE); }
 
 /* 'property' may be both keyword and identifier, depending on context */
 Identifier
     : tIdentifier    { $$ = $1; }
     | tPROPERTY      { $$ = propertyW; }
+
+/* Some statements accept both new line and ':' as a separator */
+StSep
+    : tNL
+    | ':'
+
 %%
 
 static int parser_error(parser_ctx_t *ctx, const char *str)
@@ -619,7 +644,7 @@ static statement_t *new_set_statement(parser_ctx_t *ctx, member_expression_t *le
     return &stat->stat;
 }
 
-static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, dim_decl_t *next)
+static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, BOOL is_array, dim_list_t *dims)
 {
     dim_decl_t *decl;
 
@@ -628,10 +653,25 @@ static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, dim_decl_t
         return NULL;
 
     decl->name = name;
-    decl->next = next;
+    decl->is_array = is_array;
+    decl->dims = dims;
+    decl->next = NULL;
     return decl;
 }
 
+static dim_list_t *new_dim(parser_ctx_t *ctx, unsigned val, dim_list_t *next)
+{
+    dim_list_t *ret;
+
+    ret = parser_alloc(ctx, sizeof(*ret));
+    if(!ret)
+        return NULL;
+
+    ret->val = val;
+    ret->next = next;
+    return ret;
+}
+
 static statement_t *new_dim_statement(parser_ctx_t *ctx, dim_decl_t *decls)
 {
     dim_statement_t *stat;
@@ -860,24 +900,17 @@ static class_decl_t *add_class_function(parser_ctx_t *ctx, class_decl_t *class_d
     return class_decl;
 }
 
-static class_decl_t *add_variant_prop(parser_ctx_t *ctx, class_decl_t *class_decl, const WCHAR *identifier, unsigned storage_flags)
+static class_decl_t *add_dim_prop(parser_ctx_t *ctx, class_decl_t *class_decl, dim_decl_t *dim_decl, unsigned storage_flags)
 {
-    class_prop_decl_t *prop;
-
     if(storage_flags & STORAGE_IS_DEFAULT) {
         FIXME("variant prop van't be default value\n");
         ctx->hres = E_FAIL;
         return NULL;
     }
 
-    prop = parser_alloc(ctx, sizeof(*prop));
-    if(!prop)
-        return NULL;
-
-    prop->name = identifier;
-    prop->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
-    prop->next = class_decl->props;
-    class_decl->props = prop;
+    dim_decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
+    dim_decl->next = class_decl->props;
+    class_decl->props = dim_decl;
     return class_decl;
 }
 
index 724e8de..cf51530 100644 (file)
@@ -883,7 +883,7 @@ ProcessOp(CompilerState *state, REOpData *opData, RENode **operandStack,
 
 /*
  * Hack two bits in CompilerState.flags, for use within FindParenCount to flag
- * its being on the stack, and to propagate errors to its callers.
+ * it being on the stack, and to propagate errors to its callers.
  */
 #define JSREG_FIND_PAREN_COUNT  0x8000
 #define JSREG_FIND_PAREN_ERROR  0x4000
index 67b54da..3f8b13e 100644 (file)
@@ -103,7 +103,7 @@ static HRESULT invoke_variant_prop(VARIANT *v, WORD flags, DISPPARAMS *dp, VARIA
             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
         }
 
-        hres = VariantCopy(res, v);
+        hres = VariantCopyInd(res, v);
         break;
 
     case DISPATCH_PROPERTYPUT: {
@@ -115,10 +115,15 @@ static HRESULT invoke_variant_prop(VARIANT *v, WORD flags, DISPPARAMS *dp, VARIA
             return DISP_E_PARAMNOTOPTIONAL;
         }
 
+        if(arg_cnt(dp)) {
+            FIXME("Arguments not supported\n");
+            return E_NOTIMPL;
+        }
+
         if(res)
             V_VT(res) = VT_EMPTY;
 
-        hres = VariantCopy(v, put_val);
+        hres = VariantCopyInd(v, put_val);
         break;
     }
 
@@ -222,7 +227,7 @@ static BOOL run_terminator(vbdisp_t *This)
 
     This->ref++;
     exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
-            (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
+            This, &dp, NULL);
     return !--This->ref;
 }
 
@@ -233,6 +238,13 @@ static void clean_props(vbdisp_t *This)
     if(!This->desc)
         return;
 
+    for(i=0; i < This->desc->array_cnt; i++) {
+        if(This->arrays[i]) {
+            SafeArrayDestroy(This->arrays[i]);
+            This->arrays[i] = NULL;
+        }
+    }
+
     for(i=0; i < This->desc->prop_cnt; i++)
         VariantClear(This->props+i);
 }
@@ -285,6 +297,7 @@ static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
     if(!ref && run_terminator(This)) {
         clean_props(This);
         list_remove(&This->entry);
+        heap_free(This->arrays);
         heap_free(This);
     }
 
@@ -378,7 +391,7 @@ static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lc
                 return DISP_E_MEMBERNOTFOUND;
             }
 
-            return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
+            return exec_script(This->desc->ctx, func, This, pdp, pvarRes);
         case DISPATCH_PROPERTYPUT: {
             VARIANT *put_val;
             DISPPARAMS dp = {NULL, NULL, 1, 0};
@@ -401,7 +414,7 @@ static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lc
                 return DISP_E_MEMBERNOTFOUND;
             }
 
-            return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
+            return exec_script(This->desc->ctx, func, This, &dp, NULL);
         }
         default:
             FIXME("flags %x\n", wFlags);
@@ -499,6 +512,7 @@ static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 {
     vbdisp_t *vbdisp;
+    HRESULT hres = S_OK;
 
     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
     if(!vbdisp)
@@ -510,18 +524,46 @@ HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 
     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 
-    if(desc->class_initialize_id) {
-        DISPPARAMS dp = {0};
-        HRESULT hres;
+    if(desc->array_cnt) {
+        vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays));
+        if(vbdisp->arrays) {
+            unsigned i, j;
 
-        hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
-                           (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
-        if(FAILED(hres)) {
-            IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
-            return hres;
+            for(i=0; i < desc->array_cnt; i++) {
+                if(!desc->array_descs[i].dim_cnt)
+                    continue;
+
+                vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds);
+                if(!vbdisp->arrays[i]) {
+                    hres = E_OUTOFMEMORY;
+                    break;
+                }
+            }
+
+            if(SUCCEEDED(hres)) {
+                for(i=0, j=0; i < desc->prop_cnt; i++) {
+                    if(desc->props[i].is_array) {
+                        V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT;
+                        V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++;
+                    }
+                }
+            }
+        }else {
+            hres = E_OUTOFMEMORY;
         }
     }
 
+    if(SUCCEEDED(hres) && desc->class_initialize_id) {
+        DISPPARAMS dp = {0};
+        hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
+                           vbdisp, &dp, NULL);
+    }
+
+    if(FAILED(hres)) {
+        IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
+        return hres;
+    }
+
     *ret = vbdisp;
     return S_OK;
 }
@@ -920,6 +962,69 @@ HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type
     return hres;
 }
 
+#define RPC_E_SERVER_UNAVAILABLE 0x800706ba
+
+HRESULT map_hres(HRESULT hres)
+{
+    if(SUCCEEDED(hres) || HRESULT_FACILITY(hres) == FACILITY_VBS)
+        return hres;
+
+    switch(hres) {
+    case E_NOTIMPL:                  return MAKE_VBSERROR(VBSE_ACTION_NOT_SUPPORTED);
+    case E_NOINTERFACE:              return MAKE_VBSERROR(VBSE_OLE_NOT_SUPPORTED);
+    case DISP_E_UNKNOWNINTERFACE:    return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
+    case DISP_E_MEMBERNOTFOUND:      return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
+    case DISP_E_PARAMNOTFOUND:       return MAKE_VBSERROR(VBSE_NAMED_PARAM_NOT_FOUND);
+    case DISP_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
+    case DISP_E_UNKNOWNNAME:         return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
+    case DISP_E_NONAMEDARGS:         return MAKE_VBSERROR(VBSE_NAMED_ARGS_NOT_SUPPORTED);
+    case DISP_E_BADVARTYPE:          return MAKE_VBSERROR(VBSE_INVALID_TYPELIB_VARIABLE);
+    case DISP_E_OVERFLOW:            return MAKE_VBSERROR(VBSE_OVERFLOW);
+    case DISP_E_BADINDEX:            return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
+    case DISP_E_UNKNOWNLCID:         return MAKE_VBSERROR(VBSE_LOCALE_SETTING_NOT_SUPPORTED);
+    case DISP_E_ARRAYISLOCKED:       return MAKE_VBSERROR(VBSE_ARRAY_LOCKED);
+    case DISP_E_BADPARAMCOUNT:       return MAKE_VBSERROR(VBSE_FUNC_ARITY_MISMATCH);
+    case DISP_E_PARAMNOTOPTIONAL:    return MAKE_VBSERROR(VBSE_PARAMETER_NOT_OPTIONAL);
+    case DISP_E_NOTACOLLECTION:      return MAKE_VBSERROR(VBSE_NOT_ENUM);
+    case TYPE_E_DLLFUNCTIONNOTFOUND: return MAKE_VBSERROR(VBSE_INVALID_DLL_FUNCTION_NAME);
+    case TYPE_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
+    case TYPE_E_OUTOFBOUNDS:         return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
+    case TYPE_E_IOERROR:             return MAKE_VBSERROR(VBSE_IO_ERROR);
+    case TYPE_E_CANTCREATETMPFILE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_TMP_FILE);
+    case STG_E_FILENOTFOUND:         return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
+    case STG_E_PATHNOTFOUND:         return MAKE_VBSERROR(VBSE_PATH_NOT_FOUND);
+    case STG_E_TOOMANYOPENFILES:     return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
+    case STG_E_ACCESSDENIED:         return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case STG_E_INSUFFICIENTMEMORY:   return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
+    case STG_E_NOMOREFILES:          return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
+    case STG_E_DISKISWRITEPROTECTED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case STG_E_WRITEFAULT:           return MAKE_VBSERROR(VBSE_IO_ERROR);
+    case STG_E_READFAULT:            return MAKE_VBSERROR(VBSE_IO_ERROR);
+    case STG_E_SHAREVIOLATION:       return MAKE_VBSERROR(VBSE_PATH_FILE_ACCESS);
+    case STG_E_LOCKVIOLATION:        return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case STG_E_FILEALREADYEXISTS:    return MAKE_VBSERROR(VBSE_FILE_ALREADY_EXISTS);
+    case STG_E_MEDIUMFULL:           return MAKE_VBSERROR(VBSE_DISK_FULL);
+    case STG_E_INVALIDNAME:          return MAKE_VBSERROR(VBSE_FILE_NOT_FOUND);
+    case STG_E_INUSE:                return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case STG_E_NOTCURRENT:           return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case STG_E_CANTSAVE:             return MAKE_VBSERROR(VBSE_IO_ERROR);
+    case REGDB_E_CLASSNOTREG:        return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    case MK_E_UNAVAILABLE:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    case MK_E_INVALIDEXTENSION:      return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
+    case MK_E_CANTOPENFILE:          return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
+    case CO_E_CLASSSTRING:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    case CO_E_APPNOTFOUND:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    case CO_E_APPDIDNTREG:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    case E_ACCESSDENIED:             return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
+    case E_OUTOFMEMORY:              return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
+    case E_INVALIDARG:               return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
+    case RPC_E_SERVER_UNAVAILABLE:   return MAKE_VBSERROR(VBSE_SERVER_NOT_FOUND);
+    case CO_E_SERVER_EXEC_FAILURE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
+    }
+
+    return hres;
+}
+
 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
 {
     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
index 6379028..03aa2a7 100644 (file)
@@ -1596,29 +1596,41 @@ static IRegExpVtbl RegExpVtbl = {
     RegExp_Replace
 };
 
-HRESULT WINAPI VBScriptRegExpFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, void **ppv)
+HRESULT create_regexp(IDispatch **ret)
 {
-    RegExp2 *ret;
+    RegExp2 *regexp;
     HRESULT hres;
 
-    TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
-
     hres = init_regexp_typeinfo(RegExp2_tid);
     if(FAILED(hres))
         return hres;
 
-    ret = heap_alloc_zero(sizeof(*ret));
-    if(!ret)
+    regexp = heap_alloc_zero(sizeof(*regexp));
+    if(!regexp)
         return E_OUTOFMEMORY;
 
-    ret->IRegExp2_iface.lpVtbl = &RegExp2Vtbl;
-    ret->IRegExp_iface.lpVtbl = &RegExpVtbl;
+    regexp->IRegExp2_iface.lpVtbl = &RegExp2Vtbl;
+    regexp->IRegExp_iface.lpVtbl = &RegExpVtbl;
+    regexp->ref = 1;
+    heap_pool_init(&regexp->pool);
 
-    ret->ref = 1;
-    heap_pool_init(&ret->pool);
+    *ret = (IDispatch*)&regexp->IRegExp2_iface;
+    return S_OK;
+}
+
+HRESULT WINAPI VBScriptRegExpFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, void **ppv)
+{
+    IDispatch *regexp;
+    HRESULT hres;
+
+    TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
+
+    hres = create_regexp(&regexp);
+    if(FAILED(hres))
+        return hres;
 
-    hres = IRegExp2_QueryInterface(&ret->IRegExp2_iface, riid, ppv);
-    IRegExp2_Release(&ret->IRegExp2_iface);
+    hres = IDispatch_QueryInterface(regexp, riid, ppv);
+    IDispatch_Release(regexp);
     return hres;
 }
 
index 9ffe555..82eebc2 100644 (file)
@@ -78,14 +78,21 @@ typedef enum {
     VBDISP_ANY
 } vbdisp_invoke_type_t;
 
+typedef struct {
+    unsigned dim_cnt;
+    SAFEARRAYBOUND *bounds;
+} array_desc_t;
+
 typedef struct {
     BOOL is_public;
+    BOOL is_array;
     const WCHAR *name;
 } vbdisp_prop_desc_t;
 
 typedef struct {
     const WCHAR *name;
     BOOL is_public;
+    BOOL is_array;
     function_t *entries[VBDISP_ANY];
 } vbdisp_funcprop_desc_t;
 
@@ -112,6 +119,9 @@ typedef struct _class_desc_t {
     unsigned prop_cnt;
     vbdisp_prop_desc_t *props;
 
+    unsigned array_cnt;
+    array_desc_t *array_descs;
+
     unsigned builtin_prop_cnt;
     const builtin_prop_t *builtin_props;
     ITypeInfo *typeinfo;
@@ -128,6 +138,7 @@ struct _vbdisp_t {
     struct list entry;
 
     const class_desc_t *desc;
+    SAFEARRAY **arrays;
     VARIANT props[1];
 };
 
@@ -153,6 +164,8 @@ void collect_objects(script_ctx_t*) DECLSPEC_HIDDEN;
 HRESULT create_procedure_disp(script_ctx_t*,vbscode_t*,IDispatch**) DECLSPEC_HIDDEN;
 HRESULT create_script_disp(script_ctx_t*,ScriptDisp**) DECLSPEC_HIDDEN;
 
+HRESULT to_int(VARIANT*,int*) DECLSPEC_HIDDEN;
+
 static inline unsigned arg_cnt(const DISPPARAMS *dp)
 {
     return dp->cArgs - dp->cNamedArgs;
@@ -187,6 +200,8 @@ struct _script_ctx_t {
     class_desc_t err_desc;
     vbdisp_t *err_obj;
 
+    HRESULT err_number;
+
     dynamic_var_t *global_vars;
     function_t *global_funcs;
     class_desc_t *classes;
@@ -220,9 +235,11 @@ typedef enum {
     X(assign_ident,   1, ARG_BSTR,    ARG_UINT)   \
     X(assign_member,  1, ARG_BSTR,    ARG_UINT)   \
     X(bool,           1, ARG_INT,     0)          \
+    X(catch,          1, ARG_ADDR,    ARG_UINT)    \
     X(case,           0, ARG_ADDR,    0)          \
     X(concat,         1, 0,           0)          \
     X(const,          1, ARG_BSTR,    0)          \
+    X(dim,            1, ARG_BSTR,    ARG_UINT)   \
     X(div,            1, 0,           0)          \
     X(double,         1, ARG_DOUBLE,  0)          \
     X(empty,          1, 0,           0)          \
@@ -318,6 +335,8 @@ struct _function_t {
     unsigned arg_cnt;
     var_desc_t *vars;
     unsigned var_cnt;
+    array_desc_t *array_descs;
+    unsigned array_cnt;
     unsigned code_off;
     vbscode_t *code_ctx;
     function_t *next;
@@ -342,7 +361,7 @@ struct _vbscode_t {
 
 void release_vbscode(vbscode_t*) DECLSPEC_HIDDEN;
 HRESULT compile_script(script_ctx_t*,const WCHAR*,const WCHAR*,vbscode_t**) DECLSPEC_HIDDEN;
-HRESULT exec_script(script_ctx_t*,function_t*,IDispatch*,DISPPARAMS*,VARIANT*) DECLSPEC_HIDDEN;
+HRESULT exec_script(script_ctx_t*,function_t*,vbdisp_t*,DISPPARAMS*,VARIANT*) DECLSPEC_HIDDEN;
 void release_dynamic_vars(dynamic_var_t*) DECLSPEC_HIDDEN;
 
 typedef struct {
@@ -377,6 +396,43 @@ static inline BOOL is_int32(double d)
     return INT32_MIN <= d && d <= INT32_MAX && (double)(int)d == d;
 }
 
+HRESULT create_regexp(IDispatch**) DECLSPEC_HIDDEN;
+
+HRESULT map_hres(HRESULT) DECLSPEC_HIDDEN;
+
+#define FACILITY_VBS 0xa
+#define MAKE_VBSERROR(code) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_VBS, code)
+
+#define VBSE_ILLEGAL_FUNC_CALL              5
+#define VBSE_OVERFLOW                       6
+#define VBSE_OUT_OF_MEMORY                  7
+#define VBSE_OUT_OF_BOUNDS                  9
+#define VBSE_ARRAY_LOCKED                  10
+#define VBSE_TYPE_MISMATCH                 13
+#define VBSE_FILE_NOT_FOUND                53
+#define VBSE_IO_ERROR                      57
+#define VBSE_FILE_ALREADY_EXISTS           58
+#define VBSE_DISK_FULL                     61
+#define VBSE_TOO_MANY_FILES                67
+#define VBSE_PERMISSION_DENIED             70
+#define VBSE_PATH_FILE_ACCESS              75
+#define VBSE_PATH_NOT_FOUND                76
+#define VBSE_OLE_NOT_SUPPORTED            430
+#define VBSE_OLE_NO_PROP_OR_METHOD        438
+#define VBSE_ACTION_NOT_SUPPORTED         445
+#define VBSE_NAMED_ARGS_NOT_SUPPORTED     446
+#define VBSE_LOCALE_SETTING_NOT_SUPPORTED 447
+#define VBSE_NAMED_PARAM_NOT_FOUND        448
+#define VBSE_INVALID_TYPELIB_VARIABLE     458
+#define VBSE_FUNC_ARITY_MISMATCH          450
+#define VBSE_PARAMETER_NOT_OPTIONAL       449
+#define VBSE_NOT_ENUM                     451
+#define VBSE_INVALID_DLL_FUNCTION_NAME    453
+#define VBSE_CANT_CREATE_TMP_FILE         322
+#define VBSE_OLE_FILE_NOT_FOUND           432
+#define VBSE_CANT_CREATE_OBJECT           429
+#define VBSE_SERVER_NOT_FOUND             462
+
 HRESULT WINAPI VBScriptFactory_CreateInstance(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN;
 HRESULT WINAPI VBScriptRegExpFactory_CreateInstance(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN;
 
index c800e1b..a433d71 100644 (file)
@@ -16,6 +16,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#pragma makedep register
+
 [
     helpstring("VBScript Regular Expression"),
     threading(apartment),
index fb847c1..c2c80d3 100644 (file)
@@ -16,6 +16,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#pragma makedep regtypelib
+
 import "oaidl.idl";
 
 #include "vbscript_defs.h"
index d1f181e..e76ef52 100644 (file)
@@ -16,6 +16,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#pragma makedep regtypelib
+
 import "oaidl.idl";
 
 #include "vbscript_defs.h"
index b6934e0..67d88de 100644 (file)
@@ -16,6 +16,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#pragma makedep regtypelib
+
 import "oaidl.idl";
 
 #include "vbscript_defs.h"
index c1d425d..2ed40a3 100644 (file)
@@ -198,7 +198,7 @@ reactos/dll/win32/url                 # Synced to Wine-1.7.17
 reactos/dll/win32/urlmon              # Synced to Wine-1.7.17
 reactos/dll/win32/usp10               # Synced to Wine-1.7.17
 reactos/dll/win32/uxtheme             # Forked
-reactos/dll/win32/vbscript            # Synced to Wine-1.7.1
+reactos/dll/win32/vbscript            # Synced to Wine-1.7.17
 reactos/dll/win32/version             # Synced to Wine-1.7.1
 reactos/dll/win32/wbemdisp            # Synced to Wine-1.7.17
 reactos/dll/win32/wbemprox            # Synced to Wine-1.7.2