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