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         HeapFree(GetProcessHeap(), 0, attributes->szLocalname);
 810         HeapFree(GetProcessHeap(), 0, attributes->szPrefix);
 811         HeapFree(GetProcessHeap(), 0, attributes->szURI);
 812         HeapFree(GetProcessHeap(), 0, attributes->szValue);
 813         HeapFree(GetProcessHeap(), 0, attributes->szQName);
 814         HeapFree(GetProcessHeap(), 0, attributes);
 815         return E_FAIL;
 816     }
 817
 818     for(index=0; index<nb_attributes; index++)
 819     {
 820         int len1, len2;
 821
 822         attributes->szLocalname[index] =
 823             bstr_from_xmlChar(xmlAttributes[index*5]);
 824         attributes->szPrefix[index] =
 825             bstr_from_xmlChar(xmlAttributes[index*5+1]);
 826         attributes->szURI[index] =
 827             bstr_from_xmlChar(xmlAttributes[index*5+2]);
 828         attributes->szValue[index] =
 829             bstr_from_xmlCharN(xmlAttributes[index*5+3],
 830                     xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
 831
 832         len1 = SysStringLen(attributes->szPrefix[index]);
 833         len2 = SysStringLen(attributes->szLocalname[index]);
 834         attributes->szQName[index] = SysAllocStringLen(NULL, len1+len2);
 835         memcpy(attributes->szQName[index], attributes->szPrefix[index],
 836                 len1*sizeof(WCHAR));
 837         memcpy(attributes->szQName[index]+len1,
 838                 attributes->szLocalname[index], len2*sizeof(WCHAR));
 839         attributes->szQName[index][len1+len2] = '\0';
 840     }
 841
 842     *attr = attributes;
 843
 844     TRACE("returning %p\n", *attr);
 845
 846     return S_OK;
 847 }
 848
 849 /*** LibXML callbacks ***/
 850 static void libxmlStartDocument(void *ctx)
 851 {
 852     saxlocator *This = ctx;
 853     HRESULT hr;
 854
 855     if(This->saxreader->contentHandler)
 856     {
 857         if(This->vbInterface)
 858             hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
 859         else
 860             hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
 861
 862         if(hr != S_OK)
 863             format_error_message_from_id(This, hr);
 864     }
 865
 866     update_position(This, NULL);
 867 }
 868
 869 static void libxmlEndDocument(void *ctx)
 870 {
 871     saxlocator *This = ctx;
 872     HRESULT hr;
 873
 874     This->column = 0;
 875     This->line = 0;
 876
 877     if(This->ret != S_OK) return;
 878
 879     if(This->saxreader->contentHandler)
 880     {
 881         if(This->vbInterface)
 882             hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
 883         else
 884             hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
 885
 886         if(hr != S_OK)
 887             format_error_message_from_id(This, hr);
 888     }
 889 }
 890
 891 static void libxmlStartElementNS(
 892         void *ctx,
 893         const xmlChar *localname,
 894         const xmlChar *prefix,
 895         const xmlChar *URI,
 896         int nb_namespaces,
 897         const xmlChar **namespaces,
 898         int nb_attributes,
 899         int nb_defaulted,
 900         const xmlChar **attributes)
 901 {
 902     BSTR NamespaceUri, LocalName, QName;
 903     saxlocator *This = ctx;
 904     HRESULT hr;
 905     saxattributes *attr;
 906
 907     update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
 908
 909     if(This->saxreader->contentHandler)
 910     {
 911         NamespaceUri = bstr_from_xmlChar(URI);
 912         LocalName = bstr_from_xmlChar(localname);
 913         QName = bstr_from_xmlChar(localname);
 914
 915         hr = SAXAttributes_create(&attr, nb_attributes, attributes);
 916         if(hr == S_OK)
 917         {
 918             if(This->vbInterface)
 919                 hr = IVBSAXContentHandler_startElement(
 920                         This->saxreader->vbcontentHandler,
 921                         &NamespaceUri, &LocalName, &QName,
 922                         (IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
 923             else
 924                 hr = ISAXContentHandler_startElement(
 925                         This->saxreader->contentHandler,
 926                         NamespaceUri, SysStringLen(NamespaceUri),
 927                         LocalName, SysStringLen(LocalName),
 928                         QName, SysStringLen(QName),
 929                         (ISAXAttributes*)&attr->lpSAXAttributesVtbl);
 930
 931             ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
 932         }
 933
 934         SysFreeString(NamespaceUri);
 935         SysFreeString(LocalName);
 936         SysFreeString(QName);
 937
 938         if(hr != S_OK)
 939             format_error_message_from_id(This, hr);
 940     }
 941 }
 942
 943 static void libxmlEndElementNS(
 944         void *ctx,
 945         const xmlChar *localname,
 946         const xmlChar *prefix,
 947         const xmlChar *URI)
 948 {
 949     BSTR NamespaceUri, LocalName, QName;
 950     saxlocator *This = ctx;
 951     HRESULT hr;
 952     xmlChar *end;
 953
 954     end = This->lastCur;
 955     while(*end != '<' && *(end+1) != '/') end++;
 956     update_position(This, end+2);
 957
 958     if(This->saxreader->contentHandler)
 959     {
 960         NamespaceUri = bstr_from_xmlChar(URI);
 961         LocalName = bstr_from_xmlChar(localname);
 962         QName = bstr_from_xmlChar(localname);
 963
 964         if(This->vbInterface)
 965             hr = IVBSAXContentHandler_endElement(
 966                     This->saxreader->vbcontentHandler,
 967                     &NamespaceUri, &LocalName, &QName);
 968         else
 969             hr = ISAXContentHandler_endElement(
 970                     This->saxreader->contentHandler,
 971                     NamespaceUri, SysStringLen(NamespaceUri),
 972                     LocalName, SysStringLen(LocalName),
 973                     QName, SysStringLen(QName));
 974
 975         SysFreeString(NamespaceUri);
 976         SysFreeString(LocalName);
 977         SysFreeString(QName);
 978
 979         if(hr != S_OK)
 980             format_error_message_from_id(This, hr);
 981     }
 982 }
 983
 984 static void libxmlCharacters(
 985         void *ctx,
 986         const xmlChar *ch,
 987         int len)
 988 {
 989     BSTR Chars;
 990     saxlocator *This = ctx;
 991     HRESULT hr;
 992     xmlChar *end;
 993     xmlChar *lastCurCopy;
 994     xmlChar *chEnd;
 995     int columnCopy;
 996     int lineCopy;
 997
 998     if(*(This->lastCur-1) != '>' && *(This->lastCur-1) != '/') return;
 999
1000     if(*(This->lastCur-1) != '>')
1001     {
1002         end = (xmlChar*)This->pParserCtxt->input->cur-len;
1003         while(*(end-1) != '>') end--;
1004         update_position(This, end);
1005     }
1006
1007     chEnd = This->lastCur+len;
1008     while(*chEnd != '<') chEnd++;
1009
1010     Chars = bstr_from_xmlChar(ch);
1011
1012     lastCurCopy = This->lastCur;
1013     columnCopy = This->column;
1014     lineCopy = This->line;
1015     end = This->lastCur;
1016
1017     if(This->saxreader->contentHandler)
1018     {
1019         while(This->lastCur < chEnd)
1020         {
1021             end = This->lastCur;
1022             while(end < chEnd-1)
1023             {
1024                 if(*end == '\r') break;
1025                 end++;
1026             }
1027
1028             Chars = bstr_from_xmlChar(This->lastCur);
1029
1030             if(*end == '\r' && *(end+1) == '\n')
1031             {
1032                 memmove((WCHAR*)Chars+(end-This->lastCur),
1033                         (WCHAR*)Chars+(end-This->lastCur)+1,
1034                         (SysStringLen(Chars)-(end-This->lastCur))*sizeof(WCHAR));
1035                 SysReAllocStringLen(&Chars, Chars, SysStringLen(Chars)-1);
1036             }
1037             else if(*end == '\r') Chars[end-This->lastCur] = '\n';
1038
1039             if(This->vbInterface)
1040                 hr = IVBSAXContentHandler_characters(
1041                         This->saxreader->vbcontentHandler, &Chars);
1042             else
1043                 hr = ISAXContentHandler_characters(
1044                         This->saxreader->contentHandler,
1045                         Chars, end-This->lastCur+1);
1046
1047             SysFreeString(Chars);
1048             if(hr != S_OK)
1049             {
1050                 format_error_message_from_id(This, hr);
1051                 return;
1052             }
1053
1054             if(*(end+1) == '\n') end++;
1055             if(end < chEnd) end++;
1056
1057             This->column += end-This->lastCur;
1058             This->lastCur = end;
1059         }
1060
1061         This->lastCur = lastCurCopy;
1062         This->column = columnCopy;
1063         This->line = lineCopy;
1064         update_position(This, chEnd);
1065     }
1066 }
1067
1068 static void libxmlSetDocumentLocator(
1069         void *ctx,
1070         xmlSAXLocatorPtr loc)
1071 {
1072     saxlocator *This = ctx;
1073     HRESULT hr;
1074
1075     if(This->vbInterface)
1076         hr = IVBSAXContentHandler_putref_documentLocator(
1077                 This->saxreader->vbcontentHandler,
1078                 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
1079     else
1080         hr = ISAXContentHandler_putDocumentLocator(
1081                 This->saxreader->contentHandler,
1082                 (ISAXLocator*)&This->lpSAXLocatorVtbl);
1083
1084     if(FAILED(hr))
1085         format_error_message_from_id(This, hr);
1086 }
1087
1088 void libxmlFatalError(void *ctx, const char *msg, ...)
1089 {
1090     saxlocator *This = ctx;
1091     char message[1024];
1092     WCHAR *wszError;
1093     DWORD len;
1094     va_list args;
1095
1096     if(!This->saxreader->errorHandler)
1097     {
1098         xmlStopParser(This->pParserCtxt);
1099         This->ret = E_FAIL;
1100         return;
1101     }
1102
1103     FIXME("Error handling is not compatible.\n");
1104
1105     va_start(args, msg);
1106     vsprintf(message, msg, args);
1107     va_end(args);
1108
1109     len = MultiByteToWideChar(CP_ACP, 0, message, -1, NULL, 0);
1110     wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
1111     MultiByteToWideChar(CP_ACP, 0, message, -1, (LPWSTR)wszError, len);
1112
1113     if(This->vbInterface)
1114     {
1115         BSTR bstrError = SysAllocString(wszError);
1116         IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
1117                 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
1118     }
1119     else
1120         ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
1121                 (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
1122
1123     HeapFree(GetProcessHeap(), 0, wszError);
1124
1125     xmlStopParser(This->pParserCtxt);
1126     This->ret = E_FAIL;
1127 }
1128
1129 /*** IVBSAXLocator interface ***/
1130 /*** IUnknown methods ***/
1131 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1132 {
1133     saxlocator *This = impl_from_IVBSAXLocator( iface );
1134
1135     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1136
1137     *ppvObject = NULL;
1138
1139     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1140             IsEqualGUID( riid, &IID_IDispatch) ||
1141             IsEqualGUID( riid, &IID_IVBSAXLocator ))
1142     {
1143         *ppvObject = iface;
1144     }
1145     else
1146     {
1147         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1148         return E_NOINTERFACE;
1149     }
1150
1151     IVBSAXLocator_AddRef( iface );
1152
1153     return S_OK;
1154 }
1155
1156 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1157 {
1158     saxlocator *This = impl_from_IVBSAXLocator( iface );
1159     TRACE("%p\n", This );
1160     return InterlockedIncrement( &This->ref );
1161 }
1162
1163 static ULONG WINAPI ivbsaxlocator_Release(
1164         IVBSAXLocator* iface)
1165 {
1166     saxlocator *This = impl_from_IVBSAXLocator( iface );
1167     return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1168 }
1169
1170 /*** IDispatch methods ***/
1171 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1172 {
1173     saxlocator *This = impl_from_IVBSAXLocator( iface );
1174
1175     TRACE("(%p)->(%p)\n", This, pctinfo);
1176
1177     *pctinfo = 1;
1178
1179     return S_OK;
1180 }
1181
1182 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1183     IVBSAXLocator *iface,
1184     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1185 {
1186     saxlocator *This = impl_from_IVBSAXLocator( iface );
1187     HRESULT hr;
1188
1189     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1190
1191     hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1192
1193     return hr;
1194 }
1195
1196 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1197     IVBSAXLocator *iface,
1198     REFIID riid,
1199     LPOLESTR* rgszNames,
1200     UINT cNames,
1201     LCID lcid,
1202     DISPID* rgDispId)
1203 {
1204     saxlocator *This = impl_from_IVBSAXLocator( iface );
1205     ITypeInfo *typeinfo;
1206     HRESULT hr;
1207
1208     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1209           lcid, rgDispId);
1210
1211     if(!rgszNames || cNames == 0 || !rgDispId)
1212         return E_INVALIDARG;
1213
1214     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1215     if(SUCCEEDED(hr))
1216     {
1217         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1218         ITypeInfo_Release(typeinfo);
1219     }
1220
1221     return hr;
1222 }
1223
1224 static HRESULT WINAPI ivbsaxlocator_Invoke(
1225     IVBSAXLocator *iface,
1226     DISPID dispIdMember,
1227     REFIID riid,
1228     LCID lcid,
1229     WORD wFlags,
1230     DISPPARAMS* pDispParams,
1231     VARIANT* pVarResult,
1232     EXCEPINFO* pExcepInfo,
1233     UINT* puArgErr)
1234 {
1235     saxlocator *This = impl_from_IVBSAXLocator( iface );
1236     ITypeInfo *typeinfo;
1237     HRESULT hr;
1238
1239     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1240           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1241
1242     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1243     if(SUCCEEDED(hr))
1244     {
1245         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1246                 pVarResult, pExcepInfo, puArgErr);
1247         ITypeInfo_Release(typeinfo);
1248     }
1249
1250     return hr;
1251 }
1252
1253 /*** IVBSAXLocator methods ***/
1254 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1255         IVBSAXLocator* iface,
1256         int *pnColumn)
1257 {
1258     saxlocator *This = impl_from_IVBSAXLocator( iface );
1259     return ISAXLocator_getColumnNumber(
1260             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1261             pnColumn);
1262 }
1263
1264 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1265         IVBSAXLocator* iface,
1266         int *pnLine)
1267 {
1268     saxlocator *This = impl_from_IVBSAXLocator( iface );
1269     return ISAXLocator_getLineNumber(
1270             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1271             pnLine);
1272 }
1273
1274 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1275         IVBSAXLocator* iface,
1276         BSTR* publicId)
1277 {
1278     saxlocator *This = impl_from_IVBSAXLocator( iface );
1279     return ISAXLocator_getPublicId(
1280             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1281             (const WCHAR**)publicId);
1282 }
1283
1284 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1285         IVBSAXLocator* iface,
1286         BSTR* systemId)
1287 {
1288     saxlocator *This = impl_from_IVBSAXLocator( iface );
1289     return ISAXLocator_getSystemId(
1290             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1291             (const WCHAR**)systemId);
1292 }
1293
1294 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1295 {
1296     ivbsaxlocator_QueryInterface,
1297     ivbsaxlocator_AddRef,
1298     ivbsaxlocator_Release,
1299     ivbsaxlocator_GetTypeInfoCount,
1300     ivbsaxlocator_GetTypeInfo,
1301     ivbsaxlocator_GetIDsOfNames,
1302     ivbsaxlocator_Invoke,
1303     ivbsaxlocator_get_columnNumber,
1304     ivbsaxlocator_get_lineNumber,
1305     ivbsaxlocator_get_publicId,
1306     ivbsaxlocator_get_systemId
1307 };
1308
1309 /*** ISAXLocator interface ***/
1310 /*** IUnknown methods ***/
1311 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1312 {
1313     saxlocator *This = impl_from_ISAXLocator( iface );
1314
1315     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1316
1317     *ppvObject = NULL;
1318
1319     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1320             IsEqualGUID( riid, &IID_ISAXLocator ))
1321     {
1322         *ppvObject = iface;
1323     }
1324     else
1325     {
1326         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1327         return E_NOINTERFACE;
1328     }
1329
1330     ISAXLocator_AddRef( iface );
1331
1332     return S_OK;
1333 }
1334
1335 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1336 {
1337     saxlocator *This = impl_from_ISAXLocator( iface );
1338     TRACE("%p\n", This );
1339     return InterlockedIncrement( &This->ref );
1340 }
1341
1342 static ULONG WINAPI isaxlocator_Release(
1343         ISAXLocator* iface)
1344 {
1345     saxlocator *This = impl_from_ISAXLocator( iface );
1346     LONG ref;
1347
1348     TRACE("%p\n", This );
1349
1350     ref = InterlockedDecrement( &This->ref );
1351     if ( ref == 0 )
1352     {
1353         if(This->publicId)
1354             SysFreeString(This->publicId);
1355         if(This->systemId)
1356             SysFreeString(This->systemId);
1357
1358         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1359         HeapFree( GetProcessHeap(), 0, This );
1360     }
1361
1362     return ref;
1363 }
1364
1365 /*** ISAXLocator methods ***/
1366 static HRESULT WINAPI isaxlocator_getColumnNumber(
1367         ISAXLocator* iface,
1368         int *pnColumn)
1369 {
1370     saxlocator *This = impl_from_ISAXLocator( iface );
1371
1372     *pnColumn = This->column;
1373     return S_OK;
1374 }
1375
1376 static HRESULT WINAPI isaxlocator_getLineNumber(
1377         ISAXLocator* iface,
1378         int *pnLine)
1379 {
1380     saxlocator *This = impl_from_ISAXLocator( iface );
1381
1382     *pnLine = This->line;
1383     return S_OK;
1384 }
1385
1386 static HRESULT WINAPI isaxlocator_getPublicId(
1387         ISAXLocator* iface,
1388         const WCHAR ** ppwchPublicId)
1389 {
1390     BSTR publicId;
1391     saxlocator *This = impl_from_ISAXLocator( iface );
1392
1393     if(This->publicId) SysFreeString(This->publicId);
1394
1395     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1396     if(SysStringLen(publicId))
1397         This->publicId = (WCHAR*)&publicId;
1398     else
1399     {
1400         SysFreeString(publicId);
1401         This->publicId = NULL;
1402     }
1403
1404     *ppwchPublicId = This->publicId;
1405     return S_OK;
1406 }
1407
1408 static HRESULT WINAPI isaxlocator_getSystemId(
1409         ISAXLocator* iface,
1410         const WCHAR ** ppwchSystemId)
1411 {
1412     BSTR systemId;
1413     saxlocator *This = impl_from_ISAXLocator( iface );
1414
1415     if(This->systemId) SysFreeString(This->systemId);
1416
1417     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1418     if(SysStringLen(systemId))
1419         This->systemId = (WCHAR*)&systemId;
1420     else
1421     {
1422         SysFreeString(systemId);
1423         This->systemId = NULL;
1424     }
1425
1426     *ppwchSystemId = This->systemId;
1427     return S_OK;
1428 }
1429
1430 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1431 {
1432     isaxlocator_QueryInterface,
1433     isaxlocator_AddRef,
1434     isaxlocator_Release,
1435     isaxlocator_getColumnNumber,
1436     isaxlocator_getLineNumber,
1437     isaxlocator_getPublicId,
1438     isaxlocator_getSystemId
1439 };
1440
1441 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1442 {
1443     saxlocator *locator;
1444
1445     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
1446     if( !locator )
1447         return E_OUTOFMEMORY;
1448
1449     locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1450     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1451     locator->ref = 1;
1452     locator->vbInterface = vbInterface;
1453
1454     locator->saxreader = reader;
1455     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1456
1457     locator->pParserCtxt = NULL;
1458     locator->publicId = NULL;
1459     locator->systemId = NULL;
1460     locator->lastCur = NULL;
1461     locator->line = 0;
1462     locator->column = 0;
1463     locator->ret = S_OK;
1464
1465     *ppsaxlocator = locator;
1466
1467     TRACE("returning %p\n", *ppsaxlocator);
1468
1469     return S_OK;
1470 }
1471
1472 /*** SAXXMLReader internal functions ***/
1473 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1474 {
1475     saxlocator *locator;
1476     HRESULT hr;
1477
1478     hr = SAXLocator_create(This, &locator, vbInterface);
1479     if(FAILED(hr))
1480         return E_FAIL;
1481
1482     locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1483     if(!locator->pParserCtxt)
1484     {
1485         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1486         return E_FAIL;
1487     }
1488
1489     locator->pParserCtxt->sax = &locator->saxreader->sax;
1490     locator->pParserCtxt->userData = locator;
1491
1492     if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1493     else hr = locator->ret;
1494
1495     if(locator->pParserCtxt)
1496     {
1497         locator->pParserCtxt->sax = NULL;
1498         xmlFreeParserCtxt(locator->pParserCtxt);
1499         locator->pParserCtxt = NULL;
1500     }
1501
1502     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1503     return S_OK;
1504 }
1505
1506 static HRESULT WINAPI internal_getEntityResolver(
1507         saxreader *This,
1508         void *pEntityResolver,
1509         BOOL vbInterface)
1510 {
1511     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1512     return E_NOTIMPL;
1513 }
1514
1515 static HRESULT WINAPI internal_putEntityResolver(
1516         saxreader *This,
1517         void *pEntityResolver,
1518         BOOL vbInterface)
1519 {
1520     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1521     return E_NOTIMPL;
1522 }
1523
1524 static HRESULT WINAPI internal_getContentHandler(
1525         saxreader* This,
1526         void *pContentHandler,
1527         BOOL vbInterface)
1528 {
1529     TRACE("(%p)->(%p)\n", This, pContentHandler);
1530     if(pContentHandler == NULL)
1531         return E_POINTER;
1532     if(This->contentHandler)
1533     {
1534         if(vbInterface)
1535             IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1536         else
1537             ISAXContentHandler_AddRef(This->contentHandler);
1538     }
1539     if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1540         This->vbcontentHandler;
1541     else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1542
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI internal_putContentHandler(
1547         saxreader* This,
1548         void *contentHandler,
1549         BOOL vbInterface)
1550 {
1551     TRACE("(%p)->(%p)\n", This, contentHandler);
1552     if(contentHandler)
1553     {
1554         if(vbInterface)
1555             IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1556         else
1557             ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1558     }
1559     if(This->contentHandler)
1560     {
1561         if(vbInterface)
1562             IVBSAXContentHandler_Release(This->vbcontentHandler);
1563         else
1564             ISAXContentHandler_Release(This->contentHandler);
1565     }
1566     if(vbInterface)
1567         This->vbcontentHandler = contentHandler;
1568     else
1569         This->contentHandler = contentHandler;
1570
1571     return S_OK;
1572 }
1573
1574 static HRESULT WINAPI internal_getDTDHandler(
1575         saxreader* This,
1576         void *pDTDHandler,
1577         BOOL vbInterface)
1578 {
1579     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1580     return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI internal_putDTDHandler(
1584         saxreader* This,
1585         void *pDTDHandler,
1586         BOOL vbInterface)
1587 {
1588     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1589     return E_NOTIMPL;
1590 }
1591
1592 static HRESULT WINAPI internal_getErrorHandler(
1593         saxreader* This,
1594         void *pErrorHandler,
1595         BOOL vbInterface)
1596 {
1597     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1598     if(pErrorHandler == NULL)
1599         return E_POINTER;
1600     if(This->errorHandler)
1601     {
1602         if(vbInterface)
1603             IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1604         else
1605             ISAXErrorHandler_AddRef(This->errorHandler);
1606     }
1607     if(vbInterface)
1608         *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1609     else
1610         *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1611
1612     return S_OK;
1613
1614 }
1615
1616 static HRESULT WINAPI internal_putErrorHandler(
1617         saxreader* This,
1618         void *errorHandler,
1619         BOOL vbInterface)
1620 {
1621     TRACE("(%p)->(%p)\n", This, errorHandler);
1622     if(errorHandler)
1623     {
1624         if(vbInterface)
1625             IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
1626         else
1627             ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
1628     }
1629     if(This->errorHandler)
1630     {
1631         if(vbInterface)
1632             IVBSAXErrorHandler_Release(This->vberrorHandler);
1633         else
1634             ISAXErrorHandler_Release(This->errorHandler);
1635     }
1636     if(vbInterface)
1637         This->vberrorHandler = errorHandler;
1638     else
1639         This->errorHandler = errorHandler;
1640
1641     return S_OK;
1642
1643 }
1644
1645 static HRESULT WINAPI internal_parse(
1646         saxreader* This,
1647         VARIANT varInput,
1648         BOOL vbInterface)
1649 {
1650     HRESULT hr;
1651
1652     TRACE("(%p)\n", This);
1653
1654     hr = S_OK;
1655     switch(V_VT(&varInput))
1656     {
1657         case VT_BSTR:
1658             hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
1659                     SysStringByteLen(V_BSTR(&varInput)), vbInterface);
1660             break;
1661         case VT_ARRAY|VT_UI1: {
1662             void *pSAData;
1663             LONG lBound, uBound;
1664             ULONG dataRead;
1665
1666             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
1667             if(hr != S_OK) break;
1668             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
1669             if(hr != S_OK) break;
1670             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
1671             hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
1672             if(hr != S_OK) break;
1673             hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
1674             SafeArrayUnaccessData(V_ARRAY(&varInput));
1675             break;
1676         }
1677         case VT_UNKNOWN:
1678         case VT_DISPATCH: {
1679             IPersistStream *persistStream;
1680             IStream *stream = NULL;
1681             IXMLDOMDocument *xmlDoc;
1682
1683             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1684                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
1685             {
1686                 hr = IPersistStream_Save(persistStream, stream, TRUE);
1687                 IPersistStream_Release(persistStream);
1688                 if(hr != S_OK) break;
1689             }
1690             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1691                         &IID_IStream, (void**)&stream) == S_OK)
1692             {
1693                 STATSTG dataInfo;
1694                 ULONG dataRead;
1695                 char *data;
1696
1697                 while(1)
1698                 {
1699                     hr = IStream_Stat(stream, &dataInfo, STATFLAG_NONAME);
1700                     if(hr == E_PENDING) continue;
1701                     break;
1702                 }
1703                 data = HeapAlloc(GetProcessHeap(), 0,
1704                         dataInfo.cbSize.QuadPart);
1705                 while(1)
1706                 {
1707                     hr = IStream_Read(stream, data,
1708                             dataInfo.cbSize.QuadPart, &dataRead);
1709                     if(hr == E_PENDING) continue;
1710                     break;
1711                 }
1712                 hr = internal_parseBuffer(This, data,
1713                         dataInfo.cbSize.QuadPart, vbInterface);
1714                 HeapFree(GetProcessHeap(), 0, data);
1715                 IStream_Release(stream);
1716                 break;
1717             }
1718             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1719                                        &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
1720             {
1721                 BSTR bstrData;
1722
1723                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
1724                 hr = internal_parseBuffer(This, (const char*)bstrData,
1725                         SysStringByteLen(bstrData), vbInterface);
1726                 IXMLDOMDocument_Release(xmlDoc);
1727                 hr = E_NOTIMPL;
1728                 break;
1729             }
1730         }
1731         default:
1732             WARN("vt %d not implemented\n", V_VT(&varInput));
1733             hr = E_INVALIDARG;
1734     }
1735
1736     return hr;
1737 }
1738
1739 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
1740 {
1741     saxreader *This = obj;
1742
1743     return internal_parseBuffer(This, ptr, len, TRUE);
1744 }
1745
1746 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
1747 {
1748     saxreader *This = obj;
1749
1750     return internal_parseBuffer(This, ptr, len, FALSE);
1751 }
1752
1753 static HRESULT WINAPI internal_parseURL(
1754         saxreader* This,
1755         const WCHAR *url,
1756         BOOL vbInterface)
1757 {
1758     bsc_t *bsc;
1759     HRESULT hr;
1760
1761     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
1762
1763     if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
1764     else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
1765
1766     if(FAILED(hr))
1767         return hr;
1768
1769     detach_bsc(bsc);
1770
1771     return S_OK;
1772 }
1773
1774 /*** IVBSAXXMLReader interface ***/
1775 /*** IUnknown methods ***/
1776 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
1777 {
1778     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1779
1780     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1781
1782     *ppvObject = NULL;
1783
1784     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1785          IsEqualGUID( riid, &IID_IDispatch ) ||
1786          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
1787     {
1788         *ppvObject = iface;
1789     }
1790     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
1791     {
1792         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
1793     }
1794     else
1795     {
1796         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1797         return E_NOINTERFACE;
1798     }
1799
1800     IVBSAXXMLReader_AddRef( iface );
1801
1802     return S_OK;
1803 }
1804
1805 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
1806 {
1807     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1808     TRACE("%p\n", This );
1809     return InterlockedIncrement( &This->ref );
1810 }
1811
1812 static ULONG WINAPI saxxmlreader_Release(
1813     IVBSAXXMLReader* iface)
1814 {
1815     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1816     LONG ref;
1817
1818     TRACE("%p\n", This );
1819
1820     ref = InterlockedDecrement( &This->ref );
1821     if ( ref == 0 )
1822     {
1823         if(This->contentHandler)
1824             ISAXContentHandler_Release(This->contentHandler);
1825
1826         if(This->errorHandler)
1827             ISAXErrorHandler_Release(This->errorHandler);
1828
1829         HeapFree( GetProcessHeap(), 0, This );
1830     }
1831
1832     return ref;
1833 }
1834 /*** IDispatch ***/
1835 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
1836 {
1837     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1838
1839     TRACE("(%p)->(%p)\n", This, pctinfo);
1840
1841     *pctinfo = 1;
1842
1843     return S_OK;
1844 }
1845
1846 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
1847     IVBSAXXMLReader *iface,
1848     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1849 {
1850     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1851     HRESULT hr;
1852
1853     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1854
1855     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
1856
1857     return hr;
1858 }
1859
1860 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
1861     IVBSAXXMLReader *iface,
1862     REFIID riid,
1863     LPOLESTR* rgszNames,
1864     UINT cNames,
1865     LCID lcid,
1866     DISPID* rgDispId)
1867 {
1868     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1869     ITypeInfo *typeinfo;
1870     HRESULT hr;
1871
1872     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1873           lcid, rgDispId);
1874
1875     if(!rgszNames || cNames == 0 || !rgDispId)
1876         return E_INVALIDARG;
1877
1878     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
1879     if(SUCCEEDED(hr))
1880     {
1881         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1882         ITypeInfo_Release(typeinfo);
1883     }
1884
1885     return hr;
1886 }
1887
1888 static HRESULT WINAPI saxxmlreader_Invoke(
1889     IVBSAXXMLReader *iface,
1890     DISPID dispIdMember,
1891     REFIID riid,
1892     LCID lcid,
1893     WORD wFlags,
1894     DISPPARAMS* pDispParams,
1895     VARIANT* pVarResult,
1896     EXCEPINFO* pExcepInfo,
1897     UINT* puArgErr)
1898 {
1899     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1900     ITypeInfo *typeinfo;
1901     HRESULT hr;
1902
1903     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1904           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1905
1906     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
1907     if(SUCCEEDED(hr))
1908     {
1909         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
1910                 pVarResult, pExcepInfo, puArgErr);
1911         ITypeInfo_Release(typeinfo);
1912     }
1913
1914     return hr;
1915 }
1916
1917 /*** IVBSAXXMLReader methods ***/
1918 static HRESULT WINAPI saxxmlreader_getFeature(
1919     IVBSAXXMLReader* iface,
1920     const WCHAR *pFeature,
1921     VARIANT_BOOL *pValue)
1922 {
1923     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1924
1925     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
1926     return E_NOTIMPL;
1927 }
1928
1929 static HRESULT WINAPI saxxmlreader_putFeature(
1930     IVBSAXXMLReader* iface,
1931     const WCHAR *pFeature,
1932     VARIANT_BOOL vfValue)
1933 {
1934     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1935
1936     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
1937     return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI saxxmlreader_getProperty(
1941     IVBSAXXMLReader* iface,
1942     const WCHAR *pProp,
1943     VARIANT *pValue)
1944 {
1945     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1946
1947     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
1948     return E_NOTIMPL;
1949 }
1950
1951 static HRESULT WINAPI saxxmlreader_putProperty(
1952     IVBSAXXMLReader* iface,
1953     const WCHAR *pProp,
1954     VARIANT value)
1955 {
1956     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1957
1958     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
1959     return E_NOTIMPL;
1960 }
1961
1962 static HRESULT WINAPI saxxmlreader_getEntityResolver(
1963     IVBSAXXMLReader* iface,
1964     IVBSAXEntityResolver **pEntityResolver)
1965 {
1966     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1967     return internal_getEntityResolver(This, pEntityResolver, TRUE);
1968 }
1969
1970 static HRESULT WINAPI saxxmlreader_putEntityResolver(
1971     IVBSAXXMLReader* iface,
1972     IVBSAXEntityResolver *pEntityResolver)
1973 {
1974     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1975     return internal_putEntityResolver(This, pEntityResolver, TRUE);
1976 }
1977
1978 static HRESULT WINAPI saxxmlreader_getContentHandler(
1979     IVBSAXXMLReader* iface,
1980     IVBSAXContentHandler **ppContentHandler)
1981 {
1982     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1983     return internal_getContentHandler(This, ppContentHandler, TRUE);
1984 }
1985
1986 static HRESULT WINAPI saxxmlreader_putContentHandler(
1987     IVBSAXXMLReader* iface,
1988     IVBSAXContentHandler *contentHandler)
1989 {
1990     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1991     return internal_putContentHandler(This, contentHandler, TRUE);
1992 }
1993
1994 static HRESULT WINAPI saxxmlreader_getDTDHandler(
1995     IVBSAXXMLReader* iface,
1996     IVBSAXDTDHandler **pDTDHandler)
1997 {
1998     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1999     return internal_getDTDHandler(This, pDTDHandler, TRUE);
2000 }
2001
2002 static HRESULT WINAPI saxxmlreader_putDTDHandler(
2003     IVBSAXXMLReader* iface,
2004     IVBSAXDTDHandler *pDTDHandler)
2005 {
2006     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2007     return internal_putDTDHandler(This, pDTDHandler, TRUE);
2008 }
2009
2010 static HRESULT WINAPI saxxmlreader_getErrorHandler(
2011     IVBSAXXMLReader* iface,
2012     IVBSAXErrorHandler **pErrorHandler)
2013 {
2014     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2015     return internal_getErrorHandler(This, pErrorHandler, TRUE);
2016 }
2017
2018 static HRESULT WINAPI saxxmlreader_putErrorHandler(
2019     IVBSAXXMLReader* iface,
2020     IVBSAXErrorHandler *errorHandler)
2021 {
2022     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2023     return internal_putErrorHandler(This, errorHandler, TRUE);
2024 }
2025
2026 static HRESULT WINAPI saxxmlreader_getBaseURL(
2027     IVBSAXXMLReader* iface,
2028     const WCHAR **pBaseUrl)
2029 {
2030     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2031
2032     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2033     return E_NOTIMPL;
2034 }
2035
2036 static HRESULT WINAPI saxxmlreader_putBaseURL(
2037     IVBSAXXMLReader* iface,
2038     const WCHAR *pBaseUrl)
2039 {
2040     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2041
2042     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2043     return E_NOTIMPL;
2044 }
2045
2046 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
2047     IVBSAXXMLReader* iface,
2048     const WCHAR **pSecureBaseUrl)
2049 {
2050     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2051
2052     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2053     return E_NOTIMPL;
2054 }
2055
2056
2057 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
2058     IVBSAXXMLReader* iface,
2059     const WCHAR *secureBaseUrl)
2060 {
2061     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2062
2063     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2064     return E_NOTIMPL;
2065 }
2066
2067 static HRESULT WINAPI saxxmlreader_parse(
2068     IVBSAXXMLReader* iface,
2069     VARIANT varInput)
2070 {
2071     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2072     return internal_parse(This, varInput, TRUE);
2073 }
2074
2075 static HRESULT WINAPI saxxmlreader_parseURL(
2076     IVBSAXXMLReader* iface,
2077     const WCHAR *url)
2078 {
2079     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2080     return internal_parseURL(This, url, TRUE);
2081 }
2082
2083 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2084 {
2085     saxxmlreader_QueryInterface,
2086     saxxmlreader_AddRef,
2087     saxxmlreader_Release,
2088     saxxmlreader_GetTypeInfoCount,
2089     saxxmlreader_GetTypeInfo,
2090     saxxmlreader_GetIDsOfNames,
2091     saxxmlreader_Invoke,
2092     saxxmlreader_getFeature,
2093     saxxmlreader_putFeature,
2094     saxxmlreader_getProperty,
2095     saxxmlreader_putProperty,
2096     saxxmlreader_getEntityResolver,
2097     saxxmlreader_putEntityResolver,
2098     saxxmlreader_getContentHandler,
2099     saxxmlreader_putContentHandler,
2100     saxxmlreader_getDTDHandler,
2101     saxxmlreader_putDTDHandler,
2102     saxxmlreader_getErrorHandler,
2103     saxxmlreader_putErrorHandler,
2104     saxxmlreader_getBaseURL,
2105     saxxmlreader_putBaseURL,
2106     saxxmlreader_getSecureBaseURL,
2107     saxxmlreader_putSecureBaseURL,
2108     saxxmlreader_parse,
2109     saxxmlreader_parseURL
2110 };
2111
2112 /*** ISAXXMLReader interface ***/
2113 /*** IUnknown methods ***/
2114 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2115 {
2116     saxreader *This = impl_from_ISAXXMLReader( iface );
2117     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2118 }
2119
2120 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2121 {
2122     saxreader *This = impl_from_ISAXXMLReader( iface );
2123     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2124 }
2125
2126 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2127 {
2128     saxreader *This = impl_from_ISAXXMLReader( iface );
2129     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2130 }
2131
2132 /*** ISAXXMLReader methods ***/
2133 static HRESULT WINAPI isaxxmlreader_getFeature(
2134         ISAXXMLReader* iface,
2135         const WCHAR *pFeature,
2136         VARIANT_BOOL *pValue)
2137 {
2138     saxreader *This = impl_from_ISAXXMLReader( iface );
2139     return IVBSAXXMLReader_getFeature(
2140             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2141             pFeature, pValue);
2142 }
2143
2144 static HRESULT WINAPI isaxxmlreader_putFeature(
2145         ISAXXMLReader* iface,
2146         const WCHAR *pFeature,
2147         VARIANT_BOOL vfValue)
2148 {
2149     saxreader *This = impl_from_ISAXXMLReader( iface );
2150     return IVBSAXXMLReader_putFeature(
2151             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2152             pFeature, vfValue);
2153 }
2154
2155 static HRESULT WINAPI isaxxmlreader_getProperty(
2156         ISAXXMLReader* iface,
2157         const WCHAR *pProp,
2158         VARIANT *pValue)
2159 {
2160     saxreader *This = impl_from_ISAXXMLReader( iface );
2161     return IVBSAXXMLReader_getProperty(
2162             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2163             pProp, pValue);
2164 }
2165
2166 static HRESULT WINAPI isaxxmlreader_putProperty(
2167         ISAXXMLReader* iface,
2168         const WCHAR *pProp,
2169         VARIANT value)
2170 {
2171     saxreader *This = impl_from_ISAXXMLReader( iface );
2172     return IVBSAXXMLReader_putProperty(
2173             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2174             pProp, value);
2175 }
2176
2177 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2178         ISAXXMLReader* iface,
2179         ISAXEntityResolver **ppEntityResolver)
2180 {
2181     saxreader *This = impl_from_ISAXXMLReader( iface );
2182     return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2183 }
2184
2185 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2186         ISAXXMLReader* iface,
2187         ISAXEntityResolver *pEntityResolver)
2188 {
2189     saxreader *This = impl_from_ISAXXMLReader( iface );
2190     return internal_putEntityResolver(This, pEntityResolver, FALSE);
2191 }
2192
2193 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2194         ISAXXMLReader* iface,
2195         ISAXContentHandler **pContentHandler)
2196 {
2197     saxreader *This = impl_from_ISAXXMLReader( iface );
2198     return internal_getContentHandler(This, pContentHandler, FALSE);
2199 }
2200
2201 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2202         ISAXXMLReader* iface,
2203         ISAXContentHandler *contentHandler)
2204 {
2205     saxreader *This = impl_from_ISAXXMLReader( iface );
2206     return internal_putContentHandler(This, contentHandler, FALSE);
2207 }
2208
2209 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2210         ISAXXMLReader* iface,
2211         ISAXDTDHandler **pDTDHandler)
2212 {
2213     saxreader *This = impl_from_ISAXXMLReader( iface );
2214     return internal_getDTDHandler(This, pDTDHandler, FALSE);
2215 }
2216
2217 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2218         ISAXXMLReader* iface,
2219         ISAXDTDHandler *pDTDHandler)
2220 {
2221     saxreader *This = impl_from_ISAXXMLReader( iface );
2222     return internal_putDTDHandler(This, pDTDHandler, FALSE);
2223 }
2224
2225 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2226         ISAXXMLReader* iface,
2227         ISAXErrorHandler **pErrorHandler)
2228 {
2229     saxreader *This = impl_from_ISAXXMLReader( iface );
2230     return internal_getErrorHandler(This, pErrorHandler, FALSE);
2231 }
2232
2233 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2234         ISAXXMLReader* iface,
2235         ISAXErrorHandler *errorHandler)
2236 {
2237     saxreader *This = impl_from_ISAXXMLReader( iface );
2238     return internal_putErrorHandler(This, errorHandler, FALSE);
2239 }
2240
2241 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2242         ISAXXMLReader* iface,
2243         const WCHAR **pBaseUrl)
2244 {
2245     saxreader *This = impl_from_ISAXXMLReader( iface );
2246     return IVBSAXXMLReader_get_getBaseURL(
2247             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2248             pBaseUrl);
2249 }
2250
2251 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2252         ISAXXMLReader* iface,
2253         const WCHAR *pBaseUrl)
2254 {
2255     saxreader *This = impl_from_ISAXXMLReader( iface );
2256     return IVBSAXXMLReader_put_putBaseURL(
2257             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2258             pBaseUrl);
2259 }
2260
2261 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2262         ISAXXMLReader* iface,
2263         const WCHAR **pSecureBaseUrl)
2264 {
2265     saxreader *This = impl_from_ISAXXMLReader( iface );
2266     return IVBSAXXMLReader_get_getSecureBaseURL(
2267             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2268             pSecureBaseUrl);
2269 }
2270
2271 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2272         ISAXXMLReader* iface,
2273         const WCHAR *secureBaseUrl)
2274 {
2275     saxreader *This = impl_from_ISAXXMLReader( iface );
2276     return IVBSAXXMLReader_put_putSecureBaseURL(
2277             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2278             secureBaseUrl);
2279 }
2280
2281 static HRESULT WINAPI isaxxmlreader_parse(
2282         ISAXXMLReader* iface,
2283         VARIANT varInput)
2284 {
2285     saxreader *This = impl_from_ISAXXMLReader( iface );
2286     return internal_parse(This, varInput, FALSE);
2287 }
2288
2289 static HRESULT WINAPI isaxxmlreader_parseURL(
2290         ISAXXMLReader* iface,
2291         const WCHAR *url)
2292 {
2293     saxreader *This = impl_from_ISAXXMLReader( iface );
2294     return internal_parseURL(This, url, FALSE);
2295 }
2296
2297 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2298 {
2299     isaxxmlreader_QueryInterface,
2300     isaxxmlreader_AddRef,
2301     isaxxmlreader_Release,
2302     isaxxmlreader_getFeature,
2303     isaxxmlreader_putFeature,
2304     isaxxmlreader_getProperty,
2305     isaxxmlreader_putProperty,
2306     isaxxmlreader_getEntityResolver,
2307     isaxxmlreader_putEntityResolver,
2308     isaxxmlreader_getContentHandler,
2309     isaxxmlreader_putContentHandler,
2310     isaxxmlreader_getDTDHandler,
2311     isaxxmlreader_putDTDHandler,
2312     isaxxmlreader_getErrorHandler,
2313     isaxxmlreader_putErrorHandler,
2314     isaxxmlreader_getBaseURL,
2315     isaxxmlreader_putBaseURL,
2316     isaxxmlreader_getSecureBaseURL,
2317     isaxxmlreader_putSecureBaseURL,
2318     isaxxmlreader_parse,
2319     isaxxmlreader_parseURL
2320 };
2321
2322 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2323 {
2324     saxreader *reader;
2325
2326     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2327
2328     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
2329     if( !reader )
2330         return E_OUTOFMEMORY;
2331
2332     reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2333     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2334     reader->ref = 1;
2335     reader->contentHandler = NULL;
2336     reader->errorHandler = NULL;
2337
2338     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2339     reader->sax.initialized = XML_SAX2_MAGIC;
2340     reader->sax.startDocument = libxmlStartDocument;
2341     reader->sax.endDocument = libxmlEndDocument;
2342     reader->sax.startElementNs = libxmlStartElementNS;
2343     reader->sax.endElementNs = libxmlEndElementNS;
2344     reader->sax.characters = libxmlCharacters;
2345     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2346     reader->sax.error = libxmlFatalError;
2347     reader->sax.fatalError = libxmlFatalError;
2348
2349     *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2350
2351     TRACE("returning iface %p\n", *ppObj);
2352
2353     return S_OK;
2354 }
2355
2356 #else
2357
2358 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2359 {
2360     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2361             "libxml2 support was not present at compile time.\n");
2362     return E_NOTIMPL;
2363 }
2364
2365 #endif