dlls/msxml3/saxreader.c

   1 /*
   2  *    SAX Reader implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   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 #define COBJMACROS
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31 #include "msxml2.h"
  32 #include "wininet.h"
  33 #include "urlmon.h"
  34 #include "winreg.h"
  35 #include "shlwapi.h"
  36
  37 #include "wine/debug.h"
  38
  39 #include "msxml_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  42
  43 #ifdef HAVE_LIBXML2
  44
  45 #include <libxml/SAX2.h>
  46
  47 typedef struct _saxreader
  48 {
  49     const struct IVBSAXXMLReaderVtbl *lpVtbl;
  50     const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
  51     LONG ref;
  52     struct ISAXContentHandler *contentHandler;
  53     xmlSAXHandler sax;
  54 } saxreader;
  55
  56 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  57 {
  58     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  59 }
  60
  61 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  62 {
  63     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
  64 }
  65
  66 /*** IVBSAXXMLReader interface ***/
  67 /*** IUnknown methods ***/
  68 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
  69 {
  70     saxreader *This = impl_from_IVBSAXXMLReader( iface );
  71
  72     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  73
  74     *ppvObject = NULL;
  75
  76     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
  77          IsEqualGUID( riid, &IID_IDispatch ) ||
  78          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
  79     {
  80         *ppvObject = iface;
  81     }
  82     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
  83     {
  84         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
  85     }
  86     else
  87     {
  88         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  89         return E_NOINTERFACE;
  90     }
  91
  92     IVBSAXXMLReader_AddRef( iface );
  93
  94     return S_OK;
  95 }
  96
  97 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
  98 {
  99     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 100     TRACE("%p\n", This );
 101     return InterlockedIncrement( &This->ref );
 102 }
 103
 104 static ULONG WINAPI saxxmlreader_Release(
 105     IVBSAXXMLReader* iface)
 106 {
 107     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 108     LONG ref;
 109
 110     TRACE("%p\n", This );
 111
 112     ref = InterlockedDecrement( &This->ref );
 113     if ( ref == 0 )
 114     {
 115         if(This->contentHandler)
 116             ISAXContentHandler_Release(This->contentHandler);
 117
 118         HeapFree( GetProcessHeap(), 0, This );
 119     }
 120
 121     return ref;
 122 }
 123 /*** IDispatch ***/
 124 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 125 {
 126     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 127
 128     TRACE("(%p)->(%p)\n", This, pctinfo);
 129
 130     *pctinfo = 1;
 131
 132     return S_OK;
 133 }
 134
 135 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 136     IVBSAXXMLReader *iface,
 137     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 138 {
 139     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 140     HRESULT hr;
 141
 142     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 143
 144     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 145
 146     return hr;
 147 }
 148
 149 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 150     IVBSAXXMLReader *iface,
 151     REFIID riid,
 152     LPOLESTR* rgszNames,
 153     UINT cNames,
 154     LCID lcid,
 155     DISPID* rgDispId)
 156 {
 157     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 158     ITypeInfo *typeinfo;
 159     HRESULT hr;
 160
 161     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 162           lcid, rgDispId);
 163
 164     if(!rgszNames || cNames == 0 || !rgDispId)
 165         return E_INVALIDARG;
 166
 167     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 168     if(SUCCEEDED(hr))
 169     {
 170         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 171         ITypeInfo_Release(typeinfo);
 172     }
 173
 174     return hr;
 175 }
 176
 177 static HRESULT WINAPI saxxmlreader_Invoke(
 178     IVBSAXXMLReader *iface,
 179     DISPID dispIdMember,
 180     REFIID riid,
 181     LCID lcid,
 182     WORD wFlags,
 183     DISPPARAMS* pDispParams,
 184     VARIANT* pVarResult,
 185     EXCEPINFO* pExcepInfo,
 186     UINT* puArgErr)
 187 {
 188     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 189     ITypeInfo *typeinfo;
 190     HRESULT hr;
 191
 192     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 193           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 194
 195     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 196     if(SUCCEEDED(hr))
 197     {
 198         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 199                 pVarResult, pExcepInfo, puArgErr);
 200         ITypeInfo_Release(typeinfo);
 201     }
 202
 203     return hr;
 204 }
 205
 206 /*** IVBSAXXMLReader methods ***/
 207 static HRESULT WINAPI saxxmlreader_getFeature(
 208     IVBSAXXMLReader* iface,
 209     const WCHAR *pFeature,
 210     VARIANT_BOOL *pValue)
 211 {
 212     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 213
 214     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 215     return E_NOTIMPL;
 216 }
 217
 218 static HRESULT WINAPI saxxmlreader_putFeature(
 219     IVBSAXXMLReader* iface,
 220     const WCHAR *pFeature,
 221     VARIANT_BOOL vfValue)
 222 {
 223     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 224
 225     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI saxxmlreader_getProperty(
 230     IVBSAXXMLReader* iface,
 231     const WCHAR *pProp,
 232     VARIANT *pValue)
 233 {
 234     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 235
 236     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI saxxmlreader_putProperty(
 241     IVBSAXXMLReader* iface,
 242     const WCHAR *pProp,
 243     VARIANT value)
 244 {
 245     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 246
 247     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI saxxmlreader_getEntityResolver(
 252     IVBSAXXMLReader* iface,
 253     IVBSAXEntityResolver **pEntityResolver)
 254 {
 255     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 256
 257     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 258     return E_NOTIMPL;
 259 }
 260
 261 static HRESULT WINAPI saxxmlreader_putEntityResolver(
 262     IVBSAXXMLReader* iface,
 263     IVBSAXEntityResolver *pEntityResolver)
 264 {
 265     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 266
 267     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI saxxmlreader_getContentHandler(
 272     IVBSAXXMLReader* iface,
 273     IVBSAXContentHandler **ppContentHandler)
 274 {
 275     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 276
 277     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI saxxmlreader_putContentHandler(
 282     IVBSAXXMLReader* iface,
 283     IVBSAXContentHandler *contentHandler)
 284 {
 285     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 286
 287     FIXME("(%p)->(%p) stub\n", This, contentHandler);
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI saxxmlreader_getDTDHandler(
 292     IVBSAXXMLReader* iface,
 293     IVBSAXDTDHandler **pDTDHandler)
 294 {
 295     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 296
 297     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI saxxmlreader_putDTDHandler(
 302     IVBSAXXMLReader* iface,
 303     IVBSAXDTDHandler *pDTDHandler)
 304 {
 305     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 306
 307     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI saxxmlreader_getErrorHandler(
 312     IVBSAXXMLReader* iface,
 313     IVBSAXErrorHandler **pErrorHandler)
 314 {
 315     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 316
 317     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI saxxmlreader_putErrorHandler(
 322     IVBSAXXMLReader* iface,
 323     IVBSAXErrorHandler *errorHandler)
 324 {
 325     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 326
 327     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI saxxmlreader_getBaseURL(
 332     IVBSAXXMLReader* iface,
 333     const WCHAR **pBaseUrl)
 334 {
 335     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 336
 337     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI saxxmlreader_putBaseURL(
 342     IVBSAXXMLReader* iface,
 343     const WCHAR *pBaseUrl)
 344 {
 345     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 346
 347     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
 352     IVBSAXXMLReader* iface,
 353     const WCHAR **pSecureBaseUrl)
 354 {
 355     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 356
 357     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 358     return E_NOTIMPL;
 359 }
 360
 361
 362 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
 363     IVBSAXXMLReader* iface,
 364     const WCHAR *secureBaseUrl)
 365 {
 366     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 367
 368     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT WINAPI saxxmlreader_parse(
 373     IVBSAXXMLReader* iface,
 374     VARIANT varInput)
 375 {
 376     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 377
 378     FIXME("(%p) stub\n", This);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI saxxmlreader_parseURL(
 383     IVBSAXXMLReader* iface,
 384     const WCHAR *url)
 385 {
 386     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 387
 388     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 389     return E_NOTIMPL;
 390 }
 391
 392 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
 393 {
 394     saxxmlreader_QueryInterface,
 395     saxxmlreader_AddRef,
 396     saxxmlreader_Release,
 397     saxxmlreader_GetTypeInfoCount,
 398     saxxmlreader_GetTypeInfo,
 399     saxxmlreader_GetIDsOfNames,
 400     saxxmlreader_Invoke,
 401     saxxmlreader_getFeature,
 402     saxxmlreader_putFeature,
 403     saxxmlreader_getProperty,
 404     saxxmlreader_putProperty,
 405     saxxmlreader_getEntityResolver,
 406     saxxmlreader_putEntityResolver,
 407     saxxmlreader_getContentHandler,
 408     saxxmlreader_putContentHandler,
 409     saxxmlreader_getDTDHandler,
 410     saxxmlreader_putDTDHandler,
 411     saxxmlreader_getErrorHandler,
 412     saxxmlreader_putErrorHandler,
 413     saxxmlreader_getBaseURL,
 414     saxxmlreader_putBaseURL,
 415     saxxmlreader_getSecureBaseURL,
 416     saxxmlreader_putSecureBaseURL,
 417     saxxmlreader_parse,
 418     saxxmlreader_parseURL
 419 };
 420
 421 /*** ISAXXMLReader interface ***/
 422 /*** IUnknown methods ***/
 423 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
 424 {
 425     saxreader *This = impl_from_ISAXXMLReader( iface );
 426     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVtbl, riid, ppvObject);
 427 }
 428
 429 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
 430 {
 431     saxreader *This = impl_from_ISAXXMLReader( iface );
 432     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVtbl);
 433 }
 434
 435 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
 436 {
 437     saxreader *This = impl_from_ISAXXMLReader( iface );
 438     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVtbl);
 439 }
 440
 441 /*** ISAXXMLReader methods ***/
 442 static HRESULT WINAPI isaxxmlreader_getFeature(
 443         ISAXXMLReader* iface,
 444         const WCHAR *pFeature,
 445         VARIANT_BOOL *pValue)
 446 {
 447     saxreader *This = impl_from_ISAXXMLReader( iface );
 448
 449     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI isaxxmlreader_putFeature(
 454         ISAXXMLReader* iface,
 455         const WCHAR *pFeature,
 456         VARIANT_BOOL vfValue)
 457 {
 458     saxreader *This = impl_from_ISAXXMLReader( iface );
 459
 460     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI isaxxmlreader_getProperty(
 465         ISAXXMLReader* iface,
 466         const WCHAR *pProp,
 467         VARIANT *pValue)
 468 {
 469     saxreader *This = impl_from_ISAXXMLReader( iface );
 470
 471     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI isaxxmlreader_putProperty(
 476         ISAXXMLReader* iface,
 477         const WCHAR *pProp,
 478         VARIANT value)
 479 {
 480     saxreader *This = impl_from_ISAXXMLReader( iface );
 481
 482     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 483     return E_NOTIMPL;
 484 }
 485
 486 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
 487         ISAXXMLReader* iface,
 488         ISAXEntityResolver **ppEntityResolver)
 489 {
 490     saxreader *This = impl_from_ISAXXMLReader( iface );
 491
 492     FIXME("(%p)->(%p) stub\n", This, ppEntityResolver);
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
 497         ISAXXMLReader* iface,
 498         ISAXEntityResolver *pEntityResolver)
 499 {
 500     saxreader *This = impl_from_ISAXXMLReader( iface );
 501
 502     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 503     return E_NOTIMPL;
 504 }
 505
 506 static HRESULT WINAPI isaxxmlreader_getContentHandler(
 507         ISAXXMLReader* iface,
 508         ISAXContentHandler **pContentHandler)
 509 {
 510     saxreader *This = impl_from_ISAXXMLReader( iface );
 511
 512     TRACE("(%p)->(%p)\n", This, pContentHandler);
 513     if(This->contentHandler)
 514         ISAXContentHandler_AddRef(This->contentHandler);
 515     *pContentHandler = This->contentHandler;
 516
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI isaxxmlreader_putContentHandler(
 521         ISAXXMLReader* iface,
 522         ISAXContentHandler *contentHandler)
 523 {
 524     saxreader *This = impl_from_ISAXXMLReader( iface );
 525
 526     TRACE("(%p)->(%p)\n", This, contentHandler);
 527     if(contentHandler)
 528         ISAXContentHandler_AddRef(contentHandler);
 529     if(This->contentHandler)
 530         ISAXContentHandler_Release(This->contentHandler);
 531     This->contentHandler = contentHandler;
 532
 533     return S_OK;
 534 }
 535
 536 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
 537         ISAXXMLReader* iface,
 538         ISAXDTDHandler **pDTDHandler)
 539 {
 540     saxreader *This = impl_from_ISAXXMLReader( iface );
 541
 542     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
 547         ISAXXMLReader* iface,
 548         ISAXDTDHandler *pDTDHandler)
 549 {
 550     saxreader *This = impl_from_ISAXXMLReader( iface );
 551
 552     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
 557         ISAXXMLReader* iface,
 558         ISAXErrorHandler **pErrorHandler)
 559 {
 560     saxreader *This = impl_from_ISAXXMLReader( iface );
 561
 562     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
 567         ISAXXMLReader* iface,
 568         ISAXErrorHandler *errorHandler)
 569 {
 570     saxreader *This = impl_from_ISAXXMLReader( iface );
 571
 572     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI isaxxmlreader_getBaseURL(
 577         ISAXXMLReader* iface,
 578         const WCHAR **pBaseUrl)
 579 {
 580     saxreader *This = impl_from_ISAXXMLReader( iface );
 581
 582     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI isaxxmlreader_putBaseURL(
 587         ISAXXMLReader* iface,
 588         const WCHAR *pBaseUrl)
 589 {
 590     saxreader *This = impl_from_ISAXXMLReader( iface );
 591
 592     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
 597         ISAXXMLReader* iface,
 598         const WCHAR **pSecureBaseUrl)
 599 {
 600     saxreader *This = impl_from_ISAXXMLReader( iface );
 601
 602     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
 607         ISAXXMLReader* iface,
 608         const WCHAR *secureBaseUrl)
 609 {
 610     saxreader *This = impl_from_ISAXXMLReader( iface );
 611
 612     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI isaxxmlreader_parse(
 617         ISAXXMLReader* iface,
 618         VARIANT varInput)
 619 {
 620     saxreader *This = impl_from_ISAXXMLReader( iface );
 621
 622     FIXME("(%p) stub\n", This);
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI isaxxmlreader_parseURL(
 627         ISAXXMLReader* iface,
 628         const WCHAR *url)
 629 {
 630     saxreader *This = impl_from_ISAXXMLReader( iface );
 631
 632     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 633     return E_NOTIMPL;
 634 }
 635
 636 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
 637 {
 638     isaxxmlreader_QueryInterface,
 639     isaxxmlreader_AddRef,
 640     isaxxmlreader_Release,
 641     isaxxmlreader_getFeature,
 642     isaxxmlreader_putFeature,
 643     isaxxmlreader_getProperty,
 644     isaxxmlreader_putProperty,
 645     isaxxmlreader_getEntityResolver,
 646     isaxxmlreader_putEntityResolver,
 647     isaxxmlreader_getContentHandler,
 648     isaxxmlreader_putContentHandler,
 649     isaxxmlreader_getDTDHandler,
 650     isaxxmlreader_putDTDHandler,
 651     isaxxmlreader_getErrorHandler,
 652     isaxxmlreader_putErrorHandler,
 653     isaxxmlreader_getBaseURL,
 654     isaxxmlreader_putBaseURL,
 655     isaxxmlreader_getSecureBaseURL,
 656     isaxxmlreader_putSecureBaseURL,
 657     isaxxmlreader_parse,
 658     isaxxmlreader_parseURL
 659 };
 660
 661 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 662 {
 663     saxreader *reader;
 664
 665     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 666
 667     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
 668     if( !reader )
 669         return E_OUTOFMEMORY;
 670
 671     reader->lpVtbl = &saxreader_vtbl;
 672     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
 673     reader->ref = 1;
 674     reader->contentHandler = NULL;
 675
 676     *ppObj = &reader->lpVtbl;
 677
 678     TRACE("returning iface %p\n", *ppObj);
 679
 680     return S_OK;
 681 }
 682
 683 #else
 684
 685 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 686 {
 687     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
 688             "libxml2 support was not present at compile time.\n");
 689     return E_NOTIMPL;
 690 }
 691
 692 #endif