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 /*** IVBSAXLocator interface ***/
1134 /*** IUnknown methods ***/
1135 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1136 {
1137     saxlocator *This = impl_from_IVBSAXLocator( 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_IDispatch) ||
1145             IsEqualGUID( riid, &IID_IVBSAXLocator ))
1146     {
1147         *ppvObject = iface;
1148     }
1149     else
1150     {
1151         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1152         return E_NOINTERFACE;
1153     }
1154
1155     IVBSAXLocator_AddRef( iface );
1156
1157     return S_OK;
1158 }
1159
1160 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1161 {
1162     saxlocator *This = impl_from_IVBSAXLocator( iface );
1163     TRACE("%p\n", This );
1164     return InterlockedIncrement( &This->ref );
1165 }
1166
1167 static ULONG WINAPI ivbsaxlocator_Release(
1168         IVBSAXLocator* iface)
1169 {
1170     saxlocator *This = impl_from_IVBSAXLocator( iface );
1171     return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1172 }
1173
1174 /*** IDispatch methods ***/
1175 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1176 {
1177     saxlocator *This = impl_from_IVBSAXLocator( iface );
1178
1179     TRACE("(%p)->(%p)\n", This, pctinfo);
1180
1181     *pctinfo = 1;
1182
1183     return S_OK;
1184 }
1185
1186 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1187     IVBSAXLocator *iface,
1188     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1189 {
1190     saxlocator *This = impl_from_IVBSAXLocator( iface );
1191     HRESULT hr;
1192
1193     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1194
1195     hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1196
1197     return hr;
1198 }
1199
1200 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1201     IVBSAXLocator *iface,
1202     REFIID riid,
1203     LPOLESTR* rgszNames,
1204     UINT cNames,
1205     LCID lcid,
1206     DISPID* rgDispId)
1207 {
1208     saxlocator *This = impl_from_IVBSAXLocator( iface );
1209     ITypeInfo *typeinfo;
1210     HRESULT hr;
1211
1212     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1213           lcid, rgDispId);
1214
1215     if(!rgszNames || cNames == 0 || !rgDispId)
1216         return E_INVALIDARG;
1217
1218     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1219     if(SUCCEEDED(hr))
1220     {
1221         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1222         ITypeInfo_Release(typeinfo);
1223     }
1224
1225     return hr;
1226 }
1227
1228 static HRESULT WINAPI ivbsaxlocator_Invoke(
1229     IVBSAXLocator *iface,
1230     DISPID dispIdMember,
1231     REFIID riid,
1232     LCID lcid,
1233     WORD wFlags,
1234     DISPPARAMS* pDispParams,
1235     VARIANT* pVarResult,
1236     EXCEPINFO* pExcepInfo,
1237     UINT* puArgErr)
1238 {
1239     saxlocator *This = impl_from_IVBSAXLocator( iface );
1240     ITypeInfo *typeinfo;
1241     HRESULT hr;
1242
1243     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1244           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1245
1246     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1247     if(SUCCEEDED(hr))
1248     {
1249         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1250                 pVarResult, pExcepInfo, puArgErr);
1251         ITypeInfo_Release(typeinfo);
1252     }
1253
1254     return hr;
1255 }
1256
1257 /*** IVBSAXLocator methods ***/
1258 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1259         IVBSAXLocator* iface,
1260         int *pnColumn)
1261 {
1262     saxlocator *This = impl_from_IVBSAXLocator( iface );
1263     return ISAXLocator_getColumnNumber(
1264             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1265             pnColumn);
1266 }
1267
1268 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1269         IVBSAXLocator* iface,
1270         int *pnLine)
1271 {
1272     saxlocator *This = impl_from_IVBSAXLocator( iface );
1273     return ISAXLocator_getLineNumber(
1274             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1275             pnLine);
1276 }
1277
1278 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1279         IVBSAXLocator* iface,
1280         BSTR* publicId)
1281 {
1282     saxlocator *This = impl_from_IVBSAXLocator( iface );
1283     return ISAXLocator_getPublicId(
1284             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1285             (const WCHAR**)publicId);
1286 }
1287
1288 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1289         IVBSAXLocator* iface,
1290         BSTR* systemId)
1291 {
1292     saxlocator *This = impl_from_IVBSAXLocator( iface );
1293     return ISAXLocator_getSystemId(
1294             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1295             (const WCHAR**)systemId);
1296 }
1297
1298 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1299 {
1300     ivbsaxlocator_QueryInterface,
1301     ivbsaxlocator_AddRef,
1302     ivbsaxlocator_Release,
1303     ivbsaxlocator_GetTypeInfoCount,
1304     ivbsaxlocator_GetTypeInfo,
1305     ivbsaxlocator_GetIDsOfNames,
1306     ivbsaxlocator_Invoke,
1307     ivbsaxlocator_get_columnNumber,
1308     ivbsaxlocator_get_lineNumber,
1309     ivbsaxlocator_get_publicId,
1310     ivbsaxlocator_get_systemId
1311 };
1312
1313 /*** ISAXLocator interface ***/
1314 /*** IUnknown methods ***/
1315 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1316 {
1317     saxlocator *This = impl_from_ISAXLocator( iface );
1318
1319     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1320
1321     *ppvObject = NULL;
1322
1323     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1324             IsEqualGUID( riid, &IID_ISAXLocator ))
1325     {
1326         *ppvObject = iface;
1327     }
1328     else
1329     {
1330         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1331         return E_NOINTERFACE;
1332     }
1333
1334     ISAXLocator_AddRef( iface );
1335
1336     return S_OK;
1337 }
1338
1339 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1340 {
1341     saxlocator *This = impl_from_ISAXLocator( iface );
1342     TRACE("%p\n", This );
1343     return InterlockedIncrement( &This->ref );
1344 }
1345
1346 static ULONG WINAPI isaxlocator_Release(
1347         ISAXLocator* iface)
1348 {
1349     saxlocator *This = impl_from_ISAXLocator( iface );
1350     LONG ref;
1351
1352     TRACE("%p\n", This );
1353
1354     ref = InterlockedDecrement( &This->ref );
1355     if ( ref == 0 )
1356     {
1357         if(This->publicId)
1358             SysFreeString(This->publicId);
1359         if(This->systemId)
1360             SysFreeString(This->systemId);
1361
1362         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1363         HeapFree( GetProcessHeap(), 0, This );
1364     }
1365
1366     return ref;
1367 }
1368
1369 /*** ISAXLocator methods ***/
1370 static HRESULT WINAPI isaxlocator_getColumnNumber(
1371         ISAXLocator* iface,
1372         int *pnColumn)
1373 {
1374     saxlocator *This = impl_from_ISAXLocator( iface );
1375
1376     *pnColumn = This->column;
1377     return S_OK;
1378 }
1379
1380 static HRESULT WINAPI isaxlocator_getLineNumber(
1381         ISAXLocator* iface,
1382         int *pnLine)
1383 {
1384     saxlocator *This = impl_from_ISAXLocator( iface );
1385
1386     *pnLine = This->line;
1387     return S_OK;
1388 }
1389
1390 static HRESULT WINAPI isaxlocator_getPublicId(
1391         ISAXLocator* iface,
1392         const WCHAR ** ppwchPublicId)
1393 {
1394     BSTR publicId;
1395     saxlocator *This = impl_from_ISAXLocator( iface );
1396
1397     if(This->publicId) SysFreeString(This->publicId);
1398
1399     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1400     if(SysStringLen(publicId))
1401         This->publicId = (WCHAR*)&publicId;
1402     else
1403     {
1404         SysFreeString(publicId);
1405         This->publicId = NULL;
1406     }
1407
1408     *ppwchPublicId = This->publicId;
1409     return S_OK;
1410 }
1411
1412 static HRESULT WINAPI isaxlocator_getSystemId(
1413         ISAXLocator* iface,
1414         const WCHAR ** ppwchSystemId)
1415 {
1416     BSTR systemId;
1417     saxlocator *This = impl_from_ISAXLocator( iface );
1418
1419     if(This->systemId) SysFreeString(This->systemId);
1420
1421     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1422     if(SysStringLen(systemId))
1423         This->systemId = (WCHAR*)&systemId;
1424     else
1425     {
1426         SysFreeString(systemId);
1427         This->systemId = NULL;
1428     }
1429
1430     *ppwchSystemId = This->systemId;
1431     return S_OK;
1432 }
1433
1434 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1435 {
1436     isaxlocator_QueryInterface,
1437     isaxlocator_AddRef,
1438     isaxlocator_Release,
1439     isaxlocator_getColumnNumber,
1440     isaxlocator_getLineNumber,
1441     isaxlocator_getPublicId,
1442     isaxlocator_getSystemId
1443 };
1444
1445 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1446 {
1447     saxlocator *locator;
1448
1449     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
1450     if( !locator )
1451         return E_OUTOFMEMORY;
1452
1453     locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1454     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1455     locator->ref = 1;
1456     locator->vbInterface = vbInterface;
1457
1458     locator->saxreader = reader;
1459     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1460
1461     locator->pParserCtxt = NULL;
1462     locator->publicId = NULL;
1463     locator->systemId = NULL;
1464     locator->lastCur = NULL;
1465     locator->line = 0;
1466     locator->column = 0;
1467     locator->ret = S_OK;
1468
1469     *ppsaxlocator = locator;
1470
1471     TRACE("returning %p\n", *ppsaxlocator);
1472
1473     return S_OK;
1474 }
1475
1476 /*** SAXXMLReader internal functions ***/
1477 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1478 {
1479     saxlocator *locator;
1480     HRESULT hr;
1481
1482     hr = SAXLocator_create(This, &locator, vbInterface);
1483     if(FAILED(hr))
1484         return E_FAIL;
1485
1486     locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1487     if(!locator->pParserCtxt)
1488     {
1489         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1490         return E_FAIL;
1491     }
1492
1493     locator->pParserCtxt->sax = &locator->saxreader->sax;
1494     locator->pParserCtxt->userData = locator;
1495
1496     if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1497     else hr = locator->ret;
1498
1499     if(locator->pParserCtxt)
1500     {
1501         locator->pParserCtxt->sax = NULL;
1502         xmlFreeParserCtxt(locator->pParserCtxt);
1503         locator->pParserCtxt = NULL;
1504     }
1505
1506     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1507     return S_OK;
1508 }
1509
1510 static HRESULT WINAPI internal_getEntityResolver(
1511         saxreader *This,
1512         void *pEntityResolver,
1513         BOOL vbInterface)
1514 {
1515     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1516     return E_NOTIMPL;
1517 }
1518
1519 static HRESULT WINAPI internal_putEntityResolver(
1520         saxreader *This,
1521         void *pEntityResolver,
1522         BOOL vbInterface)
1523 {
1524     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1525     return E_NOTIMPL;
1526 }
1527
1528 static HRESULT WINAPI internal_getContentHandler(
1529         saxreader* This,
1530         void *pContentHandler,
1531         BOOL vbInterface)
1532 {
1533     TRACE("(%p)->(%p)\n", This, pContentHandler);
1534     if(pContentHandler == NULL)
1535         return E_POINTER;
1536     if(This->contentHandler)
1537     {
1538         if(vbInterface)
1539             IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1540         else
1541             ISAXContentHandler_AddRef(This->contentHandler);
1542     }
1543     if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1544         This->vbcontentHandler;
1545     else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1546
1547     return S_OK;
1548 }
1549
1550 static HRESULT WINAPI internal_putContentHandler(
1551         saxreader* This,
1552         void *contentHandler,
1553         BOOL vbInterface)
1554 {
1555     TRACE("(%p)->(%p)\n", This, contentHandler);
1556     if(contentHandler)
1557     {
1558         if(vbInterface)
1559             IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1560         else
1561             ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1562     }
1563     if(This->contentHandler)
1564     {
1565         if(vbInterface)
1566             IVBSAXContentHandler_Release(This->vbcontentHandler);
1567         else
1568             ISAXContentHandler_Release(This->contentHandler);
1569     }
1570     if(vbInterface)
1571         This->vbcontentHandler = contentHandler;
1572     else
1573         This->contentHandler = contentHandler;
1574
1575     return S_OK;
1576 }
1577
1578 static HRESULT WINAPI internal_getDTDHandler(
1579         saxreader* This,
1580         void *pDTDHandler,
1581         BOOL vbInterface)
1582 {
1583     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1584     return E_NOTIMPL;
1585 }
1586
1587 static HRESULT WINAPI internal_putDTDHandler(
1588         saxreader* This,
1589         void *pDTDHandler,
1590         BOOL vbInterface)
1591 {
1592     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1593     return E_NOTIMPL;
1594 }
1595
1596 static HRESULT WINAPI internal_getErrorHandler(
1597         saxreader* This,
1598         void *pErrorHandler,
1599         BOOL vbInterface)
1600 {
1601     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1602     if(pErrorHandler == NULL)
1603         return E_POINTER;
1604     if(This->errorHandler)
1605     {
1606         if(vbInterface)
1607             IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1608         else
1609             ISAXErrorHandler_AddRef(This->errorHandler);
1610     }
1611     if(vbInterface)
1612         *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1613     else
1614         *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1615
1616     return S_OK;
1617
1618 }
1619
1620 static HRESULT WINAPI internal_putErrorHandler(
1621         saxreader* This,
1622         void *errorHandler,
1623         BOOL vbInterface)
1624 {
1625     TRACE("(%p)->(%p)\n", This, errorHandler);
1626     if(errorHandler)
1627     {
1628         if(vbInterface)
1629             IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
1630         else
1631             ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
1632     }
1633     if(This->errorHandler)
1634     {
1635         if(vbInterface)
1636             IVBSAXErrorHandler_Release(This->vberrorHandler);
1637         else
1638             ISAXErrorHandler_Release(This->errorHandler);
1639     }
1640     if(vbInterface)
1641         This->vberrorHandler = errorHandler;
1642     else
1643         This->errorHandler = errorHandler;
1644
1645     return S_OK;
1646
1647 }
1648
1649 static HRESULT WINAPI internal_parse(
1650         saxreader* This,
1651         VARIANT varInput,
1652         BOOL vbInterface)
1653 {
1654     HRESULT hr;
1655
1656     TRACE("(%p)\n", This);
1657
1658     hr = S_OK;
1659     switch(V_VT(&varInput))
1660     {
1661         case VT_BSTR:
1662             hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
1663                     SysStringByteLen(V_BSTR(&varInput)), vbInterface);
1664             break;
1665         case VT_ARRAY|VT_UI1: {
1666             void *pSAData;
1667             LONG lBound, uBound;
1668             ULONG dataRead;
1669
1670             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
1671             if(hr != S_OK) break;
1672             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
1673             if(hr != S_OK) break;
1674             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
1675             hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
1676             if(hr != S_OK) break;
1677             hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
1678             SafeArrayUnaccessData(V_ARRAY(&varInput));
1679             break;
1680         }
1681         case VT_UNKNOWN:
1682         case VT_DISPATCH: {
1683             IPersistStream *persistStream;
1684             IStream *stream = NULL;
1685             IXMLDOMDocument *xmlDoc;
1686
1687             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1688                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
1689             {
1690                 hr = IPersistStream_Save(persistStream, stream, TRUE);
1691                 IPersistStream_Release(persistStream);
1692                 if(hr != S_OK) break;
1693             }
1694             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1695                         &IID_IStream, (void**)&stream) == S_OK)
1696             {
1697                 STATSTG dataInfo;
1698                 ULONG dataRead;
1699                 char *data;
1700
1701                 while(1)
1702                 {
1703                     hr = IStream_Stat(stream, &dataInfo, STATFLAG_NONAME);
1704                     if(hr == E_PENDING) continue;
1705                     break;
1706                 }
1707                 data = HeapAlloc(GetProcessHeap(), 0,
1708                         dataInfo.cbSize.QuadPart);
1709                 while(1)
1710                 {
1711                     hr = IStream_Read(stream, data,
1712                             dataInfo.cbSize.QuadPart, &dataRead);
1713                     if(hr == E_PENDING) continue;
1714                     break;
1715                 }
1716                 hr = internal_parseBuffer(This, data,
1717                         dataInfo.cbSize.QuadPart, vbInterface);
1718                 HeapFree(GetProcessHeap(), 0, data);
1719                 IStream_Release(stream);
1720                 break;
1721             }
1722             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1723                                        &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
1724             {
1725                 BSTR bstrData;
1726
1727                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
1728                 hr = internal_parseBuffer(This, (const char*)bstrData,
1729                         SysStringByteLen(bstrData), vbInterface);
1730                 IXMLDOMDocument_Release(xmlDoc);
1731                 hr = E_NOTIMPL;
1732                 break;
1733             }
1734         }
1735         default:
1736             WARN("vt %d not implemented\n", V_VT(&varInput));
1737             hr = E_INVALIDARG;
1738     }
1739
1740     return hr;
1741 }
1742
1743 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
1744 {
1745     saxreader *This = obj;
1746
1747     return internal_parseBuffer(This, ptr, len, TRUE);
1748 }
1749
1750 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
1751 {
1752     saxreader *This = obj;
1753
1754     return internal_parseBuffer(This, ptr, len, FALSE);
1755 }
1756
1757 static HRESULT WINAPI internal_parseURL(
1758         saxreader* This,
1759         const WCHAR *url,
1760         BOOL vbInterface)
1761 {
1762     bsc_t *bsc;
1763     HRESULT hr;
1764
1765     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
1766
1767     if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
1768     else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
1769
1770     if(FAILED(hr))
1771         return hr;
1772
1773     detach_bsc(bsc);
1774
1775     return S_OK;
1776 }
1777
1778 /*** IVBSAXXMLReader interface ***/
1779 /*** IUnknown methods ***/
1780 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
1781 {
1782     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1783
1784     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1785
1786     *ppvObject = NULL;
1787
1788     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1789          IsEqualGUID( riid, &IID_IDispatch ) ||
1790          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
1791     {
1792         *ppvObject = iface;
1793     }
1794     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
1795     {
1796         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
1797     }
1798     else
1799     {
1800         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1801         return E_NOINTERFACE;
1802     }
1803
1804     IVBSAXXMLReader_AddRef( iface );
1805
1806     return S_OK;
1807 }
1808
1809 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
1810 {
1811     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1812     TRACE("%p\n", This );
1813     return InterlockedIncrement( &This->ref );
1814 }
1815
1816 static ULONG WINAPI saxxmlreader_Release(
1817     IVBSAXXMLReader* iface)
1818 {
1819     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1820     LONG ref;
1821
1822     TRACE("%p\n", This );
1823
1824     ref = InterlockedDecrement( &This->ref );
1825     if ( ref == 0 )
1826     {
1827         if(This->contentHandler)
1828             ISAXContentHandler_Release(This->contentHandler);
1829
1830         if(This->errorHandler)
1831             ISAXErrorHandler_Release(This->errorHandler);
1832
1833         HeapFree( GetProcessHeap(), 0, This );
1834     }
1835
1836     return ref;
1837 }
1838 /*** IDispatch ***/
1839 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
1840 {
1841     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1842
1843     TRACE("(%p)->(%p)\n", This, pctinfo);
1844
1845     *pctinfo = 1;
1846
1847     return S_OK;
1848 }
1849
1850 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
1851     IVBSAXXMLReader *iface,
1852     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1853 {
1854     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1855     HRESULT hr;
1856
1857     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1858
1859     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
1860
1861     return hr;
1862 }
1863
1864 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
1865     IVBSAXXMLReader *iface,
1866     REFIID riid,
1867     LPOLESTR* rgszNames,
1868     UINT cNames,
1869     LCID lcid,
1870     DISPID* rgDispId)
1871 {
1872     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1873     ITypeInfo *typeinfo;
1874     HRESULT hr;
1875
1876     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1877           lcid, rgDispId);
1878
1879     if(!rgszNames || cNames == 0 || !rgDispId)
1880         return E_INVALIDARG;
1881
1882     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
1883     if(SUCCEEDED(hr))
1884     {
1885         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1886         ITypeInfo_Release(typeinfo);
1887     }
1888
1889     return hr;
1890 }
1891
1892 static HRESULT WINAPI saxxmlreader_Invoke(
1893     IVBSAXXMLReader *iface,
1894     DISPID dispIdMember,
1895     REFIID riid,
1896     LCID lcid,
1897     WORD wFlags,
1898     DISPPARAMS* pDispParams,
1899     VARIANT* pVarResult,
1900     EXCEPINFO* pExcepInfo,
1901     UINT* puArgErr)
1902 {
1903     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1904     ITypeInfo *typeinfo;
1905     HRESULT hr;
1906
1907     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1908           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1909
1910     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
1911     if(SUCCEEDED(hr))
1912     {
1913         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
1914                 pVarResult, pExcepInfo, puArgErr);
1915         ITypeInfo_Release(typeinfo);
1916     }
1917
1918     return hr;
1919 }
1920
1921 /*** IVBSAXXMLReader methods ***/
1922 static HRESULT WINAPI saxxmlreader_getFeature(
1923     IVBSAXXMLReader* iface,
1924     const WCHAR *pFeature,
1925     VARIANT_BOOL *pValue)
1926 {
1927     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1928
1929     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI saxxmlreader_putFeature(
1934     IVBSAXXMLReader* iface,
1935     const WCHAR *pFeature,
1936     VARIANT_BOOL vfValue)
1937 {
1938     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1939
1940     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
1941     return E_NOTIMPL;
1942 }
1943
1944 static HRESULT WINAPI saxxmlreader_getProperty(
1945     IVBSAXXMLReader* iface,
1946     const WCHAR *pProp,
1947     VARIANT *pValue)
1948 {
1949     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1950
1951     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
1952     return E_NOTIMPL;
1953 }
1954
1955 static HRESULT WINAPI saxxmlreader_putProperty(
1956     IVBSAXXMLReader* iface,
1957     const WCHAR *pProp,
1958     VARIANT value)
1959 {
1960     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1961
1962     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
1963     return E_NOTIMPL;
1964 }
1965
1966 static HRESULT WINAPI saxxmlreader_getEntityResolver(
1967     IVBSAXXMLReader* iface,
1968     IVBSAXEntityResolver **pEntityResolver)
1969 {
1970     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1971     return internal_getEntityResolver(This, pEntityResolver, TRUE);
1972 }
1973
1974 static HRESULT WINAPI saxxmlreader_putEntityResolver(
1975     IVBSAXXMLReader* iface,
1976     IVBSAXEntityResolver *pEntityResolver)
1977 {
1978     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1979     return internal_putEntityResolver(This, pEntityResolver, TRUE);
1980 }
1981
1982 static HRESULT WINAPI saxxmlreader_getContentHandler(
1983     IVBSAXXMLReader* iface,
1984     IVBSAXContentHandler **ppContentHandler)
1985 {
1986     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1987     return internal_getContentHandler(This, ppContentHandler, TRUE);
1988 }
1989
1990 static HRESULT WINAPI saxxmlreader_putContentHandler(
1991     IVBSAXXMLReader* iface,
1992     IVBSAXContentHandler *contentHandler)
1993 {
1994     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1995     return internal_putContentHandler(This, contentHandler, TRUE);
1996 }
1997
1998 static HRESULT WINAPI saxxmlreader_getDTDHandler(
1999     IVBSAXXMLReader* iface,
2000     IVBSAXDTDHandler **pDTDHandler)
2001 {
2002     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2003     return internal_getDTDHandler(This, pDTDHandler, TRUE);
2004 }
2005
2006 static HRESULT WINAPI saxxmlreader_putDTDHandler(
2007     IVBSAXXMLReader* iface,
2008     IVBSAXDTDHandler *pDTDHandler)
2009 {
2010     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2011     return internal_putDTDHandler(This, pDTDHandler, TRUE);
2012 }
2013
2014 static HRESULT WINAPI saxxmlreader_getErrorHandler(
2015     IVBSAXXMLReader* iface,
2016     IVBSAXErrorHandler **pErrorHandler)
2017 {
2018     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2019     return internal_getErrorHandler(This, pErrorHandler, TRUE);
2020 }
2021
2022 static HRESULT WINAPI saxxmlreader_putErrorHandler(
2023     IVBSAXXMLReader* iface,
2024     IVBSAXErrorHandler *errorHandler)
2025 {
2026     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2027     return internal_putErrorHandler(This, errorHandler, TRUE);
2028 }
2029
2030 static HRESULT WINAPI saxxmlreader_getBaseURL(
2031     IVBSAXXMLReader* iface,
2032     const WCHAR **pBaseUrl)
2033 {
2034     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2035
2036     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2037     return E_NOTIMPL;
2038 }
2039
2040 static HRESULT WINAPI saxxmlreader_putBaseURL(
2041     IVBSAXXMLReader* iface,
2042     const WCHAR *pBaseUrl)
2043 {
2044     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2045
2046     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2047     return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
2051     IVBSAXXMLReader* iface,
2052     const WCHAR **pSecureBaseUrl)
2053 {
2054     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2055
2056     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2057     return E_NOTIMPL;
2058 }
2059
2060
2061 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
2062     IVBSAXXMLReader* iface,
2063     const WCHAR *secureBaseUrl)
2064 {
2065     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2066
2067     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2068     return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI saxxmlreader_parse(
2072     IVBSAXXMLReader* iface,
2073     VARIANT varInput)
2074 {
2075     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2076     return internal_parse(This, varInput, TRUE);
2077 }
2078
2079 static HRESULT WINAPI saxxmlreader_parseURL(
2080     IVBSAXXMLReader* iface,
2081     const WCHAR *url)
2082 {
2083     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2084     return internal_parseURL(This, url, TRUE);
2085 }
2086
2087 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2088 {
2089     saxxmlreader_QueryInterface,
2090     saxxmlreader_AddRef,
2091     saxxmlreader_Release,
2092     saxxmlreader_GetTypeInfoCount,
2093     saxxmlreader_GetTypeInfo,
2094     saxxmlreader_GetIDsOfNames,
2095     saxxmlreader_Invoke,
2096     saxxmlreader_getFeature,
2097     saxxmlreader_putFeature,
2098     saxxmlreader_getProperty,
2099     saxxmlreader_putProperty,
2100     saxxmlreader_getEntityResolver,
2101     saxxmlreader_putEntityResolver,
2102     saxxmlreader_getContentHandler,
2103     saxxmlreader_putContentHandler,
2104     saxxmlreader_getDTDHandler,
2105     saxxmlreader_putDTDHandler,
2106     saxxmlreader_getErrorHandler,
2107     saxxmlreader_putErrorHandler,
2108     saxxmlreader_getBaseURL,
2109     saxxmlreader_putBaseURL,
2110     saxxmlreader_getSecureBaseURL,
2111     saxxmlreader_putSecureBaseURL,
2112     saxxmlreader_parse,
2113     saxxmlreader_parseURL
2114 };
2115
2116 /*** ISAXXMLReader interface ***/
2117 /*** IUnknown methods ***/
2118 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2119 {
2120     saxreader *This = impl_from_ISAXXMLReader( iface );
2121     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2122 }
2123
2124 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2125 {
2126     saxreader *This = impl_from_ISAXXMLReader( iface );
2127     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2128 }
2129
2130 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2131 {
2132     saxreader *This = impl_from_ISAXXMLReader( iface );
2133     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2134 }
2135
2136 /*** ISAXXMLReader methods ***/
2137 static HRESULT WINAPI isaxxmlreader_getFeature(
2138         ISAXXMLReader* iface,
2139         const WCHAR *pFeature,
2140         VARIANT_BOOL *pValue)
2141 {
2142     saxreader *This = impl_from_ISAXXMLReader( iface );
2143     return IVBSAXXMLReader_getFeature(
2144             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2145             pFeature, pValue);
2146 }
2147
2148 static HRESULT WINAPI isaxxmlreader_putFeature(
2149         ISAXXMLReader* iface,
2150         const WCHAR *pFeature,
2151         VARIANT_BOOL vfValue)
2152 {
2153     saxreader *This = impl_from_ISAXXMLReader( iface );
2154     return IVBSAXXMLReader_putFeature(
2155             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2156             pFeature, vfValue);
2157 }
2158
2159 static HRESULT WINAPI isaxxmlreader_getProperty(
2160         ISAXXMLReader* iface,
2161         const WCHAR *pProp,
2162         VARIANT *pValue)
2163 {
2164     saxreader *This = impl_from_ISAXXMLReader( iface );
2165     return IVBSAXXMLReader_getProperty(
2166             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2167             pProp, pValue);
2168 }
2169
2170 static HRESULT WINAPI isaxxmlreader_putProperty(
2171         ISAXXMLReader* iface,
2172         const WCHAR *pProp,
2173         VARIANT value)
2174 {
2175     saxreader *This = impl_from_ISAXXMLReader( iface );
2176     return IVBSAXXMLReader_putProperty(
2177             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2178             pProp, value);
2179 }
2180
2181 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2182         ISAXXMLReader* iface,
2183         ISAXEntityResolver **ppEntityResolver)
2184 {
2185     saxreader *This = impl_from_ISAXXMLReader( iface );
2186     return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2187 }
2188
2189 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2190         ISAXXMLReader* iface,
2191         ISAXEntityResolver *pEntityResolver)
2192 {
2193     saxreader *This = impl_from_ISAXXMLReader( iface );
2194     return internal_putEntityResolver(This, pEntityResolver, FALSE);
2195 }
2196
2197 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2198         ISAXXMLReader* iface,
2199         ISAXContentHandler **pContentHandler)
2200 {
2201     saxreader *This = impl_from_ISAXXMLReader( iface );
2202     return internal_getContentHandler(This, pContentHandler, FALSE);
2203 }
2204
2205 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2206         ISAXXMLReader* iface,
2207         ISAXContentHandler *contentHandler)
2208 {
2209     saxreader *This = impl_from_ISAXXMLReader( iface );
2210     return internal_putContentHandler(This, contentHandler, FALSE);
2211 }
2212
2213 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2214         ISAXXMLReader* iface,
2215         ISAXDTDHandler **pDTDHandler)
2216 {
2217     saxreader *This = impl_from_ISAXXMLReader( iface );
2218     return internal_getDTDHandler(This, pDTDHandler, FALSE);
2219 }
2220
2221 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2222         ISAXXMLReader* iface,
2223         ISAXDTDHandler *pDTDHandler)
2224 {
2225     saxreader *This = impl_from_ISAXXMLReader( iface );
2226     return internal_putDTDHandler(This, pDTDHandler, FALSE);
2227 }
2228
2229 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2230         ISAXXMLReader* iface,
2231         ISAXErrorHandler **pErrorHandler)
2232 {
2233     saxreader *This = impl_from_ISAXXMLReader( iface );
2234     return internal_getErrorHandler(This, pErrorHandler, FALSE);
2235 }
2236
2237 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2238         ISAXXMLReader* iface,
2239         ISAXErrorHandler *errorHandler)
2240 {
2241     saxreader *This = impl_from_ISAXXMLReader( iface );
2242     return internal_putErrorHandler(This, errorHandler, FALSE);
2243 }
2244
2245 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2246         ISAXXMLReader* iface,
2247         const WCHAR **pBaseUrl)
2248 {
2249     saxreader *This = impl_from_ISAXXMLReader( iface );
2250     return IVBSAXXMLReader_get_getBaseURL(
2251             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2252             pBaseUrl);
2253 }
2254
2255 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2256         ISAXXMLReader* iface,
2257         const WCHAR *pBaseUrl)
2258 {
2259     saxreader *This = impl_from_ISAXXMLReader( iface );
2260     return IVBSAXXMLReader_put_putBaseURL(
2261             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2262             pBaseUrl);
2263 }
2264
2265 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2266         ISAXXMLReader* iface,
2267         const WCHAR **pSecureBaseUrl)
2268 {
2269     saxreader *This = impl_from_ISAXXMLReader( iface );
2270     return IVBSAXXMLReader_get_getSecureBaseURL(
2271             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2272             pSecureBaseUrl);
2273 }
2274
2275 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2276         ISAXXMLReader* iface,
2277         const WCHAR *secureBaseUrl)
2278 {
2279     saxreader *This = impl_from_ISAXXMLReader( iface );
2280     return IVBSAXXMLReader_put_putSecureBaseURL(
2281             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2282             secureBaseUrl);
2283 }
2284
2285 static HRESULT WINAPI isaxxmlreader_parse(
2286         ISAXXMLReader* iface,
2287         VARIANT varInput)
2288 {
2289     saxreader *This = impl_from_ISAXXMLReader( iface );
2290     return internal_parse(This, varInput, FALSE);
2291 }
2292
2293 static HRESULT WINAPI isaxxmlreader_parseURL(
2294         ISAXXMLReader* iface,
2295         const WCHAR *url)
2296 {
2297     saxreader *This = impl_from_ISAXXMLReader( iface );
2298     return internal_parseURL(This, url, FALSE);
2299 }
2300
2301 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2302 {
2303     isaxxmlreader_QueryInterface,
2304     isaxxmlreader_AddRef,
2305     isaxxmlreader_Release,
2306     isaxxmlreader_getFeature,
2307     isaxxmlreader_putFeature,
2308     isaxxmlreader_getProperty,
2309     isaxxmlreader_putProperty,
2310     isaxxmlreader_getEntityResolver,
2311     isaxxmlreader_putEntityResolver,
2312     isaxxmlreader_getContentHandler,
2313     isaxxmlreader_putContentHandler,
2314     isaxxmlreader_getDTDHandler,
2315     isaxxmlreader_putDTDHandler,
2316     isaxxmlreader_getErrorHandler,
2317     isaxxmlreader_putErrorHandler,
2318     isaxxmlreader_getBaseURL,
2319     isaxxmlreader_putBaseURL,
2320     isaxxmlreader_getSecureBaseURL,
2321     isaxxmlreader_putSecureBaseURL,
2322     isaxxmlreader_parse,
2323     isaxxmlreader_parseURL
2324 };
2325
2326 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2327 {
2328     saxreader *reader;
2329
2330     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2331
2332     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
2333     if( !reader )
2334         return E_OUTOFMEMORY;
2335
2336     reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2337     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2338     reader->ref = 1;
2339     reader->contentHandler = NULL;
2340     reader->errorHandler = NULL;
2341
2342     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2343     reader->sax.initialized = XML_SAX2_MAGIC;
2344     reader->sax.startDocument = libxmlStartDocument;
2345     reader->sax.endDocument = libxmlEndDocument;
2346     reader->sax.startElementNs = libxmlStartElementNS;
2347     reader->sax.endElementNs = libxmlEndElementNS;
2348     reader->sax.characters = libxmlCharacters;
2349     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2350     reader->sax.error = libxmlFatalError;
2351     reader->sax.fatalError = libxmlFatalError;
2352
2353     *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2354
2355     TRACE("returning iface %p\n", *ppObj);
2356
2357     return S_OK;
2358 }
2359
2360 #else
2361
2362 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2363 {
2364     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2365             "libxml2 support was not present at compile time.\n");
2366     return E_NOTIMPL;
2367 }
2368
2369 #endif