Author: akhaldi Date: Wed Oct 8 20:02:37 2014 New Revision: 64626
URL: http://svn.reactos.org/svn/reactos?rev=64626&view=rev Log: [XMLLITE] * Sync with Wine 1.7.27. CORE-8540
Modified: trunk/reactos/dll/win32/xmllite/reader.c trunk/reactos/dll/win32/xmllite/writer.c trunk/reactos/dll/win32/xmllite/xmllite_private.h trunk/reactos/media/doc/README.WINE
Modified: trunk/reactos/dll/win32/xmllite/reader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/xmllite/reader.c?... ============================================================================== --- trunk/reactos/dll/win32/xmllite/reader.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/xmllite/reader.c [iso-8859-1] Wed Oct 8 20:02:37 2014 @@ -113,7 +113,7 @@ return type_names[nodetype]; }
-static const char *debugstr_prop(XmlReaderProperty prop) +static const char *debugstr_reader_prop(XmlReaderProperty prop) { static const char * const prop_names[] = { @@ -144,6 +144,11 @@ { utf16W, XmlEncoding_UTF16, ~0 }, { utf8W, XmlEncoding_UTF8, CP_UTF8 } }; + +const WCHAR *get_encoding_name(xml_encoding encoding) +{ + return xml_encoding_map[encoding].name; +}
typedef struct { @@ -248,14 +253,6 @@ return CONTAINING_RECORD(iface, xmlreaderinput, IXmlReaderInput_iface); }
-static inline void *m_realloc(IMalloc *imalloc, void *mem, size_t len) -{ - if (imalloc) - return IMalloc_Realloc(imalloc, mem, len); - else - return heap_realloc(mem, len); -} - /* reader memory allocation functions */ static inline void *reader_alloc(xmlreader *reader, size_t len) { @@ -363,12 +360,6 @@ reader_free(reader, v->str); *v = strval_empty; } -} - -/* returns length in WCHARs from 'start' to current buffer offset */ -static inline UINT reader_get_len(const xmlreader *reader, UINT start) -{ - return reader->input->buffer->utf16.cur - start; }
static inline void reader_init_strvalue(UINT start, UINT len, strval *v) @@ -544,7 +535,7 @@ 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) { @@ -632,7 +623,7 @@
/* 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;
@@ -2507,7 +2498,7 @@ { /* 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); } @@ -2527,7 +2518,7 @@ { 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;
@@ -2551,7 +2542,7 @@ { xmlreader *This = impl_from_IXmlReader(iface);
- TRACE("(%p)->(%s %lu)\n", This, debugstr_prop(property), value); + TRACE("(%p)->(%s %lu)\n", This, debugstr_reader_prop(property), value);
switch (property) {
Modified: trunk/reactos/dll/win32/xmllite/writer.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/xmllite/writer.c?... ============================================================================== --- trunk/reactos/dll/win32/xmllite/writer.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/xmllite/writer.c [iso-8859-1] Wed Oct 8 20:02:37 2014 @@ -2,6 +2,7 @@ * IXmlWriter implementation * * Copyright 2011 Alistair Leslie-Hughes + * Copyright 2014 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 @@ -20,22 +21,71 @@
#include "xmllite_private.h"
+#include <wine/list.h> +#include <wine/unicode.h> + /* not defined in public headers */ DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a); + +#define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0])) + +static const WCHAR closeelementW[] = {'<','/'}; +static const WCHAR closepiW[] = {'?','>'}; +static const WCHAR ltW[] = {'<'}; +static const WCHAR gtW[] = {'>'}; + +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_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;
typedef struct { IXmlWriterOutput IXmlWriterOutput_iface; LONG ref; IUnknown *output; + ISequentialStream *stream; IMalloc *imalloc; xml_encoding encoding; + struct output_buffer buffer; } xmlwriteroutput; + +static const struct IUnknownVtbl xmlwriteroutputvtbl; + +struct element +{ + struct list entry; + WCHAR *qname; + unsigned int len; /* qname length in chars */ +};
typedef struct _xmlwriter { IXmlWriter IXmlWriter_iface; LONG ref; + IMalloc *imalloc; + xmlwriteroutput *output; + BOOL indent; + BOOL bom; + BOOL omitxmldecl; + XmlConformanceLevel conformance; + XmlWriterState state; + BOOL bomwritten; + BOOL starttagopen; + struct list elements; } xmlwriter;
static inline xmlwriter *impl_from_IXmlWriter(IXmlWriter *iface) @@ -48,7 +98,24 @@ return CONTAINING_RECORD(iface, xmlwriteroutput, IXmlWriterOutput_iface); }
-/* reader input memory allocation functions */ +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]; +} + +/* writer output memory allocation functions */ static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len) { return m_alloc(output->imalloc, len); @@ -57,6 +124,251 @@ 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(xmlwriter *writer, size_t len) +{ + return m_alloc(writer->imalloc, len); +} + +static inline void writer_free(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 ? strlenW(prefix) + 1 /* ':' */ : 0; + len += strlenW(local); + + ret->qname = writer_alloc(writer, (len + 1)*sizeof(WCHAR)); + ret->len = len; + if (prefix) { + static const WCHAR colonW[] = {':',0}; + strcpyW(ret->qname, prefix); + strcatW(ret->qname, colonW); + } + else + ret->qname[0] = 0; + strcatW(ret->qname, local); + + return ret; +} + +static void free_element(xmlwriter *writer, struct element *element) +{ + writer_free(writer, element->qname); + writer_free(writer, element); +} + +static void 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 HRESULT init_output_buffer(xmlwriteroutput *output) +{ + struct output_buffer *buffer = &output->buffer; + const int initial_len = 0x2000; + HRESULT hr; + UINT cp; + + hr = get_code_page(output->encoding, &cp); + if (FAILED(hr)) return hr; + + 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 != ~0) { + 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; + } + else { + /* WCHAR data just copied */ + length = len == -1 ? strlenW(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; + } + } + + return S_OK; +} + +static HRESULT write_output_buffer_quoted(xmlwriteroutput *output, const WCHAR *data, int len) +{ + static const WCHAR quoteW[] = {'"'}; + write_output_buffer(output, quoteW, ARRAY_SIZE(quoteW)); + write_output_buffer(output, data, len); + write_output_buffer(output, quoteW, ARRAY_SIZE(quoteW)); + return S_OK; +} + +/* TODO: test if we need to validate char range */ +static HRESULT write_output_qname(xmlwriteroutput *output, const WCHAR *prefix, const WCHAR *local_name) +{ + if (prefix) { + static const WCHAR colW[] = {':'}; + write_output_buffer(output, prefix, -1); + write_output_buffer(output, colW, ARRAY_SIZE(colW)); + } + + write_output_buffer(output, local_name, -1); + + 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 occured. */ + 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 HRESULT writer_close_starttag(xmlwriter *writer) +{ + HRESULT hr; + + if (!writer->starttagopen) return S_OK; + hr = write_output_buffer(writer->output, gtW, ARRAY_SIZE(gtW)); + writer->starttagopen = FALSE; + writer->state = XmlWriterState_Content; + return hr; }
static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject) @@ -91,38 +403,123 @@ TRACE("%p\n", This);
ref = InterlockedDecrement(&This->ref); - if (ref == 0) - heap_free(This); + if (ref == 0) { + struct element *element, *element2; + IMalloc *imalloc = This->imalloc; + + IXmlWriter_Flush(iface); + if (This->output) IUnknown_Release(&This->output->IXmlWriterOutput_iface); + + /* element stack */ + LIST_FOR_EACH_ENTRY_SAFE(element, element2, &This->elements, struct element, entry) { + list_remove(&element->entry); + free_element(This, element); + } + + writer_free(This, This); + if (imalloc) IMalloc_Release(imalloc); + }
return ref; }
/*** IXmlWriter methods ***/ -static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *pOutput) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %p\n", This, pOutput); - - return E_NOTIMPL; -} - -static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR *ppValue) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %u %p\n", This, nProperty, ppValue); - - return E_NOTIMPL; -} - -static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR pValue) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %u %lu\n", This, nProperty, pValue); - - return E_NOTIMPL; +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 = FALSE; + } + + /* 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 IXmlWriterOutput basing on supplied interface */ + hr = CreateXmlWriterOutputWithEncodingName(output, This->imalloc, NULL, &writeroutput); + if (hr != S_OK) return hr; + This->output = impl_from_IXmlWriterOutput(writeroutput); + } + + 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_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, @@ -186,16 +583,39 @@ return E_NOTIMPL; }
-static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR pwszPrefix, - LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri, - LPCWSTR pwszValue) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName), - wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue)); - - return E_NOTIMPL; +static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR prefix, + LPCWSTR local_name, LPCWSTR uri, LPCWSTR value) +{ + xmlwriter *This = impl_from_IXmlWriter(iface); + + 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)); + + switch (This->state) + { + case XmlWriterState_Initial: + return E_UNEXPECTED; + case XmlWriterState_ElemStarted: + writer_close_starttag(This); + break; + default: + ; + } + + write_encoding_bom(This); + write_output_buffer(This->output, ltW, ARRAY_SIZE(ltW)); + write_output_qname(This->output, prefix, local_name); + write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW)); + + if (value) + write_output_buffer(This->output, value, -1); + + write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW)); + write_output_qname(This->output, prefix, local_name); + write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW)); + This->state = XmlWriterState_Content; + + return S_OK; }
static HRESULT WINAPI xmlwriter_WriteEndDocument(IXmlWriter *iface) @@ -210,10 +630,27 @@ static HRESULT WINAPI xmlwriter_WriteEndElement(IXmlWriter *iface) { xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p\n", This); - - return E_NOTIMPL; + struct element *element; + + TRACE("%p\n", This); + + element = pop_element(This); + if (!element) + return WR_E_INVALIDACTION; + + if (This->starttagopen) { + static WCHAR closetagW[] = {' ','/','>'}; + write_output_buffer(This->output, closetagW, ARRAY_SIZE(closetagW)); + This->starttagopen = FALSE; + } + else { + /* 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(This->output, gtW, ARRAY_SIZE(gtW)); + } + + return S_OK; }
static HRESULT WINAPI xmlwriter_WriteEntityRef(IXmlWriter *iface, LPCWSTR pwszName) @@ -228,10 +665,21 @@ static HRESULT WINAPI xmlwriter_WriteFullEndElement(IXmlWriter *iface) { xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p\n", This); - - return E_NOTIMPL; + struct element *element; + + TRACE("%p\n", This); + + element = pop_element(This); + if (!element) + return WR_E_INVALIDACTION; + + /* 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(This->output, gtW, ARRAY_SIZE(gtW)); + This->starttagopen = FALSE; + + return S_OK; }
static HRESULT WINAPI xmlwriter_WriteName(IXmlWriter *iface, LPCWSTR pwszName) @@ -272,14 +720,41 @@ return E_NOTIMPL; }
-static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR pwszName, - LPCWSTR pwszText) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszText)); - - return E_NOTIMPL; +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[] = {'<','?'}; + static const WCHAR spaceW[] = {' '}; + + TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_w(name), wine_dbgstr_w(text)); + + switch (This->state) + { + case XmlWriterState_Initial: + return E_UNEXPECTED; + case XmlWriterState_DocStarted: + if (!strcmpW(name, xmlW)) + return WR_E_INVALIDACTION; + break; + case XmlWriterState_ElemStarted: + return WR_E_INVALIDACTION; + default: + ; + } + + write_encoding_bom(This); + write_output_buffer(This->output, openpiW, ARRAY_SIZE(openpiW)); + write_output_buffer(This->output, name, -1); + write_output_buffer(This->output, spaceW, ARRAY_SIZE(spaceW)); + write_output_buffer(This->output, text, -1); + write_output_buffer(This->output, closepiW, ARRAY_SIZE(closepiW)); + + if (!strcmpW(name, xmlW)) + This->state = XmlWriterState_PIDocStarted; + + return S_OK; }
static HRESULT WINAPI xmlwriter_WriteQualifiedName(IXmlWriter *iface, LPCWSTR pwszLocalName, @@ -312,22 +787,86 @@
static HRESULT WINAPI xmlwriter_WriteStartDocument(IXmlWriter *iface, XmlStandalone standalone) { - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p\n", This); - - return E_NOTIMPL; -} - -static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR pwszPrefix, - LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri) -{ - xmlwriter *This = impl_from_IXmlWriter(iface); - - FIXME("%p %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName), - wine_dbgstr_w(pwszNamespaceUri)); - - return E_NOTIMPL; + 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','='}; + xmlwriter *This = impl_from_IXmlWriter(iface); + + TRACE("(%p)->(%d)\n", This, standalone); + + switch (This->state) + { + case XmlWriterState_Initial: + return E_UNEXPECTED; + case XmlWriterState_PIDocStarted: + This->state = XmlWriterState_DocStarted; + return S_OK; + case XmlWriterState_DocStarted: + case XmlWriterState_ElemStarted: + return WR_E_INVALIDACTION; + default: + ; + } + + write_encoding_bom(This); + This->state = XmlWriterState_DocStarted; + if (This->omitxmldecl) return S_OK; + + /* version */ + write_output_buffer(This->output, versionW, ARRAY_SIZE(versionW)); + + /* encoding */ + write_output_buffer(This->output, encodingW, ARRAY_SIZE(encodingW)); + write_output_buffer_quoted(This->output, get_encoding_name(This->output->encoding), -1); + + /* standalone */ + if (standalone == XmlStandalone_Omit) + write_output_buffer(This->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(This->output, standaloneW, ARRAY_SIZE(standaloneW)); + if (standalone == XmlStandalone_Yes) + write_output_buffer(This->output, yesW, ARRAY_SIZE(yesW)); + else + write_output_buffer(This->output, noW, ARRAY_SIZE(noW)); + } + + return S_OK; +} + +static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR prefix, LPCWSTR local_name, LPCWSTR uri) +{ + xmlwriter *This = impl_from_IXmlWriter(iface); + struct element *element; + + TRACE("(%p)->(%s %s %s)\n", This, wine_dbgstr_w(prefix), wine_dbgstr_w(local_name), wine_dbgstr_w(uri)); + + if (This->state == XmlWriterState_Initial) + return E_UNEXPECTED; + + if (!local_name) + return E_INVALIDARG; + + /* close pending element */ + if (This->starttagopen) + write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW)); + + element = alloc_element(This, prefix, local_name); + if (!element) + return E_OUTOFMEMORY; + + write_encoding_bom(This); + This->state = XmlWriterState_ElemStarted; + This->starttagopen = TRUE; + + push_element(This, element); + + write_output_buffer(This->output, ltW, ARRAY_SIZE(ltW)); + write_output_qname(This->output, prefix, local_name); + + return S_OK; }
static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, LPCWSTR pwszText) @@ -361,9 +900,9 @@ { xmlwriter *This = impl_from_IXmlWriter(iface);
- FIXME("%p\n", This); - - return E_NOTIMPL; + TRACE("%p\n", This); + + return writeroutput_flush_stream(This->output); }
static const struct IXmlWriterVtbl xmlwriter_vtbl = @@ -445,6 +984,8 @@ { 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); if (imalloc) IMalloc_Release(imalloc); } @@ -459,13 +1000,11 @@ xmlwriteroutput_Release };
-HRESULT WINAPI CreateXmlWriter(REFIID riid, void **pObject, IMalloc *pMalloc) +HRESULT WINAPI CreateXmlWriter(REFIID riid, void **obj, IMalloc *imalloc) { xmlwriter *writer;
- TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), pObject, pMalloc); - - if (pMalloc) FIXME("custom IMalloc not supported yet\n"); + TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
if (!IsEqualGUID(riid, &IID_IXmlWriter)) { @@ -473,15 +1012,29 @@ return E_FAIL; }
- writer = heap_alloc(sizeof(*writer)); + if (imalloc) + writer = IMalloc_Alloc(imalloc, sizeof(*writer)); + else + writer = heap_alloc(sizeof(*writer)); if(!writer) return E_OUTOFMEMORY;
writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl; writer->ref = 1; - - *pObject = &writer->IXmlWriter_iface; - - TRACE("returning iface %p\n", *pObject); + writer->imalloc = imalloc; + if (imalloc) IMalloc_AddRef(imalloc); + writer->output = NULL; + writer->indent = FALSE; + writer->bom = TRUE; + writer->omitxmldecl = FALSE; + writer->conformance = XmlConformanceLevel_Document; + writer->state = XmlWriterState_Initial; + writer->bomwritten = FALSE; + writer->starttagopen = FALSE; + list_init(&writer->elements); + + *obj = &writer->IXmlWriter_iface; + + TRACE("returning iface %p\n", *obj);
return S_OK; } @@ -491,11 +1044,15 @@ LPCWSTR encoding, IXmlWriterOutput **output) { + static const WCHAR utf8W[] = {'U','T','F','-','8',0}; xmlwriteroutput *writeroutput; + HRESULT hr;
TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), output);
if (!stream || !output) return E_INVALIDARG; + + *output = NULL;
if (imalloc) writeroutput = IMalloc_Alloc(imalloc, sizeof(*writeroutput)); @@ -507,7 +1064,13 @@ writeroutput->ref = 1; writeroutput->imalloc = imalloc; if (imalloc) IMalloc_AddRef(imalloc); - writeroutput->encoding = parse_encoding_name(encoding, -1); + writeroutput->encoding = parse_encoding_name(encoding ? encoding : utf8W, -1); + writeroutput->stream = NULL; + hr = init_output_buffer(writeroutput); + if (FAILED(hr)) { + IUnknown_Release(&writeroutput->IXmlWriterOutput_iface); + return hr; + }
IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&writeroutput->output);
Modified: trunk/reactos/dll/win32/xmllite/xmllite_private.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/xmllite/xmllite_p... ============================================================================== --- trunk/reactos/dll/win32/xmllite/xmllite_private.h [iso-8859-1] (original) +++ trunk/reactos/dll/win32/xmllite/xmllite_private.h [iso-8859-1] Wed Oct 8 20:02:37 2014 @@ -63,6 +63,14 @@ return heap_alloc(len); }
+static inline void *m_realloc(IMalloc *imalloc, void *mem, size_t len) +{ + if (imalloc) + return IMalloc_Realloc(imalloc, mem, len); + else + return heap_realloc(mem, len); +} + static inline void m_free(IMalloc *imalloc, void *mem) { if (imalloc) @@ -78,6 +86,8 @@ XmlEncoding_Unknown } xml_encoding;
-xml_encoding parse_encoding_name(const WCHAR *name, int len) DECLSPEC_HIDDEN; +xml_encoding parse_encoding_name(const WCHAR*,int) DECLSPEC_HIDDEN; +HRESULT get_code_page(xml_encoding,UINT*) DECLSPEC_HIDDEN; +const WCHAR *get_encoding_name(xml_encoding) DECLSPEC_HIDDEN;
#endif /* __XMLLITE_PRIVATE__ */
Modified: trunk/reactos/media/doc/README.WINE URL: http://svn.reactos.org/svn/reactos/trunk/reactos/media/doc/README.WINE?rev=6... ============================================================================== --- trunk/reactos/media/doc/README.WINE [iso-8859-1] (original) +++ trunk/reactos/media/doc/README.WINE [iso-8859-1] Wed Oct 8 20:02:37 2014 @@ -227,7 +227,7 @@ reactos/dll/win32/xinput1_2 # Synced to Wine-1.7.17 reactos/dll/win32/xinput1_3 # Synced to Wine-1.7.17 reactos/dll/win32/xinput9_1_0 # Synced to Wine-1.7.17 -reactos/dll/win32/xmllite # Synced to Wine-1.7.17 +reactos/dll/win32/xmllite # Synced to Wine-1.7.27
reactos/dll/cpl/inetcpl # Synced to Wine-1.7.1