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 BOOL	is_wchar_space (WCHAR ch)
static int	reader_skipspaces (xmlreader *reader)
static HRESULT	reader_parse_versionnum (xmlreader *reader, strval *val)
static HRESULT	reader_parse_eq (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)
static HRESULT	reader_parse_sddecl (xmlreader *reader)
static HRESULT	reader_parse_xmldecl (xmlreader *reader)
static HRESULT	reader_parse_comment (xmlreader *reader)
static BOOL	is_char (WCHAR ch)
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)
HRESULT WINAPI	CreateXmlReaderInputWithEncodingName (IUnknown *stream, IMalloc *imalloc, LPCWSTR encoding, BOOL hint, LPCWSTR base_uri, IXmlReaderInput **ppInput)

Variables
static const WCHAR	usasciiW [] = {'U','S','-','A','S','C','I','I',0}
static const WCHAR	utf16W [] = {'U','T','F','-','1','6',0}
static const WCHAR	utf8W [] = {'U','T','F','-','8',0}
static const WCHAR	dblquoteW [] = {'\"',0}
static const WCHAR	quoteW [] = {'\'',0}
static const WCHAR	ltW [] = {'<',0}
static const WCHAR	gtW [] = {'>',0}
static const WCHAR	commentW [] = {'<','!','-','-',0}
static const WCHAR	piW [] = {'<','?',0}
static const struct xml_encoding_data	xml_encoding_map []
static const struct IUnknownVtbl	xmlreaderinputvtbl
static WCHAR	emptyW [] = {0}
static WCHAR	xmlW [] = {'x','m','l',0}
static WCHAR	xmlnsW [] = {'x','m','l','n','s',0}
static const strval	strval_empty = { emptyW }
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 189 of file reader.c.

Enumeration Type Documentation

attribute_flags

enum attribute_flags

Enumerator
ATTRIBUTE_NS_DEFINITION
ATTRIBUTE_DEFAULT_NS_DEFINITION

Definition at line 239 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 776 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 CreateXmlReaderInputWithEncodingName().

CreateXmlReader()

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

Definition at line 3653 of file reader.c.

{
    xmlreader *reader;
    HRESULT hr;
    int i;
 
    TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
 
    if (imalloc)
        reader = IMalloc_Alloc(imalloc, sizeof(*reader));
    else
        reader = heap_alloc(sizeof(*reader));
    if (!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 %#x\n", *obj, hr);
 
    return hr;
}

Referenced by test_attribute_by_name(), test_encoding_detection(), test_endoffile(), 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(), and test_string_pointers().

CreateXmlReaderInputWithEncodingName()

HRESULT WINAPI CreateXmlReaderInputWithEncodingName	(	IUnknown *	stream,
		IMalloc *	imalloc,
		LPCWSTR	encoding,
		BOOL	hint,
		LPCWSTR	base_uri,
		IXmlReaderInput **	ppInput
	)

Definition at line 3696 of file reader.c.

{
    xmlreaderinput *readerinput;
    HRESULT hr;
 
    TRACE("%p %p %s %d %s %p\n", stream, imalloc, wine_dbgstr_w(encoding),
                                       hint, wine_dbgstr_w(base_uri), ppInput);
 
    if (!stream || !ppInput) return E_INVALIDARG;
 
    if (imalloc)
        readerinput = IMalloc_Alloc(imalloc, sizeof(*readerinput));
    else
        readerinput = heap_alloc(sizeof(*readerinput));
    if(!readerinput) return E_OUTOFMEMORY;
 
    readerinput->IXmlReaderInput_iface.lpVtbl = &xmlreaderinputvtbl;
    readerinput->ref = 1;
    readerinput->imalloc = imalloc;
    readerinput->stream = NULL;
    if (imalloc) IMalloc_AddRef(imalloc);
    readerinput->encoding = parse_encoding_name(encoding, -1);
    readerinput->hint = hint;
    readerinput->baseuri = readerinput_strdupW(readerinput, base_uri);
    readerinput->pending = 0;
 
    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 test_readerinput(), and xmlreader_SetInput().

debug_strval()

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

inlinestatic

Definition at line 477 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 102 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 132 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 990 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 729 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 805 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 734 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 170 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 CreateXmlWriterOutputWithEncodingCodePage().

get_encoding_name()

const WCHAR * get_encoding_name

(

xml_encoding

encoding

)

Definition at line 165 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 2046 of file reader.c.

{
    static const WCHAR entltW[]   = {'l','t'};
    static const WCHAR entgtW[]   = {'g','t'};
    static const WCHAR entampW[]  = {'a','m','p'};
    static const WCHAR entaposW[] = {'a','p','o','s'};
    static const WCHAR entquotW[] = {'q','u','o','t'};
    static const strval lt   = { (WCHAR*)entltW,   2 };
    static const strval gt   = { (WCHAR*)entgtW,   2 };
    static const strval amp  = { (WCHAR*)entampW,  3 };
    static const strval apos = { (WCHAR*)entaposW, 4 };
    static const strval quot = { (WCHAR*)entquotW, 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 312 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_QueryInterface(), 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 317 of file reader.c.

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

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

init_encoded_buffer()

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

static

Definition at line 714 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_char()

static BOOL is_char ( WCHAR  ch )

inlinestatic

Definition at line 1486 of file reader.c.

{
    return (ch == '\t') || (ch == '\r') || (ch == '\n') ||
           (ch >= 0x20 && ch <= 0xd7ff) ||
           (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
           (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
           (ch >= 0xe000 && ch <= 0xfffd);
}

Referenced by reader_parse_reference(), and reader_parse_sys_literal().

is_namechar()

BOOL is_namechar

(

WCHAR

ch

)

Definition at line 1553 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 1509 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 1529 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 1496 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 709 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 1263 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().

is_wchar_space()

static BOOL is_wchar_space ( WCHAR  ch )

inlinestatic

Definition at line 1168 of file reader.c.

{
    return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
}

Referenced by reader_parse_attvalue(), reader_parse_chardata(), reader_parse_misc(), reader_parse_pi(), reader_parse_reference(), and reader_skipspaces().

parse_encoding_name()

xml_encoding parse_encoding_name	(	const WCHAR *	name,
		int	len
	)

Definition at line 747 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 426 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->value);
    }
    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 323 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 328 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 410 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 510 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 2712 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 1124 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_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 544 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 336 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 580 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 490 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 401 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 495 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 3048 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 3006 of file reader.c.

{
    static const WCHAR xmlns_uriW[] = {'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g','/',
            '2','0','0','0','/','x','m','l','n','s','/',0};
    static const WCHAR xml_uriW[] = {'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g','/',
            'X','M','L','/','1','9','9','8','/','n','a','m','e','s','p','a','c','e',0};
 
    /* 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 1111 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 462 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 1558 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 1116 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 342 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 348 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 3349 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 539 of file reader.c.

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

Referenced by reader_move_to_first_attribute(), and reader_parse_nextnode().

reader_init_cstrvalue()

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

inlinestatic

Definition at line 483 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 470 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_lookup_ns()

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

static

Definition at line 526 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 3199 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 588 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 1073 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 */
    hr = readerinput_growraw(readerinput);
    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*sizeof(WCHAR);
    }
    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 2965 of file reader.c.

{
    if (!reader->attr_count)
        return S_FALSE;
 
    if (!reader->attr)
        reader_inc_depth(reader);
 
    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 2235 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 2188 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 2401 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++;
        }
    }
 
    return S_OK;
}

Referenced by reader_parse_content().

reader_parse_chardata()

static HRESULT reader_parse_chardata ( xmlreader *  reader )

static

Definition at line 2452 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)
    {
        static const WCHAR ampW[] = {'&',0};
 
        /* 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, ampW))
            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 1427 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 2513 of file reader.c.

{
    static const WCHAR cdstartW[] = {'<','!','[','C','D','A','T','A','[',0};
    static const WCHAR etagW[] = {'<','/',0};
 
    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, etagW))
        return reader_parse_endtag(reader);
 
    if (!reader_cmp(reader, commentW))
        return reader_parse_comment(reader);
 
    if (!reader_cmp(reader, piW))
        return reader_parse_pi(reader);
 
    if (!reader_cmp(reader, cdstartW))
        return reader_parse_cdata(reader);
 
    if (!reader_cmp(reader, ltW))
        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 1886 of file reader.c.

{
    static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',0};
    strval name;
    WCHAR *cur;
    HRESULT hr;
 
    /* check if we have "<!DOCTYPE" */
    if (reader_cmp(reader, doctypeW)) 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 2315 of file reader.c.

{
    HRESULT hr;
 
    switch (reader->resumestate)
    {
    case XmlReadResumeState_Initial:
        /* check if we are really on element */
        if (reader_cmp(reader, ltW)) 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 )

static

Definition at line 1303 of file reader.c.

{
    static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0};
    struct reader_position position;
    strval name, val;
    HRESULT hr;
 
    if (!reader_skipspaces(reader)) return S_FALSE;
 
    position = reader->position;
    if (reader_cmp(reader, encodingW)) 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_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    hr = reader_parse_encname(reader, &val);
    if (FAILED(hr)) return hr;
 
    if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        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_encname()

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

static

Definition at line 1273 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 2361 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, gtW)) 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 1215 of file reader.c.

{
    static const WCHAR eqW[] = {'=',0};
    reader_skipspaces(reader);
    if (reader_cmp(reader, eqW)) 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 1833 of file reader.c.

{
    static WCHAR systemW[] = {'S','Y','S','T','E','M',0};
    static WCHAR publicW[] = {'P','U','B','L','I','C',0};
    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 1932 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 1738 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, commentW))
            hr = reader_parse_comment(reader);
        else if (!reader_cmp(reader, piW))
            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 1571 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 2558 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, 0x%08x\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 1637 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 1609 of file reader.c.

{
    static const WCHAR xmlW[] = {'x','m','l'};
    static const strval xmlval = { (WCHAR*)xmlW, 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 1808 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 1974 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 2087 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);
        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);
 
            *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 )

static

Definition at line 1341 of file reader.c.

{
    static const WCHAR standaloneW[] = {'s','t','a','n','d','a','l','o','n','e',0};
    static const WCHAR yesW[] = {'y','e','s',0};
    static const WCHAR noW[] = {'n','o',0};
    struct reader_position position;
    strval name, val;
    UINT start;
    HRESULT hr;
 
    if (!reader_skipspaces(reader)) return S_FALSE;
 
    position = reader->position;
    if (reader_cmp(reader, standaloneW)) 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_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    if (reader_cmp(reader, yesW) && reader_cmp(reader, noW))
        return WC_E_XMLDECL;
 
    start = reader_get_cur(reader);
    /* skip 'yes'|'no' */
    reader_skipn(reader, reader_cmp(reader, yesW) ? 2 : 3);
    reader_init_strvalue(start, reader_get_cur(reader)-start, &val);
    TRACE("standalone=%s\n", debug_strval(reader, &val));
 
    if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        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 2266 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 (;;)
    {
        static const WCHAR endW[] = {'/','>',0};
 
        reader_skipspaces(reader);
 
        /* empty element */
        if ((reader->is_empty_element = !reader_cmp(reader, endW)))
        {
            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, gtW))
        {
            /* 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 1782 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 1227 of file reader.c.

{
    static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0};
    struct reader_position position;
    strval val, name;
    HRESULT hr;
 
    if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
 
    position = reader->position;
    if (reader_cmp(reader, versionW)) 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_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        return WC_E_QUOTE;
    /* skip "'"|'"' */
    reader_skipn(reader, 1);
 
    hr = reader_parse_versionnum(reader, &val);
    if (FAILED(hr)) return hr;
 
    if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
        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 1189 of file reader.c.

{
    static const WCHAR onedotW[] = {'1','.',0};
    WCHAR *ptr, *ptr2;
    UINT start;
 
    if (reader_cmp(reader, onedotW)) 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 1703 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 1385 of file reader.c.

{
    static const WCHAR xmldeclW[] = {'<','?','x','m','l',' ',0};
    static const WCHAR declcloseW[] = {'?','>',0};
    struct reader_position position;
    HRESULT hr;
 
    /* check if we have "<?xml " */
    if (reader_cmp(reader, xmldeclW))
        return S_FALSE;
 
    reader_skipn(reader, 2);
    position = reader->position;
    reader_skipn(reader, 3);
    hr = reader_parse_versioninfo(reader);
    if (FAILED(hr))
        return hr;
 
    hr = reader_parse_encdecl(reader);
    if (FAILED(hr))
        return hr;
 
    hr = reader_parse_sddecl(reader);
    if (FAILED(hr))
        return hr;
 
    reader_skipspaces(reader);
    if (reader_cmp(reader, declcloseW))
        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 655 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 630 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 605 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 550 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 2730 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 2956 of file reader.c.

{
    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 675 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 1057 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 1156 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 1174 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 353 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 1142 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 370 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 898 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 380 of file reader.c.

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

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

readerinput_get_convlen()

static int readerinput_get_convlen ( xmlreaderinput *  readerinput )

static

Definition at line 958 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 940 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
    int len = buffer->written;
 
    /* 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 865 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 835 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=%d, read=%d, ret=0x%08x\n", buffer->written, buffer->allocated, len, read, hr);
    readerinput->pending = hr == E_PENDING;
    if (FAILED(hr)) return hr;
    buffer->written += read;
 
    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 879 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 822 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 375 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 812 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 975 of file reader.c.

{
    encoded_buffer *buffer = &readerinput->buffer->encoded;
 
    if (len == -1)
        len = readerinput_get_convlen(readerinput);
 
    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 385 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 CreateXmlReaderInputWithEncodingName().

readerinput_switchencoding()

static void readerinput_switchencoding ( xmlreaderinput *  readerinput, xml_encoding  enc  )

static

Definition at line 1019 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*sizeof(WCHAR);
    }
    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 504 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 2704 of file reader.c.

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

xmlreader_GetAttributeCount()

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

static

Definition at line 3536 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)->(%p)\n", This, 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 3449 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 3548 of file reader.c.

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

xmlreader_GetLineNumber()

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

static

Definition at line 3472 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct element *element;
 
    TRACE("(%p %p)\n", This, 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 3504 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct element *element;
 
    TRACE("(%p %p)\n", This, 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 3263 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    struct element *element;
    UINT length;
 
    TRACE("(%p)->(%p %p)\n", This, 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 3207 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 2943 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)->(%p)\n", This, 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 3301 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    XmlNodeType nodetype;
    UINT length;
 
    TRACE("(%p)->(%p %p)\n", This, 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 2827 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)->(%s %p)\n", This, 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 3139 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", This, 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 3388 of file reader.c.

{
    xmlreader *reader = impl_from_IXmlReader(iface);
    const strval *val = &reader->strvalues[StringValue_Value];
    UINT off;
 
    TRACE("(%p)->(%p %p)\n", reader, 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 3457 of file reader.c.

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

xmlreader_IsEmptyElement()

static BOOL WINAPI xmlreader_IsEmptyElement ( IXmlReader *  iface )

static

Definition at line 3463 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    TRACE("(%p)\n", This);
    /* 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 3556 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 3068 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", This, 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 3108 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)\n", This);
 
    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 2978 of file reader.c.

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

xmlreader_MoveToNextAttribute()

static HRESULT WINAPI xmlreader_MoveToNextAttribute ( IXmlReader *  iface )

static

Definition at line 2987 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    const struct list *next;
 
    TRACE("(%p)\n", This);
 
    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 2681 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)->(%s %p)\n", This, 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 2903 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    XmlNodeType oldtype = This->nodetype;
    XmlNodeType type;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, 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 3422 of file reader.c.

{
    xmlreader *reader = impl_from_IXmlReader(iface);
    const strval *val;
    UINT len = 0;
 
    TRACE("(%p)->(%p %u %p)\n", reader, 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 2747 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\n", This, 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 2768 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
    IXmlReaderInput *readerinput;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, 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 2864 of file reader.c.

{
    xmlreader *This = impl_from_IXmlReader(iface);
 
    TRACE("(%p)->(%s 0x%lx)\n", This, 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 3617 of file reader.c.

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

xmlreaderinput_QueryInterface()

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

static

IXmlReaderInput

Definition at line 3594 of file reader.c.

{
    xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
 
    TRACE("(%p)->(%s %p)\n", This, 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 3625 of file reader.c.

{
    xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\n", This, 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

commentW

const WCHAR commentW[] = {'<','!','-','-',0}

static

Definition at line 97 of file reader.c.

Referenced by reader_parse_content(), reader_parse_misc(), test_indentation(), and test_mxwriter_comment().

dblquoteW

const WCHAR dblquoteW[] = {'\"',0}

static

Definition at line 93 of file reader.c.

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

emptyW

WCHAR emptyW[] = {0}

static

Definition at line 226 of file reader.c.

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

gtW

const WCHAR gtW[] = {'>',0}

static

Definition at line 96 of file reader.c.

Referenced by close_element_starttag(), get_escaped_string(), reader_parse_endtag(), reader_parse_stag(), SAXContentHandler_endElement(), and write_escaped_string().

ltW

const WCHAR ltW[] = {'<',0}

static

Definition at line 95 of file reader.c.

Referenced by get_escaped_string(), mxwriter_write_starttag(), reader_parse_content(), reader_parse_element(), and write_escaped_string().

piW

const WCHAR piW[] = {'<','?',0}

static

Definition at line 98 of file reader.c.

Referenced by reader_parse_content(), reader_parse_misc(), and test_bom().

quoteW

const WCHAR quoteW[] = {'\'',0}

static

Definition at line 94 of file reader.c.

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

strval_empty

const strval strval_empty = { emptyW }

static

Definition at line 229 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 230 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 231 of file reader.c.

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

usasciiW

const WCHAR usasciiW[] = {'U','S','-','A','S','C','I','I',0}

static

Definition at line 89 of file reader.c.

Referenced by test_writeroutput(), and test_writestartdocument().

utf16W

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

static

Definition at line 90 of file reader.c.

utf8W

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

static

Definition at line 91 of file reader.c.

xml_encoding_map

const struct xml_encoding_data xml_encoding_map[]

static

Initial value:

= {
    { usasciiW, XmlEncoding_USASCII, 20127 },
    { utf16W, XmlEncoding_UTF16, 1200 },
    { utf8W,  XmlEncoding_UTF8,  CP_UTF8 },
}

Definition at line 159 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[] = {'x','m','l','n','s',0}

static

Definition at line 228 of file reader.c.

Referenced by namespacemanager_declarePrefix(), reader_get_attribute_local_name(), test_attribute_by_name(), 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 3563 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 209 of file reader.c.

Referenced by CreateXmlReaderInputWithEncodingName(), and xmlreader_SetInput().

xmlW

WCHAR xmlW[] = {'x','m','l',0}

static

Definition at line 227 of file reader.c.

Referenced by reader_parse_pitarget(), and xmlreader_GetPrefix().