dlls/msxml3/stylesheet.c

   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 <stdarg.h>
  24 #include <libxml/parser.h>
  25 #include <libxml/xmlerror.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "msxml6.h"
  32
  33 #include "msxml_private.h"
  34
  35 #include "initguid.h"
  36 #include "asptlb.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  41
  42 typedef struct
  43 {
  44     DispatchEx dispex;
  45     IXSLTemplate IXSLTemplate_iface;
  46     LONG ref;
  47
  48     IXMLDOMNode *node;
  49 } xsltemplate;
  50
  51 enum output_type
  52 {
  53     PROCESSOR_OUTPUT_NOT_SET,
  54     PROCESSOR_OUTPUT_STREAM,        /* IStream or ISequentialStream */
  55     PROCESSOR_OUTPUT_PERSISTSTREAM, /* IPersistStream or IPersistStreamInit */
  56     PROCESSOR_OUTPUT_RESPONSE,      /* IResponse */
  57 };
  58
  59 typedef struct
  60 {
  61     DispatchEx dispex;
  62     IXSLProcessor IXSLProcessor_iface;
  63     LONG ref;
  64
  65     xsltemplate *stylesheet;
  66     IXMLDOMNode *input;
  67
  68     union
  69     {
  70         IUnknown *unk;
  71         ISequentialStream *stream;
  72         IPersistStream *persiststream;
  73         IResponse *response;
  74     } output;
  75     enum output_type output_type;
  76     BSTR outstr;
  77
  78     struct xslprocessor_params params;
  79 } xslprocessor;
  80
  81 static HRESULT XSLProcessor_create(xsltemplate*, IXSLProcessor**);
  82
  83 static inline xsltemplate *impl_from_IXSLTemplate( IXSLTemplate *iface )
  84 {
  85     return CONTAINING_RECORD(iface, xsltemplate, IXSLTemplate_iface);
  86 }
  87
  88 static inline xslprocessor *impl_from_IXSLProcessor( IXSLProcessor *iface )
  89 {
  90     return CONTAINING_RECORD(iface, xslprocessor, IXSLProcessor_iface);
  91 }
  92
  93 static void xslprocessor_par_free(struct xslprocessor_params *params, struct xslprocessor_par *par)
  94 {
  95     params->count--;
  96     list_remove(&par->entry);
  97     SysFreeString(par->name);
  98     SysFreeString(par->value);
  99     heap_free(par);
 100 }
 101
 102 static void xsltemplate_set_node( xsltemplate *This, IXMLDOMNode *node )
 103 {
 104     if (This->node) IXMLDOMNode_Release(This->node);
 105     This->node = node;
 106     if (node) IXMLDOMNode_AddRef(node);
 107 }
 108
 109 static HRESULT WINAPI xsltemplate_QueryInterface(
 110     IXSLTemplate *iface,
 111     REFIID riid,
 112     void** ppvObject )
 113 {
 114     xsltemplate *This = impl_from_IXSLTemplate( iface );
 115     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 116
 117     if ( IsEqualGUID( riid, &IID_IXSLTemplate ) ||
 118          IsEqualGUID( riid, &IID_IDispatch ) ||
 119          IsEqualGUID( riid, &IID_IUnknown ) )
 120     {
 121         *ppvObject = iface;
 122     }
 123     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
 124     {
 125         return *ppvObject ? S_OK : E_NOINTERFACE;
 126     }
 127     else
 128     {
 129         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 130         *ppvObject = NULL;
 131         return E_NOINTERFACE;
 132     }
 133
 134     IUnknown_AddRef((IUnknown*)*ppvObject);
 135     return S_OK;
 136 }
 137
 138 static ULONG WINAPI xsltemplate_AddRef( IXSLTemplate *iface )
 139 {
 140     xsltemplate *This = impl_from_IXSLTemplate( iface );
 141     ULONG ref = InterlockedIncrement( &This->ref );
 142     TRACE("%p, refcount %lu.\n", iface, ref);
 143     return ref;
 144 }
 145
 146 static ULONG WINAPI xsltemplate_Release( IXSLTemplate *iface )
 147 {
 148     xsltemplate *This = impl_from_IXSLTemplate( iface );
 149     ULONG ref = InterlockedDecrement( &This->ref );
 150
 151     TRACE("%p, refcount %lu.\n", iface, ref);
 152     if ( ref == 0 )
 153     {
 154         if (This->node) IXMLDOMNode_Release( This->node );
 155         heap_free( This );
 156     }
 157
 158     return ref;
 159 }
 160
 161 static HRESULT WINAPI xsltemplate_GetTypeInfoCount( IXSLTemplate *iface, UINT* pctinfo )
 162 {
 163     xsltemplate *This = impl_from_IXSLTemplate( iface );
 164     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 165 }
 166
 167 static HRESULT WINAPI xsltemplate_GetTypeInfo(
 168     IXSLTemplate *iface,
 169     UINT iTInfo, LCID lcid,
 170     ITypeInfo** ppTInfo )
 171 {
 172     xsltemplate *This = impl_from_IXSLTemplate( iface );
 173     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 174         iTInfo, lcid, ppTInfo);
 175 }
 176
 177 static HRESULT WINAPI xsltemplate_GetIDsOfNames(
 178     IXSLTemplate *iface,
 179     REFIID riid, LPOLESTR* rgszNames,
 180     UINT cNames, LCID lcid, DISPID* rgDispId )
 181 {
 182     xsltemplate *This = impl_from_IXSLTemplate( iface );
 183     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 184         riid, rgszNames, cNames, lcid, rgDispId);
 185 }
 186
 187 static HRESULT WINAPI xsltemplate_Invoke(
 188     IXSLTemplate *iface,
 189     DISPID dispIdMember, REFIID riid, LCID lcid,
 190     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 191     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 192 {
 193     xsltemplate *This = impl_from_IXSLTemplate( iface );
 194     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 195         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 196 }
 197
 198 static HRESULT WINAPI xsltemplate_putref_stylesheet( IXSLTemplate *iface,
 199     IXMLDOMNode *node)
 200 {
 201     xsltemplate *This = impl_from_IXSLTemplate( iface );
 202
 203     TRACE("(%p)->(%p)\n", This, node);
 204
 205     if (!node)
 206     {
 207         xsltemplate_set_node(This, NULL);
 208         return S_OK;
 209     }
 210
 211     /* FIXME: test for document type */
 212     xsltemplate_set_node(This, node);
 213
 214     return S_OK;
 215 }
 216
 217 static HRESULT WINAPI xsltemplate_get_stylesheet( IXSLTemplate *iface,
 218     IXMLDOMNode **node)
 219 {
 220     xsltemplate *This = impl_from_IXSLTemplate( iface );
 221
 222     FIXME("(%p)->(%p): stub\n", This, node);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI xsltemplate_createProcessor( IXSLTemplate *iface,
 227     IXSLProcessor **processor)
 228 {
 229     xsltemplate *This = impl_from_IXSLTemplate( iface );
 230
 231     TRACE("(%p)->(%p)\n", This, processor);
 232
 233     if (!processor) return E_INVALIDARG;
 234
 235     return XSLProcessor_create(This, processor);
 236 }
 237
 238 static const struct IXSLTemplateVtbl XSLTemplateVtbl =
 239 {
 240     xsltemplate_QueryInterface,
 241     xsltemplate_AddRef,
 242     xsltemplate_Release,
 243     xsltemplate_GetTypeInfoCount,
 244     xsltemplate_GetTypeInfo,
 245     xsltemplate_GetIDsOfNames,
 246     xsltemplate_Invoke,
 247     xsltemplate_putref_stylesheet,
 248     xsltemplate_get_stylesheet,
 249     xsltemplate_createProcessor
 250 };
 251
 252 static const tid_t xsltemplate_iface_tids[] = {
 253     IXSLTemplate_tid,
 254     0
 255 };
 256
 257 static dispex_static_data_t xsltemplate_dispex = {
 258     NULL,
 259     IXSLTemplate_tid,
 260     NULL,
 261     xsltemplate_iface_tids
 262 };
 263
 264 HRESULT XSLTemplate_create(void **ppObj)
 265 {
 266     xsltemplate *This;
 267
 268     TRACE("(%p)\n", ppObj);
 269
 270     This = heap_alloc( sizeof (*This) );
 271     if(!This)
 272         return E_OUTOFMEMORY;
 273
 274     This->IXSLTemplate_iface.lpVtbl = &XSLTemplateVtbl;
 275     This->ref = 1;
 276     This->node = NULL;
 277     init_dispex(&This->dispex, (IUnknown*)&This->IXSLTemplate_iface, &xsltemplate_dispex);
 278
 279     *ppObj = &This->IXSLTemplate_iface;
 280
 281     TRACE("returning iface %p\n", *ppObj);
 282
 283     return S_OK;
 284 }
 285
 286 /*** IXSLProcessor ***/
 287 static HRESULT WINAPI xslprocessor_QueryInterface(
 288     IXSLProcessor *iface,
 289     REFIID riid,
 290     void** ppvObject )
 291 {
 292     xslprocessor *This = impl_from_IXSLProcessor( iface );
 293     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 294
 295     if ( IsEqualGUID( riid, &IID_IXSLProcessor ) ||
 296          IsEqualGUID( riid, &IID_IDispatch ) ||
 297          IsEqualGUID( riid, &IID_IUnknown ) )
 298     {
 299         *ppvObject = iface;
 300     }
 301     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
 302     {
 303         return *ppvObject ? S_OK : E_NOINTERFACE;
 304     }
 305     else
 306     {
 307         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 308         *ppvObject = NULL;
 309         return E_NOINTERFACE;
 310     }
 311
 312     IUnknown_AddRef((IUnknown*)*ppvObject);
 313     return S_OK;
 314 }
 315
 316 static ULONG WINAPI xslprocessor_AddRef( IXSLProcessor *iface )
 317 {
 318     xslprocessor *This = impl_from_IXSLProcessor( iface );
 319     ULONG ref = InterlockedIncrement( &This->ref );
 320     TRACE("%p, refcount %lu.\n", iface, ref);
 321     return ref;
 322 }
 323
 324 static ULONG WINAPI xslprocessor_Release( IXSLProcessor *iface )
 325 {
 326     xslprocessor *This = impl_from_IXSLProcessor( iface );
 327     ULONG ref = InterlockedDecrement( &This->ref );
 328
 329     TRACE("%p, refcount %lu.\n", iface, ref);
 330     if ( ref == 0 )
 331     {
 332         struct xslprocessor_par *par, *par2;
 333
 334         if (This->input) IXMLDOMNode_Release(This->input);
 335         if (This->output.unk)
 336             IUnknown_Release(This->output.unk);
 337         SysFreeString(This->outstr);
 338
 339         LIST_FOR_EACH_ENTRY_SAFE(par, par2, &This->params.list, struct xslprocessor_par, entry)
 340             xslprocessor_par_free(&This->params, par);
 341
 342         IXSLTemplate_Release(&This->stylesheet->IXSLTemplate_iface);
 343         heap_free( This );
 344     }
 345
 346     return ref;
 347 }
 348
 349 static HRESULT WINAPI xslprocessor_GetTypeInfoCount( IXSLProcessor *iface, UINT* pctinfo )
 350 {
 351     xslprocessor *This = impl_from_IXSLProcessor( iface );
 352     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 353 }
 354
 355 static HRESULT WINAPI xslprocessor_GetTypeInfo(
 356     IXSLProcessor *iface,
 357     UINT iTInfo, LCID lcid,
 358     ITypeInfo** ppTInfo )
 359 {
 360     xslprocessor *This = impl_from_IXSLProcessor( iface );
 361     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 362         iTInfo, lcid, ppTInfo);
 363 }
 364
 365 static HRESULT WINAPI xslprocessor_GetIDsOfNames(
 366     IXSLProcessor *iface,
 367     REFIID riid, LPOLESTR* rgszNames,
 368     UINT cNames, LCID lcid, DISPID* rgDispId )
 369 {
 370     xslprocessor *This = impl_from_IXSLProcessor( iface );
 371     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 372         riid, rgszNames, cNames, lcid, rgDispId);
 373 }
 374
 375 static HRESULT WINAPI xslprocessor_Invoke(
 376     IXSLProcessor *iface,
 377     DISPID dispIdMember, REFIID riid, LCID lcid,
 378     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 379     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 380 {
 381     xslprocessor *This = impl_from_IXSLProcessor( iface );
 382     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 383         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 384 }
 385
 386 static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input )
 387 {
 388     xslprocessor *This = impl_from_IXSLProcessor( iface );
 389     IXMLDOMNode *input_node;
 390     HRESULT hr;
 391
 392     TRACE("(%p)->(%s)\n", This, debugstr_variant(&input));
 393
 394     /* try IXMLDOMNode directly first */
 395     if (V_VT(&input) == VT_UNKNOWN)
 396         hr = IUnknown_QueryInterface(V_UNKNOWN(&input), &IID_IXMLDOMNode, (void**)&input_node);
 397     else if (V_VT(&input) == VT_DISPATCH)
 398         hr = IDispatch_QueryInterface(V_DISPATCH(&input), &IID_IXMLDOMNode, (void**)&input_node);
 399     else
 400     {
 401         IXMLDOMDocument *doc;
 402
 403         hr = dom_document_create(MSXML_DEFAULT, (void **)&doc);
 404         if (hr == S_OK)
 405         {
 406             VARIANT_BOOL b;
 407
 408             hr = IXMLDOMDocument_load(doc, input, &b);
 409             if (hr == S_OK)
 410                 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&input_node);
 411             IXMLDOMDocument_Release(doc);
 412         }
 413     }
 414
 415     if (hr == S_OK)
 416     {
 417         if (This->input) IXMLDOMNode_Release(This->input);
 418         This->input = input_node;
 419     }
 420
 421     return hr;
 422 }
 423
 424 static HRESULT WINAPI xslprocessor_get_input( IXSLProcessor *iface, VARIANT *input )
 425 {
 426     xslprocessor *This = impl_from_IXSLProcessor( iface );
 427
 428     FIXME("(%p)->(%p): stub\n", This, input);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI xslprocessor_get_ownerTemplate(
 433     IXSLProcessor *iface,
 434     IXSLTemplate **template)
 435 {
 436     xslprocessor *This = impl_from_IXSLProcessor( iface );
 437
 438     FIXME("(%p)->(%p): stub\n", This, template);
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI xslprocessor_setStartMode(
 443     IXSLProcessor *iface,
 444     BSTR p,
 445     BSTR uri)
 446 {
 447     xslprocessor *This = impl_from_IXSLProcessor( iface );
 448
 449     FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(p), debugstr_w(uri));
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI xslprocessor_get_startMode(
 454     IXSLProcessor *iface,
 455     BSTR *p)
 456 {
 457     xslprocessor *This = impl_from_IXSLProcessor( iface );
 458
 459     FIXME("(%p)->(%p): stub\n", This, p);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI xslprocessor_get_startModeURI(
 464     IXSLProcessor *iface,
 465     BSTR *uri)
 466 {
 467     xslprocessor *This = impl_from_IXSLProcessor( iface );
 468
 469     FIXME("(%p)->(%p): stub\n", This, uri);
 470     return E_NOTIMPL;
 471 }
 472
 473 static HRESULT WINAPI xslprocessor_put_output(
 474     IXSLProcessor *iface,
 475     VARIANT var)
 476 {
 477     xslprocessor *This = impl_from_IXSLProcessor( iface );
 478     enum output_type output_type = PROCESSOR_OUTPUT_NOT_SET;
 479     IUnknown *output = NULL;
 480     HRESULT hr = S_OK;
 481
 482     TRACE("(%p)->(%s)\n", This, debugstr_variant(&var));
 483
 484     switch (V_VT(&var))
 485     {
 486     case VT_EMPTY:
 487         break;
 488     case VT_UNKNOWN:
 489     case VT_DISPATCH:
 490         if (!V_UNKNOWN(&var))
 491             break;
 492
 493         output_type = PROCESSOR_OUTPUT_STREAM;
 494         hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IStream, (void **)&output);
 495         if (FAILED(hr))
 496             hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_ISequentialStream, (void **)&output);
 497         if (FAILED(hr))
 498         {
 499             output_type = PROCESSOR_OUTPUT_RESPONSE;
 500             hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IResponse, (void **)&output);
 501         }
 502         if (FAILED(hr))
 503         {
 504             output_type = PROCESSOR_OUTPUT_PERSISTSTREAM;
 505             hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IPersistStream, (void **)&output);
 506         }
 507         if (FAILED(hr))
 508             hr = IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IPersistStreamInit, (void **)&output);
 509         if (FAILED(hr))
 510         {
 511             output_type = PROCESSOR_OUTPUT_NOT_SET;
 512             WARN("failed to get output interface, hr %#lx.\n", hr);
 513         }
 514         break;
 515     default:
 516         FIXME("output type %d not handled\n", V_VT(&var));
 517         hr = E_FAIL;
 518     }
 519
 520     if (hr == S_OK)
 521     {
 522         if (This->output.unk)
 523             IUnknown_Release(This->output.unk);
 524         This->output.unk = output;
 525         This->output_type = output_type;
 526     }
 527
 528     return hr;
 529 }
 530
 531 static HRESULT WINAPI xslprocessor_get_output(
 532     IXSLProcessor *iface,
 533     VARIANT *output)
 534 {
 535     xslprocessor *This = impl_from_IXSLProcessor( iface );
 536
 537     TRACE("(%p)->(%p)\n", This, output);
 538
 539     if (!output) return E_INVALIDARG;
 540
 541     if (This->output.unk)
 542     {
 543         V_VT(output) = VT_UNKNOWN;
 544         V_UNKNOWN(output) = This->output.unk;
 545         IUnknown_AddRef(This->output.unk);
 546     }
 547     else if (This->outstr)
 548     {
 549         V_VT(output) = VT_BSTR;
 550         V_BSTR(output) = SysAllocString(This->outstr);
 551     }
 552     else
 553         V_VT(output) = VT_EMPTY;
 554
 555     return S_OK;
 556 }
 557
 558 static HRESULT WINAPI xslprocessor_transform(
 559     IXSLProcessor *iface,
 560     VARIANT_BOOL  *ret)
 561 {
 562     xslprocessor *This = impl_from_IXSLProcessor( iface );
 563     ISequentialStream *stream = NULL;
 564     HRESULT hr;
 565
 566     TRACE("(%p)->(%p)\n", This, ret);
 567
 568     if (!ret)
 569         return E_INVALIDARG;
 570
 571     if (This->output_type == PROCESSOR_OUTPUT_STREAM)
 572     {
 573         stream = This->output.stream;
 574         ISequentialStream_AddRef(stream);
 575     }
 576     else if (This->output_type == PROCESSOR_OUTPUT_PERSISTSTREAM ||
 577             This->output_type == PROCESSOR_OUTPUT_RESPONSE)
 578     {
 579         if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, (IStream **)&stream)))
 580             return hr;
 581     }
 582
 583     SysFreeString(This->outstr);
 584
 585     hr = node_transform_node_params(get_node_obj(This->input), This->stylesheet->node,
 586             &This->outstr, stream, &This->params);
 587     if (SUCCEEDED(hr))
 588     {
 589         IStream *src = (IStream *)stream;
 590
 591         switch (This->output_type)
 592         {
 593         case PROCESSOR_OUTPUT_PERSISTSTREAM:
 594         {
 595             LARGE_INTEGER zero;
 596
 597             /* for IPersistStream* output seekable stream is used */
 598             zero.QuadPart = 0;
 599             IStream_Seek(src, zero, STREAM_SEEK_SET, NULL);
 600             hr = IPersistStream_Load(This->output.persiststream, src);
 601             break;
 602         }
 603         case PROCESSOR_OUTPUT_RESPONSE:
 604         {
 605             SAFEARRAYBOUND bound;
 606             SAFEARRAY *array;
 607             HGLOBAL hglobal;
 608             VARIANT bin;
 609             DWORD size;
 610             void *dest;
 611
 612             if (FAILED(hr = GetHGlobalFromStream(src, &hglobal)))
 613                 break;
 614             size = GlobalSize(hglobal);
 615
 616             bound.lLbound = 0;
 617             bound.cElements = size;
 618             if (!(array = SafeArrayCreate(VT_UI1, 1, &bound)))
 619                 break;
 620
 621             V_VT(&bin) = VT_ARRAY | VT_UI1;
 622             V_ARRAY(&bin) = array;
 623
 624             hr = SafeArrayAccessData(array, &dest);
 625             if (hr == S_OK)
 626             {
 627                 void *data = GlobalLock(hglobal);
 628                 memcpy(dest, data, size);
 629                 GlobalUnlock(hglobal);
 630                 SafeArrayUnaccessData(array);
 631
 632                 IResponse_BinaryWrite(This->output.response, bin);
 633             }
 634
 635             VariantClear(&bin);
 636             break;
 637         }
 638         default:
 639             ;
 640         }
 641     }
 642
 643     if (stream)
 644         ISequentialStream_Release(stream);
 645
 646     *ret = hr == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
 647     return hr;
 648 }
 649
 650 static HRESULT WINAPI xslprocessor_reset( IXSLProcessor *iface )
 651 {
 652     xslprocessor *This = impl_from_IXSLProcessor( iface );
 653
 654     FIXME("(%p): stub\n", This);
 655     return E_NOTIMPL;
 656 }
 657
 658 static HRESULT WINAPI xslprocessor_get_readyState(
 659     IXSLProcessor *iface,
 660     LONG *state)
 661 {
 662     xslprocessor *This = impl_from_IXSLProcessor( iface );
 663
 664     FIXME("(%p)->(%p): stub\n", This, state);
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT xslprocessor_set_parvalue(const VARIANT *var, struct xslprocessor_par *par)
 669 {
 670     HRESULT hr = S_OK;
 671
 672     switch (V_VT(var))
 673     {
 674     case VT_BSTR:
 675     {
 676         par->value = SysAllocString(V_BSTR(var));
 677         if (!par->value) hr = E_OUTOFMEMORY;
 678         break;
 679     }
 680     default:
 681         FIXME("value type %d not handled\n", V_VT(var));
 682         hr = E_NOTIMPL;
 683     }
 684
 685     return hr;
 686 }
 687
 688 static HRESULT WINAPI xslprocessor_addParameter(
 689     IXSLProcessor *iface,
 690     BSTR p,
 691     VARIANT var,
 692     BSTR uri)
 693 {
 694     xslprocessor *This = impl_from_IXSLProcessor( iface );
 695     struct xslprocessor_par *cur, *par = NULL;
 696     HRESULT hr;
 697
 698     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(p), debugstr_variant(&var),
 699         debugstr_w(uri));
 700
 701     if (uri && *uri)
 702         FIXME("namespace uri is not supported\n");
 703
 704     /* search for existing parameter first */
 705     LIST_FOR_EACH_ENTRY(cur, &This->params.list, struct xslprocessor_par, entry)
 706     {
 707         if (!wcscmp(cur->name, p))
 708         {
 709             par = cur;
 710             break;
 711         }
 712     }
 713
 714     /* override with new value or add new parameter */
 715     if (par)
 716     {
 717         if (V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY)
 718         {
 719             /* remove parameter */
 720             xslprocessor_par_free(&This->params, par);
 721             return S_OK;
 722         }
 723         SysFreeString(par->value);
 724         par->value = NULL;
 725     }
 726     else
 727     {
 728         /* new parameter */
 729         par = heap_alloc(sizeof(struct xslprocessor_par));
 730         if (!par) return E_OUTOFMEMORY;
 731
 732         par->name = SysAllocString(p);
 733         if (!par->name)
 734         {
 735             heap_free(par);
 736             return E_OUTOFMEMORY;
 737         }
 738         list_add_tail(&This->params.list, &par->entry);
 739         This->params.count++;
 740     }
 741
 742     hr = xslprocessor_set_parvalue(&var, par);
 743     if (FAILED(hr))
 744         xslprocessor_par_free(&This->params, par);
 745
 746     return hr;
 747 }
 748
 749 static HRESULT WINAPI xslprocessor_addObject(
 750     IXSLProcessor *iface,
 751     IDispatch *obj,
 752     BSTR uri)
 753 {
 754     xslprocessor *This = impl_from_IXSLProcessor( iface );
 755
 756     FIXME("(%p)->(%p %s): stub\n", This, obj, debugstr_w(uri));
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI xslprocessor_get_stylesheet(
 761     IXSLProcessor *iface,
 762     IXMLDOMNode  **node)
 763 {
 764     xslprocessor *This = impl_from_IXSLProcessor( iface );
 765
 766     FIXME("(%p)->(%p): stub\n", This, node);
 767     return E_NOTIMPL;
 768 }
 769
 770 static const struct IXSLProcessorVtbl XSLProcessorVtbl =
 771 {
 772     xslprocessor_QueryInterface,
 773     xslprocessor_AddRef,
 774     xslprocessor_Release,
 775     xslprocessor_GetTypeInfoCount,
 776     xslprocessor_GetTypeInfo,
 777     xslprocessor_GetIDsOfNames,
 778     xslprocessor_Invoke,
 779     xslprocessor_put_input,
 780     xslprocessor_get_input,
 781     xslprocessor_get_ownerTemplate,
 782     xslprocessor_setStartMode,
 783     xslprocessor_get_startMode,
 784     xslprocessor_get_startModeURI,
 785     xslprocessor_put_output,
 786     xslprocessor_get_output,
 787     xslprocessor_transform,
 788     xslprocessor_reset,
 789     xslprocessor_get_readyState,
 790     xslprocessor_addParameter,
 791     xslprocessor_addObject,
 792     xslprocessor_get_stylesheet
 793 };
 794
 795 static const tid_t xslprocessor_iface_tids[] = {
 796     IXSLProcessor_tid,
 797     0
 798 };
 799
 800 static dispex_static_data_t xslprocessor_dispex = {
 801     NULL,
 802     IXSLProcessor_tid,
 803     NULL,
 804     xslprocessor_iface_tids
 805 };
 806
 807 HRESULT XSLProcessor_create(xsltemplate *template, IXSLProcessor **ppObj)
 808 {
 809     xslprocessor *This;
 810
 811     TRACE("(%p)\n", ppObj);
 812
 813     This = heap_alloc( sizeof (*This) );
 814     if(!This)
 815         return E_OUTOFMEMORY;
 816
 817     This->IXSLProcessor_iface.lpVtbl = &XSLProcessorVtbl;
 818     This->ref = 1;
 819     This->input = NULL;
 820     This->output.unk = NULL;
 821     This->output_type = PROCESSOR_OUTPUT_NOT_SET;
 822     This->outstr = NULL;
 823     list_init(&This->params.list);
 824     This->params.count = 0;
 825     This->stylesheet = template;
 826     IXSLTemplate_AddRef(&template->IXSLTemplate_iface);
 827     init_dispex(&This->dispex, (IUnknown*)&This->IXSLProcessor_iface, &xslprocessor_dispex);
 828
 829     *ppObj = &This->IXSLProcessor_iface;
 830
 831     TRACE("returning iface %p\n", *ppObj);
 832
 833     return S_OK;
 834 }