?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Implement GdipSetPathGradientLinearBlend.
[wine/multimedia.git] / dlls / msxml3 / saxreader.c
blob913eeaf7952ef769a5bbe537fb1affeac37aced7
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 i;
1164
1165 /* skip namespace definitions */
1166 if ((locator->saxreader->features & NamespacePrefixes) == 0)
1167 nb_namespaces = 0;
1168
1169 locator->nb_attributes = nb_namespaces + nb_attributes;
1170 if(locator->nb_attributes > locator->attributesSize)
1171 {
1172 attrs = heap_realloc(locator->attributes, sizeof(struct _attributes)*locator->nb_attributes*2);
1173 if(!attrs)
1174 {
1175 locator->nb_attributes = 0;
1176 return E_OUTOFMEMORY;
1177 }
1178 locator->attributes = attrs;
1179 }
1180 else
1181 {
1182 attrs = locator->attributes;
1183 }
1184
1185 for (i = 0; i < nb_namespaces; i++)
1186 {
1187 attrs[nb_attributes+i].szLocalname = SysAllocStringLen(NULL, 0);
1188 attrs[nb_attributes+i].szURI = locator->namespaceUri;
1189 attrs[nb_attributes+i].szValue = bstr_from_xmlChar(xmlNamespaces[2*i+1]);
1190 if(!xmlNamespaces[2*i])
1191 attrs[nb_attributes+i].szQName = SysAllocString(xmlnsW);
1192 else
1193 attrs[nb_attributes+i].szQName = QName_from_xmlChar(xmlns, xmlNamespaces[2*i]);
1194 }
1195
1196 for (i = 0; i < nb_attributes; i++)
1197 {
1198 static const xmlChar xmlA[] = "xml";
1199
1200 if (xmlStrEqual(xmlAttributes[i*5+1], xmlA))
1201 attrs[i].szURI = bstr_from_xmlChar(xmlAttributes[i*5+2]);
1202 else
1203 attrs[i].szURI = find_element_uri(locator, xmlAttributes[i*5+2]);
1204
1205 attrs[i].szLocalname = bstr_from_xmlChar(xmlAttributes[i*5]);
1206 attrs[i].szValue = bstr_from_xmlCharN(xmlAttributes[i*5+3],
1207 xmlAttributes[i*5+4]-xmlAttributes[i*5+3]);
1208 attrs[i].szQName = QName_from_xmlChar(xmlAttributes[i*5+1],
1209 xmlAttributes[i*5]);
1210 }
1211
1212 return S_OK;
1213 }
1214
1215 /*** LibXML callbacks ***/
1216 static void libxmlStartDocument(void *ctx)
1217 {
1218 saxlocator *This = ctx;
1219 HRESULT hr;
1220
1221 if (This->saxreader->version >= MSXML4)
1222 {
1223 const xmlChar *p = This->pParserCtxt->input->cur-1;
1224 update_position(This, FALSE);
1225 while(p>This->pParserCtxt->input->base && *p!='>')
1226 {
1227 if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1228 This->line--;
1229 p--;
1230 }
1231 This->column = 0;
1232 for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1233 This->column++;
1234 }
1235
1236 if(has_content_handler(This))
1237 {
1238 if(This->vbInterface)
1239 hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
1240 else
1241 hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
1242
1243 if (sax_callback_failed(This, hr))
1244 format_error_message_from_id(This, hr);
1245 }
1246 }
1247
1248 static void libxmlEndDocument(void *ctx)
1249 {
1250 saxlocator *This = ctx;
1251 HRESULT hr;
1252
1253 if (This->saxreader->version >= MSXML4) {
1254 update_position(This, FALSE);
1255 if(This->column > 1)
1256 This->line++;
1257 This->column = 0;
1258 } else {
1259 This->column = 0;
1260 This->line = 0;
1261 }
1262
1263 if(This->ret != S_OK) return;
1264
1265 if(has_content_handler(This))
1266 {
1267 if(This->vbInterface)
1268 hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1269 else
1270 hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1271
1272 if (sax_callback_failed(This, hr))
1273 format_error_message_from_id(This, hr);
1274 }
1275 }
1276
1277 static void libxmlStartElementNS(
1278 void *ctx,
1279 const xmlChar *localname,
1280 const xmlChar *prefix,
1281 const xmlChar *URI,
1282 int nb_namespaces,
1283 const xmlChar **namespaces,
1284 int nb_attributes,
1285 int nb_defaulted,
1286 const xmlChar **attributes)
1287 {
1288 saxlocator *This = ctx;
1289 element_entry *element;
1290 HRESULT hr = S_OK;
1291
1292 update_position(This, TRUE);
1293 if(*(This->pParserCtxt->input->cur) == '/')
1294 This->column++;
1295 if(This->saxreader->version < MSXML4)
1296 This->column++;
1297
1298 element = alloc_element_entry(localname, prefix, nb_namespaces, namespaces);
1299 push_element_ns(This, element);
1300
1301 if (has_content_handler(This))
1302 {
1303 BSTR uri;
1304
1305 if (is_namespaces_enabled(This->saxreader))
1306 {
1307 int i;
1308
1309 for (i = 0; i < nb_namespaces; i++)
1310 {
1311 if (This->vbInterface)
1312 hr = IVBSAXContentHandler_startPrefixMapping(
1313 This->saxreader->vbcontentHandler,
1314 &element->ns[i].prefix,
1315 &element->ns[i].uri);
1316 else
1317 hr = ISAXContentHandler_startPrefixMapping(
1318 This->saxreader->contentHandler,
1319 element->ns[i].prefix,
1320 SysStringLen(element->ns[i].prefix),
1321 element->ns[i].uri,
1322 SysStringLen(element->ns[i].uri));
1323
1324 if (sax_callback_failed(This, hr))
1325 {
1326 format_error_message_from_id(This, hr);
1327 return;
1328 }
1329 }
1330 }
1331
1332 uri = find_element_uri(This, URI);
1333
1334 hr = SAXAttributes_populate(This, nb_namespaces, namespaces, nb_attributes, attributes);
1335 if (hr == S_OK)
1336 {
1337 BSTR local;
1338
1339 if (is_namespaces_enabled(This->saxreader))
1340 local = element->local;
1341 else
1342 uri = local = NULL;
1343
1344 if (This->vbInterface)
1345 hr = IVBSAXContentHandler_startElement(This->saxreader->vbcontentHandler,
1346 &uri, &local, &element->qname, &This->IVBSAXAttributes_iface);
1347 else
1348 hr = ISAXContentHandler_startElement(This->saxreader->contentHandler,
1349 uri, SysStringLen(uri),
1350 local, SysStringLen(local),
1351 element->qname, SysStringLen(element->qname),
1352 &This->ISAXAttributes_iface);
1353 }
1354 }
1355
1356 if (sax_callback_failed(This, hr))
1357 format_error_message_from_id(This, hr);
1358 }
1359
1360 static void libxmlEndElementNS(
1361 void *ctx,
1362 const xmlChar *localname,
1363 const xmlChar *prefix,
1364 const xmlChar *URI)
1365 {
1366 saxlocator *This = ctx;
1367 element_entry *element;
1368 const xmlChar *p;
1369 BSTR uri, local;
1370 HRESULT hr;
1371
1372 update_position(This, FALSE);
1373 p = This->pParserCtxt->input->cur;
1374
1375 if (This->saxreader->version >= MSXML4)
1376 {
1377 p--;
1378 while(p>This->pParserCtxt->input->base && *p!='>')
1379 {
1380 if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1381 This->line--;
1382 p--;
1383 }
1384 }
1385 else if(*(p-1)!='>' || *(p-2)!='/')
1386 {
1387 p--;
1388 while(p-2>=This->pParserCtxt->input->base
1389 && *(p-2)!='<' && *(p-1)!='/')
1390 {
1391 if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1392 This->line--;
1393 p--;
1394 }
1395 }
1396 This->column = 0;
1397 for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1398 This->column++;
1399
1400 uri = find_element_uri(This, URI);
1401 element = pop_element_ns(This);
1402
1403 if (!has_content_handler(This))
1404 {
1405 This->nb_attributes = 0;
1406 free_element_entry(element);
1407 return;
1408 }
1409
1410 if (is_namespaces_enabled(This->saxreader))
1411 local = element->local;
1412 else
1413 uri = local = NULL;
1414
1415 if (This->vbInterface)
1416 hr = IVBSAXContentHandler_endElement(
1417 This->saxreader->vbcontentHandler,
1418 &uri, &local, &element->qname);
1419 else
1420 hr = ISAXContentHandler_endElement(
1421 This->saxreader->contentHandler,
1422 uri, SysStringLen(uri),
1423 local, SysStringLen(local),
1424 element->qname, SysStringLen(element->qname));
1425
1426 This->nb_attributes = 0;
1427
1428 if (sax_callback_failed(This, hr))
1429 {
1430 format_error_message_from_id(This, hr);
1431 free_element_entry(element);
1432 return;
1433 }
1434
1435 if (is_namespaces_enabled(This->saxreader))
1436 {
1437 int i = -1;
1438 while (iterate_endprefix_index(This, element, &i))
1439 {
1440 if (This->vbInterface)
1441 hr = IVBSAXContentHandler_endPrefixMapping(
1442 This->saxreader->vbcontentHandler, &element->ns[i].prefix);
1443 else
1444 hr = ISAXContentHandler_endPrefixMapping(
1445 This->saxreader->contentHandler,
1446 element->ns[i].prefix, SysStringLen(element->ns[i].prefix));
1447
1448 if (sax_callback_failed(This, hr)) break;
1449 }
1450 }
1451
1452 if (sax_callback_failed(This, hr))
1453 format_error_message_from_id(This, hr);
1454
1455 free_element_entry(element);
1456 }
1457
1458 static void libxmlCharacters(
1459 void *ctx,
1460 const xmlChar *ch,
1461 int len)
1462 {
1463 saxlocator *This = ctx;
1464 BSTR Chars;
1465 HRESULT hr;
1466 xmlChar *cur, *end;
1467 BOOL lastEvent = FALSE;
1468
1469 if(!(has_content_handler(This))) return;
1470
1471 update_position(This, FALSE);
1472 cur = (xmlChar*)This->pParserCtxt->input->cur;
1473 while(cur>=This->pParserCtxt->input->base && *cur!='>')
1474 {
1475 if(*cur=='\n' || (*cur=='\r' && *(cur+1)!='\n'))
1476 This->line--;
1477 cur--;
1478 }
1479 This->column = 1;
1480 for(; cur>=This->pParserCtxt->input->base && *cur!='\n' && *cur!='\r'; cur--)
1481 This->column++;
1482
1483 cur = (xmlChar*)ch;
1484 if(*(ch-1)=='\r') cur--;
1485 end = cur;
1486
1487 while(1)
1488 {
1489 while(end-ch<len && *end!='\r') end++;
1490 if(end-ch==len)
1491 {
1492 lastEvent = TRUE;
1493 }
1494 else
1495 {
1496 *end = '\n';
1497 end++;
1498 }
1499
1500 if (This->saxreader->version >= MSXML4)
1501 {
1502 xmlChar *p;
1503
1504 for(p=cur; p!=end; p++)
1505 {
1506 if(*p=='\n')
1507 {
1508 This->line++;
1509 This->column = 1;
1510 }
1511 else
1512 {
1513 This->column++;
1514 }
1515 }
1516
1517 if(!lastEvent)
1518 This->column = 0;
1519 }
1520
1521 Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur);
1522 if(This->vbInterface)
1523 hr = IVBSAXContentHandler_characters(
1524 This->saxreader->vbcontentHandler, &Chars);
1525 else
1526 hr = ISAXContentHandler_characters(
1527 This->saxreader->contentHandler,
1528 Chars, SysStringLen(Chars));
1529
1530 if (sax_callback_failed(This, hr))
1531 {
1532 format_error_message_from_id(This, hr);
1533 return;
1534 }
1535
1536 if (This->saxreader->version < MSXML4)
1537 This->column += end-cur;
1538
1539 if(lastEvent)
1540 break;
1541
1542 *(end-1) = '\r';
1543 if(*end == '\n')
1544 {
1545 end++;
1546 This->column++;
1547 }
1548 cur = end;
1549
1550 if(end-ch == len) break;
1551 }
1552 }
1553
1554 static void libxmlSetDocumentLocator(
1555 void *ctx,
1556 xmlSAXLocatorPtr loc)
1557 {
1558 saxlocator *This = ctx;
1559 HRESULT hr = S_OK;
1560
1561 if(has_content_handler(This))
1562 {
1563 if(This->vbInterface)
1564 hr = IVBSAXContentHandler_putref_documentLocator(This->saxreader->vbcontentHandler,
1565 &This->IVBSAXLocator_iface);
1566 else
1567 hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
1568 &This->ISAXLocator_iface);
1569 }
1570
1571 if(FAILED(hr))
1572 format_error_message_from_id(This, hr);
1573 }
1574
1575 static void libxmlComment(void *ctx, const xmlChar *value)
1576 {
1577 saxlocator *This = ctx;
1578 BSTR bValue;
1579 HRESULT hr;
1580 const xmlChar *p = This->pParserCtxt->input->cur;
1581
1582 update_position(This, FALSE);
1583 while(p-4>=This->pParserCtxt->input->base
1584 && memcmp(p-4, "<!--", sizeof(char[4])))
1585 {
1586 if(*p=='\n' || (*p=='\r' && *(p+1)!='\n'))
1587 This->line--;
1588 p--;
1589 }
1590 This->column = 0;
1591 for(; p>=This->pParserCtxt->input->base && *p!='\n' && *p!='\r'; p--)
1592 This->column++;
1593
1594 if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1595 if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1596
1597 bValue = pooled_bstr_from_xmlChar(&This->saxreader->pool, value);
1598
1599 if(This->vbInterface)
1600 hr = IVBSAXLexicalHandler_comment(
1601 This->saxreader->vblexicalHandler, &bValue);
1602 else
1603 hr = ISAXLexicalHandler_comment(
1604 This->saxreader->lexicalHandler,
1605 bValue, SysStringLen(bValue));
1606
1607 if(FAILED(hr))
1608 format_error_message_from_id(This, hr);
1609 }
1610
1611 static void libxmlFatalError(void *ctx, const char *msg, ...)
1612 {
1613 saxlocator *This = ctx;
1614 char message[1024];
1615 WCHAR *error;
1616 DWORD len;
1617 va_list args;
1618
1619 if(This->ret != S_OK) {
1620 xmlStopParser(This->pParserCtxt);
1621 return;
1622 }
1623
1624 va_start(args, msg);
1625 vsprintf(message, msg, args);
1626 va_end(args);
1627
1628 len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1629 error = heap_alloc(sizeof(WCHAR)*len);
1630 if(error)
1631 {
1632 MultiByteToWideChar(CP_UNIXCP, 0, message, -1, error, len);
1633 TRACE("fatal error for %p: %s\n", This, debugstr_w(error));
1634 }
1635
1636 if(!has_error_handler(This))
1637 {
1638 xmlStopParser(This->pParserCtxt);
1639 This->ret = E_FAIL;
1640 heap_free(error);
1641 return;
1642 }
1643
1644 FIXME("Error handling is not compatible.\n");
1645
1646 if(This->vbInterface)
1647 {
1648 BSTR bstrError = SysAllocString(error);
1649 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler, &This->IVBSAXLocator_iface,
1650 &bstrError, E_FAIL);
1651 SysFreeString(bstrError);
1652 }
1653 else
1654 ISAXErrorHandler_fatalError(This->saxreader->errorHandler, &This->ISAXLocator_iface,
1655 error, E_FAIL);
1656
1657 heap_free(error);
1658
1659 xmlStopParser(This->pParserCtxt);
1660 This->ret = E_FAIL;
1661 }
1662
1663 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1664 {
1665 saxlocator *This = ctx;
1666 HRESULT hr = S_OK;
1667 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1668 xmlChar *cur, *end;
1669 int realLen;
1670 BSTR Chars;
1671 BOOL lastEvent = FALSE, change;
1672
1673 update_position(This, FALSE);
1674 while(beg-9>=This->pParserCtxt->input->base
1675 && memcmp(beg-9, "<![CDATA[", sizeof(char[9])))
1676 {
1677 if(*beg=='\n' || (*beg=='\r' && *(beg+1)!='\n'))
1678 This->line--;
1679 beg--;
1680 }
1681 This->column = 0;
1682 for(; beg>=This->pParserCtxt->input->base && *beg!='\n' && *beg!='\r'; beg--)
1683 This->column++;
1684
1685 if(This->vbInterface && This->saxreader->vblexicalHandler)
1686 hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1687 if(!This->vbInterface && This->saxreader->lexicalHandler)
1688 hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1689
1690 if(FAILED(hr))
1691 {
1692 format_error_message_from_id(This, hr);
1693 return;
1694 }
1695
1696 realLen = This->pParserCtxt->input->cur-beg-3;
1697 cur = beg;
1698 end = beg;
1699
1700 while(1)
1701 {
1702 while(end-beg<realLen && *end!='\r') end++;
1703 if(end-beg==realLen)
1704 {
1705 end--;
1706 lastEvent = TRUE;
1707 }
1708 else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1709 lastEvent = TRUE;
1710
1711 if(*end == '\r') change = TRUE;
1712 else change = FALSE;
1713
1714 if(change) *end = '\n';
1715
1716 if(has_content_handler(This))
1717 {
1718 Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur+1);
1719 if(This->vbInterface)
1720 hr = IVBSAXContentHandler_characters(
1721 This->saxreader->vbcontentHandler, &Chars);
1722 else
1723 hr = ISAXContentHandler_characters(
1724 This->saxreader->contentHandler,
1725 Chars, SysStringLen(Chars));
1726 }
1727
1728 if(change) *end = '\r';
1729
1730 if(lastEvent)
1731 break;
1732
1733 This->column += end-cur+2;
1734 end += 2;
1735 cur = end;
1736 }
1737
1738 if(This->vbInterface && This->saxreader->vblexicalHandler)
1739 hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1740 if(!This->vbInterface && This->saxreader->lexicalHandler)
1741 hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1742
1743 if(FAILED(hr))
1744 format_error_message_from_id(This, hr);
1745
1746 This->column += 4+end-cur;
1747 }
1748
1749 /*** IVBSAXLocator interface ***/
1750 /*** IUnknown methods ***/
1751 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1752 {
1753 saxlocator *This = impl_from_IVBSAXLocator( iface );
1754
1755 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1756
1757 *ppvObject = NULL;
1758
1759 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1760 IsEqualGUID( riid, &IID_IDispatch) ||
1761 IsEqualGUID( riid, &IID_IVBSAXLocator ))
1762 {
1763 *ppvObject = iface;
1764 }
1765 else if ( IsEqualGUID( riid, &IID_IVBSAXAttributes ))
1766 {
1767 *ppvObject = &This->IVBSAXAttributes_iface;
1768 }
1769 else
1770 {
1771 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1772 return E_NOINTERFACE;
1773 }
1774
1775 IVBSAXLocator_AddRef( iface );
1776
1777 return S_OK;
1778 }
1779
1780 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1781 {
1782 saxlocator *This = impl_from_IVBSAXLocator( iface );
1783 TRACE("%p\n", This );
1784 return InterlockedIncrement( &This->ref );
1785 }
1786
1787 static ULONG WINAPI ivbsaxlocator_Release(
1788 IVBSAXLocator* iface)
1789 {
1790 saxlocator *This = impl_from_IVBSAXLocator( iface );
1791 return ISAXLocator_Release((ISAXLocator*)&This->IVBSAXLocator_iface);
1792 }
1793
1794 /*** IDispatch methods ***/
1795 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1796 {
1797 saxlocator *This = impl_from_IVBSAXLocator( iface );
1798
1799 TRACE("(%p)->(%p)\n", This, pctinfo);
1800
1801 *pctinfo = 1;
1802
1803 return S_OK;
1804 }
1805
1806 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1807 IVBSAXLocator *iface,
1808 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1809 {
1810 saxlocator *This = impl_from_IVBSAXLocator( iface );
1811 HRESULT hr;
1812
1813 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1814
1815 hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1816
1817 return hr;
1818 }
1819
1820 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1821 IVBSAXLocator *iface,
1822 REFIID riid,
1823 LPOLESTR* rgszNames,
1824 UINT cNames,
1825 LCID lcid,
1826 DISPID* rgDispId)
1827 {
1828 saxlocator *This = impl_from_IVBSAXLocator( iface );
1829 ITypeInfo *typeinfo;
1830 HRESULT hr;
1831
1832 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1833 lcid, rgDispId);
1834
1835 if(!rgszNames || cNames == 0 || !rgDispId)
1836 return E_INVALIDARG;
1837
1838 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1839 if(SUCCEEDED(hr))
1840 {
1841 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1842 ITypeInfo_Release(typeinfo);
1843 }
1844
1845 return hr;
1846 }
1847
1848 static HRESULT WINAPI ivbsaxlocator_Invoke(
1849 IVBSAXLocator *iface,
1850 DISPID dispIdMember,
1851 REFIID riid,
1852 LCID lcid,
1853 WORD wFlags,
1854 DISPPARAMS* pDispParams,
1855 VARIANT* pVarResult,
1856 EXCEPINFO* pExcepInfo,
1857 UINT* puArgErr)
1858 {
1859 saxlocator *This = impl_from_IVBSAXLocator( iface );
1860 ITypeInfo *typeinfo;
1861 HRESULT hr;
1862
1863 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1864 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1865
1866 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1867 if(SUCCEEDED(hr))
1868 {
1869 hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXLocator_iface, dispIdMember, wFlags,
1870 pDispParams, pVarResult, pExcepInfo, puArgErr);
1871 ITypeInfo_Release(typeinfo);
1872 }
1873
1874 return hr;
1875 }
1876
1877 /*** IVBSAXLocator methods ***/
1878 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1879 IVBSAXLocator* iface,
1880 int *pnColumn)
1881 {
1882 saxlocator *This = impl_from_IVBSAXLocator( iface );
1883 return ISAXLocator_getColumnNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnColumn);
1884 }
1885
1886 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1887 IVBSAXLocator* iface,
1888 int *pnLine)
1889 {
1890 saxlocator *This = impl_from_IVBSAXLocator( iface );
1891 return ISAXLocator_getLineNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnLine);
1892 }
1893
1894 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1895 IVBSAXLocator* iface,
1896 BSTR* publicId)
1897 {
1898 saxlocator *This = impl_from_IVBSAXLocator( iface );
1899 return ISAXLocator_getPublicId((ISAXLocator*)&This->IVBSAXLocator_iface,
1900 (const WCHAR**)publicId);
1901 }
1902
1903 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1904 IVBSAXLocator* iface,
1905 BSTR* systemId)
1906 {
1907 saxlocator *This = impl_from_IVBSAXLocator( iface );
1908 return ISAXLocator_getSystemId((ISAXLocator*)&This->IVBSAXLocator_iface,
1909 (const WCHAR**)systemId);
1910 }
1911
1912 static const struct IVBSAXLocatorVtbl VBSAXLocatorVtbl =
1913 {
1914 ivbsaxlocator_QueryInterface,
1915 ivbsaxlocator_AddRef,
1916 ivbsaxlocator_Release,
1917 ivbsaxlocator_GetTypeInfoCount,
1918 ivbsaxlocator_GetTypeInfo,
1919 ivbsaxlocator_GetIDsOfNames,
1920 ivbsaxlocator_Invoke,
1921 ivbsaxlocator_get_columnNumber,
1922 ivbsaxlocator_get_lineNumber,
1923 ivbsaxlocator_get_publicId,
1924 ivbsaxlocator_get_systemId
1925 };
1926
1927 /*** ISAXLocator interface ***/
1928 /*** IUnknown methods ***/
1929 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1930 {
1931 saxlocator *This = impl_from_ISAXLocator( iface );
1932
1933 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1934
1935 *ppvObject = NULL;
1936
1937 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1938 IsEqualGUID( riid, &IID_ISAXLocator ))
1939 {
1940 *ppvObject = iface;
1941 }
1942 else if ( IsEqualGUID( riid, &IID_ISAXAttributes ))
1943 {
1944 *ppvObject = &This->ISAXAttributes_iface;
1945 }
1946 else
1947 {
1948 WARN("interface %s not implemented\n", debugstr_guid(riid));
1949 return E_NOINTERFACE;
1950 }
1951
1952 ISAXLocator_AddRef( iface );
1953
1954 return S_OK;
1955 }
1956
1957 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1958 {
1959 saxlocator *This = impl_from_ISAXLocator( iface );
1960 ULONG ref = InterlockedIncrement( &This->ref );
1961 TRACE("(%p)->(%d)\n", This, ref);
1962 return ref;
1963 }
1964
1965 static ULONG WINAPI isaxlocator_Release(
1966 ISAXLocator* iface)
1967 {
1968 saxlocator *This = impl_from_ISAXLocator( iface );
1969 LONG ref = InterlockedDecrement( &This->ref );
1970
1971 TRACE("(%p)->(%d)\n", This, ref );
1972
1973 if (ref == 0)
1974 {
1975 element_entry *element, *element2;
1976 int index;
1977
1978 SysFreeString(This->publicId);
1979 SysFreeString(This->systemId);
1980 SysFreeString(This->namespaceUri);
1981
1982 for(index=0; index<This->nb_attributes; index++)
1983 {
1984 SysFreeString(This->attributes[index].szLocalname);
1985 SysFreeString(This->attributes[index].szValue);
1986 SysFreeString(This->attributes[index].szQName);
1987 }
1988 heap_free(This->attributes);
1989
1990 /* element stack */
1991 LIST_FOR_EACH_ENTRY_SAFE(element, element2, &This->elements, element_entry, entry)
1992 {
1993 list_remove(&element->entry);
1994 free_element_entry(element);
1995 }
1996
1997 ISAXXMLReader_Release(&This->saxreader->ISAXXMLReader_iface);
1998 heap_free( This );
1999 }
2000
2001 return ref;
2002 }
2003
2004 /*** ISAXLocator methods ***/
2005 static HRESULT WINAPI isaxlocator_getColumnNumber(
2006 ISAXLocator* iface,
2007 int *pnColumn)
2008 {
2009 saxlocator *This = impl_from_ISAXLocator( iface );
2010
2011 *pnColumn = This->column;
2012 return S_OK;
2013 }
2014
2015 static HRESULT WINAPI isaxlocator_getLineNumber(
2016 ISAXLocator* iface,
2017 int *pnLine)
2018 {
2019 saxlocator *This = impl_from_ISAXLocator( iface );
2020
2021 *pnLine = This->line;
2022 return S_OK;
2023 }
2024
2025 static HRESULT WINAPI isaxlocator_getPublicId(
2026 ISAXLocator* iface,
2027 const WCHAR ** ppwchPublicId)
2028 {
2029 BSTR publicId;
2030 saxlocator *This = impl_from_ISAXLocator( iface );
2031
2032 SysFreeString(This->publicId);
2033
2034 publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
2035 if(SysStringLen(publicId))
2036 This->publicId = (WCHAR*)&publicId;
2037 else
2038 {
2039 SysFreeString(publicId);
2040 This->publicId = NULL;
2041 }
2042
2043 *ppwchPublicId = This->publicId;
2044 return S_OK;
2045 }
2046
2047 static HRESULT WINAPI isaxlocator_getSystemId(
2048 ISAXLocator* iface,
2049 const WCHAR ** ppwchSystemId)
2050 {
2051 BSTR systemId;
2052 saxlocator *This = impl_from_ISAXLocator( iface );
2053
2054 SysFreeString(This->systemId);
2055
2056 systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
2057 if(SysStringLen(systemId))
2058 This->systemId = (WCHAR*)&systemId;
2059 else
2060 {
2061 SysFreeString(systemId);
2062 This->systemId = NULL;
2063 }
2064
2065 *ppwchSystemId = This->systemId;
2066 return S_OK;
2067 }
2068
2069 static const struct ISAXLocatorVtbl SAXLocatorVtbl =
2070 {
2071 isaxlocator_QueryInterface,
2072 isaxlocator_AddRef,
2073 isaxlocator_Release,
2074 isaxlocator_getColumnNumber,
2075 isaxlocator_getLineNumber,
2076 isaxlocator_getPublicId,
2077 isaxlocator_getSystemId
2078 };
2079
2080 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
2081 {
2082 static const WCHAR w3xmlns[] = { 'h','t','t','p',':','/','/', 'w','w','w','.','w','3','.',
2083 'o','r','g','/','2','0','0','0','/','x','m','l','n','s','/',0 };
2084
2085 saxlocator *locator;
2086
2087 locator = heap_alloc( sizeof (*locator) );
2088 if( !locator )
2089 return E_OUTOFMEMORY;
2090
2091 locator->IVBSAXLocator_iface.lpVtbl = &VBSAXLocatorVtbl;
2092 locator->ISAXLocator_iface.lpVtbl = &SAXLocatorVtbl;
2093 locator->IVBSAXAttributes_iface.lpVtbl = &ivbsaxattributes_vtbl;
2094 locator->ISAXAttributes_iface.lpVtbl = &isaxattributes_vtbl;
2095 locator->ref = 1;
2096 locator->vbInterface = vbInterface;
2097
2098 locator->saxreader = reader;
2099 ISAXXMLReader_AddRef(&reader->ISAXXMLReader_iface);
2100
2101 locator->pParserCtxt = NULL;
2102 locator->publicId = NULL;
2103 locator->systemId = NULL;
2104 locator->line = reader->version < MSXML4 ? 0 : 1;
2105 locator->column = 0;
2106 locator->ret = S_OK;
2107 if (locator->saxreader->version >= MSXML6)
2108 locator->namespaceUri = SysAllocString(w3xmlns);
2109 else
2110 locator->namespaceUri = SysAllocStringLen(NULL, 0);
2111 if(!locator->namespaceUri)
2112 {
2113 ISAXXMLReader_Release(&reader->ISAXXMLReader_iface);
2114 heap_free(locator);
2115 return E_OUTOFMEMORY;
2116 }
2117
2118 locator->attributesSize = 8;
2119 locator->nb_attributes = 0;
2120 locator->attributes = heap_alloc(sizeof(struct _attributes)*locator->attributesSize);
2121 if(!locator->attributes)
2122 {
2123 ISAXXMLReader_Release(&reader->ISAXXMLReader_iface);
2124 SysFreeString(locator->namespaceUri);
2125 heap_free(locator);
2126 return E_OUTOFMEMORY;
2127 }
2128
2129 list_init(&locator->elements);
2130
2131 *ppsaxlocator = locator;
2132
2133 TRACE("returning %p\n", *ppsaxlocator);
2134
2135 return S_OK;
2136 }
2137
2138 /*** SAXXMLReader internal functions ***/
2139 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
2140 {
2141 xmlCharEncoding encoding = XML_CHAR_ENCODING_NONE;
2142 xmlChar *enc_name = NULL;
2143 saxlocator *locator;
2144 HRESULT hr;
2145
2146 hr = SAXLocator_create(This, &locator, vbInterface);
2147 if (FAILED(hr))
2148 return hr;
2149
2150 if (size >= 4)
2151 {
2152 const unsigned char *buff = (unsigned char*)buffer;
2153
2154 encoding = xmlDetectCharEncoding((xmlChar*)buffer, 4);
2155 enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
2156 TRACE("detected encoding: %s\n", enc_name);
2157 /* skip BOM, parser won't switch encodings and so won't skip it on its own */
2158 if ((encoding == XML_CHAR_ENCODING_UTF8) &&
2159 buff[0] == 0xEF && buff[1] == 0xBB && buff[2] == 0xBF)
2160 {
2161 buffer += 3;
2162 size -= 3;
2163 }
2164 }
2165
2166 /* if libxml2 detection failed try to guess */
2167 if (encoding == XML_CHAR_ENCODING_NONE)
2168 {
2169 const WCHAR *ptr = (WCHAR*)buffer;
2170 /* xml declaration with possibly specfied encoding will be still handled by parser */
2171 if ((size >= 2) && *ptr == '<' && ptr[1] != '?')
2172 {
2173 enc_name = (xmlChar*)xmlGetCharEncodingName(XML_CHAR_ENCODING_UTF16LE);
2174 encoding = XML_CHAR_ENCODING_UTF16LE;
2175 }
2176 }
2177 else if (encoding == XML_CHAR_ENCODING_UTF8)
2178 enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
2179 else
2180 enc_name = NULL;
2181
2182 locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
2183 if (!locator->pParserCtxt)
2184 {
2185 ISAXLocator_Release(&locator->ISAXLocator_iface);
2186 return E_FAIL;
2187 }
2188
2189 if (enc_name)
2190 {
2191 locator->pParserCtxt->encoding = xmlStrdup(enc_name);
2192 if (encoding == XML_CHAR_ENCODING_UTF16LE) {
2193 TRACE("switching to %s\n", enc_name);
2194 xmlSwitchEncoding(locator->pParserCtxt, encoding);
2195 }
2196 }
2197
2198 xmlFree(locator->pParserCtxt->sax);
2199 locator->pParserCtxt->sax = &locator->saxreader->sax;
2200 locator->pParserCtxt->userData = locator;
2201
2202 This->isParsing = TRUE;
2203 if(xmlParseDocument(locator->pParserCtxt) == -1 && locator->ret == S_OK)
2204 hr = E_FAIL;
2205 else
2206 hr = locator->ret;
2207 This->isParsing = FALSE;
2208
2209 if(locator->pParserCtxt)
2210 {
2211 locator->pParserCtxt->sax = NULL;
2212 xmlFreeParserCtxt(locator->pParserCtxt);
2213 locator->pParserCtxt = NULL;
2214 }
2215
2216 ISAXLocator_Release(&locator->ISAXLocator_iface);
2217 return hr;
2218 }
2219
2220 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
2221 {
2222 saxlocator *locator;
2223 HRESULT hr;
2224 ULONG dataRead;
2225 char data[1024];
2226 int ret;
2227
2228 dataRead = 0;
2229 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
2230 if(FAILED(hr)) return hr;
2231
2232 hr = SAXLocator_create(This, &locator, vbInterface);
2233 if(FAILED(hr)) return hr;
2234
2235 locator->pParserCtxt = xmlCreatePushParserCtxt(
2236 &locator->saxreader->sax, locator,
2237 data, dataRead, NULL);
2238 if(!locator->pParserCtxt)
2239 {
2240 ISAXLocator_Release(&locator->ISAXLocator_iface);
2241 return E_FAIL;
2242 }
2243
2244 This->isParsing = TRUE;
2245
2246 if(dataRead != sizeof(data))
2247 {
2248 ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
2249 hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2250 }
2251 else
2252 {
2253 while(1)
2254 {
2255 dataRead = 0;
2256 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
2257 if (FAILED(hr)) break;
2258
2259 ret = xmlParseChunk(locator->pParserCtxt, data, dataRead, 0);
2260 hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2261
2262 if (hr != S_OK) break;
2263
2264 if (dataRead != sizeof(data))
2265 {
2266 ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
2267 hr = ret!=XML_ERR_OK && locator->ret==S_OK ? E_FAIL : locator->ret;
2268 break;
2269 }
2270 }
2271 }
2272
2273 This->isParsing = FALSE;
2274
2275 xmlFreeParserCtxt(locator->pParserCtxt);
2276 locator->pParserCtxt = NULL;
2277 ISAXLocator_Release(&locator->ISAXLocator_iface);
2278 return hr;
2279 }
2280
2281 static HRESULT internal_getEntityResolver(
2282 saxreader *This,
2283 void *pEntityResolver,
2284 BOOL vbInterface)
2285 {
2286 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2287 return E_NOTIMPL;
2288 }
2289
2290 static HRESULT internal_putEntityResolver(
2291 saxreader *This,
2292 void *pEntityResolver,
2293 BOOL vbInterface)
2294 {
2295 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2296 return E_NOTIMPL;
2297 }
2298
2299 static HRESULT internal_getContentHandler(
2300 saxreader* This,
2301 void *pContentHandler,
2302 BOOL vbInterface)
2303 {
2304 TRACE("(%p)->(%p)\n", This, pContentHandler);
2305 if(pContentHandler == NULL)
2306 return E_POINTER;
2307 if((vbInterface && This->vbcontentHandler)
2308 || (!vbInterface && This->contentHandler))
2309 {
2310 if(vbInterface)
2311 IVBSAXContentHandler_AddRef(This->vbcontentHandler);
2312 else
2313 ISAXContentHandler_AddRef(This->contentHandler);
2314 }
2315 if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
2316 This->vbcontentHandler;
2317 else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
2318
2319 return S_OK;
2320 }
2321
2322 static HRESULT internal_putContentHandler(
2323 saxreader* This,
2324 void *contentHandler,
2325 BOOL vbInterface)
2326 {
2327 TRACE("(%p)->(%p)\n", This, contentHandler);
2328 if(contentHandler)
2329 {
2330 if(vbInterface)
2331 IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
2332 else
2333 ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
2334 }
2335 if((vbInterface && This->vbcontentHandler)
2336 || (!vbInterface && This->contentHandler))
2337 {
2338 if(vbInterface)
2339 IVBSAXContentHandler_Release(This->vbcontentHandler);
2340 else
2341 ISAXContentHandler_Release(This->contentHandler);
2342 }
2343 if(vbInterface)
2344 This->vbcontentHandler = contentHandler;
2345 else
2346 This->contentHandler = contentHandler;
2347
2348 return S_OK;
2349 }
2350
2351 static HRESULT internal_getDTDHandler(
2352 saxreader* This,
2353 void *pDTDHandler,
2354 BOOL vbInterface)
2355 {
2356 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2357 return E_NOTIMPL;
2358 }
2359
2360 static HRESULT internal_putDTDHandler(
2361 saxreader* This,
2362 void *pDTDHandler,
2363 BOOL vbInterface)
2364 {
2365 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2366 return E_NOTIMPL;
2367 }
2368
2369 static HRESULT internal_getErrorHandler(
2370 saxreader* This,
2371 void *pErrorHandler,
2372 BOOL vbInterface)
2373 {
2374 TRACE("(%p)->(%p)\n", This, pErrorHandler);
2375 if(pErrorHandler == NULL)
2376 return E_POINTER;
2377
2378 if(vbInterface && This->vberrorHandler)
2379 IVBSAXErrorHandler_AddRef(This->vberrorHandler);
2380 else if(!vbInterface && This->errorHandler)
2381 ISAXErrorHandler_AddRef(This->errorHandler);
2382
2383 if(vbInterface)
2384 *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
2385 else
2386 *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
2387
2388 return S_OK;
2389
2390 }
2391
2392 static HRESULT internal_putErrorHandler(
2393 saxreader* This,
2394 void *errorHandler,
2395 BOOL vbInterface)
2396 {
2397 TRACE("(%p)->(%p)\n", This, errorHandler);
2398 if(errorHandler)
2399 {
2400 if(vbInterface)
2401 IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
2402 else
2403 ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
2404 }
2405
2406 if(vbInterface && This->vberrorHandler)
2407 IVBSAXErrorHandler_Release(This->vberrorHandler);
2408 else if(!vbInterface && This->errorHandler)
2409 ISAXErrorHandler_Release(This->errorHandler);
2410
2411 if(vbInterface)
2412 This->vberrorHandler = errorHandler;
2413 else
2414 This->errorHandler = errorHandler;
2415
2416 return S_OK;
2417
2418 }
2419
2420 static HRESULT internal_parse(
2421 saxreader* This,
2422 VARIANT varInput,
2423 BOOL vbInterface)
2424 {
2425 HRESULT hr;
2426
2427 TRACE("(%p)->(%s)\n", This, debugstr_variant(&varInput));
2428
2429 /* Dispose of the BSTRs in the pool from a prior run, if any. */
2430 free_bstr_pool(&This->pool);
2431
2432 switch(V_VT(&varInput))
2433 {
2434 case VT_BSTR:
2435 hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2436 SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2437 break;
2438 case VT_ARRAY|VT_UI1: {
2439 void *pSAData;
2440 LONG lBound, uBound;
2441 ULONG dataRead;
2442
2443 hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2444 if(hr != S_OK) break;
2445 hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2446 if(hr != S_OK) break;
2447 dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2448 hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2449 if(hr != S_OK) break;
2450 hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2451 SafeArrayUnaccessData(V_ARRAY(&varInput));
2452 break;
2453 }
2454 case VT_UNKNOWN:
2455 case VT_DISPATCH: {
2456 IPersistStream *persistStream;
2457 IStream *stream = NULL;
2458 IXMLDOMDocument *xmlDoc;
2459
2460 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2461 &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2462 {
2463 BSTR bstrData;
2464
2465 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2466 hr = internal_parseBuffer(This, (const char*)bstrData,
2467 SysStringByteLen(bstrData), vbInterface);
2468 IXMLDOMDocument_Release(xmlDoc);
2469 SysFreeString(bstrData);
2470 break;
2471 }
2472
2473 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2474 &IID_IPersistStream, (void**)&persistStream) == S_OK)
2475 {
2476 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2477 if(hr != S_OK)
2478 {
2479 IPersistStream_Release(persistStream);
2480 return hr;
2481 }
2482
2483 hr = IPersistStream_Save(persistStream, stream, TRUE);
2484 IPersistStream_Release(persistStream);
2485 if(hr != S_OK)
2486 {
2487 IStream_Release(stream);
2488 stream = NULL;
2489 }
2490 }
2491
2492 if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2493 &IID_IStream, (void**)&stream) == S_OK)
2494 {
2495 hr = internal_parseStream(This, stream, vbInterface);
2496 IStream_Release(stream);
2497 break;
2498 }
2499 }
2500 default:
2501 WARN("vt %d not implemented\n", V_VT(&varInput));
2502 hr = E_INVALIDARG;
2503 }
2504
2505 return hr;
2506 }
2507
2508 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2509 {
2510 saxreader *This = obj;
2511
2512 return internal_parseBuffer(This, ptr, len, TRUE);
2513 }
2514
2515 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2516 {
2517 saxreader *This = obj;
2518
2519 return internal_parseBuffer(This, ptr, len, FALSE);
2520 }
2521
2522 static HRESULT internal_parseURL(
2523 saxreader* This,
2524 const WCHAR *url,
2525 BOOL vbInterface)
2526 {
2527 IMoniker *mon;
2528 bsc_t *bsc;
2529 HRESULT hr;
2530
2531 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2532
2533 hr = create_moniker_from_url(url, &mon);
2534 if(FAILED(hr))
2535 return hr;
2536
2537 if(vbInterface) hr = bind_url(mon, internal_vbonDataAvailable, This, &bsc);
2538 else hr = bind_url(mon, internal_onDataAvailable, This, &bsc);
2539 IMoniker_Release(mon);
2540
2541 if(FAILED(hr))
2542 return hr;
2543
2544 return detach_bsc(bsc);
2545 }
2546
2547 static HRESULT internal_putProperty(
2548 saxreader* This,
2549 const WCHAR *prop,
2550 VARIANT value,
2551 BOOL vbInterface)
2552 {
2553 TRACE("(%p)->(%s %s)\n", This, debugstr_w(prop), debugstr_variant(&value));
2554
2555 if(!memcmp(prop, PropertyDeclHandlerW, sizeof(PropertyDeclHandlerW)))
2556 {
2557 if(This->isParsing) return E_FAIL;
2558
2559 switch (V_VT(&value))
2560 {
2561 case VT_EMPTY:
2562 if (vbInterface)
2563 {
2564 if (This->vbdeclHandler)
2565 {
2566 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2567 This->vbdeclHandler = NULL;
2568 }
2569 }
2570 else
2571 if (This->declHandler)
2572 {
2573 ISAXDeclHandler_Release(This->declHandler);
2574 This->declHandler = NULL;
2575 }
2576 break;
2577 case VT_UNKNOWN:
2578 if (V_UNKNOWN(&value)) IUnknown_AddRef(V_UNKNOWN(&value));
2579
2580 if ((vbInterface && This->vbdeclHandler) ||
2581 (!vbInterface && This->declHandler))
2582 {
2583 if (vbInterface)
2584 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2585 else
2586 ISAXDeclHandler_Release(This->declHandler);
2587 }
2588
2589 if (vbInterface)
2590 This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2591 else
2592 This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2593 break;
2594 default:
2595 return E_INVALIDARG;
2596 }
2597
2598 return S_OK;
2599 }
2600
2601 if(!memcmp(prop, PropertyLexicalHandlerW, sizeof(PropertyLexicalHandlerW)))
2602 {
2603 if(This->isParsing) return E_FAIL;
2604
2605 switch (V_VT(&value))
2606 {
2607 case VT_EMPTY:
2608 if (vbInterface)
2609 {
2610 if (This->vblexicalHandler)
2611 {
2612 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2613 This->vblexicalHandler = NULL;
2614 }
2615 }
2616 else
2617 if (This->lexicalHandler)
2618 {
2619 ISAXLexicalHandler_Release(This->lexicalHandler);
2620 This->lexicalHandler = NULL;
2621 }
2622 break;
2623 case VT_UNKNOWN:
2624 if (V_UNKNOWN(&value)) IUnknown_AddRef(V_UNKNOWN(&value));
2625
2626 if ((vbInterface && This->vblexicalHandler) ||
2627 (!vbInterface && This->lexicalHandler))
2628 {
2629 if (vbInterface)
2630 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2631 else
2632 ISAXLexicalHandler_Release(This->lexicalHandler);
2633 }
2634
2635 if (vbInterface)
2636 This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2637 else
2638 This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2639 break;
2640 default:
2641 return E_INVALIDARG;
2642 }
2643
2644 return S_OK;
2645 }
2646
2647 if(!memcmp(prop, PropertyMaxXMLSizeW, sizeof(PropertyMaxXMLSizeW)))
2648 {
2649 if (V_VT(&value) == VT_I4 && V_I4(&value) == 0) return S_OK;
2650 FIXME("(%p)->(%s): max-xml-size unsupported\n", This, debugstr_variant(&value));
2651 return E_NOTIMPL;
2652 }
2653
2654 if(!memcmp(prop, PropertyMaxElementDepthW, sizeof(PropertyMaxElementDepthW)))
2655 {
2656 if (V_VT(&value) == VT_I4 && V_I4(&value) == 0) return S_OK;
2657 FIXME("(%p)->(%s): max-element-depth unsupported\n", This, debugstr_variant(&value));
2658 return E_NOTIMPL;
2659 }
2660
2661 FIXME("(%p)->(%s:%s): unsupported property\n", This, debugstr_w(prop), debugstr_variant(&value));
2662
2663 if(!memcmp(prop, PropertyCharsetW, sizeof(PropertyCharsetW)))
2664 return E_NOTIMPL;
2665
2666 if(!memcmp(prop, PropertyDomNodeW, sizeof(PropertyDomNodeW)))
2667 return E_FAIL;
2668
2669 if(!memcmp(prop, PropertyInputSourceW, sizeof(PropertyInputSourceW)))
2670 return E_NOTIMPL;
2671
2672 if(!memcmp(prop, PropertySchemaDeclHandlerW, sizeof(PropertySchemaDeclHandlerW)))
2673 return E_NOTIMPL;
2674
2675 if(!memcmp(prop, PropertyXMLDeclEncodingW, sizeof(PropertyXMLDeclEncodingW)))
2676 return E_FAIL;
2677
2678 if(!memcmp(prop, PropertyXMLDeclStandaloneW, sizeof(PropertyXMLDeclStandaloneW)))
2679 return E_FAIL;
2680
2681 if(!memcmp(prop, PropertyXMLDeclVersionW, sizeof(PropertyXMLDeclVersionW)))
2682 return E_FAIL;
2683
2684 return E_INVALIDARG;
2685 }
2686
2687 static HRESULT internal_getProperty(const saxreader* This, const WCHAR *prop, VARIANT *value, BOOL vb)
2688 {
2689 TRACE("(%p)->(%s)\n", This, debugstr_w(prop));
2690
2691 if (!value) return E_POINTER;
2692
2693 if (!memcmp(PropertyLexicalHandlerW, prop, sizeof(PropertyLexicalHandlerW)))
2694 {
2695 V_VT(value) = VT_UNKNOWN;
2696 V_UNKNOWN(value) = vb ? (IUnknown*)This->vblexicalHandler : (IUnknown*)This->lexicalHandler;
2697 if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2698 return S_OK;
2699 }
2700
2701 if (!memcmp(PropertyDeclHandlerW, prop, sizeof(PropertyDeclHandlerW)))
2702 {
2703 V_VT(value) = VT_UNKNOWN;
2704 V_UNKNOWN(value) = vb ? (IUnknown*)This->vbdeclHandler : (IUnknown*)This->declHandler;
2705 if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2706 return S_OK;
2707 }
2708
2709 FIXME("(%p)->(%s) unsupported property\n", This, debugstr_w(prop));
2710
2711 return E_NOTIMPL;
2712 }
2713
2714 /*** IVBSAXXMLReader interface ***/
2715 /*** IUnknown methods ***/
2716 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2717 {
2718 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2719
2720 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2721
2722 *ppvObject = NULL;
2723
2724 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2725 IsEqualGUID( riid, &IID_IDispatch ) ||
2726 IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2727 {
2728 *ppvObject = iface;
2729 }
2730 else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2731 {
2732 *ppvObject = &This->ISAXXMLReader_iface;
2733 }
2734 else if (dispex_query_interface(&This->dispex, riid, ppvObject))
2735 {
2736 return *ppvObject ? S_OK : E_NOINTERFACE;
2737 }
2738 else
2739 {
2740 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2741 return E_NOINTERFACE;
2742 }
2743
2744 IVBSAXXMLReader_AddRef( iface );
2745
2746 return S_OK;
2747 }
2748
2749 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2750 {
2751 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2752 TRACE("%p\n", This );
2753 return InterlockedIncrement( &This->ref );
2754 }
2755
2756 static ULONG WINAPI saxxmlreader_Release(
2757 IVBSAXXMLReader* iface)
2758 {
2759 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2760 LONG ref;
2761
2762 TRACE("%p\n", This );
2763
2764 ref = InterlockedDecrement( &This->ref );
2765 if ( ref == 0 )
2766 {
2767 if(This->contentHandler)
2768 ISAXContentHandler_Release(This->contentHandler);
2769
2770 if(This->vbcontentHandler)
2771 IVBSAXContentHandler_Release(This->vbcontentHandler);
2772
2773 if(This->errorHandler)
2774 ISAXErrorHandler_Release(This->errorHandler);
2775
2776 if(This->vberrorHandler)
2777 IVBSAXErrorHandler_Release(This->vberrorHandler);
2778
2779 if(This->lexicalHandler)
2780 ISAXLexicalHandler_Release(This->lexicalHandler);
2781
2782 if(This->vblexicalHandler)
2783 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2784
2785 if(This->declHandler)
2786 ISAXDeclHandler_Release(This->declHandler);
2787
2788 if(This->vbdeclHandler)
2789 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2790
2791 free_bstr_pool(&This->pool);
2792
2793 release_dispex(&This->dispex);
2794 heap_free( This );
2795 }
2796
2797 return ref;
2798 }
2799 /*** IDispatch ***/
2800 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2801 {
2802 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2803 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2804 }
2805
2806 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2807 IVBSAXXMLReader *iface,
2808 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2809 {
2810 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2811 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
2812 iTInfo, lcid, ppTInfo);
2813 }
2814
2815 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2816 IVBSAXXMLReader *iface,
2817 REFIID riid,
2818 LPOLESTR* rgszNames,
2819 UINT cNames,
2820 LCID lcid,
2821 DISPID* rgDispId)
2822 {
2823 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2824 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
2825 riid, rgszNames, cNames, lcid, rgDispId);
2826 }
2827
2828 static HRESULT WINAPI saxxmlreader_Invoke(
2829 IVBSAXXMLReader *iface,
2830 DISPID dispIdMember,
2831 REFIID riid,
2832 LCID lcid,
2833 WORD wFlags,
2834 DISPPARAMS* pDispParams,
2835 VARIANT* pVarResult,
2836 EXCEPINFO* pExcepInfo,
2837 UINT* puArgErr)
2838 {
2839 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2840 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
2841 dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2842 }
2843
2844 /*** IVBSAXXMLReader methods ***/
2845 static HRESULT WINAPI saxxmlreader_getFeature(
2846 IVBSAXXMLReader* iface,
2847 const WCHAR *feature_name,
2848 VARIANT_BOOL *value)
2849 {
2850 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2851 saxreader_feature feature;
2852
2853 TRACE("(%p)->(%s %p)\n", This, debugstr_w(feature_name), value);
2854
2855 feature = get_saxreader_feature(feature_name);
2856 if (feature == Namespaces || feature == NamespacePrefixes)
2857 return get_feature_value(This, feature, value);
2858
2859 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(feature_name), value);
2860 return E_NOTIMPL;
2861 }
2862
2863 static HRESULT WINAPI saxxmlreader_putFeature(
2864 IVBSAXXMLReader* iface,
2865 const WCHAR *feature_name,
2866 VARIANT_BOOL value)
2867 {
2868 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2869 saxreader_feature feature;
2870
2871 TRACE("(%p)->(%s %x)\n", This, debugstr_w(feature_name), value);
2872
2873 feature = get_saxreader_feature(feature_name);
2874
2875 /* accepted cases */
2876 if ((feature == ExternalGeneralEntities && value == VARIANT_FALSE) ||
2877 (feature == ExternalParameterEntities && value == VARIANT_FALSE) ||
2878 feature == Namespaces ||
2879 feature == NamespacePrefixes)
2880 {
2881 return set_feature_value(This, feature, value);
2882 }
2883
2884 if (feature == LexicalHandlerParEntities || feature == ProhibitDTD)
2885 {
2886 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature_name), value);
2887 return set_feature_value(This, feature, value);
2888 }
2889
2890 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature_name), value);
2891 return E_NOTIMPL;
2892 }
2893
2894 static HRESULT WINAPI saxxmlreader_getProperty(
2895 IVBSAXXMLReader* iface,
2896 const WCHAR *prop,
2897 VARIANT *value)
2898 {
2899 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2900 return internal_getProperty(This, prop, value, TRUE);
2901 }
2902
2903 static HRESULT WINAPI saxxmlreader_putProperty(
2904 IVBSAXXMLReader* iface,
2905 const WCHAR *pProp,
2906 VARIANT value)
2907 {
2908 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2909 return internal_putProperty(This, pProp, value, TRUE);
2910 }
2911
2912 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2913 IVBSAXXMLReader* iface,
2914 IVBSAXEntityResolver **pEntityResolver)
2915 {
2916 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2917 return internal_getEntityResolver(This, pEntityResolver, TRUE);
2918 }
2919
2920 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2921 IVBSAXXMLReader* iface,
2922 IVBSAXEntityResolver *pEntityResolver)
2923 {
2924 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2925 return internal_putEntityResolver(This, pEntityResolver, TRUE);
2926 }
2927
2928 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2929 IVBSAXXMLReader* iface,
2930 IVBSAXContentHandler **ppContentHandler)
2931 {
2932 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2933 return internal_getContentHandler(This, ppContentHandler, TRUE);
2934 }
2935
2936 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2937 IVBSAXXMLReader* iface,
2938 IVBSAXContentHandler *contentHandler)
2939 {
2940 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2941 return internal_putContentHandler(This, contentHandler, TRUE);
2942 }
2943
2944 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2945 IVBSAXXMLReader* iface,
2946 IVBSAXDTDHandler **pDTDHandler)
2947 {
2948 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2949 return internal_getDTDHandler(This, pDTDHandler, TRUE);
2950 }
2951
2952 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2953 IVBSAXXMLReader* iface,
2954 IVBSAXDTDHandler *pDTDHandler)
2955 {
2956 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2957 return internal_putDTDHandler(This, pDTDHandler, TRUE);
2958 }
2959
2960 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2961 IVBSAXXMLReader* iface,
2962 IVBSAXErrorHandler **pErrorHandler)
2963 {
2964 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2965 return internal_getErrorHandler(This, pErrorHandler, TRUE);
2966 }
2967
2968 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2969 IVBSAXXMLReader* iface,
2970 IVBSAXErrorHandler *errorHandler)
2971 {
2972 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2973 return internal_putErrorHandler(This, errorHandler, TRUE);
2974 }
2975
2976 static HRESULT WINAPI saxxmlreader_get_baseURL(
2977 IVBSAXXMLReader* iface,
2978 const WCHAR **pBaseUrl)
2979 {
2980 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2981
2982 FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2983 return E_NOTIMPL;
2984 }
2985
2986 static HRESULT WINAPI saxxmlreader_put_baseURL(
2987 IVBSAXXMLReader* iface,
2988 const WCHAR *pBaseUrl)
2989 {
2990 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2991
2992 FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2993 return E_NOTIMPL;
2994 }
2995
2996 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2997 IVBSAXXMLReader* iface,
2998 const WCHAR **pSecureBaseUrl)
2999 {
3000 saxreader *This = impl_from_IVBSAXXMLReader( iface );
3001
3002 FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
3003 return E_NOTIMPL;
3004 }
3005
3006
3007 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
3008 IVBSAXXMLReader* iface,
3009 const WCHAR *secureBaseUrl)
3010 {
3011 saxreader *This = impl_from_IVBSAXXMLReader( iface );
3012
3013 FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
3014 return E_NOTIMPL;
3015 }
3016
3017 static HRESULT WINAPI saxxmlreader_parse(
3018 IVBSAXXMLReader* iface,
3019 VARIANT varInput)
3020 {
3021 saxreader *This = impl_from_IVBSAXXMLReader( iface );
3022 return internal_parse(This, varInput, TRUE);
3023 }
3024
3025 static HRESULT WINAPI saxxmlreader_parseURL(
3026 IVBSAXXMLReader* iface,
3027 const WCHAR *url)
3028 {
3029 saxreader *This = impl_from_IVBSAXXMLReader( iface );
3030 return internal_parseURL(This, url, TRUE);
3031 }
3032
3033 static const struct IVBSAXXMLReaderVtbl VBSAXXMLReaderVtbl =
3034 {
3035 saxxmlreader_QueryInterface,
3036 saxxmlreader_AddRef,
3037 saxxmlreader_Release,
3038 saxxmlreader_GetTypeInfoCount,
3039 saxxmlreader_GetTypeInfo,
3040 saxxmlreader_GetIDsOfNames,
3041 saxxmlreader_Invoke,
3042 saxxmlreader_getFeature,
3043 saxxmlreader_putFeature,
3044 saxxmlreader_getProperty,
3045 saxxmlreader_putProperty,
3046 saxxmlreader_get_entityResolver,
3047 saxxmlreader_put_entityResolver,
3048 saxxmlreader_get_contentHandler,
3049 saxxmlreader_put_contentHandler,
3050 saxxmlreader_get_dtdHandler,
3051 saxxmlreader_put_dtdHandler,
3052 saxxmlreader_get_errorHandler,
3053 saxxmlreader_put_errorHandler,
3054 saxxmlreader_get_baseURL,
3055 saxxmlreader_put_baseURL,
3056 saxxmlreader_get_secureBaseURL,
3057 saxxmlreader_put_secureBaseURL,
3058 saxxmlreader_parse,
3059 saxxmlreader_parseURL
3060 };
3061
3062 /*** ISAXXMLReader interface ***/
3063 /*** IUnknown methods ***/
3064 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
3065 {
3066 saxreader *This = impl_from_ISAXXMLReader( iface );
3067 return saxxmlreader_QueryInterface(&This->IVBSAXXMLReader_iface, riid, ppvObject);
3068 }
3069
3070 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
3071 {
3072 saxreader *This = impl_from_ISAXXMLReader( iface );
3073 return saxxmlreader_AddRef(&This->IVBSAXXMLReader_iface);
3074 }
3075
3076 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
3077 {
3078 saxreader *This = impl_from_ISAXXMLReader( iface );
3079 return saxxmlreader_Release(&This->IVBSAXXMLReader_iface);
3080 }
3081
3082 /*** ISAXXMLReader methods ***/
3083 static HRESULT WINAPI isaxxmlreader_getFeature(
3084 ISAXXMLReader* iface,
3085 const WCHAR *pFeature,
3086 VARIANT_BOOL *pValue)
3087 {
3088 saxreader *This = impl_from_ISAXXMLReader( iface );
3089 return IVBSAXXMLReader_getFeature(&This->IVBSAXXMLReader_iface, pFeature, pValue);
3090 }
3091
3092 static HRESULT WINAPI isaxxmlreader_putFeature(
3093 ISAXXMLReader* iface,
3094 const WCHAR *pFeature,
3095 VARIANT_BOOL vfValue)
3096 {
3097 saxreader *This = impl_from_ISAXXMLReader( iface );
3098 return IVBSAXXMLReader_putFeature(&This->IVBSAXXMLReader_iface, pFeature, vfValue);
3099 }
3100
3101 static HRESULT WINAPI isaxxmlreader_getProperty(
3102 ISAXXMLReader* iface,
3103 const WCHAR *prop,
3104 VARIANT *value)
3105 {
3106 saxreader *This = impl_from_ISAXXMLReader( iface );
3107 return internal_getProperty(This, prop, value, FALSE);
3108 }
3109
3110 static HRESULT WINAPI isaxxmlreader_putProperty(
3111 ISAXXMLReader* iface,
3112 const WCHAR *pProp,
3113 VARIANT value)
3114 {
3115 saxreader *This = impl_from_ISAXXMLReader( iface );
3116 return internal_putProperty(This, pProp, value, FALSE);
3117 }
3118
3119 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
3120 ISAXXMLReader* iface,
3121 ISAXEntityResolver **ppEntityResolver)
3122 {
3123 saxreader *This = impl_from_ISAXXMLReader( iface );
3124 return internal_getEntityResolver(This, ppEntityResolver, FALSE);
3125 }
3126
3127 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
3128 ISAXXMLReader* iface,
3129 ISAXEntityResolver *pEntityResolver)
3130 {
3131 saxreader *This = impl_from_ISAXXMLReader( iface );
3132 return internal_putEntityResolver(This, pEntityResolver, FALSE);
3133 }
3134
3135 static HRESULT WINAPI isaxxmlreader_getContentHandler(
3136 ISAXXMLReader* iface,
3137 ISAXContentHandler **pContentHandler)
3138 {
3139 saxreader *This = impl_from_ISAXXMLReader( iface );
3140 return internal_getContentHandler(This, pContentHandler, FALSE);
3141 }
3142
3143 static HRESULT WINAPI isaxxmlreader_putContentHandler(
3144 ISAXXMLReader* iface,
3145 ISAXContentHandler *contentHandler)
3146 {
3147 saxreader *This = impl_from_ISAXXMLReader( iface );
3148 return internal_putContentHandler(This, contentHandler, FALSE);
3149 }
3150
3151 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
3152 ISAXXMLReader* iface,
3153 ISAXDTDHandler **pDTDHandler)
3154 {
3155 saxreader *This = impl_from_ISAXXMLReader( iface );
3156 return internal_getDTDHandler(This, pDTDHandler, FALSE);
3157 }
3158
3159 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
3160 ISAXXMLReader* iface,
3161 ISAXDTDHandler *pDTDHandler)
3162 {
3163 saxreader *This = impl_from_ISAXXMLReader( iface );
3164 return internal_putDTDHandler(This, pDTDHandler, FALSE);
3165 }
3166
3167 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
3168 ISAXXMLReader* iface,
3169 ISAXErrorHandler **pErrorHandler)
3170 {
3171 saxreader *This = impl_from_ISAXXMLReader( iface );
3172 return internal_getErrorHandler(This, pErrorHandler, FALSE);
3173 }
3174
3175 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
3176 ISAXXMLReader* iface,
3177 ISAXErrorHandler *errorHandler)
3178 {
3179 saxreader *This = impl_from_ISAXXMLReader( iface );
3180 return internal_putErrorHandler(This, errorHandler, FALSE);
3181 }
3182
3183 static HRESULT WINAPI isaxxmlreader_getBaseURL(
3184 ISAXXMLReader* iface,
3185 const WCHAR **pBaseUrl)
3186 {
3187 saxreader *This = impl_from_ISAXXMLReader( iface );
3188 return IVBSAXXMLReader_get_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
3189 }
3190
3191 static HRESULT WINAPI isaxxmlreader_putBaseURL(
3192 ISAXXMLReader* iface,
3193 const WCHAR *pBaseUrl)
3194 {
3195 saxreader *This = impl_from_ISAXXMLReader( iface );
3196 return IVBSAXXMLReader_put_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
3197 }
3198
3199 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
3200 ISAXXMLReader* iface,
3201 const WCHAR **pSecureBaseUrl)
3202 {
3203 saxreader *This = impl_from_ISAXXMLReader( iface );
3204 return IVBSAXXMLReader_get_secureBaseURL(&This->IVBSAXXMLReader_iface, pSecureBaseUrl);
3205 }
3206
3207 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
3208 ISAXXMLReader* iface,
3209 const WCHAR *secureBaseUrl)
3210 {
3211 saxreader *This = impl_from_ISAXXMLReader( iface );
3212 return IVBSAXXMLReader_put_secureBaseURL(&This->IVBSAXXMLReader_iface, secureBaseUrl);
3213 }
3214
3215 static HRESULT WINAPI isaxxmlreader_parse(
3216 ISAXXMLReader* iface,
3217 VARIANT varInput)
3218 {
3219 saxreader *This = impl_from_ISAXXMLReader( iface );
3220 return internal_parse(This, varInput, FALSE);
3221 }
3222
3223 static HRESULT WINAPI isaxxmlreader_parseURL(
3224 ISAXXMLReader* iface,
3225 const WCHAR *url)
3226 {
3227 saxreader *This = impl_from_ISAXXMLReader( iface );
3228 return internal_parseURL(This, url, FALSE);
3229 }
3230
3231 static const struct ISAXXMLReaderVtbl SAXXMLReaderVtbl =
3232 {
3233 isaxxmlreader_QueryInterface,
3234 isaxxmlreader_AddRef,
3235 isaxxmlreader_Release,
3236 isaxxmlreader_getFeature,
3237 isaxxmlreader_putFeature,
3238 isaxxmlreader_getProperty,
3239 isaxxmlreader_putProperty,
3240 isaxxmlreader_getEntityResolver,
3241 isaxxmlreader_putEntityResolver,
3242 isaxxmlreader_getContentHandler,
3243 isaxxmlreader_putContentHandler,
3244 isaxxmlreader_getDTDHandler,
3245 isaxxmlreader_putDTDHandler,
3246 isaxxmlreader_getErrorHandler,
3247 isaxxmlreader_putErrorHandler,
3248 isaxxmlreader_getBaseURL,
3249 isaxxmlreader_putBaseURL,
3250 isaxxmlreader_getSecureBaseURL,
3251 isaxxmlreader_putSecureBaseURL,
3252 isaxxmlreader_parse,
3253 isaxxmlreader_parseURL
3254 };
3255
3256 static const tid_t saxreader_iface_tids[] = {
3257 IVBSAXXMLReader_tid,
3258 0
3259 };
3260 static dispex_static_data_t saxreader_dispex = {
3261 NULL,
3262 IVBSAXXMLReader_tid,
3263 NULL,
3264 saxreader_iface_tids
3265 };
3266
3267 HRESULT SAXXMLReader_create(MSXML_VERSION version, IUnknown *outer, LPVOID *ppObj)
3268 {
3269 saxreader *reader;
3270
3271 TRACE("(%p, %p)\n", outer, ppObj);
3272
3273 reader = heap_alloc( sizeof (*reader) );
3274 if( !reader )
3275 return E_OUTOFMEMORY;
3276
3277 reader->IVBSAXXMLReader_iface.lpVtbl = &VBSAXXMLReaderVtbl;
3278 reader->ISAXXMLReader_iface.lpVtbl = &SAXXMLReaderVtbl;
3279 reader->ref = 1;
3280 reader->contentHandler = NULL;
3281 reader->vbcontentHandler = NULL;
3282 reader->errorHandler = NULL;
3283 reader->vberrorHandler = NULL;
3284 reader->lexicalHandler = NULL;
3285 reader->vblexicalHandler = NULL;
3286 reader->declHandler = NULL;
3287 reader->vbdeclHandler = NULL;
3288 reader->isParsing = FALSE;
3289 reader->pool.pool = NULL;
3290 reader->pool.index = 0;
3291 reader->pool.len = 0;
3292 reader->features = Namespaces | NamespacePrefixes;
3293 reader->version = version;
3294
3295 init_dispex(&reader->dispex, (IUnknown*)&reader->IVBSAXXMLReader_iface, &saxreader_dispex);
3296
3297 memset(&reader->sax, 0, sizeof(xmlSAXHandler));
3298 reader->sax.initialized = XML_SAX2_MAGIC;
3299 reader->sax.startDocument = libxmlStartDocument;
3300 reader->sax.endDocument = libxmlEndDocument;
3301 reader->sax.startElementNs = libxmlStartElementNS;
3302 reader->sax.endElementNs = libxmlEndElementNS;
3303 reader->sax.characters = libxmlCharacters;
3304 reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
3305 reader->sax.comment = libxmlComment;
3306 reader->sax.error = libxmlFatalError;
3307 reader->sax.fatalError = libxmlFatalError;
3308 reader->sax.cdataBlock = libxmlCDataBlock;
3309
3310 *ppObj = &reader->IVBSAXXMLReader_iface;
3311
3312 TRACE("returning iface %p\n", *ppObj);
3313
3314 return S_OK;
3315 }
3316
3317 #else
3318
3319 HRESULT SAXXMLReader_create(MSXML_VERSION version, IUnknown *pUnkOuter, LPVOID *ppObj)
3320 {
3321 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
3322 "libxml2 support was not present at compile time.\n");
3323 return E_NOTIMPL;
3324 }
3325
3326 #endif
Maarten's multimedia branch