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, void **ppObj)
1662 {
1663     static const WCHAR version10W[] = {'1','.','0',0};
1664     mxwriter *This;
1665     HRESULT hr;
1666
1667     TRACE("(%p)\n", ppObj);
1668
1669     This = heap_alloc( sizeof (*This) );
1670     if(!This)
1671         return E_OUTOFMEMORY;
1672
1673     This->IMXWriter_iface.lpVtbl = &MXWriterVtbl;
1674     This->ISAXContentHandler_iface.lpVtbl = &SAXContentHandlerVtbl;
1675     This->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
1676     This->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
1677     This->ref = 1;
1678     This->class_version = version;
1679
1680     This->props[MXWriter_BOM] = VARIANT_TRUE;
1681     This->props[MXWriter_DisableEscaping] = VARIANT_FALSE;
1682     This->props[MXWriter_Indent] = VARIANT_FALSE;
1683     This->props[MXWriter_OmitXmlDecl] = VARIANT_FALSE;
1684     This->props[MXWriter_Standalone] = VARIANT_FALSE;
1685     This->prop_changed = FALSE;
1686     This->encoding = SysAllocString(utf16W);
1687     This->version  = SysAllocString(version10W);
1688     This->xml_enc  = XmlEncoding_UTF16;
1689
1690     This->element = NULL;
1691     This->cdata = FALSE;
1692     This->indent = 0;
1693     This->text = FALSE;
1694     This->newline = FALSE;
1695
1696     This->dest = NULL;
1697     This->dest_written = 0;
1698
1699     hr = alloc_output_buffer(This->xml_enc, &This->buffer);
1700     if (hr != S_OK) {
1701         SysFreeString(This->encoding);
1702         SysFreeString(This->version);
1703         heap_free(This);
1704         return hr;
1705     }
1706
1707     init_dispex(&This->dispex, (IUnknown*)&This->IMXWriter_iface, &mxwriter_dispex);
1708
1709     *ppObj = &This->IMXWriter_iface;
1710
1711     TRACE("returning iface %p\n", *ppObj);
1712
1713     return S_OK;
1714 }
1715
1716 static HRESULT WINAPI MXAttributes_QueryInterface(IMXAttributes *iface, REFIID riid, void **ppObj)
1717 {
1718     mxattributes *This = impl_from_IMXAttributes( iface );
1719
1720     TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppObj);
1721
1722     *ppObj = NULL;
1723
1724     if ( IsEqualGUID( riid, &IID_IUnknown )  ||
1725          IsEqualGUID( riid, &IID_IDispatch ) ||
1726          IsEqualGUID( riid, &IID_IMXAttributes ))
1727     {
1728         *ppObj = iface;
1729     }
1730     else if ( IsEqualGUID( riid, &IID_ISAXAttributes ))
1731     {
1732         *ppObj = &This->ISAXAttributes_iface;
1733     }
1734     else if ( IsEqualGUID( riid, &IID_IVBSAXAttributes ))
1735     {
1736         *ppObj = &This->IVBSAXAttributes_iface;
1737     }
1738     else if (dispex_query_interface(&This->dispex, riid, ppObj))
1739     {
1740         return *ppObj ? S_OK : E_NOINTERFACE;
1741     }
1742     else
1743     {
1744         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1745         return E_NOINTERFACE;
1746     }
1747
1748     IMXAttributes_AddRef( iface );
1749
1750     return S_OK;
1751 }
1752
1753 static ULONG WINAPI MXAttributes_AddRef(IMXAttributes *iface)
1754 {
1755     mxattributes *This = impl_from_IMXAttributes( iface );
1756     ULONG ref = InterlockedIncrement( &This->ref );
1757     TRACE("(%p)->(%d)\n", This, ref );
1758     return ref;
1759 }
1760
1761 static ULONG WINAPI MXAttributes_Release(IMXAttributes *iface)
1762 {
1763     mxattributes *This = impl_from_IMXAttributes( iface );
1764     LONG ref = InterlockedDecrement( &This->ref );
1765
1766     TRACE("(%p)->(%d)\n", This, ref);
1767
1768     if (ref == 0)
1769     {
1770         int i;
1771
1772         for (i = 0; i < This->length; i++)
1773         {
1774             SysFreeString(This->attr[i].qname);
1775             SysFreeString(This->attr[i].local);
1776             SysFreeString(This->attr[i].uri);
1777             SysFreeString(This->attr[i].type);
1778             SysFreeString(This->attr[i].value);
1779         }
1780
1781         release_dispex(&This->dispex);
1782         heap_free(This->attr);
1783         heap_free(This);
1784     }
1785
1786     return ref;
1787 }
1788
1789 static HRESULT WINAPI MXAttributes_GetTypeInfoCount(IMXAttributes *iface, UINT* pctinfo)
1790 {
1791     mxattributes *This = impl_from_IMXAttributes( iface );
1792     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1793 }
1794
1795 static HRESULT WINAPI MXAttributes_GetTypeInfo(IMXAttributes *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1796 {
1797     mxattributes *This = impl_from_IMXAttributes( iface );
1798     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1799 }
1800
1801 static HRESULT WINAPI MXAttributes_GetIDsOfNames(
1802     IMXAttributes *iface,
1803     REFIID riid,
1804     LPOLESTR* rgszNames,
1805     UINT cNames,
1806     LCID lcid,
1807     DISPID* rgDispId)
1808 {
1809     mxattributes *This = impl_from_IMXAttributes( iface );
1810     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
1811         riid, rgszNames, cNames, lcid, rgDispId);
1812 }
1813
1814 static HRESULT WINAPI MXAttributes_Invoke(
1815     IMXAttributes *iface,
1816     DISPID dispIdMember,
1817     REFIID riid,
1818     LCID lcid,
1819     WORD wFlags,
1820     DISPPARAMS* pDispParams,
1821     VARIANT* pVarResult,
1822     EXCEPINFO* pExcepInfo,
1823     UINT* puArgErr)
1824 {
1825     mxattributes *This = impl_from_IMXAttributes( iface );
1826     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
1827         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1828 }
1829
1830 static HRESULT WINAPI MXAttributes_addAttribute(IMXAttributes *iface,
1831     BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
1832 {
1833     mxattributes *This = impl_from_IMXAttributes( iface );
1834     mxattribute *attr;
1835     HRESULT hr;
1836
1837     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(uri), debugstr_w(localName),
1838         debugstr_w(QName), debugstr_w(type), debugstr_w(value));
1839
1840     if ((!uri || !localName || !QName || !type || !value) && This->class_version != MSXML6)
1841         return E_INVALIDARG;
1842
1843     /* ensure array is large enough */
1844     hr = mxattributes_grow(This);
1845     if (hr != S_OK) return hr;
1846
1847     attr = &This->attr[This->length];
1848
1849     attr->qname = SysAllocString(QName);
1850     attr->local = SysAllocString(localName);
1851     attr->uri   = SysAllocString(uri);
1852     attr->type  = SysAllocString(type ? type : emptyW);
1853     attr->value = SysAllocString(value);
1854     This->length++;
1855
1856     return S_OK;
1857 }
1858
1859 static HRESULT WINAPI MXAttributes_addAttributeFromIndex(IMXAttributes *iface,
1860     VARIANT atts, int index)
1861 {
1862     mxattributes *This = impl_from_IMXAttributes( iface );
1863     FIXME("(%p)->(%s %d): stub\n", This, debugstr_variant(&atts), index);
1864     return E_NOTIMPL;
1865 }
1866
1867 static HRESULT WINAPI MXAttributes_clear(IMXAttributes *iface)
1868 {
1869     mxattributes *This = impl_from_IMXAttributes( iface );
1870     int i;
1871
1872     TRACE("(%p)\n", This);
1873
1874     for (i = 0; i < This->length; i++)
1875     {
1876         SysFreeString(This->attr[i].qname);
1877         SysFreeString(This->attr[i].local);
1878         SysFreeString(This->attr[i].uri);
1879         SysFreeString(This->attr[i].type);
1880         SysFreeString(This->attr[i].value);
1881         memset(&This->attr[i], 0, sizeof(mxattribute));
1882     }
1883
1884     This->length = 0;
1885
1886     return S_OK;
1887 }
1888
1889 static mxattribute *get_attribute_byindex(mxattributes *attrs, int index)
1890 {
1891     if (index < 0 || index >= attrs->length) return NULL;
1892     return &attrs->attr[index];
1893 }
1894
1895 static HRESULT WINAPI MXAttributes_removeAttribute(IMXAttributes *iface, int index)
1896 {
1897     mxattributes *This = impl_from_IMXAttributes( iface );
1898     mxattribute *dst;
1899
1900     TRACE("(%p)->(%d)\n", This, index);
1901
1902     if (!(dst = get_attribute_byindex(This, index))) return E_INVALIDARG;
1903
1904     /* no need to remove last attribute, just make it inaccessible */
1905     if (index + 1 == This->length)
1906     {
1907         This->length--;
1908         return S_OK;
1909     }
1910
1911     memmove(dst, dst + 1, (This->length-index-1)*sizeof(*dst));
1912     This->length--;
1913
1914     return S_OK;
1915 }
1916
1917 static HRESULT WINAPI MXAttributes_setAttribute(IMXAttributes *iface, int index,
1918     BSTR uri, BSTR localName, BSTR QName, BSTR type, BSTR value)
1919 {
1920     mxattributes *This = impl_from_IMXAttributes( iface );
1921     FIXME("(%p)->(%d %s %s %s %s %s): stub\n", This, index, debugstr_w(uri),
1922         debugstr_w(localName), debugstr_w(QName), debugstr_w(type), debugstr_w(value));
1923     return E_NOTIMPL;
1924 }
1925
1926 static HRESULT WINAPI MXAttributes_setAttributes(IMXAttributes *iface, VARIANT atts)
1927 {
1928     mxattributes *This = impl_from_IMXAttributes( iface );
1929     FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&atts));
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI MXAttributes_setLocalName(IMXAttributes *iface, int index,
1934     BSTR localName)
1935 {
1936     mxattributes *This = impl_from_IMXAttributes( iface );
1937     mxattribute *attr;
1938
1939     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(localName));
1940
1941     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1942
1943     SysFreeString(attr->local);
1944     attr->local = SysAllocString(localName);
1945
1946     return S_OK;
1947 }
1948
1949 static HRESULT WINAPI MXAttributes_setQName(IMXAttributes *iface, int index, BSTR QName)
1950 {
1951     mxattributes *This = impl_from_IMXAttributes( iface );
1952     mxattribute *attr;
1953
1954     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(QName));
1955
1956     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1957
1958     SysFreeString(attr->qname);
1959     attr->qname = SysAllocString(QName);
1960
1961     return S_OK;
1962 }
1963
1964 static HRESULT WINAPI MXAttributes_setURI(IMXAttributes *iface, int index, BSTR uri)
1965 {
1966     mxattributes *This = impl_from_IMXAttributes( iface );
1967     mxattribute *attr;
1968
1969     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(uri));
1970
1971     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1972
1973     SysFreeString(attr->uri);
1974     attr->uri = SysAllocString(uri);
1975
1976     return S_OK;
1977 }
1978
1979 static HRESULT WINAPI MXAttributes_setValue(IMXAttributes *iface, int index, BSTR value)
1980 {
1981     mxattributes *This = impl_from_IMXAttributes( iface );
1982     mxattribute *attr;
1983
1984     TRACE("(%p)->(%d %s)\n", This, index, debugstr_w(value));
1985
1986     if (!(attr = get_attribute_byindex(This, index))) return E_INVALIDARG;
1987
1988     SysFreeString(attr->value);
1989     attr->value = SysAllocString(value);
1990
1991     return S_OK;
1992 }
1993
1994 static const IMXAttributesVtbl MXAttributesVtbl = {
1995     MXAttributes_QueryInterface,
1996     MXAttributes_AddRef,
1997     MXAttributes_Release,
1998     MXAttributes_GetTypeInfoCount,
1999     MXAttributes_GetTypeInfo,
2000     MXAttributes_GetIDsOfNames,
2001     MXAttributes_Invoke,
2002     MXAttributes_addAttribute,
2003     MXAttributes_addAttributeFromIndex,
2004     MXAttributes_clear,
2005     MXAttributes_removeAttribute,
2006     MXAttributes_setAttribute,
2007     MXAttributes_setAttributes,
2008     MXAttributes_setLocalName,
2009     MXAttributes_setQName,
2010     MXAttributes_setURI,
2011     MXAttributes_setValue
2012 };
2013
2014 static HRESULT WINAPI SAXAttributes_QueryInterface(ISAXAttributes *iface, REFIID riid, void **ppObj)
2015 {
2016     mxattributes *This = impl_from_ISAXAttributes( iface );
2017     return IMXAttributes_QueryInterface(&This->IMXAttributes_iface, riid, ppObj);
2018 }
2019
2020 static ULONG WINAPI SAXAttributes_AddRef(ISAXAttributes *iface)
2021 {
2022     mxattributes *This = impl_from_ISAXAttributes( iface );
2023     return IMXAttributes_AddRef(&This->IMXAttributes_iface);
2024 }
2025
2026 static ULONG WINAPI SAXAttributes_Release(ISAXAttributes *iface)
2027 {
2028     mxattributes *This = impl_from_ISAXAttributes( iface );
2029     return IMXAttributes_Release(&This->IMXAttributes_iface);
2030 }
2031
2032 static HRESULT WINAPI SAXAttributes_getLength(ISAXAttributes *iface, int *length)
2033 {
2034     mxattributes *This = impl_from_ISAXAttributes( iface );
2035     TRACE("(%p)->(%p)\n", This, length);
2036
2037     if (!length && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2038        return E_POINTER;
2039
2040     *length = This->length;
2041
2042     return S_OK;
2043 }
2044
2045 static HRESULT WINAPI SAXAttributes_getURI(ISAXAttributes *iface, int index, const WCHAR **uri,
2046     int *len)
2047 {
2048     mxattributes *This = impl_from_ISAXAttributes( iface );
2049
2050     TRACE("(%p)->(%d %p %p)\n", This, index, uri, len);
2051
2052     if (index >= This->length || index < 0) return E_INVALIDARG;
2053     if (!uri || !len) return E_POINTER;
2054
2055     *len = SysStringLen(This->attr[index].uri);
2056     *uri = This->attr[index].uri;
2057
2058     return S_OK;
2059 }
2060
2061 static HRESULT WINAPI SAXAttributes_getLocalName(ISAXAttributes *iface, int index, const WCHAR **name,
2062     int *len)
2063 {
2064     mxattributes *This = impl_from_ISAXAttributes( iface );
2065
2066     TRACE("(%p)->(%d %p %p)\n", This, index, name, len);
2067
2068     if (index >= This->length || index < 0) return E_INVALIDARG;
2069     if (!name || !len) return E_POINTER;
2070
2071     *len = SysStringLen(This->attr[index].local);
2072     *name = This->attr[index].local;
2073
2074     return S_OK;
2075 }
2076
2077 static HRESULT WINAPI SAXAttributes_getQName(ISAXAttributes *iface, int index, const WCHAR **qname, int *length)
2078 {
2079     mxattributes *This = impl_from_ISAXAttributes( iface );
2080
2081     TRACE("(%p)->(%d %p %p)\n", This, index, qname, length);
2082
2083     if (index >= This->length) return E_INVALIDARG;
2084     if (!qname || !length) return E_POINTER;
2085
2086     *qname = This->attr[index].qname;
2087     *length = SysStringLen(This->attr[index].qname);
2088
2089     return S_OK;
2090 }
2091
2092 static HRESULT WINAPI SAXAttributes_getName(ISAXAttributes *iface, int index, const WCHAR **uri, int *uri_len,
2093     const WCHAR **local, int *local_len, const WCHAR **qname, int *qname_len)
2094 {
2095     mxattributes *This = impl_from_ISAXAttributes( iface );
2096
2097     TRACE("(%p)->(%d %p %p %p %p %p %p)\n", This, index, uri, uri_len, local, local_len, qname, qname_len);
2098
2099     if (index >= This->length || index < 0)
2100         return E_INVALIDARG;
2101
2102     if (!uri || !uri_len || !local || !local_len || !qname || !qname_len)
2103         return E_POINTER;
2104
2105     *uri_len = SysStringLen(This->attr[index].uri);
2106     *uri = This->attr[index].uri;
2107
2108     *local_len = SysStringLen(This->attr[index].local);
2109     *local = This->attr[index].local;
2110
2111     *qname_len = SysStringLen(This->attr[index].qname);
2112     *qname = This->attr[index].qname;
2113
2114     TRACE("(%s, %s, %s)\n", debugstr_w(*uri), debugstr_w(*local), debugstr_w(*qname));
2115
2116     return S_OK;
2117 }
2118
2119 static HRESULT WINAPI SAXAttributes_getIndexFromName(ISAXAttributes *iface, const WCHAR *uri, int uri_len,
2120     const WCHAR *name, int len, int *index)
2121 {
2122     mxattributes *This = impl_from_ISAXAttributes( iface );
2123     int i;
2124
2125     TRACE("(%p)->(%s:%d %s:%d %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
2126         debugstr_wn(name, len), len, index);
2127
2128     if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2129         return E_POINTER;
2130
2131     if (!uri || !name || !index) return E_INVALIDARG;
2132
2133     for (i = 0; i < This->length; i++)
2134     {
2135         if (uri_len != SysStringLen(This->attr[i].uri)) continue;
2136         if (strncmpW(uri, This->attr[i].uri, uri_len)) continue;
2137
2138         if (len != SysStringLen(This->attr[i].local)) continue;
2139         if (strncmpW(name, This->attr[i].local, len)) continue;
2140
2141         *index = i;
2142         return S_OK;
2143     }
2144
2145     return E_INVALIDARG;
2146 }
2147
2148 static HRESULT WINAPI SAXAttributes_getIndexFromQName(ISAXAttributes *iface, const WCHAR *qname,
2149     int len, int *index)
2150 {
2151     mxattributes *This = impl_from_ISAXAttributes( iface );
2152     int i;
2153
2154     TRACE("(%p)->(%s:%d %p)\n", This, debugstr_wn(qname, len), len, index);
2155
2156     if (!index && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2157         return E_POINTER;
2158
2159     if (!qname || !index || !len) return E_INVALIDARG;
2160
2161     for (i = 0; i < This->length; i++)
2162     {
2163         if (len != SysStringLen(This->attr[i].qname)) continue;
2164         if (strncmpW(qname, This->attr[i].qname, len)) continue;
2165
2166         *index = i;
2167         return S_OK;
2168     }
2169
2170     return E_INVALIDARG;
2171 }
2172
2173 static HRESULT WINAPI SAXAttributes_getType(ISAXAttributes *iface, int index, const WCHAR **type,
2174     int *len)
2175 {
2176     mxattributes *This = impl_from_ISAXAttributes( iface );
2177
2178     TRACE("(%p)->(%d %p %p)\n", This, index, type, len);
2179
2180     if (index >= This->length) return E_INVALIDARG;
2181
2182     if ((!type || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2183        return E_POINTER;
2184
2185     *type = This->attr[index].type;
2186     *len = SysStringLen(This->attr[index].type);
2187
2188     return S_OK;
2189 }
2190
2191 static HRESULT WINAPI SAXAttributes_getTypeFromName(ISAXAttributes *iface, const WCHAR * pUri, int nUri,
2192     const WCHAR * pLocalName, int nLocalName, const WCHAR ** pType, int * nType)
2193 {
2194     mxattributes *This = impl_from_ISAXAttributes( iface );
2195     FIXME("(%p)->(%s:%d %s:%d %p %p): stub\n", This, debugstr_wn(pUri, nUri), nUri,
2196         debugstr_wn(pLocalName, nLocalName), nLocalName, pType, nType);
2197     return E_NOTIMPL;
2198 }
2199
2200 static HRESULT WINAPI SAXAttributes_getTypeFromQName(ISAXAttributes *iface, const WCHAR * pQName,
2201     int nQName, const WCHAR ** pType, int * nType)
2202 {
2203     mxattributes *This = impl_from_ISAXAttributes( iface );
2204     FIXME("(%p)->(%s:%d %p %p): stub\n", This, debugstr_wn(pQName, nQName), nQName, pType, nType);
2205     return E_NOTIMPL;
2206 }
2207
2208 static HRESULT WINAPI SAXAttributes_getValue(ISAXAttributes *iface, int index, const WCHAR **value,
2209     int *len)
2210 {
2211     mxattributes *This = impl_from_ISAXAttributes( iface );
2212
2213     TRACE("(%p)->(%d %p %p)\n", This, index, value, len);
2214
2215     if (index >= This->length) return E_INVALIDARG;
2216
2217     if ((!value || !len) && (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3))
2218        return E_POINTER;
2219
2220     *value = This->attr[index].value;
2221     *len = SysStringLen(This->attr[index].value);
2222
2223     return S_OK;
2224 }
2225
2226 static HRESULT WINAPI SAXAttributes_getValueFromName(ISAXAttributes *iface, const WCHAR *uri,
2227     int uri_len, const WCHAR *name, int name_len, const WCHAR **value, int *value_len)
2228 {
2229     mxattributes *This = impl_from_ISAXAttributes( iface );
2230     HRESULT hr;
2231     int index;
2232
2233     TRACE("(%p)->(%s:%d %s:%d %p %p)\n", This, debugstr_wn(uri, uri_len), uri_len,
2234         debugstr_wn(name, name_len), name_len, value, value_len);
2235
2236     if (!uri || !name || !value || !value_len)
2237         return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
2238
2239     hr = ISAXAttributes_getIndexFromName(iface, uri, uri_len, name, name_len, &index);
2240     if (hr == S_OK)
2241         hr = ISAXAttributes_getValue(iface, index, value, value_len);
2242
2243     return hr;
2244 }
2245
2246 static HRESULT WINAPI SAXAttributes_getValueFromQName(ISAXAttributes *iface, const WCHAR *qname,
2247     int qname_len, const WCHAR **value, int *value_len)
2248 {
2249     mxattributes *This = impl_from_ISAXAttributes( iface );
2250     HRESULT hr;
2251     int index;
2252
2253     TRACE("(%p)->(%s:%d %p %p)\n", This, debugstr_wn(qname, qname_len), qname_len, value, value_len);
2254
2255     if (!qname || !value || !value_len)
2256         return (This->class_version == MSXML_DEFAULT || This->class_version == MSXML3) ? E_POINTER : E_INVALIDARG;
2257
2258     hr = ISAXAttributes_getIndexFromQName(iface, qname, qname_len, &index);
2259     if (hr == S_OK)
2260         hr = ISAXAttributes_getValue(iface, index, value, value_len);
2261
2262     return hr;
2263 }
2264
2265 static const ISAXAttributesVtbl SAXAttributesVtbl = {
2266     SAXAttributes_QueryInterface,
2267     SAXAttributes_AddRef,
2268     SAXAttributes_Release,
2269     SAXAttributes_getLength,
2270     SAXAttributes_getURI,
2271     SAXAttributes_getLocalName,
2272     SAXAttributes_getQName,
2273     SAXAttributes_getName,
2274     SAXAttributes_getIndexFromName,
2275     SAXAttributes_getIndexFromQName,
2276     SAXAttributes_getType,
2277     SAXAttributes_getTypeFromName,
2278     SAXAttributes_getTypeFromQName,
2279     SAXAttributes_getValue,
2280     SAXAttributes_getValueFromName,
2281     SAXAttributes_getValueFromQName
2282 };
2283
2284 static HRESULT WINAPI VBSAXAttributes_QueryInterface(
2285         IVBSAXAttributes* iface,
2286         REFIID riid,
2287         void **ppvObject)
2288 {
2289     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2290     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
2291     return ISAXAttributes_QueryInterface(&This->ISAXAttributes_iface, riid, ppvObject);
2292 }
2293
2294 static ULONG WINAPI VBSAXAttributes_AddRef(IVBSAXAttributes* iface)
2295 {
2296     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2297     return ISAXAttributes_AddRef(&This->ISAXAttributes_iface);
2298 }
2299
2300 static ULONG WINAPI VBSAXAttributes_Release(IVBSAXAttributes* iface)
2301 {
2302     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2303     return ISAXAttributes_Release(&This->ISAXAttributes_iface);
2304 }
2305
2306 static HRESULT WINAPI VBSAXAttributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
2307 {
2308     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2309
2310     TRACE("(%p)->(%p)\n", This, pctinfo);
2311
2312     *pctinfo = 1;
2313
2314     return S_OK;
2315 }
2316
2317 static HRESULT WINAPI VBSAXAttributes_GetTypeInfo(
2318     IVBSAXAttributes *iface,
2319     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2320 {
2321     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2322     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2323     return get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
2324 }
2325
2326 static HRESULT WINAPI VBSAXAttributes_GetIDsOfNames(
2327     IVBSAXAttributes *iface,
2328     REFIID riid,
2329     LPOLESTR* rgszNames,
2330     UINT cNames,
2331     LCID lcid,
2332     DISPID* rgDispId)
2333 {
2334     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2335     ITypeInfo *typeinfo;
2336     HRESULT hr;
2337
2338     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2339           lcid, rgDispId);
2340
2341     if(!rgszNames || cNames == 0 || !rgDispId)
2342         return E_INVALIDARG;
2343
2344     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
2345     if(SUCCEEDED(hr))
2346     {
2347         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2348         ITypeInfo_Release(typeinfo);
2349     }
2350
2351     return hr;
2352 }
2353
2354 static HRESULT WINAPI VBSAXAttributes_Invoke(
2355     IVBSAXAttributes *iface,
2356     DISPID dispIdMember,
2357     REFIID riid,
2358     LCID lcid,
2359     WORD wFlags,
2360     DISPPARAMS* pDispParams,
2361     VARIANT* pVarResult,
2362     EXCEPINFO* pExcepInfo,
2363     UINT* puArgErr)
2364 {
2365     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2366     ITypeInfo *typeinfo;
2367     HRESULT hr;
2368
2369     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2370           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2371
2372     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
2373     if(SUCCEEDED(hr))
2374     {
2375         hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXAttributes_iface, dispIdMember, wFlags,
2376                 pDispParams, pVarResult, pExcepInfo, puArgErr);
2377         ITypeInfo_Release(typeinfo);
2378     }
2379
2380     return hr;
2381 }
2382
2383 static HRESULT WINAPI VBSAXAttributes_get_length(IVBSAXAttributes* iface, int *len)
2384 {
2385     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2386     return ISAXAttributes_getLength(&This->ISAXAttributes_iface, len);
2387 }
2388
2389 static HRESULT WINAPI VBSAXAttributes_getURI(IVBSAXAttributes* iface, int index, BSTR *uri)
2390 {
2391     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2392     int len;
2393
2394     return ISAXAttributes_getURI(&This->ISAXAttributes_iface, index, (const WCHAR**)uri, &len);
2395 }
2396
2397 static HRESULT WINAPI VBSAXAttributes_getLocalName(IVBSAXAttributes* iface, int index, BSTR *name)
2398 {
2399     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2400     int len;
2401
2402     return ISAXAttributes_getLocalName(&This->ISAXAttributes_iface, index, (const WCHAR**)name, &len);
2403 }
2404
2405 static HRESULT WINAPI VBSAXAttributes_getQName(IVBSAXAttributes* iface, int index, BSTR *qname)
2406 {
2407     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2408     int len;
2409
2410     return ISAXAttributes_getQName(&This->ISAXAttributes_iface, index, (const WCHAR**)qname, &len);
2411 }
2412
2413 static HRESULT WINAPI VBSAXAttributes_getIndexFromName(IVBSAXAttributes* iface, BSTR uri, BSTR name, int *index)
2414 {
2415     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2416     return ISAXAttributes_getIndexFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2417             name, SysStringLen(name), index);
2418 }
2419
2420 static HRESULT WINAPI VBSAXAttributes_getIndexFromQName(IVBSAXAttributes* iface, BSTR qname, int *index)
2421 {
2422     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2423     return ISAXAttributes_getIndexFromQName(&This->ISAXAttributes_iface, qname,
2424             SysStringLen(qname), index);
2425 }
2426
2427 static HRESULT WINAPI VBSAXAttributes_getType(IVBSAXAttributes* iface, int index,BSTR *type)
2428 {
2429     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2430     int len;
2431
2432     return ISAXAttributes_getType(&This->ISAXAttributes_iface, index, (const WCHAR**)type, &len);
2433 }
2434
2435 static HRESULT WINAPI VBSAXAttributes_getTypeFromName(IVBSAXAttributes* iface, BSTR uri,
2436     BSTR name, BSTR *type)
2437 {
2438     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2439     int len;
2440
2441     return ISAXAttributes_getTypeFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2442             name, SysStringLen(name), (const WCHAR**)type, &len);
2443 }
2444
2445 static HRESULT WINAPI VBSAXAttributes_getTypeFromQName(IVBSAXAttributes* iface, BSTR qname, BSTR *type)
2446 {
2447     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2448     int len;
2449
2450     return ISAXAttributes_getTypeFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
2451             (const WCHAR**)type, &len);
2452 }
2453
2454 static HRESULT WINAPI VBSAXAttributes_getValue(IVBSAXAttributes* iface, int index, BSTR *value)
2455 {
2456     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2457     int len;
2458
2459     return ISAXAttributes_getValue(&This->ISAXAttributes_iface, index, (const WCHAR**)value, &len);
2460 }
2461
2462 static HRESULT WINAPI VBSAXAttributes_getValueFromName(IVBSAXAttributes* iface, BSTR uri, BSTR name,
2463     BSTR *value)
2464 {
2465     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2466     int len;
2467
2468     return ISAXAttributes_getValueFromName(&This->ISAXAttributes_iface, uri, SysStringLen(uri),
2469             name, SysStringLen(name), (const WCHAR**)value, &len);
2470 }
2471
2472 static HRESULT WINAPI VBSAXAttributes_getValueFromQName(IVBSAXAttributes* iface, BSTR qname, BSTR *value)
2473 {
2474     mxattributes *This = impl_from_IVBSAXAttributes( iface );
2475     int len;
2476
2477     return ISAXAttributes_getValueFromQName(&This->ISAXAttributes_iface, qname, SysStringLen(qname),
2478         (const WCHAR**)value, &len);
2479 }
2480
2481 static const struct IVBSAXAttributesVtbl VBSAXAttributesVtbl =
2482 {
2483     VBSAXAttributes_QueryInterface,
2484     VBSAXAttributes_AddRef,
2485     VBSAXAttributes_Release,
2486     VBSAXAttributes_GetTypeInfoCount,
2487     VBSAXAttributes_GetTypeInfo,
2488     VBSAXAttributes_GetIDsOfNames,
2489     VBSAXAttributes_Invoke,
2490     VBSAXAttributes_get_length,
2491     VBSAXAttributes_getURI,
2492     VBSAXAttributes_getLocalName,
2493     VBSAXAttributes_getQName,
2494     VBSAXAttributes_getIndexFromName,
2495     VBSAXAttributes_getIndexFromQName,
2496     VBSAXAttributes_getType,
2497     VBSAXAttributes_getTypeFromName,
2498     VBSAXAttributes_getTypeFromQName,
2499     VBSAXAttributes_getValue,
2500     VBSAXAttributes_getValueFromName,
2501     VBSAXAttributes_getValueFromQName
2502 };
2503
2504 static const tid_t mxattrs_iface_tids[] = {
2505     IMXAttributes_tid,
2506     0
2507 };
2508
2509 static dispex_static_data_t mxattrs_dispex = {
2510     NULL,
2511     IMXAttributes_tid,
2512     NULL,
2513     mxattrs_iface_tids
2514 };
2515
2516 HRESULT SAXAttributes_create(MSXML_VERSION version, void **ppObj)
2517 {
2518     static const int default_count = 10;
2519     mxattributes *This;
2520
2521     TRACE("(%p)\n", ppObj);
2522
2523     This = heap_alloc( sizeof (*This) );
2524     if( !This )
2525         return E_OUTOFMEMORY;
2526
2527     This->IMXAttributes_iface.lpVtbl = &MXAttributesVtbl;
2528     This->ISAXAttributes_iface.lpVtbl = &SAXAttributesVtbl;
2529     This->IVBSAXAttributes_iface.lpVtbl = &VBSAXAttributesVtbl;
2530     This->ref = 1;
2531
2532     This->class_version = version;
2533
2534     This->attr = heap_alloc(default_count*sizeof(mxattribute));
2535     This->length = 0;
2536     This->allocated = default_count;
2537
2538     *ppObj = &This->IMXAttributes_iface;
2539
2540     init_dispex(&This->dispex, (IUnknown*)&This->IMXAttributes_iface, &mxattrs_dispex);
2541
2542     TRACE("returning iface %p\n", *ppObj);
2543
2544     return S_OK;
2545 }