reactos/dll/win32/mshtml/script.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 "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29 #include "activscp.h"
  30 #include "activdbg.h"
  31 #include "objsafe.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "mshtml_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
  40 static const WCHAR emptyW[] = {0};
  41
  42 static const CLSID CLSID_JScript =
  43     {0xf414c260,0x6ac0,0x11cf,{0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58}};
  44
  45 struct ScriptHost {
  46     const IActiveScriptSiteVtbl               *lpIActiveScriptSiteVtbl;
  47     const IActiveScriptSiteInterruptPollVtbl  *lpIActiveScriptSiteInterruptPollVtbl;
  48     const IActiveScriptSiteWindowVtbl         *lpIActiveScriptSiteWindowVtbl;
  49     const IActiveScriptSiteDebug32Vtbl        *lpIActiveScriptSiteDebug32Vtbl;
  50     const IServiceProviderVtbl                *lpServiceProviderVtbl;
  51
  52     LONG ref;
  53
  54     IActiveScript *script;
  55     IActiveScriptParse *parse;
  56     IActiveScriptParseProcedure *parse_proc;
  57
  58     SCRIPTSTATE script_state;
  59
  60     HTMLWindow *window;
  61
  62     GUID guid;
  63     struct list entry;
  64 };
  65
  66 #define ACTSCPSITE(x)  ((IActiveScriptSite*)               &(x)->lpIActiveScriptSiteVtbl)
  67 #define ACTSCPPOLL(x)  (&(x)->lpIActiveScriptSiteInterruptPollVtbl)
  68 #define ACTSCPWIN(x)   (&(x)->lpIActiveScriptSiteWindowVtbl)
  69 #define ACTSCPDBG32(x) (&(x)->lpIActiveScriptSiteDebug32Vtbl)
  70
  71 static void set_script_prop(ScriptHost *script_host, DWORD property, VARIANT *val)
  72 {
  73     IActiveScriptProperty *script_prop;
  74     HRESULT hres;
  75
  76     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptProperty,
  77             (void**)&script_prop);
  78     if(FAILED(hres)) {
  79         WARN("Could not get IActiveScriptProperty iface: %08x\n", hres);
  80         return;
  81     }
  82
  83     hres = IActiveScriptProperty_SetProperty(script_prop, property, NULL, val);
  84     IActiveScriptProperty_Release(script_prop);
  85     if(FAILED(hres))
  86         WARN("SetProperty(%x) failed: %08x\n", property, hres);
  87 }
  88
  89 static BOOL init_script_engine(ScriptHost *script_host)
  90 {
  91     IObjectSafety *safety;
  92     SCRIPTSTATE state;
  93     DWORD supported_opts=0, enabled_opts=0;
  94     VARIANT var;
  95     HRESULT hres;
  96
  97     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParse, (void**)&script_host->parse);
  98     if(FAILED(hres)) {
  99         WARN("Could not get IActiveScriptHost: %08x\n", hres);
 100         return FALSE;
 101     }
 102
 103     hres = IActiveScript_QueryInterface(script_host->script, &IID_IObjectSafety, (void**)&safety);
 104     if(FAILED(hres)) {
 105         FIXME("Could not get IObjectSafety: %08x\n", hres);
 106         return FALSE;
 107     }
 108
 109     hres = IObjectSafety_GetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse, &supported_opts, &enabled_opts);
 110     if(FAILED(hres)) {
 111         FIXME("GetInterfaceSafetyOptions failed: %08x\n", hres);
 112     }else if(!(supported_opts & INTERFACE_USES_DISPEX)) {
 113         FIXME("INTERFACE_USES_DISPEX is not supported\n");
 114     }else {
 115         hres = IObjectSafety_SetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse,
 116                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER,
 117                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER);
 118         if(FAILED(hres))
 119             FIXME("SetInterfaceSafetyOptions failed: %08x\n", hres);
 120     }
 121
 122     IObjectSafety_Release(safety);
 123     if(FAILED(hres))
 124         return FALSE;
 125
 126     V_VT(&var) = VT_I4;
 127     V_I4(&var) = 1;
 128     set_script_prop(script_host, SCRIPTPROP_INVOKEVERSIONING, &var);
 129
 130     V_VT(&var) = VT_BOOL;
 131     V_BOOL(&var) = VARIANT_TRUE;
 132     set_script_prop(script_host, SCRIPTPROP_HACK_TRIDENTEVENTSINK, &var);
 133
 134     hres = IActiveScriptParse64_InitNew(script_host->parse);
 135     if(FAILED(hres)) {
 136         WARN("InitNew failed: %08x\n", hres);
 137         return FALSE;
 138     }
 139
 140     hres = IActiveScript_SetScriptSite(script_host->script, ACTSCPSITE(script_host));
 141     if(FAILED(hres)) {
 142         WARN("SetScriptSite failed: %08x\n", hres);
 143         IActiveScript_Close(script_host->script);
 144         return FALSE;
 145     }
 146
 147     hres = IActiveScript_GetScriptState(script_host->script, &state);
 148     if(FAILED(hres))
 149         WARN("GetScriptState failed: %08x\n", hres);
 150     else if(state != SCRIPTSTATE_INITIALIZED)
 151         FIXME("state = %x\n", state);
 152
 153     hres = IActiveScript_SetScriptState(script_host->script, SCRIPTSTATE_STARTED);
 154     if(FAILED(hres)) {
 155         WARN("Starting script failed: %08x\n", hres);
 156         return FALSE;
 157     }
 158
 159     hres = IActiveScript_AddNamedItem(script_host->script, windowW,
 160             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 161     if(SUCCEEDED(hres)) {
 162         V_VT(&var) = VT_BOOL;
 163         V_BOOL(&var) = VARIANT_TRUE;
 164         set_script_prop(script_host, SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION, &var);
 165     }else {
 166        WARN("AddNamedItem failed: %08x\n", hres);
 167     }
 168
 169     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParseProcedure2,
 170                                         (void**)&script_host->parse_proc);
 171     if(FAILED(hres)) {
 172         /* FIXME: QI for IActiveScriptParseProcedure */
 173         WARN("Could not get IActiveScriptParseProcedure iface: %08x\n", hres);
 174     }
 175
 176     return TRUE;
 177 }
 178
 179 static void release_script_engine(ScriptHost *This)
 180 {
 181     if(!This->script)
 182         return;
 183
 184     switch(This->script_state) {
 185     case SCRIPTSTATE_CONNECTED:
 186         IActiveScript_SetScriptState(This->script, SCRIPTSTATE_DISCONNECTED);
 187
 188     case SCRIPTSTATE_STARTED:
 189     case SCRIPTSTATE_DISCONNECTED:
 190     case SCRIPTSTATE_INITIALIZED:
 191         IActiveScript_Close(This->script);
 192
 193     default:
 194         if(This->parse_proc) {
 195             IUnknown_Release(This->parse_proc);
 196             This->parse_proc = NULL;
 197         }
 198
 199         if(This->parse) {
 200             IUnknown_Release(This->parse);
 201             This->parse = NULL;
 202         }
 203     }
 204
 205     IActiveScript_Release(This->script);
 206     This->script = NULL;
 207     This->script_state = SCRIPTSTATE_UNINITIALIZED;
 208 }
 209
 210 void connect_scripts(HTMLWindow *window)
 211 {
 212     ScriptHost *iter;
 213
 214     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 215         if(iter->script_state == SCRIPTSTATE_STARTED)
 216             IActiveScript_SetScriptState(iter->script, SCRIPTSTATE_CONNECTED);
 217     }
 218 }
 219
 220 #define ACTSCPSITE_THIS(iface) DEFINE_THIS(ScriptHost, IActiveScriptSite, iface)
 221
 222 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 223 {
 224     ScriptHost *This = ACTSCPSITE_THIS(iface);
 225
 226     *ppv = NULL;
 227
 228     if(IsEqualGUID(&IID_IUnknown, riid)) {
 229         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 230         *ppv = ACTSCPSITE(This);
 231     }else if(IsEqualGUID(&IID_IActiveScriptSite, riid)) {
 232         TRACE("(%p)->(IID_IActiveScriptSite %p)\n", This, ppv);
 233         *ppv = ACTSCPSITE(This);
 234     }else if(IsEqualGUID(&IID_IActiveScriptSiteInterruptPoll, riid)) {
 235         TRACE("(%p)->(IID_IActiveScriptSiteInterruprtPoll %p)\n", This, ppv);
 236         *ppv = ACTSCPPOLL(This);
 237     }else if(IsEqualGUID(&IID_IActiveScriptSiteWindow, riid)) {
 238         TRACE("(%p)->(IID_IActiveScriptSiteWindow %p)\n", This, ppv);
 239         *ppv = ACTSCPWIN(This);
 240     }else if(IsEqualGUID(&IID_IActiveScriptSiteDebug32, riid)) {
 241         TRACE("(%p)->(IID_IActiveScriptSiteDebug32 %p)\n", This, ppv);
 242         *ppv = ACTSCPDBG32(This);
 243     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 244         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 245         *ppv = SERVPROV(This);
 246     }else if(IsEqualGUID(&IID_ICanHandleException, riid)) {
 247         TRACE("(%p)->(IID_ICanHandleException not supported %p)\n", This, ppv);
 248         return E_NOINTERFACE;
 249     }else {
 250         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 251         return E_NOINTERFACE;
 252     }
 253
 254     IUnknown_AddRef((IUnknown*)*ppv);
 255     return S_OK;
 256 }
 257
 258 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 259 {
 260     ScriptHost *This = ACTSCPSITE_THIS(iface);
 261     LONG ref = InterlockedIncrement(&This->ref);
 262
 263     TRACE("(%p) ref=%d\n", This, ref);
 264
 265     return ref;
 266 }
 267
 268 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 269 {
 270     ScriptHost *This = ACTSCPSITE_THIS(iface);
 271     LONG ref = InterlockedDecrement(&This->ref);
 272
 273     TRACE("(%p) ref=%d\n", This, ref);
 274
 275     if(!ref) {
 276         release_script_engine(This);
 277         if(This->window)
 278             list_remove(&This->entry);
 279         heap_free(This);
 280     }
 281
 282     return ref;
 283 }
 284
 285 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 286 {
 287     ScriptHost *This = ACTSCPSITE_THIS(iface);
 288
 289     TRACE("(%p)->(%p)\n", This, plcid);
 290
 291     *plcid = GetUserDefaultLCID();
 292     return S_OK;
 293 }
 294
 295 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 296         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 297 {
 298     ScriptHost *This = ACTSCPSITE_THIS(iface);
 299
 300     TRACE("(%p)->(%s %x %p %p)\n", This, debugstr_w(pstrName), dwReturnMask, ppiunkItem, ppti);
 301
 302     if(dwReturnMask != SCRIPTINFO_IUNKNOWN) {
 303         FIXME("Unsupported mask %x\n", dwReturnMask);
 304         return E_NOTIMPL;
 305     }
 306
 307     *ppiunkItem = NULL;
 308
 309     if(strcmpW(pstrName, windowW))
 310         return DISP_E_MEMBERNOTFOUND;
 311
 312     if(!This->window)
 313         return E_FAIL;
 314
 315     /* FIXME: Return proxy object */
 316     *ppiunkItem = (IUnknown*)HTMLWINDOW2(This->window);
 317     IUnknown_AddRef(*ppiunkItem);
 318
 319     return S_OK;
 320 }
 321
 322 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 323 {
 324     ScriptHost *This = ACTSCPSITE_THIS(iface);
 325     FIXME("(%p)->(%p)\n", This, pbstrVersion);
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 330         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 331 {
 332     ScriptHost *This = ACTSCPSITE_THIS(iface);
 333     FIXME("(%p)->(%p %p)\n", This, pvarResult, pexcepinfo);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 338 {
 339     ScriptHost *This = ACTSCPSITE_THIS(iface);
 340
 341     TRACE("(%p)->(%x)\n", This, ssScriptState);
 342
 343     This->script_state = ssScriptState;
 344     return S_OK;
 345 }
 346
 347 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 348 {
 349     ScriptHost *This = ACTSCPSITE_THIS(iface);
 350     FIXME("(%p)->(%p)\n", This, pscripterror);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 355 {
 356     ScriptHost *This = ACTSCPSITE_THIS(iface);
 357
 358     TRACE("(%p)->()\n", This);
 359
 360     return S_OK;
 361 }
 362
 363 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 364 {
 365     ScriptHost *This = ACTSCPSITE_THIS(iface);
 366
 367     TRACE("(%p)->()\n", This);
 368
 369     return S_OK;
 370 }
 371
 372 #undef ACTSCPSITE_THIS
 373
 374 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 375     ActiveScriptSite_QueryInterface,
 376     ActiveScriptSite_AddRef,
 377     ActiveScriptSite_Release,
 378     ActiveScriptSite_GetLCID,
 379     ActiveScriptSite_GetItemInfo,
 380     ActiveScriptSite_GetDocVersionString,
 381     ActiveScriptSite_OnScriptTerminate,
 382     ActiveScriptSite_OnStateChange,
 383     ActiveScriptSite_OnScriptError,
 384     ActiveScriptSite_OnEnterScript,
 385     ActiveScriptSite_OnLeaveScript
 386 };
 387
 388 #define ACTSCPPOLL_THIS(iface) DEFINE_THIS(ScriptHost, IActiveScriptSiteInterruptPoll, iface)
 389
 390 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryInterface(IActiveScriptSiteInterruptPoll *iface,
 391         REFIID riid, void **ppv)
 392 {
 393     ScriptHost *This = ACTSCPPOLL_THIS(iface);
 394     return IActiveScriptSite_QueryInterface(ACTSCPSITE(This), riid, ppv);
 395 }
 396
 397 static ULONG WINAPI ActiveScriptSiteInterruptPoll_AddRef(IActiveScriptSiteInterruptPoll *iface)
 398 {
 399     ScriptHost *This = ACTSCPPOLL_THIS(iface);
 400     return IActiveScriptSite_AddRef(ACTSCPSITE(This));
 401 }
 402
 403 static ULONG WINAPI ActiveScriptSiteInterruptPoll_Release(IActiveScriptSiteInterruptPoll *iface)
 404 {
 405     ScriptHost *This = ACTSCPPOLL_THIS(iface);
 406     return IActiveScriptSite_Release(ACTSCPSITE(This));
 407 }
 408
 409 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryContinue(IActiveScriptSiteInterruptPoll *iface)
 410 {
 411     ScriptHost *This = ACTSCPPOLL_THIS(iface);
 412
 413     TRACE("(%p)\n", This);
 414
 415     return S_OK;
 416 }
 417
 418 #undef ACTSCPPOLL_THIS
 419
 420 static const IActiveScriptSiteInterruptPollVtbl ActiveScriptSiteInterruptPollVtbl = {
 421     ActiveScriptSiteInterruptPoll_QueryInterface,
 422     ActiveScriptSiteInterruptPoll_AddRef,
 423     ActiveScriptSiteInterruptPoll_Release,
 424     ActiveScriptSiteInterruptPoll_QueryContinue
 425 };
 426
 427 #define ACTSCPWIN_THIS(iface) DEFINE_THIS(ScriptHost, IActiveScriptSiteWindow, iface)
 428
 429 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface,
 430         REFIID riid, void **ppv)
 431 {
 432     ScriptHost *This = ACTSCPWIN_THIS(iface);
 433     return IActiveScriptSite_QueryInterface(ACTSCPSITE(This), riid, ppv);
 434 }
 435
 436 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 437 {
 438     ScriptHost *This = ACTSCPWIN_THIS(iface);
 439     return IActiveScriptSite_AddRef(ACTSCPSITE(This));
 440 }
 441
 442 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 443 {
 444     ScriptHost *This = ACTSCPWIN_THIS(iface);
 445     return IActiveScriptSite_Release(ACTSCPSITE(This));
 446 }
 447
 448 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *phwnd)
 449 {
 450     ScriptHost *This = ACTSCPWIN_THIS(iface);
 451     FIXME("(%p)->(%p)\n", This, phwnd);
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL fEnable)
 456 {
 457     ScriptHost *This = ACTSCPWIN_THIS(iface);
 458     FIXME("(%p)->(%x)\n", This, fEnable);
 459     return E_NOTIMPL;
 460 }
 461
 462 #undef ACTSCPWIN_THIS
 463
 464 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 465     ActiveScriptSiteWindow_QueryInterface,
 466     ActiveScriptSiteWindow_AddRef,
 467     ActiveScriptSiteWindow_Release,
 468     ActiveScriptSiteWindow_GetWindow,
 469     ActiveScriptSiteWindow_EnableModeless
 470 };
 471
 472 #define ACTSCPDBG32_THIS(iface) DEFINE_THIS(ScriptHost, IActiveScriptSiteDebug32, iface)
 473
 474 static HRESULT WINAPI ActiveScriptSiteDebug32_QueryInterface(IActiveScriptSiteDebug32 *iface,
 475         REFIID riid, void **ppv)
 476 {
 477     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 478     return IActiveScriptSite_QueryInterface(ACTSCPSITE(This), riid, ppv);
 479 }
 480
 481 static ULONG WINAPI ActiveScriptSiteDebug32_AddRef(IActiveScriptSiteDebug32 *iface)
 482 {
 483     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 484     return IActiveScriptSite_AddRef(ACTSCPSITE(This));
 485 }
 486
 487 static ULONG WINAPI ActiveScriptSiteDebug32_Release(IActiveScriptSiteDebug32 *iface)
 488 {
 489     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 490     return IActiveScriptSite_Release(ACTSCPSITE(This));
 491 }
 492
 493 static HRESULT WINAPI ActiveScriptSiteDebug32_GetDocumentContextFromPosition(IActiveScriptSiteDebug32 *iface,
 494             DWORD dwSourceContext, ULONG uCharacterOffset, ULONG uNumChars, IDebugDocumentContext **ppsc)
 495 {
 496     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 497     FIXME("(%p)->(%x %u %u %p)\n", This, dwSourceContext, uCharacterOffset, uNumChars, ppsc);
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT WINAPI ActiveScriptSiteDebug32_GetApplication(IActiveScriptSiteDebug32 *iface, IDebugApplication32 **ppda)
 502 {
 503     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 504     FIXME("(%p)->(%p)\n", This, ppda);
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI ActiveScriptSiteDebug32_GetRootApplicationNode(IActiveScriptSiteDebug32 *iface,
 509             IDebugApplicationNode **ppdanRoot)
 510 {
 511     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 512     FIXME("(%p)->(%p)\n", This, ppdanRoot);
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI ActiveScriptSiteDebug32_OnScriptErrorDebug(IActiveScriptSiteDebug32 *iface,
 517             IActiveScriptErrorDebug *pErrorDebug, BOOL *pfEnterDebugger, BOOL *pfCallOnScriptErrorWhenContinuing)
 518 {
 519     ScriptHost *This = ACTSCPDBG32_THIS(iface);
 520     FIXME("(%p)->(%p %p %p)\n", This, pErrorDebug, pfEnterDebugger, pfCallOnScriptErrorWhenContinuing);
 521     return E_NOTIMPL;
 522 }
 523
 524 #undef ACTSCPDBG32_THIS
 525
 526 static const IActiveScriptSiteDebug32Vtbl ActiveScriptSiteDebug32Vtbl = {
 527     ActiveScriptSiteDebug32_QueryInterface,
 528     ActiveScriptSiteDebug32_AddRef,
 529     ActiveScriptSiteDebug32_Release,
 530     ActiveScriptSiteDebug32_GetDocumentContextFromPosition,
 531     ActiveScriptSiteDebug32_GetApplication,
 532     ActiveScriptSiteDebug32_GetRootApplicationNode,
 533     ActiveScriptSiteDebug32_OnScriptErrorDebug
 534 };
 535
 536 #define SERVPROV_THIS(iface) DEFINE_THIS(ScriptHost, ServiceProvider, iface)
 537
 538 static HRESULT WINAPI ASServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 539 {
 540     ScriptHost *This = SERVPROV_THIS(iface);
 541     return IActiveScriptSite_QueryInterface(ACTSCPSITE(This), riid, ppv);
 542 }
 543
 544 static ULONG WINAPI ASServiceProvider_AddRef(IServiceProvider *iface)
 545 {
 546     ScriptHost *This = SERVPROV_THIS(iface);
 547     return IActiveScriptSite_AddRef(ACTSCPSITE(This));
 548 }
 549
 550 static ULONG WINAPI ASServiceProvider_Release(IServiceProvider *iface)
 551 {
 552     ScriptHost *This = SERVPROV_THIS(iface);
 553     return IActiveScriptSite_Release(ACTSCPSITE(This));
 554 }
 555
 556 static HRESULT WINAPI ASServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 557         REFIID riid, void **ppv)
 558 {
 559     ScriptHost *This = SERVPROV_THIS(iface);
 560
 561     if(IsEqualGUID(&SID_SInternetHostSecurityManager, guidService)) {
 562         TRACE("(%p)->(SID_SInternetHostSecurityManager)\n", This);
 563
 564         if(!This->window || !This->window->doc)
 565             return E_NOINTERFACE;
 566
 567         return IInternetHostSecurityManager_QueryInterface(HOSTSECMGR(This->window->doc), riid, ppv);
 568     }
 569
 570     FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 571     return E_NOINTERFACE;
 572 }
 573
 574 #undef SERVPROV_THIS
 575
 576 static const IServiceProviderVtbl ASServiceProviderVtbl = {
 577     ASServiceProvider_QueryInterface,
 578     ASServiceProvider_AddRef,
 579     ASServiceProvider_Release,
 580     ASServiceProvider_QueryService
 581 };
 582
 583 static ScriptHost *create_script_host(HTMLWindow *window, const GUID *guid)
 584 {
 585     ScriptHost *ret;
 586     HRESULT hres;
 587
 588     ret = heap_alloc_zero(sizeof(*ret));
 589     ret->lpIActiveScriptSiteVtbl               = &ActiveScriptSiteVtbl;
 590     ret->lpIActiveScriptSiteInterruptPollVtbl  = &ActiveScriptSiteInterruptPollVtbl;
 591     ret->lpIActiveScriptSiteWindowVtbl         = &ActiveScriptSiteWindowVtbl;
 592     ret->lpIActiveScriptSiteDebug32Vtbl        = &ActiveScriptSiteDebug32Vtbl;
 593     ret->lpServiceProviderVtbl                 = &ASServiceProviderVtbl;
 594     ret->ref = 1;
 595     ret->window = window;
 596     ret->script_state = SCRIPTSTATE_UNINITIALIZED;
 597
 598     ret->guid = *guid;
 599     list_add_tail(&window->script_hosts, &ret->entry);
 600
 601     hres = CoCreateInstance(&ret->guid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 602             &IID_IActiveScript, (void**)&ret->script);
 603     if(FAILED(hres))
 604         WARN("Could not load script engine: %08x\n", hres);
 605     else if(!init_script_engine(ret))
 606         release_script_engine(ret);
 607
 608     return ret;
 609 }
 610
 611 static void parse_text(ScriptHost *script_host, LPCWSTR text)
 612 {
 613     EXCEPINFO excepinfo;
 614     VARIANT var;
 615     HRESULT hres;
 616
 617     static const WCHAR script_endW[] = {'<','/','S','C','R','I','P','T','>',0};
 618
 619     TRACE("%s\n", debugstr_w(text));
 620
 621     VariantInit(&var);
 622     memset(&excepinfo, 0, sizeof(excepinfo));
 623     TRACE(">>>\n");
 624     hres = IActiveScriptParse64_ParseScriptText(script_host->parse, text, windowW, NULL, script_endW,
 625                                               0, 0, SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE,
 626                                               &var, &excepinfo);
 627     if(SUCCEEDED(hres))
 628         TRACE("<<<\n");
 629     else
 630         WARN("<<< %08x\n", hres);
 631
 632 }
 633
 634 static void parse_extern_script(ScriptHost *script_host, LPCWSTR src)
 635 {
 636     IMoniker *mon;
 637     char *buf;
 638     WCHAR *text;
 639     DWORD len, size=0;
 640     HRESULT hres;
 641
 642     static const WCHAR wine_schemaW[] = {'w','i','n','e',':'};
 643
 644     if(strlenW(src) > sizeof(wine_schemaW)/sizeof(WCHAR) && !memcmp(src, wine_schemaW, sizeof(wine_schemaW)))
 645         src += sizeof(wine_schemaW)/sizeof(WCHAR);
 646
 647     hres = CreateURLMoniker(NULL, src, &mon);
 648     if(FAILED(hres))
 649         return;
 650
 651     hres = bind_mon_to_buffer(script_host->window->doc, mon, (void**)&buf, &size);
 652     IMoniker_Release(mon);
 653     if(FAILED(hres))
 654         return;
 655
 656     len = MultiByteToWideChar(CP_ACP, 0, buf, size, NULL, 0);
 657     text = heap_alloc((len+1)*sizeof(WCHAR));
 658     MultiByteToWideChar(CP_ACP, 0, buf, size, text, len);
 659     heap_free(buf);
 660     text[len] = 0;
 661
 662     parse_text(script_host, text);
 663
 664     heap_free(text);
 665 }
 666
 667 static void parse_inline_script(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 668 {
 669     const PRUnichar *text;
 670     nsAString text_str;
 671     nsresult nsres;
 672
 673     nsAString_Init(&text_str, NULL);
 674
 675     nsres = nsIDOMHTMLScriptElement_GetText(nsscript, &text_str);
 676
 677     if(NS_SUCCEEDED(nsres)) {
 678         nsAString_GetData(&text_str, &text);
 679         parse_text(script_host, text);
 680     }else {
 681         ERR("GetText failed: %08x\n", nsres);
 682     }
 683
 684     nsAString_Finish(&text_str);
 685 }
 686
 687 static void parse_script_elem(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 688 {
 689     const PRUnichar *src;
 690     nsAString src_str;
 691     nsresult nsres;
 692
 693     nsAString_Init(&src_str, NULL);
 694
 695     nsres = nsIDOMHTMLScriptElement_GetSrc(nsscript, &src_str);
 696     nsAString_GetData(&src_str, &src);
 697
 698     if(NS_FAILED(nsres))
 699         ERR("GetSrc failed: %08x\n", nsres);
 700     else if(*src)
 701         parse_extern_script(script_host, src);
 702     else
 703         parse_inline_script(script_host, nsscript);
 704
 705     nsAString_Finish(&src_str);
 706 }
 707
 708 static BOOL get_guid_from_type(LPCWSTR type, GUID *guid)
 709 {
 710     const WCHAR text_javascriptW[] =
 711         {'t','e','x','t','/','j','a','v','a','s','c','r','i','p','t',0};
 712
 713     /* FIXME: Handle more types */
 714     if(!strcmpiW(type, text_javascriptW)) {
 715         *guid = CLSID_JScript;
 716     }else {
 717         FIXME("Unknown type %s\n", debugstr_w(type));
 718         return FALSE;
 719     }
 720
 721     return TRUE;
 722 }
 723
 724 static BOOL get_guid_from_language(LPCWSTR type, GUID *guid)
 725 {
 726     HRESULT hres;
 727
 728     hres = CLSIDFromProgID(type, guid);
 729     if(FAILED(hres))
 730         return FALSE;
 731
 732     /* FIXME: Check CATID_ActiveScriptParse */
 733
 734     return TRUE;
 735 }
 736
 737 static BOOL get_script_guid(nsIDOMHTMLScriptElement *nsscript, GUID *guid)
 738 {
 739     nsAString attr_str, val_str;
 740     BOOL ret = FALSE;
 741     nsresult nsres;
 742
 743     static const PRUnichar languageW[] = {'l','a','n','g','u','a','g','e',0};
 744
 745     nsAString_Init(&val_str, NULL);
 746
 747     nsres = nsIDOMHTMLScriptElement_GetType(nsscript, &val_str);
 748     if(NS_SUCCEEDED(nsres)) {
 749         const PRUnichar *type;
 750
 751         nsAString_GetData(&val_str, &type);
 752         if(*type) {
 753             ret = get_guid_from_type(type, guid);
 754             nsAString_Finish(&val_str);
 755             return ret;
 756         }
 757     }else {
 758         ERR("GetType failed: %08x\n", nsres);
 759     }
 760
 761     nsAString_Init(&attr_str, languageW);
 762
 763     nsres = nsIDOMHTMLScriptElement_GetAttribute(nsscript, &attr_str, &val_str);
 764     if(NS_SUCCEEDED(nsres)) {
 765         const PRUnichar *language;
 766
 767         nsAString_GetData(&val_str, &language);
 768
 769         if(*language) {
 770             ret = get_guid_from_language(language, guid);
 771         }else {
 772             *guid = CLSID_JScript;
 773             ret = TRUE;
 774         }
 775     }else {
 776         ERR("GetAttribute(language) failed: %08x\n", nsres);
 777     }
 778
 779     nsAString_Finish(&attr_str);
 780     nsAString_Finish(&val_str);
 781
 782     return ret;
 783 }
 784
 785 static ScriptHost *get_script_host(HTMLWindow *window, const GUID *guid)
 786 {
 787     ScriptHost *iter;
 788
 789     if(IsEqualGUID(&CLSID_JScript, guid) && window->scriptmode != SCRIPTMODE_ACTIVESCRIPT) {
 790         TRACE("Ignoring JScript\n");
 791         return NULL;
 792     }
 793
 794     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 795         if(IsEqualGUID(guid, &iter->guid))
 796             return iter;
 797     }
 798
 799     return create_script_host(window, guid);
 800 }
 801
 802 void doc_insert_script(HTMLWindow *window, nsIDOMHTMLScriptElement *nsscript)
 803 {
 804     ScriptHost *script_host;
 805     GUID guid;
 806
 807     if(!get_script_guid(nsscript, &guid)) {
 808         WARN("Could not find script GUID\n");
 809         return;
 810     }
 811
 812     script_host = get_script_host(window, &guid);
 813     if(!script_host)
 814         return;
 815
 816     if(script_host->parse)
 817         parse_script_elem(script_host, nsscript);
 818 }
 819
 820 IDispatch *script_parse_event(HTMLWindow *window, LPCWSTR text)
 821 {
 822     ScriptHost *script_host;
 823     GUID guid = CLSID_JScript;
 824     const WCHAR *ptr;
 825     IDispatch *disp;
 826     HRESULT hres;
 827
 828     static const WCHAR delimiterW[] = {'\"',0};
 829
 830     for(ptr = text; isalnumW(*ptr); ptr++);
 831     if(*ptr == ':') {
 832         LPWSTR language;
 833         BOOL b;
 834
 835         language = heap_alloc((ptr-text+1)*sizeof(WCHAR));
 836         memcpy(language, text, (ptr-text)*sizeof(WCHAR));
 837         language[ptr-text] = 0;
 838
 839         b = get_guid_from_language(language, &guid);
 840
 841         heap_free(language);
 842
 843         if(!b) {
 844             WARN("Could not find language\n");
 845             return NULL;
 846         }
 847
 848         ptr++;
 849     }else {
 850         ptr = text;
 851     }
 852
 853     script_host = get_script_host(window, &guid);
 854     if(!script_host || !script_host->parse_proc)
 855         return NULL;
 856
 857     hres = IActiveScriptParseProcedure64_ParseProcedureText(script_host->parse_proc, ptr, NULL, emptyW,
 858             NULL, NULL, delimiterW, 0 /* FIXME */, 0,
 859             SCRIPTPROC_HOSTMANAGESSOURCE|SCRIPTPROC_IMPLICIT_THIS|SCRIPTPROC_IMPLICIT_PARENTS, &disp);
 860     if(FAILED(hres)) {
 861         WARN("ParseProcedureText failed: %08x\n", hres);
 862         return NULL;
 863     }
 864
 865     TRACE("ret %p\n", disp);
 866     return disp;
 867 }
 868
 869 IDispatch *get_script_disp(ScriptHost *script_host)
 870 {
 871     IDispatch *disp;
 872     HRESULT hres;
 873
 874     if(!script_host->script)
 875         return NULL;
 876
 877     hres = IActiveScript_GetScriptDispatch(script_host->script, windowW, &disp);
 878     if(FAILED(hres))
 879         return NULL;
 880
 881     return disp;
 882 }
 883
 884 BOOL find_global_prop(HTMLWindow *window, BSTR name, DWORD flags, ScriptHost **ret_host, DISPID *ret_id)
 885 {
 886     IDispatchEx *dispex;
 887     IDispatch *disp;
 888     ScriptHost *iter;
 889     HRESULT hres;
 890
 891     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 892         disp = get_script_disp(iter);
 893         if(!disp)
 894             continue;
 895
 896         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 897         if(SUCCEEDED(hres)) {
 898             hres = IDispatchEx_GetDispID(dispex, name, flags & (~fdexNameEnsure), ret_id);
 899             IDispatchEx_Release(dispex);
 900         }else {
 901             FIXME("No IDispatchEx\n");
 902             hres = E_NOTIMPL;
 903         }
 904
 905         IDispatch_Release(disp);
 906         if(SUCCEEDED(hres)) {
 907             *ret_host = iter;
 908             return TRUE;
 909         }
 910     }
 911
 912     return FALSE;
 913 }
 914
 915 static BOOL is_jscript_available(void)
 916 {
 917     static BOOL available, checked;
 918
 919     if(!checked) {
 920         IUnknown *unk;
 921         HRESULT hres = CoGetClassObject(&CLSID_JScript, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
 922
 923         if(SUCCEEDED(hres)) {
 924             available = TRUE;
 925             IUnknown_Release(unk);
 926         }else {
 927             available = FALSE;
 928         }
 929         checked = TRUE;
 930     }
 931
 932     return available;
 933 }
 934
 935 void set_script_mode(HTMLWindow *window, SCRIPTMODE mode)
 936 {
 937     nsIWebBrowserSetup *setup;
 938     nsresult nsres;
 939
 940     if(mode == SCRIPTMODE_ACTIVESCRIPT && !is_jscript_available()) {
 941         TRACE("jscript.dll not available\n");
 942         window->scriptmode = SCRIPTMODE_GECKO;
 943         return;
 944     }
 945
 946     window->scriptmode = mode;
 947
 948     if(!window->doc_obj->nscontainer || !window->doc_obj->nscontainer->webbrowser)
 949         return;
 950
 951     nsres = nsIWebBrowser_QueryInterface(window->doc_obj->nscontainer->webbrowser,
 952             &IID_nsIWebBrowserSetup, (void**)&setup);
 953     if(NS_SUCCEEDED(nsres)) {
 954         nsres = nsIWebBrowserSetup_SetProperty(setup, SETUP_ALLOW_JAVASCRIPT,
 955                 window->scriptmode == SCRIPTMODE_GECKO);
 956         nsIWebBrowserSetup_Release(setup);
 957     }
 958
 959     if(NS_FAILED(nsres))
 960         ERR("JavaScript setup failed: %08x\n", nsres);
 961 }
 962
 963 void release_script_hosts(HTMLWindow *window)
 964 {
 965     ScriptHost *iter;
 966
 967     while(!list_empty(&window->script_hosts)) {
 968         iter = LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
 969
 970         release_script_engine(iter);
 971         list_remove(&iter->entry);
 972         iter->window = NULL;
 973         IActiveScript_Release(ACTSCPSITE(iter));
 974     }
 975 }