dlls/msxml3/mxwriter.c

   1 /*
   2  *    MXWriter implementation
   3  *
   4  * Copyright 2011-2013 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 emptyW[] = {0};
  43 static const WCHAR spaceW[] = {' '};
  44 static const WCHAR quotW[]  = {'\"'};
  45 static const WCHAR closetagW[] = {'>','\r','\n'};
  46 static const WCHAR crlfW[] = {'\r','\n'};
  47 static const WCHAR entityW[] = {'<','!','E','N','T','I','T','Y',' '};
  48
  49 /* should be ordered as encoding names are sorted */
  50 typedef enum
  51 {
  52     XmlEncoding_ISO_8859_1 = 0,
  53     XmlEncoding_ISO_8859_13,
  54     XmlEncoding_ISO_8859_15,
  55     XmlEncoding_ISO_8859_2,
  56     XmlEncoding_ISO_8859_3,
  57     XmlEncoding_ISO_8859_4,
  58     XmlEncoding_ISO_8859_5,
  59     XmlEncoding_ISO_8859_7,
  60     XmlEncoding_ISO_8859_9,
  61     XmlEncoding_UTF16,
  62     XmlEncoding_UTF8,
  63     XmlEncoding_Unknown
  64 } xml_encoding;
  65
  66 struct xml_encoding_data
  67 {
  68     const WCHAR *encoding;
  69     xml_encoding enc;
  70     UINT cp;
  71 };
  72
  73 static const WCHAR iso_8859_1W[] = {'i','s','o','-','8','8','5','9','-','1',0};
  74 static const WCHAR iso_8859_2W[] = {'i','s','o','-','8','8','5','9','-','2',0};
  75 static const WCHAR iso_8859_3W[] = {'i','s','o','-','8','8','5','9','-','3',0};
  76 static const WCHAR iso_8859_4W[] = {'i','s','o','-','8','8','5','9','-','4',0};
  77 static const WCHAR iso_8859_5W[] = {'i','s','o','-','8','8','5','9','-','5',0};
  78 static const WCHAR iso_8859_7W[] = {'i','s','o','-','8','8','5','9','-','7',0};
  79 static const WCHAR iso_8859_9W[] = {'i','s','o','-','8','8','5','9','-','9',0};
  80 static const WCHAR iso_8859_13W[] = {'i','s','o','-','8','8','5','9','-','1','3',0};
  81 static const WCHAR iso_8859_15W[] = {'i','s','o','-','8','8','5','9','-','1','5',0};
  82 static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
  83 static const WCHAR utf8W[] = {'U','T','F','-','8',0};
  84
  85 static const struct xml_encoding_data xml_encoding_map[] = {
  86     { iso_8859_1W,  XmlEncoding_ISO_8859_1,  28591 },
  87     { iso_8859_13W, XmlEncoding_ISO_8859_13, 28603 },
  88     { iso_8859_15W, XmlEncoding_ISO_8859_15, 28605 },
  89     { iso_8859_2W,  XmlEncoding_ISO_8859_2,  28592 },
  90     { iso_8859_3W,  XmlEncoding_ISO_8859_3,  28593 },
  91     { iso_8859_4W,  XmlEncoding_ISO_8859_4,  28594 },
  92     { iso_8859_5W,  XmlEncoding_ISO_8859_5,  28595 },
  93     { iso_8859_7W,  XmlEncoding_ISO_8859_7,  28597 },
  94     { iso_8859_9W,  XmlEncoding_ISO_8859_9,  28599 },
  95     { utf16W,       XmlEncoding_UTF16,          ~0 },
  96     { utf8W,        XmlEncoding_UTF8,      CP_UTF8 }
  97 };
  98
  99 typedef enum
 100 {
 101     OutputBuffer_Native  = 0x001,
 102     OutputBuffer_Encoded = 0x010,
 103     OutputBuffer_Both    = 0x100
 104 } output_mode;
 105
 106 typedef enum
 107 {
 108     MXWriter_BOM = 0,
 109     MXWriter_DisableEscaping,
 110     MXWriter_Indent,
 111     MXWriter_OmitXmlDecl,
 112     MXWriter_Standalone,
 113     MXWriter_LastProp
 114 } mxwriter_prop;
 115
 116 typedef enum
 117 {
 118     EscapeValue,
 119     EscapeText
 120 } escape_mode;
 121
 122 typedef struct
 123 {
 124     char *data;
 125     unsigned int allocated;
 126     unsigned int written;
 127 } encoded_buffer;
 128
 129 typedef struct
 130 {
 131     encoded_buffer utf16;
 132     encoded_buffer encoded;
 133     UINT code_page;
 134 } output_buffer;
 135
 136 typedef struct
 137 {
 138     DispatchEx dispex;
 139     IMXWriter IMXWriter_iface;
 140     ISAXContentHandler ISAXContentHandler_iface;
 141     ISAXLexicalHandler ISAXLexicalHandler_iface;
 142     ISAXDeclHandler    ISAXDeclHandler_iface;
 143
 144     LONG ref;
 145     MSXML_VERSION class_version;
 146
 147     VARIANT_BOOL props[MXWriter_LastProp];
 148     BOOL prop_changed;
 149     BOOL cdata;
 150
 151     BOOL text; /* last node was text node, so we shouldn't indent next node */
 152     BOOL newline; /* newline was already added as a part of previous call */
 153     UINT indent; /* indentation level for next node */
 154
 155     BSTR version;
 156
 157     BSTR encoding; /* exact property value */
 158     xml_encoding xml_enc;
 159
 160     /* contains a pending (or not closed yet) element name or NULL if
 161        we don't have to close */
 162     BSTR element;
 163
 164     IStream *dest;
 165     ULONG dest_written;
 166
 167     output_buffer *buffer;
 168 } mxwriter;
 169
 170 typedef struct
 171 {
 172     BSTR qname;
 173     BSTR local;
 174     BSTR uri;
 175     BSTR type;
 176     BSTR value;
 177 } mxattribute;
 178
 179 typedef struct
 180 {
 181     DispatchEx dispex;
 182     IMXAttributes IMXAttributes_iface;
 183     ISAXAttributes ISAXAttributes_iface;
 184     IVBSAXAttributes IVBSAXAttributes_iface;
 185     LONG ref;
 186
 187     MSXML_VERSION class_version;
 188
 189     mxattribute *attr;
 190     int length;
 191     int allocated;
 192 } mxattributes;
 193
 194 static inline mxattributes *impl_from_IMXAttributes( IMXAttributes *iface )
 195 {
 196     return CONTAINING_RECORD(iface, mxattributes, IMXAttributes_iface);
 197 }
 198
 199 static inline mxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
 200 {
 201     return CONTAINING_RECORD(iface, mxattributes, ISAXAttributes_iface);
 202 }
 203
 204 static inline mxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
 205 {
 206     return CONTAINING_RECORD(iface, mxattributes, IVBSAXAttributes_iface);
 207 }
 208
 209 static HRESULT mxattributes_grow(mxattributes *This)
 210 {
 211     if (This->length < This->allocated) return S_OK;
 212
 213     This->allocated *= 2;
 214     This->attr = heap_realloc(This->attr, This->allocated*sizeof(mxattribute));
 215
 216     return This->attr ? S_OK : E_OUTOFMEMORY;
 217 }
 218
 219 static xml_encoding parse_encoding_name(const WCHAR *encoding)
 220 {
 221     int min, max, n, c;
 222
 223     min = 0;
 224     max = sizeof(xml_encoding_map)/sizeof(struct xml_encoding_data) - 1;
 225
 226     while (min <= max)
 227     {
 228         n = (min+max)/2;
 229
 230         c = strcmpiW(xml_encoding_map[n].encoding, encoding);
 231         if (!c)
 232             return xml_encoding_map[n].enc;
 233
 234         if (c > 0)
 235             max = n-1;
 236         else
 237             min = n+1;
 238     }
 239
 240     return XmlEncoding_Unknown;
 241 }
 242
 243 static HRESULT init_encoded_buffer(encoded_buffer *buffer)
 244 {
 245     const int initial_len = 0x2000;
 246     buffer->data = heap_alloc(initial_len);
 247     if (!buffer->data) return E_OUTOFMEMORY;
 248
 249     memset(buffer->data, 0, 4);
 250     buffer->allocated = initial_len;
 251     buffer->written = 0;
 252
 253     return S_OK;
 254 }
 255
 256 static void free_encoded_buffer(encoded_buffer *buffer)
 257 {
 258     heap_free(buffer->data);
 259 }
 260
 261 static HRESULT get_code_page(xml_encoding encoding, UINT *cp)
 262 {
 263     const struct xml_encoding_data *data;
 264
 265     if (encoding == XmlEncoding_Unknown)
 266     {
 267         FIXME("unsupported encoding %d\n", encoding);
 268         return E_NOTIMPL;
 269     }
 270
 271     data = &xml_encoding_map[encoding];
 272     *cp = data->cp;
 273
 274     return S_OK;
 275 }
 276
 277 static HRESULT alloc_output_buffer(xml_encoding encoding, output_buffer **buffer)
 278 {
 279     output_buffer *ret;
 280     HRESULT hr;
 281
 282     ret = heap_alloc(sizeof(*ret));
 283     if (!ret) return E_OUTOFMEMORY;
 284
 285     hr = get_code_page(encoding, &ret->code_page);
 286     if (hr != S_OK) {
 287         heap_free(ret);
 288         return hr;
 289     }
 290
 291     hr = init_encoded_buffer(&ret->utf16);
 292     if (hr != S_OK) {
 293         heap_free(ret);
 294         return hr;
 295     }
 296
 297     /* currently we always create a default output buffer that is UTF-16 only,
 298        but it's possible to allocate with specific encoding too */
 299     if (encoding != XmlEncoding_UTF16) {
 300         hr = init_encoded_buffer(&ret->encoded);
 301         if (hr != S_OK) {
 302             free_encoded_buffer(&ret->utf16);
 303             heap_free(ret);
 304             return hr;
 305         }
 306     }
 307     else
 308         memset(&ret->encoded, 0, sizeof(ret->encoded));
 309
 310     *buffer = ret;
 311
 312     return S_OK;
 313 }
 314
 315 static void free_output_buffer(output_buffer *buffer)
 316 {
 317     free_encoded_buffer(&buffer->encoded);
 318     free_encoded_buffer(&buffer->utf16);
 319     heap_free(buffer);
 320 }
 321
 322 static void grow_buffer(encoded_buffer *buffer, int length)
 323 {
 324     /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
 325     if (buffer->allocated < buffer->written + length + 4)
 326     {
 327         int grown_size = max(2*buffer->allocated, buffer->allocated + length);
 328         buffer->data = heap_realloc(buffer->data, grown_size);
 329         buffer->allocated = grown_size;
 330     }
 331 }
 332
 333 static HRESULT write_output_buffer_mode(output_buffer *buffer, output_mode mode, const WCHAR *data, int len)
 334 {
 335     int length;
 336     char *ptr;
 337
 338     if (mode & (OutputBuffer_Encoded | OutputBuffer_Both)) {
 339         if (buffer->code_page != ~0)
 340         {
 341             length = WideCharToMultiByte(buffer->code_page, 0, data, len, NULL, 0, NULL, NULL);
 342             grow_buffer(&buffer->encoded, length);
 343             ptr = buffer->encoded.data + buffer->encoded.written;
 344             length = WideCharToMultiByte(buffer->code_page, 0, data, len, ptr, length, NULL, NULL);
 345             buffer->encoded.written += len == -1 ? length-1 : length;
 346         }
 347     }
 348
 349     if (mode & (OutputBuffer_Native | OutputBuffer_Both)) {
 350         /* WCHAR data just copied */
 351         length = len == -1 ? strlenW(data) : len;
 352         if (length)
 353         {
 354             length *= sizeof(WCHAR);
 355
 356             grow_buffer(&buffer->utf16, length);
 357             ptr = buffer->utf16.data + buffer->utf16.written;
 358
 359             memcpy(ptr, data, length);
 360             buffer->utf16.written += length;
 361             ptr += length;
 362             /* null termination */
 363             memset(ptr, 0, sizeof(WCHAR));
 364         }
 365     }
 366
 367     return S_OK;
 368 }
 369
 370 static HRESULT write_output_buffer(output_buffer *buffer, const WCHAR *data, int len)
 371 {
 372     return write_output_buffer_mode(buffer, OutputBuffer_Both, data, len);
 373 }
 374
 375 static HRESULT write_output_buffer_quoted(output_buffer *buffer, const WCHAR *data, int len)
 376 {
 377     write_output_buffer(buffer, quotW, 1);
 378     write_output_buffer(buffer, data, len);
 379     write_output_buffer(buffer, quotW, 1);
 380
 381     return S_OK;
 382 }
 383
 384 /* frees buffer data, reallocates with a default lengths */
 385 static void close_output_buffer(mxwriter *This)
 386 {
 387     heap_free(This->buffer->utf16.data);
 388     heap_free(This->buffer->encoded.data);
 389     init_encoded_buffer(&This->buffer->utf16);
 390     init_encoded_buffer(&This->buffer->encoded);
 391     get_code_page(This->xml_enc, &This->buffer->code_page);
 392 }
 393
 394 /* escapes special characters like:
 395    '<' -> "&lt;"
 396    '&' -> "&amp;"
 397    '"' -> "&quot;"
 398    '>' -> "&gt;"
 399 */
 400 static WCHAR *get_escaped_string(const WCHAR *str, escape_mode mode, int *len)
 401 {
 402     static const WCHAR ltW[]    = {'&','l','t',';'};
 403     static const WCHAR ampW[]   = {'&','a','m','p',';'};
 404     static const WCHAR equotW[] = {'&','q','u','o','t',';'};
 405     static const WCHAR gtW[]    = {'&','g','t',';'};
 406
 407     const int default_alloc = 100;
 408     const int grow_thresh = 10;
 409     int p = *len, conv_len;
 410     WCHAR *ptr, *ret;
 411
 412     /* default buffer size to something if length is unknown */
 413     conv_len = *len == -1 ? default_alloc : max(2**len, default_alloc);
 414     ptr = ret = heap_alloc(conv_len*sizeof(WCHAR));
 415
 416     while (*str && p)
 417     {
 418         if (ptr - ret > conv_len - grow_thresh)
 419         {
 420             int written = ptr - ret;
 421             conv_len *= 2;
 422             ptr = ret = heap_realloc(ret, conv_len*sizeof(WCHAR));
 423             ptr += written;
 424         }
 425
 426         switch (*str)
 427         {
 428         case '<':
 429             memcpy(ptr, ltW, sizeof(ltW));
 430             ptr += sizeof(ltW)/sizeof(WCHAR);
 431             break;
 432         case '&':
 433             memcpy(ptr, ampW, sizeof(ampW));
 434             ptr += sizeof(ampW)/sizeof(WCHAR);
 435             break;
 436         case '>':
 437             memcpy(ptr, gtW, sizeof(gtW));
 438             ptr += sizeof(gtW)/sizeof(WCHAR);
 439             break;
 440         case '"':
 441             if (mode == EscapeValue)
 442             {
 443                 memcpy(ptr, equotW, sizeof(equotW));
 444                 ptr += sizeof(equotW)/sizeof(WCHAR);
 445                 break;
 446             }
 447             /* fallthrough for text mode */
 448         default:
 449             *ptr++ = *str;
 450             break;
 451         }
 452
 453         str++;
 454         if (*len != -1) p--;
 455     }
 456
 457     if (*len != -1) *len = ptr-ret;
 458     *++ptr = 0;
 459
 460     return ret;
 461 }
 462
 463 static void write_prolog_buffer(mxwriter *This)
 464 {
 465     static const WCHAR versionW[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','='};
 466     static const WCHAR encodingW[] = {' ','e','n','c','o','d','i','n','g','=','\"'};
 467     static const WCHAR standaloneW[] = {' ','s','t','a','n','d','a','l','o','n','e','=','\"'};
 468     static const WCHAR yesW[] = {'y','e','s','\"','?','>'};
 469     static const WCHAR noW[] = {'n','o','\"','?','>'};
 470
 471     /* version */
 472     write_output_buffer(This->buffer, versionW, sizeof(versionW)/sizeof(WCHAR));
 473     write_output_buffer_quoted(This->buffer, This->version, -1);
 474
 475     /* encoding */
 476     write_output_buffer(This->buffer, encodingW, sizeof(encodingW)/sizeof(WCHAR));
 477
 478     /* always write UTF-16 to WCHAR buffer */
 479     write_output_buffer_mode(This->buffer, OutputBuffer_Native, utf16W, sizeof(utf16W)/sizeof(WCHAR) - 1);
 480     write_output_buffer_mode(This->buffer, OutputBuffer_Encoded, This->encoding, -1);
 481     write_output_buffer(This->buffer, quotW, 1);
 482
 483     /* standalone */
 484     write_output_buffer(This->buffer, standaloneW, sizeof(standaloneW)/sizeof(WCHAR));
 485     if (This->props[MXWriter_Standalone] == VARIANT_TRUE)
 486         write_output_buffer(This->buffer, yesW, sizeof(yesW)/sizeof(WCHAR));
 487     else
 488         write_output_buffer(This->buffer, noW, sizeof(noW)/sizeof(WCHAR));
 489
 490     write_output_buffer(This->buffer, crlfW, sizeof(crlfW)/sizeof(WCHAR));
 491     This->newline = TRUE;
 492 }
 493
 494 /* Attempts to the write data from the mxwriter's buffer to
 495  * the destination stream (if there is one).
 496  */
 497 static HRESULT write_data_to_stream(mxwriter *This)
 498 {
 499     encoded_buffer *buffer;
 500     ULONG written = 0;
 501     HRESULT hr;
 502
 503     if (!This->dest)
 504         return S_OK;
 505
 506     if (This->xml_enc != XmlEncoding_UTF16)
 507         buffer = &This->buffer->encoded;
 508     else
 509         buffer = &This->buffer->utf16;
 510
 511     if (This->dest_written > buffer->written) {
 512         ERR("Failed sanity check! Not sure what to do... (%d > %d)\n", This->dest_written, buffer->written);
 513         return E_FAIL;
 514     } else if (This->dest_written == buffer->written && This->xml_enc != XmlEncoding_UTF8)
 515         /* Windows seems to make an empty write call when the encoding is UTF-8 and
 516          * all the data has been written to the stream. It doesn't seem make this call
 517          * for any other encodings.
 518          */
 519         return S_OK;
 520
 521     /* Write the current content from the output buffer into 'dest'.
 522      * TODO: Check what Windows does if the IStream doesn't write all of
 523      *       the data we give it at once.
 524      */
 525     hr = IStream_Write(This->dest, buffer->data+This->dest_written,
 526                          buffer->written-This->dest_written, &written);
 527     if (FAILED(hr)) {
 528         WARN("Failed to write data to IStream (0x%08x)\n", hr);
 529         return hr;
 530     }
 531
 532     This->dest_written += written;
 533     return hr;
 534 }
 535
 536 /* Newly added element start tag left unclosed cause for empty elements
 537    we have to close it differently. */
 538 static void close_element_starttag(const mxwriter *This)
 539 {
 540     static const WCHAR gtW[] = {'>'};
 541     if (!This->element) return;
 542     write_output_buffer(This->buffer, gtW, 1);
 543 }
 544
 545 static void write_node_indent(mxwriter *This)
 546 {
 547     static const WCHAR tabW[] = {'\t'};
 548     int indent = This->indent;
 549
 550     if (!This->props[MXWriter_Indent] || This->text)
 551     {
 552         This->text = FALSE;
 553         return;
 554     }
 555
 556     /* This is to workaround PI output logic that always puts newline chars,
 557        document prolog PI does that too. */
 558     if (!This->newline)
 559         write_output_buffer(This->buffer, crlfW, sizeof(crlfW)/sizeof(WCHAR));
 560     while (indent--)
 561         write_output_buffer(This->buffer, tabW, 1);
 562
 563     This->newline = FALSE;
 564     This->text = FALSE;
 565 }
 566
 567 static inline void writer_inc_indent(mxwriter *This)
 568 {
 569     This->indent++;
 570 }
 571
 572 static inline void writer_dec_indent(mxwriter *This)
 573 {
 574     if (This->indent) This->indent--;
 575     /* depth is decreased only when element is closed, meaning it's not a text node
 576        at this point */
 577     This->text = FALSE;
 578 }
 579
 580 static void set_element_name(mxwriter *This, const WCHAR *name, int len)
 581 {
 582     SysFreeString(This->element);
 583     if (name)
 584         This->element = len != -1 ? SysAllocStringLen(name, len) : SysAllocString(name);
 585     else
 586         This->element = NULL;
 587 }
 588
 589 static inline HRESULT flush_output_buffer(mxwriter *This)
 590 {
 591     close_element_starttag(This);
 592     set_element_name(This, NULL, 0);
 593     This->cdata = FALSE;
 594     return write_data_to_stream(This);
 595 }
 596
 597 /* Resets the mxwriter's output buffer by closing it, then creating a new
 598  * output buffer using the given encoding.
 599  */
 600 static inline void reset_output_buffer(mxwriter *This)
 601 {
 602     close_output_buffer(This);
 603     This->dest_written = 0;
 604 }
 605
 606 static HRESULT writer_set_property(mxwriter *writer, mxwriter_prop property, VARIANT_BOOL value)
 607 {
 608     writer->props[property] = value;
 609     writer->prop_changed = TRUE;
 610     return S_OK;
 611 }
 612
 613 static HRESULT writer_get_property(const mxwriter *writer, mxwriter_prop property, VARIANT_BOOL *value)
 614 {
 615     if (!value) return E_POINTER;
 616     *value = writer->props[property];
 617     return S_OK;
 618 }
 619
 620 static inline mxwriter *impl_from_IMXWriter(IMXWriter *iface)
 621 {
 622     return CONTAINING_RECORD(iface, mxwriter, IMXWriter_iface);
 623 }
 624
 625 static inline mxwriter *impl_from_ISAXContentHandler(ISAXContentHandler *iface)
 626 {
 627     return CONTAINING_RECORD(iface, mxwriter, ISAXContentHandler_iface);
 628 }
 629
 630 static inline mxwriter *impl_from_ISAXLexicalHandler(ISAXLexicalHandler *iface)
 631 {
 632     return CONTAINING_RECORD(iface, mxwriter, ISAXLexicalHandler_iface);
 633 }
 634
 635 static inline mxwriter *impl_from_ISAXDeclHandler(ISAXDeclHandler *iface)
 636 {
 637     return CONTAINING_RECORD(iface, mxwriter, ISAXDeclHandler_iface);
 638 }
 639
 640 static HRESULT WINAPI mxwriter_QueryInterface(IMXWriter *iface, REFIID riid, void **obj)
 641 {
 642     mxwriter *This = impl_from_IMXWriter( iface );
 643
 644     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 645
 646     *obj = NULL;
 647
 648     if ( IsEqualGUID( riid, &IID_IMXWriter ) ||
 649          IsEqualGUID( riid, &IID_IDispatch ) ||
 650          IsEqualGUID( riid, &IID_IUnknown ) )
 651     {
 652         *obj = &This->IMXWriter_iface;
 653     }
 654     else if ( IsEqualGUID( riid, &IID_ISAXContentHandler ) )
 655     {
 656         *obj = &This->ISAXContentHandler_iface;
 657     }
 658     else if ( IsEqualGUID( riid, &IID_ISAXLexicalHandler ) )
 659     {
 660         *obj = &This->ISAXLexicalHandler_iface;
 661     }
 662     else if ( IsEqualGUID( riid, &IID_ISAXDeclHandler ) )
 663     {
 664         *obj = &This->ISAXDeclHandler_iface;
 665     }
 666     else if (dispex_query_interface(&This->dispex, riid, obj))
 667     {
 668         return *obj ? S_OK : E_NOINTERFACE;
 669     }
 670     else
 671     {
 672         ERR("interface %s not implemented\n", debugstr_guid(riid));
 673         *obj = NULL;
 674         return E_NOINTERFACE;
 675     }
 676
 677     IMXWriter_AddRef(iface);
 678     return S_OK;
 679 }
 680
 681 static ULONG WINAPI mxwriter_AddRef(IMXWriter *iface)
 682 {
 683     mxwriter *This = impl_from_IMXWriter( iface );
 684     LONG ref = InterlockedIncrement(&This->ref);
 685
 686     TRACE("(%p)->(%d)\n", This, ref);
 687
 688     return ref;
 689 }
 690
 691 static ULONG WINAPI mxwriter_Release(IMXWriter *iface)
 692 {
 693     mxwriter *This = impl_from_IMXWriter( iface );
 694     ULONG ref = InterlockedDecrement(&This->ref);
 695
 696     TRACE("(%p)->(%d)\n", This, ref);
 697
 698     if(!ref)
 699     {
 700         /* Windows flushes the buffer when the interface is destroyed. */
 701         flush_output_buffer(This);
 702         free_output_buffer(This->buffer);
 703
 704         if (This->dest) IStream_Release(This->dest);
 705         SysFreeString(This->version);
 706         SysFreeString(This->encoding);
 707
 708         SysFreeString(This->element);
 709         release_dispex(&This->dispex);
 710         heap_free(This);
 711     }
 712
 713     return ref;
 714 }
 715
 716 static HRESULT WINAPI mxwriter_GetTypeInfoCount(IMXWriter *iface, UINT* pctinfo)
 717 {
 718     mxwriter *This = impl_from_IMXWriter( iface );
 719     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 720 }
 721
 722 static HRESULT WINAPI mxwriter_GetTypeInfo(
 723     IMXWriter *iface,
 724     UINT iTInfo, LCID lcid,
 725     ITypeInfo** ppTInfo )
 726 {
 727     mxwriter *This = impl_from_IMXWriter( iface );
 728     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 729         iTInfo, lcid, ppTInfo);
 730 }
 731
 732 static HRESULT WINAPI mxwriter_GetIDsOfNames(
 733     IMXWriter *iface,
 734     REFIID riid, LPOLESTR* rgszNames,
 735     UINT cNames, LCID lcid, DISPID* rgDispId )
 736 {
 737     mxwriter *This = impl_from_IMXWriter( iface );
 738     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 739         riid, rgszNames, cNames, lcid, rgDispId);
 740 }
 741
 742 static HRESULT WINAPI mxwriter_Invoke(
 743     IMXWriter *iface,
 744     DISPID dispIdMember, REFIID riid, LCID lcid,
 745     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 746     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 747 {
 748     mxwriter *This = impl_from_IMXWriter( iface );
 749     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 750         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 751 }
 752
 753 static HRESULT WINAPI mxwriter_put_output(IMXWriter *iface, VARIANT dest)
 754 {
 755     mxwriter *This = impl_from_IMXWriter( iface );
 756     HRESULT hr;
 757
 758     TRACE("(%p)->(%s)\n", This, debugstr_variant(&dest));
 759
 760     hr = flush_output_buffer(This);
 761     if (FAILED(hr))
 762         return hr;
 763
 764     switch (V_VT(&dest))
 765     {
 766     case VT_EMPTY:
 767     {
 768         if (This->dest) IStream_Release(This->dest);
 769         This->dest = NULL;
 770         reset_output_buffer(This);
 771         break;
 772     }
 773     case VT_UNKNOWN:
 774     {
 775         IStream *stream;
 776
 777         hr = IUnknown_QueryInterface(V_UNKNOWN(&dest), &IID_IStream, (void**)&stream);
 778         if (hr == S_OK)
 779         {
 780             /* Recreate the output buffer to make sure it's using the correct encoding. */
 781             reset_output_buffer(This);
 782
 783             if (This->dest) IStream_Release(This->dest);
 784             This->dest = stream;
 785             break;
 786         }
 787
 788         FIXME("unhandled interface type for VT_UNKNOWN destination\n");
 789         return E_NOTIMPL;
 790     }
 791     default:
 792         FIXME("unhandled destination type %s\n", debugstr_variant(&dest));
 793         return E_NOTIMPL;
 794     }
 795
 796     return S_OK;
 797 }
 798
 799 static HRESULT WINAPI mxwriter_get_output(IMXWriter *iface, VARIANT *dest)
 800 {
 801     mxwriter *This = impl_from_IMXWriter( iface );
 802
 803     TRACE("(%p)->(%p)\n", This, dest);
 804
 805     if (!dest) return E_POINTER;
 806
 807     if (!This->dest)
 808     {
 809         HRESULT hr = flush_output_buffer(This);
 810         if (FAILED(hr))
 811             return hr;
 812
 813         V_VT(dest)   = VT_BSTR;
 814         V_BSTR(dest) = SysAllocString((WCHAR*)This->buffer->utf16.data);
 815
 816         return S_OK;
 817     }
 818
 819     /* we only support IStream output so far */
 820     V_VT(dest) = VT_UNKNOWN;
 821     V_UNKNOWN(dest) = (IUnknown*)This->dest;
 822     IStream_AddRef(This->dest);
 823
 824     return S_OK;
 825 }
 826
 827 static HRESULT WINAPI mxwriter_put_encoding(IMXWriter *iface, BSTR encoding)
 828 {
 829     mxwriter *This = impl_from_IMXWriter( iface );
 830     xml_encoding enc;
 831     HRESULT hr;
 832
 833     TRACE("(%p)->(%s)\n", This, debugstr_w(encoding));
 834
 835     enc = parse_encoding_name(encoding);
 836     if (enc == XmlEncoding_Unknown)
 837     {
 838         FIXME("unsupported encoding %s\n", debugstr_w(encoding));
 839         return E_INVALIDARG;
 840     }
 841
 842     hr = flush_output_buffer(This);
 843     if (FAILED(hr))
 844         return hr;
 845
 846     SysReAllocString(&This->encoding, encoding);
 847     This->xml_enc = enc;
 848
 849     TRACE("got encoding %d\n", This->xml_enc);
 850     reset_output_buffer(This);
 851     return S_OK;
 852 }
 853
 854 static HRESULT WINAPI mxwriter_get_encoding(IMXWriter *iface, BSTR *encoding)
 855 {
 856     mxwriter *This = impl_from_IMXWriter( iface );
 857
 858     TRACE("(%p)->(%p)\n", This, encoding);
 859
 860     if (!encoding) return E_POINTER;
 861
 862     *encoding = SysAllocString(This->encoding);
 863     if (!*encoding) return E_OUTOFMEMORY;
 864
 865     return S_OK;
 866 }
 867
 868 static HRESULT WINAPI mxwriter_put_byteOrderMark(IMXWriter *iface, VARIANT_BOOL value)
 869 {
 870     mxwriter *This = impl_from_IMXWriter( iface );
 871
 872     TRACE("(%p)->(%d)\n", This, value);
 873     return writer_set_property(This, MXWriter_BOM, value);
 874 }
 875
 876 static HRESULT WINAPI mxwriter_get_byteOrderMark(IMXWriter *iface, VARIANT_BOOL *value)
 877 {
 878     mxwriter *This = impl_from_IMXWriter( iface );
 879
 880     TRACE("(%p)->(%p)\n", This, value);
 881     return writer_get_property(This, MXWriter_BOM, value);
 882 }
 883
 884 static HRESULT WINAPI mxwriter_put_indent(IMXWriter *iface, VARIANT_BOOL value)
 885 {
 886     mxwriter *This = impl_from_IMXWriter( iface );
 887
 888     TRACE("(%p)->(%d)\n", This, value);
 889     return writer_set_property(This, MXWriter_Indent, value);
 890 }
 891
 892 static HRESULT WINAPI mxwriter_get_indent(IMXWriter *iface, VARIANT_BOOL *value)
 893 {
 894     mxwriter *This = impl_from_IMXWriter( iface );
 895
 896     TRACE("(%p)->(%p)\n", This, value);
 897     return writer_get_property(This, MXWriter_Indent, value);
 898 }
 899
 900 static HRESULT WINAPI mxwriter_put_standalone(IMXWriter *iface, VARIANT_BOOL value)
 901 {
 902     mxwriter *This = impl_from_IMXWriter( iface );
 903
 904     TRACE("(%p)->(%d)\n", This, value);
 905     return writer_set_property(This, MXWriter_Standalone, value);
 906 }
 907
 908 static HRESULT WINAPI mxwriter_get_standalone(IMXWriter *iface, VARIANT_BOOL *value)
 909 {
 910     mxwriter *This = impl_from_IMXWriter( iface );
 911
 912     TRACE("(%p)->(%p)\n", This, value);
 913     return writer_get_property(This, MXWriter_Standalone, value);
 914 }
 915
 916 static HRESULT WINAPI mxwriter_put_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL value)
 917 {
 918     mxwriter *This = impl_from_IMXWriter( iface );
 919
 920     TRACE("(%p)->(%d)\n", This, value);
 921     return writer_set_property(This, MXWriter_OmitXmlDecl, value);
 922 }
 923
 924 static HRESULT WINAPI mxwriter_get_omitXMLDeclaration(IMXWriter *iface, VARIANT_BOOL *value)
 925 {
 926     mxwriter *This = impl_from_IMXWriter( iface );
 927
 928     TRACE("(%p)->(%p)\n", This, value);
 929     return writer_get_property(This, MXWriter_OmitXmlDecl, value);
 930 }
 931
 932 static HRESULT WINAPI mxwriter_put_version(IMXWriter *iface, BSTR version)
 933 {
 934     mxwriter *This = impl_from_IMXWriter( iface );
 935
 936     TRACE("(%p)->(%s)\n", This, debugstr_w(version));
 937
 938     if (!version) return E_INVALIDARG;
 939
 940     SysFreeString(This->version);
 941     This->version = SysAllocString(version);
 942
 943     return S_OK;
 944 }
 945
 946 static HRESULT WINAPI mxwriter_get_version(IMXWriter *iface, BSTR *version)
 947 {
 948     mxwriter *This = impl_from_IMXWriter( iface );
 949
 950     TRACE("(%p)->(%p)\n", This, version);
 951
 952     if (!version) return E_POINTER;
 953
 954     return return_bstr(This->version, version);
 955 }
 956
 957 static HRESULT WINAPI mxwriter_put_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL value)
 958 {
 959     mxwriter *This = impl_from_IMXWriter( iface );
 960
 961     TRACE("(%p)->(%d)\n", This, value);
 962     return writer_set_property(This, MXWriter_DisableEscaping, value);
 963 }
 964
 965 static HRESULT WINAPI mxwriter_get_disableOutputEscaping(IMXWriter *iface, VARIANT_BOOL *value)
 966 {
 967     mxwriter *This = impl_from_IMXWriter( iface );
 968
 969     TRACE("(%p)->(%p)\n", This, value);
 970     return writer_get_property(This, MXWriter_DisableEscaping, value);
 971 }
 972
 973 static HRESULT WINAPI mxwriter_flush(IMXWriter *iface)
 974 {
 975     mxwriter *This = impl_from_IMXWriter( iface );
 976     TRACE("(%p)\n", This);
 977     return flush_output_buffer(This);
 978 }
 979
 980 static const struct IMXWriterVtbl MXWriterVtbl =
 981 {
 982     mxwriter_QueryInterface,
 983     mxwriter_AddRef,
 984     mxwriter_Release,
 985     mxwriter_GetTypeInfoCount,
 986     mxwriter_GetTypeInfo,
 987     mxwriter_GetIDsOfNames,
 988     mxwriter_Invoke,
 989     mxwriter_put_output,
 990     mxwriter_get_output,
 991     mxwriter_put_encoding,
 992     mxwriter_get_encoding,
 993     mxwriter_put_byteOrderMark,
 994     mxwriter_get_byteOrderMark,
 995     mxwriter_put_indent,
 996     mxwriter_get_indent,
 997     mxwriter_put_standalone,
 998     mxwriter_get_standalone,
 999     mxwriter_put_omitXMLDeclaration,
1000     mxwriter_get_omitXMLDeclaration,
1001     mxwriter_put_version,
1002     mxwriter_get_version,
1003     mxwriter_put_disableOutputEscaping,
1004     mxwriter_get_disableOutputEscaping,
1005     mxwriter_flush
1006 };
1007
1008 /*** ISAXContentHandler ***/
1009 static HRESULT WINAPI SAXContentHandler_QueryInterface(
1010     ISAXContentHandler *iface,
1011     REFIID riid,
1012     void **obj)
1013 {
1014     mxwriter *This = impl_from_ISAXContentHandler( iface );
1015     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
1016 }
1017
1018 static ULONG WINAPI SAXContentHandler_AddRef(ISAXContentHandler *iface)
1019 {
1020     mxwriter *This = impl_from_ISAXContentHandler( iface );
1021     return IMXWriter_AddRef(&This->IMXWriter_iface);
1022 }
1023
1024 static ULONG WINAPI SAXContentHandler_Release(ISAXContentHandler *iface)
1025 {
1026     mxwriter *This = impl_from_ISAXContentHandler( iface );
1027     return IMXWriter_Release(&This->IMXWriter_iface);
1028 }
1029
1030 static HRESULT WINAPI SAXContentHandler_putDocumentLocator(
1031     ISAXContentHandler *iface,
1032     ISAXLocator *locator)
1033 {
1034     mxwriter *This = impl_from_ISAXContentHandler( iface );
1035     FIXME("(%p)->(%p)\n", This, locator);
1036     return E_NOTIMPL;
1037 }
1038
1039 static HRESULT WINAPI SAXContentHandler_startDocument(ISAXContentHandler *iface)
1040 {
1041     mxwriter *This = impl_from_ISAXContentHandler( iface );
1042
1043     TRACE("(%p)\n", This);
1044
1045     /* If properties have been changed since the last "endDocument" call
1046      * we need to reset the output buffer. If we don't the output buffer
1047      * could end up with multiple XML documents in it, plus this seems to
1048      * be how Windows works.
1049      */
1050     if (This->prop_changed) {
1051         reset_output_buffer(This);
1052         This->prop_changed = FALSE;
1053     }
1054
1055     if (This->props[MXWriter_OmitXmlDecl] == VARIANT_TRUE) return S_OK;
1056
1057     write_prolog_buffer(This);
1058
1059     if (This->dest && This->xml_enc == XmlEncoding_UTF16) {
1060         static const char utf16BOM[] = {0xff,0xfe};
1061
1062         if (This->props[MXWriter_BOM] == VARIANT_TRUE)
1063             /* Windows passes a NULL pointer as the pcbWritten parameter and
1064              * ignores any error codes returned from this Write call.
1065              */
1066             IStream_Write(This->dest, utf16BOM, sizeof(utf16BOM), NULL);
1067     }
1068
1069     return S_OK;
1070 }
1071
1072 static HRESULT WINAPI SAXContentHandler_endDocument(ISAXContentHandler *iface)
1073 {
1074     mxwriter *This = impl_from_ISAXContentHandler( iface );
1075     TRACE("(%p)\n", This);
1076     This->prop_changed = FALSE;
1077     return flush_output_buffer(This);
1078 }
1079
1080 static HRESULT WINAPI SAXContentHandler_startPrefixMapping(
1081     ISAXContentHandler *iface,
1082     const WCHAR *prefix,
1083     int nprefix,
1084     const WCHAR *uri,
1085     int nuri)
1086 {
1087     mxwriter *This = impl_from_ISAXContentHandler( iface );
1088     FIXME("(%p)->(%s %s)\n", This, debugstr_wn(prefix, nprefix), debugstr_wn(uri, nuri));
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI SAXContentHandler_endPrefixMapping(
1093     ISAXContentHandler *iface,
1094     const WCHAR *prefix,
1095     int nprefix)
1096 {
1097     mxwriter *This = impl_from_ISAXContentHandler( iface );
1098     FIXME("(%p)->(%s)\n", This, debugstr_wn(prefix, nprefix));
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI SAXContentHandler_startElement(
1103     ISAXContentHandler *iface,
1104     const WCHAR *namespaceUri,
1105     int nnamespaceUri,
1106     const WCHAR *local_name,
1107     int nlocal_name,
1108     const WCHAR *QName,
1109     int nQName,
1110     ISAXAttributes *attr)
1111 {
1112     mxwriter *This = impl_from_ISAXContentHandler( iface );
1113     static const WCHAR ltW[] = {'<'};
1114
1115     TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_wn(namespaceUri, nnamespaceUri),
1116         debugstr_wn(local_name, nlocal_name), debugstr_wn(QName, nQName), attr);
1117
1118     if (((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) ||
1119         (nQName == -1 && This->class_version == MSXML6))
1120         return E_INVALIDARG;
1121
1122     close_element_starttag(This);
1123     set_element_name(This, QName ? QName  : emptyW,
1124                            QName ? nQName : 0);
1125
1126     write_node_indent(This);
1127
1128     write_output_buffer(This->buffer, ltW, 1);
1129     write_output_buffer(This->buffer, QName, nQName);
1130     writer_inc_indent(This);
1131
1132     if (attr)
1133     {
1134         int length, i, escape;
1135         HRESULT hr;
1136
1137         hr = ISAXAttributes_getLength(attr, &length);
1138         if (FAILED(hr)) return hr;
1139
1140         escape = This->props[MXWriter_DisableEscaping] == VARIANT_FALSE ||
1141             (This->class_version == MSXML4 || This->class_version == MSXML6);
1142
1143         for (i = 0; i < length; i++)
1144         {
1145             static const WCHAR eqW[] = {'='};
1146             const WCHAR *str;
1147             int len = 0;
1148
1149             hr = ISAXAttributes_getQName(attr, i, &str, &len);
1150             if (FAILED(hr)) return hr;
1151
1152             /* space separator in front of every attribute */
1153             write_output_buffer(This->buffer, spaceW, 1);
1154             write_output_buffer(This->buffer, str, len);
1155
1156             write_output_buffer(This->buffer, eqW, 1);
1157
1158             len = 0;
1159             hr = ISAXAttributes_getValue(attr, i, &str, &len);
1160             if (FAILED(hr)) return hr;
1161
1162             if (escape)
1163             {
1164                 WCHAR *escaped = get_escaped_string(str, EscapeValue, &len);
1165                 write_output_buffer_quoted(This->buffer, escaped, len);
1166                 heap_free(escaped);
1167             }
1168             else
1169                 write_output_buffer_quoted(This->buffer, str, len);
1170         }
1171     }
1172
1173     return S_OK;
1174 }
1175
1176 static HRESULT WINAPI SAXContentHandler_endElement(
1177     ISAXContentHandler *iface,
1178     const WCHAR *namespaceUri,
1179     int nnamespaceUri,
1180     const WCHAR * local_name,
1181     int nlocal_name,
1182     const WCHAR *QName,
1183     int nQName)
1184 {
1185     mxwriter *This = impl_from_ISAXContentHandler( iface );
1186
1187     TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri,
1188         debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName);
1189
1190     if (((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) ||
1191          (nQName == -1 && This->class_version == MSXML6))
1192         return E_INVALIDARG;
1193
1194     writer_dec_indent(This);
1195
1196     if (This->element)
1197     {
1198         static const WCHAR closeW[] = {'/','>'};
1199         write_output_buffer(This->buffer, closeW, 2);
1200     }
1201     else
1202     {
1203         static const WCHAR closetagW[] = {'<','/'};
1204         static const WCHAR gtW[] = {'>'};
1205
1206         write_node_indent(This);
1207         write_output_buffer(This->buffer, closetagW, 2);
1208         write_output_buffer(This->buffer, QName, nQName);
1209         write_output_buffer(This->buffer, gtW, 1);
1210     }
1211
1212     set_element_name(This, NULL, 0);
1213
1214     return S_OK;
1215 }
1216
1217 static HRESULT WINAPI SAXContentHandler_characters(
1218     ISAXContentHandler *iface,
1219     const WCHAR *chars,
1220     int nchars)
1221 {
1222     mxwriter *This = impl_from_ISAXContentHandler( iface );
1223
1224     TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
1225
1226     if (!chars) return E_INVALIDARG;
1227
1228     close_element_starttag(This);
1229     set_element_name(This, NULL, 0);
1230
1231     if (!This->cdata)
1232         This->text = TRUE;
1233
1234     if (nchars)
1235     {
1236         if (This->cdata || This->props[MXWriter_DisableEscaping] == VARIANT_TRUE)
1237             write_output_buffer(This->buffer, chars, nchars);
1238         else
1239         {
1240             int len = nchars;
1241             WCHAR *escaped;
1242
1243             escaped = get_escaped_string(chars, EscapeText, &len);
1244             write_output_buffer(This->buffer, escaped, len);
1245             heap_free(escaped);
1246         }
1247     }
1248
1249     return S_OK;
1250 }
1251
1252 static HRESULT WINAPI SAXContentHandler_ignorableWhitespace(
1253     ISAXContentHandler *iface,
1254     const WCHAR *chars,
1255     int nchars)
1256 {
1257     mxwriter *This = impl_from_ISAXContentHandler( iface );
1258
1259     TRACE("(%p)->(%s)\n", This, debugstr_wn(chars, nchars));
1260
1261     if (!chars) return E_INVALIDARG;
1262
1263     write_output_buffer(This->buffer, chars, nchars);
1264
1265     return S_OK;
1266 }
1267
1268 static HRESULT WINAPI SAXContentHandler_processingInstruction(
1269     ISAXContentHandler *iface,
1270     const WCHAR *target,
1271     int ntarget,
1272     const WCHAR *data,
1273     int ndata)
1274 {
1275     mxwriter *This = impl_from_ISAXContentHandler( iface );
1276     static const WCHAR openpiW[] = {'<','?'};
1277     static const WCHAR closepiW[] = {'?','>','\r','\n'};
1278
1279     TRACE("(%p)->(%s %s)\n", This, debugstr_wn(target, ntarget), debugstr_wn(data, ndata));
1280
1281     if (!target) return E_INVALIDARG;
1282
1283     write_node_indent(This);
1284     write_output_buffer(This->buffer, openpiW, sizeof(openpiW)/sizeof(WCHAR));
1285
1286     if (*target)
1287         write_output_buffer(This->buffer, target, ntarget);
1288
1289     if (data && *data && ndata)
1290     {
1291         write_output_buffer(This->buffer, spaceW, 1);
1292         write_output_buffer(This->buffer, data, ndata);
1293     }
1294
1295     write_output_buffer(This->buffer, closepiW, sizeof(closepiW)/sizeof(WCHAR));
1296     This->newline = TRUE;
1297
1298     return S_OK;
1299 }
1300
1301 static HRESULT WINAPI SAXContentHandler_skippedEntity(
1302     ISAXContentHandler *iface,
1303     const WCHAR *name,
1304     int nname)
1305 {
1306     mxwriter *This = impl_from_ISAXContentHandler( iface );
1307     FIXME("(%p)->(%s)\n", This, debugstr_wn(name, nname));
1308     return E_NOTIMPL;
1309 }
1310
1311 static const struct ISAXContentHandlerVtbl SAXContentHandlerVtbl =
1312 {
1313     SAXContentHandler_QueryInterface,
1314     SAXContentHandler_AddRef,
1315     SAXContentHandler_Release,
1316     SAXContentHandler_putDocumentLocator,
1317     SAXContentHandler_startDocument,
1318     SAXContentHandler_endDocument,
1319     SAXContentHandler_startPrefixMapping,
1320     SAXContentHandler_endPrefixMapping,
1321     SAXContentHandler_startElement,
1322     SAXContentHandler_endElement,
1323     SAXContentHandler_characters,
1324     SAXContentHandler_ignorableWhitespace,
1325     SAXContentHandler_processingInstruction,
1326     SAXContentHandler_skippedEntity
1327 };
1328
1329 /*** ISAXLexicalHandler ***/
1330 static HRESULT WINAPI SAXLexicalHandler_QueryInterface(ISAXLexicalHandler *iface,
1331     REFIID riid, void **obj)
1332 {
1333     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1334     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
1335 }
1336
1337 static ULONG WINAPI SAXLexicalHandler_AddRef(ISAXLexicalHandler *iface)
1338 {
1339     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1340     return IMXWriter_AddRef(&This->IMXWriter_iface);
1341 }
1342
1343 static ULONG WINAPI SAXLexicalHandler_Release(ISAXLexicalHandler *iface)
1344 {
1345     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1346     return IMXWriter_Release(&This->IMXWriter_iface);
1347 }
1348
1349 static HRESULT WINAPI SAXLexicalHandler_startDTD(ISAXLexicalHandler *iface,
1350     const WCHAR *name, int name_len, const WCHAR *publicId, int publicId_len,
1351     const WCHAR *systemId, int systemId_len)
1352 {
1353     static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',' '};
1354     static const WCHAR openintW[] = {'[','\r','\n'};
1355
1356     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1357
1358     TRACE("(%p)->(%s %s %s)\n", This, debugstr_wn(name, name_len), debugstr_wn(publicId, publicId_len),
1359         debugstr_wn(systemId, systemId_len));
1360
1361     if (!name) return E_INVALIDARG;
1362
1363     write_output_buffer(This->buffer, doctypeW, sizeof(doctypeW)/sizeof(WCHAR));
1364
1365     if (*name)
1366     {
1367         write_output_buffer(This->buffer, name, name_len);
1368         write_output_buffer(This->buffer, spaceW, 1);
1369     }
1370
1371     if (publicId)
1372     {
1373         static const WCHAR publicW[] = {'P','U','B','L','I','C',' '};
1374
1375         write_output_buffer(This->buffer, publicW, sizeof(publicW)/sizeof(WCHAR));
1376         write_output_buffer_quoted(This->buffer, publicId, publicId_len);
1377
1378         if (!systemId) return E_INVALIDARG;
1379
1380         if (*publicId)
1381             write_output_buffer(This->buffer, spaceW, 1);
1382
1383         write_output_buffer_quoted(This->buffer, systemId, systemId_len);
1384
1385         if (*systemId)
1386             write_output_buffer(This->buffer, spaceW, 1);
1387     }
1388     else if (systemId)
1389     {
1390         static const WCHAR systemW[] = {'S','Y','S','T','E','M',' '};
1391
1392         write_output_buffer(This->buffer, systemW, sizeof(systemW)/sizeof(WCHAR));
1393         write_output_buffer_quoted(This->buffer, systemId, systemId_len);
1394         if (*systemId)
1395             write_output_buffer(This->buffer, spaceW, 1);
1396     }
1397
1398     write_output_buffer(This->buffer, openintW, sizeof(openintW)/sizeof(WCHAR));
1399
1400     return S_OK;
1401 }
1402
1403 static HRESULT WINAPI SAXLexicalHandler_endDTD(ISAXLexicalHandler *iface)
1404 {
1405     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1406     static const WCHAR closedtdW[] = {']','>','\r','\n'};
1407
1408     TRACE("(%p)\n", This);
1409
1410     write_output_buffer(This->buffer, closedtdW, sizeof(closedtdW)/sizeof(WCHAR));
1411
1412     return S_OK;
1413 }
1414
1415 static HRESULT WINAPI SAXLexicalHandler_startEntity(ISAXLexicalHandler *iface, const WCHAR *name, int len)
1416 {
1417     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1418     FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
1419     return E_NOTIMPL;
1420 }
1421
1422 static HRESULT WINAPI SAXLexicalHandler_endEntity(ISAXLexicalHandler *iface, const WCHAR *name, int len)
1423 {
1424     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1425     FIXME("(%p)->(%s): stub\n", This, debugstr_wn(name, len));
1426     return E_NOTIMPL;
1427 }
1428
1429 static HRESULT WINAPI SAXLexicalHandler_startCDATA(ISAXLexicalHandler *iface)
1430 {
1431     static const WCHAR scdataW[] = {'<','!','[','C','D','A','T','A','['};
1432     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1433
1434     TRACE("(%p)\n", This);
1435
1436     write_node_indent(This);
1437     write_output_buffer(This->buffer, scdataW, sizeof(scdataW)/sizeof(WCHAR));
1438     This->cdata = TRUE;
1439
1440     return S_OK;
1441 }
1442
1443 static HRESULT WINAPI SAXLexicalHandler_endCDATA(ISAXLexicalHandler *iface)
1444 {
1445     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1446     static const WCHAR ecdataW[] = {']',']','>'};
1447
1448     TRACE("(%p)\n", This);
1449
1450     write_output_buffer(This->buffer, ecdataW, sizeof(ecdataW)/sizeof(WCHAR));
1451     This->cdata = FALSE;
1452
1453     return S_OK;
1454 }
1455
1456 static HRESULT WINAPI SAXLexicalHandler_comment(ISAXLexicalHandler *iface, const WCHAR *chars, int nchars)
1457 {
1458     mxwriter *This = impl_from_ISAXLexicalHandler( iface );
1459     static const WCHAR copenW[] = {'<','!','-','-'};
1460     static const WCHAR ccloseW[] = {'-','-','>','\r','\n'};
1461
1462     TRACE("(%p)->(%s:%d)\n", This, debugstr_wn(chars, nchars), nchars);
1463
1464     if (!chars) return E_INVALIDARG;
1465
1466     close_element_starttag(This);
1467     write_node_indent(This);
1468
1469     write_output_buffer(This->buffer, copenW, sizeof(copenW)/sizeof(WCHAR));
1470     if (nchars)
1471         write_output_buffer(This->buffer, chars, nchars);
1472     write_output_buffer(This->buffer, ccloseW, sizeof(ccloseW)/sizeof(WCHAR));
1473
1474     return S_OK;
1475 }
1476
1477 static const struct ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl =
1478 {
1479     SAXLexicalHandler_QueryInterface,
1480     SAXLexicalHandler_AddRef,
1481     SAXLexicalHandler_Release,
1482     SAXLexicalHandler_startDTD,
1483     SAXLexicalHandler_endDTD,
1484     SAXLexicalHandler_startEntity,
1485     SAXLexicalHandler_endEntity,
1486     SAXLexicalHandler_startCDATA,
1487     SAXLexicalHandler_endCDATA,
1488     SAXLexicalHandler_comment
1489 };
1490
1491 /*** ISAXDeclHandler ***/
1492 static HRESULT WINAPI SAXDeclHandler_QueryInterface(ISAXDeclHandler *iface,
1493     REFIID riid, void **obj)
1494 {
1495     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1496     return IMXWriter_QueryInterface(&This->IMXWriter_iface, riid, obj);
1497 }
1498
1499 static ULONG WINAPI SAXDeclHandler_AddRef(ISAXDeclHandler *iface)
1500 {
1501     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1502     return IMXWriter_AddRef(&This->IMXWriter_iface);
1503 }
1504
1505 static ULONG WINAPI SAXDeclHandler_Release(ISAXDeclHandler *iface)
1506 {
1507     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1508     return IMXWriter_Release(&This->IMXWriter_iface);
1509 }
1510
1511 static HRESULT WINAPI SAXDeclHandler_elementDecl(ISAXDeclHandler *iface,
1512     const WCHAR *name, int n_name, const WCHAR *model, int n_model)
1513 {
1514     static const WCHAR elementW[] = {'<','!','E','L','E','M','E','N','T',' '};
1515     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1516
1517     TRACE("(%p)->(%s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
1518         debugstr_wn(model, n_model), n_model);
1519
1520     if (!name || !model) return E_INVALIDARG;
1521
1522     write_output_buffer(This->buffer, elementW, sizeof(elementW)/sizeof(WCHAR));
1523     if (n_name) {
1524         write_output_buffer(This->buffer, name, n_name);
1525         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1526     }
1527     if (n_model)
1528         write_output_buffer(This->buffer, model, n_model);
1529     write_output_buffer(This->buffer, closetagW, sizeof(closetagW)/sizeof(WCHAR));
1530
1531     return S_OK;
1532 }
1533
1534 static HRESULT WINAPI SAXDeclHandler_attributeDecl(ISAXDeclHandler *iface,
1535     const WCHAR *element, int n_element, const WCHAR *attr, int n_attr,
1536     const WCHAR *type, int n_type, const WCHAR *Default, int n_default,
1537     const WCHAR *value, int n_value)
1538 {
1539     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1540     static const WCHAR attlistW[] = {'<','!','A','T','T','L','I','S','T',' '};
1541     static const WCHAR closetagW[] = {'>','\r','\n'};
1542
1543     TRACE("(%p)->(%s:%d %s:%d %s:%d %s:%d %s:%d)\n", This, debugstr_wn(element, n_element), n_element,
1544         debugstr_wn(attr, n_attr), n_attr, debugstr_wn(type, n_type), n_type, debugstr_wn(Default, n_default), n_default,
1545         debugstr_wn(value, n_value), n_value);
1546
1547     write_output_buffer(This->buffer, attlistW, sizeof(attlistW)/sizeof(WCHAR));
1548     if (n_element) {
1549         write_output_buffer(This->buffer, element, n_element);
1550         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1551     }
1552
1553     if (n_attr) {
1554         write_output_buffer(This->buffer, attr, n_attr);
1555         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1556     }
1557
1558     if (n_type) {
1559         write_output_buffer(This->buffer, type, n_type);
1560         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1561     }
1562
1563     if (n_default) {
1564         write_output_buffer(This->buffer, Default, n_default);
1565         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1566     }
1567
1568     if (n_value)
1569         write_output_buffer_quoted(This->buffer, value, n_value);
1570
1571     write_output_buffer(This->buffer, closetagW, sizeof(closetagW)/sizeof(WCHAR));
1572
1573     return S_OK;
1574 }
1575
1576 static HRESULT WINAPI SAXDeclHandler_internalEntityDecl(ISAXDeclHandler *iface,
1577     const WCHAR *name, int n_name, const WCHAR *value, int n_value)
1578 {
1579     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1580
1581     TRACE("(%p)->(%s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
1582         debugstr_wn(value, n_value), n_value);
1583
1584     if (!name || !value) return E_INVALIDARG;
1585
1586     write_output_buffer(This->buffer, entityW, sizeof(entityW)/sizeof(WCHAR));
1587     if (n_name) {
1588         write_output_buffer(This->buffer, name, n_name);
1589         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1590     }
1591
1592     if (n_value)
1593         write_output_buffer_quoted(This->buffer, value, n_value);
1594
1595     write_output_buffer(This->buffer, closetagW, sizeof(closetagW)/sizeof(WCHAR));
1596
1597     return S_OK;
1598 }
1599
1600 static HRESULT WINAPI SAXDeclHandler_externalEntityDecl(ISAXDeclHandler *iface,
1601     const WCHAR *name, int n_name, const WCHAR *publicId, int n_publicId,
1602     const WCHAR *systemId, int n_systemId)
1603 {
1604     static const WCHAR publicW[] = {'P','U','B','L','I','C',' '};
1605     static const WCHAR systemW[] = {'S','Y','S','T','E','M',' '};
1606     mxwriter *This = impl_from_ISAXDeclHandler( iface );
1607
1608     TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(name, n_name), n_name,
1609         debugstr_wn(publicId, n_publicId), n_publicId, debugstr_wn(systemId, n_systemId), n_systemId);
1610
1611     if (!name) return E_INVALIDARG;
1612     if (publicId && !systemId) return E_INVALIDARG;
1613     if (!publicId && !systemId) return E_INVALIDARG;
1614
1615     write_output_buffer(This->buffer, entityW, sizeof(entityW)/sizeof(WCHAR));
1616     if (n_name) {
1617         write_output_buffer(This->buffer, name, n_name);
1618         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1619     }
1620
1621     if (publicId)
1622     {
1623         write_output_buffer(This->buffer, publicW, sizeof(publicW)/sizeof(WCHAR));
1624         write_output_buffer_quoted(This->buffer, publicId, n_publicId);
1625         write_output_buffer(This->buffer, spaceW, sizeof(spaceW)/sizeof(WCHAR));
1626         write_output_buffer_quoted(This->buffer, systemId, n_systemId);
1627     }
1628     else
1629     {
1630         write_output_buffer(This->buffer, systemW, sizeof(systemW)/sizeof(WCHAR));
1631         write_output_buffer_quoted(This->buffer, systemId, n_systemId);
1632     }
1633
1634     write_output_buffer(This->buffer, closetagW, sizeof(closetagW)/sizeof(WCHAR));
1635
1636     return S_OK;
1637 }
1638
1639 static const ISAXDeclHandlerVtbl SAXDeclHandlerVtbl = {
1640     SAXDeclHandler_QueryInterface,
1641     SAXDeclHandler_AddRef,
1642     SAXDeclHandler_Release,
1643     SAXDeclHandler_elementDecl,
1644     SAXDeclHandler_attributeDecl,
1645     SAXDeclHandler_internalEntityDecl,
1646     SAXDeclHandler_externalEntityDecl
1647 };
1648
1649 static const tid_t mxwriter_iface_tids[] = {
1650     IMXWriter_tid,
1651     0
1652 };
1653
1654 static dispex_static_data_t mxwriter_dispex = {
1655     NULL,
1656     IMXWriter_tid,
1657     NULL,
1658     mxwriter_iface_tids
1659 };
1660
1661 HRESULT MXWriter_create(MSXML_VERSION version, IUnknown *outer, void **ppObj)
1662 {
1663     static const WCHAR version10W[] = {'1','.','0',0};
1664     mxwriter *This;
1665     HRESULT hr;
1666
1667     TRACE("(%p, %p)\n", outer, ppObj);
1668
1669     if (outer) FIXME("support aggregation, outer\n");
1670
1671     This = heap_alloc( sizeof (*This) );
1672     if(!This)
1673         return E_OUTOFMEMORY;
1674
1675     This->IMXWriter_iface.lpVtbl = &MXWriterVtbl;
1676     This->ISAXContentHandler_iface.lpVtbl = &SAXContentHandlerVtbl;
1677     This->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
1678     This->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
1679     This->ref = 1;
1680     This->class_version = version;
1681
1682     This->props[MXWriter_BOM] = VARIANT_TRUE;
1683     This->props[MXWriter_DisableEscaping] = VARIANT_FALSE;
1684     This->props[MXWriter_Indent] = VARIANT_FALSE;
1685     This->props[MXWriter_OmitXmlDecl] = VARIANT_FALSE;
1686     This->props[MXWriter_Standalone] = VARIANT_FALSE;
1687     This->prop_changed = FALSE;
1688     This->encoding = SysAllocString(utf16W);
1689     This->version  = SysAllocString(version10W);
1690     This->xml_enc  = XmlEncoding_UTF16;
1691
1692     This->element = NULL;
1693     This->cdata = FALSE;
1694     This->indent = 0;
1695     This->text = FALSE;
1696     This->newline = FALSE;
1697
1698     This->dest = NULL;
1699     This->dest_written = 0;
1700
1701     hr = alloc_output_buffer(This->xml_enc, &This->buffer);
1702     if (hr != S_OK) {
1703         SysFreeString(This->encoding);
1704         SysFreeString(This->version);
1705         heap_free(This);
1706         return hr;
1707     }
1708
1709     init_dispex(&This->dispex, (IUnknown*)&This->IMXWriter_iface, &mxwriter_dispex);
1710
1711     *ppObj = &This->IMXWriter_iface;
1712
1713     TRACE("returning iface %p\n", *ppObj);
1714
1715     return S_OK;
1716 }
1717
1718 static HRESULT WINAPI MXAttributes_QueryInterface(IMXAttributes *iface, REFIID riid, void **ppObj)
1719 {
1720     mxattributes *This = impl_from_IMXAttributes( iface );
1721
1722     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppObj);
1723
1724     *ppObj = NULL;
1725
1726     if ( IsEqualGUID( riid, &IID_IUnknown )  ||
1727          IsEqualGUID( riid, &IID_IDispatch ) ||
1728          IsEqualGUID( riid, &IID_IMXAttributes ))
1729     {
1730         *ppObj = iface;
1731     }
1732     else if ( IsEqualGUID( riid, &IID_ISAXAttributes ))
1733     {
1734         *ppObj = &This->ISAXAttributes_iface;
1735     }
1736     else if ( IsEqualGUID( riid, &IID_IVBSAXAttributes ))
1737     {
1738         *ppObj = &This->IVBSAXAttributes_iface;
1739     }
1740     else if (dispex_query_interface(&This->dispex, riid, ppObj))
1741     {
1742         return *ppObj ? S_OK : E_NOINTERFACE;
1743     }
1744     else
1745     {
1746         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1747         return E_NOINTERFACE;
1748     }
1749
1750     IMXAttributes_AddRef( iface );
1751
1752     return S_OK;
1753 }
1754
1755 static ULONG WINAPI MXAttributes_AddRef(IMXAttributes *iface)
1756 {
1757     mxattributes *This = impl_from_IMXAttributes( iface );
1758     ULONG ref = InterlockedIncrement( &This->ref );
1759     TRACE("(%p)->(%d)\n", This, ref );
1760     return ref;
1761 }
1762
1763 static ULONG WINAPI MXAttributes_Release(IMXAttributes *iface)
1764 {
1765     mxattributes *This = impl_from_IMXAttributes( iface );
1766     LONG ref = InterlockedDecrement( &This->ref );
1767
1768     TRACE("(%p)->(%d)\n", This, ref);
1769
1770     if (ref == 0)
1771     {
1772         int i;
1773
1774         for (i = 0; i < This->length; i++)
1775         {
1776             SysFreeString(This->attr[i].qname);
1777             SysFreeString(This->attr[i].local);
1778             SysFreeString(This->attr[i].uri);
1779             SysFreeString(This->attr[i].type);
1780             SysFreeString(This->attr[i].value);
1781         }
1782
1783         release_dispex(&This->dispex);
1784         heap_free(This->attr);
1785         heap_free(This);
1786     }
1787
1788     return ref;
1789 }
1790
1791 static HRESULT WINAPI MXAttributes_GetTypeInfoCount(IMXAttributes *iface, UINT* pctinfo)
1792 {
1793     mxattributes *This = impl_from_IMXAttributes( iface );
1794     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1795 }
1796
1797 static HRESULT WINAPI MXAttributes_GetTypeInfo(IMXAttributes *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1798 {
1799     mxattributes *This = impl_from_IMXAttributes( iface );
1800     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1801 }
1802
1803 static HRESULT WINAPI MXAttributes_GetIDsOfNames(
1804     IMXAttributes *iface,
1805     REFIID riid,
1806     LPOLESTR* rgszNames,
1807     UINT cNames,
1808     LCID lcid,
1809     DISPID* rgDispId)
1810 {
1811     mxattributes *This = impl_from_IMXAttributes( iface );
1812     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
1813         riid, rgszNames, cNames, lcid, rgDispId);
1814 }
1815
1816 static HRESULT WINAPI MXAttributes_Invoke(
1817     IMXAttributes *iface,
1818     DISPID dispIdMember,
1819     REFIID riid,
1820     LCID lcid,
1821     WORD wFlags,
1822     DISPPARAMS* pDispParams,
1823     VARIANT* pVarResult,
1824     EXCEPINFO* pExcepInfo,
1825     UINT* puArgErr)
1826 {
1827     mxattributes *This = impl_from_IMXAttributes( iface );
1828     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
1829         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1830 }
1831
1832 static HRESULT WINAPI MXAttributes_addAttribute(IMXAttributes *iface,
1833     BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
1834 {
1835     mxattributes *This = impl_from_IMXAttributes( iface );
1836     mxattribute *attr;
1837     HRESULT hr;
1838
1839     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(uri), debugstr_w(localName),
1840         debugstr_w(QName), debugstr_w(type), debugstr_w(value));
1841
1842     if ((!uri || !localName || !QName || !type || !value) && This->class_version != MSXML6)
1843         return E_INVALIDARG;
1844
1845     /* ensure array is large enough */
1846     hr = mxattributes_grow(This);
1847     if (hr != S_OK) return hr;
1848
1849     attr = &This->attr[This->length];
1850
1851     attr->qname = SysAllocString(QName);
1852     attr->local = SysAllocString(localName);
1853     attr->uri   = SysAllocString(uri);
1854     attr->type  = SysAllocString(type ? type : emptyW);
1855     attr->value = SysAllocString(value);
1856     This->length++;
1857
1858     return S_OK;
1859 }
1860
1861 static HRESULT WINAPI MXAttributes_addAttributeFromIndex(IMXAttributes *iface,
1862     VARIANT atts, int index)
1863 {
1864     mxattributes *This = impl_from_IMXAttributes( iface );
1865     FIXME("(%p)->(%s %d): stub\n", This, debugstr_variant(&atts), index);
1866     return E_NOTIMPL;
1867 }
1868
1869 static HRESULT WINAPI MXAttributes_clear(IMXAttributes *iface)
1870 {
1871     mxattributes *This = impl_from_IMXAttributes( iface );
1872     int i;
1873
1874     TRACE("(%p)\n", This);
1875
1876     for (i = 0; i < This->length; i++)
1877     {
1878         SysFreeString(This->attr[i].qname);
1879         SysFreeString(This->attr[i].local);
1880         SysFreeString(This->attr[i].uri);
1881         SysFreeString(This->attr[i].type);
1882         SysFreeString(This->attr[i].value);
1883         memset(&This->attr[i], 0, sizeof(mxattribute));
1884     }
1885
1886     This->length = 0;
1887
1888     return S_OK;
1889 }
1890
1891 static mxattribute *get_attribute_byindex(mxattributes *attrs, int index)
1892 {
1893     if (index < 0 || index >= attrs->length) return NULL;
1894     return &attrs->attr[index];
1895 }
1896
1897 static HRESULT WINAPI MXAttributes_removeAttribute(IMXAttributes *iface, int index)
1898 {
1899     mxattributes *This = impl_from_IMXAttributes( iface );
1900     mxattribute *dst;
1901
1902     TRACE("(%p)->(%d)\n", This, index);
1903
1904     if (!(dst = get_attribute_byindex(This, index))) return E_INVALIDARG;
1905
1906     /* no need to remove last attribute, just make it inaccessible */
1907     if (index + 1 == This->length)
1908     {
1909         This->length--;
1910         return S_OK;
1911     }
1912
1913     memmove(dst, dst + 1, (This->length-index-1)*sizeof(*dst));
1914     This->length--;
1915
1916     return S_OK;
1917 }
1918
1919 static HRESULT WINAPI MXAttributes_setAttribute(IMXAttributes *iface, int index,
1920     BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
1921 {
1922     mxattributes *This = impl_from_IMXAttributes( iface );
1923     FIXME("(%p)->(%d %s %s %s %s %s): stub\n", This, index, debugstr_w(uri),
1924         debugstr_w(localName), debugstr_w(QName), debugstr_w(type), debugstr_w(value));
1925     return E_NOTIMPL;
1926 }
1927
1928 static HRESULT WINAPI MXAttributes_setAttributes(IMXAttributes *iface, VARIANT atts)
1929 {
1930     mxattributes *This = impl_from_IMXAttributes( iface );
1931     FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&atts));
1932     return E_NOTIMPL;
1933 }
1934
1935 static HRESULT WINAPI MXAttributes_setLocalName(IMXAttributes *iface, int index,
1936     BSTR localName)
1937 {
1938     mxattributes *This = impl_from_IMXAttributes( iface );
1939     mxattribute *attr;
1940
1941     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(localName));
1942
1943     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1944
1945     SysFreeString(attr->local);
1946     attr->local = SysAllocString(localName);
1947
1948     return S_OK;
1949 }
1950
1951 static HRESULT WINAPI MXAttributes_setQName(IMXAttributes *iface, int index, BSTR QName)
1952 {
1953     mxattributes *This = impl_from_IMXAttributes( iface );
1954     mxattribute *attr;
1955
1956     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(QName));
1957
1958     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1959
1960     SysFreeString(attr->qname);
1961     attr->qname = SysAllocString(QName);
1962
1963     return S_OK;
1964 }
1965
1966 static HRESULT WINAPI MXAttributes_setURI(IMXAttributes *iface, int index, BSTR uri)
1967 {
1968     mxattributes *This = impl_from_IMXAttributes( iface );
1969     mxattribute *attr;
1970
1971     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(uri));
1972
1973     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1974
1975     SysFreeString(attr->uri);
1976     attr->uri = SysAllocString(uri);
1977
1978     return S_OK;
1979 }
1980
1981 static HRESULT WINAPI MXAttributes_setValue(IMXAttributes *iface, int index, BSTR value)
1982 {
1983     mxattributes *This = impl_from_IMXAttributes( iface );
1984     mxattribute *attr;
1985
1986     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(value));
1987
1988     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1989
1990     SysFreeString(attr->value);
1991     attr->value = SysAllocString(value);
1992
1993     return S_OK;
1994 }
1995
1996 static const IMXAttributesVtbl MXAttributesVtbl = {
1997     MXAttributes_QueryInterface,
1998     MXAttributes_AddRef,
1999     MXAttributes_Release,
2000     MXAttributes_GetTypeInfoCount,
2001     MXAttributes_GetTypeInfo,
2002     MXAttributes_GetIDsOfNames,
2003     MXAttributes_Invoke,
2004     MXAttributes_addAttribute,
2005     MXAttributes_addAttributeFromIndex,
2006     MXAttributes_clear,
2007     MXAttributes_removeAttribute,
2008     MXAttributes_setAttribute,
2009     MXAttributes_setAttributes,
2010     MXAttributes_setLocalName,
2011     MXAttributes_setQName,
2012     MXAttributes_setURI,
2013     MXAttributes_setValue
2014 };
2015
2016 static HRESULT WINAPI SAXAttributes_QueryInterface(ISAXAttributes *iface, REFIID riid, void **ppObj)
2017 {
2018     mxattributes *This = impl_from_ISAXAttributes( iface );
2019     return IMXAttributes_QueryInterface(&This->IMXAttributes_iface, riid, ppObj);
2020 }
2021
2022 static ULONG WINAPI SAXAttributes_AddRef(ISAXAttributes *iface)
2023 {
2024     mxattributes *This = impl_from_ISAXAttributes( iface );
2025     return IMXAttributes_AddRef(&This->IMXAttributes_iface);
2026 }
2027
2028 static ULONG WINAPI SAXAttributes_Release(ISAXAttributes *iface)
2029 {
2030     mxattributes *This = impl_from_ISAXAttributes( iface );
2031     return IMXAttributes_Release(&This->IMXAttributes_iface);
2032 }
2033
2034 static HRESULT WINAPI SAXAttributes_getLength(ISAXAttributes *iface, int *length)
2035 {
2036     mxattributes *This = impl_from_ISAXAttributes( iface );
2037     TRACE("(%p)->(%p)\n", This, length);
2038
2039     if (!length && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2040        return E_POINTER;
2041
2042     *length = This->length;
2043
2044     return S_OK;
2045 }
2046
2047 static HRESULT WINAPI SAXAttributes_getURI(ISAXAttributes *iface, int index, const WCHAR **uri,
2048     int *len)
2049 {
2050     mxattributes *This = impl_from_ISAXAttributes( iface );
2051
2052     TRACE("(%p)->(%d %p %p)\n", This, index, uri, len);
2053
2054     if (index >= This->length || index < 0) return E_INVALIDARG;
2055     if (!uri || !len) return E_POINTER;
2056
2057     *len = SysStringLen(This->attr[index].uri);
2058     *uri = This->attr[index].uri;
2059
2060     return S_OK;
2061 }
2062
2063 static HRESULT WINAPI SAXAttributes_getLocalName(ISAXAttributes *iface, int index, const WCHAR **name,
2064     int *len)
2065 {
2066     mxattributes *This = impl_from_ISAXAttributes( iface );
2067
2068     TRACE("(%p)->(%d %p %p)\n", This, index, name, len);
2069
2070     if (index >= This->length || index < 0) return E_INVALIDARG;
2071     if (!name || !len) return E_POINTER;
2072
2073     *len = SysStringLen(This->attr[index].local);
2074     *name = This->attr[index].local;
2075
2076     return S_OK;
2077 }
2078
2079 static HRESULT WINAPI SAXAttributes_getQName(ISAXAttributes *iface, int index, const WCHAR **qname, int *length)
2080 {
2081     mxattributes *This = impl_from_ISAXAttributes( iface );
2082
2083     TRACE("(%p)->(%d %p %p)\n", This, index, qname, length);
2084
2085     if (index >= This->length) return E_INVALIDARG;
2086     if (!qname || !length) return E_POINTER;
2087
2088     *qname = This->attr[index].qname;
2089     *length = SysStringLen(This->attr[index].qname);
2090
2091     return S_OK;
2092 }
2093
2094 static HRESULT WINAPI SAXAttributes_getName(ISAXAttributes *iface, int index, const WCHAR **uri, int *uri_len,
2095     const WCHAR **local, int *local_len, const WCHAR **qname, int *qname_len)
2096 {
2097     mxattributes *This = impl_from_ISAXAttributes( iface );
2098
2099     TRACE("(%p)->(%d %p %p %p %p %p %p)\n", This, index, uri, uri_len, local, local_len, qname, qname_len);
2100
2101     if (index >= This->length || index < 0)
2102         return E_INVALIDARG;
2103
2104     if (!uri || !uri_len || !local || !local_len || !qname || !qname_len)
2105         return E_POINTER;
2106
2107     *uri_len = SysStringLen(This->attr[index].uri);
2108     *uri = This->attr[index].uri;
2109
2110     *local_len = SysStringLen(This->attr[index].local);
2111     *local = This->attr[index].local;
2112
2113     *qname_len = SysStringLen(This->attr[index].qname);
2114     *qname = This->attr[index].qname;
2115
2116     TRACE("(%s, %s, %s)\n", debugstr_w(*uri), debugstr_w(*local), debugstr_w(*qname));
2117
2118     return S_OK;
2119 }
2120
2121 static HRESULT WINAPI SAXAttributes_getIndexFromName(ISAXAttributes *iface, const WCHAR *uri, int uri_len,
2122     const WCHAR *name, int len, int *index)
2123 {
2124     mxattributes *This = impl_from_ISAXAttributes( iface );
2125     int i;
2126
2127     TRACE("(%p)->(%s:%d %s:%d %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
2128         debugstr_wn(name, len), len, index);
2129
2130     if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2131         return E_POINTER;
2132
2133     if (!uri || !name || !index) return E_INVALIDARG;
2134
2135     for (i = 0; i < This->length; i++)
2136     {
2137         if (uri_len != SysStringLen(This->attr[i].uri)) continue;
2138         if (strncmpW(uri, This->attr[i].uri, uri_len)) continue;
2139
2140         if (len != SysStringLen(This->attr[i].local)) continue;
2141         if (strncmpW(name, This->attr[i].local, len)) continue;
2142
2143         *index = i;
2144         return S_OK;
2145     }
2146
2147     return E_INVALIDARG;
2148 }
2149
2150 static HRESULT WINAPI SAXAttributes_getIndexFromQName(ISAXAttributes *iface, const WCHAR *qname,
2151     int len, int *index)
2152 {
2153     mxattributes *This = impl_from_ISAXAttributes( iface );
2154     int i;
2155
2156     TRACE("(%p)->(%s:%d %p)\n", This, debugstr_wn(qname, len), len, index);
2157
2158     if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2159         return E_POINTER;
2160
2161     if (!qname || !index || !len) return E_INVALIDARG;
2162
2163     for (i = 0; i < This->length; i++)
2164     {
2165         if (len != SysStringLen(This->attr[i].qname)) continue;
2166         if (strncmpW(qname, This->attr[i].qname, len)) continue;
2167
2168         *index = i;
2169         return S_OK;
2170     }
2171
2172     return E_INVALIDARG;
2173 }
2174
2175 static HRESULT WINAPI SAXAttributes_getType(ISAXAttributes *iface, int index, const WCHAR **type,
2176     int *len)
2177 {
2178     mxattributes *This = impl_from_ISAXAttributes( iface );
2179
2180     TRACE("(%p)->(%d %p %p)\n", This, index, type, len);
2181
2182     if (index >= This->length) return E_INVALIDARG;
2183
2184     if ((!type || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2185        return E_POINTER;
2186
2187     *type = This->attr[index].type;
2188     *len = SysStringLen(This->attr[index].type);
2189
2190     return S_OK;
2191 }
2192
2193 static HRESULT WINAPI SAXAttributes_getTypeFromName(ISAXAttributes *iface, const WCHAR * pUri, int nUri,
2194     const WCHAR * pLocalName, int nLocalName, const WCHAR ** pType, int * nType)
2195 {
2196     mxattributes *This = impl_from_ISAXAttributes( iface );
2197     FIXME("(%p)->(%s:%d %s:%d %p %p): stub\n", This, debugstr_wn(pUri, nUri), nUri,
2198         debugstr_wn(pLocalName, nLocalName), nLocalName, pType, nType);
2199     return E_NOTIMPL;
2200 }
2201
2202 static HRESULT WINAPI SAXAttributes_getTypeFromQName(ISAXAttributes *iface, const WCHAR * pQName,
2203     int nQName, const WCHAR ** pType, int * nType)
2204 {
2205     mxattributes *This = impl_from_ISAXAttributes( iface );
2206     FIXME("(%p)->(%s:%d %p %p): stub\n", This, debugstr_wn(pQName, nQName), nQName, pType, nType);
2207     return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI SAXAttributes_getValue(ISAXAttributes *iface, int index, const WCHAR **value,
2211     int *len)
2212 {
2213     mxattributes *This = impl_from_ISAXAttributes( iface );
2214
2215     TRACE("(%p)->(%d %p %p)\n", This, index, value, len);
2216
2217     if (index >= This->length) return E_INVALIDARG;
2218
2219     if ((!value || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2220        return E_POINTER;
2221
2222     *value = This->attr[index].value;
2223     *len = SysStringLen(This->attr[index].value);
2224
2225     return S_OK;
2226 }
2227
2228 static HRESULT WINAPI SAXAttributes_getValueFromName(ISAXAttributes *iface, const WCHAR *uri,
2229     int uri_len, const WCHAR *name, int name_len, const WCHAR **value, int *value_len)
2230 {
2231     mxattributes *This = impl_from_ISAXAttributes( iface );
2232     HRESULT hr;
2233     int index;
2234
2235     TRACE("(%p)->(%s:%d %s:%d %p %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
2236         debugstr_wn(name, name_len), name_len, value, value_len);
2237
2238     if (!uri || !name || !value || !value_len)
2239         return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
2240
2241     hr = ISAXAttributes_getIndexFromName(iface, uri, uri_len, name, name_len, &index);
2242     if (hr == S_OK)
2243         hr = ISAXAttributes_getValue(iface, index, value, value_len);
2244
2245     return hr;
2246 }
2247
2248 static HRESULT WINAPI SAXAttributes_getValueFromQName(ISAXAttributes *iface, const WCHAR *qname,
2249     int qname_len, const WCHAR **value, int *value_len)
2250 {
2251     mxattributes *This = impl_from_ISAXAttributes( iface );
2252     HRESULT hr;
2253     int index;
2254
2255     TRACE("(%p)->(%s:%d %p %p)\n", This, debugstr_wn(qname, qname_len), qname_len, value, value_len);
2256
2257     if (!qname || !value || !value_len)
2258         return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
2259
2260     hr = ISAXAttributes_getIndexFromQName(iface, qname, qname_len, &index);
2261     if (hr == S_OK)
2262         hr = ISAXAttributes_getValue(iface, index, value, value_len);
2263
2264     return hr;
2265 }
2266
2267 static const ISAXAttributesVtbl SAXAttributesVtbl = {
2268     SAXAttributes_QueryInterface,
2269     SAXAttributes_AddRef,
2270     SAXAttributes_Release,
2271     SAXAttributes_getLength,
2272     SAXAttributes_getURI,
2273     SAXAttributes_getLocalName,
2274     SAXAttributes_getQName,
2275     SAXAttributes_getName,
2276     SAXAttributes_getIndexFromName,
2277     SAXAttributes_getIndexFromQName,
2278     SAXAttributes_getType,
2279     SAXAttributes_getTypeFromName,
2280     SAXAttributes_getTypeFromQName,
2281     SAXAttributes_getValue,
2282     SAXAttributes_getValueFromName,
2283     SAXAttributes_getValueFromQName
2284 };
2285
2286 static HRESULT WINAPI VBSAXAttributes_QueryInterface(
2287         IVBSAXAttributes* iface,
2288         REFIID riid,
2289         void **ppvObject)
2290 {
2291     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2292     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
2293     return ISAXAttributes_QueryInterface(&This->ISAXAttributes_iface, riid, ppvObject);
2294 }
2295
2296 static ULONG WINAPI VBSAXAttributes_AddRef(IVBSAXAttributes* iface)
2297 {
2298     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2299     return ISAXAttributes_AddRef(&This->ISAXAttributes_iface);
2300 }
2301
2302 static ULONG WINAPI VBSAXAttributes_Release(IVBSAXAttributes* iface)
2303 {
2304     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2305     return ISAXAttributes_Release(&This->ISAXAttributes_iface);
2306 }
2307
2308 static HRESULT WINAPI VBSAXAttributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
2309 {
2310     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2311
2312     TRACE("(%p)->(%p)\n", This, pctinfo);
2313
2314     *pctinfo = 1;
2315
2316     return S_OK;
2317 }
2318
2319 static HRESULT WINAPI VBSAXAttributes_GetTypeInfo(
2320     IVBSAXAttributes *iface,
2321     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2322 {
2323     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2324     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2325     return get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
2326 }
2327
2328 static HRESULT WINAPI VBSAXAttributes_GetIDsOfNames(
2329     IVBSAXAttributes *iface,
2330     REFIID riid,
2331     LPOLESTR* rgszNames,
2332     UINT cNames,
2333     LCID lcid,
2334     DISPID* rgDispId)
2335 {
2336     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2337     ITypeInfo *typeinfo;
2338     HRESULT hr;
2339
2340     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2341           lcid, rgDispId);
2342
2343     if(!rgszNames || cNames == 0 || !rgDispId)
2344         return E_INVALIDARG;
2345
2346     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
2347     if(SUCCEEDED(hr))
2348     {
2349         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2350         ITypeInfo_Release(typeinfo);
2351     }
2352
2353     return hr;
2354 }
2355
2356 static HRESULT WINAPI VBSAXAttributes_Invoke(
2357     IVBSAXAttributes *iface,
2358     DISPID dispIdMember,
2359     REFIID riid,
2360     LCID lcid,
2361     WORD wFlags,
2362     DISPPARAMS* pDispParams,
2363     VARIANT* pVarResult,
2364     EXCEPINFO* pExcepInfo,
2365     UINT* puArgErr)
2366 {
2367     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2368     ITypeInfo *typeinfo;
2369     HRESULT hr;
2370
2371     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2372           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2373
2374     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
2375     if(SUCCEEDED(hr))
2376     {
2377         hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXAttributes_iface, dispIdMember, wFlags,
2378                 pDispParams, pVarResult, pExcepInfo, puArgErr);
2379         ITypeInfo_Release(typeinfo);
2380     }
2381
2382     return hr;
2383 }
2384
2385 static HRESULT WINAPI VBSAXAttributes_get_length(IVBSAXAttributes* iface, int *len)
2386 {
2387     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2388     return ISAXAttributes_getLength(&This->ISAXAttributes_iface, len);
2389 }
2390
2391 static HRESULT WINAPI VBSAXAttributes_getURI(IVBSAXAttributes* iface, int index, BSTR *uri)
2392 {
2393     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2394     int len;
2395
2396     return ISAXAttributes_getURI(&This->ISAXAttributes_iface, index, (const WCHAR**)uri, &len);
2397 }
2398
2399 static HRESULT WINAPI VBSAXAttributes_getLocalName(IVBSAXAttributes* iface, int index, BSTR *name)
2400 {
2401     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2402     int len;
2403
2404     return ISAXAttributes_getLocalName(&This->ISAXAttributes_iface, index, (const WCHAR**)name, &len);
2405 }
2406
2407 static HRESULT WINAPI VBSAXAttributes_getQName(IVBSAXAttributes* iface, int index, BSTR *qname)
2408 {
2409     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2410     int len;
2411
2412     return ISAXAttributes_getQName(&This->ISAXAttributes_iface, index, (const WCHAR**)qname, &len);
2413 }
2414
2415 static HRESULT WINAPI VBSAXAttributes_getIndexFromName(IVBSAXAttributes* iface, BSTR uri, BSTR name, int *index)
2416 {
2417     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2418     return ISAXAttributes_getIndexFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2419             name, SysStringLen(name), index);
2420 }
2421
2422 static HRESULT WINAPI VBSAXAttributes_getIndexFromQName(IVBSAXAttributes* iface, BSTR qname, int *index)
2423 {
2424     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2425     return ISAXAttributes_getIndexFromQName(&This->ISAXAttributes_iface, qname,
2426             SysStringLen(qname), index);
2427 }
2428
2429 static HRESULT WINAPI VBSAXAttributes_getType(IVBSAXAttributes* iface, int index,BSTR *type)
2430 {
2431     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2432     int len;
2433
2434     return ISAXAttributes_getType(&This->ISAXAttributes_iface, index, (const WCHAR**)type, &len);
2435 }
2436
2437 static HRESULT WINAPI VBSAXAttributes_getTypeFromName(IVBSAXAttributes* iface, BSTR uri,
2438     BSTR name, BSTR *type)
2439 {
2440     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2441     int len;
2442
2443     return ISAXAttributes_getTypeFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2444             name, SysStringLen(name), (const WCHAR**)type, &len);
2445 }
2446
2447 static HRESULT WINAPI VBSAXAttributes_getTypeFromQName(IVBSAXAttributes* iface, BSTR qname, BSTR *type)
2448 {
2449     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2450     int len;
2451
2452     return ISAXAttributes_getTypeFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
2453             (const WCHAR**)type, &len);
2454 }
2455
2456 static HRESULT WINAPI VBSAXAttributes_getValue(IVBSAXAttributes* iface, int index, BSTR *value)
2457 {
2458     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2459     int len;
2460
2461     return ISAXAttributes_getValue(&This->ISAXAttributes_iface, index, (const WCHAR**)value, &len);
2462 }
2463
2464 static HRESULT WINAPI VBSAXAttributes_getValueFromName(IVBSAXAttributes* iface, BSTR uri, BSTR name,
2465     BSTR *value)
2466 {
2467     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2468     int len;
2469
2470     return ISAXAttributes_getValueFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2471             name, SysStringLen(name), (const WCHAR**)value, &len);
2472 }
2473
2474 static HRESULT WINAPI VBSAXAttributes_getValueFromQName(IVBSAXAttributes* iface, BSTR qname, BSTR *value)
2475 {
2476     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2477     int len;
2478
2479     return ISAXAttributes_getValueFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
2480         (const WCHAR**)value, &len);
2481 }
2482
2483 static const struct IVBSAXAttributesVtbl VBSAXAttributesVtbl =
2484 {
2485     VBSAXAttributes_QueryInterface,
2486     VBSAXAttributes_AddRef,
2487     VBSAXAttributes_Release,
2488     VBSAXAttributes_GetTypeInfoCount,
2489     VBSAXAttributes_GetTypeInfo,
2490     VBSAXAttributes_GetIDsOfNames,
2491     VBSAXAttributes_Invoke,
2492     VBSAXAttributes_get_length,
2493     VBSAXAttributes_getURI,
2494     VBSAXAttributes_getLocalName,
2495     VBSAXAttributes_getQName,
2496     VBSAXAttributes_getIndexFromName,
2497     VBSAXAttributes_getIndexFromQName,
2498     VBSAXAttributes_getType,
2499     VBSAXAttributes_getTypeFromName,
2500     VBSAXAttributes_getTypeFromQName,
2501     VBSAXAttributes_getValue,
2502     VBSAXAttributes_getValueFromName,
2503     VBSAXAttributes_getValueFromQName
2504 };
2505
2506 static const tid_t mxattrs_iface_tids[] = {
2507     IMXAttributes_tid,
2508     0
2509 };
2510
2511 static dispex_static_data_t mxattrs_dispex = {
2512     NULL,
2513     IMXAttributes_tid,
2514     NULL,
2515     mxattrs_iface_tids
2516 };
2517
2518 HRESULT SAXAttributes_create(MSXML_VERSION version, IUnknown *outer, void **ppObj)
2519 {
2520     static const int default_count = 10;
2521     mxattributes *This;
2522
2523     TRACE("(%p, %p)\n", outer, ppObj);
2524
2525     This = heap_alloc( sizeof (*This) );
2526     if( !This )
2527         return E_OUTOFMEMORY;
2528
2529     This->IMXAttributes_iface.lpVtbl = &MXAttributesVtbl;
2530     This->ISAXAttributes_iface.lpVtbl = &SAXAttributesVtbl;
2531     This->IVBSAXAttributes_iface.lpVtbl = &VBSAXAttributesVtbl;
2532     This->ref = 1;
2533
2534     This->class_version = version;
2535
2536     This->attr = heap_alloc(default_count*sizeof(mxattribute));
2537     This->length = 0;
2538     This->allocated = default_count;
2539
2540     *ppObj = &This->IMXAttributes_iface;
2541
2542     init_dispex(&This->dispex, (IUnknown*)&This->IMXAttributes_iface, &mxattrs_dispex);
2543
2544     TRACE("returning iface %p\n", *ppObj);
2545
2546     return S_OK;
2547 }