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