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
27 # include <libxml/parser.h>
28 # include <libxml/xmlerror.h>
29 # include <libxml/SAX2.h>
30 # include <libxml/parserInternals.h>
44 #include "wine/debug.h"
46 #include "msxml_private.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
54 ExhaustiveErrors = 1 << 1,
55 ExternalGeneralEntities = 1 << 2,
56 ExternalParameterEntities = 1 << 3,
57 ForcedResync = 1 << 4,
58 NamespacePrefixes = 1 << 5,
60 ParameterEntities = 1 << 7,
61 PreserveSystemIndentifiers = 1 << 8,
63 SchemaValidation = 1 << 10,
64 ServerHttpRequest = 1 << 11,
65 SuppressValidationfatalError = 1 << 12,
66 UseInlineSchema = 1 << 13,
67 UseSchemaLocation = 1 << 14,
68 LexicalHandlerParEntities = 1 << 15
78 typedef struct _saxreader
80 IVBSAXXMLReader IVBSAXXMLReader_iface;
81 ISAXXMLReader ISAXXMLReader_iface;
83 struct ISAXContentHandler *contentHandler;
84 struct IVBSAXContentHandler *vbcontentHandler;
85 struct ISAXErrorHandler *errorHandler;
86 struct IVBSAXErrorHandler *vberrorHandler;
87 struct ISAXLexicalHandler *lexicalHandler;
88 struct IVBSAXLexicalHandler *vblexicalHandler;
89 struct ISAXDeclHandler *declHandler;
90 struct IVBSAXDeclHandler *vbdeclHandler;
94 enum ReaderFeatures features;
97 typedef struct _saxlocator
99 IVBSAXLocator IVBSAXLocator_iface;
100 ISAXLocator ISAXLocator_iface;
102 saxreader *saxreader;
104 xmlParserCtxtPtr pParserCtxt;
118 typedef struct _saxattributes
120 IVBSAXAttributes IVBSAXAttributes_iface;
121 ISAXAttributes ISAXAttributes_iface;
130 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
132 return CONTAINING_RECORD(iface, saxreader, IVBSAXXMLReader_iface);
135 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
137 return CONTAINING_RECORD(iface, saxreader, ISAXXMLReader_iface);
140 static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
142 return CONTAINING_RECORD(iface, saxlocator, IVBSAXLocator_iface);
145 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
147 return CONTAINING_RECORD(iface, saxlocator, ISAXLocator_iface);
150 static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
152 return CONTAINING_RECORD(iface, saxattributes, IVBSAXAttributes_iface);
155 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
157 return CONTAINING_RECORD(iface, saxattributes, ISAXAttributes_iface);
161 static const WCHAR PropertyCharsetW[] = {
162 'c','h','a','r','s','e','t',0
164 static const WCHAR PropertyDeclHandlerW[] = {
165 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
166 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
167 'd','e','c','l','a','r','a','t','i','o','n',
168 '-','h','a','n','d','l','e','r',0
170 static const WCHAR PropertyDomNodeW[] = {
171 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
172 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
173 'd','o','m','-','n','o','d','e',0
175 static const WCHAR PropertyInputSourceW[] = {
176 'i','n','p','u','t','-','s','o','u','r','c','e',0
178 static const WCHAR PropertyLexicalHandlerW[] = {
179 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
180 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
181 'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
183 static const WCHAR PropertyMaxElementDepthW[] = {
184 'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
186 static const WCHAR PropertyMaxXMLSizeW[] = {
187 'm','a','x','-','x','m','l','-','s','i','z','e',0
189 static const WCHAR PropertySchemaDeclHandlerW[] = {
190 's','c','h','e','m','a','-','d','e','c','l','a','r','a','t','i','o','n','-',
191 'h','a','n','d','l','e','r',0
193 static const WCHAR PropertyXMLDeclEncodingW[] = {
194 'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
196 static const WCHAR PropertyXMLDeclStandaloneW[] = {
197 'x','m','l','d','e','c','l','-','s','t','a','n','d','a','l','o','n','e',0
199 static const WCHAR PropertyXMLDeclVersionW[] = {
200 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
204 static const WCHAR FeatureExternalGeneralEntitiesW[] = {
205 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/',
206 'f','e','a','t','u','r','e','s','/','e','x','t','e','r','n','a','l','-','g','e','n','e','r','a','l',
207 '-','e','n','t','i','t','i','e','s',0
210 static const WCHAR FeatureExternalParameterEntitiesW[] = {
211 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
212 '/','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
215 static const WCHAR FeatureLexicalHandlerParEntitiesW[] = {
216 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/','s','a','x','/','f','e','a','t','u','r','e','s',
217 '/','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
220 static inline HRESULT set_feature_value(saxreader *reader, enum ReaderFeatures feature, VARIANT_BOOL value)
222 if (value == VARIANT_TRUE)
223 reader->features |= feature;
225 reader->features &= ~feature;
230 static inline BOOL has_content_handler(const saxlocator *locator)
232 return (locator->vbInterface && locator->saxreader->vbcontentHandler) ||
233 (!locator->vbInterface && locator->saxreader->contentHandler);
236 static inline BOOL has_error_handler(const saxlocator *locator)
238 return (locator->vbInterface && locator->saxreader->vberrorHandler) ||
239 (!locator->vbInterface && locator->saxreader->errorHandler);
242 static HRESULT namespacePush(saxlocator *locator, int ns)
244 if(locator->nsStackLast>=locator->nsStackSize)
248 new_stack = HeapReAlloc(GetProcessHeap(), 0,
249 locator->nsStack, sizeof(int)*locator->nsStackSize*2);
250 if(!new_stack) return E_OUTOFMEMORY;
251 locator->nsStack = new_stack;
252 locator->nsStackSize *= 2;
254 locator->nsStack[locator->nsStackLast++] = ns;
259 static int namespacePop(saxlocator *locator)
261 if(locator->nsStackLast == 0) return 0;
262 return locator->nsStack[--locator->nsStackLast];
265 static BOOL bstr_pool_insert(struct bstrpool *pool, BSTR pool_entry)
269 pool->pool = HeapAlloc(GetProcessHeap(), 0, 16 * sizeof(*pool->pool));
276 else if (pool->index == pool->len)
278 BSTR *realloc = HeapReAlloc(GetProcessHeap(), 0, pool->pool, pool->len * 2 * sizeof(*realloc));
283 pool->pool = realloc;
287 pool->pool[pool->index++] = pool_entry;
291 static void free_bstr_pool(struct bstrpool *pool)
295 for (i = 0; i < pool->index; i++)
296 SysFreeString(pool->pool[i]);
298 HeapFree(GetProcessHeap(), 0, pool->pool);
301 pool->index = pool->len = 0;
304 static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
312 dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
313 if(len != -1) dLen++;
314 bstr = SysAllocStringLen(NULL, dLen-1);
317 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, bstr, dLen);
318 if(len != -1) bstr[dLen-1] = '\0';
323 static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
328 if(!name) return NULL;
330 if(!prefix || !*prefix)
331 return bstr_from_xmlChar(name);
333 qname = xmlBuildQName(name, prefix, NULL, 0);
334 bstr = bstr_from_xmlChar(qname);
340 static BSTR pooled_bstr_from_xmlChar(struct bstrpool *pool, const xmlChar *buf)
342 BSTR pool_entry = bstr_from_xmlChar(buf);
344 if (pool_entry && !bstr_pool_insert(pool, pool_entry))
346 SysFreeString(pool_entry);
353 static BSTR pooled_bstr_from_xmlCharN(struct bstrpool *pool, const xmlChar *buf, int len)
355 BSTR pool_entry = bstr_from_xmlCharN(buf, len);
357 if (pool_entry && !bstr_pool_insert(pool, pool_entry))
359 SysFreeString(pool_entry);
366 static BSTR pooled_QName_from_xmlChar(struct bstrpool *pool, const xmlChar *prefix, const xmlChar *name)
368 BSTR pool_entry = QName_from_xmlChar(prefix, name);
370 if (pool_entry && !bstr_pool_insert(pool, pool_entry))
372 SysFreeString(pool_entry);
379 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
381 xmlStopParser(This->pParserCtxt);
384 if(has_error_handler(This))
387 if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
388 NULL, hr, 0, msg, sizeof(msg), NULL))
390 FIXME("MSXML errors not yet supported.\n");
394 if(This->vbInterface)
396 BSTR bstrMsg = SysAllocString(msg);
397 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
398 &This->IVBSAXLocator_iface, &bstrMsg, hr);
399 SysFreeString(bstrMsg);
402 ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
403 &This->ISAXLocator_iface, msg, hr);
407 static void update_position(saxlocator *This, xmlChar *end)
409 if(This->lastCur == NULL)
411 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
413 This->realColumn = 1;
415 else if(This->lastCur < This->pParserCtxt->input->base)
417 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
419 This->realColumn = 1;
422 if(This->pParserCtxt->input->cur<This->lastCur)
424 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
426 This->realColumn = 1;
429 if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
431 while(This->lastCur < end)
433 if(*(This->lastCur) == '\n')
436 This->realColumn = 1;
438 else if(*(This->lastCur) == '\r' &&
439 (This->lastCur==This->pParserCtxt->input->end ||
440 *(This->lastCur+1)!='\n'))
443 This->realColumn = 1;
445 else This->realColumn++;
449 /* Count multibyte UTF8 encoded characters once */
450 while((*(This->lastCur)&0xC0) == 0x80) This->lastCur++;
453 This->line = This->realLine;
454 This->column = This->realColumn;
457 /*** IVBSAXAttributes interface ***/
458 /*** IUnknown methods ***/
459 static HRESULT WINAPI ivbsaxattributes_QueryInterface(
460 IVBSAXAttributes* iface,
464 saxattributes *This = impl_from_IVBSAXAttributes(iface);
466 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
470 if (IsEqualGUID(riid, &IID_IUnknown) ||
471 IsEqualGUID(riid, &IID_IDispatch) ||
472 IsEqualGUID(riid, &IID_IVBSAXAttributes))
478 FIXME("interface %s not implemented\n", debugstr_guid(riid));
479 return E_NOINTERFACE;
482 IVBSAXAttributes_AddRef(iface);
487 static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
489 saxattributes *This = impl_from_IVBSAXAttributes(iface);
490 return ISAXAttributes_AddRef(&This->ISAXAttributes_iface);
493 static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
495 saxattributes *This = impl_from_IVBSAXAttributes(iface);
496 return ISAXAttributes_Release(&This->ISAXAttributes_iface);
499 /*** IDispatch methods ***/
500 static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
502 saxattributes *This = impl_from_IVBSAXAttributes( iface );
504 TRACE("(%p)->(%p)\n", This, pctinfo);
511 static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
512 IVBSAXAttributes *iface,
513 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
515 saxattributes *This = impl_from_IVBSAXAttributes( iface );
518 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
520 hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
525 static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
526 IVBSAXAttributes *iface,
533 saxattributes *This = impl_from_IVBSAXAttributes( iface );
537 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
540 if(!rgszNames || cNames == 0 || !rgDispId)
543 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
546 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
547 ITypeInfo_Release(typeinfo);
553 static HRESULT WINAPI ivbsaxattributes_Invoke(
554 IVBSAXAttributes *iface,
559 DISPPARAMS* pDispParams,
561 EXCEPINFO* pExcepInfo,
564 saxattributes *This = impl_from_IVBSAXAttributes( iface );
568 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
569 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
571 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
574 hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXAttributes_iface, dispIdMember, wFlags,
575 pDispParams, pVarResult, pExcepInfo, puArgErr);
576 ITypeInfo_Release(typeinfo);
582 /*** IVBSAXAttributes methods ***/
583 static HRESULT WINAPI ivbsaxattributes_get_length(
584 IVBSAXAttributes* iface,
587 saxattributes *This = impl_from_IVBSAXAttributes( iface );
588 return ISAXAttributes_getLength(&This->ISAXAttributes_iface, nLength);
591 static HRESULT WINAPI ivbsaxattributes_getURI(
592 IVBSAXAttributes* iface,
597 saxattributes *This = impl_from_IVBSAXAttributes( iface );
598 return ISAXAttributes_getURI(&This->ISAXAttributes_iface, nIndex, (const WCHAR**)uri, &len);
601 static HRESULT WINAPI ivbsaxattributes_getLocalName(
602 IVBSAXAttributes* iface,
607 saxattributes *This = impl_from_IVBSAXAttributes( iface );
608 return ISAXAttributes_getLocalName(&This->ISAXAttributes_iface, nIndex,
609 (const WCHAR**)localName, &len);
612 static HRESULT WINAPI ivbsaxattributes_getQName(
613 IVBSAXAttributes* iface,
618 saxattributes *This = impl_from_IVBSAXAttributes( iface );
619 return ISAXAttributes_getQName(&This->ISAXAttributes_iface, nIndex, (const WCHAR**)QName, &len);
622 static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
623 IVBSAXAttributes* iface,
628 saxattributes *This = impl_from_IVBSAXAttributes( iface );
629 return ISAXAttributes_getIndexFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
630 localName, SysStringLen(localName), index);
633 static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
634 IVBSAXAttributes* iface,
638 saxattributes *This = impl_from_IVBSAXAttributes( iface );
639 return ISAXAttributes_getIndexFromQName(&This->ISAXAttributes_iface, QName,
640 SysStringLen(QName), index);
643 static HRESULT WINAPI ivbsaxattributes_getType(
644 IVBSAXAttributes* iface,
649 saxattributes *This = impl_from_IVBSAXAttributes( iface );
650 return ISAXAttributes_getType(&This->ISAXAttributes_iface, nIndex, (const WCHAR**)type, &len);
653 static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
654 IVBSAXAttributes* iface,
660 saxattributes *This = impl_from_IVBSAXAttributes( iface );
661 return ISAXAttributes_getTypeFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
662 localName, SysStringLen(localName), (const WCHAR**)type, &len);
665 static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
666 IVBSAXAttributes* iface,
671 saxattributes *This = impl_from_IVBSAXAttributes( iface );
672 return ISAXAttributes_getTypeFromQName(&This->ISAXAttributes_iface, QName, SysStringLen(QName),
673 (const WCHAR**)type, &len);
676 static HRESULT WINAPI ivbsaxattributes_getValue(
677 IVBSAXAttributes* iface,
682 saxattributes *This = impl_from_IVBSAXAttributes( iface );
683 return ISAXAttributes_getValue(&This->ISAXAttributes_iface, nIndex, (const WCHAR**)value, &len);
686 static HRESULT WINAPI ivbsaxattributes_getValueFromName(
687 IVBSAXAttributes* iface,
693 saxattributes *This = impl_from_IVBSAXAttributes( iface );
694 return ISAXAttributes_getValueFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
695 localName, SysStringLen(localName), (const WCHAR**)value, &len);
698 static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
699 IVBSAXAttributes* iface,
704 saxattributes *This = impl_from_IVBSAXAttributes( iface );
705 return ISAXAttributes_getValueFromQName(&This->ISAXAttributes_iface, QName,
706 SysStringLen(QName), (const WCHAR**)value, &len);
709 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
711 ivbsaxattributes_QueryInterface,
712 ivbsaxattributes_AddRef,
713 ivbsaxattributes_Release,
714 ivbsaxattributes_GetTypeInfoCount,
715 ivbsaxattributes_GetTypeInfo,
716 ivbsaxattributes_GetIDsOfNames,
717 ivbsaxattributes_Invoke,
718 ivbsaxattributes_get_length,
719 ivbsaxattributes_getURI,
720 ivbsaxattributes_getLocalName,
721 ivbsaxattributes_getQName,
722 ivbsaxattributes_getIndexFromName,
723 ivbsaxattributes_getIndexFromQName,
724 ivbsaxattributes_getType,
725 ivbsaxattributes_getTypeFromName,
726 ivbsaxattributes_getTypeFromQName,
727 ivbsaxattributes_getValue,
728 ivbsaxattributes_getValueFromName,
729 ivbsaxattributes_getValueFromQName
732 /*** ISAXAttributes interface ***/
733 /*** IUnknown methods ***/
734 static HRESULT WINAPI isaxattributes_QueryInterface(
735 ISAXAttributes* iface,
739 saxattributes *This = impl_from_ISAXAttributes(iface);
741 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
745 if (IsEqualGUID(riid, &IID_IUnknown) ||
746 IsEqualGUID(riid, &IID_ISAXAttributes))
752 FIXME("interface %s not implemented\n", debugstr_guid(riid));
753 return E_NOINTERFACE;
756 ISAXAttributes_AddRef(iface);
761 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
763 saxattributes *This = impl_from_ISAXAttributes(iface);
765 return InterlockedIncrement(&This->ref);
768 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
770 saxattributes *This = impl_from_ISAXAttributes(iface);
775 ref = InterlockedDecrement(&This->ref);
779 for(index=0; index<This->nb_attributes; index++)
781 SysFreeString(This->szLocalname[index]);
782 SysFreeString(This->szURI[index]);
783 SysFreeString(This->szValue[index]);
784 SysFreeString(This->szQName[index]);
787 heap_free(This->szLocalname);
788 heap_free(This->szURI);
789 heap_free(This->szValue);
790 heap_free(This->szQName);
798 /*** ISAXAttributes methods ***/
799 static HRESULT WINAPI isaxattributes_getLength(
800 ISAXAttributes* iface,
803 saxattributes *This = impl_from_ISAXAttributes( iface );
805 *length = This->nb_attributes;
806 TRACE("Length set to %d\n", *length);
810 static HRESULT WINAPI isaxattributes_getURI(
811 ISAXAttributes* iface,
816 saxattributes *This = impl_from_ISAXAttributes( iface );
817 TRACE("(%p)->(%d)\n", This, nIndex);
819 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
820 if(!pUrl || !pUriSize) return E_POINTER;
822 *pUriSize = SysStringLen(This->szURI[nIndex]);
823 *pUrl = This->szURI[nIndex];
828 static HRESULT WINAPI isaxattributes_getLocalName(
829 ISAXAttributes* iface,
831 const WCHAR **pLocalName,
832 int *pLocalNameLength)
834 saxattributes *This = impl_from_ISAXAttributes( iface );
835 TRACE("(%p)->(%d)\n", This, nIndex);
837 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
838 if(!pLocalName || !pLocalNameLength) return E_POINTER;
840 *pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
841 *pLocalName = This->szLocalname[nIndex];
846 static HRESULT WINAPI isaxattributes_getQName(
847 ISAXAttributes* iface,
849 const WCHAR **pQName,
852 saxattributes *This = impl_from_ISAXAttributes( iface );
853 TRACE("(%p)->(%d)\n", This, nIndex);
855 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
856 if(!pQName || !pQNameLength) return E_POINTER;
858 *pQNameLength = SysStringLen(This->szQName[nIndex]);
859 *pQName = This->szQName[nIndex];
864 static HRESULT WINAPI isaxattributes_getName(
865 ISAXAttributes* iface,
869 const WCHAR **pLocalName,
871 const WCHAR **pQName,
874 saxattributes *This = impl_from_ISAXAttributes( iface );
875 TRACE("(%p)->(%d)\n", This, nIndex);
877 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
878 if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
879 || !pQName || !pQNameLength) return E_POINTER;
881 *pUriLength = SysStringLen(This->szURI[nIndex]);
882 *pUri = This->szURI[nIndex];
883 *pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
884 *pLocalName = This->szLocalname[nIndex];
885 *pQNameLength = SysStringLen(This->szQName[nIndex]);
886 *pQName = This->szQName[nIndex];
891 static HRESULT WINAPI isaxattributes_getIndexFromName(
892 ISAXAttributes* iface,
895 const WCHAR *pLocalName,
899 saxattributes *This = impl_from_ISAXAttributes( iface );
901 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
902 debugstr_w(pLocalName), cocalNameLength);
904 if(!pUri || !pLocalName || !index) return E_POINTER;
906 for(i=0; i<This->nb_attributes; i++)
908 if(cUriLength!=SysStringLen(This->szURI[i])
909 || cocalNameLength!=SysStringLen(This->szLocalname[i]))
911 if(cUriLength && memcmp(pUri, This->szURI[i],
912 sizeof(WCHAR)*cUriLength))
914 if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
915 sizeof(WCHAR)*cocalNameLength))
925 static HRESULT WINAPI isaxattributes_getIndexFromQName(
926 ISAXAttributes* iface,
931 saxattributes *This = impl_from_ISAXAttributes( iface );
933 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQNameLength);
935 if(!pQName || !index) return E_POINTER;
936 if(!nQNameLength) return E_INVALIDARG;
938 for(i=0; i<This->nb_attributes; i++)
940 if(nQNameLength!=SysStringLen(This->szQName[i])) continue;
941 if(memcmp(pQName, This->szQName, sizeof(WCHAR)*nQNameLength)) continue;
950 static HRESULT WINAPI isaxattributes_getType(
951 ISAXAttributes* iface,
956 saxattributes *This = impl_from_ISAXAttributes( iface );
958 FIXME("(%p)->(%d) stub\n", This, nIndex);
962 static HRESULT WINAPI isaxattributes_getTypeFromName(
963 ISAXAttributes* iface,
966 const WCHAR *pLocalName,
971 saxattributes *This = impl_from_ISAXAttributes( iface );
973 FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
974 debugstr_w(pLocalName), nLocalName);
978 static HRESULT WINAPI isaxattributes_getTypeFromQName(
979 ISAXAttributes* iface,
985 saxattributes *This = impl_from_ISAXAttributes( iface );
987 FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
991 static HRESULT WINAPI isaxattributes_getValue(
992 ISAXAttributes* iface,
994 const WCHAR **pValue,
997 saxattributes *This = impl_from_ISAXAttributes( iface );
998 TRACE("(%p)->(%d)\n", This, nIndex);
1000 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
1001 if(!pValue || !nValue) return E_POINTER;
1003 *nValue = SysStringLen(This->szValue[nIndex]);
1004 *pValue = This->szValue[nIndex];
1009 static HRESULT WINAPI isaxattributes_getValueFromName(
1010 ISAXAttributes* iface,
1013 const WCHAR *pLocalName,
1015 const WCHAR **pValue,
1020 saxattributes *This = impl_from_ISAXAttributes( iface );
1021 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), nUri,
1022 debugstr_w(pLocalName), nLocalName);
1024 hr = ISAXAttributes_getIndexFromName(iface,
1025 pUri, nUri, pLocalName, nLocalName, &index);
1026 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
1031 static HRESULT WINAPI isaxattributes_getValueFromQName(
1032 ISAXAttributes* iface,
1033 const WCHAR *pQName,
1035 const WCHAR **pValue,
1040 saxattributes *This = impl_from_ISAXAttributes( iface );
1041 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQName);
1043 hr = ISAXAttributes_getIndexFromQName(iface, pQName, nQName, &index);
1044 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
1049 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
1051 isaxattributes_QueryInterface,
1052 isaxattributes_AddRef,
1053 isaxattributes_Release,
1054 isaxattributes_getLength,
1055 isaxattributes_getURI,
1056 isaxattributes_getLocalName,
1057 isaxattributes_getQName,
1058 isaxattributes_getName,
1059 isaxattributes_getIndexFromName,
1060 isaxattributes_getIndexFromQName,
1061 isaxattributes_getType,
1062 isaxattributes_getTypeFromName,
1063 isaxattributes_getTypeFromQName,
1064 isaxattributes_getValue,
1065 isaxattributes_getValueFromName,
1066 isaxattributes_getValueFromQName
1069 static HRESULT SAXAttributes_create(saxattributes **attr,
1070 int nb_namespaces, const xmlChar **xmlNamespaces,
1071 int nb_attributes, const xmlChar **xmlAttributes)
1073 saxattributes *attributes;
1075 static const xmlChar xmlns[] = "xmlns";
1077 attributes = heap_alloc(sizeof(*attributes));
1079 return E_OUTOFMEMORY;
1081 attributes->IVBSAXAttributes_iface.lpVtbl = &ivbsaxattributes_vtbl;
1082 attributes->ISAXAttributes_iface.lpVtbl = &isaxattributes_vtbl;
1083 attributes->ref = 1;
1085 attributes->nb_attributes = nb_namespaces+nb_attributes;
1087 attributes->szLocalname = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
1088 attributes->szURI = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
1089 attributes->szValue = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
1090 attributes->szQName = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
1092 if(!attributes->szLocalname || !attributes->szURI
1093 || !attributes->szValue || !attributes->szQName)
1095 heap_free(attributes->szLocalname);
1096 heap_free(attributes->szURI);
1097 heap_free(attributes->szValue);
1098 heap_free(attributes->szQName);
1099 heap_free(attributes);
1103 for(index=0; index<nb_namespaces; index++)
1105 attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
1106 attributes->szURI[index] = SysAllocStringLen(NULL, 0);
1107 attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
1108 attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
1111 for(index=0; index<nb_attributes; index++)
1113 attributes->szLocalname[nb_namespaces+index] =
1114 bstr_from_xmlChar(xmlAttributes[index*5]);
1115 attributes->szURI[nb_namespaces+index] =
1116 bstr_from_xmlChar(xmlAttributes[index*5+2]);
1117 attributes->szValue[nb_namespaces+index] =
1118 bstr_from_xmlCharN(xmlAttributes[index*5+3],
1119 xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
1120 attributes->szQName[nb_namespaces+index] =
1121 QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
1126 TRACE("returning %p\n", *attr);
1131 /*** LibXML callbacks ***/
1132 static void libxmlStartDocument(void *ctx)
1134 saxlocator *This = ctx;
1137 if(has_content_handler(This))
1139 if(This->vbInterface)
1140 hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
1142 hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
1145 format_error_message_from_id(This, hr);
1148 update_position(This, NULL);
1151 static void libxmlEndDocument(void *ctx)
1153 saxlocator *This = ctx;
1159 if(This->ret != S_OK) return;
1161 if(has_content_handler(This))
1163 if(This->vbInterface)
1164 hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1166 hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1169 format_error_message_from_id(This, hr);
1173 static void libxmlStartElementNS(
1175 const xmlChar *localname,
1176 const xmlChar *prefix,
1179 const xmlChar **namespaces,
1182 const xmlChar **attributes)
1184 BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
1185 saxlocator *This = ctx;
1187 saxattributes *attr;
1190 if(*(This->pParserCtxt->input->cur) == '/')
1191 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+2);
1193 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
1195 hr = namespacePush(This, nb_namespaces);
1196 if(hr==S_OK && has_content_handler(This))
1198 for(index=0; index<nb_namespaces; index++)
1200 Prefix = pooled_bstr_from_xmlChar(&This->saxreader->pool, namespaces[2*index]);
1201 Uri = pooled_bstr_from_xmlChar(&This->saxreader->pool, namespaces[2*index+1]);
1203 if(This->vbInterface)
1204 hr = IVBSAXContentHandler_startPrefixMapping(
1205 This->saxreader->vbcontentHandler,
1208 hr = ISAXContentHandler_startPrefixMapping(
1209 This->saxreader->contentHandler,
1210 Prefix, SysStringLen(Prefix),
1211 Uri, SysStringLen(Uri));
1215 format_error_message_from_id(This, hr);
1220 NamespaceUri = pooled_bstr_from_xmlChar(&This->saxreader->pool, URI);
1221 LocalName = pooled_bstr_from_xmlChar(&This->saxreader->pool, localname);
1222 QName = pooled_QName_from_xmlChar(&This->saxreader->pool, prefix, localname);
1224 hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
1227 if(This->vbInterface)
1228 hr = IVBSAXContentHandler_startElement(This->saxreader->vbcontentHandler,
1229 &NamespaceUri, &LocalName, &QName, &attr->IVBSAXAttributes_iface);
1231 hr = ISAXContentHandler_startElement(This->saxreader->contentHandler, NamespaceUri,
1232 SysStringLen(NamespaceUri), LocalName, SysStringLen(LocalName), QName,
1233 SysStringLen(QName), &attr->ISAXAttributes_iface);
1235 ISAXAttributes_Release(&attr->ISAXAttributes_iface);
1240 format_error_message_from_id(This, hr);
1243 static void libxmlEndElementNS(
1245 const xmlChar *localname,
1246 const xmlChar *prefix,
1249 BSTR NamespaceUri, LocalName, QName, Prefix;
1250 saxlocator *This = ctx;
1255 end = (xmlChar*)This->pParserCtxt->input->cur;
1256 if(*(end-1) != '>' || *(end-2) != '/')
1257 while(end-2>=This->pParserCtxt->input->base
1258 && *(end-2)!='<' && *(end-1)!='/') end--;
1260 update_position(This, end);
1262 nsNr = namespacePop(This);
1264 if(has_content_handler(This))
1266 NamespaceUri = pooled_bstr_from_xmlChar(&This->saxreader->pool, URI);
1267 LocalName = pooled_bstr_from_xmlChar(&This->saxreader->pool, localname);
1268 QName = pooled_QName_from_xmlChar(&This->saxreader->pool, prefix, localname);
1270 if(This->vbInterface)
1271 hr = IVBSAXContentHandler_endElement(
1272 This->saxreader->vbcontentHandler,
1273 &NamespaceUri, &LocalName, &QName);
1275 hr = ISAXContentHandler_endElement(
1276 This->saxreader->contentHandler,
1277 NamespaceUri, SysStringLen(NamespaceUri),
1278 LocalName, SysStringLen(LocalName),
1279 QName, SysStringLen(QName));
1283 format_error_message_from_id(This, hr);
1287 for(index=This->pParserCtxt->nsNr-2;
1288 index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
1290 Prefix = pooled_bstr_from_xmlChar(&This->saxreader->pool, This->pParserCtxt->nsTab[index]);
1292 if(This->vbInterface)
1293 hr = IVBSAXContentHandler_endPrefixMapping(
1294 This->saxreader->vbcontentHandler, &Prefix);
1296 hr = ISAXContentHandler_endPrefixMapping(
1297 This->saxreader->contentHandler,
1298 Prefix, SysStringLen(Prefix));
1302 format_error_message_from_id(This, hr);
1309 update_position(This, NULL);
1312 static void libxmlCharacters(
1317 saxlocator *This = ctx;
1322 BOOL lastEvent = FALSE;
1324 if(!(has_content_handler(This))) return;
1327 if(*(ch-1)=='\r') cur--;
1330 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1335 while(end-ch<len && *end!='\r') end++;
1342 if(!lastEvent) *end = '\n';
1344 Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur+1);
1345 if(This->vbInterface)
1346 hr = IVBSAXContentHandler_characters(
1347 This->saxreader->vbcontentHandler, &Chars);
1349 hr = ISAXContentHandler_characters(
1350 This->saxreader->contentHandler,
1351 Chars, SysStringLen(Chars));
1355 format_error_message_from_id(This, hr);
1359 This->column += end-cur+1;
1373 if(end-ch == len) break;
1376 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1377 This->column = This->realColumn
1378 +This->pParserCtxt->input->cur-This->lastCur;
1381 static void libxmlSetDocumentLocator(
1383 xmlSAXLocatorPtr loc)
1385 saxlocator *This = ctx;
1388 if(has_content_handler(This))
1390 if(This->vbInterface)
1391 hr = IVBSAXContentHandler_putref_documentLocator(This->saxreader->vbcontentHandler,
1392 &This->IVBSAXLocator_iface);
1394 hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
1395 &This->ISAXLocator_iface);
1399 format_error_message_from_id(This, hr);
1402 static void libxmlComment(void *ctx, const xmlChar *value)
1404 saxlocator *This = ctx;
1407 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur;
1409 while(beg-4>=This->pParserCtxt->input->base
1410 && memcmp(beg-4, "<!--", sizeof(char[4]))) beg--;
1411 update_position(This, beg);
1413 if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1414 if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1416 bValue = pooled_bstr_from_xmlChar(&This->saxreader->pool, value);
1418 if(This->vbInterface)
1419 hr = IVBSAXLexicalHandler_comment(
1420 This->saxreader->vblexicalHandler, &bValue);
1422 hr = ISAXLexicalHandler_comment(
1423 This->saxreader->lexicalHandler,
1424 bValue, SysStringLen(bValue));
1427 format_error_message_from_id(This, hr);
1429 update_position(This, NULL);
1432 static void libxmlFatalError(void *ctx, const char *msg, ...)
1434 saxlocator *This = ctx;
1440 va_start(args, msg);
1441 vsprintf(message, msg, args);
1444 len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1445 error = heap_alloc(sizeof(WCHAR)*len);
1448 MultiByteToWideChar(CP_UNIXCP, 0, message, -1, error, len);
1449 TRACE("fatal error for %p: %s\n", This, debugstr_w(error));
1452 if(!has_error_handler(This))
1454 xmlStopParser(This->pParserCtxt);
1460 FIXME("Error handling is not compatible.\n");
1462 if(This->vbInterface)
1464 BSTR bstrError = SysAllocString(error);
1465 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler, &This->IVBSAXLocator_iface,
1466 &bstrError, E_FAIL);
1467 SysFreeString(bstrError);
1470 ISAXErrorHandler_fatalError(This->saxreader->errorHandler, &This->ISAXLocator_iface,
1475 xmlStopParser(This->pParserCtxt);
1479 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1481 saxlocator *This = ctx;
1483 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1487 BOOL lastEvent = FALSE, change;
1489 while(beg-9>=This->pParserCtxt->input->base
1490 && memcmp(beg-9, "<![CDATA[", sizeof(char[9]))) beg--;
1491 update_position(This, beg);
1493 if(This->vbInterface && This->saxreader->vblexicalHandler)
1494 hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1495 if(!This->vbInterface && This->saxreader->lexicalHandler)
1496 hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1500 format_error_message_from_id(This, hr);
1504 realLen = This->pParserCtxt->input->cur-beg-3;
1510 while(end-beg<realLen && *end!='\r') end++;
1511 if(end-beg==realLen)
1516 else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1519 if(*end == '\r') change = TRUE;
1520 else change = FALSE;
1522 if(change) *end = '\n';
1524 if(has_content_handler(This))
1526 Chars = pooled_bstr_from_xmlCharN(&This->saxreader->pool, cur, end-cur+1);
1527 if(This->vbInterface)
1528 hr = IVBSAXContentHandler_characters(
1529 This->saxreader->vbcontentHandler, &Chars);
1531 hr = ISAXContentHandler_characters(
1532 This->saxreader->contentHandler,
1533 Chars, SysStringLen(Chars));
1536 if(change) *end = '\r';
1541 This->column += end-cur+2;
1546 if(This->vbInterface && This->saxreader->vblexicalHandler)
1547 hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1548 if(!This->vbInterface && This->saxreader->lexicalHandler)
1549 hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1552 format_error_message_from_id(This, hr);
1554 This->column += 4+end-cur;
1557 /*** IVBSAXLocator interface ***/
1558 /*** IUnknown methods ***/
1559 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1561 saxlocator *This = impl_from_IVBSAXLocator( iface );
1563 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1567 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1568 IsEqualGUID( riid, &IID_IDispatch) ||
1569 IsEqualGUID( riid, &IID_IVBSAXLocator ))
1575 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1576 return E_NOINTERFACE;
1579 IVBSAXLocator_AddRef( iface );
1584 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1586 saxlocator *This = impl_from_IVBSAXLocator( iface );
1587 TRACE("%p\n", This );
1588 return InterlockedIncrement( &This->ref );
1591 static ULONG WINAPI ivbsaxlocator_Release(
1592 IVBSAXLocator* iface)
1594 saxlocator *This = impl_from_IVBSAXLocator( iface );
1595 return ISAXLocator_Release((ISAXLocator*)&This->IVBSAXLocator_iface);
1598 /*** IDispatch methods ***/
1599 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1601 saxlocator *This = impl_from_IVBSAXLocator( iface );
1603 TRACE("(%p)->(%p)\n", This, pctinfo);
1610 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1611 IVBSAXLocator *iface,
1612 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1614 saxlocator *This = impl_from_IVBSAXLocator( iface );
1617 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1619 hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1624 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1625 IVBSAXLocator *iface,
1627 LPOLESTR* rgszNames,
1632 saxlocator *This = impl_from_IVBSAXLocator( iface );
1633 ITypeInfo *typeinfo;
1636 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1639 if(!rgszNames || cNames == 0 || !rgDispId)
1640 return E_INVALIDARG;
1642 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1645 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1646 ITypeInfo_Release(typeinfo);
1652 static HRESULT WINAPI ivbsaxlocator_Invoke(
1653 IVBSAXLocator *iface,
1654 DISPID dispIdMember,
1658 DISPPARAMS* pDispParams,
1659 VARIANT* pVarResult,
1660 EXCEPINFO* pExcepInfo,
1663 saxlocator *This = impl_from_IVBSAXLocator( iface );
1664 ITypeInfo *typeinfo;
1667 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1668 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1670 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1673 hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXLocator_iface, dispIdMember, wFlags,
1674 pDispParams, pVarResult, pExcepInfo, puArgErr);
1675 ITypeInfo_Release(typeinfo);
1681 /*** IVBSAXLocator methods ***/
1682 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1683 IVBSAXLocator* iface,
1686 saxlocator *This = impl_from_IVBSAXLocator( iface );
1687 return ISAXLocator_getColumnNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnColumn);
1690 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1691 IVBSAXLocator* iface,
1694 saxlocator *This = impl_from_IVBSAXLocator( iface );
1695 return ISAXLocator_getLineNumber((ISAXLocator*)&This->IVBSAXLocator_iface, pnLine);
1698 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1699 IVBSAXLocator* iface,
1702 saxlocator *This = impl_from_IVBSAXLocator( iface );
1703 return ISAXLocator_getPublicId((ISAXLocator*)&This->IVBSAXLocator_iface,
1704 (const WCHAR**)publicId);
1707 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1708 IVBSAXLocator* iface,
1711 saxlocator *This = impl_from_IVBSAXLocator( iface );
1712 return ISAXLocator_getSystemId((ISAXLocator*)&This->IVBSAXLocator_iface,
1713 (const WCHAR**)systemId);
1716 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1718 ivbsaxlocator_QueryInterface,
1719 ivbsaxlocator_AddRef,
1720 ivbsaxlocator_Release,
1721 ivbsaxlocator_GetTypeInfoCount,
1722 ivbsaxlocator_GetTypeInfo,
1723 ivbsaxlocator_GetIDsOfNames,
1724 ivbsaxlocator_Invoke,
1725 ivbsaxlocator_get_columnNumber,
1726 ivbsaxlocator_get_lineNumber,
1727 ivbsaxlocator_get_publicId,
1728 ivbsaxlocator_get_systemId
1731 /*** ISAXLocator interface ***/
1732 /*** IUnknown methods ***/
1733 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1735 saxlocator *This = impl_from_ISAXLocator( iface );
1737 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1741 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1742 IsEqualGUID( riid, &IID_ISAXLocator ))
1748 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1749 return E_NOINTERFACE;
1752 ISAXLocator_AddRef( iface );
1757 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1759 saxlocator *This = impl_from_ISAXLocator( iface );
1760 TRACE("%p\n", This );
1761 return InterlockedIncrement( &This->ref );
1764 static ULONG WINAPI isaxlocator_Release(
1767 saxlocator *This = impl_from_ISAXLocator( iface );
1770 TRACE("%p\n", This );
1772 ref = InterlockedDecrement( &This->ref );
1775 SysFreeString(This->publicId);
1776 SysFreeString(This->systemId);
1777 heap_free(This->nsStack);
1779 ISAXXMLReader_Release(&This->saxreader->ISAXXMLReader_iface);
1786 /*** ISAXLocator methods ***/
1787 static HRESULT WINAPI isaxlocator_getColumnNumber(
1791 saxlocator *This = impl_from_ISAXLocator( iface );
1793 *pnColumn = This->column;
1797 static HRESULT WINAPI isaxlocator_getLineNumber(
1801 saxlocator *This = impl_from_ISAXLocator( iface );
1803 *pnLine = This->line;
1807 static HRESULT WINAPI isaxlocator_getPublicId(
1809 const WCHAR ** ppwchPublicId)
1812 saxlocator *This = impl_from_ISAXLocator( iface );
1814 SysFreeString(This->publicId);
1816 publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1817 if(SysStringLen(publicId))
1818 This->publicId = (WCHAR*)&publicId;
1821 SysFreeString(publicId);
1822 This->publicId = NULL;
1825 *ppwchPublicId = This->publicId;
1829 static HRESULT WINAPI isaxlocator_getSystemId(
1831 const WCHAR ** ppwchSystemId)
1834 saxlocator *This = impl_from_ISAXLocator( iface );
1836 SysFreeString(This->systemId);
1838 systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1839 if(SysStringLen(systemId))
1840 This->systemId = (WCHAR*)&systemId;
1843 SysFreeString(systemId);
1844 This->systemId = NULL;
1847 *ppwchSystemId = This->systemId;
1851 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1853 isaxlocator_QueryInterface,
1855 isaxlocator_Release,
1856 isaxlocator_getColumnNumber,
1857 isaxlocator_getLineNumber,
1858 isaxlocator_getPublicId,
1859 isaxlocator_getSystemId
1862 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1864 saxlocator *locator;
1866 locator = heap_alloc( sizeof (*locator) );
1868 return E_OUTOFMEMORY;
1870 locator->IVBSAXLocator_iface.lpVtbl = &ivbsaxlocator_vtbl;
1871 locator->ISAXLocator_iface.lpVtbl = &isaxlocator_vtbl;
1873 locator->vbInterface = vbInterface;
1875 locator->saxreader = reader;
1876 ISAXXMLReader_AddRef(&reader->ISAXXMLReader_iface);
1878 locator->pParserCtxt = NULL;
1879 locator->publicId = NULL;
1880 locator->systemId = NULL;
1881 locator->lastCur = NULL;
1883 locator->column = 0;
1884 locator->ret = S_OK;
1885 locator->nsStackSize = 8;
1886 locator->nsStackLast = 0;
1887 locator->nsStack = heap_alloc(sizeof(int)*locator->nsStackSize);
1888 if(!locator->nsStack)
1890 ISAXXMLReader_Release(&reader->ISAXXMLReader_iface);
1892 return E_OUTOFMEMORY;
1895 *ppsaxlocator = locator;
1897 TRACE("returning %p\n", *ppsaxlocator);
1902 /*** SAXXMLReader internal functions ***/
1903 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1905 xmlCharEncoding encoding = XML_CHAR_ENCODING_NONE;
1906 xmlChar *enc_name = NULL;
1907 saxlocator *locator;
1910 hr = SAXLocator_create(This, &locator, vbInterface);
1916 const unsigned char *buff = (unsigned char*)buffer;
1918 encoding = xmlDetectCharEncoding((xmlChar*)buffer, 4);
1919 enc_name = (xmlChar*)xmlGetCharEncodingName(encoding);
1920 TRACE("detected encoding: %s\n", enc_name);
1921 /* skip BOM, parser won't switch encodings and so won't skip it on its own */
1922 if ((encoding == XML_CHAR_ENCODING_UTF8) &&
1923 buff[0] == 0xEF && buff[1] == 0xBB && buff[2] == 0xBF)
1930 locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1931 if(!locator->pParserCtxt)
1933 ISAXLocator_Release(&locator->ISAXLocator_iface);
1937 if (encoding == XML_CHAR_ENCODING_UTF8)
1938 locator->pParserCtxt->encoding = xmlStrdup(enc_name);
1940 xmlFree(locator->pParserCtxt->sax);
1941 locator->pParserCtxt->sax = &locator->saxreader->sax;
1942 locator->pParserCtxt->userData = locator;
1944 This->isParsing = TRUE;
1945 if(xmlParseDocument(locator->pParserCtxt) == -1) hr = E_FAIL;
1946 else hr = locator->ret;
1947 This->isParsing = FALSE;
1949 if(locator->pParserCtxt)
1951 locator->pParserCtxt->sax = NULL;
1952 xmlFreeParserCtxt(locator->pParserCtxt);
1953 locator->pParserCtxt = NULL;
1956 ISAXLocator_Release(&locator->ISAXLocator_iface);
1960 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
1962 saxlocator *locator;
1969 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1970 if(FAILED(hr)) return hr;
1972 hr = SAXLocator_create(This, &locator, vbInterface);
1973 if(FAILED(hr)) return hr;
1975 locator->pParserCtxt = xmlCreatePushParserCtxt(
1976 &locator->saxreader->sax, locator,
1977 data, dataRead, NULL);
1978 if(!locator->pParserCtxt)
1980 ISAXLocator_Release(&locator->ISAXLocator_iface);
1984 This->isParsing = TRUE;
1986 if(dataRead != sizeof(data))
1988 ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
1989 hr = ret != XML_ERR_OK ? E_FAIL : locator->ret;
1996 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1997 if (FAILED(hr)) break;
1999 ret = xmlParseChunk(locator->pParserCtxt, data, dataRead, 0);
2000 hr = ret != XML_ERR_OK ? E_FAIL : locator->ret;
2002 if (hr != S_OK) break;
2004 if (dataRead != sizeof(data))
2006 ret = xmlParseChunk(locator->pParserCtxt, data, 0, 1);
2007 hr = ret != XML_ERR_OK ? E_FAIL : locator->ret;
2013 This->isParsing = FALSE;
2015 xmlFreeParserCtxt(locator->pParserCtxt);
2016 locator->pParserCtxt = NULL;
2017 ISAXLocator_Release(&locator->ISAXLocator_iface);
2021 static HRESULT internal_getEntityResolver(
2023 void *pEntityResolver,
2026 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2030 static HRESULT internal_putEntityResolver(
2032 void *pEntityResolver,
2035 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
2039 static HRESULT internal_getContentHandler(
2041 void *pContentHandler,
2044 TRACE("(%p)->(%p)\n", This, pContentHandler);
2045 if(pContentHandler == NULL)
2047 if((vbInterface && This->vbcontentHandler)
2048 || (!vbInterface && This->contentHandler))
2051 IVBSAXContentHandler_AddRef(This->vbcontentHandler);
2053 ISAXContentHandler_AddRef(This->contentHandler);
2055 if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
2056 This->vbcontentHandler;
2057 else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
2062 static HRESULT internal_putContentHandler(
2064 void *contentHandler,
2067 TRACE("(%p)->(%p)\n", This, contentHandler);
2071 IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
2073 ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
2075 if((vbInterface && This->vbcontentHandler)
2076 || (!vbInterface && This->contentHandler))
2079 IVBSAXContentHandler_Release(This->vbcontentHandler);
2081 ISAXContentHandler_Release(This->contentHandler);
2084 This->vbcontentHandler = contentHandler;
2086 This->contentHandler = contentHandler;
2091 static HRESULT internal_getDTDHandler(
2096 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2100 static HRESULT internal_putDTDHandler(
2105 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
2109 static HRESULT internal_getErrorHandler(
2111 void *pErrorHandler,
2114 TRACE("(%p)->(%p)\n", This, pErrorHandler);
2115 if(pErrorHandler == NULL)
2118 if(vbInterface && This->vberrorHandler)
2119 IVBSAXErrorHandler_AddRef(This->vberrorHandler);
2120 else if(!vbInterface && This->errorHandler)
2121 ISAXErrorHandler_AddRef(This->errorHandler);
2124 *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
2126 *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
2132 static HRESULT internal_putErrorHandler(
2137 TRACE("(%p)->(%p)\n", This, errorHandler);
2141 IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
2143 ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
2146 if(vbInterface && This->vberrorHandler)
2147 IVBSAXErrorHandler_Release(This->vberrorHandler);
2148 else if(!vbInterface && This->errorHandler)
2149 ISAXErrorHandler_Release(This->errorHandler);
2152 This->vberrorHandler = errorHandler;
2154 This->errorHandler = errorHandler;
2160 static HRESULT internal_parse(
2167 TRACE("(%p)->(%s)\n", This, debugstr_variant(&varInput));
2169 /* Dispose of the BSTRs in the pool from a prior run, if any. */
2170 free_bstr_pool(&This->pool);
2172 switch(V_VT(&varInput))
2175 hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2176 SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2178 case VT_ARRAY|VT_UI1: {
2180 LONG lBound, uBound;
2183 hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2184 if(hr != S_OK) break;
2185 hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2186 if(hr != S_OK) break;
2187 dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2188 hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2189 if(hr != S_OK) break;
2190 hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2191 SafeArrayUnaccessData(V_ARRAY(&varInput));
2196 IPersistStream *persistStream;
2197 IStream *stream = NULL;
2198 IXMLDOMDocument *xmlDoc;
2200 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2201 &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2205 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2206 hr = internal_parseBuffer(This, (const char*)bstrData,
2207 SysStringByteLen(bstrData), vbInterface);
2208 IXMLDOMDocument_Release(xmlDoc);
2209 SysFreeString(bstrData);
2213 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2214 &IID_IPersistStream, (void**)&persistStream) == S_OK)
2216 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2219 IPersistStream_Release(persistStream);
2223 hr = IPersistStream_Save(persistStream, stream, TRUE);
2224 IPersistStream_Release(persistStream);
2227 IStream_Release(stream);
2231 if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2232 &IID_IStream, (void**)&stream) == S_OK)
2234 hr = internal_parseStream(This, stream, vbInterface);
2235 IStream_Release(stream);
2240 WARN("vt %d not implemented\n", V_VT(&varInput));
2247 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2249 saxreader *This = obj;
2251 return internal_parseBuffer(This, ptr, len, TRUE);
2254 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2256 saxreader *This = obj;
2258 return internal_parseBuffer(This, ptr, len, FALSE);
2261 static HRESULT internal_parseURL(
2269 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2271 if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
2272 else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
2282 static HRESULT internal_putProperty(
2288 TRACE("(%p)->(%s %s)\n", This, debugstr_w(prop), debugstr_variant(&value));
2290 if(!memcmp(prop, PropertyDeclHandlerW, sizeof(PropertyDeclHandlerW)))
2292 if(This->isParsing) return E_FAIL;
2294 switch (V_VT(&value))
2299 if (This->vbdeclHandler)
2301 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2302 This->vbdeclHandler = NULL;
2306 if (This->declHandler)
2308 ISAXDeclHandler_Release(This->declHandler);
2309 This->declHandler = NULL;
2313 if (V_UNKNOWN(&value)) IUnknown_AddRef(V_UNKNOWN(&value));
2315 if ((vbInterface && This->vbdeclHandler) ||
2316 (!vbInterface && This->declHandler))
2319 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2321 ISAXDeclHandler_Release(This->declHandler);
2325 This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2327 This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2330 return E_INVALIDARG;
2336 if(!memcmp(prop, PropertyLexicalHandlerW, sizeof(PropertyLexicalHandlerW)))
2338 if(This->isParsing) return E_FAIL;
2340 switch (V_VT(&value))
2345 if (This->vblexicalHandler)
2347 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2348 This->vblexicalHandler = NULL;
2352 if (This->lexicalHandler)
2354 ISAXLexicalHandler_Release(This->lexicalHandler);
2355 This->lexicalHandler = NULL;
2359 if (V_UNKNOWN(&value)) IUnknown_AddRef(V_UNKNOWN(&value));
2361 if ((vbInterface && This->vblexicalHandler) ||
2362 (!vbInterface && This->lexicalHandler))
2365 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2367 ISAXLexicalHandler_Release(This->lexicalHandler);
2371 This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2373 This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2376 return E_INVALIDARG;
2382 FIXME("(%p)->(%s): unsupported property\n", This, debugstr_w(prop));
2384 if(!memcmp(prop, PropertyCharsetW, sizeof(PropertyCharsetW)))
2387 if(!memcmp(prop, PropertyDomNodeW, sizeof(PropertyDomNodeW)))
2390 if(!memcmp(prop, PropertyInputSourceW, sizeof(PropertyInputSourceW)))
2393 if(!memcmp(prop, PropertyMaxElementDepthW, sizeof(PropertyMaxElementDepthW)))
2396 if(!memcmp(prop, PropertyMaxXMLSizeW, sizeof(PropertyMaxXMLSizeW)))
2399 if(!memcmp(prop, PropertySchemaDeclHandlerW, sizeof(PropertySchemaDeclHandlerW)))
2402 if(!memcmp(prop, PropertyXMLDeclEncodingW, sizeof(PropertyXMLDeclEncodingW)))
2405 if(!memcmp(prop, PropertyXMLDeclStandaloneW, sizeof(PropertyXMLDeclStandaloneW)))
2408 if(!memcmp(prop, PropertyXMLDeclVersionW, sizeof(PropertyXMLDeclVersionW)))
2411 return E_INVALIDARG;
2414 static HRESULT internal_getProperty(const saxreader* This, const WCHAR *prop, VARIANT *value, BOOL vb)
2416 TRACE("(%p)->(%s)\n", This, debugstr_w(prop));
2418 if (!value) return E_POINTER;
2420 if (!memcmp(PropertyLexicalHandlerW, prop, sizeof(PropertyLexicalHandlerW)))
2422 V_VT(value) = VT_UNKNOWN;
2423 V_UNKNOWN(value) = vb ? (IUnknown*)This->vblexicalHandler : (IUnknown*)This->lexicalHandler;
2424 if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2428 if (!memcmp(PropertyDeclHandlerW, prop, sizeof(PropertyDeclHandlerW)))
2430 V_VT(value) = VT_UNKNOWN;
2431 V_UNKNOWN(value) = vb ? (IUnknown*)This->vbdeclHandler : (IUnknown*)This->declHandler;
2432 if (V_UNKNOWN(value)) IUnknown_AddRef(V_UNKNOWN(value));
2436 FIXME("(%p)->(%s) unsupported property\n", This, debugstr_w(prop));
2441 /*** IVBSAXXMLReader interface ***/
2442 /*** IUnknown methods ***/
2443 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2445 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2447 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2451 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2452 IsEqualGUID( riid, &IID_IDispatch ) ||
2453 IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2457 else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2459 *ppvObject = &This->ISAXXMLReader_iface;
2463 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2464 return E_NOINTERFACE;
2467 IVBSAXXMLReader_AddRef( iface );
2472 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2474 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2475 TRACE("%p\n", This );
2476 return InterlockedIncrement( &This->ref );
2479 static ULONG WINAPI saxxmlreader_Release(
2480 IVBSAXXMLReader* iface)
2482 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2485 TRACE("%p\n", This );
2487 ref = InterlockedDecrement( &This->ref );
2490 if(This->contentHandler)
2491 ISAXContentHandler_Release(This->contentHandler);
2493 if(This->vbcontentHandler)
2494 IVBSAXContentHandler_Release(This->vbcontentHandler);
2496 if(This->errorHandler)
2497 ISAXErrorHandler_Release(This->errorHandler);
2499 if(This->vberrorHandler)
2500 IVBSAXErrorHandler_Release(This->vberrorHandler);
2502 if(This->lexicalHandler)
2503 ISAXLexicalHandler_Release(This->lexicalHandler);
2505 if(This->vblexicalHandler)
2506 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2508 if(This->declHandler)
2509 ISAXDeclHandler_Release(This->declHandler);
2511 if(This->vbdeclHandler)
2512 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2514 free_bstr_pool(&This->pool);
2522 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2524 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2526 TRACE("(%p)->(%p)\n", This, pctinfo);
2533 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2534 IVBSAXXMLReader *iface,
2535 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2537 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2540 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2542 hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2547 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2548 IVBSAXXMLReader *iface,
2550 LPOLESTR* rgszNames,
2555 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2556 ITypeInfo *typeinfo;
2559 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2562 if(!rgszNames || cNames == 0 || !rgDispId)
2563 return E_INVALIDARG;
2565 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2568 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2569 ITypeInfo_Release(typeinfo);
2575 static HRESULT WINAPI saxxmlreader_Invoke(
2576 IVBSAXXMLReader *iface,
2577 DISPID dispIdMember,
2581 DISPPARAMS* pDispParams,
2582 VARIANT* pVarResult,
2583 EXCEPINFO* pExcepInfo,
2586 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2587 ITypeInfo *typeinfo;
2590 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2591 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2593 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2596 hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXXMLReader_iface, dispIdMember, wFlags,
2597 pDispParams, pVarResult, pExcepInfo, puArgErr);
2598 ITypeInfo_Release(typeinfo);
2604 /*** IVBSAXXMLReader methods ***/
2605 static HRESULT WINAPI saxxmlreader_getFeature(
2606 IVBSAXXMLReader* iface,
2607 const WCHAR *pFeature,
2608 VARIANT_BOOL *pValue)
2610 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2612 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2616 static HRESULT WINAPI saxxmlreader_putFeature(
2617 IVBSAXXMLReader* iface,
2618 const WCHAR *feature,
2621 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2623 TRACE("(%p)->(%s %x)\n", This, debugstr_w(feature), value);
2625 if (!strcmpW(FeatureExternalGeneralEntitiesW, feature) && value == VARIANT_FALSE)
2626 return set_feature_value(This, ExternalGeneralEntities, value);
2628 if (!strcmpW(FeatureExternalParameterEntitiesW, feature) && value == VARIANT_FALSE)
2629 return set_feature_value(This, ExternalParameterEntities, value);
2631 if (!strcmpW(FeatureLexicalHandlerParEntitiesW, feature))
2633 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature), value);
2634 return set_feature_value(This, LexicalHandlerParEntities, value);
2637 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(feature), value);
2641 static HRESULT WINAPI saxxmlreader_getProperty(
2642 IVBSAXXMLReader* iface,
2646 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2647 return internal_getProperty(This, prop, value, TRUE);
2650 static HRESULT WINAPI saxxmlreader_putProperty(
2651 IVBSAXXMLReader* iface,
2655 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2656 return internal_putProperty(This, pProp, value, TRUE);
2659 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2660 IVBSAXXMLReader* iface,
2661 IVBSAXEntityResolver **pEntityResolver)
2663 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2664 return internal_getEntityResolver(This, pEntityResolver, TRUE);
2667 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2668 IVBSAXXMLReader* iface,
2669 IVBSAXEntityResolver *pEntityResolver)
2671 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2672 return internal_putEntityResolver(This, pEntityResolver, TRUE);
2675 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2676 IVBSAXXMLReader* iface,
2677 IVBSAXContentHandler **ppContentHandler)
2679 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2680 return internal_getContentHandler(This, ppContentHandler, TRUE);
2683 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2684 IVBSAXXMLReader* iface,
2685 IVBSAXContentHandler *contentHandler)
2687 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2688 return internal_putContentHandler(This, contentHandler, TRUE);
2691 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2692 IVBSAXXMLReader* iface,
2693 IVBSAXDTDHandler **pDTDHandler)
2695 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2696 return internal_getDTDHandler(This, pDTDHandler, TRUE);
2699 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2700 IVBSAXXMLReader* iface,
2701 IVBSAXDTDHandler *pDTDHandler)
2703 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2704 return internal_putDTDHandler(This, pDTDHandler, TRUE);
2707 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2708 IVBSAXXMLReader* iface,
2709 IVBSAXErrorHandler **pErrorHandler)
2711 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2712 return internal_getErrorHandler(This, pErrorHandler, TRUE);
2715 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2716 IVBSAXXMLReader* iface,
2717 IVBSAXErrorHandler *errorHandler)
2719 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2720 return internal_putErrorHandler(This, errorHandler, TRUE);
2723 static HRESULT WINAPI saxxmlreader_get_baseURL(
2724 IVBSAXXMLReader* iface,
2725 const WCHAR **pBaseUrl)
2727 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2729 FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2733 static HRESULT WINAPI saxxmlreader_put_baseURL(
2734 IVBSAXXMLReader* iface,
2735 const WCHAR *pBaseUrl)
2737 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2739 FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2743 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2744 IVBSAXXMLReader* iface,
2745 const WCHAR **pSecureBaseUrl)
2747 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2749 FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2754 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
2755 IVBSAXXMLReader* iface,
2756 const WCHAR *secureBaseUrl)
2758 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2760 FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2764 static HRESULT WINAPI saxxmlreader_parse(
2765 IVBSAXXMLReader* iface,
2768 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2769 return internal_parse(This, varInput, TRUE);
2772 static HRESULT WINAPI saxxmlreader_parseURL(
2773 IVBSAXXMLReader* iface,
2776 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2777 return internal_parseURL(This, url, TRUE);
2780 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2782 saxxmlreader_QueryInterface,
2783 saxxmlreader_AddRef,
2784 saxxmlreader_Release,
2785 saxxmlreader_GetTypeInfoCount,
2786 saxxmlreader_GetTypeInfo,
2787 saxxmlreader_GetIDsOfNames,
2788 saxxmlreader_Invoke,
2789 saxxmlreader_getFeature,
2790 saxxmlreader_putFeature,
2791 saxxmlreader_getProperty,
2792 saxxmlreader_putProperty,
2793 saxxmlreader_get_entityResolver,
2794 saxxmlreader_put_entityResolver,
2795 saxxmlreader_get_contentHandler,
2796 saxxmlreader_put_contentHandler,
2797 saxxmlreader_get_dtdHandler,
2798 saxxmlreader_put_dtdHandler,
2799 saxxmlreader_get_errorHandler,
2800 saxxmlreader_put_errorHandler,
2801 saxxmlreader_get_baseURL,
2802 saxxmlreader_put_baseURL,
2803 saxxmlreader_get_secureBaseURL,
2804 saxxmlreader_put_secureBaseURL,
2806 saxxmlreader_parseURL
2809 /*** ISAXXMLReader interface ***/
2810 /*** IUnknown methods ***/
2811 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2813 saxreader *This = impl_from_ISAXXMLReader( iface );
2814 return saxxmlreader_QueryInterface(&This->IVBSAXXMLReader_iface, riid, ppvObject);
2817 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2819 saxreader *This = impl_from_ISAXXMLReader( iface );
2820 return saxxmlreader_AddRef(&This->IVBSAXXMLReader_iface);
2823 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2825 saxreader *This = impl_from_ISAXXMLReader( iface );
2826 return saxxmlreader_Release(&This->IVBSAXXMLReader_iface);
2829 /*** ISAXXMLReader methods ***/
2830 static HRESULT WINAPI isaxxmlreader_getFeature(
2831 ISAXXMLReader* iface,
2832 const WCHAR *pFeature,
2833 VARIANT_BOOL *pValue)
2835 saxreader *This = impl_from_ISAXXMLReader( iface );
2836 return IVBSAXXMLReader_getFeature(&This->IVBSAXXMLReader_iface, pFeature, pValue);
2839 static HRESULT WINAPI isaxxmlreader_putFeature(
2840 ISAXXMLReader* iface,
2841 const WCHAR *pFeature,
2842 VARIANT_BOOL vfValue)
2844 saxreader *This = impl_from_ISAXXMLReader( iface );
2845 return IVBSAXXMLReader_putFeature(&This->IVBSAXXMLReader_iface, pFeature, vfValue);
2848 static HRESULT WINAPI isaxxmlreader_getProperty(
2849 ISAXXMLReader* iface,
2853 saxreader *This = impl_from_ISAXXMLReader( iface );
2854 return internal_getProperty(This, prop, value, FALSE);
2857 static HRESULT WINAPI isaxxmlreader_putProperty(
2858 ISAXXMLReader* iface,
2862 saxreader *This = impl_from_ISAXXMLReader( iface );
2863 return internal_putProperty(This, pProp, value, FALSE);
2866 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2867 ISAXXMLReader* iface,
2868 ISAXEntityResolver **ppEntityResolver)
2870 saxreader *This = impl_from_ISAXXMLReader( iface );
2871 return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2874 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2875 ISAXXMLReader* iface,
2876 ISAXEntityResolver *pEntityResolver)
2878 saxreader *This = impl_from_ISAXXMLReader( iface );
2879 return internal_putEntityResolver(This, pEntityResolver, FALSE);
2882 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2883 ISAXXMLReader* iface,
2884 ISAXContentHandler **pContentHandler)
2886 saxreader *This = impl_from_ISAXXMLReader( iface );
2887 return internal_getContentHandler(This, pContentHandler, FALSE);
2890 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2891 ISAXXMLReader* iface,
2892 ISAXContentHandler *contentHandler)
2894 saxreader *This = impl_from_ISAXXMLReader( iface );
2895 return internal_putContentHandler(This, contentHandler, FALSE);
2898 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2899 ISAXXMLReader* iface,
2900 ISAXDTDHandler **pDTDHandler)
2902 saxreader *This = impl_from_ISAXXMLReader( iface );
2903 return internal_getDTDHandler(This, pDTDHandler, FALSE);
2906 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2907 ISAXXMLReader* iface,
2908 ISAXDTDHandler *pDTDHandler)
2910 saxreader *This = impl_from_ISAXXMLReader( iface );
2911 return internal_putDTDHandler(This, pDTDHandler, FALSE);
2914 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2915 ISAXXMLReader* iface,
2916 ISAXErrorHandler **pErrorHandler)
2918 saxreader *This = impl_from_ISAXXMLReader( iface );
2919 return internal_getErrorHandler(This, pErrorHandler, FALSE);
2922 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2923 ISAXXMLReader* iface,
2924 ISAXErrorHandler *errorHandler)
2926 saxreader *This = impl_from_ISAXXMLReader( iface );
2927 return internal_putErrorHandler(This, errorHandler, FALSE);
2930 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2931 ISAXXMLReader* iface,
2932 const WCHAR **pBaseUrl)
2934 saxreader *This = impl_from_ISAXXMLReader( iface );
2935 return IVBSAXXMLReader_get_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
2938 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2939 ISAXXMLReader* iface,
2940 const WCHAR *pBaseUrl)
2942 saxreader *This = impl_from_ISAXXMLReader( iface );
2943 return IVBSAXXMLReader_put_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
2946 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2947 ISAXXMLReader* iface,
2948 const WCHAR **pSecureBaseUrl)
2950 saxreader *This = impl_from_ISAXXMLReader( iface );
2951 return IVBSAXXMLReader_get_secureBaseURL(&This->IVBSAXXMLReader_iface, pSecureBaseUrl);
2954 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2955 ISAXXMLReader* iface,
2956 const WCHAR *secureBaseUrl)
2958 saxreader *This = impl_from_ISAXXMLReader( iface );
2959 return IVBSAXXMLReader_put_secureBaseURL(&This->IVBSAXXMLReader_iface, secureBaseUrl);
2962 static HRESULT WINAPI isaxxmlreader_parse(
2963 ISAXXMLReader* iface,
2966 saxreader *This = impl_from_ISAXXMLReader( iface );
2967 return internal_parse(This, varInput, FALSE);
2970 static HRESULT WINAPI isaxxmlreader_parseURL(
2971 ISAXXMLReader* iface,
2974 saxreader *This = impl_from_ISAXXMLReader( iface );
2975 return internal_parseURL(This, url, FALSE);
2978 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2980 isaxxmlreader_QueryInterface,
2981 isaxxmlreader_AddRef,
2982 isaxxmlreader_Release,
2983 isaxxmlreader_getFeature,
2984 isaxxmlreader_putFeature,
2985 isaxxmlreader_getProperty,
2986 isaxxmlreader_putProperty,
2987 isaxxmlreader_getEntityResolver,
2988 isaxxmlreader_putEntityResolver,
2989 isaxxmlreader_getContentHandler,
2990 isaxxmlreader_putContentHandler,
2991 isaxxmlreader_getDTDHandler,
2992 isaxxmlreader_putDTDHandler,
2993 isaxxmlreader_getErrorHandler,
2994 isaxxmlreader_putErrorHandler,
2995 isaxxmlreader_getBaseURL,
2996 isaxxmlreader_putBaseURL,
2997 isaxxmlreader_getSecureBaseURL,
2998 isaxxmlreader_putSecureBaseURL,
2999 isaxxmlreader_parse,
3000 isaxxmlreader_parseURL
3003 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
3007 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
3009 reader = heap_alloc( sizeof (*reader) );
3011 return E_OUTOFMEMORY;
3013 reader->IVBSAXXMLReader_iface.lpVtbl = &saxreader_vtbl;
3014 reader->ISAXXMLReader_iface.lpVtbl = &isaxreader_vtbl;
3016 reader->contentHandler = NULL;
3017 reader->vbcontentHandler = NULL;
3018 reader->errorHandler = NULL;
3019 reader->vberrorHandler = NULL;
3020 reader->lexicalHandler = NULL;
3021 reader->vblexicalHandler = NULL;
3022 reader->declHandler = NULL;
3023 reader->vbdeclHandler = NULL;
3024 reader->isParsing = FALSE;
3025 reader->pool.pool = NULL;
3026 reader->pool.index = 0;
3027 reader->pool.len = 0;
3028 reader->features = 0;
3030 memset(&reader->sax, 0, sizeof(xmlSAXHandler));
3031 reader->sax.initialized = XML_SAX2_MAGIC;
3032 reader->sax.startDocument = libxmlStartDocument;
3033 reader->sax.endDocument = libxmlEndDocument;
3034 reader->sax.startElementNs = libxmlStartElementNS;
3035 reader->sax.endElementNs = libxmlEndElementNS;
3036 reader->sax.characters = libxmlCharacters;
3037 reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
3038 reader->sax.comment = libxmlComment;
3039 reader->sax.error = libxmlFatalError;
3040 reader->sax.fatalError = libxmlFatalError;
3041 reader->sax.cdataBlock = libxmlCDataBlock;
3043 *ppObj = &reader->IVBSAXXMLReader_iface;
3045 TRACE("returning iface %p\n", *ppObj);
3052 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
3054 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
3055 "libxml2 support was not present at compile time.\n");