reader.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "initguid.h"
#include "objbase.h"
#include "xmllite.h"
#include "xmllite_private.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for reader.c:

Go to the source code of this file.

Classes
struct	xml_encoding_data
struct	encoded_buffer
struct	xmlreaderinput
struct	strval
struct	reader_position
struct	attribute
struct	element
struct	ns
struct	xmlreader
struct	input_buffer

Macros
#define	COBJMACROS

Typedefs
typedef struct input_buffer	input_buffer

Enumerations
enum	XmlReaderInternalState {   XmlReadInState_Initial , XmlReadInState_XmlDecl , XmlReadInState_Misc_DTD , XmlReadInState_DTD ,   XmlReadInState_DTD_Misc , XmlReadInState_Element , XmlReadInState_Content , XmlReadInState_MiscEnd ,   XmlReadInState_Eof }
enum	XmlReaderResumeState {   XmlReadResumeState_Initial , XmlReadResumeState_PITarget , XmlReadResumeState_PIBody , XmlReadResumeState_CDATA ,   XmlReadResumeState_Comment , XmlReadResumeState_STag , XmlReadResumeState_CharData , XmlReadResumeState_Whitespace }
enum	XmlReaderResume { XmlReadResume_Name , XmlReadResume_Local , XmlReadResume_Body , XmlReadResume_Last }
enum	XmlReaderStringValue {   StringValue_LocalName , StringValue_Prefix , StringValue_QualifiedName , StringValue_Value ,   StringValue_Last }
enum	attribute_flags { ATTRIBUTE_NS_DEFINITION = 0x1 , ATTRIBUTE_DEFAULT_NS_DEFINITION = 0x2 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (xmllite)
	DEFINE_GUID (IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda)
BOOL	is_namestartchar (WCHAR ch)
static const char *	debugstr_nodetype (XmlNodeType nodetype)
static const char *	debugstr_reader_prop (XmlReaderProperty prop)
const WCHAR *	get_encoding_name (xml_encoding encoding)
xml_encoding	get_encoding_from_codepage (UINT codepage)
static xmlreader *	impl_from_IXmlReader (IXmlReader *iface)
static xmlreaderinput *	impl_from_IXmlReaderInput (IXmlReaderInput *iface)
static void *	reader_alloc (xmlreader *reader, size_t len)
static void *	reader_alloc_zero (xmlreader *reader, size_t len)
static void	reader_free (xmlreader *reader, void *mem)
static WCHAR *	reader_get_ptr2 (const xmlreader *reader, UINT offset)
static WCHAR *	reader_get_strptr (const xmlreader *reader, const strval *v)
static HRESULT	reader_strvaldup (xmlreader *reader, const strval *src, strval *dest)
static void *	readerinput_alloc (xmlreaderinput *input, size_t len)
static void *	readerinput_realloc (xmlreaderinput *input, void *mem, size_t len)
static void	readerinput_free (xmlreaderinput *input, void *mem)
static WCHAR *	readerinput_strdupW (xmlreaderinput *input, const WCHAR *str)
static void	reader_free_strvalued (xmlreader *reader, strval *v)
static void	reader_clear_attrs (xmlreader *reader)
static HRESULT	reader_add_attr (xmlreader *reader, strval *prefix, strval *localname, strval *qname, strval *value, const struct reader_position *position, unsigned int flags)
static struct element *	reader_get_element (xmlreader *reader)
static void	reader_init_strvalue (UINT start, UINT len, strval *v)
static const char *	debug_strval (const xmlreader *reader, const strval *v)
static void	reader_init_cstrvalue (WCHAR *str, UINT len, strval *v)
static void	reader_free_strvalue (xmlreader *reader, XmlReaderStringValue type)
static void	reader_free_strvalues (xmlreader *reader)
static int	strval_eq (const xmlreader *reader, const strval *str1, const strval *str2)
static void	reader_clear_elements (xmlreader *reader)
static struct ns *	reader_lookup_ns (xmlreader *reader, const strval *prefix)
static HRESULT	reader_inc_depth (xmlreader *reader)
static void	reader_dec_depth (xmlreader *reader)
static HRESULT	reader_push_ns (xmlreader *reader, const strval *prefix, const strval *uri, BOOL def)
static void	reader_free_element (xmlreader *reader, struct element *element)
static void	reader_mark_ns_nodes (xmlreader *reader, struct element *element)
static HRESULT	reader_push_element (xmlreader *reader, strval *prefix, strval *localname, strval *qname, const struct reader_position *position)
static void	reader_pop_ns_nodes (xmlreader *reader, struct element *element)
static void	reader_pop_element (xmlreader *reader)
static void	reader_set_strvalue (xmlreader *reader, XmlReaderStringValue type, const strval *value)
static int	is_reader_pending (xmlreader *reader)
static HRESULT	init_encoded_buffer (xmlreaderinput *input, encoded_buffer *buffer)
static void	free_encoded_buffer (xmlreaderinput *input, encoded_buffer *buffer)
HRESULT	get_code_page (xml_encoding encoding, UINT *cp)
xml_encoding	parse_encoding_name (const WCHAR *name, int len)
static HRESULT	alloc_input_buffer (xmlreaderinput *input)
static void	free_input_buffer (input_buffer *buffer)
static void	readerinput_release_stream (xmlreaderinput *readerinput)
static HRESULT	readerinput_query_for_stream (xmlreaderinput *readerinput)
static HRESULT	readerinput_growraw (xmlreaderinput *readerinput)
static void	readerinput_grow (xmlreaderinput *readerinput, int length)
static BOOL	readerinput_is_utf8 (xmlreaderinput *readerinput)
static HRESULT	readerinput_detectencoding (xmlreaderinput *readerinput, xml_encoding *enc)
static int	readerinput_get_utf8_convlen (xmlreaderinput *readerinput)
static int	readerinput_get_convlen (xmlreaderinput *readerinput)
static void	readerinput_shrinkraw (xmlreaderinput *readerinput, int len)
static void	fixup_buffer_cr (encoded_buffer *buffer, int off)
static void	readerinput_switchencoding (xmlreaderinput *readerinput, xml_encoding enc)
static void	reader_shrink (xmlreader *reader)
static HRESULT	reader_more (xmlreader *reader)
static UINT	reader_get_cur (xmlreader *reader)
static WCHAR *	reader_get_ptr (xmlreader *reader)
static int	reader_cmp (xmlreader *reader, const WCHAR *str)
static void	reader_update_position (xmlreader *reader, WCHAR ch)
static void	reader_skipn (xmlreader *reader, int n)
static int	reader_skipspaces (xmlreader *reader)
static HRESULT	reader_parse_versionnum (xmlreader *reader, strval *val)
static HRESULT	reader_parse_eq (xmlreader *reader)
static BOOL	reader_is_quote (xmlreader *reader)
static HRESULT	reader_parse_versioninfo (xmlreader *reader)
static BOOL	is_wchar_encname (WCHAR ch)
static HRESULT	reader_parse_encname (xmlreader *reader, strval *val)
static HRESULT	reader_parse_encdecl (xmlreader *reader, BOOL *spaces)
static HRESULT	reader_parse_sddecl (xmlreader *reader, BOOL spaces)
static HRESULT	reader_parse_xmldecl (xmlreader *reader)
static HRESULT	reader_parse_comment (xmlreader *reader)
BOOL	is_pubchar (WCHAR ch)
BOOL	is_ncnamechar (WCHAR ch)
BOOL	is_namechar (WCHAR ch)
static XmlNodeType	reader_get_nodetype (const xmlreader *reader)
static HRESULT	reader_parse_name (xmlreader *reader, strval *name)
static HRESULT	reader_parse_pitarget (xmlreader *reader, strval *target)
static HRESULT	reader_parse_pi (xmlreader *reader)
static HRESULT	reader_parse_whitespace (xmlreader *reader)
static HRESULT	reader_parse_misc (xmlreader *reader)
static HRESULT	reader_parse_sys_literal (xmlreader *reader, strval *literal)
static HRESULT	reader_parse_pub_literal (xmlreader *reader, strval *literal)
static HRESULT	reader_parse_externalid (xmlreader *reader)
static HRESULT	reader_parse_dtd (xmlreader *reader)
static HRESULT	reader_parse_local (xmlreader *reader, strval *local, BOOL check_for_separator)
static HRESULT	reader_parse_qname (xmlreader *reader, strval *prefix, strval *local, strval *qname)
static WCHAR	get_predefined_entity (const xmlreader *reader, const strval *name)
static HRESULT	reader_parse_reference (xmlreader *reader)
static HRESULT	reader_parse_attvalue (xmlreader *reader, strval *value)
static HRESULT	reader_parse_attribute (xmlreader *reader)
static HRESULT	reader_parse_stag (xmlreader *reader, strval *prefix, strval *local, strval *qname)
static HRESULT	reader_parse_element (xmlreader *reader)
static HRESULT	reader_parse_endtag (xmlreader *reader)
static HRESULT	reader_parse_cdata (xmlreader *reader)
static HRESULT	reader_parse_chardata (xmlreader *reader)
static HRESULT	reader_parse_content (xmlreader *reader)
static HRESULT	reader_parse_nextnode (xmlreader *reader)
static HRESULT WINAPI	xmlreader_QueryInterface (IXmlReader *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	xmlreader_AddRef (IXmlReader *iface)
static void	reader_clear_ns (xmlreader *reader)
static void	reader_reset_parser (xmlreader *reader)
static ULONG WINAPI	xmlreader_Release (IXmlReader *iface)
static HRESULT WINAPI	xmlreader_SetInput (IXmlReader *iface, IUnknown *input)
static HRESULT WINAPI	xmlreader_GetProperty (IXmlReader *iface, UINT property, LONG_PTR *value)
static HRESULT WINAPI	xmlreader_SetProperty (IXmlReader *iface, UINT property, LONG_PTR value)
static HRESULT WINAPI	xmlreader_Read (IXmlReader *iface, XmlNodeType *nodetype)
static HRESULT WINAPI	xmlreader_GetNodeType (IXmlReader *iface, XmlNodeType *node_type)
static void	reader_set_current_attribute (xmlreader *reader, struct attribute *attr)
static HRESULT	reader_move_to_first_attribute (xmlreader *reader)
static HRESULT WINAPI	xmlreader_MoveToFirstAttribute (IXmlReader *iface)
static HRESULT WINAPI	xmlreader_MoveToNextAttribute (IXmlReader *iface)
static void	reader_get_attribute_ns_uri (xmlreader *reader, struct attribute *attr, const WCHAR **uri, UINT *len)
static void	reader_get_attribute_local_name (xmlreader *reader, struct attribute *attr, const WCHAR **name, UINT *len)
static HRESULT WINAPI	xmlreader_MoveToAttributeByName (IXmlReader *iface, const WCHAR *local_name, const WCHAR *namespace_uri)
static HRESULT WINAPI	xmlreader_MoveToElement (IXmlReader *iface)
static HRESULT WINAPI	xmlreader_GetQualifiedName (IXmlReader *iface, LPCWSTR *name, UINT *len)
static struct ns *	reader_lookup_nsdef (xmlreader *reader)
static HRESULT WINAPI	xmlreader_GetNamespaceUri (IXmlReader *iface, const WCHAR **uri, UINT *len)
static HRESULT WINAPI	xmlreader_GetLocalName (IXmlReader *iface, LPCWSTR *name, UINT *len)
static HRESULT WINAPI	xmlreader_GetPrefix (IXmlReader *iface, const WCHAR **ret, UINT *len)
static const strval *	reader_get_value (xmlreader *reader, BOOL ensure_allocated)
static HRESULT WINAPI	xmlreader_GetValue (IXmlReader *iface, const WCHAR **value, UINT *len)
static HRESULT WINAPI	xmlreader_ReadValueChunk (IXmlReader *iface, WCHAR *buffer, UINT chunk_size, UINT *read)
static HRESULT WINAPI	xmlreader_GetBaseUri (IXmlReader *iface, LPCWSTR *baseUri, UINT *baseUri_length)
static BOOL WINAPI	xmlreader_IsDefault (IXmlReader *iface)
static BOOL WINAPI	xmlreader_IsEmptyElement (IXmlReader *iface)
static HRESULT WINAPI	xmlreader_GetLineNumber (IXmlReader *iface, UINT *line_number)
static HRESULT WINAPI	xmlreader_GetLinePosition (IXmlReader *iface, UINT *line_position)
static HRESULT WINAPI	xmlreader_GetAttributeCount (IXmlReader *iface, UINT *count)
static HRESULT WINAPI	xmlreader_GetDepth (IXmlReader *iface, UINT *depth)
static BOOL WINAPI	xmlreader_IsEOF (IXmlReader *iface)
static HRESULT WINAPI	xmlreaderinput_QueryInterface (IXmlReaderInput *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	xmlreaderinput_AddRef (IXmlReaderInput *iface)
static ULONG WINAPI	xmlreaderinput_Release (IXmlReaderInput *iface)
HRESULT WINAPI	CreateXmlReader (REFIID riid, void **obj, IMalloc *imalloc)
static HRESULT	create_reader_input (IUnknown *stream, IMalloc *imalloc, xml_encoding encoding, BOOL hint, const WCHAR *base_uri, IXmlReaderInput **ppInput)
HRESULT WINAPI	CreateXmlReaderInputWithEncodingName (IUnknown *stream, IMalloc *imalloc, const WCHAR *encoding, BOOL hint, const WCHAR *base_uri, IXmlReaderInput **input)
HRESULT WINAPI	CreateXmlReaderInputWithEncodingCodePage (IUnknown *stream, IMalloc *imalloc, UINT codepage, BOOL hint, const WCHAR *base_uri, IXmlReaderInput **input)

Variables
static const struct xml_encoding_data	xml_encoding_map []
static const struct IUnknownVtbl	xmlreaderinputvtbl
static WCHAR	emptyW [] = L""
static WCHAR	xmlW [] = L"xml"
static WCHAR	xmlnsW [] = L"xmlns"
static const strval	strval_empty = { emptyW, 0 }
static const strval	strval_xml = { xmlW, 3 }
static const strval	strval_xmlns = { xmlnsW, 5 }
static const struct IXmlReaderVtbl	xmlreader_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file reader.c.

Typedef Documentation

input_buffer

typedef struct input_buffer input_buffer

Definition at line 179 of file reader.c.

Enumeration Type Documentation

attribute_flags

enum attribute_flags

Enumerator
ATTRIBUTE_NS_DEFINITION
ATTRIBUTE_DEFAULT_NS_DEFINITION

Definition at line 229 of file reader.c.

{
    ATTRIBUTE_NS_DEFINITION = 0x1,
    ATTRIBUTE_DEFAULT_NS_DEFINITION = 0x2,
};

XmlReaderInternalState

enum XmlReaderInternalState

Enumerator
XmlReadInState_Initial
XmlReadInState_XmlDecl
XmlReadInState_Misc_DTD
XmlReadInState_DTD
XmlReadInState_DTD_Misc
XmlReadInState_Element
XmlReadInState_Content
XmlReadInState_MiscEnd
XmlReadInState_Eof

Definition at line 44 of file reader.c.

{
    XmlReadInState_Initial,
    XmlReadInState_XmlDecl,
    XmlReadInState_Misc_DTD,
    XmlReadInState_DTD,
    XmlReadInState_DTD_Misc,
    XmlReadInState_Element,
    XmlReadInState_Content,
    XmlReadInState_MiscEnd, /* optional Misc at the end of a document */
    XmlReadInState_Eof
} XmlReaderInternalState;

XmlReaderResume

enum XmlReaderResume

Enumerator
XmlReadResume_Name
XmlReadResume_Local
XmlReadResume_Body
XmlReadResume_Last

Definition at line 72 of file reader.c.

{
    XmlReadResume_Name,  /* PITarget, name for NCName, prefix for QName */
    XmlReadResume_Local, /* local for QName */
    XmlReadResume_Body,  /* PI body, comment text, CDATA text, CharData text */
    XmlReadResume_Last
} XmlReaderResume;

XmlReaderResumeState

enum XmlReaderResumeState

Enumerator
XmlReadResumeState_Initial
XmlReadResumeState_PITarget
XmlReadResumeState_PIBody
XmlReadResumeState_CDATA
XmlReadResumeState_Comment
XmlReadResumeState_STag
XmlReadResumeState_CharData
XmlReadResumeState_Whitespace

Definition at line 59 of file reader.c.

{
    XmlReadResumeState_Initial,
    XmlReadResumeState_PITarget,
    XmlReadResumeState_PIBody,
    XmlReadResumeState_CDATA,
    XmlReadResumeState_Comment,
    XmlReadResumeState_STag,
    XmlReadResumeState_CharData,
    XmlReadResumeState_Whitespace
} XmlReaderResumeState;

XmlReaderStringValue

enum XmlReaderStringValue

Enumerator
StringValue_LocalName
StringValue_Prefix
StringValue_QualifiedName
StringValue_Value
StringValue_Last

Definition at line 80 of file reader.c.

{
    StringValue_LocalName,
    StringValue_Prefix,
    StringValue_QualifiedName,
    StringValue_Value,
    StringValue_Last
} XmlReaderStringValue;

Function Documentation

alloc_input_buffer()

static HRESULT alloc_input_buffer ( xmlreaderinput *  input )

static

Definition at line 766 of file reader.c.

{
    input_buffer *buffer;
    HRESULT hr;
 
    input->buffer = NULL;
 
    buffer = readerinput_alloc(input, sizeof(*buffer));
    if (!buffer) return E_OUTOFMEMORY;
 
    buffer->input = input;
    buffer->code_page = ~0; /* code page is unknown at this point */
    hr = init_encoded_buffer(input, &buffer->utf16);
    if (hr != S_OK) {
        readerinput_free(input, buffer);
        return hr;
    }
 
    hr = init_encoded_buffer(input, &buffer->encoded);
    if (hr != S_OK) {
        free_encoded_buffer(input, &buffer->utf16);
        readerinput_free(input, buffer);
        return hr;
    }
 
    input->buffer = buffer;
    return S_OK;
}

Referenced by create_reader_input().

create_reader_input()

static HRESULT create_reader_input ( IUnknown *  stream, IMalloc *  imalloc, xml_encoding  encoding, BOOL  hint, const WCHAR *  base_uri, IXmlReaderInput **  ppInput  )

static

Definition at line 3655 of file reader.c.

{
    xmlreaderinput *readerinput;
    HRESULT hr;
 
    if (!stream || !ppInput) return E_INVALIDARG;
 
    if (!(readerinput = m_alloc(imalloc, sizeof(*readerinput))))
        return E_OUTOFMEMORY;
    memset(readerinput, 0, sizeof(*readerinput));
 
    readerinput->IXmlReaderInput_iface.lpVtbl = &xmlreaderinputvtbl;
    readerinput->ref = 1;
    readerinput->imalloc = imalloc;
    if (imalloc) IMalloc_AddRef(imalloc);
    readerinput->encoding = encoding;
    readerinput->hint = hint;
    readerinput->baseuri = readerinput_strdupW(readerinput, base_uri);
 
    hr = alloc_input_buffer(readerinput);
    if (hr != S_OK)
    {
        readerinput_free(readerinput, readerinput->baseuri);
        readerinput_free(readerinput, readerinput);
        if (imalloc) IMalloc_Release(imalloc);
        return hr;
    }
    IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&readerinput->input);
 
    *ppInput = &readerinput->IXmlReaderInput_iface;
 
    TRACE("returning iface %p\n", *ppInput);
 
    return S_OK;
}

Referenced by CreateXmlReaderInputWithEncodingCodePage(), and CreateXmlReaderInputWithEncodingName().

CreateXmlReader()

HRESULT WINAPI CreateXmlReader	(	REFIID	riid,
		void **	obj,
		IMalloc *	imalloc
	)

Definition at line 3616 of file reader.c.

{
    xmlreader *reader;
    HRESULT hr;
    int i;
 
    TRACE("%s, %p, %p.\n", wine_dbgstr_guid(riid), obj, imalloc);
 
    if (!(reader = m_alloc(imalloc, sizeof(*reader))))
        return E_OUTOFMEMORY;
 
    memset(reader, 0, sizeof(*reader));
    reader->IXmlReader_iface.lpVtbl = &xmlreader_vtbl;
    reader->ref = 1;
    reader->state = XmlReadState_Closed;
    reader->instate = XmlReadInState_Initial;
    reader->resumestate = XmlReadResumeState_Initial;
    reader->dtdmode = DtdProcessing_Prohibit;
    reader->imalloc = imalloc;
    if (imalloc) IMalloc_AddRef(imalloc);
    reader->nodetype = XmlNodeType_None;
    list_init(&reader->attrs);
    list_init(&reader->nsdef);
    list_init(&reader->ns);
    list_init(&reader->elements);
    reader->max_depth = 256;
 
    reader->chunk_read_off = 0;
    for (i = 0; i < StringValue_Last; i++)
        reader->strvalues[i] = strval_empty;
 
    hr = IXmlReader_QueryInterface(&reader->IXmlReader_iface, riid, obj);
    IXmlReader_Release(&reader->IXmlReader_iface);
 
    TRACE("returning iface %p, hr %#lx.\n", *obj, hr);
 
    return hr;
}

Referenced by check_writer_state(), d2d_factory_register_effect_from_stream(), get_xml_elements(), parse_desc_xml(), test_attribute_by_name(), test_encoding_detection(), test_endoffile(), test_invalid_output_encoding(), test_isemptyelement(), test_max_element_depth(), test_namespaceuri(), test_prefix(), test_read_attribute(), test_read_cdata(), test_read_charref(), test_read_comment(), test_read_element(), test_read_full(), test_read_pending(), test_read_pi(), test_read_public_dtd(), test_read_system_dtd(), test_read_text(), test_read_xmldeclaration(), test_reader_create(), test_reader_position(), test_reader_properties(), test_reader_state(), test_readerinput(), test_readvaluechunk(), test_string_pointers(), test_WriteAttributes(), test_WriteNode(), and test_WriteNodeShallow().

CreateXmlReaderInputWithEncodingCodePage()

HRESULT WINAPI CreateXmlReaderInputWithEncodingCodePage	(	IUnknown *	stream,
		IMalloc *	imalloc,
		UINT	codepage,
		BOOL	hint,
		const WCHAR *	base_uri,
		IXmlReaderInput **	input
	)

Definition at line 3707 of file reader.c.

{
    TRACE("%p, %p, %u, %d, %s, %p.\n", stream, imalloc, codepage, hint, wine_dbgstr_w(base_uri), input);
 
    return create_reader_input(stream, imalloc, get_encoding_from_codepage(codepage), hint, base_uri, input);
}

Referenced by test_readerinput().

CreateXmlReaderInputWithEncodingName()

HRESULT WINAPI CreateXmlReaderInputWithEncodingName	(	IUnknown *	stream,
		IMalloc *	imalloc,
		const WCHAR *	encoding,
		BOOL	hint,
		const WCHAR *	base_uri,
		IXmlReaderInput **	input
	)

Definition at line 3695 of file reader.c.

{
    TRACE("%p, %p, %s, %d, %s, %p.\n", stream, imalloc, wine_dbgstr_w(encoding),
            hint, wine_dbgstr_w(base_uri), input);
 
    return create_reader_input(stream, imalloc, parse_encoding_name(encoding, -1), hint, base_uri, input);
}

Referenced by test_readerinput(), and xmlreader_SetInput().

debug_strval()

static const char * debug_strval ( const xmlreader *  reader, const strval *  v  )

inlinestatic

Definition at line 467 of file reader.c.

{
    return debugstr_wn(reader_get_strptr(reader, v), v->len);
}

Referenced by reader_parse_attribute(), reader_parse_cdata(), reader_parse_comment(), reader_parse_name(), reader_parse_pi(), reader_parse_pitarget(), reader_parse_pub_literal(), reader_parse_qname(), reader_parse_reference(), reader_parse_sddecl(), reader_parse_sys_literal(), reader_parse_versionnum(), and reader_parse_whitespace().

debugstr_nodetype()

static const char * debugstr_nodetype ( XmlNodeType  nodetype )

static

Definition at line 91 of file reader.c.

{
    static const char * const type_names[] =
    {
        "None",
        "Element",
        "Attribute",
        "Text",
        "CDATA",
        "",
        "",
        "ProcessingInstruction",
        "Comment",
        "",
        "DocumentType",
        "",
        "",
        "Whitespace",
        "",
        "EndElement",
        "",
        "XmlDeclaration"
    };
 
    if (nodetype > _XmlNodeType_Last)
        return wine_dbg_sprintf("unknown type=%d", nodetype);
 
    return type_names[nodetype];
}

Referenced by xmlreader_Read().

debugstr_reader_prop()

static const char * debugstr_reader_prop ( XmlReaderProperty  prop )

static

Definition at line 121 of file reader.c.

{
    static const char * const prop_names[] =
    {
        "MultiLanguage",
        "ConformanceLevel",
        "RandomAccess",
        "XmlResolver",
        "DtdProcessing",
        "ReadState",
        "MaxElementDepth",
        "MaxEntityExpansion"
    };
 
    if (prop > _XmlReaderProperty_Last)
        return wine_dbg_sprintf("unknown property=%d", prop);
 
    return prop_names[prop];
}

Referenced by xmlreader_GetProperty(), and xmlreader_SetProperty().

DEFINE_GUID()

DEFINE_GUID	(	IID_IXmlReaderInput	,
		0x0b3ccc9b	,
		0x9214	,
		0x428b	,
		0xa2	,
		0xae	,
		0xef	,
		0x3a	,
		0xa8	,
		0x71	,
		0xaf	,
		0xda
	)

fixup_buffer_cr()

static void fixup_buffer_cr ( encoded_buffer *  buffer, int  off  )

static

Definition at line 985 of file reader.c.

{
    BOOL prev_cr = buffer->prev_cr;
    const WCHAR *src;
    WCHAR *dest;
 
    src = dest = (WCHAR*)buffer->data + off;
    while ((const char*)src < buffer->data + buffer->written)
    {
        if (*src == '\r')
        {
            *dest++ = '\n';
            src++;
            prev_cr = TRUE;
            continue;
        }
        if(prev_cr && *src == '\n')
            src++;
        else
            *dest++ = *src++;
        prev_cr = FALSE;
    }
 
    buffer->written = (char*)dest - buffer->data;
    buffer->prev_cr = prev_cr;
    *dest = 0;
}

Referenced by reader_more(), and readerinput_switchencoding().

free_encoded_buffer()

static void free_encoded_buffer ( xmlreaderinput *  input, encoded_buffer *  buffer  )

static

Definition at line 719 of file reader.c.

{
    readerinput_free(input, buffer->data);
}

Referenced by alloc_input_buffer(), and free_input_buffer().

free_input_buffer()

static void free_input_buffer ( input_buffer *  buffer )

static

Definition at line 795 of file reader.c.

{
    free_encoded_buffer(buffer->input, &buffer->encoded);
    free_encoded_buffer(buffer->input, &buffer->utf16);
    readerinput_free(buffer->input, buffer);
}

Referenced by xmlreaderinput_Release().

get_code_page()

HRESULT get_code_page	(	xml_encoding	encoding,
		UINT *	cp
	)

Definition at line 724 of file reader.c.

{
    if (encoding == XmlEncoding_Unknown)
    {
        FIXME("unsupported encoding %d\n", encoding);
        return E_NOTIMPL;
    }
 
    *cp = xml_encoding_map[encoding].cp;
 
    return S_OK;
}

Referenced by readerinput_switchencoding().

get_encoding_from_codepage()

xml_encoding get_encoding_from_codepage

(

UINT

codepage

)

Definition at line 160 of file reader.c.

{
    int i;
    for (i = 0; i < ARRAY_SIZE(xml_encoding_map); i++)
    {
        if (xml_encoding_map[i].cp == codepage) return xml_encoding_map[i].enc;
    }
    return XmlEncoding_Unknown;
}

Referenced by CreateXmlReaderInputWithEncodingCodePage(), and CreateXmlWriterOutputWithEncodingCodePage().

get_encoding_name()

const WCHAR * get_encoding_name

(

xml_encoding

encoding

)

Definition at line 155 of file reader.c.

{
    return xml_encoding_map[encoding].name;
}

Referenced by get_output_encoding_name().

get_predefined_entity()

static WCHAR get_predefined_entity ( const xmlreader *  reader, const strval *  name  )

static

Definition at line 2020 of file reader.c.

{
    static const strval lt   = { (WCHAR *)L"lt",   2 };
    static const strval gt   = { (WCHAR *)L"gt",   2 };
    static const strval amp  = { (WCHAR *)L"amp",  3 };
    static const strval apos = { (WCHAR *)L"apos", 4 };
    static const strval quot = { (WCHAR *)L"quot", 4 };
    WCHAR *str = reader_get_strptr(reader, name);
 
    switch (*str)
    {
    case 'l':
        if (strval_eq(reader, name, &lt)) return '<';
        break;
    case 'g':
        if (strval_eq(reader, name, &gt)) return '>';
        break;
    case 'a':
        if (strval_eq(reader, name, &amp))
            return '&';
        else if (strval_eq(reader, name, &apos))
            return '\'';
        break;
    case 'q':
        if (strval_eq(reader, name, &quot)) return '\"';
        break;
    default:
        ;
    }
 
    return 0;
}

Referenced by reader_parse_reference().

impl_from_IXmlReader()

static xmlreader * impl_from_IXmlReader ( IXmlReader *  iface )

inlinestatic

Definition at line 302 of file reader.c.

{
    return CONTAINING_RECORD(iface, xmlreader, IXmlReader_iface);
}

Referenced by xmlreader_AddRef(), xmlreader_GetAttributeCount(), xmlreader_GetDepth(), xmlreader_GetLineNumber(), xmlreader_GetLinePosition(), xmlreader_GetLocalName(), xmlreader_GetNamespaceUri(), xmlreader_GetNodeType(), xmlreader_GetPrefix(), xmlreader_GetProperty(), xmlreader_GetQualifiedName(), xmlreader_GetValue(), xmlreader_IsEmptyElement(), xmlreader_IsEOF(), xmlreader_MoveToAttributeByName(), xmlreader_MoveToElement(), xmlreader_MoveToFirstAttribute(), xmlreader_MoveToNextAttribute(), xmlreader_Read(), xmlreader_ReadValueChunk(), xmlreader_Release(), xmlreader_SetInput(), and xmlreader_SetProperty().

impl_from_IXmlReaderInput()

static xmlreaderinput * impl_from_IXmlReaderInput ( IXmlReaderInput *  iface )

inlinestatic

Definition at line 307 of file reader.c.

{
    return CONTAINING_RECORD(iface, xmlreaderinput, IXmlReaderInput_iface);
}

Referenced by xmlreader_SetInput(), xmlreaderinput_AddRef(), and xmlreaderinput_Release().

init_encoded_buffer()

static HRESULT init_encoded_buffer ( xmlreaderinput *  input, encoded_buffer *  buffer  )

static

Definition at line 704 of file reader.c.

{
    const int initial_len = 0x2000;
    buffer->data = readerinput_alloc(input, initial_len);
    if (!buffer->data) return E_OUTOFMEMORY;
 
    memset(buffer->data, 0, 4);
    buffer->cur = 0;
    buffer->allocated = initial_len;
    buffer->written = 0;
    buffer->prev_cr = FALSE;
 
    return S_OK;
}

Referenced by alloc_input_buffer().

is_namechar()

BOOL is_namechar

(

WCHAR

ch

)

Definition at line 1530 of file reader.c.

{
    return (ch == ':') || is_ncnamechar(ch);
}

Referenced by is_valid_name(), and reader_parse_name().

is_namestartchar()

BOOL is_namestartchar

(

WCHAR

ch

)

Definition at line 1486 of file reader.c.

{
    return (ch == ':') || (ch >= 'A' && ch <= 'Z') ||
           (ch == '_') || (ch >= 'a' && ch <= 'z') ||
           (ch >= 0xc0   && ch <= 0xd6)   ||
           (ch >= 0xd8   && ch <= 0xf6)   ||
           (ch >= 0xf8   && ch <= 0x2ff)  ||
           (ch >= 0x370  && ch <= 0x37d)  ||
           (ch >= 0x37f  && ch <= 0x1fff) ||
           (ch >= 0x200c && ch <= 0x200d) ||
           (ch >= 0x2070 && ch <= 0x218f) ||
           (ch >= 0x2c00 && ch <= 0x2fef) ||
           (ch >= 0x3001 && ch <= 0xd7ff) ||
           (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
           (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
           (ch >= 0xf900 && ch <= 0xfdcf) ||
           (ch >= 0xfdf0 && ch <= 0xfffd);
}

Referenced by is_valid_name(), reader_parse_name(), and readerinput_detectencoding().

is_ncnamechar()

BOOL is_ncnamechar

(

WCHAR

ch

)

Definition at line 1506 of file reader.c.

{
    return (ch >= 'A' && ch <= 'Z') ||
           (ch == '_') || (ch >= 'a' && ch <= 'z') ||
           (ch == '-') || (ch == '.') ||
           (ch >= '0'    && ch <= '9')    ||
           (ch == 0xb7)                   ||
           (ch >= 0xc0   && ch <= 0xd6)   ||
           (ch >= 0xd8   && ch <= 0xf6)   ||
           (ch >= 0xf8   && ch <= 0x2ff)  ||
           (ch >= 0x300  && ch <= 0x36f)  ||
           (ch >= 0x370  && ch <= 0x37d)  ||
           (ch >= 0x37f  && ch <= 0x1fff) ||
           (ch >= 0x200c && ch <= 0x200d) ||
           (ch >= 0x203f && ch <= 0x2040) ||
           (ch >= 0x2070 && ch <= 0x218f) ||
           (ch >= 0x2c00 && ch <= 0x2fef) ||
           (ch >= 0x3001 && ch <= 0xd7ff) ||
           (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
           (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
           (ch >= 0xf900 && ch <= 0xfdcf) ||
           (ch >= 0xfdf0 && ch <= 0xfffd);
}

Referenced by is_namechar(), is_valid_ncname(), reader_parse_local(), and reader_parse_qname().

is_pubchar()

BOOL is_pubchar

(

WCHAR

ch

)

Definition at line 1473 of file reader.c.

{
    return (ch == ' ') ||
           (ch >= 'a' && ch <= 'z') ||
           (ch >= 'A' && ch <= 'Z') ||
           (ch >= '0' && ch <= '9') ||
           (ch >= '-' && ch <= ';') || /* '()*+,-./:; */
           (ch == '=') || (ch == '?') ||
           (ch == '@') || (ch == '!') ||
           (ch >= '#' && ch <= '%') || /* #$% */
           (ch == '_') || (ch == '\r') || (ch == '\n');
}

Referenced by is_valid_pubid(), and reader_parse_pub_literal().

is_reader_pending()

static int is_reader_pending ( xmlreader *  reader )

inlinestatic

Definition at line 699 of file reader.c.

{
    return reader->input->pending;
}

Referenced by reader_parse_local(), reader_parse_name(), reader_parse_nextnode(), reader_parse_pitarget(), reader_parse_qname(), reader_parse_whitespace(), and xmlreader_GetValue().

is_wchar_encname()

static BOOL is_wchar_encname ( WCHAR  ch )

inlinestatic

Definition at line 1257 of file reader.c.

{
    return ((ch >= 'A' && ch <= 'Z') ||
            (ch >= 'a' && ch <= 'z') ||
            (ch >= '0' && ch <= '9') ||
            (ch == '.') || (ch == '_') ||
            (ch == '-'));
}

Referenced by reader_parse_encname().

parse_encoding_name()

xml_encoding parse_encoding_name	(	const WCHAR *	name,
		int	len
	)

Definition at line 737 of file reader.c.

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

Referenced by CreateXmlReaderInputWithEncodingName(), and reader_parse_encname().

reader_add_attr()

static HRESULT reader_add_attr ( xmlreader *  reader, strval *  prefix, strval *  localname, strval *  qname, strval *  value, const struct reader_position *  position, unsigned int  flags  )

static

Definition at line 416 of file reader.c.

{
    struct attribute *attr;
    HRESULT hr;
 
    attr = reader_alloc(reader, sizeof(*attr));
    if (!attr) return E_OUTOFMEMORY;
 
    hr = reader_strvaldup(reader, localname, &attr->localname);
    if (hr == S_OK)
    {
        hr = reader_strvaldup(reader, value, &attr->value);
        if (hr != S_OK)
            reader_free_strvalued(reader, &attr->localname);
    }
    if (hr != S_OK)
    {
        reader_free(reader, attr);
        return hr;
    }
 
    if (prefix)
        attr->prefix = *prefix;
    else
        memset(&attr->prefix, 0, sizeof(attr->prefix));
    attr->qname = qname ? *qname : *localname;
    attr->position = *position;
    attr->flags = flags;
    list_add_tail(&reader->attrs, &attr->entry);
    reader->attr_count++;
 
    return S_OK;
}

Referenced by reader_parse_attribute(), reader_parse_encdecl(), reader_parse_externalid(), reader_parse_sddecl(), and reader_parse_versioninfo().

reader_alloc()

static void * reader_alloc ( xmlreader *  reader, size_t  len  )

inlinestatic

Definition at line 313 of file reader.c.

{
    return m_alloc(reader->imalloc, len);
}

Referenced by reader_add_attr(), reader_alloc_zero(), reader_get_value(), reader_push_ns(), reader_set_strvalue(), and reader_strvaldup().

reader_alloc_zero()

static void * reader_alloc_zero ( xmlreader *  reader, size_t  len  )

inlinestatic

Definition at line 318 of file reader.c.

{
    void *ret = reader_alloc(reader, len);
    if (ret)
        memset(ret, 0, len);
    return ret;
}

Referenced by reader_push_element().

reader_clear_attrs()

static void reader_clear_attrs ( xmlreader *  reader )

static

Definition at line 400 of file reader.c.

{
    struct attribute *attr, *attr2;
    LIST_FOR_EACH_ENTRY_SAFE(attr, attr2, &reader->attrs, struct attribute, entry)
    {
        reader_free_strvalued(reader, &attr->localname);
        reader_free_strvalued(reader, &attr->value);
        reader_free(reader, attr);
    }
    list_init(&reader->attrs);
    reader->attr_count = 0;
    reader->attr = NULL;
}

Referenced by reader_parse_nextnode(), and reader_reset_parser().

reader_clear_elements()

static void reader_clear_elements ( xmlreader *  reader )

static

Definition at line 500 of file reader.c.

{
    struct element *elem, *elem2;
    LIST_FOR_EACH_ENTRY_SAFE(elem, elem2, &reader->elements, struct element, entry)
    {
        reader_free_strvalued(reader, &elem->prefix);
        reader_free_strvalued(reader, &elem->localname);
        reader_free_strvalued(reader, &elem->qname);
        reader_free(reader, elem);
    }
    list_init(&reader->elements);
    reader_free_strvalued(reader, &reader->empty_element.localname);
    reader_free_strvalued(reader, &reader->empty_element.qname);
    reader->is_empty_element = FALSE;
}

Referenced by reader_reset_parser().

reader_clear_ns()

static void reader_clear_ns ( xmlreader *  reader )

static

Definition at line 2674 of file reader.c.

{
    struct ns *ns, *ns2;
 
    LIST_FOR_EACH_ENTRY_SAFE(ns, ns2, &reader->ns, struct ns, entry) {
        list_remove(&ns->entry);
        reader_free_strvalued(reader, &ns->prefix);
        reader_free_strvalued(reader, &ns->uri);
        reader_free(reader, ns);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(ns, ns2, &reader->nsdef, struct ns, entry) {
        list_remove(&ns->entry);
        reader_free_strvalued(reader, &ns->uri);
        reader_free(reader, ns);
    }
}

Referenced by reader_reset_parser().

reader_cmp()

static int reader_cmp ( xmlreader *  reader, const WCHAR *  str  )

static

Definition at line 1121 of file reader.c.

{
    int i=0;
    const WCHAR *ptr = reader_get_ptr(reader);
    while (str[i])
    {
        if (!ptr[i])
        {
            reader_more(reader);
            ptr = reader_get_ptr(reader);
        }
        if (str[i] != ptr[i])
            return ptr[i] - str[i];
        i++;
    }
    return 0;
}

Referenced by reader_is_quote(), reader_parse_chardata(), reader_parse_content(), reader_parse_dtd(), reader_parse_element(), reader_parse_encdecl(), reader_parse_endtag(), reader_parse_eq(), reader_parse_externalid(), reader_parse_misc(), reader_parse_sddecl(), reader_parse_stag(), reader_parse_versioninfo(), reader_parse_versionnum(), and reader_parse_xmldecl().

reader_dec_depth()

static void reader_dec_depth ( xmlreader *  reader )

static

Definition at line 534 of file reader.c.

{
    if (reader->depth)
        reader->depth--;
}

Referenced by reader_parse_nextnode(), and xmlreader_MoveToElement().

reader_free()

static void reader_free ( xmlreader *  reader, void *  mem  )

inlinestatic

Definition at line 326 of file reader.c.

{
    m_free(reader->imalloc, mem);
}

Referenced by reader_add_attr(), reader_clear_attrs(), reader_clear_elements(), reader_clear_ns(), reader_free_element(), reader_free_strvalued(), reader_pop_ns_nodes(), reader_push_ns(), and xmlreader_Release().

reader_free_element()

static void reader_free_element ( xmlreader *  reader, struct element *  element  )

static

Definition at line 570 of file reader.c.

{
    reader_free_strvalued(reader, &element->prefix);
    reader_free_strvalued(reader, &element->localname);
    reader_free_strvalued(reader, &element->qname);
    reader_free(reader, element);
}

Referenced by reader_pop_element(), and reader_push_element().

reader_free_strvalue()

static void reader_free_strvalue ( xmlreader *  reader, XmlReaderStringValue  type  )

static

Definition at line 480 of file reader.c.

{
    reader_free_strvalued(reader, &reader->strvalues[type]);
}

Referenced by reader_free_strvalues(), and reader_set_strvalue().

reader_free_strvalued()

static void reader_free_strvalued ( xmlreader *  reader, strval *  v  )

static

Definition at line 391 of file reader.c.

{
    if (v->str != strval_empty.str)
    {
        reader_free(reader, v->str);
        *v = strval_empty;
    }
}

Referenced by reader_add_attr(), reader_clear_attrs(), reader_clear_elements(), reader_clear_ns(), reader_free_element(), reader_free_strvalue(), reader_parse_stag(), reader_pop_ns_nodes(), and reader_push_ns().

reader_free_strvalues()

static void reader_free_strvalues ( xmlreader *  reader )

static

Definition at line 485 of file reader.c.

{
    int type;
    for (type = 0; type < StringValue_Last; type++)
        reader_free_strvalue(reader, type);
}

Referenced by reader_reset_parser().

reader_get_attribute_local_name()

static void reader_get_attribute_local_name ( xmlreader *  reader, struct attribute *  attr, const WCHAR **  name, UINT *  len  )

static

Definition at line 3007 of file reader.c.

{
    if (attr->flags & ATTRIBUTE_DEFAULT_NS_DEFINITION)
    {
        *name = xmlnsW;
        *len = 5;
    }
    else if (attr->flags & ATTRIBUTE_NS_DEFINITION)
    {
        const struct ns *ns = reader_lookup_ns(reader, &attr->localname);
        *name = ns->prefix.str;
        *len = ns->prefix.len;
    }
    else
    {
        *name = attr->localname.str;
        *len = attr->localname.len;
    }
}

Referenced by xmlreader_GetLocalName(), and xmlreader_MoveToAttributeByName().

reader_get_attribute_ns_uri()

static void reader_get_attribute_ns_uri ( xmlreader *  reader, struct attribute *  attr, const WCHAR **  uri, UINT *  len  )

static

Definition at line 2967 of file reader.c.

{
    static const WCHAR xmlns_uriW[] = L"http://www.w3.org/2000/xmlns/";
    static const WCHAR xml_uriW[] = L"http://www.w3.org/XML/1998/namespace";
 
    /* Check for reserved prefixes first */
    if ((strval_eq(reader, &attr->prefix, &strval_empty) && strval_eq(reader, &attr->localname, &strval_xmlns)) ||
            strval_eq(reader, &attr->prefix, &strval_xmlns))
    {
        *uri = xmlns_uriW;
        *len = ARRAY_SIZE(xmlns_uriW) - 1;
    }
    else if (strval_eq(reader, &attr->prefix, &strval_xml))
    {
        *uri = xml_uriW;
        *len = ARRAY_SIZE(xml_uriW) - 1;
    }
    else
    {
        *uri = NULL;
        *len = 0;
    }
 
    if (!*uri)
    {
        struct ns *ns;
 
        if ((ns = reader_lookup_ns(reader, &attr->prefix)))
        {
            *uri = ns->uri.str;
            *len = ns->uri.len;
        }
        else
        {
            *uri = emptyW;
            *len = 0;
        }
    }
}

Referenced by xmlreader_GetNamespaceUri(), and xmlreader_MoveToAttributeByName().

reader_get_cur()

static UINT reader_get_cur ( xmlreader *  reader )

inlinestatic

Definition at line 1108 of file reader.c.

{
    return reader->input->buffer->utf16.cur;
}

Referenced by reader_parse_attvalue(), reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_encdecl(), reader_parse_encname(), reader_parse_local(), reader_parse_name(), reader_parse_pi(), reader_parse_pub_literal(), reader_parse_qname(), reader_parse_reference(), reader_parse_sddecl(), reader_parse_sys_literal(), reader_parse_versioninfo(), reader_parse_versionnum(), reader_parse_whitespace(), and reader_skipspaces().

reader_get_element()

static struct element * reader_get_element ( xmlreader *  reader )

static

Definition at line 452 of file reader.c.

{
    if (reader->is_empty_element)
        return &reader->empty_element;
 
    return LIST_ENTRY(list_head(&reader->elements), struct element, entry);
}

Referenced by xmlreader_GetLineNumber(), xmlreader_GetLinePosition(), xmlreader_GetLocalName(), and xmlreader_GetQualifiedName().

reader_get_nodetype()

static XmlNodeType reader_get_nodetype ( const xmlreader *  reader )

static

Definition at line 1535 of file reader.c.

{
    /* When we're on attribute always return attribute type, container node type is kept.
       Note that container is not necessarily an element, and attribute doesn't mean it's
       an attribute in XML spec terms. */
    return reader->attr ? XmlNodeType_Attribute : reader->nodetype;
}

Referenced by reader_get_value(), reader_parse_nextnode(), xmlreader_GetLineNumber(), xmlreader_GetLinePosition(), xmlreader_GetLocalName(), xmlreader_GetNamespaceUri(), xmlreader_GetNodeType(), xmlreader_GetPrefix(), xmlreader_GetQualifiedName(), and xmlreader_IsEmptyElement().

reader_get_ptr()

static WCHAR * reader_get_ptr ( xmlreader *  reader )

inlinestatic

Definition at line 1113 of file reader.c.

{
    encoded_buffer *buffer = &reader->input->buffer->utf16;
    WCHAR *ptr = (WCHAR*)buffer->data + buffer->cur;
    if (!*ptr) reader_more(reader);
    return (WCHAR*)buffer->data + buffer->cur;
}

Referenced by reader_cmp(), reader_parse_attvalue(), reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_dtd(), reader_parse_encdecl(), reader_parse_encname(), reader_parse_local(), reader_parse_misc(), reader_parse_name(), reader_parse_nextnode(), reader_parse_pi(), reader_parse_pub_literal(), reader_parse_qname(), reader_parse_reference(), reader_parse_sys_literal(), reader_parse_versionnum(), reader_skipn(), and reader_skipspaces().

reader_get_ptr2()

static WCHAR * reader_get_ptr2 ( const xmlreader *  reader, UINT  offset  )

inlinestatic

Definition at line 332 of file reader.c.

{
    encoded_buffer *buffer = &reader->input->buffer->utf16;
    return (WCHAR*)buffer->data + offset;
}

Referenced by reader_get_strptr(), reader_parse_pi(), and reader_parse_reference().

reader_get_strptr()

static WCHAR * reader_get_strptr ( const xmlreader *  reader, const strval *  v  )

inlinestatic

Definition at line 338 of file reader.c.

{
    return v->str ? v->str : reader_get_ptr2(reader, v->start);
}

Referenced by debug_strval(), get_predefined_entity(), reader_get_value(), reader_parse_pitarget(), reader_set_strvalue(), reader_strvaldup(), strval_eq(), and xmlreader_ReadValueChunk().

reader_get_value()

static const strval * reader_get_value ( xmlreader *  reader, BOOL  ensure_allocated  )

static

Definition at line 3308 of file reader.c.

{
    strval *val;
 
    switch (reader_get_nodetype(reader))
    {
    case XmlNodeType_XmlDeclaration:
    case XmlNodeType_EndElement:
    case XmlNodeType_None:
        return &strval_empty;
    case XmlNodeType_Attribute:
        /* For namespace definition attributes return values from namespace list */
        if (reader->attr->flags & (ATTRIBUTE_NS_DEFINITION | ATTRIBUTE_DEFAULT_NS_DEFINITION))
        {
            struct ns *ns;
 
            if (!(ns = reader_lookup_ns(reader, &reader->attr->localname)))
                ns = reader_lookup_nsdef(reader);
 
            return &ns->uri;
        }
        return &reader->attr->value;
    default:
        break;
    }
 
    val = &reader->strvalues[StringValue_Value];
    if (!val->str && ensure_allocated)
    {
        WCHAR *ptr = reader_alloc(reader, (val->len+1)*sizeof(WCHAR));
        if (!ptr) return NULL;
        memcpy(ptr, reader_get_strptr(reader, val), val->len*sizeof(WCHAR));
        ptr[val->len] = 0;
        val->str = ptr;
    }
 
    return val;
}

Referenced by xmlreader_GetValue(), and xmlreader_ReadValueChunk().

reader_inc_depth()

static HRESULT reader_inc_depth ( xmlreader *  reader )

static

Definition at line 529 of file reader.c.

{
    return (++reader->depth >= reader->max_depth && reader->max_depth) ? SC_E_MAXELEMENTDEPTH : S_OK;
}

Referenced by reader_parse_nextnode(), and reader_set_current_attribute().

reader_init_cstrvalue()

static void reader_init_cstrvalue ( WCHAR *  str, UINT  len, strval *  v  )

inlinestatic

Definition at line 473 of file reader.c.

{
    v->start = 0;
    v->len = len;
    v->str = str;
}

Referenced by reader_parse_externalid().

reader_init_strvalue()

static void reader_init_strvalue ( UINT  start, UINT  len, strval *  v  )

inlinestatic

Definition at line 460 of file reader.c.

{
    v->start = start;
    v->len = len;
    v->str = NULL;
}

Referenced by reader_parse_attvalue(), reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_local(), reader_parse_name(), reader_parse_pi(), reader_parse_pub_literal(), reader_parse_qname(), reader_parse_sddecl(), reader_parse_sys_literal(), reader_parse_versioninfo(), reader_parse_versionnum(), and reader_parse_whitespace().

reader_is_quote()

static BOOL reader_is_quote ( xmlreader *  reader )

static

Definition at line 1216 of file reader.c.

{
    return !reader_cmp(reader, L"\'") || !reader_cmp(reader, L"\"");
}

Referenced by reader_parse_encdecl(), reader_parse_sddecl(), and reader_parse_versioninfo().

reader_lookup_ns()

static struct ns * reader_lookup_ns ( xmlreader *  reader, const strval *  prefix  )

static

Definition at line 516 of file reader.c.

{
    struct list *nslist = prefix ? &reader->ns : &reader->nsdef;
    struct ns *ns;
 
    LIST_FOR_EACH_ENTRY_REV(ns, nslist, struct ns, entry) {
        if (strval_eq(reader, prefix, &ns->prefix))
            return ns;
    }
 
    return NULL;
}

Referenced by reader_get_attribute_local_name(), reader_get_attribute_ns_uri(), reader_get_value(), xmlreader_GetNamespaceUri(), and xmlreader_GetPrefix().

reader_lookup_nsdef()

static struct ns * reader_lookup_nsdef ( xmlreader *  reader )

static

Definition at line 3158 of file reader.c.

{
    if (list_empty(&reader->nsdef))
        return NULL;
 
    return LIST_ENTRY(list_head(&reader->nsdef), struct ns, entry);
}

Referenced by reader_get_value(), and xmlreader_GetNamespaceUri().

reader_mark_ns_nodes()

static void reader_mark_ns_nodes ( xmlreader *  reader, struct element *  element  )

static

Definition at line 578 of file reader.c.

{
    struct ns *ns;
 
    LIST_FOR_EACH_ENTRY(ns, &reader->ns, struct ns, entry) {
        if (ns->element)
            break;
        ns->element = element;
    }
 
    LIST_FOR_EACH_ENTRY(ns, &reader->nsdef, struct ns, entry) {
        if (ns->element)
            break;
        ns->element = element;
    }
}

Referenced by reader_parse_stag(), and reader_push_element().

reader_more()

static HRESULT reader_more ( xmlreader *  reader )

static

Definition at line 1068 of file reader.c.

{
    xmlreaderinput *readerinput = reader->input;
    encoded_buffer *src = &readerinput->buffer->encoded;
    encoded_buffer *dest = &readerinput->buffer->utf16;
    UINT cp = readerinput->buffer->code_page;
    int len, dest_len, prev_len;
    HRESULT hr;
    WCHAR *ptr;
 
    /* get some raw data from stream first */
    if (FAILED(hr = readerinput_growraw(readerinput)))
        return hr;
 
    len = readerinput_get_convlen(readerinput);
    prev_len = dest->written / sizeof(WCHAR);
 
    /* just copy for UTF-16 case */
    if (cp == 1200)
    {
        readerinput_grow(readerinput, len);
        memcpy(dest->data + dest->written, src->data + src->cur, len);
        dest->written += len;
    }
    else
    {
        dest_len = MultiByteToWideChar(cp, 0, src->data + src->cur, len, NULL, 0);
        readerinput_grow(readerinput, dest_len);
        ptr = (WCHAR*)(dest->data + dest->written);
        MultiByteToWideChar(cp, 0, src->data + src->cur, len, ptr, dest_len);
        ptr[dest_len] = 0;
        dest->written += dest_len*sizeof(WCHAR);
        /* get rid of processed data */
        readerinput_shrinkraw(readerinput, len);
    }
 
    fixup_buffer_cr(dest, prev_len);
    return hr;
}

Referenced by reader_cmp(), reader_get_ptr(), and reader_parse_misc().

reader_move_to_first_attribute()

static HRESULT reader_move_to_first_attribute ( xmlreader *  reader )

static

Definition at line 2929 of file reader.c.

{
    if (!reader->attr_count)
        return S_FALSE;
 
    reader_set_current_attribute(reader, LIST_ENTRY(list_head(&reader->attrs), struct attribute, entry));
 
    return S_OK;
}

Referenced by xmlreader_MoveToFirstAttribute(), and xmlreader_MoveToNextAttribute().

reader_parse_attribute()

static HRESULT reader_parse_attribute ( xmlreader *  reader )

static

Definition at line 2206 of file reader.c.

{
    struct reader_position position = reader->position;
    strval prefix, local, qname, value;
    enum attribute_flags flags = 0;
    HRESULT hr;
 
    hr = reader_parse_qname(reader, &prefix, &local, &qname);
    if (FAILED(hr)) return hr;
 
    if (strval_eq(reader, &prefix, &strval_xmlns))
        flags |= ATTRIBUTE_NS_DEFINITION;
 
    if (strval_eq(reader, &qname, &strval_xmlns))
        flags |= ATTRIBUTE_DEFAULT_NS_DEFINITION;
 
    hr = reader_parse_eq(reader);
    if (FAILED(hr)) return hr;
 
    hr = reader_parse_attvalue(reader, &value);
    if (FAILED(hr)) return hr;
 
    if (flags & (ATTRIBUTE_NS_DEFINITION | ATTRIBUTE_DEFAULT_NS_DEFINITION))
        reader_push_ns(reader, &local, &value, !!(flags & ATTRIBUTE_DEFAULT_NS_DEFINITION));
 
    TRACE("%s=%s\n", debug_strval(reader, &local), debug_strval(reader, &value));
    return reader_add_attr(reader, &prefix, &local, &qname, &value, &position, flags);
}

Referenced by reader_parse_stag().

reader_parse_attvalue()

static HRESULT reader_parse_attvalue ( xmlreader *  reader, strval *  value  )

static

Definition at line 2159 of file reader.c.

{
    WCHAR *ptr, quote;
    UINT start;
 
    ptr = reader_get_ptr(reader);
 
    /* skip opening quote */
    quote = *ptr;
    if (quote != '\"' && quote != '\'') return WC_E_QUOTE;
    reader_skipn(reader, 1);
 
    ptr = reader_get_ptr(reader);
    start = reader_get_cur(reader);
    while (*ptr)
    {
        if (*ptr == '<') return WC_E_LESSTHAN;
 
        if (*ptr == quote)
        {
            reader_init_strvalue(start, reader_get_cur(reader)-start, value);
            /* skip closing quote */
            reader_skipn(reader, 1);
            return S_OK;
        }
 
        if (*ptr == '&')
        {
            HRESULT hr = reader_parse_reference(reader);
            if (FAILED(hr)) return hr;
        }
        else
        {
            /* replace all whitespace chars with ' ' */
            if (is_wchar_space(*ptr)) *ptr = ' ';
            reader_skipn(reader, 1);
        }
        ptr = reader_get_ptr(reader);
    }
 
    return WC_E_QUOTE;
}

Referenced by reader_parse_attribute().

reader_parse_cdata()

static HRESULT reader_parse_cdata ( xmlreader *  reader )

static

Definition at line 2370 of file reader.c.

{
    WCHAR *ptr;
    UINT start;
 
    if (reader->resumestate == XmlReadResumeState_CDATA)
    {
        start = reader->resume[XmlReadResume_Body];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        /* skip markup '<![CDATA[' */
        reader_skipn(reader, 9);
        reader_shrink(reader);
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
        reader->nodetype = XmlNodeType_CDATA;
        reader->resume[XmlReadResume_Body] = start;
        reader->resumestate = XmlReadResumeState_CDATA;
        reader_set_strvalue(reader, StringValue_Value, NULL);
    }
 
    while (*ptr)
    {
        if (*ptr == ']' && *(ptr+1) == ']' && *(ptr+2) == '>')
        {
            strval value;
 
            reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
 
            /* skip ']]>' */
            reader_skipn(reader, 3);
            TRACE("%s\n", debug_strval(reader, &value));
 
            reader_set_strvalue(reader, StringValue_Value, &value);
            reader->resume[XmlReadResume_Body] = 0;
            reader->resumestate = XmlReadResumeState_Initial;
            return S_OK;
        }
        else
        {
            reader_skipn(reader, 1);
            ptr = reader_get_ptr(reader);
        }
    }
 
    return S_OK;
}

Referenced by reader_parse_content().

reader_parse_chardata()

static HRESULT reader_parse_chardata ( xmlreader *  reader )

static

Definition at line 2421 of file reader.c.

{
    struct reader_position position;
    WCHAR *ptr;
    UINT start;
 
    if (reader->resumestate == XmlReadResumeState_CharData)
    {
        start = reader->resume[XmlReadResume_Body];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        reader_shrink(reader);
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
        /* There's no text */
        if (!*ptr || *ptr == '<') return S_OK;
        reader->nodetype = is_wchar_space(*ptr) ? XmlNodeType_Whitespace : XmlNodeType_Text;
        reader->resume[XmlReadResume_Body] = start;
        reader->resumestate = XmlReadResumeState_CharData;
        reader_set_strvalue(reader, StringValue_Value, NULL);
    }
 
    position = reader->position;
    while (*ptr)
    {
        /* CDATA closing sequence ']]>' is not allowed */
        if (ptr[0] == ']' && ptr[1] == ']' && ptr[2] == '>')
            return WC_E_CDSECTEND;
 
        /* Found next markup part */
        if (ptr[0] == '<')
        {
            strval value;
 
            reader->empty_element.position = position;
            reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
            reader_set_strvalue(reader, StringValue_Value, &value);
            reader->resume[XmlReadResume_Body] = 0;
            reader->resumestate = XmlReadResumeState_Initial;
            return S_OK;
        }
 
        /* this covers a case when text has leading whitespace chars */
        if (!is_wchar_space(*ptr)) reader->nodetype = XmlNodeType_Text;
 
        if (!reader_cmp(reader, L"&"))
            reader_parse_reference(reader);
        else
            reader_skipn(reader, 1);
 
        ptr = reader_get_ptr(reader);
    }
 
    return S_OK;
}

Referenced by reader_parse_content().

reader_parse_comment()

static HRESULT reader_parse_comment ( xmlreader *  reader )

static

Definition at line 1414 of file reader.c.

{
    WCHAR *ptr;
    UINT start;
 
    if (reader->resumestate == XmlReadResumeState_Comment)
    {
        start = reader->resume[XmlReadResume_Body];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        /* skip '<!--' */
        reader_skipn(reader, 4);
        reader_shrink(reader);
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
        reader->nodetype = XmlNodeType_Comment;
        reader->resume[XmlReadResume_Body] = start;
        reader->resumestate = XmlReadResumeState_Comment;
        reader_set_strvalue(reader, StringValue_Value, NULL);
    }
 
    /* will exit when there's no more data, it won't attempt to
       read more from stream */
    while (*ptr)
    {
        if (ptr[0] == '-')
        {
            if (ptr[1] == '-')
            {
                if (ptr[2] == '>')
                {
                    strval value;
 
                    reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
                    TRACE("%s\n", debug_strval(reader, &value));
 
                    /* skip rest of markup '->' */
                    reader_skipn(reader, 3);
 
                    reader_set_strvalue(reader, StringValue_Value, &value);
                    reader->resume[XmlReadResume_Body] = 0;
                    reader->resumestate = XmlReadResumeState_Initial;
                    return S_OK;
                }
                else
                    return WC_E_COMMENT;
            }
        }
 
        reader_skipn(reader, 1);
        ptr++;
    }
 
    return S_OK;
}

Referenced by reader_parse_content(), and reader_parse_misc().

reader_parse_content()

static HRESULT reader_parse_content ( xmlreader *  reader )

static

Definition at line 2480 of file reader.c.

{
    if (reader->resumestate != XmlReadResumeState_Initial)
    {
        switch (reader->resumestate)
        {
        case XmlReadResumeState_CDATA:
            return reader_parse_cdata(reader);
        case XmlReadResumeState_Comment:
            return reader_parse_comment(reader);
        case XmlReadResumeState_PIBody:
        case XmlReadResumeState_PITarget:
            return reader_parse_pi(reader);
        case XmlReadResumeState_CharData:
            return reader_parse_chardata(reader);
        default:
            ERR("unknown resume state %d\n", reader->resumestate);
        }
    }
 
    reader_shrink(reader);
 
    /* handle end tag here, it indicates end of content as well */
    if (!reader_cmp(reader, L"</"))
        return reader_parse_endtag(reader);
 
    if (!reader_cmp(reader, L"<!--"))
        return reader_parse_comment(reader);
 
    if (!reader_cmp(reader, L"<?"))
        return reader_parse_pi(reader);
 
    if (!reader_cmp(reader, L"<![CDATA["))
        return reader_parse_cdata(reader);
 
    if (!reader_cmp(reader, L"<"))
        return reader_parse_element(reader);
 
    /* what's left must be CharData */
    return reader_parse_chardata(reader);
}

Referenced by reader_parse_nextnode().

reader_parse_dtd()

static HRESULT reader_parse_dtd ( xmlreader *  reader )

static

Definition at line 1862 of file reader.c.

{
    strval name;
    WCHAR *cur;
    HRESULT hr;
 
    if (reader_cmp(reader, L"<!DOCTYPE")) return S_FALSE;
    reader_shrink(reader);
 
    /* DTD processing is not allowed by default */
    if (reader->dtdmode == DtdProcessing_Prohibit) return WC_E_DTDPROHIBITED;
 
    reader_skipn(reader, 9);
    if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
 
    /* name */
    hr = reader_parse_name(reader, &name);
    if (FAILED(hr)) return WC_E_DECLDOCTYPE;
 
    reader_skipspaces(reader);
 
    hr = reader_parse_externalid(reader);
    if (FAILED(hr)) return hr;
 
    reader_skipspaces(reader);
 
    cur = reader_get_ptr(reader);
    if (*cur != '>')
    {
        FIXME("internal subset parsing not implemented\n");
        return E_NOTIMPL;
    }
 
    /* skip '>' */
    reader_skipn(reader, 1);
 
    reader->nodetype = XmlNodeType_DocumentType;
    reader_set_strvalue(reader, StringValue_LocalName, &name);
    reader_set_strvalue(reader, StringValue_QualifiedName, &name);
 
    return S_OK;
}

Referenced by reader_parse_nextnode().

reader_parse_element()

static HRESULT reader_parse_element ( xmlreader *  reader )

static

Definition at line 2284 of file reader.c.

{
    HRESULT hr;
 
    switch (reader->resumestate)
    {
    case XmlReadResumeState_Initial:
        /* check if we are really on element */
        if (reader_cmp(reader, L"<")) return S_FALSE;
 
        /* skip '<' */
        reader_skipn(reader, 1);
 
        reader_shrink(reader);
        reader->resumestate = XmlReadResumeState_STag;
    case XmlReadResumeState_STag:
    {
        strval qname, prefix, local;
 
        /* this handles empty elements too */
        hr = reader_parse_stag(reader, &prefix, &local, &qname);
        if (FAILED(hr)) return hr;
 
        /* FIXME: need to check for defined namespace to reject invalid prefix */
 
        /* if we got empty element and stack is empty go straight to Misc */
        if (reader->is_empty_element && list_empty(&reader->elements))
            reader->instate = XmlReadInState_MiscEnd;
        else
            reader->instate = XmlReadInState_Content;
 
        reader->nodetype = XmlNodeType_Element;
        reader->resumestate = XmlReadResumeState_Initial;
        reader_set_strvalue(reader, StringValue_Prefix, &prefix);
        reader_set_strvalue(reader, StringValue_QualifiedName, &qname);
        reader_set_strvalue(reader, StringValue_Value, &strval_empty);
        break;
    }
    default:
        hr = E_FAIL;
    }
 
    return hr;
}

Referenced by reader_parse_content(), and reader_parse_nextnode().

reader_parse_encdecl()

static HRESULT reader_parse_encdecl ( xmlreader *  reader, BOOL *  spaces  )

static

Definition at line 1297 of file reader.c.

{
    struct reader_position position;
    strval name, val;
    HRESULT hr;
 
    if (!(*spaces = reader_skipspaces(reader))) return S_FALSE;
 
    position = reader->position;
    if (reader_cmp(reader, L"encoding")) return S_FALSE;
    name.str = reader_get_ptr(reader);
    name.start = reader_get_cur(reader);
    name.len = 8;
    /* skip 'encoding' */
    reader_skipn(reader, 8);
 
    hr = reader_parse_eq(reader);
    if (FAILED(hr)) return hr;
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    hr = reader_parse_encname(reader, &val);
    if (FAILED(hr)) return hr;
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
 
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
    *spaces = FALSE;
 
    return reader_add_attr(reader, NULL, &name, NULL, &val, &position, 0);
}

Referenced by reader_parse_xmldecl().

reader_parse_encname()

static HRESULT reader_parse_encname ( xmlreader *  reader, strval *  val  )

static

Definition at line 1267 of file reader.c.

{
    WCHAR *start = reader_get_ptr(reader), *ptr;
    xml_encoding enc;
    int len;
 
    if ((*start < 'A' || *start > 'Z') && (*start < 'a' || *start > 'z'))
        return WC_E_ENCNAME;
 
    val->start = reader_get_cur(reader);
 
    ptr = start;
    while (is_wchar_encname(*++ptr))
        ;
 
    len = ptr - start;
    enc = parse_encoding_name(start, len);
    TRACE("encoding name %s\n", debugstr_wn(start, len));
    val->str = start;
    val->len = len;
 
    if (enc == XmlEncoding_Unknown)
        return WC_E_ENCNAME;
 
    /* skip encoding name */
    reader_skipn(reader, len);
    return S_OK;
}

Referenced by reader_parse_encdecl().

reader_parse_endtag()

static HRESULT reader_parse_endtag ( xmlreader *  reader )

static

Definition at line 2330 of file reader.c.

{
    struct reader_position position;
    strval prefix, local, qname;
    struct element *element;
    HRESULT hr;
 
    /* skip '</' */
    reader_skipn(reader, 2);
 
    position = reader->position;
    hr = reader_parse_qname(reader, &prefix, &local, &qname);
    if (FAILED(hr)) return hr;
 
    reader_skipspaces(reader);
 
    if (reader_cmp(reader, L">")) return WC_E_GREATERTHAN;
 
    /* skip '>' */
    reader_skipn(reader, 1);
 
    /* Element stack should never be empty at this point, cause we shouldn't get to
       content parsing if it's empty. */
    element = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
    if (!strval_eq(reader, &element->qname, &qname)) return WC_E_ELEMENTMATCH;
 
    /* update position stored for start tag, we won't be using it */
    element->position = position;
 
    reader->nodetype = XmlNodeType_EndElement;
    reader->is_empty_element = FALSE;
    reader_set_strvalue(reader, StringValue_Prefix, &prefix);
 
    return S_OK;
}

Referenced by reader_parse_content().

reader_parse_eq()

static HRESULT reader_parse_eq ( xmlreader *  reader )

static

Definition at line 1206 of file reader.c.

{
    reader_skipspaces(reader);
    if (reader_cmp(reader, L"=")) return WC_E_EQUAL;
    /* skip '=' */
    reader_skipn(reader, 1);
    reader_skipspaces(reader);
    return S_OK;
}

Referenced by reader_parse_attribute(), reader_parse_encdecl(), reader_parse_sddecl(), and reader_parse_versioninfo().

reader_parse_externalid()

static HRESULT reader_parse_externalid ( xmlreader *  reader )

static

Definition at line 1809 of file reader.c.

{
    static WCHAR systemW[] = L"SYSTEM";
    static WCHAR publicW[] = L"PUBLIC";
    struct reader_position position = reader->position;
    strval name, sys;
    HRESULT hr;
    int cnt;
 
    if (!reader_cmp(reader, publicW)) {
        strval pub;
 
        /* public id */
        reader_skipn(reader, 6);
        cnt = reader_skipspaces(reader);
        if (!cnt) return WC_E_WHITESPACE;
 
        hr = reader_parse_pub_literal(reader, &pub);
        if (FAILED(hr)) return hr;
 
        reader_init_cstrvalue(publicW, lstrlenW(publicW), &name);
        hr = reader_add_attr(reader, NULL, &name, NULL, &pub, &position, 0);
        if (FAILED(hr)) return hr;
 
        cnt = reader_skipspaces(reader);
        if (!cnt) return S_OK;
 
        /* optional system id */
        hr = reader_parse_sys_literal(reader, &sys);
        if (FAILED(hr)) return S_OK;
 
        reader_init_cstrvalue(systemW, lstrlenW(systemW), &name);
        hr = reader_add_attr(reader, NULL, &name, NULL, &sys, &position, 0);
        if (FAILED(hr)) return hr;
 
        return S_OK;
    } else if (!reader_cmp(reader, systemW)) {
        /* system id */
        reader_skipn(reader, 6);
        cnt = reader_skipspaces(reader);
        if (!cnt) return WC_E_WHITESPACE;
 
        hr = reader_parse_sys_literal(reader, &sys);
        if (FAILED(hr)) return hr;
 
        reader_init_cstrvalue(systemW, lstrlenW(systemW), &name);
        return reader_add_attr(reader, NULL, &name, NULL, &sys, &position, 0);
    }
 
    return S_FALSE;
}

Referenced by reader_parse_dtd().

reader_parse_local()

static HRESULT reader_parse_local ( xmlreader *  reader, strval *  local, BOOL  check_for_separator  )

static

Definition at line 1906 of file reader.c.

{
    WCHAR *ptr;
    UINT start;
 
    if (reader->resume[XmlReadResume_Local])
    {
        start = reader->resume[XmlReadResume_Local];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
    }
 
    while (is_ncnamechar(*ptr))
    {
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
    }
 
    if (check_for_separator && *ptr == ':')
        return NC_E_QNAMECOLON;
 
    if (is_reader_pending(reader))
    {
         reader->resume[XmlReadResume_Local] = start;
         return E_PENDING;
    }
    else
         reader->resume[XmlReadResume_Local] = 0;
 
    reader_init_strvalue(start, reader_get_cur(reader)-start, local);
 
    return S_OK;
}

Referenced by reader_parse_qname().

reader_parse_misc()

static HRESULT reader_parse_misc ( xmlreader *  reader )

static

Definition at line 1714 of file reader.c.

{
    HRESULT hr = S_FALSE;
 
    if (reader->resumestate != XmlReadResumeState_Initial)
    {
        hr = reader_more(reader);
        if (FAILED(hr)) return hr;
 
        /* finish current node */
        switch (reader->resumestate)
        {
        case XmlReadResumeState_PITarget:
        case XmlReadResumeState_PIBody:
            return reader_parse_pi(reader);
        case XmlReadResumeState_Comment:
            return reader_parse_comment(reader);
        case XmlReadResumeState_Whitespace:
            return reader_parse_whitespace(reader);
        default:
            ERR("unknown resume state %d\n", reader->resumestate);
        }
    }
 
    while (1)
    {
        const WCHAR *cur = reader_get_ptr(reader);
 
        if (is_wchar_space(*cur))
            hr = reader_parse_whitespace(reader);
        else if (!reader_cmp(reader, L"<!--"))
            hr = reader_parse_comment(reader);
        else if (!reader_cmp(reader, L"<?"))
            hr = reader_parse_pi(reader);
        else
            break;
 
        if (hr != S_FALSE) return hr;
    }
 
    return hr;
}

Referenced by reader_parse_nextnode().

reader_parse_name()

static HRESULT reader_parse_name ( xmlreader *  reader, strval *  name  )

static

Definition at line 1548 of file reader.c.

{
    WCHAR *ptr;
    UINT start;
 
    if (reader->resume[XmlReadResume_Name])
    {
        start = reader->resume[XmlReadResume_Name];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
        if (!is_namestartchar(*ptr)) return WC_E_NAMECHARACTER;
    }
 
    while (is_namechar(*ptr))
    {
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
    }
 
    if (is_reader_pending(reader))
    {
        reader->resume[XmlReadResume_Name] = start;
        return E_PENDING;
    }
    else
        reader->resume[XmlReadResume_Name] = 0;
 
    reader_init_strvalue(start, reader_get_cur(reader)-start, name);
    TRACE("name %s:%d\n", debug_strval(reader, name), name->len);
 
    return S_OK;
}

Referenced by reader_parse_dtd(), reader_parse_pitarget(), and reader_parse_reference().

reader_parse_nextnode()

static HRESULT reader_parse_nextnode ( xmlreader *  reader )

static

Definition at line 2522 of file reader.c.

{
    XmlNodeType nodetype = reader_get_nodetype(reader);
    HRESULT hr;
 
    if (!is_reader_pending(reader))
    {
        reader->chunk_read_off = 0;
        reader_clear_attrs(reader);
    }
 
    /* When moving from EndElement or empty element, pop its own namespace definitions */
    switch (nodetype)
    {
    case XmlNodeType_Attribute:
        reader_dec_depth(reader);
        /* fallthrough */
    case XmlNodeType_Element:
        if (reader->is_empty_element)
            reader_pop_ns_nodes(reader, &reader->empty_element);
        else if (FAILED(hr = reader_inc_depth(reader)))
            return hr;
        break;
    case XmlNodeType_EndElement:
        reader_pop_element(reader);
        reader_dec_depth(reader);
        break;
    default:
        ;
    }
 
    for (;;)
    {
        switch (reader->instate)
        {
        /* if it's a first call for a new input we need to detect stream encoding */
        case XmlReadInState_Initial:
            {
                xml_encoding enc;
 
                hr = readerinput_growraw(reader->input);
                if (FAILED(hr)) return hr;
 
                reader->position.line_number = 1;
                reader->position.line_position = 1;
 
                /* try to detect encoding by BOM or data and set input code page */
                hr = readerinput_detectencoding(reader->input, &enc);
                TRACE("detected encoding %s, %#lx.\n", enc == XmlEncoding_Unknown ? "(unknown)" :
                        debugstr_w(xml_encoding_map[enc].name), hr);
                if (FAILED(hr)) return hr;
 
                /* always switch first time cause we have to put something in */
                readerinput_switchencoding(reader->input, enc);
 
                /* parse xml declaration */
                hr = reader_parse_xmldecl(reader);
                if (FAILED(hr)) return hr;
 
                readerinput_shrinkraw(reader->input, -1);
                reader->instate = XmlReadInState_Misc_DTD;
                if (hr == S_OK) return hr;
            }
            break;
        case XmlReadInState_Misc_DTD:
            hr = reader_parse_misc(reader);
            if (FAILED(hr)) return hr;
 
            if (hr == S_FALSE)
                reader->instate = XmlReadInState_DTD;
            else
                return hr;
            break;
        case XmlReadInState_DTD:
            hr = reader_parse_dtd(reader);
            if (FAILED(hr)) return hr;
 
            if (hr == S_OK)
            {
                reader->instate = XmlReadInState_DTD_Misc;
                return hr;
            }
            else
                reader->instate = XmlReadInState_Element;
            break;
        case XmlReadInState_DTD_Misc:
            hr = reader_parse_misc(reader);
            if (FAILED(hr)) return hr;
 
            if (hr == S_FALSE)
                reader->instate = XmlReadInState_Element;
            else
                return hr;
            break;
        case XmlReadInState_Element:
            return reader_parse_element(reader);
        case XmlReadInState_Content:
            return reader_parse_content(reader);
        case XmlReadInState_MiscEnd:
            hr = reader_parse_misc(reader);
            if (hr != S_FALSE) return hr;
 
            if (*reader_get_ptr(reader))
            {
                WARN("found garbage in the end of XML\n");
                return WC_E_SYNTAX;
            }
 
            reader->instate = XmlReadInState_Eof;
            reader->state = XmlReadState_EndOfFile;
            reader->nodetype = XmlNodeType_None;
            return hr;
        case XmlReadInState_Eof:
            return S_FALSE;
        default:
            FIXME("internal state %d not handled\n", reader->instate);
            return E_NOTIMPL;
        }
    }
 
    return E_NOTIMPL;
}

Referenced by xmlreader_Read().

reader_parse_pi()

static HRESULT reader_parse_pi ( xmlreader *  reader )

static

Definition at line 1613 of file reader.c.

{
    strval target;
    WCHAR *ptr;
    UINT start;
    HRESULT hr;
 
    switch (reader->resumestate)
    {
    case XmlReadResumeState_Initial:
        /* skip '<?' */
        reader_skipn(reader, 2);
        reader_shrink(reader);
        reader->resumestate = XmlReadResumeState_PITarget;
    case XmlReadResumeState_PITarget:
        hr = reader_parse_pitarget(reader, &target);
        if (FAILED(hr)) return hr;
        reader_set_strvalue(reader, StringValue_LocalName, &target);
        reader_set_strvalue(reader, StringValue_QualifiedName, &target);
        reader_set_strvalue(reader, StringValue_Value, &strval_empty);
        reader->resumestate = XmlReadResumeState_PIBody;
        reader->resume[XmlReadResume_Body] = reader_get_cur(reader);
    default:
        ;
    }
 
    start = reader->resume[XmlReadResume_Body];
    ptr = reader_get_ptr(reader);
    while (*ptr)
    {
        if (ptr[0] == '?')
        {
            if (ptr[1] == '>')
            {
                UINT cur = reader_get_cur(reader);
                strval value;
 
                /* strip all leading whitespace chars */
                while (start < cur)
                {
                    ptr = reader_get_ptr2(reader, start);
                    if (!is_wchar_space(*ptr)) break;
                    start++;
                }
 
                reader_init_strvalue(start, cur-start, &value);
 
                /* skip '?>' */
                reader_skipn(reader, 2);
                TRACE("%s\n", debug_strval(reader, &value));
                reader->nodetype = XmlNodeType_ProcessingInstruction;
                reader->resumestate = XmlReadResumeState_Initial;
                reader->resume[XmlReadResume_Body] = 0;
                reader_set_strvalue(reader, StringValue_Value, &value);
                return S_OK;
            }
        }
 
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
    }
 
    return S_OK;
}

Referenced by reader_parse_content(), and reader_parse_misc().

reader_parse_pitarget()

static HRESULT reader_parse_pitarget ( xmlreader *  reader, strval *  target  )

static

Definition at line 1586 of file reader.c.

{
    static const strval xmlval = { (WCHAR *)L"xml", 3 };
    strval name;
    WCHAR *ptr;
    HRESULT hr;
    UINT i;
 
    hr = reader_parse_name(reader, &name);
    if (FAILED(hr)) return is_reader_pending(reader) ? E_PENDING : WC_E_PI;
 
    /* now that we got name check for illegal content */
    if (strval_eq(reader, &name, &xmlval))
        return WC_E_LEADINGXML;
 
    /* PITarget can't be a qualified name */
    ptr = reader_get_strptr(reader, &name);
    for (i = 0; i < name.len; i++)
        if (ptr[i] == ':')
            return i ? NC_E_NAMECOLON : WC_E_PI;
 
    TRACE("pitarget %s:%d\n", debug_strval(reader, &name), name.len);
    *target = name;
    return S_OK;
}

Referenced by reader_parse_pi().

reader_parse_pub_literal()

static HRESULT reader_parse_pub_literal ( xmlreader *  reader, strval *  literal  )

static

Definition at line 1784 of file reader.c.

{
    WCHAR *cur = reader_get_ptr(reader), quote;
    UINT start;
 
    if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
 
    quote = *cur;
    reader_skipn(reader, 1);
 
    start = reader_get_cur(reader);
    cur = reader_get_ptr(reader);
    while (is_pubchar(*cur) && *cur != quote)
    {
        reader_skipn(reader, 1);
        cur = reader_get_ptr(reader);
    }
    reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
    if (*cur == quote) reader_skipn(reader, 1);
 
    TRACE("%s\n", debug_strval(reader, literal));
    return S_OK;
}

Referenced by reader_parse_externalid().

reader_parse_qname()

static HRESULT reader_parse_qname ( xmlreader *  reader, strval *  prefix, strval *  local, strval *  qname  )

static

Definition at line 1948 of file reader.c.

{
    WCHAR *ptr;
    UINT start;
    HRESULT hr;
 
    if (reader->resume[XmlReadResume_Name])
    {
        start = reader->resume[XmlReadResume_Name];
        ptr = reader_get_ptr(reader);
    }
    else
    {
        ptr = reader_get_ptr(reader);
        start = reader_get_cur(reader);
        reader->resume[XmlReadResume_Name] = start;
        if (!is_ncnamechar(*ptr)) return NC_E_QNAMECHARACTER;
    }
 
    if (reader->resume[XmlReadResume_Local])
    {
        hr = reader_parse_local(reader, local, FALSE);
        if (FAILED(hr)) return hr;
 
        reader_init_strvalue(reader->resume[XmlReadResume_Name],
                             local->start - reader->resume[XmlReadResume_Name] - 1,
                             prefix);
    }
    else
    {
        /* skip prefix part */
        while (is_ncnamechar(*ptr))
        {
            reader_skipn(reader, 1);
            ptr = reader_get_ptr(reader);
        }
 
        if (is_reader_pending(reader)) return E_PENDING;
 
        /* got a qualified name */
        if (*ptr == ':')
        {
            reader_init_strvalue(start, reader_get_cur(reader)-start, prefix);
 
            /* skip ':' */
            reader_skipn(reader, 1);
            hr = reader_parse_local(reader, local, TRUE);
            if (FAILED(hr)) return hr;
        }
        else
        {
            reader_init_strvalue(reader->resume[XmlReadResume_Name], reader_get_cur(reader)-reader->resume[XmlReadResume_Name], local);
            reader_init_strvalue(0, 0, prefix);
        }
    }
 
    if (prefix->len)
        TRACE("qname %s:%s\n", debug_strval(reader, prefix), debug_strval(reader, local));
    else
        TRACE("ncname %s\n", debug_strval(reader, local));
 
    reader_init_strvalue(prefix->len ? prefix->start : local->start,
                        /* count ':' too */
                        (prefix->len ? prefix->len + 1 : 0) + local->len,
                         qname);
 
    reader->resume[XmlReadResume_Name] = 0;
    reader->resume[XmlReadResume_Local] = 0;
 
    return S_OK;
}

Referenced by reader_parse_attribute(), reader_parse_endtag(), and reader_parse_stag().

reader_parse_reference()

static HRESULT reader_parse_reference ( xmlreader *  reader )

static

Definition at line 2056 of file reader.c.

{
    encoded_buffer *buffer = &reader->input->buffer->utf16;
    WCHAR *start = reader_get_ptr(reader), *ptr;
    UINT cur = reader_get_cur(reader);
    WCHAR ch = 0;
    int len;
 
    /* skip '&' */
    reader_skipn(reader, 1);
    ptr = reader_get_ptr(reader);
 
    if (*ptr == '#')
    {
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
 
        /* hex char or decimal */
        if (*ptr == 'x')
        {
            reader_skipn(reader, 1);
            ptr = reader_get_ptr(reader);
 
            while (*ptr != ';')
            {
                if ((*ptr >= '0' && *ptr <= '9'))
                    ch = ch*16 + *ptr - '0';
                else if ((*ptr >= 'a' && *ptr <= 'f'))
                    ch = ch*16 + *ptr - 'a' + 10;
                else if ((*ptr >= 'A' && *ptr <= 'F'))
                    ch = ch*16 + *ptr - 'A' + 10;
                else
                    return ch ? WC_E_SEMICOLON : WC_E_HEXDIGIT;
                reader_skipn(reader, 1);
                ptr = reader_get_ptr(reader);
            }
        }
        else
        {
            while (*ptr != ';')
            {
                if ((*ptr >= '0' && *ptr <= '9'))
                {
                    ch = ch*10 + *ptr - '0';
                    reader_skipn(reader, 1);
                    ptr = reader_get_ptr(reader);
                }
                else
                    return ch ? WC_E_SEMICOLON : WC_E_DIGIT;
            }
        }
 
        if (!is_char(ch)) return WC_E_XMLCHARACTER;
 
        /* normalize */
        if (is_wchar_space(ch)) ch = ' ';
 
        ptr = reader_get_ptr(reader);
        start = reader_get_ptr2(reader, cur);
        len = buffer->written - ((char *)ptr - buffer->data);
        memmove(start + 1, ptr + 1, len);
 
        buffer->written -= (reader_get_cur(reader) - cur) * sizeof(WCHAR);
        *(WCHAR*)(buffer->data + buffer->written) = 0;
        buffer->cur = cur + 1;
 
        *start = ch;
    }
    else
    {
        strval name;
        HRESULT hr;
 
        hr = reader_parse_name(reader, &name);
        if (FAILED(hr)) return hr;
 
        ptr = reader_get_ptr(reader);
        if (*ptr != ';') return WC_E_SEMICOLON;
 
        /* predefined entities resolve to a single character */
        ch = get_predefined_entity(reader, &name);
        if (ch)
        {
            len = buffer->written - ((char*)ptr - buffer->data) - sizeof(WCHAR);
            memmove(start+1, ptr+1, len);
            buffer->cur = cur + 1;
            buffer->written -= (ptr - start) * sizeof(WCHAR);
            *(WCHAR*)(buffer->data + buffer->written) = 0;
 
            *start = ch;
        }
        else
        {
            FIXME("undeclared entity %s\n", debug_strval(reader, &name));
            return WC_E_UNDECLAREDENTITY;
        }
 
    }
 
    return S_OK;
}

Referenced by reader_parse_attvalue(), and reader_parse_chardata().

reader_parse_sddecl()

static HRESULT reader_parse_sddecl ( xmlreader *  reader, BOOL  spaces  )

static

Definition at line 1335 of file reader.c.

{
    struct reader_position position;
    strval name, val;
    UINT start;
    HRESULT hr;
 
    if (!spaces && !reader_skipspaces(reader)) return S_FALSE;
 
    position = reader->position;
    if (reader_cmp(reader, L"standalone")) return S_FALSE;
    reader_init_strvalue(reader_get_cur(reader), 10, &name);
    /* skip 'standalone' */
    reader_skipn(reader, 10);
 
    hr = reader_parse_eq(reader);
    if (FAILED(hr)) return hr;
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    if (reader_cmp(reader, L"yes") && reader_cmp(reader, L"no"))
        return WC_E_XMLDECL;
 
    start = reader_get_cur(reader);
    /* skip 'yes'|'no' */
    reader_skipn(reader, reader_cmp(reader, L"yes") ? 2 : 3);
    reader_init_strvalue(start, reader_get_cur(reader)-start, &val);
    TRACE("standalone=%s\n", debug_strval(reader, &val));
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    return reader_add_attr(reader, NULL, &name, NULL, &val, &position, 0);
}

Referenced by reader_parse_xmldecl().

reader_parse_stag()

static HRESULT reader_parse_stag ( xmlreader *  reader, strval *  prefix, strval *  local, strval *  qname  )

static

Definition at line 2237 of file reader.c.

{
    struct reader_position position = reader->position;
    HRESULT hr;
 
    hr = reader_parse_qname(reader, prefix, local, qname);
    if (FAILED(hr)) return hr;
 
    for (;;)
    {
        reader_skipspaces(reader);
 
        /* empty element */
        if ((reader->is_empty_element = !reader_cmp(reader, L"/>")))
        {
            struct element *element = &reader->empty_element;
 
            /* skip '/>' */
            reader_skipn(reader, 2);
 
            reader_free_strvalued(reader, &element->qname);
            reader_free_strvalued(reader, &element->localname);
 
            element->prefix = *prefix;
            reader_strvaldup(reader, qname, &element->qname);
            reader_strvaldup(reader, local, &element->localname);
            element->position = position;
            reader_mark_ns_nodes(reader, element);
            return S_OK;
        }
 
        /* got a start tag */
        if (!reader_cmp(reader, L">"))
        {
            /* skip '>' */
            reader_skipn(reader, 1);
            return reader_push_element(reader, prefix, local, qname, &position);
        }
 
        hr = reader_parse_attribute(reader);
        if (FAILED(hr)) return hr;
    }
 
    return S_OK;
}

Referenced by reader_parse_element().

reader_parse_sys_literal()

static HRESULT reader_parse_sys_literal ( xmlreader *  reader, strval *  literal  )

static

Definition at line 1758 of file reader.c.

{
    WCHAR *cur = reader_get_ptr(reader), quote;
    UINT start;
 
    if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
 
    quote = *cur;
    reader_skipn(reader, 1);
 
    cur = reader_get_ptr(reader);
    start = reader_get_cur(reader);
    while (is_char(*cur) && *cur != quote)
    {
        reader_skipn(reader, 1);
        cur = reader_get_ptr(reader);
    }
    reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
    if (*cur == quote) reader_skipn(reader, 1);
 
    TRACE("%s\n", debug_strval(reader, literal));
    return S_OK;
}

Referenced by reader_parse_externalid().

reader_parse_versioninfo()

static HRESULT reader_parse_versioninfo ( xmlreader *  reader )

static

Definition at line 1222 of file reader.c.

{
    struct reader_position position;
    strval val, name;
    HRESULT hr;
 
    if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
 
    position = reader->position;
    if (reader_cmp(reader, L"version")) return WC_E_XMLDECL;
    reader_init_strvalue(reader_get_cur(reader), 7, &name);
    /* skip 'version' */
    reader_skipn(reader, 7);
 
    hr = reader_parse_eq(reader);
    if (FAILED(hr)) return hr;
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    hr = reader_parse_versionnum(reader, &val);
    if (FAILED(hr)) return hr;
 
    if (!reader_is_quote(reader))
        return WC_E_QUOTE;
 
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    return reader_add_attr(reader, NULL, &name, NULL, &val, &position, 0);
}

Referenced by reader_parse_xmldecl().

reader_parse_versionnum()

static HRESULT reader_parse_versionnum ( xmlreader *  reader, strval *  val  )

static

Definition at line 1181 of file reader.c.

{
    WCHAR *ptr, *ptr2;
    UINT start;
 
    if (reader_cmp(reader, L"1.")) return WC_E_XMLDECL;
 
    start = reader_get_cur(reader);
    /* skip "1." */
    reader_skipn(reader, 2);
 
    ptr2 = ptr = reader_get_ptr(reader);
    while (*ptr >= '0' && *ptr <= '9')
    {
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
    }
 
    if (ptr2 == ptr) return WC_E_DIGIT;
    reader_init_strvalue(start, reader_get_cur(reader)-start, val);
    TRACE("version=%s\n", debug_strval(reader, val));
    return S_OK;
}

Referenced by reader_parse_versioninfo().

reader_parse_whitespace()

static HRESULT reader_parse_whitespace ( xmlreader *  reader )

static

Definition at line 1679 of file reader.c.

{
    switch (reader->resumestate)
    {
    case XmlReadResumeState_Initial:
        reader_shrink(reader);
        reader->resumestate = XmlReadResumeState_Whitespace;
        reader->resume[XmlReadResume_Body] = reader_get_cur(reader);
        reader->nodetype = XmlNodeType_Whitespace;
        reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
        reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
        reader_set_strvalue(reader, StringValue_Value, &strval_empty);
        /* fallthrough */
    case XmlReadResumeState_Whitespace:
    {
        strval value;
        UINT start;
 
        reader_skipspaces(reader);
        if (is_reader_pending(reader)) return S_OK;
 
        start = reader->resume[XmlReadResume_Body];
        reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
        reader_set_strvalue(reader, StringValue_Value, &value);
        TRACE("%s\n", debug_strval(reader, &value));
        reader->resumestate = XmlReadResumeState_Initial;
    }
    default:
        ;
    }
 
    return S_OK;
}

Referenced by reader_parse_misc().

reader_parse_xmldecl()

static HRESULT reader_parse_xmldecl ( xmlreader *  reader )

static

Definition at line 1376 of file reader.c.

{
    struct reader_position position;
    BOOL spaces;
    HRESULT hr;
 
    if (reader_cmp(reader, L"<?xml "))
        return S_FALSE;
 
    reader_skipn(reader, 2);
    position = reader->position;
    reader_skipn(reader, 3);
    hr = reader_parse_versioninfo(reader);
    if (FAILED(hr))
        return hr;
 
    if (FAILED(hr = reader_parse_encdecl(reader, &spaces)))
        return hr;
 
    if (FAILED(hr = reader_parse_sddecl(reader, spaces)))
        return hr;
 
    reader_skipspaces(reader);
    if (reader_cmp(reader, L"?>"))
        return WC_E_XMLDECL;
 
    /* skip '?>' */
    reader_skipn(reader, 2);
 
    reader->nodetype = XmlNodeType_XmlDeclaration;
    reader->empty_element.position = position;
    reader_set_strvalue(reader, StringValue_LocalName, &strval_xml);
    reader_set_strvalue(reader, StringValue_QualifiedName, &strval_xml);
 
    return S_OK;
}

Referenced by reader_parse_nextnode().

reader_pop_element()

static void reader_pop_element ( xmlreader *  reader )

static

Definition at line 645 of file reader.c.

{
    struct element *element;
 
    if (list_empty(&reader->elements))
        return;
 
    element = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
    list_remove(&element->entry);
 
    reader_pop_ns_nodes(reader, element);
    reader_free_element(reader, element);
 
    /* It was a root element, the rest is expected as Misc */
    if (list_empty(&reader->elements))
        reader->instate = XmlReadInState_MiscEnd;
}

Referenced by reader_parse_nextnode().

reader_pop_ns_nodes()

static void reader_pop_ns_nodes ( xmlreader *  reader, struct element *  element  )

static

Definition at line 620 of file reader.c.

{
    struct ns *ns, *ns2;
 
    LIST_FOR_EACH_ENTRY_SAFE_REV(ns, ns2, &reader->ns, struct ns, entry) {
        if (ns->element != element)
            break;
 
        list_remove(&ns->entry);
        reader_free_strvalued(reader, &ns->prefix);
        reader_free_strvalued(reader, &ns->uri);
        reader_free(reader, ns);
    }
 
    if (!list_empty(&reader->nsdef)) {
        ns = LIST_ENTRY(list_head(&reader->nsdef), struct ns, entry);
        if (ns->element == element) {
            list_remove(&ns->entry);
            reader_free_strvalued(reader, &ns->prefix);
            reader_free_strvalued(reader, &ns->uri);
            reader_free(reader, ns);
        }
    }
}

Referenced by reader_parse_nextnode(), and reader_pop_element().

reader_push_element()

static HRESULT reader_push_element ( xmlreader *  reader, strval *  prefix, strval *  localname, strval *  qname, const struct reader_position *  position  )

static

Definition at line 595 of file reader.c.

{
    struct element *element;
    HRESULT hr;
 
    element = reader_alloc_zero(reader, sizeof(*element));
    if (!element)
        return E_OUTOFMEMORY;
 
    if ((hr = reader_strvaldup(reader, prefix, &element->prefix)) == S_OK &&
            (hr = reader_strvaldup(reader, localname, &element->localname)) == S_OK &&
            (hr = reader_strvaldup(reader, qname, &element->qname)) == S_OK)
    {
        list_add_head(&reader->elements, &element->entry);
        reader_mark_ns_nodes(reader, element);
        reader->is_empty_element = FALSE;
        element->position = *position;
    }
    else
        reader_free_element(reader, element);
 
    return hr;
}

Referenced by reader_parse_stag().

reader_push_ns()

static HRESULT reader_push_ns ( xmlreader *  reader, const strval *  prefix, const strval *  uri, BOOL  def  )

static

Definition at line 540 of file reader.c.

{
    struct ns *ns;
    HRESULT hr;
 
    ns = reader_alloc(reader, sizeof(*ns));
    if (!ns) return E_OUTOFMEMORY;
 
    if (def)
        memset(&ns->prefix, 0, sizeof(ns->prefix));
    else {
        hr = reader_strvaldup(reader, prefix, &ns->prefix);
        if (FAILED(hr)) {
            reader_free(reader, ns);
            return hr;
        }
    }
 
    hr = reader_strvaldup(reader, uri, &ns->uri);
    if (FAILED(hr)) {
        reader_free_strvalued(reader, &ns->prefix);
        reader_free(reader, ns);
        return hr;
    }
 
    ns->element = NULL;
    list_add_head(def ? &reader->nsdef : &reader->ns, &ns->entry);
    return hr;
}

Referenced by reader_parse_attribute().

reader_reset_parser()

static void reader_reset_parser ( xmlreader *  reader )

static

Definition at line 2692 of file reader.c.

{
    reader->position.line_number = 0;
    reader->position.line_position = 0;
 
    reader_clear_elements(reader);
    reader_clear_attrs(reader);
    reader_clear_ns(reader);
    reader_free_strvalues(reader);
 
    reader->depth = 0;
    reader->nodetype = XmlNodeType_None;
    reader->resumestate = XmlReadResumeState_Initial;
    memset(reader->resume, 0, sizeof(reader->resume));
    reader->is_empty_element = FALSE;
}

Referenced by xmlreader_Release(), and xmlreader_SetInput().

reader_set_current_attribute()

static void reader_set_current_attribute ( xmlreader *  reader, struct attribute *  attr  )

static

Definition at line 2918 of file reader.c.

{
    if (!reader->attr)
        reader_inc_depth(reader);
    reader->attr = attr;
    reader->chunk_read_off = 0;
    reader_set_strvalue(reader, StringValue_Prefix, &attr->prefix);
    reader_set_strvalue(reader, StringValue_QualifiedName, &attr->qname);
    reader_set_strvalue(reader, StringValue_Value, &attr->value);
}

Referenced by reader_move_to_first_attribute(), xmlreader_MoveToAttributeByName(), and xmlreader_MoveToNextAttribute().

reader_set_strvalue()

static void reader_set_strvalue ( xmlreader *  reader, XmlReaderStringValue  type, const strval *  value  )

static

Definition at line 665 of file reader.c.

{
    strval *v = &reader->strvalues[type];
 
    reader_free_strvalue(reader, type);
    if (!value)
    {
        v->str = NULL;
        v->start = 0;
        v->len = 0;
        return;
    }
 
    if (value->str == strval_empty.str)
        *v = *value;
    else
    {
        if (type == StringValue_Value)
        {
            /* defer allocation for value string */
            v->str = NULL;
            v->start = value->start;
            v->len = value->len;
        }
        else
        {
            v->str = reader_alloc(reader, (value->len + 1)*sizeof(WCHAR));
            memcpy(v->str, reader_get_strptr(reader, value), value->len*sizeof(WCHAR));
            v->str[value->len] = 0;
            v->len = value->len;
        }
    }
}

Referenced by reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_dtd(), reader_parse_element(), reader_parse_endtag(), reader_parse_pi(), reader_parse_whitespace(), reader_parse_xmldecl(), reader_set_current_attribute(), and xmlreader_MoveToElement().

reader_shrink()

static void reader_shrink ( xmlreader *  reader )

static

Definition at line 1052 of file reader.c.

{
    encoded_buffer *buffer = &reader->input->buffer->utf16;
 
    /* avoid to move too often using threshold shrink length */
    if (buffer->cur*sizeof(WCHAR) > buffer->written / 2)
    {
        buffer->written -= buffer->cur*sizeof(WCHAR);
        memmove(buffer->data, (WCHAR*)buffer->data + buffer->cur, buffer->written);
        buffer->cur = 0;
        *(WCHAR*)&buffer->data[buffer->written] = 0;
    }
}

Referenced by reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_content(), reader_parse_dtd(), reader_parse_element(), reader_parse_pi(), and reader_parse_whitespace().

reader_skipn()

static void reader_skipn ( xmlreader *  reader, int  n  )

static

Definition at line 1153 of file reader.c.

{
    encoded_buffer *buffer = &reader->input->buffer->utf16;
    const WCHAR *ptr;
 
    while (*(ptr = reader_get_ptr(reader)) && n--)
    {
        reader_update_position(reader, *ptr);
        buffer->cur++;
    }
}

Referenced by reader_parse_attvalue(), reader_parse_cdata(), reader_parse_chardata(), reader_parse_comment(), reader_parse_dtd(), reader_parse_element(), reader_parse_encdecl(), reader_parse_encname(), reader_parse_endtag(), reader_parse_eq(), reader_parse_externalid(), reader_parse_local(), reader_parse_name(), reader_parse_pi(), reader_parse_pub_literal(), reader_parse_qname(), reader_parse_reference(), reader_parse_sddecl(), reader_parse_stag(), reader_parse_sys_literal(), reader_parse_versioninfo(), reader_parse_versionnum(), reader_parse_xmldecl(), and reader_skipspaces().

reader_skipspaces()

static int reader_skipspaces ( xmlreader *  reader )

static

Definition at line 1166 of file reader.c.

{
    const WCHAR *ptr = reader_get_ptr(reader);
    UINT start = reader_get_cur(reader);
 
    while (is_wchar_space(*ptr))
    {
        reader_skipn(reader, 1);
        ptr = reader_get_ptr(reader);
    }
 
    return reader_get_cur(reader) - start;
}

Referenced by reader_parse_dtd(), reader_parse_encdecl(), reader_parse_endtag(), reader_parse_eq(), reader_parse_externalid(), reader_parse_sddecl(), reader_parse_stag(), reader_parse_versioninfo(), reader_parse_whitespace(), and reader_parse_xmldecl().

reader_strvaldup()

static HRESULT reader_strvaldup ( xmlreader *  reader, const strval *  src, strval *  dest  )

static

Definition at line 343 of file reader.c.

{
    *dest = *src;
 
    if (src->str != strval_empty.str)
    {
        dest->str = reader_alloc(reader, (dest->len+1)*sizeof(WCHAR));
        if (!dest->str) return E_OUTOFMEMORY;
        memcpy(dest->str, reader_get_strptr(reader, src), dest->len*sizeof(WCHAR));
        dest->str[dest->len] = 0;
        dest->start = 0;
    }
 
    return S_OK;
}

Referenced by reader_add_attr(), reader_parse_stag(), reader_push_element(), and reader_push_ns().

reader_update_position()

static void reader_update_position ( xmlreader *  reader, WCHAR  ch  )

static

Definition at line 1139 of file reader.c.

{
    if (ch == '\r')
        reader->position.line_position = 1;
    else if (ch == '\n')
    {
        reader->position.line_number++;
        reader->position.line_position = 1;
    }
    else
        reader->position.line_position++;
}

Referenced by reader_skipn().

readerinput_alloc()

static void * readerinput_alloc ( xmlreaderinput *  input, size_t  len  )

inlinestatic

Definition at line 360 of file reader.c.

{
    return m_alloc(input->imalloc, len);
}

Referenced by alloc_input_buffer(), init_encoded_buffer(), and readerinput_strdupW().

readerinput_detectencoding()

static HRESULT readerinput_detectencoding ( xmlreaderinput *  readerinput, xml_encoding *  enc  )

static

Definition at line 890 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    static const char utf8bom[] = {0xef,0xbb,0xbf};
    static const char utf16lebom[] = {0xff,0xfe};
    WCHAR *ptrW;
 
    *enc = XmlEncoding_Unknown;
 
    if (buffer->written <= 3)
    {
        HRESULT hr = readerinput_growraw(readerinput);
        if (FAILED(hr)) return hr;
        if (buffer->written < 3) return MX_E_INPUTEND;
    }
 
    ptrW = (WCHAR *)buffer->data;
    /* try start symbols if we have enough data to do that, input buffer should contain
       first chunk already */
    if (readerinput_is_utf8(readerinput))
        *enc = XmlEncoding_UTF8;
    else if (*ptrW == '<')
    {
        ptrW++;
        if (*ptrW == '?' || *ptrW == '!' || is_namestartchar(*ptrW))
            *enc = XmlEncoding_UTF16;
    }
    /* try with BOM now */
    else if (!memcmp(buffer->data, utf8bom, sizeof(utf8bom)))
    {
        buffer->cur += sizeof(utf8bom);
        *enc = XmlEncoding_UTF8;
    }
    else if (!memcmp(buffer->data, utf16lebom, sizeof(utf16lebom)))
    {
        buffer->cur += sizeof(utf16lebom);
        *enc = XmlEncoding_UTF16;
    }
 
    return S_OK;
}

Referenced by reader_parse_nextnode().

readerinput_free()

static void readerinput_free ( xmlreaderinput *  input, void *  mem  )

inlinestatic

Definition at line 370 of file reader.c.

{
    m_free(input->imalloc, mem);
}

Referenced by alloc_input_buffer(), create_reader_input(), free_encoded_buffer(), free_input_buffer(), and xmlreaderinput_Release().

readerinput_get_convlen()

static int readerinput_get_convlen ( xmlreaderinput *  readerinput )

static

Definition at line 952 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    int len;
 
    if (readerinput->buffer->code_page == CP_UTF8)
        len = readerinput_get_utf8_convlen(readerinput);
    else
        len = buffer->written;
 
    TRACE("%d\n", len - buffer->cur);
    return len - buffer->cur;
}

Referenced by reader_more(), readerinput_shrinkraw(), and readerinput_switchencoding().

readerinput_get_utf8_convlen()

static int readerinput_get_utf8_convlen ( xmlreaderinput *  readerinput )

static

Definition at line 932 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    int len = buffer->written;
 
    assert(len);
 
    /* complete single byte char */
    if (!(buffer->data[len-1] & 0x80)) return len;
 
    /* find start byte of multibyte char */
    while (--len && !(buffer->data[len] & 0xc0))
        ;
 
    return len;
}

Referenced by readerinput_get_convlen().

readerinput_grow()

static void readerinput_grow ( xmlreaderinput *  readerinput, int  length  )

static

Definition at line 857 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->utf16;
 
    length *= sizeof(WCHAR);
    /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
    if (buffer->allocated < buffer->written + length + 4)
    {
        int grown_size = max(2*buffer->allocated, buffer->allocated + length);
        buffer->data = readerinput_realloc(readerinput, buffer->data, grown_size);
        buffer->allocated = grown_size;
    }
}

Referenced by reader_more(), and readerinput_switchencoding().

readerinput_growraw()

static HRESULT readerinput_growraw ( xmlreaderinput *  readerinput )

static

Definition at line 825 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    /* to make sure aligned length won't exceed allocated length */
    ULONG len = buffer->allocated - buffer->written - 4;
    ULONG read;
    HRESULT hr;
 
    /* always try to get aligned to 4 bytes, so the only case we can get partially read characters is
       variable width encodings like UTF-8 */
    len = (len + 3) & ~3;
    /* try to use allocated space or grow */
    if (buffer->allocated - buffer->written < len)
    {
        buffer->allocated *= 2;
        buffer->data = readerinput_realloc(readerinput, buffer->data, buffer->allocated);
        len = buffer->allocated - buffer->written;
    }
 
    read = 0;
    hr = ISequentialStream_Read(readerinput->stream, buffer->data + buffer->written, len, &read);
    TRACE("written=%d, alloc=%d, requested=%ld, read=%ld, ret=%#lx\n", buffer->written, buffer->allocated, len, read, hr);
    readerinput->pending = hr == E_PENDING;
    if (FAILED(hr)) return hr;
    buffer->written += read;
    if (!buffer->written)
        return MX_E_INPUTEND;
 
    return hr;
}

Referenced by reader_more(), reader_parse_nextnode(), and readerinput_detectencoding().

readerinput_is_utf8()

static BOOL readerinput_is_utf8 ( xmlreaderinput *  readerinput )

inlinestatic

Definition at line 871 of file reader.c.

{
    static const char startA[] = {'<','?'};
    static const char commentA[] = {'<','!'};
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    unsigned char *ptr = (unsigned char*)buffer->data;
 
    return !memcmp(buffer->data, startA, sizeof(startA)) ||
           !memcmp(buffer->data, commentA, sizeof(commentA)) ||
           /* test start byte */
           (ptr[0] == '<' &&
            (
             (ptr[1] && (ptr[1] <= 0x7f)) ||
             (buffer->data[1] >> 5) == 0x6  || /* 2 bytes */
             (buffer->data[1] >> 4) == 0xe  || /* 3 bytes */
             (buffer->data[1] >> 3) == 0x1e)   /* 4 bytes */
           );
}

Referenced by readerinput_detectencoding().

readerinput_query_for_stream()

static HRESULT readerinput_query_for_stream ( xmlreaderinput *  readerinput )

inlinestatic

Definition at line 812 of file reader.c.

{
    HRESULT hr;
 
    readerinput_release_stream(readerinput);
    hr = IUnknown_QueryInterface(readerinput->input, &IID_IStream, (void**)&readerinput->stream);
    if (hr != S_OK)
        hr = IUnknown_QueryInterface(readerinput->input, &IID_ISequentialStream, (void**)&readerinput->stream);
 
    return hr;
}

Referenced by xmlreader_SetInput().

readerinput_realloc()

static void * readerinput_realloc ( xmlreaderinput *  input, void *  mem, size_t  len  )

inlinestatic

Definition at line 365 of file reader.c.

{
    return m_realloc(input->imalloc, mem, len);
}

Referenced by readerinput_grow(), and readerinput_growraw().

readerinput_release_stream()

static void readerinput_release_stream ( xmlreaderinput *  readerinput )

static

Definition at line 802 of file reader.c.

{
    if (readerinput->stream) {
        ISequentialStream_Release(readerinput->stream);
        readerinput->stream = NULL;
    }
}

Referenced by readerinput_query_for_stream(), and xmlreader_SetInput().

readerinput_shrinkraw()

static void readerinput_shrinkraw ( xmlreaderinput *  readerinput, int  len  )

static

Definition at line 969 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
 
    if (len == -1)
        len = readerinput_get_convlen(readerinput);
 
    assert(len >= 0);
    memmove(buffer->data, buffer->data + buffer->cur + (buffer->written - len), len);
    /* everything below cur is lost too */
    buffer->written -= len + buffer->cur;
    /* after this point we don't need cur offset really,
       it's used only to mark where actual data begins when first chunk is read */
    buffer->cur = 0;
}

Referenced by reader_more(), and reader_parse_nextnode().

readerinput_strdupW()

static WCHAR * readerinput_strdupW ( xmlreaderinput *  input, const WCHAR *  str  )

inlinestatic

Definition at line 375 of file reader.c.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD size;
 
        size = (lstrlenW(str)+1)*sizeof(WCHAR);
        ret = readerinput_alloc(input, size);
        if (ret) memcpy(ret, str, size);
    }
 
    return ret;
}

Referenced by create_reader_input().

readerinput_switchencoding()

static void readerinput_switchencoding ( xmlreaderinput *  readerinput, xml_encoding  enc  )

static

Definition at line 1014 of file reader.c.

{
    encoded_buffer *src = &readerinput->buffer->encoded;
    encoded_buffer *dest = &readerinput->buffer->utf16;
    int len, dest_len;
    UINT cp = ~0u;
    HRESULT hr;
    WCHAR *ptr;
 
    hr = get_code_page(enc, &cp);
    if (FAILED(hr)) return;
 
    readerinput->buffer->code_page = cp;
    len = readerinput_get_convlen(readerinput);
 
    TRACE("switching to cp %d\n", cp);
 
    /* just copy in this case */
    if (enc == XmlEncoding_UTF16)
    {
        readerinput_grow(readerinput, len);
        memcpy(dest->data, src->data + src->cur, len);
        dest->written += len;
    }
    else
    {
        dest_len = MultiByteToWideChar(cp, 0, src->data + src->cur, len, NULL, 0);
        readerinput_grow(readerinput, dest_len);
        ptr = (WCHAR*)dest->data;
        MultiByteToWideChar(cp, 0, src->data + src->cur, len, ptr, dest_len);
        ptr[dest_len] = 0;
        dest->written += dest_len*sizeof(WCHAR);
    }
 
    fixup_buffer_cr(dest, 0);
}

Referenced by reader_parse_nextnode().

strval_eq()

static int strval_eq ( const xmlreader *  reader, const strval *  str1, const strval *  str2  )

inlinestatic

Definition at line 494 of file reader.c.

{
    if (str1->len != str2->len) return 0;
    return !memcmp(reader_get_strptr(reader, str1), reader_get_strptr(reader, str2), str1->len*sizeof(WCHAR));
}

Referenced by get_predefined_entity(), reader_get_attribute_ns_uri(), reader_lookup_ns(), reader_parse_attribute(), reader_parse_endtag(), reader_parse_pitarget(), and xmlreader_GetPrefix().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

xmllite

)

xmlreader_AddRef()

static ULONG WINAPI xmlreader_AddRef ( IXmlReader *  iface )

static

Definition at line 2666 of file reader.c.

{
    xmlreader *reader = impl_from_IXmlReader(iface);
    ULONG ref = InterlockedIncrement(&reader->ref);
    TRACE("%p, refcount %ld.\n", iface, ref);
    return ref;
}

xmlreader_GetAttributeCount()

static HRESULT WINAPI xmlreader_GetAttributeCount ( IXmlReader *  iface, UINT *  count  )

static

Definition at line 3497 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p, %p.\n", iface, count);
 
    if (!count) return E_INVALIDARG;
 
    *count = This->attr_count;
    return S_OK;
}

xmlreader_GetBaseUri()

static HRESULT WINAPI xmlreader_GetBaseUri ( IXmlReader *  iface, LPCWSTR *  baseUri, UINT *  baseUri_length  )

static

Definition at line 3408 of file reader.c.

{
    FIXME("%p, %p, %p: stub\n", iface, baseUri, baseUri_length);
    return E_NOTIMPL;
}

xmlreader_GetDepth()

static HRESULT WINAPI xmlreader_GetDepth ( IXmlReader *  iface, UINT *  depth  )

static

Definition at line 3509 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p, %p.\n", iface, depth);
 
    *depth = This->depth;
    return S_OK;
}

xmlreader_GetLineNumber()

static HRESULT WINAPI xmlreader_GetLineNumber ( IXmlReader *  iface, UINT *  line_number  )

static

Definition at line 3433 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct element *element;
 
    TRACE("%p, %p.\n", iface, line_number);
 
    if (!line_number)
        return E_INVALIDARG;
 
    switch (reader_get_nodetype(This))
    {
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
        element = reader_get_element(This);
        *line_number = element->position.line_number;
        break;
    case XmlNodeType_Attribute:
        *line_number = This->attr->position.line_number;
        break;
    case XmlNodeType_Whitespace:
    case XmlNodeType_XmlDeclaration:
        *line_number = This->empty_element.position.line_number;
        break;
    default:
        *line_number = This->position.line_number;
        break;
    }
 
    return This->state == XmlReadState_Closed ? S_FALSE : S_OK;
}

xmlreader_GetLinePosition()

static HRESULT WINAPI xmlreader_GetLinePosition ( IXmlReader *  iface, UINT *  line_position  )

static

Definition at line 3465 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct element *element;
 
    TRACE("%p, %p.\n", iface, line_position);
 
    if (!line_position)
        return E_INVALIDARG;
 
    switch (reader_get_nodetype(This))
    {
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
        element = reader_get_element(This);
        *line_position = element->position.line_position;
        break;
    case XmlNodeType_Attribute:
        *line_position = This->attr->position.line_position;
        break;
    case XmlNodeType_Whitespace:
    case XmlNodeType_XmlDeclaration:
        *line_position = This->empty_element.position.line_position;
        break;
    default:
        *line_position = This->position.line_position;
        break;
    }
 
    return This->state == XmlReadState_Closed ? S_FALSE : S_OK;
}

xmlreader_GetLocalName()

static HRESULT WINAPI xmlreader_GetLocalName ( IXmlReader *  iface, LPCWSTR *  name, UINT *  len  )

static

Definition at line 3222 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    struct element *element;
    UINT length;
 
    TRACE("%p, %p, %p.\n", iface, name, len);
 
    if (!len)
        len = &length;
 
    switch (reader_get_nodetype(This))
    {
    case XmlNodeType_Text:
    case XmlNodeType_CDATA:
    case XmlNodeType_Comment:
    case XmlNodeType_Whitespace:
        *name = emptyW;
        *len = 0;
        break;
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
        element = reader_get_element(This);
        *name = element->localname.str;
        *len = element->localname.len;
        break;
    case XmlNodeType_Attribute:
        reader_get_attribute_local_name(This, This->attr, name, len);
        break;
    default:
        *name = This->strvalues[StringValue_LocalName].str;
        *len = This->strvalues[StringValue_LocalName].len;
        break;
    }
 
    return S_OK;
}

xmlreader_GetNamespaceUri()

static HRESULT WINAPI xmlreader_GetNamespaceUri ( IXmlReader *  iface, const WCHAR **  uri, UINT *  len  )

static

Definition at line 3166 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const strval *prefix = &This->strvalues[StringValue_Prefix];
    XmlNodeType nodetype;
    struct ns *ns;
    UINT length;
 
    TRACE("%p, %p, %p.\n", iface, uri, len);
 
    if (!len)
        len = &length;
 
    switch ((nodetype = reader_get_nodetype(This)))
    {
    case XmlNodeType_Attribute:
        reader_get_attribute_ns_uri(This, This->attr, uri, len);
        break;
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
        {
            ns = reader_lookup_ns(This, prefix);
 
            /* pick top default ns if any */
            if (!ns)
                ns = reader_lookup_nsdef(This);
 
            if (ns) {
                *uri = ns->uri.str;
                *len = ns->uri.len;
            }
            else {
                *uri = emptyW;
                *len = 0;
            }
        }
        break;
    case XmlNodeType_Text:
    case XmlNodeType_CDATA:
    case XmlNodeType_ProcessingInstruction:
    case XmlNodeType_Comment:
    case XmlNodeType_Whitespace:
    case XmlNodeType_XmlDeclaration:
        *uri = emptyW;
        *len = 0;
        break;
    default:
        FIXME("Unhandled node type %d\n", nodetype);
        *uri = NULL;
        *len = 0;
        return E_NOTIMPL;
    }
 
    return S_OK;
}

xmlreader_GetNodeType()

static HRESULT WINAPI xmlreader_GetNodeType ( IXmlReader *  iface, XmlNodeType *  node_type  )

static

Definition at line 2905 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p, %p.\n", iface, node_type);
 
    if (!node_type)
        return E_INVALIDARG;
 
    *node_type = reader_get_nodetype(This);
    return This->state == XmlReadState_Closed ? S_FALSE : S_OK;
}

xmlreader_GetPrefix()

static HRESULT WINAPI xmlreader_GetPrefix ( IXmlReader *  iface, const WCHAR **  ret, UINT *  len  )

static

Definition at line 3260 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    XmlNodeType nodetype;
    UINT length;
 
    TRACE("%p, %p, %p.\n", iface, ret, len);
 
    if (!len)
        len = &length;
 
    *ret = emptyW;
    *len = 0;
 
    switch ((nodetype = reader_get_nodetype(This)))
    {
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
    case XmlNodeType_Attribute:
    {
        const strval *prefix = &This->strvalues[StringValue_Prefix];
        struct ns *ns;
 
        if (strval_eq(This, prefix, &strval_xml))
        {
            *ret = xmlW;
            *len = 3;
        }
        else if (strval_eq(This, prefix, &strval_xmlns))
        {
            *ret = xmlnsW;
            *len = 5;
        }
        else if ((ns = reader_lookup_ns(This, prefix)))
        {
            *ret = ns->prefix.str;
            *len = ns->prefix.len;
        }
 
        break;
    }
    default:
        ;
    }
 
    return S_OK;
}

xmlreader_GetProperty()

static HRESULT WINAPI xmlreader_GetProperty ( IXmlReader *  iface, UINT  property, LONG_PTR *  value  )

static

Definition at line 2789 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p, %s, %p.\n", iface, debugstr_reader_prop(property), value);
 
    if (!value) return E_INVALIDARG;
 
    switch (property)
    {
        case XmlReaderProperty_MultiLanguage:
            *value = (LONG_PTR)This->mlang;
            if (This->mlang)
                IUnknown_AddRef(This->mlang);
            break;
        case XmlReaderProperty_XmlResolver:
            *value = (LONG_PTR)This->resolver;
            if (This->resolver)
                IXmlResolver_AddRef(This->resolver);
            break;
        case XmlReaderProperty_DtdProcessing:
            *value = This->dtdmode;
            break;
        case XmlReaderProperty_ReadState:
            *value = This->state;
            break;
        case XmlReaderProperty_MaxElementDepth:
            *value = This->max_depth;
            break;
        default:
            FIXME("Unimplemented property (%u)\n", property);
            return E_NOTIMPL;
    }
 
    return S_OK;
}

xmlreader_GetQualifiedName()

static HRESULT WINAPI xmlreader_GetQualifiedName ( IXmlReader *  iface, LPCWSTR *  name, UINT *  len  )

static

Definition at line 3098 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    struct attribute *attribute = This->attr;
    struct element *element;
    UINT length;
 
    TRACE("%p, %p, %p.\n", iface, name, len);
 
    if (!len)
        len = &length;
 
    switch (reader_get_nodetype(This))
    {
    case XmlNodeType_Text:
    case XmlNodeType_CDATA:
    case XmlNodeType_Comment:
    case XmlNodeType_Whitespace:
        *name = emptyW;
        *len = 0;
        break;
    case XmlNodeType_Element:
    case XmlNodeType_EndElement:
        element = reader_get_element(This);
        if (element->prefix.len)
        {
            *name = element->qname.str;
            *len = element->qname.len;
        }
        else
        {
            *name = element->localname.str;
            *len = element->localname.len;
        }
        break;
    case XmlNodeType_Attribute:
        if (attribute->flags & ATTRIBUTE_DEFAULT_NS_DEFINITION)
        {
            *name = xmlnsW;
            *len = 5;
        } else if (attribute->prefix.len)
        {
            *name = This->strvalues[StringValue_QualifiedName].str;
            *len = This->strvalues[StringValue_QualifiedName].len;
        }
        else
        {
            *name = attribute->localname.str;
            *len = attribute->localname.len;
        }
        break;
    default:
        *name = This->strvalues[StringValue_QualifiedName].str;
        *len = This->strvalues[StringValue_QualifiedName].len;
        break;
    }
 
    return S_OK;
}

xmlreader_GetValue()

static HRESULT WINAPI xmlreader_GetValue ( IXmlReader *  iface, const WCHAR **  value, UINT *  len  )

static

Definition at line 3347 of file reader.c.

{
    xmlreader *reader = impl_from_IXmlReader(iface);
    const strval *val = &reader->strvalues[StringValue_Value];
    UINT off;
 
    TRACE("%p, %p, %p.\n", iface, value, len);
 
    *value = NULL;
 
    if ((reader->nodetype == XmlNodeType_Comment && !val->str && !val->len) || is_reader_pending(reader))
    {
        XmlNodeType type;
        HRESULT hr;
 
        hr = IXmlReader_Read(iface, &type);
        if (FAILED(hr)) return hr;
 
        /* return if still pending, partially read values are not reported */
        if (is_reader_pending(reader)) return E_PENDING;
    }
 
    val = reader_get_value(reader, TRUE);
    if (!val)
        return E_OUTOFMEMORY;
 
    off = abs(reader->chunk_read_off);
    assert(off <= val->len);
    *value = val->str + off;
    if (len) *len = val->len - off;
    reader->chunk_read_off = -off;
    return S_OK;
}

xmlreader_IsDefault()

static BOOL WINAPI xmlreader_IsDefault ( IXmlReader *  iface )

static

Definition at line 3416 of file reader.c.

{
    FIXME("%p: stub\n", iface);
    return FALSE;
}

xmlreader_IsEmptyElement()

static BOOL WINAPI xmlreader_IsEmptyElement ( IXmlReader *  iface )

static

Definition at line 3422 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p.\n", iface);
 
    /* Empty elements are not placed in stack, it's stored as a global reader flag that makes sense
       when current node is start tag of an element */
    return (reader_get_nodetype(This) == XmlNodeType_Element) ? This->is_empty_element : FALSE;
}

xmlreader_IsEOF()

static BOOL WINAPI xmlreader_IsEOF ( IXmlReader *  iface )

static

Definition at line 3519 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p.\n", iface);
 
    return This->state == XmlReadState_EndOfFile;
}

xmlreader_MoveToAttributeByName()

static HRESULT WINAPI xmlreader_MoveToAttributeByName ( IXmlReader *  iface, const WCHAR *  local_name, const WCHAR *  namespace_uri  )

static

Definition at line 3027 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    UINT target_name_len, target_uri_len;
    struct attribute *attr;
 
    TRACE("%p, %s, %s.\n", iface, debugstr_w(local_name), debugstr_w(namespace_uri));
 
    if (!local_name)
        return E_INVALIDARG;
 
    if (!This->attr_count)
        return S_FALSE;
 
    if (!namespace_uri)
        namespace_uri = emptyW;
 
    target_name_len = lstrlenW(local_name);
    target_uri_len = lstrlenW(namespace_uri);
 
    LIST_FOR_EACH_ENTRY(attr, &This->attrs, struct attribute, entry)
    {
        UINT name_len, uri_len;
        const WCHAR *name, *uri;
 
        reader_get_attribute_local_name(This, attr, &name, &name_len);
        reader_get_attribute_ns_uri(This, attr, &uri, &uri_len);
 
        if (name_len == target_name_len && uri_len == target_uri_len &&
                !wcscmp(name, local_name) && !wcscmp(uri, namespace_uri))
        {
            reader_set_current_attribute(This, attr);
            return S_OK;
        }
    }
 
    return S_FALSE;
}

xmlreader_MoveToElement()

static HRESULT WINAPI xmlreader_MoveToElement ( IXmlReader *  iface )

static

Definition at line 3067 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p.\n", iface);
 
    if (!This->attr_count) return S_FALSE;
 
    if (This->attr)
        reader_dec_depth(This);
 
    This->attr = NULL;
 
    /* FIXME: support other node types with 'attributes' like DTD */
    if (This->is_empty_element) {
        reader_set_strvalue(This, StringValue_Prefix, &This->empty_element.prefix);
        reader_set_strvalue(This, StringValue_QualifiedName, &This->empty_element.qname);
    }
    else {
        struct element *element = LIST_ENTRY(list_head(&This->elements), struct element, entry);
        if (element) {
            reader_set_strvalue(This, StringValue_Prefix, &element->prefix);
            reader_set_strvalue(This, StringValue_QualifiedName, &element->qname);
        }
    }
    This->chunk_read_off = 0;
    reader_set_strvalue(This, StringValue_Value, &strval_empty);
 
    return S_OK;
}

xmlreader_MoveToFirstAttribute()

static HRESULT WINAPI xmlreader_MoveToFirstAttribute ( IXmlReader *  iface )

static

Definition at line 2939 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p.\n", iface);
 
    return reader_move_to_first_attribute(This);
}

xmlreader_MoveToNextAttribute()

static HRESULT WINAPI xmlreader_MoveToNextAttribute ( IXmlReader *  iface )

static

Definition at line 2948 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct list *next;
 
    TRACE("%p.\n", iface);
 
    if (!This->attr_count) return S_FALSE;
 
    if (!This->attr)
        return reader_move_to_first_attribute(This);
 
    next = list_next(&This->attrs, &This->attr->entry);
    if (next)
        reader_set_current_attribute(This, LIST_ENTRY(next, struct attribute, entry));
 
    return next ? S_OK : S_FALSE;
}

xmlreader_QueryInterface()

static HRESULT WINAPI xmlreader_QueryInterface ( IXmlReader *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2645 of file reader.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppvObject);
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IXmlReader))
    {
        *ppvObject = iface;
    }
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
 
    IXmlReader_AddRef(iface);
 
    return S_OK;
}

xmlreader_Read()

static HRESULT WINAPI xmlreader_Read ( IXmlReader *  iface, XmlNodeType *  nodetype  )

static

Definition at line 2865 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    XmlNodeType oldtype = This->nodetype;
    XmlNodeType type;
    HRESULT hr;
 
    TRACE("%p, %p.\n", iface, nodetype);
 
    if (!nodetype)
        nodetype = &type;
 
    switch (This->state)
    {
    case XmlReadState_Closed:
        hr = S_FALSE;
        break;
    case XmlReadState_Error:
        hr = This->error;
        break;
    default:
        hr = reader_parse_nextnode(This);
        if (SUCCEEDED(hr) && oldtype == XmlNodeType_None && This->nodetype != oldtype)
            This->state = XmlReadState_Interactive;
 
        if (FAILED(hr))
        {
            This->state = XmlReadState_Error;
            This->nodetype = XmlNodeType_None;
            This->depth = 0;
            This->error = hr;
        }
    }
 
    TRACE("node type %s\n", debugstr_nodetype(This->nodetype));
    *nodetype = This->nodetype;
 
    return hr;
}

xmlreader_ReadValueChunk()

static HRESULT WINAPI xmlreader_ReadValueChunk ( IXmlReader *  iface, WCHAR *  buffer, UINT  chunk_size, UINT *  read  )

static

Definition at line 3381 of file reader.c.

{
    xmlreader *reader = impl_from_IXmlReader(iface);
    const strval *val;
    UINT len = 0;
 
    TRACE("%p, %p, %u, %p.\n", iface, buffer, chunk_size, read);
 
    val = reader_get_value(reader, FALSE);
 
    /* If value is already read by GetValue, chunk_read_off is negative and chunked reads are not possible. */
    if (reader->chunk_read_off >= 0)
    {
        assert(reader->chunk_read_off <= val->len);
        len = min(val->len - reader->chunk_read_off, chunk_size);
    }
    if (read) *read = len;
 
    if (len)
    {
        memcpy(buffer, reader_get_strptr(reader, val) + reader->chunk_read_off, len*sizeof(WCHAR));
        reader->chunk_read_off += len;
    }
 
    return len || !chunk_size ? S_OK : S_FALSE;
}

xmlreader_Release()

static ULONG WINAPI xmlreader_Release ( IXmlReader *  iface )

static

Definition at line 2709 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p, refcount %ld.\n", iface, ref);
 
    if (ref == 0)
    {
        IMalloc *imalloc = This->imalloc;
        reader_reset_parser(This);
        if (This->input) IUnknown_Release(&This->input->IXmlReaderInput_iface);
        if (This->resolver) IXmlResolver_Release(This->resolver);
        if (This->mlang) IUnknown_Release(This->mlang);
        reader_free(This, This);
        if (imalloc) IMalloc_Release(imalloc);
    }
 
    return ref;
}

xmlreader_SetInput()

static HRESULT WINAPI xmlreader_SetInput ( IXmlReader *  iface, IUnknown *  input  )

static

Definition at line 2730 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    IXmlReaderInput *readerinput;
    HRESULT hr;
 
    TRACE("%p, %p.\n", iface, input);
 
    if (This->input)
    {
        readerinput_release_stream(This->input);
        IUnknown_Release(&This->input->IXmlReaderInput_iface);
        This->input = NULL;
    }
 
    reader_reset_parser(This);
 
    /* just reset current input */
    if (!input)
    {
        This->state = XmlReadState_Initial;
        return S_OK;
    }
 
    /* now try IXmlReaderInput, ISequentialStream, IStream */
    hr = IUnknown_QueryInterface(input, &IID_IXmlReaderInput, (void**)&readerinput);
    if (hr == S_OK)
    {
        if (readerinput->lpVtbl == &xmlreaderinputvtbl)
            This->input = impl_from_IXmlReaderInput(readerinput);
        else
        {
            ERR("got external IXmlReaderInput implementation: %p, vtbl=%p\n",
                readerinput, readerinput->lpVtbl);
            IUnknown_Release(readerinput);
            return E_FAIL;
 
        }
    }
 
    if (hr != S_OK || !readerinput)
    {
        /* create IXmlReaderInput basing on supplied interface */
        hr = CreateXmlReaderInputWithEncodingName(input,
                                         This->imalloc, NULL, FALSE, NULL, &readerinput);
        if (hr != S_OK) return hr;
        This->input = impl_from_IXmlReaderInput(readerinput);
    }
 
    /* set stream for supplied IXmlReaderInput */
    hr = readerinput_query_for_stream(This->input);
    if (hr == S_OK)
    {
        This->state = XmlReadState_Initial;
        This->instate = XmlReadInState_Initial;
    }
    return hr;
}

xmlreader_SetProperty()

static HRESULT WINAPI xmlreader_SetProperty ( IXmlReader *  iface, UINT  property, LONG_PTR  value  )

static

Definition at line 2826 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("%p, %s, %Ix.\n", iface, debugstr_reader_prop(property), value);
 
    switch (property)
    {
        case XmlReaderProperty_MultiLanguage:
            if (This->mlang)
                IUnknown_Release(This->mlang);
            This->mlang = (IUnknown*)value;
            if (This->mlang)
                IUnknown_AddRef(This->mlang);
            if (This->mlang)
                FIXME("Ignoring MultiLanguage %p\n", This->mlang);
            break;
        case XmlReaderProperty_XmlResolver:
            if (This->resolver)
                IXmlResolver_Release(This->resolver);
            This->resolver = (IXmlResolver*)value;
            if (This->resolver)
                IXmlResolver_AddRef(This->resolver);
            break;
        case XmlReaderProperty_DtdProcessing:
            if (value < 0 || value > _DtdProcessing_Last) return E_INVALIDARG;
            This->dtdmode = value;
            break;
        case XmlReaderProperty_MaxElementDepth:
            This->max_depth = value;
            break;
        default:
            FIXME("Unimplemented property (%u)\n", property);
            return E_NOTIMPL;
    }
 
    return S_OK;
}

xmlreaderinput_AddRef()

static ULONG WINAPI xmlreaderinput_AddRef ( IXmlReaderInput *  iface )

static

Definition at line 3580 of file reader.c.

{
    xmlreaderinput *input = impl_from_IXmlReaderInput(iface);
    ULONG ref = InterlockedIncrement(&input->ref);
    TRACE("%p, refcount %ld.\n", iface, ref);
    return ref;
}

xmlreaderinput_QueryInterface()

static HRESULT WINAPI xmlreaderinput_QueryInterface ( IXmlReaderInput *  iface, REFIID  riid, void **  ppvObject  )

static

IXmlReaderInput

Definition at line 3559 of file reader.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppvObject);
 
    if (IsEqualGUID(riid, &IID_IXmlReaderInput) ||
        IsEqualGUID(riid, &IID_IUnknown))
    {
        *ppvObject = iface;
    }
    else
    {
        WARN("interface %s not implemented\n", debugstr_guid(riid));
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef(iface);
 
    return S_OK;
}

xmlreaderinput_Release()

static ULONG WINAPI xmlreaderinput_Release ( IXmlReaderInput *  iface )

static

Definition at line 3588 of file reader.c.

{
    xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p, refcount %ld.\n", iface, ref);
 
    if (ref == 0)
    {
        IMalloc *imalloc = This->imalloc;
        if (This->input) IUnknown_Release(This->input);
        if (This->stream) ISequentialStream_Release(This->stream);
        if (This->buffer) free_input_buffer(This->buffer);
        readerinput_free(This, This->baseuri);
        readerinput_free(This, This);
        if (imalloc) IMalloc_Release(imalloc);
    }
 
    return ref;
}

Variable Documentation

emptyW

WCHAR emptyW[] = L""

static

Definition at line 216 of file reader.c.

Referenced by reader_get_attribute_ns_uri(), xmlreader_GetLocalName(), xmlreader_GetNamespaceUri(), xmlreader_GetPrefix(), xmlreader_GetQualifiedName(), and xmlreader_MoveToAttributeByName().

strval_empty

const strval strval_empty = { emptyW, 0 }

static

Definition at line 219 of file reader.c.

Referenced by CreateXmlReader(), reader_free_strvalued(), reader_get_attribute_ns_uri(), reader_get_value(), reader_parse_element(), reader_parse_pi(), reader_parse_whitespace(), reader_set_strvalue(), reader_strvaldup(), and xmlreader_MoveToElement().

strval_xml

const strval strval_xml = { xmlW, 3 }

static

Definition at line 220 of file reader.c.

Referenced by reader_get_attribute_ns_uri(), reader_parse_xmldecl(), and xmlreader_GetPrefix().

strval_xmlns

const strval strval_xmlns = { xmlnsW, 5 }

static

Definition at line 221 of file reader.c.

Referenced by reader_get_attribute_ns_uri(), reader_parse_attribute(), and xmlreader_GetPrefix().

xml_encoding_map

const struct xml_encoding_data xml_encoding_map[]

static

Initial value:

=
{
    { L"US-ASCII", XmlEncoding_USASCII, 20127 },
    { L"UTF-16",   XmlEncoding_UTF16,   1200 },
    { L"UTF-8",    XmlEncoding_UTF8,    CP_UTF8 },
}

Definition at line 148 of file reader.c.

Referenced by get_code_page(), get_encoding_from_codepage(), get_encoding_name(), parse_encoding_name(), and reader_parse_nextnode().

xmlnsW

WCHAR xmlnsW[] = L"xmlns"

static

Definition at line 218 of file reader.c.

Referenced by domelem_setAttributeNode(), namespacemanager_declarePrefix(), reader_get_attribute_local_name(), SAXAttributes_populate(), xmlreader_GetPrefix(), and xmlreader_GetQualifiedName().

xmlreader_vtbl

const struct IXmlReaderVtbl xmlreader_vtbl

static

Initial value:

=
{
    xmlreader_QueryInterface,
    xmlreader_AddRef,
    xmlreader_Release,
    xmlreader_SetInput,
    xmlreader_GetProperty,
    xmlreader_SetProperty,
    xmlreader_Read,
    xmlreader_GetNodeType,
    xmlreader_MoveToFirstAttribute,
    xmlreader_MoveToNextAttribute,
    xmlreader_MoveToAttributeByName,
    xmlreader_MoveToElement,
    xmlreader_GetQualifiedName,
    xmlreader_GetNamespaceUri,
    xmlreader_GetLocalName,
    xmlreader_GetPrefix,
    xmlreader_GetValue,
    xmlreader_ReadValueChunk,
    xmlreader_GetBaseUri,
    xmlreader_IsDefault,
    xmlreader_IsEmptyElement,
    xmlreader_GetLineNumber,
    xmlreader_GetLinePosition,
    xmlreader_GetAttributeCount,
    xmlreader_GetDepth,
    xmlreader_IsEOF
}

Definition at line 3528 of file reader.c.

Referenced by CreateXmlReader().

xmlreaderinputvtbl

static const struct IUnknownVtbl xmlreaderinputvtbl

static

Initial value:

=
{
    xmlreaderinput_QueryInterface,
    xmlreaderinput_AddRef,
    xmlreaderinput_Release
}

Definition at line 199 of file reader.c.

Referenced by create_reader_input(), and xmlreader_SetInput().

xmlW

WCHAR xmlW[] = L"xml"

static

Definition at line 217 of file reader.c.

Referenced by xmlreader_GetPrefix().