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