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