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