dlls/msxml3/mxwriter.c

   1 /*
   2  *    MXWriter implementation
   3  *
   4  * Copyright 2011 Nikolay Sivov for CodeWeavers
   5  * Copyright 2011 Thomas Mullaly
   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
  22 #define COBJMACROS
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #ifdef HAVE_LIBXML2
  27 # include <libxml/parser.h>
  28 #endif
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "ole2.h"
  33
  34 #include "msxml6.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "msxml_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  41
  42 #ifdef HAVE_LIBXML2
  43
  44 static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
  45 static const WCHAR utf8W[]  = {'U','T','F','-','8',0};
  46
  47 static const char crlfA[] = "\r\n";
  48 static const WCHAR emptyW[] = {0};
  49
  50 typedef enum
  51 {
  52     MXWriter_BOM = 0,
  53     MXWriter_DisableEscaping,
  54     MXWriter_Indent,
  55     MXWriter_OmitXmlDecl,
  56     MXWriter_Standalone,
  57     MXWriter_LastProp
  58 } MXWRITER_PROPS;
  59
  60 typedef struct
  61 {
  62     DispatchEx dispex;
  63     IMXWriter IMXWriter_iface;
  64     ISAXContentHandler ISAXContentHandler_iface;
  65
  66     LONG ref;
  67     MSXML_VERSION class_version;
  68
  69     VARIANT_BOOL props[MXWriter_LastProp];
  70     BOOL prop_changed;
  71     xmlCharEncoding encoding;
  72     BSTR version;
  73
  74     /* contains a pending (or not closed yet) element name or NULL if
  75        we don't have to close */
  76     BSTR element;
  77
  78     IStream *dest;
  79     ULONG   dest_written;
  80
  81     int decl_count;   /* practically how many times startDocument was called */
  82     int decl_written; /* byte length of document prolog */
  83
  84     xmlOutputBufferPtr buffer;
  85 } mxwriter;
  86
  87 static HRESULT bstr_from_xmlCharEncoding(xmlCharEncoding enc, BSTR *encoding)
  88 {
  89     const char *encodingA;
  90
  91     if (enc != XML_CHAR_ENCODING_UTF16LE && enc != XML_CHAR_ENCODING_UTF8) {
  92         FIXME("Unsupported xmlCharEncoding: %d\n", enc);
  93         *encoding = NULL;
  94         return E_NOTIMPL;
  95     }
  96
  97     encodingA = xmlGetCharEncodingName(enc);
  98     if (encodingA) {
  99         DWORD len = MultiByteToWideChar(CP_ACP, 0, encodingA, -1, NULL, 0);
 100         *encoding = SysAllocStringLen(NULL, len-1);
 101         if(*encoding)
 102             MultiByteToWideChar( CP_ACP, 0, encodingA, -1, *encoding, len);
 103     } else
 104         *encoding = SysAllocStringLen(NULL, 0);
 105
 106     return *encoding ? S_OK : E_OUTOFMEMORY;
 107 }
 108
 109 /* escapes special characters like:
 110    '<' -> "&lt;"
 111    '&' -> "&amp;"
 112    '"' -> "&quot;"
 113    '>' -> "&gt;"
 114 */
 115 static WCHAR *get_escaped_string(const WCHAR *str, int *len)
 116 {
 117     static const WCHAR ltW[]   = {'&','l','t',';'};
 118     static const WCHAR ampW[]  = {'&','a','m','p',';'};
 119     static const WCHAR quotW[] = {'&','q','u','o','t',';'};
 120     static const WCHAR gtW[]   = {'&','g','t',';'};
 121
 122     const int default_alloc = 100;
 123     const int grow_thresh = 10;
 124     int p = *len, conv_len;
 125     WCHAR *ptr, *ret;
 126
 127     /* default buffer size to something if length is unknown */
 128     conv_len = *len == -1 ? default_alloc : max(2**len, default_alloc);
 129     ptr = ret = heap_alloc(conv_len*sizeof(WCHAR));
 130
 131     while (*str && p)
 132     {
 133         if (ptr - ret > conv_len - grow_thresh)
 134         {
 135             int written = ptr - ret;
 136             conv_len *= 2;
 137             ptr = ret = heap_realloc(ret, conv_len*sizeof(WCHAR));
 138             ptr += written;
 139         }
 140
 141         switch (*str)
 142         {
 143         case '<':
 144             memcpy(ptr, ltW, sizeof(ltW));
 145             ptr += sizeof(ltW)/sizeof(WCHAR);
 146             break;
 147         case '&':
 148             memcpy(ptr, ampW, sizeof(ampW));
 149             ptr += sizeof(ampW)/sizeof(WCHAR);
 150             break;
 151         case '"':
 152             memcpy(ptr, quotW, sizeof(quotW));
 153             ptr += sizeof(quotW)/sizeof(WCHAR);
 154             break;
 155         case '>':
 156             memcpy(ptr, gtW, sizeof(gtW));
 157             ptr += sizeof(gtW)/sizeof(WCHAR);
 158             break;
 159         default:
 160             *ptr++ = *str;
 161             break;
 162         }
 163
 164         str++;
 165         if (*len != -1) p--;
 166     }
 167
 168     if (*len != -1) *len = ptr-ret;
 169     *++ptr = 0;
 170
 171     return ret;
 172 }
 173
 174 /* creates UTF-8 encoded prolog string with specified or store encoding value */
 175 static int write_prolog_buffer(const mxwriter *This, xmlCharEncoding enc, xmlOutputBufferPtr buffer)
 176 {
 177     static const char version[] = "<?xml version=\"";
 178     static const char encoding[] = " encoding=\"";
 179     static const char standalone[] = " standalone=\"";
 180     static const char yes[] = "yes\"?>";
 181     static const char no[] = "no\"?>";
 182     xmlBufferPtr buf;
 183     xmlChar *s;
 184     int use;
 185
 186     if (enc == XML_CHAR_ENCODING_UTF8)
 187         buf = buffer->buffer;
 188     else
 189         buf = buffer->conv;
 190
 191     use = buf->use;
 192
 193     /* version */
 194     xmlOutputBufferWrite(buffer, sizeof(version)-1, version);
 195     s = xmlchar_from_wchar(This->version);
 196     xmlOutputBufferWriteString(buffer, (char*)s);
 197     heap_free(s);
 198     xmlOutputBufferWrite(buffer, 1, "\"");
 199
 200     /* encoding */
 201     xmlOutputBufferWrite(buffer, sizeof(encoding)-1, encoding);
 202     xmlOutputBufferWriteString(buffer, xmlGetCharEncodingName(enc));
 203     xmlOutputBufferWrite(buffer, 1, "\"");
 204
 205     /* standalone */
 206     xmlOutputBufferWrite(buffer, sizeof(standalone)-1, standalone);
 207     if (This->props[MXWriter_Standalone] == VARIANT_TRUE)
 208         xmlOutputBufferWrite(buffer, sizeof(yes)-1, yes);
 209     else
 210         xmlOutputBufferWrite(buffer, sizeof(no)-1, no);
 211
 212     xmlOutputBufferWrite(buffer, sizeof(crlfA)-1, crlfA);
 213     xmlOutputBufferFlush(buffer);
 214
 215     return buf->use - use;
 216 }
 217
 218 /* Attempts to the write data from the mxwriter's buffer to
 219  * the destination stream (if there is one).
 220  */
 221 static HRESULT write_data_to_stream(mxwriter *This)
 222 {
 223     xmlBufferPtr buffer;
 224     ULONG written = 0;
 225     HRESULT hr;
 226
 227     if (!This->dest)
 228         return S_OK;
 229
 230     /* The xmlOutputBuffer doesn't copy its contents from its 'buffer' to the
 231      * 'conv' buffer when UTF8 encoding is used.
 232      */
 233     if (This->encoding == XML_CHAR_ENCODING_UTF8)
 234         buffer = This->buffer->buffer;
 235     else
 236         buffer = This->buffer->conv;
 237
 238     if (This->dest_written > buffer->use) {
 239         ERR("Failed sanity check! Not sure what to do... (%d > %d)\n", This->dest_written, buffer->use);
 240         return E_FAIL;
 241     } else if (This->dest_written == buffer->use && This->encoding != XML_CHAR_ENCODING_UTF8)
 242         /* Windows seems to make an empty write call when the encoding is UTF-8 and
 243          * all the data has been written to the stream. It doesn't seem make this call
 244          * for any other encodings.
 245          */
 246         return S_OK;
 247
 248     /* Write the current content from the output buffer into 'dest'.
 249      * TODO: Check what Windows does if the IStream doesn't write all of
 250      *       the data we give it at once.
 251      */
 252     hr = IStream_Write(This->dest, buffer->content+This->dest_written,
 253                          buffer->use-This->dest_written, &written);
 254     if (FAILED(hr)) {
 255         WARN("Failed to write data to IStream (0x%08x)\n", hr);
 256         return hr;
 257     }
 258
 259     This->dest_written += written;
 260     return hr;
 261 }
 262
 263 static void write_output_buffer(const mxwriter *This, const char *data, int len)
 264 {
 265     xmlOutputBufferWrite(This->buffer, len, data);
 266 }
 267
 268 static void write_output_buffer_str(const mxwriter *This, const char *data)
 269 {
 270     xmlOutputBufferWriteString(This->buffer, data);
 271 }
 272
 273 /* Newly added element start tag left unclosed cause for empty elements
 274    we have to close it differently. */
 275 static void close_element_starttag(const mxwriter *This)
 276 {
 277     static const char gt = '>';
 278     if (!This->element) return;
 279     write_output_buffer(This, &gt, 1);
 280 }
 281
 282 static void set_element_name(mxwriter *This, const WCHAR *name, int len)
 283 {
 284     SysFreeString(This->element);
 285     This->element = name ? SysAllocStringLen(name, len) : NULL;
 286 }
 287
 288 static inline HRESULT flush_output_buffer(mxwriter *This)
 289 {
 290     close_element_starttag(This);
 291     set_element_name(This, NULL, 0);
 292     xmlOutputBufferFlush(This->buffer);
 293     return write_data_to_stream(This);
 294 }
 295
 296 /* Resets the mxwriter's output buffer by closing it, then creating a new
 297  * output buffer using the given encoding.
 298  */
 299 static inline void reset_output_buffer(mxwriter *This)
 300 {
 301     xmlOutputBufferClose(This->buffer);
 302     This->buffer = xmlAllocOutputBuffer(xmlGetCharEncodingHandler(This->encoding));
 303     This->dest_written = 0;
 304     This->decl_count = 0;
 305     This->decl_written = 0;
 306 }
 307
 308 static HRESULT writer_set_property(mxwriter *writer, MXWRITER_PROPS property, VARIANT_BOOL value)
 309 {
 310     writer->props[property] = value;
 311     writer->prop_changed = TRUE;
 312     return S_OK;
 313 }
 314
 315 static HRESULT writer_get_property(const mxwriter *writer, MXWRITER_PROPS property, VARIANT_BOOL *value)
 316 {
 317     if (!value) return E_POINTER;
 318     *value = writer->props[property];
 319     return S_OK;
 320 }
 321
 322 static inline mxwriter *impl_from_IMXWriter(IMXWriter *iface)
 323 {
 324     return CONTAINING_RECORD(iface, mxwriter, IMXWriter_iface);
 325 }
 326
 327 static inline mxwriter *impl_from_ISAXContentHandler(ISAXContentHandler *iface)
 328 {
 329     return CONTAINING_RECORD(iface, mxwriter, ISAXContentHandler_iface);
 330 }
 331
 332 static HRESULT WINAPI mxwriter_QueryInterface(IMXWriter *iface, REFIID riid, void **obj)
 333 {
 334     mxwriter *This = impl_from_IMXWriter( iface );
 335
 336     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 337
 338     *obj = NULL;
 339
 340     if ( IsEqualGUID( riid, &IID_IMXWriter ) ||
 341          IsEqualGUID( riid, &IID_IDispatch ) ||
 342          IsEqualGUID( riid, &IID_IUnknown ) )
 343     {
 344         *obj = &This->IMXWriter_iface;
 345     }
 346     else if ( IsEqualGUID( riid, &IID_ISAXContentHandler ) )
 347     {
 348         *obj = &This->ISAXContentHandler_iface;
 349     }
 350     else if (dispex_query_interface(&This->dispex, riid, obj))
 351     {
 352         return *obj ? S_OK : E_NOINTERFACE;
 353     }
 354     else
 355     {
 356         ERR("interface %s not implemented\n", debugstr_guid(riid));
 357         *obj = NULL;
 358         return E_NOINTERFACE;
 359     }
 360
 361     IMXWriter_AddRef(iface);
 362     return S_OK;
 363 }
 364
 365 static ULONG WINAPI mxwriter_AddRef(IMXWriter *iface)
 366 {
 367     mxwriter *This = impl_from_IMXWriter( iface );
 368     LONG ref = InterlockedIncrement(&This->ref);
 369
 370     TRACE("(%p)->(%d)\n", This, ref);
 371
 372     return ref;
 373 }
 374
 375 static ULONG WINAPI mxwriter_Release(IMXWriter *iface)
 376 {
 377     mxwriter *This = impl_from_IMXWriter( iface );
 378     ULONG ref = InterlockedDecrement(&This->ref);
 379
 380     TRACE("(%p)->(%d)\n", This, ref);
 381
 382     if(!ref)
 383     {
 384         /* Windows flushes the buffer when the interface is destroyed. */
 385         flush_output_buffer(This);
 386
 387         if (This->dest) IStream_Release(This->dest);
 388         SysFreeString(This->version);
 389
 390         xmlOutputBufferClose(This->buffer);
 391         SysFreeString(This->element);
 392         release_dispex(&This->dispex);
 393         heap_free(This);
 394     }
 395
 396     return ref;
 397 }
 398
 399 static HRESULT WINAPI mxwriter_GetTypeInfoCount(IMXWriter *iface, UINT* pctinfo)
 400 {
 401     mxwriter *This = impl_from_IMXWriter( iface );
 402     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 403 }
 404
 405 static HRESULT WINAPI mxwriter_GetTypeInfo(
 406     IMXWriter *iface,
 407     UINT iTInfo, LCID lcid,
 408     ITypeInfo** ppTInfo )
 409 {
 410     mxwriter *This = impl_from_IMXWriter( iface );
 411     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 412         iTInfo, lcid, ppTInfo);
 413 }
 414
 415 static HRESULT WINAPI mxwriter_GetIDsOfNames(
 416     IMXWriter *iface,
 417     REFIID riid, LPOLESTR* rgszNames,
 418     UINT cNames, LCID lcid, DISPID* rgDispId )
 419 {
 420     mxwriter *This = impl_from_IMXWriter( iface );
 421     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 422         riid, rgszNames, cNames, lcid, rgDispId);
 423 }
 424
 425 static HRESULT WINAPI mxwriter_Invoke(
 426     IMXWriter *iface,
 427     DISPID dispIdMember, REFIID riid, LCID lcid,
 428     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 429     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 430 {
 431     mxwriter *This = impl_from_IMXWriter( iface );
 432     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 433         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 434 }
 435
 436 static HRESULT WINAPI mxwriter_put_output(IMXWriter *iface, VARIANT dest)
 437 {
 438     mxwriter *This = impl_from_IMXWriter( iface );
 439     HRESULT hr;
 440
 441     TRACE("(%p)->(%s)\n", This, debugstr_variant(&dest));
 442
 443     hr = flush_output_buffer(This);
 444     if (FAILED(hr))
 445         return hr;
 446
 447     switch (V_VT(&dest))
 448     {
 449     case VT_EMPTY:
 450     {
 451         if (This->dest) IStream_Release(This->dest);
 452         This->dest = NULL;
 453         reset_output_buffer(This);
 454         break;
 455     }
 456     case VT_UNKNOWN:
 457     {
 458         IStream *stream;
 459
 460         hr = IUnknown_QueryInterface(V_UNKNOWN(&dest), &IID_IStream, (void**)&stream);
 461         if (hr == S_OK)
 462         {
 463             /* Recreate the output buffer to make sure it's using the correct encoding. */
 464             reset_output_buffer(This);
 465
 466             if (This->dest) IStream_Release(This->dest);
 467             This->dest = stream;
 468             break;
 469         }
 470
 471         FIXME("unhandled interface type for VT_UNKNOWN destination\n");
 472         return E_NOTIMPL;
 473     }
 474     default:
 475         FIXME("unhandled destination type %s\n", debugstr_variant(&dest));
 476         return E_NOTIMPL;
 477     }
 478
 479     return S_OK;
 480 }
 481
 482 static HRESULT WINAPI mxwriter_get_output(IMXWriter *iface, VARIANT *dest)
 483 {
 484     mxwriter *This = impl_from_IMXWriter( iface );
 485
 486     TRACE("(%p)->(%p)\n", This, dest);
 487
 488     if (!This->dest)
 489     {
 490         xmlOutputBufferPtr prolog;
 491         BSTR output, body = NULL;
 492         xmlBufferPtr buffer;
 493         WCHAR *ptr;
 494         HRESULT hr;
 495         int i;
 496
 497         hr = flush_output_buffer(This);
 498         if (FAILED(hr))
 499             return hr;
 500
 501         if (This->decl_count)
 502         {
 503             prolog = xmlAllocOutputBuffer(xmlGetCharEncodingHandler(xmlParseCharEncoding("UTF-16")));
 504             write_prolog_buffer(This, xmlParseCharEncoding("UTF-16"), prolog);
 505         }
 506         else
 507             prolog = NULL;
 508
 509         /* optimize some paticular cases */
 510         /* 1. no prolog and UTF-8 buffer */
 511         if (This->encoding == XML_CHAR_ENCODING_UTF8 && !prolog)
 512         {
 513             V_VT(dest)   = VT_BSTR;
 514             V_BSTR(dest) = bstr_from_xmlChar(This->buffer->buffer->content);
 515             return S_OK;
 516         }
 517
 518         /* 2. no prolog and UTF-16 buffer */
 519         if (!prolog)
 520         {
 521             V_VT(dest)   = VT_BSTR;
 522             V_BSTR(dest) = SysAllocStringLen((const WCHAR*)This->buffer->conv->content,
 523                 This->buffer->conv->use/sizeof(WCHAR));
 524             return S_OK;
 525         }
 526
 527         V_BSTR(dest) = NULL;
 528
 529         if (This->encoding == XML_CHAR_ENCODING_UTF8)
 530         {
 531             buffer = This->buffer->buffer;
 532             body = bstr_from_xmlChar(buffer->content+This->decl_written);
 533             ptr = output = SysAllocStringByteLen(NULL, prolog->conv->use*This->decl_count +
 534                 SysStringByteLen(body));
 535         }
 536         else
 537         {
 538             buffer = This->buffer->conv;
 539             ptr = output = SysAllocStringByteLen(NULL, prolog->conv->use*This->decl_count +
 540                 buffer->use - This->decl_written);
 541         }
 542
 543         /* write prolog part */
 544         i = This->decl_count;
 545         while (i--)
 546         {
 547             memcpy(ptr, prolog->conv->content, prolog->conv->use);
 548             ptr += prolog->conv->use/sizeof(WCHAR);
 549         }
 550         xmlOutputBufferClose(prolog);
 551
 552         /* write main part */
 553         if (body)
 554         {
 555             memcpy(ptr, body, SysStringByteLen(body));
 556             SysFreeString(body);
 557         }
 558         else
 559             memcpy(ptr, buffer->content + This->decl_written, buffer->use-This->decl_written);
 560
 561         V_VT(dest)   = VT_BSTR;
 562         V_BSTR(dest) = output;
 563
 564         return S_OK;
 565     }
 566     else
 567         FIXME("not implemented when stream is set up\n");
 568
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI mxwriter_put_encoding(IMXWriter *iface, BSTR encoding)
 573 {
 574     mxwriter *This = impl_from_IMXWriter( iface );
 575
 576     TRACE("(%p)->(%s)\n", This, debugstr_w(encoding));
 577
 578     /* FIXME: filter all supported encodings */
 579     if (!strcmpW(encoding, utf16W) || !strcmpW(encoding, utf8W))
 580     {
 581         HRESULT hr;
 582         LPSTR enc;
 583
 584         hr = flush_output_buffer(This);
 585         if (FAILED(hr))
 586             return hr;
 587
 588         enc = heap_strdupWtoA(encoding);
 589         if (!enc)
 590             return E_OUTOFMEMORY;
 591
 592         This->encoding = xmlParseCharEncoding(enc);
 593         heap_free(enc);
 594
 595         TRACE("got encoding %d\n", This->encoding);
 596         reset_output_buffer(This);
 597         return S_OK;
 598     }
 599     else
 600     {
 601         FIXME("unsupported encoding %s\n", debugstr_w(encoding));
 602         return E_INVALIDARG;
 603     }
 604 }
 605
 606 static HRESULT WINAPI mxwriter_get_encoding(IMXWriter *iface, BSTR *encoding)
 607 {
 608     mxwriter *This = impl_from_IMXWriter( iface );
 609
 610     TRACE("(%p)->(%p)\n", This, encoding);
 611
 612     if (!encoding) return E_POINTER;
 613
 614     return bstr_from_xmlCharEncoding(This->encoding, encoding);
 615 }
 616
 617 static HRESULT WINAPI mxwriter_put_byteOrderMark(IMXWriter *iface, VARIANT_BOOL value)
 618 {
 619     mxwriter *This = impl_from_IMXWriter( iface );
 620
 621     TRACE("(%p)->(%d)\n", This, value);
 622     return writer_set_property(This, MXWriter_BOM, value);
 623 }
 624
 625 static HRESULT WINAPI mxwriter_get_byteOrderMark(IMXWriter *iface, VARIANT_BOOL *value)
 626 {
 627     mxwriter *This = impl_from_IMXWriter( iface );
 628
 629     TRACE("(%p)->(%p)\n", This, value);
 630     return writer_get_property(This, MXWriter_BOM, value);
 631 }
 632
 633 static HRESULT WINAPI mxwriter_put_indent(IMXWriter *iface, VARIANT_BOOL value)
 634 {
 635     mxwriter *This = impl_from_IMXWriter( iface );
 636
 637     TRACE("(%p)->(%d)\n", This, value);
 638     return writer_set_property(This, MXWriter_Indent, value);
 639 }
 640
 641 static HRESULT WINAPI mxwriter_get_indent(IMXWriter *iface, VARIANT_BOOL *value)
 642 {
 643     mxwriter *This = impl_from_IMXWriter( iface );
 644
 645     TRACE("(%p)->(%p)\n", This, value);
 646     return writer_get_property(This, MXWriter_Indent, value);
 647 }
 648
 649 static HRESULT WINAPI mxwriter_put_standalone(IMXWriter *iface, VARIANT_BOOL value)
 650 {
 651     mxwriter *This = impl_from_IMXWriter( iface );
 652
 653     TRACE("(%p)->(%d)\n", This, value);
 654     return writer_set_property(This, MXWriter_Standalone, value);
 655 }
 656
 657 static HRESULT WINAPI mxwriter_get_standalone(IMXWriter *iface, VARIANT_BOOL *value)
 658 {
 659     mxwriter *This = impl_from_IMXWriter( iface );
 660
 661     TRACE("(%p)->(%p)\n", This, value);
 662     return writer_get_property(This, MXWriter_Standalone, value);
 663 }
 664
 665 static HRESULT WINAPI mxwriter_put_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL value)
 666 {
 667     mxwriter *This = impl_from_IMXWriter( iface );
 668
 669     TRACE("(%p)->(%d)\n", This, value);
 670     return writer_set_property(This, MXWriter_OmitXmlDecl, value);
 671 }
 672
 673 static HRESULT WINAPI mxwriter_get_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL *value)
 674 {
 675     mxwriter *This = impl_from_IMXWriter( iface );
 676
 677     TRACE("(%p)->(%p)\n", This, value);
 678     return writer_get_property(This, MXWriter_OmitXmlDecl, value);
 679 }
 680
 681 static HRESULT WINAPI mxwriter_put_version(IMXWriter *iface, BSTR version)
 682 {
 683     mxwriter *This = impl_from_IMXWriter( iface );
 684
 685     TRACE("(%p)->(%s)\n", This, debugstr_w(version));
 686
 687     if (!version) return E_INVALIDARG;
 688
 689     SysFreeString(This->version);
 690     This->version = SysAllocString(version);
 691
 692     return S_OK;
 693 }
 694
 695 static HRESULT WINAPI mxwriter_get_version(IMXWriter *iface, BSTR *version)
 696 {
 697     mxwriter *This = impl_from_IMXWriter( iface );
 698
 699     TRACE("(%p)->(%p)\n", This, version);
 700
 701     if (!version) return E_POINTER;
 702
 703     return return_bstr(This->version, version);
 704 }
 705
 706 static HRESULT WINAPI mxwriter_put_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL value)
 707 {
 708     mxwriter *This = impl_from_IMXWriter( iface );
 709
 710     TRACE("(%p)->(%d)\n", This, value);
 711     return writer_set_property(This, MXWriter_DisableEscaping, value);
 712 }
 713
 714 static HRESULT WINAPI mxwriter_get_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL *value)
 715 {
 716     mxwriter *This = impl_from_IMXWriter( iface );
 717
 718     TRACE("(%p)->(%p)\n", This, value);
 719     return writer_get_property(This, MXWriter_DisableEscaping, value);
 720 }
 721
 722 static HRESULT WINAPI mxwriter_flush(IMXWriter *iface)
 723 {
 724     mxwriter *This = impl_from_IMXWriter( iface );
 725     TRACE("(%p)\n", This);
 726     return flush_output_buffer(This);
 727 }
 728
 729 static const struct IMXWriterVtbl MXWriterVtbl =
 730 {
 731     mxwriter_QueryInterface,
 732     mxwriter_AddRef,
 733     mxwriter_Release,
 734     mxwriter_GetTypeInfoCount,
 735     mxwriter_GetTypeInfo,
 736     mxwriter_GetIDsOfNames,
 737     mxwriter_Invoke,
 738     mxwriter_put_output,
 739     mxwriter_get_output,
 740     mxwriter_put_encoding,
 741     mxwriter_get_encoding,
 742     mxwriter_put_byteOrderMark,
 743     mxwriter_get_byteOrderMark,
 744     mxwriter_put_indent,
 745     mxwriter_get_indent,
 746     mxwriter_put_standalone,
 747     mxwriter_get_standalone,
 748     mxwriter_put_omitXMLDeclaration,
 749     mxwriter_get_omitXMLDeclaration,
 750     mxwriter_put_version,
 751     mxwriter_get_version,
 752     mxwriter_put_disableOutputEscaping,
 753     mxwriter_get_disableOutputEscaping,
 754     mxwriter_flush
 755 };
 756
 757 /*** ISAXContentHandler ***/
 758 static HRESULT WINAPI mxwriter_saxcontent_QueryInterface(
 759     ISAXContentHandler *iface,
 760     REFIID riid,
 761     void **obj)
 762 {
 763     mxwriter *This = impl_from_ISAXContentHandler( iface );
 764     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
 765 }
 766
 767 static ULONG WINAPI mxwriter_saxcontent_AddRef(ISAXContentHandler *iface)
 768 {
 769     mxwriter *This = impl_from_ISAXContentHandler( iface );
 770     return IMXWriter_AddRef(&This->IMXWriter_iface);
 771 }
 772
 773 static ULONG WINAPI mxwriter_saxcontent_Release(ISAXContentHandler *iface)
 774 {
 775     mxwriter *This = impl_from_ISAXContentHandler( iface );
 776     return IMXWriter_Release(&This->IMXWriter_iface);
 777 }
 778
 779 static HRESULT WINAPI mxwriter_saxcontent_putDocumentLocator(
 780     ISAXContentHandler *iface,
 781     ISAXLocator *locator)
 782 {
 783     mxwriter *This = impl_from_ISAXContentHandler( iface );
 784     FIXME("(%p)->(%p)\n", This, locator);
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI mxwriter_saxcontent_startDocument(ISAXContentHandler *iface)
 789 {
 790     mxwriter *This = impl_from_ISAXContentHandler( iface );
 791
 792     TRACE("(%p)\n", This);
 793
 794     /* If properties have been changed since the last "endDocument" call
 795      * we need to reset the output buffer. If we don't the output buffer
 796      * could end up with multiple XML documents in it, plus this seems to
 797      * be how Windows works.
 798      */
 799     if (This->prop_changed) {
 800         reset_output_buffer(This);
 801         This->prop_changed = FALSE;
 802     }
 803
 804     if (This->props[MXWriter_OmitXmlDecl] == VARIANT_TRUE) return S_OK;
 805
 806     This->decl_count++;
 807     This->decl_written += write_prolog_buffer(This, This->encoding, This->buffer);
 808
 809     if (This->dest && This->encoding == XML_CHAR_ENCODING_UTF16LE) {
 810         static const CHAR utf16BOM[] = {0xff,0xfe};
 811
 812         if (This->props[MXWriter_BOM] == VARIANT_TRUE)
 813             /* Windows passes a NULL pointer as the pcbWritten parameter and
 814              * ignores any error codes returned from this Write call.
 815              */
 816             IStream_Write(This->dest, utf16BOM, sizeof(utf16BOM), NULL);
 817     }
 818
 819     return S_OK;
 820 }
 821
 822 static HRESULT WINAPI mxwriter_saxcontent_endDocument(ISAXContentHandler *iface)
 823 {
 824     mxwriter *This = impl_from_ISAXContentHandler( iface );
 825     TRACE("(%p)\n", This);
 826     This->prop_changed = FALSE;
 827     return flush_output_buffer(This);
 828 }
 829
 830 static HRESULT WINAPI mxwriter_saxcontent_startPrefixMapping(
 831     ISAXContentHandler *iface,
 832     const WCHAR *prefix,
 833     int nprefix,
 834     const WCHAR *uri,
 835     int nuri)
 836 {
 837     mxwriter *This = impl_from_ISAXContentHandler( iface );
 838     FIXME("(%p)->(%s %s)\n", This, debugstr_wn(prefix, nprefix), debugstr_wn(uri, nuri));
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI mxwriter_saxcontent_endPrefixMapping(
 843     ISAXContentHandler *iface,
 844     const WCHAR *prefix,
 845     int nprefix)
 846 {
 847     mxwriter *This = impl_from_ISAXContentHandler( iface );
 848     FIXME("(%p)->(%s)\n", This, debugstr_wn(prefix, nprefix));
 849     return E_NOTIMPL;
 850 }
 851
 852 static HRESULT WINAPI mxwriter_saxcontent_startElement(
 853     ISAXContentHandler *iface,
 854     const WCHAR *namespaceUri,
 855     int nnamespaceUri,
 856     const WCHAR *local_name,
 857     int nlocal_name,
 858     const WCHAR *QName,
 859     int nQName,
 860     ISAXAttributes *attr)
 861 {
 862     mxwriter *This = impl_from_ISAXContentHandler( iface );
 863     xmlChar *s;
 864
 865     TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_wn(namespaceUri, nnamespaceUri),
 866         debugstr_wn(local_name, nlocal_name), debugstr_wn(QName, nQName), attr);
 867
 868     if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6)
 869         return E_INVALIDARG;
 870
 871     close_element_starttag(This);
 872     set_element_name(This, QName ? QName  : emptyW,
 873                            QName ? nQName : 0);
 874
 875     write_output_buffer(This, "<", 1);
 876     s = xmlchar_from_wcharn(QName, nQName);
 877     write_output_buffer_str(This, (char*)s);
 878     heap_free(s);
 879
 880     if (attr)
 881     {
 882         HRESULT hr;
 883         INT length;
 884         INT i;
 885
 886         hr = ISAXAttributes_getLength(attr, &length);
 887         if (FAILED(hr)) return hr;
 888
 889         for (i = 0; i < length; i++)
 890         {
 891             const WCHAR *str;
 892             WCHAR *escaped;
 893             INT len = 0;
 894
 895             hr = ISAXAttributes_getQName(attr, i, &str, &len);
 896             if (FAILED(hr)) return hr;
 897
 898             /* space separator in front of every attribute */
 899             write_output_buffer(This, " ", 1);
 900
 901             s = xmlchar_from_wcharn(str, len);
 902             write_output_buffer_str(This, (char*)s);
 903             heap_free(s);
 904
 905             write_output_buffer(This, "=\"", 2);
 906
 907             len = 0;
 908             hr = ISAXAttributes_getValue(attr, i, &str, &len);
 909             if (FAILED(hr)) return hr;
 910
 911             escaped = get_escaped_string(str, &len);
 912             s = xmlchar_from_wcharn(escaped, len);
 913             write_output_buffer_str(This, (char*)s);
 914             heap_free(escaped);
 915             heap_free(s);
 916
 917             write_output_buffer(This, "\"", 1);
 918         }
 919     }
 920
 921     return S_OK;
 922 }
 923
 924 static HRESULT WINAPI mxwriter_saxcontent_endElement(
 925     ISAXContentHandler *iface,
 926     const WCHAR *namespaceUri,
 927     int nnamespaceUri,
 928     const WCHAR * local_name,
 929     int nlocal_name,
 930     const WCHAR *QName,
 931     int nQName)
 932 {
 933     mxwriter *This = impl_from_ISAXContentHandler( iface );
 934
 935     TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri,
 936         debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName);
 937
 938     if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6)
 939         return E_INVALIDARG;
 940
 941     if (This->element && QName && !strncmpW(This->element, QName, nQName))
 942     {
 943         write_output_buffer(This, "/>", 2);
 944     }
 945     else
 946     {
 947         xmlChar *s = xmlchar_from_wcharn(QName, nQName);
 948
 949         write_output_buffer(This, "</", 2);
 950         write_output_buffer_str(This, (char*)s);
 951         write_output_buffer(This, ">", 1);
 952
 953         heap_free(s);
 954     }
 955
 956     set_element_name(This, NULL, 0);
 957
 958     return S_OK;
 959 }
 960
 961 static HRESULT WINAPI mxwriter_saxcontent_characters(
 962     ISAXContentHandler *iface,
 963     const WCHAR *chars,
 964     int nchars)
 965 {
 966     mxwriter *This = impl_from_ISAXContentHandler( iface );
 967
 968     TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
 969
 970     if (!chars) return E_INVALIDARG;
 971
 972     close_element_starttag(This);
 973     set_element_name(This, NULL, 0);
 974
 975     if (nchars)
 976     {
 977         xmlChar *s = xmlchar_from_wcharn(chars, nchars);
 978         write_output_buffer_str(This, (char*)s);
 979         heap_free(s);
 980     }
 981
 982     return S_OK;
 983 }
 984
 985 static HRESULT WINAPI mxwriter_saxcontent_ignorableWhitespace(
 986     ISAXContentHandler *iface,
 987     const WCHAR *chars,
 988     int nchars)
 989 {
 990     mxwriter *This = impl_from_ISAXContentHandler( iface );
 991     FIXME("(%p)->(%s)\n", This, debugstr_wn(chars, nchars));
 992     return E_NOTIMPL;
 993 }
 994
 995 static HRESULT WINAPI mxwriter_saxcontent_processingInstruction(
 996     ISAXContentHandler *iface,
 997     const WCHAR *target,
 998     int ntarget,
 999     const WCHAR *data,
1000     int ndata)
1001 {
1002     mxwriter *This = impl_from_ISAXContentHandler( iface );
1003     FIXME("(%p)->(%s %s)\n", This, debugstr_wn(target, ntarget), debugstr_wn(data, ndata));
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI mxwriter_saxcontent_skippedEntity(
1008     ISAXContentHandler *iface,
1009     const WCHAR *name,
1010     int nname)
1011 {
1012     mxwriter *This = impl_from_ISAXContentHandler( iface );
1013     FIXME("(%p)->(%s)\n", This, debugstr_wn(name, nname));
1014     return E_NOTIMPL;
1015 }
1016
1017 static const struct ISAXContentHandlerVtbl mxwriter_saxcontent_vtbl =
1018 {
1019     mxwriter_saxcontent_QueryInterface,
1020     mxwriter_saxcontent_AddRef,
1021     mxwriter_saxcontent_Release,
1022     mxwriter_saxcontent_putDocumentLocator,
1023     mxwriter_saxcontent_startDocument,
1024     mxwriter_saxcontent_endDocument,
1025     mxwriter_saxcontent_startPrefixMapping,
1026     mxwriter_saxcontent_endPrefixMapping,
1027     mxwriter_saxcontent_startElement,
1028     mxwriter_saxcontent_endElement,
1029     mxwriter_saxcontent_characters,
1030     mxwriter_saxcontent_ignorableWhitespace,
1031     mxwriter_saxcontent_processingInstruction,
1032     mxwriter_saxcontent_skippedEntity
1033 };
1034
1035 static const tid_t mxwriter_iface_tids[] = {
1036     IMXWriter_tid,
1037     0
1038 };
1039
1040 static dispex_static_data_t mxwriter_dispex = {
1041     NULL,
1042     IMXWriter_tid,
1043     NULL,
1044     mxwriter_iface_tids
1045 };
1046
1047 HRESULT MXWriter_create(MSXML_VERSION version, IUnknown *outer, void **ppObj)
1048 {
1049     static const WCHAR version10W[] = {'1','.','0',0};
1050     mxwriter *This;
1051
1052     TRACE("(%p, %p)\n", outer, ppObj);
1053
1054     if (outer) FIXME("support aggregation, outer\n");
1055
1056     This = heap_alloc( sizeof (*This) );
1057     if(!This)
1058         return E_OUTOFMEMORY;
1059
1060     This->IMXWriter_iface.lpVtbl = &MXWriterVtbl;
1061     This->ISAXContentHandler_iface.lpVtbl = &mxwriter_saxcontent_vtbl;
1062     This->ref = 1;
1063     This->class_version = version;
1064
1065     This->props[MXWriter_BOM] = VARIANT_TRUE;
1066     This->props[MXWriter_DisableEscaping] = VARIANT_FALSE;
1067     This->props[MXWriter_Indent] = VARIANT_FALSE;
1068     This->props[MXWriter_OmitXmlDecl] = VARIANT_FALSE;
1069     This->props[MXWriter_Standalone] = VARIANT_FALSE;
1070     This->prop_changed = FALSE;
1071     This->encoding = xmlParseCharEncoding("UTF-16");
1072     This->version  = SysAllocString(version10W);
1073
1074     This->element = NULL;
1075
1076     This->decl_count = 0;
1077     This->decl_written = 0;
1078
1079     This->dest = NULL;
1080     This->dest_written = 0;
1081
1082     This->buffer = xmlAllocOutputBuffer(xmlGetCharEncodingHandler(This->encoding));
1083
1084     init_dispex(&This->dispex, (IUnknown*)&This->IMXWriter_iface, &mxwriter_dispex);
1085
1086     *ppObj = &This->IMXWriter_iface;
1087
1088     TRACE("returning iface %p\n", *ppObj);
1089
1090     return S_OK;
1091 }
1092
1093 #else
1094
1095 HRESULT MXWriter_create(MSXML_VERSION version, IUnknown *outer, void **obj)
1096 {
1097     MESSAGE("This program tried to use a MXXMLWriter object, but\n"
1098             "libxml2 support was not present at compile time.\n");
1099     return E_NOTIMPL;
1100 }
1101
1102 #endif /* HAVE_LIBXML2 */