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