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