dlls/msxml3/saxreader.c

   1 /*
   2  *    SAX Reader implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   5  * Copyright 2008 Piotr Caban
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33 #include "wininet.h"
  34 #include "urlmon.h"
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "wine/debug.h"
  39
  40 #include "msxml_private.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 #include <libxml/SAX2.h>
  47
  48 typedef struct _saxreader
  49 {
  50     const struct IVBSAXXMLReaderVtbl *lpVtbl;
  51     const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
  52     LONG ref;
  53     struct ISAXContentHandler *contentHandler;
  54     struct ISAXErrorHandler *errorHandler;
  55     xmlSAXHandler sax;
  56 } saxreader;
  57
  58 typedef struct _saxlocator
  59 {
  60     const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
  61     LONG ref;
  62     saxreader *saxreader;
  63 } saxlocator;
  64
  65 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  66 {
  67     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  68 }
  69
  70 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  71 {
  72     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
  73 }
  74
  75 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
  76 {
  77     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
  78 }
  79
  80 /*** ISAXLocator interface ***/
  81 /*** IUnknown methods ***/
  82 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
  83 {
  84     saxlocator *This = impl_from_ISAXLocator( iface );
  85
  86     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  87
  88     *ppvObject = NULL;
  89
  90     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
  91             IsEqualGUID( riid, &IID_ISAXLocator ))
  92     {
  93         *ppvObject = iface;
  94     }
  95     else
  96     {
  97         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  98         return E_NOINTERFACE;
  99     }
 100
 101     ISAXLocator_AddRef( iface );
 102
 103     return S_OK;
 104 }
 105
 106 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
 107 {
 108     saxlocator *This = impl_from_ISAXLocator( iface );
 109     TRACE("%p\n", This );
 110     return InterlockedIncrement( &This->ref );
 111 }
 112
 113 static ULONG WINAPI isaxlocator_Release(
 114         ISAXLocator* iface)
 115 {
 116     saxlocator *This = impl_from_ISAXLocator( iface );
 117     LONG ref;
 118
 119     TRACE("%p\n", This );
 120
 121     ref = InterlockedDecrement( &This->ref );
 122     if ( ref == 0 )
 123     {
 124         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
 125         HeapFree( GetProcessHeap(), 0, This );
 126     }
 127
 128     return ref;
 129 }
 130
 131 /*** ISAXLocator methods ***/
 132 static HRESULT WINAPI isaxlocator_getColumnNumber(
 133         ISAXLocator* iface,
 134         int *pnColumn)
 135 {
 136     saxlocator *This = impl_from_ISAXLocator( iface );
 137
 138     FIXME("(%p)->(%p) stub\n", This, pnColumn);
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI isaxlocator_getLineNumber(
 143         ISAXLocator* iface,
 144         int *pnLine)
 145 {
 146     saxlocator *This = impl_from_ISAXLocator( iface );
 147
 148     FIXME("(%p)->(%p) stub\n", This, pnLine);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI isaxlocator_getPublicId(
 153         ISAXLocator* iface,
 154         const WCHAR ** ppwchPublicId)
 155 {
 156     saxlocator *This = impl_from_ISAXLocator( iface );
 157
 158     FIXME("(%p)->(%p) stub\n", This, ppwchPublicId);
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI isaxlocator_getSystemId(
 163         ISAXLocator* iface,
 164         const WCHAR ** ppwchSystemId)
 165 {
 166     saxlocator *This = impl_from_ISAXLocator( iface );
 167
 168     FIXME("(%p)->(%p) stub\n", This, ppwchSystemId);
 169     return E_NOTIMPL;
 170 }
 171
 172 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
 173 {
 174     isaxlocator_QueryInterface,
 175     isaxlocator_AddRef,
 176     isaxlocator_Release,
 177     isaxlocator_getColumnNumber,
 178     isaxlocator_getLineNumber,
 179     isaxlocator_getPublicId,
 180     isaxlocator_getSystemId
 181 };
 182
 183 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator)
 184 {
 185     saxlocator *locator;
 186
 187     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
 188     if( !locator )
 189         return E_OUTOFMEMORY;
 190
 191     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
 192     locator->ref = 1;
 193
 194     locator->saxreader = reader;
 195     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
 196
 197     *ppsaxlocator = locator;
 198
 199     TRACE("returning %p\n", *ppsaxlocator);
 200
 201     return S_OK;
 202 }
 203
 204 /*** IVBSAXXMLReader interface ***/
 205 /*** IUnknown methods ***/
 206 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
 207 {
 208     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 209
 210     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 211
 212     *ppvObject = NULL;
 213
 214     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 215          IsEqualGUID( riid, &IID_IDispatch ) ||
 216          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
 217     {
 218         *ppvObject = iface;
 219     }
 220     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
 221     {
 222         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
 223     }
 224     else
 225     {
 226         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 227         return E_NOINTERFACE;
 228     }
 229
 230     IVBSAXXMLReader_AddRef( iface );
 231
 232     return S_OK;
 233 }
 234
 235 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
 236 {
 237     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 238     TRACE("%p\n", This );
 239     return InterlockedIncrement( &This->ref );
 240 }
 241
 242 static ULONG WINAPI saxxmlreader_Release(
 243     IVBSAXXMLReader* iface)
 244 {
 245     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 246     LONG ref;
 247
 248     TRACE("%p\n", This );
 249
 250     ref = InterlockedDecrement( &This->ref );
 251     if ( ref == 0 )
 252     {
 253         if(This->contentHandler)
 254             ISAXContentHandler_Release(This->contentHandler);
 255
 256         if(This->errorHandler)
 257             ISAXErrorHandler_Release(This->errorHandler);
 258
 259         HeapFree( GetProcessHeap(), 0, This );
 260     }
 261
 262     return ref;
 263 }
 264 /*** IDispatch ***/
 265 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 266 {
 267     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 268
 269     TRACE("(%p)->(%p)\n", This, pctinfo);
 270
 271     *pctinfo = 1;
 272
 273     return S_OK;
 274 }
 275
 276 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 277     IVBSAXXMLReader *iface,
 278     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 279 {
 280     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 281     HRESULT hr;
 282
 283     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 284
 285     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 286
 287     return hr;
 288 }
 289
 290 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 291     IVBSAXXMLReader *iface,
 292     REFIID riid,
 293     LPOLESTR* rgszNames,
 294     UINT cNames,
 295     LCID lcid,
 296     DISPID* rgDispId)
 297 {
 298     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 299     ITypeInfo *typeinfo;
 300     HRESULT hr;
 301
 302     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 303           lcid, rgDispId);
 304
 305     if(!rgszNames || cNames == 0 || !rgDispId)
 306         return E_INVALIDARG;
 307
 308     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 309     if(SUCCEEDED(hr))
 310     {
 311         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 312         ITypeInfo_Release(typeinfo);
 313     }
 314
 315     return hr;
 316 }
 317
 318 static HRESULT WINAPI saxxmlreader_Invoke(
 319     IVBSAXXMLReader *iface,
 320     DISPID dispIdMember,
 321     REFIID riid,
 322     LCID lcid,
 323     WORD wFlags,
 324     DISPPARAMS* pDispParams,
 325     VARIANT* pVarResult,
 326     EXCEPINFO* pExcepInfo,
 327     UINT* puArgErr)
 328 {
 329     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 330     ITypeInfo *typeinfo;
 331     HRESULT hr;
 332
 333     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 334           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 335
 336     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 337     if(SUCCEEDED(hr))
 338     {
 339         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 340                 pVarResult, pExcepInfo, puArgErr);
 341         ITypeInfo_Release(typeinfo);
 342     }
 343
 344     return hr;
 345 }
 346
 347 /*** IVBSAXXMLReader methods ***/
 348 static HRESULT WINAPI saxxmlreader_getFeature(
 349     IVBSAXXMLReader* iface,
 350     const WCHAR *pFeature,
 351     VARIANT_BOOL *pValue)
 352 {
 353     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 354
 355     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI saxxmlreader_putFeature(
 360     IVBSAXXMLReader* iface,
 361     const WCHAR *pFeature,
 362     VARIANT_BOOL vfValue)
 363 {
 364     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 365
 366     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI saxxmlreader_getProperty(
 371     IVBSAXXMLReader* iface,
 372     const WCHAR *pProp,
 373     VARIANT *pValue)
 374 {
 375     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 376
 377     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI saxxmlreader_putProperty(
 382     IVBSAXXMLReader* iface,
 383     const WCHAR *pProp,
 384     VARIANT value)
 385 {
 386     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 387
 388     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI saxxmlreader_getEntityResolver(
 393     IVBSAXXMLReader* iface,
 394     IVBSAXEntityResolver **pEntityResolver)
 395 {
 396     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 397
 398     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI saxxmlreader_putEntityResolver(
 403     IVBSAXXMLReader* iface,
 404     IVBSAXEntityResolver *pEntityResolver)
 405 {
 406     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 407
 408     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI saxxmlreader_getContentHandler(
 413     IVBSAXXMLReader* iface,
 414     IVBSAXContentHandler **ppContentHandler)
 415 {
 416     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 417
 418     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI saxxmlreader_putContentHandler(
 423     IVBSAXXMLReader* iface,
 424     IVBSAXContentHandler *contentHandler)
 425 {
 426     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 427
 428     FIXME("(%p)->(%p) stub\n", This, contentHandler);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI saxxmlreader_getDTDHandler(
 433     IVBSAXXMLReader* iface,
 434     IVBSAXDTDHandler **pDTDHandler)
 435 {
 436     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 437
 438     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI saxxmlreader_putDTDHandler(
 443     IVBSAXXMLReader* iface,
 444     IVBSAXDTDHandler *pDTDHandler)
 445 {
 446     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 447
 448     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI saxxmlreader_getErrorHandler(
 453     IVBSAXXMLReader* iface,
 454     IVBSAXErrorHandler **pErrorHandler)
 455 {
 456     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 457
 458     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI saxxmlreader_putErrorHandler(
 463     IVBSAXXMLReader* iface,
 464     IVBSAXErrorHandler *errorHandler)
 465 {
 466     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 467
 468     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI saxxmlreader_getBaseURL(
 473     IVBSAXXMLReader* iface,
 474     const WCHAR **pBaseUrl)
 475 {
 476     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 477
 478     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI saxxmlreader_putBaseURL(
 483     IVBSAXXMLReader* iface,
 484     const WCHAR *pBaseUrl)
 485 {
 486     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 487
 488     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
 493     IVBSAXXMLReader* iface,
 494     const WCHAR **pSecureBaseUrl)
 495 {
 496     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 497
 498     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 499     return E_NOTIMPL;
 500 }
 501
 502
 503 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
 504     IVBSAXXMLReader* iface,
 505     const WCHAR *secureBaseUrl)
 506 {
 507     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 508
 509     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI saxxmlreader_parse(
 514     IVBSAXXMLReader* iface,
 515     VARIANT varInput)
 516 {
 517     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 518
 519     FIXME("(%p) stub\n", This);
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI saxxmlreader_parseURL(
 524     IVBSAXXMLReader* iface,
 525     const WCHAR *url)
 526 {
 527     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 528
 529     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 530     return E_NOTIMPL;
 531 }
 532
 533 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
 534 {
 535     saxxmlreader_QueryInterface,
 536     saxxmlreader_AddRef,
 537     saxxmlreader_Release,
 538     saxxmlreader_GetTypeInfoCount,
 539     saxxmlreader_GetTypeInfo,
 540     saxxmlreader_GetIDsOfNames,
 541     saxxmlreader_Invoke,
 542     saxxmlreader_getFeature,
 543     saxxmlreader_putFeature,
 544     saxxmlreader_getProperty,
 545     saxxmlreader_putProperty,
 546     saxxmlreader_getEntityResolver,
 547     saxxmlreader_putEntityResolver,
 548     saxxmlreader_getContentHandler,
 549     saxxmlreader_putContentHandler,
 550     saxxmlreader_getDTDHandler,
 551     saxxmlreader_putDTDHandler,
 552     saxxmlreader_getErrorHandler,
 553     saxxmlreader_putErrorHandler,
 554     saxxmlreader_getBaseURL,
 555     saxxmlreader_putBaseURL,
 556     saxxmlreader_getSecureBaseURL,
 557     saxxmlreader_putSecureBaseURL,
 558     saxxmlreader_parse,
 559     saxxmlreader_parseURL
 560 };
 561
 562 /*** ISAXXMLReader interface ***/
 563 /*** IUnknown methods ***/
 564 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
 565 {
 566     saxreader *This = impl_from_ISAXXMLReader( iface );
 567     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVtbl, riid, ppvObject);
 568 }
 569
 570 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
 571 {
 572     saxreader *This = impl_from_ISAXXMLReader( iface );
 573     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVtbl);
 574 }
 575
 576 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
 577 {
 578     saxreader *This = impl_from_ISAXXMLReader( iface );
 579     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVtbl);
 580 }
 581
 582 /*** ISAXXMLReader methods ***/
 583 static HRESULT WINAPI isaxxmlreader_getFeature(
 584         ISAXXMLReader* iface,
 585         const WCHAR *pFeature,
 586         VARIANT_BOOL *pValue)
 587 {
 588     saxreader *This = impl_from_ISAXXMLReader( iface );
 589
 590     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI isaxxmlreader_putFeature(
 595         ISAXXMLReader* iface,
 596         const WCHAR *pFeature,
 597         VARIANT_BOOL vfValue)
 598 {
 599     saxreader *This = impl_from_ISAXXMLReader( iface );
 600
 601     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI isaxxmlreader_getProperty(
 606         ISAXXMLReader* iface,
 607         const WCHAR *pProp,
 608         VARIANT *pValue)
 609 {
 610     saxreader *This = impl_from_ISAXXMLReader( iface );
 611
 612     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI isaxxmlreader_putProperty(
 617         ISAXXMLReader* iface,
 618         const WCHAR *pProp,
 619         VARIANT value)
 620 {
 621     saxreader *This = impl_from_ISAXXMLReader( iface );
 622
 623     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
 628         ISAXXMLReader* iface,
 629         ISAXEntityResolver **ppEntityResolver)
 630 {
 631     saxreader *This = impl_from_ISAXXMLReader( iface );
 632
 633     FIXME("(%p)->(%p) stub\n", This, ppEntityResolver);
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
 638         ISAXXMLReader* iface,
 639         ISAXEntityResolver *pEntityResolver)
 640 {
 641     saxreader *This = impl_from_ISAXXMLReader( iface );
 642
 643     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI isaxxmlreader_getContentHandler(
 648         ISAXXMLReader* iface,
 649         ISAXContentHandler **pContentHandler)
 650 {
 651     saxreader *This = impl_from_ISAXXMLReader( iface );
 652
 653     TRACE("(%p)->(%p)\n", This, pContentHandler);
 654     if(pContentHandler == NULL)
 655         return E_POINTER;
 656     if(This->contentHandler)
 657         ISAXContentHandler_AddRef(This->contentHandler);
 658     *pContentHandler = This->contentHandler;
 659
 660     return S_OK;
 661 }
 662
 663 static HRESULT WINAPI isaxxmlreader_putContentHandler(
 664         ISAXXMLReader* iface,
 665         ISAXContentHandler *contentHandler)
 666 {
 667     saxreader *This = impl_from_ISAXXMLReader( iface );
 668
 669     TRACE("(%p)->(%p)\n", This, contentHandler);
 670     if(contentHandler)
 671         ISAXContentHandler_AddRef(contentHandler);
 672     if(This->contentHandler)
 673         ISAXContentHandler_Release(This->contentHandler);
 674     This->contentHandler = contentHandler;
 675
 676     return S_OK;
 677 }
 678
 679 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
 680         ISAXXMLReader* iface,
 681         ISAXDTDHandler **pDTDHandler)
 682 {
 683     saxreader *This = impl_from_ISAXXMLReader( iface );
 684
 685     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
 690         ISAXXMLReader* iface,
 691         ISAXDTDHandler *pDTDHandler)
 692 {
 693     saxreader *This = impl_from_ISAXXMLReader( iface );
 694
 695     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
 700         ISAXXMLReader* iface,
 701         ISAXErrorHandler **pErrorHandler)
 702 {
 703     saxreader *This = impl_from_ISAXXMLReader( iface );
 704
 705     TRACE("(%p)->(%p)\n", This, pErrorHandler);
 706     if(pErrorHandler == NULL)
 707         return E_POINTER;
 708     if(This->errorHandler)
 709         ISAXErrorHandler_AddRef(This->errorHandler);
 710     *pErrorHandler = This->errorHandler;
 711
 712     return S_OK;
 713 }
 714
 715 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
 716         ISAXXMLReader* iface,
 717         ISAXErrorHandler *errorHandler)
 718 {
 719     saxreader *This = impl_from_ISAXXMLReader( iface );
 720
 721     TRACE("(%p)->(%p)\n", This, errorHandler);
 722     if(errorHandler)
 723         ISAXErrorHandler_AddRef(errorHandler);
 724     if(This->errorHandler)
 725         ISAXErrorHandler_Release(This->errorHandler);
 726     This->errorHandler = errorHandler;
 727
 728     return S_OK;
 729 }
 730
 731 static HRESULT WINAPI isaxxmlreader_getBaseURL(
 732         ISAXXMLReader* iface,
 733         const WCHAR **pBaseUrl)
 734 {
 735     saxreader *This = impl_from_ISAXXMLReader( iface );
 736
 737     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 738     return E_NOTIMPL;
 739 }
 740
 741 static HRESULT WINAPI isaxxmlreader_putBaseURL(
 742         ISAXXMLReader* iface,
 743         const WCHAR *pBaseUrl)
 744 {
 745     saxreader *This = impl_from_ISAXXMLReader( iface );
 746
 747     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
 752         ISAXXMLReader* iface,
 753         const WCHAR **pSecureBaseUrl)
 754 {
 755     saxreader *This = impl_from_ISAXXMLReader( iface );
 756
 757     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
 762         ISAXXMLReader* iface,
 763         const WCHAR *secureBaseUrl)
 764 {
 765     saxreader *This = impl_from_ISAXXMLReader( iface );
 766
 767     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 768     return E_NOTIMPL;
 769 }
 770
 771 static HRESULT WINAPI isaxxmlreader_parse(
 772         ISAXXMLReader* iface,
 773         VARIANT varInput)
 774 {
 775     saxreader *This = impl_from_ISAXXMLReader( iface );
 776
 777     FIXME("(%p) stub\n", This);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI isaxxmlreader_parseURL(
 782         ISAXXMLReader* iface,
 783         const WCHAR *url)
 784 {
 785     saxreader *This = impl_from_ISAXXMLReader( iface );
 786
 787     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 788     return E_NOTIMPL;
 789 }
 790
 791 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
 792 {
 793     isaxxmlreader_QueryInterface,
 794     isaxxmlreader_AddRef,
 795     isaxxmlreader_Release,
 796     isaxxmlreader_getFeature,
 797     isaxxmlreader_putFeature,
 798     isaxxmlreader_getProperty,
 799     isaxxmlreader_putProperty,
 800     isaxxmlreader_getEntityResolver,
 801     isaxxmlreader_putEntityResolver,
 802     isaxxmlreader_getContentHandler,
 803     isaxxmlreader_putContentHandler,
 804     isaxxmlreader_getDTDHandler,
 805     isaxxmlreader_putDTDHandler,
 806     isaxxmlreader_getErrorHandler,
 807     isaxxmlreader_putErrorHandler,
 808     isaxxmlreader_getBaseURL,
 809     isaxxmlreader_putBaseURL,
 810     isaxxmlreader_getSecureBaseURL,
 811     isaxxmlreader_putSecureBaseURL,
 812     isaxxmlreader_parse,
 813     isaxxmlreader_parseURL
 814 };
 815
 816 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 817 {
 818     saxreader *reader;
 819
 820     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 821
 822     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
 823     if( !reader )
 824         return E_OUTOFMEMORY;
 825
 826     reader->lpVtbl = &saxreader_vtbl;
 827     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
 828     reader->ref = 1;
 829     reader->contentHandler = NULL;
 830     reader->errorHandler = NULL;
 831
 832     *ppObj = &reader->lpVtbl;
 833
 834     TRACE("returning iface %p\n", *ppObj);
 835
 836     return S_OK;
 837 }
 838
 839 #else
 840
 841 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 842 {
 843     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
 844             "libxml2 support was not present at compile time.\n");
 845     return E_NOTIMPL;
 846 }
 847
 848 #endif