dlls/xmllite/writer.c

   1 /*
   2  * IXmlWriter implementation
   3  *
   4  * Copyright 2011 Alistair Leslie-Hughes
   5  * Copyright 2014, 2016 Nikolay Sivov for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27 #include "xmllite.h"
  28 #include "xmllite_private.h"
  29 #include "initguid.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/list.h"
  33 #include "wine/unicode.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(xmllite);
  36
  37 /* not defined in public headers */
  38 DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
  39
  40 #define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0]))
  41
  42 static const WCHAR closeelementW[] = {'<','/'};
  43 static const WCHAR closetagW[] = {' ','/','>'};
  44 static const WCHAR closepiW[] = {'?','>'};
  45 static const WCHAR ltW[] = {'<'};
  46 static const WCHAR gtW[] = {'>'};
  47 static const WCHAR spaceW[] = {' '};
  48 static const WCHAR quoteW[] = {'"'};
  49
  50 struct output_buffer
  51 {
  52     char *data;
  53     unsigned int allocated;
  54     unsigned int written;
  55     UINT codepage;
  56 };
  57
  58 typedef enum
  59 {
  60     XmlWriterState_Initial,         /* output is not set yet */
  61     XmlWriterState_Ready,           /* SetOutput() was called, ready to start */
  62     XmlWriterState_InvalidEncoding, /* SetOutput() was called, but output had invalid encoding */
  63     XmlWriterState_PIDocStarted,    /* document was started with manually added 'xml' PI */
  64     XmlWriterState_DocStarted,      /* document was started with WriteStartDocument() */
  65     XmlWriterState_ElemStarted,     /* writing element */
  66     XmlWriterState_Content,         /* content is accepted at this point */
  67     XmlWriterState_DocClosed        /* WriteEndDocument was called */
  68 } XmlWriterState;
  69
  70 typedef struct
  71 {
  72     IXmlWriterOutput IXmlWriterOutput_iface;
  73     LONG ref;
  74     IUnknown *output;
  75     ISequentialStream *stream;
  76     IMalloc *imalloc;
  77     xml_encoding encoding;
  78     WCHAR *encoding_name; /* exactly as specified on output creation */
  79     struct output_buffer buffer;
  80 } xmlwriteroutput;
  81
  82 static const struct IUnknownVtbl xmlwriteroutputvtbl;
  83
  84 struct element
  85 {
  86     struct list entry;
  87     WCHAR *qname;
  88     unsigned int len; /* qname length in chars */
  89 };
  90
  91 typedef struct _xmlwriter
  92 {
  93     IXmlWriter IXmlWriter_iface;
  94     LONG ref;
  95     IMalloc *imalloc;
  96     xmlwriteroutput *output;
  97     unsigned int indent_level;
  98     BOOL indent;
  99     BOOL bom;
 100     BOOL omitxmldecl;
 101     XmlConformanceLevel conformance;
 102     XmlWriterState state;
 103     BOOL bomwritten;
 104     BOOL starttagopen;
 105     struct list elements;
 106 } xmlwriter;
 107
 108 static inline xmlwriter *impl_from_IXmlWriter(IXmlWriter *iface)
 109 {
 110     return CONTAINING_RECORD(iface, xmlwriter, IXmlWriter_iface);
 111 }
 112
 113 static inline xmlwriteroutput *impl_from_IXmlWriterOutput(IXmlWriterOutput *iface)
 114 {
 115     return CONTAINING_RECORD(iface, xmlwriteroutput, IXmlWriterOutput_iface);
 116 }
 117
 118 static const char *debugstr_writer_prop(XmlWriterProperty prop)
 119 {
 120     static const char * const prop_names[] =
 121     {
 122         "MultiLanguage",
 123         "Indent",
 124         "ByteOrderMark",
 125         "OmitXmlDeclaration",
 126         "ConformanceLevel"
 127     };
 128
 129     if (prop > _XmlWriterProperty_Last)
 130         return wine_dbg_sprintf("unknown property=%d", prop);
 131
 132     return prop_names[prop];
 133 }
 134
 135 /* writer output memory allocation functions */
 136 static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len)
 137 {
 138     return m_alloc(output->imalloc, len);
 139 }
 140
 141 static inline void writeroutput_free(xmlwriteroutput *output, void *mem)
 142 {
 143     m_free(output->imalloc, mem);
 144 }
 145
 146 static inline void *writeroutput_realloc(xmlwriteroutput *output, void *mem, size_t len)
 147 {
 148     return m_realloc(output->imalloc, mem, len);
 149 }
 150
 151 /* writer memory allocation functions */
 152 static inline void *writer_alloc(xmlwriter *writer, size_t len)
 153 {
 154     return m_alloc(writer->imalloc, len);
 155 }
 156
 157 static inline void writer_free(xmlwriter *writer, void *mem)
 158 {
 159     m_free(writer->imalloc, mem);
 160 }
 161
 162 static struct element *alloc_element(xmlwriter *writer, const WCHAR *prefix, const WCHAR *local)
 163 {
 164     struct element *ret;
 165     int len;
 166
 167     ret = writer_alloc(writer, sizeof(*ret));
 168     if (!ret) return ret;
 169
 170     len = prefix ? strlenW(prefix) + 1 /* ':' */ : 0;
 171     len += strlenW(local);
 172
 173     ret->qname = writer_alloc(writer, (len + 1)*sizeof(WCHAR));
 174     ret->len = len;
 175     if (prefix) {
 176         static const WCHAR colonW[] = {':',0};
 177         strcpyW(ret->qname, prefix);
 178         strcatW(ret->qname, colonW);
 179     }
 180     else
 181         ret->qname[0] = 0;
 182     strcatW(ret->qname, local);
 183
 184     return ret;
 185 }
 186
 187 static void free_element(xmlwriter *writer, struct element *element)
 188 {
 189     writer_free(writer, element->qname);
 190     writer_free(writer, element);
 191 }
 192
 193 static void push_element(xmlwriter *writer, struct element *element)
 194 {
 195     list_add_head(&writer->elements, &element->entry);
 196 }
 197
 198 static struct element *pop_element(xmlwriter *writer)
 199 {
 200     struct element *element = LIST_ENTRY(list_head(&writer->elements), struct element, entry);
 201
 202     if (element)
 203         list_remove(&element->entry);
 204
 205     return element;
 206 }
 207
 208 static HRESULT init_output_buffer(xmlwriteroutput *output)
 209 {
 210     struct output_buffer *buffer = &output->buffer;
 211     const int initial_len = 0x2000;
 212     UINT cp = ~0u;
 213     HRESULT hr;
 214
 215     if (FAILED(hr = get_code_page(output->encoding, &cp)))
 216         WARN("Failed to get code page for specified encoding.\n");
 217
 218     buffer->data = writeroutput_alloc(output, initial_len);
 219     if (!buffer->data) return E_OUTOFMEMORY;
 220
 221     memset(buffer->data, 0, 4);
 222     buffer->allocated = initial_len;
 223     buffer->written = 0;
 224     buffer->codepage = cp;
 225
 226     return S_OK;
 227 }
 228
 229 static void free_output_buffer(xmlwriteroutput *output)
 230 {
 231     struct output_buffer *buffer = &output->buffer;
 232     writeroutput_free(output, buffer->data);
 233     buffer->data = NULL;
 234     buffer->allocated = 0;
 235     buffer->written = 0;
 236 }
 237
 238 static HRESULT grow_output_buffer(xmlwriteroutput *output, int length)
 239 {
 240     struct output_buffer *buffer = &output->buffer;
 241     /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
 242     if (buffer->allocated < buffer->written + length + 4) {
 243         int grown_size = max(2*buffer->allocated, buffer->allocated + length);
 244         char *ptr = writeroutput_realloc(output, buffer->data, grown_size);
 245         if (!ptr) return E_OUTOFMEMORY;
 246         buffer->data = ptr;
 247         buffer->allocated = grown_size;
 248     }
 249
 250     return S_OK;
 251 }
 252
 253 static HRESULT write_output_buffer(xmlwriteroutput *output, const WCHAR *data, int len)
 254 {
 255     struct output_buffer *buffer = &output->buffer;
 256     int length;
 257     HRESULT hr;
 258     char *ptr;
 259
 260     if (buffer->codepage == 1200) {
 261         /* For UTF-16 encoding just copy. */
 262         length = len == -1 ? strlenW(data) : len;
 263         if (length) {
 264             length *= sizeof(WCHAR);
 265
 266             hr = grow_output_buffer(output, length);
 267             if (FAILED(hr)) return hr;
 268             ptr = buffer->data + buffer->written;
 269
 270             memcpy(ptr, data, length);
 271             buffer->written += length;
 272             ptr += length;
 273             /* null termination */
 274             *(WCHAR*)ptr = 0;
 275         }
 276     }
 277     else {
 278         length = WideCharToMultiByte(buffer->codepage, 0, data, len, NULL, 0, NULL, NULL);
 279         hr = grow_output_buffer(output, length);
 280         if (FAILED(hr)) return hr;
 281         ptr = buffer->data + buffer->written;
 282         length = WideCharToMultiByte(buffer->codepage, 0, data, len, ptr, length, NULL, NULL);
 283         buffer->written += len == -1 ? length-1 : length;
 284     }
 285
 286     return S_OK;
 287 }
 288
 289 static HRESULT write_output_buffer_quoted(xmlwriteroutput *output, const WCHAR *data, int len)
 290 {
 291     write_output_buffer(output, quoteW, ARRAY_SIZE(quoteW));
 292     write_output_buffer(output, data, len);
 293     write_output_buffer(output, quoteW, ARRAY_SIZE(quoteW));
 294     return S_OK;
 295 }
 296
 297 /* TODO: test if we need to validate char range */
 298 static HRESULT write_output_qname(xmlwriteroutput *output, const WCHAR *prefix, const WCHAR *local_name)
 299 {
 300     if (prefix) {
 301         static const WCHAR colW[] = {':'};
 302         write_output_buffer(output, prefix, -1);
 303         write_output_buffer(output, colW, ARRAY_SIZE(colW));
 304     }
 305
 306     write_output_buffer(output, local_name, -1);
 307
 308     return S_OK;
 309 }
 310
 311 static void writeroutput_release_stream(xmlwriteroutput *writeroutput)
 312 {
 313     if (writeroutput->stream) {
 314         ISequentialStream_Release(writeroutput->stream);
 315         writeroutput->stream = NULL;
 316     }
 317 }
 318
 319 static inline HRESULT writeroutput_query_for_stream(xmlwriteroutput *writeroutput)
 320 {
 321     HRESULT hr;
 322
 323     writeroutput_release_stream(writeroutput);
 324     hr = IUnknown_QueryInterface(writeroutput->output, &IID_IStream, (void**)&writeroutput->stream);
 325     if (hr != S_OK)
 326         hr = IUnknown_QueryInterface(writeroutput->output, &IID_ISequentialStream, (void**)&writeroutput->stream);
 327
 328     return hr;
 329 }
 330
 331 static HRESULT writeroutput_flush_stream(xmlwriteroutput *output)
 332 {
 333     struct output_buffer *buffer;
 334     ULONG written, offset = 0;
 335     HRESULT hr;
 336
 337     if (!output || !output->stream)
 338         return S_OK;
 339
 340     buffer = &output->buffer;
 341
 342     /* It will loop forever until everything is written or an error occurred. */
 343     do {
 344         written = 0;
 345         hr = ISequentialStream_Write(output->stream, buffer->data + offset, buffer->written, &written);
 346         if (FAILED(hr)) {
 347             WARN("write to stream failed (0x%08x)\n", hr);
 348             buffer->written = 0;
 349             return hr;
 350         }
 351
 352         offset += written;
 353         buffer->written -= written;
 354     } while (buffer->written > 0);
 355
 356     return S_OK;
 357 }
 358
 359 static HRESULT write_encoding_bom(xmlwriter *writer)
 360 {
 361     if (!writer->bom || writer->bomwritten) return S_OK;
 362
 363     if (writer->output->encoding == XmlEncoding_UTF16) {
 364         static const char utf16bom[] = {0xff, 0xfe};
 365         struct output_buffer *buffer = &writer->output->buffer;
 366         int len = sizeof(utf16bom);
 367         HRESULT hr;
 368
 369         hr = grow_output_buffer(writer->output, len);
 370         if (FAILED(hr)) return hr;
 371         memcpy(buffer->data + buffer->written, utf16bom, len);
 372         buffer->written += len;
 373     }
 374
 375     writer->bomwritten = TRUE;
 376     return S_OK;
 377 }
 378
 379 static const WCHAR *get_output_encoding_name(xmlwriteroutput *output)
 380 {
 381     if (output->encoding_name)
 382         return output->encoding_name;
 383
 384     return get_encoding_name(output->encoding);
 385 }
 386
 387 static HRESULT write_xmldecl(xmlwriter *writer, XmlStandalone standalone)
 388 {
 389     static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"'};
 390     static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','='};
 391
 392     write_encoding_bom(writer);
 393     writer->state = XmlWriterState_DocStarted;
 394     if (writer->omitxmldecl) return S_OK;
 395
 396     /* version */
 397     write_output_buffer(writer->output, versionW, ARRAY_SIZE(versionW));
 398
 399     /* encoding */
 400     write_output_buffer(writer->output, encodingW, ARRAY_SIZE(encodingW));
 401     write_output_buffer_quoted(writer->output, get_output_encoding_name(writer->output), -1);
 402
 403     /* standalone */
 404     if (standalone == XmlStandalone_Omit)
 405         write_output_buffer(writer->output, closepiW, ARRAY_SIZE(closepiW));
 406     else {
 407         static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
 408         static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
 409         static const WCHAR noW[] = {'n','o','\"','?','>'};
 410
 411         write_output_buffer(writer->output, standaloneW, ARRAY_SIZE(standaloneW));
 412         if (standalone == XmlStandalone_Yes)
 413             write_output_buffer(writer->output, yesW, ARRAY_SIZE(yesW));
 414         else
 415             write_output_buffer(writer->output, noW, ARRAY_SIZE(noW));
 416     }
 417
 418     return S_OK;
 419 }
 420
 421 static HRESULT writer_close_starttag(xmlwriter *writer)
 422 {
 423     HRESULT hr;
 424
 425     if (!writer->starttagopen) return S_OK;
 426     hr = write_output_buffer(writer->output, gtW, ARRAY_SIZE(gtW));
 427     writer->starttagopen = FALSE;
 428     return hr;
 429 }
 430
 431 static void writer_inc_indent(xmlwriter *writer)
 432 {
 433     writer->indent_level++;
 434 }
 435
 436 static void writer_dec_indent(xmlwriter *writer)
 437 {
 438     if (writer->indent_level)
 439         writer->indent_level--;
 440 }
 441
 442 static void write_node_indent(xmlwriter *writer)
 443 {
 444     static const WCHAR dblspaceW[] = {' ',' '};
 445     static const WCHAR crlfW[] = {'\r','\n'};
 446     unsigned int indent_level = writer->indent_level;
 447
 448     if (!writer->indent)
 449         return;
 450
 451     /* Do state check to prevent newline inserted after BOM. It is assumed that
 452        state does not change between writing BOM and inserting indentation. */
 453     if (writer->output->buffer.written && writer->state != XmlWriterState_Ready)
 454         write_output_buffer(writer->output, crlfW, ARRAY_SIZE(crlfW));
 455     while (indent_level--)
 456         write_output_buffer(writer->output, dblspaceW, ARRAY_SIZE(dblspaceW));
 457 }
 458
 459 static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject)
 460 {
 461     xmlwriter *This = impl_from_IXmlWriter(iface);
 462
 463     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 464
 465     if (IsEqualGUID(riid, &IID_IXmlWriter) ||
 466         IsEqualGUID(riid, &IID_IUnknown))
 467     {
 468         *ppvObject = iface;
 469     }
 470     else
 471     {
 472         FIXME("interface %s is not supported\n", debugstr_guid(riid));
 473         *ppvObject = NULL;
 474         return E_NOINTERFACE;
 475     }
 476
 477     IXmlWriter_AddRef(iface);
 478
 479     return S_OK;
 480 }
 481
 482 static ULONG WINAPI xmlwriter_AddRef(IXmlWriter *iface)
 483 {
 484     xmlwriter *This = impl_from_IXmlWriter(iface);
 485     ULONG ref = InterlockedIncrement(&This->ref);
 486     TRACE("(%p)->(%u)\n", This, ref);
 487     return ref;
 488 }
 489
 490 static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
 491 {
 492     xmlwriter *This = impl_from_IXmlWriter(iface);
 493     ULONG ref = InterlockedDecrement(&This->ref);
 494
 495     TRACE("(%p)->(%u)\n", This, ref);
 496
 497     if (ref == 0) {
 498         struct element *element, *element2;
 499         IMalloc *imalloc = This->imalloc;
 500
 501         writeroutput_flush_stream(This->output);
 502         if (This->output) IUnknown_Release(&This->output->IXmlWriterOutput_iface);
 503
 504         /* element stack */
 505         LIST_FOR_EACH_ENTRY_SAFE(element, element2, &This->elements, struct element, entry) {
 506             list_remove(&element->entry);
 507             free_element(This, element);
 508         }
 509
 510         writer_free(This, This);
 511         if (imalloc) IMalloc_Release(imalloc);
 512     }
 513
 514     return ref;
 515 }
 516
 517 /*** IXmlWriter methods ***/
 518 static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *output)
 519 {
 520     xmlwriter *This = impl_from_IXmlWriter(iface);
 521     IXmlWriterOutput *writeroutput;
 522     HRESULT hr;
 523
 524     TRACE("(%p)->(%p)\n", This, output);
 525
 526     if (This->output) {
 527         writeroutput_release_stream(This->output);
 528         IUnknown_Release(&This->output->IXmlWriterOutput_iface);
 529         This->output = NULL;
 530         This->bomwritten = FALSE;
 531         This->indent_level = 0;
 532     }
 533
 534     /* just reset current output */
 535     if (!output) {
 536         This->state = XmlWriterState_Initial;
 537         return S_OK;
 538     }
 539
 540     /* now try IXmlWriterOutput, ISequentialStream, IStream */
 541     hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&writeroutput);
 542     if (hr == S_OK) {
 543         if (writeroutput->lpVtbl == &xmlwriteroutputvtbl)
 544             This->output = impl_from_IXmlWriterOutput(writeroutput);
 545         else {
 546             ERR("got external IXmlWriterOutput implementation: %p, vtbl=%p\n",
 547                 writeroutput, writeroutput->lpVtbl);
 548             IUnknown_Release(writeroutput);
 549             return E_FAIL;
 550         }
 551     }
 552
 553     if (hr != S_OK || !writeroutput) {
 554         /* create IXmlWriterOutput basing on supplied interface */
 555         hr = CreateXmlWriterOutputWithEncodingName(output, This->imalloc, NULL, &writeroutput);
 556         if (hr != S_OK) return hr;
 557         This->output = impl_from_IXmlWriterOutput(writeroutput);
 558     }
 559
 560     if (This->output->encoding == XmlEncoding_Unknown)
 561         This->state = XmlWriterState_InvalidEncoding;
 562     else
 563         This->state = XmlWriterState_Ready;
 564     return writeroutput_query_for_stream(This->output);
 565 }
 566
 567 static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT property, LONG_PTR *value)
 568 {
 569     xmlwriter *This = impl_from_IXmlWriter(iface);
 570
 571     TRACE("(%p)->(%s %p)\n", This, debugstr_writer_prop(property), value);
 572
 573     if (!value) return E_INVALIDARG;
 574
 575     switch (property)
 576     {
 577         case XmlWriterProperty_Indent:
 578             *value = This->indent;
 579             break;
 580         case XmlWriterProperty_ByteOrderMark:
 581             *value = This->bom;
 582             break;
 583         case XmlWriterProperty_OmitXmlDeclaration:
 584             *value = This->omitxmldecl;
 585             break;
 586         case XmlWriterProperty_ConformanceLevel:
 587             *value = This->conformance;
 588             break;
 589         default:
 590             FIXME("Unimplemented property (%u)\n", property);
 591             return E_NOTIMPL;
 592     }
 593
 594     return S_OK;
 595 }
 596
 597 static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT property, LONG_PTR value)
 598 {
 599     xmlwriter *This = impl_from_IXmlWriter(iface);
 600
 601     TRACE("(%p)->(%s %lu)\n", This, debugstr_writer_prop(property), value);
 602
 603     switch (property)
 604     {
 605         case XmlWriterProperty_Indent:
 606             This->indent = !!value;
 607             break;
 608         case XmlWriterProperty_ByteOrderMark:
 609             This->bom = !!value;
 610             break;
 611         case XmlWriterProperty_OmitXmlDeclaration:
 612             This->omitxmldecl = !!value;
 613             break;
 614         default:
 615             FIXME("Unimplemented property (%u)\n", property);
 616             return E_NOTIMPL;
 617     }
 618
 619     return S_OK;
 620 }
 621
 622 static HRESULT WINAPI xmlwriter_WriteAttributes(IXmlWriter *iface, IXmlReader *pReader,
 623                                   BOOL fWriteDefaultAttributes)
 624 {
 625     xmlwriter *This = impl_from_IXmlWriter(iface);
 626
 627     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 628
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR ns_prefix,
 633     LPCWSTR local_name, LPCWSTR ns_uri, LPCWSTR value)
 634 {
 635     static const WCHAR eqW[] = {'=','"'};
 636     xmlwriter *This = impl_from_IXmlWriter(iface);
 637
 638     TRACE("%p %s %s %s %s\n", This, debugstr_w(ns_prefix), debugstr_w(local_name),
 639                         debugstr_w(ns_uri), debugstr_w(value));
 640
 641     switch (This->state)
 642     {
 643     case XmlWriterState_Initial:
 644         return E_UNEXPECTED;
 645     case XmlWriterState_Ready:
 646     case XmlWriterState_DocClosed:
 647         This->state = XmlWriterState_DocClosed;
 648         return WR_E_INVALIDACTION;
 649     case XmlWriterState_InvalidEncoding:
 650         return MX_E_ENCODING;
 651     default:
 652         ;
 653     }
 654
 655     if (ns_prefix || ns_uri)
 656     {
 657         FIXME("namespaces are not supported.\n");
 658         return E_NOTIMPL;
 659     }
 660
 661     write_output_buffer(This->output, spaceW, ARRAY_SIZE(spaceW));
 662     write_output_buffer(This->output, local_name, -1);
 663     write_output_buffer(This->output, eqW, ARRAY_SIZE(eqW));
 664     write_output_buffer(This->output, value, -1);
 665     write_output_buffer(This->output, quoteW, ARRAY_SIZE(quoteW));
 666
 667     return S_OK;
 668 }
 669
 670 static void write_cdata_section(xmlwriteroutput *output, const WCHAR *data, int len)
 671 {
 672     static const WCHAR cdataopenW[] = {'<','!','[','C','D','A','T','A','['};
 673     static const WCHAR cdatacloseW[] = {']',']','>'};
 674     write_output_buffer(output, cdataopenW, ARRAY_SIZE(cdataopenW));
 675     if (data)
 676         write_output_buffer(output, data, len);
 677     write_output_buffer(output, cdatacloseW, ARRAY_SIZE(cdatacloseW));
 678 }
 679
 680 static HRESULT WINAPI xmlwriter_WriteCData(IXmlWriter *iface, LPCWSTR data)
 681 {
 682     xmlwriter *This = impl_from_IXmlWriter(iface);
 683     int len;
 684
 685     TRACE("%p %s\n", This, debugstr_w(data));
 686
 687     switch (This->state)
 688     {
 689     case XmlWriterState_Initial:
 690         return E_UNEXPECTED;
 691     case XmlWriterState_ElemStarted:
 692         writer_close_starttag(This);
 693         break;
 694     case XmlWriterState_Ready:
 695     case XmlWriterState_DocClosed:
 696         This->state = XmlWriterState_DocClosed;
 697         return WR_E_INVALIDACTION;
 698     case XmlWriterState_InvalidEncoding:
 699         return MX_E_ENCODING;
 700     default:
 701         ;
 702     }
 703
 704     len = data ? strlenW(data) : 0;
 705
 706     write_node_indent(This);
 707     if (!len)
 708         write_cdata_section(This->output, NULL, 0);
 709     else {
 710         static const WCHAR cdatacloseW[] = {']',']','>',0};
 711         while (len) {
 712             const WCHAR *str = strstrW(data, cdatacloseW);
 713             if (str) {
 714                 str += 2;
 715                 write_cdata_section(This->output, data, str - data);
 716                 len -= str - data;
 717                 data = str;
 718             }
 719             else {
 720                 write_cdata_section(This->output, data, len);
 721                 break;
 722             }
 723         }
 724     }
 725
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR ch)
 730 {
 731     static const WCHAR fmtW[] = {'&','#','x','%','x',';',0};
 732     xmlwriter *This = impl_from_IXmlWriter(iface);
 733     WCHAR bufW[16];
 734
 735     TRACE("%p %#x\n", This, ch);
 736
 737     switch (This->state)
 738     {
 739     case XmlWriterState_Initial:
 740         return E_UNEXPECTED;
 741     case XmlWriterState_InvalidEncoding:
 742         return MX_E_ENCODING;
 743     case XmlWriterState_ElemStarted:
 744         writer_close_starttag(This);
 745         break;
 746     case XmlWriterState_DocClosed:
 747         return WR_E_INVALIDACTION;
 748     default:
 749         ;
 750     }
 751
 752     sprintfW(bufW, fmtW, ch);
 753     write_output_buffer(This->output, bufW, -1);
 754
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI xmlwriter_WriteChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
 759 {
 760     xmlwriter *This = impl_from_IXmlWriter(iface);
 761
 762     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
 763
 764     switch (This->state)
 765     {
 766     case XmlWriterState_Initial:
 767         return E_UNEXPECTED;
 768     case XmlWriterState_InvalidEncoding:
 769         return MX_E_ENCODING;
 770     case XmlWriterState_DocClosed:
 771         return WR_E_INVALIDACTION;
 772     default:
 773         ;
 774     }
 775
 776     return E_NOTIMPL;
 777 }
 778
 779
 780 static HRESULT WINAPI xmlwriter_WriteComment(IXmlWriter *iface, LPCWSTR comment)
 781 {
 782     static const WCHAR copenW[] = {'<','!','-','-'};
 783     static const WCHAR ccloseW[] = {'-','-','>'};
 784     xmlwriter *This = impl_from_IXmlWriter(iface);
 785
 786     TRACE("%p %s\n", This, debugstr_w(comment));
 787
 788     switch (This->state)
 789     {
 790     case XmlWriterState_Initial:
 791         return E_UNEXPECTED;
 792     case XmlWriterState_InvalidEncoding:
 793         return MX_E_ENCODING;
 794     case XmlWriterState_ElemStarted:
 795         writer_close_starttag(This);
 796         break;
 797     case XmlWriterState_DocClosed:
 798         return WR_E_INVALIDACTION;
 799     default:
 800         ;
 801     }
 802
 803     write_node_indent(This);
 804     write_output_buffer(This->output, copenW, ARRAY_SIZE(copenW));
 805     if (comment) {
 806         int len = strlenW(comment), i;
 807
 808         /* Make sure there's no two hyphen sequences in a string, space is used as a separator to produce compliant
 809            comment string */
 810         if (len > 1) {
 811             for (i = 0; i < len; i++) {
 812                 write_output_buffer(This->output, comment + i, 1);
 813                 if (comment[i] == '-' && (i + 1 < len) && comment[i+1] == '-')
 814                     write_output_buffer(This->output, spaceW, ARRAY_SIZE(spaceW));
 815             }
 816         }
 817         else
 818             write_output_buffer(This->output, comment, len);
 819
 820         if (len && comment[len-1] == '-')
 821             write_output_buffer(This->output, spaceW, ARRAY_SIZE(spaceW));
 822     }
 823     write_output_buffer(This->output, ccloseW, ARRAY_SIZE(ccloseW));
 824
 825     return S_OK;
 826 }
 827
 828 static HRESULT WINAPI xmlwriter_WriteDocType(IXmlWriter *iface, LPCWSTR pwszName, LPCWSTR pwszPublicId,
 829                                LPCWSTR pwszSystemId, LPCWSTR pwszSubset)
 830 {
 831     xmlwriter *This = impl_from_IXmlWriter(iface);
 832
 833     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszPublicId),
 834                         wine_dbgstr_w(pwszSystemId), wine_dbgstr_w(pwszSubset));
 835
 836     return E_NOTIMPL;
 837 }
 838
 839 static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR prefix,
 840                                      LPCWSTR local_name, LPCWSTR uri, LPCWSTR value)
 841 {
 842     xmlwriter *This = impl_from_IXmlWriter(iface);
 843
 844     TRACE("(%p)->(%s %s %s %s)\n", This, wine_dbgstr_w(prefix), wine_dbgstr_w(local_name),
 845                         wine_dbgstr_w(uri), wine_dbgstr_w(value));
 846
 847     switch (This->state)
 848     {
 849     case XmlWriterState_Initial:
 850         return E_UNEXPECTED;
 851     case XmlWriterState_InvalidEncoding:
 852         return MX_E_ENCODING;
 853     case XmlWriterState_ElemStarted:
 854         writer_close_starttag(This);
 855         break;
 856     case XmlWriterState_DocClosed:
 857         return WR_E_INVALIDACTION;
 858     default:
 859         ;
 860     }
 861
 862     write_encoding_bom(This);
 863     write_node_indent(This);
 864     write_output_buffer(This->output, ltW, ARRAY_SIZE(ltW));
 865     write_output_qname(This->output, prefix, local_name);
 866
 867     if (value)
 868     {
 869         write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW));
 870         write_output_buffer(This->output, value, -1);
 871         write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
 872         write_output_qname(This->output, prefix, local_name);
 873         write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW));
 874     }
 875     else
 876         write_output_buffer(This->output, closetagW, ARRAY_SIZE(closetagW));
 877
 878     This->state = XmlWriterState_Content;
 879
 880     return S_OK;
 881 }
 882
 883 static HRESULT WINAPI xmlwriter_WriteEndDocument(IXmlWriter *iface)
 884 {
 885     xmlwriter *This = impl_from_IXmlWriter(iface);
 886
 887     TRACE("%p\n", This);
 888
 889     switch (This->state)
 890     {
 891     case XmlWriterState_Initial:
 892         return E_UNEXPECTED;
 893     case XmlWriterState_Ready:
 894     case XmlWriterState_DocClosed:
 895         This->state = XmlWriterState_DocClosed;
 896         return WR_E_INVALIDACTION;
 897     case XmlWriterState_InvalidEncoding:
 898         return MX_E_ENCODING;
 899     default:
 900         ;
 901     }
 902
 903     /* empty element stack */
 904     while (IXmlWriter_WriteEndElement(iface) == S_OK)
 905         ;
 906
 907     This->state = XmlWriterState_DocClosed;
 908     return S_OK;
 909 }
 910
 911 static HRESULT WINAPI xmlwriter_WriteEndElement(IXmlWriter *iface)
 912 {
 913     xmlwriter *This = impl_from_IXmlWriter(iface);
 914     struct element *element;
 915
 916     TRACE("%p\n", This);
 917
 918     switch (This->state)
 919     {
 920     case XmlWriterState_Initial:
 921         return E_UNEXPECTED;
 922     case XmlWriterState_Ready:
 923     case XmlWriterState_DocClosed:
 924         This->state = XmlWriterState_DocClosed;
 925         return WR_E_INVALIDACTION;
 926     case XmlWriterState_InvalidEncoding:
 927         return MX_E_ENCODING;
 928     default:
 929         ;
 930     }
 931
 932     element = pop_element(This);
 933     if (!element)
 934         return WR_E_INVALIDACTION;
 935
 936     writer_dec_indent(This);
 937
 938     if (This->starttagopen)
 939     {
 940         write_output_buffer(This->output, closetagW, ARRAY_SIZE(closetagW));
 941         This->starttagopen = FALSE;
 942     }
 943     else {
 944         /* write full end tag */
 945         write_node_indent(This);
 946         write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
 947         write_output_buffer(This->output, element->qname, element->len);
 948         write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW));
 949     }
 950
 951     return S_OK;
 952 }
 953
 954 static HRESULT WINAPI xmlwriter_WriteEntityRef(IXmlWriter *iface, LPCWSTR pwszName)
 955 {
 956     xmlwriter *This = impl_from_IXmlWriter(iface);
 957
 958     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
 959
 960     switch (This->state)
 961     {
 962     case XmlWriterState_Initial:
 963         return E_UNEXPECTED;
 964     case XmlWriterState_InvalidEncoding:
 965         return MX_E_ENCODING;
 966     case XmlWriterState_DocClosed:
 967         return WR_E_INVALIDACTION;
 968     default:
 969         ;
 970     }
 971
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI xmlwriter_WriteFullEndElement(IXmlWriter *iface)
 976 {
 977     xmlwriter *This = impl_from_IXmlWriter(iface);
 978     struct element *element;
 979
 980     TRACE("%p\n", This);
 981
 982     switch (This->state)
 983     {
 984     case XmlWriterState_Initial:
 985         return E_UNEXPECTED;
 986     case XmlWriterState_Ready:
 987     case XmlWriterState_DocClosed:
 988         This->state = XmlWriterState_DocClosed;
 989         return WR_E_INVALIDACTION;
 990     case XmlWriterState_InvalidEncoding:
 991         return MX_E_ENCODING;
 992     default:
 993         ;
 994     }
 995
 996     element = pop_element(This);
 997     if (!element)
 998         return WR_E_INVALIDACTION;
 999
1000     writer_close_starttag(This);
1001     writer_dec_indent(This);
1002
1003     /* don't force full end tag to the next line */
1004     if (This->state == XmlWriterState_ElemStarted)
1005         This->state = XmlWriterState_Content;
1006     else
1007         write_node_indent(This);
1008
1009     /* write full end tag */
1010     write_output_buffer(This->output, closeelementW, ARRAY_SIZE(closeelementW));
1011     write_output_buffer(This->output, element->qname, element->len);
1012     write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW));
1013
1014     return S_OK;
1015 }
1016
1017 static HRESULT WINAPI xmlwriter_WriteName(IXmlWriter *iface, LPCWSTR pwszName)
1018 {
1019     xmlwriter *This = impl_from_IXmlWriter(iface);
1020
1021     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
1022
1023     switch (This->state)
1024     {
1025     case XmlWriterState_Initial:
1026         return E_UNEXPECTED;
1027     case XmlWriterState_Ready:
1028     case XmlWriterState_DocClosed:
1029         This->state = XmlWriterState_DocClosed;
1030         return WR_E_INVALIDACTION;
1031     case XmlWriterState_InvalidEncoding:
1032         return MX_E_ENCODING;
1033     default:
1034         ;
1035     }
1036
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI xmlwriter_WriteNmToken(IXmlWriter *iface, LPCWSTR pwszNmToken)
1041 {
1042     xmlwriter *This = impl_from_IXmlWriter(iface);
1043
1044     FIXME("%p %s\n", This, wine_dbgstr_w(pwszNmToken));
1045
1046     switch (This->state)
1047     {
1048     case XmlWriterState_Initial:
1049         return E_UNEXPECTED;
1050     case XmlWriterState_Ready:
1051     case XmlWriterState_DocClosed:
1052         This->state = XmlWriterState_DocClosed;
1053         return WR_E_INVALIDACTION;
1054     case XmlWriterState_InvalidEncoding:
1055         return MX_E_ENCODING;
1056     default:
1057         ;
1058     }
1059
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI xmlwriter_WriteNode(IXmlWriter *iface, IXmlReader *pReader,
1064                             BOOL fWriteDefaultAttributes)
1065 {
1066     xmlwriter *This = impl_from_IXmlWriter(iface);
1067
1068     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
1069
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI xmlwriter_WriteNodeShallow(IXmlWriter *iface, IXmlReader *pReader,
1074                                    BOOL fWriteDefaultAttributes)
1075 {
1076     xmlwriter *This = impl_from_IXmlWriter(iface);
1077
1078     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
1079
1080     return E_NOTIMPL;
1081 }
1082
1083 static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR name,
1084                                              LPCWSTR text)
1085 {
1086     xmlwriter *This = impl_from_IXmlWriter(iface);
1087     static const WCHAR xmlW[] = {'x','m','l',0};
1088     static const WCHAR openpiW[] = {'<','?'};
1089
1090     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_w(name), wine_dbgstr_w(text));
1091
1092     switch (This->state)
1093     {
1094     case XmlWriterState_Initial:
1095         return E_UNEXPECTED;
1096     case XmlWriterState_InvalidEncoding:
1097         return MX_E_ENCODING;
1098     case XmlWriterState_DocStarted:
1099         if (!strcmpW(name, xmlW))
1100             return WR_E_INVALIDACTION;
1101         break;
1102     case XmlWriterState_ElemStarted:
1103     case XmlWriterState_DocClosed:
1104         return WR_E_INVALIDACTION;
1105     default:
1106         ;
1107     }
1108
1109     write_encoding_bom(This);
1110     write_node_indent(This);
1111     write_output_buffer(This->output, openpiW, ARRAY_SIZE(openpiW));
1112     write_output_buffer(This->output, name, -1);
1113     write_output_buffer(This->output, spaceW, ARRAY_SIZE(spaceW));
1114     write_output_buffer(This->output, text, -1);
1115     write_output_buffer(This->output, closepiW, ARRAY_SIZE(closepiW));
1116
1117     if (!strcmpW(name, xmlW))
1118         This->state = XmlWriterState_PIDocStarted;
1119
1120     return S_OK;
1121 }
1122
1123 static HRESULT WINAPI xmlwriter_WriteQualifiedName(IXmlWriter *iface, LPCWSTR pwszLocalName,
1124                                      LPCWSTR pwszNamespaceUri)
1125 {
1126     xmlwriter *This = impl_from_IXmlWriter(iface);
1127
1128     FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszLocalName), wine_dbgstr_w(pwszNamespaceUri));
1129
1130     switch (This->state)
1131     {
1132     case XmlWriterState_Initial:
1133         return E_UNEXPECTED;
1134     case XmlWriterState_InvalidEncoding:
1135         return MX_E_ENCODING;
1136     case XmlWriterState_DocClosed:
1137         return WR_E_INVALIDACTION;
1138     default:
1139         ;
1140     }
1141
1142     return E_NOTIMPL;
1143 }
1144
1145 static HRESULT WINAPI xmlwriter_WriteRaw(IXmlWriter *iface, LPCWSTR data)
1146 {
1147     xmlwriter *This = impl_from_IXmlWriter(iface);
1148
1149     TRACE("%p %s\n", This, debugstr_w(data));
1150
1151     if (!data)
1152         return S_OK;
1153
1154     switch (This->state)
1155     {
1156     case XmlWriterState_Initial:
1157         return E_UNEXPECTED;
1158     case XmlWriterState_Ready:
1159         write_xmldecl(This, XmlStandalone_Omit);
1160         /* fallthrough */
1161     case XmlWriterState_DocStarted:
1162     case XmlWriterState_PIDocStarted:
1163         break;
1164     case XmlWriterState_InvalidEncoding:
1165         return MX_E_ENCODING;
1166     default:
1167         This->state = XmlWriterState_DocClosed;
1168         return WR_E_INVALIDACTION;
1169     }
1170
1171     write_output_buffer(This->output, data, -1);
1172     return S_OK;
1173 }
1174
1175 static HRESULT WINAPI xmlwriter_WriteRawChars(IXmlWriter *iface,  const WCHAR *pwch, UINT cwch)
1176 {
1177     xmlwriter *This = impl_from_IXmlWriter(iface);
1178
1179     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
1180
1181     switch (This->state)
1182     {
1183     case XmlWriterState_Initial:
1184         return E_UNEXPECTED;
1185     case XmlWriterState_InvalidEncoding:
1186         return MX_E_ENCODING;
1187     case XmlWriterState_DocClosed:
1188         return WR_E_INVALIDACTION;
1189     default:
1190         ;
1191     }
1192
1193     return E_NOTIMPL;
1194 }
1195
1196 static HRESULT WINAPI xmlwriter_WriteStartDocument(IXmlWriter *iface, XmlStandalone standalone)
1197 {
1198     xmlwriter *This = impl_from_IXmlWriter(iface);
1199
1200     TRACE("(%p)->(%d)\n", This, standalone);
1201
1202     switch (This->state)
1203     {
1204     case XmlWriterState_Initial:
1205         return E_UNEXPECTED;
1206     case XmlWriterState_PIDocStarted:
1207         This->state = XmlWriterState_DocStarted;
1208         return S_OK;
1209     case XmlWriterState_Ready:
1210         break;
1211     case XmlWriterState_InvalidEncoding:
1212         return MX_E_ENCODING;
1213     default:
1214         This->state = XmlWriterState_DocClosed;
1215         return WR_E_INVALIDACTION;
1216     }
1217
1218     return write_xmldecl(This, standalone);
1219 }
1220
1221 static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR prefix, LPCWSTR local_name, LPCWSTR uri)
1222 {
1223     xmlwriter *This = impl_from_IXmlWriter(iface);
1224     struct element *element;
1225
1226     TRACE("(%p)->(%s %s %s)\n", This, wine_dbgstr_w(prefix), wine_dbgstr_w(local_name), wine_dbgstr_w(uri));
1227
1228     if (!local_name)
1229         return E_INVALIDARG;
1230
1231     switch (This->state)
1232     {
1233     case XmlWriterState_Initial:
1234         return E_UNEXPECTED;
1235     case XmlWriterState_InvalidEncoding:
1236         return MX_E_ENCODING;
1237     case XmlWriterState_DocClosed:
1238         return WR_E_INVALIDACTION;
1239     default:
1240         ;
1241     }
1242
1243     /* close pending element */
1244     if (This->starttagopen)
1245         write_output_buffer(This->output, gtW, ARRAY_SIZE(gtW));
1246
1247     element = alloc_element(This, prefix, local_name);
1248     if (!element)
1249         return E_OUTOFMEMORY;
1250
1251     write_encoding_bom(This);
1252     write_node_indent(This);
1253
1254     This->state = XmlWriterState_ElemStarted;
1255     This->starttagopen = TRUE;
1256
1257     push_element(This, element);
1258
1259     write_output_buffer(This->output, ltW, ARRAY_SIZE(ltW));
1260     write_output_qname(This->output, prefix, local_name);
1261     writer_inc_indent(This);
1262
1263     return S_OK;
1264 }
1265
1266 static void write_escaped_string(xmlwriter *writer, const WCHAR *string)
1267 {
1268     static const WCHAR ampW[] = {'&','a','m','p',';'};
1269     static const WCHAR ltW[] = {'&','l','t',';'};
1270     static const WCHAR gtW[] = {'&','g','t',';'};
1271
1272     while (*string)
1273     {
1274         switch (*string)
1275         {
1276         case '<':
1277             write_output_buffer(writer->output, ltW, ARRAY_SIZE(ltW));
1278             break;
1279         case '&':
1280             write_output_buffer(writer->output, ampW, ARRAY_SIZE(ampW));
1281             break;
1282         case '>':
1283             write_output_buffer(writer->output, gtW, ARRAY_SIZE(gtW));
1284             break;
1285         default:
1286             write_output_buffer(writer->output, string, 1);
1287         }
1288
1289         string++;
1290     }
1291 }
1292
1293 static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, const WCHAR *string)
1294 {
1295     xmlwriter *This = impl_from_IXmlWriter(iface);
1296
1297     TRACE("%p %s\n", This, debugstr_w(string));
1298
1299     if (!string)
1300         return S_OK;
1301
1302     switch (This->state)
1303     {
1304     case XmlWriterState_Initial:
1305         return E_UNEXPECTED;
1306     case XmlWriterState_ElemStarted:
1307         writer_close_starttag(This);
1308         break;
1309     case XmlWriterState_Ready:
1310     case XmlWriterState_DocClosed:
1311         This->state = XmlWriterState_DocClosed;
1312         return WR_E_INVALIDACTION;
1313     case XmlWriterState_InvalidEncoding:
1314         return MX_E_ENCODING;
1315     default:
1316         ;
1317     }
1318
1319     write_escaped_string(This, string);
1320     return S_OK;
1321 }
1322
1323 static HRESULT WINAPI xmlwriter_WriteSurrogateCharEntity(IXmlWriter *iface, WCHAR wchLow, WCHAR wchHigh)
1324 {
1325     xmlwriter *This = impl_from_IXmlWriter(iface);
1326
1327     FIXME("%p %d %d\n", This, wchLow, wchHigh);
1328
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI xmlwriter_WriteWhitespace(IXmlWriter *iface, LPCWSTR pwszWhitespace)
1333 {
1334     xmlwriter *This = impl_from_IXmlWriter(iface);
1335
1336     FIXME("%p %s\n", This, wine_dbgstr_w(pwszWhitespace));
1337
1338     return E_NOTIMPL;
1339 }
1340
1341 static HRESULT WINAPI xmlwriter_Flush(IXmlWriter *iface)
1342 {
1343     xmlwriter *This = impl_from_IXmlWriter(iface);
1344
1345     TRACE("%p\n", This);
1346
1347     return writeroutput_flush_stream(This->output);
1348 }
1349
1350 static const struct IXmlWriterVtbl xmlwriter_vtbl =
1351 {
1352     xmlwriter_QueryInterface,
1353     xmlwriter_AddRef,
1354     xmlwriter_Release,
1355     xmlwriter_SetOutput,
1356     xmlwriter_GetProperty,
1357     xmlwriter_SetProperty,
1358     xmlwriter_WriteAttributes,
1359     xmlwriter_WriteAttributeString,
1360     xmlwriter_WriteCData,
1361     xmlwriter_WriteCharEntity,
1362     xmlwriter_WriteChars,
1363     xmlwriter_WriteComment,
1364     xmlwriter_WriteDocType,
1365     xmlwriter_WriteElementString,
1366     xmlwriter_WriteEndDocument,
1367     xmlwriter_WriteEndElement,
1368     xmlwriter_WriteEntityRef,
1369     xmlwriter_WriteFullEndElement,
1370     xmlwriter_WriteName,
1371     xmlwriter_WriteNmToken,
1372     xmlwriter_WriteNode,
1373     xmlwriter_WriteNodeShallow,
1374     xmlwriter_WriteProcessingInstruction,
1375     xmlwriter_WriteQualifiedName,
1376     xmlwriter_WriteRaw,
1377     xmlwriter_WriteRawChars,
1378     xmlwriter_WriteStartDocument,
1379     xmlwriter_WriteStartElement,
1380     xmlwriter_WriteString,
1381     xmlwriter_WriteSurrogateCharEntity,
1382     xmlwriter_WriteWhitespace,
1383     xmlwriter_Flush
1384 };
1385
1386 /** IXmlWriterOutput **/
1387 static HRESULT WINAPI xmlwriteroutput_QueryInterface(IXmlWriterOutput *iface, REFIID riid, void** ppvObject)
1388 {
1389     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
1390
1391     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1392
1393     if (IsEqualGUID(riid, &IID_IXmlWriterOutput) ||
1394         IsEqualGUID(riid, &IID_IUnknown))
1395     {
1396         *ppvObject = iface;
1397     }
1398     else
1399     {
1400         WARN("interface %s not implemented\n", debugstr_guid(riid));
1401         *ppvObject = NULL;
1402         return E_NOINTERFACE;
1403     }
1404
1405     IUnknown_AddRef(iface);
1406
1407     return S_OK;
1408 }
1409
1410 static ULONG WINAPI xmlwriteroutput_AddRef(IXmlWriterOutput *iface)
1411 {
1412     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
1413     ULONG ref = InterlockedIncrement(&This->ref);
1414     TRACE("(%p)->(%d)\n", This, ref);
1415     return ref;
1416 }
1417
1418 static ULONG WINAPI xmlwriteroutput_Release(IXmlWriterOutput *iface)
1419 {
1420     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
1421     LONG ref = InterlockedDecrement(&This->ref);
1422
1423     TRACE("(%p)->(%d)\n", This, ref);
1424
1425     if (ref == 0)
1426     {
1427         IMalloc *imalloc = This->imalloc;
1428         if (This->output) IUnknown_Release(This->output);
1429         if (This->stream) ISequentialStream_Release(This->stream);
1430         free_output_buffer(This);
1431         writeroutput_free(This, This->encoding_name);
1432         writeroutput_free(This, This);
1433         if (imalloc) IMalloc_Release(imalloc);
1434     }
1435
1436     return ref;
1437 }
1438
1439 static const struct IUnknownVtbl xmlwriteroutputvtbl =
1440 {
1441     xmlwriteroutput_QueryInterface,
1442     xmlwriteroutput_AddRef,
1443     xmlwriteroutput_Release
1444 };
1445
1446 HRESULT WINAPI CreateXmlWriter(REFIID riid, void **obj, IMalloc *imalloc)
1447 {
1448     xmlwriter *writer;
1449     HRESULT hr;
1450
1451     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
1452
1453     if (imalloc)
1454         writer = IMalloc_Alloc(imalloc, sizeof(*writer));
1455     else
1456         writer = heap_alloc(sizeof(*writer));
1457     if(!writer) return E_OUTOFMEMORY;
1458
1459     writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl;
1460     writer->ref = 1;
1461     writer->imalloc = imalloc;
1462     if (imalloc) IMalloc_AddRef(imalloc);
1463     writer->output = NULL;
1464     writer->indent_level = 0;
1465     writer->indent = FALSE;
1466     writer->bom = TRUE;
1467     writer->omitxmldecl = FALSE;
1468     writer->conformance = XmlConformanceLevel_Document;
1469     writer->state = XmlWriterState_Initial;
1470     writer->bomwritten = FALSE;
1471     writer->starttagopen = FALSE;
1472     list_init(&writer->elements);
1473
1474     hr = IXmlWriter_QueryInterface(&writer->IXmlWriter_iface, riid, obj);
1475     IXmlWriter_Release(&writer->IXmlWriter_iface);
1476
1477     TRACE("returning iface %p, hr %#x\n", *obj, hr);
1478
1479     return hr;
1480 }
1481
1482 static HRESULT create_writer_output(IUnknown *stream, IMalloc *imalloc, xml_encoding encoding,
1483     const WCHAR *encoding_name, IXmlWriterOutput **output)
1484 {
1485     xmlwriteroutput *writeroutput;
1486     HRESULT hr;
1487
1488     *output = NULL;
1489
1490     if (imalloc)
1491         writeroutput = IMalloc_Alloc(imalloc, sizeof(*writeroutput));
1492     else
1493         writeroutput = heap_alloc(sizeof(*writeroutput));
1494     if (!writeroutput)
1495         return E_OUTOFMEMORY;
1496
1497     writeroutput->IXmlWriterOutput_iface.lpVtbl = &xmlwriteroutputvtbl;
1498     writeroutput->ref = 1;
1499     writeroutput->imalloc = imalloc;
1500     if (imalloc)
1501         IMalloc_AddRef(imalloc);
1502     writeroutput->encoding = encoding;
1503     writeroutput->stream = NULL;
1504     hr = init_output_buffer(writeroutput);
1505     if (FAILED(hr)) {
1506         IUnknown_Release(&writeroutput->IXmlWriterOutput_iface);
1507         return hr;
1508     }
1509
1510     if (encoding_name) {
1511         unsigned int size = (strlenW(encoding_name) + 1) * sizeof(WCHAR);
1512         writeroutput->encoding_name = writeroutput_alloc(writeroutput, size);
1513         memcpy(writeroutput->encoding_name, encoding_name, size);
1514     }
1515     else
1516         writeroutput->encoding_name = NULL;
1517
1518     IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&writeroutput->output);
1519
1520     *output = &writeroutput->IXmlWriterOutput_iface;
1521
1522     TRACE("returning iface %p\n", *output);
1523
1524     return S_OK;
1525 }
1526
1527 HRESULT WINAPI CreateXmlWriterOutputWithEncodingName(IUnknown *stream,
1528                                                      IMalloc *imalloc,
1529                                                      LPCWSTR encoding,
1530                                                      IXmlWriterOutput **output)
1531 {
1532     static const WCHAR utf8W[] = {'U','T','F','-','8',0};
1533     xml_encoding xml_enc;
1534
1535     TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), output);
1536
1537     if (!stream || !output) return E_INVALIDARG;
1538
1539     xml_enc = parse_encoding_name(encoding ? encoding : utf8W, -1);
1540     return create_writer_output(stream, imalloc, xml_enc, encoding, output);
1541 }
1542
1543 HRESULT WINAPI CreateXmlWriterOutputWithEncodingCodePage(IUnknown *stream,
1544                                                          IMalloc *imalloc,
1545                                                          UINT codepage,
1546                                                          IXmlWriterOutput **output)
1547 {
1548     xml_encoding xml_enc;
1549
1550     TRACE("%p %p %u %p\n", stream, imalloc, codepage, output);
1551
1552     if (!stream || !output) return E_INVALIDARG;
1553
1554     xml_enc = get_encoding_from_codepage(codepage);
1555     return create_writer_output(stream, imalloc, xml_enc, NULL, output);
1556 }