dll/win32/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(jsthis)
 381                 set_disp(&vthis, jsthis);
 382             else
 383                 set_jsdisp(&vthis, This);
 384             hres = prop->u.p->invoke(This->ctx, &vthis, flags, argc, argv, r);
 385             vdisp_release(&vthis);
 386         }else {
 387             /* Function object calls are special case */
 388             hres = Function_invoke(This, jsthis, flags, argc, argv, r);
 389         }
 390         return hres;
 391     }
 392     case PROP_PROTREF:
 393         return invoke_prop_func(This->prototype, jsthis, This->prototype->props+prop->u.ref,
 394                 flags, argc, argv, r, caller);
 395     case PROP_JSVAL: {
 396         if(!is_object_instance(prop->u.val)) {
 397             FIXME("invoke %s\n", debugstr_jsval(prop->u.val));
 398             return E_FAIL;
 399         }
 400
 401         TRACE("call %s %p\n", debugstr_w(prop->name), get_object(prop->u.val));
 402
 403         return disp_call_value(This->ctx, get_object(prop->u.val), jsthis, flags, argc, argv, r);
 404     }
 405     case PROP_IDX:
 406         FIXME("Invoking PROP_IDX not yet supported\n");
 407         return E_NOTIMPL;
 408     case PROP_DELETED:
 409         assert(0);
 410     }
 411
 412     assert(0);
 413     return E_FAIL;
 414 }
 415
 416 static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp,
 417         jsval_t *r, IServiceProvider *caller)
 418 {
 419     HRESULT hres;
 420
 421     switch(prop->type) {
 422     case PROP_BUILTIN:
 423         if(prop->u.p->flags & PROPF_METHOD) {
 424             jsdisp_t *obj;
 425             hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->name, NULL,
 426                     prop->u.p->flags, NULL, &obj);
 427             if(FAILED(hres))
 428                 break;
 429
 430             prop->type = PROP_JSVAL;
 431             prop->u.val = jsval_obj(obj);
 432
 433             jsdisp_addref(obj);
 434             *r = jsval_obj(obj);
 435         }else {
 436             vdisp_t vthis;
 437
 438             set_jsdisp(&vthis, This);
 439             hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYGET, 0, NULL, r);
 440             vdisp_release(&vthis);
 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->flags & PROPF_METHOD)) {
 476             vdisp_t vthis;
 477
 478             set_jsdisp(&vthis, This);
 479             hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYPUT, 1, &val, NULL);
 480             vdisp_release(&vthis);
 481             return hres;
 482         }
 483         /* fall through */
 484     case PROP_PROTREF:
 485         prop->type = PROP_JSVAL;
 486         prop->flags = PROPF_ENUM;
 487         prop->u.val = jsval_undefined();
 488         break;
 489     case PROP_JSVAL:
 490         jsval_release(prop->u.val);
 491         break;
 492     case PROP_IDX:
 493         return This->builtin_info->idx_put(This, prop->u.idx, val);
 494     default:
 495         ERR("type %d\n", prop->type);
 496         return E_FAIL;
 497     }
 498
 499     TRACE("%s = %s\n", debugstr_w(prop->name), debugstr_jsval(val));
 500
 501     hres = jsval_copy(val, &prop->u.val);
 502     if(FAILED(hres)) {
 503         prop->u.val = jsval_undefined();
 504         return hres;
 505     }
 506
 507     if(This->builtin_info->on_put)
 508         This->builtin_info->on_put(This, prop->name);
 509
 510     return S_OK;
 511 }
 512
 513 static HRESULT fill_protrefs(jsdisp_t *This)
 514 {
 515     dispex_prop_t *iter, *prop;
 516     HRESULT hres;
 517
 518     if(!This->prototype)
 519         return S_OK;
 520
 521     fill_protrefs(This->prototype);
 522
 523     for(iter = This->prototype->props; iter < This->prototype->props+This->prototype->prop_cnt; iter++) {
 524         if(!iter->name)
 525             continue;
 526         hres = find_prop_name(This, iter->hash, iter->name, &prop);
 527         if(FAILED(hres))
 528             return hres;
 529         if(!prop || prop->type==PROP_DELETED) {
 530             if(prop) {
 531                 prop->type = PROP_PROTREF;
 532                 prop->flags = 0;
 533                 prop->u.ref = iter - This->prototype->props;
 534             }else {
 535                 prop = alloc_protref(This, iter->name, iter - This->prototype->props);
 536                 if(!prop)
 537                     return E_OUTOFMEMORY;
 538             }
 539         }
 540     }
 541
 542     return S_OK;
 543 }
 544
 545 static inline jsdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 546 {
 547     return CONTAINING_RECORD(iface, jsdisp_t, IDispatchEx_iface);
 548 }
 549
 550 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 551 {
 552     jsdisp_t *This = impl_from_IDispatchEx(iface);
 553
 554     if(IsEqualGUID(&IID_IUnknown, riid)) {
 555         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 556         *ppv = &This->IDispatchEx_iface;
 557     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 558         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 559         *ppv = &This->IDispatchEx_iface;
 560     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 561         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 562         *ppv = &This->IDispatchEx_iface;
 563     }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
 564         TRACE("(%p)->(IID_IDispatchJS %p)\n", This, ppv);
 565         jsdisp_addref(This);
 566         *ppv = This;
 567         return S_OK;
 568     }else {
 569         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 570         *ppv = NULL;
 571         return E_NOINTERFACE;
 572     }
 573
 574     jsdisp_addref(This);
 575     return S_OK;
 576 }
 577
 578 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 579 {
 580     jsdisp_t *This = impl_from_IDispatchEx(iface);
 581     jsdisp_addref(This);
 582     return This->ref;
 583 }
 584
 585 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 586 {
 587     jsdisp_t *This = impl_from_IDispatchEx(iface);
 588     ULONG ref = --This->ref;
 589     if(!ref)
 590         jsdisp_free(This);
 591     return ref;
 592 }
 593
 594 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 595 {
 596     jsdisp_t *This = impl_from_IDispatchEx(iface);
 597
 598     TRACE("(%p)->(%p)\n", This, pctinfo);
 599
 600     *pctinfo = 1;
 601     return S_OK;
 602 }
 603
 604 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 605                                               ITypeInfo **ppTInfo)
 606 {
 607     jsdisp_t *This = impl_from_IDispatchEx(iface);
 608     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 613                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 614                                                 DISPID *rgDispId)
 615 {
 616     jsdisp_t *This = impl_from_IDispatchEx(iface);
 617     UINT i;
 618     HRESULT hres;
 619
 620     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 621           lcid, rgDispId);
 622
 623     for(i=0; i < cNames; i++) {
 624         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
 625         if(FAILED(hres))
 626             return hres;
 627     }
 628
 629     return S_OK;
 630 }
 631
 632 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 633                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 634                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 635 {
 636     jsdisp_t *This = impl_from_IDispatchEx(iface);
 637
 638     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 639           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 640
 641     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 642             pDispParams, pVarResult, pExcepInfo, NULL);
 643 }
 644
 645 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 646 {
 647     jsdisp_t *This = impl_from_IDispatchEx(iface);
 648
 649     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 650
 651     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK)) {
 652         FIXME("Unsupported grfdex %x\n", grfdex);
 653         return E_NOTIMPL;
 654     }
 655
 656     return jsdisp_get_id(This, bstrName, grfdex, pid);
 657 }
 658
 659 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 660         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 661 {
 662     jsdisp_t *This = impl_from_IDispatchEx(iface);
 663     dispex_prop_t *prop;
 664     HRESULT hres;
 665
 666     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 667
 668     if(pvarRes)
 669         V_VT(pvarRes) = VT_EMPTY;
 670
 671     prop = get_prop(This, id);
 672     if(!prop || prop->type == PROP_DELETED) {
 673         TRACE("invalid id\n");
 674         return DISP_E_MEMBERNOTFOUND;
 675     }
 676
 677     clear_ei(This->ctx);
 678
 679     switch(wFlags) {
 680     case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 681         wFlags = DISPATCH_METHOD;
 682         /* fall through */
 683     case DISPATCH_METHOD:
 684     case DISPATCH_CONSTRUCT: {
 685         jsval_t *argv, buf[6], r;
 686         unsigned argc;
 687
 688         hres = convert_params(pdp, buf, &argc, &argv);
 689         if(FAILED(hres))
 690             return hres;
 691
 692         hres = invoke_prop_func(This, get_this(pdp), prop, wFlags, argc, argv, pvarRes ? &r : NULL, pspCaller);
 693         if(argv != buf)
 694             heap_free(argv);
 695         if(SUCCEEDED(hres) && pvarRes) {
 696             hres = jsval_to_variant(r, pvarRes);
 697             jsval_release(r);
 698         }
 699         break;
 700     }
 701     case DISPATCH_PROPERTYGET: {
 702         jsval_t r;
 703
 704         hres = prop_get(This, prop, pdp, &r, pspCaller);
 705         if(SUCCEEDED(hres)) {
 706             hres = jsval_to_variant(r, pvarRes);
 707             jsval_release(r);
 708         }
 709         break;
 710     }
 711     case DISPATCH_PROPERTYPUT: {
 712         jsval_t val;
 713         DWORD i;
 714
 715         for(i=0; i < pdp->cNamedArgs; i++) {
 716             if(pdp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
 717                 break;
 718         }
 719
 720         if(i == pdp->cNamedArgs) {
 721             TRACE("no value to set\n");
 722             return DISP_E_PARAMNOTOPTIONAL;
 723         }
 724
 725         hres = variant_to_jsval(pdp->rgvarg+i, &val);
 726         if(FAILED(hres))
 727             return hres;
 728
 729         hres = prop_put(This, prop, val, pspCaller);
 730         jsval_release(val);
 731         break;
 732     }
 733     default:
 734         FIXME("Unimplemented flags %x\n", wFlags);
 735         return E_INVALIDARG;
 736     }
 737
 738     if(pei)
 739         *pei = This->ctx->ei.ei;
 740     return hres;
 741 }
 742
 743 static HRESULT delete_prop(dispex_prop_t *prop, BOOL *ret)
 744 {
 745     if(prop->flags & PROPF_DONTDELETE) {
 746         *ret = FALSE;
 747         return S_OK;
 748     }
 749
 750     *ret = TRUE; /* FIXME: not exactly right */
 751
 752     if(prop->type == PROP_JSVAL) {
 753         jsval_release(prop->u.val);
 754         prop->type = PROP_DELETED;
 755     }
 756     return S_OK;
 757 }
 758
 759 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 760 {
 761     jsdisp_t *This = impl_from_IDispatchEx(iface);
 762     dispex_prop_t *prop;
 763     BOOL b;
 764     HRESULT hres;
 765
 766     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 767
 768     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK))
 769         FIXME("Unsupported grfdex %x\n", grfdex);
 770
 771     hres = find_prop_name(This, string_hash(bstrName), bstrName, &prop);
 772     if(FAILED(hres))
 773         return hres;
 774     if(!prop) {
 775         TRACE("not found\n");
 776         return S_OK;
 777     }
 778
 779     return delete_prop(prop, &b);
 780 }
 781
 782 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 783 {
 784     jsdisp_t *This = impl_from_IDispatchEx(iface);
 785     dispex_prop_t *prop;
 786     BOOL b;
 787
 788     TRACE("(%p)->(%x)\n", This, id);
 789
 790     prop = get_prop(This, id);
 791     if(!prop) {
 792         WARN("invalid id\n");
 793         return DISP_E_MEMBERNOTFOUND;
 794     }
 795
 796     return delete_prop(prop, &b);
 797 }
 798
 799 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 800 {
 801     jsdisp_t *This = impl_from_IDispatchEx(iface);
 802     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 807 {
 808     jsdisp_t *This = impl_from_IDispatchEx(iface);
 809     dispex_prop_t *prop;
 810
 811     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
 812
 813     prop = get_prop(This, id);
 814     if(!prop || !prop->name || prop->type == PROP_DELETED)
 815         return DISP_E_MEMBERNOTFOUND;
 816
 817     *pbstrName = SysAllocString(prop->name);
 818     if(!*pbstrName)
 819         return E_OUTOFMEMORY;
 820
 821     return S_OK;
 822 }
 823
 824 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 825 {
 826     jsdisp_t *This = impl_from_IDispatchEx(iface);
 827     dispex_prop_t *iter;
 828     HRESULT hres;
 829
 830     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 831
 832     if(id == DISPID_STARTENUM) {
 833         hres = fill_protrefs(This);
 834         if(FAILED(hres))
 835             return hres;
 836     }
 837
 838     if(id+1>=0 && id+1<This->prop_cnt) {
 839         iter = &This->props[id+1];
 840     }else {
 841         *pid = DISPID_STARTENUM;
 842         return S_FALSE;
 843     }
 844
 845     while(iter < This->props + This->prop_cnt) {
 846         if(iter->name && (get_flags(This, iter) & PROPF_ENUM) && iter->type!=PROP_DELETED) {
 847             *pid = prop_to_id(This, iter);
 848             return S_OK;
 849         }
 850         iter++;
 851     }
 852
 853     *pid = DISPID_STARTENUM;
 854     return S_FALSE;
 855 }
 856
 857 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 858 {
 859     jsdisp_t *This = impl_from_IDispatchEx(iface);
 860     FIXME("(%p)->(%p)\n", This, ppunk);
 861     return E_NOTIMPL;
 862 }
 863
 864 static IDispatchExVtbl DispatchExVtbl = {
 865     DispatchEx_QueryInterface,
 866     DispatchEx_AddRef,
 867     DispatchEx_Release,
 868     DispatchEx_GetTypeInfoCount,
 869     DispatchEx_GetTypeInfo,
 870     DispatchEx_GetIDsOfNames,
 871     DispatchEx_Invoke,
 872     DispatchEx_GetDispID,
 873     DispatchEx_InvokeEx,
 874     DispatchEx_DeleteMemberByName,
 875     DispatchEx_DeleteMemberByDispID,
 876     DispatchEx_GetMemberProperties,
 877     DispatchEx_GetMemberName,
 878     DispatchEx_GetNextDispID,
 879     DispatchEx_GetNameSpaceParent
 880 };
 881
 882 jsdisp_t *as_jsdisp(IDispatch *disp)
 883 {
 884     assert(disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl);
 885     return impl_from_IDispatchEx((IDispatchEx*)disp);
 886 }
 887
 888 jsdisp_t *to_jsdisp(IDispatch *disp)
 889 {
 890     return disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl ? impl_from_IDispatchEx((IDispatchEx*)disp) : NULL;
 891 }
 892
 893 HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype)
 894 {
 895     TRACE("%p (%p)\n", dispex, prototype);
 896
 897     dispex->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 898     dispex->ref = 1;
 899     dispex->builtin_info = builtin_info;
 900
 901     dispex->props = heap_alloc_zero(sizeof(dispex_prop_t)*(dispex->buf_size=4));
 902     if(!dispex->props)
 903         return E_OUTOFMEMORY;
 904
 905     dispex->prototype = prototype;
 906     if(prototype)
 907         jsdisp_addref(prototype);
 908
 909     dispex->prop_cnt = 1;
 910     if(builtin_info->value_prop.invoke) {
 911         dispex->props[0].type = PROP_BUILTIN;
 912         dispex->props[0].u.p = &builtin_info->value_prop;
 913     }else {
 914         dispex->props[0].type = PROP_DELETED;
 915     }
 916
 917     script_addref(ctx);
 918     dispex->ctx = ctx;
 919
 920     return S_OK;
 921 }
 922
 923 static const builtin_info_t dispex_info = {
 924     JSCLASS_NONE,
 925     {NULL, NULL, 0},
 926     0, NULL,
 927     NULL,
 928     NULL
 929 };
 930
 931 HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype, jsdisp_t **dispex)
 932 {
 933     jsdisp_t *ret;
 934     HRESULT hres;
 935
 936     ret = heap_alloc_zero(sizeof(jsdisp_t));
 937     if(!ret)
 938         return E_OUTOFMEMORY;
 939
 940     hres = init_dispex(ret, ctx, builtin_info ? builtin_info : &dispex_info, prototype);
 941     if(FAILED(hres)) {
 942         heap_free(ret);
 943         return hres;
 944     }
 945
 946     *dispex = ret;
 947     return S_OK;
 948 }
 949
 950 void jsdisp_free(jsdisp_t *obj)
 951 {
 952     dispex_prop_t *prop;
 953
 954     TRACE("(%p)\n", obj);
 955
 956     for(prop = obj->props; prop < obj->props+obj->prop_cnt; prop++) {
 957         if(prop->type == PROP_JSVAL)
 958             jsval_release(prop->u.val);
 959         heap_free(prop->name);
 960     }
 961     heap_free(obj->props);
 962     script_release(obj->ctx);
 963     if(obj->prototype)
 964         jsdisp_release(obj->prototype);
 965
 966     if(obj->builtin_info->destructor)
 967         obj->builtin_info->destructor(obj);
 968     else
 969         heap_free(obj);
 970 }
 971
 972 #ifdef TRACE_REFCNT
 973
 974 jsdisp_t *jsdisp_addref(jsdisp_t *jsdisp)
 975 {
 976     ULONG ref = ++jsdisp->ref;
 977     TRACE("(%p) ref=%d\n", jsdisp, ref);
 978     return jsdisp;
 979 }
 980
 981 void jsdisp_release(jsdisp_t *jsdisp)
 982 {
 983     ULONG ref = --jsdisp->ref;
 984
 985     TRACE("(%p) ref=%d\n", jsdisp, ref);
 986
 987     if(!ref)
 988         jsdisp_free(jsdisp);
 989 }
 990
 991 #endif
 992
 993 HRESULT init_dispex_from_constr(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *constr)
 994 {
 995     jsdisp_t *prot = NULL;
 996     dispex_prop_t *prop;
 997     HRESULT hres;
 998
 999     static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
1000
1001     hres = find_prop_name_prot(constr, string_hash(prototypeW), prototypeW, &prop);
1002     if(SUCCEEDED(hres) && prop && prop->type!=PROP_DELETED) {
1003         jsval_t val;
1004
1005         hres = prop_get(constr, prop, NULL, &val, NULL);
1006         if(FAILED(hres)) {
1007             ERR("Could not get prototype\n");
1008             return hres;
1009         }
1010
1011         if(is_object_instance(val))
1012             prot = iface_to_jsdisp((IUnknown*)get_object(val));
1013         jsval_release(val);
1014     }
1015
1016     hres = init_dispex(dispex, ctx, builtin_info, prot);
1017
1018     if(prot)
1019         jsdisp_release(prot);
1020     return hres;
1021 }
1022
1023 jsdisp_t *iface_to_jsdisp(IUnknown *iface)
1024 {
1025     jsdisp_t *ret;
1026     HRESULT hres;
1027
1028     hres = IUnknown_QueryInterface(iface, &IID_IDispatchJS, (void**)&ret);
1029     if(FAILED(hres))
1030         return NULL;
1031
1032     return ret;
1033 }
1034
1035 HRESULT jsdisp_get_id(jsdisp_t *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
1036 {
1037     dispex_prop_t *prop;
1038     HRESULT hres;
1039
1040     if(flags & fdexNameEnsure)
1041         hres = ensure_prop_name(jsdisp, name, TRUE, PROPF_ENUM, &prop);
1042     else
1043         hres = find_prop_name_prot(jsdisp, string_hash(name), name, &prop);
1044     if(FAILED(hres))
1045         return hres;
1046
1047     if(prop && prop->type!=PROP_DELETED) {
1048         *id = prop_to_id(jsdisp, prop);
1049         return S_OK;
1050     }
1051
1052     TRACE("not found %s\n", debugstr_w(name));
1053     return DISP_E_UNKNOWNNAME;
1054 }
1055
1056 HRESULT jsdisp_call_value(jsdisp_t *jsfunc, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1057 {
1058     HRESULT hres;
1059
1060     if(is_class(jsfunc, JSCLASS_FUNCTION)) {
1061         hres = Function_invoke(jsfunc, jsthis, flags, argc, argv, r);
1062     }else {
1063         vdisp_t vdisp;
1064
1065         set_disp(&vdisp, jsthis);
1066         hres = jsfunc->builtin_info->value_prop.invoke(jsfunc->ctx, &vdisp, flags, argc, argv, r);
1067         vdisp_release(&vdisp);
1068     }
1069     return hres;
1070 }
1071
1072 HRESULT jsdisp_call(jsdisp_t *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1073 {
1074     dispex_prop_t *prop;
1075
1076     prop = get_prop(disp, id);
1077     if(!prop)
1078         return DISP_E_MEMBERNOTFOUND;
1079
1080     return invoke_prop_func(disp, to_disp(disp), prop, flags, argc, argv, r, NULL);
1081 }
1082
1083 HRESULT jsdisp_call_name(jsdisp_t *disp, const WCHAR *name, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1084 {
1085     dispex_prop_t *prop;
1086     HRESULT hres;
1087
1088     hres = find_prop_name_prot(disp, string_hash(name), name, &prop);
1089     if(FAILED(hres))
1090         return hres;
1091
1092     return invoke_prop_func(disp, to_disp(disp), prop, flags, argc, argv, r, NULL);
1093 }
1094
1095 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *ret)
1096 {
1097     IDispatchEx *dispex;
1098     jsdisp_t *jsdisp;
1099     VARIANT buf[6], retv;
1100     DISPPARAMS dp;
1101     unsigned i;
1102     HRESULT hres;
1103
1104     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1105     if(jsdisp) {
1106         if(flags & DISPATCH_PROPERTYPUT) {
1107             FIXME("disp_call(propput) on builtin object\n");
1108             return E_FAIL;
1109         }
1110
1111         hres = jsdisp_call(jsdisp, id, flags, argc, argv, ret);
1112         jsdisp_release(jsdisp);
1113         return hres;
1114     }
1115
1116     if(ret && argc)
1117         flags |= DISPATCH_PROPERTYGET;
1118
1119     dp.cArgs = argc;
1120
1121     if(flags & DISPATCH_PROPERTYPUT) {
1122         static DISPID propput_dispid = DISPID_PROPERTYPUT;
1123
1124         dp.cNamedArgs = 1;
1125         dp.rgdispidNamedArgs = &propput_dispid;
1126     }else {
1127         dp.cNamedArgs = 0;
1128         dp.rgdispidNamedArgs = NULL;
1129     }
1130
1131     if(argc > 6) {
1132         dp.rgvarg = heap_alloc(argc*sizeof(VARIANT));
1133         if(!dp.rgvarg)
1134             return E_OUTOFMEMORY;
1135     }else {
1136         dp.rgvarg = buf;
1137     }
1138
1139     for(i=0; i<argc; i++) {
1140         hres = jsval_to_variant(argv[i], dp.rgvarg+argc-i-1);
1141         if(FAILED(hres)) {
1142             while(i--)
1143                 VariantClear(dp.rgvarg+argc-i-1);
1144             if(dp.rgvarg != buf)
1145                 heap_free(dp.rgvarg);
1146             return hres;
1147         }
1148     }
1149
1150     V_VT(&retv) = VT_EMPTY;
1151     clear_ei(ctx);
1152     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1153     if(SUCCEEDED(hres)) {
1154         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, &dp, ret ? &retv : NULL, &ctx->ei.ei,
1155                 &ctx->jscaller->IServiceProvider_iface);
1156         IDispatchEx_Release(dispex);
1157     }else {
1158         UINT err = 0;
1159
1160         if(flags == DISPATCH_CONSTRUCT) {
1161             WARN("IDispatch cannot be constructor\n");
1162             return DISP_E_MEMBERNOTFOUND;
1163         }
1164
1165         TRACE("using IDispatch\n");
1166         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, &dp, ret ? &retv : NULL, &ctx->ei.ei, &err);
1167     }
1168
1169     for(i=0; i<argc; i++)
1170         VariantClear(dp.rgvarg+argc-i-1);
1171     if(dp.rgvarg != buf)
1172         heap_free(dp.rgvarg);
1173     if(FAILED(hres))
1174         return hres;
1175
1176     if(ret) {
1177         hres = variant_to_jsval(&retv, ret);
1178         VariantClear(&retv);
1179     }
1180     return hres;
1181 }
1182
1183 HRESULT disp_call_value(script_ctx_t *ctx, IDispatch *disp, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv,
1184         jsval_t *r)
1185 {
1186     jsdisp_t *jsdisp;
1187     IDispatchEx *dispex;
1188     VARIANT buf[6], retv;
1189     DISPPARAMS dp;
1190     unsigned i;
1191     HRESULT hres;
1192
1193     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1194     if(jsdisp) {
1195         if(flags & DISPATCH_PROPERTYPUT) {
1196             FIXME("disp_call(propput) on builtin object\n");
1197             return E_FAIL;
1198         }
1199
1200         hres = jsdisp_call_value(jsdisp, jsthis, flags, argc, argv, r);
1201         jsdisp_release(jsdisp);
1202         return hres;
1203     }
1204
1205     if(r && argc)
1206         flags |= DISPATCH_PROPERTYGET;
1207
1208     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1209     if(FAILED(hres)) {
1210         TRACE("using IDispatch\n");
1211         dispex = NULL;
1212         jsthis = NULL;
1213     }
1214
1215     if(jsthis) {
1216         static DISPID this_id = DISPID_THIS;
1217
1218         dp.cArgs = argc+1;
1219         dp.cNamedArgs = 1;
1220         dp.rgdispidNamedArgs = &this_id;
1221     }else {
1222         dp.cArgs = argc;
1223         dp.cNamedArgs = 0;
1224         dp.rgdispidNamedArgs = NULL;
1225     }
1226
1227     if(dp.cArgs > sizeof(buf)/sizeof(*buf)) {
1228         dp.rgvarg = heap_alloc(dp.cArgs*sizeof(VARIANT));
1229         if(!dp.rgvarg) {
1230             if(dispex)
1231                 IDispatchEx_Release(dispex);
1232             return E_OUTOFMEMORY;
1233         }
1234     }else {
1235         dp.rgvarg = buf;
1236     }
1237
1238     for(i=0; i<argc; i++) {
1239         hres = jsval_to_variant(argv[i], dp.rgvarg+dp.cArgs-i-1);
1240         if(FAILED(hres)) {
1241             while(i--)
1242                 VariantClear(dp.rgvarg+dp.cArgs-i-1);
1243             if(dp.rgvarg != buf)
1244                 heap_free(dp.rgvarg);
1245             if(dispex)
1246                 IDispatchEx_Release(dispex);
1247             return hres;
1248         }
1249     }
1250     if(jsthis) {
1251         V_VT(dp.rgvarg) = VT_DISPATCH;
1252         V_DISPATCH(dp.rgvarg) = jsthis;
1253     }
1254
1255     V_VT(&retv) = VT_EMPTY;
1256     clear_ei(ctx);
1257     if(dispex) {
1258         hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, ctx->lcid, flags, &dp, r ? &retv : NULL, &ctx->ei.ei,
1259                 &ctx->jscaller->IServiceProvider_iface);
1260         IDispatchEx_Release(dispex);
1261     }else {
1262         UINT err = 0;
1263
1264         if(flags == DISPATCH_CONSTRUCT) {
1265             WARN("IDispatch cannot be constructor\n");
1266             return DISP_E_MEMBERNOTFOUND;
1267         }
1268
1269         hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, ctx->lcid, flags, &dp, r ? &retv : NULL, &ctx->ei.ei, &err);
1270     }
1271
1272     for(i=0; i<argc; i++)
1273         VariantClear(dp.rgvarg+dp.cArgs-i-1);
1274     if(dp.rgvarg != buf)
1275         heap_free(dp.rgvarg);
1276     if(FAILED(hres))
1277         return hres;
1278
1279     if(!r)
1280         return S_OK;
1281
1282     hres = variant_to_jsval(&retv, r);
1283     VariantClear(&retv);
1284     return hres;
1285 }
1286
1287 HRESULT jsdisp_propput(jsdisp_t *obj, const WCHAR *name, DWORD flags, jsval_t val)
1288 {
1289     dispex_prop_t *prop;
1290     HRESULT hres;
1291
1292     hres = ensure_prop_name(obj, name, FALSE, flags, &prop);
1293     if(FAILED(hres))
1294         return hres;
1295
1296     return prop_put(obj, prop, val, NULL);
1297 }
1298
1299 HRESULT jsdisp_propput_name(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1300 {
1301     return jsdisp_propput(obj, name, PROPF_ENUM, val);
1302 }
1303
1304 HRESULT jsdisp_propput_const(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1305 {
1306     dispex_prop_t *prop;
1307     HRESULT hres;
1308
1309     hres = ensure_prop_name(obj, name, FALSE, PROPF_CONST, &prop);
1310     if(FAILED(hres))
1311         return hres;
1312
1313     return jsval_copy(val, &prop->u.val);
1314 }
1315
1316 HRESULT jsdisp_propput_dontenum(jsdisp_t *obj, const WCHAR *name, jsval_t val)
1317 {
1318     return jsdisp_propput(obj, name, 0, val);
1319 }
1320
1321 HRESULT jsdisp_propput_idx(jsdisp_t *obj, DWORD idx, jsval_t val)
1322 {
1323     WCHAR buf[12];
1324
1325     static const WCHAR formatW[] = {'%','d',0};
1326
1327     sprintfW(buf, formatW, idx);
1328     return jsdisp_propput_name(obj, buf, val);
1329 }
1330
1331 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val)
1332 {
1333     jsdisp_t *jsdisp;
1334     HRESULT hres;
1335
1336     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1337     if(jsdisp) {
1338         dispex_prop_t *prop;
1339
1340         prop = get_prop(jsdisp, id);
1341         if(prop)
1342             hres = prop_put(jsdisp, prop, val, NULL);
1343         else
1344             hres = DISP_E_MEMBERNOTFOUND;
1345
1346         jsdisp_release(jsdisp);
1347     }else {
1348         DISPID dispid = DISPID_PROPERTYPUT;
1349         VARIANT var;
1350         DISPPARAMS dp  = {&var, &dispid, 1, 1};
1351         IDispatchEx *dispex;
1352
1353         hres = jsval_to_variant(val, &var);
1354         if(FAILED(hres))
1355             return hres;
1356
1357         clear_ei(ctx);
1358         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1359         if(SUCCEEDED(hres)) {
1360             hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ctx->ei.ei,
1361                     &ctx->jscaller->IServiceProvider_iface);
1362             IDispatchEx_Release(dispex);
1363         }else {
1364             ULONG err = 0;
1365
1366             TRACE("using IDispatch\n");
1367             hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ctx->ei.ei, &err);
1368         }
1369
1370         VariantClear(&var);
1371     }
1372
1373     return hres;
1374 }
1375
1376 HRESULT jsdisp_propget_name(jsdisp_t *obj, const WCHAR *name, jsval_t *val)
1377 {
1378     DISPPARAMS dp = {NULL, NULL, 0, 0};
1379     dispex_prop_t *prop;
1380     HRESULT hres;
1381
1382     hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1383     if(FAILED(hres))
1384         return hres;
1385
1386     if(!prop || prop->type==PROP_DELETED) {
1387         *val = jsval_undefined();
1388         return S_OK;
1389     }
1390
1391     return prop_get(obj, prop, &dp, val, NULL);
1392 }
1393
1394 HRESULT jsdisp_get_idx(jsdisp_t *obj, DWORD idx, jsval_t *r)
1395 {
1396     WCHAR name[12];
1397     DISPPARAMS dp = {NULL, NULL, 0, 0};
1398     dispex_prop_t *prop;
1399     HRESULT hres;
1400
1401     static const WCHAR formatW[] = {'%','d',0};
1402
1403     sprintfW(name, formatW, idx);
1404
1405     hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1406     if(FAILED(hres))
1407         return hres;
1408
1409     if(!prop || prop->type==PROP_DELETED) {
1410         *r = jsval_undefined();
1411         return DISP_E_UNKNOWNNAME;
1412     }
1413
1414     return prop_get(obj, prop, &dp, r, NULL);
1415 }
1416
1417 HRESULT jsdisp_propget(jsdisp_t *jsdisp, DISPID id, jsval_t *val)
1418 {
1419     DISPPARAMS dp  = {NULL,NULL,0,0};
1420     dispex_prop_t *prop;
1421
1422     prop = get_prop(jsdisp, id);
1423     if(!prop)
1424         return DISP_E_MEMBERNOTFOUND;
1425
1426     return prop_get(jsdisp, prop, &dp, val, NULL);
1427 }
1428
1429 HRESULT disp_propget(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t *val)
1430 {
1431     DISPPARAMS dp  = {NULL,NULL,0,0};
1432     IDispatchEx *dispex;
1433     jsdisp_t *jsdisp;
1434     VARIANT var;
1435     HRESULT hres;
1436
1437     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1438     if(jsdisp) {
1439         hres = jsdisp_propget(jsdisp, id, val);
1440         jsdisp_release(jsdisp);
1441         return hres;
1442     }
1443
1444     V_VT(&var) = VT_EMPTY;
1445     clear_ei(ctx);
1446     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1447     if(SUCCEEDED(hres)) {
1448         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, INVOKE_PROPERTYGET, &dp, &var, &ctx->ei.ei,
1449                 &ctx->jscaller->IServiceProvider_iface);
1450         IDispatchEx_Release(dispex);
1451     }else {
1452         ULONG err = 0;
1453
1454         TRACE("using IDispatch\n");
1455         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, INVOKE_PROPERTYGET, &dp, &var, &ctx->ei.ei, &err);
1456     }
1457     if(FAILED(hres))
1458         return hres;
1459
1460     hres = variant_to_jsval(&var, val);
1461     VariantClear(&var);
1462     return hres;
1463 }
1464
1465 HRESULT jsdisp_delete_idx(jsdisp_t *obj, DWORD idx)
1466 {
1467     static const WCHAR formatW[] = {'%','d',0};
1468     WCHAR buf[12];
1469     dispex_prop_t *prop;
1470     BOOL b;
1471     HRESULT hres;
1472
1473     sprintfW(buf, formatW, idx);
1474
1475     hres = find_prop_name(obj, string_hash(buf), buf, &prop);
1476     if(FAILED(hres) || !prop)
1477         return hres;
1478
1479     return delete_prop(prop, &b);
1480 }
1481
1482 HRESULT disp_delete(IDispatch *disp, DISPID id, BOOL *ret)
1483 {
1484     IDispatchEx *dispex;
1485     jsdisp_t *jsdisp;
1486     HRESULT hres;
1487
1488     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1489     if(jsdisp) {
1490         dispex_prop_t *prop;
1491
1492         prop = get_prop(jsdisp, id);
1493         if(prop)
1494             hres = delete_prop(prop, ret);
1495         else
1496             hres = DISP_E_MEMBERNOTFOUND;
1497
1498         jsdisp_release(jsdisp);
1499         return hres;
1500     }
1501
1502     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1503     if(FAILED(hres)) {
1504         *ret = FALSE;
1505         return S_OK;
1506     }
1507
1508     hres = IDispatchEx_DeleteMemberByDispID(dispex, id);
1509     IDispatchEx_Release(dispex);
1510     if(FAILED(hres))
1511         return hres;
1512
1513     *ret = hres == S_OK;
1514     return S_OK;
1515 }
1516
1517 HRESULT disp_delete_name(script_ctx_t *ctx, IDispatch *disp, jsstr_t *name, BOOL *ret)
1518 {
1519     IDispatchEx *dispex;
1520     jsdisp_t *jsdisp;
1521     BSTR bstr;
1522     HRESULT hres;
1523
1524     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1525     if(jsdisp) {
1526         dispex_prop_t *prop;
1527
1528         hres = find_prop_name(jsdisp, string_hash(name->str), name->str, &prop);
1529         if(prop) {
1530             hres = delete_prop(prop, ret);
1531         }else {
1532             *ret = TRUE;
1533             hres = S_OK;
1534         }
1535
1536         jsdisp_release(jsdisp);
1537         return hres;
1538     }
1539
1540     bstr = SysAllocStringLen(NULL, jsstr_length(name));
1541     if(!bstr)
1542         return E_OUTOFMEMORY;
1543     jsstr_flush(name, bstr);
1544
1545     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1546     if(SUCCEEDED(hres)) {
1547         hres = IDispatchEx_DeleteMemberByName(dispex, bstr, make_grfdex(ctx, fdexNameCaseSensitive));
1548         if(SUCCEEDED(hres))
1549             *ret = hres == S_OK;
1550         IDispatchEx_Release(dispex);
1551     }else {
1552         DISPID id;
1553
1554         hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &bstr, 1, 0, &id);
1555         if(SUCCEEDED(hres)) {
1556             /* Property exists and we can't delete it from pure IDispatch interface, so return false. */
1557             *ret = FALSE;
1558         }else if(hres == DISP_E_UNKNOWNNAME) {
1559             /* Property doesn't exist, so nothing to delete */
1560             *ret = TRUE;
1561             hres = S_OK;
1562         }
1563     }
1564
1565     SysFreeString(bstr);
1566     return hres;
1567 }
1568
1569 HRESULT jsdisp_is_own_prop(jsdisp_t *obj, const WCHAR *name, BOOL *ret)
1570 {
1571     dispex_prop_t *prop;
1572     HRESULT hres;
1573
1574     hres = find_prop_name(obj, string_hash(name), name, &prop);
1575     if(FAILED(hres))
1576         return hres;
1577
1578     *ret = prop && (prop->type == PROP_JSVAL || prop->type == PROP_BUILTIN);
1579     return S_OK;
1580 }
1581
1582 HRESULT jsdisp_is_enumerable(jsdisp_t *obj, const WCHAR *name, BOOL *ret)
1583 {
1584     dispex_prop_t *prop;
1585     HRESULT hres;
1586
1587     hres = find_prop_name(obj, string_hash(name), name, &prop);
1588     if(FAILED(hres))
1589         return hres;
1590
1591     *ret = prop && (prop->flags & PROPF_ENUM) && prop->type != PROP_PROTREF;
1592     return S_OK;
1593 }