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