dlls/jscript/dispex.c

   1 /*
   2  * Copyright 2008 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 "jscript.h"
  22
  23 #include "wine/unicode.h"
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  27
  28 /*
  29  * This IID is used to get jsdisp_t objecto from interface.
  30  * We might consider using private interface instead.
  31  */
  32 static const IID IID_IDispatchJS =
  33         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
  34
  35 #define FDEX_VERSION_MASK 0xf0000000
  36 #define GOLDEN_RATIO 0x9E3779B9U
  37
  38 typedef enum {
  39     PROP_JSVAL,
  40     PROP_BUILTIN,
  41     PROP_PROTREF,
  42     PROP_DELETED,
  43     PROP_IDX
  44 } prop_type_t;
  45
  46 struct _dispex_prop_t {
  47     WCHAR *name;
  48     unsigned hash;
  49     prop_type_t type;
  50     DWORD flags;
  51
  52     union {
  53         jsval_t val;
  54         const builtin_prop_t *p;
  55         DWORD ref;
  56         unsigned idx;
  57     } u;
  58
  59     int bucket_head;
  60     int bucket_next;
  61 };
  62
  63 static inline DISPID prop_to_id(jsdisp_t *This, dispex_prop_t *prop)
  64 {
  65     return prop - This->props;
  66 }
  67
  68 static inline dispex_prop_t *get_prop(jsdisp_t *This, DISPID id)
  69 {
  70     if(id < 0 || id >= This->prop_cnt || This->props[id].type == PROP_DELETED)
  71         return NULL;
  72
  73     return This->props+id;
  74 }
  75
  76 static DWORD get_flags(jsdisp_t *This, dispex_prop_t *prop)
  77 {
  78     if(prop->type == PROP_PROTREF) {
  79         dispex_prop_t *parent = get_prop(This->prototype, prop->u.ref);
  80         if(!parent) {
  81             prop->type = PROP_DELETED;
  82             return 0;
  83         }
  84
  85         return get_flags(This->prototype, parent);
  86     }
  87
  88     return prop->flags;
  89 }
  90
  91 static const builtin_prop_t *find_builtin_prop(jsdisp_t *This, const WCHAR *name)
  92 {
  93     int min = 0, max, i, r;
  94
  95     max = This->builtin_info->props_cnt-1;
  96     while(min <= max) {
  97         i = (min+max)/2;
  98
  99         r = strcmpW(name, This->builtin_info->props[i].name);
 100         if(!r)
 101             return This->builtin_info->props + i;
 102
 103         if(r < 0)
 104             max = i-1;
 105         else
 106             min = i+1;
 107     }
 108
 109     return NULL;
 110 }
 111
 112 static inline unsigned string_hash(const WCHAR *name)
 113 {
 114     unsigned h = 0;
 115     for(; *name; name++)
 116         h = (h>>(sizeof(unsigned)*8-4)) ^ (h<<4) ^ tolowerW(*name);
 117     return h;
 118 }
 119
 120 static inline unsigned get_props_idx(jsdisp_t *This, unsigned hash)
 121 {
 122     return (hash*GOLDEN_RATIO) & (This->buf_size-1);
 123 }
 124
 125 static inline HRESULT resize_props(jsdisp_t *This)
 126 {
 127     dispex_prop_t *props;
 128     int i, bucket;
 129
 130     if(This->buf_size != This->prop_cnt)
 131         return S_FALSE;
 132
 133     props = heap_realloc(This->props, sizeof(dispex_prop_t)*This->buf_size*2);
 134     if(!props)
 135         return E_OUTOFMEMORY;
 136     This->buf_size *= 2;
 137     This->props = props;
 138
 139     for(i=0; i<This->buf_size; i++) {
 140         This->props[i].bucket_head = 0;
 141         This->props[i].bucket_next = 0;
 142     }
 143
 144     for(i=1; i<This->prop_cnt; i++) {
 145         props = This->props+i;
 146
 147         bucket = get_props_idx(This, props->hash);
 148         props->bucket_next = This->props[bucket].bucket_head;
 149         This->props[bucket].bucket_head = i;
 150     }
 151
 152     return S_OK;
 153 }
 154
 155 static inline dispex_prop_t* alloc_prop(jsdisp_t *This, const WCHAR *name, prop_type_t type, DWORD flags)
 156 {
 157     dispex_prop_t *prop;
 158     unsigned bucket;
 159
 160     if(FAILED(resize_props(This)))
 161         return NULL;
 162
 163     prop = &This->props[This->prop_cnt];
 164     prop->name = heap_strdupW(name);
 165     if(!prop->name)
 166         return NULL;
 167     prop->type = type;
 168     prop->flags = flags;
 169     prop->hash = string_hash(name);
 170
 171     bucket = get_props_idx(This, prop->hash);
 172     prop->bucket_next = This->props[bucket].bucket_head;
 173     This->props[bucket].bucket_head = This->prop_cnt++;
 174     return prop;
 175 }
 176
 177 static dispex_prop_t *alloc_protref(jsdisp_t *This, const WCHAR *name, DWORD ref)
 178 {
 179     dispex_prop_t *ret;
 180
 181     ret = alloc_prop(This, name, PROP_PROTREF, 0);
 182     if(!ret)
 183         return NULL;
 184
 185     ret->u.ref = ref;
 186     return ret;
 187 }
 188
 189 static HRESULT find_prop_name(jsdisp_t *This, unsigned hash, const WCHAR *name, dispex_prop_t **ret)
 190 {
 191     const builtin_prop_t *builtin;
 192     unsigned bucket, pos, prev = 0;
 193     dispex_prop_t *prop;
 194
 195     bucket = get_props_idx(This, hash);
 196     pos = This->props[bucket].bucket_head;
 197     while(pos != 0) {
 198         if(!strcmpW(name, This->props[pos].name)) {
 199             if(prev != 0) {
 200                 This->props[prev].bucket_next = This->props[pos].bucket_next;
 201                 This->props[pos].bucket_next = This->props[bucket].bucket_head;
 202                 This->props[bucket].bucket_head = pos;
 203             }
 204
 205             *ret = &This->props[pos];
 206             return S_OK;
 207         }
 208
 209         prev = pos;
 210         pos = This->props[pos].bucket_next;
 211     }
 212
 213     builtin = find_builtin_prop(This, name);
 214     if(builtin) {
 215         prop = alloc_prop(This, name, PROP_BUILTIN, builtin->flags);
 216         if(!prop)
 217             return E_OUTOFMEMORY;
 218
 219         prop->u.p = builtin;
 220         *ret = prop;
 221         return S_OK;
 222     }
 223
 224     if(This->builtin_info->idx_length) {
 225         const WCHAR *ptr;
 226         unsigned idx = 0;
 227
 228         for(ptr = name; isdigitW(*ptr) && idx < 0x10000; ptr++)
 229             idx = idx*10 + (*ptr-'0');
 230         if(!*ptr && idx < This->builtin_info->idx_length(This)) {
 231             prop = alloc_prop(This, name, PROP_IDX, This->builtin_info->idx_put ? 0 : PROPF_CONST);
 232             if(!prop)
 233                 return E_OUTOFMEMORY;
 234
 235             prop->u.idx = idx;
 236             *ret = prop;
 237             return S_OK;
 238         }
 239     }
 240
 241     *ret = NULL;
 242     return S_OK;
 243 }
 244
 245 static HRESULT find_prop_name_prot(jsdisp_t *This, unsigned hash, const WCHAR *name, dispex_prop_t **ret)
 246 {
 247     dispex_prop_t *prop, *del=NULL;
 248     HRESULT hres;
 249
 250     hres = find_prop_name(This, hash, name, &prop);
 251     if(FAILED(hres))
 252         return hres;
 253     if(prop && prop->type==PROP_DELETED) {
 254         del = prop;
 255     } else if(prop) {
 256         *ret = prop;
 257         return S_OK;
 258     }
 259
 260     if(This->prototype) {
 261         hres = find_prop_name_prot(This->prototype, hash, name, &prop);
 262         if(FAILED(hres))
 263             return hres;
 264         if(prop) {
 265             if(del) {
 266                 del->type = PROP_PROTREF;
 267                 del->flags = 0;
 268                 del->u.ref = prop - This->prototype->props;
 269                 prop = del;
 270             }else {
 271                 prop = alloc_protref(This, prop->name, prop - This->prototype->props);
 272                 if(!prop)
 273                     return E_OUTOFMEMORY;
 274             }
 275
 276             *ret = prop;
 277             return S_OK;
 278         }
 279     }
 280
 281     *ret = del;
 282     return S_OK;
 283 }
 284
 285 static HRESULT ensure_prop_name(jsdisp_t *This, const WCHAR *name, BOOL search_prot, DWORD create_flags, dispex_prop_t **ret)
 286 {
 287     dispex_prop_t *prop;
 288     HRESULT hres;
 289
 290     if(search_prot)
 291         hres = find_prop_name_prot(This, string_hash(name), name, &prop);
 292     else
 293         hres = find_prop_name(This, string_hash(name), name, &prop);
 294     if(SUCCEEDED(hres) && (!prop || prop->type == PROP_DELETED)) {
 295         TRACE("creating prop %s flags %x\n", debugstr_w(name), create_flags);
 296
 297         if(prop) {
 298             prop->type = PROP_JSVAL;
 299             prop->flags = create_flags;
 300             prop->u.val = jsval_undefined();
 301         }else {
 302             prop = alloc_prop(This, name, PROP_JSVAL, create_flags);
 303             if(!prop)
 304                 return E_OUTOFMEMORY;
 305         }
 306
 307         prop->u.val = jsval_undefined();
 308     }
 309
 310     *ret = prop;
 311     return hres;
 312 }
 313
 314 static IDispatch *get_this(DISPPARAMS *dp)
 315 {
 316     DWORD i;
 317
 318     for(i=0; i < dp->cNamedArgs; i++) {
 319         if(dp->rgdispidNamedArgs[i] == DISPID_THIS) {
 320             if(V_VT(dp->rgvarg+i) == VT_DISPATCH)
 321                 return V_DISPATCH(dp->rgvarg+i);
 322
 323             WARN("This is not VT_DISPATCH\n");
 324             return NULL;
 325         }
 326     }
 327
 328     TRACE("no this passed\n");
 329     return NULL;
 330 }
 331
 332 static HRESULT convert_params(const DISPPARAMS *dp, jsval_t *buf, unsigned *argc, jsval_t **ret)
 333 {
 334     jsval_t *argv;
 335     unsigned cnt;
 336     unsigned i;
 337     HRESULT hres;
 338
 339     cnt = dp->cArgs - dp->cNamedArgs;
 340
 341     if(cnt > 6) {
 342         argv = heap_alloc(cnt * sizeof(*argv));
 343         if(!argv)
 344             return E_OUTOFMEMORY;
 345     }else {
 346         argv = buf;
 347     }
 348
 349     for(i = 0; i < cnt; i++) {
 350         hres = variant_to_jsval(dp->rgvarg+dp->cArgs-i-1, argv+i);
 351         if(FAILED(hres)) {
 352             while(i--)
 353                 jsval_release(argv[i]);
 354             if(argv != buf)
 355                 heap_free(argv);
 356             return hres;
 357         }
 358     }
 359
 360     *argc = cnt;
 361     *ret = argv;
 362     return S_OK;
 363 }
 364
 365 static HRESULT invoke_prop_func(jsdisp_t *This, IDispatch *jsthis, dispex_prop_t *prop, WORD flags,
 366         unsigned argc, jsval_t *argv, jsval_t *r, IServiceProvider *caller)
 367 {
 368     HRESULT hres;
 369
 370     switch(prop->type) {
 371     case PROP_BUILTIN: {
 372         if(flags == DISPATCH_CONSTRUCT && (prop->flags & PROPF_METHOD)) {
 373             WARN("%s is not a constructor\n", debugstr_w(prop->name));
 374             return E_INVALIDARG;
 375         }
 376
 377         if(prop->name || This->builtin_info->class != JSCLASS_FUNCTION) {
 378             vdisp_t vthis;
 379
 380             if(This->builtin_info->class != JSCLASS_FUNCTION && prop->u.p->invoke != JSGlobal_eval)
 381                 flags &= ~DISPATCH_JSCRIPT_INTERNAL_MASK;
 382             if(jsthis)
 383                 set_disp(&vthis, jsthis);
 384             else
 385                 set_jsdisp(&vthis, This);
 386             hres = prop->u.p->invoke(This->ctx, &vthis, flags, argc, argv, r);
 387             vdisp_release(&vthis);
 388         }else {
 389             /* Function object calls are special case */
 390             hres = Function_invoke(This, jsthis, flags, argc, argv, r);
 391         }
 392         return hres;
 393     }
 394     case PROP_PROTREF:
 395         return invoke_prop_func(This->prototype, jsthis, This->prototype->props+prop->u.ref,
 396                 flags, argc, argv, r, caller);
 397     case PROP_JSVAL: {
 398         if(!is_object_instance(prop->u.val)) {
 399             FIXME("invoke %s\n", debugstr_jsval(prop->u.val));
 400             return E_FAIL;
 401         }
 402
 403         TRACE("call %s %p\n", debugstr_w(prop->name), get_object(prop->u.val));
 404
 405         return disp_call_value(This->ctx, get_object(prop->u.val), jsthis, flags, argc, argv, r);
 406     }
 407     case PROP_IDX:
 408         FIXME("Invoking PROP_IDX not yet supported\n");
 409         return E_NOTIMPL;
 410     case PROP_DELETED:
 411         assert(0);
 412     }
 413
 414     assert(0);
 415     return E_FAIL;
 416 }
 417
 418 static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp,
 419         jsval_t *r, IServiceProvider *caller)
 420 {
 421     HRESULT hres;
 422
 423     switch(prop->type) {
 424     case PROP_BUILTIN:
 425         if(prop->u.p->getter) {
 426             hres = prop->u.p->getter(This->ctx, This, r);
 427         }else {
 428             jsdisp_t *obj;
 429
 430             assert(prop->u.p->invoke != NULL);
 431             hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->name, NULL,
 432                     prop->u.p->flags, NULL, &obj);
 433             if(FAILED(hres))
 434                 break;
 435
 436             prop->type = PROP_JSVAL;
 437             prop->u.val = jsval_obj(obj);
 438
 439             jsdisp_addref(obj);
 440             *r = jsval_obj(obj);
 441         }
 442         break;
 443     case PROP_PROTREF:
 444         hres = prop_get(This->prototype, This->prototype->props+prop->u.ref, dp, r, caller);
 445         break;
 446     case PROP_JSVAL:
 447         hres = jsval_copy(prop->u.val, r);
 448         break;
 449     case PROP_IDX:
 450         hres = This->builtin_info->idx_get(This, prop->u.idx, r);
 451         break;
 452     default:
 453         ERR("type %d\n", prop->type);
 454         return E_FAIL;
 455     }
 456
 457     if(FAILED(hres)) {
 458         TRACE("fail %08x\n", hres);
 459         return hres;
 460     }
 461
 462     TRACE("%s ret %s\n", debugstr_w(prop->name), debugstr_jsval(*r));
 463     return hres;
 464 }
 465
 466 static HRESULT prop_put(jsdisp_t *This, dispex_prop_t *prop, jsval_t val, IServiceProvider *caller)
 467 {
 468     HRESULT hres;
 469
 470     if(prop->flags & PROPF_CONST)
 471         return S_OK;
 472
 473     switch(prop->type) {
 474     case PROP_BUILTIN:
 475         if(prop->u.p->setter)
 476             return prop->u.p->setter(This->ctx, This, val);
 477
 478         if(prop->u.p->setter) {
 479             FIXME("getter with no setter\n");
 480             return E_FAIL;
 481         }
 482         /* fall through */
 483     case PROP_PROTREF:
 484         prop->type = PROP_JSVAL;
 485         prop->flags = PROPF_ENUM;
 486         prop->u.val = jsval_undefined();
 487         break;
 488     case PROP_JSVAL:
 489         jsval_release(prop->u.val);
 490         break;
 491     case PROP_IDX:
 492         return This->builtin_info->idx_put(This, prop->u.idx, val);
 493     default:
 494         ERR("type %d\n", prop->type);
 495         return E_FAIL;
 496     }
 497
 498     TRACE("%s = %s\n", debugstr_w(prop->name), debugstr_jsval(val));
 499
 500     hres = jsval_copy(val, &prop->u.val);
 501     if(FAILED(hres)) {
 502         prop->u.val = jsval_undefined();
 503         return hres;
 504     }
 505
 506     if(This->builtin_info->on_put)
 507         This->builtin_info->on_put(This, prop->name);
 508
 509     return S_OK;
 510 }
 511
 512 HRESULT builtin_set_const(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value)
 513 {
 514     TRACE("%p %s\n", jsthis, debugstr_jsval(value));
 515     return S_OK;
 516 }
 517
 518 static HRESULT fill_protrefs(jsdisp_t *This)
 519 {
 520     dispex_prop_t *iter, *prop;
 521     HRESULT hres;
 522
 523     if(!This->prototype)
 524         return S_OK;
 525
 526     fill_protrefs(This->prototype);
 527
 528     for(iter = This->prototype->props; iter < This->prototype->props+This->prototype->prop_cnt; iter++) {
 529         if(!iter->name)
 530             continue;
 531         hres = find_prop_name(This, iter->hash, iter->name, &prop);
 532         if(FAILED(hres))
 533             return hres;
 534         if(!prop || prop->type==PROP_DELETED) {
 535             if(prop) {
 536                 prop->type = PROP_PROTREF;
 537                 prop->flags = 0;
 538                 prop->u.ref = iter - This->prototype->props;
 539             }else {
 540                 prop = alloc_protref(This, iter->name, iter - This->prototype->props);
 541                 if(!prop)
 542                     return E_OUTOFMEMORY;
 543             }
 544         }
 545     }
 546
 547     return S_OK;
 548 }
 549
 550 static inline jsdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 551 {
 552     return CONTAINING_RECORD(iface, jsdisp_t, IDispatchEx_iface);
 553 }
 554
 555 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 556 {
 557     jsdisp_t *This = impl_from_IDispatchEx(iface);
 558
 559     if(IsEqualGUID(&IID_IUnknown, riid)) {
 560         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 561         *ppv = &This->IDispatchEx_iface;
 562     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 563         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 564         *ppv = &This->IDispatchEx_iface;
 565     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 566         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 567         *ppv = &This->IDispatchEx_iface;
 568     }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
 569         TRACE("(%p)->(IID_IDispatchJS %p)\n", This, ppv);
 570         jsdisp_addref(This);
 571         *ppv = This;
 572         return S_OK;
 573     }else {
 574         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 575         *ppv = NULL;
 576         return E_NOINTERFACE;
 577     }
 578
 579     jsdisp_addref(This);
 580     return S_OK;
 581 }
 582
 583 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 584 {
 585     jsdisp_t *This = impl_from_IDispatchEx(iface);
 586     jsdisp_addref(This);
 587     return This->ref;
 588 }
 589
 590 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 591 {
 592     jsdisp_t *This = impl_from_IDispatchEx(iface);
 593     ULONG ref = --This->ref;
 594     if(!ref)
 595         jsdisp_free(This);
 596     return ref;
 597 }
 598
 599 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 600 {
 601     jsdisp_t *This = impl_from_IDispatchEx(iface);
 602
 603     TRACE("(%p)->(%p)\n", This, pctinfo);
 604
 605     *pctinfo = 1;
 606     return S_OK;
 607 }
 608
 609 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 610                                               ITypeInfo **ppTInfo)
 611 {
 612     jsdisp_t *This = impl_from_IDispatchEx(iface);
 613     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 618                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 619                                                 DISPID *rgDispId)
 620 {
 621     jsdisp_t *This = impl_from_IDispatchEx(iface);
 622     UINT i;
 623     HRESULT hres;
 624
 625     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 626           lcid, rgDispId);
 627
 628     for(i=0; i < cNames; i++) {
 629         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
 630         if(FAILED(hres))
 631             return hres;
 632     }
 633
 634     return S_OK;
 635 }
 636
 637 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 638                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 639                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 640 {
 641     jsdisp_t *This = impl_from_IDispatchEx(iface);
 642
 643     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 644           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 645
 646     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 647             pDispParams, pVarResult, pExcepInfo, NULL);
 648 }
 649
 650 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 651 {
 652     jsdisp_t *This = impl_from_IDispatchEx(iface);
 653
 654     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 655
 656     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK)) {
 657         FIXME("Unsupported grfdex %x\n", grfdex);
 658         return E_NOTIMPL;
 659     }
 660
 661     return jsdisp_get_id(This, bstrName, grfdex, pid);
 662 }
 663
 664 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 665         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 666 {
 667     jsdisp_t *This = impl_from_IDispatchEx(iface);
 668     dispex_prop_t *prop;
 669     HRESULT hres;
 670
 671     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 672
 673     if(pvarRes)
 674         V_VT(pvarRes) = VT_EMPTY;
 675
 676     prop = get_prop(This, id);
 677     if(!prop || prop->type == PROP_DELETED) {
 678         TRACE("invalid id\n");
 679         return DISP_E_MEMBERNOTFOUND;
 680     }
 681
 682     clear_ei(This->ctx);
 683
 684     switch(wFlags) {
 685     case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 686         wFlags = DISPATCH_METHOD;
 687         /* fall through */
 688     case DISPATCH_METHOD:
 689     case DISPATCH_CONSTRUCT: {
 690         jsval_t *argv, buf[6], r;
 691         unsigned argc;
 692
 693         hres = convert_params(pdp, buf, &argc, &argv);
 694         if(FAILED(hres))
 695             return hres;
 696
 697         hres = invoke_prop_func(This, get_this(pdp), prop, wFlags, argc, argv, pvarRes ? &r : NULL, pspCaller);
 698         if(argv != buf)
 699             heap_free(argv);
 700         if(SUCCEEDED(hres) && pvarRes) {
 701             hres = jsval_to_variant(r, pvarRes);
 702             jsval_release(r);
 703         }
 704         break;
 705     }
 706     case DISPATCH_PROPERTYGET: {
 707         jsval_t r;
 708
 709         hres = prop_get(This, prop, pdp, &r, pspCaller);
 710         if(SUCCEEDED(hres)) {
 711             hres = jsval_to_variant(r, pvarRes);
 712             jsval_release(r);
 713         }
 714         break;
 715     }
 716     case DISPATCH_PROPERTYPUT: {
 717         jsval_t val;
 718         DWORD i;
 719
 720         for(i=0; i < pdp->cNamedArgs; i++) {
 721             if(pdp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
 722                 break;
 723         }
 724
 725         if(i == pdp->cNamedArgs) {
 726             TRACE("no value to set\n");
 727             return DISP_E_PARAMNOTOPTIONAL;
 728         }
 729
 730         hres = variant_to_jsval(pdp->rgvarg+i, &val);
 731         if(FAILED(hres))
 732             return hres;
 733
 734         hres = prop_put(This, prop, val, pspCaller);
 735         jsval_release(val);
 736         break;
 737     }
 738     default:
 739         FIXME("Unimplemented flags %x\n", wFlags);
 740         return E_INVALIDARG;
 741     }
 742
 743     if(pei)
 744         *pei = This->ctx->ei.ei;
 745     return hres;
 746 }
 747
 748 static HRESULT delete_prop(dispex_prop_t *prop, BOOL *ret)
 749 {
 750     if(prop->flags & PROPF_DONTDELETE) {
 751         *ret = FALSE;
 752         return S_OK;
 753     }
 754
 755     *ret = TRUE; /* FIXME: not exactly right */
 756
 757     if(prop->type == PROP_JSVAL) {
 758         jsval_release(prop->u.val);
 759         prop->type = PROP_DELETED;
 760     }
 761     return S_OK;
 762 }
 763
 764 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 765 {
 766     jsdisp_t *This = impl_from_IDispatchEx(iface);
 767     dispex_prop_t *prop;
 768     BOOL b;
 769     HRESULT hres;
 770
 771     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 772
 773     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK))
 774         FIXME("Unsupported grfdex %x\n", grfdex);
 775
 776     hres = find_prop_name(This, string_hash(bstrName), bstrName, &prop);
 777     if(FAILED(hres))
 778         return hres;
 779     if(!prop) {
 780         TRACE("not found\n");
 781         return S_OK;
 782     }
 783
 784     return delete_prop(prop, &b);
 785 }
 786
 787 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 788 {
 789     jsdisp_t *This = impl_from_IDispatchEx(iface);
 790     dispex_prop_t *prop;
 791     BOOL b;
 792
 793     TRACE("(%p)->(%x)\n", This, id);
 794
 795     prop = get_prop(This, id);
 796     if(!prop) {
 797         WARN("invalid id\n");
 798         return DISP_E_MEMBERNOTFOUND;
 799     }
 800
 801     return delete_prop(prop, &b);
 802 }
 803
 804 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 805 {
 806     jsdisp_t *This = impl_from_IDispatchEx(iface);
 807     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 812 {
 813     jsdisp_t *This = impl_from_IDispatchEx(iface);
 814     dispex_prop_t *prop;
 815
 816     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
 817
 818     prop = get_prop(This, id);
 819     if(!prop || !prop->name || prop->type == PROP_DELETED)
 820         return DISP_E_MEMBERNOTFOUND;
 821
 822     *pbstrName = SysAllocString(prop->name);
 823     if(!*pbstrName)
 824         return E_OUTOFMEMORY;
 825
 826     return S_OK;
 827 }
 828
 829 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 830 {
 831     jsdisp_t *This = impl_from_IDispatchEx(iface);
 832     dispex_prop_t *iter;
 833     HRESULT hres;
 834
 835     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 836
 837     if(id == DISPID_STARTENUM) {
 838         hres = fill_protrefs(This);
 839         if(FAILED(hres))
 840             return hres;
 841     }
 842
 843     if(id+1>=0 && id+1<This->prop_cnt) {
 844         iter = &This->props[id+1];
 845     }else {
 846         *pid = DISPID_STARTENUM;
 847         return S_FALSE;
 848     }
 849
 850     while(iter < This->props + This->prop_cnt) {
 851         if(iter->name && (get_flags(This, iter) & PROPF_ENUM) && iter->type!=PROP_DELETED) {
 852             *pid = prop_to_id(This, iter);
 853             return S_OK;
 854         }
 855         iter++;
 856     }
 857
 858     *pid = DISPID_STARTENUM;
 859     return S_FALSE;
 860 }
 861
 862 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 863 {
 864     jsdisp_t *This = impl_from_IDispatchEx(iface);
 865     FIXME("(%p)->(%p)\n", This, ppunk);
 866     return E_NOTIMPL;
 867 }
 868
 869 static IDispatchExVtbl DispatchExVtbl = {
 870     DispatchEx_QueryInterface,
 871     DispatchEx_AddRef,
 872     DispatchEx_Release,
 873     DispatchEx_GetTypeInfoCount,
 874     DispatchEx_GetTypeInfo,
 875     DispatchEx_GetIDsOfNames,
 876     DispatchEx_Invoke,
 877     DispatchEx_GetDispID,
 878     DispatchEx_InvokeEx,
 879     DispatchEx_DeleteMemberByName,
 880     DispatchEx_DeleteMemberByDispID,
 881     DispatchEx_GetMemberProperties,
 882     DispatchEx_GetMemberName,
 883     DispatchEx_GetNextDispID,
 884     DispatchEx_GetNameSpaceParent
 885 };
 886
 887 jsdisp_t *as_jsdisp(IDispatch *disp)
 888 {
 889     assert(disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl);
 890     return impl_from_IDispatchEx((IDispatchEx*)disp);
 891 }
 892
 893 jsdisp_t *to_jsdisp(IDispatch *disp)
 894 {
 895     return disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl ? impl_from_IDispatchEx((IDispatchEx*)disp) : NULL;
 896 }
 897
 898 HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype)
 899 {
 900     TRACE("%p (%p)\n", dispex, prototype);
 901
 902     dispex->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 903     dispex->ref = 1;
 904     dispex->builtin_info = builtin_info;
 905
 906     dispex->props = heap_alloc_zero(sizeof(dispex_prop_t)*(dispex->buf_size=4));
 907     if(!dispex->props)
 908         return E_OUTOFMEMORY;
 909
 910     dispex->prototype = prototype;
 911     if(prototype)
 912         jsdisp_addref(prototype);
 913
 914     dispex->prop_cnt = 1;
 915     if(builtin_info->value_prop.invoke || builtin_info->value_prop.getter) {
 916         dispex->props[0].type = PROP_BUILTIN;
 917         dispex->props[0].u.p = &builtin_info->value_prop;
 918     }else {
 919         dispex->props[0].type = PROP_DELETED;
 920     }
 921
 922     script_addref(ctx);
 923     dispex->ctx = ctx;
 924
 925     return S_OK;
 926 }
 927
 928 static const builtin_info_t dispex_info = {
 929     JSCLASS_NONE,
 930     {NULL, NULL, 0},
 931     0, NULL,
 932     NULL,
 933     NULL
 934 };
 935
 936 HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype, jsdisp_t **dispex)
 937 {
 938     jsdisp_t *ret;
 939     HRESULT hres;
 940
 941     ret = heap_alloc_zero(sizeof(jsdisp_t));
 942     if(!ret)
 943         return E_OUTOFMEMORY;
 944
 945     hres = init_dispex(ret, ctx, builtin_info ? builtin_info : &dispex_info, prototype);
 946     if(FAILED(hres)) {
 947         heap_free(ret);
 948         return hres;
 949     }
 950
 951     *dispex = ret;
 952     return S_OK;
 953 }
 954
 955 void jsdisp_free(jsdisp_t *obj)
 956 {
 957     dispex_prop_t *prop;
 958
 959     TRACE("(%p)\n", obj);
 960
 961     for(prop = obj->props; prop < obj->props+obj->prop_cnt; prop++) {
 962         if(prop->type == PROP_JSVAL)
 963             jsval_release(prop->u.val);
 964         heap_free(prop->name);
 965     }
 966     heap_free(obj->props);
 967     script_release(obj->ctx);
 968     if(obj->prototype)
 969         jsdisp_release(obj->prototype);
 970
 971     if(obj->builtin_info->destructor)
 972         obj->builtin_info->destructor(obj);
 973     else
 974         heap_free(obj);
 975 }
 976
 977 #ifdef TRACE_REFCNT
 978
 979 jsdisp_t *jsdisp_addref(jsdisp_t *jsdisp)
 980 {
 981     ULONG ref = ++jsdisp->ref;
 982     TRACE("(%p) ref=%d\n", jsdisp, ref);
 983     return jsdisp;
 984 }
 985
 986 void jsdisp_release(jsdisp_t *jsdisp)
 987 {
 988     ULONG ref = --jsdisp->ref;
 989
 990     TRACE("(%p) ref=%d\n", jsdisp, ref);
 991
 992     if(!ref)
 993         jsdisp_free(jsdisp);
 994 }
 995
 996 #endif
 997
 998 HRESULT init_dispex_from_constr(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *constr)
 999 {
1000     jsdisp_t *prot = NULL;
1001     dispex_prop_t *prop;
1002     HRESULT hres;
1003
1004     static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
1005
1006     hres = find_prop_name_prot(constr, string_hash(prototypeW), prototypeW, &prop);
1007     if(SUCCEEDED(hres) && prop && prop->type!=PROP_DELETED) {
1008         jsval_t val;
1009
1010         hres = prop_get(constr, prop, NULL, &val, NULL);
1011         if(FAILED(hres)) {
1012             ERR("Could not get prototype\n");
1013             return hres;
1014         }
1015
1016         if(is_object_instance(val))
1017             prot = iface_to_jsdisp((IUnknown*)get_object(val));
1018         jsval_release(val);
1019     }
1020
1021     hres = init_dispex(dispex, ctx, builtin_info, prot);
1022
1023     if(prot)
1024         jsdisp_release(prot);
1025     return hres;
1026 }
1027
1028 jsdisp_t *iface_to_jsdisp(IUnknown *iface)
1029 {
1030     jsdisp_t *ret;
1031     HRESULT hres;
1032
1033     hres = IUnknown_QueryInterface(iface, &IID_IDispatchJS, (void**)&ret);
1034     if(FAILED(hres))
1035         return NULL;
1036
1037     return ret;
1038 }
1039
1040 HRESULT jsdisp_get_id(jsdisp_t *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
1041 {
1042     dispex_prop_t *prop;
1043     HRESULT hres;
1044
1045     if(flags & fdexNameEnsure)
1046         hres = ensure_prop_name(jsdisp, name, TRUE, PROPF_ENUM, &prop);
1047     else
1048         hres = find_prop_name_prot(jsdisp, string_hash(name), name, &prop);
1049     if(FAILED(hres))
1050         return hres;
1051
1052     if(prop && prop->type!=PROP_DELETED) {
1053         *id = prop_to_id(jsdisp, prop);
1054         return S_OK;
1055     }
1056
1057     TRACE("not found %s\n", debugstr_w(name));
1058     return DISP_E_UNKNOWNNAME;
1059 }
1060
1061 HRESULT jsdisp_call_value(jsdisp_t *jsfunc, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1062 {
1063     HRESULT hres;
1064
1065     assert(!(flags & ~(DISPATCH_METHOD|DISPATCH_CONSTRUCT|DISPATCH_JSCRIPT_INTERNAL_MASK)));
1066
1067     if(is_class(jsfunc, JSCLASS_FUNCTION)) {
1068         hres = Function_invoke(jsfunc, jsthis, flags, argc, argv, r);
1069     }else {
1070         vdisp_t vdisp;
1071
1072         if(!jsfunc->builtin_info->value_prop.invoke) {
1073             WARN("Not a function\n");
1074             return throw_type_error(jsfunc->ctx, JS_E_FUNCTION_EXPECTED, NULL);
1075         }
1076
1077         set_disp(&vdisp, jsthis);
1078         flags &= ~DISPATCH_JSCRIPT_INTERNAL_MASK;
1079         hres = jsfunc->builtin_info->value_prop.invoke(jsfunc->ctx, &vdisp, flags, argc, argv, r);
1080         vdisp_release(&vdisp);
1081     }
1082     return hres;
1083 }
1084
1085 HRESULT jsdisp_call(jsdisp_t *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1086 {
1087     dispex_prop_t *prop;
1088
1089     prop = get_prop(disp, id);
1090     if(!prop)
1091         return DISP_E_MEMBERNOTFOUND;
1092
1093     return invoke_prop_func(disp, to_disp(disp), prop, flags, argc, argv, r, NULL);
1094 }
1095
1096 HRESULT jsdisp_call_name(jsdisp_t *disp, const WCHAR *name, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1097 {
1098     dispex_prop_t *prop;
1099     HRESULT hres;
1100
1101     hres = find_prop_name_prot(disp, string_hash(name), name, &prop);
1102     if(FAILED(hres))
1103         return hres;
1104
1105     return invoke_prop_func(disp, to_disp(disp), prop, flags, argc, argv, r, NULL);
1106 }
1107
1108 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *ret)
1109 {
1110     IDispatchEx *dispex;
1111     jsdisp_t *jsdisp;
1112     VARIANT buf[6], retv;
1113     DISPPARAMS dp;
1114     unsigned i;
1115     HRESULT hres;
1116
1117     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1118     if(jsdisp) {
1119         if(flags & DISPATCH_PROPERTYPUT) {
1120             FIXME("disp_call(propput) on builtin object\n");
1121             return E_FAIL;
1122         }
1123
1124         hres = jsdisp_call(jsdisp, id, flags, argc, argv, ret);
1125         jsdisp_release(jsdisp);
1126         return hres;
1127     }
1128
1129     flags &= ~DISPATCH_JSCRIPT_INTERNAL_MASK;
1130     if(ret && argc)
1131         flags |= DISPATCH_PROPERTYGET;
1132
1133     dp.cArgs = argc;
1134
1135     if(flags & DISPATCH_PROPERTYPUT) {
1136         static DISPID propput_dispid = DISPID_PROPERTYPUT;
1137
1138         dp.cNamedArgs = 1;
1139         dp.rgdispidNamedArgs = &propput_dispid;
1140     }else {
1141         dp.cNamedArgs = 0;
1142         dp.rgdispidNamedArgs = NULL;
1143     }
1144
1145     if(argc > 6) {
1146         dp.rgvarg = heap_alloc(argc*sizeof(VARIANT));
1147         if(!dp.rgvarg)
1148             return E_OUTOFMEMORY;
1149     }else {
1150         dp.rgvarg = buf;
1151     }
1152
1153     for(i=0; i<argc; i++) {
1154         hres = jsval_to_variant(argv[i], dp.rgvarg+argc-i-1);
1155         if(FAILED(hres)) {
1156             while(i--)
1157                 VariantClear(dp.rgvarg+argc-i-1);
1158             if(dp.rgvarg != buf)
1159                 heap_free(dp.rgvarg);
1160             return hres;
1161         }
1162     }
1163
1164     V_VT(&retv) = VT_EMPTY;
1165     clear_ei(ctx);
1166     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1167     if(SUCCEEDED(hres)) {
1168         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, &dp, ret ? &retv : NULL, &ctx->ei.ei,
1169                 &ctx->jscaller->IServiceProvider_iface);
1170         IDispatchEx_Release(dispex);
1171     }else {
1172         UINT err = 0;
1173
1174         if(flags == DISPATCH_CONSTRUCT) {
1175             WARN("IDispatch cannot be constructor\n");
1176             return DISP_E_MEMBERNOTFOUND;
1177         }
1178
1179         TRACE("using IDispatch\n");
1180         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, &dp, ret ? &retv : NULL, &ctx->ei.ei, &err);
1181     }
1182
1183     for(i=0; i<argc; i++)
1184         VariantClear(dp.rgvarg+argc-i-1);
1185     if(dp.rgvarg != buf)
1186         heap_free(dp.rgvarg);
1187     if(FAILED(hres))
1188         return hres;
1189
1190     if(ret) {
1191         hres = variant_to_jsval(&retv, ret);
1192         VariantClear(&retv);
1193     }
1194
1195     return hres;
1196 }
1197
1198 HRESULT disp_call_value(script_ctx_t *ctx, IDispatch *disp, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv,
1199         jsval_t *r)
1200 {
1201     jsdisp_t *jsdisp;
1202     IDispatchEx *dispex;
1203     VARIANT buf[6], retv;
1204     DISPPARAMS dp;
1205     unsigned i;
1206     HRESULT hres;
1207
1208     assert(!(flags & ~(DISPATCH_METHOD|DISPATCH_CONSTRUCT|DISPATCH_JSCRIPT_INTERNAL_MASK)));
1209
1210     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1211     if(jsdisp) {
1212         hres = jsdisp_call_value(jsdisp, jsthis, flags, argc, argv, r);
1213         jsdisp_release(jsdisp);
1214         return hres;
1215     }
1216
1217     flags &= ~DISPATCH_JSCRIPT_INTERNAL_MASK;
1218     if(r && argc && flags == DISPATCH_METHOD)
1219         flags |= DISPATCH_PROPERTYGET;
1220
1221     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1222     if(FAILED(hres)) {
1223         TRACE("using IDispatch\n");
1224         dispex = NULL;
1225         jsthis = NULL;
1226     }
1227
1228     if(jsthis) {
1229         static DISPID this_id = DISPID_THIS;
1230
1231         dp.cArgs = argc+1;
1232         dp.cNamedArgs = 1;
1233         dp.rgdispidNamedArgs = &this_id;
1234     }else {
1235         dp.cArgs = argc;
1236         dp.cNamedArgs = 0;
1237         dp.rgdispidNamedArgs = NULL;
1238     }
1239
1240     if(dp.cArgs > sizeof(buf)/sizeof(*buf)) {
1241         dp.rgvarg = heap_alloc(dp.cArgs*sizeof(VARIANT));
1242         if(!dp.rgvarg) {
1243             if(dispex)
1244                 IDispatchEx_Release(dispex);
1245             return E_OUTOFMEMORY;
1246         }
1247     }else {
1248         dp.rgvarg = buf;
1249     }
1250
1251     for(i=0; i<argc; i++) {
1252         hres = jsval_to_variant(argv[i], dp.rgvarg+dp.cArgs-i-1);
1253         if(FAILED(hres)) {
1254             while(i--)
1255                 VariantClear(dp.rgvarg+dp.cArgs-i-1);
1256             if(dp.rgvarg != buf)
1257                 heap_free(dp.rgvarg);
1258             if(dispex)
1259                 IDispatchEx_Release(dispex);
1260             return hres;
1261         }
1262     }
1263     if(jsthis) {
1264         V_VT(dp.rgvarg) = VT_DISPATCH;
1265         V_DISPATCH(dp.rgvarg) = jsthis;
1266     }
1267
1268     V_VT(&retv) = VT_EMPTY;
1269     clear_ei(ctx);
1270     if(dispex) {
1271         hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, ctx->lcid, flags, &dp, r ? &retv : NULL, &ctx->ei.ei,
1272                 &ctx->jscaller->IServiceProvider_iface);
1273         IDispatchEx_Release(dispex);
1274     }else {
1275         UINT err = 0;
1276
1277         if(flags == DISPATCH_CONSTRUCT) {
1278             WARN("IDispatch cannot be constructor\n");
1279             return DISP_E_MEMBERNOTFOUND;
1280         }
1281
1282         hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, ctx->lcid, flags, &dp, r ? &retv : NULL, &ctx->ei.ei, &err);
1283     }
1284
1285     for(i=0; i<argc; i++)
1286         VariantClear(dp.rgvarg+dp.cArgs-i-1);
1287     if(dp.rgvarg != buf)
1288         heap_free(dp.rgvarg);
1289     if(FAILED(hres))
1290         return hres;
1291
1292     if(!r)
1293         return S_OK;
1294
1295     hres = variant_to_jsval(&retv, r);
1296     VariantClear(&retv);
1297     return hres;
1298 }
1299
1300 HRESULT jsdisp_propput(jsdisp_t *obj, const WCHAR *name, DWORD flags, jsval_t val)
1301 {
1302     dispex_prop_t *prop;
1303     HRESULT hres;
1304
1305     hres = ensure_prop_name(obj, name, FALSE, flags, &prop);
1306     if(FAILED(hres))
1307         return hres;
1308
1309     return prop_put(obj, prop, val, NULL);
1310 }
1311
1312 HRESULT jsdisp_propput_name(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1313 {
1314     return jsdisp_propput(obj, name, PROPF_ENUM, val);
1315 }
1316
1317 HRESULT jsdisp_propput_const(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1318 {
1319     dispex_prop_t *prop;
1320     HRESULT hres;
1321
1322     hres = ensure_prop_name(obj, name, FALSE, PROPF_CONST, &prop);
1323     if(FAILED(hres))
1324         return hres;
1325
1326     return jsval_copy(val, &prop->u.val);
1327 }
1328
1329 HRESULT jsdisp_propput_dontenum(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1330 {
1331     return jsdisp_propput(obj, name, 0, val);
1332 }
1333
1334 HRESULT jsdisp_propput_idx(jsdisp_t *obj, DWORD idx, jsval_t val)
1335 {
1336     WCHAR buf[12];
1337
1338     static const WCHAR formatW[] = {'%','d',0};
1339
1340     sprintfW(buf, formatW, idx);
1341     return jsdisp_propput_name(obj, buf, val);
1342 }
1343
1344 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val)
1345 {
1346     jsdisp_t *jsdisp;
1347     HRESULT hres;
1348
1349     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1350     if(jsdisp) {
1351         dispex_prop_t *prop;
1352
1353         prop = get_prop(jsdisp, id);
1354         if(prop)
1355             hres = prop_put(jsdisp, prop, val, NULL);
1356         else
1357             hres = DISP_E_MEMBERNOTFOUND;
1358
1359         jsdisp_release(jsdisp);
1360     }else {
1361         DISPID dispid = DISPID_PROPERTYPUT;
1362         DWORD flags = DISPATCH_PROPERTYPUT;
1363         VARIANT var;
1364         DISPPARAMS dp  = {&var, &dispid, 1, 1};
1365         IDispatchEx *dispex;
1366
1367         hres = jsval_to_variant(val, &var);
1368         if(FAILED(hres))
1369             return hres;
1370
1371         if(V_VT(&var) == VT_DISPATCH)
1372             flags |= DISPATCH_PROPERTYPUTREF;
1373
1374         clear_ei(ctx);
1375         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1376         if(SUCCEEDED(hres)) {
1377             hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, &dp, NULL, &ctx->ei.ei,
1378                     &ctx->jscaller->IServiceProvider_iface);
1379             IDispatchEx_Release(dispex);
1380         }else {
1381             ULONG err = 0;
1382
1383             TRACE("using IDispatch\n");
1384             hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, &dp, NULL, &ctx->ei.ei, &err);
1385         }
1386
1387         VariantClear(&var);
1388     }
1389
1390     return hres;
1391 }
1392
1393 HRESULT jsdisp_propget_name(jsdisp_t *obj, const WCHAR *name, jsval_t *val)
1394 {
1395     DISPPARAMS dp = {NULL, NULL, 0, 0};
1396     dispex_prop_t *prop;
1397     HRESULT hres;
1398
1399     hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1400     if(FAILED(hres))
1401         return hres;
1402
1403     if(!prop || prop->type==PROP_DELETED) {
1404         *val = jsval_undefined();
1405         return S_OK;
1406     }
1407
1408     return prop_get(obj, prop, &dp, val, NULL);
1409 }
1410
1411 HRESULT jsdisp_get_idx(jsdisp_t *obj, DWORD idx, jsval_t *r)
1412 {
1413     WCHAR name[12];
1414     DISPPARAMS dp = {NULL, NULL, 0, 0};
1415     dispex_prop_t *prop;
1416     HRESULT hres;
1417
1418     static const WCHAR formatW[] = {'%','d',0};
1419
1420     sprintfW(name, formatW, idx);
1421
1422     hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1423     if(FAILED(hres))
1424         return hres;
1425
1426     if(!prop || prop->type==PROP_DELETED) {
1427         *r = jsval_undefined();
1428         return DISP_E_UNKNOWNNAME;
1429     }
1430
1431     return prop_get(obj, prop, &dp, r, NULL);
1432 }
1433
1434 HRESULT jsdisp_propget(jsdisp_t *jsdisp, DISPID id, jsval_t *val)
1435 {
1436     DISPPARAMS dp  = {NULL,NULL,0,0};
1437     dispex_prop_t *prop;
1438
1439     prop = get_prop(jsdisp, id);
1440     if(!prop)
1441         return DISP_E_MEMBERNOTFOUND;
1442
1443     return prop_get(jsdisp, prop, &dp, val, NULL);
1444 }
1445
1446 HRESULT disp_propget(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t *val)
1447 {
1448     DISPPARAMS dp  = {NULL,NULL,0,0};
1449     IDispatchEx *dispex;
1450     jsdisp_t *jsdisp;
1451     VARIANT var;
1452     HRESULT hres;
1453
1454     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1455     if(jsdisp) {
1456         hres = jsdisp_propget(jsdisp, id, val);
1457         jsdisp_release(jsdisp);
1458         return hres;
1459     }
1460
1461     V_VT(&var) = VT_EMPTY;
1462     clear_ei(ctx);
1463     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1464     if(SUCCEEDED(hres)) {
1465         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, INVOKE_PROPERTYGET, &dp, &var, &ctx->ei.ei,
1466                 &ctx->jscaller->IServiceProvider_iface);
1467         IDispatchEx_Release(dispex);
1468     }else {
1469         ULONG err = 0;
1470
1471         TRACE("using IDispatch\n");
1472         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, INVOKE_PROPERTYGET, &dp, &var, &ctx->ei.ei, &err);
1473     }
1474     if(FAILED(hres))
1475         return hres;
1476
1477     hres = variant_to_jsval(&var, val);
1478     VariantClear(&var);
1479     return hres;
1480 }
1481
1482 HRESULT jsdisp_delete_idx(jsdisp_t *obj, DWORD idx)
1483 {
1484     static const WCHAR formatW[] = {'%','d',0};
1485     WCHAR buf[12];
1486     dispex_prop_t *prop;
1487     BOOL b;
1488     HRESULT hres;
1489
1490     sprintfW(buf, formatW, idx);
1491
1492     hres = find_prop_name(obj, string_hash(buf), buf, &prop);
1493     if(FAILED(hres) || !prop)
1494         return hres;
1495
1496     return delete_prop(prop, &b);
1497 }
1498
1499 HRESULT disp_delete(IDispatch *disp, DISPID id, BOOL *ret)
1500 {
1501     IDispatchEx *dispex;
1502     jsdisp_t *jsdisp;
1503     HRESULT hres;
1504
1505     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1506     if(jsdisp) {
1507         dispex_prop_t *prop;
1508
1509         prop = get_prop(jsdisp, id);
1510         if(prop)
1511             hres = delete_prop(prop, ret);
1512         else
1513             hres = DISP_E_MEMBERNOTFOUND;
1514
1515         jsdisp_release(jsdisp);
1516         return hres;
1517     }
1518
1519     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1520     if(FAILED(hres)) {
1521         *ret = FALSE;
1522         return S_OK;
1523     }
1524
1525     hres = IDispatchEx_DeleteMemberByDispID(dispex, id);
1526     IDispatchEx_Release(dispex);
1527     if(FAILED(hres))
1528         return hres;
1529
1530     *ret = hres == S_OK;
1531     return S_OK;
1532 }
1533
1534 HRESULT disp_delete_name(script_ctx_t *ctx, IDispatch *disp, jsstr_t *name, BOOL *ret)
1535 {
1536     IDispatchEx *dispex;
1537     jsdisp_t *jsdisp;
1538     BSTR bstr;
1539     HRESULT hres;
1540
1541     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1542     if(jsdisp) {
1543         dispex_prop_t *prop;
1544         const WCHAR *ptr;
1545
1546         ptr = jsstr_flatten(name);
1547         if(!ptr) {
1548             jsdisp_release(jsdisp);
1549             return E_OUTOFMEMORY;
1550         }
1551
1552         hres = find_prop_name(jsdisp, string_hash(ptr), ptr, &prop);
1553         if(prop) {
1554             hres = delete_prop(prop, ret);
1555         }else {
1556             *ret = TRUE;
1557             hres = S_OK;
1558         }
1559
1560         jsdisp_release(jsdisp);
1561         return hres;
1562     }
1563
1564     bstr = SysAllocStringLen(NULL, jsstr_length(name));
1565     if(!bstr)
1566         return E_OUTOFMEMORY;
1567     jsstr_flush(name, bstr);
1568
1569     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1570     if(SUCCEEDED(hres)) {
1571         hres = IDispatchEx_DeleteMemberByName(dispex, bstr, make_grfdex(ctx, fdexNameCaseSensitive));
1572         if(SUCCEEDED(hres))
1573             *ret = hres == S_OK;
1574         IDispatchEx_Release(dispex);
1575     }else {
1576         DISPID id;
1577
1578         hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &bstr, 1, 0, &id);
1579         if(SUCCEEDED(hres)) {
1580             /* Property exists and we can't delete it from pure IDispatch interface, so return false. */
1581             *ret = FALSE;
1582         }else if(hres == DISP_E_UNKNOWNNAME) {
1583             /* Property doesn't exist, so nothing to delete */
1584             *ret = TRUE;
1585             hres = S_OK;
1586         }
1587     }
1588
1589     SysFreeString(bstr);
1590     return hres;
1591 }
1592
1593 HRESULT jsdisp_is_own_prop(jsdisp_t *obj, const WCHAR *name, BOOL *ret)
1594 {
1595     dispex_prop_t *prop;
1596     HRESULT hres;
1597
1598     hres = find_prop_name(obj, string_hash(name), name, &prop);
1599     if(FAILED(hres))
1600         return hres;
1601
1602     *ret = prop && (prop->type == PROP_JSVAL || prop->type == PROP_BUILTIN);
1603     return S_OK;
1604 }
1605
1606 HRESULT jsdisp_is_enumerable(jsdisp_t *obj, const WCHAR *name, BOOL *ret)
1607 {
1608     dispex_prop_t *prop;
1609     HRESULT hres;
1610
1611     hres = find_prop_name(obj, string_hash(name), name, &prop);
1612     if(FAILED(hres))
1613         return hres;
1614
1615     *ret = prop && (prop->flags & PROPF_ENUM) && prop->type != PROP_PROTREF;
1616     return S_OK;
1617 }