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