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