msxml3/tests: Avoid a crash that happens on some native systems.
[wine] / 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 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
39
40 #ifdef HAVE_LIBXML2
41
42 typedef struct _xmlnode
43 {
44     const struct IXMLDOMNodeVtbl *lpVtbl;
45     const struct IUnknownVtbl *lpInternalUnkVtbl;
46     IUnknown *pUnkOuter;
47     LONG ref;
48     xmlNodePtr node;
49 } xmlnode;
50
51 static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
52 {
53     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
54 }
55
56 static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
57 {
58     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
59 }
60
61 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
62 {
63     xmlnode *This;
64
65     if ( !iface )
66         return NULL;
67     This = impl_from_IXMLDOMNode( iface );
68     if ( !This->node )
69         return NULL;
70     if ( type && This->node->type != type )
71         return NULL;
72     return This->node;
73 }
74
75 void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xml )
76 {
77     xmlnode *This = impl_from_IXMLDOMNode( node );
78
79     if(This->node)
80         xmldoc_release(This->node->doc);
81
82     This->node = xml;
83     if(This->node)
84         xmldoc_add_ref(This->node->doc);
85
86     return;
87 }
88
89 static HRESULT WINAPI xmlnode_QueryInterface(
90     IXMLDOMNode *iface,
91     REFIID riid,
92     void** ppvObject )
93 {
94     xmlnode *This = impl_from_IXMLDOMNode( iface );
95     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
96
97     return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
98 }
99
100 static ULONG WINAPI xmlnode_AddRef(
101     IXMLDOMNode *iface )
102 {
103     xmlnode *This = impl_from_IXMLDOMNode( iface );
104     return IUnknown_AddRef(This->pUnkOuter);
105 }
106
107 static ULONG WINAPI xmlnode_Release(
108     IXMLDOMNode *iface )
109 {
110     xmlnode *This = impl_from_IXMLDOMNode( iface );
111     return IUnknown_Release(This->pUnkOuter);
112 }
113
114 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
115     IXMLDOMNode *iface,
116     UINT* pctinfo )
117 {
118     FIXME("\n");
119     return E_NOTIMPL;
120 }
121
122 static HRESULT WINAPI xmlnode_GetTypeInfo(
123     IXMLDOMNode *iface,
124     UINT iTInfo,
125     LCID lcid,
126     ITypeInfo** ppTInfo )
127 {
128     FIXME("\n");
129     return E_NOTIMPL;
130 }
131
132 static HRESULT WINAPI xmlnode_GetIDsOfNames(
133     IXMLDOMNode *iface,
134     REFIID riid,
135     LPOLESTR* rgszNames,
136     UINT cNames,
137     LCID lcid,
138     DISPID* rgDispId )
139 {
140     FIXME("\n");
141     return E_NOTIMPL;
142 }
143
144 static HRESULT WINAPI xmlnode_Invoke(
145     IXMLDOMNode *iface,
146     DISPID dispIdMember,
147     REFIID riid,
148     LCID lcid,
149     WORD wFlags,
150     DISPPARAMS* pDispParams,
151     VARIANT* pVarResult,
152     EXCEPINFO* pExcepInfo,
153     UINT* puArgErr )
154 {
155     FIXME("\n");
156     return E_NOTIMPL;
157 }
158
159 static HRESULT WINAPI xmlnode_get_nodeName(
160     IXMLDOMNode *iface,
161     BSTR* name)
162 {
163     xmlnode *This = impl_from_IXMLDOMNode( iface );
164     const xmlChar *str;
165
166     TRACE("%p\n", This );
167
168     if (!name)
169         return E_INVALIDARG;
170
171     if ( !This->node )
172         return E_FAIL;
173
174     switch( This->node->type )
175     {
176     case XML_TEXT_NODE:
177         str = (const xmlChar*) "#text";
178         break;
179     case XML_DOCUMENT_NODE:
180         str = (const xmlChar*) "#document";
181         break;
182     default:
183         str = This->node->name;
184         break;
185     }
186
187     *name = bstr_from_xmlChar( str );
188     if (!*name)
189         return S_FALSE;
190
191     return S_OK;
192 }
193
194 BSTR bstr_from_xmlChar( const xmlChar *buf )
195 {
196     DWORD len;
197     LPWSTR str;
198     BSTR bstr;
199
200     if ( !buf )
201         return NULL;
202
203     len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, NULL, 0 );
204     str = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
205     if ( !str )
206         return NULL;
207     MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, str, len );
208     bstr = SysAllocString( str );
209     HeapFree( GetProcessHeap(), 0, str );
210     return bstr;
211 }
212
213 static HRESULT WINAPI xmlnode_get_nodeValue(
214     IXMLDOMNode *iface,
215     VARIANT* value)
216 {
217     xmlnode *This = impl_from_IXMLDOMNode( iface );
218     HRESULT r = S_FALSE;
219
220     TRACE("%p %p\n", This, value);
221
222     V_BSTR(value) = NULL;
223     V_VT(value) = VT_NULL;
224
225     switch ( This->node->type )
226     {
227     case XML_ATTRIBUTE_NODE:
228       {
229         xmlChar *content = xmlNodeGetContent(This->node);
230         V_VT(value) = VT_BSTR;
231         V_BSTR(value) = bstr_from_xmlChar( content );
232         xmlFree(content);
233         r = S_OK;
234         break;
235       }
236     case XML_TEXT_NODE:
237         V_VT(value) = VT_BSTR;
238         V_BSTR(value) = bstr_from_xmlChar( This->node->content );
239         r = S_OK;
240         break;
241     case XML_ELEMENT_NODE:
242     case XML_DOCUMENT_NODE:
243         /* these seem to return NULL */
244         break;
245     case XML_PI_NODE:
246     default:
247         FIXME("node %p type %d\n", This, This->node->type);
248     }
249  
250     TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
251
252     return r;
253 }
254
255 static HRESULT WINAPI xmlnode_put_nodeValue(
256     IXMLDOMNode *iface,
257     VARIANT value)
258 {
259     FIXME("\n");
260     return E_NOTIMPL;
261 }
262
263 static HRESULT WINAPI xmlnode_get_nodeType(
264     IXMLDOMNode *iface,
265     DOMNodeType* type)
266 {
267     xmlnode *This = impl_from_IXMLDOMNode( iface );
268
269     TRACE("%p %p\n", This, type);
270
271     assert( NODE_ELEMENT == XML_ELEMENT_NODE );
272     assert( NODE_NOTATION == XML_NOTATION_NODE );
273
274     *type = This->node->type;
275
276     return S_OK;
277 }
278
279 static HRESULT get_node(
280     xmlnode *This,
281     const char *name,
282     xmlNodePtr node,
283     IXMLDOMNode **out )
284 {
285     TRACE("%p->%s %p\n", This, name, node );
286
287     if ( !out )
288         return E_INVALIDARG;
289     *out = create_node( node );
290     if (!*out)
291         return S_FALSE;
292     return S_OK;
293 }
294
295 static HRESULT WINAPI xmlnode_get_parentNode(
296     IXMLDOMNode *iface,
297     IXMLDOMNode** parent)
298 {
299     xmlnode *This = impl_from_IXMLDOMNode( iface );
300     return get_node( This, "parent", This->node->parent, parent );
301 }
302
303 static HRESULT WINAPI xmlnode_get_childNodes(
304     IXMLDOMNode *iface,
305     IXMLDOMNodeList** childList)
306 {
307     xmlnode *This = impl_from_IXMLDOMNode( iface );
308
309     TRACE("%p %p\n", This, childList );
310
311     if ( !childList )
312         return E_INVALIDARG;
313
314     *childList = create_children_nodelist(This->node);
315     if (*childList == NULL)
316         return E_OUTOFMEMORY;
317
318     return S_OK;
319 }
320
321 static HRESULT WINAPI xmlnode_get_firstChild(
322     IXMLDOMNode *iface,
323     IXMLDOMNode** firstChild)
324 {
325     xmlnode *This = impl_from_IXMLDOMNode( iface );
326     return get_node( This, "firstChild", This->node->children, firstChild );
327 }
328
329 static HRESULT WINAPI xmlnode_get_lastChild(
330     IXMLDOMNode *iface,
331     IXMLDOMNode** lastChild)
332 {
333     xmlnode *This = impl_from_IXMLDOMNode( iface );
334     return get_node( This, "lastChild", This->node->last, lastChild );
335 }
336
337 static HRESULT WINAPI xmlnode_get_previousSibling(
338     IXMLDOMNode *iface,
339     IXMLDOMNode** previousSibling)
340 {
341     xmlnode *This = impl_from_IXMLDOMNode( iface );
342     return get_node( This, "previous", This->node->prev, previousSibling );
343 }
344
345 static HRESULT WINAPI xmlnode_get_nextSibling(
346     IXMLDOMNode *iface,
347     IXMLDOMNode** nextSibling)
348 {
349     xmlnode *This = impl_from_IXMLDOMNode( iface );
350     return get_node( This, "next", This->node->next, nextSibling );
351 }
352
353 static HRESULT WINAPI xmlnode_get_attributes(
354     IXMLDOMNode *iface,
355     IXMLDOMNamedNodeMap** attributeMap)
356 {
357     xmlnode *This = impl_from_IXMLDOMNode( iface );
358     TRACE("%p\n", This);
359     *attributeMap = create_nodemap( iface );
360     return S_OK;
361 }
362
363 static HRESULT WINAPI xmlnode_insertBefore(
364     IXMLDOMNode *iface,
365     IXMLDOMNode* newChild,
366     VARIANT refChild,
367     IXMLDOMNode** outNewChild)
368 {
369     xmlnode *This = impl_from_IXMLDOMNode( iface );
370     xmlNodePtr before_node, new_child_node;
371     IXMLDOMNode *before = NULL, *new;
372     HRESULT hr;
373
374     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
375
376     if (!(newChild && outNewChild))
377         return E_INVALIDARG;
378
379     switch(V_VT(&refChild))
380     {
381     case VT_EMPTY:
382     case VT_NULL:
383         break;
384
385     case VT_UNKNOWN:
386         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
387         if(FAILED(hr)) return hr;
388         break;
389
390     case VT_DISPATCH:
391         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
392         if(FAILED(hr)) return hr;
393         break;
394
395     default:
396         FIXME("refChild var type %x\n", V_VT(&refChild));
397         return E_FAIL;
398     }
399
400     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
401     new_child_node = impl_from_IXMLDOMNode(new)->node;
402     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
403
404     if(before)
405     {
406         before_node = impl_from_IXMLDOMNode(before)->node;
407         xmlAddPrevSibling(before_node, new_child_node);
408         IXMLDOMNode_Release(before);
409     }
410     else
411     {
412         xmlAddChild(This->node, new_child_node);
413     }
414
415     IXMLDOMNode_Release(new);
416     IXMLDOMNode_AddRef(newChild);
417     *outNewChild = newChild;
418     TRACE("ret S_OK\n");
419     return S_OK;
420 }
421
422 static HRESULT WINAPI xmlnode_replaceChild(
423     IXMLDOMNode *iface,
424     IXMLDOMNode* newChild,
425     IXMLDOMNode* oldChild,
426     IXMLDOMNode** outOldChild)
427 {
428     FIXME("\n");
429     return E_NOTIMPL;
430 }
431
432 static HRESULT WINAPI xmlnode_removeChild(
433     IXMLDOMNode *iface,
434     IXMLDOMNode* childNode,
435     IXMLDOMNode** oldChild)
436 {
437     xmlnode *This = impl_from_IXMLDOMNode( iface );
438     xmlNode *ancestor, *child_node_ptr;
439     HRESULT hr;
440     IXMLDOMNode *child;
441
442     TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
443
444     *oldChild = NULL;
445
446     if(!childNode) return E_INVALIDARG;
447
448     hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
449     if(FAILED(hr))
450         return hr;
451
452     child_node_ptr = ancestor = impl_from_IXMLDOMNode(child)->node;
453     while(ancestor->parent)
454     {
455         if(ancestor->parent == This->node)
456             break;
457         ancestor = ancestor->parent;
458     }
459     if(!ancestor->parent)
460     {
461         WARN("childNode %p is not a child of %p\n", childNode, iface);
462         IXMLDOMNode_Release(child);
463         return E_INVALIDARG;
464     }
465
466     xmlUnlinkNode(child_node_ptr);
467
468     IXMLDOMNode_Release(child);
469     IXMLDOMNode_AddRef(childNode);
470     *oldChild = childNode;
471     return S_OK;
472 }
473
474 static HRESULT WINAPI xmlnode_appendChild(
475     IXMLDOMNode *iface,
476     IXMLDOMNode* newChild,
477     IXMLDOMNode** outNewChild)
478 {
479     xmlnode *This = impl_from_IXMLDOMNode( iface );
480     VARIANT var;
481
482     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
483     VariantInit(&var);
484     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
485 }
486
487 static HRESULT WINAPI xmlnode_hasChildNodes(
488     IXMLDOMNode *iface,
489     VARIANT_BOOL* hasChild)
490 {
491     xmlnode *This = impl_from_IXMLDOMNode( iface );
492
493     TRACE("%p\n", This);
494
495     if (!hasChild)
496         return E_INVALIDARG;
497     if (!This->node->children)
498     {
499         *hasChild = VARIANT_FALSE;
500         return S_FALSE;
501     }
502
503     *hasChild = VARIANT_TRUE;
504     return S_OK;
505 }
506
507 static HRESULT WINAPI xmlnode_get_ownerDocument(
508     IXMLDOMNode *iface,
509     IXMLDOMDocument** DOMDocument)
510 {
511     FIXME("\n");
512     return E_NOTIMPL;
513 }
514
515 static HRESULT WINAPI xmlnode_cloneNode(
516     IXMLDOMNode *iface,
517     VARIANT_BOOL deep,
518     IXMLDOMNode** cloneRoot)
519 {
520     FIXME("\n");
521     return E_NOTIMPL;
522 }
523
524 static HRESULT WINAPI xmlnode_get_nodeTypeString(
525     IXMLDOMNode *iface,
526     BSTR* xmlnodeType)
527 {
528     FIXME("\n");
529     return E_NOTIMPL;
530 }
531
532 static HRESULT WINAPI xmlnode_get_text(
533     IXMLDOMNode *iface,
534     BSTR* text)
535 {
536     xmlnode *This = impl_from_IXMLDOMNode( iface );
537     BSTR str = NULL;
538
539     TRACE("%p\n", This);
540
541     if ( !text )
542         return E_INVALIDARG;
543
544     switch(This->node->type)
545     {
546     case XML_ELEMENT_NODE:
547     case XML_ATTRIBUTE_NODE:
548     {
549         xmlNodePtr child = This->node->children;
550         if ( child && child->type == XML_TEXT_NODE )
551             str = bstr_from_xmlChar( child->content );
552         break;
553     }
554
555     case XML_TEXT_NODE:
556     case XML_CDATA_SECTION_NODE:
557     case XML_PI_NODE:
558     case XML_COMMENT_NODE:
559         str = bstr_from_xmlChar( This->node->content );
560         break;
561
562     default:
563         FIXME("Unhandled node type %d\n", This->node->type);
564     }
565         
566     TRACE("%p %s\n", This, debugstr_w(str) );
567     *text = str;
568  
569     return S_OK;
570 }
571
572 static HRESULT WINAPI xmlnode_put_text(
573     IXMLDOMNode *iface,
574     BSTR text)
575 {
576     FIXME("\n");
577     return E_NOTIMPL;
578 }
579
580 static HRESULT WINAPI xmlnode_get_specified(
581     IXMLDOMNode *iface,
582     VARIANT_BOOL* isSpecified)
583 {
584     FIXME("\n");
585     return E_NOTIMPL;
586 }
587
588 static HRESULT WINAPI xmlnode_get_definition(
589     IXMLDOMNode *iface,
590     IXMLDOMNode** definitionNode)
591 {
592     FIXME("\n");
593     return E_NOTIMPL;
594 }
595
596 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
597     IXMLDOMNode *iface,
598     VARIANT* typedValue)
599 {
600     FIXME("ignoring data type\n");
601     return xmlnode_get_nodeValue(iface, typedValue);
602 }
603
604 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
605     IXMLDOMNode *iface,
606     VARIANT typedValue)
607 {
608     FIXME("\n");
609     return E_NOTIMPL;
610 }
611
612 static HRESULT WINAPI xmlnode_get_dataType(
613     IXMLDOMNode *iface,
614     VARIANT* dataTypeName)
615 {
616     FIXME("\n");
617     return E_NOTIMPL;
618 }
619
620 static HRESULT WINAPI xmlnode_put_dataType(
621     IXMLDOMNode *iface,
622     BSTR dataTypeName)
623 {
624     FIXME("\n");
625     return E_NOTIMPL;
626 }
627
628 static HRESULT WINAPI xmlnode_get_xml(
629     IXMLDOMNode *iface,
630     BSTR* xmlString)
631 {
632     FIXME("\n");
633     return E_NOTIMPL;
634 }
635
636 static HRESULT WINAPI xmlnode_transformNode(
637     IXMLDOMNode *iface,
638     IXMLDOMNode* styleSheet,
639     BSTR* xmlString)
640 {
641     FIXME("\n");
642     return E_NOTIMPL;
643 }
644
645 static HRESULT WINAPI xmlnode_selectNodes(
646     IXMLDOMNode *iface,
647     BSTR queryString,
648     IXMLDOMNodeList** resultList)
649 {
650     xmlnode *This = impl_from_IXMLDOMNode( iface );
651
652     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
653
654     return queryresult_create( This->node, queryString, resultList );
655 }
656
657 static HRESULT WINAPI xmlnode_selectSingleNode(
658     IXMLDOMNode *iface,
659     BSTR queryString,
660     IXMLDOMNode** resultNode)
661 {
662     xmlnode *This = impl_from_IXMLDOMNode( iface );
663     IXMLDOMNodeList *list;
664     HRESULT r;
665
666     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
667
668     *resultNode = NULL;
669     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
670     if(r == S_OK)
671     {
672         r = IXMLDOMNodeList_nextNode(list, resultNode);
673         IXMLDOMNodeList_Release(list);
674     }
675     return r;
676 }
677
678 static HRESULT WINAPI xmlnode_get_parsed(
679     IXMLDOMNode *iface,
680     VARIANT_BOOL* isParsed)
681 {
682     FIXME("\n");
683     return E_NOTIMPL;
684 }
685
686 static HRESULT WINAPI xmlnode_get_namespaceURI(
687     IXMLDOMNode *iface,
688     BSTR* namespaceURI)
689 {
690     FIXME("\n");
691     return E_NOTIMPL;
692 }
693
694 static HRESULT WINAPI xmlnode_get_prefix(
695     IXMLDOMNode *iface,
696     BSTR* prefixString)
697 {
698     FIXME("\n");
699     return E_NOTIMPL;
700 }
701
702 static HRESULT WINAPI xmlnode_get_baseName(
703     IXMLDOMNode *iface,
704     BSTR* nameString)
705 {
706     xmlnode *This = impl_from_IXMLDOMNode( iface );
707     BSTR str = NULL;
708     HRESULT r = S_FALSE;
709
710     TRACE("%p %p\n", This, nameString );
711
712     if ( !nameString )
713         return E_INVALIDARG;
714
715     switch ( This->node->type )
716     {
717     case XML_ELEMENT_NODE:
718     case XML_ATTRIBUTE_NODE:
719         str = bstr_from_xmlChar( This->node->name );
720         r = S_OK;
721         break;
722     case XML_TEXT_NODE:
723         break;
724     default:
725         ERR("Unhandled type %d\n", This->node->type );
726         break;
727     }
728
729     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
730
731     *nameString = str;
732     return r;
733 }
734
735 static HRESULT WINAPI xmlnode_transformNodeToObject(
736     IXMLDOMNode *iface,
737     IXMLDOMNode* stylesheet,
738     VARIANT outputObject)
739 {
740     FIXME("\n");
741     return E_NOTIMPL;
742 }
743
744 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
745 {
746     xmlnode_QueryInterface,
747     xmlnode_AddRef,
748     xmlnode_Release,
749     xmlnode_GetTypeInfoCount,
750     xmlnode_GetTypeInfo,
751     xmlnode_GetIDsOfNames,
752     xmlnode_Invoke,
753     xmlnode_get_nodeName,
754     xmlnode_get_nodeValue,
755     xmlnode_put_nodeValue,
756     xmlnode_get_nodeType,
757     xmlnode_get_parentNode,
758     xmlnode_get_childNodes,
759     xmlnode_get_firstChild,
760     xmlnode_get_lastChild,
761     xmlnode_get_previousSibling,
762     xmlnode_get_nextSibling,
763     xmlnode_get_attributes,
764     xmlnode_insertBefore,
765     xmlnode_replaceChild,
766     xmlnode_removeChild,
767     xmlnode_appendChild,
768     xmlnode_hasChildNodes,
769     xmlnode_get_ownerDocument,
770     xmlnode_cloneNode,
771     xmlnode_get_nodeTypeString,
772     xmlnode_get_text,
773     xmlnode_put_text,
774     xmlnode_get_specified,
775     xmlnode_get_definition,
776     xmlnode_get_nodeTypedValue,
777     xmlnode_put_nodeTypedValue,
778     xmlnode_get_dataType,
779     xmlnode_put_dataType,
780     xmlnode_get_xml,
781     xmlnode_transformNode,
782     xmlnode_selectNodes,
783     xmlnode_selectSingleNode,
784     xmlnode_get_parsed,
785     xmlnode_get_namespaceURI,
786     xmlnode_get_prefix,
787     xmlnode_get_baseName,
788     xmlnode_transformNodeToObject,
789 };
790
791 static HRESULT WINAPI Internal_QueryInterface(
792     IUnknown *iface,
793     REFIID riid,
794     void** ppvObject )
795 {
796     xmlnode *This = impl_from_InternalUnknown( iface );
797
798     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
799
800
801     if ( IsEqualGUID( riid, &IID_IUnknown ))
802         *ppvObject = iface;
803     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
804               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
805         *ppvObject = &This->lpVtbl;
806     else
807     {
808         FIXME("interface %s not implemented\n", debugstr_guid(riid));
809         *ppvObject = NULL;
810         return E_NOINTERFACE;
811     }
812
813     IUnknown_AddRef( (IUnknown*)*ppvObject );
814
815     return S_OK;
816 }
817
818 static ULONG WINAPI Internal_AddRef(
819                  IUnknown *iface )
820 {
821     xmlnode *This = impl_from_InternalUnknown( iface );
822     return InterlockedIncrement( &This->ref );
823 }
824
825 static ULONG WINAPI Internal_Release(
826     IUnknown *iface )
827 {
828     xmlnode *This = impl_from_InternalUnknown( iface );
829     ULONG ref;
830
831     ref = InterlockedDecrement( &This->ref );
832     if ( ref == 0 )
833     {
834         if( This->node )
835             xmldoc_release( This->node->doc );
836         HeapFree( GetProcessHeap(), 0, This );
837     }
838
839     return ref;
840 }
841
842 static const struct IUnknownVtbl internal_unk_vtbl =
843 {
844     Internal_QueryInterface,
845     Internal_AddRef,
846     Internal_Release
847 };
848
849 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
850 {
851     xmlnode *This;
852
853     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
854     if ( !This )
855         return NULL;
856
857     if(node)
858         xmldoc_add_ref( node->doc );
859
860     This->lpVtbl = &xmlnode_vtbl;
861     This->lpInternalUnkVtbl = &internal_unk_vtbl;
862
863     if(pUnkOuter)
864         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
865     else
866         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
867
868     This->ref = 1;
869     This->node = node;
870
871     return (IUnknown*)&This->lpInternalUnkVtbl;
872 }
873
874 IXMLDOMNode *create_node( xmlNodePtr node )
875 {
876     IUnknown *pUnk;
877     IXMLDOMNode *ret;
878     HRESULT hr;
879
880     if ( !node )
881         return NULL;
882
883     TRACE("type %d\n", node->type);
884     switch(node->type)
885     {
886     case XML_ELEMENT_NODE:
887         pUnk = create_element( node, NULL );
888         break;
889     case XML_ATTRIBUTE_NODE:
890         pUnk = create_attribute( node );
891         break;
892     case XML_TEXT_NODE:
893         pUnk = create_text( node );
894         break;
895     case XML_COMMENT_NODE:
896         pUnk = create_comment( node );
897         break;
898     case XML_DOCUMENT_NODE:
899         ERR("shouldn't be here!\n");
900         return NULL;
901     default:
902         FIXME("only creating basic node for type %d\n", node->type);
903         pUnk = create_basic_node( node, NULL );
904     }
905
906     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
907     IUnknown_Release(pUnk);
908     if(FAILED(hr)) return NULL;
909     return ret;
910 }
911 #endif