2 * SAX Reader implementation
4 * Copyright 2008 Alistair Leslie-Hughes
5 * Copyright 2008 Piotr Caban
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.
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.
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
21 #define WIN32_NO_STATUS
30 //# include <libxml/parser.h>
31 //# include <libxml/xmlerror.h>
32 //# include <libxml/SAX2.h>
33 # include <libxml/parserInternals.h>
38 //#include "winuser.h"
42 //#include "wininet.h"
45 //#include "shlwapi.h"
47 #include <wine/debug.h>
48 #include <wine/list.h>
50 #include "msxml_private.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(msxml
);
59 ExhaustiveErrors
= 1 << 1,
60 ExternalGeneralEntities
= 1 << 2,
61 ExternalParameterEntities
= 1 << 3,
62 ForcedResync
= 1 << 4,
63 NamespacePrefixes
= 1 << 5,
65 ParameterEntities
= 1 << 7,
66 PreserveSystemIndentifiers
= 1 << 8,
68 SchemaValidation
= 1 << 10,
69 ServerHttpRequest
= 1 << 11,
70 SuppressValidationfatalError
= 1 << 12,
71 UseInlineSchema
= 1 << 13,
72 UseSchemaLocation
= 1 << 14,
73 LexicalHandlerParEntities
= 1 << 15
77 static const WCHAR FeatureExternalGeneralEntitiesW
[] = {
78 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/',
79 'f','e','a','t','u','r','e','s','/','e','x','t','e','r','n','a','l','-','g','e','n','e','r','a','l',
80 '-','e','n','t','i','t','i','e','s',0
83 static const WCHAR FeatureExternalParameterEntitiesW
[] = {
84 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
85 '/','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
88 static const WCHAR FeatureLexicalHandlerParEntitiesW
[] = {
89 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
90 '/','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
93 static const WCHAR FeatureProhibitDTDW
[] = {
94 'p','r','o','h','i','b','i','t','-','d','t','d',0
97 static const WCHAR FeatureNamespacesW
[] = {
98 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
99 '/','n','a','m','e','s','p','a','c','e','s',0
102 static const WCHAR FeatureNamespacePrefixesW
[] = {
103 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
104 '/','n','a','m','e','s','p','a','c','e','-','p','r','e','f','i','x','e','s',0
107 struct saxreader_feature_pair
109 saxreader_feature feature
;
113 static const struct saxreader_feature_pair saxreader_feature_map
[] = {
114 { ExternalGeneralEntities
, FeatureExternalGeneralEntitiesW
},
115 { ExternalParameterEntities
, FeatureExternalParameterEntitiesW
},
116 { LexicalHandlerParEntities
, FeatureLexicalHandlerParEntitiesW
},
117 { NamespacePrefixes
, FeatureNamespacePrefixesW
},
118 { Namespaces
, FeatureNamespacesW
},
119 { ProhibitDTD
, FeatureProhibitDTDW
}
122 static saxreader_feature
get_saxreader_feature(const WCHAR
*name
)
127 max
= sizeof(saxreader_feature_map
)/sizeof(struct saxreader_feature_pair
) - 1;
133 c
= strcmpW(saxreader_feature_map
[n
].name
, name
);
135 return saxreader_feature_map
[n
].feature
;
143 return FeatureUnknown
;
165 ns
*ns
; /* namespaces defined in this particular element */
171 SAXContentHandler
= 0,
180 struct saxanyhandler_iface
186 struct saxcontenthandler_iface
188 ISAXContentHandler
*handler
;
189 IVBSAXContentHandler
*vbhandler
;
192 struct saxerrorhandler_iface
194 ISAXErrorHandler
*handler
;
195 IVBSAXErrorHandler
*vbhandler
;
198 struct saxlexicalhandler_iface
200 ISAXLexicalHandler
*handler
;
201 IVBSAXLexicalHandler
*vbhandler
;
204 struct saxentityresolver_iface
206 ISAXEntityResolver
*handler
;
207 IVBSAXEntityResolver
*vbhandler
;
210 struct saxhandler_iface
213 struct saxcontenthandler_iface content
;
214 struct saxentityresolver_iface entityresolver
;
215 struct saxerrorhandler_iface error
;
216 struct saxlexicalhandler_iface lexical
;
217 struct saxanyhandler_iface anyhandler
;
224 IVBSAXXMLReader IVBSAXXMLReader_iface
;
225 ISAXXMLReader ISAXXMLReader_iface
;
228 struct saxhandler_iface saxhandlers
[SAXHandler_Last
];
231 struct bstrpool pool
;
232 saxreader_feature features
;
233 BSTR xmldecl_version
;
234 MSXML_VERSION version
;
237 static HRESULT
saxreader_put_handler(saxreader
*reader
, enum saxhandler_type type
, void *ptr
, BOOL vb
)
239 struct saxanyhandler_iface
*iface
= &reader
->saxhandlers
[type
].u
.anyhandler
;
240 IUnknown
*unk
= (IUnknown
*)ptr
;
243 IUnknown_AddRef(unk
);
245 if ((vb
&& iface
->vbhandler
) || (!vb
&& iface
->handler
))
246 IUnknown_Release(vb
? iface
->vbhandler
: iface
->handler
);
249 iface
->vbhandler
= unk
;
251 iface
->handler
= unk
;
256 static HRESULT
saxreader_get_handler(const saxreader
*reader
, enum saxhandler_type type
, BOOL vb
, void **ret
)
258 const struct saxanyhandler_iface
*iface
= &reader
->saxhandlers
[type
].u
.anyhandler
;
260 if (!ret
) return E_POINTER
;
262 if ((vb
&& iface
->vbhandler
) || (!vb
&& iface
->handler
))
265 IUnknown_AddRef(iface
->vbhandler
);
267 IUnknown_AddRef(iface
->handler
);
270 *ret
= vb
? iface
->vbhandler
: iface
->handler
;
275 static struct saxcontenthandler_iface
*saxreader_get_contenthandler(saxreader
*reader
)
277 return &reader
->saxhandlers
[SAXContentHandler
].u
.content
;
280 static struct saxerrorhandler_iface
*saxreader_get_errorhandler(saxreader
*reader
)
282 return &reader
->saxhandlers
[SAXErrorHandler
].u
.error
;
285 static struct saxlexicalhandler_iface
*saxreader_get_lexicalhandler(saxreader
*reader
)
287 return &reader
->saxhandlers
[SAXLexicalHandler
].u
.lexical
;
292 IVBSAXLocator IVBSAXLocator_iface
;
293 ISAXLocator ISAXLocator_iface
;
294 IVBSAXAttributes IVBSAXAttributes_iface
;
295 ISAXAttributes ISAXAttributes_iface
;
297 saxreader
*saxreader
;
299 xmlParserCtxtPtr pParserCtxt
;
305 struct list elements
;
319 static inline saxreader
*impl_from_IVBSAXXMLReader( IVBSAXXMLReader
*iface
)
321 return CONTAINING_RECORD(iface
, saxreader
, IVBSAXXMLReader_iface
);
324 static inline saxreader
*impl_from_ISAXXMLReader( ISAXXMLReader
*iface
)
326 return CONTAINING_RECORD(iface
, saxreader
, ISAXXMLReader_iface
);
329 static inline saxlocator
*impl_from_IVBSAXLocator( IVBSAXLocator
*iface
)
331 return CONTAINING_RECORD(iface
, saxlocator
, IVBSAXLocator_iface
);
334 static inline saxlocator
*impl_from_ISAXLocator( ISAXLocator
*iface
)
336 return CONTAINING_RECORD(iface
, saxlocator
, ISAXLocator_iface
);
339 static inline saxlocator
*impl_from_IVBSAXAttributes( IVBSAXAttributes
*iface
)
341 return CONTAINING_RECORD(iface
, saxlocator
, IVBSAXAttributes_iface
);
344 static inline saxlocator
*impl_from_ISAXAttributes( ISAXAttributes
*iface
)
346 return CONTAINING_RECORD(iface
, saxlocator
, ISAXAttributes_iface
);
349 static inline int saxreader_has_handler(const saxlocator
*locator
, enum saxhandler_type type
)
351 struct saxanyhandler_iface
*iface
= &locator
->saxreader
->saxhandlers
[type
].u
.anyhandler
;
352 return (locator
->vbInterface
&& iface
->vbhandler
) || (!locator
->vbInterface
&& iface
->handler
);
355 static HRESULT
saxreader_saxcharacters(saxlocator
*locator
, BSTR chars
)
357 struct saxcontenthandler_iface
*content
= saxreader_get_contenthandler(locator
->saxreader
);
360 if (!saxreader_has_handler(locator
, SAXContentHandler
)) return S_OK
;
362 if (locator
->vbInterface
)
363 hr
= IVBSAXContentHandler_characters(content
->vbhandler
, &chars
);
365 hr
= ISAXContentHandler_characters(content
->handler
, chars
, SysStringLen(chars
));
371 static const WCHAR PropertyCharsetW
[] = {
372 'c','h','a','r','s','e','t',0
374 static const WCHAR PropertyXmlDeclVersionW
[] = {
375 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
377 static const WCHAR PropertyDeclHandlerW
[] = {
378 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
379 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
380 'd','e','c','l','a','r','a','t','i','o','n',
381 '-','h','a','n','d','l','e','r',0
383 static const WCHAR PropertyDomNodeW
[] = {
384 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
385 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
386 'd','o','m','-','n','o','d','e',0
388 static const WCHAR PropertyInputSourceW
[] = {
389 'i','n','p','u','t','-','s','o','u','r','c','e',0
391 static const WCHAR PropertyLexicalHandlerW
[] = {
392 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
393 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
394 'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
396 static const WCHAR PropertyMaxElementDepthW
[] = {
397 'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
399 static const WCHAR PropertyMaxXMLSizeW
[] = {
400 'm','a','x','-','x','m','l','-','s','i','z','e',0
402 static const WCHAR PropertySchemaDeclHandlerW
[] = {
403 's','c','h','e','m','a','-','d','e','c','l','a','r','a','t','i','o','n','-',
404 'h','a','n','d','l','e','r',0
406 static const WCHAR PropertyXMLDeclEncodingW
[] = {
407 'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
409 static const WCHAR PropertyXMLDeclStandaloneW
[] = {
410 'x','m','l','d','e','c','l','-','s','t','a','n','d','a','l','o','n','e',0
412 static const WCHAR PropertyXMLDeclVersionW
[] = {
413 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
416 static inline HRESULT
set_feature_value(saxreader
*reader
, saxreader_feature feature
, VARIANT_BOOL value
)
418 /* handling of non-VARIANT_* values is version dependent */
419 if ((reader
->version
< MSXML4
) && (value
!= VARIANT_TRUE
))
420 value
= VARIANT_FALSE
;
421 if ((reader
->version
>= MSXML4
) && (value
!= VARIANT_FALSE
))
422 value
= VARIANT_TRUE
;
424 if (value
== VARIANT_TRUE
)
425 reader
->features
|= feature
;
427 reader
->features
&= ~feature
;
432 static inline HRESULT
get_feature_value(const saxreader
*reader
, saxreader_feature feature
, VARIANT_BOOL
*value
)
434 *value
= reader
->features
& feature
? VARIANT_TRUE
: VARIANT_FALSE
;
438 static BOOL
is_namespaces_enabled(const saxreader
*reader
)
440 return (reader
->version
< MSXML4
) || (reader
->features
& Namespaces
);
443 static BSTR
build_qname(BSTR prefix
, BSTR local
)
445 if (prefix
&& *prefix
)
447 BSTR qname
= SysAllocStringLen(NULL
, SysStringLen(prefix
) + SysStringLen(local
) + 1);
451 strcpyW(ptr
, prefix
);
452 ptr
+= SysStringLen(prefix
);
458 return SysAllocString(local
);
461 static element_entry
* alloc_element_entry(const xmlChar
*local
, const xmlChar
*prefix
, int nb_ns
,
462 const xmlChar
**namespaces
)
467 ret
= heap_alloc(sizeof(*ret
));
468 if (!ret
) return ret
;
470 ret
->local
= bstr_from_xmlChar(local
);
471 ret
->prefix
= bstr_from_xmlChar(prefix
);
472 ret
->qname
= build_qname(ret
->prefix
, ret
->local
);
473 ret
->ns
= nb_ns
? heap_alloc(nb_ns
*sizeof(ns
)) : NULL
;
474 ret
->ns_count
= nb_ns
;
476 for (i
=0; i
< nb_ns
; i
++)
478 ret
->ns
[i
].prefix
= bstr_from_xmlChar(namespaces
[2*i
]);
479 ret
->ns
[i
].uri
= bstr_from_xmlChar(namespaces
[2*i
+1]);
485 static void free_element_entry(element_entry
*element
)
489 for (i
=0; i
<element
->ns_count
;i
++)
491 SysFreeString(element
->ns
[i
].prefix
);
492 SysFreeString(element
->ns
[i
].uri
);
495 SysFreeString(element
->prefix
);
496 SysFreeString(element
->local
);
498 heap_free(element
->ns
);
502 static void push_element_ns(saxlocator
*locator
, element_entry
*element
)
504 list_add_head(&locator
->elements
, &element
->entry
);
507 static element_entry
* pop_element_ns(saxlocator
*locator
)
509 element_entry
*element
= LIST_ENTRY(list_head(&locator
->elements
), element_entry
, entry
);
512 list_remove(&element
->entry
);
517 static BSTR
find_element_uri(saxlocator
*locator
, const xmlChar
*uri
)
519 element_entry
*element
;
523 if (!uri
) return NULL
;
525 uriW
= bstr_from_xmlChar(uri
);
527 LIST_FOR_EACH_ENTRY(element
, &locator
->elements
, element_entry
, entry
)
529 for (i
=0; i
< element
->ns_count
; i
++)
530 if (!strcmpW(uriW
, element
->ns
[i
].uri
))
533 return element
->ns
[i
].uri
;
538 ERR("namespace uri not found, %s\n", debugstr_a((char*)uri
));
542 /* used to localize version dependent error check behaviour */
543 static inline BOOL
sax_callback_failed(saxlocator
*This
, HRESULT hr
)
545 return This
->saxreader
->version
>= MSXML4
? FAILED(hr
) : hr
!= S_OK
;
548 /* index value -1 means it tries to loop for a first time */
549 static inline BOOL
iterate_endprefix_index(saxlocator
*This
, const element_entry
*element
, int *i
)
551 if (This
->saxreader
->version
>= MSXML4
)
553 if (*i
== -1) *i
= 0; else ++*i
;
554 return *i
< element
->ns_count
;
558 if (*i
== -1) *i
= element
->ns_count
-1; else --*i
;
563 static BOOL
bstr_pool_insert(struct bstrpool
*pool
, BSTR pool_entry
)
567 pool
->pool
= HeapAlloc(GetProcessHeap(), 0, 16 * sizeof(*pool
->pool
));
574 else if (pool
->index
== pool
->len
)
576 BSTR
*realloc
= HeapReAlloc(GetProcessHeap(), 0, pool
->pool
, pool
->len
* 2 * sizeof(*realloc
));
581 pool
->pool
= realloc
;
585 pool
->pool
[pool
->index
++] = pool_entry
;
589 static void free_bstr_pool(struct bstrpool
*pool
)
593 for (i
= 0; i
< pool
->index
; i
++)
594 SysFreeString(pool
->pool
[i
]);
596 HeapFree(GetProcessHeap(), 0, pool
->pool
);
599 pool
->index
= pool
->len
= 0;
602 static BSTR
bstr_from_xmlCharN(const xmlChar
*buf
, int len
)
610 dLen
= MultiByteToWideChar(CP_UTF8
, 0, (LPCSTR
)buf
, len
, NULL
, 0);
611 if(len
!= -1) dLen
++;
612 bstr
= SysAllocStringLen(NULL
, dLen
-1);
615 MultiByteToWideChar(CP_UTF8
, 0, (LPCSTR
)buf
, len
, bstr
, dLen
);
616 if(len
!= -1) bstr
[dLen
-1] = '\0';
621 static BSTR
QName_from_xmlChar(const xmlChar
*prefix
, const xmlChar
*name
)
626 if(!name
) return NULL
;
628 if(!prefix
|| !*prefix
)
629 return bstr_from_xmlChar(name
);
631 qname
= xmlBuildQName(name
, prefix
, NULL
, 0);
632 bstr
= bstr_from_xmlChar(qname
);
638 static BSTR
pooled_bstr_from_xmlChar(struct bstrpool
*pool
, const xmlChar
*buf
)
640 BSTR pool_entry
= bstr_from_xmlChar(buf
);
642 if (pool_entry
&& !bstr_pool_insert(pool
, pool_entry
))
644 SysFreeString(pool_entry
);
651 static BSTR
pooled_bstr_from_xmlCharN(struct bstrpool
*pool
, const xmlChar
*buf
, int len
)
653 BSTR pool_entry
= bstr_from_xmlCharN(buf
, len
);
655 if (pool_entry
&& !bstr_pool_insert(pool
, pool_entry
))
657 SysFreeString(pool_entry
);
664 static void format_error_message_from_id(saxlocator
*This
, HRESULT hr
)
666 struct saxerrorhandler_iface
*handler
= saxreader_get_errorhandler(This
->saxreader
);
667 xmlStopParser(This
->pParserCtxt
);
670 if (saxreader_has_handler(This
, SAXErrorHandler
))
673 if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM
,
674 NULL
, hr
, 0, msg
, sizeof(msg
), NULL
))
676 FIXME("MSXML errors not yet supported.\n");
680 if(This
->vbInterface
)
682 BSTR bstrMsg
= SysAllocString(msg
);
683 IVBSAXErrorHandler_fatalError(handler
->vbhandler
,
684 &This
->IVBSAXLocator_iface
, &bstrMsg
, hr
);
685 SysFreeString(bstrMsg
);
688 ISAXErrorHandler_fatalError(handler
->handler
,
689 &This
->ISAXLocator_iface
, msg
, hr
);
693 static void update_position(saxlocator
*This
, BOOL fix_column
)
695 const xmlChar
*p
= This
->pParserCtxt
->input
->cur
-1;
697 This
->line
= xmlSAX2GetLineNumber(This
->pParserCtxt
);
701 for(; *p
!='\n' && *p
!='\r' && p
>=This
->pParserCtxt
->input
->base
; p
--)
706 This
->column
= xmlSAX2GetColumnNumber(This
->pParserCtxt
);
710 /*** IVBSAXAttributes interface ***/
711 /*** IUnknown methods ***/
712 static HRESULT WINAPI
ivbsaxattributes_QueryInterface(
713 IVBSAXAttributes
* iface
,
717 saxlocator
*This
= impl_from_IVBSAXAttributes(iface
);
718 TRACE("%p %s %p\n", This
, debugstr_guid(riid
), ppvObject
);
719 return IVBSAXLocator_QueryInterface(&This
->IVBSAXLocator_iface
, riid
, ppvObject
);
722 static ULONG WINAPI
ivbsaxattributes_AddRef(IVBSAXAttributes
* iface
)
724 saxlocator
*This
= impl_from_IVBSAXAttributes(iface
);
725 return ISAXLocator_AddRef(&This
->ISAXLocator_iface
);
728 static ULONG WINAPI
ivbsaxattributes_Release(IVBSAXAttributes
* iface
)
730 saxlocator
*This
= impl_from_IVBSAXAttributes(iface
);
731 return ISAXLocator_Release(&This
->ISAXLocator_iface
);
734 /*** IDispatch methods ***/
735 static HRESULT WINAPI
ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes
*iface
, UINT
* pctinfo
)
737 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
739 TRACE("(%p)->(%p)\n", This
, pctinfo
);
746 static HRESULT WINAPI
ivbsaxattributes_GetTypeInfo(
747 IVBSAXAttributes
*iface
,
748 UINT iTInfo
, LCID lcid
, ITypeInfo
** ppTInfo
)
750 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
753 TRACE("(%p)->(%u %u %p)\n", This
, iTInfo
, lcid
, ppTInfo
);
755 hr
= get_typeinfo(IVBSAXAttributes_tid
, ppTInfo
);
760 static HRESULT WINAPI
ivbsaxattributes_GetIDsOfNames(
761 IVBSAXAttributes
*iface
,
768 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
772 TRACE("(%p)->(%s %p %u %u %p)\n", This
, debugstr_guid(riid
), rgszNames
, cNames
,
775 if(!rgszNames
|| cNames
== 0 || !rgDispId
)
778 hr
= get_typeinfo(IVBSAXAttributes_tid
, &typeinfo
);
781 hr
= ITypeInfo_GetIDsOfNames(typeinfo
, rgszNames
, cNames
, rgDispId
);
782 ITypeInfo_Release(typeinfo
);
788 static HRESULT WINAPI
ivbsaxattributes_Invoke(
789 IVBSAXAttributes
*iface
,
794 DISPPARAMS
* pDispParams
,
796 EXCEPINFO
* pExcepInfo
,
799 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
803 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This
, dispIdMember
, debugstr_guid(riid
),
804 lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
806 hr
= get_typeinfo(IVBSAXAttributes_tid
, &typeinfo
);
809 hr
= ITypeInfo_Invoke(typeinfo
, &This
->IVBSAXAttributes_iface
, dispIdMember
, wFlags
,
810 pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
811 ITypeInfo_Release(typeinfo
);
817 /*** IVBSAXAttributes methods ***/
818 static HRESULT WINAPI
ivbsaxattributes_get_length(
819 IVBSAXAttributes
* iface
,
822 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
823 return ISAXAttributes_getLength(&This
->ISAXAttributes_iface
, nLength
);
826 static HRESULT WINAPI
ivbsaxattributes_getURI(
827 IVBSAXAttributes
* iface
,
832 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
833 return ISAXAttributes_getURI(&This
->ISAXAttributes_iface
, nIndex
, (const WCHAR
**)uri
, &len
);
836 static HRESULT WINAPI
ivbsaxattributes_getLocalName(
837 IVBSAXAttributes
* iface
,
842 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
843 return ISAXAttributes_getLocalName(&This
->ISAXAttributes_iface
, nIndex
,
844 (const WCHAR
**)localName
, &len
);
847 static HRESULT WINAPI
ivbsaxattributes_getQName(
848 IVBSAXAttributes
* iface
,
853 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
854 return ISAXAttributes_getQName(&This
->ISAXAttributes_iface
, nIndex
, (const WCHAR
**)QName
, &len
);
857 static HRESULT WINAPI
ivbsaxattributes_getIndexFromName(
858 IVBSAXAttributes
* iface
,
863 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
864 return ISAXAttributes_getIndexFromName(&This
->ISAXAttributes_iface
, uri
, SysStringLen(uri
),
865 localName
, SysStringLen(localName
), index
);
868 static HRESULT WINAPI
ivbsaxattributes_getIndexFromQName(
869 IVBSAXAttributes
* iface
,
873 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
874 return ISAXAttributes_getIndexFromQName(&This
->ISAXAttributes_iface
, QName
,
875 SysStringLen(QName
), index
);
878 static HRESULT WINAPI
ivbsaxattributes_getType(
879 IVBSAXAttributes
* iface
,
884 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
885 return ISAXAttributes_getType(&This
->ISAXAttributes_iface
, nIndex
, (const WCHAR
**)type
, &len
);
888 static HRESULT WINAPI
ivbsaxattributes_getTypeFromName(
889 IVBSAXAttributes
* iface
,
895 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
896 return ISAXAttributes_getTypeFromName(&This
->ISAXAttributes_iface
, uri
, SysStringLen(uri
),
897 localName
, SysStringLen(localName
), (const WCHAR
**)type
, &len
);
900 static HRESULT WINAPI
ivbsaxattributes_getTypeFromQName(
901 IVBSAXAttributes
* iface
,
906 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
907 return ISAXAttributes_getTypeFromQName(&This
->ISAXAttributes_iface
, QName
, SysStringLen(QName
),
908 (const WCHAR
**)type
, &len
);
911 static HRESULT WINAPI
ivbsaxattributes_getValue(
912 IVBSAXAttributes
* iface
,
917 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
918 return ISAXAttributes_getValue(&This
->ISAXAttributes_iface
, nIndex
, (const WCHAR
**)value
, &len
);
921 static HRESULT WINAPI
ivbsaxattributes_getValueFromName(
922 IVBSAXAttributes
* iface
,
928 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
929 return ISAXAttributes_getValueFromName(&This
->ISAXAttributes_iface
, uri
, SysStringLen(uri
),
930 localName
, SysStringLen(localName
), (const WCHAR
**)value
, &len
);
933 static HRESULT WINAPI
ivbsaxattributes_getValueFromQName(
934 IVBSAXAttributes
* iface
,
939 saxlocator
*This
= impl_from_IVBSAXAttributes( iface
);
940 return ISAXAttributes_getValueFromQName(&This
->ISAXAttributes_iface
, QName
,
941 SysStringLen(QName
), (const WCHAR
**)value
, &len
);
944 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl
=
946 ivbsaxattributes_QueryInterface
,
947 ivbsaxattributes_AddRef
,
948 ivbsaxattributes_Release
,
949 ivbsaxattributes_GetTypeInfoCount
,
950 ivbsaxattributes_GetTypeInfo
,
951 ivbsaxattributes_GetIDsOfNames
,
952 ivbsaxattributes_Invoke
,
953 ivbsaxattributes_get_length
,
954 ivbsaxattributes_getURI
,
955 ivbsaxattributes_getLocalName
,
956 ivbsaxattributes_getQName
,
957 ivbsaxattributes_getIndexFromName
,
958 ivbsaxattributes_getIndexFromQName
,
959 ivbsaxattributes_getType
,
960 ivbsaxattributes_getTypeFromName
,
961 ivbsaxattributes_getTypeFromQName
,
962 ivbsaxattributes_getValue
,
963 ivbsaxattributes_getValueFromName
,
964 ivbsaxattributes_getValueFromQName
967 /*** ISAXAttributes interface ***/
968 /*** IUnknown methods ***/
969 static HRESULT WINAPI
isaxattributes_QueryInterface(
970 ISAXAttributes
* iface
,
974 saxlocator
*This
= impl_from_ISAXAttributes(iface
);
975 TRACE("%p %s %p\n", This
, debugstr_guid(riid
), ppvObject
);
976 return ISAXLocator_QueryInterface(&This
->ISAXLocator_iface
, riid
, ppvObject
);
979 static ULONG WINAPI
isaxattributes_AddRef(ISAXAttributes
* iface
)
981 saxlocator
*This
= impl_from_ISAXAttributes(iface
);
983 return ISAXLocator_AddRef(&This
->ISAXLocator_iface
);
986 static ULONG WINAPI
isaxattributes_Release(ISAXAttributes
* iface
)
988 saxlocator
*This
= impl_from_ISAXAttributes(iface
);
991 return ISAXLocator_Release(&This
->ISAXLocator_iface
);
994 /*** ISAXAttributes methods ***/
995 static HRESULT WINAPI
isaxattributes_getLength(
996 ISAXAttributes
* iface
,
999 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1001 *length
= This
->nb_attributes
;
1002 TRACE("Length set to %d\n", *length
);
1006 static HRESULT WINAPI
isaxattributes_getURI(
1007 ISAXAttributes
* iface
,
1012 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1013 TRACE("(%p)->(%d)\n", This
, index
);
1015 if(index
>= This
->nb_attributes
|| index
< 0) return E_INVALIDARG
;
1016 if(!url
|| !size
) return E_POINTER
;
1018 *size
= SysStringLen(This
->attributes
[index
].szURI
);
1019 *url
= This
->attributes
[index
].szURI
;
1021 TRACE("(%s:%d)\n", debugstr_w(This
->attributes
[index
].szURI
), *size
);
1026 static HRESULT WINAPI
isaxattributes_getLocalName(
1027 ISAXAttributes
* iface
,
1029 const WCHAR
**pLocalName
,
1030 int *pLocalNameLength
)
1032 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1033 TRACE("(%p)->(%d)\n", This
, nIndex
);
1035 if(nIndex
>=This
->nb_attributes
|| nIndex
<0) return E_INVALIDARG
;
1036 if(!pLocalName
|| !pLocalNameLength
) return E_POINTER
;
1038 *pLocalNameLength
= SysStringLen(This
->attributes
[nIndex
].szLocalname
);
1039 *pLocalName
= This
->attributes
[nIndex
].szLocalname
;
1044 static HRESULT WINAPI
isaxattributes_getQName(
1045 ISAXAttributes
* iface
,
1047 const WCHAR
**pQName
,
1050 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1051 TRACE("(%p)->(%d)\n", This
, nIndex
);
1053 if(nIndex
>=This
->nb_attributes
|| nIndex
<0) return E_INVALIDARG
;
1054 if(!pQName
|| !pQNameLength
) return E_POINTER
;
1056 *pQNameLength
= SysStringLen(This
->attributes
[nIndex
].szQName
);
1057 *pQName
= This
->attributes
[nIndex
].szQName
;
1062 static HRESULT WINAPI
isaxattributes_getName(
1063 ISAXAttributes
* iface
,
1067 const WCHAR
**localName
,
1068 int *pLocalNameSize
,
1069 const WCHAR
**QName
,
1072 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1073 TRACE("(%p)->(%d)\n", This
, index
);
1075 if(index
>=This
->nb_attributes
|| index
<0) return E_INVALIDARG
;
1076 if(!uri
|| !pUriLength
|| !localName
|| !pLocalNameSize
1077 || !QName
|| !pQNameLength
) return E_POINTER
;
1079 *pUriLength
= SysStringLen(This
->attributes
[index
].szURI
);
1080 *uri
= This
->attributes
[index
].szURI
;
1081 *pLocalNameSize
= SysStringLen(This
->attributes
[index
].szLocalname
);
1082 *localName
= This
->attributes
[index
].szLocalname
;
1083 *pQNameLength
= SysStringLen(This
->attributes
[index
].szQName
);
1084 *QName
= This
->attributes
[index
].szQName
;
1086 TRACE("(%s, %s, %s)\n", debugstr_w(*uri
), debugstr_w(*localName
), debugstr_w(*QName
));
1091 static HRESULT WINAPI
isaxattributes_getIndexFromName(
1092 ISAXAttributes
* iface
,
1095 const WCHAR
*pLocalName
,
1096 int cocalNameLength
,
1099 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1101 TRACE("(%p)->(%s, %d, %s, %d)\n", This
, debugstr_w(pUri
), cUriLength
,
1102 debugstr_w(pLocalName
), cocalNameLength
);
1104 if(!pUri
|| !pLocalName
|| !index
) return E_POINTER
;
1106 for(i
=0; i
<This
->nb_attributes
; i
++)
1108 if(cUriLength
!=SysStringLen(This
->attributes
[i
].szURI
)
1109 || cocalNameLength
!=SysStringLen(This
->attributes
[i
].szLocalname
))
1111 if(cUriLength
&& memcmp(pUri
, This
->attributes
[i
].szURI
,
1112 sizeof(WCHAR
)*cUriLength
))
1114 if(cocalNameLength
&& memcmp(pLocalName
, This
->attributes
[i
].szLocalname
,
1115 sizeof(WCHAR
)*cocalNameLength
))
1122 return E_INVALIDARG
;
1125 static HRESULT WINAPI
isaxattributes_getIndexFromQName(
1126 ISAXAttributes
* iface
,
1127 const WCHAR
*pQName
,
1131 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1133 TRACE("(%p)->(%s, %d)\n", This
, debugstr_w(pQName
), nQNameLength
);
1135 if(!pQName
|| !index
) return E_POINTER
;
1136 if(!nQNameLength
) return E_INVALIDARG
;
1138 for(i
=0; i
<This
->nb_attributes
; i
++)
1140 if(nQNameLength
!=SysStringLen(This
->attributes
[i
].szQName
)) continue;
1141 if(memcmp(pQName
, This
->attributes
[i
].szQName
, sizeof(WCHAR
)*nQNameLength
)) continue;
1147 return E_INVALIDARG
;
1150 static HRESULT WINAPI
isaxattributes_getType(
1151 ISAXAttributes
* iface
,
1153 const WCHAR
**pType
,
1156 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1158 FIXME("(%p)->(%d) stub\n", This
, nIndex
);
1162 static HRESULT WINAPI
isaxattributes_getTypeFromName(
1163 ISAXAttributes
* iface
,
1166 const WCHAR
*pLocalName
,
1168 const WCHAR
**pType
,
1171 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1173 FIXME("(%p)->(%s, %d, %s, %d) stub\n", This
, debugstr_w(pUri
), nUri
,
1174 debugstr_w(pLocalName
), nLocalName
);
1178 static HRESULT WINAPI
isaxattributes_getTypeFromQName(
1179 ISAXAttributes
* iface
,
1180 const WCHAR
*pQName
,
1182 const WCHAR
**pType
,
1185 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1187 FIXME("(%p)->(%s, %d) stub\n", This
, debugstr_w(pQName
), nQName
);
1191 static HRESULT WINAPI
isaxattributes_getValue(
1192 ISAXAttributes
* iface
,
1194 const WCHAR
**value
,
1197 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1198 TRACE("(%p)->(%d)\n", This
, index
);
1200 if(index
>=This
->nb_attributes
|| index
<0) return E_INVALIDARG
;
1201 if(!value
|| !nValue
) return E_POINTER
;
1203 *nValue
= SysStringLen(This
->attributes
[index
].szValue
);
1204 *value
= This
->attributes
[index
].szValue
;
1206 TRACE("(%s:%d)\n", debugstr_w(*value
), *nValue
);
1211 static HRESULT WINAPI
isaxattributes_getValueFromName(
1212 ISAXAttributes
* iface
,
1215 const WCHAR
*pLocalName
,
1217 const WCHAR
**pValue
,
1222 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1223 TRACE("(%p)->(%s, %d, %s, %d)\n", This
, debugstr_w(pUri
), nUri
,
1224 debugstr_w(pLocalName
), nLocalName
);
1226 hr
= ISAXAttributes_getIndexFromName(iface
,
1227 pUri
, nUri
, pLocalName
, nLocalName
, &index
);
1228 if(hr
==S_OK
) hr
= ISAXAttributes_getValue(iface
, index
, pValue
, nValue
);
1233 static HRESULT WINAPI
isaxattributes_getValueFromQName(
1234 ISAXAttributes
* iface
,
1235 const WCHAR
*pQName
,
1237 const WCHAR
**pValue
,
1242 saxlocator
*This
= impl_from_ISAXAttributes( iface
);
1243 TRACE("(%p)->(%s, %d)\n", This
, debugstr_w(pQName
), nQName
);
1245 hr
= ISAXAttributes_getIndexFromQName(iface
, pQName
, nQName
, &index
);
1246 if(hr
==S_OK
) hr
= ISAXAttributes_getValue(iface
, index
, pValue
, nValue
);
1251 static const struct ISAXAttributesVtbl isaxattributes_vtbl
=
1253 isaxattributes_QueryInterface
,
1254 isaxattributes_AddRef
,
1255 isaxattributes_Release
,
1256 isaxattributes_getLength
,
1257 isaxattributes_getURI
,
1258 isaxattributes_getLocalName
,
1259 isaxattributes_getQName
,
1260 isaxattributes_getName
,
1261 isaxattributes_getIndexFromName
,
1262 isaxattributes_getIndexFromQName
,
1263 isaxattributes_getType
,
1264 isaxattributes_getTypeFromName
,
1265 isaxattributes_getTypeFromQName
,
1266 isaxattributes_getValue
,
1267 isaxattributes_getValueFromName
,
1268 isaxattributes_getValueFromQName
1271 static HRESULT
SAXAttributes_populate(saxlocator
*locator
,
1272 int nb_namespaces
, const xmlChar
**xmlNamespaces
,
1273 int nb_attributes
, const xmlChar
**xmlAttributes
)
1275 static const xmlChar xmlns
[] = "xmlns";
1276 static const WCHAR xmlnsW
[] = { 'x','m','l','n','s',0 };
1278 struct _attributes
*attrs
;
1281 /* skip namespace definitions */
1282 if ((locator
->saxreader
->features
& NamespacePrefixes
) == 0)
1285 locator
->nb_attributes
= nb_namespaces
+ nb_attributes
;
1286 if(locator
->nb_attributes
> locator
->attributesSize
)
1288 attrs
= heap_realloc(locator
->attributes
, sizeof(struct _attributes
)*locator
->nb_attributes
*2);
1291 locator
->nb_attributes
= 0;
1292 return E_OUTOFMEMORY
;
1294 locator
->attributes
= attrs
;
1298 attrs
= locator
->attributes
;
1301 for (i
= 0; i
< nb_namespaces
; i
++)
1303 attrs
[nb_attributes
+i
].szLocalname
= SysAllocStringLen(NULL
, 0);
1304 attrs
[nb_attributes
+i
].szURI
= locator
->namespaceUri
;
1305 attrs
[nb_attributes
+i
].szValue
= bstr_from_xmlChar(xmlNamespaces
[2*i
+1]);
1306 if(!xmlNamespaces
[2*i
])
1307 attrs
[nb_attributes
+i
].szQName
= SysAllocString(xmlnsW
);
1309 attrs
[nb_attributes
+i
].szQName
= QName_from_xmlChar(xmlns
, xmlNamespaces
[2*i
]);
1312 for (i
= 0; i
< nb_attributes
; i
++)
1314 static const xmlChar xmlA
[] = "xml";
1316 if (xmlStrEqual(xmlAttributes
[i
*5+1], xmlA
))
1317 attrs
[i
].szURI
= bstr_from_xmlChar(xmlAttributes
[i
*5+2]);
1319 /* that's an important feature to keep same uri pointer for every reported attribute */
1320 attrs
[i
].szURI
= find_element_uri(locator
, xmlAttributes
[i
*5+2]);
1322 attrs
[i
].szLocalname
= bstr_from_xmlChar(xmlAttributes
[i
*5]);
1323 attrs
[i
].szValue
= bstr_from_xmlCharN(xmlAttributes
[i
*5+3],
1324 xmlAttributes
[i
*5+4]-xmlAttributes
[i
*5+3]);
1325 attrs
[i
].szQName
= QName_from_xmlChar(xmlAttributes
[i
*5+1],
1326 xmlAttributes
[i
*5]);
1332 /*** LibXML callbacks ***/
1333 static void libxmlStartDocument(void *ctx
)
1335 saxlocator
*This
= ctx
;
1336 struct saxcontenthandler_iface
*handler
= saxreader_get_contenthandler(This
->saxreader
);
1339 if (This
->saxreader
->version
>= MSXML4
)
1341 const xmlChar
*p
= This
->pParserCtxt
->input
->cur
-1;
1342 update_position(This
, FALSE
);
1343 while(p
>This
->pParserCtxt
->input
->base
&& *p
!='>')
1345 if(*p
=='\n' || (*p
=='\r' && *(p
+1)!='\n'))
1350 for(; p
>=This
->pParserCtxt
->input
->base
&& *p
!='\n' && *p
!='\r'; p
--)
1354 /* store version value, declaration has to contain version attribute */
1355 if (This
->pParserCtxt
->standalone
!= -1)
1357 SysFreeString(This
->saxreader
->xmldecl_version
);
1358 This
->saxreader
->xmldecl_version
= bstr_from_xmlChar(This
->pParserCtxt
->version
);
1361 if (saxreader_has_handler(This
, SAXContentHandler
))
1363 if(This
->vbInterface
)
1364 hr
= IVBSAXContentHandler_startDocument(handler
->vbhandler
);
1366 hr
= ISAXContentHandler_startDocument(handler
->handler
);
1368 if (sax_callback_failed(This
, hr
))
1369 format_error_message_from_id(This
, hr
);
1373 static void libxmlEndDocument(void *ctx
)
1375 saxlocator
*This
= ctx
;
1376 struct saxcontenthandler_iface
*handler
= saxreader_get_contenthandler(This
->saxreader
);
1379 if (This
->saxreader
->version
>= MSXML4
) {
1380 update_position(This
, FALSE
);
1381 if(This
->column
> 1)
1389 if(This
->ret
!= S_OK
) return;
1391 if (saxreader_has_handler(This
, SAXContentHandler
))
1393 if(This
->vbInterface
)
1394 hr
= IVBSAXContentHandler_endDocument(handler
->vbhandler
);
1396 hr
= ISAXContentHandler_endDocument(handler
->handler
);
1398 if (sax_callback_failed(This
, hr
))
1399 format_error_message_from_id(This
, hr
);
1403 static void libxmlStartElementNS(
1405 const xmlChar
*localname
,
1406 const xmlChar
*prefix
,
1409 const xmlChar
**namespaces
,
1412 const xmlChar
**attributes
)
1414 saxlocator
*This
= ctx
;
1415 struct saxcontenthandler_iface
*handler
= saxreader_get_contenthandler(This
->saxreader
);
1416 element_entry
*element
;
1420 update_position(This
, TRUE
);
1421 if(*(This
->pParserCtxt
->input
->cur
) == '/')
1423 if(This
->saxreader
->version
< MSXML4
)
1426 element
= alloc_element_entry(localname
, prefix
, nb_namespaces
, namespaces
);
1427 push_element_ns(This
, element
);
1429 if (is_namespaces_enabled(This
->saxreader
))
1433 for (i
= 0; i
< nb_namespaces
&& saxreader_has_handler(This
, SAXContentHandler
); i
++)
1435 if (This
->vbInterface
)
1436 hr
= IVBSAXContentHandler_startPrefixMapping(
1438 &element
->ns
[i
].prefix
,
1439 &element
->ns
[i
].uri
);
1441 hr
= ISAXContentHandler_startPrefixMapping(
1443 element
->ns
[i
].prefix
,
1444 SysStringLen(element
->ns
[i
].prefix
),
1446 SysStringLen(element
->ns
[i
].uri
));
1448 if (sax_callback_failed(This
, hr
))
1450 format_error_message_from_id(This
, hr
);
1456 uri
= find_element_uri(This
, URI
);
1457 hr
= SAXAttributes_populate(This
, nb_namespaces
, namespaces
, nb_attributes
, attributes
);
1458 if (hr
== S_OK
&& saxreader_has_handler(This
, SAXContentHandler
))
1462 if (is_namespaces_enabled(This
->saxreader
))
1463 local
= element
->local
;
1467 if (This
->vbInterface
)
1468 hr
= IVBSAXContentHandler_startElement(handler
->vbhandler
,
1469 &uri
, &local
, &element
->qname
, &This
->IVBSAXAttributes_iface
);
1471 hr
= ISAXContentHandler_startElement(handler
->handler
,
1472 uri
, SysStringLen(uri
),
1473 local
, SysStringLen(local
),
1474 element
->qname
, SysStringLen(element
->qname
),
1475 &This
->ISAXAttributes_iface
);
1477 if (sax_callback_failed(This
, hr
))
1478 format_error_message_from_id(This
, hr
);
1482 static void libxmlEndElementNS(
1484 const xmlChar
*localname
,
1485 const xmlChar
*prefix
,
1488 saxlocator
*This
= ctx
;
1489 struct saxcontenthandler_iface
*handler
= saxreader_get_contenthandler(This
->saxreader
);
1490 element_entry
*element
;
1495 update_position(This
, FALSE
);
1496 p
= This
->pParserCtxt
->input
->cur
;
1498 if (This
->saxreader
->version
>= MSXML4
)
1501 while(p
>This
->pParserCtxt
->input
->base
&& *p
!='>')
1503 if(*p
=='\n' || (*p
=='\r' && *(p
+1)!='\n'))
1508 else if(*(p
-1)!='>' || *(p
-2)!='/')
1511 while(p
-2>=This
->pParserCtxt
->input
->base
1512 && *(p
-2)!='<' && *(p
-1)!='/')
1514 if(*p
=='\n' || (*p
=='\r' && *(p
+1)!='\n'))
1520 for(; p
>=This
->pParserCtxt
->input
->base
&& *p
!='\n' && *p
!='\r'; p
--)
1523 uri
= find_element_uri(This
, URI
);
1524 element
= pop_element_ns(This
);
1526 if (!saxreader_has_handler(This
, SAXContentHandler
))
1528 This
->nb_attributes
= 0;
1529 free_element_entry(element
);
1533 if (is_namespaces_enabled(This
->saxreader
))
1534 local
= element
->local
;
1538 if (This
->vbInterface
)
1539 hr
= IVBSAXContentHandler_endElement(
1541 &uri
, &local
, &element
->qname
);
1543 hr
= ISAXContentHandler_endElement(
1545 uri
, SysStringLen(uri
),
1546 local
, SysStringLen(local
),
1547 element
->qname
, SysStringLen(element
->qname
));
1549 This
->nb_attributes
= 0;
1551 if (sax_callback_failed(This
, hr
))
1553 format_error_message_from_id(This
, hr
);
1554 free_element_entry(element
);
1558 if (is_namespaces_enabled(This
->saxreader
))
1561 while (iterate_endprefix_index(This
, element
, &i
) && saxreader_has_handler(This
, SAXContentHandler
))
1563 if (This
->vbInterface
)
1564 hr
= IVBSAXContentHandler_endPrefixMapping(
1565 handler
->vbhandler
, &element
->ns
[i
].prefix
);
1567 hr
= ISAXContentHandler_endPrefixMapping(
1568 handler
->handler
, element
->ns
[i
].prefix
, SysStringLen(element
->ns
[i
].prefix
));
1570 if (sax_callback_failed(This
, hr
)) break;
1573 if (sax_callback_failed(This
, hr
))
1574 format_error_message_from_id(This
, hr
);
1577 free_element_entry(element
);
1580 static void libxmlCharacters(
1585 saxlocator
*This
= ctx
;
1589 BOOL lastEvent
= FALSE
;
1591 if (!saxreader_has_handler(This
, SAXContentHandler
)) return;
1593 update_position(This
, FALSE
);
1594 cur
= (xmlChar
*)This
->pParserCtxt
->input
->cur
;
1595 while(cur
>=This
->pParserCtxt
->input
->base
&& *cur
!='>')
1597 if(*cur
=='\n' || (*cur
=='\r' && *(cur
+1)!='\n'))
1602 for(; cur
>=This
->pParserCtxt
->input
->base
&& *cur
!='\n' && *cur
!='\r'; cur
--)
1606 if(*(ch
-1)=='\r') cur
--;
1611 while(end
-ch
<len
&& *end
!='\r') end
++;
1622 if (This
->saxreader
->version
>= MSXML4
)
1626 for(p
=cur
; p
!=end
; p
++)
1643 Chars
= pooled_bstr_from_xmlCharN(&This
->saxreader
->pool
, cur
, end
-cur
);
1644 hr
= saxreader_saxcharacters(This
, Chars
);
1646 if (sax_callback_failed(This
, hr
))
1648 format_error_message_from_id(This
, hr
);
1652 if (This
->saxreader
->version
< MSXML4
)
1653 This
->column
+= end
-cur
;
1666 if(end
-ch
== len
) break;
1670 static void libxmlSetDocumentLocator(
1672 xmlSAXLocatorPtr loc
)
1674 saxlocator
*This
= ctx
;
1675 struct saxcontenthandler_iface
*handler
= saxreader_get_contenthandler(This
->saxreader
);
1678 if (saxreader_has_handler(This
, SAXContentHandler
))
1680 if(This
->vbInterface
)
1681 hr
= IVBSAXContentHandler_putref_documentLocator(handler
->vbhandler
,
1682 &This
->IVBSAXLocator_iface
);
1684 hr
= ISAXContentHandler_putDocumentLocator(handler
->handler
, &This
->ISAXLocator_iface
);
1688 format_error_message_from_id(This
, hr
);
1691 static void libxmlComment(void *ctx
, const xmlChar
*value
)
1693 saxlocator
*This
= ctx
;
1694 struct saxlexicalhandler_iface
*handler
= saxreader_get_lexicalhandler(This
->saxreader
);
1697 const xmlChar
*p
= This
->pParserCtxt
->input
->cur
;
1699 update_position(This
, FALSE
);
1700 while(p
-4>=This
->pParserCtxt
->input
->base
1701 && memcmp(p
-4, "<!--", sizeof(char[4])))
1703 if(*p
=='\n' || (*p
=='\r' && *(p
+1)!='\n'))
1709 for(; p
>=This
->pParserCtxt
->input
->base
&& *p
!='\n' && *p
!='\r'; p
--)
1712 if (!saxreader_has_handler(This
, SAXLexicalHandler
)) return;
1714 bValue
= pooled_bstr_from_xmlChar(&This
->saxreader
->pool
, value
);
1716 if (This
->vbInterface
)
1717 hr
= IVBSAXLexicalHandler_comment(handler
->vbhandler
, &bValue
);
1719 hr
= ISAXLexicalHandler_comment(handler
->handler
, bValue
, SysStringLen(bValue
));
1722 format_error_message_from_id(This
, hr
);
1725 static void libxmlFatalError(void *ctx
, const char *msg
, ...)
1727 saxlocator
*This
= ctx
;
1728 struct saxerrorhandler_iface
*handler
= saxreader_get_errorhandler(This
->saxreader
);
1734 if(This
->ret
!= S_OK
) {
1735 xmlStopParser(This
->pParserCtxt
);
1739 va_start(args
, msg
);
1740 vsprintf(message
, msg
, args
);
1743 len
= MultiByteToWideChar(CP_UNIXCP
, 0, message
, -1, NULL
, 0);
1744 error
= heap_alloc(sizeof(WCHAR
)*len
);
1747 MultiByteToWideChar(CP_UNIXCP
, 0, message
, -1, error
, len
);
1748 TRACE("fatal error for %p: %s\n", This
, debugstr_w(error
));
1751 if (!saxreader_has_handler(This
, SAXErrorHandler
))
1753 xmlStopParser(This
->pParserCtxt
);
1759 FIXME("Error handling is not compatible.\n");
1761 if(This
->vbInterface
)
1763 BSTR bstrError
= SysAllocString(error
);
1764 IVBSAXErrorHandler_fatalError(handler
->vbhandler
, &This
->IVBSAXLocator_iface
,
1765 &bstrError
, E_FAIL
);
1766 SysFreeString(bstrError
);
1769 ISAXErrorHandler_fatalError(handler
->handler
, &This
->ISAXLocator_iface
, error
, E_FAIL
);
1773 xmlStopParser(This
->pParserCtxt
);
1777 /* The only reason this helper exists is that CDATA section are reported by chunks,
1778 newlines are used as delimiter. More than that, reader even alters input data before reporting.
1780 This helper should be called for substring with trailing newlines.
1782 static BSTR
saxreader_get_cdata_chunk(const xmlChar
*str
, int len
)
1784 BSTR bstr
= bstr_from_xmlCharN(str
, len
), ret
;
1787 ptr
= bstr
+ len
- 1;
1788 while ((*ptr
== '\r' || *ptr
== '\n') && ptr
>= bstr
)
1793 /* replace returns as:
1795 - "\r<char>" -> "\n<char>"
1801 if (*(ptr
+1) == '\r' || *(ptr
+1) == '\n')
1804 memmove(ptr
, ptr
+1, len
-- - (ptr
-bstr
));
1811 ret
= SysAllocStringLen(bstr
, len
);
1812 SysFreeString(bstr
);
1816 static void libxml_cdatablock(void *ctx
, const xmlChar
*value
, int len
)
1818 const xmlChar
*start
, *end
;
1819 saxlocator
*locator
= ctx
;
1820 struct saxlexicalhandler_iface
*lexical
= saxreader_get_lexicalhandler(locator
->saxreader
);
1825 update_position(locator
, FALSE
);
1826 if (saxreader_has_handler(locator
, SAXLexicalHandler
))
1828 if (locator
->vbInterface
)
1829 hr
= IVBSAXLexicalHandler_startCDATA(lexical
->vbhandler
);
1831 hr
= ISAXLexicalHandler_startCDATA(lexical
->handler
);
1836 format_error_message_from_id(locator
, hr
);
1846 /* scan for newlines */
1847 if (value
[i
] == '\r' || value
[i
] == '\n')
1849 /* skip newlines/linefeeds */
1852 if (value
[i
] != '\r' && value
[i
] != '\n') break;
1858 chars
= saxreader_get_cdata_chunk(start
, end
-start
);
1859 TRACE("(chunk %s)\n", debugstr_w(chars
));
1860 hr
= saxreader_saxcharacters(locator
, chars
);
1861 SysFreeString(chars
);
1870 /* no newline chars (or last chunk) report as a whole */
1871 if (!end
&& start
== value
)
1874 chars
= bstr_from_xmlCharN(start
, len
-(start
-value
));
1875 TRACE("(%s)\n", debugstr_w(chars
));
1876 hr
= saxreader_saxcharacters(locator
, chars
);
1877 SysFreeString(chars
);
1880 if (saxreader_has_handler(locator
, SAXLexicalHandler
))
1882 if (locator
->vbInterface
)
1883 hr
= IVBSAXLexicalHandler_endCDATA(lexical
->vbhandler
);
1885 hr
= ISAXLexicalHandler_endCDATA(lexical
->handler
);
1889 format_error_message_from_id(locator
, hr
);
1892 static xmlParserInputPtr
libxmlresolveentity(void *ctx
, const xmlChar
*publicid
, const xmlChar
*systemid
)
1894 FIXME("entity resolving not implemented, %s, %s\n", publicid
, systemid
);
1895 return xmlSAX2ResolveEntity(ctx
, publicid
, systemid
);
1898 /*** IVBSAXLocator interface ***/
1899 /*** IUnknown methods ***/
1900 static HRESULT WINAPI
ivbsaxlocator_QueryInterface(IVBSAXLocator
* iface
, REFIID riid
, void **ppvObject
)
1902 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1904 TRACE("%p %s %p\n", This
, debugstr_guid( riid
), ppvObject
);
1908 if ( IsEqualGUID( riid
, &IID_IUnknown
) ||
1909 IsEqualGUID( riid
, &IID_IDispatch
) ||
1910 IsEqualGUID( riid
, &IID_IVBSAXLocator
))
1914 else if ( IsEqualGUID( riid
, &IID_IVBSAXAttributes
))
1916 *ppvObject
= &This
->IVBSAXAttributes_iface
;
1920 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
1921 return E_NOINTERFACE
;
1924 IVBSAXLocator_AddRef( iface
);
1929 static ULONG WINAPI
ivbsaxlocator_AddRef(IVBSAXLocator
* iface
)
1931 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1932 TRACE("%p\n", This
);
1933 return InterlockedIncrement( &This
->ref
);
1936 static ULONG WINAPI
ivbsaxlocator_Release(
1937 IVBSAXLocator
* iface
)
1939 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1940 return ISAXLocator_Release((ISAXLocator
*)&This
->IVBSAXLocator_iface
);
1943 /*** IDispatch methods ***/
1944 static HRESULT WINAPI
ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator
*iface
, UINT
* pctinfo
)
1946 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1948 TRACE("(%p)->(%p)\n", This
, pctinfo
);
1955 static HRESULT WINAPI
ivbsaxlocator_GetTypeInfo(
1956 IVBSAXLocator
*iface
,
1957 UINT iTInfo
, LCID lcid
, ITypeInfo
** ppTInfo
)
1959 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1962 TRACE("(%p)->(%u %u %p)\n", This
, iTInfo
, lcid
, ppTInfo
);
1964 hr
= get_typeinfo(IVBSAXLocator_tid
, ppTInfo
);
1969 static HRESULT WINAPI
ivbsaxlocator_GetIDsOfNames(
1970 IVBSAXLocator
*iface
,
1972 LPOLESTR
* rgszNames
,
1977 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
1978 ITypeInfo
*typeinfo
;
1981 TRACE("(%p)->(%s %p %u %u %p)\n", This
, debugstr_guid(riid
), rgszNames
, cNames
,
1984 if(!rgszNames
|| cNames
== 0 || !rgDispId
)
1985 return E_INVALIDARG
;
1987 hr
= get_typeinfo(IVBSAXLocator_tid
, &typeinfo
);
1990 hr
= ITypeInfo_GetIDsOfNames(typeinfo
, rgszNames
, cNames
, rgDispId
);
1991 ITypeInfo_Release(typeinfo
);
1997 static HRESULT WINAPI
ivbsaxlocator_Invoke(
1998 IVBSAXLocator
*iface
,
1999 DISPID dispIdMember
,
2003 DISPPARAMS
* pDispParams
,
2004 VARIANT
* pVarResult
,
2005 EXCEPINFO
* pExcepInfo
,
2008 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
2009 ITypeInfo
*typeinfo
;
2012 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This
, dispIdMember
, debugstr_guid(riid
),
2013 lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
2015 hr
= get_typeinfo(IVBSAXLocator_tid
, &typeinfo
);
2018 hr
= ITypeInfo_Invoke(typeinfo
, &This
->IVBSAXLocator_iface
, dispIdMember
, wFlags
,
2019 pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
2020 ITypeInfo_Release(typeinfo
);
2026 /*** IVBSAXLocator methods ***/
2027 static HRESULT WINAPI
ivbsaxlocator_get_columnNumber(
2028 IVBSAXLocator
* iface
,
2031 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
2032 return ISAXLocator_getColumnNumber((ISAXLocator
*)&This
->IVBSAXLocator_iface
, pnColumn
);
2035 static HRESULT WINAPI
ivbsaxlocator_get_lineNumber(
2036 IVBSAXLocator
* iface
,
2039 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
2040 return ISAXLocator_getLineNumber((ISAXLocator
*)&This
->IVBSAXLocator_iface
, pnLine
);
2043 static HRESULT WINAPI
ivbsaxlocator_get_publicId(
2044 IVBSAXLocator
* iface
,
2047 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
2048 return ISAXLocator_getPublicId((ISAXLocator
*)&This
->IVBSAXLocator_iface
,
2049 (const WCHAR
**)publicId
);
2052 static HRESULT WINAPI
ivbsaxlocator_get_systemId(
2053 IVBSAXLocator
* iface
,
2056 saxlocator
*This
= impl_from_IVBSAXLocator( iface
);
2057 return ISAXLocator_getSystemId((ISAXLocator
*)&This
->IVBSAXLocator_iface
,
2058 (const WCHAR
**)systemId
);
2061 static const struct IVBSAXLocatorVtbl VBSAXLocatorVtbl
=
2063 ivbsaxlocator_QueryInterface
,
2064 ivbsaxlocator_AddRef
,
2065 ivbsaxlocator_Release
,
2066 ivbsaxlocator_GetTypeInfoCount
,
2067 ivbsaxlocator_GetTypeInfo
,
2068 ivbsaxlocator_GetIDsOfNames
,
2069 ivbsaxlocator_Invoke
,
2070 ivbsaxlocator_get_columnNumber
,
2071 ivbsaxlocator_get_lineNumber
,
2072 ivbsaxlocator_get_publicId
,
2073 ivbsaxlocator_get_systemId
2076 /*** ISAXLocator interface ***/
2077 /*** IUnknown methods ***/
2078 static HRESULT WINAPI
isaxlocator_QueryInterface(ISAXLocator
* iface
, REFIID riid
, void **ppvObject
)
2080 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2082 TRACE("%p %s %p\n", This
, debugstr_guid( riid
), ppvObject
);
2086 if ( IsEqualGUID( riid
, &IID_IUnknown
) ||
2087 IsEqualGUID( riid
, &IID_ISAXLocator
))
2091 else if ( IsEqualGUID( riid
, &IID_ISAXAttributes
))
2093 *ppvObject
= &This
->ISAXAttributes_iface
;
2097 WARN("interface %s not implemented\n", debugstr_guid(riid
));
2098 return E_NOINTERFACE
;
2101 ISAXLocator_AddRef( iface
);
2106 static ULONG WINAPI
isaxlocator_AddRef(ISAXLocator
* iface
)
2108 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2109 ULONG ref
= InterlockedIncrement( &This
->ref
);
2110 TRACE("(%p)->(%d)\n", This
, ref
);
2114 static ULONG WINAPI
isaxlocator_Release(
2117 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2118 LONG ref
= InterlockedDecrement( &This
->ref
);
2120 TRACE("(%p)->(%d)\n", This
, ref
);
2124 element_entry
*element
, *element2
;
2127 SysFreeString(This
->publicId
);
2128 SysFreeString(This
->systemId
);
2129 SysFreeString(This
->namespaceUri
);
2131 for(index
=0; index
<This
->nb_attributes
; index
++)
2133 SysFreeString(This
->attributes
[index
].szLocalname
);
2134 SysFreeString(This
->attributes
[index
].szValue
);
2135 SysFreeString(This
->attributes
[index
].szQName
);
2137 heap_free(This
->attributes
);
2140 LIST_FOR_EACH_ENTRY_SAFE(element
, element2
, &This
->elements
, element_entry
, entry
)
2142 list_remove(&element
->entry
);
2143 free_element_entry(element
);
2146 ISAXXMLReader_Release(&This
->saxreader
->ISAXXMLReader_iface
);
2153 /*** ISAXLocator methods ***/
2154 static HRESULT WINAPI
isaxlocator_getColumnNumber(
2158 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2160 *pnColumn
= This
->column
;
2164 static HRESULT WINAPI
isaxlocator_getLineNumber(
2168 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2170 *pnLine
= This
->line
;
2174 static HRESULT WINAPI
isaxlocator_getPublicId(
2176 const WCHAR
** ppwchPublicId
)
2179 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2181 SysFreeString(This
->publicId
);
2183 publicId
= bstr_from_xmlChar(xmlSAX2GetPublicId(This
->pParserCtxt
));
2184 if(SysStringLen(publicId
))
2185 This
->publicId
= publicId
;
2188 SysFreeString(publicId
);
2189 This
->publicId
= NULL
;
2192 *ppwchPublicId
= This
->publicId
;
2196 static HRESULT WINAPI
isaxlocator_getSystemId(
2198 const WCHAR
** ppwchSystemId
)
2201 saxlocator
*This
= impl_from_ISAXLocator( iface
);
2203 SysFreeString(This
->systemId
);
2205 systemId
= bstr_from_xmlChar(xmlSAX2GetSystemId(This
->pParserCtxt
));
2206 if(SysStringLen(systemId
))
2207 This
->systemId
= systemId
;
2210 SysFreeString(systemId
);
2211 This
->systemId
= NULL
;
2214 *ppwchSystemId
= This
->systemId
;
2218 static const struct ISAXLocatorVtbl SAXLocatorVtbl
=
2220 isaxlocator_QueryInterface
,
2222 isaxlocator_Release
,
2223 isaxlocator_getColumnNumber
,
2224 isaxlocator_getLineNumber
,
2225 isaxlocator_getPublicId
,
2226 isaxlocator_getSystemId
2229 static HRESULT
SAXLocator_create(saxreader
*reader
, saxlocator
**ppsaxlocator
, BOOL vbInterface
)
2231 static const WCHAR w3xmlns
[] = { 'h','t','t','p',':','/','/', 'w','w','w','.','w','3','.',
2232 'o','r','g','/','2','0','0','0','/','x','m','l','n','s','/',0 };
2234 saxlocator
*locator
;
2236 locator
= heap_alloc( sizeof (*locator
) );
2238 return E_OUTOFMEMORY
;
2240 locator
->IVBSAXLocator_iface
.lpVtbl
= &VBSAXLocatorVtbl
;
2241 locator
->ISAXLocator_iface
.lpVtbl
= &SAXLocatorVtbl
;
2242 locator
->IVBSAXAttributes_iface
.lpVtbl
= &ivbsaxattributes_vtbl
;
2243 locator
->ISAXAttributes_iface
.lpVtbl
= &isaxattributes_vtbl
;
2245 locator
->vbInterface
= vbInterface
;
2247 locator
->saxreader
= reader
;
2248 ISAXXMLReader_AddRef(&reader
->ISAXXMLReader_iface
);
2250 locator
->pParserCtxt
= NULL
;
2251 locator
->publicId
= NULL
;
2252 locator
->systemId
= NULL
;
2253 locator
->line
= reader
->version
< MSXML4
? 0 : 1;
2254 locator
->column
= 0;
2255 locator
->ret
= S_OK
;
2256 if (locator
->saxreader
->version
>= MSXML6
)
2257 locator
->namespaceUri
= SysAllocString(w3xmlns
);
2259 locator
->namespaceUri
= SysAllocStringLen(NULL
, 0);
2260 if(!locator
->namespaceUri
)
2262 ISAXXMLReader_Release(&reader
->ISAXXMLReader_iface
);
2264 return E_OUTOFMEMORY
;
2267 locator
->attributesSize
= 8;
2268 locator
->nb_attributes
= 0;
2269 locator
->attributes
= heap_alloc(sizeof(struct _attributes
)*locator
->attributesSize
);
2270 if(!locator
->attributes
)
2272 ISAXXMLReader_Release(&reader
->ISAXXMLReader_iface
);
2273 SysFreeString(locator
->namespaceUri
);
2275 return E_OUTOFMEMORY
;
2278 list_init(&locator
->elements
);
2280 *ppsaxlocator
= locator
;
2282 TRACE("returning %p\n", *ppsaxlocator
);
2287 /*** SAXXMLReader internal functions ***/
2288 static HRESULT
internal_parseBuffer(saxreader
*This
, const char *buffer
, int size
, BOOL vbInterface
)
2290 xmlCharEncoding encoding
= XML_CHAR_ENCODING_NONE
;
2291 xmlChar
*enc_name
= NULL
;
2292 saxlocator
*locator
;
2295 TRACE("(%p)->(%p %d)\n", This
, buffer
, size
);
2297 hr
= SAXLocator_create(This
, &locator
, vbInterface
);
2303 const unsigned char *buff
= (unsigned char*)buffer
;
2305 encoding
= xmlDetectCharEncoding((xmlChar
*)buffer
, 4);
2306 enc_name
= (xmlChar
*)xmlGetCharEncodingName(encoding
);
2307 TRACE("detected encoding: %s\n", enc_name
);
2308 /* skip BOM, parser won't switch encodings and so won't skip it on its own */
2309 if ((encoding
== XML_CHAR_ENCODING_UTF8
) &&
2310 buff
[0] == 0xEF && buff
[1] == 0xBB && buff
[2] == 0xBF)
2317 /* if libxml2 detection failed try to guess */
2318 if (encoding
== XML_CHAR_ENCODING_NONE
)
2320 const WCHAR
*ptr
= (WCHAR
*)buffer
;
2321 /* xml declaration with possibly specfied encoding will be still handled by parser */
2322 if ((size
>= 2) && *ptr
== '<' && ptr
[1] != '?')
2324 enc_name
= (xmlChar
*)xmlGetCharEncodingName(XML_CHAR_ENCODING_UTF16LE
);
2325 encoding
= XML_CHAR_ENCODING_UTF16LE
;
2328 else if (encoding
== XML_CHAR_ENCODING_UTF8
)
2329 enc_name
= (xmlChar
*)xmlGetCharEncodingName(encoding
);
2333 locator
->pParserCtxt
= xmlCreateMemoryParserCtxt(buffer
, size
);
2334 if (!locator
->pParserCtxt
)
2336 ISAXLocator_Release(&locator
->ISAXLocator_iface
);
2342 locator
->pParserCtxt
->encoding
= xmlStrdup(enc_name
);
2343 if (encoding
== XML_CHAR_ENCODING_UTF16LE
) {
2344 TRACE("switching to %s\n", enc_name
);
2345 xmlSwitchEncoding(locator
->pParserCtxt
, encoding
);
2349 xmlFree(locator
->pParserCtxt
->sax
);
2350 locator
->pParserCtxt
->sax
= &locator
->saxreader
->sax
;
2351 locator
->pParserCtxt
->userData
= locator
;
2353 This
->isParsing
= TRUE
;
2354 if(xmlParseDocument(locator
->pParserCtxt
) == -1 && locator
->ret
== S_OK
)
2358 This
->isParsing
= FALSE
;
2360 if(locator
->pParserCtxt
)
2362 locator
->pParserCtxt
->sax
= NULL
;
2363 xmlFreeParserCtxt(locator
->pParserCtxt
);
2364 locator
->pParserCtxt
= NULL
;
2367 ISAXLocator_Release(&locator
->ISAXLocator_iface
);
2371 static HRESULT
internal_parseStream(saxreader
*This
, ISequentialStream
*stream
, BOOL vbInterface
)
2373 saxlocator
*locator
;
2380 hr
= ISequentialStream_Read(stream
, data
, sizeof(data
), &dataRead
);
2381 if(FAILED(hr
)) return hr
;
2383 hr
= SAXLocator_create(This
, &locator
, vbInterface
);
2384 if(FAILED(hr
)) return hr
;
2386 locator
->pParserCtxt
= xmlCreatePushParserCtxt(
2387 &locator
->saxreader
->sax
, locator
,
2388 data
, dataRead
, NULL
);
2389 if(!locator
->pParserCtxt
)
2391 ISAXLocator_Release(&locator
->ISAXLocator_iface
);
2395 This
->isParsing
= TRUE
;
2397 if(dataRead
!= sizeof(data
))
2399 ret
= xmlParseChunk(locator
->pParserCtxt
, data
, 0, 1);
2400 hr
= ret
!=XML_ERR_OK
&& locator
->ret
==S_OK
? E_FAIL
: locator
->ret
;
2407 hr
= ISequentialStream_Read(stream
, data
, sizeof(data
), &dataRead
);
2408 if (FAILED(hr
)) break;
2410 ret
= xmlParseChunk(locator
->pParserCtxt
, data
, dataRead
, 0);
2411 hr
= ret
!=XML_ERR_OK
&& locator
->ret
==S_OK
? E_FAIL
: locator
->ret
;
2413 if (hr
!= S_OK
) break;
2415 if (dataRead
!= sizeof(data
))
2417 ret
= xmlParseChunk(locator
->pParserCtxt
, data
, 0, 1);
2418 hr
= ret
!=XML_ERR_OK
&& locator
->ret
==S_OK
? E_FAIL
: locator
->ret
;
2424 This
->isParsing
= FALSE
;
2426 xmlFreeParserCtxt(locator
->pParserCtxt
);
2427 locator
->pParserCtxt
= NULL
;
2428 ISAXLocator_Release(&locator
->ISAXLocator_iface
);
2432 static HRESULT
internal_parse(
2439 TRACE("(%p)->(%s)\n", This
, debugstr_variant(&varInput
));
2441 /* Dispose of the BSTRs in the pool from a prior run, if any. */
2442 free_bstr_pool(&This
->pool
);
2444 switch(V_VT(&varInput
))
2447 hr
= internal_parseBuffer(This
, (const char*)V_BSTR(&varInput
),
2448 strlenW(V_BSTR(&varInput
))*sizeof(WCHAR
), vbInterface
);
2450 case VT_ARRAY
|VT_UI1
: {
2452 LONG lBound
, uBound
;
2455 hr
= SafeArrayGetLBound(V_ARRAY(&varInput
), 1, &lBound
);
2456 if(hr
!= S_OK
) break;
2457 hr
= SafeArrayGetUBound(V_ARRAY(&varInput
), 1, &uBound
);
2458 if(hr
!= S_OK
) break;
2459 dataRead
= (uBound
-lBound
)*SafeArrayGetElemsize(V_ARRAY(&varInput
));
2460 hr
= SafeArrayAccessData(V_ARRAY(&varInput
), &pSAData
);
2461 if(hr
!= S_OK
) break;
2462 hr
= internal_parseBuffer(This
, pSAData
, dataRead
, vbInterface
);
2463 SafeArrayUnaccessData(V_ARRAY(&varInput
));
2468 IPersistStream
*persistStream
;
2469 ISequentialStream
*stream
= NULL
;
2470 IXMLDOMDocument
*xmlDoc
;
2472 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput
),
2473 &IID_IXMLDOMDocument
, (void**)&xmlDoc
) == S_OK
)
2477 IXMLDOMDocument_get_xml(xmlDoc
, &bstrData
);
2478 hr
= internal_parseBuffer(This
, (const char*)bstrData
,
2479 SysStringByteLen(bstrData
), vbInterface
);
2480 IXMLDOMDocument_Release(xmlDoc
);
2481 SysFreeString(bstrData
);
2485 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput
),
2486 &IID_IPersistStream
, (void**)&persistStream
) == S_OK
)
2488 IStream
*stream_copy
;
2490 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream_copy
);
2493 IPersistStream_Release(persistStream
);
2497 hr
= IPersistStream_Save(persistStream
, stream_copy
, TRUE
);
2498 IPersistStream_Release(persistStream
);
2500 IStream_QueryInterface(stream_copy
, &IID_ISequentialStream
, (void**)&stream
);
2502 IStream_Release(stream_copy
);
2505 /* try base interface first */
2508 IUnknown_QueryInterface(V_UNKNOWN(&varInput
), &IID_ISequentialStream
, (void**)&stream
);
2510 /* this should never happen if IStream is implemented properly, but just in case */
2511 IUnknown_QueryInterface(V_UNKNOWN(&varInput
), &IID_IStream
, (void**)&stream
);
2516 hr
= internal_parseStream(This
, stream
, vbInterface
);
2517 ISequentialStream_Release(stream
);
2521 WARN("IUnknown* input doesn't support any of expected interfaces\n");
2528 WARN("vt %d not implemented\n", V_VT(&varInput
));
2535 static HRESULT
internal_vbonDataAvailable(void *obj
, char *ptr
, DWORD len
)
2537 saxreader
*This
= obj
;
2539 return internal_parseBuffer(This
, ptr
, len
, TRUE
);
2542 static HRESULT
internal_onDataAvailable(void *obj
, char *ptr
, DWORD len
)
2544 saxreader
*This
= obj
;
2546 return internal_parseBuffer(This
, ptr
, len
, FALSE
);
2549 static HRESULT
internal_parseURL(
2558 TRACE("(%p)->(%s)\n", This
, debugstr_w(url
));
2560 hr
= create_moniker_from_url(url
, &mon
);
2564 if(vbInterface
) hr
= bind_url(mon
, internal_vbonDataAvailable
, This
, &bsc
);
2565 else hr
= bind_url(mon
, internal_onDataAvailable
, This
, &bsc
);
2566 IMoniker_Release(mon
);
2571 return detach_bsc(bsc
);
2574 static HRESULT
internal_putProperty(
2580 TRACE("(%p)->(%s %s)\n", This
, debugstr_w(prop
), debugstr_variant(&value
));
2582 if(!memcmp(prop
, PropertyDeclHandlerW
, sizeof(PropertyDeclHandlerW
)))
2584 if(This
->isParsing
) return E_FAIL
;
2586 switch (V_VT(&value
))
2589 saxreader_put_handler(This
, SAXDeclHandler
, NULL
, vbInterface
);
2593 IUnknown
*handler
= NULL
;
2595 if (V_UNKNOWN(&value
))
2600 hr
= IUnknown_QueryInterface(V_UNKNOWN(&value
), &IID_IVBSAXDeclHandler
, (void**)&handler
);
2602 hr
= IUnknown_QueryInterface(V_UNKNOWN(&value
), &IID_ISAXDeclHandler
, (void**)&handler
);
2603 if (FAILED(hr
)) return hr
;
2606 saxreader_put_handler(This
, SAXDeclHandler
, handler
, vbInterface
);
2607 if (handler
) IUnknown_Release(handler
);
2611 return E_INVALIDARG
;
2617 if(!memcmp(prop
, PropertyLexicalHandlerW
, sizeof(PropertyLexicalHandlerW
)))
2619 if(This
->isParsing
) return E_FAIL
;
2621 switch (V_VT(&value
))
2624 saxreader_put_handler(This
, SAXLexicalHandler
, NULL
, vbInterface
);
2628 IUnknown
*handler
= NULL
;
2630 if (V_UNKNOWN(&value
))
2635 hr
= IUnknown_QueryInterface(V_UNKNOWN(&value
), &IID_IVBSAXLexicalHandler
, (void**)&handler
);
2637 hr
= IUnknown_QueryInterface(V_UNKNOWN(&value
), &IID_ISAXLexicalHandler
, (void**)&handler
);
2638 if (FAILED(hr
)) return hr
;
2641 saxreader_put_handler(This
, SAXLexicalHandler
, handler
, vbInterface
);
2642 if (handler
) IUnknown_Release(handler
);
2646 return E_INVALIDARG
;
2652 if(!memcmp(prop
, PropertyMaxXMLSizeW
, sizeof(PropertyMaxXMLSizeW
)))
2654 if (V_VT(&value
) == VT_I4
&& V_I4(&value
) == 0) return S_OK
;
2655 FIXME("(%p)->(%s): max-xml-size unsupported\n", This
, debugstr_variant(&value
));
2659 if(!memcmp(prop
, PropertyMaxElementDepthW
, sizeof(PropertyMaxElementDepthW
)))
2661 if (V_VT(&value
) == VT_I4
&& V_I4(&value
) == 0) return S_OK
;
2662 FIXME("(%p)->(%s): max-element-depth unsupported\n", This
, debugstr_variant(&value
));
2666 FIXME("(%p)->(%s:%s): unsupported property\n", This
, debugstr_w(prop
), debugstr_variant(&value
));
2668 if(!memcmp(prop
, PropertyCharsetW
, sizeof(PropertyCharsetW
)))
2671 if(!memcmp(prop
, PropertyDomNodeW
, sizeof(PropertyDomNodeW
)))
2674 if(!memcmp(prop
, PropertyInputSourceW
, sizeof(PropertyInputSourceW
)))
2677 if(!memcmp(prop
, PropertySchemaDeclHandlerW
, sizeof(PropertySchemaDeclHandlerW
)))
2680 if(!memcmp(prop
, PropertyXMLDeclEncodingW
, sizeof(PropertyXMLDeclEncodingW
)))
2683 if(!memcmp(prop
, PropertyXMLDeclStandaloneW
, sizeof(PropertyXMLDeclStandaloneW
)))
2686 if(!memcmp(prop
, PropertyXMLDeclVersionW
, sizeof(PropertyXMLDeclVersionW
)))
2689 return E_INVALIDARG
;
2692 static HRESULT
internal_getProperty(const saxreader
* This
, const WCHAR
*prop
, VARIANT
*value
, BOOL vb
)
2694 TRACE("(%p)->(%s)\n", This
, debugstr_w(prop
));
2696 if (!value
) return E_POINTER
;
2698 if (!memcmp(PropertyLexicalHandlerW
, prop
, sizeof(PropertyLexicalHandlerW
)))
2700 V_VT(value
) = VT_UNKNOWN
;
2701 saxreader_get_handler(This
, SAXLexicalHandler
, vb
, (void**)&V_UNKNOWN(value
));
2705 if (!memcmp(PropertyDeclHandlerW
, prop
, sizeof(PropertyDeclHandlerW
)))
2707 V_VT(value
) = VT_UNKNOWN
;
2708 saxreader_get_handler(This
, SAXDeclHandler
, vb
, (void**)&V_UNKNOWN(value
));
2712 if (!memcmp(PropertyXmlDeclVersionW
, prop
, sizeof(PropertyXmlDeclVersionW
)))
2714 V_VT(value
) = VT_BSTR
;
2715 V_BSTR(value
) = SysAllocString(This
->xmldecl_version
);
2719 FIXME("(%p)->(%s) unsupported property\n", This
, debugstr_w(prop
));
2724 /*** IVBSAXXMLReader interface ***/
2725 /*** IUnknown methods ***/
2726 static HRESULT WINAPI
saxxmlreader_QueryInterface(IVBSAXXMLReader
* iface
, REFIID riid
, void **ppvObject
)
2728 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2730 TRACE("%p %s %p\n", This
, debugstr_guid( riid
), ppvObject
);
2734 if ( IsEqualGUID( riid
, &IID_IUnknown
) ||
2735 IsEqualGUID( riid
, &IID_IDispatch
) ||
2736 IsEqualGUID( riid
, &IID_IVBSAXXMLReader
))
2740 else if( IsEqualGUID( riid
, &IID_ISAXXMLReader
))
2742 *ppvObject
= &This
->ISAXXMLReader_iface
;
2744 else if (dispex_query_interface(&This
->dispex
, riid
, ppvObject
))
2746 return *ppvObject
? S_OK
: E_NOINTERFACE
;
2750 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
2751 return E_NOINTERFACE
;
2754 IVBSAXXMLReader_AddRef( iface
);
2759 static ULONG WINAPI
saxxmlreader_AddRef(IVBSAXXMLReader
* iface
)
2761 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2762 TRACE("%p\n", This
);
2763 return InterlockedIncrement( &This
->ref
);
2766 static ULONG WINAPI
saxxmlreader_Release(
2767 IVBSAXXMLReader
* iface
)
2769 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2772 TRACE("%p\n", This
);
2774 ref
= InterlockedDecrement( &This
->ref
);
2779 for (i
= 0; i
< SAXHandler_Last
; i
++)
2781 struct saxanyhandler_iface
*iface
= &This
->saxhandlers
[i
].u
.anyhandler
;
2784 IUnknown_Release(iface
->handler
);
2786 if (iface
->vbhandler
)
2787 IUnknown_Release(iface
->vbhandler
);
2790 SysFreeString(This
->xmldecl_version
);
2791 free_bstr_pool(&This
->pool
);
2793 release_dispex(&This
->dispex
);
2800 static HRESULT WINAPI
saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader
*iface
, UINT
* pctinfo
)
2802 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2803 return IDispatchEx_GetTypeInfoCount(&This
->dispex
.IDispatchEx_iface
, pctinfo
);
2806 static HRESULT WINAPI
saxxmlreader_GetTypeInfo(
2807 IVBSAXXMLReader
*iface
,
2808 UINT iTInfo
, LCID lcid
, ITypeInfo
** ppTInfo
)
2810 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2811 return IDispatchEx_GetTypeInfo(&This
->dispex
.IDispatchEx_iface
,
2812 iTInfo
, lcid
, ppTInfo
);
2815 static HRESULT WINAPI
saxxmlreader_GetIDsOfNames(
2816 IVBSAXXMLReader
*iface
,
2818 LPOLESTR
* rgszNames
,
2823 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2824 return IDispatchEx_GetIDsOfNames(&This
->dispex
.IDispatchEx_iface
,
2825 riid
, rgszNames
, cNames
, lcid
, rgDispId
);
2828 static HRESULT WINAPI
saxxmlreader_Invoke(
2829 IVBSAXXMLReader
*iface
,
2830 DISPID dispIdMember
,
2834 DISPPARAMS
* pDispParams
,
2835 VARIANT
* pVarResult
,
2836 EXCEPINFO
* pExcepInfo
,
2839 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2840 return IDispatchEx_Invoke(&This
->dispex
.IDispatchEx_iface
,
2841 dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
2844 /*** IVBSAXXMLReader methods ***/
2845 static HRESULT WINAPI
saxxmlreader_getFeature(
2846 IVBSAXXMLReader
* iface
,
2847 const WCHAR
*feature_name
,
2848 VARIANT_BOOL
*value
)
2850 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2851 saxreader_feature feature
;
2853 TRACE("(%p)->(%s %p)\n", This
, debugstr_w(feature_name
), value
);
2855 feature
= get_saxreader_feature(feature_name
);
2856 if (feature
== Namespaces
|| feature
== NamespacePrefixes
)
2857 return get_feature_value(This
, feature
, value
);
2859 FIXME("(%p)->(%s %p) stub\n", This
, debugstr_w(feature_name
), value
);
2863 static HRESULT WINAPI
saxxmlreader_putFeature(
2864 IVBSAXXMLReader
* iface
,
2865 const WCHAR
*feature_name
,
2868 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2869 saxreader_feature feature
;
2871 TRACE("(%p)->(%s %x)\n", This
, debugstr_w(feature_name
), value
);
2873 feature
= get_saxreader_feature(feature_name
);
2875 /* accepted cases */
2876 if ((feature
== ExternalGeneralEntities
&& value
== VARIANT_FALSE
) ||
2877 (feature
== ExternalParameterEntities
&& value
== VARIANT_FALSE
) ||
2878 feature
== Namespaces
||
2879 feature
== NamespacePrefixes
)
2881 return set_feature_value(This
, feature
, value
);
2884 if (feature
== LexicalHandlerParEntities
|| feature
== ProhibitDTD
)
2886 FIXME("(%p)->(%s %x) stub\n", This
, debugstr_w(feature_name
), value
);
2887 return set_feature_value(This
, feature
, value
);
2890 FIXME("(%p)->(%s %x) stub\n", This
, debugstr_w(feature_name
), value
);
2894 static HRESULT WINAPI
saxxmlreader_getProperty(
2895 IVBSAXXMLReader
* iface
,
2899 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2900 return internal_getProperty(This
, prop
, value
, TRUE
);
2903 static HRESULT WINAPI
saxxmlreader_putProperty(
2904 IVBSAXXMLReader
* iface
,
2908 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2909 return internal_putProperty(This
, pProp
, value
, TRUE
);
2912 static HRESULT WINAPI
saxxmlreader_get_entityResolver(
2913 IVBSAXXMLReader
* iface
,
2914 IVBSAXEntityResolver
**resolver
)
2916 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2917 return saxreader_get_handler(This
, SAXEntityResolver
, TRUE
, (void**)resolver
);
2920 static HRESULT WINAPI
saxxmlreader_put_entityResolver(
2921 IVBSAXXMLReader
* iface
,
2922 IVBSAXEntityResolver
*resolver
)
2924 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2925 return saxreader_put_handler(This
, SAXEntityResolver
, resolver
, TRUE
);
2928 static HRESULT WINAPI
saxxmlreader_get_contentHandler(
2929 IVBSAXXMLReader
* iface
,
2930 IVBSAXContentHandler
**handler
)
2932 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2933 return saxreader_get_handler(This
, SAXContentHandler
, TRUE
, (void**)handler
);
2936 static HRESULT WINAPI
saxxmlreader_put_contentHandler(
2937 IVBSAXXMLReader
* iface
,
2938 IVBSAXContentHandler
*handler
)
2940 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2941 return saxreader_put_handler(This
, SAXContentHandler
, handler
, TRUE
);
2944 static HRESULT WINAPI
saxxmlreader_get_dtdHandler(
2945 IVBSAXXMLReader
* iface
,
2946 IVBSAXDTDHandler
**handler
)
2948 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2949 return saxreader_get_handler(This
, SAXDTDHandler
, TRUE
, (void**)handler
);
2952 static HRESULT WINAPI
saxxmlreader_put_dtdHandler(
2953 IVBSAXXMLReader
* iface
,
2954 IVBSAXDTDHandler
*handler
)
2956 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2957 return saxreader_put_handler(This
, SAXDTDHandler
, handler
, TRUE
);
2960 static HRESULT WINAPI
saxxmlreader_get_errorHandler(
2961 IVBSAXXMLReader
* iface
,
2962 IVBSAXErrorHandler
**handler
)
2964 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2965 return saxreader_get_handler(This
, SAXErrorHandler
, TRUE
, (void**)handler
);
2968 static HRESULT WINAPI
saxxmlreader_put_errorHandler(
2969 IVBSAXXMLReader
* iface
,
2970 IVBSAXErrorHandler
*handler
)
2972 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2973 return saxreader_put_handler(This
, SAXErrorHandler
, handler
, TRUE
);
2976 static HRESULT WINAPI
saxxmlreader_get_baseURL(
2977 IVBSAXXMLReader
* iface
,
2978 const WCHAR
**pBaseUrl
)
2980 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2982 FIXME("(%p)->(%p) stub\n", This
, pBaseUrl
);
2986 static HRESULT WINAPI
saxxmlreader_put_baseURL(
2987 IVBSAXXMLReader
* iface
,
2988 const WCHAR
*pBaseUrl
)
2990 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
2992 FIXME("(%p)->(%s) stub\n", This
, debugstr_w(pBaseUrl
));
2996 static HRESULT WINAPI
saxxmlreader_get_secureBaseURL(
2997 IVBSAXXMLReader
* iface
,
2998 const WCHAR
**pSecureBaseUrl
)
3000 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
3002 FIXME("(%p)->(%p) stub\n", This
, pSecureBaseUrl
);
3007 static HRESULT WINAPI
saxxmlreader_put_secureBaseURL(
3008 IVBSAXXMLReader
* iface
,
3009 const WCHAR
*secureBaseUrl
)
3011 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
3013 FIXME("(%p)->(%s) stub\n", This
, debugstr_w(secureBaseUrl
));
3017 static HRESULT WINAPI
saxxmlreader_parse(
3018 IVBSAXXMLReader
* iface
,
3021 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
3022 return internal_parse(This
, varInput
, TRUE
);
3025 static HRESULT WINAPI
saxxmlreader_parseURL(
3026 IVBSAXXMLReader
* iface
,
3029 saxreader
*This
= impl_from_IVBSAXXMLReader( iface
);
3030 return internal_parseURL(This
, url
, TRUE
);
3033 static const struct IVBSAXXMLReaderVtbl VBSAXXMLReaderVtbl
=
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
,
3059 saxxmlreader_parseURL
3062 /*** ISAXXMLReader interface ***/
3063 /*** IUnknown methods ***/
3064 static HRESULT WINAPI
isaxxmlreader_QueryInterface(ISAXXMLReader
* iface
, REFIID riid
, void **ppvObject
)
3066 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3067 return saxxmlreader_QueryInterface(&This
->IVBSAXXMLReader_iface
, riid
, ppvObject
);
3070 static ULONG WINAPI
isaxxmlreader_AddRef(ISAXXMLReader
* iface
)
3072 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3073 return saxxmlreader_AddRef(&This
->IVBSAXXMLReader_iface
);
3076 static ULONG WINAPI
isaxxmlreader_Release(ISAXXMLReader
* iface
)
3078 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3079 return saxxmlreader_Release(&This
->IVBSAXXMLReader_iface
);
3082 /*** ISAXXMLReader methods ***/
3083 static HRESULT WINAPI
isaxxmlreader_getFeature(
3084 ISAXXMLReader
* iface
,
3085 const WCHAR
*pFeature
,
3086 VARIANT_BOOL
*pValue
)
3088 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3089 return IVBSAXXMLReader_getFeature(&This
->IVBSAXXMLReader_iface
, pFeature
, pValue
);
3092 static HRESULT WINAPI
isaxxmlreader_putFeature(
3093 ISAXXMLReader
* iface
,
3094 const WCHAR
*pFeature
,
3095 VARIANT_BOOL vfValue
)
3097 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3098 return IVBSAXXMLReader_putFeature(&This
->IVBSAXXMLReader_iface
, pFeature
, vfValue
);
3101 static HRESULT WINAPI
isaxxmlreader_getProperty(
3102 ISAXXMLReader
* iface
,
3106 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3107 return internal_getProperty(This
, prop
, value
, FALSE
);
3110 static HRESULT WINAPI
isaxxmlreader_putProperty(
3111 ISAXXMLReader
* iface
,
3115 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3116 return internal_putProperty(This
, pProp
, value
, FALSE
);
3119 static HRESULT WINAPI
isaxxmlreader_getEntityResolver(
3120 ISAXXMLReader
* iface
,
3121 ISAXEntityResolver
**resolver
)
3123 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3124 return saxreader_get_handler(This
, SAXEntityResolver
, FALSE
, (void**)resolver
);
3127 static HRESULT WINAPI
isaxxmlreader_putEntityResolver(
3128 ISAXXMLReader
* iface
,
3129 ISAXEntityResolver
*resolver
)
3131 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3132 return saxreader_put_handler(This
, SAXEntityResolver
, resolver
, FALSE
);
3135 static HRESULT WINAPI
isaxxmlreader_getContentHandler(
3136 ISAXXMLReader
* iface
,
3137 ISAXContentHandler
**handler
)
3139 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3140 return saxreader_get_handler(This
, SAXContentHandler
, FALSE
, (void**)handler
);
3143 static HRESULT WINAPI
isaxxmlreader_putContentHandler(
3144 ISAXXMLReader
* iface
,
3145 ISAXContentHandler
*handler
)
3147 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3148 return saxreader_put_handler(This
, SAXContentHandler
, handler
, FALSE
);
3151 static HRESULT WINAPI
isaxxmlreader_getDTDHandler(
3152 ISAXXMLReader
* iface
,
3153 ISAXDTDHandler
**handler
)
3155 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3156 return saxreader_get_handler(This
, SAXDTDHandler
, FALSE
, (void**)handler
);
3159 static HRESULT WINAPI
isaxxmlreader_putDTDHandler(
3160 ISAXXMLReader
* iface
,
3161 ISAXDTDHandler
*handler
)
3163 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3164 return saxreader_put_handler(This
, SAXDTDHandler
, handler
, FALSE
);
3167 static HRESULT WINAPI
isaxxmlreader_getErrorHandler(
3168 ISAXXMLReader
* iface
,
3169 ISAXErrorHandler
**handler
)
3171 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3172 return saxreader_get_handler(This
, SAXErrorHandler
, FALSE
, (void**)handler
);
3175 static HRESULT WINAPI
isaxxmlreader_putErrorHandler(ISAXXMLReader
* iface
, ISAXErrorHandler
*handler
)
3177 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3178 return saxreader_put_handler(This
, SAXErrorHandler
, handler
, FALSE
);
3181 static HRESULT WINAPI
isaxxmlreader_getBaseURL(
3182 ISAXXMLReader
* iface
,
3183 const WCHAR
**pBaseUrl
)
3185 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3186 return IVBSAXXMLReader_get_baseURL(&This
->IVBSAXXMLReader_iface
, pBaseUrl
);
3189 static HRESULT WINAPI
isaxxmlreader_putBaseURL(
3190 ISAXXMLReader
* iface
,
3191 const WCHAR
*pBaseUrl
)
3193 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3194 return IVBSAXXMLReader_put_baseURL(&This
->IVBSAXXMLReader_iface
, pBaseUrl
);
3197 static HRESULT WINAPI
isaxxmlreader_getSecureBaseURL(
3198 ISAXXMLReader
* iface
,
3199 const WCHAR
**pSecureBaseUrl
)
3201 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3202 return IVBSAXXMLReader_get_secureBaseURL(&This
->IVBSAXXMLReader_iface
, pSecureBaseUrl
);
3205 static HRESULT WINAPI
isaxxmlreader_putSecureBaseURL(
3206 ISAXXMLReader
* iface
,
3207 const WCHAR
*secureBaseUrl
)
3209 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3210 return IVBSAXXMLReader_put_secureBaseURL(&This
->IVBSAXXMLReader_iface
, secureBaseUrl
);
3213 static HRESULT WINAPI
isaxxmlreader_parse(
3214 ISAXXMLReader
* iface
,
3217 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3218 return internal_parse(This
, varInput
, FALSE
);
3221 static HRESULT WINAPI
isaxxmlreader_parseURL(
3222 ISAXXMLReader
* iface
,
3225 saxreader
*This
= impl_from_ISAXXMLReader( iface
);
3226 return internal_parseURL(This
, url
, FALSE
);
3229 static const struct ISAXXMLReaderVtbl SAXXMLReaderVtbl
=
3231 isaxxmlreader_QueryInterface
,
3232 isaxxmlreader_AddRef
,
3233 isaxxmlreader_Release
,
3234 isaxxmlreader_getFeature
,
3235 isaxxmlreader_putFeature
,
3236 isaxxmlreader_getProperty
,
3237 isaxxmlreader_putProperty
,
3238 isaxxmlreader_getEntityResolver
,
3239 isaxxmlreader_putEntityResolver
,
3240 isaxxmlreader_getContentHandler
,
3241 isaxxmlreader_putContentHandler
,
3242 isaxxmlreader_getDTDHandler
,
3243 isaxxmlreader_putDTDHandler
,
3244 isaxxmlreader_getErrorHandler
,
3245 isaxxmlreader_putErrorHandler
,
3246 isaxxmlreader_getBaseURL
,
3247 isaxxmlreader_putBaseURL
,
3248 isaxxmlreader_getSecureBaseURL
,
3249 isaxxmlreader_putSecureBaseURL
,
3250 isaxxmlreader_parse
,
3251 isaxxmlreader_parseURL
3254 static const tid_t saxreader_iface_tids
[] = {
3255 IVBSAXXMLReader_tid
,
3258 static dispex_static_data_t saxreader_dispex
= {
3260 IVBSAXXMLReader_tid
,
3262 saxreader_iface_tids
3265 HRESULT
SAXXMLReader_create(MSXML_VERSION version
, IUnknown
*outer
, LPVOID
*ppObj
)
3269 TRACE("(%p, %p)\n", outer
, ppObj
);
3271 reader
= heap_alloc( sizeof (*reader
) );
3273 return E_OUTOFMEMORY
;
3275 reader
->IVBSAXXMLReader_iface
.lpVtbl
= &VBSAXXMLReaderVtbl
;
3276 reader
->ISAXXMLReader_iface
.lpVtbl
= &SAXXMLReaderVtbl
;
3278 memset(reader
->saxhandlers
, 0, sizeof(reader
->saxhandlers
));
3279 reader
->isParsing
= FALSE
;
3280 reader
->xmldecl_version
= NULL
;
3281 reader
->pool
.pool
= NULL
;
3282 reader
->pool
.index
= 0;
3283 reader
->pool
.len
= 0;
3284 reader
->features
= Namespaces
| NamespacePrefixes
;
3285 reader
->version
= version
;
3287 init_dispex(&reader
->dispex
, (IUnknown
*)&reader
->IVBSAXXMLReader_iface
, &saxreader_dispex
);
3289 memset(&reader
->sax
, 0, sizeof(xmlSAXHandler
));
3290 reader
->sax
.initialized
= XML_SAX2_MAGIC
;
3291 reader
->sax
.startDocument
= libxmlStartDocument
;
3292 reader
->sax
.endDocument
= libxmlEndDocument
;
3293 reader
->sax
.startElementNs
= libxmlStartElementNS
;
3294 reader
->sax
.endElementNs
= libxmlEndElementNS
;
3295 reader
->sax
.characters
= libxmlCharacters
;
3296 reader
->sax
.setDocumentLocator
= libxmlSetDocumentLocator
;
3297 reader
->sax
.comment
= libxmlComment
;
3298 reader
->sax
.error
= libxmlFatalError
;
3299 reader
->sax
.fatalError
= libxmlFatalError
;
3300 reader
->sax
.cdataBlock
= libxml_cdatablock
;
3301 reader
->sax
.resolveEntity
= libxmlresolveentity
;
3303 *ppObj
= &reader
->IVBSAXXMLReader_iface
;
3305 TRACE("returning iface %p\n", *ppObj
);
3312 HRESULT
SAXXMLReader_create(MSXML_VERSION version
, IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
3314 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
3315 "libxml2 support was not present at compile time.\n");