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 "jscript.h"
  20
  21 #include "wine/unicode.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  25
  26 /*
  27  * This IID is used to get jsdisp_t objecto from interface.
  28  * We might consider using private insteface instead.
  29  */
  30 static const IID IID_IDispatchJS =
  31         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
  32
  33 #define FDEX_VERSION_MASK 0xf0000000
  34
  35 typedef enum {
  36     PROP_VARIANT,
  37     PROP_BUILTIN,
  38     PROP_PROTREF,
  39     PROP_DELETED
  40 } prop_type_t;
  41
  42 struct _dispex_prop_t {
  43     WCHAR *name;
  44     prop_type_t type;
  45     DWORD flags;
  46
  47     union {
  48         VARIANT var;
  49         const builtin_prop_t *p;
  50         DWORD ref;
  51     } u;
  52 };
  53
  54 static inline DISPID prop_to_id(jsdisp_t *This, dispex_prop_t *prop)
  55 {
  56     return prop - This->props;
  57 }
  58
  59 static inline dispex_prop_t *get_prop(jsdisp_t *This, DISPID id)
  60 {
  61     if(id < 0 || id >= This->prop_cnt || This->props[id].type == PROP_DELETED)
  62         return NULL;
  63
  64     return This->props+id;
  65 }
  66
  67 static DWORD get_flags(jsdisp_t *This, dispex_prop_t *prop)
  68 {
  69     if(prop->type == PROP_PROTREF) {
  70         dispex_prop_t *parent = get_prop(This->prototype, prop->u.ref);
  71         if(!parent) {
  72             prop->type = PROP_DELETED;
  73             return 0;
  74         }
  75
  76         return get_flags(This->prototype, parent);
  77     }
  78
  79     return prop->flags;
  80 }
  81
  82 static const builtin_prop_t *find_builtin_prop(jsdisp_t *This, const WCHAR *name)
  83 {
  84     int min = 0, max, i, r;
  85
  86     max = This->builtin_info->props_cnt-1;
  87     while(min <= max) {
  88         i = (min+max)/2;
  89
  90         r = strcmpW(name, This->builtin_info->props[i].name);
  91         if(!r)
  92             return This->builtin_info->props + i;
  93
  94         if(r < 0)
  95             max = i-1;
  96         else
  97             min = i+1;
  98     }
  99
 100     return NULL;
 101 }
 102
 103 static dispex_prop_t *alloc_prop(jsdisp_t *This, const WCHAR *name, prop_type_t type, DWORD flags)
 104 {
 105     dispex_prop_t *ret;
 106
 107     if(This->buf_size == This->prop_cnt) {
 108         dispex_prop_t *tmp = heap_realloc(This->props, (This->buf_size<<=1)*sizeof(*This->props));
 109         if(!tmp)
 110             return NULL;
 111         This->props = tmp;
 112     }
 113
 114     ret = This->props + This->prop_cnt++;
 115     ret->type = type;
 116     ret->flags = flags;
 117     ret->name = heap_strdupW(name);
 118     if(!ret->name)
 119         return NULL;
 120
 121     return ret;
 122 }
 123
 124 static dispex_prop_t *alloc_protref(jsdisp_t *This, const WCHAR *name, DWORD ref)
 125 {
 126     dispex_prop_t *ret;
 127
 128     ret = alloc_prop(This, name, PROP_PROTREF, 0);
 129     if(!ret)
 130         return NULL;
 131
 132     ret->u.ref = ref;
 133     return ret;
 134 }
 135
 136 static HRESULT find_prop_name(jsdisp_t *This, const WCHAR *name, dispex_prop_t **ret)
 137 {
 138     const builtin_prop_t *builtin;
 139     dispex_prop_t *prop;
 140
 141     for(prop = This->props; prop < This->props+This->prop_cnt; prop++) {
 142         if(prop->name && !strcmpW(prop->name, name)) {
 143             *ret = prop;
 144             return S_OK;
 145         }
 146     }
 147
 148     builtin = find_builtin_prop(This, name);
 149     if(builtin) {
 150         prop = alloc_prop(This, name, PROP_BUILTIN, builtin->flags);
 151         if(!prop)
 152             return E_OUTOFMEMORY;
 153
 154         prop->u.p = builtin;
 155         *ret = prop;
 156         return S_OK;
 157     }
 158
 159     *ret = NULL;
 160     return S_OK;
 161 }
 162
 163 static HRESULT find_prop_name_prot(jsdisp_t *This, const WCHAR *name, dispex_prop_t **ret)
 164 {
 165     dispex_prop_t *prop;
 166     HRESULT hres;
 167
 168     hres = find_prop_name(This, name, &prop);
 169     if(FAILED(hres))
 170         return hres;
 171     if(prop) {
 172         *ret = prop;
 173         return S_OK;
 174     }
 175
 176     if(This->prototype) {
 177         hres = find_prop_name_prot(This->prototype, name, &prop);
 178         if(FAILED(hres))
 179             return hres;
 180         if(prop) {
 181             prop = alloc_protref(This, prop->name, prop - This->prototype->props);
 182             if(!prop)
 183                 return E_OUTOFMEMORY;
 184             *ret = prop;
 185             return S_OK;
 186         }
 187     }
 188
 189     *ret = prop;
 190     return S_OK;
 191 }
 192
 193 static HRESULT ensure_prop_name(jsdisp_t *This, const WCHAR *name, BOOL search_prot, DWORD create_flags, dispex_prop_t **ret)
 194 {
 195     dispex_prop_t *prop;
 196     HRESULT hres;
 197
 198     if(search_prot)
 199         hres = find_prop_name_prot(This, name, &prop);
 200     else
 201         hres = find_prop_name(This, name, &prop);
 202     if(SUCCEEDED(hres) && !prop) {
 203         TRACE("creating prop %s\n", debugstr_w(name));
 204
 205         prop = alloc_prop(This, name, PROP_VARIANT, create_flags);
 206         if(!prop)
 207             return E_OUTOFMEMORY;
 208         VariantInit(&prop->u.var);
 209     }
 210
 211     *ret = prop;
 212     return hres;
 213 }
 214
 215 static HRESULT set_this(DISPPARAMS *dp, DISPPARAMS *olddp, IDispatch *jsthis)
 216 {
 217     VARIANTARG *oldargs;
 218     int i;
 219
 220     static DISPID this_id = DISPID_THIS;
 221
 222     *dp = *olddp;
 223
 224     for(i = 0; i < dp->cNamedArgs; i++) {
 225         if(dp->rgdispidNamedArgs[i] == DISPID_THIS)
 226             return S_OK;
 227     }
 228
 229     oldargs = dp->rgvarg;
 230     dp->rgvarg = heap_alloc((dp->cArgs+1) * sizeof(VARIANTARG));
 231     if(!dp->rgvarg)
 232         return E_OUTOFMEMORY;
 233     memcpy(dp->rgvarg+1, oldargs, dp->cArgs*sizeof(VARIANTARG));
 234     V_VT(dp->rgvarg) = VT_DISPATCH;
 235     V_DISPATCH(dp->rgvarg) = jsthis;
 236     dp->cArgs++;
 237
 238     if(dp->cNamedArgs) {
 239         DISPID *old = dp->rgdispidNamedArgs;
 240         dp->rgdispidNamedArgs = heap_alloc((dp->cNamedArgs+1)*sizeof(DISPID));
 241         if(!dp->rgdispidNamedArgs) {
 242             heap_free(dp->rgvarg);
 243             return E_OUTOFMEMORY;
 244         }
 245
 246         memcpy(dp->rgdispidNamedArgs+1, old, dp->cNamedArgs*sizeof(DISPID));
 247         dp->rgdispidNamedArgs[0] = DISPID_THIS;
 248         dp->cNamedArgs++;
 249     }else {
 250         dp->rgdispidNamedArgs = &this_id;
 251         dp->cNamedArgs = 1;
 252     }
 253
 254     return S_OK;
 255 }
 256
 257 static HRESULT invoke_prop_func(jsdisp_t *This, jsdisp_t *jsthis, dispex_prop_t *prop, WORD flags,
 258         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 259 {
 260     HRESULT hres;
 261
 262     switch(prop->type) {
 263     case PROP_BUILTIN: {
 264         vdisp_t vthis;
 265
 266         if(flags == DISPATCH_CONSTRUCT && (prop->flags & PROPF_METHOD)) {
 267             WARN("%s is not a constructor\n", debugstr_w(prop->name));
 268             return E_INVALIDARG;
 269         }
 270
 271         set_jsdisp(&vthis, jsthis);
 272         hres = prop->u.p->invoke(This->ctx, &vthis, flags, dp, retv, ei, caller);
 273         vdisp_release(&vthis);
 274         return hres;
 275     }
 276     case PROP_PROTREF:
 277         return invoke_prop_func(This->prototype, jsthis, This->prototype->props+prop->u.ref, flags, dp, retv, ei, caller);
 278     case PROP_VARIANT: {
 279         DISPPARAMS new_dp;
 280
 281         if(V_VT(&prop->u.var) != VT_DISPATCH) {
 282             FIXME("invoke vt %d\n", V_VT(&prop->u.var));
 283             return E_FAIL;
 284         }
 285
 286         TRACE("call %s %p\n", debugstr_w(prop->name), V_DISPATCH(&prop->u.var));
 287
 288         hres = set_this(&new_dp, dp, to_disp(jsthis));
 289         if(FAILED(hres))
 290             return hres;
 291
 292         hres = disp_call(This->ctx, V_DISPATCH(&prop->u.var), DISPID_VALUE, flags, &new_dp, retv, ei, caller);
 293
 294         if(new_dp.rgvarg != dp->rgvarg) {
 295             heap_free(new_dp.rgvarg);
 296             if(new_dp.cNamedArgs > 1)
 297                 heap_free(new_dp.rgdispidNamedArgs);
 298         }
 299
 300         return hres;
 301     }
 302     default:
 303         ERR("type %d\n", prop->type);
 304     }
 305
 306     return E_FAIL;
 307 }
 308
 309 static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp,
 310         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 311 {
 312     HRESULT hres;
 313
 314     switch(prop->type) {
 315     case PROP_BUILTIN:
 316         if(prop->u.p->flags & PROPF_METHOD) {
 317             jsdisp_t *obj;
 318             hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->name, NULL,
 319                     prop->u.p->flags, NULL, &obj);
 320             if(FAILED(hres))
 321                 break;
 322
 323             prop->type = PROP_VARIANT;
 324             var_set_jsdisp(&prop->u.var, obj);
 325             hres = VariantCopy(retv, &prop->u.var);
 326         }else {
 327             vdisp_t vthis;
 328
 329             set_jsdisp(&vthis, This);
 330             hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYGET, dp, retv, ei, caller);
 331             vdisp_release(&vthis);
 332         }
 333         break;
 334     case PROP_PROTREF:
 335         hres = prop_get(This->prototype, This->prototype->props+prop->u.ref, dp, retv, ei, caller);
 336         break;
 337     case PROP_VARIANT:
 338         hres = VariantCopy(retv, &prop->u.var);
 339         break;
 340     default:
 341         ERR("type %d\n", prop->type);
 342         return E_FAIL;
 343     }
 344
 345     if(FAILED(hres)) {
 346         TRACE("fail %08x\n", hres);
 347         return hres;
 348     }
 349
 350     TRACE("%s ret %s\n", debugstr_w(prop->name), debugstr_variant(retv));
 351     return hres;
 352 }
 353
 354 static HRESULT prop_put(jsdisp_t *This, dispex_prop_t *prop, VARIANT *val,
 355         jsexcept_t *ei, IServiceProvider *caller)
 356 {
 357     HRESULT hres;
 358
 359     if(prop->flags & PROPF_CONST)
 360         return S_OK;
 361
 362     switch(prop->type) {
 363     case PROP_BUILTIN:
 364         if(!(prop->flags & PROPF_METHOD)) {
 365             DISPPARAMS dp = {val, NULL, 1, 0};
 366             vdisp_t vthis;
 367
 368             set_jsdisp(&vthis, This);
 369             hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYPUT, &dp, NULL, ei, caller);
 370             vdisp_release(&vthis);
 371             return hres;
 372         }
 373     case PROP_PROTREF:
 374         prop->type = PROP_VARIANT;
 375         prop->flags = PROPF_ENUM;
 376         V_VT(&prop->u.var) = VT_EMPTY;
 377         break;
 378     case PROP_VARIANT:
 379         VariantClear(&prop->u.var);
 380         break;
 381     default:
 382         ERR("type %d\n", prop->type);
 383         return E_FAIL;
 384     }
 385
 386     hres = VariantCopy(&prop->u.var, val);
 387     if(FAILED(hres))
 388         return hres;
 389
 390     if(This->builtin_info->on_put)
 391         This->builtin_info->on_put(This, prop->name);
 392
 393     TRACE("%s = %s\n", debugstr_w(prop->name), debugstr_variant(val));
 394     return S_OK;
 395 }
 396
 397 static HRESULT fill_protrefs(jsdisp_t *This)
 398 {
 399     dispex_prop_t *iter, *prop;
 400     HRESULT hres;
 401
 402     if(!This->prototype)
 403         return S_OK;
 404
 405     fill_protrefs(This->prototype);
 406
 407     for(iter = This->prototype->props; iter < This->prototype->props+This->prototype->prop_cnt; iter++) {
 408         if(!iter->name)
 409             continue;
 410         hres = find_prop_name(This, iter->name, &prop);
 411         if(FAILED(hres))
 412             return hres;
 413         if(!prop) {
 414             prop = alloc_protref(This, iter->name, iter - This->prototype->props);
 415             if(!prop)
 416                 return E_OUTOFMEMORY;
 417         }
 418     }
 419
 420     return S_OK;
 421 }
 422
 423 static inline jsdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 424 {
 425     return CONTAINING_RECORD(iface, jsdisp_t, IDispatchEx_iface);
 426 }
 427
 428 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 429 {
 430     jsdisp_t *This = impl_from_IDispatchEx(iface);
 431
 432     if(IsEqualGUID(&IID_IUnknown, riid)) {
 433         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 434         *ppv = &This->IDispatchEx_iface;
 435     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 436         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 437         *ppv = &This->IDispatchEx_iface;
 438     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 439         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 440         *ppv = &This->IDispatchEx_iface;
 441     }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
 442         TRACE("(%p)->(IID_IDispatchJS %p)\n", This, ppv);
 443         jsdisp_addref(This);
 444         *ppv = This;
 445         return S_OK;
 446     }else {
 447         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 448         *ppv = NULL;
 449         return E_NOINTERFACE;
 450     }
 451
 452     IUnknown_AddRef((IUnknown*)*ppv);
 453     return S_OK;
 454 }
 455
 456 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 457 {
 458     jsdisp_t *This = impl_from_IDispatchEx(iface);
 459     LONG ref = InterlockedIncrement(&This->ref);
 460
 461     TRACE("(%p) ref=%d\n", This, ref);
 462
 463     return ref;
 464 }
 465
 466 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 467 {
 468     jsdisp_t *This = impl_from_IDispatchEx(iface);
 469     LONG ref = InterlockedDecrement(&This->ref);
 470
 471     TRACE("(%p) ref=%d\n", This, ref);
 472
 473     if(!ref) {
 474         dispex_prop_t *prop;
 475
 476         for(prop = This->props; prop < This->props+This->prop_cnt; prop++) {
 477             if(prop->type == PROP_VARIANT)
 478                 VariantClear(&prop->u.var);
 479             heap_free(prop->name);
 480         }
 481         heap_free(This->props);
 482         script_release(This->ctx);
 483         if(This->prototype)
 484             jsdisp_release(This->prototype);
 485
 486         if(This->builtin_info->destructor)
 487             This->builtin_info->destructor(This);
 488         else
 489             heap_free(This);
 490     }
 491
 492     return ref;
 493 }
 494
 495 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 496 {
 497     jsdisp_t *This = impl_from_IDispatchEx(iface);
 498
 499     TRACE("(%p)->(%p)\n", This, pctinfo);
 500
 501     *pctinfo = 1;
 502     return S_OK;
 503 }
 504
 505 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 506                                               ITypeInfo **ppTInfo)
 507 {
 508     jsdisp_t *This = impl_from_IDispatchEx(iface);
 509     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 514                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 515                                                 DISPID *rgDispId)
 516 {
 517     jsdisp_t *This = impl_from_IDispatchEx(iface);
 518     UINT i;
 519     HRESULT hres;
 520
 521     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 522           lcid, rgDispId);
 523
 524     for(i=0; i < cNames; i++) {
 525         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
 526         if(FAILED(hres))
 527             return hres;
 528     }
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 534                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 535                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 536 {
 537     jsdisp_t *This = impl_from_IDispatchEx(iface);
 538
 539     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 540           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 541
 542     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 543             pDispParams, pVarResult, pExcepInfo, NULL);
 544 }
 545
 546 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 547 {
 548     jsdisp_t *This = impl_from_IDispatchEx(iface);
 549
 550     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 551
 552     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK)) {
 553         FIXME("Unsupported grfdex %x\n", grfdex);
 554         return E_NOTIMPL;
 555     }
 556
 557     return jsdisp_get_id(This, bstrName, grfdex, pid);
 558 }
 559
 560 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 561         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 562 {
 563     jsdisp_t *This = impl_from_IDispatchEx(iface);
 564     dispex_prop_t *prop;
 565     jsexcept_t jsexcept;
 566     HRESULT hres;
 567
 568     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 569
 570     if(pvarRes)
 571         V_VT(pvarRes) = VT_EMPTY;
 572
 573     prop = get_prop(This, id);
 574     if(!prop || prop->type == PROP_DELETED) {
 575         TRACE("invalid id\n");
 576         return DISP_E_MEMBERNOTFOUND;
 577     }
 578
 579     memset(&jsexcept, 0, sizeof(jsexcept));
 580
 581     switch(wFlags) {
 582     case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 583         wFlags = DISPATCH_METHOD;
 584     case DISPATCH_METHOD:
 585     case DISPATCH_CONSTRUCT:
 586         hres = invoke_prop_func(This, This, prop, wFlags, pdp, pvarRes, &jsexcept, pspCaller);
 587         break;
 588     case DISPATCH_PROPERTYGET:
 589         hres = prop_get(This, prop, pdp, pvarRes, &jsexcept, pspCaller);
 590         break;
 591     case DISPATCH_PROPERTYPUT: {
 592         DWORD i;
 593
 594         for(i=0; i < pdp->cNamedArgs; i++) {
 595             if(pdp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
 596                 break;
 597         }
 598
 599         if(i == pdp->cNamedArgs) {
 600             TRACE("no value to set\n");
 601             return DISP_E_PARAMNOTOPTIONAL;
 602         }
 603
 604         hres = prop_put(This, prop, pdp->rgvarg+i, &jsexcept, pspCaller);
 605         break;
 606     }
 607     default:
 608         FIXME("Unimplemented flags %x\n", wFlags);
 609         return E_INVALIDARG;
 610     }
 611
 612     if(pei)
 613         *pei = jsexcept.ei;
 614
 615     return hres;
 616 }
 617
 618 static HRESULT delete_prop(dispex_prop_t *prop)
 619 {
 620     heap_free(prop->name);
 621     prop->name = NULL;
 622     prop->type = PROP_DELETED;
 623
 624     return S_OK;
 625 }
 626
 627 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 628 {
 629     jsdisp_t *This = impl_from_IDispatchEx(iface);
 630     dispex_prop_t *prop;
 631     HRESULT hres;
 632
 633     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 634
 635     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK))
 636         FIXME("Unsupported grfdex %x\n", grfdex);
 637
 638     hres = find_prop_name(This, bstrName, &prop);
 639     if(FAILED(hres))
 640         return hres;
 641     if(!prop) {
 642         TRACE("not found\n");
 643         return S_OK;
 644     }
 645
 646     return delete_prop(prop);
 647 }
 648
 649 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 650 {
 651     jsdisp_t *This = impl_from_IDispatchEx(iface);
 652     dispex_prop_t *prop;
 653
 654     TRACE("(%p)->(%x)\n", This, id);
 655
 656     prop = get_prop(This, id);
 657     if(!prop) {
 658         WARN("invalid id\n");
 659         return DISP_E_MEMBERNOTFOUND;
 660     }
 661
 662     return delete_prop(prop);
 663 }
 664
 665 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 666 {
 667     jsdisp_t *This = impl_from_IDispatchEx(iface);
 668     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 673 {
 674     jsdisp_t *This = impl_from_IDispatchEx(iface);
 675     dispex_prop_t *prop;
 676
 677     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
 678
 679     prop = get_prop(This, id);
 680     if(!prop || !prop->name || prop->type == PROP_DELETED)
 681         return DISP_E_MEMBERNOTFOUND;
 682
 683     *pbstrName = SysAllocString(prop->name);
 684     if(!*pbstrName)
 685         return E_OUTOFMEMORY;
 686
 687     return S_OK;
 688 }
 689
 690 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 691 {
 692     jsdisp_t *This = impl_from_IDispatchEx(iface);
 693     dispex_prop_t *iter;
 694     HRESULT hres;
 695
 696     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 697
 698     if(id == DISPID_STARTENUM) {
 699         hres = fill_protrefs(This);
 700         if(FAILED(hres))
 701             return hres;
 702     }
 703
 704     iter = get_prop(This, id+1);
 705     if(!iter) {
 706         *pid = DISPID_STARTENUM;
 707         return S_FALSE;
 708     }
 709
 710     while(iter < This->props + This->prop_cnt) {
 711         if(iter->name && (get_flags(This, iter) & PROPF_ENUM)) {
 712             *pid = prop_to_id(This, iter);
 713             return S_OK;
 714         }
 715         iter++;
 716     }
 717
 718     *pid = DISPID_STARTENUM;
 719     return S_FALSE;
 720 }
 721
 722 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 723 {
 724     jsdisp_t *This = impl_from_IDispatchEx(iface);
 725     FIXME("(%p)->(%p)\n", This, ppunk);
 726     return E_NOTIMPL;
 727 }
 728
 729 static IDispatchExVtbl DispatchExVtbl = {
 730     DispatchEx_QueryInterface,
 731     DispatchEx_AddRef,
 732     DispatchEx_Release,
 733     DispatchEx_GetTypeInfoCount,
 734     DispatchEx_GetTypeInfo,
 735     DispatchEx_GetIDsOfNames,
 736     DispatchEx_Invoke,
 737     DispatchEx_GetDispID,
 738     DispatchEx_InvokeEx,
 739     DispatchEx_DeleteMemberByName,
 740     DispatchEx_DeleteMemberByDispID,
 741     DispatchEx_GetMemberProperties,
 742     DispatchEx_GetMemberName,
 743     DispatchEx_GetNextDispID,
 744     DispatchEx_GetNameSpaceParent
 745 };
 746
 747 HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype)
 748 {
 749     TRACE("%p (%p)\n", dispex, prototype);
 750
 751     dispex->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 752     dispex->ref = 1;
 753     dispex->builtin_info = builtin_info;
 754
 755     dispex->props = heap_alloc((dispex->buf_size=4) * sizeof(dispex_prop_t));
 756     if(!dispex->props)
 757         return E_OUTOFMEMORY;
 758
 759     dispex->prototype = prototype;
 760     if(prototype)
 761         jsdisp_addref(prototype);
 762
 763     dispex->prop_cnt = 1;
 764     dispex->props[0].name = NULL;
 765     dispex->props[0].flags = 0;
 766     if(builtin_info->value_prop.invoke) {
 767         dispex->props[0].type = PROP_BUILTIN;
 768         dispex->props[0].u.p = &builtin_info->value_prop;
 769     }else {
 770         dispex->props[0].type = PROP_DELETED;
 771     }
 772
 773     script_addref(ctx);
 774     dispex->ctx = ctx;
 775
 776     return S_OK;
 777 }
 778
 779 static const builtin_info_t dispex_info = {
 780     JSCLASS_NONE,
 781     {NULL, NULL, 0},
 782     0, NULL,
 783     NULL,
 784     NULL
 785 };
 786
 787 HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype, jsdisp_t **dispex)
 788 {
 789     jsdisp_t *ret;
 790     HRESULT hres;
 791
 792     ret = heap_alloc_zero(sizeof(jsdisp_t));
 793     if(!ret)
 794         return E_OUTOFMEMORY;
 795
 796     hres = init_dispex(ret, ctx, builtin_info ? builtin_info : &dispex_info, prototype);
 797     if(FAILED(hres))
 798         return hres;
 799
 800     *dispex = ret;
 801     return S_OK;
 802 }
 803
 804 HRESULT init_dispex_from_constr(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *constr)
 805 {
 806     jsdisp_t *prot = NULL;
 807     dispex_prop_t *prop;
 808     HRESULT hres;
 809
 810     static const WCHAR constructorW[] = {'c','o','n','s','t','r','u','c','t','o','r',0};
 811     static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
 812
 813     hres = find_prop_name_prot(constr, prototypeW, &prop);
 814     if(SUCCEEDED(hres) && prop) {
 815         jsexcept_t jsexcept;
 816         VARIANT var;
 817
 818         V_VT(&var) = VT_EMPTY;
 819         memset(&jsexcept, 0, sizeof(jsexcept));
 820         hres = prop_get(constr, prop, NULL, &var, &jsexcept, NULL/*FIXME*/);
 821         if(FAILED(hres)) {
 822             ERR("Could not get prototype\n");
 823             return hres;
 824         }
 825
 826         if(V_VT(&var) == VT_DISPATCH)
 827             prot = iface_to_jsdisp((IUnknown*)V_DISPATCH(&var));
 828         VariantClear(&var);
 829     }
 830
 831     hres = init_dispex(dispex, ctx, builtin_info, prot);
 832
 833     if(prot)
 834         jsdisp_release(prot);
 835     if(FAILED(hres))
 836         return hres;
 837
 838     hres = ensure_prop_name(dispex, constructorW, FALSE, 0, &prop);
 839     if(SUCCEEDED(hres)) {
 840         jsexcept_t jsexcept;
 841         VARIANT var;
 842
 843         var_set_jsdisp(&var, constr);
 844         memset(&jsexcept, 0, sizeof(jsexcept));
 845         hres = prop_put(dispex, prop, &var, &jsexcept, NULL/*FIXME*/);
 846     }
 847     if(FAILED(hres))
 848         jsdisp_release(dispex);
 849
 850     return hres;
 851 }
 852
 853 jsdisp_t *iface_to_jsdisp(IUnknown *iface)
 854 {
 855     jsdisp_t *ret;
 856     HRESULT hres;
 857
 858     hres = IUnknown_QueryInterface(iface, &IID_IDispatchJS, (void**)&ret);
 859     if(FAILED(hres))
 860         return NULL;
 861
 862     return ret;
 863 }
 864
 865 HRESULT jsdisp_get_id(jsdisp_t *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
 866 {
 867     dispex_prop_t *prop;
 868     HRESULT hres;
 869
 870     if(flags & fdexNameEnsure)
 871         hres = ensure_prop_name(jsdisp, name, TRUE, PROPF_ENUM, &prop);
 872     else
 873         hres = find_prop_name_prot(jsdisp, name, &prop);
 874     if(FAILED(hres))
 875         return hres;
 876
 877     if(prop) {
 878         *id = prop_to_id(jsdisp, prop);
 879         return S_OK;
 880     }
 881
 882     TRACE("not found %s\n", debugstr_w(name));
 883     return DISP_E_UNKNOWNNAME;
 884 }
 885
 886 HRESULT jsdisp_call_value(jsdisp_t *jsthis, WORD flags, DISPPARAMS *dp, VARIANT *retv,
 887         jsexcept_t *ei, IServiceProvider *caller)
 888 {
 889     vdisp_t vdisp;
 890     HRESULT hres;
 891
 892     set_jsdisp(&vdisp, jsthis);
 893     hres = jsthis->builtin_info->value_prop.invoke(jsthis->ctx, &vdisp, flags, dp, retv, ei, caller);
 894     vdisp_release(&vdisp);
 895     return hres;
 896 }
 897
 898 HRESULT jsdisp_call(jsdisp_t *disp, DISPID id, WORD flags, DISPPARAMS *dp, VARIANT *retv,
 899         jsexcept_t *ei, IServiceProvider *caller)
 900 {
 901     dispex_prop_t *prop;
 902
 903     memset(ei, 0, sizeof(*ei));
 904     if(retv)
 905         V_VT(retv) = VT_EMPTY;
 906
 907     prop = get_prop(disp, id);
 908     if(!prop)
 909         return DISP_E_MEMBERNOTFOUND;
 910
 911     return invoke_prop_func(disp, disp, prop, flags, dp, retv, ei, caller);
 912 }
 913
 914 HRESULT jsdisp_call_name(jsdisp_t *disp, const WCHAR *name, WORD flags, DISPPARAMS *dp, VARIANT *retv,
 915         jsexcept_t *ei, IServiceProvider *caller)
 916 {
 917     dispex_prop_t *prop;
 918     HRESULT hres;
 919
 920     hres = find_prop_name_prot(disp, name, &prop);
 921     if(FAILED(hres))
 922         return hres;
 923
 924     memset(ei, 0, sizeof(*ei));
 925     if(retv)
 926         V_VT(retv) = VT_EMPTY;
 927
 928     return invoke_prop_func(disp, disp, prop, flags, dp, retv, ei, caller);
 929 }
 930
 931 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp, VARIANT *retv,
 932         jsexcept_t *ei, IServiceProvider *caller)
 933 {
 934     jsdisp_t *jsdisp;
 935     IDispatchEx *dispex;
 936     HRESULT hres;
 937
 938     jsdisp = iface_to_jsdisp((IUnknown*)disp);
 939     if(jsdisp) {
 940         hres = jsdisp_call(jsdisp, id, flags, dp, retv, ei, caller);
 941         jsdisp_release(jsdisp);
 942         return hres;
 943     }
 944
 945     memset(ei, 0, sizeof(*ei));
 946     if(retv && arg_cnt(dp))
 947         flags |= DISPATCH_PROPERTYGET;
 948
 949     if(retv)
 950         V_VT(retv) = VT_EMPTY;
 951     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 952     if(FAILED(hres)) {
 953         UINT err = 0;
 954
 955         if(flags == DISPATCH_CONSTRUCT) {
 956             WARN("IDispatch cannot be constructor\n");
 957             return DISP_E_MEMBERNOTFOUND;
 958         }
 959
 960         TRACE("using IDispatch\n");
 961         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei->ei, &err);
 962     }
 963
 964     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei->ei, caller);
 965     IDispatchEx_Release(dispex);
 966
 967     return hres;
 968 }
 969
 970 HRESULT jsdisp_propput_name(jsdisp_t *obj, const WCHAR *name, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
 971 {
 972     dispex_prop_t *prop;
 973     HRESULT hres;
 974
 975     hres = ensure_prop_name(obj, name, FALSE, PROPF_ENUM, &prop);
 976     if(FAILED(hres))
 977         return hres;
 978
 979     return prop_put(obj, prop, val, ei, caller);
 980 }
 981
 982 HRESULT jsdisp_propput_const(jsdisp_t *obj, const WCHAR *name, VARIANT *val)
 983 {
 984     dispex_prop_t *prop;
 985     HRESULT hres;
 986
 987     hres = ensure_prop_name(obj, name, FALSE, PROPF_ENUM|PROPF_CONST, &prop);
 988     if(FAILED(hres))
 989         return hres;
 990
 991     return VariantCopy(&prop->u.var, val);
 992 }
 993
 994 HRESULT jsdisp_propput_idx(jsdisp_t *obj, DWORD idx, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
 995 {
 996     WCHAR buf[12];
 997
 998     static const WCHAR formatW[] = {'%','d',0};
 999
1000     sprintfW(buf, formatW, idx);
1001     return jsdisp_propput_name(obj, buf, val, ei, caller);
1002 }
1003
1004 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
1005 {
1006     jsdisp_t *jsdisp;
1007     HRESULT hres;
1008
1009     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1010     if(jsdisp) {
1011         dispex_prop_t *prop;
1012
1013         prop = get_prop(jsdisp, id);
1014         if(prop)
1015             hres = prop_put(jsdisp, prop, val, ei, caller);
1016         else
1017             hres = DISP_E_MEMBERNOTFOUND;
1018
1019         jsdisp_release(jsdisp);
1020     }else {
1021         DISPID dispid = DISPID_PROPERTYPUT;
1022         DISPPARAMS dp  = {val, &dispid, 1, 1};
1023         IDispatchEx *dispex;
1024
1025         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1026         if(SUCCEEDED(hres)) {
1027             hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei, caller);
1028             IDispatchEx_Release(dispex);
1029         }else {
1030             ULONG err = 0;
1031
1032             TRACE("using IDispatch\n");
1033             hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei, &err);
1034         }
1035     }
1036
1037     return hres;
1038 }
1039
1040 HRESULT jsdisp_propget_name(jsdisp_t *obj, const WCHAR *name, VARIANT *var, jsexcept_t *ei, IServiceProvider *caller)
1041 {
1042     DISPPARAMS dp = {NULL, NULL, 0, 0};
1043     dispex_prop_t *prop;
1044     HRESULT hres;
1045
1046     hres = find_prop_name_prot(obj, name, &prop);
1047     if(FAILED(hres))
1048         return hres;
1049
1050     V_VT(var) = VT_EMPTY;
1051     if(!prop)
1052         return S_OK;
1053
1054     return prop_get(obj, prop, &dp, var, ei, caller);
1055 }
1056
1057 HRESULT jsdisp_get_idx(jsdisp_t *obj, DWORD idx, VARIANT *var, jsexcept_t *ei, IServiceProvider *caller)
1058 {
1059     WCHAR name[12];
1060     DISPPARAMS dp = {NULL, NULL, 0, 0};
1061     dispex_prop_t *prop;
1062     HRESULT hres;
1063
1064     static const WCHAR formatW[] = {'%','d',0};
1065
1066     sprintfW(name, formatW, idx);
1067
1068     hres = find_prop_name_prot(obj, name, &prop);
1069     if(FAILED(hres))
1070         return hres;
1071
1072     V_VT(var) = VT_EMPTY;
1073     if(!prop)
1074         return DISP_E_UNKNOWNNAME;
1075
1076     return prop_get(obj, prop, &dp, var, ei, caller);
1077 }
1078
1079 HRESULT jsdisp_propget(jsdisp_t *jsdisp, DISPID id, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
1080 {
1081     DISPPARAMS dp  = {NULL,NULL,0,0};
1082     dispex_prop_t *prop;
1083
1084     prop = get_prop(jsdisp, id);
1085     if(!prop)
1086         return DISP_E_MEMBERNOTFOUND;
1087
1088     V_VT(val) = VT_EMPTY;
1089     return prop_get(jsdisp, prop, &dp, val, ei, caller);
1090 }
1091
1092 HRESULT disp_propget(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
1093 {
1094     DISPPARAMS dp  = {NULL,NULL,0,0};
1095     IDispatchEx *dispex;
1096     jsdisp_t *jsdisp;
1097     HRESULT hres;
1098
1099     jsdisp = iface_to_jsdisp((IUnknown*)disp);
1100     if(jsdisp) {
1101         hres = jsdisp_propget(jsdisp, id, val, ei, caller);
1102         jsdisp_release(jsdisp);
1103         return hres;
1104     }
1105
1106     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1107     if(FAILED(hres)) {
1108         ULONG err = 0;
1109
1110         TRACE("using IDispatch\n");
1111         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, &err);
1112     }
1113
1114     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, caller);
1115     IDispatchEx_Release(dispex);
1116
1117     return hres;
1118 }
1119
1120 HRESULT jsdisp_delete_idx(jsdisp_t *obj, DWORD idx)
1121 {
1122     static const WCHAR formatW[] = {'%','d',0};
1123     WCHAR buf[12];
1124     dispex_prop_t *prop;
1125     HRESULT hres;
1126
1127     sprintfW(buf, formatW, idx);
1128
1129     hres = find_prop_name(obj, buf, &prop);
1130     if(FAILED(hres) || !prop)
1131         return hres;
1132
1133     return delete_prop(prop);
1134 }