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 i;
1164
1165     /* skip namespace definitions */
1166     if ((locator->saxreader->features & NamespacePrefixes) == 0)
1167         nb_namespaces = 0;
1168
1169     locator->nb_attributes = nb_namespaces + nb_attributes;
1170     if(locator->nb_attributes > locator->attributesSize)
1171     {
1172         attrs = heap_realloc(locator->attributes, sizeof(struct _attributes)*locator->nb_attributes*2);
1173         if(!attrs)
1174         {
1175             locator->nb_attributes = 0;
1176             return E_OUTOFMEMORY;
1177         }
1178         locator->attributes = attrs;
1179     }
1180     else
1181     {
1182         attrs = locator->attributes;
1183     }
1184
1185     for (i = 0; i < nb_namespaces; i++)
1186     {
1187         attrs[nb_attributes+i].szLocalname = SysAllocStringLen(NULL, 0);
1188         attrs[nb_attributes+i].szURI = locator->namespaceUri;
1189         attrs[nb_attributes+i].szValue = bstr_from_xmlChar(xmlNamespaces[2*i+1]);
1190         if(!xmlNamespaces[2*i])
1191             attrs[nb_attributes+i].szQName = SysAllocString(xmlnsW);
1192         else
1193             attrs[nb_attributes+i].szQName = QName_from_xmlChar(xmlns, xmlNamespaces[2*i]);
1194     }
1195
1196     for (i = 0; i < nb_attributes; i++)
1197     {
1198         static const xmlChar xmlA[] = "xml";
1199
1200         if (xmlStrEqual(xmlAttributes[i*5+1], xmlA))
1201             attrs[i].szURI = bstr_from_xmlChar(xmlAttributes[i*5+2]);
1202         else
1203             attrs[i].szURI = find_element_uri(locator, xmlAttributes[i*5+2]);
1204
1205         attrs[i].szLocalname = bstr_from_xmlChar(xmlAttributes[i*5]);
1206         attrs[i].szValue = bstr_from_xmlCharN(xmlAttributes[i*5+3],
1207                 xmlAttributes[i*5+4]-xmlAttributes[i*5+3]);
1208         attrs[i].szQName = QName_from_xmlChar(xmlAttributes[i*5+1],
1209                 xmlAttributes[i*5]);
1210     }
1211
1212     return S_OK;
1213 }
1214
1215 /*** LibXML callbacks ***/
1216 static void libxmlStartDocument(void *ctx)
1217 {
1218     saxlocator *This = ctx;
1219     HRESULT hr;
1220
1221     if (This->saxreader->version >= MSXML4)
1222     {
1223         const xmlChar *p = This->pParserCtxt->input->cur-1;
1224         update_position(This, FALSE);
1225         while(p>This->pParserCtxt->input->base && *p!='>')
1226         {
1227             if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1228                 This->line--;
1229             p--;
1230         }
1231         This->column = 0;
1232         for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1233             This->column++;
1234     }
1235
1236     if(has_content_handler(This))
1237     {
1238         if(This->vbInterface)
1239             hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
1240         else
1241             hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
1242
1243         if (sax_callback_failed(This, hr))
1244             format_error_message_from_id(This, hr);
1245     }
1246 }
1247
1248 static void libxmlEndDocument(void *ctx)
1249 {
1250     saxlocator *This = ctx;
1251     HRESULT hr;
1252
1253     if (This->saxreader->version >= MSXML4) {
1254         update_position(This, FALSE);
1255         if(This->column > 1)
1256             This->line++;
1257         This->column = 0;
1258     } else {
1259         This->column = 0;
1260         This->line = 0;
1261     }
1262
1263     if(This->ret != S_OK) return;
1264
1265     if(has_content_handler(This))
1266     {
1267         if(This->vbInterface)
1268             hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1269         else
1270             hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1271
1272         if (sax_callback_failed(This, hr))
1273             format_error_message_from_id(This, hr);
1274     }
1275 }
1276
1277 static void libxmlStartElementNS(
1278         void *ctx,
1279         const xmlChar *localname,
1280         const xmlChar *prefix,
1281         const xmlChar *URI,
1282         int nb_namespaces,
1283         const xmlChar **namespaces,
1284         int nb_attributes,
1285         int nb_defaulted,
1286         const xmlChar **attributes)
1287 {
1288     saxlocator *This = ctx;
1289     element_entry *element;
1290     HRESULT hr = S_OK;
1291
1292     update_position(This, TRUE);
1293     if(*(This->pParserCtxt->input->cur) == '/')
1294         This->column++;
1295     if(This->saxreader->version < MSXML4)
1296         This->column++;
1297
1298     element = alloc_element_entry(localname, prefix, nb_namespaces, namespaces);
1299     push_element_ns(This, element);
1300
1301     if (has_content_handler(This))
1302     {
1303         BSTR uri;
1304
1305         if (is_namespaces_enabled(This->saxreader))
1306         {
1307             int i;
1308
1309             for (i = 0; i < nb_namespaces; i++)
1310             {
1311                 if (This->vbInterface)
1312                     hr = IVBSAXContentHandler_startPrefixMapping(
1313                             This->saxreader->vbcontentHandler,
1314                             &element->ns[i].prefix,
1315                             &element->ns[i].uri);
1316                 else
1317                     hr = ISAXContentHandler_startPrefixMapping(
1318                             This->saxreader->contentHandler,
1319                             element->ns[i].prefix,
1320                             SysStringLen(element->ns[i].prefix),
1321                             element->ns[i].uri,
1322                             SysStringLen(element->ns[i].uri));
1323
1324                 if (sax_callback_failed(This, hr))
1325                 {
1326                     format_error_message_from_id(This, hr);
1327                     return;
1328                 }
1329             }
1330         }
1331
1332         uri = find_element_uri(This, URI);
1333
1334         hr = SAXAttributes_populate(This, nb_namespaces, namespaces, nb_attributes, attributes);
1335         if (hr == S_OK)
1336         {
1337             BSTR local;
1338
1339             if (is_namespaces_enabled(This->saxreader))
1340                 local = element->local;
1341             else
1342                 uri = local = NULL;
1343
1344             if (This->vbInterface)
1345                 hr = IVBSAXContentHandler_startElement(This->saxreader->vbcontentHandler,
1346                         &uri, &local, &element->qname, &This->IVBSAXAttributes_iface);
1347             else
1348                 hr = ISAXContentHandler_startElement(This->saxreader->contentHandler,
1349                         uri, SysStringLen(uri),
1350                         local, SysStringLen(local),
1351                         element->qname, SysStringLen(element->qname),
1352                         &This->ISAXAttributes_iface);
1353         }
1354     }
1355
1356     if (sax_callback_failed(This, hr))
1357         format_error_message_from_id(This, hr);
1358 }
1359
1360 static void libxmlEndElementNS(
1361         void *ctx,
1362         const xmlChar *localname,
1363         const xmlChar *prefix,
1364         const xmlChar *URI)
1365 {
1366     saxlocator *This = ctx;
1367     element_entry *element;
1368     const xmlChar *p;
1369     BSTR uri, local;
1370     HRESULT hr;
1371
1372     update_position(This, FALSE);
1373     p = This->pParserCtxt->input->cur;
1374
1375     if (This->saxreader->version >= MSXML4)
1376     {
1377         p--;
1378         while(p>This->pParserCtxt->input->base && *p!='>')
1379         {
1380             if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1381                 This->line--;
1382             p--;
1383         }
1384     }
1385     else if(*(p-1)!='>' || *(p-2)!='/')
1386     {
1387         p--;
1388         while(p-2>=This->pParserCtxt->input->base
1389                 && *(p-2)!='<' && *(p-1)!='/')
1390         {
1391             if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1392                 This->line--;
1393             p--;
1394         }
1395     }
1396     This->column = 0;
1397     for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1398         This->column++;
1399
1400     uri = find_element_uri(This, URI);
1401     element = pop_element_ns(This);
1402
1403     if (!has_content_handler(This))
1404     {
1405         This->nb_attributes = 0;
1406         free_element_entry(element);
1407         return;
1408     }
1409
1410     if (is_namespaces_enabled(This->saxreader))
1411         local = element->local;
1412     else
1413         uri = local = NULL;
1414
1415     if (This->vbInterface)
1416         hr = IVBSAXContentHandler_endElement(
1417                 This->saxreader->vbcontentHandler,
1418                 &uri, &local, &element->qname);
1419     else
1420         hr = ISAXContentHandler_endElement(
1421                 This->saxreader->contentHandler,
1422                 uri, SysStringLen(uri),
1423                 local, SysStringLen(local),
1424                 element->qname, SysStringLen(element->qname));
1425
1426     This->nb_attributes = 0;
1427
1428     if (sax_callback_failed(This, hr))
1429     {
1430         format_error_message_from_id(This, hr);
1431         free_element_entry(element);
1432         return;
1433     }
1434
1435     if (is_namespaces_enabled(This->saxreader))
1436     {
1437         int i = -1;
1438         while (iterate_endprefix_index(This, element, &i))
1439         {
1440             if (This->vbInterface)
1441                 hr = IVBSAXContentHandler_endPrefixMapping(
1442                         This->saxreader->vbcontentHandler, &element->ns[i].prefix);
1443             else
1444                 hr = ISAXContentHandler_endPrefixMapping(
1445                         This->saxreader->contentHandler,
1446                         element->ns[i].prefix, SysStringLen(element->ns[i].prefix));
1447
1448             if (sax_callback_failed(This, hr)) break;
1449        }
1450     }
1451
1452     if (sax_callback_failed(This, hr))
1453         format_error_message_from_id(This, hr);
1454
1455     free_element_entry(element);
1456 }
1457
1458 static void libxmlCharacters(
1459         void *ctx,
1460         const xmlChar *ch,
1461         int len)
1462 {
1463     saxlocator *This = ctx;
1464     BSTR Chars;
1465     HRESULT hr;
1466     xmlChar *cur, *end;
1467     BOOL lastEvent = FALSE;
1468
1469     if(!(has_content_handler(This))) return;
1470
1471     update_position(This, FALSE);
1472     cur = (xmlChar*)This->pParserCtxt->input->cur;
1473     while(cur>=This->pParserCtxt->input->base && *cur!='>')
1474     {
1475         if(*cur=='\n' || (*cur=='\r' && *(cur+1)!='\n'))
1476             This->line--;
1477         cur--;
1478     }
1479     This->column = 1;
1480     for(; cur>=This->pParserCtxt->input->base && *cur!='\n' && *cur!='\r'; cur--)
1481         This->column++;
1482
1483     cur = (xmlChar*)ch;
1484     if(*(ch-1)=='\r') cur--;
1485     end = cur;
1486
1487     while(1)
1488     {
1489         while(end-ch<len && *end!='\r') end++;
1490         if(end-ch==len)
1491         {
1492             lastEvent = TRUE;
1493         }
1494         else
1495         {
1496             *end = '\n';
1497             end++;
1498         }
1499
1500         if (This->saxreader->version >= MSXML4)
1501         {
1502             xmlChar *p;
1503
1504             for(p=cur; p!=end; p++)
1505             {
1506                 if(*p=='\n')
1507                 {
1508                     This->line++;
1509                     This->column = 1;
1510                 }
1511                 else
1512                 {
1513                     This->column++;
1514                 }
1515             }
1516
1517             if(!lastEvent)
1518                 This->column = 0;
1519         }
1520
1521         Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur);
1522         if(This->vbInterface)
1523             hr = IVBSAXContentHandler_characters(
1524                     This->saxreader->vbcontentHandler, &Chars);
1525         else
1526             hr = ISAXContentHandler_characters(
1527                     This->saxreader->contentHandler,
1528                     Chars, SysStringLen(Chars));
1529
1530         if (sax_callback_failed(This, hr))
1531         {
1532             format_error_message_from_id(This, hr);
1533             return;
1534         }
1535
1536         if (This->saxreader->version < MSXML4)
1537             This->column += end-cur;
1538
1539         if(lastEvent)
1540             break;
1541
1542         *(end-1) = '\r';
1543         if(*end == '\n')
1544         {
1545             end++;
1546             This->column++;
1547         }
1548         cur = end;
1549
1550         if(end-ch == len) break;
1551     }
1552 }
1553
1554 static void libxmlSetDocumentLocator(
1555         void *ctx,
1556         xmlSAXLocatorPtr loc)
1557 {
1558     saxlocator *This = ctx;
1559     HRESULT hr = S_OK;
1560
1561     if(has_content_handler(This))
1562     {
1563         if(This->vbInterface)
1564             hr = IVBSAXContentHandler_putref_documentLocator(This->saxreader->vbcontentHandler,
1565                     &This->IVBSAXLocator_iface);
1566         else
1567             hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
1568                     &This->ISAXLocator_iface);
1569     }
1570
1571     if(FAILED(hr))
1572         format_error_message_from_id(This, hr);
1573 }
1574
1575 static void libxmlComment(void *ctx, const xmlChar *value)
1576 {
1577     saxlocator *This = ctx;
1578     BSTR bValue;
1579     HRESULT hr;
1580     const xmlChar *p = This->pParserCtxt->input->cur;
1581
1582     update_position(This, FALSE);
1583     while(p-4>=This->pParserCtxt->input->base
1584             && memcmp(p-4, "<!--", sizeof(char[4])))
1585     {
1586         if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1587             This->line--;
1588         p--;
1589     }
1590     This->column = 0;
1591     for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1592         This->column++;
1593
1594     if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1595     if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1596
1597     bValue = pooled_bstr_from_xmlChar(&This->saxreader->pool, value);
1598
1599     if(This->vbInterface)
1600         hr = IVBSAXLexicalHandler_comment(
1601                 This->saxreader->vblexicalHandler, &bValue);
1602     else
1603         hr = ISAXLexicalHandler_comment(
1604                 This->saxreader->lexicalHandler,
1605                 bValue, SysStringLen(bValue));
1606
1607     if(FAILED(hr))
1608         format_error_message_from_id(This, hr);
1609 }
1610
1611 static void libxmlFatalError(void *ctx, const char *msg, ...)
1612 {
1613     saxlocator *This = ctx;
1614     char message[1024];
1615     WCHAR *error;
1616     DWORD len;
1617     va_list args;
1618
1619     if(This->ret != S_OK) {
1620         xmlStopParser(This->pParserCtxt);
1621         return;
1622     }
1623
1624     va_start(args, msg);
1625     vsprintf(message, msg, args);
1626     va_end(args);
1627
1628     len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1629     error = heap_alloc(sizeof(WCHAR)*len);
1630     if(error)
1631     {
1632         MultiByteToWideChar(CP_UNIXCP, 0, message, -1, error, len);
1633         TRACE("fatal error for %p: %s\n", This, debugstr_w(error));
1634     }
1635
1636     if(!has_error_handler(This))
1637     {
1638         xmlStopParser(This->pParserCtxt);
1639         This->ret = E_FAIL;
1640         heap_free(error);
1641         return;
1642     }
1643
1644     FIXME("Error handling is not compatible.\n");
1645
1646     if(This->vbInterface)
1647     {
1648         BSTR bstrError = SysAllocString(error);
1649         IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler, &This->IVBSAXLocator_iface,
1650                 &bstrError, E_FAIL);
1651         SysFreeString(bstrError);
1652     }
1653     else
1654         ISAXErrorHandler_fatalError(This->saxreader->errorHandler, &This->ISAXLocator_iface,
1655                 error, E_FAIL);
1656
1657     heap_free(error);
1658
1659     xmlStopParser(This->pParserCtxt);
1660     This->ret = E_FAIL;
1661 }
1662
1663 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1664 {
1665     saxlocator *This = ctx;
1666     HRESULT hr = S_OK;
1667     xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1668     xmlChar *cur, *end;
1669     int realLen;
1670     BSTR Chars;
1671     BOOL lastEvent = FALSE, change;
1672
1673     update_position(This, FALSE);
1674     while(beg-9>=This->pParserCtxt->input->base
1675             && memcmp(beg-9, "<![CDATA[", sizeof(char[9])))
1676     {
1677         if(*beg=='\n' || (*beg=='\r' && *(beg+1)!='\n'))
1678             This->line--;
1679         beg--;
1680     }
1681     This->column = 0;
1682     for(; beg>=This->pParserCtxt->input->base && *beg!='\n' && *beg!='\r'; beg--)
1683         This->column++;
1684
1685     if(This->vbInterface && This->saxreader->vblexicalHandler)
1686         hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1687     if(!This->vbInterface && This->saxreader->lexicalHandler)
1688         hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1689
1690     if(FAILED(hr))
1691     {
1692         format_error_message_from_id(This, hr);
1693         return;
1694     }
1695
1696     realLen = This->pParserCtxt->input->cur-beg-3;
1697     cur = beg;
1698     end = beg;
1699
1700     while(1)
1701     {
1702         while(end-beg<realLen && *end!='\r') end++;
1703         if(end-beg==realLen)
1704         {
1705             end--;
1706             lastEvent = TRUE;
1707         }
1708         else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1709             lastEvent = TRUE;
1710
1711         if(*end == '\r') change = TRUE;
1712         else change = FALSE;
1713
1714         if(change) *end = '\n';
1715
1716         if(has_content_handler(This))
1717         {
1718             Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur+1);
1719             if(This->vbInterface)
1720                 hr = IVBSAXContentHandler_characters(
1721                         This->saxreader->vbcontentHandler, &Chars);
1722             else
1723                 hr = ISAXContentHandler_characters(
1724                         This->saxreader->contentHandler,
1725                         Chars, SysStringLen(Chars));
1726         }
1727
1728         if(change) *end = '\r';
1729
1730         if(lastEvent)
1731             break;
1732
1733         This->column += end-cur+2;
1734         end += 2;
1735         cur = end;
1736     }
1737
1738     if(This->vbInterface && This->saxreader->vblexicalHandler)
1739         hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1740     if(!This->vbInterface && This->saxreader->lexicalHandler)
1741         hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1742
1743     if(FAILED(hr))
1744         format_error_message_from_id(This, hr);
1745
1746     This->column += 4+end-cur;
1747 }
1748
1749 /*** IVBSAXLocator interface ***/
1750 /*** IUnknown methods ***/
1751 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1752 {
1753     saxlocator *This = impl_from_IVBSAXLocator( iface );
1754
1755     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1756
1757     *ppvObject = NULL;
1758
1759     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1760             IsEqualGUID( riid, &IID_IDispatch) ||
1761             IsEqualGUID( riid, &IID_IVBSAXLocator ))
1762     {
1763         *ppvObject = iface;
1764     }
1765     else if ( IsEqualGUID( riid, &IID_IVBSAXAttributes ))
1766     {
1767         *ppvObject = &This->IVBSAXAttributes_iface;
1768     }
1769     else
1770     {
1771         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1772         return E_NOINTERFACE;
1773     }
1774
1775     IVBSAXLocator_AddRef( iface );
1776
1777     return S_OK;
1778 }
1779
1780 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1781 {
1782     saxlocator *This = impl_from_IVBSAXLocator( iface );
1783     TRACE("%p\n", This );
1784     return InterlockedIncrement( &This->ref );
1785 }
1786
1787 static ULONG WINAPI ivbsaxlocator_Release(
1788         IVBSAXLocator* iface)
1789 {
1790     saxlocator *This = impl_from_IVBSAXLocator( iface );
1791     return ISAXLocator_Release((ISAXLocator*)&This->IVBSAXLocator_iface);
1792 }
1793
1794 /*** IDispatch methods ***/
1795 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1796 {
1797     saxlocator *This = impl_from_IVBSAXLocator( iface );
1798
1799     TRACE("(%p)->(%p)\n", This, pctinfo);
1800
1801     *pctinfo = 1;
1802
1803     return S_OK;
1804 }
1805
1806 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1807     IVBSAXLocator *iface,
1808     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1809 {
1810     saxlocator *This = impl_from_IVBSAXLocator( iface );
1811     HRESULT hr;
1812
1813     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1814
1815     hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1816
1817     return hr;
1818 }
1819
1820 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1821     IVBSAXLocator *iface,
1822     REFIID riid,
1823     LPOLESTR* rgszNames,
1824     UINT cNames,
1825     LCID lcid,
1826     DISPID* rgDispId)
1827 {
1828     saxlocator *This = impl_from_IVBSAXLocator( iface );
1829     ITypeInfo *typeinfo;
1830     HRESULT hr;
1831
1832     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1833           lcid, rgDispId);
1834
1835     if(!rgszNames || cNames == 0 || !rgDispId)
1836         return E_INVALIDARG;
1837
1838     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1839     if(SUCCEEDED(hr))
1840     {
1841         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1842         ITypeInfo_Release(typeinfo);
1843     }
1844
1845     return hr;
1846 }
1847
1848 static HRESULT WINAPI ivbsaxlocator_Invoke(
1849     IVBSAXLocator *iface,
1850     DISPID dispIdMember,
1851     REFIID riid,
1852     LCID lcid,
1853     WORD wFlags,
1854     DISPPARAMS* pDispParams,
1855     VARIANT* pVarResult,
1856     EXCEPINFO* pExcepInfo,
1857     UINT* puArgErr)
1858 {
1859     saxlocator *This = impl_from_IVBSAXLocator( iface );
1860     ITypeInfo *typeinfo;
1861     HRESULT hr;
1862
1863     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1864           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1865
1866     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1867     if(SUCCEEDED(hr))
1868     {
1869         hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXLocator_iface, dispIdMember, wFlags,
1870                 pDispParams, pVarResult, pExcepInfo, puArgErr);
1871         ITypeInfo_Release(typeinfo);
1872     }
1873
1874     return hr;
1875 }
1876
1877 /*** IVBSAXLocator methods ***/
1878 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1879         IVBSAXLocator* iface,
1880         int *pnColumn)
1881 {
1882     saxlocator *This = impl_from_IVBSAXLocator( iface );
1883     return ISAXLocator_getColumnNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnColumn);
1884 }
1885
1886 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1887         IVBSAXLocator* iface,
1888         int *pnLine)
1889 {
1890     saxlocator *This = impl_from_IVBSAXLocator( iface );
1891     return ISAXLocator_getLineNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnLine);
1892 }
1893
1894 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1895         IVBSAXLocator* iface,
1896         BSTR* publicId)
1897 {
1898     saxlocator *This = impl_from_IVBSAXLocator( iface );
1899     return ISAXLocator_getPublicId((ISAXLocator*)&This->IVBSAXLocator_iface,
1900             (const WCHAR**)publicId);
1901 }
1902
1903 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1904         IVBSAXLocator* iface,
1905         BSTR* systemId)
1906 {
1907     saxlocator *This = impl_from_IVBSAXLocator( iface );
1908     return ISAXLocator_getSystemId((ISAXLocator*)&This->IVBSAXLocator_iface,
1909             (const WCHAR**)systemId);
1910 }
1911
1912 static const struct IVBSAXLocatorVtbl VBSAXLocatorVtbl =
1913 {
1914     ivbsaxlocator_QueryInterface,
1915     ivbsaxlocator_AddRef,
1916     ivbsaxlocator_Release,
1917     ivbsaxlocator_GetTypeInfoCount,
1918     ivbsaxlocator_GetTypeInfo,
1919     ivbsaxlocator_GetIDsOfNames,
1920     ivbsaxlocator_Invoke,
1921     ivbsaxlocator_get_columnNumber,
1922     ivbsaxlocator_get_lineNumber,
1923     ivbsaxlocator_get_publicId,
1924     ivbsaxlocator_get_systemId
1925 };
1926
1927 /*** ISAXLocator interface ***/
1928 /*** IUnknown methods ***/
1929 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1930 {
1931     saxlocator *This = impl_from_ISAXLocator( iface );
1932
1933     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1934
1935     *ppvObject = NULL;
1936
1937     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1938             IsEqualGUID( riid, &IID_ISAXLocator ))
1939     {
1940         *ppvObject = iface;
1941     }
1942     else if ( IsEqualGUID( riid, &IID_ISAXAttributes ))
1943     {
1944         *ppvObject = &This->ISAXAttributes_iface;
1945     }
1946     else
1947     {
1948         WARN("interface %s not implemented\n", debugstr_guid(riid));
1949         return E_NOINTERFACE;
1950     }
1951
1952     ISAXLocator_AddRef( iface );
1953
1954     return S_OK;
1955 }
1956
1957 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1958 {
1959     saxlocator *This = impl_from_ISAXLocator( iface );
1960     ULONG ref = InterlockedIncrement( &This->ref );
1961     TRACE("(%p)->(%d)\n", This, ref);
1962     return ref;
1963 }
1964
1965 static ULONG WINAPI isaxlocator_Release(
1966         ISAXLocator* iface)
1967 {
1968     saxlocator *This = impl_from_ISAXLocator( iface );
1969     LONG ref = InterlockedDecrement( &This->ref );
1970
1971     TRACE("(%p)->(%d)\n", This, ref );
1972
1973     if (ref == 0)
1974     {
1975         element_entry *element, *element2;
1976         int index;
1977
1978         SysFreeString(This->publicId);
1979         SysFreeString(This->systemId);
1980         SysFreeString(This->namespaceUri);
1981
1982         for(index=0; index<This->nb_attributes; index++)
1983         {
1984             SysFreeString(This->attributes[index].szLocalname);
1985             SysFreeString(This->attributes[index].szValue);
1986             SysFreeString(This->attributes[index].szQName);
1987         }
1988         heap_free(This->attributes);
1989
1990         /* element stack */
1991         LIST_FOR_EACH_ENTRY_SAFE(element, element2, &This->elements, element_entry, entry)
1992         {
1993             list_remove(&element->entry);
1994             free_element_entry(element);
1995         }
1996
1997         ISAXXMLReader_Release(&This->saxreader->ISAXXMLReader_iface);
1998         heap_free( This );
1999     }
2000
2001     return ref;
2002 }
2003
2004 /*** ISAXLocator methods ***/
2005 static HRESULT WINAPI isaxlocator_getColumnNumber(
2006         ISAXLocator* iface,
2007         int *pnColumn)
2008 {
2009     saxlocator *This = impl_from_ISAXLocator( iface );
2010
2011     *pnColumn = This->column;
2012     return S_OK;
2013 }
2014
2015 static HRESULT WINAPI isaxlocator_getLineNumber(
2016         ISAXLocator* iface,
2017         int *pnLine)
2018 {
2019     saxlocator *This = impl_from_ISAXLocator( iface );
2020
2021     *pnLine = This->line;
2022     return S_OK;
2023 }
2024
2025 static HRESULT WINAPI isaxlocator_getPublicId(
2026         ISAXLocator* iface,
2027         const WCHAR ** ppwchPublicId)
2028 {
2029     BSTR publicId;
2030     saxlocator *This = impl_from_ISAXLocator( iface );
2031
2032     SysFreeString(This->publicId);
2033
2034     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
2035     if(SysStringLen(publicId))
2036         This->publicId = (WCHAR*)&publicId;
2037     else
2038     {
2039         SysFreeString(publicId);
2040         This->publicId = NULL;
2041     }
2042
2043     *ppwchPublicId = This->publicId;
2044     return S_OK;
2045 }
2046
2047 static HRESULT WINAPI isaxlocator_getSystemId(
2048         ISAXLocator* iface,
2049         const WCHAR ** ppwchSystemId)
2050 {
2051     BSTR systemId;
2052     saxlocator *This = impl_from_ISAXLocator( iface );
2053
2054     SysFreeString(This->systemId);
2055
2056     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
2057     if(SysStringLen(systemId))
2058         This->systemId = (WCHAR*)&systemId;
2059     else
2060     {
2061         SysFreeString(systemId);
2062         This->systemId = NULL;
2063     }
2064
2065     *ppwchSystemId = This->systemId;
2066     return S_OK;
2067 }
2068
2069 static const struct ISAXLocatorVtbl SAXLocatorVtbl =
2070 {
2071     isaxlocator_QueryInterface,
2072     isaxlocator_AddRef,
2073     isaxlocator_Release,
2074     isaxlocator_getColumnNumber,
2075     isaxlocator_getLineNumber,
2076     isaxlocator_getPublicId,
2077     isaxlocator_getSystemId
2078 };
2079
2080 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
2081 {
2082     static const WCHAR w3xmlns[] = { 'h','t','t','p',':','/','/', 'w','w','w','.','w','3','.',
2083         'o','r','g','/','2','0','0','0','/','x','m','l','n','s','/',0 };
2084
2085     saxlocator *locator;
2086
2087     locator = heap_alloc( sizeof (*locator) );
2088     if( !locator )
2089         return E_OUTOFMEMORY;
2090
2091     locator->IVBSAXLocator_iface.lpVtbl = &VBSAXLocatorVtbl;
2092     locator->ISAXLocator_iface.lpVtbl = &SAXLocatorVtbl;
2093     locator->IVBSAXAttributes_iface.lpVtbl = &ivbsaxattributes_vtbl;
2094     locator->ISAXAttributes_iface.lpVtbl = &isaxattributes_vtbl;
2095     locator->ref = 1;
2096     locator->vbInterface = vbInterface;
2097
2098     locator->saxreader = reader;
2099     ISAXXMLReader_AddRef(&reader->ISAXXMLReader_iface);
2100
2101     locator->pParserCtxt = NULL;
2102     locator->publicId = NULL;
2103     locator->systemId = NULL;
2104     locator->line = reader->version < MSXML4 ? 0 : 1;
2105     locator->column = 0;
2106     locator->ret = S_OK;
2107     if (locator->saxreader->version >= MSXML6)
2108         locator->namespaceUri = SysAllocString(w3xmlns);
2109     else
2110         locator->namespaceUri = SysAllocStringLen(NULL, 0);
2111     if(!locator->namespaceUri)
2112     {
2113         ISAXXMLReader_Release(&reader->ISAXXMLReader_iface);
2114         heap_free(locator);
2115         return E_OUTOFMEMORY;
2116     }
2117
2118     locator->attributesSize = 8;
2119     locator->nb_attributes = 0;
2120     locator->attributes = heap_alloc(sizeof(struct _attributes)*locator->attributesSize);
2121     if(!locator->attributes)
2122     {
2123         ISAXXMLReader_Release(&reader->ISAXXMLReader_iface);
2124         SysFreeString(locator->namespaceUri);
2125         heap_free(locator);
2126         return E_OUTOFMEMORY;
2127     }
2128
2129     list_init(&locator->elements);
2130
2131     *ppsaxlocator = locator;
2132
2133     TRACE("returning %p\n", *ppsaxlocator);
2134
2135     return S_OK;
2136 }
2137
2138 /*** SAXXMLReader internal functions ***/
2139 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
2140 {
2141     xmlCharEncoding encoding = XML_CHAR_ENCODING_NONE;
2142     xmlChar *enc_name = NULL;
2143     saxlocator *locator;
2144     HRESULT hr;
2145
2146     hr = SAXLocator_create(This, &locator, vbInterface);
2147     if (FAILED(hr))
2148         return hr;
2149
2150     if (size >= 4)
2151     {
2152         const unsigned char *buff = (unsigned char*)buffer;
2153
2154         encoding = xmlDetectCharEncoding((xmlChar*)buffer, 4);
2155         enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
2156         TRACE("detected encoding: %s\n", enc_name);
2157         /* skip BOM, parser won't switch encodings and so won't skip it on its own */
2158         if ((encoding == XML_CHAR_ENCODING_UTF8) &&
2159             buff[0] == 0xEF && buff[1] == 0xBB && buff[2] == 0xBF)
2160         {
2161             buffer += 3;
2162             size -= 3;
2163         }
2164     }
2165
2166     /* if libxml2 detection failed try to guess */
2167     if (encoding == XML_CHAR_ENCODING_NONE)
2168     {
2169         const WCHAR *ptr = (WCHAR*)buffer;
2170         /* xml declaration with possibly specfied encoding will be still handled by parser */
2171         if ((size >= 2) && *ptr == '<' && ptr[1] != '?')
2172         {
2173             enc_name = (xmlChar*)xmlGetCharEncodingName(XML_CHAR_ENCODING_UTF16LE);
2174             encoding = XML_CHAR_ENCODING_UTF16LE;
2175         }
2176     }
2177     else if (encoding == XML_CHAR_ENCODING_UTF8)
2178         enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
2179     else
2180         enc_name = NULL;
2181
2182     locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
2183     if (!locator->pParserCtxt)
2184     {
2185         ISAXLocator_Release(&locator->ISAXLocator_iface);
2186         return E_FAIL;
2187     }
2188
2189     if (enc_name)
2190     {
2191         locator->pParserCtxt->encoding = xmlStrdup(enc_name);
2192         if (encoding == XML_CHAR_ENCODING_UTF16LE) {
2193             TRACE("switching to %s\n", enc_name);
2194             xmlSwitchEncoding(locator->pParserCtxt, encoding);
2195         }
2196     }
2197
2198     xmlFree(locator->pParserCtxt->sax);
2199     locator->pParserCtxt->sax = &locator->saxreader->sax;
2200     locator->pParserCtxt->userData = locator;
2201
2202     This->isParsing = TRUE;
2203     if(xmlParseDocument(locator->pParserCtxt) == -1 && locator->ret == S_OK)
2204         hr = E_FAIL;
2205     else
2206         hr = locator->ret;
2207     This->isParsing = FALSE;
2208
2209     if(locator->pParserCtxt)
2210     {
2211         locator->pParserCtxt->sax = NULL;
2212         xmlFreeParserCtxt(locator->pParserCtxt);
2213         locator->pParserCtxt = NULL;
2214     }
2215
2216     ISAXLocator_Release(&locator->ISAXLocator_iface);
2217     return hr;
2218 }
2219
2220 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
2221 {
2222     saxlocator *locator;
2223     HRESULT hr;
2224     ULONG dataRead;
2225     char data[1024];
2226     int ret;
2227
2228     dataRead = 0;
2229     hr = IStream_Read(stream, data, sizeof(data), &dataRead);
2230     if(FAILED(hr)) return hr;
2231
2232     hr = SAXLocator_create(This, &locator, vbInterface);
2233     if(FAILED(hr)) return hr;
2234
2235     locator->pParserCtxt = xmlCreatePushParserCtxt(
2236             &locator->saxreader->sax, locator,
2237             data, dataRead, NULL);
2238     if(!locator->pParserCtxt)
2239     {
2240         ISAXLocator_Release(&locator->ISAXLocator_iface);
2241         return E_FAIL;
2242     }
2243
2244     This->isParsing = TRUE;
2245
2246     if(dataRead != sizeof(data))
2247     {
2248         ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
2249         hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2250     }
2251     else
2252     {
2253         while(1)
2254         {
2255             dataRead = 0;
2256             hr = IStream_Read(stream, data, sizeof(data), &dataRead);
2257             if (FAILED(hr)) break;
2258
2259             ret = xmlParseChunk(locator->pParserCtxt, data, dataRead, 0);
2260             hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2261
2262             if (hr != S_OK) break;
2263
2264             if (dataRead != sizeof(data))
2265             {
2266                 ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
2267                 hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2268                 break;
2269             }
2270         }
2271     }
2272
2273     This->isParsing = FALSE;
2274
2275     xmlFreeParserCtxt(locator->pParserCtxt);
2276     locator->pParserCtxt = NULL;
2277     ISAXLocator_Release(&locator->ISAXLocator_iface);
2278     return hr;
2279 }
2280
2281 static HRESULT internal_getEntityResolver(
2282         saxreader *This,
2283         void *pEntityResolver,
2284         BOOL vbInterface)
2285 {
2286     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2287     return E_NOTIMPL;
2288 }
2289
2290 static HRESULT internal_putEntityResolver(
2291         saxreader *This,
2292         void *pEntityResolver,
2293         BOOL vbInterface)
2294 {
2295     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2296     return E_NOTIMPL;
2297 }
2298
2299 static HRESULT internal_getContentHandler(
2300         saxreader* This,
2301         void *pContentHandler,
2302         BOOL vbInterface)
2303 {
2304     TRACE("(%p)->(%p)\n", This, pContentHandler);
2305     if(pContentHandler == NULL)
2306         return E_POINTER;
2307     if((vbInterface && This->vbcontentHandler)
2308             || (!vbInterface && This->contentHandler))
2309     {
2310         if(vbInterface)
2311             IVBSAXContentHandler_AddRef(This->vbcontentHandler);
2312         else
2313             ISAXContentHandler_AddRef(This->contentHandler);
2314     }
2315     if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
2316         This->vbcontentHandler;
2317     else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
2318
2319     return S_OK;
2320 }
2321
2322 static HRESULT internal_putContentHandler(
2323         saxreader* This,
2324         void *contentHandler,
2325         BOOL vbInterface)
2326 {
2327     TRACE("(%p)->(%p)\n", This, contentHandler);
2328     if(contentHandler)
2329     {
2330         if(vbInterface)
2331             IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
2332         else
2333             ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
2334     }
2335     if((vbInterface && This->vbcontentHandler)
2336             || (!vbInterface && This->contentHandler))
2337     {
2338         if(vbInterface)
2339             IVBSAXContentHandler_Release(This->vbcontentHandler);
2340         else
2341             ISAXContentHandler_Release(This->contentHandler);
2342     }
2343     if(vbInterface)
2344         This->vbcontentHandler = contentHandler;
2345     else
2346         This->contentHandler = contentHandler;
2347
2348     return S_OK;
2349 }
2350
2351 static HRESULT internal_getDTDHandler(
2352         saxreader* This,
2353         void *pDTDHandler,
2354         BOOL vbInterface)
2355 {
2356     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2357     return E_NOTIMPL;
2358 }
2359
2360 static HRESULT internal_putDTDHandler(
2361         saxreader* This,
2362         void *pDTDHandler,
2363         BOOL vbInterface)
2364 {
2365     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2366     return E_NOTIMPL;
2367 }
2368
2369 static HRESULT internal_getErrorHandler(
2370         saxreader* This,
2371         void *pErrorHandler,
2372         BOOL vbInterface)
2373 {
2374     TRACE("(%p)->(%p)\n", This, pErrorHandler);
2375     if(pErrorHandler == NULL)
2376         return E_POINTER;
2377
2378     if(vbInterface && This->vberrorHandler)
2379         IVBSAXErrorHandler_AddRef(This->vberrorHandler);
2380     else if(!vbInterface && This->errorHandler)
2381         ISAXErrorHandler_AddRef(This->errorHandler);
2382
2383     if(vbInterface)
2384         *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
2385     else
2386         *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
2387
2388     return S_OK;
2389
2390 }
2391
2392 static HRESULT internal_putErrorHandler(
2393         saxreader* This,
2394         void *errorHandler,
2395         BOOL vbInterface)
2396 {
2397     TRACE("(%p)->(%p)\n", This, errorHandler);
2398     if(errorHandler)
2399     {
2400         if(vbInterface)
2401             IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
2402         else
2403             ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
2404     }
2405
2406     if(vbInterface && This->vberrorHandler)
2407         IVBSAXErrorHandler_Release(This->vberrorHandler);
2408     else if(!vbInterface && This->errorHandler)
2409         ISAXErrorHandler_Release(This->errorHandler);
2410
2411     if(vbInterface)
2412         This->vberrorHandler = errorHandler;
2413     else
2414         This->errorHandler = errorHandler;
2415
2416     return S_OK;
2417
2418 }
2419
2420 static HRESULT internal_parse(
2421         saxreader* This,
2422         VARIANT varInput,
2423         BOOL vbInterface)
2424 {
2425     HRESULT hr;
2426
2427     TRACE("(%p)->(%s)\n", This, debugstr_variant(&varInput));
2428
2429     /* Dispose of the BSTRs in the pool from a prior run, if any. */
2430     free_bstr_pool(&This->pool);
2431
2432     switch(V_VT(&varInput))
2433     {
2434         case VT_BSTR:
2435             hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2436                     SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2437             break;
2438         case VT_ARRAY|VT_UI1: {
2439             void *pSAData;
2440             LONG lBound, uBound;
2441             ULONG dataRead;
2442
2443             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2444             if(hr != S_OK) break;
2445             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2446             if(hr != S_OK) break;
2447             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2448             hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2449             if(hr != S_OK) break;
2450             hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2451             SafeArrayUnaccessData(V_ARRAY(&varInput));
2452             break;
2453         }
2454         case VT_UNKNOWN:
2455         case VT_DISPATCH: {
2456             IPersistStream *persistStream;
2457             IStream *stream = NULL;
2458             IXMLDOMDocument *xmlDoc;
2459
2460             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2461                         &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2462             {
2463                 BSTR bstrData;
2464
2465                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2466                 hr = internal_parseBuffer(This, (const char*)bstrData,
2467                         SysStringByteLen(bstrData), vbInterface);
2468                 IXMLDOMDocument_Release(xmlDoc);
2469                 SysFreeString(bstrData);
2470                 break;
2471             }
2472
2473             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2474                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
2475             {
2476                 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2477                 if(hr != S_OK)
2478                 {
2479                     IPersistStream_Release(persistStream);
2480                     return hr;
2481                 }
2482
2483                 hr = IPersistStream_Save(persistStream, stream, TRUE);
2484                 IPersistStream_Release(persistStream);
2485                 if(hr != S_OK)
2486                 {
2487                     IStream_Release(stream);
2488                     stream = NULL;
2489                 }
2490             }
2491
2492             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2493                         &IID_IStream, (void**)&stream) == S_OK)
2494             {
2495                 hr = internal_parseStream(This, stream, vbInterface);
2496                 IStream_Release(stream);
2497                 break;
2498             }
2499         }
2500         default:
2501             WARN("vt %d not implemented\n", V_VT(&varInput));
2502             hr = E_INVALIDARG;
2503     }
2504
2505     return hr;
2506 }
2507
2508 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2509 {
2510     saxreader *This = obj;
2511
2512     return internal_parseBuffer(This, ptr, len, TRUE);
2513 }
2514
2515 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2516 {
2517     saxreader *This = obj;
2518
2519     return internal_parseBuffer(This, ptr, len, FALSE);
2520 }
2521
2522 static HRESULT internal_parseURL(
2523         saxreader* This,
2524         const WCHAR *url,
2525         BOOL vbInterface)
2526 {
2527     IMoniker *mon;
2528     bsc_t *bsc;
2529     HRESULT hr;
2530
2531     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2532
2533     hr = create_moniker_from_url(url, &mon);
2534     if(FAILED(hr))
2535         return hr;
2536
2537     if(vbInterface) hr = bind_url(mon, internal_vbonDataAvailable, This, &bsc);
2538     else hr = bind_url(mon, internal_onDataAvailable, This, &bsc);
2539     IMoniker_Release(mon);
2540
2541     if(FAILED(hr))
2542         return hr;
2543
2544     return detach_bsc(bsc);
2545 }
2546
2547 static HRESULT internal_putProperty(
2548     saxreader* This,
2549     const WCHAR *prop,
2550     VARIANT value,
2551     BOOL vbInterface)
2552 {
2553     TRACE("(%p)->(%s %s)\n", This, debugstr_w(prop), debugstr_variant(&value));
2554
2555     if(!memcmp(prop, PropertyDeclHandlerW, sizeof(PropertyDeclHandlerW)))
2556     {
2557         if(This->isParsing) return E_FAIL;
2558
2559         switch (V_VT(&value))
2560         {
2561         case VT_EMPTY:
2562             if (vbInterface)
2563             {
2564                 if (This->vbdeclHandler)
2565                 {
2566                     IVBSAXDeclHandler_Release(This->vbdeclHandler);
2567                     This->vbdeclHandler = NULL;
2568                 }
2569             }
2570             else
2571                 if (This->declHandler)
2572                 {
2573                     ISAXDeclHandler_Release(This->declHandler);
2574                     This->declHandler = NULL;
2575                 }
2576             break;
2577         case VT_UNKNOWN:
2578             if ((vbInterface && This->vbdeclHandler) ||
2579                (!vbInterface && This->declHandler))
2580             {
2581                 if (vbInterface)
2582                     IVBSAXDeclHandler_Release(This->vbdeclHandler);
2583                 else
2584                     ISAXDeclHandler_Release(This->declHandler);
2585             }
2586
2587             if (V_UNKNOWN(&value))
2588             {
2589                 return vbInterface ?
2590                     IVBSAXDeclHandler_QueryInterface(V_UNKNOWN(&value), &IID_IVBSAXDeclHandler, (void**)&This->vbdeclHandler) :
2591                     ISAXDeclHandler_QueryInterface(V_UNKNOWN(&value), &IID_ISAXDeclHandler, (void**)&This->declHandler);
2592             }
2593             else
2594             {
2595                 This->vbdeclHandler = NULL;
2596                 This->declHandler = NULL;
2597             }
2598             break;
2599         default:
2600             return E_INVALIDARG;
2601         }
2602
2603         return S_OK;
2604     }
2605
2606     if(!memcmp(prop, PropertyLexicalHandlerW, sizeof(PropertyLexicalHandlerW)))
2607     {
2608         if(This->isParsing) return E_FAIL;
2609
2610         switch (V_VT(&value))
2611         {
2612         case VT_EMPTY:
2613             if (vbInterface)
2614             {
2615                 if (This->vblexicalHandler)
2616                 {
2617                     IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2618                     This->vblexicalHandler = NULL;
2619                 }
2620             }
2621             else
2622                 if (This->lexicalHandler)
2623                 {
2624                     ISAXLexicalHandler_Release(This->lexicalHandler);
2625                     This->lexicalHandler = NULL;
2626                 }
2627             break;
2628         case VT_UNKNOWN:
2629             if ((vbInterface && This->vblexicalHandler) ||
2630                (!vbInterface && This->lexicalHandler))
2631             {
2632                 if (vbInterface)
2633                     IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2634                 else
2635                     ISAXLexicalHandler_Release(This->lexicalHandler);
2636             }
2637
2638             if (V_UNKNOWN(&value))
2639             {
2640                 return vbInterface ?
2641                     IVBSAXLexicalHandler_QueryInterface(V_UNKNOWN(&value), &IID_IVBSAXLexicalHandler, (void**)&This->vblexicalHandler) :
2642                     ISAXLexicalHandler_QueryInterface(V_UNKNOWN(&value), &IID_ISAXLexicalHandler, (void**)&This->lexicalHandler);
2643             }
2644             else
2645             {
2646                 This->vblexicalHandler = NULL;
2647                 This->lexicalHandler = NULL;
2648             }
2649
2650             break;
2651         default:
2652             return E_INVALIDARG;
2653         }
2654
2655         return S_OK;
2656     }
2657
2658     if(!memcmp(prop, PropertyMaxXMLSizeW, sizeof(PropertyMaxXMLSizeW)))
2659     {
2660         if (V_VT(&value) == VT_I4 && V_I4(&value) == 0) return S_OK;
2661         FIXME("(%p)->(%s): max-xml-size unsupported\n", This, debugstr_variant(&value));
2662         return E_NOTIMPL;
2663     }
2664
2665     if(!memcmp(prop, PropertyMaxElementDepthW, sizeof(PropertyMaxElementDepthW)))
2666     {
2667         if (V_VT(&value) == VT_I4 && V_I4(&value) == 0) return S_OK;
2668         FIXME("(%p)->(%s): max-element-depth unsupported\n", This, debugstr_variant(&value));
2669         return E_NOTIMPL;
2670     }
2671
2672     FIXME("(%p)->(%s:%s): unsupported property\n", This, debugstr_w(prop), debugstr_variant(&value));
2673
2674     if(!memcmp(prop, PropertyCharsetW, sizeof(PropertyCharsetW)))
2675         return E_NOTIMPL;
2676
2677     if(!memcmp(prop, PropertyDomNodeW, sizeof(PropertyDomNodeW)))
2678         return E_FAIL;
2679
2680     if(!memcmp(prop, PropertyInputSourceW, sizeof(PropertyInputSourceW)))
2681         return E_NOTIMPL;
2682
2683     if(!memcmp(prop, PropertySchemaDeclHandlerW, sizeof(PropertySchemaDeclHandlerW)))
2684         return E_NOTIMPL;
2685
2686     if(!memcmp(prop, PropertyXMLDeclEncodingW, sizeof(PropertyXMLDeclEncodingW)))
2687         return E_FAIL;
2688
2689     if(!memcmp(prop, PropertyXMLDeclStandaloneW, sizeof(PropertyXMLDeclStandaloneW)))
2690         return E_FAIL;
2691
2692     if(!memcmp(prop, PropertyXMLDeclVersionW, sizeof(PropertyXMLDeclVersionW)))
2693         return E_FAIL;
2694
2695     return E_INVALIDARG;
2696 }
2697
2698 static HRESULT internal_getProperty(const saxreader* This, const WCHAR *prop, VARIANT *value, BOOL vb)
2699 {
2700     TRACE("(%p)->(%s)\n", This, debugstr_w(prop));
2701
2702     if (!value) return E_POINTER;
2703
2704     if (!memcmp(PropertyLexicalHandlerW, prop, sizeof(PropertyLexicalHandlerW)))
2705     {
2706         V_VT(value) = VT_UNKNOWN;
2707         V_UNKNOWN(value) = vb ? (IUnknown*)This->vblexicalHandler : (IUnknown*)This->lexicalHandler;
2708         if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2709         return S_OK;
2710     }
2711
2712     if (!memcmp(PropertyDeclHandlerW, prop, sizeof(PropertyDeclHandlerW)))
2713     {
2714         V_VT(value) = VT_UNKNOWN;
2715         V_UNKNOWN(value) = vb ? (IUnknown*)This->vbdeclHandler : (IUnknown*)This->declHandler;
2716         if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2717         return S_OK;
2718     }
2719
2720     FIXME("(%p)->(%s) unsupported property\n", This, debugstr_w(prop));
2721
2722     return E_NOTIMPL;
2723 }
2724
2725 /*** IVBSAXXMLReader interface ***/
2726 /*** IUnknown methods ***/
2727 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2728 {
2729     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2730
2731     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2732
2733     *ppvObject = NULL;
2734
2735     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2736          IsEqualGUID( riid, &IID_IDispatch ) ||
2737          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2738     {
2739         *ppvObject = iface;
2740     }
2741     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2742     {
2743         *ppvObject = &This->ISAXXMLReader_iface;
2744     }
2745     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
2746     {
2747         return *ppvObject ? S_OK : E_NOINTERFACE;
2748     }
2749     else
2750     {
2751         FIXME("interface %s not implemented\n", debugstr_guid(riid));
2752         return E_NOINTERFACE;
2753     }
2754
2755     IVBSAXXMLReader_AddRef( iface );
2756
2757     return S_OK;
2758 }
2759
2760 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2761 {
2762     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2763     TRACE("%p\n", This );
2764     return InterlockedIncrement( &This->ref );
2765 }
2766
2767 static ULONG WINAPI saxxmlreader_Release(
2768     IVBSAXXMLReader* iface)
2769 {
2770     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2771     LONG ref;
2772
2773     TRACE("%p\n", This );
2774
2775     ref = InterlockedDecrement( &This->ref );
2776     if ( ref == 0 )
2777     {
2778         if(This->contentHandler)
2779             ISAXContentHandler_Release(This->contentHandler);
2780
2781         if(This->vbcontentHandler)
2782             IVBSAXContentHandler_Release(This->vbcontentHandler);
2783
2784         if(This->errorHandler)
2785             ISAXErrorHandler_Release(This->errorHandler);
2786
2787         if(This->vberrorHandler)
2788             IVBSAXErrorHandler_Release(This->vberrorHandler);
2789
2790         if(This->lexicalHandler)
2791             ISAXLexicalHandler_Release(This->lexicalHandler);
2792
2793         if(This->vblexicalHandler)
2794             IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2795
2796         if(This->declHandler)
2797             ISAXDeclHandler_Release(This->declHandler);
2798
2799         if(This->vbdeclHandler)
2800             IVBSAXDeclHandler_Release(This->vbdeclHandler);
2801
2802         free_bstr_pool(&This->pool);
2803
2804         release_dispex(&This->dispex);
2805         heap_free( This );
2806     }
2807
2808     return ref;
2809 }
2810 /*** IDispatch ***/
2811 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2812 {
2813     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2814     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2815 }
2816
2817 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2818     IVBSAXXMLReader *iface,
2819     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2820 {
2821     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2822     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
2823         iTInfo, lcid, ppTInfo);
2824 }
2825
2826 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2827     IVBSAXXMLReader *iface,
2828     REFIID riid,
2829     LPOLESTR* rgszNames,
2830     UINT cNames,
2831     LCID lcid,
2832     DISPID* rgDispId)
2833 {
2834     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2835     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
2836         riid, rgszNames, cNames, lcid, rgDispId);
2837 }
2838
2839 static HRESULT WINAPI saxxmlreader_Invoke(
2840     IVBSAXXMLReader *iface,
2841     DISPID dispIdMember,
2842     REFIID riid,
2843     LCID lcid,
2844     WORD wFlags,
2845     DISPPARAMS* pDispParams,
2846     VARIANT* pVarResult,
2847     EXCEPINFO* pExcepInfo,
2848     UINT* puArgErr)
2849 {
2850     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2851     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
2852         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2853 }
2854
2855 /*** IVBSAXXMLReader methods ***/
2856 static HRESULT WINAPI saxxmlreader_getFeature(
2857     IVBSAXXMLReader* iface,
2858     const WCHAR *feature_name,
2859     VARIANT_BOOL *value)
2860 {
2861     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2862     saxreader_feature feature;
2863
2864     TRACE("(%p)->(%s %p)\n", This, debugstr_w(feature_name), value);
2865
2866     feature = get_saxreader_feature(feature_name);
2867     if (feature == Namespaces || feature == NamespacePrefixes)
2868         return get_feature_value(This, feature, value);
2869
2870     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(feature_name), value);
2871     return E_NOTIMPL;
2872 }
2873
2874 static HRESULT WINAPI saxxmlreader_putFeature(
2875     IVBSAXXMLReader* iface,
2876     const WCHAR *feature_name,
2877     VARIANT_BOOL value)
2878 {
2879     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2880     saxreader_feature feature;
2881
2882     TRACE("(%p)->(%s %x)\n", This, debugstr_w(feature_name), value);
2883
2884     feature = get_saxreader_feature(feature_name);
2885
2886     /* accepted cases */
2887     if ((feature == ExternalGeneralEntities   && value == VARIANT_FALSE) ||
2888         (feature == ExternalParameterEntities && value == VARIANT_FALSE) ||
2889          feature == Namespaces ||
2890          feature == NamespacePrefixes)
2891     {
2892         return set_feature_value(This, feature, value);
2893     }
2894
2895     if (feature == LexicalHandlerParEntities || feature == ProhibitDTD)
2896     {
2897         FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature_name), value);
2898         return set_feature_value(This, feature, value);
2899     }
2900
2901     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature_name), value);
2902     return E_NOTIMPL;
2903 }
2904
2905 static HRESULT WINAPI saxxmlreader_getProperty(
2906     IVBSAXXMLReader* iface,
2907     const WCHAR *prop,
2908     VARIANT *value)
2909 {
2910     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2911     return internal_getProperty(This, prop, value, TRUE);
2912 }
2913
2914 static HRESULT WINAPI saxxmlreader_putProperty(
2915     IVBSAXXMLReader* iface,
2916     const WCHAR *pProp,
2917     VARIANT value)
2918 {
2919     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2920     return internal_putProperty(This, pProp, value, TRUE);
2921 }
2922
2923 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2924     IVBSAXXMLReader* iface,
2925     IVBSAXEntityResolver **pEntityResolver)
2926 {
2927     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2928     return internal_getEntityResolver(This, pEntityResolver, TRUE);
2929 }
2930
2931 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2932     IVBSAXXMLReader* iface,
2933     IVBSAXEntityResolver *pEntityResolver)
2934 {
2935     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2936     return internal_putEntityResolver(This, pEntityResolver, TRUE);
2937 }
2938
2939 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2940     IVBSAXXMLReader* iface,
2941     IVBSAXContentHandler **ppContentHandler)
2942 {
2943     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2944     return internal_getContentHandler(This, ppContentHandler, TRUE);
2945 }
2946
2947 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2948     IVBSAXXMLReader* iface,
2949     IVBSAXContentHandler *contentHandler)
2950 {
2951     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2952     return internal_putContentHandler(This, contentHandler, TRUE);
2953 }
2954
2955 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2956     IVBSAXXMLReader* iface,
2957     IVBSAXDTDHandler **pDTDHandler)
2958 {
2959     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2960     return internal_getDTDHandler(This, pDTDHandler, TRUE);
2961 }
2962
2963 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2964     IVBSAXXMLReader* iface,
2965     IVBSAXDTDHandler *pDTDHandler)
2966 {
2967     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2968     return internal_putDTDHandler(This, pDTDHandler, TRUE);
2969 }
2970
2971 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2972     IVBSAXXMLReader* iface,
2973     IVBSAXErrorHandler **pErrorHandler)
2974 {
2975     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2976     return internal_getErrorHandler(This, pErrorHandler, TRUE);
2977 }
2978
2979 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2980     IVBSAXXMLReader* iface,
2981     IVBSAXErrorHandler *errorHandler)
2982 {
2983     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2984     return internal_putErrorHandler(This, errorHandler, TRUE);
2985 }
2986
2987 static HRESULT WINAPI saxxmlreader_get_baseURL(
2988     IVBSAXXMLReader* iface,
2989     const WCHAR **pBaseUrl)
2990 {
2991     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2992
2993     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2994     return E_NOTIMPL;
2995 }
2996
2997 static HRESULT WINAPI saxxmlreader_put_baseURL(
2998     IVBSAXXMLReader* iface,
2999     const WCHAR *pBaseUrl)
3000 {
3001     saxreader *This = impl_from_IVBSAXXMLReader( iface );
3002
3003     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
3004     return E_NOTIMPL;
3005 }
3006
3007 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
3008     IVBSAXXMLReader* iface,
3009     const WCHAR **pSecureBaseUrl)
3010 {
3011     saxreader *This = impl_from_IVBSAXXMLReader( iface );
3012
3013     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
3014     return E_NOTIMPL;
3015 }
3016
3017
3018 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
3019     IVBSAXXMLReader* iface,
3020     const WCHAR *secureBaseUrl)
3021 {
3022     saxreader *This = impl_from_IVBSAXXMLReader( iface );
3023
3024     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
3025     return E_NOTIMPL;
3026 }
3027
3028 static HRESULT WINAPI saxxmlreader_parse(
3029     IVBSAXXMLReader* iface,
3030     VARIANT varInput)
3031 {
3032     saxreader *This = impl_from_IVBSAXXMLReader( iface );
3033     return internal_parse(This, varInput, TRUE);
3034 }
3035
3036 static HRESULT WINAPI saxxmlreader_parseURL(
3037     IVBSAXXMLReader* iface,
3038     const WCHAR *url)
3039 {
3040     saxreader *This = impl_from_IVBSAXXMLReader( iface );
3041     return internal_parseURL(This, url, TRUE);
3042 }
3043
3044 static const struct IVBSAXXMLReaderVtbl VBSAXXMLReaderVtbl =
3045 {
3046     saxxmlreader_QueryInterface,
3047     saxxmlreader_AddRef,
3048     saxxmlreader_Release,
3049     saxxmlreader_GetTypeInfoCount,
3050     saxxmlreader_GetTypeInfo,
3051     saxxmlreader_GetIDsOfNames,
3052     saxxmlreader_Invoke,
3053     saxxmlreader_getFeature,
3054     saxxmlreader_putFeature,
3055     saxxmlreader_getProperty,
3056     saxxmlreader_putProperty,
3057     saxxmlreader_get_entityResolver,
3058     saxxmlreader_put_entityResolver,
3059     saxxmlreader_get_contentHandler,
3060     saxxmlreader_put_contentHandler,
3061     saxxmlreader_get_dtdHandler,
3062     saxxmlreader_put_dtdHandler,
3063     saxxmlreader_get_errorHandler,
3064     saxxmlreader_put_errorHandler,
3065     saxxmlreader_get_baseURL,
3066     saxxmlreader_put_baseURL,
3067     saxxmlreader_get_secureBaseURL,
3068     saxxmlreader_put_secureBaseURL,
3069     saxxmlreader_parse,
3070     saxxmlreader_parseURL
3071 };
3072
3073 /*** ISAXXMLReader interface ***/
3074 /*** IUnknown methods ***/
3075 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
3076 {
3077     saxreader *This = impl_from_ISAXXMLReader( iface );
3078     return saxxmlreader_QueryInterface(&This->IVBSAXXMLReader_iface, riid, ppvObject);
3079 }
3080
3081 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
3082 {
3083     saxreader *This = impl_from_ISAXXMLReader( iface );
3084     return saxxmlreader_AddRef(&This->IVBSAXXMLReader_iface);
3085 }
3086
3087 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
3088 {
3089     saxreader *This = impl_from_ISAXXMLReader( iface );
3090     return saxxmlreader_Release(&This->IVBSAXXMLReader_iface);
3091 }
3092
3093 /*** ISAXXMLReader methods ***/
3094 static HRESULT WINAPI isaxxmlreader_getFeature(
3095         ISAXXMLReader* iface,
3096         const WCHAR *pFeature,
3097         VARIANT_BOOL *pValue)
3098 {
3099     saxreader *This = impl_from_ISAXXMLReader( iface );
3100     return IVBSAXXMLReader_getFeature(&This->IVBSAXXMLReader_iface, pFeature, pValue);
3101 }
3102
3103 static HRESULT WINAPI isaxxmlreader_putFeature(
3104         ISAXXMLReader* iface,
3105         const WCHAR *pFeature,
3106         VARIANT_BOOL vfValue)
3107 {
3108     saxreader *This = impl_from_ISAXXMLReader( iface );
3109     return IVBSAXXMLReader_putFeature(&This->IVBSAXXMLReader_iface, pFeature, vfValue);
3110 }
3111
3112 static HRESULT WINAPI isaxxmlreader_getProperty(
3113         ISAXXMLReader* iface,
3114         const WCHAR *prop,
3115         VARIANT *value)
3116 {
3117     saxreader *This = impl_from_ISAXXMLReader( iface );
3118     return internal_getProperty(This, prop, value, FALSE);
3119 }
3120
3121 static HRESULT WINAPI isaxxmlreader_putProperty(
3122         ISAXXMLReader* iface,
3123         const WCHAR *pProp,
3124         VARIANT value)
3125 {
3126     saxreader *This = impl_from_ISAXXMLReader( iface );
3127     return internal_putProperty(This, pProp, value, FALSE);
3128 }
3129
3130 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
3131         ISAXXMLReader* iface,
3132         ISAXEntityResolver **ppEntityResolver)
3133 {
3134     saxreader *This = impl_from_ISAXXMLReader( iface );
3135     return internal_getEntityResolver(This, ppEntityResolver, FALSE);
3136 }
3137
3138 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
3139         ISAXXMLReader* iface,
3140         ISAXEntityResolver *pEntityResolver)
3141 {
3142     saxreader *This = impl_from_ISAXXMLReader( iface );
3143     return internal_putEntityResolver(This, pEntityResolver, FALSE);
3144 }
3145
3146 static HRESULT WINAPI isaxxmlreader_getContentHandler(
3147         ISAXXMLReader* iface,
3148         ISAXContentHandler **pContentHandler)
3149 {
3150     saxreader *This = impl_from_ISAXXMLReader( iface );
3151     return internal_getContentHandler(This, pContentHandler, FALSE);
3152 }
3153
3154 static HRESULT WINAPI isaxxmlreader_putContentHandler(
3155         ISAXXMLReader* iface,
3156         ISAXContentHandler *contentHandler)
3157 {
3158     saxreader *This = impl_from_ISAXXMLReader( iface );
3159     return internal_putContentHandler(This, contentHandler, FALSE);
3160 }
3161
3162 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
3163         ISAXXMLReader* iface,
3164         ISAXDTDHandler **pDTDHandler)
3165 {
3166     saxreader *This = impl_from_ISAXXMLReader( iface );
3167     return internal_getDTDHandler(This, pDTDHandler, FALSE);
3168 }
3169
3170 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
3171         ISAXXMLReader* iface,
3172         ISAXDTDHandler *pDTDHandler)
3173 {
3174     saxreader *This = impl_from_ISAXXMLReader( iface );
3175     return internal_putDTDHandler(This, pDTDHandler, FALSE);
3176 }
3177
3178 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
3179         ISAXXMLReader* iface,
3180         ISAXErrorHandler **pErrorHandler)
3181 {
3182     saxreader *This = impl_from_ISAXXMLReader( iface );
3183     return internal_getErrorHandler(This, pErrorHandler, FALSE);
3184 }
3185
3186 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
3187         ISAXXMLReader* iface,
3188         ISAXErrorHandler *errorHandler)
3189 {
3190     saxreader *This = impl_from_ISAXXMLReader( iface );
3191     return internal_putErrorHandler(This, errorHandler, FALSE);
3192 }
3193
3194 static HRESULT WINAPI isaxxmlreader_getBaseURL(
3195         ISAXXMLReader* iface,
3196         const WCHAR **pBaseUrl)
3197 {
3198     saxreader *This = impl_from_ISAXXMLReader( iface );
3199     return IVBSAXXMLReader_get_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
3200 }
3201
3202 static HRESULT WINAPI isaxxmlreader_putBaseURL(
3203         ISAXXMLReader* iface,
3204         const WCHAR *pBaseUrl)
3205 {
3206     saxreader *This = impl_from_ISAXXMLReader( iface );
3207     return IVBSAXXMLReader_put_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
3208 }
3209
3210 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
3211         ISAXXMLReader* iface,
3212         const WCHAR **pSecureBaseUrl)
3213 {
3214     saxreader *This = impl_from_ISAXXMLReader( iface );
3215     return IVBSAXXMLReader_get_secureBaseURL(&This->IVBSAXXMLReader_iface, pSecureBaseUrl);
3216 }
3217
3218 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
3219         ISAXXMLReader* iface,
3220         const WCHAR *secureBaseUrl)
3221 {
3222     saxreader *This = impl_from_ISAXXMLReader( iface );
3223     return IVBSAXXMLReader_put_secureBaseURL(&This->IVBSAXXMLReader_iface, secureBaseUrl);
3224 }
3225
3226 static HRESULT WINAPI isaxxmlreader_parse(
3227         ISAXXMLReader* iface,
3228         VARIANT varInput)
3229 {
3230     saxreader *This = impl_from_ISAXXMLReader( iface );
3231     return internal_parse(This, varInput, FALSE);
3232 }
3233
3234 static HRESULT WINAPI isaxxmlreader_parseURL(
3235         ISAXXMLReader* iface,
3236         const WCHAR *url)
3237 {
3238     saxreader *This = impl_from_ISAXXMLReader( iface );
3239     return internal_parseURL(This, url, FALSE);
3240 }
3241
3242 static const struct ISAXXMLReaderVtbl SAXXMLReaderVtbl =
3243 {
3244     isaxxmlreader_QueryInterface,
3245     isaxxmlreader_AddRef,
3246     isaxxmlreader_Release,
3247     isaxxmlreader_getFeature,
3248     isaxxmlreader_putFeature,
3249     isaxxmlreader_getProperty,
3250     isaxxmlreader_putProperty,
3251     isaxxmlreader_getEntityResolver,
3252     isaxxmlreader_putEntityResolver,
3253     isaxxmlreader_getContentHandler,
3254     isaxxmlreader_putContentHandler,
3255     isaxxmlreader_getDTDHandler,
3256     isaxxmlreader_putDTDHandler,
3257     isaxxmlreader_getErrorHandler,
3258     isaxxmlreader_putErrorHandler,
3259     isaxxmlreader_getBaseURL,
3260     isaxxmlreader_putBaseURL,
3261     isaxxmlreader_getSecureBaseURL,
3262     isaxxmlreader_putSecureBaseURL,
3263     isaxxmlreader_parse,
3264     isaxxmlreader_parseURL
3265 };
3266
3267 static const tid_t saxreader_iface_tids[] = {
3268     IVBSAXXMLReader_tid,
3269     0
3270 };
3271 static dispex_static_data_t saxreader_dispex = {
3272     NULL,
3273     IVBSAXXMLReader_tid,
3274     NULL,
3275     saxreader_iface_tids
3276 };
3277
3278 HRESULT SAXXMLReader_create(MSXML_VERSION version, IUnknown *outer, LPVOID *ppObj)
3279 {
3280     saxreader *reader;
3281
3282     TRACE("(%p, %p)\n", outer, ppObj);
3283
3284     reader = heap_alloc( sizeof (*reader) );
3285     if( !reader )
3286         return E_OUTOFMEMORY;
3287
3288     reader->IVBSAXXMLReader_iface.lpVtbl = &VBSAXXMLReaderVtbl;
3289     reader->ISAXXMLReader_iface.lpVtbl = &SAXXMLReaderVtbl;
3290     reader->ref = 1;
3291     reader->contentHandler = NULL;
3292     reader->vbcontentHandler = NULL;
3293     reader->errorHandler = NULL;
3294     reader->vberrorHandler = NULL;
3295     reader->lexicalHandler = NULL;
3296     reader->vblexicalHandler = NULL;
3297     reader->declHandler = NULL;
3298     reader->vbdeclHandler = NULL;
3299     reader->isParsing = FALSE;
3300     reader->pool.pool = NULL;
3301     reader->pool.index = 0;
3302     reader->pool.len = 0;
3303     reader->features = Namespaces | NamespacePrefixes;
3304     reader->version = version;
3305
3306     init_dispex(&reader->dispex, (IUnknown*)&reader->IVBSAXXMLReader_iface, &saxreader_dispex);
3307
3308     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
3309     reader->sax.initialized = XML_SAX2_MAGIC;
3310     reader->sax.startDocument = libxmlStartDocument;
3311     reader->sax.endDocument = libxmlEndDocument;
3312     reader->sax.startElementNs = libxmlStartElementNS;
3313     reader->sax.endElementNs = libxmlEndElementNS;
3314     reader->sax.characters = libxmlCharacters;
3315     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
3316     reader->sax.comment = libxmlComment;
3317     reader->sax.error = libxmlFatalError;
3318     reader->sax.fatalError = libxmlFatalError;
3319     reader->sax.cdataBlock = libxmlCDataBlock;
3320
3321     *ppObj = &reader->IVBSAXXMLReader_iface;
3322
3323     TRACE("returning iface %p\n", *ppObj);
3324
3325     return S_OK;
3326 }
3327
3328 #else
3329
3330 HRESULT SAXXMLReader_create(MSXML_VERSION version, IUnknown *pUnkOuter, LPVOID *ppObj)
3331 {
3332     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
3333             "libxml2 support was not present at compile time.\n");
3334     return E_NOTIMPL;
3335 }
3336
3337 #endif