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