git.oblomov.eu Git - wine/blob - dlls/msxml3/domdoc.c

   1 /*
   2  *    DOM Document implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   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 "config.h"
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33 #include "wininet.h"
  34 #include "urlmon.h"
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "wine/debug.h"
  39
  40 #include "msxml_private.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 typedef struct {
  47     const struct IBindStatusCallbackVtbl *lpVtbl;
  48 } bsc;
  49
  50 static HRESULT WINAPI bsc_QueryInterface(
  51     IBindStatusCallback *iface,
  52     REFIID riid,
  53     LPVOID *ppobj )
  54 {
  55     if (IsEqualGUID(riid, &IID_IUnknown) ||
  56         IsEqualGUID(riid, &IID_IBindStatusCallback))
  57     {
  58         IBindStatusCallback_AddRef( iface );
  59         *ppobj = iface;
  60         return S_OK;
  61     }
  62
  63     FIXME("interface %s not implemented\n", debugstr_guid(riid));
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG WINAPI bsc_AddRef(
  68     IBindStatusCallback *iface )
  69 {
  70     return 2;
  71 }
  72
  73 static ULONG WINAPI bsc_Release(
  74     IBindStatusCallback *iface )
  75 {
  76     return 1;
  77 }
  78
  79 static HRESULT WINAPI bsc_OnStartBinding(
  80         IBindStatusCallback* iface,
  81         DWORD dwReserved,
  82         IBinding* pib)
  83 {
  84     return S_OK;
  85 }
  86
  87 static HRESULT WINAPI bsc_GetPriority(
  88         IBindStatusCallback* iface,
  89         LONG* pnPriority)
  90 {
  91     return S_OK;
  92 }
  93
  94 static HRESULT WINAPI bsc_OnLowResource(
  95         IBindStatusCallback* iface,
  96         DWORD reserved)
  97 {
  98     return S_OK;
  99 }
 100
 101 static HRESULT WINAPI bsc_OnProgress(
 102         IBindStatusCallback* iface,
 103         ULONG ulProgress,
 104         ULONG ulProgressMax,
 105         ULONG ulStatusCode,
 106         LPCWSTR szStatusText)
 107 {
 108     return S_OK;
 109 }
 110
 111 static HRESULT WINAPI bsc_OnStopBinding(
 112         IBindStatusCallback* iface,
 113         HRESULT hresult,
 114         LPCWSTR szError)
 115 {
 116     return S_OK;
 117 }
 118
 119 static HRESULT WINAPI bsc_GetBindInfo(
 120         IBindStatusCallback* iface,
 121         DWORD* grfBINDF,
 122         BINDINFO* pbindinfo)
 123 {
 124     *grfBINDF = BINDF_RESYNCHRONIZE;
 125
 126     return S_OK;
 127 }
 128
 129 static HRESULT WINAPI bsc_OnDataAvailable(
 130         IBindStatusCallback* iface,
 131         DWORD grfBSCF,
 132         DWORD dwSize,
 133         FORMATETC* pformatetc,
 134         STGMEDIUM* pstgmed)
 135 {
 136     return S_OK;
 137 }
 138
 139 static HRESULT WINAPI bsc_OnObjectAvailable(
 140         IBindStatusCallback* iface,
 141         REFIID riid,
 142         IUnknown* punk)
 143 {
 144     return S_OK;
 145 }
 146
 147 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 148 {
 149     bsc_QueryInterface,
 150     bsc_AddRef,
 151     bsc_Release,
 152     bsc_OnStartBinding,
 153     bsc_GetPriority,
 154     bsc_OnLowResource,
 155     bsc_OnProgress,
 156     bsc_OnStopBinding,
 157     bsc_GetBindInfo,
 158     bsc_OnDataAvailable,
 159     bsc_OnObjectAvailable
 160 };
 161
 162 static bsc domdoc_bsc = { &bsc_vtbl };
 163
 164 typedef struct _domdoc
 165 {
 166     const struct IXMLDOMDocumentVtbl *lpVtbl;
 167     LONG ref;
 168     VARIANT_BOOL async;
 169     VARIANT_BOOL validating;
 170     VARIANT_BOOL resolving;
 171     VARIANT_BOOL preserving;
 172     IUnknown *node_unk;
 173     IXMLDOMNode *node;
 174     HRESULT error;
 175 } domdoc;
 176
 177 LONG xmldoc_add_ref(xmlDocPtr doc)
 178 {
 179     LONG ref = InterlockedIncrement((LONG*)&doc->_private);
 180     TRACE("%d\n", ref);
 181     return ref;
 182 }
 183
 184 LONG xmldoc_release(xmlDocPtr doc)
 185 {
 186     LONG ref = InterlockedDecrement((LONG*)&doc->_private);
 187     TRACE("%d\n", ref);
 188     if(ref == 0)
 189     {
 190         TRACE("freeing docptr %p\n", doc);
 191         xmlFreeDoc(doc);
 192     }
 193
 194     return ref;
 195 }
 196
 197 static inline domdoc *impl_from_IXMLDOMDocument( IXMLDOMDocument *iface )
 198 {
 199     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtbl));
 200 }
 201
 202 static inline xmlDocPtr get_doc( domdoc *This )
 203 {
 204     return (xmlDocPtr) xmlNodePtr_from_domnode( This->node, XML_DOCUMENT_NODE );
 205 }
 206
 207 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument *iface, REFIID riid, void** ppvObject )
 208 {
 209     domdoc *This = impl_from_IXMLDOMDocument( iface );
 210
 211     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 212
 213     if ( IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
 214          IsEqualGUID( riid, &IID_IUnknown ) )
 215     {
 216         *ppvObject = iface;
 217     }
 218     else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
 219               IsEqualGUID( riid, &IID_IDispatch ) )
 220     {
 221         return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
 222     }
 223     else
 224     {
 225         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 226         return E_NOINTERFACE;
 227     }
 228
 229     IXMLDOMDocument_AddRef( iface );
 230
 231     return S_OK;
 232 }
 233
 234
 235 static ULONG WINAPI domdoc_AddRef(
 236      IXMLDOMDocument *iface )
 237 {
 238     domdoc *This = impl_from_IXMLDOMDocument( iface );
 239     TRACE("%p\n", This );
 240     return InterlockedIncrement( &This->ref );
 241 }
 242
 243
 244 static ULONG WINAPI domdoc_Release(
 245      IXMLDOMDocument *iface )
 246 {
 247     domdoc *This = impl_from_IXMLDOMDocument( iface );
 248     LONG ref;
 249
 250     TRACE("%p\n", This );
 251
 252     ref = InterlockedDecrement( &This->ref );
 253     if ( ref == 0 )
 254     {
 255         IUnknown_Release( This->node_unk );
 256         HeapFree( GetProcessHeap(), 0, This );
 257     }
 258
 259     return ref;
 260 }
 261
 262 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument *iface, UINT* pctinfo )
 263 {
 264     FIXME("\n");
 265     return E_NOTIMPL;
 266 }
 267
 268 static HRESULT WINAPI domdoc_GetTypeInfo(
 269     IXMLDOMDocument *iface,
 270     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 271 {
 272     FIXME("\n");
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI domdoc_GetIDsOfNames(
 277     IXMLDOMDocument *iface,
 278     REFIID riid,
 279     LPOLESTR* rgszNames,
 280     UINT cNames,
 281     LCID lcid,
 282     DISPID* rgDispId)
 283 {
 284     FIXME("\n");
 285     return E_NOTIMPL;
 286 }
 287
 288
 289 static HRESULT WINAPI domdoc_Invoke(
 290     IXMLDOMDocument *iface,
 291     DISPID dispIdMember,
 292     REFIID riid,
 293     LCID lcid,
 294     WORD wFlags,
 295     DISPPARAMS* pDispParams,
 296     VARIANT* pVarResult,
 297     EXCEPINFO* pExcepInfo,
 298     UINT* puArgErr)
 299 {
 300     FIXME("\n");
 301     return E_NOTIMPL;
 302 }
 303
 304
 305 static HRESULT WINAPI domdoc_get_nodeName(
 306     IXMLDOMDocument *iface,
 307     BSTR* name )
 308 {
 309     domdoc *This = impl_from_IXMLDOMDocument( iface );
 310     return IXMLDOMNode_get_nodeName( This->node, name );
 311 }
 312
 313
 314 static HRESULT WINAPI domdoc_get_nodeValue(
 315     IXMLDOMDocument *iface,
 316     VARIANT* value )
 317 {
 318     domdoc *This = impl_from_IXMLDOMDocument( iface );
 319     return IXMLDOMNode_get_nodeValue( This->node, value );
 320 }
 321
 322
 323 static HRESULT WINAPI domdoc_put_nodeValue(
 324     IXMLDOMDocument *iface,
 325     VARIANT value)
 326 {
 327     domdoc *This = impl_from_IXMLDOMDocument( iface );
 328     return IXMLDOMNode_put_nodeValue( This->node, value );
 329 }
 330
 331
 332 static HRESULT WINAPI domdoc_get_nodeType(
 333     IXMLDOMDocument *iface,
 334     DOMNodeType* type )
 335 {
 336     domdoc *This = impl_from_IXMLDOMDocument( iface );
 337     return IXMLDOMNode_get_nodeType( This->node, type );
 338 }
 339
 340
 341 static HRESULT WINAPI domdoc_get_parentNode(
 342     IXMLDOMDocument *iface,
 343     IXMLDOMNode** parent )
 344 {
 345     domdoc *This = impl_from_IXMLDOMDocument( iface );
 346     return IXMLDOMNode_get_parentNode( This->node, parent );
 347 }
 348
 349
 350 static HRESULT WINAPI domdoc_get_childNodes(
 351     IXMLDOMDocument *iface,
 352     IXMLDOMNodeList** childList )
 353 {
 354     domdoc *This = impl_from_IXMLDOMDocument( iface );
 355     return IXMLDOMNode_get_childNodes( This->node, childList );
 356 }
 357
 358
 359 static HRESULT WINAPI domdoc_get_firstChild(
 360     IXMLDOMDocument *iface,
 361     IXMLDOMNode** firstChild )
 362 {
 363     domdoc *This = impl_from_IXMLDOMDocument( iface );
 364     return IXMLDOMNode_get_firstChild( This->node, firstChild );
 365 }
 366
 367
 368 static HRESULT WINAPI domdoc_get_lastChild(
 369     IXMLDOMDocument *iface,
 370     IXMLDOMNode** lastChild )
 371 {
 372     domdoc *This = impl_from_IXMLDOMDocument( iface );
 373     return IXMLDOMNode_get_lastChild( This->node, lastChild );
 374 }
 375
 376
 377 static HRESULT WINAPI domdoc_get_previousSibling(
 378     IXMLDOMDocument *iface,
 379     IXMLDOMNode** previousSibling )
 380 {
 381     domdoc *This = impl_from_IXMLDOMDocument( iface );
 382     return IXMLDOMNode_get_previousSibling( This->node, previousSibling );
 383 }
 384
 385
 386 static HRESULT WINAPI domdoc_get_nextSibling(
 387     IXMLDOMDocument *iface,
 388     IXMLDOMNode** nextSibling )
 389 {
 390     domdoc *This = impl_from_IXMLDOMDocument( iface );
 391     return IXMLDOMNode_get_nextSibling( This->node, nextSibling );
 392 }
 393
 394
 395 static HRESULT WINAPI domdoc_get_attributes(
 396     IXMLDOMDocument *iface,
 397     IXMLDOMNamedNodeMap** attributeMap )
 398 {
 399     domdoc *This = impl_from_IXMLDOMDocument( iface );
 400     return IXMLDOMNode_get_attributes( This->node, attributeMap );
 401 }
 402
 403
 404 static HRESULT WINAPI domdoc_insertBefore(
 405     IXMLDOMDocument *iface,
 406     IXMLDOMNode* newChild,
 407     VARIANT refChild,
 408     IXMLDOMNode** outNewChild )
 409 {
 410     domdoc *This = impl_from_IXMLDOMDocument( iface );
 411     return IXMLDOMNode_insertBefore( This->node, newChild, refChild, outNewChild );
 412 }
 413
 414
 415 static HRESULT WINAPI domdoc_replaceChild(
 416     IXMLDOMDocument *iface,
 417     IXMLDOMNode* newChild,
 418     IXMLDOMNode* oldChild,
 419     IXMLDOMNode** outOldChild)
 420 {
 421     domdoc *This = impl_from_IXMLDOMDocument( iface );
 422     return IXMLDOMNode_replaceChild( This->node, newChild, oldChild, outOldChild );
 423 }
 424
 425
 426 static HRESULT WINAPI domdoc_removeChild(
 427     IXMLDOMDocument *iface,
 428     IXMLDOMNode* childNode,
 429     IXMLDOMNode** oldChild)
 430 {
 431     domdoc *This = impl_from_IXMLDOMDocument( iface );
 432     return IXMLDOMNode_removeChild( This->node, childNode, oldChild );
 433 }
 434
 435
 436 static HRESULT WINAPI domdoc_appendChild(
 437     IXMLDOMDocument *iface,
 438     IXMLDOMNode* newChild,
 439     IXMLDOMNode** outNewChild)
 440 {
 441     domdoc *This = impl_from_IXMLDOMDocument( iface );
 442     return IXMLDOMNode_appendChild( This->node, newChild, outNewChild );
 443 }
 444
 445
 446 static HRESULT WINAPI domdoc_hasChildNodes(
 447     IXMLDOMDocument *iface,
 448     VARIANT_BOOL* hasChild)
 449 {
 450     domdoc *This = impl_from_IXMLDOMDocument( iface );
 451     return IXMLDOMNode_hasChildNodes( This->node, hasChild );
 452 }
 453
 454
 455 static HRESULT WINAPI domdoc_get_ownerDocument(
 456     IXMLDOMDocument *iface,
 457     IXMLDOMDocument** DOMDocument)
 458 {
 459     domdoc *This = impl_from_IXMLDOMDocument( iface );
 460     return IXMLDOMNode_get_ownerDocument( This->node, DOMDocument );
 461 }
 462
 463
 464 static HRESULT WINAPI domdoc_cloneNode(
 465     IXMLDOMDocument *iface,
 466     VARIANT_BOOL deep,
 467     IXMLDOMNode** cloneRoot)
 468 {
 469     domdoc *This = impl_from_IXMLDOMDocument( iface );
 470     return IXMLDOMNode_cloneNode( This->node, deep, cloneRoot );
 471 }
 472
 473
 474 static HRESULT WINAPI domdoc_get_nodeTypeString(
 475     IXMLDOMDocument *iface,
 476     BSTR* nodeType )
 477 {
 478     domdoc *This = impl_from_IXMLDOMDocument( iface );
 479     return IXMLDOMNode_get_nodeTypeString( This->node, nodeType );
 480 }
 481
 482
 483 static HRESULT WINAPI domdoc_get_text(
 484     IXMLDOMDocument *iface,
 485     BSTR* text )
 486 {
 487     domdoc *This = impl_from_IXMLDOMDocument( iface );
 488     return IXMLDOMNode_get_text( This->node, text );
 489 }
 490
 491
 492 static HRESULT WINAPI domdoc_put_text(
 493     IXMLDOMDocument *iface,
 494     BSTR text )
 495 {
 496     domdoc *This = impl_from_IXMLDOMDocument( iface );
 497     return IXMLDOMNode_put_text( This->node, text );
 498 }
 499
 500
 501 static HRESULT WINAPI domdoc_get_specified(
 502     IXMLDOMDocument *iface,
 503     VARIANT_BOOL* isSpecified )
 504 {
 505     domdoc *This = impl_from_IXMLDOMDocument( iface );
 506     return IXMLDOMNode_get_specified( This->node, isSpecified );
 507 }
 508
 509
 510 static HRESULT WINAPI domdoc_get_definition(
 511     IXMLDOMDocument *iface,
 512     IXMLDOMNode** definitionNode )
 513 {
 514     domdoc *This = impl_from_IXMLDOMDocument( iface );
 515     return IXMLDOMNode_get_definition( This->node, definitionNode );
 516 }
 517
 518
 519 static HRESULT WINAPI domdoc_get_nodeTypedValue(
 520     IXMLDOMDocument *iface,
 521     VARIANT* typedValue )
 522 {
 523     domdoc *This = impl_from_IXMLDOMDocument( iface );
 524     return IXMLDOMNode_get_nodeTypedValue( This->node, typedValue );
 525 }
 526
 527 static HRESULT WINAPI domdoc_put_nodeTypedValue(
 528     IXMLDOMDocument *iface,
 529     VARIANT typedValue )
 530 {
 531     domdoc *This = impl_from_IXMLDOMDocument( iface );
 532     return IXMLDOMNode_put_nodeTypedValue( This->node, typedValue );
 533 }
 534
 535
 536 static HRESULT WINAPI domdoc_get_dataType(
 537     IXMLDOMDocument *iface,
 538     VARIANT* dataTypeName )
 539 {
 540     domdoc *This = impl_from_IXMLDOMDocument( iface );
 541     return IXMLDOMNode_get_dataType( This->node, dataTypeName );
 542 }
 543
 544
 545 static HRESULT WINAPI domdoc_put_dataType(
 546     IXMLDOMDocument *iface,
 547     BSTR dataTypeName )
 548 {
 549     domdoc *This = impl_from_IXMLDOMDocument( iface );
 550     return IXMLDOMNode_put_dataType( This->node, dataTypeName );
 551 }
 552
 553
 554 static HRESULT WINAPI domdoc_get_xml(
 555     IXMLDOMDocument *iface,
 556     BSTR* xmlString )
 557 {
 558     domdoc *This = impl_from_IXMLDOMDocument( iface );
 559     return IXMLDOMNode_get_xml( This->node, xmlString );
 560 }
 561
 562
 563 static HRESULT WINAPI domdoc_transformNode(
 564     IXMLDOMDocument *iface,
 565     IXMLDOMNode* styleSheet,
 566     BSTR* xmlString )
 567 {
 568     domdoc *This = impl_from_IXMLDOMDocument( iface );
 569     return IXMLDOMNode_transformNode( This->node, styleSheet, xmlString );
 570 }
 571
 572
 573 static HRESULT WINAPI domdoc_selectNodes(
 574     IXMLDOMDocument *iface,
 575     BSTR queryString,
 576     IXMLDOMNodeList** resultList )
 577 {
 578     domdoc *This = impl_from_IXMLDOMDocument( iface );
 579     return IXMLDOMNode_selectNodes( This->node, queryString, resultList );
 580 }
 581
 582
 583 static HRESULT WINAPI domdoc_selectSingleNode(
 584     IXMLDOMDocument *iface,
 585     BSTR queryString,
 586     IXMLDOMNode** resultNode )
 587 {
 588     domdoc *This = impl_from_IXMLDOMDocument( iface );
 589     return IXMLDOMNode_selectSingleNode( This->node, queryString, resultNode );
 590 }
 591
 592
 593 static HRESULT WINAPI domdoc_get_parsed(
 594     IXMLDOMDocument *iface,
 595     VARIANT_BOOL* isParsed )
 596 {
 597     domdoc *This = impl_from_IXMLDOMDocument( iface );
 598     return IXMLDOMNode_get_parsed( This->node, isParsed );
 599 }
 600
 601
 602 static HRESULT WINAPI domdoc_get_namespaceURI(
 603     IXMLDOMDocument *iface,
 604     BSTR* namespaceURI )
 605 {
 606     domdoc *This = impl_from_IXMLDOMDocument( iface );
 607     return IXMLDOMNode_get_namespaceURI( This->node, namespaceURI );
 608 }
 609
 610
 611 static HRESULT WINAPI domdoc_get_prefix(
 612     IXMLDOMDocument *iface,
 613     BSTR* prefixString )
 614 {
 615     domdoc *This = impl_from_IXMLDOMDocument( iface );
 616     return IXMLDOMNode_get_prefix( This->node, prefixString );
 617 }
 618
 619
 620 static HRESULT WINAPI domdoc_get_baseName(
 621     IXMLDOMDocument *iface,
 622     BSTR* nameString )
 623 {
 624     domdoc *This = impl_from_IXMLDOMDocument( iface );
 625     return IXMLDOMNode_get_baseName( This->node, nameString );
 626 }
 627
 628
 629 static HRESULT WINAPI domdoc_transformNodeToObject(
 630     IXMLDOMDocument *iface,
 631     IXMLDOMNode* stylesheet,
 632     VARIANT outputObject)
 633 {
 634     domdoc *This = impl_from_IXMLDOMDocument( iface );
 635     return IXMLDOMNode_transformNodeToObject( This->node, stylesheet, outputObject );
 636 }
 637
 638
 639 static HRESULT WINAPI domdoc_get_doctype(
 640     IXMLDOMDocument *iface,
 641     IXMLDOMDocumentType** documentType )
 642 {
 643     FIXME("\n");
 644     return E_NOTIMPL;
 645 }
 646
 647
 648 static HRESULT WINAPI domdoc_get_implementation(
 649     IXMLDOMDocument *iface,
 650     IXMLDOMImplementation** impl )
 651 {
 652     FIXME("\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI domdoc_get_documentElement(
 657     IXMLDOMDocument *iface,
 658     IXMLDOMElement** DOMElement )
 659 {
 660     domdoc *This = impl_from_IXMLDOMDocument( iface );
 661     xmlDocPtr xmldoc = NULL;
 662     xmlNodePtr root = NULL;
 663     IXMLDOMNode *element_node;
 664     HRESULT hr;
 665
 666     TRACE("%p\n", This);
 667
 668     *DOMElement = NULL;
 669
 670     xmldoc = get_doc( This );
 671
 672     root = xmlDocGetRootElement( xmldoc );
 673     if ( !root )
 674         return S_FALSE;
 675
 676     element_node = create_node( root );
 677     if(!element_node) return S_FALSE;
 678
 679     hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (LPVOID*)DOMElement);
 680     IXMLDOMNode_Release(element_node);
 681
 682     return hr;
 683 }
 684
 685
 686 static HRESULT WINAPI domdoc_documentElement(
 687     IXMLDOMDocument *iface,
 688     IXMLDOMElement* DOMElement )
 689 {
 690     FIXME("\n");
 691     return E_NOTIMPL;
 692 }
 693
 694
 695 static HRESULT WINAPI domdoc_createElement(
 696     IXMLDOMDocument *iface,
 697     BSTR tagname,
 698     IXMLDOMElement** element )
 699 {
 700     xmlNodePtr xmlnode;
 701     domdoc *This = impl_from_IXMLDOMDocument( iface );
 702     xmlChar *xml_name;
 703     IUnknown *elem_unk;
 704     HRESULT hr;
 705
 706     TRACE("%p->(%s,%p)\n", iface, debugstr_w(tagname), element);
 707
 708     xml_name = xmlChar_from_wchar((WCHAR*)tagname);
 709     xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
 710
 711     TRACE("created xmlptr %p\n", xmlnode);
 712     elem_unk = create_element(xmlnode, NULL);
 713     HeapFree(GetProcessHeap(), 0, xml_name);
 714
 715     hr = IUnknown_QueryInterface(elem_unk, &IID_IXMLDOMElement, (void **)element);
 716     IUnknown_Release(elem_unk);
 717     TRACE("returning %p\n", *element);
 718     return hr;
 719 }
 720
 721
 722 static HRESULT WINAPI domdoc_createDocumentFragment(
 723     IXMLDOMDocument *iface,
 724     IXMLDOMDocumentFragment** docFrag )
 725 {
 726     FIXME("\n");
 727     return E_NOTIMPL;
 728 }
 729
 730
 731 static HRESULT WINAPI domdoc_createTextNode(
 732     IXMLDOMDocument *iface,
 733     BSTR data,
 734     IXMLDOMText** text )
 735 {
 736     FIXME("\n");
 737     return E_NOTIMPL;
 738 }
 739
 740
 741 static HRESULT WINAPI domdoc_createComment(
 742     IXMLDOMDocument *iface,
 743     BSTR data,
 744     IXMLDOMComment** comment )
 745 {
 746     FIXME("\n");
 747     return E_NOTIMPL;
 748 }
 749
 750
 751 static HRESULT WINAPI domdoc_createCDATASection(
 752     IXMLDOMDocument *iface,
 753     BSTR data,
 754     IXMLDOMCDATASection** cdata )
 755 {
 756     FIXME("\n");
 757     return E_NOTIMPL;
 758 }
 759
 760
 761 static HRESULT WINAPI domdoc_createProcessingInstruction(
 762     IXMLDOMDocument *iface,
 763     BSTR target,
 764     BSTR data,
 765     IXMLDOMProcessingInstruction** pi )
 766 {
 767 #ifdef HAVE_XMLNEWDOCPI
 768     xmlNodePtr xmlnode;
 769     domdoc *This = impl_from_IXMLDOMDocument( iface );
 770     xmlChar *xml_target, *xml_content;
 771
 772     TRACE("%p->(%s %s %p)\n", iface, debugstr_w(target), debugstr_w(data), pi);
 773
 774     xml_target = xmlChar_from_wchar((WCHAR*)target);
 775     xml_content = xmlChar_from_wchar((WCHAR*)data);
 776
 777     xmlnode = xmlNewDocPI(get_doc(This), xml_target, xml_content);
 778     TRACE("created xmlptr %p\n", xmlnode);
 779     *pi = (IXMLDOMProcessingInstruction*)create_pi(xmlnode);
 780
 781     HeapFree(GetProcessHeap(), 0, xml_content);
 782     HeapFree(GetProcessHeap(), 0, xml_target);
 783
 784     return S_OK;
 785 #else
 786     FIXME("Libxml 2.6.15 or greater required.\n");
 787     return E_NOTIMPL;
 788 #endif
 789 }
 790
 791
 792 static HRESULT WINAPI domdoc_createAttribute(
 793     IXMLDOMDocument *iface,
 794     BSTR name,
 795     IXMLDOMAttribute** attribute )
 796 {
 797     FIXME("\n");
 798     return E_NOTIMPL;
 799 }
 800
 801
 802 static HRESULT WINAPI domdoc_createEntityReference(
 803     IXMLDOMDocument *iface,
 804     BSTR name,
 805     IXMLDOMEntityReference** entityRef )
 806 {
 807     FIXME("\n");
 808     return E_NOTIMPL;
 809 }
 810
 811
 812 static HRESULT WINAPI domdoc_getElementsByTagName(
 813     IXMLDOMDocument *iface,
 814     BSTR tagName,
 815     IXMLDOMNodeList** resultList )
 816 {
 817     domdoc *This = impl_from_IXMLDOMDocument( iface );
 818     xmlChar *name;
 819     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
 820
 821     name = xmlChar_from_wchar((WCHAR*)tagName);
 822     *resultList = create_filtered_nodelist((xmlNodePtr)get_doc(This), name, TRUE);
 823     HeapFree(GetProcessHeap(), 0, name);
 824
 825     if(!*resultList) return S_FALSE;
 826     return S_OK;
 827 }
 828
 829 static DOMNodeType get_node_type(VARIANT Type)
 830 {
 831     if(V_VT(&Type) == VT_I4)
 832         return V_I4(&Type);
 833
 834     FIXME("Unsupported variant type %x\n", V_VT(&Type));
 835     return 0;
 836 }
 837
 838 static HRESULT WINAPI domdoc_createNode(
 839     IXMLDOMDocument *iface,
 840     VARIANT Type,
 841     BSTR name,
 842     BSTR namespaceURI,
 843     IXMLDOMNode** node )
 844 {
 845     domdoc *This = impl_from_IXMLDOMDocument( iface );
 846     DOMNodeType node_type;
 847     xmlNodePtr xmlnode = NULL;
 848     xmlChar *xml_name;
 849
 850     TRACE("(%p)->(type,%s,%s,%p)\n", This, debugstr_w(name), debugstr_w(namespaceURI), node);
 851
 852     node_type = get_node_type(Type);
 853     TRACE("node_type %d\n", node_type);
 854
 855     xml_name = xmlChar_from_wchar((WCHAR*)name);
 856
 857     switch(node_type)
 858     {
 859     case NODE_ELEMENT:
 860         xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
 861         *node = create_node(xmlnode);
 862         TRACE("created %p\n", xmlnode);
 863         break;
 864
 865     default:
 866         FIXME("unhandled node type %d\n", node_type);
 867         break;
 868     }
 869
 870     HeapFree(GetProcessHeap(), 0, xml_name);
 871
 872     if(xmlnode && *node)
 873         return S_OK;
 874
 875     return E_FAIL;
 876 }
 877
 878 static HRESULT WINAPI domdoc_nodeFromID(
 879     IXMLDOMDocument *iface,
 880     BSTR idString,
 881     IXMLDOMNode** node )
 882 {
 883     FIXME("\n");
 884     return E_NOTIMPL;
 885 }
 886
 887 static xmlDocPtr doparse( char *ptr, int len )
 888 {
 889 #ifdef HAVE_XMLREADMEMORY
 890     /*
 891      * use xmlReadMemory if possible so we can suppress
 892      * writing errors to stderr
 893      */
 894     return xmlReadMemory( ptr, len, NULL, NULL,
 895                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS );
 896 #else
 897     return xmlParseMemory( ptr, len );
 898 #endif
 899 }
 900
 901 static xmlDocPtr doread( LPWSTR filename )
 902 {
 903     xmlDocPtr xmldoc = NULL;
 904     HRESULT hr;
 905     IBindCtx *pbc;
 906     IStream *stream, *memstream;
 907     WCHAR url[INTERNET_MAX_URL_LENGTH];
 908     BYTE buf[4096];
 909     DWORD read, written;
 910
 911     TRACE("%s\n", debugstr_w( filename ));
 912
 913     if(!PathIsURLW(filename))
 914     {
 915         WCHAR fullpath[MAX_PATH];
 916         DWORD needed = sizeof(url)/sizeof(WCHAR);
 917
 918         if(!PathSearchAndQualifyW(filename, fullpath, sizeof(fullpath)/sizeof(WCHAR)))
 919         {
 920             WARN("can't find path\n");
 921             return NULL;
 922         }
 923
 924         if(FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
 925         {
 926             ERR("can't create url from path\n");
 927             return NULL;
 928         }
 929         filename = url;
 930     }
 931
 932     hr = CreateBindCtx(0, &pbc);
 933     if(SUCCEEDED(hr))
 934     {
 935         hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&domdoc_bsc.lpVtbl, NULL, 0);
 936         if(SUCCEEDED(hr))
 937         {
 938             IMoniker *moniker;
 939             hr = CreateURLMoniker(NULL, filename, &moniker);
 940             if(SUCCEEDED(hr))
 941             {
 942                 hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
 943                 IMoniker_Release(moniker);
 944             }
 945         }
 946         IBindCtx_Release(pbc);
 947     }
 948     if(FAILED(hr))
 949         return NULL;
 950
 951     hr = CreateStreamOnHGlobal(NULL, TRUE, &memstream);
 952     if(FAILED(hr))
 953     {
 954         IStream_Release(stream);
 955         return NULL;
 956     }
 957
 958     do
 959     {
 960         IStream_Read(stream, buf, sizeof(buf), &read);
 961         hr = IStream_Write(memstream, buf, read, &written);
 962     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 963
 964     if(SUCCEEDED(hr))
 965     {
 966         HGLOBAL hglobal;
 967         hr = GetHGlobalFromStream(memstream, &hglobal);
 968         if(SUCCEEDED(hr))
 969         {
 970             DWORD len = GlobalSize(hglobal);
 971             char *ptr = GlobalLock(hglobal);
 972             if(len != 0)
 973                 xmldoc = doparse( ptr, len );
 974             GlobalUnlock(hglobal);
 975         }
 976     }
 977     IStream_Release(memstream);
 978     IStream_Release(stream);
 979     return xmldoc;
 980 }
 981
 982 static HRESULT WINAPI domdoc_load(
 983     IXMLDOMDocument *iface,
 984     VARIANT xmlSource,
 985     VARIANT_BOOL* isSuccessful )
 986 {
 987     domdoc *This = impl_from_IXMLDOMDocument( iface );
 988     LPWSTR filename = NULL;
 989     xmlDocPtr xmldoc = NULL;
 990     HRESULT hr = S_FALSE;
 991
 992     TRACE("type %d\n", V_VT(&xmlSource) );
 993
 994     *isSuccessful = VARIANT_FALSE;
 995
 996     assert( This->node );
 997
 998     attach_xmlnode(This->node, NULL);
 999
1000     switch( V_VT(&xmlSource) )
1001     {
1002     case VT_BSTR:
1003         filename = V_BSTR(&xmlSource);
1004     }
1005
1006     if ( filename )
1007     {
1008         xmldoc = doread( filename );
1009
1010         if ( !xmldoc )
1011             This->error = E_FAIL;
1012         else
1013         {
1014             hr = This->error = S_OK;
1015             *isSuccessful = VARIANT_TRUE;
1016         }
1017     }
1018
1019     if(!xmldoc)
1020         xmldoc = xmlNewDoc(NULL);
1021
1022     xmldoc->_private = 0;
1023     attach_xmlnode(This->node, (xmlNodePtr) xmldoc);
1024
1025     return hr;
1026 }
1027
1028
1029 static HRESULT WINAPI domdoc_get_readyState(
1030     IXMLDOMDocument *iface,
1031     long* value )
1032 {
1033     FIXME("\n");
1034     return E_NOTIMPL;
1035 }
1036
1037
1038 static HRESULT WINAPI domdoc_get_parseError(
1039     IXMLDOMDocument *iface,
1040     IXMLDOMParseError** errorObj )
1041 {
1042     BSTR error_string = NULL;
1043     static const WCHAR err[] = {'e','r','r','o','r',0};
1044     domdoc *This = impl_from_IXMLDOMDocument( iface );
1045
1046     FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
1047
1048     if(This->error)
1049         error_string = SysAllocString(err);
1050
1051     *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
1052     if(!*errorObj) return E_OUTOFMEMORY;
1053     return S_OK;
1054 }
1055
1056
1057 static HRESULT WINAPI domdoc_get_url(
1058     IXMLDOMDocument *iface,
1059     BSTR* urlString )
1060 {
1061     FIXME("\n");
1062     return E_NOTIMPL;
1063 }
1064
1065
1066 static HRESULT WINAPI domdoc_get_async(
1067     IXMLDOMDocument *iface,
1068     VARIANT_BOOL* isAsync )
1069 {
1070     domdoc *This = impl_from_IXMLDOMDocument( iface );
1071
1072     TRACE("%p <- %d\n", isAsync, This->async);
1073     *isAsync = This->async;
1074     return S_OK;
1075 }
1076
1077
1078 static HRESULT WINAPI domdoc_put_async(
1079     IXMLDOMDocument *iface,
1080     VARIANT_BOOL isAsync )
1081 {
1082     domdoc *This = impl_from_IXMLDOMDocument( iface );
1083
1084     TRACE("%d\n", isAsync);
1085     This->async = isAsync;
1086     return S_OK;
1087 }
1088
1089
1090 static HRESULT WINAPI domdoc_abort(
1091     IXMLDOMDocument *iface )
1092 {
1093     FIXME("\n");
1094     return E_NOTIMPL;
1095 }
1096
1097
1098 static BOOL bstr_to_utf8( BSTR bstr, char **pstr, int *plen )
1099 {
1100     UINT len, blen = SysStringLen( bstr );
1101     LPSTR str;
1102
1103     len = WideCharToMultiByte( CP_UTF8, 0, bstr, blen, NULL, 0, NULL, NULL );
1104     str = HeapAlloc( GetProcessHeap(), 0, len );
1105     if ( !str )
1106         return FALSE;
1107     WideCharToMultiByte( CP_UTF8, 0, bstr, blen, str, len, NULL, NULL );
1108     *plen = len;
1109     *pstr = str;
1110     return TRUE;
1111 }
1112
1113 static HRESULT WINAPI domdoc_loadXML(
1114     IXMLDOMDocument *iface,
1115     BSTR bstrXML,
1116     VARIANT_BOOL* isSuccessful )
1117 {
1118     domdoc *This = impl_from_IXMLDOMDocument( iface );
1119     xmlDocPtr xmldoc = NULL;
1120     char *str;
1121     int len;
1122     HRESULT hr = S_FALSE;
1123
1124     TRACE("%p %s %p\n", This, debugstr_w( bstrXML ), isSuccessful );
1125
1126     assert ( This->node );
1127
1128     attach_xmlnode( This->node, NULL );
1129
1130     if ( isSuccessful )
1131     {
1132         *isSuccessful = VARIANT_FALSE;
1133
1134         if ( bstrXML  && bstr_to_utf8( bstrXML, &str, &len ) )
1135         {
1136             xmldoc = doparse( str, len );
1137             HeapFree( GetProcessHeap(), 0, str );
1138             if ( !xmldoc )
1139                 This->error = E_FAIL;
1140             else
1141             {
1142                 hr = This->error = S_OK;
1143                 *isSuccessful = VARIANT_TRUE;
1144             }
1145         }
1146     }
1147     if(!xmldoc)
1148         xmldoc = xmlNewDoc(NULL);
1149
1150     xmldoc->_private = 0;
1151     attach_xmlnode( This->node, (xmlNodePtr) xmldoc );
1152
1153     return hr;
1154 }
1155
1156
1157 static HRESULT WINAPI domdoc_save(
1158     IXMLDOMDocument *iface,
1159     VARIANT destination )
1160 {
1161     domdoc *This = impl_from_IXMLDOMDocument( iface );
1162     HANDLE handle;
1163     xmlChar *mem;
1164     int size;
1165     HRESULT ret = S_OK;
1166     DWORD written;
1167
1168     TRACE("(%p)->(var(vt %x, %s))\n", This, V_VT(&destination),
1169           V_VT(&destination) == VT_BSTR ? debugstr_w(V_BSTR(&destination)) : NULL);
1170
1171     if(V_VT(&destination) != VT_BSTR)
1172     {
1173         FIXME("Unhandled vt %x\n", V_VT(&destination));
1174         return S_FALSE;
1175     }
1176
1177     handle = CreateFileW( V_BSTR(&destination), GENERIC_WRITE, 0,
1178                           NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1179     if( handle == INVALID_HANDLE_VALUE )
1180     {
1181         WARN("failed to create file\n");
1182         return S_FALSE;
1183     }
1184
1185     xmlDocDumpMemory(get_doc(This), &mem, &size);
1186     if(!WriteFile(handle, mem, (DWORD)size, &written, NULL) || written != (DWORD)size)
1187     {
1188         WARN("write error\n");
1189         ret = S_FALSE;
1190     }
1191
1192     xmlFree(mem);
1193     CloseHandle(handle);
1194     return ret;
1195 }
1196
1197 static HRESULT WINAPI domdoc_get_validateOnParse(
1198     IXMLDOMDocument *iface,
1199     VARIANT_BOOL* isValidating )
1200 {
1201     domdoc *This = impl_from_IXMLDOMDocument( iface );
1202
1203     TRACE("%p <- %d\n", isValidating, This->validating);
1204     *isValidating = This->validating;
1205     return S_OK;
1206 }
1207
1208
1209 static HRESULT WINAPI domdoc_put_validateOnParse(
1210     IXMLDOMDocument *iface,
1211     VARIANT_BOOL isValidating )
1212 {
1213     domdoc *This = impl_from_IXMLDOMDocument( iface );
1214
1215     TRACE("%d\n", isValidating);
1216     This->validating = isValidating;
1217     return S_OK;
1218 }
1219
1220
1221 static HRESULT WINAPI domdoc_get_resolveExternals(
1222     IXMLDOMDocument *iface,
1223     VARIANT_BOOL* isResolving )
1224 {
1225     domdoc *This = impl_from_IXMLDOMDocument( iface );
1226
1227     TRACE("%p <- %d\n", isResolving, This->resolving);
1228     *isResolving = This->resolving;
1229     return S_OK;
1230 }
1231
1232
1233 static HRESULT WINAPI domdoc_put_resolveExternals(
1234     IXMLDOMDocument *iface,
1235     VARIANT_BOOL isResolving )
1236 {
1237     domdoc *This = impl_from_IXMLDOMDocument( iface );
1238
1239     TRACE("%d\n", isResolving);
1240     This->resolving = isResolving;
1241     return S_OK;
1242 }
1243
1244
1245 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
1246     IXMLDOMDocument *iface,
1247     VARIANT_BOOL* isPreserving )
1248 {
1249     domdoc *This = impl_from_IXMLDOMDocument( iface );
1250
1251     TRACE("%p <- %d\n", isPreserving, This->preserving);
1252     *isPreserving = This->preserving;
1253     return S_OK;
1254 }
1255
1256
1257 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
1258     IXMLDOMDocument *iface,
1259     VARIANT_BOOL isPreserving )
1260 {
1261     domdoc *This = impl_from_IXMLDOMDocument( iface );
1262
1263     TRACE("%d\n", isPreserving);
1264     This->preserving = isPreserving;
1265     return S_OK;
1266 }
1267
1268
1269 static HRESULT WINAPI domdoc_put_onReadyStateChange(
1270     IXMLDOMDocument *iface,
1271     VARIANT readyStateChangeSink )
1272 {
1273     FIXME("\n");
1274     return E_NOTIMPL;
1275 }
1276
1277
1278 static HRESULT WINAPI domdoc_put_onDataAvailable(
1279     IXMLDOMDocument *iface,
1280     VARIANT onDataAvailableSink )
1281 {
1282     FIXME("\n");
1283     return E_NOTIMPL;
1284 }
1285
1286 static HRESULT WINAPI domdoc_put_onTransformNode(
1287     IXMLDOMDocument *iface,
1288     VARIANT onTransformNodeSink )
1289 {
1290     FIXME("\n");
1291     return E_NOTIMPL;
1292 }
1293
1294 static const struct IXMLDOMDocumentVtbl domdoc_vtbl =
1295 {
1296     domdoc_QueryInterface,
1297     domdoc_AddRef,
1298     domdoc_Release,
1299     domdoc_GetTypeInfoCount,
1300     domdoc_GetTypeInfo,
1301     domdoc_GetIDsOfNames,
1302     domdoc_Invoke,
1303     domdoc_get_nodeName,
1304     domdoc_get_nodeValue,
1305     domdoc_put_nodeValue,
1306     domdoc_get_nodeType,
1307     domdoc_get_parentNode,
1308     domdoc_get_childNodes,
1309     domdoc_get_firstChild,
1310     domdoc_get_lastChild,
1311     domdoc_get_previousSibling,
1312     domdoc_get_nextSibling,
1313     domdoc_get_attributes,
1314     domdoc_insertBefore,
1315     domdoc_replaceChild,
1316     domdoc_removeChild,
1317     domdoc_appendChild,
1318     domdoc_hasChildNodes,
1319     domdoc_get_ownerDocument,
1320     domdoc_cloneNode,
1321     domdoc_get_nodeTypeString,
1322     domdoc_get_text,
1323     domdoc_put_text,
1324     domdoc_get_specified,
1325     domdoc_get_definition,
1326     domdoc_get_nodeTypedValue,
1327     domdoc_put_nodeTypedValue,
1328     domdoc_get_dataType,
1329     domdoc_put_dataType,
1330     domdoc_get_xml,
1331     domdoc_transformNode,
1332     domdoc_selectNodes,
1333     domdoc_selectSingleNode,
1334     domdoc_get_parsed,
1335     domdoc_get_namespaceURI,
1336     domdoc_get_prefix,
1337     domdoc_get_baseName,
1338     domdoc_transformNodeToObject,
1339     domdoc_get_doctype,
1340     domdoc_get_implementation,
1341     domdoc_get_documentElement,
1342     domdoc_documentElement,
1343     domdoc_createElement,
1344     domdoc_createDocumentFragment,
1345     domdoc_createTextNode,
1346     domdoc_createComment,
1347     domdoc_createCDATASection,
1348     domdoc_createProcessingInstruction,
1349     domdoc_createAttribute,
1350     domdoc_createEntityReference,
1351     domdoc_getElementsByTagName,
1352     domdoc_createNode,
1353     domdoc_nodeFromID,
1354     domdoc_load,
1355     domdoc_get_readyState,
1356     domdoc_get_parseError,
1357     domdoc_get_url,
1358     domdoc_get_async,
1359     domdoc_put_async,
1360     domdoc_abort,
1361     domdoc_loadXML,
1362     domdoc_save,
1363     domdoc_get_validateOnParse,
1364     domdoc_put_validateOnParse,
1365     domdoc_get_resolveExternals,
1366     domdoc_put_resolveExternals,
1367     domdoc_get_preserveWhiteSpace,
1368     domdoc_put_preserveWhiteSpace,
1369     domdoc_put_onReadyStateChange,
1370     domdoc_put_onDataAvailable,
1371     domdoc_put_onTransformNode,
1372 };
1373
1374 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1375 {
1376     domdoc *doc;
1377     HRESULT hr;
1378     xmlDocPtr xmldoc;
1379
1380     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1381
1382     doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) );
1383     if( !doc )
1384         return E_OUTOFMEMORY;
1385
1386     doc->lpVtbl = &domdoc_vtbl;
1387     doc->ref = 1;
1388     doc->async = 0;
1389     doc->validating = 0;
1390     doc->resolving = 0;
1391     doc->preserving = 0;
1392     doc->error = S_OK;
1393
1394     xmldoc = xmlNewDoc(NULL);
1395     if(!xmldoc)
1396     {
1397         HeapFree(GetProcessHeap(), 0, doc);
1398         return E_OUTOFMEMORY;
1399     }
1400
1401     xmldoc->_private = 0;
1402
1403     doc->node_unk = create_basic_node( (xmlNodePtr)xmldoc, (IUnknown*)&doc->lpVtbl );
1404     if(!doc->node_unk)
1405     {
1406         xmlFreeDoc(xmldoc);
1407         HeapFree(GetProcessHeap(), 0, doc);
1408         return E_FAIL;
1409     }
1410
1411     hr = IUnknown_QueryInterface(doc->node_unk, &IID_IXMLDOMNode, (LPVOID*)&doc->node);
1412     if(FAILED(hr))
1413     {
1414         IUnknown_Release(doc->node_unk);
1415         HeapFree( GetProcessHeap(), 0, doc );
1416         return E_FAIL;
1417     }
1418     /* The ref on doc->node is actually looped back into this object, so release it */
1419     IXMLDOMNode_Release(doc->node);
1420
1421     *ppObj = &doc->lpVtbl;
1422
1423     TRACE("returning iface %p\n", *ppObj);
1424     return S_OK;
1425 }
1426
1427 #else
1428
1429 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1430 {
1431     MESSAGE("This program tried to use a DOMDocument object, but\n"
1432             "libxml2 support was not present at compile time.\n");
1433     return E_NOTIMPL;
1434 }
1435
1436 #endif