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