- Import and add to the bootcd msxml3.dll from Wine, but build it without libxml2 for now. It's not ready for autosyncing yet.

svn path=/trunk/; revision=31500

reactos/baseaddress.rbuild

@@ -91,6 +91,7 @@
   <property name="BASEADDRESS_SYSSETUP" value="0x74a30000" />
   <property name="BASEADDRESS_POWRPROF" value="0x74ad0000" />
   <property name="BASEADDRESS_MMDRV" value="0x74c30000" />
+  <property name="BASEADDRESS_MSXML3" value="0x74980000" />
   <property name="BASEADDRESS_OLEDLG" value="0x74d00000" />
   <property name="BASEADDRESS_SAMSRV" value="0x74f30000" />
   <property name="BASEADDRESS_SAMLIB" value="0x750C0000" />

reactos/boot/bootdata/packages/reactos.dff

@@ -212,6 +212,7 @@ dll\win32\msvcrt\msvcrt.dll                         1
 dll\win32\msvcrt20\msvcrt20.dll                     1
 dll\win32\msvfw32\msvfw32.dll                       1
 dll\win32\mswsock\mswsock.dll                       1
+dll\win32\msxml3\msxml3.dll                         1
 dll\win32\netapi32\netapi32.dll                     1
 dll\win32\netcfgx\netcfgx.dll                       1
 dll\win32\netid\netid.dll                           1

reactos/dll/win32/msxml3/attribute.c

@@ -0,0 +1,538 @@
+/*
+ *    DOM Attribute implementation
+ *
+ * Copyright 2006 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _domattr
+{
+    const struct IXMLDOMAttributeVtbl *lpVtbl;
+    LONG ref;
+    IUnknown *node_unk;
+    IXMLDOMNode *node;
+} domattr;
+
+static inline domattr *impl_from_IXMLDOMAttribute( IXMLDOMAttribute *iface )
+{
+    return (domattr *)((char*)iface - FIELD_OFFSET(domattr, lpVtbl));
+}
+
+static HRESULT WINAPI domattr_QueryInterface(
+    IXMLDOMAttribute *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IXMLDOMAttribute ) ||
+         IsEqualGUID( riid, &IID_IUnknown ) )
+    {
+        *ppvObject = iface;
+    }
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) )
+    {
+        return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
+    }
+    else
+    {
+        FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMAttribute_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI domattr_AddRef(
+    IXMLDOMAttribute *iface )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI domattr_Release(
+    IXMLDOMAttribute *iface )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IUnknown_Release( This->node_unk );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI domattr_GetTypeInfoCount(
+    IXMLDOMAttribute *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_GetTypeInfo(
+    IXMLDOMAttribute *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_GetIDsOfNames(
+    IXMLDOMAttribute *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_Invoke(
+    IXMLDOMAttribute *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_get_nodeName(
+    IXMLDOMAttribute *iface,
+    BSTR* p )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nodeName( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_nodeValue(
+    IXMLDOMAttribute *iface,
+    VARIANT* var1 )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domattr_put_nodeValue(
+    IXMLDOMAttribute *iface,
+    VARIANT var1 )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_put_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domattr_get_nodeType(
+    IXMLDOMAttribute *iface,
+    DOMNodeType* domNodeType )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nodeType( This->node, domNodeType );
+}
+
+static HRESULT WINAPI domattr_get_parentNode(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** parent )
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_parentNode( This->node, parent );
+}
+
+static HRESULT WINAPI domattr_get_childNodes(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNodeList** outList)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_childNodes( This->node, outList );
+}
+
+static HRESULT WINAPI domattr_get_firstChild(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** domNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_firstChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domattr_get_lastChild(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** domNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_lastChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domattr_get_previousSibling(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** domNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_previousSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domattr_get_nextSibling(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** domNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nextSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domattr_get_attributes(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_attributes( This->node, attributeMap );
+}
+
+static HRESULT WINAPI domattr_insertBefore(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* newNode, VARIANT var1,
+    IXMLDOMNode** outOldNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_insertBefore( This->node, newNode, var1, outOldNode );
+}
+
+static HRESULT WINAPI domattr_replaceChild(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* newNode,
+    IXMLDOMNode* oldNode,
+    IXMLDOMNode** outOldNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_replaceChild( This->node, newNode, oldNode, outOldNode );
+}
+
+static HRESULT WINAPI domattr_removeChild(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_removeChild( This->node, domNode, oldNode );
+}
+
+static HRESULT WINAPI domattr_appendChild(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_appendChild( This->node, newNode, outNewNode );
+}
+
+static HRESULT WINAPI domattr_hasChildNodes(
+    IXMLDOMAttribute *iface,
+    VARIANT_BOOL* pbool)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_hasChildNodes( This->node, pbool );
+}
+
+static HRESULT WINAPI domattr_get_ownerDocument(
+    IXMLDOMAttribute *iface,
+    IXMLDOMDocument** domDocument)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_ownerDocument( This->node, domDocument );
+}
+
+static HRESULT WINAPI domattr_cloneNode(
+    IXMLDOMAttribute *iface,
+    VARIANT_BOOL pbool, IXMLDOMNode** outNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_cloneNode( This->node, pbool, outNode );
+}
+
+static HRESULT WINAPI domattr_get_nodeTypeString(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nodeTypeString( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_text(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_text( This->node, p );
+}
+
+static HRESULT WINAPI domattr_put_text(
+    IXMLDOMAttribute *iface,
+    BSTR p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_put_text( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_specified(
+    IXMLDOMAttribute *iface,
+    VARIANT_BOOL* pbool)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_specified( This->node, pbool );
+}
+
+static HRESULT WINAPI domattr_get_definition(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode** domNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_definition( This->node, domNode );
+}
+
+static HRESULT WINAPI domattr_get_nodeTypedValue(
+    IXMLDOMAttribute *iface,
+    VARIANT* var1)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domattr_put_nodeTypedValue(
+    IXMLDOMAttribute *iface,
+    VARIANT var1)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_put_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domattr_get_dataType(
+    IXMLDOMAttribute *iface,
+    VARIANT* var1)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_dataType( This->node, var1 );
+}
+
+static HRESULT WINAPI domattr_put_dataType(
+    IXMLDOMAttribute *iface,
+    BSTR p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_put_dataType( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_xml(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_xml( This->node, p );
+}
+
+static HRESULT WINAPI domattr_transformNode(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* domNode, BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_transformNode( This->node, domNode, p );
+}
+
+static HRESULT WINAPI domattr_selectNodes(
+    IXMLDOMAttribute *iface,
+    BSTR p, IXMLDOMNodeList** outList)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_selectNodes( This->node, p, outList );
+}
+
+static HRESULT WINAPI domattr_selectSingleNode(
+    IXMLDOMAttribute *iface,
+    BSTR p, IXMLDOMNode** outNode)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_selectSingleNode( This->node, p, outNode );
+}
+
+static HRESULT WINAPI domattr_get_parsed(
+    IXMLDOMAttribute *iface,
+    VARIANT_BOOL* pbool)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_parsed( This->node, pbool );
+}
+
+static HRESULT WINAPI domattr_get_namespaceURI(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_namespaceURI( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_prefix(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_prefix( This->node, p );
+}
+
+static HRESULT WINAPI domattr_get_baseName(
+    IXMLDOMAttribute *iface,
+    BSTR* p)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_get_baseName( This->node, p );
+}
+
+static HRESULT WINAPI domattr_transformNodeToObject(
+    IXMLDOMAttribute *iface,
+    IXMLDOMNode* domNode, VARIANT var1)
+{
+    domattr *This = impl_from_IXMLDOMAttribute( iface );
+    return IXMLDOMNode_transformNodeToObject( This->node, domNode, var1 );
+}
+
+static HRESULT WINAPI domattr_get_name(
+    IXMLDOMAttribute *iface,
+    BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_get_value(
+    IXMLDOMAttribute *iface,
+    VARIANT *var1)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domattr_put_value(
+    IXMLDOMAttribute *iface,
+    VARIANT var1)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMAttributeVtbl domattr_vtbl =
+{
+    domattr_QueryInterface,
+    domattr_AddRef,
+    domattr_Release,
+    domattr_GetTypeInfoCount,
+    domattr_GetTypeInfo,
+    domattr_GetIDsOfNames,
+    domattr_Invoke,
+    domattr_get_nodeName,
+    domattr_get_nodeValue,
+    domattr_put_nodeValue,
+    domattr_get_nodeType,
+    domattr_get_parentNode,
+    domattr_get_childNodes,
+    domattr_get_firstChild,
+    domattr_get_lastChild,
+    domattr_get_previousSibling,
+    domattr_get_nextSibling,
+    domattr_get_attributes,
+    domattr_insertBefore,
+    domattr_replaceChild,
+    domattr_removeChild,
+    domattr_appendChild,
+    domattr_hasChildNodes,
+    domattr_get_ownerDocument,
+    domattr_cloneNode,
+    domattr_get_nodeTypeString,
+    domattr_get_text,
+    domattr_put_text,
+    domattr_get_specified,
+    domattr_get_definition,
+    domattr_get_nodeTypedValue,
+    domattr_put_nodeTypedValue,
+    domattr_get_dataType,
+    domattr_put_dataType,
+    domattr_get_xml,
+    domattr_transformNode,
+    domattr_selectNodes,
+    domattr_selectSingleNode,
+    domattr_get_parsed,
+    domattr_get_namespaceURI,
+    domattr_get_prefix,
+    domattr_get_baseName,
+    domattr_transformNodeToObject,
+    domattr_get_name,
+    domattr_get_value,
+    domattr_put_value
+};
+
+IUnknown* create_attribute( xmlNodePtr attribute )
+{
+    domattr *This;
+    HRESULT hr;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &domattr_vtbl;
+    This->ref = 1;
+
+    This->node_unk = create_basic_node( attribute, (IUnknown*)&This->lpVtbl );
+    if(!This->node_unk)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return NULL;
+    }
+
+    hr = IUnknown_QueryInterface(This->node_unk, &IID_IXMLDOMNode, (LPVOID*)&This->node);
+    if(FAILED(hr))
+    {
+        IUnknown_Release(This->node_unk);
+        HeapFree( GetProcessHeap(), 0, This );
+        return NULL;
+    }
+    /* The ref on This->node is actually looped back into this object, so release it */
+    IXMLDOMNode_Release(This->node);
+
+    return (IUnknown*) &This->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/comment.c

@@ -0,0 +1,583 @@
+/*
+ *    DOM comment node implementation
+ *
+ * Copyright 2006 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _domcomment
+{
+    const struct IXMLDOMCommentVtbl *lpVtbl;
+    LONG ref;
+    IUnknown *node_unk;
+    IXMLDOMNode *node;
+} domcomment;
+
+static inline domcomment *impl_from_IXMLDOMComment( IXMLDOMComment *iface )
+{
+    return (domcomment *)((char*)iface - FIELD_OFFSET(domcomment, lpVtbl));
+}
+
+static HRESULT WINAPI domcomment_QueryInterface(
+    IXMLDOMComment *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IXMLDOMComment ) ||
+         IsEqualGUID( riid, &IID_IUnknown ) )
+    {
+        *ppvObject = iface;
+    }
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) )
+    {
+        return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
+    }
+    else
+    {
+        FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMComment_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI domcomment_AddRef(
+    IXMLDOMComment *iface )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI domcomment_Release(
+    IXMLDOMComment *iface )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IUnknown_Release( This->node_unk );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI domcomment_GetTypeInfoCount(
+    IXMLDOMComment *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_GetTypeInfo(
+    IXMLDOMComment *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_GetIDsOfNames(
+    IXMLDOMComment *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_Invoke(
+    IXMLDOMComment *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_get_nodeName(
+    IXMLDOMComment *iface,
+    BSTR* p )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nodeName( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_nodeValue(
+    IXMLDOMComment *iface,
+    VARIANT* var1 )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domcomment_put_nodeValue(
+    IXMLDOMComment *iface,
+    VARIANT var1 )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_put_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domcomment_get_nodeType(
+    IXMLDOMComment *iface,
+    DOMNodeType* domNodeType )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nodeType( This->node, domNodeType );
+}
+
+static HRESULT WINAPI domcomment_get_parentNode(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** parent )
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_parentNode( This->node, parent );
+}
+
+static HRESULT WINAPI domcomment_get_childNodes(
+    IXMLDOMComment *iface,
+    IXMLDOMNodeList** outList)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_childNodes( This->node, outList );
+}
+
+static HRESULT WINAPI domcomment_get_firstChild(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** domNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_firstChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domcomment_get_lastChild(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** domNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_lastChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domcomment_get_previousSibling(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** domNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_previousSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domcomment_get_nextSibling(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** domNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nextSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domcomment_get_attributes(
+    IXMLDOMComment *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_attributes( This->node, attributeMap );
+}
+
+static HRESULT WINAPI domcomment_insertBefore(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* newNode, VARIANT var1,
+    IXMLDOMNode** outOldNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_insertBefore( This->node, newNode, var1, outOldNode );
+}
+
+static HRESULT WINAPI domcomment_replaceChild(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* newNode,
+    IXMLDOMNode* oldNode,
+    IXMLDOMNode** outOldNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_replaceChild( This->node, newNode, oldNode, outOldNode );
+}
+
+static HRESULT WINAPI domcomment_removeChild(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_removeChild( This->node, domNode, oldNode );
+}
+
+static HRESULT WINAPI domcomment_appendChild(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_appendChild( This->node, newNode, outNewNode );
+}
+
+static HRESULT WINAPI domcomment_hasChildNodes(
+    IXMLDOMComment *iface,
+    VARIANT_BOOL* pbool)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_hasChildNodes( This->node, pbool );
+}
+
+static HRESULT WINAPI domcomment_get_ownerDocument(
+    IXMLDOMComment *iface,
+    IXMLDOMDocument** domDocument)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_ownerDocument( This->node, domDocument );
+}
+
+static HRESULT WINAPI domcomment_cloneNode(
+    IXMLDOMComment *iface,
+    VARIANT_BOOL pbool, IXMLDOMNode** outNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_cloneNode( This->node, pbool, outNode );
+}
+
+static HRESULT WINAPI domcomment_get_nodeTypeString(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nodeTypeString( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_text(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_text( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_put_text(
+    IXMLDOMComment *iface,
+    BSTR p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_put_text( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_specified(
+    IXMLDOMComment *iface,
+    VARIANT_BOOL* pbool)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_specified( This->node, pbool );
+}
+
+static HRESULT WINAPI domcomment_get_definition(
+    IXMLDOMComment *iface,
+    IXMLDOMNode** domNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_definition( This->node, domNode );
+}
+
+static HRESULT WINAPI domcomment_get_nodeTypedValue(
+    IXMLDOMComment *iface,
+    VARIANT* var1)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domcomment_put_nodeTypedValue(
+    IXMLDOMComment *iface,
+    VARIANT var1)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_put_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domcomment_get_dataType(
+    IXMLDOMComment *iface,
+    VARIANT* var1)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_dataType( This->node, var1 );
+}
+
+static HRESULT WINAPI domcomment_put_dataType(
+    IXMLDOMComment *iface,
+    BSTR p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_put_dataType( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_xml(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_xml( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_transformNode(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* domNode, BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_transformNode( This->node, domNode, p );
+}
+
+static HRESULT WINAPI domcomment_selectNodes(
+    IXMLDOMComment *iface,
+    BSTR p, IXMLDOMNodeList** outList)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_selectNodes( This->node, p, outList );
+}
+
+static HRESULT WINAPI domcomment_selectSingleNode(
+    IXMLDOMComment *iface,
+    BSTR p, IXMLDOMNode** outNode)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_selectSingleNode( This->node, p, outNode );
+}
+
+static HRESULT WINAPI domcomment_get_parsed(
+    IXMLDOMComment *iface,
+    VARIANT_BOOL* pbool)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_parsed( This->node, pbool );
+}
+
+static HRESULT WINAPI domcomment_get_namespaceURI(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_namespaceURI( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_prefix(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_prefix( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_get_baseName(
+    IXMLDOMComment *iface,
+    BSTR* p)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_get_baseName( This->node, p );
+}
+
+static HRESULT WINAPI domcomment_transformNodeToObject(
+    IXMLDOMComment *iface,
+    IXMLDOMNode* domNode, VARIANT var1)
+{
+    domcomment *This = impl_from_IXMLDOMComment( iface );
+    return IXMLDOMNode_transformNodeToObject( This->node, domNode, var1 );
+}
+
+static HRESULT WINAPI domcomment_get_data(
+    IXMLDOMComment *iface,
+    BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_put_data(
+    IXMLDOMComment *iface,
+    BSTR data)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_get_length(
+    IXMLDOMComment *iface,
+    long *len)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_substringData(
+    IXMLDOMComment *iface,
+    long offset, long count, BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_appendData(
+    IXMLDOMComment *iface,
+    BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_insertData(
+    IXMLDOMComment *iface,
+    long offset, BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_deleteData(
+    IXMLDOMComment *iface,
+    long offset, long count)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domcomment_replaceData(
+    IXMLDOMComment *iface,
+    long offset, long count, BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMCommentVtbl domcomment_vtbl =
+{
+    domcomment_QueryInterface,
+    domcomment_AddRef,
+    domcomment_Release,
+    domcomment_GetTypeInfoCount,
+    domcomment_GetTypeInfo,
+    domcomment_GetIDsOfNames,
+    domcomment_Invoke,
+    domcomment_get_nodeName,
+    domcomment_get_nodeValue,
+    domcomment_put_nodeValue,
+    domcomment_get_nodeType,
+    domcomment_get_parentNode,
+    domcomment_get_childNodes,
+    domcomment_get_firstChild,
+    domcomment_get_lastChild,
+    domcomment_get_previousSibling,
+    domcomment_get_nextSibling,
+    domcomment_get_attributes,
+    domcomment_insertBefore,
+    domcomment_replaceChild,
+    domcomment_removeChild,
+    domcomment_appendChild,
+    domcomment_hasChildNodes,
+    domcomment_get_ownerDocument,
+    domcomment_cloneNode,
+    domcomment_get_nodeTypeString,
+    domcomment_get_text,
+    domcomment_put_text,
+    domcomment_get_specified,
+    domcomment_get_definition,
+    domcomment_get_nodeTypedValue,
+    domcomment_put_nodeTypedValue,
+    domcomment_get_dataType,
+    domcomment_put_dataType,
+    domcomment_get_xml,
+    domcomment_transformNode,
+    domcomment_selectNodes,
+    domcomment_selectSingleNode,
+    domcomment_get_parsed,
+    domcomment_get_namespaceURI,
+    domcomment_get_prefix,
+    domcomment_get_baseName,
+    domcomment_transformNodeToObject,
+    domcomment_get_data,
+    domcomment_put_data,
+    domcomment_get_length,
+    domcomment_substringData,
+    domcomment_appendData,
+    domcomment_insertData,
+    domcomment_deleteData,
+    domcomment_replaceData
+};
+
+IUnknown* create_comment( xmlNodePtr comment )
+{
+    domcomment *This;
+    HRESULT hr;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &domcomment_vtbl;
+    This->ref = 1;
+
+    This->node_unk = create_basic_node( comment, (IUnknown*)&This->lpVtbl );
+    if(!This->node_unk)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return NULL;
+    }
+
+    hr = IUnknown_QueryInterface(This->node_unk, &IID_IXMLDOMNode, (LPVOID*)&This->node);
+    if(FAILED(hr))
+    {
+        IUnknown_Release(This->node_unk);
+        HeapFree( GetProcessHeap(), 0, This );
+        return NULL;
+    }
+    /* The ref on This->node is actually looped back into this object, so release it */
+    IXMLDOMNode_Release(This->node);
+
+    return (IUnknown*) &This->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/element.c

@@ -0,0 +1,738 @@
+/*
+ *    DOM Document implementation
+ *
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winnls.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _domelem
+{
+    const struct IXMLDOMElementVtbl *lpVtbl;
+    const struct IUnknownVtbl *lpInternalUnkVtbl;
+    IUnknown *pUnkOuter;
+    LONG ref;
+    IUnknown *node_unk;
+    IXMLDOMNode *node;
+} domelem;
+
+static inline domelem *impl_from_IXMLDOMElement( IXMLDOMElement *iface )
+{
+    return (domelem *)((char*)iface - FIELD_OFFSET(domelem, lpVtbl));
+}
+
+static inline domelem *impl_from_InternalUnknown( IUnknown *iface )
+{
+    return (domelem *)((char*)iface - FIELD_OFFSET(domelem, lpInternalUnkVtbl));
+}
+
+static inline xmlNodePtr get_element( domelem *This )
+{
+    return xmlNodePtr_from_domnode( This->node, XML_ELEMENT_NODE );
+}
+
+static HRESULT WINAPI domelem_QueryInterface(
+    IXMLDOMElement *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
+}
+
+static ULONG WINAPI domelem_AddRef(
+    IXMLDOMElement *iface )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IUnknown_AddRef(This->pUnkOuter);
+}
+
+static ULONG WINAPI domelem_Release(
+    IXMLDOMElement *iface )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IUnknown_Release(This->pUnkOuter);
+}
+
+static HRESULT WINAPI domelem_GetTypeInfoCount(
+    IXMLDOMElement *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_GetTypeInfo(
+    IXMLDOMElement *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_GetIDsOfNames(
+    IXMLDOMElement *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_Invoke(
+    IXMLDOMElement *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_get_nodeName(
+    IXMLDOMElement *iface,
+    BSTR* p )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nodeName( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_nodeValue(
+    IXMLDOMElement *iface,
+    VARIANT* var1 )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domelem_put_nodeValue(
+    IXMLDOMElement *iface,
+    VARIANT var1 )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_put_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domelem_get_nodeType(
+    IXMLDOMElement *iface,
+    DOMNodeType* domNodeType )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nodeType( This->node, domNodeType );
+}
+
+static HRESULT WINAPI domelem_get_parentNode(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** parent )
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_parentNode( This->node, parent );
+}
+
+static HRESULT WINAPI domelem_get_childNodes(
+    IXMLDOMElement *iface,
+    IXMLDOMNodeList** outList)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_childNodes( This->node, outList );
+}
+
+static HRESULT WINAPI domelem_get_firstChild(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** domNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_firstChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domelem_get_lastChild(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** domNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_lastChild( This->node, domNode );
+}
+
+static HRESULT WINAPI domelem_get_previousSibling(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** domNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_previousSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domelem_get_nextSibling(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** domNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nextSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI domelem_get_attributes(
+    IXMLDOMElement *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_attributes( This->node, attributeMap );
+}
+
+static HRESULT WINAPI domelem_insertBefore(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* newNode, VARIANT var1,
+    IXMLDOMNode** outOldNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_insertBefore( This->node, newNode, var1, outOldNode );
+}
+
+static HRESULT WINAPI domelem_replaceChild(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* newNode,
+    IXMLDOMNode* oldNode,
+    IXMLDOMNode** outOldNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_replaceChild( This->node, newNode, oldNode, outOldNode );
+}
+
+static HRESULT WINAPI domelem_removeChild(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_removeChild( This->node, domNode, oldNode );
+}
+
+static HRESULT WINAPI domelem_appendChild(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_appendChild( This->node, newNode, outNewNode );
+}
+
+static HRESULT WINAPI domelem_hasChildNodes(
+    IXMLDOMElement *iface,
+    VARIANT_BOOL* pbool)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_hasChildNodes( This->node, pbool );
+}
+
+static HRESULT WINAPI domelem_get_ownerDocument(
+    IXMLDOMElement *iface,
+    IXMLDOMDocument** domDocument)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_ownerDocument( This->node, domDocument );
+}
+
+static HRESULT WINAPI domelem_cloneNode(
+    IXMLDOMElement *iface,
+    VARIANT_BOOL pbool, IXMLDOMNode** outNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_cloneNode( This->node, pbool, outNode );
+}
+
+static HRESULT WINAPI domelem_get_nodeTypeString(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nodeTypeString( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_text(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_text( This->node, p );
+}
+
+static HRESULT WINAPI domelem_put_text(
+    IXMLDOMElement *iface,
+    BSTR p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_put_text( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_specified(
+    IXMLDOMElement *iface,
+    VARIANT_BOOL* pbool)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_specified( This->node, pbool );
+}
+
+static HRESULT WINAPI domelem_get_definition(
+    IXMLDOMElement *iface,
+    IXMLDOMNode** domNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_definition( This->node, domNode );
+}
+
+static HRESULT WINAPI domelem_get_nodeTypedValue(
+    IXMLDOMElement *iface,
+    VARIANT* var1)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domelem_put_nodeTypedValue(
+    IXMLDOMElement *iface,
+    VARIANT var1)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_put_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI domelem_get_dataType(
+    IXMLDOMElement *iface,
+    VARIANT* var1)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_dataType( This->node, var1 );
+}
+
+static HRESULT WINAPI domelem_put_dataType(
+    IXMLDOMElement *iface,
+    BSTR p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_put_dataType( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_xml(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_xml( This->node, p );
+}
+
+static HRESULT WINAPI domelem_transformNode(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* domNode, BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_transformNode( This->node, domNode, p );
+}
+
+static HRESULT WINAPI domelem_selectNodes(
+    IXMLDOMElement *iface,
+    BSTR p, IXMLDOMNodeList** outList)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_selectNodes( This->node, p, outList );
+}
+
+static HRESULT WINAPI domelem_selectSingleNode(
+    IXMLDOMElement *iface,
+    BSTR p, IXMLDOMNode** outNode)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_selectSingleNode( This->node, p, outNode );
+}
+
+static HRESULT WINAPI domelem_get_parsed(
+    IXMLDOMElement *iface,
+    VARIANT_BOOL* pbool)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_parsed( This->node, pbool );
+}
+
+static HRESULT WINAPI domelem_get_namespaceURI(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_namespaceURI( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_prefix(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_prefix( This->node, p );
+}
+
+static HRESULT WINAPI domelem_get_baseName(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_get_baseName( This->node, p );
+}
+
+static HRESULT WINAPI domelem_transformNodeToObject(
+    IXMLDOMElement *iface,
+    IXMLDOMNode* domNode, VARIANT var1)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    return IXMLDOMNode_transformNodeToObject( This->node, domNode, var1 );
+}
+
+static HRESULT WINAPI domelem_get_tagName(
+    IXMLDOMElement *iface,
+    BSTR* p)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    xmlNodePtr element;
+    DWORD len;
+    DWORD offset = 0;
+    LPWSTR str;
+
+    TRACE("%p\n", This );
+
+    if ( !This->node )
+        return E_FAIL;
+
+    element = get_element( This );
+    if ( !element )
+        return E_FAIL;
+
+    len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->name, -1, NULL, 0 );
+    if (element->ns)
+        len += MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->ns->prefix, -1, NULL, 0 );
+    str = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
+    if ( !str )
+        return E_OUTOFMEMORY;
+    if (element->ns)
+    {
+        offset = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->ns->prefix, -1, str, len );
+        str[offset - 1] = ':';
+    }
+    MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->name, -1, str + offset, len - offset );
+    *p = SysAllocString( str );
+    HeapFree( GetProcessHeap(), 0, str );
+
+    return S_OK;
+}
+
+static HRESULT WINAPI domelem_getAttribute(
+    IXMLDOMElement *iface,
+    BSTR name, VARIANT* value)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    xmlNodePtr element;
+    xmlChar *xml_name, *xml_value;
+    HRESULT hr = E_FAIL;
+
+    TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), value);
+
+    element = get_element( This );
+    if ( !element )
+        return E_FAIL;
+
+    VariantInit(value);
+    xml_name = xmlChar_from_wchar( name );
+    xml_value = xmlGetNsProp(element, xml_name, NULL);
+    HeapFree(GetProcessHeap(), 0, xml_name);
+    if(xml_value)
+    {
+        V_VT(value) = VT_BSTR;
+        V_BSTR(value) = bstr_from_xmlChar( xml_value );
+        xmlFree(xml_value);
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+static HRESULT WINAPI domelem_setAttribute(
+    IXMLDOMElement *iface,
+    BSTR name, VARIANT value)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    xmlNodePtr element;
+    xmlChar *xml_name, *xml_value;
+    HRESULT hr;
+    VARIANT var;
+
+    TRACE("(%p)->(%s, var)\n", This, debugstr_w(name));
+
+    element = get_element( This );
+    if ( !element )
+        return E_FAIL;
+
+    VariantInit(&var);
+    hr = VariantChangeType(&var, &value, 0, VT_BSTR);
+    if(hr != S_OK)
+    {
+        FIXME("VariantChangeType failed\n");
+        return hr;
+    }
+
+    xml_name = xmlChar_from_wchar( name );
+    xml_value = xmlChar_from_wchar( V_BSTR(&var) );
+
+    if(!xmlSetNsProp(element, NULL,  xml_name, xml_value))
+        hr = E_FAIL;
+
+    HeapFree(GetProcessHeap(), 0, xml_value);
+    HeapFree(GetProcessHeap(), 0, xml_name);
+    VariantClear(&var);
+
+    return hr;
+}
+
+static HRESULT WINAPI domelem_removeAttribute(
+    IXMLDOMElement *iface,
+    BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_getAttributeNode(
+    IXMLDOMElement *iface,
+    BSTR p, IXMLDOMAttribute** attributeNode )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_setAttributeNode(
+    IXMLDOMElement *iface,
+    IXMLDOMAttribute* domAttribute,
+    IXMLDOMAttribute** attributeNode)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_removeAttributeNode(
+    IXMLDOMElement *iface,
+    IXMLDOMAttribute* domAttribute,
+    IXMLDOMAttribute** attributeNode)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domelem_getElementsByTagName(
+    IXMLDOMElement *iface,
+    BSTR bstrName, IXMLDOMNodeList** resultList)
+{
+    domelem *This = impl_from_IXMLDOMElement( iface );
+    LPWSTR szPattern;
+    HRESULT hr;
+
+    TRACE("(%p)->(%s,%p)\n", This, debugstr_w(bstrName), resultList);
+
+    szPattern = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(3+lstrlenW(bstrName)+1));
+    szPattern[0] = '.';
+    szPattern[1] = szPattern[2] = '/';
+    lstrcpyW(szPattern+3, bstrName);
+    TRACE("%s\n", debugstr_w(szPattern));
+
+    hr = queryresult_create(get_element(This), szPattern, resultList);
+    HeapFree(GetProcessHeap(), 0, szPattern);
+
+    return hr;
+}
+
+static HRESULT WINAPI domelem_normalize(
+    IXMLDOMElement *iface )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMElementVtbl domelem_vtbl =
+{
+    domelem_QueryInterface,
+    domelem_AddRef,
+    domelem_Release,
+    domelem_GetTypeInfoCount,
+    domelem_GetTypeInfo,
+    domelem_GetIDsOfNames,
+    domelem_Invoke,
+    domelem_get_nodeName,
+    domelem_get_nodeValue,
+    domelem_put_nodeValue,
+    domelem_get_nodeType,
+    domelem_get_parentNode,
+    domelem_get_childNodes,
+    domelem_get_firstChild,
+    domelem_get_lastChild,
+    domelem_get_previousSibling,
+    domelem_get_nextSibling,
+    domelem_get_attributes,
+    domelem_insertBefore,
+    domelem_replaceChild,
+    domelem_removeChild,
+    domelem_appendChild,
+    domelem_hasChildNodes,
+    domelem_get_ownerDocument,
+    domelem_cloneNode,
+    domelem_get_nodeTypeString,
+    domelem_get_text,
+    domelem_put_text,
+    domelem_get_specified,
+    domelem_get_definition,
+    domelem_get_nodeTypedValue,
+    domelem_put_nodeTypedValue,
+    domelem_get_dataType,
+    domelem_put_dataType,
+    domelem_get_xml,
+    domelem_transformNode,
+    domelem_selectNodes,
+    domelem_selectSingleNode,
+    domelem_get_parsed,
+    domelem_get_namespaceURI,
+    domelem_get_prefix,
+    domelem_get_baseName,
+    domelem_transformNodeToObject,
+    domelem_get_tagName,
+    domelem_getAttribute,
+    domelem_setAttribute,
+    domelem_removeAttribute,
+    domelem_getAttributeNode,
+    domelem_setAttributeNode,
+    domelem_removeAttributeNode,
+    domelem_getElementsByTagName,
+    domelem_normalize,
+};
+
+static HRESULT WINAPI Internal_QueryInterface(
+    IUnknown *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    domelem *This = impl_from_InternalUnknown( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) ||
+         IsEqualGUID( riid, &IID_IUnknown ) )
+    {
+        *ppvObject = &This->lpVtbl;
+    }
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) )
+    {
+        return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef( (IUnknown*)*ppvObject );
+
+    return S_OK;
+}
+
+static ULONG WINAPI Internal_AddRef(
+    IUnknown *iface )
+{
+    domelem *This = impl_from_InternalUnknown( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI Internal_Release(
+    IUnknown *iface )
+{
+    domelem *This = impl_from_InternalUnknown( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IUnknown_Release( This->node_unk );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static const struct IUnknownVtbl internal_unk_vtbl =
+{
+    Internal_QueryInterface,
+    Internal_AddRef,
+    Internal_Release
+};
+
+IUnknown* create_element( xmlNodePtr element, IUnknown *pUnkOuter )
+{
+    domelem *This;
+    HRESULT hr;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &domelem_vtbl;
+    This->ref = 1;
+    This->lpInternalUnkVtbl = &internal_unk_vtbl;
+
+    if(pUnkOuter)
+        This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
+    else
+        This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
+
+    This->node_unk = create_basic_node( element, (IUnknown*)&This->lpVtbl );
+    if(!This->node_unk)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return NULL;
+    }
+
+    hr = IUnknown_QueryInterface(This->node_unk, &IID_IXMLDOMNode, (LPVOID*)&This->node);
+    if(FAILED(hr))
+    {
+        IUnknown_Release(This->node_unk);
+        HeapFree( GetProcessHeap(), 0, This );
+        return NULL;
+    }
+    /* The ref on This->node is actually looped back into this object, so release it */
+    IXMLDOMNode_Release(This->node);
+
+    return (IUnknown*) &This->lpInternalUnkVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/factory.c

@@ -0,0 +1,170 @@
+/*
+ *    MSXML Class Factory
+ *
+ * Copyright 2002 Lionel Ulmer
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml.h"
+#include "xmldom.h"
+#include "msxml2.h"
+
+/* undef the #define in msxml2 so that we can access the v.2 version
+   independent CLSID as well as the v.3 one. */
+#undef CLSID_DOMDocument
+
+#include "wine/debug.h"
+
+#include "msxml_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+typedef HRESULT (*fnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
+
+/******************************************************************************
+ * MSXML ClassFactory
+ */
+typedef struct _xmlcf
+{
+    const struct IClassFactoryVtbl *lpVtbl;
+    fnCreateInstance pfnCreateInstance;
+} xmlcf;
+
+static inline xmlcf *impl_from_IClassFactory( IClassFactory *iface )
+{
+    return (xmlcf *)((char*)iface - FIELD_OFFSET(xmlcf, lpVtbl));
+}
+
+static HRESULT WINAPI xmlcf_QueryInterface(
+    IClassFactory *iface,
+    REFIID riid,
+    LPVOID *ppobj )
+{
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IClassFactory))
+    {
+        IClassFactory_AddRef( iface );
+        *ppobj = iface;
+        return S_OK;
+    }
+
+    FIXME("interface %s not implemented\n", debugstr_guid(riid));
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI xmlcf_AddRef(
+    IClassFactory *iface )
+{
+    return 2;
+}
+
+static ULONG WINAPI xmlcf_Release(
+    IClassFactory *iface )
+{
+    return 1;
+}
+
+static HRESULT WINAPI xmlcf_CreateInstance(
+    IClassFactory *iface,
+    LPUNKNOWN pOuter,
+    REFIID riid,
+    LPVOID *ppobj )
+{
+    xmlcf *This = impl_from_IClassFactory( iface );
+    HRESULT r;
+    IUnknown *punk;
+    
+    TRACE("%p %s %p\n", pOuter, debugstr_guid(riid), ppobj );
+
+    *ppobj = NULL;
+
+    if (pOuter)
+        return CLASS_E_NOAGGREGATION;
+
+    r = This->pfnCreateInstance( pOuter, (LPVOID*) &punk );
+    if (FAILED(r))
+        return r;
+
+    r = IUnknown_QueryInterface( punk, riid, ppobj );
+    IUnknown_Release( punk );
+    return r;
+}
+
+static HRESULT WINAPI xmlcf_LockServer(
+    IClassFactory *iface,
+    BOOL dolock)
+{
+    FIXME("(%p)->(%d),stub!\n",iface,dolock);
+    return S_OK;
+}
+
+static const struct IClassFactoryVtbl xmlcf_vtbl =
+{
+    xmlcf_QueryInterface,
+    xmlcf_AddRef,
+    xmlcf_Release,
+    xmlcf_CreateInstance,
+    xmlcf_LockServer
+};
+
+static xmlcf domdoccf = { &xmlcf_vtbl, DOMDocument_create };
+static xmlcf schemacf = { &xmlcf_vtbl, SchemaCache_create };
+static xmlcf xmldoccf = { &xmlcf_vtbl, XMLDocument_create };
+
+/******************************************************************
+ *		DllGetClassObject (MSXML3.@)
+ */
+HRESULT WINAPI DllGetClassObject( REFCLSID rclsid, REFIID iid, LPVOID *ppv )
+{
+    IClassFactory *cf = NULL;
+
+    TRACE("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv );
+
+    if( IsEqualCLSID( rclsid, &CLSID_DOMDocument ) ||   /* Version indep. v 2.x */
+        IsEqualCLSID( rclsid, &CLSID_DOMDocument2 ) ||  /* Version indep. v 3.0 */
+        IsEqualCLSID( rclsid, &CLSID_DOMDocument30 ) )  /* Version dep.   v 3.0 */
+    {
+        cf = (IClassFactory*) &domdoccf.lpVtbl;
+    }
+    else if( IsEqualCLSID( rclsid, &CLSID_XMLSchemaCache ) ||
+             IsEqualCLSID( rclsid, &CLSID_XMLSchemaCache30 ) )
+    {
+        cf = (IClassFactory*) &schemacf.lpVtbl;
+    }
+    else if( IsEqualCLSID( rclsid, &CLSID_XMLDocument ) )
+    {
+        cf = (IClassFactory*) &xmldoccf.lpVtbl;
+    }
+    else if( IsEqualCLSID( rclsid, &CLSID_FreeThreadedDOMDocument ) )
+    {
+        cf = (IClassFactory*) &domdoccf.lpVtbl;
+    }
+
+    if ( !cf )
+        return CLASS_E_CLASSNOTAVAILABLE;
+
+    return IClassFactory_QueryInterface( cf, iid, ppv );
+}

reactos/dll/win32/msxml3/main.c

@@ -0,0 +1,60 @@
+/*
+ *    MSXML Class Factory
+ *
+ * Copyright 2002 Lionel Ulmer
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "wine/debug.h"
+
+#include "msxml_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+HRESULT WINAPI DllCanUnloadNow(void)
+{
+    FIXME("\n");
+    return S_FALSE;
+}
+
+BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
+{
+    switch(fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+#ifdef HAVE_LIBXML2
+        xmlInitParser();
+#endif
+        DisableThreadLibraryCalls(hInstDLL);
+        break;
+    case DLL_PROCESS_DETACH:
+#ifdef HAVE_LIBXML2
+        xmlCleanupParser();
+#endif
+        break;
+    }
+    return TRUE;
+}

reactos/dll/win32/msxml3/msxml3.rbuild

@@ -0,0 +1,47 @@
+<module name="msxml3" type="win32dll" baseaddress="${BASEADDRESS_MSXML3}" installbase="system32" installname="msxml3.dll" allowwarnings="true">
+	<autoregister infsection="OleControlDlls" type="DllRegisterServer" />
+	<importlibrary definition="msxml3.spec.def" />
+	<include base="msxml3">.</include>
+	<include base="ReactOS">include/reactos/wine</include>
+	<define name="__REACTOS__" />
+	<define name="__WINESRC__" />
+	<define name="__USE_W32API" />
+	<define name="_WIN32_IE">0x600</define>
+	<define name="_WIN32_WINNT">0x601</define>
+	<define name="WINVER">0x501</define>
+	<library>wine</library>
+	<library>urlmon</library>
+	<library>wininet</library>
+	<library>comctl32</library>
+	<library>shell32</library>
+	<library>shlwapi</library>
+	<library>cabinet</library>
+	<library>oleaut32</library>
+	<library>ole32</library>
+	<library>version</library>
+	<library>user32</library>
+	<library>gdi32</library>
+	<library>advapi32</library>
+	<library>kernel32</library>
+	<library>uuid</library>
+	<library>ntdll</library>
+	<file>attribute.c</file>
+	<file>comment.c</file>
+	<file>domdoc.c</file>
+	<file>element.c</file>
+	<file>factory.c</file>
+	<file>main.c</file>
+	<file>node.c</file>
+	<file>nodelist.c</file>
+	<file>nodemap.c</file>
+	<file>parseerror.c</file>
+	<file>pi.c</file>
+	<file>queryresult.c</file>
+	<file>regsvr.c</file>
+	<file>schema.c</file>
+	<file>text.c</file>
+	<file>uuid.c</file>
+	<file>xmldoc.c</file>
+	<file>xmlelem.c</file>
+	<file>msxml3.spec</file>
+</module>

reactos/dll/win32/msxml3/msxml3.spec

@@ -0,0 +1,12 @@
+ 6 stub @
+ 7 stub @
+ 8 stub @
+ 9 stub @
+10 stub @
+11 stub @
+12 stub @
+
+@ stdcall -private DllCanUnloadNow()
+@ stdcall -private DllGetClassObject(ptr ptr ptr)
+@ stdcall -private DllRegisterServer()
+@ stdcall -private DllUnregisterServer()

reactos/dll/win32/msxml3/msxml_private.h

@@ -0,0 +1,74 @@
+/*
+ *    MSXML Class Factory
+ *
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __MSXML_PRIVATE__
+#define __MSXML_PRIVATE__
+
+#ifndef __WINE_CONFIG_H
+# error You must include config.h to use this header
+#endif
+
+#ifdef HAVE_LIBXML2
+
+#ifdef HAVE_LIBXML_PARSER_H
+#include <libxml/parser.h>
+#endif
+
+/* constructors */
+extern IUnknown         *create_domdoc( void );
+extern IUnknown         *create_xmldoc( void );
+extern IXMLDOMNode      *create_node( xmlNodePtr node );
+extern IUnknown         *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter );
+extern IUnknown         *create_element( xmlNodePtr element, IUnknown *pUnkOuter );
+extern IUnknown         *create_attribute( xmlNodePtr attribute );
+extern IUnknown         *create_text( xmlNodePtr text );
+extern IUnknown         *create_pi( xmlNodePtr pi );
+extern IUnknown         *create_comment( xmlNodePtr comment );
+extern IXMLDOMNodeList  *create_children_nodelist( xmlNodePtr );
+extern IXMLDOMNamedNodeMap *create_nodemap( IXMLDOMNode *node );
+
+extern HRESULT queryresult_create( xmlNodePtr, LPWSTR, IXMLDOMNodeList ** );
+
+extern void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xmlnode );
+
+/* data accessors */
+xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type );
+
+/* helpers */
+extern xmlChar *xmlChar_from_wchar( LPWSTR str );
+extern BSTR bstr_from_xmlChar( const xmlChar *buf );
+
+extern LONG xmldoc_add_ref( xmlDocPtr doc );
+extern LONG xmldoc_release( xmlDocPtr doc );
+
+extern HRESULT XMLElement_create( IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj );
+extern HRESULT XMLElementCollection_create( IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj );
+
+extern xmlDocPtr parse_xml(char *ptr, int len);
+
+#endif
+
+extern IXMLDOMParseError *create_parseError( LONG code, BSTR url, BSTR reason, BSTR srcText,
+                                             LONG line, LONG linepos, LONG filepos );
+extern HRESULT DOMDocument_create( IUnknown *pUnkOuter, LPVOID *ppObj );
+extern HRESULT SchemaCache_create( IUnknown *pUnkOuter, LPVOID *ppObj );
+extern HRESULT XMLDocument_create( IUnknown *pUnkOuter, LPVOID *ppObj );
+
+#endif /* __MSXML_PRIVATE__ */

reactos/dll/win32/msxml3/node.c

@@ -0,0 +1,944 @@
+/*
+ *    Node implementation
+ *
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+
+#define COBJMACROS
+
+#include <stdarg.h>
+#include <assert.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winnls.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _xmlnode
+{
+    const struct IXMLDOMNodeVtbl *lpVtbl;
+    const struct IUnknownVtbl *lpInternalUnkVtbl;
+    IUnknown *pUnkOuter;
+    LONG ref;
+    xmlNodePtr node;
+} xmlnode;
+
+static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
+{
+    return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
+}
+
+static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
+{
+    return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
+}
+
+xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
+{
+    xmlnode *This;
+
+    if ( !iface )
+        return NULL;
+    This = impl_from_IXMLDOMNode( iface );
+    if ( !This->node )
+        return NULL;
+    if ( type && This->node->type != type )
+        return NULL;
+    return This->node;
+}
+
+void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xml )
+{
+    xmlnode *This = impl_from_IXMLDOMNode( node );
+
+    if(This->node)
+        xmldoc_release(This->node->doc);
+
+    This->node = xml;
+    if(This->node)
+        xmldoc_add_ref(This->node->doc);
+
+    return;
+}
+
+static HRESULT WINAPI xmlnode_QueryInterface(
+    IXMLDOMNode *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
+}
+
+static ULONG WINAPI xmlnode_AddRef(
+    IXMLDOMNode *iface )
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return IUnknown_AddRef(This->pUnkOuter);
+}
+
+static ULONG WINAPI xmlnode_Release(
+    IXMLDOMNode *iface )
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return IUnknown_Release(This->pUnkOuter);
+}
+
+static HRESULT WINAPI xmlnode_GetTypeInfoCount(
+    IXMLDOMNode *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_GetTypeInfo(
+    IXMLDOMNode *iface,
+    UINT iTInfo,
+    LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_GetIDsOfNames(
+    IXMLDOMNode *iface,
+    REFIID riid,
+    LPOLESTR* rgszNames,
+    UINT cNames,
+    LCID lcid,
+    DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_Invoke(
+    IXMLDOMNode *iface,
+    DISPID dispIdMember,
+    REFIID riid,
+    LCID lcid,
+    WORD wFlags,
+    DISPPARAMS* pDispParams,
+    VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo,
+    UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_nodeName(
+    IXMLDOMNode *iface,
+    BSTR* name)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    const xmlChar *str;
+
+    TRACE("%p\n", This );
+
+    if (!name)
+        return E_INVALIDARG;
+
+    if ( !This->node )
+        return E_FAIL;
+
+    switch( This->node->type )
+    {
+    case XML_TEXT_NODE:
+        str = (const xmlChar*) "#text";
+        break;
+    case XML_DOCUMENT_NODE:
+        str = (const xmlChar*) "#document";
+	break;
+    default:
+        str = This->node->name;
+        break;
+    }
+
+    *name = bstr_from_xmlChar( str );
+    if (!*name)
+        return S_FALSE;
+
+    return S_OK;
+}
+
+BSTR bstr_from_xmlChar( const xmlChar *buf )
+{
+    DWORD len;
+    LPWSTR str;
+    BSTR bstr;
+
+    if ( !buf )
+        return NULL;
+
+    len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, NULL, 0 );
+    str = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
+    if ( !str )
+        return NULL;
+    MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, str, len );
+    bstr = SysAllocString( str );
+    HeapFree( GetProcessHeap(), 0, str );
+    return bstr;
+}
+
+static HRESULT WINAPI xmlnode_get_nodeValue(
+    IXMLDOMNode *iface,
+    VARIANT* value)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    HRESULT r = S_FALSE;
+
+    TRACE("%p %p\n", This, value);
+
+    V_BSTR(value) = NULL;
+    V_VT(value) = VT_NULL;
+
+    switch ( This->node->type )
+    {
+    case XML_ATTRIBUTE_NODE:
+      {
+        xmlChar *content = xmlNodeGetContent(This->node);
+        V_VT(value) = VT_BSTR;
+        V_BSTR(value) = bstr_from_xmlChar( content );
+        xmlFree(content);
+        r = S_OK;
+        break;
+      }
+    case XML_TEXT_NODE:
+        V_VT(value) = VT_BSTR;
+        V_BSTR(value) = bstr_from_xmlChar( This->node->content );
+        r = S_OK;
+        break;
+    case XML_ELEMENT_NODE:
+    case XML_DOCUMENT_NODE:
+        /* these seem to return NULL */
+        break;
+    case XML_PI_NODE:
+    default:
+        FIXME("node %p type %d\n", This, This->node->type);
+    }
+ 
+    TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
+
+    return r;
+}
+
+static HRESULT WINAPI xmlnode_put_nodeValue(
+    IXMLDOMNode *iface,
+    VARIANT value)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_nodeType(
+    IXMLDOMNode *iface,
+    DOMNodeType* type)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+
+    TRACE("%p %p\n", This, type);
+
+    assert( NODE_ELEMENT == XML_ELEMENT_NODE );
+    assert( NODE_NOTATION == XML_NOTATION_NODE );
+
+    *type = This->node->type;
+
+    return S_OK;
+}
+
+static HRESULT get_node(
+    xmlnode *This,
+    const char *name,
+    xmlNodePtr node,
+    IXMLDOMNode **out )
+{
+    TRACE("%p->%s %p\n", This, name, node );
+
+    if ( !out )
+        return E_INVALIDARG;
+    *out = create_node( node );
+    if (!*out)
+        return S_FALSE;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_get_parentNode(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** parent)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return get_node( This, "parent", This->node->parent, parent );
+}
+
+static HRESULT WINAPI xmlnode_get_childNodes(
+    IXMLDOMNode *iface,
+    IXMLDOMNodeList** childList)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+
+    TRACE("%p %p\n", This, childList );
+
+    if ( !childList )
+        return E_INVALIDARG;
+
+    *childList = create_children_nodelist(This->node);
+    if (*childList == NULL)
+        return E_OUTOFMEMORY;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_get_firstChild(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** firstChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return get_node( This, "firstChild", This->node->children, firstChild );
+}
+
+static HRESULT WINAPI xmlnode_get_lastChild(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** lastChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return get_node( This, "lastChild", This->node->last, lastChild );
+}
+
+static HRESULT WINAPI xmlnode_get_previousSibling(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** previousSibling)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return get_node( This, "previous", This->node->prev, previousSibling );
+}
+
+static HRESULT WINAPI xmlnode_get_nextSibling(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** nextSibling)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    return get_node( This, "next", This->node->next, nextSibling );
+}
+
+static HRESULT WINAPI xmlnode_get_attributes(
+    IXMLDOMNode *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    TRACE("%p\n", This);
+    *attributeMap = create_nodemap( iface );
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_insertBefore(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* newChild,
+    VARIANT refChild,
+    IXMLDOMNode** outNewChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    xmlNodePtr before_node, new_child_node;
+    IXMLDOMNode *before = NULL, *new;
+    HRESULT hr;
+
+    TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
+
+    if (!newChild)
+        return E_INVALIDARG;
+
+    switch(V_VT(&refChild))
+    {
+    case VT_EMPTY:
+    case VT_NULL:
+        break;
+
+    case VT_UNKNOWN:
+        hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
+        if(FAILED(hr)) return hr;
+        break;
+
+    case VT_DISPATCH:
+        hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
+        if(FAILED(hr)) return hr;
+        break;
+
+    default:
+        FIXME("refChild var type %x\n", V_VT(&refChild));
+        return E_FAIL;
+    }
+
+    IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
+    new_child_node = impl_from_IXMLDOMNode(new)->node;
+    TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
+
+    if(before)
+    {
+        before_node = impl_from_IXMLDOMNode(before)->node;
+        xmlAddPrevSibling(before_node, new_child_node);
+        IXMLDOMNode_Release(before);
+    }
+    else
+    {
+        xmlAddChild(This->node, new_child_node);
+    }
+
+    IXMLDOMNode_Release(new);
+    IXMLDOMNode_AddRef(newChild);
+    if(outNewChild)
+        *outNewChild = newChild;
+
+    TRACE("ret S_OK\n");
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_replaceChild(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* newChild,
+    IXMLDOMNode* oldChild,
+    IXMLDOMNode** outOldChild)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_removeChild(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* childNode,
+    IXMLDOMNode** oldChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    xmlNode *ancestor, *child_node_ptr;
+    HRESULT hr;
+    IXMLDOMNode *child;
+
+    TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
+
+    *oldChild = NULL;
+
+    if(!childNode) return E_INVALIDARG;
+
+    hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
+    if(FAILED(hr))
+        return hr;
+
+    child_node_ptr = ancestor = impl_from_IXMLDOMNode(child)->node;
+    while(ancestor->parent)
+    {
+        if(ancestor->parent == This->node)
+            break;
+        ancestor = ancestor->parent;
+    }
+    if(!ancestor->parent)
+    {
+        WARN("childNode %p is not a child of %p\n", childNode, iface);
+        IXMLDOMNode_Release(child);
+        return E_INVALIDARG;
+    }
+
+    xmlUnlinkNode(child_node_ptr);
+
+    IXMLDOMNode_Release(child);
+    IXMLDOMNode_AddRef(childNode);
+    *oldChild = childNode;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_appendChild(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* newChild,
+    IXMLDOMNode** outNewChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    VARIANT var;
+
+    TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
+    VariantInit(&var);
+    return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
+}
+
+static HRESULT WINAPI xmlnode_hasChildNodes(
+    IXMLDOMNode *iface,
+    VARIANT_BOOL* hasChild)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+
+    TRACE("%p\n", This);
+
+    if (!hasChild)
+        return E_INVALIDARG;
+    if (!This->node->children)
+    {
+        *hasChild = VARIANT_FALSE;
+        return S_FALSE;
+    }
+
+    *hasChild = VARIANT_TRUE;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_get_ownerDocument(
+    IXMLDOMNode *iface,
+    IXMLDOMDocument** DOMDocument)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_cloneNode(
+    IXMLDOMNode *iface,
+    VARIANT_BOOL deep,
+    IXMLDOMNode** cloneRoot)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    xmlNodePtr pClone = NULL;
+    IXMLDOMNode *pNode = NULL;
+
+    TRACE("%p (%d)\n", This, deep);
+
+    if(!cloneRoot)
+        return E_INVALIDARG;
+
+    pClone = xmlCopyNode(This->node, deep ? 1 : 2);
+    if(pClone)
+    {
+        pClone->doc = This->node->doc;
+
+        pNode = create_node(pClone);
+        if(!pNode)
+        {
+            ERR("Copy failed\n");
+            return E_FAIL;
+        }
+
+        *cloneRoot = pNode;
+    }
+    else
+    {
+        ERR("Copy failed\n");
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_get_nodeTypeString(
+    IXMLDOMNode *iface,
+    BSTR* xmlnodeType)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_text(
+    IXMLDOMNode *iface,
+    BSTR* text)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    BSTR str = NULL;
+
+    TRACE("%p\n", This);
+
+    if ( !text )
+        return E_INVALIDARG;
+
+    switch(This->node->type)
+    {
+    case XML_ELEMENT_NODE:
+    case XML_ATTRIBUTE_NODE:
+    {
+        xmlNodePtr child = This->node->children;
+        if ( child && child->type == XML_TEXT_NODE )
+            str = bstr_from_xmlChar( child->content );
+        break;
+    }
+
+    case XML_TEXT_NODE:
+    case XML_CDATA_SECTION_NODE:
+    case XML_PI_NODE:
+    case XML_COMMENT_NODE:
+        str = bstr_from_xmlChar( This->node->content );
+        break;
+
+    default:
+        FIXME("Unhandled node type %d\n", This->node->type);
+    }
+
+    /* Always return a string. */
+    if (!str) str = SysAllocStringLen( NULL, 0 );
+
+    TRACE("%p %s\n", This, debugstr_w(str) );
+    *text = str;
+ 
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnode_put_text(
+    IXMLDOMNode *iface,
+    BSTR text)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_specified(
+    IXMLDOMNode *iface,
+    VARIANT_BOOL* isSpecified)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_definition(
+    IXMLDOMNode *iface,
+    IXMLDOMNode** definitionNode)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_nodeTypedValue(
+    IXMLDOMNode *iface,
+    VARIANT* typedValue)
+{
+    FIXME("ignoring data type\n");
+    return xmlnode_get_nodeValue(iface, typedValue);
+}
+
+static HRESULT WINAPI xmlnode_put_nodeTypedValue(
+    IXMLDOMNode *iface,
+    VARIANT typedValue)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_dataType(
+    IXMLDOMNode *iface,
+    VARIANT* dataTypeName)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_put_dataType(
+    IXMLDOMNode *iface,
+    BSTR dataTypeName)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_xml(
+    IXMLDOMNode *iface,
+    BSTR* xmlString)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_transformNode(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* styleSheet,
+    BSTR* xmlString)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_selectNodes(
+    IXMLDOMNode *iface,
+    BSTR queryString,
+    IXMLDOMNodeList** resultList)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+
+    TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
+
+    return queryresult_create( This->node, queryString, resultList );
+}
+
+static HRESULT WINAPI xmlnode_selectSingleNode(
+    IXMLDOMNode *iface,
+    BSTR queryString,
+    IXMLDOMNode** resultNode)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    IXMLDOMNodeList *list;
+    HRESULT r;
+
+    TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
+
+    *resultNode = NULL;
+    r = IXMLDOMNode_selectNodes(iface, queryString, &list);
+    if(r == S_OK)
+    {
+        r = IXMLDOMNodeList_nextNode(list, resultNode);
+        IXMLDOMNodeList_Release(list);
+    }
+    return r;
+}
+
+static HRESULT WINAPI xmlnode_get_parsed(
+    IXMLDOMNode *iface,
+    VARIANT_BOOL* isParsed)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_namespaceURI(
+    IXMLDOMNode *iface,
+    BSTR* namespaceURI)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_prefix(
+    IXMLDOMNode *iface,
+    BSTR* prefixString)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnode_get_baseName(
+    IXMLDOMNode *iface,
+    BSTR* nameString)
+{
+    xmlnode *This = impl_from_IXMLDOMNode( iface );
+    BSTR str = NULL;
+    HRESULT r = S_FALSE;
+
+    TRACE("%p %p\n", This, nameString );
+
+    if ( !nameString )
+        return E_INVALIDARG;
+
+    switch ( This->node->type )
+    {
+    case XML_ELEMENT_NODE:
+    case XML_ATTRIBUTE_NODE:
+        str = bstr_from_xmlChar( This->node->name );
+        r = S_OK;
+        break;
+    case XML_TEXT_NODE:
+        break;
+    default:
+        ERR("Unhandled type %d\n", This->node->type );
+        break;
+    }
+
+    TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
+
+    *nameString = str;
+    return r;
+}
+
+static HRESULT WINAPI xmlnode_transformNodeToObject(
+    IXMLDOMNode *iface,
+    IXMLDOMNode* stylesheet,
+    VARIANT outputObject)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
+{
+    xmlnode_QueryInterface,
+    xmlnode_AddRef,
+    xmlnode_Release,
+    xmlnode_GetTypeInfoCount,
+    xmlnode_GetTypeInfo,
+    xmlnode_GetIDsOfNames,
+    xmlnode_Invoke,
+    xmlnode_get_nodeName,
+    xmlnode_get_nodeValue,
+    xmlnode_put_nodeValue,
+    xmlnode_get_nodeType,
+    xmlnode_get_parentNode,
+    xmlnode_get_childNodes,
+    xmlnode_get_firstChild,
+    xmlnode_get_lastChild,
+    xmlnode_get_previousSibling,
+    xmlnode_get_nextSibling,
+    xmlnode_get_attributes,
+    xmlnode_insertBefore,
+    xmlnode_replaceChild,
+    xmlnode_removeChild,
+    xmlnode_appendChild,
+    xmlnode_hasChildNodes,
+    xmlnode_get_ownerDocument,
+    xmlnode_cloneNode,
+    xmlnode_get_nodeTypeString,
+    xmlnode_get_text,
+    xmlnode_put_text,
+    xmlnode_get_specified,
+    xmlnode_get_definition,
+    xmlnode_get_nodeTypedValue,
+    xmlnode_put_nodeTypedValue,
+    xmlnode_get_dataType,
+    xmlnode_put_dataType,
+    xmlnode_get_xml,
+    xmlnode_transformNode,
+    xmlnode_selectNodes,
+    xmlnode_selectSingleNode,
+    xmlnode_get_parsed,
+    xmlnode_get_namespaceURI,
+    xmlnode_get_prefix,
+    xmlnode_get_baseName,
+    xmlnode_transformNodeToObject,
+};
+
+static HRESULT WINAPI Internal_QueryInterface(
+    IUnknown *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    xmlnode *This = impl_from_InternalUnknown( iface );
+
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+
+    if ( IsEqualGUID( riid, &IID_IUnknown ))
+        *ppvObject = iface;
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) )
+        *ppvObject = &This->lpVtbl;
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        *ppvObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef( (IUnknown*)*ppvObject );
+
+    return S_OK;
+}
+
+static ULONG WINAPI Internal_AddRef(
+                 IUnknown *iface )
+{
+    xmlnode *This = impl_from_InternalUnknown( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI Internal_Release(
+    IUnknown *iface )
+{
+    xmlnode *This = impl_from_InternalUnknown( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        if( This->node )
+	    xmldoc_release( This->node->doc );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static const struct IUnknownVtbl internal_unk_vtbl =
+{
+    Internal_QueryInterface,
+    Internal_AddRef,
+    Internal_Release
+};
+
+IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
+{
+    xmlnode *This;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    if(node)
+        xmldoc_add_ref( node->doc );
+
+    This->lpVtbl = &xmlnode_vtbl;
+    This->lpInternalUnkVtbl = &internal_unk_vtbl;
+
+    if(pUnkOuter)
+        This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
+    else
+        This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
+
+    This->ref = 1;
+    This->node = node;
+
+    return (IUnknown*)&This->lpInternalUnkVtbl;
+}
+
+IXMLDOMNode *create_node( xmlNodePtr node )
+{
+    IUnknown *pUnk;
+    IXMLDOMNode *ret;
+    HRESULT hr;
+
+    if ( !node )
+        return NULL;
+
+    TRACE("type %d\n", node->type);
+    switch(node->type)
+    {
+    case XML_ELEMENT_NODE:
+        pUnk = create_element( node, NULL );
+        break;
+    case XML_ATTRIBUTE_NODE:
+        pUnk = create_attribute( node );
+        break;
+    case XML_TEXT_NODE:
+        pUnk = create_text( node );
+        break;
+    case XML_COMMENT_NODE:
+        pUnk = create_comment( node );
+        break;
+    case XML_DOCUMENT_NODE:
+        ERR("shouldn't be here!\n");
+        return NULL;
+    default:
+        FIXME("only creating basic node for type %d\n", node->type);
+        pUnk = create_basic_node( node, NULL );
+    }
+
+    hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
+    IUnknown_Release(pUnk);
+    if(FAILED(hr)) return NULL;
+    return ret;
+}
+#endif

reactos/dll/win32/msxml3/nodelist.c

@@ -0,0 +1,278 @@
+/*
+ *    Node list implementation
+ *
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+/* This file implements the object returned by childNodes property. Note that this is
+ * not the IXMLDOMNodeList returned by XPath querites - it's implemented in queryresult.c.
+ * They are different because the list returned by childNodes:
+ *  - is "live" - changes to the XML tree are automatically reflected in the list
+ *  - doesn't supports IXMLDOMSelection
+ *  - note that an attribute node have a text child in DOM but not in the XPath data model
+ *    thus the child is inaccessible by an XPath query
+ */
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _xmlnodelist
+{
+    const struct IXMLDOMNodeListVtbl *lpVtbl;
+    LONG ref;
+    xmlNodePtr parent;
+    xmlNodePtr current;
+} xmlnodelist;
+
+static inline xmlnodelist *impl_from_IXMLDOMNodeList( IXMLDOMNodeList *iface )
+{
+    return (xmlnodelist *)((char*)iface - FIELD_OFFSET(xmlnodelist, lpVtbl));
+}
+
+static HRESULT WINAPI xmlnodelist_QueryInterface(
+    IXMLDOMNodeList *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
+         IsEqualGUID( riid, &IID_IDispatch ) ||
+         IsEqualGUID( riid, &IID_IXMLDOMNodeList ) )
+    {
+        *ppvObject = iface;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        *ppvObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMNodeList_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI xmlnodelist_AddRef(
+    IXMLDOMNodeList *iface )
+{
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI xmlnodelist_Release(
+    IXMLDOMNodeList *iface )
+{
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        xmldoc_release( This->parent->doc );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI xmlnodelist_GetTypeInfoCount(
+    IXMLDOMNodeList *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodelist_GetTypeInfo(
+    IXMLDOMNodeList *iface,
+    UINT iTInfo,
+    LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodelist_GetIDsOfNames(
+    IXMLDOMNodeList *iface,
+    REFIID riid,
+    LPOLESTR* rgszNames,
+    UINT cNames,
+    LCID lcid,
+    DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodelist_Invoke(
+    IXMLDOMNodeList *iface,
+    DISPID dispIdMember,
+    REFIID riid,
+    LCID lcid,
+    WORD wFlags,
+    DISPPARAMS* pDispParams,
+    VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo,
+    UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodelist_get_item(
+        IXMLDOMNodeList* iface,
+        long index,
+        IXMLDOMNode** listItem)
+{
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+    xmlNodePtr curr;
+    long nodeIndex = 0;
+
+    TRACE("%p %ld\n", This, index);
+ 
+    *listItem = NULL;
+
+    if (index < 0)
+        return S_FALSE;
+
+    curr = This->parent->children;
+    while(curr)
+    {
+        if(nodeIndex++ == index) break;
+        curr = curr->next;
+    }
+    if(!curr) return S_FALSE;
+
+    *listItem = create_node( curr );
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodelist_get_length(
+        IXMLDOMNodeList* iface,
+        long* listLength)
+{
+
+    xmlNodePtr curr;
+    long nodeCount = 0;
+
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p\n", This);
+
+    curr = This->parent->children;
+    while (curr)
+    {
+        nodeCount++;
+        curr = curr->next;
+    }
+
+    *listLength = nodeCount;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodelist_nextNode(
+        IXMLDOMNodeList* iface,
+        IXMLDOMNode** nextItem)
+{
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p %p\n", This, nextItem );
+
+    *nextItem = NULL;
+
+    if (!This->current)
+        return S_FALSE;
+
+    *nextItem = create_node( This->current );
+    This->current = This->current->next;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodelist_reset(
+        IXMLDOMNodeList* iface)
+{
+    xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p\n", This);
+    This->current = This->parent->children;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodelist__newEnum(
+        IXMLDOMNodeList* iface,
+        IUnknown** ppUnk)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+
+static const struct IXMLDOMNodeListVtbl xmlnodelist_vtbl =
+{
+    xmlnodelist_QueryInterface,
+    xmlnodelist_AddRef,
+    xmlnodelist_Release,
+    xmlnodelist_GetTypeInfoCount,
+    xmlnodelist_GetTypeInfo,
+    xmlnodelist_GetIDsOfNames,
+    xmlnodelist_Invoke,
+    xmlnodelist_get_item,
+    xmlnodelist_get_length,
+    xmlnodelist_nextNode,
+    xmlnodelist_reset,
+    xmlnodelist__newEnum,
+};
+
+IXMLDOMNodeList* create_children_nodelist( xmlNodePtr node )
+{
+    xmlnodelist *nodelist;
+
+    nodelist = HeapAlloc( GetProcessHeap(), 0, sizeof *nodelist );
+    if ( !nodelist )
+        return NULL;
+
+    nodelist->lpVtbl = &xmlnodelist_vtbl;
+    nodelist->ref = 1;
+    nodelist->parent = node;
+    nodelist->current = node->children;
+
+    xmldoc_add_ref( node->doc );
+
+    return (IXMLDOMNodeList*) &nodelist->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/nodemap.c

@@ -0,0 +1,428 @@
+/*
+ *    Node map implementation
+ *
+ * Copyright 2005 Mike McCormack
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+
+#define COBJMACROS
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winnls.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _xmlnodemap
+{
+    const struct IXMLDOMNamedNodeMapVtbl *lpVtbl;
+    const struct ISupportErrorInfoVtbl *lpSEIVtbl;
+    LONG ref;
+    IXMLDOMNode *node;
+    long iterator;
+} xmlnodemap;
+
+static inline xmlnodemap *impl_from_IXMLDOMNamedNodeMap( IXMLDOMNamedNodeMap *iface )
+{
+    return (xmlnodemap *)((char*)iface - FIELD_OFFSET(xmlnodemap, lpVtbl));
+}
+
+static inline xmlnodemap *impl_from_ISupportErrorInfo( ISupportErrorInfo *iface )
+{
+    return (xmlnodemap *)((char*)iface - FIELD_OFFSET(xmlnodemap, lpSEIVtbl));
+}
+
+static HRESULT WINAPI xmlnodemap_QueryInterface(
+    IXMLDOMNamedNodeMap *iface,
+    REFIID riid, void** ppvObject )
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+    if( IsEqualGUID( riid, &IID_IUnknown ) ||
+        IsEqualGUID( riid, &IID_IDispatch ) ||
+        IsEqualGUID( riid, &IID_IXMLDOMNamedNodeMap ) )
+    {
+        *ppvObject = iface;
+    }
+    else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
+    {
+        *ppvObject = &This->lpSEIVtbl;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMElement_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI xmlnodemap_AddRef(
+    IXMLDOMNamedNodeMap *iface )
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI xmlnodemap_Release(
+    IXMLDOMNamedNodeMap *iface )
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IXMLDOMNode_Release( This->node );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI xmlnodemap_GetTypeInfoCount(
+    IXMLDOMNamedNodeMap *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_GetTypeInfo(
+    IXMLDOMNamedNodeMap *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_GetIDsOfNames(
+    IXMLDOMNamedNodeMap *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_Invoke(
+    IXMLDOMNamedNodeMap *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+xmlChar *xmlChar_from_wchar( LPWSTR str )
+{
+    DWORD len;
+    xmlChar *xmlstr;
+
+    len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
+    xmlstr = HeapAlloc( GetProcessHeap(), 0, len );
+    if ( xmlstr )
+        WideCharToMultiByte( CP_UTF8, 0, str, -1, (LPSTR) xmlstr, len, NULL, NULL );
+    return xmlstr;
+}
+
+static HRESULT WINAPI xmlnodemap_getNamedItem(
+    IXMLDOMNamedNodeMap *iface,
+    BSTR name,
+    IXMLDOMNode** namedItem)
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    xmlChar *element_name;
+    xmlAttrPtr attr;
+    xmlNodePtr node;
+
+    TRACE("%p %s %p\n", This, debugstr_w(name), namedItem );
+
+    if ( !namedItem )
+        return E_INVALIDARG;
+
+    node = xmlNodePtr_from_domnode( This->node, 0 );
+    if ( !node )
+        return E_FAIL;
+
+    element_name = xmlChar_from_wchar( name );
+    attr = xmlHasNsProp( node, element_name, NULL );
+    HeapFree( GetProcessHeap(), 0, element_name );
+
+    if ( !attr )
+    {
+        *namedItem = NULL;
+        return S_FALSE;
+    }
+
+    *namedItem = create_node( (xmlNodePtr) attr );
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodemap_setNamedItem(
+    IXMLDOMNamedNodeMap *iface,
+    IXMLDOMNode* newItem,
+    IXMLDOMNode** namedItem)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_removeNamedItem(
+    IXMLDOMNamedNodeMap *iface,
+    BSTR name,
+    IXMLDOMNode** namedItem)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_get_item(
+    IXMLDOMNamedNodeMap *iface,
+    long index,
+    IXMLDOMNode** listItem)
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    xmlNodePtr node;
+    xmlAttrPtr curr;
+    long attrIndex;
+
+    TRACE("%p %ld\n", This, index);
+
+    *listItem = NULL;
+
+    if (index < 0)
+        return S_FALSE;
+
+    node = xmlNodePtr_from_domnode( This->node, 0 );
+    curr = node->properties;
+
+    for (attrIndex = 0; attrIndex < index; attrIndex++) {
+        if (curr->next == NULL)
+            return S_FALSE;
+        else
+            curr = curr->next;
+    }
+    
+    *listItem = create_node( (xmlNodePtr) curr );
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodemap_get_length(
+    IXMLDOMNamedNodeMap *iface,
+    long* listLength)
+{
+    xmlNodePtr node;
+    xmlAttrPtr first;
+    xmlAttrPtr curr;
+    long attrCount;
+
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+
+    TRACE("%p\n", This);
+
+    node = xmlNodePtr_from_domnode( This->node, 0 );
+    if ( !node )
+        return E_FAIL;
+
+    first = node->properties;
+    if (first == NULL) {
+	*listLength = 0;
+	return S_OK;
+    }
+
+    curr = first;
+    attrCount = 1;
+    while (curr->next != NULL) {
+        attrCount++;
+        curr = curr->next;
+    }
+    *listLength = attrCount;
+ 
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodemap_getQualifiedItem(
+    IXMLDOMNamedNodeMap *iface,
+    BSTR baseName,
+    BSTR namespaceURI,
+    IXMLDOMNode** qualifiedItem)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_removeQualifiedItem(
+    IXMLDOMNamedNodeMap *iface,
+    BSTR baseName,
+    BSTR namespaceURI,
+    IXMLDOMNode** qualifiedItem)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlnodemap_nextNode(
+    IXMLDOMNamedNodeMap *iface,
+    IXMLDOMNode** nextItem)
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+    xmlNodePtr node;
+    xmlAttrPtr curr;
+    long attrIndex;
+
+    TRACE("%p %ld\n", This, This->iterator);
+
+    *nextItem = NULL;
+
+    node = xmlNodePtr_from_domnode( This->node, 0 );
+    curr = node->properties;
+
+    for (attrIndex = 0; attrIndex < This->iterator; attrIndex++) {
+        if (curr->next == NULL)
+            return S_FALSE;
+        else
+            curr = curr->next;
+    }
+
+    This->iterator++;
+
+    *nextItem = create_node( (xmlNodePtr) curr );
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodemap_reset(
+    IXMLDOMNamedNodeMap *iface )
+{
+    xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
+
+    TRACE("%p %ld\n", This, This->iterator);
+
+    This->iterator = 0;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlnodemap__newEnum(
+    IXMLDOMNamedNodeMap *iface,
+    IUnknown** ppUnk)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMNamedNodeMapVtbl xmlnodemap_vtbl =
+{
+    xmlnodemap_QueryInterface,
+    xmlnodemap_AddRef,
+    xmlnodemap_Release,
+    xmlnodemap_GetTypeInfoCount,
+    xmlnodemap_GetTypeInfo,
+    xmlnodemap_GetIDsOfNames,
+    xmlnodemap_Invoke,
+    xmlnodemap_getNamedItem,
+    xmlnodemap_setNamedItem,
+    xmlnodemap_removeNamedItem,
+    xmlnodemap_get_item,
+    xmlnodemap_get_length,
+    xmlnodemap_getQualifiedItem,
+    xmlnodemap_removeQualifiedItem,
+    xmlnodemap_nextNode,
+    xmlnodemap_reset,
+    xmlnodemap__newEnum,
+};
+
+static HRESULT WINAPI support_error_QueryInterface(
+    ISupportErrorInfo *iface,
+    REFIID riid, void** ppvObject )
+{
+    xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+    return IXMLDOMNamedNodeMap_QueryInterface((IXMLDOMNamedNodeMap*)&This->lpVtbl, riid, ppvObject);
+}
+
+static ULONG WINAPI support_error_AddRef(
+    ISupportErrorInfo *iface )
+{
+    xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
+    return IXMLDOMNamedNodeMap_AddRef((IXMLDOMNamedNodeMap*)&This->lpVtbl);
+}
+
+static ULONG WINAPI support_error_Release(
+    ISupportErrorInfo *iface )
+{
+    xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
+    return IXMLDOMNamedNodeMap_Release((IXMLDOMNamedNodeMap*)&This->lpVtbl);
+}
+
+static HRESULT WINAPI support_error_InterfaceSupportsErrorInfo(
+    ISupportErrorInfo *iface,
+    REFIID riid )
+{
+    FIXME("(%p)->(%s)\n", iface, debugstr_guid(riid));
+    return S_FALSE;
+}
+
+static const struct ISupportErrorInfoVtbl support_error_vtbl =
+{
+    support_error_QueryInterface,
+    support_error_AddRef,
+    support_error_Release,
+    support_error_InterfaceSupportsErrorInfo
+};
+
+IXMLDOMNamedNodeMap *create_nodemap( IXMLDOMNode *node )
+{
+    xmlnodemap *nodemap;
+
+    nodemap = HeapAlloc( GetProcessHeap(), 0, sizeof *nodemap );
+    if ( !nodemap )
+        return NULL;
+
+    nodemap->lpVtbl = &xmlnodemap_vtbl;
+    nodemap->lpSEIVtbl = &support_error_vtbl;
+    nodemap->node = node;
+    nodemap->ref = 1;
+    nodemap->iterator = 0;
+
+    IXMLDOMNode_AddRef( node );
+    /* Since we AddRef a node here, we don't need to call xmldoc_add_ref() */
+
+    return (IXMLDOMNamedNodeMap*) &nodemap->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/parseerror.c

@@ -0,0 +1,261 @@
+/*
+ *    ParseError implementation
+ *
+ * Copyright 2005 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include <assert.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+typedef struct
+{
+    const struct IXMLDOMParseErrorVtbl *lpVtbl;
+    LONG ref;
+    LONG code, line, linepos, filepos;
+    BSTR url, reason, srcText;
+} parse_error_t;
+
+static inline parse_error_t *impl_from_IXMLDOMParseError( IXMLDOMParseError *iface )
+{
+    return (parse_error_t *)((char*)iface - FIELD_OFFSET(parse_error_t, lpVtbl));
+}
+
+static HRESULT WINAPI parseError_QueryInterface(
+    IXMLDOMParseError *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
+         IsEqualGUID( riid, &IID_IDispatch ) ||
+         IsEqualGUID( riid, &IID_IXMLDOMParseError ) )
+    {
+        *ppvObject = iface;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMParseError_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI parseError_AddRef(
+    IXMLDOMParseError *iface )
+{
+    parse_error_t *This = impl_from_IXMLDOMParseError( iface );
+    ULONG ref = InterlockedIncrement( &This->ref );
+    TRACE("(%p) ref now %d\n", This, ref);
+    return ref;
+}
+
+static ULONG WINAPI parseError_Release(
+    IXMLDOMParseError *iface )
+{
+    parse_error_t *This = impl_from_IXMLDOMParseError( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    TRACE("(%p) ref now %d\n", This, ref);
+    if ( ref == 0 )
+    {
+        SysFreeString(This->url);
+        SysFreeString(This->reason);
+        SysFreeString(This->srcText);
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI parseError_GetTypeInfoCount(
+    IXMLDOMParseError *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_GetTypeInfo(
+    IXMLDOMParseError *iface,
+    UINT iTInfo,
+    LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_GetIDsOfNames(
+    IXMLDOMParseError *iface,
+    REFIID riid,
+    LPOLESTR* rgszNames,
+    UINT cNames,
+    LCID lcid,
+    DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_Invoke(
+    IXMLDOMParseError *iface,
+    DISPID dispIdMember,
+    REFIID riid,
+    LCID lcid,
+    WORD wFlags,
+    DISPPARAMS* pDispParams,
+    VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo,
+    UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_get_errorCode(
+    IXMLDOMParseError *iface,
+    long *code )
+{
+    parse_error_t *This = impl_from_IXMLDOMParseError( iface );
+    TRACE("(%p)->(%p)\n", This, code);
+
+    *code = This->code;
+
+    if(This->code == 0)
+        return S_FALSE;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI parseError_get_url(
+    IXMLDOMParseError *iface,
+    BSTR *url )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_get_reason(
+    IXMLDOMParseError *iface,
+    BSTR *reason )
+{
+    parse_error_t *This = impl_from_IXMLDOMParseError( iface );
+    TRACE("(%p)->(%p)\n", This, reason);
+    
+    if(!This->reason)
+    {
+        *reason = NULL;
+        return S_FALSE;
+    }
+    *reason = SysAllocString(This->reason);
+    return S_OK;
+}
+
+static HRESULT WINAPI parseError_get_srcText(
+    IXMLDOMParseError *iface,
+    BSTR *srcText )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_get_line(
+    IXMLDOMParseError *iface,
+    long *line )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_get_linepos(
+    IXMLDOMParseError *iface,
+    long *linepos )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI parseError_get_filepos(
+    IXMLDOMParseError *iface,
+    long *filepos )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMParseErrorVtbl parseError_vtbl =
+{
+    parseError_QueryInterface,
+    parseError_AddRef,
+    parseError_Release,
+    parseError_GetTypeInfoCount,
+    parseError_GetTypeInfo,
+    parseError_GetIDsOfNames,
+    parseError_Invoke,
+    parseError_get_errorCode,
+    parseError_get_url,
+    parseError_get_reason,
+    parseError_get_srcText,
+    parseError_get_line,
+    parseError_get_linepos,
+    parseError_get_filepos
+};
+
+IXMLDOMParseError *create_parseError( LONG code, BSTR url, BSTR reason, BSTR srcText,
+                                      LONG line, LONG linepos, LONG filepos )
+{
+    parse_error_t *This;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &parseError_vtbl;
+    This->ref = 1;
+
+    This->code = code;
+    This->url = url;
+    This->reason = reason;
+    This->srcText = srcText;
+    This->line = line;
+    This->linepos = linepos;
+    This->filepos = filepos;
+
+    return (IXMLDOMParseError*) &This->lpVtbl;
+}

reactos/dll/win32/msxml3/pi.c

@@ -0,0 +1,539 @@
+/*
+ *    DOM processing instruction node implementation
+ *
+ * Copyright 2006 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _dom_pi
+{
+    const struct IXMLDOMProcessingInstructionVtbl *lpVtbl;
+    LONG ref;
+    IUnknown *node_unk;
+    IXMLDOMNode *node;
+} dom_pi;
+
+static inline dom_pi *impl_from_IXMLDOMProcessingInstruction( IXMLDOMProcessingInstruction *iface )
+{
+    return (dom_pi *)((char*)iface - FIELD_OFFSET(dom_pi, lpVtbl));
+}
+
+static HRESULT WINAPI dom_pi_QueryInterface(
+    IXMLDOMProcessingInstruction *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IXMLDOMProcessingInstruction ) ||
+         IsEqualGUID( riid, &IID_IUnknown ) )
+    {
+        *ppvObject = iface;
+    }
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) )
+    {
+        return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
+    }
+    else
+    {
+        FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMProcessingInstruction_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI dom_pi_AddRef(
+    IXMLDOMProcessingInstruction *iface )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI dom_pi_Release(
+    IXMLDOMProcessingInstruction *iface )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IUnknown_Release( This->node_unk );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI dom_pi_GetTypeInfoCount(
+    IXMLDOMProcessingInstruction *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_GetTypeInfo(
+    IXMLDOMProcessingInstruction *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_GetIDsOfNames(
+    IXMLDOMProcessingInstruction *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_Invoke(
+    IXMLDOMProcessingInstruction *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_get_nodeName(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nodeName( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_nodeValue(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT* var1 )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI dom_pi_put_nodeValue(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT var1 )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_put_nodeValue( This->node, var1 );
+}
+
+static HRESULT WINAPI dom_pi_get_nodeType(
+    IXMLDOMProcessingInstruction *iface,
+    DOMNodeType* domNodeType )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nodeType( This->node, domNodeType );
+}
+
+static HRESULT WINAPI dom_pi_get_parentNode(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** parent )
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_parentNode( This->node, parent );
+}
+
+static HRESULT WINAPI dom_pi_get_childNodes(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNodeList** outList)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_childNodes( This->node, outList );
+}
+
+static HRESULT WINAPI dom_pi_get_firstChild(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** domNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_firstChild( This->node, domNode );
+}
+
+static HRESULT WINAPI dom_pi_get_lastChild(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** domNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_lastChild( This->node, domNode );
+}
+
+static HRESULT WINAPI dom_pi_get_previousSibling(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** domNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_previousSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI dom_pi_get_nextSibling(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** domNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nextSibling( This->node, domNode );
+}
+
+static HRESULT WINAPI dom_pi_get_attributes(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_attributes( This->node, attributeMap );
+}
+
+static HRESULT WINAPI dom_pi_insertBefore(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* newNode, VARIANT var1,
+    IXMLDOMNode** outOldNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_insertBefore( This->node, newNode, var1, outOldNode );
+}
+
+static HRESULT WINAPI dom_pi_replaceChild(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* newNode,
+    IXMLDOMNode* oldNode,
+    IXMLDOMNode** outOldNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_replaceChild( This->node, newNode, oldNode, outOldNode );
+}
+
+static HRESULT WINAPI dom_pi_removeChild(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_removeChild( This->node, domNode, oldNode );
+}
+
+static HRESULT WINAPI dom_pi_appendChild(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_appendChild( This->node, newNode, outNewNode );
+}
+
+static HRESULT WINAPI dom_pi_hasChildNodes(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT_BOOL* pbool)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_hasChildNodes( This->node, pbool );
+}
+
+static HRESULT WINAPI dom_pi_get_ownerDocument(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMDocument** domDocument)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_ownerDocument( This->node, domDocument );
+}
+
+static HRESULT WINAPI dom_pi_cloneNode(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT_BOOL pbool, IXMLDOMNode** outNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_cloneNode( This->node, pbool, outNode );
+}
+
+static HRESULT WINAPI dom_pi_get_nodeTypeString(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nodeTypeString( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_text(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_text( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_put_text(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_put_text( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_specified(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT_BOOL* pbool)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_specified( This->node, pbool );
+}
+
+static HRESULT WINAPI dom_pi_get_definition(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode** domNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_definition( This->node, domNode );
+}
+
+static HRESULT WINAPI dom_pi_get_nodeTypedValue(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT* var1)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI dom_pi_put_nodeTypedValue(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT var1)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_put_nodeTypedValue( This->node, var1 );
+}
+
+static HRESULT WINAPI dom_pi_get_dataType(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT* var1)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_dataType( This->node, var1 );
+}
+
+static HRESULT WINAPI dom_pi_put_dataType(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_put_dataType( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_xml(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_xml( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_transformNode(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* domNode, BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_transformNode( This->node, domNode, p );
+}
+
+static HRESULT WINAPI dom_pi_selectNodes(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR p, IXMLDOMNodeList** outList)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_selectNodes( This->node, p, outList );
+}
+
+static HRESULT WINAPI dom_pi_selectSingleNode(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR p, IXMLDOMNode** outNode)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_selectSingleNode( This->node, p, outNode );
+}
+
+static HRESULT WINAPI dom_pi_get_parsed(
+    IXMLDOMProcessingInstruction *iface,
+    VARIANT_BOOL* pbool)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_parsed( This->node, pbool );
+}
+
+static HRESULT WINAPI dom_pi_get_namespaceURI(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_namespaceURI( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_prefix(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_prefix( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_get_baseName(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR* p)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_get_baseName( This->node, p );
+}
+
+static HRESULT WINAPI dom_pi_transformNodeToObject(
+    IXMLDOMProcessingInstruction *iface,
+    IXMLDOMNode* domNode, VARIANT var1)
+{
+    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
+    return IXMLDOMNode_transformNodeToObject( This->node, domNode, var1 );
+}
+
+static HRESULT WINAPI dom_pi_get_target(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_get_data(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI dom_pi_put_data(
+    IXMLDOMProcessingInstruction *iface,
+    BSTR data)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl =
+{
+    dom_pi_QueryInterface,
+    dom_pi_AddRef,
+    dom_pi_Release,
+    dom_pi_GetTypeInfoCount,
+    dom_pi_GetTypeInfo,
+    dom_pi_GetIDsOfNames,
+    dom_pi_Invoke,
+    dom_pi_get_nodeName,
+    dom_pi_get_nodeValue,
+    dom_pi_put_nodeValue,
+    dom_pi_get_nodeType,
+    dom_pi_get_parentNode,
+    dom_pi_get_childNodes,
+    dom_pi_get_firstChild,
+    dom_pi_get_lastChild,
+    dom_pi_get_previousSibling,
+    dom_pi_get_nextSibling,
+    dom_pi_get_attributes,
+    dom_pi_insertBefore,
+    dom_pi_replaceChild,
+    dom_pi_removeChild,
+    dom_pi_appendChild,
+    dom_pi_hasChildNodes,
+    dom_pi_get_ownerDocument,
+    dom_pi_cloneNode,
+    dom_pi_get_nodeTypeString,
+    dom_pi_get_text,
+    dom_pi_put_text,
+    dom_pi_get_specified,
+    dom_pi_get_definition,
+    dom_pi_get_nodeTypedValue,
+    dom_pi_put_nodeTypedValue,
+    dom_pi_get_dataType,
+    dom_pi_put_dataType,
+    dom_pi_get_xml,
+    dom_pi_transformNode,
+    dom_pi_selectNodes,
+    dom_pi_selectSingleNode,
+    dom_pi_get_parsed,
+    dom_pi_get_namespaceURI,
+    dom_pi_get_prefix,
+    dom_pi_get_baseName,
+    dom_pi_transformNodeToObject,
+
+    dom_pi_get_target,
+    dom_pi_get_data,
+    dom_pi_put_data
+};
+
+IUnknown* create_pi( xmlNodePtr pi )
+{
+    dom_pi *This;
+    HRESULT hr;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &dom_pi_vtbl;
+    This->ref = 1;
+
+    This->node_unk = create_basic_node( pi, (IUnknown*)&This->lpVtbl );
+    if(!This->node_unk)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return NULL;
+    }
+
+    hr = IUnknown_QueryInterface(This->node_unk, &IID_IXMLDOMNode, (LPVOID*)&This->node);
+    if(FAILED(hr))
+    {
+        IUnknown_Release(This->node_unk);
+        HeapFree( GetProcessHeap(), 0, This );
+        return NULL;
+    }
+    /* The ref on This->node is actually looped back into this object, so release it */
+    IXMLDOMNode_Release(This->node);
+
+    return (IUnknown*) &This->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/queryresult.c

@@ -0,0 +1,293 @@
+/*
+ *    XPath query result node list implementation (TODO: XSLPattern support)
+ *
+ * Copyright 2005 Mike McCormack
+ * Copyright 2007 Mikolaj Zalewski
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+/* This file implements the object returned by a XPath query. Note that this is
+ * not the IXMLDOMNodeList returned by childNodes - it's implemented in nodelist.c.
+ * They are different because the list returned by XPath queries:
+ *  - is static - gives the results for the XML tree as it existed during the
+ *    execution of the query
+ *  - supports IXMLDOMSelection (TODO)
+ *
+ * TODO: XSLPattern support
+ */
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+#include <libxml/xpath.h>
+
+static const struct IXMLDOMNodeListVtbl queryresult_vtbl;
+
+typedef struct _queryresult
+{
+    const struct IXMLDOMNodeListVtbl *lpVtbl;
+    LONG ref;
+    xmlNodePtr node;
+    xmlXPathObjectPtr result;
+    int resultPos;
+} queryresult;
+
+static inline queryresult *impl_from_IXMLDOMNodeList( IXMLDOMNodeList *iface )
+{
+    return (queryresult *)((char*)iface - FIELD_OFFSET(queryresult, lpVtbl));
+}
+
+HRESULT queryresult_create(xmlNodePtr node, LPWSTR szQuery, IXMLDOMNodeList **out)
+{
+    queryresult *This = CoTaskMemAlloc(sizeof(queryresult));
+    xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
+    xmlChar *str = xmlChar_from_wchar(szQuery);
+    HRESULT hr;
+
+
+    TRACE("(%p, %s, %p)\n", node, wine_dbgstr_w(szQuery), out);
+
+    *out = NULL;
+    if (This == NULL || ctxt == NULL || str == NULL)
+    {
+        hr = E_OUTOFMEMORY;
+        goto cleanup;
+    }
+
+    This->lpVtbl = &queryresult_vtbl;
+    This->ref = 1;
+    This->resultPos = 0;
+    This->node = node;
+    xmldoc_add_ref(This->node->doc);
+
+    ctxt->node = node;
+    This->result = xmlXPathEval(str, ctxt);
+    if (!This->result || This->result->type != XPATH_NODESET)
+    {
+        hr = E_FAIL;
+        goto cleanup;
+    }
+
+    *out = (IXMLDOMNodeList *)This;
+    hr = S_OK;
+    TRACE("found %d matches\n", This->result->nodesetval->nodeNr);
+
+cleanup:
+    if (This != NULL && FAILED(hr))
+        IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
+    if (ctxt != NULL)
+        xmlXPathFreeContext(ctxt);
+    HeapFree(GetProcessHeap(), 0, str);
+    return hr;
+}
+
+
+static HRESULT WINAPI queryresult_QueryInterface(
+    IXMLDOMNodeList *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
+         IsEqualGUID( riid, &IID_IDispatch ) ||
+         IsEqualGUID( riid, &IID_IXMLDOMNodeList ) )
+    {
+        *ppvObject = iface;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        *ppvObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMNodeList_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI queryresult_AddRef(
+    IXMLDOMNodeList *iface )
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI queryresult_Release(
+    IXMLDOMNodeList *iface )
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement(&This->ref);
+    if ( ref == 0 )
+    {
+        xmlXPathFreeObject(This->result);
+        xmldoc_release(This->node->doc);
+        CoTaskMemFree(This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI queryresult_GetTypeInfoCount(
+    IXMLDOMNodeList *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI queryresult_GetTypeInfo(
+    IXMLDOMNodeList *iface,
+    UINT iTInfo,
+    LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI queryresult_GetIDsOfNames(
+    IXMLDOMNodeList *iface,
+    REFIID riid,
+    LPOLESTR* rgszNames,
+    UINT cNames,
+    LCID lcid,
+    DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI queryresult_Invoke(
+    IXMLDOMNodeList *iface,
+    DISPID dispIdMember,
+    REFIID riid,
+    LCID lcid,
+    WORD wFlags,
+    DISPPARAMS* pDispParams,
+    VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo,
+    UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI queryresult_get_item(
+        IXMLDOMNodeList* iface,
+        long index,
+        IXMLDOMNode** listItem)
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p %ld\n", This, index);
+
+    *listItem = NULL;
+
+    if (index < 0 || index >= This->result->nodesetval->nodeNr)
+        return S_FALSE;
+
+    *listItem = create_node(This->result->nodesetval->nodeTab[index]);
+    This->resultPos = index + 1;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI queryresult_get_length(
+        IXMLDOMNodeList* iface,
+        long* listLength)
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p\n", This);
+
+    *listLength = This->result->nodesetval->nodeNr;
+    return S_OK;
+}
+
+static HRESULT WINAPI queryresult_nextNode(
+        IXMLDOMNodeList* iface,
+        IXMLDOMNode** nextItem)
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p %p\n", This, nextItem );
+
+    *nextItem = NULL;
+
+    if (This->resultPos >= This->result->nodesetval->nodeNr)
+        return S_FALSE;
+
+    *nextItem = create_node(This->result->nodesetval->nodeTab[This->resultPos]);
+    This->resultPos++;
+    return S_OK;
+}
+
+static HRESULT WINAPI queryresult_reset(
+        IXMLDOMNodeList* iface)
+{
+    queryresult *This = impl_from_IXMLDOMNodeList( iface );
+
+    TRACE("%p\n", This);
+    This->resultPos = 0;
+    return S_OK;
+}
+
+static HRESULT WINAPI queryresult__newEnum(
+        IXMLDOMNodeList* iface,
+        IUnknown** ppUnk)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+
+static const struct IXMLDOMNodeListVtbl queryresult_vtbl =
+{
+    queryresult_QueryInterface,
+    queryresult_AddRef,
+    queryresult_Release,
+    queryresult_GetTypeInfoCount,
+    queryresult_GetTypeInfo,
+    queryresult_GetIDsOfNames,
+    queryresult_Invoke,
+    queryresult_get_item,
+    queryresult_get_length,
+    queryresult_nextNode,
+    queryresult_reset,
+    queryresult__newEnum,
+};
+
+#endif

reactos/dll/win32/msxml3/regsvr.c

@@ -0,0 +1,680 @@
+/*
+ *	MSXML3 self-registerable dll functions
+ *
+ * Copyright (C) 2003 John K. Hohm
+ * Copyright (C) 2006 Robert Shearman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+
+#include <stdarg.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "winerror.h"
+#include "ole2.h"
+#include "msxml.h"
+#include "xmldom.h"
+#include "xmldso.h"
+#include "msxml2.h"
+
+/* undef the #define in msxml2 so that we can access the v.2 version
+   independent CLSID as well as the v.3 one. */
+#undef CLSID_DOMDocument
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+/*
+ * Near the bottom of this file are the exported DllRegisterServer and
+ * DllUnregisterServer, which make all this worthwhile.
+ */
+
+/***********************************************************************
+ *		interface for self-registering
+ */
+struct regsvr_interface
+{
+    IID const *iid;		/* NULL for end of list */
+    LPCSTR name;		/* can be NULL to omit */
+    IID const *base_iid;	/* can be NULL to omit */
+    int num_methods;		/* can be <0 to omit */
+    CLSID const *ps_clsid;	/* can be NULL to omit */
+    CLSID const *ps_clsid32;	/* can be NULL to omit */
+};
+
+static HRESULT register_interfaces(struct regsvr_interface const *list);
+static HRESULT unregister_interfaces(struct regsvr_interface const *list);
+
+struct regsvr_coclass
+{
+    CLSID const *clsid;		/* NULL for end of list */
+    LPCSTR name;		/* can be NULL to omit */
+    LPCSTR ips;			/* can be NULL to omit */
+    LPCSTR ips32;		/* can be NULL to omit */
+    LPCSTR ips32_tmodel;	/* can be NULL to omit */
+    LPCSTR progid;		/* can be NULL to omit */
+    LPCSTR version;		/* can be NULL to omit */
+};
+
+static HRESULT register_coclasses(struct regsvr_coclass const *list);
+static HRESULT unregister_coclasses(struct regsvr_coclass const *list);
+
+struct progid
+{
+    LPCSTR name;		/* NULL for end of list */
+    LPCSTR description;		/* can be NULL to omit */
+    CLSID const *clsid;
+    LPCSTR curver;		/* can be NULL to omit */
+};
+
+static HRESULT register_progids(struct progid const *list);
+static HRESULT unregister_progids(struct progid const *list);
+
+/***********************************************************************
+ *		static string constants
+ */
+static WCHAR const interface_keyname[10] = {
+    'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };
+static WCHAR const base_ifa_keyname[14] = {
+    'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c',
+    'e', 0 };
+static WCHAR const num_methods_keyname[11] = {
+    'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };
+static WCHAR const ps_clsid_keyname[15] = {
+    'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
+    'i', 'd', 0 };
+static WCHAR const ps_clsid32_keyname[17] = {
+    'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
+    'i', 'd', '3', '2', 0 };
+static WCHAR const clsid_keyname[6] = {
+    'C', 'L', 'S', 'I', 'D', 0 };
+static WCHAR const ips_keyname[13] = {
+    'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
+    0 };
+static WCHAR const ips32_keyname[15] = {
+    'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
+    '3', '2', 0 };
+static WCHAR const progid_keyname[7] = {
+    'P', 'r', 'o', 'g', 'I', 'D', 0 };
+static WCHAR const versionindependentprogid_keyname[] = {
+    'V', 'e', 'r', 's', 'i', 'o', 'n',
+    'I', 'n', 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 't',
+    'P', 'r', 'o', 'g', 'I', 'D', 0 };
+static WCHAR const version_keyname[] = {
+    'V', 'e', 'r', 's', 'i', 'o', 'n', 0 };
+static WCHAR const curver_keyname[] = {
+    'C', 'u', 'r', 'V', 'e', 'r', 0 };
+static char const tmodel_valuename[] = "ThreadingModel";
+
+/***********************************************************************
+ *		static helper functions
+ */
+static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);
+static LONG register_key_defvalueW(HKEY base, WCHAR const *name,
+				   WCHAR const *value);
+static LONG register_key_defvalueA(HKEY base, WCHAR const *name,
+				   char const *value);
+
+/***********************************************************************
+ *		register_interfaces
+ */
+static HRESULT register_interfaces(struct regsvr_interface const *list)
+{
+    LONG res = ERROR_SUCCESS;
+    HKEY interface_key;
+
+    res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
+			  KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
+    if (res != ERROR_SUCCESS) goto error_return;
+
+    for (; res == ERROR_SUCCESS && list->iid; ++list) {
+	WCHAR buf[39];
+	HKEY iid_key;
+
+	StringFromGUID2(list->iid, buf, 39);
+	res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
+			      KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
+	if (res != ERROR_SUCCESS) goto error_close_interface_key;
+
+	if (list->name) {
+	    res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
+				 (CONST BYTE*)(list->name),
+				 strlen(list->name) + 1);
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+	}
+
+	if (list->base_iid) {
+	    res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+	}
+
+	if (0 <= list->num_methods) {
+	    static WCHAR const fmt[3] = { '%', 'd', 0 };
+	    HKEY key;
+
+	    res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
+				  KEY_READ | KEY_WRITE, NULL, &key, NULL);
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+
+	    wsprintfW(buf, fmt, list->num_methods);
+	    res = RegSetValueExW(key, NULL, 0, REG_SZ,
+				 (CONST BYTE*)buf,
+				 (lstrlenW(buf) + 1) * sizeof(WCHAR));
+	    RegCloseKey(key);
+
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+	}
+
+	if (list->ps_clsid) {
+	    res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+	}
+
+	if (list->ps_clsid32) {
+	    res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
+	    if (res != ERROR_SUCCESS) goto error_close_iid_key;
+	}
+
+    error_close_iid_key:
+	RegCloseKey(iid_key);
+    }
+
+error_close_interface_key:
+    RegCloseKey(interface_key);
+error_return:
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		unregister_interfaces
+ */
+static HRESULT unregister_interfaces(struct regsvr_interface const *list)
+{
+    LONG res = ERROR_SUCCESS;
+    HKEY interface_key;
+
+    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
+			KEY_READ | KEY_WRITE, &interface_key);
+    if (res == ERROR_FILE_NOT_FOUND) return S_OK;
+    if (res != ERROR_SUCCESS) goto error_return;
+
+    for (; res == ERROR_SUCCESS && list->iid; ++list) {
+	WCHAR buf[39];
+
+	StringFromGUID2(list->iid, buf, 39);
+	res = RegDeleteTreeW(interface_key, buf);
+	if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
+    }
+
+    RegCloseKey(interface_key);
+error_return:
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		register_coclasses
+ */
+static HRESULT register_coclasses(struct regsvr_coclass const *list)
+{
+    LONG res = ERROR_SUCCESS;
+    HKEY coclass_key;
+
+    res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
+			  KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
+    if (res != ERROR_SUCCESS) goto error_return;
+
+    for (; res == ERROR_SUCCESS && list->clsid; ++list) {
+	WCHAR buf[39];
+	HKEY clsid_key;
+
+	StringFromGUID2(list->clsid, buf, 39);
+	res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
+			      KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
+	if (res != ERROR_SUCCESS) goto error_close_coclass_key;
+
+	if (list->name) {
+	    res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
+				 (CONST BYTE*)(list->name),
+				 strlen(list->name) + 1);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	}
+
+	if (list->ips) {
+	    res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	}
+
+	if (list->ips32) {
+	    HKEY ips32_key;
+
+	    res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
+				  KEY_READ | KEY_WRITE, NULL,
+				  &ips32_key, NULL);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+
+	    res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
+				 (CONST BYTE*)list->ips32,
+				 lstrlenA(list->ips32) + 1);
+	    if (res == ERROR_SUCCESS && list->ips32_tmodel)
+		res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
+				     (CONST BYTE*)list->ips32_tmodel,
+				     strlen(list->ips32_tmodel) + 1);
+	    RegCloseKey(ips32_key);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	}
+
+	if (list->progid) {
+            char *buffer = NULL;
+            LPCSTR progid;
+
+	    if (list->version) {
+		buffer = HeapAlloc(GetProcessHeap(), 0, strlen(list->progid) + strlen(list->version) + 2);
+		if (!buffer) {
+		    res = ERROR_OUTOFMEMORY;
+		    goto error_close_clsid_key;
+		}
+		strcpy(buffer, list->progid);
+		strcat(buffer, ".");
+		strcat(buffer, list->version);
+		progid = buffer;
+	    } else
+		progid = list->progid;
+	    res = register_key_defvalueA(clsid_key, progid_keyname,
+					 progid);
+	    HeapFree(GetProcessHeap(), 0, buffer);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+
+	    if (list->version) {
+	        res = register_key_defvalueA(clsid_key, versionindependentprogid_keyname,
+					     list->progid);
+		if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	    }
+	}
+
+	if (list->version) {
+	    res = register_key_defvalueA(clsid_key, version_keyname,
+					 list->version);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	}
+
+    error_close_clsid_key:
+	RegCloseKey(clsid_key);
+    }
+
+error_close_coclass_key:
+    RegCloseKey(coclass_key);
+error_return:
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		unregister_coclasses
+ */
+static HRESULT unregister_coclasses(struct regsvr_coclass const *list)
+{
+    LONG res = ERROR_SUCCESS;
+    HKEY coclass_key;
+
+    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
+			KEY_READ | KEY_WRITE, &coclass_key);
+    if (res == ERROR_FILE_NOT_FOUND) return S_OK;
+    if (res != ERROR_SUCCESS) goto error_return;
+
+    for (; res == ERROR_SUCCESS && list->clsid; ++list) {
+	WCHAR buf[39];
+
+	StringFromGUID2(list->clsid, buf, 39);
+	res = RegDeleteTreeW(coclass_key, buf);
+	if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
+	if (res != ERROR_SUCCESS) goto error_close_coclass_key;
+    }
+
+error_close_coclass_key:
+    RegCloseKey(coclass_key);
+error_return:
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		register_progids
+ */
+static HRESULT register_progids(struct progid const *list)
+{
+    LONG res = ERROR_SUCCESS;
+
+    for (; res == ERROR_SUCCESS && list->name; ++list) {
+	WCHAR buf[39];
+	HKEY progid_key;
+
+	res = RegCreateKeyExA(HKEY_CLASSES_ROOT, list->name, 0,
+			  NULL, 0, KEY_READ | KEY_WRITE, NULL,
+			  &progid_key, NULL);
+	if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+
+	res = RegSetValueExA(progid_key, NULL, 0, REG_SZ,
+			 (CONST BYTE*)list->description,
+			 strlen(list->description) + 1);
+	if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+
+	StringFromGUID2(list->clsid, buf, 39);
+
+	res = register_key_defvalueW(progid_key, clsid_keyname, buf);
+	if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+
+	if (list->curver) {
+	    res = register_key_defvalueA(progid_key, curver_keyname, list->curver);
+	    if (res != ERROR_SUCCESS) goto error_close_clsid_key;
+	}
+
+    error_close_clsid_key:
+	RegCloseKey(progid_key);
+    }
+
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		unregister_progids
+ */
+static HRESULT unregister_progids(struct progid const *list)
+{
+    LONG res = ERROR_SUCCESS;
+
+    for (; res == ERROR_SUCCESS && list->name; ++list) {
+	res = RegDeleteTreeA(HKEY_CLASSES_ROOT, list->name);
+	if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS;
+    }
+
+    return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
+}
+
+/***********************************************************************
+ *		regsvr_key_guid
+ */
+static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid)
+{
+    WCHAR buf[39];
+
+    StringFromGUID2(guid, buf, 39);
+    return register_key_defvalueW(base, name, buf);
+}
+
+/***********************************************************************
+ *		regsvr_key_defvalueW
+ */
+static LONG register_key_defvalueW(
+    HKEY base,
+    WCHAR const *name,
+    WCHAR const *value)
+{
+    LONG res;
+    HKEY key;
+
+    res = RegCreateKeyExW(base, name, 0, NULL, 0,
+			  KEY_READ | KEY_WRITE, NULL, &key, NULL);
+    if (res != ERROR_SUCCESS) return res;
+    res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
+			 (lstrlenW(value) + 1) * sizeof(WCHAR));
+    RegCloseKey(key);
+    return res;
+}
+
+/***********************************************************************
+ *		regsvr_key_defvalueA
+ */
+static LONG register_key_defvalueA(
+    HKEY base,
+    WCHAR const *name,
+    char const *value)
+{
+    LONG res;
+    HKEY key;
+
+    res = RegCreateKeyExW(base, name, 0, NULL, 0,
+			  KEY_READ | KEY_WRITE, NULL, &key, NULL);
+    if (res != ERROR_SUCCESS) return res;
+    res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
+			 lstrlenA(value) + 1);
+    RegCloseKey(key);
+    return res;
+}
+
+/***********************************************************************
+ *		coclass list
+ */
+static struct regsvr_coclass const coclass_list[] = {
+    {   &CLSID_DOMDocument,
+	"XML DOM Document",
+	NULL,
+	"msxml3.dll",
+	"Both",
+	"Microsoft.XMLDOM",
+	"1.0"
+    },
+    {   &CLSID_DOMDocument2,
+        "XML DOM Document",
+        NULL,
+        "msxml3.dll",
+        "Both",
+        "Msxml2.DOMDocument",
+        "3.0"
+    },
+    {   &CLSID_DOMDocument30,
+        "XML DOM Document 3.0",
+        NULL,
+        "msxml3.dll",
+        "Both",
+        "Msxml2.DOMDocument",
+        "3.0"
+    },
+    {   &CLSID_DOMFreeThreadedDocument,
+	"Free threaded XML DOM Document",
+	NULL,
+	"msxml3.dll",
+	"Both",
+	"Microsoft.FreeThreadedXMLDOM",
+	"1.0"
+    },
+    {   &CLSID_DOMFreeThreadedDocument,
+        "Free threaded XML DOM Document",
+        NULL,
+        "msxml3.dll",
+        "Both",
+        "Microsoft.FreeThreadedXMLDOM",
+        NULL
+    },
+    {   &CLSID_FreeThreadedDOMDocument,
+        "Free Threaded XML DOM Document",
+        NULL,
+        "msxml3.dll",
+        "Both",
+        "Microsoft.FreeThreadedXMLDOM.1.0",
+        "1.0"
+     },
+
+    {   &CLSID_XMLHTTPRequest,
+	"XML HTTP Request",
+	NULL,
+	"msxml3.dll",
+	"Apartment",
+	"Microsoft.XMLHTTP",
+	"1.0"
+    },
+    {   &CLSID_XMLDSOControl,
+	"XML Data Source Object",
+	NULL,
+	"msxml3.dll",
+	"Apartment",
+	"Microsoft.XMLDSO",
+	"1.0"
+    },
+    {   &CLSID_XMLDocument,
+	"Msxml",
+	NULL,
+	"msxml3.dll",
+	"Both",
+	"Msxml"
+    },
+    {   &CLSID_XMLSchemaCache,
+	"XML Schema Cache",
+	NULL,
+	"msxml3.dll",
+	"Both",
+	"Msxml2.XMLSchemaCache",
+        "3.0"
+    },
+    {   &CLSID_XMLSchemaCache30,
+	"XML Schema Cache 3.0",
+	NULL,
+	"msxml3.dll",
+	"Both",
+	"Msxml2.XMLSchemaCache",
+        "3.0"
+    },
+    { NULL }			/* list terminator */
+};
+
+/***********************************************************************
+ *		interface list
+ */
+static struct regsvr_interface const interface_list[] = {
+    { NULL }			/* list terminator */
+};
+
+/***********************************************************************
+ *		progid list
+ */
+static struct progid const progid_list[] = {
+    {   "Microsoft.XMLDOM",
+	"XML DOM Document",
+	&CLSID_DOMDocument,
+	"Microsoft.XMLDOM.1.0"
+    },
+    {   "Microsoft.XMLDOM.1.0",
+	"XML DOM Document",
+	&CLSID_DOMDocument,
+	NULL
+    },
+    {   "MSXML.DOMDocument",
+	"XML DOM Document",
+	&CLSID_DOMDocument,
+	"Microsoft.XMLDOM.1.0"
+    },
+    {   "Msxml2.DOMDocument",
+        "XML DOM Document",
+        &CLSID_DOMDocument2,
+        "Msxml2.DOMDocument.3.0"
+    },
+    {   "Msxml2.DOMDocument.3.0",
+        "XML DOM Document 3.0",
+        &CLSID_DOMDocument30,
+        NULL
+    },
+    {   "Microsoft.FreeThreadedXMLDOM",
+	"Free threaded XML DOM Document",
+	&CLSID_DOMFreeThreadedDocument,
+	"Microsoft.FreeThreadedXMLDOM.1.0"
+    },
+    {   "Microsoft.FreeThreadedXMLDOM.1.0",
+	"Free threaded XML DOM Document",
+	&CLSID_DOMFreeThreadedDocument,
+	NULL
+    },
+    {   "MSXML.FreeThreadedDOMDocument",
+	"Free threaded XML DOM Document",
+	&CLSID_DOMFreeThreadedDocument,
+	"Microsoft.FreeThreadedXMLDOM.1.0"
+    },
+    {   "Microsoft.XMLHTTP",
+	"XML HTTP Request",
+	&CLSID_XMLHTTPRequest,
+	"Microsoft.XMLHTTP.1.0"
+    },
+    {   "Microsoft.XMLHTTP.1.0",
+	"XML HTTP Request",
+	&CLSID_XMLHTTPRequest,
+	NULL
+    },
+    {   "Microsoft.XMLDSO",
+	"XML Data Source Object",
+	&CLSID_XMLDSOControl,
+	"Microsoft.XMLDSO.1.0"
+    },
+    {   "Microsoft.XMLDSO.1.0",
+	"XML Data Source Object",
+	&CLSID_XMLDSOControl,
+	NULL
+    },
+    {   "Msxml",
+	"Msxml",
+	&CLSID_XMLDocument,
+	NULL
+    },
+    {   "Msxml2.XMLSchemaCache",
+        "XML Schema Cache",
+        &CLSID_XMLSchemaCache,
+        "Msxml2.XMLSchemaCache.3.0"
+    },
+    {   "Msxml2.XMLSchemaCache.3.0",
+        "XML Schema Cache 3.0",
+        &CLSID_XMLSchemaCache30,
+        NULL
+    },
+
+    { NULL }			/* list terminator */
+};
+
+/***********************************************************************
+ *		DllRegisterServer (OLEAUT32.@)
+ */
+HRESULT WINAPI DllRegisterServer(void)
+{
+    HRESULT hr;
+
+    TRACE("\n");
+
+    hr = register_coclasses(coclass_list);
+    if (SUCCEEDED(hr))
+	hr = register_interfaces(interface_list);
+    if (SUCCEEDED(hr))
+	hr = register_progids(progid_list);
+    return hr;
+}
+
+/***********************************************************************
+ *		DllUnregisterServer (OLEAUT32.@)
+ */
+HRESULT WINAPI DllUnregisterServer(void)
+{
+    HRESULT hr;
+
+    TRACE("\n");
+
+    hr = unregister_coclasses(coclass_list);
+    if (SUCCEEDED(hr))
+	hr = unregister_interfaces(interface_list);
+    if (SUCCEEDED(hr))
+	hr = unregister_progids(progid_list);
+    return hr;
+}

reactos/dll/win32/msxml3/schema.c

@@ -0,0 +1,204 @@
+/*
+ * Schema cache implementation
+ *
+ * Copyright 2007 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "wine/debug.h"
+
+#include "msxml_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+
+typedef struct
+{
+    const struct IXMLDOMSchemaCollectionVtbl *lpVtbl;
+    LONG ref;
+} schema_t;
+
+static inline schema_t *impl_from_IXMLDOMSchemaCollection( IXMLDOMSchemaCollection *iface )
+{
+    return (schema_t *)((char*)iface - FIELD_OFFSET(schema_t, lpVtbl));
+}
+
+static HRESULT WINAPI schema_cache_QueryInterface( IXMLDOMSchemaCollection *iface, REFIID riid, void** ppvObject )
+{
+    schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
+
+    TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
+
+    if ( IsEqualIID( riid, &IID_IUnknown ) ||
+         IsEqualIID( riid, &IID_IDispatch ) ||
+         IsEqualIID( riid, &IID_IXMLDOMSchemaCollection ) )
+    {
+        *ppvObject = iface;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMSchemaCollection_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI schema_cache_AddRef( IXMLDOMSchemaCollection *iface )
+{
+    schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
+    LONG ref = InterlockedIncrement( &This->ref );
+    TRACE("%p new ref %d\n", This, ref);
+    return ref;
+}
+
+static ULONG WINAPI schema_cache_Release( IXMLDOMSchemaCollection *iface )
+{
+    schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
+    LONG ref = InterlockedDecrement( &This->ref );
+    TRACE("%p new ref %d\n", This, ref);
+
+    if ( ref == 0 )
+    {
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI schema_cache_GetTypeInfoCount( IXMLDOMSchemaCollection *iface, UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_GetTypeInfo( IXMLDOMSchemaCollection *iface,
+                                                UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_GetIDsOfNames( IXMLDOMSchemaCollection *iface,
+                                                  REFIID riid,
+                                                  LPOLESTR* rgszNames,
+                                                  UINT cNames,
+                                                  LCID lcid,
+                                                  DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_Invoke( IXMLDOMSchemaCollection *iface,
+                                           DISPID dispIdMember,
+                                           REFIID riid,
+                                           LCID lcid,
+                                           WORD wFlags,
+                                           DISPPARAMS* pDispParams,
+                                           VARIANT* pVarResult,
+                                           EXCEPINFO* pExcepInfo,
+                                           UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_add( IXMLDOMSchemaCollection *iface, BSTR uri, VARIANT var )
+{
+    FIXME("(%p)->(%s, var(vt %x)): stub\n", iface, debugstr_w(uri), V_VT(&var));
+    return S_OK;
+}
+
+static HRESULT WINAPI schema_cache_get( IXMLDOMSchemaCollection *iface, BSTR uri, IXMLDOMNode **node )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_remove( IXMLDOMSchemaCollection *iface, BSTR uri )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_get_length( IXMLDOMSchemaCollection *iface, long *length )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_get_namespaceURI( IXMLDOMSchemaCollection *iface, long index, BSTR *len )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_addCollection( IXMLDOMSchemaCollection *iface, IXMLDOMSchemaCollection *otherCollection )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI schema_cache_get__newEnum( IXMLDOMSchemaCollection *iface, IUnknown **ppUnk )
+{
+    FIXME("stub\n");
+    return E_NOTIMPL;
+}
+
+static const struct IXMLDOMSchemaCollectionVtbl schema_vtbl =
+{
+    schema_cache_QueryInterface,
+    schema_cache_AddRef,
+    schema_cache_Release,
+    schema_cache_GetTypeInfoCount,
+    schema_cache_GetTypeInfo,
+    schema_cache_GetIDsOfNames,
+    schema_cache_Invoke,
+    schema_cache_add,
+    schema_cache_get,
+    schema_cache_remove,
+    schema_cache_get_length,
+    schema_cache_get_namespaceURI,
+    schema_cache_addCollection,
+    schema_cache_get__newEnum
+};
+
+HRESULT SchemaCache_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+{
+    schema_t *schema = HeapAlloc( GetProcessHeap(), 0, sizeof (*schema) );
+    if( !schema )
+        return E_OUTOFMEMORY;
+
+    schema->lpVtbl = &schema_vtbl;
+    schema->ref = 1;
+
+    *ppObj = &schema->lpVtbl;
+    return S_OK;
+}

reactos/dll/win32/msxml3/text.c

@@ -0,0 +1,594 @@
+/*
+ *    DOM text node implementation
+ *
+ * Copyright 2006 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+typedef struct _domtext
+{
+    const struct IXMLDOMTextVtbl *lpVtbl;
+    LONG ref;
+    IUnknown *element_unk;
+    IXMLDOMElement *element;
+} domtext;
+
+static inline domtext *impl_from_IXMLDOMText( IXMLDOMText *iface )
+{
+    return (domtext *)((char*)iface - FIELD_OFFSET(domtext, lpVtbl));
+}
+
+static HRESULT WINAPI domtext_QueryInterface(
+    IXMLDOMText *iface,
+    REFIID riid,
+    void** ppvObject )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if ( IsEqualGUID( riid, &IID_IXMLDOMText ) ||
+         IsEqualGUID( riid, &IID_IUnknown ) )
+    {
+        *ppvObject = iface;
+    }
+    else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
+              IsEqualGUID( riid, &IID_IXMLDOMElement ) )
+    {
+        return IUnknown_QueryInterface(This->element_unk, riid, ppvObject);
+    }
+    else
+    {
+        FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDOMText_AddRef( iface );
+
+    return S_OK;
+}
+
+static ULONG WINAPI domtext_AddRef(
+    IXMLDOMText *iface )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return InterlockedIncrement( &This->ref );
+}
+
+static ULONG WINAPI domtext_Release(
+    IXMLDOMText *iface )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &This->ref );
+    if ( ref == 0 )
+    {
+        IUnknown_Release( This->element_unk );
+        HeapFree( GetProcessHeap(), 0, This );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI domtext_GetTypeInfoCount(
+    IXMLDOMText *iface,
+    UINT* pctinfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_GetTypeInfo(
+    IXMLDOMText *iface,
+    UINT iTInfo, LCID lcid,
+    ITypeInfo** ppTInfo )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_GetIDsOfNames(
+    IXMLDOMText *iface,
+    REFIID riid, LPOLESTR* rgszNames,
+    UINT cNames, LCID lcid, DISPID* rgDispId )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_Invoke(
+    IXMLDOMText *iface,
+    DISPID dispIdMember, REFIID riid, LCID lcid,
+    WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
+    EXCEPINFO* pExcepInfo, UINT* puArgErr )
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_get_nodeName(
+    IXMLDOMText *iface,
+    BSTR* p )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nodeName( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_nodeValue(
+    IXMLDOMText *iface,
+    VARIANT* var1 )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nodeValue( This->element, var1 );
+}
+
+static HRESULT WINAPI domtext_put_nodeValue(
+    IXMLDOMText *iface,
+    VARIANT var1 )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_put_nodeValue( This->element, var1 );
+}
+
+static HRESULT WINAPI domtext_get_nodeType(
+    IXMLDOMText *iface,
+    DOMNodeType* domNodeType )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nodeType( This->element, domNodeType );
+}
+
+static HRESULT WINAPI domtext_get_parentNode(
+    IXMLDOMText *iface,
+    IXMLDOMNode** parent )
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_parentNode( This->element, parent );
+}
+
+static HRESULT WINAPI domtext_get_childNodes(
+    IXMLDOMText *iface,
+    IXMLDOMNodeList** outList)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_childNodes( This->element, outList );
+}
+
+static HRESULT WINAPI domtext_get_firstChild(
+    IXMLDOMText *iface,
+    IXMLDOMNode** domNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_firstChild( This->element, domNode );
+}
+
+static HRESULT WINAPI domtext_get_lastChild(
+    IXMLDOMText *iface,
+    IXMLDOMNode** domNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_lastChild( This->element, domNode );
+}
+
+static HRESULT WINAPI domtext_get_previousSibling(
+    IXMLDOMText *iface,
+    IXMLDOMNode** domNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_previousSibling( This->element, domNode );
+}
+
+static HRESULT WINAPI domtext_get_nextSibling(
+    IXMLDOMText *iface,
+    IXMLDOMNode** domNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nextSibling( This->element, domNode );
+}
+
+static HRESULT WINAPI domtext_get_attributes(
+    IXMLDOMText *iface,
+    IXMLDOMNamedNodeMap** attributeMap)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_attributes( This->element, attributeMap );
+}
+
+static HRESULT WINAPI domtext_insertBefore(
+    IXMLDOMText *iface,
+    IXMLDOMNode* newNode, VARIANT var1,
+    IXMLDOMNode** outOldNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_insertBefore( This->element, newNode, var1, outOldNode );
+}
+
+static HRESULT WINAPI domtext_replaceChild(
+    IXMLDOMText *iface,
+    IXMLDOMNode* newNode,
+    IXMLDOMNode* oldNode,
+    IXMLDOMNode** outOldNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_replaceChild( This->element, newNode, oldNode, outOldNode );
+}
+
+static HRESULT WINAPI domtext_removeChild(
+    IXMLDOMText *iface,
+    IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_removeChild( This->element, domNode, oldNode );
+}
+
+static HRESULT WINAPI domtext_appendChild(
+    IXMLDOMText *iface,
+    IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_appendChild( This->element, newNode, outNewNode );
+}
+
+static HRESULT WINAPI domtext_hasChildNodes(
+    IXMLDOMText *iface,
+    VARIANT_BOOL* pbool)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_hasChildNodes( This->element, pbool );
+}
+
+static HRESULT WINAPI domtext_get_ownerDocument(
+    IXMLDOMText *iface,
+    IXMLDOMDocument** domDocument)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_ownerDocument( This->element, domDocument );
+}
+
+static HRESULT WINAPI domtext_cloneNode(
+    IXMLDOMText *iface,
+    VARIANT_BOOL pbool, IXMLDOMNode** outNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_cloneNode( This->element, pbool, outNode );
+}
+
+static HRESULT WINAPI domtext_get_nodeTypeString(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nodeTypeString( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_text(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_text( This->element, p );
+}
+
+static HRESULT WINAPI domtext_put_text(
+    IXMLDOMText *iface,
+    BSTR p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_put_text( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_specified(
+    IXMLDOMText *iface,
+    VARIANT_BOOL* pbool)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_specified( This->element, pbool );
+}
+
+static HRESULT WINAPI domtext_get_definition(
+    IXMLDOMText *iface,
+    IXMLDOMNode** domNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_definition( This->element, domNode );
+}
+
+static HRESULT WINAPI domtext_get_nodeTypedValue(
+    IXMLDOMText *iface,
+    VARIANT* var1)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_nodeTypedValue( This->element, var1 );
+}
+
+static HRESULT WINAPI domtext_put_nodeTypedValue(
+    IXMLDOMText *iface,
+    VARIANT var1)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_put_nodeTypedValue( This->element, var1 );
+}
+
+static HRESULT WINAPI domtext_get_dataType(
+    IXMLDOMText *iface,
+    VARIANT* var1)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_dataType( This->element, var1 );
+}
+
+static HRESULT WINAPI domtext_put_dataType(
+    IXMLDOMText *iface,
+    BSTR p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_put_dataType( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_xml(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_xml( This->element, p );
+}
+
+static HRESULT WINAPI domtext_transformNode(
+    IXMLDOMText *iface,
+    IXMLDOMNode* domNode, BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_transformNode( This->element, domNode, p );
+}
+
+static HRESULT WINAPI domtext_selectNodes(
+    IXMLDOMText *iface,
+    BSTR p, IXMLDOMNodeList** outList)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_selectNodes( This->element, p, outList );
+}
+
+static HRESULT WINAPI domtext_selectSingleNode(
+    IXMLDOMText *iface,
+    BSTR p, IXMLDOMNode** outNode)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_selectSingleNode( This->element, p, outNode );
+}
+
+static HRESULT WINAPI domtext_get_parsed(
+    IXMLDOMText *iface,
+    VARIANT_BOOL* pbool)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_parsed( This->element, pbool );
+}
+
+static HRESULT WINAPI domtext_get_namespaceURI(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_namespaceURI( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_prefix(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_prefix( This->element, p );
+}
+
+static HRESULT WINAPI domtext_get_baseName(
+    IXMLDOMText *iface,
+    BSTR* p)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_get_baseName( This->element, p );
+}
+
+static HRESULT WINAPI domtext_transformNodeToObject(
+    IXMLDOMText *iface,
+    IXMLDOMNode* domNode, VARIANT var1)
+{
+    domtext *This = impl_from_IXMLDOMText( iface );
+    return IXMLDOMNode_transformNodeToObject( This->element, domNode, var1 );
+}
+
+static HRESULT WINAPI domtext_get_data(
+    IXMLDOMText *iface,
+    BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_put_data(
+    IXMLDOMText *iface,
+    BSTR data)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_get_length(
+    IXMLDOMText *iface,
+    long *len)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_substringData(
+    IXMLDOMText *iface,
+    long offset, long count, BSTR *p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_appendData(
+    IXMLDOMText *iface,
+    BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_insertData(
+    IXMLDOMText *iface,
+    long offset, BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_deleteData(
+    IXMLDOMText *iface,
+    long offset, long count)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_replaceData(
+    IXMLDOMText *iface,
+    long offset, long count, BSTR p)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI domtext_splitText(
+    IXMLDOMText *iface,
+    long offset, IXMLDOMText **txtNode)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+
+static const struct IXMLDOMTextVtbl domtext_vtbl =
+{
+    domtext_QueryInterface,
+    domtext_AddRef,
+    domtext_Release,
+    domtext_GetTypeInfoCount,
+    domtext_GetTypeInfo,
+    domtext_GetIDsOfNames,
+    domtext_Invoke,
+    domtext_get_nodeName,
+    domtext_get_nodeValue,
+    domtext_put_nodeValue,
+    domtext_get_nodeType,
+    domtext_get_parentNode,
+    domtext_get_childNodes,
+    domtext_get_firstChild,
+    domtext_get_lastChild,
+    domtext_get_previousSibling,
+    domtext_get_nextSibling,
+    domtext_get_attributes,
+    domtext_insertBefore,
+    domtext_replaceChild,
+    domtext_removeChild,
+    domtext_appendChild,
+    domtext_hasChildNodes,
+    domtext_get_ownerDocument,
+    domtext_cloneNode,
+    domtext_get_nodeTypeString,
+    domtext_get_text,
+    domtext_put_text,
+    domtext_get_specified,
+    domtext_get_definition,
+    domtext_get_nodeTypedValue,
+    domtext_put_nodeTypedValue,
+    domtext_get_dataType,
+    domtext_put_dataType,
+    domtext_get_xml,
+    domtext_transformNode,
+    domtext_selectNodes,
+    domtext_selectSingleNode,
+    domtext_get_parsed,
+    domtext_get_namespaceURI,
+    domtext_get_prefix,
+    domtext_get_baseName,
+    domtext_transformNodeToObject,
+    domtext_get_data,
+    domtext_put_data,
+    domtext_get_length,
+    domtext_substringData,
+    domtext_appendData,
+    domtext_insertData,
+    domtext_deleteData,
+    domtext_replaceData,
+    domtext_splitText
+};
+
+IUnknown* create_text( xmlNodePtr text )
+{
+    domtext *This;
+    HRESULT hr;
+
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+    if ( !This )
+        return NULL;
+
+    This->lpVtbl = &domtext_vtbl;
+    This->ref = 1;
+
+    This->element_unk = create_element( text, (IUnknown*)&This->lpVtbl );
+    if(!This->element_unk)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return NULL;
+    }
+
+    hr = IUnknown_QueryInterface(This->element_unk, &IID_IXMLDOMNode, (LPVOID*)&This->element);
+    if(FAILED(hr))
+    {
+        IUnknown_Release(This->element_unk);
+        HeapFree( GetProcessHeap(), 0, This );
+        return NULL;
+    }
+    /* The ref on This->element is actually looped back into this object, so release it */
+    IXMLDOMNode_Release(This->element);
+
+    return (IUnknown*) &This->lpVtbl;
+}
+
+#endif

reactos/dll/win32/msxml3/uuid.c

@@ -0,0 +1,58 @@
+/*
+ * MSXML2 uuids
+ *
+ * Copyright 2006 Huw Davies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/*
+ * We can't use the autogenerated _i.c file from msxml2.idl as that
+ * will contain some of the (version 2) uuids defined in libuuid.
+ * Therefore we roll our own.
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+
+/*
+ * First include the version 2 headers so that we don't redefine their
+ * uuids - they're already in libuuid
+ */
+#include "xmldom.h"
+#include "xmldso.h"
+#include "msxml.h"
+
+/* Now we can initialize the rest of the uuids */
+#include "initguid.h"
+#include "msxml2.h"
+
+/*
+ * Note that because of a #define in msxml2.h, we end up initializing
+ * CLSID_DOMDocument2 to be the v.3 version independent DOMDocument
+ * class {f6d90f11-9c73-11d3-b32e-00c04f990bb4}.  The other version
+ * independent CLSIDs all have slightly different names:
+ *
+ * v.2.x                              v.3.0
+ *
+ * DOMFreeThreadedDocument            FreeThreadedDOMDocument
+ * XMLHTTPRequest                     XMLHTTP
+ * XMLDSOControl                      DSOControl
+ *
+ */

reactos/dll/win32/msxml3/version.rc

@@ -0,0 +1,25 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define WINE_OLESELFREGISTER
+#define WINE_FILEDESCRIPTION_STR "Wine MSXML 3.0"
+#define WINE_FILENAME_STR "msxml3.dll"
+#define WINE_FILEVERSION 8,30,9926,0
+#define WINE_FILEVERSION_STR "8.30.9926.0"
+#define WINE_PRODUCTVERSION 8,30,9926,0
+#define WINE_PRODUCTVERSION_STR "8.30.9926.0"
+
+#include "wine/wine_common_ver.rc"

reactos/dll/win32/msxml3/xmldoc.c

@@ -0,0 +1,655 @@
+/*
+ * XML Document implementation
+ *
+ * Copyright 2007 James Hawkins
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+#include "wininet.h"
+#include "winreg.h"
+#include "shlwapi.h"
+#include "ocidl.h"
+
+#include "wine/debug.h"
+
+#include "msxml_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+/* FIXME: IXMLDocument needs to implement
+ *   - IXMLError
+ *   - IPersistMoniker
+ */
+
+typedef struct _xmldoc
+{
+    const IXMLDocumentVtbl       *lpVtbl;
+    const IPersistStreamInitVtbl *lpvtblIPersistStreamInit;
+    LONG ref;
+    HRESULT error;
+
+    /* IXMLDocument */
+    IXMLElement *root;
+    xmlDocPtr xmldoc;
+
+    /* IPersistStream */
+    IStream *stream;
+} xmldoc;
+
+static inline xmldoc *impl_from_IXMLDocument(IXMLDocument *iface)
+{
+    return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpVtbl));
+}
+
+static inline xmldoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
+{
+    return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpvtblIPersistStreamInit));
+}
+
+static HRESULT WINAPI xmldoc_QueryInterface(IXMLDocument *iface, REFIID riid, void** ppvObject)
+{
+    xmldoc *This = impl_from_IXMLDocument(iface);
+
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IXMLDocument) ||
+        IsEqualGUID(riid, &IID_IXMLDOMDocument))
+    {
+        *ppvObject = iface;
+    }
+    else if (IsEqualGUID(&IID_IPersistStreamInit, riid) ||
+             IsEqualGUID(&IID_IPersistStream, riid))
+    {
+        *ppvObject = (IPersistStreamInit *)&(This->lpvtblIPersistStreamInit);
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLDocument_AddRef(iface);
+
+    return S_OK;
+}
+
+static ULONG WINAPI xmldoc_AddRef(IXMLDocument *iface)
+{
+    xmldoc *This = impl_from_IXMLDocument(iface);
+    TRACE("%p\n", This);
+    return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI xmldoc_Release(IXMLDocument *iface)
+{
+    xmldoc *This = impl_from_IXMLDocument(iface);
+    LONG ref;
+
+    TRACE("%p\n", This);
+
+    ref = InterlockedDecrement(&This->ref);
+    if (ref == 0)
+    {
+        xmlFreeDoc(This->xmldoc);
+        if (This->stream) IStream_Release(This->stream);
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI xmldoc_GetTypeInfoCount(IXMLDocument *iface, UINT* pctinfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_GetTypeInfo(IXMLDocument *iface, UINT iTInfo,
+                                         LCID lcid, ITypeInfo** ppTInfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_GetIDsOfNames(IXMLDocument *iface, REFIID riid,
+                                           LPOLESTR* rgszNames, UINT cNames,
+                                           LCID lcid, DISPID* rgDispId)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
+                                    REFIID riid, LCID lcid, WORD wFlags,
+                                    DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                                    EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
+{
+    xmldoc *This = impl_from_IXMLDocument(iface);
+
+    TRACE("(%p, %p)\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    *p = This->root;
+    if (!*p)
+        return E_FAIL;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmldoc_get_fileSize(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_put_fileModifiedDate(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_fileUpdatedDate(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_URL(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+typedef struct {
+    const struct IBindStatusCallbackVtbl *lpVtbl;
+} bsc;
+
+static HRESULT WINAPI bsc_QueryInterface(
+    IBindStatusCallback *iface,
+    REFIID riid,
+    LPVOID *ppobj )
+{
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IBindStatusCallback))
+    {
+        IBindStatusCallback_AddRef( iface );
+        *ppobj = iface;
+        return S_OK;
+    }
+
+    FIXME("interface %s not implemented\n", debugstr_guid(riid));
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI bsc_AddRef(
+    IBindStatusCallback *iface )
+{
+    return 2;
+}
+
+static ULONG WINAPI bsc_Release(
+    IBindStatusCallback *iface )
+{
+    return 1;
+}
+
+static HRESULT WINAPI bsc_OnStartBinding(
+        IBindStatusCallback* iface,
+        DWORD dwReserved,
+        IBinding* pib)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_GetPriority(
+        IBindStatusCallback* iface,
+        LONG* pnPriority)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_OnLowResource(
+        IBindStatusCallback* iface,
+        DWORD reserved)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_OnProgress(
+        IBindStatusCallback* iface,
+        ULONG ulProgress,
+        ULONG ulProgressMax,
+        ULONG ulStatusCode,
+        LPCWSTR szStatusText)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_OnStopBinding(
+        IBindStatusCallback* iface,
+        HRESULT hresult,
+        LPCWSTR szError)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_GetBindInfo(
+        IBindStatusCallback* iface,
+        DWORD* grfBINDF,
+        BINDINFO* pbindinfo)
+{
+    *grfBINDF = BINDF_RESYNCHRONIZE;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_OnDataAvailable(
+        IBindStatusCallback* iface,
+        DWORD grfBSCF,
+        DWORD dwSize,
+        FORMATETC* pformatetc,
+        STGMEDIUM* pstgmed)
+{
+    return S_OK;
+}
+
+static HRESULT WINAPI bsc_OnObjectAvailable(
+        IBindStatusCallback* iface,
+        REFIID riid,
+        IUnknown* punk)
+{
+    return S_OK;
+}
+
+static const struct IBindStatusCallbackVtbl bsc_vtbl =
+{
+    bsc_QueryInterface,
+    bsc_AddRef,
+    bsc_Release,
+    bsc_OnStartBinding,
+    bsc_GetPriority,
+    bsc_OnLowResource,
+    bsc_OnProgress,
+    bsc_OnStopBinding,
+    bsc_GetBindInfo,
+    bsc_OnDataAvailable,
+    bsc_OnObjectAvailable
+};
+
+static bsc xmldoc_bsc = { &bsc_vtbl };
+
+static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
+{
+    WCHAR url[INTERNET_MAX_URL_LENGTH];
+    IStream *stream;
+    IBindCtx *bctx;
+    IMoniker *moniker;
+    IPersistStreamInit *persist;
+    HRESULT hr;
+
+    TRACE("(%p, %s)\n", iface, debugstr_w(p));
+
+    if (!p)
+        return E_INVALIDARG;
+
+    if (!PathIsURLW(p))
+    {
+        WCHAR fullpath[MAX_PATH];
+        DWORD needed = sizeof(url) / sizeof(WCHAR);
+
+        if (!PathSearchAndQualifyW(p, fullpath, sizeof(fullpath) / sizeof(WCHAR)))
+        {
+            ERR("can't find path\n");
+            return E_FAIL;
+        }
+
+        if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
+        {
+            ERR("can't create url from path\n");
+            return E_FAIL;
+        }
+
+        p = url;
+    }
+
+    hr = CreateURLMoniker(NULL, p, &moniker);
+    if (FAILED(hr))
+        return hr;
+
+    CreateAsyncBindCtx(0, (IBindStatusCallback *)&xmldoc_bsc, 0, &bctx);
+
+    hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
+    IBindCtx_Release(bctx);
+    IMoniker_Release(moniker);
+    if (FAILED(hr))
+        return hr;
+
+    hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
+    if (FAILED(hr))
+    {
+        IStream_Release(stream);
+        return hr;
+    }
+
+    hr = IPersistStreamInit_Load(persist, stream);
+    IPersistStreamInit_Release(persist);
+    IStream_Release(stream);
+
+    return hr;
+}
+
+static HRESULT WINAPI xmldoc_get_mimeType(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_readyState(IXMLDocument *iface, long *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_charset(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_put_charset(IXMLDocument *iface, BSTR p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_version(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_get_dtdURl(IXMLDocument *iface, BSTR *p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+    return E_NOTIMPL;
+}
+
+static xmlElementType type_msxml_to_libxml(long type)
+{
+    switch (type)
+    {
+        case XMLELEMTYPE_ELEMENT:
+            return XML_ELEMENT_NODE;
+        case XMLELEMTYPE_TEXT:
+            return XML_TEXT_NODE;
+        case XMLELEMTYPE_COMMENT:
+            return XML_COMMENT_NODE;
+        case XMLELEMTYPE_DOCUMENT:
+            return XML_DOCUMENT_NODE;
+        case XMLELEMTYPE_DTD:
+            return XML_DTD_NODE;
+        case XMLELEMTYPE_PI:
+            return XML_PI_NODE;
+        default:
+            break;
+    }
+
+    return -1; /* FIXME: what is OTHER in msxml? */
+}
+
+static HRESULT WINAPI xmldoc_createElement(IXMLDocument *iface, VARIANT vType,
+                                           VARIANT var1, IXMLElement **ppElem)
+{
+    xmlNodePtr node;
+    static const xmlChar empty[] = "\0";
+
+    TRACE("(%p, %p)\n", iface, ppElem);
+
+    if (!ppElem)
+        return E_INVALIDARG;
+
+    *ppElem = NULL;
+
+    if (V_VT(&vType) != VT_I4)
+        return E_INVALIDARG;
+
+    node = xmlNewNode(NULL, empty);
+    node->type = type_msxml_to_libxml(V_I4(&vType));
+
+    /* FIXME: create xmlNodePtr based on vType and var1 */
+    return XMLElement_create((IUnknown *)iface, node, (LPVOID *)ppElem);
+}
+
+static const struct IXMLDocumentVtbl xmldoc_vtbl =
+{
+    xmldoc_QueryInterface,
+    xmldoc_AddRef,
+    xmldoc_Release,
+    xmldoc_GetTypeInfoCount,
+    xmldoc_GetTypeInfo,
+    xmldoc_GetIDsOfNames,
+    xmldoc_Invoke,
+    xmldoc_get_root,
+    xmldoc_get_fileSize,
+    xmldoc_put_fileModifiedDate,
+    xmldoc_get_fileUpdatedDate,
+    xmldoc_get_URL,
+    xmldoc_put_URL,
+    xmldoc_get_mimeType,
+    xmldoc_get_readyState,
+    xmldoc_get_charset,
+    xmldoc_put_charset,
+    xmldoc_get_version,
+    xmldoc_get_doctype,
+    xmldoc_get_dtdURl,
+    xmldoc_createElement
+};
+
+/************************************************************************
+ * xmldoc implementation of IPersistStreamInit.
+ */
+static HRESULT WINAPI xmldoc_IPersistStreamInit_QueryInterface(
+    IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj)
+{
+    xmldoc *this = impl_from_IPersistStreamInit(iface);
+    return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
+}
+
+static ULONG WINAPI xmldoc_IPersistStreamInit_AddRef(
+    IPersistStreamInit *iface)
+{
+    xmldoc *this = impl_from_IPersistStreamInit(iface);
+    return IXMLDocument_AddRef((IXMLDocument *)this);
+}
+
+static ULONG WINAPI xmldoc_IPersistStreamInit_Release(
+    IPersistStreamInit *iface)
+{
+    xmldoc *this = impl_from_IPersistStreamInit(iface);
+    return IXMLDocument_Release((IXMLDocument *)this);
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_GetClassID(
+    IPersistStreamInit *iface, CLSID *classid)
+{
+    FIXME("(%p,%p): stub!\n", iface, classid);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_IsDirty(
+    IPersistStreamInit *iface)
+{
+    FIXME("(%p): stub!\n", iface);
+    return E_NOTIMPL;
+}
+
+xmlDocPtr parse_xml(char *ptr, int len)
+{
+#ifdef HAVE_XMLREADMEMORY
+    return xmlReadMemory(ptr, len, NULL, NULL,
+                         XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS);
+#else
+    return xmlParseMemory(ptr, len);
+#endif
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_Load(
+    IPersistStreamInit *iface, LPSTREAM pStm)
+{
+    xmldoc *This = impl_from_IPersistStreamInit(iface);
+    xmlNodePtr xmlnode;
+    HRESULT hr;
+    HGLOBAL hglobal;
+    DWORD read, written, len;
+    BYTE buf[4096];
+    char *ptr;
+
+    TRACE("(%p, %p)\n", iface, pStm);
+
+    if (!pStm)
+        return E_INVALIDARG;
+
+    hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
+    if (FAILED(hr))
+        return hr;
+
+    do
+    {
+        IStream_Read(pStm, buf, sizeof(buf), &read);
+        hr = IStream_Write(This->stream, buf, read, &written);
+    } while(SUCCEEDED(hr) && written != 0 && read != 0);
+
+    if (FAILED(hr))
+    {
+        ERR("Failed to copy stream\n");
+        return hr;
+    }
+
+    hr = GetHGlobalFromStream(This->stream, &hglobal);
+    if (FAILED(hr))
+        return hr;
+
+    len = GlobalSize(hglobal);
+    ptr = GlobalLock(hglobal);
+    if (len != 0)
+        This->xmldoc = parse_xml(ptr, len);
+    GlobalUnlock(hglobal);
+
+    if (!This->xmldoc)
+    {
+        ERR("Failed to parse xml\n");
+        return E_FAIL;
+    }
+
+    xmlnode = xmlDocGetRootElement(This->xmldoc);
+    return XMLElement_create((IUnknown *)This, xmlnode, (LPVOID *)&This->root);
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_Save(
+    IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty)
+{
+    FIXME("(%p, %p, %d): stub!\n", iface, pStm, fClearDirty);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_GetSizeMax(
+    IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
+{
+    FIXME("(%p, %p): stub!\n", iface, pcbSize);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmldoc_IPersistStreamInit_InitNew(
+    IPersistStreamInit *iface)
+{
+    FIXME("(%p): stub!\n", iface);
+    return E_NOTIMPL;
+}
+
+static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
+{
+  xmldoc_IPersistStreamInit_QueryInterface,
+  xmldoc_IPersistStreamInit_AddRef,
+  xmldoc_IPersistStreamInit_Release,
+  xmldoc_IPersistStreamInit_GetClassID,
+  xmldoc_IPersistStreamInit_IsDirty,
+  xmldoc_IPersistStreamInit_Load,
+  xmldoc_IPersistStreamInit_Save,
+  xmldoc_IPersistStreamInit_GetSizeMax,
+  xmldoc_IPersistStreamInit_InitNew
+};
+
+HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+{
+    xmldoc *doc;
+
+    TRACE("(%p,%p)\n", pUnkOuter, ppObj);
+
+    doc = HeapAlloc(GetProcessHeap(), 0, sizeof (*doc));
+    if(!doc)
+        return E_OUTOFMEMORY;
+
+    doc->lpVtbl = &xmldoc_vtbl;
+    doc->lpvtblIPersistStreamInit = &xmldoc_IPersistStreamInit_VTable;
+    doc->ref = 1;
+    doc->error = S_OK;
+    doc->root = NULL;
+    doc->xmldoc = NULL;
+    doc->stream = NULL;
+
+    *ppObj = &doc->lpVtbl;
+
+    TRACE("returning iface %p\n", *ppObj);
+    return S_OK;
+}
+
+#else
+
+HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+{
+    MESSAGE("This program tried to use an XMLDocument object, but\n"
+            "libxml2 support was not present at compile time.\n");
+    return E_NOTIMPL;
+}
+
+#endif

reactos/dll/win32/msxml3/xmlelem.c

@@ -0,0 +1,730 @@
+/*
+ * XML Element implementation
+ *
+ * Copyright 2007 James Hawkins
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "msxml2.h"
+#include "ocidl.h"
+
+#include "wine/debug.h"
+
+#include "msxml_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+#ifdef HAVE_LIBXML2
+
+/**********************************************************************
+ * IXMLElement
+ */
+typedef struct _xmlelem
+{
+    const IXMLElementVtbl *lpVtbl;
+    LONG ref;
+    xmlNodePtr node;
+} xmlelem;
+
+static inline xmlelem *impl_from_IXMLElement(IXMLElement *iface)
+{
+    return (xmlelem *)((char*)iface - FIELD_OFFSET(xmlelem, lpVtbl));
+}
+
+static HRESULT WINAPI xmlelem_QueryInterface(IXMLElement *iface, REFIID riid, void** ppvObject)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IXMLElement))
+    {
+        *ppvObject = iface;
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLElement_AddRef(iface);
+
+    return S_OK;
+}
+
+static ULONG WINAPI xmlelem_AddRef(IXMLElement *iface)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    TRACE("%p\n", This);
+    return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI xmlelem_Release(IXMLElement *iface)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    LONG ref;
+
+    TRACE("%p\n", This);
+
+    ref = InterlockedDecrement(&This->ref);
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI xmlelem_GetTypeInfoCount(IXMLElement *iface, UINT* pctinfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_GetTypeInfo(IXMLElement *iface, UINT iTInfo,
+                                          LCID lcid, ITypeInfo** ppTInfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_GetIDsOfNames(IXMLElement *iface, REFIID riid,
+                                            LPOLESTR* rgszNames, UINT cNames,
+                                            LCID lcid, DISPID* rgDispId)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_Invoke(IXMLElement *iface, DISPID dispIdMember,
+                                     REFIID riid, LCID lcid, WORD wFlags,
+                                     DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                                     EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static inline BSTR str_dup_upper(BSTR str)
+{
+    INT len = (lstrlenW(str) + 1) * sizeof(WCHAR);
+    BSTR p = SysAllocStringLen(NULL, len);
+    if (p)
+    {
+        memcpy(p, str, len);
+        CharUpperW(p);
+    }
+    return p;
+}
+
+static HRESULT WINAPI xmlelem_get_tagName(IXMLElement *iface, BSTR *p)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    BSTR temp;
+
+    TRACE("(%p, %p)\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    temp = bstr_from_xmlChar(This->node->name);
+    *p = str_dup_upper(temp);
+    SysFreeString(temp);
+
+    TRACE("returning %s\n", debugstr_w(*p));
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_put_tagName(IXMLElement *iface, BSTR p)
+{
+    FIXME("(%p, %p): stub\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_get_parent(IXMLElement *iface, IXMLElement **parent)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+
+    TRACE("(%p, %p)\n", iface, parent);
+
+    if (!parent)
+        return E_INVALIDARG;
+
+    *parent = NULL;
+
+    if (!This->node->parent)
+        return S_FALSE;
+
+    return XMLElement_create((IUnknown *)iface, This->node->parent, (LPVOID *)parent);
+}
+
+static HRESULT WINAPI xmlelem_setAttribute(IXMLElement *iface, BSTR strPropertyName,
+                                            VARIANT PropertyValue)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlChar *name, *value;
+    xmlAttrPtr attr;
+
+    TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
+
+    if (!strPropertyName || V_VT(&PropertyValue) != VT_BSTR)
+        return E_INVALIDARG;
+
+    name = xmlChar_from_wchar(strPropertyName);
+    value = xmlChar_from_wchar(V_BSTR(&PropertyValue));
+    attr = xmlSetProp(This->node, name, value);
+
+    HeapFree(GetProcessHeap(), 0, name);
+    HeapFree(GetProcessHeap(), 0, value);
+    return (attr) ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI xmlelem_getAttribute(IXMLElement *iface, BSTR strPropertyName,
+                                           VARIANT *PropertyValue)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlChar *val = NULL, *name;
+    xmlAttrPtr ptr;
+
+    TRACE("(%p, %s, %p)\n", iface, debugstr_w(strPropertyName), PropertyValue);
+
+    if (!PropertyValue)
+        return E_INVALIDARG;
+
+    VariantInit(PropertyValue);
+    V_BSTR(PropertyValue) = NULL;
+
+    if (!strPropertyName)
+        return E_INVALIDARG;
+
+    name = xmlChar_from_wchar(strPropertyName);
+    ptr = This->node->properties;
+    while (ptr)
+    {
+        if (!lstrcmpiA((LPSTR)name, (LPCSTR)ptr->name))
+        {
+            val = xmlNodeListGetString(ptr->doc, ptr->children, 1);
+            break;
+        }
+
+        ptr = ptr->next;
+    }
+
+    if (val)
+    {
+        V_VT(PropertyValue) = VT_BSTR;
+        V_BSTR(PropertyValue) = bstr_from_xmlChar(val);
+    }
+
+    HeapFree(GetProcessHeap(), 0, name);
+    xmlFree(val);
+    TRACE("returning %s\n", debugstr_w(V_BSTR(PropertyValue)));
+    return (val) ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI xmlelem_removeAttribute(IXMLElement *iface, BSTR strPropertyName)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlChar *name;
+    xmlAttrPtr attr;
+    int res;
+    HRESULT hr = S_FALSE;
+
+    TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
+
+    if (!strPropertyName)
+        return E_INVALIDARG;
+
+    name = xmlChar_from_wchar(strPropertyName);
+    attr = xmlHasProp(This->node, name);
+    if (!attr)
+        goto done;
+
+    res = xmlRemoveProp(attr);
+
+    if (res == 0)
+        hr = S_OK;
+
+done:
+    HeapFree(GetProcessHeap(), 0, name);
+    return hr;
+}
+
+static HRESULT WINAPI xmlelem_get_children(IXMLElement *iface, IXMLElementCollection **p)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+
+    TRACE("(%p, %p)\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    return XMLElementCollection_create((IUnknown *)iface, This->node->children, (LPVOID *)p);
+}
+
+static long type_libxml_to_msxml(xmlElementType type)
+{
+    switch (type)
+    {
+        case XML_ELEMENT_NODE:
+            return XMLELEMTYPE_ELEMENT;
+        case XML_TEXT_NODE:
+            return XMLELEMTYPE_TEXT;
+        case XML_COMMENT_NODE:
+            return XMLELEMTYPE_COMMENT;
+        case XML_DOCUMENT_NODE:
+            return XMLELEMTYPE_DOCUMENT;
+        case XML_DTD_NODE:
+            return XMLELEMTYPE_DTD;
+        case XML_PI_NODE:
+            return XMLELEMTYPE_PI;
+        default:
+            break;
+    }
+
+    return XMLELEMTYPE_OTHER;
+}
+
+static HRESULT WINAPI xmlelem_get_type(IXMLElement *iface, long *p)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+
+    TRACE("(%p, %p)\n", This, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    *p = type_libxml_to_msxml(This->node->type);
+    TRACE("returning %ld\n", *p);
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_get_text(IXMLElement *iface, BSTR *p)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlChar *content;
+
+    TRACE("(%p, %p)\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    content = xmlNodeGetContent(This->node);
+    *p = bstr_from_xmlChar(content);
+    TRACE("returning %s\n", debugstr_w(*p));
+
+    xmlFree(content);
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_put_text(IXMLElement *iface, BSTR p)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlChar *content;
+
+    TRACE("(%p, %s)\n", iface, debugstr_w(p));
+
+    /* FIXME: test which types can be used */
+    if (This->node->type == XML_ELEMENT_NODE)
+        return E_NOTIMPL;
+
+    content = xmlChar_from_wchar(p);
+    xmlNodeSetContent(This->node, content);
+
+    HeapFree( GetProcessHeap(), 0, content);
+
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_addChild(IXMLElement *iface, IXMLElement *pChildElem,
+                                        long lIndex, long lreserved)
+{
+    xmlelem *This = impl_from_IXMLElement(iface);
+    xmlelem *childElem = impl_from_IXMLElement(pChildElem);
+    xmlNodePtr child;
+
+    TRACE("(%p, %p, %ld, %ld)\n", iface, pChildElem, lIndex, lreserved);
+
+    if (lIndex == 0)
+        child = xmlAddChild(This->node, childElem->node);
+    else
+        child = xmlAddNextSibling(This->node, childElem->node->last);
+
+    return (child) ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI xmlelem_removeChild(IXMLElement *iface, IXMLElement *pChildElem)
+{
+    FIXME("(%p, %p): stub\n", iface, pChildElem);
+    return E_NOTIMPL;
+}
+
+static const struct IXMLElementVtbl xmlelem_vtbl =
+{
+    xmlelem_QueryInterface,
+    xmlelem_AddRef,
+    xmlelem_Release,
+    xmlelem_GetTypeInfoCount,
+    xmlelem_GetTypeInfo,
+    xmlelem_GetIDsOfNames,
+    xmlelem_Invoke,
+    xmlelem_get_tagName,
+    xmlelem_put_tagName,
+    xmlelem_get_parent,
+    xmlelem_setAttribute,
+    xmlelem_getAttribute,
+    xmlelem_removeAttribute,
+    xmlelem_get_children,
+    xmlelem_get_type,
+    xmlelem_get_text,
+    xmlelem_put_text,
+    xmlelem_addChild,
+    xmlelem_removeChild
+};
+
+HRESULT XMLElement_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
+{
+    xmlelem *elem;
+
+    TRACE("(%p,%p)\n", pUnkOuter, ppObj);
+
+    if (!ppObj)
+        return E_INVALIDARG;
+
+    *ppObj = NULL;
+
+    elem = HeapAlloc(GetProcessHeap(), 0, sizeof (*elem));
+    if(!elem)
+        return E_OUTOFMEMORY;
+
+    elem->lpVtbl = &xmlelem_vtbl;
+    elem->ref = 1;
+    elem->node = node;
+
+    *ppObj = &elem->lpVtbl;
+
+    TRACE("returning iface %p\n", *ppObj);
+    return S_OK;
+}
+
+/************************************************************************
+ * IXMLElementCollection
+ */
+typedef struct _xmlelem_collection
+{
+    const IXMLElementCollectionVtbl *lpVtbl;
+    const IEnumVARIANTVtbl          *lpvtblIEnumVARIANT;
+    LONG ref;
+    LONG length;
+    xmlNodePtr node;
+
+    /* IEnumVARIANT members */
+    xmlNodePtr current;
+} xmlelem_collection;
+
+static inline xmlelem_collection *impl_from_IXMLElementCollection(IXMLElementCollection *iface)
+{
+    return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpVtbl));
+}
+
+static inline xmlelem_collection *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
+{
+    return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpvtblIEnumVARIANT));
+}
+
+static HRESULT WINAPI xmlelem_collection_QueryInterface(IXMLElementCollection *iface, REFIID riid, void** ppvObject)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+
+    TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+        IsEqualGUID(riid, &IID_IXMLElementCollection))
+    {
+        *ppvObject = iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IEnumVARIANT))
+    {
+        *ppvObject = (IEnumVARIANT *)&(This->lpvtblIEnumVARIANT);
+    }
+    else
+    {
+        FIXME("interface %s not implemented\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IXMLElementCollection_AddRef(iface);
+
+    return S_OK;
+}
+
+static ULONG WINAPI xmlelem_collection_AddRef(IXMLElementCollection *iface)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+    TRACE("%p\n", This);
+    return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI xmlelem_collection_Release(IXMLElementCollection *iface)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+    LONG ref;
+
+    TRACE("%p\n", This);
+
+    ref = InterlockedDecrement(&This->ref);
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI xmlelem_collection_GetTypeInfoCount(IXMLElementCollection *iface, UINT* pctinfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_collection_GetTypeInfo(IXMLElementCollection *iface, UINT iTInfo,
+                                                     LCID lcid, ITypeInfo** ppTInfo)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_collection_GetIDsOfNames(IXMLElementCollection *iface, REFIID riid,
+                                                       LPOLESTR* rgszNames, UINT cNames,
+                                                       LCID lcid, DISPID* rgDispId)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_collection_Invoke(IXMLElementCollection *iface, DISPID dispIdMember,
+                                                REFIID riid, LCID lcid, WORD wFlags,
+                                                DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                                                EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+    FIXME("\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_collection_put_length(IXMLElementCollection *iface, long v)
+{
+    TRACE("(%p, %ld)\n", iface, v);
+    return E_FAIL;
+}
+
+static HRESULT WINAPI xmlelem_collection_get_length(IXMLElementCollection *iface, long *p)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+
+    TRACE("(%p, %p)\n", iface, p);
+
+    if (!p)
+        return E_INVALIDARG;
+
+    *p = This->length;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_collection_get__newEnum(IXMLElementCollection *iface, IUnknown **ppUnk)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+
+    TRACE("(%p, %p)\n", iface, ppUnk);
+
+    if (!ppUnk)
+        return E_INVALIDARG;
+
+    *ppUnk = (IUnknown *)This;
+    IUnknown_AddRef(*ppUnk);
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_collection_item(IXMLElementCollection *iface, VARIANT var1,
+                                              VARIANT var2, IDispatch **ppDisp)
+{
+    xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
+    xmlNodePtr ptr = This->node;
+    int index, i;
+
+    TRACE("(%p, %p)\n", iface, ppDisp);
+
+    if (!ppDisp)
+        return E_INVALIDARG;
+
+    *ppDisp = NULL;
+
+    index = V_I4(&var1);
+    if (index < 0)
+        return E_INVALIDARG;
+    if (index >= This->length)
+        return E_FAIL;
+
+    for (i = 0; i < index; i++)
+        ptr = ptr->next;
+
+    return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)ppDisp);
+}
+
+static const struct IXMLElementCollectionVtbl xmlelem_collection_vtbl =
+{
+    xmlelem_collection_QueryInterface,
+    xmlelem_collection_AddRef,
+    xmlelem_collection_Release,
+    xmlelem_collection_GetTypeInfoCount,
+    xmlelem_collection_GetTypeInfo,
+    xmlelem_collection_GetIDsOfNames,
+    xmlelem_collection_Invoke,
+    xmlelem_collection_put_length,
+    xmlelem_collection_get_length,
+    xmlelem_collection_get__newEnum,
+    xmlelem_collection_item
+};
+
+/************************************************************************
+ * xmlelem_collection implementation of IEnumVARIANT.
+ */
+static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_QueryInterface(
+    IEnumVARIANT *iface, REFIID riid, LPVOID *ppvObj)
+{
+    xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
+    return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
+}
+
+static ULONG WINAPI xmlelem_collection_IEnumVARIANT_AddRef(
+    IEnumVARIANT *iface)
+{
+    xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
+    return IXMLDocument_AddRef((IXMLDocument *)this);
+}
+
+static ULONG WINAPI xmlelem_collection_IEnumVARIANT_Release(
+    IEnumVARIANT *iface)
+{
+    xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
+    return IXMLDocument_Release((IXMLDocument *)this);
+}
+
+static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Next(
+    IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
+{
+    xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
+    xmlNodePtr ptr = This->current;
+
+    TRACE("(%p, %d, %p, %p)\n", iface, celt, rgVar, pCeltFetched);
+
+    if (!rgVar)
+        return E_INVALIDARG;
+
+    /* FIXME: handle celt */
+    if (pCeltFetched)
+        *pCeltFetched = 1;
+
+    This->current = This->current->next;
+
+    V_VT(rgVar) = VT_DISPATCH;
+    return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)&V_DISPATCH(rgVar));
+}
+
+static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Skip(
+    IEnumVARIANT *iface, ULONG celt)
+{
+    FIXME("(%p, %d): stub\n", iface, celt);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Reset(
+    IEnumVARIANT *iface)
+{
+    xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
+    This->current = This->node;
+    return S_OK;
+}
+
+static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Clone(
+    IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
+{
+    FIXME("(%p, %p): stub\n", iface, ppEnum);
+    return E_NOTIMPL;
+}
+
+static const struct IEnumVARIANTVtbl xmlelem_collection_IEnumVARIANTvtbl =
+{
+    xmlelem_collection_IEnumVARIANT_QueryInterface,
+    xmlelem_collection_IEnumVARIANT_AddRef,
+    xmlelem_collection_IEnumVARIANT_Release,
+    xmlelem_collection_IEnumVARIANT_Next,
+    xmlelem_collection_IEnumVARIANT_Skip,
+    xmlelem_collection_IEnumVARIANT_Reset,
+    xmlelem_collection_IEnumVARIANT_Clone
+};
+
+HRESULT XMLElementCollection_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
+{
+    xmlelem_collection *collection;
+    xmlNodePtr ptr;
+
+    TRACE("(%p,%p)\n", pUnkOuter, ppObj);
+
+    *ppObj = NULL;
+
+    if (!node)
+        return S_FALSE;
+
+    collection = HeapAlloc(GetProcessHeap(), 0, sizeof (*collection));
+    if(!collection)
+        return E_OUTOFMEMORY;
+
+    collection->lpVtbl = &xmlelem_collection_vtbl;
+    collection->lpvtblIEnumVARIANT = &xmlelem_collection_IEnumVARIANTvtbl;
+    collection->ref = 1;
+    collection->length = 0;
+    collection->node = node;
+    collection->current = node;
+
+    ptr = node;
+    while (ptr)
+    {
+        collection->length++;
+        ptr = ptr->next;
+    }
+
+    *ppObj = &collection->lpVtbl;
+
+    TRACE("returning iface %p\n", *ppObj);
+    return S_OK;
+}
+
+#endif

reactos/dll/win32/win32.rbuild

@@ -157,6 +157,9 @@
 <directory name="mswsock">
 	<xi:include href="mswsock/mswsock.rbuild" />
 </directory>
+<directory name="msxml3">
+	<xi:include href="msxml3/msxml3.rbuild" />
+</directory>
 <directory name="netapi32">
 	<xi:include href="netapi32/netapi32.rbuild" />
 </directory>
@@ -337,4 +340,4 @@
 <directory name="wtsapi32">
 	<xi:include href="wtsapi32/wtsapi32.rbuild" />
 </directory>
-</group>
+</group>

reactos/media/doc/README.WINE

@@ -57,6 +57,7 @@ reactos/dll/win32/msimg32         # Autosync
 reactos/dll/win32/msi             # Needs a widl update
 reactos/dll/win32/msvcrt20        # Out of sync
 reactos/dll/win32/msvfw32         # Autosync
+reactos/dll/win32/msxml3          # Synced to Wine-20071230
 reactos/dll/win32/netapi32        # Autosync
 reactos/dll/win32/objsel          # Autosync
 reactos/dll/win32/odbc32          # Out of sync. Depends on port of Linux ODBC.