dlls/msxml3/saxreader.c

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