dlls/msxml3/saxreader.c

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