dlls/msxml3/xmldoc.c

   1 /*
   2  * XML Document implementation
   3  *
   4  * Copyright 2007 James Hawkins
   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 <libxml/parser.h>
  25 #include <libxml/xmlerror.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "msxml6.h"
  32 #include "wininet.h"
  33 #include "winreg.h"
  34 #include "shlwapi.h"
  35 #include "ocidl.h"
  36
  37 #include "wine/debug.h"
  38
  39 #include "msxml_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  42
  43 /* FIXME: IXMLDocument needs to implement
  44  *   - IXMLError
  45  *   - IPersistMoniker
  46  */
  47
  48 typedef struct _xmldoc
  49 {
  50     IXMLDocument IXMLDocument_iface;
  51     IPersistStreamInit IPersistStreamInit_iface;
  52     LONG ref;
  53     HRESULT error;
  54
  55     /* IXMLDocument */
  56     xmlDocPtr xmldoc;
  57
  58     /* IPersistStream */
  59     IStream *stream;
  60 } xmldoc;
  61
  62 static inline xmldoc *impl_from_IXMLDocument(IXMLDocument *iface)
  63 {
  64     return CONTAINING_RECORD(iface, xmldoc, IXMLDocument_iface);
  65 }
  66
  67 static inline xmldoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
  68 {
  69     return CONTAINING_RECORD(iface, xmldoc, IPersistStreamInit_iface);
  70 }
  71
  72 static HRESULT WINAPI xmldoc_QueryInterface(IXMLDocument *iface, REFIID riid, void** ppvObject)
  73 {
  74     xmldoc *This = impl_from_IXMLDocument(iface);
  75
  76     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  77
  78     if (IsEqualGUID(riid, &IID_IUnknown)  ||
  79         IsEqualGUID(riid, &IID_IDispatch) ||
  80         IsEqualGUID(riid, &IID_IXMLDocument))
  81     {
  82         *ppvObject = iface;
  83     }
  84     else if (IsEqualGUID(&IID_IPersistStreamInit, riid) ||
  85              IsEqualGUID(&IID_IPersistStream, riid))
  86     {
  87         *ppvObject = &This->IPersistStreamInit_iface;
  88     }
  89     else
  90     {
  91         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  92         *ppvObject = NULL;
  93         return E_NOINTERFACE;
  94     }
  95
  96     IXMLDocument_AddRef(iface);
  97
  98     return S_OK;
  99 }
 100
 101 static ULONG WINAPI xmldoc_AddRef(IXMLDocument *iface)
 102 {
 103     xmldoc *This = impl_from_IXMLDocument(iface);
 104     ULONG ref = InterlockedIncrement(&This->ref);
 105     TRACE("%p, refcount %ld.\n", iface, ref);
 106     return ref;
 107 }
 108
 109 static ULONG WINAPI xmldoc_Release(IXMLDocument *iface)
 110 {
 111     xmldoc *This = impl_from_IXMLDocument(iface);
 112     LONG ref = InterlockedDecrement(&This->ref);
 113
 114     TRACE("%p, refcount %ld.\n", iface, ref);
 115
 116     if (ref == 0)
 117     {
 118         xmlFreeDoc(This->xmldoc);
 119         if (This->stream) IStream_Release(This->stream);
 120         heap_free(This);
 121     }
 122
 123     return ref;
 124 }
 125
 126 static HRESULT WINAPI xmldoc_GetTypeInfoCount(IXMLDocument *iface, UINT* pctinfo)
 127 {
 128     xmldoc *This = impl_from_IXMLDocument(iface);
 129
 130     TRACE("(%p)->(%p)\n", This, pctinfo);
 131
 132     *pctinfo = 1;
 133
 134     return S_OK;
 135 }
 136
 137 static HRESULT WINAPI xmldoc_GetTypeInfo(IXMLDocument *iface, UINT iTInfo,
 138                                          LCID lcid, ITypeInfo** ppTInfo)
 139 {
 140     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 141
 142     return get_typeinfo(IXMLDocument_tid, ppTInfo);
 143 }
 144
 145 static HRESULT WINAPI xmldoc_GetIDsOfNames(IXMLDocument *iface, REFIID riid,
 146                                            LPOLESTR* rgszNames, UINT cNames,
 147                                            LCID lcid, DISPID* rgDispId)
 148 {
 149     ITypeInfo *typeinfo;
 150     HRESULT hr;
 151
 152     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames,
 153           lcid, rgDispId);
 154
 155     if(!rgszNames || cNames == 0 || !rgDispId)
 156         return E_INVALIDARG;
 157
 158     hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
 159     if(SUCCEEDED(hr))
 160     {
 161         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 162         ITypeInfo_Release(typeinfo);
 163     }
 164
 165     return hr;
 166 }
 167
 168 static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
 169                                     REFIID riid, LCID lcid, WORD wFlags,
 170                                     DISPPARAMS* pDispParams, VARIANT* pVarResult,
 171                                     EXCEPINFO* pExcepInfo, UINT* puArgErr)
 172 {
 173     ITypeInfo *typeinfo;
 174     HRESULT hr;
 175
 176     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 177           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 178
 179     hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
 180     if(SUCCEEDED(hr))
 181     {
 182         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 183         ITypeInfo_Release(typeinfo);
 184     }
 185
 186     return hr;
 187 }
 188
 189 static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
 190 {
 191     xmldoc *This = impl_from_IXMLDocument(iface);
 192     xmlNodePtr root;
 193
 194     TRACE("(%p, %p)\n", iface, p);
 195
 196     if (!p)
 197         return E_INVALIDARG;
 198
 199     *p = NULL;
 200
 201     if (!(root = xmlDocGetRootElement(This->xmldoc)))
 202         return E_FAIL;
 203
 204     return XMLElement_create(root, (LPVOID *)p, FALSE);
 205 }
 206
 207 static HRESULT WINAPI xmldoc_get_fileSize(IXMLDocument *iface, BSTR *p)
 208 {
 209     FIXME("(%p, %p): stub\n", iface, p);
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI xmldoc_put_fileModifiedDate(IXMLDocument *iface, BSTR *p)
 214 {
 215     FIXME("(%p, %p): stub\n", iface, p);
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI xmldoc_get_fileUpdatedDate(IXMLDocument *iface, BSTR *p)
 220 {
 221     FIXME("(%p, %p): stub\n", iface, p);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI xmldoc_get_URL(IXMLDocument *iface, BSTR *p)
 226 {
 227     FIXME("(%p, %p): stub\n", iface, p);
 228     return E_NOTIMPL;
 229 }
 230
 231 typedef struct {
 232     IBindStatusCallback IBindStatusCallback_iface;
 233 } bsc;
 234
 235 static HRESULT WINAPI bsc_QueryInterface(
 236     IBindStatusCallback *iface,
 237     REFIID riid,
 238     LPVOID *ppobj )
 239 {
 240     if (IsEqualGUID(riid, &IID_IUnknown) ||
 241         IsEqualGUID(riid, &IID_IBindStatusCallback))
 242     {
 243         IBindStatusCallback_AddRef( iface );
 244         *ppobj = iface;
 245         return S_OK;
 246     }
 247
 248     TRACE("interface %s not implemented\n", debugstr_guid(riid));
 249     return E_NOINTERFACE;
 250 }
 251
 252 static ULONG WINAPI bsc_AddRef(
 253     IBindStatusCallback *iface )
 254 {
 255     return 2;
 256 }
 257
 258 static ULONG WINAPI bsc_Release(
 259     IBindStatusCallback *iface )
 260 {
 261     return 1;
 262 }
 263
 264 static HRESULT WINAPI bsc_OnStartBinding(
 265         IBindStatusCallback* iface,
 266         DWORD dwReserved,
 267         IBinding* pib)
 268 {
 269     return S_OK;
 270 }
 271
 272 static HRESULT WINAPI bsc_GetPriority(
 273         IBindStatusCallback* iface,
 274         LONG* pnPriority)
 275 {
 276     return S_OK;
 277 }
 278
 279 static HRESULT WINAPI bsc_OnLowResource(
 280         IBindStatusCallback* iface,
 281         DWORD reserved)
 282 {
 283     return S_OK;
 284 }
 285
 286 static HRESULT WINAPI bsc_OnProgress(
 287         IBindStatusCallback* iface,
 288         ULONG ulProgress,
 289         ULONG ulProgressMax,
 290         ULONG ulStatusCode,
 291         LPCWSTR szStatusText)
 292 {
 293     return S_OK;
 294 }
 295
 296 static HRESULT WINAPI bsc_OnStopBinding(
 297         IBindStatusCallback* iface,
 298         HRESULT hresult,
 299         LPCWSTR szError)
 300 {
 301     return S_OK;
 302 }
 303
 304 static HRESULT WINAPI bsc_GetBindInfo(
 305         IBindStatusCallback* iface,
 306         DWORD* grfBINDF,
 307         BINDINFO* pbindinfo)
 308 {
 309     *grfBINDF = BINDF_RESYNCHRONIZE;
 310
 311     return S_OK;
 312 }
 313
 314 static HRESULT WINAPI bsc_OnDataAvailable(
 315         IBindStatusCallback* iface,
 316         DWORD grfBSCF,
 317         DWORD dwSize,
 318         FORMATETC* pformatetc,
 319         STGMEDIUM* pstgmed)
 320 {
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI bsc_OnObjectAvailable(
 325         IBindStatusCallback* iface,
 326         REFIID riid,
 327         IUnknown* punk)
 328 {
 329     return S_OK;
 330 }
 331
 332 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 333 {
 334     bsc_QueryInterface,
 335     bsc_AddRef,
 336     bsc_Release,
 337     bsc_OnStartBinding,
 338     bsc_GetPriority,
 339     bsc_OnLowResource,
 340     bsc_OnProgress,
 341     bsc_OnStopBinding,
 342     bsc_GetBindInfo,
 343     bsc_OnDataAvailable,
 344     bsc_OnObjectAvailable
 345 };
 346
 347 static bsc xmldoc_bsc = { { &bsc_vtbl } };
 348
 349 static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
 350 {
 351     WCHAR url[INTERNET_MAX_URL_LENGTH];
 352     IStream *stream;
 353     IBindCtx *bctx;
 354     IMoniker *moniker;
 355     IPersistStreamInit *persist;
 356     HRESULT hr;
 357
 358     TRACE("(%p, %s)\n", iface, debugstr_w(p));
 359
 360     if (!p)
 361         return E_INVALIDARG;
 362
 363     if (!PathIsURLW(p))
 364     {
 365         WCHAR fullpath[MAX_PATH];
 366         DWORD needed = ARRAY_SIZE(url);
 367
 368         if (!PathSearchAndQualifyW(p, fullpath, ARRAY_SIZE(fullpath)))
 369         {
 370             ERR("can't find path\n");
 371             return E_FAIL;
 372         }
 373
 374         if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
 375         {
 376             ERR("can't create url from path\n");
 377             return E_FAIL;
 378         }
 379
 380         p = url;
 381     }
 382
 383     hr = CreateURLMoniker(NULL, p, &moniker);
 384     if (FAILED(hr))
 385         return hr;
 386
 387     CreateAsyncBindCtx(0, &xmldoc_bsc.IBindStatusCallback_iface, 0, &bctx);
 388
 389     hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
 390     IBindCtx_Release(bctx);
 391     IMoniker_Release(moniker);
 392     if (FAILED(hr))
 393         return hr;
 394
 395     hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
 396     if (FAILED(hr))
 397     {
 398         IStream_Release(stream);
 399         return hr;
 400     }
 401
 402     hr = IPersistStreamInit_Load(persist, stream);
 403     IPersistStreamInit_Release(persist);
 404     IStream_Release(stream);
 405
 406     return hr;
 407 }
 408
 409 static HRESULT WINAPI xmldoc_get_mimeType(IXMLDocument *iface, BSTR *p)
 410 {
 411     FIXME("(%p, %p): stub\n", iface, p);
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI xmldoc_get_readyState(IXMLDocument *iface, LONG *p)
 416 {
 417     FIXME("(%p, %p): stub\n", iface, p);
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI xmldoc_get_charset(IXMLDocument *iface, BSTR *p)
 422 {
 423     FIXME("(%p, %p): stub\n", iface, p);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI xmldoc_put_charset(IXMLDocument *iface, BSTR p)
 428 {
 429     FIXME("(%p, %p): stub\n", iface, p);
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI xmldoc_get_version(IXMLDocument *iface, BSTR *p)
 434 {
 435     xmldoc *This = impl_from_IXMLDocument(iface);
 436
 437     TRACE("(%p, %p)\n", This, p);
 438
 439     if (!p) return E_INVALIDARG;
 440     *p = bstr_from_xmlChar(This->xmldoc->version);
 441
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
 446 {
 447     xmldoc *This = impl_from_IXMLDocument(iface);
 448     xmlDtd *dtd;
 449
 450     TRACE("(%p, %p)\n", This, p);
 451
 452     if (!p) return E_INVALIDARG;
 453
 454     dtd = xmlGetIntSubset(This->xmldoc);
 455     if (!dtd) return S_FALSE;
 456
 457     *p = bstr_from_xmlChar(dtd->name);
 458     CharUpperBuffW(*p, SysStringLen(*p));
 459
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI xmldoc_get_dtdURl(IXMLDocument *iface, BSTR *p)
 464 {
 465     FIXME("(%p, %p): stub\n", iface, p);
 466     return E_NOTIMPL;
 467 }
 468
 469 static xmlElementType type_msxml_to_libxml(LONG type)
 470 {
 471     switch (type)
 472     {
 473         case XMLELEMTYPE_ELEMENT:
 474             return XML_ELEMENT_NODE;
 475         case XMLELEMTYPE_TEXT:
 476             return XML_TEXT_NODE;
 477         case XMLELEMTYPE_COMMENT:
 478             return XML_COMMENT_NODE;
 479         case XMLELEMTYPE_DOCUMENT:
 480             return XML_DOCUMENT_NODE;
 481         case XMLELEMTYPE_DTD:
 482             return XML_DTD_NODE;
 483         case XMLELEMTYPE_PI:
 484             return XML_PI_NODE;
 485         default:
 486             break;
 487     }
 488
 489     return -1; /* FIXME: what is OTHER in msxml? */
 490 }
 491
 492 static HRESULT WINAPI xmldoc_createElement(IXMLDocument *iface, VARIANT vType,
 493                                            VARIANT var1, IXMLElement **ppElem)
 494 {
 495     xmlNodePtr node;
 496     static const xmlChar empty[] = "\0";
 497
 498     TRACE("(%p)->(%s %s %p)\n", iface, debugstr_variant(&vType),
 499         debugstr_variant(&var1), ppElem);
 500
 501     if (!ppElem)
 502         return E_INVALIDARG;
 503
 504     *ppElem = NULL;
 505
 506     if (V_VT(&vType) != VT_I4)
 507         return E_INVALIDARG;
 508
 509     if(type_msxml_to_libxml(V_I4(&vType)) == -1)
 510         return E_NOTIMPL;
 511
 512     node = xmlNewNode(NULL, empty);
 513     node->type = type_msxml_to_libxml(V_I4(&vType));
 514
 515     /* FIXME: create xmlNodePtr based on vType and var1 */
 516     return XMLElement_create(node, (LPVOID *)ppElem, TRUE);
 517 }
 518
 519 static const struct IXMLDocumentVtbl xmldoc_vtbl =
 520 {
 521     xmldoc_QueryInterface,
 522     xmldoc_AddRef,
 523     xmldoc_Release,
 524     xmldoc_GetTypeInfoCount,
 525     xmldoc_GetTypeInfo,
 526     xmldoc_GetIDsOfNames,
 527     xmldoc_Invoke,
 528     xmldoc_get_root,
 529     xmldoc_get_fileSize,
 530     xmldoc_put_fileModifiedDate,
 531     xmldoc_get_fileUpdatedDate,
 532     xmldoc_get_URL,
 533     xmldoc_put_URL,
 534     xmldoc_get_mimeType,
 535     xmldoc_get_readyState,
 536     xmldoc_get_charset,
 537     xmldoc_put_charset,
 538     xmldoc_get_version,
 539     xmldoc_get_doctype,
 540     xmldoc_get_dtdURl,
 541     xmldoc_createElement
 542 };
 543
 544 /************************************************************************
 545  * xmldoc implementation of IPersistStreamInit.
 546  */
 547 static HRESULT WINAPI xmldoc_IPersistStreamInit_QueryInterface(
 548     IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj)
 549 {
 550     xmldoc *this = impl_from_IPersistStreamInit(iface);
 551     return IXMLDocument_QueryInterface(&this->IXMLDocument_iface, riid, ppvObj);
 552 }
 553
 554 static ULONG WINAPI xmldoc_IPersistStreamInit_AddRef(
 555     IPersistStreamInit *iface)
 556 {
 557     xmldoc *this = impl_from_IPersistStreamInit(iface);
 558     return IXMLDocument_AddRef(&this->IXMLDocument_iface);
 559 }
 560
 561 static ULONG WINAPI xmldoc_IPersistStreamInit_Release(
 562     IPersistStreamInit *iface)
 563 {
 564     xmldoc *this = impl_from_IPersistStreamInit(iface);
 565     return IXMLDocument_Release(&this->IXMLDocument_iface);
 566 }
 567
 568 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetClassID(
 569     IPersistStreamInit *iface, CLSID *classid)
 570 {
 571     xmldoc *this = impl_from_IPersistStreamInit(iface);
 572     TRACE("(%p,%p)\n", this, classid);
 573
 574     if (!classid) return E_POINTER;
 575
 576     *classid = CLSID_XMLDocument;
 577     return S_OK;
 578 }
 579
 580 static HRESULT WINAPI xmldoc_IPersistStreamInit_IsDirty(
 581     IPersistStreamInit *iface)
 582 {
 583     FIXME("(%p): stub!\n", iface);
 584     return E_NOTIMPL;
 585 }
 586
 587 static xmlDocPtr parse_xml(char *ptr, int len)
 588 {
 589     return xmlReadMemory(ptr, len, NULL, NULL,
 590                          XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS);
 591 }
 592
 593 static HRESULT WINAPI xmldoc_IPersistStreamInit_Load(
 594     IPersistStreamInit *iface, LPSTREAM pStm)
 595 {
 596     xmldoc *This = impl_from_IPersistStreamInit(iface);
 597     HRESULT hr;
 598     HGLOBAL hglobal;
 599     DWORD read, written, len;
 600     BYTE buf[4096];
 601     char *ptr;
 602
 603     TRACE("(%p, %p)\n", iface, pStm);
 604
 605     if (!pStm)
 606         return E_INVALIDARG;
 607
 608     /* release previously allocated stream */
 609     if (This->stream) IStream_Release(This->stream);
 610     hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 611     if (FAILED(hr))
 612         return hr;
 613
 614     do
 615     {
 616         IStream_Read(pStm, buf, sizeof(buf), &read);
 617         hr = IStream_Write(This->stream, buf, read, &written);
 618     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 619
 620     if (FAILED(hr))
 621     {
 622         ERR("Failed to copy stream\n");
 623         return hr;
 624     }
 625
 626     hr = GetHGlobalFromStream(This->stream, &hglobal);
 627     if (FAILED(hr))
 628         return hr;
 629
 630     len = GlobalSize(hglobal);
 631     ptr = GlobalLock(hglobal);
 632     if (len != 0)
 633     {
 634         xmlFreeDoc(This->xmldoc);
 635         This->xmldoc = parse_xml(ptr, len);
 636     }
 637     GlobalUnlock(hglobal);
 638
 639     if (!This->xmldoc)
 640     {
 641         ERR("Failed to parse xml\n");
 642         return E_FAIL;
 643     }
 644
 645     return S_OK;
 646 }
 647
 648 static HRESULT WINAPI xmldoc_IPersistStreamInit_Save(
 649     IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty)
 650 {
 651     FIXME("(%p, %p, %d): stub!\n", iface, pStm, fClearDirty);
 652     return E_NOTIMPL;
 653 }
 654
 655 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetSizeMax(
 656     IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
 657 {
 658     xmldoc *This = impl_from_IPersistStreamInit(iface);
 659     TRACE("(%p, %p)\n", This, pcbSize);
 660     return E_NOTIMPL;
 661 }
 662
 663 static HRESULT WINAPI xmldoc_IPersistStreamInit_InitNew(
 664     IPersistStreamInit *iface)
 665 {
 666     xmldoc *This = impl_from_IPersistStreamInit(iface);
 667     TRACE("(%p)\n", This);
 668     return S_OK;
 669 }
 670
 671 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
 672 {
 673   xmldoc_IPersistStreamInit_QueryInterface,
 674   xmldoc_IPersistStreamInit_AddRef,
 675   xmldoc_IPersistStreamInit_Release,
 676   xmldoc_IPersistStreamInit_GetClassID,
 677   xmldoc_IPersistStreamInit_IsDirty,
 678   xmldoc_IPersistStreamInit_Load,
 679   xmldoc_IPersistStreamInit_Save,
 680   xmldoc_IPersistStreamInit_GetSizeMax,
 681   xmldoc_IPersistStreamInit_InitNew
 682 };
 683
 684 HRESULT XMLDocument_create(LPVOID *ppObj)
 685 {
 686     xmldoc *doc;
 687
 688     TRACE("(%p)\n", ppObj);
 689
 690     doc = heap_alloc(sizeof (*doc));
 691     if(!doc)
 692         return E_OUTOFMEMORY;
 693
 694     doc->IXMLDocument_iface.lpVtbl = &xmldoc_vtbl;
 695     doc->IPersistStreamInit_iface.lpVtbl = &xmldoc_IPersistStreamInit_VTable;
 696     doc->ref = 1;
 697     doc->error = S_OK;
 698     doc->xmldoc = NULL;
 699     doc->stream = NULL;
 700
 701     *ppObj = &doc->IXMLDocument_iface;
 702
 703     TRACE("returning iface %p\n", *ppObj);
 704     return S_OK;
 705 }