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