dlls/msxml3/saxreader.c

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