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     xmlChar *lastCur;
  68     int line;
  69     int column;
  70 } saxlocator;
  71
  72 typedef struct _saxattributes
  73 {
  74     const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
  75     LONG ref;
  76 } saxattributes;
  77
  78 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  79 {
  80     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  81 }
  82
  83 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  84 {
  85     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
  86 }
  87
  88 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
  89 {
  90     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
  91 }
  92
  93 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
  94 {
  95     return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
  96 }
  97
  98
  99 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
 100 {
 101     xmlStopParser(This->pParserCtxt);
 102     This->ret = hr;
 103
 104     if(This->saxreader->errorHandler)
 105     {
 106         WCHAR msg[1024];
 107         if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
 108                     NULL, hr, 0, msg, sizeof(msg), NULL))
 109         {
 110             FIXME("MSXML errors not yet supported.\n");
 111             msg[0] = '\0';
 112         }
 113
 114         ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 115                 (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
 116     }
 117 }
 118
 119 static void update_position(saxlocator *This, xmlChar *end)
 120 {
 121     if(This->lastCur == NULL)
 122     {
 123         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 124         This->line = 1;
 125         This->column = 1;
 126     }
 127
 128     if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
 129
 130     while(This->lastCur < end)
 131     {
 132         if(*(This->lastCur) == '\n')
 133         {
 134             This->line++;
 135             This->column = 1;
 136         }
 137         else if(*(This->lastCur) == '\r' && (This->lastCur==This->pParserCtxt->input->end || *(This->lastCur+1)!='\n'))
 138         {
 139             This->line++;
 140             This->column = 1;
 141         }
 142         else This->column++;
 143
 144         This->lastCur++;
 145     }
 146 }
 147
 148 /*** ISAXAttributes interface ***/
 149 /*** IUnknown methods ***/
 150 static HRESULT WINAPI isaxattributes_QueryInterface(
 151         ISAXAttributes* iface,
 152         REFIID riid,
 153         void **ppvObject)
 154 {
 155     saxattributes *This = impl_from_ISAXAttributes(iface);
 156
 157     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 158
 159     *ppvObject = NULL;
 160
 161     if (IsEqualGUID(riid, &IID_IUnknown) ||
 162             IsEqualGUID(riid, &IID_ISAXAttributes))
 163     {
 164         *ppvObject = iface;
 165     }
 166     else
 167     {
 168         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 169         return E_NOINTERFACE;
 170     }
 171
 172     ISAXAttributes_AddRef(iface);
 173
 174     return S_OK;
 175 }
 176
 177 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
 178 {
 179     saxattributes *This = impl_from_ISAXAttributes(iface);
 180     TRACE("%p\n", This);
 181     return InterlockedIncrement(&This->ref);
 182 }
 183
 184 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
 185 {
 186     saxattributes *This = impl_from_ISAXAttributes(iface);
 187     LONG ref;
 188
 189     TRACE("%p\n", This);
 190
 191     ref = InterlockedDecrement(&This->ref);
 192     if (ref==0)
 193     {
 194         HeapFree(GetProcessHeap(), 0, This);
 195     }
 196
 197     return ref;
 198 }
 199
 200 /*** ISAXAttributes methods ***/
 201 static HRESULT WINAPI isaxattributes_getLength(
 202         ISAXAttributes* iface,
 203         int *length)
 204 {
 205     saxattributes *This = impl_from_ISAXAttributes( iface );
 206
 207     FIXME("(%p) stub\n", This);
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT WINAPI isaxattributes_getURI(
 212         ISAXAttributes* iface,
 213         int nIndex,
 214         const WCHAR **pUrl,
 215         int *pUriSize)
 216 {
 217     saxattributes *This = impl_from_ISAXAttributes( iface );
 218
 219     FIXME("(%p)->(%d) stub\n", This, nIndex);
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI isaxattributes_getLocalName(
 224         ISAXAttributes* iface,
 225         int nIndex,
 226         const WCHAR **pLocalName,
 227         int *pLocalNameLength)
 228 {
 229     saxattributes *This = impl_from_ISAXAttributes( iface );
 230
 231     FIXME("(%p)->(%d) stub\n", This, nIndex);
 232     return E_NOTIMPL;
 233 }
 234
 235 static HRESULT WINAPI isaxattributes_getQName(
 236         ISAXAttributes* iface,
 237         int nIndex,
 238         const WCHAR **pQName,
 239         int *pQNameLength)
 240 {
 241     saxattributes *This = impl_from_ISAXAttributes( iface );
 242
 243     FIXME("(%p)->(%d) stub\n", This, nIndex);
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI isaxattributes_getName(
 248         ISAXAttributes* iface,
 249         int nIndex,
 250         const WCHAR **pUri,
 251         int *pUriLength,
 252         const WCHAR **pLocalName,
 253         int *pLocalNameSize,
 254         const WCHAR **pQName,
 255         int *pQNameLength)
 256 {
 257     saxattributes *This = impl_from_ISAXAttributes( iface );
 258
 259     FIXME("(%p)->(%d) stub\n", This, nIndex);
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI isaxattributes_getIndexFromName(
 264         ISAXAttributes* iface,
 265         const WCHAR *pUri,
 266         int cUriLength,
 267         const WCHAR *pLocalName,
 268         int cocalNameLength,
 269         int *index)
 270 {
 271     saxattributes *This = impl_from_ISAXAttributes( iface );
 272
 273     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), cUriLength,
 274             debugstr_w(pLocalName), cocalNameLength);
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI isaxattributes_getIndexFromQName(
 279         ISAXAttributes* iface,
 280         const WCHAR *pQName,
 281         int nQNameLength,
 282         int *index)
 283 {
 284     saxattributes *This = impl_from_ISAXAttributes( iface );
 285
 286     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQNameLength);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI isaxattributes_getType(
 291         ISAXAttributes* iface,
 292         int nIndex,
 293         const WCHAR **pType,
 294         int *pTypeLength)
 295 {
 296     saxattributes *This = impl_from_ISAXAttributes( iface );
 297
 298     FIXME("(%p)->(%d) stub\n", This, nIndex);
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI isaxattributes_getTypeFromName(
 303         ISAXAttributes* iface,
 304         const WCHAR *pUri,
 305         int nUri,
 306         const WCHAR *pLocalName,
 307         int nLocalName,
 308         const WCHAR **pType,
 309         int *nType)
 310 {
 311     saxattributes *This = impl_from_ISAXAttributes( iface );
 312
 313     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
 314             debugstr_w(pLocalName), nLocalName);
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI isaxattributes_getTypeFromQName(
 319         ISAXAttributes* iface,
 320         const WCHAR *pQName,
 321         int nQName,
 322         const WCHAR **pType,
 323         int *nType)
 324 {
 325     saxattributes *This = impl_from_ISAXAttributes( iface );
 326
 327     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI isaxattributes_getValue(
 332         ISAXAttributes* iface,
 333         int nIndex,
 334         const WCHAR **pValue,
 335         int *nValue)
 336 {
 337     saxattributes *This = impl_from_ISAXAttributes( iface );
 338
 339     FIXME("(%p)->(%d) stub\n", This, nIndex);
 340     return E_NOTIMPL;
 341 }
 342
 343 static HRESULT WINAPI isaxattributes_getValueFromName(
 344         ISAXAttributes* iface,
 345         const WCHAR *pUri,
 346         int nUri,
 347         const WCHAR *pLocalName,
 348         int nLocalName,
 349         const WCHAR **pValue,
 350         int *nValue)
 351 {
 352     saxattributes *This = impl_from_ISAXAttributes( iface );
 353
 354     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
 355             debugstr_w(pLocalName), nLocalName);
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI isaxattributes_getValueFromQName(
 360         ISAXAttributes* iface,
 361         const WCHAR *pQName,
 362         int nQName,
 363         const WCHAR **pValue,
 364         int *nValue)
 365 {
 366     saxattributes *This = impl_from_ISAXAttributes( iface );
 367
 368     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
 369     return E_NOTIMPL;
 370 }
 371
 372 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
 373 {
 374     isaxattributes_QueryInterface,
 375     isaxattributes_AddRef,
 376     isaxattributes_Release,
 377     isaxattributes_getLength,
 378     isaxattributes_getURI,
 379     isaxattributes_getLocalName,
 380     isaxattributes_getQName,
 381     isaxattributes_getName,
 382     isaxattributes_getIndexFromName,
 383     isaxattributes_getIndexFromQName,
 384     isaxattributes_getType,
 385     isaxattributes_getTypeFromName,
 386     isaxattributes_getTypeFromQName,
 387     isaxattributes_getValue,
 388     isaxattributes_getValueFromName,
 389     isaxattributes_getValueFromQName
 390 };
 391
 392 static HRESULT SAXAttributes_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 393 {
 394     saxattributes *attributes;
 395
 396     attributes = HeapAlloc(GetProcessHeap(), 0, sizeof(*attributes));
 397     if(!attributes)
 398         return E_OUTOFMEMORY;
 399
 400     attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
 401     attributes->ref = 1;
 402
 403     *ppObj = attributes;
 404
 405     TRACE("returning %p\n", *ppObj);
 406
 407     return S_OK;
 408 }
 409
 410 /*** LibXML callbacks ***/
 411 static void libxmlStartDocument(void *ctx)
 412 {
 413     saxlocator *This = ctx;
 414     HRESULT hr;
 415
 416     if(This->saxreader->contentHandler)
 417     {
 418         hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
 419         if(hr != S_OK)
 420             format_error_message_from_id(This, hr);
 421     }
 422
 423     update_position(This, NULL);
 424 }
 425
 426 static void libxmlEndDocument(void *ctx)
 427 {
 428     saxlocator *This = ctx;
 429     HRESULT hr;
 430
 431     This->column = 0;
 432     This->line = 0;
 433
 434     if(This->ret != S_OK) return;
 435
 436     if(This->saxreader->contentHandler)
 437     {
 438         hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
 439         if(hr != S_OK)
 440             format_error_message_from_id(This, hr);
 441     }
 442 }
 443
 444 static void libxmlStartElementNS(
 445         void *ctx,
 446         const xmlChar *localname,
 447         const xmlChar *prefix,
 448         const xmlChar *URI,
 449         int nb_namespaces,
 450         const xmlChar **namespaces,
 451         int nb_attributes,
 452         int nb_defaulted,
 453         const xmlChar **attributes)
 454 {
 455     BSTR NamespaceUri, LocalName, QName;
 456     saxlocator *This = ctx;
 457     HRESULT hr;
 458     ISAXAttributes *attr;
 459
 460     FIXME("Arguments processing not yet implemented.\n");
 461
 462     update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
 463
 464     if(This->saxreader->contentHandler)
 465     {
 466         NamespaceUri = bstr_from_xmlChar(URI);
 467         LocalName = bstr_from_xmlChar(localname);
 468         QName = bstr_from_xmlChar(localname);
 469
 470         SAXAttributes_create(NULL, (void*)&attr);
 471
 472         hr = ISAXContentHandler_startElement(
 473                 This->saxreader->contentHandler,
 474                 NamespaceUri, SysStringLen(NamespaceUri),
 475                 LocalName, SysStringLen(LocalName),
 476                 QName, SysStringLen(QName),
 477                 attr);
 478
 479         SysFreeString(NamespaceUri);
 480         SysFreeString(LocalName);
 481         SysFreeString(QName);
 482
 483         ISAXAttributes_Release(attr);
 484
 485         if(hr != S_OK)
 486             format_error_message_from_id(This, hr);
 487     }
 488 }
 489
 490 static void libxmlEndElementNS(
 491         void *ctx,
 492         const xmlChar *localname,
 493         const xmlChar *prefix,
 494         const xmlChar *URI)
 495 {
 496     BSTR NamespaceUri, LocalName, QName;
 497     saxlocator *This = ctx;
 498     HRESULT hr;
 499     xmlChar *end;
 500
 501     end = This->lastCur;
 502     while(*end != '<' && *(end+1) != '/') end++;
 503     update_position(This, end+2);
 504
 505     if(This->saxreader->contentHandler)
 506     {
 507         NamespaceUri = bstr_from_xmlChar(URI);
 508         LocalName = bstr_from_xmlChar(localname);
 509         QName = bstr_from_xmlChar(localname);
 510
 511         hr = ISAXContentHandler_endElement(
 512                 This->saxreader->contentHandler,
 513                 NamespaceUri, SysStringLen(NamespaceUri),
 514                 LocalName, SysStringLen(LocalName),
 515                 QName, SysStringLen(QName));
 516
 517         SysFreeString(NamespaceUri);
 518         SysFreeString(LocalName);
 519         SysFreeString(QName);
 520
 521         if(hr != S_OK)
 522             format_error_message_from_id(This, hr);
 523     }
 524 }
 525
 526 static void libxmlCharacters(
 527         void *ctx,
 528         const xmlChar *ch,
 529         int len)
 530 {
 531     BSTR Chars;
 532     saxlocator *This = ctx;
 533     HRESULT hr;
 534     xmlChar *end;
 535     xmlChar *lastCurCopy;
 536     xmlChar *chEnd;
 537     int columnCopy;
 538     int lineCopy;
 539
 540     if(*(This->lastCur-1) != '>' && *(This->lastCur-1) != '/') return;
 541
 542     if(*(This->lastCur-1) != '>')
 543     {
 544         end = (xmlChar*)This->pParserCtxt->input->cur-len;
 545         while(*(end-1) != '>') end--;
 546         update_position(This, end);
 547     }
 548
 549     chEnd = This->lastCur+len;
 550     while(*chEnd != '<') chEnd++;
 551
 552     Chars = bstr_from_xmlChar(ch);
 553
 554     lastCurCopy = This->lastCur;
 555     columnCopy = This->column;
 556     lineCopy = This->line;
 557     end = This->lastCur;
 558
 559     if(This->saxreader->contentHandler)
 560     {
 561         while(This->lastCur < chEnd)
 562         {
 563             end = This->lastCur;
 564             while(end < chEnd-1)
 565             {
 566                 if(*end == '\r') break;
 567                 end++;
 568             }
 569
 570             Chars = bstr_from_xmlChar(This->lastCur);
 571
 572             if(*end == '\r' && *(end+1) == '\n')
 573             {
 574                 memmove((WCHAR*)Chars+(end-This->lastCur),
 575                         (WCHAR*)Chars+(end-This->lastCur)+1,
 576                         (SysStringLen(Chars)-(end-This->lastCur))*sizeof(WCHAR));
 577                 SysReAllocStringLen(&Chars, Chars, SysStringLen(Chars)-1);
 578             }
 579             else if(*end == '\r') Chars[end-This->lastCur] = '\n';
 580
 581             hr = ISAXContentHandler_characters(This->saxreader->contentHandler, Chars, end-This->lastCur+1);
 582             SysFreeString(Chars);
 583             if(hr != S_OK)
 584             {
 585                 format_error_message_from_id(This, hr);
 586                 return;
 587             }
 588
 589             if(*(end+1) == '\n') end++;
 590             if(end < chEnd) end++;
 591
 592             This->column += end-This->lastCur;
 593             This->lastCur = end;
 594         }
 595
 596         This->lastCur = lastCurCopy;
 597         This->column = columnCopy;
 598         This->line = lineCopy;
 599         update_position(This, chEnd);
 600     }
 601 }
 602
 603 static void libxmlSetDocumentLocator(
 604         void *ctx,
 605         xmlSAXLocatorPtr loc)
 606 {
 607     saxlocator *This = ctx;
 608     HRESULT hr;
 609
 610     hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
 611             (ISAXLocator*)&This->lpSAXLocatorVtbl);
 612
 613     if(FAILED(hr))
 614         format_error_message_from_id(This, hr);
 615 }
 616
 617 void libxmlFatalError(void *ctx, const char *msg, ...)
 618 {
 619     saxlocator *This = ctx;
 620     char message[1024];
 621     WCHAR *wszError;
 622     DWORD len;
 623     va_list args;
 624
 625     if(!This->saxreader->errorHandler)
 626     {
 627         xmlStopParser(This->pParserCtxt);
 628         This->ret = E_FAIL;
 629         return;
 630     }
 631
 632     FIXME("Error handling is not compatible.\n");
 633
 634     va_start(args, msg);
 635     vsprintf(message, msg, args);
 636     va_end(args);
 637
 638     len = MultiByteToWideChar(CP_ACP, 0, message, -1, NULL, 0);
 639     wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 640     MultiByteToWideChar(CP_ACP, 0, message, -1, (LPWSTR)wszError, len);
 641
 642     ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 643             (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
 644
 645     HeapFree(GetProcessHeap(), 0, wszError);
 646
 647     xmlStopParser(This->pParserCtxt);
 648     This->ret = E_FAIL;
 649 }
 650
 651 /*** ISAXLocator interface ***/
 652 /*** IUnknown methods ***/
 653 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
 654 {
 655     saxlocator *This = impl_from_ISAXLocator( iface );
 656
 657     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 658
 659     *ppvObject = NULL;
 660
 661     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 662             IsEqualGUID( riid, &IID_ISAXLocator ))
 663     {
 664         *ppvObject = iface;
 665     }
 666     else
 667     {
 668         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 669         return E_NOINTERFACE;
 670     }
 671
 672     ISAXLocator_AddRef( iface );
 673
 674     return S_OK;
 675 }
 676
 677 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
 678 {
 679     saxlocator *This = impl_from_ISAXLocator( iface );
 680     TRACE("%p\n", This );
 681     return InterlockedIncrement( &This->ref );
 682 }
 683
 684 static ULONG WINAPI isaxlocator_Release(
 685         ISAXLocator* iface)
 686 {
 687     saxlocator *This = impl_from_ISAXLocator( iface );
 688     LONG ref;
 689
 690     TRACE("%p\n", This );
 691
 692     ref = InterlockedDecrement( &This->ref );
 693     if ( ref == 0 )
 694     {
 695         if(This->publicId)
 696             SysFreeString(This->publicId);
 697         if(This->systemId)
 698             SysFreeString(This->systemId);
 699
 700         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
 701         HeapFree( GetProcessHeap(), 0, This );
 702     }
 703
 704     return ref;
 705 }
 706
 707 /*** ISAXLocator methods ***/
 708 static HRESULT WINAPI isaxlocator_getColumnNumber(
 709         ISAXLocator* iface,
 710         int *pnColumn)
 711 {
 712     saxlocator *This = impl_from_ISAXLocator( iface );
 713
 714     *pnColumn = This->column;
 715     return S_OK;
 716 }
 717
 718 static HRESULT WINAPI isaxlocator_getLineNumber(
 719         ISAXLocator* iface,
 720         int *pnLine)
 721 {
 722     saxlocator *This = impl_from_ISAXLocator( iface );
 723
 724     *pnLine = This->line;
 725     return S_OK;
 726 }
 727
 728 static HRESULT WINAPI isaxlocator_getPublicId(
 729         ISAXLocator* iface,
 730         const WCHAR ** ppwchPublicId)
 731 {
 732     BSTR publicId;
 733     saxlocator *This = impl_from_ISAXLocator( iface );
 734
 735     if(This->publicId) SysFreeString(This->publicId);
 736
 737     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
 738     if(SysStringLen(publicId))
 739         This->publicId = (WCHAR*)&publicId;
 740     else
 741     {
 742         SysFreeString(publicId);
 743         This->publicId = NULL;
 744     }
 745
 746     *ppwchPublicId = This->publicId;
 747     return S_OK;
 748 }
 749
 750 static HRESULT WINAPI isaxlocator_getSystemId(
 751         ISAXLocator* iface,
 752         const WCHAR ** ppwchSystemId)
 753 {
 754     BSTR systemId;
 755     saxlocator *This = impl_from_ISAXLocator( iface );
 756
 757     if(This->systemId) SysFreeString(This->systemId);
 758
 759     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
 760     if(SysStringLen(systemId))
 761         This->systemId = (WCHAR*)&systemId;
 762     else
 763     {
 764         SysFreeString(systemId);
 765         This->systemId = NULL;
 766     }
 767
 768     *ppwchSystemId = This->systemId;
 769     return S_OK;
 770 }
 771
 772 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
 773 {
 774     isaxlocator_QueryInterface,
 775     isaxlocator_AddRef,
 776     isaxlocator_Release,
 777     isaxlocator_getColumnNumber,
 778     isaxlocator_getLineNumber,
 779     isaxlocator_getPublicId,
 780     isaxlocator_getSystemId
 781 };
 782
 783 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator)
 784 {
 785     saxlocator *locator;
 786
 787     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
 788     if( !locator )
 789         return E_OUTOFMEMORY;
 790
 791     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
 792     locator->ref = 1;
 793
 794     locator->saxreader = reader;
 795     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
 796
 797     locator->pParserCtxt = NULL;
 798     locator->publicId = NULL;
 799     locator->systemId = NULL;
 800     locator->lastCur = NULL;
 801     locator->line = 0;
 802     locator->column = 0;
 803     locator->ret = S_OK;
 804
 805     *ppsaxlocator = locator;
 806
 807     TRACE("returning %p\n", *ppsaxlocator);
 808
 809     return S_OK;
 810 }
 811
 812 /*** IVBSAXXMLReader interface ***/
 813 /*** IUnknown methods ***/
 814 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
 815 {
 816     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 817
 818     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 819
 820     *ppvObject = NULL;
 821
 822     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 823          IsEqualGUID( riid, &IID_IDispatch ) ||
 824          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
 825     {
 826         *ppvObject = iface;
 827     }
 828     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
 829     {
 830         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
 831     }
 832     else
 833     {
 834         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 835         return E_NOINTERFACE;
 836     }
 837
 838     IVBSAXXMLReader_AddRef( iface );
 839
 840     return S_OK;
 841 }
 842
 843 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
 844 {
 845     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 846     TRACE("%p\n", This );
 847     return InterlockedIncrement( &This->ref );
 848 }
 849
 850 static ULONG WINAPI saxxmlreader_Release(
 851     IVBSAXXMLReader* iface)
 852 {
 853     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 854     LONG ref;
 855
 856     TRACE("%p\n", This );
 857
 858     ref = InterlockedDecrement( &This->ref );
 859     if ( ref == 0 )
 860     {
 861         if(This->contentHandler)
 862             ISAXContentHandler_Release(This->contentHandler);
 863
 864         if(This->errorHandler)
 865             ISAXErrorHandler_Release(This->errorHandler);
 866
 867         HeapFree( GetProcessHeap(), 0, This );
 868     }
 869
 870     return ref;
 871 }
 872 /*** IDispatch ***/
 873 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 874 {
 875     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 876
 877     TRACE("(%p)->(%p)\n", This, pctinfo);
 878
 879     *pctinfo = 1;
 880
 881     return S_OK;
 882 }
 883
 884 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 885     IVBSAXXMLReader *iface,
 886     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 887 {
 888     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 889     HRESULT hr;
 890
 891     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 892
 893     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 894
 895     return hr;
 896 }
 897
 898 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 899     IVBSAXXMLReader *iface,
 900     REFIID riid,
 901     LPOLESTR* rgszNames,
 902     UINT cNames,
 903     LCID lcid,
 904     DISPID* rgDispId)
 905 {
 906     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 907     ITypeInfo *typeinfo;
 908     HRESULT hr;
 909
 910     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 911           lcid, rgDispId);
 912
 913     if(!rgszNames || cNames == 0 || !rgDispId)
 914         return E_INVALIDARG;
 915
 916     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 917     if(SUCCEEDED(hr))
 918     {
 919         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 920         ITypeInfo_Release(typeinfo);
 921     }
 922
 923     return hr;
 924 }
 925
 926 static HRESULT WINAPI saxxmlreader_Invoke(
 927     IVBSAXXMLReader *iface,
 928     DISPID dispIdMember,
 929     REFIID riid,
 930     LCID lcid,
 931     WORD wFlags,
 932     DISPPARAMS* pDispParams,
 933     VARIANT* pVarResult,
 934     EXCEPINFO* pExcepInfo,
 935     UINT* puArgErr)
 936 {
 937     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 938     ITypeInfo *typeinfo;
 939     HRESULT hr;
 940
 941     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 942           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 943
 944     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 945     if(SUCCEEDED(hr))
 946     {
 947         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 948                 pVarResult, pExcepInfo, puArgErr);
 949         ITypeInfo_Release(typeinfo);
 950     }
 951
 952     return hr;
 953 }
 954
 955 /*** IVBSAXXMLReader methods ***/
 956 static HRESULT WINAPI saxxmlreader_getFeature(
 957     IVBSAXXMLReader* iface,
 958     const WCHAR *pFeature,
 959     VARIANT_BOOL *pValue)
 960 {
 961     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 962
 963     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI saxxmlreader_putFeature(
 968     IVBSAXXMLReader* iface,
 969     const WCHAR *pFeature,
 970     VARIANT_BOOL vfValue)
 971 {
 972     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 973
 974     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI saxxmlreader_getProperty(
 979     IVBSAXXMLReader* iface,
 980     const WCHAR *pProp,
 981     VARIANT *pValue)
 982 {
 983     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 984
 985     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI saxxmlreader_putProperty(
 990     IVBSAXXMLReader* iface,
 991     const WCHAR *pProp,
 992     VARIANT value)
 993 {
 994     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 995
 996     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 997     return E_NOTIMPL;
 998 }
 999
1000 static HRESULT WINAPI saxxmlreader_getEntityResolver(
1001     IVBSAXXMLReader* iface,
1002     IVBSAXEntityResolver **pEntityResolver)
1003 {
1004     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1005
1006     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1007     return E_NOTIMPL;
1008 }
1009
1010 static HRESULT WINAPI saxxmlreader_putEntityResolver(
1011     IVBSAXXMLReader* iface,
1012     IVBSAXEntityResolver *pEntityResolver)
1013 {
1014     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1015
1016     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI saxxmlreader_getContentHandler(
1021     IVBSAXXMLReader* iface,
1022     IVBSAXContentHandler **ppContentHandler)
1023 {
1024     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1025
1026     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI saxxmlreader_putContentHandler(
1031     IVBSAXXMLReader* iface,
1032     IVBSAXContentHandler *contentHandler)
1033 {
1034     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1035
1036     FIXME("(%p)->(%p) stub\n", This, contentHandler);
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI saxxmlreader_getDTDHandler(
1041     IVBSAXXMLReader* iface,
1042     IVBSAXDTDHandler **pDTDHandler)
1043 {
1044     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1045
1046     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1047     return E_NOTIMPL;
1048 }
1049
1050 static HRESULT WINAPI saxxmlreader_putDTDHandler(
1051     IVBSAXXMLReader* iface,
1052     IVBSAXDTDHandler *pDTDHandler)
1053 {
1054     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1055
1056     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1057     return E_NOTIMPL;
1058 }
1059
1060 static HRESULT WINAPI saxxmlreader_getErrorHandler(
1061     IVBSAXXMLReader* iface,
1062     IVBSAXErrorHandler **pErrorHandler)
1063 {
1064     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1065
1066     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
1067     return E_NOTIMPL;
1068 }
1069
1070 static HRESULT WINAPI saxxmlreader_putErrorHandler(
1071     IVBSAXXMLReader* iface,
1072     IVBSAXErrorHandler *errorHandler)
1073 {
1074     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1075
1076     FIXME("(%p)->(%p) stub\n", This, errorHandler);
1077     return E_NOTIMPL;
1078 }
1079
1080 static HRESULT WINAPI saxxmlreader_getBaseURL(
1081     IVBSAXXMLReader* iface,
1082     const WCHAR **pBaseUrl)
1083 {
1084     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1085
1086     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
1087     return E_NOTIMPL;
1088 }
1089
1090 static HRESULT WINAPI saxxmlreader_putBaseURL(
1091     IVBSAXXMLReader* iface,
1092     const WCHAR *pBaseUrl)
1093 {
1094     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1095
1096     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
1101     IVBSAXXMLReader* iface,
1102     const WCHAR **pSecureBaseUrl)
1103 {
1104     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1105
1106     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
1107     return E_NOTIMPL;
1108 }
1109
1110
1111 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
1112     IVBSAXXMLReader* iface,
1113     const WCHAR *secureBaseUrl)
1114 {
1115     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1116
1117     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
1118     return E_NOTIMPL;
1119 }
1120
1121 static HRESULT WINAPI saxxmlreader_parse(
1122     IVBSAXXMLReader* iface,
1123     VARIANT varInput)
1124 {
1125     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1126
1127     FIXME("(%p) stub\n", This);
1128     return E_NOTIMPL;
1129 }
1130
1131 static HRESULT WINAPI saxxmlreader_parseURL(
1132     IVBSAXXMLReader* iface,
1133     const WCHAR *url)
1134 {
1135     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1136
1137     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
1138     return E_NOTIMPL;
1139 }
1140
1141 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
1142 {
1143     saxxmlreader_QueryInterface,
1144     saxxmlreader_AddRef,
1145     saxxmlreader_Release,
1146     saxxmlreader_GetTypeInfoCount,
1147     saxxmlreader_GetTypeInfo,
1148     saxxmlreader_GetIDsOfNames,
1149     saxxmlreader_Invoke,
1150     saxxmlreader_getFeature,
1151     saxxmlreader_putFeature,
1152     saxxmlreader_getProperty,
1153     saxxmlreader_putProperty,
1154     saxxmlreader_getEntityResolver,
1155     saxxmlreader_putEntityResolver,
1156     saxxmlreader_getContentHandler,
1157     saxxmlreader_putContentHandler,
1158     saxxmlreader_getDTDHandler,
1159     saxxmlreader_putDTDHandler,
1160     saxxmlreader_getErrorHandler,
1161     saxxmlreader_putErrorHandler,
1162     saxxmlreader_getBaseURL,
1163     saxxmlreader_putBaseURL,
1164     saxxmlreader_getSecureBaseURL,
1165     saxxmlreader_putSecureBaseURL,
1166     saxxmlreader_parse,
1167     saxxmlreader_parseURL
1168 };
1169
1170 /*** ISAXXMLReader interface ***/
1171 /*** IUnknown methods ***/
1172 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
1173 {
1174     saxreader *This = impl_from_ISAXXMLReader( iface );
1175     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVtbl, riid, ppvObject);
1176 }
1177
1178 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
1179 {
1180     saxreader *This = impl_from_ISAXXMLReader( iface );
1181     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVtbl);
1182 }
1183
1184 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
1185 {
1186     saxreader *This = impl_from_ISAXXMLReader( iface );
1187     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVtbl);
1188 }
1189
1190 /*** ISAXXMLReader methods ***/
1191 static HRESULT WINAPI isaxxmlreader_getFeature(
1192         ISAXXMLReader* iface,
1193         const WCHAR *pFeature,
1194         VARIANT_BOOL *pValue)
1195 {
1196     saxreader *This = impl_from_ISAXXMLReader( iface );
1197
1198     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
1199     return E_NOTIMPL;
1200 }
1201
1202 static HRESULT WINAPI isaxxmlreader_putFeature(
1203         ISAXXMLReader* iface,
1204         const WCHAR *pFeature,
1205         VARIANT_BOOL vfValue)
1206 {
1207     saxreader *This = impl_from_ISAXXMLReader( iface );
1208
1209     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
1210     return E_NOTIMPL;
1211 }
1212
1213 static HRESULT WINAPI isaxxmlreader_getProperty(
1214         ISAXXMLReader* iface,
1215         const WCHAR *pProp,
1216         VARIANT *pValue)
1217 {
1218     saxreader *This = impl_from_ISAXXMLReader( iface );
1219
1220     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
1221     return E_NOTIMPL;
1222 }
1223
1224 static HRESULT WINAPI isaxxmlreader_putProperty(
1225         ISAXXMLReader* iface,
1226         const WCHAR *pProp,
1227         VARIANT value)
1228 {
1229     saxreader *This = impl_from_ISAXXMLReader( iface );
1230
1231     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
1232     return E_NOTIMPL;
1233 }
1234
1235 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
1236         ISAXXMLReader* iface,
1237         ISAXEntityResolver **ppEntityResolver)
1238 {
1239     saxreader *This = impl_from_ISAXXMLReader( iface );
1240
1241     FIXME("(%p)->(%p) stub\n", This, ppEntityResolver);
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
1246         ISAXXMLReader* iface,
1247         ISAXEntityResolver *pEntityResolver)
1248 {
1249     saxreader *This = impl_from_ISAXXMLReader( iface );
1250
1251     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1252     return E_NOTIMPL;
1253 }
1254
1255 static HRESULT WINAPI isaxxmlreader_getContentHandler(
1256         ISAXXMLReader* iface,
1257         ISAXContentHandler **pContentHandler)
1258 {
1259     saxreader *This = impl_from_ISAXXMLReader( iface );
1260
1261     TRACE("(%p)->(%p)\n", This, pContentHandler);
1262     if(pContentHandler == NULL)
1263         return E_POINTER;
1264     if(This->contentHandler)
1265         ISAXContentHandler_AddRef(This->contentHandler);
1266     *pContentHandler = This->contentHandler;
1267
1268     return S_OK;
1269 }
1270
1271 static HRESULT WINAPI isaxxmlreader_putContentHandler(
1272         ISAXXMLReader* iface,
1273         ISAXContentHandler *contentHandler)
1274 {
1275     saxreader *This = impl_from_ISAXXMLReader( iface );
1276
1277     TRACE("(%p)->(%p)\n", This, contentHandler);
1278     if(contentHandler)
1279         ISAXContentHandler_AddRef(contentHandler);
1280     if(This->contentHandler)
1281         ISAXContentHandler_Release(This->contentHandler);
1282     This->contentHandler = contentHandler;
1283
1284     return S_OK;
1285 }
1286
1287 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
1288         ISAXXMLReader* iface,
1289         ISAXDTDHandler **pDTDHandler)
1290 {
1291     saxreader *This = impl_from_ISAXXMLReader( iface );
1292
1293     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1294     return E_NOTIMPL;
1295 }
1296
1297 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
1298         ISAXXMLReader* iface,
1299         ISAXDTDHandler *pDTDHandler)
1300 {
1301     saxreader *This = impl_from_ISAXXMLReader( iface );
1302
1303     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1304     return E_NOTIMPL;
1305 }
1306
1307 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
1308         ISAXXMLReader* iface,
1309         ISAXErrorHandler **pErrorHandler)
1310 {
1311     saxreader *This = impl_from_ISAXXMLReader( iface );
1312
1313     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1314     if(pErrorHandler == NULL)
1315         return E_POINTER;
1316     if(This->errorHandler)
1317         ISAXErrorHandler_AddRef(This->errorHandler);
1318     *pErrorHandler = This->errorHandler;
1319
1320     return S_OK;
1321 }
1322
1323 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
1324         ISAXXMLReader* iface,
1325         ISAXErrorHandler *errorHandler)
1326 {
1327     saxreader *This = impl_from_ISAXXMLReader( iface );
1328
1329     TRACE("(%p)->(%p)\n", This, errorHandler);
1330     if(errorHandler)
1331         ISAXErrorHandler_AddRef(errorHandler);
1332     if(This->errorHandler)
1333         ISAXErrorHandler_Release(This->errorHandler);
1334     This->errorHandler = errorHandler;
1335
1336     return S_OK;
1337 }
1338
1339 static HRESULT WINAPI isaxxmlreader_getBaseURL(
1340         ISAXXMLReader* iface,
1341         const WCHAR **pBaseUrl)
1342 {
1343     saxreader *This = impl_from_ISAXXMLReader( iface );
1344
1345     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
1346     return E_NOTIMPL;
1347 }
1348
1349 static HRESULT WINAPI isaxxmlreader_putBaseURL(
1350         ISAXXMLReader* iface,
1351         const WCHAR *pBaseUrl)
1352 {
1353     saxreader *This = impl_from_ISAXXMLReader( iface );
1354
1355     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
1356     return E_NOTIMPL;
1357 }
1358
1359 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
1360         ISAXXMLReader* iface,
1361         const WCHAR **pSecureBaseUrl)
1362 {
1363     saxreader *This = impl_from_ISAXXMLReader( iface );
1364
1365     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
1366     return E_NOTIMPL;
1367 }
1368
1369 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
1370         ISAXXMLReader* iface,
1371         const WCHAR *secureBaseUrl)
1372 {
1373     saxreader *This = impl_from_ISAXXMLReader( iface );
1374
1375     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
1376     return E_NOTIMPL;
1377 }
1378
1379 static HRESULT parse_buffer(saxreader *This, xmlChar *buffer)
1380 {
1381     saxlocator *locator;
1382     HRESULT hr;
1383
1384     hr = SAXLocator_create(This, &locator);
1385     if(FAILED(hr))
1386         return E_FAIL;
1387
1388     locator->pParserCtxt = xmlNewParserCtxt();
1389     if(!locator->pParserCtxt)
1390     {
1391         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1392         return E_FAIL;
1393     }
1394
1395     locator->pParserCtxt->sax = &locator->saxreader->sax;
1396     locator->pParserCtxt->userData = locator;
1397
1398     xmlSetupParserForBuffer(locator->pParserCtxt, buffer, NULL);
1399
1400     if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1401     else hr = locator->ret;
1402
1403     if(locator->pParserCtxt)
1404     {
1405         locator->pParserCtxt->sax = NULL;
1406         xmlFreeParserCtxt(locator->pParserCtxt);
1407         locator->pParserCtxt = NULL;
1408     }
1409
1410     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1411     return S_OK;
1412 }
1413
1414 static HRESULT WINAPI isaxxmlreader_parse(
1415         ISAXXMLReader* iface,
1416         VARIANT varInput)
1417 {
1418     saxreader *This = impl_from_ISAXXMLReader( iface );
1419     xmlChar *data = NULL;
1420     HRESULT hr;
1421
1422     TRACE("(%p)\n", This);
1423
1424     hr = S_OK;
1425     switch(V_VT(&varInput))
1426     {
1427         case VT_BSTR:
1428             data = xmlChar_from_wchar(V_BSTR(&varInput));
1429             hr = parse_buffer(This, data);
1430             break;
1431         case VT_ARRAY|VT_UI1: {
1432             void *pSAData;
1433             LONG lBound, uBound;
1434             ULONG dataRead;
1435
1436             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
1437             if(hr != S_OK) break;
1438             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
1439             if(hr != S_OK) break;
1440             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
1441             data = HeapAlloc(GetProcessHeap(), 0, dataRead+1);
1442             if(!data) break;
1443             hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
1444             if(hr != S_OK) break;
1445             memcpy(data, pSAData, dataRead);
1446             data[dataRead] = '\0';
1447             hr = parse_buffer(This, data);
1448             SafeArrayUnaccessData(V_ARRAY(&varInput));
1449             break;
1450         }
1451         case VT_UNKNOWN:
1452         case VT_DISPATCH: {
1453             IPersistStream *persistStream;
1454             IStream *stream = NULL;
1455             IXMLDOMDocument *xmlDoc;
1456
1457             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1458                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
1459             {
1460                 hr = IPersistStream_Save(persistStream, stream, TRUE);
1461                 IPersistStream_Release(persistStream);
1462                 if(hr != S_OK) break;
1463             }
1464             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1465                         &IID_IStream, (void**)&stream) == S_OK)
1466             {
1467                 STATSTG dataInfo;
1468                 ULONG dataRead;
1469
1470                 while(1)
1471                 {
1472                     hr = IStream_Stat(stream, &dataInfo, STATFLAG_NONAME);
1473                     if(hr == E_PENDING) continue;
1474                     break;
1475                 }
1476                 data = HeapAlloc(GetProcessHeap(), 0,
1477                         dataInfo.cbSize.QuadPart+1);
1478                 while(1)
1479                 {
1480                     hr = IStream_Read(stream, data,
1481                             dataInfo.cbSize.QuadPart, &dataRead);
1482                     if(hr == E_PENDING) continue;
1483                     break;
1484                 }
1485                 data[dataInfo.cbSize.QuadPart] = '\0';
1486                 hr = parse_buffer(This, data);
1487                 IStream_Release(stream);
1488                 break;
1489             }
1490             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1491                                        &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
1492             {
1493                 BSTR bstrData;
1494
1495                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
1496                 data = xmlChar_from_wchar(bstrData);
1497                 hr = parse_buffer(This, data);
1498                 IXMLDOMDocument_Release(xmlDoc);
1499                 hr = E_NOTIMPL;
1500                 break;
1501             }
1502         }
1503         default:
1504             WARN("vt %d not implemented\n", V_VT(&varInput));
1505             hr = E_INVALIDARG;
1506     }
1507
1508     HeapFree(GetProcessHeap(), 0, data);
1509     return hr;
1510 }
1511
1512 static HRESULT saxreader_onDataAvailable(void *obj, char *ptr, DWORD len)
1513 {
1514     saxreader *This = obj;
1515     xmlChar *data;
1516     HRESULT hr;
1517
1518     data = HeapAlloc(GetProcessHeap(), 0, len+1);
1519     memcpy(data, ptr, len);
1520     data[len] = 0;
1521
1522     hr = parse_buffer(This, data);
1523
1524     HeapFree(GetProcessHeap(), 0, data);
1525     return hr;
1526 }
1527
1528 static HRESULT WINAPI isaxxmlreader_parseURL(
1529         ISAXXMLReader* iface,
1530         const WCHAR *url)
1531 {
1532     saxreader *This = impl_from_ISAXXMLReader( iface );
1533     bsc_t *bsc;
1534     HRESULT hr;
1535
1536     TRACE("(%p)->(%s) stub\n", This, debugstr_w(url));
1537
1538     hr = bind_url(url, saxreader_onDataAvailable, This, &bsc);
1539     if(FAILED(hr))
1540         return hr;
1541
1542     detach_bsc(bsc);
1543
1544     return S_OK;
1545 }
1546
1547 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
1548 {
1549     isaxxmlreader_QueryInterface,
1550     isaxxmlreader_AddRef,
1551     isaxxmlreader_Release,
1552     isaxxmlreader_getFeature,
1553     isaxxmlreader_putFeature,
1554     isaxxmlreader_getProperty,
1555     isaxxmlreader_putProperty,
1556     isaxxmlreader_getEntityResolver,
1557     isaxxmlreader_putEntityResolver,
1558     isaxxmlreader_getContentHandler,
1559     isaxxmlreader_putContentHandler,
1560     isaxxmlreader_getDTDHandler,
1561     isaxxmlreader_putDTDHandler,
1562     isaxxmlreader_getErrorHandler,
1563     isaxxmlreader_putErrorHandler,
1564     isaxxmlreader_getBaseURL,
1565     isaxxmlreader_putBaseURL,
1566     isaxxmlreader_getSecureBaseURL,
1567     isaxxmlreader_putSecureBaseURL,
1568     isaxxmlreader_parse,
1569     isaxxmlreader_parseURL
1570 };
1571
1572 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1573 {
1574     saxreader *reader;
1575
1576     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1577
1578     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
1579     if( !reader )
1580         return E_OUTOFMEMORY;
1581
1582     reader->lpVtbl = &saxreader_vtbl;
1583     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
1584     reader->ref = 1;
1585     reader->contentHandler = NULL;
1586     reader->errorHandler = NULL;
1587
1588     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
1589     reader->sax.initialized = XML_SAX2_MAGIC;
1590     reader->sax.startDocument = libxmlStartDocument;
1591     reader->sax.endDocument = libxmlEndDocument;
1592     reader->sax.startElementNs = libxmlStartElementNS;
1593     reader->sax.endElementNs = libxmlEndElementNS;
1594     reader->sax.characters = libxmlCharacters;
1595     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
1596     reader->sax.error = libxmlFatalError;
1597     reader->sax.fatalError = libxmlFatalError;
1598
1599     *ppObj = &reader->lpVtbl;
1600
1601     TRACE("returning iface %p\n", *ppObj);
1602
1603     return S_OK;
1604 }
1605
1606 #else
1607
1608 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1609 {
1610     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
1611             "libxml2 support was not present at compile time.\n");
1612     return E_NOTIMPL;
1613 }
1614
1615 #endif