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