mxwriter.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "msxml6.h"
#include "wine/debug.h"
#include "msxml_dispex.h"

Include dependency graph for mxwriter.c:

Go to the source code of this file.

Classes
struct	xml_encoding_data
struct	encoded_buffer
struct	output_buffer
struct	mxwriter
struct	mxattribute
struct	mxattributes

Macros
#define	COBJMACROS

Enumerations
enum	xml_encoding {   XmlEncoding_ISO_8859_1 = 0 , XmlEncoding_ISO_8859_13 , XmlEncoding_ISO_8859_15 , XmlEncoding_ISO_8859_2 ,   XmlEncoding_ISO_8859_3 , XmlEncoding_ISO_8859_4 , XmlEncoding_ISO_8859_5 , XmlEncoding_ISO_8859_7 ,   XmlEncoding_ISO_8859_9 , XmlEncoding_UTF16 , XmlEncoding_UTF8 , XmlEncoding_windows_1250 ,   XmlEncoding_windows_1251 , XmlEncoding_windows_1252 , XmlEncoding_windows_1253 , XmlEncoding_windows_1254 ,   XmlEncoding_windows_1255 , XmlEncoding_windows_1256 , XmlEncoding_windows_1257 , XmlEncoding_windows_1258 ,   XmlEncoding_Unknown , XmlEncoding_USASCII , XmlEncoding_UTF16 , XmlEncoding_UTF8 ,   XmlEncoding_Unknown }
enum	mxwriter_prop {   MXWriter_BOM = 0 , MXWriter_DisableEscaping , MXWriter_Indent , MXWriter_OmitXmlDecl ,   MXWriter_Standalone , MXWriter_LastProp }
enum	escape_mode { EscapeValue , EscapeText }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msxml)
static mxattributes *	impl_from_IMXAttributes (IMXAttributes *iface)
static mxattributes *	impl_from_ISAXAttributes (ISAXAttributes *iface)
static mxattributes *	impl_from_IVBSAXAttributes (IVBSAXAttributes *iface)
static HRESULT	mxattributes_grow (mxattributes *This)
static xml_encoding	parse_encoding_name (const WCHAR *encoding)
static HRESULT	init_encoded_buffer (encoded_buffer *buffer)
static void	free_encoded_buffer (encoded_buffer *buffer)
static HRESULT	get_code_page (xml_encoding encoding, UINT *cp)
static HRESULT	init_output_buffer (xml_encoding encoding, output_buffer *buffer)
static void	free_output_buffer (output_buffer *buffer)
static HRESULT	write_output_buffer (mxwriter *writer, const WCHAR *data, int len)
static HRESULT	write_output_buffer_quoted (mxwriter *writer, const WCHAR *data, int len)
static void	close_output_buffer (mxwriter *writer)
static WCHAR *	get_escaped_string (const WCHAR *str, escape_mode mode, int *len)
static void	write_prolog_buffer (mxwriter *writer)
static HRESULT	write_data_to_stream (mxwriter *writer)
static void	close_element_starttag (mxwriter *writer)
static void	write_node_indent (mxwriter *writer)
static void	writer_inc_indent (mxwriter *This)
static void	writer_dec_indent (mxwriter *This)
static void	set_element_name (mxwriter *This, const WCHAR *name, int len)
static HRESULT	flush_output_buffer (mxwriter *This)
static HRESULT	writer_set_property (mxwriter *writer, mxwriter_prop property, VARIANT_BOOL value)
static HRESULT	writer_get_property (const mxwriter *writer, mxwriter_prop property, VARIANT_BOOL *value)
static mxwriter *	impl_from_IMXWriter (IMXWriter *iface)
static mxwriter *	impl_from_ISAXContentHandler (ISAXContentHandler *iface)
static mxwriter *	impl_from_IVBSAXContentHandler (IVBSAXContentHandler *iface)
static mxwriter *	impl_from_ISAXLexicalHandler (ISAXLexicalHandler *iface)
static mxwriter *	impl_from_IVBSAXLexicalHandler (IVBSAXLexicalHandler *iface)
static mxwriter *	impl_from_ISAXDeclHandler (ISAXDeclHandler *iface)
static mxwriter *	impl_from_IVBSAXDeclHandler (IVBSAXDeclHandler *iface)
static mxwriter *	impl_from_ISAXDTDHandler (ISAXDTDHandler *iface)
static mxwriter *	impl_from_IVBSAXDTDHandler (IVBSAXDTDHandler *iface)
static mxwriter *	impl_from_ISAXErrorHandler (ISAXErrorHandler *iface)
static mxwriter *	impl_from_IVBSAXErrorHandler (IVBSAXErrorHandler *iface)
static HRESULT WINAPI	mxwriter_QueryInterface (IMXWriter *iface, REFIID riid, void **obj)
static ULONG WINAPI	mxwriter_AddRef (IMXWriter *iface)
static ULONG WINAPI	mxwriter_Release (IMXWriter *iface)
static HRESULT WINAPI	mxwriter_GetTypeInfoCount (IMXWriter *iface, UINT *pctinfo)
static HRESULT WINAPI	mxwriter_GetTypeInfo (IMXWriter *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	mxwriter_GetIDsOfNames (IMXWriter *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	mxwriter_Invoke (IMXWriter *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	mxwriter_put_output (IMXWriter *iface, VARIANT dest)
static HRESULT WINAPI	mxwriter_get_output (IMXWriter *iface, VARIANT *dest)
static HRESULT WINAPI	mxwriter_put_encoding (IMXWriter *iface, BSTR encoding)
static HRESULT WINAPI	mxwriter_get_encoding (IMXWriter *iface, BSTR *encoding)
static HRESULT WINAPI	mxwriter_put_byteOrderMark (IMXWriter *iface, VARIANT_BOOL value)
static HRESULT WINAPI	mxwriter_get_byteOrderMark (IMXWriter *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	mxwriter_put_indent (IMXWriter *iface, VARIANT_BOOL value)
static HRESULT WINAPI	mxwriter_get_indent (IMXWriter *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	mxwriter_put_standalone (IMXWriter *iface, VARIANT_BOOL value)
static HRESULT WINAPI	mxwriter_get_standalone (IMXWriter *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	mxwriter_put_omitXMLDeclaration (IMXWriter *iface, VARIANT_BOOL value)
static HRESULT WINAPI	mxwriter_get_omitXMLDeclaration (IMXWriter *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	mxwriter_put_version (IMXWriter *iface, BSTR version)
static HRESULT WINAPI	mxwriter_get_version (IMXWriter *iface, BSTR *version)
static HRESULT WINAPI	mxwriter_put_disableOutputEscaping (IMXWriter *iface, VARIANT_BOOL value)
static HRESULT WINAPI	mxwriter_get_disableOutputEscaping (IMXWriter *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	mxwriter_flush (IMXWriter *iface)
static HRESULT WINAPI	SAXContentHandler_QueryInterface (ISAXContentHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	SAXContentHandler_AddRef (ISAXContentHandler *iface)
static ULONG WINAPI	SAXContentHandler_Release (ISAXContentHandler *iface)
static HRESULT WINAPI	SAXContentHandler_putDocumentLocator (ISAXContentHandler *iface, ISAXLocator *locator)
static HRESULT WINAPI	SAXContentHandler_startDocument (ISAXContentHandler *iface)
static HRESULT WINAPI	SAXContentHandler_endDocument (ISAXContentHandler *iface)
static HRESULT WINAPI	SAXContentHandler_startPrefixMapping (ISAXContentHandler *iface, const WCHAR *prefix, int nprefix, const WCHAR *uri, int nuri)
static HRESULT WINAPI	SAXContentHandler_endPrefixMapping (ISAXContentHandler *iface, const WCHAR *prefix, int nprefix)
static void	mxwriter_write_attribute (mxwriter *writer, const WCHAR *qname, int qname_len, const WCHAR *value, int value_len, BOOL escape)
static void	mxwriter_write_starttag (mxwriter *writer, const WCHAR *qname, int len)
static HRESULT WINAPI	SAXContentHandler_startElement (ISAXContentHandler *iface, const WCHAR *namespaceUri, int nnamespaceUri, const WCHAR *local_name, int nlocal_name, const WCHAR *QName, int nQName, ISAXAttributes *attr)
static HRESULT WINAPI	SAXContentHandler_endElement (ISAXContentHandler *iface, const WCHAR *namespaceUri, int nnamespaceUri, const WCHAR *local_name, int nlocal_name, const WCHAR *QName, int nQName)
static HRESULT WINAPI	SAXContentHandler_characters (ISAXContentHandler *iface, const WCHAR *chars, int nchars)
static HRESULT WINAPI	SAXContentHandler_ignorableWhitespace (ISAXContentHandler *iface, const WCHAR *chars, int nchars)
static HRESULT WINAPI	SAXContentHandler_processingInstruction (ISAXContentHandler *iface, const WCHAR *target, int ntarget, const WCHAR *data, int ndata)
static HRESULT WINAPI	SAXContentHandler_skippedEntity (ISAXContentHandler *iface, const WCHAR *name, int nname)
static HRESULT WINAPI	SAXLexicalHandler_QueryInterface (ISAXLexicalHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	SAXLexicalHandler_AddRef (ISAXLexicalHandler *iface)
static ULONG WINAPI	SAXLexicalHandler_Release (ISAXLexicalHandler *iface)
static HRESULT WINAPI	SAXLexicalHandler_startDTD (ISAXLexicalHandler *iface, const WCHAR *name, int name_len, const WCHAR *publicId, int publicId_len, const WCHAR *systemId, int systemId_len)
static HRESULT WINAPI	SAXLexicalHandler_endDTD (ISAXLexicalHandler *iface)
static HRESULT WINAPI	SAXLexicalHandler_startEntity (ISAXLexicalHandler *iface, const WCHAR *name, int len)
static HRESULT WINAPI	SAXLexicalHandler_endEntity (ISAXLexicalHandler *iface, const WCHAR *name, int len)
static HRESULT WINAPI	SAXLexicalHandler_startCDATA (ISAXLexicalHandler *iface)
static HRESULT WINAPI	SAXLexicalHandler_endCDATA (ISAXLexicalHandler *iface)
static HRESULT WINAPI	SAXLexicalHandler_comment (ISAXLexicalHandler *iface, const WCHAR *chars, int nchars)
static HRESULT WINAPI	SAXDeclHandler_QueryInterface (ISAXDeclHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	SAXDeclHandler_AddRef (ISAXDeclHandler *iface)
static ULONG WINAPI	SAXDeclHandler_Release (ISAXDeclHandler *iface)
static HRESULT WINAPI	SAXDeclHandler_elementDecl (ISAXDeclHandler *iface, const WCHAR *name, int n_name, const WCHAR *model, int n_model)
static HRESULT WINAPI	SAXDeclHandler_attributeDecl (ISAXDeclHandler *iface, const WCHAR *element, int n_element, const WCHAR *attr, int n_attr, const WCHAR *type, int n_type, const WCHAR *Default, int n_default, const WCHAR *value, int n_value)
static HRESULT WINAPI	SAXDeclHandler_internalEntityDecl (ISAXDeclHandler *iface, const WCHAR *name, int n_name, const WCHAR *value, int n_value)
static HRESULT WINAPI	SAXDeclHandler_externalEntityDecl (ISAXDeclHandler *iface, const WCHAR *name, int n_name, const WCHAR *publicId, int n_publicId, const WCHAR *systemId, int n_systemId)
static HRESULT WINAPI	VBSAXDeclHandler_QueryInterface (IVBSAXDeclHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	VBSAXDeclHandler_AddRef (IVBSAXDeclHandler *iface)
static ULONG WINAPI	VBSAXDeclHandler_Release (IVBSAXDeclHandler *iface)
static HRESULT WINAPI	VBSAXDeclHandler_GetTypeInfoCount (IVBSAXDeclHandler *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXDeclHandler_GetTypeInfo (IVBSAXDeclHandler *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXDeclHandler_GetIDsOfNames (IVBSAXDeclHandler *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXDeclHandler_Invoke (IVBSAXDeclHandler *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXDeclHandler_elementDecl (IVBSAXDeclHandler *iface, BSTR *name, BSTR *model)
static HRESULT WINAPI	VBSAXDeclHandler_attributeDecl (IVBSAXDeclHandler *iface, BSTR *element, BSTR *attr, BSTR *type, BSTR *default_value, BSTR *value)
static HRESULT WINAPI	VBSAXDeclHandler_internalEntityDecl (IVBSAXDeclHandler *iface, BSTR *name, BSTR *value)
static HRESULT WINAPI	VBSAXDeclHandler_externalEntityDecl (IVBSAXDeclHandler *iface, BSTR *name, BSTR *publicid, BSTR *systemid)
static HRESULT WINAPI	VBSAXLexicalHandler_QueryInterface (IVBSAXLexicalHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	VBSAXLexicalHandler_AddRef (IVBSAXLexicalHandler *iface)
static ULONG WINAPI	VBSAXLexicalHandler_Release (IVBSAXLexicalHandler *iface)
static HRESULT WINAPI	VBSAXLexicalHandler_GetTypeInfoCount (IVBSAXLexicalHandler *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXLexicalHandler_GetTypeInfo (IVBSAXLexicalHandler *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXLexicalHandler_GetIDsOfNames (IVBSAXLexicalHandler *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXLexicalHandler_Invoke (IVBSAXLexicalHandler *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXLexicalHandler_startDTD (IVBSAXLexicalHandler *iface, BSTR *name, BSTR *publicId, BSTR *systemId)
static HRESULT WINAPI	VBSAXLexicalHandler_endDTD (IVBSAXLexicalHandler *iface)
static HRESULT WINAPI	VBSAXLexicalHandler_startEntity (IVBSAXLexicalHandler *iface, BSTR *name)
static HRESULT WINAPI	VBSAXLexicalHandler_endEntity (IVBSAXLexicalHandler *iface, BSTR *name)
static HRESULT WINAPI	VBSAXLexicalHandler_startCDATA (IVBSAXLexicalHandler *iface)
static HRESULT WINAPI	VBSAXLexicalHandler_endCDATA (IVBSAXLexicalHandler *iface)
static HRESULT WINAPI	VBSAXLexicalHandler_comment (IVBSAXLexicalHandler *iface, BSTR *chars)
static HRESULT WINAPI	VBSAXContentHandler_QueryInterface (IVBSAXContentHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	VBSAXContentHandler_AddRef (IVBSAXContentHandler *iface)
static ULONG WINAPI	VBSAXContentHandler_Release (IVBSAXContentHandler *iface)
static HRESULT WINAPI	VBSAXContentHandler_GetTypeInfoCount (IVBSAXContentHandler *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXContentHandler_GetTypeInfo (IVBSAXContentHandler *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXContentHandler_GetIDsOfNames (IVBSAXContentHandler *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXContentHandler_Invoke (IVBSAXContentHandler *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXContentHandler_putref_documentLocator (IVBSAXContentHandler *iface, IVBSAXLocator *locator)
static HRESULT WINAPI	VBSAXContentHandler_startDocument (IVBSAXContentHandler *iface)
static HRESULT WINAPI	VBSAXContentHandler_endDocument (IVBSAXContentHandler *iface)
static HRESULT WINAPI	VBSAXContentHandler_startPrefixMapping (IVBSAXContentHandler *iface, BSTR *prefix, BSTR *uri)
static HRESULT WINAPI	VBSAXContentHandler_endPrefixMapping (IVBSAXContentHandler *iface, BSTR *prefix)
static HRESULT WINAPI	VBSAXContentHandler_startElement (IVBSAXContentHandler *iface, BSTR *namespaceURI, BSTR *localName, BSTR *QName, IVBSAXAttributes *attrs)
static HRESULT WINAPI	VBSAXContentHandler_endElement (IVBSAXContentHandler *iface, BSTR *namespaceURI, BSTR *localName, BSTR *QName)
static HRESULT WINAPI	VBSAXContentHandler_characters (IVBSAXContentHandler *iface, BSTR *chars)
static HRESULT WINAPI	VBSAXContentHandler_ignorableWhitespace (IVBSAXContentHandler *iface, BSTR *chars)
static HRESULT WINAPI	VBSAXContentHandler_processingInstruction (IVBSAXContentHandler *iface, BSTR *target, BSTR *data)
static HRESULT WINAPI	VBSAXContentHandler_skippedEntity (IVBSAXContentHandler *iface, BSTR *name)
static HRESULT WINAPI	SAXDTDHandler_QueryInterface (ISAXDTDHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	SAXDTDHandler_AddRef (ISAXDTDHandler *iface)
static ULONG WINAPI	SAXDTDHandler_Release (ISAXDTDHandler *iface)
static HRESULT WINAPI	SAXDTDHandler_notationDecl (ISAXDTDHandler *iface, const WCHAR *name, INT n_name, const WCHAR *publicid, INT n_publicid, const WCHAR *systemid, INT n_systemid)
static HRESULT WINAPI	SAXDTDHandler_unparsedEntityDecl (ISAXDTDHandler *iface, const WCHAR *name, INT nname, const WCHAR *publicid, INT npublicid, const WCHAR *systemid, INT nsystemid, const WCHAR *notation, INT nnotation)
static HRESULT WINAPI	VBSAXDTDHandler_QueryInterface (IVBSAXDTDHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	VBSAXDTDHandler_AddRef (IVBSAXDTDHandler *iface)
static ULONG WINAPI	VBSAXDTDHandler_Release (IVBSAXDTDHandler *iface)
static HRESULT WINAPI	VBSAXDTDHandler_GetTypeInfoCount (IVBSAXDTDHandler *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXDTDHandler_GetTypeInfo (IVBSAXDTDHandler *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXDTDHandler_GetIDsOfNames (IVBSAXDTDHandler *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXDTDHandler_Invoke (IVBSAXDTDHandler *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXDTDHandler_notationDecl (IVBSAXDTDHandler *iface, BSTR *name, BSTR *publicId, BSTR *systemId)
static HRESULT WINAPI	VBSAXDTDHandler_unparsedEntityDecl (IVBSAXDTDHandler *iface, BSTR *name, BSTR *publicId, BSTR *systemId, BSTR *notation)
static HRESULT WINAPI	SAXErrorHandler_QueryInterface (ISAXErrorHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	SAXErrorHandler_AddRef (ISAXErrorHandler *iface)
static ULONG WINAPI	SAXErrorHandler_Release (ISAXErrorHandler *iface)
static HRESULT WINAPI	SAXErrorHandler_error (ISAXErrorHandler *iface, ISAXLocator *locator, const WCHAR *message, HRESULT hr)
static HRESULT WINAPI	SAXErrorHandler_fatalError (ISAXErrorHandler *iface, ISAXLocator *locator, const WCHAR *message, HRESULT hr)
static HRESULT WINAPI	SAXErrorHandler_ignorableWarning (ISAXErrorHandler *iface, ISAXLocator *locator, const WCHAR *message, HRESULT hr)
static HRESULT WINAPI	VBSAXErrorHandler_QueryInterface (IVBSAXErrorHandler *iface, REFIID riid, void **obj)
static ULONG WINAPI	VBSAXErrorHandler_AddRef (IVBSAXErrorHandler *iface)
static ULONG WINAPI	VBSAXErrorHandler_Release (IVBSAXErrorHandler *iface)
static HRESULT WINAPI	VBSAXErrorHandler_GetTypeInfoCount (IVBSAXErrorHandler *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXErrorHandler_GetTypeInfo (IVBSAXErrorHandler *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXErrorHandler_GetIDsOfNames (IVBSAXErrorHandler *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXErrorHandler_Invoke (IVBSAXErrorHandler *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXErrorHandler_error (IVBSAXErrorHandler *iface, IVBSAXLocator *locator, BSTR *message, LONG code)
static HRESULT WINAPI	VBSAXErrorHandler_fatalError (IVBSAXErrorHandler *iface, IVBSAXLocator *locator, BSTR *message, LONG code)
static HRESULT WINAPI	VBSAXErrorHandler_ignorableWarning (IVBSAXErrorHandler *iface, IVBSAXLocator *locator, BSTR *message, LONG code)
HRESULT	MXWriter_create (MSXML_VERSION version, void **ppObj)
static HRESULT WINAPI	MXAttributes_QueryInterface (IMXAttributes *iface, REFIID riid, void **ppObj)
static ULONG WINAPI	MXAttributes_AddRef (IMXAttributes *iface)
static ULONG WINAPI	MXAttributes_Release (IMXAttributes *iface)
static HRESULT WINAPI	MXAttributes_GetTypeInfoCount (IMXAttributes *iface, UINT *pctinfo)
static HRESULT WINAPI	MXAttributes_GetTypeInfo (IMXAttributes *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	MXAttributes_GetIDsOfNames (IMXAttributes *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	MXAttributes_Invoke (IMXAttributes *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	MXAttributes_addAttribute (IMXAttributes *iface, BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
static HRESULT WINAPI	MXAttributes_addAttributeFromIndex (IMXAttributes *iface, VARIANT atts, int index)
static HRESULT WINAPI	MXAttributes_clear (IMXAttributes *iface)
static mxattribute *	get_attribute_byindex (mxattributes *attrs, int index)
static HRESULT WINAPI	MXAttributes_removeAttribute (IMXAttributes *iface, int index)
static HRESULT WINAPI	MXAttributes_setAttribute (IMXAttributes *iface, int index, BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
static HRESULT WINAPI	MXAttributes_setAttributes (IMXAttributes *iface, VARIANT atts)
static HRESULT WINAPI	MXAttributes_setLocalName (IMXAttributes *iface, int index, BSTR localName)
static HRESULT WINAPI	MXAttributes_setQName (IMXAttributes *iface, int index, BSTR QName)
static HRESULT WINAPI	MXAttributes_setURI (IMXAttributes *iface, int index, BSTR uri)
static HRESULT WINAPI	MXAttributes_setValue (IMXAttributes *iface, int index, BSTR value)
static HRESULT WINAPI	SAXAttributes_QueryInterface (ISAXAttributes *iface, REFIID riid, void **ppObj)
static ULONG WINAPI	SAXAttributes_AddRef (ISAXAttributes *iface)
static ULONG WINAPI	SAXAttributes_Release (ISAXAttributes *iface)
static HRESULT WINAPI	SAXAttributes_getLength (ISAXAttributes *iface, int *length)
static HRESULT WINAPI	SAXAttributes_getURI (ISAXAttributes *iface, int index, const WCHAR **uri, int *len)
static HRESULT WINAPI	SAXAttributes_getLocalName (ISAXAttributes *iface, int index, const WCHAR **name, int *len)
static HRESULT WINAPI	SAXAttributes_getQName (ISAXAttributes *iface, int index, const WCHAR **qname, int *length)
static HRESULT WINAPI	SAXAttributes_getName (ISAXAttributes *iface, int index, const WCHAR **uri, int *uri_len, const WCHAR **local, int *local_len, const WCHAR **qname, int *qname_len)
static HRESULT WINAPI	SAXAttributes_getIndexFromName (ISAXAttributes *iface, const WCHAR *uri, int uri_len, const WCHAR *name, int len, int *index)
static HRESULT WINAPI	SAXAttributes_getIndexFromQName (ISAXAttributes *iface, const WCHAR *qname, int len, int *index)
static HRESULT WINAPI	SAXAttributes_getType (ISAXAttributes *iface, int index, const WCHAR **type, int *len)
static HRESULT WINAPI	SAXAttributes_getTypeFromName (ISAXAttributes *iface, const WCHAR *pUri, int nUri, const WCHAR *pLocalName, int nLocalName, const WCHAR **pType, int *nType)
static HRESULT WINAPI	SAXAttributes_getTypeFromQName (ISAXAttributes *iface, const WCHAR *pQName, int nQName, const WCHAR **pType, int *nType)
static HRESULT WINAPI	SAXAttributes_getValue (ISAXAttributes *iface, int index, const WCHAR **value, int *len)
static HRESULT WINAPI	SAXAttributes_getValueFromName (ISAXAttributes *iface, const WCHAR *uri, int uri_len, const WCHAR *name, int name_len, const WCHAR **value, int *value_len)
static HRESULT WINAPI	SAXAttributes_getValueFromQName (ISAXAttributes *iface, const WCHAR *qname, int qname_len, const WCHAR **value, int *value_len)
static HRESULT WINAPI	VBSAXAttributes_QueryInterface (IVBSAXAttributes *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	VBSAXAttributes_AddRef (IVBSAXAttributes *iface)
static ULONG WINAPI	VBSAXAttributes_Release (IVBSAXAttributes *iface)
static HRESULT WINAPI	VBSAXAttributes_GetTypeInfoCount (IVBSAXAttributes *iface, UINT *pctinfo)
static HRESULT WINAPI	VBSAXAttributes_GetTypeInfo (IVBSAXAttributes *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VBSAXAttributes_GetIDsOfNames (IVBSAXAttributes *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VBSAXAttributes_Invoke (IVBSAXAttributes *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	VBSAXAttributes_get_length (IVBSAXAttributes *iface, int *len)
static HRESULT WINAPI	VBSAXAttributes_getURI (IVBSAXAttributes *iface, int index, BSTR *uri)
static HRESULT WINAPI	VBSAXAttributes_getLocalName (IVBSAXAttributes *iface, int index, BSTR *name)
static HRESULT WINAPI	VBSAXAttributes_getQName (IVBSAXAttributes *iface, int index, BSTR *qname)
static HRESULT WINAPI	VBSAXAttributes_getIndexFromName (IVBSAXAttributes *iface, BSTR uri, BSTR name, int *index)
static HRESULT WINAPI	VBSAXAttributes_getIndexFromQName (IVBSAXAttributes *iface, BSTR qname, int *index)
static HRESULT WINAPI	VBSAXAttributes_getType (IVBSAXAttributes *iface, int index, BSTR *type)
static HRESULT WINAPI	VBSAXAttributes_getTypeFromName (IVBSAXAttributes *iface, BSTR uri, BSTR name, BSTR *type)
static HRESULT WINAPI	VBSAXAttributes_getTypeFromQName (IVBSAXAttributes *iface, BSTR qname, BSTR *type)
static HRESULT WINAPI	VBSAXAttributes_getValue (IVBSAXAttributes *iface, int index, BSTR *value)
static HRESULT WINAPI	VBSAXAttributes_getValueFromName (IVBSAXAttributes *iface, BSTR uri, BSTR name, BSTR *value)
static HRESULT WINAPI	VBSAXAttributes_getValueFromQName (IVBSAXAttributes *iface, BSTR qname, BSTR *value)
HRESULT	SAXAttributes_create (MSXML_VERSION version, void **ppObj)

Variables
static const WCHAR	emptyW [] = {0}
static const WCHAR	spaceW [] = {' '}
static const WCHAR	quotW [] = {'\"'}
static const WCHAR	closetagW [] = {'>','\r','\n'}
static const WCHAR	crlfW [] = {'\r','\n'}
static const WCHAR	entityW [] = {'<','!','E','N','T','I','T','Y',' '}
static const WCHAR	publicW [] = {'P','U','B','L','I','C',' '}
static const WCHAR	systemW [] = {'S','Y','S','T','E','M',' '}
static const WCHAR	iso_8859_1W [] = {'i','s','o','-','8','8','5','9','-','1',0}
static const WCHAR	iso_8859_2W [] = {'i','s','o','-','8','8','5','9','-','2',0}
static const WCHAR	iso_8859_3W [] = {'i','s','o','-','8','8','5','9','-','3',0}
static const WCHAR	iso_8859_4W [] = {'i','s','o','-','8','8','5','9','-','4',0}
static const WCHAR	iso_8859_5W [] = {'i','s','o','-','8','8','5','9','-','5',0}
static const WCHAR	iso_8859_7W [] = {'i','s','o','-','8','8','5','9','-','7',0}
static const WCHAR	iso_8859_9W [] = {'i','s','o','-','8','8','5','9','-','9',0}
static const WCHAR	iso_8859_13W [] = {'i','s','o','-','8','8','5','9','-','1','3',0}
static const WCHAR	iso_8859_15W [] = {'i','s','o','-','8','8','5','9','-','1','5',0}
static const WCHAR	utf16W [] = {'U','T','F','-','1','6',0}
static const WCHAR	utf8W [] = {'U','T','F','-','8',0}
static const WCHAR	windows_1250W [] = {'w','i','n','d','o','w','s','-','1','2','5','0',0}
static const WCHAR	windows_1251W [] = {'w','i','n','d','o','w','s','-','1','2','5','1',0}
static const WCHAR	windows_1252W [] = {'w','i','n','d','o','w','s','-','1','2','5','2',0}
static const WCHAR	windows_1253W [] = {'w','i','n','d','o','w','s','-','1','2','5','3',0}
static const WCHAR	windows_1254W [] = {'w','i','n','d','o','w','s','-','1','2','5','4',0}
static const WCHAR	windows_1255W [] = {'w','i','n','d','o','w','s','-','1','2','5','5',0}
static const WCHAR	windows_1256W [] = {'w','i','n','d','o','w','s','-','1','2','5','6',0}
static const WCHAR	windows_1257W [] = {'w','i','n','d','o','w','s','-','1','2','5','7',0}
static const WCHAR	windows_1258W [] = {'w','i','n','d','o','w','s','-','1','2','5','8',0}
static const struct xml_encoding_data	xml_encoding_map []
static const struct IMXWriterVtbl	MXWriterVtbl
static const struct ISAXContentHandlerVtbl	SAXContentHandlerVtbl
static const struct ISAXLexicalHandlerVtbl	SAXLexicalHandlerVtbl
static const ISAXDeclHandlerVtbl	SAXDeclHandlerVtbl
static const IVBSAXDeclHandlerVtbl	VBSAXDeclHandlerVtbl
static const IVBSAXLexicalHandlerVtbl	VBSAXLexicalHandlerVtbl
static const IVBSAXContentHandlerVtbl	VBSAXContentHandlerVtbl
static const ISAXDTDHandlerVtbl	SAXDTDHandlerVtbl
static const IVBSAXDTDHandlerVtbl	VBSAXDTDHandlerVtbl
static const ISAXErrorHandlerVtbl	SAXErrorHandlerVtbl
static const IVBSAXErrorHandlerVtbl	VBSAXErrorHandlerVtbl
static const tid_t	mxwriter_iface_tids []
static dispex_static_data_t	mxwriter_dispex
static const IMXAttributesVtbl	MXAttributesVtbl
static const ISAXAttributesVtbl	SAXAttributesVtbl
static const struct IVBSAXAttributesVtbl	VBSAXAttributesVtbl
static const tid_t	mxattrs_iface_tids []
static dispex_static_data_t	mxattrs_dispex

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file mxwriter.c.

Enumeration Type Documentation

escape_mode

enum escape_mode

Enumerator
EscapeValue
EscapeText

Definition at line 134 of file mxwriter.c.

{
    EscapeValue,
    EscapeText
} escape_mode;

mxwriter_prop

enum mxwriter_prop

Enumerator
MXWriter_BOM
MXWriter_DisableEscaping
MXWriter_Indent
MXWriter_OmitXmlDecl
MXWriter_Standalone
MXWriter_LastProp

Definition at line 124 of file mxwriter.c.

{
    MXWriter_BOM = 0,
    MXWriter_DisableEscaping,
    MXWriter_Indent,
    MXWriter_OmitXmlDecl,
    MXWriter_Standalone,
    MXWriter_LastProp
} mxwriter_prop;

xml_encoding

enum xml_encoding

Enumerator
XmlEncoding_ISO_8859_1
XmlEncoding_ISO_8859_13
XmlEncoding_ISO_8859_15
XmlEncoding_ISO_8859_2
XmlEncoding_ISO_8859_3
XmlEncoding_ISO_8859_4
XmlEncoding_ISO_8859_5
XmlEncoding_ISO_8859_7
XmlEncoding_ISO_8859_9
XmlEncoding_UTF16
XmlEncoding_UTF8
XmlEncoding_windows_1250
XmlEncoding_windows_1251
XmlEncoding_windows_1252
XmlEncoding_windows_1253
XmlEncoding_windows_1254
XmlEncoding_windows_1255
XmlEncoding_windows_1256
XmlEncoding_windows_1257
XmlEncoding_windows_1258
XmlEncoding_Unknown
XmlEncoding_USASCII
XmlEncoding_UTF16
XmlEncoding_UTF8
XmlEncoding_Unknown

Definition at line 48 of file mxwriter.c.

{
    XmlEncoding_ISO_8859_1 = 0,
    XmlEncoding_ISO_8859_13,
    XmlEncoding_ISO_8859_15,
    XmlEncoding_ISO_8859_2,
    XmlEncoding_ISO_8859_3,
    XmlEncoding_ISO_8859_4,
    XmlEncoding_ISO_8859_5,
    XmlEncoding_ISO_8859_7,
    XmlEncoding_ISO_8859_9,
    XmlEncoding_UTF16,
    XmlEncoding_UTF8,
    XmlEncoding_windows_1250,
    XmlEncoding_windows_1251,
    XmlEncoding_windows_1252,
    XmlEncoding_windows_1253,
    XmlEncoding_windows_1254,
    XmlEncoding_windows_1255,
    XmlEncoding_windows_1256,
    XmlEncoding_windows_1257,
    XmlEncoding_windows_1258,
    XmlEncoding_Unknown
} xml_encoding;

Function Documentation

close_element_starttag()

static void close_element_starttag ( mxwriter *  writer )

static

Definition at line 632 of file mxwriter.c.

{
    static const WCHAR gtW[] = {'>'};
    if (!writer->element) return;
    write_output_buffer(writer, gtW, 1);
}

Referenced by flush_output_buffer(), mxwriter_write_starttag(), SAXContentHandler_characters(), and SAXLexicalHandler_comment().

close_output_buffer()

static void close_output_buffer ( mxwriter *  writer )

static

Definition at line 482 of file mxwriter.c.

{
    encoded_buffer *cur, *cur2;
 
    free(writer->buffer.encoded.data);
 
    LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &writer->buffer.blocks, encoded_buffer, entry)
    {
        list_remove(&cur->entry);
        free_encoded_buffer(cur);
        free(cur);
    }
 
    init_encoded_buffer(&writer->buffer.encoded);
    get_code_page(writer->xml_enc, &writer->buffer.code_page);
    writer->buffer.utf16_total = 0;
    list_init(&writer->buffer.blocks);
}

Referenced by mxwriter_put_encoding(), mxwriter_put_output(), and SAXContentHandler_startDocument().

flush_output_buffer()

static HRESULT flush_output_buffer ( mxwriter *  This )

inlinestatic

Definition at line 683 of file mxwriter.c.

{
    close_element_starttag(This);
    set_element_name(This, NULL, 0);
    This->cdata = FALSE;
    return write_data_to_stream(This);
}

Referenced by flush_output_resources(), mxwriter_flush(), mxwriter_get_output(), mxwriter_put_encoding(), mxwriter_put_output(), mxwriter_Release(), save_all_changes(), and SAXContentHandler_endDocument().

free_encoded_buffer()

static void free_encoded_buffer ( encoded_buffer *  buffer )

static

Definition at line 282 of file mxwriter.c.

{
    free(buffer->data);
}

Referenced by close_output_buffer(), and free_output_buffer().

free_output_buffer()

static void free_output_buffer ( output_buffer *  buffer )

static

Definition at line 321 of file mxwriter.c.

{
    encoded_buffer *cur, *cur2;
 
    free_encoded_buffer(&buffer->encoded);
 
    LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &buffer->blocks, encoded_buffer, entry)
    {
        list_remove(&cur->entry);
        free_encoded_buffer(cur);
        free(cur);
    }
}

Referenced by mxwriter_Release().

get_attribute_byindex()

static mxattribute * get_attribute_byindex ( mxattributes *  attrs, int  index  )

static

Definition at line 2823 of file mxwriter.c.

{
    if (index < 0 || index >= attrs->length) return NULL;
    return &attrs->attr[index];
}

Referenced by MXAttributes_removeAttribute(), MXAttributes_setLocalName(), MXAttributes_setQName(), MXAttributes_setURI(), and MXAttributes_setValue().

get_code_page()

static HRESULT get_code_page ( xml_encoding  encoding, UINT *  cp  )

static

Definition at line 287 of file mxwriter.c.

{
    const struct xml_encoding_data *data;
 
    if (encoding == XmlEncoding_Unknown)
    {
        FIXME("unsupported encoding %d\n", encoding);
        return E_NOTIMPL;
    }
 
    data = &xml_encoding_map[encoding];
    *cp = data->cp;
 
    return S_OK;
}

Referenced by close_output_buffer(), and init_output_buffer().

get_escaped_string()

static WCHAR * get_escaped_string ( const WCHAR *  str, escape_mode  mode, int *  len  )

static

Definition at line 510 of file mxwriter.c.

{
    static const WCHAR ltW[]    = {'&','l','t',';'};
    static const WCHAR ampW[]   = {'&','a','m','p',';'};
    static const WCHAR equotW[] = {'&','q','u','o','t',';'};
    static const WCHAR gtW[]    = {'&','g','t',';'};
 
    const int default_alloc = 100;
    const int grow_thresh = 10;
    int p = *len, conv_len;
    WCHAR *ptr, *ret;
 
    /* default buffer size to something if length is unknown */
    conv_len = max(2**len, default_alloc);
    ptr = ret = malloc(conv_len * sizeof(WCHAR));
 
    while (p)
    {
        if (ptr - ret > conv_len - grow_thresh)
        {
            int written = ptr - ret;
            conv_len *= 2;
            ptr = ret = realloc(ret, conv_len * sizeof(WCHAR));
            ptr += written;
        }
 
        switch (*str)
        {
        case '<':
            memcpy(ptr, ltW, sizeof(ltW));
            ptr += ARRAY_SIZE(ltW);
            break;
        case '&':
            memcpy(ptr, ampW, sizeof(ampW));
            ptr += ARRAY_SIZE(ampW);
            break;
        case '>':
            memcpy(ptr, gtW, sizeof(gtW));
            ptr += ARRAY_SIZE(gtW);
            break;
        case '"':
            if (mode == EscapeValue)
            {
                memcpy(ptr, equotW, sizeof(equotW));
                ptr += ARRAY_SIZE(equotW);
                break;
            }
            /* fallthrough for text mode */
        default:
            *ptr++ = *str;
            break;
        }
 
        str++;
        p--;
    }
 
    *len = ptr-ret;
    *++ptr = 0;
 
    return ret;
}

Referenced by mxwriter_write_attribute(), and SAXContentHandler_characters().

impl_from_IMXAttributes()

static mxattributes * impl_from_IMXAttributes ( IMXAttributes *  iface )

inlinestatic

Definition at line 220 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxattributes, IMXAttributes_iface);
}

Referenced by MXAttributes_addAttribute(), MXAttributes_addAttributeFromIndex(), MXAttributes_AddRef(), MXAttributes_clear(), MXAttributes_GetIDsOfNames(), MXAttributes_GetTypeInfo(), MXAttributes_GetTypeInfoCount(), MXAttributes_Invoke(), MXAttributes_QueryInterface(), MXAttributes_Release(), MXAttributes_removeAttribute(), MXAttributes_setAttribute(), MXAttributes_setAttributes(), MXAttributes_setLocalName(), MXAttributes_setQName(), MXAttributes_setURI(), and MXAttributes_setValue().

impl_from_IMXWriter()

static mxwriter * impl_from_IMXWriter ( IMXWriter *  iface )

inlinestatic

Definition at line 705 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IMXWriter_iface);
}

Referenced by mxwriter_AddRef(), mxwriter_flush(), mxwriter_get_byteOrderMark(), mxwriter_get_disableOutputEscaping(), mxwriter_get_encoding(), mxwriter_get_indent(), mxwriter_get_omitXMLDeclaration(), mxwriter_get_output(), mxwriter_get_standalone(), mxwriter_get_version(), mxwriter_GetIDsOfNames(), mxwriter_GetTypeInfo(), mxwriter_GetTypeInfoCount(), mxwriter_Invoke(), mxwriter_put_byteOrderMark(), mxwriter_put_disableOutputEscaping(), mxwriter_put_encoding(), mxwriter_put_indent(), mxwriter_put_omitXMLDeclaration(), mxwriter_put_output(), mxwriter_put_standalone(), mxwriter_put_version(), mxwriter_QueryInterface(), and mxwriter_Release().

impl_from_ISAXAttributes()

static mxattributes * impl_from_ISAXAttributes ( ISAXAttributes *  iface )

inlinestatic

Definition at line 225 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxattributes, ISAXAttributes_iface);
}

Referenced by SAXAttributes_AddRef(), SAXAttributes_getIndexFromName(), SAXAttributes_getIndexFromQName(), SAXAttributes_getLength(), SAXAttributes_getLocalName(), SAXAttributes_getName(), SAXAttributes_getQName(), SAXAttributes_getType(), SAXAttributes_getTypeFromName(), SAXAttributes_getTypeFromQName(), SAXAttributes_getURI(), SAXAttributes_getValue(), SAXAttributes_getValueFromName(), SAXAttributes_getValueFromQName(), SAXAttributes_QueryInterface(), and SAXAttributes_Release().

impl_from_ISAXContentHandler()

static mxwriter * impl_from_ISAXContentHandler ( ISAXContentHandler *  iface )

inlinestatic

Definition at line 710 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, ISAXContentHandler_iface);
}

Referenced by SAXContentHandler_AddRef(), SAXContentHandler_characters(), SAXContentHandler_endDocument(), SAXContentHandler_endElement(), SAXContentHandler_endPrefixMapping(), SAXContentHandler_ignorableWhitespace(), SAXContentHandler_processingInstruction(), SAXContentHandler_putDocumentLocator(), SAXContentHandler_QueryInterface(), SAXContentHandler_Release(), SAXContentHandler_skippedEntity(), SAXContentHandler_startDocument(), SAXContentHandler_startElement(), and SAXContentHandler_startPrefixMapping().

impl_from_ISAXDeclHandler()

static mxwriter * impl_from_ISAXDeclHandler ( ISAXDeclHandler *  iface )

inlinestatic

Definition at line 730 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, ISAXDeclHandler_iface);
}

Referenced by SAXDeclHandler_AddRef(), SAXDeclHandler_attributeDecl(), SAXDeclHandler_elementDecl(), SAXDeclHandler_externalEntityDecl(), SAXDeclHandler_internalEntityDecl(), SAXDeclHandler_QueryInterface(), and SAXDeclHandler_Release().

impl_from_ISAXDTDHandler()

static mxwriter * impl_from_ISAXDTDHandler ( ISAXDTDHandler *  iface )

inlinestatic

Definition at line 740 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, ISAXDTDHandler_iface);
}

Referenced by SAXDTDHandler_AddRef(), SAXDTDHandler_notationDecl(), SAXDTDHandler_QueryInterface(), SAXDTDHandler_Release(), and SAXDTDHandler_unparsedEntityDecl().

impl_from_ISAXErrorHandler()

static mxwriter * impl_from_ISAXErrorHandler ( ISAXErrorHandler *  iface )

inlinestatic

Definition at line 750 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, ISAXErrorHandler_iface);
}

Referenced by SAXErrorHandler_AddRef(), SAXErrorHandler_QueryInterface(), and SAXErrorHandler_Release().

impl_from_ISAXLexicalHandler()

static mxwriter * impl_from_ISAXLexicalHandler ( ISAXLexicalHandler *  iface )

inlinestatic

Definition at line 720 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, ISAXLexicalHandler_iface);
}

Referenced by SAXLexicalHandler_AddRef(), SAXLexicalHandler_comment(), SAXLexicalHandler_endCDATA(), SAXLexicalHandler_endDTD(), SAXLexicalHandler_endEntity(), SAXLexicalHandler_QueryInterface(), SAXLexicalHandler_Release(), SAXLexicalHandler_startCDATA(), SAXLexicalHandler_startDTD(), and SAXLexicalHandler_startEntity().

impl_from_IVBSAXAttributes()

static mxattributes * impl_from_IVBSAXAttributes ( IVBSAXAttributes *  iface )

inlinestatic

Definition at line 230 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxattributes, IVBSAXAttributes_iface);
}

Referenced by VBSAXAttributes_AddRef(), VBSAXAttributes_get_length(), VBSAXAttributes_getIndexFromName(), VBSAXAttributes_getIndexFromQName(), VBSAXAttributes_getLocalName(), VBSAXAttributes_getQName(), VBSAXAttributes_getType(), VBSAXAttributes_getTypeFromName(), VBSAXAttributes_getTypeFromQName(), VBSAXAttributes_GetTypeInfoCount(), VBSAXAttributes_getURI(), VBSAXAttributes_getValue(), VBSAXAttributes_getValueFromName(), VBSAXAttributes_getValueFromQName(), VBSAXAttributes_QueryInterface(), and VBSAXAttributes_Release().

impl_from_IVBSAXContentHandler()

static mxwriter * impl_from_IVBSAXContentHandler ( IVBSAXContentHandler *  iface )

inlinestatic

Definition at line 715 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IVBSAXContentHandler_iface);
}

Referenced by VBSAXContentHandler_AddRef(), VBSAXContentHandler_characters(), VBSAXContentHandler_endDocument(), VBSAXContentHandler_endElement(), VBSAXContentHandler_endPrefixMapping(), VBSAXContentHandler_GetIDsOfNames(), VBSAXContentHandler_GetTypeInfo(), VBSAXContentHandler_GetTypeInfoCount(), VBSAXContentHandler_ignorableWhitespace(), VBSAXContentHandler_Invoke(), VBSAXContentHandler_processingInstruction(), VBSAXContentHandler_putref_documentLocator(), VBSAXContentHandler_QueryInterface(), VBSAXContentHandler_Release(), VBSAXContentHandler_skippedEntity(), VBSAXContentHandler_startDocument(), VBSAXContentHandler_startElement(), and VBSAXContentHandler_startPrefixMapping().

impl_from_IVBSAXDeclHandler()

static mxwriter * impl_from_IVBSAXDeclHandler ( IVBSAXDeclHandler *  iface )

inlinestatic

Definition at line 735 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IVBSAXDeclHandler_iface);
}

Referenced by VBSAXDeclHandler_AddRef(), VBSAXDeclHandler_attributeDecl(), VBSAXDeclHandler_elementDecl(), VBSAXDeclHandler_externalEntityDecl(), VBSAXDeclHandler_GetIDsOfNames(), VBSAXDeclHandler_GetTypeInfo(), VBSAXDeclHandler_GetTypeInfoCount(), VBSAXDeclHandler_internalEntityDecl(), VBSAXDeclHandler_Invoke(), VBSAXDeclHandler_QueryInterface(), and VBSAXDeclHandler_Release().

impl_from_IVBSAXDTDHandler()

static mxwriter * impl_from_IVBSAXDTDHandler ( IVBSAXDTDHandler *  iface )

inlinestatic

Definition at line 745 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IVBSAXDTDHandler_iface);
}

Referenced by VBSAXDTDHandler_AddRef(), VBSAXDTDHandler_GetIDsOfNames(), VBSAXDTDHandler_GetTypeInfo(), VBSAXDTDHandler_GetTypeInfoCount(), VBSAXDTDHandler_Invoke(), VBSAXDTDHandler_notationDecl(), VBSAXDTDHandler_QueryInterface(), VBSAXDTDHandler_Release(), and VBSAXDTDHandler_unparsedEntityDecl().

impl_from_IVBSAXErrorHandler()

static mxwriter * impl_from_IVBSAXErrorHandler ( IVBSAXErrorHandler *  iface )

inlinestatic

Definition at line 755 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IVBSAXErrorHandler_iface);
}

Referenced by VBSAXErrorHandler_AddRef(), VBSAXErrorHandler_GetIDsOfNames(), VBSAXErrorHandler_GetTypeInfo(), VBSAXErrorHandler_GetTypeInfoCount(), VBSAXErrorHandler_Invoke(), VBSAXErrorHandler_QueryInterface(), and VBSAXErrorHandler_Release().

impl_from_IVBSAXLexicalHandler()

static mxwriter * impl_from_IVBSAXLexicalHandler ( IVBSAXLexicalHandler *  iface )

inlinestatic

Definition at line 725 of file mxwriter.c.

{
    return CONTAINING_RECORD(iface, mxwriter, IVBSAXLexicalHandler_iface);
}

Referenced by VBSAXLexicalHandler_AddRef(), VBSAXLexicalHandler_comment(), VBSAXLexicalHandler_endCDATA(), VBSAXLexicalHandler_endDTD(), VBSAXLexicalHandler_endEntity(), VBSAXLexicalHandler_GetIDsOfNames(), VBSAXLexicalHandler_GetTypeInfo(), VBSAXLexicalHandler_GetTypeInfoCount(), VBSAXLexicalHandler_Invoke(), VBSAXLexicalHandler_QueryInterface(), VBSAXLexicalHandler_Release(), VBSAXLexicalHandler_startCDATA(), VBSAXLexicalHandler_startDTD(), and VBSAXLexicalHandler_startEntity().

init_encoded_buffer()

static HRESULT init_encoded_buffer ( encoded_buffer *  buffer )

static

Definition at line 269 of file mxwriter.c.

{
    const int initial_len = 0x1000;
    buffer->data = malloc(initial_len);
    if (!buffer->data) return E_OUTOFMEMORY;
 
    memset(buffer->data, 0, 4);
    buffer->allocated = initial_len;
    buffer->written = 0;
 
    return S_OK;
}

Referenced by close_output_buffer(), init_output_buffer(), and write_output_buffer().

init_output_buffer()

static HRESULT init_output_buffer ( xml_encoding  encoding, output_buffer *  buffer  )

static

Definition at line 303 of file mxwriter.c.

{
    HRESULT hr;
 
    hr = get_code_page(encoding, &buffer->code_page);
    if (hr != S_OK)
        return hr;
 
    hr = init_encoded_buffer(&buffer->encoded);
    if (hr != S_OK)
        return hr;
 
    list_init(&buffer->blocks);
    buffer->utf16_total = 0;
 
    return S_OK;
}

MXAttributes_addAttribute()

static HRESULT WINAPI MXAttributes_addAttribute ( IMXAttributes *  iface, BSTR  uri, BSTR  localName, BSTR  QName, BSTR  type, BSTR  value  )

static

Definition at line 2764 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *attr;
    HRESULT hr;
 
    TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(uri), debugstr_w(localName),
        debugstr_w(QName), debugstr_w(type), debugstr_w(value));
 
    if ((!uri || !localName || !QName || !type || !value) && This->class_version != MSXML6)
        return E_INVALIDARG;
 
    /* ensure array is large enough */
    hr = mxattributes_grow(This);
    if (hr != S_OK) return hr;
 
    attr = &This->attr[This->length];
 
    attr->qname = SysAllocString(QName);
    attr->local = SysAllocString(localName);
    attr->uri   = SysAllocString(uri);
    attr->type  = SysAllocString(type ? type : emptyW);
    attr->value = SysAllocString(value);
    This->length++;
 
    return S_OK;
}

MXAttributes_addAttributeFromIndex()

static HRESULT WINAPI MXAttributes_addAttributeFromIndex ( IMXAttributes *  iface, VARIANT  atts, int  index  )

static

Definition at line 2793 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    FIXME("(%p)->(%s %d): stub\n", This, debugstr_variant(&atts), index);
    return E_NOTIMPL;
}

MXAttributes_AddRef()

static ULONG WINAPI MXAttributes_AddRef ( IMXAttributes *  iface )

static

Definition at line 2688 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    ULONG ref = InterlockedIncrement( &This->ref );
    TRACE("%p, refcount %lu.\n", iface, ref );
    return ref;
}

MXAttributes_clear()

static HRESULT WINAPI MXAttributes_clear ( IMXAttributes *  iface )

static

Definition at line 2801 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    int i;
 
    TRACE("(%p)\n", This);
 
    for (i = 0; i < This->length; i++)
    {
        SysFreeString(This->attr[i].qname);
        SysFreeString(This->attr[i].local);
        SysFreeString(This->attr[i].uri);
        SysFreeString(This->attr[i].type);
        SysFreeString(This->attr[i].value);
        memset(&This->attr[i], 0, sizeof(mxattribute));
    }
 
    This->length = 0;
 
    return S_OK;
}

MXAttributes_GetIDsOfNames()

static HRESULT WINAPI MXAttributes_GetIDsOfNames ( IMXAttributes *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2735 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
        riid, rgszNames, cNames, lcid, rgDispId);
}

MXAttributes_GetTypeInfo()

static HRESULT WINAPI MXAttributes_GetTypeInfo ( IMXAttributes *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2729 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}

MXAttributes_GetTypeInfoCount()

static HRESULT WINAPI MXAttributes_GetTypeInfoCount ( IMXAttributes *  iface, UINT *  pctinfo  )

static

Definition at line 2723 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
}

mxattributes_grow()

static HRESULT mxattributes_grow ( mxattributes *  This )

static

Definition at line 235 of file mxwriter.c.

{
    if (This->length < This->allocated) return S_OK;
 
    This->allocated *= 2;
    This->attr = realloc(This->attr, This->allocated * sizeof(mxattribute));
 
    return This->attr ? S_OK : E_OUTOFMEMORY;
}

Referenced by MXAttributes_addAttribute().

MXAttributes_Invoke()

static HRESULT WINAPI MXAttributes_Invoke ( IMXAttributes *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2748 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
        dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}

MXAttributes_QueryInterface()

static HRESULT WINAPI MXAttributes_QueryInterface ( IMXAttributes *  iface, REFIID  riid, void **  ppObj  )

static

Definition at line 2651 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppObj);
 
    *ppObj = NULL;
 
    if ( IsEqualGUID( riid, &IID_IUnknown )  ||
         IsEqualGUID( riid, &IID_IDispatch ) ||
         IsEqualGUID( riid, &IID_IMXAttributes ))
    {
        *ppObj = iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXAttributes ))
    {
        *ppObj = &This->ISAXAttributes_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXAttributes ))
    {
        *ppObj = &This->IVBSAXAttributes_iface;
    }
    else if (dispex_query_interface(&This->dispex, riid, ppObj))
    {
        return *ppObj ? S_OK : E_NOINTERFACE;
    }
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    IMXAttributes_AddRef( iface );
 
    return S_OK;
}

MXAttributes_Release()

static ULONG WINAPI MXAttributes_Release ( IMXAttributes *  iface )

static

Definition at line 2696 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    ULONG ref = InterlockedDecrement( &This->ref );
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    if (!ref)
    {
        int i;
 
        for (i = 0; i < This->length; i++)
        {
            SysFreeString(This->attr[i].qname);
            SysFreeString(This->attr[i].local);
            SysFreeString(This->attr[i].uri);
            SysFreeString(This->attr[i].type);
            SysFreeString(This->attr[i].value);
        }
 
        free(This->attr);
        free(This);
    }
 
    return ref;
}

MXAttributes_removeAttribute()

static HRESULT WINAPI MXAttributes_removeAttribute ( IMXAttributes *  iface, int  index  )

static

Definition at line 2829 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *dst;
 
    TRACE("(%p)->(%d)\n", This, index);
 
    if (!(dst = get_attribute_byindex(This, index))) return E_INVALIDARG;
 
    /* no need to remove last attribute, just make it inaccessible */
    if (index + 1 == This->length)
    {
        This->length--;
        return S_OK;
    }
 
    memmove(dst, dst + 1, (This->length-index-1)*sizeof(*dst));
    This->length--;
 
    return S_OK;
}

MXAttributes_setAttribute()

static HRESULT WINAPI MXAttributes_setAttribute ( IMXAttributes *  iface, int  index, BSTR  uri, BSTR  localName, BSTR  QName, BSTR  type, BSTR  value  )

static

Definition at line 2851 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    FIXME("(%p)->(%d %s %s %s %s %s): stub\n", This, index, debugstr_w(uri),
        debugstr_w(localName), debugstr_w(QName), debugstr_w(type), debugstr_w(value));
    return E_NOTIMPL;
}

MXAttributes_setAttributes()

static HRESULT WINAPI MXAttributes_setAttributes ( IMXAttributes *  iface, VARIANT  atts  )

static

Definition at line 2860 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&atts));
    return E_NOTIMPL;
}

MXAttributes_setLocalName()

static HRESULT WINAPI MXAttributes_setLocalName ( IMXAttributes *  iface, int  index, BSTR  localName  )

static

Definition at line 2867 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *attr;
 
    TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(localName));
 
    if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
 
    SysFreeString(attr->local);
    attr->local = SysAllocString(localName);
 
    return S_OK;
}

MXAttributes_setQName()

static HRESULT WINAPI MXAttributes_setQName ( IMXAttributes *  iface, int  index, BSTR  QName  )

static

Definition at line 2883 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *attr;
 
    TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(QName));
 
    if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
 
    SysFreeString(attr->qname);
    attr->qname = SysAllocString(QName);
 
    return S_OK;
}

MXAttributes_setURI()

static HRESULT WINAPI MXAttributes_setURI ( IMXAttributes *  iface, int  index, BSTR  uri  )

static

Definition at line 2898 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *attr;
 
    TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(uri));
 
    if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
 
    SysFreeString(attr->uri);
    attr->uri = SysAllocString(uri);
 
    return S_OK;
}

MXAttributes_setValue()

static HRESULT WINAPI MXAttributes_setValue ( IMXAttributes *  iface, int  index, BSTR  value  )

static

Definition at line 2913 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    mxattribute *attr;
 
    TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(value));
 
    if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
 
    SysFreeString(attr->value);
    attr->value = SysAllocString(value);
 
    return S_OK;
}

mxwriter_AddRef()

static ULONG WINAPI mxwriter_AddRef ( IMXWriter *  iface )

static

Definition at line 829 of file mxwriter.c.

{
    mxwriter *writer = impl_from_IMXWriter(iface);
    LONG ref = InterlockedIncrement(&writer->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    return ref;
}

MXWriter_create()

HRESULT MXWriter_create	(	MSXML_VERSION	version,
		void **	ppObj
	)

Definition at line 2590 of file mxwriter.c.

{
    static const WCHAR version10W[] = {'1','.','0',0};
    mxwriter *This;
    HRESULT hr;
 
    TRACE("(%p)\n", ppObj);
 
    This = malloc(sizeof(*This));
    if(!This)
        return E_OUTOFMEMORY;
 
    This->IMXWriter_iface.lpVtbl = &MXWriterVtbl;
    This->ISAXContentHandler_iface.lpVtbl = &SAXContentHandlerVtbl;
    This->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
    This->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
    This->ISAXDTDHandler_iface.lpVtbl = &SAXDTDHandlerVtbl;
    This->ISAXErrorHandler_iface.lpVtbl = &SAXErrorHandlerVtbl;
    This->IVBSAXDeclHandler_iface.lpVtbl = &VBSAXDeclHandlerVtbl;
    This->IVBSAXLexicalHandler_iface.lpVtbl = &VBSAXLexicalHandlerVtbl;
    This->IVBSAXContentHandler_iface.lpVtbl = &VBSAXContentHandlerVtbl;
    This->IVBSAXDTDHandler_iface.lpVtbl = &VBSAXDTDHandlerVtbl;
    This->IVBSAXErrorHandler_iface.lpVtbl = &VBSAXErrorHandlerVtbl;
    This->ref = 1;
    This->class_version = version;
 
    This->props[MXWriter_BOM] = VARIANT_TRUE;
    This->props[MXWriter_DisableEscaping] = VARIANT_FALSE;
    This->props[MXWriter_Indent] = VARIANT_FALSE;
    This->props[MXWriter_OmitXmlDecl] = VARIANT_FALSE;
    This->props[MXWriter_Standalone] = VARIANT_FALSE;
    This->prop_changed = FALSE;
    This->encoding = SysAllocString(utf16W);
    This->version  = SysAllocString(version10W);
    This->xml_enc  = XmlEncoding_UTF16;
 
    This->element = NULL;
    This->cdata = FALSE;
    This->indent = 0;
    This->text = FALSE;
    This->newline = FALSE;
 
    This->dest = NULL;
 
    hr = init_output_buffer(This->xml_enc, &This->buffer);
    if (hr != S_OK) {
        SysFreeString(This->encoding);
        SysFreeString(This->version);
        free(This);
        return hr;
    }
 
    init_dispex(&This->dispex, (IUnknown*)&This->IMXWriter_iface, &mxwriter_dispex);
 
    *ppObj = &This->IMXWriter_iface;
 
    TRACE("returning iface %p\n", *ppObj);
 
    return S_OK;
}

Referenced by DllGetClassObject().

mxwriter_flush()

static HRESULT WINAPI mxwriter_flush ( IMXWriter *  iface )

static

Definition at line 1141 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    TRACE("(%p)\n", This);
    return flush_output_buffer(This);
}

mxwriter_get_byteOrderMark()

static HRESULT WINAPI mxwriter_get_byteOrderMark ( IMXWriter *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1044 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
    return writer_get_property(This, MXWriter_BOM, value);
}

mxwriter_get_disableOutputEscaping()

static HRESULT WINAPI mxwriter_get_disableOutputEscaping ( IMXWriter *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1133 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
    return writer_get_property(This, MXWriter_DisableEscaping, value);
}

mxwriter_get_encoding()

static HRESULT WINAPI mxwriter_get_encoding ( IMXWriter *  iface, BSTR *  encoding  )

static

Definition at line 1022 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, encoding);
 
    if (!encoding) return E_POINTER;
 
    *encoding = SysAllocString(This->encoding);
    if (!*encoding) return E_OUTOFMEMORY;
 
    return S_OK;
}

mxwriter_get_indent()

static HRESULT WINAPI mxwriter_get_indent ( IMXWriter *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1060 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
    return writer_get_property(This, MXWriter_Indent, value);
}

mxwriter_get_omitXMLDeclaration()

static HRESULT WINAPI mxwriter_get_omitXMLDeclaration ( IMXWriter *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1092 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
    return writer_get_property(This, MXWriter_OmitXmlDecl, value);
}

mxwriter_get_output()

static HRESULT WINAPI mxwriter_get_output ( IMXWriter *  iface, VARIANT *  dest  )

static

Definition at line 946 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, dest);
 
    if (!dest) return E_POINTER;
 
    if (This->dest)
    {
        /* we only support IStream output so far */
        V_VT(dest) = VT_UNKNOWN;
        V_UNKNOWN(dest) = (IUnknown*)This->dest;
        IStream_AddRef(This->dest);
    }
    else
    {
        encoded_buffer *buff;
        char *dest_ptr;
        HRESULT hr;
 
        hr = flush_output_buffer(This);
        if (FAILED(hr))
            return hr;
 
        V_VT(dest)   = VT_BSTR;
        V_BSTR(dest) = SysAllocStringLen(NULL, This->buffer.utf16_total / sizeof(WCHAR));
        if (!V_BSTR(dest))
            return E_OUTOFMEMORY;
 
        dest_ptr = (char*)V_BSTR(dest);
        buff = &This->buffer.encoded;
 
        if (buff->written)
        {
            memcpy(dest_ptr, buff->data, buff->written);
            dest_ptr += buff->written;
        }
 
        LIST_FOR_EACH_ENTRY(buff, &This->buffer.blocks, encoded_buffer, entry)
        {
            memcpy(dest_ptr, buff->data, buff->written);
            dest_ptr += buff->written;
        }
    }
 
    return S_OK;
}

mxwriter_get_standalone()

static HRESULT WINAPI mxwriter_get_standalone ( IMXWriter *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1076 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
    return writer_get_property(This, MXWriter_Standalone, value);
}

mxwriter_get_version()

static HRESULT WINAPI mxwriter_get_version ( IMXWriter *  iface, BSTR *  version  )

static

Definition at line 1114 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%p)\n", This, version);
 
    if (!version) return E_POINTER;
 
    return return_bstr(This->version, version);
}

mxwriter_GetIDsOfNames()

static HRESULT WINAPI mxwriter_GetIDsOfNames ( IMXWriter *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 879 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
        riid, rgszNames, cNames, lcid, rgDispId);
}

mxwriter_GetTypeInfo()

static HRESULT WINAPI mxwriter_GetTypeInfo ( IMXWriter *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 869 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
        iTInfo, lcid, ppTInfo);
}

mxwriter_GetTypeInfoCount()

static HRESULT WINAPI mxwriter_GetTypeInfoCount ( IMXWriter *  iface, UINT *  pctinfo  )

static

Definition at line 863 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
}

mxwriter_Invoke()

static HRESULT WINAPI mxwriter_Invoke ( IMXWriter *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 889 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
        dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}

mxwriter_put_byteOrderMark()

static HRESULT WINAPI mxwriter_put_byteOrderMark ( IMXWriter *  iface, VARIANT_BOOL  value  )

static

Definition at line 1036 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%d)\n", This, value);
    return writer_set_property(This, MXWriter_BOM, value);
}

mxwriter_put_disableOutputEscaping()

static HRESULT WINAPI mxwriter_put_disableOutputEscaping ( IMXWriter *  iface, VARIANT_BOOL  value  )

static

Definition at line 1125 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%d)\n", This, value);
    return writer_set_property(This, MXWriter_DisableEscaping, value);
}

mxwriter_put_encoding()

static HRESULT WINAPI mxwriter_put_encoding ( IMXWriter *  iface, BSTR  encoding  )

static

Definition at line 995 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    xml_encoding enc;
    HRESULT hr;
 
    TRACE("(%p)->(%s)\n", This, debugstr_w(encoding));
 
    enc = parse_encoding_name(encoding);
    if (enc == XmlEncoding_Unknown)
    {
        FIXME("unsupported encoding %s\n", debugstr_w(encoding));
        return E_INVALIDARG;
    }
 
    hr = flush_output_buffer(This);
    if (FAILED(hr))
        return hr;
 
    SysReAllocString(&This->encoding, encoding);
    This->xml_enc = enc;
 
    TRACE("got encoding %d\n", This->xml_enc);
    close_output_buffer(This);
    return S_OK;
}

mxwriter_put_indent()

static HRESULT WINAPI mxwriter_put_indent ( IMXWriter *  iface, VARIANT_BOOL  value  )

static

Definition at line 1052 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%d)\n", This, value);
    return writer_set_property(This, MXWriter_Indent, value);
}

mxwriter_put_omitXMLDeclaration()

static HRESULT WINAPI mxwriter_put_omitXMLDeclaration ( IMXWriter *  iface, VARIANT_BOOL  value  )

static

Definition at line 1084 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%d)\n", This, value);
    return writer_set_property(This, MXWriter_OmitXmlDecl, value);
}

mxwriter_put_output()

static HRESULT WINAPI mxwriter_put_output ( IMXWriter *  iface, VARIANT  dest  )

static

Definition at line 900 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    HRESULT hr;
 
    TRACE("(%p)->(%s)\n", This, debugstr_variant(&dest));
 
    hr = flush_output_buffer(This);
    if (FAILED(hr))
        return hr;
 
    switch (V_VT(&dest))
    {
    case VT_EMPTY:
    {
        if (This->dest) IStream_Release(This->dest);
        This->dest = NULL;
        close_output_buffer(This);
        break;
    }
    case VT_UNKNOWN:
    {
        IStream *stream;
 
        hr = IUnknown_QueryInterface(V_UNKNOWN(&dest), &IID_IStream, (void**)&stream);
        if (hr == S_OK)
        {
            /* Recreate the output buffer to make sure it's using the correct encoding. */
            close_output_buffer(This);
 
            if (This->dest) IStream_Release(This->dest);
            This->dest = stream;
            break;
        }
 
        FIXME("unhandled interface type for VT_UNKNOWN destination\n");
        return E_NOTIMPL;
    }
    default:
        FIXME("unhandled destination type %s\n", debugstr_variant(&dest));
        return E_NOTIMPL;
    }
 
    return S_OK;
}

mxwriter_put_standalone()

static HRESULT WINAPI mxwriter_put_standalone ( IMXWriter *  iface, VARIANT_BOOL  value  )

static

Definition at line 1068 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%d)\n", This, value);
    return writer_set_property(This, MXWriter_Standalone, value);
}

mxwriter_put_version()

static HRESULT WINAPI mxwriter_put_version ( IMXWriter *  iface, BSTR  version  )

static

Definition at line 1100 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%s)\n", This, debugstr_w(version));
 
    if (!version) return E_INVALIDARG;
 
    SysFreeString(This->version);
    This->version = SysAllocString(version);
 
    return S_OK;
}

mxwriter_QueryInterface()

static HRESULT WINAPI mxwriter_QueryInterface ( IMXWriter *  iface, REFIID  riid, void **  obj  )

static

Definition at line 760 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if ( IsEqualGUID( riid, &IID_IMXWriter ) ||
         IsEqualGUID( riid, &IID_IDispatch ) ||
         IsEqualGUID( riid, &IID_IUnknown ) )
    {
        *obj = &This->IMXWriter_iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXContentHandler ) )
    {
        *obj = &This->ISAXContentHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXLexicalHandler ) )
    {
        *obj = &This->ISAXLexicalHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXDeclHandler ) )
    {
        *obj = &This->ISAXDeclHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXDTDHandler ) )
    {
        *obj = &This->ISAXDTDHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_ISAXErrorHandler ) )
    {
        *obj = &This->ISAXErrorHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXDeclHandler ) )
    {
        *obj = &This->IVBSAXDeclHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXLexicalHandler ) )
    {
        *obj = &This->IVBSAXLexicalHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXContentHandler ) )
    {
        *obj = &This->IVBSAXContentHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXDTDHandler ) )
    {
        *obj = &This->IVBSAXDTDHandler_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IVBSAXErrorHandler ) )
    {
        *obj = &This->IVBSAXErrorHandler_iface;
    }
    else if (dispex_query_interface(&This->dispex, riid, obj))
    {
        return *obj ? S_OK : E_NOINTERFACE;
    }
    else
    {
        ERR("interface %s not implemented\n", debugstr_guid(riid));
        *obj = NULL;
        return E_NOINTERFACE;
    }
 
    IMXWriter_AddRef(iface);
    return S_OK;
}

mxwriter_Release()

static ULONG WINAPI mxwriter_Release ( IMXWriter *  iface )

static

Definition at line 839 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    if (!ref)
    {
        /* Windows flushes the buffer when the interface is destroyed. */
        flush_output_buffer(This);
        free_output_buffer(&This->buffer);
 
        if (This->dest) IStream_Release(This->dest);
        SysFreeString(This->version);
        SysFreeString(This->encoding);
 
        SysFreeString(This->element);
        free(This);
    }
 
    return ref;
}

mxwriter_write_attribute()

static void mxwriter_write_attribute ( mxwriter *  writer, const WCHAR *  qname, int  qname_len, const WCHAR *  value, int  value_len, BOOL  escape  )

static

Definition at line 1270 of file mxwriter.c.

{
    static const WCHAR eqW[] = {'='};
 
    /* space separator in front of every attribute */
    write_output_buffer(writer, spaceW, 1);
    write_output_buffer(writer, qname, qname_len);
    write_output_buffer(writer, eqW, 1);
 
    if (escape)
    {
        WCHAR *escaped = get_escaped_string(value, EscapeValue, &value_len);
        write_output_buffer_quoted(writer, escaped, value_len);
        free(escaped);
    }
    else
        write_output_buffer_quoted(writer, value, value_len);
}

Referenced by SAXContentHandler_startElement(), and VBSAXContentHandler_startElement().

mxwriter_write_starttag()

static void mxwriter_write_starttag ( mxwriter *  writer, const WCHAR *  qname, int  len  )

static

Definition at line 1290 of file mxwriter.c.

{
    static const WCHAR ltW[] = {'<'};
 
    close_element_starttag(writer);
    set_element_name(writer, qname ? qname : emptyW, qname ? len : 0);
 
    write_node_indent(writer);
 
    write_output_buffer(writer, ltW, 1);
    write_output_buffer(writer, qname ? qname : emptyW, qname ? len : 0);
    writer_inc_indent(writer);
}

Referenced by SAXContentHandler_startElement(), and VBSAXContentHandler_startElement().

parse_encoding_name()

static xml_encoding parse_encoding_name ( const WCHAR *  encoding )

static

Definition at line 245 of file mxwriter.c.

{
    int min, max, n, c;
 
    min = 0;
    max = ARRAY_SIZE(xml_encoding_map) - 1;
 
    while (min <= max)
    {
        n = (min+max)/2;
 
        c = lstrcmpiW(xml_encoding_map[n].encoding, encoding);
        if (!c)
            return xml_encoding_map[n].enc;
 
        if (c > 0)
            max = n-1;
        else
            min = n+1;
    }
 
    return XmlEncoding_Unknown;
}

Referenced by CreateXmlWriterOutputWithEncodingName(), and mxwriter_put_encoding().

SAXAttributes_AddRef()

static ULONG WINAPI SAXAttributes_AddRef ( ISAXAttributes *  iface )

static

Definition at line 2954 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    return IMXAttributes_AddRef(&This->IMXAttributes_iface);
}

SAXAttributes_create()

HRESULT SAXAttributes_create	(	MSXML_VERSION	version,
		void **	ppObj
	)

Definition at line 3555 of file mxwriter.c.

{
    static const int default_count = 10;
    mxattributes *This;
 
    TRACE("(%p)\n", ppObj);
 
    This = malloc(sizeof(*This));
    if( !This )
        return E_OUTOFMEMORY;
 
    This->IMXAttributes_iface.lpVtbl = &MXAttributesVtbl;
    This->ISAXAttributes_iface.lpVtbl = &SAXAttributesVtbl;
    This->IVBSAXAttributes_iface.lpVtbl = &VBSAXAttributesVtbl;
    This->ref = 1;
 
    This->class_version = version;
 
    This->attr = malloc(default_count * sizeof(mxattribute));
    This->length = 0;
    This->allocated = default_count;
 
    *ppObj = &This->IMXAttributes_iface;
 
    init_dispex(&This->dispex, (IUnknown*)&This->IMXAttributes_iface, &mxattrs_dispex);
 
    TRACE("returning iface %p\n", *ppObj);
 
    return S_OK;
}

Referenced by DllGetClassObject().

SAXAttributes_getIndexFromName()

static HRESULT WINAPI SAXAttributes_getIndexFromName ( ISAXAttributes *  iface, const WCHAR *  uri, int  uri_len, const WCHAR *  name, int  len, int *  index  )

static

Definition at line 3053 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    int i;
 
    TRACE("(%p)->(%s:%d %s:%d %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
        debugstr_wn(name, len), len, index);
 
    if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
        return E_POINTER;
 
    if (!uri || !name || !index) return E_INVALIDARG;
 
    for (i = 0; i < This->length; i++)
    {
        if (uri_len != SysStringLen(This->attr[i].uri)) continue;
        if (wcsncmp(uri, This->attr[i].uri, uri_len)) continue;
 
        if (len != SysStringLen(This->attr[i].local)) continue;
        if (wcsncmp(name, This->attr[i].local, len)) continue;
 
        *index = i;
        return S_OK;
    }
 
    return E_INVALIDARG;
}

SAXAttributes_getIndexFromQName()

static HRESULT WINAPI SAXAttributes_getIndexFromQName ( ISAXAttributes *  iface, const WCHAR *  qname, int  len, int *  index  )

static

Definition at line 3082 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    int i;
 
    TRACE("(%p)->(%s:%d %p)\n", This, debugstr_wn(qname, len), len, index);
 
    if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
        return E_POINTER;
 
    if (!qname || !index || !len) return E_INVALIDARG;
 
    for (i = 0; i < This->length; i++)
    {
        if (len != SysStringLen(This->attr[i].qname)) continue;
        if (wcsncmp(qname, This->attr[i].qname, len)) continue;
 
        *index = i;
        return S_OK;
    }
 
    return E_INVALIDARG;
}

SAXAttributes_getLength()

static HRESULT WINAPI SAXAttributes_getLength ( ISAXAttributes *  iface, int *  length  )

static

Definition at line 2966 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    TRACE("(%p)->(%p)\n", This, length);
 
    if (!length && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
       return E_POINTER;
 
    *length = This->length;
 
    return S_OK;
}

SAXAttributes_getLocalName()

static HRESULT WINAPI SAXAttributes_getLocalName ( ISAXAttributes *  iface, int  index, const WCHAR **  name, int *  len  )

static

Definition at line 2995 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p)\n", This, index, name, len);
 
    if (index >= This->length || index < 0) return E_INVALIDARG;
    if (!name || !len) return E_POINTER;
 
    *len = SysStringLen(This->attr[index].local);
    *name = This->attr[index].local;
 
    return S_OK;
}

SAXAttributes_getName()

static HRESULT WINAPI SAXAttributes_getName ( ISAXAttributes *  iface, int  index, const WCHAR **  uri, int *  uri_len, const WCHAR **  local, int *  local_len, const WCHAR **  qname, int *  qname_len  )

static

Definition at line 3026 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p %p %p %p %p)\n", This, index, uri, uri_len, local, local_len, qname, qname_len);
 
    if (index >= This->length || index < 0)
        return E_INVALIDARG;
 
    if (!uri || !uri_len || !local || !local_len || !qname || !qname_len)
        return E_POINTER;
 
    *uri_len = SysStringLen(This->attr[index].uri);
    *uri = This->attr[index].uri;
 
    *local_len = SysStringLen(This->attr[index].local);
    *local = This->attr[index].local;
 
    *qname_len = SysStringLen(This->attr[index].qname);
    *qname = This->attr[index].qname;
 
    TRACE("(%s, %s, %s)\n", debugstr_w(*uri), debugstr_w(*local), debugstr_w(*qname));
 
    return S_OK;
}

SAXAttributes_getQName()

static HRESULT WINAPI SAXAttributes_getQName ( ISAXAttributes *  iface, int  index, const WCHAR **  qname, int *  length  )

static

Definition at line 3011 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p)\n", This, index, qname, length);
 
    if (index >= This->length) return E_INVALIDARG;
    if (!qname || !length) return E_POINTER;
 
    *qname = This->attr[index].qname;
    *length = SysStringLen(This->attr[index].qname);
 
    return S_OK;
}

SAXAttributes_getType()

static HRESULT WINAPI SAXAttributes_getType ( ISAXAttributes *  iface, int  index, const WCHAR **  type, int *  len  )

static

Definition at line 3107 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p)\n", This, index, type, len);
 
    if (index >= This->length) return E_INVALIDARG;
 
    if ((!type || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
       return E_POINTER;
 
    *type = This->attr[index].type;
    *len = SysStringLen(This->attr[index].type);
 
    return S_OK;
}

SAXAttributes_getTypeFromName()

static HRESULT WINAPI SAXAttributes_getTypeFromName ( ISAXAttributes *  iface, const WCHAR *  pUri, int  nUri, const WCHAR *  pLocalName, int  nLocalName, const WCHAR **  pType, int *  nType  )

static

Definition at line 3125 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    FIXME("(%p)->(%s:%d %s:%d %p %p): stub\n", This, debugstr_wn(pUri, nUri), nUri,
        debugstr_wn(pLocalName, nLocalName), nLocalName, pType, nType);
    return E_NOTIMPL;
}

SAXAttributes_getTypeFromQName()

static HRESULT WINAPI SAXAttributes_getTypeFromQName ( ISAXAttributes *  iface, const WCHAR *  pQName, int  nQName, const WCHAR **  pType, int *  nType  )

static

Definition at line 3134 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    FIXME("(%p)->(%s:%d %p %p): stub\n", This, debugstr_wn(pQName, nQName), nQName, pType, nType);
    return E_NOTIMPL;
}

SAXAttributes_getURI()

static HRESULT WINAPI SAXAttributes_getURI ( ISAXAttributes *  iface, int  index, const WCHAR **  uri, int *  len  )

static

Definition at line 2979 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p)\n", This, index, uri, len);
 
    if (index >= This->length || index < 0) return E_INVALIDARG;
    if (!uri || !len) return E_POINTER;
 
    *len = SysStringLen(This->attr[index].uri);
    *uri = This->attr[index].uri;
 
    return S_OK;
}

SAXAttributes_getValue()

static HRESULT WINAPI SAXAttributes_getValue ( ISAXAttributes *  iface, int  index, const WCHAR **  value, int *  len  )

static

Definition at line 3142 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
 
    TRACE("(%p)->(%d %p %p)\n", This, index, value, len);
 
    if (index >= This->length) return E_INVALIDARG;
 
    if ((!value || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
       return E_POINTER;
 
    *value = This->attr[index].value;
    *len = SysStringLen(This->attr[index].value);
 
    return S_OK;
}

SAXAttributes_getValueFromName()

static HRESULT WINAPI SAXAttributes_getValueFromName ( ISAXAttributes *  iface, const WCHAR *  uri, int  uri_len, const WCHAR *  name, int  name_len, const WCHAR **  value, int *  value_len  )

static

Definition at line 3160 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    HRESULT hr;
    int index;
 
    TRACE("(%p)->(%s:%d %s:%d %p %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
        debugstr_wn(name, name_len), name_len, value, value_len);
 
    if (!uri || !name || !value || !value_len)
        return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
 
    hr = ISAXAttributes_getIndexFromName(iface, uri, uri_len, name, name_len, &index);
    if (hr == S_OK)
        hr = ISAXAttributes_getValue(iface, index, value, value_len);
 
    return hr;
}

SAXAttributes_getValueFromQName()

static HRESULT WINAPI SAXAttributes_getValueFromQName ( ISAXAttributes *  iface, const WCHAR *  qname, int  qname_len, const WCHAR **  value, int *  value_len  )

static

Definition at line 3180 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    HRESULT hr;
    int index;
 
    TRACE("(%p)->(%s:%d %p %p)\n", This, debugstr_wn(qname, qname_len), qname_len, value, value_len);
 
    if (!qname || !value || !value_len)
        return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
 
    hr = ISAXAttributes_getIndexFromQName(iface, qname, qname_len, &index);
    if (hr == S_OK)
        hr = ISAXAttributes_getValue(iface, index, value, value_len);
 
    return hr;
}

SAXAttributes_QueryInterface()

static HRESULT WINAPI SAXAttributes_QueryInterface ( ISAXAttributes *  iface, REFIID  riid, void **  ppObj  )

static

Definition at line 2948 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    return IMXAttributes_QueryInterface(&This->IMXAttributes_iface, riid, ppObj);
}

SAXAttributes_Release()

static ULONG WINAPI SAXAttributes_Release ( ISAXAttributes *  iface )

static

Definition at line 2960 of file mxwriter.c.

{
    mxattributes *This = impl_from_ISAXAttributes( iface );
    return IMXAttributes_Release(&This->IMXAttributes_iface);
}

SAXContentHandler_AddRef()

static ULONG WINAPI SAXContentHandler_AddRef ( ISAXContentHandler *  iface )

static

Definition at line 1186 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

SAXContentHandler_characters()

static HRESULT WINAPI SAXContentHandler_characters ( ISAXContentHandler *  iface, const WCHAR *  chars, int  nchars  )

static

Definition at line 1395 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
 
    TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
 
    if (!chars) return E_INVALIDARG;
 
    close_element_starttag(This);
    set_element_name(This, NULL, 0);
 
    if (!This->cdata)
        This->text = TRUE;
 
    if (nchars)
    {
        if (This->cdata || This->props[MXWriter_DisableEscaping] == VARIANT_TRUE)
            write_output_buffer(This, chars, nchars);
        else
        {
            int len = nchars;
            WCHAR *escaped;
 
            escaped = get_escaped_string(chars, EscapeText, &len);
            write_output_buffer(This, escaped, len);
            free(escaped);
        }
    }
 
    return S_OK;
}

SAXContentHandler_endDocument()

static HRESULT WINAPI SAXContentHandler_endDocument ( ISAXContentHandler *  iface )

static

Definition at line 1240 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    TRACE("(%p)\n", This);
    This->prop_changed = FALSE;
    return flush_output_buffer(This);
}

SAXContentHandler_endElement()

static HRESULT WINAPI SAXContentHandler_endElement ( ISAXContentHandler *  iface, const WCHAR *  namespaceUri, int  nnamespaceUri, const WCHAR *  local_name, int  nlocal_name, const WCHAR *  QName, int  nQName  )

static

Definition at line 1354 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
 
    TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri,
        debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName);
 
    if (((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) ||
         (nQName == -1 && This->class_version == MSXML6))
        return E_INVALIDARG;
 
    writer_dec_indent(This);
 
    if (This->element)
    {
        static const WCHAR closeW[] = {'/','>'};
        write_output_buffer(This, closeW, 2);
    }
    else
    {
        static const WCHAR closetagW[] = {'<','/'};
        static const WCHAR gtW[] = {'>'};
 
        write_node_indent(This);
        write_output_buffer(This, closetagW, 2);
        write_output_buffer(This, QName, nQName);
        write_output_buffer(This, gtW, 1);
    }
 
    set_element_name(This, NULL, 0);
 
    return S_OK;
}

SAXContentHandler_endPrefixMapping()

static HRESULT WINAPI SAXContentHandler_endPrefixMapping ( ISAXContentHandler *  iface, const WCHAR *  prefix, int  nprefix  )

static

Definition at line 1260 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    TRACE("(%p)->(%s)\n", This, debugstr_wn(prefix, nprefix));
    return S_OK;
}

SAXContentHandler_ignorableWhitespace()

static HRESULT WINAPI SAXContentHandler_ignorableWhitespace ( ISAXContentHandler *  iface, const WCHAR *  chars, int  nchars  )

static

Definition at line 1430 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
 
    TRACE("(%p)->(%s)\n", This, debugstr_wn(chars, nchars));
 
    if (!chars) return E_INVALIDARG;
 
    write_output_buffer(This, chars, nchars);
 
    return S_OK;
}

SAXContentHandler_processingInstruction()

static HRESULT WINAPI SAXContentHandler_processingInstruction ( ISAXContentHandler *  iface, const WCHAR *  target, int  ntarget, const WCHAR *  data, int  ndata  )

static

Definition at line 1446 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    static const WCHAR openpiW[] = {'<','?'};
    static const WCHAR closepiW[] = {'?','>','\r','\n'};
 
    TRACE("(%p)->(%s %s)\n", This, debugstr_wn(target, ntarget), debugstr_wn(data, ndata));
 
    if (!target) return E_INVALIDARG;
 
    write_node_indent(This);
    write_output_buffer(This, openpiW, ARRAY_SIZE(openpiW));
 
    if (*target)
        write_output_buffer(This, target, ntarget);
 
    if (data && *data && ndata)
    {
        write_output_buffer(This, spaceW, 1);
        write_output_buffer(This, data, ndata);
    }
 
    write_output_buffer(This, closepiW, ARRAY_SIZE(closepiW));
    This->newline = TRUE;
 
    return S_OK;
}

SAXContentHandler_putDocumentLocator()

static HRESULT WINAPI SAXContentHandler_putDocumentLocator ( ISAXContentHandler *  iface, ISAXLocator *  locator  )

static

Definition at line 1198 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    FIXME("(%p)->(%p)\n", This, locator);
    return E_NOTIMPL;
}

SAXContentHandler_QueryInterface()

static HRESULT WINAPI SAXContentHandler_QueryInterface ( ISAXContentHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1177 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

SAXContentHandler_Release()

static ULONG WINAPI SAXContentHandler_Release ( ISAXContentHandler *  iface )

static

Definition at line 1192 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

SAXContentHandler_skippedEntity()

static HRESULT WINAPI SAXContentHandler_skippedEntity ( ISAXContentHandler *  iface, const WCHAR *  name, int  nname  )

static

Definition at line 1479 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    FIXME("(%p)->(%s)\n", This, debugstr_wn(name, nname));
    return E_NOTIMPL;
}

SAXContentHandler_startDocument()

static HRESULT WINAPI SAXContentHandler_startDocument ( ISAXContentHandler *  iface )

static

Definition at line 1207 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
 
    TRACE("(%p)\n", This);
 
    /* If properties have been changed since the last "endDocument" call
     * we need to reset the output buffer. If we don't the output buffer
     * could end up with multiple XML documents in it, plus this seems to
     * be how Windows works.
     */
    if (This->prop_changed) {
        close_output_buffer(This);
        This->prop_changed = FALSE;
    }
 
    if (This->props[MXWriter_OmitXmlDecl] == VARIANT_TRUE) return S_OK;
 
    write_prolog_buffer(This);
 
    if (This->dest && This->xml_enc == XmlEncoding_UTF16) {
        static const char utf16BOM[] = {0xff,0xfe};
 
        if (This->props[MXWriter_BOM] == VARIANT_TRUE)
            /* Windows passes a NULL pointer as the pcbWritten parameter and
             * ignores any error codes returned from this Write call.
             */
            IStream_Write(This->dest, utf16BOM, sizeof(utf16BOM), NULL);
    }
 
    return S_OK;
}

SAXContentHandler_startElement()

static HRESULT WINAPI SAXContentHandler_startElement ( ISAXContentHandler *  iface, const WCHAR *  namespaceUri, int  nnamespaceUri, const WCHAR *  local_name, int  nlocal_name, const WCHAR *  QName, int  nQName, ISAXAttributes *  attr  )

static

Definition at line 1304 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
 
    TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_wn(namespaceUri, nnamespaceUri),
        debugstr_wn(local_name, nlocal_name), debugstr_wn(QName, nQName), attr);
 
    if (((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) ||
        (nQName == -1 && This->class_version == MSXML6))
        return E_INVALIDARG;
 
    mxwriter_write_starttag(This, QName, nQName);
 
    if (attr)
    {
        int length, i, escape;
        HRESULT hr;
 
        hr = ISAXAttributes_getLength(attr, &length);
        if (FAILED(hr)) return hr;
 
        escape = This->props[MXWriter_DisableEscaping] == VARIANT_FALSE ||
            (This->class_version == MSXML4 || This->class_version == MSXML6);
 
        for (i = 0; i < length; i++)
        {
            int qname_len = 0, value_len = 0;
            const WCHAR *qname, *value;
 
            hr = ISAXAttributes_getQName(attr, i, &qname, &qname_len);
            if (FAILED(hr)) return hr;
 
            hr = ISAXAttributes_getValue(attr, i, &value, &value_len);
            if (FAILED(hr)) return hr;
 
            mxwriter_write_attribute(This, qname, qname_len, value, value_len, escape);
        }
    }
 
    return S_OK;
}

SAXContentHandler_startPrefixMapping()

static HRESULT WINAPI SAXContentHandler_startPrefixMapping ( ISAXContentHandler *  iface, const WCHAR *  prefix, int  nprefix, const WCHAR *  uri, int  nuri  )

static

Definition at line 1248 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXContentHandler( iface );
    TRACE("(%p)->(%s %s)\n", This, debugstr_wn(prefix, nprefix), debugstr_wn(uri, nuri));
    return S_OK;
}

SAXDeclHandler_AddRef()

static ULONG WINAPI SAXDeclHandler_AddRef ( ISAXDeclHandler *  iface )

static

Definition at line 1673 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

SAXDeclHandler_attributeDecl()

static HRESULT WINAPI SAXDeclHandler_attributeDecl ( ISAXDeclHandler *  iface, const WCHAR *  element, int  n_element, const WCHAR *  attr, int  n_attr, const WCHAR *  type, int  n_type, const WCHAR *  Default, int  n_default, const WCHAR *  value, int  n_value  )

static

Definition at line 1708 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
    static const WCHAR attlistW[] = {'<','!','A','T','T','L','I','S','T',' '};
    static const WCHAR closetagW[] = {'>','\r','\n'};
 
    TRACE("(%p)->(%s:%d %s:%d %s:%d %s:%d %s:%d)\n", This, debugstr_wn(element, n_element), n_element,
        debugstr_wn(attr, n_attr), n_attr, debugstr_wn(type, n_type), n_type, debugstr_wn(Default, n_default), n_default,
        debugstr_wn(value, n_value), n_value);
 
    write_output_buffer(This, attlistW, ARRAY_SIZE(attlistW));
    if (n_element) {
        write_output_buffer(This, element, n_element);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (n_attr) {
        write_output_buffer(This, attr, n_attr);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (n_type) {
        write_output_buffer(This, type, n_type);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (n_default) {
        write_output_buffer(This, Default, n_default);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (n_value)
        write_output_buffer_quoted(This, value, n_value);
 
    write_output_buffer(This, closetagW, ARRAY_SIZE(closetagW));
 
    return S_OK;
}

SAXDeclHandler_elementDecl()

static HRESULT WINAPI SAXDeclHandler_elementDecl ( ISAXDeclHandler *  iface, const WCHAR *  name, int  n_name, const WCHAR *  model, int  n_model  )

static

Definition at line 1685 of file mxwriter.c.

{
    static const WCHAR elementW[] = {'<','!','E','L','E','M','E','N','T',' '};
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
 
    TRACE("(%p)->(%s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
        debugstr_wn(model, n_model), n_model);
 
    if (!name || !model) return E_INVALIDARG;
 
    write_output_buffer(This, elementW, ARRAY_SIZE(elementW));
    if (n_name) {
        write_output_buffer(This, name, n_name);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
    if (n_model)
        write_output_buffer(This, model, n_model);
    write_output_buffer(This, closetagW, ARRAY_SIZE(closetagW));
 
    return S_OK;
}

SAXDeclHandler_externalEntityDecl()

static HRESULT WINAPI SAXDeclHandler_externalEntityDecl ( ISAXDeclHandler *  iface, const WCHAR *  name, int  n_name, const WCHAR *  publicId, int  n_publicId, const WCHAR *  systemId, int  n_systemId  )

static

Definition at line 1774 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
 
    TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
        debugstr_wn(publicId, n_publicId), n_publicId, debugstr_wn(systemId, n_systemId), n_systemId);
 
    if (!name || !systemId) return E_INVALIDARG;
 
    write_output_buffer(This, entityW, ARRAY_SIZE(entityW));
    if (n_name) {
        write_output_buffer(This, name, n_name);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (publicId)
    {
        write_output_buffer(This, publicW, ARRAY_SIZE(publicW));
        write_output_buffer_quoted(This, publicId, n_publicId);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
        write_output_buffer_quoted(This, systemId, n_systemId);
    }
    else
    {
        write_output_buffer(This, systemW, ARRAY_SIZE(systemW));
        write_output_buffer_quoted(This, systemId, n_systemId);
    }
 
    write_output_buffer(This, closetagW, ARRAY_SIZE(closetagW));
 
    return S_OK;
}

SAXDeclHandler_internalEntityDecl()

static HRESULT WINAPI SAXDeclHandler_internalEntityDecl ( ISAXDeclHandler *  iface, const WCHAR *  name, int  n_name, const WCHAR *  value, int  n_value  )

static

Definition at line 1750 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
 
    TRACE("(%p)->(%s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
        debugstr_wn(value, n_value), n_value);
 
    if (!name || !value) return E_INVALIDARG;
 
    write_output_buffer(This, entityW, ARRAY_SIZE(entityW));
    if (n_name) {
        write_output_buffer(This, name, n_name);
        write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    }
 
    if (n_value)
        write_output_buffer_quoted(This, value, n_value);
 
    write_output_buffer(This, closetagW, ARRAY_SIZE(closetagW));
 
    return S_OK;
}

SAXDeclHandler_QueryInterface()

static HRESULT WINAPI SAXDeclHandler_QueryInterface ( ISAXDeclHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1666 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

SAXDeclHandler_Release()

static ULONG WINAPI SAXDeclHandler_Release ( ISAXDeclHandler *  iface )

static

Definition at line 1679 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDeclHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

SAXDTDHandler_AddRef()

static ULONG WINAPI SAXDTDHandler_AddRef ( ISAXDTDHandler *  iface )

static

Definition at line 2290 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDTDHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

SAXDTDHandler_notationDecl()

static HRESULT WINAPI SAXDTDHandler_notationDecl ( ISAXDTDHandler *  iface, const WCHAR *  name, INT  n_name, const WCHAR *  publicid, INT  n_publicid, const WCHAR *  systemid, INT  n_systemid  )

static

Definition at line 2302 of file mxwriter.c.

{
    static const WCHAR notationW[] = {'<','!','N','O','T','A','T','I','O','N',' '};
    mxwriter *This = impl_from_ISAXDTDHandler( iface );
 
    TRACE("(%p)->(%s:%d, %s:%d, %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
        debugstr_wn(publicid, n_publicid), n_publicid, debugstr_wn(systemid, n_systemid), n_systemid);
 
    if (!name || !n_name)
        return E_INVALIDARG;
 
    write_output_buffer(This, notationW, ARRAY_SIZE(notationW));
    write_output_buffer(This, name, n_name);
 
    if (!publicid && !systemid)
        return E_INVALIDARG;
 
    write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
    if (publicid)
    {
        write_output_buffer(This, publicW, ARRAY_SIZE(publicW));
        write_output_buffer_quoted(This, publicid, n_publicid);
        if (systemid)
        {
            write_output_buffer(This, spaceW, ARRAY_SIZE(spaceW));
            write_output_buffer_quoted(This, systemid, n_systemid);
        }
    }
    else
    {
        write_output_buffer(This, systemW, ARRAY_SIZE(systemW));
        write_output_buffer_quoted(This, systemid, n_systemid);
    }
 
    write_output_buffer(This, closetagW, ARRAY_SIZE(closetagW));
 
    return S_OK;
}

SAXDTDHandler_QueryInterface()

static HRESULT WINAPI SAXDTDHandler_QueryInterface ( ISAXDTDHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2284 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDTDHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

SAXDTDHandler_Release()

static ULONG WINAPI SAXDTDHandler_Release ( ISAXDTDHandler *  iface )

static

Definition at line 2296 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDTDHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

SAXDTDHandler_unparsedEntityDecl()

static HRESULT WINAPI SAXDTDHandler_unparsedEntityDecl ( ISAXDTDHandler *  iface, const WCHAR *  name, INT  nname, const WCHAR *  publicid, INT  npublicid, const WCHAR *  systemid, INT  nsystemid, const WCHAR *  notation, INT  nnotation  )

static

Definition at line 2344 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXDTDHandler( iface );
    FIXME("(%p)->(%s:%d, %s:%d, %s:%d, %s:%d): stub\n", This, debugstr_wn(name, nname), nname,
        debugstr_wn(publicid, npublicid), npublicid, debugstr_wn(systemid, nsystemid), nsystemid,
        debugstr_wn(notation, nnotation), nnotation);
    return E_NOTIMPL;
}

SAXErrorHandler_AddRef()

static ULONG WINAPI SAXErrorHandler_AddRef ( ISAXErrorHandler *  iface )

static

Definition at line 2456 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

SAXErrorHandler_error()

static HRESULT WINAPI SAXErrorHandler_error ( ISAXErrorHandler *  iface, ISAXLocator *  locator, const WCHAR *  message, HRESULT  hr  )

static

Definition at line 2468 of file mxwriter.c.

{
    FIXME("%p, %p, %s, %#lx.\n", iface, locator, debugstr_w(message), hr);
 
    return E_NOTIMPL;
}

SAXErrorHandler_fatalError()

static HRESULT WINAPI SAXErrorHandler_fatalError ( ISAXErrorHandler *  iface, ISAXLocator *  locator, const WCHAR *  message, HRESULT  hr  )

static

Definition at line 2476 of file mxwriter.c.

{
    FIXME("%p, %p, %s, %#lx.\n", iface, locator, debugstr_w(message), hr);
 
    return E_NOTIMPL;
}

SAXErrorHandler_ignorableWarning()

static HRESULT WINAPI SAXErrorHandler_ignorableWarning ( ISAXErrorHandler *  iface, ISAXLocator *  locator, const WCHAR *  message, HRESULT  hr  )

static

Definition at line 2484 of file mxwriter.c.

{
    FIXME("%p, %p, %s, %#lx.\n", iface, locator, debugstr_w(message), hr);
 
    return E_NOTIMPL;
}

SAXErrorHandler_QueryInterface()

static HRESULT WINAPI SAXErrorHandler_QueryInterface ( ISAXErrorHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2450 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

SAXErrorHandler_Release()

static ULONG WINAPI SAXErrorHandler_Release ( ISAXErrorHandler *  iface )

static

Definition at line 2462 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

SAXLexicalHandler_AddRef()

static ULONG WINAPI SAXLexicalHandler_AddRef ( ISAXLexicalHandler *  iface )

static

Definition at line 1515 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

SAXLexicalHandler_comment()

static HRESULT WINAPI SAXLexicalHandler_comment ( ISAXLexicalHandler *  iface, const WCHAR *  chars, int  nchars  )

static

Definition at line 1630 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    static const WCHAR copenW[] = {'<','!','-','-'};
    static const WCHAR ccloseW[] = {'-','-','>','\r','\n'};
 
    TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
 
    if (!chars) return E_INVALIDARG;
 
    close_element_starttag(This);
    write_node_indent(This);
 
    write_output_buffer(This, copenW, ARRAY_SIZE(copenW));
    if (nchars)
        write_output_buffer(This, chars, nchars);
    write_output_buffer(This, ccloseW, ARRAY_SIZE(ccloseW));
 
    return S_OK;
}

SAXLexicalHandler_endCDATA()

static HRESULT WINAPI SAXLexicalHandler_endCDATA ( ISAXLexicalHandler *  iface )

static

Definition at line 1617 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    static const WCHAR ecdataW[] = {']',']','>'};
 
    TRACE("(%p)\n", This);
 
    write_output_buffer(This, ecdataW, ARRAY_SIZE(ecdataW));
    This->cdata = FALSE;
 
    return S_OK;
}

SAXLexicalHandler_endDTD()

static HRESULT WINAPI SAXLexicalHandler_endDTD ( ISAXLexicalHandler *  iface )

static

Definition at line 1577 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    static const WCHAR closedtdW[] = {']','>','\r','\n'};
 
    TRACE("(%p)\n", This);
 
    write_output_buffer(This, closedtdW, ARRAY_SIZE(closedtdW));
 
    return S_OK;
}

SAXLexicalHandler_endEntity()

static HRESULT WINAPI SAXLexicalHandler_endEntity ( ISAXLexicalHandler *  iface, const WCHAR *  name, int  len  )

static

Definition at line 1596 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
    return E_NOTIMPL;
}

SAXLexicalHandler_QueryInterface()

static HRESULT WINAPI SAXLexicalHandler_QueryInterface ( ISAXLexicalHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1508 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

SAXLexicalHandler_Release()

static ULONG WINAPI SAXLexicalHandler_Release ( ISAXLexicalHandler *  iface )

static

Definition at line 1521 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

SAXLexicalHandler_startCDATA()

static HRESULT WINAPI SAXLexicalHandler_startCDATA ( ISAXLexicalHandler *  iface )

static

Definition at line 1603 of file mxwriter.c.

{
    static const WCHAR scdataW[] = {'<','!','[','C','D','A','T','A','['};
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
 
    TRACE("(%p)\n", This);
 
    write_node_indent(This);
    write_output_buffer(This, scdataW, ARRAY_SIZE(scdataW));
    This->cdata = TRUE;
 
    return S_OK;
}

SAXLexicalHandler_startDTD()

static HRESULT WINAPI SAXLexicalHandler_startDTD ( ISAXLexicalHandler *  iface, const WCHAR *  name, int  name_len, const WCHAR *  publicId, int  publicId_len, const WCHAR *  systemId, int  systemId_len  )

static

Definition at line 1527 of file mxwriter.c.

{
    static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',' '};
    static const WCHAR openintW[] = {'[','\r','\n'};
 
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
 
    TRACE("(%p)->(%s %s %s)\n", This, debugstr_wn(name, name_len), debugstr_wn(publicId, publicId_len),
        debugstr_wn(systemId, systemId_len));
 
    if (!name) return E_INVALIDARG;
 
    write_output_buffer(This, doctypeW, ARRAY_SIZE(doctypeW));
 
    if (*name)
    {
        write_output_buffer(This, name, name_len);
        write_output_buffer(This, spaceW, 1);
    }
 
    if (publicId)
    {
        write_output_buffer(This, publicW, ARRAY_SIZE(publicW));
        write_output_buffer_quoted(This, publicId, publicId_len);
 
        if (!systemId) return E_INVALIDARG;
 
        if (*publicId)
            write_output_buffer(This, spaceW, 1);
 
        write_output_buffer_quoted(This, systemId, systemId_len);
 
        if (*systemId)
            write_output_buffer(This, spaceW, 1);
    }
    else if (systemId)
    {
        write_output_buffer(This, systemW, ARRAY_SIZE(systemW));
        write_output_buffer_quoted(This, systemId, systemId_len);
        if (*systemId)
            write_output_buffer(This, spaceW, 1);
    }
 
    write_output_buffer(This, openintW, ARRAY_SIZE(openintW));
 
    return S_OK;
}

SAXLexicalHandler_startEntity()

static HRESULT WINAPI SAXLexicalHandler_startEntity ( ISAXLexicalHandler *  iface, const WCHAR *  name, int  len  )

static

Definition at line 1589 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXLexicalHandler( iface );
    FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
    return E_NOTIMPL;
}

set_element_name()

static void set_element_name ( mxwriter *  This, const WCHAR *  name, int  len  )

static

Definition at line 674 of file mxwriter.c.

{
    SysFreeString(This->element);
    if (name)
        This->element = len != -1 ? SysAllocStringLen(name, len) : SysAllocString(name);
    else
        This->element = NULL;
}

Referenced by flush_output_buffer(), mxwriter_write_starttag(), SAXContentHandler_characters(), and SAXContentHandler_endElement().

VBSAXAttributes_AddRef()

static ULONG WINAPI VBSAXAttributes_AddRef ( IVBSAXAttributes *  iface )

static

Definition at line 3228 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    return ISAXAttributes_AddRef(&This->ISAXAttributes_iface);
}

VBSAXAttributes_get_length()

static HRESULT WINAPI VBSAXAttributes_get_length ( IVBSAXAttributes *  iface, int *  len  )

static

Definition at line 3314 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    return ISAXAttributes_getLength(&This->ISAXAttributes_iface, len);
}

VBSAXAttributes_GetIDsOfNames()

static HRESULT WINAPI VBSAXAttributes_GetIDsOfNames ( IVBSAXAttributes *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 3260 of file mxwriter.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, 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;
}

VBSAXAttributes_getIndexFromName()

static HRESULT WINAPI VBSAXAttributes_getIndexFromName ( IVBSAXAttributes *  iface, BSTR  uri, BSTR  name, int *  index  )

static

Definition at line 3380 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    return ISAXAttributes_getIndexFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
            name, SysStringLen(name), index);
}

VBSAXAttributes_getIndexFromQName()

static HRESULT WINAPI VBSAXAttributes_getIndexFromQName ( IVBSAXAttributes *  iface, BSTR  qname, int *  index  )

static

Definition at line 3387 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    return ISAXAttributes_getIndexFromQName(&This->ISAXAttributes_iface, qname,
            SysStringLen(qname), index);
}

VBSAXAttributes_getLocalName()

static HRESULT WINAPI VBSAXAttributes_getLocalName ( IVBSAXAttributes *  iface, int  index, BSTR *  name  )

static

Definition at line 3340 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *nameW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%d %p)\n", This, index, name);
 
    if (!name)
        return E_POINTER;
 
    *name = NULL;
    hr = ISAXAttributes_getLocalName(&This->ISAXAttributes_iface, index, &nameW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(nameW, len, name);
}

VBSAXAttributes_getQName()

static HRESULT WINAPI VBSAXAttributes_getQName ( IVBSAXAttributes *  iface, int  index, BSTR *  qname  )

static

Definition at line 3360 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *qnameW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%d %p)\n", This, index, qname);
 
    if (!qname)
        return E_POINTER;
 
    *qname = NULL;
    hr = ISAXAttributes_getQName(&This->ISAXAttributes_iface, index, &qnameW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(qnameW, len, qname);
}

VBSAXAttributes_getType()

static HRESULT WINAPI VBSAXAttributes_getType ( IVBSAXAttributes *  iface, int  index, BSTR *  type  )

static

Definition at line 3394 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *typeW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%d %p)\n", This, index, type);
 
    if (!type)
        return E_POINTER;
 
    *type = NULL;
    hr = ISAXAttributes_getType(&This->ISAXAttributes_iface, index, &typeW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(typeW, len, type);
}

VBSAXAttributes_getTypeFromName()

static HRESULT WINAPI VBSAXAttributes_getTypeFromName ( IVBSAXAttributes *  iface, BSTR  uri, BSTR  name, BSTR *  type  )

static

Definition at line 3414 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *typeW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(uri), debugstr_w(name), type);
 
    if (!type)
        return E_POINTER;
 
    *type = NULL;
    hr = ISAXAttributes_getTypeFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
            name, SysStringLen(name), &typeW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(typeW, len, type);
}

VBSAXAttributes_getTypeFromQName()

static HRESULT WINAPI VBSAXAttributes_getTypeFromQName ( IVBSAXAttributes *  iface, BSTR  qname, BSTR *  type  )

static

Definition at line 3436 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *typeW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(qname), type);
 
    if (!type)
        return E_POINTER;
 
    *type = NULL;
    hr = ISAXAttributes_getTypeFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
            &typeW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(typeW, len, type);
}

VBSAXAttributes_GetTypeInfo()

static HRESULT WINAPI VBSAXAttributes_GetTypeInfo ( IVBSAXAttributes *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 3251 of file mxwriter.c.

{
    TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 
    return get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
}

VBSAXAttributes_GetTypeInfoCount()

static HRESULT WINAPI VBSAXAttributes_GetTypeInfoCount ( IVBSAXAttributes *  iface, UINT *  pctinfo  )

static

Definition at line 3240 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
 
    TRACE("(%p)->(%p)\n", This, pctinfo);
 
    *pctinfo = 1;
 
    return S_OK;
}

VBSAXAttributes_getURI()

static HRESULT WINAPI VBSAXAttributes_getURI ( IVBSAXAttributes *  iface, int  index, BSTR *  uri  )

static

Definition at line 3320 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *uriW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%d %p)\n", This, index, uri);
 
    if (!uri)
        return E_POINTER;
 
    *uri = NULL;
    hr = ISAXAttributes_getURI(&This->ISAXAttributes_iface, index, &uriW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(uriW, len, uri);
}

VBSAXAttributes_getValue()

static HRESULT WINAPI VBSAXAttributes_getValue ( IVBSAXAttributes *  iface, int  index, BSTR *  value  )

static

Definition at line 3457 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *valueW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%d %p)\n", This, index, value);
 
    if (!value)
        return E_POINTER;
 
    *value = NULL;
    hr = ISAXAttributes_getValue(&This->ISAXAttributes_iface, index, &valueW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(valueW, len, value);
}

VBSAXAttributes_getValueFromName()

static HRESULT WINAPI VBSAXAttributes_getValueFromName ( IVBSAXAttributes *  iface, BSTR  uri, BSTR  name, BSTR *  value  )

static

Definition at line 3477 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *valueW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(uri), debugstr_w(name), value);
 
    if (!value)
        return E_POINTER;
 
    *value = NULL;
    hr = ISAXAttributes_getValueFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
            name, SysStringLen(name), &valueW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(valueW, len, value);
}

VBSAXAttributes_getValueFromQName()

static HRESULT WINAPI VBSAXAttributes_getValueFromQName ( IVBSAXAttributes *  iface, BSTR  qname, BSTR *  value  )

static

Definition at line 3499 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    const WCHAR *valueW;
    HRESULT hr;
    int len;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(qname), value);
 
    if (!value)
        return E_POINTER;
 
    *value = NULL;
    hr = ISAXAttributes_getValueFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
        &valueW, &len);
    if (FAILED(hr))
        return hr;
 
    return return_bstrn(valueW, len, value);
}

VBSAXAttributes_Invoke()

static HRESULT WINAPI VBSAXAttributes_Invoke ( IVBSAXAttributes *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 3287 of file mxwriter.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
          lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

VBSAXAttributes_QueryInterface()

static HRESULT WINAPI VBSAXAttributes_QueryInterface ( IVBSAXAttributes *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 3218 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
    return ISAXAttributes_QueryInterface(&This->ISAXAttributes_iface, riid, ppvObject);
}

VBSAXAttributes_Release()

static ULONG WINAPI VBSAXAttributes_Release ( IVBSAXAttributes *  iface )

static

Definition at line 3234 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    return ISAXAttributes_Release(&This->ISAXAttributes_iface);
}

VBSAXContentHandler_AddRef()

static ULONG WINAPI VBSAXContentHandler_AddRef ( IVBSAXContentHandler *  iface )

static

Definition at line 2068 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

VBSAXContentHandler_characters()

static HRESULT WINAPI VBSAXContentHandler_characters ( IVBSAXContentHandler *  iface, BSTR *  chars  )

static

Definition at line 2214 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, chars);
 
    if (!chars)
        return E_POINTER;
 
    return ISAXContentHandler_characters(&This->ISAXContentHandler_iface, *chars, SysStringLen(*chars));
}

VBSAXContentHandler_endDocument()

static HRESULT WINAPI VBSAXContentHandler_endDocument ( IVBSAXContentHandler *  iface )

static

Definition at line 2120 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return ISAXContentHandler_endDocument(&This->ISAXContentHandler_iface);
}

VBSAXContentHandler_endElement()

static HRESULT WINAPI VBSAXContentHandler_endElement ( IVBSAXContentHandler *  iface, BSTR *  namespaceURI, BSTR *  localName, BSTR *  QName  )

static

Definition at line 2198 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p %p %p)\n", This, namespaceURI, localName, QName);
 
    if (!namespaceURI || !localName || !QName)
        return E_POINTER;
 
    return ISAXContentHandler_endElement(&This->ISAXContentHandler_iface,
        *namespaceURI, SysStringLen(*namespaceURI),
        *localName, SysStringLen(*localName),
        *QName, SysStringLen(*QName));
}

VBSAXContentHandler_endPrefixMapping()

static HRESULT WINAPI VBSAXContentHandler_endPrefixMapping ( IVBSAXContentHandler *  iface, BSTR *  prefix  )

static

Definition at line 2138 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, prefix);
 
    if (!prefix)
        return E_POINTER;
 
    return ISAXContentHandler_endPrefixMapping(&This->ISAXContentHandler_iface, *prefix, -1);
}

VBSAXContentHandler_GetIDsOfNames()

static HRESULT WINAPI VBSAXContentHandler_GetIDsOfNames ( IVBSAXContentHandler *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2092 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_GetIDsOfNames(&This->IMXWriter_iface, riid, rgszNames, cNames, lcid, rgDispId);
}

VBSAXContentHandler_GetTypeInfo()

static HRESULT WINAPI VBSAXContentHandler_GetTypeInfo ( IVBSAXContentHandler *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2086 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_GetTypeInfo(&This->IMXWriter_iface, iTInfo, lcid, ppTInfo);
}

VBSAXContentHandler_GetTypeInfoCount()

static HRESULT WINAPI VBSAXContentHandler_GetTypeInfoCount ( IVBSAXContentHandler *  iface, UINT *  pctinfo  )

static

Definition at line 2080 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_GetTypeInfoCount(&This->IMXWriter_iface, pctinfo);
}

VBSAXContentHandler_ignorableWhitespace()

static HRESULT WINAPI VBSAXContentHandler_ignorableWhitespace ( IVBSAXContentHandler *  iface, BSTR *  chars  )

static

Definition at line 2226 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, chars);
 
    if (!chars)
        return E_POINTER;
 
    return ISAXContentHandler_ignorableWhitespace(&This->ISAXContentHandler_iface, *chars, -1);
}

VBSAXContentHandler_Invoke()

static HRESULT WINAPI VBSAXContentHandler_Invoke ( IVBSAXContentHandler *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2099 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_Invoke(&This->IMXWriter_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
}

VBSAXContentHandler_processingInstruction()

static HRESULT WINAPI VBSAXContentHandler_processingInstruction ( IVBSAXContentHandler *  iface, BSTR *  target, BSTR *  data  )

static

Definition at line 2238 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p %p)\n", This, target, data);
 
    if (!target || !data)
        return E_POINTER;
 
    return ISAXContentHandler_processingInstruction(&This->ISAXContentHandler_iface, *target, -1, *data, -1);
}

VBSAXContentHandler_putref_documentLocator()

static HRESULT WINAPI VBSAXContentHandler_putref_documentLocator ( IVBSAXContentHandler *  iface, IVBSAXLocator *  locator  )

static

Definition at line 2107 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    TRACE("(%p)->(%p)\n", This, locator);
    return S_OK;
}

VBSAXContentHandler_QueryInterface()

static HRESULT WINAPI VBSAXContentHandler_QueryInterface ( IVBSAXContentHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2062 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

VBSAXContentHandler_Release()

static ULONG WINAPI VBSAXContentHandler_Release ( IVBSAXContentHandler *  iface )

static

Definition at line 2074 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

VBSAXContentHandler_skippedEntity()

static HRESULT WINAPI VBSAXContentHandler_skippedEntity ( IVBSAXContentHandler *  iface, BSTR *  name  )

static

Definition at line 2251 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, name);
 
    if (!name)
        return E_POINTER;
 
    return ISAXContentHandler_skippedEntity(&This->ISAXContentHandler_iface, *name, -1);
}

VBSAXContentHandler_startDocument()

static HRESULT WINAPI VBSAXContentHandler_startDocument ( IVBSAXContentHandler *  iface )

static

Definition at line 2114 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
    return ISAXContentHandler_startDocument(&This->ISAXContentHandler_iface);
}

VBSAXContentHandler_startElement()

static HRESULT WINAPI VBSAXContentHandler_startElement ( IVBSAXContentHandler *  iface, BSTR *  namespaceURI, BSTR *  localName, BSTR *  QName, IVBSAXAttributes *  attrs  )

static

Definition at line 2150 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p %p %p %p)\n", This, namespaceURI, localName, QName, attrs);
 
    if (!namespaceURI || !*namespaceURI || !localName || !QName)
        return E_INVALIDARG;
 
    TRACE("(%s %s %s)\n", debugstr_w(*namespaceURI), debugstr_w(*localName), debugstr_w(*QName));
 
    mxwriter_write_starttag(This, *QName, SysStringLen(*QName));
 
    if (attrs)
    {
        int length, i, escape;
        HRESULT hr;
 
        hr = IVBSAXAttributes_get_length(attrs, &length);
        if (FAILED(hr)) return hr;
 
        escape = This->props[MXWriter_DisableEscaping] == VARIANT_FALSE ||
            (This->class_version == MSXML4 || This->class_version == MSXML6);
 
        for (i = 0; i < length; i++)
        {
            BSTR qname, value;
 
            hr = IVBSAXAttributes_getQName(attrs, i, &qname);
            if (FAILED(hr)) return hr;
 
            hr = IVBSAXAttributes_getValue(attrs, i, &value);
            if (FAILED(hr))
            {
                SysFreeString(qname);
                return hr;
            }
 
            mxwriter_write_attribute(This, qname, SysStringLen(qname), value, SysStringLen(value), escape);
            SysFreeString(qname);
            SysFreeString(value);
        }
    }
 
    return S_OK;
}

VBSAXContentHandler_startPrefixMapping()

static HRESULT WINAPI VBSAXContentHandler_startPrefixMapping ( IVBSAXContentHandler *  iface, BSTR *  prefix, BSTR *  uri  )

static

Definition at line 2126 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p %p)\n", This, prefix, uri);
 
    if (!prefix || !uri)
        return E_POINTER;
 
    return ISAXContentHandler_startPrefixMapping(&This->ISAXContentHandler_iface, *prefix, -1, *uri, -1);
}

VBSAXDeclHandler_AddRef()

static ULONG WINAPI VBSAXDeclHandler_AddRef ( IVBSAXDeclHandler *  iface )

static

Definition at line 1827 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

VBSAXDeclHandler_attributeDecl()

static HRESULT WINAPI VBSAXDeclHandler_attributeDecl ( IVBSAXDeclHandler *  iface, BSTR *  element, BSTR *  attr, BSTR *  type, BSTR *  default_value, BSTR *  value  )

static

Definition at line 1878 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
 
    TRACE("(%p)->(%p %p %p %p %p)\n", This, element, attr, type, default_value, value);
 
    if (!element || !attr || !type || !default_value || !value)
        return E_POINTER;
 
    return ISAXDeclHandler_attributeDecl(&This->ISAXDeclHandler_iface, *element, -1, *attr, -1, *type, -1,
        *default_value, -1, *value, -1);
}

VBSAXDeclHandler_elementDecl()

static HRESULT WINAPI VBSAXDeclHandler_elementDecl ( IVBSAXDeclHandler *  iface, BSTR *  name, BSTR *  model  )

static

Definition at line 1866 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
 
    TRACE("(%p)->(%p %p)\n", This, name, model);
 
    if (!name || !model)
        return E_POINTER;
 
    return ISAXDeclHandler_elementDecl(&This->ISAXDeclHandler_iface, *name, -1, *model, -1);
}

VBSAXDeclHandler_externalEntityDecl()

static HRESULT WINAPI VBSAXDeclHandler_externalEntityDecl ( IVBSAXDeclHandler *  iface, BSTR *  name, BSTR *  publicid, BSTR *  systemid  )

static

Definition at line 1904 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
 
    TRACE("(%p)->(%p %p %p)\n", This, name, publicid, systemid);
 
    if (!name || !publicid || !systemid)
        return E_POINTER;
 
    return ISAXDeclHandler_externalEntityDecl(&This->ISAXDeclHandler_iface, *name, -1, *publicid, -1, *systemid, -1);
}

VBSAXDeclHandler_GetIDsOfNames()

static HRESULT WINAPI VBSAXDeclHandler_GetIDsOfNames ( IVBSAXDeclHandler *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 1851 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_GetIDsOfNames(&This->IMXWriter_iface, riid, rgszNames, cNames, lcid, rgDispId);
}

VBSAXDeclHandler_GetTypeInfo()

static HRESULT WINAPI VBSAXDeclHandler_GetTypeInfo ( IVBSAXDeclHandler *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1845 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_GetTypeInfo(&This->IMXWriter_iface, iTInfo, lcid, ppTInfo);
}

VBSAXDeclHandler_GetTypeInfoCount()

static HRESULT WINAPI VBSAXDeclHandler_GetTypeInfoCount ( IVBSAXDeclHandler *  iface, UINT *  pctinfo  )

static

Definition at line 1839 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_GetTypeInfoCount(&This->IMXWriter_iface, pctinfo);
}

VBSAXDeclHandler_internalEntityDecl()

static HRESULT WINAPI VBSAXDeclHandler_internalEntityDecl ( IVBSAXDeclHandler *  iface, BSTR *  name, BSTR *  value  )

static

Definition at line 1892 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
 
    TRACE("(%p)->(%p %p)\n", This, name, value);
 
    if (!name || !value)
        return E_POINTER;
 
    return ISAXDeclHandler_internalEntityDecl(&This->ISAXDeclHandler_iface, *name, -1, *value, -1);
}

VBSAXDeclHandler_Invoke()

static HRESULT WINAPI VBSAXDeclHandler_Invoke ( IVBSAXDeclHandler *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 1858 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_Invoke(&This->IMXWriter_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
}

VBSAXDeclHandler_QueryInterface()

static HRESULT WINAPI VBSAXDeclHandler_QueryInterface ( IVBSAXDeclHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1820 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

VBSAXDeclHandler_Release()

static ULONG WINAPI VBSAXDeclHandler_Release ( IVBSAXDeclHandler *  iface )

static

Definition at line 1833 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDeclHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

VBSAXDTDHandler_AddRef()

static ULONG WINAPI VBSAXDTDHandler_AddRef ( IVBSAXDTDHandler *  iface )

static

Definition at line 2372 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

VBSAXDTDHandler_GetIDsOfNames()

static HRESULT WINAPI VBSAXDTDHandler_GetIDsOfNames ( IVBSAXDTDHandler *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2396 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_GetIDsOfNames(&This->IMXWriter_iface, riid, rgszNames, cNames, lcid, rgDispId);
}

VBSAXDTDHandler_GetTypeInfo()

static HRESULT WINAPI VBSAXDTDHandler_GetTypeInfo ( IVBSAXDTDHandler *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2390 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_GetTypeInfo(&This->IMXWriter_iface, iTInfo, lcid, ppTInfo);
}

VBSAXDTDHandler_GetTypeInfoCount()

static HRESULT WINAPI VBSAXDTDHandler_GetTypeInfoCount ( IVBSAXDTDHandler *  iface, UINT *  pctinfo  )

static

Definition at line 2384 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_GetTypeInfoCount(&This->IMXWriter_iface, pctinfo);
}

VBSAXDTDHandler_Invoke()

static HRESULT WINAPI VBSAXDTDHandler_Invoke ( IVBSAXDTDHandler *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2403 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_Invoke(&This->IMXWriter_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
}

VBSAXDTDHandler_notationDecl()

static HRESULT WINAPI VBSAXDTDHandler_notationDecl ( IVBSAXDTDHandler *  iface, BSTR *  name, BSTR *  publicId, BSTR *  systemId  )

static

Definition at line 2411 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
 
    TRACE("(%p)->(%p %p %p)\n", This, name, publicId, systemId);
 
    if (!name || !publicId || !systemId)
        return E_POINTER;
 
    return ISAXDTDHandler_notationDecl(&This->ISAXDTDHandler_iface, *name, -1, *publicId, -1, *systemId, -1);
}

VBSAXDTDHandler_QueryInterface()

static HRESULT WINAPI VBSAXDTDHandler_QueryInterface ( IVBSAXDTDHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2366 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

VBSAXDTDHandler_Release()

static ULONG WINAPI VBSAXDTDHandler_Release ( IVBSAXDTDHandler *  iface )

static

Definition at line 2378 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

VBSAXDTDHandler_unparsedEntityDecl()

static HRESULT WINAPI VBSAXDTDHandler_unparsedEntityDecl ( IVBSAXDTDHandler *  iface, BSTR *  name, BSTR *  publicId, BSTR *  systemId, BSTR *  notation  )

static

Definition at line 2423 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXDTDHandler( iface );
 
    TRACE("(%p)->(%p %p %p %p)\n", This, name, publicId, systemId, notation);
 
    if (!name || !publicId || !systemId || !notation)
        return E_POINTER;
 
    return ISAXDTDHandler_unparsedEntityDecl(&This->ISAXDTDHandler_iface, *name, -1, *publicId, -1,
        *systemId, -1, *notation, -1);
}

VBSAXErrorHandler_AddRef()

static ULONG WINAPI VBSAXErrorHandler_AddRef ( IVBSAXErrorHandler *  iface )

static

Definition at line 2508 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

VBSAXErrorHandler_error()

static HRESULT WINAPI VBSAXErrorHandler_error ( IVBSAXErrorHandler *  iface, IVBSAXLocator *  locator, BSTR *  message, LONG  code  )

static

Definition at line 2547 of file mxwriter.c.

{
    FIXME("%p, %p, %p, %lx: stub\n", iface, locator, message, code);
    return E_NOTIMPL;
}

VBSAXErrorHandler_fatalError()

static HRESULT WINAPI VBSAXErrorHandler_fatalError ( IVBSAXErrorHandler *  iface, IVBSAXLocator *  locator, BSTR *  message, LONG  code  )

static

Definition at line 2553 of file mxwriter.c.

{
    FIXME("%p, %p, %p, %lx: stub\n", iface, locator, message, code);
    return E_NOTIMPL;
}

VBSAXErrorHandler_GetIDsOfNames()

static HRESULT WINAPI VBSAXErrorHandler_GetIDsOfNames ( IVBSAXErrorHandler *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2532 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_GetIDsOfNames(&This->IMXWriter_iface, riid, rgszNames, cNames, lcid, rgDispId);
}

VBSAXErrorHandler_GetTypeInfo()

static HRESULT WINAPI VBSAXErrorHandler_GetTypeInfo ( IVBSAXErrorHandler *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2526 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_GetTypeInfo(&This->IMXWriter_iface, iTInfo, lcid, ppTInfo);
}

VBSAXErrorHandler_GetTypeInfoCount()

static HRESULT WINAPI VBSAXErrorHandler_GetTypeInfoCount ( IVBSAXErrorHandler *  iface, UINT *  pctinfo  )

static

Definition at line 2520 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_GetTypeInfoCount(&This->IMXWriter_iface, pctinfo);
}

VBSAXErrorHandler_ignorableWarning()

static HRESULT WINAPI VBSAXErrorHandler_ignorableWarning ( IVBSAXErrorHandler *  iface, IVBSAXLocator *  locator, BSTR *  message, LONG  code  )

static

Definition at line 2559 of file mxwriter.c.

{
    FIXME("%p, %p, %p, %lx: stub\n", iface, locator, message, code);
    return E_NOTIMPL;
}

VBSAXErrorHandler_Invoke()

static HRESULT WINAPI VBSAXErrorHandler_Invoke ( IVBSAXErrorHandler *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2539 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_Invoke(&This->IMXWriter_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
}

VBSAXErrorHandler_QueryInterface()

static HRESULT WINAPI VBSAXErrorHandler_QueryInterface ( IVBSAXErrorHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2502 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

VBSAXErrorHandler_Release()

static ULONG WINAPI VBSAXErrorHandler_Release ( IVBSAXErrorHandler *  iface )

static

Definition at line 2514 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

VBSAXLexicalHandler_AddRef()

static ULONG WINAPI VBSAXLexicalHandler_AddRef ( IVBSAXLexicalHandler *  iface )

static

Definition at line 1939 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_AddRef(&This->IMXWriter_iface);
}

VBSAXLexicalHandler_comment()

static HRESULT WINAPI VBSAXLexicalHandler_comment ( IVBSAXLexicalHandler *  iface, BSTR *  chars  )

static

Definition at line 2032 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, chars);
 
    if (!chars)
        return E_POINTER;
 
    return ISAXLexicalHandler_comment(&This->ISAXLexicalHandler_iface, *chars, -1);
}

VBSAXLexicalHandler_endCDATA()

static HRESULT WINAPI VBSAXLexicalHandler_endCDATA ( IVBSAXLexicalHandler *  iface )

static

Definition at line 2026 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return ISAXLexicalHandler_endCDATA(&This->ISAXLexicalHandler_iface);
}

VBSAXLexicalHandler_endDTD()

static HRESULT WINAPI VBSAXLexicalHandler_endDTD ( IVBSAXLexicalHandler *  iface )

static

Definition at line 1990 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return ISAXLexicalHandler_endDTD(&This->ISAXLexicalHandler_iface);
}

VBSAXLexicalHandler_endEntity()

static HRESULT WINAPI VBSAXLexicalHandler_endEntity ( IVBSAXLexicalHandler *  iface, BSTR *  name  )

static

Definition at line 2008 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, name);
 
    if (!name)
        return E_POINTER;
 
    return ISAXLexicalHandler_endEntity(&This->ISAXLexicalHandler_iface, *name, -1);
}

VBSAXLexicalHandler_GetIDsOfNames()

static HRESULT WINAPI VBSAXLexicalHandler_GetIDsOfNames ( IVBSAXLexicalHandler *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 1963 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_GetIDsOfNames(&This->IMXWriter_iface, riid, rgszNames, cNames, lcid, rgDispId);
}

VBSAXLexicalHandler_GetTypeInfo()

static HRESULT WINAPI VBSAXLexicalHandler_GetTypeInfo ( IVBSAXLexicalHandler *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1957 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_GetTypeInfo(&This->IMXWriter_iface, iTInfo, lcid, ppTInfo);
}

VBSAXLexicalHandler_GetTypeInfoCount()

static HRESULT WINAPI VBSAXLexicalHandler_GetTypeInfoCount ( IVBSAXLexicalHandler *  iface, UINT *  pctinfo  )

static

Definition at line 1951 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_GetTypeInfoCount(&This->IMXWriter_iface, pctinfo);
}

VBSAXLexicalHandler_Invoke()

static HRESULT WINAPI VBSAXLexicalHandler_Invoke ( IVBSAXLexicalHandler *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 1970 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_Invoke(&This->IMXWriter_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
}

VBSAXLexicalHandler_QueryInterface()

static HRESULT WINAPI VBSAXLexicalHandler_QueryInterface ( IVBSAXLexicalHandler *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1932 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
}

VBSAXLexicalHandler_Release()

static ULONG WINAPI VBSAXLexicalHandler_Release ( IVBSAXLexicalHandler *  iface )

static

Definition at line 1945 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return IMXWriter_Release(&This->IMXWriter_iface);
}

VBSAXLexicalHandler_startCDATA()

static HRESULT WINAPI VBSAXLexicalHandler_startCDATA ( IVBSAXLexicalHandler *  iface )

static

Definition at line 2020 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
    return ISAXLexicalHandler_startCDATA(&This->ISAXLexicalHandler_iface);
}

VBSAXLexicalHandler_startDTD()

static HRESULT WINAPI VBSAXLexicalHandler_startDTD ( IVBSAXLexicalHandler *  iface, BSTR *  name, BSTR *  publicId, BSTR *  systemId  )

static

Definition at line 1978 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
 
    TRACE("(%p)->(%p %p %p)\n", This, name, publicId, systemId);
 
    if (!name || !publicId || !systemId)
        return E_POINTER;
 
    return ISAXLexicalHandler_startDTD(&This->ISAXLexicalHandler_iface, *name, -1, *publicId, -1, *systemId, -1);
}

VBSAXLexicalHandler_startEntity()

static HRESULT WINAPI VBSAXLexicalHandler_startEntity ( IVBSAXLexicalHandler *  iface, BSTR *  name  )

static

Definition at line 1996 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXLexicalHandler( iface );
 
    TRACE("(%p)->(%p)\n", This, name);
 
    if (!name)
        return E_POINTER;
 
    return ISAXLexicalHandler_startEntity(&This->ISAXLexicalHandler_iface, *name, -1);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msxml

)

write_data_to_stream()

static HRESULT write_data_to_stream ( mxwriter *  writer )

static

Definition at line 608 of file mxwriter.c.

{
    encoded_buffer *buffer = &writer->buffer.encoded;
    ULONG written = 0;
 
    if (!writer->dest)
        return S_OK;
 
    if (buffer->written == 0)
    {
        if (writer->xml_enc == XmlEncoding_UTF8)
            IStream_Write(writer->dest, buffer->data, 0, &written);
    }
    else
    {
        IStream_Write(writer->dest, buffer->data, buffer->written, &written);
        buffer->written = 0;
    }
 
    return S_OK;
}

Referenced by flush_output_buffer().

write_node_indent()

static void write_node_indent ( mxwriter *  writer )

static

Definition at line 639 of file mxwriter.c.

{
    static const WCHAR tabW[] = {'\t'};
    int indent = writer->indent;
 
    if (!writer->props[MXWriter_Indent] || writer->text)
    {
        writer->text = FALSE;
        return;
    }
 
    /* This is to workaround PI output logic that always puts newline chars,
       document prolog PI does that too. */
    if (!writer->newline)
        write_output_buffer(writer, crlfW, ARRAY_SIZE(crlfW));
    while (indent--)
        write_output_buffer(writer, tabW, 1);
 
    writer->newline = FALSE;
    writer->text = FALSE;
}

Referenced by mxwriter_write_starttag(), SAXContentHandler_endElement(), SAXContentHandler_processingInstruction(), SAXLexicalHandler_comment(), and SAXLexicalHandler_startCDATA().

write_output_buffer()

static HRESULT write_output_buffer ( mxwriter *  writer, const WCHAR *  data, int  len  )

static

Definition at line 335 of file mxwriter.c.

{
    output_buffer *buffer = &writer->buffer;
    encoded_buffer *buff;
    ULONG written;
    int src_len;
 
    if (!len || !*data)
        return S_OK;
 
    src_len = len == -1 ? lstrlenW(data) : len;
    if (writer->dest)
    {
        buff = &buffer->encoded;
 
        if (buffer->code_page == ~0)
        {
            unsigned int avail = buff->allocated - buff->written;
 
            src_len *= sizeof(WCHAR);
            written = min(avail, src_len);
 
            /* fill internal buffer first */
            if (avail)
            {
                memcpy(buff->data + buff->written, data, written);
                data += written / sizeof(WCHAR);
                buff->written += written;
                avail -= written;
                src_len -= written;
            }
 
            if (!avail)
            {
                IStream_Write(writer->dest, buff->data, buff->written, &written);
                buff->written = 0;
                if (src_len >= buff->allocated)
                    IStream_Write(writer->dest, data, src_len, &written);
                else if (src_len)
                {
                    memcpy(buff->data, data, src_len);
                    buff->written += src_len;
                }
            }
        }
        else
        {
            unsigned int avail = buff->allocated - buff->written;
            int length;
 
            length = WideCharToMultiByte(buffer->code_page, 0, data, src_len, NULL, 0, NULL, NULL);
            if (avail >= length)
            {
                length = WideCharToMultiByte(buffer->code_page, 0, data, src_len, buff->data + buff->written, length, NULL, NULL);
                buff->written += length;
            }
            else
            {
                /* drain what we go so far */
                if (buff->written)
                {
                    IStream_Write(writer->dest, buff->data, buff->written, &written);
                    buff->written = 0;
                    avail = buff->allocated;
                }
 
                if (avail >= length)
                {
                    length = WideCharToMultiByte(buffer->code_page, 0, data, src_len, buff->data + buff->written, length, NULL, NULL);
                    buff->written += length;
                }
                else
                {
                    char *mb;
 
                    /* if current chunk is larger than total buffer size, convert it at once using temporary allocated buffer */
                    mb = malloc(length);
                    if (!mb)
                        return E_OUTOFMEMORY;
 
                    length = WideCharToMultiByte(buffer->code_page, 0, data, src_len, mb, length, NULL, NULL);
                    IStream_Write(writer->dest, mb, length, &written);
                    free(mb);
                }
            }
        }
    }
    /* When writer has no output set we have to accumulate everything to return it later in a form of BSTR.
       To achieve that:
 
       - fill a buffer already allocated as part of output buffer;
       - when current buffer is full, allocate another one and switch to it; buffers themselves never grow,
         but are linked together, with head pointing to first allocated buffer after initial one got filled;
       - later during get_output() contents are concatenated by copying one after another to destination BSTR buffer,
         that's returned to the client. */
    else
    {
        /* select last used block */
        if (list_empty(&buffer->blocks))
            buff = &buffer->encoded;
        else
            buff = LIST_ENTRY(list_tail(&buffer->blocks), encoded_buffer, entry);
 
        src_len *= sizeof(WCHAR);
        while (src_len)
        {
            unsigned int avail = buff->allocated - buff->written;
            unsigned int written = min(avail, src_len);
 
            if (avail)
            {
                memcpy(buff->data + buff->written, data, written);
                buff->written += written;
                buffer->utf16_total += written;
                src_len -= written;
            }
 
            /* alloc new block if needed and retry */
            if (src_len)
            {
                encoded_buffer *next = malloc(sizeof(*next));
                HRESULT hr;
 
                if (FAILED(hr = init_encoded_buffer(next))) {
                    free(next);
                    return hr;
                }
 
                list_add_tail(&buffer->blocks, &next->entry);
                buff = next;
            }
        }
    }
 
    return S_OK;
}

Referenced by close_element_starttag(), mxwriter_write_attribute(), mxwriter_write_starttag(), SAXContentHandler_characters(), SAXContentHandler_endElement(), SAXContentHandler_ignorableWhitespace(), SAXContentHandler_processingInstruction(), SAXDeclHandler_attributeDecl(), SAXDeclHandler_elementDecl(), SAXDeclHandler_externalEntityDecl(), SAXDeclHandler_internalEntityDecl(), SAXDTDHandler_notationDecl(), SAXLexicalHandler_comment(), SAXLexicalHandler_endCDATA(), SAXLexicalHandler_endDTD(), SAXLexicalHandler_startCDATA(), SAXLexicalHandler_startDTD(), write_node_indent(), write_output_buffer_quoted(), and write_prolog_buffer().

write_output_buffer_quoted()

static HRESULT write_output_buffer_quoted ( mxwriter *  writer, const WCHAR *  data, int  len  )

static

Definition at line 472 of file mxwriter.c.

{
    write_output_buffer(writer, quotW, 1);
    write_output_buffer(writer, data, len);
    write_output_buffer(writer, quotW, 1);
 
    return S_OK;
}

Referenced by mxwriter_write_attribute(), SAXDeclHandler_attributeDecl(), SAXDeclHandler_externalEntityDecl(), SAXDeclHandler_internalEntityDecl(), SAXDTDHandler_notationDecl(), SAXLexicalHandler_startDTD(), and write_prolog_buffer().

write_prolog_buffer()

static void write_prolog_buffer ( mxwriter *  writer )

static

Definition at line 573 of file mxwriter.c.

{
    static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','='};
    static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','=','\"'};
    static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
    static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
    static const WCHAR noW[] = {'n','o','\"','?','>'};
 
    /* version */
    write_output_buffer(writer, versionW, ARRAY_SIZE(versionW));
    write_output_buffer_quoted(writer, writer->version, -1);
 
    /* encoding */
    write_output_buffer(writer, encodingW, ARRAY_SIZE(encodingW));
 
    if (writer->dest)
        write_output_buffer(writer, writer->encoding, -1);
    else
        write_output_buffer(writer, utf16W, ARRAY_SIZE(utf16W) - 1);
    write_output_buffer(writer, quotW, 1);
 
    /* standalone */
    write_output_buffer(writer, standaloneW, ARRAY_SIZE(standaloneW));
    if (writer->props[MXWriter_Standalone] == VARIANT_TRUE)
        write_output_buffer(writer, yesW, ARRAY_SIZE(yesW));
    else
        write_output_buffer(writer, noW, ARRAY_SIZE(noW));
 
    write_output_buffer(writer, crlfW, ARRAY_SIZE(crlfW));
    writer->newline = TRUE;
}

Referenced by SAXContentHandler_startDocument().

writer_dec_indent()

static void writer_dec_indent ( mxwriter *  This )

inlinestatic

Definition at line 666 of file mxwriter.c.

{
    if (This->indent) This->indent--;
    /* depth is decreased only when element is closed, meaning it's not a text node
       at this point */
    This->text = FALSE;
}

Referenced by SAXContentHandler_endElement().

writer_get_property()

static HRESULT writer_get_property ( const mxwriter *  writer, mxwriter_prop  property, VARIANT_BOOL *  value  )

static

Definition at line 698 of file mxwriter.c.

{
    if (!value) return E_POINTER;
    *value = writer->props[property];
    return S_OK;
}

Referenced by mxwriter_get_byteOrderMark(), mxwriter_get_disableOutputEscaping(), mxwriter_get_indent(), mxwriter_get_omitXMLDeclaration(), and mxwriter_get_standalone().

writer_inc_indent()

static void writer_inc_indent ( mxwriter *  This )

inlinestatic

Definition at line 661 of file mxwriter.c.

{
    This->indent++;
}

Referenced by mxwriter_write_starttag().

writer_set_property()

static HRESULT writer_set_property ( mxwriter *  writer, mxwriter_prop  property, VARIANT_BOOL  value  )

static

Definition at line 691 of file mxwriter.c.

{
    writer->props[property] = value;
    writer->prop_changed = TRUE;
    return S_OK;
}

Referenced by mxwriter_put_byteOrderMark(), mxwriter_put_disableOutputEscaping(), mxwriter_put_indent(), mxwriter_put_omitXMLDeclaration(), and mxwriter_put_standalone().

Variable Documentation

closetagW

const WCHAR closetagW[] = {'>','\r','\n'}

static

Definition at line 41 of file mxwriter.c.

Referenced by SAXContentHandler_endElement(), SAXDeclHandler_attributeDecl(), SAXDeclHandler_elementDecl(), SAXDeclHandler_externalEntityDecl(), SAXDeclHandler_internalEntityDecl(), and SAXDTDHandler_notationDecl().

crlfW

const WCHAR crlfW[] = {'\r','\n'}

static

Definition at line 42 of file mxwriter.c.

Referenced by write_node_indent(), and write_prolog_buffer().

emptyW

const WCHAR emptyW[] = {0}

static

Definition at line 38 of file mxwriter.c.

Referenced by MXAttributes_addAttribute(), and mxwriter_write_starttag().

entityW

const WCHAR entityW[] = {'<','!','E','N','T','I','T','Y',' '}

static

Definition at line 43 of file mxwriter.c.

Referenced by SAXDeclHandler_externalEntityDecl(), and SAXDeclHandler_internalEntityDecl().

iso_8859_13W

const WCHAR iso_8859_13W[] = {'i','s','o','-','8','8','5','9','-','1','3',0}

static

Definition at line 87 of file mxwriter.c.

iso_8859_15W

const WCHAR iso_8859_15W[] = {'i','s','o','-','8','8','5','9','-','1','5',0}

static

Definition at line 88 of file mxwriter.c.

iso_8859_1W

const WCHAR iso_8859_1W[] = {'i','s','o','-','8','8','5','9','-','1',0}

static

Definition at line 80 of file mxwriter.c.

iso_8859_2W

const WCHAR iso_8859_2W[] = {'i','s','o','-','8','8','5','9','-','2',0}

static

Definition at line 81 of file mxwriter.c.

iso_8859_3W

const WCHAR iso_8859_3W[] = {'i','s','o','-','8','8','5','9','-','3',0}

static

Definition at line 82 of file mxwriter.c.

iso_8859_4W

const WCHAR iso_8859_4W[] = {'i','s','o','-','8','8','5','9','-','4',0}

static

Definition at line 83 of file mxwriter.c.

iso_8859_5W

const WCHAR iso_8859_5W[] = {'i','s','o','-','8','8','5','9','-','5',0}

static

Definition at line 84 of file mxwriter.c.

iso_8859_7W

const WCHAR iso_8859_7W[] = {'i','s','o','-','8','8','5','9','-','7',0}

static

Definition at line 85 of file mxwriter.c.

iso_8859_9W

const WCHAR iso_8859_9W[] = {'i','s','o','-','8','8','5','9','-','9',0}

static

Definition at line 86 of file mxwriter.c.

MXAttributesVtbl

const IMXAttributesVtbl MXAttributesVtbl

static

Initial value:

= {
    MXAttributes_QueryInterface,
    MXAttributes_AddRef,
    MXAttributes_Release,
    MXAttributes_GetTypeInfoCount,
    MXAttributes_GetTypeInfo,
    MXAttributes_GetIDsOfNames,
    MXAttributes_Invoke,
    MXAttributes_addAttribute,
    MXAttributes_addAttributeFromIndex,
    MXAttributes_clear,
    MXAttributes_removeAttribute,
    MXAttributes_setAttribute,
    MXAttributes_setAttributes,
    MXAttributes_setLocalName,
    MXAttributes_setQName,
    MXAttributes_setURI,
    MXAttributes_setValue
}

Definition at line 2928 of file mxwriter.c.

Referenced by SAXAttributes_create().

mxattrs_dispex

dispex_static_data_t mxattrs_dispex

static

Initial value:

= {
    NULL,
    IMXAttributes_tid,
    NULL,
    mxattrs_iface_tids
}

Definition at line 3548 of file mxwriter.c.

Referenced by SAXAttributes_create().

mxattrs_iface_tids

const tid_t mxattrs_iface_tids[]

static

Initial value:

= {
    IMXAttributes_tid,
    0
}

Definition at line 3543 of file mxwriter.c.

mxwriter_dispex

dispex_static_data_t mxwriter_dispex

static

Initial value:

= {
    NULL,
    IMXWriter_tid,
    NULL,
    mxwriter_iface_tids
}

Definition at line 2583 of file mxwriter.c.

Referenced by MXWriter_create().

mxwriter_iface_tids

const tid_t mxwriter_iface_tids[]

static

Initial value:

= {
    IMXWriter_tid,
    0
}

Definition at line 2578 of file mxwriter.c.

MXWriterVtbl

const struct IMXWriterVtbl MXWriterVtbl

static

Initial value:

=
{
    mxwriter_QueryInterface,
    mxwriter_AddRef,
    mxwriter_Release,
    mxwriter_GetTypeInfoCount,
    mxwriter_GetTypeInfo,
    mxwriter_GetIDsOfNames,
    mxwriter_Invoke,
    mxwriter_put_output,
    mxwriter_get_output,
    mxwriter_put_encoding,
    mxwriter_get_encoding,
    mxwriter_put_byteOrderMark,
    mxwriter_get_byteOrderMark,
    mxwriter_put_indent,
    mxwriter_get_indent,
    mxwriter_put_standalone,
    mxwriter_get_standalone,
    mxwriter_put_omitXMLDeclaration,
    mxwriter_get_omitXMLDeclaration,
    mxwriter_put_version,
    mxwriter_get_version,
    mxwriter_put_disableOutputEscaping,
    mxwriter_get_disableOutputEscaping,
    mxwriter_flush
}

Definition at line 1148 of file mxwriter.c.

Referenced by MXWriter_create().

publicW

const WCHAR publicW[] = {'P','U','B','L','I','C',' '}

static

Definition at line 44 of file mxwriter.c.

Referenced by reader_parse_externalid(), SAXDeclHandler_externalEntityDecl(), SAXDTDHandler_notationDecl(), SAXLexicalHandler_startDTD(), and xmlwriter_WriteDocType().

quotW

const WCHAR quotW[] = {'\"'}

static

Definition at line 40 of file mxwriter.c.

Referenced by write_output_buffer_quoted(), and write_prolog_buffer().

SAXAttributesVtbl

const ISAXAttributesVtbl SAXAttributesVtbl

static

Initial value:

= {
    SAXAttributes_QueryInterface,
    SAXAttributes_AddRef,
    SAXAttributes_Release,
    SAXAttributes_getLength,
    SAXAttributes_getURI,
    SAXAttributes_getLocalName,
    SAXAttributes_getQName,
    SAXAttributes_getName,
    SAXAttributes_getIndexFromName,
    SAXAttributes_getIndexFromQName,
    SAXAttributes_getType,
    SAXAttributes_getTypeFromName,
    SAXAttributes_getTypeFromQName,
    SAXAttributes_getValue,
    SAXAttributes_getValueFromName,
    SAXAttributes_getValueFromQName
}

Definition at line 3199 of file mxwriter.c.

Referenced by SAXAttributes_create().

SAXContentHandlerVtbl

const struct ISAXContentHandlerVtbl SAXContentHandlerVtbl

static

Initial value:

=
{
    SAXContentHandler_QueryInterface,
    SAXContentHandler_AddRef,
    SAXContentHandler_Release,
    SAXContentHandler_putDocumentLocator,
    SAXContentHandler_startDocument,
    SAXContentHandler_endDocument,
    SAXContentHandler_startPrefixMapping,
    SAXContentHandler_endPrefixMapping,
    SAXContentHandler_startElement,
    SAXContentHandler_endElement,
    SAXContentHandler_characters,
    SAXContentHandler_ignorableWhitespace,
    SAXContentHandler_processingInstruction,
    SAXContentHandler_skippedEntity
}

Definition at line 1489 of file mxwriter.c.

Referenced by MXWriter_create().

SAXDeclHandlerVtbl

const ISAXDeclHandlerVtbl SAXDeclHandlerVtbl

static

Initial value:

= {
    SAXDeclHandler_QueryInterface,
    SAXDeclHandler_AddRef,
    SAXDeclHandler_Release,
    SAXDeclHandler_elementDecl,
    SAXDeclHandler_attributeDecl,
    SAXDeclHandler_internalEntityDecl,
    SAXDeclHandler_externalEntityDecl
}

Definition at line 1809 of file mxwriter.c.

Referenced by MXWriter_create().

SAXDTDHandlerVtbl

const ISAXDTDHandlerVtbl SAXDTDHandlerVtbl

static

Initial value:

= {
    SAXDTDHandler_QueryInterface,
    SAXDTDHandler_AddRef,
    SAXDTDHandler_Release,
    SAXDTDHandler_notationDecl,
    SAXDTDHandler_unparsedEntityDecl
}

Definition at line 2357 of file mxwriter.c.

Referenced by MXWriter_create().

SAXErrorHandlerVtbl

const ISAXErrorHandlerVtbl SAXErrorHandlerVtbl

static

Initial value:

= {
    SAXErrorHandler_QueryInterface,
    SAXErrorHandler_AddRef,
    SAXErrorHandler_Release,
    SAXErrorHandler_error,
    SAXErrorHandler_fatalError,
    SAXErrorHandler_ignorableWarning
}

Definition at line 2492 of file mxwriter.c.

Referenced by MXWriter_create().

SAXLexicalHandlerVtbl

const struct ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl

static

Initial value:

=
{
    SAXLexicalHandler_QueryInterface,
    SAXLexicalHandler_AddRef,
    SAXLexicalHandler_Release,
    SAXLexicalHandler_startDTD,
    SAXLexicalHandler_endDTD,
    SAXLexicalHandler_startEntity,
    SAXLexicalHandler_endEntity,
    SAXLexicalHandler_startCDATA,
    SAXLexicalHandler_endCDATA,
    SAXLexicalHandler_comment
}

Definition at line 1651 of file mxwriter.c.

Referenced by MXWriter_create().

spaceW

const WCHAR spaceW[] = {' '}

static

Definition at line 39 of file mxwriter.c.

Referenced by build_proxy_connect_string(), build_request_string(), CreateColorTransformA(), decode_string(), MCIWND_UpdateState(), mxwriter_write_attribute(), SAXContentHandler_processingInstruction(), SAXDeclHandler_attributeDecl(), SAXDeclHandler_elementDecl(), SAXDeclHandler_externalEntityDecl(), SAXDeclHandler_internalEntityDecl(), SAXDTDHandler_notationDecl(), SAXLexicalHandler_startDTD(), and test_SHFormatDateTimeW().

systemW

const WCHAR systemW[] = {'S','Y','S','T','E','M',' '}

static

Definition at line 45 of file mxwriter.c.

Referenced by get_service_startmode(), reader_parse_externalid(), SAXDeclHandler_externalEntityDecl(), SAXDTDHandler_notationDecl(), SAXLexicalHandler_startDTD(), and xmlwriter_WriteDocType().

utf16W

const WCHAR utf16W[] = {'U','T','F','-','1','6',0}

static

Definition at line 89 of file mxwriter.c.

Referenced by MXWriter_create(), test_bom(), test_writeroutput(), and write_prolog_buffer().

utf8W

const WCHAR utf8W[] = {'U','T','F','-','8',0}

static

Definition at line 90 of file mxwriter.c.

Referenced by request_get_codepage(), test_IWinHttpRequest(), test_IWinHttpRequest_Invoke(), and winhttp_request_put_Option().

VBSAXAttributesVtbl

const struct IVBSAXAttributesVtbl VBSAXAttributesVtbl

static

Initial value:

=
{
    VBSAXAttributes_QueryInterface,
    VBSAXAttributes_AddRef,
    VBSAXAttributes_Release,
    VBSAXAttributes_GetTypeInfoCount,
    VBSAXAttributes_GetTypeInfo,
    VBSAXAttributes_GetIDsOfNames,
    VBSAXAttributes_Invoke,
    VBSAXAttributes_get_length,
    VBSAXAttributes_getURI,
    VBSAXAttributes_getLocalName,
    VBSAXAttributes_getQName,
    VBSAXAttributes_getIndexFromName,
    VBSAXAttributes_getIndexFromQName,
    VBSAXAttributes_getType,
    VBSAXAttributes_getTypeFromName,
    VBSAXAttributes_getTypeFromQName,
    VBSAXAttributes_getValue,
    VBSAXAttributes_getValueFromName,
    VBSAXAttributes_getValueFromQName
}

Definition at line 3520 of file mxwriter.c.

Referenced by SAXAttributes_create().

VBSAXContentHandlerVtbl

const IVBSAXContentHandlerVtbl VBSAXContentHandlerVtbl

static

Initial value:

= {
    VBSAXContentHandler_QueryInterface,
    VBSAXContentHandler_AddRef,
    VBSAXContentHandler_Release,
    VBSAXContentHandler_GetTypeInfoCount,
    VBSAXContentHandler_GetTypeInfo,
    VBSAXContentHandler_GetIDsOfNames,
    VBSAXContentHandler_Invoke,
    VBSAXContentHandler_putref_documentLocator,
    VBSAXContentHandler_startDocument,
    VBSAXContentHandler_endDocument,
    VBSAXContentHandler_startPrefixMapping,
    VBSAXContentHandler_endPrefixMapping,
    VBSAXContentHandler_startElement,
    VBSAXContentHandler_endElement,
    VBSAXContentHandler_characters,
    VBSAXContentHandler_ignorableWhitespace,
    VBSAXContentHandler_processingInstruction,
    VBSAXContentHandler_skippedEntity
}

Definition at line 2263 of file mxwriter.c.

Referenced by MXWriter_create().

VBSAXDeclHandlerVtbl

const IVBSAXDeclHandlerVtbl VBSAXDeclHandlerVtbl

static

Initial value:

= {
    VBSAXDeclHandler_QueryInterface,
    VBSAXDeclHandler_AddRef,
    VBSAXDeclHandler_Release,
    VBSAXDeclHandler_GetTypeInfoCount,
    VBSAXDeclHandler_GetTypeInfo,
    VBSAXDeclHandler_GetIDsOfNames,
    VBSAXDeclHandler_Invoke,
    VBSAXDeclHandler_elementDecl,
    VBSAXDeclHandler_attributeDecl,
    VBSAXDeclHandler_internalEntityDecl,
    VBSAXDeclHandler_externalEntityDecl
}

Definition at line 1917 of file mxwriter.c.

Referenced by MXWriter_create().

VBSAXDTDHandlerVtbl

const IVBSAXDTDHandlerVtbl VBSAXDTDHandlerVtbl

static

Initial value:

= {
    VBSAXDTDHandler_QueryInterface,
    VBSAXDTDHandler_AddRef,
    VBSAXDTDHandler_Release,
    VBSAXDTDHandler_GetTypeInfoCount,
    VBSAXDTDHandler_GetTypeInfo,
    VBSAXDTDHandler_GetIDsOfNames,
    VBSAXDTDHandler_Invoke,
    VBSAXDTDHandler_notationDecl,
    VBSAXDTDHandler_unparsedEntityDecl
}

Definition at line 2437 of file mxwriter.c.

Referenced by MXWriter_create().

VBSAXErrorHandlerVtbl

const IVBSAXErrorHandlerVtbl VBSAXErrorHandlerVtbl

static

Initial value:

= {
    VBSAXErrorHandler_QueryInterface,
    VBSAXErrorHandler_AddRef,
    VBSAXErrorHandler_Release,
    VBSAXErrorHandler_GetTypeInfoCount,
    VBSAXErrorHandler_GetTypeInfo,
    VBSAXErrorHandler_GetIDsOfNames,
    VBSAXErrorHandler_Invoke,
    VBSAXErrorHandler_error,
    VBSAXErrorHandler_fatalError,
    VBSAXErrorHandler_ignorableWarning
}

Definition at line 2565 of file mxwriter.c.

Referenced by MXWriter_create().

VBSAXLexicalHandlerVtbl

const IVBSAXLexicalHandlerVtbl VBSAXLexicalHandlerVtbl

static

Initial value:

= {
    VBSAXLexicalHandler_QueryInterface,
    VBSAXLexicalHandler_AddRef,
    VBSAXLexicalHandler_Release,
    VBSAXLexicalHandler_GetTypeInfoCount,
    VBSAXLexicalHandler_GetTypeInfo,
    VBSAXLexicalHandler_GetIDsOfNames,
    VBSAXLexicalHandler_Invoke,
    VBSAXLexicalHandler_startDTD,
    VBSAXLexicalHandler_endDTD,
    VBSAXLexicalHandler_startEntity,
    VBSAXLexicalHandler_endEntity,
    VBSAXLexicalHandler_startCDATA,
    VBSAXLexicalHandler_endCDATA,
    VBSAXLexicalHandler_comment
}

Definition at line 2044 of file mxwriter.c.

Referenced by MXWriter_create().

windows_1250W

const WCHAR windows_1250W[] = {'w','i','n','d','o','w','s','-','1','2','5','0',0}

static

Definition at line 91 of file mxwriter.c.

windows_1251W

const WCHAR windows_1251W[] = {'w','i','n','d','o','w','s','-','1','2','5','1',0}

static

Definition at line 92 of file mxwriter.c.

windows_1252W

const WCHAR windows_1252W[] = {'w','i','n','d','o','w','s','-','1','2','5','2',0}

static

Definition at line 93 of file mxwriter.c.

windows_1253W

const WCHAR windows_1253W[] = {'w','i','n','d','o','w','s','-','1','2','5','3',0}

static

Definition at line 94 of file mxwriter.c.

windows_1254W

const WCHAR windows_1254W[] = {'w','i','n','d','o','w','s','-','1','2','5','4',0}

static

Definition at line 95 of file mxwriter.c.

windows_1255W

const WCHAR windows_1255W[] = {'w','i','n','d','o','w','s','-','1','2','5','5',0}

static

Definition at line 96 of file mxwriter.c.

windows_1256W

const WCHAR windows_1256W[] = {'w','i','n','d','o','w','s','-','1','2','5','6',0}

static

Definition at line 97 of file mxwriter.c.

windows_1257W

const WCHAR windows_1257W[] = {'w','i','n','d','o','w','s','-','1','2','5','7',0}

static

Definition at line 98 of file mxwriter.c.

windows_1258W

const WCHAR windows_1258W[] = {'w','i','n','d','o','w','s','-','1','2','5','8',0}

static

Definition at line 99 of file mxwriter.c.

xml_encoding_map

const struct xml_encoding_data xml_encoding_map[]

static

Initial value:

= {
    { iso_8859_1W,  XmlEncoding_ISO_8859_1,  28591 },
    { iso_8859_13W, XmlEncoding_ISO_8859_13, 28603 },
    { iso_8859_15W, XmlEncoding_ISO_8859_15, 28605 },
    { iso_8859_2W,  XmlEncoding_ISO_8859_2,  28592 },
    { iso_8859_3W,  XmlEncoding_ISO_8859_3,  28593 },
    { iso_8859_4W,  XmlEncoding_ISO_8859_4,  28594 },
    { iso_8859_5W,  XmlEncoding_ISO_8859_5,  28595 },
    { iso_8859_7W,  XmlEncoding_ISO_8859_7,  28597 },
    { iso_8859_9W,  XmlEncoding_ISO_8859_9,  28599 },
    { utf16W,       XmlEncoding_UTF16,          ~0 },
    { utf8W,        XmlEncoding_UTF8,      CP_UTF8 },
    { windows_1250W,XmlEncoding_windows_1250, 1250 },
    { windows_1251W,XmlEncoding_windows_1251, 1251 },
    { windows_1252W,XmlEncoding_windows_1252, 1252 },
    { windows_1253W,XmlEncoding_windows_1253, 1253 },
    { windows_1254W,XmlEncoding_windows_1254, 1254 },
    { windows_1255W,XmlEncoding_windows_1255, 1255 },
    { windows_1256W,XmlEncoding_windows_1256, 1256 },
    { windows_1257W,XmlEncoding_windows_1257, 1257 },
    { windows_1258W,XmlEncoding_windows_1258, 1258 }
}

Definition at line 101 of file mxwriter.c.

Referenced by get_code_page(), and parse_encoding_name().