dlls/msxml3/mxwriter.c

   1 /*
   2  *    MXWriter implementation
   3  *
   4  * Copyright 2011-2012 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 static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
  43 static const WCHAR emptyW[] = {0};
  44 static const WCHAR spaceW[] = {' '};
  45 static const WCHAR quotW[]  = {'\"'};
  46
  47 typedef enum
  48 {
  49     XmlEncoding_UTF8,
  50     XmlEncoding_UTF16,
  51     XmlEncoding_Unknown
  52 } xml_encoding;
  53
  54 typedef enum
  55 {
  56     OutputBuffer_Native  = 0x001,
  57     OutputBuffer_Encoded = 0x010,
  58     OutputBuffer_Both    = 0x100
  59 } output_mode;
  60
  61 typedef enum
  62 {
  63     MXWriter_BOM = 0,
  64     MXWriter_DisableEscaping,
  65     MXWriter_Indent,
  66     MXWriter_OmitXmlDecl,
  67     MXWriter_Standalone,
  68     MXWriter_LastProp
  69 } mxwriter_prop;
  70
  71 typedef enum
  72 {
  73     EscapeValue,
  74     EscapeText
  75 } escape_mode;
  76
  77 typedef struct
  78 {
  79     char *data;
  80     unsigned int allocated;
  81     unsigned int written;
  82 } encoded_buffer;
  83
  84 typedef struct
  85 {
  86     encoded_buffer utf16;
  87     encoded_buffer encoded;
  88     UINT code_page;
  89 } output_buffer;
  90
  91 typedef struct
  92 {
  93     DispatchEx dispex;
  94     IMXWriter IMXWriter_iface;
  95     ISAXContentHandler ISAXContentHandler_iface;
  96     ISAXLexicalHandler ISAXLexicalHandler_iface;
  97     ISAXDeclHandler    ISAXDeclHandler_iface;
  98
  99     LONG ref;
 100     MSXML_VERSION class_version;
 101
 102     VARIANT_BOOL props[MXWriter_LastProp];
 103     BOOL prop_changed;
 104     BOOL cdata;
 105
 106     BSTR version;
 107
 108     BSTR encoding; /* exact property value */
 109     xml_encoding xml_enc;
 110
 111     /* contains a pending (or not closed yet) element name or NULL if
 112        we don't have to close */
 113     BSTR element;
 114
 115     IStream *dest;
 116     ULONG dest_written;
 117
 118     output_buffer *buffer;
 119 } mxwriter;
 120
 121 static xml_encoding parse_encoding_name(const WCHAR *encoding)
 122 {
 123     static const WCHAR utf8W[]  = {'U','T','F','-','8',0};
 124     if (!strcmpiW(encoding, utf8W))  return XmlEncoding_UTF8;
 125     if (!strcmpiW(encoding, utf16W)) return XmlEncoding_UTF16;
 126     return XmlEncoding_Unknown;
 127 }
 128
 129 static HRESULT init_encoded_buffer(encoded_buffer *buffer)
 130 {
 131     const int initial_len = 0x2000;
 132     buffer->data = heap_alloc(initial_len);
 133     if (!buffer->data) return E_OUTOFMEMORY;
 134
 135     memset(buffer->data, 0, 4);
 136     buffer->allocated = initial_len;
 137     buffer->written = 0;
 138
 139     return S_OK;
 140 }
 141
 142 static void free_encoded_buffer(encoded_buffer *buffer)
 143 {
 144     heap_free(buffer->data);
 145 }
 146
 147 static HRESULT get_code_page(xml_encoding encoding, UINT *cp)
 148 {
 149     switch (encoding)
 150     {
 151     case XmlEncoding_UTF8:
 152         *cp = CP_UTF8;
 153         break;
 154     case XmlEncoding_UTF16:
 155         *cp = ~0;
 156         break;
 157     default:
 158         FIXME("unsupported encoding %d\n", encoding);
 159         return E_NOTIMPL;
 160     }
 161
 162     return S_OK;
 163 }
 164
 165 static HRESULT alloc_output_buffer(xml_encoding encoding, output_buffer **buffer)
 166 {
 167     output_buffer *ret;
 168     HRESULT hr;
 169
 170     ret = heap_alloc(sizeof(*ret));
 171     if (!ret) return E_OUTOFMEMORY;
 172
 173     hr = get_code_page(encoding, &ret->code_page);
 174     if (hr != S_OK) {
 175         heap_free(ret);
 176         return hr;
 177     }
 178
 179     hr = init_encoded_buffer(&ret->utf16);
 180     if (hr != S_OK) {
 181         heap_free(ret);
 182         return hr;
 183     }
 184
 185     if (ret->code_page == CP_UTF8) {
 186         hr = init_encoded_buffer(&ret->encoded);
 187         if (hr != S_OK) {
 188             free_encoded_buffer(&ret->utf16);
 189             heap_free(ret);
 190             return hr;
 191         }
 192     }
 193     else
 194         memset(&ret->encoded, 0, sizeof(ret->encoded));
 195
 196     *buffer = ret;
 197
 198     return S_OK;
 199 }
 200
 201 static void free_output_buffer(output_buffer *buffer)
 202 {
 203     free_encoded_buffer(&buffer->encoded);
 204     free_encoded_buffer(&buffer->utf16);
 205     heap_free(buffer);
 206 }
 207
 208 static void grow_buffer(encoded_buffer *buffer, int length)
 209 {
 210     /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
 211     if (buffer->allocated < buffer->written + length + 4)
 212     {
 213         int grown_size = max(2*buffer->allocated, buffer->allocated + length);
 214         buffer->data = heap_realloc(buffer->data, grown_size);
 215         buffer->allocated = grown_size;
 216     }
 217 }
 218
 219 static HRESULT write_output_buffer_mode(output_buffer *buffer, output_mode mode, const WCHAR *data, int len)
 220 {
 221     int length;
 222     char *ptr;
 223
 224     if (mode & (OutputBuffer_Encoded | OutputBuffer_Both)) {
 225         if (buffer->code_page == CP_UTF8)
 226         {
 227             length = WideCharToMultiByte(buffer->code_page, 0, data, len, NULL, 0, NULL, NULL);
 228             grow_buffer(&buffer->encoded, length);
 229             ptr = buffer->encoded.data + buffer->encoded.written;
 230             length = WideCharToMultiByte(buffer->code_page, 0, data, len, ptr, length, NULL, NULL);
 231             buffer->encoded.written += len == -1 ? length-1 : length;
 232         }
 233     }
 234
 235     if (mode & (OutputBuffer_Native | OutputBuffer_Both)) {
 236         /* WCHAR data just copied */
 237         length = len == -1 ? strlenW(data) : len;
 238         if (length)
 239         {
 240             length *= sizeof(WCHAR);
 241
 242             grow_buffer(&buffer->utf16, length);
 243             ptr = buffer->utf16.data + buffer->utf16.written;
 244
 245             memcpy(ptr, data, length);
 246             buffer->utf16.written += length;
 247             ptr += length;
 248             /* null termination */
 249             memset(ptr, 0, sizeof(WCHAR));
 250         }
 251     }
 252
 253     return S_OK;
 254 }
 255
 256 static HRESULT write_output_buffer(output_buffer *buffer, const WCHAR *data, int len)
 257 {
 258     return write_output_buffer_mode(buffer, OutputBuffer_Both, data, len);
 259 }
 260
 261 static HRESULT write_output_buffer_quoted(output_buffer *buffer, const WCHAR *data, int len)
 262 {
 263     write_output_buffer(buffer, quotW, 1);
 264     write_output_buffer(buffer, data, len);
 265     write_output_buffer(buffer, quotW, 1);
 266
 267     return S_OK;
 268 }
 269
 270 /* frees buffer data, reallocates with a default lengths */
 271 static void close_output_buffer(mxwriter *This)
 272 {
 273     heap_free(This->buffer->utf16.data);
 274     heap_free(This->buffer->encoded.data);
 275     init_encoded_buffer(&This->buffer->utf16);
 276     init_encoded_buffer(&This->buffer->encoded);
 277     get_code_page(This->xml_enc, &This->buffer->code_page);
 278 }
 279
 280 /* escapes special characters like:
 281    '<' -> "&lt;"
 282    '&' -> "&amp;"
 283    '"' -> "&quot;"
 284    '>' -> "&gt;"
 285 */
 286 static WCHAR *get_escaped_string(const WCHAR *str, escape_mode mode, int *len)
 287 {
 288     static const WCHAR ltW[]    = {'&','l','t',';'};
 289     static const WCHAR ampW[]   = {'&','a','m','p',';'};
 290     static const WCHAR equotW[] = {'&','q','u','o','t',';'};
 291     static const WCHAR gtW[]    = {'&','g','t',';'};
 292
 293     const int default_alloc = 100;
 294     const int grow_thresh = 10;
 295     int p = *len, conv_len;
 296     WCHAR *ptr, *ret;
 297
 298     /* default buffer size to something if length is unknown */
 299     conv_len = *len == -1 ? default_alloc : max(2**len, default_alloc);
 300     ptr = ret = heap_alloc(conv_len*sizeof(WCHAR));
 301
 302     while (*str && p)
 303     {
 304         if (ptr - ret > conv_len - grow_thresh)
 305         {
 306             int written = ptr - ret;
 307             conv_len *= 2;
 308             ptr = ret = heap_realloc(ret, conv_len*sizeof(WCHAR));
 309             ptr += written;
 310         }
 311
 312         switch (*str)
 313         {
 314         case '<':
 315             memcpy(ptr, ltW, sizeof(ltW));
 316             ptr += sizeof(ltW)/sizeof(WCHAR);
 317             break;
 318         case '&':
 319             memcpy(ptr, ampW, sizeof(ampW));
 320             ptr += sizeof(ampW)/sizeof(WCHAR);
 321             break;
 322         case '>':
 323             memcpy(ptr, gtW, sizeof(gtW));
 324             ptr += sizeof(gtW)/sizeof(WCHAR);
 325             break;
 326         case '"':
 327             if (mode == EscapeValue)
 328             {
 329                 memcpy(ptr, equotW, sizeof(equotW));
 330                 ptr += sizeof(equotW)/sizeof(WCHAR);
 331                 break;
 332             }
 333             /* fallthrough for text mode */
 334         default:
 335             *ptr++ = *str;
 336             break;
 337         }
 338
 339         str++;
 340         if (*len != -1) p--;
 341     }
 342
 343     if (*len != -1) *len = ptr-ret;
 344     *++ptr = 0;
 345
 346     return ret;
 347 }
 348
 349 static void write_prolog_buffer(const mxwriter *This)
 350 {
 351     static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','='};
 352     static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','=','\"'};
 353     static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
 354     static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
 355     static const WCHAR noW[] = {'n','o','\"','?','>'};
 356     static const WCHAR crlfW[] = {'\r','\n'};
 357
 358     /* version */
 359     write_output_buffer(This->buffer, versionW, sizeof(versionW)/sizeof(WCHAR));
 360     write_output_buffer_quoted(This->buffer, This->version, -1);
 361
 362     /* encoding */
 363     write_output_buffer(This->buffer, encodingW, sizeof(encodingW)/sizeof(WCHAR));
 364
 365     /* always write UTF-16 to WCHAR buffer */
 366     write_output_buffer_mode(This->buffer, OutputBuffer_Native, utf16W, sizeof(utf16W)/sizeof(WCHAR) - 1);
 367     write_output_buffer_mode(This->buffer, OutputBuffer_Encoded, This->encoding, -1);
 368     write_output_buffer(This->buffer, quotW, 1);
 369
 370     /* standalone */
 371     write_output_buffer(This->buffer, standaloneW, sizeof(standaloneW)/sizeof(WCHAR));
 372     if (This->props[MXWriter_Standalone] == VARIANT_TRUE)
 373         write_output_buffer(This->buffer, yesW, sizeof(yesW)/sizeof(WCHAR));
 374     else
 375         write_output_buffer(This->buffer, noW, sizeof(noW)/sizeof(WCHAR));
 376
 377     write_output_buffer(This->buffer, crlfW, sizeof(crlfW)/sizeof(WCHAR));
 378 }
 379
 380 /* Attempts to the write data from the mxwriter's buffer to
 381  * the destination stream (if there is one).
 382  */
 383 static HRESULT write_data_to_stream(mxwriter *This)
 384 {
 385     encoded_buffer *buffer;
 386     ULONG written = 0;
 387     HRESULT hr;
 388
 389     if (!This->dest)
 390         return S_OK;
 391
 392     if (This->xml_enc != XmlEncoding_UTF16)
 393         buffer = &This->buffer->encoded;
 394     else
 395         buffer = &This->buffer->utf16;
 396
 397     if (This->dest_written > buffer->written) {
 398         ERR("Failed sanity check! Not sure what to do... (%d > %d)\n", This->dest_written, buffer->written);
 399         return E_FAIL;
 400     } else if (This->dest_written == buffer->written && This->xml_enc != XmlEncoding_UTF8)
 401         /* Windows seems to make an empty write call when the encoding is UTF-8 and
 402          * all the data has been written to the stream. It doesn't seem make this call
 403          * for any other encodings.
 404          */
 405         return S_OK;
 406
 407     /* Write the current content from the output buffer into 'dest'.
 408      * TODO: Check what Windows does if the IStream doesn't write all of
 409      *       the data we give it at once.
 410      */
 411     hr = IStream_Write(This->dest, buffer->data+This->dest_written,
 412                          buffer->written-This->dest_written, &written);
 413     if (FAILED(hr)) {
 414         WARN("Failed to write data to IStream (0x%08x)\n", hr);
 415         return hr;
 416     }
 417
 418     This->dest_written += written;
 419     return hr;
 420 }
 421
 422 /* Newly added element start tag left unclosed cause for empty elements
 423    we have to close it differently. */
 424 static void close_element_starttag(const mxwriter *This)
 425 {
 426     static const WCHAR gtW[] = {'>'};
 427     if (!This->element) return;
 428     write_output_buffer(This->buffer, gtW, 1);
 429 }
 430
 431 static void set_element_name(mxwriter *This, const WCHAR *name, int len)
 432 {
 433     SysFreeString(This->element);
 434     This->element = name ? SysAllocStringLen(name, len) : NULL;
 435 }
 436
 437 static inline HRESULT flush_output_buffer(mxwriter *This)
 438 {
 439     close_element_starttag(This);
 440     set_element_name(This, NULL, 0);
 441     This->cdata = FALSE;
 442     return write_data_to_stream(This);
 443 }
 444
 445 /* Resets the mxwriter's output buffer by closing it, then creating a new
 446  * output buffer using the given encoding.
 447  */
 448 static inline void reset_output_buffer(mxwriter *This)
 449 {
 450     close_output_buffer(This);
 451     This->dest_written = 0;
 452 }
 453
 454 static HRESULT writer_set_property(mxwriter *writer, mxwriter_prop property, VARIANT_BOOL value)
 455 {
 456     writer->props[property] = value;
 457     writer->prop_changed = TRUE;
 458     return S_OK;
 459 }
 460
 461 static HRESULT writer_get_property(const mxwriter *writer, mxwriter_prop property, VARIANT_BOOL *value)
 462 {
 463     if (!value) return E_POINTER;
 464     *value = writer->props[property];
 465     return S_OK;
 466 }
 467
 468 static inline mxwriter *impl_from_IMXWriter(IMXWriter *iface)
 469 {
 470     return CONTAINING_RECORD(iface, mxwriter, IMXWriter_iface);
 471 }
 472
 473 static inline mxwriter *impl_from_ISAXContentHandler(ISAXContentHandler *iface)
 474 {
 475     return CONTAINING_RECORD(iface, mxwriter, ISAXContentHandler_iface);
 476 }
 477
 478 static inline mxwriter *impl_from_ISAXLexicalHandler(ISAXLexicalHandler *iface)
 479 {
 480     return CONTAINING_RECORD(iface, mxwriter, ISAXLexicalHandler_iface);
 481 }
 482
 483 static inline mxwriter *impl_from_ISAXDeclHandler(ISAXDeclHandler *iface)
 484 {
 485     return CONTAINING_RECORD(iface, mxwriter, ISAXDeclHandler_iface);
 486 }
 487
 488 static HRESULT WINAPI mxwriter_QueryInterface(IMXWriter *iface, REFIID riid, void **obj)
 489 {
 490     mxwriter *This = impl_from_IMXWriter( iface );
 491
 492     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 493
 494     *obj = NULL;
 495
 496     if ( IsEqualGUID( riid, &IID_IMXWriter ) ||
 497          IsEqualGUID( riid, &IID_IDispatch ) ||
 498          IsEqualGUID( riid, &IID_IUnknown ) )
 499     {
 500         *obj = &This->IMXWriter_iface;
 501     }
 502     else if ( IsEqualGUID( riid, &IID_ISAXContentHandler ) )
 503     {
 504         *obj = &This->ISAXContentHandler_iface;
 505     }
 506     else if ( IsEqualGUID( riid, &IID_ISAXLexicalHandler ) )
 507     {
 508         *obj = &This->ISAXLexicalHandler_iface;
 509     }
 510     else if ( IsEqualGUID( riid, &IID_ISAXDeclHandler ) )
 511     {
 512         *obj = &This->ISAXDeclHandler_iface;
 513     }
 514     else if (dispex_query_interface(&This->dispex, riid, obj))
 515     {
 516         return *obj ? S_OK : E_NOINTERFACE;
 517     }
 518     else
 519     {
 520         ERR("interface %s not implemented\n", debugstr_guid(riid));
 521         *obj = NULL;
 522         return E_NOINTERFACE;
 523     }
 524
 525     IMXWriter_AddRef(iface);
 526     return S_OK;
 527 }
 528
 529 static ULONG WINAPI mxwriter_AddRef(IMXWriter *iface)
 530 {
 531     mxwriter *This = impl_from_IMXWriter( iface );
 532     LONG ref = InterlockedIncrement(&This->ref);
 533
 534     TRACE("(%p)->(%d)\n", This, ref);
 535
 536     return ref;
 537 }
 538
 539 static ULONG WINAPI mxwriter_Release(IMXWriter *iface)
 540 {
 541     mxwriter *This = impl_from_IMXWriter( iface );
 542     ULONG ref = InterlockedDecrement(&This->ref);
 543
 544     TRACE("(%p)->(%d)\n", This, ref);
 545
 546     if(!ref)
 547     {
 548         /* Windows flushes the buffer when the interface is destroyed. */
 549         flush_output_buffer(This);
 550         free_output_buffer(This->buffer);
 551
 552         if (This->dest) IStream_Release(This->dest);
 553         SysFreeString(This->version);
 554         SysFreeString(This->encoding);
 555
 556         SysFreeString(This->element);
 557         release_dispex(&This->dispex);
 558         heap_free(This);
 559     }
 560
 561     return ref;
 562 }
 563
 564 static HRESULT WINAPI mxwriter_GetTypeInfoCount(IMXWriter *iface, UINT* pctinfo)
 565 {
 566     mxwriter *This = impl_from_IMXWriter( iface );
 567     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 568 }
 569
 570 static HRESULT WINAPI mxwriter_GetTypeInfo(
 571     IMXWriter *iface,
 572     UINT iTInfo, LCID lcid,
 573     ITypeInfo** ppTInfo )
 574 {
 575     mxwriter *This = impl_from_IMXWriter( iface );
 576     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 577         iTInfo, lcid, ppTInfo);
 578 }
 579
 580 static HRESULT WINAPI mxwriter_GetIDsOfNames(
 581     IMXWriter *iface,
 582     REFIID riid, LPOLESTR* rgszNames,
 583     UINT cNames, LCID lcid, DISPID* rgDispId )
 584 {
 585     mxwriter *This = impl_from_IMXWriter( iface );
 586     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 587         riid, rgszNames, cNames, lcid, rgDispId);
 588 }
 589
 590 static HRESULT WINAPI mxwriter_Invoke(
 591     IMXWriter *iface,
 592     DISPID dispIdMember, REFIID riid, LCID lcid,
 593     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 594     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 595 {
 596     mxwriter *This = impl_from_IMXWriter( iface );
 597     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 598         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 599 }
 600
 601 static HRESULT WINAPI mxwriter_put_output(IMXWriter *iface, VARIANT dest)
 602 {
 603     mxwriter *This = impl_from_IMXWriter( iface );
 604     HRESULT hr;
 605
 606     TRACE("(%p)->(%s)\n", This, debugstr_variant(&dest));
 607
 608     hr = flush_output_buffer(This);
 609     if (FAILED(hr))
 610         return hr;
 611
 612     switch (V_VT(&dest))
 613     {
 614     case VT_EMPTY:
 615     {
 616         if (This->dest) IStream_Release(This->dest);
 617         This->dest = NULL;
 618         reset_output_buffer(This);
 619         break;
 620     }
 621     case VT_UNKNOWN:
 622     {
 623         IStream *stream;
 624
 625         hr = IUnknown_QueryInterface(V_UNKNOWN(&dest), &IID_IStream, (void**)&stream);
 626         if (hr == S_OK)
 627         {
 628             /* Recreate the output buffer to make sure it's using the correct encoding. */
 629             reset_output_buffer(This);
 630
 631             if (This->dest) IStream_Release(This->dest);
 632             This->dest = stream;
 633             break;
 634         }
 635
 636         FIXME("unhandled interface type for VT_UNKNOWN destination\n");
 637         return E_NOTIMPL;
 638     }
 639     default:
 640         FIXME("unhandled destination type %s\n", debugstr_variant(&dest));
 641         return E_NOTIMPL;
 642     }
 643
 644     return S_OK;
 645 }
 646
 647 static HRESULT WINAPI mxwriter_get_output(IMXWriter *iface, VARIANT *dest)
 648 {
 649     mxwriter *This = impl_from_IMXWriter( iface );
 650
 651     TRACE("(%p)->(%p)\n", This, dest);
 652
 653     if (!This->dest)
 654     {
 655         HRESULT hr = flush_output_buffer(This);
 656         if (FAILED(hr))
 657             return hr;
 658
 659         V_VT(dest)   = VT_BSTR;
 660         V_BSTR(dest) = SysAllocString((WCHAR*)This->buffer->utf16.data);
 661
 662         return S_OK;
 663     }
 664     else
 665         FIXME("not implemented when stream is set up\n");
 666
 667     return E_NOTIMPL;
 668 }
 669
 670 static HRESULT WINAPI mxwriter_put_encoding(IMXWriter *iface, BSTR encoding)
 671 {
 672     mxwriter *This = impl_from_IMXWriter( iface );
 673     xml_encoding enc;
 674     HRESULT hr;
 675
 676     TRACE("(%p)->(%s)\n", This, debugstr_w(encoding));
 677
 678     enc = parse_encoding_name(encoding);
 679     if (enc == XmlEncoding_Unknown)
 680     {
 681         FIXME("unsupported encoding %s\n", debugstr_w(encoding));
 682         return E_INVALIDARG;
 683     }
 684
 685     hr = flush_output_buffer(This);
 686     if (FAILED(hr))
 687         return hr;
 688
 689     SysReAllocString(&This->encoding, encoding);
 690     This->xml_enc = enc;
 691
 692     TRACE("got encoding %d\n", This->xml_enc);
 693     reset_output_buffer(This);
 694     return S_OK;
 695 }
 696
 697 static HRESULT WINAPI mxwriter_get_encoding(IMXWriter *iface, BSTR *encoding)
 698 {
 699     mxwriter *This = impl_from_IMXWriter( iface );
 700
 701     TRACE("(%p)->(%p)\n", This, encoding);
 702
 703     if (!encoding) return E_POINTER;
 704
 705     *encoding = SysAllocString(This->encoding);
 706     if (!*encoding) return E_OUTOFMEMORY;
 707
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI mxwriter_put_byteOrderMark(IMXWriter *iface, VARIANT_BOOL value)
 712 {
 713     mxwriter *This = impl_from_IMXWriter( iface );
 714
 715     TRACE("(%p)->(%d)\n", This, value);
 716     return writer_set_property(This, MXWriter_BOM, value);
 717 }
 718
 719 static HRESULT WINAPI mxwriter_get_byteOrderMark(IMXWriter *iface, VARIANT_BOOL *value)
 720 {
 721     mxwriter *This = impl_from_IMXWriter( iface );
 722
 723     TRACE("(%p)->(%p)\n", This, value);
 724     return writer_get_property(This, MXWriter_BOM, value);
 725 }
 726
 727 static HRESULT WINAPI mxwriter_put_indent(IMXWriter *iface, VARIANT_BOOL value)
 728 {
 729     mxwriter *This = impl_from_IMXWriter( iface );
 730
 731     TRACE("(%p)->(%d)\n", This, value);
 732     return writer_set_property(This, MXWriter_Indent, value);
 733 }
 734
 735 static HRESULT WINAPI mxwriter_get_indent(IMXWriter *iface, VARIANT_BOOL *value)
 736 {
 737     mxwriter *This = impl_from_IMXWriter( iface );
 738
 739     TRACE("(%p)->(%p)\n", This, value);
 740     return writer_get_property(This, MXWriter_Indent, value);
 741 }
 742
 743 static HRESULT WINAPI mxwriter_put_standalone(IMXWriter *iface, VARIANT_BOOL value)
 744 {
 745     mxwriter *This = impl_from_IMXWriter( iface );
 746
 747     TRACE("(%p)->(%d)\n", This, value);
 748     return writer_set_property(This, MXWriter_Standalone, value);
 749 }
 750
 751 static HRESULT WINAPI mxwriter_get_standalone(IMXWriter *iface, VARIANT_BOOL *value)
 752 {
 753     mxwriter *This = impl_from_IMXWriter( iface );
 754
 755     TRACE("(%p)->(%p)\n", This, value);
 756     return writer_get_property(This, MXWriter_Standalone, value);
 757 }
 758
 759 static HRESULT WINAPI mxwriter_put_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL value)
 760 {
 761     mxwriter *This = impl_from_IMXWriter( iface );
 762
 763     TRACE("(%p)->(%d)\n", This, value);
 764     return writer_set_property(This, MXWriter_OmitXmlDecl, value);
 765 }
 766
 767 static HRESULT WINAPI mxwriter_get_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL *value)
 768 {
 769     mxwriter *This = impl_from_IMXWriter( iface );
 770
 771     TRACE("(%p)->(%p)\n", This, value);
 772     return writer_get_property(This, MXWriter_OmitXmlDecl, value);
 773 }
 774
 775 static HRESULT WINAPI mxwriter_put_version(IMXWriter *iface, BSTR version)
 776 {
 777     mxwriter *This = impl_from_IMXWriter( iface );
 778
 779     TRACE("(%p)->(%s)\n", This, debugstr_w(version));
 780
 781     if (!version) return E_INVALIDARG;
 782
 783     SysFreeString(This->version);
 784     This->version = SysAllocString(version);
 785
 786     return S_OK;
 787 }
 788
 789 static HRESULT WINAPI mxwriter_get_version(IMXWriter *iface, BSTR *version)
 790 {
 791     mxwriter *This = impl_from_IMXWriter( iface );
 792
 793     TRACE("(%p)->(%p)\n", This, version);
 794
 795     if (!version) return E_POINTER;
 796
 797     return return_bstr(This->version, version);
 798 }
 799
 800 static HRESULT WINAPI mxwriter_put_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL value)
 801 {
 802     mxwriter *This = impl_from_IMXWriter( iface );
 803
 804     TRACE("(%p)->(%d)\n", This, value);
 805     return writer_set_property(This, MXWriter_DisableEscaping, value);
 806 }
 807
 808 static HRESULT WINAPI mxwriter_get_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL *value)
 809 {
 810     mxwriter *This = impl_from_IMXWriter( iface );
 811
 812     TRACE("(%p)->(%p)\n", This, value);
 813     return writer_get_property(This, MXWriter_DisableEscaping, value);
 814 }
 815
 816 static HRESULT WINAPI mxwriter_flush(IMXWriter *iface)
 817 {
 818     mxwriter *This = impl_from_IMXWriter( iface );
 819     TRACE("(%p)\n", This);
 820     return flush_output_buffer(This);
 821 }
 822
 823 static const struct IMXWriterVtbl MXWriterVtbl =
 824 {
 825     mxwriter_QueryInterface,
 826     mxwriter_AddRef,
 827     mxwriter_Release,
 828     mxwriter_GetTypeInfoCount,
 829     mxwriter_GetTypeInfo,
 830     mxwriter_GetIDsOfNames,
 831     mxwriter_Invoke,
 832     mxwriter_put_output,
 833     mxwriter_get_output,
 834     mxwriter_put_encoding,
 835     mxwriter_get_encoding,
 836     mxwriter_put_byteOrderMark,
 837     mxwriter_get_byteOrderMark,
 838     mxwriter_put_indent,
 839     mxwriter_get_indent,
 840     mxwriter_put_standalone,
 841     mxwriter_get_standalone,
 842     mxwriter_put_omitXMLDeclaration,
 843     mxwriter_get_omitXMLDeclaration,
 844     mxwriter_put_version,
 845     mxwriter_get_version,
 846     mxwriter_put_disableOutputEscaping,
 847     mxwriter_get_disableOutputEscaping,
 848     mxwriter_flush
 849 };
 850
 851 /*** ISAXContentHandler ***/
 852 static HRESULT WINAPI SAXContentHandler_QueryInterface(
 853     ISAXContentHandler *iface,
 854     REFIID riid,
 855     void **obj)
 856 {
 857     mxwriter *This = impl_from_ISAXContentHandler( iface );
 858     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
 859 }
 860
 861 static ULONG WINAPI SAXContentHandler_AddRef(ISAXContentHandler *iface)
 862 {
 863     mxwriter *This = impl_from_ISAXContentHandler( iface );
 864     return IMXWriter_AddRef(&This->IMXWriter_iface);
 865 }
 866
 867 static ULONG WINAPI SAXContentHandler_Release(ISAXContentHandler *iface)
 868 {
 869     mxwriter *This = impl_from_ISAXContentHandler( iface );
 870     return IMXWriter_Release(&This->IMXWriter_iface);
 871 }
 872
 873 static HRESULT WINAPI SAXContentHandler_putDocumentLocator(
 874     ISAXContentHandler *iface,
 875     ISAXLocator *locator)
 876 {
 877     mxwriter *This = impl_from_ISAXContentHandler( iface );
 878     FIXME("(%p)->(%p)\n", This, locator);
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI SAXContentHandler_startDocument(ISAXContentHandler *iface)
 883 {
 884     mxwriter *This = impl_from_ISAXContentHandler( iface );
 885
 886     TRACE("(%p)\n", This);
 887
 888     /* If properties have been changed since the last "endDocument" call
 889      * we need to reset the output buffer. If we don't the output buffer
 890      * could end up with multiple XML documents in it, plus this seems to
 891      * be how Windows works.
 892      */
 893     if (This->prop_changed) {
 894         reset_output_buffer(This);
 895         This->prop_changed = FALSE;
 896     }
 897
 898     if (This->props[MXWriter_OmitXmlDecl] == VARIANT_TRUE) return S_OK;
 899
 900     write_prolog_buffer(This);
 901
 902     if (This->dest && This->xml_enc == XmlEncoding_UTF16) {
 903         static const char utf16BOM[] = {0xff,0xfe};
 904
 905         if (This->props[MXWriter_BOM] == VARIANT_TRUE)
 906             /* Windows passes a NULL pointer as the pcbWritten parameter and
 907              * ignores any error codes returned from this Write call.
 908              */
 909             IStream_Write(This->dest, utf16BOM, sizeof(utf16BOM), NULL);
 910     }
 911
 912     return S_OK;
 913 }
 914
 915 static HRESULT WINAPI SAXContentHandler_endDocument(ISAXContentHandler *iface)
 916 {
 917     mxwriter *This = impl_from_ISAXContentHandler( iface );
 918     TRACE("(%p)\n", This);
 919     This->prop_changed = FALSE;
 920     return flush_output_buffer(This);
 921 }
 922
 923 static HRESULT WINAPI SAXContentHandler_startPrefixMapping(
 924     ISAXContentHandler *iface,
 925     const WCHAR *prefix,
 926     int nprefix,
 927     const WCHAR *uri,
 928     int nuri)
 929 {
 930     mxwriter *This = impl_from_ISAXContentHandler( iface );
 931     FIXME("(%p)->(%s %s)\n", This, debugstr_wn(prefix, nprefix), debugstr_wn(uri, nuri));
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI SAXContentHandler_endPrefixMapping(
 936     ISAXContentHandler *iface,
 937     const WCHAR *prefix,
 938     int nprefix)
 939 {
 940     mxwriter *This = impl_from_ISAXContentHandler( iface );
 941     FIXME("(%p)->(%s)\n", This, debugstr_wn(prefix, nprefix));
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI SAXContentHandler_startElement(
 946     ISAXContentHandler *iface,
 947     const WCHAR *namespaceUri,
 948     int nnamespaceUri,
 949     const WCHAR *local_name,
 950     int nlocal_name,
 951     const WCHAR *QName,
 952     int nQName,
 953     ISAXAttributes *attr)
 954 {
 955     mxwriter *This = impl_from_ISAXContentHandler( iface );
 956     static const WCHAR ltW[] = {'<'};
 957
 958     TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_wn(namespaceUri, nnamespaceUri),
 959         debugstr_wn(local_name, nlocal_name), debugstr_wn(QName, nQName), attr);
 960
 961     if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6)
 962         return E_INVALIDARG;
 963
 964     close_element_starttag(This);
 965     set_element_name(This, QName ? QName  : emptyW,
 966                            QName ? nQName : 0);
 967
 968     write_output_buffer(This->buffer, ltW, 1);
 969     write_output_buffer(This->buffer, QName, nQName);
 970
 971     if (attr)
 972     {
 973         HRESULT hr;
 974         INT length;
 975         INT i;
 976
 977         hr = ISAXAttributes_getLength(attr, &length);
 978         if (FAILED(hr)) return hr;
 979
 980         for (i = 0; i < length; i++)
 981         {
 982             static const WCHAR eqW[] = {'='};
 983             const WCHAR *str;
 984             WCHAR *escaped;
 985             INT len = 0;
 986
 987             hr = ISAXAttributes_getQName(attr, i, &str, &len);
 988             if (FAILED(hr)) return hr;
 989
 990             /* space separator in front of every attribute */
 991             write_output_buffer(This->buffer, spaceW, 1);
 992             write_output_buffer(This->buffer, str, len);
 993
 994             write_output_buffer(This->buffer, eqW, 1);
 995
 996             len = 0;
 997             hr = ISAXAttributes_getValue(attr, i, &str, &len);
 998             if (FAILED(hr)) return hr;
 999
1000             escaped = get_escaped_string(str, EscapeValue, &len);
1001             write_output_buffer_quoted(This->buffer, escaped, len);
1002             heap_free(escaped);
1003         }
1004     }
1005
1006     return S_OK;
1007 }
1008
1009 static HRESULT WINAPI SAXContentHandler_endElement(
1010     ISAXContentHandler *iface,
1011     const WCHAR *namespaceUri,
1012     int nnamespaceUri,
1013     const WCHAR * local_name,
1014     int nlocal_name,
1015     const WCHAR *QName,
1016     int nQName)
1017 {
1018     mxwriter *This = impl_from_ISAXContentHandler( iface );
1019
1020     TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri,
1021         debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName);
1022
1023     if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6)
1024         return E_INVALIDARG;
1025
1026     if (This->element && QName && !strncmpW(This->element, QName, nQName))
1027     {
1028         static const WCHAR closeW[] = {'/','>'};
1029
1030         write_output_buffer(This->buffer, closeW, 2);
1031     }
1032     else
1033     {
1034         static const WCHAR closetagW[] = {'<','/'};
1035         static const WCHAR gtW[] = {'>'};
1036
1037         write_output_buffer(This->buffer, closetagW, 2);
1038         write_output_buffer(This->buffer, QName, nQName);
1039         write_output_buffer(This->buffer, gtW, 1);
1040     }
1041
1042     set_element_name(This, NULL, 0);
1043
1044     return S_OK;
1045 }
1046
1047 static HRESULT WINAPI SAXContentHandler_characters(
1048     ISAXContentHandler *iface,
1049     const WCHAR *chars,
1050     int nchars)
1051 {
1052     mxwriter *This = impl_from_ISAXContentHandler( iface );
1053
1054     TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
1055
1056     if (!chars) return E_INVALIDARG;
1057
1058     close_element_starttag(This);
1059     set_element_name(This, NULL, 0);
1060
1061     if (nchars)
1062     {
1063         if (This->cdata)
1064             write_output_buffer(This->buffer, chars, nchars);
1065         else
1066         {
1067             int len = nchars;
1068             WCHAR *escaped;
1069
1070             escaped = get_escaped_string(chars, EscapeText, &len);
1071             write_output_buffer(This->buffer, escaped, len);
1072             heap_free(escaped);
1073         }
1074     }
1075
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI SAXContentHandler_ignorableWhitespace(
1080     ISAXContentHandler *iface,
1081     const WCHAR *chars,
1082     int nchars)
1083 {
1084     mxwriter *This = impl_from_ISAXContentHandler( iface );
1085     FIXME("(%p)->(%s)\n", This, debugstr_wn(chars, nchars));
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI SAXContentHandler_processingInstruction(
1090     ISAXContentHandler *iface,
1091     const WCHAR *target,
1092     int ntarget,
1093     const WCHAR *data,
1094     int ndata)
1095 {
1096     mxwriter *This = impl_from_ISAXContentHandler( iface );
1097     FIXME("(%p)->(%s %s)\n", This, debugstr_wn(target, ntarget), debugstr_wn(data, ndata));
1098     return E_NOTIMPL;
1099 }
1100
1101 static HRESULT WINAPI SAXContentHandler_skippedEntity(
1102     ISAXContentHandler *iface,
1103     const WCHAR *name,
1104     int nname)
1105 {
1106     mxwriter *This = impl_from_ISAXContentHandler( iface );
1107     FIXME("(%p)->(%s)\n", This, debugstr_wn(name, nname));
1108     return E_NOTIMPL;
1109 }
1110
1111 static const struct ISAXContentHandlerVtbl SAXContentHandlerVtbl =
1112 {
1113     SAXContentHandler_QueryInterface,
1114     SAXContentHandler_AddRef,
1115     SAXContentHandler_Release,
1116     SAXContentHandler_putDocumentLocator,
1117     SAXContentHandler_startDocument,
1118     SAXContentHandler_endDocument,
1119     SAXContentHandler_startPrefixMapping,
1120     SAXContentHandler_endPrefixMapping,
1121     SAXContentHandler_startElement,
1122     SAXContentHandler_endElement,
1123     SAXContentHandler_characters,
1124     SAXContentHandler_ignorableWhitespace,
1125     SAXContentHandler_processingInstruction,
1126     SAXContentHandler_skippedEntity
1127 };
1128
1129 /*** ISAXLexicalHandler ***/
1130 static HRESULT WINAPI SAXLexicalHandler_QueryInterface(ISAXLexicalHandler *iface,
1131     REFIID riid, void **obj)
1132 {
1133     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1134     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
1135 }
1136
1137 static ULONG WINAPI SAXLexicalHandler_AddRef(ISAXLexicalHandler *iface)
1138 {
1139     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1140     return IMXWriter_AddRef(&This->IMXWriter_iface);
1141 }
1142
1143 static ULONG WINAPI SAXLexicalHandler_Release(ISAXLexicalHandler *iface)
1144 {
1145     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1146     return IMXWriter_Release(&This->IMXWriter_iface);
1147 }
1148
1149 static HRESULT WINAPI SAXLexicalHandler_startDTD(ISAXLexicalHandler *iface,
1150     const WCHAR *name, int name_len, const WCHAR *publicId, int publicId_len,
1151     const WCHAR *systemId, int systemId_len)
1152 {
1153     static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',' '};
1154     static const WCHAR openintW[] = {'[','\r','\n'};
1155
1156     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1157
1158     TRACE("(%p)->(%s %s %s)\n", This, debugstr_wn(name, name_len), debugstr_wn(publicId, publicId_len),
1159         debugstr_wn(systemId, systemId_len));
1160
1161     if (!name) return E_INVALIDARG;
1162
1163     write_output_buffer(This->buffer, doctypeW, sizeof(doctypeW)/sizeof(WCHAR));
1164
1165     if (*name)
1166     {
1167         write_output_buffer(This->buffer, name, name_len);
1168         write_output_buffer(This->buffer, spaceW, 1);
1169     }
1170
1171     if (publicId)
1172     {
1173         static const WCHAR publicW[] = {'P','U','B','L','I','C',' '};
1174
1175         write_output_buffer(This->buffer, publicW, sizeof(publicW)/sizeof(WCHAR));
1176         write_output_buffer_quoted(This->buffer, publicId, publicId_len);
1177
1178         if (!systemId) return E_INVALIDARG;
1179
1180         if (*publicId)
1181             write_output_buffer(This->buffer, spaceW, 1);
1182
1183         write_output_buffer_quoted(This->buffer, systemId, systemId_len);
1184
1185         if (*systemId)
1186             write_output_buffer(This->buffer, spaceW, 1);
1187     }
1188     else if (systemId)
1189     {
1190         static const WCHAR systemW[] = {'S','Y','S','T','E','M',' '};
1191
1192         write_output_buffer(This->buffer, systemW, sizeof(systemW)/sizeof(WCHAR));
1193         write_output_buffer_quoted(This->buffer, systemId, systemId_len);
1194         if (*systemId)
1195             write_output_buffer(This->buffer, spaceW, 1);
1196     }
1197
1198     write_output_buffer(This->buffer, openintW, sizeof(openintW)/sizeof(WCHAR));
1199
1200     return S_OK;
1201 }
1202
1203 static HRESULT WINAPI SAXLexicalHandler_endDTD(ISAXLexicalHandler *iface)
1204 {
1205     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1206     static const WCHAR closedtdW[] = {']','>','\r','\n'};
1207
1208     TRACE("(%p)\n", This);
1209
1210     write_output_buffer(This->buffer, closedtdW, sizeof(closedtdW)/sizeof(WCHAR));
1211
1212     return S_OK;
1213 }
1214
1215 static HRESULT WINAPI SAXLexicalHandler_startEntity(ISAXLexicalHandler *iface, const WCHAR *name, int len)
1216 {
1217     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1218     FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI SAXLexicalHandler_endEntity(ISAXLexicalHandler *iface, const WCHAR *name, int len)
1223 {
1224     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1225     FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
1226     return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI SAXLexicalHandler_startCDATA(ISAXLexicalHandler *iface)
1230 {
1231     static const WCHAR scdataW[] = {'<','!','[','C','D','A','T','A','['};
1232     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1233
1234     TRACE("(%p)\n", This);
1235
1236     write_output_buffer(This->buffer, scdataW, sizeof(scdataW)/sizeof(WCHAR));
1237     This->cdata = TRUE;
1238
1239     return S_OK;
1240 }
1241
1242 static HRESULT WINAPI SAXLexicalHandler_endCDATA(ISAXLexicalHandler *iface)
1243 {
1244     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1245     static const WCHAR ecdataW[] = {']',']','>'};
1246
1247     TRACE("(%p)\n", This);
1248
1249     write_output_buffer(This->buffer, ecdataW, sizeof(ecdataW)/sizeof(WCHAR));
1250     This->cdata = FALSE;
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI SAXLexicalHandler_comment(ISAXLexicalHandler *iface, const WCHAR *chars, int nchars)
1256 {
1257     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1258     static const WCHAR copenW[] = {'<','!','-','-'};
1259     static const WCHAR ccloseW[] = {'-','-','>','\r','\n'};
1260
1261     TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
1262
1263     if (!chars) return E_INVALIDARG;
1264
1265     close_element_starttag(This);
1266
1267     write_output_buffer(This->buffer, copenW, sizeof(copenW)/sizeof(WCHAR));
1268     if (nchars)
1269         write_output_buffer(This->buffer, chars, nchars);
1270     write_output_buffer(This->buffer, ccloseW, sizeof(ccloseW)/sizeof(WCHAR));
1271
1272     return S_OK;
1273 }
1274
1275 static const struct ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl =
1276 {
1277     SAXLexicalHandler_QueryInterface,
1278     SAXLexicalHandler_AddRef,
1279     SAXLexicalHandler_Release,
1280     SAXLexicalHandler_startDTD,
1281     SAXLexicalHandler_endDTD,
1282     SAXLexicalHandler_startEntity,
1283     SAXLexicalHandler_endEntity,
1284     SAXLexicalHandler_startCDATA,
1285     SAXLexicalHandler_endCDATA,
1286     SAXLexicalHandler_comment
1287 };
1288
1289 /*** ISAXDeclHandler ***/
1290 static HRESULT WINAPI SAXDeclHandler_QueryInterface(ISAXDeclHandler *iface,
1291     REFIID riid, void **obj)
1292 {
1293     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1294     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
1295 }
1296
1297 static ULONG WINAPI SAXDeclHandler_AddRef(ISAXDeclHandler *iface)
1298 {
1299     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1300     return IMXWriter_AddRef(&This->IMXWriter_iface);
1301 }
1302
1303 static ULONG WINAPI SAXDeclHandler_Release(ISAXDeclHandler *iface)
1304 {
1305     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1306     return IMXWriter_Release(&This->IMXWriter_iface);
1307 }
1308
1309 static HRESULT WINAPI SAXDeclHandler_elementDecl(ISAXDeclHandler *iface,
1310     const WCHAR *name, int n_name, const WCHAR *model, int n_model)
1311 {
1312     static const WCHAR elementW[] = {'<','!','E','L','E','M','E','N','T',' '};
1313     static const WCHAR closeelementW[] = {'>','\r','\n'};
1314     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1315
1316     TRACE("(%p)->(%s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
1317         debugstr_wn(model, n_model), n_model);
1318
1319     if (!name || !model) return E_INVALIDARG;
1320
1321     write_output_buffer(This->buffer, elementW, sizeof(elementW)/sizeof(WCHAR));
1322     if (n_name) {
1323         write_output_buffer(This->buffer, name, n_name);
1324         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1325     }
1326     if (n_model)
1327         write_output_buffer(This->buffer, model, n_model);
1328     write_output_buffer(This->buffer, closeelementW, sizeof(closeelementW)/sizeof(WCHAR));
1329
1330     return S_OK;
1331 }
1332
1333 static HRESULT WINAPI SAXDeclHandler_attributeDecl(ISAXDeclHandler *iface,
1334     const WCHAR *element, int n_element, const WCHAR *attr, int n_attr,
1335     const WCHAR *type, int n_type, const WCHAR *Default, int n_default,
1336     const WCHAR *value, int n_value)
1337 {
1338     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1339     FIXME("(%p)->(%s:%d %s:%d %s:%d %s:%d %s:%d): stub\n", This, debugstr_wn(element, n_element), n_element,
1340         debugstr_wn(attr, n_attr), n_attr, debugstr_wn(type, n_type), n_type, debugstr_wn(Default, n_default), n_default,
1341         debugstr_wn(value, n_value), n_value);
1342     return E_NOTIMPL;
1343 }
1344
1345 static HRESULT WINAPI SAXDeclHandler_internalEntityDecl(ISAXDeclHandler *iface,
1346     const WCHAR *name, int n_name, const WCHAR *value, int n_value)
1347 {
1348     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1349     FIXME("(%p)->(%s:%d %s:%d): stub\n", This, debugstr_wn(name, n_name), n_name,
1350         debugstr_wn(value, n_value), n_value);
1351     return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI SAXDeclHandler_externalEntityDecl(ISAXDeclHandler *iface,
1355     const WCHAR *name, int n_name, const WCHAR *publicId, int n_publicId,
1356     const WCHAR *systemId, int n_systemId)
1357 {
1358     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1359     FIXME("(%p)->(%s:%d %s:%d %s:%d): stub\n", This, debugstr_wn(name, n_name), n_name,
1360         debugstr_wn(publicId, n_publicId), n_publicId, debugstr_wn(systemId, n_systemId), n_systemId);
1361     return E_NOTIMPL;
1362 }
1363
1364 static const ISAXDeclHandlerVtbl SAXDeclHandlerVtbl = {
1365     SAXDeclHandler_QueryInterface,
1366     SAXDeclHandler_AddRef,
1367     SAXDeclHandler_Release,
1368     SAXDeclHandler_elementDecl,
1369     SAXDeclHandler_attributeDecl,
1370     SAXDeclHandler_internalEntityDecl,
1371     SAXDeclHandler_externalEntityDecl
1372 };
1373
1374 static const tid_t mxwriter_iface_tids[] = {
1375     IMXWriter_tid,
1376     0
1377 };
1378
1379 static dispex_static_data_t mxwriter_dispex = {
1380     NULL,
1381     IMXWriter_tid,
1382     NULL,
1383     mxwriter_iface_tids
1384 };
1385
1386 HRESULT MXWriter_create(MSXML_VERSION version, IUnknown *outer, void **ppObj)
1387 {
1388     static const WCHAR version10W[] = {'1','.','0',0};
1389     mxwriter *This;
1390     HRESULT hr;
1391
1392     TRACE("(%p, %p)\n", outer, ppObj);
1393
1394     if (outer) FIXME("support aggregation, outer\n");
1395
1396     This = heap_alloc( sizeof (*This) );
1397     if(!This)
1398         return E_OUTOFMEMORY;
1399
1400     This->IMXWriter_iface.lpVtbl = &MXWriterVtbl;
1401     This->ISAXContentHandler_iface.lpVtbl = &SAXContentHandlerVtbl;
1402     This->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
1403     This->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
1404     This->ref = 1;
1405     This->class_version = version;
1406
1407     This->props[MXWriter_BOM] = VARIANT_TRUE;
1408     This->props[MXWriter_DisableEscaping] = VARIANT_FALSE;
1409     This->props[MXWriter_Indent] = VARIANT_FALSE;
1410     This->props[MXWriter_OmitXmlDecl] = VARIANT_FALSE;
1411     This->props[MXWriter_Standalone] = VARIANT_FALSE;
1412     This->prop_changed = FALSE;
1413     This->encoding = SysAllocString(utf16W);
1414     This->version  = SysAllocString(version10W);
1415     This->xml_enc  = XmlEncoding_UTF16;
1416
1417     This->element = NULL;
1418     This->cdata = FALSE;
1419
1420     This->dest = NULL;
1421     This->dest_written = 0;
1422
1423     hr = alloc_output_buffer(This->xml_enc, &This->buffer);
1424     if (hr != S_OK) {
1425         SysFreeString(This->encoding);
1426         SysFreeString(This->version);
1427         heap_free(This);
1428         return hr;
1429     }
1430
1431     init_dispex(&This->dispex, (IUnknown*)&This->IMXWriter_iface, &mxwriter_dispex);
1432
1433     *ppObj = &This->IMXWriter_iface;
1434
1435     TRACE("returning iface %p\n", *ppObj);
1436
1437     return S_OK;
1438 }