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
38 #include "wine/debug.h"
40 #include "msxml_private.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
46 #include <libxml/SAX2.h>
47 #include <libxml/parserInternals.h>
49 typedef struct _saxreader
51 const struct IVBSAXXMLReaderVtbl *lpVBSAXXMLReaderVtbl;
52 const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
54 struct ISAXContentHandler *contentHandler;
55 struct IVBSAXContentHandler *vbcontentHandler;
56 struct ISAXErrorHandler *errorHandler;
57 struct IVBSAXErrorHandler *vberrorHandler;
58 struct ISAXLexicalHandler *lexicalHandler;
59 struct IVBSAXLexicalHandler *vblexicalHandler;
60 struct ISAXDeclHandler *declHandler;
61 struct IVBSAXDeclHandler *vbdeclHandler;
66 typedef struct _saxlocator
68 const struct IVBSAXLocatorVtbl *lpVBSAXLocatorVtbl;
69 const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
73 xmlParserCtxtPtr pParserCtxt;
87 typedef struct _saxattributes
89 const struct IVBSAXAttributesVtbl *lpVBSAXAttributesVtbl;
90 const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
99 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
101 return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVBSAXXMLReaderVtbl));
104 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
106 return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
109 static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
111 return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpVBSAXLocatorVtbl));
114 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
116 return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
119 static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
121 return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpVBSAXAttributesVtbl));
124 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
126 return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
129 static inline BOOL has_content_handler(const saxlocator *locator)
131 return (locator->vbInterface && locator->saxreader->vbcontentHandler) ||
132 (!locator->vbInterface && locator->saxreader->contentHandler);
135 static HRESULT namespacePush(saxlocator *locator, int ns)
137 if(locator->nsStackLast>=locator->nsStackSize)
141 new_stack = HeapReAlloc(GetProcessHeap(), 0,
142 locator->nsStack, sizeof(int)*locator->nsStackSize*2);
143 if(!new_stack) return E_OUTOFMEMORY;
144 locator->nsStack = new_stack;
145 locator->nsStackSize *= 2;
147 locator->nsStack[locator->nsStackLast++] = ns;
152 static int namespacePop(saxlocator *locator)
154 if(locator->nsStackLast == 0) return 0;
155 return locator->nsStack[--locator->nsStackLast];
158 static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
167 dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
168 if(len != -1) dLen++;
169 str = heap_alloc(dLen * sizeof (WCHAR));
172 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, str, dLen);
173 if(len != -1) str[dLen-1] = '\0';
174 bstr = SysAllocString(str);
180 static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
186 if(!name) return NULL;
188 if(!prefix || *prefix=='\0')
189 return bstr_from_xmlChar(name);
191 dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, NULL, 0)
192 + MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, NULL, 0);
193 str = heap_alloc(dLen * sizeof(WCHAR));
197 dLast = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, str, dLen);
199 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &str[dLast], dLen-dLast);
200 bstr = SysAllocString(str);
207 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
209 xmlStopParser(This->pParserCtxt);
212 if((This->vbInterface && This->saxreader->vberrorHandler)
213 || (!This->vbInterface && This->saxreader->errorHandler))
216 if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
217 NULL, hr, 0, msg, sizeof(msg), NULL))
219 FIXME("MSXML errors not yet supported.\n");
223 if(This->vbInterface)
225 BSTR bstrMsg = SysAllocString(msg);
226 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
227 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrMsg, hr);
230 ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
231 (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
235 static void update_position(saxlocator *This, xmlChar *end)
237 if(This->lastCur == NULL)
239 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
241 This->realColumn = 1;
243 else if(This->lastCur < This->pParserCtxt->input->base)
245 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
247 This->realColumn = 1;
250 if(This->pParserCtxt->input->cur<This->lastCur)
252 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
254 This->realColumn = 1;
257 if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
259 while(This->lastCur < end)
261 if(*(This->lastCur) == '\n')
264 This->realColumn = 1;
266 else if(*(This->lastCur) == '\r' &&
267 (This->lastCur==This->pParserCtxt->input->end ||
268 *(This->lastCur+1)!='\n'))
271 This->realColumn = 1;
273 else This->realColumn++;
277 /* Count multibyte UTF8 encoded characters once */
278 while((*(This->lastCur)&0xC0) == 0x80) This->lastCur++;
281 This->line = This->realLine;
282 This->column = This->realColumn;
285 /*** IVBSAXAttributes interface ***/
286 /*** IUnknown methods ***/
287 static HRESULT WINAPI ivbsaxattributes_QueryInterface(
288 IVBSAXAttributes* iface,
292 saxattributes *This = impl_from_IVBSAXAttributes(iface);
294 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
298 if (IsEqualGUID(riid, &IID_IUnknown) ||
299 IsEqualGUID(riid, &IID_IDispatch) ||
300 IsEqualGUID(riid, &IID_IVBSAXAttributes))
306 FIXME("interface %s not implemented\n", debugstr_guid(riid));
307 return E_NOINTERFACE;
310 IVBSAXAttributes_AddRef(iface);
315 static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
317 saxattributes *This = impl_from_IVBSAXAttributes(iface);
318 return ISAXAttributes_AddRef((ISAXAttributes*)&This->lpSAXAttributesVtbl);
321 static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
323 saxattributes *This = impl_from_IVBSAXAttributes(iface);
324 return ISAXAttributes_Release((ISAXAttributes*)&This->lpSAXAttributesVtbl);
327 /*** IDispatch methods ***/
328 static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
330 saxattributes *This = impl_from_IVBSAXAttributes( iface );
332 TRACE("(%p)->(%p)\n", This, pctinfo);
339 static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
340 IVBSAXAttributes *iface,
341 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
343 saxattributes *This = impl_from_IVBSAXAttributes( iface );
346 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
348 hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
353 static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
354 IVBSAXAttributes *iface,
361 saxattributes *This = impl_from_IVBSAXAttributes( iface );
365 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
368 if(!rgszNames || cNames == 0 || !rgDispId)
371 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
374 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
375 ITypeInfo_Release(typeinfo);
381 static HRESULT WINAPI ivbsaxattributes_Invoke(
382 IVBSAXAttributes *iface,
387 DISPPARAMS* pDispParams,
389 EXCEPINFO* pExcepInfo,
392 saxattributes *This = impl_from_IVBSAXAttributes( iface );
396 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
397 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
399 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
402 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXAttributesVtbl), dispIdMember, wFlags, pDispParams,
403 pVarResult, pExcepInfo, puArgErr);
404 ITypeInfo_Release(typeinfo);
410 /*** IVBSAXAttributes methods ***/
411 static HRESULT WINAPI ivbsaxattributes_get_length(
412 IVBSAXAttributes* iface,
415 saxattributes *This = impl_from_IVBSAXAttributes( iface );
416 return ISAXAttributes_getLength(
417 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
421 static HRESULT WINAPI ivbsaxattributes_getURI(
422 IVBSAXAttributes* iface,
427 saxattributes *This = impl_from_IVBSAXAttributes( iface );
428 return ISAXAttributes_getURI(
429 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
430 nIndex, (const WCHAR**)uri, &len);
433 static HRESULT WINAPI ivbsaxattributes_getLocalName(
434 IVBSAXAttributes* iface,
439 saxattributes *This = impl_from_IVBSAXAttributes( iface );
440 return ISAXAttributes_getLocalName(
441 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
442 nIndex, (const WCHAR**)localName, &len);
445 static HRESULT WINAPI ivbsaxattributes_getQName(
446 IVBSAXAttributes* iface,
451 saxattributes *This = impl_from_IVBSAXAttributes( iface );
452 return ISAXAttributes_getQName(
453 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
454 nIndex, (const WCHAR**)QName, &len);
457 static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
458 IVBSAXAttributes* iface,
463 saxattributes *This = impl_from_IVBSAXAttributes( iface );
464 return ISAXAttributes_getIndexFromName(
465 (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
466 localName, SysStringLen(localName), index);
469 static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
470 IVBSAXAttributes* iface,
474 saxattributes *This = impl_from_IVBSAXAttributes( iface );
475 return ISAXAttributes_getIndexFromQName(
476 (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
477 SysStringLen(QName), index);
480 static HRESULT WINAPI ivbsaxattributes_getType(
481 IVBSAXAttributes* iface,
486 saxattributes *This = impl_from_IVBSAXAttributes( iface );
487 return ISAXAttributes_getType(
488 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
489 nIndex, (const WCHAR**)type, &len);
492 static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
493 IVBSAXAttributes* iface,
499 saxattributes *This = impl_from_IVBSAXAttributes( iface );
500 return ISAXAttributes_getTypeFromName(
501 (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
502 localName, SysStringLen(localName), (const WCHAR**)type, &len);
505 static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
506 IVBSAXAttributes* iface,
511 saxattributes *This = impl_from_IVBSAXAttributes( iface );
512 return ISAXAttributes_getTypeFromQName(
513 (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
514 SysStringLen(QName), (const WCHAR**)type, &len);
517 static HRESULT WINAPI ivbsaxattributes_getValue(
518 IVBSAXAttributes* iface,
523 saxattributes *This = impl_from_IVBSAXAttributes( iface );
524 return ISAXAttributes_getValue(
525 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
526 nIndex, (const WCHAR**)value, &len);
529 static HRESULT WINAPI ivbsaxattributes_getValueFromName(
530 IVBSAXAttributes* iface,
536 saxattributes *This = impl_from_IVBSAXAttributes( iface );
537 return ISAXAttributes_getValueFromName(
538 (ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
539 localName, SysStringLen(localName), (const WCHAR**)value, &len);
542 static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
543 IVBSAXAttributes* iface,
548 saxattributes *This = impl_from_IVBSAXAttributes( iface );
549 return ISAXAttributes_getValueFromQName(
550 (ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
551 SysStringLen(QName), (const WCHAR**)value, &len);
554 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
556 ivbsaxattributes_QueryInterface,
557 ivbsaxattributes_AddRef,
558 ivbsaxattributes_Release,
559 ivbsaxattributes_GetTypeInfoCount,
560 ivbsaxattributes_GetTypeInfo,
561 ivbsaxattributes_GetIDsOfNames,
562 ivbsaxattributes_Invoke,
563 ivbsaxattributes_get_length,
564 ivbsaxattributes_getURI,
565 ivbsaxattributes_getLocalName,
566 ivbsaxattributes_getQName,
567 ivbsaxattributes_getIndexFromName,
568 ivbsaxattributes_getIndexFromQName,
569 ivbsaxattributes_getType,
570 ivbsaxattributes_getTypeFromName,
571 ivbsaxattributes_getTypeFromQName,
572 ivbsaxattributes_getValue,
573 ivbsaxattributes_getValueFromName,
574 ivbsaxattributes_getValueFromQName
577 /*** ISAXAttributes interface ***/
578 /*** IUnknown methods ***/
579 static HRESULT WINAPI isaxattributes_QueryInterface(
580 ISAXAttributes* iface,
584 saxattributes *This = impl_from_ISAXAttributes(iface);
586 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
590 if (IsEqualGUID(riid, &IID_IUnknown) ||
591 IsEqualGUID(riid, &IID_ISAXAttributes))
597 FIXME("interface %s not implemented\n", debugstr_guid(riid));
598 return E_NOINTERFACE;
601 ISAXAttributes_AddRef(iface);
606 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
608 saxattributes *This = impl_from_ISAXAttributes(iface);
610 return InterlockedIncrement(&This->ref);
613 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
615 saxattributes *This = impl_from_ISAXAttributes(iface);
620 ref = InterlockedDecrement(&This->ref);
624 for(index=0; index<This->nb_attributes; index++)
626 SysFreeString(This->szLocalname[index]);
627 SysFreeString(This->szURI[index]);
628 SysFreeString(This->szValue[index]);
629 SysFreeString(This->szQName[index]);
632 heap_free(This->szLocalname);
633 heap_free(This->szURI);
634 heap_free(This->szValue);
635 heap_free(This->szQName);
643 /*** ISAXAttributes methods ***/
644 static HRESULT WINAPI isaxattributes_getLength(
645 ISAXAttributes* iface,
648 saxattributes *This = impl_from_ISAXAttributes( iface );
650 *length = This->nb_attributes;
651 TRACE("Length set to %d\n", *length);
655 static HRESULT WINAPI isaxattributes_getURI(
656 ISAXAttributes* iface,
661 saxattributes *This = impl_from_ISAXAttributes( iface );
662 TRACE("(%p)->(%d)\n", This, nIndex);
664 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
665 if(!pUrl || !pUriSize) return E_POINTER;
667 *pUriSize = SysStringLen(This->szURI[nIndex]);
668 *pUrl = This->szURI[nIndex];
673 static HRESULT WINAPI isaxattributes_getLocalName(
674 ISAXAttributes* iface,
676 const WCHAR **pLocalName,
677 int *pLocalNameLength)
679 saxattributes *This = impl_from_ISAXAttributes( iface );
680 TRACE("(%p)->(%d)\n", This, nIndex);
682 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
683 if(!pLocalName || !pLocalNameLength) return E_POINTER;
685 *pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
686 *pLocalName = This->szLocalname[nIndex];
691 static HRESULT WINAPI isaxattributes_getQName(
692 ISAXAttributes* iface,
694 const WCHAR **pQName,
697 saxattributes *This = impl_from_ISAXAttributes( iface );
698 TRACE("(%p)->(%d)\n", This, nIndex);
700 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
701 if(!pQName || !pQNameLength) return E_POINTER;
703 *pQNameLength = SysStringLen(This->szQName[nIndex]);
704 *pQName = This->szQName[nIndex];
709 static HRESULT WINAPI isaxattributes_getName(
710 ISAXAttributes* iface,
714 const WCHAR **pLocalName,
716 const WCHAR **pQName,
719 saxattributes *This = impl_from_ISAXAttributes( iface );
720 TRACE("(%p)->(%d)\n", This, nIndex);
722 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
723 if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
724 || !pQName || !pQNameLength) return E_POINTER;
726 *pUriLength = SysStringLen(This->szURI[nIndex]);
727 *pUri = This->szURI[nIndex];
728 *pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
729 *pLocalName = This->szLocalname[nIndex];
730 *pQNameLength = SysStringLen(This->szQName[nIndex]);
731 *pQName = This->szQName[nIndex];
736 static HRESULT WINAPI isaxattributes_getIndexFromName(
737 ISAXAttributes* iface,
740 const WCHAR *pLocalName,
744 saxattributes *This = impl_from_ISAXAttributes( iface );
746 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
747 debugstr_w(pLocalName), cocalNameLength);
749 if(!pUri || !pLocalName || !index) return E_POINTER;
751 for(i=0; i<This->nb_attributes; i++)
753 if(cUriLength!=SysStringLen(This->szURI[i])
754 || cocalNameLength!=SysStringLen(This->szLocalname[i]))
756 if(cUriLength && memcmp(pUri, This->szURI[i],
757 sizeof(WCHAR)*cUriLength))
759 if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
760 sizeof(WCHAR)*cocalNameLength))
770 static HRESULT WINAPI isaxattributes_getIndexFromQName(
771 ISAXAttributes* iface,
776 saxattributes *This = impl_from_ISAXAttributes( iface );
778 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQNameLength);
780 if(!pQName || !index) return E_POINTER;
781 if(!nQNameLength) return E_INVALIDARG;
783 for(i=0; i<This->nb_attributes; i++)
785 if(nQNameLength!=SysStringLen(This->szQName[i])) continue;
786 if(memcmp(pQName, This->szQName, sizeof(WCHAR)*nQNameLength)) continue;
795 static HRESULT WINAPI isaxattributes_getType(
796 ISAXAttributes* iface,
801 saxattributes *This = impl_from_ISAXAttributes( iface );
803 FIXME("(%p)->(%d) stub\n", This, nIndex);
807 static HRESULT WINAPI isaxattributes_getTypeFromName(
808 ISAXAttributes* iface,
811 const WCHAR *pLocalName,
816 saxattributes *This = impl_from_ISAXAttributes( iface );
818 FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
819 debugstr_w(pLocalName), nLocalName);
823 static HRESULT WINAPI isaxattributes_getTypeFromQName(
824 ISAXAttributes* iface,
830 saxattributes *This = impl_from_ISAXAttributes( iface );
832 FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
836 static HRESULT WINAPI isaxattributes_getValue(
837 ISAXAttributes* iface,
839 const WCHAR **pValue,
842 saxattributes *This = impl_from_ISAXAttributes( iface );
843 TRACE("(%p)->(%d)\n", This, nIndex);
845 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
846 if(!pValue || !nValue) return E_POINTER;
848 *nValue = SysStringLen(This->szValue[nIndex]);
849 *pValue = This->szValue[nIndex];
854 static HRESULT WINAPI isaxattributes_getValueFromName(
855 ISAXAttributes* iface,
858 const WCHAR *pLocalName,
860 const WCHAR **pValue,
865 saxattributes *This = impl_from_ISAXAttributes( iface );
866 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), nUri,
867 debugstr_w(pLocalName), nLocalName);
869 hr = ISAXAttributes_getIndexFromName(iface,
870 pUri, nUri, pLocalName, nLocalName, &index);
871 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
876 static HRESULT WINAPI isaxattributes_getValueFromQName(
877 ISAXAttributes* iface,
880 const WCHAR **pValue,
885 saxattributes *This = impl_from_ISAXAttributes( iface );
886 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQName);
888 hr = ISAXAttributes_getIndexFromQName(iface, pQName, nQName, &index);
889 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
894 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
896 isaxattributes_QueryInterface,
897 isaxattributes_AddRef,
898 isaxattributes_Release,
899 isaxattributes_getLength,
900 isaxattributes_getURI,
901 isaxattributes_getLocalName,
902 isaxattributes_getQName,
903 isaxattributes_getName,
904 isaxattributes_getIndexFromName,
905 isaxattributes_getIndexFromQName,
906 isaxattributes_getType,
907 isaxattributes_getTypeFromName,
908 isaxattributes_getTypeFromQName,
909 isaxattributes_getValue,
910 isaxattributes_getValueFromName,
911 isaxattributes_getValueFromQName
914 static HRESULT SAXAttributes_create(saxattributes **attr,
915 int nb_namespaces, const xmlChar **xmlNamespaces,
916 int nb_attributes, const xmlChar **xmlAttributes)
918 saxattributes *attributes;
920 static const xmlChar xmlns[] = "xmlns";
922 attributes = heap_alloc(sizeof(*attributes));
924 return E_OUTOFMEMORY;
926 attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
927 attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
930 attributes->nb_attributes = nb_namespaces+nb_attributes;
932 attributes->szLocalname = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
933 attributes->szURI = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
934 attributes->szValue = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
935 attributes->szQName = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
937 if(!attributes->szLocalname || !attributes->szURI
938 || !attributes->szValue || !attributes->szQName)
940 heap_free(attributes->szLocalname);
941 heap_free(attributes->szURI);
942 heap_free(attributes->szValue);
943 heap_free(attributes->szQName);
944 heap_free(attributes);
948 for(index=0; index<nb_namespaces; index++)
950 attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
951 attributes->szURI[index] = SysAllocStringLen(NULL, 0);
952 attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
953 attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
956 for(index=0; index<nb_attributes; index++)
958 attributes->szLocalname[nb_namespaces+index] =
959 bstr_from_xmlChar(xmlAttributes[index*5]);
960 attributes->szURI[nb_namespaces+index] =
961 bstr_from_xmlChar(xmlAttributes[index*5+2]);
962 attributes->szValue[nb_namespaces+index] =
963 bstr_from_xmlCharN(xmlAttributes[index*5+3],
964 xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
965 attributes->szQName[nb_namespaces+index] =
966 QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
971 TRACE("returning %p\n", *attr);
976 /*** LibXML callbacks ***/
977 static void libxmlStartDocument(void *ctx)
979 saxlocator *This = ctx;
982 if(has_content_handler(This))
984 if(This->vbInterface)
985 hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
987 hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
990 format_error_message_from_id(This, hr);
993 update_position(This, NULL);
996 static void libxmlEndDocument(void *ctx)
998 saxlocator *This = ctx;
1004 if(This->ret != S_OK) return;
1006 if(has_content_handler(This))
1008 if(This->vbInterface)
1009 hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1011 hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1014 format_error_message_from_id(This, hr);
1018 static void libxmlStartElementNS(
1020 const xmlChar *localname,
1021 const xmlChar *prefix,
1024 const xmlChar **namespaces,
1027 const xmlChar **attributes)
1029 BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
1030 saxlocator *This = ctx;
1032 saxattributes *attr;
1035 if(*(This->pParserCtxt->input->cur) == '/')
1036 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+2);
1038 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
1040 hr = namespacePush(This, nb_namespaces);
1041 if(hr==S_OK && has_content_handler(This))
1043 for(index=0; index<nb_namespaces; index++)
1045 Prefix = bstr_from_xmlChar(namespaces[2*index]);
1046 Uri = bstr_from_xmlChar(namespaces[2*index+1]);
1048 if(This->vbInterface)
1049 hr = IVBSAXContentHandler_startPrefixMapping(
1050 This->saxreader->vbcontentHandler,
1053 hr = ISAXContentHandler_startPrefixMapping(
1054 This->saxreader->contentHandler,
1055 Prefix, SysStringLen(Prefix),
1056 Uri, SysStringLen(Uri));
1058 SysFreeString(Prefix);
1063 format_error_message_from_id(This, hr);
1068 NamespaceUri = bstr_from_xmlChar(URI);
1069 LocalName = bstr_from_xmlChar(localname);
1070 QName = QName_from_xmlChar(prefix, localname);
1072 hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
1075 if(This->vbInterface)
1076 hr = IVBSAXContentHandler_startElement(
1077 This->saxreader->vbcontentHandler,
1078 &NamespaceUri, &LocalName, &QName,
1079 (IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
1081 hr = ISAXContentHandler_startElement(
1082 This->saxreader->contentHandler,
1083 NamespaceUri, SysStringLen(NamespaceUri),
1084 LocalName, SysStringLen(LocalName),
1085 QName, SysStringLen(QName),
1086 (ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1088 ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1091 SysFreeString(NamespaceUri);
1092 SysFreeString(LocalName);
1093 SysFreeString(QName);
1097 format_error_message_from_id(This, hr);
1100 static void libxmlEndElementNS(
1102 const xmlChar *localname,
1103 const xmlChar *prefix,
1106 BSTR NamespaceUri, LocalName, QName, Prefix;
1107 saxlocator *This = ctx;
1112 end = (xmlChar*)This->pParserCtxt->input->cur;
1113 if(*(end-1) != '>' || *(end-2) != '/')
1114 while(end-2>=This->pParserCtxt->input->base
1115 && *(end-2)!='<' && *(end-1)!='/') end--;
1117 update_position(This, end);
1119 nsNr = namespacePop(This);
1121 if(has_content_handler(This))
1123 NamespaceUri = bstr_from_xmlChar(URI);
1124 LocalName = bstr_from_xmlChar(localname);
1125 QName = QName_from_xmlChar(prefix, localname);
1127 if(This->vbInterface)
1128 hr = IVBSAXContentHandler_endElement(
1129 This->saxreader->vbcontentHandler,
1130 &NamespaceUri, &LocalName, &QName);
1132 hr = ISAXContentHandler_endElement(
1133 This->saxreader->contentHandler,
1134 NamespaceUri, SysStringLen(NamespaceUri),
1135 LocalName, SysStringLen(LocalName),
1136 QName, SysStringLen(QName));
1138 SysFreeString(NamespaceUri);
1139 SysFreeString(LocalName);
1140 SysFreeString(QName);
1144 format_error_message_from_id(This, hr);
1148 for(index=This->pParserCtxt->nsNr-2;
1149 index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
1151 Prefix = bstr_from_xmlChar(This->pParserCtxt->nsTab[index]);
1153 if(This->vbInterface)
1154 hr = IVBSAXContentHandler_endPrefixMapping(
1155 This->saxreader->vbcontentHandler, &Prefix);
1157 hr = ISAXContentHandler_endPrefixMapping(
1158 This->saxreader->contentHandler,
1159 Prefix, SysStringLen(Prefix));
1161 SysFreeString(Prefix);
1165 format_error_message_from_id(This, hr);
1172 update_position(This, NULL);
1175 static void libxmlCharacters(
1180 saxlocator *This = ctx;
1185 BOOL lastEvent = FALSE;
1187 if(!(has_content_handler(This))) return;
1190 if(*(ch-1)=='\r') cur--;
1193 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1198 while(end-ch<len && *end!='\r') end++;
1205 if(!lastEvent) *end = '\n';
1207 Chars = bstr_from_xmlCharN(cur, end-cur+1);
1208 if(This->vbInterface)
1209 hr = IVBSAXContentHandler_characters(
1210 This->saxreader->vbcontentHandler, &Chars);
1212 hr = ISAXContentHandler_characters(
1213 This->saxreader->contentHandler,
1214 Chars, SysStringLen(Chars));
1215 SysFreeString(Chars);
1219 format_error_message_from_id(This, hr);
1223 This->column += end-cur+1;
1237 if(end-ch == len) break;
1240 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1241 This->column = This->realColumn
1242 +This->pParserCtxt->input->cur-This->lastCur;
1245 static void libxmlSetDocumentLocator(
1247 xmlSAXLocatorPtr loc)
1249 saxlocator *This = ctx;
1252 if(This->vbInterface)
1253 hr = IVBSAXContentHandler_putref_documentLocator(
1254 This->saxreader->vbcontentHandler,
1255 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
1257 hr = ISAXContentHandler_putDocumentLocator(
1258 This->saxreader->contentHandler,
1259 (ISAXLocator*)&This->lpSAXLocatorVtbl);
1262 format_error_message_from_id(This, hr);
1265 static void libxmlComment(void *ctx, const xmlChar *value)
1267 saxlocator *This = ctx;
1270 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur;
1272 while(beg-4>=This->pParserCtxt->input->base
1273 && memcmp(beg-4, "<!--", sizeof(char[4]))) beg--;
1274 update_position(This, beg);
1276 if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1277 if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1279 bValue = bstr_from_xmlChar(value);
1281 if(This->vbInterface)
1282 hr = IVBSAXLexicalHandler_comment(
1283 This->saxreader->vblexicalHandler, &bValue);
1285 hr = ISAXLexicalHandler_comment(
1286 This->saxreader->lexicalHandler,
1287 bValue, SysStringLen(bValue));
1289 SysFreeString(bValue);
1292 format_error_message_from_id(This, hr);
1294 update_position(This, NULL);
1297 static void libxmlFatalError(void *ctx, const char *msg, ...)
1299 saxlocator *This = ctx;
1305 if((This->vbInterface && !This->saxreader->vberrorHandler)
1306 || (!This->vbInterface && !This->saxreader->errorHandler))
1308 xmlStopParser(This->pParserCtxt);
1313 FIXME("Error handling is not compatible.\n");
1315 va_start(args, msg);
1316 vsprintf(message, msg, args);
1319 len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1320 wszError = heap_alloc(sizeof(WCHAR)*len);
1322 MultiByteToWideChar(CP_UNIXCP, 0, message, -1, wszError, len);
1324 if(This->vbInterface)
1326 BSTR bstrError = SysAllocString(wszError);
1327 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
1328 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
1331 ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
1332 (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
1334 heap_free(wszError);
1336 xmlStopParser(This->pParserCtxt);
1340 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1342 saxlocator *This = ctx;
1344 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1348 BOOL lastEvent = FALSE, change;
1350 while(beg-9>=This->pParserCtxt->input->base
1351 && memcmp(beg-9, "<![CDATA[", sizeof(char[9]))) beg--;
1352 update_position(This, beg);
1354 if(This->vbInterface && This->saxreader->vblexicalHandler)
1355 hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1356 if(!This->vbInterface && This->saxreader->lexicalHandler)
1357 hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1361 format_error_message_from_id(This, hr);
1365 realLen = This->pParserCtxt->input->cur-beg-3;
1371 while(end-beg<realLen && *end!='\r') end++;
1372 if(end-beg==realLen)
1377 else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1380 if(*end == '\r') change = TRUE;
1381 else change = FALSE;
1383 if(change) *end = '\n';
1385 if(has_content_handler(This))
1387 Chars = bstr_from_xmlCharN(cur, end-cur+1);
1388 if(This->vbInterface)
1389 hr = IVBSAXContentHandler_characters(
1390 This->saxreader->vbcontentHandler, &Chars);
1392 hr = ISAXContentHandler_characters(
1393 This->saxreader->contentHandler,
1394 Chars, SysStringLen(Chars));
1395 SysFreeString(Chars);
1398 if(change) *end = '\r';
1403 This->column += end-cur+2;
1408 if(This->vbInterface && This->saxreader->vblexicalHandler)
1409 hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1410 if(!This->vbInterface && This->saxreader->lexicalHandler)
1411 hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1414 format_error_message_from_id(This, hr);
1416 This->column += 4+end-cur;
1419 /*** IVBSAXLocator interface ***/
1420 /*** IUnknown methods ***/
1421 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1423 saxlocator *This = impl_from_IVBSAXLocator( iface );
1425 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1429 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1430 IsEqualGUID( riid, &IID_IDispatch) ||
1431 IsEqualGUID( riid, &IID_IVBSAXLocator ))
1437 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1438 return E_NOINTERFACE;
1441 IVBSAXLocator_AddRef( iface );
1446 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1448 saxlocator *This = impl_from_IVBSAXLocator( iface );
1449 TRACE("%p\n", This );
1450 return InterlockedIncrement( &This->ref );
1453 static ULONG WINAPI ivbsaxlocator_Release(
1454 IVBSAXLocator* iface)
1456 saxlocator *This = impl_from_IVBSAXLocator( iface );
1457 return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1460 /*** IDispatch methods ***/
1461 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1463 saxlocator *This = impl_from_IVBSAXLocator( iface );
1465 TRACE("(%p)->(%p)\n", This, pctinfo);
1472 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1473 IVBSAXLocator *iface,
1474 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1476 saxlocator *This = impl_from_IVBSAXLocator( iface );
1479 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1481 hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1486 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1487 IVBSAXLocator *iface,
1489 LPOLESTR* rgszNames,
1494 saxlocator *This = impl_from_IVBSAXLocator( iface );
1495 ITypeInfo *typeinfo;
1498 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1501 if(!rgszNames || cNames == 0 || !rgDispId)
1502 return E_INVALIDARG;
1504 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1507 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1508 ITypeInfo_Release(typeinfo);
1514 static HRESULT WINAPI ivbsaxlocator_Invoke(
1515 IVBSAXLocator *iface,
1516 DISPID dispIdMember,
1520 DISPPARAMS* pDispParams,
1521 VARIANT* pVarResult,
1522 EXCEPINFO* pExcepInfo,
1525 saxlocator *This = impl_from_IVBSAXLocator( iface );
1526 ITypeInfo *typeinfo;
1529 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1530 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1532 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1535 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1536 pVarResult, pExcepInfo, puArgErr);
1537 ITypeInfo_Release(typeinfo);
1543 /*** IVBSAXLocator methods ***/
1544 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1545 IVBSAXLocator* iface,
1548 saxlocator *This = impl_from_IVBSAXLocator( iface );
1549 return ISAXLocator_getColumnNumber(
1550 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1554 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1555 IVBSAXLocator* iface,
1558 saxlocator *This = impl_from_IVBSAXLocator( iface );
1559 return ISAXLocator_getLineNumber(
1560 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1564 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1565 IVBSAXLocator* iface,
1568 saxlocator *This = impl_from_IVBSAXLocator( iface );
1569 return ISAXLocator_getPublicId(
1570 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1571 (const WCHAR**)publicId);
1574 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1575 IVBSAXLocator* iface,
1578 saxlocator *This = impl_from_IVBSAXLocator( iface );
1579 return ISAXLocator_getSystemId(
1580 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1581 (const WCHAR**)systemId);
1584 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1586 ivbsaxlocator_QueryInterface,
1587 ivbsaxlocator_AddRef,
1588 ivbsaxlocator_Release,
1589 ivbsaxlocator_GetTypeInfoCount,
1590 ivbsaxlocator_GetTypeInfo,
1591 ivbsaxlocator_GetIDsOfNames,
1592 ivbsaxlocator_Invoke,
1593 ivbsaxlocator_get_columnNumber,
1594 ivbsaxlocator_get_lineNumber,
1595 ivbsaxlocator_get_publicId,
1596 ivbsaxlocator_get_systemId
1599 /*** ISAXLocator interface ***/
1600 /*** IUnknown methods ***/
1601 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1603 saxlocator *This = impl_from_ISAXLocator( iface );
1605 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1609 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1610 IsEqualGUID( riid, &IID_ISAXLocator ))
1616 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1617 return E_NOINTERFACE;
1620 ISAXLocator_AddRef( iface );
1625 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1627 saxlocator *This = impl_from_ISAXLocator( iface );
1628 TRACE("%p\n", This );
1629 return InterlockedIncrement( &This->ref );
1632 static ULONG WINAPI isaxlocator_Release(
1635 saxlocator *This = impl_from_ISAXLocator( iface );
1638 TRACE("%p\n", This );
1640 ref = InterlockedDecrement( &This->ref );
1643 SysFreeString(This->publicId);
1644 SysFreeString(This->systemId);
1645 heap_free(This->nsStack);
1647 ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1654 /*** ISAXLocator methods ***/
1655 static HRESULT WINAPI isaxlocator_getColumnNumber(
1659 saxlocator *This = impl_from_ISAXLocator( iface );
1661 *pnColumn = This->column;
1665 static HRESULT WINAPI isaxlocator_getLineNumber(
1669 saxlocator *This = impl_from_ISAXLocator( iface );
1671 *pnLine = This->line;
1675 static HRESULT WINAPI isaxlocator_getPublicId(
1677 const WCHAR ** ppwchPublicId)
1680 saxlocator *This = impl_from_ISAXLocator( iface );
1682 SysFreeString(This->publicId);
1684 publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1685 if(SysStringLen(publicId))
1686 This->publicId = (WCHAR*)&publicId;
1689 SysFreeString(publicId);
1690 This->publicId = NULL;
1693 *ppwchPublicId = This->publicId;
1697 static HRESULT WINAPI isaxlocator_getSystemId(
1699 const WCHAR ** ppwchSystemId)
1702 saxlocator *This = impl_from_ISAXLocator( iface );
1704 SysFreeString(This->systemId);
1706 systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1707 if(SysStringLen(systemId))
1708 This->systemId = (WCHAR*)&systemId;
1711 SysFreeString(systemId);
1712 This->systemId = NULL;
1715 *ppwchSystemId = This->systemId;
1719 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1721 isaxlocator_QueryInterface,
1723 isaxlocator_Release,
1724 isaxlocator_getColumnNumber,
1725 isaxlocator_getLineNumber,
1726 isaxlocator_getPublicId,
1727 isaxlocator_getSystemId
1730 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1732 saxlocator *locator;
1734 locator = heap_alloc( sizeof (*locator) );
1736 return E_OUTOFMEMORY;
1738 locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1739 locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1741 locator->vbInterface = vbInterface;
1743 locator->saxreader = reader;
1744 ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1746 locator->pParserCtxt = NULL;
1747 locator->publicId = NULL;
1748 locator->systemId = NULL;
1749 locator->lastCur = NULL;
1751 locator->column = 0;
1752 locator->ret = S_OK;
1753 locator->nsStackSize = 8;
1754 locator->nsStackLast = 0;
1755 locator->nsStack = heap_alloc(sizeof(int)*locator->nsStackSize);
1756 if(!locator->nsStack)
1758 ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1760 return E_OUTOFMEMORY;
1763 *ppsaxlocator = locator;
1765 TRACE("returning %p\n", *ppsaxlocator);
1770 /*** SAXXMLReader internal functions ***/
1771 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1773 saxlocator *locator;
1776 hr = SAXLocator_create(This, &locator, vbInterface);
1780 locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1781 if(!locator->pParserCtxt)
1783 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1787 xmlFree(locator->pParserCtxt->sax);
1788 locator->pParserCtxt->sax = &locator->saxreader->sax;
1789 locator->pParserCtxt->userData = locator;
1791 This->isParsing = TRUE;
1792 if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1793 else hr = locator->ret;
1794 This->isParsing = FALSE;
1796 if(locator->pParserCtxt)
1798 locator->pParserCtxt->sax = NULL;
1799 xmlFreeParserCtxt(locator->pParserCtxt);
1800 locator->pParserCtxt = NULL;
1803 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1807 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
1809 saxlocator *locator;
1814 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1818 hr = SAXLocator_create(This, &locator, vbInterface);
1822 locator->pParserCtxt = xmlCreatePushParserCtxt(
1823 &locator->saxreader->sax, locator,
1824 data, dataRead, NULL);
1825 if(!locator->pParserCtxt)
1827 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1831 This->isParsing = TRUE;
1834 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1838 if(xmlParseChunk(locator->pParserCtxt, data, dataRead, 0)) hr = E_FAIL;
1839 else hr = locator->ret;
1841 if(hr != S_OK) break;
1843 if(dataRead != sizeof(data))
1845 if(xmlParseChunk(locator->pParserCtxt, data, 0, 1)) hr = E_FAIL;
1846 else hr = locator->ret;
1851 This->isParsing = FALSE;
1853 xmlFreeParserCtxt(locator->pParserCtxt);
1854 locator->pParserCtxt = NULL;
1855 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1859 static HRESULT internal_getEntityResolver(
1861 void *pEntityResolver,
1864 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1868 static HRESULT internal_putEntityResolver(
1870 void *pEntityResolver,
1873 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1877 static HRESULT internal_getContentHandler(
1879 void *pContentHandler,
1882 TRACE("(%p)->(%p)\n", This, pContentHandler);
1883 if(pContentHandler == NULL)
1885 if((vbInterface && This->vbcontentHandler)
1886 || (!vbInterface && This->contentHandler))
1889 IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1891 ISAXContentHandler_AddRef(This->contentHandler);
1893 if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1894 This->vbcontentHandler;
1895 else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1900 static HRESULT internal_putContentHandler(
1902 void *contentHandler,
1905 TRACE("(%p)->(%p)\n", This, contentHandler);
1909 IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1911 ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1913 if((vbInterface && This->vbcontentHandler)
1914 || (!vbInterface && This->contentHandler))
1917 IVBSAXContentHandler_Release(This->vbcontentHandler);
1919 ISAXContentHandler_Release(This->contentHandler);
1922 This->vbcontentHandler = contentHandler;
1924 This->contentHandler = contentHandler;
1929 static HRESULT internal_getDTDHandler(
1934 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1938 static HRESULT internal_putDTDHandler(
1943 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1947 static HRESULT internal_getErrorHandler(
1949 void *pErrorHandler,
1952 TRACE("(%p)->(%p)\n", This, pErrorHandler);
1953 if(pErrorHandler == NULL)
1956 if(vbInterface && This->vberrorHandler)
1957 IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1958 else if(!vbInterface && This->errorHandler)
1959 ISAXErrorHandler_AddRef(This->errorHandler);
1962 *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1964 *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1970 static HRESULT internal_putErrorHandler(
1975 TRACE("(%p)->(%p)\n", This, errorHandler);
1979 IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
1981 ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
1984 if(vbInterface && This->vberrorHandler)
1985 IVBSAXErrorHandler_Release(This->vberrorHandler);
1986 else if(!vbInterface && This->errorHandler)
1987 ISAXErrorHandler_Release(This->errorHandler);
1990 This->vberrorHandler = errorHandler;
1992 This->errorHandler = errorHandler;
1998 static HRESULT internal_parse(
2005 TRACE("(%p)\n", This);
2008 switch(V_VT(&varInput))
2011 hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2012 SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2014 case VT_ARRAY|VT_UI1: {
2016 LONG lBound, uBound;
2019 hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2020 if(hr != S_OK) break;
2021 hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2022 if(hr != S_OK) break;
2023 dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2024 hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2025 if(hr != S_OK) break;
2026 hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2027 SafeArrayUnaccessData(V_ARRAY(&varInput));
2032 IPersistStream *persistStream;
2033 IStream *stream = NULL;
2034 IXMLDOMDocument *xmlDoc;
2036 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2037 &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2041 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2042 hr = internal_parseBuffer(This, (const char*)bstrData,
2043 SysStringByteLen(bstrData), vbInterface);
2044 IXMLDOMDocument_Release(xmlDoc);
2045 SysFreeString(bstrData);
2048 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2049 &IID_IPersistStream, (void**)&persistStream) == S_OK)
2051 hr = IPersistStream_Save(persistStream, stream, TRUE);
2052 IPersistStream_Release(persistStream);
2053 if(hr != S_OK) break;
2055 if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2056 &IID_IStream, (void**)&stream) == S_OK)
2058 hr = internal_parseStream(This, stream, vbInterface);
2059 IStream_Release(stream);
2064 WARN("vt %d not implemented\n", V_VT(&varInput));
2071 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2073 saxreader *This = obj;
2075 return internal_parseBuffer(This, ptr, len, TRUE);
2078 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2080 saxreader *This = obj;
2082 return internal_parseBuffer(This, ptr, len, FALSE);
2085 static HRESULT internal_parseURL(
2093 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2095 if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
2096 else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
2106 static HRESULT internal_putProperty(
2112 static const WCHAR wszCharset[] = {
2113 'c','h','a','r','s','e','t',0
2115 static const WCHAR wszDeclarationHandler[] = {
2116 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2117 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2118 'd','e','c','l','a','r','a','t','i','o','n',
2119 '-','h','a','n','d','l','e','r',0
2121 static const WCHAR wszDomNode[] = {
2122 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2123 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2124 'd','o','m','-','n','o','d','e',0
2126 static const WCHAR wszInputSource[] = {
2127 'i','n','p','u','t','-','s','o','u','r','c','e',0
2129 static const WCHAR wszLexicalHandler[] = {
2130 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2131 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2132 'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
2134 static const WCHAR wszMaxElementDepth[] = {
2135 'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
2137 static const WCHAR wszMaxXMLSize[] = {
2138 'm','a','x','-','x','m','l','-','s','i','z','e',0
2140 static const WCHAR wszSchemaDeclarationHandler[] = {
2141 's','c','h','e','m','a','-',
2142 'd','e','c','l','a','r','a','t','i','o','n','-',
2143 'h','a','n','d','l','e','r',0
2145 static const WCHAR wszXMLDeclEncoding[] = {
2146 'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
2148 static const WCHAR wszXMLDeclStandalone[] = {
2149 'x','m','l','d','e','c','l',
2150 '-','s','t','a','n','d','a','l','o','n','e',0
2152 static const WCHAR wszXMLDeclVersion[] = {
2153 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
2156 FIXME("(%p)->(%s): semi-stub\n", This, debugstr_w(pProp));
2158 if(!memcmp(pProp, wszCharset, sizeof(wszCharset)))
2161 if(!memcmp(pProp, wszDeclarationHandler, sizeof(wszDeclarationHandler)))
2163 if(This->isParsing) return E_FAIL;
2165 if(V_UNKNOWN(&value))
2168 IVBSAXDeclHandler_AddRef((IVBSAXDeclHandler*)V_UNKNOWN(&value));
2170 ISAXDeclHandler_AddRef((ISAXDeclHandler*)V_UNKNOWN(&value));
2172 if((vbInterface && This->vbdeclHandler)
2173 || (!vbInterface && This->declHandler))
2176 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2178 ISAXDeclHandler_Release(This->declHandler);
2181 This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2183 This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2187 if(!memcmp(pProp, wszDomNode, sizeof(wszDomNode)))
2190 if(!memcmp(pProp, wszInputSource, sizeof(wszInputSource)))
2193 if(!memcmp(pProp, wszLexicalHandler, sizeof(wszLexicalHandler)))
2195 if(This->isParsing) return E_FAIL;
2197 if(V_UNKNOWN(&value))
2200 IVBSAXLexicalHandler_AddRef(
2201 (IVBSAXLexicalHandler*)V_UNKNOWN(&value));
2203 ISAXLexicalHandler_AddRef(
2204 (ISAXLexicalHandler*)V_UNKNOWN(&value));
2206 if((vbInterface && This->vblexicalHandler)
2207 || (!vbInterface && This->lexicalHandler))
2210 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2212 ISAXLexicalHandler_Release(This->lexicalHandler);
2215 This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2217 This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2221 if(!memcmp(pProp, wszMaxElementDepth, sizeof(wszMaxElementDepth)))
2224 if(!memcmp(pProp, wszMaxXMLSize, sizeof(wszMaxXMLSize)))
2227 if(!memcmp(pProp, wszSchemaDeclarationHandler,
2228 sizeof(wszSchemaDeclarationHandler)))
2231 if(!memcmp(pProp, wszXMLDeclEncoding, sizeof(wszXMLDeclEncoding)))
2234 if(!memcmp(pProp, wszXMLDeclStandalone, sizeof(wszXMLDeclStandalone)))
2237 if(!memcmp(pProp, wszXMLDeclVersion, sizeof(wszXMLDeclVersion)))
2240 return E_INVALIDARG;
2243 /*** IVBSAXXMLReader interface ***/
2244 /*** IUnknown methods ***/
2245 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2247 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2249 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2253 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2254 IsEqualGUID( riid, &IID_IDispatch ) ||
2255 IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2259 else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2261 *ppvObject = &This->lpSAXXMLReaderVtbl;
2265 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2266 return E_NOINTERFACE;
2269 IVBSAXXMLReader_AddRef( iface );
2274 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2276 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2277 TRACE("%p\n", This );
2278 return InterlockedIncrement( &This->ref );
2281 static ULONG WINAPI saxxmlreader_Release(
2282 IVBSAXXMLReader* iface)
2284 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2287 TRACE("%p\n", This );
2289 ref = InterlockedDecrement( &This->ref );
2292 if(This->contentHandler)
2293 ISAXContentHandler_Release(This->contentHandler);
2295 if(This->vbcontentHandler)
2296 IVBSAXContentHandler_Release(This->vbcontentHandler);
2298 if(This->errorHandler)
2299 ISAXErrorHandler_Release(This->errorHandler);
2301 if(This->vberrorHandler)
2302 IVBSAXErrorHandler_Release(This->vberrorHandler);
2304 if(This->lexicalHandler)
2305 ISAXLexicalHandler_Release(This->lexicalHandler);
2307 if(This->vblexicalHandler)
2308 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2310 if(This->declHandler)
2311 ISAXDeclHandler_Release(This->declHandler);
2313 if(This->vbdeclHandler)
2314 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2322 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2324 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2326 TRACE("(%p)->(%p)\n", This, pctinfo);
2333 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2334 IVBSAXXMLReader *iface,
2335 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2337 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2340 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2342 hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2347 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2348 IVBSAXXMLReader *iface,
2350 LPOLESTR* rgszNames,
2355 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2356 ITypeInfo *typeinfo;
2359 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2362 if(!rgszNames || cNames == 0 || !rgDispId)
2363 return E_INVALIDARG;
2365 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2368 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2369 ITypeInfo_Release(typeinfo);
2375 static HRESULT WINAPI saxxmlreader_Invoke(
2376 IVBSAXXMLReader *iface,
2377 DISPID dispIdMember,
2381 DISPPARAMS* pDispParams,
2382 VARIANT* pVarResult,
2383 EXCEPINFO* pExcepInfo,
2386 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2387 ITypeInfo *typeinfo;
2390 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2391 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2393 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2396 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
2397 pVarResult, pExcepInfo, puArgErr);
2398 ITypeInfo_Release(typeinfo);
2404 /*** IVBSAXXMLReader methods ***/
2405 static HRESULT WINAPI saxxmlreader_getFeature(
2406 IVBSAXXMLReader* iface,
2407 const WCHAR *pFeature,
2408 VARIANT_BOOL *pValue)
2410 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2412 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2416 static HRESULT WINAPI saxxmlreader_putFeature(
2417 IVBSAXXMLReader* iface,
2418 const WCHAR *pFeature,
2419 VARIANT_BOOL vfValue)
2421 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2423 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
2427 static HRESULT WINAPI saxxmlreader_getProperty(
2428 IVBSAXXMLReader* iface,
2432 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2434 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
2438 static HRESULT WINAPI saxxmlreader_putProperty(
2439 IVBSAXXMLReader* iface,
2443 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2444 return internal_putProperty(This, pProp, value, TRUE);
2447 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2448 IVBSAXXMLReader* iface,
2449 IVBSAXEntityResolver **pEntityResolver)
2451 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2452 return internal_getEntityResolver(This, pEntityResolver, TRUE);
2455 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2456 IVBSAXXMLReader* iface,
2457 IVBSAXEntityResolver *pEntityResolver)
2459 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2460 return internal_putEntityResolver(This, pEntityResolver, TRUE);
2463 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2464 IVBSAXXMLReader* iface,
2465 IVBSAXContentHandler **ppContentHandler)
2467 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2468 return internal_getContentHandler(This, ppContentHandler, TRUE);
2471 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2472 IVBSAXXMLReader* iface,
2473 IVBSAXContentHandler *contentHandler)
2475 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2476 return internal_putContentHandler(This, contentHandler, TRUE);
2479 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2480 IVBSAXXMLReader* iface,
2481 IVBSAXDTDHandler **pDTDHandler)
2483 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2484 return internal_getDTDHandler(This, pDTDHandler, TRUE);
2487 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2488 IVBSAXXMLReader* iface,
2489 IVBSAXDTDHandler *pDTDHandler)
2491 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2492 return internal_putDTDHandler(This, pDTDHandler, TRUE);
2495 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2496 IVBSAXXMLReader* iface,
2497 IVBSAXErrorHandler **pErrorHandler)
2499 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2500 return internal_getErrorHandler(This, pErrorHandler, TRUE);
2503 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2504 IVBSAXXMLReader* iface,
2505 IVBSAXErrorHandler *errorHandler)
2507 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2508 return internal_putErrorHandler(This, errorHandler, TRUE);
2511 static HRESULT WINAPI saxxmlreader_get_baseURL(
2512 IVBSAXXMLReader* iface,
2513 const WCHAR **pBaseUrl)
2515 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2517 FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2521 static HRESULT WINAPI saxxmlreader_put_baseURL(
2522 IVBSAXXMLReader* iface,
2523 const WCHAR *pBaseUrl)
2525 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2527 FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2531 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2532 IVBSAXXMLReader* iface,
2533 const WCHAR **pSecureBaseUrl)
2535 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2537 FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2542 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
2543 IVBSAXXMLReader* iface,
2544 const WCHAR *secureBaseUrl)
2546 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2548 FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2552 static HRESULT WINAPI saxxmlreader_parse(
2553 IVBSAXXMLReader* iface,
2556 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2557 return internal_parse(This, varInput, TRUE);
2560 static HRESULT WINAPI saxxmlreader_parseURL(
2561 IVBSAXXMLReader* iface,
2564 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2565 return internal_parseURL(This, url, TRUE);
2568 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2570 saxxmlreader_QueryInterface,
2571 saxxmlreader_AddRef,
2572 saxxmlreader_Release,
2573 saxxmlreader_GetTypeInfoCount,
2574 saxxmlreader_GetTypeInfo,
2575 saxxmlreader_GetIDsOfNames,
2576 saxxmlreader_Invoke,
2577 saxxmlreader_getFeature,
2578 saxxmlreader_putFeature,
2579 saxxmlreader_getProperty,
2580 saxxmlreader_putProperty,
2581 saxxmlreader_get_entityResolver,
2582 saxxmlreader_put_entityResolver,
2583 saxxmlreader_get_contentHandler,
2584 saxxmlreader_put_contentHandler,
2585 saxxmlreader_get_dtdHandler,
2586 saxxmlreader_put_dtdHandler,
2587 saxxmlreader_get_errorHandler,
2588 saxxmlreader_put_errorHandler,
2589 saxxmlreader_get_baseURL,
2590 saxxmlreader_put_baseURL,
2591 saxxmlreader_get_secureBaseURL,
2592 saxxmlreader_put_secureBaseURL,
2594 saxxmlreader_parseURL
2597 /*** ISAXXMLReader interface ***/
2598 /*** IUnknown methods ***/
2599 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2601 saxreader *This = impl_from_ISAXXMLReader( iface );
2602 return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2605 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2607 saxreader *This = impl_from_ISAXXMLReader( iface );
2608 return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2611 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2613 saxreader *This = impl_from_ISAXXMLReader( iface );
2614 return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2617 /*** ISAXXMLReader methods ***/
2618 static HRESULT WINAPI isaxxmlreader_getFeature(
2619 ISAXXMLReader* iface,
2620 const WCHAR *pFeature,
2621 VARIANT_BOOL *pValue)
2623 saxreader *This = impl_from_ISAXXMLReader( iface );
2624 return IVBSAXXMLReader_getFeature(
2625 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2629 static HRESULT WINAPI isaxxmlreader_putFeature(
2630 ISAXXMLReader* iface,
2631 const WCHAR *pFeature,
2632 VARIANT_BOOL vfValue)
2634 saxreader *This = impl_from_ISAXXMLReader( iface );
2635 return IVBSAXXMLReader_putFeature(
2636 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2640 static HRESULT WINAPI isaxxmlreader_getProperty(
2641 ISAXXMLReader* iface,
2645 saxreader *This = impl_from_ISAXXMLReader( iface );
2646 return IVBSAXXMLReader_getProperty(
2647 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2651 static HRESULT WINAPI isaxxmlreader_putProperty(
2652 ISAXXMLReader* iface,
2656 saxreader *This = impl_from_ISAXXMLReader( iface );
2657 return internal_putProperty(This, pProp, value, FALSE);
2660 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2661 ISAXXMLReader* iface,
2662 ISAXEntityResolver **ppEntityResolver)
2664 saxreader *This = impl_from_ISAXXMLReader( iface );
2665 return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2668 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2669 ISAXXMLReader* iface,
2670 ISAXEntityResolver *pEntityResolver)
2672 saxreader *This = impl_from_ISAXXMLReader( iface );
2673 return internal_putEntityResolver(This, pEntityResolver, FALSE);
2676 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2677 ISAXXMLReader* iface,
2678 ISAXContentHandler **pContentHandler)
2680 saxreader *This = impl_from_ISAXXMLReader( iface );
2681 return internal_getContentHandler(This, pContentHandler, FALSE);
2684 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2685 ISAXXMLReader* iface,
2686 ISAXContentHandler *contentHandler)
2688 saxreader *This = impl_from_ISAXXMLReader( iface );
2689 return internal_putContentHandler(This, contentHandler, FALSE);
2692 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2693 ISAXXMLReader* iface,
2694 ISAXDTDHandler **pDTDHandler)
2696 saxreader *This = impl_from_ISAXXMLReader( iface );
2697 return internal_getDTDHandler(This, pDTDHandler, FALSE);
2700 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2701 ISAXXMLReader* iface,
2702 ISAXDTDHandler *pDTDHandler)
2704 saxreader *This = impl_from_ISAXXMLReader( iface );
2705 return internal_putDTDHandler(This, pDTDHandler, FALSE);
2708 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2709 ISAXXMLReader* iface,
2710 ISAXErrorHandler **pErrorHandler)
2712 saxreader *This = impl_from_ISAXXMLReader( iface );
2713 return internal_getErrorHandler(This, pErrorHandler, FALSE);
2716 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2717 ISAXXMLReader* iface,
2718 ISAXErrorHandler *errorHandler)
2720 saxreader *This = impl_from_ISAXXMLReader( iface );
2721 return internal_putErrorHandler(This, errorHandler, FALSE);
2724 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2725 ISAXXMLReader* iface,
2726 const WCHAR **pBaseUrl)
2728 saxreader *This = impl_from_ISAXXMLReader( iface );
2729 return IVBSAXXMLReader_get_baseURL(
2730 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2734 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2735 ISAXXMLReader* iface,
2736 const WCHAR *pBaseUrl)
2738 saxreader *This = impl_from_ISAXXMLReader( iface );
2739 return IVBSAXXMLReader_put_baseURL(
2740 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2744 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2745 ISAXXMLReader* iface,
2746 const WCHAR **pSecureBaseUrl)
2748 saxreader *This = impl_from_ISAXXMLReader( iface );
2749 return IVBSAXXMLReader_get_secureBaseURL(
2750 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2754 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2755 ISAXXMLReader* iface,
2756 const WCHAR *secureBaseUrl)
2758 saxreader *This = impl_from_ISAXXMLReader( iface );
2759 return IVBSAXXMLReader_put_secureBaseURL(
2760 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2764 static HRESULT WINAPI isaxxmlreader_parse(
2765 ISAXXMLReader* iface,
2768 saxreader *This = impl_from_ISAXXMLReader( iface );
2769 return internal_parse(This, varInput, FALSE);
2772 static HRESULT WINAPI isaxxmlreader_parseURL(
2773 ISAXXMLReader* iface,
2776 saxreader *This = impl_from_ISAXXMLReader( iface );
2777 return internal_parseURL(This, url, FALSE);
2780 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2782 isaxxmlreader_QueryInterface,
2783 isaxxmlreader_AddRef,
2784 isaxxmlreader_Release,
2785 isaxxmlreader_getFeature,
2786 isaxxmlreader_putFeature,
2787 isaxxmlreader_getProperty,
2788 isaxxmlreader_putProperty,
2789 isaxxmlreader_getEntityResolver,
2790 isaxxmlreader_putEntityResolver,
2791 isaxxmlreader_getContentHandler,
2792 isaxxmlreader_putContentHandler,
2793 isaxxmlreader_getDTDHandler,
2794 isaxxmlreader_putDTDHandler,
2795 isaxxmlreader_getErrorHandler,
2796 isaxxmlreader_putErrorHandler,
2797 isaxxmlreader_getBaseURL,
2798 isaxxmlreader_putBaseURL,
2799 isaxxmlreader_getSecureBaseURL,
2800 isaxxmlreader_putSecureBaseURL,
2801 isaxxmlreader_parse,
2802 isaxxmlreader_parseURL
2805 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2809 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2811 reader = heap_alloc( sizeof (*reader) );
2813 return E_OUTOFMEMORY;
2815 reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2816 reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2818 reader->contentHandler = NULL;
2819 reader->vbcontentHandler = NULL;
2820 reader->errorHandler = NULL;
2821 reader->vberrorHandler = NULL;
2822 reader->lexicalHandler = NULL;
2823 reader->vblexicalHandler = NULL;
2824 reader->declHandler = NULL;
2825 reader->vbdeclHandler = NULL;
2826 reader->isParsing = FALSE;
2828 memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2829 reader->sax.initialized = XML_SAX2_MAGIC;
2830 reader->sax.startDocument = libxmlStartDocument;
2831 reader->sax.endDocument = libxmlEndDocument;
2832 reader->sax.startElementNs = libxmlStartElementNS;
2833 reader->sax.endElementNs = libxmlEndElementNS;
2834 reader->sax.characters = libxmlCharacters;
2835 reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2836 reader->sax.comment = libxmlComment;
2837 reader->sax.error = libxmlFatalError;
2838 reader->sax.fatalError = libxmlFatalError;
2839 reader->sax.cdataBlock = libxmlCDataBlock;
2841 *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2843 TRACE("returning iface %p\n", *ppObj);
2850 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2852 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2853 "libxml2 support was not present at compile time.\n");