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