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