* IXmlWriter implementation
*
* Copyright 2011 Alistair Leslie-Hughes
+ * Copyright 2014-2018 Nikolay Sivov for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#define COBJMACROS
+#include <assert.h>
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "objbase.h"
+#include "xmllite.h"
#include "xmllite_private.h"
+#ifdef __REACTOS__
+#include <wchar.h>
+#include <winnls.h>
+#endif
+#include "initguid.h"
+
+#include "wine/debug.h"
+#include "wine/list.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(xmllite);
/* not defined in public headers */
DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
+static const WCHAR closeelementW[] = {'<','/'};
+static const WCHAR closetagW[] = {' ','/','>'};
+static const WCHAR closepiW[] = {'?','>'};
+static const WCHAR xmlnsW[] = {' ','x','m','l','n','s'};
+static const WCHAR xmlnsuriW[] = {'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g','/','2','0','0','0','/','x','m','l','n','s','/',0};
+
+struct output_buffer
+{
+ char *data;
+ unsigned int allocated;
+ unsigned int written;
+ UINT codepage;
+};
+
+typedef enum
+{
+ XmlWriterState_Initial, /* output is not set yet */
+ XmlWriterState_Ready, /* SetOutput() was called, ready to start */
+ XmlWriterState_InvalidEncoding, /* SetOutput() was called, but output had invalid encoding */
+ XmlWriterState_PIDocStarted, /* document was started with manually added 'xml' PI */
+ XmlWriterState_DocStarted, /* document was started with WriteStartDocument() */
+ XmlWriterState_ElemStarted, /* writing element */
+ XmlWriterState_Content, /* content is accepted at this point */
+ XmlWriterState_DocClosed /* WriteEndDocument was called */
+} XmlWriterState;
+
typedef struct
{
IXmlWriterOutput IXmlWriterOutput_iface;
LONG ref;
IUnknown *output;
+ ISequentialStream *stream;
IMalloc *imalloc;
xml_encoding encoding;
+ WCHAR *encoding_name; /* exactly as specified on output creation */
+ struct output_buffer buffer;
+ DWORD written : 1;
} xmlwriteroutput;
+static const struct IUnknownVtbl xmlwriteroutputvtbl;
+
+struct element
+{
+ struct list entry;
+ WCHAR *qname;
+ unsigned int len; /* qname length in chars */
+ struct list ns;
+};
+
+struct ns
+{
+ struct list entry;
+ WCHAR *prefix;
+ int prefix_len;
+ WCHAR *uri;
+ BOOL emitted;
+ struct element *element;
+};
+
typedef struct _xmlwriter
{
IXmlWriter IXmlWriter_iface;
LONG ref;
+ IMalloc *imalloc;
+ xmlwriteroutput *output;
+ unsigned int indent_level;
+ BOOL indent;
+ BOOL bom;
+ BOOL omitxmldecl;
+ XmlConformanceLevel conformance;
+ XmlWriterState state;
+ struct list elements;
+ DWORD bomwritten : 1;
+ DWORD starttagopen : 1;
+ DWORD textnode : 1;
} xmlwriter;
static inline xmlwriter *impl_from_IXmlWriter(IXmlWriter *iface)
return CONTAINING_RECORD(iface, xmlwriteroutput, IXmlWriterOutput_iface);
}
-/* reader input memory allocation functions */
-static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len)
+static const char *debugstr_writer_prop(XmlWriterProperty prop)
+{
+ static const char * const prop_names[] =
+ {
+ "MultiLanguage",
+ "Indent",
+ "ByteOrderMark",
+ "OmitXmlDeclaration",
+ "ConformanceLevel"
+ };
+
+ if (prop > _XmlWriterProperty_Last)
+ return wine_dbg_sprintf("unknown property=%d", prop);
+
+ return prop_names[prop];
+}
+
+static HRESULT create_writer_output(IUnknown *stream, IMalloc *imalloc, xml_encoding encoding,
+ const WCHAR *encoding_name, xmlwriteroutput **out);
+
+/* writer output memory allocation functions */
+static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len)
+{
+ return m_alloc(output->imalloc, len);
+}
+
+static inline void writeroutput_free(xmlwriteroutput *output, void *mem)
+{
+ m_free(output->imalloc, mem);
+}
+
+static inline void *writeroutput_realloc(xmlwriteroutput *output, void *mem, size_t len)
+{
+ return m_realloc(output->imalloc, mem, len);
+}
+
+/* writer memory allocation functions */
+static inline void *writer_alloc(const xmlwriter *writer, size_t len)
+{
+ return m_alloc(writer->imalloc, len);
+}
+
+static inline void writer_free(const xmlwriter *writer, void *mem)
+{
+ m_free(writer->imalloc, mem);
+}
+
+static struct element *alloc_element(xmlwriter *writer, const WCHAR *prefix, const WCHAR *local)
+{
+ struct element *ret;
+ int len;
+
+ ret = writer_alloc(writer, sizeof(*ret));
+ if (!ret) return ret;
+
+ len = prefix ? lstrlenW(prefix) + 1 /* ':' */ : 0;
+ len += lstrlenW(local);
+
+ ret->qname = writer_alloc(writer, (len + 1)*sizeof(WCHAR));
+ ret->len = len;
+ if (prefix) {
+ static const WCHAR colonW[] = {':',0};
+ lstrcpyW(ret->qname, prefix);
+ lstrcatW(ret->qname, colonW);
+ }
+ else
+ ret->qname[0] = 0;
+ lstrcatW(ret->qname, local);
+ list_init(&ret->ns);
+
+ return ret;
+}
+
+static void writer_free_element(xmlwriter *writer, struct element *element)
+{
+ struct ns *ns, *ns2;
+
+ LIST_FOR_EACH_ENTRY_SAFE(ns, ns2, &element->ns, struct ns, entry)
+ {
+ list_remove(&ns->entry);
+ writer_free(writer, ns->prefix);
+ writer_free(writer, ns->uri);
+ writer_free(writer, ns);
+ }
+
+ writer_free(writer, element->qname);
+ writer_free(writer, element);
+}
+
+static void writer_free_element_stack(xmlwriter *writer)
+{
+ struct element *element, *element2;
+
+ LIST_FOR_EACH_ENTRY_SAFE(element, element2, &writer->elements, struct element, entry)
+ {
+ list_remove(&element->entry);
+ writer_free_element(writer, element);
+ }
+}
+
+static void writer_push_element(xmlwriter *writer, struct element *element)
+{
+ list_add_head(&writer->elements, &element->entry);
+}
+
+static struct element *pop_element(xmlwriter *writer)
+{
+ struct element *element = LIST_ENTRY(list_head(&writer->elements), struct element, entry);
+
+ if (element)
+ list_remove(&element->entry);
+
+ return element;
+}
+
+static WCHAR *writer_strndupW(const xmlwriter *writer, const WCHAR *str, int len)
+{
+ size_t size;
+ WCHAR *ret;
+
+ if (!str)
+ return NULL;
+
+ if (len == -1)
+ len = lstrlenW(str);
+
+ size = (len + 1) * sizeof(WCHAR);
+ ret = writer_alloc(writer, size);
+ memcpy(ret, str, size);
+ return ret;
+}
+
+static WCHAR *writer_strdupW(const xmlwriter *writer, const WCHAR *str)
+{
+ return writer_strndupW(writer, str, -1);
+}
+
+static struct ns *writer_push_ns(xmlwriter *writer, const WCHAR *prefix, int prefix_len, const WCHAR *uri)
+{
+ struct element *element;
+ struct ns *ns;
+
+ element = LIST_ENTRY(list_head(&writer->elements), struct element, entry);
+ if (!element)
+ return NULL;
+
+ if ((ns = writer_alloc(writer, sizeof(*ns))))
+ {
+ ns->prefix = writer_strndupW(writer, prefix, prefix_len);
+ ns->prefix_len = prefix_len;
+ ns->uri = writer_strdupW(writer, uri);
+ ns->emitted = FALSE;
+ ns->element = element;
+ list_add_tail(&element->ns, &ns->entry);
+ }
+
+ return ns;
+}
+
+static BOOL is_empty_string(const WCHAR *str)
+{
+ return !str || !*str;
+}
+
+static struct ns *writer_find_ns_current(const xmlwriter *writer, const WCHAR *prefix, const WCHAR *uri)
+{
+ struct element *element;
+ struct ns *ns;
+
+ if (is_empty_string(prefix) || is_empty_string(uri))
+ return NULL;
+
+ element = LIST_ENTRY(list_head(&writer->elements), struct element, entry);
+
+ LIST_FOR_EACH_ENTRY(ns, &element->ns, struct ns, entry)
+ {
+ if (!wcscmp(uri, ns->uri) && !wcscmp(prefix, ns->prefix))
+ return ns;
+ }
+
+ return NULL;
+}
+
+static struct ns *writer_find_ns(const xmlwriter *writer, const WCHAR *prefix, const WCHAR *uri)
+{
+ struct element *element;
+ struct ns *ns;
+
+ if (is_empty_string(prefix) && is_empty_string(uri))
+ return NULL;
+
+ LIST_FOR_EACH_ENTRY(element, &writer->elements, struct element, entry)
+ {
+ LIST_FOR_EACH_ENTRY(ns, &element->ns, struct ns, entry)
+ {
+ if (!uri)
+ {
+ if (!ns->prefix) continue;
+ if (!wcscmp(ns->prefix, prefix))
+ return ns;
+ }
+ else if (!wcscmp(uri, ns->uri))
+ {
+ if (prefix && !*prefix)
+ return NULL;
+ if (!prefix || !wcscmp(prefix, ns->prefix))
+ return ns;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static HRESULT is_valid_ncname(const WCHAR *str, int *out)
+{
+ int len = 0;
+
+ *out = 0;
+
+ if (!str || !*str)
+ return S_OK;
+
+ while (*str)
+ {
+ if (!is_ncnamechar(*str))
+ return WC_E_NAMECHARACTER;
+ len++;
+ str++;
+ }
+
+ *out = len;
+ return S_OK;
+}
+
+static HRESULT is_valid_name(const WCHAR *str, unsigned int *out)
+{
+ unsigned int len = 1;
+
+ *out = 0;
+
+ if (!str || !*str)
+ return S_OK;
+
+ if (!is_namestartchar(*str++))
+ return WC_E_NAMECHARACTER;
+
+ while (*str++)
+ {
+ if (!is_namechar(*str))
+ return WC_E_NAMECHARACTER;
+ len++;
+ }
+
+ *out = len;
+ return S_OK;
+}
+
+static HRESULT is_valid_pubid(const WCHAR *str, unsigned int *out)
+{
+ unsigned int len = 0;
+
+ *out = 0;
+
+ if (!str || !*str)
+ return S_OK;
+
+ while (*str)
+ {
+ if (!is_pubchar(*str++))
+ return WC_E_PUBLICID;
+ len++;
+ }
+
+ *out = len;
+
+ return S_OK;
+}
+
+static HRESULT init_output_buffer(xmlwriteroutput *output)
+{
+ struct output_buffer *buffer = &output->buffer;
+ const int initial_len = 0x2000;
+ UINT cp = ~0u;
+ HRESULT hr;
+
+ if (FAILED(hr = get_code_page(output->encoding, &cp)))
+ WARN("Failed to get code page for specified encoding.\n");
+
+ buffer->data = writeroutput_alloc(output, initial_len);
+ if (!buffer->data) return E_OUTOFMEMORY;
+
+ memset(buffer->data, 0, 4);
+ buffer->allocated = initial_len;
+ buffer->written = 0;
+ buffer->codepage = cp;
+
+ return S_OK;
+}
+
+static void free_output_buffer(xmlwriteroutput *output)
+{
+ struct output_buffer *buffer = &output->buffer;
+ writeroutput_free(output, buffer->data);
+ buffer->data = NULL;
+ buffer->allocated = 0;
+ buffer->written = 0;
+}
+
+static HRESULT grow_output_buffer(xmlwriteroutput *output, int length)
+{
+ struct output_buffer *buffer = &output->buffer;
+ /* 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);
+ char *ptr = writeroutput_realloc(output, buffer->data, grown_size);
+ if (!ptr) return E_OUTOFMEMORY;
+ buffer->data = ptr;
+ buffer->allocated = grown_size;
+ }
+
+ return S_OK;
+}
+
+static HRESULT write_output_buffer(xmlwriteroutput *output, const WCHAR *data, int len)
+{
+ struct output_buffer *buffer = &output->buffer;
+ int length;
+ HRESULT hr;
+ char *ptr;
+
+ if (buffer->codepage == 1200) {
+ /* For UTF-16 encoding just copy. */
+ length = len == -1 ? lstrlenW(data) : len;
+ if (length) {
+ length *= sizeof(WCHAR);
+
+ hr = grow_output_buffer(output, length);
+ if (FAILED(hr)) return hr;
+ ptr = buffer->data + buffer->written;
+
+ memcpy(ptr, data, length);
+ buffer->written += length;
+ ptr += length;
+ /* null termination */
+ *(WCHAR*)ptr = 0;
+ }
+ }
+ else {
+ length = WideCharToMultiByte(buffer->codepage, 0, data, len, NULL, 0, NULL, NULL);
+ hr = grow_output_buffer(output, length);
+ if (FAILED(hr)) return hr;
+ ptr = buffer->data + buffer->written;
+ length = WideCharToMultiByte(buffer->codepage, 0, data, len, ptr, length, NULL, NULL);
+ buffer->written += len == -1 ? length-1 : length;
+ }
+ output->written = length != 0;
+
+ return S_OK;
+}
+
+static HRESULT write_output_buffer_char(xmlwriteroutput *output, WCHAR ch)
+{
+ return write_output_buffer(output, &ch, 1);
+}
+
+static HRESULT write_output_buffer_quoted(xmlwriteroutput *output, const WCHAR *data, int len)
+{
+ write_output_buffer_char(output, '"');
+ if (!is_empty_string(data))
+ write_output_buffer(output, data, len);
+ write_output_buffer_char(output, '"');
+ return S_OK;
+}
+
+/* TODO: test if we need to validate char range */
+static HRESULT write_output_qname(xmlwriteroutput *output, const WCHAR *prefix, int prefix_len,
+ const WCHAR *local_name, int local_len)
+{
+ assert(prefix_len >= 0 && local_len >= 0);
+
+ if (prefix_len)
+ write_output_buffer(output, prefix, prefix_len);
+
+ if (prefix_len && local_len)
+ write_output_buffer_char(output, ':');
+
+ write_output_buffer(output, local_name, local_len);
+
+ return S_OK;
+}
+
+static void writeroutput_release_stream(xmlwriteroutput *writeroutput)
+{
+ if (writeroutput->stream) {
+ ISequentialStream_Release(writeroutput->stream);
+ writeroutput->stream = NULL;
+ }
+}
+
+static inline HRESULT writeroutput_query_for_stream(xmlwriteroutput *writeroutput)
+{
+ HRESULT hr;
+
+ writeroutput_release_stream(writeroutput);
+ hr = IUnknown_QueryInterface(writeroutput->output, &IID_IStream, (void**)&writeroutput->stream);
+ if (hr != S_OK)
+ hr = IUnknown_QueryInterface(writeroutput->output, &IID_ISequentialStream, (void**)&writeroutput->stream);
+
+ return hr;
+}
+
+static HRESULT writeroutput_flush_stream(xmlwriteroutput *output)
+{
+ struct output_buffer *buffer;
+ ULONG written, offset = 0;
+ HRESULT hr;
+
+ if (!output || !output->stream)
+ return S_OK;
+
+ buffer = &output->buffer;
+
+ /* It will loop forever until everything is written or an error occurred. */
+ do {
+ written = 0;
+ hr = ISequentialStream_Write(output->stream, buffer->data + offset, buffer->written, &written);
+ if (FAILED(hr)) {
+ WARN("write to stream failed (0x%08x)\n", hr);
+ buffer->written = 0;
+ return hr;
+ }
+
+ offset += written;
+ buffer->written -= written;
+ } while (buffer->written > 0);
+
+ return S_OK;
+}
+
+static HRESULT write_encoding_bom(xmlwriter *writer)
+{
+ if (!writer->bom || writer->bomwritten) return S_OK;
+
+ if (writer->output->encoding == XmlEncoding_UTF16) {
+ static const char utf16bom[] = {0xff, 0xfe};
+ struct output_buffer *buffer = &writer->output->buffer;
+ int len = sizeof(utf16bom);
+ HRESULT hr;
+
+ hr = grow_output_buffer(writer->output, len);
+ if (FAILED(hr)) return hr;
+ memcpy(buffer->data + buffer->written, utf16bom, len);
+ buffer->written += len;
+ }
+
+ writer->bomwritten = TRUE;
+ return S_OK;
+}
+
+static const WCHAR *get_output_encoding_name(xmlwriteroutput *output)
+{
+ if (output->encoding_name)
+ return output->encoding_name;
+
+ return get_encoding_name(output->encoding);
+}
+
+static HRESULT write_xmldecl(xmlwriter *writer, XmlStandalone standalone)
+{
+ static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"'};
+ static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','='};
+
+ write_encoding_bom(writer);
+ writer->state = XmlWriterState_DocStarted;
+ if (writer->omitxmldecl) return S_OK;
+
+ /* version */
+ write_output_buffer(writer->output, versionW, ARRAY_SIZE(versionW));
+
+ /* encoding */
+ write_output_buffer(writer->output, encodingW, ARRAY_SIZE(encodingW));
+ write_output_buffer_quoted(writer->output, get_output_encoding_name(writer->output), -1);
+
+ /* standalone */
+ if (standalone == XmlStandalone_Omit)
+ write_output_buffer(writer->output, closepiW, ARRAY_SIZE(closepiW));
+ else {
+ static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
+ static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
+ static const WCHAR noW[] = {'n','o','\"','?','>'};
+
+ write_output_buffer(writer->output, standaloneW, ARRAY_SIZE(standaloneW));
+ if (standalone == XmlStandalone_Yes)
+ write_output_buffer(writer->output, yesW, ARRAY_SIZE(yesW));
+ else
+ write_output_buffer(writer->output, noW, ARRAY_SIZE(noW));
+ }
+
+ return S_OK;
+}
+
+static void writer_output_ns(xmlwriter *writer, struct element *element)
+{
+ struct ns *ns;
+
+ LIST_FOR_EACH_ENTRY(ns, &element->ns, struct ns, entry)
+ {
+ if (ns->emitted)
+ continue;
+
+ write_output_qname(writer->output, xmlnsW, ARRAY_SIZE(xmlnsW), ns->prefix, ns->prefix_len);
+ write_output_buffer_char(writer->output, '=');
+ write_output_buffer_quoted(writer->output, ns->uri, -1);
+ }
+}
+
+static HRESULT writer_close_starttag(xmlwriter *writer)
+{
+ HRESULT hr;
+
+ if (!writer->starttagopen) return S_OK;
+
+ writer_output_ns(writer, LIST_ENTRY(list_head(&writer->elements), struct element, entry));
+ hr = write_output_buffer_char(writer->output, '>');
+ writer->starttagopen = 0;
+ return hr;
+}
+
+static void writer_inc_indent(xmlwriter *writer)
+{
+ writer->indent_level++;
+}
+
+static void writer_dec_indent(xmlwriter *writer)
+{
+ if (writer->indent_level)
+ writer->indent_level--;
+}
+
+static void write_node_indent(xmlwriter *writer)
+{
+ static const WCHAR dblspaceW[] = {' ',' '};
+ static const WCHAR crlfW[] = {'\r','\n'};
+ unsigned int indent_level = writer->indent_level;
+
+ if (!writer->indent || writer->textnode)
+ {
+ writer->textnode = 0;
+ return;
+ }
+
+ /* Do state check to prevent newline inserted after BOM. It is assumed that
+ state does not change between writing BOM and inserting indentation. */
+ if (writer->output->written && writer->state != XmlWriterState_Ready)
+ write_output_buffer(writer->output, crlfW, ARRAY_SIZE(crlfW));
+ while (indent_level--)
+ write_output_buffer(writer->output, dblspaceW, ARRAY_SIZE(dblspaceW));
+
+ writer->textnode = 0;
+}
+
+static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+
+ TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
+
+ if (IsEqualGUID(riid, &IID_IXmlWriter) ||
+ IsEqualGUID(riid, &IID_IUnknown))
+ {
+ *ppvObject = iface;
+ }
+ else
+ {
+ FIXME("interface %s is not supported\n", debugstr_guid(riid));
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+
+ IXmlWriter_AddRef(iface);
+
+ return S_OK;
+}
+
+static ULONG WINAPI xmlwriter_AddRef(IXmlWriter *iface)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+ ULONG ref = InterlockedIncrement(&This->ref);
+ TRACE("(%p)->(%u)\n", This, ref);
+ return ref;
+}
+
+static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p)->(%u)\n", This, ref);
+
+ if (ref == 0) {
+ IMalloc *imalloc = This->imalloc;
+
+ writeroutput_flush_stream(This->output);
+ if (This->output) IUnknown_Release(&This->output->IXmlWriterOutput_iface);
+
+ writer_free_element_stack(This);
+
+ writer_free(This, This);
+ if (imalloc) IMalloc_Release(imalloc);
+ }
+
+ return ref;
+}
+
+/*** IXmlWriter methods ***/
+static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *output)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+ IXmlWriterOutput *writeroutput;
+ HRESULT hr;
+
+ TRACE("(%p)->(%p)\n", This, output);
+
+ if (This->output) {
+ writeroutput_release_stream(This->output);
+ IUnknown_Release(&This->output->IXmlWriterOutput_iface);
+ This->output = NULL;
+ This->bomwritten = 0;
+ This->textnode = 0;
+ This->indent_level = 0;
+ writer_free_element_stack(This);
+ }
+
+ /* just reset current output */
+ if (!output) {
+ This->state = XmlWriterState_Initial;
+ return S_OK;
+ }
+
+ /* now try IXmlWriterOutput, ISequentialStream, IStream */
+ hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&writeroutput);
+ if (hr == S_OK) {
+ if (writeroutput->lpVtbl == &xmlwriteroutputvtbl)
+ This->output = impl_from_IXmlWriterOutput(writeroutput);
+ else {
+ ERR("got external IXmlWriterOutput implementation: %p, vtbl=%p\n",
+ writeroutput, writeroutput->lpVtbl);
+ IUnknown_Release(writeroutput);
+ return E_FAIL;
+ }
+ }
+
+ if (hr != S_OK || !writeroutput) {
+ /* Create output for given stream. */
+ hr = create_writer_output(output, This->imalloc, XmlEncoding_UTF8, NULL, &This->output);
+ if (hr != S_OK)
+ return hr;
+ }
+
+ if (This->output->encoding == XmlEncoding_Unknown)
+ This->state = XmlWriterState_InvalidEncoding;
+ else
+ This->state = XmlWriterState_Ready;
+ return writeroutput_query_for_stream(This->output);
+}
+
+static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT property, LONG_PTR *value)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+
+ TRACE("(%p)->(%s %p)\n", This, debugstr_writer_prop(property), value);
+
+ if (!value) return E_INVALIDARG;
+
+ switch (property)
+ {
+ case XmlWriterProperty_Indent:
+ *value = This->indent;
+ break;
+ case XmlWriterProperty_ByteOrderMark:
+ *value = This->bom;
+ break;
+ case XmlWriterProperty_OmitXmlDeclaration:
+ *value = This->omitxmldecl;
+ break;
+ case XmlWriterProperty_ConformanceLevel:
+ *value = This->conformance;
+ break;
+ default:
+ FIXME("Unimplemented property (%u)\n", property);
+ return E_NOTIMPL;
+ }
+
+ return S_OK;
+}
+
+static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT property, LONG_PTR value)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+
+ TRACE("(%p)->(%s %lu)\n", This, debugstr_writer_prop(property), value);
+
+ switch (property)
+ {
+ case XmlWriterProperty_Indent:
+ This->indent = !!value;
+ break;
+ case XmlWriterProperty_ByteOrderMark:
+ This->bom = !!value;
+ break;
+ case XmlWriterProperty_OmitXmlDeclaration:
+ This->omitxmldecl = !!value;
+ break;
+ default:
+ FIXME("Unimplemented property (%u)\n", property);
+ return E_NOTIMPL;
+ }
+
+ return S_OK;
+}
+
+static HRESULT WINAPI xmlwriter_WriteAttributes(IXmlWriter *iface, IXmlReader *pReader,
+ BOOL fWriteDefaultAttributes)
+{
+ xmlwriter *This = impl_from_IXmlWriter(iface);
+
+ FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
+
+ return E_NOTIMPL;
+}
+
+static void write_output_attribute(xmlwriter *writer, const WCHAR *prefix, int prefix_len,
+ const WCHAR *local, int local_len, const WCHAR *value)
{
- return m_alloc(output->imalloc, len);
+ write_output_buffer_char(writer->output, ' ');
+ write_output_qname(writer->output, prefix, prefix_len, local, local_len);
+ write_output_buffer_char(writer->output, '=');
+ write_output_buffer_quoted(writer->output, value, -1);
}
-static inline void writeroutput_free(xmlwriteroutput *output, void *mem)
+static BOOL is_valid_xml_space_value(const WCHAR *value)
{
- m_free(output->imalloc, mem);
+ static const WCHAR preserveW[] = {'p','r','e','s','e','r','v','e',0};
+ static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
+
+ if (!value)
+ return FALSE;
+
+ return !wcscmp(value, preserveW) || !wcscmp(value, defaultW);
}
-static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject)
+static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR prefix,
+ LPCWSTR local, LPCWSTR uri, LPCWSTR value)
{
+ static const WCHAR spaceattrW[] = {'s','p','a','c','e',0};
+ static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
+ static const WCHAR xmlW[] = {'x','m','l',0};
xmlwriter *This = impl_from_IXmlWriter(iface);
+ BOOL is_xmlns_prefix, is_xmlns_local;
+ int prefix_len, local_len;
+ struct ns *ns;
+ HRESULT hr;
- TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+ TRACE("%p %s %s %s %s\n", This, debugstr_w(prefix), debugstr_w(local), debugstr_w(uri), debugstr_w(value));
- if (IsEqualGUID(riid, &IID_IUnknown) ||
- IsEqualGUID(riid, &IID_IXmlWriter))
+ switch (This->state)
{
- *ppvObject = iface;
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
}
- IXmlWriter_AddRef(iface);
+ /* Prefix "xmlns" */
+ is_xmlns_prefix = prefix && !wcscmp(prefix, xmlnsW);
+ if (is_xmlns_prefix && is_empty_string(uri) && is_empty_string(local))
+ return WR_E_NSPREFIXDECLARED;
+
+ if (!local)
+ return E_INVALIDARG;
+
+ /* Validate prefix and local name */
+ if (FAILED(hr = is_valid_ncname(prefix, &prefix_len)))
+ return hr;
+
+ if (FAILED(hr = is_valid_ncname(local, &local_len)))
+ return hr;
+
+ is_xmlns_local = !wcscmp(local, xmlnsW);
+
+ /* Trivial case, no prefix. */
+ if (prefix_len == 0 && is_empty_string(uri))
+ {
+ write_output_attribute(This, prefix, prefix_len, local, local_len, value);
+ return S_OK;
+ }
+
+ /* Predefined "xml" prefix. */
+ if (prefix_len && !wcscmp(prefix, xmlW))
+ {
+ /* Valid "space" value is enforced. */
+ if (!wcscmp(local, spaceattrW) && !is_valid_xml_space_value(value))
+ return WR_E_INVALIDXMLSPACE;
+
+ /* Redefinition is not allowed. */
+ if (!is_empty_string(uri))
+ return WR_E_XMLPREFIXDECLARATION;
+
+ write_output_attribute(This, prefix, prefix_len, local, local_len, value);
+
+ return S_OK;
+ }
+
+ if (is_xmlns_prefix || (prefix_len == 0 && uri && !wcscmp(uri, xmlnsuriW)))
+ {
+ if (prefix_len && !is_empty_string(uri))
+ return WR_E_XMLNSPREFIXDECLARATION;
+
+ /* Look for exact match defined in current element, and write it out. */
+ if (!(ns = writer_find_ns_current(This, prefix, value)))
+ ns = writer_push_ns(This, local, local_len, value);
+ ns->emitted = TRUE;
+
+ write_output_attribute(This, xmlnsW, ARRAY_SIZE(xmlnsW) - 1, local, local_len, value);
+
+ return S_OK;
+ }
+
+ /* Ignore prefix is URI wasn't specified. */
+ if (is_xmlns_local && is_empty_string(uri))
+ {
+ write_output_attribute(This, NULL, 0, xmlnsW, ARRAY_SIZE(xmlnsW) - 1, value);
+ return S_OK;
+ }
+
+ if (!(ns = writer_find_ns(This, prefix, uri)))
+ {
+ if (is_empty_string(prefix) && !is_empty_string(uri))
+ {
+ FIXME("Prefix autogeneration is not implemented.\n");
+ return E_NOTIMPL;
+ }
+ if (!is_empty_string(uri))
+ ns = writer_push_ns(This, prefix, prefix_len, uri);
+ }
+
+ if (ns)
+ write_output_attribute(This, ns->prefix, ns->prefix_len, local, local_len, value);
+ else
+ write_output_attribute(This, prefix, prefix_len, local, local_len, value);
return S_OK;
}
-static ULONG WINAPI xmlwriter_AddRef(IXmlWriter *iface)
+static void write_cdata_section(xmlwriteroutput *output, const WCHAR *data, int len)
{
- xmlwriter *This = impl_from_IXmlWriter(iface);
- TRACE("%p\n", This);
- return InterlockedIncrement(&This->ref);
+ static const WCHAR cdataopenW[] = {'<','!','[','C','D','A','T','A','['};
+ static const WCHAR cdatacloseW[] = {']',']','>'};
+ write_output_buffer(output, cdataopenW, ARRAY_SIZE(cdataopenW));
+ if (data)
+ write_output_buffer(output, data, len);
+ write_output_buffer(output, cdatacloseW, ARRAY_SIZE(cdatacloseW));
}
-static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
+static HRESULT WINAPI xmlwriter_WriteCData(IXmlWriter *iface, LPCWSTR data)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- LONG ref;
+ int len;
- TRACE("%p\n", This);
+ TRACE("%p %s\n", This, debugstr_w(data));
- ref = InterlockedDecrement(&This->ref);
- if (ref == 0)
- heap_free(This);
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
- return ref;
+ len = data ? lstrlenW(data) : 0;
+
+ write_node_indent(This);
+ if (!len)
+ write_cdata_section(This->output, NULL, 0);
+ else {
+ static const WCHAR cdatacloseW[] = {']',']','>',0};
+ while (len) {
+ const WCHAR *str = wcsstr(data, cdatacloseW);
+ if (str) {
+ str += 2;
+ write_cdata_section(This->output, data, str - data);
+ len -= str - data;
+ data = str;
+ }
+ else {
+ write_cdata_section(This->output, data, len);
+ break;
+ }
+ }
+ }
+
+ return S_OK;
}
-/*** IXmlWriter methods ***/
-static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *pOutput)
+static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR ch)
{
+ static const WCHAR fmtW[] = {'&','#','x','%','x',';',0};
xmlwriter *This = impl_from_IXmlWriter(iface);
+ WCHAR bufW[16];
- FIXME("%p %p\n", This, pOutput);
+ TRACE("%p %#x\n", This, ch);
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
+ swprintf(bufW, fmtW, ch);
+ write_output_buffer(This->output, bufW, -1);
+
+ return S_OK;
}
-static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR *ppValue)
+static HRESULT WINAPI xmlwriter_WriteChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p %u %p\n", This, nProperty, ppValue);
+ FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
+
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
return E_NOTIMPL;
}
-static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR pValue)
+
+static HRESULT WINAPI xmlwriter_WriteComment(IXmlWriter *iface, LPCWSTR comment)
{
+ static const WCHAR copenW[] = {'<','!','-','-'};
+ static const WCHAR ccloseW[] = {'-','-','>'};
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p %u %lu\n", This, nProperty, pValue);
+ TRACE("%p %s\n", This, debugstr_w(comment));
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
+ write_node_indent(This);
+ write_output_buffer(This->output, copenW, ARRAY_SIZE(copenW));
+ if (comment) {
+ int len = lstrlenW(comment), i;
+
+ /* Make sure there's no two hyphen sequences in a string, space is used as a separator to produce compliant
+ comment string */
+ if (len > 1) {
+ for (i = 0; i < len; i++) {
+ write_output_buffer(This->output, comment + i, 1);
+ if (comment[i] == '-' && (i + 1 < len) && comment[i+1] == '-')
+ write_output_buffer_char(This->output, ' ');
+ }
+ }
+ else
+ write_output_buffer(This->output, comment, len);
+
+ if (len && comment[len-1] == '-')
+ write_output_buffer_char(This->output, ' ');
+ }
+ write_output_buffer(This->output, ccloseW, ARRAY_SIZE(ccloseW));
+
+ return S_OK;
}
-static HRESULT WINAPI xmlwriter_WriteAttributes(IXmlWriter *iface, IXmlReader *pReader,
- BOOL fWriteDefaultAttributes)
+static HRESULT WINAPI xmlwriter_WriteDocType(IXmlWriter *iface, LPCWSTR name, LPCWSTR pubid,
+ LPCWSTR sysid, LPCWSTR subset)
{
+ static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',' '};
+ static const WCHAR publicW[] = {' ','P','U','B','L','I','C',' '};
+ static const WCHAR systemW[] = {' ','S','Y','S','T','E','M',' '};
xmlwriter *This = impl_from_IXmlWriter(iface);
+ unsigned int name_len, pubid_len;
+ HRESULT hr;
- FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
+ TRACE("(%p)->(%s %s %s %s)\n", This, wine_dbgstr_w(name), wine_dbgstr_w(pubid), wine_dbgstr_w(sysid),
+ wine_dbgstr_w(subset));
- return E_NOTIMPL;
-}
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_Content:
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
-static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR pwszPrefix,
- LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
- LPCWSTR pwszValue)
-{
- xmlwriter *This = impl_from_IXmlWriter(iface);
+ if (is_empty_string(name))
+ return E_INVALIDARG;
- FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
- wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
+ if (FAILED(hr = is_valid_name(name, &name_len)))
+ return hr;
- return E_NOTIMPL;
-}
+ if (FAILED(hr = is_valid_pubid(pubid, &pubid_len)))
+ return hr;
-static HRESULT WINAPI xmlwriter_WriteCData(IXmlWriter *iface, LPCWSTR pwszText)
-{
- xmlwriter *This = impl_from_IXmlWriter(iface);
+ write_output_buffer(This->output, doctypeW, ARRAY_SIZE(doctypeW));
+ write_output_buffer(This->output, name, name_len);
- FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
+ if (pubid)
+ {
+ write_output_buffer(This->output, publicW, ARRAY_SIZE(publicW));
+ write_output_buffer_quoted(This->output, pubid, pubid_len);
+ write_output_buffer_char(This->output, ' ');
+ write_output_buffer_quoted(This->output, sysid, -1);
+ }
+ else if (sysid)
+ {
+ write_output_buffer(This->output, systemW, ARRAY_SIZE(systemW));
+ write_output_buffer_quoted(This->output, sysid, -1);
+ }
- return E_NOTIMPL;
-}
+ if (subset)
+ {
+ write_output_buffer_char(This->output, ' ');
+ write_output_buffer_char(This->output, '[');
+ write_output_buffer(This->output, subset, -1);
+ write_output_buffer_char(This->output, ']');
+ }
+ write_output_buffer_char(This->output, '>');
-static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR wch)
-{
- return E_NOTIMPL;
+ This->state = XmlWriterState_Content;
+
+ return S_OK;
}
-static HRESULT WINAPI xmlwriter_WriteChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
+static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR prefix,
+ LPCWSTR local_name, LPCWSTR uri, LPCWSTR value)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
+ int prefix_len, local_len;
+ struct ns *ns;
+ HRESULT hr;
- FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
+ TRACE("(%p)->(%s %s %s %s)\n", This, wine_dbgstr_w(prefix), wine_dbgstr_w(local_name),
+ wine_dbgstr_w(uri), wine_dbgstr_w(value));
- return E_NOTIMPL;
-}
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
-static HRESULT WINAPI xmlwriter_WriteComment(IXmlWriter *iface, LPCWSTR pwszComment)
-{
- return E_NOTIMPL;
-}
+ if (!local_name)
+ return E_INVALIDARG;
-static HRESULT WINAPI xmlwriter_WriteDocType(IXmlWriter *iface, LPCWSTR pwszName, LPCWSTR pwszPublicId,
- LPCWSTR pwszSystemId, LPCWSTR pwszSubset)
-{
- xmlwriter *This = impl_from_IXmlWriter(iface);
+ /* Validate prefix and local name */
+ if (FAILED(hr = is_valid_ncname(prefix, &prefix_len)))
+ return hr;
- FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszPublicId),
- wine_dbgstr_w(pwszSystemId), wine_dbgstr_w(pwszSubset));
+ if (FAILED(hr = is_valid_ncname(local_name, &local_len)))
+ return hr;
- return E_NOTIMPL;
-}
+ ns = writer_find_ns(This, prefix, uri);
+ if (!ns && !is_empty_string(prefix) && is_empty_string(uri))
+ return WR_E_NSPREFIXWITHEMPTYNSURI;
-static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR pwszPrefix,
- LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
- LPCWSTR pwszValue)
-{
- xmlwriter *This = impl_from_IXmlWriter(iface);
+ if (uri && !wcscmp(uri, xmlnsuriW))
+ {
+ if (!prefix)
+ return WR_E_XMLNSPREFIXDECLARATION;
+
+ if (!is_empty_string(prefix))
+ return WR_E_XMLNSURIDECLARATION;
+ }
- FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
- wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
+ write_encoding_bom(This);
+ write_node_indent(This);
- return E_NOTIMPL;
+ write_output_buffer_char(This->output, '<');
+ if (ns)
+ write_output_qname(This->output, ns->prefix, ns->prefix_len, local_name, local_len);
+ else
+ write_output_qname(This->output, prefix, prefix_len, local_name, local_len);
+
+ if (!ns && (prefix_len || !is_empty_string(uri)))
+ {
+ write_output_qname(This->output, xmlnsW, ARRAY_SIZE(xmlnsW), prefix, prefix_len);
+ write_output_buffer_char(This->output, '=');
+ write_output_buffer_quoted(This->output, uri, -1);
+ }
+
+ if (value)
+ {
+ write_output_buffer_char(This->output, '>');
+ write_output_buffer(This->output, value, -1);
+ write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
+ write_output_qname(This->output, prefix, prefix_len, local_name, local_len);
+ write_output_buffer_char(This->output, '>');
+ }
+ else
+ write_output_buffer(This->output, closetagW, ARRAY_SIZE(closetagW));
+
+ This->state = XmlWriterState_Content;
+
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteEndDocument(IXmlWriter *iface)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p\n", This);
+ TRACE("%p\n", This);
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
+
+ /* empty element stack */
+ while (IXmlWriter_WriteEndElement(iface) == S_OK)
+ ;
+
+ This->state = XmlWriterState_DocClosed;
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteEndElement(IXmlWriter *iface)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
+ struct element *element;
- FIXME("%p\n", This);
+ TRACE("%p\n", This);
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
+
+ element = pop_element(This);
+ if (!element)
+ return WR_E_INVALIDACTION;
+
+ writer_dec_indent(This);
+
+ if (This->starttagopen)
+ {
+ writer_output_ns(This, element);
+ write_output_buffer(This->output, closetagW, ARRAY_SIZE(closetagW));
+ This->starttagopen = 0;
+ }
+ else
+ {
+ /* Write full end tag. */
+ write_node_indent(This);
+ write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
+ write_output_buffer(This->output, element->qname, element->len);
+ write_output_buffer_char(This->output, '>');
+ }
+ writer_free_element(This, element);
+
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteEntityRef(IXmlWriter *iface, LPCWSTR pwszName)
FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
return E_NOTIMPL;
}
static HRESULT WINAPI xmlwriter_WriteFullEndElement(IXmlWriter *iface)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
+ struct element *element;
- FIXME("%p\n", This);
+ TRACE("%p\n", This);
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ default:
+ ;
+ }
+
+ element = pop_element(This);
+ if (!element)
+ return WR_E_INVALIDACTION;
+
+ writer_dec_indent(This);
+
+ /* don't force full end tag to the next line */
+ if (This->state == XmlWriterState_ElemStarted)
+ {
+ This->state = XmlWriterState_Content;
+ This->textnode = 0;
+ }
+ else
+ write_node_indent(This);
+
+ /* write full end tag */
+ write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
+ write_output_buffer(This->output, element->qname, element->len);
+ write_output_buffer_char(This->output, '>');
+
+ writer_free_element(This, element);
+
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteName(IXmlWriter *iface, LPCWSTR pwszName)
FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
+
return E_NOTIMPL;
}
FIXME("%p %s\n", This, wine_dbgstr_w(pwszNmToken));
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
+
return E_NOTIMPL;
}
return E_NOTIMPL;
}
-static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR pwszName,
- LPCWSTR pwszText)
+static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR name,
+ LPCWSTR text)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
+ static const WCHAR xmlW[] = {'x','m','l',0};
+ static const WCHAR openpiW[] = {'<','?'};
- FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszText));
+ TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_w(name), wine_dbgstr_w(text));
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocStarted:
+ if (!wcscmp(name, xmlW))
+ return WR_E_INVALIDACTION;
+ break;
+ case XmlWriterState_ElemStarted:
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
+ write_encoding_bom(This);
+ write_node_indent(This);
+ write_output_buffer(This->output, openpiW, ARRAY_SIZE(openpiW));
+ write_output_buffer(This->output, name, -1);
+ write_output_buffer_char(This->output, ' ');
+ write_output_buffer(This->output, text, -1);
+ write_output_buffer(This->output, closepiW, ARRAY_SIZE(closepiW));
+
+ if (!wcscmp(name, xmlW))
+ This->state = XmlWriterState_PIDocStarted;
+
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteQualifiedName(IXmlWriter *iface, LPCWSTR pwszLocalName,
FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszLocalName), wine_dbgstr_w(pwszNamespaceUri));
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
return E_NOTIMPL;
}
-static HRESULT WINAPI xmlwriter_WriteRaw(IXmlWriter *iface, LPCWSTR pwszData)
+static HRESULT WINAPI xmlwriter_WriteRaw(IXmlWriter *iface, LPCWSTR data)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p %s\n", This, wine_dbgstr_w(pwszData));
+ TRACE("%p %s\n", This, debugstr_w(data));
- return E_NOTIMPL;
+ if (!data)
+ return S_OK;
+
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_Ready:
+ write_xmldecl(This, XmlStandalone_Omit);
+ /* fallthrough */
+ case XmlWriterState_DocStarted:
+ case XmlWriterState_PIDocStarted:
+ break;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ }
+
+ write_output_buffer(This->output, data, -1);
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteRawChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ default:
+ ;
+ }
+
return E_NOTIMPL;
}
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p\n", This);
+ TRACE("(%p)->(%d)\n", This, standalone);
- return E_NOTIMPL;
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_PIDocStarted:
+ This->state = XmlWriterState_DocStarted;
+ return S_OK;
+ case XmlWriterState_Ready:
+ break;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ }
+
+ return write_xmldecl(This, standalone);
}
-static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR pwszPrefix,
- LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri)
+static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR prefix, LPCWSTR local_name, LPCWSTR uri)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
+ int prefix_len, local_len;
+ struct element *element;
+ struct ns *ns;
+ HRESULT hr;
- FIXME("%p %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
- wine_dbgstr_w(pwszNamespaceUri));
+ TRACE("(%p)->(%s %s %s)\n", This, wine_dbgstr_w(prefix), wine_dbgstr_w(local_name), wine_dbgstr_w(uri));
- return E_NOTIMPL;
+ if (!local_name)
+ return E_INVALIDARG;
+
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ case XmlWriterState_DocClosed:
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ default:
+ ;
+ }
+
+ /* Validate prefix and local name */
+ if (FAILED(hr = is_valid_ncname(prefix, &prefix_len)))
+ return hr;
+
+ if (FAILED(hr = is_valid_ncname(local_name, &local_len)))
+ return hr;
+
+ if (uri && !wcscmp(uri, xmlnsuriW))
+ {
+ if (!prefix)
+ return WR_E_XMLNSPREFIXDECLARATION;
+
+ if (!is_empty_string(prefix))
+ return WR_E_XMLNSURIDECLARATION;
+ }
+
+ ns = writer_find_ns(This, prefix, uri);
+
+ element = alloc_element(This, prefix, local_name);
+ if (!element)
+ return E_OUTOFMEMORY;
+
+ write_encoding_bom(This);
+ write_node_indent(This);
+
+ This->state = XmlWriterState_ElemStarted;
+ This->starttagopen = 1;
+
+ writer_push_element(This, element);
+
+ if (!ns && uri)
+ writer_push_ns(This, prefix, prefix_len, uri);
+
+ write_output_buffer_char(This->output, '<');
+ if (ns)
+ write_output_qname(This->output, ns->prefix, ns->prefix_len, local_name, local_len);
+ else
+ write_output_qname(This->output, prefix, prefix_len, local_name, local_len);
+ writer_inc_indent(This);
+
+ return S_OK;
+}
+
+static void write_escaped_string(xmlwriter *writer, const WCHAR *string)
+{
+ static const WCHAR ampW[] = {'&','a','m','p',';'};
+ static const WCHAR ltW[] = {'&','l','t',';'};
+ static const WCHAR gtW[] = {'&','g','t',';'};
+
+ while (*string)
+ {
+ switch (*string)
+ {
+ case '<':
+ write_output_buffer(writer->output, ltW, ARRAY_SIZE(ltW));
+ break;
+ case '&':
+ write_output_buffer(writer->output, ampW, ARRAY_SIZE(ampW));
+ break;
+ case '>':
+ write_output_buffer(writer->output, gtW, ARRAY_SIZE(gtW));
+ break;
+ default:
+ write_output_buffer(writer->output, string, 1);
+ }
+
+ string++;
+ }
}
-static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, LPCWSTR pwszText)
+static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, const WCHAR *string)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
+ TRACE("%p %s\n", This, debugstr_w(string));
- return E_NOTIMPL;
+ if (!string)
+ return S_OK;
+
+ switch (This->state)
+ {
+ case XmlWriterState_Initial:
+ return E_UNEXPECTED;
+ case XmlWriterState_ElemStarted:
+ writer_close_starttag(This);
+ break;
+ case XmlWriterState_Ready:
+ case XmlWriterState_DocClosed:
+ This->state = XmlWriterState_DocClosed;
+ return WR_E_INVALIDACTION;
+ case XmlWriterState_InvalidEncoding:
+ return MX_E_ENCODING;
+ default:
+ ;
+ }
+
+ This->textnode = 1;
+ write_escaped_string(This, string);
+ return S_OK;
}
static HRESULT WINAPI xmlwriter_WriteSurrogateCharEntity(IXmlWriter *iface, WCHAR wchLow, WCHAR wchHigh)
{
xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p\n", This);
+ TRACE("%p\n", This);
- return E_NOTIMPL;
+ return writeroutput_flush_stream(This->output);
}
static const struct IXmlWriterVtbl xmlwriter_vtbl =
{
IMalloc *imalloc = This->imalloc;
if (This->output) IUnknown_Release(This->output);
+ if (This->stream) ISequentialStream_Release(This->stream);
+ free_output_buffer(This);
+ writeroutput_free(This, This->encoding_name);
writeroutput_free(This, This);
if (imalloc) IMalloc_Release(imalloc);
}
xmlwriteroutput_Release
};
-HRESULT WINAPI CreateXmlWriter(REFIID riid, void **pObject, IMalloc *pMalloc)
+HRESULT WINAPI CreateXmlWriter(REFIID riid, void **obj, IMalloc *imalloc)
{
xmlwriter *writer;
+ HRESULT hr;
- TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), pObject, pMalloc);
+ TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
- if (pMalloc) FIXME("custom IMalloc not supported yet\n");
-
- if (!IsEqualGUID(riid, &IID_IXmlWriter))
- {
- ERR("Unexpected IID requested -> (%s)\n", wine_dbgstr_guid(riid));
- return E_FAIL;
- }
+ if (imalloc)
+ writer = IMalloc_Alloc(imalloc, sizeof(*writer));
+ else
+ writer = heap_alloc(sizeof(*writer));
+ if (!writer)
+ return E_OUTOFMEMORY;
- writer = heap_alloc(sizeof(*writer));
- if(!writer) return E_OUTOFMEMORY;
+ memset(writer, 0, sizeof(*writer));
writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl;
writer->ref = 1;
+ writer->imalloc = imalloc;
+ if (imalloc) IMalloc_AddRef(imalloc);
+ writer->bom = TRUE;
+ writer->conformance = XmlConformanceLevel_Document;
+ writer->state = XmlWriterState_Initial;
+ list_init(&writer->elements);
- *pObject = &writer->IXmlWriter_iface;
+ hr = IXmlWriter_QueryInterface(&writer->IXmlWriter_iface, riid, obj);
+ IXmlWriter_Release(&writer->IXmlWriter_iface);
- TRACE("returning iface %p\n", *pObject);
+ TRACE("returning iface %p, hr %#x\n", *obj, hr);
- return S_OK;
+ return hr;
}
-HRESULT WINAPI CreateXmlWriterOutputWithEncodingName(IUnknown *stream,
- IMalloc *imalloc,
- LPCWSTR encoding,
- IXmlWriterOutput **output)
+static HRESULT create_writer_output(IUnknown *stream, IMalloc *imalloc, xml_encoding encoding,
+ const WCHAR *encoding_name, xmlwriteroutput **out)
{
xmlwriteroutput *writeroutput;
+ HRESULT hr;
- TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), output);
-
- if (!stream || !output) return E_INVALIDARG;
+ *out = NULL;
if (imalloc)
writeroutput = IMalloc_Alloc(imalloc, sizeof(*writeroutput));
else
writeroutput = heap_alloc(sizeof(*writeroutput));
- if(!writeroutput) return E_OUTOFMEMORY;
+ if (!writeroutput)
+ return E_OUTOFMEMORY;
writeroutput->IXmlWriterOutput_iface.lpVtbl = &xmlwriteroutputvtbl;
writeroutput->ref = 1;
writeroutput->imalloc = imalloc;
- if (imalloc) IMalloc_AddRef(imalloc);
- writeroutput->encoding = parse_encoding_name(encoding, -1);
+ if (imalloc)
+ IMalloc_AddRef(imalloc);
+ writeroutput->encoding = encoding;
+ writeroutput->stream = NULL;
+ hr = init_output_buffer(writeroutput);
+ if (FAILED(hr)) {
+ IUnknown_Release(&writeroutput->IXmlWriterOutput_iface);
+ return hr;
+ }
+
+ if (encoding_name) {
+ unsigned int size = (lstrlenW(encoding_name) + 1) * sizeof(WCHAR);
+ writeroutput->encoding_name = writeroutput_alloc(writeroutput, size);
+ memcpy(writeroutput->encoding_name, encoding_name, size);
+ }
+ else
+ writeroutput->encoding_name = NULL;
+ writeroutput->written = 0;
IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&writeroutput->output);
- *output = &writeroutput->IXmlWriterOutput_iface;
+ *out = writeroutput;
- TRACE("returning iface %p\n", *output);
+ TRACE("Created writer output %p\n", *out);
return S_OK;
}
+
+HRESULT WINAPI CreateXmlWriterOutputWithEncodingName(IUnknown *stream, IMalloc *imalloc, const WCHAR *encoding,
+ IXmlWriterOutput **out)
+{
+ xmlwriteroutput *output;
+ xml_encoding xml_enc;
+ HRESULT hr;
+
+ TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), out);
+
+ if (!stream || !out)
+ return E_INVALIDARG;
+
+ *out = NULL;
+
+ xml_enc = encoding ? parse_encoding_name(encoding, -1) : XmlEncoding_UTF8;
+ if (SUCCEEDED(hr = create_writer_output(stream, imalloc, xml_enc, encoding, &output)))
+ *out = &output->IXmlWriterOutput_iface;
+
+ return hr;
+}
+
+HRESULT WINAPI CreateXmlWriterOutputWithEncodingCodePage(IUnknown *stream, IMalloc *imalloc, UINT codepage,
+ IXmlWriterOutput **out)
+{
+ xmlwriteroutput *output;
+ xml_encoding xml_enc;
+ HRESULT hr;
+
+ TRACE("%p %p %u %p\n", stream, imalloc, codepage, out);
+
+ if (!stream || !out)
+ return E_INVALIDARG;
+
+ *out = NULL;
+
+ xml_enc = get_encoding_from_codepage(codepage);
+ if (SUCCEEDED(hr = create_writer_output(stream, imalloc, xml_enc, NULL, &output)))
+ *out = &output->IXmlWriterOutput_iface;
+
+ return hr;
+}
projects / reactos.git / blobdiff