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