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