dlls/mshtml/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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct {
  35     DISPID id;
  36     BSTR name;
  37     tid_t tid;
  38     int func_disp_idx;
  39 } func_info_t;
  40
  41 struct dispex_data_t {
  42     DWORD func_cnt;
  43     func_info_t *funcs;
  44     func_info_t **name_table;
  45     DWORD func_disp_cnt;
  46
  47     struct list entry;
  48 };
  49
  50 typedef struct {
  51     VARIANT var;
  52     LPWSTR name;
  53 } dynamic_prop_t;
  54
  55 typedef struct {
  56     DispatchEx dispex;
  57     const IUnknownVtbl *lpIUnknownVtbl;
  58     DispatchEx *obj;
  59     func_info_t *info;
  60 } func_disp_t;
  61
  62 #define FUNCUNKNOWN(x)  ((IUnknown*) &(x)->lpIUnknownVtbl)
  63
  64 struct dispex_dynamic_data_t {
  65     DWORD buf_size;
  66     DWORD prop_cnt;
  67     dynamic_prop_t *props;
  68     func_disp_t **func_disps;
  69 };
  70
  71 #define DISPID_DYNPROP_0    0x50000000
  72 #define DISPID_DYNPROP_MAX  0x5fffffff
  73
  74 static ITypeLib *typelib;
  75 static ITypeInfo *typeinfos[LAST_tid];
  76 static struct list dispex_data_list = LIST_INIT(dispex_data_list);
  77
  78 static REFIID tid_ids[] = {
  79     &IID_NULL,
  80     &DIID_DispCEventObj,
  81     &DIID_DispDOMChildrenCollection,
  82     &DIID_DispHTMLBody,
  83     &DIID_DispHTMLCommentElement,
  84     &DIID_DispHTMLCurrentStyle,
  85     &DIID_DispHTMLDocument,
  86     &DIID_DispHTMLDOMTextNode,
  87     &DIID_DispHTMLElementCollection,
  88     &DIID_DispHTMLGenericElement,
  89     &DIID_DispHTMLIFrame,
  90     &DIID_DispHTMLImg,
  91     &DIID_DispHTMLInputElement,
  92     &DIID_DispHTMLLocation,
  93     &DIID_DispHTMLNavigator,
  94     &DIID_DispHTMLOptionElement,
  95     &DIID_DispHTMLSelectElement,
  96     &DIID_DispHTMLStyle,
  97     &DIID_DispHTMLTable,
  98     &DIID_DispHTMLTableRow,
  99     &DIID_DispHTMLUnknownElement,
 100     &DIID_DispHTMLWindow2,
 101     &IID_IHTMLBodyElement,
 102     &IID_IHTMLBodyElement2,
 103     &IID_IHTMLCommentElement,
 104     &IID_IHTMLCurrentStyle,
 105     &IID_IHTMLCurrentStyle2,
 106     &IID_IHTMLCurrentStyle3,
 107     &IID_IHTMLCurrentStyle4,
 108     &IID_IHTMLDocument2,
 109     &IID_IHTMLDocument3,
 110     &IID_IHTMLDocument4,
 111     &IID_IHTMLDocument5,
 112     &IID_IHTMLDOMChildrenCollection,
 113     &IID_IHTMLDOMNode,
 114     &IID_IHTMLDOMNode2,
 115     &IID_IHTMLDOMTextNode,
 116     &IID_IHTMLElement,
 117     &IID_IHTMLElement2,
 118     &IID_IHTMLElement3,
 119     &IID_IHTMLElement4,
 120     &IID_IHTMLElementCollection,
 121     &IID_IHTMLEventObj,
 122     &IID_IHTMLFrameBase2,
 123     &IID_IHTMLGenericElement,
 124     &IID_IHTMLImgElement,
 125     &IID_IHTMLInputElement,
 126     &IID_IHTMLLocation,
 127     &IID_IHTMLOptionElement,
 128     &IID_IHTMLSelectElement,
 129     &IID_IHTMLStyle,
 130     &IID_IHTMLStyle2,
 131     &IID_IHTMLStyle3,
 132     &IID_IHTMLStyle4,
 133     &IID_IHTMLTable,
 134     &IID_IHTMLTableRow,
 135     &IID_IHTMLTextContainer,
 136     &IID_IHTMLUniqueName,
 137     &IID_IHTMLWindow2,
 138     &IID_IHTMLWindow3,
 139     &IID_IOmNavigator
 140 };
 141
 142 static HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
 143 {
 144     HRESULT hres;
 145
 146     if(!typelib) {
 147         ITypeLib *tl;
 148
 149         hres = LoadRegTypeLib(&LIBID_MSHTML, 4, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 150         if(FAILED(hres)) {
 151             ERR("LoadRegTypeLib failed: %08x\n", hres);
 152             return hres;
 153         }
 154
 155         if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
 156             ITypeLib_Release(tl);
 157     }
 158
 159     if(!typeinfos[tid]) {
 160         ITypeInfo *typeinfo;
 161
 162         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &typeinfo);
 163         if(FAILED(hres)) {
 164             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
 165             return hres;
 166         }
 167
 168         if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), typeinfo, NULL))
 169             ITypeInfo_Release(typeinfo);
 170     }
 171
 172     *typeinfo = typeinfos[tid];
 173     return S_OK;
 174 }
 175
 176 void release_typelib(void)
 177 {
 178     dispex_data_t *iter;
 179     unsigned i;
 180
 181     while(!list_empty(&dispex_data_list)) {
 182         iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
 183         list_remove(&iter->entry);
 184
 185         for(i=0; i < iter->func_cnt; i++)
 186             SysFreeString(iter->funcs[i].name);
 187
 188         heap_free(iter->funcs);
 189         heap_free(iter->name_table);
 190         heap_free(iter);
 191     }
 192
 193     if(!typelib)
 194         return;
 195
 196     for(i=0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 197         if(typeinfos[i])
 198             ITypeInfo_Release(typeinfos[i]);
 199
 200     ITypeLib_Release(typelib);
 201 }
 202
 203 static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, const FUNCDESC *desc, ITypeInfo *dti)
 204 {
 205     HRESULT hres;
 206
 207     if(data->func_cnt && data->funcs[data->func_cnt-1].id == desc->memid)
 208         return;
 209
 210     if(data->func_cnt == *size)
 211         data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t));
 212
 213     hres = ITypeInfo_GetDocumentation(dti, desc->memid, &data->funcs[data->func_cnt].name, NULL, NULL, NULL);
 214     if(FAILED(hres))
 215         return;
 216
 217     data->funcs[data->func_cnt].id = desc->memid;
 218     data->funcs[data->func_cnt].tid = tid;
 219     data->funcs[data->func_cnt].func_disp_idx = desc->invkind == INVOKE_FUNC ? data->func_disp_cnt++ : -1;
 220
 221     data->func_cnt++;
 222 }
 223
 224 static int dispid_cmp(const void *p1, const void *p2)
 225 {
 226     return ((func_info_t*)p1)->id - ((func_info_t*)p2)->id;
 227 }
 228
 229 static int func_name_cmp(const void *p1, const void *p2)
 230 {
 231     return strcmpiW((*(func_info_t**)p1)->name, (*(func_info_t**)p2)->name);
 232 }
 233
 234 static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
 235 {
 236     const tid_t *tid = This->data->iface_tids;
 237     FUNCDESC *funcdesc;
 238     dispex_data_t *data;
 239     DWORD size = 16, i;
 240     ITypeInfo *ti, *dti;
 241     HRESULT hres;
 242
 243     TRACE("(%p)\n", This);
 244
 245     hres = get_typeinfo(This->data->disp_tid, &dti);
 246     if(FAILED(hres)) {
 247         ERR("Could not get disp type info: %08x\n", hres);
 248         return NULL;
 249     }
 250
 251     data = heap_alloc(sizeof(dispex_data_t));
 252     data->func_cnt = 0;
 253     data->func_disp_cnt = 0;
 254     data->funcs = heap_alloc(size*sizeof(func_info_t));
 255     list_add_tail(&dispex_data_list, &data->entry);
 256
 257     while(*tid) {
 258         hres = get_typeinfo(*tid, &ti);
 259         if(FAILED(hres))
 260             break;
 261
 262         i=7;
 263         while(1) {
 264             hres = ITypeInfo_GetFuncDesc(ti, i++, &funcdesc);
 265             if(FAILED(hres))
 266                 break;
 267
 268             add_func_info(data, &size, *tid, funcdesc, dti);
 269             ITypeInfo_ReleaseFuncDesc(ti, funcdesc);
 270         }
 271
 272         tid++;
 273     }
 274
 275     if(!data->func_cnt) {
 276         heap_free(data->funcs);
 277         data->funcs = NULL;
 278     }else if(data->func_cnt != size) {
 279         data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
 280     }
 281
 282     qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
 283
 284     if(data->funcs) {
 285         data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
 286         for(i=0; i < data->func_cnt; i++)
 287             data->name_table[i] = data->funcs+i;
 288         qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp);
 289     }else {
 290         data->name_table = NULL;
 291     }
 292
 293     return data;
 294 }
 295
 296 static CRITICAL_SECTION cs_dispex_static_data;
 297 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg =
 298 {
 299     0, 0, &cs_dispex_static_data,
 300     { &cs_dispex_static_data_dbg.ProcessLocksList, &cs_dispex_static_data_dbg.ProcessLocksList },
 301       0, 0, { (DWORD_PTR)(__FILE__ ": dispex_static_data") }
 302 };
 303 static CRITICAL_SECTION cs_dispex_static_data = { &cs_dispex_static_data_dbg, -1, 0, 0, 0, 0 };
 304
 305
 306 static dispex_data_t *get_dispex_data(DispatchEx *This)
 307 {
 308     if(This->data->data)
 309         return This->data->data;
 310
 311     EnterCriticalSection(&cs_dispex_static_data);
 312
 313     if(!This->data->data)
 314         This->data->data = preprocess_dispex_data(This);
 315
 316     LeaveCriticalSection(&cs_dispex_static_data);
 317
 318     return This->data->data;
 319 }
 320
 321 void call_disp_func(HTMLDocument *doc, IDispatch *disp, IDispatch *this_obj)
 322 {
 323     DISPID named_arg = DISPID_THIS;
 324     VARIANTARG arg;
 325     DISPPARAMS params = {&arg, &named_arg, 1, 1};
 326     EXCEPINFO ei;
 327     IDispatchEx *dispex;
 328     VARIANT res;
 329     HRESULT hres;
 330
 331     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 332     if(FAILED(hres)) {
 333         FIXME("Could not get IDispatchEx interface: %08x\n", hres);
 334         return;
 335     }
 336
 337     V_VT(&arg) = VT_DISPATCH;
 338     V_DISPATCH(&arg) = this_obj;
 339     VariantInit(&res);
 340     memset(&ei, 0, sizeof(ei));
 341
 342     hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, &params, &res, &ei, NULL);
 343     IDispatchEx_Release(dispex);
 344
 345     TRACE("%p returned %08x\n", disp, hres);
 346
 347     VariantClear(&res);
 348 }
 349
 350 static inline BOOL is_custom_dispid(DISPID id)
 351 {
 352     return MSHTML_DISPID_CUSTOM_MIN <= id && id <= MSHTML_DISPID_CUSTOM_MAX;
 353 }
 354
 355 static inline BOOL is_dynamic_dispid(DISPID id)
 356 {
 357     return DISPID_DYNPROP_0 <= id && id <= DISPID_DYNPROP_MAX;
 358 }
 359
 360 static inline dispex_dynamic_data_t *get_dynamic_data(DispatchEx *This, BOOL alloc)
 361 {
 362     return !alloc || This->dynamic_data
 363         ? This->dynamic_data
 364         : (This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t)));
 365 }
 366
 367 static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, BOOL alloc, dynamic_prop_t **ret)
 368 {
 369     dispex_dynamic_data_t *data = get_dynamic_data(This, alloc);
 370     unsigned i;
 371
 372     if(!data) {
 373         if(alloc)
 374             return E_OUTOFMEMORY;
 375
 376         TRACE("not found %s\n", debugstr_w(name));
 377         return DISP_E_UNKNOWNNAME;
 378     }
 379
 380     for(i=0; i < data->prop_cnt; i++) {
 381         if(!strcmpW(data->props[i].name, name)) {
 382             *ret = data->props+i;
 383             return S_OK;
 384         }
 385     }
 386
 387     TRACE("creating dynamic prop %s\n", debugstr_w(name));
 388
 389     if(!data->buf_size) {
 390         data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
 391         if(!data->props)
 392             return E_OUTOFMEMORY;
 393         data->buf_size = 4;
 394     }else if(data->buf_size == data->prop_cnt) {
 395         dynamic_prop_t *new_props;
 396
 397         new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1));
 398         if(!new_props)
 399             return E_OUTOFMEMORY;
 400
 401         data->props = new_props;
 402         data->buf_size <<= 1;
 403     }
 404
 405     data->props[data->prop_cnt].name = heap_strdupW(name);
 406     VariantInit(&data->props[data->prop_cnt].var);
 407     *ret = data->props + data->prop_cnt++;
 408
 409     return S_OK;
 410 }
 411
 412 HRESULT dispex_get_dprop_ref(DispatchEx *This, const WCHAR *name, BOOL alloc, VARIANT **ret)
 413 {
 414     dynamic_prop_t *prop;
 415     HRESULT hres;
 416
 417     hres = get_dynamic_prop(This, name, alloc, &prop);
 418     if(FAILED(hres))
 419         return hres;
 420
 421     *ret = &prop->var;
 422     return S_OK;
 423 }
 424
 425 static HRESULT dispex_value(DispatchEx *This, LCID lcid, WORD flags, DISPPARAMS *params,
 426         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 427 {
 428     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
 429
 430     if(This->data->vtbl && This->data->vtbl->value)
 431         return This->data->vtbl->value(This->outer, lcid, flags, params, res, ei, caller);
 432
 433     switch(flags) {
 434     case DISPATCH_PROPERTYGET:
 435         V_VT(res) = VT_BSTR;
 436         V_BSTR(res) = SysAllocString(objectW);
 437         if(!V_BSTR(res))
 438             return E_OUTOFMEMORY;
 439         break;
 440     default:
 441         FIXME("Unimplemented flags %x\n", flags);
 442         return E_NOTIMPL;
 443     }
 444
 445     return S_OK;
 446 }
 447
 448 static HRESULT typeinfo_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res,
 449         EXCEPINFO *ei)
 450 {
 451     ITypeInfo *ti;
 452     IUnknown *unk;
 453     UINT argerr=0;
 454     HRESULT hres;
 455
 456     hres = get_typeinfo(func->tid, &ti);
 457     if(FAILED(hres)) {
 458         ERR("Could not get type info: %08x\n", hres);
 459         return hres;
 460     }
 461
 462     hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&unk);
 463     if(FAILED(hres)) {
 464         ERR("Could not get iface %s: %08x\n", debugstr_guid(tid_ids[func->tid]), hres);
 465         return E_FAIL;
 466     }
 467
 468     hres = ITypeInfo_Invoke(ti, unk, func->id, flags, dp, res, ei, &argerr);
 469
 470     IUnknown_Release(unk);
 471     return hres;
 472 }
 473
 474 #define FUNCTION_THIS(iface) DEFINE_THIS(func_disp_t, IUnknown, iface)
 475
 476 static HRESULT WINAPI Function_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 477 {
 478     func_disp_t *This = FUNCTION_THIS(iface);
 479
 480     if(IsEqualGUID(&IID_IUnknown, riid)) {
 481         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 482         *ppv = FUNCUNKNOWN(This);
 483     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 484         return *ppv ? S_OK : E_NOINTERFACE;
 485     }else {
 486         *ppv = NULL;
 487         return E_NOINTERFACE;
 488     }
 489
 490     IUnknown_AddRef((IUnknown*)*ppv);
 491     return S_OK;
 492 }
 493
 494 static ULONG WINAPI Function_AddRef(IUnknown *iface)
 495 {
 496     func_disp_t *This = FUNCTION_THIS(iface);
 497
 498     TRACE("(%p)\n", This);
 499
 500     return IDispatchEx_AddRef(DISPATCHEX(This->obj));
 501 }
 502
 503 static ULONG WINAPI Function_Release(IUnknown *iface)
 504 {
 505     func_disp_t *This = FUNCTION_THIS(iface);
 506
 507     TRACE("(%p)\n", This);
 508
 509     return IDispatchEx_Release(DISPATCHEX(This->obj));
 510 }
 511
 512 static HRESULT function_value(IUnknown *iface, LCID lcid, WORD flags, DISPPARAMS *params,
 513         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 514 {
 515     func_disp_t *This = FUNCTION_THIS(iface);
 516     HRESULT hres;
 517
 518     switch(flags) {
 519     case DISPATCH_METHOD:
 520         hres = typeinfo_invoke(This->obj, This->info, flags, params, res, ei);
 521         break;
 522     default:
 523         FIXME("Unimplemented flags %x\n", flags);
 524         hres = E_NOTIMPL;
 525     }
 526
 527     return hres;
 528 }
 529
 530 #undef FUNCTION_THIS
 531
 532 static const IUnknownVtbl FunctionUnkVtbl = {
 533     Function_QueryInterface,
 534     Function_AddRef,
 535     Function_Release
 536 };
 537
 538 static const dispex_static_data_vtbl_t function_dispex_vtbl = {
 539     function_value,
 540     NULL,
 541     NULL
 542 };
 543
 544 static dispex_static_data_t function_dispex = {
 545     &function_dispex_vtbl,
 546     LAST_tid,
 547     NULL,
 548     NULL
 549 };
 550
 551 static func_disp_t *create_func_disp(DispatchEx *obj, func_info_t *info)
 552 {
 553     func_disp_t *ret;
 554
 555     ret = heap_alloc_zero(sizeof(func_disp_t));
 556     if(!ret)
 557         return NULL;
 558
 559     ret->lpIUnknownVtbl = &FunctionUnkVtbl;
 560     init_dispex(&ret->dispex, FUNCUNKNOWN(ret),  &function_dispex);
 561     ret->obj = obj;
 562     ret->info = info;
 563
 564     return ret;
 565 }
 566
 567 static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res,
 568         EXCEPINFO *ei)
 569 {
 570     HRESULT hres;
 571
 572     switch(flags) {
 573     case DISPATCH_METHOD:
 574         hres = typeinfo_invoke(This, func, flags, dp, res, ei);
 575         break;
 576     case DISPATCH_PROPERTYGET: {
 577         dispex_dynamic_data_t *dynamic_data;
 578
 579         dynamic_data = get_dynamic_data(This, TRUE);
 580         if(!dynamic_data)
 581             return E_OUTOFMEMORY;
 582
 583         if(!dynamic_data->func_disps) {
 584             dynamic_data->func_disps = heap_alloc_zero(This->data->data->func_disp_cnt * sizeof(func_disp_t*));
 585             if(!dynamic_data->func_disps)
 586                 return E_OUTOFMEMORY;
 587         }
 588
 589         if(!dynamic_data->func_disps[func->func_disp_idx]) {
 590             dynamic_data->func_disps[func->func_disp_idx] = create_func_disp(This, func);
 591             if(!dynamic_data->func_disps[func->func_disp_idx])
 592                 return E_OUTOFMEMORY;
 593         }
 594
 595         V_VT(res) = VT_DISPATCH;
 596         V_DISPATCH(res) = (IDispatch*)DISPATCHEX(&dynamic_data->func_disps[func->func_disp_idx]->dispex);
 597         IDispatch_AddRef(V_DISPATCH(res));
 598         hres = S_OK;
 599         break;
 600     }
 601     default:
 602         FIXME("Unimplemented flags %x\n", flags);
 603     case DISPATCH_PROPERTYPUT:
 604         hres = E_NOTIMPL;
 605     }
 606
 607     return hres;
 608 }
 609
 610 #define DISPATCHEX_THIS(iface) DEFINE_THIS(DispatchEx, IDispatchEx, iface)
 611
 612 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 613 {
 614     DispatchEx *This = DISPATCHEX_THIS(iface);
 615
 616     return IUnknown_QueryInterface(This->outer, riid, ppv);
 617 }
 618
 619 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 620 {
 621     DispatchEx *This = DISPATCHEX_THIS(iface);
 622
 623     return IUnknown_AddRef(This->outer);
 624 }
 625
 626 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 627 {
 628     DispatchEx *This = DISPATCHEX_THIS(iface);
 629
 630     return IUnknown_Release(This->outer);
 631 }
 632
 633 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 634 {
 635     DispatchEx *This = DISPATCHEX_THIS(iface);
 636
 637     TRACE("(%p)->(%p)\n", This, pctinfo);
 638
 639     *pctinfo = 1;
 640     return S_OK;
 641 }
 642
 643 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 644                                               LCID lcid, ITypeInfo **ppTInfo)
 645 {
 646     DispatchEx *This = DISPATCHEX_THIS(iface);
 647     HRESULT hres;
 648
 649     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 650
 651     hres = get_typeinfo(This->data->disp_tid, ppTInfo);
 652     if(FAILED(hres))
 653         return hres;
 654
 655     ITypeInfo_AddRef(*ppTInfo);
 656     return S_OK;
 657 }
 658
 659 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 660                                                 LPOLESTR *rgszNames, UINT cNames,
 661                                                 LCID lcid, DISPID *rgDispId)
 662 {
 663     DispatchEx *This = DISPATCHEX_THIS(iface);
 664     UINT i;
 665     HRESULT hres;
 666
 667     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 668           lcid, rgDispId);
 669
 670     for(i=0; i < cNames; i++) {
 671         hres = IDispatchEx_GetDispID(DISPATCHEX(This), rgszNames[i], 0, rgDispId+i);
 672         if(FAILED(hres))
 673             return hres;
 674     }
 675
 676     return S_OK;
 677 }
 678
 679 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 680                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 681                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 682 {
 683     DispatchEx *This = DISPATCHEX_THIS(iface);
 684
 685     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 686           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 687
 688     return IDispatchEx_InvokeEx(DISPATCHEX(This), dispIdMember, lcid, wFlags,
 689                                 pDispParams, pVarResult, pExcepInfo, NULL);
 690 }
 691
 692 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 693 {
 694     DispatchEx *This = DISPATCHEX_THIS(iface);
 695     dynamic_prop_t *dprop;
 696     dispex_data_t *data;
 697     int min, max, n, c;
 698     HRESULT hres;
 699
 700     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 701
 702     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit))
 703         FIXME("Unsupported grfdex %x\n", grfdex);
 704
 705     data = get_dispex_data(This);
 706     if(!data)
 707         return E_FAIL;
 708
 709     min = 0;
 710     max = data->func_cnt-1;
 711
 712     while(min <= max) {
 713         n = (min+max)/2;
 714
 715         c = strcmpiW(data->name_table[n]->name, bstrName);
 716         if(!c) {
 717             if((grfdex & fdexNameCaseSensitive) && strcmpW(data->name_table[n]->name, bstrName))
 718                 break;
 719
 720             *pid = data->name_table[n]->id;
 721             return S_OK;
 722         }
 723
 724         if(c > 0)
 725             max = n-1;
 726         else
 727             min = n+1;
 728     }
 729
 730     if(This->data->vtbl && This->data->vtbl->get_dispid) {
 731         HRESULT hres;
 732
 733         hres = This->data->vtbl->get_dispid(This->outer, bstrName, grfdex, pid);
 734         if(hres != DISP_E_UNKNOWNNAME)
 735             return hres;
 736     }
 737
 738     hres = get_dynamic_prop(This, bstrName, grfdex&fdexNameEnsure, &dprop);
 739     if(FAILED(hres))
 740         return hres;
 741
 742     *pid = DISPID_DYNPROP_0 + (dprop - This->dynamic_data->props);
 743     return S_OK;
 744 }
 745
 746 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 747         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 748 {
 749     DispatchEx *This = DISPATCHEX_THIS(iface);
 750     dispex_data_t *data;
 751     int min, max, n;
 752     HRESULT hres;
 753
 754     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 755
 756     if(id == DISPID_VALUE)
 757         return dispex_value(This, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 758
 759     if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke)
 760         return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 761
 762     if(wFlags == DISPATCH_CONSTRUCT) {
 763         FIXME("DISPATCH_CONSTRUCT not implemented\n");
 764         return E_NOTIMPL;
 765     }
 766
 767     if(is_dynamic_dispid(id)) {
 768         DWORD idx = id - DISPID_DYNPROP_0;
 769         VARIANT *var;
 770
 771         if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx)
 772             return DISP_E_UNKNOWNNAME;
 773
 774         var = &This->dynamic_data->props[idx].var;
 775
 776         switch(wFlags) {
 777         case INVOKE_FUNC: {
 778             DISPID named_arg = DISPID_THIS;
 779             DISPPARAMS dp = {NULL, &named_arg, 0, 1};
 780             IDispatchEx *dispex;
 781
 782             if(V_VT(var) != VT_DISPATCH) {
 783                 FIXME("invoke vt %d\n", V_VT(var));
 784                 return E_NOTIMPL;
 785             }
 786
 787             if(pdp->cNamedArgs) {
 788                 FIXME("named args not supported\n");
 789                 return E_NOTIMPL;
 790             }
 791
 792             dp.rgvarg = heap_alloc((pdp->cArgs+1)*sizeof(VARIANTARG));
 793             if(!dp.rgvarg)
 794                 return E_OUTOFMEMORY;
 795
 796             dp.cArgs = pdp->cArgs+1;
 797             memcpy(dp.rgvarg+1, pdp->rgvarg, pdp->cArgs*sizeof(VARIANTARG));
 798
 799             V_VT(dp.rgvarg) = VT_DISPATCH;
 800             V_DISPATCH(dp.rgvarg) = (IDispatch*)DISPATCHEX(This);
 801
 802             hres = IDispatch_QueryInterface(V_DISPATCH(var), &IID_IDispatchEx, (void**)&dispex);
 803             TRACE("%s call\n", debugstr_w(This->dynamic_data->props[idx].name));
 804             if(SUCCEEDED(hres)) {
 805                 hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, wFlags, &dp, pvarRes, pei, pspCaller);
 806                 IDispatchEx_Release(dispex);
 807             }else {
 808                 ULONG err = 0;
 809                 hres = IDispatch_Invoke(V_DISPATCH(var), DISPID_VALUE, &IID_NULL, lcid, wFlags, pdp, pvarRes, pei, &err);
 810             }
 811             TRACE("%s ret %08x\n", debugstr_w(This->dynamic_data->props[idx].name), hres);
 812
 813             heap_free(dp.rgvarg);
 814             return hres;
 815         }
 816         case INVOKE_PROPERTYGET:
 817             return VariantCopy(pvarRes, var);
 818         case INVOKE_PROPERTYPUT:
 819             VariantClear(var);
 820             return VariantCopy(var, pdp->rgvarg);
 821         default:
 822             FIXME("unhandled wFlags %x\n", wFlags);
 823             return E_NOTIMPL;
 824         }
 825     }
 826
 827     data = get_dispex_data(This);
 828     if(!data)
 829         return E_FAIL;
 830
 831     min = 0;
 832     max = data->func_cnt-1;
 833
 834     while(min <= max) {
 835         n = (min+max)/2;
 836
 837         if(data->funcs[n].id == id)
 838             break;
 839
 840         if(data->funcs[n].id < id)
 841             min = n+1;
 842         else
 843             max = n-1;
 844     }
 845
 846     if(min > max) {
 847         WARN("invalid id %x\n", id);
 848         return DISP_E_UNKNOWNNAME;
 849     }
 850
 851     if(data->funcs[n].func_disp_idx == -1)
 852         hres = typeinfo_invoke(This, data->funcs+n, wFlags, pdp, pvarRes, pei);
 853     else
 854         hres = function_invoke(This, data->funcs+n, wFlags, pdp, pvarRes, pei);
 855
 856     return hres;
 857 }
 858
 859 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 860 {
 861     DispatchEx *This = DISPATCHEX_THIS(iface);
 862     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 867 {
 868     DispatchEx *This = DISPATCHEX_THIS(iface);
 869     FIXME("(%p)->(%x)\n", This, id);
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 874 {
 875     DispatchEx *This = DISPATCHEX_THIS(iface);
 876     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 877     return E_NOTIMPL;
 878 }
 879
 880 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 881 {
 882     DispatchEx *This = DISPATCHEX_THIS(iface);
 883     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 888 {
 889     DispatchEx *This = DISPATCHEX_THIS(iface);
 890     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 895 {
 896     DispatchEx *This = DISPATCHEX_THIS(iface);
 897     FIXME("(%p)->(%p)\n", This, ppunk);
 898     return E_NOTIMPL;
 899 }
 900
 901 #undef DISPATCHEX_THIS
 902
 903 static IDispatchExVtbl DispatchExVtbl = {
 904     DispatchEx_QueryInterface,
 905     DispatchEx_AddRef,
 906     DispatchEx_Release,
 907     DispatchEx_GetTypeInfoCount,
 908     DispatchEx_GetTypeInfo,
 909     DispatchEx_GetIDsOfNames,
 910     DispatchEx_Invoke,
 911     DispatchEx_GetDispID,
 912     DispatchEx_InvokeEx,
 913     DispatchEx_DeleteMemberByName,
 914     DispatchEx_DeleteMemberByDispID,
 915     DispatchEx_GetMemberProperties,
 916     DispatchEx_GetMemberName,
 917     DispatchEx_GetNextDispID,
 918     DispatchEx_GetNameSpaceParent
 919 };
 920
 921 BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
 922 {
 923     static const IID IID_UndocumentedScriptIface =
 924         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
 925     static const IID IID_IDispatchJS =
 926         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
 927
 928     if(IsEqualGUID(&IID_IDispatch, riid)) {
 929         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 930         *ppv = DISPATCHEX(This);
 931     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 932         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 933         *ppv = DISPATCHEX(This);
 934     }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
 935         TRACE("(%p)->(IID_IDispatchJS %p) returning NULL\n", This, ppv);
 936         *ppv = NULL;
 937     }else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid)) {
 938         TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This, ppv);
 939         *ppv = NULL;
 940     }else {
 941         return FALSE;
 942     }
 943
 944     if(*ppv)
 945         IUnknown_AddRef((IUnknown*)*ppv);
 946     return TRUE;
 947 }
 948
 949 void release_dispex(DispatchEx *This)
 950 {
 951     dynamic_prop_t *prop;
 952
 953     if(!This->dynamic_data)
 954         return;
 955
 956     for(prop = This->dynamic_data->props; prop < This->dynamic_data->props + This->dynamic_data->prop_cnt; prop++) {
 957         VariantClear(&prop->var);
 958         heap_free(prop->name);
 959     }
 960
 961     heap_free(This->dynamic_data->props);
 962
 963     if(This->dynamic_data->func_disps) {
 964         unsigned i;
 965
 966         for(i=0; i < This->data->data->func_disp_cnt; i++) {
 967             if(This->dynamic_data->func_disps[i]) {
 968                 release_dispex(&This->dynamic_data->func_disps[i]->dispex);
 969                 heap_free(This->dynamic_data->func_disps[i]);
 970             }
 971         }
 972
 973         heap_free(This->dynamic_data->func_disps);
 974     }
 975
 976     heap_free(This->dynamic_data);
 977 }
 978
 979 void init_dispex(DispatchEx *dispex, IUnknown *outer, dispex_static_data_t *data)
 980 {
 981     dispex->lpIDispatchExVtbl = &DispatchExVtbl;
 982     dispex->outer = outer;
 983     dispex->data = data;
 984     dispex->dynamic_data = NULL;
 985 }