dlls/xmllite/writer.c

   1 /*
   2  * IXmlWriter implementation
   3  *
   4  * Copyright 2011 Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #define COBJMACROS
  21
  22 #include <stdarg.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "xmllite.h"
  27 #include "xmllite_private.h"
  28 #include "initguid.h"
  29
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(xmllite);
  34
  35 /* not defined in public headers */
  36 DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
  37
  38 static const WCHAR closepiW[] = {'?','>'};
  39
  40 struct output_buffer
  41 {
  42     char *data;
  43     unsigned int allocated;
  44     unsigned int written;
  45     UINT codepage;
  46 };
  47
  48 typedef enum
  49 {
  50     XmlWriterState_Initial,      /* output is not set yet */
  51     XmlWriterState_Ready,        /* SetOutput() was called, ready to start */
  52     XmlWriterState_PIDocStarted, /* document was started with manually added 'xml' PI */
  53     XmlWriterState_DocStarted    /* document was started with WriteStartDocument() */
  54 } XmlWriterState;
  55
  56 typedef struct
  57 {
  58     IXmlWriterOutput IXmlWriterOutput_iface;
  59     LONG ref;
  60     IUnknown *output;
  61     ISequentialStream *stream;
  62     IMalloc *imalloc;
  63     xml_encoding encoding;
  64     struct output_buffer buffer;
  65 } xmlwriteroutput;
  66
  67 static const struct IUnknownVtbl xmlwriteroutputvtbl;
  68
  69 typedef struct _xmlwriter
  70 {
  71     IXmlWriter IXmlWriter_iface;
  72     LONG ref;
  73     IMalloc *imalloc;
  74     xmlwriteroutput *output;
  75     BOOL indent;
  76     BOOL bom;
  77     BOOL omitxmldecl;
  78     XmlConformanceLevel conformance;
  79     XmlWriterState state;
  80 } xmlwriter;
  81
  82 static inline xmlwriter *impl_from_IXmlWriter(IXmlWriter *iface)
  83 {
  84     return CONTAINING_RECORD(iface, xmlwriter, IXmlWriter_iface);
  85 }
  86
  87 static inline xmlwriteroutput *impl_from_IXmlWriterOutput(IXmlWriterOutput *iface)
  88 {
  89     return CONTAINING_RECORD(iface, xmlwriteroutput, IXmlWriterOutput_iface);
  90 }
  91
  92 static const char *debugstr_writer_prop(XmlWriterProperty prop)
  93 {
  94     static const char * const prop_names[] =
  95     {
  96         "MultiLanguage",
  97         "Indent",
  98         "ByteOrderMark",
  99         "OmitXmlDeclaration",
 100         "ConformanceLevel"
 101     };
 102
 103     if (prop > _XmlWriterProperty_Last)
 104         return wine_dbg_sprintf("unknown property=%d", prop);
 105
 106     return prop_names[prop];
 107 }
 108
 109 /* writer output memory allocation functions */
 110 static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len)
 111 {
 112     return m_alloc(output->imalloc, len);
 113 }
 114
 115 static inline void writeroutput_free(xmlwriteroutput *output, void *mem)
 116 {
 117     m_free(output->imalloc, mem);
 118 }
 119
 120 static inline void *writeroutput_realloc(xmlwriteroutput *output, void *mem, size_t len)
 121 {
 122     return m_realloc(output->imalloc, mem, len);
 123 }
 124
 125 /* writer memory allocation functions */
 126 static inline void *writer_alloc(xmlwriter *writer, size_t len)
 127 {
 128     return m_alloc(writer->imalloc, len);
 129 }
 130
 131 static inline void writer_free(xmlwriter *writer, void *mem)
 132 {
 133     m_free(writer->imalloc, mem);
 134 }
 135
 136 static HRESULT init_output_buffer(xmlwriteroutput *output)
 137 {
 138     struct output_buffer *buffer = &output->buffer;
 139     const int initial_len = 0x2000;
 140     HRESULT hr;
 141     UINT cp;
 142
 143     hr = get_code_page(output->encoding, &cp);
 144     if (FAILED(hr)) return hr;
 145
 146     buffer->data = writeroutput_alloc(output, initial_len);
 147     if (!buffer->data) return E_OUTOFMEMORY;
 148
 149     memset(buffer->data, 0, 4);
 150     buffer->allocated = initial_len;
 151     buffer->written = 0;
 152     buffer->codepage = cp;
 153
 154     return S_OK;
 155 }
 156
 157 static void free_output_buffer(xmlwriteroutput *output)
 158 {
 159     struct output_buffer *buffer = &output->buffer;
 160     writeroutput_free(output, buffer->data);
 161     buffer->data = NULL;
 162     buffer->allocated = 0;
 163     buffer->written = 0;
 164 }
 165
 166 static HRESULT grow_output_buffer(xmlwriteroutput *output, int length)
 167 {
 168     struct output_buffer *buffer = &output->buffer;
 169     /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
 170     if (buffer->allocated < buffer->written + length + 4) {
 171         int grown_size = max(2*buffer->allocated, buffer->allocated + length);
 172         char *ptr = writeroutput_realloc(output, buffer->data, grown_size);
 173         if (!ptr) return E_OUTOFMEMORY;
 174         buffer->data = ptr;
 175         buffer->allocated = grown_size;
 176     }
 177
 178     return S_OK;
 179 }
 180
 181 static HRESULT write_output_buffer(xmlwriteroutput *output, const WCHAR *data, int len)
 182 {
 183     struct output_buffer *buffer = &output->buffer;
 184     int length;
 185     HRESULT hr;
 186     char *ptr;
 187
 188     if (buffer->codepage != ~0) {
 189         length = WideCharToMultiByte(buffer->codepage, 0, data, len, NULL, 0, NULL, NULL);
 190         hr = grow_output_buffer(output, length);
 191         if (FAILED(hr)) return hr;
 192         ptr = buffer->data + buffer->written;
 193         length = WideCharToMultiByte(buffer->codepage, 0, data, len, ptr, length, NULL, NULL);
 194         buffer->written += len == -1 ? length-1 : length;
 195     }
 196     else {
 197         /* WCHAR data just copied */
 198         length = len == -1 ? strlenW(data) : len;
 199         if (length) {
 200             length *= sizeof(WCHAR);
 201
 202             hr = grow_output_buffer(output, length);
 203             if (FAILED(hr)) return hr;
 204             ptr = buffer->data + buffer->written;
 205
 206             memcpy(ptr, data, length);
 207             buffer->written += length;
 208             ptr += length;
 209             /* null termination */
 210             *(WCHAR*)ptr = 0;
 211         }
 212     }
 213
 214     return S_OK;
 215 }
 216
 217 static HRESULT write_output_buffer_quoted(xmlwriteroutput *output, const WCHAR *data, int len)
 218 {
 219     static const WCHAR quotW[] = {'"'};
 220     write_output_buffer(output, quotW, 1);
 221     write_output_buffer(output, data, len);
 222     write_output_buffer(output, quotW, 1);
 223     return S_OK;
 224 }
 225
 226 static void writeroutput_release_stream(xmlwriteroutput *writeroutput)
 227 {
 228     if (writeroutput->stream) {
 229         ISequentialStream_Release(writeroutput->stream);
 230         writeroutput->stream = NULL;
 231     }
 232 }
 233
 234 static inline HRESULT writeroutput_query_for_stream(xmlwriteroutput *writeroutput)
 235 {
 236     HRESULT hr;
 237
 238     writeroutput_release_stream(writeroutput);
 239     hr = IUnknown_QueryInterface(writeroutput->output, &IID_IStream, (void**)&writeroutput->stream);
 240     if (hr != S_OK)
 241         hr = IUnknown_QueryInterface(writeroutput->output, &IID_ISequentialStream, (void**)&writeroutput->stream);
 242
 243     return hr;
 244 }
 245
 246 static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject)
 247 {
 248     xmlwriter *This = impl_from_IXmlWriter(iface);
 249
 250     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 251
 252     if (IsEqualGUID(riid, &IID_IUnknown) ||
 253         IsEqualGUID(riid, &IID_IXmlWriter))
 254     {
 255         *ppvObject = iface;
 256     }
 257
 258     IXmlWriter_AddRef(iface);
 259
 260     return S_OK;
 261 }
 262
 263 static ULONG WINAPI xmlwriter_AddRef(IXmlWriter *iface)
 264 {
 265     xmlwriter *This = impl_from_IXmlWriter(iface);
 266     TRACE("%p\n", This);
 267     return InterlockedIncrement(&This->ref);
 268 }
 269
 270 static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
 271 {
 272     xmlwriter *This = impl_from_IXmlWriter(iface);
 273     LONG ref;
 274
 275     TRACE("%p\n", This);
 276
 277     ref = InterlockedDecrement(&This->ref);
 278     if (ref == 0) {
 279         IMalloc *imalloc = This->imalloc;
 280         if (This->output) IUnknown_Release(&This->output->IXmlWriterOutput_iface);
 281         writer_free(This, This);
 282         if (imalloc) IMalloc_Release(imalloc);
 283     }
 284
 285     return ref;
 286 }
 287
 288 /*** IXmlWriter methods ***/
 289 static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *output)
 290 {
 291     xmlwriter *This = impl_from_IXmlWriter(iface);
 292     IXmlWriterOutput *writeroutput;
 293     HRESULT hr;
 294
 295     TRACE("(%p)->(%p)\n", This, output);
 296
 297     if (This->output) {
 298         writeroutput_release_stream(This->output);
 299         IUnknown_Release(&This->output->IXmlWriterOutput_iface);
 300         This->output = NULL;
 301     }
 302
 303     /* just reset current output */
 304     if (!output) {
 305         This->state = XmlWriterState_Initial;
 306         return S_OK;
 307     }
 308
 309     /* now try IXmlWriterOutput, ISequentialStream, IStream */
 310     hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&writeroutput);
 311     if (hr == S_OK) {
 312         if (writeroutput->lpVtbl == &xmlwriteroutputvtbl)
 313             This->output = impl_from_IXmlWriterOutput(writeroutput);
 314         else {
 315             ERR("got external IXmlWriterOutput implementation: %p, vtbl=%p\n",
 316                 writeroutput, writeroutput->lpVtbl);
 317             IUnknown_Release(writeroutput);
 318             return E_FAIL;
 319
 320         }
 321     }
 322
 323     if (hr != S_OK || !writeroutput) {
 324         /* create IXmlWriterOutput basing on supplied interface */
 325         hr = CreateXmlWriterOutputWithEncodingName(output, This->imalloc, NULL, &writeroutput);
 326         if (hr != S_OK) return hr;
 327         This->output = impl_from_IXmlWriterOutput(writeroutput);
 328     }
 329
 330     This->state = XmlWriterState_Ready;
 331     return writeroutput_query_for_stream(This->output);
 332 }
 333
 334 static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT property, LONG_PTR *value)
 335 {
 336     xmlwriter *This = impl_from_IXmlWriter(iface);
 337
 338     TRACE("(%p)->(%s %p)\n", This, debugstr_writer_prop(property), value);
 339
 340     if (!value) return E_INVALIDARG;
 341
 342     switch (property)
 343     {
 344         case XmlWriterProperty_Indent:
 345             *value = This->indent;
 346             break;
 347         case XmlWriterProperty_ByteOrderMark:
 348             *value = This->bom;
 349             break;
 350         case XmlWriterProperty_OmitXmlDeclaration:
 351             *value = This->omitxmldecl;
 352             break;
 353         case XmlWriterProperty_ConformanceLevel:
 354             *value = This->conformance;
 355             break;
 356         default:
 357             FIXME("Unimplemented property (%u)\n", property);
 358             return E_NOTIMPL;
 359     }
 360
 361     return S_OK;
 362 }
 363
 364 static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR pValue)
 365 {
 366     xmlwriter *This = impl_from_IXmlWriter(iface);
 367
 368     FIXME("%p %u %lu\n", This, nProperty, pValue);
 369
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI xmlwriter_WriteAttributes(IXmlWriter *iface, IXmlReader *pReader,
 374                                   BOOL fWriteDefaultAttributes)
 375 {
 376     xmlwriter *This = impl_from_IXmlWriter(iface);
 377
 378     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 379
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR pwszPrefix,
 384                                        LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
 385                                        LPCWSTR pwszValue)
 386 {
 387     xmlwriter *This = impl_from_IXmlWriter(iface);
 388
 389     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 390                         wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
 391
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI xmlwriter_WriteCData(IXmlWriter *iface, LPCWSTR pwszText)
 396 {
 397     xmlwriter *This = impl_from_IXmlWriter(iface);
 398
 399     FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
 400
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR wch)
 405 {
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI xmlwriter_WriteChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
 410 {
 411     xmlwriter *This = impl_from_IXmlWriter(iface);
 412
 413     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
 414
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI xmlwriter_WriteComment(IXmlWriter *iface, LPCWSTR pwszComment)
 419 {
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI xmlwriter_WriteDocType(IXmlWriter *iface, LPCWSTR pwszName, LPCWSTR pwszPublicId,
 424                                LPCWSTR pwszSystemId, LPCWSTR pwszSubset)
 425 {
 426     xmlwriter *This = impl_from_IXmlWriter(iface);
 427
 428     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszPublicId),
 429                         wine_dbgstr_w(pwszSystemId), wine_dbgstr_w(pwszSubset));
 430
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR pwszPrefix,
 435                                      LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
 436                                      LPCWSTR pwszValue)
 437 {
 438     xmlwriter *This = impl_from_IXmlWriter(iface);
 439
 440     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 441                         wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
 442
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI xmlwriter_WriteEndDocument(IXmlWriter *iface)
 447 {
 448     xmlwriter *This = impl_from_IXmlWriter(iface);
 449
 450     FIXME("%p\n", This);
 451
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI xmlwriter_WriteEndElement(IXmlWriter *iface)
 456 {
 457     xmlwriter *This = impl_from_IXmlWriter(iface);
 458
 459     FIXME("%p\n", This);
 460
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI xmlwriter_WriteEntityRef(IXmlWriter *iface, LPCWSTR pwszName)
 465 {
 466     xmlwriter *This = impl_from_IXmlWriter(iface);
 467
 468     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
 469
 470     return E_NOTIMPL;
 471 }
 472
 473 static HRESULT WINAPI xmlwriter_WriteFullEndElement(IXmlWriter *iface)
 474 {
 475     xmlwriter *This = impl_from_IXmlWriter(iface);
 476
 477     FIXME("%p\n", This);
 478
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI xmlwriter_WriteName(IXmlWriter *iface, LPCWSTR pwszName)
 483 {
 484     xmlwriter *This = impl_from_IXmlWriter(iface);
 485
 486     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
 487
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT WINAPI xmlwriter_WriteNmToken(IXmlWriter *iface, LPCWSTR pwszNmToken)
 492 {
 493     xmlwriter *This = impl_from_IXmlWriter(iface);
 494
 495     FIXME("%p %s\n", This, wine_dbgstr_w(pwszNmToken));
 496
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI xmlwriter_WriteNode(IXmlWriter *iface, IXmlReader *pReader,
 501                             BOOL fWriteDefaultAttributes)
 502 {
 503     xmlwriter *This = impl_from_IXmlWriter(iface);
 504
 505     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 506
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI xmlwriter_WriteNodeShallow(IXmlWriter *iface, IXmlReader *pReader,
 511                                    BOOL fWriteDefaultAttributes)
 512 {
 513     xmlwriter *This = impl_from_IXmlWriter(iface);
 514
 515     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 516
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR name,
 521                                              LPCWSTR text)
 522 {
 523     xmlwriter *This = impl_from_IXmlWriter(iface);
 524     static const WCHAR xmlW[] = {'x','m','l',0};
 525     static const WCHAR openpiW[] = {'<','?'};
 526     static const WCHAR spaceW[] = {' '};
 527
 528     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_w(name), wine_dbgstr_w(text));
 529
 530     if (This->state == XmlWriterState_Initial)
 531         return E_UNEXPECTED;
 532
 533     if (This->state == XmlWriterState_DocStarted && !strcmpW(name, xmlW))
 534         return WR_E_INVALIDACTION;
 535
 536     write_output_buffer(This->output, openpiW, sizeof(openpiW)/sizeof(WCHAR));
 537     write_output_buffer(This->output, name, -1);
 538     write_output_buffer(This->output, spaceW, 1);
 539     write_output_buffer(This->output, text, -1);
 540     write_output_buffer(This->output, closepiW, sizeof(closepiW)/sizeof(WCHAR));
 541
 542     if (!strcmpW(name, xmlW))
 543         This->state = XmlWriterState_PIDocStarted;
 544
 545     return S_OK;
 546 }
 547
 548 static HRESULT WINAPI xmlwriter_WriteQualifiedName(IXmlWriter *iface, LPCWSTR pwszLocalName,
 549                                      LPCWSTR pwszNamespaceUri)
 550 {
 551     xmlwriter *This = impl_from_IXmlWriter(iface);
 552
 553     FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszLocalName), wine_dbgstr_w(pwszNamespaceUri));
 554
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI xmlwriter_WriteRaw(IXmlWriter *iface, LPCWSTR pwszData)
 559 {
 560     xmlwriter *This = impl_from_IXmlWriter(iface);
 561
 562     FIXME("%p %s\n", This, wine_dbgstr_w(pwszData));
 563
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI xmlwriter_WriteRawChars(IXmlWriter *iface,  const WCHAR *pwch, UINT cwch)
 568 {
 569     xmlwriter *This = impl_from_IXmlWriter(iface);
 570
 571     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
 572
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI xmlwriter_WriteStartDocument(IXmlWriter *iface, XmlStandalone standalone)
 577 {
 578     static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"'};
 579     static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','='};
 580     xmlwriter *This = impl_from_IXmlWriter(iface);
 581
 582     TRACE("(%p)->(%d)\n", This, standalone);
 583
 584     switch (This->state)
 585     {
 586     case XmlWriterState_Initial:
 587         return E_UNEXPECTED;
 588     case XmlWriterState_PIDocStarted:
 589         This->state = XmlWriterState_DocStarted;
 590         return S_OK;
 591     case XmlWriterState_DocStarted:
 592         return WR_E_INVALIDACTION;
 593     default:
 594         ;
 595     }
 596
 597     /* version */
 598     write_output_buffer(This->output, versionW, sizeof(versionW)/sizeof(WCHAR));
 599
 600     /* encoding */
 601     write_output_buffer(This->output, encodingW, sizeof(encodingW)/sizeof(WCHAR));
 602     write_output_buffer_quoted(This->output, get_encoding_name(This->output->encoding), -1);
 603
 604     /* standalone */
 605     if (standalone == XmlStandalone_Omit)
 606         write_output_buffer(This->output, closepiW, sizeof(closepiW)/sizeof(WCHAR));
 607     else {
 608         static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
 609         static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
 610         static const WCHAR noW[] = {'n','o','\"','?','>'};
 611
 612         write_output_buffer(This->output, standaloneW, sizeof(standaloneW)/sizeof(WCHAR));
 613         if (standalone == XmlStandalone_Yes)
 614             write_output_buffer(This->output, yesW, sizeof(yesW)/sizeof(WCHAR));
 615         else
 616             write_output_buffer(This->output, noW, sizeof(noW)/sizeof(WCHAR));
 617     }
 618
 619     This->state = XmlWriterState_DocStarted;
 620     return S_OK;
 621 }
 622
 623 static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR pwszPrefix,
 624                                     LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri)
 625 {
 626     xmlwriter *This = impl_from_IXmlWriter(iface);
 627
 628     FIXME("%p %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 629                 wine_dbgstr_w(pwszNamespaceUri));
 630
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, LPCWSTR pwszText)
 635 {
 636     xmlwriter *This = impl_from_IXmlWriter(iface);
 637
 638     FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
 639
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI xmlwriter_WriteSurrogateCharEntity(IXmlWriter *iface, WCHAR wchLow, WCHAR wchHigh)
 644 {
 645     xmlwriter *This = impl_from_IXmlWriter(iface);
 646
 647     FIXME("%p %d %d\n", This, wchLow, wchHigh);
 648
 649     return E_NOTIMPL;
 650 }
 651
 652 static HRESULT WINAPI xmlwriter_WriteWhitespace(IXmlWriter *iface, LPCWSTR pwszWhitespace)
 653 {
 654     xmlwriter *This = impl_from_IXmlWriter(iface);
 655
 656     FIXME("%p %s\n", This, wine_dbgstr_w(pwszWhitespace));
 657
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI xmlwriter_Flush(IXmlWriter *iface)
 662 {
 663     xmlwriter *This = impl_from_IXmlWriter(iface);
 664
 665     FIXME("%p\n", This);
 666
 667     return E_NOTIMPL;
 668 }
 669
 670 static const struct IXmlWriterVtbl xmlwriter_vtbl =
 671 {
 672     xmlwriter_QueryInterface,
 673     xmlwriter_AddRef,
 674     xmlwriter_Release,
 675     xmlwriter_SetOutput,
 676     xmlwriter_GetProperty,
 677     xmlwriter_SetProperty,
 678     xmlwriter_WriteAttributes,
 679     xmlwriter_WriteAttributeString,
 680     xmlwriter_WriteCData,
 681     xmlwriter_WriteCharEntity,
 682     xmlwriter_WriteChars,
 683     xmlwriter_WriteComment,
 684     xmlwriter_WriteDocType,
 685     xmlwriter_WriteElementString,
 686     xmlwriter_WriteEndDocument,
 687     xmlwriter_WriteEndElement,
 688     xmlwriter_WriteEntityRef,
 689     xmlwriter_WriteFullEndElement,
 690     xmlwriter_WriteName,
 691     xmlwriter_WriteNmToken,
 692     xmlwriter_WriteNode,
 693     xmlwriter_WriteNodeShallow,
 694     xmlwriter_WriteProcessingInstruction,
 695     xmlwriter_WriteQualifiedName,
 696     xmlwriter_WriteRaw,
 697     xmlwriter_WriteRawChars,
 698     xmlwriter_WriteStartDocument,
 699     xmlwriter_WriteStartElement,
 700     xmlwriter_WriteString,
 701     xmlwriter_WriteSurrogateCharEntity,
 702     xmlwriter_WriteWhitespace,
 703     xmlwriter_Flush
 704 };
 705
 706 /** IXmlWriterOutput **/
 707 static HRESULT WINAPI xmlwriteroutput_QueryInterface(IXmlWriterOutput *iface, REFIID riid, void** ppvObject)
 708 {
 709     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 710
 711     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 712
 713     if (IsEqualGUID(riid, &IID_IXmlWriterOutput) ||
 714         IsEqualGUID(riid, &IID_IUnknown))
 715     {
 716         *ppvObject = iface;
 717     }
 718     else
 719     {
 720         WARN("interface %s not implemented\n", debugstr_guid(riid));
 721         *ppvObject = NULL;
 722         return E_NOINTERFACE;
 723     }
 724
 725     IUnknown_AddRef(iface);
 726
 727     return S_OK;
 728 }
 729
 730 static ULONG WINAPI xmlwriteroutput_AddRef(IXmlWriterOutput *iface)
 731 {
 732     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 733     ULONG ref = InterlockedIncrement(&This->ref);
 734     TRACE("(%p)->(%d)\n", This, ref);
 735     return ref;
 736 }
 737
 738 static ULONG WINAPI xmlwriteroutput_Release(IXmlWriterOutput *iface)
 739 {
 740     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 741     LONG ref = InterlockedDecrement(&This->ref);
 742
 743     TRACE("(%p)->(%d)\n", This, ref);
 744
 745     if (ref == 0)
 746     {
 747         IMalloc *imalloc = This->imalloc;
 748         if (This->output) IUnknown_Release(This->output);
 749         if (This->stream) ISequentialStream_Release(This->stream);
 750         free_output_buffer(This);
 751         writeroutput_free(This, This);
 752         if (imalloc) IMalloc_Release(imalloc);
 753     }
 754
 755     return ref;
 756 }
 757
 758 static const struct IUnknownVtbl xmlwriteroutputvtbl =
 759 {
 760     xmlwriteroutput_QueryInterface,
 761     xmlwriteroutput_AddRef,
 762     xmlwriteroutput_Release
 763 };
 764
 765 HRESULT WINAPI CreateXmlWriter(REFIID riid, void **obj, IMalloc *imalloc)
 766 {
 767     xmlwriter *writer;
 768
 769     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
 770
 771     if (!IsEqualGUID(riid, &IID_IXmlWriter))
 772     {
 773         ERR("Unexpected IID requested -> (%s)\n", wine_dbgstr_guid(riid));
 774         return E_FAIL;
 775     }
 776
 777     if (imalloc)
 778         writer = IMalloc_Alloc(imalloc, sizeof(*writer));
 779     else
 780         writer = heap_alloc(sizeof(*writer));
 781     if(!writer) return E_OUTOFMEMORY;
 782
 783     writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl;
 784     writer->ref = 1;
 785     writer->imalloc = imalloc;
 786     if (imalloc) IMalloc_AddRef(imalloc);
 787     writer->output = NULL;
 788     writer->indent = FALSE;
 789     writer->bom = TRUE;
 790     writer->omitxmldecl = FALSE;
 791     writer->conformance = XmlConformanceLevel_Document;
 792     writer->state = XmlWriterState_Initial;
 793
 794     *obj = &writer->IXmlWriter_iface;
 795
 796     TRACE("returning iface %p\n", *obj);
 797
 798     return S_OK;
 799 }
 800
 801 HRESULT WINAPI CreateXmlWriterOutputWithEncodingName(IUnknown *stream,
 802                                                      IMalloc *imalloc,
 803                                                      LPCWSTR encoding,
 804                                                      IXmlWriterOutput **output)
 805 {
 806     static const WCHAR utf8W[] = {'U','T','F','-','8',0};
 807     xmlwriteroutput *writeroutput;
 808     HRESULT hr;
 809
 810     TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), output);
 811
 812     if (!stream || !output) return E_INVALIDARG;
 813
 814     *output = NULL;
 815
 816     if (imalloc)
 817         writeroutput = IMalloc_Alloc(imalloc, sizeof(*writeroutput));
 818     else
 819         writeroutput = heap_alloc(sizeof(*writeroutput));
 820     if(!writeroutput) return E_OUTOFMEMORY;
 821
 822     writeroutput->IXmlWriterOutput_iface.lpVtbl = &xmlwriteroutputvtbl;
 823     writeroutput->ref = 1;
 824     writeroutput->imalloc = imalloc;
 825     if (imalloc) IMalloc_AddRef(imalloc);
 826     writeroutput->encoding = parse_encoding_name(encoding ? encoding : utf8W, -1);
 827     writeroutput->stream = NULL;
 828     hr = init_output_buffer(writeroutput);
 829     if (FAILED(hr)) {
 830         IUnknown_Release(&writeroutput->IXmlWriterOutput_iface);
 831         return hr;
 832     }
 833
 834     IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&writeroutput->output);
 835
 836     *output = &writeroutput->IXmlWriterOutput_iface;
 837
 838     TRACE("returning iface %p\n", *output);
 839
 840     return S_OK;
 841 }