dlls/xmllite/reader.c

   1 /*
   2  * IXmlReader implementation
   3  *
   4  * Copyright 2010 Nikolay Sivov
   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 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "initguid.h"
  27 #include "objbase.h"
  28 #include "xmllite.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_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
  36
  37 static HRESULT xmlreaderinput_query_for_stream(IXmlReaderInput *iface, void **pObj);
  38
  39 typedef struct _xmlreader
  40 {
  41     const IXmlReaderVtbl *lpVtbl;
  42     LONG ref;
  43     IXmlReaderInput *input;
  44     ISequentialStream *stream;/* stored as sequential stream, cause currently
  45                                  optimizations possible with IStream aren't implemented */
  46     XmlReadState state;
  47 } xmlreader;
  48
  49 typedef struct _xmlreaderinput
  50 {
  51     const IUnknownVtbl *lpVtbl;
  52     LONG ref;
  53     IUnknown *input;          /* reference passed on IXmlReaderInput creation */
  54 } xmlreaderinput;
  55
  56 static inline xmlreader *impl_from_IXmlReader(IXmlReader *iface)
  57 {
  58     return (xmlreader *)((char*)iface - FIELD_OFFSET(xmlreader, lpVtbl));
  59 }
  60
  61 static inline xmlreaderinput *impl_from_IXmlReaderInput(IXmlReaderInput *iface)
  62 {
  63     return (xmlreaderinput *)((char*)iface - FIELD_OFFSET(xmlreaderinput, lpVtbl));
  64 }
  65
  66 static HRESULT WINAPI xmlreader_QueryInterface(IXmlReader *iface, REFIID riid, void** ppvObject)
  67 {
  68     xmlreader *This = impl_from_IXmlReader(iface);
  69
  70     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  71
  72     if (IsEqualGUID(riid, &IID_IUnknown) ||
  73         IsEqualGUID(riid, &IID_IXmlReader))
  74     {
  75         *ppvObject = iface;
  76     }
  77     else
  78     {
  79         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  80         return E_NOINTERFACE;
  81     }
  82
  83     IXmlReader_AddRef(iface);
  84
  85     return S_OK;
  86 }
  87
  88 static ULONG WINAPI xmlreader_AddRef(IXmlReader *iface)
  89 {
  90     xmlreader *This = impl_from_IXmlReader(iface);
  91     TRACE("%p\n", This);
  92     return InterlockedIncrement(&This->ref);
  93 }
  94
  95 static ULONG WINAPI xmlreader_Release(IXmlReader *iface)
  96 {
  97     xmlreader *This = impl_from_IXmlReader(iface);
  98     LONG ref;
  99
 100     TRACE("%p\n", This);
 101
 102     ref = InterlockedDecrement(&This->ref);
 103     if (ref == 0)
 104     {
 105         if (This->input)
 106         {
 107             IUnknown_Release(This->stream);
 108             IUnknown_Release(This->input);
 109         }
 110         HeapFree(GetProcessHeap(), 0, This);
 111     }
 112
 113     return ref;
 114 }
 115
 116 static HRESULT WINAPI xmlreader_SetInput(IXmlReader* iface, IUnknown *input)
 117 {
 118     xmlreader *This = impl_from_IXmlReader(iface);
 119     HRESULT hr;
 120
 121     TRACE("(%p %p)\n", This, input);
 122
 123     if (This->input)
 124     {
 125         IUnknown_Release(This->input);
 126         This->input  = NULL;
 127     }
 128
 129     if (This->stream)
 130     {
 131         IUnknown_Release(This->stream);
 132         This->stream = NULL;
 133     }
 134
 135     /* just reset current input */
 136     if (!input)
 137     {
 138         This->state = XmlReadState_Closed;
 139         return S_OK;
 140     }
 141
 142     /* now try IXmlReaderInput, ISequentialStream, IStream */
 143     hr = IUnknown_QueryInterface(input, &IID_IXmlReaderInput, (void**)&This->input);
 144     if (hr != S_OK)
 145     {
 146         /* create IXmlReaderInput basing on supplied interface */
 147         hr = CreateXmlReaderInputWithEncodingName(input,
 148                                          NULL, NULL, FALSE, NULL, &This->input);
 149         if (hr != S_OK) return hr;
 150     }
 151
 152     /* set stream for supplied IXmlReaderInput */
 153     hr = xmlreaderinput_query_for_stream(This->input, (void**)&This->stream);
 154     if (hr != S_OK)
 155     {
 156         /* IXmlReaderInput doesn't provide streaming interface */
 157         IUnknown_Release(This->input);
 158         This->input = NULL;
 159     }
 160     else
 161         This->state = XmlReadState_Initial;
 162
 163     return hr;
 164 }
 165
 166 static HRESULT WINAPI xmlreader_GetProperty(IXmlReader* iface, UINT property, LONG_PTR *value)
 167 {
 168     xmlreader *This = impl_from_IXmlReader(iface);
 169
 170     TRACE("(%p %u %p)\n", This, property, value);
 171
 172     if (!value) return E_INVALIDARG;
 173
 174     switch (property)
 175     {
 176         case XmlReaderProperty_ReadState:
 177             *value = This->state;
 178             break;
 179         default:
 180             FIXME("Unimplemented property (%u)\n", property);
 181             return E_NOTIMPL;
 182     }
 183
 184     return S_OK;
 185 }
 186
 187 static HRESULT WINAPI xmlreader_SetProperty(IXmlReader* iface, UINT property, LONG_PTR value)
 188 {
 189     FIXME("(%p %u %lu): stub\n", iface, property, value);
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI xmlreader_Read(IXmlReader* iface, XmlNodeType *node_type)
 194 {
 195     FIXME("(%p %p): stub\n", iface, node_type);
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI xmlreader_GetNodeType(IXmlReader* iface, XmlNodeType *node_type)
 200 {
 201     FIXME("(%p %p): stub\n", iface, node_type);
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI xmlreader_MoveToFirstAttribute(IXmlReader* iface)
 206 {
 207     FIXME("(%p): stub\n", iface);
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT WINAPI xmlreader_MoveToNextAttribute(IXmlReader* iface)
 212 {
 213     FIXME("(%p): stub\n", iface);
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI xmlreader_MoveToAttributeByName(IXmlReader* iface,
 218                                                       LPCWSTR local_name,
 219                                                       LPCWSTR namespaceUri)
 220 {
 221     FIXME("(%p %p %p): stub\n", iface, local_name, namespaceUri);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI xmlreader_MoveToElement(IXmlReader* iface)
 226 {
 227     FIXME("(%p): stub\n", iface);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI xmlreader_GetQualifiedName(IXmlReader* iface, LPCWSTR *qualifiedName,
 232                                                  UINT *qualifiedName_length)
 233 {
 234     FIXME("(%p %p %p): stub\n", iface, qualifiedName, qualifiedName_length);
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI xmlreader_GetNamespaceUri(IXmlReader* iface,
 239                                                 LPCWSTR *namespaceUri,
 240                                                 UINT *namespaceUri_length)
 241 {
 242     FIXME("(%p %p %p): stub\n", iface, namespaceUri, namespaceUri_length);
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI xmlreader_GetLocalName(IXmlReader* iface,
 247                                              LPCWSTR *local_name,
 248                                              UINT *local_name_length)
 249 {
 250     FIXME("(%p %p %p): stub\n", iface, local_name, local_name_length);
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI xmlreader_GetPrefix(IXmlReader* iface,
 255                                           LPCWSTR *prefix,
 256                                           UINT *prefix_length)
 257 {
 258     FIXME("(%p %p %p): stub\n", iface, prefix, prefix_length);
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI xmlreader_GetValue(IXmlReader* iface,
 263                                          LPCWSTR *value,
 264                                          UINT *value_length)
 265 {
 266     FIXME("(%p %p %p): stub\n", iface, value, value_length);
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT WINAPI xmlreader_ReadValueChunk(IXmlReader* iface,
 271                                                WCHAR *buffer,
 272                                                UINT   chunk_size,
 273                                                UINT  *read)
 274 {
 275     FIXME("(%p %p %u %p): stub\n", iface, buffer, chunk_size, read);
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI xmlreader_GetBaseUri(IXmlReader* iface,
 280                                            LPCWSTR *baseUri,
 281                                            UINT *baseUri_length)
 282 {
 283     FIXME("(%p %p %p): stub\n", iface, baseUri, baseUri_length);
 284     return E_NOTIMPL;
 285 }
 286
 287 static BOOL WINAPI xmlreader_IsDefault(IXmlReader* iface)
 288 {
 289     FIXME("(%p): stub\n", iface);
 290     return E_NOTIMPL;
 291 }
 292
 293 static BOOL WINAPI xmlreader_IsEmptyElement(IXmlReader* iface)
 294 {
 295     FIXME("(%p): stub\n", iface);
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI xmlreader_GetLineNumber(IXmlReader* iface, UINT *lineNumber)
 300 {
 301     FIXME("(%p %p): stub\n", iface, lineNumber);
 302     return E_NOTIMPL;
 303 }
 304
 305 static HRESULT WINAPI xmlreader_GetLinePosition(IXmlReader* iface, UINT *linePosition)
 306 {
 307     FIXME("(%p %p): stub\n", iface, linePosition);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI xmlreader_GetAttributeCount(IXmlReader* iface, UINT *attributeCount)
 312 {
 313     FIXME("(%p %p): stub\n", iface, attributeCount);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI xmlreader_GetDepth(IXmlReader* iface, UINT *depth)
 318 {
 319     FIXME("(%p %p): stub\n", iface, depth);
 320     return E_NOTIMPL;
 321 }
 322
 323 static BOOL WINAPI xmlreader_IsEOF(IXmlReader* iface)
 324 {
 325     FIXME("(%p): stub\n", iface);
 326     return E_NOTIMPL;
 327 }
 328
 329 static const struct IXmlReaderVtbl xmlreader_vtbl =
 330 {
 331     xmlreader_QueryInterface,
 332     xmlreader_AddRef,
 333     xmlreader_Release,
 334     xmlreader_SetInput,
 335     xmlreader_GetProperty,
 336     xmlreader_SetProperty,
 337     xmlreader_Read,
 338     xmlreader_GetNodeType,
 339     xmlreader_MoveToFirstAttribute,
 340     xmlreader_MoveToNextAttribute,
 341     xmlreader_MoveToAttributeByName,
 342     xmlreader_MoveToElement,
 343     xmlreader_GetQualifiedName,
 344     xmlreader_GetNamespaceUri,
 345     xmlreader_GetLocalName,
 346     xmlreader_GetPrefix,
 347     xmlreader_GetValue,
 348     xmlreader_ReadValueChunk,
 349     xmlreader_GetBaseUri,
 350     xmlreader_IsDefault,
 351     xmlreader_IsEmptyElement,
 352     xmlreader_GetLineNumber,
 353     xmlreader_GetLinePosition,
 354     xmlreader_GetAttributeCount,
 355     xmlreader_GetDepth,
 356     xmlreader_IsEOF
 357 };
 358
 359 /** IXmlReaderInput **/
 360
 361 /* Queries already stored interface for IStream/ISequentialStream.
 362    Interface supplied on creation will be overwritten */
 363 static HRESULT xmlreaderinput_query_for_stream(IXmlReaderInput *iface, void **pObj)
 364 {
 365     xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
 366     HRESULT hr;
 367
 368     hr = IUnknown_QueryInterface(This->input, &IID_IStream, pObj);
 369     if (hr != S_OK)
 370         hr = IUnknown_QueryInterface(This->input, &IID_ISequentialStream, pObj);
 371
 372     return hr;
 373 }
 374
 375 static HRESULT WINAPI xmlreaderinput_QueryInterface(IXmlReaderInput *iface, REFIID riid, void** ppvObject)
 376 {
 377     xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
 378
 379     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 380
 381     if (IsEqualGUID(riid, &IID_IXmlReaderInput) ||
 382         IsEqualGUID(riid, &IID_IUnknown))
 383     {
 384         *ppvObject = iface;
 385     }
 386     else
 387     {
 388         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 389         return E_NOINTERFACE;
 390     }
 391
 392     IUnknown_AddRef(iface);
 393
 394     return S_OK;
 395 }
 396
 397 static ULONG WINAPI xmlreaderinput_AddRef(IXmlReaderInput *iface)
 398 {
 399     xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
 400     TRACE("%p\n", This);
 401     return InterlockedIncrement(&This->ref);
 402 }
 403
 404 static ULONG WINAPI xmlreaderinput_Release(IXmlReaderInput *iface)
 405 {
 406     xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
 407     LONG ref;
 408
 409     TRACE("%p\n", This);
 410
 411     ref = InterlockedDecrement(&This->ref);
 412     if (ref == 0)
 413     {
 414         if (This->input) IUnknown_Release(This->input);
 415         HeapFree(GetProcessHeap(), 0, This);
 416     }
 417
 418     return ref;
 419 }
 420
 421 static const struct IUnknownVtbl xmlreaderinput_vtbl =
 422 {
 423     xmlreaderinput_QueryInterface,
 424     xmlreaderinput_AddRef,
 425     xmlreaderinput_Release
 426 };
 427
 428 HRESULT WINAPI CreateXmlReader(REFIID riid, void **pObject, IMalloc *pMalloc)
 429 {
 430     xmlreader *reader;
 431
 432     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), pObject, pMalloc);
 433
 434     if (pMalloc) FIXME("custom IMalloc not supported yet\n");
 435
 436     if (!IsEqualGUID(riid, &IID_IXmlReader))
 437     {
 438         ERR("Unexpected IID requested -> (%s)\n", wine_dbgstr_guid(riid));
 439         return E_FAIL;
 440     }
 441
 442     reader = HeapAlloc(GetProcessHeap(), 0, sizeof (*reader));
 443     if(!reader) return E_OUTOFMEMORY;
 444
 445     reader->lpVtbl = &xmlreader_vtbl;
 446     reader->ref = 1;
 447     reader->stream = NULL;
 448     reader->input = NULL;
 449     reader->state = XmlReadState_Closed;
 450
 451     *pObject = &reader->lpVtbl;
 452
 453     TRACE("returning iface %p\n", *pObject);
 454
 455     return S_OK;
 456 }
 457
 458 HRESULT WINAPI CreateXmlReaderInputWithEncodingName(IUnknown *stream,
 459                                                     IMalloc *pMalloc,
 460                                                     LPCWSTR encoding,
 461                                                     BOOL hint,
 462                                                     LPCWSTR base_uri,
 463                                                     IXmlReaderInput **ppInput)
 464 {
 465     xmlreaderinput *readerinput;
 466
 467     FIXME("%p %p %s %d %s %p: stub\n", stream, pMalloc, wine_dbgstr_w(encoding),
 468                                        hint, wine_dbgstr_w(base_uri), ppInput);
 469
 470     if (!stream || !ppInput) return E_INVALIDARG;
 471
 472     readerinput = HeapAlloc(GetProcessHeap(), 0, sizeof (*readerinput));
 473     if(!readerinput) return E_OUTOFMEMORY;
 474
 475     readerinput->lpVtbl = &xmlreaderinput_vtbl;
 476     readerinput->ref = 1;
 477     IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&readerinput->input);
 478
 479     *ppInput = (IXmlReaderInput*)&readerinput->lpVtbl;
 480
 481     TRACE("returning iface %p\n", *ppInput);
 482
 483     return S_OK;
 484 }