/*
* IXmlReader implementation
*
- * Copyright 2010, 2012-2013 Nikolay Sivov
+ * Copyright 2010, 2012-2013, 2016 Nikolay Sivov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
/* not defined in public headers */
DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
-typedef enum
-{
- XmlEncoding_UTF16,
- XmlEncoding_UTF8,
- XmlEncoding_Unknown
-} xml_encoding;
-
typedef enum
{
XmlReadInState_Initial,
XmlReadResumeState_CDATA,
XmlReadResumeState_Comment,
XmlReadResumeState_STag,
- XmlReadResumeState_CharData
+ XmlReadResumeState_CharData,
+ XmlReadResumeState_Whitespace
} XmlReaderResumeState;
/* saved pointer index to resume from particular input position */
static const char *debugstr_nodetype(XmlNodeType nodetype)
{
- static const char* type_names[] =
+ static const char * const type_names[] =
{
"None",
"Element",
};
if (nodetype > _XmlNodeType_Last)
- {
- static char buf[25];
- sprintf(buf, "unknown type=%d", nodetype);
- return buf;
- }
+ return wine_dbg_sprintf("unknown type=%d", nodetype);
+
return type_names[nodetype];
}
-static const char *debugstr_prop(XmlReaderProperty prop)
+static const char *debugstr_reader_prop(XmlReaderProperty prop)
{
- static const char* prop_names[] =
+ static const char * const prop_names[] =
{
"MultiLanguage",
"ConformanceLevel",
};
if (prop > _XmlReaderProperty_Last)
- {
- static char buf[25];
- sprintf(buf, "unknown property=%d", prop);
- return buf;
- }
+ return wine_dbg_sprintf("unknown property=%d", prop);
+
return prop_names[prop];
}
{ utf8W, XmlEncoding_UTF8, CP_UTF8 }
};
+const WCHAR *get_encoding_name(xml_encoding encoding)
+{
+ return xml_encoding_map[encoding].name;
+}
+
+xml_encoding get_encoding_from_codepage(UINT codepage)
+{
+ int i;
+ for (i = 0; i < sizeof(xml_encoding_map)/sizeof(xml_encoding_map[0]); i++)
+ {
+ if (xml_encoding_map[i].cp == codepage) return xml_encoding_map[i].enc;
+ }
+ return XmlEncoding_Unknown;
+}
+
typedef struct
{
char *data;
- char *cur;
+ UINT cur;
unsigned int allocated;
unsigned int written;
} encoded_buffer;
{
WCHAR *str; /* allocated null-terminated string */
UINT len; /* length in WCHARs, altered after ReadValueChunk */
- WCHAR *start; /* input position where value starts */
+ UINT start; /* input position where value starts */
} strval;
static WCHAR emptyW[] = {0};
-static const strval strval_empty = {emptyW, 0, emptyW};
+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 };
struct attribute
{
struct list entry;
+ strval prefix;
strval localname;
strval value;
};
struct element
{
struct list entry;
- strval qname;
+ strval prefix;
strval localname;
+ strval qname;
+};
+
+struct ns
+{
+ struct list entry;
+ strval prefix;
+ strval uri;
+ struct element *element;
};
typedef struct
XmlReaderResumeState resumestate;
XmlNodeType nodetype;
DtdProcessing dtdmode;
+ IXmlResolver *resolver;
+ IUnknown *mlang;
UINT line, pos; /* reader position in XML stream */
struct list attrs; /* attributes list for current node */
struct attribute *attr; /* current attribute */
UINT attr_count;
+ struct list nsdef;
+ struct list ns;
struct list elements;
strval strvalues[StringValue_Last];
UINT depth;
UINT max_depth;
- BOOL empty_element;
- WCHAR *resume[XmlReadResume_Last]; /* pointers used to resume reader */
+ BOOL is_empty_element;
+ struct element empty_element;
+ UINT resume[XmlReadResume_Last]; /* offsets used to resume reader */
} xmlreader;
struct input_buffer
return CONTAINING_RECORD(iface, xmlreaderinput, IXmlReaderInput_iface);
}
-static inline void *m_alloc(IMalloc *imalloc, size_t len)
+/* reader memory allocation functions */
+static inline void *reader_alloc(xmlreader *reader, size_t len)
{
- if (imalloc)
- return IMalloc_Alloc(imalloc, len);
- else
- return heap_alloc(len);
+ return m_alloc(reader->imalloc, len);
}
-static inline void *m_realloc(IMalloc *imalloc, void *mem, size_t len)
+static inline void *reader_alloc_zero(xmlreader *reader, size_t len)
{
- if (imalloc)
- return IMalloc_Realloc(imalloc, mem, len);
- else
- return heap_realloc(mem, len);
+ void *ret = reader_alloc(reader, len);
+ if (ret)
+ memset(ret, 0, len);
+ return ret;
}
-static inline void m_free(IMalloc *imalloc, void *mem)
+static inline void reader_free(xmlreader *reader, void *mem)
{
- if (imalloc)
- IMalloc_Free(imalloc, mem);
- else
- heap_free(mem);
+ m_free(reader->imalloc, mem);
}
-/* reader memory allocation functions */
-static inline void *reader_alloc(xmlreader *reader, size_t len)
+/* Just return pointer from offset, no attempt to read more. */
+static inline WCHAR *reader_get_ptr2(const xmlreader *reader, UINT offset)
{
- return m_alloc(reader->imalloc, len);
+ encoded_buffer *buffer = &reader->input->buffer->utf16;
+ return (WCHAR*)buffer->data + offset;
}
-static inline void reader_free(xmlreader *reader, void *mem)
+static inline WCHAR *reader_get_strptr(const xmlreader *reader, const strval *v)
{
- m_free(reader->imalloc, mem);
+ return v->str ? v->str : reader_get_ptr2(reader, v->start);
}
static HRESULT reader_strvaldup(xmlreader *reader, const strval *src, strval *dest)
{
dest->str = reader_alloc(reader, (dest->len+1)*sizeof(WCHAR));
if (!dest->str) return E_OUTOFMEMORY;
- memcpy(dest->str, src->str, dest->len*sizeof(WCHAR));
+ memcpy(dest->str, reader_get_strptr(reader, src), dest->len*sizeof(WCHAR));
dest->str[dest->len] = 0;
+ dest->start = 0;
}
return S_OK;
}
list_init(&reader->attrs);
reader->attr_count = 0;
+ reader->attr = NULL;
}
/* attribute data holds pointers to buffer data, so buffer shrink is not possible
while we are on a node with attributes */
-static HRESULT reader_add_attr(xmlreader *reader, strval *localname, strval *value)
+static HRESULT reader_add_attr(xmlreader *reader, strval *prefix, strval *localname, strval *value)
{
struct attribute *attr;
attr = reader_alloc(reader, sizeof(*attr));
if (!attr) return E_OUTOFMEMORY;
+ if (prefix)
+ attr->prefix = *prefix;
+ else
+ memset(&attr->prefix, 0, sizeof(attr->prefix));
attr->localname = *localname;
attr->value = *value;
list_add_tail(&reader->attrs, &attr->entry);
}
}
-static inline void reader_init_strvalue(WCHAR *str, UINT len, strval *v)
+static inline void reader_init_strvalue(UINT start, UINT len, strval *v)
{
- v->start = v->str = str;
+ v->start = start;
v->len = len;
+ v->str = NULL;
+}
+
+static inline const char* debug_strval(const xmlreader *reader, const strval *v)
+{
+ return debugstr_wn(reader_get_strptr(reader, v), v->len);
+}
+
+/* used to initialize from constant string */
+static inline void reader_init_cstrvalue(WCHAR *str, UINT len, strval *v)
+{
+ v->start = 0;
+ v->len = len;
+ v->str = str;
}
static void reader_free_strvalue(xmlreader *reader, XmlReaderStringValue type)
/* This helper should only be used to test if strings are the same,
it doesn't try to sort. */
-static inline int strval_eq(const strval *str1, const strval *str2)
+static inline int strval_eq(const xmlreader *reader, const strval *str1, const strval *str2)
{
if (str1->len != str2->len) return 0;
- return !memcmp(str1->str, str2->str, str1->len*sizeof(WCHAR));
+ return !memcmp(reader_get_strptr(reader, str1), reader_get_strptr(reader, str2), str1->len*sizeof(WCHAR));
}
static void reader_clear_elements(xmlreader *reader)
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->empty_element = FALSE;
+ reader->is_empty_element = FALSE;
}
static HRESULT reader_inc_depth(xmlreader *reader)
if (reader->depth > 1) reader->depth--;
}
-static HRESULT reader_push_element(xmlreader *reader, strval *qname, strval *localname)
+static HRESULT reader_push_ns(xmlreader *reader, const strval *prefix, const strval *uri, BOOL def)
{
- struct element *elem;
+ struct ns *ns;
HRESULT hr;
- elem = reader_alloc(reader, sizeof(*elem));
- if (!elem) return E_OUTOFMEMORY;
+ ns = reader_alloc(reader, sizeof(*ns));
+ if (!ns) return E_OUTOFMEMORY;
- hr = reader_strvaldup(reader, qname, &elem->qname);
+ 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(reader, elem);
+ reader_free_strvalued(reader, &ns->prefix);
+ reader_free(reader, ns);
return hr;
}
- hr = reader_strvaldup(reader, localname, &elem->localname);
- if (FAILED(hr))
- {
- reader_free_strvalued(reader, &elem->qname);
- reader_free(reader, elem);
- return hr;
+ ns->element = NULL;
+ list_add_head(def ? &reader->nsdef : &reader->ns, &ns->entry);
+ return hr;
+}
+
+static void reader_free_element(xmlreader *reader, struct element *element)
+{
+ reader_free_strvalued(reader, &element->prefix);
+ reader_free_strvalued(reader, &element->localname);
+ reader_free_strvalued(reader, &element->qname);
+ reader_free(reader, element);
+}
+
+static void reader_mark_ns_nodes(xmlreader *reader, struct element *element)
+{
+ 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;
+ }
+}
+
+static HRESULT reader_push_element(xmlreader *reader, strval *prefix, strval *localname,
+ strval *qname)
+{
+ struct element *element;
+ HRESULT hr;
+
if (!list_empty(&reader->elements))
{
hr = reader_inc_depth(reader);
- if (FAILED(hr)) {
- reader_free(reader, elem);
+ if (FAILED(hr))
return hr;
- }
}
- list_add_head(&reader->elements, &elem->entry);
- reader->empty_element = FALSE;
+ element = reader_alloc_zero(reader, sizeof(*element));
+ if (!element) {
+ hr = E_OUTOFMEMORY;
+ goto failed;
+ }
+
+ 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)
+ {
+ reader_free_element(reader, element);
+ goto failed;
+ }
+
+ list_add_head(&reader->elements, &element->entry);
+ reader_mark_ns_nodes(reader, element);
+ reader->is_empty_element = FALSE;
+
+failed:
+ reader_dec_depth(reader);
return hr;
}
-static void reader_pop_element(xmlreader *reader)
+static void reader_pop_ns_nodes(xmlreader *reader, struct element *element)
{
- struct element *elem = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
+ struct ns *ns, *ns2;
- if (elem)
- {
- list_remove(&elem->entry);
- reader_free_strvalued(reader, &elem->qname);
- reader_free_strvalued(reader, &elem->localname);
- reader_free(reader, elem);
- reader_dec_depth(reader);
+ 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);
+ }
+ }
+}
+
+static void reader_pop_element(xmlreader *reader)
+{
+ 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);
+ reader_dec_depth(reader);
+
+ /* It was a root element, the rest is expected as Misc */
+ if (list_empty(&reader->elements))
+ reader->instate = XmlReadInState_MiscEnd;
}
/* Always make a copy, cause strings are supposed to be null terminated. Null pointer for 'value'
if (!value)
{
v->str = NULL;
- v->start = NULL;
+ v->start = 0;
v->len = 0;
return;
}
else
{
v->str = reader_alloc(reader, (value->len + 1)*sizeof(WCHAR));
- memcpy(v->str, value->start, value->len*sizeof(WCHAR));
+ memcpy(v->str, reader_get_strptr(reader, value), value->len*sizeof(WCHAR));
v->str[value->len] = 0;
v->len = value->len;
}
if (!buffer->data) return E_OUTOFMEMORY;
memset(buffer->data, 0, 4);
- buffer->cur = buffer->data;
+ buffer->cur = 0;
buffer->allocated = initial_len;
buffer->written = 0;
readerinput_free(input, buffer->data);
}
-static HRESULT get_code_page(xml_encoding encoding, UINT *cp)
+HRESULT get_code_page(xml_encoding encoding, UINT *cp)
{
if (encoding == XmlEncoding_Unknown)
{
return S_OK;
}
-static xml_encoding parse_encoding_name(const WCHAR *name, int len)
+xml_encoding parse_encoding_name(const WCHAR *name, int len)
{
int min, max, n, c;
/* Queries already stored interface for IStream/ISequentialStream.
Interface supplied on creation will be overwritten */
-static HRESULT readerinput_query_for_stream(xmlreaderinput *readerinput)
+static inline HRESULT readerinput_query_for_stream(xmlreaderinput *readerinput)
{
HRESULT hr;
read = 0;
hr = ISequentialStream_Read(readerinput->stream, buffer->data + buffer->written, len, &read);
- TRACE("requested %d, read %d, ret 0x%08x\n", len, read, hr);
+ 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;
}
-/* grows UTF-16 buffer so it has at least 'length' bytes free on return */
+/* grows UTF-16 buffer so it has at least 'length' WCHAR chars free on return */
static void readerinput_grow(xmlreaderinput *readerinput, int length)
{
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)
{
}
}
-static inline int readerinput_is_utf8(xmlreaderinput *readerinput)
+static inline BOOL readerinput_is_utf8(xmlreaderinput *readerinput)
{
- static char startA[] = {'<','?'};
- static char commentA[] = {'<','!'};
+ static const char startA[] = {'<','?'};
+ static const char commentA[] = {'<','!'};
encoded_buffer *buffer = &readerinput->buffer->encoded;
unsigned char *ptr = (unsigned char*)buffer->data;
static HRESULT readerinput_detectencoding(xmlreaderinput *readerinput, xml_encoding *enc)
{
encoded_buffer *buffer = &readerinput->buffer->encoded;
- static WCHAR startW[] = {'<','?'};
- static WCHAR commentW[] = {'<','!'};
- static char utf8bom[] = {0xef,0xbb,0xbf};
- static char utf16lebom[] = {0xff,0xfe};
+ static const WCHAR startW[] = {'<','?'};
+ static const WCHAR commentW[] = {'<','!'};
+ static const char utf8bom[] = {0xef,0xbb,0xbf};
+ static const char utf16lebom[] = {0xff,0xfe};
*enc = XmlEncoding_Unknown;
else
len = buffer->written;
- TRACE("%d\n", len - (int)(buffer->cur - buffer->data));
- return len - (buffer->cur - buffer->data);
+ TRACE("%d\n", len - buffer->cur);
+ return len - buffer->cur;
}
/* It's possible that raw buffer has some leftovers from last conversion - some char
if (len == -1)
len = readerinput_get_convlen(readerinput);
- memmove(buffer->data, buffer->cur + (buffer->written - len), len);
+ memmove(buffer->data, buffer->data + buffer->cur + (buffer->written - len), len);
/* everything below cur is lost too */
- buffer->written -= len + (buffer->cur - buffer->data);
- /* after this point we don't need cur pointer really,
+ 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 = buffer->data;
+ buffer->cur = 0;
}
/* note that raw buffer content is kept */
if (enc == XmlEncoding_UTF16)
{
readerinput_grow(readerinput, len);
- memcpy(dest->data, src->cur, len);
+ memcpy(dest->data, src->data + src->cur, len);
dest->written += len*sizeof(WCHAR);
return;
}
- dest_len = MultiByteToWideChar(cp, 0, src->cur, len, NULL, 0);
+ 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->cur, len, ptr, dest_len);
+ MultiByteToWideChar(cp, 0, src->data + src->cur, len, ptr, dest_len);
ptr[dest_len] = 0;
dest->written += dest_len*sizeof(WCHAR);
}
encoded_buffer *buffer = &reader->input->buffer->utf16;
/* avoid to move too often using threshold shrink length */
- if (buffer->cur - buffer->data > buffer->written / 2)
+ if (buffer->cur*sizeof(WCHAR) > buffer->written / 2)
{
- buffer->written -= buffer->cur - buffer->data;
- memmove(buffer->data, buffer->cur, buffer->written);
- buffer->cur = buffer->data;
- *(WCHAR*)&buffer->cur[buffer->written] = 0;
+ 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;
}
}
if (cp == ~0)
{
readerinput_grow(readerinput, len);
- memcpy(dest->data, src->cur, len);
+ memcpy(dest->data + dest->written, src->data + src->cur, len);
dest->written += len*sizeof(WCHAR);
return hr;
}
- dest_len = MultiByteToWideChar(cp, 0, src->cur, len, NULL, 0);
+ 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->cur, len, ptr, 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 */
return hr;
}
-static inline WCHAR *reader_get_cur(xmlreader *reader)
+static inline UINT reader_get_cur(xmlreader *reader)
{
- WCHAR *ptr = (WCHAR*)reader->input->buffer->utf16.cur;
+ return reader->input->buffer->utf16.cur;
+}
+
+static inline WCHAR *reader_get_ptr(xmlreader *reader)
+{
+ encoded_buffer *buffer = &reader->input->buffer->utf16;
+ WCHAR *ptr = (WCHAR*)buffer->data + buffer->cur;
if (!*ptr) reader_more(reader);
- return ptr;
+ return (WCHAR*)buffer->data + buffer->cur;
}
static int reader_cmp(xmlreader *reader, const WCHAR *str)
{
- const WCHAR *ptr = reader_get_cur(reader);
- return strncmpW(str, ptr, strlenW(str));
+ 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;
}
/* moves cursor n WCHARs forward */
static void reader_skipn(xmlreader *reader, int n)
{
encoded_buffer *buffer = &reader->input->buffer->utf16;
- const WCHAR *ptr = reader_get_cur(reader);
+ const WCHAR *ptr = reader_get_ptr(reader);
while (*ptr++ && n--)
{
- buffer->cur += sizeof(WCHAR);
+ buffer->cur++;
reader->pos++;
}
}
-static inline int is_wchar_space(WCHAR ch)
+static inline BOOL is_wchar_space(WCHAR ch)
{
return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
}
static int reader_skipspaces(xmlreader *reader)
{
encoded_buffer *buffer = &reader->input->buffer->utf16;
- const WCHAR *ptr = reader_get_cur(reader), *start = ptr;
+ const WCHAR *ptr = reader_get_ptr(reader);
+ UINT start = reader_get_cur(reader);
while (is_wchar_space(*ptr))
{
- buffer->cur += sizeof(WCHAR);
if (*ptr == '\r')
reader->pos = 0;
else if (*ptr == '\n')
}
else
reader->pos++;
- ptr++;
+
+ buffer->cur++;
+ ptr = reader_get_ptr(reader);
}
- return ptr - start;
+ return reader_get_cur(reader) - start;
}
/* [26] VersionNum ::= '1.' [0-9]+ */
static HRESULT reader_parse_versionnum(xmlreader *reader, strval *val)
{
- WCHAR *ptr, *ptr2, *start = reader_get_cur(reader);
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_cur(reader);
+ ptr2 = ptr = reader_get_ptr(reader);
while (*ptr >= '0' && *ptr <= '9')
- ptr++;
+ {
+ reader_skipn(reader, 1);
+ ptr = reader_get_ptr(reader);
+ }
if (ptr2 == ptr) return WC_E_DIGIT;
- TRACE("version=%s\n", debugstr_wn(start, ptr-start));
- reader_init_strvalue(start, ptr-start, val);
- reader_skipn(reader, ptr-ptr2);
+ reader_init_strvalue(start, reader_get_cur(reader)-start, val);
+ TRACE("version=%s\n", debug_strval(reader, val));
return S_OK;
}
/* skip "'"|'"' */
reader_skipn(reader, 1);
- return reader_add_attr(reader, &name, &val);
+ return reader_add_attr(reader, NULL, &name, &val);
}
/* ([A-Za-z0-9._] | '-') */
-static inline int is_wchar_encname(WCHAR ch)
+static inline BOOL is_wchar_encname(WCHAR ch)
{
return ((ch >= 'A' && ch <= 'Z') ||
(ch >= 'a' && ch <= 'z') ||
/* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* */
static HRESULT reader_parse_encname(xmlreader *reader, strval *val)
{
- WCHAR *start = reader_get_cur(reader), *ptr;
+ 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))
;
strval name, val;
HRESULT hr;
- if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
+ if (!reader_skipspaces(reader)) return S_FALSE;
if (reader_cmp(reader, encodingW)) return S_FALSE;
- name.str = reader_get_cur(reader);
+ name.str = reader_get_ptr(reader);
+ name.start = reader_get_cur(reader);
name.len = 8;
/* skip 'encoding' */
reader_skipn(reader, 8);
/* skip "'"|'"' */
reader_skipn(reader, 1);
- return reader_add_attr(reader, &name, &val);
+ return reader_add_attr(reader, NULL, &name, &val);
}
/* [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"')) */
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};
- WCHAR *start, *ptr;
strval name, val;
+ UINT start;
HRESULT hr;
- if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
+ if (!reader_skipspaces(reader)) return S_FALSE;
if (reader_cmp(reader, standaloneW)) return S_FALSE;
reader_init_strvalue(reader_get_cur(reader), 10, &name);
start = reader_get_cur(reader);
/* skip 'yes'|'no' */
reader_skipn(reader, reader_cmp(reader, yesW) ? 2 : 3);
- ptr = reader_get_cur(reader);
- TRACE("standalone=%s\n", debugstr_wn(start, ptr-start));
- val.str = val.start = start;
- val.len = ptr-start;
+ 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, &name, &val);
+ return reader_add_attr(reader, NULL, &name, &val);
}
/* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' */
/* [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' */
static HRESULT reader_parse_comment(xmlreader *reader)
{
- WCHAR *start, *ptr;
+ WCHAR *ptr;
+ UINT start;
- if (reader->resume[XmlReadResume_Body])
+ if (reader->resumestate == XmlReadResumeState_Comment)
{
start = reader->resume[XmlReadResume_Body];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
/* skip '<!--' */
reader_skipn(reader, 4);
reader_shrink(reader);
- ptr = start = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
reader->nodetype = XmlNodeType_Comment;
reader->resume[XmlReadResume_Body] = start;
reader->resumestate = XmlReadResumeState_Comment;
{
strval value;
- TRACE("%s\n", debugstr_wn(start, ptr-start));
- /* skip '-->' */
+ 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_init_strvalue(start, ptr-start, &value);
+
reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
reader_set_strvalue(reader, StringValue_Value, &value);
- reader->resume[XmlReadResume_Body] = NULL;
+ reader->resume[XmlReadResume_Body] = 0;
reader->resumestate = XmlReadResumeState_Initial;
return S_OK;
}
else
return WC_E_COMMENT;
}
- else
- ptr++;
- }
- else
- {
- reader_skipn(reader, 1);
- ptr++;
}
+
+ reader_skipn(reader, 1);
+ ptr++;
}
return S_OK;
}
/* [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] */
-static inline int is_char(WCHAR ch)
+static inline BOOL is_char(WCHAR ch)
{
return (ch == '\t') || (ch == '\r') || (ch == '\n') ||
(ch >= 0x20 && ch <= 0xd7ff) ||
}
/* [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] */
-static inline int is_pubchar(WCHAR ch)
+static inline BOOL is_pubchar(WCHAR ch)
{
return (ch == ' ') ||
(ch >= 'a' && ch <= 'z') ||
(ch == '_') || (ch == '\r') || (ch == '\n');
}
-static inline int is_namestartchar(WCHAR ch)
+static inline BOOL is_namestartchar(WCHAR ch)
{
return (ch == ':') || (ch >= 'A' && ch <= 'Z') ||
(ch == '_') || (ch >= 'a' && ch <= 'z') ||
}
/* [4 NS] NCName ::= Name - (Char* ':' Char*) */
-static inline int is_ncnamechar(WCHAR ch)
+static inline BOOL is_ncnamechar(WCHAR ch)
{
return (ch >= 'A' && ch <= 'Z') ||
(ch == '_') || (ch >= 'a' && ch <= 'z') ||
(ch >= 0xfdf0 && ch <= 0xfffd);
}
-static inline int is_namechar(WCHAR ch)
+static inline BOOL is_namechar(WCHAR ch)
{
return (ch == ':') || is_ncnamechar(ch);
}
[5] Name ::= NameStartChar (NameChar)* */
static HRESULT reader_parse_name(xmlreader *reader, strval *name)
{
- WCHAR *ptr, *start;
+ WCHAR *ptr;
+ UINT start;
if (reader->resume[XmlReadResume_Name])
{
start = reader->resume[XmlReadResume_Name];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
- ptr = start = reader_get_cur(reader);
+ 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_cur(reader);
+ ptr = reader_get_ptr(reader);
}
if (is_reader_pending(reader))
return E_PENDING;
}
else
- reader->resume[XmlReadResume_Name] = NULL;
+ reader->resume[XmlReadResume_Name] = 0;
- TRACE("name %s:%d\n", debugstr_wn(start, ptr-start), (int)(ptr-start));
- reader_init_strvalue(start, ptr-start, name);
+ reader_init_strvalue(start, reader_get_cur(reader)-start, name);
+ TRACE("name %s:%d\n", debug_strval(reader, name), name->len);
return S_OK;
}
static HRESULT reader_parse_pitarget(xmlreader *reader, strval *target)
{
static const WCHAR xmlW[] = {'x','m','l'};
+ static const strval xmlval = { (WCHAR*)xmlW, 3 };
strval name;
+ WCHAR *ptr;
HRESULT hr;
UINT i;
if (FAILED(hr)) return is_reader_pending(reader) ? E_PENDING : WC_E_PI;
/* now that we got name check for illegal content */
- if (name.len == 3 && !strncmpiW(name.str, xmlW, 3))
+ 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 (name.str[i] == ':')
+ if (ptr[i] == ':')
return i ? NC_E_NAMECOLON : WC_E_PI;
- TRACE("pitarget %s:%d\n", debugstr_wn(name.str, name.len), name.len);
+ TRACE("pitarget %s:%d\n", debug_strval(reader, &name), name.len);
*target = name;
return S_OK;
}
/* [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' */
static HRESULT reader_parse_pi(xmlreader *reader)
{
- WCHAR *ptr, *start;
strval target;
+ WCHAR *ptr;
+ UINT start;
HRESULT hr;
switch (reader->resumestate)
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:
;
}
- ptr = reader_get_cur(reader);
- /* exit earlier if there's no content */
- if (ptr[0] == '?' && ptr[1] == '>')
- {
- /* skip '?>' */
- reader_skipn(reader, 2);
- reader->nodetype = XmlNodeType_ProcessingInstruction;
- reader->resumestate = XmlReadResumeState_Initial;
- return S_OK;
- }
-
- if (!reader->resume[XmlReadResume_Body])
- {
- /* now at least a single space char should be there */
- if (!is_wchar_space(*ptr)) return WC_E_WHITESPACE;
- reader_skipspaces(reader);
- ptr = start = reader_get_cur(reader);
- reader->resume[XmlReadResume_Body] = start;
- }
- else
- {
- start = reader->resume[XmlReadResume_Body];
- ptr = reader_get_cur(reader);
- }
-
+ 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;
- TRACE("%s\n", debugstr_wn(start, ptr-start));
+ /* 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] = NULL;
- reader_init_strvalue(start, ptr-start, &value);
+ reader->resume[XmlReadResume_Body] = 0;
reader_set_strvalue(reader, StringValue_Value, &value);
return S_OK;
}
- else
- {
- ptr++;
- reader_more(reader);
- }
- }
- else
- {
- reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
}
+
+ reader_skipn(reader, 1);
+ ptr = reader_get_ptr(reader);
}
return S_OK;
/* This one is used to parse significant whitespace nodes, like in Misc production */
static HRESULT reader_parse_whitespace(xmlreader *reader)
{
- WCHAR *start, *ptr;
+ 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_shrink(reader);
- start = reader_get_cur(reader);
+ reader_skipspaces(reader);
+ if (is_reader_pending(reader)) return S_OK;
- reader_skipspaces(reader);
- ptr = reader_get_cur(reader);
- TRACE("%s\n", debugstr_wn(start, ptr-start));
+ 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:
+ ;
+ }
- 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);
return S_OK;
}
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_cur(reader);
+ const WCHAR *cur = reader_get_ptr(reader);
if (is_wchar_space(*cur))
hr = reader_parse_whitespace(reader);
/* [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") */
static HRESULT reader_parse_sys_literal(xmlreader *reader, strval *literal)
{
- WCHAR *start = reader_get_cur(reader), *cur, quote;
+ WCHAR *cur = reader_get_ptr(reader), quote;
+ UINT start;
- if (*start != '"' && *start != '\'') return WC_E_QUOTE;
+ if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
- quote = *start;
+ quote = *cur;
reader_skipn(reader, 1);
- cur = start = reader_get_cur(reader);
+ cur = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
while (is_char(*cur) && *cur != quote)
{
reader_skipn(reader, 1);
- cur = reader_get_cur(reader);
+ cur = reader_get_ptr(reader);
}
+ reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
if (*cur == quote) reader_skipn(reader, 1);
- reader_init_strvalue(start, cur-start, literal);
- TRACE("%s\n", debugstr_wn(start, cur-start));
+ TRACE("%s\n", debug_strval(reader, literal));
return S_OK;
}
[13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] */
static HRESULT reader_parse_pub_literal(xmlreader *reader, strval *literal)
{
- WCHAR *start = reader_get_cur(reader), *cur, quote;
+ WCHAR *cur = reader_get_ptr(reader), quote;
+ UINT start;
- if (*start != '"' && *start != '\'') return WC_E_QUOTE;
+ if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
- quote = *start;
+ quote = *cur;
reader_skipn(reader, 1);
- cur = start;
+ start = reader_get_cur(reader);
+ cur = reader_get_ptr(reader);
while (is_pubchar(*cur) && *cur != quote)
{
reader_skipn(reader, 1);
- cur = reader_get_cur(reader);
+ cur = reader_get_ptr(reader);
}
+ reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
+ if (*cur == quote) reader_skipn(reader, 1);
- reader_init_strvalue(start, cur-start, literal);
- TRACE("%s\n", debugstr_wn(start, cur-start));
+ TRACE("%s\n", debug_strval(reader, literal));
return S_OK;
}
{
static WCHAR systemW[] = {'S','Y','S','T','E','M',0};
static WCHAR publicW[] = {'P','U','B','L','I','C',0};
- strval name;
+ strval name, sys;
HRESULT hr;
int cnt;
- if (reader_cmp(reader, systemW))
- {
- if (reader_cmp(reader, publicW))
- return S_FALSE;
- else
- {
- strval pub;
+ if (!reader_cmp(reader, publicW)) {
+ strval pub;
- /* public id */
- reader_skipn(reader, 6);
- cnt = reader_skipspaces(reader);
- if (!cnt) return WC_E_WHITESPACE;
+ /* 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;
+ hr = reader_parse_pub_literal(reader, &pub);
+ if (FAILED(hr)) return hr;
- reader_init_strvalue(publicW, strlenW(publicW), &name);
- return reader_add_attr(reader, &name, &pub);
- }
- }
- else
- {
- strval sys;
+ reader_init_cstrvalue(publicW, strlenW(publicW), &name);
+ hr = reader_add_attr(reader, NULL, &name, &pub);
+ 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, strlenW(systemW), &name);
+ hr = reader_add_attr(reader, NULL, &name, &sys);
+ if (FAILED(hr)) return hr;
+
+ return S_OK;
+ } else if (!reader_cmp(reader, systemW)) {
/* system id */
reader_skipn(reader, 6);
cnt = reader_skipspaces(reader);
hr = reader_parse_sys_literal(reader, &sys);
if (FAILED(hr)) return hr;
- reader_init_strvalue(systemW, strlenW(systemW), &name);
- return reader_add_attr(reader, &name, &sys);
+ reader_init_cstrvalue(systemW, strlenW(systemW), &name);
+ return reader_add_attr(reader, NULL, &name, &sys);
}
- return hr;
+ return S_FALSE;
}
/* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>' */
reader_skipspaces(reader);
- cur = reader_get_cur(reader);
+ cur = reader_get_ptr(reader);
if (*cur != '>')
{
FIXME("internal subset parsing not implemented\n");
/* [11 NS] LocalPart ::= NCName */
static HRESULT reader_parse_local(xmlreader *reader, strval *local)
{
- WCHAR *ptr, *start;
+ WCHAR *ptr;
+ UINT start;
if (reader->resume[XmlReadResume_Local])
{
start = reader->resume[XmlReadResume_Local];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
- ptr = start = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
}
while (is_ncnamechar(*ptr))
{
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
if (is_reader_pending(reader))
return E_PENDING;
}
else
- reader->resume[XmlReadResume_Local] = NULL;
+ reader->resume[XmlReadResume_Local] = 0;
- reader_init_strvalue(start, ptr-start, local);
+ reader_init_strvalue(start, reader_get_cur(reader)-start, local);
return S_OK;
}
[10 NS] Prefix ::= NCName */
static HRESULT reader_parse_qname(xmlreader *reader, strval *prefix, strval *local, strval *qname)
{
- WCHAR *ptr, *start;
+ WCHAR *ptr;
+ UINT start;
HRESULT hr;
if (reader->resume[XmlReadResume_Name])
{
start = reader->resume[XmlReadResume_Name];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
- ptr = start = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
reader->resume[XmlReadResume_Name] = start;
if (!is_ncnamechar(*ptr)) return NC_E_QNAMECHARACTER;
}
while (is_ncnamechar(*ptr))
{
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
if (is_reader_pending(reader)) return E_PENDING;
/* got a qualified name */
if (*ptr == ':')
{
- reader_init_strvalue(start, ptr-start, prefix);
+ reader_init_strvalue(start, reader_get_cur(reader)-start, prefix);
/* skip ':' */
reader_skipn(reader, 1);
}
else
{
- reader_init_strvalue(reader->resume[XmlReadResume_Name], ptr-reader->resume[XmlReadResume_Name], local);
- reader_init_strvalue(NULL, 0, prefix);
+ reader_init_strvalue(reader->resume[XmlReadResume_Name], reader_get_cur(reader)-reader->resume[XmlReadResume_Name], local);
+ reader_init_strvalue(0, 0, prefix);
}
}
- reader_init_strvalue(start, ptr-start, local);
-
if (prefix->len)
- TRACE("qname %s:%s\n", debugstr_wn(prefix->start, prefix->len), debugstr_wn(local->start, local->len));
+ TRACE("qname %s:%s\n", debug_strval(reader, prefix), debug_strval(reader, local));
else
- TRACE("ncname %s\n", debugstr_wn(local->start, local->len));
+ TRACE("ncname %s\n", debug_strval(reader, local));
- reader_init_strvalue(prefix->start ? prefix->start : local->start,
+ reader_init_strvalue(prefix->len ? prefix->start : local->start,
/* count ':' too */
(prefix->len ? prefix->len + 1 : 0) + local->len,
qname);
- reader->resume[XmlReadResume_Name] = NULL;
- reader->resume[XmlReadResume_Local] = NULL;
+ reader->resume[XmlReadResume_Name] = 0;
+ reader->resume[XmlReadResume_Local] = 0;
return S_OK;
}
*ptr = ' ';
}
-static WCHAR get_predefined_entity(const strval *name)
+static WCHAR get_predefined_entity(const xmlreader *reader, const strval *name)
{
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 (name->str[0])
+ switch (*str)
{
case 'l':
- if (strval_eq(name, <)) return '<';
+ if (strval_eq(reader, name, <)) return '<';
break;
case 'g':
- if (strval_eq(name, >)) return '>';
+ if (strval_eq(reader, name, >)) return '>';
break;
case 'a':
- if (strval_eq(name, &))
+ if (strval_eq(reader, name, &))
return '&';
- else if (strval_eq(name, &apos))
+ else if (strval_eq(reader, name, &apos))
return '\'';
break;
case 'q':
- if (strval_eq(name, ")) return '\"';
+ if (strval_eq(reader, name, ")) return '\"';
break;
default:
;
static HRESULT reader_parse_reference(xmlreader *reader)
{
encoded_buffer *buffer = &reader->input->buffer->utf16;
- WCHAR *start = reader_get_cur(reader), *ptr;
+ 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_cur(reader);
+ ptr = reader_get_ptr(reader);
if (*ptr == '#')
{
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
/* hex char or decimal */
if (*ptr == 'x')
{
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
while (*ptr != ';')
{
else
return ch ? WC_E_SEMICOLON : WC_E_HEXDIGIT;
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
}
else
{
ch = ch*10 + *ptr - '0';
reader_skipn(reader, 1);
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
return ch ? WC_E_SEMICOLON : WC_E_DIGIT;
len = buffer->written - ((char*)ptr - buffer->data) - sizeof(WCHAR);
memmove(start+1, ptr+1, len);
- buffer->cur = (char*)(start+1);
+ buffer->cur = cur + 1;
*start = ch;
}
hr = reader_parse_name(reader, &name);
if (FAILED(hr)) return hr;
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
if (*ptr != ';') return WC_E_SEMICOLON;
/* predefined entities resolve to a single character */
- ch = get_predefined_entity(&name);
+ 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 = (char*)(start+1);
+ buffer->cur = cur + 1;
*start = ch;
}
else
{
- FIXME("undeclared entity %s\n", debugstr_wn(name.str, name.len));
+ FIXME("undeclared entity %s\n", debug_strval(reader, &name));
return WC_E_UNDECLAREDENTITY;
}
/* [10 NS] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'" */
static HRESULT reader_parse_attvalue(xmlreader *reader, strval *value)
{
- WCHAR *ptr, *start;
- WCHAR quote;
+ WCHAR *ptr, quote;
+ UINT start;
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
/* skip opening quote */
quote = *ptr;
if (quote != '\"' && quote != '\'') return WC_E_QUOTE;
reader_skipn(reader, 1);
- start = ptr = reader_get_cur(reader);
+ 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);
- break;
+ return S_OK;
}
if (*ptr == '&')
reader_normalize_space(reader, ptr);
reader_skipn(reader, 1);
}
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
- reader_init_strvalue(start, ptr-start, value);
-
- return S_OK;
+ return WC_E_QUOTE;
}
/* [1 NS] NSAttName ::= PrefixedAttName | DefaultAttName
[15 NS] Attribute ::= NSAttName Eq AttValue | QName Eq AttValue */
static HRESULT reader_parse_attribute(xmlreader *reader)
{
- static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
- strval prefix, local, qname, xmlns, value;
+ strval prefix, local, qname, value;
+ BOOL ns = FALSE, nsdef = FALSE;
HRESULT hr;
hr = reader_parse_qname(reader, &prefix, &local, &qname);
if (FAILED(hr)) return hr;
- reader_init_strvalue((WCHAR*)xmlnsW, 5, &xmlns);
-
- if (strval_eq(&prefix, &xmlns))
- {
- FIXME("namespace definitions not supported\n");
- return E_NOTIMPL;
- }
+ if (strval_eq(reader, &prefix, &strval_xmlns))
+ ns = TRUE;
- if (strval_eq(&qname, &xmlns))
- {
- FIXME("default namespace definitions not supported\n");
- return E_NOTIMPL;
- }
+ if (strval_eq(reader, &qname, &strval_xmlns))
+ ns = nsdef = TRUE;
hr = reader_parse_eq(reader);
if (FAILED(hr)) return hr;
hr = reader_parse_attvalue(reader, &value);
if (FAILED(hr)) return hr;
- TRACE("%s=%s\n", debugstr_wn(local.str, local.len), debugstr_wn(value.str, value.len));
- return reader_add_attr(reader, &local, &value);
+ if (ns)
+ reader_push_ns(reader, nsdef ? &strval_xmlns : &local, &value, nsdef);
+
+ TRACE("%s=%s\n", debug_strval(reader, &local), debug_strval(reader, &value));
+ return reader_add_attr(reader, &prefix, &local, &value);
}
/* [12 NS] STag ::= '<' QName (S Attribute)* S? '>'
{
/* skip '/>' */
reader_skipn(reader, 2);
- reader->empty_element = TRUE;
+ reader->is_empty_element = TRUE;
+ reader->empty_element.prefix = *prefix;
+ reader->empty_element.localname = *local;
+ reader->empty_element.qname = *qname;
+ reader_mark_ns_nodes(reader, &reader->empty_element);
return S_OK;
}
{
/* skip '>' */
reader_skipn(reader, 1);
- return reader_push_element(reader, qname, local);
+ return reader_push_element(reader, prefix, local, qname);
}
hr = reader_parse_attribute(reader);
hr = reader_parse_stag(reader, &prefix, &local, &qname, &empty);
if (FAILED(hr)) return hr;
- /* FIXME: need to check for defined namespace to reject invalid prefix,
- currently reject all prefixes */
- if (prefix.len) return NC_E_UNDECLAREDPREFIX;
+ /* 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 (empty && list_empty(&reader->elements))
reader->nodetype = XmlNodeType_Element;
reader->resumestate = XmlReadResumeState_Initial;
- reader_set_strvalue(reader, StringValue_LocalName, &local);
reader_set_strvalue(reader, StringValue_Prefix, &prefix);
+ reader_set_strvalue(reader, StringValue_LocalName, &local);
reader_set_strvalue(reader, StringValue_QualifiedName, &qname);
break;
}
/* Element stack should never be empty at this point, cause we shouldn't get to
content parsing if it's empty. */
elem = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
- if (!strval_eq(&elem->qname, &qname)) return WC_E_ELEMENTMATCH;
-
- reader_pop_element(reader);
-
- /* It was a root element, the rest is expected as Misc */
- if (list_empty(&reader->elements))
- reader->instate = XmlReadInState_MiscEnd;
+ if (!strval_eq(reader, &elem->qname, &qname)) return WC_E_ELEMENTMATCH;
reader->nodetype = XmlNodeType_EndElement;
+ reader_set_strvalue(reader, StringValue_Prefix, &prefix);
reader_set_strvalue(reader, StringValue_LocalName, &local);
reader_set_strvalue(reader, StringValue_QualifiedName, &qname);
[21] CDEnd ::= ']]>' */
static HRESULT reader_parse_cdata(xmlreader *reader)
{
- WCHAR *start, *ptr;
+ WCHAR *ptr;
+ UINT start;
- if (reader->resume[XmlReadResume_Body])
+ if (reader->resumestate == XmlReadResumeState_CDATA)
{
start = reader->resume[XmlReadResume_Body];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
/* skip markup '<![CDATA[' */
reader_skipn(reader, 9);
reader_shrink(reader);
- ptr = start = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
reader->nodetype = XmlNodeType_CDATA;
reader->resume[XmlReadResume_Body] = start;
reader->resumestate = XmlReadResumeState_CDATA;
{
strval value;
- TRACE("%s\n", debugstr_wn(start, ptr-start));
+ reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
+
/* skip ']]>' */
reader_skipn(reader, 3);
- reader_init_strvalue(start, ptr-start, &value);
+ TRACE("%s\n", debug_strval(reader, &value));
+
reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
reader_set_strvalue(reader, StringValue_Value, &value);
- reader->resume[XmlReadResume_Body] = NULL;
+ reader->resume[XmlReadResume_Body] = 0;
reader->resumestate = XmlReadResumeState_Initial;
return S_OK;
}
/* [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) */
static HRESULT reader_parse_chardata(xmlreader *reader)
{
- WCHAR *start, *ptr;
+ WCHAR *ptr;
+ UINT start;
- if (reader->resume[XmlReadResume_Body])
+ if (reader->resumestate == XmlReadResumeState_CharData)
{
start = reader->resume[XmlReadResume_Body];
- ptr = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
}
else
{
reader_shrink(reader);
- ptr = start = reader_get_cur(reader);
+ ptr = reader_get_ptr(reader);
+ start = reader_get_cur(reader);
/* There's no text */
if (!*ptr || *ptr == '<') return S_OK;
- reader->nodetype = XmlNodeType_Text;
+ reader->nodetype = is_wchar_space(*ptr) ? XmlNodeType_Whitespace : XmlNodeType_Text;
reader->resume[XmlReadResume_Body] = start;
reader->resumestate = XmlReadResumeState_CharData;
reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
while (*ptr)
{
+ static const WCHAR ampW[] = {'&',0};
+
/* CDATA closing sequence ']]>' is not allowed */
if (ptr[0] == ']' && ptr[1] == ']' && ptr[2] == '>')
return WC_E_CDSECTEND;
{
strval value;
- reader_init_strvalue(start, ptr-start, &value);
+ 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;
}
- reader_skipn(reader, 1);
- ptr++;
+ /* 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;
{
static const WCHAR cdstartW[] = {'<','!','[','C','D','A','T','A','[',0};
static const WCHAR etagW[] = {'<','/',0};
- static const WCHAR ampW[] = {'&',0};
if (reader->resumestate != XmlReadResumeState_Initial)
{
if (!reader_cmp(reader, cdstartW))
return reader_parse_cdata(reader);
- if (!reader_cmp(reader, ampW))
- return reader_parse_reference(reader);
-
if (!reader_cmp(reader, ltW))
return reader_parse_element(reader);
static HRESULT reader_parse_nextnode(xmlreader *reader)
{
+ XmlNodeType nodetype = reader_get_nodetype(reader);
HRESULT hr;
if (!is_reader_pending(reader))
reader_clear_attrs(reader);
+ /* When moving from EndElement or empty element, pop its own namespace definitions */
+ if (nodetype == XmlNodeType_Element && reader->is_empty_element)
+ reader_pop_ns_nodes(reader, &reader->empty_element);
+ else if (nodetype == XmlNodeType_EndElement)
+ reader_pop_element(reader);
+
while (1)
{
switch (reader->instate)
return ref;
}
+static void reader_clear_ns(xmlreader *reader)
+{
+ struct ns *ns, *ns2;
+
+ LIST_FOR_EACH_ENTRY_SAFE(ns, ns2, &reader->ns, struct 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) {
+ reader_free_strvalued(reader, &ns->uri);
+ reader_free(reader, ns);
+ }
+}
+
static ULONG WINAPI xmlreader_Release(IXmlReader *iface)
{
xmlreader *This = impl_from_IXmlReader(iface);
{
IMalloc *imalloc = This->imalloc;
if (This->input) IUnknown_Release(&This->input->IXmlReaderInput_iface);
+ if (This->resolver) IXmlResolver_Release(This->resolver);
+ if (This->mlang) IUnknown_Release(This->mlang);
reader_clear_attrs(This);
+ reader_clear_ns(This);
reader_clear_elements(This);
reader_free_strvalues(This);
reader_free(This, This);
{
/* create IXmlReaderInput basing on supplied interface */
hr = CreateXmlReaderInputWithEncodingName(input,
- NULL, NULL, FALSE, NULL, &readerinput);
+ This->imalloc, NULL, FALSE, NULL, &readerinput);
if (hr != S_OK) return hr;
This->input = impl_from_IXmlReaderInput(readerinput);
}
{
xmlreader *This = impl_from_IXmlReader(iface);
- TRACE("(%p)->(%s %p)\n", This, debugstr_prop(property), value);
+ 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;
{
xmlreader *This = impl_from_IXmlReader(iface);
- TRACE("(%p)->(%s %lu)\n", This, debugstr_prop(property), value);
+ 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:
+ FIXME("Ignoring MaxElementDepth %ld\n", value);
+ break;
default:
FIXME("Unimplemented property (%u)\n", property);
return E_NOTIMPL;
if (hr == S_OK)
{
TRACE("node type %s\n", debugstr_nodetype(This->nodetype));
- *nodetype = This->nodetype;
+ if (nodetype)
+ *nodetype = This->nodetype;
}
return hr;
static HRESULT WINAPI xmlreader_GetNodeType(IXmlReader* iface, XmlNodeType *node_type)
{
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;
}
+static HRESULT reader_move_to_first_attribute(xmlreader *reader)
+{
+ if (!reader->attr_count)
+ return S_FALSE;
+
+ reader->attr = LIST_ENTRY(list_head(&reader->attrs), struct attribute, entry);
+ reader_set_strvalue(reader, StringValue_Prefix, &reader->attr->prefix);
+ reader_set_strvalue(reader, StringValue_LocalName, &reader->attr->localname);
+ reader_set_strvalue(reader, StringValue_Value, &reader->attr->value);
+
+ return S_OK;
+}
+
static HRESULT WINAPI xmlreader_MoveToFirstAttribute(IXmlReader* iface)
{
xmlreader *This = impl_from_IXmlReader(iface);
TRACE("(%p)\n", This);
- if (!This->attr_count) return S_FALSE;
- This->attr = LIST_ENTRY(list_head(&This->attrs), struct attribute, entry);
- reader_set_strvalue(This, StringValue_LocalName, &This->attr->localname);
- reader_set_strvalue(This, StringValue_Value, &This->attr->value);
-
- return S_OK;
+ return reader_move_to_first_attribute(This);
}
static HRESULT WINAPI xmlreader_MoveToNextAttribute(IXmlReader* iface)
if (!This->attr_count) return S_FALSE;
if (!This->attr)
- return IXmlReader_MoveToFirstAttribute(iface);
+ return reader_move_to_first_attribute(This);
next = list_next(&This->attrs, &This->attr->entry);
if (next)
{
This->attr = LIST_ENTRY(next, struct attribute, entry);
+ reader_set_strvalue(This, StringValue_Prefix, &This->attr->prefix);
reader_set_strvalue(This, StringValue_LocalName, &This->attr->localname);
reader_set_strvalue(This, StringValue_Value, &This->attr->value);
}
static HRESULT WINAPI xmlreader_MoveToElement(IXmlReader* iface)
{
xmlreader *This = impl_from_IXmlReader(iface);
- struct element *elem;
TRACE("(%p)\n", This);
This->attr = NULL;
/* FIXME: support other node types with 'attributes' like DTD */
- elem = LIST_ENTRY(list_head(&This->elements), struct element, entry);
- if (elem)
- {
- reader_set_strvalue(This, StringValue_QualifiedName, &elem->qname);
- reader_set_strvalue(This, StringValue_LocalName, &elem->localname);
+ if (This->is_empty_element) {
+ reader_set_strvalue(This, StringValue_LocalName, &This->empty_element.localname);
+ 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_LocalName, &element->localname);
+ reader_set_strvalue(This, StringValue_QualifiedName, &element->qname);
+ }
}
return S_OK;
TRACE("(%p)->(%p %p)\n", This, name, len);
*name = This->strvalues[StringValue_QualifiedName].str;
- *len = This->strvalues[StringValue_QualifiedName].len;
+ if (len) *len = This->strvalues[StringValue_QualifiedName].len;
return S_OK;
}
-static HRESULT WINAPI xmlreader_GetNamespaceUri(IXmlReader* iface,
- LPCWSTR *namespaceUri,
- UINT *namespaceUri_length)
+static struct ns *reader_lookup_ns(xmlreader *reader, const strval *prefix)
{
- FIXME("(%p %p %p): stub\n", iface, namespaceUri, namespaceUri_length);
- return E_NOTIMPL;
+ 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;
+}
+
+static struct ns *reader_lookup_nsdef(xmlreader *reader)
+{
+ if (list_empty(&reader->nsdef))
+ return NULL;
+
+ return LIST_ENTRY(list_head(&reader->nsdef), struct ns, entry);
+}
+
+static HRESULT WINAPI xmlreader_GetNamespaceUri(IXmlReader* iface, const WCHAR **uri, UINT *len)
+{
+ 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;
+
+ *uri = NULL;
+ *len = 0;
+
+ switch ((nodetype = reader_get_nodetype(This)))
+ {
+ case XmlNodeType_Attribute:
+ {
+ 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};
+ const strval *local = &This->strvalues[StringValue_LocalName];
+
+ /* check for reserved prefixes first */
+ if ((strval_eq(This, prefix, &strval_empty) && strval_eq(This, local, &strval_xmlns)) ||
+ strval_eq(This, prefix, &strval_xmlns))
+ {
+ *uri = xmlns_uriW;
+ *len = sizeof(xmlns_uriW)/sizeof(xmlns_uriW[0]) - 1;
+ }
+ else if (strval_eq(This, prefix, &strval_xml)) {
+ *uri = xml_uriW;
+ *len = sizeof(xml_uriW)/sizeof(xml_uriW[0]) - 1;
+ }
+
+ if (!*uri) {
+ ns = reader_lookup_ns(This, prefix);
+ if (ns) {
+ *uri = ns->uri.str;
+ *len = ns->uri.len;
+ }
+ else {
+ *uri = emptyW;
+ *len = 0;
+ }
+ }
+ }
+ 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;
+ default:
+ FIXME("Unhandled node type %d\n", nodetype);
+ return E_NOTIMPL;
+ }
+
+ return S_OK;
}
static HRESULT WINAPI xmlreader_GetLocalName(IXmlReader* iface, LPCWSTR *name, UINT *len)
return S_OK;
}
+static BOOL is_namespace_definition(xmlreader *reader)
+{
+ const strval *local = &reader->strvalues[StringValue_LocalName];
+ const strval *prefix = &reader->strvalues[StringValue_Prefix];
+
+ if (reader_get_nodetype(reader) != XmlNodeType_Attribute)
+ return FALSE;
+
+ return ((strval_eq(reader, prefix, &strval_empty) && strval_eq(reader, local, &strval_xmlns)) ||
+ strval_eq(reader, prefix, &strval_xmlns));
+}
+
static HRESULT WINAPI xmlreader_GetValue(IXmlReader* iface, const WCHAR **value, UINT *len)
{
xmlreader *reader = impl_from_IXmlReader(iface);
if (!val->str)
{
- val->str = reader_alloc(reader, (val->len+1)*sizeof(WCHAR));
- if (!val->str) return E_OUTOFMEMORY;
- memcpy(val->str, val->start, val->len*sizeof(WCHAR));
- val->str[val->len] = 0;
+ WCHAR *ptr = reader_alloc(reader, (val->len+1)*sizeof(WCHAR));
+ if (!ptr) return E_OUTOFMEMORY;
+ memcpy(ptr, reader_get_strptr(reader, val), val->len*sizeof(WCHAR));
+ ptr[val->len] = 0;
+ val->str = ptr;
+ }
+
+ /* For namespace definition attributes return values from namespace list */
+ if (is_namespace_definition(reader)) {
+ const strval *local = &reader->strvalues[StringValue_LocalName];
+ struct ns *ns;
+
+ ns = reader_lookup_ns(reader, local);
+ if (!ns)
+ ns = reader_lookup_nsdef(reader);
+
+ val = &ns->uri;
}
*value = val->str;
if (val->len)
{
len = min(chunk_size, val->len);
- memcpy(buffer, val->start, len);
+ memcpy(buffer, reader_get_ptr2(reader, val->start), len);
val->start += len;
val->len -= len;
if (read) *read = len;
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->empty_element : FALSE;
+ return (reader_get_nodetype(This) == XmlNodeType_Element) ? This->is_empty_element : FALSE;
}
static HRESULT WINAPI xmlreader_GetLineNumber(IXmlReader* iface, UINT *lineNumber)
static BOOL WINAPI xmlreader_IsEOF(IXmlReader* iface)
{
FIXME("(%p): stub\n", iface);
- return E_NOTIMPL;
+ return FALSE;
}
static const struct IXmlReaderVtbl xmlreader_vtbl =
reader->instate = XmlReadInState_Initial;
reader->resumestate = XmlReadResumeState_Initial;
reader->dtdmode = DtdProcessing_Prohibit;
+ reader->resolver = NULL;
+ reader->mlang = NULL;
reader->line = reader->pos = 0;
reader->imalloc = imalloc;
if (imalloc) IMalloc_AddRef(imalloc);
list_init(&reader->attrs);
reader->attr_count = 0;
reader->attr = NULL;
+ list_init(&reader->nsdef);
+ list_init(&reader->ns);
list_init(&reader->elements);
reader->depth = 0;
reader->max_depth = 256;
- reader->empty_element = FALSE;
+ reader->is_empty_element = FALSE;
memset(reader->resume, 0, sizeof(reader->resume));
for (i = 0; i < StringValue_Last; i++)
projects / reactos.git / blobdiff