git.oblomov.eu Git - wine/blob - dlls/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     hres = IActiveScriptParse64_ParseScriptText(script_host->parse, text, windowW, NULL, script_endW,
 624                                               0, 0, SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE,
 625                                               &var, &excepinfo);
 626     if(FAILED(hres))
 627         WARN("ParseScriptText failed: %08x\n", hres);
 628
 629 }
 630
 631 static void parse_extern_script(ScriptHost *script_host, LPCWSTR src)
 632 {
 633     IMoniker *mon;
 634     char *buf;
 635     WCHAR *text;
 636     DWORD len, size=0;
 637     HRESULT hres;
 638
 639     static const WCHAR wine_schemaW[] = {'w','i','n','e',':'};
 640
 641     if(strlenW(src) > sizeof(wine_schemaW)/sizeof(WCHAR) && !memcmp(src, wine_schemaW, sizeof(wine_schemaW)))
 642         src += sizeof(wine_schemaW)/sizeof(WCHAR);
 643
 644     hres = CreateURLMoniker(NULL, src, &mon);
 645     if(FAILED(hres))
 646         return;
 647
 648     hres = bind_mon_to_buffer(&script_host->window->doc_obj->basedoc, mon, (void**)&buf, &size);
 649     IMoniker_Release(mon);
 650     if(FAILED(hres))
 651         return;
 652
 653     len = MultiByteToWideChar(CP_ACP, 0, buf, size, NULL, 0);
 654     text = heap_alloc((len+1)*sizeof(WCHAR));
 655     MultiByteToWideChar(CP_ACP, 0, buf, size, text, len);
 656     heap_free(buf);
 657     text[len] = 0;
 658
 659     parse_text(script_host, text);
 660
 661     heap_free(text);
 662 }
 663
 664 static void parse_inline_script(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 665 {
 666     const PRUnichar *text;
 667     nsAString text_str;
 668     nsresult nsres;
 669
 670     nsAString_Init(&text_str, NULL);
 671
 672     nsres = nsIDOMHTMLScriptElement_GetText(nsscript, &text_str);
 673
 674     if(NS_SUCCEEDED(nsres)) {
 675         nsAString_GetData(&text_str, &text);
 676         parse_text(script_host, text);
 677     }else {
 678         ERR("GetText failed: %08x\n", nsres);
 679     }
 680
 681     nsAString_Finish(&text_str);
 682 }
 683
 684 static void parse_script_elem(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 685 {
 686     const PRUnichar *src;
 687     nsAString src_str;
 688     nsresult nsres;
 689
 690     nsAString_Init(&src_str, NULL);
 691
 692     nsres = nsIDOMHTMLScriptElement_GetSrc(nsscript, &src_str);
 693     nsAString_GetData(&src_str, &src);
 694
 695     if(NS_FAILED(nsres))
 696         ERR("GetSrc failed: %08x\n", nsres);
 697     else if(*src)
 698         parse_extern_script(script_host, src);
 699     else
 700         parse_inline_script(script_host, nsscript);
 701
 702     nsAString_Finish(&src_str);
 703 }
 704
 705 static BOOL get_guid_from_type(LPCWSTR type, GUID *guid)
 706 {
 707     const WCHAR text_javascriptW[] =
 708         {'t','e','x','t','/','j','a','v','a','s','c','r','i','p','t',0};
 709
 710     /* FIXME: Handle more types */
 711     if(!strcmpiW(type, text_javascriptW)) {
 712         *guid = CLSID_JScript;
 713     }else {
 714         FIXME("Unknown type %s\n", debugstr_w(type));
 715         return FALSE;
 716     }
 717
 718     return TRUE;
 719 }
 720
 721 static BOOL get_guid_from_language(LPCWSTR type, GUID *guid)
 722 {
 723     HRESULT hres;
 724
 725     hres = CLSIDFromProgID(type, guid);
 726     if(FAILED(hres))
 727         return FALSE;
 728
 729     /* FIXME: Check CATID_ActiveScriptParse */
 730
 731     return TRUE;
 732 }
 733
 734 static BOOL get_script_guid(nsIDOMHTMLScriptElement *nsscript, GUID *guid)
 735 {
 736     nsAString attr_str, val_str;
 737     BOOL ret = FALSE;
 738     nsresult nsres;
 739
 740     static const PRUnichar languageW[] = {'l','a','n','g','u','a','g','e',0};
 741
 742     nsAString_Init(&val_str, NULL);
 743
 744     nsres = nsIDOMHTMLScriptElement_GetType(nsscript, &val_str);
 745     if(NS_SUCCEEDED(nsres)) {
 746         const PRUnichar *type;
 747
 748         nsAString_GetData(&val_str, &type);
 749         if(*type) {
 750             ret = get_guid_from_type(type, guid);
 751             nsAString_Finish(&val_str);
 752             return ret;
 753         }
 754     }else {
 755         ERR("GetType failed: %08x\n", nsres);
 756     }
 757
 758     nsAString_Init(&attr_str, languageW);
 759
 760     nsres = nsIDOMHTMLScriptElement_GetAttribute(nsscript, &attr_str, &val_str);
 761     if(NS_SUCCEEDED(nsres)) {
 762         const PRUnichar *language;
 763
 764         nsAString_GetData(&val_str, &language);
 765
 766         if(*language) {
 767             ret = get_guid_from_language(language, guid);
 768         }else {
 769             *guid = CLSID_JScript;
 770             ret = TRUE;
 771         }
 772     }else {
 773         ERR("GetAttribute(language) failed: %08x\n", nsres);
 774     }
 775
 776     nsAString_Finish(&attr_str);
 777     nsAString_Finish(&val_str);
 778
 779     return ret;
 780 }
 781
 782 static ScriptHost *get_script_host(HTMLWindow *window, const GUID *guid)
 783 {
 784     ScriptHost *iter;
 785
 786     if(IsEqualGUID(&CLSID_JScript, guid) && window->scriptmode != SCRIPTMODE_ACTIVESCRIPT) {
 787         TRACE("Ignoring JScript\n");
 788         return NULL;
 789     }
 790
 791     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 792         if(IsEqualGUID(guid, &iter->guid))
 793             return iter;
 794     }
 795
 796     return create_script_host(window, guid);
 797 }
 798
 799 void doc_insert_script(HTMLWindow *window, nsIDOMHTMLScriptElement *nsscript)
 800 {
 801     ScriptHost *script_host;
 802     GUID guid;
 803
 804     if(!get_script_guid(nsscript, &guid)) {
 805         WARN("Could not find script GUID\n");
 806         return;
 807     }
 808
 809     script_host = get_script_host(window, &guid);
 810     if(!script_host)
 811         return;
 812
 813     if(script_host->parse)
 814         parse_script_elem(script_host, nsscript);
 815 }
 816
 817 IDispatch *script_parse_event(HTMLWindow *window, LPCWSTR text)
 818 {
 819     ScriptHost *script_host;
 820     GUID guid = CLSID_JScript;
 821     const WCHAR *ptr;
 822     IDispatch *disp;
 823     HRESULT hres;
 824
 825     static const WCHAR delimiterW[] = {'\"',0};
 826
 827     for(ptr = text; isalnumW(*ptr); ptr++);
 828     if(*ptr == ':') {
 829         LPWSTR language;
 830         BOOL b;
 831
 832         language = heap_alloc((ptr-text+1)*sizeof(WCHAR));
 833         memcpy(language, text, (ptr-text)*sizeof(WCHAR));
 834         language[ptr-text] = 0;
 835
 836         b = get_guid_from_language(language, &guid);
 837
 838         heap_free(language);
 839
 840         if(!b) {
 841             WARN("Could not find language\n");
 842             return NULL;
 843         }
 844
 845         ptr++;
 846     }else {
 847         ptr = text;
 848     }
 849
 850     script_host = get_script_host(window, &guid);
 851     if(!script_host || !script_host->parse_proc)
 852         return NULL;
 853
 854     hres = IActiveScriptParseProcedure64_ParseProcedureText(script_host->parse_proc, ptr, NULL, emptyW,
 855             NULL, NULL, delimiterW, 0 /* FIXME */, 0,
 856             SCRIPTPROC_HOSTMANAGESSOURCE|SCRIPTPROC_IMPLICIT_THIS|SCRIPTPROC_IMPLICIT_PARENTS, &disp);
 857     if(FAILED(hres)) {
 858         WARN("ParseProcedureText failed: %08x\n", hres);
 859         return NULL;
 860     }
 861
 862     TRACE("ret %p\n", disp);
 863     return disp;
 864 }
 865
 866 IDispatch *get_script_disp(ScriptHost *script_host)
 867 {
 868     IDispatch *disp;
 869     HRESULT hres;
 870
 871     if(!script_host->script)
 872         return NULL;
 873
 874     hres = IActiveScript_GetScriptDispatch(script_host->script, windowW, &disp);
 875     if(FAILED(hres))
 876         return NULL;
 877
 878     return disp;
 879 }
 880
 881 BOOL find_global_prop(HTMLWindow *window, BSTR name, DWORD flags, ScriptHost **ret_host, DISPID *ret_id)
 882 {
 883     IDispatchEx *dispex;
 884     IDispatch *disp;
 885     ScriptHost *iter;
 886     HRESULT hres;
 887
 888     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 889         disp = get_script_disp(iter);
 890         if(!disp)
 891             continue;
 892
 893         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 894         if(SUCCEEDED(hres)) {
 895             hres = IDispatchEx_GetDispID(dispex, name, flags, ret_id);
 896             IDispatchEx_Release(dispex);
 897         }else {
 898             FIXME("No IDispatchEx\n");
 899             hres = E_NOTIMPL;
 900         }
 901
 902         IDispatch_Release(disp);
 903         if(SUCCEEDED(hres)) {
 904             *ret_host = iter;
 905             return TRUE;
 906         }
 907     }
 908
 909     return FALSE;
 910 }
 911
 912 static BOOL is_jscript_available(void)
 913 {
 914     static BOOL available, checked;
 915
 916     if(!checked) {
 917         IUnknown *unk;
 918         HRESULT hres = CoGetClassObject(&CLSID_JScript, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
 919
 920         if(SUCCEEDED(hres)) {
 921             available = TRUE;
 922             IUnknown_Release(unk);
 923         }else {
 924             available = FALSE;
 925         }
 926         checked = TRUE;
 927     }
 928
 929     return available;
 930 }
 931
 932 void set_script_mode(HTMLWindow *window, SCRIPTMODE mode)
 933 {
 934     nsIWebBrowserSetup *setup;
 935     nsresult nsres;
 936
 937     if(mode == SCRIPTMODE_ACTIVESCRIPT && !is_jscript_available()) {
 938         TRACE("jscript.dll not available\n");
 939         window->scriptmode = SCRIPTMODE_GECKO;
 940         return;
 941     }
 942
 943     window->scriptmode = mode;
 944
 945     if(!window->doc_obj->nscontainer || !window->doc_obj->nscontainer->webbrowser)
 946         return;
 947
 948     nsres = nsIWebBrowser_QueryInterface(window->doc_obj->nscontainer->webbrowser,
 949             &IID_nsIWebBrowserSetup, (void**)&setup);
 950     if(NS_SUCCEEDED(nsres)) {
 951         nsres = nsIWebBrowserSetup_SetProperty(setup, SETUP_ALLOW_JAVASCRIPT,
 952                 window->scriptmode == SCRIPTMODE_GECKO);
 953         nsIWebBrowserSetup_Release(setup);
 954     }
 955
 956     if(NS_FAILED(nsres))
 957         ERR("JavaScript setup failed: %08x\n", nsres);
 958 }
 959
 960 void release_script_hosts(HTMLWindow *window)
 961 {
 962     ScriptHost *iter;
 963
 964     while(!list_empty(&window->script_hosts)) {
 965         iter = LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
 966
 967         release_script_engine(iter);
 968         list_remove(&iter->entry);
 969         iter->window = NULL;
 970         IActiveScript_Release(ACTSCPSITE(iter));
 971     }
 972 }