schema.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <libxml/xmlerror.h>
#include <libxml/tree.h>
#include <libxml/xmlschemas.h>
#include <libxml/schemasInternals.h>
#include <libxml/hash.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlIO.h>
#include <libxml/xmlversion.h>
#include <libxml/xpath.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
#include "msxml6.h"
#include "wine/debug.h"
#include "msxml_private.h"

Include dependency graph for schema.c:

Go to the source code of this file.

Classes
struct	schema_cache
struct	cache_entry

Macros
#define	COBJMACROS
#define	DEFAULT_HASHTABLE_SIZE   17
#define	DT_MIN_STR_LEN   2
#define	DT_MAX_STR_LEN   11
#define	DT_MIN_HASH_VALUE   2
#define	DT_MAX_HASH_VALUE   115

Enumerations
enum	CacheEntryType { CacheEntryType_Invalid , CacheEntryType_XDR , CacheEntryType_XSD , CacheEntryType_NS }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msxml)
xmlDocPtr	XDR_to_XSD_doc (xmlDocPtr xdr_doc, xmlChar const *nsURI)
static void LIBXML2_LOG_CALLBACK	parser_error (void *ctx, char const *msg,...)
static void LIBXML2_LOG_CALLBACK	parser_warning (void *ctx, char const *msg,...)
static void	parser_serror (void *ctx, const xmlError *err)
static xmlSchemaPtr	Schema_parse (xmlSchemaParserCtxtPtr spctx)
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 void	validate_serror (void *ctx, const xmlError *err)
static HRESULT	schema_cache_get_item (IUnknown *iface, LONG index, VARIANT *item)
static HRESULT	Schema_validate_tree (xmlSchemaPtr schema, xmlNodePtr tree)
static DWORD	dt_hash (xmlChar const *str, int len)
static DWORD	dt_hash_bstr (OLECHAR const *bstr, int len)
XDR_DT	str_to_dt (xmlChar const *str, int len)
XDR_DT	bstr_to_dt (OLECHAR const *bstr, int len)
xmlChar const *	dt_to_str (XDR_DT dt)
OLECHAR const *	dt_to_bstr (XDR_DT dt)
const char *	debugstr_dt (XDR_DT dt)
HRESULT	dt_validate (XDR_DT dt, xmlChar const *content)
static xmlChar const *	get_node_nsURI (xmlNodePtr node)
static cache_entry *	get_entry (schema_cache *This, xmlChar const *nsURI)
static xmlSchemaPtr	get_node_schema (schema_cache *This, xmlNodePtr node)
static xmlParserInputPtr	external_entity_loader (const char *URL, const char *ID, xmlParserCtxtPtr ctxt)
void	schemasInit (void)
void	schemasCleanup (void)
static LONG	cache_entry_add_ref (cache_entry *entry)
static LONG	cache_entry_release (cache_entry *entry)
static schema_cache *	impl_from_IXMLDOMSchemaCollection2 (IXMLDOMSchemaCollection2 *iface)
static schema_cache *	impl_from_IXMLDOMSchemaCollection (IXMLDOMSchemaCollection *iface)
static schema_cache *	unsafe_impl_from_IXMLDOMSchemaCollection (IXMLDOMSchemaCollection *iface)
static CacheEntryType	cache_type_from_xmlDocPtr (xmlDocPtr schema)
static BOOL	link_datatypes (xmlDocPtr schema)
static cache_entry *	cache_entry_from_xsd_doc (xmlDocPtr doc, xmlChar const *nsURI, MSXML_VERSION v)
static cache_entry *	cache_entry_from_xdr_doc (xmlDocPtr doc, xmlChar const *nsURI, MSXML_VERSION version)
static cache_entry *	cache_entry_from_url (VARIANT url, xmlChar const *nsURI, MSXML_VERSION version)
static void	cache_free (void *data, const xmlChar *name)
static int	cache_free_uri (schema_cache *cache, const xmlChar *uri)
static void	cache_add_entry (schema_cache *cache, const xmlChar *uri, cache_entry *entry)
static void	cache_remove_entry (schema_cache *cache, const xmlChar *uri)
HRESULT	cache_from_doc_ns (IXMLDOMSchemaCollection2 *iface, xmlnode *node)
static HRESULT WINAPI	schema_cache_QueryInterface (IXMLDOMSchemaCollection2 *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	schema_cache_AddRef (IXMLDOMSchemaCollection2 *iface)
static ULONG WINAPI	schema_cache_Release (IXMLDOMSchemaCollection2 *iface)
static HRESULT WINAPI	schema_cache_GetTypeInfoCount (IXMLDOMSchemaCollection2 *iface, UINT *pctinfo)
static HRESULT WINAPI	schema_cache_GetTypeInfo (IXMLDOMSchemaCollection2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	schema_cache_GetIDsOfNames (IXMLDOMSchemaCollection2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	schema_cache_Invoke (IXMLDOMSchemaCollection2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	schema_cache_add (IXMLDOMSchemaCollection2 *iface, BSTR uri, VARIANT var)
static HRESULT WINAPI	schema_cache_get (IXMLDOMSchemaCollection2 *iface, BSTR uri, IXMLDOMNode **node)
static HRESULT WINAPI	schema_cache_remove (IXMLDOMSchemaCollection2 *iface, BSTR uri)
static HRESULT WINAPI	schema_cache_get_length (IXMLDOMSchemaCollection2 *iface, LONG *length)
static HRESULT WINAPI	schema_cache_get_namespaceURI (IXMLDOMSchemaCollection2 *iface, LONG index, BSTR *uri)
static void	cache_copy (void *data, void *dest, const xmlChar *name)
static HRESULT WINAPI	schema_cache_addCollection (IXMLDOMSchemaCollection2 *iface, IXMLDOMSchemaCollection *collection)
static HRESULT WINAPI	schema_cache_get__newEnum (IXMLDOMSchemaCollection2 *iface, IUnknown **enumv)
static HRESULT WINAPI	schema_cache_validate (IXMLDOMSchemaCollection2 *iface)
static HRESULT WINAPI	schema_cache_put_validateOnLoad (IXMLDOMSchemaCollection2 *iface, VARIANT_BOOL value)
static HRESULT WINAPI	schema_cache_get_validateOnLoad (IXMLDOMSchemaCollection2 *iface, VARIANT_BOOL *value)
static HRESULT WINAPI	schema_cache_getSchema (IXMLDOMSchemaCollection2 *iface, BSTR namespaceURI, ISchema **schema)
static HRESULT WINAPI	schema_cache_getDeclaration (IXMLDOMSchemaCollection2 *iface, IXMLDOMNode *node, ISchemaItem **item)
static xmlSchemaElementPtr	lookup_schema_elemDecl (xmlSchemaPtr schema, xmlNodePtr node)
static xmlNodePtr	lookup_schema_element (xmlSchemaPtr schema, xmlNodePtr node)
HRESULT	SchemaCache_validate_tree (IXMLDOMSchemaCollection2 *iface, xmlNodePtr tree)
XDR_DT	SchemaCache_get_node_dt (IXMLDOMSchemaCollection2 *iface, xmlNodePtr node)
HRESULT	SchemaCache_create (MSXML_VERSION version, void **obj)

Variables
static const xmlChar	XSD_schema [] = "schema"
static const xmlChar	XSD_nsURI [] = "http://www.w3.org/2001/XMLSchema"
static const xmlChar	XDR_schema [] = "Schema"
static const xmlChar	XDR_nsURI [] = "urn:schemas-microsoft-com:xml-data"
static const xmlChar	DT_nsURI [] = "urn:schemas-microsoft-com:datatypes"
static xmlChar *	datatypes_src
static int	datatypes_len
static HGLOBAL	datatypes_handle
static HRSRC	datatypes_rsrc
static xmlSchemaPtr	datatypes_schema
static const WCHAR	emptyW [] = {0}
static const tid_t	schema_cache_se_tids []
static const xmlChar	DT_bin_base64 [] = "bin.base64"
static const xmlChar	DT_bin_hex [] = "bin.hex"
static const xmlChar	DT_boolean [] = "boolean"
static const xmlChar	DT_char [] = "char"
static const xmlChar	DT_date [] = "date"
static const xmlChar	DT_date_tz [] = "date.tz"
static const xmlChar	DT_dateTime [] = "dateTime"
static const xmlChar	DT_dateTime_tz [] = "dateTime.tz"
static const xmlChar	DT_entity [] = "entity"
static const xmlChar	DT_entities [] = "entities"
static const xmlChar	DT_enumeration [] = "enumeration"
static const xmlChar	DT_fixed_14_4 [] = "fixed.14.4"
static const xmlChar	DT_float [] = "float"
static const xmlChar	DT_i1 [] = "i1"
static const xmlChar	DT_i2 [] = "i2"
static const xmlChar	DT_i4 [] = "i4"
static const xmlChar	DT_i8 [] = "i8"
static const xmlChar	DT_id [] = "id"
static const xmlChar	DT_idref [] = "idref"
static const xmlChar	DT_idrefs [] = "idrefs"
static const xmlChar	DT_int [] = "int"
static const xmlChar	DT_nmtoken [] = "nmtoken"
static const xmlChar	DT_nmtokens [] = "nmtokens"
static const xmlChar	DT_notation [] = "notation"
static const xmlChar	DT_number [] = "number"
static const xmlChar	DT_r4 [] = "r4"
static const xmlChar	DT_r8 [] = "r8"
static const xmlChar	DT_string [] = "string"
static const xmlChar	DT_time [] = "time"
static const xmlChar	DT_time_tz [] = "time.tz"
static const xmlChar	DT_ui1 [] = "ui1"
static const xmlChar	DT_ui2 [] = "ui2"
static const xmlChar	DT_ui4 [] = "ui4"
static const xmlChar	DT_ui8 [] = "ui8"
static const xmlChar	DT_uri [] = "uri"
static const xmlChar	DT_uuid [] = "uuid"
static const OLECHAR	wDT_bin_base64 [] = {'b','i','n','.','b','a','s','e','6','4',0}
static const OLECHAR	wDT_bin_hex [] = {'b','i','n','.','h','e','x',0}
static const OLECHAR	wDT_boolean [] = {'b','o','o','l','e','a','n',0}
static const OLECHAR	wDT_char [] = {'c','h','a','r',0}
static const OLECHAR	wDT_date [] = {'d','a','t','e',0}
static const OLECHAR	wDT_date_tz [] = {'d','a','t','e','.','t','z',0}
static const OLECHAR	wDT_dateTime [] = {'d','a','t','e','T','i','m','e',0}
static const OLECHAR	wDT_dateTime_tz [] = {'d','a','t','e','T','i','m','e','.','t','z',0}
static const OLECHAR	wDT_entity [] = {'e','n','t','i','t','y',0}
static const OLECHAR	wDT_entities [] = {'e','n','t','i','t','i','e','s',0}
static const OLECHAR	wDT_enumeration [] = {'e','n','u','m','e','r','a','t','i','o','n',0}
static const OLECHAR	wDT_fixed_14_4 [] = {'f','i','x','e','d','.','1','4','.','4',0}
static const OLECHAR	wDT_float [] = {'f','l','o','a','t',0}
static const OLECHAR	wDT_i1 [] = {'i','1',0}
static const OLECHAR	wDT_i2 [] = {'i','2',0}
static const OLECHAR	wDT_i4 [] = {'i','4',0}
static const OLECHAR	wDT_i8 [] = {'i','8',0}
static const OLECHAR	wDT_id [] = {'i','d',0}
static const OLECHAR	wDT_idref [] = {'i','d','r','e','f',0}
static const OLECHAR	wDT_idrefs [] = {'i','d','r','e','f','s',0}
static const OLECHAR	wDT_int [] = {'i','n','t',0}
static const OLECHAR	wDT_nmtoken [] = {'n','m','t','o','k','e','n',0}
static const OLECHAR	wDT_nmtokens [] = {'n','m','t','o','k','e','n','s',0}
static const OLECHAR	wDT_notation [] = {'n','o','t','a','t','i','o','n',0}
static const OLECHAR	wDT_number [] = {'n','u','m','b','e','r',0}
static const OLECHAR	wDT_r4 [] = {'r','4',0}
static const OLECHAR	wDT_r8 [] = {'r','8',0}
static const OLECHAR	wDT_string [] = {'s','t','r','i','n','g',0}
static const OLECHAR	wDT_time [] = {'t','i','m','e',0}
static const OLECHAR	wDT_time_tz [] = {'t','i','m','e','.','t','z',0}
static const OLECHAR	wDT_ui1 [] = {'u','i','1',0}
static const OLECHAR	wDT_ui2 [] = {'u','i','2',0}
static const OLECHAR	wDT_ui4 [] = {'u','i','4',0}
static const OLECHAR	wDT_ui8 [] = {'u','i','8',0}
static const OLECHAR	wDT_uri [] = {'u','r','i',0}
static const OLECHAR	wDT_uuid [] = {'u','u','i','d',0}
static const BYTE	hash_assoc_values []
static const struct enumvariant_funcs	schemacache_enumvariant
static const xmlChar *const	DT_string_table [LAST_DT]
static const WCHAR *const	DT_wstring_table [LAST_DT]
static const XDR_DT	DT_lookup_table []
static xmlExternalEntityLoader	_external_entity_loader
static const struct IXMLDOMSchemaCollection2Vtbl	XMLDOMSchemaCollection2Vtbl
static const tid_t	schemacache_iface_tids []
static dispex_static_data_t	schemacache_dispex

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file schema.c.

DEFAULT_HASHTABLE_SIZE

#define DEFAULT_HASHTABLE_SIZE   17

Definition at line 55 of file schema.c.

DT_MAX_HASH_VALUE

#define DT_MAX_HASH_VALUE   115

Definition at line 124 of file schema.c.

DT_MAX_STR_LEN

#define DT_MAX_STR_LEN   11

Definition at line 122 of file schema.c.

DT_MIN_HASH_VALUE

#define DT_MIN_HASH_VALUE   2

Definition at line 123 of file schema.c.

DT_MIN_STR_LEN

#define DT_MIN_STR_LEN   2

Definition at line 121 of file schema.c.

Enumeration Type Documentation

CacheEntryType

enum CacheEntryType

Enumerator
CacheEntryType_Invalid
CacheEntryType_XDR
CacheEntryType_XSD
CacheEntryType_NS

Definition at line 82 of file schema.c.

              {
    CacheEntryType_Invalid,
    CacheEntryType_XDR,
    CacheEntryType_XSD,
    CacheEntryType_NS
} CacheEntryType;

Function Documentation

bstr_to_dt()

XDR_DT bstr_to_dt	(	OLECHAR const *	bstr,
		int	len
	)

Definition at line 555 of file schema.c.

{
    DWORD hash = dt_hash_bstr(bstr, len);
    XDR_DT dt = DT_INVALID;
 
    if (hash <= DT_MAX_HASH_VALUE)
        dt = DT_lookup_table[hash];
 
    if (dt != DT_INVALID && lstrcmpiW(bstr, DT_wstring_table[dt]) == 0)
        return dt;
 
    return DT_INVALID;
}

Referenced by domelem_put_dataType().

cache_add_entry()

static void cache_add_entry ( schema_cache *  cache, const xmlChar *  uri, cache_entry *  entry  )

static

Definition at line 988 of file schema.c.

{
    int i;
 
    /* meaning no entry found with this name */
    if (xmlHashRemoveEntry(cache->cache, uri, cache_free))
    {
        if (cache->count == cache->allocated)
        {
            cache->allocated *= 2;
            cache->uris = realloc(cache->uris, cache->allocated * sizeof(xmlChar*));
        }
        i = cache->count++;
    }
    else
        i = cache_free_uri(cache, uri);
 
    cache->uris[i] = strdupxmlChar(uri);
    xmlHashAddEntry(cache->cache, uri, entry);
}

Referenced by cache_copy(), cache_from_doc_ns(), and schema_cache_add().

cache_copy()

static void cache_copy ( void *  data, void *  dest, const xmlChar *  name  )

static

Definition at line 1385 of file schema.c.

{
    schema_cache* This = (schema_cache*) dest;
    cache_entry* entry = (cache_entry*) data;
 
    if (xmlHashLookup(This->cache, name) == NULL)
    {
        cache_entry_add_ref(entry);
        cache_add_entry(This, name, entry);
    }
}

Referenced by schema_cache_addCollection().

cache_entry_add_ref()

static LONG cache_entry_add_ref ( cache_entry *  entry )

static

Definition at line 755 of file schema.c.

{
    LONG ref = InterlockedIncrement(&entry->ref);
    TRACE("%p, refcount %ld.\n", entry, ref);
    return ref;
}

Referenced by cache_copy(), and schema_cache_add().

cache_entry_from_url()

static cache_entry * cache_entry_from_url ( VARIANT  url, xmlChar const *  nsURI, MSXML_VERSION  version  )

static

Definition at line 919 of file schema.c.

{
    cache_entry* entry;
    IXMLDOMDocument3* domdoc = NULL;
    xmlDocPtr doc = NULL;
    HRESULT hr = dom_document_create(version, (void **)&domdoc);
    VARIANT_BOOL b = VARIANT_FALSE;
    CacheEntryType type = CacheEntryType_Invalid;
 
    if (hr != S_OK)
    {
        FIXME("failed to create domdoc\n");
        return NULL;
    }
    assert(domdoc != NULL);
    assert(V_VT(&url) == VT_BSTR);
 
    hr = IXMLDOMDocument3_load(domdoc, url, &b);
    if (hr != S_OK)
    {
        ERR("load() returned %#lx.\n", hr);
        if (b != VARIANT_TRUE)
        {
            FIXME("Failed to load doc at %s\n", debugstr_w(V_BSTR(&url)));
            IXMLDOMDocument3_Release(domdoc);
            return NULL;
        }
    }
    doc = xmlNodePtr_from_domnode((IXMLDOMNode*)domdoc, XML_DOCUMENT_NODE)->doc;
    type = cache_type_from_xmlDocPtr(doc);
 
    switch (type)
    {
        case CacheEntryType_XSD:
            entry = cache_entry_from_xsd_doc(doc, nsURI, version);
            break;
        case CacheEntryType_XDR:
            entry = cache_entry_from_xdr_doc(doc, nsURI, version);
            break;
        default:
            entry = NULL;
            FIXME("invalid schema\n");
            break;
    }
    IXMLDOMDocument3_Release(domdoc);
 
    return entry;
}

Referenced by schema_cache_add().

cache_entry_from_xdr_doc()

static cache_entry * cache_entry_from_xdr_doc ( xmlDocPtr  doc, xmlChar const *  nsURI, MSXML_VERSION  version  )

static

Definition at line 886 of file schema.c.

{
    cache_entry* entry = malloc(sizeof(cache_entry));
    xmlSchemaParserCtxtPtr spctx;
    xmlDocPtr new_doc = xmlCopyDoc(doc, 1), xsd_doc = XDR_to_XSD_doc(doc, nsURI);
 
    link_datatypes(xsd_doc);
 
    entry->type = CacheEntryType_XDR;
    entry->ref = 0;
    spctx = xmlSchemaNewDocParserCtxt(xsd_doc);
 
    if ((entry->schema = Schema_parse(spctx)))
    {
        entry->doc = new_doc;
        xmldoc_init(entry->schema->doc, version);
        xmldoc_init(entry->doc, version);
        xmldoc_add_ref(entry->doc);
        xmldoc_add_ref(entry->schema->doc);
    }
    else
    {
        FIXME("failed to parse doc\n");
        xmlFreeDoc(new_doc);
        xmlFreeDoc(xsd_doc);
        free(entry);
        entry = NULL;
    }
    xmlSchemaFreeParserCtxt(spctx);
 
    return entry;
}

Referenced by cache_entry_from_url(), and schema_cache_add().

cache_entry_from_xsd_doc()

static cache_entry * cache_entry_from_xsd_doc ( xmlDocPtr  doc, xmlChar const *  nsURI, MSXML_VERSION  v  )

static

Definition at line 855 of file schema.c.

{
    cache_entry* entry = malloc(sizeof(cache_entry));
    xmlSchemaParserCtxtPtr spctx;
    xmlDocPtr new_doc = xmlCopyDoc(doc, 1);
 
    link_datatypes(new_doc);
 
    /* TODO: if the nsURI is different from the default xmlns or targetNamespace,
     *       do we need to do something special here? */
    entry->type = CacheEntryType_XSD;
    entry->ref = 0;
    spctx = xmlSchemaNewDocParserCtxt(new_doc);
 
    if ((entry->schema = Schema_parse(spctx)))
    {
        xmldoc_init(entry->schema->doc, v);
        entry->doc = entry->schema->doc;
        xmldoc_add_ref(entry->doc);
    }
    else
    {
        FIXME("failed to parse doc\n");
        xmlFreeDoc(new_doc);
        free(entry);
        entry = NULL;
    }
    xmlSchemaFreeParserCtxt(spctx);
    return entry;
}

Referenced by cache_entry_from_url(), and schema_cache_add().

cache_entry_release()

static LONG cache_entry_release ( cache_entry *  entry )

static

Definition at line 762 of file schema.c.

{
    LONG ref = InterlockedDecrement(&entry->ref);
    TRACE("%p, refcount %ld.\n", entry, ref);
 
    if (ref == 0)
    {
        if (entry->type == CacheEntryType_XSD)
        {
            xmldoc_release(entry->doc);
            entry->schema->doc = NULL;
            xmlSchemaFree(entry->schema);
        }
        else if (entry->type == CacheEntryType_XDR)
        {
            xmldoc_release(entry->doc);
            xmldoc_release(entry->schema->doc);
            entry->schema->doc = NULL;
            xmlSchemaFree(entry->schema);
        }
 
        free(entry);
    }
    return ref;
}

Referenced by cache_free().

cache_free()

static void cache_free ( void *  data, const xmlChar *  name  )

static

Definition at line 968 of file schema.c.

{
    cache_entry_release((cache_entry*)data);
}

Referenced by cache_add_entry(), cache_remove_entry(), and schema_cache_Release().

cache_free_uri()

static int cache_free_uri ( schema_cache *  cache, const xmlChar *  uri  )

static

Definition at line 974 of file schema.c.

{
    int i;
 
    for (i = 0; i < cache->count; i++)
        if (xmlStrEqual(cache->uris[i], uri))
        {
            free(cache->uris[i]);
            return i;
        }
 
    return -1;
}

Referenced by cache_add_entry(), and cache_remove_entry().

cache_from_doc_ns()

HRESULT cache_from_doc_ns	(	IXMLDOMSchemaCollection2 *	iface,
		xmlnode *	node
	)

Definition at line 1028 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    static const xmlChar query[] = "//*/namespace::*";
    xmlXPathObjectPtr nodeset;
    xmlXPathContextPtr ctxt;
 
    This->read_only = 1;
 
    ctxt = xmlXPathNewContext(node->node->doc);
 
    nodeset = xmlXPathEvalExpression(query, ctxt);
    xmlXPathFreeContext(ctxt);
 
    if (nodeset)
    {
        int pos = 0, len = xmlXPathNodeSetGetLength(nodeset->nodesetval);
 
        while (pos < len)
        {
            xmlNodePtr node = xmlXPathNodeSetItem(nodeset->nodesetval, pos);
            if (node->type == XML_NAMESPACE_DECL)
            {
                static const xmlChar defns[] = "http://www.w3.org/XML/1998/namespace";
                xmlNsPtr ns = (xmlNsPtr)node;
                cache_entry *entry;
 
                /* filter out default uri */
                if (xmlStrEqual(ns->href, defns))
                {
                    pos++;
                    continue;
                }
 
                entry = malloc(sizeof(cache_entry));
                entry->type = CacheEntryType_NS;
                entry->ref = 1;
                entry->schema = NULL;
                entry->doc = NULL;
 
                cache_add_entry(This, ns->href, entry);
            }
            pos++;
        }
 
        xmlXPathFreeObject(nodeset);
    }
 
    return S_OK;
}

Referenced by domdoc_get_namespaces().

cache_remove_entry()

static void cache_remove_entry ( schema_cache *  cache, const xmlChar *  uri  )

static

Definition at line 1009 of file schema.c.

{
    /* adjust index if entry was really removed */
    if (xmlHashRemoveEntry(cache->cache, uri, cache_free) == 0)
    {
        int i = cache_free_uri(cache, uri);
        if (i == -1) return;
        /* shift array */
        if (i != --cache->count)
            memmove(&cache->uris[i], &cache->uris[i+1], (cache->count-i)*sizeof(xmlChar*));
    }
}

Referenced by schema_cache_add(), and schema_cache_remove().

cache_type_from_xmlDocPtr()

static CacheEntryType cache_type_from_xmlDocPtr ( xmlDocPtr  schema )

inlinestatic

Definition at line 805 of file schema.c.

{
    xmlNodePtr root = NULL;
    if (schema)
        root = xmlDocGetRootElement(schema);
    if (root && root->ns)
    {
 
        if (xmlStrEqual(root->name, XDR_schema) &&
            xmlStrEqual(root->ns->href, XDR_nsURI))
        {
            return CacheEntryType_XDR;
        }
        else if (xmlStrEqual(root->name, XSD_schema) &&
                 xmlStrEqual(root->ns->href, XSD_nsURI))
        {
            return CacheEntryType_XSD;
        }
    }
    return CacheEntryType_Invalid;
}

Referenced by cache_entry_from_url(), and schema_cache_add().

debugstr_dt()

const char * debugstr_dt

(

XDR_DT

dt

)

Definition at line 585 of file schema.c.

{
    return debugstr_a(dt != DT_INVALID ? (const char*)DT_string_table[dt] : NULL);
}

Referenced by domelem_put_dataType(), domelem_put_nodeTypedValue(), dt_validate(), element_get_dt(), and variant_from_dt().

dt_hash()

static DWORD dt_hash ( xmlChar const *  str, int  len  )

static

Definition at line 313 of file schema.c.

{
    DWORD hval = (len == -1)? xmlStrlen(str) : len;
 
    switch (hval)
    {
        default:
            hval += hash_assoc_values[str[10]];
            /*FALLTHROUGH*/
        case 10:
            hval += hash_assoc_values[str[9]];
            /*FALLTHROUGH*/
        case 9:
            hval += hash_assoc_values[str[8]];
            /*FALLTHROUGH*/
        case 8:
            hval += hash_assoc_values[str[7]];
            /*FALLTHROUGH*/
        case 7:
            hval += hash_assoc_values[str[6]];
            /*FALLTHROUGH*/
        case 6:
            hval += hash_assoc_values[str[5]];
            /*FALLTHROUGH*/
        case 5:
            hval += hash_assoc_values[str[4]];
            /*FALLTHROUGH*/
        case 4:
            hval += hash_assoc_values[str[3]];
            /*FALLTHROUGH*/
        case 3:
            hval += hash_assoc_values[str[2]];
            /*FALLTHROUGH*/
        case 2:
            hval += hash_assoc_values[str[1]];
            /*FALLTHROUGH*/
        case 1:
            hval += hash_assoc_values[str[0]];
            break;
    }
    return hval;
}

Referenced by str_to_dt().

dt_hash_bstr()

static DWORD dt_hash_bstr ( OLECHAR const *  bstr, int  len  )

static

Definition at line 356 of file schema.c.

{
    DWORD hval = (len == -1)? lstrlenW(bstr) : len;
 
    switch (hval)
    {
        default:
            hval += (bstr[10] & 0xFF00)? 116 : hash_assoc_values[bstr[10]];
            /*FALLTHROUGH*/
        case 10:
            hval += (bstr[9] & 0xFF00)? 116 : hash_assoc_values[bstr[9]];
            /*FALLTHROUGH*/
        case 9:
            hval += (bstr[8] & 0xFF00)? 116 : hash_assoc_values[bstr[8]];
            /*FALLTHROUGH*/
        case 8:
            hval += (bstr[7] & 0xFF00)? 116 : hash_assoc_values[bstr[7]];
            /*FALLTHROUGH*/
        case 7:
            hval += (bstr[6] & 0xFF00)? 116 : hash_assoc_values[bstr[6]];
            /*FALLTHROUGH*/
        case 6:
            hval += (bstr[5] & 0xFF00)? 116 : hash_assoc_values[bstr[5]];
            /*FALLTHROUGH*/
        case 5:
            hval += (bstr[4] & 0xFF00)? 116 : hash_assoc_values[bstr[4]];
            /*FALLTHROUGH*/
        case 4:
            hval += (bstr[3] & 0xFF00)? 116 : hash_assoc_values[bstr[3]];
            /*FALLTHROUGH*/
        case 3:
            hval += (bstr[2] & 0xFF00)? 116 : hash_assoc_values[bstr[2]];
            /*FALLTHROUGH*/
        case 2:
            hval += (bstr[1] & 0xFF00)? 116 : hash_assoc_values[bstr[1]];
            /*FALLTHROUGH*/
        case 1:
            hval += (bstr[0] & 0xFF00)? 116 : hash_assoc_values[bstr[0]];
            break;
    }
    return hval;
}

Referenced by bstr_to_dt().

dt_to_bstr()

OLECHAR const * dt_to_bstr

(

XDR_DT

dt

)

Definition at line 577 of file schema.c.

{
    if (dt == DT_INVALID)
        return NULL;
 
    return DT_wstring_table[dt];
}

Referenced by domelem_get_dataType().

dt_to_str()

xmlChar const * dt_to_str

(

XDR_DT

dt

)

Definition at line 569 of file schema.c.

{
    if (dt == DT_INVALID)
        return NULL;
 
    return DT_string_table[dt];
}

Referenced by domelem_put_dataType(), and dt_validate().

dt_validate()

HRESULT dt_validate	(	XDR_DT	dt,
		xmlChar const *	content
	)

Definition at line 590 of file schema.c.

{
    xmlDocPtr tmp_doc;
    xmlNodePtr node;
    xmlNsPtr ns;
    HRESULT hr;
 
    TRACE("(dt:%s, %s)\n", debugstr_dt(dt), debugstr_a((char const*)content));
 
    if (!datatypes_schema)
    {
        xmlSchemaParserCtxtPtr spctx;
        assert(datatypes_src != NULL);
        spctx = xmlSchemaNewMemParserCtxt((char const*)datatypes_src, datatypes_len);
        datatypes_schema = Schema_parse(spctx);
        xmlSchemaFreeParserCtxt(spctx);
    }
 
    switch (dt)
    {
        case DT_INVALID:
            return E_FAIL;
        case DT_BIN_BASE64:
        case DT_BIN_HEX:
        case DT_BOOLEAN:
        case DT_CHAR:
        case DT_DATE:
        case DT_DATE_TZ:
        case DT_DATETIME:
        case DT_DATETIME_TZ:
        case DT_FIXED_14_4:
        case DT_FLOAT:
        case DT_I1:
        case DT_I2:
        case DT_I4:
        case DT_I8:
        case DT_INT:
        case DT_NMTOKEN:
        case DT_NMTOKENS:
        case DT_NUMBER:
        case DT_R4:
        case DT_R8:
        case DT_STRING:
        case DT_TIME:
        case DT_TIME_TZ:
        case DT_UI1:
        case DT_UI2:
        case DT_UI4:
        case DT_UI8:
        case DT_URI:
        case DT_UUID:
            if (!datatypes_schema)
            {
                ERR("failed to load schema for urn:schemas-microsoft-com:datatypes, "
                    "you're probably using an old version of libxml2: " LIBXML_DOTTED_VERSION "\n");
 
                /* Hopefully they don't need much in the way of XDR datatypes support... */
                return S_OK;
            }
 
            if (content && xmlStrlen(content))
            {
                tmp_doc = xmlNewDoc(NULL);
                node = xmlNewChild((xmlNodePtr)tmp_doc, NULL, dt_to_str(dt), content);
                ns = xmlNewNs(node, DT_nsURI, BAD_CAST "dt");
                xmlSetNs(node, ns);
                xmlDocSetRootElement(tmp_doc, node);
 
                hr = Schema_validate_tree(datatypes_schema, (xmlNodePtr)tmp_doc);
                xmlFreeDoc(tmp_doc);
            }
            else
            {   /* probably the node is being created manually and has no content yet */
                hr = S_OK;
            }
            return hr;
        default:
            FIXME("need to handle dt:%s\n", debugstr_dt(dt));
            return S_OK;
    }
}

Referenced by domelem_put_dataType().

external_entity_loader()

static xmlParserInputPtr external_entity_loader ( const char *  URL, const char *  ID, xmlParserCtxtPtr  ctxt  )

static

Definition at line 691 of file schema.c.

{
    xmlParserInputPtr input;
 
    TRACE("(%s %s %p)\n", debugstr_a(URL), debugstr_a(ID), ctxt);
 
    assert(MSXML_hInstance != NULL);
    assert(datatypes_rsrc != NULL);
    assert(datatypes_handle != NULL);
    assert(datatypes_src != NULL);
 
    /* TODO: if the desired schema is in the cache, load it from there */
    if (lstrcmpA(URL, "urn:schemas-microsoft-com:datatypes") == 0)
    {
        TRACE("loading built-in schema for %s\n", URL);
        input = xmlNewStringInputStream(ctxt, datatypes_src);
    }
    else
    {
        input = _external_entity_loader(URL, ID, ctxt);
    }
 
    return input;
}

Referenced by link_datatypes(), and schemasInit().

get_entry()

static cache_entry * get_entry ( schema_cache *  This, xmlChar const *  nsURI  )

inlinestatic

Definition at line 677 of file schema.c.

{
    return (!nsURI)? xmlHashLookup(This->cache, BAD_CAST "") :
                     xmlHashLookup(This->cache, nsURI);
}

Referenced by get_node_schema().

get_node_nsURI()

static xmlChar const * get_node_nsURI ( xmlNodePtr  node )

inlinestatic

Definition at line 672 of file schema.c.

{
    return (node->ns != NULL)? node->ns->href : NULL;
}

Referenced by get_node_schema(), lookup_schema_elemDecl(), and SchemaCache_validate_tree().

get_node_schema()

static xmlSchemaPtr get_node_schema ( schema_cache *  This, xmlNodePtr  node  )

inlinestatic

Definition at line 683 of file schema.c.

{
    cache_entry* entry = get_entry(This, get_node_nsURI(node));
    return (!entry)? NULL : entry->schema;
}

Referenced by SchemaCache_get_node_dt(), and SchemaCache_validate_tree().

impl_from_IXMLDOMSchemaCollection()

static schema_cache * impl_from_IXMLDOMSchemaCollection ( IXMLDOMSchemaCollection *  iface )

inlinestatic

Definition at line 795 of file schema.c.

{
    return CONTAINING_RECORD(iface, schema_cache, IXMLDOMSchemaCollection2_iface);
}

Referenced by unsafe_impl_from_IXMLDOMSchemaCollection().

impl_from_IXMLDOMSchemaCollection2()

static schema_cache * impl_from_IXMLDOMSchemaCollection2 ( IXMLDOMSchemaCollection2 *  iface )

inlinestatic

Definition at line 790 of file schema.c.

{
    return CONTAINING_RECORD(iface, schema_cache, IXMLDOMSchemaCollection2_iface);
}

Referenced by cache_from_doc_ns(), schema_cache_add(), schema_cache_addCollection(), schema_cache_AddRef(), schema_cache_get(), schema_cache_get__newEnum(), schema_cache_get_length(), schema_cache_get_namespaceURI(), schema_cache_get_validateOnLoad(), schema_cache_getDeclaration(), schema_cache_GetIDsOfNames(), schema_cache_getSchema(), schema_cache_GetTypeInfo(), schema_cache_GetTypeInfoCount(), schema_cache_Invoke(), schema_cache_put_validateOnLoad(), schema_cache_QueryInterface(), schema_cache_Release(), schema_cache_remove(), schema_cache_validate(), SchemaCache_get_node_dt(), and SchemaCache_validate_tree().

link_datatypes()

static BOOL link_datatypes ( xmlDocPtr  schema )

static

Definition at line 827 of file schema.c.

{
    xmlNodePtr root, next, child;
    xmlNsPtr ns;
 
    assert(xmlGetExternalEntityLoader() == external_entity_loader);
    root = xmlDocGetRootElement(schema);
    if (!root)
        return FALSE;
 
    for (ns = root->nsDef; ns != NULL; ns = ns->next)
    {
        if (xmlStrEqual(ns->href, DT_nsURI))
            break;
    }
 
    if (!ns)
        return FALSE;
 
    next = xmlFirstElementChild(root);
    child = xmlNewChild(root, NULL, BAD_CAST "import", NULL);
    if (next) child = xmlAddPrevSibling(next, child);
    xmlSetProp(child, BAD_CAST "namespace", DT_nsURI);
    xmlSetProp(child, BAD_CAST "schemaLocation", DT_nsURI);
 
    return TRUE;
}

Referenced by cache_entry_from_xdr_doc(), and cache_entry_from_xsd_doc().

lookup_schema_elemDecl()

static xmlSchemaElementPtr lookup_schema_elemDecl ( xmlSchemaPtr  schema, xmlNodePtr  node  )

static

Definition at line 1503 of file schema.c.

{
    xmlSchemaElementPtr decl = NULL;
    xmlChar const* nsURI = get_node_nsURI(node);
 
    TRACE("(%p, %p)\n", schema, node);
 
    if (xmlStrEqual(nsURI, schema->targetNamespace))
        decl = xmlHashLookup(schema->elemDecl, node->name);
 
    if (!decl && xmlHashSize(schema->schemasImports) > 1)
    {
        FIXME("declaration not found in main schema - need to check schema imports!\n");
        /*xmlSchemaImportPtr import;
        if (nsURI == NULL)
            import = xmlHashLookup(schema->schemasImports, XML_SCHEMAS_NO_NAMESPACE);
        else
            import = xmlHashLookup(schema->schemasImports, node->ns->href);
 
        if (import != NULL)
            decl = xmlHashLookup(import->schema->elemDecl, node->name);*/
    }
 
    return decl;
}

Referenced by lookup_schema_element().

lookup_schema_element()

static xmlNodePtr lookup_schema_element ( xmlSchemaPtr  schema, xmlNodePtr  node  )

inlinestatic

Definition at line 1529 of file schema.c.

{
    xmlSchemaElementPtr decl = lookup_schema_elemDecl(schema, node);
    while (decl != NULL && decl->refDecl != NULL)
        decl = decl->refDecl;
    return (decl != NULL)? decl->node : NULL;
}

Referenced by SchemaCache_get_node_dt().

parser_error()

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

static

Definition at line 230 of file schema.c.

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

Referenced by error_at(), and Schema_parse().

parser_serror()

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

static

Definition at line 246 of file schema.c.

{
    LIBXML2_CALLBACK_SERROR(Schema_parse, err);
}

Referenced by Schema_parse().

parser_warning()

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

static

Definition at line 238 of file schema.c.

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

Referenced by Schema_parse(), and warning_at().

schema_cache_add()

static HRESULT WINAPI schema_cache_add ( IXMLDOMSchemaCollection2 *  iface, BSTR  uri, VARIANT  var  )

static

Definition at line 1188 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    xmlChar* name;
 
    TRACE("(%p)->(%s %s)\n", This, debugstr_w(uri), debugstr_variant(&var));
 
    if (This->read_only) return E_FAIL;
 
    name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
 
    switch (V_VT(&var))
    {
        case VT_NULL:
            {
                cache_remove_entry(This, name);
            }
            break;
 
        case VT_BSTR:
            {
                cache_entry* entry = cache_entry_from_url(var, name, This->version);
 
                if (entry)
                {
                    cache_entry_add_ref(entry);
                }
                else
                {
                    free(name);
                    return E_FAIL;
                }
 
                cache_add_entry(This, name, entry);
            }
            break;
 
        case VT_DISPATCH:
        case VT_UNKNOWN:
            {
                xmlDocPtr doc = NULL;
                cache_entry* entry;
                CacheEntryType type;
                IXMLDOMNode* domnode = NULL;
                IUnknown_QueryInterface(V_UNKNOWN(&var), &IID_IXMLDOMNode, (void**)&domnode);
 
                if (domnode)
                {
                    DOMNodeType type;
 
                    IXMLDOMNode_get_nodeType(domnode, &type);
                    switch (type)
                    {
                    case NODE_ELEMENT:
                    {
                        IXMLDOMDocument *domdoc;
                        VARIANT_BOOL b;
                        BSTR xml;
 
                        IXMLDOMNode_get_xml(domnode, &xml);
                        dom_document_create(This->version, (void **)&domdoc);
                        IXMLDOMDocument_loadXML(domdoc, xml, &b);
                        SysFreeString(xml);
                        doc = xmlNodePtr_from_domnode((IXMLDOMNode*)domdoc, XML_DOCUMENT_NODE)->doc;
                        break;
                    }
                    default:
                        doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
                        break;
                    }
                }
 
                if (!doc)
                {
                    IXMLDOMNode_Release(domnode);
                    free(name);
                    return E_INVALIDARG;
                }
                type = cache_type_from_xmlDocPtr(doc);
 
                if (type == CacheEntryType_XSD)
                {
                    entry = cache_entry_from_xsd_doc(doc, name, This->version);
                }
                else if (type == CacheEntryType_XDR)
                {
                    entry = cache_entry_from_xdr_doc(doc, name, This->version);
                }
                else
                {
                    WARN("invalid schema!\n");
                    entry = NULL;
                }
 
                IXMLDOMNode_Release(domnode);
 
                if (entry)
                {
                    cache_entry_add_ref(entry);
                }
                else
                {
                    free(name);
                    return E_FAIL;
                }
 
                cache_add_entry(This, name, entry);
            }
            break;
 
        default:
            FIXME("arg type is not supported, %s\n", debugstr_variant(&var));
            free(name);
            return E_INVALIDARG;
    }
    free(name);
    return S_OK;
}

schema_cache_addCollection()

static HRESULT WINAPI schema_cache_addCollection ( IXMLDOMSchemaCollection2 *  iface, IXMLDOMSchemaCollection *  collection  )

static

Definition at line 1397 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    schema_cache* That;
 
    TRACE("(%p)->(%p)\n", This, collection);
 
    if (!collection)
        return E_POINTER;
 
    That = unsafe_impl_from_IXMLDOMSchemaCollection(collection);
    if (!That)
    {
        ERR("external collection implementation\n");
        return E_FAIL;
    }
 
    /* TODO: detect errors while copying & return E_FAIL */
    xmlHashScan(That->cache, cache_copy, This);
 
    return S_OK;
}

schema_cache_AddRef()

static ULONG WINAPI schema_cache_AddRef ( IXMLDOMSchemaCollection2 *  iface )

static

Definition at line 1125 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    LONG ref = InterlockedIncrement(&This->ref);
    TRACE("%p, refcount %ld.\n", iface, ref);
    return ref;
}

schema_cache_get()

static HRESULT WINAPI schema_cache_get ( IXMLDOMSchemaCollection2 *  iface, BSTR  uri, IXMLDOMNode **  node  )

static

Definition at line 1307 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    cache_entry* entry;
    xmlChar* name;
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_w(uri), node);
 
    if (This->version == MSXML6)
    {
        if (node) *node = NULL;
        return E_NOTIMPL;
    }
 
    if (!node)
        return E_POINTER;
 
    *node = NULL;
 
    name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
    entry = (cache_entry*) xmlHashLookup(This->cache, name);
    free(name);
 
    /* TODO: this should be read-only */
    if (entry && entry->doc)
        return get_domdoc_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node);
 
    return S_OK;
}

schema_cache_get__newEnum()

static HRESULT WINAPI schema_cache_get__newEnum ( IXMLDOMSchemaCollection2 *  iface, IUnknown **  enumv  )

static

Definition at line 1421 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    TRACE("(%p)->(%p)\n", This, enumv);
    return create_enumvariant((IUnknown*)iface, TRUE, &schemacache_enumvariant, (IEnumVARIANT**)enumv);
}

schema_cache_get_item()

static HRESULT schema_cache_get_item ( IUnknown *  iface, LONG  index, VARIANT *  item  )

static

Definition at line 281 of file schema.c.

{
    V_VT(item) = VT_BSTR;
    return IXMLDOMSchemaCollection2_get_namespaceURI((IXMLDOMSchemaCollection2*)iface, index, &V_BSTR(item));
}

schema_cache_get_length()

static HRESULT WINAPI schema_cache_get_length ( IXMLDOMSchemaCollection2 *  iface, LONG *  length  )

static

Definition at line 1353 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    TRACE("(%p)->(%p)\n", This, length);
 
    if (!length)
        return E_POINTER;
 
    *length = This->count;
    return S_OK;
}

schema_cache_get_namespaceURI()

static HRESULT WINAPI schema_cache_get_namespaceURI ( IXMLDOMSchemaCollection2 *  iface, LONG  index, BSTR *  uri  )

static

Definition at line 1365 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
 
    TRACE("%p, %ld, %p.\n", iface, index, uri);
 
    if (!uri)
        return E_POINTER;
 
    if (This->version == MSXML6)
        *uri = NULL;
 
    if (index >= This->count)
        return E_FAIL;
 
    *uri = bstr_from_xmlChar(This->uris[index]);
    return S_OK;
}

schema_cache_get_validateOnLoad()

static HRESULT WINAPI schema_cache_get_validateOnLoad ( IXMLDOMSchemaCollection2 *  iface, VARIANT_BOOL *  value  )

static

Definition at line 1448 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    TRACE("(%p)->(%p)\n", This, value);
 
    if (!value) return E_POINTER;
    *value = This->validateOnLoad;
 
    return S_OK;
}

schema_cache_getDeclaration()

static HRESULT WINAPI schema_cache_getDeclaration ( IXMLDOMSchemaCollection2 *  iface, IXMLDOMNode *  node, ISchemaItem **  item  )

static

Definition at line 1470 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    FIXME("(%p)->(%p %p): stub\n", This, node, item);
    if (item)
        *item = NULL;
    return E_NOTIMPL;
}

schema_cache_GetIDsOfNames()

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

static

Definition at line 1168 of file schema.c.

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

schema_cache_getSchema()

static HRESULT WINAPI schema_cache_getSchema ( IXMLDOMSchemaCollection2 *  iface, BSTR  namespaceURI, ISchema **  schema  )

static

Definition at line 1460 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(namespaceURI), schema);
    if (schema)
        *schema = NULL;
    return E_NOTIMPL;
}

schema_cache_GetTypeInfo()

static HRESULT WINAPI schema_cache_GetTypeInfo ( IXMLDOMSchemaCollection2 *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1160 of file schema.c.

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

schema_cache_GetTypeInfoCount()

static HRESULT WINAPI schema_cache_GetTypeInfoCount ( IXMLDOMSchemaCollection2 *  iface, UINT *  pctinfo  )

static

Definition at line 1153 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
}

schema_cache_Invoke()

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

static

Definition at line 1177 of file schema.c.

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

schema_cache_put_validateOnLoad()

static HRESULT WINAPI schema_cache_put_validateOnLoad ( IXMLDOMSchemaCollection2 *  iface, VARIANT_BOOL  value  )

static

Definition at line 1435 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    FIXME("(%p)->(%d): stub\n", This, value);
 
    This->validateOnLoad = value;
    /* it's ok to disable it, cause we don't validate on load anyway */
    if (value == VARIANT_FALSE) return S_OK;
 
    return E_NOTIMPL;
}

schema_cache_QueryInterface()

static HRESULT WINAPI schema_cache_QueryInterface ( IXMLDOMSchemaCollection2 *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1079 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 
    if ( IsEqualIID(riid, &IID_IUnknown) ||
         IsEqualIID(riid, &IID_IDispatch) ||
         IsEqualIID(riid, &IID_IXMLDOMSchemaCollection) ||
         IsEqualIID(riid, &IID_IXMLDOMSchemaCollection2) )
    {
        *ppvObject = iface;
    }
    else if(This->version == MSXML6 && IsEqualIID(riid, &CLSID_XMLSchemaCache60))
    {
        /*
         * Version 6 can be queried for an interface with IID equal to CLSID.
         * There is no public interface with that IID and returned pointer
         * is equal to returned IXMLDOMSchemaCollection2 iface. We assume
         * that it's just another way for querying IXMLDOMSchemaCollection2
         * interface. Office 2013 ClickToRun installer uses this.
         */
        WARN("riid CLSID_XMLSchemaCache60, returning IXMLDOMSchemaCollection2 interface.\n");
        *ppvObject = iface;
    }
    else if (dispex_query_interface(&This->dispex, riid, ppvObject))
    {
        return *ppvObject ? S_OK : E_NOINTERFACE;
    }
    else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
    {
        return node_create_supporterrorinfo(schema_cache_se_tids, ppvObject);
    }
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
 
    IXMLDOMSchemaCollection2_AddRef(iface);
 
    return S_OK;
}

schema_cache_Release()

static ULONG WINAPI schema_cache_Release ( IXMLDOMSchemaCollection2 *  iface )

static

Definition at line 1133 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    LONG ref = InterlockedDecrement(&This->ref);
    TRACE("%p, refcount %ld.\n", iface, ref);
 
    if (!ref)
    {
        int i;
 
        for (i = 0; i < This->count; i++)
            free(This->uris[i]);
        free(This->uris);
        xmlHashFree(This->cache, cache_free);
        free(This);
    }
 
    return ref;
}

schema_cache_remove()

static HRESULT WINAPI schema_cache_remove ( IXMLDOMSchemaCollection2 *  iface, BSTR  uri  )

static

Definition at line 1338 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    xmlChar* name;
 
    TRACE("(%p)->(%s)\n", This, debugstr_w(uri));
 
    if (This->version == MSXML6) return E_NOTIMPL;
 
    name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
    cache_remove_entry(This, name);
    free(name);
    return S_OK;
}

schema_cache_validate()

static HRESULT WINAPI schema_cache_validate ( IXMLDOMSchemaCollection2 *  iface )

static

Definition at line 1428 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    FIXME("(%p): stub\n", This);
    return E_NOTIMPL;
}

Schema_parse()

static xmlSchemaPtr Schema_parse ( xmlSchemaParserCtxtPtr  spctx )

inlinestatic

Definition at line 251 of file schema.c.

{
    TRACE("(%p)\n", spctx);
 
    xmlSchemaSetParserErrors(spctx, parser_error, parser_warning, NULL);
    xmlSchemaSetParserStructuredErrors(spctx, parser_serror, NULL);
    return xmlSchemaParse(spctx);
}

Referenced by cache_entry_from_xdr_doc(), cache_entry_from_xsd_doc(), dt_validate(), parser_error(), parser_serror(), and parser_warning().

Schema_validate_tree()

static HRESULT Schema_validate_tree ( xmlSchemaPtr  schema, xmlNodePtr  tree  )

inlinestatic

Definition at line 292 of file schema.c.

{
    xmlSchemaValidCtxtPtr svctx;
    int err;
 
    TRACE("(%p, %p)\n", schema, tree);
    /* TODO: if validateOnLoad property is false,
     *       we probably need to validate the schema here. */
    svctx = xmlSchemaNewValidCtxt(schema);
    xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL);
    xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL);
 
    if (tree->type == XML_DOCUMENT_NODE)
        err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree);
    else
        err = xmlSchemaValidateOneElement(svctx, tree);
 
    xmlSchemaFreeValidCtxt(svctx);
    return err? S_FALSE : S_OK;
}

Referenced by dt_validate(), SchemaCache_validate_tree(), validate_error(), validate_serror(), and validate_warning().

SchemaCache_create()

HRESULT SchemaCache_create	(	MSXML_VERSION	version,
		void **	obj
	)

Definition at line 1601 of file schema.c.

{
    schema_cache* This = malloc(sizeof(schema_cache));
    if (!This)
        return E_OUTOFMEMORY;
 
    TRACE("(%d %p)\n", version, obj);
 
    This->IXMLDOMSchemaCollection2_iface.lpVtbl = &XMLDOMSchemaCollection2Vtbl;
    This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE);
    This->allocated = 10;
    This->count = 0;
    This->uris = malloc(This->allocated * sizeof(xmlChar*));
    This->ref = 1;
    This->version = version;
    This->validateOnLoad = VARIANT_TRUE;
    This->read_only = 0;
    init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSchemaCollection2_iface, &schemacache_dispex);
 
    *obj = &This->IXMLDOMSchemaCollection2_iface;
    return S_OK;
}

Referenced by DllGetClassObject(), and domdoc_get_namespaces().

SchemaCache_get_node_dt()

XDR_DT SchemaCache_get_node_dt	(	IXMLDOMSchemaCollection2 *	iface,
		xmlNodePtr	node
	)

Definition at line 1561 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    xmlSchemaPtr schema = get_node_schema(This, node);
    XDR_DT dt = DT_INVALID;
 
    TRACE("(%p, %p)\n", This, node);
 
    if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
    {
        dt = str_to_dt(node->name, -1);
    }
    else if (schema)
    {
        xmlChar* str;
        xmlNodePtr schema_node = lookup_schema_element(schema, node);
 
        str = xmlGetNsProp(schema_node, BAD_CAST "dt", DT_nsURI);
        if (str)
        {
            dt = str_to_dt(str, -1);
            xmlFree(str);
        }
    }
 
    return dt;
}

Referenced by element_get_dt().

SchemaCache_validate_tree()

HRESULT SchemaCache_validate_tree	(	IXMLDOMSchemaCollection2 *	iface,
		xmlNodePtr	tree
	)

Definition at line 1537 of file schema.c.

{
    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
    xmlSchemaPtr schema;
 
    TRACE("(%p, %p)\n", This, tree);
 
    if (!tree)
        return E_POINTER;
 
    if (tree->type == XML_DOCUMENT_NODE)
        tree = xmlDocGetRootElement(tree->doc);
 
    schema = get_node_schema(This, tree);
    /* TODO: if the ns is not in the cache, and it's a URL,
     *       do we try to load from that? */
    if (schema)
        return Schema_validate_tree(schema, tree);
    else
        WARN("no schema found for xmlns=%s\n", get_node_nsURI(tree));
 
    return E_FAIL;
}

Referenced by domdoc_validateNode().

schemasCleanup()

void schemasCleanup

(

void

)

Definition at line 748 of file schema.c.

{
    xmlSchemaFree(datatypes_schema);
    free(datatypes_src);
    xmlSetExternalEntityLoader(_external_entity_loader);
}

Referenced by DllMain().

schemasInit()

void schemasInit

(

void

)

Definition at line 717 of file schema.c.

{
    xmlChar* buf;
    if (!(datatypes_rsrc = FindResourceA(MSXML_hInstance, "DATATYPES", "XML")))
    {
        FIXME("failed to find resource for %s\n", DT_nsURI);
        return;
    }
 
    if (!(datatypes_handle = LoadResource(MSXML_hInstance, datatypes_rsrc)))
    {
        FIXME("failed to load resource for %s\n", DT_nsURI);
        return;
    }
    buf = LockResource(datatypes_handle);
    datatypes_len = SizeofResource(MSXML_hInstance, datatypes_rsrc);
 
    /* Resource is loaded as raw data,
     * need a null-terminated string */
    while (buf[datatypes_len - 1] != '>') datatypes_len--;
    datatypes_src = malloc(datatypes_len + 1);
    memcpy(datatypes_src, buf, datatypes_len);
    datatypes_src[datatypes_len] = 0;
 
    if (xmlGetExternalEntityLoader() != external_entity_loader)
    {
        _external_entity_loader = xmlGetExternalEntityLoader();
        xmlSetExternalEntityLoader(external_entity_loader);
    }
}

Referenced by DllMain().

str_to_dt()

XDR_DT str_to_dt	(	xmlChar const *	str,
		int	len
	)

Definition at line 541 of file schema.c.

{
    DWORD hash = dt_hash(str, len);
    XDR_DT dt = DT_INVALID;
 
    if (hash <= DT_MAX_HASH_VALUE)
        dt = DT_lookup_table[hash];
 
    if (dt != DT_INVALID && xmlStrcasecmp(str, DT_string_table[dt]) == 0)
        return dt;
 
    return DT_INVALID;
}

Referenced by element_get_dt(), and SchemaCache_get_node_dt().

unsafe_impl_from_IXMLDOMSchemaCollection()

static schema_cache * unsafe_impl_from_IXMLDOMSchemaCollection ( IXMLDOMSchemaCollection *  iface )

inlinestatic

Definition at line 800 of file schema.c.

{
    return iface->lpVtbl == (void*)&XMLDOMSchemaCollection2Vtbl ? impl_from_IXMLDOMSchemaCollection(iface) : NULL;
}

Referenced by schema_cache_addCollection().

validate_error()

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

static

Definition at line 260 of file schema.c.

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

Referenced by Schema_validate_tree().

validate_serror()

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

static

Definition at line 276 of file schema.c.

{
    LIBXML2_CALLBACK_SERROR(Schema_validate_tree, err);
}

Referenced by Schema_validate_tree().

validate_warning()

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

static

Definition at line 268 of file schema.c.

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

Referenced by Schema_validate_tree().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msxml

)

XDR_to_XSD_doc()

xmlDocPtr XDR_to_XSD_doc	(	xmlDocPtr	xdr_doc,
		xmlChar const *	nsURI
	)

Definition at line 810 of file xdr.c.

{
    xmlDocPtr xsd_doc = xmlNewDoc(NULL);
 
    TRACE("(%p)\n", xdr_doc);
 
    XDR_E_Schema(get_schema((xmlNodePtr)xdr_doc), (xmlNodePtr)xsd_doc, nsURI);
 
    return xsd_doc;
}

Referenced by cache_entry_from_xdr_doc().

Variable Documentation

_external_entity_loader

xmlExternalEntityLoader _external_entity_loader

static

Definition at line 689 of file schema.c.

Referenced by external_entity_loader(), schemasCleanup(), and schemasInit().

datatypes_handle

HGLOBAL datatypes_handle

static

Definition at line 67 of file schema.c.

Referenced by external_entity_loader(), and schemasInit().

datatypes_len

int datatypes_len

static

Definition at line 66 of file schema.c.

Referenced by dt_validate(), and schemasInit().

datatypes_rsrc

HRSRC datatypes_rsrc

static

Definition at line 68 of file schema.c.

Referenced by external_entity_loader(), and schemasInit().

datatypes_schema

xmlSchemaPtr datatypes_schema

static

Definition at line 69 of file schema.c.

Referenced by dt_validate(), and schemasCleanup().

datatypes_src

xmlChar* datatypes_src

static

Definition at line 65 of file schema.c.

Referenced by dt_validate(), external_entity_loader(), schemasCleanup(), and schemasInit().

DT_bin_base64

const xmlChar DT_bin_base64[] = "bin.base64"

static

Definition at line 126 of file schema.c.

DT_bin_hex

const xmlChar DT_bin_hex[] = "bin.hex"

static

Definition at line 127 of file schema.c.

DT_boolean

const xmlChar DT_boolean[] = "boolean"

static

Definition at line 128 of file schema.c.

DT_char

const xmlChar DT_char[] = "char"

static

Definition at line 129 of file schema.c.

DT_date

const xmlChar DT_date[] = "date"

static

Definition at line 130 of file schema.c.

DT_date_tz

const xmlChar DT_date_tz[] = "date.tz"

static

Definition at line 131 of file schema.c.

DT_dateTime

const xmlChar DT_dateTime[] = "dateTime"

static

Definition at line 132 of file schema.c.

DT_dateTime_tz

const xmlChar DT_dateTime_tz[] = "dateTime.tz"

static

Definition at line 133 of file schema.c.

DT_entities

const xmlChar DT_entities[] = "entities"

static

Definition at line 135 of file schema.c.

DT_entity

const xmlChar DT_entity[] = "entity"

static

Definition at line 134 of file schema.c.

DT_enumeration

const xmlChar DT_enumeration[] = "enumeration"

static

Definition at line 136 of file schema.c.

DT_fixed_14_4

const xmlChar DT_fixed_14_4[] = "fixed.14.4"

static

Definition at line 137 of file schema.c.

DT_float

const xmlChar DT_float[] = "float"

static

Definition at line 138 of file schema.c.

DT_i1

const xmlChar DT_i1[] = "i1"

static

Definition at line 139 of file schema.c.

DT_i2

const xmlChar DT_i2[] = "i2"

static

Definition at line 140 of file schema.c.

DT_i4

const xmlChar DT_i4[] = "i4"

static

Definition at line 141 of file schema.c.

DT_i8

const xmlChar DT_i8[] = "i8"

static

Definition at line 142 of file schema.c.

DT_id

const xmlChar DT_id[] = "id"

static

Definition at line 143 of file schema.c.

DT_idref

const xmlChar DT_idref[] = "idref"

static

Definition at line 144 of file schema.c.

DT_idrefs

const xmlChar DT_idrefs[] = "idrefs"

static

Definition at line 145 of file schema.c.

DT_int

const xmlChar DT_int[] = "int"

static

Definition at line 146 of file schema.c.

DT_lookup_table

const XDR_DT DT_lookup_table[]

static

Definition at line 479 of file schema.c.

Referenced by bstr_to_dt(), and str_to_dt().

DT_nmtoken

const xmlChar DT_nmtoken[] = "nmtoken"

static

Definition at line 147 of file schema.c.

DT_nmtokens

const xmlChar DT_nmtokens[] = "nmtokens"

static

Definition at line 148 of file schema.c.

DT_notation

const xmlChar DT_notation[] = "notation"

static

Definition at line 149 of file schema.c.

DT_nsURI

const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes"

static

Definition at line 63 of file schema.c.

Referenced by dt_validate(), link_datatypes(), SchemaCache_get_node_dt(), and schemasInit().

DT_number

const xmlChar DT_number[] = "number"

static

Definition at line 150 of file schema.c.

DT_r4

const xmlChar DT_r4[] = "r4"

static

Definition at line 151 of file schema.c.

DT_r8

const xmlChar DT_r8[] = "r8"

static

Definition at line 152 of file schema.c.

DT_string

const xmlChar DT_string[] = "string"

static

Definition at line 153 of file schema.c.

DT_string_table

const xmlChar* const DT_string_table[LAST_DT]

static

Definition at line 399 of file schema.c.

Referenced by debugstr_dt(), dt_to_str(), and str_to_dt().

DT_time

const xmlChar DT_time[] = "time"

static

Definition at line 154 of file schema.c.

DT_time_tz

const xmlChar DT_time_tz[] = "time.tz"

static

Definition at line 155 of file schema.c.

DT_ui1

const xmlChar DT_ui1[] = "ui1"

static

Definition at line 156 of file schema.c.

DT_ui2

const xmlChar DT_ui2[] = "ui2"

static

Definition at line 157 of file schema.c.

DT_ui4

const xmlChar DT_ui4[] = "ui4"

static

Definition at line 158 of file schema.c.

DT_ui8

const xmlChar DT_ui8[] = "ui8"

static

Definition at line 159 of file schema.c.

DT_uri

const xmlChar DT_uri[] = "uri"

static

Definition at line 160 of file schema.c.

DT_uuid

const xmlChar DT_uuid[] = "uuid"

static

Definition at line 161 of file schema.c.

DT_wstring_table

const WCHAR* const DT_wstring_table[LAST_DT]

static

Definition at line 439 of file schema.c.

Referenced by bstr_to_dt(), and dt_to_bstr().

emptyW

const WCHAR emptyW[] = {0}

static

Definition at line 71 of file schema.c.

Referenced by schema_cache_add(), schema_cache_get(), and schema_cache_remove().

hash_assoc_values

const BYTE hash_assoc_values[]

static

Initial value:

=
{
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116,  10, 116, 116,  55,
     45, 116,   5, 116,   0, 116,   0, 116, 116, 116,
    116, 116, 116, 116, 116,   5,   0,   0,  20,   0,
      0,  10,   0,   0, 116,   0,   0,   0,  15,   5,
    116, 116,  10,   0,   0,   0, 116, 116,   0,   0,
     10, 116, 116, 116, 116, 116, 116,   5,   0,   0,
     20,   0,   0,  10,   0,   0, 116,   0,   0,   0,
     15,   5, 116, 116,  10,   0,   0,   0, 116, 116,
      0,   0,  10, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 116
}

Definition at line 200 of file schema.c.

Referenced by dt_hash(), and dt_hash_bstr().

schema_cache_se_tids

const tid_t schema_cache_se_tids[]

static

Initial value:

= {
    IXMLDOMSchemaCollection_tid,
    IXMLDOMSchemaCollection2_tid,
    NULL_tid
}

Definition at line 113 of file schema.c.

Referenced by schema_cache_QueryInterface().

schemacache_dispex

dispex_static_data_t schemacache_dispex

static

Initial value:

= {
    NULL,
    IXMLDOMSchemaCollection2_tid,
    NULL,
    schemacache_iface_tids
}

Definition at line 1594 of file schema.c.

Referenced by SchemaCache_create().

schemacache_enumvariant

const struct enumvariant_funcs schemacache_enumvariant

static

Initial value:

= {
    schema_cache_get_item,
    NULL
}

Definition at line 287 of file schema.c.

Referenced by schema_cache_get__newEnum().

schemacache_iface_tids

const tid_t schemacache_iface_tids[]

static

Initial value:

= {
    IXMLDOMSchemaCollection2_tid,
    0
}

Definition at line 1589 of file schema.c.

wDT_bin_base64

const OLECHAR wDT_bin_base64[] = {'b','i','n','.','b','a','s','e','6','4',0}

static

Definition at line 163 of file schema.c.

wDT_bin_hex

const OLECHAR wDT_bin_hex[] = {'b','i','n','.','h','e','x',0}

static

Definition at line 164 of file schema.c.

wDT_boolean

const OLECHAR wDT_boolean[] = {'b','o','o','l','e','a','n',0}

static

Definition at line 165 of file schema.c.

wDT_char

const OLECHAR wDT_char[] = {'c','h','a','r',0}

static

Definition at line 166 of file schema.c.

wDT_date

const OLECHAR wDT_date[] = {'d','a','t','e',0}

static

Definition at line 167 of file schema.c.

wDT_date_tz

const OLECHAR wDT_date_tz[] = {'d','a','t','e','.','t','z',0}

static

Definition at line 168 of file schema.c.

wDT_dateTime

const OLECHAR wDT_dateTime[] = {'d','a','t','e','T','i','m','e',0}

static

Definition at line 169 of file schema.c.

wDT_dateTime_tz

const OLECHAR wDT_dateTime_tz[] = {'d','a','t','e','T','i','m','e','.','t','z',0}

static

Definition at line 170 of file schema.c.

wDT_entities

const OLECHAR wDT_entities[] = {'e','n','t','i','t','i','e','s',0}

static

Definition at line 172 of file schema.c.

wDT_entity

const OLECHAR wDT_entity[] = {'e','n','t','i','t','y',0}

static

Definition at line 171 of file schema.c.

wDT_enumeration

const OLECHAR wDT_enumeration[] = {'e','n','u','m','e','r','a','t','i','o','n',0}

static

Definition at line 173 of file schema.c.

wDT_fixed_14_4

const OLECHAR wDT_fixed_14_4[] = {'f','i','x','e','d','.','1','4','.','4',0}

static

Definition at line 174 of file schema.c.

wDT_float

const OLECHAR wDT_float[] = {'f','l','o','a','t',0}

static

Definition at line 175 of file schema.c.

wDT_i1

const OLECHAR wDT_i1[] = {'i','1',0}

static

Definition at line 176 of file schema.c.

wDT_i2

const OLECHAR wDT_i2[] = {'i','2',0}

static

Definition at line 177 of file schema.c.

wDT_i4

const OLECHAR wDT_i4[] = {'i','4',0}

static

Definition at line 178 of file schema.c.

wDT_i8

const OLECHAR wDT_i8[] = {'i','8',0}

static

Definition at line 179 of file schema.c.

wDT_id

const OLECHAR wDT_id[] = {'i','d',0}

static

Definition at line 180 of file schema.c.

wDT_idref

const OLECHAR wDT_idref[] = {'i','d','r','e','f',0}

static

Definition at line 181 of file schema.c.

wDT_idrefs

const OLECHAR wDT_idrefs[] = {'i','d','r','e','f','s',0}

static

Definition at line 182 of file schema.c.

wDT_int

const OLECHAR wDT_int[] = {'i','n','t',0}

static

Definition at line 183 of file schema.c.

wDT_nmtoken

const OLECHAR wDT_nmtoken[] = {'n','m','t','o','k','e','n',0}

static

Definition at line 184 of file schema.c.

wDT_nmtokens

const OLECHAR wDT_nmtokens[] = {'n','m','t','o','k','e','n','s',0}

static

Definition at line 185 of file schema.c.

wDT_notation

const OLECHAR wDT_notation[] = {'n','o','t','a','t','i','o','n',0}

static

Definition at line 186 of file schema.c.

wDT_number

const OLECHAR wDT_number[] = {'n','u','m','b','e','r',0}

static

Definition at line 187 of file schema.c.

wDT_r4

const OLECHAR wDT_r4[] = {'r','4',0}

static

Definition at line 188 of file schema.c.

wDT_r8

const OLECHAR wDT_r8[] = {'r','8',0}

static

Definition at line 189 of file schema.c.

wDT_string

const OLECHAR wDT_string[] = {'s','t','r','i','n','g',0}

static

Definition at line 190 of file schema.c.

wDT_time

const OLECHAR wDT_time[] = {'t','i','m','e',0}

static

Definition at line 191 of file schema.c.

wDT_time_tz

const OLECHAR wDT_time_tz[] = {'t','i','m','e','.','t','z',0}

static

Definition at line 192 of file schema.c.

wDT_ui1

const OLECHAR wDT_ui1[] = {'u','i','1',0}

static

Definition at line 193 of file schema.c.

wDT_ui2

const OLECHAR wDT_ui2[] = {'u','i','2',0}

static

Definition at line 194 of file schema.c.

wDT_ui4

const OLECHAR wDT_ui4[] = {'u','i','4',0}

static

Definition at line 195 of file schema.c.

wDT_ui8

const OLECHAR wDT_ui8[] = {'u','i','8',0}

static

Definition at line 196 of file schema.c.

wDT_uri

const OLECHAR wDT_uri[] = {'u','r','i',0}

static

Definition at line 197 of file schema.c.

wDT_uuid

const OLECHAR wDT_uuid[] = {'u','u','i','d',0}

static

Definition at line 198 of file schema.c.

XDR_nsURI

const xmlChar XDR_nsURI[] = "urn:schemas-microsoft-com:xml-data"

static

Definition at line 62 of file schema.c.

Referenced by cache_type_from_xmlDocPtr().

XDR_schema

const xmlChar XDR_schema[] = "Schema"

static

Definition at line 61 of file schema.c.

Referenced by cache_type_from_xmlDocPtr().

XMLDOMSchemaCollection2Vtbl

static const struct IXMLDOMSchemaCollection2Vtbl XMLDOMSchemaCollection2Vtbl

static

Initial value:

=
{
    schema_cache_QueryInterface,
    schema_cache_AddRef,
    schema_cache_Release,
    schema_cache_GetTypeInfoCount,
    schema_cache_GetTypeInfo,
    schema_cache_GetIDsOfNames,
    schema_cache_Invoke,
    schema_cache_add,
    schema_cache_get,
    schema_cache_remove,
    schema_cache_get_length,
    schema_cache_get_namespaceURI,
    schema_cache_addCollection,
    schema_cache_get__newEnum,
    schema_cache_validate,
    schema_cache_put_validateOnLoad,
    schema_cache_get_validateOnLoad,
    schema_cache_getSchema,
    schema_cache_getDeclaration
}

Definition at line 788 of file schema.c.

Referenced by SchemaCache_create(), and unsafe_impl_from_IXMLDOMSchemaCollection().

XSD_nsURI

const xmlChar XSD_nsURI[] = "http://www.w3.org/2001/XMLSchema"

static

Definition at line 60 of file schema.c.

Referenced by cache_type_from_xmlDocPtr().

XSD_schema

const xmlChar XSD_schema[] = "schema"

static

Definition at line 59 of file schema.c.

Referenced by cache_type_from_xmlDocPtr().