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)
 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 S_OK;
 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     hres = stack_assume_disp(ctx, arg_cnt+1, &obj);
 992     if(FAILED(hres))
 993         return hres;
 994
 995     if(!obj) {
 996         FIXME("NULL obj\n");
 997         return E_FAIL;
 998     }
 999
1000     hres = stack_assume_disp(ctx, arg_cnt, NULL);
1001     if(FAILED(hres))
1002         return hres;
1003
1004     hres = disp_get_id(obj, identifier, VBDISP_SET, FALSE, &id);
1005     if(SUCCEEDED(hres)) {
1006         vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
1007         hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUTREF, &dp);
1008     }
1009     if(FAILED(hres))
1010         return hres;
1011
1012     stack_popn(ctx, arg_cnt+2);
1013     return S_OK;
1014 }
1015
1016 static HRESULT interp_const(exec_ctx_t *ctx)
1017 {
1018     BSTR arg = ctx->instr->arg1.bstr;
1019     VARIANT *v;
1020     ref_t ref;
1021     HRESULT hres;
1022
1023     TRACE("%s\n", debugstr_w(arg));
1024
1025     assert(ctx->func->type == FUNC_GLOBAL);
1026
1027     hres = lookup_identifier(ctx, arg, VBDISP_CALLGET, &ref);
1028     if(FAILED(hres))
1029         return hres;
1030
1031     if(ref.type != REF_NONE) {
1032         FIXME("%s already defined\n", debugstr_w(arg));
1033         return E_FAIL;
1034     }
1035
1036     hres = stack_assume_val(ctx, 0);
1037     if(FAILED(hres))
1038         return hres;
1039
1040     hres = add_dynamic_var(ctx, arg, TRUE, &v);
1041     if(FAILED(hres))
1042         return hres;
1043
1044     *v = *stack_pop(ctx);
1045     return S_OK;
1046 }
1047
1048 static HRESULT interp_val(exec_ctx_t *ctx)
1049 {
1050     variant_val_t val;
1051     VARIANT v;
1052     HRESULT hres;
1053
1054     TRACE("\n");
1055
1056     hres = stack_pop_val(ctx, &val);
1057     if(FAILED(hres))
1058         return hres;
1059
1060     if(!val.owned) {
1061         V_VT(&v) = VT_EMPTY;
1062         hres = VariantCopy(&v, val.v);
1063         if(FAILED(hres))
1064             return hres;
1065     }
1066
1067     return stack_push(ctx, val.owned ? val.v : &v);
1068 }
1069
1070 static HRESULT interp_pop(exec_ctx_t *ctx)
1071 {
1072     const unsigned n = ctx->instr->arg1.uint;
1073
1074     TRACE("%u\n", n);
1075
1076     stack_popn(ctx, n);
1077     return S_OK;
1078 }
1079
1080 static HRESULT interp_stack(exec_ctx_t *ctx)
1081 {
1082     const unsigned n = ctx->instr->arg1.uint;
1083     VARIANT v;
1084     HRESULT hres;
1085
1086     TRACE("%#x\n", n);
1087
1088     if(n == ~0)
1089         return MAKE_VBSERROR(505);
1090     assert(n < ctx->top);
1091
1092     V_VT(&v) = VT_EMPTY;
1093     hres = VariantCopy(&v, ctx->stack + n);
1094     if(FAILED(hres))
1095         return hres;
1096
1097     return stack_push(ctx, &v);
1098 }
1099
1100 static HRESULT interp_deref(exec_ctx_t *ctx)
1101 {
1102     VARIANT copy, *v = stack_top(ctx, 0);
1103     HRESULT hres;
1104
1105     TRACE("%s\n", debugstr_variant(v));
1106
1107     if(V_VT(v) != (VT_BYREF|VT_VARIANT))
1108         return S_OK;
1109
1110     V_VT(&copy) = VT_EMPTY;
1111     hres = VariantCopy(&copy, V_VARIANTREF(v));
1112     if(SUCCEEDED(hres))
1113         *v = copy;
1114     return hres;
1115 }
1116
1117 static HRESULT interp_new(exec_ctx_t *ctx)
1118 {
1119     const WCHAR *arg = ctx->instr->arg1.bstr;
1120     class_desc_t *class_desc = NULL;
1121     vbdisp_t *obj;
1122     VARIANT v;
1123     HRESULT hres;
1124
1125     TRACE("%s\n", debugstr_w(arg));
1126
1127     if(!wcsicmp(arg, L"regexp")) {
1128         V_VT(&v) = VT_DISPATCH;
1129         hres = create_regexp(&V_DISPATCH(&v));
1130         if(FAILED(hres))
1131             return hres;
1132
1133         return stack_push(ctx, &v);
1134     }
1135
1136     if(ctx->code->named_item)
1137         for(class_desc = ctx->code->named_item->script_obj->classes; class_desc; class_desc = class_desc->next)
1138             if(!wcsicmp(class_desc->name, arg))
1139                 break;
1140     if(!class_desc)
1141         for(class_desc = ctx->script->script_obj->classes; class_desc; class_desc = class_desc->next)
1142             if(!wcsicmp(class_desc->name, arg))
1143                 break;
1144     if(!class_desc) {
1145         FIXME("Class %s not found\n", debugstr_w(arg));
1146         return E_FAIL;
1147     }
1148
1149     hres = create_vbdisp(class_desc, &obj);
1150     if(FAILED(hres))
1151         return hres;
1152
1153     V_VT(&v) = VT_DISPATCH;
1154     V_DISPATCH(&v) = (IDispatch*)&obj->IDispatchEx_iface;
1155     return stack_push(ctx, &v);
1156 }
1157
1158 static HRESULT interp_dim(exec_ctx_t *ctx)
1159 {
1160     ScriptDisp *script_obj = ctx->code->named_item ? ctx->code->named_item->script_obj : ctx->script->script_obj;
1161     const BSTR ident = ctx->instr->arg1.bstr;
1162     const unsigned array_id = ctx->instr->arg2.uint;
1163     const array_desc_t *array_desc;
1164     SAFEARRAY **array_ref;
1165     VARIANT *v;
1166     HRESULT hres;
1167
1168     TRACE("%s\n", debugstr_w(ident));
1169
1170     assert(array_id < ctx->func->array_cnt);
1171
1172     if(ctx->func->type == FUNC_GLOBAL) {
1173         unsigned i;
1174         for(i = 0; i < script_obj->global_vars_cnt; i++) {
1175             if(!wcsicmp(script_obj->global_vars[i]->name, ident))
1176                 break;
1177         }
1178         assert(i < script_obj->global_vars_cnt);
1179         v = &script_obj->global_vars[i]->v;
1180         array_ref = &script_obj->global_vars[i]->array;
1181     }else {
1182         ref_t ref;
1183
1184         if(!ctx->arrays) {
1185             ctx->arrays = heap_alloc_zero(ctx->func->array_cnt * sizeof(SAFEARRAY*));
1186             if(!ctx->arrays)
1187                 return E_OUTOFMEMORY;
1188         }
1189
1190         hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
1191         if(FAILED(hres)) {
1192             FIXME("lookup %s failed: %08x\n", debugstr_w(ident), hres);
1193             return hres;
1194         }
1195
1196         if(ref.type != REF_VAR) {
1197             FIXME("got ref.type = %d\n", ref.type);
1198             return E_FAIL;
1199         }
1200
1201         v = ref.u.v;
1202         array_ref = ctx->arrays + array_id;
1203     }
1204
1205     if(*array_ref) {
1206         FIXME("Array already initialized\n");
1207         return E_FAIL;
1208     }
1209
1210     array_desc = ctx->func->array_descs + array_id;
1211     if(array_desc->dim_cnt) {
1212         *array_ref = SafeArrayCreate(VT_VARIANT, array_desc->dim_cnt, array_desc->bounds);
1213         if(!*array_ref)
1214             return E_OUTOFMEMORY;
1215     }
1216
1217     V_VT(v) = VT_ARRAY|VT_BYREF|VT_VARIANT;
1218     V_ARRAYREF(v) = array_ref;
1219     return S_OK;
1220 }
1221
1222 static HRESULT array_bounds_from_stack(exec_ctx_t *ctx, unsigned dim_cnt, SAFEARRAYBOUND **ret)
1223 {
1224     SAFEARRAYBOUND *bounds;
1225     unsigned i;
1226     int dim;
1227     HRESULT hres;
1228
1229     if(!(bounds = heap_alloc(dim_cnt * sizeof(*bounds))))
1230         return E_OUTOFMEMORY;
1231
1232     for(i = 0; i < dim_cnt; i++) {
1233         hres = to_int(stack_top(ctx, dim_cnt - i - 1), &dim);
1234         if(FAILED(hres)) {
1235             heap_free(bounds);
1236             return hres;
1237         }
1238
1239         bounds[i].cElements = dim + 1;
1240         bounds[i].lLbound = 0;
1241     }
1242
1243     stack_popn(ctx, dim_cnt);
1244     *ret = bounds;
1245     return S_OK;
1246 }
1247
1248 static HRESULT interp_redim(exec_ctx_t *ctx)
1249 {
1250     BSTR identifier = ctx->instr->arg1.bstr;
1251     const unsigned dim_cnt = ctx->instr->arg2.uint;
1252     SAFEARRAYBOUND *bounds;
1253     SAFEARRAY *array;
1254     ref_t ref;
1255     HRESULT hres;
1256
1257     TRACE("%s %u\n", debugstr_w(identifier), dim_cnt);
1258
1259     hres = lookup_identifier(ctx, identifier, VBDISP_LET, &ref);
1260     if(FAILED(hres)) {
1261         FIXME("lookup %s failed: %08x\n", debugstr_w(identifier), hres);
1262         return hres;
1263     }
1264
1265     if(ref.type != REF_VAR) {
1266         FIXME("got ref.type = %d\n", ref.type);
1267         return E_FAIL;
1268     }
1269
1270     hres = array_bounds_from_stack(ctx, dim_cnt, &bounds);
1271     if(FAILED(hres))
1272         return hres;
1273
1274     array = SafeArrayCreate(VT_VARIANT, dim_cnt, bounds);
1275     heap_free(bounds);
1276     if(!array)
1277         return E_OUTOFMEMORY;
1278
1279     /* FIXME: We should check if we're not modifying an existing static array here */
1280
1281     VariantClear(ref.u.v);
1282     V_VT(ref.u.v) = VT_ARRAY|VT_VARIANT;
1283     V_ARRAY(ref.u.v) = array;
1284     return S_OK;
1285 }
1286
1287 static HRESULT interp_redim_preserve(exec_ctx_t *ctx)
1288 {
1289     BSTR identifier = ctx->instr->arg1.bstr;
1290     const unsigned dim_cnt = ctx->instr->arg2.uint;
1291     unsigned i;
1292     SAFEARRAYBOUND *bounds;
1293     SAFEARRAY *array;
1294     ref_t ref;
1295     HRESULT hres;
1296
1297     TRACE("%s %u\n", debugstr_w(identifier), dim_cnt);
1298
1299     hres = lookup_identifier(ctx, identifier, VBDISP_LET, &ref);
1300     if(FAILED(hres)) {
1301         FIXME("lookup %s failed: %08x\n", debugstr_w(identifier), hres);
1302         return hres;
1303     }
1304
1305     if(ref.type != REF_VAR) {
1306         FIXME("got ref.type = %d\n", ref.type);
1307         return E_FAIL;
1308     }
1309
1310     if(!(V_VT(ref.u.v) & VT_ARRAY)) {
1311         FIXME("ReDim Preserve not valid on type %d\n", V_VT(ref.u.v));
1312         return E_FAIL;
1313     }
1314
1315     array = V_ARRAY(ref.u.v);
1316
1317     hres = array_bounds_from_stack(ctx, dim_cnt, &bounds);
1318     if(FAILED(hres))
1319         return hres;
1320
1321     if(array == NULL || array->cDims == 0) {
1322         /* can initially allocate the array */
1323         array = SafeArrayCreate(VT_VARIANT, dim_cnt, bounds);
1324         VariantClear(ref.u.v);
1325         V_VT(ref.u.v) = VT_ARRAY|VT_VARIANT;
1326         V_ARRAY(ref.u.v) = array;
1327         return S_OK;
1328     } else if(array->cDims != dim_cnt) {
1329         /* can't otherwise change the number of dimensions */
1330         TRACE("Can't resize %s, cDims %d != %d\n", debugstr_w(identifier), array->cDims, dim_cnt);
1331         return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1332     } else {
1333         /* can resize the last dimensions (if others match */
1334         for(i = 0; i+1 < dim_cnt; ++i) {
1335             if(array->rgsabound[array->cDims - 1 - i].cElements != bounds[i].cElements) {
1336                 TRACE("Can't resize %s, bound[%d] %d != %d\n", debugstr_w(identifier), i, array->rgsabound[i].cElements, bounds[i].cElements);
1337                 return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1338             }
1339         }
1340         return SafeArrayRedim(array, &bounds[dim_cnt-1]);
1341     }
1342 }
1343
1344 static HRESULT interp_step(exec_ctx_t *ctx)
1345 {
1346     const BSTR ident = ctx->instr->arg2.bstr;
1347     BOOL gteq_zero;
1348     VARIANT zero;
1349     ref_t ref;
1350     HRESULT hres;
1351
1352     TRACE("%s\n", debugstr_w(ident));
1353
1354     V_VT(&zero) = VT_I2;
1355     V_I2(&zero) = 0;
1356     hres = VarCmp(stack_top(ctx, 0), &zero, ctx->script->lcid, 0);
1357     if(FAILED(hres))
1358         return hres;
1359
1360     gteq_zero = hres == VARCMP_GT || hres == VARCMP_EQ;
1361
1362     hres = lookup_identifier(ctx, ident, VBDISP_ANY, &ref);
1363     if(FAILED(hres))
1364         return hres;
1365
1366     if(ref.type != REF_VAR) {
1367         FIXME("%s is not REF_VAR\n", debugstr_w(ident));
1368         return E_FAIL;
1369     }
1370
1371     hres = VarCmp(ref.u.v, stack_top(ctx, 1), ctx->script->lcid, 0);
1372     if(FAILED(hres))
1373         return hres;
1374
1375     if(hres == VARCMP_EQ || hres == (gteq_zero ? VARCMP_LT : VARCMP_GT)) {
1376         ctx->instr++;
1377     }else {
1378         stack_popn(ctx, 2);
1379         instr_jmp(ctx, ctx->instr->arg1.uint);
1380     }
1381     return S_OK;
1382 }
1383
1384 static HRESULT interp_newenum(exec_ctx_t *ctx)
1385 {
1386     variant_val_t v;
1387     VARIANT *r;
1388     HRESULT hres;
1389
1390     TRACE("\n");
1391
1392     stack_pop_deref(ctx, &v);
1393     assert(V_VT(stack_top(ctx, 0)) == VT_EMPTY);
1394     r = stack_top(ctx, 0);
1395
1396     switch(V_VT(v.v)) {
1397     case VT_DISPATCH|VT_BYREF:
1398     case VT_DISPATCH: {
1399         IEnumVARIANT *iter;
1400         DISPPARAMS dp = {0};
1401         VARIANT iterv;
1402
1403         hres = disp_call(ctx->script, V_ISBYREF(v.v) ? *V_DISPATCHREF(v.v) : V_DISPATCH(v.v), DISPID_NEWENUM, &dp, &iterv);
1404         release_val(&v);
1405         if(FAILED(hres))
1406             return hres;
1407
1408         if(V_VT(&iterv) != VT_UNKNOWN && V_VT(&iterv) != VT_DISPATCH) {
1409             FIXME("Unsupported iterv %s\n", debugstr_variant(&iterv));
1410             VariantClear(&iterv);
1411             return hres;
1412         }
1413
1414         hres = IUnknown_QueryInterface(V_UNKNOWN(&iterv), &IID_IEnumVARIANT, (void**)&iter);
1415         IUnknown_Release(V_UNKNOWN(&iterv));
1416         if(FAILED(hres)) {
1417             FIXME("Could not get IEnumVARIANT iface: %08x\n", hres);
1418             return hres;
1419         }
1420
1421         V_VT(r) = VT_UNKNOWN;
1422         V_UNKNOWN(r) = (IUnknown*)iter;
1423         break;
1424     }
1425     case VT_VARIANT|VT_ARRAY:
1426     case VT_VARIANT|VT_ARRAY|VT_BYREF: {
1427         IEnumVARIANT *iter;
1428
1429         hres = create_safearray_iter(V_ISBYREF(v.v) ? *V_ARRAYREF(v.v) : V_ARRAY(v.v), &iter);
1430         if(FAILED(hres))
1431             return hres;
1432
1433         V_VT(r) = VT_UNKNOWN;
1434         V_UNKNOWN(r) = (IUnknown*)iter;
1435         break;
1436     }
1437     default:
1438         FIXME("Unsupported for %s\n", debugstr_variant(v.v));
1439         release_val(&v);
1440         return E_NOTIMPL;
1441     }
1442
1443     return S_OK;
1444 }
1445
1446 static HRESULT interp_enumnext(exec_ctx_t *ctx)
1447 {
1448     const unsigned loop_end = ctx->instr->arg1.uint;
1449     const BSTR ident = ctx->instr->arg2.bstr;
1450     VARIANT v;
1451     DISPPARAMS dp = {&v, &propput_dispid, 1, 1};
1452     IEnumVARIANT *iter;
1453     BOOL do_continue;
1454     HRESULT hres;
1455
1456     TRACE("\n");
1457
1458     if(V_VT(stack_top(ctx, 0)) == VT_EMPTY) {
1459         FIXME("uninitialized\n");
1460         return E_FAIL;
1461     }
1462
1463     assert(V_VT(stack_top(ctx, 0)) == VT_UNKNOWN);
1464     iter = (IEnumVARIANT*)V_UNKNOWN(stack_top(ctx, 0));
1465
1466     V_VT(&v) = VT_EMPTY;
1467     hres = IEnumVARIANT_Next(iter, 1, &v, NULL);
1468     if(FAILED(hres))
1469         return hres;
1470
1471     do_continue = hres == S_OK;
1472     hres = assign_ident(ctx, ident, DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &dp);
1473     VariantClear(&v);
1474     if(FAILED(hres))
1475         return hres;
1476
1477     if(do_continue) {
1478         ctx->instr++;
1479     }else {
1480         stack_popn(ctx, 1);
1481         instr_jmp(ctx, loop_end);
1482     }
1483     return S_OK;
1484 }
1485
1486 static HRESULT interp_jmp(exec_ctx_t *ctx)
1487 {
1488     const unsigned arg = ctx->instr->arg1.uint;
1489
1490     TRACE("%u\n", arg);
1491
1492     instr_jmp(ctx, arg);
1493     return S_OK;
1494 }
1495
1496 static HRESULT interp_jmp_false(exec_ctx_t *ctx)
1497 {
1498     const unsigned arg = ctx->instr->arg1.uint;
1499     HRESULT hres;
1500     BOOL b;
1501
1502     TRACE("%u\n", arg);
1503
1504     hres = stack_pop_bool(ctx, &b);
1505     if(FAILED(hres))
1506         return hres;
1507
1508     if(b)
1509         ctx->instr++;
1510     else
1511         instr_jmp(ctx, ctx->instr->arg1.uint);
1512     return S_OK;
1513 }
1514
1515 static HRESULT interp_jmp_true(exec_ctx_t *ctx)
1516 {
1517     const unsigned arg = ctx->instr->arg1.uint;
1518     HRESULT hres;
1519     BOOL b;
1520
1521     TRACE("%u\n", arg);
1522
1523     hres = stack_pop_bool(ctx, &b);
1524     if(FAILED(hres))
1525         return hres;
1526
1527     if(b)
1528         instr_jmp(ctx, ctx->instr->arg1.uint);
1529     else
1530         ctx->instr++;
1531     return S_OK;
1532 }
1533
1534 static HRESULT interp_ret(exec_ctx_t *ctx)
1535 {
1536     TRACE("\n");
1537
1538     ctx->instr = NULL;
1539     return S_OK;
1540 }
1541
1542 static HRESULT interp_retval(exec_ctx_t *ctx)
1543 {
1544     variant_val_t val;
1545     HRESULT hres;
1546
1547     TRACE("\n");
1548
1549     stack_pop_deref(ctx, &val);
1550
1551     if(val.owned) {
1552         VariantClear(&ctx->ret_val);
1553         ctx->ret_val = *val.v;
1554     }
1555     else {
1556         hres = VariantCopy(&ctx->ret_val, val.v);
1557         if(FAILED(hres))
1558             return hres;
1559     }
1560
1561     return S_OK;
1562 }
1563
1564 static HRESULT interp_stop(exec_ctx_t *ctx)
1565 {
1566     WARN("\n");
1567
1568     /* NOTE: this should have effect in debugging mode (that we don't support yet) */
1569     return S_OK;
1570 }
1571
1572 static HRESULT interp_me(exec_ctx_t *ctx)
1573 {
1574     IDispatch *disp;
1575     VARIANT v;
1576
1577     TRACE("\n");
1578
1579     if(ctx->vbthis) {
1580         disp = (IDispatch*)&ctx->vbthis->IDispatchEx_iface;
1581     }else if(ctx->code->named_item) {
1582         disp = (ctx->code->named_item->flags & SCRIPTITEM_CODEONLY)
1583                ? (IDispatch*)&ctx->code->named_item->script_obj->IDispatchEx_iface
1584                : ctx->code->named_item->disp;
1585     }else {
1586         named_item_t *item;
1587         disp = NULL;
1588         LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
1589             if(!(item->flags & SCRIPTITEM_GLOBALMEMBERS)) continue;
1590             disp = item->disp;
1591             break;
1592         }
1593         if(!disp)
1594             disp = (IDispatch*)&ctx->script->script_obj->IDispatchEx_iface;
1595     }
1596
1597     IDispatch_AddRef(disp);
1598     V_VT(&v) = VT_DISPATCH;
1599     V_DISPATCH(&v) = disp;
1600     return stack_push(ctx, &v);
1601 }
1602
1603 static HRESULT interp_bool(exec_ctx_t *ctx)
1604 {
1605     const VARIANT_BOOL arg = ctx->instr->arg1.lng;
1606     VARIANT v;
1607
1608     TRACE("%s\n", arg ? "true" : "false");
1609
1610     V_VT(&v) = VT_BOOL;
1611     V_BOOL(&v) = arg;
1612     return stack_push(ctx, &v);
1613 }
1614
1615 static HRESULT interp_errmode(exec_ctx_t *ctx)
1616 {
1617     const int err_mode = ctx->instr->arg1.uint;
1618
1619     TRACE("%d\n", err_mode);
1620
1621     ctx->resume_next = err_mode;
1622     clear_ei(&ctx->script->ei);
1623     return S_OK;
1624 }
1625
1626 static HRESULT interp_string(exec_ctx_t *ctx)
1627 {
1628     VARIANT v;
1629
1630     TRACE("\n");
1631
1632     V_VT(&v) = VT_BSTR;
1633     V_BSTR(&v) = SysAllocString(ctx->instr->arg1.str);
1634     if(!V_BSTR(&v))
1635         return E_OUTOFMEMORY;
1636
1637     return stack_push(ctx, &v);
1638 }
1639
1640 static HRESULT interp_int(exec_ctx_t *ctx)
1641 {
1642     const LONG arg = ctx->instr->arg1.lng;
1643     VARIANT v;
1644
1645     TRACE("%d\n", arg);
1646
1647     if(arg == (INT16)arg) {
1648         V_VT(&v) = VT_I2;
1649         V_I2(&v) = arg;
1650     }else {
1651         V_VT(&v) = VT_I4;
1652         V_I4(&v) = arg;
1653     }
1654     return stack_push(ctx, &v);
1655 }
1656
1657 static HRESULT interp_double(exec_ctx_t *ctx)
1658 {
1659     const DOUBLE *arg = ctx->instr->arg1.dbl;
1660     VARIANT v;
1661
1662     TRACE("%lf\n", *arg);
1663
1664     V_VT(&v) = VT_R8;
1665     V_R8(&v) = *arg;
1666     return stack_push(ctx, &v);
1667 }
1668
1669 static HRESULT interp_empty(exec_ctx_t *ctx)
1670 {
1671     VARIANT v;
1672
1673     TRACE("\n");
1674
1675     V_VT(&v) = VT_EMPTY;
1676     return stack_push(ctx, &v);
1677 }
1678
1679 static HRESULT interp_null(exec_ctx_t *ctx)
1680 {
1681     TRACE("\n");
1682     return stack_push_null(ctx);
1683 }
1684
1685 static HRESULT interp_nothing(exec_ctx_t *ctx)
1686 {
1687     VARIANT v;
1688
1689     TRACE("\n");
1690
1691     V_VT(&v) = VT_DISPATCH;
1692     V_DISPATCH(&v) = NULL;
1693     return stack_push(ctx, &v);
1694 }
1695
1696 static HRESULT interp_hres(exec_ctx_t *ctx)
1697 {
1698     const unsigned arg = ctx->instr->arg1.uint;
1699     VARIANT v;
1700
1701     TRACE("%d\n", arg);
1702
1703     V_VT(&v) = VT_ERROR;
1704     V_ERROR(&v) = arg;
1705     return stack_push(ctx, &v);
1706 }
1707
1708 static HRESULT interp_not(exec_ctx_t *ctx)
1709 {
1710     variant_val_t val;
1711     VARIANT v;
1712     HRESULT hres;
1713
1714     TRACE("\n");
1715
1716     hres = stack_pop_val(ctx, &val);
1717     if(FAILED(hres))
1718         return hres;
1719
1720     hres = VarNot(val.v, &v);
1721     release_val(&val);
1722     if(FAILED(hres))
1723         return hres;
1724
1725     return stack_push(ctx, &v);
1726 }
1727
1728 static HRESULT interp_and(exec_ctx_t *ctx)
1729 {
1730     variant_val_t r, l;
1731     VARIANT v;
1732     HRESULT hres;
1733
1734     TRACE("\n");
1735
1736     hres = stack_pop_val(ctx, &r);
1737     if(FAILED(hres))
1738         return hres;
1739
1740     hres = stack_pop_val(ctx, &l);
1741     if(SUCCEEDED(hres)) {
1742         hres = VarAnd(l.v, r.v, &v);
1743         release_val(&l);
1744     }
1745     release_val(&r);
1746     if(FAILED(hres))
1747         return hres;
1748
1749     return stack_push(ctx, &v);
1750 }
1751
1752 static HRESULT interp_or(exec_ctx_t *ctx)
1753 {
1754     variant_val_t r, l;
1755     VARIANT v;
1756     HRESULT hres;
1757
1758     TRACE("\n");
1759
1760     hres = stack_pop_val(ctx, &r);
1761     if(FAILED(hres))
1762         return hres;
1763
1764     hres = stack_pop_val(ctx, &l);
1765     if(SUCCEEDED(hres)) {
1766         hres = VarOr(l.v, r.v, &v);
1767         release_val(&l);
1768     }
1769     release_val(&r);
1770     if(FAILED(hres))
1771         return hres;
1772
1773     return stack_push(ctx, &v);
1774 }
1775
1776 static HRESULT interp_xor(exec_ctx_t *ctx)
1777 {
1778     variant_val_t r, l;
1779     VARIANT v;
1780     HRESULT hres;
1781
1782     TRACE("\n");
1783
1784     hres = stack_pop_val(ctx, &r);
1785     if(FAILED(hres))
1786         return hres;
1787
1788     hres = stack_pop_val(ctx, &l);
1789     if(SUCCEEDED(hres)) {
1790         hres = VarXor(l.v, r.v, &v);
1791         release_val(&l);
1792     }
1793     release_val(&r);
1794     if(FAILED(hres))
1795         return hres;
1796
1797     return stack_push(ctx, &v);
1798 }
1799
1800 static HRESULT interp_eqv(exec_ctx_t *ctx)
1801 {
1802     variant_val_t r, l;
1803     VARIANT v;
1804     HRESULT hres;
1805
1806     TRACE("\n");
1807
1808     hres = stack_pop_val(ctx, &r);
1809     if(FAILED(hres))
1810         return hres;
1811
1812     hres = stack_pop_val(ctx, &l);
1813     if(SUCCEEDED(hres)) {
1814         hres = VarEqv(l.v, r.v, &v);
1815         release_val(&l);
1816     }
1817     release_val(&r);
1818     if(FAILED(hres))
1819         return hres;
1820
1821     return stack_push(ctx, &v);
1822 }
1823
1824 static HRESULT interp_imp(exec_ctx_t *ctx)
1825 {
1826     variant_val_t r, l;
1827     VARIANT v;
1828     HRESULT hres;
1829
1830     TRACE("\n");
1831
1832     hres = stack_pop_val(ctx, &r);
1833     if(FAILED(hres))
1834         return hres;
1835
1836     hres = stack_pop_val(ctx, &l);
1837     if(SUCCEEDED(hres)) {
1838         hres = VarImp(l.v, r.v, &v);
1839         release_val(&l);
1840     }
1841     release_val(&r);
1842     if(FAILED(hres))
1843         return hres;
1844
1845     return stack_push(ctx, &v);
1846 }
1847
1848 static HRESULT var_cmp(exec_ctx_t *ctx, VARIANT *l, VARIANT *r)
1849 {
1850     TRACE("%s %s\n", debugstr_variant(l), debugstr_variant(r));
1851
1852     /* FIXME: Fix comparing string to number */
1853
1854     return VarCmp(l, r, ctx->script->lcid, 0);
1855  }
1856
1857 static HRESULT cmp_oper(exec_ctx_t *ctx)
1858 {
1859     variant_val_t l, r;
1860     HRESULT hres;
1861
1862     hres = stack_pop_val(ctx, &r);
1863     if(FAILED(hres))
1864         return hres;
1865
1866     hres = stack_pop_val(ctx, &l);
1867     if(SUCCEEDED(hres)) {
1868         hres = var_cmp(ctx, l.v, r.v);
1869         release_val(&l);
1870     }
1871
1872     release_val(&r);
1873     return hres;
1874 }
1875
1876 static HRESULT interp_equal(exec_ctx_t *ctx)
1877 {
1878     VARIANT v;
1879     HRESULT hres;
1880
1881     TRACE("\n");
1882
1883     hres = cmp_oper(ctx);
1884     if(FAILED(hres))
1885         return hres;
1886     if(hres == VARCMP_NULL)
1887         return stack_push_null(ctx);
1888
1889     V_VT(&v) = VT_BOOL;
1890     V_BOOL(&v) = hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1891     return stack_push(ctx, &v);
1892 }
1893
1894 static HRESULT interp_nequal(exec_ctx_t *ctx)
1895 {
1896     VARIANT v;
1897     HRESULT hres;
1898
1899     TRACE("\n");
1900
1901     hres = cmp_oper(ctx);
1902     if(FAILED(hres))
1903         return hres;
1904     if(hres == VARCMP_NULL)
1905         return stack_push_null(ctx);
1906
1907     V_VT(&v) = VT_BOOL;
1908     V_BOOL(&v) = hres != VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1909     return stack_push(ctx, &v);
1910 }
1911
1912 static HRESULT interp_gt(exec_ctx_t *ctx)
1913 {
1914     VARIANT v;
1915     HRESULT hres;
1916
1917     TRACE("\n");
1918
1919     hres = cmp_oper(ctx);
1920     if(FAILED(hres))
1921         return hres;
1922     if(hres == VARCMP_NULL)
1923         return stack_push_null(ctx);
1924
1925     V_VT(&v) = VT_BOOL;
1926     V_BOOL(&v) = hres == VARCMP_GT ? VARIANT_TRUE : VARIANT_FALSE;
1927     return stack_push(ctx, &v);
1928 }
1929
1930 static HRESULT interp_gteq(exec_ctx_t *ctx)
1931 {
1932     VARIANT v;
1933     HRESULT hres;
1934
1935     TRACE("\n");
1936
1937     hres = cmp_oper(ctx);
1938     if(FAILED(hres))
1939         return hres;
1940     if(hres == VARCMP_NULL)
1941         return stack_push_null(ctx);
1942
1943     V_VT(&v) = VT_BOOL;
1944     V_BOOL(&v) = hres == VARCMP_GT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1945     return stack_push(ctx, &v);
1946 }
1947
1948 static HRESULT interp_lt(exec_ctx_t *ctx)
1949 {
1950     VARIANT v;
1951     HRESULT hres;
1952
1953     TRACE("\n");
1954
1955     hres = cmp_oper(ctx);
1956     if(FAILED(hres))
1957         return hres;
1958     if(hres == VARCMP_NULL)
1959         return stack_push_null(ctx);
1960
1961     V_VT(&v) = VT_BOOL;
1962     V_BOOL(&v) = hres == VARCMP_LT ? VARIANT_TRUE : VARIANT_FALSE;
1963     return stack_push(ctx, &v);
1964 }
1965
1966 static HRESULT interp_lteq(exec_ctx_t *ctx)
1967 {
1968     VARIANT v;
1969     HRESULT hres;
1970
1971     TRACE("\n");
1972
1973     hres = cmp_oper(ctx);
1974     if(FAILED(hres))
1975         return hres;
1976     if(hres == VARCMP_NULL)
1977         return stack_push_null(ctx);
1978
1979     V_VT(&v) = VT_BOOL;
1980     V_BOOL(&v) = hres == VARCMP_LT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1981     return stack_push(ctx, &v);
1982 }
1983
1984 static HRESULT interp_case(exec_ctx_t *ctx)
1985 {
1986     const unsigned arg = ctx->instr->arg1.uint;
1987     variant_val_t v;
1988     HRESULT hres;
1989
1990     TRACE("%d\n", arg);
1991
1992     hres = stack_pop_val(ctx, &v);
1993     if(FAILED(hres))
1994         return hres;
1995
1996     hres = var_cmp(ctx, stack_top(ctx, 0), v.v);
1997     release_val(&v);
1998     if(FAILED(hres))
1999         return hres;
2000
2001     if(hres == VARCMP_EQ) {
2002         stack_popn(ctx, 1);
2003         instr_jmp(ctx, arg);
2004     }else {
2005         ctx->instr++;
2006     }
2007
2008     return S_OK;
2009 }
2010
2011 static HRESULT interp_is(exec_ctx_t *ctx)
2012 {
2013     IUnknown *l = NULL, *r = NULL;
2014     variant_val_t v;
2015     HRESULT hres = S_OK;
2016
2017     TRACE("\n");
2018
2019     stack_pop_deref(ctx, &v);
2020     if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
2021         FIXME("Unhandled type %s\n", debugstr_variant(v.v));
2022         hres = E_NOTIMPL;
2023     }else if(V_UNKNOWN(v.v)) {
2024         hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&r);
2025     }
2026     if(v.owned) VariantClear(v.v);
2027     if(FAILED(hres))
2028         return hres;
2029
2030     stack_pop_deref(ctx, &v);
2031     if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
2032         FIXME("Unhandled type %s\n", debugstr_variant(v.v));
2033         hres = E_NOTIMPL;
2034     }else if(V_UNKNOWN(v.v)) {
2035         hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&l);
2036     }
2037     if(v.owned) VariantClear(v.v);
2038
2039     if(SUCCEEDED(hres)) {
2040         VARIANT res;
2041         V_VT(&res) = VT_BOOL;
2042         if(r == l)
2043             V_BOOL(&res) = VARIANT_TRUE;
2044         else if(!r || !l)
2045             V_BOOL(&res) = VARIANT_FALSE;
2046         else {
2047             IObjectIdentity *identity;
2048             hres = IUnknown_QueryInterface(l, &IID_IObjectIdentity, (void**)&identity);
2049             if(SUCCEEDED(hres)) {
2050                 hres = IObjectIdentity_IsEqualObject(identity, r);
2051                 IObjectIdentity_Release(identity);
2052             }
2053             V_BOOL(&res) = hres == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
2054         }
2055         hres = stack_push(ctx, &res);
2056     }
2057     if(r)
2058         IUnknown_Release(r);
2059     if(l)
2060         IUnknown_Release(l);
2061     return hres;
2062 }
2063
2064 static HRESULT interp_concat(exec_ctx_t *ctx)
2065 {
2066     variant_val_t r, l;
2067     VARIANT v;
2068     HRESULT hres;
2069
2070     TRACE("\n");
2071
2072     hres = stack_pop_val(ctx, &r);
2073     if(FAILED(hres))
2074         return hres;
2075
2076     hres = stack_pop_val(ctx, &l);
2077     if(SUCCEEDED(hres)) {
2078         hres = VarCat(l.v, r.v, &v);
2079         release_val(&l);
2080     }
2081     release_val(&r);
2082     if(FAILED(hres))
2083         return hres;
2084
2085     return stack_push(ctx, &v);
2086 }
2087
2088 static HRESULT interp_add(exec_ctx_t *ctx)
2089 {
2090     variant_val_t r, l;
2091     VARIANT v;
2092     HRESULT hres;
2093
2094     TRACE("\n");
2095
2096     hres = stack_pop_val(ctx, &r);
2097     if(FAILED(hres))
2098         return hres;
2099
2100     hres = stack_pop_val(ctx, &l);
2101     if(SUCCEEDED(hres)) {
2102         hres = VarAdd(l.v, r.v, &v);
2103         release_val(&l);
2104     }
2105     release_val(&r);
2106     if(FAILED(hres))
2107         return hres;
2108
2109     return stack_push(ctx, &v);
2110 }
2111
2112 static HRESULT interp_sub(exec_ctx_t *ctx)
2113 {
2114     variant_val_t r, l;
2115     VARIANT v;
2116     HRESULT hres;
2117
2118     TRACE("\n");
2119
2120     hres = stack_pop_val(ctx, &r);
2121     if(FAILED(hres))
2122         return hres;
2123
2124     hres = stack_pop_val(ctx, &l);
2125     if(SUCCEEDED(hres)) {
2126         hres = VarSub(l.v, r.v, &v);
2127         release_val(&l);
2128     }
2129     release_val(&r);
2130     if(FAILED(hres))
2131         return hres;
2132
2133     return stack_push(ctx, &v);
2134 }
2135
2136 static HRESULT interp_mod(exec_ctx_t *ctx)
2137 {
2138     variant_val_t r, l;
2139     VARIANT v;
2140     HRESULT hres;
2141
2142     TRACE("\n");
2143
2144     hres = stack_pop_val(ctx, &r);
2145     if(FAILED(hres))
2146         return hres;
2147
2148     hres = stack_pop_val(ctx, &l);
2149     if(SUCCEEDED(hres)) {
2150         hres = VarMod(l.v, r.v, &v);
2151         release_val(&l);
2152     }
2153     release_val(&r);
2154     if(FAILED(hres))
2155         return hres;
2156
2157     return stack_push(ctx, &v);
2158 }
2159
2160 static HRESULT interp_idiv(exec_ctx_t *ctx)
2161 {
2162     variant_val_t r, l;
2163     VARIANT v;
2164     HRESULT hres;
2165
2166     TRACE("\n");
2167
2168     hres = stack_pop_val(ctx, &r);
2169     if(FAILED(hres))
2170         return hres;
2171
2172     hres = stack_pop_val(ctx, &l);
2173     if(SUCCEEDED(hres)) {
2174         hres = VarIdiv(l.v, r.v, &v);
2175         release_val(&l);
2176     }
2177     release_val(&r);
2178     if(FAILED(hres))
2179         return hres;
2180
2181     return stack_push(ctx, &v);
2182 }
2183
2184 static HRESULT interp_div(exec_ctx_t *ctx)
2185 {
2186     variant_val_t r, l;
2187     VARIANT v;
2188     HRESULT hres;
2189
2190     TRACE("\n");
2191
2192     hres = stack_pop_val(ctx, &r);
2193     if(FAILED(hres))
2194         return hres;
2195
2196     hres = stack_pop_val(ctx, &l);
2197     if(SUCCEEDED(hres)) {
2198         hres = VarDiv(l.v, r.v, &v);
2199         release_val(&l);
2200     }
2201     release_val(&r);
2202     if(FAILED(hres))
2203         return hres;
2204
2205     return stack_push(ctx, &v);
2206 }
2207
2208 static HRESULT interp_mul(exec_ctx_t *ctx)
2209 {
2210     variant_val_t r, l;
2211     VARIANT v;
2212     HRESULT hres;
2213
2214     TRACE("\n");
2215
2216     hres = stack_pop_val(ctx, &r);
2217     if(FAILED(hres))
2218         return hres;
2219
2220     hres = stack_pop_val(ctx, &l);
2221     if(SUCCEEDED(hres)) {
2222         hres = VarMul(l.v, r.v, &v);
2223         release_val(&l);
2224     }
2225     release_val(&r);
2226     if(FAILED(hres))
2227         return hres;
2228
2229     return stack_push(ctx, &v);
2230 }
2231
2232 static HRESULT interp_exp(exec_ctx_t *ctx)
2233 {
2234     variant_val_t r, l;
2235     VARIANT v;
2236     HRESULT hres;
2237
2238     TRACE("\n");
2239
2240     hres = stack_pop_val(ctx, &r);
2241     if(FAILED(hres))
2242         return hres;
2243
2244     hres = stack_pop_val(ctx, &l);
2245     if(SUCCEEDED(hres)) {
2246         hres = VarPow(l.v, r.v, &v);
2247         release_val(&l);
2248     }
2249     release_val(&r);
2250     if(FAILED(hres))
2251         return hres;
2252
2253     return stack_push(ctx, &v);
2254 }
2255
2256 static HRESULT interp_neg(exec_ctx_t *ctx)
2257 {
2258     variant_val_t val;
2259     VARIANT v;
2260     HRESULT hres;
2261
2262     hres = stack_pop_val(ctx, &val);
2263     if(FAILED(hres))
2264         return hres;
2265
2266     hres = VarNeg(val.v, &v);
2267     release_val(&val);
2268     if(FAILED(hres))
2269         return hres;
2270
2271     return stack_push(ctx, &v);
2272 }
2273
2274 static HRESULT interp_incc(exec_ctx_t *ctx)
2275 {
2276     const BSTR ident = ctx->instr->arg1.bstr;
2277     VARIANT v;
2278     ref_t ref;
2279     HRESULT hres;
2280
2281     TRACE("\n");
2282
2283     hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
2284     if(FAILED(hres))
2285         return hres;
2286
2287     if(ref.type != REF_VAR) {
2288         FIXME("ref.type is not REF_VAR\n");
2289         return E_FAIL;
2290     }
2291
2292     hres = VarAdd(stack_top(ctx, 0), ref.u.v, &v);
2293     if(FAILED(hres))
2294         return hres;
2295
2296     VariantClear(ref.u.v);
2297     *ref.u.v = v;
2298     return S_OK;
2299 }
2300
2301 static HRESULT interp_catch(exec_ctx_t *ctx)
2302 {
2303     /* Nothing to do here, the OP is for unwinding only. */
2304     return S_OK;
2305 }
2306
2307 static const instr_func_t op_funcs[] = {
2308 #define X(x,n,a,b) interp_ ## x,
2309 OP_LIST
2310 #undef X
2311 };
2312
2313 static const unsigned op_move[] = {
2314 #define X(x,n,a,b) n,
2315 OP_LIST
2316 #undef X
2317 };
2318
2319 void release_dynamic_var(dynamic_var_t *var)
2320 {
2321     VariantClear(&var->v);
2322     if(var->array)
2323         SafeArrayDestroy(var->array);
2324 }
2325
2326 static void release_exec(exec_ctx_t *ctx)
2327 {
2328     dynamic_var_t *var;
2329     unsigned i;
2330
2331     VariantClear(&ctx->ret_val);
2332
2333     for(var = ctx->dynamic_vars; var; var = var->next)
2334         release_dynamic_var(var);
2335
2336     if(ctx->vbthis)
2337         IDispatchEx_Release(&ctx->vbthis->IDispatchEx_iface);
2338
2339     if(ctx->args) {
2340         for(i=0; i < ctx->func->arg_cnt; i++)
2341             VariantClear(ctx->args+i);
2342     }
2343
2344     if(ctx->vars) {
2345         for(i=0; i < ctx->func->var_cnt; i++)
2346             VariantClear(ctx->vars+i);
2347     }
2348
2349     if(ctx->arrays) {
2350         for(i=0; i < ctx->func->array_cnt; i++) {
2351             if(ctx->arrays[i])
2352                 SafeArrayDestroy(ctx->arrays[i]);
2353         }
2354         heap_free(ctx->arrays);
2355     }
2356
2357     heap_pool_free(&ctx->heap);
2358     heap_free(ctx->args);
2359     heap_free(ctx->vars);
2360     heap_free(ctx->stack);
2361 }
2362
2363 HRESULT exec_script(script_ctx_t *ctx, BOOL extern_caller, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
2364 {
2365     exec_ctx_t exec = {func->code_ctx};
2366     vbsop_t op;
2367     HRESULT hres = S_OK;
2368
2369     exec.code = func->code_ctx;
2370
2371     if(dp ? func->arg_cnt != arg_cnt(dp) : func->arg_cnt) {
2372         FIXME("wrong arg_cnt %d, expected %d\n", dp ? arg_cnt(dp) : 0, func->arg_cnt);
2373         return E_FAIL;
2374     }
2375
2376     heap_pool_init(&exec.heap);
2377
2378     TRACE("%s(", debugstr_w(func->name));
2379     if(func->arg_cnt) {
2380         VARIANT *v;
2381         unsigned i;
2382
2383         exec.args = heap_alloc_zero(func->arg_cnt * sizeof(VARIANT));
2384         if(!exec.args) {
2385             release_exec(&exec);
2386             return E_OUTOFMEMORY;
2387         }
2388
2389         for(i=0; i < func->arg_cnt; i++) {
2390             v = get_arg(dp, i);
2391             TRACE("%s%s", i ? ", " : "", debugstr_variant(v));
2392             if(V_VT(v) == (VT_VARIANT|VT_BYREF)) {
2393                 if(func->args[i].by_ref)
2394                     exec.args[i] = *v;
2395                 else
2396                     hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
2397             }else {
2398                 hres = VariantCopyInd(exec.args+i, v);
2399             }
2400             if(FAILED(hres)) {
2401                 release_exec(&exec);
2402                 return hres;
2403             }
2404         }
2405     }else {
2406         exec.args = NULL;
2407     }
2408     TRACE(")\n");
2409
2410     if(func->var_cnt) {
2411         exec.vars = heap_alloc_zero(func->var_cnt * sizeof(VARIANT));
2412         if(!exec.vars) {
2413             release_exec(&exec);
2414             return E_OUTOFMEMORY;
2415         }
2416     }else {
2417         exec.vars = NULL;
2418     }
2419
2420     exec.stack_size = 16;
2421     exec.top = 0;
2422     exec.stack = heap_alloc(exec.stack_size * sizeof(VARIANT));
2423     if(!exec.stack) {
2424         release_exec(&exec);
2425         return E_OUTOFMEMORY;
2426     }
2427
2428     if(extern_caller)
2429         IActiveScriptSite_OnEnterScript(ctx->site);
2430
2431     if(vbthis) {
2432         IDispatchEx_AddRef(&vbthis->IDispatchEx_iface);
2433         exec.vbthis = vbthis;
2434     }
2435
2436     exec.instr = exec.code->instrs + func->code_off;
2437     exec.script = ctx;
2438     exec.func = func;
2439
2440     while(exec.instr) {
2441         op = exec.instr->op;
2442         hres = op_funcs[op](&exec);
2443         if(FAILED(hres)) {
2444             if(hres != SCRIPT_E_RECORDED) {
2445                 clear_ei(&ctx->ei);
2446
2447                 ctx->ei.scode = hres = map_hres(hres);
2448                 ctx->ei.bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
2449                 ctx->ei.bstrDescription = get_vbscript_error_string(hres);
2450             }else {
2451                 hres = ctx->ei.scode;
2452             }
2453
2454             if(exec.resume_next) {
2455                 unsigned stack_off;
2456
2457                 WARN("Failed %08x in resume next mode\n", hres);
2458
2459                 /*
2460                  * Unwinding here is simple. We need to find the next OP_catch, which contains
2461                  * information about expected stack size and jump offset on error. Generated
2462                  * bytecode needs to guarantee, that simple jump and stack adjustment will
2463                  * guarantee proper execution continuation.
2464                  */
2465                 while((++exec.instr)->op != OP_catch);
2466
2467                 TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
2468
2469                 clear_error_loc(ctx);
2470                 stack_off = exec.instr->arg2.uint;
2471                 instr_jmp(&exec, exec.instr->arg1.uint);
2472
2473                 if(exec.top > stack_off) {
2474                     stack_popn(&exec, exec.top-stack_off);
2475                 }else if(exec.top < stack_off) {
2476                     VARIANT v;
2477
2478                     V_VT(&v) = VT_EMPTY;
2479                     while(exec.top < stack_off) {
2480                         hres = stack_push(&exec, &v);
2481                         if(FAILED(hres))
2482                             break;
2483                     }
2484                 }
2485
2486                 continue;
2487             }else {
2488                 if(!ctx->error_loc_code) {
2489                     grab_vbscode(exec.code);
2490                     ctx->error_loc_code = exec.code;
2491                     ctx->error_loc_offset = exec.instr->loc;
2492                 }
2493                 stack_popn(&exec, exec.top);
2494                 break;
2495             }
2496         }
2497
2498         exec.instr += op_move[op];
2499     }
2500
2501     assert(!exec.top);
2502
2503     if(extern_caller) {
2504         if(FAILED(hres)) {
2505             if(!ctx->ei.scode)
2506                 ctx->ei.scode = hres;
2507             hres = report_script_error(ctx, ctx->error_loc_code, ctx->error_loc_offset);
2508             clear_error_loc(ctx);
2509         }
2510         IActiveScriptSite_OnLeaveScript(ctx->site);
2511     }
2512
2513     if(SUCCEEDED(hres) && res) {
2514         *res = exec.ret_val;
2515         V_VT(&exec.ret_val) = VT_EMPTY;
2516     }
2517
2518     release_exec(&exec);
2519     return hres;
2520 }