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