dlls/xmllite/writer.c

   1 /*
   2  * IXmlWriter implementation
   3  *
   4  * Copyright 2011 Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #define COBJMACROS
  21
  22 #include <stdarg.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "xmllite.h"
  27 #include "xmllite_private.h"
  28 #include "initguid.h"
  29
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(xmllite);
  33
  34 /* not defined in public headers */
  35 DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
  36
  37 typedef struct
  38 {
  39     IXmlWriterOutput IXmlWriterOutput_iface;
  40     LONG ref;
  41     IUnknown *output;
  42     IMalloc *imalloc;
  43     xml_encoding encoding;
  44 } xmlwriteroutput;
  45
  46 typedef struct _xmlwriter
  47 {
  48     IXmlWriter IXmlWriter_iface;
  49     LONG ref;
  50     IMalloc *imalloc;
  51 } xmlwriter;
  52
  53 static inline xmlwriter *impl_from_IXmlWriter(IXmlWriter *iface)
  54 {
  55     return CONTAINING_RECORD(iface, xmlwriter, IXmlWriter_iface);
  56 }
  57
  58 static inline xmlwriteroutput *impl_from_IXmlWriterOutput(IXmlWriterOutput *iface)
  59 {
  60     return CONTAINING_RECORD(iface, xmlwriteroutput, IXmlWriterOutput_iface);
  61 }
  62
  63 /* writer output memory allocation functions */
  64 static inline void *writeroutput_alloc(xmlwriteroutput *output, size_t len)
  65 {
  66     return m_alloc(output->imalloc, len);
  67 }
  68
  69 static inline void writeroutput_free(xmlwriteroutput *output, void *mem)
  70 {
  71     m_free(output->imalloc, mem);
  72 }
  73
  74 /* writer memory allocation functions */
  75 static inline void *writer_alloc(xmlwriter *writer, size_t len)
  76 {
  77     return m_alloc(writer->imalloc, len);
  78 }
  79
  80 static inline void writer_free(xmlwriter *writer, void *mem)
  81 {
  82     m_free(writer->imalloc, mem);
  83 }
  84
  85 static HRESULT WINAPI xmlwriter_QueryInterface(IXmlWriter *iface, REFIID riid, void **ppvObject)
  86 {
  87     xmlwriter *This = impl_from_IXmlWriter(iface);
  88
  89     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  90
  91     if (IsEqualGUID(riid, &IID_IUnknown) ||
  92         IsEqualGUID(riid, &IID_IXmlWriter))
  93     {
  94         *ppvObject = iface;
  95     }
  96
  97     IXmlWriter_AddRef(iface);
  98
  99     return S_OK;
 100 }
 101
 102 static ULONG WINAPI xmlwriter_AddRef(IXmlWriter *iface)
 103 {
 104     xmlwriter *This = impl_from_IXmlWriter(iface);
 105     TRACE("%p\n", This);
 106     return InterlockedIncrement(&This->ref);
 107 }
 108
 109 static ULONG WINAPI xmlwriter_Release(IXmlWriter *iface)
 110 {
 111     xmlwriter *This = impl_from_IXmlWriter(iface);
 112     LONG ref;
 113
 114     TRACE("%p\n", This);
 115
 116     ref = InterlockedDecrement(&This->ref);
 117     if (ref == 0) {
 118         IMalloc *imalloc = This->imalloc;
 119         writer_free(This, This);
 120         if (imalloc) IMalloc_Release(imalloc);
 121     }
 122
 123     return ref;
 124 }
 125
 126 /*** IXmlWriter methods ***/
 127 static HRESULT WINAPI xmlwriter_SetOutput(IXmlWriter *iface, IUnknown *pOutput)
 128 {
 129     xmlwriter *This = impl_from_IXmlWriter(iface);
 130
 131     FIXME("%p %p\n", This, pOutput);
 132
 133     return E_NOTIMPL;
 134 }
 135
 136 static HRESULT WINAPI xmlwriter_GetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR *ppValue)
 137 {
 138     xmlwriter *This = impl_from_IXmlWriter(iface);
 139
 140     FIXME("%p %u %p\n", This, nProperty, ppValue);
 141
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI xmlwriter_SetProperty(IXmlWriter *iface, UINT nProperty, LONG_PTR pValue)
 146 {
 147     xmlwriter *This = impl_from_IXmlWriter(iface);
 148
 149     FIXME("%p %u %lu\n", This, nProperty, pValue);
 150
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI xmlwriter_WriteAttributes(IXmlWriter *iface, IXmlReader *pReader,
 155                                   BOOL fWriteDefaultAttributes)
 156 {
 157     xmlwriter *This = impl_from_IXmlWriter(iface);
 158
 159     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 160
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR pwszPrefix,
 165                                        LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
 166                                        LPCWSTR pwszValue)
 167 {
 168     xmlwriter *This = impl_from_IXmlWriter(iface);
 169
 170     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 171                         wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
 172
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI xmlwriter_WriteCData(IXmlWriter *iface, LPCWSTR pwszText)
 177 {
 178     xmlwriter *This = impl_from_IXmlWriter(iface);
 179
 180     FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
 181
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI xmlwriter_WriteCharEntity(IXmlWriter *iface, WCHAR wch)
 186 {
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI xmlwriter_WriteChars(IXmlWriter *iface, const WCHAR *pwch, UINT cwch)
 191 {
 192     xmlwriter *This = impl_from_IXmlWriter(iface);
 193
 194     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
 195
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI xmlwriter_WriteComment(IXmlWriter *iface, LPCWSTR pwszComment)
 200 {
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI xmlwriter_WriteDocType(IXmlWriter *iface, LPCWSTR pwszName, LPCWSTR pwszPublicId,
 205                                LPCWSTR pwszSystemId, LPCWSTR pwszSubset)
 206 {
 207     xmlwriter *This = impl_from_IXmlWriter(iface);
 208
 209     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszPublicId),
 210                         wine_dbgstr_w(pwszSystemId), wine_dbgstr_w(pwszSubset));
 211
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI xmlwriter_WriteElementString(IXmlWriter *iface, LPCWSTR pwszPrefix,
 216                                      LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri,
 217                                      LPCWSTR pwszValue)
 218 {
 219     xmlwriter *This = impl_from_IXmlWriter(iface);
 220
 221     FIXME("%p %s %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 222                         wine_dbgstr_w(pwszNamespaceUri), wine_dbgstr_w(pwszValue));
 223
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI xmlwriter_WriteEndDocument(IXmlWriter *iface)
 228 {
 229     xmlwriter *This = impl_from_IXmlWriter(iface);
 230
 231     FIXME("%p\n", This);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI xmlwriter_WriteEndElement(IXmlWriter *iface)
 237 {
 238     xmlwriter *This = impl_from_IXmlWriter(iface);
 239
 240     FIXME("%p\n", This);
 241
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI xmlwriter_WriteEntityRef(IXmlWriter *iface, LPCWSTR pwszName)
 246 {
 247     xmlwriter *This = impl_from_IXmlWriter(iface);
 248
 249     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
 250
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI xmlwriter_WriteFullEndElement(IXmlWriter *iface)
 255 {
 256     xmlwriter *This = impl_from_IXmlWriter(iface);
 257
 258     FIXME("%p\n", This);
 259
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI xmlwriter_WriteName(IXmlWriter *iface, LPCWSTR pwszName)
 264 {
 265     xmlwriter *This = impl_from_IXmlWriter(iface);
 266
 267     FIXME("%p %s\n", This, wine_dbgstr_w(pwszName));
 268
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI xmlwriter_WriteNmToken(IXmlWriter *iface, LPCWSTR pwszNmToken)
 273 {
 274     xmlwriter *This = impl_from_IXmlWriter(iface);
 275
 276     FIXME("%p %s\n", This, wine_dbgstr_w(pwszNmToken));
 277
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI xmlwriter_WriteNode(IXmlWriter *iface, IXmlReader *pReader,
 282                             BOOL fWriteDefaultAttributes)
 283 {
 284     xmlwriter *This = impl_from_IXmlWriter(iface);
 285
 286     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 287
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI xmlwriter_WriteNodeShallow(IXmlWriter *iface, IXmlReader *pReader,
 292                                    BOOL fWriteDefaultAttributes)
 293 {
 294     xmlwriter *This = impl_from_IXmlWriter(iface);
 295
 296     FIXME("%p %p %d\n", This, pReader, fWriteDefaultAttributes);
 297
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI xmlwriter_WriteProcessingInstruction(IXmlWriter *iface, LPCWSTR pwszName,
 302                                              LPCWSTR pwszText)
 303 {
 304     xmlwriter *This = impl_from_IXmlWriter(iface);
 305
 306     FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszName), wine_dbgstr_w(pwszText));
 307
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI xmlwriter_WriteQualifiedName(IXmlWriter *iface, LPCWSTR pwszLocalName,
 312                                      LPCWSTR pwszNamespaceUri)
 313 {
 314     xmlwriter *This = impl_from_IXmlWriter(iface);
 315
 316     FIXME("%p %s %s\n", This, wine_dbgstr_w(pwszLocalName), wine_dbgstr_w(pwszNamespaceUri));
 317
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI xmlwriter_WriteRaw(IXmlWriter *iface, LPCWSTR pwszData)
 322 {
 323     xmlwriter *This = impl_from_IXmlWriter(iface);
 324
 325     FIXME("%p %s\n", This, wine_dbgstr_w(pwszData));
 326
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI xmlwriter_WriteRawChars(IXmlWriter *iface,  const WCHAR *pwch, UINT cwch)
 331 {
 332     xmlwriter *This = impl_from_IXmlWriter(iface);
 333
 334     FIXME("%p %s %d\n", This, wine_dbgstr_w(pwch), cwch);
 335
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI xmlwriter_WriteStartDocument(IXmlWriter *iface, XmlStandalone standalone)
 340 {
 341     xmlwriter *This = impl_from_IXmlWriter(iface);
 342
 343     FIXME("%p\n", This);
 344
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI xmlwriter_WriteStartElement(IXmlWriter *iface, LPCWSTR pwszPrefix,
 349                                     LPCWSTR pwszLocalName, LPCWSTR pwszNamespaceUri)
 350 {
 351     xmlwriter *This = impl_from_IXmlWriter(iface);
 352
 353     FIXME("%p %s %s %s\n", This, wine_dbgstr_w(pwszPrefix), wine_dbgstr_w(pwszLocalName),
 354                 wine_dbgstr_w(pwszNamespaceUri));
 355
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI xmlwriter_WriteString(IXmlWriter *iface, LPCWSTR pwszText)
 360 {
 361     xmlwriter *This = impl_from_IXmlWriter(iface);
 362
 363     FIXME("%p %s\n", This, wine_dbgstr_w(pwszText));
 364
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI xmlwriter_WriteSurrogateCharEntity(IXmlWriter *iface, WCHAR wchLow, WCHAR wchHigh)
 369 {
 370     xmlwriter *This = impl_from_IXmlWriter(iface);
 371
 372     FIXME("%p %d %d\n", This, wchLow, wchHigh);
 373
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI xmlwriter_WriteWhitespace(IXmlWriter *iface, LPCWSTR pwszWhitespace)
 378 {
 379     xmlwriter *This = impl_from_IXmlWriter(iface);
 380
 381     FIXME("%p %s\n", This, wine_dbgstr_w(pwszWhitespace));
 382
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI xmlwriter_Flush(IXmlWriter *iface)
 387 {
 388     xmlwriter *This = impl_from_IXmlWriter(iface);
 389
 390     FIXME("%p\n", This);
 391
 392     return E_NOTIMPL;
 393 }
 394
 395 static const struct IXmlWriterVtbl xmlwriter_vtbl =
 396 {
 397     xmlwriter_QueryInterface,
 398     xmlwriter_AddRef,
 399     xmlwriter_Release,
 400     xmlwriter_SetOutput,
 401     xmlwriter_GetProperty,
 402     xmlwriter_SetProperty,
 403     xmlwriter_WriteAttributes,
 404     xmlwriter_WriteAttributeString,
 405     xmlwriter_WriteCData,
 406     xmlwriter_WriteCharEntity,
 407     xmlwriter_WriteChars,
 408     xmlwriter_WriteComment,
 409     xmlwriter_WriteDocType,
 410     xmlwriter_WriteElementString,
 411     xmlwriter_WriteEndDocument,
 412     xmlwriter_WriteEndElement,
 413     xmlwriter_WriteEntityRef,
 414     xmlwriter_WriteFullEndElement,
 415     xmlwriter_WriteName,
 416     xmlwriter_WriteNmToken,
 417     xmlwriter_WriteNode,
 418     xmlwriter_WriteNodeShallow,
 419     xmlwriter_WriteProcessingInstruction,
 420     xmlwriter_WriteQualifiedName,
 421     xmlwriter_WriteRaw,
 422     xmlwriter_WriteRawChars,
 423     xmlwriter_WriteStartDocument,
 424     xmlwriter_WriteStartElement,
 425     xmlwriter_WriteString,
 426     xmlwriter_WriteSurrogateCharEntity,
 427     xmlwriter_WriteWhitespace,
 428     xmlwriter_Flush
 429 };
 430
 431 /** IXmlWriterOutput **/
 432 static HRESULT WINAPI xmlwriteroutput_QueryInterface(IXmlWriterOutput *iface, REFIID riid, void** ppvObject)
 433 {
 434     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 435
 436     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 437
 438     if (IsEqualGUID(riid, &IID_IXmlWriterOutput) ||
 439         IsEqualGUID(riid, &IID_IUnknown))
 440     {
 441         *ppvObject = iface;
 442     }
 443     else
 444     {
 445         WARN("interface %s not implemented\n", debugstr_guid(riid));
 446         *ppvObject = NULL;
 447         return E_NOINTERFACE;
 448     }
 449
 450     IUnknown_AddRef(iface);
 451
 452     return S_OK;
 453 }
 454
 455 static ULONG WINAPI xmlwriteroutput_AddRef(IXmlWriterOutput *iface)
 456 {
 457     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 458     ULONG ref = InterlockedIncrement(&This->ref);
 459     TRACE("(%p)->(%d)\n", This, ref);
 460     return ref;
 461 }
 462
 463 static ULONG WINAPI xmlwriteroutput_Release(IXmlWriterOutput *iface)
 464 {
 465     xmlwriteroutput *This = impl_from_IXmlWriterOutput(iface);
 466     LONG ref = InterlockedDecrement(&This->ref);
 467
 468     TRACE("(%p)->(%d)\n", This, ref);
 469
 470     if (ref == 0)
 471     {
 472         IMalloc *imalloc = This->imalloc;
 473         if (This->output) IUnknown_Release(This->output);
 474         writeroutput_free(This, This);
 475         if (imalloc) IMalloc_Release(imalloc);
 476     }
 477
 478     return ref;
 479 }
 480
 481 static const struct IUnknownVtbl xmlwriteroutputvtbl =
 482 {
 483     xmlwriteroutput_QueryInterface,
 484     xmlwriteroutput_AddRef,
 485     xmlwriteroutput_Release
 486 };
 487
 488 HRESULT WINAPI CreateXmlWriter(REFIID riid, void **obj, IMalloc *imalloc)
 489 {
 490     xmlwriter *writer;
 491
 492     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
 493
 494     if (!IsEqualGUID(riid, &IID_IXmlWriter))
 495     {
 496         ERR("Unexpected IID requested -> (%s)\n", wine_dbgstr_guid(riid));
 497         return E_FAIL;
 498     }
 499
 500     if (imalloc)
 501         writer = IMalloc_Alloc(imalloc, sizeof(*writer));
 502     else
 503         writer = heap_alloc(sizeof(*writer));
 504     if(!writer) return E_OUTOFMEMORY;
 505
 506     writer->IXmlWriter_iface.lpVtbl = &xmlwriter_vtbl;
 507     writer->ref = 1;
 508     writer->imalloc = imalloc;
 509     if (imalloc) IMalloc_AddRef(imalloc);
 510
 511     *obj = &writer->IXmlWriter_iface;
 512
 513     TRACE("returning iface %p\n", *obj);
 514
 515     return S_OK;
 516 }
 517
 518 HRESULT WINAPI CreateXmlWriterOutputWithEncodingName(IUnknown *stream,
 519                                                      IMalloc *imalloc,
 520                                                      LPCWSTR encoding,
 521                                                      IXmlWriterOutput **output)
 522 {
 523     xmlwriteroutput *writeroutput;
 524
 525     TRACE("%p %p %s %p\n", stream, imalloc, debugstr_w(encoding), output);
 526
 527     if (!stream || !output) return E_INVALIDARG;
 528
 529     if (imalloc)
 530         writeroutput = IMalloc_Alloc(imalloc, sizeof(*writeroutput));
 531     else
 532         writeroutput = heap_alloc(sizeof(*writeroutput));
 533     if(!writeroutput) return E_OUTOFMEMORY;
 534
 535     writeroutput->IXmlWriterOutput_iface.lpVtbl = &xmlwriteroutputvtbl;
 536     writeroutput->ref = 1;
 537     writeroutput->imalloc = imalloc;
 538     if (imalloc) IMalloc_AddRef(imalloc);
 539     writeroutput->encoding = parse_encoding_name(encoding, -1);
 540
 541     IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&writeroutput->output);
 542
 543     *output = &writeroutput->IXmlWriterOutput_iface;
 544
 545     TRACE("returning iface %p\n", *output);
 546
 547     return S_OK;
 548 }