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