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(pContentHandler == NULL)
 518         return E_POINTER;
 519     if(This->contentHandler)
 520         ISAXContentHandler_AddRef(This->contentHandler);
 521     *pContentHandler = This->contentHandler;
 522
 523     return S_OK;
 524 }
 525
 526 static HRESULT WINAPI isaxxmlreader_putContentHandler(
 527         ISAXXMLReader* iface,
 528         ISAXContentHandler *contentHandler)
 529 {
 530     saxreader *This = impl_from_ISAXXMLReader( iface );
 531
 532     TRACE("(%p)->(%p)\n", This, contentHandler);
 533     if(contentHandler)
 534         ISAXContentHandler_AddRef(contentHandler);
 535     if(This->contentHandler)
 536         ISAXContentHandler_Release(This->contentHandler);
 537     This->contentHandler = contentHandler;
 538
 539     return S_OK;
 540 }
 541
 542 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
 543         ISAXXMLReader* iface,
 544         ISAXDTDHandler **pDTDHandler)
 545 {
 546     saxreader *This = impl_from_ISAXXMLReader( iface );
 547
 548     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
 553         ISAXXMLReader* iface,
 554         ISAXDTDHandler *pDTDHandler)
 555 {
 556     saxreader *This = impl_from_ISAXXMLReader( iface );
 557
 558     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
 563         ISAXXMLReader* iface,
 564         ISAXErrorHandler **pErrorHandler)
 565 {
 566     saxreader *This = impl_from_ISAXXMLReader( iface );
 567
 568     TRACE("(%p)->(%p)\n", This, pErrorHandler);
 569     if(pErrorHandler == NULL)
 570         return E_POINTER;
 571     if(This->errorHandler)
 572         ISAXErrorHandler_AddRef(This->errorHandler);
 573     *pErrorHandler = This->errorHandler;
 574
 575     return S_OK;
 576 }
 577
 578 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
 579         ISAXXMLReader* iface,
 580         ISAXErrorHandler *errorHandler)
 581 {
 582     saxreader *This = impl_from_ISAXXMLReader( iface );
 583
 584     TRACE("(%p)->(%p)\n", This, errorHandler);
 585     if(errorHandler)
 586         ISAXErrorHandler_AddRef(errorHandler);
 587     if(This->errorHandler)
 588         ISAXErrorHandler_Release(This->errorHandler);
 589     This->errorHandler = errorHandler;
 590
 591     return S_OK;
 592 }
 593
 594 static HRESULT WINAPI isaxxmlreader_getBaseURL(
 595         ISAXXMLReader* iface,
 596         const WCHAR **pBaseUrl)
 597 {
 598     saxreader *This = impl_from_ISAXXMLReader( iface );
 599
 600     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI isaxxmlreader_putBaseURL(
 605         ISAXXMLReader* iface,
 606         const WCHAR *pBaseUrl)
 607 {
 608     saxreader *This = impl_from_ISAXXMLReader( iface );
 609
 610     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
 615         ISAXXMLReader* iface,
 616         const WCHAR **pSecureBaseUrl)
 617 {
 618     saxreader *This = impl_from_ISAXXMLReader( iface );
 619
 620     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
 625         ISAXXMLReader* iface,
 626         const WCHAR *secureBaseUrl)
 627 {
 628     saxreader *This = impl_from_ISAXXMLReader( iface );
 629
 630     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI isaxxmlreader_parse(
 635         ISAXXMLReader* iface,
 636         VARIANT varInput)
 637 {
 638     saxreader *This = impl_from_ISAXXMLReader( iface );
 639
 640     FIXME("(%p) stub\n", This);
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI isaxxmlreader_parseURL(
 645         ISAXXMLReader* iface,
 646         const WCHAR *url)
 647 {
 648     saxreader *This = impl_from_ISAXXMLReader( iface );
 649
 650     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 651     return E_NOTIMPL;
 652 }
 653
 654 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
 655 {
 656     isaxxmlreader_QueryInterface,
 657     isaxxmlreader_AddRef,
 658     isaxxmlreader_Release,
 659     isaxxmlreader_getFeature,
 660     isaxxmlreader_putFeature,
 661     isaxxmlreader_getProperty,
 662     isaxxmlreader_putProperty,
 663     isaxxmlreader_getEntityResolver,
 664     isaxxmlreader_putEntityResolver,
 665     isaxxmlreader_getContentHandler,
 666     isaxxmlreader_putContentHandler,
 667     isaxxmlreader_getDTDHandler,
 668     isaxxmlreader_putDTDHandler,
 669     isaxxmlreader_getErrorHandler,
 670     isaxxmlreader_putErrorHandler,
 671     isaxxmlreader_getBaseURL,
 672     isaxxmlreader_putBaseURL,
 673     isaxxmlreader_getSecureBaseURL,
 674     isaxxmlreader_putSecureBaseURL,
 675     isaxxmlreader_parse,
 676     isaxxmlreader_parseURL
 677 };
 678
 679 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 680 {
 681     saxreader *reader;
 682
 683     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 684
 685     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
 686     if( !reader )
 687         return E_OUTOFMEMORY;
 688
 689     reader->lpVtbl = &saxreader_vtbl;
 690     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
 691     reader->ref = 1;
 692     reader->contentHandler = NULL;
 693     reader->errorHandler = NULL;
 694
 695     *ppObj = &reader->lpVtbl;
 696
 697     TRACE("returning iface %p\n", *ppObj);
 698
 699     return S_OK;
 700 }
 701
 702 #else
 703
 704 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 705 {
 706     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
 707             "libxml2 support was not present at compile time.\n");
 708     return E_NOTIMPL;
 709 }
 710
 711 #endif