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