xref: /reactos/dll/win32/msxml3/stylesheet.c (revision bae2bac6) 
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 
44 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
45 
46 typedef struct
47 {
48     DispatchEx dispex;
49     IXSLTemplate IXSLTemplate_iface;
50     LONG ref;
51 
52     IXMLDOMNode *node;
53 } xsltemplate;
54 
55 enum output_type
56 {
57     PROCESSOR_OUTPUT_NOT_SET,
58     PROCESSOR_OUTPUT_STREAM,        /* IStream or ISequentialStream */
59     PROCESSOR_OUTPUT_PERSISTSTREAM, /* IPersistStream or IPersistStreamInit */
60     PROCESSOR_OUTPUT_RESPONSE,      /* IResponse */
61 };
62 
63 typedef struct
64 {
65     DispatchEx dispex;
66     IXSLProcessor IXSLProcessor_iface;
67     LONG ref;
68 
69     xsltemplate *stylesheet;
70     IXMLDOMNode *input;
71 
72     union
73     {
74         IUnknown *unk;
75         ISequentialStream *stream;
76         IPersistStream *persiststream;
77         IResponse *response;
78     } output;
79     enum output_type output_type;
80     BSTR outstr;
81 
82     struct xslprocessor_params params;
83 } xslprocessor;
84 
85 static HRESULT XSLProcessor_create(xsltemplate*, IXSLProcessor**);
86 
87 static inline xsltemplate *impl_from_IXSLTemplate( IXSLTemplate *iface )
88 {
89     return CONTAINING_RECORD(iface, xsltemplate, IXSLTemplate_iface);
90 }
91 
92 static inline xslprocessor *impl_from_IXSLProcessor( IXSLProcessor *iface )
93 {
94     return CONTAINING_RECORD(iface, xslprocessor, IXSLProcessor_iface);
95 }
96 
97 static void xslprocessor_par_free(struct xslprocessor_params *params, struct xslprocessor_par *par)
98 {
99     params->count--;
100     list_remove(&par->entry);
101     SysFreeString(par->name);
102     SysFreeString(par->value);
103     heap_free(par);
104 }
105 
106 static void xsltemplate_set_node( xsltemplate *This, IXMLDOMNode *node )
107 {
108     if (This->node) IXMLDOMNode_Release(This->node);
109     This->node = node;
110     if (node) IXMLDOMNode_AddRef(node);
111 }
112 
113 static HRESULT WINAPI xsltemplate_QueryInterface(
114     IXSLTemplate *iface,
115     REFIID riid,
116     void** ppvObject )
117 {
118     xsltemplate *This = impl_from_IXSLTemplate( iface );
119     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
120 
121     if ( IsEqualGUID( riid, &IID_IXSLTemplate ) ||
122          IsEqualGUID( riid, &IID_IDispatch ) ||
123          IsEqualGUID( riid, &IID_IUnknown ) )
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 
142 static ULONG WINAPI xsltemplate_AddRef( IXSLTemplate *iface )
143 {
144     xsltemplate *This = impl_from_IXSLTemplate( iface );
145     ULONG ref = InterlockedIncrement( &This->ref );
146     TRACE("(%p)->(%d)\n", This, ref);
147     return ref;
148 }
149 
150 static ULONG WINAPI xsltemplate_Release( IXSLTemplate *iface )
151 {
152     xsltemplate *This = impl_from_IXSLTemplate( iface );
153     ULONG ref = InterlockedDecrement( &This->ref );
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 
165 static HRESULT WINAPI xsltemplate_GetTypeInfoCount( IXSLTemplate *iface, UINT* pctinfo )
166 {
167     xsltemplate *This = impl_from_IXSLTemplate( iface );
168     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
169 }
170 
171 static HRESULT WINAPI xsltemplate_GetTypeInfo(
172     IXSLTemplate *iface,
173     UINT iTInfo, LCID lcid,
174     ITypeInfo** ppTInfo )
175 {
176     xsltemplate *This = impl_from_IXSLTemplate( iface );
177     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
178         iTInfo, lcid, ppTInfo);
179 }
180 
181 static HRESULT WINAPI xsltemplate_GetIDsOfNames(
182     IXSLTemplate *iface,
183     REFIID riid, LPOLESTR* rgszNames,
184     UINT cNames, LCID lcid, DISPID* rgDispId )
185 {
186     xsltemplate *This = impl_from_IXSLTemplate( iface );
187     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
188         riid, rgszNames, cNames, lcid, rgDispId);
189 }
190 
191 static HRESULT WINAPI xsltemplate_Invoke(
192     IXSLTemplate *iface,
193     DISPID dispIdMember, REFIID riid, LCID lcid,
194     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
195     EXCEPINFO* pExcepInfo, UINT* puArgErr )
196 {
197     xsltemplate *This = impl_from_IXSLTemplate( iface );
198     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
199         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
200 }
201 
202 static HRESULT WINAPI xsltemplate_putref_stylesheet( IXSLTemplate *iface,
203     IXMLDOMNode *node)
204 {
205     xsltemplate *This = impl_from_IXSLTemplate( iface );
206 
207     TRACE("(%p)->(%p)\n", This, node);
208 
209     if (!node)
210     {
211         xsltemplate_set_node(This, NULL);
212         return S_OK;
213     }
214 
215     /* FIXME: test for document type */
216     xsltemplate_set_node(This, node);
217 
218     return S_OK;
219 }
220 
221 static HRESULT WINAPI xsltemplate_get_stylesheet( IXSLTemplate *iface,
222     IXMLDOMNode **node)
223 {
224     xsltemplate *This = impl_from_IXSLTemplate( iface );
225 
226     FIXME("(%p)->(%p): stub\n", This, node);
227     return E_NOTIMPL;
228 }
229 
230 static HRESULT WINAPI xsltemplate_createProcessor( IXSLTemplate *iface,
231     IXSLProcessor **processor)
232 {
233     xsltemplate *This = impl_from_IXSLTemplate( iface );
234 
235     TRACE("(%p)->(%p)\n", This, processor);
236 
237     if (!processor) return E_INVALIDARG;
238 
239     return XSLProcessor_create(This, processor);
240 }
241 
242 static const struct IXSLTemplateVtbl XSLTemplateVtbl =
243 {
244     xsltemplate_QueryInterface,
245     xsltemplate_AddRef,
246     xsltemplate_Release,
247     xsltemplate_GetTypeInfoCount,
248     xsltemplate_GetTypeInfo,
249     xsltemplate_GetIDsOfNames,
250     xsltemplate_Invoke,
251     xsltemplate_putref_stylesheet,
252     xsltemplate_get_stylesheet,
253     xsltemplate_createProcessor
254 };
255 
256 static const tid_t xsltemplate_iface_tids[] = {
257     IXSLTemplate_tid,
258     0
259 };
260 
261 static dispex_static_data_t xsltemplate_dispex = {
262     NULL,
263     IXSLTemplate_tid,
264     NULL,
265     xsltemplate_iface_tids
266 };
267 
268 HRESULT XSLTemplate_create(void **ppObj)
269 {
270     xsltemplate *This;
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 ***/
291 static HRESULT WINAPI xslprocessor_QueryInterface(
292     IXSLProcessor *iface,
293     REFIID riid,
294     void** ppvObject )
295 {
296     xslprocessor *This = impl_from_IXSLProcessor( iface );
297     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
298 
299     if ( IsEqualGUID( riid, &IID_IXSLProcessor ) ||
300          IsEqualGUID( riid, &IID_IDispatch ) ||
301          IsEqualGUID( riid, &IID_IUnknown ) )
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 
320 static ULONG WINAPI xslprocessor_AddRef( IXSLProcessor *iface )
321 {
322     xslprocessor *This = impl_from_IXSLProcessor( iface );
323     ULONG ref = InterlockedIncrement( &This->ref );
324     TRACE("(%p)->(%d)\n", This, ref);
325     return ref;
326 }
327 
328 static ULONG WINAPI xslprocessor_Release( IXSLProcessor *iface )
329 {
330     xslprocessor *This = impl_from_IXSLProcessor( iface );
331     ULONG ref = InterlockedDecrement( &This->ref );
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 
353 static HRESULT WINAPI xslprocessor_GetTypeInfoCount( IXSLProcessor *iface, UINT* pctinfo )
354 {
355     xslprocessor *This = impl_from_IXSLProcessor( iface );
356     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
357 }
358 
359 static HRESULT WINAPI xslprocessor_GetTypeInfo(
360     IXSLProcessor *iface,
361     UINT iTInfo, LCID lcid,
362     ITypeInfo** ppTInfo )
363 {
364     xslprocessor *This = impl_from_IXSLProcessor( iface );
365     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
366         iTInfo, lcid, ppTInfo);
367 }
368 
369 static HRESULT WINAPI xslprocessor_GetIDsOfNames(
370     IXSLProcessor *iface,
371     REFIID riid, LPOLESTR* rgszNames,
372     UINT cNames, LCID lcid, DISPID* rgDispId )
373 {
374     xslprocessor *This = impl_from_IXSLProcessor( iface );
375     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
376         riid, rgszNames, cNames, lcid, rgDispId);
377 }
378 
379 static HRESULT WINAPI xslprocessor_Invoke(
380     IXSLProcessor *iface,
381     DISPID dispIdMember, REFIID riid, LCID lcid,
382     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
383     EXCEPINFO* pExcepInfo, UINT* puArgErr )
384 {
385     xslprocessor *This = impl_from_IXSLProcessor( iface );
386     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
387         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
388 }
389 
390 static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input )
391 {
392     xslprocessor *This = impl_from_IXSLProcessor( iface );
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         {
410             VARIANT_BOOL b;
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 
428 static HRESULT WINAPI xslprocessor_get_input( IXSLProcessor *iface, VARIANT *input )
429 {
430     xslprocessor *This = impl_from_IXSLProcessor( iface );
431 
432     FIXME("(%p)->(%p): stub\n", This, input);
433     return E_NOTIMPL;
434 }
435 
436 static HRESULT WINAPI xslprocessor_get_ownerTemplate(
437     IXSLProcessor *iface,
438     IXSLTemplate **template)
439 {
440     xslprocessor *This = impl_from_IXSLProcessor( iface );
441 
442     FIXME("(%p)->(%p): stub\n", This, template);
443     return E_NOTIMPL;
444 }
445 
446 static HRESULT WINAPI xslprocessor_setStartMode(
447     IXSLProcessor *iface,
448     BSTR p,
449     BSTR uri)
450 {
451     xslprocessor *This = impl_from_IXSLProcessor( iface );
452 
453     FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(p), debugstr_w(uri));
454     return E_NOTIMPL;
455 }
456 
457 static HRESULT WINAPI xslprocessor_get_startMode(
458     IXSLProcessor *iface,
459     BSTR *p)
460 {
461     xslprocessor *This = impl_from_IXSLProcessor( iface );
462 
463     FIXME("(%p)->(%p): stub\n", This, p);
464     return E_NOTIMPL;
465 }
466 
467 static HRESULT WINAPI xslprocessor_get_startModeURI(
468     IXSLProcessor *iface,
469     BSTR *uri)
470 {
471     xslprocessor *This = impl_from_IXSLProcessor( iface );
472 
473     FIXME("(%p)->(%p): stub\n", This, uri);
474     return E_NOTIMPL;
475 }
476 
477 static HRESULT WINAPI xslprocessor_put_output(
478     IXSLProcessor *iface,
479     VARIANT var)
480 {
481     xslprocessor *This = impl_from_IXSLProcessor( iface );
482     enum output_type output_type = PROCESSOR_OUTPUT_NOT_SET;
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 
497         output_type = PROCESSOR_OUTPUT_STREAM;
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         {
503             output_type = PROCESSOR_OUTPUT_RESPONSE;
504             hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IResponse, (void **)&output);
505         }
506         if (FAILED(hr))
507         {
508             output_type = PROCESSOR_OUTPUT_PERSISTSTREAM;
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         {
515             output_type = PROCESSOR_OUTPUT_NOT_SET;
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 
535 static HRESULT WINAPI xslprocessor_get_output(
536     IXSLProcessor *iface,
537     VARIANT *output)
538 {
539     xslprocessor *This = impl_from_IXSLProcessor( iface );
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 
562 static HRESULT WINAPI xslprocessor_transform(
563     IXSLProcessor *iface,
564     VARIANT_BOOL  *ret)
565 {
566 #ifdef HAVE_LIBXML2
567     xslprocessor *This = impl_from_IXSLProcessor( iface );
568     ISequentialStream *stream = NULL;
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     {
584         if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, (IStream **)&stream)))
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     {
594         IStream *src = (IStream *)stream;
595 
596         switch (This->output_type)
597         {
598         case PROCESSOR_OUTPUT_PERSISTSTREAM:
599         {
600             LARGE_INTEGER zero;
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         }
608         case PROCESSOR_OUTPUT_RESPONSE:
609         {
610             SAFEARRAYBOUND bound;
611             SAFEARRAY *array;
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 
629             hr = SafeArrayAccessData(array, &dest);
630             if (hr == S_OK)
631             {
632                 void *data = GlobalLock(hglobal);
633                 memcpy(dest, data, size);
634                 GlobalUnlock(hglobal);
635                 SafeArrayUnaccessData(array);
636 
637                 IResponse_BinaryWrite(This->output.response, bin);
638             }
639 
640             VariantClear(&bin);
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 
659 static HRESULT WINAPI xslprocessor_reset( IXSLProcessor *iface )
660 {
661     xslprocessor *This = impl_from_IXSLProcessor( iface );
662 
663     FIXME("(%p): stub\n", This);
664     return E_NOTIMPL;
665 }
666 
667 static HRESULT WINAPI xslprocessor_get_readyState(
668     IXSLProcessor *iface,
669     LONG *state)
670 {
671     xslprocessor *This = impl_from_IXSLProcessor( iface );
672 
673     FIXME("(%p)->(%p): stub\n", This, state);
674     return E_NOTIMPL;
675 }
676 
677 static HRESULT xslprocessor_set_parvalue(const VARIANT *var, struct xslprocessor_par *par)
678 {
679     HRESULT hr = S_OK;
680 
681     switch (V_VT(var))
682     {
683     case VT_BSTR:
684     {
685         par->value = SysAllocString(V_BSTR(var));
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 
697 static HRESULT WINAPI xslprocessor_addParameter(
698     IXSLProcessor *iface,
699     BSTR p,
700     VARIANT var,
701     BSTR uri)
702 {
703     xslprocessor *This = impl_from_IXSLProcessor( iface );
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 
751     hr = xslprocessor_set_parvalue(&var, par);
752     if (FAILED(hr))
753         xslprocessor_par_free(&This->params, par);
754 
755     return hr;
756 }
757 
758 static HRESULT WINAPI xslprocessor_addObject(
759     IXSLProcessor *iface,
760     IDispatch *obj,
761     BSTR uri)
762 {
763     xslprocessor *This = impl_from_IXSLProcessor( iface );
764 
765     FIXME("(%p)->(%p %s): stub\n", This, obj, debugstr_w(uri));
766     return E_NOTIMPL;
767 }
768 
769 static HRESULT WINAPI xslprocessor_get_stylesheet(
770     IXSLProcessor *iface,
771     IXMLDOMNode  **node)
772 {
773     xslprocessor *This = impl_from_IXSLProcessor( iface );
774 
775     FIXME("(%p)->(%p): stub\n", This, node);
776     return E_NOTIMPL;
777 }
778 
779 static const struct IXSLProcessorVtbl XSLProcessorVtbl =
780 {
781     xslprocessor_QueryInterface,
782     xslprocessor_AddRef,
783     xslprocessor_Release,
784     xslprocessor_GetTypeInfoCount,
785     xslprocessor_GetTypeInfo,
786     xslprocessor_GetIDsOfNames,
787     xslprocessor_Invoke,
788     xslprocessor_put_input,
789     xslprocessor_get_input,
790     xslprocessor_get_ownerTemplate,
791     xslprocessor_setStartMode,
792     xslprocessor_get_startMode,
793     xslprocessor_get_startModeURI,
794     xslprocessor_put_output,
795     xslprocessor_get_output,
796     xslprocessor_transform,
797     xslprocessor_reset,
798     xslprocessor_get_readyState,
799     xslprocessor_addParameter,
800     xslprocessor_addObject,
801     xslprocessor_get_stylesheet
802 };
803 
804 static const tid_t xslprocessor_iface_tids[] = {
805     IXSLProcessor_tid,
806     0
807 };
808 
809 static dispex_static_data_t xslprocessor_dispex = {
810     NULL,
811     IXSLProcessor_tid,
812     NULL,
813     xslprocessor_iface_tids
814 };
815 
816 HRESULT XSLProcessor_create(xsltemplate *template, IXSLProcessor **ppObj)
817 {
818     xslprocessor *This;
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 }
844