2008-09-08 16:58:34 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2009-01-04 10:48:19 +00:00
|
|
|
struct ISAXLexicalHandler *lexicalHandler;
|
|
|
|
struct IVBSAXLexicalHandler *vblexicalHandler;
|
|
|
|
struct ISAXDeclHandler *declHandler;
|
|
|
|
struct IVBSAXDeclHandler *vbdeclHandler;
|
2008-09-08 16:58:34 +00:00
|
|
|
xmlSAXHandler sax;
|
2009-01-04 10:48:19 +00:00
|
|
|
BOOL isParsing;
|
2008-09-08 16:58:34 +00:00
|
|
|
} 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;
|
2009-01-04 10:48:19 +00:00
|
|
|
int realLine;
|
2008-09-08 16:58:34 +00:00
|
|
|
int column;
|
2009-01-04 10:48:19 +00:00
|
|
|
int realColumn;
|
2008-09-08 16:58:34 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
static inline BOOL has_content_handler(const saxlocator *locator)
|
|
|
|
{
|
|
|
|
return (locator->vbInterface && locator->saxreader->vbcontentHandler) ||
|
|
|
|
(!locator->vbInterface && locator->saxreader->contentHandler);
|
|
|
|
}
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
static HRESULT namespacePush(saxlocator *locator, int ns)
|
|
|
|
{
|
|
|
|
if(locator->nsStackLast>=locator->nsStackSize)
|
|
|
|
{
|
|
|
|
int *new_stack;
|
|
|
|
|
|
|
|
new_stack = HeapReAlloc(GetProcessHeap(), 0,
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
locator->nsStack, sizeof(int)*locator->nsStackSize*2);
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
BSTR bstr;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
|
|
|
|
if(len != -1) dLen++;
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
bstr = SysAllocStringLen(NULL, dLen-1);
|
|
|
|
if (!bstr)
|
2008-09-08 16:58:34 +00:00
|
|
|
return NULL;
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, bstr, dLen);
|
|
|
|
if(len != -1) bstr[dLen-1] = '\0';
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
return bstr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
|
|
|
|
{
|
|
|
|
DWORD dLen, dLast;
|
|
|
|
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);
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
bstr = SysAllocStringLen(NULL, dLen-1);
|
|
|
|
if(!bstr)
|
2008-09-08 16:58:34 +00:00
|
|
|
return NULL;
|
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
dLast = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, bstr, dLen);
|
|
|
|
bstr[dLast-1] = ':';
|
|
|
|
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &bstr[dLast], dLen-dLast);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
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;
|
2009-01-04 10:48:19 +00:00
|
|
|
This->realLine = 1;
|
|
|
|
This->realColumn = 1;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
else if(This->lastCur < This->pParserCtxt->input->base)
|
|
|
|
{
|
|
|
|
This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
|
2009-01-04 10:48:19 +00:00
|
|
|
This->realLine = 1;
|
|
|
|
This->realColumn = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(This->pParserCtxt->input->cur<This->lastCur)
|
|
|
|
{
|
|
|
|
This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
|
|
|
|
This->realLine -= 1;
|
|
|
|
This->realColumn = 1;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
|
|
|
|
|
|
|
|
while(This->lastCur < end)
|
|
|
|
{
|
|
|
|
if(*(This->lastCur) == '\n')
|
|
|
|
{
|
2009-01-04 10:48:19 +00:00
|
|
|
This->realLine++;
|
|
|
|
This->realColumn = 1;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
else if(*(This->lastCur) == '\r' &&
|
|
|
|
(This->lastCur==This->pParserCtxt->input->end ||
|
|
|
|
*(This->lastCur+1)!='\n'))
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
2009-01-04 10:48:19 +00:00
|
|
|
This->realLine++;
|
|
|
|
This->realColumn = 1;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
else This->realColumn++;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
This->lastCur++;
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
/* Count multibyte UTF8 encoded characters once */
|
|
|
|
while((*(This->lastCur)&0xC0) == 0x80) This->lastCur++;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
This->line = This->realLine;
|
|
|
|
This->column = This->realColumn;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*** 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(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
|
|
|
|
localName, SysStringLen(localName), index);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
|
|
|
|
IVBSAXAttributes* iface,
|
|
|
|
BSTR QName,
|
|
|
|
int *index)
|
|
|
|
{
|
|
|
|
saxattributes *This = impl_from_IVBSAXAttributes( iface );
|
|
|
|
return ISAXAttributes_getIndexFromQName(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
|
|
|
|
SysStringLen(QName), index);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
|
|
|
|
localName, SysStringLen(localName), (const WCHAR**)type, &len);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
|
|
|
|
IVBSAXAttributes* iface,
|
|
|
|
BSTR QName,
|
|
|
|
BSTR *type)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
saxattributes *This = impl_from_IVBSAXAttributes( iface );
|
|
|
|
return ISAXAttributes_getTypeFromQName(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
|
|
|
|
SysStringLen(QName), (const WCHAR**)type, &len);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, uri, SysStringLen(uri),
|
|
|
|
localName, SysStringLen(localName), (const WCHAR**)value, &len);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
|
|
|
|
IVBSAXAttributes* iface,
|
|
|
|
BSTR QName,
|
|
|
|
BSTR *value)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
saxattributes *This = impl_from_IVBSAXAttributes( iface );
|
|
|
|
return ISAXAttributes_getValueFromQName(
|
2009-01-31 11:27:22 +00:00
|
|
|
(ISAXAttributes*)&This->lpSAXAttributesVtbl, QName,
|
|
|
|
SysStringLen(QName), (const WCHAR**)value, &len);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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]);
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(This->szLocalname);
|
|
|
|
heap_free(This->szURI);
|
|
|
|
heap_free(This->szValue);
|
|
|
|
heap_free(This->szQName);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(This);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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";
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
attributes = heap_alloc(sizeof(*attributes));
|
2008-09-08 16:58:34 +00:00
|
|
|
if(!attributes)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
|
|
|
attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
|
|
|
|
attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
|
|
|
|
attributes->ref = 1;
|
|
|
|
|
|
|
|
attributes->nb_attributes = nb_namespaces+nb_attributes;
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
attributes->szLocalname = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
|
|
|
|
attributes->szURI = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
|
|
|
|
attributes->szValue = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
|
|
|
|
attributes->szQName = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
if(!attributes->szLocalname || !attributes->szURI
|
|
|
|
|| !attributes->szValue || !attributes->szQName)
|
|
|
|
{
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(attributes->szLocalname);
|
|
|
|
heap_free(attributes->szURI);
|
|
|
|
heap_free(attributes->szValue);
|
|
|
|
heap_free(attributes->szQName);
|
|
|
|
heap_free(attributes);
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
if(has_content_handler(This))
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
if(has_content_handler(This))
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(*(This->pParserCtxt->input->cur) == '/')
|
|
|
|
update_position(This, (xmlChar*)This->pParserCtxt->input->cur+2);
|
|
|
|
else
|
|
|
|
update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
hr = namespacePush(This, nb_namespaces);
|
2010-02-06 21:34:28 +00:00
|
|
|
if(hr==S_OK && has_content_handler(This))
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
end = (xmlChar*)This->pParserCtxt->input->cur;
|
|
|
|
if(*(end-1) != '>' || *(end-2) != '/')
|
Sync avifil, credui, crypt32, cryptdlg, cryptui, dnsapi, gdiplus, hhctrl, hnetcfg, iccvid, imaadp32, imm32, jscript, localspl, localui, mapi32, mciavi32, mcicda, mciqtz32, mciseq, mciwave, mshtml, msrle32, msvfw32, msvidc32, msxml3, oleacc, oleaut32 to Wine 1.2rc5 (Samuel Serapion, small changes by me)
Remove Esperanto and Walon languages from comctl32, comdlg32, mpr, msi, shlwapi, wininet
svn path=/trunk/; revision=47920
2010-07-01 11:09:47 +00:00
|
|
|
while(end-2>=This->pParserCtxt->input->base
|
|
|
|
&& *(end-2)!='<' && *(end-1)!='/') end--;
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
update_position(This, end);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
nsNr = namespacePop(This);
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
if(has_content_handler(This))
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
|
|
|
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);
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
if(hr != S_OK)
|
|
|
|
{
|
|
|
|
format_error_message_from_id(This, hr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
update_position(This, NULL);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void libxmlCharacters(
|
|
|
|
void *ctx,
|
|
|
|
const xmlChar *ch,
|
|
|
|
int len)
|
|
|
|
{
|
|
|
|
saxlocator *This = ctx;
|
2009-01-04 10:48:19 +00:00
|
|
|
BSTR Chars;
|
2008-09-08 16:58:34 +00:00
|
|
|
HRESULT hr;
|
2009-01-04 10:48:19 +00:00
|
|
|
xmlChar *cur;
|
2008-09-08 16:58:34 +00:00
|
|
|
xmlChar *end;
|
2009-01-04 10:48:19 +00:00
|
|
|
BOOL lastEvent = FALSE;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
if(!(has_content_handler(This))) return;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
cur = (xmlChar*)ch;
|
|
|
|
if(*(ch-1)=='\r') cur--;
|
|
|
|
end = cur;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
|
|
|
|
This->column++;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
while(1)
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
2009-01-04 10:48:19 +00:00
|
|
|
while(end-ch<len && *end!='\r') end++;
|
|
|
|
if(end-ch==len)
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
2009-01-04 10:48:19 +00:00
|
|
|
end--;
|
|
|
|
lastEvent = TRUE;
|
|
|
|
}
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(!lastEvent) *end = '\n';
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
Chars = bstr_from_xmlCharN(cur, end-cur+1);
|
|
|
|
if(This->vbInterface)
|
|
|
|
hr = IVBSAXContentHandler_characters(
|
|
|
|
This->saxreader->vbcontentHandler, &Chars);
|
|
|
|
else
|
|
|
|
hr = ISAXContentHandler_characters(
|
|
|
|
This->saxreader->contentHandler,
|
|
|
|
Chars, SysStringLen(Chars));
|
|
|
|
SysFreeString(Chars);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(hr != S_OK)
|
|
|
|
{
|
|
|
|
format_error_message_from_id(This, hr);
|
|
|
|
return;
|
|
|
|
}
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
This->column += end-cur+1;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(lastEvent)
|
|
|
|
break;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
*end = '\r';
|
|
|
|
end++;
|
|
|
|
if(*end == '\n')
|
|
|
|
{
|
|
|
|
end++;
|
|
|
|
This->column++;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
cur = end;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(end-ch == len) break;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
|
|
|
|
if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
|
|
|
|
This->column = This->realColumn
|
|
|
|
+This->pParserCtxt->input->cur-This->lastCur;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static void libxmlComment(void *ctx, const xmlChar *value)
|
|
|
|
{
|
|
|
|
saxlocator *This = ctx;
|
|
|
|
BSTR bValue;
|
|
|
|
HRESULT hr;
|
|
|
|
xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur;
|
|
|
|
|
Sync avifil, credui, crypt32, cryptdlg, cryptui, dnsapi, gdiplus, hhctrl, hnetcfg, iccvid, imaadp32, imm32, jscript, localspl, localui, mapi32, mciavi32, mcicda, mciqtz32, mciseq, mciwave, mshtml, msrle32, msvfw32, msvidc32, msxml3, oleacc, oleaut32 to Wine 1.2rc5 (Samuel Serapion, small changes by me)
Remove Esperanto and Walon languages from comctl32, comdlg32, mpr, msi, shlwapi, wininet
svn path=/trunk/; revision=47920
2010-07-01 11:09:47 +00:00
|
|
|
while(beg-4>=This->pParserCtxt->input->base
|
|
|
|
&& memcmp(beg-4, "<!--", sizeof(char[4]))) beg--;
|
2009-01-04 10:48:19 +00:00
|
|
|
update_position(This, beg);
|
|
|
|
|
|
|
|
if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
|
|
|
|
if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
|
|
|
|
|
|
|
|
bValue = bstr_from_xmlChar(value);
|
|
|
|
|
|
|
|
if(This->vbInterface)
|
|
|
|
hr = IVBSAXLexicalHandler_comment(
|
|
|
|
This->saxreader->vblexicalHandler, &bValue);
|
|
|
|
else
|
|
|
|
hr = ISAXLexicalHandler_comment(
|
|
|
|
This->saxreader->lexicalHandler,
|
|
|
|
bValue, SysStringLen(bValue));
|
|
|
|
|
|
|
|
SysFreeString(bValue);
|
|
|
|
|
|
|
|
if(FAILED(hr))
|
|
|
|
format_error_message_from_id(This, hr);
|
|
|
|
|
|
|
|
update_position(This, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void libxmlFatalError(void *ctx, const char *msg, ...)
|
2008-09-08 16:58:34 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
|
2010-02-06 21:34:28 +00:00
|
|
|
wszError = heap_alloc(sizeof(WCHAR)*len);
|
2008-09-08 16:58:34 +00:00
|
|
|
if(wszError)
|
2009-01-31 11:27:22 +00:00
|
|
|
MultiByteToWideChar(CP_UNIXCP, 0, message, -1, wszError, len);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(wszError);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
xmlStopParser(This->pParserCtxt);
|
|
|
|
This->ret = E_FAIL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
|
|
|
|
{
|
|
|
|
saxlocator *This = ctx;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
|
|
|
|
xmlChar *cur, *end;
|
|
|
|
int realLen;
|
|
|
|
BSTR Chars;
|
|
|
|
BOOL lastEvent = FALSE, change;
|
|
|
|
|
Sync avifil, credui, crypt32, cryptdlg, cryptui, dnsapi, gdiplus, hhctrl, hnetcfg, iccvid, imaadp32, imm32, jscript, localspl, localui, mapi32, mciavi32, mcicda, mciqtz32, mciseq, mciwave, mshtml, msrle32, msvfw32, msvidc32, msxml3, oleacc, oleaut32 to Wine 1.2rc5 (Samuel Serapion, small changes by me)
Remove Esperanto and Walon languages from comctl32, comdlg32, mpr, msi, shlwapi, wininet
svn path=/trunk/; revision=47920
2010-07-01 11:09:47 +00:00
|
|
|
while(beg-9>=This->pParserCtxt->input->base
|
|
|
|
&& memcmp(beg-9, "<![CDATA[", sizeof(char[9]))) beg--;
|
2009-01-04 10:48:19 +00:00
|
|
|
update_position(This, beg);
|
|
|
|
|
|
|
|
if(This->vbInterface && This->saxreader->vblexicalHandler)
|
|
|
|
hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
|
|
|
|
if(!This->vbInterface && This->saxreader->lexicalHandler)
|
|
|
|
hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
|
|
|
|
|
|
|
|
if(FAILED(hr))
|
|
|
|
{
|
|
|
|
format_error_message_from_id(This, hr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
realLen = This->pParserCtxt->input->cur-beg-3;
|
|
|
|
cur = beg;
|
|
|
|
end = beg;
|
|
|
|
|
|
|
|
while(1)
|
|
|
|
{
|
|
|
|
while(end-beg<realLen && *end!='\r') end++;
|
|
|
|
if(end-beg==realLen)
|
|
|
|
{
|
|
|
|
end--;
|
|
|
|
lastEvent = TRUE;
|
|
|
|
}
|
|
|
|
else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
|
|
|
|
lastEvent = TRUE;
|
|
|
|
|
|
|
|
if(*end == '\r') change = TRUE;
|
|
|
|
else change = FALSE;
|
|
|
|
|
|
|
|
if(change) *end = '\n';
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
if(has_content_handler(This))
|
2009-01-04 10:48:19 +00:00
|
|
|
{
|
|
|
|
Chars = bstr_from_xmlCharN(cur, end-cur+1);
|
|
|
|
if(This->vbInterface)
|
|
|
|
hr = IVBSAXContentHandler_characters(
|
|
|
|
This->saxreader->vbcontentHandler, &Chars);
|
|
|
|
else
|
|
|
|
hr = ISAXContentHandler_characters(
|
|
|
|
This->saxreader->contentHandler,
|
|
|
|
Chars, SysStringLen(Chars));
|
|
|
|
SysFreeString(Chars);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(change) *end = '\r';
|
|
|
|
|
|
|
|
if(lastEvent)
|
|
|
|
break;
|
|
|
|
|
|
|
|
This->column += end-cur+2;
|
|
|
|
end += 2;
|
|
|
|
cur = end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(This->vbInterface && This->saxreader->vblexicalHandler)
|
|
|
|
hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
|
|
|
|
if(!This->vbInterface && This->saxreader->lexicalHandler)
|
|
|
|
hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
|
|
|
|
|
|
|
|
if(FAILED(hr))
|
|
|
|
format_error_message_from_id(This, hr);
|
|
|
|
|
|
|
|
This->column += 4+end-cur;
|
|
|
|
}
|
|
|
|
|
2008-09-08 16:58:34 +00:00
|
|
|
/*** 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 )
|
|
|
|
{
|
2009-01-04 10:48:19 +00:00
|
|
|
SysFreeString(This->publicId);
|
|
|
|
SysFreeString(This->systemId);
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(This->nsStack);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free( This );
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 );
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
SysFreeString(This->publicId);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
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 );
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
SysFreeString(This->systemId);
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
locator = heap_alloc( sizeof (*locator) );
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
locator->nsStack = heap_alloc(sizeof(int)*locator->nsStackSize);
|
2008-09-08 16:58:34 +00:00
|
|
|
if(!locator->nsStack)
|
|
|
|
{
|
|
|
|
ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free(locator);
|
2008-09-08 16:58:34 +00:00
|
|
|
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))
|
2009-01-04 10:48:19 +00:00
|
|
|
return hr;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
|
|
|
|
if(!locator->pParserCtxt)
|
|
|
|
{
|
|
|
|
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
|
|
|
|
return E_FAIL;
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
xmlFree(locator->pParserCtxt->sax);
|
2008-09-08 16:58:34 +00:00
|
|
|
locator->pParserCtxt->sax = &locator->saxreader->sax;
|
|
|
|
locator->pParserCtxt->userData = locator;
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
This->isParsing = TRUE;
|
2008-09-08 16:58:34 +00:00
|
|
|
if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
|
|
|
|
else hr = locator->ret;
|
2009-01-04 10:48:19 +00:00
|
|
|
This->isParsing = FALSE;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
if(locator->pParserCtxt)
|
|
|
|
{
|
|
|
|
locator->pParserCtxt->sax = NULL;
|
|
|
|
xmlFreeParserCtxt(locator->pParserCtxt);
|
|
|
|
locator->pParserCtxt = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
|
2009-01-04 10:48:19 +00:00
|
|
|
return hr;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
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))
|
2009-01-04 10:48:19 +00:00
|
|
|
return hr;
|
2008-09-21 13:03:20 +00:00
|
|
|
|
|
|
|
locator->pParserCtxt = xmlCreatePushParserCtxt(
|
|
|
|
&locator->saxreader->sax, locator,
|
|
|
|
data, dataRead, NULL);
|
|
|
|
if(!locator->pParserCtxt)
|
|
|
|
{
|
|
|
|
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
|
|
|
|
return E_FAIL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
This->isParsing = TRUE;
|
2008-09-21 13:03:20 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2009-01-04 10:48:19 +00:00
|
|
|
This->isParsing = FALSE;
|
2008-09-21 13:03:20 +00:00
|
|
|
|
|
|
|
xmlFreeParserCtxt(locator->pParserCtxt);
|
|
|
|
locator->pParserCtxt = NULL;
|
|
|
|
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_getEntityResolver(
|
2008-09-08 16:58:34 +00:00
|
|
|
saxreader *This,
|
|
|
|
void *pEntityResolver,
|
|
|
|
BOOL vbInterface)
|
|
|
|
{
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_putEntityResolver(
|
2008-09-08 16:58:34 +00:00
|
|
|
saxreader *This,
|
|
|
|
void *pEntityResolver,
|
|
|
|
BOOL vbInterface)
|
|
|
|
{
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_getContentHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_putContentHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_getDTDHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
saxreader* This,
|
|
|
|
void *pDTDHandler,
|
|
|
|
BOOL vbInterface)
|
|
|
|
{
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_putDTDHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
saxreader* This,
|
|
|
|
void *pDTDHandler,
|
|
|
|
BOOL vbInterface)
|
|
|
|
{
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_getErrorHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_putErrorHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_parse(
|
2008-09-08 16:58:34 +00:00
|
|
|
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));
|
2009-01-31 11:27:22 +00:00
|
|
|
hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
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);
|
2010-02-06 21:34:28 +00:00
|
|
|
SysFreeString(bstrData);
|
2009-01-04 10:48:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-09-08 16:58:34 +00:00
|
|
|
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)
|
|
|
|
{
|
2008-09-21 13:03:20 +00:00
|
|
|
hr = internal_parseStream(This, stream, vbInterface);
|
2008-09-08 16:58:34 +00:00
|
|
|
IStream_Release(stream);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_parseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
static HRESULT internal_putProperty(
|
|
|
|
saxreader* This,
|
|
|
|
const WCHAR *pProp,
|
|
|
|
VARIANT value,
|
|
|
|
BOOL vbInterface)
|
|
|
|
{
|
|
|
|
static const WCHAR wszCharset[] = {
|
|
|
|
'c','h','a','r','s','e','t',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszDeclarationHandler[] = {
|
|
|
|
'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
|
|
|
|
's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
|
|
|
|
'd','e','c','l','a','r','a','t','i','o','n',
|
|
|
|
'-','h','a','n','d','l','e','r',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszDomNode[] = {
|
|
|
|
'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
|
|
|
|
's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
|
|
|
|
'd','o','m','-','n','o','d','e',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszInputSource[] = {
|
|
|
|
'i','n','p','u','t','-','s','o','u','r','c','e',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszLexicalHandler[] = {
|
|
|
|
'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
|
|
|
|
's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
|
|
|
|
'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszMaxElementDepth[] = {
|
|
|
|
'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszMaxXMLSize[] = {
|
|
|
|
'm','a','x','-','x','m','l','-','s','i','z','e',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszSchemaDeclarationHandler[] = {
|
|
|
|
's','c','h','e','m','a','-',
|
|
|
|
'd','e','c','l','a','r','a','t','i','o','n','-',
|
|
|
|
'h','a','n','d','l','e','r',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszXMLDeclEncoding[] = {
|
|
|
|
'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszXMLDeclStandalone[] = {
|
|
|
|
'x','m','l','d','e','c','l',
|
|
|
|
'-','s','t','a','n','d','a','l','o','n','e',0
|
|
|
|
};
|
|
|
|
static const WCHAR wszXMLDeclVersion[] = {
|
|
|
|
'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
|
|
|
|
};
|
|
|
|
|
|
|
|
FIXME("(%p)->(%s): semi-stub\n", This, debugstr_w(pProp));
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszCharset, sizeof(wszCharset)))
|
|
|
|
return E_NOTIMPL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszDeclarationHandler, sizeof(wszDeclarationHandler)))
|
|
|
|
{
|
|
|
|
if(This->isParsing) return E_FAIL;
|
|
|
|
|
|
|
|
if(V_UNKNOWN(&value))
|
|
|
|
{
|
|
|
|
if(vbInterface)
|
|
|
|
IVBSAXDeclHandler_AddRef((IVBSAXDeclHandler*)V_UNKNOWN(&value));
|
|
|
|
else
|
|
|
|
ISAXDeclHandler_AddRef((ISAXDeclHandler*)V_UNKNOWN(&value));
|
|
|
|
}
|
|
|
|
if((vbInterface && This->vbdeclHandler)
|
|
|
|
|| (!vbInterface && This->declHandler))
|
|
|
|
{
|
|
|
|
if(vbInterface)
|
|
|
|
IVBSAXDeclHandler_Release(This->vbdeclHandler);
|
|
|
|
else
|
|
|
|
ISAXDeclHandler_Release(This->declHandler);
|
|
|
|
}
|
|
|
|
if(vbInterface)
|
|
|
|
This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
|
|
|
|
else
|
|
|
|
This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszDomNode, sizeof(wszDomNode)))
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszInputSource, sizeof(wszInputSource)))
|
|
|
|
return E_NOTIMPL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszLexicalHandler, sizeof(wszLexicalHandler)))
|
|
|
|
{
|
|
|
|
if(This->isParsing) return E_FAIL;
|
|
|
|
|
|
|
|
if(V_UNKNOWN(&value))
|
|
|
|
{
|
|
|
|
if(vbInterface)
|
|
|
|
IVBSAXLexicalHandler_AddRef(
|
|
|
|
(IVBSAXLexicalHandler*)V_UNKNOWN(&value));
|
|
|
|
else
|
|
|
|
ISAXLexicalHandler_AddRef(
|
|
|
|
(ISAXLexicalHandler*)V_UNKNOWN(&value));
|
|
|
|
}
|
|
|
|
if((vbInterface && This->vblexicalHandler)
|
|
|
|
|| (!vbInterface && This->lexicalHandler))
|
|
|
|
{
|
|
|
|
if(vbInterface)
|
|
|
|
IVBSAXLexicalHandler_Release(This->vblexicalHandler);
|
|
|
|
else
|
|
|
|
ISAXLexicalHandler_Release(This->lexicalHandler);
|
|
|
|
}
|
|
|
|
if(vbInterface)
|
|
|
|
This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
|
|
|
|
else
|
|
|
|
This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszMaxElementDepth, sizeof(wszMaxElementDepth)))
|
|
|
|
return E_NOTIMPL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszMaxXMLSize, sizeof(wszMaxXMLSize)))
|
|
|
|
return E_NOTIMPL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszSchemaDeclarationHandler,
|
|
|
|
sizeof(wszSchemaDeclarationHandler)))
|
|
|
|
return E_NOTIMPL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszXMLDeclEncoding, sizeof(wszXMLDeclEncoding)))
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszXMLDeclStandalone, sizeof(wszXMLDeclStandalone)))
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
if(!memcmp(pProp, wszXMLDeclVersion, sizeof(wszXMLDeclVersion)))
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
return E_INVALIDARG;
|
|
|
|
}
|
|
|
|
|
2008-09-08 16:58:34 +00:00
|
|
|
/*** 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 ))
|
|
|
|
{
|
2009-01-31 11:27:22 +00:00
|
|
|
*ppvObject = &This->lpSAXXMLReaderVtbl;
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
2009-01-04 10:48:19 +00:00
|
|
|
if(This->lexicalHandler)
|
|
|
|
ISAXLexicalHandler_Release(This->lexicalHandler);
|
|
|
|
|
|
|
|
if(This->vblexicalHandler)
|
|
|
|
IVBSAXLexicalHandler_Release(This->vblexicalHandler);
|
|
|
|
|
|
|
|
if(This->declHandler)
|
|
|
|
ISAXDeclHandler_Release(This->declHandler);
|
|
|
|
|
|
|
|
if(This->vbdeclHandler)
|
|
|
|
IVBSAXDeclHandler_Release(This->vbdeclHandler);
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
heap_free( This );
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 );
|
2009-01-04 10:48:19 +00:00
|
|
|
return internal_putProperty(This, pProp, value, TRUE);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_entityResolver(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXEntityResolver **pEntityResolver)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_getEntityResolver(This, pEntityResolver, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_entityResolver(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXEntityResolver *pEntityResolver)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_putEntityResolver(This, pEntityResolver, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_contentHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXContentHandler **ppContentHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_getContentHandler(This, ppContentHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_contentHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXContentHandler *contentHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_putContentHandler(This, contentHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_dtdHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXDTDHandler **pDTDHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_getDTDHandler(This, pDTDHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_dtdHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXDTDHandler *pDTDHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_putDTDHandler(This, pDTDHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_errorHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXErrorHandler **pErrorHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_getErrorHandler(This, pErrorHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_errorHandler(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
IVBSAXErrorHandler *errorHandler)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
return internal_putErrorHandler(This, errorHandler, TRUE);
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_baseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
const WCHAR **pBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_baseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
const WCHAR *pBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
|
|
|
|
FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
IVBSAXXMLReader* iface,
|
|
|
|
const WCHAR **pSecureBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_IVBSAXXMLReader( iface );
|
|
|
|
|
|
|
|
FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-09-21 13:03:20 +00:00
|
|
|
static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
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,
|
2008-09-21 13:03:20 +00:00
|
|
|
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,
|
2008-09-08 16:58:34 +00:00
|
|
|
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 );
|
2009-01-04 10:48:19 +00:00
|
|
|
return internal_putProperty(This, pProp, value, FALSE);
|
2008-09-08 16:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 );
|
2008-09-21 13:03:20 +00:00
|
|
|
return IVBSAXXMLReader_get_baseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
|
|
|
|
pBaseUrl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI isaxxmlreader_putBaseURL(
|
|
|
|
ISAXXMLReader* iface,
|
|
|
|
const WCHAR *pBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_ISAXXMLReader( iface );
|
2008-09-21 13:03:20 +00:00
|
|
|
return IVBSAXXMLReader_put_baseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
|
|
|
|
pBaseUrl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
|
|
|
|
ISAXXMLReader* iface,
|
|
|
|
const WCHAR **pSecureBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_ISAXXMLReader( iface );
|
2008-09-21 13:03:20 +00:00
|
|
|
return IVBSAXXMLReader_get_secureBaseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
(IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
|
|
|
|
pSecureBaseUrl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
|
|
|
|
ISAXXMLReader* iface,
|
|
|
|
const WCHAR *secureBaseUrl)
|
|
|
|
{
|
|
|
|
saxreader *This = impl_from_ISAXXMLReader( iface );
|
2008-09-21 13:03:20 +00:00
|
|
|
return IVBSAXXMLReader_put_secureBaseURL(
|
2008-09-08 16:58:34 +00:00
|
|
|
(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);
|
|
|
|
|
2010-02-06 21:34:28 +00:00
|
|
|
reader = heap_alloc( sizeof (*reader) );
|
2008-09-08 16:58:34 +00:00
|
|
|
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;
|
2009-01-04 10:48:19 +00:00
|
|
|
reader->lexicalHandler = NULL;
|
|
|
|
reader->vblexicalHandler = NULL;
|
|
|
|
reader->declHandler = NULL;
|
|
|
|
reader->vbdeclHandler = NULL;
|
|
|
|
reader->isParsing = FALSE;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
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;
|
2009-01-04 10:48:19 +00:00
|
|
|
reader->sax.comment = libxmlComment;
|
2008-09-08 16:58:34 +00:00
|
|
|
reader->sax.error = libxmlFatalError;
|
|
|
|
reader->sax.fatalError = libxmlFatalError;
|
2009-01-04 10:48:19 +00:00
|
|
|
reader->sax.cdataBlock = libxmlCDataBlock;
|
2008-09-08 16:58:34 +00:00
|
|
|
|
|
|
|
*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
|