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