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