ReactOS 0.4.15-dev-8207-gd73a838
stylesheet.c
Go to the documentation of this file.
1/*
2 * XSLTemplate/XSLProcessor support
3 *
4 * Copyright 2011 Nikolay Sivov for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#define COBJMACROS
22
23#include "config.h"
24
25#include <stdarg.h>
26#ifdef HAVE_LIBXML2
27# include <libxml/parser.h>
28# include <libxml/xmlerror.h>
29#endif
30
31#include "windef.h"
32#include "winbase.h"
33#include "winuser.h"
34#include "ole2.h"
35#include "msxml6.h"
36
37#include "msxml_private.h"
38
39#include "initguid.h"
40#include "asptlb.h"
41
42#include "wine/debug.h"
43
45
46typedef struct
47{
49 IXSLTemplate IXSLTemplate_iface;
51
54
56{
58 PROCESSOR_OUTPUT_STREAM, /* IStream or ISequentialStream */
59 PROCESSOR_OUTPUT_PERSISTSTREAM, /* IPersistStream or IPersistStreamInit */
61};
62
63typedef struct
64{
66 IXSLProcessor IXSLProcessor_iface;
68
71
72 union
73 {
78 } output;
81
84
85static HRESULT XSLProcessor_create(xsltemplate*, IXSLProcessor**);
86
87static inline xsltemplate *impl_from_IXSLTemplate( IXSLTemplate *iface )
88{
89 return CONTAINING_RECORD(iface, xsltemplate, IXSLTemplate_iface);
90}
91
92static inline xslprocessor *impl_from_IXSLProcessor( IXSLProcessor *iface )
93{
94 return CONTAINING_RECORD(iface, xslprocessor, IXSLProcessor_iface);
95}
96
98{
99 params->count--;
100 list_remove(&par->entry);
101 SysFreeString(par->name);
102 SysFreeString(par->value);
103 heap_free(par);
104}
105
107{
108 if (This->node) IXMLDOMNode_Release(This->node);
109 This->node = node;
110 if (node) IXMLDOMNode_AddRef(node);
111}
112
114 IXSLTemplate *iface,
115 REFIID riid,
116 void** ppvObject )
117{
119 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
120
121 if ( IsEqualGUID( riid, &IID_IXSLTemplate ) ||
124 {
125 *ppvObject = iface;
126 }
127 else if (dispex_query_interface(&This->dispex, riid, ppvObject))
128 {
129 return *ppvObject ? S_OK : E_NOINTERFACE;
130 }
131 else
132 {
133 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
134 *ppvObject = NULL;
135 return E_NOINTERFACE;
136 }
137
138 IUnknown_AddRef((IUnknown*)*ppvObject);
139 return S_OK;
140}
141
142static ULONG WINAPI xsltemplate_AddRef( IXSLTemplate *iface )
143{
146 TRACE("(%p)->(%d)\n", This, ref);
147 return ref;
148}
149
150static ULONG WINAPI xsltemplate_Release( IXSLTemplate *iface )
151{
154
155 TRACE("(%p)->(%d)\n", This, ref);
156 if ( ref == 0 )
157 {
158 if (This->node) IXMLDOMNode_Release( This->node );
159 heap_free( This );
160 }
161
162 return ref;
163}
164
165static HRESULT WINAPI xsltemplate_GetTypeInfoCount( IXSLTemplate *iface, UINT* pctinfo )
166{
168 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
169}
170
172 IXSLTemplate *iface,
173 UINT iTInfo, LCID lcid,
174 ITypeInfo** ppTInfo )
175{
177 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
178 iTInfo, lcid, ppTInfo);
179}
180
182 IXSLTemplate *iface,
183 REFIID riid, LPOLESTR* rgszNames,
184 UINT cNames, LCID lcid, DISPID* rgDispId )
185{
187 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
188 riid, rgszNames, cNames, lcid, rgDispId);
189}
190
192 IXSLTemplate *iface,
193 DISPID dispIdMember, REFIID riid, LCID lcid,
194 WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
195 EXCEPINFO* pExcepInfo, UINT* puArgErr )
196{
198 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
199 dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
200}
201
202static HRESULT WINAPI xsltemplate_putref_stylesheet( IXSLTemplate *iface,
204{
206
207 TRACE("(%p)->(%p)\n", This, node);
208
209 if (!node)
210 {
212 return S_OK;
213 }
214
215 /* FIXME: test for document type */
217
218 return S_OK;
219}
220
221static HRESULT WINAPI xsltemplate_get_stylesheet( IXSLTemplate *iface,
223{
225
226 FIXME("(%p)->(%p): stub\n", This, node);
227 return E_NOTIMPL;
228}
229
230static HRESULT WINAPI xsltemplate_createProcessor( IXSLTemplate *iface,
231 IXSLProcessor **processor)
232{
234
235 TRACE("(%p)->(%p)\n", This, processor);
236
237 if (!processor) return E_INVALIDARG;
238
239 return XSLProcessor_create(This, processor);
240}
241
242static const struct IXSLTemplateVtbl XSLTemplateVtbl =
243{
254};
255
258 0
259};
260
262 NULL,
264 NULL,
266};
267
269{
271
272 TRACE("(%p)\n", ppObj);
273
274 This = heap_alloc( sizeof (*This) );
275 if(!This)
276 return E_OUTOFMEMORY;
277
278 This->IXSLTemplate_iface.lpVtbl = &XSLTemplateVtbl;
279 This->ref = 1;
280 This->node = NULL;
281 init_dispex(&This->dispex, (IUnknown*)&This->IXSLTemplate_iface, &xsltemplate_dispex);
282
283 *ppObj = &This->IXSLTemplate_iface;
284
285 TRACE("returning iface %p\n", *ppObj);
286
287 return S_OK;
288}
289
290/*** IXSLProcessor ***/
292 IXSLProcessor *iface,
293 REFIID riid,
294 void** ppvObject )
295{
297 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
298
299 if ( IsEqualGUID( riid, &IID_IXSLProcessor ) ||
302 {
303 *ppvObject = iface;
304 }
305 else if (dispex_query_interface(&This->dispex, riid, ppvObject))
306 {
307 return *ppvObject ? S_OK : E_NOINTERFACE;
308 }
309 else
310 {
311 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
312 *ppvObject = NULL;
313 return E_NOINTERFACE;
314 }
315
316 IUnknown_AddRef((IUnknown*)*ppvObject);
317 return S_OK;
318}
319
320static ULONG WINAPI xslprocessor_AddRef( IXSLProcessor *iface )
321{
324 TRACE("(%p)->(%d)\n", This, ref);
325 return ref;
326}
327
328static ULONG WINAPI xslprocessor_Release( IXSLProcessor *iface )
329{
332
333 TRACE("(%p)->(%d)\n", This, ref);
334 if ( ref == 0 )
335 {
336 struct xslprocessor_par *par, *par2;
337
338 if (This->input) IXMLDOMNode_Release(This->input);
339 if (This->output.unk)
340 IUnknown_Release(This->output.unk);
341 SysFreeString(This->outstr);
342
343 LIST_FOR_EACH_ENTRY_SAFE(par, par2, &This->params.list, struct xslprocessor_par, entry)
344 xslprocessor_par_free(&This->params, par);
345
346 IXSLTemplate_Release(&This->stylesheet->IXSLTemplate_iface);
347 heap_free( This );
348 }
349
350 return ref;
351}
352
353static HRESULT WINAPI xslprocessor_GetTypeInfoCount( IXSLProcessor *iface, UINT* pctinfo )
354{
356 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
357}
358
360 IXSLProcessor *iface,
361 UINT iTInfo, LCID lcid,
362 ITypeInfo** ppTInfo )
363{
365 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
366 iTInfo, lcid, ppTInfo);
367}
368
370 IXSLProcessor *iface,
371 REFIID riid, LPOLESTR* rgszNames,
372 UINT cNames, LCID lcid, DISPID* rgDispId )
373{
375 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
376 riid, rgszNames, cNames, lcid, rgDispId);
377}
378
380 IXSLProcessor *iface,
381 DISPID dispIdMember, REFIID riid, LCID lcid,
382 WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
383 EXCEPINFO* pExcepInfo, UINT* puArgErr )
384{
386 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
387 dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
388}
389
390static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input )
391{
393 IXMLDOMNode *input_node;
394 HRESULT hr;
395
396 TRACE("(%p)->(%s)\n", This, debugstr_variant(&input));
397
398 /* try IXMLDOMNode directly first */
399 if (V_VT(&input) == VT_UNKNOWN)
400 hr = IUnknown_QueryInterface(V_UNKNOWN(&input), &IID_IXMLDOMNode, (void**)&input_node);
401 else if (V_VT(&input) == VT_DISPATCH)
402 hr = IDispatch_QueryInterface(V_DISPATCH(&input), &IID_IXMLDOMNode, (void**)&input_node);
403 else
404 {
405 IXMLDOMDocument *doc;
406
407 hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc);
408 if (hr == S_OK)
409 {
411
412 hr = IXMLDOMDocument_load(doc, input, &b);
413 if (hr == S_OK)
414 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&input_node);
415 IXMLDOMDocument_Release(doc);
416 }
417 }
418
419 if (hr == S_OK)
420 {
421 if (This->input) IXMLDOMNode_Release(This->input);
422 This->input = input_node;
423 }
424
425 return hr;
426}
427
428static HRESULT WINAPI xslprocessor_get_input( IXSLProcessor *iface, VARIANT *input )
429{
431
432 FIXME("(%p)->(%p): stub\n", This, input);
433 return E_NOTIMPL;
434}
435
437 IXSLProcessor *iface,
438 IXSLTemplate **template)
439{
441
442 FIXME("(%p)->(%p): stub\n", This, template);
443 return E_NOTIMPL;
444}
445
447 IXSLProcessor *iface,
448 BSTR p,
449 BSTR uri)
450{
452
453 FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(p), debugstr_w(uri));
454 return E_NOTIMPL;
455}
456
458 IXSLProcessor *iface,
459 BSTR *p)
460{
462
463 FIXME("(%p)->(%p): stub\n", This, p);
464 return E_NOTIMPL;
465}
466
468 IXSLProcessor *iface,
469 BSTR *uri)
470{
472
473 FIXME("(%p)->(%p): stub\n", This, uri);
474 return E_NOTIMPL;
475}
476
478 IXSLProcessor *iface,
479 VARIANT var)
480{
483 IUnknown *output = NULL;
484 HRESULT hr = S_OK;
485
486 TRACE("(%p)->(%s)\n", This, debugstr_variant(&var));
487
488 switch (V_VT(&var))
489 {
490 case VT_EMPTY:
491 break;
492 case VT_UNKNOWN:
493 case VT_DISPATCH:
494 if (!V_UNKNOWN(&var))
495 break;
496
498 hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IStream, (void **)&output);
499 if (FAILED(hr))
500 hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_ISequentialStream, (void **)&output);
501 if (FAILED(hr))
502 {
504 hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IResponse, (void **)&output);
505 }
506 if (FAILED(hr))
507 {
509 hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IPersistStream, (void **)&output);
510 }
511 if (FAILED(hr))
512 hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IPersistStreamInit, (void **)&output);
513 if (FAILED(hr))
514 {
516 WARN("failed to get output interface, 0x%08x\n", hr);
517 }
518 break;
519 default:
520 FIXME("output type %d not handled\n", V_VT(&var));
521 hr = E_FAIL;
522 }
523
524 if (hr == S_OK)
525 {
526 if (This->output.unk)
527 IUnknown_Release(This->output.unk);
528 This->output.unk = output;
529 This->output_type = output_type;
530 }
531
532 return hr;
533}
534
536 IXSLProcessor *iface,
537 VARIANT *output)
538{
540
541 TRACE("(%p)->(%p)\n", This, output);
542
543 if (!output) return E_INVALIDARG;
544
545 if (This->output.unk)
546 {
547 V_VT(output) = VT_UNKNOWN;
548 V_UNKNOWN(output) = This->output.unk;
549 IUnknown_AddRef(This->output.unk);
550 }
551 else if (This->outstr)
552 {
553 V_VT(output) = VT_BSTR;
554 V_BSTR(output) = SysAllocString(This->outstr);
555 }
556 else
557 V_VT(output) = VT_EMPTY;
558
559 return S_OK;
560}
561
563 IXSLProcessor *iface,
565{
566#ifdef HAVE_LIBXML2
569 HRESULT hr;
570
571 TRACE("(%p)->(%p)\n", This, ret);
572
573 if (!ret)
574 return E_INVALIDARG;
575
576 if (This->output_type == PROCESSOR_OUTPUT_STREAM)
577 {
578 stream = This->output.stream;
579 ISequentialStream_AddRef(stream);
580 }
581 else if (This->output_type == PROCESSOR_OUTPUT_PERSISTSTREAM ||
582 This->output_type == PROCESSOR_OUTPUT_RESPONSE)
583 {
585 return hr;
586 }
587
588 SysFreeString(This->outstr);
589
590 hr = node_transform_node_params(get_node_obj(This->input), This->stylesheet->node,
591 &This->outstr, stream, &This->params);
592 if (SUCCEEDED(hr))
593 {
595
596 switch (This->output_type)
597 {
599 {
601
602 /* for IPersistStream* output seekable stream is used */
603 zero.QuadPart = 0;
604 IStream_Seek(src, zero, STREAM_SEEK_SET, NULL);
605 hr = IPersistStream_Load(This->output.persiststream, src);
606 break;
607 }
609 {
610 SAFEARRAYBOUND bound;
612 HGLOBAL hglobal;
613 VARIANT bin;
614 DWORD size;
615 void *dest;
616
617 if (FAILED(hr = GetHGlobalFromStream(src, &hglobal)))
618 break;
619 size = GlobalSize(hglobal);
620
621 bound.lLbound = 0;
622 bound.cElements = size;
623 if (!(array = SafeArrayCreate(VT_UI1, 1, &bound)))
624 break;
625
626 V_VT(&bin) = VT_ARRAY | VT_UI1;
627 V_ARRAY(&bin) = array;
628
630 if (hr == S_OK)
631 {
632 void *data = GlobalLock(hglobal);
633 memcpy(dest, data, size);
634 GlobalUnlock(hglobal);
636
637 IResponse_BinaryWrite(This->output.response, bin);
638 }
639
641 break;
642 }
643 default:
644 ;
645 }
646 }
647
648 if (stream)
649 ISequentialStream_Release(stream);
650
651 *ret = hr == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
652 return hr;
653#else
654 FIXME("libxml2 is required but wasn't present at compile time\n");
655 return E_NOTIMPL;
656#endif
657}
658
659static HRESULT WINAPI xslprocessor_reset( IXSLProcessor *iface )
660{
662
663 FIXME("(%p): stub\n", This);
664 return E_NOTIMPL;
665}
666
668 IXSLProcessor *iface,
669 LONG *state)
670{
672
673 FIXME("(%p)->(%p): stub\n", This, state);
674 return E_NOTIMPL;
675}
676
678{
679 HRESULT hr = S_OK;
680
681 switch (V_VT(var))
682 {
683 case VT_BSTR:
684 {
686 if (!par->value) hr = E_OUTOFMEMORY;
687 break;
688 }
689 default:
690 FIXME("value type %d not handled\n", V_VT(var));
691 hr = E_NOTIMPL;
692 }
693
694 return hr;
695}
696
698 IXSLProcessor *iface,
699 BSTR p,
700 VARIANT var,
701 BSTR uri)
702{
704 struct xslprocessor_par *cur, *par = NULL;
705 HRESULT hr;
706
707 TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(p), debugstr_variant(&var),
708 debugstr_w(uri));
709
710 if (uri && *uri)
711 FIXME("namespace uri is not supported\n");
712
713 /* search for existing parameter first */
714 LIST_FOR_EACH_ENTRY(cur, &This->params.list, struct xslprocessor_par, entry)
715 {
716 if (!strcmpW(cur->name, p))
717 {
718 par = cur;
719 break;
720 }
721 }
722
723 /* override with new value or add new parameter */
724 if (par)
725 {
726 if (V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY)
727 {
728 /* remove parameter */
729 xslprocessor_par_free(&This->params, par);
730 return S_OK;
731 }
732 SysFreeString(par->value);
733 par->value = NULL;
734 }
735 else
736 {
737 /* new parameter */
738 par = heap_alloc(sizeof(struct xslprocessor_par));
739 if (!par) return E_OUTOFMEMORY;
740
741 par->name = SysAllocString(p);
742 if (!par->name)
743 {
744 heap_free(par);
745 return E_OUTOFMEMORY;
746 }
747 list_add_tail(&This->params.list, &par->entry);
748 This->params.count++;
749 }
750
752 if (FAILED(hr))
753 xslprocessor_par_free(&This->params, par);
754
755 return hr;
756}
757
759 IXSLProcessor *iface,
760 IDispatch *obj,
761 BSTR uri)
762{
764
765 FIXME("(%p)->(%p %s): stub\n", This, obj, debugstr_w(uri));
766 return E_NOTIMPL;
767}
768
770 IXSLProcessor *iface,
772{
774
775 FIXME("(%p)->(%p): stub\n", This, node);
776 return E_NOTIMPL;
777}
778
779static const struct IXSLProcessorVtbl XSLProcessorVtbl =
780{
802};
803
806 0
807};
808
810 NULL,
812 NULL,
814};
815
816HRESULT XSLProcessor_create(xsltemplate *template, IXSLProcessor **ppObj)
817{
819
820 TRACE("(%p)\n", ppObj);
821
822 This = heap_alloc( sizeof (*This) );
823 if(!This)
824 return E_OUTOFMEMORY;
825
826 This->IXSLProcessor_iface.lpVtbl = &XSLProcessorVtbl;
827 This->ref = 1;
828 This->input = NULL;
829 This->output.unk = NULL;
830 This->output_type = PROCESSOR_OUTPUT_NOT_SET;
831 This->outstr = NULL;
832 list_init(&This->params.list);
833 This->params.count = 0;
834 This->stylesheet = template;
835 IXSLTemplate_AddRef(&template->IXSLTemplate_iface);
836 init_dispex(&This->dispex, (IUnknown*)&This->IXSLProcessor_iface, &xslprocessor_dispex);
837
838 *ppObj = &This->IXSLProcessor_iface;
839
840 TRACE("returning iface %p\n", *ppObj);
841
842 return S_OK;
843}
static int state
Definition: maze.c:121
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static void list_init(struct list_entry *head)
Definition: list.h:51
const GUID IID_IUnknown
#define FIXME(fmt,...)
Definition: debug.h:114
#define WARN(fmt,...)
Definition: debug.h:115
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
OLECHAR * BSTR
Definition: compat.h:2293
short VARIANT_BOOL
Definition: compat.h:2290
@ VT_BSTR
Definition: compat.h:2303
@ VT_NULL
Definition: compat.h:2296
@ VT_UNKNOWN
Definition: compat.h:2308
@ VT_ARRAY
Definition: compat.h:2341
@ VT_EMPTY
Definition: compat.h:2295
@ VT_DISPATCH
Definition: compat.h:2304
@ VT_UI1
Definition: compat.h:2311
const UINT template
Definition: action.c:7481
HRESULT DOMDocument_create(MSXML_VERSION version, void **ppObj)
Definition: domdoc.c:3727
HRESULT WINAPI GetHGlobalFromStream(IStream *pstm, HGLOBAL *phglobal)
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
Definition: safearray.c:600
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
FxCollectionEntry * cur
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLenum src
Definition: glext.h:6340
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLenum const GLfloat * params
Definition: glext.h:5645
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLenum GLenum input
Definition: glext.h:9031
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
SIZE_T NTAPI GlobalSize(HGLOBAL hMem)
Definition: heapmem.c:1090
static HTMLDOMNode * get_node_obj(IHTMLDOMNode *)
Definition: htmlnode.c:1045
tid_t
Definition: ieframe.h:311
REFIID riid
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
uint32_t entry
Definition: isohybrid.c:63
HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype)
Definition: dispex.c:919
#define b
Definition: ke_i.h:79
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
const char * var
Definition: shader.c:5666
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
static struct _PeImage bin
static char * dest
Definition: rtl.c:135
static LPOLESTR
Definition: stg_prop.c:27
static VARIANTARG static DISPID
Definition: ordinal.c:52
const char * uri
Definition: sec_mgr.c:1588
BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
Definition: dispex.c:1656
@ MSXML_DEFAULT
Definition: msxml_private.h:35
@ IXSLProcessor_tid
Definition: msxml_private.h:69
@ IXSLTemplate_tid
Definition: msxml_private.h:70
unsigned int UINT
Definition: ndis.h:50
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_UNKNOWN(A)
Definition: oleauto.h:281
#define V_VT(A)
Definition: oleauto.h:211
#define V_BSTR(A)
Definition: oleauto.h:226
#define V_DISPATCH(A)
Definition: oleauto.h:239
const GUID IID_IDispatch
const GUID IID_IPersistStreamInit
long LONG
Definition: pedump.c:60
const GUID IID_IPersistStream
Definition: proxy.cpp:13
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define REFIID
Definition: guiddef.h:118
#define strcmpW(s1, s2)
Definition: unicode.h:44
DWORD LCID
Definition: nls.h:13
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
int zero
Definition: sehframes.cpp:29
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
Definition: send.c:48
Definition: parse.h:23
struct list entry
ISequentialStream * stream
Definition: stylesheet.c:75
IResponse * response
Definition: stylesheet.c:77
IPersistStream * persiststream
Definition: stylesheet.c:76
xsltemplate * stylesheet
Definition: stylesheet.c:69
enum output_type output_type
Definition: stylesheet.c:79
IUnknown * unk
Definition: stylesheet.c:74
IXSLProcessor IXSLProcessor_iface
Definition: stylesheet.c:66
IXMLDOMNode * input
Definition: stylesheet.c:70
DispatchEx dispex
Definition: stylesheet.c:65
IXMLDOMNode * node
Definition: stylesheet.c:52
DispatchEx dispex
Definition: stylesheet.c:48
IXSLTemplate IXSLTemplate_iface
Definition: stylesheet.c:49
static const tid_t xslprocessor_iface_tids[]
Definition: stylesheet.c:804
static HRESULT xslprocessor_set_parvalue(const VARIANT *var, struct xslprocessor_par *par)
Definition: stylesheet.c:677
static ULONG WINAPI xslprocessor_Release(IXSLProcessor *iface)
Definition: stylesheet.c:328
static HRESULT WINAPI xslprocessor_setStartMode(IXSLProcessor *iface, BSTR p, BSTR uri)
Definition: stylesheet.c:446
static HRESULT XSLProcessor_create(xsltemplate *, IXSLProcessor **)
Definition: stylesheet.c:816
static dispex_static_data_t xslprocessor_dispex
Definition: stylesheet.c:809
static HRESULT WINAPI xslprocessor_QueryInterface(IXSLProcessor *iface, REFIID riid, void **ppvObject)
Definition: stylesheet.c:291
static HRESULT WINAPI xslprocessor_get_readyState(IXSLProcessor *iface, LONG *state)
Definition: stylesheet.c:667
static HRESULT WINAPI xslprocessor_put_input(IXSLProcessor *iface, VARIANT input)
Definition: stylesheet.c:390
static ULONG WINAPI xslprocessor_AddRef(IXSLProcessor *iface)
Definition: stylesheet.c:320
static HRESULT WINAPI xslprocessor_transform(IXSLProcessor *iface, VARIANT_BOOL *ret)
Definition: stylesheet.c:562
static void xsltemplate_set_node(xsltemplate *This, IXMLDOMNode *node)
Definition: stylesheet.c:106
static HRESULT WINAPI xslprocessor_reset(IXSLProcessor *iface)
Definition: stylesheet.c:659
static HRESULT WINAPI xsltemplate_Invoke(IXSLTemplate *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: stylesheet.c:191
static HRESULT WINAPI xslprocessor_put_output(IXSLProcessor *iface, VARIANT var)
Definition: stylesheet.c:477
static HRESULT WINAPI xsltemplate_QueryInterface(IXSLTemplate *iface, REFIID riid, void **ppvObject)
Definition: stylesheet.c:113
output_type
Definition: stylesheet.c:56
@ PROCESSOR_OUTPUT_NOT_SET
Definition: stylesheet.c:57
@ PROCESSOR_OUTPUT_RESPONSE
Definition: stylesheet.c:60
@ PROCESSOR_OUTPUT_PERSISTSTREAM
Definition: stylesheet.c:59
@ PROCESSOR_OUTPUT_STREAM
Definition: stylesheet.c:58
static HRESULT WINAPI xslprocessor_addObject(IXSLProcessor *iface, IDispatch *obj, BSTR uri)
Definition: stylesheet.c:758
static void xslprocessor_par_free(struct xslprocessor_params *params, struct xslprocessor_par *par)
Definition: stylesheet.c:97
static HRESULT WINAPI xslprocessor_get_stylesheet(IXSLProcessor *iface, IXMLDOMNode **node)
Definition: stylesheet.c:769
static HRESULT WINAPI xsltemplate_GetIDsOfNames(IXSLTemplate *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: stylesheet.c:181
static HRESULT WINAPI xslprocessor_get_startModeURI(IXSLProcessor *iface, BSTR *uri)
Definition: stylesheet.c:467
static HRESULT WINAPI xslprocessor_GetIDsOfNames(IXSLProcessor *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: stylesheet.c:369
static HRESULT WINAPI xsltemplate_createProcessor(IXSLTemplate *iface, IXSLProcessor **processor)
Definition: stylesheet.c:230
static HRESULT WINAPI xslprocessor_get_input(IXSLProcessor *iface, VARIANT *input)
Definition: stylesheet.c:428
static xsltemplate * impl_from_IXSLTemplate(IXSLTemplate *iface)
Definition: stylesheet.c:87
static const struct IXSLProcessorVtbl XSLProcessorVtbl
Definition: stylesheet.c:779
static HRESULT WINAPI xsltemplate_GetTypeInfoCount(IXSLTemplate *iface, UINT *pctinfo)
Definition: stylesheet.c:165
HRESULT XSLTemplate_create(void **ppObj)
Definition: stylesheet.c:268
static dispex_static_data_t xsltemplate_dispex
Definition: stylesheet.c:261
static HRESULT WINAPI xslprocessor_GetTypeInfoCount(IXSLProcessor *iface, UINT *pctinfo)
Definition: stylesheet.c:353
static HRESULT WINAPI xslprocessor_GetTypeInfo(IXSLProcessor *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: stylesheet.c:359
static xslprocessor * impl_from_IXSLProcessor(IXSLProcessor *iface)
Definition: stylesheet.c:92
static HRESULT WINAPI xsltemplate_GetTypeInfo(IXSLTemplate *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: stylesheet.c:171
static HRESULT WINAPI xslprocessor_get_ownerTemplate(IXSLProcessor *iface, IXSLTemplate **template)
Definition: stylesheet.c:436
static HRESULT WINAPI xslprocessor_addParameter(IXSLProcessor *iface, BSTR p, VARIANT var, BSTR uri)
Definition: stylesheet.c:697
static HRESULT WINAPI xsltemplate_putref_stylesheet(IXSLTemplate *iface, IXMLDOMNode *node)
Definition: stylesheet.c:202
static const struct IXSLTemplateVtbl XSLTemplateVtbl
Definition: stylesheet.c:242
static ULONG WINAPI xsltemplate_AddRef(IXSLTemplate *iface)
Definition: stylesheet.c:142
static HRESULT WINAPI xslprocessor_Invoke(IXSLProcessor *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: stylesheet.c:379
static HRESULT WINAPI xsltemplate_get_stylesheet(IXSLTemplate *iface, IXMLDOMNode **node)
Definition: stylesheet.c:221
static const tid_t xsltemplate_iface_tids[]
Definition: stylesheet.c:256
static HRESULT WINAPI xslprocessor_get_output(IXSLProcessor *iface, VARIANT *output)
Definition: stylesheet.c:535
static HRESULT WINAPI xslprocessor_get_startMode(IXSLProcessor *iface, BSTR *p)
Definition: stylesheet.c:457
static ULONG WINAPI xsltemplate_Release(IXSLTemplate *iface)
Definition: stylesheet.c:150
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
Definition: dlist.c:348
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
int ret
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364