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