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     HRESULT ret;
  64     xmlParserCtxtPtr pParserCtxt;
  65     WCHAR *publicId;
  66     WCHAR *systemId;
  67     int lastLine;
  68     int lastColumn;
  69 } saxlocator;
  70
  71 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  72 {
  73     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  74 }
  75
  76 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  77 {
  78     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
  79 }
  80
  81 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
  82 {
  83     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
  84 }
  85
  86 /*** LibXML callbacks ***/
  87 static void libxmlStartDocument(void *ctx)
  88 {
  89     saxlocator *This = ctx;
  90     HRESULT hr;
  91
  92     if(This->saxreader->contentHandler)
  93     {
  94         hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
  95         if(FAILED(hr))
  96         {
  97             xmlStopParser(This->pParserCtxt);
  98             This->ret = hr;
  99         }
 100     }
 101
 102     This->lastColumn = xmlSAX2GetColumnNumber(This->pParserCtxt);
 103     This->lastLine = xmlSAX2GetLineNumber(This->pParserCtxt);
 104 }
 105
 106 static void libxmlEndDocument(void *ctx)
 107 {
 108     saxlocator *This = ctx;
 109     HRESULT hr;
 110
 111     This->lastColumn = 0;
 112     This->lastLine = 0;
 113
 114     if(This->saxreader->contentHandler)
 115     {
 116         hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
 117         if(FAILED(hr))
 118         {
 119             xmlStopParser(This->pParserCtxt);
 120             This->ret = hr;
 121         }
 122     }
 123 }
 124
 125 static void libxmlStartElementNS(
 126         void *ctx,
 127         const xmlChar *localname,
 128         const xmlChar *prefix,
 129         const xmlChar *URI,
 130         int nb_namespaces,
 131         const xmlChar **namespaces,
 132         int nb_attributes,
 133         int nb_defaulted,
 134         const xmlChar **attributes)
 135 {
 136     BSTR NamespaceUri, LocalName, QName;
 137     saxlocator *This = ctx;
 138     HRESULT hr;
 139
 140     FIXME("Arguments processing not yet implemented.\n");
 141
 142     This->lastColumn = xmlSAX2GetColumnNumber(This->pParserCtxt)+1;
 143     This->lastLine = xmlSAX2GetLineNumber(This->pParserCtxt);
 144
 145     if(This->saxreader->contentHandler)
 146     {
 147         NamespaceUri = bstr_from_xmlChar(URI);
 148         LocalName = bstr_from_xmlChar(localname);
 149         QName = bstr_from_xmlChar(localname);
 150
 151         hr = ISAXContentHandler_startElement(
 152                 This->saxreader->contentHandler,
 153                 NamespaceUri, SysStringLen(NamespaceUri),
 154                 LocalName, SysStringLen(LocalName),
 155                 QName, SysStringLen(QName),
 156                 NULL);
 157
 158         SysFreeString(NamespaceUri);
 159         SysFreeString(LocalName);
 160         SysFreeString(QName);
 161
 162         if(FAILED(hr))
 163         {
 164             xmlStopParser(This->pParserCtxt);
 165             This->ret = hr;
 166         }
 167     }
 168 }
 169
 170 static void libxmlEndElementNS(
 171         void *ctx,
 172         const xmlChar *localname,
 173         const xmlChar *prefix,
 174         const xmlChar *URI)
 175 {
 176     BSTR NamespaceUri, LocalName, QName;
 177     saxlocator *This = ctx;
 178     HRESULT hr;
 179
 180     This->lastColumn = xmlSAX2GetColumnNumber(This->pParserCtxt);
 181     This->lastLine = xmlSAX2GetLineNumber(This->pParserCtxt);
 182
 183     if(This->saxreader->contentHandler)
 184     {
 185         NamespaceUri = bstr_from_xmlChar(URI);
 186         LocalName = bstr_from_xmlChar(localname);
 187         QName = bstr_from_xmlChar(localname);
 188
 189         hr = ISAXContentHandler_endElement(
 190                 This->saxreader->contentHandler,
 191                 NamespaceUri, SysStringLen(NamespaceUri),
 192                 LocalName, SysStringLen(LocalName),
 193                 QName, SysStringLen(QName));
 194
 195         SysFreeString(NamespaceUri);
 196         SysFreeString(LocalName);
 197         SysFreeString(QName);
 198
 199         if(FAILED(hr))
 200         {
 201             xmlStopParser(This->pParserCtxt);
 202             This->ret = hr;
 203         }
 204     }
 205 }
 206
 207 static void libxmlCharacters(
 208         void *ctx,
 209         const xmlChar *ch,
 210         int len)
 211 {
 212     BSTR Chars;
 213     saxlocator *This = ctx;
 214     const xmlChar *cur;
 215     int pos;
 216     HRESULT hr;
 217
 218     This->lastColumn = 1;
 219     This->lastLine = xmlSAX2GetLineNumber(This->pParserCtxt);
 220
 221     cur = This->pParserCtxt->input->cur;
 222     if(*cur != '<')
 223     {
 224         for(pos=0; pos<len; pos++)
 225             if(*(cur+pos) == '\n') This->lastLine--;
 226         cur--;
 227     }
 228     else
 229     {
 230         for(pos=0; pos<len; pos++)
 231             if(*(cur-pos-1) == '\n') This->lastLine--;
 232         cur = cur-len-1;
 233     }
 234     for(; *cur!='\n' && cur!=This->pParserCtxt->input->base; cur--)
 235         This->lastColumn++;
 236
 237     if(This->saxreader->contentHandler)
 238     {
 239         Chars = bstr_from_xmlChar(ch);
 240         hr = ISAXContentHandler_characters(This->saxreader->contentHandler, Chars, len);
 241         SysFreeString(Chars);
 242
 243         if(FAILED(hr))
 244         {
 245             xmlStopParser(This->pParserCtxt);
 246             This->ret = hr;
 247         }
 248     }
 249 }
 250
 251 static void libxmlSetDocumentLocator(
 252         void *ctx,
 253         xmlSAXLocatorPtr loc)
 254 {
 255     saxlocator *This = ctx;
 256     HRESULT hr;
 257
 258     hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
 259             (ISAXLocator*)&This->lpSAXLocatorVtbl);
 260
 261     if(FAILED(hr))
 262     {
 263         xmlStopParser(This->pParserCtxt);
 264         This->ret = hr;
 265     }
 266 }
 267
 268 /*** ISAXLocator interface ***/
 269 /*** IUnknown methods ***/
 270 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
 271 {
 272     saxlocator *This = impl_from_ISAXLocator( iface );
 273
 274     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 275
 276     *ppvObject = NULL;
 277
 278     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 279             IsEqualGUID( riid, &IID_ISAXLocator ))
 280     {
 281         *ppvObject = iface;
 282     }
 283     else
 284     {
 285         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 286         return E_NOINTERFACE;
 287     }
 288
 289     ISAXLocator_AddRef( iface );
 290
 291     return S_OK;
 292 }
 293
 294 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
 295 {
 296     saxlocator *This = impl_from_ISAXLocator( iface );
 297     TRACE("%p\n", This );
 298     return InterlockedIncrement( &This->ref );
 299 }
 300
 301 static ULONG WINAPI isaxlocator_Release(
 302         ISAXLocator* iface)
 303 {
 304     saxlocator *This = impl_from_ISAXLocator( iface );
 305     LONG ref;
 306
 307     TRACE("%p\n", This );
 308
 309     ref = InterlockedDecrement( &This->ref );
 310     if ( ref == 0 )
 311     {
 312         if(This->publicId)
 313             SysFreeString(This->publicId);
 314         if(This->systemId)
 315             SysFreeString(This->systemId);
 316
 317         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
 318         HeapFree( GetProcessHeap(), 0, This );
 319     }
 320
 321     return ref;
 322 }
 323
 324 /*** ISAXLocator methods ***/
 325 static HRESULT WINAPI isaxlocator_getColumnNumber(
 326         ISAXLocator* iface,
 327         int *pnColumn)
 328 {
 329     saxlocator *This = impl_from_ISAXLocator( iface );
 330
 331     *pnColumn = This->lastColumn;
 332     return S_OK;
 333 }
 334
 335 static HRESULT WINAPI isaxlocator_getLineNumber(
 336         ISAXLocator* iface,
 337         int *pnLine)
 338 {
 339     saxlocator *This = impl_from_ISAXLocator( iface );
 340
 341     *pnLine = This->lastLine;
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI isaxlocator_getPublicId(
 346         ISAXLocator* iface,
 347         const WCHAR ** ppwchPublicId)
 348 {
 349     BSTR publicId;
 350     saxlocator *This = impl_from_ISAXLocator( iface );
 351
 352     if(This->publicId) SysFreeString(This->publicId);
 353
 354     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
 355     if(SysStringLen(publicId))
 356         This->publicId = (WCHAR*)&publicId;
 357     else
 358     {
 359         SysFreeString(publicId);
 360         This->publicId = NULL;
 361     }
 362
 363     *ppwchPublicId = This->publicId;
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI isaxlocator_getSystemId(
 368         ISAXLocator* iface,
 369         const WCHAR ** ppwchSystemId)
 370 {
 371     BSTR systemId;
 372     saxlocator *This = impl_from_ISAXLocator( iface );
 373
 374     if(This->systemId) SysFreeString(This->systemId);
 375
 376     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
 377     if(SysStringLen(systemId))
 378         This->systemId = (WCHAR*)&systemId;
 379     else
 380     {
 381         SysFreeString(systemId);
 382         This->systemId = NULL;
 383     }
 384
 385     *ppwchSystemId = This->systemId;
 386     return S_OK;
 387 }
 388
 389 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
 390 {
 391     isaxlocator_QueryInterface,
 392     isaxlocator_AddRef,
 393     isaxlocator_Release,
 394     isaxlocator_getColumnNumber,
 395     isaxlocator_getLineNumber,
 396     isaxlocator_getPublicId,
 397     isaxlocator_getSystemId
 398 };
 399
 400 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator)
 401 {
 402     saxlocator *locator;
 403
 404     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
 405     if( !locator )
 406         return E_OUTOFMEMORY;
 407
 408     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
 409     locator->ref = 1;
 410
 411     locator->saxreader = reader;
 412     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
 413
 414     locator->pParserCtxt = NULL;
 415     locator->publicId = NULL;
 416     locator->systemId = NULL;
 417     locator->lastLine = 0;
 418     locator->lastColumn = 0;
 419     locator->ret = S_OK;
 420
 421     *ppsaxlocator = locator;
 422
 423     TRACE("returning %p\n", *ppsaxlocator);
 424
 425     return S_OK;
 426 }
 427
 428 /*** IVBSAXXMLReader interface ***/
 429 /*** IUnknown methods ***/
 430 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
 431 {
 432     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 433
 434     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 435
 436     *ppvObject = NULL;
 437
 438     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 439          IsEqualGUID( riid, &IID_IDispatch ) ||
 440          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
 441     {
 442         *ppvObject = iface;
 443     }
 444     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
 445     {
 446         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
 447     }
 448     else
 449     {
 450         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 451         return E_NOINTERFACE;
 452     }
 453
 454     IVBSAXXMLReader_AddRef( iface );
 455
 456     return S_OK;
 457 }
 458
 459 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
 460 {
 461     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 462     TRACE("%p\n", This );
 463     return InterlockedIncrement( &This->ref );
 464 }
 465
 466 static ULONG WINAPI saxxmlreader_Release(
 467     IVBSAXXMLReader* iface)
 468 {
 469     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 470     LONG ref;
 471
 472     TRACE("%p\n", This );
 473
 474     ref = InterlockedDecrement( &This->ref );
 475     if ( ref == 0 )
 476     {
 477         if(This->contentHandler)
 478             ISAXContentHandler_Release(This->contentHandler);
 479
 480         if(This->errorHandler)
 481             ISAXErrorHandler_Release(This->errorHandler);
 482
 483         HeapFree( GetProcessHeap(), 0, This );
 484     }
 485
 486     return ref;
 487 }
 488 /*** IDispatch ***/
 489 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 490 {
 491     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 492
 493     TRACE("(%p)->(%p)\n", This, pctinfo);
 494
 495     *pctinfo = 1;
 496
 497     return S_OK;
 498 }
 499
 500 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 501     IVBSAXXMLReader *iface,
 502     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 503 {
 504     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 505     HRESULT hr;
 506
 507     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 508
 509     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 510
 511     return hr;
 512 }
 513
 514 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 515     IVBSAXXMLReader *iface,
 516     REFIID riid,
 517     LPOLESTR* rgszNames,
 518     UINT cNames,
 519     LCID lcid,
 520     DISPID* rgDispId)
 521 {
 522     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 523     ITypeInfo *typeinfo;
 524     HRESULT hr;
 525
 526     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 527           lcid, rgDispId);
 528
 529     if(!rgszNames || cNames == 0 || !rgDispId)
 530         return E_INVALIDARG;
 531
 532     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 533     if(SUCCEEDED(hr))
 534     {
 535         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 536         ITypeInfo_Release(typeinfo);
 537     }
 538
 539     return hr;
 540 }
 541
 542 static HRESULT WINAPI saxxmlreader_Invoke(
 543     IVBSAXXMLReader *iface,
 544     DISPID dispIdMember,
 545     REFIID riid,
 546     LCID lcid,
 547     WORD wFlags,
 548     DISPPARAMS* pDispParams,
 549     VARIANT* pVarResult,
 550     EXCEPINFO* pExcepInfo,
 551     UINT* puArgErr)
 552 {
 553     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 554     ITypeInfo *typeinfo;
 555     HRESULT hr;
 556
 557     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 558           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 559
 560     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 561     if(SUCCEEDED(hr))
 562     {
 563         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 564                 pVarResult, pExcepInfo, puArgErr);
 565         ITypeInfo_Release(typeinfo);
 566     }
 567
 568     return hr;
 569 }
 570
 571 /*** IVBSAXXMLReader methods ***/
 572 static HRESULT WINAPI saxxmlreader_getFeature(
 573     IVBSAXXMLReader* iface,
 574     const WCHAR *pFeature,
 575     VARIANT_BOOL *pValue)
 576 {
 577     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 578
 579     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI saxxmlreader_putFeature(
 584     IVBSAXXMLReader* iface,
 585     const WCHAR *pFeature,
 586     VARIANT_BOOL vfValue)
 587 {
 588     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 589
 590     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI saxxmlreader_getProperty(
 595     IVBSAXXMLReader* iface,
 596     const WCHAR *pProp,
 597     VARIANT *pValue)
 598 {
 599     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 600
 601     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI saxxmlreader_putProperty(
 606     IVBSAXXMLReader* iface,
 607     const WCHAR *pProp,
 608     VARIANT value)
 609 {
 610     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 611
 612     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI saxxmlreader_getEntityResolver(
 617     IVBSAXXMLReader* iface,
 618     IVBSAXEntityResolver **pEntityResolver)
 619 {
 620     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 621
 622     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI saxxmlreader_putEntityResolver(
 627     IVBSAXXMLReader* iface,
 628     IVBSAXEntityResolver *pEntityResolver)
 629 {
 630     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 631
 632     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI saxxmlreader_getContentHandler(
 637     IVBSAXXMLReader* iface,
 638     IVBSAXContentHandler **ppContentHandler)
 639 {
 640     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 641
 642     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
 643     return E_NOTIMPL;
 644 }
 645
 646 static HRESULT WINAPI saxxmlreader_putContentHandler(
 647     IVBSAXXMLReader* iface,
 648     IVBSAXContentHandler *contentHandler)
 649 {
 650     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 651
 652     FIXME("(%p)->(%p) stub\n", This, contentHandler);
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI saxxmlreader_getDTDHandler(
 657     IVBSAXXMLReader* iface,
 658     IVBSAXDTDHandler **pDTDHandler)
 659 {
 660     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 661
 662     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI saxxmlreader_putDTDHandler(
 667     IVBSAXXMLReader* iface,
 668     IVBSAXDTDHandler *pDTDHandler)
 669 {
 670     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 671
 672     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI saxxmlreader_getErrorHandler(
 677     IVBSAXXMLReader* iface,
 678     IVBSAXErrorHandler **pErrorHandler)
 679 {
 680     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 681
 682     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 683     return E_NOTIMPL;
 684 }
 685
 686 static HRESULT WINAPI saxxmlreader_putErrorHandler(
 687     IVBSAXXMLReader* iface,
 688     IVBSAXErrorHandler *errorHandler)
 689 {
 690     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 691
 692     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI saxxmlreader_getBaseURL(
 697     IVBSAXXMLReader* iface,
 698     const WCHAR **pBaseUrl)
 699 {
 700     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 701
 702     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI saxxmlreader_putBaseURL(
 707     IVBSAXXMLReader* iface,
 708     const WCHAR *pBaseUrl)
 709 {
 710     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 711
 712     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
 717     IVBSAXXMLReader* iface,
 718     const WCHAR **pSecureBaseUrl)
 719 {
 720     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 721
 722     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 723     return E_NOTIMPL;
 724 }
 725
 726
 727 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
 728     IVBSAXXMLReader* iface,
 729     const WCHAR *secureBaseUrl)
 730 {
 731     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 732
 733     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI saxxmlreader_parse(
 738     IVBSAXXMLReader* iface,
 739     VARIANT varInput)
 740 {
 741     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 742
 743     FIXME("(%p) stub\n", This);
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI saxxmlreader_parseURL(
 748     IVBSAXXMLReader* iface,
 749     const WCHAR *url)
 750 {
 751     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 752
 753     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 754     return E_NOTIMPL;
 755 }
 756
 757 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
 758 {
 759     saxxmlreader_QueryInterface,
 760     saxxmlreader_AddRef,
 761     saxxmlreader_Release,
 762     saxxmlreader_GetTypeInfoCount,
 763     saxxmlreader_GetTypeInfo,
 764     saxxmlreader_GetIDsOfNames,
 765     saxxmlreader_Invoke,
 766     saxxmlreader_getFeature,
 767     saxxmlreader_putFeature,
 768     saxxmlreader_getProperty,
 769     saxxmlreader_putProperty,
 770     saxxmlreader_getEntityResolver,
 771     saxxmlreader_putEntityResolver,
 772     saxxmlreader_getContentHandler,
 773     saxxmlreader_putContentHandler,
 774     saxxmlreader_getDTDHandler,
 775     saxxmlreader_putDTDHandler,
 776     saxxmlreader_getErrorHandler,
 777     saxxmlreader_putErrorHandler,
 778     saxxmlreader_getBaseURL,
 779     saxxmlreader_putBaseURL,
 780     saxxmlreader_getSecureBaseURL,
 781     saxxmlreader_putSecureBaseURL,
 782     saxxmlreader_parse,
 783     saxxmlreader_parseURL
 784 };
 785
 786 /*** ISAXXMLReader interface ***/
 787 /*** IUnknown methods ***/
 788 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
 789 {
 790     saxreader *This = impl_from_ISAXXMLReader( iface );
 791     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVtbl, riid, ppvObject);
 792 }
 793
 794 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
 795 {
 796     saxreader *This = impl_from_ISAXXMLReader( iface );
 797     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVtbl);
 798 }
 799
 800 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
 801 {
 802     saxreader *This = impl_from_ISAXXMLReader( iface );
 803     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVtbl);
 804 }
 805
 806 /*** ISAXXMLReader methods ***/
 807 static HRESULT WINAPI isaxxmlreader_getFeature(
 808         ISAXXMLReader* iface,
 809         const WCHAR *pFeature,
 810         VARIANT_BOOL *pValue)
 811 {
 812     saxreader *This = impl_from_ISAXXMLReader( iface );
 813
 814     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI isaxxmlreader_putFeature(
 819         ISAXXMLReader* iface,
 820         const WCHAR *pFeature,
 821         VARIANT_BOOL vfValue)
 822 {
 823     saxreader *This = impl_from_ISAXXMLReader( iface );
 824
 825     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI isaxxmlreader_getProperty(
 830         ISAXXMLReader* iface,
 831         const WCHAR *pProp,
 832         VARIANT *pValue)
 833 {
 834     saxreader *This = impl_from_ISAXXMLReader( iface );
 835
 836     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI isaxxmlreader_putProperty(
 841         ISAXXMLReader* iface,
 842         const WCHAR *pProp,
 843         VARIANT value)
 844 {
 845     saxreader *This = impl_from_ISAXXMLReader( iface );
 846
 847     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 848     return E_NOTIMPL;
 849 }
 850
 851 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
 852         ISAXXMLReader* iface,
 853         ISAXEntityResolver **ppEntityResolver)
 854 {
 855     saxreader *This = impl_from_ISAXXMLReader( iface );
 856
 857     FIXME("(%p)->(%p) stub\n", This, ppEntityResolver);
 858     return E_NOTIMPL;
 859 }
 860
 861 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
 862         ISAXXMLReader* iface,
 863         ISAXEntityResolver *pEntityResolver)
 864 {
 865     saxreader *This = impl_from_ISAXXMLReader( iface );
 866
 867     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 868     return E_NOTIMPL;
 869 }
 870
 871 static HRESULT WINAPI isaxxmlreader_getContentHandler(
 872         ISAXXMLReader* iface,
 873         ISAXContentHandler **pContentHandler)
 874 {
 875     saxreader *This = impl_from_ISAXXMLReader( iface );
 876
 877     TRACE("(%p)->(%p)\n", This, pContentHandler);
 878     if(pContentHandler == NULL)
 879         return E_POINTER;
 880     if(This->contentHandler)
 881         ISAXContentHandler_AddRef(This->contentHandler);
 882     *pContentHandler = This->contentHandler;
 883
 884     return S_OK;
 885 }
 886
 887 static HRESULT WINAPI isaxxmlreader_putContentHandler(
 888         ISAXXMLReader* iface,
 889         ISAXContentHandler *contentHandler)
 890 {
 891     saxreader *This = impl_from_ISAXXMLReader( iface );
 892
 893     TRACE("(%p)->(%p)\n", This, contentHandler);
 894     if(contentHandler)
 895         ISAXContentHandler_AddRef(contentHandler);
 896     if(This->contentHandler)
 897         ISAXContentHandler_Release(This->contentHandler);
 898     This->contentHandler = contentHandler;
 899
 900     return S_OK;
 901 }
 902
 903 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
 904         ISAXXMLReader* iface,
 905         ISAXDTDHandler **pDTDHandler)
 906 {
 907     saxreader *This = impl_from_ISAXXMLReader( iface );
 908
 909     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 910     return E_NOTIMPL;
 911 }
 912
 913 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
 914         ISAXXMLReader* iface,
 915         ISAXDTDHandler *pDTDHandler)
 916 {
 917     saxreader *This = impl_from_ISAXXMLReader( iface );
 918
 919     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 920     return E_NOTIMPL;
 921 }
 922
 923 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
 924         ISAXXMLReader* iface,
 925         ISAXErrorHandler **pErrorHandler)
 926 {
 927     saxreader *This = impl_from_ISAXXMLReader( iface );
 928
 929     TRACE("(%p)->(%p)\n", This, pErrorHandler);
 930     if(pErrorHandler == NULL)
 931         return E_POINTER;
 932     if(This->errorHandler)
 933         ISAXErrorHandler_AddRef(This->errorHandler);
 934     *pErrorHandler = This->errorHandler;
 935
 936     return S_OK;
 937 }
 938
 939 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
 940         ISAXXMLReader* iface,
 941         ISAXErrorHandler *errorHandler)
 942 {
 943     saxreader *This = impl_from_ISAXXMLReader( iface );
 944
 945     TRACE("(%p)->(%p)\n", This, errorHandler);
 946     if(errorHandler)
 947         ISAXErrorHandler_AddRef(errorHandler);
 948     if(This->errorHandler)
 949         ISAXErrorHandler_Release(This->errorHandler);
 950     This->errorHandler = errorHandler;
 951
 952     return S_OK;
 953 }
 954
 955 static HRESULT WINAPI isaxxmlreader_getBaseURL(
 956         ISAXXMLReader* iface,
 957         const WCHAR **pBaseUrl)
 958 {
 959     saxreader *This = impl_from_ISAXXMLReader( iface );
 960
 961     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 962     return E_NOTIMPL;
 963 }
 964
 965 static HRESULT WINAPI isaxxmlreader_putBaseURL(
 966         ISAXXMLReader* iface,
 967         const WCHAR *pBaseUrl)
 968 {
 969     saxreader *This = impl_from_ISAXXMLReader( iface );
 970
 971     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
 976         ISAXXMLReader* iface,
 977         const WCHAR **pSecureBaseUrl)
 978 {
 979     saxreader *This = impl_from_ISAXXMLReader( iface );
 980
 981     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 982     return E_NOTIMPL;
 983 }
 984
 985 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
 986         ISAXXMLReader* iface,
 987         const WCHAR *secureBaseUrl)
 988 {
 989     saxreader *This = impl_from_ISAXXMLReader( iface );
 990
 991     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 992     return E_NOTIMPL;
 993 }
 994
 995 static HRESULT WINAPI isaxxmlreader_parse(
 996         ISAXXMLReader* iface,
 997         VARIANT varInput)
 998 {
 999     saxreader *This = impl_from_ISAXXMLReader( iface );
1000     saxlocator *locator;
1001     xmlChar *data = NULL;
1002     HRESULT hr;
1003
1004     FIXME("(%p) semi-stub\n", This);
1005
1006     hr = SAXLocator_create(This, &locator);
1007     if(FAILED(hr))
1008         return E_FAIL;
1009
1010     hr = S_OK;
1011     switch(V_VT(&varInput))
1012     {
1013         case VT_BSTR:
1014             locator->pParserCtxt = xmlNewParserCtxt();
1015             if(!locator->pParserCtxt)
1016             {
1017                 hr = E_FAIL;
1018                 break;
1019             }
1020             data = xmlChar_from_wchar(V_BSTR(&varInput));
1021             xmlSetupParserForBuffer(locator->pParserCtxt, data, NULL);
1022
1023             locator->pParserCtxt->sax = &locator->saxreader->sax;
1024             locator->pParserCtxt->userData = locator;
1025
1026             if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1027             else hr = locator->ret;
1028             break;
1029         default:
1030             hr = E_NOTIMPL;
1031     }
1032
1033     if(locator->pParserCtxt)
1034     {
1035         locator->pParserCtxt->sax = NULL;
1036         xmlFreeParserCtxt(locator->pParserCtxt);
1037         locator->pParserCtxt = NULL;
1038     }
1039     HeapFree(GetProcessHeap(), 0, data);
1040     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1041     return hr;
1042 }
1043
1044 static HRESULT WINAPI isaxxmlreader_parseURL(
1045         ISAXXMLReader* iface,
1046         const WCHAR *url)
1047 {
1048     saxreader *This = impl_from_ISAXXMLReader( iface );
1049
1050     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
1051     return E_NOTIMPL;
1052 }
1053
1054 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
1055 {
1056     isaxxmlreader_QueryInterface,
1057     isaxxmlreader_AddRef,
1058     isaxxmlreader_Release,
1059     isaxxmlreader_getFeature,
1060     isaxxmlreader_putFeature,
1061     isaxxmlreader_getProperty,
1062     isaxxmlreader_putProperty,
1063     isaxxmlreader_getEntityResolver,
1064     isaxxmlreader_putEntityResolver,
1065     isaxxmlreader_getContentHandler,
1066     isaxxmlreader_putContentHandler,
1067     isaxxmlreader_getDTDHandler,
1068     isaxxmlreader_putDTDHandler,
1069     isaxxmlreader_getErrorHandler,
1070     isaxxmlreader_putErrorHandler,
1071     isaxxmlreader_getBaseURL,
1072     isaxxmlreader_putBaseURL,
1073     isaxxmlreader_getSecureBaseURL,
1074     isaxxmlreader_putSecureBaseURL,
1075     isaxxmlreader_parse,
1076     isaxxmlreader_parseURL
1077 };
1078
1079 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1080 {
1081     saxreader *reader;
1082
1083     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1084
1085     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
1086     if( !reader )
1087         return E_OUTOFMEMORY;
1088
1089     reader->lpVtbl = &saxreader_vtbl;
1090     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
1091     reader->ref = 1;
1092     reader->contentHandler = NULL;
1093     reader->errorHandler = NULL;
1094
1095     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
1096     reader->sax.initialized = XML_SAX2_MAGIC;
1097     reader->sax.startDocument = libxmlStartDocument;
1098     reader->sax.endDocument = libxmlEndDocument;
1099     reader->sax.startElementNs = libxmlStartElementNS;
1100     reader->sax.endElementNs = libxmlEndElementNS;
1101     reader->sax.characters = libxmlCharacters;
1102     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
1103
1104     *ppObj = &reader->lpVtbl;
1105
1106     TRACE("returning iface %p\n", *ppObj);
1107
1108     return S_OK;
1109 }
1110
1111 #else
1112
1113 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1114 {
1115     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
1116             "libxml2 support was not present at compile time.\n");
1117     return E_NOTIMPL;
1118 }
1119
1120 #endif