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