dlls/msxml3/saxreader.c

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