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