mxwriter.c File Reference

#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "msxml6.h"
#include "wine/debug.h"
#include "wine/list.h"
#include "msxml_private.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_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 void	reset_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 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 112 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 102 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_Unknown
XmlEncoding_USASCII
XmlEncoding_UTF16
XmlEncoding_UTF8
XmlEncoding_Unknown

Definition at line 53 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_Unknown
} xml_encoding;

Function Documentation

close_element_starttag()

static void close_element_starttag ( mxwriter *  writer )

static

Definition at line 610 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 460 of file mxwriter.c.

{
    encoded_buffer *cur, *cur2;
 
    heap_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);
        heap_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 reset_output_buffer().

flush_output_buffer()

static HRESULT flush_output_buffer ( mxwriter *  This )

inlinestatic

Definition at line 661 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 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 260 of file mxwriter.c.

{
    heap_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 299 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);
        heap_free(cur);
    }
}

Referenced by mxwriter_Release().

get_attribute_byindex()

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

static

Definition at line 2818 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 265 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 488 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 = heap_alloc(conv_len*sizeof(WCHAR));
 
    while (p)
    {
        if (ptr - ret > conv_len - grow_thresh)
        {
            int written = ptr - ret;
            conv_len *= 2;
            ptr = ret = heap_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 198 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 691 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 203 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 696 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 716 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 726 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 736 of file mxwriter.c.

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

Referenced by SAXErrorHandler_AddRef(), SAXErrorHandler_error(), SAXErrorHandler_fatalError(), SAXErrorHandler_ignorableWarning(), SAXErrorHandler_QueryInterface(), and SAXErrorHandler_Release().

impl_from_ISAXLexicalHandler()

static mxwriter * impl_from_ISAXLexicalHandler ( ISAXLexicalHandler *  iface )

inlinestatic

Definition at line 706 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 208 of file mxwriter.c.

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

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

impl_from_IVBSAXContentHandler()

static mxwriter * impl_from_IVBSAXContentHandler ( IVBSAXContentHandler *  iface )

inlinestatic

Definition at line 701 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 721 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 731 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 741 of file mxwriter.c.

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

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

impl_from_IVBSAXLexicalHandler()

static mxwriter * impl_from_IVBSAXLexicalHandler ( IVBSAXLexicalHandler *  iface )

inlinestatic

Definition at line 711 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 247 of file mxwriter.c.

{
    const int initial_len = 0x1000;
    buffer->data = heap_alloc(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 281 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 2759 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 2788 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 2683 of file mxwriter.c.

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

MXAttributes_clear()

static HRESULT WINAPI MXAttributes_clear ( IMXAttributes *  iface )

static

Definition at line 2796 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 2730 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 2724 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 2718 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 213 of file mxwriter.c.

{
    if (This->length < This->allocated) return S_OK;
 
    This->allocated *= 2;
    This->attr = heap_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 2743 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 2646 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 2691 of file mxwriter.c.

{
    mxattributes *This = impl_from_IMXAttributes( iface );
    LONG ref = InterlockedDecrement( &This->ref );
 
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (ref == 0)
    {
        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);
        }
 
        heap_free(This->attr);
        heap_free(This);
    }
 
    return ref;
}

MXAttributes_removeAttribute()

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

static

Definition at line 2824 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 2846 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 2855 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 2862 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 2878 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 2893 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 2908 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 815 of file mxwriter.c.

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

MXWriter_create()

HRESULT MXWriter_create	(	MSXML_VERSION	version,
		void **	ppObj
	)

Definition at line 2585 of file mxwriter.c.

{
    static const WCHAR version10W[] = {'1','.','0',0};
    mxwriter *This;
    HRESULT hr;
 
    TRACE("(%p)\n", ppObj);
 
    This = heap_alloc( 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);
        heap_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 1127 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 1030 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 1119 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 1008 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 1046 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 1078 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 932 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 1062 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 1100 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 865 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 855 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 849 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 875 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 1022 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 1111 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 981 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);
    reset_output_buffer(This);
    return S_OK;
}

mxwriter_put_indent()

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

static

Definition at line 1038 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 1070 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 886 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;
        reset_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. */
            reset_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 1054 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 1086 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 746 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 825 of file mxwriter.c.

{
    mxwriter *This = impl_from_IMXWriter( iface );
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\n", This, 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);
        heap_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 1256 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);
        heap_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 1276 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 223 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 = strcmpiW(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().

reset_output_buffer()

static void reset_output_buffer ( mxwriter *  This )

inlinestatic

Definition at line 672 of file mxwriter.c.

{
    close_output_buffer(This);
}

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

SAXAttributes_AddRef()

static ULONG WINAPI SAXAttributes_AddRef ( ISAXAttributes *  iface )

static

Definition at line 2949 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 3553 of file mxwriter.c.

{
    static const int default_count = 10;
    mxattributes *This;
 
    TRACE("(%p)\n", ppObj);
 
    This = heap_alloc( 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 = heap_alloc(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 3048 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 (strncmpW(uri, This->attr[i].uri, uri_len)) continue;
 
        if (len != SysStringLen(This->attr[i].local)) continue;
        if (strncmpW(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 3077 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 (strncmpW(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 2961 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 2990 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 3021 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 3006 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 3102 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 3120 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 3129 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 2974 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 3137 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 3155 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 3175 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 2943 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 2955 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 1172 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 1381 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);
            heap_free(escaped);
        }
    }
 
    return S_OK;
}

SAXContentHandler_endDocument()

static HRESULT WINAPI SAXContentHandler_endDocument ( ISAXContentHandler *  iface )

static

Definition at line 1226 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 1340 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 1246 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 1416 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 1432 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 1184 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 1163 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 1178 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 1465 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 1193 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) {
        reset_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 1290 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 1234 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 1659 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 1694 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 1671 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 1760 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 1736 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 1652 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 1665 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 2276 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 2288 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 2270 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 2282 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 2330 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 2442 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 2454 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
 
    FIXME("(%p)->(%p %s 0x%08x)\n", This, 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 2464 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
 
    FIXME("(%p)->(%p %s 0x%08x)\n", This, 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 2474 of file mxwriter.c.

{
    mxwriter *This = impl_from_ISAXErrorHandler( iface );
 
    FIXME("(%p)->(%p %s 0x%08x)\n", This, 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 2436 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 2448 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 1501 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 1616 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 1603 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 1563 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 1582 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 1494 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 1507 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 1589 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 1513 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 1575 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 652 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 3223 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 3312 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 3255 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
          lcid, rgDispId);
 
    if(!rgszNames || cNames == 0 || !rgDispId)
        return E_INVALIDARG;
 
    hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

VBSAXAttributes_getIndexFromName()

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

static

Definition at line 3378 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 3385 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 3338 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 3358 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 3392 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 3412 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 3434 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 3246 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
    return get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
}

VBSAXAttributes_GetTypeInfoCount()

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

static

Definition at line 3235 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 3318 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 3455 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 3475 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 3497 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 3283 of file mxwriter.c.

{
    mxattributes *This = impl_from_IVBSAXAttributes( iface );
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
          lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXAttributes_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 3213 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 3229 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 2054 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 2200 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 2106 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 2184 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 2124 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 2078 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 2072 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 2066 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 2212 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 2085 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 2224 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 2093 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 2048 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 2060 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 2237 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 2100 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 2136 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXContentHandler( iface );
 
    TRACE("(%p)->(%p %p %p %p)\n", This, namespaceURI, localName, QName, attrs);
 
    if (!namespaceURI || !localName || !QName)
        return E_POINTER;
 
    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 2112 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 1813 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 1864 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 1852 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 1890 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 1837 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 1831 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 1825 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 1878 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 1844 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 1806 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 1819 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 2358 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 2382 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 2376 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 2370 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 2389 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 2397 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 2352 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 2364 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 2409 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 2500 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 2539 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    FIXME("(%p)->(%p %p %x): stub\n", This, 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 2546 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    FIXME("(%p)->(%p %p %x): stub\n", This, 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 2524 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 2518 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 2512 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 2553 of file mxwriter.c.

{
    mxwriter *This = impl_from_IVBSAXErrorHandler( iface );
    FIXME("(%p)->(%p %p %x): stub\n", This, 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 2531 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 2494 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 2506 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 1925 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 2018 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 2012 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 1976 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 1994 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 1949 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 1943 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 1937 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 1956 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 1918 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 1931 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 2006 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 1964 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 1982 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 586 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 617 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 313 of file mxwriter.c.

{
    output_buffer *buffer = &writer->buffer;
    encoded_buffer *buff;
    unsigned int written;
    int src_len;
 
    if (!len || !*data)
        return S_OK;
 
    src_len = len == -1 ? strlenW(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 = heap_alloc(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);
                    heap_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 = heap_alloc(sizeof(*next));
                HRESULT hr;
 
                if (FAILED(hr = init_encoded_buffer(next))) {
                    heap_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 450 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 551 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 644 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 684 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 639 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 677 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 46 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 47 of file mxwriter.c.

Referenced by build_proxy_connect_string(), build_request_string(), test_Read(), test_ReadAll(), test_WriteLine(), textstream_writecrlf(), write_node_indent(), and write_prolog_buffer().

emptyW

const WCHAR emptyW[] = {0}

static

Definition at line 43 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 48 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 83 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 84 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 76 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 77 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 78 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 79 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 80 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 81 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 82 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 2923 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 3546 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 3541 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 2578 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 2573 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 1134 of file mxwriter.c.

Referenced by MXWriter_create().

publicW

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

static

Definition at line 49 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 45 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 3194 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 1475 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 1795 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 2343 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 2484 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 1637 of file mxwriter.c.

Referenced by MXWriter_create().

spaceW

const WCHAR spaceW[] = {' '}

static

Definition at line 44 of file mxwriter.c.

Referenced by build_proxy_connect_string(), build_request_string(), CreateColorTransformA(), decode_string(), MCIWND_UpdateState(), ME_GetRunSizeCommon(), mxwriter_write_attribute(), para_num_init(), 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 50 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 85 of file mxwriter.c.

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

utf8W

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

static

Definition at line 86 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 3518 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 2249 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 1903 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 2423 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 2560 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 2030 of file mxwriter.c.

Referenced by MXWriter_create().

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 }
}

Definition at line 88 of file mxwriter.c.

Referenced by get_code_page(), and parse_encoding_name().