dlls/scrobj/scrobj.c

   1 /*
   2  * Copyright 2017 Nikolay Sivov
   3  * Copyright 2019 Jacek Caban for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "ole2.h"
  26 #include "olectl.h"
  27 #include "rpcproxy.h"
  28 #include "activscp.h"
  29 #include "dispex.h"
  30 #include "mshtmhst.h"
  31
  32 #include "initguid.h"
  33 #include "scrobj.h"
  34 #include "xmllite.h"
  35
  36 #include "wine/debug.h"
  37 #include "wine/list.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(scrobj);
  40
  41 #ifdef _WIN64
  42
  43 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  44 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  45 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  46
  47 #else
  48
  49 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  50 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  51 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  52
  53 #endif
  54
  55 static HINSTANCE scrobj_instance;
  56
  57 enum member_type
  58 {
  59     MEMBER_METHOD,
  60     MEMBER_PROPERTY
  61 };
  62
  63 #define PROP_GETTER   0x01
  64 #define PROP_SETTER   0x02
  65
  66 struct scriptlet_member
  67 {
  68     struct list entry;
  69     enum member_type type;
  70     WCHAR *name;
  71     union
  72     {
  73         struct list parameters;
  74         unsigned int flags;
  75     } u;
  76 };
  77
  78 struct method_parameter
  79 {
  80     struct list entry;
  81     WCHAR *name;
  82 };
  83
  84 struct scriptlet_script
  85 {
  86     struct list entry;
  87     WCHAR *language;
  88     WCHAR *body;
  89 };
  90
  91 struct scriptlet_global
  92 {
  93     IDispatchEx IDispatchEx_iface;
  94     LONG ref;
  95 };
  96
  97 struct scriptlet_factory
  98 {
  99     IClassFactory IClassFactory_iface;
 100
 101     LONG ref;
 102
 103     IXmlReader *xml_reader;
 104     IMoniker *moniker;
 105
 106     BOOL have_registration;
 107     BOOL have_public;
 108     WCHAR *description;
 109     WCHAR *progid;
 110     WCHAR *versioned_progid;
 111     WCHAR *version;
 112     WCHAR *classid_str;
 113     CLSID classid;
 114
 115     struct list hosts;
 116     struct list members;
 117     struct list scripts;
 118 };
 119
 120 struct script_reference
 121 {
 122     struct script_host *host;
 123     DISPID id;
 124 };
 125
 126 struct object_member
 127 {
 128     enum member_type type;
 129     BSTR name;
 130     union
 131     {
 132         struct script_reference method;
 133         struct
 134         {
 135             struct script_reference get;
 136             struct script_reference put;
 137         } property;
 138     } u;
 139 };
 140
 141 struct scriptlet_instance
 142 {
 143     IDispatchEx IDispatchEx_iface;
 144     LONG ref;
 145     struct list hosts;
 146     struct scriptlet_global *global;
 147     unsigned member_cnt;
 148     struct object_member *members;
 149 };
 150
 151 struct script_host
 152 {
 153     IActiveScriptSite IActiveScriptSite_iface;
 154     IActiveScriptSiteWindow IActiveScriptSiteWindow_iface;
 155     IServiceProvider IServiceProvider_iface;
 156
 157     LONG ref;
 158     struct list entry;
 159
 160     WCHAR *language;
 161
 162     IActiveScript *active_script;
 163     IActiveScriptParse *parser;
 164     IDispatchEx *script_dispatch;
 165     struct scriptlet_instance *object;
 166     SCRIPTSTATE state;
 167     BOOL cloned;
 168 };
 169
 170 typedef enum tid_t
 171 {
 172     NULL_tid,
 173     IGenScriptletTLib_tid,
 174     LAST_tid
 175 } tid_t;
 176
 177 static ITypeLib *typelib;
 178 static ITypeInfo *typeinfos[LAST_tid];
 179
 180 static REFIID tid_ids[] = {
 181     &IID_NULL,
 182     &IID_IGenScriptletTLib,
 183 };
 184
 185 static HRESULT load_typelib(void)
 186 {
 187     HRESULT hres;
 188     ITypeLib *tl;
 189
 190     if (typelib)
 191         return S_OK;
 192
 193     hres = LoadRegTypeLib(&LIBID_Scriptlet, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 194     if (FAILED(hres))
 195     {
 196         ERR("LoadRegTypeLib failed: %08lx\n", hres);
 197         return hres;
 198     }
 199
 200     if (InterlockedCompareExchangePointer((void **)&typelib, tl, NULL))
 201         ITypeLib_Release(tl);
 202     return hres;
 203 }
 204
 205 static HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
 206 {
 207     HRESULT hres;
 208
 209     if (FAILED(hres = load_typelib()))
 210         return hres;
 211
 212     if (!typeinfos[tid])
 213     {
 214         ITypeInfo *ti;
 215
 216         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
 217         if (FAILED(hres)) {
 218             ERR("GetTypeInfoOfGuid(%s) failed: %08lx\n", debugstr_guid(tid_ids[tid]), hres);
 219             return hres;
 220         }
 221
 222         if (InterlockedCompareExchangePointer((void **)(typeinfos+tid), ti, NULL))
 223             ITypeInfo_Release(ti);
 224     }
 225
 226     *typeinfo = typeinfos[tid];
 227     ITypeInfo_AddRef(typeinfos[tid]);
 228     return S_OK;
 229 }
 230
 231 static void release_typelib(void)
 232 {
 233     unsigned i;
 234
 235     if (!typelib)
 236         return;
 237
 238     for (i = 0; i < ARRAY_SIZE(typeinfos); i++)
 239         if (typeinfos[i])
 240             ITypeInfo_Release(typeinfos[i]);
 241
 242     ITypeLib_Release(typelib);
 243 }
 244
 245 static inline struct scriptlet_global *global_from_IDispatchEx(IDispatchEx *iface)
 246 {
 247     return CONTAINING_RECORD(iface, struct scriptlet_global, IDispatchEx_iface);
 248 }
 249
 250 static HRESULT WINAPI global_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 251 {
 252     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 253
 254     if (IsEqualGUID(&IID_IUnknown, riid))
 255     {
 256         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 257         *ppv = &This->IDispatchEx_iface;
 258     }
 259     else if (IsEqualGUID(&IID_IDispatch, riid))
 260     {
 261         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 262         *ppv = &This->IDispatchEx_iface;
 263     }
 264     else if (IsEqualGUID(&IID_IDispatchEx, riid))
 265     {
 266         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 267         *ppv = &This->IDispatchEx_iface;
 268     }
 269     else
 270     {
 271         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 272         *ppv = NULL;
 273         return E_NOINTERFACE;
 274     }
 275
 276     IUnknown_AddRef((IUnknown*)*ppv);
 277     return S_OK;
 278 }
 279
 280 static ULONG WINAPI global_AddRef(IDispatchEx *iface)
 281 {
 282     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 283     ULONG ref = InterlockedIncrement(&This->ref);
 284
 285     TRACE("(%p) ref=%ld\n", This, ref);
 286
 287     return ref;
 288 }
 289
 290 static ULONG WINAPI global_Release(IDispatchEx *iface)
 291 {
 292     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 293     ULONG ref = InterlockedDecrement(&This->ref);
 294
 295     TRACE("(%p) ref=%ld\n", This, ref);
 296
 297     if (!ref) free(This);
 298
 299     return ref;
 300 }
 301
 302 static HRESULT WINAPI global_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 303 {
 304     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 305     FIXME("(%p)->(%p)\n", This, pctinfo);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI global_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 310 {
 311     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 312     FIXME("(%p)->(%u %lu %p)\n", This, iTInfo, lcid, ppTInfo);
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI global_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 317         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 318 {
 319     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 320     UINT i;
 321     HRESULT hres;
 322
 323     TRACE("(%p)->(%s %p %u %lu %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 324
 325     for(i=0; i < cNames; i++)
 326     {
 327         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId + i);
 328         if(FAILED(hres))
 329             return hres;
 330     }
 331
 332     return S_OK;
 333 }
 334
 335 static HRESULT WINAPI global_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 336         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 337         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 338 {
 339     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 340     TRACE("(%p)->(%ld %s %ld %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 341           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 342     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 343             pDispParams, pVarResult, pExcepInfo, NULL);
 344 }
 345
 346 static HRESULT WINAPI global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 347 {
 348     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 349     FIXME("(%p)->(%s %lx %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 350     return E_NOTIMPL;
 351 }
 352
 353 static HRESULT WINAPI global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 354         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 355 {
 356     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 357     FIXME("(%p)->(%lx %lx %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI global_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 362 {
 363     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 364     FIXME("(%p)->(%s %lx)\n", This, debugstr_w(bstrName), grfdex);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI global_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 369 {
 370     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 371     FIXME("(%p)->(%lx)\n", This, id);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI global_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 376 {
 377     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 378     FIXME("(%p)->(%lx %lx %p)\n", This, id, grfdexFetch, pgrfdex);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI global_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 383 {
 384     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 385     FIXME("(%p)->(%lx %p)\n", This, id, pbstrName);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI global_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 390 {
 391     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 392     FIXME("(%p)->(%lx %lx %p)\n", This, grfdex, id, pid);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI global_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 397 {
 398     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 399     FIXME("(%p)->(%p)\n", This, ppunk);
 400     return E_NOTIMPL;
 401 }
 402
 403 static IDispatchExVtbl global_vtbl = {
 404     global_QueryInterface,
 405     global_AddRef,
 406     global_Release,
 407     global_GetTypeInfoCount,
 408     global_GetTypeInfo,
 409     global_GetIDsOfNames,
 410     global_Invoke,
 411     global_GetDispID,
 412     global_InvokeEx,
 413     global_DeleteMemberByName,
 414     global_DeleteMemberByDispID,
 415     global_GetMemberProperties,
 416     global_GetMemberName,
 417     global_GetNextDispID,
 418     global_GetNameSpaceParent
 419 };
 420
 421 static HRESULT set_script_state(struct script_host *host, SCRIPTSTATE state)
 422 {
 423     HRESULT hres;
 424     if (state == host->state) return S_OK;
 425     hres = IActiveScript_SetScriptState(host->active_script, state);
 426     if (FAILED(hres)) return hres;
 427     host->state = state;
 428     return S_OK;
 429 }
 430
 431 static inline struct script_host *impl_from_IActiveScriptSite(IActiveScriptSite *iface)
 432 {
 433     return CONTAINING_RECORD(iface, struct script_host, IActiveScriptSite_iface);
 434 }
 435
 436 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 437 {
 438     struct script_host *This = impl_from_IActiveScriptSite(iface);
 439
 440     if (IsEqualGUID(&IID_IUnknown, riid))
 441     {
 442         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 443         *ppv = &This->IActiveScriptSite_iface;
 444     }
 445     else if (IsEqualGUID(&IID_IActiveScriptSite, riid))
 446     {
 447         TRACE("(%p)->(IID_IActiveScriptSite %p)\n", This, ppv);
 448         *ppv = &This->IActiveScriptSite_iface;
 449     }
 450     else if (IsEqualGUID(&IID_IActiveScriptSiteWindow, riid))
 451     {
 452         TRACE("(%p)->(IID_IActiveScriptSiteWindow %p)\n", This, ppv);
 453         *ppv = &This->IActiveScriptSiteWindow_iface;
 454     }
 455     else if(IsEqualGUID(&IID_IServiceProvider, riid))
 456     {
 457         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 458         *ppv = &This->IServiceProvider_iface;
 459     }
 460     else
 461     {
 462         WARN("(%p)->(%s %p) interface not supported\n", This, debugstr_guid(riid), ppv);
 463         *ppv = NULL;
 464         return E_NOINTERFACE;
 465     }
 466
 467     IUnknown_AddRef((IUnknown*)*ppv);
 468     return S_OK;
 469 }
 470
 471 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 472 {
 473     struct script_host *This = impl_from_IActiveScriptSite(iface);
 474     LONG ref = InterlockedIncrement(&This->ref);
 475
 476     TRACE("(%p) ref=%ld\n", This, ref);
 477
 478     return ref;
 479 }
 480
 481 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 482 {
 483     struct script_host *This = impl_from_IActiveScriptSite(iface);
 484     LONG ref = InterlockedDecrement(&This->ref);
 485
 486     TRACE("(%p) ref=%ld\n", This, ref);
 487
 488     if(!ref) {
 489         free(This->language);
 490         free(This);
 491     }
 492
 493     return ref;
 494 }
 495
 496 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *lcid)
 497 {
 498     struct script_host *This = impl_from_IActiveScriptSite(iface);
 499
 500     TRACE("(%p, %p)\n", This, lcid);
 501
 502     *lcid = GetUserDefaultLCID();
 503     return S_OK;
 504 }
 505
 506 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR name, DWORD mask,
 507     IUnknown **unk, ITypeInfo **ti)
 508 {
 509     struct script_host *This = impl_from_IActiveScriptSite(iface);
 510
 511     TRACE("(%p, %s, %#lx, %p, %p)\n", This, debugstr_w(name), mask, unk, ti);
 512
 513     if (mask != SCRIPTINFO_IUNKNOWN)
 514     {
 515         FIXME("mask %lx not supported\n", mask);
 516         return E_NOTIMPL;
 517     }
 518
 519     if (wcscmp(name, L"scriptlet") && wcscmp(name, L"globals"))
 520     {
 521         FIXME("%s not supported\n", debugstr_w(name));
 522         return E_FAIL;
 523     }
 524
 525     if (!This->object) return E_UNEXPECTED;
 526
 527     *unk = (IUnknown *)&This->object->global->IDispatchEx_iface;
 528     IUnknown_AddRef(*unk);
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *version)
 533 {
 534     struct script_host *This = impl_from_IActiveScriptSite(iface);
 535     FIXME("(%p, %p)\n", This, version);
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface, const VARIANT *result,
 540     const EXCEPINFO *ei)
 541 {
 542     struct script_host *This = impl_from_IActiveScriptSite(iface);
 543     FIXME("(%p, %s, %p)\n", This, debugstr_variant(result), ei);
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE state)
 548 {
 549     struct script_host *This = impl_from_IActiveScriptSite(iface);
 550     TRACE("(%p, %d)\n", This, state);
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *script_error)
 555 {
 556     struct script_host *This = impl_from_IActiveScriptSite(iface);
 557     FIXME("(%p, %p)\n", This, script_error);
 558     return E_NOTIMPL;
 559 }
 560
 561 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 562 {
 563     struct script_host *This = impl_from_IActiveScriptSite(iface);
 564     TRACE("(%p)\n", This);
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 569 {
 570     struct script_host *This = impl_from_IActiveScriptSite(iface);
 571     TRACE("(%p)\n", This);
 572     return S_OK;
 573 }
 574
 575 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 576     ActiveScriptSite_QueryInterface,
 577     ActiveScriptSite_AddRef,
 578     ActiveScriptSite_Release,
 579     ActiveScriptSite_GetLCID,
 580     ActiveScriptSite_GetItemInfo,
 581     ActiveScriptSite_GetDocVersionString,
 582     ActiveScriptSite_OnScriptTerminate,
 583     ActiveScriptSite_OnStateChange,
 584     ActiveScriptSite_OnScriptError,
 585     ActiveScriptSite_OnEnterScript,
 586     ActiveScriptSite_OnLeaveScript
 587 };
 588
 589 static inline struct script_host *impl_from_IActiveScriptSiteWindow(IActiveScriptSiteWindow *iface)
 590 {
 591     return CONTAINING_RECORD(iface, struct script_host, IActiveScriptSiteWindow_iface);
 592 }
 593
 594 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface, REFIID riid, void **obj)
 595 {
 596     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 597     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, obj);
 598 }
 599
 600 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 601 {
 602     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 603     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 604 }
 605
 606 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 607 {
 608     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 609     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 610 }
 611
 612 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *hwnd)
 613 {
 614     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 615     FIXME("(%p, %p)\n", This, hwnd);
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL enable)
 620 {
 621     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 622     FIXME("(%p, %d)\n", This, enable);
 623     return E_NOTIMPL;
 624 }
 625
 626 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 627     ActiveScriptSiteWindow_QueryInterface,
 628     ActiveScriptSiteWindow_AddRef,
 629     ActiveScriptSiteWindow_Release,
 630     ActiveScriptSiteWindow_GetWindow,
 631     ActiveScriptSiteWindow_EnableModeless
 632 };
 633
 634 static inline struct script_host *impl_from_IServiceProvider(IServiceProvider *iface)
 635 {
 636     return CONTAINING_RECORD(iface, struct script_host, IServiceProvider_iface);
 637 }
 638
 639 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **obj)
 640 {
 641     struct script_host *This = impl_from_IServiceProvider(iface);
 642     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, obj);
 643 }
 644
 645 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 646 {
 647     struct script_host *This = impl_from_IServiceProvider(iface);
 648     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 649 }
 650
 651 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 652 {
 653     struct script_host *This = impl_from_IServiceProvider(iface);
 654     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 655 }
 656
 657 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID service,
 658     REFIID riid, void **obj)
 659 {
 660     struct script_host *This = impl_from_IServiceProvider(iface);
 661     FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(service), debugstr_guid(riid), obj);
 662     return E_NOTIMPL;
 663 }
 664
 665 static const IServiceProviderVtbl ServiceProviderVtbl = {
 666     ServiceProvider_QueryInterface,
 667     ServiceProvider_AddRef,
 668     ServiceProvider_Release,
 669     ServiceProvider_QueryService
 670 };
 671
 672 static struct script_host *find_script_host(struct list *hosts, const WCHAR *language)
 673 {
 674     struct script_host *host;
 675     LIST_FOR_EACH_ENTRY(host, hosts, struct script_host, entry)
 676     {
 677         if (!wcscmp(host->language, language)) return host;
 678     }
 679     return NULL;
 680 }
 681
 682 static HRESULT parse_scripts(struct scriptlet_factory *factory, struct list *hosts, BOOL start)
 683 {
 684     DWORD parse_flags = SCRIPTTEXT_ISVISIBLE;
 685     struct scriptlet_script *script;
 686     struct script_host *host;
 687     HRESULT hres;
 688
 689     if (!start) parse_flags |= SCRIPTITEM_ISPERSISTENT;
 690
 691     LIST_FOR_EACH_ENTRY(script, &factory->scripts, struct scriptlet_script, entry)
 692     {
 693         host = find_script_host(hosts, script->language);
 694
 695         if (start && host->state != SCRIPTSTATE_STARTED)
 696         {
 697             hres = set_script_state(host, SCRIPTSTATE_STARTED);
 698             if (FAILED(hres)) return hres;
 699         }
 700
 701         if (host->cloned) continue;
 702
 703         hres = IActiveScriptParse_ParseScriptText(host->parser, script->body, NULL, NULL, NULL, 0, 0 /* FIXME */,
 704                                                   parse_flags, NULL, NULL);
 705         if (FAILED(hres))
 706         {
 707             WARN("ParseScriptText failed: %08lx\n", hres);
 708             return hres;
 709         }
 710     }
 711     if (!start)
 712     {
 713         LIST_FOR_EACH_ENTRY(host, hosts, struct script_host, entry)
 714         {
 715             if (host->state != SCRIPTSTATE_UNINITIALIZED)
 716                 set_script_state(host, SCRIPTSTATE_UNINITIALIZED);
 717         }
 718     }
 719     return S_OK;
 720 }
 721
 722 static HRESULT lookup_script_properties(struct scriptlet_instance *object, BSTR name, struct script_reference *ret)
 723 {
 724     struct script_host *host;
 725     HRESULT hres;
 726
 727     LIST_FOR_EACH_ENTRY(host, &object->hosts, struct script_host, entry)
 728     {
 729         hres = IDispatchEx_GetDispID(host->script_dispatch, name, 0, &ret->id);
 730         if (FAILED(hres)) continue;
 731         ret->host = host;
 732         return S_OK;
 733     }
 734
 735     FIXME("Could not find %s in scripts\n", debugstr_w(name));
 736     return E_FAIL;
 737 }
 738
 739 static HRESULT lookup_object_properties(struct scriptlet_instance *object, struct scriptlet_factory *factory)
 740 {
 741     struct scriptlet_member *member;
 742     unsigned i = 0, member_cnt = 0;
 743     size_t len;
 744     BSTR name;
 745     HRESULT hres;
 746
 747     LIST_FOR_EACH_ENTRY(member, &factory->members, struct scriptlet_member, entry)
 748         member_cnt++;
 749
 750     if (!member_cnt) return S_OK;
 751
 752     if (!(object->members = calloc(member_cnt, sizeof(*object->members))))
 753         return E_OUTOFMEMORY;
 754     object->member_cnt = member_cnt;
 755
 756     LIST_FOR_EACH_ENTRY(member, &factory->members, struct scriptlet_member, entry)
 757     {
 758         object->members[i].type = member->type;
 759         if (!(object->members[i].name = SysAllocString(member->name))) return E_OUTOFMEMORY;
 760         switch (member->type)
 761         {
 762         case MEMBER_METHOD:
 763             hres = lookup_script_properties(object, object->members[i].name, &object->members[i].u.method);
 764             if (FAILED(hres)) return hres;
 765             break;
 766         case MEMBER_PROPERTY:
 767             len = wcslen(member->name);
 768             if (!(name = SysAllocStringLen(NULL, len + 4))) return E_OUTOFMEMORY;
 769             wcscpy(name, L"get_");
 770             wcscat(name, member->name);
 771             hres = lookup_script_properties(object, name, &object->members[i].u.property.get);
 772             if (SUCCEEDED(hres))
 773             {
 774                 memcpy(name, L"put", 3 * sizeof(WCHAR));
 775                 hres = lookup_script_properties(object, name, &object->members[i].u.property.put);
 776             }
 777             SysFreeString(name);
 778             if (FAILED(hres)) return hres;
 779             break;
 780         }
 781         i++;
 782     }
 783
 784     return S_OK;
 785 }
 786
 787 static HRESULT init_script_host(struct script_host *host, IActiveScript *clone)
 788 {
 789     HRESULT hres;
 790
 791     if (!clone)
 792     {
 793         IClassFactoryEx *factory_ex;
 794         IClassFactory *factory;
 795         IUnknown *unk;
 796         CLSID clsid;
 797
 798         if (FAILED(hres = CLSIDFromProgID(host->language, &clsid)))
 799         {
 800             WARN("Could not find script engine for %s\n", debugstr_w(host->language));
 801             return hres;
 802         }
 803
 804         hres = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, NULL,
 805                                 &IID_IClassFactory, (void**)&factory);
 806         if (FAILED(hres)) return hres;
 807
 808         hres = IClassFactory_QueryInterface(factory, &IID_IClassFactoryEx, (void**)&factory_ex);
 809         if (SUCCEEDED(hres))
 810         {
 811             FIXME("Use IClassFactoryEx\n");
 812             IClassFactoryEx_Release(factory_ex);
 813         }
 814
 815         hres = IClassFactory_CreateInstance(factory, NULL, &IID_IUnknown, (void**)&unk);
 816         IClassFactory_Release(factory);
 817         if (FAILED(hres)) return hres;
 818
 819         hres = IUnknown_QueryInterface(unk, &IID_IActiveScript, (void**)&host->active_script);
 820         IUnknown_Release(unk);
 821         if (FAILED(hres)) return hres;
 822     }
 823     else
 824     {
 825         IActiveScript_AddRef(clone);
 826         host->active_script = clone;
 827         host->cloned = TRUE;
 828     }
 829
 830     hres = IActiveScript_QueryInterface(host->active_script, &IID_IActiveScriptParse, (void**)&host->parser);
 831     if (FAILED(hres)) return hres;
 832
 833     if (!clone)
 834     {
 835         hres = IActiveScriptParse_InitNew(host->parser);
 836         if (FAILED(hres))
 837         {
 838             IActiveScriptParse_Release(host->parser);
 839             host->parser = NULL;
 840             return hres;
 841         }
 842     }
 843
 844     return IActiveScript_SetScriptSite(host->active_script, &host->IActiveScriptSite_iface);
 845 }
 846
 847 static HRESULT create_script_host(const WCHAR *language, IActiveScript *origin_script, struct list *hosts, struct script_host **ret)
 848 {
 849     IActiveScript *clone = NULL;
 850     struct script_host *host;
 851     HRESULT hres;
 852
 853     if (!(host = calloc(1, sizeof(*host))))
 854         return E_OUTOFMEMORY;
 855
 856     host->IActiveScriptSite_iface.lpVtbl = &ActiveScriptSiteVtbl;
 857     host->IActiveScriptSiteWindow_iface.lpVtbl = &ActiveScriptSiteWindowVtbl;
 858     host->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
 859     host->ref = 1;
 860     host->state = SCRIPTSTATE_CLOSED;
 861
 862     if (!(host->language = wcsdup(language)))
 863     {
 864         IActiveScriptSite_Release(&host->IActiveScriptSite_iface);
 865         return E_OUTOFMEMORY;
 866     }
 867
 868     if (origin_script)
 869     {
 870         hres = IActiveScript_Clone(origin_script, &clone);
 871         if (FAILED(hres)) clone = NULL;
 872     }
 873
 874     list_add_tail(hosts, &host->entry);
 875     hres = init_script_host(host, clone);
 876     if (clone) IActiveScript_Release(clone);
 877     if (FAILED(hres)) return hres;
 878     if (ret) *ret = host;
 879     return S_OK;
 880 }
 881
 882 static void detach_script_hosts(struct list *hosts)
 883 {
 884     while (!list_empty(hosts))
 885     {
 886         struct script_host *host = LIST_ENTRY(list_head(hosts), struct script_host, entry);
 887         if (host->state != SCRIPTSTATE_UNINITIALIZED) set_script_state(host, SCRIPTSTATE_UNINITIALIZED);
 888         list_remove(&host->entry);
 889         host->object = NULL;
 890         if (host->script_dispatch)
 891         {
 892             IDispatchEx_Release(host->script_dispatch);
 893             host->script_dispatch = NULL;
 894         }
 895         if (host->parser)
 896         {
 897             IActiveScript_Close(host->active_script);
 898             IActiveScriptParse_Release(host->parser);
 899             host->parser = NULL;
 900         }
 901         if (host->active_script)
 902         {
 903             IActiveScript_Release(host->active_script);
 904             host->active_script = NULL;
 905         }
 906         IActiveScriptSite_Release(&host->IActiveScriptSite_iface);
 907     }
 908 }
 909
 910 static HRESULT create_scriptlet_hosts(struct scriptlet_factory *factory, struct list *hosts)
 911 {
 912     struct scriptlet_script *script;
 913     HRESULT hres;
 914
 915     LIST_FOR_EACH_ENTRY(script, &factory->scripts, struct scriptlet_script, entry)
 916     {
 917         if (find_script_host(hosts, script->language)) continue;
 918         hres = create_script_host(script->language, NULL, hosts, NULL);
 919         if (FAILED(hres))
 920         {
 921             detach_script_hosts(hosts);
 922             return hres;
 923         }
 924     }
 925
 926     return S_OK;
 927 }
 928
 929 static inline struct scriptlet_instance *impl_from_IDispatchEx(IDispatchEx *iface)
 930 {
 931     return CONTAINING_RECORD(iface, struct scriptlet_instance, IDispatchEx_iface);
 932 }
 933
 934 static HRESULT WINAPI scriptlet_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 935 {
 936     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 937
 938     if (IsEqualGUID(&IID_IUnknown, riid))
 939     {
 940         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 941         *ppv = &This->IDispatchEx_iface;
 942     }
 943     else if (IsEqualGUID(&IID_IDispatch, riid))
 944     {
 945         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 946         *ppv = &This->IDispatchEx_iface;
 947     }
 948     else if (IsEqualGUID(&IID_IDispatchEx, riid))
 949     {
 950         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 951         *ppv = &This->IDispatchEx_iface;
 952     }
 953     else
 954     {
 955         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 956         *ppv = NULL;
 957         return E_NOINTERFACE;
 958     }
 959
 960     IUnknown_AddRef((IUnknown*)*ppv);
 961     return S_OK;
 962 }
 963
 964 static ULONG WINAPI scriptlet_AddRef(IDispatchEx *iface)
 965 {
 966     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 967     ULONG ref = InterlockedIncrement(&This->ref);
 968
 969     TRACE("(%p) ref=%ld\n", This, ref);
 970
 971     return ref;
 972 }
 973
 974 static ULONG WINAPI scriptlet_Release(IDispatchEx *iface)
 975 {
 976     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 977     ULONG ref = InterlockedDecrement(&This->ref);
 978
 979     TRACE("(%p) ref=%ld\n", This, ref);
 980
 981     if (!ref)
 982     {
 983         unsigned i;
 984         for (i = 0; i < This->member_cnt; i++)
 985             SysFreeString(This->members[i].name);
 986         free(This->members);
 987         detach_script_hosts(&This->hosts);
 988         if (This->global) IDispatchEx_Release(&This->global->IDispatchEx_iface);
 989         free(This);
 990     }
 991     return ref;
 992 }
 993
 994 static HRESULT WINAPI scriptlet_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 995 {
 996     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 997     FIXME("(%p)->(%p)\n", This, pctinfo);
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI scriptlet_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1002 {
1003     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1004     FIXME("(%p)->(%u %lu %p)\n", This, iTInfo, lcid, ppTInfo);
1005     return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI scriptlet_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1009         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1010 {
1011     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1012     UINT i;
1013     HRESULT hres;
1014
1015     TRACE("(%p)->(%s %p %u %lu %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1016           lcid, rgDispId);
1017
1018     for(i=0; i < cNames; i++)
1019     {
1020         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId + i);
1021         if(FAILED(hres))
1022             return hres;
1023     }
1024
1025     return S_OK;
1026 }
1027
1028 static HRESULT WINAPI scriptlet_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1029         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1030         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1031 {
1032     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1033     TRACE("(%p)->(%ld %s %ld %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1034           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1035     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
1036             pDispParams, pVarResult, pExcepInfo, NULL);
1037 }
1038
1039 static HRESULT WINAPI scriptlet_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
1040 {
1041     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1042     unsigned i;
1043
1044     TRACE("(%p)->(%s %lx %p)\n", This, debugstr_w(bstrName), grfdex, pid);
1045
1046     if (grfdex & ~(fdexNameCaseInsensitive|fdexNameCaseSensitive))
1047         FIXME("Unsupported grfdex %lx\n", grfdex);
1048
1049     for (i = 0; i < This->member_cnt; i++)
1050     {
1051         if (grfdex & fdexNameCaseInsensitive)
1052         {
1053             if (wcsicmp(This->members[i].name, bstrName)) continue;
1054         }
1055         else if (wcscmp(This->members[i].name, bstrName)) continue;
1056         *pid = i + 1;
1057         return S_OK;
1058     }
1059
1060     WARN("Unknown property %s\n", debugstr_w(bstrName));
1061     return DISP_E_UNKNOWNNAME;
1062 }
1063
1064 static HRESULT WINAPI scriptlet_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *pdp,
1065         VARIANT *res, EXCEPINFO *pei, IServiceProvider *caller)
1066 {
1067     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1068     struct object_member *member;
1069
1070     TRACE("(%p)->(%lx %lx %x %p %p %p %p)\n", This, id, lcid, flags, pdp, res, pei, caller);
1071
1072     if (id < 1 || id > This->member_cnt)
1073     {
1074         WARN("Unknown id %lxu\n", id);
1075         return DISP_E_MEMBERNOTFOUND;
1076     }
1077     member = &This->members[id - 1];
1078
1079     switch (member->type)
1080     {
1081     case MEMBER_METHOD:
1082         if ((flags & ~DISPATCH_PROPERTYGET) != DISPATCH_METHOD)
1083         {
1084             FIXME("unsupported method flags %x\n", flags);
1085             return DISP_E_MEMBERNOTFOUND;
1086         }
1087         return IDispatchEx_InvokeEx(member->u.method.host->script_dispatch, member->u.method.id, lcid,
1088                                     DISPATCH_METHOD, pdp, res, pei, caller);
1089     case MEMBER_PROPERTY:
1090         if (flags & DISPATCH_PROPERTYGET)
1091         {
1092             if (!member->u.property.get.host)
1093             {
1094                 FIXME("No %s getter\n", debugstr_w(member->name));
1095                 return DISP_E_MEMBERNOTFOUND;
1096             }
1097             return IDispatchEx_InvokeEx(member->u.property.get.host->script_dispatch, member->u.property.get.id, lcid,
1098                                         DISPATCH_METHOD, pdp, res, pei, caller);
1099         }
1100         if (flags & DISPATCH_PROPERTYPUT)
1101         {
1102             DISPPARAMS dp;
1103
1104             if (!member->u.property.put.host)
1105             {
1106                 FIXME("No %s setter\n", debugstr_w(member->name));
1107                 return DISP_E_MEMBERNOTFOUND;
1108             }
1109             if (pdp->cNamedArgs != 1 || pdp->rgdispidNamedArgs[0] != DISPID_PROPERTYPUT)
1110             {
1111                 FIXME("no propput argument\n");
1112                 return E_FAIL;
1113             }
1114             dp = *pdp;
1115             dp.cNamedArgs = 0;
1116             return IDispatchEx_InvokeEx(member->u.property.put.host->script_dispatch, member->u.property.put.id, lcid,
1117                                         DISPATCH_METHOD, &dp, res, pei, caller);
1118         }
1119
1120         FIXME("unsupported flags %x\n", flags);
1121     }
1122
1123     return DISP_E_MEMBERNOTFOUND;
1124 }
1125
1126 static HRESULT WINAPI scriptlet_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
1127 {
1128     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1129     FIXME("(%p)->(%s %lx)\n", This, debugstr_w(bstrName), grfdex);
1130     return E_NOTIMPL;
1131 }
1132
1133 static HRESULT WINAPI scriptlet_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
1134 {
1135     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1136     FIXME("(%p)->(%lx)\n", This, id);
1137     return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI scriptlet_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
1141 {
1142     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1143     FIXME("(%p)->(%lx %lx %p)\n", This, id, grfdexFetch, pgrfdex);
1144     return E_NOTIMPL;
1145 }
1146
1147 static HRESULT WINAPI scriptlet_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
1148 {
1149     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1150     FIXME("(%p)->(%lx %p)\n", This, id, pbstrName);
1151     return E_NOTIMPL;
1152 }
1153
1154 static HRESULT WINAPI scriptlet_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
1155 {
1156     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1157     FIXME("(%p)->(%lx %lx %p)\n", This, grfdex, id, pid);
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI scriptlet_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
1162 {
1163     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1164     FIXME("(%p)->(%p)\n", This, ppunk);
1165     return E_NOTIMPL;
1166 }
1167
1168 static IDispatchExVtbl DispatchExVtbl = {
1169     scriptlet_QueryInterface,
1170     scriptlet_AddRef,
1171     scriptlet_Release,
1172     scriptlet_GetTypeInfoCount,
1173     scriptlet_GetTypeInfo,
1174     scriptlet_GetIDsOfNames,
1175     scriptlet_Invoke,
1176     scriptlet_GetDispID,
1177     scriptlet_InvokeEx,
1178     scriptlet_DeleteMemberByName,
1179     scriptlet_DeleteMemberByDispID,
1180     scriptlet_GetMemberProperties,
1181     scriptlet_GetMemberName,
1182     scriptlet_GetNextDispID,
1183     scriptlet_GetNameSpaceParent
1184 };
1185
1186 static HRESULT create_scriptlet_instance(struct scriptlet_factory *factory, IDispatchEx **disp)
1187 {
1188     struct script_host *factory_host, *host;
1189     struct scriptlet_instance *obj;
1190     IDispatch *script_dispatch;
1191     HRESULT hres = S_OK;
1192
1193     if (!(obj = calloc(1, sizeof(*obj))))
1194         return E_OUTOFMEMORY;
1195
1196     obj->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
1197     obj->ref = 1;
1198     list_init(&obj->hosts);
1199
1200     if (!(obj->global = malloc(sizeof(*obj->global))))
1201     {
1202         IDispatchEx_Release(&obj->IDispatchEx_iface);
1203         return E_OUTOFMEMORY;
1204     }
1205     obj->global->IDispatchEx_iface.lpVtbl = &global_vtbl;
1206     obj->global->ref = 1;
1207
1208     LIST_FOR_EACH_ENTRY(factory_host, &factory->hosts, struct script_host, entry)
1209     {
1210         hres = create_script_host(factory_host->language, factory_host->active_script, &obj->hosts, &host);
1211         if (FAILED(hres)) break;
1212         host->object = obj;
1213
1214         hres = IActiveScript_AddNamedItem(host->active_script, L"scriptlet",
1215                                           SCRIPTITEM_ISVISIBLE | SCRIPTITEM_GLOBALMEMBERS);
1216         if (FAILED(hres)) break;
1217
1218         hres = IActiveScript_AddNamedItem(host->active_script, L"globals", SCRIPTITEM_ISVISIBLE);
1219         if (FAILED(hres)) break;
1220
1221         hres = IActiveScript_GetScriptDispatch(host->active_script, NULL, &script_dispatch);
1222         if (FAILED(hres)) return hres;
1223
1224         hres = IDispatch_QueryInterface(script_dispatch, &IID_IDispatchEx, (void**)&host->script_dispatch);
1225         IDispatch_Release(script_dispatch);
1226         if (FAILED(hres))
1227         {
1228             FIXME("IDispatchEx not supported by script engine\n");
1229             return hres;
1230         }
1231     }
1232
1233     if (SUCCEEDED(hres)) hres = parse_scripts(factory, &obj->hosts, TRUE);
1234     if (SUCCEEDED(hres)) hres = lookup_object_properties(obj, factory);
1235     if (FAILED(hres))
1236     {
1237         IDispatchEx_Release(&obj->IDispatchEx_iface);
1238         return hres;
1239     }
1240
1241     *disp = &obj->IDispatchEx_iface;
1242     return S_OK;
1243 }
1244
1245 static const char *debugstr_xml_name(struct scriptlet_factory *factory)
1246 {
1247     const WCHAR *str;
1248     UINT len;
1249     HRESULT hres;
1250     hres = IXmlReader_GetLocalName(factory->xml_reader, &str, &len);
1251     if (FAILED(hres)) return "#err";
1252     return debugstr_wn(str, len);
1253 }
1254
1255 static HRESULT next_xml_node(struct scriptlet_factory *factory, XmlNodeType *node_type)
1256 {
1257     HRESULT hres;
1258     for (;;)
1259     {
1260         hres = IXmlReader_Read(factory->xml_reader, node_type);
1261         if (FAILED(hres)) break;
1262         if (*node_type == XmlNodeType_Whitespace) continue;
1263         if (*node_type == XmlNodeType_ProcessingInstruction)
1264         {
1265             FIXME("Ignoring processing instruction\n");
1266             continue;
1267         }
1268         break;
1269     }
1270     return hres;
1271 }
1272
1273 static BOOL is_xml_name(struct scriptlet_factory *factory, const WCHAR *name)
1274 {
1275     const WCHAR *qname;
1276     UINT len;
1277     HRESULT hres;
1278     hres = IXmlReader_GetQualifiedName(factory->xml_reader, &qname, &len);
1279     return hres == S_OK && len == wcslen(name) && !memcmp(qname, name, len * sizeof(WCHAR));
1280 }
1281
1282 static HRESULT expect_end_element(struct scriptlet_factory *factory)
1283 {
1284     XmlNodeType node_type;
1285     HRESULT hres;
1286     hres = next_xml_node(factory, &node_type);
1287     if (hres != S_OK || node_type != XmlNodeType_EndElement)
1288     {
1289         FIXME("Unexpected node %u %s\n", node_type, debugstr_xml_name(factory));
1290         return E_FAIL;
1291     }
1292     return S_OK;
1293 }
1294
1295 static HRESULT expect_no_attributes(struct scriptlet_factory *factory)
1296 {
1297     UINT count;
1298     HRESULT hres;
1299     hres = IXmlReader_GetAttributeCount(factory->xml_reader, &count);
1300     if (FAILED(hres)) return hres;
1301     if (!count) return S_OK;
1302     FIXME("Unexpected attributes\n");
1303     return E_FAIL;
1304 }
1305
1306 static BOOL is_case_xml_name(struct scriptlet_factory *factory, const WCHAR *name)
1307 {
1308     const WCHAR *qname;
1309     UINT len;
1310     HRESULT hres;
1311     hres = IXmlReader_GetQualifiedName(factory->xml_reader, &qname, &len);
1312     return hres == S_OK && len == wcslen(name) && !memicmp(qname, name, len * sizeof(WCHAR));
1313 }
1314
1315 static HRESULT read_xml_value(struct scriptlet_factory *factory, WCHAR **ret)
1316 {
1317     const WCHAR *str;
1318     UINT len;
1319     HRESULT hres;
1320     hres = IXmlReader_GetValue(factory->xml_reader, &str, &len);
1321     if (FAILED(hres)) return hres;
1322     if (!(*ret = malloc((len + 1) * sizeof(WCHAR)))) return E_OUTOFMEMORY;
1323     memcpy(*ret, str, len * sizeof(WCHAR));
1324     (*ret)[len] = 0;
1325     return S_OK;
1326 }
1327
1328 static HRESULT parse_scriptlet_registration(struct scriptlet_factory *factory)
1329 {
1330     HRESULT hres;
1331
1332     TRACE("\n");
1333
1334     if (factory->have_registration)
1335     {
1336         FIXME("duplicated registration element\n");
1337         return E_FAIL;
1338     }
1339     factory->have_registration = TRUE;
1340
1341     for (;;)
1342     {
1343         hres = IXmlReader_MoveToNextAttribute(factory->xml_reader);
1344         if (hres != S_OK) break;
1345
1346         if (is_xml_name(factory, L"description"))
1347         {
1348             if (factory->description)
1349             {
1350                 FIXME("Duplicated description\n");
1351                 return E_FAIL;
1352             }
1353             hres = read_xml_value(factory, &factory->description);
1354             if (FAILED(hres)) return hres;
1355         }
1356         else if (is_case_xml_name(factory, L"progid"))
1357         {
1358             if (factory->progid)
1359             {
1360                 FIXME("Duplicated progid\n");
1361                 return E_FAIL;
1362             }
1363             hres = read_xml_value(factory, &factory->progid);
1364             if (FAILED(hres)) return hres;
1365         }
1366         else if (is_xml_name(factory, L"version"))
1367         {
1368             if (factory->version)
1369             {
1370                 FIXME("Duplicated version\n");
1371                 return E_FAIL;
1372             }
1373             hres = read_xml_value(factory, &factory->version);
1374             if (FAILED(hres)) return hres;
1375         }
1376         else if (is_xml_name(factory, L"classid"))
1377         {
1378             if (factory->classid_str)
1379             {
1380                 FIXME("Duplicated classid attribute\n");
1381                 return E_FAIL;
1382             }
1383             hres = read_xml_value(factory, &factory->classid_str);
1384             if (FAILED(hres)) return hres;
1385             hres = IIDFromString(factory->classid_str, &factory->classid);
1386             if (FAILED(hres))
1387             {
1388                 FIXME("Invalid classid %s\n", debugstr_w(factory->classid_str));
1389
1390                 return E_FAIL;
1391             }
1392         }
1393         else
1394         {
1395             FIXME("Unexpected attribute\n");
1396             return E_NOTIMPL;
1397         }
1398     }
1399
1400     if (!factory->progid && !factory->classid_str)
1401     {
1402         FIXME("Incomplet registration element\n");
1403         return E_FAIL;
1404     }
1405
1406     if (factory->progid)
1407     {
1408         size_t progid_len = wcslen(factory->progid);
1409         size_t version_len = wcslen(factory->version);
1410
1411         if (!(factory->versioned_progid = malloc((progid_len + version_len + 2) * sizeof(WCHAR))))
1412             return E_OUTOFMEMORY;
1413
1414         memcpy(factory->versioned_progid, factory->progid, (progid_len + 1) * sizeof(WCHAR));
1415         if (version_len)
1416         {
1417             factory->versioned_progid[progid_len++] = '.';
1418             wcscpy(factory->versioned_progid + progid_len, factory->version);
1419         }
1420         else factory->versioned_progid[progid_len] = 0;
1421     }
1422
1423     return expect_end_element(factory);
1424 }
1425
1426 static HRESULT parse_scriptlet_public(struct scriptlet_factory *factory)
1427 {
1428     struct scriptlet_member *member, *member_iter;
1429     enum member_type member_type;
1430     XmlNodeType node_type;
1431     BOOL empty;
1432     HRESULT hres;
1433
1434     TRACE("\n");
1435
1436     if (factory->have_public)
1437     {
1438         FIXME("duplicated public element\n");
1439         return E_FAIL;
1440     }
1441     factory->have_public = TRUE;
1442
1443     for (;;)
1444     {
1445         hres = next_xml_node(factory, &node_type);
1446         if (FAILED(hres)) return hres;
1447         if (node_type == XmlNodeType_EndElement) break;
1448         if (node_type != XmlNodeType_Element)
1449         {
1450             FIXME("Unexpected node type %u\n", node_type);
1451             return E_FAIL;
1452         }
1453
1454         if (is_xml_name(factory, L"method"))
1455             member_type = MEMBER_METHOD;
1456         else if (is_xml_name(factory, L"property"))
1457             member_type = MEMBER_PROPERTY;
1458         else
1459         {
1460             FIXME("Unexpected element %s\n", debugstr_xml_name(factory));
1461             return E_NOTIMPL;
1462         }
1463
1464         empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1465
1466         hres = IXmlReader_MoveToAttributeByName(factory->xml_reader, L"name", NULL);
1467         if (hres != S_OK)
1468         {
1469             FIXME("Missing method name\n");
1470             return E_FAIL;
1471         }
1472
1473         if (!(member = malloc(sizeof(*member)))) return E_OUTOFMEMORY;
1474         member->type = member_type;
1475
1476         hres = read_xml_value(factory, &member->name);
1477         if (FAILED(hres))
1478         {
1479             free(member);
1480             return hres;
1481         }
1482
1483         LIST_FOR_EACH_ENTRY(member_iter, &factory->members, struct scriptlet_member, entry)
1484         {
1485             if (!wcsicmp(member_iter->name, member->name))
1486             {
1487                 FIXME("Duplicated member %s\n", debugstr_w(member->name));
1488                 free(member);
1489                 return E_FAIL;
1490             }
1491         }
1492         list_add_tail(&factory->members, &member->entry);
1493
1494         switch (member_type)
1495         {
1496         case MEMBER_METHOD:
1497             list_init(&member->u.parameters);
1498
1499             if (empty) break;
1500             for (;;)
1501             {
1502                 struct method_parameter *parameter;
1503
1504                 hres = next_xml_node(factory, &node_type);
1505                 if (FAILED(hres)) return hres;
1506                 if (node_type == XmlNodeType_EndElement) break;
1507                 if (node_type != XmlNodeType_Element)
1508                 {
1509                     FIXME("Unexpected node type %u\n", node_type);
1510                     return E_FAIL;
1511                 }
1512                 if (!is_case_xml_name(factory, L"parameter"))
1513                 {
1514                     FIXME("Unexpected method element\n");
1515                     return E_FAIL;
1516                 }
1517
1518                 empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1519
1520                 hres = IXmlReader_MoveToAttributeByName(factory->xml_reader, L"name", NULL);
1521                 if (hres != S_OK)
1522                 {
1523                     FIXME("Missing parameter name\n");
1524                     return E_FAIL;
1525                 }
1526
1527                 if (!(parameter = calloc(1, sizeof(*parameter)))) return E_OUTOFMEMORY;
1528                 list_add_tail(&member->u.parameters, &parameter->entry);
1529
1530                 hres = read_xml_value(factory, &parameter->name);
1531                 if (FAILED(hres)) return hres;
1532                 if (!empty && FAILED(hres = expect_end_element(factory))) return hres;
1533             }
1534             break;
1535
1536         case MEMBER_PROPERTY:
1537             member->u.flags = 0;
1538
1539             if (empty) break;
1540             for (;;)
1541             {
1542                 hres = next_xml_node(factory, &node_type);
1543                 if (FAILED(hres)) return hres;
1544                 if (node_type == XmlNodeType_EndElement) break;
1545                 if (node_type != XmlNodeType_Element)
1546                 {
1547                     FIXME("Unexpected node type %u\n", node_type);
1548                     return E_FAIL;
1549                 }
1550                 if (is_case_xml_name(factory, L"get"))
1551                 {
1552                     if (member->u.flags & PROP_GETTER)
1553                     {
1554                         FIXME("Duplicated getter\n");
1555                         return E_FAIL;
1556                     }
1557                     member->u.flags |= PROP_GETTER;
1558                 }
1559                 else if (is_case_xml_name(factory, L"put"))
1560                 {
1561                     if (member->u.flags & PROP_SETTER)
1562                     {
1563                         FIXME("Duplicated setter\n");
1564                         return E_FAIL;
1565                     }
1566                     member->u.flags |= PROP_SETTER;
1567                 }
1568                 else
1569                 {
1570                     FIXME("Unexpected property element %s\n", debugstr_xml_name(factory));
1571                     return E_FAIL;
1572                 }
1573
1574                 empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1575                 if (!empty && FAILED(hres = expect_end_element(factory))) return hres;
1576             }
1577             if (!member->u.flags)
1578             {
1579                 FIXME("No getter or setter\n");
1580                 return E_NOTIMPL;
1581             }
1582             break;
1583         }
1584         if (FAILED(hres)) return hres;
1585     }
1586
1587     return S_OK;
1588 }
1589
1590 static HRESULT parse_scriptlet_script(struct scriptlet_factory *factory, struct scriptlet_script *script)
1591 {
1592     XmlNodeType node_type;
1593     size_t buf_size, size;
1594     WCHAR *new_body;
1595     UINT read;
1596     HRESULT hres;
1597
1598     TRACE("\n");
1599
1600     for (;;)
1601     {
1602         hres = IXmlReader_MoveToNextAttribute(factory->xml_reader);
1603         if (hres != S_OK) break;
1604
1605         if (is_xml_name(factory, L"language"))
1606         {
1607             if (script->language)
1608             {
1609                 FIXME("Duplicated language\n");
1610                 return E_FAIL;
1611             }
1612             hres = read_xml_value(factory, &script->language);
1613             if (FAILED(hres)) return hres;
1614         }
1615         else
1616         {
1617             FIXME("Unexpected attribute\n");
1618             return E_NOTIMPL;
1619         }
1620     }
1621
1622     if (!script->language)
1623     {
1624         FIXME("Language not specified\n");
1625         return E_FAIL;
1626     }
1627
1628     if (FAILED(hres = next_xml_node(factory, &node_type))) return hres;
1629
1630     if (node_type != XmlNodeType_Text && node_type != XmlNodeType_CDATA)
1631     {
1632         FIXME("Unexpected node type %u\n", node_type);
1633         return E_FAIL;
1634     }
1635
1636     if (!(script->body = malloc((buf_size = 1024) * sizeof(WCHAR)))) return E_OUTOFMEMORY;
1637     size = 0;
1638
1639     for (;;)
1640     {
1641         read = 0;
1642         hres = IXmlReader_ReadValueChunk(factory->xml_reader, script->body + size, buf_size - size - 1, &read);
1643         if (FAILED(hres)) return hres;
1644         size += read;
1645         if (hres == S_FALSE) break;
1646         if (size + 1 == buf_size)
1647         {
1648             if (!(new_body = realloc(script->body, (buf_size *= 2) * sizeof(WCHAR)))) return E_OUTOFMEMORY;
1649             script->body = new_body;
1650         }
1651     }
1652     script->body[size++] = 0;
1653     if (size != buf_size) script->body = realloc(script->body, size * sizeof(WCHAR));
1654
1655     TRACE("body %s\n", debugstr_w(script->body));
1656     return expect_end_element(factory);
1657 }
1658
1659 static HRESULT parse_scriptlet_file(struct scriptlet_factory *factory, const WCHAR *url)
1660 {
1661     XmlNodeType node_type;
1662     IBindCtx *bind_ctx;
1663     IStream *stream;
1664     HRESULT hres;
1665
1666     hres = CreateURLMoniker(NULL, url, &factory->moniker);
1667     if (FAILED(hres))
1668     {
1669         WARN("CreateURLMoniker failed: %08lx\n", hres);
1670         return hres;
1671     }
1672
1673     hres = CreateBindCtx(0, &bind_ctx);
1674     if(FAILED(hres))
1675         return hres;
1676
1677     hres = IMoniker_BindToStorage(factory->moniker, bind_ctx, NULL, &IID_IStream, (void**)&stream);
1678     IBindCtx_Release(bind_ctx);
1679     if (FAILED(hres))
1680         return hres;
1681
1682     hres = CreateXmlReader(&IID_IXmlReader, (void**)&factory->xml_reader, NULL);
1683     if(SUCCEEDED(hres))
1684         hres = IXmlReader_SetInput(factory->xml_reader, (IUnknown*)stream);
1685     IStream_Release(stream);
1686     if (FAILED(hres))
1687         return hres;
1688
1689     hres = next_xml_node(factory, &node_type);
1690     if (hres == S_OK && node_type == XmlNodeType_XmlDeclaration)
1691         hres = next_xml_node(factory, &node_type);
1692     if (FAILED(hres))
1693         return hres;
1694
1695     if (node_type != XmlNodeType_Element || !is_xml_name(factory, L"component"))
1696     {
1697         FIXME("Unexpected %s element\n", debugstr_xml_name(factory));
1698         return E_FAIL;
1699     }
1700
1701     hres = expect_no_attributes(factory);
1702     if (FAILED(hres)) return hres;
1703
1704     for (;;)
1705     {
1706         hres = next_xml_node(factory, &node_type);
1707         if (FAILED(hres)) return hres;
1708         if (node_type == XmlNodeType_EndElement) break;
1709         if (node_type != XmlNodeType_Element)
1710         {
1711             FIXME("Unexpected node type %u\n", node_type);
1712             return E_FAIL;
1713         }
1714
1715         if (is_xml_name(factory, L"registration"))
1716             hres = parse_scriptlet_registration(factory);
1717         else if (is_xml_name(factory, L"public"))
1718             hres = parse_scriptlet_public(factory);
1719         else if (is_xml_name(factory, L"script"))
1720         {
1721             struct scriptlet_script *script;
1722             if (!(script = calloc(1, sizeof(*script)))) return E_OUTOFMEMORY;
1723             list_add_tail(&factory->scripts, &script->entry);
1724             hres = parse_scriptlet_script(factory, script);
1725             if (FAILED(hres)) return hres;
1726         }
1727         else
1728         {
1729             FIXME("Unexpected element %s\n", debugstr_xml_name(factory));
1730             return E_NOTIMPL;
1731         }
1732         if (FAILED(hres)) return hres;
1733     }
1734
1735     hres = next_xml_node(factory, &node_type);
1736     if (hres != S_FALSE)
1737     {
1738         FIXME("Unexpected node type %u\n", node_type);
1739         return E_FAIL;
1740     }
1741     return S_OK;
1742 }
1743
1744 static inline struct scriptlet_factory *impl_from_IClassFactory(IClassFactory *iface)
1745 {
1746     return CONTAINING_RECORD(iface, struct scriptlet_factory, IClassFactory_iface);
1747 }
1748
1749 static HRESULT WINAPI scriptlet_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1750 {
1751     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1752
1753     if (IsEqualGUID(&IID_IUnknown, riid))
1754     {
1755         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
1756         *ppv = &This->IClassFactory_iface;
1757     }
1758     else if (IsEqualGUID(&IID_IClassFactory, riid))
1759     {
1760         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
1761         *ppv = &This->IClassFactory_iface;
1762     }
1763     else
1764     {
1765         WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
1766         *ppv = NULL;
1767         return E_NOINTERFACE;
1768     }
1769
1770     IUnknown_AddRef((IUnknown *)*ppv);
1771     return S_OK;
1772 }
1773
1774 static ULONG WINAPI scriptlet_factory_AddRef(IClassFactory *iface)
1775 {
1776     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1777     ULONG ref = InterlockedIncrement(&This->ref);
1778
1779     TRACE("(%p) ref=%ld\n", This, ref);
1780
1781     return ref;
1782 }
1783
1784 static ULONG WINAPI scriptlet_factory_Release(IClassFactory *iface)
1785 {
1786     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1787     ULONG ref = InterlockedDecrement(&This->ref);
1788
1789     TRACE("(%p) ref=%ld\n", This, ref);
1790
1791     if (!ref)
1792     {
1793         if (This->moniker) IMoniker_Release(This->moniker);
1794         if (This->xml_reader) IXmlReader_Release(This->xml_reader);
1795         detach_script_hosts(&This->hosts);
1796         while (!list_empty(&This->members))
1797         {
1798             struct scriptlet_member *member = LIST_ENTRY(list_head(&This->members), struct scriptlet_member, entry);
1799             list_remove(&member->entry);
1800             free(member->name);
1801             if (member->type == MEMBER_METHOD)
1802             {
1803                 while (!list_empty(&member->u.parameters))
1804                 {
1805                     struct method_parameter *parameter = LIST_ENTRY(list_head(&member->u.parameters), struct method_parameter, entry);
1806                     list_remove(&parameter->entry);
1807                     free(parameter->name);
1808                     free(parameter);
1809                 }
1810             }
1811             free(member);
1812         }
1813         while (!list_empty(&This->scripts))
1814         {
1815             struct scriptlet_script *script = LIST_ENTRY(list_head(&This->scripts), struct scriptlet_script, entry);
1816             list_remove(&script->entry);
1817             free(script->language);
1818             free(script->body);
1819             free(script);
1820         }
1821         free(This->classid_str);
1822         free(This->description);
1823         free(This->versioned_progid);
1824         free(This->progid);
1825         free(This->version);
1826         free(This);
1827     }
1828     return ref;
1829 }
1830
1831 static HRESULT WINAPI scriptlet_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1832 {
1833     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1834     IDispatchEx *disp;
1835     HRESULT hres;
1836
1837     TRACE("(%p)->(%p %s %p)\n", This, outer, debugstr_guid(riid), ppv);
1838
1839     if (outer) FIXME("outer not supported\n");
1840
1841     if (list_empty(&This->hosts))
1842     {
1843         hres = create_scriptlet_hosts(This, &This->hosts);
1844         if (FAILED(hres)) return hres;
1845
1846         hres = parse_scripts(This, &This->hosts, FALSE);
1847         if (FAILED(hres))
1848         {
1849             detach_script_hosts(&This->hosts);
1850             return hres;
1851         }
1852     }
1853
1854     hres = create_scriptlet_instance(This, &disp);
1855     if (FAILED(hres)) return hres;
1856
1857     hres = IDispatchEx_QueryInterface(disp, riid, ppv);
1858     IDispatchEx_Release(disp);
1859     return hres;
1860 }
1861
1862 static HRESULT WINAPI scriptlet_factory_LockServer(IClassFactory *iface, BOOL fLock)
1863 {
1864     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1865     TRACE("(%p)->(%x)\n", This, fLock);
1866     return S_OK;
1867 }
1868
1869 static const struct IClassFactoryVtbl scriptlet_factory_vtbl =
1870 {
1871     scriptlet_factory_QueryInterface,
1872     scriptlet_factory_AddRef,
1873     scriptlet_factory_Release,
1874     scriptlet_factory_CreateInstance,
1875     scriptlet_factory_LockServer
1876 };
1877
1878 static HRESULT create_scriptlet_factory(const WCHAR *url, struct scriptlet_factory **ret)
1879 {
1880     struct scriptlet_factory *factory;
1881     HRESULT hres;
1882
1883     TRACE("%s\n", debugstr_w(url));
1884
1885     if (!(factory = calloc(1, sizeof(*factory))))
1886         return E_OUTOFMEMORY;
1887
1888     factory->IClassFactory_iface.lpVtbl = &scriptlet_factory_vtbl;
1889     factory->ref = 1;
1890     list_init(&factory->hosts);
1891     list_init(&factory->members);
1892     list_init(&factory->scripts);
1893
1894     hres = parse_scriptlet_file(factory, url);
1895     if (FAILED(hres))
1896     {
1897         IClassFactory_Release(&factory->IClassFactory_iface);
1898         return hres;
1899     }
1900
1901     *ret = factory;
1902     return S_OK;
1903 }
1904
1905 static HRESULT register_scriptlet(struct scriptlet_factory *factory)
1906 {
1907     HKEY key, clsid_key, obj_key;
1908     LSTATUS status;
1909     HRESULT hres;
1910
1911     if (factory->classid_str)
1912     {
1913         WCHAR *url;
1914
1915         status = RegCreateKeyW(HKEY_CLASSES_ROOT, L"CLSID", &clsid_key);
1916         if (status) return E_ACCESSDENIED;
1917
1918         status = RegCreateKeyW(clsid_key, factory->classid_str, &obj_key);
1919         RegCloseKey(clsid_key);
1920         if (status) return E_ACCESSDENIED;
1921
1922         hres = IMoniker_GetDisplayName(factory->moniker, NULL, NULL, &url);
1923         if (FAILED(hres))
1924         {
1925             RegCloseKey(obj_key);
1926             return hres;
1927         }
1928         status = RegCreateKeyW(obj_key, L"ScriptletURL", &key);
1929         if (!status)
1930         {
1931             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)url,
1932                                     (wcslen(url) + 1) * sizeof(WCHAR));
1933             RegCloseKey(key);
1934         }
1935         CoTaskMemFree(url);
1936
1937         if (factory->description)
1938             status = RegSetValueExW(obj_key, NULL, 0, REG_SZ, (BYTE*)factory->description,
1939                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
1940
1941         if (!status)
1942         {
1943             status = RegCreateKeyW(obj_key, L"InprocServer32", &key);
1944             if (!status)
1945             {
1946                 WCHAR str[MAX_PATH];
1947                 GetModuleFileNameW(scrobj_instance, str, MAX_PATH);
1948                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)str, (wcslen(str) + 1) * sizeof(WCHAR));
1949                 RegCloseKey(key);
1950             }
1951         }
1952
1953         if (!status && factory->versioned_progid)
1954         {
1955             status = RegCreateKeyW(obj_key, L"ProgID", &key);
1956             if (!status)
1957             {
1958                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->versioned_progid,
1959                                         (wcslen(factory->versioned_progid) + 1) * sizeof(WCHAR));
1960                 RegCloseKey(key);
1961             }
1962         }
1963
1964         if (!status && factory->progid)
1965         {
1966             status = RegCreateKeyW(obj_key, L"VersionIndependentProgID", &key);
1967             if (!status)
1968             {
1969                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->progid,
1970                                         (wcslen(factory->progid) + 1) * sizeof(WCHAR));
1971                 RegCloseKey(key);
1972             }
1973         }
1974
1975         RegCloseKey(obj_key);
1976         if (status) return E_ACCESSDENIED;
1977     }
1978
1979     if (factory->progid)
1980     {
1981         status = RegCreateKeyW(HKEY_CLASSES_ROOT, factory->progid, &key);
1982         if (status) return E_ACCESSDENIED;
1983
1984         if (factory->description)
1985             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->description,
1986                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
1987
1988         if (!status && factory->classid_str)
1989         {
1990             status = RegCreateKeyW(key, L"CLSID", &clsid_key);
1991             if (!status)
1992             {
1993                 status = RegSetValueExW(clsid_key, NULL, 0, REG_SZ, (BYTE*)factory->classid_str,
1994                                         (wcslen(factory->classid_str) + 1) * sizeof(WCHAR));
1995                 RegCloseKey(clsid_key);
1996             }
1997         }
1998
1999         RegCloseKey(key);
2000         if (status) return E_ACCESSDENIED;
2001     }
2002
2003     if (factory->versioned_progid)
2004     {
2005         status = RegCreateKeyW(HKEY_CLASSES_ROOT, factory->versioned_progid, &key);
2006         if (status) return E_ACCESSDENIED;
2007
2008         if (factory->description)
2009             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->description,
2010                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
2011
2012         if (!status && factory->classid_str)
2013         {
2014             status = RegCreateKeyW(key, L"CLSID", &clsid_key);
2015             if (!status)
2016             {
2017                 status = RegSetValueExW(clsid_key, NULL, 0, REG_SZ, (BYTE*)factory->classid_str,
2018                                         (wcslen(factory->classid_str) + 1) * sizeof(WCHAR));
2019                 RegCloseKey(clsid_key);
2020             }
2021         }
2022
2023         RegCloseKey(key);
2024         if (status) return E_ACCESSDENIED;
2025     }
2026
2027     return S_OK;
2028 }
2029
2030 static HRESULT unregister_scriptlet(struct scriptlet_factory *factory)
2031 {
2032     LSTATUS status;
2033
2034     if (factory->classid_str)
2035     {
2036         HKEY clsid_key;
2037         status = RegCreateKeyW(HKEY_CLASSES_ROOT, L"CLSID", &clsid_key);
2038         if (!status)
2039         {
2040             RegDeleteTreeW(clsid_key, factory->classid_str);
2041             RegCloseKey(clsid_key);
2042         }
2043     }
2044
2045     if (factory->progid) RegDeleteTreeW(HKEY_CLASSES_ROOT, factory->progid);
2046     if (factory->versioned_progid) RegDeleteTreeW(HKEY_CLASSES_ROOT, factory->versioned_progid);
2047     return S_OK;
2048 }
2049
2050 struct scriptlet_typelib
2051 {
2052     IGenScriptletTLib IGenScriptletTLib_iface;
2053     LONG ref;
2054
2055     BSTR guid;
2056 };
2057
2058 static inline struct scriptlet_typelib *impl_from_IGenScriptletTLib(IGenScriptletTLib *iface)
2059 {
2060     return CONTAINING_RECORD(iface, struct scriptlet_typelib, IGenScriptletTLib_iface);
2061 }
2062
2063 static HRESULT WINAPI scriptlet_typelib_QueryInterface(IGenScriptletTLib *iface, REFIID riid, void **obj)
2064 {
2065     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2066
2067     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), obj);
2068
2069     if (IsEqualIID(riid, &IID_IGenScriptletTLib) ||
2070             IsEqualIID(riid, &IID_IDispatch) ||
2071             IsEqualIID(riid, &IID_IUnknown))
2072     {
2073         *obj = iface;
2074         IGenScriptletTLib_AddRef(iface);
2075         return S_OK;
2076     }
2077
2078     *obj = NULL;
2079     return E_NOINTERFACE;
2080 }
2081
2082 static ULONG WINAPI scriptlet_typelib_AddRef(IGenScriptletTLib *iface)
2083 {
2084     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2085     ULONG ref = InterlockedIncrement(&This->ref);
2086     TRACE("(%p)->(%lu)\n", This, ref);
2087     return ref;
2088 }
2089
2090 static ULONG WINAPI scriptlet_typelib_Release(IGenScriptletTLib *iface)
2091 {
2092     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2093     LONG ref = InterlockedDecrement(&This->ref);
2094
2095     TRACE("(%p)->(%lu)\n", This, ref);
2096
2097     if (!ref)
2098     {
2099         SysFreeString(This->guid);
2100         free(This);
2101     }
2102
2103     return ref;
2104 }
2105
2106 static HRESULT WINAPI scriptlet_typelib_GetTypeInfoCount(IGenScriptletTLib *iface, UINT *count)
2107 {
2108     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2109
2110     TRACE("(%p, %p)\n", This, count);
2111
2112     *count = 1;
2113     return S_OK;
2114 }
2115
2116 static HRESULT WINAPI scriptlet_typelib_GetTypeInfo(IGenScriptletTLib *iface, UINT index, LCID lcid,
2117     ITypeInfo **tinfo)
2118 {
2119     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2120
2121     TRACE("(%p, %u, %lx, %p)\n", This, index, lcid, tinfo);
2122
2123     return get_typeinfo(IGenScriptletTLib_tid, tinfo);
2124 }
2125
2126 static HRESULT WINAPI scriptlet_typelib_GetIDsOfNames(IGenScriptletTLib *iface, REFIID riid, LPOLESTR *names,
2127     UINT cNames, LCID lcid, DISPID *dispid)
2128 {
2129     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2130     ITypeInfo *typeinfo;
2131     HRESULT hr;
2132
2133     TRACE("(%p, %s, %p, %u, %lx, %p)\n", This, debugstr_guid(riid), names, cNames, lcid, dispid);
2134
2135     hr = get_typeinfo(IGenScriptletTLib_tid, &typeinfo);
2136     if (SUCCEEDED(hr))
2137     {
2138         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, cNames, dispid);
2139         ITypeInfo_Release(typeinfo);
2140     }
2141
2142     return hr;
2143 }
2144
2145 static HRESULT WINAPI scriptlet_typelib_Invoke(IGenScriptletTLib *iface, DISPID dispid, REFIID riid,
2146     LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *ei, UINT *argerr)
2147 {
2148     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2149     ITypeInfo *typeinfo;
2150     HRESULT hr;
2151
2152     TRACE("(%p, %ld, %s, %lx, %x, %p, %p, %p, %p)\n", This, dispid, debugstr_guid(riid), lcid, flags,
2153         params, result, ei, argerr);
2154
2155     hr = get_typeinfo(IGenScriptletTLib_tid, &typeinfo);
2156     if (SUCCEEDED(hr))
2157     {
2158         hr = ITypeInfo_Invoke(typeinfo, &This->IGenScriptletTLib_iface, dispid, flags,
2159                 params, result, ei, argerr);
2160         ITypeInfo_Release(typeinfo);
2161     }
2162
2163     return hr;
2164 }
2165
2166 static HRESULT WINAPI scriptlet_typelib_AddURL(IGenScriptletTLib *iface, BSTR url)
2167 {
2168     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2169
2170     FIXME("(%p, %s): stub\n", This, debugstr_w(url));
2171
2172     return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI scriptlet_typelib_put_Path(IGenScriptletTLib *iface, BSTR path)
2176 {
2177     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2178
2179     FIXME("(%p, %s): stub\n", This, debugstr_w(path));
2180
2181     return E_NOTIMPL;
2182 }
2183
2184 static HRESULT WINAPI scriptlet_typelib_get_Path(IGenScriptletTLib *iface, BSTR *path)
2185 {
2186     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2187
2188     FIXME("(%p, %p): stub\n", This, path);
2189
2190     return E_NOTIMPL;
2191 }
2192
2193 static HRESULT WINAPI scriptlet_typelib_put_Doc(IGenScriptletTLib *iface, BSTR doc)
2194 {
2195     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2196
2197     FIXME("(%p, %s): stub\n", This, debugstr_w(doc));
2198
2199     return E_NOTIMPL;
2200 }
2201
2202 static HRESULT WINAPI scriptlet_typelib_get_Doc(IGenScriptletTLib *iface, BSTR *doc)
2203 {
2204     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2205
2206     FIXME("(%p, %p): stub\n", This, doc);
2207
2208     return E_NOTIMPL;
2209 }
2210
2211 static HRESULT WINAPI scriptlet_typelib_put_Name(IGenScriptletTLib *iface, BSTR name)
2212 {
2213     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2214
2215     FIXME("(%p, %s): stub\n", This, debugstr_w(name));
2216
2217     return E_NOTIMPL;
2218 }
2219
2220 static HRESULT WINAPI scriptlet_typelib_get_Name(IGenScriptletTLib *iface, BSTR *name)
2221 {
2222     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2223
2224     FIXME("(%p, %p): stub\n", This, name);
2225
2226     return E_NOTIMPL;
2227 }
2228
2229 static HRESULT WINAPI scriptlet_typelib_put_MajorVersion(IGenScriptletTLib *iface, WORD version)
2230 {
2231     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2232
2233     FIXME("(%p, %x): stub\n", This, version);
2234
2235     return E_NOTIMPL;
2236 }
2237
2238 static HRESULT WINAPI scriptlet_typelib_get_MajorVersion(IGenScriptletTLib *iface, WORD *version)
2239 {
2240     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2241
2242     FIXME("(%p, %p): stub\n", This, version);
2243
2244     return E_NOTIMPL;
2245 }
2246
2247 static HRESULT WINAPI scriptlet_typelib_put_MinorVersion(IGenScriptletTLib *iface, WORD version)
2248 {
2249     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2250
2251     FIXME("(%p, %x): stub\n", This, version);
2252
2253     return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI scriptlet_typelib_get_MinorVersion(IGenScriptletTLib *iface, WORD *version)
2257 {
2258     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2259
2260     FIXME("(%p, %p): stub\n", This, version);
2261
2262     return E_NOTIMPL;
2263 }
2264
2265 static HRESULT WINAPI scriptlet_typelib_Write(IGenScriptletTLib *iface)
2266 {
2267     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2268
2269     FIXME("(%p): stub\n", This);
2270
2271     return E_NOTIMPL;
2272 }
2273
2274 static HRESULT WINAPI scriptlet_typelib_Reset(IGenScriptletTLib *iface)
2275 {
2276     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2277
2278     FIXME("(%p): stub\n", This);
2279
2280     return E_NOTIMPL;
2281 }
2282
2283 static HRESULT WINAPI scriptlet_typelib_put_GUID(IGenScriptletTLib *iface, BSTR guid)
2284 {
2285     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2286
2287     FIXME("(%p, %s): stub\n", This, debugstr_w(guid));
2288
2289     return E_NOTIMPL;
2290 }
2291
2292 static HRESULT WINAPI scriptlet_typelib_get_GUID(IGenScriptletTLib *iface, BSTR *ret)
2293 {
2294     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2295
2296     TRACE("(%p, %p)\n", This, ret);
2297
2298     *ret = NULL;
2299
2300     if (!This->guid)
2301     {
2302         WCHAR guidW[39];
2303         GUID guid;
2304         HRESULT hr;
2305
2306         hr = CoCreateGuid(&guid);
2307         if (FAILED(hr))
2308             return hr;
2309
2310         hr = StringFromGUID2(&guid, guidW, ARRAY_SIZE(guidW));
2311         if (FAILED(hr))
2312             return hr;
2313
2314         if (!(This->guid = SysAllocString(guidW)))
2315             return E_OUTOFMEMORY;
2316     }
2317
2318     *ret = SysAllocString(This->guid);
2319     return *ret ? S_OK : E_OUTOFMEMORY;
2320 }
2321
2322 static const IGenScriptletTLibVtbl scriptlet_typelib_vtbl =
2323 {
2324     scriptlet_typelib_QueryInterface,
2325     scriptlet_typelib_AddRef,
2326     scriptlet_typelib_Release,
2327     scriptlet_typelib_GetTypeInfoCount,
2328     scriptlet_typelib_GetTypeInfo,
2329     scriptlet_typelib_GetIDsOfNames,
2330     scriptlet_typelib_Invoke,
2331     scriptlet_typelib_AddURL,
2332     scriptlet_typelib_put_Path,
2333     scriptlet_typelib_get_Path,
2334     scriptlet_typelib_put_Doc,
2335     scriptlet_typelib_get_Doc,
2336     scriptlet_typelib_put_Name,
2337     scriptlet_typelib_get_Name,
2338     scriptlet_typelib_put_MajorVersion,
2339     scriptlet_typelib_get_MajorVersion,
2340     scriptlet_typelib_put_MinorVersion,
2341     scriptlet_typelib_get_MinorVersion,
2342     scriptlet_typelib_Write,
2343     scriptlet_typelib_Reset,
2344     scriptlet_typelib_put_GUID,
2345     scriptlet_typelib_get_GUID
2346 };
2347
2348 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved)
2349 {
2350     TRACE("%p, %lu, %p\n", hinst, reason, reserved);
2351
2352     switch (reason)
2353     {
2354         case DLL_PROCESS_ATTACH:
2355             DisableThreadLibraryCalls(hinst);
2356             scrobj_instance = hinst;
2357             break;
2358         case DLL_PROCESS_DETACH:
2359             if (reserved) break;
2360             release_typelib();
2361             break;
2362     }
2363     return TRUE;
2364 }
2365
2366 /***********************************************************************
2367  *      DllInstall (scrobj.@)
2368  */
2369 HRESULT WINAPI DllInstall(BOOL install, const WCHAR *arg)
2370 {
2371     struct scriptlet_factory *factory;
2372     HRESULT hres;
2373
2374     if (install)
2375     {
2376         hres = DllRegisterServer();
2377         if (!arg || FAILED(hres)) return hres;
2378     }
2379     else if (!arg)
2380         return DllUnregisterServer();
2381
2382     hres = create_scriptlet_factory(arg, &factory);
2383     if (SUCCEEDED(hres))
2384     {
2385         if (factory->have_registration)
2386         {
2387             /* validate scripts */
2388             hres = create_scriptlet_hosts(factory, &factory->hosts);
2389             if (SUCCEEDED(hres)) hres = parse_scripts(factory, &factory->hosts, FALSE);
2390         }
2391         else
2392         {
2393             FIXME("No registration info\n");
2394             hres = E_FAIL;
2395         }
2396         if (SUCCEEDED(hres))
2397         {
2398             if (install)
2399                 hres = register_scriptlet(factory);
2400             else
2401                 hres = unregister_scriptlet(factory);
2402         }
2403         IClassFactory_Release(&factory->IClassFactory_iface);
2404     }
2405
2406     return hres;
2407 }
2408
2409 static HRESULT WINAPI scriptlet_typelib_CreateInstance(IClassFactory *factory, IUnknown *outer, REFIID riid, void **obj)
2410 {
2411     struct scriptlet_typelib *This;
2412     HRESULT hr;
2413
2414     TRACE("(%p, %p, %s, %p)\n", factory, outer, debugstr_guid(riid), obj);
2415
2416     *obj = NULL;
2417
2418     if (!(This = calloc(1, sizeof(*This))))
2419         return E_OUTOFMEMORY;
2420
2421     This->IGenScriptletTLib_iface.lpVtbl = &scriptlet_typelib_vtbl;
2422     This->ref = 1;
2423
2424     hr = IGenScriptletTLib_QueryInterface(&This->IGenScriptletTLib_iface, riid, obj);
2425     IGenScriptletTLib_Release(&This->IGenScriptletTLib_iface);
2426     return hr;
2427 }
2428
2429 static HRESULT WINAPI scrruncf_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2430 {
2431     *ppv = NULL;
2432
2433     if (IsEqualGUID(&IID_IUnknown, riid))
2434     {
2435         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
2436         *ppv = iface;
2437     }
2438     else if (IsEqualGUID(&IID_IClassFactory, riid))
2439     {
2440         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
2441         *ppv = iface;
2442     }
2443
2444     if (*ppv)
2445     {
2446         IUnknown_AddRef((IUnknown *)*ppv);
2447         return S_OK;
2448     }
2449
2450     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
2451     return E_NOINTERFACE;
2452 }
2453
2454 static ULONG WINAPI scrruncf_AddRef(IClassFactory *iface)
2455 {
2456     TRACE("(%p)\n", iface);
2457     return 2;
2458 }
2459
2460 static ULONG WINAPI scrruncf_Release(IClassFactory *iface)
2461 {
2462     TRACE("(%p)\n", iface);
2463     return 1;
2464 }
2465
2466 static HRESULT WINAPI scrruncf_LockServer(IClassFactory *iface, BOOL fLock)
2467 {
2468     TRACE("(%p)->(%x)\n", iface, fLock);
2469     return S_OK;
2470 }
2471
2472 static const struct IClassFactoryVtbl scriptlet_typelib_factory_vtbl =
2473 {
2474     scrruncf_QueryInterface,
2475     scrruncf_AddRef,
2476     scrruncf_Release,
2477     scriptlet_typelib_CreateInstance,
2478     scrruncf_LockServer
2479 };
2480
2481 static IClassFactory scriptlet_typelib_factory = { &scriptlet_typelib_factory_vtbl };
2482
2483 /***********************************************************************
2484  *      DllGetClassObject (scrobj.@)
2485  */
2486 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
2487 {
2488     WCHAR key_name[128], *p;
2489     LONG size = 0;
2490     LSTATUS status;
2491
2492     if (IsEqualGUID(&CLSID_TypeLib, rclsid))
2493     {
2494         TRACE("(Scriptlet.TypeLib %s %p)\n", debugstr_guid(riid), ppv);
2495         return IClassFactory_QueryInterface(&scriptlet_typelib_factory, riid, ppv);
2496     }
2497
2498     wcscpy(key_name, L"CLSID\\");
2499     p = key_name + wcslen(key_name);
2500     p += StringFromGUID2(rclsid, p, ARRAY_SIZE(key_name) - (p - key_name)) - 1;
2501     wcscpy(p, L"\\ScriptletURL");
2502     status = RegQueryValueW(HKEY_CLASSES_ROOT, key_name, NULL, &size);
2503     if (!status)
2504     {
2505         struct scriptlet_factory *factory;
2506         WCHAR *url;
2507         HRESULT hres;
2508
2509         if (!(url = malloc(size * sizeof(WCHAR)))) return E_OUTOFMEMORY;
2510         status = RegQueryValueW(HKEY_CLASSES_ROOT, key_name, url, &size);
2511
2512         hres = create_scriptlet_factory(url, &factory);
2513         free(url);
2514         if (FAILED(hres)) return hres;
2515
2516         hres = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, ppv);
2517         IClassFactory_Release(&factory->IClassFactory_iface);
2518         return hres;
2519     }
2520
2521     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
2522     return CLASS_E_CLASSNOTAVAILABLE;
2523 }