domdoc.c File Reference

#include <stdarg.h>
#include <assert.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/xpathInternals.h>
#include <libxml/xmlsave.h>
#include <libxml/SAX2.h>
#include <libxml/parserInternals.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winnls.h"
#include "ole2.h"
#include "olectl.h"
#include "msxml6.h"
#include "wininet.h"
#include "winreg.h"
#include "shlwapi.h"
#include "ocidl.h"
#include "objsafe.h"
#include "wine/debug.h"
#include "msxml_private.h"

Include dependency graph for domdoc.c:

Go to the source code of this file.

Classes
struct	domdoc_properties
struct	ConnectionPoint< T >
struct	domdoc
struct	_xmldoc_priv
struct	_orphan_entry
struct	_select_ns_entry

Macros
#define	COBJMACROS
#define	SAFETY_SUPPORTED_OPTIONS   (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)

Typedefs
typedef struct ConnectionPoint	ConnectionPoint
typedef struct domdoc	domdoc
typedef struct _xmldoc_priv	xmldoc_priv
typedef struct _orphan_entry	orphan_entry
typedef struct _select_ns_entry	select_ns_entry

Enumerations
enum	eventid_t {   EVENTID_ABORT , EVENTID_BEFOREUNLOAD , EVENTID_BLUR , EVENTID_CHANGE ,   EVENTID_CLICK , EVENTID_CONTEXTMENU , EVENTID_DATAAVAILABLE , EVENTID_DBLCLICK ,   EVENTID_DRAG , EVENTID_DRAGSTART , EVENTID_ERROR , EVENTID_FOCUS ,   EVENTID_FOCUSIN , EVENTID_HELP , EVENTID_KEYDOWN , EVENTID_KEYPRESS ,   EVENTID_KEYUP , EVENTID_LOAD , EVENTID_MOUSEDOWN , EVENTID_MOUSEMOVE ,   EVENTID_MOUSEOUT , EVENTID_MOUSEOVER , EVENTID_MOUSEUP , EVENTID_MOUSEWHEEL ,   EVENTID_PASTE , EVENTID_READYSTATECHANGE , EVENTID_RESIZE , EVENTID_SCROLL ,   EVENTID_SELECTSTART , EVENTID_SUBMIT , EVENTID_LAST , EVENTID_READYSTATECHANGE = 0 ,   EVENTID_DATAAVAILABLE , EVENTID_TRANSFORMNODE , EVENTID_LAST }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msxml)
static HRESULT	set_doc_event (domdoc *doc, eventid_t eid, const VARIANT *v)
static ConnectionPoint *	impl_from_IConnectionPoint (IConnectionPoint *iface)
static xmldoc_priv *	priv_from_xmlDocPtr (const xmlDocPtr doc)
static domdoc_properties *	properties_from_xmlDocPtr (xmlDocPtr doc)
BOOL	is_xpathmode (const xmlDocPtr doc)
void	set_xpathmode (xmlDocPtr doc, BOOL xpath)
int	registerNamespaces (xmlXPathContextPtr ctxt)
static void	clear_selectNsList (struct list *pNsList)
static xmldoc_priv *	create_priv (void)
static domdoc_properties *	create_properties (MSXML_VERSION version)
static domdoc_properties *	copy_properties (domdoc_properties const *properties)
static domdoc_properties *	properties_add_ref (domdoc_properties *properties)
static void	properties_release (domdoc_properties *properties)
static void	release_namespaces (domdoc *This)
void	xmldoc_link_xmldecl (xmlDocPtr doc, xmlNodePtr node)
xmlNodePtr	xmldoc_unlink_xmldecl (xmlDocPtr doc)
MSXML_VERSION	xmldoc_version (xmlDocPtr doc)
BOOL	is_preserving_whitespace (xmlNodePtr node)
static BOOL	strn_isspace (xmlChar const *str, int len)
static void	sax_characters (void *ctx, const xmlChar *ch, int len)
static void LIBXML2_LOG_CALLBACK	sax_error (void *ctx, char const *msg,...)
static void LIBXML2_LOG_CALLBACK	sax_warning (void *ctx, char const *msg,...)
static void	sax_serror (void *ctx, const xmlError *err)
static xmlDocPtr	doparse (domdoc *This, char const *ptr, int len, xmlCharEncoding encoding)
void	xmldoc_init (xmlDocPtr doc, MSXML_VERSION version)
LONG	xmldoc_add_refs (xmlDocPtr doc, LONG refs)
LONG	xmldoc_add_ref (xmlDocPtr doc)
LONG	xmldoc_release_refs (xmlDocPtr doc, LONG refs)
LONG	xmldoc_release (xmlDocPtr doc)
HRESULT	xmldoc_add_orphan (xmlDocPtr doc, xmlNodePtr node)
HRESULT	xmldoc_remove_orphan (xmlDocPtr doc, xmlNodePtr node)
static xmlDocPtr	get_doc (domdoc *This)
static HRESULT	attach_xmldoc (domdoc *This, xmlDocPtr xml)
static domdoc *	impl_from_IXMLDOMDocument3 (IXMLDOMDocument3 *iface)
static domdoc *	impl_from_IPersistStreamInit (IPersistStreamInit *iface)
static domdoc *	impl_from_IObjectWithSite (IObjectWithSite *iface)
static domdoc *	impl_from_IObjectSafety (IObjectSafety *iface)
static domdoc *	impl_from_IConnectionPointContainer (IConnectionPointContainer *iface)
static HRESULT WINAPI	PersistStreamInit_QueryInterface (IPersistStreamInit *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	PersistStreamInit_AddRef (IPersistStreamInit *iface)
static ULONG WINAPI	PersistStreamInit_Release (IPersistStreamInit *iface)
static HRESULT WINAPI	PersistStreamInit_GetClassID (IPersistStreamInit *iface, CLSID *classid)
static HRESULT WINAPI	PersistStreamInit_IsDirty (IPersistStreamInit *iface)
static HRESULT	domdoc_load_from_stream (domdoc *doc, ISequentialStream *stream)
static HRESULT WINAPI	PersistStreamInit_Load (IPersistStreamInit *iface, IStream *stream)
static HRESULT WINAPI	PersistStreamInit_Save (IPersistStreamInit *iface, IStream *stream, BOOL clr_dirty)
static HRESULT WINAPI	PersistStreamInit_GetSizeMax (IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
static HRESULT WINAPI	PersistStreamInit_InitNew (IPersistStreamInit *iface)
static HRESULT WINAPI	domdoc_QueryInterface (IXMLDOMDocument3 *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	domdoc_AddRef (IXMLDOMDocument3 *iface)
static ULONG WINAPI	domdoc_Release (IXMLDOMDocument3 *iface)
static HRESULT WINAPI	domdoc_GetTypeInfoCount (IXMLDOMDocument3 *iface, UINT *pctinfo)
static HRESULT WINAPI	domdoc_GetTypeInfo (IXMLDOMDocument3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	domdoc_GetIDsOfNames (IXMLDOMDocument3 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	domdoc_Invoke (IXMLDOMDocument3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	domdoc_get_nodeName (IXMLDOMDocument3 *iface, BSTR *name)
static HRESULT WINAPI	domdoc_get_nodeValue (IXMLDOMDocument3 *iface, VARIANT *value)
static HRESULT WINAPI	domdoc_put_nodeValue (IXMLDOMDocument3 *iface, VARIANT value)
static HRESULT WINAPI	domdoc_get_nodeType (IXMLDOMDocument3 *iface, DOMNodeType *type)
static HRESULT WINAPI	domdoc_get_parentNode (IXMLDOMDocument3 *iface, IXMLDOMNode **parent)
static HRESULT WINAPI	domdoc_get_childNodes (IXMLDOMDocument3 *iface, IXMLDOMNodeList **childList)
static HRESULT WINAPI	domdoc_get_firstChild (IXMLDOMDocument3 *iface, IXMLDOMNode **firstChild)
static HRESULT WINAPI	domdoc_get_lastChild (IXMLDOMDocument3 *iface, IXMLDOMNode **lastChild)
static HRESULT WINAPI	domdoc_get_previousSibling (IXMLDOMDocument3 *iface, IXMLDOMNode **previousSibling)
static HRESULT WINAPI	domdoc_get_nextSibling (IXMLDOMDocument3 *iface, IXMLDOMNode **nextSibling)
static HRESULT WINAPI	domdoc_get_attributes (IXMLDOMDocument3 *iface, IXMLDOMNamedNodeMap **attributeMap)
static HRESULT WINAPI	domdoc_insertBefore (IXMLDOMDocument3 *iface, IXMLDOMNode *newChild, VARIANT refChild, IXMLDOMNode **outNewChild)
static HRESULT WINAPI	domdoc_replaceChild (IXMLDOMDocument3 *iface, IXMLDOMNode *newChild, IXMLDOMNode *oldChild, IXMLDOMNode **outOldChild)
static HRESULT WINAPI	domdoc_removeChild (IXMLDOMDocument3 *iface, IXMLDOMNode *child, IXMLDOMNode **oldChild)
static HRESULT WINAPI	domdoc_appendChild (IXMLDOMDocument3 *iface, IXMLDOMNode *child, IXMLDOMNode **outChild)
static HRESULT WINAPI	domdoc_hasChildNodes (IXMLDOMDocument3 *iface, VARIANT_BOOL *ret)
static HRESULT WINAPI	domdoc_get_ownerDocument (IXMLDOMDocument3 *iface, IXMLDOMDocument **doc)
static HRESULT WINAPI	domdoc_cloneNode (IXMLDOMDocument3 *iface, VARIANT_BOOL deep, IXMLDOMNode **outNode)
static HRESULT WINAPI	domdoc_get_nodeTypeString (IXMLDOMDocument3 *iface, BSTR *p)
static HRESULT WINAPI	domdoc_get_text (IXMLDOMDocument3 *iface, BSTR *p)
static HRESULT WINAPI	domdoc_put_text (IXMLDOMDocument3 *iface, BSTR text)
static HRESULT WINAPI	domdoc_get_specified (IXMLDOMDocument3 *iface, VARIANT_BOOL *isSpecified)
static HRESULT WINAPI	domdoc_get_definition (IXMLDOMDocument3 *iface, IXMLDOMNode **definitionNode)
static HRESULT WINAPI	domdoc_get_nodeTypedValue (IXMLDOMDocument3 *iface, VARIANT *v)
static HRESULT WINAPI	domdoc_put_nodeTypedValue (IXMLDOMDocument3 *iface, VARIANT typedValue)
static HRESULT WINAPI	domdoc_get_dataType (IXMLDOMDocument3 *iface, VARIANT *typename)
static HRESULT WINAPI	domdoc_put_dataType (IXMLDOMDocument3 *iface, BSTR dataTypeName)
static int XMLCALL	domdoc_get_xml_writecallback (void *ctx, const char *data, int len)
static HRESULT WINAPI	domdoc_get_xml (IXMLDOMDocument3 *iface, BSTR *p)
static HRESULT WINAPI	domdoc_transformNode (IXMLDOMDocument3 *iface, IXMLDOMNode *node, BSTR *p)
static HRESULT WINAPI	domdoc_selectNodes (IXMLDOMDocument3 *iface, BSTR p, IXMLDOMNodeList **outList)
static HRESULT WINAPI	domdoc_selectSingleNode (IXMLDOMDocument3 *iface, BSTR p, IXMLDOMNode **outNode)
static HRESULT WINAPI	domdoc_get_parsed (IXMLDOMDocument3 *iface, VARIANT_BOOL *isParsed)
static HRESULT WINAPI	domdoc_get_namespaceURI (IXMLDOMDocument3 *iface, BSTR *namespaceURI)
static HRESULT WINAPI	domdoc_get_prefix (IXMLDOMDocument3 *iface, BSTR *prefix)
static HRESULT WINAPI	domdoc_get_baseName (IXMLDOMDocument3 *iface, BSTR *name)
static HRESULT WINAPI	domdoc_transformNodeToObject (IXMLDOMDocument3 *iface, IXMLDOMNode *stylesheet, VARIANT output)
static HRESULT WINAPI	domdoc_get_doctype (IXMLDOMDocument3 *iface, IXMLDOMDocumentType **doctype)
static HRESULT WINAPI	domdoc_get_implementation (IXMLDOMDocument3 *iface, IXMLDOMImplementation **impl)
static HRESULT WINAPI	domdoc_get_documentElement (IXMLDOMDocument3 *iface, IXMLDOMElement **DOMElement)
static HRESULT WINAPI	domdoc_put_documentElement (IXMLDOMDocument3 *iface, IXMLDOMElement *DOMElement)
static HRESULT WINAPI	domdoc_createElement (IXMLDOMDocument3 *iface, BSTR tagname, IXMLDOMElement **element)
static HRESULT WINAPI	domdoc_createDocumentFragment (IXMLDOMDocument3 *iface, IXMLDOMDocumentFragment **frag)
static HRESULT WINAPI	domdoc_createTextNode (IXMLDOMDocument3 *iface, BSTR data, IXMLDOMText **text)
static HRESULT WINAPI	domdoc_createComment (IXMLDOMDocument3 *iface, BSTR data, IXMLDOMComment **comment)
static HRESULT WINAPI	domdoc_createCDATASection (IXMLDOMDocument3 *iface, BSTR data, IXMLDOMCDATASection **cdata)
static HRESULT WINAPI	domdoc_createProcessingInstruction (IXMLDOMDocument3 *iface, BSTR target, BSTR data, IXMLDOMProcessingInstruction **pi)
static HRESULT WINAPI	domdoc_createAttribute (IXMLDOMDocument3 *iface, BSTR name, IXMLDOMAttribute **attribute)
static HRESULT WINAPI	domdoc_createEntityReference (IXMLDOMDocument3 *iface, BSTR name, IXMLDOMEntityReference **entityref)
xmlChar *	tagName_to_XPath (const BSTR tagName)
static HRESULT WINAPI	domdoc_getElementsByTagName (IXMLDOMDocument3 *iface, BSTR tagName, IXMLDOMNodeList **resultList)
static HRESULT	get_node_type (VARIANT Type, DOMNodeType *type)
static HRESULT WINAPI	domdoc_createNode (IXMLDOMDocument3 *iface, VARIANT Type, BSTR name, BSTR namespaceURI, IXMLDOMNode **node)
static HRESULT WINAPI	domdoc_nodeFromID (IXMLDOMDocument3 *iface, BSTR idString, IXMLDOMNode **node)
static HRESULT	domdoc_onDataAvailable (void *obj, char *ptr, DWORD len)
static HRESULT	domdoc_load_moniker (domdoc *This, IMoniker *mon)
static HRESULT WINAPI	domdoc_load (IXMLDOMDocument3 *iface, VARIANT source, VARIANT_BOOL *isSuccessful)
static HRESULT WINAPI	domdoc_get_readyState (IXMLDOMDocument3 *iface, LONG *value)
static HRESULT WINAPI	domdoc_get_parseError (IXMLDOMDocument3 *iface, IXMLDOMParseError **errorObj)
static HRESULT WINAPI	domdoc_get_url (IXMLDOMDocument3 *iface, BSTR *url)
static HRESULT WINAPI	domdoc_get_async (IXMLDOMDocument3 *iface, VARIANT_BOOL *isAsync)
static HRESULT WINAPI	domdoc_put_async (IXMLDOMDocument3 *iface, VARIANT_BOOL isAsync)
static HRESULT WINAPI	domdoc_abort (IXMLDOMDocument3 *iface)
static HRESULT WINAPI	domdoc_loadXML (IXMLDOMDocument3 *iface, BSTR data, VARIANT_BOOL *isSuccessful)
static int XMLCALL	domdoc_save_writecallback (void *ctx, const char *buffer, int len)
static int XMLCALL	domdoc_save_closecallback (void *ctx)
static int XMLCALL	domdoc_stream_save_writecallback (void *ctx, const char *buffer, int len)
static int XMLCALL	domdoc_stream_save_closecallback (void *ctx)
static char *	xmldoc_encoding (IXMLDOMDocument3 *doc)
static HRESULT WINAPI	domdoc_save (IXMLDOMDocument3 *iface, VARIANT destination)
static HRESULT WINAPI	domdoc_get_validateOnParse (IXMLDOMDocument3 *iface, VARIANT_BOOL *isValidating)
static HRESULT WINAPI	domdoc_put_validateOnParse (IXMLDOMDocument3 *iface, VARIANT_BOOL isValidating)
static HRESULT WINAPI	domdoc_get_resolveExternals (IXMLDOMDocument3 *iface, VARIANT_BOOL *isResolving)
static HRESULT WINAPI	domdoc_put_resolveExternals (IXMLDOMDocument3 *iface, VARIANT_BOOL isResolving)
static HRESULT WINAPI	domdoc_get_preserveWhiteSpace (IXMLDOMDocument3 *iface, VARIANT_BOOL *isPreserving)
static HRESULT WINAPI	domdoc_put_preserveWhiteSpace (IXMLDOMDocument3 *iface, VARIANT_BOOL isPreserving)
static HRESULT WINAPI	domdoc_put_onreadystatechange (IXMLDOMDocument3 *iface, VARIANT event)
static HRESULT WINAPI	domdoc_put_onDataAvailable (IXMLDOMDocument3 *iface, VARIANT sink)
static HRESULT WINAPI	domdoc_put_onTransformNode (IXMLDOMDocument3 *iface, VARIANT sink)
static HRESULT WINAPI	domdoc_get_namespaces (IXMLDOMDocument3 *iface, IXMLDOMSchemaCollection **collection)
static HRESULT WINAPI	domdoc_get_schemas (IXMLDOMDocument3 *iface, VARIANT *schema)
static HRESULT WINAPI	domdoc_putref_schemas (IXMLDOMDocument3 *iface, VARIANT schema)
static BOOL	is_wellformed (xmlDocPtr doc)
static void LIBXML2_LOG_CALLBACK	validate_error (void *ctx, char const *msg,...)
static void LIBXML2_LOG_CALLBACK	validate_warning (void *ctx, char const *msg,...)
static HRESULT WINAPI	domdoc_validateNode (IXMLDOMDocument3 *iface, IXMLDOMNode *node, IXMLDOMParseError **err)
static HRESULT WINAPI	domdoc_validate (IXMLDOMDocument3 *iface, IXMLDOMParseError **err)
static HRESULT WINAPI	domdoc_setProperty (IXMLDOMDocument3 *iface, BSTR p, VARIANT value)
static HRESULT WINAPI	domdoc_getProperty (IXMLDOMDocument3 *iface, BSTR p, VARIANT *var)
static HRESULT WINAPI	domdoc_importNode (IXMLDOMDocument3 *iface, IXMLDOMNode *node, VARIANT_BOOL deep, IXMLDOMNode **clone)
static HRESULT WINAPI	ConnectionPointContainer_QueryInterface (IConnectionPointContainer *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ConnectionPointContainer_AddRef (IConnectionPointContainer *iface)
static ULONG WINAPI	ConnectionPointContainer_Release (IConnectionPointContainer *iface)
static HRESULT WINAPI	ConnectionPointContainer_EnumConnectionPoints (IConnectionPointContainer *iface, IEnumConnectionPoints **ppEnum)
static HRESULT WINAPI	ConnectionPointContainer_FindConnectionPoint (IConnectionPointContainer *iface, REFIID riid, IConnectionPoint **cp)
static HRESULT WINAPI	ConnectionPoint_QueryInterface (IConnectionPoint *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ConnectionPoint_AddRef (IConnectionPoint *iface)
static ULONG WINAPI	ConnectionPoint_Release (IConnectionPoint *iface)
static HRESULT WINAPI	ConnectionPoint_GetConnectionInterface (IConnectionPoint *iface, IID *iid)
static HRESULT WINAPI	ConnectionPoint_GetConnectionPointContainer (IConnectionPoint *iface, IConnectionPointContainer **container)
static HRESULT WINAPI	ConnectionPoint_Advise (IConnectionPoint *iface, IUnknown *unk_sink, DWORD *cookie)
static HRESULT WINAPI	ConnectionPoint_Unadvise (IConnectionPoint *iface, DWORD cookie)
static HRESULT WINAPI	ConnectionPoint_EnumConnections (IConnectionPoint *iface, IEnumConnections **ppEnum)
static void	ConnectionPoint_Init (ConnectionPoint *cp, struct domdoc *doc, REFIID riid)
static HRESULT WINAPI	domdoc_ObjectWithSite_QueryInterface (IObjectWithSite *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	domdoc_ObjectWithSite_AddRef (IObjectWithSite *iface)
static ULONG WINAPI	domdoc_ObjectWithSite_Release (IObjectWithSite *iface)
static HRESULT WINAPI	domdoc_ObjectWithSite_GetSite (IObjectWithSite *iface, REFIID iid, void **ppvSite)
static HRESULT WINAPI	domdoc_ObjectWithSite_SetSite (IObjectWithSite *iface, IUnknown *punk)
static HRESULT WINAPI	domdoc_Safety_QueryInterface (IObjectSafety *iface, REFIID riid, void **ppv)
static ULONG WINAPI	domdoc_Safety_AddRef (IObjectSafety *iface)
static ULONG WINAPI	domdoc_Safety_Release (IObjectSafety *iface)
static HRESULT WINAPI	domdoc_Safety_GetInterfaceSafetyOptions (IObjectSafety *iface, REFIID riid, DWORD *supported, DWORD *enabled)
static HRESULT WINAPI	domdoc_Safety_SetInterfaceSafetyOptions (IObjectSafety *iface, REFIID riid, DWORD mask, DWORD enabled)
HRESULT	get_domdoc_from_xmldoc (xmlDocPtr xmldoc, IXMLDOMDocument3 **document)
HRESULT	dom_document_create (MSXML_VERSION version, void **ppObj)
IUnknown *	create_domdoc (xmlNodePtr document)

Variables
static const WCHAR	PropertySelectionLanguageW [] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0}
static const WCHAR	PropertySelectionNamespacesW [] = {'S','e','l','e','c','t','i','o','n','N','a','m','e','s','p','a','c','e','s',0}
static const WCHAR	PropertyProhibitDTDW [] = {'P','r','o','h','i','b','i','t','D','T','D',0}
static const WCHAR	PropertyNewParserW [] = {'N','e','w','P','a','r','s','e','r',0}
static const WCHAR	PropValueXPathW [] = {'X','P','a','t','h',0}
static const WCHAR	PropValueXSLPatternW [] = {'X','S','L','P','a','t','t','e','r','n',0}
static const WCHAR	PropertyResolveExternalsW [] = {'R','e','s','o','l','v','e','E','x','t','e','r','n','a','l','s',0}
static const WCHAR	PropertyAllowXsltScriptW [] = {'A','l','l','o','w','X','s','l','t','S','c','r','i','p','t',0}
static const WCHAR	PropertyAllowDocumentFunctionW [] = {'A','l','l','o','w','D','o','c','u','m','e','n','t','F','u','n','c','t','i','o','n',0}
static const WCHAR	PropertyNormalizeAttributeValuesW [] = {'N','o','r','m','a','l','i','z','e','A','t','t','r','i','b','u','t','e','V','a','l','u','e','s',0}
static const WCHAR	PropertyValidateOnParse [] = L"ValidateOnParse"
static const WCHAR	PropertyMaxElementDepth [] = L"MaxElementDepth"
static const IPersistStreamInitVtbl	xmldoc_IPersistStreamInit_VTable
static const tid_t	domdoc_se_tids []
static const struct IXMLDOMDocument3Vtbl	XMLDOMDocument3Vtbl
static const struct IConnectionPointContainerVtbl	ConnectionPointContainerVtbl
static const IConnectionPointVtbl	ConnectionPointVtbl
static const IObjectWithSiteVtbl	domdocObjectSite
static const IObjectSafetyVtbl	domdocObjectSafetyVtbl
static const tid_t	domdoc_iface_tids []
static dispex_static_data_t	domdoc_dispex

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file domdoc.c.

SAFETY_SUPPORTED_OPTIONS

#define SAFETY_SUPPORTED_OPTIONS   (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)

Definition at line 3695 of file domdoc.c.

Typedef Documentation

ConnectionPoint

typedef struct ConnectionPoint ConnectionPoint

Definition at line 82 of file domdoc.c.

domdoc

typedef struct domdoc domdoc

Definition at line 83 of file domdoc.c.

orphan_entry

typedef struct _orphan_entry orphan_entry

select_ns_entry

typedef struct _select_ns_entry select_ns_entry

xmldoc_priv

typedef struct _xmldoc_priv xmldoc_priv

Enumeration Type Documentation

eventid_t

enum eventid_t

Enumerator
EVENTID_ABORT
EVENTID_BEFOREUNLOAD
EVENTID_BLUR
EVENTID_CHANGE
EVENTID_CLICK
EVENTID_CONTEXTMENU
EVENTID_DATAAVAILABLE
EVENTID_DBLCLICK
EVENTID_DRAG
EVENTID_DRAGSTART
EVENTID_ERROR
EVENTID_FOCUS
EVENTID_FOCUSIN
EVENTID_HELP
EVENTID_KEYDOWN
EVENTID_KEYPRESS
EVENTID_KEYUP
EVENTID_LOAD
EVENTID_MOUSEDOWN
EVENTID_MOUSEMOVE
EVENTID_MOUSEOUT
EVENTID_MOUSEOVER
EVENTID_MOUSEUP
EVENTID_MOUSEWHEEL
EVENTID_PASTE
EVENTID_READYSTATECHANGE
EVENTID_RESIZE
EVENTID_SCROLL
EVENTID_SELECTSTART
EVENTID_SUBMIT
EVENTID_LAST
EVENTID_READYSTATECHANGE
EVENTID_DATAAVAILABLE
EVENTID_TRANSFORMNODE
EVENTID_LAST

Definition at line 103 of file domdoc.c.

             {
    EVENTID_READYSTATECHANGE = 0,
    EVENTID_DATAAVAILABLE,
    EVENTID_TRANSFORMNODE,
    EVENTID_LAST
} eventid_t;

Function Documentation

attach_xmldoc()

static HRESULT attach_xmldoc ( domdoc *  This, xmlDocPtr  xml  )

static

Definition at line 695 of file domdoc.c.

{
    release_namespaces(This);
 
    if(This->node.node)
    {
        properties_release(properties_from_xmlDocPtr(get_doc(This)));
        priv_from_xmlDocPtr(get_doc(This))->properties = NULL;
        if (xmldoc_release(get_doc(This)) != 0)
        {
            /* The xmlDocPtr object can no longer use the properties of this
             * domdoc object. So give it its own copy.
             */
            priv_from_xmlDocPtr(get_doc(This))->properties =
                copy_properties(This->properties);
        }
    }
 
    This->node.node = (xmlNodePtr) xml;
 
    if(This->node.node)
    {
        xmldoc_add_ref(get_doc(This));
        /* Only attach new xmlDocPtr objects, i.e. ones for which properties
         * is still NULL.
         */
        priv_from_xmlDocPtr(get_doc(This))->properties = properties_add_ref(This->properties);
    }
 
    return S_OK;
}

Referenced by domdoc_load(), domdoc_load_from_stream(), domdoc_loadXML(), and domdoc_onDataAvailable().

clear_selectNsList()

static void clear_selectNsList ( struct list *  pNsList )

inlinestatic

Definition at line 252 of file domdoc.c.

{
    select_ns_entry *ns, *ns2;
    LIST_FOR_EACH_ENTRY_SAFE( ns, ns2, pNsList, select_ns_entry, entry )
    {
        free(ns);
    }
    list_init(pNsList);
}

Referenced by domdoc_setProperty(), and properties_release().

ConnectionPoint_AddRef()

static ULONG WINAPI ConnectionPoint_AddRef ( IConnectionPoint *  iface )

static

Definition at line 3476 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
    return IConnectionPointContainer_AddRef(This->container);
}

ConnectionPoint_Advise()

static HRESULT WINAPI ConnectionPoint_Advise ( IConnectionPoint *  iface, IUnknown *  unk_sink, DWORD *  cookie  )

static

Definition at line 3514 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
    IUnknown *sink;
    HRESULT hr;
    DWORD i;
 
    TRACE("(%p)->(%p %p)\n", This, unk_sink, cookie);
 
    hr = IUnknown_QueryInterface(unk_sink, This->iid, (void**)&sink);
    if(FAILED(hr) && !IsEqualGUID(&IID_IPropertyNotifySink, This->iid))
        hr = IUnknown_QueryInterface(unk_sink, &IID_IDispatch, (void**)&sink);
    if(FAILED(hr))
        return CONNECT_E_CANNOTCONNECT;
 
    if(This->sinks)
    {
        for (i = 0; i < This->sinks_size; i++)
            if (!This->sinks[i].unk)
                break;
 
        if (i == This->sinks_size)
            This->sinks = realloc(This->sinks, (++This->sinks_size) * sizeof(*This->sinks));
    }
    else
    {
        This->sinks = malloc(sizeof(*This->sinks));
        This->sinks_size = 1;
        i = 0;
    }
 
    This->sinks[i].unk = sink;
    if (cookie)
        *cookie = i+1;
 
    return S_OK;
}

ConnectionPoint_EnumConnections()

static HRESULT WINAPI ConnectionPoint_EnumConnections ( IConnectionPoint *  iface, IEnumConnections **  ppEnum  )

static

Definition at line 3568 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
    FIXME("(%p)->(%p): stub\n", This, ppEnum);
    return E_NOTIMPL;
}

ConnectionPoint_GetConnectionInterface()

static HRESULT WINAPI ConnectionPoint_GetConnectionInterface ( IConnectionPoint *  iface, IID *  iid  )

static

Definition at line 3488 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 
    TRACE("(%p)->(%p)\n", This, iid);
 
    if (!iid) return E_POINTER;
 
    *iid = *This->iid;
    return S_OK;
}

ConnectionPoint_GetConnectionPointContainer()

static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer ( IConnectionPoint *  iface, IConnectionPointContainer **  container  )

static

Definition at line 3500 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 
    TRACE("(%p)->(%p)\n", This, container);
 
    if (!container) return E_POINTER;
 
    *container = This->container;
    IConnectionPointContainer_AddRef(*container);
    return S_OK;
}

ConnectionPoint_Init()

static void ConnectionPoint_Init ( ConnectionPoint *  cp, struct domdoc *  doc, REFIID  riid  )

static

Definition at line 3588 of file domdoc.c.

{
    cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
    cp->doc = doc;
    cp->iid = riid;
    cp->sinks = NULL;
    cp->sinks_size = 0;
 
    cp->next = doc->cp_list;
    doc->cp_list = cp;
 
    cp->container = &doc->IConnectionPointContainer_iface;
}

Referenced by get_domdoc_from_xmldoc().

ConnectionPoint_QueryInterface()

static HRESULT WINAPI ConnectionPoint_QueryInterface ( IConnectionPoint *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3451 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv );
 
    *ppv = NULL;
 
    if (IsEqualGUID(&IID_IUnknown, riid) ||
        IsEqualGUID(&IID_IConnectionPoint, riid))
    {
        *ppv = iface;
    }
 
    if (*ppv)
    {
        IConnectionPoint_AddRef(iface);
        return S_OK;
    }
 
    WARN("Unsupported interface %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

ConnectionPoint_Release()

static ULONG WINAPI ConnectionPoint_Release ( IConnectionPoint *  iface )

static

Definition at line 3482 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
    return IConnectionPointContainer_Release(This->container);
}

ConnectionPoint_Unadvise()

static HRESULT WINAPI ConnectionPoint_Unadvise ( IConnectionPoint *  iface, DWORD  cookie  )

static

Definition at line 3553 of file domdoc.c.

{
    ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 
    TRACE("%p, %ld.\n", iface, cookie);
 
    if (cookie == 0 || cookie > This->sinks_size || !This->sinks[cookie-1].unk)
        return CONNECT_E_NOCONNECTION;
 
    IUnknown_Release(This->sinks[cookie-1].unk);
    This->sinks[cookie-1].unk = NULL;
 
    return S_OK;
}

ConnectionPointContainer_AddRef()

static ULONG WINAPI ConnectionPointContainer_AddRef ( IConnectionPointContainer *  iface )

static

Definition at line 3394 of file domdoc.c.

{
    domdoc *This = impl_from_IConnectionPointContainer(iface);
    return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
}

ConnectionPointContainer_EnumConnectionPoints()

static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints ( IConnectionPointContainer *  iface, IEnumConnectionPoints **  ppEnum  )

static

Definition at line 3406 of file domdoc.c.

{
    domdoc *This = impl_from_IConnectionPointContainer(iface);
    FIXME("(%p)->(%p): stub\n", This, ppEnum);
    return E_NOTIMPL;
}

ConnectionPointContainer_FindConnectionPoint()

static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint ( IConnectionPointContainer *  iface, REFIID  riid, IConnectionPoint **  cp  )

static

Definition at line 3414 of file domdoc.c.

{
    domdoc *This = impl_from_IConnectionPointContainer(iface);
    ConnectionPoint *iter;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), cp);
 
    *cp = NULL;
 
    for(iter = This->cp_list; iter; iter = iter->next)
    {
        if (IsEqualGUID(iter->iid, riid))
            *cp = &iter->IConnectionPoint_iface;
    }
 
    if (*cp)
    {
        IConnectionPoint_AddRef(*cp);
        return S_OK;
    }
 
    FIXME("unsupported riid %s\n", debugstr_guid(riid));
    return CONNECT_E_NOCONNECTION;
 
}

ConnectionPointContainer_QueryInterface()

static HRESULT WINAPI ConnectionPointContainer_QueryInterface ( IConnectionPointContainer *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3387 of file domdoc.c.

{
    domdoc *This = impl_from_IConnectionPointContainer(iface);
    return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
}

ConnectionPointContainer_Release()

static ULONG WINAPI ConnectionPointContainer_Release ( IConnectionPointContainer *  iface )

static

Definition at line 3400 of file domdoc.c.

{
    domdoc *This = impl_from_IConnectionPointContainer(iface);
    return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
}

copy_properties()

static domdoc_properties * copy_properties ( domdoc_properties const *  properties )

static

Definition at line 299 of file domdoc.c.

{
    domdoc_properties* pcopy = malloc(sizeof(domdoc_properties));
    select_ns_entry const* ns = NULL;
    select_ns_entry* new_ns = NULL;
    int len = (properties->selectNsStr_len+1)*sizeof(xmlChar);
    ptrdiff_t offset;
 
    if (pcopy)
    {
        pcopy->refs = 1;
        pcopy->version = properties->version;
        pcopy->preserving = properties->preserving;
        pcopy->validating = properties->validating;
        pcopy->schemaCache = properties->schemaCache;
        if (pcopy->schemaCache)
            IXMLDOMSchemaCollection2_AddRef(pcopy->schemaCache);
        pcopy->XPath = properties->XPath;
        pcopy->selectNsStr_len = properties->selectNsStr_len;
        list_init( &pcopy->selectNsList );
        pcopy->selectNsStr = malloc(len);
        memcpy((xmlChar*)pcopy->selectNsStr, properties->selectNsStr, len);
        offset = pcopy->selectNsStr - properties->selectNsStr;
 
        LIST_FOR_EACH_ENTRY( ns, (&properties->selectNsList), select_ns_entry, entry )
        {
            new_ns = malloc(sizeof(select_ns_entry));
            memcpy(new_ns, ns, sizeof(select_ns_entry));
            new_ns->href += offset;
            new_ns->prefix += offset;
            list_add_tail(&pcopy->selectNsList, &new_ns->entry);
        }
 
        pcopy->uri = properties->uri;
        if (pcopy->uri)
            IUri_AddRef(pcopy->uri);
    }
 
    return pcopy;
}

Referenced by attach_xmldoc(), and domdoc_cloneNode().

create_domdoc()

IUnknown * create_domdoc

(

xmlNodePtr

document

)

Definition at line 3813 of file domdoc.c.

{
    IUnknown *obj = NULL;
    HRESULT hr;
 
    TRACE("(%p)\n", document);
 
    hr = get_domdoc_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument3**)&obj);
    if (FAILED(hr))
        return NULL;
 
    return obj;
}

Referenced by create_node(), domdoc_cloneNode(), and element_get_dt().

create_priv()

static xmldoc_priv * create_priv ( void  )

static

Definition at line 262 of file domdoc.c.

{
    xmldoc_priv *priv;
    priv = malloc(sizeof(*priv));
 
    if (priv)
    {
        priv->refs = 0;
        list_init( &priv->orphans );
        priv->properties = NULL;
    }
 
    return priv;
}

Referenced by domdoc_cloneNode(), domdoc_load(), domdoc_load_from_stream(), domdoc_loadXML(), domdoc_onDataAvailable(), and xmldoc_init().

create_properties()

static domdoc_properties * create_properties ( MSXML_VERSION  version )

static

Definition at line 277 of file domdoc.c.

{
    domdoc_properties *properties = malloc(sizeof(domdoc_properties));
 
    properties->refs = 1;
    list_init(&properties->selectNsList);
    properties->preserving = VARIANT_FALSE;
    properties->validating = VARIANT_TRUE;
    properties->schemaCache = NULL;
    properties->selectNsStr = calloc(1, sizeof(xmlChar));
    properties->selectNsStr_len = 0;
 
    /* properties that are dependent on object versions */
    properties->version = version;
    properties->XPath = (version == MSXML4 || version == MSXML6);
 
    /* document uri */
    properties->uri = NULL;
 
    return properties;
}

Referenced by xmldoc_init().

dom_document_create()

HRESULT dom_document_create	(	MSXML_VERSION	version,
		void **	ppObj
	)

Definition at line 3788 of file domdoc.c.

{
    xmlDocPtr xmldoc;
    HRESULT hr;
 
    TRACE("(%d, %p)\n", version, ppObj);
 
    xmldoc = xmlNewDoc(NULL);
    if(!xmldoc)
        return E_OUTOFMEMORY;
 
    xmldoc_init(xmldoc, version);
 
    hr = get_domdoc_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj);
    if(FAILED(hr))
    {
        properties_release(properties_from_xmlDocPtr(xmldoc));
        free(xmldoc->_private);
        xmlFreeDoc(xmldoc);
        return hr;
    }
 
    return hr;
}

Referenced by cache_entry_from_url(), DllGetClassObject(), handle_xml_load(), httprequest_get_responseXML(), schema_cache_add(), and xslprocessor_put_input().

domdoc_abort()

static HRESULT WINAPI domdoc_abort ( IXMLDOMDocument3 *  iface )

static

Definition at line 2453 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
    FIXME("%p\n", This);
    return E_NOTIMPL;
}

domdoc_AddRef()

static ULONG WINAPI domdoc_AddRef ( IXMLDOMDocument3 *  iface )

static

Definition at line 978 of file domdoc.c.

{
    domdoc *doc = impl_from_IXMLDOMDocument3(iface);
    ULONG ref = InterlockedIncrement(&doc->ref);
    TRACE("%p, refcount %ld.\n", iface, ref);
    return ref;
}

domdoc_appendChild()

static HRESULT WINAPI domdoc_appendChild ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  child, IXMLDOMNode **  outChild  )

static

Definition at line 1250 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p %p)\n", This, child, outChild);
    return node_append_child(&This->node, child, outChild);
}

domdoc_cloneNode()

static HRESULT WINAPI domdoc_cloneNode ( IXMLDOMDocument3 *  iface, VARIANT_BOOL  deep, IXMLDOMNode **  outNode  )

static

Definition at line 1281 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    xmlNodePtr clone;
 
    TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 
    if (!outNode)
        return E_INVALIDARG;
 
    *outNode = NULL;
 
    clone = xmlCopyNode((xmlNodePtr)get_doc(This), deep ? 1 : 2);
    if (!clone)
        return E_FAIL;
 
    clone->doc->_private = create_priv();
    xmldoc_add_orphan(clone->doc, clone);
    xmldoc_add_ref(clone->doc);
 
    priv_from_xmlDocPtr(clone->doc)->properties = copy_properties(This->properties);
    if (!(*outNode = (IXMLDOMNode*)create_domdoc(clone)))
    {
        xmldoc_release(clone->doc);
        return E_FAIL;
    }
 
    return S_OK;
}

domdoc_createAttribute()

static HRESULT WINAPI domdoc_createAttribute ( IXMLDOMDocument3 *  iface, BSTR  name, IXMLDOMAttribute **  attribute  )

static

Definition at line 1898 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), attribute);
 
    if (!attribute || !name) return E_INVALIDARG;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_ATTRIBUTE;
 
    hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMAttribute, (void**)attribute);
        IXMLDOMNode_Release(node);
    }
 
    return hr;
}

domdoc_createCDATASection()

static HRESULT WINAPI domdoc_createCDATASection ( IXMLDOMDocument3 *  iface, BSTR  data, IXMLDOMCDATASection **  cdata  )

static

Definition at line 1833 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), cdata);
 
    if (!cdata) return E_INVALIDARG;
 
    *cdata = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_CDATA_SECTION;
 
    hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)cdata);
        IXMLDOMNode_Release(node);
        hr = IXMLDOMCDATASection_put_data(*cdata, data);
    }
 
    return hr;
}

domdoc_createComment()

static HRESULT WINAPI domdoc_createComment ( IXMLDOMDocument3 *  iface, BSTR  data, IXMLDOMComment **  comment  )

static

Definition at line 1802 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    VARIANT type;
    HRESULT hr;
    IXMLDOMNode *node;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), comment);
 
    if (!comment) return E_INVALIDARG;
 
    *comment = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_COMMENT;
 
    hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)comment);
        IXMLDOMNode_Release(node);
        hr = IXMLDOMComment_put_data(*comment, data);
    }
 
    return hr;
}

domdoc_createDocumentFragment()

static HRESULT WINAPI domdoc_createDocumentFragment ( IXMLDOMDocument3 *  iface, IXMLDOMDocumentFragment **  frag  )

static

Definition at line 1742 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, frag);
 
    if (!frag) return E_INVALIDARG;
 
    *frag = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
 
    hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentFragment, (void**)frag);
        IXMLDOMNode_Release(node);
    }
 
    return hr;
}

domdoc_createElement()

static HRESULT WINAPI domdoc_createElement ( IXMLDOMDocument3 *  iface, BSTR  tagname, IXMLDOMElement **  element  )

static

Definition at line 1714 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(tagname), element);
 
    if (!element || !tagname) return E_INVALIDARG;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_ELEMENT;
 
    hr = IXMLDOMDocument3_createNode(iface, type, tagname, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)element);
        IXMLDOMNode_Release(node);
    }
 
    return hr;
}

domdoc_createEntityReference()

static HRESULT WINAPI domdoc_createEntityReference ( IXMLDOMDocument3 *  iface, BSTR  name, IXMLDOMEntityReference **  entityref  )

static

Definition at line 1926 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), entityref);
 
    if (!entityref) return E_INVALIDARG;
 
    *entityref = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_ENTITY_REFERENCE;
 
    hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMEntityReference, (void**)entityref);
        IXMLDOMNode_Release(node);
    }
 
    return hr;
}

domdoc_createNode()

static HRESULT WINAPI domdoc_createNode ( IXMLDOMDocument3 *  iface, VARIANT  Type, BSTR  name, BSTR  namespaceURI, IXMLDOMNode **  node  )

static

Definition at line 2042 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    DOMNodeType node_type;
    xmlNodePtr xmlnode;
    xmlChar *xml_name, *href;
    HRESULT hr;
 
    TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_variant(&Type), debugstr_w(name), debugstr_w(namespaceURI), node);
 
    if(!node) return E_INVALIDARG;
 
    hr = get_node_type(Type, &node_type);
    if(FAILED(hr)) return hr;
 
    TRACE("node_type %d\n", node_type);
 
    /* exit earlier for types that need name */
    switch(node_type)
    {
    case NODE_ELEMENT:
    case NODE_ATTRIBUTE:
    case NODE_ENTITY_REFERENCE:
    case NODE_PROCESSING_INSTRUCTION:
        if (!name || *name == 0) return E_FAIL;
        break;
    default:
        break;
    }
 
    xml_name = xmlchar_from_wchar(name);
    /* prevent empty href from being allocated */
    href = namespaceURI ? xmlchar_from_wchar(namespaceURI) : NULL;
 
    switch(node_type)
    {
    case NODE_ELEMENT:
    {
        xmlChar *local, *prefix;
 
        local = xmlSplitQName2(xml_name, &prefix);
 
        xmlnode = xmlNewDocNode(get_doc(This), NULL, local ? local : xml_name, NULL);
 
        /* allow creating the default namespace xmlns= */
        if (local || (href && *href))
        {
            xmlNsPtr ns = xmlNewNs(xmlnode, href, prefix);
            xmlSetNs(xmlnode, ns);
        }
 
        xmlFree(local);
        xmlFree(prefix);
 
        break;
    }
    case NODE_ATTRIBUTE:
    {
        xmlChar *local, *prefix;
 
        local = xmlSplitQName2(xml_name, &prefix);
 
        xmlnode = (xmlNodePtr)xmlNewDocProp(get_doc(This), local ? local : xml_name, NULL);
 
        if (local || (href && *href))
        {
            /* we need a floating namespace here, it can't be created linked to attribute from
               a start */
            xmlNsPtr ns = xmlNewNs(NULL, href, prefix);
            xmlSetNs(xmlnode, ns);
        }
 
        xmlFree(local);
        xmlFree(prefix);
 
        break;
    }
    case NODE_TEXT:
        xmlnode = (xmlNodePtr)xmlNewDocText(get_doc(This), NULL);
        break;
    case NODE_CDATA_SECTION:
        xmlnode = xmlNewCDataBlock(get_doc(This), NULL, 0);
        break;
    case NODE_ENTITY_REFERENCE:
        xmlnode = xmlNewReference(get_doc(This), xml_name);
        break;
    case NODE_PROCESSING_INSTRUCTION:
        xmlnode = xmlNewDocPI(get_doc(This), xml_name, NULL);
        break;
    case NODE_COMMENT:
        xmlnode = xmlNewDocComment(get_doc(This), NULL);
        break;
    case NODE_DOCUMENT_FRAGMENT:
        xmlnode = xmlNewDocFragment(get_doc(This));
        break;
    /* unsupported types */
    case NODE_DOCUMENT:
    case NODE_DOCUMENT_TYPE:
    case NODE_ENTITY:
    case NODE_NOTATION:
        free(xml_name);
        return E_INVALIDARG;
    default:
        FIXME("unhandled node type %d\n", node_type);
        xmlnode = NULL;
        break;
    }
 
    *node = create_node(xmlnode);
    free(xml_name);
    free(href);
 
    if(*node)
    {
        TRACE("created node (%d, %p, %p)\n", node_type, *node, xmlnode);
        xmldoc_add_orphan(xmlnode->doc, xmlnode);
        return S_OK;
    }
 
    return E_FAIL;
}

domdoc_createProcessingInstruction()

static HRESULT WINAPI domdoc_createProcessingInstruction ( IXMLDOMDocument3 *  iface, BSTR  target, BSTR  data, IXMLDOMProcessingInstruction **  pi  )

static

Definition at line 1864 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), pi);
 
    if (!pi) return E_INVALIDARG;
 
    *pi = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_PROCESSING_INSTRUCTION;
 
    hr = IXMLDOMDocument3_createNode(iface, type, target, NULL, &node);
    if (hr == S_OK)
    {
        /* this is to bypass check in ::put_data() that blocks "<?xml" PIs */
        hr = dom_pi_put_xml_decl(node, data);
        if (SUCCEEDED(hr))
            hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)pi);
        IXMLDOMNode_Release(node);
    }
 
    return hr;
}

domdoc_createTextNode()

static HRESULT WINAPI domdoc_createTextNode ( IXMLDOMDocument3 *  iface, BSTR  data, IXMLDOMText **  text  )

static

Definition at line 1771 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *node;
    VARIANT type;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), text);
 
    if (!text) return E_INVALIDARG;
 
    *text = NULL;
 
    V_VT(&type) = VT_I1;
    V_I1(&type) = NODE_TEXT;
 
    hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
    if (hr == S_OK)
    {
        IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)text);
        IXMLDOMNode_Release(node);
        hr = IXMLDOMText_put_data(*text, data);
    }
 
    return hr;
}

domdoc_get_async()

static HRESULT WINAPI domdoc_get_async ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isAsync  )

static

Definition at line 2429 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p: %d)\n", This, isAsync, This->async);
    *isAsync = This->async;
    return S_OK;
}

domdoc_get_attributes()

static HRESULT WINAPI domdoc_get_attributes ( IXMLDOMDocument3 *  iface, IXMLDOMNamedNodeMap **  attributeMap  )

static

Definition at line 1183 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, attributeMap);
 
    return return_null_ptr((void**)attributeMap);
}

domdoc_get_baseName()

static HRESULT WINAPI domdoc_get_baseName ( IXMLDOMDocument3 *  iface, BSTR *  name  )

static

Definition at line 1534 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, name);
    return return_null_bstr( name );
}

domdoc_get_childNodes()

static HRESULT WINAPI domdoc_get_childNodes ( IXMLDOMDocument3 *  iface, IXMLDOMNodeList **  childList  )

static

Definition at line 1123 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, childList);
 
    return node_get_child_nodes(&This->node, childList);
}

domdoc_get_dataType()

static HRESULT WINAPI domdoc_get_dataType ( IXMLDOMDocument3 *  iface, VARIANT *  typename  )

static

Definition at line 1388 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, typename);
    return return_null_var( typename );
}

domdoc_get_definition()

static HRESULT WINAPI domdoc_get_definition ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  definitionNode  )

static

Definition at line 1359 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%p)\n", This, definitionNode);
    return E_NOTIMPL;
}

domdoc_get_doctype()

static HRESULT WINAPI domdoc_get_doctype ( IXMLDOMDocument3 *  iface, IXMLDOMDocumentType **  doctype  )

static

Definition at line 1600 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
    IXMLDOMNode *node;
    xmlDtdPtr dtd;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, doctype);
 
    if (!doctype) return E_INVALIDARG;
 
    *doctype = NULL;
 
    dtd = xmlGetIntSubset(get_doc(This));
    if (!dtd) return S_FALSE;
 
    node = create_node((xmlNodePtr)dtd);
    if (!node) return S_FALSE;
 
    hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentType, (void**)doctype);
    IXMLDOMNode_Release(node);
 
    return hr;
}

domdoc_get_documentElement()

static HRESULT WINAPI domdoc_get_documentElement ( IXMLDOMDocument3 *  iface, IXMLDOMElement **  DOMElement  )

static

Definition at line 1642 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *element_node;
    xmlNodePtr root;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, DOMElement);
 
    if(!DOMElement)
        return E_INVALIDARG;
 
    *DOMElement = NULL;
 
    root = xmlDocGetRootElement( get_doc(This) );
    if ( !root )
        return S_FALSE;
 
    element_node = create_node( root );
    if(!element_node) return S_FALSE;
 
    hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (void**)DOMElement);
    IXMLDOMNode_Release(element_node);
 
    return hr;
}

domdoc_get_firstChild()

static HRESULT WINAPI domdoc_get_firstChild ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  firstChild  )

static

Definition at line 1135 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, firstChild);
 
    return node_get_first_child(&This->node, firstChild);
}

domdoc_get_implementation()

static HRESULT WINAPI domdoc_get_implementation ( IXMLDOMDocument3 *  iface, IXMLDOMImplementation **  impl  )

static

Definition at line 1628 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
 
    TRACE("(%p)->(%p)\n", This, impl);
 
    if(!impl)
        return E_INVALIDARG;
 
    return create_dom_implementation(impl);
}

domdoc_get_lastChild()

static HRESULT WINAPI domdoc_get_lastChild ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  lastChild  )

static

Definition at line 1147 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, lastChild);
 
    return node_get_last_child(&This->node, lastChild);
}

domdoc_get_namespaces()

static HRESULT WINAPI domdoc_get_namespaces ( IXMLDOMDocument3 *  iface, IXMLDOMSchemaCollection **  collection  )

static

Definition at line 2797 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    HRESULT hr;
 
    FIXME("(%p)->(%p): semi-stub\n", This, collection);
 
    if (!collection) return E_POINTER;
 
    if (!This->namespaces)
    {
        hr = SchemaCache_create(This->properties->version, (void**)&This->namespaces);
        if (hr != S_OK) return hr;
 
        hr = cache_from_doc_ns(This->namespaces, &This->node);
        if (hr != S_OK)
            release_namespaces(This);
    }
 
    if (This->namespaces)
        return IXMLDOMSchemaCollection2_QueryInterface(This->namespaces,
                   &IID_IXMLDOMSchemaCollection, (void**)collection);
 
    return hr;
}

domdoc_get_namespaceURI()

static HRESULT WINAPI domdoc_get_namespaceURI ( IXMLDOMDocument3 *  iface, BSTR *  namespaceURI  )

static

Definition at line 1515 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, namespaceURI);
    return return_null_bstr( namespaceURI );
}

domdoc_get_nextSibling()

static HRESULT WINAPI domdoc_get_nextSibling ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  nextSibling  )

static

Definition at line 1171 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, nextSibling);
 
    return return_null_node(nextSibling);
}

domdoc_get_nodeName()

static HRESULT WINAPI domdoc_get_nodeName ( IXMLDOMDocument3 *  iface, BSTR *  name  )

static

Definition at line 1057 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    static const WCHAR documentW[] = {'#','d','o','c','u','m','e','n','t',0};
 
    TRACE("(%p)->(%p)\n", This, name);
 
    return return_bstr(documentW, name);
}

domdoc_get_nodeType()

static HRESULT WINAPI domdoc_get_nodeType ( IXMLDOMDocument3 *  iface, DOMNodeType *  type  )

static

Definition at line 1098 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, type);
 
    *type = NODE_DOCUMENT;
    return S_OK;
}

domdoc_get_nodeTypedValue()

static HRESULT WINAPI domdoc_get_nodeTypedValue ( IXMLDOMDocument3 *  iface, VARIANT *  v  )

static

Definition at line 1369 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, v);
    return return_null_var(v);
}

domdoc_get_nodeTypeString()

static HRESULT WINAPI domdoc_get_nodeTypeString ( IXMLDOMDocument3 *  iface, BSTR *  p  )

static

Definition at line 1315 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
 
    TRACE("(%p)->(%p)\n", This, p);
 
    return return_bstr(documentW, p);
}

domdoc_get_nodeValue()

static HRESULT WINAPI domdoc_get_nodeValue ( IXMLDOMDocument3 *  iface, VARIANT *  value  )

static

Definition at line 1071 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, value);
 
    if(!value)
        return E_INVALIDARG;
 
    V_VT(value) = VT_NULL;
    V_BSTR(value) = NULL; /* tests show that we should do this */
    return S_FALSE;
}

domdoc_get_ownerDocument()

static HRESULT WINAPI domdoc_get_ownerDocument ( IXMLDOMDocument3 *  iface, IXMLDOMDocument **  doc  )

static

Definition at line 1271 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, doc);
    return node_get_owner_doc(&This->node, doc);
}

domdoc_get_parentNode()

static HRESULT WINAPI domdoc_get_parentNode ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  parent  )

static

Definition at line 1111 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, parent);
 
    return node_get_parent(&This->node, parent);
}

domdoc_get_parsed()

static HRESULT WINAPI domdoc_get_parsed ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isParsed  )

static

Definition at line 1505 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%p) stub!\n", This, isParsed);
    *isParsed = VARIANT_TRUE;
    return S_OK;
}

domdoc_get_parseError()

static HRESULT WINAPI domdoc_get_parseError ( IXMLDOMDocument3 *  iface, IXMLDOMParseError **  errorObj  )

static

Definition at line 2392 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    static const WCHAR err[] = {'e','r','r','o','r',0};
    BSTR error_string = NULL;
 
    FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
 
    if(This->error)
        error_string = SysAllocString(err);
 
    *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
    if(!*errorObj) return E_OUTOFMEMORY;
    return S_OK;
}

domdoc_get_prefix()

static HRESULT WINAPI domdoc_get_prefix ( IXMLDOMDocument3 *  iface, BSTR *  prefix  )

static

Definition at line 1524 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, prefix);
    return return_null_bstr( prefix );
}

domdoc_get_preserveWhiteSpace()

static HRESULT WINAPI domdoc_get_preserveWhiteSpace ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isPreserving  )

static

Definition at line 2750 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p: %d)\n", This, isPreserving, This->properties->preserving);
    *isPreserving = This->properties->preserving;
    return S_OK;
}

domdoc_get_previousSibling()

static HRESULT WINAPI domdoc_get_previousSibling ( IXMLDOMDocument3 *  iface, IXMLDOMNode **  previousSibling  )

static

Definition at line 1159 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p)\n", This, previousSibling);
 
    return return_null_node(previousSibling);
}

domdoc_get_readyState()

static HRESULT WINAPI domdoc_get_readyState ( IXMLDOMDocument3 *  iface, LONG *  value  )

static

Definition at line 2377 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
    FIXME("stub! (%p)->(%p)\n", This, value);
 
    if (!value)
        return E_INVALIDARG;
 
    *value = READYSTATE_COMPLETE;
    return S_OK;
}

domdoc_get_resolveExternals()

static HRESULT WINAPI domdoc_get_resolveExternals ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isResolving  )

static

Definition at line 2728 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p: %d)\n", This, isResolving, This->resolving);
    *isResolving = This->resolving;
    return S_OK;
}

domdoc_get_schemas()

static HRESULT WINAPI domdoc_get_schemas ( IXMLDOMDocument3 *  iface, VARIANT *  schema  )

static

Definition at line 2825 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMSchemaCollection2* cur_schema = This->properties->schemaCache;
    HRESULT hr = S_FALSE;
 
    TRACE("(%p)->(%p)\n", This, schema);
 
    V_VT(schema) = VT_NULL;
    /* just to reset pointer part, cause that's what application is expected to use */
    V_DISPATCH(schema) = NULL;
 
    if(cur_schema)
    {
        hr = IXMLDOMSchemaCollection2_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(schema));
        if(SUCCEEDED(hr))
            V_VT(schema) = VT_DISPATCH;
    }
    return hr;
}

domdoc_get_specified()

static HRESULT WINAPI domdoc_get_specified ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isSpecified  )

static

Definition at line 1348 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%p) stub!\n", This, isSpecified);
    *isSpecified = VARIANT_TRUE;
    return S_OK;
}

domdoc_get_text()

static HRESULT WINAPI domdoc_get_text ( IXMLDOMDocument3 *  iface, BSTR *  p  )

static

Definition at line 1328 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, p);
    return node_get_text(&This->node, p);
}

domdoc_get_url()

static HRESULT WINAPI domdoc_get_url ( IXMLDOMDocument3 *  iface, BSTR *  url  )

static

Definition at line 2411 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
 
    TRACE("(%p)->(%p)\n", This, url);
 
    if (!url)
        return E_INVALIDARG;
 
    if (!This->properties->uri)
        return return_null_bstr(url);
 
    return IUri_GetPropertyBSTR(This->properties->uri, Uri_PROPERTY_DISPLAY_URI, url, 0);
}

domdoc_get_validateOnParse()

static HRESULT WINAPI domdoc_get_validateOnParse ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  isValidating  )

static

Definition at line 2706 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p: %d)\n", This, isValidating, This->properties->validating);
    *isValidating = This->properties->validating;
    return S_OK;
}

domdoc_get_xml()

static HRESULT WINAPI domdoc_get_xml ( IXMLDOMDocument3 *  iface, BSTR *  p  )

static

Definition at line 1417 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    xmlSaveCtxtPtr ctxt;
    xmlBufferPtr buf;
    int options;
    long ret;
 
    TRACE("(%p)->(%p)\n", This, p);
 
    if(!p)
        return E_INVALIDARG;
 
    *p = NULL;
 
    buf = xmlBufferCreate();
    if(!buf)
        return E_OUTOFMEMORY;
 
    options = XML_SAVE_FORMAT | XML_SAVE_NO_DECL;
    ctxt = xmlSaveToIO(domdoc_get_xml_writecallback, NULL, buf, "UTF-8", options);
 
    if(!ctxt)
    {
        xmlBufferFree(buf);
        return E_OUTOFMEMORY;
    }
 
    ret = xmlSaveDoc(ctxt, get_doc(This));
    /* flushes on close */
    xmlSaveClose(ctxt);
 
    TRACE("%ld, len=%d\n", ret, xmlBufferLength(buf));
    if(ret != -1 && xmlBufferLength(buf) > 0)
    {
        BSTR content;
 
        content = bstr_from_xmlChar(xmlBufferContent(buf));
        content = EnsureCorrectEOL(content);
 
        *p = content;
    }
    else
    {
        *p = SysAllocStringLen(NULL, 0);
    }
 
    xmlBufferFree(buf);
 
    return *p ? S_OK : E_OUTOFMEMORY;
}

domdoc_get_xml_writecallback()

static int XMLCALL domdoc_get_xml_writecallback ( void *  ctx, const char *  data, int  len  )

static

Definition at line 1412 of file domdoc.c.

{
    return xmlBufferAdd((xmlBufferPtr)ctx, (xmlChar*)data, len) == 0 ? len : 0;
}

Referenced by domdoc_get_xml().

domdoc_getElementsByTagName()

static HRESULT WINAPI domdoc_getElementsByTagName ( IXMLDOMDocument3 *  iface, BSTR  tagName, IXMLDOMNodeList **  resultList  )

static

Definition at line 2003 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    xmlChar *query;
    HRESULT hr;
    BOOL XPath;
 
    TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
 
    if (!tagName || !resultList) return E_INVALIDARG;
 
    XPath = This->properties->XPath;
    This->properties->XPath = TRUE;
    query = tagName_to_XPath(tagName);
    hr = create_selection((xmlNodePtr)get_doc(This), query, resultList);
    xmlFree(query);
    This->properties->XPath = XPath;
 
    return hr;
}

domdoc_GetIDsOfNames()

static HRESULT WINAPI domdoc_GetIDsOfNames ( IXMLDOMDocument3 *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 1028 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
        riid, rgszNames, cNames, lcid, rgDispId);
}

domdoc_getProperty()

static HRESULT WINAPI domdoc_getProperty ( IXMLDOMDocument3 *  iface, BSTR  p, VARIANT *  var  )

static

Definition at line 3216 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 
    if (!var)
        return E_INVALIDARG;
 
    if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
    {
        V_VT(var) = VT_BSTR;
        V_BSTR(var) = This->properties->XPath ?
                      SysAllocString(PropValueXPathW) :
                      SysAllocString(PropValueXSLPatternW);
        return V_BSTR(var) ? S_OK : E_OUTOFMEMORY;
    }
    else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
    {
        int lenA, lenW;
        BSTR rebuiltStr, cur;
        const xmlChar *nsStr;
        struct list *pNsList;
        select_ns_entry* pNsEntry;
 
        V_VT(var) = VT_BSTR;
        nsStr = This->properties->selectNsStr;
        pNsList = &This->properties->selectNsList;
        lenA = This->properties->selectNsStr_len;
        lenW = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, NULL, 0);
        rebuiltStr = malloc(lenW * sizeof(WCHAR));
        MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, rebuiltStr, lenW);
        cur = rebuiltStr;
        /* this is fine because all of the chars that end tokens are ASCII*/
        LIST_FOR_EACH_ENTRY(pNsEntry, pNsList, select_ns_entry, entry)
        {
            while (*cur != 0) ++cur;
            if (pNsEntry->prefix_end)
            {
                *cur = pNsEntry->prefix_end;
                while (*cur != 0) ++cur;
            }
 
            if (pNsEntry->href_end)
            {
                *cur = pNsEntry->href_end;
            }
        }
        V_BSTR(var) = SysAllocString(rebuiltStr);
        free(rebuiltStr);
        return S_OK;
    }
    else if (lstrcmpiW(p, PropertyValidateOnParse) == 0)
    {
        if (This->properties->version < MSXML4)
            return E_FAIL;
        else
        {
            V_VT(var) = VT_BOOL;
            V_BOOL(var) = This->properties->validating;
            return S_OK;
        }
    }
 
    FIXME("Unknown property %s\n", debugstr_w(p));
    return E_FAIL;
}

domdoc_GetTypeInfo()

static HRESULT WINAPI domdoc_GetTypeInfo ( IXMLDOMDocument3 *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1020 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}

domdoc_GetTypeInfoCount()

static HRESULT WINAPI domdoc_GetTypeInfoCount ( IXMLDOMDocument3 *  iface, UINT *  pctinfo  )

static

Definition at line 1014 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
}

domdoc_hasChildNodes()

static HRESULT WINAPI domdoc_hasChildNodes ( IXMLDOMDocument3 *  iface, VARIANT_BOOL *  ret  )

static

Definition at line 1261 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, ret);
    return node_has_childnodes(&This->node, ret);
}

domdoc_importNode()

static HRESULT WINAPI domdoc_importNode ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  node, VARIANT_BOOL  deep, IXMLDOMNode **  clone  )

static

Definition at line 3287 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%p %d %p): stub\n", This, node, deep, clone);
    return E_NOTIMPL;
}

domdoc_insertBefore()

static HRESULT WINAPI domdoc_insertBefore ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  newChild, VARIANT  refChild, IXMLDOMNode **  outNewChild  )

static

Definition at line 1195 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    DOMNodeType type;
    HRESULT hr;
 
    TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), outNewChild);
 
    if (!newChild) return E_INVALIDARG;
 
    hr = IXMLDOMNode_get_nodeType(newChild, &type);
    if (hr != S_OK) return hr;
 
    TRACE("new node type %d\n", type);
    switch (type)
    {
        case NODE_ATTRIBUTE:
        case NODE_DOCUMENT:
        case NODE_CDATA_SECTION:
            if (outNewChild) *outNewChild = NULL;
            return E_FAIL;
        default:
            return node_insert_before(&This->node, newChild, &refChild, outNewChild);
    }
}

domdoc_Invoke()

static HRESULT WINAPI domdoc_Invoke ( IXMLDOMDocument3 *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 1041 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
        dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}

domdoc_load()

static HRESULT WINAPI domdoc_load ( IXMLDOMDocument3 *  iface, VARIANT  source, VARIANT_BOOL *  isSuccessful  )

static

Definition at line 2205 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    LPWSTR filename = NULL;
    HRESULT hr = S_FALSE;
    xmlDocPtr xmldoc;
 
    TRACE("(%p)->(%s)\n", This, debugstr_variant(&source));
 
    if (!isSuccessful)
        return E_POINTER;
    *isSuccessful = VARIANT_FALSE;
 
    assert( &This->node );
 
    switch( V_VT(&source) )
    {
    case VT_BSTR:
        filename = V_BSTR(&source);
        break;
    case VT_BSTR|VT_BYREF:
        if (!V_BSTRREF(&source)) return E_INVALIDARG;
        filename = *V_BSTRREF(&source);
        break;
    case VT_ARRAY|VT_UI1:
        {
            SAFEARRAY *psa = V_ARRAY(&source);
            char *str;
            LONG len;
            UINT dim = SafeArrayGetDim(psa);
 
            switch (dim)
            {
            case 0:
                ERR("SAFEARRAY == NULL\n");
                hr = This->error = E_INVALIDARG;
                break;
            case 1:
                /* Only takes UTF-8 strings.
                 * NOT NULL-terminated. */
                hr = SafeArrayAccessData(psa, (void**)&str);
                if (FAILED(hr))
                {
                    This->error = hr;
                    WARN("failed to access array data, hr %#lx.\n", hr);
                    break;
                }
                SafeArrayGetUBound(psa, 1, &len);
 
                if ((xmldoc = doparse(This, str, ++len, XML_CHAR_ENCODING_UTF8)))
                {
                    hr = This->error = S_OK;
                    *isSuccessful = VARIANT_TRUE;
                    TRACE("parsed document %p\n", xmldoc);
                }
                else
                {
                    This->error = E_FAIL;
                    TRACE("failed to parse document\n");
                }
 
                SafeArrayUnaccessData(psa);
 
                if(xmldoc)
                {
                    xmldoc->_private = create_priv();
                    return attach_xmldoc(This, xmldoc);
                }
                break;
            default:
                FIXME("unhandled SAFEARRAY dim: %d\n", dim);
                hr = This->error = E_NOTIMPL;
            }
        }
        break;
    case VT_UNKNOWN:
    {
        ISequentialStream *stream = NULL;
        IXMLDOMDocument3 *newdoc = NULL;
 
        if (!V_UNKNOWN(&source)) return E_INVALIDARG;
 
        hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IXMLDOMDocument3, (void**)&newdoc);
        if(hr == S_OK)
        {
            if(newdoc)
            {
                domdoc *newDoc = impl_from_IXMLDOMDocument3( newdoc );
 
                xmldoc = xmlCopyDoc(get_doc(newDoc), 1);
                xmldoc->_private = create_priv();
                hr = attach_xmldoc(This, xmldoc);
 
                if(SUCCEEDED(hr))
                    *isSuccessful = VARIANT_TRUE;
 
                return hr;
            }
        }
 
        hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IStream, (void**)&stream);
        if (FAILED(hr))
            hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_ISequentialStream, (void**)&stream);
 
        if (hr == S_OK)
        {
            hr = This->error = domdoc_load_from_stream(This, stream);
            if (hr == S_OK)
                *isSuccessful = VARIANT_TRUE;
            ISequentialStream_Release(stream);
            return hr;
        }
 
        FIXME("unsupported IUnknown type (%#lx) (%p)\n", hr, V_UNKNOWN(&source)->lpVtbl);
        break;
    }
    default:
        FIXME("VT type not supported (%d)\n", V_VT(&source));
    }
 
    if ( filename )
    {
        IUri *uri = NULL;
        IMoniker *mon;
 
        if (This->properties->uri)
        {
            IUri_Release(This->properties->uri);
            This->properties->uri = NULL;
        }
 
        hr = create_uri(This->base_uri, filename, &uri);
        if (SUCCEEDED(hr))
            hr = CreateURLMonikerEx2(NULL, uri, &mon, 0);
        if ( SUCCEEDED(hr) )
        {
            hr = domdoc_load_moniker( This, mon );
            IMoniker_Release(mon);
        }
 
        if (SUCCEEDED(hr))
        {
            get_doc(This)->name = (char *)xmlchar_from_wcharn(filename, -1, TRUE);
            This->properties->uri = uri;
            hr = This->error = S_OK;
            *isSuccessful = VARIANT_TRUE;
        }
        else
        {
            if (uri)
                IUri_Release(uri);
            This->error = E_FAIL;
        }
    }
 
    if(!filename || FAILED(hr)) {
        xmldoc = xmlNewDoc(NULL);
        xmldoc->_private = create_priv();
        hr = attach_xmldoc(This, xmldoc);
        if(SUCCEEDED(hr))
            hr = S_FALSE;
    }
 
    TRACE("hr %#lx.\n", hr);
 
    return hr;
}

domdoc_load_from_stream()

static HRESULT domdoc_load_from_stream ( domdoc *  doc, ISequentialStream *  stream  )

static

Definition at line 798 of file domdoc.c.

{
    DWORD read, written, len;
    xmlDocPtr xmldoc = NULL;
    IStream *hstream;
    HGLOBAL hglobal;
    BYTE buf[4096];
    HRESULT hr;
    char *ptr;
 
    hstream = NULL;
    hr = CreateStreamOnHGlobal(NULL, TRUE, &hstream);
    if (FAILED(hr))
        return hr;
 
    do
    {
        ISequentialStream_Read(stream, buf, sizeof(buf), &read);
        hr = IStream_Write(hstream, buf, read, &written);
    } while(SUCCEEDED(hr) && written != 0 && read != 0);
 
    if (FAILED(hr))
    {
        ERR("failed to copy stream, hr %#lx.\n", hr);
        IStream_Release(hstream);
        return hr;
    }
 
    hr = GetHGlobalFromStream(hstream, &hglobal);
    if (FAILED(hr))
    {
        IStream_Release(hstream);
        return hr;
    }
 
    len = GlobalSize(hglobal);
    ptr = GlobalLock(hglobal);
    if (len)
        xmldoc = doparse(doc, ptr, len, XML_CHAR_ENCODING_NONE);
    GlobalUnlock(hglobal);
    IStream_Release(hstream);
 
    if (!xmldoc)
    {
        ERR("Failed to parse xml\n");
        return E_FAIL;
    }
 
    xmldoc->_private = create_priv();
 
    return attach_xmldoc(doc, xmldoc);
}

Referenced by domdoc_load(), and PersistStreamInit_Load().

domdoc_load_moniker()

static HRESULT domdoc_load_moniker ( domdoc *  This, IMoniker *  mon  )

static

Definition at line 2193 of file domdoc.c.

{
    bsc_t *bsc;
    HRESULT hr;
 
    hr = bind_url(mon, domdoc_onDataAvailable, This, &bsc);
    if(FAILED(hr))
        return hr;
 
    return detach_bsc(bsc);
}

Referenced by domdoc_load().

domdoc_loadXML()

static HRESULT WINAPI domdoc_loadXML ( IXMLDOMDocument3 *  iface, BSTR  data, VARIANT_BOOL *  isSuccessful  )

static

Definition at line 2462 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    xmlDocPtr xmldoc = NULL;
    HRESULT hr = S_FALSE, hr2;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), isSuccessful );
 
    assert ( &This->node );
 
    if ( isSuccessful )
    {
        *isSuccessful = VARIANT_FALSE;
 
        if (data)
        {
            WCHAR *ptr = data;
 
            /* skip leading spaces if needed */
            if (This->properties->version == MSXML_DEFAULT || This->properties->version == MSXML26)
                while (*ptr && iswspace(*ptr)) ptr++;
 
            xmldoc = doparse(This, (char*)ptr, lstrlenW(ptr)*sizeof(WCHAR), XML_CHAR_ENCODING_UTF16LE);
            if ( !xmldoc )
            {
                This->error = E_FAIL;
                TRACE("failed to parse document\n");
            }
            else
            {
                hr = This->error = S_OK;
                *isSuccessful = VARIANT_TRUE;
                TRACE("parsed document %p\n", xmldoc);
            }
        }
    }
 
    if(!xmldoc)
        xmldoc = xmlNewDoc(NULL);
    xmldoc->_private = create_priv();
    hr2 = attach_xmldoc(This, xmldoc);
    if( FAILED(hr2) )
        hr = hr2;
 
    return hr;
}

domdoc_nodeFromID()

static HRESULT WINAPI domdoc_nodeFromID ( IXMLDOMDocument3 *  iface, BSTR  idString, IXMLDOMNode **  node  )

static

Definition at line 2169 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3(iface);
    FIXME("(%p)->(%s %p)\n", This, debugstr_w(idString), node);
    return E_NOTIMPL;
}

domdoc_ObjectWithSite_AddRef()

static ULONG WINAPI domdoc_ObjectWithSite_AddRef ( IObjectWithSite *  iface )

static

Definition at line 3610 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectWithSite(iface);
    return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
}

domdoc_ObjectWithSite_GetSite()

static HRESULT WINAPI domdoc_ObjectWithSite_GetSite ( IObjectWithSite *  iface, REFIID  iid, void **  ppvSite  )

static

Definition at line 3622 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectWithSite(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
 
    if ( !This->site )
        return E_FAIL;
 
    return IUnknown_QueryInterface( This->site, iid, ppvSite );
}

domdoc_ObjectWithSite_QueryInterface()

static HRESULT WINAPI domdoc_ObjectWithSite_QueryInterface ( IObjectWithSite *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 3604 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectWithSite(iface);
    return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObject);
}

domdoc_ObjectWithSite_Release()

static ULONG WINAPI domdoc_ObjectWithSite_Release ( IObjectWithSite *  iface )

static

Definition at line 3616 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectWithSite(iface);
    return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
}

domdoc_ObjectWithSite_SetSite()

static HRESULT WINAPI domdoc_ObjectWithSite_SetSite ( IObjectWithSite *  iface, IUnknown *  punk  )

static

Definition at line 3634 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectWithSite(iface);
 
    TRACE("(%p)->(%p)\n", iface, punk);
 
    if(!punk)
    {
        if(This->site)
        {
            IUnknown_Release( This->site );
            This->site = NULL;
        }
 
        if(This->base_uri)
        {
            IUri_Release(This->base_uri);
            This->base_uri = NULL;
        }
 
        return S_OK;
    }
 
    IUnknown_AddRef( punk );
 
    if(This->site)
        IUnknown_Release( This->site );
 
    This->site = punk;
    This->base_uri = get_base_uri(This->site);
 
    return S_OK;
}

domdoc_onDataAvailable()

static HRESULT domdoc_onDataAvailable ( void *  obj, char *  ptr, DWORD  len  )

static

Definition at line 2179 of file domdoc.c.

{
    domdoc *This = obj;
    xmlDocPtr xmldoc;
 
    xmldoc = doparse(This, ptr, len, XML_CHAR_ENCODING_NONE);
    if(xmldoc) {
        xmldoc->_private = create_priv();
        return attach_xmldoc(This, xmldoc);
    }
 
    return E_FAIL;
}

Referenced by domdoc_load_moniker().

domdoc_put_async()

static HRESULT WINAPI domdoc_put_async ( IXMLDOMDocument3 *  iface, VARIANT_BOOL  isAsync  )

static

Definition at line 2441 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%d)\n", This, isAsync);
    This->async = isAsync;
    return S_OK;
}

domdoc_put_dataType()

static HRESULT WINAPI domdoc_put_dataType ( IXMLDOMDocument3 *  iface, BSTR  dataTypeName  )

static

Definition at line 1398 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    FIXME("(%p)->(%s)\n", This, debugstr_w(dataTypeName));
 
    if(!dataTypeName)
        return E_INVALIDARG;
 
    return E_FAIL;
}

domdoc_put_documentElement()

static HRESULT WINAPI domdoc_put_documentElement ( IXMLDOMDocument3 *  iface, IXMLDOMElement *  DOMElement  )

static

Definition at line 1672 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    IXMLDOMNode *elementNode;
    xmlNodePtr oldRoot;
    xmlDocPtr old_doc;
    xmlnode *xmlNode;
    int refcount = 0;
    HRESULT hr;
 
    TRACE("(%p)->(%p)\n", This, DOMElement);
 
    hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode );
    if(FAILED(hr))
        return hr;
 
    xmlNode = get_node_obj( elementNode );
    if(!xmlNode) return E_FAIL;
 
    if(!xmlNode->node->parent)
        if(xmldoc_remove_orphan(xmlNode->node->doc, xmlNode->node) != S_OK)
            WARN("%p is not an orphan of %p\n", xmlNode->node->doc, xmlNode->node);
 
    old_doc = xmlNode->node->doc;
    if (old_doc != get_doc(This))
        refcount = xmlnode_get_inst_cnt(xmlNode);
 
    /* old root is still orphaned by its document, update refcount from new root */
    if (refcount) xmldoc_add_refs(get_doc(This), refcount);
    oldRoot = xmlDocSetRootElement( get_doc(This), xmlNode->node);
    if (refcount) xmldoc_release_refs(old_doc, refcount);
    IXMLDOMNode_Release( elementNode );
 
    if(oldRoot)
        xmldoc_add_orphan(oldRoot->doc, oldRoot);
 
    return S_OK;
}

domdoc_put_nodeTypedValue()

static HRESULT WINAPI domdoc_put_nodeTypedValue ( IXMLDOMDocument3 *  iface, VARIANT  typedValue  )

static

Definition at line 1378 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
    return E_NOTIMPL;
}

domdoc_put_nodeValue()

static HRESULT WINAPI domdoc_put_nodeValue ( IXMLDOMDocument3 *  iface, VARIANT  value  )

static

Definition at line 1088 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
    return E_FAIL;
}

domdoc_put_onDataAvailable()

static HRESULT WINAPI domdoc_put_onDataAvailable ( IXMLDOMDocument3 *  iface, VARIANT  sink  )

static

Definition at line 2783 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
    return E_NOTIMPL;
}

domdoc_put_onreadystatechange()

static HRESULT WINAPI domdoc_put_onreadystatechange ( IXMLDOMDocument3 *  iface, VARIANT  event  )

static

Definition at line 2772 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%s)\n", This, debugstr_variant(&event));
    return set_doc_event(This, EVENTID_READYSTATECHANGE, &event);
}

domdoc_put_onTransformNode()

static HRESULT WINAPI domdoc_put_onTransformNode ( IXMLDOMDocument3 *  iface, VARIANT  sink  )

static

Definition at line 2790 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
    return E_NOTIMPL;
}

domdoc_put_preserveWhiteSpace()

static HRESULT WINAPI domdoc_put_preserveWhiteSpace ( IXMLDOMDocument3 *  iface, VARIANT_BOOL  isPreserving  )

static

Definition at line 2761 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%d)\n", This, isPreserving);
    This->properties->preserving = isPreserving;
    return S_OK;
}

domdoc_put_resolveExternals()

static HRESULT WINAPI domdoc_put_resolveExternals ( IXMLDOMDocument3 *  iface, VARIANT_BOOL  isResolving  )

static

Definition at line 2739 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%d)\n", This, isResolving);
    This->resolving = isResolving;
    return S_OK;
}

domdoc_put_text()

static HRESULT WINAPI domdoc_put_text ( IXMLDOMDocument3 *  iface, BSTR  text  )

static

Definition at line 1338 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%s)\n", This, debugstr_w(text));
    return E_FAIL;
}

domdoc_put_validateOnParse()

static HRESULT WINAPI domdoc_put_validateOnParse ( IXMLDOMDocument3 *  iface, VARIANT_BOOL  isValidating  )

static

Definition at line 2717 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%d)\n", This, isValidating);
    This->properties->validating = isValidating;
    return S_OK;
}

domdoc_putref_schemas()

static HRESULT WINAPI domdoc_putref_schemas ( IXMLDOMDocument3 *  iface, VARIANT  schema  )

static

Definition at line 2848 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    HRESULT hr = E_FAIL;
    IXMLDOMSchemaCollection2* new_schema = NULL;
 
    FIXME("(%p)->(%s): semi-stub\n", This, debugstr_variant(&schema));
    switch(V_VT(&schema))
    {
    case VT_UNKNOWN:
        if (V_UNKNOWN(&schema))
        {
            hr = IUnknown_QueryInterface(V_UNKNOWN(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
            break;
        }
        /* fallthrough */
    case VT_DISPATCH:
        if (V_DISPATCH(&schema))
        {
            hr = IDispatch_QueryInterface(V_DISPATCH(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
            break;
        }
        /* fallthrough */
    case VT_NULL:
    case VT_EMPTY:
        hr = S_OK;
        break;
 
    default:
        WARN("Can't get schema from vt %x\n", V_VT(&schema));
    }
 
    if(SUCCEEDED(hr))
    {
        IXMLDOMSchemaCollection2* old_schema = InterlockedExchangePointer((void**)&This->properties->schemaCache, new_schema);
        if(old_schema) IXMLDOMSchemaCollection2_Release(old_schema);
    }
 
    return hr;
}

domdoc_QueryInterface()

static HRESULT WINAPI domdoc_QueryInterface ( IXMLDOMDocument3 *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 925 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppvObject );
 
    *ppvObject = NULL;
 
    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
         IsEqualGUID( riid, &IID_IDispatch ) ||
         IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
         IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
         IsEqualGUID( riid, &IID_IXMLDOMDocument2 )||
         IsEqualGUID( riid, &IID_IXMLDOMDocument3 ))
    {
        *ppvObject = iface;
    }
    else if (IsEqualGUID(&IID_IPersistStream, riid) ||
             IsEqualGUID(&IID_IPersistStreamInit, riid))
    {
        *ppvObject = &This->IPersistStreamInit_iface;
    }
    else if (IsEqualGUID(&IID_IObjectWithSite, riid))
    {
        *ppvObject = &This->IObjectWithSite_iface;
    }
    else if (IsEqualGUID(&IID_IObjectSafety, riid))
    {
        *ppvObject = &This->IObjectSafety_iface;
    }
    else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
    {
        return node_create_supporterrorinfo(domdoc_se_tids, ppvObject);
    }
    else if(node_query_interface(&This->node, riid, ppvObject))
    {
        return *ppvObject ? S_OK : E_NOINTERFACE;
    }
    else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
    {
        *ppvObject = &This->IConnectionPointContainer_iface;
    }
    else
    {
        TRACE("interface %s not implemented\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppvObject);
 
    return S_OK;
}

domdoc_Release()

static ULONG WINAPI domdoc_Release ( IXMLDOMDocument3 *  iface )

static

Definition at line 986 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    LONG ref = InterlockedDecrement( &This->ref );
 
    TRACE("%p, refcount %ld.\n", iface, ref);
 
    if (!ref)
    {
        int eid;
 
        if (This->site)
            IUnknown_Release( This->site );
        if (This->base_uri)
            IUri_Release( This->base_uri );
        destroy_xmlnode(&This->node);
 
        for (eid = 0; eid < EVENTID_LAST; eid++)
            if (This->events[eid]) IDispatch_Release(This->events[eid]);
 
        properties_release(This->properties);
        release_namespaces(This);
        free(This);
    }
 
    return ref;
}

domdoc_removeChild()

static HRESULT WINAPI domdoc_removeChild ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  child, IXMLDOMNode **  oldChild  )

static

Definition at line 1239 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p %p)\n", This, child, oldChild);
    return node_remove_child(&This->node, child, oldChild);
}

domdoc_replaceChild()

static HRESULT WINAPI domdoc_replaceChild ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  newChild, IXMLDOMNode *  oldChild, IXMLDOMNode **  outOldChild  )

static

Definition at line 1225 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, outOldChild);
 
    return node_replace_child(&This->node, newChild, oldChild, outOldChild);
}

domdoc_Safety_AddRef()

static ULONG WINAPI domdoc_Safety_AddRef ( IObjectSafety *  iface )

static

Definition at line 3683 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectSafety(iface);
    return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
}

domdoc_Safety_GetInterfaceSafetyOptions()

static HRESULT WINAPI domdoc_Safety_GetInterfaceSafetyOptions ( IObjectSafety *  iface, REFIID  riid, DWORD *  supported, DWORD *  enabled  )

static

Definition at line 3697 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectSafety(iface);
 
    TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
 
    if(!supported || !enabled) return E_POINTER;
 
    *supported = SAFETY_SUPPORTED_OPTIONS;
    *enabled = This->safeopt;
 
    return S_OK;
}

domdoc_Safety_QueryInterface()

static HRESULT WINAPI domdoc_Safety_QueryInterface ( IObjectSafety *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3677 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectSafety(iface);
    return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
}

domdoc_Safety_Release()

static ULONG WINAPI domdoc_Safety_Release ( IObjectSafety *  iface )

static

Definition at line 3689 of file domdoc.c.

{
    domdoc *This = impl_from_IObjectSafety(iface);
    return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
}

domdoc_Safety_SetInterfaceSafetyOptions()

static HRESULT WINAPI domdoc_Safety_SetInterfaceSafetyOptions ( IObjectSafety *  iface, REFIID  riid, DWORD  mask, DWORD  enabled  )

static

Definition at line 3712 of file domdoc.c.

{
    domdoc *doc = impl_from_IObjectSafety(iface);
 
    TRACE("%p, %s, %lx, %lx.\n", iface, debugstr_guid(riid), mask, enabled);
 
    if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
        return E_FAIL;
 
    doc->safeopt = (doc->safeopt & ~mask) | (mask & enabled);
 
    return S_OK;
}

domdoc_save()

static HRESULT WINAPI domdoc_save ( IXMLDOMDocument3 *  iface, VARIANT  destination  )

static

Definition at line 2612 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    xmlSaveCtxtPtr ctx = NULL;
    HRESULT ret = S_OK;
 
    TRACE("(%p)->(%s)\n", This, debugstr_variant(&destination));
 
    switch (V_VT(&destination))
    {
    case VT_UNKNOWN:
        {
            IUnknown *pUnk = V_UNKNOWN(&destination);
            IXMLDOMDocument3 *document;
            IStream *stream;
 
            ret = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMDocument3, (void**)&document);
            if(ret == S_OK)
            {
                VARIANT_BOOL success;
                BSTR xml;
 
                ret = IXMLDOMDocument3_get_xml(iface, &xml);
                if(ret == S_OK)
                {
                    ret = IXMLDOMDocument3_loadXML(document, xml, &success);
                    SysFreeString(xml);
                }
 
                IXMLDOMDocument3_Release(document);
                return ret;
            }
 
            ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream);
            if(ret == S_OK)
            {
                char *encoding = xmldoc_encoding(iface);
 
                TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default");
                ctx = xmlSaveToIO(domdoc_stream_save_writecallback,
                    domdoc_stream_save_closecallback, stream, encoding, XML_SAVE_NO_DECL);
                free(encoding);
 
                if(!ctx)
                {
                    IStream_Release(stream);
                    return E_FAIL;
                }
            }
        }
        break;
 
    case VT_BSTR:
    case VT_BSTR | VT_BYREF:
        {
            char *encoding;
            /* save with file path */
            HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination),
                                         GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
            if( handle == INVALID_HANDLE_VALUE )
            {
                WARN("failed to create file\n");
                return E_FAIL;
            }
 
            encoding = xmldoc_encoding(iface);
            TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default");
            ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback,
                              handle, encoding, XML_SAVE_NO_DECL);
            free(encoding);
 
            if (!ctx)
            {
                CloseHandle(handle);
                return E_FAIL;
            }
        }
        break;
 
    default:
        FIXME("Unhandled VARIANT: %s\n", debugstr_variant(&destination));
        return S_FALSE;
    }
 
    if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE;
 
    /* will release resources through close callback */
    xmlSaveClose(ctx);
 
    return ret;
}

domdoc_save_closecallback()

static int XMLCALL domdoc_save_closecallback ( void *  ctx )

static

Definition at line 2525 of file domdoc.c.

{
    return CloseHandle(ctx) ? 0 : -1;
}

Referenced by domdoc_save().

domdoc_save_writecallback()

static int XMLCALL domdoc_save_writecallback ( void *  ctx, const char *  buffer, int  len  )

static

Definition at line 2512 of file domdoc.c.

{
    DWORD written = -1;
 
    if(!WriteFile(ctx, buffer, len, &written, NULL))
    {
        WARN("write error\n");
        return -1;
    }
    else
        return written;
}

Referenced by domdoc_save().

domdoc_selectNodes()

static HRESULT WINAPI domdoc_selectNodes ( IXMLDOMDocument3 *  iface, BSTR  p, IXMLDOMNodeList **  outList  )

static

Definition at line 1483 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
    return node_select_nodes(&This->node, p, outList);
}

domdoc_selectSingleNode()

static HRESULT WINAPI domdoc_selectSingleNode ( IXMLDOMDocument3 *  iface, BSTR  p, IXMLDOMNode **  outNode  )

static

Definition at line 1494 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
    return node_select_singlenode(&This->node, p, outNode);
}

domdoc_setProperty()

static HRESULT WINAPI domdoc_setProperty ( IXMLDOMDocument3 *  iface, BSTR  p, VARIANT  value  )

static

Definition at line 3021 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%s %s)\n", This, debugstr_w(p), debugstr_variant(&value));
 
    if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
    {
        VARIANT varStr;
        HRESULT hr;
        BSTR bstr;
 
        V_VT(&varStr) = VT_EMPTY;
        if (V_VT(&value) != VT_BSTR)
        {
            if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
                return hr;
            bstr = V_BSTR(&varStr);
        }
        else
            bstr = V_BSTR(&value);
 
        hr = S_OK;
        if (lstrcmpiW(bstr, PropValueXPathW) == 0)
            This->properties->XPath = TRUE;
        else if (lstrcmpiW(bstr, PropValueXSLPatternW) == 0)
            This->properties->XPath = FALSE;
        else
            hr = E_FAIL;
 
        VariantClear(&varStr);
        return hr;
    }
    else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
    {
        xmlChar *nsStr = (xmlChar*)This->properties->selectNsStr;
        struct list *pNsList;
        VARIANT varStr;
        HRESULT hr;
        BSTR bstr;
 
        V_VT(&varStr) = VT_EMPTY;
        if (V_VT(&value) != VT_BSTR)
        {
            if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
                return hr;
            bstr = V_BSTR(&varStr);
        }
        else
            bstr = V_BSTR(&value);
 
        hr = S_OK;
 
        pNsList = &(This->properties->selectNsList);
        clear_selectNsList(pNsList);
        free(nsStr);
        nsStr = xmlchar_from_wchar(bstr);
 
        TRACE("property value: \"%s\"\n", debugstr_w(bstr));
 
        This->properties->selectNsStr = nsStr;
        This->properties->selectNsStr_len = xmlStrlen(nsStr);
        if (bstr && *bstr)
        {
            xmlChar *pTokBegin, *pTokEnd, *pTokInner;
            select_ns_entry* ns_entry = NULL;
            xmlXPathContextPtr ctx;
 
            ctx = xmlXPathNewContext(This->node.node->doc);
            pTokBegin = nsStr;
 
            /* skip leading spaces */
            while (*pTokBegin == ' '  || *pTokBegin == '\n' ||
                   *pTokBegin == '\t' || *pTokBegin == '\r')
                ++pTokBegin;
 
            for (; *pTokBegin; pTokBegin = pTokEnd)
            {
                if (ns_entry)
                    memset(ns_entry, 0, sizeof(select_ns_entry));
                else
                    ns_entry = calloc(1, sizeof(select_ns_entry));
 
                while (*pTokBegin == ' ')
                    ++pTokBegin;
                pTokEnd = pTokBegin;
                while (*pTokEnd != ' ' && *pTokEnd != 0)
                    ++pTokEnd;
 
                /* so it failed to advance which means we've got some trailing spaces */
                if (pTokEnd == pTokBegin) break;
 
                if (xmlStrncmp(pTokBegin, (xmlChar const*)"xmlns", 5) != 0)
                {
                    hr = E_FAIL;
                    WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
                          debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
                    continue;
                }
 
                pTokBegin += 5;
                if (*pTokBegin == '=')
                {
                    /*valid for XSLPattern?*/
                    FIXME("Setting default xmlns not supported - skipping.\n");
                    continue;
                }
                else if (*pTokBegin == ':')
                {
                    ns_entry->prefix = ++pTokBegin;
                    for (pTokInner = pTokBegin; pTokInner != pTokEnd && *pTokInner != '='; ++pTokInner)
                        ;
 
                    if (pTokInner == pTokEnd)
                    {
                        hr = E_FAIL;
                        WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
                              debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
                        continue;
                    }
 
                    ns_entry->prefix_end = *pTokInner;
                    *pTokInner = 0;
                    ++pTokInner;
 
                    if (pTokEnd-pTokInner > 1 &&
                        ((*pTokInner == '\'' && *(pTokEnd-1) == '\'') ||
                         (*pTokInner == '"' && *(pTokEnd-1) == '"')))
                    {
                        ns_entry->href = ++pTokInner;
                        ns_entry->href_end = *(pTokEnd-1);
                        *(pTokEnd-1) = 0;
                        list_add_tail(pNsList, &ns_entry->entry);
                        /*let libxml figure out if they're valid from here ;)*/
                        if (xmlXPathRegisterNs(ctx, ns_entry->prefix, ns_entry->href) != 0)
                        {
                            hr = E_FAIL;
                        }
                        ns_entry = NULL;
                        continue;
                    }
                    else
                    {
                        WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
                              debugstr_w(bstr), debugstr_an((const char*)pTokInner, pTokEnd-pTokInner));
                        list_add_tail(pNsList, &ns_entry->entry);
 
                        ns_entry = NULL;
                        hr = E_FAIL;
                        continue;
                    }
                }
                else
                {
                    hr = E_FAIL;
                    continue;
                }
            }
            free(ns_entry);
            xmlXPathFreeContext(ctx);
        }
 
        VariantClear(&varStr);
        return hr;
    }
    else if (lstrcmpiW(p, PropertyValidateOnParse) == 0)
    {
        if (This->properties->version < MSXML4)
            return E_FAIL;
        else
        {
            This->properties->validating = V_BOOL(&value);
            return S_OK;
        }
    }
    else if (lstrcmpiW(p, PropertyProhibitDTDW) == 0 ||
             lstrcmpiW(p, PropertyNewParserW) == 0 ||
             lstrcmpiW(p, PropertyResolveExternalsW) == 0 ||
             lstrcmpiW(p, PropertyAllowXsltScriptW) == 0 ||
             lstrcmpiW(p, PropertyNormalizeAttributeValuesW) == 0 ||
             lstrcmpiW(p, PropertyAllowDocumentFunctionW) == 0 ||
             lstrcmpiW(p, PropertyMaxElementDepth) == 0)
    {
        /* Ignore */
        FIXME("Ignoring property %s, value %s\n", debugstr_w(p), debugstr_variant(&value));
        return S_OK;
    }
 
    FIXME("Unknown property %s\n", debugstr_w(p));
    return E_FAIL;
}

domdoc_stream_save_closecallback()

static int XMLCALL domdoc_stream_save_closecallback ( void *  ctx )

static

Definition at line 2546 of file domdoc.c.

{
    IStream_Release((IStream*)ctx);
    return 0;
}

Referenced by domdoc_save().

domdoc_stream_save_writecallback()

static int XMLCALL domdoc_stream_save_writecallback ( void *  ctx, const char *  buffer, int  len  )

static

Definition at line 2530 of file domdoc.c.

{
    ULONG written = 0;
    HRESULT hr;
 
    hr = IStream_Write((IStream*)ctx, buffer, len, &written);
    TRACE("hr %#lx, %p, %d, %lu.\n", hr, buffer, len, written);
    if (hr != S_OK)
    {
        WARN("stream write error, hr %#lx.\n", hr);
        return -1;
    }
    else
        return len;
}

Referenced by domdoc_save().

domdoc_transformNode()

static HRESULT WINAPI domdoc_transformNode ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  node, BSTR *  p  )

static

Definition at line 1472 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p %p)\n", This, node, p);
    return node_transform_node(&This->node, node, p);
}

domdoc_transformNodeToObject()

static HRESULT WINAPI domdoc_transformNodeToObject ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  stylesheet, VARIANT  output  )

static

Definition at line 1544 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
 
    TRACE("(%p)->(%p %s)\n", This, stylesheet, debugstr_variant(&output));
 
    switch (V_VT(&output))
    {
    case VT_UNKNOWN:
    case VT_DISPATCH:
    {
        ISequentialStream *stream;
        IXMLDOMDocument *doc;
        HRESULT hr;
        BSTR str;
 
        if (!V_UNKNOWN(&output))
            return E_INVALIDARG;
 
        /* FIXME: we're not supposed to query for document interface, should use IStream
           which we don't support currently. */
        if (IUnknown_QueryInterface(V_UNKNOWN(&output), &IID_IXMLDOMDocument, (void **)&doc) == S_OK)
        {
            VARIANT_BOOL b;
 
            if (FAILED(hr = node_transform_node(&This->node, stylesheet, &str)))
                return hr;
 
            hr = IXMLDOMDocument_loadXML(doc, str, &b);
            SysFreeString(str);
            return hr;
        }
        else if (IUnknown_QueryInterface(V_UNKNOWN(&output), &IID_ISequentialStream, (void**)&stream) == S_OK)
        {
            hr = node_transform_node_params(&This->node, stylesheet, NULL, stream, NULL);
            ISequentialStream_Release(stream);
            return hr;
        }
        else
        {
            FIXME("Unsupported destination type.\n");
            return E_INVALIDARG;
        }
    }
    default:
        FIXME("Output type %d not handled.\n", V_VT(&output));
        return E_NOTIMPL;
    }
 
    return E_NOTIMPL;
}

domdoc_validate()

static HRESULT WINAPI domdoc_validate ( IXMLDOMDocument3 *  iface, IXMLDOMParseError **  err  )

static

Definition at line 3012 of file domdoc.c.

{
    domdoc *This = impl_from_IXMLDOMDocument3( iface );
    TRACE("(%p)->(%p)\n", This, err);
    return IXMLDOMDocument3_validateNode(iface, (IXMLDOMNode*)iface, err);
}

domdoc_validateNode()

static HRESULT WINAPI domdoc_validateNode ( IXMLDOMDocument3 *  iface, IXMLDOMNode *  node, IXMLDOMParseError **  err  )

static

Definition at line 2912 of file domdoc.c.

{
    domdoc* This = impl_from_IXMLDOMDocument3(iface);
    LONG state, err_code = 0;
    HRESULT hr = S_OK;
    int validated = 0;
 
    TRACE("(%p)->(%p, %p)\n", This, node, err);
    IXMLDOMDocument3_get_readyState(iface, &state);
    if (state != READYSTATE_COMPLETE)
    {
        if (err)
           *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
        return E_PENDING;
    }
 
    if (!node)
    {
        if (err)
            *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
        return E_POINTER;
    }
 
    if (!get_node_obj(node)->node || get_node_obj(node)->node->doc != get_doc(This))
    {
        if (err)
            *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
        return E_FAIL;
    }
 
    if (!is_wellformed(get_doc(This)))
    {
        ERR("doc not well-formed\n");
        if (err)
            *err = create_parseError(E_XML_NOTWF, NULL, NULL, NULL, 0, 0, 0);
        return S_FALSE;
    }
 
    /* DTD validation */
    if (get_doc(This)->intSubset || get_doc(This)->extSubset)
    {
        xmlValidCtxtPtr vctx = xmlNewValidCtxt();
        vctx->error = validate_error;
        vctx->warning = validate_warning;
        ++validated;
 
        if (!((node == (IXMLDOMNode*)iface)?
              xmlValidateDocument(vctx, get_doc(This)) :
              xmlValidateElement(vctx, get_doc(This), get_node_obj(node)->node)))
        {
            /* TODO: get a real error code here */
            TRACE("DTD validation failed\n");
            err_code = E_XML_INVALID;
            hr = S_FALSE;
        }
        xmlFreeValidCtxt(vctx);
    }
 
    /* Schema validation */
    if (hr == S_OK && This->properties->schemaCache != NULL)
    {
 
        hr = SchemaCache_validate_tree(This->properties->schemaCache, get_node_obj(node)->node);
        if (SUCCEEDED(hr))
        {
            ++validated;
            /* TODO: get a real error code here */
            if (hr == S_OK)
            {
                TRACE("schema validation succeeded\n");
            }
            else
            {
                ERR("schema validation failed\n");
                err_code = E_XML_INVALID;
            }
        }
        else
        {
            /* not really OK, just didn't find a schema for the ns */
            hr = S_OK;
        }
    }
 
    if (!validated)
    {
        ERR("no DTD or schema found\n");
        err_code = E_XML_NODTD;
        hr = S_FALSE;
    }
 
    if (err)
        *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
 
    return hr;
}

Referenced by validate_error(), and validate_warning().

doparse()

static xmlDocPtr doparse ( domdoc *  This, char const *  ptr, int  len, xmlCharEncoding  encoding  )

static

Definition at line 502 of file domdoc.c.

{
    char *ctx_encoding;
    xmlDocPtr doc = NULL;
    xmlParserCtxtPtr pctx;
    static xmlSAXHandler sax_handler = {
        xmlSAX2InternalSubset,          /* internalSubset */
        xmlSAX2IsStandalone,            /* isStandalone */
        xmlSAX2HasInternalSubset,       /* hasInternalSubset */
        xmlSAX2HasExternalSubset,       /* hasExternalSubset */
        xmlSAX2ResolveEntity,           /* resolveEntity */
        xmlSAX2GetEntity,               /* getEntity */
        xmlSAX2EntityDecl,              /* entityDecl */
        xmlSAX2NotationDecl,            /* notationDecl */
        xmlSAX2AttributeDecl,           /* attributeDecl */
        xmlSAX2ElementDecl,             /* elementDecl */
        xmlSAX2UnparsedEntityDecl,      /* unparsedEntityDecl */
        xmlSAX2SetDocumentLocator,      /* setDocumentLocator */
        xmlSAX2StartDocument,           /* startDocument */
        xmlSAX2EndDocument,             /* endDocument */
        xmlSAX2StartElement,            /* startElement */
        xmlSAX2EndElement,              /* endElement */
        xmlSAX2Reference,               /* reference */
        sax_characters,                 /* characters */
        sax_characters,                 /* ignorableWhitespace */
        xmlSAX2ProcessingInstruction,   /* processingInstruction */
        xmlSAX2Comment,                 /* comment */
        sax_warning,                    /* warning */
        sax_error,                      /* error */
        sax_error,                      /* fatalError */
        xmlSAX2GetParameterEntity,      /* getParameterEntity */
        xmlSAX2CDataBlock,              /* cdataBlock */
        xmlSAX2ExternalSubset,          /* externalSubset */
        0,                              /* initialized */
        NULL,                           /* _private */
        xmlSAX2StartElementNs,          /* startElementNs */
        xmlSAX2EndElementNs,            /* endElementNs */
        sax_serror                      /* serror */
    };
 
    pctx = xmlCreateMemoryParserCtxt(ptr, len);
    if (!pctx)
    {
        ERR("Failed to create parser context\n");
        return NULL;
    }
 
    if (pctx->sax) xmlFree(pctx->sax);
    pctx->sax = &sax_handler;
    pctx->_private = This;
    pctx->recovery = 0;
 
    if (encoding != XML_CHAR_ENCODING_NONE)
        xmlSwitchEncoding(pctx, encoding);
 
    xmlParseDocument(pctx);
 
    if (pctx->wellFormed)
    {
        doc = pctx->myDoc;
    }
    else
    {
       xmlFreeDoc(pctx->myDoc);
       pctx->myDoc = NULL;
    }
    pctx->sax = NULL;
    ctx_encoding = (char *)pctx->encoding;
    pctx->encoding = NULL;
    xmlFreeParserCtxt(pctx);
 
    /* TODO: put this in one of the SAX callbacks */
    /* create first child as a <?xml...?> */
    if (doc && doc->standalone != -1)
    {
        xmlNodePtr node;
        char buff[30];
        xmlChar *xmlbuff = (xmlChar*)buff;
 
        node = xmlNewDocPI( doc, (xmlChar*)"xml", NULL );
 
        /* version attribute can't be omitted */
        sprintf(buff, "version=\"%s\"", doc->version ? (char*)doc->version : "1.0");
        xmlNodeAddContent( node, xmlbuff );
 
        if (ctx_encoding)
        {
            sprintf(buff, " encoding=\"%s\"", ctx_encoding);
            xmlNodeAddContent( node, xmlbuff );
        }
 
        if (doc->standalone != -2)
        {
            sprintf(buff, " standalone=\"%s\"", doc->standalone == 0 ? "no" : "yes");
            xmlNodeAddContent( node, xmlbuff );
        }
 
        xmldoc_link_xmldecl( doc, node );
    }
 
    xmlFree( ctx_encoding );
    return doc;
}

Referenced by domdoc_load(), domdoc_load_from_stream(), domdoc_loadXML(), domdoc_onDataAvailable(), sax_error(), sax_serror(), and sax_warning().

get_doc()

static xmlDocPtr get_doc ( domdoc *  This )

inlinestatic

Definition at line 690 of file domdoc.c.

{
    return This->node.node->doc;
}

Referenced by attach_xmldoc(), domdoc_cloneNode(), domdoc_createNode(), domdoc_get_doctype(), domdoc_get_documentElement(), domdoc_get_xml(), domdoc_getElementsByTagName(), domdoc_load(), domdoc_put_documentElement(), domdoc_save(), and domdoc_validateNode().

get_domdoc_from_xmldoc()

HRESULT get_domdoc_from_xmldoc	(	xmlDocPtr	xmldoc,
		IXMLDOMDocument3 **	document
	)

Definition at line 3749 of file domdoc.c.

{
    domdoc *doc;
 
    doc = malloc(sizeof(*doc));
    if( !doc )
        return E_OUTOFMEMORY;
 
    doc->IXMLDOMDocument3_iface.lpVtbl = &XMLDOMDocument3Vtbl;
    doc->IPersistStreamInit_iface.lpVtbl = &xmldoc_IPersistStreamInit_VTable;
    doc->IObjectWithSite_iface.lpVtbl = &domdocObjectSite;
    doc->IObjectSafety_iface.lpVtbl = &domdocObjectSafetyVtbl;
    doc->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
    doc->ref = 1;
    doc->async = VARIANT_TRUE;
    doc->resolving = 0;
    doc->properties = properties_add_ref(properties_from_xmlDocPtr(xmldoc));
    doc->error = S_OK;
    doc->site = NULL;
    doc->base_uri = NULL;
    doc->safeopt = 0;
    doc->cp_list = NULL;
    doc->namespaces = NULL;
    memset(doc->events, 0, sizeof(doc->events));
 
    /* events connection points */
    ConnectionPoint_Init(&doc->cp_dispatch, doc, &IID_IDispatch);
    ConnectionPoint_Init(&doc->cp_propnotif, doc, &IID_IPropertyNotifySink);
    ConnectionPoint_Init(&doc->cp_domdocevents, doc, &DIID_XMLDOMDocumentEvents);
 
    init_xmlnode(&doc->node, (xmlNodePtr)xmldoc, (IXMLDOMNode*)&doc->IXMLDOMDocument3_iface,
            &domdoc_dispex);
 
    *document = &doc->IXMLDOMDocument3_iface;
 
    TRACE("returning iface %p\n", *document);
    return S_OK;
}

Referenced by create_domdoc(), dom_document_create(), node_get_owner_doc(), and schema_cache_get().

get_node_type()

static HRESULT get_node_type ( VARIANT  Type, DOMNodeType *  type  )

static

Definition at line 2027 of file domdoc.c.

{
    VARIANT tmp;
    HRESULT hr;
 
    VariantInit(&tmp);
    hr = VariantChangeType(&tmp, &Type, 0, VT_I4);
    if(FAILED(hr))
        return E_INVALIDARG;
 
    *type = V_I4(&tmp);
 
    return S_OK;
}

impl_from_IConnectionPoint()

static ConnectionPoint * impl_from_IConnectionPoint ( IConnectionPoint *  iface )

inlinestatic

Definition at line 169 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface);
}

Referenced by ConnectionPoint_AddRef(), ConnectionPoint_Advise(), ConnectionPoint_EnumConnections(), ConnectionPoint_GetConnectionInterface(), ConnectionPoint_GetConnectionPointContainer(), ConnectionPoint_QueryInterface(), ConnectionPoint_Release(), and ConnectionPoint_Unadvise().

impl_from_IConnectionPointContainer()

static domdoc * impl_from_IConnectionPointContainer ( IConnectionPointContainer *  iface )

inlinestatic

Definition at line 747 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, domdoc, IConnectionPointContainer_iface);
}

Referenced by ConnectionPointContainer_AddRef(), ConnectionPointContainer_EnumConnectionPoints(), ConnectionPointContainer_FindConnectionPoint(), ConnectionPointContainer_QueryInterface(), and ConnectionPointContainer_Release().

impl_from_IObjectSafety()

static domdoc * impl_from_IObjectSafety ( IObjectSafety *  iface )

inlinestatic

Definition at line 742 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, domdoc, IObjectSafety_iface);
}

Referenced by domdoc_Safety_AddRef(), domdoc_Safety_GetInterfaceSafetyOptions(), domdoc_Safety_QueryInterface(), domdoc_Safety_Release(), and domdoc_Safety_SetInterfaceSafetyOptions().

impl_from_IObjectWithSite()

static domdoc * impl_from_IObjectWithSite ( IObjectWithSite *  iface )

inlinestatic

Definition at line 737 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, domdoc, IObjectWithSite_iface);
}

Referenced by domdoc_ObjectWithSite_AddRef(), domdoc_ObjectWithSite_GetSite(), domdoc_ObjectWithSite_QueryInterface(), domdoc_ObjectWithSite_Release(), and domdoc_ObjectWithSite_SetSite().

impl_from_IPersistStreamInit()

static domdoc * impl_from_IPersistStreamInit ( IPersistStreamInit *  iface )

inlinestatic

Definition at line 732 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, domdoc, IPersistStreamInit_iface);
}

Referenced by PersistStreamInit_AddRef(), PersistStreamInit_GetClassID(), PersistStreamInit_GetSizeMax(), PersistStreamInit_InitNew(), PersistStreamInit_IsDirty(), PersistStreamInit_Load(), PersistStreamInit_QueryInterface(), PersistStreamInit_Release(), and PersistStreamInit_Save().

impl_from_IXMLDOMDocument3()

static domdoc * impl_from_IXMLDOMDocument3 ( IXMLDOMDocument3 *  iface )

inlinestatic

Definition at line 727 of file domdoc.c.

{
    return CONTAINING_RECORD(iface, domdoc, IXMLDOMDocument3_iface);
}

Referenced by domdoc_abort(), domdoc_AddRef(), domdoc_appendChild(), domdoc_cloneNode(), domdoc_createAttribute(), domdoc_createCDATASection(), domdoc_createComment(), domdoc_createDocumentFragment(), domdoc_createElement(), domdoc_createEntityReference(), domdoc_createNode(), domdoc_createProcessingInstruction(), domdoc_createTextNode(), domdoc_get_async(), domdoc_get_attributes(), domdoc_get_baseName(), domdoc_get_childNodes(), domdoc_get_dataType(), domdoc_get_definition(), domdoc_get_doctype(), domdoc_get_documentElement(), domdoc_get_firstChild(), domdoc_get_implementation(), domdoc_get_lastChild(), domdoc_get_namespaces(), domdoc_get_namespaceURI(), domdoc_get_nextSibling(), domdoc_get_nodeName(), domdoc_get_nodeType(), domdoc_get_nodeTypedValue(), domdoc_get_nodeTypeString(), domdoc_get_nodeValue(), domdoc_get_ownerDocument(), domdoc_get_parentNode(), domdoc_get_parsed(), domdoc_get_parseError(), domdoc_get_prefix(), domdoc_get_preserveWhiteSpace(), domdoc_get_previousSibling(), domdoc_get_readyState(), domdoc_get_resolveExternals(), domdoc_get_schemas(), domdoc_get_specified(), domdoc_get_text(), domdoc_get_url(), domdoc_get_validateOnParse(), domdoc_get_xml(), domdoc_getElementsByTagName(), domdoc_GetIDsOfNames(), domdoc_getProperty(), domdoc_GetTypeInfo(), domdoc_GetTypeInfoCount(), domdoc_hasChildNodes(), domdoc_importNode(), domdoc_insertBefore(), domdoc_Invoke(), domdoc_load(), domdoc_loadXML(), domdoc_nodeFromID(), domdoc_put_async(), domdoc_put_dataType(), domdoc_put_documentElement(), domdoc_put_nodeTypedValue(), domdoc_put_nodeValue(), domdoc_put_onDataAvailable(), domdoc_put_onreadystatechange(), domdoc_put_onTransformNode(), domdoc_put_preserveWhiteSpace(), domdoc_put_resolveExternals(), domdoc_put_text(), domdoc_put_validateOnParse(), domdoc_putref_schemas(), domdoc_QueryInterface(), domdoc_Release(), domdoc_removeChild(), domdoc_replaceChild(), domdoc_save(), domdoc_selectNodes(), domdoc_selectSingleNode(), domdoc_setProperty(), domdoc_transformNode(), domdoc_transformNodeToObject(), domdoc_validate(), and domdoc_validateNode().

is_preserving_whitespace()

BOOL is_preserving_whitespace

(

xmlNodePtr

node

)

Definition at line 419 of file domdoc.c.

{
    domdoc_properties* properties = NULL;
    /* during parsing the xmlDoc._private stuff is not there */
    if (priv_from_xmlDocPtr(node->doc))
        properties = properties_from_xmlDocPtr(node->doc);
    return ((properties && properties->preserving == VARIANT_TRUE) ||
            xmlNodeGetSpacePreserve(node) == 1);
}

Referenced by do_get_text(), and sax_characters().

is_wellformed()

static BOOL is_wellformed ( xmlDocPtr  doc )

inlinestatic

Definition at line 2891 of file domdoc.c.

{
    return doc->properties & XML_DOC_WELLFORMED;
}

Referenced by domdoc_validateNode().

is_xpathmode()

BOOL is_xpathmode

(

const xmlDocPtr

doc

)

Definition at line 225 of file domdoc.c.

{
    return properties_from_xmlDocPtr(doc)->XPath;
}

Referenced by create_selection(), and domelem_getElementsByTagName().

PersistStreamInit_AddRef()

static ULONG WINAPI PersistStreamInit_AddRef ( IPersistStreamInit *  iface )

static

Definition at line 762 of file domdoc.c.

{
    domdoc* This = impl_from_IPersistStreamInit(iface);
    return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
}

PersistStreamInit_GetClassID()

static HRESULT WINAPI PersistStreamInit_GetClassID ( IPersistStreamInit *  iface, CLSID *  classid  )

static

Definition at line 776 of file domdoc.c.

{
    domdoc* This = impl_from_IPersistStreamInit(iface);
    TRACE("(%p)->(%p)\n", This, classid);
 
    if(!classid)
        return E_POINTER;
 
    *classid = *DOMDocument_version(This->properties->version);
 
    return S_OK;
}

PersistStreamInit_GetSizeMax()

static HRESULT WINAPI PersistStreamInit_GetSizeMax ( IPersistStreamInit *  iface, ULARGE_INTEGER *  pcbSize  )

static

Definition at line 886 of file domdoc.c.

{
    domdoc *This = impl_from_IPersistStreamInit(iface);
    TRACE("(%p)->(%p)\n", This, pcbSize);
    return E_NOTIMPL;
}

PersistStreamInit_InitNew()

static HRESULT WINAPI PersistStreamInit_InitNew ( IPersistStreamInit *  iface )

static

Definition at line 894 of file domdoc.c.

{
    domdoc *This = impl_from_IPersistStreamInit(iface);
    TRACE("(%p)\n", This);
    return S_OK;
}

PersistStreamInit_IsDirty()

static HRESULT WINAPI PersistStreamInit_IsDirty ( IPersistStreamInit *  iface )

static

Definition at line 790 of file domdoc.c.

{
    domdoc *This = impl_from_IPersistStreamInit(iface);
    FIXME("(%p): stub!\n", This);
    return S_FALSE;
}

PersistStreamInit_Load()

static HRESULT WINAPI PersistStreamInit_Load ( IPersistStreamInit *  iface, IStream *  stream  )

static

Definition at line 851 of file domdoc.c.

{
    domdoc *This = impl_from_IPersistStreamInit(iface);
 
    TRACE("(%p)->(%p)\n", This, stream);
 
    if (!stream)
        return E_INVALIDARG;
 
    return This->error = domdoc_load_from_stream(This, (ISequentialStream*)stream);
}

PersistStreamInit_QueryInterface()

static HRESULT WINAPI PersistStreamInit_QueryInterface ( IPersistStreamInit *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 755 of file domdoc.c.

{
    domdoc* This = impl_from_IPersistStreamInit(iface);
    return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObj);
}

PersistStreamInit_Release()

static ULONG WINAPI PersistStreamInit_Release ( IPersistStreamInit *  iface )

static

Definition at line 769 of file domdoc.c.

{
    domdoc* This = impl_from_IPersistStreamInit(iface);
    return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
}

PersistStreamInit_Save()

static HRESULT WINAPI PersistStreamInit_Save ( IPersistStreamInit *  iface, IStream *  stream, BOOL  clr_dirty  )

static

Definition at line 863 of file domdoc.c.

{
    domdoc *This = impl_from_IPersistStreamInit(iface);
    BSTR xmlString;
    HRESULT hr;
 
    TRACE("(%p)->(%p %d)\n", This, stream, clr_dirty);
 
    hr = IXMLDOMDocument3_get_xml(&This->IXMLDOMDocument3_iface, &xmlString);
    if(hr == S_OK)
    {
        DWORD len = SysStringLen(xmlString) * sizeof(WCHAR);
 
        hr = IStream_Write( stream, xmlString, len, NULL );
        SysFreeString(xmlString);
    }
 
    TRACE("hr %#lx.\n", hr);
 
    return hr;
}

priv_from_xmlDocPtr()

static xmldoc_priv * priv_from_xmlDocPtr ( const xmlDocPtr  doc )

inlinestatic

Definition at line 215 of file domdoc.c.

{
    return doc->_private;
}

Referenced by attach_xmldoc(), domdoc_cloneNode(), is_preserving_whitespace(), properties_from_xmlDocPtr(), xmldoc_add_orphan(), xmldoc_add_refs(), xmldoc_init(), xmldoc_release_refs(), and xmldoc_remove_orphan().

properties_add_ref()

static domdoc_properties * properties_add_ref ( domdoc_properties *  properties )

static

Definition at line 340 of file domdoc.c.

{
    LONG ref;
 
    if (!properties) return NULL;
 
    ref = InterlockedIncrement(&properties->refs);
    TRACE("%p, %ld.\n", properties, ref);
    return properties;
}

Referenced by attach_xmldoc(), and get_domdoc_from_xmldoc().

properties_from_xmlDocPtr()

static domdoc_properties * properties_from_xmlDocPtr ( xmlDocPtr  doc )

inlinestatic

Definition at line 220 of file domdoc.c.

{
    return priv_from_xmlDocPtr(doc)->properties;
}

Referenced by attach_xmldoc(), dom_document_create(), get_domdoc_from_xmldoc(), is_preserving_whitespace(), is_xpathmode(), registerNamespaces(), set_xpathmode(), and xmldoc_version().

properties_release()

static void properties_release ( domdoc_properties *  properties )

static

Definition at line 351 of file domdoc.c.

{
    LONG ref;
 
    if (!properties) return;
 
    ref = InterlockedDecrement(&properties->refs);
 
    TRACE("%p, %ld.\n", properties, ref);
 
    if (ref < 0)
        WARN("negative refcount, expect troubles\n");
 
    if (ref == 0)
    {
        if (properties->schemaCache)
            IXMLDOMSchemaCollection2_Release(properties->schemaCache);
        clear_selectNsList(&properties->selectNsList);
        free((xmlChar*)properties->selectNsStr);
        if (properties->uri)
            IUri_Release(properties->uri);
        free(properties);
    }
}

Referenced by attach_xmldoc(), dom_document_create(), domdoc_Release(), and xmldoc_release_refs().

registerNamespaces()

int registerNamespaces

(

xmlXPathContextPtr

ctxt

)

Definition at line 235 of file domdoc.c.

{
    int n = 0;
    const select_ns_entry* ns = NULL;
    const struct list* pNsList = &properties_from_xmlDocPtr(ctxt->doc)->selectNsList;
 
    TRACE("(%p)\n", ctxt);
 
    LIST_FOR_EACH_ENTRY( ns, pNsList, select_ns_entry, entry )
    {
        xmlXPathRegisterNs(ctxt, ns->prefix, ns->href);
        ++n;
    }
 
    return n;
}

Referenced by create_selection().

release_namespaces()

static void release_namespaces ( domdoc *  This )

static

Definition at line 376 of file domdoc.c.

{
    if (This->namespaces)
    {
        IXMLDOMSchemaCollection2_Release(This->namespaces);
        This->namespaces = NULL;
    }
}

Referenced by attach_xmldoc(), domdoc_get_namespaces(), and domdoc_Release().

sax_characters()

static void sax_characters ( void *  ctx, const xmlChar *  ch, int  len  )

static

Definition at line 438 of file domdoc.c.

{
    xmlParserCtxtPtr ctxt;
    const domdoc *This;
 
    ctxt = (xmlParserCtxtPtr) ctx;
    This = (const domdoc*) ctxt->_private;
 
    if (ctxt->node)
    {
        xmlChar cur = *(ctxt->input->cur);
 
        /* Characters are reported with multiple calls, for example each charref is reported with a separate
           call and then parser appends it to a single text node or creates a new node if not created.
           It's not possible to tell if it's ignorable data or not just looking at data itself cause it could be
           space chars that separate charrefs or similar case. We only need to skip leading and trailing spaces,
           or whole node if it has nothing but space chars, so to detect leading space node->last is checked that
           contains text node pointer if already created, trailing spaces are detected directly looking at parser input
           for next '<' opening bracket - similar logic is used by libxml2 itself. Basically 'cur' == '<' means the last
           chunk of char data, in case it's not the last chunk we check for previously added node type and if it's not
           a text node it's safe to ignore.
 
           Note that during domdoc_loadXML() the xmlDocPtr->_private data is not available. */
 
        if (!This->properties->preserving &&
            !is_preserving_whitespace(ctxt->node) &&
            strn_isspace(ch, len) &&
            (!ctxt->node->last ||
            ((ctxt->node->last && (cur == '<' || ctxt->node->last->type != XML_TEXT_NODE))
           )))
        {
            /* Keep information about ignorable whitespace text node in previous or parent node */
            if (ctxt->node->last)
                *(DWORD*)&ctxt->node->last->_private |= NODE_PRIV_TRAILING_IGNORABLE_WS;
            else if (ctxt->node->type != XML_DOCUMENT_NODE)
                *(DWORD*)&ctxt->node->_private |= NODE_PRIV_CHILD_IGNORABLE_WS;
            return;
        }
    }
 
    xmlSAX2Characters(ctxt, ch, len);
}

Referenced by doparse().

sax_error()

static void LIBXML2_LOG_CALLBACK sax_error ( void *  ctx, char const *  msg,   ...  )

static

Definition at line 481 of file domdoc.c.

{
    va_list ap;
    va_start(ap, msg);
    LIBXML2_CALLBACK_ERR(doparse, msg, ap);
    va_end(ap);
}

Referenced by doparse().

sax_serror()

static void sax_serror ( void *  ctx, const xmlError *  err  )

static

Definition at line 497 of file domdoc.c.

{
    LIBXML2_CALLBACK_SERROR(doparse, err);
}

Referenced by doparse().

sax_warning()

static void LIBXML2_LOG_CALLBACK sax_warning ( void *  ctx, char const *  msg,   ...  )

static

Definition at line 489 of file domdoc.c.

{
    va_list ap;
    va_start(ap, msg);
    LIBXML2_CALLBACK_WARN(doparse, msg, ap);
    va_end(ap);
}

Referenced by doparse().

set_doc_event()

static HRESULT set_doc_event ( domdoc *  doc, eventid_t  eid, const VARIANT *  v  )

static

Definition at line 143 of file domdoc.c.

{
    IDispatch *disp;
 
    switch (V_VT(v))
    {
    case VT_UNKNOWN:
        if (V_UNKNOWN(v))
            IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, (void**)&disp);
        else
            disp = NULL;
        break;
    case VT_DISPATCH:
        disp = V_DISPATCH(v);
        if (disp) IDispatch_AddRef(disp);
        break;
    default:
        return DISP_E_TYPEMISMATCH;
    }
 
    if (doc->events[eid]) IDispatch_Release(doc->events[eid]);
    doc->events[eid] = disp;
 
    return S_OK;
}

Referenced by domdoc_put_onreadystatechange().

set_xpathmode()

void set_xpathmode	(	xmlDocPtr	doc,
		BOOL	xpath
	)

Definition at line 230 of file domdoc.c.

{
    properties_from_xmlDocPtr(doc)->XPath = xpath;
}

Referenced by domelem_getElementsByTagName().

strn_isspace()

static BOOL strn_isspace ( xmlChar const *  str, int  len  )

inlinestatic

Definition at line 429 of file domdoc.c.

{
    for (; str && len > 0 && *str; ++str, --len)
        if (!isspace(*str))
            break;
 
    return len == 0;
}

Referenced by sax_characters().

tagName_to_XPath()

xmlChar * tagName_to_XPath

(

const BSTR

tagName

)

Definition at line 1955 of file domdoc.c.

{
    xmlChar *query, *tmp;
    static const xmlChar everything[] = "/descendant::node()";
    static const xmlChar mod_pre[] = "*[local-name()='";
    static const xmlChar mod_post[] = "']";
    static const xmlChar prefix[] = "descendant::";
    const WCHAR *tokBegin, *tokEnd;
    int len;
 
    /* Special case - empty tagname - means select all nodes,
       except document itself. */
    if (!*tagName)
        return xmlStrdup(everything);
 
    query = xmlStrdup(prefix);
 
    tokBegin = tagName;
    while (tokBegin && *tokBegin)
    {
        switch (*tokBegin)
        {
        case '/':
            query = xmlStrcat(query, BAD_CAST "/");
            ++tokBegin;
            break;
        case '*':
            query = xmlStrcat(query, BAD_CAST "*");
            ++tokBegin;
            break;
        default:
            query = xmlStrcat(query, mod_pre);
            tokEnd = tokBegin;
            while (*tokEnd && *tokEnd != '/')
                ++tokEnd;
            len = WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, NULL, 0, NULL, NULL);
            tmp = xmlMalloc(len);
            WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, (char*)tmp, len, NULL, NULL);
            query = xmlStrncat(query, tmp, len);
            xmlFree(tmp);
            tokBegin = tokEnd;
            query = xmlStrcat(query, mod_post);
        }
    }
 
    return query;
}

Referenced by domdoc_getElementsByTagName(), and domelem_getElementsByTagName().

validate_error()

static void LIBXML2_LOG_CALLBACK validate_error ( void *  ctx, char const *  msg,   ...  )

static

Definition at line 2896 of file domdoc.c.

{
    va_list ap;
    va_start(ap, msg);
    LIBXML2_CALLBACK_ERR(domdoc_validateNode, msg, ap);
    va_end(ap);
}

Referenced by domdoc_validateNode().

validate_warning()

static void LIBXML2_LOG_CALLBACK validate_warning ( void *  ctx, char const *  msg,   ...  )

static

Definition at line 2904 of file domdoc.c.

{
    va_list ap;
    va_start(ap, msg);
    LIBXML2_CALLBACK_WARN(domdoc_validateNode, msg, ap);
    va_end(ap);
}

Referenced by domdoc_validateNode().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msxml

)

xmldoc_add_orphan()

HRESULT xmldoc_add_orphan	(	xmlDocPtr	doc,
		xmlNodePtr	node
	)

Definition at line 658 of file domdoc.c.

{
    xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
    orphan_entry *entry;
 
    entry = malloc(sizeof(*entry));
    if(!entry)
        return E_OUTOFMEMORY;
 
    entry->node = node;
    list_add_head( &priv->orphans, &entry->entry );
    return S_OK;
}

Referenced by domdoc_cloneNode(), domdoc_createNode(), domdoc_put_documentElement(), domelem_remove_qualified_item(), node_clone(), node_remove_child(), and node_replace_child().

xmldoc_add_ref()

LONG xmldoc_add_ref

(

xmlDocPtr

doc

)

Definition at line 619 of file domdoc.c.

{
    return xmldoc_add_refs(doc, 1);
}

Referenced by attach_xmldoc(), cache_entry_from_xdr_doc(), cache_entry_from_xsd_doc(), create_children_nodelist(), create_nodemap(), create_selection(), domdoc_cloneNode(), and init_xmlnode().

xmldoc_add_refs()

LONG xmldoc_add_refs	(	xmlDocPtr	doc,
		LONG	refs
	)

Definition at line 612 of file domdoc.c.

{
    LONG ref = InterlockedExchangeAdd(&priv_from_xmlDocPtr(doc)->refs, refs) + refs;
    TRACE("%p, refcount %ld.\n", doc, ref);
    return ref;
}

Referenced by domdoc_put_documentElement(), node_insert_before(), node_replace_child(), and xmldoc_add_ref().

xmldoc_encoding()

static char * xmldoc_encoding ( IXMLDOMDocument3 *  doc )

static

Definition at line 2552 of file domdoc.c.

{
    HRESULT hr;
    IXMLDOMNode *node;
    char *encoding = NULL;
 
    hr = IXMLDOMDocument3_get_firstChild(doc, &node);
    if (hr == S_OK)
    {
        DOMNodeType type;
 
        hr = IXMLDOMNode_get_nodeType(node, &type);
        if (hr == S_OK && type == NODE_PROCESSING_INSTRUCTION)
        {
            IXMLDOMProcessingInstruction *pi;
            IXMLDOMNode *item;
            IXMLDOMNamedNodeMap *node_map;
 
            hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void **)&pi);
            if (hr == S_OK)
            {
                hr = IXMLDOMNode_get_attributes(node, &node_map);
                if (hr == S_OK)
                {
                    static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0};
                    BSTR bstr;
 
                    bstr = SysAllocString(encodingW);
                    hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, bstr, &item);
                    SysFreeString(bstr);
                    if (hr == S_OK)
                    {
                        VARIANT var;
 
                        hr = IXMLDOMNode_get_nodeValue(item, &var);
                        if (hr == S_OK)
                        {
                            if (V_VT(&var) == VT_BSTR)
                                encoding = (char *)xmlchar_from_wchar(V_BSTR(&var));
 
                            VariantClear(&var);
                        }
                    }
 
                    IXMLDOMNamedNodeMap_Release(node_map);
                }
 
                IXMLDOMProcessingInstruction_Release(pi);
            }
        }
 
        IXMLDOMNode_Release(node);
    }
 
    if (!encoding && (encoding = malloc(sizeof("UTF-8"))))
        strcpy(encoding, "UTF-8");
 
    return encoding;
}

Referenced by domdoc_save().

xmldoc_init()

void xmldoc_init	(	xmlDocPtr	doc,
		MSXML_VERSION	version
	)

Definition at line 606 of file domdoc.c.

{
    doc->_private = create_priv();
    priv_from_xmlDocPtr(doc)->properties = create_properties(version);
}

Referenced by cache_entry_from_xdr_doc(), cache_entry_from_xsd_doc(), and dom_document_create().

xmldoc_link_xmldecl()

void xmldoc_link_xmldecl	(	xmlDocPtr	doc,
		xmlNodePtr	node
	)

Definition at line 386 of file domdoc.c.

{
    assert(doc != NULL);
    if (doc->standalone != -1) xmlAddPrevSibling( doc->children, node );
}

Referenced by doparse(), and node_get_xml().

xmldoc_release()

LONG xmldoc_release

(

xmlDocPtr

doc

)

Definition at line 653 of file domdoc.c.

{
    return xmldoc_release_refs(doc, 1);
}

Referenced by attach_xmldoc(), cache_entry_release(), destroy_xmlnode(), domdoc_cloneNode(), domselection_Release(), xmlnodelist_Release(), and xmlnodemap_Release().

xmldoc_release_refs()

LONG xmldoc_release_refs	(	xmlDocPtr	doc,
		LONG	refs
	)

Definition at line 624 of file domdoc.c.

{
    xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
    LONG ref = InterlockedExchangeAdd(&priv->refs, -refs) - refs;
 
    TRACE("%p, refcount %ld.\n", doc, ref);
 
    if (ref < 0)
        WARN("negative refcount, expect troubles\n");
 
    if (ref == 0)
    {
        orphan_entry *orphan, *orphan2;
        TRACE("freeing docptr %p\n", doc);
 
        LIST_FOR_EACH_ENTRY_SAFE( orphan, orphan2, &priv->orphans, orphan_entry, entry )
        {
            xmlFreeNode( orphan->node );
            free( orphan );
        }
        properties_release(priv->properties);
        free(doc->_private);
 
        xmlFreeDoc(doc);
    }
 
    return ref;
}

Referenced by domdoc_put_documentElement(), node_insert_before(), node_replace_child(), and xmldoc_release().

xmldoc_remove_orphan()

HRESULT xmldoc_remove_orphan	(	xmlDocPtr	doc,
		xmlNodePtr	node
	)

Definition at line 672 of file domdoc.c.

{
    xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
    orphan_entry *entry, *entry2;
 
    LIST_FOR_EACH_ENTRY_SAFE( entry, entry2, &priv->orphans, orphan_entry, entry )
    {
        if( entry->node == node )
        {
            list_remove( &entry->entry );
            free( entry );
            return S_OK;
        }
    }
 
    return S_FALSE;
}

Referenced by domdoc_put_documentElement(), domelem_set_named_item(), node_clone(), node_insert_before(), and node_replace_child().

xmldoc_unlink_xmldecl()

xmlNodePtr xmldoc_unlink_xmldecl

(

xmlDocPtr

doc

)

Definition at line 393 of file domdoc.c.

{
    static const xmlChar xmlA[] = "xml";
    xmlNodePtr node, first_child;
 
    assert(doc != NULL);
 
    /* xml declaration node could be created automatically after parsing or added
       to a tree later */
    first_child = doc->children;
    if (first_child && first_child->type == XML_PI_NODE && xmlStrEqual(first_child->name, xmlA))
    {
        node = first_child;
        xmlUnlinkNode( node );
    }
    else
        node = NULL;
 
    return node;
}

Referenced by node_get_xml().

xmldoc_version()

MSXML_VERSION xmldoc_version

(

xmlDocPtr

doc

)

Definition at line 414 of file domdoc.c.

{
    return properties_from_xmlDocPtr(doc)->version;
}

Referenced by domattr_get_namespaceURI(), domattr_get_prefix(), node_get_base_name(), and node_get_nodeName().

Variable Documentation

ConnectionPointContainerVtbl

const struct IConnectionPointContainerVtbl ConnectionPointContainerVtbl

static

Initial value:

=
{
    ConnectionPointContainer_QueryInterface,
    ConnectionPointContainer_AddRef,
    ConnectionPointContainer_Release,
    ConnectionPointContainer_EnumConnectionPoints,
    ConnectionPointContainer_FindConnectionPoint
}

Definition at line 3441 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().

ConnectionPointVtbl

const IConnectionPointVtbl ConnectionPointVtbl

static

Initial value:

=
{
    ConnectionPoint_QueryInterface,
    ConnectionPoint_AddRef,
    ConnectionPoint_Release,
    ConnectionPoint_GetConnectionInterface,
    ConnectionPoint_GetConnectionPointContainer,
    ConnectionPoint_Advise,
    ConnectionPoint_Unadvise,
    ConnectionPoint_EnumConnections
}

Definition at line 3576 of file domdoc.c.

Referenced by ConnectionPoint_Init().

domdoc_dispex

dispex_static_data_t domdoc_dispex

static

Initial value:

= {
    NULL,
    IXMLDOMDocument3_tid,
    NULL,
    domdoc_iface_tids
}

Definition at line 3742 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().

domdoc_iface_tids

const tid_t domdoc_iface_tids[]

static

Initial value:

= {
    IXMLDOMDocument3_tid,
    0
}

Definition at line 3737 of file domdoc.c.

domdoc_se_tids

const tid_t domdoc_se_tids[]

static

Initial value:

= {
    IXMLDOMNode_tid,
    IXMLDOMDocument_tid,
    IXMLDOMDocument2_tid,
    IXMLDOMDocument3_tid,
    NULL_tid
}

Definition at line 917 of file domdoc.c.

Referenced by domdoc_QueryInterface().

domdocObjectSafetyVtbl

const IObjectSafetyVtbl domdocObjectSafetyVtbl

static

Initial value:

= {
    domdoc_Safety_QueryInterface,
    domdoc_Safety_AddRef,
    domdoc_Safety_Release,
    domdoc_Safety_GetInterfaceSafetyOptions,
    domdoc_Safety_SetInterfaceSafetyOptions
}

Definition at line 3729 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().

domdocObjectSite

const IObjectWithSiteVtbl domdocObjectSite

static

Initial value:

=
{
    domdoc_ObjectWithSite_QueryInterface,
    domdoc_ObjectWithSite_AddRef,
    domdoc_ObjectWithSite_Release,
    domdoc_ObjectWithSite_SetSite,
    domdoc_ObjectWithSite_GetSite
}

Definition at line 3668 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().

PropertyAllowDocumentFunctionW

const WCHAR PropertyAllowDocumentFunctionW[] = {'A','l','l','o','w','D','o','c','u','m','e','n','t','F','u','n','c','t','i','o','n',0}

static

Definition at line 60 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyAllowXsltScriptW

const WCHAR PropertyAllowXsltScriptW[] = {'A','l','l','o','w','X','s','l','t','S','c','r','i','p','t',0}

static

Definition at line 59 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyMaxElementDepth

const WCHAR PropertyMaxElementDepth[] = L"MaxElementDepth"

static

Definition at line 63 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyNewParserW

const WCHAR PropertyNewParserW[] = {'N','e','w','P','a','r','s','e','r',0}

static

Definition at line 55 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyNormalizeAttributeValuesW

const WCHAR PropertyNormalizeAttributeValuesW[] = {'N','o','r','m','a','l','i','z','e','A','t','t','r','i','b','u','t','e','V','a','l','u','e','s',0}

static

Definition at line 61 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyProhibitDTDW

const WCHAR PropertyProhibitDTDW[] = {'P','r','o','h','i','b','i','t','D','T','D',0}

static

Definition at line 54 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertyResolveExternalsW

const WCHAR PropertyResolveExternalsW[] = {'R','e','s','o','l','v','e','E','x','t','e','r','n','a','l','s',0}

static

Definition at line 58 of file domdoc.c.

Referenced by domdoc_setProperty().

PropertySelectionLanguageW

const WCHAR PropertySelectionLanguageW[] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0}

static

Definition at line 52 of file domdoc.c.

Referenced by domdoc_getProperty(), and domdoc_setProperty().

PropertySelectionNamespacesW

const WCHAR PropertySelectionNamespacesW[] = {'S','e','l','e','c','t','i','o','n','N','a','m','e','s','p','a','c','e','s',0}

static

Definition at line 53 of file domdoc.c.

Referenced by domdoc_getProperty(), and domdoc_setProperty().

PropertyValidateOnParse

const WCHAR PropertyValidateOnParse[] = L"ValidateOnParse"

static

Definition at line 62 of file domdoc.c.

Referenced by domdoc_getProperty(), and domdoc_setProperty().

PropValueXPathW

const WCHAR PropValueXPathW[] = {'X','P','a','t','h',0}

static

Definition at line 56 of file domdoc.c.

Referenced by domdoc_getProperty(), and domdoc_setProperty().

PropValueXSLPatternW

const WCHAR PropValueXSLPatternW[] = {'X','S','L','P','a','t','t','e','r','n',0}

static

Definition at line 57 of file domdoc.c.

Referenced by domdoc_getProperty(), and domdoc_setProperty().

xmldoc_IPersistStreamInit_VTable

const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable

static

Initial value:

=
{
    PersistStreamInit_QueryInterface,
    PersistStreamInit_AddRef,
    PersistStreamInit_Release,
    PersistStreamInit_GetClassID,
    PersistStreamInit_IsDirty,
    PersistStreamInit_Load,
    PersistStreamInit_Save,
    PersistStreamInit_GetSizeMax,
    PersistStreamInit_InitNew
}

Definition at line 902 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().

XMLDOMDocument3Vtbl

const struct IXMLDOMDocument3Vtbl XMLDOMDocument3Vtbl

static

Definition at line 3298 of file domdoc.c.

Referenced by get_domdoc_from_xmldoc().