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