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