reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-02 16:57:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8e7dad93ef
wine/dlls/msxml3/saxreader.c

2581 lines
72 KiB
C
Raw Blame History

/*
* SAX Reader implementation
*
* Copyright 2008 Alistair Leslie-Hughes
* Copyright 2008 Piotr Caban
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#include "config.h"
#include <stdarg.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winnls.h"
#include "ole2.h"
#include "msxml2.h"
#include "wininet.h"
#include "urlmon.h"
#include "winreg.h"
#include "shlwapi.h"
#include "wine/debug.h"
#include "msxml_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(msxml);
#ifdef HAVE_LIBXML2
#include <libxml/SAX2.h>
#include <libxml/parserInternals.h>
typedef struct _saxreader
{
const struct IVBSAXXMLReaderVtbl *lpVBSAXXMLReaderVtbl;
const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
LONG ref;
struct ISAXContentHandler *contentHandler;
struct IVBSAXContentHandler *vbcontentHandler;
struct ISAXErrorHandler *errorHandler;
struct IVBSAXErrorHandler *vberrorHandler;
xmlSAXHandler sax;
} saxreader;
typedef struct _saxlocator
{
const struct IVBSAXLocatorVtbl *lpVBSAXLocatorVtbl;
const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
LONG ref;
saxreader *saxreader;
HRESULT ret;
xmlParserCtxtPtr pParserCtxt;
WCHAR *publicId;
WCHAR *systemId;
xmlChar *lastCur;
int line;
int column;
BOOL vbInterface;
int nsStackSize;
int nsStackLast;
int *nsStack;
} saxlocator;
typedef struct _saxattributes
{
const struct IVBSAXAttributesVtbl *lpVBSAXAttributesVtbl;
const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
LONG ref;
int nb_attributes;
BSTR *szLocalname;
BSTR *szURI;
BSTR *szValue;
BSTR *szQName;
} saxattributes;
static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
{
return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVBSAXXMLReaderVtbl));
}
static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
{
return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
}
static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
{
return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpVBSAXLocatorVtbl));
}
static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
{
return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
}
static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
{
return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpVBSAXAttributesVtbl));
}
static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
{
return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
}
static HRESULT namespacePush(saxlocator *locator, int ns)
{
if(locator->nsStackLast>=locator->nsStackSize)
{
int *new_stack;
new_stack = HeapReAlloc(GetProcessHeap(), 0,
locator->nsStack, locator->nsStackSize*2);
if(!new_stack) return E_OUTOFMEMORY;
locator->nsStack = new_stack;
locator->nsStackSize *= 2;
}
locator->nsStack[locator->nsStackLast++] = ns;
return S_OK;
}
static int namespacePop(saxlocator *locator)
{
if(locator->nsStackLast == 0) return 0;
return locator->nsStack[--locator->nsStackLast];
}
static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
{
DWORD dLen;
LPWSTR str;
BSTR bstr;
if (!buf)
return NULL;
dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
if(len != -1) dLen++;
str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, dLen * sizeof (WCHAR));
if (!str)
return NULL;
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, str, dLen);
if(len != -1) str[dLen-1] = '\0';
bstr = SysAllocString(str);
HeapFree(GetProcessHeap(), 0, str);
return bstr;
}
static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
{
DWORD dLen, dLast;
LPWSTR str;
BSTR bstr;
if(!name) return NULL;
if(!prefix || *prefix=='\0')
return bstr_from_xmlChar(name);
dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, NULL, 0)
+ MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, NULL, 0);
str = HeapAlloc(GetProcessHeap(), 0, dLen * sizeof(WCHAR));
if(!str)
return NULL;
dLast = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, str, dLen);
str[dLast-1] = ':';
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &str[dLast], dLen-dLast);
bstr = SysAllocString(str);
HeapFree(GetProcessHeap(), 0, str);
return bstr;
}
static void format_error_message_from_id(saxlocator *This, HRESULT hr)
{
xmlStopParser(This->pParserCtxt);
This->ret = hr;
if((This->vbInterface && This->saxreader->vberrorHandler)
|| (!This->vbInterface && This->saxreader->errorHandler))
{
WCHAR msg[1024];
if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
NULL, hr, 0, msg, sizeof(msg), NULL))
{
FIXME("MSXML errors not yet supported.\n");
msg[0] = '\0';
}
if(This->vbInterface)
{
BSTR bstrMsg = SysAllocString(msg);
IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
(IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrMsg, hr);
}
else
ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
(ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
}
}
static void update_position(saxlocator *This, xmlChar *end)
{
if(This->lastCur == NULL)
{
This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
This->line = 1;
This->column = 1;
}
else if(This->lastCur < This->pParserCtxt->input->base)
{
This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
This->line = 1;
This->column = 1;
}
if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
while(This->lastCur < end)
{
if(*(This->lastCur) == '\n')
{
This->line++;
This->column = 1;
}
else if(*(This->lastCur) == '\r' && (This->lastCur==This->pParserCtxt->input->end || *(This->lastCur+1)!='\n'))
{
This->line++;
This->column = 1;
}
else This->column++;
This->lastCur++;
}
}
/*** IVBSAXAttributes interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI ivbsaxattributes_QueryInterface(
IVBSAXAttributes* iface,
REFIID riid,
void **ppvObject)
{
saxattributes *This = impl_from_IVBSAXAttributes(iface);
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
*ppvObject = NULL;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_IDispatch) ||
IsEqualGUID(riid, &IID_IVBSAXAttributes))
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IVBSAXAttributes_AddRef(iface);
return S_OK;
}
static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
{
saxattributes *This = impl_from_IVBSAXAttributes(iface);
return ISAXAttributes_AddRef((ISAXAttributes*)&This->lpSAXAttributesVtbl);
}
static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
{
saxattributes *This = impl_from_IVBSAXAttributes(iface);
return ISAXAttributes_Release((ISAXAttributes*)&This->lpSAXAttributesVtbl);
}
/*** IDispatch methods ***/
static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
IVBSAXAttributes *iface,
UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
IVBSAXAttributes *iface,
REFIID riid,
LPOLESTR* rgszNames,
UINT cNames,
LCID lcid,
DISPID* rgDispId)
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI ivbsaxattributes_Invoke(
IVBSAXAttributes *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS* pDispParams,
VARIANT* pVarResult,
EXCEPINFO* pExcepInfo,
UINT* puArgErr)
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXAttributesVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
/*** IVBSAXAttributes methods ***/
static HRESULT WINAPI ivbsaxattributes_get_length(
IVBSAXAttributes* iface,
int *nLength)
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getLength(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nLength);
}
static HRESULT WINAPI ivbsaxattributes_getURI(
IVBSAXAttributes* iface,
int nIndex,
BSTR *uri)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getURI(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nIndex, (const WCHAR**)uri, &len);
}
static HRESULT WINAPI ivbsaxattributes_getLocalName(
IVBSAXAttributes* iface,
int nIndex,
BSTR *localName)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getLocalName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nIndex, (const WCHAR**)localName, &len);
}
static HRESULT WINAPI ivbsaxattributes_getQName(
IVBSAXAttributes* iface,
int nIndex,
BSTR *QName)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getQName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nIndex, (const WCHAR**)QName, &len);
}
static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
IVBSAXAttributes* iface,
BSTR uri,
BSTR localName,
int *index)
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getIndexFromName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)uri, SysStringLen(uri),
(const WCHAR*)localName, SysStringLen(localName), index);
}
static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
IVBSAXAttributes* iface,
BSTR QName,
int *index)
{
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getIndexFromQName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)QName, SysStringLen(QName), index);
}
static HRESULT WINAPI ivbsaxattributes_getType(
IVBSAXAttributes* iface,
int nIndex,
BSTR *type)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getType(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nIndex, (const WCHAR**)type, &len);
}
static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
IVBSAXAttributes* iface,
BSTR uri,
BSTR localName,
BSTR *type)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getTypeFromName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)uri, SysStringLen(uri),
(const WCHAR*)localName, SysStringLen(localName),
(const WCHAR**)type, &len);
}
static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
IVBSAXAttributes* iface,
BSTR QName,
BSTR *type)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getTypeFromQName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)QName, SysStringLen(QName),
(const WCHAR**)type, &len);
}
static HRESULT WINAPI ivbsaxattributes_getValue(
IVBSAXAttributes* iface,
int nIndex,
BSTR *value)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getValue(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
nIndex, (const WCHAR**)value, &len);
}
static HRESULT WINAPI ivbsaxattributes_getValueFromName(
IVBSAXAttributes* iface,
BSTR uri,
BSTR localName,
BSTR *value)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getValueFromName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)uri, SysStringLen(uri),
(const WCHAR*)localName, SysStringLen(localName),
(const WCHAR**)value, &len);
}
static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
IVBSAXAttributes* iface,
BSTR QName,
BSTR *value)
{
int len;
saxattributes *This = impl_from_IVBSAXAttributes( iface );
return ISAXAttributes_getValueFromQName(
(ISAXAttributes*)&This->lpSAXAttributesVtbl,
(const WCHAR*)QName, SysStringLen(QName),
(const WCHAR**)value, &len);
}
static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
{
ivbsaxattributes_QueryInterface,
ivbsaxattributes_AddRef,
ivbsaxattributes_Release,
ivbsaxattributes_GetTypeInfoCount,
ivbsaxattributes_GetTypeInfo,
ivbsaxattributes_GetIDsOfNames,
ivbsaxattributes_Invoke,
ivbsaxattributes_get_length,
ivbsaxattributes_getURI,
ivbsaxattributes_getLocalName,
ivbsaxattributes_getQName,
ivbsaxattributes_getIndexFromName,
ivbsaxattributes_getIndexFromQName,
ivbsaxattributes_getType,
ivbsaxattributes_getTypeFromName,
ivbsaxattributes_getTypeFromQName,
ivbsaxattributes_getValue,
ivbsaxattributes_getValueFromName,
ivbsaxattributes_getValueFromQName
};
/*** ISAXAttributes interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI isaxattributes_QueryInterface(
ISAXAttributes* iface,
REFIID riid,
void **ppvObject)
{
saxattributes *This = impl_from_ISAXAttributes(iface);
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
*ppvObject = NULL;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_ISAXAttributes))
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
ISAXAttributes_AddRef(iface);
return S_OK;
}
static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
{
saxattributes *This = impl_from_ISAXAttributes(iface);
TRACE("%p\n", This);
return InterlockedIncrement(&This->ref);
}
static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
{
saxattributes *This = impl_from_ISAXAttributes(iface);
LONG ref;
TRACE("%p\n", This);
ref = InterlockedDecrement(&This->ref);
if (ref==0)
{
int index;
for(index=0; index<This->nb_attributes; index++)
{
SysFreeString(This->szLocalname[index]);
SysFreeString(This->szURI[index]);
SysFreeString(This->szValue[index]);
SysFreeString(This->szQName[index]);
}
HeapFree(GetProcessHeap(), 0, This->szLocalname);
HeapFree(GetProcessHeap(), 0, This->szURI);
HeapFree(GetProcessHeap(), 0, This->szValue);
HeapFree(GetProcessHeap(), 0, This->szQName);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
}
/*** ISAXAttributes methods ***/
static HRESULT WINAPI isaxattributes_getLength(
ISAXAttributes* iface,
int *length)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
*length = This->nb_attributes;
TRACE("Length set to %d\n", *length);
return S_OK;
}
static HRESULT WINAPI isaxattributes_getURI(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pUrl,
int *pUriSize)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%d)\n", This, nIndex);
if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
if(!pUrl || !pUriSize) return E_POINTER;
*pUriSize = SysStringLen(This->szURI[nIndex]);
*pUrl = This->szURI[nIndex];
return S_OK;
}
static HRESULT WINAPI isaxattributes_getLocalName(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pLocalName,
int *pLocalNameLength)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%d)\n", This, nIndex);
if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
if(!pLocalName || !pLocalNameLength) return E_POINTER;
*pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
*pLocalName = This->szLocalname[nIndex];
return S_OK;
}
static HRESULT WINAPI isaxattributes_getQName(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pQName,
int *pQNameLength)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%d)\n", This, nIndex);
if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
if(!pQName || !pQNameLength) return E_POINTER;
*pQNameLength = SysStringLen(This->szQName[nIndex]);
*pQName = This->szQName[nIndex];
return S_OK;
}
static HRESULT WINAPI isaxattributes_getName(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pUri,
int *pUriLength,
const WCHAR **pLocalName,
int *pLocalNameSize,
const WCHAR **pQName,
int *pQNameLength)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%d)\n", This, nIndex);
if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
|| !pQName || !pQNameLength) return E_POINTER;
*pUriLength = SysStringLen(This->szURI[nIndex]);
*pUri = This->szURI[nIndex];
*pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
*pLocalName = This->szLocalname[nIndex];
*pQNameLength = SysStringLen(This->szQName[nIndex]);
*pQName = This->szQName[nIndex];
return S_OK;
}
static HRESULT WINAPI isaxattributes_getIndexFromName(
ISAXAttributes* iface,
const WCHAR *pUri,
int cUriLength,
const WCHAR *pLocalName,
int cocalNameLength,
int *index)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
int i;
TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
debugstr_w(pLocalName), cocalNameLength);
if(!pUri || !pLocalName || !index) return E_POINTER;
for(i=0; i<This->nb_attributes; i++)
{
if(cUriLength!=SysStringLen(This->szURI[i])
|| cocalNameLength!=SysStringLen(This->szLocalname[i]))
continue;
if(cUriLength && memcmp(pUri, This->szURI[i],
sizeof(WCHAR)*cUriLength))
continue;
if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
sizeof(WCHAR)*cocalNameLength))
continue;
*index = i;
return S_OK;
}
return E_INVALIDARG;
}
static HRESULT WINAPI isaxattributes_getIndexFromQName(
ISAXAttributes* iface,
const WCHAR *pQName,
int nQNameLength,
int *index)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
int i;
TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQNameLength);
if(!pQName || !index) return E_POINTER;
if(!nQNameLength) return E_INVALIDARG;
for(i=0; i<This->nb_attributes; i++)
{
if(nQNameLength!=SysStringLen(This->szQName[i])) continue;
if(memcmp(pQName, This->szQName, sizeof(WCHAR)*nQNameLength)) continue;
*index = i;
return S_OK;
}
return E_INVALIDARG;
}
static HRESULT WINAPI isaxattributes_getType(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pType,
int *pTypeLength)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
FIXME("(%p)->(%d) stub\n", This, nIndex);
return E_NOTIMPL;
}
static HRESULT WINAPI isaxattributes_getTypeFromName(
ISAXAttributes* iface,
const WCHAR *pUri,
int nUri,
const WCHAR *pLocalName,
int nLocalName,
const WCHAR **pType,
int *nType)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
debugstr_w(pLocalName), nLocalName);
return E_NOTIMPL;
}
static HRESULT WINAPI isaxattributes_getTypeFromQName(
ISAXAttributes* iface,
const WCHAR *pQName,
int nQName,
const WCHAR **pType,
int *nType)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
return E_NOTIMPL;
}
static HRESULT WINAPI isaxattributes_getValue(
ISAXAttributes* iface,
int nIndex,
const WCHAR **pValue,
int *nValue)
{
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%d)\n", This, nIndex);
if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
if(!pValue || !nValue) return E_POINTER;
*nValue = SysStringLen(This->szValue[nIndex]);
*pValue = This->szValue[nIndex];
return S_OK;
}
static HRESULT WINAPI isaxattributes_getValueFromName(
ISAXAttributes* iface,
const WCHAR *pUri,
int nUri,
const WCHAR *pLocalName,
int nLocalName,
const WCHAR **pValue,
int *nValue)
{
HRESULT hr;
int index;
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), nUri,
debugstr_w(pLocalName), nLocalName);
hr = ISAXAttributes_getIndexFromName(iface,
pUri, nUri, pLocalName, nLocalName, &index);
if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
return hr;
}
static HRESULT WINAPI isaxattributes_getValueFromQName(
ISAXAttributes* iface,
const WCHAR *pQName,
int nQName,
const WCHAR **pValue,
int *nValue)
{
HRESULT hr;
int index;
saxattributes *This = impl_from_ISAXAttributes( iface );
TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQName);
hr = ISAXAttributes_getIndexFromQName(iface, pQName, nQName, &index);
if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
return hr;
}
static const struct ISAXAttributesVtbl isaxattributes_vtbl =
{
isaxattributes_QueryInterface,
isaxattributes_AddRef,
isaxattributes_Release,
isaxattributes_getLength,
isaxattributes_getURI,
isaxattributes_getLocalName,
isaxattributes_getQName,
isaxattributes_getName,
isaxattributes_getIndexFromName,
isaxattributes_getIndexFromQName,
isaxattributes_getType,
isaxattributes_getTypeFromName,
isaxattributes_getTypeFromQName,
isaxattributes_getValue,
isaxattributes_getValueFromName,
isaxattributes_getValueFromQName
};
static HRESULT SAXAttributes_create(saxattributes **attr,
int nb_namespaces, const xmlChar **xmlNamespaces,
int nb_attributes, const xmlChar **xmlAttributes)
{
saxattributes *attributes;
int index;
static const xmlChar xmlns[] = "xmlns";
attributes = HeapAlloc(GetProcessHeap(), 0, sizeof(*attributes));
if(!attributes)
return E_OUTOFMEMORY;
attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
attributes->ref = 1;
attributes->nb_attributes = nb_namespaces+nb_attributes;
attributes->szLocalname =
HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
attributes->szURI =
HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
attributes->szValue =
HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
attributes->szQName =
HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
if(!attributes->szLocalname || !attributes->szURI
|| !attributes->szValue || !attributes->szQName)
{
HeapFree(GetProcessHeap(), 0, attributes->szLocalname);
HeapFree(GetProcessHeap(), 0, attributes->szURI);
HeapFree(GetProcessHeap(), 0, attributes->szValue);
HeapFree(GetProcessHeap(), 0, attributes->szQName);
HeapFree(GetProcessHeap(), 0, attributes);
return E_FAIL;
}
for(index=0; index<nb_namespaces; index++)
{
attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
attributes->szURI[index] = SysAllocStringLen(NULL, 0);
attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
}
for(index=0; index<nb_attributes; index++)
{
attributes->szLocalname[nb_namespaces+index] =
bstr_from_xmlChar(xmlAttributes[index*5]);
attributes->szURI[nb_namespaces+index] =
bstr_from_xmlChar(xmlAttributes[index*5+2]);
attributes->szValue[nb_namespaces+index] =
bstr_from_xmlCharN(xmlAttributes[index*5+3],
xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
attributes->szQName[nb_namespaces+index] =
QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
}
*attr = attributes;
TRACE("returning %p\n", *attr);
return S_OK;
}
/*** LibXML callbacks ***/
static void libxmlStartDocument(void *ctx)
{
saxlocator *This = ctx;
HRESULT hr;
if((This->vbInterface && This->saxreader->vbcontentHandler)
|| (!This->vbInterface && This->saxreader->contentHandler))
{
if(This->vbInterface)
hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
else
hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
if(hr != S_OK)
format_error_message_from_id(This, hr);
}
update_position(This, NULL);
}
static void libxmlEndDocument(void *ctx)
{
saxlocator *This = ctx;
HRESULT hr;
This->column = 0;
This->line = 0;
if(This->ret != S_OK) return;
if((This->vbInterface && This->saxreader->vbcontentHandler)
|| (!This->vbInterface && This->saxreader->contentHandler))
{
if(This->vbInterface)
hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
else
hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
if(hr != S_OK)
format_error_message_from_id(This, hr);
}
}
static void libxmlStartElementNS(
void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI,
int nb_namespaces,
const xmlChar **namespaces,
int nb_attributes,
int nb_defaulted,
const xmlChar **attributes)
{
BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
saxlocator *This = ctx;
HRESULT hr;
saxattributes *attr;
int index;
update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
hr = namespacePush(This, nb_namespaces);
if(hr==S_OK && ((This->vbInterface && This->saxreader->vbcontentHandler)
|| (!This->vbInterface && This->saxreader->contentHandler)))
{
for(index=0; index<nb_namespaces; index++)
{
Prefix = bstr_from_xmlChar(namespaces[2*index]);
Uri = bstr_from_xmlChar(namespaces[2*index+1]);
if(This->vbInterface)
hr = IVBSAXContentHandler_startPrefixMapping(
This->saxreader->vbcontentHandler,
&Prefix, &Uri);
else
hr = ISAXContentHandler_startPrefixMapping(
This->saxreader->contentHandler,
Prefix, SysStringLen(Prefix),
Uri, SysStringLen(Uri));
SysFreeString(Prefix);
SysFreeString(Uri);
if(hr != S_OK)
{
format_error_message_from_id(This, hr);
return;
}
}
NamespaceUri = bstr_from_xmlChar(URI);
LocalName = bstr_from_xmlChar(localname);
QName = QName_from_xmlChar(prefix, localname);
hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
if(hr == S_OK)
{
if(This->vbInterface)
hr = IVBSAXContentHandler_startElement(
This->saxreader->vbcontentHandler,
&NamespaceUri, &LocalName, &QName,
(IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
else
hr = ISAXContentHandler_startElement(
This->saxreader->contentHandler,
NamespaceUri, SysStringLen(NamespaceUri),
LocalName, SysStringLen(LocalName),
QName, SysStringLen(QName),
(ISAXAttributes*)&attr->lpSAXAttributesVtbl);
ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
}
SysFreeString(NamespaceUri);
SysFreeString(LocalName);
SysFreeString(QName);
}
if(hr != S_OK)
format_error_message_from_id(This, hr);
}
static void libxmlEndElementNS(
void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI)
{
BSTR NamespaceUri, LocalName, QName, Prefix;
saxlocator *This = ctx;
HRESULT hr;
xmlChar *end;
int nsNr, index;
end = This->lastCur;
while(*end != '<' && *(end+1) != '/') end++;
update_position(This, end+2);
nsNr = namespacePop(This);
if((This->vbInterface && This->saxreader->vbcontentHandler)
|| (!This->vbInterface && This->saxreader->contentHandler))
{
NamespaceUri = bstr_from_xmlChar(URI);
LocalName = bstr_from_xmlChar(localname);
QName = QName_from_xmlChar(prefix, localname);
if(This->vbInterface)
hr = IVBSAXContentHandler_endElement(
This->saxreader->vbcontentHandler,
&NamespaceUri, &LocalName, &QName);
else
hr = ISAXContentHandler_endElement(
This->saxreader->contentHandler,
NamespaceUri, SysStringLen(NamespaceUri),
LocalName, SysStringLen(LocalName),
QName, SysStringLen(QName));
SysFreeString(NamespaceUri);
SysFreeString(LocalName);
SysFreeString(QName);
if(hr != S_OK)
{
format_error_message_from_id(This, hr);
return;
}
for(index=This->pParserCtxt->nsNr-2;
index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
{
Prefix = bstr_from_xmlChar(This->pParserCtxt->nsTab[index]);
if(This->vbInterface)
hr = IVBSAXContentHandler_endPrefixMapping(
This->saxreader->vbcontentHandler, &Prefix);
else
hr = ISAXContentHandler_endPrefixMapping(
This->saxreader->contentHandler,
Prefix, SysStringLen(Prefix));
SysFreeString(Prefix);
}
}
}
static void libxmlCharacters(
void *ctx,
const xmlChar *ch,
int len)
{
BSTR Chars;
saxlocator *This = ctx;
HRESULT hr;
xmlChar *end;
xmlChar *lastCurCopy;
xmlChar *chEnd;
int columnCopy;
int lineCopy;
if(*(This->lastCur-1) != '>' && *(This->lastCur-1) != '/') return;
if(*(This->lastCur-1) != '>')
{
end = (xmlChar*)This->pParserCtxt->input->cur-len;
while(*(end-1) != '>') end--;
update_position(This, end);
}
chEnd = This->lastCur+len;
while(*chEnd != '<') chEnd++;
Chars = bstr_from_xmlChar(ch);
lastCurCopy = This->lastCur;
columnCopy = This->column;
lineCopy = This->line;
end = This->lastCur;
if((This->vbInterface && This->saxreader->vbcontentHandler)
|| (!This->vbInterface && This->saxreader->contentHandler))
{
while(This->lastCur < chEnd)
{
end = This->lastCur;
while(end < chEnd-1)
{
if(*end == '\r') break;
end++;
}
Chars = bstr_from_xmlChar(This->lastCur);
if(*end == '\r' && *(end+1) == '\n')
{
memmove((WCHAR*)Chars+(end-This->lastCur),
(WCHAR*)Chars+(end-This->lastCur)+1,
(SysStringLen(Chars)-(end-This->lastCur))*sizeof(WCHAR));
SysReAllocStringLen(&Chars, Chars, SysStringLen(Chars)-1);
}
else if(*end == '\r') Chars[end-This->lastCur] = '\n';
if(This->vbInterface)
hr = IVBSAXContentHandler_characters(
This->saxreader->vbcontentHandler, &Chars);
else
hr = ISAXContentHandler_characters(
This->saxreader->contentHandler,
Chars, end-This->lastCur+1);
SysFreeString(Chars);
if(hr != S_OK)
{
format_error_message_from_id(This, hr);
return;
}
if(*(end+1) == '\n') end++;
if(end < chEnd) end++;
This->column += end-This->lastCur;
This->lastCur = end;
}
This->lastCur = lastCurCopy;
This->column = columnCopy;
This->line = lineCopy;
update_position(This, chEnd);
}
}
static void libxmlSetDocumentLocator(
void *ctx,
xmlSAXLocatorPtr loc)
{
saxlocator *This = ctx;
HRESULT hr;
if(This->vbInterface)
hr = IVBSAXContentHandler_putref_documentLocator(
This->saxreader->vbcontentHandler,
(IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
else
hr = ISAXContentHandler_putDocumentLocator(
This->saxreader->contentHandler,
(ISAXLocator*)&This->lpSAXLocatorVtbl);
if(FAILED(hr))
format_error_message_from_id(This, hr);
}
void libxmlFatalError(void *ctx, const char *msg, ...)
{
saxlocator *This = ctx;
char message[1024];
WCHAR *wszError;
DWORD len;
va_list args;
if((This->vbInterface && !This->saxreader->vberrorHandler)
|| (!This->vbInterface && !This->saxreader->errorHandler))
{
xmlStopParser(This->pParserCtxt);
This->ret = E_FAIL;
return;
}
FIXME("Error handling is not compatible.\n");
va_start(args, msg);
vsprintf(message, msg, args);
va_end(args);
len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
if(wszError)
MultiByteToWideChar(CP_UNIXCP, 0, message, -1, (LPWSTR)wszError, len);
if(This->vbInterface)
{
BSTR bstrError = SysAllocString(wszError);
IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
(IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
}
else
ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
(ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
HeapFree(GetProcessHeap(), 0, wszError);
xmlStopParser(This->pParserCtxt);
This->ret = E_FAIL;
}
/*** IVBSAXLocator interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
*ppvObject = NULL;
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
IsEqualGUID( riid, &IID_IDispatch) ||
IsEqualGUID( riid, &IID_IVBSAXLocator ))
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IVBSAXLocator_AddRef( iface );
return S_OK;
}
static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
TRACE("%p\n", This );
return InterlockedIncrement( &This->ref );
}
static ULONG WINAPI ivbsaxlocator_Release(
IVBSAXLocator* iface)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
}
/*** IDispatch methods ***/
static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
IVBSAXLocator *iface,
UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
IVBSAXLocator *iface,
REFIID riid,
LPOLESTR* rgszNames,
UINT cNames,
LCID lcid,
DISPID* rgDispId)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI ivbsaxlocator_Invoke(
IVBSAXLocator *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS* pDispParams,
VARIANT* pVarResult,
EXCEPINFO* pExcepInfo,
UINT* puArgErr)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
/*** IVBSAXLocator methods ***/
static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
IVBSAXLocator* iface,
int *pnColumn)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
return ISAXLocator_getColumnNumber(
(ISAXLocator*)&This->lpVBSAXLocatorVtbl,
pnColumn);
}
static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
IVBSAXLocator* iface,
int *pnLine)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
return ISAXLocator_getLineNumber(
(ISAXLocator*)&This->lpVBSAXLocatorVtbl,
pnLine);
}
static HRESULT WINAPI ivbsaxlocator_get_publicId(
IVBSAXLocator* iface,
BSTR* publicId)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
return ISAXLocator_getPublicId(
(ISAXLocator*)&This->lpVBSAXLocatorVtbl,
(const WCHAR**)publicId);
}
static HRESULT WINAPI ivbsaxlocator_get_systemId(
IVBSAXLocator* iface,
BSTR* systemId)
{
saxlocator *This = impl_from_IVBSAXLocator( iface );
return ISAXLocator_getSystemId(
(ISAXLocator*)&This->lpVBSAXLocatorVtbl,
(const WCHAR**)systemId);
}
static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
{
ivbsaxlocator_QueryInterface,
ivbsaxlocator_AddRef,
ivbsaxlocator_Release,
ivbsaxlocator_GetTypeInfoCount,
ivbsaxlocator_GetTypeInfo,
ivbsaxlocator_GetIDsOfNames,
ivbsaxlocator_Invoke,
ivbsaxlocator_get_columnNumber,
ivbsaxlocator_get_lineNumber,
ivbsaxlocator_get_publicId,
ivbsaxlocator_get_systemId
};
/*** ISAXLocator interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
{
saxlocator *This = impl_from_ISAXLocator( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
*ppvObject = NULL;
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
IsEqualGUID( riid, &IID_ISAXLocator ))
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
ISAXLocator_AddRef( iface );
return S_OK;
}
static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
{
saxlocator *This = impl_from_ISAXLocator( iface );
TRACE("%p\n", This );
return InterlockedIncrement( &This->ref );
}
static ULONG WINAPI isaxlocator_Release(
ISAXLocator* iface)
{
saxlocator *This = impl_from_ISAXLocator( iface );
LONG ref;
TRACE("%p\n", This );
ref = InterlockedDecrement( &This->ref );
if ( ref == 0 )
{
if(This->publicId)
SysFreeString(This->publicId);
if(This->systemId)
SysFreeString(This->systemId);
HeapFree(GetProcessHeap(), 0, This->nsStack);
ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
HeapFree( GetProcessHeap(), 0, This );
}
return ref;
}
/*** ISAXLocator methods ***/
static HRESULT WINAPI isaxlocator_getColumnNumber(
ISAXLocator* iface,
int *pnColumn)
{
saxlocator *This = impl_from_ISAXLocator( iface );
*pnColumn = This->column;
return S_OK;
}
static HRESULT WINAPI isaxlocator_getLineNumber(
ISAXLocator* iface,
int *pnLine)
{
saxlocator *This = impl_from_ISAXLocator( iface );
*pnLine = This->line;
return S_OK;
}
static HRESULT WINAPI isaxlocator_getPublicId(
ISAXLocator* iface,
const WCHAR ** ppwchPublicId)
{
BSTR publicId;
saxlocator *This = impl_from_ISAXLocator( iface );
if(This->publicId) SysFreeString(This->publicId);
publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
if(SysStringLen(publicId))
This->publicId = (WCHAR*)&publicId;
else
{
SysFreeString(publicId);
This->publicId = NULL;
}
*ppwchPublicId = This->publicId;
return S_OK;
}
static HRESULT WINAPI isaxlocator_getSystemId(
ISAXLocator* iface,
const WCHAR ** ppwchSystemId)
{
BSTR systemId;
saxlocator *This = impl_from_ISAXLocator( iface );
if(This->systemId) SysFreeString(This->systemId);
systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
if(SysStringLen(systemId))
This->systemId = (WCHAR*)&systemId;
else
{
SysFreeString(systemId);
This->systemId = NULL;
}
*ppwchSystemId = This->systemId;
return S_OK;
}
static const struct ISAXLocatorVtbl isaxlocator_vtbl =
{
isaxlocator_QueryInterface,
isaxlocator_AddRef,
isaxlocator_Release,
isaxlocator_getColumnNumber,
isaxlocator_getLineNumber,
isaxlocator_getPublicId,
isaxlocator_getSystemId
};
static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
{
saxlocator *locator;
locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
if( !locator )
return E_OUTOFMEMORY;
locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
locator->ref = 1;
locator->vbInterface = vbInterface;
locator->saxreader = reader;
ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
locator->pParserCtxt = NULL;
locator->publicId = NULL;
locator->systemId = NULL;
locator->lastCur = NULL;
locator->line = 0;
locator->column = 0;
locator->ret = S_OK;
locator->nsStackSize = 8;
locator->nsStackLast = 0;
locator->nsStack = HeapAlloc(GetProcessHeap(), 0, locator->nsStackSize);
if(!locator->nsStack)
{
ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
HeapFree(GetProcessHeap(), 0, locator);
return E_OUTOFMEMORY;
}
*ppsaxlocator = locator;
TRACE("returning %p\n", *ppsaxlocator);
return S_OK;
}
/*** SAXXMLReader internal functions ***/
static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
{
saxlocator *locator;
HRESULT hr;
hr = SAXLocator_create(This, &locator, vbInterface);
if(FAILED(hr))
return E_FAIL;
locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
if(!locator->pParserCtxt)
{
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
return E_FAIL;
}
locator->pParserCtxt->sax = &locator->saxreader->sax;
locator->pParserCtxt->userData = locator;
if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
else hr = locator->ret;
if(locator->pParserCtxt)
{
locator->pParserCtxt->sax = NULL;
xmlFreeParserCtxt(locator->pParserCtxt);
locator->pParserCtxt = NULL;
}
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
return S_OK;
}
static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
{
saxlocator *locator;
HRESULT hr;
ULONG dataRead;
char data[1024];
hr = IStream_Read(stream, data, sizeof(data), &dataRead);
if(hr != S_OK)
return hr;
hr = SAXLocator_create(This, &locator, vbInterface);
if(FAILED(hr))
return E_FAIL;
locator->pParserCtxt = xmlCreatePushParserCtxt(
&locator->saxreader->sax, locator,
data, dataRead, NULL);
if(!locator->pParserCtxt)
{
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
return E_FAIL;
}
while(1)
{
hr = IStream_Read(stream, data, sizeof(data), &dataRead);
if(hr != S_OK)
break;
if(xmlParseChunk(locator->pParserCtxt, data, dataRead, 0)) hr = E_FAIL;
else hr = locator->ret;
if(hr != S_OK) break;
if(dataRead != sizeof(data))
{
if(xmlParseChunk(locator->pParserCtxt, data, 0, 1)) hr = E_FAIL;
else hr = locator->ret;
break;
}
}
locator->pParserCtxt->sax = NULL;
xmlFreeParserCtxt(locator->pParserCtxt);
locator->pParserCtxt = NULL;
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
return hr;
}
static HRESULT WINAPI internal_getEntityResolver(
saxreader *This,
void *pEntityResolver,
BOOL vbInterface)
{
FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
return E_NOTIMPL;
}
static HRESULT WINAPI internal_putEntityResolver(
saxreader *This,
void *pEntityResolver,
BOOL vbInterface)
{
FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
return E_NOTIMPL;
}
static HRESULT WINAPI internal_getContentHandler(
saxreader* This,
void *pContentHandler,
BOOL vbInterface)
{
TRACE("(%p)->(%p)\n", This, pContentHandler);
if(pContentHandler == NULL)
return E_POINTER;
if((vbInterface && This->vbcontentHandler)
|| (!vbInterface && This->contentHandler))
{
if(vbInterface)
IVBSAXContentHandler_AddRef(This->vbcontentHandler);
else
ISAXContentHandler_AddRef(This->contentHandler);
}
if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
This->vbcontentHandler;
else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
return S_OK;
}
static HRESULT WINAPI internal_putContentHandler(
saxreader* This,
void *contentHandler,
BOOL vbInterface)
{
TRACE("(%p)->(%p)\n", This, contentHandler);
if(contentHandler)
{
if(vbInterface)
IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
else
ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
}
if((vbInterface && This->vbcontentHandler)
|| (!vbInterface && This->contentHandler))
{
if(vbInterface)
IVBSAXContentHandler_Release(This->vbcontentHandler);
else
ISAXContentHandler_Release(This->contentHandler);
}
if(vbInterface)
This->vbcontentHandler = contentHandler;
else
This->contentHandler = contentHandler;
return S_OK;
}
static HRESULT WINAPI internal_getDTDHandler(
saxreader* This,
void *pDTDHandler,
BOOL vbInterface)
{
FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
return E_NOTIMPL;
}
static HRESULT WINAPI internal_putDTDHandler(
saxreader* This,
void *pDTDHandler,
BOOL vbInterface)
{
FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
return E_NOTIMPL;
}
static HRESULT WINAPI internal_getErrorHandler(
saxreader* This,
void *pErrorHandler,
BOOL vbInterface)
{
TRACE("(%p)->(%p)\n", This, pErrorHandler);
if(pErrorHandler == NULL)
return E_POINTER;
if(vbInterface && This->vberrorHandler)
IVBSAXErrorHandler_AddRef(This->vberrorHandler);
else if(!vbInterface && This->errorHandler)
ISAXErrorHandler_AddRef(This->errorHandler);
if(vbInterface)
*(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
else
*(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
return S_OK;
}
static HRESULT WINAPI internal_putErrorHandler(
saxreader* This,
void *errorHandler,
BOOL vbInterface)
{
TRACE("(%p)->(%p)\n", This, errorHandler);
if(errorHandler)
{
if(vbInterface)
IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
else
ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
}
if(vbInterface && This->vberrorHandler)
IVBSAXErrorHandler_Release(This->vberrorHandler);
else if(!vbInterface && This->errorHandler)
ISAXErrorHandler_Release(This->errorHandler);
if(vbInterface)
This->vberrorHandler = errorHandler;
else
This->errorHandler = errorHandler;
return S_OK;
}
static HRESULT WINAPI internal_parse(
saxreader* This,
VARIANT varInput,
BOOL vbInterface)
{
HRESULT hr;
TRACE("(%p)\n", This);
hr = S_OK;
switch(V_VT(&varInput))
{
case VT_BSTR:
hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
SysStringByteLen(V_BSTR(&varInput)), vbInterface);
break;
case VT_ARRAY|VT_UI1: {
void *pSAData;
LONG lBound, uBound;
ULONG dataRead;
hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
if(hr != S_OK) break;
hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
if(hr != S_OK) break;
dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
if(hr != S_OK) break;
hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
SafeArrayUnaccessData(V_ARRAY(&varInput));
break;
}
case VT_UNKNOWN:
case VT_DISPATCH: {
IPersistStream *persistStream;
IStream *stream = NULL;
IXMLDOMDocument *xmlDoc;
if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
&IID_IPersistStream, (void**)&persistStream) == S_OK)
{
hr = IPersistStream_Save(persistStream, stream, TRUE);
IPersistStream_Release(persistStream);
if(hr != S_OK) break;
}
if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
&IID_IStream, (void**)&stream) == S_OK)
{
hr = internal_parseStream(This, stream, vbInterface);
IStream_Release(stream);
break;
}
if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
&IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
{
BSTR bstrData;
IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
hr = internal_parseBuffer(This, (const char*)bstrData,
SysStringByteLen(bstrData), vbInterface);
IXMLDOMDocument_Release(xmlDoc);
hr = E_NOTIMPL;
break;
}
}
default:
WARN("vt %d not implemented\n", V_VT(&varInput));
hr = E_INVALIDARG;
}
return hr;
}
static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
{
saxreader *This = obj;
return internal_parseBuffer(This, ptr, len, TRUE);
}
static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
{
saxreader *This = obj;
return internal_parseBuffer(This, ptr, len, FALSE);
}
static HRESULT WINAPI internal_parseURL(
saxreader* This,
const WCHAR *url,
BOOL vbInterface)
{
bsc_t *bsc;
HRESULT hr;
TRACE("(%p)->(%s)\n", This, debugstr_w(url));
if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
if(FAILED(hr))
return hr;
detach_bsc(bsc);
return S_OK;
}
/*** IVBSAXXMLReader interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
*ppvObject = NULL;
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
{
*ppvObject = iface;
}
else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
{
*ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IVBSAXXMLReader_AddRef( iface );
return S_OK;
}
static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
TRACE("%p\n", This );
return InterlockedIncrement( &This->ref );
}
static ULONG WINAPI saxxmlreader_Release(
IVBSAXXMLReader* iface)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
LONG ref;
TRACE("%p\n", This );
ref = InterlockedDecrement( &This->ref );
if ( ref == 0 )
{
if(This->contentHandler)
ISAXContentHandler_Release(This->contentHandler);
if(This->vbcontentHandler)
IVBSAXContentHandler_Release(This->vbcontentHandler);
if(This->errorHandler)
ISAXErrorHandler_Release(This->errorHandler);
if(This->vberrorHandler)
IVBSAXErrorHandler_Release(This->vberrorHandler);
HeapFree( GetProcessHeap(), 0, This );
}
return ref;
}
/*** IDispatch ***/
static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI saxxmlreader_GetTypeInfo(
IVBSAXXMLReader *iface,
UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
IVBSAXXMLReader *iface,
REFIID riid,
LPOLESTR* rgszNames,
UINT cNames,
LCID lcid,
DISPID* rgDispId)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI saxxmlreader_Invoke(
IVBSAXXMLReader *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS* pDispParams,
VARIANT* pVarResult,
EXCEPINFO* pExcepInfo,
UINT* puArgErr)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
/*** IVBSAXXMLReader methods ***/
static HRESULT WINAPI saxxmlreader_getFeature(
IVBSAXXMLReader* iface,
const WCHAR *pFeature,
VARIANT_BOOL *pValue)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_putFeature(
IVBSAXXMLReader* iface,
const WCHAR *pFeature,
VARIANT_BOOL vfValue)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_getProperty(
IVBSAXXMLReader* iface,
const WCHAR *pProp,
VARIANT *pValue)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_putProperty(
IVBSAXXMLReader* iface,
const WCHAR *pProp,
VARIANT value)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_get_entityResolver(
IVBSAXXMLReader* iface,
IVBSAXEntityResolver **pEntityResolver)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_getEntityResolver(This, pEntityResolver, TRUE);
}
static HRESULT WINAPI saxxmlreader_put_entityResolver(
IVBSAXXMLReader* iface,
IVBSAXEntityResolver *pEntityResolver)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_putEntityResolver(This, pEntityResolver, TRUE);
}
static HRESULT WINAPI saxxmlreader_get_contentHandler(
IVBSAXXMLReader* iface,
IVBSAXContentHandler **ppContentHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_getContentHandler(This, ppContentHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_put_contentHandler(
IVBSAXXMLReader* iface,
IVBSAXContentHandler *contentHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_putContentHandler(This, contentHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_get_dtdHandler(
IVBSAXXMLReader* iface,
IVBSAXDTDHandler **pDTDHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_getDTDHandler(This, pDTDHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_put_dtdHandler(
IVBSAXXMLReader* iface,
IVBSAXDTDHandler *pDTDHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_putDTDHandler(This, pDTDHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_get_errorHandler(
IVBSAXXMLReader* iface,
IVBSAXErrorHandler **pErrorHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_getErrorHandler(This, pErrorHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_put_errorHandler(
IVBSAXXMLReader* iface,
IVBSAXErrorHandler *errorHandler)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_putErrorHandler(This, errorHandler, TRUE);
}
static HRESULT WINAPI saxxmlreader_get_baseURL(
IVBSAXXMLReader* iface,
const WCHAR **pBaseUrl)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_put_baseURL(
IVBSAXXMLReader* iface,
const WCHAR *pBaseUrl)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
IVBSAXXMLReader* iface,
const WCHAR **pSecureBaseUrl)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
IVBSAXXMLReader* iface,
const WCHAR *secureBaseUrl)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
return E_NOTIMPL;
}
static HRESULT WINAPI saxxmlreader_parse(
IVBSAXXMLReader* iface,
VARIANT varInput)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_parse(This, varInput, TRUE);
}
static HRESULT WINAPI saxxmlreader_parseURL(
IVBSAXXMLReader* iface,
const WCHAR *url)
{
saxreader *This = impl_from_IVBSAXXMLReader( iface );
return internal_parseURL(This, url, TRUE);
}
static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
{
saxxmlreader_QueryInterface,
saxxmlreader_AddRef,
saxxmlreader_Release,
saxxmlreader_GetTypeInfoCount,
saxxmlreader_GetTypeInfo,
saxxmlreader_GetIDsOfNames,
saxxmlreader_Invoke,
saxxmlreader_getFeature,
saxxmlreader_putFeature,
saxxmlreader_getProperty,
saxxmlreader_putProperty,
saxxmlreader_get_entityResolver,
saxxmlreader_put_entityResolver,
saxxmlreader_get_contentHandler,
saxxmlreader_put_contentHandler,
saxxmlreader_get_dtdHandler,
saxxmlreader_put_dtdHandler,
saxxmlreader_get_errorHandler,
saxxmlreader_put_errorHandler,
saxxmlreader_get_baseURL,
saxxmlreader_put_baseURL,
saxxmlreader_get_secureBaseURL,
saxxmlreader_put_secureBaseURL,
saxxmlreader_parse,
saxxmlreader_parseURL
};
/*** ISAXXMLReader interface ***/
/*** IUnknown methods ***/
static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
}
static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
}
static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
}
/*** ISAXXMLReader methods ***/
static HRESULT WINAPI isaxxmlreader_getFeature(
ISAXXMLReader* iface,
const WCHAR *pFeature,
VARIANT_BOOL *pValue)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_getFeature(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pFeature, pValue);
}
static HRESULT WINAPI isaxxmlreader_putFeature(
ISAXXMLReader* iface,
const WCHAR *pFeature,
VARIANT_BOOL vfValue)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_putFeature(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pFeature, vfValue);
}
static HRESULT WINAPI isaxxmlreader_getProperty(
ISAXXMLReader* iface,
const WCHAR *pProp,
VARIANT *pValue)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_getProperty(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pProp, pValue);
}
static HRESULT WINAPI isaxxmlreader_putProperty(
ISAXXMLReader* iface,
const WCHAR *pProp,
VARIANT value)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_putProperty(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pProp, value);
}
static HRESULT WINAPI isaxxmlreader_getEntityResolver(
ISAXXMLReader* iface,
ISAXEntityResolver **ppEntityResolver)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_getEntityResolver(This, ppEntityResolver, FALSE);
}
static HRESULT WINAPI isaxxmlreader_putEntityResolver(
ISAXXMLReader* iface,
ISAXEntityResolver *pEntityResolver)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_putEntityResolver(This, pEntityResolver, FALSE);
}
static HRESULT WINAPI isaxxmlreader_getContentHandler(
ISAXXMLReader* iface,
ISAXContentHandler **pContentHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_getContentHandler(This, pContentHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_putContentHandler(
ISAXXMLReader* iface,
ISAXContentHandler *contentHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_putContentHandler(This, contentHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_getDTDHandler(
ISAXXMLReader* iface,
ISAXDTDHandler **pDTDHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_getDTDHandler(This, pDTDHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_putDTDHandler(
ISAXXMLReader* iface,
ISAXDTDHandler *pDTDHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_putDTDHandler(This, pDTDHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_getErrorHandler(
ISAXXMLReader* iface,
ISAXErrorHandler **pErrorHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_getErrorHandler(This, pErrorHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_putErrorHandler(
ISAXXMLReader* iface,
ISAXErrorHandler *errorHandler)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_putErrorHandler(This, errorHandler, FALSE);
}
static HRESULT WINAPI isaxxmlreader_getBaseURL(
ISAXXMLReader* iface,
const WCHAR **pBaseUrl)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_get_baseURL(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pBaseUrl);
}
static HRESULT WINAPI isaxxmlreader_putBaseURL(
ISAXXMLReader* iface,
const WCHAR *pBaseUrl)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_put_baseURL(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pBaseUrl);
}
static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
ISAXXMLReader* iface,
const WCHAR **pSecureBaseUrl)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_get_secureBaseURL(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
pSecureBaseUrl);
}
static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
ISAXXMLReader* iface,
const WCHAR *secureBaseUrl)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return IVBSAXXMLReader_put_secureBaseURL(
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
secureBaseUrl);
}
static HRESULT WINAPI isaxxmlreader_parse(
ISAXXMLReader* iface,
VARIANT varInput)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_parse(This, varInput, FALSE);
}
static HRESULT WINAPI isaxxmlreader_parseURL(
ISAXXMLReader* iface,
const WCHAR *url)
{
saxreader *This = impl_from_ISAXXMLReader( iface );
return internal_parseURL(This, url, FALSE);
}
static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
{
isaxxmlreader_QueryInterface,
isaxxmlreader_AddRef,
isaxxmlreader_Release,
isaxxmlreader_getFeature,
isaxxmlreader_putFeature,
isaxxmlreader_getProperty,
isaxxmlreader_putProperty,
isaxxmlreader_getEntityResolver,
isaxxmlreader_putEntityResolver,
isaxxmlreader_getContentHandler,
isaxxmlreader_putContentHandler,
isaxxmlreader_getDTDHandler,
isaxxmlreader_putDTDHandler,
isaxxmlreader_getErrorHandler,
isaxxmlreader_putErrorHandler,
isaxxmlreader_getBaseURL,
isaxxmlreader_putBaseURL,
isaxxmlreader_getSecureBaseURL,
isaxxmlreader_putSecureBaseURL,
isaxxmlreader_parse,
isaxxmlreader_parseURL
};
HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
{
saxreader *reader;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
if( !reader )
return E_OUTOFMEMORY;
reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
reader->ref = 1;
reader->contentHandler = NULL;
reader->vbcontentHandler = NULL;
reader->errorHandler = NULL;
reader->vberrorHandler = NULL;
memset(&reader->sax, 0, sizeof(xmlSAXHandler));
reader->sax.initialized = XML_SAX2_MAGIC;
reader->sax.startDocument = libxmlStartDocument;
reader->sax.endDocument = libxmlEndDocument;
reader->sax.startElementNs = libxmlStartElementNS;
reader->sax.endElementNs = libxmlEndElementNS;
reader->sax.characters = libxmlCharacters;
reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
reader->sax.error = libxmlFatalError;
reader->sax.fatalError = libxmlFatalError;
*ppObj = &reader->lpVBSAXXMLReaderVtbl;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}
#else
HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
{
MESSAGE("This program tried to use a SAX XML Reader object, but\n"
"libxml2 support was not present at compile time.\n");
return E_NOTIMPL;
}
#endif
Reference in New Issue View Git Blame Copy Permalink