git.oblomov.eu Git - wine/blob - 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 "msxml6.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 #include <libxml/parserInternals.h>
  48
  49 typedef struct _saxreader
  50 {
  51     const struct IVBSAXXMLReaderVtbl *lpVBSAXXMLReaderVtbl;
  52     const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
  53     LONG ref;
  54     struct ISAXContentHandler *contentHandler;
  55     struct IVBSAXContentHandler *vbcontentHandler;
  56     struct ISAXErrorHandler *errorHandler;
  57     struct IVBSAXErrorHandler *vberrorHandler;
  58     struct ISAXLexicalHandler *lexicalHandler;
  59     struct IVBSAXLexicalHandler *vblexicalHandler;
  60     struct ISAXDeclHandler *declHandler;
  61     struct IVBSAXDeclHandler *vbdeclHandler;
  62     xmlSAXHandler sax;
  63     BOOL isParsing;
  64 } saxreader;
  65
  66 typedef struct _saxlocator
  67 {
  68     const struct IVBSAXLocatorVtbl *lpVBSAXLocatorVtbl;
  69     const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
  70     LONG ref;
  71     saxreader *saxreader;
  72     HRESULT ret;
  73     xmlParserCtxtPtr pParserCtxt;
  74     WCHAR *publicId;
  75     WCHAR *systemId;
  76     xmlChar *lastCur;
  77     int line;
  78     int realLine;
  79     int column;
  80     int realColumn;
  81     BOOL vbInterface;
  82     int nsStackSize;
  83     int nsStackLast;
  84     int *nsStack;
  85 } saxlocator;
  86
  87 typedef struct _saxattributes
  88 {
  89     const struct IVBSAXAttributesVtbl *lpVBSAXAttributesVtbl;
  90     const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
  91     LONG ref;
  92     int nb_attributes;
  93     BSTR *szLocalname;
  94     BSTR *szURI;
  95     BSTR *szValue;
  96     BSTR *szQName;
  97 } saxattributes;
  98
  99 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
 100 {
 101     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVBSAXXMLReaderVtbl));
 102 }
 103
 104 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
 105 {
 106     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
 107 }
 108
 109 static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
 110 {
 111     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpVBSAXLocatorVtbl));
 112 }
 113
 114 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
 115 {
 116     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
 117 }
 118
 119 static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
 120 {
 121     return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpVBSAXAttributesVtbl));
 122 }
 123
 124 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
 125 {
 126     return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
 127 }
 128
 129 static inline BOOL has_content_handler(const saxlocator *locator)
 130 {
 131     return  (locator->vbInterface && locator->saxreader->vbcontentHandler) ||
 132            (!locator->vbInterface && locator->saxreader->contentHandler);
 133 }
 134
 135 static inline BOOL has_error_handler(const saxlocator *locator)
 136 {
 137     return (locator->vbInterface && locator->saxreader->vberrorHandler) ||
 138           (!locator->vbInterface && locator->saxreader->errorHandler);
 139 }
 140
 141 static HRESULT namespacePush(saxlocator *locator, int ns)
 142 {
 143     if(locator->nsStackLast>=locator->nsStackSize)
 144     {
 145         int *new_stack;
 146
 147         new_stack = HeapReAlloc(GetProcessHeap(), 0,
 148                 locator->nsStack, sizeof(int)*locator->nsStackSize*2);
 149         if(!new_stack) return E_OUTOFMEMORY;
 150         locator->nsStack = new_stack;
 151         locator->nsStackSize *= 2;
 152     }
 153     locator->nsStack[locator->nsStackLast++] = ns;
 154
 155     return S_OK;
 156 }
 157
 158 static int namespacePop(saxlocator *locator)
 159 {
 160     if(locator->nsStackLast == 0) return 0;
 161     return locator->nsStack[--locator->nsStackLast];
 162 }
 163
 164 static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
 165 {
 166     DWORD dLen;
 167     BSTR bstr;
 168
 169     if (!buf)
 170         return NULL;
 171
 172     dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
 173     if(len != -1) dLen++;
 174     bstr = SysAllocStringLen(NULL, dLen-1);
 175     if (!bstr)
 176         return NULL;
 177     MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, bstr, dLen);
 178     if(len != -1) bstr[dLen-1] = '\0';
 179
 180     return bstr;
 181 }
 182
 183 static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
 184 {
 185     xmlChar *qname;
 186     BSTR bstr;
 187
 188     if(!name) return NULL;
 189
 190     if(!prefix || !*prefix)
 191         return bstr_from_xmlChar(name);
 192
 193     qname = xmlBuildQName(name, prefix, NULL, 0);
 194     bstr = bstr_from_xmlChar(qname);
 195     xmlFree(qname);
 196
 197     return bstr;
 198 }
 199
 200 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
 201 {
 202     xmlStopParser(This->pParserCtxt);
 203     This->ret = hr;
 204
 205     if(has_error_handler(This))
 206     {
 207         WCHAR msg[1024];
 208         if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
 209                     NULL, hr, 0, msg, sizeof(msg), NULL))
 210         {
 211             FIXME("MSXML errors not yet supported.\n");
 212             msg[0] = '\0';
 213         }
 214
 215         if(This->vbInterface)
 216         {
 217             BSTR bstrMsg = SysAllocString(msg);
 218             IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
 219                     (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrMsg, hr);
 220             SysFreeString(bstrMsg);
 221         }
 222         else
 223             ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 224                     (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
 225     }
 226 }
 227
 228 static void update_position(saxlocator *This, xmlChar *end)
 229 {
 230     if(This->lastCur == NULL)
 231     {
 232         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 233         This->realLine = 1;
 234         This->realColumn = 1;
 235     }
 236     else if(This->lastCur < This->pParserCtxt->input->base)
 237     {
 238         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 239         This->realLine = 1;
 240         This->realColumn = 1;
 241     }
 242
 243     if(This->pParserCtxt->input->cur<This->lastCur)
 244     {
 245         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 246         This->realLine -= 1;
 247         This->realColumn = 1;
 248     }
 249
 250     if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
 251
 252     while(This->lastCur < end)
 253     {
 254         if(*(This->lastCur) == '\n')
 255         {
 256             This->realLine++;
 257             This->realColumn = 1;
 258         }
 259         else if(*(This->lastCur) == '\r' &&
 260                 (This->lastCur==This->pParserCtxt->input->end ||
 261                  *(This->lastCur+1)!='\n'))
 262         {
 263             This->realLine++;
 264             This->realColumn = 1;
 265         }
 266         else This->realColumn++;
 267
 268         This->lastCur++;
 269
 270         /* Count multibyte UTF8 encoded characters once */
 271         while((*(This->lastCur)&0xC0) == 0x80) This->lastCur++;
 272     }
 273
 274     This->line = This->realLine;
 275     This->column = This->realColumn;
 276 }
 277
 278 /*** IVBSAXAttributes interface ***/
 279 /*** IUnknown methods ***/
 280 static HRESULT WINAPI ivbsaxattributes_QueryInterface(
 281         IVBSAXAttributes* iface,
 282         REFIID riid,
 283         void **ppvObject)
 284 {
 285     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 286
 287     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 288
 289     *ppvObject = NULL;
 290
 291     if (IsEqualGUID(riid, &IID_IUnknown) ||
 292             IsEqualGUID(riid, &IID_IDispatch) ||
 293             IsEqualGUID(riid, &IID_IVBSAXAttributes))
 294     {
 295         *ppvObject = iface;
 296     }
 297     else
 298     {
 299         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 300         return E_NOINTERFACE;
 301     }
 302
 303     IVBSAXAttributes_AddRef(iface);
 304
 305     return S_OK;
 306 }
 307
 308 static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
 309 {
 310     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 311     return ISAXAttributes_AddRef((ISAXAttributes*)&This->lpSAXAttributesVtbl);
 312 }
 313
 314 static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
 315 {
 316     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 317     return ISAXAttributes_Release((ISAXAttributes*)&This->lpSAXAttributesVtbl);
 318 }
 319
 320 /*** IDispatch methods ***/
 321 static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
 322 {
 323     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 324
 325     TRACE("(%p)->(%p)\n", This, pctinfo);
 326
 327     *pctinfo = 1;
 328
 329     return S_OK;
 330 }
 331
 332 static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
 333     IVBSAXAttributes *iface,
 334     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 335 {
 336     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 337     HRESULT hr;
 338
 339     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 340
 341     hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
 342
 343     return hr;
 344 }
 345
 346 static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
 347     IVBSAXAttributes *iface,
 348     REFIID riid,
 349     LPOLESTR* rgszNames,
 350     UINT cNames,
 351     LCID lcid,
 352     DISPID* rgDispId)
 353 {
 354     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 355     ITypeInfo *typeinfo;
 356     HRESULT hr;
 357
 358     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 359           lcid, rgDispId);
 360
 361     if(!rgszNames || cNames == 0 || !rgDispId)
 362         return E_INVALIDARG;
 363
 364     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
 365     if(SUCCEEDED(hr))
 366     {
 367         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 368         ITypeInfo_Release(typeinfo);
 369     }
 370
 371     return hr;
 372 }
 373
 374 static HRESULT WINAPI ivbsaxattributes_Invoke(
 375     IVBSAXAttributes *iface,
 376     DISPID dispIdMember,
 377     REFIID riid,
 378     LCID lcid,
 379     WORD wFlags,
 380     DISPPARAMS* pDispParams,
 381     VARIANT* pVarResult,
 382     EXCEPINFO* pExcepInfo,
 383     UINT* puArgErr)
 384 {
 385     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 386     ITypeInfo *typeinfo;
 387     HRESULT hr;
 388
 389     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 390           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 391
 392     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
 393     if(SUCCEEDED(hr))
 394     {
 395         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXAttributesVtbl), dispIdMember, wFlags, pDispParams,
 396                 pVarResult, pExcepInfo, puArgErr);
 397         ITypeInfo_Release(typeinfo);
 398     }
 399
 400     return hr;
 401 }
 402
 403 /*** IVBSAXAttributes methods ***/
 404 static HRESULT WINAPI ivbsaxattributes_get_length(
 405         IVBSAXAttributes* iface,
 406         int *nLength)
 407 {
 408     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 409     return ISAXAttributes_getLength(
 410             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 411             nLength);
 412 }
 413
 414 static HRESULT WINAPI ivbsaxattributes_getURI(
 415         IVBSAXAttributes* iface,
 416         int nIndex,
 417         BSTR *uri)
 418 {
 419     int len;
 420     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 421     return ISAXAttributes_getURI(
 422             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 423             nIndex, (const WCHAR**)uri, &len);
 424 }
 425
 426 static HRESULT WINAPI ivbsaxattributes_getLocalName(
 427         IVBSAXAttributes* iface,
 428         int nIndex,
 429         BSTR *localName)
 430 {
 431     int len;
 432     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 433     return ISAXAttributes_getLocalName(
 434             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 435             nIndex, (const WCHAR**)localName, &len);
 436 }
 437
 438 static HRESULT WINAPI ivbsaxattributes_getQName(
 439         IVBSAXAttributes* iface,
 440         int nIndex,
 441         BSTR *QName)
 442 {
 443     int len;
 444     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 445     return ISAXAttributes_getQName(
 446             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 447             nIndex, (const WCHAR**)QName, &len);
 448 }
 449
 450 static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
 451         IVBSAXAttributes* iface,
 452         BSTR uri,
 453         BSTR localName,
 454         int *index)
 455 {
 456     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 457     return ISAXAttributes_getIndexFromName(
 458             (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
 459             localName, SysStringLen(localName), index);
 460 }
 461
 462 static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
 463         IVBSAXAttributes* iface,
 464         BSTR QName,
 465         int *index)
 466 {
 467     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 468     return ISAXAttributes_getIndexFromQName(
 469             (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
 470             SysStringLen(QName), index);
 471 }
 472
 473 static HRESULT WINAPI ivbsaxattributes_getType(
 474         IVBSAXAttributes* iface,
 475         int nIndex,
 476         BSTR *type)
 477 {
 478     int len;
 479     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 480     return ISAXAttributes_getType(
 481             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 482             nIndex, (const WCHAR**)type, &len);
 483 }
 484
 485 static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
 486         IVBSAXAttributes* iface,
 487         BSTR uri,
 488         BSTR localName,
 489         BSTR *type)
 490 {
 491     int len;
 492     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 493     return ISAXAttributes_getTypeFromName(
 494             (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
 495             localName, SysStringLen(localName), (const WCHAR**)type, &len);
 496 }
 497
 498 static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
 499         IVBSAXAttributes* iface,
 500         BSTR QName,
 501         BSTR *type)
 502 {
 503     int len;
 504     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 505     return ISAXAttributes_getTypeFromQName(
 506             (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
 507             SysStringLen(QName), (const WCHAR**)type, &len);
 508 }
 509
 510 static HRESULT WINAPI ivbsaxattributes_getValue(
 511         IVBSAXAttributes* iface,
 512         int nIndex,
 513         BSTR *value)
 514 {
 515     int len;
 516     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 517     return ISAXAttributes_getValue(
 518             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 519             nIndex, (const WCHAR**)value, &len);
 520 }
 521
 522 static HRESULT WINAPI ivbsaxattributes_getValueFromName(
 523         IVBSAXAttributes* iface,
 524         BSTR uri,
 525         BSTR localName,
 526         BSTR *value)
 527 {
 528     int len;
 529     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 530     return ISAXAttributes_getValueFromName(
 531             (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
 532             localName, SysStringLen(localName), (const WCHAR**)value, &len);
 533 }
 534
 535 static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
 536         IVBSAXAttributes* iface,
 537         BSTR QName,
 538         BSTR *value)
 539 {
 540     int len;
 541     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 542     return ISAXAttributes_getValueFromQName(
 543             (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
 544             SysStringLen(QName), (const WCHAR**)value, &len);
 545 }
 546
 547 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
 548 {
 549     ivbsaxattributes_QueryInterface,
 550     ivbsaxattributes_AddRef,
 551     ivbsaxattributes_Release,
 552     ivbsaxattributes_GetTypeInfoCount,
 553     ivbsaxattributes_GetTypeInfo,
 554     ivbsaxattributes_GetIDsOfNames,
 555     ivbsaxattributes_Invoke,
 556     ivbsaxattributes_get_length,
 557     ivbsaxattributes_getURI,
 558     ivbsaxattributes_getLocalName,
 559     ivbsaxattributes_getQName,
 560     ivbsaxattributes_getIndexFromName,
 561     ivbsaxattributes_getIndexFromQName,
 562     ivbsaxattributes_getType,
 563     ivbsaxattributes_getTypeFromName,
 564     ivbsaxattributes_getTypeFromQName,
 565     ivbsaxattributes_getValue,
 566     ivbsaxattributes_getValueFromName,
 567     ivbsaxattributes_getValueFromQName
 568 };
 569
 570 /*** ISAXAttributes interface ***/
 571 /*** IUnknown methods ***/
 572 static HRESULT WINAPI isaxattributes_QueryInterface(
 573         ISAXAttributes* iface,
 574         REFIID riid,
 575         void **ppvObject)
 576 {
 577     saxattributes *This = impl_from_ISAXAttributes(iface);
 578
 579     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 580
 581     *ppvObject = NULL;
 582
 583     if (IsEqualGUID(riid, &IID_IUnknown) ||
 584             IsEqualGUID(riid, &IID_ISAXAttributes))
 585     {
 586         *ppvObject = iface;
 587     }
 588     else
 589     {
 590         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 591         return E_NOINTERFACE;
 592     }
 593
 594     ISAXAttributes_AddRef(iface);
 595
 596     return S_OK;
 597 }
 598
 599 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
 600 {
 601     saxattributes *This = impl_from_ISAXAttributes(iface);
 602     TRACE("%p\n", This);
 603     return InterlockedIncrement(&This->ref);
 604 }
 605
 606 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
 607 {
 608     saxattributes *This = impl_from_ISAXAttributes(iface);
 609     LONG ref;
 610
 611     TRACE("%p\n", This);
 612
 613     ref = InterlockedDecrement(&This->ref);
 614     if (ref==0)
 615     {
 616         int index;
 617         for(index=0; index<This->nb_attributes; index++)
 618         {
 619             SysFreeString(This->szLocalname[index]);
 620             SysFreeString(This->szURI[index]);
 621             SysFreeString(This->szValue[index]);
 622             SysFreeString(This->szQName[index]);
 623         }
 624
 625         heap_free(This->szLocalname);
 626         heap_free(This->szURI);
 627         heap_free(This->szValue);
 628         heap_free(This->szQName);
 629
 630         heap_free(This);
 631     }
 632
 633     return ref;
 634 }
 635
 636 /*** ISAXAttributes methods ***/
 637 static HRESULT WINAPI isaxattributes_getLength(
 638         ISAXAttributes* iface,
 639         int *length)
 640 {
 641     saxattributes *This = impl_from_ISAXAttributes( iface );
 642
 643     *length = This->nb_attributes;
 644     TRACE("Length set to %d\n", *length);
 645     return S_OK;
 646 }
 647
 648 static HRESULT WINAPI isaxattributes_getURI(
 649         ISAXAttributes* iface,
 650         int nIndex,
 651         const WCHAR **pUrl,
 652         int *pUriSize)
 653 {
 654     saxattributes *This = impl_from_ISAXAttributes( iface );
 655     TRACE("(%p)->(%d)\n", This, nIndex);
 656
 657     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 658     if(!pUrl || !pUriSize) return E_POINTER;
 659
 660     *pUriSize = SysStringLen(This->szURI[nIndex]);
 661     *pUrl = This->szURI[nIndex];
 662
 663     return S_OK;
 664 }
 665
 666 static HRESULT WINAPI isaxattributes_getLocalName(
 667         ISAXAttributes* iface,
 668         int nIndex,
 669         const WCHAR **pLocalName,
 670         int *pLocalNameLength)
 671 {
 672     saxattributes *This = impl_from_ISAXAttributes( iface );
 673     TRACE("(%p)->(%d)\n", This, nIndex);
 674
 675     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 676     if(!pLocalName || !pLocalNameLength) return E_POINTER;
 677
 678     *pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
 679     *pLocalName = This->szLocalname[nIndex];
 680
 681     return S_OK;
 682 }
 683
 684 static HRESULT WINAPI isaxattributes_getQName(
 685         ISAXAttributes* iface,
 686         int nIndex,
 687         const WCHAR **pQName,
 688         int *pQNameLength)
 689 {
 690     saxattributes *This = impl_from_ISAXAttributes( iface );
 691     TRACE("(%p)->(%d)\n", This, nIndex);
 692
 693     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 694     if(!pQName || !pQNameLength) return E_POINTER;
 695
 696     *pQNameLength = SysStringLen(This->szQName[nIndex]);
 697     *pQName = This->szQName[nIndex];
 698
 699     return S_OK;
 700 }
 701
 702 static HRESULT WINAPI isaxattributes_getName(
 703         ISAXAttributes* iface,
 704         int nIndex,
 705         const WCHAR **pUri,
 706         int *pUriLength,
 707         const WCHAR **pLocalName,
 708         int *pLocalNameSize,
 709         const WCHAR **pQName,
 710         int *pQNameLength)
 711 {
 712     saxattributes *This = impl_from_ISAXAttributes( iface );
 713     TRACE("(%p)->(%d)\n", This, nIndex);
 714
 715     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 716     if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
 717             || !pQName || !pQNameLength) return E_POINTER;
 718
 719     *pUriLength = SysStringLen(This->szURI[nIndex]);
 720     *pUri = This->szURI[nIndex];
 721     *pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
 722     *pLocalName = This->szLocalname[nIndex];
 723     *pQNameLength = SysStringLen(This->szQName[nIndex]);
 724     *pQName = This->szQName[nIndex];
 725
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI isaxattributes_getIndexFromName(
 730         ISAXAttributes* iface,
 731         const WCHAR *pUri,
 732         int cUriLength,
 733         const WCHAR *pLocalName,
 734         int cocalNameLength,
 735         int *index)
 736 {
 737     saxattributes *This = impl_from_ISAXAttributes( iface );
 738     int i;
 739     TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
 740             debugstr_w(pLocalName), cocalNameLength);
 741
 742     if(!pUri || !pLocalName || !index) return E_POINTER;
 743
 744     for(i=0; i<This->nb_attributes; i++)
 745     {
 746         if(cUriLength!=SysStringLen(This->szURI[i])
 747                 || cocalNameLength!=SysStringLen(This->szLocalname[i]))
 748             continue;
 749         if(cUriLength && memcmp(pUri, This->szURI[i],
 750                     sizeof(WCHAR)*cUriLength))
 751             continue;
 752         if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
 753                     sizeof(WCHAR)*cocalNameLength))
 754             continue;
 755
 756         *index = i;
 757         return S_OK;
 758     }
 759
 760     return E_INVALIDARG;
 761 }
 762
 763 static HRESULT WINAPI isaxattributes_getIndexFromQName(
 764         ISAXAttributes* iface,
 765         const WCHAR *pQName,
 766         int nQNameLength,
 767         int *index)
 768 {
 769     saxattributes *This = impl_from_ISAXAttributes( iface );
 770     int i;
 771     TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQNameLength);
 772
 773     if(!pQName || !index) return E_POINTER;
 774     if(!nQNameLength) return E_INVALIDARG;
 775
 776     for(i=0; i<This->nb_attributes; i++)
 777     {
 778         if(nQNameLength!=SysStringLen(This->szQName[i])) continue;
 779         if(memcmp(pQName, This->szQName, sizeof(WCHAR)*nQNameLength)) continue;
 780
 781         *index = i;
 782         return S_OK;
 783     }
 784
 785     return E_INVALIDARG;
 786 }
 787
 788 static HRESULT WINAPI isaxattributes_getType(
 789         ISAXAttributes* iface,
 790         int nIndex,
 791         const WCHAR **pType,
 792         int *pTypeLength)
 793 {
 794     saxattributes *This = impl_from_ISAXAttributes( iface );
 795
 796     FIXME("(%p)->(%d) stub\n", This, nIndex);
 797     return E_NOTIMPL;
 798 }
 799
 800 static HRESULT WINAPI isaxattributes_getTypeFromName(
 801         ISAXAttributes* iface,
 802         const WCHAR *pUri,
 803         int nUri,
 804         const WCHAR *pLocalName,
 805         int nLocalName,
 806         const WCHAR **pType,
 807         int *nType)
 808 {
 809     saxattributes *This = impl_from_ISAXAttributes( iface );
 810
 811     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
 812             debugstr_w(pLocalName), nLocalName);
 813     return E_NOTIMPL;
 814 }
 815
 816 static HRESULT WINAPI isaxattributes_getTypeFromQName(
 817         ISAXAttributes* iface,
 818         const WCHAR *pQName,
 819         int nQName,
 820         const WCHAR **pType,
 821         int *nType)
 822 {
 823     saxattributes *This = impl_from_ISAXAttributes( iface );
 824
 825     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI isaxattributes_getValue(
 830         ISAXAttributes* iface,
 831         int nIndex,
 832         const WCHAR **pValue,
 833         int *nValue)
 834 {
 835     saxattributes *This = impl_from_ISAXAttributes( iface );
 836     TRACE("(%p)->(%d)\n", This, nIndex);
 837
 838     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 839     if(!pValue || !nValue) return E_POINTER;
 840
 841     *nValue = SysStringLen(This->szValue[nIndex]);
 842     *pValue = This->szValue[nIndex];
 843
 844     return S_OK;
 845 }
 846
 847 static HRESULT WINAPI isaxattributes_getValueFromName(
 848         ISAXAttributes* iface,
 849         const WCHAR *pUri,
 850         int nUri,
 851         const WCHAR *pLocalName,
 852         int nLocalName,
 853         const WCHAR **pValue,
 854         int *nValue)
 855 {
 856     HRESULT hr;
 857     int index;
 858     saxattributes *This = impl_from_ISAXAttributes( iface );
 859     TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), nUri,
 860             debugstr_w(pLocalName), nLocalName);
 861
 862     hr = ISAXAttributes_getIndexFromName(iface,
 863             pUri, nUri, pLocalName, nLocalName, &index);
 864     if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
 865
 866     return hr;
 867 }
 868
 869 static HRESULT WINAPI isaxattributes_getValueFromQName(
 870         ISAXAttributes* iface,
 871         const WCHAR *pQName,
 872         int nQName,
 873         const WCHAR **pValue,
 874         int *nValue)
 875 {
 876     HRESULT hr;
 877     int index;
 878     saxattributes *This = impl_from_ISAXAttributes( iface );
 879     TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQName);
 880
 881     hr = ISAXAttributes_getIndexFromQName(iface, pQName, nQName, &index);
 882     if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
 883
 884     return hr;
 885 }
 886
 887 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
 888 {
 889     isaxattributes_QueryInterface,
 890     isaxattributes_AddRef,
 891     isaxattributes_Release,
 892     isaxattributes_getLength,
 893     isaxattributes_getURI,
 894     isaxattributes_getLocalName,
 895     isaxattributes_getQName,
 896     isaxattributes_getName,
 897     isaxattributes_getIndexFromName,
 898     isaxattributes_getIndexFromQName,
 899     isaxattributes_getType,
 900     isaxattributes_getTypeFromName,
 901     isaxattributes_getTypeFromQName,
 902     isaxattributes_getValue,
 903     isaxattributes_getValueFromName,
 904     isaxattributes_getValueFromQName
 905 };
 906
 907 static HRESULT SAXAttributes_create(saxattributes **attr,
 908         int nb_namespaces, const xmlChar **xmlNamespaces,
 909         int nb_attributes, const xmlChar **xmlAttributes)
 910 {
 911     saxattributes *attributes;
 912     int index;
 913     static const xmlChar xmlns[] = "xmlns";
 914
 915     attributes = heap_alloc(sizeof(*attributes));
 916     if(!attributes)
 917         return E_OUTOFMEMORY;
 918
 919     attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
 920     attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
 921     attributes->ref = 1;
 922
 923     attributes->nb_attributes = nb_namespaces+nb_attributes;
 924
 925     attributes->szLocalname = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
 926     attributes->szURI = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
 927     attributes->szValue = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
 928     attributes->szQName = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
 929
 930     if(!attributes->szLocalname || !attributes->szURI
 931             || !attributes->szValue || !attributes->szQName)
 932     {
 933         heap_free(attributes->szLocalname);
 934         heap_free(attributes->szURI);
 935         heap_free(attributes->szValue);
 936         heap_free(attributes->szQName);
 937         heap_free(attributes);
 938         return E_FAIL;
 939     }
 940
 941     for(index=0; index<nb_namespaces; index++)
 942     {
 943         attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
 944         attributes->szURI[index] = SysAllocStringLen(NULL, 0);
 945         attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
 946         attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
 947     }
 948
 949     for(index=0; index<nb_attributes; index++)
 950     {
 951         attributes->szLocalname[nb_namespaces+index] =
 952             bstr_from_xmlChar(xmlAttributes[index*5]);
 953         attributes->szURI[nb_namespaces+index] =
 954             bstr_from_xmlChar(xmlAttributes[index*5+2]);
 955         attributes->szValue[nb_namespaces+index] =
 956             bstr_from_xmlCharN(xmlAttributes[index*5+3],
 957                     xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
 958         attributes->szQName[nb_namespaces+index] =
 959             QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
 960     }
 961
 962     *attr = attributes;
 963
 964     TRACE("returning %p\n", *attr);
 965
 966     return S_OK;
 967 }
 968
 969 /*** LibXML callbacks ***/
 970 static void libxmlStartDocument(void *ctx)
 971 {
 972     saxlocator *This = ctx;
 973     HRESULT hr;
 974
 975     if(has_content_handler(This))
 976     {
 977         if(This->vbInterface)
 978             hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
 979         else
 980             hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
 981
 982         if(hr != S_OK)
 983             format_error_message_from_id(This, hr);
 984     }
 985
 986     update_position(This, NULL);
 987 }
 988
 989 static void libxmlEndDocument(void *ctx)
 990 {
 991     saxlocator *This = ctx;
 992     HRESULT hr;
 993
 994     This->column = 0;
 995     This->line = 0;
 996
 997     if(This->ret != S_OK) return;
 998
 999     if(has_content_handler(This))
1000     {
1001         if(This->vbInterface)
1002             hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1003         else
1004             hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1005
1006         if(hr != S_OK)
1007             format_error_message_from_id(This, hr);
1008     }
1009 }
1010
1011 static void libxmlStartElementNS(
1012         void *ctx,
1013         const xmlChar *localname,
1014         const xmlChar *prefix,
1015         const xmlChar *URI,
1016         int nb_namespaces,
1017         const xmlChar **namespaces,
1018         int nb_attributes,
1019         int nb_defaulted,
1020         const xmlChar **attributes)
1021 {
1022     BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
1023     saxlocator *This = ctx;
1024     HRESULT hr;
1025     saxattributes *attr;
1026     int index;
1027
1028     if(*(This->pParserCtxt->input->cur) == '/')
1029         update_position(This, (xmlChar*)This->pParserCtxt->input->cur+2);
1030     else
1031         update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
1032
1033     hr = namespacePush(This, nb_namespaces);
1034     if(hr==S_OK && has_content_handler(This))
1035     {
1036         for(index=0; index<nb_namespaces; index++)
1037         {
1038             Prefix = bstr_from_xmlChar(namespaces[2*index]);
1039             Uri = bstr_from_xmlChar(namespaces[2*index+1]);
1040
1041             if(This->vbInterface)
1042                 hr = IVBSAXContentHandler_startPrefixMapping(
1043                         This->saxreader->vbcontentHandler,
1044                         &Prefix, &Uri);
1045             else
1046                 hr = ISAXContentHandler_startPrefixMapping(
1047                         This->saxreader->contentHandler,
1048                         Prefix, SysStringLen(Prefix),
1049                         Uri, SysStringLen(Uri));
1050
1051             SysFreeString(Prefix);
1052             SysFreeString(Uri);
1053
1054             if(hr != S_OK)
1055             {
1056                 format_error_message_from_id(This, hr);
1057                 return;
1058             }
1059         }
1060
1061         NamespaceUri = bstr_from_xmlChar(URI);
1062         LocalName = bstr_from_xmlChar(localname);
1063         QName = QName_from_xmlChar(prefix, localname);
1064
1065         hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
1066         if(hr == S_OK)
1067         {
1068             if(This->vbInterface)
1069                 hr = IVBSAXContentHandler_startElement(
1070                         This->saxreader->vbcontentHandler,
1071                         &NamespaceUri, &LocalName, &QName,
1072                         (IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
1073             else
1074                 hr = ISAXContentHandler_startElement(
1075                         This->saxreader->contentHandler,
1076                         NamespaceUri, SysStringLen(NamespaceUri),
1077                         LocalName, SysStringLen(LocalName),
1078                         QName, SysStringLen(QName),
1079                         (ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1080
1081             ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1082         }
1083
1084         SysFreeString(NamespaceUri);
1085         SysFreeString(LocalName);
1086         SysFreeString(QName);
1087     }
1088
1089     if(hr != S_OK)
1090         format_error_message_from_id(This, hr);
1091 }
1092
1093 static void libxmlEndElementNS(
1094         void *ctx,
1095         const xmlChar *localname,
1096         const xmlChar *prefix,
1097         const xmlChar *URI)
1098 {
1099     BSTR NamespaceUri, LocalName, QName, Prefix;
1100     saxlocator *This = ctx;
1101     HRESULT hr;
1102     xmlChar *end;
1103     int nsNr, index;
1104
1105     end = (xmlChar*)This->pParserCtxt->input->cur;
1106     if(*(end-1) != '>' || *(end-2) != '/')
1107         while(end-2>=This->pParserCtxt->input->base
1108                 && *(end-2)!='<' && *(end-1)!='/') end--;
1109
1110     update_position(This, end);
1111
1112     nsNr = namespacePop(This);
1113
1114     if(has_content_handler(This))
1115     {
1116         NamespaceUri = bstr_from_xmlChar(URI);
1117         LocalName = bstr_from_xmlChar(localname);
1118         QName = QName_from_xmlChar(prefix, localname);
1119
1120         if(This->vbInterface)
1121             hr = IVBSAXContentHandler_endElement(
1122                     This->saxreader->vbcontentHandler,
1123                     &NamespaceUri, &LocalName, &QName);
1124         else
1125             hr = ISAXContentHandler_endElement(
1126                     This->saxreader->contentHandler,
1127                     NamespaceUri, SysStringLen(NamespaceUri),
1128                     LocalName, SysStringLen(LocalName),
1129                     QName, SysStringLen(QName));
1130
1131         SysFreeString(NamespaceUri);
1132         SysFreeString(LocalName);
1133         SysFreeString(QName);
1134
1135         if(hr != S_OK)
1136         {
1137             format_error_message_from_id(This, hr);
1138             return;
1139         }
1140
1141         for(index=This->pParserCtxt->nsNr-2;
1142                 index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
1143         {
1144             Prefix = bstr_from_xmlChar(This->pParserCtxt->nsTab[index]);
1145
1146             if(This->vbInterface)
1147                 hr = IVBSAXContentHandler_endPrefixMapping(
1148                         This->saxreader->vbcontentHandler, &Prefix);
1149             else
1150                 hr = ISAXContentHandler_endPrefixMapping(
1151                         This->saxreader->contentHandler,
1152                         Prefix, SysStringLen(Prefix));
1153
1154             SysFreeString(Prefix);
1155
1156             if(hr != S_OK)
1157             {
1158                 format_error_message_from_id(This, hr);
1159                 return;
1160             }
1161
1162         }
1163     }
1164
1165     update_position(This, NULL);
1166 }
1167
1168 static void libxmlCharacters(
1169         void *ctx,
1170         const xmlChar *ch,
1171         int len)
1172 {
1173     saxlocator *This = ctx;
1174     BSTR Chars;
1175     HRESULT hr;
1176     xmlChar *cur;
1177     xmlChar *end;
1178     BOOL lastEvent = FALSE;
1179
1180     if(!(has_content_handler(This))) return;
1181
1182     cur = (xmlChar*)ch;
1183     if(*(ch-1)=='\r') cur--;
1184     end = cur;
1185
1186     if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1187         This->column++;
1188
1189     while(1)
1190     {
1191         while(end-ch<len && *end!='\r') end++;
1192         if(end-ch==len)
1193         {
1194             end--;
1195             lastEvent = TRUE;
1196         }
1197
1198         if(!lastEvent) *end = '\n';
1199
1200         Chars = bstr_from_xmlCharN(cur, end-cur+1);
1201         if(This->vbInterface)
1202             hr = IVBSAXContentHandler_characters(
1203                     This->saxreader->vbcontentHandler, &Chars);
1204         else
1205             hr = ISAXContentHandler_characters(
1206                     This->saxreader->contentHandler,
1207                     Chars, SysStringLen(Chars));
1208         SysFreeString(Chars);
1209
1210         if(hr != S_OK)
1211         {
1212             format_error_message_from_id(This, hr);
1213             return;
1214         }
1215
1216         This->column += end-cur+1;
1217
1218         if(lastEvent)
1219             break;
1220
1221         *end = '\r';
1222         end++;
1223         if(*end == '\n')
1224         {
1225             end++;
1226             This->column++;
1227         }
1228         cur = end;
1229
1230         if(end-ch == len) break;
1231     }
1232
1233     if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1234         This->column = This->realColumn
1235             +This->pParserCtxt->input->cur-This->lastCur;
1236 }
1237
1238 static void libxmlSetDocumentLocator(
1239         void *ctx,
1240         xmlSAXLocatorPtr loc)
1241 {
1242     saxlocator *This = ctx;
1243     HRESULT hr = S_OK;
1244
1245     if(has_content_handler(This))
1246     {
1247         if(This->vbInterface)
1248             hr = IVBSAXContentHandler_putref_documentLocator(
1249                     This->saxreader->vbcontentHandler,
1250                     (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
1251         else
1252             hr = ISAXContentHandler_putDocumentLocator(
1253                     This->saxreader->contentHandler,
1254                     (ISAXLocator*)&This->lpSAXLocatorVtbl);
1255     }
1256
1257     if(FAILED(hr))
1258         format_error_message_from_id(This, hr);
1259 }
1260
1261 static void libxmlComment(void *ctx, const xmlChar *value)
1262 {
1263     saxlocator *This = ctx;
1264     BSTR bValue;
1265     HRESULT hr;
1266     xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur;
1267
1268     while(beg-4>=This->pParserCtxt->input->base
1269             && memcmp(beg-4, "<!--", sizeof(char[4]))) beg--;
1270     update_position(This, beg);
1271
1272     if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1273     if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1274
1275     bValue = bstr_from_xmlChar(value);
1276
1277     if(This->vbInterface)
1278         hr = IVBSAXLexicalHandler_comment(
1279                 This->saxreader->vblexicalHandler, &bValue);
1280     else
1281         hr = ISAXLexicalHandler_comment(
1282                 This->saxreader->lexicalHandler,
1283                 bValue, SysStringLen(bValue));
1284
1285     SysFreeString(bValue);
1286
1287     if(FAILED(hr))
1288         format_error_message_from_id(This, hr);
1289
1290     update_position(This, NULL);
1291 }
1292
1293 static void libxmlFatalError(void *ctx, const char *msg, ...)
1294 {
1295     saxlocator *This = ctx;
1296     char message[1024];
1297     WCHAR *error;
1298     DWORD len;
1299     va_list args;
1300
1301     va_start(args, msg);
1302     vsprintf(message, msg, args);
1303     va_end(args);
1304
1305     len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1306     error = heap_alloc(sizeof(WCHAR)*len);
1307     if(error)
1308     {
1309         MultiByteToWideChar(CP_UNIXCP, 0, message, -1, error, len);
1310         TRACE("fatal error for %p: %s\n", This, debugstr_w(error));
1311     }
1312
1313     if(!has_error_handler(This))
1314     {
1315         xmlStopParser(This->pParserCtxt);
1316         This->ret = E_FAIL;
1317         heap_free(error);
1318         return;
1319     }
1320
1321     FIXME("Error handling is not compatible.\n");
1322
1323     if(This->vbInterface)
1324     {
1325         BSTR bstrError = SysAllocString(error);
1326         IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
1327                 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
1328         SysFreeString(bstrError);
1329     }
1330     else
1331         ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
1332                 (ISAXLocator*)&This->lpSAXLocatorVtbl, error, E_FAIL);
1333
1334     heap_free(error);
1335
1336     xmlStopParser(This->pParserCtxt);
1337     This->ret = E_FAIL;
1338 }
1339
1340 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1341 {
1342     saxlocator *This = ctx;
1343     HRESULT hr = S_OK;
1344     xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1345     xmlChar *cur, *end;
1346     int realLen;
1347     BSTR Chars;
1348     BOOL lastEvent = FALSE, change;
1349
1350     while(beg-9>=This->pParserCtxt->input->base
1351             && memcmp(beg-9, "<![CDATA[", sizeof(char[9]))) beg--;
1352     update_position(This, beg);
1353
1354     if(This->vbInterface && This->saxreader->vblexicalHandler)
1355         hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1356     if(!This->vbInterface && This->saxreader->lexicalHandler)
1357         hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1358
1359     if(FAILED(hr))
1360     {
1361         format_error_message_from_id(This, hr);
1362         return;
1363     }
1364
1365     realLen = This->pParserCtxt->input->cur-beg-3;
1366     cur = beg;
1367     end = beg;
1368
1369     while(1)
1370     {
1371         while(end-beg<realLen && *end!='\r') end++;
1372         if(end-beg==realLen)
1373         {
1374             end--;
1375             lastEvent = TRUE;
1376         }
1377         else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1378             lastEvent = TRUE;
1379
1380         if(*end == '\r') change = TRUE;
1381         else change = FALSE;
1382
1383         if(change) *end = '\n';
1384
1385         if(has_content_handler(This))
1386         {
1387             Chars = bstr_from_xmlCharN(cur, end-cur+1);
1388             if(This->vbInterface)
1389                 hr = IVBSAXContentHandler_characters(
1390                         This->saxreader->vbcontentHandler, &Chars);
1391             else
1392                 hr = ISAXContentHandler_characters(
1393                         This->saxreader->contentHandler,
1394                         Chars, SysStringLen(Chars));
1395             SysFreeString(Chars);
1396         }
1397
1398         if(change) *end = '\r';
1399
1400         if(lastEvent)
1401             break;
1402
1403         This->column += end-cur+2;
1404         end += 2;
1405         cur = end;
1406     }
1407
1408     if(This->vbInterface && This->saxreader->vblexicalHandler)
1409         hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1410     if(!This->vbInterface && This->saxreader->lexicalHandler)
1411         hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1412
1413     if(FAILED(hr))
1414         format_error_message_from_id(This, hr);
1415
1416     This->column += 4+end-cur;
1417 }
1418
1419 /*** IVBSAXLocator interface ***/
1420 /*** IUnknown methods ***/
1421 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1422 {
1423     saxlocator *This = impl_from_IVBSAXLocator( iface );
1424
1425     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1426
1427     *ppvObject = NULL;
1428
1429     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1430             IsEqualGUID( riid, &IID_IDispatch) ||
1431             IsEqualGUID( riid, &IID_IVBSAXLocator ))
1432     {
1433         *ppvObject = iface;
1434     }
1435     else
1436     {
1437         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1438         return E_NOINTERFACE;
1439     }
1440
1441     IVBSAXLocator_AddRef( iface );
1442
1443     return S_OK;
1444 }
1445
1446 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1447 {
1448     saxlocator *This = impl_from_IVBSAXLocator( iface );
1449     TRACE("%p\n", This );
1450     return InterlockedIncrement( &This->ref );
1451 }
1452
1453 static ULONG WINAPI ivbsaxlocator_Release(
1454         IVBSAXLocator* iface)
1455 {
1456     saxlocator *This = impl_from_IVBSAXLocator( iface );
1457     return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1458 }
1459
1460 /*** IDispatch methods ***/
1461 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1462 {
1463     saxlocator *This = impl_from_IVBSAXLocator( iface );
1464
1465     TRACE("(%p)->(%p)\n", This, pctinfo);
1466
1467     *pctinfo = 1;
1468
1469     return S_OK;
1470 }
1471
1472 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1473     IVBSAXLocator *iface,
1474     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1475 {
1476     saxlocator *This = impl_from_IVBSAXLocator( iface );
1477     HRESULT hr;
1478
1479     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1480
1481     hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1482
1483     return hr;
1484 }
1485
1486 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1487     IVBSAXLocator *iface,
1488     REFIID riid,
1489     LPOLESTR* rgszNames,
1490     UINT cNames,
1491     LCID lcid,
1492     DISPID* rgDispId)
1493 {
1494     saxlocator *This = impl_from_IVBSAXLocator( iface );
1495     ITypeInfo *typeinfo;
1496     HRESULT hr;
1497
1498     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1499           lcid, rgDispId);
1500
1501     if(!rgszNames || cNames == 0 || !rgDispId)
1502         return E_INVALIDARG;
1503
1504     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1505     if(SUCCEEDED(hr))
1506     {
1507         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1508         ITypeInfo_Release(typeinfo);
1509     }
1510
1511     return hr;
1512 }
1513
1514 static HRESULT WINAPI ivbsaxlocator_Invoke(
1515     IVBSAXLocator *iface,
1516     DISPID dispIdMember,
1517     REFIID riid,
1518     LCID lcid,
1519     WORD wFlags,
1520     DISPPARAMS* pDispParams,
1521     VARIANT* pVarResult,
1522     EXCEPINFO* pExcepInfo,
1523     UINT* puArgErr)
1524 {
1525     saxlocator *This = impl_from_IVBSAXLocator( iface );
1526     ITypeInfo *typeinfo;
1527     HRESULT hr;
1528
1529     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1530           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1531
1532     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1533     if(SUCCEEDED(hr))
1534     {
1535         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1536                 pVarResult, pExcepInfo, puArgErr);
1537         ITypeInfo_Release(typeinfo);
1538     }
1539
1540     return hr;
1541 }
1542
1543 /*** IVBSAXLocator methods ***/
1544 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1545         IVBSAXLocator* iface,
1546         int *pnColumn)
1547 {
1548     saxlocator *This = impl_from_IVBSAXLocator( iface );
1549     return ISAXLocator_getColumnNumber(
1550             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1551             pnColumn);
1552 }
1553
1554 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1555         IVBSAXLocator* iface,
1556         int *pnLine)
1557 {
1558     saxlocator *This = impl_from_IVBSAXLocator( iface );
1559     return ISAXLocator_getLineNumber(
1560             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1561             pnLine);
1562 }
1563
1564 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1565         IVBSAXLocator* iface,
1566         BSTR* publicId)
1567 {
1568     saxlocator *This = impl_from_IVBSAXLocator( iface );
1569     return ISAXLocator_getPublicId(
1570             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1571             (const WCHAR**)publicId);
1572 }
1573
1574 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1575         IVBSAXLocator* iface,
1576         BSTR* systemId)
1577 {
1578     saxlocator *This = impl_from_IVBSAXLocator( iface );
1579     return ISAXLocator_getSystemId(
1580             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1581             (const WCHAR**)systemId);
1582 }
1583
1584 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1585 {
1586     ivbsaxlocator_QueryInterface,
1587     ivbsaxlocator_AddRef,
1588     ivbsaxlocator_Release,
1589     ivbsaxlocator_GetTypeInfoCount,
1590     ivbsaxlocator_GetTypeInfo,
1591     ivbsaxlocator_GetIDsOfNames,
1592     ivbsaxlocator_Invoke,
1593     ivbsaxlocator_get_columnNumber,
1594     ivbsaxlocator_get_lineNumber,
1595     ivbsaxlocator_get_publicId,
1596     ivbsaxlocator_get_systemId
1597 };
1598
1599 /*** ISAXLocator interface ***/
1600 /*** IUnknown methods ***/
1601 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1602 {
1603     saxlocator *This = impl_from_ISAXLocator( iface );
1604
1605     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1606
1607     *ppvObject = NULL;
1608
1609     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1610             IsEqualGUID( riid, &IID_ISAXLocator ))
1611     {
1612         *ppvObject = iface;
1613     }
1614     else
1615     {
1616         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1617         return E_NOINTERFACE;
1618     }
1619
1620     ISAXLocator_AddRef( iface );
1621
1622     return S_OK;
1623 }
1624
1625 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1626 {
1627     saxlocator *This = impl_from_ISAXLocator( iface );
1628     TRACE("%p\n", This );
1629     return InterlockedIncrement( &This->ref );
1630 }
1631
1632 static ULONG WINAPI isaxlocator_Release(
1633         ISAXLocator* iface)
1634 {
1635     saxlocator *This = impl_from_ISAXLocator( iface );
1636     LONG ref;
1637
1638     TRACE("%p\n", This );
1639
1640     ref = InterlockedDecrement( &This->ref );
1641     if ( ref == 0 )
1642     {
1643         SysFreeString(This->publicId);
1644         SysFreeString(This->systemId);
1645         heap_free(This->nsStack);
1646
1647         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1648         heap_free( This );
1649     }
1650
1651     return ref;
1652 }
1653
1654 /*** ISAXLocator methods ***/
1655 static HRESULT WINAPI isaxlocator_getColumnNumber(
1656         ISAXLocator* iface,
1657         int *pnColumn)
1658 {
1659     saxlocator *This = impl_from_ISAXLocator( iface );
1660
1661     *pnColumn = This->column;
1662     return S_OK;
1663 }
1664
1665 static HRESULT WINAPI isaxlocator_getLineNumber(
1666         ISAXLocator* iface,
1667         int *pnLine)
1668 {
1669     saxlocator *This = impl_from_ISAXLocator( iface );
1670
1671     *pnLine = This->line;
1672     return S_OK;
1673 }
1674
1675 static HRESULT WINAPI isaxlocator_getPublicId(
1676         ISAXLocator* iface,
1677         const WCHAR ** ppwchPublicId)
1678 {
1679     BSTR publicId;
1680     saxlocator *This = impl_from_ISAXLocator( iface );
1681
1682     SysFreeString(This->publicId);
1683
1684     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1685     if(SysStringLen(publicId))
1686         This->publicId = (WCHAR*)&publicId;
1687     else
1688     {
1689         SysFreeString(publicId);
1690         This->publicId = NULL;
1691     }
1692
1693     *ppwchPublicId = This->publicId;
1694     return S_OK;
1695 }
1696
1697 static HRESULT WINAPI isaxlocator_getSystemId(
1698         ISAXLocator* iface,
1699         const WCHAR ** ppwchSystemId)
1700 {
1701     BSTR systemId;
1702     saxlocator *This = impl_from_ISAXLocator( iface );
1703
1704     SysFreeString(This->systemId);
1705
1706     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1707     if(SysStringLen(systemId))
1708         This->systemId = (WCHAR*)&systemId;
1709     else
1710     {
1711         SysFreeString(systemId);
1712         This->systemId = NULL;
1713     }
1714
1715     *ppwchSystemId = This->systemId;
1716     return S_OK;
1717 }
1718
1719 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1720 {
1721     isaxlocator_QueryInterface,
1722     isaxlocator_AddRef,
1723     isaxlocator_Release,
1724     isaxlocator_getColumnNumber,
1725     isaxlocator_getLineNumber,
1726     isaxlocator_getPublicId,
1727     isaxlocator_getSystemId
1728 };
1729
1730 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1731 {
1732     saxlocator *locator;
1733
1734     locator = heap_alloc( sizeof (*locator) );
1735     if( !locator )
1736         return E_OUTOFMEMORY;
1737
1738     locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1739     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1740     locator->ref = 1;
1741     locator->vbInterface = vbInterface;
1742
1743     locator->saxreader = reader;
1744     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1745
1746     locator->pParserCtxt = NULL;
1747     locator->publicId = NULL;
1748     locator->systemId = NULL;
1749     locator->lastCur = NULL;
1750     locator->line = 0;
1751     locator->column = 0;
1752     locator->ret = S_OK;
1753     locator->nsStackSize = 8;
1754     locator->nsStackLast = 0;
1755     locator->nsStack = heap_alloc(sizeof(int)*locator->nsStackSize);
1756     if(!locator->nsStack)
1757     {
1758         ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1759         heap_free(locator);
1760         return E_OUTOFMEMORY;
1761     }
1762
1763     *ppsaxlocator = locator;
1764
1765     TRACE("returning %p\n", *ppsaxlocator);
1766
1767     return S_OK;
1768 }
1769
1770 /*** SAXXMLReader internal functions ***/
1771 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1772 {
1773     xmlCharEncoding encoding = XML_CHAR_ENCODING_NONE;
1774     xmlChar *enc_name = NULL;
1775     saxlocator *locator;
1776     HRESULT hr;
1777
1778     hr = SAXLocator_create(This, &locator, vbInterface);
1779     if(FAILED(hr))
1780         return hr;
1781
1782     if (size >= 4)
1783     {
1784         const unsigned char *buff = (unsigned char*)buffer;
1785
1786         encoding = xmlDetectCharEncoding((xmlChar*)buffer, 4);
1787         enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
1788         TRACE("detected encoding: %s\n", enc_name);
1789         /* skip BOM, parser won't switch encodings and so won't skip it on its own */
1790         if ((encoding == XML_CHAR_ENCODING_UTF8) &&
1791             buff[0] == 0xEF && buff[1] == 0xBB && buff[2] == 0xBF)
1792         {
1793             buffer += 3;
1794             size -= 3;
1795         }
1796     }
1797
1798     locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1799     if(!locator->pParserCtxt)
1800     {
1801         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1802         return E_FAIL;
1803     }
1804
1805     if (encoding == XML_CHAR_ENCODING_UTF8)
1806         locator->pParserCtxt->encoding = xmlStrdup(enc_name);
1807
1808     xmlFree(locator->pParserCtxt->sax);
1809     locator->pParserCtxt->sax = &locator->saxreader->sax;
1810     locator->pParserCtxt->userData = locator;
1811
1812     This->isParsing = TRUE;
1813     if(xmlParseDocument(locator->pParserCtxt) == -1) hr = E_FAIL;
1814     else hr = locator->ret;
1815     This->isParsing = FALSE;
1816
1817     if(locator->pParserCtxt)
1818     {
1819         locator->pParserCtxt->sax = NULL;
1820         xmlFreeParserCtxt(locator->pParserCtxt);
1821         locator->pParserCtxt = NULL;
1822     }
1823
1824     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1825     return hr;
1826 }
1827
1828 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
1829 {
1830     saxlocator *locator;
1831     HRESULT hr;
1832     ULONG dataRead;
1833     char data[1024];
1834
1835     hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1836     if(hr != S_OK)
1837         return hr;
1838
1839     hr = SAXLocator_create(This, &locator, vbInterface);
1840     if(FAILED(hr))
1841         return hr;
1842
1843     locator->pParserCtxt = xmlCreatePushParserCtxt(
1844             &locator->saxreader->sax, locator,
1845             data, dataRead, NULL);
1846     if(!locator->pParserCtxt)
1847     {
1848         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1849         return E_FAIL;
1850     }
1851
1852     This->isParsing = TRUE;
1853     while(1)
1854     {
1855         hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1856         if(hr != S_OK)
1857             break;
1858
1859         if(xmlParseChunk(locator->pParserCtxt, data, dataRead, 0)) hr = E_FAIL;
1860         else hr = locator->ret;
1861
1862         if(hr != S_OK) break;
1863
1864         if(dataRead != sizeof(data))
1865         {
1866             if(xmlParseChunk(locator->pParserCtxt, data, 0, 1)) hr = E_FAIL;
1867             else hr = locator->ret;
1868
1869             break;
1870         }
1871     }
1872     This->isParsing = FALSE;
1873
1874     xmlFreeParserCtxt(locator->pParserCtxt);
1875     locator->pParserCtxt = NULL;
1876     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1877     return hr;
1878 }
1879
1880 static HRESULT internal_getEntityResolver(
1881         saxreader *This,
1882         void *pEntityResolver,
1883         BOOL vbInterface)
1884 {
1885     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1886     return E_NOTIMPL;
1887 }
1888
1889 static HRESULT internal_putEntityResolver(
1890         saxreader *This,
1891         void *pEntityResolver,
1892         BOOL vbInterface)
1893 {
1894     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1895     return E_NOTIMPL;
1896 }
1897
1898 static HRESULT internal_getContentHandler(
1899         saxreader* This,
1900         void *pContentHandler,
1901         BOOL vbInterface)
1902 {
1903     TRACE("(%p)->(%p)\n", This, pContentHandler);
1904     if(pContentHandler == NULL)
1905         return E_POINTER;
1906     if((vbInterface && This->vbcontentHandler)
1907             || (!vbInterface && This->contentHandler))
1908     {
1909         if(vbInterface)
1910             IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1911         else
1912             ISAXContentHandler_AddRef(This->contentHandler);
1913     }
1914     if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1915         This->vbcontentHandler;
1916     else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1917
1918     return S_OK;
1919 }
1920
1921 static HRESULT internal_putContentHandler(
1922         saxreader* This,
1923         void *contentHandler,
1924         BOOL vbInterface)
1925 {
1926     TRACE("(%p)->(%p)\n", This, contentHandler);
1927     if(contentHandler)
1928     {
1929         if(vbInterface)
1930             IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1931         else
1932             ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1933     }
1934     if((vbInterface && This->vbcontentHandler)
1935             || (!vbInterface && This->contentHandler))
1936     {
1937         if(vbInterface)
1938             IVBSAXContentHandler_Release(This->vbcontentHandler);
1939         else
1940             ISAXContentHandler_Release(This->contentHandler);
1941     }
1942     if(vbInterface)
1943         This->vbcontentHandler = contentHandler;
1944     else
1945         This->contentHandler = contentHandler;
1946
1947     return S_OK;
1948 }
1949
1950 static HRESULT internal_getDTDHandler(
1951         saxreader* This,
1952         void *pDTDHandler,
1953         BOOL vbInterface)
1954 {
1955     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1956     return E_NOTIMPL;
1957 }
1958
1959 static HRESULT internal_putDTDHandler(
1960         saxreader* This,
1961         void *pDTDHandler,
1962         BOOL vbInterface)
1963 {
1964     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1965     return E_NOTIMPL;
1966 }
1967
1968 static HRESULT internal_getErrorHandler(
1969         saxreader* This,
1970         void *pErrorHandler,
1971         BOOL vbInterface)
1972 {
1973     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1974     if(pErrorHandler == NULL)
1975         return E_POINTER;
1976
1977     if(vbInterface && This->vberrorHandler)
1978         IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1979     else if(!vbInterface && This->errorHandler)
1980         ISAXErrorHandler_AddRef(This->errorHandler);
1981
1982     if(vbInterface)
1983         *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1984     else
1985         *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1986
1987     return S_OK;
1988
1989 }
1990
1991 static HRESULT internal_putErrorHandler(
1992         saxreader* This,
1993         void *errorHandler,
1994         BOOL vbInterface)
1995 {
1996     TRACE("(%p)->(%p)\n", This, errorHandler);
1997     if(errorHandler)
1998     {
1999         if(vbInterface)
2000             IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
2001         else
2002             ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
2003     }
2004
2005     if(vbInterface && This->vberrorHandler)
2006         IVBSAXErrorHandler_Release(This->vberrorHandler);
2007     else if(!vbInterface && This->errorHandler)
2008         ISAXErrorHandler_Release(This->errorHandler);
2009
2010     if(vbInterface)
2011         This->vberrorHandler = errorHandler;
2012     else
2013         This->errorHandler = errorHandler;
2014
2015     return S_OK;
2016
2017 }
2018
2019 static HRESULT internal_parse(
2020         saxreader* This,
2021         VARIANT varInput,
2022         BOOL vbInterface)
2023 {
2024     HRESULT hr;
2025
2026     TRACE("(%p)\n", This);
2027
2028     hr = S_OK;
2029     switch(V_VT(&varInput))
2030     {
2031         case VT_BSTR:
2032             hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2033                     SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2034             break;
2035         case VT_ARRAY|VT_UI1: {
2036             void *pSAData;
2037             LONG lBound, uBound;
2038             ULONG dataRead;
2039
2040             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2041             if(hr != S_OK) break;
2042             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2043             if(hr != S_OK) break;
2044             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2045             hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2046             if(hr != S_OK) break;
2047             hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2048             SafeArrayUnaccessData(V_ARRAY(&varInput));
2049             break;
2050         }
2051         case VT_UNKNOWN:
2052         case VT_DISPATCH: {
2053             IPersistStream *persistStream;
2054             IStream *stream = NULL;
2055             IXMLDOMDocument *xmlDoc;
2056
2057             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2058                         &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2059             {
2060                 BSTR bstrData;
2061
2062                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2063                 hr = internal_parseBuffer(This, (const char*)bstrData,
2064                         SysStringByteLen(bstrData), vbInterface);
2065                 IXMLDOMDocument_Release(xmlDoc);
2066                 SysFreeString(bstrData);
2067                 break;
2068             }
2069
2070             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2071                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
2072             {
2073                 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2074                 if(hr != S_OK)
2075                 {
2076                     IPersistStream_Release(persistStream);
2077                     return hr;
2078                 }
2079
2080                 hr = IPersistStream_Save(persistStream, stream, TRUE);
2081                 IPersistStream_Release(persistStream);
2082                 if(hr != S_OK)
2083                 {
2084                     IStream_Release(stream);
2085                     break;
2086                 }
2087             }
2088             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2089                         &IID_IStream, (void**)&stream) == S_OK)
2090             {
2091                 hr = internal_parseStream(This, stream, vbInterface);
2092                 IStream_Release(stream);
2093                 break;
2094             }
2095         }
2096         default:
2097             WARN("vt %d not implemented\n", V_VT(&varInput));
2098             hr = E_INVALIDARG;
2099     }
2100
2101     return hr;
2102 }
2103
2104 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2105 {
2106     saxreader *This = obj;
2107
2108     return internal_parseBuffer(This, ptr, len, TRUE);
2109 }
2110
2111 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2112 {
2113     saxreader *This = obj;
2114
2115     return internal_parseBuffer(This, ptr, len, FALSE);
2116 }
2117
2118 static HRESULT internal_parseURL(
2119         saxreader* This,
2120         const WCHAR *url,
2121         BOOL vbInterface)
2122 {
2123     bsc_t *bsc;
2124     HRESULT hr;
2125
2126     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2127
2128     if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
2129     else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
2130
2131     if(FAILED(hr))
2132         return hr;
2133
2134     detach_bsc(bsc);
2135
2136     return S_OK;
2137 }
2138
2139 static HRESULT internal_putProperty(
2140     saxreader* This,
2141     const WCHAR *pProp,
2142     VARIANT value,
2143     BOOL vbInterface)
2144 {
2145     static const WCHAR wszCharset[] = {
2146         'c','h','a','r','s','e','t',0
2147     };
2148     static const WCHAR wszDeclarationHandler[] = {
2149         'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2150         's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2151         'd','e','c','l','a','r','a','t','i','o','n',
2152         '-','h','a','n','d','l','e','r',0
2153     };
2154     static const WCHAR wszDomNode[] = {
2155         'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2156         's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2157         'd','o','m','-','n','o','d','e',0
2158     };
2159     static const WCHAR wszInputSource[] = {
2160         'i','n','p','u','t','-','s','o','u','r','c','e',0
2161     };
2162     static const WCHAR wszLexicalHandler[] = {
2163         'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2164         's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2165         'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
2166     };
2167     static const WCHAR wszMaxElementDepth[] = {
2168         'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
2169     };
2170     static const WCHAR wszMaxXMLSize[] = {
2171         'm','a','x','-','x','m','l','-','s','i','z','e',0
2172     };
2173     static const WCHAR wszSchemaDeclarationHandler[] = {
2174         's','c','h','e','m','a','-',
2175         'd','e','c','l','a','r','a','t','i','o','n','-',
2176         'h','a','n','d','l','e','r',0
2177     };
2178     static const WCHAR wszXMLDeclEncoding[] = {
2179         'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
2180     };
2181     static const WCHAR wszXMLDeclStandalone[] = {
2182         'x','m','l','d','e','c','l',
2183         '-','s','t','a','n','d','a','l','o','n','e',0
2184     };
2185     static const WCHAR wszXMLDeclVersion[] = {
2186         'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
2187     };
2188
2189     TRACE("(%p)->(%s)\n", This, debugstr_w(pProp));
2190
2191     if(!memcmp(pProp, wszDeclarationHandler, sizeof(wszDeclarationHandler)))
2192     {
2193         if(This->isParsing) return E_FAIL;
2194
2195         if(V_UNKNOWN(&value))
2196         {
2197             if(vbInterface)
2198                 IVBSAXDeclHandler_AddRef((IVBSAXDeclHandler*)V_UNKNOWN(&value));
2199             else
2200                 ISAXDeclHandler_AddRef((ISAXDeclHandler*)V_UNKNOWN(&value));
2201         }
2202         if((vbInterface && This->vbdeclHandler)
2203                 || (!vbInterface && This->declHandler))
2204         {
2205             if(vbInterface)
2206                 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2207             else
2208                 ISAXDeclHandler_Release(This->declHandler);
2209         }
2210         if(vbInterface)
2211             This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2212         else
2213             This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2214         return S_OK;
2215     }
2216
2217     if(!memcmp(pProp, wszLexicalHandler, sizeof(wszLexicalHandler)))
2218     {
2219         if(This->isParsing) return E_FAIL;
2220
2221         if(V_UNKNOWN(&value))
2222         {
2223             if(vbInterface)
2224                 IVBSAXLexicalHandler_AddRef(
2225                         (IVBSAXLexicalHandler*)V_UNKNOWN(&value));
2226             else
2227                 ISAXLexicalHandler_AddRef(
2228                         (ISAXLexicalHandler*)V_UNKNOWN(&value));
2229         }
2230         if((vbInterface && This->vblexicalHandler)
2231                 || (!vbInterface && This->lexicalHandler))
2232         {
2233             if(vbInterface)
2234                 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2235             else
2236                 ISAXLexicalHandler_Release(This->lexicalHandler);
2237         }
2238         if(vbInterface)
2239             This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2240         else
2241             This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2242         return S_OK;
2243     }
2244
2245     FIXME("(%p)->(%s): unsupported property\n", This, debugstr_w(pProp));
2246
2247     if(!memcmp(pProp, wszCharset, sizeof(wszCharset)))
2248         return E_NOTIMPL;
2249
2250     if(!memcmp(pProp, wszDomNode, sizeof(wszDomNode)))
2251         return E_FAIL;
2252
2253     if(!memcmp(pProp, wszInputSource, sizeof(wszInputSource)))
2254         return E_NOTIMPL;
2255
2256     if(!memcmp(pProp, wszMaxElementDepth, sizeof(wszMaxElementDepth)))
2257         return E_NOTIMPL;
2258
2259     if(!memcmp(pProp, wszMaxXMLSize, sizeof(wszMaxXMLSize)))
2260         return E_NOTIMPL;
2261
2262     if(!memcmp(pProp, wszSchemaDeclarationHandler,
2263                 sizeof(wszSchemaDeclarationHandler)))
2264         return E_NOTIMPL;
2265
2266     if(!memcmp(pProp, wszXMLDeclEncoding, sizeof(wszXMLDeclEncoding)))
2267         return E_FAIL;
2268
2269     if(!memcmp(pProp, wszXMLDeclStandalone, sizeof(wszXMLDeclStandalone)))
2270         return E_FAIL;
2271
2272     if(!memcmp(pProp, wszXMLDeclVersion, sizeof(wszXMLDeclVersion)))
2273         return E_FAIL;
2274
2275     return E_INVALIDARG;
2276 }
2277
2278 /*** IVBSAXXMLReader interface ***/
2279 /*** IUnknown methods ***/
2280 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2281 {
2282     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2283
2284     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2285
2286     *ppvObject = NULL;
2287
2288     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2289          IsEqualGUID( riid, &IID_IDispatch ) ||
2290          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2291     {
2292         *ppvObject = iface;
2293     }
2294     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2295     {
2296         *ppvObject = &This->lpSAXXMLReaderVtbl;
2297     }
2298     else
2299     {
2300         FIXME("interface %s not implemented\n", debugstr_guid(riid));
2301         return E_NOINTERFACE;
2302     }
2303
2304     IVBSAXXMLReader_AddRef( iface );
2305
2306     return S_OK;
2307 }
2308
2309 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2310 {
2311     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2312     TRACE("%p\n", This );
2313     return InterlockedIncrement( &This->ref );
2314 }
2315
2316 static ULONG WINAPI saxxmlreader_Release(
2317     IVBSAXXMLReader* iface)
2318 {
2319     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2320     LONG ref;
2321
2322     TRACE("%p\n", This );
2323
2324     ref = InterlockedDecrement( &This->ref );
2325     if ( ref == 0 )
2326     {
2327         if(This->contentHandler)
2328             ISAXContentHandler_Release(This->contentHandler);
2329
2330         if(This->vbcontentHandler)
2331             IVBSAXContentHandler_Release(This->vbcontentHandler);
2332
2333         if(This->errorHandler)
2334             ISAXErrorHandler_Release(This->errorHandler);
2335
2336         if(This->vberrorHandler)
2337             IVBSAXErrorHandler_Release(This->vberrorHandler);
2338
2339         if(This->lexicalHandler)
2340             ISAXLexicalHandler_Release(This->lexicalHandler);
2341
2342         if(This->vblexicalHandler)
2343             IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2344
2345         if(This->declHandler)
2346             ISAXDeclHandler_Release(This->declHandler);
2347
2348         if(This->vbdeclHandler)
2349             IVBSAXDeclHandler_Release(This->vbdeclHandler);
2350
2351         heap_free( This );
2352     }
2353
2354     return ref;
2355 }
2356 /*** IDispatch ***/
2357 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2358 {
2359     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2360
2361     TRACE("(%p)->(%p)\n", This, pctinfo);
2362
2363     *pctinfo = 1;
2364
2365     return S_OK;
2366 }
2367
2368 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2369     IVBSAXXMLReader *iface,
2370     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2371 {
2372     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2373     HRESULT hr;
2374
2375     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2376
2377     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2378
2379     return hr;
2380 }
2381
2382 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2383     IVBSAXXMLReader *iface,
2384     REFIID riid,
2385     LPOLESTR* rgszNames,
2386     UINT cNames,
2387     LCID lcid,
2388     DISPID* rgDispId)
2389 {
2390     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2391     ITypeInfo *typeinfo;
2392     HRESULT hr;
2393
2394     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2395           lcid, rgDispId);
2396
2397     if(!rgszNames || cNames == 0 || !rgDispId)
2398         return E_INVALIDARG;
2399
2400     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2401     if(SUCCEEDED(hr))
2402     {
2403         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2404         ITypeInfo_Release(typeinfo);
2405     }
2406
2407     return hr;
2408 }
2409
2410 static HRESULT WINAPI saxxmlreader_Invoke(
2411     IVBSAXXMLReader *iface,
2412     DISPID dispIdMember,
2413     REFIID riid,
2414     LCID lcid,
2415     WORD wFlags,
2416     DISPPARAMS* pDispParams,
2417     VARIANT* pVarResult,
2418     EXCEPINFO* pExcepInfo,
2419     UINT* puArgErr)
2420 {
2421     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2422     ITypeInfo *typeinfo;
2423     HRESULT hr;
2424
2425     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2426           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2427
2428     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2429     if(SUCCEEDED(hr))
2430     {
2431         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
2432                 pVarResult, pExcepInfo, puArgErr);
2433         ITypeInfo_Release(typeinfo);
2434     }
2435
2436     return hr;
2437 }
2438
2439 /*** IVBSAXXMLReader methods ***/
2440 static HRESULT WINAPI saxxmlreader_getFeature(
2441     IVBSAXXMLReader* iface,
2442     const WCHAR *pFeature,
2443     VARIANT_BOOL *pValue)
2444 {
2445     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2446
2447     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2448     return E_NOTIMPL;
2449 }
2450
2451 static HRESULT WINAPI saxxmlreader_putFeature(
2452     IVBSAXXMLReader* iface,
2453     const WCHAR *pFeature,
2454     VARIANT_BOOL vfValue)
2455 {
2456     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2457
2458     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
2459     return E_NOTIMPL;
2460 }
2461
2462 static HRESULT WINAPI saxxmlreader_getProperty(
2463     IVBSAXXMLReader* iface,
2464     const WCHAR *pProp,
2465     VARIANT *pValue)
2466 {
2467     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2468
2469     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
2470     return E_NOTIMPL;
2471 }
2472
2473 static HRESULT WINAPI saxxmlreader_putProperty(
2474     IVBSAXXMLReader* iface,
2475     const WCHAR *pProp,
2476     VARIANT value)
2477 {
2478     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2479     return internal_putProperty(This, pProp, value, TRUE);
2480 }
2481
2482 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2483     IVBSAXXMLReader* iface,
2484     IVBSAXEntityResolver **pEntityResolver)
2485 {
2486     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2487     return internal_getEntityResolver(This, pEntityResolver, TRUE);
2488 }
2489
2490 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2491     IVBSAXXMLReader* iface,
2492     IVBSAXEntityResolver *pEntityResolver)
2493 {
2494     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2495     return internal_putEntityResolver(This, pEntityResolver, TRUE);
2496 }
2497
2498 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2499     IVBSAXXMLReader* iface,
2500     IVBSAXContentHandler **ppContentHandler)
2501 {
2502     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2503     return internal_getContentHandler(This, ppContentHandler, TRUE);
2504 }
2505
2506 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2507     IVBSAXXMLReader* iface,
2508     IVBSAXContentHandler *contentHandler)
2509 {
2510     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2511     return internal_putContentHandler(This, contentHandler, TRUE);
2512 }
2513
2514 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2515     IVBSAXXMLReader* iface,
2516     IVBSAXDTDHandler **pDTDHandler)
2517 {
2518     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2519     return internal_getDTDHandler(This, pDTDHandler, TRUE);
2520 }
2521
2522 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2523     IVBSAXXMLReader* iface,
2524     IVBSAXDTDHandler *pDTDHandler)
2525 {
2526     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2527     return internal_putDTDHandler(This, pDTDHandler, TRUE);
2528 }
2529
2530 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2531     IVBSAXXMLReader* iface,
2532     IVBSAXErrorHandler **pErrorHandler)
2533 {
2534     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2535     return internal_getErrorHandler(This, pErrorHandler, TRUE);
2536 }
2537
2538 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2539     IVBSAXXMLReader* iface,
2540     IVBSAXErrorHandler *errorHandler)
2541 {
2542     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2543     return internal_putErrorHandler(This, errorHandler, TRUE);
2544 }
2545
2546 static HRESULT WINAPI saxxmlreader_get_baseURL(
2547     IVBSAXXMLReader* iface,
2548     const WCHAR **pBaseUrl)
2549 {
2550     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2551
2552     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2553     return E_NOTIMPL;
2554 }
2555
2556 static HRESULT WINAPI saxxmlreader_put_baseURL(
2557     IVBSAXXMLReader* iface,
2558     const WCHAR *pBaseUrl)
2559 {
2560     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2561
2562     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2563     return E_NOTIMPL;
2564 }
2565
2566 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2567     IVBSAXXMLReader* iface,
2568     const WCHAR **pSecureBaseUrl)
2569 {
2570     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2571
2572     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2573     return E_NOTIMPL;
2574 }
2575
2576
2577 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
2578     IVBSAXXMLReader* iface,
2579     const WCHAR *secureBaseUrl)
2580 {
2581     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2582
2583     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2584     return E_NOTIMPL;
2585 }
2586
2587 static HRESULT WINAPI saxxmlreader_parse(
2588     IVBSAXXMLReader* iface,
2589     VARIANT varInput)
2590 {
2591     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2592     return internal_parse(This, varInput, TRUE);
2593 }
2594
2595 static HRESULT WINAPI saxxmlreader_parseURL(
2596     IVBSAXXMLReader* iface,
2597     const WCHAR *url)
2598 {
2599     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2600     return internal_parseURL(This, url, TRUE);
2601 }
2602
2603 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2604 {
2605     saxxmlreader_QueryInterface,
2606     saxxmlreader_AddRef,
2607     saxxmlreader_Release,
2608     saxxmlreader_GetTypeInfoCount,
2609     saxxmlreader_GetTypeInfo,
2610     saxxmlreader_GetIDsOfNames,
2611     saxxmlreader_Invoke,
2612     saxxmlreader_getFeature,
2613     saxxmlreader_putFeature,
2614     saxxmlreader_getProperty,
2615     saxxmlreader_putProperty,
2616     saxxmlreader_get_entityResolver,
2617     saxxmlreader_put_entityResolver,
2618     saxxmlreader_get_contentHandler,
2619     saxxmlreader_put_contentHandler,
2620     saxxmlreader_get_dtdHandler,
2621     saxxmlreader_put_dtdHandler,
2622     saxxmlreader_get_errorHandler,
2623     saxxmlreader_put_errorHandler,
2624     saxxmlreader_get_baseURL,
2625     saxxmlreader_put_baseURL,
2626     saxxmlreader_get_secureBaseURL,
2627     saxxmlreader_put_secureBaseURL,
2628     saxxmlreader_parse,
2629     saxxmlreader_parseURL
2630 };
2631
2632 /*** ISAXXMLReader interface ***/
2633 /*** IUnknown methods ***/
2634 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2635 {
2636     saxreader *This = impl_from_ISAXXMLReader( iface );
2637     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2638 }
2639
2640 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2641 {
2642     saxreader *This = impl_from_ISAXXMLReader( iface );
2643     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2644 }
2645
2646 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2647 {
2648     saxreader *This = impl_from_ISAXXMLReader( iface );
2649     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2650 }
2651
2652 /*** ISAXXMLReader methods ***/
2653 static HRESULT WINAPI isaxxmlreader_getFeature(
2654         ISAXXMLReader* iface,
2655         const WCHAR *pFeature,
2656         VARIANT_BOOL *pValue)
2657 {
2658     saxreader *This = impl_from_ISAXXMLReader( iface );
2659     return IVBSAXXMLReader_getFeature(
2660             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2661             pFeature, pValue);
2662 }
2663
2664 static HRESULT WINAPI isaxxmlreader_putFeature(
2665         ISAXXMLReader* iface,
2666         const WCHAR *pFeature,
2667         VARIANT_BOOL vfValue)
2668 {
2669     saxreader *This = impl_from_ISAXXMLReader( iface );
2670     return IVBSAXXMLReader_putFeature(
2671             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2672             pFeature, vfValue);
2673 }
2674
2675 static HRESULT WINAPI isaxxmlreader_getProperty(
2676         ISAXXMLReader* iface,
2677         const WCHAR *pProp,
2678         VARIANT *pValue)
2679 {
2680     saxreader *This = impl_from_ISAXXMLReader( iface );
2681     return IVBSAXXMLReader_getProperty(
2682             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2683             pProp, pValue);
2684 }
2685
2686 static HRESULT WINAPI isaxxmlreader_putProperty(
2687         ISAXXMLReader* iface,
2688         const WCHAR *pProp,
2689         VARIANT value)
2690 {
2691     saxreader *This = impl_from_ISAXXMLReader( iface );
2692     return internal_putProperty(This, pProp, value, FALSE);
2693 }
2694
2695 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2696         ISAXXMLReader* iface,
2697         ISAXEntityResolver **ppEntityResolver)
2698 {
2699     saxreader *This = impl_from_ISAXXMLReader( iface );
2700     return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2701 }
2702
2703 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2704         ISAXXMLReader* iface,
2705         ISAXEntityResolver *pEntityResolver)
2706 {
2707     saxreader *This = impl_from_ISAXXMLReader( iface );
2708     return internal_putEntityResolver(This, pEntityResolver, FALSE);
2709 }
2710
2711 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2712         ISAXXMLReader* iface,
2713         ISAXContentHandler **pContentHandler)
2714 {
2715     saxreader *This = impl_from_ISAXXMLReader( iface );
2716     return internal_getContentHandler(This, pContentHandler, FALSE);
2717 }
2718
2719 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2720         ISAXXMLReader* iface,
2721         ISAXContentHandler *contentHandler)
2722 {
2723     saxreader *This = impl_from_ISAXXMLReader( iface );
2724     return internal_putContentHandler(This, contentHandler, FALSE);
2725 }
2726
2727 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2728         ISAXXMLReader* iface,
2729         ISAXDTDHandler **pDTDHandler)
2730 {
2731     saxreader *This = impl_from_ISAXXMLReader( iface );
2732     return internal_getDTDHandler(This, pDTDHandler, FALSE);
2733 }
2734
2735 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2736         ISAXXMLReader* iface,
2737         ISAXDTDHandler *pDTDHandler)
2738 {
2739     saxreader *This = impl_from_ISAXXMLReader( iface );
2740     return internal_putDTDHandler(This, pDTDHandler, FALSE);
2741 }
2742
2743 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2744         ISAXXMLReader* iface,
2745         ISAXErrorHandler **pErrorHandler)
2746 {
2747     saxreader *This = impl_from_ISAXXMLReader( iface );
2748     return internal_getErrorHandler(This, pErrorHandler, FALSE);
2749 }
2750
2751 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2752         ISAXXMLReader* iface,
2753         ISAXErrorHandler *errorHandler)
2754 {
2755     saxreader *This = impl_from_ISAXXMLReader( iface );
2756     return internal_putErrorHandler(This, errorHandler, FALSE);
2757 }
2758
2759 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2760         ISAXXMLReader* iface,
2761         const WCHAR **pBaseUrl)
2762 {
2763     saxreader *This = impl_from_ISAXXMLReader( iface );
2764     return IVBSAXXMLReader_get_baseURL(
2765             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2766             pBaseUrl);
2767 }
2768
2769 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2770         ISAXXMLReader* iface,
2771         const WCHAR *pBaseUrl)
2772 {
2773     saxreader *This = impl_from_ISAXXMLReader( iface );
2774     return IVBSAXXMLReader_put_baseURL(
2775             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2776             pBaseUrl);
2777 }
2778
2779 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2780         ISAXXMLReader* iface,
2781         const WCHAR **pSecureBaseUrl)
2782 {
2783     saxreader *This = impl_from_ISAXXMLReader( iface );
2784     return IVBSAXXMLReader_get_secureBaseURL(
2785             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2786             pSecureBaseUrl);
2787 }
2788
2789 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2790         ISAXXMLReader* iface,
2791         const WCHAR *secureBaseUrl)
2792 {
2793     saxreader *This = impl_from_ISAXXMLReader( iface );
2794     return IVBSAXXMLReader_put_secureBaseURL(
2795             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2796             secureBaseUrl);
2797 }
2798
2799 static HRESULT WINAPI isaxxmlreader_parse(
2800         ISAXXMLReader* iface,
2801         VARIANT varInput)
2802 {
2803     saxreader *This = impl_from_ISAXXMLReader( iface );
2804     return internal_parse(This, varInput, FALSE);
2805 }
2806
2807 static HRESULT WINAPI isaxxmlreader_parseURL(
2808         ISAXXMLReader* iface,
2809         const WCHAR *url)
2810 {
2811     saxreader *This = impl_from_ISAXXMLReader( iface );
2812     return internal_parseURL(This, url, FALSE);
2813 }
2814
2815 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2816 {
2817     isaxxmlreader_QueryInterface,
2818     isaxxmlreader_AddRef,
2819     isaxxmlreader_Release,
2820     isaxxmlreader_getFeature,
2821     isaxxmlreader_putFeature,
2822     isaxxmlreader_getProperty,
2823     isaxxmlreader_putProperty,
2824     isaxxmlreader_getEntityResolver,
2825     isaxxmlreader_putEntityResolver,
2826     isaxxmlreader_getContentHandler,
2827     isaxxmlreader_putContentHandler,
2828     isaxxmlreader_getDTDHandler,
2829     isaxxmlreader_putDTDHandler,
2830     isaxxmlreader_getErrorHandler,
2831     isaxxmlreader_putErrorHandler,
2832     isaxxmlreader_getBaseURL,
2833     isaxxmlreader_putBaseURL,
2834     isaxxmlreader_getSecureBaseURL,
2835     isaxxmlreader_putSecureBaseURL,
2836     isaxxmlreader_parse,
2837     isaxxmlreader_parseURL
2838 };
2839
2840 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2841 {
2842     saxreader *reader;
2843
2844     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2845
2846     reader = heap_alloc( sizeof (*reader) );
2847     if( !reader )
2848         return E_OUTOFMEMORY;
2849
2850     reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2851     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2852     reader->ref = 1;
2853     reader->contentHandler = NULL;
2854     reader->vbcontentHandler = NULL;
2855     reader->errorHandler = NULL;
2856     reader->vberrorHandler = NULL;
2857     reader->lexicalHandler = NULL;
2858     reader->vblexicalHandler = NULL;
2859     reader->declHandler = NULL;
2860     reader->vbdeclHandler = NULL;
2861     reader->isParsing = FALSE;
2862
2863     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2864     reader->sax.initialized = XML_SAX2_MAGIC;
2865     reader->sax.startDocument = libxmlStartDocument;
2866     reader->sax.endDocument = libxmlEndDocument;
2867     reader->sax.startElementNs = libxmlStartElementNS;
2868     reader->sax.endElementNs = libxmlEndElementNS;
2869     reader->sax.characters = libxmlCharacters;
2870     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2871     reader->sax.comment = libxmlComment;
2872     reader->sax.error = libxmlFatalError;
2873     reader->sax.fatalError = libxmlFatalError;
2874     reader->sax.cdataBlock = libxmlCDataBlock;
2875
2876     *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2877
2878     TRACE("returning iface %p\n", *ppObj);
2879
2880     return S_OK;
2881 }
2882
2883 #else
2884
2885 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2886 {
2887     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2888             "libxml2 support was not present at compile time.\n");
2889     return E_NOTIMPL;
2890 }
2891
2892 #endif