dlls/vbscript/interp.c

   1 /*
   2  * Copyright 2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <assert.h>
  20
  21 #include "vbscript.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  26
  27 static DISPID propput_dispid = DISPID_PROPERTYPUT;
  28
  29 typedef struct {
  30     vbscode_t *code;
  31     instr_t *instr;
  32     script_ctx_t *script;
  33     function_t *func;
  34     vbdisp_t *vbthis;
  35
  36     VARIANT *args;
  37     VARIANT *vars;
  38     SAFEARRAY **arrays;
  39
  40     dynamic_var_t *dynamic_vars;
  41     heap_pool_t heap;
  42
  43     BOOL resume_next;
  44
  45     unsigned stack_size;
  46     unsigned top;
  47     VARIANT *stack;
  48
  49     VARIANT ret_val;
  50 } exec_ctx_t;
  51
  52 typedef HRESULT (*instr_func_t)(exec_ctx_t*);
  53
  54 typedef enum {
  55     REF_NONE,
  56     REF_DISP,
  57     REF_VAR,
  58     REF_OBJ,
  59     REF_CONST,
  60     REF_FUNC
  61 } ref_type_t;
  62
  63 typedef struct {
  64     ref_type_t type;
  65     union {
  66         struct {
  67             IDispatch *disp;
  68             DISPID id;
  69         } d;
  70         VARIANT *v;
  71         function_t *f;
  72         IDispatch *obj;
  73     } u;
  74 } ref_t;
  75
  76 typedef struct {
  77     VARIANT *v;
  78     VARIANT store;
  79     BOOL owned;
  80 } variant_val_t;
  81
  82 static BOOL lookup_dynamic_vars(dynamic_var_t *var, const WCHAR *name, ref_t *ref)
  83 {
  84     while(var) {
  85         if(!wcsicmp(var->name, name)) {
  86             ref->type = var->is_const ? REF_CONST : REF_VAR;
  87             ref->u.v = &var->v;
  88             return TRUE;
  89         }
  90
  91         var = var->next;
  92     }
  93
  94     return FALSE;
  95 }
  96
  97 static BOOL lookup_global_vars(ScriptDisp *script, const WCHAR *name, ref_t *ref)
  98 {
  99     dynamic_var_t **vars = script->global_vars;
 100     size_t i, cnt = script->global_vars_cnt;
 101
 102     for(i = 0; i < cnt; i++) {
 103         if(!wcsicmp(vars[i]->name, name)) {
 104             ref->type = vars[i]->is_const ? REF_CONST : REF_VAR;
 105             ref->u.v = &vars[i]->v;
 106             return TRUE;
 107         }
 108     }
 109
 110     return FALSE;
 111 }
 112
 113 static BOOL lookup_global_funcs(ScriptDisp *script, const WCHAR *name, ref_t *ref)
 114 {
 115     function_t **funcs = script->global_funcs;
 116     size_t i, cnt = script->global_funcs_cnt;
 117
 118     for(i = 0; i < cnt; i++) {
 119         if(!wcsicmp(funcs[i]->name, name)) {
 120             ref->type = REF_FUNC;
 121             ref->u.f = funcs[i];
 122             return TRUE;
 123         }
 124     }
 125
 126     return FALSE;
 127 }
 128
 129 static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_t invoke_type, ref_t *ref)
 130 {
 131     ScriptDisp *script_obj = ctx->script->script_obj;
 132     named_item_t *item;
 133     unsigned i;
 134     DISPID id;
 135     HRESULT hres;
 136
 137     if((ctx->func->type == FUNC_FUNCTION || ctx->func->type == FUNC_PROPGET || ctx->func->type == FUNC_DEFGET)
 138        && !wcsicmp(name, ctx->func->name)) {
 139         ref->type = REF_VAR;
 140         ref->u.v = &ctx->ret_val;
 141         return S_OK;
 142     }
 143
 144     if(ctx->func->type != FUNC_GLOBAL) {
 145         for(i=0; i < ctx->func->var_cnt; i++) {
 146             if(!wcsicmp(ctx->func->vars[i].name, name)) {
 147                 ref->type = REF_VAR;
 148                 ref->u.v = ctx->vars+i;
 149                 return TRUE;
 150             }
 151         }
 152
 153         for(i=0; i < ctx->func->arg_cnt; i++) {
 154             if(!wcsicmp(ctx->func->args[i].name, name)) {
 155                 ref->type = REF_VAR;
 156                 ref->u.v = ctx->args+i;
 157                 return S_OK;
 158             }
 159         }
 160
 161         if(lookup_dynamic_vars(ctx->dynamic_vars, name, ref))
 162             return S_OK;
 163
 164         if(ctx->vbthis) {
 165             /* FIXME: Bind such identifier while generating bytecode. */
 166             for(i=0; i < ctx->vbthis->desc->prop_cnt; i++) {
 167                 if(!wcsicmp(ctx->vbthis->desc->props[i].name, name)) {
 168                     ref->type = REF_VAR;
 169                     ref->u.v = ctx->vbthis->props+i;
 170                     return S_OK;
 171                 }
 172             }
 173
 174             hres = vbdisp_get_id(ctx->vbthis, name, invoke_type, TRUE, &id);
 175             if(SUCCEEDED(hres)) {
 176                 ref->type = REF_DISP;
 177                 ref->u.d.disp = (IDispatch*)&ctx->vbthis->IDispatchEx_iface;
 178                 ref->u.d.id = id;
 179                 return S_OK;
 180             }
 181         }
 182     }
 183
 184     if(ctx->code->named_item) {
 185         if(lookup_global_vars(ctx->code->named_item->script_obj, name, ref))
 186             return S_OK;
 187         if(lookup_global_funcs(ctx->code->named_item->script_obj, name, ref))
 188             return S_OK;
 189     }
 190
 191     if(ctx->func->code_ctx->named_item && ctx->func->code_ctx->named_item->disp &&
 192        !(ctx->func->code_ctx->named_item->flags & SCRIPTITEM_CODEONLY))
 193     {
 194         hres = disp_get_id(ctx->func->code_ctx->named_item->disp, name, invoke_type, TRUE, &id);
 195         if(SUCCEEDED(hres)) {
 196             ref->type = REF_DISP;
 197             ref->u.d.disp = ctx->func->code_ctx->named_item->disp;
 198             ref->u.d.id = id;
 199             return S_OK;
 200         }
 201     }
 202
 203     if(lookup_global_vars(script_obj, name, ref))
 204         return S_OK;
 205     if(lookup_global_funcs(script_obj, name, ref))
 206         return S_OK;
 207
 208     hres = get_builtin_id(ctx->script->global_obj, name, &id);
 209     if(SUCCEEDED(hres)) {
 210         ref->type = REF_DISP;
 211         ref->u.d.disp = &ctx->script->global_obj->IDispatch_iface;
 212         ref->u.d.id = id;
 213         return S_OK;
 214     }
 215
 216     item = lookup_named_item(ctx->script, name, SCRIPTITEM_ISVISIBLE);
 217     if(item && item->disp) {
 218         ref->type = REF_OBJ;
 219         ref->u.obj = item->disp;
 220         return S_OK;
 221     }
 222
 223     LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
 224         if((item->flags & SCRIPTITEM_GLOBALMEMBERS)) {
 225             hres = disp_get_id(item->disp, name, invoke_type, FALSE, &id);
 226             if(SUCCEEDED(hres)) {
 227                 ref->type = REF_DISP;
 228                 ref->u.d.disp = item->disp;
 229                 ref->u.d.id = id;
 230                 return S_OK;
 231             }
 232         }
 233     }
 234
 235     ref->type = REF_NONE;
 236     return S_OK;
 237 }
 238
 239 static HRESULT add_dynamic_var(exec_ctx_t *ctx, const WCHAR *name,
 240         BOOL is_const, VARIANT **out_var)
 241 {
 242     ScriptDisp *script_obj = ctx->code->named_item ? ctx->code->named_item->script_obj : ctx->script->script_obj;
 243     dynamic_var_t *new_var;
 244     heap_pool_t *heap;
 245     WCHAR *str;
 246     unsigned size;
 247
 248     heap = ctx->func->type == FUNC_GLOBAL ? &script_obj->heap : &ctx->heap;
 249
 250     new_var = heap_pool_alloc(heap, sizeof(*new_var));
 251     if(!new_var)
 252         return E_OUTOFMEMORY;
 253
 254     size = (lstrlenW(name)+1)*sizeof(WCHAR);
 255     str = heap_pool_alloc(heap, size);
 256     if(!str)
 257         return E_OUTOFMEMORY;
 258     memcpy(str, name, size);
 259     new_var->name = str;
 260     new_var->is_const = is_const;
 261     new_var->array = NULL;
 262     V_VT(&new_var->v) = VT_EMPTY;
 263
 264     if(ctx->func->type == FUNC_GLOBAL) {
 265         size_t cnt = script_obj->global_vars_cnt + 1;
 266         if(cnt > script_obj->global_vars_size) {
 267             dynamic_var_t **new_vars;
 268             if(script_obj->global_vars)
 269                 new_vars = heap_realloc(script_obj->global_vars, cnt * 2 * sizeof(*new_vars));
 270             else
 271                 new_vars = heap_alloc(cnt * 2 * sizeof(*new_vars));
 272             if(!new_vars)
 273                 return E_OUTOFMEMORY;
 274             script_obj->global_vars = new_vars;
 275             script_obj->global_vars_size = cnt * 2;
 276         }
 277         script_obj->global_vars[script_obj->global_vars_cnt++] = new_var;
 278     }else {
 279         new_var->next = ctx->dynamic_vars;
 280         ctx->dynamic_vars = new_var;
 281     }
 282
 283     *out_var = &new_var->v;
 284     return S_OK;
 285 }
 286
 287 void clear_ei(EXCEPINFO *ei)
 288 {
 289     SysFreeString(ei->bstrSource);
 290     SysFreeString(ei->bstrDescription);
 291     SysFreeString(ei->bstrHelpFile);
 292     memset(ei, 0, sizeof(*ei));
 293 }
 294
 295 static void clear_error_loc(script_ctx_t *ctx)
 296 {
 297     if(ctx->error_loc_code) {
 298         release_vbscode(ctx->error_loc_code);
 299         ctx->error_loc_code = NULL;
 300     }
 301 }
 302
 303 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
 304 {
 305     assert(ctx->top);
 306     return ctx->stack + --ctx->top;
 307 }
 308
 309 static inline VARIANT *stack_top(exec_ctx_t *ctx, unsigned n)
 310 {
 311     assert(ctx->top >= n);
 312     return ctx->stack + (ctx->top-n-1);
 313 }
 314
 315 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
 316 {
 317     if(ctx->stack_size == ctx->top) {
 318         VARIANT *new_stack;
 319
 320         new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack));
 321         if(!new_stack) {
 322             VariantClear(v);
 323             return E_OUTOFMEMORY;
 324         }
 325
 326         ctx->stack = new_stack;
 327         ctx->stack_size *= 2;
 328     }
 329
 330     ctx->stack[ctx->top++] = *v;
 331     return S_OK;
 332 }
 333
 334 static inline HRESULT stack_push_null(exec_ctx_t *ctx)
 335 {
 336     VARIANT v;
 337     V_VT(&v) = VT_NULL;
 338     return stack_push(ctx, &v);
 339 }
 340
 341 static void stack_popn(exec_ctx_t *ctx, unsigned n)
 342 {
 343     while(n--)
 344         VariantClear(stack_pop(ctx));
 345 }
 346
 347 static void stack_pop_deref(exec_ctx_t *ctx, variant_val_t *r)
 348 {
 349     VARIANT *v;
 350
 351     v = stack_pop(ctx);
 352     if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
 353         r->owned = FALSE;
 354         r->v = V_VARIANTREF(v);
 355     }else {
 356         r->owned = TRUE;
 357         r->v = v;
 358     }
 359 }
 360
 361 static inline void release_val(variant_val_t *v)
 362 {
 363     if(v->owned)
 364         VariantClear(v->v);
 365 }
 366
 367 static HRESULT stack_pop_val(exec_ctx_t *ctx, variant_val_t *r)
 368 {
 369     stack_pop_deref(ctx, r);
 370
 371     if(V_VT(r->v) == VT_DISPATCH) {
 372         HRESULT hres;
 373
 374         hres = get_disp_value(ctx->script, V_DISPATCH(r->v), &r->store);
 375         if(r->owned && V_DISPATCH(r->v))
 376             IDispatch_Release(V_DISPATCH(r->v));
 377         if(FAILED(hres))
 378             return hres;
 379
 380         r->owned = TRUE;
 381         r->v = &r->store;
 382     }
 383
 384     return S_OK;
 385 }
 386
 387 static HRESULT stack_assume_val(exec_ctx_t *ctx, unsigned n)
 388 {
 389     VARIANT *v = stack_top(ctx, n);
 390     HRESULT hres;
 391
 392     if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
 393         VARIANT *ref = V_VARIANTREF(v);
 394
 395         V_VT(v) = VT_EMPTY;
 396         hres = VariantCopy(v, ref);
 397         if(FAILED(hres))
 398             return hres;
 399     }
 400
 401     if(V_VT(v) == VT_DISPATCH) {
 402         IDispatch *disp;
 403
 404         disp = V_DISPATCH(v);
 405         hres = get_disp_value(ctx->script, disp, v);
 406         if(disp)
 407             IDispatch_Release(disp);
 408         if(FAILED(hres))
 409             return hres;
 410     }
 411
 412     return S_OK;
 413 }
 414
 415 static int stack_pop_bool(exec_ctx_t *ctx, BOOL *b)
 416 {
 417     variant_val_t val;
 418     HRESULT hres;
 419
 420     hres = stack_pop_val(ctx, &val);
 421     if(FAILED(hres))
 422         return hres;
 423
 424     switch (V_VT(val.v))
 425     {
 426     case VT_BOOL:
 427         *b = V_BOOL(val.v);
 428         break;
 429     case VT_NULL:
 430     case VT_EMPTY:
 431         *b = FALSE;
 432         break;
 433     case VT_I2:
 434         *b = V_I2(val.v);
 435         break;
 436     case VT_I4:
 437         *b = V_I4(val.v);
 438         break;
 439     default:
 440         FIXME("unsupported for %s\n", debugstr_variant(val.v));
 441         release_val(&val);
 442         return E_NOTIMPL;
 443     }
 444     return S_OK;
 445 }
 446
 447 static HRESULT stack_pop_disp(exec_ctx_t *ctx, IDispatch **ret)
 448 {
 449     VARIANT *v = stack_pop(ctx);
 450
 451     if(V_VT(v) == VT_DISPATCH) {
 452         *ret = V_DISPATCH(v);
 453         return S_OK;
 454     }
 455
 456     if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
 457         FIXME("not supported type: %s\n", debugstr_variant(v));
 458         VariantClear(v);
 459         return E_FAIL;
 460     }
 461
 462     v = V_BYREF(v);
 463     if(V_VT(v) != VT_DISPATCH) {
 464         FIXME("not disp %s\n", debugstr_variant(v));
 465         return E_FAIL;
 466     }
 467
 468     if(V_DISPATCH(v))
 469         IDispatch_AddRef(V_DISPATCH(v));
 470     *ret = V_DISPATCH(v);
 471     return S_OK;
 472 }
 473
 474 static HRESULT stack_assume_disp(exec_ctx_t *ctx, unsigned n, IDispatch **disp)
 475 {
 476     VARIANT *v = stack_top(ctx, n), *ref;
 477
 478     if(V_VT(v) != VT_DISPATCH && (disp || V_VT(v) != VT_UNKNOWN)) {
 479         if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
 480             FIXME("not supported type: %s\n", debugstr_variant(v));
 481             return E_FAIL;
 482         }
 483
 484         ref = V_VARIANTREF(v);
 485         if(V_VT(ref) != VT_DISPATCH && (disp || V_VT(ref) != VT_UNKNOWN)) {
 486             FIXME("not disp %s\n", debugstr_variant(ref));
 487             return E_FAIL;
 488         }
 489
 490         V_VT(v) = V_VT(ref);
 491         V_UNKNOWN(v) = V_UNKNOWN(ref);
 492         if(V_UNKNOWN(v))
 493             IUnknown_AddRef(V_UNKNOWN(v));
 494     }
 495
 496     if(disp)
 497         *disp = V_DISPATCH(v);
 498     return S_OK;
 499 }
 500
 501 static inline void instr_jmp(exec_ctx_t *ctx, unsigned addr)
 502 {
 503     ctx->instr = ctx->code->instrs + addr;
 504 }
 505
 506 static void vbstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, BOOL is_propput, DISPPARAMS *dp)
 507 {
 508     dp->cNamedArgs = is_propput ? 1 : 0;
 509     dp->cArgs = arg_cnt + dp->cNamedArgs;
 510     dp->rgdispidNamedArgs = is_propput ? &propput_dispid : NULL;
 511
 512     if(arg_cnt) {
 513         VARIANT tmp;
 514         unsigned i;
 515
 516         assert(ctx->top >= arg_cnt);
 517
 518         for(i=1; i*2 <= arg_cnt; i++) {
 519             tmp = ctx->stack[ctx->top-i];
 520             ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
 521             ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
 522         }
 523
 524         dp->rgvarg = ctx->stack + ctx->top-dp->cArgs;
 525     }else {
 526         dp->rgvarg = is_propput ? ctx->stack+ctx->top-1 : NULL;
 527     }
 528 }
 529
 530 static HRESULT array_access(exec_ctx_t *ctx, SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
 531 {
 532     unsigned i, argc = arg_cnt(dp);
 533     LONG *indices;
 534     HRESULT hres;
 535
 536     if(!array) {
 537         FIXME("NULL array\n");
 538         return E_FAIL;
 539     }
 540
 541     hres = SafeArrayLock(array);
 542     if(FAILED(hres))
 543         return hres;
 544
 545     if(array->cDims != argc) {
 546         FIXME("argc %d does not match cDims %d\n", dp->cArgs, array->cDims);
 547         SafeArrayUnlock(array);
 548         return E_FAIL;
 549     }
 550
 551     indices = heap_alloc(sizeof(*indices) * argc);
 552     if(!indices) {
 553         SafeArrayUnlock(array);
 554         return E_OUTOFMEMORY;
 555     }
 556
 557     for(i=0; i<argc; i++) {
 558         hres = to_int(get_arg(dp, i), indices+i);
 559         if(FAILED(hres)) {
 560             heap_free(indices);
 561             SafeArrayUnlock(array);
 562             return hres;
 563         }
 564     }
 565
 566     hres = SafeArrayPtrOfIndex(array, indices, (void**)ret);
 567     SafeArrayUnlock(array);
 568     heap_free(indices);
 569     return hres;
 570 }
 571
 572 static HRESULT variant_call(exec_ctx_t *ctx, VARIANT *v, unsigned arg_cnt, VARIANT *res)
 573 {
 574     SAFEARRAY *array = NULL;
 575     DISPPARAMS dp;
 576     HRESULT hres;
 577
 578     TRACE("%s\n", debugstr_variant(v));
 579
 580     if(V_VT(v) == (VT_VARIANT|VT_BYREF))
 581         v = V_VARIANTREF(v);
 582
 583     switch(V_VT(v)) {
 584     case VT_ARRAY|VT_BYREF|VT_VARIANT:
 585         array = *V_ARRAYREF(v);
 586         break;
 587     case VT_ARRAY|VT_VARIANT:
 588         array = V_ARRAY(v);
 589         break;
 590     case VT_DISPATCH:
 591         vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
 592         hres = disp_call(ctx->script, V_DISPATCH(v), DISPID_VALUE, &dp, res);
 593         break;
 594     default:
 595         FIXME("unsupported on %s\n", debugstr_variant(v));
 596         return E_NOTIMPL;
 597     }
 598
 599     if(array) {
 600         if(!res) {
 601             FIXME("no res\n");
 602             return E_NOTIMPL;
 603         }
 604
 605         vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
 606         hres = array_access(ctx, array, &dp, &v);
 607         if(FAILED(hres))
 608             return hres;
 609
 610         V_VT(res) = VT_BYREF|VT_VARIANT;
 611         V_BYREF(res) = v;
 612     }
 613
 614     stack_popn(ctx, arg_cnt);
 615     return S_OK;
 616 }
 617
 618 static HRESULT do_icall(exec_ctx_t *ctx, VARIANT *res)
 619 {
 620     BSTR identifier = ctx->instr->arg1.bstr;
 621     const unsigned arg_cnt = ctx->instr->arg2.uint;
 622     DISPPARAMS dp;
 623     ref_t ref;
 624     HRESULT hres;
 625
 626     TRACE("%s %u\n", debugstr_w(identifier), arg_cnt);
 627
 628     hres = lookup_identifier(ctx, identifier, VBDISP_CALLGET, &ref);
 629     if(FAILED(hres))
 630         return hres;
 631
 632     switch(ref.type) {
 633     case REF_VAR:
 634     case REF_CONST:
 635         if(arg_cnt)
 636             return variant_call(ctx, ref.u.v, arg_cnt, res);
 637
 638         if(!res) {
 639             FIXME("REF_VAR no res\n");
 640             return E_NOTIMPL;
 641         }
 642
 643         V_VT(res) = VT_BYREF|VT_VARIANT;
 644         V_BYREF(res) = V_VT(ref.u.v) == (VT_VARIANT|VT_BYREF) ? V_VARIANTREF(ref.u.v) : ref.u.v;
 645         break;
 646     case REF_DISP:
 647         vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
 648         hres = disp_call(ctx->script, ref.u.d.disp, ref.u.d.id, &dp, res);
 649         if(FAILED(hres))
 650             return hres;
 651         break;
 652     case REF_FUNC:
 653         vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
 654         hres = exec_script(ctx->script, FALSE, ref.u.f, NULL, &dp, res);
 655         if(FAILED(hres))
 656             return hres;
 657         break;
 658     case REF_OBJ:
 659         if(arg_cnt) {
 660             FIXME("arguments on object\n");
 661             return E_NOTIMPL;
 662         }
 663
 664         if(res) {
 665             IDispatch_AddRef(ref.u.obj);
 666             V_VT(res) = VT_DISPATCH;
 667             V_DISPATCH(res) = ref.u.obj;
 668         }
 669         break;
 670     case REF_NONE:
 671         if(res && !ctx->func->code_ctx->option_explicit && arg_cnt == 0) {
 672             VARIANT *new;
 673             hres = add_dynamic_var(ctx, identifier, FALSE, &new);
 674             if(FAILED(hres))
 675                 return hres;
 676             V_VT(res) = VT_BYREF|VT_VARIANT;
 677             V_BYREF(res) = new;
 678             break;
 679         }
 680         FIXME("%s not found\n", debugstr_w(identifier));
 681         return DISP_E_UNKNOWNNAME;
 682     }
 683
 684     stack_popn(ctx, arg_cnt);
 685     return S_OK;
 686 }
 687
 688 static HRESULT interp_icall(exec_ctx_t *ctx)
 689 {
 690     VARIANT v;
 691     HRESULT hres;
 692
 693     TRACE("\n");
 694
 695     hres = do_icall(ctx, &v);
 696     if(FAILED(hres))
 697         return hres;
 698
 699     return stack_push(ctx, &v);
 700 }
 701
 702 static HRESULT interp_icallv(exec_ctx_t *ctx)
 703 {
 704     TRACE("\n");
 705     return do_icall(ctx, NULL);
 706 }
 707
 708 static HRESULT interp_vcall(exec_ctx_t *ctx)
 709 {
 710     const unsigned arg_cnt = ctx->instr->arg1.uint;
 711     VARIANT res, *v;
 712     HRESULT hres;
 713
 714     TRACE("\n");
 715
 716     v = stack_pop(ctx);
 717     hres = variant_call(ctx, v, arg_cnt, &res);
 718     VariantClear(v);
 719     if(FAILED(hres))
 720         return hres;
 721
 722     return stack_push(ctx, &res);
 723 }
 724
 725 static HRESULT interp_vcallv(exec_ctx_t *ctx)
 726 {
 727     const unsigned arg_cnt = ctx->instr->arg1.uint;
 728     VARIANT *v;
 729     HRESULT hres;
 730
 731     TRACE("\n");
 732
 733     v = stack_pop(ctx);
 734     hres = variant_call(ctx, v, arg_cnt, NULL);
 735     VariantClear(v);
 736     return hres;
 737 }
 738
 739 static HRESULT do_mcall(exec_ctx_t *ctx, VARIANT *res)
 740 {
 741     const BSTR identifier = ctx->instr->arg1.bstr;
 742     const unsigned arg_cnt = ctx->instr->arg2.uint;
 743     IDispatch *obj;
 744     DISPPARAMS dp;
 745     DISPID id;
 746     HRESULT hres;
 747
 748     hres = stack_pop_disp(ctx, &obj);
 749     if(FAILED(hres))
 750         return hres;
 751
 752     if(!obj) {
 753         FIXME("NULL obj\n");
 754         return E_FAIL;
 755     }
 756
 757     vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
 758
 759     hres = disp_get_id(obj, identifier, VBDISP_CALLGET, FALSE, &id);
 760     if(SUCCEEDED(hres))
 761         hres = disp_call(ctx->script, obj, id, &dp, res);
 762     IDispatch_Release(obj);
 763     if(FAILED(hres))
 764         return hres;
 765
 766     stack_popn(ctx, arg_cnt);
 767     return S_OK;
 768 }
 769
 770 static HRESULT interp_mcall(exec_ctx_t *ctx)
 771 {
 772     VARIANT res;
 773     HRESULT hres;
 774
 775     TRACE("\n");
 776
 777     hres = do_mcall(ctx, &res);
 778     if(FAILED(hres))
 779         return hres;
 780
 781     return stack_push(ctx, &res);
 782 }
 783
 784 static HRESULT interp_mcallv(exec_ctx_t *ctx)
 785 {
 786     TRACE("\n");
 787
 788     return do_mcall(ctx, NULL);
 789 }
 790
 791 static HRESULT assign_value(exec_ctx_t *ctx, VARIANT *dst, VARIANT *src, WORD flags)
 792 {
 793     VARIANT value;
 794     HRESULT hres;
 795
 796     V_VT(&value) = VT_EMPTY;
 797     hres = VariantCopyInd(&value, src);
 798     if(FAILED(hres))
 799         return hres;
 800
 801     if(V_VT(&value) == VT_DISPATCH && !(flags & DISPATCH_PROPERTYPUTREF)) {
 802         IDispatch *disp = V_DISPATCH(&value);
 803
 804         V_VT(&value) = VT_EMPTY;
 805         hres = get_disp_value(ctx->script, disp, &value);
 806         if(disp)
 807             IDispatch_Release(disp);
 808         if(FAILED(hres))
 809             return hres;
 810     }
 811
 812     VariantClear(dst);
 813     *dst = value;
 814     return S_OK;
 815 }
 816
 817 static HRESULT assign_ident(exec_ctx_t *ctx, BSTR name, WORD flags, DISPPARAMS *dp)
 818 {
 819     ref_t ref;
 820     HRESULT hres;
 821
 822     hres = lookup_identifier(ctx, name, VBDISP_LET, &ref);
 823     if(FAILED(hres))
 824         return hres;
 825
 826     switch(ref.type) {
 827     case REF_VAR: {
 828         VARIANT *v = ref.u.v;
 829
 830         if(V_VT(v) == (VT_VARIANT|VT_BYREF))
 831             v = V_VARIANTREF(v);
 832
 833         if(arg_cnt(dp)) {
 834             SAFEARRAY *array;
 835
 836             if(V_VT(v) == VT_DISPATCH) {
 837                 hres = disp_propput(ctx->script, V_DISPATCH(v), DISPID_VALUE, flags, dp);
 838                 break;
 839             }
 840
 841             if(!(V_VT(v) & VT_ARRAY)) {
 842                 FIXME("array assign on type %d\n", V_VT(v));
 843                 return E_FAIL;
 844             }
 845
 846             switch(V_VT(v)) {
 847             case VT_ARRAY|VT_BYREF|VT_VARIANT:
 848                 array = *V_ARRAYREF(v);
 849                 break;
 850             case VT_ARRAY|VT_VARIANT:
 851                 array = V_ARRAY(v);
 852                 break;
 853             default:
 854                 FIXME("Unsupported array type %x\n", V_VT(v));
 855                 return E_NOTIMPL;
 856             }
 857
 858             if(!array) {
 859                 FIXME("null array\n");
 860                 return E_FAIL;
 861             }
 862
 863             hres = array_access(ctx, array, dp, &v);
 864             if(FAILED(hres))
 865                 return hres;
 866         }else if(V_VT(v) == (VT_ARRAY|VT_BYREF|VT_VARIANT)) {
 867             FIXME("non-array assign\n");
 868             return E_NOTIMPL;
 869         }
 870
 871         hres = assign_value(ctx, v, dp->rgvarg, flags);
 872         break;
 873     }
 874     case REF_DISP:
 875         hres = disp_propput(ctx->script, ref.u.d.disp, ref.u.d.id, flags, dp);
 876         break;
 877     case REF_FUNC:
 878         FIXME("functions not implemented\n");
 879         return E_NOTIMPL;
 880     case REF_OBJ:
 881         FIXME("REF_OBJ\n");
 882         return E_NOTIMPL;
 883     case REF_CONST:
 884         FIXME("REF_CONST\n");
 885         return E_NOTIMPL;
 886     case REF_NONE:
 887         if(ctx->func->code_ctx->option_explicit) {
 888             FIXME("throw exception\n");
 889             hres = E_FAIL;
 890         }else {
 891             VARIANT *new_var;
 892
 893             if(arg_cnt(dp)) {
 894                 FIXME("arg_cnt %d not supported\n", arg_cnt(dp));
 895                 return E_NOTIMPL;
 896             }
 897
 898             TRACE("creating variable %s\n", debugstr_w(name));
 899             hres = add_dynamic_var(ctx, name, FALSE, &new_var);
 900             if(SUCCEEDED(hres))
 901                 hres = assign_value(ctx, new_var, dp->rgvarg, flags);
 902         }
 903     }
 904
 905     return hres;
 906 }
 907
 908 static HRESULT interp_assign_ident(exec_ctx_t *ctx)
 909 {
 910     const BSTR arg = ctx->instr->arg1.bstr;
 911     const unsigned arg_cnt = ctx->instr->arg2.uint;
 912     DISPPARAMS dp;
 913     HRESULT hres;
 914
 915     TRACE("%s\n", debugstr_w(arg));
 916
 917     vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
 918     hres = assign_ident(ctx, arg, DISPATCH_PROPERTYPUT, &dp);
 919     if(FAILED(hres))
 920         return hres;
 921
 922     stack_popn(ctx, arg_cnt+1);
 923     return S_OK;
 924 }
 925
 926 static HRESULT interp_set_ident(exec_ctx_t *ctx)
 927 {
 928     const BSTR arg = ctx->instr->arg1.bstr;
 929     const unsigned arg_cnt = ctx->instr->arg2.uint;
 930     DISPPARAMS dp;
 931     HRESULT hres;
 932
 933     TRACE("%s %u\n", debugstr_w(arg), arg_cnt);
 934
 935     hres = stack_assume_disp(ctx, arg_cnt, NULL);
 936     if(FAILED(hres))
 937         return hres;
 938
 939     vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
 940     hres = assign_ident(ctx, arg, DISPATCH_PROPERTYPUTREF, &dp);
 941     if(FAILED(hres))
 942         return hres;
 943
 944     stack_popn(ctx, arg_cnt + 1);
 945     return S_OK;
 946 }
 947
 948 static HRESULT interp_assign_member(exec_ctx_t *ctx)
 949 {
 950     BSTR identifier = ctx->instr->arg1.bstr;
 951     const unsigned arg_cnt = ctx->instr->arg2.uint;
 952     IDispatch *obj;
 953     DISPPARAMS dp;
 954     DISPID id;
 955     HRESULT hres;
 956
 957     TRACE("%s\n", debugstr_w(identifier));
 958
 959     hres = stack_assume_disp(ctx, arg_cnt+1, &obj);
 960     if(FAILED(hres))
 961         return hres;
 962
 963     if(!obj) {
 964         FIXME("NULL obj\n");
 965         return E_FAIL;
 966     }
 967
 968     hres = disp_get_id(obj, identifier, VBDISP_LET, FALSE, &id);
 969     if(SUCCEEDED(hres)) {
 970         vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
 971         hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUT, &dp);
 972     }
 973     if(FAILED(hres))
 974         return hres;
 975
 976     stack_popn(ctx, arg_cnt+2);
 977     return S_OK;
 978 }
 979
 980 static HRESULT interp_set_member(exec_ctx_t *ctx)
 981 {
 982     BSTR identifier = ctx->instr->arg1.bstr;
 983     const unsigned arg_cnt = ctx->instr->arg2.uint;
 984     IDispatch *obj;
 985     DISPPARAMS dp;
 986     DISPID id;
 987     HRESULT hres;
 988
 989     TRACE("%s\n", debugstr_w(identifier));
 990
 991     if(arg_cnt) {
 992         FIXME("arguments not supported\n");
 993         return E_NOTIMPL;
 994     }
 995
 996     hres = stack_assume_disp(ctx, 1, &obj);
 997     if(FAILED(hres))
 998         return hres;
 999
1000     if(!obj) {
1001         FIXME("NULL obj\n");
1002         return E_FAIL;
1003     }
1004
1005     hres = stack_assume_disp(ctx, 0, NULL);
1006     if(FAILED(hres))
1007         return hres;
1008
1009     hres = disp_get_id(obj, identifier, VBDISP_SET, FALSE, &id);
1010     if(SUCCEEDED(hres)) {
1011         vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
1012         hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUTREF, &dp);
1013     }
1014     if(FAILED(hres))
1015         return hres;
1016
1017     stack_popn(ctx, 2);
1018     return S_OK;
1019 }
1020
1021 static HRESULT interp_const(exec_ctx_t *ctx)
1022 {
1023     BSTR arg = ctx->instr->arg1.bstr;
1024     VARIANT *v;
1025     ref_t ref;
1026     HRESULT hres;
1027
1028     TRACE("%s\n", debugstr_w(arg));
1029
1030     assert(ctx->func->type == FUNC_GLOBAL);
1031
1032     hres = lookup_identifier(ctx, arg, VBDISP_CALLGET, &ref);
1033     if(FAILED(hres))
1034         return hres;
1035
1036     if(ref.type != REF_NONE) {
1037         FIXME("%s already defined\n", debugstr_w(arg));
1038         return E_FAIL;
1039     }
1040
1041     hres = stack_assume_val(ctx, 0);
1042     if(FAILED(hres))
1043         return hres;
1044
1045     hres = add_dynamic_var(ctx, arg, TRUE, &v);
1046     if(FAILED(hres))
1047         return hres;
1048
1049     *v = *stack_pop(ctx);
1050     return S_OK;
1051 }
1052
1053 static HRESULT interp_val(exec_ctx_t *ctx)
1054 {
1055     variant_val_t val;
1056     VARIANT v;
1057     HRESULT hres;
1058
1059     TRACE("\n");
1060
1061     hres = stack_pop_val(ctx, &val);
1062     if(FAILED(hres))
1063         return hres;
1064
1065     if(!val.owned) {
1066         V_VT(&v) = VT_EMPTY;
1067         hres = VariantCopy(&v, val.v);
1068         if(FAILED(hres))
1069             return hres;
1070     }
1071
1072     return stack_push(ctx, val.owned ? val.v : &v);
1073 }
1074
1075 static HRESULT interp_pop(exec_ctx_t *ctx)
1076 {
1077     const unsigned n = ctx->instr->arg1.uint;
1078
1079     TRACE("%u\n", n);
1080
1081     stack_popn(ctx, n);
1082     return S_OK;
1083 }
1084
1085 static HRESULT interp_stack(exec_ctx_t *ctx)
1086 {
1087     const unsigned n = ctx->instr->arg1.uint;
1088     VARIANT v;
1089     HRESULT hres;
1090
1091     TRACE("%#x\n", n);
1092
1093     if(n == ~0)
1094         return MAKE_VBSERROR(505);
1095     assert(n < ctx->top);
1096
1097     V_VT(&v) = VT_EMPTY;
1098     hres = VariantCopy(&v, ctx->stack + n);
1099     if(FAILED(hres))
1100         return hres;
1101
1102     return stack_push(ctx, &v);
1103 }
1104
1105 static HRESULT interp_deref(exec_ctx_t *ctx)
1106 {
1107     VARIANT copy, *v = stack_top(ctx, 0);
1108     HRESULT hres;
1109
1110     TRACE("%s\n", debugstr_variant(v));
1111
1112     if(V_VT(v) != (VT_BYREF|VT_VARIANT))
1113         return S_OK;
1114
1115     V_VT(&copy) = VT_EMPTY;
1116     hres = VariantCopy(&copy, V_VARIANTREF(v));
1117     if(SUCCEEDED(hres))
1118         *v = copy;
1119     return hres;
1120 }
1121
1122 static HRESULT interp_new(exec_ctx_t *ctx)
1123 {
1124     const WCHAR *arg = ctx->instr->arg1.bstr;
1125     class_desc_t *class_desc = NULL;
1126     vbdisp_t *obj;
1127     VARIANT v;
1128     HRESULT hres;
1129
1130     static const WCHAR regexpW[] = {'r','e','g','e','x','p',0};
1131
1132     TRACE("%s\n", debugstr_w(arg));
1133
1134     if(!wcsicmp(arg, regexpW)) {
1135         V_VT(&v) = VT_DISPATCH;
1136         hres = create_regexp(&V_DISPATCH(&v));
1137         if(FAILED(hres))
1138             return hres;
1139
1140         return stack_push(ctx, &v);
1141     }
1142
1143     if(ctx->code->named_item)
1144         for(class_desc = ctx->code->named_item->script_obj->classes; class_desc; class_desc = class_desc->next)
1145             if(!wcsicmp(class_desc->name, arg))
1146                 break;
1147     if(!class_desc)
1148         for(class_desc = ctx->script->script_obj->classes; class_desc; class_desc = class_desc->next)
1149             if(!wcsicmp(class_desc->name, arg))
1150                 break;
1151     if(!class_desc) {
1152         FIXME("Class %s not found\n", debugstr_w(arg));
1153         return E_FAIL;
1154     }
1155
1156     hres = create_vbdisp(class_desc, &obj);
1157     if(FAILED(hres))
1158         return hres;
1159
1160     V_VT(&v) = VT_DISPATCH;
1161     V_DISPATCH(&v) = (IDispatch*)&obj->IDispatchEx_iface;
1162     return stack_push(ctx, &v);
1163 }
1164
1165 static HRESULT interp_dim(exec_ctx_t *ctx)
1166 {
1167     ScriptDisp *script_obj = ctx->code->named_item ? ctx->code->named_item->script_obj : ctx->script->script_obj;
1168     const BSTR ident = ctx->instr->arg1.bstr;
1169     const unsigned array_id = ctx->instr->arg2.uint;
1170     const array_desc_t *array_desc;
1171     SAFEARRAY **array_ref;
1172     VARIANT *v;
1173     HRESULT hres;
1174
1175     TRACE("%s\n", debugstr_w(ident));
1176
1177     assert(array_id < ctx->func->array_cnt);
1178
1179     if(ctx->func->type == FUNC_GLOBAL) {
1180         unsigned i;
1181         for(i = 0; i < script_obj->global_vars_cnt; i++) {
1182             if(!wcsicmp(script_obj->global_vars[i]->name, ident))
1183                 break;
1184         }
1185         assert(i < script_obj->global_vars_cnt);
1186         v = &script_obj->global_vars[i]->v;
1187         array_ref = &script_obj->global_vars[i]->array;
1188     }else {
1189         ref_t ref;
1190
1191         if(!ctx->arrays) {
1192             ctx->arrays = heap_alloc_zero(ctx->func->array_cnt * sizeof(SAFEARRAY*));
1193             if(!ctx->arrays)
1194                 return E_OUTOFMEMORY;
1195         }
1196
1197         hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
1198         if(FAILED(hres)) {
1199             FIXME("lookup %s failed: %08x\n", debugstr_w(ident), hres);
1200             return hres;
1201         }
1202
1203         if(ref.type != REF_VAR) {
1204             FIXME("got ref.type = %d\n", ref.type);
1205             return E_FAIL;
1206         }
1207
1208         v = ref.u.v;
1209         array_ref = ctx->arrays + array_id;
1210     }
1211
1212     if(*array_ref) {
1213         FIXME("Array already initialized\n");
1214         return E_FAIL;
1215     }
1216
1217     array_desc = ctx->func->array_descs + array_id;
1218     if(array_desc->dim_cnt) {
1219         *array_ref = SafeArrayCreate(VT_VARIANT, array_desc->dim_cnt, array_desc->bounds);
1220         if(!*array_ref)
1221             return E_OUTOFMEMORY;
1222     }
1223
1224     V_VT(v) = VT_ARRAY|VT_BYREF|VT_VARIANT;
1225     V_ARRAYREF(v) = array_ref;
1226     return S_OK;
1227 }
1228
1229 static HRESULT array_bounds_from_stack(exec_ctx_t *ctx, unsigned dim_cnt, SAFEARRAYBOUND **ret)
1230 {
1231     SAFEARRAYBOUND *bounds;
1232     unsigned i;
1233     int dim;
1234     HRESULT hres;
1235
1236     if(!(bounds = heap_alloc(dim_cnt * sizeof(*bounds))))
1237         return E_OUTOFMEMORY;
1238
1239     for(i = 0; i < dim_cnt; i++) {
1240         hres = to_int(stack_top(ctx, dim_cnt - i - 1), &dim);
1241         if(FAILED(hres)) {
1242             heap_free(bounds);
1243             return hres;
1244         }
1245
1246         bounds[i].cElements = dim + 1;
1247         bounds[i].lLbound = 0;
1248     }
1249
1250     stack_popn(ctx, dim_cnt);
1251     *ret = bounds;
1252     return S_OK;
1253 }
1254
1255 static HRESULT interp_redim(exec_ctx_t *ctx)
1256 {
1257     BSTR identifier = ctx->instr->arg1.bstr;
1258     const unsigned dim_cnt = ctx->instr->arg2.uint;
1259     SAFEARRAYBOUND *bounds;
1260     SAFEARRAY *array;
1261     ref_t ref;
1262     HRESULT hres;
1263
1264     TRACE("%s %u\n", debugstr_w(identifier), dim_cnt);
1265
1266     hres = lookup_identifier(ctx, identifier, VBDISP_LET, &ref);
1267     if(FAILED(hres)) {
1268         FIXME("lookup %s failed: %08x\n", debugstr_w(identifier), hres);
1269         return hres;
1270     }
1271
1272     if(ref.type != REF_VAR) {
1273         FIXME("got ref.type = %d\n", ref.type);
1274         return E_FAIL;
1275     }
1276
1277     hres = array_bounds_from_stack(ctx, dim_cnt, &bounds);
1278     if(FAILED(hres))
1279         return hres;
1280
1281     array = SafeArrayCreate(VT_VARIANT, dim_cnt, bounds);
1282     heap_free(bounds);
1283     if(!array)
1284         return E_OUTOFMEMORY;
1285
1286     /* FIXME: We should check if we're not modifying an existing static array here */
1287
1288     VariantClear(ref.u.v);
1289     V_VT(ref.u.v) = VT_ARRAY|VT_VARIANT;
1290     V_ARRAY(ref.u.v) = array;
1291     return S_OK;
1292 }
1293
1294 static HRESULT interp_step(exec_ctx_t *ctx)
1295 {
1296     const BSTR ident = ctx->instr->arg2.bstr;
1297     BOOL gteq_zero;
1298     VARIANT zero;
1299     ref_t ref;
1300     HRESULT hres;
1301
1302     TRACE("%s\n", debugstr_w(ident));
1303
1304     V_VT(&zero) = VT_I2;
1305     V_I2(&zero) = 0;
1306     hres = VarCmp(stack_top(ctx, 0), &zero, ctx->script->lcid, 0);
1307     if(FAILED(hres))
1308         return hres;
1309
1310     gteq_zero = hres == VARCMP_GT || hres == VARCMP_EQ;
1311
1312     hres = lookup_identifier(ctx, ident, VBDISP_ANY, &ref);
1313     if(FAILED(hres))
1314         return hres;
1315
1316     if(ref.type != REF_VAR) {
1317         FIXME("%s is not REF_VAR\n", debugstr_w(ident));
1318         return E_FAIL;
1319     }
1320
1321     hres = VarCmp(ref.u.v, stack_top(ctx, 1), ctx->script->lcid, 0);
1322     if(FAILED(hres))
1323         return hres;
1324
1325     if(hres == VARCMP_EQ || hres == (gteq_zero ? VARCMP_LT : VARCMP_GT)) {
1326         ctx->instr++;
1327     }else {
1328         stack_popn(ctx, 2);
1329         instr_jmp(ctx, ctx->instr->arg1.uint);
1330     }
1331     return S_OK;
1332 }
1333
1334 static HRESULT interp_newenum(exec_ctx_t *ctx)
1335 {
1336     variant_val_t v;
1337     VARIANT *r;
1338     HRESULT hres;
1339
1340     TRACE("\n");
1341
1342     stack_pop_deref(ctx, &v);
1343     assert(V_VT(stack_top(ctx, 0)) == VT_EMPTY);
1344     r = stack_top(ctx, 0);
1345
1346     switch(V_VT(v.v)) {
1347     case VT_DISPATCH|VT_BYREF:
1348     case VT_DISPATCH: {
1349         IEnumVARIANT *iter;
1350         DISPPARAMS dp = {0};
1351         VARIANT iterv;
1352
1353         hres = disp_call(ctx->script, V_ISBYREF(v.v) ? *V_DISPATCHREF(v.v) : V_DISPATCH(v.v), DISPID_NEWENUM, &dp, &iterv);
1354         release_val(&v);
1355         if(FAILED(hres))
1356             return hres;
1357
1358         if(V_VT(&iterv) != VT_UNKNOWN && V_VT(&iterv) != VT_DISPATCH) {
1359             FIXME("Unsupported iterv %s\n", debugstr_variant(&iterv));
1360             VariantClear(&iterv);
1361             return hres;
1362         }
1363
1364         hres = IUnknown_QueryInterface(V_UNKNOWN(&iterv), &IID_IEnumVARIANT, (void**)&iter);
1365         IUnknown_Release(V_UNKNOWN(&iterv));
1366         if(FAILED(hres)) {
1367             FIXME("Could not get IEnumVARIANT iface: %08x\n", hres);
1368             return hres;
1369         }
1370
1371         V_VT(r) = VT_UNKNOWN;
1372         V_UNKNOWN(r) = (IUnknown*)iter;
1373         break;
1374     }
1375     case VT_VARIANT|VT_ARRAY:
1376     case VT_VARIANT|VT_ARRAY|VT_BYREF: {
1377         IEnumVARIANT *iter;
1378
1379         hres = create_safearray_iter(V_ISBYREF(v.v) ? *V_ARRAYREF(v.v) : V_ARRAY(v.v), &iter);
1380         if(FAILED(hres))
1381             return hres;
1382
1383         V_VT(r) = VT_UNKNOWN;
1384         V_UNKNOWN(r) = (IUnknown*)iter;
1385         break;
1386     }
1387     default:
1388         FIXME("Unsupported for %s\n", debugstr_variant(v.v));
1389         release_val(&v);
1390         return E_NOTIMPL;
1391     }
1392
1393     return S_OK;
1394 }
1395
1396 static HRESULT interp_enumnext(exec_ctx_t *ctx)
1397 {
1398     const unsigned loop_end = ctx->instr->arg1.uint;
1399     const BSTR ident = ctx->instr->arg2.bstr;
1400     VARIANT v;
1401     DISPPARAMS dp = {&v, &propput_dispid, 1, 1};
1402     IEnumVARIANT *iter;
1403     BOOL do_continue;
1404     HRESULT hres;
1405
1406     TRACE("\n");
1407
1408     if(V_VT(stack_top(ctx, 0)) == VT_EMPTY) {
1409         FIXME("uninitialized\n");
1410         return E_FAIL;
1411     }
1412
1413     assert(V_VT(stack_top(ctx, 0)) == VT_UNKNOWN);
1414     iter = (IEnumVARIANT*)V_UNKNOWN(stack_top(ctx, 0));
1415
1416     V_VT(&v) = VT_EMPTY;
1417     hres = IEnumVARIANT_Next(iter, 1, &v, NULL);
1418     if(FAILED(hres))
1419         return hres;
1420
1421     do_continue = hres == S_OK;
1422     hres = assign_ident(ctx, ident, DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &dp);
1423     VariantClear(&v);
1424     if(FAILED(hres))
1425         return hres;
1426
1427     if(do_continue) {
1428         ctx->instr++;
1429     }else {
1430         stack_popn(ctx, 1);
1431         instr_jmp(ctx, loop_end);
1432     }
1433     return S_OK;
1434 }
1435
1436 static HRESULT interp_jmp(exec_ctx_t *ctx)
1437 {
1438     const unsigned arg = ctx->instr->arg1.uint;
1439
1440     TRACE("%u\n", arg);
1441
1442     instr_jmp(ctx, arg);
1443     return S_OK;
1444 }
1445
1446 static HRESULT interp_jmp_false(exec_ctx_t *ctx)
1447 {
1448     const unsigned arg = ctx->instr->arg1.uint;
1449     HRESULT hres;
1450     BOOL b;
1451
1452     TRACE("%u\n", arg);
1453
1454     hres = stack_pop_bool(ctx, &b);
1455     if(FAILED(hres))
1456         return hres;
1457
1458     if(b)
1459         ctx->instr++;
1460     else
1461         instr_jmp(ctx, ctx->instr->arg1.uint);
1462     return S_OK;
1463 }
1464
1465 static HRESULT interp_jmp_true(exec_ctx_t *ctx)
1466 {
1467     const unsigned arg = ctx->instr->arg1.uint;
1468     HRESULT hres;
1469     BOOL b;
1470
1471     TRACE("%u\n", arg);
1472
1473     hres = stack_pop_bool(ctx, &b);
1474     if(FAILED(hres))
1475         return hres;
1476
1477     if(b)
1478         instr_jmp(ctx, ctx->instr->arg1.uint);
1479     else
1480         ctx->instr++;
1481     return S_OK;
1482 }
1483
1484 static HRESULT interp_ret(exec_ctx_t *ctx)
1485 {
1486     TRACE("\n");
1487
1488     ctx->instr = NULL;
1489     return S_OK;
1490 }
1491
1492 static HRESULT interp_retval(exec_ctx_t *ctx)
1493 {
1494     variant_val_t val;
1495     HRESULT hres;
1496
1497     TRACE("\n");
1498
1499     stack_pop_deref(ctx, &val);
1500
1501     if(val.owned) {
1502         VariantClear(&ctx->ret_val);
1503         ctx->ret_val = *val.v;
1504     }
1505     else {
1506         hres = VariantCopy(&ctx->ret_val, val.v);
1507         if(FAILED(hres))
1508             return hres;
1509     }
1510
1511     return S_OK;
1512 }
1513
1514 static HRESULT interp_stop(exec_ctx_t *ctx)
1515 {
1516     WARN("\n");
1517
1518     /* NOTE: this should have effect in debugging mode (that we don't support yet) */
1519     return S_OK;
1520 }
1521
1522 static HRESULT interp_me(exec_ctx_t *ctx)
1523 {
1524     IDispatch *disp;
1525     VARIANT v;
1526
1527     TRACE("\n");
1528
1529     if(ctx->vbthis) {
1530         disp = (IDispatch*)&ctx->vbthis->IDispatchEx_iface;
1531     }else if(ctx->code->named_item) {
1532         disp = (ctx->code->named_item->flags & SCRIPTITEM_CODEONLY)
1533                ? (IDispatch*)&ctx->code->named_item->script_obj->IDispatchEx_iface
1534                : ctx->code->named_item->disp;
1535     }else {
1536         named_item_t *item;
1537         disp = NULL;
1538         LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
1539             if(!(item->flags & SCRIPTITEM_GLOBALMEMBERS)) continue;
1540             disp = item->disp;
1541             break;
1542         }
1543         if(!disp)
1544             disp = (IDispatch*)&ctx->script->script_obj->IDispatchEx_iface;
1545     }
1546
1547     IDispatch_AddRef(disp);
1548     V_VT(&v) = VT_DISPATCH;
1549     V_DISPATCH(&v) = disp;
1550     return stack_push(ctx, &v);
1551 }
1552
1553 static HRESULT interp_bool(exec_ctx_t *ctx)
1554 {
1555     const VARIANT_BOOL arg = ctx->instr->arg1.lng;
1556     VARIANT v;
1557
1558     TRACE("%s\n", arg ? "true" : "false");
1559
1560     V_VT(&v) = VT_BOOL;
1561     V_BOOL(&v) = arg;
1562     return stack_push(ctx, &v);
1563 }
1564
1565 static HRESULT interp_errmode(exec_ctx_t *ctx)
1566 {
1567     const int err_mode = ctx->instr->arg1.uint;
1568
1569     TRACE("%d\n", err_mode);
1570
1571     ctx->resume_next = err_mode;
1572     clear_ei(&ctx->script->ei);
1573     return S_OK;
1574 }
1575
1576 static HRESULT interp_string(exec_ctx_t *ctx)
1577 {
1578     VARIANT v;
1579
1580     TRACE("\n");
1581
1582     V_VT(&v) = VT_BSTR;
1583     V_BSTR(&v) = SysAllocString(ctx->instr->arg1.str);
1584     if(!V_BSTR(&v))
1585         return E_OUTOFMEMORY;
1586
1587     return stack_push(ctx, &v);
1588 }
1589
1590 static HRESULT interp_int(exec_ctx_t *ctx)
1591 {
1592     const LONG arg = ctx->instr->arg1.lng;
1593     VARIANT v;
1594
1595     TRACE("%d\n", arg);
1596
1597     if(arg == (INT16)arg) {
1598         V_VT(&v) = VT_I2;
1599         V_I2(&v) = arg;
1600     }else {
1601         V_VT(&v) = VT_I4;
1602         V_I4(&v) = arg;
1603     }
1604     return stack_push(ctx, &v);
1605 }
1606
1607 static HRESULT interp_double(exec_ctx_t *ctx)
1608 {
1609     const DOUBLE *arg = ctx->instr->arg1.dbl;
1610     VARIANT v;
1611
1612     TRACE("%lf\n", *arg);
1613
1614     V_VT(&v) = VT_R8;
1615     V_R8(&v) = *arg;
1616     return stack_push(ctx, &v);
1617 }
1618
1619 static HRESULT interp_empty(exec_ctx_t *ctx)
1620 {
1621     VARIANT v;
1622
1623     TRACE("\n");
1624
1625     V_VT(&v) = VT_EMPTY;
1626     return stack_push(ctx, &v);
1627 }
1628
1629 static HRESULT interp_null(exec_ctx_t *ctx)
1630 {
1631     TRACE("\n");
1632     return stack_push_null(ctx);
1633 }
1634
1635 static HRESULT interp_nothing(exec_ctx_t *ctx)
1636 {
1637     VARIANT v;
1638
1639     TRACE("\n");
1640
1641     V_VT(&v) = VT_DISPATCH;
1642     V_DISPATCH(&v) = NULL;
1643     return stack_push(ctx, &v);
1644 }
1645
1646 static HRESULT interp_hres(exec_ctx_t *ctx)
1647 {
1648     const unsigned arg = ctx->instr->arg1.uint;
1649     VARIANT v;
1650
1651     TRACE("%d\n", arg);
1652
1653     V_VT(&v) = VT_ERROR;
1654     V_ERROR(&v) = arg;
1655     return stack_push(ctx, &v);
1656 }
1657
1658 static HRESULT interp_not(exec_ctx_t *ctx)
1659 {
1660     variant_val_t val;
1661     VARIANT v;
1662     HRESULT hres;
1663
1664     TRACE("\n");
1665
1666     hres = stack_pop_val(ctx, &val);
1667     if(FAILED(hres))
1668         return hres;
1669
1670     hres = VarNot(val.v, &v);
1671     release_val(&val);
1672     if(FAILED(hres))
1673         return hres;
1674
1675     return stack_push(ctx, &v);
1676 }
1677
1678 static HRESULT interp_and(exec_ctx_t *ctx)
1679 {
1680     variant_val_t r, l;
1681     VARIANT v;
1682     HRESULT hres;
1683
1684     TRACE("\n");
1685
1686     hres = stack_pop_val(ctx, &r);
1687     if(FAILED(hres))
1688         return hres;
1689
1690     hres = stack_pop_val(ctx, &l);
1691     if(SUCCEEDED(hres)) {
1692         hres = VarAnd(l.v, r.v, &v);
1693         release_val(&l);
1694     }
1695     release_val(&r);
1696     if(FAILED(hres))
1697         return hres;
1698
1699     return stack_push(ctx, &v);
1700 }
1701
1702 static HRESULT interp_or(exec_ctx_t *ctx)
1703 {
1704     variant_val_t r, l;
1705     VARIANT v;
1706     HRESULT hres;
1707
1708     TRACE("\n");
1709
1710     hres = stack_pop_val(ctx, &r);
1711     if(FAILED(hres))
1712         return hres;
1713
1714     hres = stack_pop_val(ctx, &l);
1715     if(SUCCEEDED(hres)) {
1716         hres = VarOr(l.v, r.v, &v);
1717         release_val(&l);
1718     }
1719     release_val(&r);
1720     if(FAILED(hres))
1721         return hres;
1722
1723     return stack_push(ctx, &v);
1724 }
1725
1726 static HRESULT interp_xor(exec_ctx_t *ctx)
1727 {
1728     variant_val_t r, l;
1729     VARIANT v;
1730     HRESULT hres;
1731
1732     TRACE("\n");
1733
1734     hres = stack_pop_val(ctx, &r);
1735     if(FAILED(hres))
1736         return hres;
1737
1738     hres = stack_pop_val(ctx, &l);
1739     if(SUCCEEDED(hres)) {
1740         hres = VarXor(l.v, r.v, &v);
1741         release_val(&l);
1742     }
1743     release_val(&r);
1744     if(FAILED(hres))
1745         return hres;
1746
1747     return stack_push(ctx, &v);
1748 }
1749
1750 static HRESULT interp_eqv(exec_ctx_t *ctx)
1751 {
1752     variant_val_t r, l;
1753     VARIANT v;
1754     HRESULT hres;
1755
1756     TRACE("\n");
1757
1758     hres = stack_pop_val(ctx, &r);
1759     if(FAILED(hres))
1760         return hres;
1761
1762     hres = stack_pop_val(ctx, &l);
1763     if(SUCCEEDED(hres)) {
1764         hres = VarEqv(l.v, r.v, &v);
1765         release_val(&l);
1766     }
1767     release_val(&r);
1768     if(FAILED(hres))
1769         return hres;
1770
1771     return stack_push(ctx, &v);
1772 }
1773
1774 static HRESULT interp_imp(exec_ctx_t *ctx)
1775 {
1776     variant_val_t r, l;
1777     VARIANT v;
1778     HRESULT hres;
1779
1780     TRACE("\n");
1781
1782     hres = stack_pop_val(ctx, &r);
1783     if(FAILED(hres))
1784         return hres;
1785
1786     hres = stack_pop_val(ctx, &l);
1787     if(SUCCEEDED(hres)) {
1788         hres = VarImp(l.v, r.v, &v);
1789         release_val(&l);
1790     }
1791     release_val(&r);
1792     if(FAILED(hres))
1793         return hres;
1794
1795     return stack_push(ctx, &v);
1796 }
1797
1798 static HRESULT var_cmp(exec_ctx_t *ctx, VARIANT *l, VARIANT *r)
1799 {
1800     TRACE("%s %s\n", debugstr_variant(l), debugstr_variant(r));
1801
1802     /* FIXME: Fix comparing string to number */
1803
1804     return VarCmp(l, r, ctx->script->lcid, 0);
1805  }
1806
1807 static HRESULT cmp_oper(exec_ctx_t *ctx)
1808 {
1809     variant_val_t l, r;
1810     HRESULT hres;
1811
1812     hres = stack_pop_val(ctx, &r);
1813     if(FAILED(hres))
1814         return hres;
1815
1816     hres = stack_pop_val(ctx, &l);
1817     if(SUCCEEDED(hres)) {
1818         hres = var_cmp(ctx, l.v, r.v);
1819         release_val(&l);
1820     }
1821
1822     release_val(&r);
1823     return hres;
1824 }
1825
1826 static HRESULT interp_equal(exec_ctx_t *ctx)
1827 {
1828     VARIANT v;
1829     HRESULT hres;
1830
1831     TRACE("\n");
1832
1833     hres = cmp_oper(ctx);
1834     if(FAILED(hres))
1835         return hres;
1836     if(hres == VARCMP_NULL)
1837         return stack_push_null(ctx);
1838
1839     V_VT(&v) = VT_BOOL;
1840     V_BOOL(&v) = hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1841     return stack_push(ctx, &v);
1842 }
1843
1844 static HRESULT interp_nequal(exec_ctx_t *ctx)
1845 {
1846     VARIANT v;
1847     HRESULT hres;
1848
1849     TRACE("\n");
1850
1851     hres = cmp_oper(ctx);
1852     if(FAILED(hres))
1853         return hres;
1854     if(hres == VARCMP_NULL)
1855         return stack_push_null(ctx);
1856
1857     V_VT(&v) = VT_BOOL;
1858     V_BOOL(&v) = hres != VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1859     return stack_push(ctx, &v);
1860 }
1861
1862 static HRESULT interp_gt(exec_ctx_t *ctx)
1863 {
1864     VARIANT v;
1865     HRESULT hres;
1866
1867     TRACE("\n");
1868
1869     hres = cmp_oper(ctx);
1870     if(FAILED(hres))
1871         return hres;
1872     if(hres == VARCMP_NULL)
1873         return stack_push_null(ctx);
1874
1875     V_VT(&v) = VT_BOOL;
1876     V_BOOL(&v) = hres == VARCMP_GT ? VARIANT_TRUE : VARIANT_FALSE;
1877     return stack_push(ctx, &v);
1878 }
1879
1880 static HRESULT interp_gteq(exec_ctx_t *ctx)
1881 {
1882     VARIANT v;
1883     HRESULT hres;
1884
1885     TRACE("\n");
1886
1887     hres = cmp_oper(ctx);
1888     if(FAILED(hres))
1889         return hres;
1890     if(hres == VARCMP_NULL)
1891         return stack_push_null(ctx);
1892
1893     V_VT(&v) = VT_BOOL;
1894     V_BOOL(&v) = hres == VARCMP_GT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1895     return stack_push(ctx, &v);
1896 }
1897
1898 static HRESULT interp_lt(exec_ctx_t *ctx)
1899 {
1900     VARIANT v;
1901     HRESULT hres;
1902
1903     TRACE("\n");
1904
1905     hres = cmp_oper(ctx);
1906     if(FAILED(hres))
1907         return hres;
1908     if(hres == VARCMP_NULL)
1909         return stack_push_null(ctx);
1910
1911     V_VT(&v) = VT_BOOL;
1912     V_BOOL(&v) = hres == VARCMP_LT ? VARIANT_TRUE : VARIANT_FALSE;
1913     return stack_push(ctx, &v);
1914 }
1915
1916 static HRESULT interp_lteq(exec_ctx_t *ctx)
1917 {
1918     VARIANT v;
1919     HRESULT hres;
1920
1921     TRACE("\n");
1922
1923     hres = cmp_oper(ctx);
1924     if(FAILED(hres))
1925         return hres;
1926     if(hres == VARCMP_NULL)
1927         return stack_push_null(ctx);
1928
1929     V_VT(&v) = VT_BOOL;
1930     V_BOOL(&v) = hres == VARCMP_LT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1931     return stack_push(ctx, &v);
1932 }
1933
1934 static HRESULT interp_case(exec_ctx_t *ctx)
1935 {
1936     const unsigned arg = ctx->instr->arg1.uint;
1937     variant_val_t v;
1938     HRESULT hres;
1939
1940     TRACE("%d\n", arg);
1941
1942     hres = stack_pop_val(ctx, &v);
1943     if(FAILED(hres))
1944         return hres;
1945
1946     hres = var_cmp(ctx, stack_top(ctx, 0), v.v);
1947     release_val(&v);
1948     if(FAILED(hres))
1949         return hres;
1950
1951     if(hres == VARCMP_EQ) {
1952         stack_popn(ctx, 1);
1953         instr_jmp(ctx, arg);
1954     }else {
1955         ctx->instr++;
1956     }
1957
1958     return S_OK;
1959 }
1960
1961 static HRESULT interp_is(exec_ctx_t *ctx)
1962 {
1963     IUnknown *l = NULL, *r = NULL;
1964     variant_val_t v;
1965     HRESULT hres = S_OK;
1966
1967     TRACE("\n");
1968
1969     stack_pop_deref(ctx, &v);
1970     if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
1971         FIXME("Unhandled type %s\n", debugstr_variant(v.v));
1972         hres = E_NOTIMPL;
1973     }else if(V_UNKNOWN(v.v)) {
1974         hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&r);
1975     }
1976     if(v.owned) VariantClear(v.v);
1977     if(FAILED(hres))
1978         return hres;
1979
1980     stack_pop_deref(ctx, &v);
1981     if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
1982         FIXME("Unhandled type %s\n", debugstr_variant(v.v));
1983         hres = E_NOTIMPL;
1984     }else if(V_UNKNOWN(v.v)) {
1985         hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&l);
1986     }
1987     if(v.owned) VariantClear(v.v);
1988
1989     if(SUCCEEDED(hres)) {
1990         VARIANT res;
1991         V_VT(&res) = VT_BOOL;
1992         if(r == l)
1993             V_BOOL(&res) = VARIANT_TRUE;
1994         else if(!r || !l)
1995             V_BOOL(&res) = VARIANT_FALSE;
1996         else {
1997             IObjectIdentity *identity;
1998             hres = IUnknown_QueryInterface(l, &IID_IObjectIdentity, (void**)&identity);
1999             if(SUCCEEDED(hres)) {
2000                 hres = IObjectIdentity_IsEqualObject(identity, r);
2001                 IObjectIdentity_Release(identity);
2002             }
2003             V_BOOL(&res) = hres == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
2004         }
2005         hres = stack_push(ctx, &res);
2006     }
2007     if(r)
2008         IUnknown_Release(r);
2009     if(l)
2010         IUnknown_Release(l);
2011     return hres;
2012 }
2013
2014 static HRESULT interp_concat(exec_ctx_t *ctx)
2015 {
2016     variant_val_t r, l;
2017     VARIANT v;
2018     HRESULT hres;
2019
2020     TRACE("\n");
2021
2022     hres = stack_pop_val(ctx, &r);
2023     if(FAILED(hres))
2024         return hres;
2025
2026     hres = stack_pop_val(ctx, &l);
2027     if(SUCCEEDED(hres)) {
2028         hres = VarCat(l.v, r.v, &v);
2029         release_val(&l);
2030     }
2031     release_val(&r);
2032     if(FAILED(hres))
2033         return hres;
2034
2035     return stack_push(ctx, &v);
2036 }
2037
2038 static HRESULT interp_add(exec_ctx_t *ctx)
2039 {
2040     variant_val_t r, l;
2041     VARIANT v;
2042     HRESULT hres;
2043
2044     TRACE("\n");
2045
2046     hres = stack_pop_val(ctx, &r);
2047     if(FAILED(hres))
2048         return hres;
2049
2050     hres = stack_pop_val(ctx, &l);
2051     if(SUCCEEDED(hres)) {
2052         hres = VarAdd(l.v, r.v, &v);
2053         release_val(&l);
2054     }
2055     release_val(&r);
2056     if(FAILED(hres))
2057         return hres;
2058
2059     return stack_push(ctx, &v);
2060 }
2061
2062 static HRESULT interp_sub(exec_ctx_t *ctx)
2063 {
2064     variant_val_t r, l;
2065     VARIANT v;
2066     HRESULT hres;
2067
2068     TRACE("\n");
2069
2070     hres = stack_pop_val(ctx, &r);
2071     if(FAILED(hres))
2072         return hres;
2073
2074     hres = stack_pop_val(ctx, &l);
2075     if(SUCCEEDED(hres)) {
2076         hres = VarSub(l.v, r.v, &v);
2077         release_val(&l);
2078     }
2079     release_val(&r);
2080     if(FAILED(hres))
2081         return hres;
2082
2083     return stack_push(ctx, &v);
2084 }
2085
2086 static HRESULT interp_mod(exec_ctx_t *ctx)
2087 {
2088     variant_val_t r, l;
2089     VARIANT v;
2090     HRESULT hres;
2091
2092     TRACE("\n");
2093
2094     hres = stack_pop_val(ctx, &r);
2095     if(FAILED(hres))
2096         return hres;
2097
2098     hres = stack_pop_val(ctx, &l);
2099     if(SUCCEEDED(hres)) {
2100         hres = VarMod(l.v, r.v, &v);
2101         release_val(&l);
2102     }
2103     release_val(&r);
2104     if(FAILED(hres))
2105         return hres;
2106
2107     return stack_push(ctx, &v);
2108 }
2109
2110 static HRESULT interp_idiv(exec_ctx_t *ctx)
2111 {
2112     variant_val_t r, l;
2113     VARIANT v;
2114     HRESULT hres;
2115
2116     TRACE("\n");
2117
2118     hres = stack_pop_val(ctx, &r);
2119     if(FAILED(hres))
2120         return hres;
2121
2122     hres = stack_pop_val(ctx, &l);
2123     if(SUCCEEDED(hres)) {
2124         hres = VarIdiv(l.v, r.v, &v);
2125         release_val(&l);
2126     }
2127     release_val(&r);
2128     if(FAILED(hres))
2129         return hres;
2130
2131     return stack_push(ctx, &v);
2132 }
2133
2134 static HRESULT interp_div(exec_ctx_t *ctx)
2135 {
2136     variant_val_t r, l;
2137     VARIANT v;
2138     HRESULT hres;
2139
2140     TRACE("\n");
2141
2142     hres = stack_pop_val(ctx, &r);
2143     if(FAILED(hres))
2144         return hres;
2145
2146     hres = stack_pop_val(ctx, &l);
2147     if(SUCCEEDED(hres)) {
2148         hres = VarDiv(l.v, r.v, &v);
2149         release_val(&l);
2150     }
2151     release_val(&r);
2152     if(FAILED(hres))
2153         return hres;
2154
2155     return stack_push(ctx, &v);
2156 }
2157
2158 static HRESULT interp_mul(exec_ctx_t *ctx)
2159 {
2160     variant_val_t r, l;
2161     VARIANT v;
2162     HRESULT hres;
2163
2164     TRACE("\n");
2165
2166     hres = stack_pop_val(ctx, &r);
2167     if(FAILED(hres))
2168         return hres;
2169
2170     hres = stack_pop_val(ctx, &l);
2171     if(SUCCEEDED(hres)) {
2172         hres = VarMul(l.v, r.v, &v);
2173         release_val(&l);
2174     }
2175     release_val(&r);
2176     if(FAILED(hres))
2177         return hres;
2178
2179     return stack_push(ctx, &v);
2180 }
2181
2182 static HRESULT interp_exp(exec_ctx_t *ctx)
2183 {
2184     variant_val_t r, l;
2185     VARIANT v;
2186     HRESULT hres;
2187
2188     TRACE("\n");
2189
2190     hres = stack_pop_val(ctx, &r);
2191     if(FAILED(hres))
2192         return hres;
2193
2194     hres = stack_pop_val(ctx, &l);
2195     if(SUCCEEDED(hres)) {
2196         hres = VarPow(l.v, r.v, &v);
2197         release_val(&l);
2198     }
2199     release_val(&r);
2200     if(FAILED(hres))
2201         return hres;
2202
2203     return stack_push(ctx, &v);
2204 }
2205
2206 static HRESULT interp_neg(exec_ctx_t *ctx)
2207 {
2208     variant_val_t val;
2209     VARIANT v;
2210     HRESULT hres;
2211
2212     hres = stack_pop_val(ctx, &val);
2213     if(FAILED(hres))
2214         return hres;
2215
2216     hres = VarNeg(val.v, &v);
2217     release_val(&val);
2218     if(FAILED(hres))
2219         return hres;
2220
2221     return stack_push(ctx, &v);
2222 }
2223
2224 static HRESULT interp_incc(exec_ctx_t *ctx)
2225 {
2226     const BSTR ident = ctx->instr->arg1.bstr;
2227     VARIANT v;
2228     ref_t ref;
2229     HRESULT hres;
2230
2231     TRACE("\n");
2232
2233     hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
2234     if(FAILED(hres))
2235         return hres;
2236
2237     if(ref.type != REF_VAR) {
2238         FIXME("ref.type is not REF_VAR\n");
2239         return E_FAIL;
2240     }
2241
2242     hres = VarAdd(stack_top(ctx, 0), ref.u.v, &v);
2243     if(FAILED(hres))
2244         return hres;
2245
2246     VariantClear(ref.u.v);
2247     *ref.u.v = v;
2248     return S_OK;
2249 }
2250
2251 static HRESULT interp_catch(exec_ctx_t *ctx)
2252 {
2253     /* Nothing to do here, the OP is for unwinding only. */
2254     return S_OK;
2255 }
2256
2257 static const instr_func_t op_funcs[] = {
2258 #define X(x,n,a,b) interp_ ## x,
2259 OP_LIST
2260 #undef X
2261 };
2262
2263 static const unsigned op_move[] = {
2264 #define X(x,n,a,b) n,
2265 OP_LIST
2266 #undef X
2267 };
2268
2269 void release_dynamic_var(dynamic_var_t *var)
2270 {
2271     VariantClear(&var->v);
2272     if(var->array)
2273         SafeArrayDestroy(var->array);
2274 }
2275
2276 static void release_exec(exec_ctx_t *ctx)
2277 {
2278     dynamic_var_t *var;
2279     unsigned i;
2280
2281     VariantClear(&ctx->ret_val);
2282
2283     for(var = ctx->dynamic_vars; var; var = var->next)
2284         release_dynamic_var(var);
2285
2286     if(ctx->vbthis)
2287         IDispatchEx_Release(&ctx->vbthis->IDispatchEx_iface);
2288
2289     if(ctx->args) {
2290         for(i=0; i < ctx->func->arg_cnt; i++)
2291             VariantClear(ctx->args+i);
2292     }
2293
2294     if(ctx->vars) {
2295         for(i=0; i < ctx->func->var_cnt; i++)
2296             VariantClear(ctx->vars+i);
2297     }
2298
2299     if(ctx->arrays) {
2300         for(i=0; i < ctx->func->array_cnt; i++) {
2301             if(ctx->arrays[i])
2302                 SafeArrayDestroy(ctx->arrays[i]);
2303         }
2304         heap_free(ctx->arrays);
2305     }
2306
2307     heap_pool_free(&ctx->heap);
2308     heap_free(ctx->args);
2309     heap_free(ctx->vars);
2310     heap_free(ctx->stack);
2311 }
2312
2313 HRESULT exec_script(script_ctx_t *ctx, BOOL extern_caller, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
2314 {
2315     exec_ctx_t exec = {func->code_ctx};
2316     vbsop_t op;
2317     HRESULT hres = S_OK;
2318
2319     exec.code = func->code_ctx;
2320
2321     if(dp ? func->arg_cnt != arg_cnt(dp) : func->arg_cnt) {
2322         FIXME("wrong arg_cnt %d, expected %d\n", dp ? arg_cnt(dp) : 0, func->arg_cnt);
2323         return E_FAIL;
2324     }
2325
2326     heap_pool_init(&exec.heap);
2327
2328     TRACE("%s(", debugstr_w(func->name));
2329     if(func->arg_cnt) {
2330         VARIANT *v;
2331         unsigned i;
2332
2333         exec.args = heap_alloc_zero(func->arg_cnt * sizeof(VARIANT));
2334         if(!exec.args) {
2335             release_exec(&exec);
2336             return E_OUTOFMEMORY;
2337         }
2338
2339         for(i=0; i < func->arg_cnt; i++) {
2340             v = get_arg(dp, i);
2341             TRACE("%s%s", i ? ", " : "", debugstr_variant(v));
2342             if(V_VT(v) == (VT_VARIANT|VT_BYREF)) {
2343                 if(func->args[i].by_ref)
2344                     exec.args[i] = *v;
2345                 else
2346                     hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
2347             }else {
2348                 hres = VariantCopyInd(exec.args+i, v);
2349             }
2350             if(FAILED(hres)) {
2351                 release_exec(&exec);
2352                 return hres;
2353             }
2354         }
2355     }else {
2356         exec.args = NULL;
2357     }
2358     TRACE(")\n");
2359
2360     if(func->var_cnt) {
2361         exec.vars = heap_alloc_zero(func->var_cnt * sizeof(VARIANT));
2362         if(!exec.vars) {
2363             release_exec(&exec);
2364             return E_OUTOFMEMORY;
2365         }
2366     }else {
2367         exec.vars = NULL;
2368     }
2369
2370     exec.stack_size = 16;
2371     exec.top = 0;
2372     exec.stack = heap_alloc(exec.stack_size * sizeof(VARIANT));
2373     if(!exec.stack) {
2374         release_exec(&exec);
2375         return E_OUTOFMEMORY;
2376     }
2377
2378     if(extern_caller)
2379         IActiveScriptSite_OnEnterScript(ctx->site);
2380
2381     if(vbthis) {
2382         IDispatchEx_AddRef(&vbthis->IDispatchEx_iface);
2383         exec.vbthis = vbthis;
2384     }
2385
2386     exec.instr = exec.code->instrs + func->code_off;
2387     exec.script = ctx;
2388     exec.func = func;
2389
2390     while(exec.instr) {
2391         op = exec.instr->op;
2392         hres = op_funcs[op](&exec);
2393         if(FAILED(hres)) {
2394             if(hres != SCRIPT_E_RECORDED) {
2395                 clear_ei(&ctx->ei);
2396
2397                 ctx->ei.scode = hres = map_hres(hres);
2398                 ctx->ei.bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
2399                 ctx->ei.bstrDescription = get_vbscript_error_string(hres);
2400             }else {
2401                 hres = ctx->ei.scode;
2402             }
2403
2404             if(exec.resume_next) {
2405                 unsigned stack_off;
2406
2407                 WARN("Failed %08x in resume next mode\n", hres);
2408
2409                 /*
2410                  * Unwinding here is simple. We need to find the next OP_catch, which contains
2411                  * information about expected stack size and jump offset on error. Generated
2412                  * bytecode needs to guarantee, that simple jump and stack adjustment will
2413                  * guarantee proper execution continuation.
2414                  */
2415                 while((++exec.instr)->op != OP_catch);
2416
2417                 TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
2418
2419                 clear_error_loc(ctx);
2420                 stack_off = exec.instr->arg2.uint;
2421                 instr_jmp(&exec, exec.instr->arg1.uint);
2422
2423                 if(exec.top > stack_off) {
2424                     stack_popn(&exec, exec.top-stack_off);
2425                 }else if(exec.top < stack_off) {
2426                     VARIANT v;
2427
2428                     V_VT(&v) = VT_EMPTY;
2429                     while(exec.top < stack_off) {
2430                         hres = stack_push(&exec, &v);
2431                         if(FAILED(hres))
2432                             break;
2433                     }
2434                 }
2435
2436                 continue;
2437             }else {
2438                 if(!ctx->error_loc_code) {
2439                     grab_vbscode(exec.code);
2440                     ctx->error_loc_code = exec.code;
2441                     ctx->error_loc_offset = exec.instr->loc;
2442                 }
2443                 stack_popn(&exec, exec.top);
2444                 break;
2445             }
2446         }
2447
2448         exec.instr += op_move[op];
2449     }
2450
2451     assert(!exec.top);
2452
2453     if(extern_caller) {
2454         if(FAILED(hres)) {
2455             if(!ctx->ei.scode)
2456                 ctx->ei.scode = hres;
2457             hres = report_script_error(ctx, ctx->error_loc_code, ctx->error_loc_offset);
2458             clear_error_loc(ctx);
2459         }
2460         IActiveScriptSite_OnLeaveScript(ctx->site);
2461     }
2462
2463     if(SUCCEEDED(hres) && res) {
2464         *res = exec.ret_val;
2465         V_VT(&exec.ret_val) = VT_EMPTY;
2466     }
2467
2468     release_exec(&exec);
2469     return hres;
2470 }