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