reactos/dll/win32/msxml3/node.c

   1 /*
   2  *    Node 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 #include "precomp.h"
  22
  23 #ifdef HAVE_LIBXML2
  24 # include <libxml/HTMLtree.h>
  25 # ifdef SONAME_LIBXSLT
  26 #  ifdef HAVE_LIBXSLT_PATTERN_H
  27 #   include <libxslt/pattern.h>
  28 #  endif
  29 #  ifdef HAVE_LIBXSLT_TRANSFORM_H
  30 #   include <libxslt/transform.h>
  31 #  endif
  32 #  include <libxslt/imports.h>
  33 #  include <libxslt/variables.h>
  34 #  include <libxslt/xsltutils.h>
  35 #  include <libxslt/xsltInternals.h>
  36 # endif
  37 #endif
  38
  39 #ifdef HAVE_LIBXML2
  40
  41 #ifdef SONAME_LIBXSLT
  42 extern void* libxslt_handle;
  43 # define MAKE_FUNCPTR(f) extern typeof(f) * p##f
  44 MAKE_FUNCPTR(xsltApplyStylesheet);
  45 MAKE_FUNCPTR(xsltApplyStylesheetUser);
  46 MAKE_FUNCPTR(xsltCleanupGlobals);
  47 MAKE_FUNCPTR(xsltFreeStylesheet);
  48 MAKE_FUNCPTR(xsltFreeTransformContext);
  49 MAKE_FUNCPTR(xsltNewTransformContext);
  50 MAKE_FUNCPTR(xsltNextImport);
  51 MAKE_FUNCPTR(xsltParseStylesheetDoc);
  52 MAKE_FUNCPTR(xsltQuoteUserParams);
  53 MAKE_FUNCPTR(xsltSaveResultTo);
  54 # undef MAKE_FUNCPTR
  55 #else
  56 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  57 #endif
  58
  59 static const IID IID_xmlnode = {0x4f2f4ba2,0xb822,0x11df,{0x8b,0x8a,0x68,0x50,0xdf,0xd7,0x20,0x85}};
  60
  61 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  62 {
  63     xmlnode *This;
  64
  65     if ( !iface )
  66         return NULL;
  67     This = get_node_obj( iface );
  68     if ( !This || !This->node )
  69         return NULL;
  70     if ( type && This->node->type != type )
  71         return NULL;
  72     return This->node;
  73 }
  74
  75 BOOL node_query_interface(xmlnode *This, REFIID riid, void **ppv)
  76 {
  77     if(IsEqualGUID(&IID_xmlnode, riid)) {
  78         TRACE("(%p)->(IID_xmlnode %p)\n", This, ppv);
  79         *ppv = This;
  80         return TRUE;
  81     }
  82
  83     return dispex_query_interface(&This->dispex, riid, ppv);
  84 }
  85
  86 /* common ISupportErrorInfo implementation */
  87 typedef struct {
  88    ISupportErrorInfo ISupportErrorInfo_iface;
  89    LONG ref;
  90
  91    const tid_t* iids;
  92 } SupportErrorInfo;
  93
  94 static inline SupportErrorInfo *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
  95 {
  96     return CONTAINING_RECORD(iface, SupportErrorInfo, ISupportErrorInfo_iface);
  97 }
  98
  99 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **obj)
 100 {
 101     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 102     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 103
 104     *obj = NULL;
 105
 106     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISupportErrorInfo)) {
 107         *obj = iface;
 108         ISupportErrorInfo_AddRef(iface);
 109         return S_OK;
 110     }
 111
 112     return E_NOINTERFACE;
 113 }
 114
 115 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
 116 {
 117     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 118     ULONG ref = InterlockedIncrement(&This->ref);
 119     TRACE("(%p)->(%d)\n", This, ref );
 120     return ref;
 121 }
 122
 123 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
 124 {
 125     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 126     LONG ref = InterlockedDecrement(&This->ref);
 127
 128     TRACE("(%p)->(%d)\n", This, ref);
 129
 130     if (ref == 0)
 131         heap_free(This);
 132
 133     return ref;
 134 }
 135
 136 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
 137 {
 138     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 139     enum tid_t const *tid;
 140
 141     TRACE("(%p)->(%s)\n", This, debugstr_guid(riid));
 142
 143     tid = This->iids;
 144     while (*tid != NULL_tid)
 145     {
 146         if (IsEqualGUID(riid, get_riid_from_tid(*tid)))
 147             return S_OK;
 148         tid++;
 149     }
 150
 151     return S_FALSE;
 152 }
 153
 154 static const struct ISupportErrorInfoVtbl SupportErrorInfoVtbl = {
 155     SupportErrorInfo_QueryInterface,
 156     SupportErrorInfo_AddRef,
 157     SupportErrorInfo_Release,
 158     SupportErrorInfo_InterfaceSupportsErrorInfo
 159 };
 160
 161 HRESULT node_create_supporterrorinfo(enum tid_t const *iids, void **obj)
 162 {
 163     SupportErrorInfo *This;
 164
 165     This = heap_alloc(sizeof(*This));
 166     if (!This) return E_OUTOFMEMORY;
 167
 168     This->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
 169     This->ref = 1;
 170     This->iids = iids;
 171
 172     *obj = &This->ISupportErrorInfo_iface;
 173
 174     return S_OK;
 175 }
 176
 177 xmlnode *get_node_obj(IXMLDOMNode *node)
 178 {
 179     xmlnode *obj = NULL;
 180     HRESULT hres;
 181
 182     hres = IXMLDOMNode_QueryInterface(node, &IID_xmlnode, (void**)&obj);
 183     if (!obj) WARN("node is not our IXMLDOMNode implementation\n");
 184     return SUCCEEDED(hres) ? obj : NULL;
 185 }
 186
 187 HRESULT node_get_nodeName(xmlnode *This, BSTR *name)
 188 {
 189     BSTR prefix, base;
 190     HRESULT hr;
 191
 192     if (!name)
 193         return E_INVALIDARG;
 194
 195     hr = node_get_base_name(This, &base);
 196     if (hr != S_OK) return hr;
 197
 198     hr = node_get_prefix(This, &prefix);
 199     if (hr == S_OK)
 200     {
 201         static const WCHAR colW = ':';
 202         WCHAR *ptr;
 203
 204         /* +1 for ':' */
 205         ptr = *name = SysAllocStringLen(NULL, SysStringLen(base) + SysStringLen(prefix) + 1);
 206         memcpy(ptr, prefix, SysStringByteLen(prefix));
 207         ptr += SysStringLen(prefix);
 208         memcpy(ptr++, &colW, sizeof(WCHAR));
 209         memcpy(ptr, base, SysStringByteLen(base));
 210
 211         SysFreeString(base);
 212         SysFreeString(prefix);
 213     }
 214     else
 215         *name = base;
 216
 217     return S_OK;
 218 }
 219
 220 HRESULT node_get_content(xmlnode *This, VARIANT *value)
 221 {
 222     xmlChar *content;
 223
 224     if(!value)
 225         return E_INVALIDARG;
 226
 227     content = xmlNodeGetContent(This->node);
 228     V_VT(value) = VT_BSTR;
 229     V_BSTR(value) = bstr_from_xmlChar( content );
 230     xmlFree(content);
 231
 232     TRACE("%p returned %s\n", This, debugstr_w(V_BSTR(value)));
 233     return S_OK;
 234 }
 235
 236 HRESULT node_set_content(xmlnode *This, LPCWSTR value)
 237 {
 238     xmlChar *str;
 239
 240     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 241     str = xmlchar_from_wchar(value);
 242     if(!str)
 243         return E_OUTOFMEMORY;
 244
 245     xmlNodeSetContent(This->node, str);
 246     heap_free(str);
 247     return S_OK;
 248 }
 249
 250 static HRESULT node_set_content_escaped(xmlnode *This, LPCWSTR value)
 251 {
 252     xmlChar *str, *escaped;
 253
 254     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 255     str = xmlchar_from_wchar(value);
 256     if(!str)
 257         return E_OUTOFMEMORY;
 258
 259     escaped = xmlEncodeSpecialChars(NULL, str);
 260     if(!escaped)
 261     {
 262         heap_free(str);
 263         return E_OUTOFMEMORY;
 264     }
 265
 266     xmlNodeSetContent(This->node, escaped);
 267
 268     heap_free(str);
 269     xmlFree(escaped);
 270
 271     return S_OK;
 272 }
 273
 274 HRESULT node_put_value(xmlnode *This, VARIANT *value)
 275 {
 276     HRESULT hr;
 277
 278     if (V_VT(value) != VT_BSTR)
 279     {
 280         VARIANT string_value;
 281
 282         VariantInit(&string_value);
 283         hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 284         if(FAILED(hr)) {
 285             WARN("Couldn't convert to VT_BSTR\n");
 286             return hr;
 287         }
 288
 289         hr = node_set_content(This, V_BSTR(&string_value));
 290         VariantClear(&string_value);
 291     }
 292     else
 293         hr = node_set_content(This, V_BSTR(value));
 294
 295     return hr;
 296 }
 297
 298 HRESULT node_put_value_escaped(xmlnode *This, VARIANT *value)
 299 {
 300     HRESULT hr;
 301
 302     if (V_VT(value) != VT_BSTR)
 303     {
 304        VARIANT string_value;
 305
 306         VariantInit(&string_value);
 307         hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 308         if(FAILED(hr)) {
 309             WARN("Couldn't convert to VT_BSTR\n");
 310             return hr;
 311         }
 312
 313         hr = node_set_content_escaped(This, V_BSTR(&string_value));
 314         VariantClear(&string_value);
 315     }
 316     else
 317         hr = node_set_content_escaped(This, V_BSTR(value));
 318
 319     return hr;
 320 }
 321
 322 static HRESULT get_node(
 323     xmlnode *This,
 324     const char *name,
 325     xmlNodePtr node,
 326     IXMLDOMNode **out )
 327 {
 328     TRACE("(%p)->(%s %p %p)\n", This, name, node, out );
 329
 330     if ( !out )
 331         return E_INVALIDARG;
 332
 333     /* if we don't have a doc, use our parent. */
 334     if(node && !node->doc && node->parent)
 335         node->doc = node->parent->doc;
 336
 337     *out = create_node( node );
 338     if (!*out)
 339         return S_FALSE;
 340     return S_OK;
 341 }
 342
 343 HRESULT node_get_parent(xmlnode *This, IXMLDOMNode **parent)
 344 {
 345     return get_node( This, "parent", This->node->parent, parent );
 346 }
 347
 348 HRESULT node_get_child_nodes(xmlnode *This, IXMLDOMNodeList **ret)
 349 {
 350     if(!ret)
 351         return E_INVALIDARG;
 352
 353     *ret = create_children_nodelist(This->node);
 354     if(!*ret)
 355         return E_OUTOFMEMORY;
 356
 357     return S_OK;
 358 }
 359
 360 HRESULT node_get_first_child(xmlnode *This, IXMLDOMNode **ret)
 361 {
 362     return get_node(This, "firstChild", This->node->children, ret);
 363 }
 364
 365 HRESULT node_get_last_child(xmlnode *This, IXMLDOMNode **ret)
 366 {
 367     return get_node(This, "lastChild", This->node->last, ret);
 368 }
 369
 370 HRESULT node_get_previous_sibling(xmlnode *This, IXMLDOMNode **ret)
 371 {
 372     return get_node(This, "previous", This->node->prev, ret);
 373 }
 374
 375 HRESULT node_get_next_sibling(xmlnode *This, IXMLDOMNode **ret)
 376 {
 377     return get_node(This, "next", This->node->next, ret);
 378 }
 379
 380 static int node_get_inst_cnt(xmlNodePtr node)
 381 {
 382     int ret = *(LONG *)&node->_private;
 383     xmlNodePtr child;
 384
 385     /* add attribute counts */
 386     if (node->type == XML_ELEMENT_NODE)
 387     {
 388         xmlAttrPtr prop = node->properties;
 389
 390         while (prop)
 391         {
 392             ret += node_get_inst_cnt((xmlNodePtr)prop);
 393             prop = prop->next;
 394         }
 395     }
 396
 397     /* add children counts */
 398     child = node->children;
 399     while (child)
 400     {
 401         ret += node_get_inst_cnt(child);
 402         child = child->next;
 403     }
 404
 405     return ret;
 406 }
 407
 408 int xmlnode_get_inst_cnt(xmlnode *node)
 409 {
 410     return node_get_inst_cnt(node->node);
 411 }
 412
 413 HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
 414         IXMLDOMNode **ret)
 415 {
 416     IXMLDOMNode *before = NULL;
 417     xmlnode *node_obj;
 418     int refcount = 0;
 419     xmlDocPtr doc;
 420     HRESULT hr;
 421
 422     if(!new_child)
 423         return E_INVALIDARG;
 424
 425     node_obj = get_node_obj(new_child);
 426     if(!node_obj) return E_FAIL;
 427
 428     switch(V_VT(ref_child))
 429     {
 430     case VT_EMPTY:
 431     case VT_NULL:
 432         break;
 433
 434     case VT_UNKNOWN:
 435     case VT_DISPATCH:
 436         if (V_UNKNOWN(ref_child))
 437         {
 438             hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (void**)&before);
 439             if(FAILED(hr)) return hr;
 440         }
 441         break;
 442
 443     default:
 444         FIXME("refChild var type %x\n", V_VT(ref_child));
 445         return E_FAIL;
 446     }
 447
 448     TRACE("new child %p, This->node %p\n", node_obj->node, This->node);
 449
 450     if(!node_obj->node->parent)
 451         if(xmldoc_remove_orphan(node_obj->node->doc, node_obj->node) != S_OK)
 452             WARN("%p is not an orphan of %p\n", node_obj->node, node_obj->node->doc);
 453
 454     refcount = xmlnode_get_inst_cnt(node_obj);
 455
 456     if(before)
 457     {
 458         xmlnode *before_node_obj = get_node_obj(before);
 459         IXMLDOMNode_Release(before);
 460         if(!before_node_obj) return E_FAIL;
 461     }
 462
 463     /* unlink from current parent first */
 464     if(node_obj->parent)
 465     {
 466         hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
 467         if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
 468     }
 469     doc = node_obj->node->doc;
 470
 471     if(before)
 472     {
 473         xmlnode *before_node_obj = get_node_obj(before);
 474
 475         /* refs count including subtree */
 476         if (doc != before_node_obj->node->doc)
 477             refcount = xmlnode_get_inst_cnt(node_obj);
 478
 479         if (refcount) xmldoc_add_refs(before_node_obj->node->doc, refcount);
 480         xmlAddPrevSibling(before_node_obj->node, node_obj->node);
 481         if (refcount) xmldoc_release_refs(doc, refcount);
 482         node_obj->parent = This->parent;
 483     }
 484     else
 485     {
 486         if (doc != This->node->doc)
 487             refcount = xmlnode_get_inst_cnt(node_obj);
 488
 489         if (refcount) xmldoc_add_refs(This->node->doc, refcount);
 490         /* xmlAddChild doesn't unlink node from previous parent */
 491         xmlUnlinkNode(node_obj->node);
 492         xmlAddChild(This->node, node_obj->node);
 493         if (refcount) xmldoc_release_refs(doc, refcount);
 494         node_obj->parent = This->iface;
 495     }
 496
 497     if(ret)
 498     {
 499         IXMLDOMNode_AddRef(new_child);
 500         *ret = new_child;
 501     }
 502
 503     TRACE("ret S_OK\n");
 504     return S_OK;
 505 }
 506
 507 HRESULT node_replace_child(xmlnode *This, IXMLDOMNode *newChild, IXMLDOMNode *oldChild,
 508         IXMLDOMNode **ret)
 509 {
 510     xmlnode *old_child, *new_child;
 511     xmlDocPtr leaving_doc;
 512     xmlNode *my_ancestor;
 513     int refcount = 0;
 514
 515     /* Do not believe any documentation telling that newChild == NULL
 516        means removal. It does certainly *not* apply to msxml3! */
 517     if(!newChild || !oldChild)
 518         return E_INVALIDARG;
 519
 520     if(ret)
 521         *ret = NULL;
 522
 523     old_child = get_node_obj(oldChild);
 524     if(!old_child) return E_FAIL;
 525
 526     if(old_child->node->parent != This->node)
 527     {
 528         WARN("childNode %p is not a child of %p\n", oldChild, This);
 529         return E_INVALIDARG;
 530     }
 531
 532     new_child = get_node_obj(newChild);
 533     if(!new_child) return E_FAIL;
 534
 535     my_ancestor = This->node;
 536     while(my_ancestor)
 537     {
 538         if(my_ancestor == new_child->node)
 539         {
 540             WARN("tried to create loop\n");
 541             return E_FAIL;
 542         }
 543         my_ancestor = my_ancestor->parent;
 544     }
 545
 546     if(!new_child->node->parent)
 547         if(xmldoc_remove_orphan(new_child->node->doc, new_child->node) != S_OK)
 548             WARN("%p is not an orphan of %p\n", new_child->node, new_child->node->doc);
 549
 550     leaving_doc = new_child->node->doc;
 551
 552     if (leaving_doc != old_child->node->doc)
 553         refcount = xmlnode_get_inst_cnt(new_child);
 554
 555     if (refcount) xmldoc_add_refs(old_child->node->doc, refcount);
 556     xmlReplaceNode(old_child->node, new_child->node);
 557     if (refcount) xmldoc_release_refs(leaving_doc, refcount);
 558     new_child->parent = old_child->parent;
 559     old_child->parent = NULL;
 560
 561     xmldoc_add_orphan(old_child->node->doc, old_child->node);
 562
 563     if(ret)
 564     {
 565         IXMLDOMNode_AddRef(oldChild);
 566         *ret = oldChild;
 567     }
 568
 569     return S_OK;
 570 }
 571
 572 HRESULT node_remove_child(xmlnode *This, IXMLDOMNode* child, IXMLDOMNode** oldChild)
 573 {
 574     xmlnode *child_node;
 575
 576     if(!child) return E_INVALIDARG;
 577
 578     if(oldChild)
 579         *oldChild = NULL;
 580
 581     child_node = get_node_obj(child);
 582     if(!child_node) return E_FAIL;
 583
 584     if(child_node->node->parent != This->node)
 585     {
 586         WARN("childNode %p is not a child of %p\n", child, This);
 587         return E_INVALIDARG;
 588     }
 589
 590     xmlUnlinkNode(child_node->node);
 591     child_node->parent = NULL;
 592     xmldoc_add_orphan(child_node->node->doc, child_node->node);
 593
 594     if(oldChild)
 595     {
 596         IXMLDOMNode_AddRef(child);
 597         *oldChild = child;
 598     }
 599
 600     return S_OK;
 601 }
 602
 603 HRESULT node_append_child(xmlnode *This, IXMLDOMNode *child, IXMLDOMNode **outChild)
 604 {
 605     DOMNodeType type;
 606     VARIANT var;
 607     HRESULT hr;
 608
 609     if (!child)
 610         return E_INVALIDARG;
 611
 612     hr = IXMLDOMNode_get_nodeType(child, &type);
 613     if(FAILED(hr) || type == NODE_ATTRIBUTE) {
 614         if (outChild) *outChild = NULL;
 615         return E_FAIL;
 616     }
 617
 618     VariantInit(&var);
 619     return IXMLDOMNode_insertBefore(This->iface, child, var, outChild);
 620 }
 621
 622 HRESULT node_has_childnodes(const xmlnode *This, VARIANT_BOOL *ret)
 623 {
 624     if (!ret) return E_INVALIDARG;
 625
 626     if (!This->node->children)
 627     {
 628         *ret = VARIANT_FALSE;
 629         return S_FALSE;
 630     }
 631
 632     *ret = VARIANT_TRUE;
 633     return S_OK;
 634 }
 635
 636 HRESULT node_get_owner_doc(const xmlnode *This, IXMLDOMDocument **doc)
 637 {
 638     return get_domdoc_from_xmldoc(This->node->doc, (IXMLDOMDocument3**)doc);
 639 }
 640
 641 HRESULT node_clone(xmlnode *This, VARIANT_BOOL deep, IXMLDOMNode **cloneNode)
 642 {
 643     IXMLDOMNode *node;
 644     xmlNodePtr clone;
 645
 646     if(!cloneNode) return E_INVALIDARG;
 647
 648     clone = xmlCopyNode(This->node, deep ? 1 : 2);
 649     if (clone)
 650     {
 651         xmlSetTreeDoc(clone, This->node->doc);
 652         xmldoc_add_orphan(clone->doc, clone);
 653
 654         node = create_node(clone);
 655         if (!node)
 656         {
 657             ERR("Copy failed\n");
 658             xmldoc_remove_orphan(clone->doc, clone);
 659             xmlFreeNode(clone);
 660             return E_FAIL;
 661         }
 662
 663         *cloneNode = node;
 664     }
 665     else
 666     {
 667         ERR("Copy failed\n");
 668         return E_FAIL;
 669     }
 670
 671     return S_OK;
 672 }
 673
 674 static inline xmlChar* trim_whitespace(xmlChar* str)
 675 {
 676     xmlChar* ret = str;
 677     int len;
 678
 679     if (!str)
 680         return NULL;
 681
 682     while (*ret && isspace(*ret))
 683         ++ret;
 684     len = xmlStrlen(ret);
 685     if (len)
 686         while (isspace(ret[len-1])) --len;
 687
 688     ret = xmlStrndup(ret, len);
 689     xmlFree(str);
 690     return ret;
 691 }
 692
 693 static xmlChar* do_get_text(xmlNodePtr node)
 694 {
 695     xmlNodePtr child;
 696     xmlChar* str;
 697     BOOL preserving = is_preserving_whitespace(node);
 698
 699     if (!node->children)
 700     {
 701         str = xmlNodeGetContent(node);
 702     }
 703     else
 704     {
 705         xmlElementType prev_type = XML_TEXT_NODE;
 706         xmlChar* tmp;
 707         str = xmlStrdup(BAD_CAST "");
 708         for (child = node->children; child != NULL; child = child->next)
 709         {
 710             switch (child->type)
 711             {
 712             case XML_ELEMENT_NODE:
 713                 tmp = do_get_text(child);
 714                 break;
 715             case XML_TEXT_NODE:
 716             case XML_CDATA_SECTION_NODE:
 717             case XML_ENTITY_REF_NODE:
 718             case XML_ENTITY_NODE:
 719                 tmp = xmlNodeGetContent(child);
 720                 break;
 721             default:
 722                 tmp = NULL;
 723                 break;
 724             }
 725
 726             if (tmp)
 727             {
 728                 if (*tmp)
 729                 {
 730                     if (prev_type == XML_ELEMENT_NODE && child->type == XML_ELEMENT_NODE)
 731                         str = xmlStrcat(str, BAD_CAST " ");
 732                     str = xmlStrcat(str, tmp);
 733                     prev_type = child->type;
 734                 }
 735                 xmlFree(tmp);
 736             }
 737         }
 738     }
 739
 740     switch (node->type)
 741     {
 742     case XML_ELEMENT_NODE:
 743     case XML_TEXT_NODE:
 744     case XML_ENTITY_REF_NODE:
 745     case XML_ENTITY_NODE:
 746     case XML_DOCUMENT_NODE:
 747     case XML_DOCUMENT_FRAG_NODE:
 748         if (!preserving)
 749             str = trim_whitespace(str);
 750         break;
 751     default:
 752         break;
 753     }
 754
 755     return str;
 756 }
 757
 758 HRESULT node_get_text(const xmlnode *This, BSTR *text)
 759 {
 760     BSTR str = NULL;
 761     xmlChar *content;
 762
 763     if (!text) return E_INVALIDARG;
 764
 765     content = do_get_text(This->node);
 766     if (content)
 767     {
 768         str = bstr_from_xmlChar(content);
 769         xmlFree(content);
 770     }
 771
 772     /* Always return a string. */
 773     if (!str) str = SysAllocStringLen( NULL, 0 );
 774
 775     TRACE("%p %s\n", This, debugstr_w(str) );
 776     *text = str;
 777
 778     return S_OK;
 779 }
 780
 781 HRESULT node_put_text(xmlnode *This, BSTR text)
 782 {
 783     xmlChar *str, *str2;
 784
 785     TRACE("(%p)->(%s)\n", This, debugstr_w(text));
 786
 787     str = xmlchar_from_wchar(text);
 788
 789     /* Escape the string. */
 790     str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
 791     heap_free(str);
 792
 793     xmlNodeSetContent(This->node, str2);
 794     xmlFree(str2);
 795
 796     return S_OK;
 797 }
 798
 799 BSTR EnsureCorrectEOL(BSTR sInput)
 800 {
 801     int nNum = 0;
 802     BSTR sNew;
 803     int nLen;
 804     int i;
 805
 806     nLen = SysStringLen(sInput);
 807     /* Count line endings */
 808     for(i=0; i < nLen; i++)
 809     {
 810         if(sInput[i] == '\n')
 811             nNum++;
 812     }
 813
 814     TRACE("len=%d, num=%d\n", nLen, nNum);
 815
 816     /* Add linefeed as needed */
 817     if(nNum > 0)
 818     {
 819         int nPlace = 0;
 820         sNew = SysAllocStringLen(NULL, nLen + nNum);
 821         for(i=0; i < nLen; i++)
 822         {
 823             if(sInput[i] == '\n')
 824             {
 825                 sNew[i+nPlace] = '\r';
 826                 nPlace++;
 827             }
 828             sNew[i+nPlace] = sInput[i];
 829         }
 830
 831         SysFreeString(sInput);
 832     }
 833     else
 834     {
 835         sNew = sInput;
 836     }
 837
 838     TRACE("len %d\n", SysStringLen(sNew));
 839
 840     return sNew;
 841 }
 842
 843 /*
 844  * We are trying to replicate the same behaviour as msxml by converting
 845  * line endings to \r\n and using indents as \t. The problem is that msxml
 846  * only formats nodes that have a line ending. Using libxml we cannot
 847  * reproduce behaviour exactly.
 848  *
 849  */
 850 HRESULT node_get_xml(xmlnode *This, BOOL ensure_eol, BSTR *ret)
 851 {
 852     xmlBufferPtr xml_buf;
 853     xmlNodePtr xmldecl;
 854     int size;
 855
 856     if(!ret)
 857         return E_INVALIDARG;
 858
 859     *ret = NULL;
 860
 861     xml_buf = xmlBufferCreate();
 862     if(!xml_buf)
 863         return E_OUTOFMEMORY;
 864
 865     xmldecl = xmldoc_unlink_xmldecl( This->node->doc );
 866
 867     size = xmlNodeDump(xml_buf, This->node->doc, This->node, 0, 1);
 868     if(size > 0) {
 869         const xmlChar *buf_content;
 870         BSTR content;
 871
 872         /* Attribute Nodes return a space in front of their name */
 873         buf_content = xmlBufferContent(xml_buf);
 874
 875         content = bstr_from_xmlChar(buf_content + (buf_content[0] == ' ' ? 1 : 0));
 876         if(ensure_eol)
 877             content = EnsureCorrectEOL(content);
 878
 879         *ret = content;
 880     }else {
 881         *ret = SysAllocStringLen(NULL, 0);
 882     }
 883
 884     xmlBufferFree(xml_buf);
 885     xmldoc_link_xmldecl( This->node->doc, xmldecl );
 886     return *ret ? S_OK : E_OUTOFMEMORY;
 887 }
 888
 889 #ifdef SONAME_LIBXSLT
 890
 891 /* duplicates xmlBufferWriteQuotedString() logic */
 892 static void xml_write_quotedstring(xmlOutputBufferPtr buf, const xmlChar *string)
 893 {
 894     const xmlChar *cur, *base;
 895
 896     if (xmlStrchr(string, '\"'))
 897     {
 898         if (xmlStrchr(string, '\''))
 899         {
 900             xmlOutputBufferWrite(buf, 1, "\"");
 901             base = cur = string;
 902
 903             while (*cur)
 904             {
 905                 if (*cur == '"')
 906                 {
 907                     if (base != cur)
 908                         xmlOutputBufferWrite(buf, cur-base, (const char*)base);
 909                     xmlOutputBufferWrite(buf, 6, "&quot;");
 910                     cur++;
 911                     base = cur;
 912                 }
 913                 else
 914                     cur++;
 915             }
 916             if (base != cur)
 917                 xmlOutputBufferWrite(buf, cur-base, (const char*)base);
 918             xmlOutputBufferWrite(buf, 1, "\"");
 919         }
 920         else
 921         {
 922             xmlOutputBufferWrite(buf, 1, "\'");
 923             xmlOutputBufferWriteString(buf, (const char*)string);
 924             xmlOutputBufferWrite(buf, 1, "\'");
 925         }
 926     }
 927     else
 928     {
 929         xmlOutputBufferWrite(buf, 1, "\"");
 930         xmlOutputBufferWriteString(buf, (const char*)string);
 931         xmlOutputBufferWrite(buf, 1, "\"");
 932     }
 933 }
 934
 935 static int XMLCALL transform_to_stream_write(void *context, const char *buffer, int len)
 936 {
 937     DWORD written;
 938     HRESULT hr = IStream_Write((IStream*)context, buffer, len, &written);
 939     return hr == S_OK ? written : -1;
 940 }
 941
 942 /* Output for method "text" */
 943 static void transform_write_text(xmlDocPtr result, xsltStylesheetPtr style, xmlOutputBufferPtr output)
 944 {
 945     xmlNodePtr cur = result->children;
 946     while (cur)
 947     {
 948         if (cur->type == XML_TEXT_NODE)
 949             xmlOutputBufferWriteString(output, (const char*)cur->content);
 950
 951         /* skip to next node */
 952         if (cur->children)
 953         {
 954             if ((cur->children->type != XML_ENTITY_DECL) &&
 955                 (cur->children->type != XML_ENTITY_REF_NODE) &&
 956                 (cur->children->type != XML_ENTITY_NODE))
 957             {
 958                 cur = cur->children;
 959                 continue;
 960             }
 961         }
 962
 963         if (cur->next) {
 964             cur = cur->next;
 965             continue;
 966         }
 967
 968         do
 969         {
 970             cur = cur->parent;
 971             if (cur == NULL)
 972                 break;
 973             if (cur == (xmlNodePtr) style->doc) {
 974                 cur = NULL;
 975                 break;
 976             }
 977             if (cur->next) {
 978                 cur = cur->next;
 979                 break;
 980             }
 981         } while (cur);
 982     }
 983 }
 984
 985 #undef XSLT_GET_IMPORT_PTR
 986 #define XSLT_GET_IMPORT_PTR(res, style, name) {          \
 987     xsltStylesheetPtr st = style;                        \
 988     res = NULL;                                          \
 989     while (st != NULL) {                                 \
 990         if (st->name != NULL) { res = st->name; break; } \
 991         st = pxsltNextImport(st);                        \
 992     }}
 993
 994 #undef XSLT_GET_IMPORT_INT
 995 #define XSLT_GET_IMPORT_INT(res, style, name) {         \
 996     xsltStylesheetPtr st = style;                       \
 997     res = -1;                                           \
 998     while (st != NULL) {                                \
 999         if (st->name != -1) { res = st->name; break; }  \
1000         st = pxsltNextImport(st);                       \
1001     }}
1002
1003 static void transform_write_xmldecl(xmlDocPtr result, xsltStylesheetPtr style, BOOL omit_encoding, xmlOutputBufferPtr output)
1004 {
1005     int omit_xmldecl, standalone;
1006
1007     XSLT_GET_IMPORT_INT(omit_xmldecl, style, omitXmlDeclaration);
1008     if (omit_xmldecl == 1) return;
1009
1010     XSLT_GET_IMPORT_INT(standalone, style, standalone);
1011
1012     xmlOutputBufferWriteString(output, "<?xml version=");
1013     if (result->version)
1014     {
1015         xmlOutputBufferWriteString(output, "\"");
1016         xmlOutputBufferWriteString(output, (const char *)result->version);
1017         xmlOutputBufferWriteString(output, "\"");
1018     }
1019     else
1020         xmlOutputBufferWriteString(output, "\"1.0\"");
1021
1022     if (!omit_encoding)
1023     {
1024         const xmlChar *encoding;
1025
1026         /* default encoding is UTF-16 */
1027         XSLT_GET_IMPORT_PTR(encoding, style, encoding);
1028         xmlOutputBufferWriteString(output, " encoding=");
1029         xmlOutputBufferWriteString(output, "\"");
1030         xmlOutputBufferWriteString(output, encoding ? (const char *)encoding : "UTF-16");
1031         xmlOutputBufferWriteString(output, "\"");
1032     }
1033
1034     /* standalone attribute */
1035     if (standalone != -1)
1036         xmlOutputBufferWriteString(output, standalone == 0 ? " standalone=\"no\"" : " standalone=\"yes\"");
1037
1038     xmlOutputBufferWriteString(output, "?>");
1039 }
1040
1041 static void htmldtd_dumpcontent(xmlOutputBufferPtr buf, xmlDocPtr doc)
1042 {
1043     xmlDtdPtr cur = doc->intSubset;
1044
1045     xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
1046     xmlOutputBufferWriteString(buf, (const char *)cur->name);
1047     if (cur->ExternalID)
1048     {
1049         xmlOutputBufferWriteString(buf, " PUBLIC ");
1050         xml_write_quotedstring(buf, cur->ExternalID);
1051         if (cur->SystemID)
1052         {
1053             xmlOutputBufferWriteString(buf, " ");
1054             xml_write_quotedstring(buf, cur->SystemID);
1055         }
1056     }
1057     else if (cur->SystemID)
1058     {
1059         xmlOutputBufferWriteString(buf, " SYSTEM ");
1060         xml_write_quotedstring(buf, cur->SystemID);
1061     }
1062     xmlOutputBufferWriteString(buf, ">\n");
1063 }
1064
1065 /* Duplicates htmlDocContentDumpFormatOutput() the way we need it - doesn't add trailing newline. */
1066 static void htmldoc_dumpcontent(xmlOutputBufferPtr buf, xmlDocPtr doc, const char *encoding, int format)
1067 {
1068     xmlElementType type;
1069
1070     /* force HTML output */
1071     type = doc->type;
1072     doc->type = XML_HTML_DOCUMENT_NODE;
1073     if (doc->intSubset)
1074         htmldtd_dumpcontent(buf, doc);
1075     if (doc->children) {
1076         xmlNodePtr cur = doc->children;
1077         while (cur) {
1078             htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
1079             cur = cur->next;
1080         }
1081     }
1082     doc->type = type;
1083 }
1084
1085 static inline BOOL transform_is_empty_resultdoc(xmlDocPtr result)
1086 {
1087     return !result->children || ((result->children->type == XML_DTD_NODE) && !result->children->next);
1088 }
1089
1090 static inline BOOL transform_is_valid_method(xsltStylesheetPtr style)
1091 {
1092     return !style->methodURI || !(style->method && xmlStrEqual(style->method, (const xmlChar *)"xhtml"));
1093 }
1094
1095 /* Helper to write transformation result to specified output buffer. */
1096 static HRESULT node_transform_write(xsltStylesheetPtr style, xmlDocPtr result, BOOL omit_encoding, const char *encoding, xmlOutputBufferPtr output)
1097 {
1098     const xmlChar *method;
1099     int indent;
1100
1101     if (!transform_is_valid_method(style))
1102     {
1103         ERR("unknown output method\n");
1104         return E_FAIL;
1105     }
1106
1107     XSLT_GET_IMPORT_PTR(method, style, method)
1108     XSLT_GET_IMPORT_INT(indent, style, indent);
1109
1110     if (!method && (result->type == XML_HTML_DOCUMENT_NODE))
1111         method = (const xmlChar *) "html";
1112
1113     if (method && xmlStrEqual(method, (const xmlChar *)"html"))
1114     {
1115         htmlSetMetaEncoding(result, (const xmlChar *)encoding);
1116         if (indent == -1)
1117             indent = 1;
1118         htmldoc_dumpcontent(output, result, (const char*)encoding, indent);
1119     }
1120     else if (method && xmlStrEqual(method, (const xmlChar *)"xhtml"))
1121     {
1122         htmlSetMetaEncoding(result, (const xmlChar *) encoding);
1123         htmlDocContentDumpOutput(output, result, encoding);
1124     }
1125     else if (method && xmlStrEqual(method, (const xmlChar *)"text"))
1126         transform_write_text(result, style, output);
1127     else
1128     {
1129         transform_write_xmldecl(result, style, omit_encoding, output);
1130
1131         if (result->children)
1132         {
1133             xmlNodePtr child = result->children;
1134
1135             while (child)
1136             {
1137                 xmlNodeDumpOutput(output, result, child, 0, indent == 1, encoding);
1138                 if (indent && ((child->type == XML_DTD_NODE) || ((child->type == XML_COMMENT_NODE) && child->next)))
1139                     xmlOutputBufferWriteString(output, "\r\n");
1140                 child = child->next;
1141             }
1142         }
1143     }
1144
1145     xmlOutputBufferFlush(output);
1146     return S_OK;
1147 }
1148
1149 /* For BSTR output is always UTF-16, without 'encoding' attribute */
1150 static HRESULT node_transform_write_to_bstr(xsltStylesheetPtr style, xmlDocPtr result, BSTR *str)
1151 {
1152     HRESULT hr = S_OK;
1153
1154     if (transform_is_empty_resultdoc(result))
1155         *str = SysAllocStringLen(NULL, 0);
1156     else
1157     {
1158         xmlOutputBufferPtr output = xmlAllocOutputBuffer(xmlFindCharEncodingHandler("UTF-16"));
1159         const xmlChar *content;
1160         size_t len;
1161
1162         *str = NULL;
1163         if (!output)
1164             return E_OUTOFMEMORY;
1165
1166         hr = node_transform_write(style, result, TRUE, "UTF-16", output);
1167 #ifdef LIBXML2_NEW_BUFFER
1168         content = xmlBufContent(output->conv);
1169         len = xmlBufUse(output->conv);
1170 #else
1171         content = xmlBufferContent(output->conv);
1172         len = xmlBufferLength(output->conv);
1173 #endif
1174         /* UTF-16 encoder places UTF-16 bom, we don't need it for BSTR */
1175         content += sizeof(WCHAR);
1176         *str = SysAllocStringLen((WCHAR*)content, len/sizeof(WCHAR) - 1);
1177         xmlOutputBufferClose(output);
1178     }
1179
1180     return *str ? hr : E_OUTOFMEMORY;
1181 }
1182
1183 static HRESULT node_transform_write_to_stream(xsltStylesheetPtr style, xmlDocPtr result, IStream *stream)
1184 {
1185     static const xmlChar *utf16 = (const xmlChar*)"UTF-16";
1186     xmlOutputBufferPtr output;
1187     const xmlChar *encoding;
1188     HRESULT hr;
1189
1190     if (transform_is_empty_resultdoc(result))
1191     {
1192         WARN("empty result document\n");
1193         return S_OK;
1194     }
1195
1196     if (style->methodURI && (!style->method || !xmlStrEqual(style->method, (const xmlChar *) "xhtml")))
1197     {
1198         ERR("unknown output method\n");
1199         return E_FAIL;
1200     }
1201
1202     /* default encoding is UTF-16 */
1203     XSLT_GET_IMPORT_PTR(encoding, style, encoding);
1204     if (!encoding)
1205         encoding = utf16;
1206
1207     output = xmlOutputBufferCreateIO(transform_to_stream_write, NULL, stream, xmlFindCharEncodingHandler((const char*)encoding));
1208     if (!output)
1209         return E_OUTOFMEMORY;
1210
1211     hr = node_transform_write(style, result, FALSE, (const char*)encoding, output);
1212     xmlOutputBufferClose(output);
1213     return hr;
1214 }
1215
1216 #endif
1217
1218 HRESULT node_transform_node_params(const xmlnode *This, IXMLDOMNode *stylesheet, BSTR *p,
1219     IStream *stream, const struct xslprocessor_params *params)
1220 {
1221 #ifdef SONAME_LIBXSLT
1222     xsltStylesheetPtr xsltSS;
1223     HRESULT hr = S_OK;
1224     xmlnode *sheet;
1225
1226     if (!libxslt_handle) return E_NOTIMPL;
1227     if (!stylesheet || !p) return E_INVALIDARG;
1228
1229     *p = NULL;
1230
1231     sheet = get_node_obj(stylesheet);
1232     if(!sheet) return E_FAIL;
1233
1234     xsltSS = pxsltParseStylesheetDoc(sheet->node->doc);
1235     if(xsltSS)
1236     {
1237         const char **xslparams = NULL;
1238         xmlDocPtr result;
1239         unsigned int i;
1240
1241         /* convert our parameter list to libxml2 format */
1242         if (params && params->count)
1243         {
1244             struct xslprocessor_par *par;
1245
1246             i = 0;
1247             xslparams = heap_alloc((params->count*2 + 1)*sizeof(char*));
1248             LIST_FOR_EACH_ENTRY(par, &params->list, struct xslprocessor_par, entry)
1249             {
1250                 xslparams[i++] = (char*)xmlchar_from_wchar(par->name);
1251                 xslparams[i++] = (char*)xmlchar_from_wchar(par->value);
1252             }
1253             xslparams[i] = NULL;
1254         }
1255
1256         if (xslparams)
1257         {
1258             xsltTransformContextPtr ctxt = pxsltNewTransformContext(xsltSS, This->node->doc);
1259
1260             /* push parameters to user context */
1261             pxsltQuoteUserParams(ctxt, xslparams);
1262             result = pxsltApplyStylesheetUser(xsltSS, This->node->doc, NULL, NULL, NULL, ctxt);
1263             pxsltFreeTransformContext(ctxt);
1264
1265             for (i = 0; i < params->count*2; i++)
1266                 heap_free((char*)xslparams[i]);
1267             heap_free(xslparams);
1268         }
1269         else
1270             result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
1271
1272         if (result)
1273         {
1274             if (stream)
1275                 hr = node_transform_write_to_stream(xsltSS, result, stream);
1276             else
1277                 hr = node_transform_write_to_bstr(xsltSS, result, p);
1278             xmlFreeDoc(result);
1279         }
1280         /* libxslt "helpfully" frees the XML document the stylesheet was
1281            generated from, too */
1282         xsltSS->doc = NULL;
1283         pxsltFreeStylesheet(xsltSS);
1284     }
1285
1286     if(!*p) *p = SysAllocStringLen(NULL, 0);
1287
1288     return hr;
1289 #else
1290     ERR_(winediag)("libxslt headers were not found at compile time. Expect problems.\n");
1291
1292     return E_NOTIMPL;
1293 #endif
1294 }
1295
1296 HRESULT node_transform_node(const xmlnode *node, IXMLDOMNode *stylesheet, BSTR *p)
1297 {
1298     return node_transform_node_params(node, stylesheet, p, NULL, NULL);
1299 }
1300
1301 HRESULT node_select_nodes(const xmlnode *This, BSTR query, IXMLDOMNodeList **nodes)
1302 {
1303     xmlChar* str;
1304     HRESULT hr;
1305
1306     if (!query || !nodes) return E_INVALIDARG;
1307
1308     str = xmlchar_from_wchar(query);
1309     hr = create_selection(This->node, str, nodes);
1310     heap_free(str);
1311
1312     return hr;
1313 }
1314
1315 HRESULT node_select_singlenode(const xmlnode *This, BSTR query, IXMLDOMNode **node)
1316 {
1317     IXMLDOMNodeList *list;
1318     HRESULT hr;
1319
1320     hr = node_select_nodes(This, query, &list);
1321     if (hr == S_OK)
1322     {
1323         hr = IXMLDOMNodeList_nextNode(list, node);
1324         IXMLDOMNodeList_Release(list);
1325     }
1326     return hr;
1327 }
1328
1329 HRESULT node_get_namespaceURI(xmlnode *This, BSTR *namespaceURI)
1330 {
1331     xmlNsPtr ns = This->node->ns;
1332
1333     if(!namespaceURI)
1334         return E_INVALIDARG;
1335
1336     *namespaceURI = NULL;
1337
1338     if (ns && ns->href)
1339         *namespaceURI = bstr_from_xmlChar(ns->href);
1340
1341     TRACE("uri: %s\n", debugstr_w(*namespaceURI));
1342
1343     return *namespaceURI ? S_OK : S_FALSE;
1344 }
1345
1346 HRESULT node_get_prefix(xmlnode *This, BSTR *prefix)
1347 {
1348     xmlNsPtr ns = This->node->ns;
1349
1350     if (!prefix) return E_INVALIDARG;
1351
1352     *prefix = NULL;
1353
1354     if (ns && ns->prefix)
1355         *prefix = bstr_from_xmlChar(ns->prefix);
1356
1357     TRACE("prefix: %s\n", debugstr_w(*prefix));
1358
1359     return *prefix ? S_OK : S_FALSE;
1360 }
1361
1362 HRESULT node_get_base_name(xmlnode *This, BSTR *name)
1363 {
1364     if (!name) return E_INVALIDARG;
1365
1366     *name = bstr_from_xmlChar(This->node->name);
1367     if (!*name) return E_OUTOFMEMORY;
1368
1369     TRACE("returning %s\n", debugstr_w(*name));
1370
1371     return S_OK;
1372 }
1373
1374 /* _private field holds a number of COM instances spawned from this libxml2 node */
1375 static void xmlnode_add_ref(xmlNodePtr node)
1376 {
1377     if (node->type == XML_DOCUMENT_NODE) return;
1378     InterlockedIncrement((LONG*)&node->_private);
1379 }
1380
1381 static void xmlnode_release(xmlNodePtr node)
1382 {
1383     if (node->type == XML_DOCUMENT_NODE) return;
1384     InterlockedDecrement((LONG*)&node->_private);
1385 }
1386
1387 void destroy_xmlnode(xmlnode *This)
1388 {
1389     if(This->node)
1390     {
1391         xmlnode_release(This->node);
1392         xmldoc_release(This->node->doc);
1393     }
1394 }
1395
1396 void init_xmlnode(xmlnode *This, xmlNodePtr node, IXMLDOMNode *node_iface, dispex_static_data_t *dispex_data)
1397 {
1398     if(node)
1399     {
1400         xmlnode_add_ref(node);
1401         xmldoc_add_ref(node->doc);
1402     }
1403
1404     This->node = node;
1405     This->iface = node_iface;
1406     This->parent = NULL;
1407
1408     init_dispex(&This->dispex, (IUnknown*)This->iface, dispex_data);
1409 }
1410
1411 typedef struct {
1412     xmlnode node;
1413     IXMLDOMNode IXMLDOMNode_iface;
1414     LONG ref;
1415 } unknode;
1416
1417 static inline unknode *unknode_from_IXMLDOMNode(IXMLDOMNode *iface)
1418 {
1419     return CONTAINING_RECORD(iface, unknode, IXMLDOMNode_iface);
1420 }
1421
1422 static HRESULT WINAPI unknode_QueryInterface(
1423     IXMLDOMNode *iface,
1424     REFIID riid,
1425     void** ppvObject )
1426 {
1427     unknode *This = unknode_from_IXMLDOMNode( iface );
1428
1429     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1430
1431     if (IsEqualGUID(riid, &IID_IUnknown)) {
1432         *ppvObject = iface;
1433     }else if (IsEqualGUID( riid, &IID_IDispatch) ||
1434               IsEqualGUID( riid, &IID_IXMLDOMNode)) {
1435         *ppvObject = &This->IXMLDOMNode_iface;
1436     }else if(node_query_interface(&This->node, riid, ppvObject)) {
1437         return *ppvObject ? S_OK : E_NOINTERFACE;
1438     }else  {
1439         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1440         *ppvObject = NULL;
1441         return E_NOINTERFACE;
1442     }
1443
1444     IUnknown_AddRef((IUnknown*)*ppvObject);
1445     return S_OK;
1446 }
1447
1448 static ULONG WINAPI unknode_AddRef(
1449     IXMLDOMNode *iface )
1450 {
1451     unknode *This = unknode_from_IXMLDOMNode( iface );
1452
1453     return InterlockedIncrement(&This->ref);
1454 }
1455
1456 static ULONG WINAPI unknode_Release(
1457     IXMLDOMNode *iface )
1458 {
1459     unknode *This = unknode_from_IXMLDOMNode( iface );
1460     LONG ref;
1461
1462     ref = InterlockedDecrement( &This->ref );
1463     if(!ref) {
1464         destroy_xmlnode(&This->node);
1465         heap_free(This);
1466     }
1467
1468     return ref;
1469 }
1470
1471 static HRESULT WINAPI unknode_GetTypeInfoCount(
1472     IXMLDOMNode *iface,
1473     UINT* pctinfo )
1474 {
1475     unknode *This = unknode_from_IXMLDOMNode( iface );
1476
1477     TRACE("(%p)->(%p)\n", This, pctinfo);
1478
1479     *pctinfo = 1;
1480
1481     return S_OK;
1482 }
1483
1484 static HRESULT WINAPI unknode_GetTypeInfo(
1485     IXMLDOMNode *iface,
1486     UINT iTInfo,
1487     LCID lcid,
1488     ITypeInfo** ppTInfo )
1489 {
1490     unknode *This = unknode_from_IXMLDOMNode( iface );
1491     HRESULT hr;
1492
1493     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1494
1495     hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
1496
1497     return hr;
1498 }
1499
1500 static HRESULT WINAPI unknode_GetIDsOfNames(
1501     IXMLDOMNode *iface,
1502     REFIID riid,
1503     LPOLESTR* rgszNames,
1504     UINT cNames,
1505     LCID lcid,
1506     DISPID* rgDispId )
1507 {
1508     unknode *This = unknode_from_IXMLDOMNode( iface );
1509
1510     ITypeInfo *typeinfo;
1511     HRESULT hr;
1512
1513     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1514           lcid, rgDispId);
1515
1516     if(!rgszNames || cNames == 0 || !rgDispId)
1517         return E_INVALIDARG;
1518
1519     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1520     if(SUCCEEDED(hr))
1521     {
1522         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1523         ITypeInfo_Release(typeinfo);
1524     }
1525
1526     return hr;
1527 }
1528
1529 static HRESULT WINAPI unknode_Invoke(
1530     IXMLDOMNode *iface,
1531     DISPID dispIdMember,
1532     REFIID riid,
1533     LCID lcid,
1534     WORD wFlags,
1535     DISPPARAMS* pDispParams,
1536     VARIANT* pVarResult,
1537     EXCEPINFO* pExcepInfo,
1538     UINT* puArgErr )
1539 {
1540     unknode *This = unknode_from_IXMLDOMNode( iface );
1541     ITypeInfo *typeinfo;
1542     HRESULT hr;
1543
1544     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1545           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1546
1547     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1548     if(SUCCEEDED(hr))
1549     {
1550         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMNode_iface, dispIdMember, wFlags, pDispParams,
1551                 pVarResult, pExcepInfo, puArgErr);
1552         ITypeInfo_Release(typeinfo);
1553     }
1554
1555     return hr;
1556 }
1557
1558 static HRESULT WINAPI unknode_get_nodeName(
1559     IXMLDOMNode *iface,
1560     BSTR* p )
1561 {
1562     unknode *This = unknode_from_IXMLDOMNode( iface );
1563
1564     FIXME("(%p)->(%p)\n", This, p);
1565
1566     return node_get_nodeName(&This->node, p);
1567 }
1568
1569 static HRESULT WINAPI unknode_get_nodeValue(
1570     IXMLDOMNode *iface,
1571     VARIANT* value)
1572 {
1573     unknode *This = unknode_from_IXMLDOMNode( iface );
1574
1575     FIXME("(%p)->(%p)\n", This, value);
1576
1577     if(!value)
1578         return E_INVALIDARG;
1579
1580     V_VT(value) = VT_NULL;
1581     return S_FALSE;
1582 }
1583
1584 static HRESULT WINAPI unknode_put_nodeValue(
1585     IXMLDOMNode *iface,
1586     VARIANT value)
1587 {
1588     unknode *This = unknode_from_IXMLDOMNode( iface );
1589     FIXME("(%p)->(v%d)\n", This, V_VT(&value));
1590     return E_FAIL;
1591 }
1592
1593 static HRESULT WINAPI unknode_get_nodeType(
1594     IXMLDOMNode *iface,
1595     DOMNodeType* domNodeType )
1596 {
1597     unknode *This = unknode_from_IXMLDOMNode( iface );
1598
1599     FIXME("(%p)->(%p)\n", This, domNodeType);
1600
1601     switch (This->node.node->type)
1602     {
1603     case XML_ELEMENT_NODE:
1604     case XML_ATTRIBUTE_NODE:
1605     case XML_TEXT_NODE:
1606     case XML_CDATA_SECTION_NODE:
1607     case XML_ENTITY_REF_NODE:
1608     case XML_ENTITY_NODE:
1609     case XML_PI_NODE:
1610     case XML_COMMENT_NODE:
1611     case XML_DOCUMENT_NODE:
1612     case XML_DOCUMENT_TYPE_NODE:
1613     case XML_DOCUMENT_FRAG_NODE:
1614     case XML_NOTATION_NODE:
1615         /* we only care about this set of types, libxml2 type values are
1616            exactly what we need */
1617         *domNodeType = (DOMNodeType)This->node.node->type;
1618         break;
1619     default:
1620         *domNodeType = NODE_INVALID;
1621         break;
1622     }
1623
1624     return S_OK;
1625 }
1626
1627 static HRESULT WINAPI unknode_get_parentNode(
1628     IXMLDOMNode *iface,
1629     IXMLDOMNode** parent )
1630 {
1631     unknode *This = unknode_from_IXMLDOMNode( iface );
1632     FIXME("(%p)->(%p)\n", This, parent);
1633     if (!parent) return E_INVALIDARG;
1634     *parent = NULL;
1635     return S_FALSE;
1636 }
1637
1638 static HRESULT WINAPI unknode_get_childNodes(
1639     IXMLDOMNode *iface,
1640     IXMLDOMNodeList** outList)
1641 {
1642     unknode *This = unknode_from_IXMLDOMNode( iface );
1643
1644     TRACE("(%p)->(%p)\n", This, outList);
1645
1646     return node_get_child_nodes(&This->node, outList);
1647 }
1648
1649 static HRESULT WINAPI unknode_get_firstChild(
1650     IXMLDOMNode *iface,
1651     IXMLDOMNode** domNode)
1652 {
1653     unknode *This = unknode_from_IXMLDOMNode( iface );
1654
1655     TRACE("(%p)->(%p)\n", This, domNode);
1656
1657     return node_get_first_child(&This->node, domNode);
1658 }
1659
1660 static HRESULT WINAPI unknode_get_lastChild(
1661     IXMLDOMNode *iface,
1662     IXMLDOMNode** domNode)
1663 {
1664     unknode *This = unknode_from_IXMLDOMNode( iface );
1665
1666     TRACE("(%p)->(%p)\n", This, domNode);
1667
1668     return node_get_last_child(&This->node, domNode);
1669 }
1670
1671 static HRESULT WINAPI unknode_get_previousSibling(
1672     IXMLDOMNode *iface,
1673     IXMLDOMNode** domNode)
1674 {
1675     unknode *This = unknode_from_IXMLDOMNode( iface );
1676
1677     TRACE("(%p)->(%p)\n", This, domNode);
1678
1679     return node_get_previous_sibling(&This->node, domNode);
1680 }
1681
1682 static HRESULT WINAPI unknode_get_nextSibling(
1683     IXMLDOMNode *iface,
1684     IXMLDOMNode** domNode)
1685 {
1686     unknode *This = unknode_from_IXMLDOMNode( iface );
1687
1688     TRACE("(%p)->(%p)\n", This, domNode);
1689
1690     return node_get_next_sibling(&This->node, domNode);
1691 }
1692
1693 static HRESULT WINAPI unknode_get_attributes(
1694     IXMLDOMNode *iface,
1695     IXMLDOMNamedNodeMap** attributeMap)
1696 {
1697     unknode *This = unknode_from_IXMLDOMNode( iface );
1698
1699     FIXME("(%p)->(%p)\n", This, attributeMap);
1700
1701     return return_null_ptr((void**)attributeMap);
1702 }
1703
1704 static HRESULT WINAPI unknode_insertBefore(
1705     IXMLDOMNode *iface,
1706     IXMLDOMNode* newNode, VARIANT refChild,
1707     IXMLDOMNode** outOldNode)
1708 {
1709     unknode *This = unknode_from_IXMLDOMNode( iface );
1710
1711     FIXME("(%p)->(%p x%d %p)\n", This, newNode, V_VT(&refChild), outOldNode);
1712
1713     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
1714 }
1715
1716 static HRESULT WINAPI unknode_replaceChild(
1717     IXMLDOMNode *iface,
1718     IXMLDOMNode* newNode,
1719     IXMLDOMNode* oldNode,
1720     IXMLDOMNode** outOldNode)
1721 {
1722     unknode *This = unknode_from_IXMLDOMNode( iface );
1723
1724     FIXME("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
1725
1726     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
1727 }
1728
1729 static HRESULT WINAPI unknode_removeChild(
1730     IXMLDOMNode *iface,
1731     IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
1732 {
1733     unknode *This = unknode_from_IXMLDOMNode( iface );
1734     return node_remove_child(&This->node, domNode, oldNode);
1735 }
1736
1737 static HRESULT WINAPI unknode_appendChild(
1738     IXMLDOMNode *iface,
1739     IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
1740 {
1741     unknode *This = unknode_from_IXMLDOMNode( iface );
1742     return node_append_child(&This->node, newNode, outNewNode);
1743 }
1744
1745 static HRESULT WINAPI unknode_hasChildNodes(
1746     IXMLDOMNode *iface,
1747     VARIANT_BOOL* pbool)
1748 {
1749     unknode *This = unknode_from_IXMLDOMNode( iface );
1750     return node_has_childnodes(&This->node, pbool);
1751 }
1752
1753 static HRESULT WINAPI unknode_get_ownerDocument(
1754     IXMLDOMNode *iface,
1755     IXMLDOMDocument** domDocument)
1756 {
1757     unknode *This = unknode_from_IXMLDOMNode( iface );
1758     return node_get_owner_doc(&This->node, domDocument);
1759 }
1760
1761 static HRESULT WINAPI unknode_cloneNode(
1762     IXMLDOMNode *iface,
1763     VARIANT_BOOL pbool, IXMLDOMNode** outNode)
1764 {
1765     unknode *This = unknode_from_IXMLDOMNode( iface );
1766     return node_clone(&This->node, pbool, outNode );
1767 }
1768
1769 static HRESULT WINAPI unknode_get_nodeTypeString(
1770     IXMLDOMNode *iface,
1771     BSTR* p)
1772 {
1773     unknode *This = unknode_from_IXMLDOMNode( iface );
1774
1775     FIXME("(%p)->(%p)\n", This, p);
1776
1777     return node_get_nodeName(&This->node, p);
1778 }
1779
1780 static HRESULT WINAPI unknode_get_text(
1781     IXMLDOMNode *iface,
1782     BSTR* p)
1783 {
1784     unknode *This = unknode_from_IXMLDOMNode( iface );
1785     return node_get_text(&This->node, p);
1786 }
1787
1788 static HRESULT WINAPI unknode_put_text(
1789     IXMLDOMNode *iface,
1790     BSTR p)
1791 {
1792     unknode *This = unknode_from_IXMLDOMNode( iface );
1793     return node_put_text(&This->node, p);
1794 }
1795
1796 static HRESULT WINAPI unknode_get_specified(
1797     IXMLDOMNode *iface,
1798     VARIANT_BOOL* isSpecified)
1799 {
1800     unknode *This = unknode_from_IXMLDOMNode( iface );
1801     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1802     *isSpecified = VARIANT_TRUE;
1803     return S_OK;
1804 }
1805
1806 static HRESULT WINAPI unknode_get_definition(
1807     IXMLDOMNode *iface,
1808     IXMLDOMNode** definitionNode)
1809 {
1810     unknode *This = unknode_from_IXMLDOMNode( iface );
1811     FIXME("(%p)->(%p)\n", This, definitionNode);
1812     return E_NOTIMPL;
1813 }
1814
1815 static HRESULT WINAPI unknode_get_nodeTypedValue(
1816     IXMLDOMNode *iface,
1817     VARIANT* var1)
1818 {
1819     unknode *This = unknode_from_IXMLDOMNode( iface );
1820     FIXME("(%p)->(%p)\n", This, var1);
1821     return return_null_var(var1);
1822 }
1823
1824 static HRESULT WINAPI unknode_put_nodeTypedValue(
1825     IXMLDOMNode *iface,
1826     VARIANT typedValue)
1827 {
1828     unknode *This = unknode_from_IXMLDOMNode( iface );
1829     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
1830     return E_NOTIMPL;
1831 }
1832
1833 static HRESULT WINAPI unknode_get_dataType(
1834     IXMLDOMNode *iface,
1835     VARIANT* var1)
1836 {
1837     unknode *This = unknode_from_IXMLDOMNode( iface );
1838     TRACE("(%p)->(%p)\n", This, var1);
1839     return return_null_var(var1);
1840 }
1841
1842 static HRESULT WINAPI unknode_put_dataType(
1843     IXMLDOMNode *iface,
1844     BSTR p)
1845 {
1846     unknode *This = unknode_from_IXMLDOMNode( iface );
1847
1848     FIXME("(%p)->(%s)\n", This, debugstr_w(p));
1849
1850     if(!p)
1851         return E_INVALIDARG;
1852
1853     return E_FAIL;
1854 }
1855
1856 static HRESULT WINAPI unknode_get_xml(
1857     IXMLDOMNode *iface,
1858     BSTR* p)
1859 {
1860     unknode *This = unknode_from_IXMLDOMNode( iface );
1861
1862     FIXME("(%p)->(%p)\n", This, p);
1863
1864     return node_get_xml(&This->node, FALSE, p);
1865 }
1866
1867 static HRESULT WINAPI unknode_transformNode(
1868     IXMLDOMNode *iface,
1869     IXMLDOMNode* domNode, BSTR* p)
1870 {
1871     unknode *This = unknode_from_IXMLDOMNode( iface );
1872     return node_transform_node(&This->node, domNode, p);
1873 }
1874
1875 static HRESULT WINAPI unknode_selectNodes(
1876     IXMLDOMNode *iface,
1877     BSTR p, IXMLDOMNodeList** outList)
1878 {
1879     unknode *This = unknode_from_IXMLDOMNode( iface );
1880     return node_select_nodes(&This->node, p, outList);
1881 }
1882
1883 static HRESULT WINAPI unknode_selectSingleNode(
1884     IXMLDOMNode *iface,
1885     BSTR p, IXMLDOMNode** outNode)
1886 {
1887     unknode *This = unknode_from_IXMLDOMNode( iface );
1888     return node_select_singlenode(&This->node, p, outNode);
1889 }
1890
1891 static HRESULT WINAPI unknode_get_parsed(
1892     IXMLDOMNode *iface,
1893     VARIANT_BOOL* isParsed)
1894 {
1895     unknode *This = unknode_from_IXMLDOMNode( iface );
1896     FIXME("(%p)->(%p) stub!\n", This, isParsed);
1897     *isParsed = VARIANT_TRUE;
1898     return S_OK;
1899 }
1900
1901 static HRESULT WINAPI unknode_get_namespaceURI(
1902     IXMLDOMNode *iface,
1903     BSTR* p)
1904 {
1905     unknode *This = unknode_from_IXMLDOMNode( iface );
1906     TRACE("(%p)->(%p)\n", This, p);
1907     return node_get_namespaceURI(&This->node, p);
1908 }
1909
1910 static HRESULT WINAPI unknode_get_prefix(
1911     IXMLDOMNode *iface,
1912     BSTR* p)
1913 {
1914     unknode *This = unknode_from_IXMLDOMNode( iface );
1915     return node_get_prefix(&This->node, p);
1916 }
1917
1918 static HRESULT WINAPI unknode_get_baseName(
1919     IXMLDOMNode *iface,
1920     BSTR* p)
1921 {
1922     unknode *This = unknode_from_IXMLDOMNode( iface );
1923     return node_get_base_name(&This->node, p);
1924 }
1925
1926 static HRESULT WINAPI unknode_transformNodeToObject(
1927     IXMLDOMNode *iface,
1928     IXMLDOMNode* domNode, VARIANT var1)
1929 {
1930     unknode *This = unknode_from_IXMLDOMNode( iface );
1931     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1932     return E_NOTIMPL;
1933 }
1934
1935 static const struct IXMLDOMNodeVtbl unknode_vtbl =
1936 {
1937     unknode_QueryInterface,
1938     unknode_AddRef,
1939     unknode_Release,
1940     unknode_GetTypeInfoCount,
1941     unknode_GetTypeInfo,
1942     unknode_GetIDsOfNames,
1943     unknode_Invoke,
1944     unknode_get_nodeName,
1945     unknode_get_nodeValue,
1946     unknode_put_nodeValue,
1947     unknode_get_nodeType,
1948     unknode_get_parentNode,
1949     unknode_get_childNodes,
1950     unknode_get_firstChild,
1951     unknode_get_lastChild,
1952     unknode_get_previousSibling,
1953     unknode_get_nextSibling,
1954     unknode_get_attributes,
1955     unknode_insertBefore,
1956     unknode_replaceChild,
1957     unknode_removeChild,
1958     unknode_appendChild,
1959     unknode_hasChildNodes,
1960     unknode_get_ownerDocument,
1961     unknode_cloneNode,
1962     unknode_get_nodeTypeString,
1963     unknode_get_text,
1964     unknode_put_text,
1965     unknode_get_specified,
1966     unknode_get_definition,
1967     unknode_get_nodeTypedValue,
1968     unknode_put_nodeTypedValue,
1969     unknode_get_dataType,
1970     unknode_put_dataType,
1971     unknode_get_xml,
1972     unknode_transformNode,
1973     unknode_selectNodes,
1974     unknode_selectSingleNode,
1975     unknode_get_parsed,
1976     unknode_get_namespaceURI,
1977     unknode_get_prefix,
1978     unknode_get_baseName,
1979     unknode_transformNodeToObject
1980 };
1981
1982 IXMLDOMNode *create_node( xmlNodePtr node )
1983 {
1984     IUnknown *pUnk;
1985     IXMLDOMNode *ret;
1986     HRESULT hr;
1987
1988     if ( !node )
1989         return NULL;
1990
1991     TRACE("type %d\n", node->type);
1992     switch(node->type)
1993     {
1994     case XML_ELEMENT_NODE:
1995         pUnk = create_element( node );
1996         break;
1997     case XML_ATTRIBUTE_NODE:
1998         pUnk = create_attribute( node );
1999         break;
2000     case XML_TEXT_NODE:
2001         pUnk = create_text( node );
2002         break;
2003     case XML_CDATA_SECTION_NODE:
2004         pUnk = create_cdata( node );
2005         break;
2006     case XML_ENTITY_REF_NODE:
2007         pUnk = create_doc_entity_ref( node );
2008         break;
2009     case XML_PI_NODE:
2010         pUnk = create_pi( node );
2011         break;
2012     case XML_COMMENT_NODE:
2013         pUnk = create_comment( node );
2014         break;
2015     case XML_DOCUMENT_NODE:
2016         pUnk = create_domdoc( node );
2017         break;
2018     case XML_DOCUMENT_FRAG_NODE:
2019         pUnk = create_doc_fragment( node );
2020         break;
2021     case XML_DTD_NODE:
2022     case XML_DOCUMENT_TYPE_NODE:
2023         pUnk = create_doc_type( node );
2024         break;
2025     case XML_ENTITY_NODE:
2026     case XML_NOTATION_NODE: {
2027         unknode *new_node;
2028
2029         FIXME("only creating basic node for type %d\n", node->type);
2030
2031         new_node = heap_alloc(sizeof(unknode));
2032         if(!new_node)
2033             return NULL;
2034
2035         new_node->IXMLDOMNode_iface.lpVtbl = &unknode_vtbl;
2036         new_node->ref = 1;
2037         init_xmlnode(&new_node->node, node, &new_node->IXMLDOMNode_iface, NULL);
2038         pUnk = (IUnknown*)&new_node->IXMLDOMNode_iface;
2039         break;
2040     }
2041     default:
2042         ERR("Called for unsupported node type %d\n", node->type);
2043         return NULL;
2044     }
2045
2046     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
2047     IUnknown_Release(pUnk);
2048     if(FAILED(hr)) return NULL;
2049     return ret;
2050 }
2051 #endif