git.oblomov.eu Git - wine/blob - 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 #include "config.h"
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26
  27 #ifdef HAVE_LIBXML2
  28 # include <libxml/parser.h>
  29 # include <libxml/xmlerror.h>
  30 # include <libxml/HTMLtree.h>
  31 # ifdef SONAME_LIBXSLT
  32 #  ifdef HAVE_LIBXSLT_PATTERN_H
  33 #   include <libxslt/pattern.h>
  34 #  endif
  35 #  ifdef HAVE_LIBXSLT_TRANSFORM_H
  36 #   include <libxslt/transform.h>
  37 #  endif
  38 #  include <libxslt/xsltutils.h>
  39 #  include <libxslt/xsltInternals.h>
  40 # endif
  41 #endif
  42
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "winuser.h"
  46 #include "winnls.h"
  47 #include "ole2.h"
  48 #include "msxml6.h"
  49
  50 #include "msxml_private.h"
  51
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  55
  56 #ifdef HAVE_LIBXML2
  57
  58 #ifdef SONAME_LIBXSLT
  59 extern void* libxslt_handle;
  60 # define MAKE_FUNCPTR(f) extern typeof(f) * p##f
  61 MAKE_FUNCPTR(xsltApplyStylesheet);
  62 MAKE_FUNCPTR(xsltCleanupGlobals);
  63 MAKE_FUNCPTR(xsltFreeStylesheet);
  64 MAKE_FUNCPTR(xsltParseStylesheetDoc);
  65 # undef MAKE_FUNCPTR
  66 #endif
  67
  68 /* TODO: get rid of these and use the enum */
  69 static const WCHAR szBinBase64[]  = {'b','i','n','.','b','a','s','e','6','4',0};
  70 static const WCHAR szString[]     = {'s','t','r','i','n','g',0};
  71 static const WCHAR szNumber[]     = {'n','u','m','b','e','r',0};
  72 static const WCHAR szInt[]        = {'I','n','t',0};
  73 static const WCHAR szFixed[]      = {'F','i','x','e','d','.','1','4','.','4',0};
  74 static const WCHAR szBoolean[]    = {'B','o','o','l','e','a','n',0};
  75 static const WCHAR szDateTime[]   = {'d','a','t','e','T','i','m','e',0};
  76 static const WCHAR szDateTimeTZ[] = {'d','a','t','e','T','i','m','e','.','t','z',0};
  77 static const WCHAR szDate[]       = {'D','a','t','e',0};
  78 static const WCHAR szTime[]       = {'T','i','m','e',0};
  79 static const WCHAR szTimeTZ[]     = {'T','i','m','e','.','t','z',0};
  80 static const WCHAR szI1[]         = {'i','1',0};
  81 static const WCHAR szI2[]         = {'i','2',0};
  82 static const WCHAR szI4[]         = {'i','4',0};
  83 static const WCHAR szIU1[]        = {'u','i','1',0};
  84 static const WCHAR szIU2[]        = {'u','i','2',0};
  85 static const WCHAR szIU4[]        = {'u','i','4',0};
  86 static const WCHAR szR4[]         = {'r','4',0};
  87 static const WCHAR szR8[]         = {'r','8',0};
  88 static const WCHAR szFloat[]      = {'f','l','o','a','t',0};
  89 static const WCHAR szUUID[]       = {'u','u','i','d',0};
  90 static const WCHAR szBinHex[]     = {'b','i','n','.','h','e','x',0};
  91
  92 static const IID IID_xmlnode = {0x4f2f4ba2,0xb822,0x11df,{0x8b,0x8a,0x68,0x50,0xdf,0xd7,0x20,0x85}};
  93
  94 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  95 {
  96     xmlnode *This;
  97
  98     if ( !iface )
  99         return NULL;
 100     This = get_node_obj( iface );
 101     if ( !This || !This->node )
 102         return NULL;
 103     if ( type && This->node->type != type )
 104         return NULL;
 105     return This->node;
 106 }
 107
 108 BOOL node_query_interface(xmlnode *This, REFIID riid, void **ppv)
 109 {
 110     if(IsEqualGUID(&IID_xmlnode, riid)) {
 111         TRACE("(%p)->(IID_xmlnode %p)\n", This, ppv);
 112         *ppv = This;
 113         return TRUE;
 114     }
 115
 116     if(This->dispex.outer)
 117         return dispex_query_interface(&This->dispex, riid, ppv);
 118
 119     return FALSE;
 120 }
 121
 122 xmlnode *get_node_obj(IXMLDOMNode *node)
 123 {
 124     xmlnode *obj = NULL;
 125     HRESULT hres;
 126
 127     hres = IXMLDOMNode_QueryInterface(node, &IID_xmlnode, (void**)&obj);
 128     if (!obj) WARN("node is not our IXMLDOMNode implementation\n");
 129     return SUCCEEDED(hres) ? obj : NULL;
 130 }
 131
 132 HRESULT node_get_nodeName(xmlnode *This, BSTR *name)
 133 {
 134     if (!name)
 135         return E_INVALIDARG;
 136
 137     *name = bstr_from_xmlChar(This->node->name);
 138     if (!*name)
 139         return S_FALSE;
 140
 141     return S_OK;
 142 }
 143
 144 HRESULT node_get_content(xmlnode *This, VARIANT *value)
 145 {
 146     xmlChar *content;
 147
 148     if(!value)
 149         return E_INVALIDARG;
 150
 151     content = xmlNodeGetContent(This->node);
 152     V_VT(value) = VT_BSTR;
 153     V_BSTR(value) = bstr_from_xmlChar( content );
 154     xmlFree(content);
 155
 156     TRACE("%p returned %s\n", This, debugstr_w(V_BSTR(value)));
 157     return S_OK;
 158 }
 159
 160 HRESULT node_set_content(xmlnode *This, LPCWSTR value)
 161 {
 162     xmlChar *str;
 163
 164     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 165     str = xmlChar_from_wchar(value);
 166     if(!str)
 167         return E_OUTOFMEMORY;
 168
 169     xmlNodeSetContent(This->node, str);
 170     heap_free(str);
 171     return S_OK;
 172 }
 173
 174 static HRESULT node_set_content_escaped(xmlnode *This, LPCWSTR value)
 175 {
 176     xmlChar *str, *escaped;
 177
 178     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 179     str = xmlChar_from_wchar(value);
 180     if(!str)
 181         return E_OUTOFMEMORY;
 182
 183     escaped = xmlEncodeSpecialChars(NULL, str);
 184     if(!escaped)
 185     {
 186         heap_free(str);
 187         return E_OUTOFMEMORY;
 188     }
 189
 190     xmlNodeSetContent(This->node, escaped);
 191
 192     heap_free(str);
 193     xmlFree(escaped);
 194
 195     return S_OK;
 196 }
 197
 198 HRESULT node_put_value(xmlnode *This, VARIANT *value)
 199 {
 200     VARIANT string_value;
 201     HRESULT hr;
 202
 203     VariantInit(&string_value);
 204     hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 205     if(FAILED(hr)) {
 206         WARN("Couldn't convert to VT_BSTR\n");
 207         return hr;
 208     }
 209
 210     hr = node_set_content(This, V_BSTR(&string_value));
 211     VariantClear(&string_value);
 212
 213     return hr;
 214 }
 215
 216 HRESULT node_put_value_escaped(xmlnode *This, VARIANT *value)
 217 {
 218     VARIANT string_value;
 219     HRESULT hr;
 220
 221     VariantInit(&string_value);
 222     hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 223     if(FAILED(hr)) {
 224         WARN("Couldn't convert to VT_BSTR\n");
 225         return hr;
 226     }
 227
 228     hr = node_set_content_escaped(This, V_BSTR(&string_value));
 229     VariantClear(&string_value);
 230
 231     return hr;
 232 }
 233
 234 static HRESULT get_node(
 235     xmlnode *This,
 236     const char *name,
 237     xmlNodePtr node,
 238     IXMLDOMNode **out )
 239 {
 240     TRACE("(%p)->(%s %p %p)\n", This, name, node, out );
 241
 242     if ( !out )
 243         return E_INVALIDARG;
 244
 245     /* if we don't have a doc, use our parent. */
 246     if(node && !node->doc && node->parent)
 247         node->doc = node->parent->doc;
 248
 249     *out = create_node( node );
 250     if (!*out)
 251         return S_FALSE;
 252     return S_OK;
 253 }
 254
 255 HRESULT node_get_parent(xmlnode *This, IXMLDOMNode **parent)
 256 {
 257     return get_node( This, "parent", This->node->parent, parent );
 258 }
 259
 260 HRESULT node_get_child_nodes(xmlnode *This, IXMLDOMNodeList **ret)
 261 {
 262     if(!ret)
 263         return E_INVALIDARG;
 264
 265     *ret = create_children_nodelist(This->node);
 266     if(!*ret)
 267         return E_OUTOFMEMORY;
 268
 269     return S_OK;
 270 }
 271
 272 HRESULT node_get_first_child(xmlnode *This, IXMLDOMNode **ret)
 273 {
 274     return get_node(This, "firstChild", This->node->children, ret);
 275 }
 276
 277 HRESULT node_get_last_child(xmlnode *This, IXMLDOMNode **ret)
 278 {
 279     return get_node(This, "lastChild", This->node->last, ret);
 280 }
 281
 282 HRESULT node_get_previous_sibling(xmlnode *This, IXMLDOMNode **ret)
 283 {
 284     return get_node(This, "previous", This->node->prev, ret);
 285 }
 286
 287 HRESULT node_get_next_sibling(xmlnode *This, IXMLDOMNode **ret)
 288 {
 289     return get_node(This, "next", This->node->next, ret);
 290 }
 291
 292 HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
 293         IXMLDOMNode **ret)
 294 {
 295     xmlNodePtr new_child_node;
 296     IXMLDOMNode *before = NULL;
 297     xmlnode *node_obj;
 298     xmlDocPtr doc;
 299     HRESULT hr;
 300
 301     if(!new_child)
 302         return E_INVALIDARG;
 303
 304     node_obj = get_node_obj(new_child);
 305     if(!node_obj) return E_FAIL;
 306
 307     switch(V_VT(ref_child))
 308     {
 309     case VT_EMPTY:
 310     case VT_NULL:
 311         break;
 312
 313     case VT_UNKNOWN:
 314     case VT_DISPATCH:
 315         hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (void**)&before);
 316         if(FAILED(hr)) return hr;
 317         break;
 318
 319     default:
 320         FIXME("refChild var type %x\n", V_VT(ref_child));
 321         return E_FAIL;
 322     }
 323
 324     new_child_node = node_obj->node;
 325     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 326
 327     if(!new_child_node->parent)
 328         if(xmldoc_remove_orphan(new_child_node->doc, new_child_node) != S_OK)
 329             WARN("%p is not an orphan of %p\n", new_child_node, new_child_node->doc);
 330
 331     if(before)
 332     {
 333         xmlnode *before_node_obj = get_node_obj(before);
 334         IXMLDOMNode_Release(before);
 335         if(!before_node_obj) return E_FAIL;
 336
 337         /* unlink from current parent first */
 338         if(node_obj->parent)
 339             IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
 340         doc = new_child_node->doc;
 341         xmldoc_add_ref(before_node_obj->node->doc);
 342         xmlAddPrevSibling(before_node_obj->node, new_child_node);
 343         xmldoc_release(doc);
 344         node_obj->parent = This->parent;
 345     }
 346     else
 347     {
 348         /* unlink from current parent first */
 349         if(node_obj->parent)
 350             IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
 351         doc = new_child_node->doc;
 352         xmldoc_add_ref(This->node->doc);
 353         xmlAddChild(This->node, new_child_node);
 354         xmldoc_release(doc);
 355         node_obj->parent = This->iface;
 356     }
 357
 358     if(ret)
 359     {
 360         IXMLDOMNode_AddRef(new_child);
 361         *ret = new_child;
 362     }
 363
 364     TRACE("ret S_OK\n");
 365     return S_OK;
 366 }
 367
 368 HRESULT node_replace_child(xmlnode *This, IXMLDOMNode *newChild, IXMLDOMNode *oldChild,
 369         IXMLDOMNode **ret)
 370 {
 371     xmlnode *old_child, *new_child;
 372     xmlDocPtr leaving_doc;
 373     xmlNode *my_ancestor;
 374
 375     /* Do not believe any documentation telling that newChild == NULL
 376        means removal. It does certainly *not* apply to msxml3! */
 377     if(!newChild || !oldChild)
 378         return E_INVALIDARG;
 379
 380     if(ret)
 381         *ret = NULL;
 382
 383     old_child = get_node_obj(oldChild);
 384     if(!old_child) return E_FAIL;
 385
 386     if(old_child->node->parent != This->node)
 387     {
 388         WARN("childNode %p is not a child of %p\n", oldChild, This);
 389         return E_INVALIDARG;
 390     }
 391
 392     new_child = get_node_obj(newChild);
 393     if(!new_child) return E_FAIL;
 394
 395     my_ancestor = This->node;
 396     while(my_ancestor)
 397     {
 398         if(my_ancestor == new_child->node)
 399         {
 400             WARN("tried to create loop\n");
 401             return E_FAIL;
 402         }
 403         my_ancestor = my_ancestor->parent;
 404     }
 405
 406     if(!new_child->node->parent)
 407         if(xmldoc_remove_orphan(new_child->node->doc, new_child->node) != S_OK)
 408             WARN("%p is not an orphan of %p\n", new_child->node, new_child->node->doc);
 409
 410     leaving_doc = new_child->node->doc;
 411     xmldoc_add_ref(old_child->node->doc);
 412     xmlReplaceNode(old_child->node, new_child->node);
 413     xmldoc_release(leaving_doc);
 414     new_child->parent = old_child->parent;
 415     old_child->parent = NULL;
 416
 417     xmldoc_add_orphan(old_child->node->doc, old_child->node);
 418
 419     if(ret)
 420     {
 421         IXMLDOMNode_AddRef(oldChild);
 422         *ret = oldChild;
 423     }
 424
 425     return S_OK;
 426 }
 427
 428 HRESULT node_remove_child(xmlnode *This, IXMLDOMNode* child, IXMLDOMNode** oldChild)
 429 {
 430     xmlnode *child_node;
 431
 432     if(!child) return E_INVALIDARG;
 433
 434     if(oldChild)
 435         *oldChild = NULL;
 436
 437     child_node = get_node_obj(child);
 438     if(!child_node) return E_FAIL;
 439
 440     if(child_node->node->parent != This->node)
 441     {
 442         WARN("childNode %p is not a child of %p\n", child, This);
 443         return E_INVALIDARG;
 444     }
 445
 446     xmlUnlinkNode(child_node->node);
 447     child_node->parent = NULL;
 448
 449     if(oldChild)
 450     {
 451         IXMLDOMNode_AddRef(child);
 452         *oldChild = child;
 453     }
 454
 455     return S_OK;
 456 }
 457
 458 HRESULT node_append_child(xmlnode *This, IXMLDOMNode *child, IXMLDOMNode **outChild)
 459 {
 460     DOMNodeType type;
 461     VARIANT var;
 462     HRESULT hr;
 463
 464     hr = IXMLDOMNode_get_nodeType(child, &type);
 465     if(FAILED(hr) || type == NODE_ATTRIBUTE) {
 466         if (outChild) *outChild = NULL;
 467         return E_FAIL;
 468     }
 469
 470     VariantInit(&var);
 471     return IXMLDOMNode_insertBefore(This->iface, child, var, outChild);
 472 }
 473
 474 HRESULT node_has_childnodes(const xmlnode *This, VARIANT_BOOL *ret)
 475 {
 476     if (!ret) return E_INVALIDARG;
 477
 478     if (!This->node->children)
 479     {
 480         *ret = VARIANT_FALSE;
 481         return S_FALSE;
 482     }
 483
 484     *ret = VARIANT_TRUE;
 485     return S_OK;
 486 }
 487
 488 HRESULT node_get_owner_doc(const xmlnode *This, IXMLDOMDocument **doc)
 489 {
 490     return get_domdoc_from_xmldoc(This->node->doc, (IXMLDOMDocument3**)doc);
 491 }
 492
 493 HRESULT node_clone(xmlnode *This, VARIANT_BOOL deep, IXMLDOMNode **cloneNode)
 494 {
 495     IXMLDOMNode *node;
 496     xmlNodePtr clone;
 497
 498     if(!cloneNode) return E_INVALIDARG;
 499
 500     clone = xmlCopyNode(This->node, deep ? 1 : 2);
 501     if (clone)
 502     {
 503         clone->doc = This->node->doc;
 504         xmldoc_add_orphan(clone->doc, clone);
 505
 506         node = create_node(clone);
 507         if (!node)
 508         {
 509             ERR("Copy failed\n");
 510             return E_FAIL;
 511         }
 512
 513         *cloneNode = node;
 514     }
 515     else
 516     {
 517         ERR("Copy failed\n");
 518         return E_FAIL;
 519     }
 520
 521     return S_OK;
 522 }
 523
 524 static inline xmlChar* trim_whitespace(xmlChar* str)
 525 {
 526     xmlChar* ret = str;
 527     int len;
 528
 529     if (!str)
 530         return NULL;
 531
 532     while (*ret && isspace(*ret))
 533         ++ret;
 534     len = xmlStrlen(ret);
 535     if (len)
 536         while (isspace(ret[len-1])) --len;
 537
 538     ret = xmlStrndup(ret, len);
 539     xmlFree(str);
 540     return ret;
 541 }
 542
 543 static xmlChar* do_get_text(xmlNodePtr node)
 544 {
 545     xmlNodePtr child;
 546     xmlChar* str;
 547     BOOL preserving = is_preserving_whitespace(node);
 548
 549     if (!node->children)
 550     {
 551         str = xmlNodeGetContent(node);
 552     }
 553     else
 554     {
 555         xmlElementType prev_type = XML_TEXT_NODE;
 556         xmlChar* tmp;
 557         str = xmlStrdup(BAD_CAST "");
 558         for (child = node->children; child != NULL; child = child->next)
 559         {
 560             switch (child->type)
 561             {
 562             case XML_ELEMENT_NODE:
 563                 tmp = do_get_text(child);
 564                 break;
 565             case XML_TEXT_NODE:
 566             case XML_CDATA_SECTION_NODE:
 567             case XML_ENTITY_REF_NODE:
 568             case XML_ENTITY_NODE:
 569                 tmp = xmlNodeGetContent(child);
 570                 break;
 571             default:
 572                 tmp = NULL;
 573                 break;
 574             }
 575
 576             if (tmp)
 577             {
 578                 if (*tmp)
 579                 {
 580                     if (prev_type == XML_ELEMENT_NODE && child->type == XML_ELEMENT_NODE)
 581                         str = xmlStrcat(str, BAD_CAST " ");
 582                     str = xmlStrcat(str, tmp);
 583                     prev_type = child->type;
 584                 }
 585                 xmlFree(tmp);
 586             }
 587         }
 588     }
 589
 590     switch (node->type)
 591     {
 592     case XML_ELEMENT_NODE:
 593     case XML_TEXT_NODE:
 594     case XML_ENTITY_REF_NODE:
 595     case XML_ENTITY_NODE:
 596     case XML_DOCUMENT_NODE:
 597     case XML_DOCUMENT_FRAG_NODE:
 598         if (!preserving)
 599             str = trim_whitespace(str);
 600         break;
 601     default:
 602         break;
 603     }
 604
 605     return str;
 606 }
 607
 608 HRESULT node_get_text(const xmlnode *This, BSTR *text)
 609 {
 610     BSTR str = NULL;
 611     xmlChar *content;
 612
 613     if (!text) return E_INVALIDARG;
 614
 615     content = do_get_text(This->node);
 616     if (content)
 617     {
 618         str = bstr_from_xmlChar(content);
 619         xmlFree(content);
 620     }
 621
 622     /* Always return a string. */
 623     if (!str) str = SysAllocStringLen( NULL, 0 );
 624
 625     TRACE("%p %s\n", This, debugstr_w(str) );
 626     *text = str;
 627
 628     return S_OK;
 629 }
 630
 631 HRESULT node_put_text(xmlnode *This, BSTR text)
 632 {
 633     xmlChar *str, *str2;
 634
 635     TRACE("(%p)->(%s)\n", This, debugstr_w(text));
 636
 637     str = xmlChar_from_wchar(text);
 638
 639     /* Escape the string. */
 640     str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
 641     heap_free(str);
 642
 643     xmlNodeSetContent(This->node, str2);
 644     xmlFree(str2);
 645
 646     return S_OK;
 647 }
 648
 649 static inline BYTE hex_to_byte(xmlChar c)
 650 {
 651     if(c <= '9') return c-'0';
 652     if(c <= 'F') return c-'A'+10;
 653     return c-'a'+10;
 654 }
 655
 656 static inline BYTE base64_to_byte(xmlChar c)
 657 {
 658     if(c == '+') return 62;
 659     if(c == '/') return 63;
 660     if(c <= '9') return c-'0'+52;
 661     if(c <= 'Z') return c-'A';
 662     return c-'a'+26;
 663 }
 664
 665 /* TODO: phasing this version out */
 666 static inline HRESULT VARIANT_from_xmlChar(xmlChar *str, VARIANT *v, BSTR type)
 667 {
 668     if(!type || !lstrcmpiW(type, szString) ||
 669             !lstrcmpiW(type, szNumber) || !lstrcmpiW(type, szUUID))
 670     {
 671         V_VT(v) = VT_BSTR;
 672         V_BSTR(v) = bstr_from_xmlChar(str);
 673
 674         if(!V_BSTR(v))
 675             return E_OUTOFMEMORY;
 676     }
 677     else if(!lstrcmpiW(type, szDateTime) || !lstrcmpiW(type, szDateTimeTZ) ||
 678             !lstrcmpiW(type, szDate) || !lstrcmpiW(type, szTime) ||
 679             !lstrcmpiW(type, szTimeTZ))
 680     {
 681         VARIANT src;
 682         WCHAR *p, *e;
 683         SYSTEMTIME st;
 684         DOUBLE date = 0.0;
 685
 686         st.wYear = 1899;
 687         st.wMonth = 12;
 688         st.wDay = 30;
 689         st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 690
 691         V_VT(&src) = VT_BSTR;
 692         V_BSTR(&src) = bstr_from_xmlChar(str);
 693
 694         if(!V_BSTR(&src))
 695             return E_OUTOFMEMORY;
 696
 697         p = V_BSTR(&src);
 698         e = p + SysStringLen(V_BSTR(&src));
 699
 700         if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */
 701         {
 702             st.wYear = atoiW(p);
 703             st.wMonth = atoiW(p+5);
 704             st.wDay = atoiW(p+8);
 705             p += 10;
 706
 707             if(*p == 'T') p++;
 708         }
 709
 710         if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */
 711         {
 712             st.wHour = atoiW(p);
 713             st.wMinute = atoiW(p+3);
 714             st.wSecond = atoiW(p+6);
 715             p += 8;
 716
 717             if(*p == '.')
 718             {
 719                 p++;
 720                 while(isdigitW(*p)) p++;
 721             }
 722         }
 723
 724         SystemTimeToVariantTime(&st, &date);
 725         V_VT(v) = VT_DATE;
 726         V_DATE(v) = date;
 727
 728         if(*p == '+') /* parse timezone offset (+hh:mm) */
 729             V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 730         else if(*p == '-') /* parse timezone offset (-hh:mm) */
 731             V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 732
 733         VariantClear(&src);
 734     }
 735     else if(!lstrcmpiW(type, szBinHex))
 736     {
 737         SAFEARRAYBOUND sab;
 738         int i, len;
 739
 740         len = xmlStrlen(str)/2;
 741         sab.lLbound = 0;
 742         sab.cElements = len;
 743
 744         V_VT(v) = (VT_ARRAY|VT_UI1);
 745         V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 746
 747         if(!V_ARRAY(v))
 748             return E_OUTOFMEMORY;
 749
 750         for(i=0; i<len; i++)
 751             ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4)
 752                 + hex_to_byte(str[2*i+1]);
 753     }
 754     else if(!lstrcmpiW(type, szBinBase64))
 755     {
 756         SAFEARRAYBOUND sab;
 757         int i, len;
 758
 759         len  = xmlStrlen(str);
 760         if(str[len-2] == '=') i = 2;
 761         else if(str[len-1] == '=') i = 1;
 762         else i = 0;
 763
 764         sab.lLbound = 0;
 765         sab.cElements = len/4*3-i;
 766
 767         V_VT(v) = (VT_ARRAY|VT_UI1);
 768         V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 769
 770         if(!V_ARRAY(v))
 771             return E_OUTOFMEMORY;
 772
 773         for(i=0; i<len/4; i++)
 774         {
 775             ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2)
 776                 + (base64_to_byte(str[4*i+1])>>4);
 777             if(3*i+1 < sab.cElements)
 778                 ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4)
 779                     + (base64_to_byte(str[4*i+2])>>2);
 780             if(3*i+2 < sab.cElements)
 781                 ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6)
 782                     + base64_to_byte(str[4*i+3]);
 783         }
 784     }
 785     else
 786     {
 787         VARIANT src;
 788         HRESULT hres;
 789
 790         if(!lstrcmpiW(type, szInt) || !lstrcmpiW(type, szI4))
 791             V_VT(v) = VT_I4;
 792         else if(!lstrcmpiW(type, szFixed))
 793             V_VT(v) = VT_CY;
 794         else if(!lstrcmpiW(type, szBoolean))
 795             V_VT(v) = VT_BOOL;
 796         else if(!lstrcmpiW(type, szI1))
 797             V_VT(v) = VT_I1;
 798         else if(!lstrcmpiW(type, szI2))
 799             V_VT(v) = VT_I2;
 800         else if(!lstrcmpiW(type, szIU1))
 801             V_VT(v) = VT_UI1;
 802         else if(!lstrcmpiW(type, szIU2))
 803             V_VT(v) = VT_UI2;
 804         else if(!lstrcmpiW(type, szIU4))
 805             V_VT(v) = VT_UI4;
 806         else if(!lstrcmpiW(type, szR4))
 807             V_VT(v) = VT_R4;
 808         else if(!lstrcmpiW(type, szR8) || !lstrcmpiW(type, szFloat))
 809             V_VT(v) = VT_R8;
 810         else
 811         {
 812             FIXME("Type handling not yet implemented\n");
 813             V_VT(v) = VT_BSTR;
 814         }
 815
 816         V_VT(&src) = VT_BSTR;
 817         V_BSTR(&src) = bstr_from_xmlChar(str);
 818
 819         if(!V_BSTR(&src))
 820             return E_OUTOFMEMORY;
 821
 822         hres = VariantChangeTypeEx(v, &src, MAKELCID(MAKELANGID(
 823                         LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v));
 824         VariantClear(&src);
 825         return hres;
 826     }
 827
 828     return S_OK;
 829 }
 830
 831 BSTR EnsureCorrectEOL(BSTR sInput)
 832 {
 833     int nNum = 0;
 834     BSTR sNew;
 835     int nLen;
 836     int i;
 837
 838     nLen = SysStringLen(sInput);
 839     /* Count line endings */
 840     for(i=0; i < nLen; i++)
 841     {
 842         if(sInput[i] == '\n')
 843             nNum++;
 844     }
 845
 846     TRACE("len=%d, num=%d\n", nLen, nNum);
 847
 848     /* Add linefeed as needed */
 849     if(nNum > 0)
 850     {
 851         int nPlace = 0;
 852         sNew = SysAllocStringLen(NULL, nLen + nNum+1);
 853         for(i=0; i < nLen; i++)
 854         {
 855             if(sInput[i] == '\n')
 856             {
 857                 sNew[i+nPlace] = '\r';
 858                 nPlace++;
 859             }
 860             sNew[i+nPlace] = sInput[i];
 861         }
 862
 863         SysFreeString(sInput);
 864     }
 865     else
 866     {
 867         sNew = sInput;
 868     }
 869
 870     TRACE("len %d\n", SysStringLen(sNew));
 871
 872     return sNew;
 873 }
 874
 875 /* Removes encoding information and last character (nullbyte) */
 876 static BSTR EnsureNoEncoding(BSTR sInput)
 877 {
 878     static const WCHAR wszEncoding[] = {'e','n','c','o','d','i','n','g','='};
 879     BSTR sNew;
 880     WCHAR *pBeg, *pEnd;
 881
 882     pBeg = sInput;
 883     while(*pBeg != '\n' && memcmp(pBeg, wszEncoding, sizeof(wszEncoding)))
 884         pBeg++;
 885
 886     if(*pBeg == '\n')
 887     {
 888         SysReAllocStringLen(&sInput, sInput, SysStringLen(sInput)-1);
 889         return sInput;
 890     }
 891     pBeg--;
 892
 893     pEnd = pBeg + sizeof(wszEncoding)/sizeof(WCHAR) + 2;
 894     while(*pEnd != '\"') pEnd++;
 895     pEnd++;
 896
 897     sNew = SysAllocStringLen(NULL,
 898             pBeg-sInput + SysStringLen(sInput)-(pEnd-sInput)-1);
 899     memcpy(sNew, sInput, (pBeg-sInput)*sizeof(WCHAR));
 900     memcpy(&sNew[pBeg-sInput], pEnd, (SysStringLen(sInput)-(pEnd-sInput)-1)*sizeof(WCHAR));
 901
 902     SysFreeString(sInput);
 903     return sNew;
 904 }
 905
 906 /*
 907  * We are trying to replicate the same behaviour as msxml by converting
 908  * line endings to \r\n and using indents as \t. The problem is that msxml
 909  * only formats nodes that have a line ending. Using libxml we cannot
 910  * reproduce behaviour exactly.
 911  *
 912  */
 913 HRESULT node_get_xml(xmlnode *This, BOOL ensure_eol, BOOL ensure_no_encoding, BSTR *ret)
 914 {
 915     xmlBufferPtr xml_buf;
 916     xmlNodePtr xmldecl;
 917     int size;
 918
 919     if(!ret)
 920         return E_INVALIDARG;
 921
 922     *ret = NULL;
 923
 924     xml_buf = xmlBufferCreate();
 925     if(!xml_buf)
 926         return E_OUTOFMEMORY;
 927
 928     xmldecl = xmldoc_unlink_xmldecl( This->node->doc );
 929
 930     size = xmlNodeDump(xml_buf, This->node->doc, This->node, 0, 1);
 931     if(size > 0) {
 932         const xmlChar *buf_content;
 933         BSTR content;
 934
 935         /* Attribute Nodes return a space in front of their name */
 936         buf_content = xmlBufferContent(xml_buf);
 937
 938         content = bstr_from_xmlChar(buf_content + (buf_content[0] == ' ' ? 1 : 0));
 939         if(ensure_eol)
 940             content = EnsureCorrectEOL(content);
 941         if(ensure_no_encoding)
 942             content = EnsureNoEncoding(content);
 943
 944         *ret = content;
 945     }else {
 946         *ret = SysAllocStringLen(NULL, 0);
 947     }
 948
 949     xmlBufferFree(xml_buf);
 950     xmldoc_link_xmldecl( This->node->doc, xmldecl );
 951     return *ret ? S_OK : E_OUTOFMEMORY;
 952 }
 953
 954 HRESULT node_transform_node(const xmlnode *This, IXMLDOMNode *stylesheet, BSTR *p)
 955 {
 956 #ifdef SONAME_LIBXSLT
 957     xsltStylesheetPtr xsltSS;
 958     xmlnode *sheet;
 959
 960     if (!libxslt_handle) return E_NOTIMPL;
 961     if (!stylesheet || !p) return E_INVALIDARG;
 962
 963     *p = NULL;
 964
 965     sheet = get_node_obj(stylesheet);
 966     if(!sheet) return E_FAIL;
 967
 968     xsltSS = pxsltParseStylesheetDoc(sheet->node->doc);
 969     if(xsltSS)
 970     {
 971         xmlDocPtr result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
 972         if(result)
 973         {
 974             const xmlChar *content;
 975
 976             if(result->type == XML_HTML_DOCUMENT_NODE)
 977             {
 978                 xmlOutputBufferPtr output = xmlAllocOutputBuffer(NULL);
 979                 if (output)
 980                 {
 981                     htmlDocContentDumpOutput(output, result->doc, NULL);
 982                     content = xmlBufferContent(output->buffer);
 983                     *p = bstr_from_xmlChar(content);
 984                     xmlOutputBufferClose(output);
 985                 }
 986             }
 987             else
 988             {
 989                 xmlBufferPtr buf = xmlBufferCreate();
 990                 if (buf)
 991                 {
 992                     int size = xmlNodeDump(buf, NULL, (xmlNodePtr)result, 0, 0);
 993                     if(size > 0)
 994                     {
 995                         content = xmlBufferContent(buf);
 996                         *p = bstr_from_xmlChar(content);
 997                     }
 998                     xmlBufferFree(buf);
 999                 }
1000             }
1001             xmlFreeDoc(result);
1002         }
1003         /* libxslt "helpfully" frees the XML document the stylesheet was
1004            generated from, too */
1005         xsltSS->doc = NULL;
1006         pxsltFreeStylesheet(xsltSS);
1007     }
1008
1009     if(!*p) *p = SysAllocStringLen(NULL, 0);
1010
1011     return S_OK;
1012 #else
1013     FIXME("libxslt headers were not found at compile time\n");
1014     return E_NOTIMPL;
1015 #endif
1016 }
1017
1018 HRESULT node_select_nodes(const xmlnode *This, BSTR query, IXMLDOMNodeList **nodes)
1019 {
1020     xmlChar* str;
1021     HRESULT hr;
1022
1023     if (!query || !nodes) return E_INVALIDARG;
1024
1025     str = xmlChar_from_wchar(query);
1026     hr = queryresult_create(This->node, str, nodes);
1027     heap_free(str);
1028
1029     return hr;
1030 }
1031
1032 HRESULT node_select_singlenode(const xmlnode *This, BSTR query, IXMLDOMNode **node)
1033 {
1034     IXMLDOMNodeList *list;
1035     HRESULT hr;
1036
1037     hr = node_select_nodes(This, query, &list);
1038     if (hr == S_OK)
1039     {
1040         hr = IXMLDOMNodeList_nextNode(list, node);
1041         IXMLDOMNodeList_Release(list);
1042     }
1043     return hr;
1044 }
1045
1046 HRESULT node_get_namespaceURI(xmlnode *This, BSTR *namespaceURI)
1047 {
1048     xmlNsPtr *ns;
1049
1050     if(!namespaceURI)
1051         return E_INVALIDARG;
1052
1053     *namespaceURI = NULL;
1054
1055     if ((ns = xmlGetNsList(This->node->doc, This->node)))
1056     {
1057         if (ns[0]->href) *namespaceURI = bstr_from_xmlChar( ns[0]->href );
1058         xmlFree(ns);
1059     }
1060
1061     TRACE("uri: %s\n", debugstr_w(*namespaceURI));
1062
1063     return *namespaceURI ? S_OK : S_FALSE;
1064 }
1065
1066 HRESULT node_get_prefix(xmlnode *This, BSTR *prefix)
1067 {
1068     xmlNsPtr *ns;
1069
1070     if (!prefix) return E_INVALIDARG;
1071
1072     *prefix = NULL;
1073
1074     if ((ns = xmlGetNsList(This->node->doc, This->node)))
1075     {
1076         if (ns[0]->prefix) *prefix = bstr_from_xmlChar( ns[0]->prefix );
1077         xmlFree(ns);
1078     }
1079
1080     TRACE("prefix: %s\n", debugstr_w(*prefix));
1081
1082     return *prefix ? S_OK : S_FALSE;
1083 }
1084
1085 HRESULT node_get_base_name(xmlnode *This, BSTR *name)
1086 {
1087     if (!name) return E_INVALIDARG;
1088
1089     *name = bstr_from_xmlChar(This->node->name);
1090     if (!*name) return E_OUTOFMEMORY;
1091
1092     TRACE("returning %s\n", debugstr_w(*name));
1093
1094     return S_OK;
1095 }
1096
1097 void destroy_xmlnode(xmlnode *This)
1098 {
1099     if(This->node)
1100         xmldoc_release(This->node->doc);
1101 }
1102
1103 void init_xmlnode(xmlnode *This, xmlNodePtr node, IXMLDOMNode *node_iface, dispex_static_data_t *dispex_data)
1104 {
1105     if(node)
1106         xmldoc_add_ref( node->doc );
1107
1108     This->node = node;
1109     This->iface = node_iface;
1110     This->parent = NULL;
1111
1112     if(dispex_data)
1113         init_dispex(&This->dispex, (IUnknown*)This->iface, dispex_data);
1114     else
1115         This->dispex.outer = NULL;
1116 }
1117
1118 typedef struct {
1119     xmlnode node;
1120     IXMLDOMNode IXMLDOMNode_iface;
1121     LONG ref;
1122 } unknode;
1123
1124 static inline unknode *unknode_from_IXMLDOMNode(IXMLDOMNode *iface)
1125 {
1126     return CONTAINING_RECORD(iface, unknode, IXMLDOMNode_iface);
1127 }
1128
1129 static HRESULT WINAPI unknode_QueryInterface(
1130     IXMLDOMNode *iface,
1131     REFIID riid,
1132     void** ppvObject )
1133 {
1134     unknode *This = unknode_from_IXMLDOMNode( iface );
1135
1136     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1137
1138     if (IsEqualGUID(riid, &IID_IUnknown)) {
1139         *ppvObject = iface;
1140     }else if (IsEqualGUID( riid, &IID_IDispatch) ||
1141               IsEqualGUID( riid, &IID_IXMLDOMNode)) {
1142         *ppvObject = &This->IXMLDOMNode_iface;
1143     }else if(node_query_interface(&This->node, riid, ppvObject)) {
1144         return *ppvObject ? S_OK : E_NOINTERFACE;
1145     }else  {
1146         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1147         *ppvObject = NULL;
1148         return E_NOINTERFACE;
1149     }
1150
1151     IUnknown_AddRef((IUnknown*)*ppvObject);
1152     return S_OK;
1153 }
1154
1155 static ULONG WINAPI unknode_AddRef(
1156     IXMLDOMNode *iface )
1157 {
1158     unknode *This = unknode_from_IXMLDOMNode( iface );
1159
1160     return InterlockedIncrement(&This->ref);
1161 }
1162
1163 static ULONG WINAPI unknode_Release(
1164     IXMLDOMNode *iface )
1165 {
1166     unknode *This = unknode_from_IXMLDOMNode( iface );
1167     LONG ref;
1168
1169     ref = InterlockedDecrement( &This->ref );
1170     if(!ref) {
1171         destroy_xmlnode(&This->node);
1172         heap_free(This);
1173     }
1174
1175     return ref;
1176 }
1177
1178 static HRESULT WINAPI unknode_GetTypeInfoCount(
1179     IXMLDOMNode *iface,
1180     UINT* pctinfo )
1181 {
1182     unknode *This = unknode_from_IXMLDOMNode( iface );
1183
1184     TRACE("(%p)->(%p)\n", This, pctinfo);
1185
1186     *pctinfo = 1;
1187
1188     return S_OK;
1189 }
1190
1191 static HRESULT WINAPI unknode_GetTypeInfo(
1192     IXMLDOMNode *iface,
1193     UINT iTInfo,
1194     LCID lcid,
1195     ITypeInfo** ppTInfo )
1196 {
1197     unknode *This = unknode_from_IXMLDOMNode( iface );
1198     HRESULT hr;
1199
1200     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1201
1202     hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
1203
1204     return hr;
1205 }
1206
1207 static HRESULT WINAPI unknode_GetIDsOfNames(
1208     IXMLDOMNode *iface,
1209     REFIID riid,
1210     LPOLESTR* rgszNames,
1211     UINT cNames,
1212     LCID lcid,
1213     DISPID* rgDispId )
1214 {
1215     unknode *This = unknode_from_IXMLDOMNode( iface );
1216
1217     ITypeInfo *typeinfo;
1218     HRESULT hr;
1219
1220     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1221           lcid, rgDispId);
1222
1223     if(!rgszNames || cNames == 0 || !rgDispId)
1224         return E_INVALIDARG;
1225
1226     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1227     if(SUCCEEDED(hr))
1228     {
1229         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1230         ITypeInfo_Release(typeinfo);
1231     }
1232
1233     return hr;
1234 }
1235
1236 static HRESULT WINAPI unknode_Invoke(
1237     IXMLDOMNode *iface,
1238     DISPID dispIdMember,
1239     REFIID riid,
1240     LCID lcid,
1241     WORD wFlags,
1242     DISPPARAMS* pDispParams,
1243     VARIANT* pVarResult,
1244     EXCEPINFO* pExcepInfo,
1245     UINT* puArgErr )
1246 {
1247     unknode *This = unknode_from_IXMLDOMNode( iface );
1248     ITypeInfo *typeinfo;
1249     HRESULT hr;
1250
1251     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1252           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1253
1254     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1255     if(SUCCEEDED(hr))
1256     {
1257         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMNode_iface, dispIdMember, wFlags, pDispParams,
1258                 pVarResult, pExcepInfo, puArgErr);
1259         ITypeInfo_Release(typeinfo);
1260     }
1261
1262     return hr;
1263 }
1264
1265 static HRESULT WINAPI unknode_get_nodeName(
1266     IXMLDOMNode *iface,
1267     BSTR* p )
1268 {
1269     unknode *This = unknode_from_IXMLDOMNode( iface );
1270
1271     FIXME("(%p)->(%p)\n", This, p);
1272
1273     return node_get_nodeName(&This->node, p);
1274 }
1275
1276 static HRESULT WINAPI unknode_get_nodeValue(
1277     IXMLDOMNode *iface,
1278     VARIANT* value)
1279 {
1280     unknode *This = unknode_from_IXMLDOMNode( iface );
1281
1282     FIXME("(%p)->(%p)\n", This, value);
1283
1284     if(!value)
1285         return E_INVALIDARG;
1286
1287     V_VT(value) = VT_NULL;
1288     return S_FALSE;
1289 }
1290
1291 static HRESULT WINAPI unknode_put_nodeValue(
1292     IXMLDOMNode *iface,
1293     VARIANT value)
1294 {
1295     unknode *This = unknode_from_IXMLDOMNode( iface );
1296     FIXME("(%p)->(v%d)\n", This, V_VT(&value));
1297     return E_FAIL;
1298 }
1299
1300 static HRESULT WINAPI unknode_get_nodeType(
1301     IXMLDOMNode *iface,
1302     DOMNodeType* domNodeType )
1303 {
1304     unknode *This = unknode_from_IXMLDOMNode( iface );
1305
1306     FIXME("(%p)->(%p)\n", This, domNodeType);
1307
1308     *domNodeType = This->node.node->type;
1309     return S_OK;
1310 }
1311
1312 static HRESULT WINAPI unknode_get_parentNode(
1313     IXMLDOMNode *iface,
1314     IXMLDOMNode** parent )
1315 {
1316     unknode *This = unknode_from_IXMLDOMNode( iface );
1317     FIXME("(%p)->(%p)\n", This, parent);
1318     if (!parent) return E_INVALIDARG;
1319     *parent = NULL;
1320     return S_FALSE;
1321 }
1322
1323 static HRESULT WINAPI unknode_get_childNodes(
1324     IXMLDOMNode *iface,
1325     IXMLDOMNodeList** outList)
1326 {
1327     unknode *This = unknode_from_IXMLDOMNode( iface );
1328
1329     TRACE("(%p)->(%p)\n", This, outList);
1330
1331     return node_get_child_nodes(&This->node, outList);
1332 }
1333
1334 static HRESULT WINAPI unknode_get_firstChild(
1335     IXMLDOMNode *iface,
1336     IXMLDOMNode** domNode)
1337 {
1338     unknode *This = unknode_from_IXMLDOMNode( iface );
1339
1340     TRACE("(%p)->(%p)\n", This, domNode);
1341
1342     return node_get_first_child(&This->node, domNode);
1343 }
1344
1345 static HRESULT WINAPI unknode_get_lastChild(
1346     IXMLDOMNode *iface,
1347     IXMLDOMNode** domNode)
1348 {
1349     unknode *This = unknode_from_IXMLDOMNode( iface );
1350
1351     TRACE("(%p)->(%p)\n", This, domNode);
1352
1353     return node_get_last_child(&This->node, domNode);
1354 }
1355
1356 static HRESULT WINAPI unknode_get_previousSibling(
1357     IXMLDOMNode *iface,
1358     IXMLDOMNode** domNode)
1359 {
1360     unknode *This = unknode_from_IXMLDOMNode( iface );
1361
1362     TRACE("(%p)->(%p)\n", This, domNode);
1363
1364     return node_get_previous_sibling(&This->node, domNode);
1365 }
1366
1367 static HRESULT WINAPI unknode_get_nextSibling(
1368     IXMLDOMNode *iface,
1369     IXMLDOMNode** domNode)
1370 {
1371     unknode *This = unknode_from_IXMLDOMNode( iface );
1372
1373     TRACE("(%p)->(%p)\n", This, domNode);
1374
1375     return node_get_next_sibling(&This->node, domNode);
1376 }
1377
1378 static HRESULT WINAPI unknode_get_attributes(
1379     IXMLDOMNode *iface,
1380     IXMLDOMNamedNodeMap** attributeMap)
1381 {
1382     unknode *This = unknode_from_IXMLDOMNode( iface );
1383
1384     FIXME("(%p)->(%p)\n", This, attributeMap);
1385
1386     return return_null_ptr((void**)attributeMap);
1387 }
1388
1389 static HRESULT WINAPI unknode_insertBefore(
1390     IXMLDOMNode *iface,
1391     IXMLDOMNode* newNode, VARIANT refChild,
1392     IXMLDOMNode** outOldNode)
1393 {
1394     unknode *This = unknode_from_IXMLDOMNode( iface );
1395
1396     FIXME("(%p)->(%p x%d %p)\n", This, newNode, V_VT(&refChild), outOldNode);
1397
1398     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
1399 }
1400
1401 static HRESULT WINAPI unknode_replaceChild(
1402     IXMLDOMNode *iface,
1403     IXMLDOMNode* newNode,
1404     IXMLDOMNode* oldNode,
1405     IXMLDOMNode** outOldNode)
1406 {
1407     unknode *This = unknode_from_IXMLDOMNode( iface );
1408
1409     FIXME("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
1410
1411     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
1412 }
1413
1414 static HRESULT WINAPI unknode_removeChild(
1415     IXMLDOMNode *iface,
1416     IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
1417 {
1418     unknode *This = unknode_from_IXMLDOMNode( iface );
1419     return node_remove_child(&This->node, domNode, oldNode);
1420 }
1421
1422 static HRESULT WINAPI unknode_appendChild(
1423     IXMLDOMNode *iface,
1424     IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
1425 {
1426     unknode *This = unknode_from_IXMLDOMNode( iface );
1427     return node_append_child(&This->node, newNode, outNewNode);
1428 }
1429
1430 static HRESULT WINAPI unknode_hasChildNodes(
1431     IXMLDOMNode *iface,
1432     VARIANT_BOOL* pbool)
1433 {
1434     unknode *This = unknode_from_IXMLDOMNode( iface );
1435     return node_has_childnodes(&This->node, pbool);
1436 }
1437
1438 static HRESULT WINAPI unknode_get_ownerDocument(
1439     IXMLDOMNode *iface,
1440     IXMLDOMDocument** domDocument)
1441 {
1442     unknode *This = unknode_from_IXMLDOMNode( iface );
1443     return node_get_owner_doc(&This->node, domDocument);
1444 }
1445
1446 static HRESULT WINAPI unknode_cloneNode(
1447     IXMLDOMNode *iface,
1448     VARIANT_BOOL pbool, IXMLDOMNode** outNode)
1449 {
1450     unknode *This = unknode_from_IXMLDOMNode( iface );
1451     return node_clone(&This->node, pbool, outNode );
1452 }
1453
1454 static HRESULT WINAPI unknode_get_nodeTypeString(
1455     IXMLDOMNode *iface,
1456     BSTR* p)
1457 {
1458     unknode *This = unknode_from_IXMLDOMNode( iface );
1459
1460     FIXME("(%p)->(%p)\n", This, p);
1461
1462     return node_get_nodeName(&This->node, p);
1463 }
1464
1465 static HRESULT WINAPI unknode_get_text(
1466     IXMLDOMNode *iface,
1467     BSTR* p)
1468 {
1469     unknode *This = unknode_from_IXMLDOMNode( iface );
1470     return node_get_text(&This->node, p);
1471 }
1472
1473 static HRESULT WINAPI unknode_put_text(
1474     IXMLDOMNode *iface,
1475     BSTR p)
1476 {
1477     unknode *This = unknode_from_IXMLDOMNode( iface );
1478     return node_put_text(&This->node, p);
1479 }
1480
1481 static HRESULT WINAPI unknode_get_specified(
1482     IXMLDOMNode *iface,
1483     VARIANT_BOOL* isSpecified)
1484 {
1485     unknode *This = unknode_from_IXMLDOMNode( iface );
1486     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1487     *isSpecified = VARIANT_TRUE;
1488     return S_OK;
1489 }
1490
1491 static HRESULT WINAPI unknode_get_definition(
1492     IXMLDOMNode *iface,
1493     IXMLDOMNode** definitionNode)
1494 {
1495     unknode *This = unknode_from_IXMLDOMNode( iface );
1496     FIXME("(%p)->(%p)\n", This, definitionNode);
1497     return E_NOTIMPL;
1498 }
1499
1500 static HRESULT WINAPI unknode_get_nodeTypedValue(
1501     IXMLDOMNode *iface,
1502     VARIANT* var1)
1503 {
1504     unknode *This = unknode_from_IXMLDOMNode( iface );
1505     FIXME("(%p)->(%p)\n", This, var1);
1506     return return_null_var(var1);
1507 }
1508
1509 static HRESULT WINAPI unknode_put_nodeTypedValue(
1510     IXMLDOMNode *iface,
1511     VARIANT typedValue)
1512 {
1513     unknode *This = unknode_from_IXMLDOMNode( iface );
1514     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
1515     return E_NOTIMPL;
1516 }
1517
1518 static HRESULT WINAPI unknode_get_dataType(
1519     IXMLDOMNode *iface,
1520     VARIANT* var1)
1521 {
1522     unknode *This = unknode_from_IXMLDOMNode( iface );
1523     TRACE("(%p)->(%p)\n", This, var1);
1524     return return_null_var(var1);
1525 }
1526
1527 static HRESULT WINAPI unknode_put_dataType(
1528     IXMLDOMNode *iface,
1529     BSTR p)
1530 {
1531     unknode *This = unknode_from_IXMLDOMNode( iface );
1532
1533     FIXME("(%p)->(%s)\n", This, debugstr_w(p));
1534
1535     if(!p)
1536         return E_INVALIDARG;
1537
1538     return E_FAIL;
1539 }
1540
1541 static HRESULT WINAPI unknode_get_xml(
1542     IXMLDOMNode *iface,
1543     BSTR* p)
1544 {
1545     unknode *This = unknode_from_IXMLDOMNode( iface );
1546
1547     FIXME("(%p)->(%p)\n", This, p);
1548
1549     return node_get_xml(&This->node, FALSE, FALSE, p);
1550 }
1551
1552 static HRESULT WINAPI unknode_transformNode(
1553     IXMLDOMNode *iface,
1554     IXMLDOMNode* domNode, BSTR* p)
1555 {
1556     unknode *This = unknode_from_IXMLDOMNode( iface );
1557     return node_transform_node(&This->node, domNode, p);
1558 }
1559
1560 static HRESULT WINAPI unknode_selectNodes(
1561     IXMLDOMNode *iface,
1562     BSTR p, IXMLDOMNodeList** outList)
1563 {
1564     unknode *This = unknode_from_IXMLDOMNode( iface );
1565     return node_select_nodes(&This->node, p, outList);
1566 }
1567
1568 static HRESULT WINAPI unknode_selectSingleNode(
1569     IXMLDOMNode *iface,
1570     BSTR p, IXMLDOMNode** outNode)
1571 {
1572     unknode *This = unknode_from_IXMLDOMNode( iface );
1573     return node_select_singlenode(&This->node, p, outNode);
1574 }
1575
1576 static HRESULT WINAPI unknode_get_parsed(
1577     IXMLDOMNode *iface,
1578     VARIANT_BOOL* isParsed)
1579 {
1580     unknode *This = unknode_from_IXMLDOMNode( iface );
1581     FIXME("(%p)->(%p) stub!\n", This, isParsed);
1582     *isParsed = VARIANT_TRUE;
1583     return S_OK;
1584 }
1585
1586 static HRESULT WINAPI unknode_get_namespaceURI(
1587     IXMLDOMNode *iface,
1588     BSTR* p)
1589 {
1590     unknode *This = unknode_from_IXMLDOMNode( iface );
1591     TRACE("(%p)->(%p)\n", This, p);
1592     return node_get_namespaceURI(&This->node, p);
1593 }
1594
1595 static HRESULT WINAPI unknode_get_prefix(
1596     IXMLDOMNode *iface,
1597     BSTR* p)
1598 {
1599     unknode *This = unknode_from_IXMLDOMNode( iface );
1600     return node_get_prefix(&This->node, p);
1601 }
1602
1603 static HRESULT WINAPI unknode_get_baseName(
1604     IXMLDOMNode *iface,
1605     BSTR* p)
1606 {
1607     unknode *This = unknode_from_IXMLDOMNode( iface );
1608     return node_get_base_name(&This->node, p);
1609 }
1610
1611 static HRESULT WINAPI unknode_transformNodeToObject(
1612     IXMLDOMNode *iface,
1613     IXMLDOMNode* domNode, VARIANT var1)
1614 {
1615     unknode *This = unknode_from_IXMLDOMNode( iface );
1616     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1617     return E_NOTIMPL;
1618 }
1619
1620 static const struct IXMLDOMNodeVtbl unknode_vtbl =
1621 {
1622     unknode_QueryInterface,
1623     unknode_AddRef,
1624     unknode_Release,
1625     unknode_GetTypeInfoCount,
1626     unknode_GetTypeInfo,
1627     unknode_GetIDsOfNames,
1628     unknode_Invoke,
1629     unknode_get_nodeName,
1630     unknode_get_nodeValue,
1631     unknode_put_nodeValue,
1632     unknode_get_nodeType,
1633     unknode_get_parentNode,
1634     unknode_get_childNodes,
1635     unknode_get_firstChild,
1636     unknode_get_lastChild,
1637     unknode_get_previousSibling,
1638     unknode_get_nextSibling,
1639     unknode_get_attributes,
1640     unknode_insertBefore,
1641     unknode_replaceChild,
1642     unknode_removeChild,
1643     unknode_appendChild,
1644     unknode_hasChildNodes,
1645     unknode_get_ownerDocument,
1646     unknode_cloneNode,
1647     unknode_get_nodeTypeString,
1648     unknode_get_text,
1649     unknode_put_text,
1650     unknode_get_specified,
1651     unknode_get_definition,
1652     unknode_get_nodeTypedValue,
1653     unknode_put_nodeTypedValue,
1654     unknode_get_dataType,
1655     unknode_put_dataType,
1656     unknode_get_xml,
1657     unknode_transformNode,
1658     unknode_selectNodes,
1659     unknode_selectSingleNode,
1660     unknode_get_parsed,
1661     unknode_get_namespaceURI,
1662     unknode_get_prefix,
1663     unknode_get_baseName,
1664     unknode_transformNodeToObject
1665 };
1666
1667 IXMLDOMNode *create_node( xmlNodePtr node )
1668 {
1669     IUnknown *pUnk;
1670     IXMLDOMNode *ret;
1671     HRESULT hr;
1672
1673     if ( !node )
1674         return NULL;
1675
1676     TRACE("type %d\n", node->type);
1677     switch(node->type)
1678     {
1679     case XML_ELEMENT_NODE:
1680         pUnk = create_element( node );
1681         break;
1682     case XML_ATTRIBUTE_NODE:
1683         pUnk = create_attribute( node );
1684         break;
1685     case XML_TEXT_NODE:
1686         pUnk = create_text( node );
1687         break;
1688     case XML_CDATA_SECTION_NODE:
1689         pUnk = create_cdata( node );
1690         break;
1691     case XML_ENTITY_REF_NODE:
1692         pUnk = create_doc_entity_ref( node );
1693         break;
1694     case XML_PI_NODE:
1695         pUnk = create_pi( node );
1696         break;
1697     case XML_COMMENT_NODE:
1698         pUnk = create_comment( node );
1699         break;
1700     case XML_DOCUMENT_NODE:
1701         pUnk = create_domdoc( node );
1702         break;
1703     case XML_DOCUMENT_FRAG_NODE:
1704         pUnk = create_doc_fragment( node );
1705         break;
1706     case XML_DTD_NODE:
1707         pUnk = create_doc_type( node );
1708         break;
1709     default: {
1710         unknode *new_node;
1711
1712         FIXME("only creating basic node for type %d\n", node->type);
1713
1714         new_node = heap_alloc(sizeof(unknode));
1715         if(!new_node)
1716             return NULL;
1717
1718         new_node->IXMLDOMNode_iface.lpVtbl = &unknode_vtbl;
1719         new_node->ref = 1;
1720         init_xmlnode(&new_node->node, node, &new_node->IXMLDOMNode_iface, NULL);
1721         pUnk = (IUnknown*)&new_node->IXMLDOMNode_iface;
1722     }
1723     }
1724
1725     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
1726     IUnknown_Release(pUnk);
1727     if(FAILED(hr)) return NULL;
1728     return ret;
1729 }
1730 #endif