Check in the libxml roll script.

third_party/libxml/src/xmlschemas.c

-/*
- * schemas.c : implementation of the XML Schema handling and
- *             schema validity checking
- *
- * See Copyright for the status of this software.
- *
- * Daniel Veillard <veillard@redhat.com>
- */
-
-/*
- * TODO:
- *   - when types are redefined in includes, check that all
- *     types in the redef list are equal
- *     -> need a type equality operation.
- *   - if we don't intend to use the schema for schemas, we
- *     need to validate all schema attributes (ref, type, name)
- *     against their types.
- *   - Eliminate item creation for: ??
- *
- * URGENT TODO:
- *   - For xsi-driven schema acquisition, augment the IDCs after every
- *     acquisition episode (xmlSchemaAugmentIDC).
- *
- * NOTES:
- *   - Elimated item creation for: <restriction>, <extension>,
- *     <simpleContent>, <complexContent>, <list>, <union>
- *
- * PROBLEMS:
- *   - http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0337.html
- *     IDC XPath expression and chameleon includes: the targetNamespace is changed, so
- *     XPath will have trouble to resolve to this namespace, since not known.
- *
- *
- * CONSTRAINTS:
- *
- * Schema Component Constraint:
- *   All Group Limited (cos-all-limited)
- *   Status: complete
- *   (1.2)
- *     In xmlSchemaGroupDefReferenceTermFixup() and
- *   (2)
- *     In xmlSchemaParseModelGroup()
- *     TODO: Actually this should go to component-level checks,
- *     but is done here due to performance. Move it to an other layer
- *     is schema construction via an API is implemented.
- */
-#define IN_LIBXML
-#include "libxml.h"
-
-#ifdef LIBXML_SCHEMAS_ENABLED
-
-#include <string.h>
-#include <libxml/xmlmemory.h>
-#include <libxml/parser.h>
-#include <libxml/parserInternals.h>
-#include <libxml/hash.h>
-#include <libxml/uri.h>
-#include <libxml/xmlschemas.h>
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemastypes.h>
-#include <libxml/xmlautomata.h>
-#include <libxml/xmlregexp.h>
-#include <libxml/dict.h>
-#include <libxml/encoding.h>
-#include <libxml/xmlIO.h>
-#ifdef LIBXML_PATTERN_ENABLED
-#include <libxml/pattern.h>
-#endif
-#ifdef LIBXML_READER_ENABLED
-#include <libxml/xmlreader.h>
-#endif
-
-/* #define DEBUG 1 */
-
-/* #define DEBUG_CONTENT 1 */
-
-/* #define DEBUG_TYPE 1 */
-
-/* #define DEBUG_CONTENT_REGEXP 1 */
-
-/* #define DEBUG_AUTOMATA 1 */
-
-/* #define DEBUG_IDC */
-
-/* #define DEBUG_IDC_NODE_TABLE */
-
-/* #define WXS_ELEM_DECL_CONS_ENABLED */
-
-#ifdef DEBUG_IDC
- #ifndef DEBUG_IDC_NODE_TABLE
-  #define DEBUG_IDC_NODE_TABLE
- #endif
-#endif
-
-/* #define ENABLE_PARTICLE_RESTRICTION 1 */
-
-#define ENABLE_REDEFINE
-
-/* #define ENABLE_NAMED_LOCALS */
-
-/* #define ENABLE_IDC_NODE_TABLES_TEST */
-
-#define DUMP_CONTENT_MODEL
-
-#ifdef LIBXML_READER_ENABLED
-/* #define XML_SCHEMA_READER_ENABLED */
-#endif
-
-#define UNBOUNDED (1 << 30)
-#define TODO                                                            \
-    xmlGenericError(xmlGenericErrorContext,                             \
-            "Unimplemented block at %s:%d\n",                           \
-            __FILE__, __LINE__);
-
-#define XML_SCHEMAS_NO_NAMESPACE (const xmlChar *) "##"
-
-/*
- * The XML Schemas namespaces
- */
-static const xmlChar *xmlSchemaNs = (const xmlChar *)
-    "http://www.w3.org/2001/XMLSchema";
-
-static const xmlChar *xmlSchemaInstanceNs = (const xmlChar *)
-    "http://www.w3.org/2001/XMLSchema-instance";
-
-static const xmlChar *xmlNamespaceNs = (const xmlChar *)
-    "http://www.w3.org/2000/xmlns/";
-
-/*
-* Come casting macros.
-*/
-#define ACTXT_CAST (xmlSchemaAbstractCtxtPtr)
-#define PCTXT_CAST (xmlSchemaParserCtxtPtr)
-#define VCTXT_CAST (xmlSchemaValidCtxtPtr)
-#define WXS_BASIC_CAST (xmlSchemaBasicItemPtr)
-#define WXS_TREE_CAST (xmlSchemaTreeItemPtr)
-#define WXS_PTC_CAST (xmlSchemaParticlePtr)
-#define WXS_TYPE_CAST (xmlSchemaTypePtr)
-#define WXS_ELEM_CAST (xmlSchemaElementPtr)
-#define WXS_ATTR_GROUP_CAST (xmlSchemaAttributeGroupPtr)
-#define WXS_ATTR_CAST (xmlSchemaAttributePtr)
-#define WXS_ATTR_USE_CAST (xmlSchemaAttributeUsePtr)
-#define WXS_ATTR_PROHIB_CAST (xmlSchemaAttributeUseProhibPtr)
-#define WXS_MODEL_GROUPDEF_CAST (xmlSchemaModelGroupDefPtr)
-#define WXS_MODEL_GROUP_CAST (xmlSchemaModelGroupPtr)
-#define WXS_IDC_CAST (xmlSchemaIDCPtr)
-#define WXS_QNAME_CAST (xmlSchemaQNameRefPtr)
-#define WXS_LIST_CAST (xmlSchemaItemListPtr)
-
-/*
-* Macros to query common properties of components.
-*/
-#define WXS_ITEM_NODE(i) xmlSchemaGetComponentNode(WXS_BASIC_CAST (i))
-
-#define WXS_ITEM_TYPE_NAME(i) xmlSchemaGetComponentTypeStr(WXS_BASIC_CAST (i))
-/*
-* Macros for element declarations.
-*/
-#define WXS_ELEM_TYPEDEF(e) (e)->subtypes
-
-#define WXS_SUBST_HEAD(item) (item)->refDecl
-/*
-* Macros for attribute declarations.
-*/
-#define WXS_ATTR_TYPEDEF(a) (a)->subtypes
-/*
-* Macros for attribute uses.
-*/
-#define WXS_ATTRUSE_DECL(au) WXS_ATTR_CAST (WXS_ATTR_USE_CAST (au))->attrDecl
-
-#define WXS_ATTRUSE_TYPEDEF(au) WXS_ATTR_TYPEDEF(WXS_ATTRUSE_DECL( WXS_ATTR_USE_CAST au))
-
-#define WXS_ATTRUSE_DECL_NAME(au) (WXS_ATTRUSE_DECL(au))->name
-
-#define WXS_ATTRUSE_DECL_TNS(au) (WXS_ATTRUSE_DECL(au))->targetNamespace
-/*
-* Macros for attribute groups.
-*/
-#define WXS_ATTR_GROUP_HAS_REFS(ag) ((WXS_ATTR_GROUP_CAST (ag))->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS)
-#define WXS_ATTR_GROUP_EXPANDED(ag) ((WXS_ATTR_GROUP_CAST (ag))->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED)
-/*
-* Macros for particles.
-*/
-#define WXS_PARTICLE(p) WXS_PTC_CAST (p)
-
-#define WXS_PARTICLE_TERM(p) (WXS_PARTICLE(p))->children
-
-#define WXS_PARTICLE_TERM_AS_ELEM(p) (WXS_ELEM_CAST WXS_PARTICLE_TERM(p))
-
-#define WXS_PARTICLE_MODEL(p) WXS_MODEL_GROUP_CAST WXS_PARTICLE(p)->children
-/*
-* Macros for model groups definitions.
-*/
-#define WXS_MODELGROUPDEF_MODEL(mgd) (WXS_MODEL_GROUP_CAST (mgd))->children
-/*
-* Macros for model groups.
-*/
-#define WXS_IS_MODEL_GROUP(i) \
-    (((i)->type == XML_SCHEMA_TYPE_SEQUENCE) || \
-     ((i)->type == XML_SCHEMA_TYPE_CHOICE) || \
-     ((i)->type == XML_SCHEMA_TYPE_ALL))
-
-#define WXS_MODELGROUP_PARTICLE(mg) WXS_PTC_CAST (mg)->children
-/*
-* Macros for schema buckets.
-*/
-#define WXS_IS_BUCKET_INCREDEF(t) (((t) == XML_SCHEMA_SCHEMA_INCLUDE) || \
-    ((t) == XML_SCHEMA_SCHEMA_REDEFINE))
-
-#define WXS_IS_BUCKET_IMPMAIN(t) (((t) == XML_SCHEMA_SCHEMA_MAIN) || \
-    ((t) == XML_SCHEMA_SCHEMA_IMPORT))
-
-#define WXS_IMPBUCKET(b) ((xmlSchemaImportPtr) (b))
-
-#define WXS_INCBUCKET(b) ((xmlSchemaIncludePtr) (b))
-/*
-* Macros for complex/simple types.
-*/
-#define WXS_IS_ANYTYPE(i) \
-     (( (i)->type == XML_SCHEMA_TYPE_BASIC) && \
-      ( (WXS_TYPE_CAST (i))->builtInType == XML_SCHEMAS_ANYTYPE))
-
-#define WXS_IS_COMPLEX(i) \
-    (((i)->type == XML_SCHEMA_TYPE_COMPLEX) || \
-     ((i)->builtInType == XML_SCHEMAS_ANYTYPE))
-
-#define WXS_IS_SIMPLE(item) \
-    ((item->type == XML_SCHEMA_TYPE_SIMPLE) || \
-     ((item->type == XML_SCHEMA_TYPE_BASIC) && \
-      (item->builtInType != XML_SCHEMAS_ANYTYPE)))
-
-#define WXS_IS_ANY_SIMPLE_TYPE(i) \
-    (((i)->type == XML_SCHEMA_TYPE_BASIC) && \
-      ((i)->builtInType == XML_SCHEMAS_ANYSIMPLETYPE))
-
-#define WXS_IS_RESTRICTION(t) \
-    ((t)->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION)
-
-#define WXS_IS_EXTENSION(t) \
-    ((t)->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION)
-
-#define WXS_IS_TYPE_NOT_FIXED(i) \
-    (((i)->type != XML_SCHEMA_TYPE_BASIC) && \
-     (((i)->flags & XML_SCHEMAS_TYPE_INTERNAL_RESOLVED) == 0))
-
-#define WXS_IS_TYPE_NOT_FIXED_1(item) \
-    (((item)->type != XML_SCHEMA_TYPE_BASIC) && \
-     (((item)->flags & XML_SCHEMAS_TYPE_FIXUP_1) == 0))
-
-#define WXS_TYPE_IS_GLOBAL(t) ((t)->flags & XML_SCHEMAS_TYPE_GLOBAL)
-
-#define WXS_TYPE_IS_LOCAL(t) (((t)->flags & XML_SCHEMAS_TYPE_GLOBAL) == 0)
-/*
-* Macros for exclusively for complex types.
-*/
-#define WXS_HAS_COMPLEX_CONTENT(item) \
-    ((item->contentType == XML_SCHEMA_CONTENT_MIXED) || \
-     (item->contentType == XML_SCHEMA_CONTENT_EMPTY) || \
-     (item->contentType == XML_SCHEMA_CONTENT_ELEMENTS))
-
-#define WXS_HAS_SIMPLE_CONTENT(item) \
-    ((item->contentType == XML_SCHEMA_CONTENT_SIMPLE) || \
-     (item->contentType == XML_SCHEMA_CONTENT_BASIC))
-
-#define WXS_HAS_MIXED_CONTENT(item) \
-    (item->contentType == XML_SCHEMA_CONTENT_MIXED)
-
-#define WXS_EMPTIABLE(t) \
-    (xmlSchemaIsParticleEmptiable(WXS_PTC_CAST (t)->subtypes))
-
-#define WXS_TYPE_CONTENTTYPE(t) (t)->subtypes
-
-#define WXS_TYPE_PARTICLE(t) WXS_PTC_CAST (t)->subtypes
-
-#define WXS_TYPE_PARTICLE_TERM(t) WXS_PARTICLE_TERM(WXS_TYPE_PARTICLE(t))
-/*
-* Macros for exclusively for simple types.
-*/
-#define WXS_LIST_ITEMTYPE(t) (t)->subtypes
-
-#define WXS_IS_ATOMIC(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC)
-
-#define WXS_IS_LIST(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_LIST)
-
-#define WXS_IS_UNION(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_UNION)
-/*
-* Misc parser context macros.
-*/
-#define WXS_CONSTRUCTOR(ctx) (ctx)->constructor
-
-#define WXS_HAS_BUCKETS(ctx) \
-( (WXS_CONSTRUCTOR((ctx))->buckets != NULL) && \
-(WXS_CONSTRUCTOR((ctx))->buckets->nbItems > 0) )
-
-#define WXS_SUBST_GROUPS(ctx) WXS_CONSTRUCTOR((ctx))->substGroups
-
-#define WXS_BUCKET(ctx) WXS_CONSTRUCTOR((ctx))->bucket
-
-#define WXS_SCHEMA(ctx) (ctx)->schema
-
-#define WXS_ADD_LOCAL(ctx, item) \
-    xmlSchemaAddItemSize(&(WXS_BUCKET(ctx)->locals), 10, item)
-
-#define WXS_ADD_GLOBAL(ctx, item) \
-    xmlSchemaAddItemSize(&(WXS_BUCKET(ctx)->globals), 5, item)
-
-#define WXS_ADD_PENDING(ctx, item) \
-    xmlSchemaAddItemSize(&((ctx)->constructor->pending), 10, item)
-/*
-* xmlSchemaItemList macros.
-*/
-#define WXS_ILIST_IS_EMPTY(l) ((l == NULL) || ((l)->nbItems == 0))
-/*
-* Misc macros.
-*/
-#define IS_SCHEMA(node, type) \
-   ((node != NULL) && (node->ns != NULL) && \
-    (xmlStrEqual(node->name, (const xmlChar *) type)) && \
-    (xmlStrEqual(node->ns->href, xmlSchemaNs)))
-
-#define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; }
-
-/*
-* Since we put the default/fixed values into the dict, we can
-* use pointer comparison for those values.
-* REMOVED: (xmlStrEqual((v1), (v2)))
-*/
-#define WXS_ARE_DEFAULT_STR_EQUAL(v1, v2) ((v1) == (v2))
-
-#define INODE_NILLED(item) (item->flags & XML_SCHEMA_ELEM_INFO_NILLED)
-
-#define CAN_PARSE_SCHEMA(b) (((b)->doc != NULL) && ((b)->parsed == 0))
-
-#define HFAILURE if (res == -1) goto exit_failure;
-
-#define HERROR if (res != 0) goto exit_error;
-
-#define HSTOP(ctx) if ((ctx)->stop) goto exit;
-/*
-* Some flags used for various schema constraints.
-*/
-#define SUBSET_RESTRICTION  1<<0
-#define SUBSET_EXTENSION    1<<1
-#define SUBSET_SUBSTITUTION 1<<2
-#define SUBSET_LIST         1<<3
-#define SUBSET_UNION        1<<4
-
-typedef struct _xmlSchemaNodeInfo xmlSchemaNodeInfo;
-typedef xmlSchemaNodeInfo *xmlSchemaNodeInfoPtr;
-
-typedef struct _xmlSchemaItemList xmlSchemaItemList;
-typedef xmlSchemaItemList *xmlSchemaItemListPtr;
-struct _xmlSchemaItemList {
-    void **items;  /* used for dynamic addition of schemata */
-    int nbItems; /* used for dynamic addition of schemata */
-    int sizeItems; /* used for dynamic addition of schemata */
-};
-
-#define XML_SCHEMA_CTXT_PARSER 1
-#define XML_SCHEMA_CTXT_VALIDATOR 2
-
-typedef struct _xmlSchemaAbstractCtxt xmlSchemaAbstractCtxt;
-typedef xmlSchemaAbstractCtxt *xmlSchemaAbstractCtxtPtr;
-struct _xmlSchemaAbstractCtxt {
-    int type; /* E.g. XML_SCHEMA_CTXT_VALIDATOR */
-};
-
-typedef struct _xmlSchemaBucket xmlSchemaBucket;
-typedef xmlSchemaBucket *xmlSchemaBucketPtr;
-
-#define XML_SCHEMA_SCHEMA_MAIN 0
-#define XML_SCHEMA_SCHEMA_IMPORT 1
-#define XML_SCHEMA_SCHEMA_INCLUDE 2
-#define XML_SCHEMA_SCHEMA_REDEFINE 3
-
-/**
- * xmlSchemaSchemaRelation:
- *
- * Used to create a graph of schema relationships.
- */
-typedef struct _xmlSchemaSchemaRelation xmlSchemaSchemaRelation;
-typedef xmlSchemaSchemaRelation *xmlSchemaSchemaRelationPtr;
-struct _xmlSchemaSchemaRelation {
-    xmlSchemaSchemaRelationPtr next;
-    int type; /* E.g. XML_SCHEMA_SCHEMA_IMPORT */
-    const xmlChar *importNamespace;
-    xmlSchemaBucketPtr bucket;
-};
-
-#define XML_SCHEMA_BUCKET_MARKED 1<<0
-#define XML_SCHEMA_BUCKET_COMPS_ADDED 1<<1
-
-struct _xmlSchemaBucket {
-    int type;
-    int flags;
-    const xmlChar *schemaLocation;
-    const xmlChar *origTargetNamespace;
-    const xmlChar *targetNamespace;
-    xmlDocPtr doc;
-    xmlSchemaSchemaRelationPtr relations;
-    int located;
-    int parsed;
-    int imported;
-    int preserveDoc;
-    xmlSchemaItemListPtr globals; /* Global components. */
-    xmlSchemaItemListPtr locals; /* Local components. */
-};
-
-/**
- * xmlSchemaImport:
- * (extends xmlSchemaBucket)
- *
- * Reflects a schema. Holds some information
- * about the schema and its toplevel components. Duplicate
- * toplevel components are not checked at this level.
- */
-typedef struct _xmlSchemaImport xmlSchemaImport;
-typedef xmlSchemaImport *xmlSchemaImportPtr;
-struct _xmlSchemaImport {
-    int type; /* Main OR import OR include. */
-    int flags;
-    const xmlChar *schemaLocation; /* The URI of the schema document. */
-    /* For chameleon includes, @origTargetNamespace will be NULL */
-    const xmlChar *origTargetNamespace;
-    /*
-    * For chameleon includes, @targetNamespace will be the
-    * targetNamespace of the including schema.
-    */
-    const xmlChar *targetNamespace;
-    xmlDocPtr doc; /* The schema node-tree. */
-    /* @relations will hold any included/imported/redefined schemas. */
-    xmlSchemaSchemaRelationPtr relations;
-    int located;
-    int parsed;
-    int imported;
-    int preserveDoc;
-    xmlSchemaItemListPtr globals;
-    xmlSchemaItemListPtr locals;
-    /* The imported schema. */
-    xmlSchemaPtr schema;
-};
-
-/*
-* (extends xmlSchemaBucket)
-*/
-typedef struct _xmlSchemaInclude xmlSchemaInclude;
-typedef xmlSchemaInclude *xmlSchemaIncludePtr;
-struct _xmlSchemaInclude {
-    int type;
-    int flags;
-    const xmlChar *schemaLocation;
-    const xmlChar *origTargetNamespace;
-    const xmlChar *targetNamespace;
-    xmlDocPtr doc;
-    xmlSchemaSchemaRelationPtr relations;
-    int located;
-    int parsed;
-    int imported;
-    int preserveDoc;
-    xmlSchemaItemListPtr globals; /* Global components. */
-    xmlSchemaItemListPtr locals; /* Local components. */
-
-    /* The owning main or import schema bucket. */
-    xmlSchemaImportPtr ownerImport;
-};
-
-/**
- * xmlSchemaBasicItem:
- *
- * The abstract base type for schema components.
- */
-typedef struct _xmlSchemaBasicItem xmlSchemaBasicItem;
-typedef xmlSchemaBasicItem *xmlSchemaBasicItemPtr;
-struct _xmlSchemaBasicItem {
-    xmlSchemaTypeType type;
-};
-
-/**
- * xmlSchemaAnnotItem:
- *
- * The abstract base type for annotated schema components.
- * (Extends xmlSchemaBasicItem)
- */
-typedef struct _xmlSchemaAnnotItem xmlSchemaAnnotItem;
-typedef xmlSchemaAnnotItem *xmlSchemaAnnotItemPtr;
-struct _xmlSchemaAnnotItem {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-};
-
-/**
- * xmlSchemaTreeItem:
- *
- * The abstract base type for tree-like structured schema components.
- * (Extends xmlSchemaAnnotItem)
- */
-typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
-typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
-struct _xmlSchemaTreeItem {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTreeItemPtr next;
-    xmlSchemaTreeItemPtr children;
-};
-
-
-#define XML_SCHEMA_ATTR_USE_FIXED 1<<0
-/**
- * xmlSchemaAttributeUsePtr:
- *
- * The abstract base type for tree-like structured schema components.
- * (Extends xmlSchemaTreeItem)
- */
-typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
-typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
-struct _xmlSchemaAttributeUse {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaAttributeUsePtr next; /* The next attr. use. */
-    /*
-    * The attr. decl. OR a QName-ref. to an attr. decl. OR
-    * a QName-ref. to an attribute group definition.
-    */
-    xmlSchemaAttributePtr attrDecl;
-
-    int flags;
-    xmlNodePtr node;
-    int occurs; /* required, optional */
-    const xmlChar * defValue;
-    xmlSchemaValPtr defVal;
-};
-
-/**
- * xmlSchemaAttributeUseProhibPtr:
- *
- * A helper component to reflect attribute prohibitions.
- * (Extends xmlSchemaBasicItem)
- */
-typedef struct _xmlSchemaAttributeUseProhib xmlSchemaAttributeUseProhib;
-typedef xmlSchemaAttributeUseProhib *xmlSchemaAttributeUseProhibPtr;
-struct _xmlSchemaAttributeUseProhib {
-    xmlSchemaTypeType type; /* == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB */
-    xmlNodePtr node;
-    const xmlChar *name;
-    const xmlChar *targetNamespace;
-    int isRef;
-};
-
-/**
- * xmlSchemaRedef:
- */
-typedef struct _xmlSchemaRedef xmlSchemaRedef;
-typedef xmlSchemaRedef *xmlSchemaRedefPtr;
-struct _xmlSchemaRedef {
-    xmlSchemaRedefPtr next;
-    xmlSchemaBasicItemPtr item; /* The redefining component. */
-    xmlSchemaBasicItemPtr reference; /* The referencing component. */
-    xmlSchemaBasicItemPtr target; /* The to-be-redefined component. */
-    const xmlChar *refName; /* The name of the to-be-redefined component. */
-    const xmlChar *refTargetNs; /* The target namespace of the
-                                   to-be-redefined comp. */
-    xmlSchemaBucketPtr targetBucket; /* The redefined schema. */
-};
-
-/**
- * xmlSchemaConstructionCtxt:
- */
-typedef struct _xmlSchemaConstructionCtxt xmlSchemaConstructionCtxt;
-typedef xmlSchemaConstructionCtxt *xmlSchemaConstructionCtxtPtr;
-struct _xmlSchemaConstructionCtxt {
-    xmlSchemaPtr mainSchema; /* The main schema. */
-    xmlSchemaBucketPtr mainBucket; /* The main schema bucket */
-    xmlDictPtr dict;
-    xmlSchemaItemListPtr buckets; /* List of schema buckets. */
-    /* xmlSchemaItemListPtr relations; */ /* List of schema relations. */
-    xmlSchemaBucketPtr bucket; /* The current schema bucket */
-    xmlSchemaItemListPtr pending; /* All Components of all schemas that
-                                     need to be fixed. */
-    xmlHashTablePtr substGroups;
-    xmlSchemaRedefPtr redefs;
-    xmlSchemaRedefPtr lastRedef;
-};
-
-#define XML_SCHEMAS_PARSE_ERROR         1
-#define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
-
-struct _xmlSchemaParserCtxt {
-    int type;
-    void *errCtxt;             /* user specific error context */
-    xmlSchemaValidityErrorFunc error;   /* the callback in case of errors */
-    xmlSchemaValidityWarningFunc warning;       /* the callback in case of warning */
-    int err;
-    int nberrors;
-    xmlStructuredErrorFunc serror;
-
-    xmlSchemaConstructionCtxtPtr constructor;
-    int ownsConstructor; /* TODO: Move this to parser *flags*. */
-
-    /* xmlSchemaPtr topschema;  */
-    /* xmlHashTablePtr namespaces;  */
-
-    xmlSchemaPtr schema;        /* The main schema in use */
-    int counter;
-
-    const xmlChar *URL;
-    xmlDocPtr doc;
-    int preserve;               /* Whether the doc should be freed  */
-
-    const char *buffer;
-    int size;
-
-    /*
-     * Used to build complex element content models
-     */
-    xmlAutomataPtr am;
-    xmlAutomataStatePtr start;
-    xmlAutomataStatePtr end;
-    xmlAutomataStatePtr state;
-
-    xmlDictPtr dict;            /* dictionary for interned string names */
-    xmlSchemaTypePtr ctxtType; /* The current context simple/complex type */
-    int options;
-    xmlSchemaValidCtxtPtr vctxt;
-    int isS4S;
-    int isRedefine;
-    int xsiAssemble;
-    int stop; /* If the parser should stop; i.e. a critical error. */
-    const xmlChar *targetNamespace;
-    xmlSchemaBucketPtr redefined; /* The schema to be redefined. */
-
-    xmlSchemaRedefPtr redef; /* Used for redefinitions. */
-    int redefCounter; /* Used for redefinitions. */
-    xmlSchemaItemListPtr attrProhibs;
-};
-
-/**
- * xmlSchemaQNameRef:
- *
- * A component reference item (not a schema component)
- * (Extends xmlSchemaBasicItem)
- */
-typedef struct _xmlSchemaQNameRef xmlSchemaQNameRef;
-typedef xmlSchemaQNameRef *xmlSchemaQNameRefPtr;
-struct _xmlSchemaQNameRef {
-    xmlSchemaTypeType type;
-    xmlSchemaBasicItemPtr item; /* The resolved referenced item. */
-    xmlSchemaTypeType itemType;
-    const xmlChar *name;
-    const xmlChar *targetNamespace;
-    xmlNodePtr node;
-};
-
-/**
- * xmlSchemaParticle:
- *
- * A particle component.
- * (Extends xmlSchemaTreeItem)
- */
-typedef struct _xmlSchemaParticle xmlSchemaParticle;
-typedef xmlSchemaParticle *xmlSchemaParticlePtr;
-struct _xmlSchemaParticle {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTreeItemPtr next; /* next particle */
-    xmlSchemaTreeItemPtr children; /* the "term" (e.g. a model group,
-        a group definition, a XML_SCHEMA_EXTRA_QNAMEREF (if a reference),
-        etc.) */
-    int minOccurs;
-    int maxOccurs;
-    xmlNodePtr node;
-};
-
-/**
- * xmlSchemaModelGroup:
- *
- * A model group component.
- * (Extends xmlSchemaTreeItem)
- */
-typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
-typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
-struct _xmlSchemaModelGroup {
-    xmlSchemaTypeType type; /* XML_SCHEMA_TYPE_SEQUENCE, XML_SCHEMA_TYPE_CHOICE, XML_SCHEMA_TYPE_ALL */
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTreeItemPtr next; /* not used */
-    xmlSchemaTreeItemPtr children; /* first particle (OR "element decl" OR "wildcard") */
-    xmlNodePtr node;
-};
-
-#define XML_SCHEMA_MODEL_GROUP_DEF_MARKED 1<<0
-#define XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED 1<<1
-/**
- * xmlSchemaModelGroupDef:
- *
- * A model group definition component.
- * (Extends xmlSchemaTreeItem)
- */
-typedef struct _xmlSchemaModelGroupDef xmlSchemaModelGroupDef;
-typedef xmlSchemaModelGroupDef *xmlSchemaModelGroupDefPtr;
-struct _xmlSchemaModelGroupDef {
-    xmlSchemaTypeType type; /* XML_SCHEMA_TYPE_GROUP */
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaTreeItemPtr next; /* not used */
-    xmlSchemaTreeItemPtr children; /* the "model group" */
-    const xmlChar *name;
-    const xmlChar *targetNamespace;
-    xmlNodePtr node;
-    int flags;
-};
-
-typedef struct _xmlSchemaIDC xmlSchemaIDC;
-typedef xmlSchemaIDC *xmlSchemaIDCPtr;
-
-/**
- * xmlSchemaIDCSelect:
- *
- * The identity-constraint "field" and "selector" item, holding the
- * XPath expression.
- */
-typedef struct _xmlSchemaIDCSelect xmlSchemaIDCSelect;
-typedef xmlSchemaIDCSelect *xmlSchemaIDCSelectPtr;
-struct _xmlSchemaIDCSelect {
-    xmlSchemaIDCSelectPtr next;
-    xmlSchemaIDCPtr idc;
-    int index; /* an index position if significant for IDC key-sequences */
-    const xmlChar *xpath; /* the XPath expression */
-    void *xpathComp; /* the compiled XPath expression */
-};
-
-/**
- * xmlSchemaIDC:
- *
- * The identity-constraint definition component.
- * (Extends xmlSchemaAnnotItem)
- */
-
-struct _xmlSchemaIDC {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaIDCPtr next;
-    xmlNodePtr node;
-    const xmlChar *name;
-    const xmlChar *targetNamespace;
-    xmlSchemaIDCSelectPtr selector;
-    xmlSchemaIDCSelectPtr fields;
-    int nbFields;
-    xmlSchemaQNameRefPtr ref;
-};
-
-/**
- * xmlSchemaIDCAug:
- *
- * The augmented IDC information used for validation.
- */
-typedef struct _xmlSchemaIDCAug xmlSchemaIDCAug;
-typedef xmlSchemaIDCAug *xmlSchemaIDCAugPtr;
-struct _xmlSchemaIDCAug {
-    xmlSchemaIDCAugPtr next; /* next in a list */
-    xmlSchemaIDCPtr def; /* the IDC definition */
-    int keyrefDepth; /* the lowest tree level to which IDC
-                        tables need to be bubbled upwards */
-};
-
-/**
- * xmlSchemaPSVIIDCKeySequence:
- *
- * The key sequence of a node table item.
- */
-typedef struct _xmlSchemaPSVIIDCKey xmlSchemaPSVIIDCKey;
-typedef xmlSchemaPSVIIDCKey *xmlSchemaPSVIIDCKeyPtr;
-struct _xmlSchemaPSVIIDCKey {
-    xmlSchemaTypePtr type;
-    xmlSchemaValPtr val;
-};
-
-/**
- * xmlSchemaPSVIIDCNode:
- *
- * The node table item of a node table.
- */
-typedef struct _xmlSchemaPSVIIDCNode xmlSchemaPSVIIDCNode;
-typedef xmlSchemaPSVIIDCNode *xmlSchemaPSVIIDCNodePtr;
-struct _xmlSchemaPSVIIDCNode {
-    xmlNodePtr node;
-    xmlSchemaPSVIIDCKeyPtr *keys;
-    int nodeLine;
-    int nodeQNameID;
-
-};
-
-/**
- * xmlSchemaPSVIIDCBinding:
- *
- * The identity-constraint binding item of the [identity-constraint table].
- */
-typedef struct _xmlSchemaPSVIIDCBinding xmlSchemaPSVIIDCBinding;
-typedef xmlSchemaPSVIIDCBinding *xmlSchemaPSVIIDCBindingPtr;
-struct _xmlSchemaPSVIIDCBinding {
-    xmlSchemaPSVIIDCBindingPtr next; /* next binding of a specific node */
-    xmlSchemaIDCPtr definition; /* the IDC definition */
-    xmlSchemaPSVIIDCNodePtr *nodeTable; /* array of key-sequences */
-    int nbNodes; /* number of entries in the node table */
-    int sizeNodes; /* size of the node table */
-    xmlSchemaItemListPtr dupls;
-};
-
-
-#define XPATH_STATE_OBJ_TYPE_IDC_SELECTOR 1
-#define XPATH_STATE_OBJ_TYPE_IDC_FIELD 2
-
-#define XPATH_STATE_OBJ_MATCHES -2
-#define XPATH_STATE_OBJ_BLOCKED -3
-
-typedef struct _xmlSchemaIDCMatcher xmlSchemaIDCMatcher;
-typedef xmlSchemaIDCMatcher *xmlSchemaIDCMatcherPtr;
-
-/**
- * xmlSchemaIDCStateObj:
- *
- * The state object used to evaluate XPath expressions.
- */
-typedef struct _xmlSchemaIDCStateObj xmlSchemaIDCStateObj;
-typedef xmlSchemaIDCStateObj *xmlSchemaIDCStateObjPtr;
-struct _xmlSchemaIDCStateObj {
-    int type;
-    xmlSchemaIDCStateObjPtr next; /* next if in a list */
-    int depth; /* depth of creation */
-    int *history; /* list of (depth, state-id) tuples */
-    int nbHistory;
-    int sizeHistory;
-    xmlSchemaIDCMatcherPtr matcher; /* the correspondent field/selector
-                                       matcher */
-    xmlSchemaIDCSelectPtr sel;
-    void *xpathCtxt;
-};
-
-#define IDC_MATCHER 0
-
-/**
- * xmlSchemaIDCMatcher:
- *
- * Used to evaluate IDC selectors (and fields).
- */
-struct _xmlSchemaIDCMatcher {
-    int type;
-    int depth; /* the tree depth at creation time */
-    xmlSchemaIDCMatcherPtr next; /* next in the list */
-    xmlSchemaIDCMatcherPtr nextCached; /* next in the cache list */
-    xmlSchemaIDCAugPtr aidc; /* the augmented IDC item */
-    int idcType;
-    xmlSchemaPSVIIDCKeyPtr **keySeqs; /* the key-sequences of the target
-                                         elements */
-    int sizeKeySeqs;
-    xmlSchemaItemListPtr targets; /* list of target-node
-                                     (xmlSchemaPSVIIDCNodePtr) entries */
-};
-
-/*
-* Element info flags.
-*/
-#define XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES  1<<0
-#define XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES 1<<1
-#define XML_SCHEMA_ELEM_INFO_NILLED            1<<2
-#define XML_SCHEMA_ELEM_INFO_LOCAL_TYPE        1<<3
-
-#define XML_SCHEMA_NODE_INFO_VALUE_NEEDED      1<<4
-#define XML_SCHEMA_ELEM_INFO_EMPTY             1<<5
-#define XML_SCHEMA_ELEM_INFO_HAS_CONTENT       1<<6
-
-#define XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT  1<<7
-#define XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT  1<<8
-#define XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED  1<<9
-#define XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE  1<<10
-
-/**
- * xmlSchemaNodeInfo:
- *
- * Holds information of an element node.
- */
-struct _xmlSchemaNodeInfo {
-    int nodeType;
-    xmlNodePtr node;
-    int nodeLine;
-    const xmlChar *localName;
-    const xmlChar *nsName;
-    const xmlChar *value;
-    xmlSchemaValPtr val; /* the pre-computed value if any */
-    xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
-
-    int flags; /* combination of node info flags */
-
-    int valNeeded;
-    int normVal;
-
-    xmlSchemaElementPtr decl; /* the element/attribute declaration */
-    int depth;
-    xmlSchemaPSVIIDCBindingPtr idcTable; /* the table of PSVI IDC bindings
-                                            for the scope element*/
-    xmlSchemaIDCMatcherPtr idcMatchers; /* the IDC matchers for the scope
-                                           element */
-    xmlRegExecCtxtPtr regexCtxt;
-
-    const xmlChar **nsBindings; /* Namespace bindings on this element */
-    int nbNsBindings;
-    int sizeNsBindings;
-
-    int hasKeyrefs;
-    int appliedXPath; /* Indicates that an XPath has been applied. */
-};
-
-#define XML_SCHEMAS_ATTR_UNKNOWN 1
-#define XML_SCHEMAS_ATTR_ASSESSED 2
-#define XML_SCHEMAS_ATTR_PROHIBITED 3
-#define XML_SCHEMAS_ATTR_ERR_MISSING 4
-#define XML_SCHEMAS_ATTR_INVALID_VALUE 5
-#define XML_SCHEMAS_ATTR_ERR_NO_TYPE 6
-#define XML_SCHEMAS_ATTR_ERR_FIXED_VALUE 7
-#define XML_SCHEMAS_ATTR_DEFAULT 8
-#define XML_SCHEMAS_ATTR_VALIDATE_VALUE 9
-#define XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL 10
-#define XML_SCHEMAS_ATTR_HAS_ATTR_USE 11
-#define XML_SCHEMAS_ATTR_HAS_ATTR_DECL 12
-#define XML_SCHEMAS_ATTR_WILD_SKIP 13
-#define XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL 14
-#define XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID 15
-#define XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID 16
-#define XML_SCHEMAS_ATTR_META 17
-/*
-* @metaType values of xmlSchemaAttrInfo.
-*/
-#define XML_SCHEMA_ATTR_INFO_META_XSI_TYPE 1
-#define XML_SCHEMA_ATTR_INFO_META_XSI_NIL 2
-#define XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC 3
-#define XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC 4
-#define XML_SCHEMA_ATTR_INFO_META_XMLNS 5
-
-typedef struct _xmlSchemaAttrInfo xmlSchemaAttrInfo;
-typedef xmlSchemaAttrInfo *xmlSchemaAttrInfoPtr;
-struct _xmlSchemaAttrInfo {
-    int nodeType;
-    xmlNodePtr node;
-    int nodeLine;
-    const xmlChar *localName;
-    const xmlChar *nsName;
-    const xmlChar *value;
-    xmlSchemaValPtr val; /* the pre-computed value if any */
-    xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
-    int flags; /* combination of node info flags */
-
-    xmlSchemaAttributePtr decl; /* the attribute declaration */
-    xmlSchemaAttributeUsePtr use;  /* the attribute use */
-    int state;
-    int metaType;
-    const xmlChar *vcValue; /* the value constraint value */
-    xmlSchemaNodeInfoPtr parent;
-};
-
-
-#define XML_SCHEMA_VALID_CTXT_FLAG_STREAM 1
-/**
- * xmlSchemaValidCtxt:
- *
- * A Schemas validation context
- */
-struct _xmlSchemaValidCtxt {
-    int type;
-    void *errCtxt;             /* user specific data block */
-    xmlSchemaValidityErrorFunc error;   /* the callback in case of errors */
-    xmlSchemaValidityWarningFunc warning; /* the callback in case of warning */
-    xmlStructuredErrorFunc serror;
-
-    xmlSchemaPtr schema;        /* The schema in use */
-    xmlDocPtr doc;
-    xmlParserInputBufferPtr input;
-    xmlCharEncoding enc;
-    xmlSAXHandlerPtr sax;
-    xmlParserCtxtPtr parserCtxt;
-    void *user_data; /* TODO: What is this for? */
-    char *filename;
-
-    int err;
-    int nberrors;
-
-    xmlNodePtr node;
-    xmlNodePtr cur;
-    /* xmlSchemaTypePtr type; */
-
-    xmlRegExecCtxtPtr regexp;
-    xmlSchemaValPtr value;
-
-    int valueWS;
-    int options;
-    xmlNodePtr validationRoot;
-    xmlSchemaParserCtxtPtr pctxt;
-    int xsiAssemble;
-
-    int depth;
-    xmlSchemaNodeInfoPtr *elemInfos; /* array of element informations */
-    int sizeElemInfos;
-    xmlSchemaNodeInfoPtr inode; /* the current element information */
-
-    xmlSchemaIDCAugPtr aidcs; /* a list of augmented IDC informations */
-
-    xmlSchemaIDCStateObjPtr xpathStates; /* first active state object. */
-    xmlSchemaIDCStateObjPtr xpathStatePool; /* first stored state object. */
-    xmlSchemaIDCMatcherPtr idcMatcherCache; /* Cache for IDC matcher objects. */
-
-    xmlSchemaPSVIIDCNodePtr *idcNodes; /* list of all IDC node-table entries*/
-    int nbIdcNodes;
-    int sizeIdcNodes;
-
-    xmlSchemaPSVIIDCKeyPtr *idcKeys; /* list of all IDC node-table entries */
-    int nbIdcKeys;
-    int sizeIdcKeys;
-
-    int flags;
-
-    xmlDictPtr dict;
-
-#ifdef LIBXML_READER_ENABLED
-    xmlTextReaderPtr reader;
-#endif
-
-    xmlSchemaAttrInfoPtr *attrInfos;
-    int nbAttrInfos;
-    int sizeAttrInfos;
-
-    int skipDepth;
-    xmlSchemaItemListPtr nodeQNames;
-    int hasKeyrefs;
-    int createIDCNodeTables;
-    int psviExposeIDCNodeTables;
-
-    /* Locator for error reporting in streaming mode */
-    xmlSchemaValidityLocatorFunc locFunc;
-    void *locCtxt;
-};
-
-/**
- * xmlSchemaSubstGroup:
- *
- *
- */
-typedef struct _xmlSchemaSubstGroup xmlSchemaSubstGroup;
-typedef xmlSchemaSubstGroup *xmlSchemaSubstGroupPtr;
-struct _xmlSchemaSubstGroup {
-    xmlSchemaElementPtr head;
-    xmlSchemaItemListPtr members;
-};
-
-/************************************************************************
- *                                                                      *
- *                      Some predeclarations                            *
- *                                                                      *
- ************************************************************************/
-
-static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaPtr schema,
-                                 xmlNodePtr node);
-static int xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaPtr schema,
-                                 xmlNodePtr node);
-static int
-xmlSchemaTypeFixup(xmlSchemaTypePtr type,
-                   xmlSchemaAbstractCtxtPtr ctxt);
-static const xmlChar *
-xmlSchemaFacetTypeToString(xmlSchemaTypeType type);
-static int
-xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                     xmlNodePtr node);
-static int
-xmlSchemaCheckFacetValues(xmlSchemaTypePtr typeDecl,
-                       xmlSchemaParserCtxtPtr ctxt);
-static void
-xmlSchemaClearValidCtxt(xmlSchemaValidCtxtPtr vctxt);
-static xmlSchemaWhitespaceValueType
-xmlSchemaGetWhiteSpaceFacetValue(xmlSchemaTypePtr type);
-static xmlSchemaTreeItemPtr
-xmlSchemaParseModelGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                         xmlNodePtr node, xmlSchemaTypeType type,
-                         int withParticle);
-static const xmlChar *
-xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item);
-static xmlSchemaTypeLinkPtr
-xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type);
-static void
-xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
-                     const char *funcName,
-                     const char *message) LIBXML_ATTR_FORMAT(3,0);
-static int
-xmlSchemaCheckCOSSTDerivedOK(xmlSchemaAbstractCtxtPtr ctxt,
-                             xmlSchemaTypePtr type,
-                             xmlSchemaTypePtr baseType,
-                             int subset);
-static void
-xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
-                                   xmlSchemaParserCtxtPtr ctxt);
-static void
-xmlSchemaComponentListFree(xmlSchemaItemListPtr list);
-static xmlSchemaQNameRefPtr
-xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
-                                xmlSchemaPtr schema,
-                                xmlNodePtr node);
-
-/************************************************************************
- *                                                                      *
- *                      Helper functions                                *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaItemTypeToStr:
- * @type: the type of the schema item
- *
- * Returns the component name of a schema item.
- */
-static const xmlChar *
-xmlSchemaItemTypeToStr(xmlSchemaTypeType type)
-{
-    switch (type) {
-        case XML_SCHEMA_TYPE_BASIC:
-            return(BAD_CAST "simple type definition");
-        case XML_SCHEMA_TYPE_SIMPLE:
-            return(BAD_CAST "simple type definition");
-        case XML_SCHEMA_TYPE_COMPLEX:
-            return(BAD_CAST "complex type definition");
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return(BAD_CAST "element declaration");
-        case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-            return(BAD_CAST "attribute use");
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            return(BAD_CAST "attribute declaration");
-        case XML_SCHEMA_TYPE_GROUP:
-            return(BAD_CAST "model group definition");
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            return(BAD_CAST "attribute group definition");
-        case XML_SCHEMA_TYPE_NOTATION:
-            return(BAD_CAST "notation declaration");
-        case XML_SCHEMA_TYPE_SEQUENCE:
-            return(BAD_CAST "model group (sequence)");
-        case XML_SCHEMA_TYPE_CHOICE:
-            return(BAD_CAST "model group (choice)");
-        case XML_SCHEMA_TYPE_ALL:
-            return(BAD_CAST "model group (all)");
-        case XML_SCHEMA_TYPE_PARTICLE:
-            return(BAD_CAST "particle");
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-            return(BAD_CAST "unique identity-constraint");
-            /* return(BAD_CAST "IDC (unique)"); */
-        case XML_SCHEMA_TYPE_IDC_KEY:
-            return(BAD_CAST "key identity-constraint");
-            /* return(BAD_CAST "IDC (key)"); */
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            return(BAD_CAST "keyref identity-constraint");
-            /* return(BAD_CAST "IDC (keyref)"); */
-        case XML_SCHEMA_TYPE_ANY:
-            return(BAD_CAST "wildcard (any)");
-        case XML_SCHEMA_EXTRA_QNAMEREF:
-            return(BAD_CAST "[helper component] QName reference");
-        case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
-            return(BAD_CAST "[helper component] attribute use prohibition");
-        default:
-            return(BAD_CAST "Not a schema component");
-    }
-}
-
-/**
- * xmlSchemaGetComponentTypeStr:
- * @type: the type of the schema item
- *
- * Returns the component name of a schema item.
- */
-static const xmlChar *
-xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_BASIC:
-            if (WXS_IS_COMPLEX(WXS_TYPE_CAST item))
-                return(BAD_CAST "complex type definition");
-            else
-                return(BAD_CAST "simple type definition");
-        default:
-            return(xmlSchemaItemTypeToStr(item->type));
-    }
-}
-
-/**
- * xmlSchemaGetComponentNode:
- * @item: a schema component
- *
- * Returns node associated with the schema component.
- * NOTE that such a node need not be available; plus, a component's
- * node need not to reflect the component directly, since there is no
- * one-to-one relationship between the XML Schema representation and
- * the component representation.
- */
-static xmlNodePtr
-xmlSchemaGetComponentNode(xmlSchemaBasicItemPtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return (((xmlSchemaElementPtr) item)->node);
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            return (((xmlSchemaAttributePtr) item)->node);
-        case XML_SCHEMA_TYPE_COMPLEX:
-        case XML_SCHEMA_TYPE_SIMPLE:
-            return (((xmlSchemaTypePtr) item)->node);
-        case XML_SCHEMA_TYPE_ANY:
-        case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
-            return (((xmlSchemaWildcardPtr) item)->node);
-        case XML_SCHEMA_TYPE_PARTICLE:
-            return (((xmlSchemaParticlePtr) item)->node);
-        case XML_SCHEMA_TYPE_SEQUENCE:
-        case XML_SCHEMA_TYPE_CHOICE:
-        case XML_SCHEMA_TYPE_ALL:
-            return (((xmlSchemaModelGroupPtr) item)->node);
-        case XML_SCHEMA_TYPE_GROUP:
-            return (((xmlSchemaModelGroupDefPtr) item)->node);
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            return (((xmlSchemaAttributeGroupPtr) item)->node);
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            return (((xmlSchemaIDCPtr) item)->node);
-        case XML_SCHEMA_EXTRA_QNAMEREF:
-            return(((xmlSchemaQNameRefPtr) item)->node);
-        /* TODO: What to do with NOTATIONs?
-        case XML_SCHEMA_TYPE_NOTATION:
-            return (((xmlSchemaNotationPtr) item)->node);
-        */
-        case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-            return (((xmlSchemaAttributeUsePtr) item)->node);
-        default:
-            return (NULL);
-    }
-}
-
-#if 0
-/**
- * xmlSchemaGetNextComponent:
- * @item: a schema component
- *
- * Returns the next sibling of the schema component.
- */
-static xmlSchemaBasicItemPtr
-xmlSchemaGetNextComponent(xmlSchemaBasicItemPtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaElementPtr) item)->next);
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaAttributePtr) item)->next);
-        case XML_SCHEMA_TYPE_COMPLEX:
-        case XML_SCHEMA_TYPE_SIMPLE:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaTypePtr) item)->next);
-        case XML_SCHEMA_TYPE_ANY:
-        case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
-            return (NULL);
-        case XML_SCHEMA_TYPE_PARTICLE:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaParticlePtr) item)->next);
-        case XML_SCHEMA_TYPE_SEQUENCE:
-        case XML_SCHEMA_TYPE_CHOICE:
-        case XML_SCHEMA_TYPE_ALL:
-            return (NULL);
-        case XML_SCHEMA_TYPE_GROUP:
-            return (NULL);
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaAttributeGroupPtr) item)->next);
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            return ((xmlSchemaBasicItemPtr) ((xmlSchemaIDCPtr) item)->next);
-        default:
-            return (NULL);
-    }
-}
-#endif
-
-
-/**
- * xmlSchemaFormatQName:
- * @buf: the string buffer
- * @namespaceName:  the namespace name
- * @localName: the local name
- *
- * Returns the given QName in the format "{namespaceName}localName" or
- * just "localName" if @namespaceName is NULL.
- *
- * Returns the localName if @namespaceName is NULL, a formatted
- * string otherwise.
- */
-static const xmlChar*
-xmlSchemaFormatQName(xmlChar **buf,
-                     const xmlChar *namespaceName,
-                     const xmlChar *localName)
-{
-    FREE_AND_NULL(*buf)
-    if (namespaceName != NULL) {
-        *buf = xmlStrdup(BAD_CAST "{");
-        *buf = xmlStrcat(*buf, namespaceName);
-        *buf = xmlStrcat(*buf, BAD_CAST "}");
-    }
-    if (localName != NULL) {
-        if (namespaceName == NULL)
-            return(localName);
-        *buf = xmlStrcat(*buf, localName);
-    } else {
-        *buf = xmlStrcat(*buf, BAD_CAST "(NULL)");
-    }
-    return ((const xmlChar *) *buf);
-}
-
-static const xmlChar*
-xmlSchemaFormatQNameNs(xmlChar **buf, xmlNsPtr ns, const xmlChar *localName)
-{
-    if (ns != NULL)
-        return (xmlSchemaFormatQName(buf, ns->href, localName));
-    else
-        return (xmlSchemaFormatQName(buf, NULL, localName));
-}
-
-static const xmlChar *
-xmlSchemaGetComponentName(xmlSchemaBasicItemPtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return (((xmlSchemaElementPtr) item)->name);
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            return (((xmlSchemaAttributePtr) item)->name);
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            return (((xmlSchemaAttributeGroupPtr) item)->name);
-        case XML_SCHEMA_TYPE_BASIC:
-        case XML_SCHEMA_TYPE_SIMPLE:
-        case XML_SCHEMA_TYPE_COMPLEX:
-            return (((xmlSchemaTypePtr) item)->name);
-        case XML_SCHEMA_TYPE_GROUP:
-            return (((xmlSchemaModelGroupDefPtr) item)->name);
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            return (((xmlSchemaIDCPtr) item)->name);
-        case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-            if (WXS_ATTRUSE_DECL(item) != NULL) {
-                return(xmlSchemaGetComponentName(
-                    WXS_BASIC_CAST WXS_ATTRUSE_DECL(item)));
-            } else
-                return(NULL);
-        case XML_SCHEMA_EXTRA_QNAMEREF:
-            return (((xmlSchemaQNameRefPtr) item)->name);
-        case XML_SCHEMA_TYPE_NOTATION:
-            return (((xmlSchemaNotationPtr) item)->name);
-        default:
-            /*
-            * Other components cannot have names.
-            */
-            break;
-    }
-    return (NULL);
-}
-
-#define xmlSchemaGetQNameRefName(r) (WXS_QNAME_CAST (r))->name
-#define xmlSchemaGetQNameRefTargetNs(r) (WXS_QNAME_CAST (r))->targetNamespace
-/*
-static const xmlChar *
-xmlSchemaGetQNameRefName(void *ref)
-{
-    return(((xmlSchemaQNameRefPtr) ref)->name);
-}
-
-static const xmlChar *
-xmlSchemaGetQNameRefTargetNs(void *ref)
-{
-    return(((xmlSchemaQNameRefPtr) ref)->targetNamespace);
-}
-*/
-
-static const xmlChar *
-xmlSchemaGetComponentTargetNs(xmlSchemaBasicItemPtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return (((xmlSchemaElementPtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            return (((xmlSchemaAttributePtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            return (((xmlSchemaAttributeGroupPtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_BASIC:
-            return (BAD_CAST "http://www.w3.org/2001/XMLSchema");
-        case XML_SCHEMA_TYPE_SIMPLE:
-        case XML_SCHEMA_TYPE_COMPLEX:
-            return (((xmlSchemaTypePtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_GROUP:
-            return (((xmlSchemaModelGroupDefPtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            return (((xmlSchemaIDCPtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-            if (WXS_ATTRUSE_DECL(item) != NULL) {
-                return(xmlSchemaGetComponentTargetNs(
-                    WXS_BASIC_CAST WXS_ATTRUSE_DECL(item)));
-            }
-            /* TODO: Will returning NULL break something? */
-            break;
-        case XML_SCHEMA_EXTRA_QNAMEREF:
-            return (((xmlSchemaQNameRefPtr) item)->targetNamespace);
-        case XML_SCHEMA_TYPE_NOTATION:
-            return (((xmlSchemaNotationPtr) item)->targetNamespace);
-        default:
-            /*
-            * Other components cannot have names.
-            */
-            break;
-    }
-    return (NULL);
-}
-
-static const xmlChar*
-xmlSchemaGetComponentQName(xmlChar **buf,
-                           void *item)
-{
-    return (xmlSchemaFormatQName(buf,
-        xmlSchemaGetComponentTargetNs((xmlSchemaBasicItemPtr) item),
-        xmlSchemaGetComponentName((xmlSchemaBasicItemPtr) item)));
-}
-
-static const xmlChar*
-xmlSchemaGetComponentDesignation(xmlChar **buf, void *item)
-{
-    xmlChar *str = NULL;
-
-    *buf = xmlStrcat(*buf, WXS_ITEM_TYPE_NAME(item));
-    *buf = xmlStrcat(*buf, BAD_CAST " '");
-    *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str,
-        (xmlSchemaBasicItemPtr) item));
-    *buf = xmlStrcat(*buf, BAD_CAST "'");
-    FREE_AND_NULL(str);
-    return(*buf);
-}
-
-static const xmlChar*
-xmlSchemaGetIDCDesignation(xmlChar **buf, xmlSchemaIDCPtr idc)
-{
-    return(xmlSchemaGetComponentDesignation(buf, idc));
-}
-
-/**
- * xmlSchemaWildcardPCToString:
- * @pc: the type of processContents
- *
- * Returns a string representation of the type of
- * processContents.
- */
-static const xmlChar *
-xmlSchemaWildcardPCToString(int pc)
-{
-    switch (pc) {
-        case XML_SCHEMAS_ANY_SKIP:
-            return (BAD_CAST "skip");
-        case XML_SCHEMAS_ANY_LAX:
-            return (BAD_CAST "lax");
-        case XML_SCHEMAS_ANY_STRICT:
-            return (BAD_CAST "strict");
-        default:
-            return (BAD_CAST "invalid process contents");
-    }
-}
-
-/**
- * xmlSchemaGetCanonValueWhtspExt:
- * @val: the precomputed value
- * @retValue: the returned value
- * @ws: the whitespace type of the value
- *
- * Get a the canonical representation of the value.
- * The caller has to free the returned retValue.
- *
- * Returns 0 if the value could be built and -1 in case of
- *         API errors or if the value type is not supported yet.
- */
-static int
-xmlSchemaGetCanonValueWhtspExt(xmlSchemaValPtr val,
-                               xmlSchemaWhitespaceValueType ws,
-                               xmlChar **retValue)
-{
-    int list;
-    xmlSchemaValType valType;
-    const xmlChar *value, *value2 = NULL;
-
-
-    if ((retValue == NULL) || (val == NULL))
-        return (-1);
-    list = xmlSchemaValueGetNext(val) ? 1 : 0;
-    *retValue = NULL;
-    do {
-        value = NULL;
-        valType = xmlSchemaGetValType(val);
-        switch (valType) {
-            case XML_SCHEMAS_STRING:
-            case XML_SCHEMAS_NORMSTRING:
-            case XML_SCHEMAS_ANYSIMPLETYPE:
-                value = xmlSchemaValueGetAsString(val);
-                if (value != NULL) {
-                    if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
-                        value2 = xmlSchemaCollapseString(value);
-                    else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
-                        value2 = xmlSchemaWhiteSpaceReplace(value);
-                    if (value2 != NULL)
-                        value = value2;
-                }
-                break;
-            default:
-                if (xmlSchemaGetCanonValue(val, &value2) == -1) {
-                    if (value2 != NULL)
-                        xmlFree((xmlChar *) value2);
-                    goto internal_error;
-                }
-                value = value2;
-        }
-        if (*retValue == NULL)
-            if (value == NULL) {
-                if (! list)
-                    *retValue = xmlStrdup(BAD_CAST "");
-            } else
-                *retValue = xmlStrdup(value);
-        else if (value != NULL) {
-            /* List. */
-            *retValue = xmlStrcat((xmlChar *) *retValue, BAD_CAST " ");
-            *retValue = xmlStrcat((xmlChar *) *retValue, value);
-        }
-        FREE_AND_NULL(value2)
-        val = xmlSchemaValueGetNext(val);
-    } while (val != NULL);
-
-    return (0);
-internal_error:
-    if (*retValue != NULL)
-        xmlFree((xmlChar *) (*retValue));
-    if (value2 != NULL)
-        xmlFree((xmlChar *) value2);
-    return (-1);
-}
-
-/**
- * xmlSchemaFormatItemForReport:
- * @buf: the string buffer
- * @itemDes: the designation of the item
- * @itemName: the name of the item
- * @item: the item as an object
- * @itemNode: the node of the item
- * @local: the local name
- * @parsing: if the function is used during the parse
- *
- * Returns a representation of the given item used
- * for error reports.
- *
- * The following order is used to build the resulting
- * designation if the arguments are not NULL:
- * 1a. If itemDes not NULL -> itemDes
- * 1b. If (itemDes not NULL) and (itemName not NULL)
- *     -> itemDes + itemName
- * 2. If the preceding was NULL and (item not NULL) -> item
- * 3. If the preceding was NULL and (itemNode not NULL) -> itemNode
- *
- * If the itemNode is an attribute node, the name of the attribute
- * will be appended to the result.
- *
- * Returns the formatted string and sets @buf to the resulting value.
- */
-static xmlChar*
-xmlSchemaFormatItemForReport(xmlChar **buf,
-                     const xmlChar *itemDes,
-                     xmlSchemaBasicItemPtr item,
-                     xmlNodePtr itemNode)
-{
-    xmlChar *str = NULL;
-    int named = 1;
-
-    if (*buf != NULL) {
-        xmlFree(*buf);
-        *buf = NULL;
-    }
-
-    if (itemDes != NULL) {
-        *buf = xmlStrdup(itemDes);
-    } else if (item != NULL) {
-        switch (item->type) {
-        case XML_SCHEMA_TYPE_BASIC: {
-            xmlSchemaTypePtr type = WXS_TYPE_CAST item;
-
-            if (WXS_IS_ATOMIC(type))
-                *buf = xmlStrdup(BAD_CAST "atomic type 'xs:");
-            else if (WXS_IS_LIST(type))
-                *buf = xmlStrdup(BAD_CAST "list type 'xs:");
-            else if (WXS_IS_UNION(type))
-                *buf = xmlStrdup(BAD_CAST "union type 'xs:");
-            else
-                *buf = xmlStrdup(BAD_CAST "simple type 'xs:");
-            *buf = xmlStrcat(*buf, type->name);
-            *buf = xmlStrcat(*buf, BAD_CAST "'");
-            }
-            break;
-        case XML_SCHEMA_TYPE_SIMPLE: {
-            xmlSchemaTypePtr type = WXS_TYPE_CAST item;
-
-            if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
-                *buf = xmlStrdup(BAD_CAST"");
-            } else {
-                *buf = xmlStrdup(BAD_CAST "local ");
-            }
-            if (WXS_IS_ATOMIC(type))
-                *buf = xmlStrcat(*buf, BAD_CAST "atomic type");
-            else if (WXS_IS_LIST(type))
-                *buf = xmlStrcat(*buf, BAD_CAST "list type");
-            else if (WXS_IS_UNION(type))
-                *buf = xmlStrcat(*buf, BAD_CAST "union type");
-            else
-                *buf = xmlStrcat(*buf, BAD_CAST "simple type");
-            if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, type->name);
-                *buf = xmlStrcat(*buf, BAD_CAST "'");
-            }
-            }
-            break;
-        case XML_SCHEMA_TYPE_COMPLEX: {
-            xmlSchemaTypePtr type = WXS_TYPE_CAST item;
-
-            if (type->flags & XML_SCHEMAS_TYPE_GLOBAL)
-                *buf = xmlStrdup(BAD_CAST "");
-            else
-                *buf = xmlStrdup(BAD_CAST "local ");
-            *buf = xmlStrcat(*buf, BAD_CAST "complex type");
-            if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, type->name);
-                *buf = xmlStrcat(*buf, BAD_CAST "'");
-            }
-            }
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTE_USE: {
-                xmlSchemaAttributeUsePtr ause;
-
-                ause = WXS_ATTR_USE_CAST item;
-                *buf = xmlStrdup(BAD_CAST "attribute use ");
-                if (WXS_ATTRUSE_DECL(ause) != NULL) {
-                    *buf = xmlStrcat(*buf, BAD_CAST "'");
-                    *buf = xmlStrcat(*buf,
-                        xmlSchemaGetComponentQName(&str, WXS_ATTRUSE_DECL(ause)));
-                    FREE_AND_NULL(str)
-                        *buf = xmlStrcat(*buf, BAD_CAST "'");
-                } else {
-                    *buf = xmlStrcat(*buf, BAD_CAST "(unknown)");
-                }
-            }
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTE: {
-                xmlSchemaAttributePtr attr;
-
-                attr = (xmlSchemaAttributePtr) item;
-                *buf = xmlStrdup(BAD_CAST "attribute decl.");
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
-                    attr->targetNamespace, attr->name));
-                FREE_AND_NULL(str)
-                    *buf = xmlStrcat(*buf, BAD_CAST "'");
-            }
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            xmlSchemaGetComponentDesignation(buf, item);
-            break;
-        case XML_SCHEMA_TYPE_ELEMENT: {
-                xmlSchemaElementPtr elem;
-
-                elem = (xmlSchemaElementPtr) item;
-                *buf = xmlStrdup(BAD_CAST "element decl.");
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
-                    elem->targetNamespace, elem->name));
-                *buf = xmlStrcat(*buf, BAD_CAST "'");
-            }
-            break;
-        case XML_SCHEMA_TYPE_IDC_UNIQUE:
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-            if (item->type == XML_SCHEMA_TYPE_IDC_UNIQUE)
-                *buf = xmlStrdup(BAD_CAST "unique '");
-            else if (item->type == XML_SCHEMA_TYPE_IDC_KEY)
-                *buf = xmlStrdup(BAD_CAST "key '");
-            else
-                *buf = xmlStrdup(BAD_CAST "keyRef '");
-            *buf = xmlStrcat(*buf, ((xmlSchemaIDCPtr) item)->name);
-            *buf = xmlStrcat(*buf, BAD_CAST "'");
-            break;
-        case XML_SCHEMA_TYPE_ANY:
-        case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
-            *buf = xmlStrdup(xmlSchemaWildcardPCToString(
-                    ((xmlSchemaWildcardPtr) item)->processContents));
-            *buf = xmlStrcat(*buf, BAD_CAST " wildcard");
-            break;
-        case XML_SCHEMA_FACET_MININCLUSIVE:
-        case XML_SCHEMA_FACET_MINEXCLUSIVE:
-        case XML_SCHEMA_FACET_MAXINCLUSIVE:
-        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-        case XML_SCHEMA_FACET_TOTALDIGITS:
-        case XML_SCHEMA_FACET_FRACTIONDIGITS:
-        case XML_SCHEMA_FACET_PATTERN:
-        case XML_SCHEMA_FACET_ENUMERATION:
-        case XML_SCHEMA_FACET_WHITESPACE:
-        case XML_SCHEMA_FACET_LENGTH:
-        case XML_SCHEMA_FACET_MAXLENGTH:
-        case XML_SCHEMA_FACET_MINLENGTH:
-            *buf = xmlStrdup(BAD_CAST "facet '");
-            *buf = xmlStrcat(*buf, xmlSchemaFacetTypeToString(item->type));
-            *buf = xmlStrcat(*buf, BAD_CAST "'");
-            break;
-        case XML_SCHEMA_TYPE_GROUP: {
-                *buf = xmlStrdup(BAD_CAST "model group def.");
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item));
-                *buf = xmlStrcat(*buf, BAD_CAST "'");
-                FREE_AND_NULL(str)
-            }
-            break;
-        case XML_SCHEMA_TYPE_SEQUENCE:
-        case XML_SCHEMA_TYPE_CHOICE:
-        case XML_SCHEMA_TYPE_ALL:
-        case XML_SCHEMA_TYPE_PARTICLE:
-            *buf = xmlStrdup(WXS_ITEM_TYPE_NAME(item));
-            break;
-        case XML_SCHEMA_TYPE_NOTATION: {
-                *buf = xmlStrdup(WXS_ITEM_TYPE_NAME(item));
-                *buf = xmlStrcat(*buf, BAD_CAST " '");
-                *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item));
-                *buf = xmlStrcat(*buf, BAD_CAST "'");
-                FREE_AND_NULL(str);
-            }
-        default:
-            named = 0;
-        }
-    } else
-        named = 0;
-
-    if ((named == 0) && (itemNode != NULL)) {
-        xmlNodePtr elem;
-
-        if (itemNode->type == XML_ATTRIBUTE_NODE)
-            elem = itemNode->parent;
-        else
-            elem = itemNode;
-        *buf = xmlStrdup(BAD_CAST "Element '");
-        if (elem->ns != NULL) {
-            *buf = xmlStrcat(*buf,
-                xmlSchemaFormatQName(&str, elem->ns->href, elem->name));
-            FREE_AND_NULL(str)
-        } else
-            *buf = xmlStrcat(*buf, elem->name);
-        *buf = xmlStrcat(*buf, BAD_CAST "'");
-
-    }
-    if ((itemNode != NULL) && (itemNode->type == XML_ATTRIBUTE_NODE)) {
-        *buf = xmlStrcat(*buf, BAD_CAST ", attribute '");
-        if (itemNode->ns != NULL) {
-            *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
-                itemNode->ns->href, itemNode->name));
-            FREE_AND_NULL(str)
-        } else
-            *buf = xmlStrcat(*buf, itemNode->name);
-        *buf = xmlStrcat(*buf, BAD_CAST "'");
-    }
-    FREE_AND_NULL(str)
-
-    return (xmlEscapeFormatString(buf));
-}
-
-/**
- * xmlSchemaFormatFacetEnumSet:
- * @buf: the string buffer
- * @type: the type holding the enumeration facets
- *
- * Builds a string consisting of all enumeration elements.
- *
- * Returns a string of all enumeration elements.
- */
-static const xmlChar *
-xmlSchemaFormatFacetEnumSet(xmlSchemaAbstractCtxtPtr actxt,
-                            xmlChar **buf, xmlSchemaTypePtr type)
-{
-    xmlSchemaFacetPtr facet;
-    xmlSchemaWhitespaceValueType ws;
-    xmlChar *value = NULL;
-    int res, found = 0;
-
-    if (*buf != NULL)
-        xmlFree(*buf);
-    *buf = NULL;
-
-    do {
-        /*
-        * Use the whitespace type of the base type.
-        */
-        ws = xmlSchemaGetWhiteSpaceFacetValue(type->baseType);
-        for (facet = type->facets; facet != NULL; facet = facet->next) {
-            if (facet->type != XML_SCHEMA_FACET_ENUMERATION)
-                continue;
-            found = 1;
-            res = xmlSchemaGetCanonValueWhtspExt(facet->val,
-                ws, &value);
-            if (res == -1) {
-                xmlSchemaInternalErr(actxt,
-                    "xmlSchemaFormatFacetEnumSet",
-                    "compute the canonical lexical representation");
-                if (*buf != NULL)
-                    xmlFree(*buf);
-                *buf = NULL;
-                return (NULL);
-            }
-            if (*buf == NULL)
-                *buf = xmlStrdup(BAD_CAST "'");
-            else
-                *buf = xmlStrcat(*buf, BAD_CAST ", '");
-            *buf = xmlStrcat(*buf, BAD_CAST value);
-            *buf = xmlStrcat(*buf, BAD_CAST "'");
-            if (value != NULL) {
-                xmlFree((xmlChar *)value);
-                value = NULL;
-            }
-        }
-        /*
-        * The enumeration facet of a type restricts the enumeration
-        * facet of the ancestor type; i.e., such restricted enumerations
-        * do not belong to the set of the given type. Thus we break
-        * on the first found enumeration.
-        */
-        if (found)
-            break;
-        type = type->baseType;
-    } while ((type != NULL) && (type->type != XML_SCHEMA_TYPE_BASIC));
-
-    return ((const xmlChar *) *buf);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Error functions                                 *
- *                                                                      *
- ************************************************************************/
-
-#if 0
-static void
-xmlSchemaErrMemory(const char *msg)
-{
-    __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, NULL, NULL,
-                     msg);
-}
-#endif
-
-static void
-xmlSchemaPSimpleErr(const char *msg)
-{
-    __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, NULL, NULL,
-                     msg);
-}
-
-/**
- * xmlSchemaPErrMemory:
- * @node: a context node
- * @extra:  extra informations
- *
- * Handle an out of memory condition
- */
-static void
-xmlSchemaPErrMemory(xmlSchemaParserCtxtPtr ctxt,
-                    const char *extra, xmlNodePtr node)
-{
-    if (ctxt != NULL)
-        ctxt->nberrors++;
-    __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, node, NULL,
-                     extra);
-}
-
-/**
- * xmlSchemaPErr:
- * @ctxt: the parsing context
- * @node: the context node
- * @error: the error code
- * @msg: the error message
- * @str1: extra data
- * @str2: extra data
- *
- * Handle a parser error
- */
-static void LIBXML_ATTR_FORMAT(4,0)
-xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
-              const char *msg, const xmlChar * str1, const xmlChar * str2)
-{
-    xmlGenericErrorFunc channel = NULL;
-    xmlStructuredErrorFunc schannel = NULL;
-    void *data = NULL;
-
-    if (ctxt != NULL) {
-        ctxt->nberrors++;
-        ctxt->err = error;
-        channel = ctxt->error;
-        data = ctxt->errCtxt;
-        schannel = ctxt->serror;
-    }
-    __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
-                    error, XML_ERR_ERROR, NULL, 0,
-                    (const char *) str1, (const char *) str2, NULL, 0, 0,
-                    msg, str1, str2);
-}
-
-/**
- * xmlSchemaPErr2:
- * @ctxt: the parsing context
- * @node: the context node
- * @node: the current child
- * @error: the error code
- * @msg: the error message
- * @str1: extra data
- * @str2: extra data
- *
- * Handle a parser error
- */
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
-               xmlNodePtr child, int error,
-               const char *msg, const xmlChar * str1, const xmlChar * str2)
-{
-    if (child != NULL)
-        xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
-    else
-        xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
-}
-
-
-/**
- * xmlSchemaPErrExt:
- * @ctxt: the parsing context
- * @node: the context node
- * @error: the error code
- * @strData1: extra data
- * @strData2: extra data
- * @strData3: extra data
- * @msg: the message
- * @str1:  extra parameter for the message display
- * @str2:  extra parameter for the message display
- * @str3:  extra parameter for the message display
- * @str4:  extra parameter for the message display
- * @str5:  extra parameter for the message display
- *
- * Handle a parser error
- */
-static void LIBXML_ATTR_FORMAT(7,0)
-xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
-                const xmlChar * strData1, const xmlChar * strData2,
-                const xmlChar * strData3, const char *msg, const xmlChar * str1,
-                const xmlChar * str2, const xmlChar * str3, const xmlChar * str4,
-                const xmlChar * str5)
-{
-
-    xmlGenericErrorFunc channel = NULL;
-    xmlStructuredErrorFunc schannel = NULL;
-    void *data = NULL;
-
-    if (ctxt != NULL) {
-        ctxt->nberrors++;
-        ctxt->err = error;
-        channel = ctxt->error;
-        data = ctxt->errCtxt;
-        schannel = ctxt->serror;
-    }
-    __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
-                    error, XML_ERR_ERROR, NULL, 0,
-                    (const char *) strData1, (const char *) strData2,
-                    (const char *) strData3, 0, 0, msg, str1, str2,
-                    str3, str4, str5);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Allround error functions                        *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaVTypeErrMemory:
- * @node: a context node
- * @extra:  extra informations
- *
- * Handle an out of memory condition
- */
-static void
-xmlSchemaVErrMemory(xmlSchemaValidCtxtPtr ctxt,
-                    const char *extra, xmlNodePtr node)
-{
-    if (ctxt != NULL) {
-        ctxt->nberrors++;
-        ctxt->err = XML_SCHEMAV_INTERNAL;
-    }
-    __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
-                     extra);
-}
-
-static void LIBXML_ATTR_FORMAT(2,0)
-xmlSchemaPSimpleInternalErr(xmlNodePtr node,
-                            const char *msg, const xmlChar *str)
-{
-     __xmlSimpleError(XML_FROM_SCHEMASP, XML_SCHEMAP_INTERNAL, node,
-         msg, (const char *) str);
-}
-
-#define WXS_ERROR_TYPE_ERROR 1
-#define WXS_ERROR_TYPE_WARNING 2
-/**
- * xmlSchemaErr4Line:
- * @ctxt: the validation context
- * @errorLevel: the error level
- * @error: the error code
- * @node: the context node
- * @line: the line number
- * @msg: the error message
- * @str1: extra data
- * @str2: extra data
- * @str3: extra data
- * @str4: extra data
- *
- * Handle a validation error
- */
-static void LIBXML_ATTR_FORMAT(6,0)
-xmlSchemaErr4Line(xmlSchemaAbstractCtxtPtr ctxt,
-                  xmlErrorLevel errorLevel,
-                  int error, xmlNodePtr node, int line, const char *msg,
-                  const xmlChar *str1, const xmlChar *str2,
-                  const xmlChar *str3, const xmlChar *str4)
-{
-    xmlStructuredErrorFunc schannel = NULL;
-    xmlGenericErrorFunc channel = NULL;
-    void *data = NULL;
-
-    if (ctxt != NULL) {
-        if (ctxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
-            xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctxt;
-            const char *file = NULL;
-            int col = 0;
-            if (errorLevel != XML_ERR_WARNING) {
-                vctxt->nberrors++;
-                vctxt->err = error;
-                channel = vctxt->error;
-            } else {
-                channel = vctxt->warning;
-            }
-            schannel = vctxt->serror;
-            data = vctxt->errCtxt;
-
-            /*
-            * Error node. If we specify a line number, then
-            * do not channel any node to the error function.
-            */
-            if (line == 0) {
-                if ((node == NULL) &&
-                    (vctxt->depth >= 0) &&
-                    (vctxt->inode != NULL)) {
-                    node = vctxt->inode->node;
-                }
-                /*
-                * Get filename and line if no node-tree.
-                */
-                if ((node == NULL) &&
-                    (vctxt->parserCtxt != NULL) &&
-                    (vctxt->parserCtxt->input != NULL)) {
-                    file = vctxt->parserCtxt->input->filename;
-                    line = vctxt->parserCtxt->input->line;
-                    col = vctxt->parserCtxt->input->col;
-                }
-            } else {
-                /*
-                * Override the given node's (if any) position
-                * and channel only the given line number.
-                */
-                node = NULL;
-                /*
-                * Get filename.
-                */
-                if (vctxt->doc != NULL)
-                    file = (const char *) vctxt->doc->URL;
-                else if ((vctxt->parserCtxt != NULL) &&
-                    (vctxt->parserCtxt->input != NULL))
-                    file = vctxt->parserCtxt->input->filename;
-            }
-            if (vctxt->locFunc != NULL) {
-                if ((file == NULL) || (line == 0)) {
-                    unsigned long l;
-                    const char *f;
-                    vctxt->locFunc(vctxt->locCtxt, &f, &l);
-                    if (file == NULL)
-                        file = f;
-                    if (line == 0)
-                        line = (int) l;
-                }
-            }
-            if ((file == NULL) && (vctxt->filename != NULL))
-                file = vctxt->filename;
-
-            __xmlRaiseError(schannel, channel, data, ctxt,
-                node, XML_FROM_SCHEMASV,
-                error, errorLevel, file, line,
-                (const char *) str1, (const char *) str2,
-                (const char *) str3, 0, col, msg, str1, str2, str3, str4);
-
-        } else if (ctxt->type == XML_SCHEMA_CTXT_PARSER) {
-            xmlSchemaParserCtxtPtr pctxt = (xmlSchemaParserCtxtPtr) ctxt;
-            if (errorLevel != XML_ERR_WARNING) {
-                pctxt->nberrors++;
-                pctxt->err = error;
-                channel = pctxt->error;
-            } else {
-                channel = pctxt->warning;
-            }
-            schannel = pctxt->serror;
-            data = pctxt->errCtxt;
-            __xmlRaiseError(schannel, channel, data, ctxt,
-                node, XML_FROM_SCHEMASP, error,
-                errorLevel, NULL, 0,
-                (const char *) str1, (const char *) str2,
-                (const char *) str3, 0, 0, msg, str1, str2, str3, str4);
-        } else {
-            TODO
-        }
-    }
-}
-
-/**
- * xmlSchemaErr3:
- * @ctxt: the validation context
- * @node: the context node
- * @error: the error code
- * @msg: the error message
- * @str1: extra data
- * @str2: extra data
- * @str3: extra data
- *
- * Handle a validation error
- */
-static void LIBXML_ATTR_FORMAT(4,0)
-xmlSchemaErr3(xmlSchemaAbstractCtxtPtr actxt,
-              int error, xmlNodePtr node, const char *msg,
-              const xmlChar *str1, const xmlChar *str2, const xmlChar *str3)
-{
-    xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
-        msg, str1, str2, str3, NULL);
-}
-
-static void LIBXML_ATTR_FORMAT(4,0)
-xmlSchemaErr4(xmlSchemaAbstractCtxtPtr actxt,
-              int error, xmlNodePtr node, const char *msg,
-              const xmlChar *str1, const xmlChar *str2,
-              const xmlChar *str3, const xmlChar *str4)
-{
-    xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
-        msg, str1, str2, str3, str4);
-}
-
-static void LIBXML_ATTR_FORMAT(4,0)
-xmlSchemaErr(xmlSchemaAbstractCtxtPtr actxt,
-             int error, xmlNodePtr node, const char *msg,
-             const xmlChar *str1, const xmlChar *str2)
-{
-    xmlSchemaErr4(actxt, error, node, msg, str1, str2, NULL, NULL);
-}
-
-static xmlChar *
-xmlSchemaFormatNodeForError(xmlChar ** msg,
-                            xmlSchemaAbstractCtxtPtr actxt,
-                            xmlNodePtr node)
-{
-    xmlChar *str = NULL;
-
-    *msg = NULL;
-    if ((node != NULL) &&
-        (node->type != XML_ELEMENT_NODE) &&
-        (node->type != XML_ATTRIBUTE_NODE))
-    {
-        /*
-        * Don't try to format other nodes than element and
-        * attribute nodes.
-        * Play safe and return an empty string.
-        */
-        *msg = xmlStrdup(BAD_CAST "");
-        return(*msg);
-    }
-    if (node != NULL) {
-        /*
-        * Work on tree nodes.
-        */
-        if (node->type == XML_ATTRIBUTE_NODE) {
-            xmlNodePtr elem = node->parent;
-
-            *msg = xmlStrdup(BAD_CAST "Element '");
-            if (elem->ns != NULL)
-                *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-                    elem->ns->href, elem->name));
-            else
-                *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-                    NULL, elem->name));
-            FREE_AND_NULL(str);
-            *msg = xmlStrcat(*msg, BAD_CAST "', ");
-            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
-        } else {
-            *msg = xmlStrdup(BAD_CAST "Element '");
-        }
-        if (node->ns != NULL)
-            *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-            node->ns->href, node->name));
-        else
-            *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-            NULL, node->name));
-        FREE_AND_NULL(str);
-        *msg = xmlStrcat(*msg, BAD_CAST "': ");
-    } else if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
-        xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) actxt;
-        /*
-        * Work on node infos.
-        */
-        if (vctxt->inode->nodeType == XML_ATTRIBUTE_NODE) {
-            xmlSchemaNodeInfoPtr ielem =
-                vctxt->elemInfos[vctxt->depth];
-
-            *msg = xmlStrdup(BAD_CAST "Element '");
-            *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-                ielem->nsName, ielem->localName));
-            FREE_AND_NULL(str);
-            *msg = xmlStrcat(*msg, BAD_CAST "', ");
-            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
-        } else {
-            *msg = xmlStrdup(BAD_CAST "Element '");
-        }
-        *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
-            vctxt->inode->nsName, vctxt->inode->localName));
-        FREE_AND_NULL(str);
-        *msg = xmlStrcat(*msg, BAD_CAST "': ");
-    } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
-        /*
-        * Hmm, no node while parsing?
-        * Return an empty string, in case NULL will break something.
-        */
-        *msg = xmlStrdup(BAD_CAST "");
-    } else {
-        TODO
-        return (NULL);
-    }
-
-    /*
-     * xmlSchemaFormatItemForReport() also returns an escaped format
-     * string, so do this before calling it below (in the future).
-     */
-    xmlEscapeFormatString(msg);
-
-    /*
-    * VAL TODO: The output of the given schema component is currently
-    * disabled.
-    */
-#if 0
-    if ((type != NULL) && (xmlSchemaIsGlobalItem(type))) {
-        *msg = xmlStrcat(*msg, BAD_CAST " [");
-        *msg = xmlStrcat(*msg, xmlSchemaFormatItemForReport(&str,
-            NULL, type, NULL, 0));
-        FREE_AND_NULL(str)
-        *msg = xmlStrcat(*msg, BAD_CAST "]");
-    }
-#endif
-    return (*msg);
-}
-
-static void LIBXML_ATTR_FORMAT(3,0)
-xmlSchemaInternalErr2(xmlSchemaAbstractCtxtPtr actxt,
-                     const char *funcName,
-                     const char *message,
-                     const xmlChar *str1,
-                     const xmlChar *str2)
-{
-    xmlChar *msg = NULL;
-
-    if (actxt == NULL)
-        return;
-    msg = xmlStrdup(BAD_CAST "Internal error: %s, ");
-    msg = xmlStrcat(msg, BAD_CAST message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-
-    if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR)
-        xmlSchemaErr3(actxt, XML_SCHEMAV_INTERNAL, NULL,
-            (const char *) msg, (const xmlChar *) funcName, str1, str2);
-    else if (actxt->type == XML_SCHEMA_CTXT_PARSER)
-        xmlSchemaErr3(actxt, XML_SCHEMAP_INTERNAL, NULL,
-            (const char *) msg, (const xmlChar *) funcName, str1, str2);
-
-    FREE_AND_NULL(msg)
-}
-
-static void LIBXML_ATTR_FORMAT(3,0)
-xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
-                     const char *funcName,
-                     const char *message)
-{
-    xmlSchemaInternalErr2(actxt, funcName, message, NULL, NULL);
-}
-
-#if 0
-static void LIBXML_ATTR_FORMAT(3,0)
-xmlSchemaPInternalErr(xmlSchemaParserCtxtPtr pctxt,
-                     const char *funcName,
-                     const char *message,
-                     const xmlChar *str1,
-                     const xmlChar *str2)
-{
-    xmlSchemaInternalErr2(ACTXT_CAST pctxt, funcName, message,
-        str1, str2);
-}
-#endif
-
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaCustomErr4(xmlSchemaAbstractCtxtPtr actxt,
-                   xmlParserErrors error,
-                   xmlNodePtr node,
-                   xmlSchemaBasicItemPtr item,
-                   const char *message,
-                   const xmlChar *str1, const xmlChar *str2,
-                   const xmlChar *str3, const xmlChar *str4)
-{
-    xmlChar *msg = NULL;
-
-    if ((node == NULL) && (item != NULL) &&
-        (actxt->type == XML_SCHEMA_CTXT_PARSER)) {
-        node = WXS_ITEM_NODE(item);
-        xmlSchemaFormatItemForReport(&msg, NULL, item, NULL);
-        msg = xmlStrcat(msg, BAD_CAST ": ");
-    } else
-        xmlSchemaFormatNodeForError(&msg, actxt, node);
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-    xmlSchemaErr4(actxt, error, node,
-        (const char *) msg, str1, str2, str3, str4);
-    FREE_AND_NULL(msg)
-}
-
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaCustomErr(xmlSchemaAbstractCtxtPtr actxt,
-                   xmlParserErrors error,
-                   xmlNodePtr node,
-                   xmlSchemaBasicItemPtr item,
-                   const char *message,
-                   const xmlChar *str1,
-                   const xmlChar *str2)
-{
-    xmlSchemaCustomErr4(actxt, error, node, item,
-        message, str1, str2, NULL, NULL);
-}
-
-
-
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaCustomWarning(xmlSchemaAbstractCtxtPtr actxt,
-                   xmlParserErrors error,
-                   xmlNodePtr node,
-                   xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
-                   const char *message,
-                   const xmlChar *str1,
-                   const xmlChar *str2,
-                   const xmlChar *str3)
-{
-    xmlChar *msg = NULL;
-
-    xmlSchemaFormatNodeForError(&msg, actxt, node);
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-
-    /* URGENT TODO: Set the error code to something sane. */
-    xmlSchemaErr4Line(actxt, XML_ERR_WARNING, error, node, 0,
-        (const char *) msg, str1, str2, str3, NULL);
-
-    FREE_AND_NULL(msg)
-}
-
-
-
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaKeyrefErr(xmlSchemaValidCtxtPtr vctxt,
-                   xmlParserErrors error,
-                   xmlSchemaPSVIIDCNodePtr idcNode,
-                   xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
-                   const char *message,
-                   const xmlChar *str1,
-                   const xmlChar *str2)
-{
-    xmlChar *msg = NULL, *qname = NULL;
-
-    msg = xmlStrdup(BAD_CAST "Element '%s': ");
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-    xmlSchemaErr4Line(ACTXT_CAST vctxt, XML_ERR_ERROR,
-        error, NULL, idcNode->nodeLine, (const char *) msg,
-        xmlSchemaFormatQName(&qname,
-            vctxt->nodeQNames->items[idcNode->nodeQNameID +1],
-            vctxt->nodeQNames->items[idcNode->nodeQNameID]),
-        str1, str2, NULL);
-    FREE_AND_NULL(qname);
-    FREE_AND_NULL(msg);
-}
-
-static int
-xmlSchemaEvalErrorNodeType(xmlSchemaAbstractCtxtPtr actxt,
-                           xmlNodePtr node)
-{
-    if (node != NULL)
-        return (node->type);
-    if ((actxt->type == XML_SCHEMA_CTXT_VALIDATOR) &&
-        (((xmlSchemaValidCtxtPtr) actxt)->inode != NULL))
-        return ( ((xmlSchemaValidCtxtPtr) actxt)->inode->nodeType);
-    return (-1);
-}
-
-static int
-xmlSchemaIsGlobalItem(xmlSchemaTypePtr item)
-{
-    switch (item->type) {
-        case XML_SCHEMA_TYPE_COMPLEX:
-        case XML_SCHEMA_TYPE_SIMPLE:
-            if (item->flags & XML_SCHEMAS_TYPE_GLOBAL)
-                return(1);
-            break;
-        case XML_SCHEMA_TYPE_GROUP:
-            return (1);
-        case XML_SCHEMA_TYPE_ELEMENT:
-            if ( ((xmlSchemaElementPtr) item)->flags &
-                XML_SCHEMAS_ELEM_GLOBAL)
-                return(1);
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTE:
-            if ( ((xmlSchemaAttributePtr) item)->flags &
-                XML_SCHEMAS_ATTR_GLOBAL)
-                return(1);
-            break;
-        /* Note that attribute groups are always global. */
-        default:
-            return(1);
-    }
-    return (0);
-}
-
-static void
-xmlSchemaSimpleTypeErr(xmlSchemaAbstractCtxtPtr actxt,
-                       xmlParserErrors error,
-                       xmlNodePtr node,
-                       const xmlChar *value,
-                       xmlSchemaTypePtr type,
-                       int displayValue)
-{
-    xmlChar *msg = NULL;
-
-    xmlSchemaFormatNodeForError(&msg, actxt, node);
-
-    if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
-            XML_ATTRIBUTE_NODE))
-        msg = xmlStrcat(msg, BAD_CAST "'%s' is not a valid value of ");
-    else
-        msg = xmlStrcat(msg, BAD_CAST "The character content is not a valid "
-            "value of ");
-
-    if (! xmlSchemaIsGlobalItem(type))
-        msg = xmlStrcat(msg, BAD_CAST "the local ");
-    else
-        msg = xmlStrcat(msg, BAD_CAST "the ");
-
-    if (WXS_IS_ATOMIC(type))
-        msg = xmlStrcat(msg, BAD_CAST "atomic type");
-    else if (WXS_IS_LIST(type))
-        msg = xmlStrcat(msg, BAD_CAST "list type");
-    else if (WXS_IS_UNION(type))
-        msg = xmlStrcat(msg, BAD_CAST "union type");
-
-    if (xmlSchemaIsGlobalItem(type)) {
-        xmlChar *str = NULL;
-        msg = xmlStrcat(msg, BAD_CAST " '");
-        if (type->builtInType != 0) {
-            msg = xmlStrcat(msg, BAD_CAST "xs:");
-            str = xmlStrdup(type->name);
-        } else {
-            const xmlChar *qName = xmlSchemaFormatQName(&str, type->targetNamespace, type->name);
-            if (!str)
-                str = xmlStrdup(qName);
-        }
-        msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
-        msg = xmlStrcat(msg, BAD_CAST "'");
-        FREE_AND_NULL(str);
-    }
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-    if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
-            XML_ATTRIBUTE_NODE))
-        xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
-    else
-        xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
-    FREE_AND_NULL(msg)
-}
-
-static const xmlChar *
-xmlSchemaFormatErrorNodeQName(xmlChar ** str,
-                              xmlSchemaNodeInfoPtr ni,
-                              xmlNodePtr node)
-{
-    if (node != NULL) {
-        if (node->ns != NULL)
-            return (xmlSchemaFormatQName(str, node->ns->href, node->name));
-        else
-            return (xmlSchemaFormatQName(str, NULL, node->name));
-    } else if (ni != NULL)
-        return (xmlSchemaFormatQName(str, ni->nsName, ni->localName));
-    return (NULL);
-}
-
-static void
-xmlSchemaIllegalAttrErr(xmlSchemaAbstractCtxtPtr actxt,
-                        xmlParserErrors error,
-                        xmlSchemaAttrInfoPtr ni,
-                        xmlNodePtr node)
-{
-    xmlChar *msg = NULL, *str = NULL;
-
-    xmlSchemaFormatNodeForError(&msg, actxt, node);
-    msg = xmlStrcat(msg, BAD_CAST "The attribute '%s' is not allowed.\n");
-    xmlSchemaErr(actxt, error, node, (const char *) msg,
-        xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node),
-        NULL);
-    FREE_AND_NULL(str)
-    FREE_AND_NULL(msg)
-}
-
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaComplexTypeErr(xmlSchemaAbstractCtxtPtr actxt,
-                        xmlParserErrors error,
-                        xmlNodePtr node,
-                        xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
-                        const char *message,
-                        int nbval,
-                        int nbneg,
-                        xmlChar **values)
-{
-    xmlChar *str = NULL, *msg = NULL;
-    xmlChar *localName, *nsName;
-    const xmlChar *cur, *end;
-    int i;
-
-    xmlSchemaFormatNodeForError(&msg, actxt, node);
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".");
-    /*
-    * Note that is does not make sense to report that we have a
-    * wildcard here, since the wildcard might be unfolded into
-    * multiple transitions.
-    */
-    if (nbval + nbneg > 0) {
-        if (nbval + nbneg > 1) {
-            str = xmlStrdup(BAD_CAST " Expected is one of ( ");
-        } else
-            str = xmlStrdup(BAD_CAST " Expected is ( ");
-        nsName = NULL;
-
-        for (i = 0; i < nbval + nbneg; i++) {
-            cur = values[i];
-            if (cur == NULL)
-                continue;
-            if ((cur[0] == 'n') && (cur[1] == 'o') && (cur[2] == 't') &&
-                (cur[3] == ' ')) {
-                cur += 4;
-                str = xmlStrcat(str, BAD_CAST "##other");
-            }
-            /*
-            * Get the local name.
-            */
-            localName = NULL;
-
-            end = cur;
-            if (*end == '*') {
-                localName = xmlStrdup(BAD_CAST "*");
-                end++;
-            } else {
-                while ((*end != 0) && (*end != '|'))
-                    end++;
-                localName = xmlStrncat(localName, BAD_CAST cur, end - cur);
-            }
-            if (*end != 0) {
-                end++;
-                /*
-                * Skip "*|*" if they come with negated expressions, since
-                * they represent the same negated wildcard.
-                */
-                if ((nbneg == 0) || (*end != '*') || (*localName != '*')) {
-                    /*
-                    * Get the namespace name.
-                    */
-                    cur = end;
-                    if (*end == '*') {
-                        nsName = xmlStrdup(BAD_CAST "{*}");
-                    } else {
-                        while (*end != 0)
-                            end++;
-
-                        if (i >= nbval)
-                            nsName = xmlStrdup(BAD_CAST "{##other:");
-                        else
-                            nsName = xmlStrdup(BAD_CAST "{");
-
-                        nsName = xmlStrncat(nsName, BAD_CAST cur, end - cur);
-                        nsName = xmlStrcat(nsName, BAD_CAST "}");
-                    }
-                    str = xmlStrcat(str, BAD_CAST nsName);
-                    FREE_AND_NULL(nsName)
-                } else {
-                    FREE_AND_NULL(localName);
-                    continue;
-                }
-            }
-            str = xmlStrcat(str, BAD_CAST localName);
-            FREE_AND_NULL(localName);
-
-            if (i < nbval + nbneg -1)
-                str = xmlStrcat(str, BAD_CAST ", ");
-        }
-        str = xmlStrcat(str, BAD_CAST " ).\n");
-        msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
-        FREE_AND_NULL(str)
-    } else
-      msg = xmlStrcat(msg, BAD_CAST "\n");
-    xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
-    xmlFree(msg);
-}
-
-static void LIBXML_ATTR_FORMAT(8,0)
-xmlSchemaFacetErr(xmlSchemaAbstractCtxtPtr actxt,
-                  xmlParserErrors error,
-                  xmlNodePtr node,
-                  const xmlChar *value,
-                  unsigned long length,
-                  xmlSchemaTypePtr type,
-                  xmlSchemaFacetPtr facet,
-                  const char *message,
-                  const xmlChar *str1,
-                  const xmlChar *str2)
-{
-    xmlChar *str = NULL, *msg = NULL;
-    xmlSchemaTypeType facetType;
-    int nodeType = xmlSchemaEvalErrorNodeType(actxt, node);
-
-    xmlSchemaFormatNodeForError(&msg, actxt, node);
-    if (error == XML_SCHEMAV_CVC_ENUMERATION_VALID) {
-        facetType = XML_SCHEMA_FACET_ENUMERATION;
-        /*
-        * If enumerations are validated, one must not expect the
-        * facet to be given.
-        */
-    } else
-        facetType = facet->type;
-    msg = xmlStrcat(msg, BAD_CAST "[");
-    msg = xmlStrcat(msg, BAD_CAST "facet '");
-    msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facetType));
-    msg = xmlStrcat(msg, BAD_CAST "'] ");
-    if (message == NULL) {
-        /*
-        * Use a default message.
-        */
-        if ((facetType == XML_SCHEMA_FACET_LENGTH) ||
-            (facetType == XML_SCHEMA_FACET_MINLENGTH) ||
-            (facetType == XML_SCHEMA_FACET_MAXLENGTH)) {
-
-            char len[25], actLen[25];
-
-            /* FIXME, TODO: What is the max expected string length of the
-            * this value?
-            */
-            if (nodeType == XML_ATTRIBUTE_NODE)
-                msg = xmlStrcat(msg, BAD_CAST "The value '%s' has a length of '%s'; ");
-            else
-                msg = xmlStrcat(msg, BAD_CAST "The value has a length of '%s'; ");
-
-            snprintf(len, 24, "%lu", xmlSchemaGetFacetValueAsULong(facet));
-            snprintf(actLen, 24, "%lu", length);
-
-            if (facetType == XML_SCHEMA_FACET_LENGTH)
-                msg = xmlStrcat(msg,
-                BAD_CAST "this differs from the allowed length of '%s'.\n");
-            else if (facetType == XML_SCHEMA_FACET_MAXLENGTH)
-                msg = xmlStrcat(msg,
-                BAD_CAST "this exceeds the allowed maximum length of '%s'.\n");
-            else if (facetType == XML_SCHEMA_FACET_MINLENGTH)
-                msg = xmlStrcat(msg,
-                BAD_CAST "this underruns the allowed minimum length of '%s'.\n");
-
-            if (nodeType == XML_ATTRIBUTE_NODE)
-                xmlSchemaErr3(actxt, error, node, (const char *) msg,
-                    value, (const xmlChar *) actLen, (const xmlChar *) len);
-            else
-                xmlSchemaErr(actxt, error, node, (const char *) msg,
-                    (const xmlChar *) actLen, (const xmlChar *) len);
-
-        } else if (facetType == XML_SCHEMA_FACET_ENUMERATION) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not an element "
-                "of the set {%s}.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                xmlSchemaFormatFacetEnumSet(actxt, &str, type));
-        } else if (facetType == XML_SCHEMA_FACET_PATTERN) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not accepted "
-                "by the pattern '%s'.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_MININCLUSIVE) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' is less than the "
-                "minimum value allowed ('%s').\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' is greater than the "
-                "maximum value allowed ('%s').\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' must be greater than "
-                "'%s'.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' must be less than "
-                "'%s'.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_TOTALDIGITS) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more "
-                "digits than are allowed ('%s').\n");
-            xmlSchemaErr(actxt, error, node, (const char*) msg, value,
-                facet->value);
-        } else if (facetType == XML_SCHEMA_FACET_FRACTIONDIGITS) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more fractional "
-                "digits than are allowed ('%s').\n");
-            xmlSchemaErr(actxt, error, node, (const char*) msg, value,
-                facet->value);
-        } else if (nodeType == XML_ATTRIBUTE_NODE) {
-            msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not facet-valid.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
-        } else {
-            msg = xmlStrcat(msg, BAD_CAST "The value is not facet-valid.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
-        }
-    } else {
-        msg = xmlStrcat(msg, (const xmlChar *) message);
-        msg = xmlStrcat(msg, BAD_CAST ".\n");
-        xmlSchemaErr(actxt, error, node, (const char *) msg, str1, str2);
-    }
-    FREE_AND_NULL(str)
-    xmlFree(msg);
-}
-
-#define VERROR(err, type, msg) \
-    xmlSchemaCustomErr(ACTXT_CAST vctxt, err, NULL, type, msg, NULL, NULL);
-
-#define VERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST vctxt, func, msg);
-
-#define PERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST pctxt, func, msg);
-#define PERROR_INT2(func, msg) xmlSchemaInternalErr(ACTXT_CAST ctxt, func, msg);
-
-#define AERROR_INT(func, msg) xmlSchemaInternalErr(actxt, func, msg);
-
-
-/**
- * xmlSchemaPMissingAttrErr:
- * @ctxt: the schema validation context
- * @ownerDes: the designation of  the owner
- * @ownerName: the name of the owner
- * @ownerItem: the owner as a schema object
- * @ownerElem: the owner as an element node
- * @node: the parent element node of the missing attribute node
- * @type: the corresponding type of the attribute node
- *
- * Reports an illegal attribute.
- */
-static void
-xmlSchemaPMissingAttrErr(xmlSchemaParserCtxtPtr ctxt,
-                         xmlParserErrors error,
-                         xmlSchemaBasicItemPtr ownerItem,
-                         xmlNodePtr ownerElem,
-                         const char *name,
-                         const char *message)
-{
-    xmlChar *des = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
-
-    if (message != NULL)
-        xmlSchemaPErr(ctxt, ownerElem, error, "%s: %s.\n", BAD_CAST des, BAD_CAST message);
-    else
-        xmlSchemaPErr(ctxt, ownerElem, error,
-            "%s: The attribute '%s' is required but missing.\n",
-            BAD_CAST des, BAD_CAST name);
-    FREE_AND_NULL(des);
-}
-
-
-/**
- * xmlSchemaPResCompAttrErr:
- * @ctxt: the schema validation context
- * @error: the error code
- * @ownerDes: the designation of  the owner
- * @ownerItem: the owner as a schema object
- * @ownerElem: the owner as an element node
- * @name: the name of the attribute holding the QName
- * @refName: the referenced local name
- * @refURI: the referenced namespace URI
- * @message: optional message
- *
- * Used to report QName attribute values that failed to resolve
- * to schema components.
- */
-static void
-xmlSchemaPResCompAttrErr(xmlSchemaParserCtxtPtr ctxt,
-                         xmlParserErrors error,
-                         xmlSchemaBasicItemPtr ownerItem,
-                         xmlNodePtr ownerElem,
-                         const char *name,
-                         const xmlChar *refName,
-                         const xmlChar *refURI,
-                         xmlSchemaTypeType refType,
-                         const char *refTypeStr)
-{
-    xmlChar *des = NULL, *strA = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
-    if (refTypeStr == NULL)
-        refTypeStr = (const char *) xmlSchemaItemTypeToStr(refType);
-        xmlSchemaPErrExt(ctxt, ownerElem, error,
-            NULL, NULL, NULL,
-            "%s, attribute '%s': The QName value '%s' does not resolve to a(n) "
-            "%s.\n", BAD_CAST des, BAD_CAST name,
-            xmlSchemaFormatQName(&strA, refURI, refName),
-            BAD_CAST refTypeStr, NULL);
-    FREE_AND_NULL(des)
-    FREE_AND_NULL(strA)
-}
-
-/**
- * xmlSchemaPCustomAttrErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @ownerDes: the designation of the owner
- * @ownerItem: the owner as a schema object
- * @attr: the illegal attribute node
- *
- * Reports an illegal attribute during the parse.
- */
-static void
-xmlSchemaPCustomAttrErr(xmlSchemaParserCtxtPtr ctxt,
-                        xmlParserErrors error,
-                        xmlChar **ownerDes,
-                        xmlSchemaBasicItemPtr ownerItem,
-                        xmlAttrPtr attr,
-                        const char *msg)
-{
-    xmlChar *des = NULL;
-
-    if (ownerDes == NULL)
-        xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent);
-    else if (*ownerDes == NULL) {
-        xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, attr->parent);
-        des = *ownerDes;
-    } else
-        des = *ownerDes;
-    if (attr == NULL) {
-        xmlSchemaPErrExt(ctxt, NULL, error, NULL, NULL, NULL,
-            "%s, attribute '%s': %s.\n",
-            BAD_CAST des, (const xmlChar *) "Unknown",
-            (const xmlChar *) msg, NULL, NULL);
-    } else {
-        xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
-            "%s, attribute '%s': %s.\n",
-            BAD_CAST des, attr->name, (const xmlChar *) msg, NULL, NULL);
-    }
-    if (ownerDes == NULL)
-        FREE_AND_NULL(des);
-}
-
-/**
- * xmlSchemaPIllegalAttrErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @ownerDes: the designation of the attribute's owner
- * @ownerItem: the attribute's owner item
- * @attr: the illegal attribute node
- *
- * Reports an illegal attribute during the parse.
- */
-static void
-xmlSchemaPIllegalAttrErr(xmlSchemaParserCtxtPtr ctxt,
-                         xmlParserErrors error,
-                         xmlSchemaBasicItemPtr ownerComp ATTRIBUTE_UNUSED,
-                         xmlAttrPtr attr)
-{
-    xmlChar *strA = NULL, *strB = NULL;
-
-    xmlSchemaFormatNodeForError(&strA, ACTXT_CAST ctxt, attr->parent);
-    xmlSchemaErr4(ACTXT_CAST ctxt, error, (xmlNodePtr) attr,
-        "%sThe attribute '%s' is not allowed.\n", BAD_CAST strA,
-        xmlSchemaFormatQNameNs(&strB, attr->ns, attr->name),
-        NULL, NULL);
-    FREE_AND_NULL(strA);
-    FREE_AND_NULL(strB);
-}
-
-/**
- * xmlSchemaPCustomErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @itemDes: the designation of the schema item
- * @item: the schema item
- * @itemElem: the node of the schema item
- * @message: the error message
- * @str1: an optional param for the error message
- * @str2: an optional param for the error message
- * @str3: an optional param for the error message
- *
- * Reports an error during parsing.
- */
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaPCustomErrExt(xmlSchemaParserCtxtPtr ctxt,
-                    xmlParserErrors error,
-                    xmlSchemaBasicItemPtr item,
-                    xmlNodePtr itemElem,
-                    const char *message,
-                    const xmlChar *str1,
-                    const xmlChar *str2,
-                    const xmlChar *str3)
-{
-    xmlChar *des = NULL, *msg = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, item, itemElem);
-    msg = xmlStrdup(BAD_CAST "%s: ");
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-    if ((itemElem == NULL) && (item != NULL))
-        itemElem = WXS_ITEM_NODE(item);
-    xmlSchemaPErrExt(ctxt, itemElem, error, NULL, NULL, NULL,
-        (const char *) msg, BAD_CAST des, str1, str2, str3, NULL);
-    FREE_AND_NULL(des);
-    FREE_AND_NULL(msg);
-}
-
-/**
- * xmlSchemaPCustomErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @itemDes: the designation of the schema item
- * @item: the schema item
- * @itemElem: the node of the schema item
- * @message: the error message
- * @str1: the optional param for the error message
- *
- * Reports an error during parsing.
- */
-static void LIBXML_ATTR_FORMAT(5,0)
-xmlSchemaPCustomErr(xmlSchemaParserCtxtPtr ctxt,
-                    xmlParserErrors error,
-                    xmlSchemaBasicItemPtr item,
-                    xmlNodePtr itemElem,
-                    const char *message,
-                    const xmlChar *str1)
-{
-    xmlSchemaPCustomErrExt(ctxt, error, item, itemElem, message,
-        str1, NULL, NULL);
-}
-
-/**
- * xmlSchemaPAttrUseErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @itemDes: the designation of the schema type
- * @item: the schema type
- * @itemElem: the node of the schema type
- * @attr: the invalid schema attribute
- * @message: the error message
- * @str1: the optional param for the error message
- *
- * Reports an attribute use error during parsing.
- */
-static void LIBXML_ATTR_FORMAT(6,0)
-xmlSchemaPAttrUseErr4(xmlSchemaParserCtxtPtr ctxt,
-                    xmlParserErrors error,
-                    xmlNodePtr node,
-                    xmlSchemaBasicItemPtr ownerItem,
-                    const xmlSchemaAttributeUsePtr attruse,
-                    const char *message,
-                    const xmlChar *str1, const xmlChar *str2,
-                    const xmlChar *str3,const xmlChar *str4)
-{
-    xmlChar *str = NULL, *msg = NULL;
-
-    xmlSchemaFormatItemForReport(&msg, NULL, ownerItem, NULL);
-    msg = xmlStrcat(msg, BAD_CAST ", ");
-    msg = xmlStrcat(msg,
-        BAD_CAST xmlSchemaFormatItemForReport(&str, NULL,
-        WXS_BASIC_CAST attruse, NULL));
-    FREE_AND_NULL(str);
-    msg = xmlStrcat(msg, BAD_CAST ": ");
-    msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");
-    xmlSchemaErr4(ACTXT_CAST ctxt, error, node,
-        (const char *) msg, str1, str2, str3, str4);
-    xmlFree(msg);
-}
-
-/**
- * xmlSchemaPIllegalFacetAtomicErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @type: the schema type
- * @baseType: the base type of type
- * @facet: the illegal facet
- *
- * Reports an illegal facet for atomic simple types.
- */
-static void
-xmlSchemaPIllegalFacetAtomicErr(xmlSchemaParserCtxtPtr ctxt,
-                          xmlParserErrors error,
-                          xmlSchemaTypePtr type,
-                          xmlSchemaTypePtr baseType,
-                          xmlSchemaFacetPtr facet)
-{
-    xmlChar *des = NULL, *strT = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST type, type->node);
-    xmlSchemaPErrExt(ctxt, type->node, error, NULL, NULL, NULL,
-        "%s: The facet '%s' is not allowed on types derived from the "
-        "type %s.\n",
-        BAD_CAST des, xmlSchemaFacetTypeToString(facet->type),
-        xmlSchemaFormatItemForReport(&strT, NULL, WXS_BASIC_CAST baseType, NULL),
-        NULL, NULL);
-    FREE_AND_NULL(des);
-    FREE_AND_NULL(strT);
-}
-
-/**
- * xmlSchemaPIllegalFacetListUnionErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @itemDes: the designation of the schema item involved
- * @item: the schema item involved
- * @facet: the illegal facet
- *
- * Reports an illegal facet for <list> and <union>.
- */
-static void
-xmlSchemaPIllegalFacetListUnionErr(xmlSchemaParserCtxtPtr ctxt,
-                          xmlParserErrors error,
-                          xmlSchemaTypePtr type,
-                          xmlSchemaFacetPtr facet)
-{
-    xmlChar *des = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST type,
-        type->node);
-    xmlSchemaPErr(ctxt, type->node, error,
-        "%s: The facet '%s' is not allowed.\n",
-        BAD_CAST des, xmlSchemaFacetTypeToString(facet->type));
-    FREE_AND_NULL(des);
-}
-
-/**
- * xmlSchemaPMutualExclAttrErr:
- * @ctxt: the schema validation context
- * @error: the error code
- * @elemDes: the designation of the parent element node
- * @attr: the bad attribute node
- * @type: the corresponding type of the attribute node
- *
- * Reports an illegal attribute.
- */
-static void
-xmlSchemaPMutualExclAttrErr(xmlSchemaParserCtxtPtr ctxt,
-                         xmlParserErrors error,
-                         xmlSchemaBasicItemPtr ownerItem,
-                         xmlAttrPtr attr,
-                         const char *name1,
-                         const char *name2)
-{
-    xmlChar *des = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST ownerItem, attr->parent);
-    xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
-        "%s: The attributes '%s' and '%s' are mutually exclusive.\n",
-        BAD_CAST des, BAD_CAST name1, BAD_CAST name2, NULL, NULL);
-    FREE_AND_NULL(des);
-}
-
-/**
- * xmlSchemaPSimpleTypeErr:
- * @ctxt:  the schema validation context
- * @error: the error code
- * @type: the type specifier
- * @ownerDes: the designation of the owner
- * @ownerItem: the schema object if existent
- * @node: the validated node
- * @value: the validated value
- *
- * Reports a simple type validation error.
- * TODO: Should this report the value of an element as well?
- */
-static void LIBXML_ATTR_FORMAT(8,0)
-xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt,
-                        xmlParserErrors error,
-                        xmlSchemaBasicItemPtr ownerItem ATTRIBUTE_UNUSED,
-                        xmlNodePtr node,
-                        xmlSchemaTypePtr type,
-                        const char *expected,
-                        const xmlChar *value,
-                        const char *message,
-                        const xmlChar *str1,
-                        const xmlChar *str2)
-{
-    xmlChar *msg = NULL;
-
-    xmlSchemaFormatNodeForError(&msg, ACTXT_CAST ctxt, node);
-    if (message == NULL) {
-        /*
-        * Use default messages.
-        */
-        if (type != NULL) {
-            if (node->type == XML_ATTRIBUTE_NODE)
-                msg = xmlStrcat(msg, BAD_CAST "'%s' is not a valid value of ");
-            else
-                msg = xmlStrcat(msg, BAD_CAST "The character content is not a "
-                "valid value of ");
-            if (! xmlSchemaIsGlobalItem(type))
-                msg = xmlStrcat(msg, BAD_CAST "the local ");
-            else
-                msg = xmlStrcat(msg, BAD_CAST "the ");
-
-            if (WXS_IS_ATOMIC(type))
-                msg = xmlStrcat(msg, BAD_CAST "atomic type");
-            else if (WXS_IS_LIST(type))
-                msg = xmlStrcat(msg, BAD_CAST "list type");
-            else if (WXS_IS_UNION(type))
-                msg = xmlStrcat(msg, BAD_CAST "union type");
-
-            if (xmlSchemaIsGlobalItem(type)) {
-                xmlChar *str = NULL;
-                msg = xmlStrcat(msg, BAD_CAST " '");
-                if (type->builtInType != 0) {
-                    msg = xmlStrcat(msg, BAD_CAST "xs:");
-                    str = xmlStrdup(type->name);
-                } else {
-                    const xmlChar *qName = xmlSchemaFormatQName(&str, type->targetNamespace, type->name);
-                    if (!str)
-                        str = xmlStrdup(qName);
-                }
-                msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
-                msg = xmlStrcat(msg, BAD_CAST "'.");
-                FREE_AND_NULL(str);
-            }
-        } else {
-            if (node->type == XML_ATTRIBUTE_NODE)
-                msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not valid.");
-            else
-                msg = xmlStrcat(msg, BAD_CAST "The character content is not "
-                "valid.");
-        }
-        if (expected) {
-            xmlChar *expectedEscaped = xmlCharStrdup(expected);
-            msg = xmlStrcat(msg, BAD_CAST " Expected is '");
-            msg = xmlStrcat(msg, xmlEscapeFormatString(&expectedEscaped));
-            FREE_AND_NULL(expectedEscaped);
-            msg = xmlStrcat(msg, BAD_CAST "'.\n");
-        } else
-            msg = xmlStrcat(msg, BAD_CAST "\n");
-        if (node->type == XML_ATTRIBUTE_NODE)
-            xmlSchemaPErr(ctxt, node, error, (const char *) msg, value, NULL);
-        else
-            xmlSchemaPErr(ctxt, node, error, (const char *) msg, NULL, NULL);
-    } else {
-        msg = xmlStrcat(msg, BAD_CAST message);
-        msg = xmlStrcat(msg, BAD_CAST ".\n");
-        xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
-             (const char*) msg, str1, str2, NULL, NULL, NULL);
-    }
-    /* Cleanup. */
-    FREE_AND_NULL(msg)
-}
-
-/**
- * xmlSchemaPContentErr:
- * @ctxt: the schema parser context
- * @error: the error code
- * @onwerDes: the designation of the holder of the content
- * @ownerItem: the owner item of the holder of the content
- * @ownerElem: the node of the holder of the content
- * @child: the invalid child node
- * @message: the optional error message
- * @content: the optional string describing the correct content
- *
- * Reports an error concerning the content of a schema element.
- */
-static void
-xmlSchemaPContentErr(xmlSchemaParserCtxtPtr ctxt,
-                     xmlParserErrors error,
-                     xmlSchemaBasicItemPtr ownerItem,
-                     xmlNodePtr ownerElem,
-                     xmlNodePtr child,
-                     const char *message,
-                     const char *content)
-{
-    xmlChar *des = NULL;
-
-    xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
-    if (message != NULL)
-        xmlSchemaPErr2(ctxt, ownerElem, child, error,
-            "%s: %s.\n",
-            BAD_CAST des, BAD_CAST message);
-    else {
-        if (content != NULL) {
-            xmlSchemaPErr2(ctxt, ownerElem, child, error,
-                "%s: The content is not valid. Expected is %s.\n",
-                BAD_CAST des, BAD_CAST content);
-        } else {
-            xmlSchemaPErr2(ctxt, ownerElem, child, error,
-                "%s: The content is not valid.\n",
-                BAD_CAST des, NULL);
-        }
-    }
-    FREE_AND_NULL(des)
-}
-
-/************************************************************************
- *                                                                      *
- *                      Streamable error functions                      *
- *                                                                      *
- ************************************************************************/
-
-
-
-
-/************************************************************************
- *                                                                      *
- *                      Validation helper functions                     *
- *                                                                      *
- ************************************************************************/
-
-
-/************************************************************************
- *                                                                      *
- *                      Allocation functions                            *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaNewSchemaForParserCtxt:
- * @ctxt:  a schema validation context
- *
- * Allocate a new Schema structure.
- *
- * Returns the newly allocated structure or NULL in case or error
- */
-static xmlSchemaPtr
-xmlSchemaNewSchema(xmlSchemaParserCtxtPtr ctxt)
-{
-    xmlSchemaPtr ret;
-
-    ret = (xmlSchemaPtr) xmlMalloc(sizeof(xmlSchema));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating schema", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchema));
-    ret->dict = ctxt->dict;
-    xmlDictReference(ret->dict);
-
-    return (ret);
-}
-
-/**
- * xmlSchemaNewFacet:
- *
- * Allocate a new Facet structure.
- *
- * Returns the newly allocated structure or NULL in case or error
- */
-xmlSchemaFacetPtr
-xmlSchemaNewFacet(void)
-{
-    xmlSchemaFacetPtr ret;
-
-    ret = (xmlSchemaFacetPtr) xmlMalloc(sizeof(xmlSchemaFacet));
-    if (ret == NULL) {
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaFacet));
-
-    return (ret);
-}
-
-/**
- * xmlSchemaNewAnnot:
- * @ctxt:  a schema validation context
- * @node:  a node
- *
- * Allocate a new annotation structure.
- *
- * Returns the newly allocated structure or NULL in case or error
- */
-static xmlSchemaAnnotPtr
-xmlSchemaNewAnnot(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
-{
-    xmlSchemaAnnotPtr ret;
-
-    ret = (xmlSchemaAnnotPtr) xmlMalloc(sizeof(xmlSchemaAnnot));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating annotation", node);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaAnnot));
-    ret->content = node;
-    return (ret);
-}
-
-static xmlSchemaItemListPtr
-xmlSchemaItemListCreate(void)
-{
-    xmlSchemaItemListPtr ret;
-
-    ret = xmlMalloc(sizeof(xmlSchemaItemList));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL,
-            "allocating an item list structure", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaItemList));
-    return (ret);
-}
-
-static void
-xmlSchemaItemListClear(xmlSchemaItemListPtr list)
-{
-    if (list->items != NULL) {
-        xmlFree(list->items);
-        list->items = NULL;
-    }
-    list->nbItems = 0;
-    list->sizeItems = 0;
-}
-
-static int
-xmlSchemaItemListAdd(xmlSchemaItemListPtr list, void *item)
-{
-    if (list->items == NULL) {
-        list->items = (void **) xmlMalloc(
-            20 * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
-            return(-1);
-        }
-        list->sizeItems = 20;
-    } else if (list->sizeItems <= list->nbItems) {
-        list->sizeItems *= 2;
-        list->items = (void **) xmlRealloc(list->items,
-            list->sizeItems * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "growing item list", NULL);
-            list->sizeItems = 0;
-            return(-1);
-        }
-    }
-    list->items[list->nbItems++] = item;
-    return(0);
-}
-
-static int
-xmlSchemaItemListAddSize(xmlSchemaItemListPtr list,
-                         int initialSize,
-                         void *item)
-{
-    if (list->items == NULL) {
-        if (initialSize <= 0)
-            initialSize = 1;
-        list->items = (void **) xmlMalloc(
-            initialSize * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
-            return(-1);
-        }
-        list->sizeItems = initialSize;
-    } else if (list->sizeItems <= list->nbItems) {
-        list->sizeItems *= 2;
-        list->items = (void **) xmlRealloc(list->items,
-            list->sizeItems * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "growing item list", NULL);
-            list->sizeItems = 0;
-            return(-1);
-        }
-    }
-    list->items[list->nbItems++] = item;
-    return(0);
-}
-
-static int
-xmlSchemaItemListInsert(xmlSchemaItemListPtr list, void *item, int idx)
-{
-    if (list->items == NULL) {
-        list->items = (void **) xmlMalloc(
-            20 * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
-            return(-1);
-        }
-        list->sizeItems = 20;
-    } else if (list->sizeItems <= list->nbItems) {
-        list->sizeItems *= 2;
-        list->items = (void **) xmlRealloc(list->items,
-            list->sizeItems * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "growing item list", NULL);
-            list->sizeItems = 0;
-            return(-1);
-        }
-    }
-    /*
-    * Just append if the index is greater/equal than the item count.
-    */
-    if (idx >= list->nbItems) {
-        list->items[list->nbItems++] = item;
-    } else {
-        int i;
-        for (i = list->nbItems; i > idx; i--)
-            list->items[i] = list->items[i-1];
-        list->items[idx] = item;
-        list->nbItems++;
-    }
-    return(0);
-}
-
-#if 0 /* enable if ever needed */
-static int
-xmlSchemaItemListInsertSize(xmlSchemaItemListPtr list,
-                            int initialSize,
-                            void *item,
-                            int idx)
-{
-    if (list->items == NULL) {
-        if (initialSize <= 0)
-            initialSize = 1;
-        list->items = (void **) xmlMalloc(
-            initialSize * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
-            return(-1);
-        }
-        list->sizeItems = initialSize;
-    } else if (list->sizeItems <= list->nbItems) {
-        list->sizeItems *= 2;
-        list->items = (void **) xmlRealloc(list->items,
-            list->sizeItems * sizeof(void *));
-        if (list->items == NULL) {
-            xmlSchemaPErrMemory(NULL, "growing item list", NULL);
-            list->sizeItems = 0;
-            return(-1);
-        }
-    }
-    /*
-    * Just append if the index is greater/equal than the item count.
-    */
-    if (idx >= list->nbItems) {
-        list->items[list->nbItems++] = item;
-    } else {
-        int i;
-        for (i = list->nbItems; i > idx; i--)
-            list->items[i] = list->items[i-1];
-        list->items[idx] = item;
-        list->nbItems++;
-    }
-    return(0);
-}
-#endif
-
-static int
-xmlSchemaItemListRemove(xmlSchemaItemListPtr list, int idx)
-{
-    int i;
-    if ((list->items == NULL) || (idx >= list->nbItems)) {
-        xmlSchemaPSimpleErr("Internal error: xmlSchemaItemListRemove, "
-            "index error.\n");
-        return(-1);
-    }
-
-    if (list->nbItems == 1) {
-        /* TODO: Really free the list? */
-        xmlFree(list->items);
-        list->items = NULL;
-        list->nbItems = 0;
-        list->sizeItems = 0;
-    } else if (list->nbItems -1 == idx) {
-        list->nbItems--;
-    } else {
-        for (i = idx; i < list->nbItems -1; i++)
-            list->items[i] = list->items[i+1];
-        list->nbItems--;
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaItemListFree:
- * @annot:  a schema type structure
- *
- * Deallocate a annotation structure
- */
-static void
-xmlSchemaItemListFree(xmlSchemaItemListPtr list)
-{
-    if (list == NULL)
-        return;
-    if (list->items != NULL)
-        xmlFree(list->items);
-    xmlFree(list);
-}
-
-static void
-xmlSchemaBucketFree(xmlSchemaBucketPtr bucket)
-{
-    if (bucket == NULL)
-        return;
-    if (bucket->globals != NULL) {
-        xmlSchemaComponentListFree(bucket->globals);
-        xmlSchemaItemListFree(bucket->globals);
-    }
-    if (bucket->locals != NULL) {
-        xmlSchemaComponentListFree(bucket->locals);
-        xmlSchemaItemListFree(bucket->locals);
-    }
-    if (bucket->relations != NULL) {
-        xmlSchemaSchemaRelationPtr prev, cur = bucket->relations;
-        do {
-            prev = cur;
-            cur = cur->next;
-            xmlFree(prev);
-        } while (cur != NULL);
-    }
-    if ((! bucket->preserveDoc) && (bucket->doc != NULL)) {
-        xmlFreeDoc(bucket->doc);
-    }
-    if (bucket->type == XML_SCHEMA_SCHEMA_IMPORT) {
-        if (WXS_IMPBUCKET(bucket)->schema != NULL)
-            xmlSchemaFree(WXS_IMPBUCKET(bucket)->schema);
-    }
-    xmlFree(bucket);
-}
-
-static xmlSchemaBucketPtr
-xmlSchemaBucketCreate(xmlSchemaParserCtxtPtr pctxt,
-                         int type, const xmlChar *targetNamespace)
-{
-    xmlSchemaBucketPtr ret;
-    int size;
-    xmlSchemaPtr mainSchema;
-
-    if (WXS_CONSTRUCTOR(pctxt)->mainSchema == NULL) {
-        PERROR_INT("xmlSchemaBucketCreate",
-            "no main schema on constructor");
-        return(NULL);
-    }
-    mainSchema = WXS_CONSTRUCTOR(pctxt)->mainSchema;
-    /* Create the schema bucket. */
-    if (WXS_IS_BUCKET_INCREDEF(type))
-        size = sizeof(xmlSchemaInclude);
-    else
-        size = sizeof(xmlSchemaImport);
-    ret = (xmlSchemaBucketPtr) xmlMalloc(size);
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL, "allocating schema bucket", NULL);
-        return(NULL);
-    }
-    memset(ret, 0, size);
-    ret->targetNamespace = targetNamespace;
-    ret->type = type;
-    ret->globals = xmlSchemaItemListCreate();
-    if (ret->globals == NULL) {
-        xmlFree(ret);
-        return(NULL);
-    }
-    ret->locals = xmlSchemaItemListCreate();
-    if (ret->locals == NULL) {
-        xmlFree(ret);
-        return(NULL);
-    }
-    /*
-    * The following will assure that only the first bucket is marked as
-    * XML_SCHEMA_SCHEMA_MAIN and it points to the *main* schema.
-    * For each following import buckets an xmlSchema will be created.
-    * An xmlSchema will be created for every distinct targetNamespace.
-    * We assign the targetNamespace to the schemata here.
-    */
-    if (! WXS_HAS_BUCKETS(pctxt)) {
-        if (WXS_IS_BUCKET_INCREDEF(type)) {
-            PERROR_INT("xmlSchemaBucketCreate",
-                "first bucket but it's an include or redefine");
-            xmlSchemaBucketFree(ret);
-            return(NULL);
-        }
-        /* Force the type to be XML_SCHEMA_SCHEMA_MAIN. */
-        ret->type = XML_SCHEMA_SCHEMA_MAIN;
-        /* Point to the *main* schema. */
-        WXS_CONSTRUCTOR(pctxt)->mainBucket = ret;
-        WXS_IMPBUCKET(ret)->schema = mainSchema;
-        /*
-        * Ensure that the main schema gets a targetNamespace.
-        */
-        mainSchema->targetNamespace = targetNamespace;
-    } else {
-        if (type == XML_SCHEMA_SCHEMA_MAIN) {
-            PERROR_INT("xmlSchemaBucketCreate",
-                "main bucket but it's not the first one");
-            xmlSchemaBucketFree(ret);
-            return(NULL);
-        } else if (type == XML_SCHEMA_SCHEMA_IMPORT) {
-            /*
-            * Create a schema for imports and assign the
-            * targetNamespace.
-            */
-            WXS_IMPBUCKET(ret)->schema = xmlSchemaNewSchema(pctxt);
-            if (WXS_IMPBUCKET(ret)->schema == NULL) {
-                xmlSchemaBucketFree(ret);
-                return(NULL);
-            }
-            WXS_IMPBUCKET(ret)->schema->targetNamespace = targetNamespace;
-        }
-    }
-    if (WXS_IS_BUCKET_IMPMAIN(type)) {
-        int res;
-        /*
-        * Imports go into the "schemasImports" slot of the main *schema*.
-        * Note that we create an import entry for the main schema as well; i.e.,
-        * even if there's only one schema, we'll get an import.
-        */
-        if (mainSchema->schemasImports == NULL) {
-            mainSchema->schemasImports = xmlHashCreateDict(5,
-                WXS_CONSTRUCTOR(pctxt)->dict);
-            if (mainSchema->schemasImports == NULL) {
-                xmlSchemaBucketFree(ret);
-                return(NULL);
-            }
-        }
-        if (targetNamespace == NULL)
-            res = xmlHashAddEntry(mainSchema->schemasImports,
-                XML_SCHEMAS_NO_NAMESPACE, ret);
-        else
-            res = xmlHashAddEntry(mainSchema->schemasImports,
-                targetNamespace, ret);
-        if (res != 0) {
-            PERROR_INT("xmlSchemaBucketCreate",
-                "failed to add the schema bucket to the hash");
-            xmlSchemaBucketFree(ret);
-            return(NULL);
-        }
-    } else {
-        /* Set the @ownerImport of an include bucket. */
-        if (WXS_IS_BUCKET_IMPMAIN(WXS_CONSTRUCTOR(pctxt)->bucket->type))
-            WXS_INCBUCKET(ret)->ownerImport =
-                WXS_IMPBUCKET(WXS_CONSTRUCTOR(pctxt)->bucket);
-        else
-            WXS_INCBUCKET(ret)->ownerImport =
-                WXS_INCBUCKET(WXS_CONSTRUCTOR(pctxt)->bucket)->ownerImport;
-
-        /* Includes got into the "includes" slot of the *main* schema. */
-        if (mainSchema->includes == NULL) {
-            mainSchema->includes = xmlSchemaItemListCreate();
-            if (mainSchema->includes == NULL) {
-                xmlSchemaBucketFree(ret);
-                return(NULL);
-            }
-        }
-        xmlSchemaItemListAdd(mainSchema->includes, ret);
-    }
-    /*
-    * Add to list of all buckets; this is used for lookup
-    * during schema construction time only.
-    */
-    if (xmlSchemaItemListAdd(WXS_CONSTRUCTOR(pctxt)->buckets, ret) == -1)
-        return(NULL);
-    return(ret);
-}
-
-static int
-xmlSchemaAddItemSize(xmlSchemaItemListPtr *list, int initialSize, void *item)
-{
-    if (*list == NULL) {
-        *list = xmlSchemaItemListCreate();
-        if (*list == NULL)
-            return(-1);
-    }
-    xmlSchemaItemListAddSize(*list, initialSize, item);
-    return(0);
-}
-
-/**
- * xmlSchemaFreeAnnot:
- * @annot:  a schema type structure
- *
- * Deallocate a annotation structure
- */
-static void
-xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot)
-{
-    if (annot == NULL)
-        return;
-    if (annot->next == NULL) {
-        xmlFree(annot);
-    } else {
-        xmlSchemaAnnotPtr prev;
-
-        do {
-            prev = annot;
-            annot = annot->next;
-            xmlFree(prev);
-        } while (annot != NULL);
-    }
-}
-
-/**
- * xmlSchemaFreeNotation:
- * @schema:  a schema notation structure
- *
- * Deallocate a Schema Notation structure.
- */
-static void
-xmlSchemaFreeNotation(xmlSchemaNotationPtr nota)
-{
-    if (nota == NULL)
-        return;
-    xmlFree(nota);
-}
-
-/**
- * xmlSchemaFreeAttribute:
- * @attr:  an attribute declaration
- *
- * Deallocates an attribute declaration structure.
- */
-static void
-xmlSchemaFreeAttribute(xmlSchemaAttributePtr attr)
-{
-    if (attr == NULL)
-        return;
-    if (attr->annot != NULL)
-        xmlSchemaFreeAnnot(attr->annot);
-    if (attr->defVal != NULL)
-        xmlSchemaFreeValue(attr->defVal);
-    xmlFree(attr);
-}
-
-/**
- * xmlSchemaFreeAttributeUse:
- * @use:  an attribute use
- *
- * Deallocates an attribute use structure.
- */
-static void
-xmlSchemaFreeAttributeUse(xmlSchemaAttributeUsePtr use)
-{
-    if (use == NULL)
-        return;
-    if (use->annot != NULL)
-        xmlSchemaFreeAnnot(use->annot);
-    if (use->defVal != NULL)
-        xmlSchemaFreeValue(use->defVal);
-    xmlFree(use);
-}
-
-/**
- * xmlSchemaFreeAttributeUseProhib:
- * @prohib:  an attribute use prohibition
- *
- * Deallocates an attribute use structure.
- */
-static void
-xmlSchemaFreeAttributeUseProhib(xmlSchemaAttributeUseProhibPtr prohib)
-{
-    if (prohib == NULL)
-        return;
-    xmlFree(prohib);
-}
-
-/**
- * xmlSchemaFreeWildcardNsSet:
- * set:  a schema wildcard namespace
- *
- * Deallocates a list of wildcard constraint structures.
- */
-static void
-xmlSchemaFreeWildcardNsSet(xmlSchemaWildcardNsPtr set)
-{
-    xmlSchemaWildcardNsPtr next;
-
-    while (set != NULL) {
-        next = set->next;
-        xmlFree(set);
-        set = next;
-    }
-}
-
-/**
- * xmlSchemaFreeWildcard:
- * @wildcard:  a wildcard structure
- *
- * Deallocates a wildcard structure.
- */
-void
-xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard)
-{
-    if (wildcard == NULL)
-        return;
-    if (wildcard->annot != NULL)
-        xmlSchemaFreeAnnot(wildcard->annot);
-    if (wildcard->nsSet != NULL)
-        xmlSchemaFreeWildcardNsSet(wildcard->nsSet);
-    if (wildcard->negNsSet != NULL)
-        xmlFree(wildcard->negNsSet);
-    xmlFree(wildcard);
-}
-
-/**
- * xmlSchemaFreeAttributeGroup:
- * @schema:  a schema attribute group structure
- *
- * Deallocate a Schema Attribute Group structure.
- */
-static void
-xmlSchemaFreeAttributeGroup(xmlSchemaAttributeGroupPtr attrGr)
-{
-    if (attrGr == NULL)
-        return;
-    if (attrGr->annot != NULL)
-        xmlSchemaFreeAnnot(attrGr->annot);
-    if (attrGr->attrUses != NULL)
-        xmlSchemaItemListFree(WXS_LIST_CAST attrGr->attrUses);
-    xmlFree(attrGr);
-}
-
-/**
- * xmlSchemaFreeQNameRef:
- * @item: a QName reference structure
- *
- * Deallocatea a QName reference structure.
- */
-static void
-xmlSchemaFreeQNameRef(xmlSchemaQNameRefPtr item)
-{
-    xmlFree(item);
-}
-
-/**
- * xmlSchemaFreeTypeLinkList:
- * @alink: a type link
- *
- * Deallocate a list of types.
- */
-static void
-xmlSchemaFreeTypeLinkList(xmlSchemaTypeLinkPtr link)
-{
-    xmlSchemaTypeLinkPtr next;
-
-    while (link != NULL) {
-        next = link->next;
-        xmlFree(link);
-        link = next;
-    }
-}
-
-static void
-xmlSchemaFreeIDCStateObjList(xmlSchemaIDCStateObjPtr sto)
-{
-    xmlSchemaIDCStateObjPtr next;
-    while (sto != NULL) {
-        next = sto->next;
-        if (sto->history != NULL)
-            xmlFree(sto->history);
-        if (sto->xpathCtxt != NULL)
-            xmlFreeStreamCtxt((xmlStreamCtxtPtr) sto->xpathCtxt);
-        xmlFree(sto);
-        sto = next;
-    }
-}
-
-/**
- * xmlSchemaFreeIDC:
- * @idc: a identity-constraint definition
- *
- * Deallocates an identity-constraint definition.
- */
-static void
-xmlSchemaFreeIDC(xmlSchemaIDCPtr idcDef)
-{
-    xmlSchemaIDCSelectPtr cur, prev;
-
-    if (idcDef == NULL)
-        return;
-    if (idcDef->annot != NULL)
-        xmlSchemaFreeAnnot(idcDef->annot);
-    /* Selector */
-    if (idcDef->selector != NULL) {
-        if (idcDef->selector->xpathComp != NULL)
-            xmlFreePattern((xmlPatternPtr) idcDef->selector->xpathComp);
-        xmlFree(idcDef->selector);
-    }
-    /* Fields */
-    if (idcDef->fields != NULL) {
-        cur = idcDef->fields;
-        do {
-            prev = cur;
-            cur = cur->next;
-            if (prev->xpathComp != NULL)
-                xmlFreePattern((xmlPatternPtr) prev->xpathComp);
-            xmlFree(prev);
-        } while (cur != NULL);
-    }
-    xmlFree(idcDef);
-}
-
-/**
- * xmlSchemaFreeElement:
- * @schema:  a schema element structure
- *
- * Deallocate a Schema Element structure.
- */
-static void
-xmlSchemaFreeElement(xmlSchemaElementPtr elem)
-{
-    if (elem == NULL)
-        return;
-    if (elem->annot != NULL)
-        xmlSchemaFreeAnnot(elem->annot);
-    if (elem->contModel != NULL)
-        xmlRegFreeRegexp(elem->contModel);
-    if (elem->defVal != NULL)
-        xmlSchemaFreeValue(elem->defVal);
-    xmlFree(elem);
-}
-
-/**
- * xmlSchemaFreeFacet:
- * @facet:  a schema facet structure
- *
- * Deallocate a Schema Facet structure.
- */
-void
-xmlSchemaFreeFacet(xmlSchemaFacetPtr facet)
-{
-    if (facet == NULL)
-        return;
-    if (facet->val != NULL)
-        xmlSchemaFreeValue(facet->val);
-    if (facet->regexp != NULL)
-        xmlRegFreeRegexp(facet->regexp);
-    if (facet->annot != NULL)
-        xmlSchemaFreeAnnot(facet->annot);
-    xmlFree(facet);
-}
-
-/**
- * xmlSchemaFreeType:
- * @type:  a schema type structure
- *
- * Deallocate a Schema Type structure.
- */
-void
-xmlSchemaFreeType(xmlSchemaTypePtr type)
-{
-    if (type == NULL)
-        return;
-    if (type->annot != NULL)
-        xmlSchemaFreeAnnot(type->annot);
-    if (type->facets != NULL) {
-        xmlSchemaFacetPtr facet, next;
-
-        facet = type->facets;
-        while (facet != NULL) {
-            next = facet->next;
-            xmlSchemaFreeFacet(facet);
-            facet = next;
-        }
-    }
-    if (type->attrUses != NULL)
-        xmlSchemaItemListFree((xmlSchemaItemListPtr) type->attrUses);
-    if (type->memberTypes != NULL)
-        xmlSchemaFreeTypeLinkList(type->memberTypes);
-    if (type->facetSet != NULL) {
-        xmlSchemaFacetLinkPtr next, link;
-
-        link = type->facetSet;
-        do {
-            next = link->next;
-            xmlFree(link);
-            link = next;
-        } while (link != NULL);
-    }
-    if (type->contModel != NULL)
-        xmlRegFreeRegexp(type->contModel);
-    xmlFree(type);
-}
-
-/**
- * xmlSchemaFreeModelGroupDef:
- * @item:  a schema model group definition
- *
- * Deallocates a schema model group definition.
- */
-static void
-xmlSchemaFreeModelGroupDef(xmlSchemaModelGroupDefPtr item)
-{
-    if (item->annot != NULL)
-        xmlSchemaFreeAnnot(item->annot);
-    xmlFree(item);
-}
-
-/**
- * xmlSchemaFreeModelGroup:
- * @item:  a schema model group
- *
- * Deallocates a schema model group structure.
- */
-static void
-xmlSchemaFreeModelGroup(xmlSchemaModelGroupPtr item)
-{
-    if (item->annot != NULL)
-        xmlSchemaFreeAnnot(item->annot);
-    xmlFree(item);
-}
-
-static void
-xmlSchemaComponentListFree(xmlSchemaItemListPtr list)
-{
-    if ((list == NULL) || (list->nbItems == 0))
-        return;
-    {
-        xmlSchemaTreeItemPtr item;
-        xmlSchemaTreeItemPtr *items = (xmlSchemaTreeItemPtr *) list->items;
-        int i;
-
-        for (i = 0; i < list->nbItems; i++) {
-            item = items[i];
-            if (item == NULL)
-                continue;
-            switch (item->type) {
-                case XML_SCHEMA_TYPE_SIMPLE:
-                case XML_SCHEMA_TYPE_COMPLEX:
-                    xmlSchemaFreeType((xmlSchemaTypePtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_ATTRIBUTE:
-                    xmlSchemaFreeAttribute((xmlSchemaAttributePtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-                    xmlSchemaFreeAttributeUse((xmlSchemaAttributeUsePtr) item);
-                    break;
-                case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
-                    xmlSchemaFreeAttributeUseProhib(
-                        (xmlSchemaAttributeUseProhibPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_ELEMENT:
-                    xmlSchemaFreeElement((xmlSchemaElementPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_PARTICLE:
-                    if (item->annot != NULL)
-                        xmlSchemaFreeAnnot(item->annot);
-                    xmlFree(item);
-                    break;
-                case XML_SCHEMA_TYPE_SEQUENCE:
-                case XML_SCHEMA_TYPE_CHOICE:
-                case XML_SCHEMA_TYPE_ALL:
-                    xmlSchemaFreeModelGroup((xmlSchemaModelGroupPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                    xmlSchemaFreeAttributeGroup(
-                        (xmlSchemaAttributeGroupPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_GROUP:
-                    xmlSchemaFreeModelGroupDef(
-                        (xmlSchemaModelGroupDefPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_ANY:
-                case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
-                    xmlSchemaFreeWildcard((xmlSchemaWildcardPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_IDC_KEY:
-                case XML_SCHEMA_TYPE_IDC_UNIQUE:
-                case XML_SCHEMA_TYPE_IDC_KEYREF:
-                    xmlSchemaFreeIDC((xmlSchemaIDCPtr) item);
-                    break;
-                case XML_SCHEMA_TYPE_NOTATION:
-                    xmlSchemaFreeNotation((xmlSchemaNotationPtr) item);
-                    break;
-                case XML_SCHEMA_EXTRA_QNAMEREF:
-                    xmlSchemaFreeQNameRef((xmlSchemaQNameRefPtr) item);
-                    break;
-                default: {
-                    /* TODO: This should never be hit. */
-                    xmlSchemaPSimpleInternalErr(NULL,
-                        "Internal error: xmlSchemaComponentListFree, "
-                        "unexpected component type '%s'\n",
-                        (const xmlChar *) WXS_ITEM_TYPE_NAME(item));
-                         }
-                    break;
-            }
-        }
-        list->nbItems = 0;
-    }
-}
-
-/**
- * xmlSchemaFree:
- * @schema:  a schema structure
- *
- * Deallocate a Schema structure.
- */
-void
-xmlSchemaFree(xmlSchemaPtr schema)
-{
-    if (schema == NULL)
-        return;
-    /* @volatiles is not used anymore :-/ */
-    if (schema->volatiles != NULL)
-        TODO
-    /*
-    * Note that those slots are not responsible for freeing
-    * schema components anymore; this will now be done by
-    * the schema buckets.
-    */
-    if (schema->notaDecl != NULL)
-        xmlHashFree(schema->notaDecl, NULL);
-    if (schema->attrDecl != NULL)
-        xmlHashFree(schema->attrDecl, NULL);
-    if (schema->attrgrpDecl != NULL)
-        xmlHashFree(schema->attrgrpDecl, NULL);
-    if (schema->elemDecl != NULL)
-        xmlHashFree(schema->elemDecl, NULL);
-    if (schema->typeDecl != NULL)
-        xmlHashFree(schema->typeDecl, NULL);
-    if (schema->groupDecl != NULL)
-        xmlHashFree(schema->groupDecl, NULL);
-    if (schema->idcDef != NULL)
-        xmlHashFree(schema->idcDef, NULL);
-
-    if (schema->schemasImports != NULL)
-        xmlHashFree(schema->schemasImports,
-                    (xmlHashDeallocator) xmlSchemaBucketFree);
-    if (schema->includes != NULL) {
-        xmlSchemaItemListPtr list = (xmlSchemaItemListPtr) schema->includes;
-        int i;
-        for (i = 0; i < list->nbItems; i++) {
-            xmlSchemaBucketFree((xmlSchemaBucketPtr) list->items[i]);
-        }
-        xmlSchemaItemListFree(list);
-    }
-    if (schema->annot != NULL)
-        xmlSchemaFreeAnnot(schema->annot);
-    /* Never free the doc here, since this will be done by the buckets. */
-
-    xmlDictFree(schema->dict);
-    xmlFree(schema);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Debug functions                                 *
- *                                                                      *
- ************************************************************************/
-
-#ifdef LIBXML_OUTPUT_ENABLED
-
-static void
-xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output); /* forward */
-
-/**
- * xmlSchemaElementDump:
- * @elem:  an element
- * @output:  the file output
- *
- * Dump the element
- */
-static void
-xmlSchemaElementDump(xmlSchemaElementPtr elem, FILE * output,
-                     const xmlChar * name ATTRIBUTE_UNUSED,
-                     const xmlChar * namespace ATTRIBUTE_UNUSED,
-                     const xmlChar * context ATTRIBUTE_UNUSED)
-{
-    if (elem == NULL)
-        return;
-
-
-    fprintf(output, "Element");
-    if (elem->flags & XML_SCHEMAS_ELEM_GLOBAL)
-        fprintf(output, " (global)");
-    fprintf(output, ": '%s' ", elem->name);
-    if (namespace != NULL)
-        fprintf(output, "ns '%s'", namespace);
-    fprintf(output, "\n");
-#if 0
-    if ((elem->minOccurs != 1) || (elem->maxOccurs != 1)) {
-        fprintf(output, "  min %d ", elem->minOccurs);
-        if (elem->maxOccurs >= UNBOUNDED)
-            fprintf(output, "max: unbounded\n");
-        else if (elem->maxOccurs != 1)
-            fprintf(output, "max: %d\n", elem->maxOccurs);
-        else
-            fprintf(output, "\n");
-    }
-#endif
-    /*
-    * Misc other properties.
-    */
-    if ((elem->flags & XML_SCHEMAS_ELEM_NILLABLE) ||
-        (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT) ||
-        (elem->flags & XML_SCHEMAS_ELEM_FIXED) ||
-        (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)) {
-        fprintf(output, "  props: ");
-        if (elem->flags & XML_SCHEMAS_ELEM_FIXED)
-            fprintf(output, "[fixed] ");
-        if (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)
-            fprintf(output, "[default] ");
-        if (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT)
-            fprintf(output, "[abstract] ");
-        if (elem->flags & XML_SCHEMAS_ELEM_NILLABLE)
-            fprintf(output, "[nillable] ");
-        fprintf(output, "\n");
-    }
-    /*
-    * Default/fixed value.
-    */
-    if (elem->value != NULL)
-        fprintf(output, "  value: '%s'\n", elem->value);
-    /*
-    * Type.
-    */
-    if (elem->namedType != NULL) {
-        fprintf(output, "  type: '%s' ", elem->namedType);
-        if (elem->namedTypeNs != NULL)
-            fprintf(output, "ns '%s'\n", elem->namedTypeNs);
-        else
-            fprintf(output, "\n");
-    } else if (elem->subtypes != NULL) {
-        /*
-        * Dump local types.
-        */
-        xmlSchemaTypeDump(elem->subtypes, output);
-    }
-    /*
-    * Substitution group.
-    */
-    if (elem->substGroup != NULL) {
-        fprintf(output, "  substitutionGroup: '%s' ", elem->substGroup);
-        if (elem->substGroupNs != NULL)
-            fprintf(output, "ns '%s'\n", elem->substGroupNs);
-        else
-            fprintf(output, "\n");
-    }
-}
-
-/**
- * xmlSchemaAnnotDump:
- * @output:  the file output
- * @annot:  a annotation
- *
- * Dump the annotation
- */
-static void
-xmlSchemaAnnotDump(FILE * output, xmlSchemaAnnotPtr annot)
-{
-    xmlChar *content;
-
-    if (annot == NULL)
-        return;
-
-    content = xmlNodeGetContent(annot->content);
-    if (content != NULL) {
-        fprintf(output, "  Annot: %s\n", content);
-        xmlFree(content);
-    } else
-        fprintf(output, "  Annot: empty\n");
-}
-
-/**
- * xmlSchemaContentModelDump:
- * @particle: the schema particle
- * @output: the file output
- * @depth: the depth used for intentation
- *
- * Dump a SchemaType structure
- */
-static void
-xmlSchemaContentModelDump(xmlSchemaParticlePtr particle, FILE * output, int depth)
-{
-    xmlChar *str = NULL;
-    xmlSchemaTreeItemPtr term;
-    char shift[100];
-    int i;
-
-    if (particle == NULL)
-        return;
-    for (i = 0;((i < depth) && (i < 25));i++)
-        shift[2 * i] = shift[2 * i + 1] = ' ';
-    shift[2 * i] = shift[2 * i + 1] = 0;
-    fprintf(output, "%s", shift);
-    if (particle->children == NULL) {
-        fprintf(output, "MISSING particle term\n");
-        return;
-    }
-    term = particle->children;
-    if (term == NULL) {
-        fprintf(output, "(NULL)");
-    } else {
-        switch (term->type) {
-            case XML_SCHEMA_TYPE_ELEMENT:
-                fprintf(output, "ELEM '%s'", xmlSchemaFormatQName(&str,
-                    ((xmlSchemaElementPtr)term)->targetNamespace,
-                    ((xmlSchemaElementPtr)term)->name));
-                FREE_AND_NULL(str);
-                break;
-            case XML_SCHEMA_TYPE_SEQUENCE:
-                fprintf(output, "SEQUENCE");
-                break;
-            case XML_SCHEMA_TYPE_CHOICE:
-                fprintf(output, "CHOICE");
-                break;
-            case XML_SCHEMA_TYPE_ALL:
-                fprintf(output, "ALL");
-                break;
-            case XML_SCHEMA_TYPE_ANY:
-                fprintf(output, "ANY");
-                break;
-            default:
-                fprintf(output, "UNKNOWN\n");
-                return;
-        }
-    }
-    if (particle->minOccurs != 1)
-        fprintf(output, " min: %d", particle->minOccurs);
-    if (particle->maxOccurs >= UNBOUNDED)
-        fprintf(output, " max: unbounded");
-    else if (particle->maxOccurs != 1)
-        fprintf(output, " max: %d", particle->maxOccurs);
-    fprintf(output, "\n");
-    if (term &&
-        ((term->type == XML_SCHEMA_TYPE_SEQUENCE) ||
-         (term->type == XML_SCHEMA_TYPE_CHOICE) ||
-         (term->type == XML_SCHEMA_TYPE_ALL)) &&
-         (term->children != NULL)) {
-        xmlSchemaContentModelDump((xmlSchemaParticlePtr) term->children,
-            output, depth +1);
-    }
-    if (particle->next != NULL)
-        xmlSchemaContentModelDump((xmlSchemaParticlePtr) particle->next,
-                output, depth);
-}
-
-/**
- * xmlSchemaAttrUsesDump:
- * @uses:  attribute uses list
- * @output:  the file output
- *
- * Dumps a list of attribute use components.
- */
-static void
-xmlSchemaAttrUsesDump(xmlSchemaItemListPtr uses, FILE * output)
-{
-    xmlSchemaAttributeUsePtr use;
-    xmlSchemaAttributeUseProhibPtr prohib;
-    xmlSchemaQNameRefPtr ref;
-    const xmlChar *name, *tns;
-    xmlChar *str = NULL;
-    int i;
-
-    if ((uses == NULL) || (uses->nbItems == 0))
-        return;
-
-    fprintf(output, "  attributes:\n");
-    for (i = 0; i < uses->nbItems; i++) {
-        use = uses->items[i];
-        if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
-            fprintf(output, "  [prohibition] ");
-            prohib = (xmlSchemaAttributeUseProhibPtr) use;
-            name = prohib->name;
-            tns = prohib->targetNamespace;
-        } else if (use->type == XML_SCHEMA_EXTRA_QNAMEREF) {
-            fprintf(output, "  [reference] ");
-            ref = (xmlSchemaQNameRefPtr) use;
-            name = ref->name;
-            tns = ref->targetNamespace;
-        } else {
-            fprintf(output, "  [use] ");
-            name = WXS_ATTRUSE_DECL_NAME(use);
-            tns = WXS_ATTRUSE_DECL_TNS(use);
-        }
-        fprintf(output, "'%s'\n",
-            (const char *) xmlSchemaFormatQName(&str, tns, name));
-        FREE_AND_NULL(str);
-    }
-}
-
-/**
- * xmlSchemaTypeDump:
- * @output:  the file output
- * @type:  a type structure
- *
- * Dump a SchemaType structure
- */
-static void
-xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output)
-{
-    if (type == NULL) {
-        fprintf(output, "Type: NULL\n");
-        return;
-    }
-    fprintf(output, "Type: ");
-    if (type->name != NULL)
-        fprintf(output, "'%s' ", type->name);
-    else
-        fprintf(output, "(no name) ");
-    if (type->targetNamespace != NULL)
-        fprintf(output, "ns '%s' ", type->targetNamespace);
-    switch (type->type) {
-        case XML_SCHEMA_TYPE_BASIC:
-            fprintf(output, "[basic] ");
-            break;
-        case XML_SCHEMA_TYPE_SIMPLE:
-            fprintf(output, "[simple] ");
-            break;
-        case XML_SCHEMA_TYPE_COMPLEX:
-            fprintf(output, "[complex] ");
-            break;
-        case XML_SCHEMA_TYPE_SEQUENCE:
-            fprintf(output, "[sequence] ");
-            break;
-        case XML_SCHEMA_TYPE_CHOICE:
-            fprintf(output, "[choice] ");
-            break;
-        case XML_SCHEMA_TYPE_ALL:
-            fprintf(output, "[all] ");
-            break;
-        case XML_SCHEMA_TYPE_UR:
-            fprintf(output, "[ur] ");
-            break;
-        case XML_SCHEMA_TYPE_RESTRICTION:
-            fprintf(output, "[restriction] ");
-            break;
-        case XML_SCHEMA_TYPE_EXTENSION:
-            fprintf(output, "[extension] ");
-            break;
-        default:
-            fprintf(output, "[unknown type %d] ", type->type);
-            break;
-    }
-    fprintf(output, "content: ");
-    switch (type->contentType) {
-        case XML_SCHEMA_CONTENT_UNKNOWN:
-            fprintf(output, "[unknown] ");
-            break;
-        case XML_SCHEMA_CONTENT_EMPTY:
-            fprintf(output, "[empty] ");
-            break;
-        case XML_SCHEMA_CONTENT_ELEMENTS:
-            fprintf(output, "[element] ");
-            break;
-        case XML_SCHEMA_CONTENT_MIXED:
-            fprintf(output, "[mixed] ");
-            break;
-        case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
-        /* not used. */
-            break;
-        case XML_SCHEMA_CONTENT_BASIC:
-            fprintf(output, "[basic] ");
-            break;
-        case XML_SCHEMA_CONTENT_SIMPLE:
-            fprintf(output, "[simple] ");
-            break;
-        case XML_SCHEMA_CONTENT_ANY:
-            fprintf(output, "[any] ");
-            break;
-    }
-    fprintf(output, "\n");
-    if (type->base != NULL) {
-        fprintf(output, "  base type: '%s'", type->base);
-        if (type->baseNs != NULL)
-            fprintf(output, " ns '%s'\n", type->baseNs);
-        else
-            fprintf(output, "\n");
-    }
-    if (type->attrUses != NULL)
-        xmlSchemaAttrUsesDump(type->attrUses, output);
-    if (type->annot != NULL)
-        xmlSchemaAnnotDump(output, type->annot);
-#ifdef DUMP_CONTENT_MODEL
-    if ((type->type == XML_SCHEMA_TYPE_COMPLEX) &&
-        (type->subtypes != NULL)) {
-        xmlSchemaContentModelDump((xmlSchemaParticlePtr) type->subtypes,
-            output, 1);
-    }
-#endif
-}
-
-/**
- * xmlSchemaDump:
- * @output:  the file output
- * @schema:  a schema structure
- *
- * Dump a Schema structure.
- */
-void
-xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
-{
-    if (output == NULL)
-        return;
-    if (schema == NULL) {
-        fprintf(output, "Schemas: NULL\n");
-        return;
-    }
-    fprintf(output, "Schemas: ");
-    if (schema->name != NULL)
-        fprintf(output, "%s, ", schema->name);
-    else
-        fprintf(output, "no name, ");
-    if (schema->targetNamespace != NULL)
-        fprintf(output, "%s", (const char *) schema->targetNamespace);
-    else
-        fprintf(output, "no target namespace");
-    fprintf(output, "\n");
-    if (schema->annot != NULL)
-        xmlSchemaAnnotDump(output, schema->annot);
-    xmlHashScan(schema->typeDecl, (xmlHashScanner) xmlSchemaTypeDump,
-                output);
-    xmlHashScanFull(schema->elemDecl,
-                    (xmlHashScannerFull) xmlSchemaElementDump, output);
-}
-
-#ifdef DEBUG_IDC_NODE_TABLE
-/**
- * xmlSchemaDebugDumpIDCTable:
- * @vctxt: the WXS validation context
- *
- * Displays the current IDC table for debug purposes.
- */
-static void
-xmlSchemaDebugDumpIDCTable(FILE * output,
-                           const xmlChar *namespaceName,
-                           const xmlChar *localName,
-                           xmlSchemaPSVIIDCBindingPtr bind)
-{
-    xmlChar *str = NULL;
-    const xmlChar *value;
-    xmlSchemaPSVIIDCNodePtr tab;
-    xmlSchemaPSVIIDCKeyPtr key;
-    int i, j, res;
-
-    fprintf(output, "IDC: TABLES on '%s'\n",
-        xmlSchemaFormatQName(&str, namespaceName, localName));
-    FREE_AND_NULL(str)
-
-    if (bind == NULL)
-        return;
-    do {
-        fprintf(output, "IDC:   BINDING '%s' (%d)\n",
-            xmlSchemaGetComponentQName(&str,
-                bind->definition), bind->nbNodes);
-        FREE_AND_NULL(str)
-        for (i = 0; i < bind->nbNodes; i++) {
-            tab = bind->nodeTable[i];
-            fprintf(output, "         ( ");
-            for (j = 0; j < bind->definition->nbFields; j++) {
-                key = tab->keys[j];
-                if ((key != NULL) && (key->val != NULL)) {
-                    res = xmlSchemaGetCanonValue(key->val, &value);
-                    if (res >= 0)
-                        fprintf(output, "'%s' ", value);
-                    else
-                        fprintf(output, "CANON-VALUE-FAILED ");
-                    if (res == 0)
-                        FREE_AND_NULL(value)
-                } else if (key != NULL)
-                    fprintf(output, "(no val), ");
-                else
-                    fprintf(output, "(key missing), ");
-            }
-            fprintf(output, ")\n");
-        }
-        if (bind->dupls && bind->dupls->nbItems) {
-            fprintf(output, "IDC:     dupls (%d):\n", bind->dupls->nbItems);
-            for (i = 0; i < bind->dupls->nbItems; i++) {
-                tab = bind->dupls->items[i];
-                fprintf(output, "         ( ");
-                for (j = 0; j < bind->definition->nbFields; j++) {
-                    key = tab->keys[j];
-                    if ((key != NULL) && (key->val != NULL)) {
-                        res = xmlSchemaGetCanonValue(key->val, &value);
-                        if (res >= 0)
-                            fprintf(output, "'%s' ", value);
-                        else
-                            fprintf(output, "CANON-VALUE-FAILED ");
-                        if (res == 0)
-                            FREE_AND_NULL(value)
-                    } else if (key != NULL)
-                    fprintf(output, "(no val), ");
-                        else
-                            fprintf(output, "(key missing), ");
-                }
-                fprintf(output, ")\n");
-            }
-        }
-        bind = bind->next;
-    } while (bind != NULL);
-}
-#endif /* DEBUG_IDC */
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-/************************************************************************
- *                                                                      *
- *                      Utilities                                       *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaGetPropNode:
- * @node: the element node
- * @name: the name of the attribute
- *
- * Seeks an attribute with a name of @name in
- * no namespace.
- *
- * Returns the attribute or NULL if not present.
- */
-static xmlAttrPtr
-xmlSchemaGetPropNode(xmlNodePtr node, const char *name)
-{
-    xmlAttrPtr prop;
-
-    if ((node == NULL) || (name == NULL))
-        return(NULL);
-    prop = node->properties;
-    while (prop != NULL) {
-        if ((prop->ns == NULL) && xmlStrEqual(prop->name, BAD_CAST name))
-            return(prop);
-        prop = prop->next;
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaGetPropNodeNs:
- * @node: the element node
- * @uri: the uri
- * @name: the name of the attribute
- *
- * Seeks an attribute with a local name of @name and
- * a namespace URI of @uri.
- *
- * Returns the attribute or NULL if not present.
- */
-static xmlAttrPtr
-xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
-{
-    xmlAttrPtr prop;
-
-    if ((node == NULL) || (name == NULL))
-        return(NULL);
-    prop = node->properties;
-    while (prop != NULL) {
-        if ((prop->ns != NULL) &&
-            xmlStrEqual(prop->name, BAD_CAST name) &&
-            xmlStrEqual(prop->ns->href, BAD_CAST uri))
-            return(prop);
-        prop = prop->next;
-    }
-    return (NULL);
-}
-
-static const xmlChar *
-xmlSchemaGetNodeContent(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
-{
-    xmlChar *val;
-    const xmlChar *ret;
-
-    val = xmlNodeGetContent(node);
-    if (val == NULL)
-        val = xmlStrdup((xmlChar *)"");
-    ret = xmlDictLookup(ctxt->dict, val, -1);
-    xmlFree(val);
-    return(ret);
-}
-
-static const xmlChar *
-xmlSchemaGetNodeContentNoDict(xmlNodePtr node)
-{
-    return((const xmlChar*) xmlNodeGetContent(node));
-}
-
-/**
- * xmlSchemaGetProp:
- * @ctxt: the parser context
- * @node: the node
- * @name: the property name
- *
- * Read a attribute value and internalize the string
- *
- * Returns the string or NULL if not present.
- */
-static const xmlChar *
-xmlSchemaGetProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
-                 const char *name)
-{
-    xmlChar *val;
-    const xmlChar *ret;
-
-    val = xmlGetNoNsProp(node, BAD_CAST name);
-    if (val == NULL)
-        return(NULL);
-    ret = xmlDictLookup(ctxt->dict, val, -1);
-    xmlFree(val);
-    return(ret);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Parsing functions                               *
- *                                                                      *
- ************************************************************************/
-
-#define WXS_FIND_GLOBAL_ITEM(slot)                      \
-    if (xmlStrEqual(nsName, schema->targetNamespace)) { \
-        ret = xmlHashLookup(schema->slot, name); \
-        if (ret != NULL) goto exit; \
-    } \
-    if (xmlHashSize(schema->schemasImports) > 1) { \
-        xmlSchemaImportPtr import; \
-        if (nsName == NULL) \
-            import = xmlHashLookup(schema->schemasImports, \
-                XML_SCHEMAS_NO_NAMESPACE); \
-        else \
-            import = xmlHashLookup(schema->schemasImports, nsName); \
-        if (import == NULL) \
-            goto exit; \
-        ret = xmlHashLookup(import->schema->slot, name); \
-    }
-
-/**
- * xmlSchemaGetElem:
- * @schema:  the schema context
- * @name:  the element name
- * @ns:  the element namespace
- *
- * Lookup a global element declaration in the schema.
- *
- * Returns the element declaration or NULL if not found.
- */
-static xmlSchemaElementPtr
-xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
-                 const xmlChar * nsName)
-{
-    xmlSchemaElementPtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return(NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(elemDecl)
-    }
-exit:
-#ifdef DEBUG
-    if (ret == NULL) {
-        if (nsName == NULL)
-            fprintf(stderr, "Unable to lookup element decl. %s", name);
-        else
-            fprintf(stderr, "Unable to lookup element decl. %s:%s", name,
-                    nsName);
-    }
-#endif
-    return (ret);
-}
-
-/**
- * xmlSchemaGetType:
- * @schema:  the main schema
- * @name:  the type's name
- * nsName:  the type's namespace
- *
- * Lookup a type in the schemas or the predefined types
- *
- * Returns the group definition or NULL if not found.
- */
-static xmlSchemaTypePtr
-xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
-                 const xmlChar * nsName)
-{
-    xmlSchemaTypePtr ret = NULL;
-
-    if (name == NULL)
-        return (NULL);
-    /* First try the built-in types. */
-    if ((nsName != NULL) && xmlStrEqual(nsName, xmlSchemaNs)) {
-        ret = xmlSchemaGetPredefinedType(name, nsName);
-        if (ret != NULL)
-            goto exit;
-        /*
-        * Note that we try the parsed schemas as well here
-        * since one might have parsed the S4S, which contain more
-        * than the built-in types.
-        * TODO: Can we optimize this?
-        */
-    }
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(typeDecl)
-    }
-exit:
-
-#ifdef DEBUG
-    if (ret == NULL) {
-        if (nsName == NULL)
-            fprintf(stderr, "Unable to lookup type %s", name);
-        else
-            fprintf(stderr, "Unable to lookup type %s:%s", name,
-                    nsName);
-    }
-#endif
-    return (ret);
-}
-
-/**
- * xmlSchemaGetAttributeDecl:
- * @schema:  the context of the schema
- * @name:  the name of the attribute
- * @ns:  the target namespace of the attribute
- *
- * Lookup a an attribute in the schema or imported schemas
- *
- * Returns the attribute declaration or NULL if not found.
- */
-static xmlSchemaAttributePtr
-xmlSchemaGetAttributeDecl(xmlSchemaPtr schema, const xmlChar * name,
-                 const xmlChar * nsName)
-{
-    xmlSchemaAttributePtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return (NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(attrDecl)
-    }
-exit:
-#ifdef DEBUG
-    if (ret == NULL) {
-        if (nsName == NULL)
-            fprintf(stderr, "Unable to lookup attribute %s", name);
-        else
-            fprintf(stderr, "Unable to lookup attribute %s:%s", name,
-                    nsName);
-    }
-#endif
-    return (ret);
-}
-
-/**
- * xmlSchemaGetAttributeGroup:
- * @schema:  the context of the schema
- * @name:  the name of the attribute group
- * @ns:  the target namespace of the attribute group
- *
- * Lookup a an attribute group in the schema or imported schemas
- *
- * Returns the attribute group definition or NULL if not found.
- */
-static xmlSchemaAttributeGroupPtr
-xmlSchemaGetAttributeGroup(xmlSchemaPtr schema, const xmlChar * name,
-                 const xmlChar * nsName)
-{
-    xmlSchemaAttributeGroupPtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return (NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(attrgrpDecl)
-    }
-exit:
-    /* TODO:
-    if ((ret != NULL) && (ret->redef != NULL)) {
-        * Return the last redefinition. *
-        ret = ret->redef;
-    }
-    */
-#ifdef DEBUG
-    if (ret == NULL) {
-        if (nsName == NULL)
-            fprintf(stderr, "Unable to lookup attribute group %s", name);
-        else
-            fprintf(stderr, "Unable to lookup attribute group %s:%s", name,
-                    nsName);
-    }
-#endif
-    return (ret);
-}
-
-/**
- * xmlSchemaGetGroup:
- * @schema:  the context of the schema
- * @name:  the name of the group
- * @ns:  the target namespace of the group
- *
- * Lookup a group in the schema or imported schemas
- *
- * Returns the group definition or NULL if not found.
- */
-static xmlSchemaModelGroupDefPtr
-xmlSchemaGetGroup(xmlSchemaPtr schema, const xmlChar * name,
-                 const xmlChar * nsName)
-{
-    xmlSchemaModelGroupDefPtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return (NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(groupDecl)
-    }
-exit:
-
-#ifdef DEBUG
-    if (ret == NULL) {
-        if (nsName == NULL)
-            fprintf(stderr, "Unable to lookup group %s", name);
-        else
-            fprintf(stderr, "Unable to lookup group %s:%s", name,
-                    nsName);
-    }
-#endif
-    return (ret);
-}
-
-static xmlSchemaNotationPtr
-xmlSchemaGetNotation(xmlSchemaPtr schema,
-                     const xmlChar *name,
-                     const xmlChar *nsName)
-{
-    xmlSchemaNotationPtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return (NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(notaDecl)
-    }
-exit:
-    return (ret);
-}
-
-static xmlSchemaIDCPtr
-xmlSchemaGetIDC(xmlSchemaPtr schema,
-                const xmlChar *name,
-                const xmlChar *nsName)
-{
-    xmlSchemaIDCPtr ret = NULL;
-
-    if ((name == NULL) || (schema == NULL))
-        return (NULL);
-    if (schema != NULL) {
-        WXS_FIND_GLOBAL_ITEM(idcDef)
-    }
-exit:
-    return (ret);
-}
-
-/**
- * xmlSchemaGetNamedComponent:
- * @schema:  the schema
- * @name:  the name of the group
- * @ns:  the target namespace of the group
- *
- * Lookup a group in the schema or imported schemas
- *
- * Returns the group definition or NULL if not found.
- */
-static xmlSchemaBasicItemPtr
-xmlSchemaGetNamedComponent(xmlSchemaPtr schema,
-                           xmlSchemaTypeType itemType,
-                           const xmlChar *name,
-                           const xmlChar *targetNs)
-{
-    switch (itemType) {
-        case XML_SCHEMA_TYPE_GROUP:
-            return ((xmlSchemaBasicItemPtr) xmlSchemaGetGroup(schema,
-                name, targetNs));
-        case XML_SCHEMA_TYPE_ELEMENT:
-            return ((xmlSchemaBasicItemPtr) xmlSchemaGetElem(schema,
-                name, targetNs));
-        default:
-            TODO
-            return (NULL);
-    }
-}
-
-/************************************************************************
- *                                                                      *
- *                      Parsing functions                               *
- *                                                                      *
- ************************************************************************/
-
-#define IS_BLANK_NODE(n)                                                \
-    (((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content, -1)))
-
-/**
- * xmlSchemaIsBlank:
- * @str:  a string
- * @len: the length of the string or -1
- *
- * Check if a string is ignorable
- *
- * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
- */
-static int
-xmlSchemaIsBlank(xmlChar * str, int len)
-{
-    if (str == NULL)
-        return (1);
-    if (len < 0) {
-        while (*str != 0) {
-            if (!(IS_BLANK_CH(*str)))
-                return (0);
-            str++;
-        }
-    } else while ((*str != 0) && (len != 0)) {
-        if (!(IS_BLANK_CH(*str)))
-            return (0);
-        str++;
-        len--;
-    }
-
-    return (1);
-}
-
-#define WXS_COMP_NAME(c, t) ((t) (c))->name
-#define WXS_COMP_TNS(c, t) ((t) (c))->targetNamespace
-/*
-* xmlSchemaFindRedefCompInGraph:
-* ATTENTION TODO: This uses pointer comp. for strings.
-*/
-static xmlSchemaBasicItemPtr
-xmlSchemaFindRedefCompInGraph(xmlSchemaBucketPtr bucket,
-                              xmlSchemaTypeType type,
-                              const xmlChar *name,
-                              const xmlChar *nsName)
-{
-    xmlSchemaBasicItemPtr ret;
-    int i;
-
-    if ((bucket == NULL) || (name == NULL))
-        return(NULL);
-    if ((bucket->globals == NULL) ||
-        (bucket->globals->nbItems == 0))
-        goto subschemas;
-    /*
-    * Search in global components.
-    */
-    for (i = 0; i < bucket->globals->nbItems; i++) {
-        ret = bucket->globals->items[i];
-        if (ret->type == type) {
-            switch (type) {
-                case XML_SCHEMA_TYPE_COMPLEX:
-                case XML_SCHEMA_TYPE_SIMPLE:
-                    if ((WXS_COMP_NAME(ret, xmlSchemaTypePtr) == name) &&
-                        (WXS_COMP_TNS(ret, xmlSchemaTypePtr) ==
-                        nsName))
-                    {
-                        return(ret);
-                    }
-                    break;
-                case XML_SCHEMA_TYPE_GROUP:
-                    if ((WXS_COMP_NAME(ret,
-                            xmlSchemaModelGroupDefPtr) == name) &&
-                        (WXS_COMP_TNS(ret,
-                            xmlSchemaModelGroupDefPtr) == nsName))
-                    {
-                        return(ret);
-                    }
-                    break;
-                case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                    if ((WXS_COMP_NAME(ret,
-                            xmlSchemaAttributeGroupPtr) == name) &&
-                        (WXS_COMP_TNS(ret,
-                            xmlSchemaAttributeGroupPtr) == nsName))
-                    {
-                        return(ret);
-                    }
-                    break;
-                default:
-                    /* Should not be hit. */
-                    return(NULL);
-            }
-        }
-    }
-subschemas:
-    /*
-    * Process imported/included schemas.
-    */
-    if (bucket->relations != NULL) {
-        xmlSchemaSchemaRelationPtr rel = bucket->relations;
-
-        /*
-        * TODO: Marking the bucket will not avoid multiple searches
-        * in the same schema, but avoids at least circularity.
-        */
-        bucket->flags |= XML_SCHEMA_BUCKET_MARKED;
-        do {
-            if ((rel->bucket != NULL) &&
-                ((rel->bucket->flags & XML_SCHEMA_BUCKET_MARKED) == 0)) {
-                ret = xmlSchemaFindRedefCompInGraph(rel->bucket,
-                    type, name, nsName);
-                if (ret != NULL)
-                    return(ret);
-            }
-            rel = rel->next;
-        } while (rel != NULL);
-         bucket->flags ^= XML_SCHEMA_BUCKET_MARKED;
-    }
-    return(NULL);
-}
-
-/**
- * xmlSchemaAddNotation:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the item name
- *
- * Add an XML schema annotation declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaNotationPtr
-xmlSchemaAddNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                     const xmlChar *name, const xmlChar *nsName,
-                     xmlNodePtr node ATTRIBUTE_UNUSED)
-{
-    xmlSchemaNotationPtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaNotationPtr) xmlMalloc(sizeof(xmlSchemaNotation));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "add annotation", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaNotation));
-    ret->type = XML_SCHEMA_TYPE_NOTATION;
-    ret->name = name;
-    ret->targetNamespace = nsName;
-    /* TODO: do we need the node to be set?
-    * ret->node = node;*/
-    WXS_ADD_GLOBAL(ctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaAddAttribute:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the item name
- * @namespace:  the namespace
- *
- * Add an XML schema Attrribute declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaAttributePtr
-xmlSchemaAddAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                      const xmlChar * name, const xmlChar * nsName,
-                      xmlNodePtr node, int topLevel)
-{
-    xmlSchemaAttributePtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaAttributePtr) xmlMalloc(sizeof(xmlSchemaAttribute));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating attribute", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaAttribute));
-    ret->type = XML_SCHEMA_TYPE_ATTRIBUTE;
-    ret->node = node;
-    ret->name = name;
-    ret->targetNamespace = nsName;
-
-    if (topLevel)
-        WXS_ADD_GLOBAL(ctxt, ret);
-    else
-        WXS_ADD_LOCAL(ctxt, ret);
-    WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaAddAttributeUse:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the item name
- * @namespace:  the namespace
- *
- * Add an XML schema Attrribute declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaAttributeUsePtr
-xmlSchemaAddAttributeUse(xmlSchemaParserCtxtPtr pctxt,
-                         xmlNodePtr node)
-{
-    xmlSchemaAttributeUsePtr ret = NULL;
-
-    if (pctxt == NULL)
-        return (NULL);
-
-    ret = (xmlSchemaAttributeUsePtr) xmlMalloc(sizeof(xmlSchemaAttributeUse));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(pctxt, "allocating attribute", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaAttributeUse));
-    ret->type = XML_SCHEMA_TYPE_ATTRIBUTE_USE;
-    ret->node = node;
-
-    WXS_ADD_LOCAL(pctxt, ret);
-    return (ret);
-}
-
-/*
-* xmlSchemaAddRedef:
-*
-* Adds a redefinition information. This is used at a later stage to:
-* resolve references to the redefined components and to check constraints.
-*/
-static xmlSchemaRedefPtr
-xmlSchemaAddRedef(xmlSchemaParserCtxtPtr pctxt,
-                  xmlSchemaBucketPtr targetBucket,
-                  void *item,
-                  const xmlChar *refName,
-                  const xmlChar *refTargetNs)
-{
-    xmlSchemaRedefPtr ret;
-
-    ret = (xmlSchemaRedefPtr)
-        xmlMalloc(sizeof(xmlSchemaRedef));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(pctxt,
-            "allocating redefinition info", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaRedef));
-    ret->item = item;
-    ret->targetBucket = targetBucket;
-    ret->refName = refName;
-    ret->refTargetNs = refTargetNs;
-    if (WXS_CONSTRUCTOR(pctxt)->redefs == NULL)
-        WXS_CONSTRUCTOR(pctxt)->redefs = ret;
-    else
-        WXS_CONSTRUCTOR(pctxt)->lastRedef->next = ret;
-    WXS_CONSTRUCTOR(pctxt)->lastRedef = ret;
-
-    return (ret);
-}
-
-/**
- * xmlSchemaAddAttributeGroupDefinition:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the item name
- * @nsName:  the target namespace
- * @node: the corresponding node
- *
- * Add an XML schema Attrribute Group definition.
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaAttributeGroupPtr
-xmlSchemaAddAttributeGroupDefinition(xmlSchemaParserCtxtPtr pctxt,
-                           xmlSchemaPtr schema ATTRIBUTE_UNUSED,
-                           const xmlChar *name,
-                           const xmlChar *nsName,
-                           xmlNodePtr node)
-{
-    xmlSchemaAttributeGroupPtr ret = NULL;
-
-    if ((pctxt == NULL) || (name == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaAttributeGroupPtr)
-        xmlMalloc(sizeof(xmlSchemaAttributeGroup));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(pctxt, "allocating attribute group", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaAttributeGroup));
-    ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
-    ret->name = name;
-    ret->targetNamespace = nsName;
-    ret->node = node;
-
-    /* TODO: Remove the flag. */
-    ret->flags |= XML_SCHEMAS_ATTRGROUP_GLOBAL;
-    if (pctxt->isRedefine) {
-        pctxt->redef = xmlSchemaAddRedef(pctxt, pctxt->redefined,
-            ret, name, nsName);
-        if (pctxt->redef == NULL) {
-            xmlFree(ret);
-            return(NULL);
-        }
-        pctxt->redefCounter = 0;
-    }
-    WXS_ADD_GLOBAL(pctxt, ret);
-    WXS_ADD_PENDING(pctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaAddElement:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the type name
- * @namespace:  the type namespace
- *
- * Add an XML schema Element declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaElementPtr
-xmlSchemaAddElement(xmlSchemaParserCtxtPtr ctxt,
-                    const xmlChar * name, const xmlChar * nsName,
-                    xmlNodePtr node, int topLevel)
-{
-    xmlSchemaElementPtr ret = NULL;
-
-    if ((ctxt == NULL) || (name == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaElementPtr) xmlMalloc(sizeof(xmlSchemaElement));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating element", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaElement));
-    ret->type = XML_SCHEMA_TYPE_ELEMENT;
-    ret->name = name;
-    ret->targetNamespace = nsName;
-    ret->node = node;
-
-    if (topLevel)
-        WXS_ADD_GLOBAL(ctxt, ret);
-    else
-        WXS_ADD_LOCAL(ctxt, ret);
-    WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaAddType:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @name:  the item name
- * @namespace:  the namespace
- *
- * Add an XML schema item
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaTypePtr
-xmlSchemaAddType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                 xmlSchemaTypeType type,
-                 const xmlChar * name, const xmlChar * nsName,
-                 xmlNodePtr node, int topLevel)
-{
-    xmlSchemaTypePtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating type", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaType));
-    ret->type = type;
-    ret->name = name;
-    ret->targetNamespace = nsName;
-    ret->node = node;
-    if (topLevel) {
-        if (ctxt->isRedefine) {
-            ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
-                ret, name, nsName);
-            if (ctxt->redef == NULL) {
-                xmlFree(ret);
-                return(NULL);
-            }
-            ctxt->redefCounter = 0;
-        }
-        WXS_ADD_GLOBAL(ctxt, ret);
-    } else
-        WXS_ADD_LOCAL(ctxt, ret);
-    WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-static xmlSchemaQNameRefPtr
-xmlSchemaNewQNameRef(xmlSchemaParserCtxtPtr pctxt,
-                     xmlSchemaTypeType refType,
-                     const xmlChar *refName,
-                     const xmlChar *refNs)
-{
-    xmlSchemaQNameRefPtr ret;
-
-    ret = (xmlSchemaQNameRefPtr)
-        xmlMalloc(sizeof(xmlSchemaQNameRef));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(pctxt,
-            "allocating QName reference item", NULL);
-        return (NULL);
-    }
-    ret->node = NULL;
-    ret->type = XML_SCHEMA_EXTRA_QNAMEREF;
-    ret->name = refName;
-    ret->targetNamespace = refNs;
-    ret->item = NULL;
-    ret->itemType = refType;
-    /*
-    * Store the reference item in the schema.
-    */
-    WXS_ADD_LOCAL(pctxt, ret);
-    return (ret);
-}
-
-static xmlSchemaAttributeUseProhibPtr
-xmlSchemaAddAttributeUseProhib(xmlSchemaParserCtxtPtr pctxt)
-{
-    xmlSchemaAttributeUseProhibPtr ret;
-
-    ret = (xmlSchemaAttributeUseProhibPtr)
-        xmlMalloc(sizeof(xmlSchemaAttributeUseProhib));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(pctxt,
-            "allocating attribute use prohibition", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaAttributeUseProhib));
-    ret->type = XML_SCHEMA_EXTRA_ATTR_USE_PROHIB;
-    WXS_ADD_LOCAL(pctxt, ret);
-    return (ret);
-}
-
-
-/**
- * xmlSchemaAddModelGroup:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @type: the "compositor" type of the model group
- * @node: the node in the schema doc
- *
- * Adds a schema model group
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaModelGroupPtr
-xmlSchemaAddModelGroup(xmlSchemaParserCtxtPtr ctxt,
-                       xmlSchemaPtr schema,
-                       xmlSchemaTypeType type,
-                       xmlNodePtr node)
-{
-    xmlSchemaModelGroupPtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaModelGroupPtr)
-        xmlMalloc(sizeof(xmlSchemaModelGroup));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating model group component",
-            NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaModelGroup));
-    ret->type = type;
-    ret->node = node;
-    WXS_ADD_LOCAL(ctxt, ret);
-    if ((type == XML_SCHEMA_TYPE_SEQUENCE) ||
-        (type == XML_SCHEMA_TYPE_CHOICE))
-        WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-
-/**
- * xmlSchemaAddParticle:
- * @ctxt:  a schema parser context
- * @schema:  the schema being built
- * @node: the corresponding node in the schema doc
- * @min: the minOccurs
- * @max: the maxOccurs
- *
- * Adds an XML schema particle component.
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaParticlePtr
-xmlSchemaAddParticle(xmlSchemaParserCtxtPtr ctxt,
-                     xmlNodePtr node, int min, int max)
-{
-    xmlSchemaParticlePtr ret = NULL;
-    if (ctxt == NULL)
-        return (NULL);
-
-#ifdef DEBUG
-    fprintf(stderr, "Adding particle component\n");
-#endif
-    ret = (xmlSchemaParticlePtr)
-        xmlMalloc(sizeof(xmlSchemaParticle));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating particle component",
-            NULL);
-        return (NULL);
-    }
-    ret->type = XML_SCHEMA_TYPE_PARTICLE;
-    ret->annot = NULL;
-    ret->node = node;
-    ret->minOccurs = min;
-    ret->maxOccurs = max;
-    ret->next = NULL;
-    ret->children = NULL;
-
-    WXS_ADD_LOCAL(ctxt, ret);
-    /*
-    * Note that addition to pending components will be done locally
-    * to the specific parsing function, since the most particles
-    * need not to be fixed up (i.e. the reference to be resolved).
-    * REMOVED: WXS_ADD_PENDING(ctxt, ret);
-    */
-    return (ret);
-}
-
-/**
- * xmlSchemaAddModelGroupDefinition:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @name:  the group name
- *
- * Add an XML schema Group definition
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaModelGroupDefPtr
-xmlSchemaAddModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaPtr schema,
-                                 const xmlChar *name,
-                                 const xmlChar *nsName,
-                                 xmlNodePtr node)
-{
-    xmlSchemaModelGroupDefPtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaModelGroupDefPtr)
-        xmlMalloc(sizeof(xmlSchemaModelGroupDef));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "adding group", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaModelGroupDef));
-    ret->name = name;
-    ret->type = XML_SCHEMA_TYPE_GROUP;
-    ret->node = node;
-    ret->targetNamespace = nsName;
-
-    if (ctxt->isRedefine) {
-        ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
-            ret, name, nsName);
-        if (ctxt->redef == NULL) {
-            xmlFree(ret);
-            return(NULL);
-        }
-        ctxt->redefCounter = 0;
-    }
-    WXS_ADD_GLOBAL(ctxt, ret);
-    WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaNewWildcardNs:
- * @ctxt:  a schema validation context
- *
- * Creates a new wildcard namespace constraint.
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaWildcardNsPtr
-xmlSchemaNewWildcardNsConstraint(xmlSchemaParserCtxtPtr ctxt)
-{
-    xmlSchemaWildcardNsPtr ret;
-
-    ret = (xmlSchemaWildcardNsPtr)
-        xmlMalloc(sizeof(xmlSchemaWildcardNs));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "creating wildcard namespace constraint", NULL);
-        return (NULL);
-    }
-    ret->value = NULL;
-    ret->next = NULL;
-    return (ret);
-}
-
-static xmlSchemaIDCPtr
-xmlSchemaAddIDC(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                  const xmlChar *name, const xmlChar *nsName,
-                  int category, xmlNodePtr node)
-{
-    xmlSchemaIDCPtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaIDCPtr) xmlMalloc(sizeof(xmlSchemaIDC));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt,
-            "allocating an identity-constraint definition", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaIDC));
-    /* The target namespace of the parent element declaration. */
-    ret->targetNamespace = nsName;
-    ret->name = name;
-    ret->type = category;
-    ret->node = node;
-
-    WXS_ADD_GLOBAL(ctxt, ret);
-    /*
-    * Only keyrefs need to be fixup up.
-    */
-    if (category == XML_SCHEMA_TYPE_IDC_KEYREF)
-        WXS_ADD_PENDING(ctxt, ret);
-    return (ret);
-}
-
-/**
- * xmlSchemaAddWildcard:
- * @ctxt:  a schema validation context
- * @schema: a schema
- *
- * Adds a wildcard.
- * It corresponds to a xsd:anyAttribute and xsd:any.
- *
- * Returns the new struture or NULL in case of error
- */
-static xmlSchemaWildcardPtr
-xmlSchemaAddWildcard(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                     xmlSchemaTypeType type, xmlNodePtr node)
-{
-    xmlSchemaWildcardPtr ret = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL))
-        return (NULL);
-
-    ret = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(ctxt, "adding wildcard", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaWildcard));
-    ret->type = type;
-    ret->node = node;
-    WXS_ADD_LOCAL(ctxt, ret);
-    return (ret);
-}
-
-static void
-xmlSchemaSubstGroupFree(xmlSchemaSubstGroupPtr group)
-{
-    if (group == NULL)
-        return;
-    if (group->members != NULL)
-        xmlSchemaItemListFree(group->members);
-    xmlFree(group);
-}
-
-static xmlSchemaSubstGroupPtr
-xmlSchemaSubstGroupAdd(xmlSchemaParserCtxtPtr pctxt,
-                       xmlSchemaElementPtr head)
-{
-    xmlSchemaSubstGroupPtr ret;
-
-    /* Init subst group hash. */
-    if (WXS_SUBST_GROUPS(pctxt) == NULL) {
-        WXS_SUBST_GROUPS(pctxt) = xmlHashCreateDict(10, pctxt->dict);
-        if (WXS_SUBST_GROUPS(pctxt) == NULL)
-            return(NULL);
-    }
-    /* Create a new substitution group. */
-    ret = (xmlSchemaSubstGroupPtr) xmlMalloc(sizeof(xmlSchemaSubstGroup));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL,
-            "allocating a substitution group container", NULL);
-        return(NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaSubstGroup));
-    ret->head = head;
-    /* Create list of members. */
-    ret->members = xmlSchemaItemListCreate();
-    if (ret->members == NULL) {
-        xmlSchemaSubstGroupFree(ret);
-        return(NULL);
-    }
-    /* Add subst group to hash. */
-    if (xmlHashAddEntry2(WXS_SUBST_GROUPS(pctxt),
-        head->name, head->targetNamespace, ret) != 0) {
-        PERROR_INT("xmlSchemaSubstGroupAdd",
-            "failed to add a new substitution container");
-        xmlSchemaSubstGroupFree(ret);
-        return(NULL);
-    }
-    return(ret);
-}
-
-static xmlSchemaSubstGroupPtr
-xmlSchemaSubstGroupGet(xmlSchemaParserCtxtPtr pctxt,
-                       xmlSchemaElementPtr head)
-{
-    if (WXS_SUBST_GROUPS(pctxt) == NULL)
-        return(NULL);
-    return(xmlHashLookup2(WXS_SUBST_GROUPS(pctxt),
-        head->name, head->targetNamespace));
-
-}
-
-/**
- * xmlSchemaAddElementSubstitutionMember:
- * @pctxt:  a schema parser context
- * @head:  the head of the substitution group
- * @member: the new member of the substitution group
- *
- * Allocate a new annotation structure.
- *
- * Returns the newly allocated structure or NULL in case or error
- */
-static int
-xmlSchemaAddElementSubstitutionMember(xmlSchemaParserCtxtPtr pctxt,
-                                      xmlSchemaElementPtr head,
-                                      xmlSchemaElementPtr member)
-{
-    xmlSchemaSubstGroupPtr substGroup = NULL;
-
-    if ((pctxt == NULL) || (head == NULL) || (member == NULL))
-        return (-1);
-
-    substGroup = xmlSchemaSubstGroupGet(pctxt, head);
-    if (substGroup == NULL)
-        substGroup = xmlSchemaSubstGroupAdd(pctxt, head);
-    if (substGroup == NULL)
-        return(-1);
-    if (xmlSchemaItemListAdd(substGroup->members, member) == -1)
-        return(-1);
-    return(0);
-}
-
-/************************************************************************
- *                                                                      *
- *              Utilities for parsing                                   *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaPValAttrNodeQNameValue:
- * @ctxt:  a schema parser context
- * @schema: the schema context
- * @ownerDes: the designation of the parent element
- * @ownerItem: the parent as a schema object
- * @value:  the QName value
- * @local: the resulting local part if found, the attribute value otherwise
- * @uri:  the resulting namespace URI if found
- *
- * Extracts the local name and the URI of a QName value and validates it.
- * This one is intended to be used on attribute values that
- * should resolve to schema components.
- *
- * Returns 0, in case the QName is valid, a positive error code
- * if not valid and -1 if an internal error occurs.
- */
-static int
-xmlSchemaPValAttrNodeQNameValue(xmlSchemaParserCtxtPtr ctxt,
-                                       xmlSchemaPtr schema,
-                                       xmlSchemaBasicItemPtr ownerItem,
-                                       xmlAttrPtr attr,
-                                       const xmlChar *value,
-                                       const xmlChar **uri,
-                                       const xmlChar **local)
-{
-    const xmlChar *pref;
-    xmlNsPtr ns;
-    int len, ret;
-
-    *uri = NULL;
-    *local = NULL;
-    ret = xmlValidateQName(value, 1);
-    if (ret > 0) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            ownerItem, (xmlNodePtr) attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
-            NULL, value, NULL, NULL, NULL);
-        *local = value;
-        return (ctxt->err);
-    } else if (ret < 0)
-        return (-1);
-
-    if (!strchr((char *) value, ':')) {
-        ns = xmlSearchNs(attr->doc, attr->parent, NULL);
-        if (ns)
-            *uri = xmlDictLookup(ctxt->dict, ns->href, -1);
-        else if (schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) {
-            /* TODO: move XML_SCHEMAS_INCLUDING_CONVERT_NS to the
-            * parser context. */
-            /*
-            * This one takes care of included schemas with no
-            * target namespace.
-            */
-            *uri = ctxt->targetNamespace;
-        }
-        *local = xmlDictLookup(ctxt->dict, value, -1);
-        return (0);
-    }
-    /*
-    * At this point xmlSplitQName3 has to return a local name.
-    */
-    *local = xmlSplitQName3(value, &len);
-    *local = xmlDictLookup(ctxt->dict, *local, -1);
-    pref = xmlDictLookup(ctxt->dict, value, len);
-    ns = xmlSearchNs(attr->doc, attr->parent, pref);
-    if (ns == NULL) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            ownerItem, (xmlNodePtr) attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), NULL, value,
-            "The value '%s' of simple type 'xs:QName' has no "
-            "corresponding namespace declaration in scope", value, NULL);
-        return (ctxt->err);
-    } else {
-        *uri = xmlDictLookup(ctxt->dict, ns->href, -1);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaPValAttrNodeQName:
- * @ctxt:  a schema parser context
- * @schema: the schema context
- * @ownerDes: the designation of the owner element
- * @ownerItem: the owner as a schema object
- * @attr:  the attribute node
- * @local: the resulting local part if found, the attribute value otherwise
- * @uri:  the resulting namespace URI if found
- *
- * Extracts and validates the QName of an attribute value.
- * This one is intended to be used on attribute values that
- * should resolve to schema components.
- *
- * Returns 0, in case the QName is valid, a positive error code
- * if not valid and -1 if an internal error occurs.
- */
-static int
-xmlSchemaPValAttrNodeQName(xmlSchemaParserCtxtPtr ctxt,
-                                       xmlSchemaPtr schema,
-                                       xmlSchemaBasicItemPtr ownerItem,
-                                       xmlAttrPtr attr,
-                                       const xmlChar **uri,
-                                       const xmlChar **local)
-{
-    const xmlChar *value;
-
-    value = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-    return (xmlSchemaPValAttrNodeQNameValue(ctxt, schema,
-        ownerItem, attr, value, uri, local));
-}
-
-/**
- * xmlSchemaPValAttrQName:
- * @ctxt:  a schema parser context
- * @schema: the schema context
- * @ownerDes: the designation of the parent element
- * @ownerItem: the owner as a schema object
- * @ownerElem:  the parent node of the attribute
- * @name:  the name of the attribute
- * @local: the resulting local part if found, the attribute value otherwise
- * @uri:  the resulting namespace URI if found
- *
- * Extracts and validates the QName of an attribute value.
- *
- * Returns 0, in case the QName is valid, a positive error code
- * if not valid and -1 if an internal error occurs.
- */
-static int
-xmlSchemaPValAttrQName(xmlSchemaParserCtxtPtr ctxt,
-                                   xmlSchemaPtr schema,
-                                   xmlSchemaBasicItemPtr ownerItem,
-                                   xmlNodePtr ownerElem,
-                                   const char *name,
-                                   const xmlChar **uri,
-                                   const xmlChar **local)
-{
-    xmlAttrPtr attr;
-
-    attr = xmlSchemaGetPropNode(ownerElem, name);
-    if (attr == NULL) {
-        *local = NULL;
-        *uri = NULL;
-        return (0);
-    }
-    return (xmlSchemaPValAttrNodeQName(ctxt, schema,
-        ownerItem, attr, uri, local));
-}
-
-/**
- * xmlSchemaPValAttrID:
- * @ctxt:  a schema parser context
- * @schema: the schema context
- * @ownerDes: the designation of the parent element
- * @ownerItem: the owner as a schema object
- * @ownerElem:  the parent node of the attribute
- * @name:  the name of the attribute
- *
- * Extracts and validates the ID of an attribute value.
- *
- * Returns 0, in case the ID is valid, a positive error code
- * if not valid and -1 if an internal error occurs.
- */
-static int
-xmlSchemaPValAttrNodeID(xmlSchemaParserCtxtPtr ctxt, xmlAttrPtr attr)
-{
-    int ret;
-    const xmlChar *value;
-
-    if (attr == NULL)
-        return(0);
-    value = xmlSchemaGetNodeContentNoDict((xmlNodePtr) attr);
-    ret = xmlValidateNCName(value, 1);
-    if (ret == 0) {
-        /*
-        * NOTE: the IDness might have already be declared in the DTD
-        */
-        if (attr->atype != XML_ATTRIBUTE_ID) {
-            xmlIDPtr res;
-            xmlChar *strip;
-
-            /*
-            * TODO: Use xmlSchemaStrip here; it's not exported at this
-            * moment.
-            */
-            strip = xmlSchemaCollapseString(value);
-            if (strip != NULL) {
-                xmlFree((xmlChar *) value);
-                value = strip;
-            }
-            res = xmlAddID(NULL, attr->doc, value, attr);
-            if (res == NULL) {
-                ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
-                xmlSchemaPSimpleTypeErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                    NULL, (xmlNodePtr) attr,
-                    xmlSchemaGetBuiltInType(XML_SCHEMAS_ID),
-                    NULL, NULL, "Duplicate value '%s' of simple "
-                    "type 'xs:ID'", value, NULL);
-            } else
-                attr->atype = XML_ATTRIBUTE_ID;
-        }
-    } else if (ret > 0) {
-        ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            NULL, (xmlNodePtr) attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_ID),
-            NULL, NULL, "The value '%s' of simple type 'xs:ID' is "
-            "not a valid 'xs:NCName'",
-            value, NULL);
-    }
-    if (value != NULL)
-        xmlFree((xmlChar *)value);
-
-    return (ret);
-}
-
-static int
-xmlSchemaPValAttrID(xmlSchemaParserCtxtPtr ctxt,
-                    xmlNodePtr ownerElem,
-                    const xmlChar *name)
-{
-    xmlAttrPtr attr;
-
-    attr = xmlSchemaGetPropNode(ownerElem, (const char *) name);
-    if (attr == NULL)
-        return(0);
-    return(xmlSchemaPValAttrNodeID(ctxt, attr));
-
-}
-
-/**
- * xmlGetMaxOccurs:
- * @ctxt:  a schema validation context
- * @node:  a subtree containing XML Schema informations
- *
- * Get the maxOccurs property
- *
- * Returns the default if not found, or the value
- */
-static int
-xmlGetMaxOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
-                int min, int max, int def, const char *expected)
-{
-    const xmlChar *val, *cur;
-    int ret = 0;
-    xmlAttrPtr attr;
-
-    attr = xmlSchemaGetPropNode(node, "maxOccurs");
-    if (attr == NULL)
-        return (def);
-    val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-
-    if (xmlStrEqual(val, (const xmlChar *) "unbounded")) {
-        if (max != UNBOUNDED) {
-            xmlSchemaPSimpleTypeErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                /* XML_SCHEMAP_INVALID_MINOCCURS, */
-                NULL, (xmlNodePtr) attr, NULL, expected,
-                val, NULL, NULL, NULL);
-            return (def);
-        } else
-            return (UNBOUNDED);  /* encoding it with -1 might be another option */
-    }
-
-    cur = val;
-    while (IS_BLANK_CH(*cur))
-        cur++;
-    if (*cur == 0) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            /* XML_SCHEMAP_INVALID_MINOCCURS, */
-            NULL, (xmlNodePtr) attr, NULL, expected,
-            val, NULL, NULL, NULL);
-        return (def);
-    }
-    while ((*cur >= '0') && (*cur <= '9')) {
-        ret = ret * 10 + (*cur - '0');
-        cur++;
-    }
-    while (IS_BLANK_CH(*cur))
-        cur++;
-    /*
-    * TODO: Restrict the maximal value to Integer.
-    */
-    if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            /* XML_SCHEMAP_INVALID_MINOCCURS, */
-            NULL, (xmlNodePtr) attr, NULL, expected,
-            val, NULL, NULL, NULL);
-        return (def);
-    }
-    return (ret);
-}
-
-/**
- * xmlGetMinOccurs:
- * @ctxt:  a schema validation context
- * @node:  a subtree containing XML Schema informations
- *
- * Get the minOccurs property
- *
- * Returns the default if not found, or the value
- */
-static int
-xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
-                int min, int max, int def, const char *expected)
-{
-    const xmlChar *val, *cur;
-    int ret = 0;
-    xmlAttrPtr attr;
-
-    attr = xmlSchemaGetPropNode(node, "minOccurs");
-    if (attr == NULL)
-        return (def);
-    val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-    cur = val;
-    while (IS_BLANK_CH(*cur))
-        cur++;
-    if (*cur == 0) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            /* XML_SCHEMAP_INVALID_MINOCCURS, */
-            NULL, (xmlNodePtr) attr, NULL, expected,
-            val, NULL, NULL, NULL);
-        return (def);
-    }
-    while ((*cur >= '0') && (*cur <= '9')) {
-        ret = ret * 10 + (*cur - '0');
-        cur++;
-    }
-    while (IS_BLANK_CH(*cur))
-        cur++;
-    /*
-    * TODO: Restrict the maximal value to Integer.
-    */
-    if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            /* XML_SCHEMAP_INVALID_MINOCCURS, */
-            NULL, (xmlNodePtr) attr, NULL, expected,
-            val, NULL, NULL, NULL);
-        return (def);
-    }
-    return (ret);
-}
-
-/**
- * xmlSchemaPGetBoolNodeValue:
- * @ctxt:  a schema validation context
- * @ownerDes:  owner designation
- * @ownerItem:  the owner as a schema item
- * @node: the node holding the value
- *
- * Converts a boolean string value into 1 or 0.
- *
- * Returns 0 or 1.
- */
-static int
-xmlSchemaPGetBoolNodeValue(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaBasicItemPtr ownerItem,
-                           xmlNodePtr node)
-{
-    xmlChar *value = NULL;
-    int res = 0;
-
-    value = xmlNodeGetContent(node);
-    /*
-    * 3.2.2.1 Lexical representation
-    * An instance of a datatype that is defined as `boolean`
-    * can have the following legal literals {true, false, 1, 0}.
-    */
-    if (xmlStrEqual(BAD_CAST value, BAD_CAST "true"))
-        res = 1;
-    else if (xmlStrEqual(BAD_CAST value, BAD_CAST "false"))
-        res = 0;
-    else if (xmlStrEqual(BAD_CAST value, BAD_CAST "1"))
-        res = 1;
-    else if (xmlStrEqual(BAD_CAST value, BAD_CAST "0"))
-        res = 0;
-    else {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_INVALID_BOOLEAN,
-            ownerItem, node,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
-            NULL, BAD_CAST value,
-            NULL, NULL, NULL);
-    }
-    if (value != NULL)
-        xmlFree(value);
-    return (res);
-}
-
-/**
- * xmlGetBooleanProp:
- * @ctxt:  a schema validation context
- * @node:  a subtree containing XML Schema informations
- * @name:  the attribute name
- * @def:  the default value
- *
- * Evaluate if a boolean property is set
- *
- * Returns the default if not found, 0 if found to be false,
- * 1 if found to be true
- */
-static int
-xmlGetBooleanProp(xmlSchemaParserCtxtPtr ctxt,
-                  xmlNodePtr node,
-                  const char *name, int def)
-{
-    const xmlChar *val;
-
-    val = xmlSchemaGetProp(ctxt, node, name);
-    if (val == NULL)
-        return (def);
-    /*
-    * 3.2.2.1 Lexical representation
-    * An instance of a datatype that is defined as `boolean`
-    * can have the following legal literals {true, false, 1, 0}.
-    */
-    if (xmlStrEqual(val, BAD_CAST "true"))
-        def = 1;
-    else if (xmlStrEqual(val, BAD_CAST "false"))
-        def = 0;
-    else if (xmlStrEqual(val, BAD_CAST "1"))
-        def = 1;
-    else if (xmlStrEqual(val, BAD_CAST "0"))
-        def = 0;
-    else {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_INVALID_BOOLEAN,
-            NULL,
-            (xmlNodePtr) xmlSchemaGetPropNode(node, name),
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
-            NULL, val, NULL, NULL, NULL);
-    }
-    return (def);
-}
-
-/************************************************************************
- *                                                                      *
- *              Shema extraction from an Infoset                        *
- *                                                                      *
- ************************************************************************/
-static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
-                                                 ctxt, xmlSchemaPtr schema,
-                                                 xmlNodePtr node,
-                                                 int topLevel);
-static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
-                                                  ctxt,
-                                                  xmlSchemaPtr schema,
-                                                  xmlNodePtr node,
-                                                  int topLevel);
-static xmlSchemaTypePtr xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr
-                                                  ctxt,
-                                                  xmlSchemaPtr schema,
-                                                  xmlNodePtr node,
-                                                  xmlSchemaTypeType parentType);
-static xmlSchemaBasicItemPtr
-xmlSchemaParseLocalAttribute(xmlSchemaParserCtxtPtr pctxt,
-                             xmlSchemaPtr schema,
-                             xmlNodePtr node,
-                             xmlSchemaItemListPtr uses,
-                             int parentType);
-static xmlSchemaTypePtr xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt,
-                                           xmlSchemaPtr schema,
-                                           xmlNodePtr node);
-static xmlSchemaWildcardPtr
-xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaPtr schema, xmlNodePtr node);
-
-/**
- * xmlSchemaPValAttrNodeValue:
- *
- * @ctxt:  a schema parser context
- * @ownerDes: the designation of the parent element
- * @ownerItem: the schema object owner if existent
- * @attr:  the schema attribute node being validated
- * @value: the value
- * @type: the built-in type to be validated against
- *
- * Validates a value against the given built-in type.
- * This one is intended to be used internally for validation
- * of schema attribute values during parsing of the schema.
- *
- * Returns 0 if the value is valid, a positive error code
- * number otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaPValAttrNodeValue(xmlSchemaParserCtxtPtr pctxt,
-                           xmlSchemaBasicItemPtr ownerItem,
-                           xmlAttrPtr attr,
-                           const xmlChar *value,
-                           xmlSchemaTypePtr type)
-{
-
-    int ret = 0;
-
-    /*
-    * NOTE: Should we move this to xmlschematypes.c? Hmm, but this
-    * one is really meant to be used internally, so better not.
-    */
-    if ((pctxt == NULL) || (type == NULL) || (attr == NULL))
-        return (-1);
-    if (type->type != XML_SCHEMA_TYPE_BASIC) {
-        PERROR_INT("xmlSchemaPValAttrNodeValue",
-            "the given type is not a built-in type");
-        return (-1);
-    }
-    switch (type->builtInType) {
-        case XML_SCHEMAS_NCNAME:
-        case XML_SCHEMAS_QNAME:
-        case XML_SCHEMAS_ANYURI:
-        case XML_SCHEMAS_TOKEN:
-        case XML_SCHEMAS_LANGUAGE:
-            ret = xmlSchemaValPredefTypeNode(type, value, NULL,
-                (xmlNodePtr) attr);
-            break;
-        default: {
-            PERROR_INT("xmlSchemaPValAttrNodeValue",
-                "validation using the given type is not supported while "
-                "parsing a schema");
-            return (-1);
-        }
-    }
-    /*
-    * TODO: Should we use the S4S error codes instead?
-    */
-    if (ret < 0) {
-        PERROR_INT("xmlSchemaPValAttrNodeValue",
-            "failed to validate a schema attribute value");
-        return (-1);
-    } else if (ret > 0) {
-        if (WXS_IS_LIST(type))
-            ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
-        else
-            ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
-        xmlSchemaPSimpleTypeErr(pctxt,
-            ret, ownerItem, (xmlNodePtr) attr,
-            type, NULL, value, NULL, NULL, NULL);
-    }
-    return (ret);
-}
-
-/**
- * xmlSchemaPValAttrNode:
- *
- * @ctxt:  a schema parser context
- * @ownerDes: the designation of the parent element
- * @ownerItem: the schema object owner if existent
- * @attr:  the schema attribute node being validated
- * @type: the built-in type to be validated against
- * @value: the resulting value if any
- *
- * Extracts and validates a value against the given built-in type.
- * This one is intended to be used internally for validation
- * of schema attribute values during parsing of the schema.
- *
- * Returns 0 if the value is valid, a positive error code
- * number otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaPValAttrNode(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaBasicItemPtr ownerItem,
-                           xmlAttrPtr attr,
-                           xmlSchemaTypePtr type,
-                           const xmlChar **value)
-{
-    const xmlChar *val;
-
-    if ((ctxt == NULL) || (type == NULL) || (attr == NULL))
-        return (-1);
-
-    val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-    if (value != NULL)
-        *value = val;
-
-    return (xmlSchemaPValAttrNodeValue(ctxt, ownerItem, attr,
-        val, type));
-}
-
-/**
- * xmlSchemaPValAttr:
- *
- * @ctxt:  a schema parser context
- * @node: the element node of the attribute
- * @ownerDes: the designation of the parent element
- * @ownerItem: the schema object owner if existent
- * @ownerElem: the owner element node
- * @name:  the name of the schema attribute node
- * @type: the built-in type to be validated against
- * @value: the resulting value if any
- *
- * Extracts and validates a value against the given built-in type.
- * This one is intended to be used internally for validation
- * of schema attribute values during parsing of the schema.
- *
- * Returns 0 if the value is valid, a positive error code
- * number otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaPValAttr(xmlSchemaParserCtxtPtr ctxt,
-                       xmlSchemaBasicItemPtr ownerItem,
-                       xmlNodePtr ownerElem,
-                       const char *name,
-                       xmlSchemaTypePtr type,
-                       const xmlChar **value)
-{
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (type == NULL)) {
-        if (value != NULL)
-            *value = NULL;
-        return (-1);
-    }
-    if (type->type != XML_SCHEMA_TYPE_BASIC) {
-        if (value != NULL)
-            *value = NULL;
-        xmlSchemaPErr(ctxt, ownerElem,
-            XML_SCHEMAP_INTERNAL,
-            "Internal error: xmlSchemaPValAttr, the given "
-            "type '%s' is not a built-in type.\n",
-            type->name, NULL);
-        return (-1);
-    }
-    attr = xmlSchemaGetPropNode(ownerElem, name);
-    if (attr == NULL) {
-        if (value != NULL)
-            *value = NULL;
-        return (0);
-    }
-    return (xmlSchemaPValAttrNode(ctxt, ownerItem, attr,
-        type, value));
-}
-
-static int
-xmlSchemaCheckReference(xmlSchemaParserCtxtPtr pctxt,
-                  xmlSchemaPtr schema ATTRIBUTE_UNUSED,
-                  xmlNodePtr node,
-                  xmlAttrPtr attr,
-                  const xmlChar *namespaceName)
-{
-    /* TODO: Pointer comparison instead? */
-    if (xmlStrEqual(pctxt->targetNamespace, namespaceName))
-        return (0);
-    if (xmlStrEqual(xmlSchemaNs, namespaceName))
-        return (0);
-    /*
-    * Check if the referenced namespace was <import>ed.
-    */
-    if (WXS_BUCKET(pctxt)->relations != NULL) {
-        xmlSchemaSchemaRelationPtr rel;
-
-        rel = WXS_BUCKET(pctxt)->relations;
-        do {
-            if (WXS_IS_BUCKET_IMPMAIN(rel->type) &&
-                xmlStrEqual(namespaceName, rel->importNamespace))
-                return (0);
-            rel = rel->next;
-        } while (rel != NULL);
-    }
-    /*
-    * No matching <import>ed namespace found.
-    */
-    {
-        xmlNodePtr n = (attr != NULL) ? (xmlNodePtr) attr : node;
-
-        if (namespaceName == NULL)
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_SRC_RESOLVE, n, NULL,
-                "References from this schema to components in no "
-                "namespace are not allowed, since not indicated by an "
-                "import statement", NULL, NULL);
-        else
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_SRC_RESOLVE, n, NULL,
-                "References from this schema to components in the "
-                "namespace '%s' are not allowed, since not indicated by an "
-                "import statement", namespaceName, NULL);
-    }
-    return (XML_SCHEMAP_SRC_RESOLVE);
-}
-
-/**
- * xmlSchemaParseLocalAttributes:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- * @type:  the hosting type where the attributes will be anchored
- *
- * Parses attribute uses and attribute declarations and
- * attribute group references.
- */
-static int
-xmlSchemaParseLocalAttributes(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                        xmlNodePtr *child, xmlSchemaItemListPtr *list,
-                        int parentType, int *hasRefs)
-{
-    void *item;
-
-    while ((IS_SCHEMA((*child), "attribute")) ||
-           (IS_SCHEMA((*child), "attributeGroup"))) {
-        if (IS_SCHEMA((*child), "attribute")) {
-            item = xmlSchemaParseLocalAttribute(ctxt, schema, *child,
-                *list, parentType);
-        } else {
-            item = xmlSchemaParseAttributeGroupRef(ctxt, schema, *child);
-            if ((item != NULL) && (hasRefs != NULL))
-                *hasRefs = 1;
-        }
-        if (item != NULL) {
-            if (*list == NULL) {
-                /* TODO: Customize grow factor. */
-                *list = xmlSchemaItemListCreate();
-                if (*list == NULL)
-                    return(-1);
-            }
-            if (xmlSchemaItemListAddSize(*list, 2, item) == -1)
-                return(-1);
-        }
-        *child = (*child)->next;
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaParseAnnotation:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Attrribute declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of error, 0 if the declaration is improper and
- *         1 in case of success.
- */
-static xmlSchemaAnnotPtr
-xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int needed)
-{
-    xmlSchemaAnnotPtr ret;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    int barked = 0;
-
-    /*
-    * INFO: S4S completed.
-    */
-    /*
-    * id = ID
-    * {any attributes with non-schema namespace . . .}>
-    * Content: (appinfo | documentation)*
-    */
-    if ((ctxt == NULL) || (node == NULL))
-        return (NULL);
-    if (needed)
-        ret = xmlSchemaNewAnnot(ctxt, node);
-    else
-        ret = NULL;
-    attr = node->properties;
-    while (attr != NULL) {
-        if (((attr->ns == NULL) &&
-            (!xmlStrEqual(attr->name, BAD_CAST "id"))) ||
-            ((attr->ns != NULL) &&
-            xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
-
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    while (child != NULL) {
-        if (IS_SCHEMA(child, "appinfo")) {
-            /* TODO: make available the content of "appinfo". */
-            /*
-            * source = anyURI
-            * {any attributes with non-schema namespace . . .}>
-            * Content: ({any})*
-            */
-            attr = child->properties;
-            while (attr != NULL) {
-                if (((attr->ns == NULL) &&
-                     (!xmlStrEqual(attr->name, BAD_CAST "source"))) ||
-                     ((attr->ns != NULL) &&
-                      xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
-
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-                attr = attr->next;
-            }
-            xmlSchemaPValAttr(ctxt, NULL, child, "source",
-                xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "documentation")) {
-            /* TODO: make available the content of "documentation". */
-            /*
-            * source = anyURI
-            * {any attributes with non-schema namespace . . .}>
-            * Content: ({any})*
-            */
-            attr = child->properties;
-            while (attr != NULL) {
-                if (attr->ns == NULL) {
-                    if (!xmlStrEqual(attr->name, BAD_CAST "source")) {
-                        xmlSchemaPIllegalAttrErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                    }
-                } else {
-                    if (xmlStrEqual(attr->ns->href, xmlSchemaNs) ||
-                        (xmlStrEqual(attr->name, BAD_CAST "lang") &&
-                        (!xmlStrEqual(attr->ns->href, XML_XML_NAMESPACE)))) {
-
-                        xmlSchemaPIllegalAttrErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                    }
-                }
-                attr = attr->next;
-            }
-            /*
-            * Attribute "xml:lang".
-            */
-            attr = xmlSchemaGetPropNodeNs(child, (const char *) XML_XML_NAMESPACE, "lang");
-            if (attr != NULL)
-                xmlSchemaPValAttrNode(ctxt, NULL, attr,
-                xmlSchemaGetBuiltInType(XML_SCHEMAS_LANGUAGE), NULL);
-            child = child->next;
-        } else {
-            if (!barked)
-                xmlSchemaPContentErr(ctxt,
-                    XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                    NULL, node, child, NULL, "(appinfo | documentation)*");
-            barked = 1;
-            child = child->next;
-        }
-    }
-
-    return (ret);
-}
-
-/**
- * xmlSchemaParseFacet:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Facet declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the new type structure or NULL in case of error
- */
-static xmlSchemaFacetPtr
-xmlSchemaParseFacet(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                    xmlNodePtr node)
-{
-    xmlSchemaFacetPtr facet;
-    xmlNodePtr child = NULL;
-    const xmlChar *value;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    facet = xmlSchemaNewFacet();
-    if (facet == NULL) {
-        xmlSchemaPErrMemory(ctxt, "allocating facet", node);
-        return (NULL);
-    }
-    facet->node = node;
-    value = xmlSchemaGetProp(ctxt, node, "value");
-    if (value == NULL) {
-        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_FACET_NO_VALUE,
-                       "Facet %s has no value\n", node->name, NULL);
-        xmlSchemaFreeFacet(facet);
-        return (NULL);
-    }
-    if (IS_SCHEMA(node, "minInclusive")) {
-        facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
-    } else if (IS_SCHEMA(node, "minExclusive")) {
-        facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
-    } else if (IS_SCHEMA(node, "maxInclusive")) {
-        facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
-    } else if (IS_SCHEMA(node, "maxExclusive")) {
-        facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
-    } else if (IS_SCHEMA(node, "totalDigits")) {
-        facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
-    } else if (IS_SCHEMA(node, "fractionDigits")) {
-        facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
-    } else if (IS_SCHEMA(node, "pattern")) {
-        facet->type = XML_SCHEMA_FACET_PATTERN;
-    } else if (IS_SCHEMA(node, "enumeration")) {
-        facet->type = XML_SCHEMA_FACET_ENUMERATION;
-    } else if (IS_SCHEMA(node, "whiteSpace")) {
-        facet->type = XML_SCHEMA_FACET_WHITESPACE;
-    } else if (IS_SCHEMA(node, "length")) {
-        facet->type = XML_SCHEMA_FACET_LENGTH;
-    } else if (IS_SCHEMA(node, "maxLength")) {
-        facet->type = XML_SCHEMA_FACET_MAXLENGTH;
-    } else if (IS_SCHEMA(node, "minLength")) {
-        facet->type = XML_SCHEMA_FACET_MINLENGTH;
-    } else {
-        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_TYPE,
-                       "Unknown facet type %s\n", node->name, NULL);
-        xmlSchemaFreeFacet(facet);
-        return (NULL);
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    facet->value = value;
-    if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
-        (facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
-        const xmlChar *fixed;
-
-        fixed = xmlSchemaGetProp(ctxt, node, "fixed");
-        if (fixed != NULL) {
-            if (xmlStrEqual(fixed, BAD_CAST "true"))
-                facet->fixed = 1;
-        }
-    }
-    child = node->children;
-
-    if (IS_SCHEMA(child, "annotation")) {
-        facet->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
-                       "Facet %s has unexpected child content\n",
-                       node->name, NULL);
-    }
-    return (facet);
-}
-
-/**
- * xmlSchemaParseWildcardNs:
- * @ctxt:  a schema parser context
- * @wildc:  the wildcard, already created
- * @node:  a subtree containing XML Schema informations
- *
- * Parses the attribute "processContents" and "namespace"
- * of a xsd:anyAttribute and xsd:any.
- * *WARNING* this interface is highly subject to change
- *
- * Returns 0 if everything goes fine, a positive error code
- * if something is not valid and -1 if an internal error occurs.
- */
-static int
-xmlSchemaParseWildcardNs(xmlSchemaParserCtxtPtr ctxt,
-                         xmlSchemaPtr schema ATTRIBUTE_UNUSED,
-                         xmlSchemaWildcardPtr wildc,
-                         xmlNodePtr node)
-{
-    const xmlChar *pc, *ns, *dictnsItem;
-    int ret = 0;
-    xmlChar *nsItem;
-    xmlSchemaWildcardNsPtr tmp, lastNs = NULL;
-    xmlAttrPtr attr;
-
-    pc = xmlSchemaGetProp(ctxt, node, "processContents");
-    if ((pc == NULL)
-        || (xmlStrEqual(pc, (const xmlChar *) "strict"))) {
-        wildc->processContents = XML_SCHEMAS_ANY_STRICT;
-    } else if (xmlStrEqual(pc, (const xmlChar *) "skip")) {
-        wildc->processContents = XML_SCHEMAS_ANY_SKIP;
-    } else if (xmlStrEqual(pc, (const xmlChar *) "lax")) {
-        wildc->processContents = XML_SCHEMAS_ANY_LAX;
-    } else {
-        xmlSchemaPSimpleTypeErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            NULL, node,
-            NULL, "(strict | skip | lax)", pc,
-            NULL, NULL, NULL);
-        wildc->processContents = XML_SCHEMAS_ANY_STRICT;
-        ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
-    }
-    /*
-     * Build the namespace constraints.
-     */
-    attr = xmlSchemaGetPropNode(node, "namespace");
-    ns = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-    if ((attr == NULL) || (xmlStrEqual(ns, BAD_CAST "##any")))
-        wildc->any = 1;
-    else if (xmlStrEqual(ns, BAD_CAST "##other")) {
-        wildc->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
-        if (wildc->negNsSet == NULL) {
-            return (-1);
-        }
-        wildc->negNsSet->value = ctxt->targetNamespace;
-    } else {
-        const xmlChar *end, *cur;
-
-        cur = ns;
-        do {
-            while (IS_BLANK_CH(*cur))
-                cur++;
-            end = cur;
-            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-                end++;
-            if (end == cur)
-                break;
-            nsItem = xmlStrndup(cur, end - cur);
-            if ((xmlStrEqual(nsItem, BAD_CAST "##other")) ||
-                    (xmlStrEqual(nsItem, BAD_CAST "##any"))) {
-                xmlSchemaPSimpleTypeErr(ctxt,
-                    XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
-                    NULL, (xmlNodePtr) attr,
-                    NULL,
-                    "((##any | ##other) | List of (xs:anyURI | "
-                    "(##targetNamespace | ##local)))",
-                    nsItem, NULL, NULL, NULL);
-                ret = XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER;
-            } else {
-                if (xmlStrEqual(nsItem, BAD_CAST "##targetNamespace")) {
-                    dictnsItem = ctxt->targetNamespace;
-                } else if (xmlStrEqual(nsItem, BAD_CAST "##local")) {
-                    dictnsItem = NULL;
-                } else {
-                    /*
-                    * Validate the item (anyURI).
-                    */
-                    xmlSchemaPValAttrNodeValue(ctxt, NULL, attr,
-                        nsItem, xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI));
-                    dictnsItem = xmlDictLookup(ctxt->dict, nsItem, -1);
-                }
-                /*
-                * Avoid dublicate namespaces.
-                */
-                tmp = wildc->nsSet;
-                while (tmp != NULL) {
-                    if (dictnsItem == tmp->value)
-                        break;
-                    tmp = tmp->next;
-                }
-                if (tmp == NULL) {
-                    tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
-                    if (tmp == NULL) {
-                        xmlFree(nsItem);
-                        return (-1);
-                    }
-                    tmp->value = dictnsItem;
-                    tmp->next = NULL;
-                    if (wildc->nsSet == NULL)
-                        wildc->nsSet = tmp;
-                    else if (lastNs != NULL)
-                        lastNs->next = tmp;
-                    lastNs = tmp;
-                }
-
-            }
-            xmlFree(nsItem);
-            cur = end;
-        } while (*cur != 0);
-    }
-    return (ret);
-}
-
-static int
-xmlSchemaPCheckParticleCorrect_2(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaParticlePtr item ATTRIBUTE_UNUSED,
-                                 xmlNodePtr node,
-                                 int minOccurs,
-                                 int maxOccurs) {
-
-    if ((maxOccurs == 0) && ( minOccurs == 0))
-        return (0);
-    if (maxOccurs != UNBOUNDED) {
-        /*
-        * TODO: Maybe we should better not create the particle,
-        * if min/max is invalid, since it could confuse the build of the
-        * content model.
-        */
-        /*
-        * 3.9.6 Schema Component Constraint: Particle Correct
-        *
-        */
-        if (maxOccurs < 1) {
-            /*
-            * 2.2 {max occurs} must be greater than or equal to 1.
-            */
-            xmlSchemaPCustomAttrErr(ctxt,
-                XML_SCHEMAP_P_PROPS_CORRECT_2_2,
-                NULL, NULL,
-                xmlSchemaGetPropNode(node, "maxOccurs"),
-                "The value must be greater than or equal to 1");
-            return (XML_SCHEMAP_P_PROPS_CORRECT_2_2);
-        } else if (minOccurs > maxOccurs) {
-            /*
-            * 2.1 {min occurs} must not be greater than {max occurs}.
-            */
-            xmlSchemaPCustomAttrErr(ctxt,
-                XML_SCHEMAP_P_PROPS_CORRECT_2_1,
-                NULL, NULL,
-                xmlSchemaGetPropNode(node, "minOccurs"),
-                "The value must not be greater than the value of 'maxOccurs'");
-            return (XML_SCHEMAP_P_PROPS_CORRECT_2_1);
-        }
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaParseAny:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parsea a XML schema <any> element. A particle and wildcard
- * will be created (except if minOccurs==maxOccurs==0, in this case
- * nothing will be created).
- * *WARNING* this interface is highly subject to change
- *
- * Returns the particle or NULL in case of error or if minOccurs==maxOccurs==0
- */
-static xmlSchemaParticlePtr
-xmlSchemaParseAny(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                  xmlNodePtr node)
-{
-    xmlSchemaParticlePtr particle;
-    xmlNodePtr child = NULL;
-    xmlSchemaWildcardPtr wild;
-    int min, max;
-    xmlAttrPtr attr;
-    xmlSchemaAnnotPtr annot = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * minOccurs/maxOccurs.
-    */
-    max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
-        "(xs:nonNegativeInteger | unbounded)");
-    min = xmlGetMinOccurs(ctxt, node, 0, -1, 1,
-        "xs:nonNegativeInteger");
-    xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
-    /*
-    * Create & parse the wildcard.
-    */
-    wild = xmlSchemaAddWildcard(ctxt, schema, XML_SCHEMA_TYPE_ANY, node);
-    if (wild == NULL)
-        return (NULL);
-    xmlSchemaParseWildcardNs(ctxt, schema, wild, node);
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?)");
-    }
-    /*
-    * No component if minOccurs==maxOccurs==0.
-    */
-    if ((min == 0) && (max == 0)) {
-        /* Don't free the wildcard, since it's already on the list. */
-        return (NULL);
-    }
-    /*
-    * Create the particle.
-    */
-    particle = xmlSchemaAddParticle(ctxt, node, min, max);
-    if (particle == NULL)
-        return (NULL);
-    particle->annot = annot;
-    particle->children = (xmlSchemaTreeItemPtr) wild;
-
-    return (particle);
-}
-
-/**
- * xmlSchemaParseNotation:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Notation declaration
- *
- * Returns the new structure or NULL in case of error
- */
-static xmlSchemaNotationPtr
-xmlSchemaParseNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                       xmlNodePtr node)
-{
-    const xmlChar *name;
-    xmlSchemaNotationPtr ret;
-    xmlNodePtr child = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    name = xmlSchemaGetProp(ctxt, node, "name");
-    if (name == NULL) {
-        xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_NOTATION_NO_NAME,
-                       "Notation has no name\n", NULL, NULL);
-        return (NULL);
-    }
-    ret = xmlSchemaAddNotation(ctxt, schema, name,
-        ctxt->targetNamespace, node);
-    if (ret == NULL)
-        return (NULL);
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?)");
-    }
-
-    return (ret);
-}
-
-/**
- * xmlSchemaParseAnyAttribute:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema AnyAttrribute declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns a wildcard or NULL.
- */
-static xmlSchemaWildcardPtr
-xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaPtr schema, xmlNodePtr node)
-{
-    xmlSchemaWildcardPtr ret;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    ret = xmlSchemaAddWildcard(ctxt, schema, XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
-        node);
-    if (ret == NULL) {
-        return (NULL);
-    }
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * Parse the namespace list.
-    */
-    if (xmlSchemaParseWildcardNs(ctxt, schema, ret, node) != 0)
-        return (NULL);
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?)");
-    }
-
-    return (ret);
-}
-
-
-/**
- * xmlSchemaParseAttribute:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Attrribute declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the attribute declaration.
- */
-static xmlSchemaBasicItemPtr
-xmlSchemaParseLocalAttribute(xmlSchemaParserCtxtPtr pctxt,
-                             xmlSchemaPtr schema,
-                             xmlNodePtr node,
-                             xmlSchemaItemListPtr uses,
-                             int parentType)
-{
-    const xmlChar *attrValue, *name = NULL, *ns = NULL;
-    xmlSchemaAttributeUsePtr use = NULL;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *tmpNs = NULL, *tmpName = NULL, *defValue = NULL;
-    int isRef = 0, occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
-    int nberrors, hasForm = 0, defValueType = 0;
-
-#define WXS_ATTR_DEF_VAL_DEFAULT 1
-#define WXS_ATTR_DEF_VAL_FIXED 2
-
-    /*
-     * 3.2.3 Constraints on XML Representations of Attribute Declarations
-     */
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    attr = xmlSchemaGetPropNode(node, "ref");
-    if (attr != NULL) {
-        if (xmlSchemaPValAttrNodeQName(pctxt, schema,
-            NULL, attr, &tmpNs, &tmpName) != 0) {
-            return (NULL);
-        }
-        if (xmlSchemaCheckReference(pctxt, schema, node, attr, tmpNs) != 0)
-            return(NULL);
-        isRef = 1;
-    }
-    nberrors = pctxt->nberrors;
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if (isRef) {
-                if (xmlStrEqual(attr->name, BAD_CAST "id")) {
-                    xmlSchemaPValAttrNodeID(pctxt, attr);
-                    goto attr_next;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "ref")) {
-                    goto attr_next;
-                }
-            } else {
-                if (xmlStrEqual(attr->name, BAD_CAST "name")) {
-                    goto attr_next;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "id")) {
-                    xmlSchemaPValAttrNodeID(pctxt, attr);
-                    goto attr_next;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "type")) {
-                    xmlSchemaPValAttrNodeQName(pctxt, schema, NULL,
-                        attr, &tmpNs, &tmpName);
-                    goto attr_next;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "form")) {
-                    /*
-                    * Evaluate the target namespace
-                    */
-                    hasForm = 1;
-                    attrValue = xmlSchemaGetNodeContent(pctxt,
-                        (xmlNodePtr) attr);
-                    if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
-                        ns = pctxt->targetNamespace;
-                    } else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified"))
-                    {
-                        xmlSchemaPSimpleTypeErr(pctxt,
-                            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                            NULL, (xmlNodePtr) attr,
-                            NULL, "(qualified | unqualified)",
-                            attrValue, NULL, NULL, NULL);
-                    }
-                    goto attr_next;
-                }
-            }
-            if (xmlStrEqual(attr->name, BAD_CAST "use")) {
-
-                attrValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
-                /* TODO: Maybe we need to normalize the value beforehand. */
-                if (xmlStrEqual(attrValue, BAD_CAST "optional"))
-                    occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
-                else if (xmlStrEqual(attrValue, BAD_CAST "prohibited"))
-                    occurs = XML_SCHEMAS_ATTR_USE_PROHIBITED;
-                else if (xmlStrEqual(attrValue, BAD_CAST "required"))
-                    occurs = XML_SCHEMAS_ATTR_USE_REQUIRED;
-                else {
-                    xmlSchemaPSimpleTypeErr(pctxt,
-                        XML_SCHEMAP_INVALID_ATTR_USE,
-                        NULL, (xmlNodePtr) attr,
-                        NULL, "(optional | prohibited | required)",
-                        attrValue, NULL, NULL, NULL);
-                }
-                goto attr_next;
-            } else if (xmlStrEqual(attr->name, BAD_CAST "default")) {
-                /*
-                * 3.2.3 : 1
-                * default and fixed must not both be present.
-                */
-                if (defValue) {
-                    xmlSchemaPMutualExclAttrErr(pctxt,
-                        XML_SCHEMAP_SRC_ATTRIBUTE_1,
-                        NULL, attr, "default", "fixed");
-                } else {
-                    defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
-                    defValueType = WXS_ATTR_DEF_VAL_DEFAULT;
-                }
-                goto attr_next;
-            } else if (xmlStrEqual(attr->name, BAD_CAST "fixed")) {
-                /*
-                * 3.2.3 : 1
-                * default and fixed must not both be present.
-                */
-                if (defValue) {
-                    xmlSchemaPMutualExclAttrErr(pctxt,
-                        XML_SCHEMAP_SRC_ATTRIBUTE_1,
-                        NULL, attr, "default", "fixed");
-                } else {
-                    defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
-                    defValueType = WXS_ATTR_DEF_VAL_FIXED;
-                }
-                goto attr_next;
-            }
-        } else if (! xmlStrEqual(attr->ns->href, xmlSchemaNs))
-            goto attr_next;
-
-        xmlSchemaPIllegalAttrErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-
-attr_next:
-        attr = attr->next;
-    }
-    /*
-    * 3.2.3 : 2
-    * If default and use are both present, use must have
-    * the actual value optional.
-    */
-    if ((defValueType == WXS_ATTR_DEF_VAL_DEFAULT) &&
-        (occurs != XML_SCHEMAS_ATTR_USE_OPTIONAL)) {
-        xmlSchemaPSimpleTypeErr(pctxt,
-            XML_SCHEMAP_SRC_ATTRIBUTE_2,
-            NULL, node, NULL,
-            "(optional | prohibited | required)", NULL,
-            "The value of the attribute 'use' must be 'optional' "
-            "if the attribute 'default' is present",
-            NULL, NULL);
-    }
-    /*
-    * We want correct attributes.
-    */
-    if (nberrors != pctxt->nberrors)
-        return(NULL);
-    if (! isRef) {
-        xmlSchemaAttributePtr attrDecl;
-
-        /* TODO: move XML_SCHEMAS_QUALIF_ATTR to the parser. */
-        if ((! hasForm) && (schema->flags & XML_SCHEMAS_QUALIF_ATTR))
-            ns = pctxt->targetNamespace;
-        /*
-        * 3.2.6 Schema Component Constraint: xsi: Not Allowed
-        * TODO: Move this to the component layer.
-        */
-        if (xmlStrEqual(ns, xmlSchemaInstanceNs)) {
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_NO_XSI,
-                node, NULL,
-                "The target namespace must not match '%s'",
-                xmlSchemaInstanceNs, NULL);
-        }
-        attr = xmlSchemaGetPropNode(node, "name");
-        if (attr == NULL) {
-            xmlSchemaPMissingAttrErr(pctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
-                NULL, node, "name", NULL);
-            return (NULL);
-        }
-        if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
-            return (NULL);
-        }
-        /*
-        * 3.2.6 Schema Component Constraint: xmlns Not Allowed
-        * TODO: Move this to the component layer.
-        */
-        if (xmlStrEqual(name, BAD_CAST "xmlns")) {
-            xmlSchemaPSimpleTypeErr(pctxt,
-                XML_SCHEMAP_NO_XMLNS,
-                NULL, (xmlNodePtr) attr,
-                xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), NULL, NULL,
-                "The value of the attribute must not match 'xmlns'",
-                NULL, NULL);
-            return (NULL);
-        }
-        if (occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED)
-            goto check_children;
-        /*
-        * Create the attribute use component.
-        */
-        use = xmlSchemaAddAttributeUse(pctxt, node);
-        if (use == NULL)
-            return(NULL);
-        use->occurs = occurs;
-        /*
-        * Create the attribute declaration.
-        */
-        attrDecl = xmlSchemaAddAttribute(pctxt, schema, name, ns, node, 0);
-        if (attrDecl == NULL)
-            return (NULL);
-        if (tmpName != NULL) {
-            attrDecl->typeName = tmpName;
-            attrDecl->typeNs = tmpNs;
-        }
-        use->attrDecl = attrDecl;
-        /*
-        * Value constraint.
-        */
-        if (defValue != NULL) {
-            attrDecl->defValue = defValue;
-            if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
-                attrDecl->flags |= XML_SCHEMAS_ATTR_FIXED;
-        }
-    } else if (occurs != XML_SCHEMAS_ATTR_USE_PROHIBITED) {
-        xmlSchemaQNameRefPtr ref;
-
-        /*
-        * Create the attribute use component.
-        */
-        use = xmlSchemaAddAttributeUse(pctxt, node);
-        if (use == NULL)
-            return(NULL);
-        /*
-        * We need to resolve the reference at later stage.
-        */
-        WXS_ADD_PENDING(pctxt, use);
-        use->occurs = occurs;
-        /*
-        * Create a QName reference to the attribute declaration.
-        */
-        ref = xmlSchemaNewQNameRef(pctxt, XML_SCHEMA_TYPE_ATTRIBUTE,
-            tmpName, tmpNs);
-        if (ref == NULL)
-            return(NULL);
-        /*
-        * Assign the reference. This will be substituted for the
-        * referenced attribute declaration when the QName is resolved.
-        */
-        use->attrDecl = WXS_ATTR_CAST ref;
-        /*
-        * Value constraint.
-        */
-        if (defValue != NULL)
-            use->defValue = defValue;
-            if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
-                use->flags |= XML_SCHEMA_ATTR_USE_FIXED;
-    }
-
-check_children:
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
-        xmlSchemaAttributeUseProhibPtr prohib;
-
-        if (IS_SCHEMA(child, "annotation")) {
-            xmlSchemaParseAnnotation(pctxt, child, 0);
-            child = child->next;
-        }
-        if (child != NULL) {
-            xmlSchemaPContentErr(pctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?)");
-        }
-        /*
-        * Check for pointlessness of attribute prohibitions.
-        */
-        if (parentType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
-            xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-                XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
-                node, NULL,
-                "Skipping attribute use prohibition, since it is "
-                "pointless inside an <attributeGroup>",
-                NULL, NULL, NULL);
-            return(NULL);
-        } else if (parentType == XML_SCHEMA_TYPE_EXTENSION) {
-            xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-                XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
-                node, NULL,
-                "Skipping attribute use prohibition, since it is "
-                "pointless when extending a type",
-                NULL, NULL, NULL);
-            return(NULL);
-        }
-        if (! isRef) {
-            tmpName = name;
-            tmpNs = ns;
-        }
-        /*
-        * Check for duplicate attribute prohibitions.
-        */
-        if (uses) {
-            int i;
-
-            for (i = 0; i < uses->nbItems; i++) {
-                use = uses->items[i];
-                if ((use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) &&
-                    (tmpName == (WXS_ATTR_PROHIB_CAST use)->name) &&
-                    (tmpNs == (WXS_ATTR_PROHIB_CAST use)->targetNamespace))
-                {
-                    xmlChar *str = NULL;
-
-                    xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-                        XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
-                        node, NULL,
-                        "Skipping duplicate attribute use prohibition '%s'",
-                        xmlSchemaFormatQName(&str, tmpNs, tmpName),
-                        NULL, NULL);
-                    FREE_AND_NULL(str)
-                    return(NULL);
-                }
-            }
-        }
-        /*
-        * Create the attribute prohibition helper component.
-        */
-        prohib = xmlSchemaAddAttributeUseProhib(pctxt);
-        if (prohib == NULL)
-            return(NULL);
-        prohib->node = node;
-        prohib->name = tmpName;
-        prohib->targetNamespace = tmpNs;
-        if (isRef) {
-            /*
-            * We need at least to resolve to the attribute declaration.
-            */
-            WXS_ADD_PENDING(pctxt, prohib);
-        }
-        return(WXS_BASIC_CAST prohib);
-    } else {
-        if (IS_SCHEMA(child, "annotation")) {
-            /*
-            * TODO: Should this go into the attr decl?
-            */
-            use->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
-            child = child->next;
-        }
-        if (isRef) {
-            if (child != NULL) {
-                if (IS_SCHEMA(child, "simpleType"))
-                    /*
-                    * 3.2.3 : 3.2
-                    * If ref is present, then all of <simpleType>,
-                    * form and type must be absent.
-                    */
-                    xmlSchemaPContentErr(pctxt,
-                        XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
-                        NULL, node, child, NULL,
-                        "(annotation?)");
-                else
-                    xmlSchemaPContentErr(pctxt,
-                        XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                        NULL, node, child, NULL,
-                        "(annotation?)");
-            }
-        } else {
-            if (IS_SCHEMA(child, "simpleType")) {
-                if (WXS_ATTRUSE_DECL(use)->typeName != NULL) {
-                    /*
-                    * 3.2.3 : 4
-                    * type and <simpleType> must not both be present.
-                    */
-                    xmlSchemaPContentErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_4,
-                        NULL, node, child,
-                        "The attribute 'type' and the <simpleType> child "
-                        "are mutually exclusive", NULL);
-                } else
-                    WXS_ATTRUSE_TYPEDEF(use) =
-                        xmlSchemaParseSimpleType(pctxt, schema, child, 0);
-                child = child->next;
-            }
-            if (child != NULL)
-                xmlSchemaPContentErr(pctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, simpleType?)");
-        }
-    }
-    return (WXS_BASIC_CAST use);
-}
-
-
-static xmlSchemaAttributePtr
-xmlSchemaParseGlobalAttribute(xmlSchemaParserCtxtPtr pctxt,
-                              xmlSchemaPtr schema,
-                              xmlNodePtr node)
-{
-    const xmlChar *attrValue;
-    xmlSchemaAttributePtr ret;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    /*
-     * Note that the w3c spec assumes the schema to be validated with schema
-     * for schemas beforehand.
-     *
-     * 3.2.3 Constraints on XML Representations of Attribute Declarations
-     */
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /*
-    * 3.2.3 : 3.1
-    * One of ref or name must be present, but not both
-    */
-    attr = xmlSchemaGetPropNode(node, "name");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(pctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "name", NULL);
-        return (NULL);
-    }
-    if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
-        xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &attrValue) != 0) {
-        return (NULL);
-    }
-    /*
-    * 3.2.6 Schema Component Constraint: xmlns Not Allowed
-    * TODO: Move this to the component layer.
-    */
-    if (xmlStrEqual(attrValue, BAD_CAST "xmlns")) {
-        xmlSchemaPSimpleTypeErr(pctxt,
-            XML_SCHEMAP_NO_XMLNS,
-            NULL, (xmlNodePtr) attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), NULL, NULL,
-            "The value of the attribute must not match 'xmlns'",
-            NULL, NULL);
-        return (NULL);
-    }
-    /*
-    * 3.2.6 Schema Component Constraint: xsi: Not Allowed
-    * TODO: Move this to the component layer.
-    *       Or better leave it here and add it to the component layer
-    *       if we have a schema construction API.
-    */
-    if (xmlStrEqual(pctxt->targetNamespace, xmlSchemaInstanceNs)) {
-        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-            XML_SCHEMAP_NO_XSI, node, NULL,
-            "The target namespace must not match '%s'",
-            xmlSchemaInstanceNs, NULL);
-    }
-
-    ret = xmlSchemaAddAttribute(pctxt, schema, attrValue,
-        pctxt->targetNamespace, node, 1);
-    if (ret == NULL)
-        return (NULL);
-    ret->flags |= XML_SCHEMAS_ATTR_GLOBAL;
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "type")))
-            {
-                xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(pctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrQName(pctxt, schema, NULL,
-        node, "type", &ret->typeNs, &ret->typeName);
-
-    xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
-    /*
-    * Attribute "fixed".
-    */
-    ret->defValue = xmlSchemaGetProp(pctxt, node, "fixed");
-    if (ret->defValue != NULL)
-        ret->flags |= XML_SCHEMAS_ATTR_FIXED;
-    /*
-    * Attribute "default".
-    */
-    attr = xmlSchemaGetPropNode(node, "default");
-    if (attr != NULL) {
-        /*
-        * 3.2.3 : 1
-        * default and fixed must not both be present.
-        */
-        if (ret->flags & XML_SCHEMAS_ATTR_FIXED) {
-            xmlSchemaPMutualExclAttrErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_1,
-                WXS_BASIC_CAST ret, attr, "default", "fixed");
-        } else
-            ret->defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
-        child = child->next;
-    }
-    if (IS_SCHEMA(child, "simpleType")) {
-        if (ret->typeName != NULL) {
-            /*
-            * 3.2.3 : 4
-            * type and <simpleType> must not both be present.
-            */
-            xmlSchemaPContentErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_4,
-                NULL, node, child,
-                "The attribute 'type' and the <simpleType> child "
-                "are mutually exclusive", NULL);
-        } else
-            ret->subtypes = xmlSchemaParseSimpleType(pctxt, schema, child, 0);
-        child = child->next;
-    }
-    if (child != NULL)
-        xmlSchemaPContentErr(pctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?, simpleType?)");
-
-    return (ret);
-}
-
-/**
- * xmlSchemaParseAttributeGroupRef:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parse an attribute group definition reference.
- * Note that a reference to an attribute group does not
- * correspond to any component at all.
- * *WARNING* this interface is highly subject to change
- *
- * Returns the attribute group or NULL in case of error.
- */
-static xmlSchemaQNameRefPtr
-xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
-                                xmlSchemaPtr schema,
-                                xmlNodePtr node)
-{
-    xmlSchemaQNameRefPtr ret;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *refNs = NULL, *ref = NULL;
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    attr = xmlSchemaGetPropNode(node, "ref");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "ref", NULL);
-        return (NULL);
-    }
-    xmlSchemaPValAttrNodeQName(pctxt, schema,
-        NULL, attr, &refNs, &ref);
-    if (xmlSchemaCheckReference(pctxt, schema, node, attr, refNs) != 0)
-        return(NULL);
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "id")))
-            {
-                xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(pctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /* Attribute ID */
-    xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
-
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * TODO: We do not have a place to store the annotation, do we?
-        */
-        xmlSchemaParseAnnotation(pctxt, child, 0);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(pctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?)");
-    }
-
-    /*
-    * Handle attribute group redefinitions.
-    */
-    if (pctxt->isRedefine && pctxt->redef &&
-        (pctxt->redef->item->type ==
-            XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
-        (ref == pctxt->redef->refName) &&
-        (refNs == pctxt->redef->refTargetNs))
-    {
-        /*
-        * SPEC src-redefine:
-        * (7.1) "If it has an <attributeGroup> among its contents
-        * the `actual value` of whose ref [attribute] is the same
-        * as the `actual value` of its own name attribute plus
-        * target namespace, then it must have exactly one such group."
-        */
-        if (pctxt->redefCounter != 0) {
-            xmlChar *str = NULL;
-
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_SRC_REDEFINE, node, NULL,
-                "The redefining attribute group definition "
-                "'%s' must not contain more than one "
-                "reference to the redefined definition",
-                xmlSchemaFormatQName(&str, refNs, ref), NULL);
-            FREE_AND_NULL(str);
-            return(NULL);
-        }
-        pctxt->redefCounter++;
-        /*
-        * URGENT TODO: How to ensure that the reference will not be
-        * handled by the normal component resolution mechanism?
-        */
-        ret = xmlSchemaNewQNameRef(pctxt,
-            XML_SCHEMA_TYPE_ATTRIBUTEGROUP, ref, refNs);
-        if (ret == NULL)
-            return(NULL);
-        ret->node = node;
-        pctxt->redef->reference = WXS_BASIC_CAST ret;
-    } else {
-        /*
-        * Create a QName-reference helper component. We will substitute this
-        * component for the attribute uses of the referenced attribute group
-        * definition.
-        */
-        ret = xmlSchemaNewQNameRef(pctxt,
-            XML_SCHEMA_TYPE_ATTRIBUTEGROUP, ref, refNs);
-        if (ret == NULL)
-            return(NULL);
-        ret->node = node;
-        /* Add to pending items, to be able to resolve the reference. */
-        WXS_ADD_PENDING(pctxt, ret);
-    }
-    return (ret);
-}
-
-/**
- * xmlSchemaParseAttributeGroupDefinition:
- * @pctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Attribute Group declaration
- * *WARNING* this interface is highly subject to change
- *
- * Returns the attribute group definition or NULL in case of error.
- */
-static xmlSchemaAttributeGroupPtr
-xmlSchemaParseAttributeGroupDefinition(xmlSchemaParserCtxtPtr pctxt,
-                                       xmlSchemaPtr schema,
-                                       xmlNodePtr node)
-{
-    const xmlChar *name;
-    xmlSchemaAttributeGroupPtr ret;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    int hasRefs = 0;
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    attr = xmlSchemaGetPropNode(node, "name");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "name", NULL);
-        return (NULL);
-    }
-    /*
-    * The name is crucial, exit if invalid.
-    */
-    if (xmlSchemaPValAttrNode(pctxt,
-        NULL, attr,
-        xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
-        return (NULL);
-    }
-    ret = xmlSchemaAddAttributeGroupDefinition(pctxt, schema,
-        name, pctxt->targetNamespace, node);
-    if (ret == NULL)
-        return (NULL);
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "id")))
-            {
-                xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(pctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /* Attribute ID */
-    xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
-        child = child->next;
-    }
-    /*
-    * Parse contained attribute decls/refs.
-    */
-    if (xmlSchemaParseLocalAttributes(pctxt, schema, &child,
-        (xmlSchemaItemListPtr *) &(ret->attrUses),
-        XML_SCHEMA_TYPE_ATTRIBUTEGROUP, &hasRefs) == -1)
-        return(NULL);
-    if (hasRefs)
-        ret->flags |= XML_SCHEMAS_ATTRGROUP_HAS_REFS;
-    /*
-    * Parse the attribute wildcard.
-    */
-    if (IS_SCHEMA(child, "anyAttribute")) {
-        ret->attributeWildcard = xmlSchemaParseAnyAttribute(pctxt,
-            schema, child);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(pctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?, ((attribute | attributeGroup)*, anyAttribute?))");
-    }
-    return (ret);
-}
-
-/**
- * xmlSchemaPValAttrFormDefault:
- * @value:  the value
- * @flags: the flags to be modified
- * @flagQualified: the specific flag for "qualified"
- *
- * Returns 0 if the value is valid, 1 otherwise.
- */
-static int
-xmlSchemaPValAttrFormDefault(const xmlChar *value,
-                             int *flags,
-                             int flagQualified)
-{
-    if (xmlStrEqual(value, BAD_CAST "qualified")) {
-        if  ((*flags & flagQualified) == 0)
-            *flags |= flagQualified;
-    } else if (!xmlStrEqual(value, BAD_CAST "unqualified"))
-        return (1);
-
-    return (0);
-}
-
-/**
- * xmlSchemaPValAttrBlockFinal:
- * @value:  the value
- * @flags: the flags to be modified
- * @flagAll: the specific flag for "#all"
- * @flagExtension: the specific flag for "extension"
- * @flagRestriction: the specific flag for "restriction"
- * @flagSubstitution: the specific flag for "substitution"
- * @flagList: the specific flag for "list"
- * @flagUnion: the specific flag for "union"
- *
- * Validates the value of the attribute "final" and "block". The value
- * is converted into the specified flag values and returned in @flags.
- *
- * Returns 0 if the value is valid, 1 otherwise.
- */
-
-static int
-xmlSchemaPValAttrBlockFinal(const xmlChar *value,
-                            int *flags,
-                            int flagAll,
-                            int flagExtension,
-                            int flagRestriction,
-                            int flagSubstitution,
-                            int flagList,
-                            int flagUnion)
-{
-    int ret = 0;
-
-    /*
-    * TODO: This does not check for dublicate entries.
-    */
-    if ((flags == NULL) || (value == NULL))
-        return (-1);
-    if (value[0] == 0)
-        return (0);
-    if (xmlStrEqual(value, BAD_CAST "#all")) {
-        if (flagAll != -1)
-            *flags |= flagAll;
-        else {
-            if (flagExtension != -1)
-                *flags |= flagExtension;
-            if (flagRestriction != -1)
-                *flags |= flagRestriction;
-            if (flagSubstitution != -1)
-                *flags |= flagSubstitution;
-            if (flagList != -1)
-                *flags |= flagList;
-            if (flagUnion != -1)
-                *flags |= flagUnion;
-        }
-    } else {
-        const xmlChar *end, *cur = value;
-        xmlChar *item;
-
-        do {
-            while (IS_BLANK_CH(*cur))
-                cur++;
-            end = cur;
-            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-                end++;
-            if (end == cur)
-                break;
-            item = xmlStrndup(cur, end - cur);
-            if (xmlStrEqual(item, BAD_CAST "extension")) {
-                if (flagExtension != -1) {
-                    if ((*flags & flagExtension) == 0)
-                        *flags |= flagExtension;
-                } else
-                    ret = 1;
-            } else if (xmlStrEqual(item, BAD_CAST "restriction")) {
-                if (flagRestriction != -1) {
-                    if ((*flags & flagRestriction) == 0)
-                        *flags |= flagRestriction;
-                } else
-                    ret = 1;
-            } else if (xmlStrEqual(item, BAD_CAST "substitution")) {
-                if (flagSubstitution != -1) {
-                    if ((*flags & flagSubstitution) == 0)
-                        *flags |= flagSubstitution;
-                } else
-                    ret = 1;
-            } else if (xmlStrEqual(item, BAD_CAST "list")) {
-                if (flagList != -1) {
-                    if ((*flags & flagList) == 0)
-                        *flags |= flagList;
-                } else
-                    ret = 1;
-            } else if (xmlStrEqual(item, BAD_CAST "union")) {
-                if (flagUnion != -1) {
-                    if ((*flags & flagUnion) == 0)
-                        *flags |= flagUnion;
-                } else
-                    ret = 1;
-            } else
-                ret = 1;
-            if (item != NULL)
-                xmlFree(item);
-            cur = end;
-        } while ((ret == 0) && (*cur != 0));
-    }
-
-    return (ret);
-}
-
-static int
-xmlSchemaCheckCSelectorXPath(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaIDCPtr idc,
-                             xmlSchemaIDCSelectPtr selector,
-                             xmlAttrPtr attr,
-                             int isField)
-{
-    xmlNodePtr node;
-
-    /*
-    * c-selector-xpath:
-    * Schema Component Constraint: Selector Value OK
-    *
-    * TODO: 1 The {selector} must be a valid XPath expression, as defined
-    * in [XPath].
-    */
-    if (selector == NULL) {
-        xmlSchemaPErr(ctxt, idc->node,
-            XML_SCHEMAP_INTERNAL,
-            "Internal error: xmlSchemaCheckCSelectorXPath, "
-            "the selector is not specified.\n", NULL, NULL);
-        return (-1);
-    }
-    if (attr == NULL)
-        node = idc->node;
-    else
-        node = (xmlNodePtr) attr;
-    if (selector->xpath == NULL) {
-        xmlSchemaPCustomErr(ctxt,
-            /* TODO: Adjust error code. */
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            NULL, node,
-            "The XPath expression of the selector is not valid", NULL);
-        return (XML_SCHEMAP_S4S_ATTR_INVALID_VALUE);
-    } else {
-        const xmlChar **nsArray = NULL;
-        xmlNsPtr *nsList = NULL;
-        /*
-        * Compile the XPath expression.
-        */
-        /*
-        * TODO: We need the array of in-scope namespaces for compilation.
-        * TODO: Call xmlPatterncompile with different options for selector/
-        * field.
-        */
-        if (attr == NULL)
-            nsList = NULL;
-        else
-            nsList = xmlGetNsList(attr->doc, attr->parent);
-        /*
-        * Build an array of prefixes and namespaces.
-        */
-        if (nsList != NULL) {
-            int i, count = 0;
-
-            for (i = 0; nsList[i] != NULL; i++)
-                count++;
-
-            nsArray = (const xmlChar **) xmlMalloc(
-                (count * 2 + 1) * sizeof(const xmlChar *));
-            if (nsArray == NULL) {
-                xmlSchemaPErrMemory(ctxt, "allocating a namespace array",
-                    NULL);
-                xmlFree(nsList);
-                return (-1);
-            }
-            for (i = 0; i < count; i++) {
-                nsArray[2 * i] = nsList[i]->href;
-                nsArray[2 * i + 1] = nsList[i]->prefix;
-            }
-            nsArray[count * 2] = NULL;
-            xmlFree(nsList);
-        }
-        /*
-        * TODO: Differentiate between "selector" and "field".
-        */
-        if (isField)
-            selector->xpathComp = (void *) xmlPatterncompile(selector->xpath,
-                NULL, XML_PATTERN_XSFIELD, nsArray);
-        else
-            selector->xpathComp = (void *) xmlPatterncompile(selector->xpath,
-                NULL, XML_PATTERN_XSSEL, nsArray);
-        if (nsArray != NULL)
-            xmlFree((xmlChar **) nsArray);
-
-        if (selector->xpathComp == NULL) {
-            xmlSchemaPCustomErr(ctxt,
-                /* TODO: Adjust error code? */
-                XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                NULL, node,
-                "The XPath expression '%s' could not be "
-                "compiled", selector->xpath);
-            return (XML_SCHEMAP_S4S_ATTR_INVALID_VALUE);
-        }
-    }
-    return (0);
-}
-
-#define ADD_ANNOTATION(annot)   \
-    xmlSchemaAnnotPtr cur = item->annot; \
-    if (item->annot == NULL) {  \
-        item->annot = annot;    \
-        return (annot);         \
-    }                           \
-    cur = item->annot;          \
-    if (cur->next != NULL) {    \
-        cur = cur->next;        \
-    }                           \
-    cur->next = annot;
-
-/**
- * xmlSchemaAssignAnnotation:
- * @item: the schema component
- * @annot: the annotation
- *
- * Adds the annotation to the given schema component.
- *
- * Returns the given annotaion.
- */
-static xmlSchemaAnnotPtr
-xmlSchemaAddAnnotation(xmlSchemaAnnotItemPtr annItem,
-                       xmlSchemaAnnotPtr annot)
-{
-    if ((annItem == NULL) || (annot == NULL))
-        return (NULL);
-    switch (annItem->type) {
-        case XML_SCHEMA_TYPE_ELEMENT: {
-                xmlSchemaElementPtr item = (xmlSchemaElementPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTE: {
-                xmlSchemaAttributePtr item = (xmlSchemaAttributePtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
-        case XML_SCHEMA_TYPE_ANY: {
-                xmlSchemaWildcardPtr item = (xmlSchemaWildcardPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_PARTICLE:
-        case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:
-        case XML_SCHEMA_TYPE_IDC_UNIQUE: {
-                xmlSchemaAnnotItemPtr item = (xmlSchemaAnnotItemPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP: {
-                xmlSchemaAttributeGroupPtr item =
-                    (xmlSchemaAttributeGroupPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_NOTATION: {
-                xmlSchemaNotationPtr item = (xmlSchemaNotationPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_FACET_MININCLUSIVE:
-        case XML_SCHEMA_FACET_MINEXCLUSIVE:
-        case XML_SCHEMA_FACET_MAXINCLUSIVE:
-        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-        case XML_SCHEMA_FACET_TOTALDIGITS:
-        case XML_SCHEMA_FACET_FRACTIONDIGITS:
-        case XML_SCHEMA_FACET_PATTERN:
-        case XML_SCHEMA_FACET_ENUMERATION:
-        case XML_SCHEMA_FACET_WHITESPACE:
-        case XML_SCHEMA_FACET_LENGTH:
-        case XML_SCHEMA_FACET_MAXLENGTH:
-        case XML_SCHEMA_FACET_MINLENGTH: {
-                xmlSchemaFacetPtr item = (xmlSchemaFacetPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_SIMPLE:
-        case XML_SCHEMA_TYPE_COMPLEX: {
-                xmlSchemaTypePtr item = (xmlSchemaTypePtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_GROUP: {
-                xmlSchemaModelGroupDefPtr item = (xmlSchemaModelGroupDefPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        case XML_SCHEMA_TYPE_SEQUENCE:
-        case XML_SCHEMA_TYPE_CHOICE:
-        case XML_SCHEMA_TYPE_ALL: {
-                xmlSchemaModelGroupPtr item = (xmlSchemaModelGroupPtr) annItem;
-                ADD_ANNOTATION(annot)
-            }
-            break;
-        default:
-             xmlSchemaPCustomErr(NULL,
-                XML_SCHEMAP_INTERNAL,
-                NULL, NULL,
-                "Internal error: xmlSchemaAddAnnotation, "
-                "The item is not a annotated schema component", NULL);
-             break;
-    }
-    return (annot);
-}
-
-/**
- * xmlSchemaParseIDCSelectorAndField:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parses a XML Schema identity-contraint definition's
- * <selector> and <field> elements.
- *
- * Returns the parsed identity-constraint definition.
- */
-static xmlSchemaIDCSelectPtr
-xmlSchemaParseIDCSelectorAndField(xmlSchemaParserCtxtPtr ctxt,
-                          xmlSchemaIDCPtr idc,
-                          xmlNodePtr node,
-                          int isField)
-{
-    xmlSchemaIDCSelectPtr item;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "xpath"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /*
-    * Create the item.
-    */
-    item = (xmlSchemaIDCSelectPtr) xmlMalloc(sizeof(xmlSchemaIDCSelect));
-    if (item == NULL) {
-        xmlSchemaPErrMemory(ctxt,
-            "allocating a 'selector' of an identity-constraint definition",
-            NULL);
-        return (NULL);
-    }
-    memset(item, 0, sizeof(xmlSchemaIDCSelect));
-    /*
-    * Attribute "xpath" (mandatory).
-    */
-    attr = xmlSchemaGetPropNode(node, "xpath");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node,
-            "name", NULL);
-    } else {
-        item->xpath = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        /*
-        * URGENT TODO: "field"s have an other syntax than "selector"s.
-        */
-
-        if (xmlSchemaCheckCSelectorXPath(ctxt, idc, item, attr,
-            isField) == -1) {
-            xmlSchemaPErr(ctxt,
-                (xmlNodePtr) attr,
-                XML_SCHEMAP_INTERNAL,
-                "Internal error: xmlSchemaParseIDCSelectorAndField, "
-                "validating the XPath expression of a IDC selector.\n",
-                NULL, NULL);
-        }
-
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the parent IDC.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) idc,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?)");
-    }
-
-    return (item);
-}
-
-/**
- * xmlSchemaParseIDC:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parses a XML Schema identity-contraint definition.
- *
- * Returns the parsed identity-constraint definition.
- */
-static xmlSchemaIDCPtr
-xmlSchemaParseIDC(xmlSchemaParserCtxtPtr ctxt,
-                  xmlSchemaPtr schema,
-                  xmlNodePtr node,
-                  xmlSchemaTypeType idcCategory,
-                  const xmlChar *targetNamespace)
-{
-    xmlSchemaIDCPtr item = NULL;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *name = NULL;
-    xmlSchemaIDCSelectPtr field = NULL, lastField = NULL;
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                ((idcCategory != XML_SCHEMA_TYPE_IDC_KEYREF) ||
-                 (!xmlStrEqual(attr->name, BAD_CAST "refer")))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /*
-    * Attribute "name" (mandatory).
-    */
-    attr = xmlSchemaGetPropNode(node, "name");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node,
-            "name", NULL);
-        return (NULL);
-    } else if (xmlSchemaPValAttrNode(ctxt,
-        NULL, attr,
-        xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
-        return (NULL);
-    }
-    /* Create the component. */
-    item = xmlSchemaAddIDC(ctxt, schema, name, targetNamespace,
-        idcCategory, node);
-    if (item == NULL)
-        return(NULL);
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    if (idcCategory == XML_SCHEMA_TYPE_IDC_KEYREF) {
-        /*
-        * Attribute "refer" (mandatory).
-        */
-        attr = xmlSchemaGetPropNode(node, "refer");
-        if (attr == NULL) {
-            xmlSchemaPMissingAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_MISSING,
-                NULL, node,
-                "refer", NULL);
-        } else {
-            /*
-            * Create a reference item.
-            */
-            item->ref = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_IDC_KEY,
-                NULL, NULL);
-            if (item->ref == NULL)
-                return (NULL);
-            xmlSchemaPValAttrNodeQName(ctxt, schema,
-                NULL, attr,
-                &(item->ref->targetNamespace),
-                &(item->ref->name));
-            xmlSchemaCheckReference(ctxt, schema, node, attr,
-                item->ref->targetNamespace);
-        }
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_MISSING,
-                NULL, node, child,
-                "A child element is missing",
-                "(annotation?, (selector, field+))");
-    }
-    /*
-    * Child element <selector>.
-    */
-    if (IS_SCHEMA(child, "selector")) {
-        item->selector = xmlSchemaParseIDCSelectorAndField(ctxt,
-            item, child, 0);
-        child = child->next;
-        /*
-        * Child elements <field>.
-        */
-        if (IS_SCHEMA(child, "field")) {
-            do {
-                field = xmlSchemaParseIDCSelectorAndField(ctxt,
-                    item, child, 1);
-                if (field != NULL) {
-                    field->index = item->nbFields;
-                    item->nbFields++;
-                    if (lastField != NULL)
-                        lastField->next = field;
-                    else
-                        item->fields = field;
-                    lastField = field;
-                }
-                child = child->next;
-            } while (IS_SCHEMA(child, "field"));
-        } else {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child,
-                NULL, "(annotation?, (selector, field+))");
-        }
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?, (selector, field+))");
-    }
-
-    return (item);
-}
-
-/**
- * xmlSchemaParseElement:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- * @topLevel: indicates if this is global declaration
- *
- * Parses a XML schema element declaration.
- * *WARNING* this interface is highly subject to change
- *
- * Returns the element declaration or a particle; NULL in case
- * of an error or if the particle has minOccurs==maxOccurs==0.
- */
-static xmlSchemaBasicItemPtr
-xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                      xmlNodePtr node, int *isElemRef, int topLevel)
-{
-    xmlSchemaElementPtr decl = NULL;
-    xmlSchemaParticlePtr particle = NULL;
-    xmlSchemaAnnotPtr annot = NULL;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr, nameAttr;
-    int min, max, isRef = 0;
-    xmlChar *des = NULL;
-
-    /* 3.3.3 Constraints on XML Representations of Element Declarations */
-    /* TODO: Complete implementation of 3.3.6 */
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    if (isElemRef != NULL)
-        *isElemRef = 0;
-    /*
-    * If we get a "ref" attribute on a local <element> we will assume it's
-    * a reference - even if there's a "name" attribute; this seems to be more
-    * robust.
-    */
-    nameAttr = xmlSchemaGetPropNode(node, "name");
-    attr = xmlSchemaGetPropNode(node, "ref");
-    if ((topLevel) || (attr == NULL)) {
-        if (nameAttr == NULL) {
-            xmlSchemaPMissingAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_MISSING,
-                NULL, node, "name", NULL);
-            return (NULL);
-        }
-    } else
-        isRef = 1;
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    /*
-    * Skip particle part if a global declaration.
-    */
-    if (topLevel)
-        goto declaration_part;
-    /*
-    * The particle part ==================================================
-    */
-    min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
-    max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(xs:nonNegativeInteger | unbounded)");
-    xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
-    particle = xmlSchemaAddParticle(ctxt, node, min, max);
-    if (particle == NULL)
-        goto return_null;
-
-    /* ret->flags |= XML_SCHEMAS_ELEM_REF; */
-
-    if (isRef) {
-        const xmlChar *refNs = NULL, *ref = NULL;
-        xmlSchemaQNameRefPtr refer = NULL;
-        /*
-        * The reference part =============================================
-        */
-        if (isElemRef != NULL)
-            *isElemRef = 1;
-
-        xmlSchemaPValAttrNodeQName(ctxt, schema,
-            NULL, attr, &refNs, &ref);
-        xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
-        /*
-        * SPEC (3.3.3 : 2.1) "One of ref or name must be present, but not both"
-        */
-        if (nameAttr != NULL) {
-            xmlSchemaPMutualExclAttrErr(ctxt,
-                XML_SCHEMAP_SRC_ELEMENT_2_1, NULL, nameAttr, "ref", "name");
-        }
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if (xmlStrEqual(attr->name, BAD_CAST "ref") ||
-                    xmlStrEqual(attr->name, BAD_CAST "name") ||
-                    xmlStrEqual(attr->name, BAD_CAST "id") ||
-                    xmlStrEqual(attr->name, BAD_CAST "maxOccurs") ||
-                    xmlStrEqual(attr->name, BAD_CAST "minOccurs"))
-                {
-                    attr = attr->next;
-                    continue;
-                } else {
-                    /* SPEC (3.3.3 : 2.2) */
-                    xmlSchemaPCustomAttrErr(ctxt,
-                        XML_SCHEMAP_SRC_ELEMENT_2_2,
-                        NULL, NULL, attr,
-                        "Only the attributes 'minOccurs', 'maxOccurs' and "
-                        "'id' are allowed in addition to 'ref'");
-                    break;
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-        /*
-        * No children except <annotation> expected.
-        */
-        if (child != NULL) {
-            xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL, "(annotation?)");
-        }
-        if ((min == 0) && (max == 0))
-            goto return_null;
-        /*
-        * Create the reference item and attach it to the particle.
-        */
-        refer = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_ELEMENT,
-            ref, refNs);
-        if (refer == NULL)
-            goto return_null;
-        particle->children = (xmlSchemaTreeItemPtr) refer;
-        particle->annot = annot;
-        /*
-        * Add the particle to pending components, since the reference
-        * need to be resolved.
-        */
-        WXS_ADD_PENDING(ctxt, particle);
-        return ((xmlSchemaBasicItemPtr) particle);
-    }
-    /*
-    * The declaration part ===============================================
-    */
-declaration_part:
-    {
-        const xmlChar *ns = NULL, *fixed, *name, *attrValue;
-        xmlSchemaIDCPtr curIDC = NULL, lastIDC = NULL;
-
-        if (xmlSchemaPValAttrNode(ctxt, NULL, nameAttr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0)
-            goto return_null;
-        /*
-        * Evaluate the target namespace.
-        */
-        if (topLevel) {
-            ns = ctxt->targetNamespace;
-        } else {
-            attr = xmlSchemaGetPropNode(node, "form");
-            if (attr != NULL) {
-                attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-                if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
-                    ns = ctxt->targetNamespace;
-                } else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified")) {
-                    xmlSchemaPSimpleTypeErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                        NULL, (xmlNodePtr) attr,
-                        NULL, "(qualified | unqualified)",
-                        attrValue, NULL, NULL, NULL);
-                }
-            } else if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
-                ns = ctxt->targetNamespace;
-        }
-        decl = xmlSchemaAddElement(ctxt, name, ns, node, topLevel);
-        if (decl == NULL) {
-            goto return_null;
-        }
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "type")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "block")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "nillable")))
-                {
-                    if (topLevel == 0) {
-                        if ((!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
-                            (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
-                            (!xmlStrEqual(attr->name, BAD_CAST "form")))
-                        {
-                            xmlSchemaPIllegalAttrErr(ctxt,
-                                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                        }
-                    } else if ((!xmlStrEqual(attr->name, BAD_CAST "final")) &&
-                        (!xmlStrEqual(attr->name, BAD_CAST "abstract")) &&
-                        (!xmlStrEqual(attr->name, BAD_CAST "substitutionGroup"))) {
-
-                        xmlSchemaPIllegalAttrErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                    }
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-        /*
-        * Extract/validate attributes.
-        */
-        if (topLevel) {
-            /*
-            * Process top attributes of global element declarations here.
-            */
-            decl->flags |= XML_SCHEMAS_ELEM_GLOBAL;
-            decl->flags |= XML_SCHEMAS_ELEM_TOPLEVEL;
-            xmlSchemaPValAttrQName(ctxt, schema,
-                NULL, node, "substitutionGroup",
-                &(decl->substGroupNs), &(decl->substGroup));
-            if (xmlGetBooleanProp(ctxt, node, "abstract", 0))
-                decl->flags |= XML_SCHEMAS_ELEM_ABSTRACT;
-            /*
-            * Attribute "final".
-            */
-            attr = xmlSchemaGetPropNode(node, "final");
-            if (attr == NULL) {
-                if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
-                    decl->flags |= XML_SCHEMAS_ELEM_FINAL_EXTENSION;
-                if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
-                    decl->flags |= XML_SCHEMAS_ELEM_FINAL_RESTRICTION;
-            } else {
-                attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-                if (xmlSchemaPValAttrBlockFinal(attrValue, &(decl->flags),
-                    -1,
-                    XML_SCHEMAS_ELEM_FINAL_EXTENSION,
-                    XML_SCHEMAS_ELEM_FINAL_RESTRICTION, -1, -1, -1) != 0) {
-                    xmlSchemaPSimpleTypeErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                        NULL, (xmlNodePtr) attr,
-                        NULL, "(#all | List of (extension | restriction))",
-                        attrValue, NULL, NULL, NULL);
-                }
-            }
-        }
-        /*
-        * Attribute "block".
-        */
-        attr = xmlSchemaGetPropNode(node, "block");
-        if (attr == NULL) {
-            /*
-            * Apply default "block" values.
-            */
-            if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
-                decl->flags |= XML_SCHEMAS_ELEM_BLOCK_RESTRICTION;
-            if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
-                decl->flags |= XML_SCHEMAS_ELEM_BLOCK_EXTENSION;
-            if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION)
-                decl->flags |= XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION;
-        } else {
-            attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-            if (xmlSchemaPValAttrBlockFinal(attrValue, &(decl->flags),
-                -1,
-                XML_SCHEMAS_ELEM_BLOCK_EXTENSION,
-                XML_SCHEMAS_ELEM_BLOCK_RESTRICTION,
-                XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION, -1, -1) != 0) {
-                xmlSchemaPSimpleTypeErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                    NULL, (xmlNodePtr) attr,
-                    NULL, "(#all | List of (extension | "
-                    "restriction | substitution))", attrValue,
-                    NULL, NULL, NULL);
-            }
-        }
-        if (xmlGetBooleanProp(ctxt, node, "nillable", 0))
-            decl->flags |= XML_SCHEMAS_ELEM_NILLABLE;
-
-        attr = xmlSchemaGetPropNode(node, "type");
-        if (attr != NULL) {
-            xmlSchemaPValAttrNodeQName(ctxt, schema,
-                NULL, attr,
-                &(decl->namedTypeNs), &(decl->namedType));
-            xmlSchemaCheckReference(ctxt, schema, node,
-                attr, decl->namedTypeNs);
-        }
-        decl->value = xmlSchemaGetProp(ctxt, node, "default");
-        attr = xmlSchemaGetPropNode(node, "fixed");
-        if (attr != NULL) {
-            fixed = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-            if (decl->value != NULL) {
-                /*
-                * 3.3.3 : 1
-                * default and fixed must not both be present.
-                */
-                xmlSchemaPMutualExclAttrErr(ctxt,
-                    XML_SCHEMAP_SRC_ELEMENT_1,
-                    NULL, attr, "default", "fixed");
-            } else {
-                decl->flags |= XML_SCHEMAS_ELEM_FIXED;
-                decl->value = fixed;
-            }
-        }
-        /*
-        * And now for the children...
-        */
-        if (IS_SCHEMA(child, "complexType")) {
-            /*
-            * 3.3.3 : 3
-            * "type" and either <simpleType> or <complexType> are mutually
-            * exclusive
-            */
-            if (decl->namedType != NULL) {
-                xmlSchemaPContentErr(ctxt,
-                    XML_SCHEMAP_SRC_ELEMENT_3,
-                    NULL, node, child,
-                    "The attribute 'type' and the <complexType> child are "
-                    "mutually exclusive", NULL);
-            } else
-                WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseComplexType(ctxt, schema, child, 0);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "simpleType")) {
-            /*
-            * 3.3.3 : 3
-            * "type" and either <simpleType> or <complexType> are
-            * mutually exclusive
-            */
-            if (decl->namedType != NULL) {
-                xmlSchemaPContentErr(ctxt,
-                    XML_SCHEMAP_SRC_ELEMENT_3,
-                    NULL, node, child,
-                    "The attribute 'type' and the <simpleType> child are "
-                    "mutually exclusive", NULL);
-            } else
-                WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
-            child = child->next;
-        }
-        while ((IS_SCHEMA(child, "unique")) ||
-            (IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
-            if (IS_SCHEMA(child, "unique")) {
-                curIDC = xmlSchemaParseIDC(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_IDC_UNIQUE, decl->targetNamespace);
-            } else if (IS_SCHEMA(child, "key")) {
-                curIDC = xmlSchemaParseIDC(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_IDC_KEY, decl->targetNamespace);
-            } else if (IS_SCHEMA(child, "keyref")) {
-                curIDC = xmlSchemaParseIDC(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_IDC_KEYREF, decl->targetNamespace);
-            }
-            if (lastIDC != NULL)
-                lastIDC->next = curIDC;
-            else
-                decl->idcs = (void *) curIDC;
-            lastIDC = curIDC;
-            child = child->next;
-        }
-        if (child != NULL) {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child,
-                NULL, "(annotation?, ((simpleType | complexType)?, "
-                "(unique | key | keyref)*))");
-        }
-        decl->annot = annot;
-    }
-    /*
-    * NOTE: Element Declaration Representation OK 4. will be checked at a
-    * different layer.
-    */
-    FREE_AND_NULL(des)
-    if (topLevel)
-        return ((xmlSchemaBasicItemPtr) decl);
-    else {
-        particle->children = (xmlSchemaTreeItemPtr) decl;
-        return ((xmlSchemaBasicItemPtr) particle);
-    }
-
-return_null:
-    FREE_AND_NULL(des);
-    if (annot != NULL) {
-        if (particle != NULL)
-            particle->annot = NULL;
-        if (decl != NULL)
-            decl->annot = NULL;
-        xmlSchemaFreeAnnot(annot);
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaParseUnion:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Union definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of internal error, 0 in case of success and a positive
- * error code otherwise.
- */
-static int
-xmlSchemaParseUnion(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                    xmlNodePtr node)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *cur = NULL;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (-1);
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    /*
-    * Mark the simple type as being of variety "union".
-    */
-    type->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
-    /*
-    * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
-    * then the `simple ur-type definition`."
-    */
-    type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "memberTypes"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * Attribute "memberTypes". This is a list of QNames.
-    * TODO: Check the value to contain anything.
-    */
-    attr = xmlSchemaGetPropNode(node, "memberTypes");
-    if (attr != NULL) {
-        const xmlChar *end;
-        xmlChar *tmp;
-        const xmlChar *localName, *nsName;
-        xmlSchemaTypeLinkPtr link, lastLink = NULL;
-        xmlSchemaQNameRefPtr ref;
-
-        cur = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        type->base = cur;
-        do {
-            while (IS_BLANK_CH(*cur))
-                cur++;
-            end = cur;
-            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-                end++;
-            if (end == cur)
-                break;
-            tmp = xmlStrndup(cur, end - cur);
-            if (xmlSchemaPValAttrNodeQNameValue(ctxt, schema,
-                NULL, attr, BAD_CAST tmp, &nsName, &localName) == 0) {
-                /*
-                * Create the member type link.
-                */
-                link = (xmlSchemaTypeLinkPtr)
-                    xmlMalloc(sizeof(xmlSchemaTypeLink));
-                if (link == NULL) {
-                    xmlSchemaPErrMemory(ctxt, "xmlSchemaParseUnion, "
-                        "allocating a type link", NULL);
-                    return (-1);
-                }
-                link->type = NULL;
-                link->next = NULL;
-                if (lastLink == NULL)
-                    type->memberTypes = link;
-                else
-                    lastLink->next = link;
-                lastLink = link;
-                /*
-                * Create a reference item.
-                */
-                ref = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_SIMPLE,
-                    localName, nsName);
-                if (ref == NULL) {
-                    FREE_AND_NULL(tmp)
-                    return (-1);
-                }
-                /*
-                * Assign the reference to the link, it will be resolved
-                * later during fixup of the union simple type.
-                */
-                link->type = (xmlSchemaTypePtr) ref;
-            }
-            FREE_AND_NULL(tmp)
-            cur = end;
-        } while (*cur != 0);
-
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the simple type ancestor.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (IS_SCHEMA(child, "simpleType")) {
-        xmlSchemaTypePtr subtype, last = NULL;
-
-        /*
-        * Anchor the member types in the "subtypes" field of the
-        * simple type.
-        */
-        while (IS_SCHEMA(child, "simpleType")) {
-            subtype = (xmlSchemaTypePtr)
-                xmlSchemaParseSimpleType(ctxt, schema, child, 0);
-            if (subtype != NULL) {
-                if (last == NULL) {
-                    type->subtypes = subtype;
-                    last = subtype;
-                } else {
-                    last->next = subtype;
-                    last = subtype;
-                }
-                last->next = NULL;
-            }
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL, "(annotation?, simpleType*)");
-    }
-    if ((attr == NULL) && (type->subtypes == NULL)) {
-         /*
-        * src-union-memberTypes-or-simpleTypes
-        * Either the memberTypes [attribute] of the <union> element must
-        * be non-empty or there must be at least one simpleType [child].
-        */
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
-            NULL, node,
-            "Either the attribute 'memberTypes' or "
-            "at least one <simpleType> child must be present", NULL);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaParseList:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema List definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of error, 0 if the declaration is improper and
- *         1 in case of success.
- */
-static xmlSchemaTypePtr
-xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                   xmlNodePtr node)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    /*
-    * Mark the type as being of variety "list".
-    */
-    type->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
-    /*
-    * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
-    * then the `simple ur-type definition`."
-    */
-    type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "itemType"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-
-    /*
-    * Attribute "itemType". NOTE that we will use the "ref" and "refNs"
-    * fields for holding the reference to the itemType.
-    *
-    * REVAMP TODO: Use the "base" and "baseNs" fields, since we will remove
-    * the "ref" fields.
-    */
-    xmlSchemaPValAttrQName(ctxt, schema, NULL,
-        node, "itemType", &(type->baseNs), &(type->base));
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (IS_SCHEMA(child, "simpleType")) {
-        /*
-        * src-list-itemType-or-simpleType
-        * Either the itemType [attribute] or the <simpleType> [child] of
-        * the <list> element must be present, but not both.
-        */
-        if (type->base != NULL) {
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
-                NULL, node,
-                "The attribute 'itemType' and the <simpleType> child "
-                "are mutually exclusive", NULL);
-        } else {
-            type->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
-        }
-        child = child->next;
-    } else if (type->base == NULL) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
-            NULL, node,
-            "Either the attribute 'itemType' or the <simpleType> child "
-            "must be present", NULL);
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL, "(annotation?, simpleType?)");
-    }
-    if ((type->base == NULL) &&
-        (type->subtypes == NULL) &&
-        (xmlSchemaGetPropNode(node, "itemType") == NULL)) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
-            NULL, node,
-            "Either the attribute 'itemType' or the <simpleType> child "
-            "must be present", NULL);
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaParseSimpleType:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Simple Type definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of error, 0 if the declaration is improper and
- * 1 in case of success.
- */
-static xmlSchemaTypePtr
-xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                         xmlNodePtr node, int topLevel)
-{
-    xmlSchemaTypePtr type, oldCtxtType;
-    xmlNodePtr child = NULL;
-    const xmlChar *attrValue = NULL;
-    xmlAttrPtr attr;
-    int hasRestriction = 0;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    if (topLevel) {
-        attr = xmlSchemaGetPropNode(node, "name");
-        if (attr == NULL) {
-            xmlSchemaPMissingAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_MISSING,
-                NULL, node,
-                "name", NULL);
-            return (NULL);
-        } else {
-            if (xmlSchemaPValAttrNode(ctxt,
-                NULL, attr,
-                xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &attrValue) != 0)
-                return (NULL);
-            /*
-            * Skip built-in types.
-            */
-            if (ctxt->isS4S) {
-                xmlSchemaTypePtr biType;
-
-                if (ctxt->isRedefine) {
-                    /*
-                    * REDEFINE: Disallow redefinition of built-in-types.
-                    * TODO: It seems that the spec does not say anything
-                    * about this case.
-                    */
-                    xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
-                        NULL, node,
-                        "Redefinition of built-in simple types is not "
-                        "supported", NULL);
-                    return(NULL);
-                }
-                biType = xmlSchemaGetPredefinedType(attrValue, xmlSchemaNs);
-                if (biType != NULL)
-                    return (biType);
-            }
-        }
-    }
-    /*
-    * TargetNamespace:
-    * SPEC "The `actual value` of the targetNamespace [attribute]
-    * of the <schema> ancestor element information item if present,
-    * otherwise `absent`.
-    */
-    if (topLevel == 0) {
-#ifdef ENABLE_NAMED_LOCALS
-        char buf[40];
-#endif
-        /*
-        * Parse as local simple type definition.
-        */
-#ifdef ENABLE_NAMED_LOCALS
-        snprintf(buf, 39, "#ST%d", ctxt->counter++ + 1);
-        type = xmlSchemaAddType(ctxt, schema,
-            XML_SCHEMA_TYPE_SIMPLE,
-            xmlDictLookup(ctxt->dict, (const xmlChar *)buf, -1),
-            ctxt->targetNamespace, node, 0);
-#else
-        type = xmlSchemaAddType(ctxt, schema,
-            XML_SCHEMA_TYPE_SIMPLE,
-            NULL, ctxt->targetNamespace, node, 0);
-#endif
-        if (type == NULL)
-            return (NULL);
-        type->type = XML_SCHEMA_TYPE_SIMPLE;
-        type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-    } else {
-        /*
-        * Parse as global simple type definition.
-        *
-        * Note that attrValue is the value of the attribute "name" here.
-        */
-        type = xmlSchemaAddType(ctxt, schema, XML_SCHEMA_TYPE_SIMPLE,
-            attrValue, ctxt->targetNamespace, node, 1);
-        if (type == NULL)
-            return (NULL);
-        type->type = XML_SCHEMA_TYPE_SIMPLE;
-        type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
-        type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "final"))) {
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-        /*
-        * Attribute "final".
-        */
-        attr = xmlSchemaGetPropNode(node, "final");
-        if (attr == NULL) {
-            if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
-                type->flags |= XML_SCHEMAS_TYPE_FINAL_RESTRICTION;
-            if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_LIST)
-                type->flags |= XML_SCHEMAS_TYPE_FINAL_LIST;
-            if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_UNION)
-                type->flags |= XML_SCHEMAS_TYPE_FINAL_UNION;
-        } else {
-            attrValue = xmlSchemaGetProp(ctxt, node, "final");
-            if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
-                -1, -1, XML_SCHEMAS_TYPE_FINAL_RESTRICTION, -1,
-                XML_SCHEMAS_TYPE_FINAL_LIST,
-                XML_SCHEMAS_TYPE_FINAL_UNION) != 0) {
-
-                xmlSchemaPSimpleTypeErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                    WXS_BASIC_CAST type, (xmlNodePtr) attr,
-                    NULL, "(#all | List of (list | union | restriction)",
-                    attrValue, NULL, NULL, NULL);
-            }
-        }
-    }
-    type->targetNamespace = ctxt->targetNamespace;
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    oldCtxtType = ctxt->ctxtType;
-
-    ctxt->ctxtType = type;
-
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_MISSING,
-            NULL, node, child, NULL,
-            "(annotation?, (restriction | list | union))");
-    } else if (IS_SCHEMA(child, "restriction")) {
-        xmlSchemaParseRestriction(ctxt, schema, child,
-            XML_SCHEMA_TYPE_SIMPLE);
-        hasRestriction = 1;
-        child = child->next;
-    } else if (IS_SCHEMA(child, "list")) {
-        xmlSchemaParseList(ctxt, schema, child);
-        child = child->next;
-    } else if (IS_SCHEMA(child, "union")) {
-        xmlSchemaParseUnion(ctxt, schema, child);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?, (restriction | list | union))");
-    }
-    /*
-    * REDEFINE: SPEC src-redefine (5)
-    * "Within the [children], each <simpleType> must have a
-    * <restriction> among its [children] ... the `actual value` of whose
-    * base [attribute] must be the same as the `actual value` of its own
-    * name attribute plus target namespace;"
-    */
-    if (topLevel && ctxt->isRedefine && (! hasRestriction)) {
-        xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
-            NULL, node, "This is a redefinition, thus the "
-            "<simpleType> must have a <restriction> child", NULL);
-    }
-
-    ctxt->ctxtType = oldCtxtType;
-    return (type);
-}
-
-/**
- * xmlSchemaParseModelGroupDefRef:
- * @ctxt:  the parser context
- * @schema: the schema being built
- * @node:  the node
- *
- * Parses a reference to a model group definition.
- *
- * We will return a particle component with a qname-component or
- * NULL in case of an error.
- */
-static xmlSchemaTreeItemPtr
-xmlSchemaParseModelGroupDefRef(xmlSchemaParserCtxtPtr ctxt,
-                               xmlSchemaPtr schema,
-                               xmlNodePtr node)
-{
-    xmlSchemaParticlePtr item;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *ref = NULL, *refNs = NULL;
-    int min, max;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    attr = xmlSchemaGetPropNode(node, "ref");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "ref", NULL);
-        return (NULL);
-    } else if (xmlSchemaPValAttrNodeQName(ctxt, schema, NULL,
-        attr, &refNs, &ref) != 0) {
-        return (NULL);
-    }
-    xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
-    min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
-    max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
-        "(xs:nonNegativeInteger | unbounded)");
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    item = xmlSchemaAddParticle(ctxt, node, min, max);
-    if (item == NULL)
-        return (NULL);
-    /*
-    * Create a qname-reference and set as the term; it will be substituted
-    * for the model group after the reference has been resolved.
-    */
-    item->children = (xmlSchemaTreeItemPtr)
-        xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_GROUP, ref, refNs);
-    xmlSchemaPCheckParticleCorrect_2(ctxt, item, node, min, max);
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    /* TODO: Is annotation even allowed for a model group reference? */
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * TODO: What to do exactly with the annotation?
-        */
-        item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?)");
-    }
-    /*
-    * Corresponds to no component at all if minOccurs==maxOccurs==0.
-    */
-    if ((min == 0) && (max == 0))
-        return (NULL);
-
-    return ((xmlSchemaTreeItemPtr) item);
-}
-
-/**
- * xmlSchemaParseModelGroupDefinition:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parses a XML schema model group definition.
- *
- * Note that the contraint src-redefine (6.2) can't be applied until
- * references have been resolved. So we will do this at the
- * component fixup level.
- *
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of error, 0 if the declaration is improper and
- *         1 in case of success.
- */
-static xmlSchemaModelGroupDefPtr
-xmlSchemaParseModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
-                                   xmlSchemaPtr schema,
-                                   xmlNodePtr node)
-{
-    xmlSchemaModelGroupDefPtr item;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *name;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    attr = xmlSchemaGetPropNode(node, "name");
-    if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node,
-            "name", NULL);
-        return (NULL);
-    } else if (xmlSchemaPValAttrNode(ctxt, NULL, attr,
-        xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
-        return (NULL);
-    }
-    item = xmlSchemaAddModelGroupDefinition(ctxt, schema, name,
-        ctxt->targetNamespace, node);
-    if (item == NULL)
-        return (NULL);
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "id"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (IS_SCHEMA(child, "all")) {
-        item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
-            XML_SCHEMA_TYPE_ALL, 0);
-        child = child->next;
-    } else if (IS_SCHEMA(child, "choice")) {
-        item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
-            XML_SCHEMA_TYPE_CHOICE, 0);
-        child = child->next;
-    } else if (IS_SCHEMA(child, "sequence")) {
-        item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
-            XML_SCHEMA_TYPE_SEQUENCE, 0);
-        child = child->next;
-    }
-
-
-
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?, (all | choice | sequence)?)");
-    }
-    return (item);
-}
-
-/**
- * xmlSchemaCleanupDoc:
- * @ctxt:  a schema validation context
- * @node:  the root of the document.
- *
- * removes unwanted nodes in a schemas document tree
- */
-static void
-xmlSchemaCleanupDoc(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr root)
-{
-    xmlNodePtr delete, cur;
-
-    if ((ctxt == NULL) || (root == NULL)) return;
-
-    /*
-     * Remove all the blank text nodes
-     */
-    delete = NULL;
-    cur = root;
-    while (cur != NULL) {
-        if (delete != NULL) {
-            xmlUnlinkNode(delete);
-            xmlFreeNode(delete);
-            delete = NULL;
-        }
-        if (cur->type == XML_TEXT_NODE) {
-            if (IS_BLANK_NODE(cur)) {
-                if (xmlNodeGetSpacePreserve(cur) != 1) {
-                    delete = cur;
-                }
-            }
-        } else if ((cur->type != XML_ELEMENT_NODE) &&
-                   (cur->type != XML_CDATA_SECTION_NODE)) {
-            delete = cur;
-            goto skip_children;
-        }
-
-        /*
-         * Skip to next node
-         */
-        if (cur->children != NULL) {
-            if ((cur->children->type != XML_ENTITY_DECL) &&
-                (cur->children->type != XML_ENTITY_REF_NODE) &&
-                (cur->children->type != XML_ENTITY_NODE)) {
-                cur = cur->children;
-                continue;
-            }
-        }
-      skip_children:
-        if (cur->next != NULL) {
-            cur = cur->next;
-            continue;
-        }
-
-        do {
-            cur = cur->parent;
-            if (cur == NULL)
-                break;
-            if (cur == root) {
-                cur = NULL;
-                break;
-            }
-            if (cur->next != NULL) {
-                cur = cur->next;
-                break;
-            }
-        } while (cur != NULL);
-    }
-    if (delete != NULL) {
-        xmlUnlinkNode(delete);
-        xmlFreeNode(delete);
-        delete = NULL;
-    }
-}
-
-
-static void
-xmlSchemaClearSchemaDefaults(xmlSchemaPtr schema)
-{
-    if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
-        schema->flags ^= XML_SCHEMAS_QUALIF_ELEM;
-
-    if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
-        schema->flags ^= XML_SCHEMAS_QUALIF_ATTR;
-
-    if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
-        schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_EXTENSION;
-    if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
-        schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION;
-    if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_LIST)
-        schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_LIST;
-    if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_UNION)
-        schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_UNION;
-
-    if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
-        schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION;
-    if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
-        schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION;
-    if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION)
-        schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION;
-}
-
-static int
-xmlSchemaParseSchemaElement(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaPtr schema,
-                             xmlNodePtr node)
-{
-    xmlAttrPtr attr;
-    const xmlChar *val;
-    int res = 0, oldErrs = ctxt->nberrors;
-
-    /*
-    * Those flags should be moved to the parser context flags,
-    * since they are not visible at the component level. I.e.
-    * they are used if processing schema *documents* only.
-    */
-    res = xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    HFAILURE;
-
-    /*
-    * Since the version is of type xs:token, we won't bother to
-    * check it.
-    */
-    /* REMOVED:
-    attr = xmlSchemaGetPropNode(node, "version");
-    if (attr != NULL) {
-        res = xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_TOKEN), &val);
-        HFAILURE;
-    }
-    */
-    attr = xmlSchemaGetPropNode(node, "targetNamespace");
-    if (attr != NULL) {
-        res = xmlSchemaPValAttrNode(ctxt, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
-        HFAILURE;
-        if (res != 0) {
-            ctxt->stop = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
-            goto exit;
-        }
-    }
-    attr = xmlSchemaGetPropNode(node, "elementFormDefault");
-    if (attr != NULL) {
-        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        res = xmlSchemaPValAttrFormDefault(val, &schema->flags,
-            XML_SCHEMAS_QUALIF_ELEM);
-        HFAILURE;
-        if (res != 0) {
-            xmlSchemaPSimpleTypeErr(ctxt,
-                XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
-                NULL, (xmlNodePtr) attr, NULL,
-                "(qualified | unqualified)", val, NULL, NULL, NULL);
-        }
-    }
-    attr = xmlSchemaGetPropNode(node, "attributeFormDefault");
-    if (attr != NULL) {
-        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        res = xmlSchemaPValAttrFormDefault(val, &schema->flags,
-            XML_SCHEMAS_QUALIF_ATTR);
-        HFAILURE;
-        if (res != 0) {
-            xmlSchemaPSimpleTypeErr(ctxt,
-                XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
-                NULL, (xmlNodePtr) attr, NULL,
-                "(qualified | unqualified)", val, NULL, NULL, NULL);
-        }
-    }
-    attr = xmlSchemaGetPropNode(node, "finalDefault");
-    if (attr != NULL) {
-        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        res = xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
-            XML_SCHEMAS_FINAL_DEFAULT_EXTENSION,
-            XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION,
-            -1,
-            XML_SCHEMAS_FINAL_DEFAULT_LIST,
-            XML_SCHEMAS_FINAL_DEFAULT_UNION);
-        HFAILURE;
-        if (res != 0) {
-            xmlSchemaPSimpleTypeErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                NULL, (xmlNodePtr) attr, NULL,
-                "(#all | List of (extension | restriction | list | union))",
-                val, NULL, NULL, NULL);
-        }
-    }
-    attr = xmlSchemaGetPropNode(node, "blockDefault");
-    if (attr != NULL) {
-        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
-        res = xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
-            XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION,
-            XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION,
-            XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION, -1, -1);
-        HFAILURE;
-        if (res != 0) {
-            xmlSchemaPSimpleTypeErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                NULL, (xmlNodePtr) attr, NULL,
-                "(#all | List of (extension | restriction | substitution))",
-                val, NULL, NULL, NULL);
-        }
-    }
-
-exit:
-    if (oldErrs != ctxt->nberrors)
-        res = ctxt->err;
-    return(res);
-exit_failure:
-    return(-1);
-}
-
-/**
- * xmlSchemaParseSchemaTopLevel:
- * @ctxt:  a schema validation context
- * @schema:  the schemas
- * @nodes:  the list of top level nodes
- *
- * Returns the internal XML Schema structure built from the resource or
- *         NULL in case of error
- */
-static int
-xmlSchemaParseSchemaTopLevel(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaPtr schema, xmlNodePtr nodes)
-{
-    xmlNodePtr child;
-    xmlSchemaAnnotPtr annot;
-    int res = 0, oldErrs, tmpOldErrs;
-
-    if ((ctxt == NULL) || (schema == NULL) || (nodes == NULL))
-        return(-1);
-
-    oldErrs = ctxt->nberrors;
-    child = nodes;
-    while ((IS_SCHEMA(child, "include")) ||
-           (IS_SCHEMA(child, "import")) ||
-           (IS_SCHEMA(child, "redefine")) ||
-           (IS_SCHEMA(child, "annotation"))) {
-        if (IS_SCHEMA(child, "annotation")) {
-            annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-            if (schema->annot == NULL)
-                schema->annot = annot;
-            else
-                xmlSchemaFreeAnnot(annot);
-        } else if (IS_SCHEMA(child, "import")) {
-            tmpOldErrs = ctxt->nberrors;
-            res = xmlSchemaParseImport(ctxt, schema, child);
-            HFAILURE;
-            HSTOP(ctxt);
-            if (tmpOldErrs != ctxt->nberrors)
-                goto exit;
-        } else if (IS_SCHEMA(child, "include")) {
-            tmpOldErrs = ctxt->nberrors;
-            res = xmlSchemaParseInclude(ctxt, schema, child);
-            HFAILURE;
-            HSTOP(ctxt);
-            if (tmpOldErrs != ctxt->nberrors)
-                goto exit;
-        } else if (IS_SCHEMA(child, "redefine")) {
-            tmpOldErrs = ctxt->nberrors;
-            res = xmlSchemaParseRedefine(ctxt, schema, child);
-            HFAILURE;
-            HSTOP(ctxt);
-            if (tmpOldErrs != ctxt->nberrors)
-                goto exit;
-        }
-        child = child->next;
-    }
-    /*
-    * URGENT TODO: Change the functions to return int results.
-    * We need especially to catch internal errors.
-    */
-    while (child != NULL) {
-        if (IS_SCHEMA(child, "complexType")) {
-            xmlSchemaParseComplexType(ctxt, schema, child, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "simpleType")) {
-            xmlSchemaParseSimpleType(ctxt, schema, child, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "element")) {
-            xmlSchemaParseElement(ctxt, schema, child, NULL, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "attribute")) {
-            xmlSchemaParseGlobalAttribute(ctxt, schema, child);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "attributeGroup")) {
-            xmlSchemaParseAttributeGroupDefinition(ctxt, schema, child);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "group")) {
-            xmlSchemaParseModelGroupDefinition(ctxt, schema, child);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "notation")) {
-            xmlSchemaParseNotation(ctxt, schema, child);
-            child = child->next;
-        } else {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, child->parent, child,
-                NULL, "((include | import | redefine | annotation)*, "
-                "(((simpleType | complexType | group | attributeGroup) "
-                "| element | attribute | notation), annotation*)*)");
-            child = child->next;
-        }
-        while (IS_SCHEMA(child, "annotation")) {
-            /*
-            * TODO: We should add all annotations.
-            */
-            annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-            if (schema->annot == NULL)
-                schema->annot = annot;
-            else
-                xmlSchemaFreeAnnot(annot);
-            child = child->next;
-        }
-    }
-exit:
-    ctxt->ctxtType = NULL;
-    if (oldErrs != ctxt->nberrors)
-        res = ctxt->err;
-    return(res);
-exit_failure:
-    return(-1);
-}
-
-static xmlSchemaSchemaRelationPtr
-xmlSchemaSchemaRelationCreate(void)
-{
-    xmlSchemaSchemaRelationPtr ret;
-
-    ret = (xmlSchemaSchemaRelationPtr)
-        xmlMalloc(sizeof(xmlSchemaSchemaRelation));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL, "allocating schema relation", NULL);
-        return(NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaSchemaRelation));
-    return(ret);
-}
-
-#if 0
-static void
-xmlSchemaSchemaRelationFree(xmlSchemaSchemaRelationPtr rel)
-{
-    xmlFree(rel);
-}
-#endif
-
-static void
-xmlSchemaRedefListFree(xmlSchemaRedefPtr redef)
-{
-    xmlSchemaRedefPtr prev;
-
-    while (redef != NULL) {
-        prev = redef;
-        redef = redef->next;
-        xmlFree(prev);
-    }
-}
-
-static void
-xmlSchemaConstructionCtxtFree(xmlSchemaConstructionCtxtPtr con)
-{
-    /*
-    * After the construction context has been freed, there will be
-    * no schema graph available any more. Only the schema buckets
-    * will stay alive, which are put into the "schemasImports" and
-    * "includes" slots of the xmlSchema.
-    */
-    if (con->buckets != NULL)
-        xmlSchemaItemListFree(con->buckets);
-    if (con->pending != NULL)
-        xmlSchemaItemListFree(con->pending);
-    if (con->substGroups != NULL)
-        xmlHashFree(con->substGroups,
-            (xmlHashDeallocator) xmlSchemaSubstGroupFree);
-    if (con->redefs != NULL)
-        xmlSchemaRedefListFree(con->redefs);
-    if (con->dict != NULL)
-        xmlDictFree(con->dict);
-    xmlFree(con);
-}
-
-static xmlSchemaConstructionCtxtPtr
-xmlSchemaConstructionCtxtCreate(xmlDictPtr dict)
-{
-    xmlSchemaConstructionCtxtPtr ret;
-
-    ret = (xmlSchemaConstructionCtxtPtr)
-        xmlMalloc(sizeof(xmlSchemaConstructionCtxt));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL,
-            "allocating schema construction context", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaConstructionCtxt));
-
-    ret->buckets = xmlSchemaItemListCreate();
-    if (ret->buckets == NULL) {
-        xmlSchemaPErrMemory(NULL,
-            "allocating list of schema buckets", NULL);
-        xmlFree(ret);
-        return (NULL);
-    }
-    ret->pending = xmlSchemaItemListCreate();
-    if (ret->pending == NULL) {
-        xmlSchemaPErrMemory(NULL,
-            "allocating list of pending global components", NULL);
-        xmlSchemaConstructionCtxtFree(ret);
-        return (NULL);
-    }
-    ret->dict = dict;
-    xmlDictReference(dict);
-    return(ret);
-}
-
-static xmlSchemaParserCtxtPtr
-xmlSchemaParserCtxtCreate(void)
-{
-    xmlSchemaParserCtxtPtr ret;
-
-    ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
-    if (ret == NULL) {
-        xmlSchemaPErrMemory(NULL, "allocating schema parser context",
-                            NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaParserCtxt));
-    ret->type = XML_SCHEMA_CTXT_PARSER;
-    ret->attrProhibs = xmlSchemaItemListCreate();
-    if (ret->attrProhibs == NULL) {
-        xmlFree(ret);
-        return(NULL);
-    }
-    return(ret);
-}
-
-/**
- * xmlSchemaNewParserCtxtUseDict:
- * @URL:  the location of the schema
- * @dict: the dictionary to be used
- *
- * Create an XML Schemas parse context for that file/resource expected
- * to contain an XML Schemas file.
- *
- * Returns the parser context or NULL in case of error
- */
-static xmlSchemaParserCtxtPtr
-xmlSchemaNewParserCtxtUseDict(const char *URL, xmlDictPtr dict)
-{
-    xmlSchemaParserCtxtPtr ret;
-
-    ret = xmlSchemaParserCtxtCreate();
-    if (ret == NULL)
-        return (NULL);
-    ret->dict = dict;
-    xmlDictReference(dict);
-    if (URL != NULL)
-        ret->URL = xmlDictLookup(dict, (const xmlChar *) URL, -1);
-    return (ret);
-}
-
-static int
-xmlSchemaCreatePCtxtOnVCtxt(xmlSchemaValidCtxtPtr vctxt)
-{
-    if (vctxt->pctxt == NULL) {
-        if (vctxt->schema != NULL)
-            vctxt->pctxt =
-                xmlSchemaNewParserCtxtUseDict("*", vctxt->schema->dict);
-        else
-            vctxt->pctxt = xmlSchemaNewParserCtxt("*");
-        if (vctxt->pctxt == NULL) {
-            VERROR_INT("xmlSchemaCreatePCtxtOnVCtxt",
-                "failed to create a temp. parser context");
-            return (-1);
-        }
-        /* TODO: Pass user data. */
-        xmlSchemaSetParserErrors(vctxt->pctxt, vctxt->error,
-            vctxt->warning, vctxt->errCtxt);
-        xmlSchemaSetParserStructuredErrors(vctxt->pctxt, vctxt->serror,
-            vctxt->errCtxt);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaGetSchemaBucket:
- * @pctxt: the schema parser context
- * @schemaLocation: the URI of the schema document
- *
- * Returns a schema bucket if it was already parsed.
- *
- * Returns a schema bucket if it was already parsed from
- *         @schemaLocation, NULL otherwise.
- */
-static xmlSchemaBucketPtr
-xmlSchemaGetSchemaBucket(xmlSchemaParserCtxtPtr pctxt,
-                            const xmlChar *schemaLocation)
-{
-    xmlSchemaBucketPtr cur;
-    xmlSchemaItemListPtr list;
-
-    list = pctxt->constructor->buckets;
-    if (list->nbItems == 0)
-        return(NULL);
-    else {
-        int i;
-        for (i = 0; i < list->nbItems; i++) {
-            cur = (xmlSchemaBucketPtr) list->items[i];
-            /* Pointer comparison! */
-            if (cur->schemaLocation == schemaLocation)
-                return(cur);
-        }
-    }
-    return(NULL);
-}
-
-static xmlSchemaBucketPtr
-xmlSchemaGetChameleonSchemaBucket(xmlSchemaParserCtxtPtr pctxt,
-                                     const xmlChar *schemaLocation,
-                                     const xmlChar *targetNamespace)
-{
-    xmlSchemaBucketPtr cur;
-    xmlSchemaItemListPtr list;
-
-    list = pctxt->constructor->buckets;
-    if (list->nbItems == 0)
-        return(NULL);
-    else {
-        int i;
-        for (i = 0; i < list->nbItems; i++) {
-            cur = (xmlSchemaBucketPtr) list->items[i];
-            /* Pointer comparison! */
-            if ((cur->origTargetNamespace == NULL) &&
-                (cur->schemaLocation == schemaLocation) &&
-                (cur->targetNamespace == targetNamespace))
-                return(cur);
-        }
-    }
-    return(NULL);
-}
-
-
-#define IS_BAD_SCHEMA_DOC(b) \
-    (((b)->doc == NULL) && ((b)->schemaLocation != NULL))
-
-static xmlSchemaBucketPtr
-xmlSchemaGetSchemaBucketByTNS(xmlSchemaParserCtxtPtr pctxt,
-                                 const xmlChar *targetNamespace,
-                                 int imported)
-{
-    xmlSchemaBucketPtr cur;
-    xmlSchemaItemListPtr list;
-
-    list = pctxt->constructor->buckets;
-    if (list->nbItems == 0)
-        return(NULL);
-    else {
-        int i;
-        for (i = 0; i < list->nbItems; i++) {
-            cur = (xmlSchemaBucketPtr) list->items[i];
-            if ((! IS_BAD_SCHEMA_DOC(cur)) &&
-                (cur->origTargetNamespace == targetNamespace) &&
-                ((imported && cur->imported) ||
-                 ((!imported) && (!cur->imported))))
-                return(cur);
-        }
-    }
-    return(NULL);
-}
-
-static int
-xmlSchemaParseNewDocWithContext(xmlSchemaParserCtxtPtr pctxt,
-                     xmlSchemaPtr schema,
-                     xmlSchemaBucketPtr bucket)
-{
-    int oldFlags;
-    xmlDocPtr oldDoc;
-    xmlNodePtr node;
-    int ret, oldErrs;
-    xmlSchemaBucketPtr oldbucket = pctxt->constructor->bucket;
-
-    /*
-    * Save old values; reset the *main* schema.
-    * URGENT TODO: This is not good; move the per-document information
-    * to the parser. Get rid of passing the main schema to the
-    * parsing functions.
-    */
-    oldFlags = schema->flags;
-    oldDoc = schema->doc;
-    if (schema->flags != 0)
-        xmlSchemaClearSchemaDefaults(schema);
-    schema->doc = bucket->doc;
-    pctxt->schema = schema;
-    /*
-    * Keep the current target namespace on the parser *not* on the
-    * main schema.
-    */
-    pctxt->targetNamespace = bucket->targetNamespace;
-    WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
-
-    if ((bucket->targetNamespace != NULL) &&
-        xmlStrEqual(bucket->targetNamespace, xmlSchemaNs)) {
-        /*
-        * We are parsing the schema for schemas!
-        */
-        pctxt->isS4S = 1;
-    }
-    /* Mark it as parsed, even if parsing fails. */
-    bucket->parsed++;
-    /* Compile the schema doc. */
-    node = xmlDocGetRootElement(bucket->doc);
-    ret = xmlSchemaParseSchemaElement(pctxt, schema, node);
-    if (ret != 0)
-        goto exit;
-    /* An empty schema; just get out. */
-    if (node->children == NULL)
-        goto exit;
-    oldErrs = pctxt->nberrors;
-    ret = xmlSchemaParseSchemaTopLevel(pctxt, schema, node->children);
-    if (ret != 0)
-        goto exit;
-    /*
-    * TODO: Not nice, but I'm not 100% sure we will get always an error
-    * as a result of the obove functions; so better rely on pctxt->err
-    * as well.
-    */
-    if ((ret == 0) && (oldErrs != pctxt->nberrors)) {
-        ret = pctxt->err;
-        goto exit;
-    }
-
-exit:
-    WXS_CONSTRUCTOR(pctxt)->bucket = oldbucket;
-    /* Restore schema values. */
-    schema->doc = oldDoc;
-    schema->flags = oldFlags;
-    return(ret);
-}
-
-static int
-xmlSchemaParseNewDoc(xmlSchemaParserCtxtPtr pctxt,
-                     xmlSchemaPtr schema,
-                     xmlSchemaBucketPtr bucket)
-{
-    xmlSchemaParserCtxtPtr newpctxt;
-    int res = 0;
-
-    if (bucket == NULL)
-        return(0);
-    if (bucket->parsed) {
-        PERROR_INT("xmlSchemaParseNewDoc",
-            "reparsing a schema doc");
-        return(-1);
-    }
-    if (bucket->doc == NULL) {
-        PERROR_INT("xmlSchemaParseNewDoc",
-            "parsing a schema doc, but there's no doc");
-        return(-1);
-    }
-    if (pctxt->constructor == NULL) {
-        PERROR_INT("xmlSchemaParseNewDoc",
-            "no constructor");
-        return(-1);
-    }
-    /* Create and init the temporary parser context. */
-    newpctxt = xmlSchemaNewParserCtxtUseDict(
-        (const char *) bucket->schemaLocation, pctxt->dict);
-    if (newpctxt == NULL)
-        return(-1);
-    newpctxt->constructor = pctxt->constructor;
-    /*
-    * TODO: Can we avoid that the parser knows about the main schema?
-    * It would be better if he knows about the current schema bucket
-    * only.
-    */
-    newpctxt->schema = schema;
-    xmlSchemaSetParserErrors(newpctxt, pctxt->error, pctxt->warning,
-        pctxt->errCtxt);
-    xmlSchemaSetParserStructuredErrors(newpctxt, pctxt->serror,
-        pctxt->errCtxt);
-    newpctxt->counter = pctxt->counter;
-
-
-    res = xmlSchemaParseNewDocWithContext(newpctxt, schema, bucket);
-
-    /* Channel back errors and cleanup the temporary parser context. */
-    if (res != 0)
-        pctxt->err = res;
-    pctxt->nberrors += newpctxt->nberrors;
-    pctxt->counter = newpctxt->counter;
-    newpctxt->constructor = NULL;
-    /* Free the parser context. */
-    xmlSchemaFreeParserCtxt(newpctxt);
-    return(res);
-}
-
-static void
-xmlSchemaSchemaRelationAddChild(xmlSchemaBucketPtr bucket,
-                                xmlSchemaSchemaRelationPtr rel)
-{
-    xmlSchemaSchemaRelationPtr cur = bucket->relations;
-
-    if (cur == NULL) {
-        bucket->relations = rel;
-        return;
-    }
-    while (cur->next != NULL)
-        cur = cur->next;
-    cur->next = rel;
-}
-
-
-static const xmlChar *
-xmlSchemaBuildAbsoluteURI(xmlDictPtr dict, const xmlChar* location,
-                          xmlNodePtr ctxtNode)
-{
-    /*
-    * Build an absolue location URI.
-    */
-    if (location != NULL) {
-        if (ctxtNode == NULL)
-            return(location);
-        else {
-            xmlChar *base, *URI;
-            const xmlChar *ret = NULL;
-
-            base = xmlNodeGetBase(ctxtNode->doc, ctxtNode);
-            if (base == NULL) {
-                URI = xmlBuildURI(location, ctxtNode->doc->URL);
-            } else {
-                URI = xmlBuildURI(location, base);
-                xmlFree(base);
-            }
-            if (URI != NULL) {
-                ret = xmlDictLookup(dict, URI, -1);
-                xmlFree(URI);
-                return(ret);
-            }
-        }
-    }
-    return(NULL);
-}
-
-
-
-/**
- * xmlSchemaAddSchemaDoc:
- * @pctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parse an included (and to-be-redefined) XML schema document.
- *
- * Returns 0 on success, a positive error code on errors and
- *         -1 in case of an internal or API error.
- */
-
-static int
-xmlSchemaAddSchemaDoc(xmlSchemaParserCtxtPtr pctxt,
-                int type, /* import or include or redefine */
-                const xmlChar *schemaLocation,
-                xmlDocPtr schemaDoc,
-                const char *schemaBuffer,
-                int schemaBufferLen,
-                xmlNodePtr invokingNode,
-                const xmlChar *sourceTargetNamespace,
-                const xmlChar *importNamespace,
-                xmlSchemaBucketPtr *bucket)
-{
-    const xmlChar *targetNamespace = NULL;
-    xmlSchemaSchemaRelationPtr relation = NULL;
-    xmlDocPtr doc = NULL;
-    int res = 0, err = 0, located = 0, preserveDoc = 0;
-    xmlSchemaBucketPtr bkt = NULL;
-
-    if (bucket != NULL)
-        *bucket = NULL;
-
-    switch (type) {
-        case XML_SCHEMA_SCHEMA_IMPORT:
-        case XML_SCHEMA_SCHEMA_MAIN:
-            err = XML_SCHEMAP_SRC_IMPORT;
-            break;
-        case XML_SCHEMA_SCHEMA_INCLUDE:
-            err = XML_SCHEMAP_SRC_INCLUDE;
-            break;
-        case XML_SCHEMA_SCHEMA_REDEFINE:
-            err = XML_SCHEMAP_SRC_REDEFINE;
-            break;
-    }
-
-
-    /* Special handling for the main schema:
-    * skip the location and relation logic and just parse the doc.
-    * We need just a bucket to be returned in this case.
-    */
-    if ((type == XML_SCHEMA_SCHEMA_MAIN) || (! WXS_HAS_BUCKETS(pctxt)))
-        goto doc_load;
-
-    /* Note that we expect the location to be an absulute URI. */
-    if (schemaLocation != NULL) {
-        bkt = xmlSchemaGetSchemaBucket(pctxt, schemaLocation);
-        if ((bkt != NULL) &&
-            (pctxt->constructor->bucket == bkt)) {
-            /* Report self-imports/inclusions/redefinitions. */
-
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
-                invokingNode, NULL,
-                "The schema must not import/include/redefine itself",
-                NULL, NULL);
-            goto exit;
-        }
-    }
-    /*
-    * Create a relation for the graph of schemas.
-    */
-    relation = xmlSchemaSchemaRelationCreate();
-    if (relation == NULL)
-        return(-1);
-    xmlSchemaSchemaRelationAddChild(pctxt->constructor->bucket,
-        relation);
-    relation->type = type;
-
-    /*
-    * Save the namespace import information.
-    */
-    if (WXS_IS_BUCKET_IMPMAIN(type)) {
-        relation->importNamespace = importNamespace;
-        if (schemaLocation == NULL) {
-            /*
-            * No location; this is just an import of the namespace.
-            * Note that we don't assign a bucket to the relation
-            * in this case.
-            */
-            goto exit;
-        }
-        targetNamespace = importNamespace;
-    }
-
-    /* Did we already fetch the doc? */
-    if (bkt != NULL) {
-        if ((WXS_IS_BUCKET_IMPMAIN(type)) && (! bkt->imported)) {
-            /*
-            * We included/redefined and then try to import a schema,
-            * but the new location provided for import was different.
-            */
-            if (schemaLocation == NULL)
-                schemaLocation = BAD_CAST "in_memory_buffer";
-            if (!xmlStrEqual(schemaLocation,
-                bkt->schemaLocation)) {
-                xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
-                    invokingNode, NULL,
-                    "The schema document '%s' cannot be imported, since "
-                    "it was already included or redefined",
-                    schemaLocation, NULL);
-                goto exit;
-            }
-        } else if ((! WXS_IS_BUCKET_IMPMAIN(type)) && (bkt->imported)) {
-            /*
-            * We imported and then try to include/redefine a schema,
-            * but the new location provided for the include/redefine
-            * was different.
-            */
-            if (schemaLocation == NULL)
-                schemaLocation = BAD_CAST "in_memory_buffer";
-            if (!xmlStrEqual(schemaLocation,
-                bkt->schemaLocation)) {
-                xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
-                    invokingNode, NULL,
-                    "The schema document '%s' cannot be included or "
-                    "redefined, since it was already imported",
-                    schemaLocation, NULL);
-                goto exit;
-            }
-        }
-    }
-
-    if (WXS_IS_BUCKET_IMPMAIN(type)) {
-        /*
-        * Given that the schemaLocation [attribute] is only a hint, it is open
-        * to applications to ignore all but the first <import> for a given
-        * namespace, regardless of the `actual value` of schemaLocation, but
-        * such a strategy risks missing useful information when new
-        * schemaLocations are offered.
-        *
-        * We will use the first <import> that comes with a location.
-        * Further <import>s *with* a location, will result in an error.
-        * TODO: Better would be to just report a warning here, but
-        * we'll try it this way until someone complains.
-        *
-        * Schema Document Location Strategy:
-        * 3 Based on the namespace name, identify an existing schema document,
-        * either as a resource which is an XML document or a <schema> element
-        * information item, in some local schema repository;
-        * 5 Attempt to resolve the namespace name to locate such a resource.
-        *
-        * NOTE: (3) and (5) are not supported.
-        */
-        if (bkt != NULL) {
-            relation->bucket = bkt;
-            goto exit;
-        }
-        bkt = xmlSchemaGetSchemaBucketByTNS(pctxt,
-            importNamespace, 1);
-
-        if (bkt != NULL) {
-            relation->bucket = bkt;
-            if (bkt->schemaLocation == NULL) {
-                /* First given location of the schema; load the doc. */
-                bkt->schemaLocation = schemaLocation;
-            } else {
-                if (!xmlStrEqual(schemaLocation,
-                    bkt->schemaLocation)) {
-                    /*
-                    * Additional location given; just skip it.
-                    * URGENT TODO: We should report a warning here.
-                    * res = XML_SCHEMAP_SRC_IMPORT;
-                    */
-                    if (schemaLocation == NULL)
-                        schemaLocation = BAD_CAST "in_memory_buffer";
-
-                    xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-                        XML_SCHEMAP_WARN_SKIP_SCHEMA,
-                        invokingNode, NULL,
-                        "Skipping import of schema located at '%s' for the "
-                        "namespace '%s', since this namespace was already "
-                        "imported with the schema located at '%s'",
-                        schemaLocation, importNamespace, bkt->schemaLocation);
-                }
-                goto exit;
-            }
-        }
-        /*
-        * No bucket + first location: load the doc and create a
-        * bucket.
-        */
-    } else {
-        /* <include> and <redefine> */
-        if (bkt != NULL) {
-
-            if ((bkt->origTargetNamespace == NULL) &&
-                (bkt->targetNamespace != sourceTargetNamespace)) {
-                xmlSchemaBucketPtr chamel;
-
-                /*
-                * Chameleon include/redefine: skip loading only if it was
-                * aleady build for the targetNamespace of the including
-                * schema.
-                */
-                /*
-                * URGENT TODO: If the schema is a chameleon-include then copy
-                * the components into the including schema and modify the
-                * targetNamespace of those components, do nothing otherwise.
-                * NOTE: This is currently worked-around by compiling the
-                * chameleon for every destinct including targetNamespace; thus
-                * not performant at the moment.
-                * TODO: Check when the namespace in wildcards for chameleons
-                * needs to be converted: before we built wildcard intersections
-                * or after.
-                *   Answer: after!
-                */
-                chamel = xmlSchemaGetChameleonSchemaBucket(pctxt,
-                    schemaLocation, sourceTargetNamespace);
-                if (chamel != NULL) {
-                    /* A fitting chameleon was already parsed; NOP. */
-                    relation->bucket = chamel;
-                    goto exit;
-                }
-                /*
-                * We need to parse the chameleon again for a different
-                * targetNamespace.
-                * CHAMELEON TODO: Optimize this by only parsing the
-                * chameleon once, and then copying the components to
-                * the new targetNamespace.
-                */
-                bkt = NULL;
-            } else {
-                relation->bucket = bkt;
-                goto exit;
-            }
-        }
-    }
-    if ((bkt != NULL) && (bkt->doc != NULL)) {
-        PERROR_INT("xmlSchemaAddSchemaDoc",
-            "trying to load a schema doc, but a doc is already "
-            "assigned to the schema bucket");
-        goto exit_failure;
-    }
-
-doc_load:
-    /*
-    * Load the document.
-    */
-    if (schemaDoc != NULL) {
-        doc = schemaDoc;
-        /* Don' free this one, since it was provided by the caller. */
-        preserveDoc = 1;
-        /* TODO: Does the context or the doc hold the location? */
-        if (schemaDoc->URL != NULL)
-            schemaLocation = xmlDictLookup(pctxt->dict,
-                schemaDoc->URL, -1);
-        else
-            schemaLocation = BAD_CAST "in_memory_buffer";
-    } else if ((schemaLocation != NULL) || (schemaBuffer != NULL)) {
-        xmlParserCtxtPtr parserCtxt;
-
-        parserCtxt = xmlNewParserCtxt();
-        if (parserCtxt == NULL) {
-            xmlSchemaPErrMemory(NULL, "xmlSchemaGetDoc, "
-                "allocating a parser context", NULL);
-            goto exit_failure;
-        }
-        if ((pctxt->dict != NULL) && (parserCtxt->dict != NULL)) {
-            /*
-            * TODO: Do we have to burden the schema parser dict with all
-            * the content of the schema doc?
-            */
-            xmlDictFree(parserCtxt->dict);
-            parserCtxt->dict = pctxt->dict;
-            xmlDictReference(parserCtxt->dict);
-        }
-        if (schemaLocation != NULL) {
-            /* Parse from file. */
-            doc = xmlCtxtReadFile(parserCtxt, (const char *) schemaLocation,
-                NULL, SCHEMAS_PARSE_OPTIONS);
-        } else if (schemaBuffer != NULL) {
-            /* Parse from memory buffer. */
-            doc = xmlCtxtReadMemory(parserCtxt, schemaBuffer, schemaBufferLen,
-                NULL, NULL, SCHEMAS_PARSE_OPTIONS);
-            schemaLocation = BAD_CAST "in_memory_buffer";
-            if (doc != NULL)
-                doc->URL = xmlStrdup(schemaLocation);
-        }
-        /*
-        * For <import>:
-        * 2.1 The referent is (a fragment of) a resource which is an
-        * XML document (see clause 1.1), which in turn corresponds to
-        * a <schema> element information item in a well-formed information
-        * set, which in turn corresponds to a valid schema.
-        * TODO: (2.1) fragments of XML documents are not supported.
-        *
-        * 2.2 The referent is a <schema> element information item in
-        * a well-formed information set, which in turn corresponds
-        * to a valid schema.
-        * TODO: (2.2) is not supported.
-        */
-        if (doc == NULL) {
-            xmlErrorPtr lerr;
-            lerr = xmlGetLastError();
-            /*
-            * Check if this a parser error, or if the document could
-            * just not be located.
-            * TODO: Try to find specific error codes to react only on
-            * localisation failures.
-            */
-            if ((lerr == NULL) || (lerr->domain != XML_FROM_IO)) {
-                /*
-                * We assume a parser error here.
-                */
-                located = 1;
-                /* TODO: Error code ?? */
-                res = XML_SCHEMAP_SRC_IMPORT_2_1;
-                xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
-                    invokingNode, NULL,
-                    "Failed to parse the XML resource '%s'",
-                    schemaLocation, NULL);
-            }
-        }
-        xmlFreeParserCtxt(parserCtxt);
-        if ((doc == NULL) && located)
-            goto exit_error;
-    } else {
-        xmlSchemaPErr(pctxt, NULL,
-            XML_SCHEMAP_NOTHING_TO_PARSE,
-            "No information for parsing was provided with the "
-            "given schema parser context.\n",
-            NULL, NULL);
-        goto exit_failure;
-    }
-    /*
-    * Preprocess the document.
-    */
-    if (doc != NULL) {
-        xmlNodePtr docElem = NULL;
-
-        located = 1;
-        docElem = xmlDocGetRootElement(doc);
-        if (docElem == NULL) {
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOROOT,
-                invokingNode, NULL,
-                "The document '%s' has no document element",
-                schemaLocation, NULL);
-            goto exit_error;
-        }
-        /*
-        * Remove all the blank text nodes.
-        */
-        xmlSchemaCleanupDoc(pctxt, docElem);
-        /*
-        * Check the schema's top level element.
-        */
-        if (!IS_SCHEMA(docElem, "schema")) {
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOT_SCHEMA,
-                invokingNode, NULL,
-                "The XML document '%s' is not a schema document",
-                schemaLocation, NULL);
-            goto exit_error;
-        }
-        /*
-        * Note that we don't apply a type check for the
-        * targetNamespace value here.
-        */
-        targetNamespace = xmlSchemaGetProp(pctxt, docElem,
-            "targetNamespace");
-    }
-
-/* after_doc_loading: */
-    if ((bkt == NULL) && located) {
-        /* Only create a bucket if the schema was located. */
-        bkt = xmlSchemaBucketCreate(pctxt, type,
-            targetNamespace);
-        if (bkt == NULL)
-            goto exit_failure;
-    }
-    if (bkt != NULL) {
-        bkt->schemaLocation = schemaLocation;
-        bkt->located = located;
-        if (doc != NULL) {
-            bkt->doc = doc;
-            bkt->targetNamespace = targetNamespace;
-            bkt->origTargetNamespace = targetNamespace;
-            if (preserveDoc)
-                bkt->preserveDoc = 1;
-        }
-        if (WXS_IS_BUCKET_IMPMAIN(type))
-            bkt->imported++;
-            /*
-            * Add it to the graph of schemas.
-            */
-        if (relation != NULL)
-            relation->bucket = bkt;
-    }
-
-exit:
-    /*
-    * Return the bucket explicitely; this is needed for the
-    * main schema.
-    */
-    if (bucket != NULL)
-        *bucket = bkt;
-    return (0);
-
-exit_error:
-    if ((doc != NULL) && (! preserveDoc)) {
-        xmlFreeDoc(doc);
-        if (bkt != NULL)
-            bkt->doc = NULL;
-    }
-    return(pctxt->err);
-
-exit_failure:
-    if ((doc != NULL) && (! preserveDoc)) {
-        xmlFreeDoc(doc);
-        if (bkt != NULL)
-            bkt->doc = NULL;
-    }
-    return (-1);
-}
-
-/**
- * xmlSchemaParseImport:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Import definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns 0 in case of success, a positive error code if
- * not valid and -1 in case of an internal error.
- */
-static int
-xmlSchemaParseImport(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
-                     xmlNodePtr node)
-{
-    xmlNodePtr child;
-    const xmlChar *namespaceName = NULL, *schemaLocation = NULL;
-    const xmlChar *thisTargetNamespace;
-    xmlAttrPtr attr;
-    int ret = 0;
-    xmlSchemaBucketPtr bucket = NULL;
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (-1);
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
-                xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(pctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /*
-    * Extract and validate attributes.
-    */
-    if (xmlSchemaPValAttr(pctxt, NULL, node,
-        "namespace", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-        &namespaceName) != 0) {
-        xmlSchemaPSimpleTypeErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            NULL, node,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-            NULL, namespaceName, NULL, NULL, NULL);
-        return (pctxt->err);
-    }
-
-    if (xmlSchemaPValAttr(pctxt, NULL, node,
-        "schemaLocation", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-        &schemaLocation) != 0) {
-        xmlSchemaPSimpleTypeErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-            NULL, node,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-            NULL, schemaLocation, NULL, NULL, NULL);
-        return (pctxt->err);
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-         * the annotation here is simply discarded ...
-         * TODO: really?
-         */
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(pctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?)");
-    }
-    /*
-    * Apply additional constraints.
-    *
-    * Note that it is important to use the original @targetNamespace
-    * (or none at all), to rule out imports of schemas _with_ a
-    * @targetNamespace if the importing schema is a chameleon schema
-    * (with no @targetNamespace).
-    */
-    thisTargetNamespace = WXS_BUCKET(pctxt)->origTargetNamespace;
-    if (namespaceName != NULL) {
-        /*
-        * 1.1 If the namespace [attribute] is present, then its `actual value`
-        * must not match the `actual value` of the enclosing <schema>'s
-        * targetNamespace [attribute].
-        */
-        if (xmlStrEqual(thisTargetNamespace, namespaceName)) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_SRC_IMPORT_1_1,
-                NULL, node,
-                "The value of the attribute 'namespace' must not match "
-                "the target namespace '%s' of the importing schema",
-                thisTargetNamespace);
-            return (pctxt->err);
-        }
-    } else {
-        /*
-        * 1.2 If the namespace [attribute] is not present, then the enclosing
-        * <schema> must have a targetNamespace [attribute].
-        */
-        if (thisTargetNamespace == NULL) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_SRC_IMPORT_1_2,
-                NULL, node,
-                "The attribute 'namespace' must be existent if "
-                "the importing schema has no target namespace",
-                NULL);
-            return (pctxt->err);
-        }
-    }
-    /*
-    * Locate and acquire the schema document.
-    */
-    if (schemaLocation != NULL)
-        schemaLocation = xmlSchemaBuildAbsoluteURI(pctxt->dict,
-            schemaLocation, node);
-    ret = xmlSchemaAddSchemaDoc(pctxt, XML_SCHEMA_SCHEMA_IMPORT,
-        schemaLocation, NULL, NULL, 0, node, thisTargetNamespace,
-        namespaceName, &bucket);
-
-    if (ret != 0)
-        return(ret);
-
-    /*
-    * For <import>: "It is *not* an error for the application
-    * schema reference strategy to fail."
-    * So just don't parse if no schema document was found.
-    * Note that we will get no bucket if the schema could not be
-    * located or if there was no schemaLocation.
-    */
-    if ((bucket == NULL) && (schemaLocation != NULL)) {
-        xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-            XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
-            node, NULL,
-            "Failed to locate a schema at location '%s'. "
-            "Skipping the import", schemaLocation, NULL, NULL);
-    }
-
-    if ((bucket != NULL) && CAN_PARSE_SCHEMA(bucket)) {
-        ret = xmlSchemaParseNewDoc(pctxt, schema, bucket);
-    }
-
-    return (ret);
-}
-
-static int
-xmlSchemaParseIncludeOrRedefineAttrs(xmlSchemaParserCtxtPtr pctxt,
-                                     xmlSchemaPtr schema,
-                                     xmlNodePtr node,
-                                     xmlChar **schemaLocation,
-                                     int type)
-{
-    xmlAttrPtr attr;
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL) ||
-        (schemaLocation == NULL))
-        return (-1);
-
-    *schemaLocation = NULL;
-    /*
-    * Check for illegal attributes.
-    * Applies for both <include> and <redefine>.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
-                xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(pctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
-    /*
-    * Preliminary step, extract the URI-Reference and make an URI
-    * from the base.
-    */
-    /*
-    * Attribute "schemaLocation" is mandatory.
-    */
-    attr = xmlSchemaGetPropNode(node, "schemaLocation");
-    if (attr != NULL) {
-        xmlChar *base = NULL;
-        xmlChar *uri = NULL;
-
-        if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-            (const xmlChar **) schemaLocation) != 0)
-            goto exit_error;
-        base = xmlNodeGetBase(node->doc, node);
-        if (base == NULL) {
-            uri = xmlBuildURI(*schemaLocation, node->doc->URL);
-        } else {
-            uri = xmlBuildURI(*schemaLocation, base);
-            xmlFree(base);
-        }
-        if (uri == NULL) {
-            PERROR_INT("xmlSchemaParseIncludeOrRedefine",
-                "could not build an URI from the schemaLocation")
-            goto exit_failure;
-        }
-        (*schemaLocation) = (xmlChar *) xmlDictLookup(pctxt->dict, uri, -1);
-        xmlFree(uri);
-    } else {
-        xmlSchemaPMissingAttrErr(pctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "schemaLocation", NULL);
-        goto exit_error;
-    }
-    /*
-    * Report self-inclusion and self-redefinition.
-    */
-    if (xmlStrEqual(*schemaLocation, pctxt->URL)) {
-        if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_SRC_REDEFINE,
-                NULL, node,
-                "The schema document '%s' cannot redefine itself.",
-                *schemaLocation);
-        } else {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_SRC_INCLUDE,
-                NULL, node,
-                "The schema document '%s' cannot include itself.",
-                *schemaLocation);
-        }
-        goto exit_error;
-    }
-
-    return(0);
-exit_error:
-    return(pctxt->err);
-exit_failure:
-    return(-1);
-}
-
-static int
-xmlSchemaParseIncludeOrRedefine(xmlSchemaParserCtxtPtr pctxt,
-                                xmlSchemaPtr schema,
-                                xmlNodePtr node,
-                                int type)
-{
-    xmlNodePtr child = NULL;
-    const xmlChar *schemaLocation = NULL;
-    int res = 0; /* hasRedefinitions = 0 */
-    int isChameleon = 0, wasChameleon = 0;
-    xmlSchemaBucketPtr bucket = NULL;
-
-    if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (-1);
-
-    /*
-    * Parse attributes. Note that the returned schemaLocation will
-    * be already converted to an absolute URI.
-    */
-    res = xmlSchemaParseIncludeOrRedefineAttrs(pctxt, schema,
-        node, (xmlChar **) (&schemaLocation), type);
-    if (res != 0)
-        return(res);
-    /*
-    * Load and add the schema document.
-    */
-    res = xmlSchemaAddSchemaDoc(pctxt, type, schemaLocation, NULL,
-        NULL, 0, node, pctxt->targetNamespace, NULL, &bucket);
-    if (res != 0)
-        return(res);
-    /*
-    * If we get no schema bucket back, then this means that the schema
-    * document could not be located or was broken XML or was not
-    * a schema document.
-    */
-    if ((bucket == NULL) || (bucket->doc == NULL)) {
-        if (type == XML_SCHEMA_SCHEMA_INCLUDE) {
-            /*
-            * WARNING for <include>:
-            * We will raise an error if the schema cannot be located
-            * for inclusions, since the that was the feedback from the
-            * schema people. I.e. the following spec piece will *not* be
-            * satisfied:
-            * SPEC src-include: "It is not an error for the `actual value` of the
-            * schemaLocation [attribute] to fail to resolve it all, in which
-            * case no corresponding inclusion is performed.
-            * So do we need a warning report here?"
-            */
-            res = XML_SCHEMAP_SRC_INCLUDE;
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
-                node, NULL,
-                "Failed to load the document '%s' for inclusion",
-                schemaLocation, NULL);
-        } else {
-            /*
-            * NOTE: This was changed to raise an error even if no redefinitions
-            * are specified.
-            *
-            * SPEC src-redefine (1)
-            * "If there are any element information items among the [children]
-            * other than <annotation> then the `actual value` of the
-            * schemaLocation [attribute] must successfully resolve."
-            * TODO: Ask the WG if a the location has always to resolve
-            * here as well!
-            */
-            res = XML_SCHEMAP_SRC_REDEFINE;
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
-                node, NULL,
-                "Failed to load the document '%s' for redefinition",
-                schemaLocation, NULL);
-        }
-    } else {
-        /*
-        * Check targetNamespace sanity before parsing the new schema.
-        * TODO: Note that we won't check further content if the
-        * targetNamespace was bad.
-        */
-        if (bucket->origTargetNamespace != NULL) {
-            /*
-            * SPEC src-include (2.1)
-            * "SII has a targetNamespace [attribute], and its `actual
-            * value` is identical to the `actual value` of the targetNamespace
-            * [attribute] of SII' (which must have such an [attribute])."
-            */
-            if (pctxt->targetNamespace == NULL) {
-                xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_SRC_INCLUDE,
-                    node, NULL,
-                    "The target namespace of the included/redefined schema "
-                    "'%s' has to be absent, since the including/redefining "
-                    "schema has no target namespace",
-                    schemaLocation, NULL);
-                goto exit_error;
-            } else if (!xmlStrEqual(bucket->origTargetNamespace,
-                pctxt->targetNamespace)) {
-                /* TODO: Change error function. */
-                xmlSchemaPCustomErrExt(pctxt,
-                    XML_SCHEMAP_SRC_INCLUDE,
-                    NULL, node,
-                    "The target namespace '%s' of the included/redefined "
-                    "schema '%s' differs from '%s' of the "
-                    "including/redefining schema",
-                    bucket->origTargetNamespace, schemaLocation,
-                    pctxt->targetNamespace);
-                goto exit_error;
-            }
-        } else if (pctxt->targetNamespace != NULL) {
-            /*
-            * Chameleons: the original target namespace will
-            * differ from the resulting namespace.
-            */
-            isChameleon = 1;
-            if (bucket->parsed &&
-                bucket->origTargetNamespace != NULL) {
-                xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_SRC_INCLUDE,
-                    node, NULL,
-                    "The target namespace of the included/redefined schema "
-                    "'%s' has to be absent or the same as the "
-                    "including/redefining schema's target namespace",
-                    schemaLocation, NULL);
-                goto exit_error;
-            }
-            bucket->targetNamespace = pctxt->targetNamespace;
-        }
-    }
-    /*
-    * Parse the schema.
-    */
-    if (bucket && (!bucket->parsed) && (bucket->doc != NULL)) {
-        if (isChameleon) {
-            /* TODO: Get rid of this flag on the schema itself. */
-            if ((schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) == 0) {
-                schema->flags |= XML_SCHEMAS_INCLUDING_CONVERT_NS;
-            } else
-                wasChameleon = 1;
-        }
-        xmlSchemaParseNewDoc(pctxt, schema, bucket);
-        /* Restore chameleon flag. */
-        if (isChameleon && (!wasChameleon))
-            schema->flags ^= XML_SCHEMAS_INCLUDING_CONVERT_NS;
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
-        /*
-        * Parse (simpleType | complexType | group | attributeGroup))*
-        */
-        pctxt->redefined = bucket;
-        /*
-        * How to proceed if the redefined schema was not located?
-        */
-        pctxt->isRedefine = 1;
-        while (IS_SCHEMA(child, "annotation") ||
-            IS_SCHEMA(child, "simpleType") ||
-            IS_SCHEMA(child, "complexType") ||
-            IS_SCHEMA(child, "group") ||
-            IS_SCHEMA(child, "attributeGroup")) {
-            if (IS_SCHEMA(child, "annotation")) {
-                /*
-                * TODO: discard or not?
-                */
-            } else if (IS_SCHEMA(child, "simpleType")) {
-                xmlSchemaParseSimpleType(pctxt, schema, child, 1);
-            } else if (IS_SCHEMA(child, "complexType")) {
-                xmlSchemaParseComplexType(pctxt, schema, child, 1);
-                /* hasRedefinitions = 1; */
-            } else if (IS_SCHEMA(child, "group")) {
-                /* hasRedefinitions = 1; */
-                xmlSchemaParseModelGroupDefinition(pctxt,
-                    schema, child);
-            } else if (IS_SCHEMA(child, "attributeGroup")) {
-                /* hasRedefinitions = 1; */
-                xmlSchemaParseAttributeGroupDefinition(pctxt, schema,
-                    child);
-            }
-            child = child->next;
-        }
-        pctxt->redefined = NULL;
-        pctxt->isRedefine = 0;
-    } else {
-        if (IS_SCHEMA(child, "annotation")) {
-            /*
-            * TODO: discard or not?
-            */
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        res = XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED;
-        if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
-            xmlSchemaPContentErr(pctxt, res,
-                NULL, node, child, NULL,
-                "(annotation | (simpleType | complexType | group | attributeGroup))*");
-        } else {
-             xmlSchemaPContentErr(pctxt, res,
-                NULL, node, child, NULL,
-                "(annotation?)");
-        }
-    }
-    return(res);
-
-exit_error:
-    return(pctxt->err);
-}
-
-static int
-xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
-                       xmlNodePtr node)
-{
-    int res;
-#ifndef ENABLE_REDEFINE
-    TODO
-    return(0);
-#endif
-    res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
-        XML_SCHEMA_SCHEMA_REDEFINE);
-    if (res != 0)
-        return(res);
-    return(0);
-}
-
-static int
-xmlSchemaParseInclude(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
-                       xmlNodePtr node)
-{
-    int res;
-
-    res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
-        XML_SCHEMA_SCHEMA_INCLUDE);
-    if (res != 0)
-        return(res);
-    return(0);
-}
-
-/**
- * xmlSchemaParseModelGroup:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- * @type: the "compositor" type
- * @particleNeeded: if a a model group with a particle
- *
- * parse a XML schema Sequence definition.
- * Applies parts of:
- *   Schema Representation Constraint:
- *     Redefinition Constraints and Semantics (src-redefine)
- *     (6.1), (6.1.1), (6.1.2)
- *
- *   Schema Component Constraint:
- *     All Group Limited (cos-all-limited) (2)
- *     TODO: Actually this should go to component-level checks,
- *     but is done here due to performance. Move it to an other layer
- *     is schema construction via an API is implemented.
- *
- * *WARNING* this interface is highly subject to change
- *
- * Returns -1 in case of error, 0 if the declaration is improper and
- *         1 in case of success.
- */
-static xmlSchemaTreeItemPtr
-xmlSchemaParseModelGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                         xmlNodePtr node, xmlSchemaTypeType type,
-                         int withParticle)
-{
-    xmlSchemaModelGroupPtr item;
-    xmlSchemaParticlePtr particle = NULL;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-    int min = 1, max = 1, isElemRef, hasRefs = 0;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /*
-    * Create a model group with the given compositor.
-    */
-    item = xmlSchemaAddModelGroup(ctxt, schema, type, node);
-    if (item == NULL)
-        return (NULL);
-
-    if (withParticle) {
-        if (type == XML_SCHEMA_TYPE_ALL) {
-            min = xmlGetMinOccurs(ctxt, node, 0, 1, 1, "(0 | 1)");
-            max = xmlGetMaxOccurs(ctxt, node, 1, 1, 1, "1");
-        } else {
-            /* choice + sequence */
-            min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
-            max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
-                "(xs:nonNegativeInteger | unbounded)");
-        }
-        xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
-        /*
-        * Create a particle
-        */
-        particle = xmlSchemaAddParticle(ctxt, node, min, max);
-        if (particle == NULL)
-            return (NULL);
-        particle->children = (xmlSchemaTreeItemPtr) item;
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
-                    (!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-    } else {
-        /*
-        * Check for illegal attributes.
-        */
-        attr = node->properties;
-        while (attr != NULL) {
-            if (attr->ns == NULL) {
-                if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
-                    xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-            } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-            attr = attr->next;
-        }
-    }
-
-    /*
-    * Extract and validate attributes.
-    */
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    if (type == XML_SCHEMA_TYPE_ALL) {
-        xmlSchemaParticlePtr part, last = NULL;
-
-        while (IS_SCHEMA(child, "element")) {
-            part = (xmlSchemaParticlePtr) xmlSchemaParseElement(ctxt,
-                schema, child, &isElemRef, 0);
-            /*
-            * SPEC cos-all-limited (2)
-            * "The {max occurs} of all the particles in the {particles}
-            * of the ('all') group must be 0 or 1.
-            */
-            if (part != NULL) {
-                if (isElemRef)
-                    hasRefs++;
-                if (part->minOccurs > 1) {
-                    xmlSchemaPCustomErr(ctxt,
-                        XML_SCHEMAP_COS_ALL_LIMITED,
-                        NULL, child,
-                        "Invalid value for minOccurs (must be 0 or 1)",
-                        NULL);
-                    /* Reset to 1. */
-                    part->minOccurs = 1;
-                }
-                if (part->maxOccurs > 1) {
-                    xmlSchemaPCustomErr(ctxt,
-                        XML_SCHEMAP_COS_ALL_LIMITED,
-                        NULL, child,
-                        "Invalid value for maxOccurs (must be 0 or 1)",
-                        NULL);
-                    /* Reset to 1. */
-                    part->maxOccurs = 1;
-                }
-                if (last == NULL)
-                    item->children = (xmlSchemaTreeItemPtr) part;
-                else
-                    last->next = (xmlSchemaTreeItemPtr) part;
-                last = part;
-            }
-            child = child->next;
-        }
-        if (child != NULL) {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, (annotation?, element*)");
-        }
-    } else {
-        /* choice + sequence */
-        xmlSchemaTreeItemPtr part = NULL, last = NULL;
-
-        while ((IS_SCHEMA(child, "element")) ||
-            (IS_SCHEMA(child, "group")) ||
-            (IS_SCHEMA(child, "any")) ||
-            (IS_SCHEMA(child, "choice")) ||
-            (IS_SCHEMA(child, "sequence"))) {
-
-            if (IS_SCHEMA(child, "element")) {
-                part = (xmlSchemaTreeItemPtr)
-                    xmlSchemaParseElement(ctxt, schema, child, &isElemRef, 0);
-                if (part && isElemRef)
-                    hasRefs++;
-            } else if (IS_SCHEMA(child, "group")) {
-                part =
-                    xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
-                if (part != NULL)
-                    hasRefs++;
-                /*
-                * Handle redefinitions.
-                */
-                if (ctxt->isRedefine && ctxt->redef &&
-                    (ctxt->redef->item->type == XML_SCHEMA_TYPE_GROUP) &&
-                    part && part->children)
-                {
-                    if ((xmlSchemaGetQNameRefName(part->children) ==
-                            ctxt->redef->refName) &&
-                        (xmlSchemaGetQNameRefTargetNs(part->children) ==
-                            ctxt->redef->refTargetNs))
-                    {
-                        /*
-                        * SPEC src-redefine:
-                        * (6.1) "If it has a <group> among its contents at
-                        * some level the `actual value` of whose ref
-                        * [attribute] is the same as the `actual value` of
-                        * its own name attribute plus target namespace, then
-                        * all of the following must be true:"
-                        * (6.1.1) "It must have exactly one such group."
-                        */
-                        if (ctxt->redefCounter != 0) {
-                            xmlChar *str = NULL;
-
-                            xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                                XML_SCHEMAP_SRC_REDEFINE, child, NULL,
-                                "The redefining model group definition "
-                                "'%s' must not contain more than one "
-                                "reference to the redefined definition",
-                                xmlSchemaFormatQName(&str,
-                                    ctxt->redef->refTargetNs,
-                                    ctxt->redef->refName),
-                                NULL);
-                            FREE_AND_NULL(str)
-                            part = NULL;
-                        } else if (((WXS_PARTICLE(part))->minOccurs != 1) ||
-                            ((WXS_PARTICLE(part))->maxOccurs != 1))
-                        {
-                            xmlChar *str = NULL;
-                            /*
-                            * SPEC src-redefine:
-                            * (6.1.2) "The `actual value` of both that
-                            * group's minOccurs and maxOccurs [attribute]
-                            * must be 1 (or `absent`).
-                            */
-                            xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                                XML_SCHEMAP_SRC_REDEFINE, child, NULL,
-                                "The redefining model group definition "
-                                "'%s' must not contain a reference to the "
-                                "redefined definition with a "
-                                "maxOccurs/minOccurs other than 1",
-                                xmlSchemaFormatQName(&str,
-                                    ctxt->redef->refTargetNs,
-                                    ctxt->redef->refName),
-                                NULL);
-                            FREE_AND_NULL(str)
-                            part = NULL;
-                        }
-                        ctxt->redef->reference = WXS_BASIC_CAST part;
-                        ctxt->redefCounter++;
-                    }
-                }
-            } else if (IS_SCHEMA(child, "any")) {
-                part = (xmlSchemaTreeItemPtr)
-                    xmlSchemaParseAny(ctxt, schema, child);
-            } else if (IS_SCHEMA(child, "choice")) {
-                part = xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_CHOICE, 1);
-            } else if (IS_SCHEMA(child, "sequence")) {
-                part = xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_SEQUENCE, 1);
-            }
-            if (part != NULL) {
-                if (last == NULL)
-                    item->children = part;
-                else
-                    last->next = part;
-                last = part;
-            }
-            child = child->next;
-        }
-        if (child != NULL) {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, (element | group | choice | sequence | any)*)");
-        }
-    }
-    if ((max == 0) && (min == 0))
-        return (NULL);
-    if (hasRefs) {
-        /*
-        * We need to resolve references.
-        */
-        WXS_ADD_PENDING(ctxt, item);
-    }
-    if (withParticle)
-        return ((xmlSchemaTreeItemPtr) particle);
-    else
-        return ((xmlSchemaTreeItemPtr) item);
-}
-
-/**
- * xmlSchemaParseRestriction:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Restriction definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns the type definition or NULL in case of error
- */
-static xmlSchemaTypePtr
-xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                          xmlNodePtr node, xmlSchemaTypeType parentType)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    /*
-    * Extract and validate attributes.
-    */
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-    /*
-    * Attribute
-    */
-    /*
-    * Extract the base type. The "base" attribute is mandatory if inside
-    * a complex type or if redefining.
-    *
-    * SPEC (1.2) "...otherwise (<restriction> has no <simpleType> "
-    * among its [children]), the simple type definition which is
-    * the {content type} of the type definition `resolved` to by
-    * the `actual value` of the base [attribute]"
-    */
-    if (xmlSchemaPValAttrQName(ctxt, schema, NULL, node, "base",
-        &(type->baseNs), &(type->base)) == 0)
-    {
-        if ((type->base == NULL) && (type->type == XML_SCHEMA_TYPE_COMPLEX)) {
-            xmlSchemaPMissingAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_MISSING,
-                NULL, node, "base", NULL);
-        } else if ((ctxt->isRedefine) &&
-            (type->flags & XML_SCHEMAS_TYPE_GLOBAL))
-        {
-            if (type->base == NULL) {
-                xmlSchemaPMissingAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_MISSING,
-                    NULL, node, "base", NULL);
-            } else if ((! xmlStrEqual(type->base, type->name)) ||
-                (! xmlStrEqual(type->baseNs, type->targetNamespace)))
-            {
-                xmlChar *str1 = NULL, *str2 = NULL;
-                /*
-                * REDEFINE: SPEC src-redefine (5)
-                * "Within the [children], each <simpleType> must have a
-                * <restriction> among its [children] ... the `actual value` of
-                * whose base [attribute] must be the same as the `actual value`
-                * of its own name attribute plus target namespace;"
-                */
-                xmlSchemaPCustomErrExt(ctxt, XML_SCHEMAP_SRC_REDEFINE,
-                    NULL, node, "This is a redefinition, but the QName "
-                    "value '%s' of the 'base' attribute does not match the "
-                    "type's designation '%s'",
-                    xmlSchemaFormatQName(&str1, type->baseNs, type->base),
-                    xmlSchemaFormatQName(&str2, type->targetNamespace,
-                        type->name), NULL);
-                FREE_AND_NULL(str1);
-                FREE_AND_NULL(str2);
-                /* Avoid confusion and erase the values. */
-                type->base = NULL;
-                type->baseNs = NULL;
-            }
-        }
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the simple type ancestor.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (parentType == XML_SCHEMA_TYPE_SIMPLE) {
-        /*
-        * Corresponds to <simpleType><restriction><simpleType>.
-        */
-        if (IS_SCHEMA(child, "simpleType")) {
-            if (type->base != NULL) {
-                /*
-                * src-restriction-base-or-simpleType
-                * Either the base [attribute] or the simpleType [child] of the
-                * <restriction> element must be present, but not both.
-                */
-                xmlSchemaPContentErr(ctxt,
-                    XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
-                    NULL, node, child,
-                    "The attribute 'base' and the <simpleType> child are "
-                    "mutually exclusive", NULL);
-            } else {
-                type->baseType = (xmlSchemaTypePtr)
-                    xmlSchemaParseSimpleType(ctxt, schema, child, 0);
-            }
-            child = child->next;
-        } else if (type->base == NULL) {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
-                NULL, node, child,
-                "Either the attribute 'base' or a <simpleType> child "
-                "must be present", NULL);
-        }
-    } else if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
-        /*
-        * Corresponds to <complexType><complexContent><restriction>...
-        * followed by:
-        *
-        * Model groups <all>, <choice> and <sequence>.
-        */
-        if (IS_SCHEMA(child, "all")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_ALL, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "choice")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt,
-                    schema, child, XML_SCHEMA_TYPE_CHOICE, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "sequence")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_SEQUENCE, 1);
-            child = child->next;
-        /*
-        * Model group reference <group>.
-        */
-        } else if (IS_SCHEMA(child, "group")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
-            /*
-            * Note that the reference will be resolved in
-            * xmlSchemaResolveTypeReferences();
-            */
-            child = child->next;
-        }
-    } else if (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
-        /*
-        * Corresponds to <complexType><simpleContent><restriction>...
-        *
-        * "1.1 the simple type definition corresponding to the <simpleType>
-        * among the [children] of <restriction> if there is one;"
-        */
-        if (IS_SCHEMA(child, "simpleType")) {
-            /*
-            * We will store the to-be-restricted simple type in
-            * type->contentTypeDef *temporarily*.
-            */
-            type->contentTypeDef = (xmlSchemaTypePtr)
-                xmlSchemaParseSimpleType(ctxt, schema, child, 0);
-            if ( type->contentTypeDef == NULL)
-                return (NULL);
-            child = child->next;
-        }
-    }
-
-    if ((parentType == XML_SCHEMA_TYPE_SIMPLE) ||
-        (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT)) {
-        xmlSchemaFacetPtr facet, lastfacet = NULL;
-        /*
-        * Corresponds to <complexType><simpleContent><restriction>...
-        * <simpleType><restriction>...
-        */
-
-        /*
-        * Add the facets to the simple type ancestor.
-        */
-        /*
-        * TODO: Datatypes: 4.1.3 Constraints on XML Representation of
-        * Simple Type Definition Schema Representation Constraint:
-        * *Single Facet Value*
-        */
-        while ((IS_SCHEMA(child, "minInclusive")) ||
-            (IS_SCHEMA(child, "minExclusive")) ||
-            (IS_SCHEMA(child, "maxInclusive")) ||
-            (IS_SCHEMA(child, "maxExclusive")) ||
-            (IS_SCHEMA(child, "totalDigits")) ||
-            (IS_SCHEMA(child, "fractionDigits")) ||
-            (IS_SCHEMA(child, "pattern")) ||
-            (IS_SCHEMA(child, "enumeration")) ||
-            (IS_SCHEMA(child, "whiteSpace")) ||
-            (IS_SCHEMA(child, "length")) ||
-            (IS_SCHEMA(child, "maxLength")) ||
-            (IS_SCHEMA(child, "minLength"))) {
-            facet = xmlSchemaParseFacet(ctxt, schema, child);
-            if (facet != NULL) {
-                if (lastfacet == NULL)
-                    type->facets = facet;
-                else
-                    lastfacet->next = facet;
-                lastfacet = facet;
-                lastfacet->next = NULL;
-            }
-            child = child->next;
-        }
-        /*
-        * Create links for derivation and validation.
-        */
-        if (type->facets != NULL) {
-            xmlSchemaFacetLinkPtr facetLink, lastFacetLink = NULL;
-
-            facet = type->facets;
-            do {
-                facetLink = (xmlSchemaFacetLinkPtr)
-                    xmlMalloc(sizeof(xmlSchemaFacetLink));
-                if (facetLink == NULL) {
-                    xmlSchemaPErrMemory(ctxt, "allocating a facet link", NULL);
-                    xmlFree(facetLink);
-                    return (NULL);
-                }
-                facetLink->facet = facet;
-                facetLink->next = NULL;
-                if (lastFacetLink == NULL)
-                    type->facetSet = facetLink;
-                else
-                    lastFacetLink->next = facetLink;
-                lastFacetLink = facetLink;
-                facet = facet->next;
-            } while (facet != NULL);
-        }
-    }
-    if (type->type == XML_SCHEMA_TYPE_COMPLEX) {
-        /*
-        * Attribute uses/declarations.
-        */
-        if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
-            (xmlSchemaItemListPtr *) &(type->attrUses),
-            XML_SCHEMA_TYPE_RESTRICTION, NULL) == -1)
-            return(NULL);
-        /*
-        * Attribute wildcard.
-        */
-        if (IS_SCHEMA(child, "anyAttribute")) {
-            type->attributeWildcard =
-                xmlSchemaParseAnyAttribute(ctxt, schema, child);
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "annotation?, (group | all | choice | sequence)?, "
-                "((attribute | attributeGroup)*, anyAttribute?))");
-        } else if (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
-             xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, (simpleType?, (minExclusive | minInclusive | "
-                "maxExclusive | maxInclusive | totalDigits | fractionDigits | "
-                "length | minLength | maxLength | enumeration | whiteSpace | "
-                "pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))");
-        } else {
-            /* Simple type */
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, (simpleType?, (minExclusive | minInclusive | "
-                "maxExclusive | maxInclusive | totalDigits | fractionDigits | "
-                "length | minLength | maxLength | enumeration | whiteSpace | "
-                "pattern)*))");
-        }
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaParseExtension:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * Parses an <extension>, which is found inside a
- * <simpleContent> or <complexContent>.
- * *WARNING* this interface is highly subject to change.
- *
- * TODO: Returns the type definition or NULL in case of error
- */
-static xmlSchemaTypePtr
-xmlSchemaParseExtension(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                        xmlNodePtr node, xmlSchemaTypeType parentType)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION;
-
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-
-    /*
-    * Attribute "base" - mandatory.
-    */
-    if ((xmlSchemaPValAttrQName(ctxt, schema, NULL, node,
-        "base", &(type->baseNs), &(type->base)) == 0) &&
-        (type->base == NULL)) {
-        xmlSchemaPMissingAttrErr(ctxt,
-            XML_SCHEMAP_S4S_ATTR_MISSING,
-            NULL, node, "base", NULL);
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the type ancestor.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
-        /*
-        * Corresponds to <complexType><complexContent><extension>... and:
-        *
-        * Model groups <all>, <choice>, <sequence> and <group>.
-        */
-        if (IS_SCHEMA(child, "all")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema,
-                    child, XML_SCHEMA_TYPE_ALL, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "choice")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema,
-                    child, XML_SCHEMA_TYPE_CHOICE, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "sequence")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema,
-                child, XML_SCHEMA_TYPE_SEQUENCE, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "group")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
-            /*
-            * Note that the reference will be resolved in
-            * xmlSchemaResolveTypeReferences();
-            */
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        /*
-        * Attribute uses/declarations.
-        */
-        if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
-            (xmlSchemaItemListPtr *) &(type->attrUses),
-            XML_SCHEMA_TYPE_EXTENSION, NULL) == -1)
-            return(NULL);
-        /*
-        * Attribute wildcard.
-        */
-        if (IS_SCHEMA(child, "anyAttribute")) {
-            ctxt->ctxtType->attributeWildcard =
-                xmlSchemaParseAnyAttribute(ctxt, schema, child);
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
-            /* Complex content extension. */
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, ((group | all | choice | sequence)?, "
-                "((attribute | attributeGroup)*, anyAttribute?)))");
-        } else {
-            /* Simple content extension. */
-            xmlSchemaPContentErr(ctxt,
-                XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-                NULL, node, child, NULL,
-                "(annotation?, ((attribute | attributeGroup)*, "
-                "anyAttribute?))");
-        }
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaParseSimpleContent:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema SimpleContent definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns the type definition or NULL in case of error
- */
-static int
-xmlSchemaParseSimpleContent(xmlSchemaParserCtxtPtr ctxt,
-                            xmlSchemaPtr schema, xmlNodePtr node,
-                            int *hasRestrictionOrExtension)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
-        (hasRestrictionOrExtension == NULL))
-        return (-1);
-    *hasRestrictionOrExtension = 0;
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id"))) {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the complex type ancestor.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_MISSING,
-            NULL, node, NULL, NULL,
-            "(annotation?, (restriction | extension))");
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_MISSING,
-            NULL, node, NULL, NULL,
-            "(annotation?, (restriction | extension))");
-    }
-    if (IS_SCHEMA(child, "restriction")) {
-        xmlSchemaParseRestriction(ctxt, schema, child,
-            XML_SCHEMA_TYPE_SIMPLE_CONTENT);
-        (*hasRestrictionOrExtension) = 1;
-        child = child->next;
-    } else if (IS_SCHEMA(child, "extension")) {
-        xmlSchemaParseExtension(ctxt, schema, child,
-            XML_SCHEMA_TYPE_SIMPLE_CONTENT);
-        (*hasRestrictionOrExtension) = 1;
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child, NULL,
-            "(annotation?, (restriction | extension))");
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaParseComplexContent:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema ComplexContent definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns the type definition or NULL in case of error
- */
-static int
-xmlSchemaParseComplexContent(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaPtr schema, xmlNodePtr node,
-                             int *hasRestrictionOrExtension)
-{
-    xmlSchemaTypePtr type;
-    xmlNodePtr child = NULL;
-    xmlAttrPtr attr;
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
-        (hasRestrictionOrExtension == NULL))
-        return (-1);
-    *hasRestrictionOrExtension = 0;
-    /* Not a component, don't create it. */
-    type = ctxt->ctxtType;
-    /*
-    * Check for illegal attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
-                (!xmlStrEqual(attr->name, BAD_CAST "mixed")))
-            {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-
-    xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-
-    /*
-    * Set the 'mixed' on the complex type ancestor.
-    */
-    if (xmlGetBooleanProp(ctxt, node, "mixed", 0))  {
-        if ((type->flags & XML_SCHEMAS_TYPE_MIXED) == 0)
-            type->flags |= XML_SCHEMAS_TYPE_MIXED;
-    }
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        /*
-        * Add the annotation to the complex type ancestor.
-        */
-        xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
-            xmlSchemaParseAnnotation(ctxt, child, 1));
-        child = child->next;
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_MISSING,
-            NULL, node, NULL,
-            NULL, "(annotation?, (restriction | extension))");
-    }
-    if (child == NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_MISSING,
-            NULL, node, NULL,
-            NULL, "(annotation?, (restriction | extension))");
-    }
-    if (IS_SCHEMA(child, "restriction")) {
-        xmlSchemaParseRestriction(ctxt, schema, child,
-            XML_SCHEMA_TYPE_COMPLEX_CONTENT);
-        (*hasRestrictionOrExtension) = 1;
-        child = child->next;
-    } else if (IS_SCHEMA(child, "extension")) {
-        xmlSchemaParseExtension(ctxt, schema, child,
-            XML_SCHEMA_TYPE_COMPLEX_CONTENT);
-        (*hasRestrictionOrExtension) = 1;
-        child = child->next;
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?, (restriction | extension))");
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaParseComplexType:
- * @ctxt:  a schema validation context
- * @schema:  the schema being built
- * @node:  a subtree containing XML Schema informations
- *
- * parse a XML schema Complex Type definition
- * *WARNING* this interface is highly subject to change
- *
- * Returns the type definition or NULL in case of error
- */
-static xmlSchemaTypePtr
-xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
-                          xmlNodePtr node, int topLevel)
-{
-    xmlSchemaTypePtr type, ctxtType;
-    xmlNodePtr child = NULL;
-    const xmlChar *name = NULL;
-    xmlAttrPtr attr;
-    const xmlChar *attrValue;
-#ifdef ENABLE_NAMED_LOCALS
-    char buf[40];
-#endif
-    int final = 0, block = 0, hasRestrictionOrExtension = 0;
-
-
-    if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);
-
-    ctxtType = ctxt->ctxtType;
-
-    if (topLevel) {
-        attr = xmlSchemaGetPropNode(node, "name");
-        if (attr == NULL) {
-            xmlSchemaPMissingAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_MISSING, NULL, node, "name", NULL);
-            return (NULL);
-        } else if (xmlSchemaPValAttrNode(ctxt, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
-            return (NULL);
-        }
-    }
-
-    if (topLevel == 0) {
-        /*
-        * Parse as local complex type definition.
-        */
-#ifdef ENABLE_NAMED_LOCALS
-        snprintf(buf, 39, "#CT%d", ctxt->counter++ + 1);
-        type = xmlSchemaAddType(ctxt, schema,
-            XML_SCHEMA_TYPE_COMPLEX,
-            xmlDictLookup(ctxt->dict, (const xmlChar *)buf, -1),
-            ctxt->targetNamespace, node, 0);
-#else
-        type = xmlSchemaAddType(ctxt, schema,
-            XML_SCHEMA_TYPE_COMPLEX,
-            NULL, ctxt->targetNamespace, node, 0);
-#endif
-        if (type == NULL)
-            return (NULL);
-        name = type->name;
-        type->node = node;
-        type->type = XML_SCHEMA_TYPE_COMPLEX;
-        /*
-        * TODO: We need the target namespace.
-        */
-    } else {
-        /*
-        * Parse as global complex type definition.
-        */
-        type = xmlSchemaAddType(ctxt, schema,
-            XML_SCHEMA_TYPE_COMPLEX,
-            name, ctxt->targetNamespace, node, 1);
-        if (type == NULL)
-            return (NULL);
-        type->node = node;
-        type->type = XML_SCHEMA_TYPE_COMPLEX;
-        type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
-    }
-    type->targetNamespace = ctxt->targetNamespace;
-    /*
-    * Handle attributes.
-    */
-    attr = node->properties;
-    while (attr != NULL) {
-        if (attr->ns == NULL) {
-            if (xmlStrEqual(attr->name, BAD_CAST "id")) {
-                /*
-                * Attribute "id".
-                */
-                xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
-            } else if (xmlStrEqual(attr->name, BAD_CAST "mixed")) {
-                /*
-                * Attribute "mixed".
-                */
-                if (xmlSchemaPGetBoolNodeValue(ctxt,
-                        NULL, (xmlNodePtr) attr))
-                    type->flags |= XML_SCHEMAS_TYPE_MIXED;
-            } else if (topLevel) {
-                /*
-                * Attributes of global complex type definitions.
-                */
-                if (xmlStrEqual(attr->name, BAD_CAST "name")) {
-                    /* Pass. */
-                } else if (xmlStrEqual(attr->name, BAD_CAST "abstract")) {
-                    /*
-                    * Attribute "abstract".
-                    */
-                    if (xmlSchemaPGetBoolNodeValue(ctxt,
-                            NULL, (xmlNodePtr) attr))
-                        type->flags |= XML_SCHEMAS_TYPE_ABSTRACT;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "final")) {
-                    /*
-                    * Attribute "final".
-                    */
-                    attrValue = xmlSchemaGetNodeContent(ctxt,
-                        (xmlNodePtr) attr);
-                    if (xmlSchemaPValAttrBlockFinal(attrValue,
-                        &(type->flags),
-                        -1,
-                        XML_SCHEMAS_TYPE_FINAL_EXTENSION,
-                        XML_SCHEMAS_TYPE_FINAL_RESTRICTION,
-                        -1, -1, -1) != 0)
-                    {
-                        xmlSchemaPSimpleTypeErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                            NULL, (xmlNodePtr) attr, NULL,
-                            "(#all | List of (extension | restriction))",
-                            attrValue, NULL, NULL, NULL);
-                    } else
-                        final = 1;
-                } else if (xmlStrEqual(attr->name, BAD_CAST "block")) {
-                    /*
-                    * Attribute "block".
-                    */
-                    attrValue = xmlSchemaGetNodeContent(ctxt,
-                        (xmlNodePtr) attr);
-                    if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
-                        -1,
-                        XML_SCHEMAS_TYPE_BLOCK_EXTENSION,
-                        XML_SCHEMAS_TYPE_BLOCK_RESTRICTION,
-                        -1, -1, -1) != 0) {
-                        xmlSchemaPSimpleTypeErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
-                            NULL, (xmlNodePtr) attr, NULL,
-                            "(#all | List of (extension | restriction)) ",
-                            attrValue, NULL, NULL, NULL);
-                    } else
-                        block = 1;
-                } else {
-                        xmlSchemaPIllegalAttrErr(ctxt,
-                            XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-                }
-            } else {
-                xmlSchemaPIllegalAttrErr(ctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-            }
-        } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt,
-                XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
-        }
-        attr = attr->next;
-    }
-    if (! block) {
-        /*
-        * Apply default "block" values.
-        */
-        if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
-            type->flags |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
-        if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
-            type->flags |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
-    }
-    if (! final) {
-        /*
-        * Apply default "block" values.
-        */
-        if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
-            type->flags |= XML_SCHEMAS_TYPE_FINAL_RESTRICTION;
-        if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
-            type->flags |= XML_SCHEMAS_TYPE_FINAL_EXTENSION;
-    }
-    /*
-    * And now for the children...
-    */
-    child = node->children;
-    if (IS_SCHEMA(child, "annotation")) {
-        type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
-        child = child->next;
-    }
-    ctxt->ctxtType = type;
-    if (IS_SCHEMA(child, "simpleContent")) {
-        /*
-        * <complexType><simpleContent>...
-        * 3.4.3 : 2.2
-        * Specifying mixed='true' when the <simpleContent>
-        * alternative is chosen has no effect
-        */
-        if (type->flags & XML_SCHEMAS_TYPE_MIXED)
-            type->flags ^= XML_SCHEMAS_TYPE_MIXED;
-        xmlSchemaParseSimpleContent(ctxt, schema, child,
-            &hasRestrictionOrExtension);
-        child = child->next;
-    } else if (IS_SCHEMA(child, "complexContent")) {
-        /*
-        * <complexType><complexContent>...
-        */
-        type->contentType = XML_SCHEMA_CONTENT_EMPTY;
-        xmlSchemaParseComplexContent(ctxt, schema, child,
-            &hasRestrictionOrExtension);
-        child = child->next;
-    } else {
-        /*
-        * E.g <complexType><sequence>... or <complexType><attribute>... etc.
-        *
-        * SPEC
-        * "...the third alternative (neither <simpleContent> nor
-        * <complexContent>) is chosen. This case is understood as shorthand
-        * for complex content restricting the `ur-type definition`, and the
-        * details of the mappings should be modified as necessary.
-        */
-        type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
-        type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
-        /*
-        * Parse model groups.
-        */
-        if (IS_SCHEMA(child, "all")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_ALL, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "choice")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_CHOICE, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "sequence")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroup(ctxt, schema, child,
-                    XML_SCHEMA_TYPE_SEQUENCE, 1);
-            child = child->next;
-        } else if (IS_SCHEMA(child, "group")) {
-            type->subtypes = (xmlSchemaTypePtr)
-                xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
-            /*
-            * Note that the reference will be resolved in
-            * xmlSchemaResolveTypeReferences();
-            */
-            child = child->next;
-        }
-        /*
-        * Parse attribute decls/refs.
-        */
-        if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
-            (xmlSchemaItemListPtr *) &(type->attrUses),
-            XML_SCHEMA_TYPE_RESTRICTION, NULL) == -1)
-            return(NULL);
-        /*
-        * Parse attribute wildcard.
-        */
-        if (IS_SCHEMA(child, "anyAttribute")) {
-            type->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
-            child = child->next;
-        }
-    }
-    if (child != NULL) {
-        xmlSchemaPContentErr(ctxt,
-            XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
-            NULL, node, child,
-            NULL, "(annotation?, (simpleContent | complexContent | "
-            "((group | all | choice | sequence)?, ((attribute | "
-            "attributeGroup)*, anyAttribute?))))");
-    }
-    /*
-    * REDEFINE: SPEC src-redefine (5)
-    */
-    if (topLevel && ctxt->isRedefine && (! hasRestrictionOrExtension)) {
-        xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
-            NULL, node, "This is a redefinition, thus the "
-            "<complexType> must have a <restriction> or <extension> "
-            "grand-child", NULL);
-    }
-    ctxt->ctxtType = ctxtType;
-    return (type);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Validating using Schemas                        *
- *                                                                      *
- ************************************************************************/
-
-/************************************************************************
- *                                                                      *
- *                      Reading/Writing Schemas                         *
- *                                                                      *
- ************************************************************************/
-
-#if 0 /* Will be enabled if it is clear what options are needed. */
-/**
- * xmlSchemaParserCtxtSetOptions:
- * @ctxt:       a schema parser context
- * @options: a combination of xmlSchemaParserOption
- *
- * Sets the options to be used during the parse.
- *
- * Returns 0 in case of success, -1 in case of an
- * API error.
- */
-static int
-xmlSchemaParserCtxtSetOptions(xmlSchemaParserCtxtPtr ctxt,
-                              int options)
-
-{
-    int i;
-
-    if (ctxt == NULL)
-        return (-1);
-    /*
-    * WARNING: Change the start value if adding to the
-    * xmlSchemaParseOption.
-    */
-    for (i = 1; i < (int) sizeof(int) * 8; i++) {
-        if (options & 1<<i) {
-            return (-1);
-        }
-    }
-    ctxt->options = options;
-    return (0);
-}
-
-/**
- * xmlSchemaValidCtxtGetOptions:
- * @ctxt: a schema parser context
- *
- * Returns the option combination of the parser context.
- */
-static int
-xmlSchemaParserCtxtGetOptions(xmlSchemaParserCtxtPtr ctxt)
-
-{
-    if (ctxt == NULL)
-        return (-1);
-    else
-        return (ctxt->options);
-}
-#endif
-
-/**
- * xmlSchemaNewParserCtxt:
- * @URL:  the location of the schema
- *
- * Create an XML Schemas parse context for that file/resource expected
- * to contain an XML Schemas file.
- *
- * Returns the parser context or NULL in case of error
- */
-xmlSchemaParserCtxtPtr
-xmlSchemaNewParserCtxt(const char *URL)
-{
-    xmlSchemaParserCtxtPtr ret;
-
-    if (URL == NULL)
-        return (NULL);
-
-    ret = xmlSchemaParserCtxtCreate();
-    if (ret == NULL)
-        return(NULL);
-    ret->dict = xmlDictCreate();
-    ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
-    return (ret);
-}
-
-/**
- * xmlSchemaNewMemParserCtxt:
- * @buffer:  a pointer to a char array containing the schemas
- * @size:  the size of the array
- *
- * Create an XML Schemas parse context for that memory buffer expected
- * to contain an XML Schemas file.
- *
- * Returns the parser context or NULL in case of error
- */
-xmlSchemaParserCtxtPtr
-xmlSchemaNewMemParserCtxt(const char *buffer, int size)
-{
-    xmlSchemaParserCtxtPtr ret;
-
-    if ((buffer == NULL) || (size <= 0))
-        return (NULL);
-    ret = xmlSchemaParserCtxtCreate();
-    if (ret == NULL)
-        return(NULL);
-    ret->buffer = buffer;
-    ret->size = size;
-    ret->dict = xmlDictCreate();
-    return (ret);
-}
-
-/**
- * xmlSchemaNewDocParserCtxt:
- * @doc:  a preparsed document tree
- *
- * Create an XML Schemas parse context for that document.
- * NB. The document may be modified during the parsing process.
- *
- * Returns the parser context or NULL in case of error
- */
-xmlSchemaParserCtxtPtr
-xmlSchemaNewDocParserCtxt(xmlDocPtr doc)
-{
-    xmlSchemaParserCtxtPtr ret;
-
-    if (doc == NULL)
-      return (NULL);
-    ret = xmlSchemaParserCtxtCreate();
-    if (ret == NULL)
-        return(NULL);
-    ret->doc = doc;
-    ret->dict = xmlDictCreate();
-    /* The application has responsibility for the document */
-    ret->preserve = 1;
-
-    return (ret);
-}
-
-/**
- * xmlSchemaFreeParserCtxt:
- * @ctxt:  the schema parser context
- *
- * Free the resources associated to the schema parser context
- */
-void
-xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt)
-{
-    if (ctxt == NULL)
-        return;
-    if (ctxt->doc != NULL && !ctxt->preserve)
-        xmlFreeDoc(ctxt->doc);
-    if (ctxt->vctxt != NULL) {
-        xmlSchemaFreeValidCtxt(ctxt->vctxt);
-    }
-    if (ctxt->ownsConstructor && (ctxt->constructor != NULL)) {
-        xmlSchemaConstructionCtxtFree(ctxt->constructor);
-        ctxt->constructor = NULL;
-        ctxt->ownsConstructor = 0;
-    }
-    if (ctxt->attrProhibs != NULL)
-        xmlSchemaItemListFree(ctxt->attrProhibs);
-    xmlDictFree(ctxt->dict);
-    xmlFree(ctxt);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Building the content models                     *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaBuildContentModelForSubstGroup:
- *
- * Returns 1 if nillable, 0 otherwise
- */
-static int
-xmlSchemaBuildContentModelForSubstGroup(xmlSchemaParserCtxtPtr pctxt,
-        xmlSchemaParticlePtr particle, int counter, xmlAutomataStatePtr end)
-{
-    xmlAutomataStatePtr start, tmp;
-    xmlSchemaElementPtr elemDecl, member;
-    xmlSchemaSubstGroupPtr substGroup;
-    int i;
-    int ret = 0;
-
-    elemDecl = (xmlSchemaElementPtr) particle->children;
-    /*
-    * Wrap the substitution group with a CHOICE.
-    */
-    start = pctxt->state;
-    if (end == NULL)
-        end = xmlAutomataNewState(pctxt->am);
-    substGroup = xmlSchemaSubstGroupGet(pctxt, elemDecl);
-    if (substGroup == NULL) {
-        xmlSchemaPErr(pctxt, WXS_ITEM_NODE(particle),
-            XML_SCHEMAP_INTERNAL,
-            "Internal error: xmlSchemaBuildContentModelForSubstGroup, "
-            "declaration is marked having a subst. group but none "
-            "available.\n", elemDecl->name, NULL);
-        return(0);
-    }
-    if (counter >= 0) {
-        /*
-        * NOTE that we put the declaration in, even if it's abstract.
-        * However, an error will be raised during *validation* if an element
-        * information item shall be validated against an abstract element
-        * declaration.
-        */
-        tmp = xmlAutomataNewCountedTrans(pctxt->am, start, NULL, counter);
-        xmlAutomataNewTransition2(pctxt->am, tmp, end,
-                    elemDecl->name, elemDecl->targetNamespace, elemDecl);
-        /*
-        * Add subst. group members.
-        */
-        for (i = 0; i < substGroup->members->nbItems; i++) {
-            member = (xmlSchemaElementPtr) substGroup->members->items[i];
-            xmlAutomataNewTransition2(pctxt->am, tmp, end,
-                               member->name, member->targetNamespace, member);
-        }
-    } else if (particle->maxOccurs == 1) {
-        /*
-        * NOTE that we put the declaration in, even if it's abstract,
-        */
-        xmlAutomataNewEpsilon(pctxt->am,
-            xmlAutomataNewTransition2(pctxt->am,
-            start, NULL,
-            elemDecl->name, elemDecl->targetNamespace, elemDecl), end);
-        /*
-        * Add subst. group members.
-        */
-        for (i = 0; i < substGroup->members->nbItems; i++) {
-            member = (xmlSchemaElementPtr) substGroup->members->items[i];
-            /*
-            * NOTE: This fixes bug #341150. xmlAutomataNewOnceTrans2()
-            *  was incorrectly used instead of xmlAutomataNewTransition2()
-            *  (seems like a copy&paste bug from the XML_SCHEMA_TYPE_ALL
-            *  section in xmlSchemaBuildAContentModel() ).
-            * TODO: Check if xmlAutomataNewOnceTrans2() was instead
-            *  intended for the above "counter" section originally. I.e.,
-            *  check xs:all with subst-groups.
-            *
-            * tmp = xmlAutomataNewOnceTrans2(pctxt->am, start, NULL,
-            *                  member->name, member->targetNamespace,
-            *                  1, 1, member);
-            */
-            tmp = xmlAutomataNewTransition2(pctxt->am, start, NULL,
-                member->name, member->targetNamespace, member);
-            xmlAutomataNewEpsilon(pctxt->am, tmp, end);
-        }
-    } else {
-        xmlAutomataStatePtr hop;
-        int maxOccurs = particle->maxOccurs == UNBOUNDED ?
-            UNBOUNDED : particle->maxOccurs - 1;
-        int minOccurs = particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
-
-        counter =
-            xmlAutomataNewCounter(pctxt->am, minOccurs,
-            maxOccurs);
-        hop = xmlAutomataNewState(pctxt->am);
-
-        xmlAutomataNewEpsilon(pctxt->am,
-            xmlAutomataNewTransition2(pctxt->am,
-            start, NULL,
-            elemDecl->name, elemDecl->targetNamespace, elemDecl),
-            hop);
-        /*
-         * Add subst. group members.
-         */
-        for (i = 0; i < substGroup->members->nbItems; i++) {
-            member = (xmlSchemaElementPtr) substGroup->members->items[i];
-            xmlAutomataNewEpsilon(pctxt->am,
-                xmlAutomataNewTransition2(pctxt->am,
-                start, NULL,
-                member->name, member->targetNamespace, member),
-                hop);
-        }
-        xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
-        xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
-    }
-    if (particle->minOccurs == 0) {
-        xmlAutomataNewEpsilon(pctxt->am, start, end);
-        ret = 1;
-    }
-    pctxt->state = end;
-    return(ret);
-}
-
-/**
- * xmlSchemaBuildContentModelForElement:
- *
- * Returns 1 if nillable, 0 otherwise
- */
-static int
-xmlSchemaBuildContentModelForElement(xmlSchemaParserCtxtPtr ctxt,
-                                     xmlSchemaParticlePtr particle)
-{
-    int ret = 0;
-
-    if (((xmlSchemaElementPtr) particle->children)->flags &
-        XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
-        /*
-        * Substitution groups.
-        */
-        ret = xmlSchemaBuildContentModelForSubstGroup(ctxt, particle, -1, NULL);
-    } else {
-        xmlSchemaElementPtr elemDecl;
-        xmlAutomataStatePtr start;
-
-        elemDecl = (xmlSchemaElementPtr) particle->children;
-
-        if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT)
-            return(0);
-        if (particle->maxOccurs == 1) {
-            start = ctxt->state;
-            ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
-                    elemDecl->name, elemDecl->targetNamespace, elemDecl);
-        } else if ((particle->maxOccurs >= UNBOUNDED) &&
-                   (particle->minOccurs < 2)) {
-            /* Special case. */
-            start = ctxt->state;
-            ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
-                elemDecl->name, elemDecl->targetNamespace, elemDecl);
-            ctxt->state = xmlAutomataNewTransition2(ctxt->am, ctxt->state, ctxt->state,
-                elemDecl->name, elemDecl->targetNamespace, elemDecl);
-        } else {
-            int counter;
-            int maxOccurs = particle->maxOccurs == UNBOUNDED ?
-                            UNBOUNDED : particle->maxOccurs - 1;
-            int minOccurs = particle->minOccurs < 1 ?
-                            0 : particle->minOccurs - 1;
-
-            start = xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
-            counter = xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs);
-            ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
-                elemDecl->name, elemDecl->targetNamespace, elemDecl);
-            xmlAutomataNewCountedTrans(ctxt->am, ctxt->state, start, counter);
-            ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, ctxt->state,
-                NULL, counter);
-        }
-        if (particle->minOccurs == 0) {
-            xmlAutomataNewEpsilon(ctxt->am, start, ctxt->state);
-            ret = 1;
-        }
-    }
-    return(ret);
-}
-
-/**
- * xmlSchemaBuildAContentModel:
- * @ctxt:  the schema parser context
- * @particle:  the particle component
- * @name:  the complex type's name whose content is being built
- *
- * Create the automaton for the {content type} of a complex type.
- *
- * Returns 1 if the content is nillable, 0 otherwise
- */
-static int
-xmlSchemaBuildAContentModel(xmlSchemaParserCtxtPtr pctxt,
-                            xmlSchemaParticlePtr particle)
-{
-    int ret = 0, tmp2;
-
-    if (particle == NULL) {
-        PERROR_INT("xmlSchemaBuildAContentModel", "particle is NULL");
-        return(1);
-    }
-    if (particle->children == NULL) {
-        /*
-        * Just return in this case. A missing "term" of the particle
-        * might arise due to an invalid "term" component.
-        */
-        return(1);
-    }
-
-    switch (particle->children->type) {
-        case XML_SCHEMA_TYPE_ANY: {
-            xmlAutomataStatePtr start, end;
-            xmlSchemaWildcardPtr wild;
-            xmlSchemaWildcardNsPtr ns;
-
-            wild = (xmlSchemaWildcardPtr) particle->children;
-
-            start = pctxt->state;
-            end = xmlAutomataNewState(pctxt->am);
-
-            if (particle->maxOccurs == 1) {
-                if (wild->any == 1) {
-                    /*
-                    * We need to add both transitions:
-                    *
-                    * 1. the {"*", "*"} for elements in a namespace.
-                    */
-                    pctxt->state =
-                        xmlAutomataNewTransition2(pctxt->am,
-                        start, NULL, BAD_CAST "*", BAD_CAST "*", wild);
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
-                    /*
-                    * 2. the {"*"} for elements in no namespace.
-                    */
-                    pctxt->state =
-                        xmlAutomataNewTransition2(pctxt->am,
-                        start, NULL, BAD_CAST "*", NULL, wild);
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
-
-                } else if (wild->nsSet != NULL) {
-                    ns = wild->nsSet;
-                    do {
-                        pctxt->state = start;
-                        pctxt->state = xmlAutomataNewTransition2(pctxt->am,
-                            pctxt->state, NULL, BAD_CAST "*", ns->value, wild);
-                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
-                        ns = ns->next;
-                    } while (ns != NULL);
-
-                } else if (wild->negNsSet != NULL) {
-                    pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
-                        start, end, BAD_CAST "*", wild->negNsSet->value,
-                        wild);
-                }
-            } else {
-                int counter;
-                xmlAutomataStatePtr hop;
-                int maxOccurs =
-                    particle->maxOccurs == UNBOUNDED ? UNBOUNDED :
-                                           particle->maxOccurs - 1;
-                int minOccurs =
-                    particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
-
-                counter = xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
-                hop = xmlAutomataNewState(pctxt->am);
-                if (wild->any == 1) {
-                    pctxt->state =
-                        xmlAutomataNewTransition2(pctxt->am,
-                        start, NULL, BAD_CAST "*", BAD_CAST "*", wild);
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
-                    pctxt->state =
-                        xmlAutomataNewTransition2(pctxt->am,
-                        start, NULL, BAD_CAST "*", NULL, wild);
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
-                } else if (wild->nsSet != NULL) {
-                    ns = wild->nsSet;
-                    do {
-                        pctxt->state =
-                            xmlAutomataNewTransition2(pctxt->am,
-                                start, NULL, BAD_CAST "*", ns->value, wild);
-                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
-                        ns = ns->next;
-                    } while (ns != NULL);
-
-                } else if (wild->negNsSet != NULL) {
-                    pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
-                        start, hop, BAD_CAST "*", wild->negNsSet->value,
-                        wild);
-                }
-                xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
-                xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
-            }
-            if (particle->minOccurs == 0) {
-                xmlAutomataNewEpsilon(pctxt->am, start, end);
-                ret = 1;
-            }
-            pctxt->state = end;
-            break;
-        }
-        case XML_SCHEMA_TYPE_ELEMENT:
-            ret = xmlSchemaBuildContentModelForElement(pctxt, particle);
-            break;
-        case XML_SCHEMA_TYPE_SEQUENCE:{
-            xmlSchemaTreeItemPtr sub;
-
-            ret = 1;
-            /*
-             * If max and min occurances are default (1) then
-             * simply iterate over the particles of the <sequence>.
-             */
-            if ((particle->minOccurs == 1) && (particle->maxOccurs == 1)) {
-                sub = particle->children->children;
-
-                while (sub != NULL) {
-                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                    if (tmp2 != 1) ret = 0;
-                    sub = sub->next;
-                }
-            } else {
-                xmlAutomataStatePtr oldstate = pctxt->state;
-
-                if (particle->maxOccurs >= UNBOUNDED) {
-                    if (particle->minOccurs > 1) {
-                        xmlAutomataStatePtr tmp;
-                        int counter;
-
-                        pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                            oldstate, NULL);
-                        oldstate = pctxt->state;
-
-                        counter = xmlAutomataNewCounter(pctxt->am,
-                            particle->minOccurs - 1, UNBOUNDED);
-
-                        sub = particle->children->children;
-                        while (sub != NULL) {
-                            tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                            (xmlSchemaParticlePtr) sub);
-                            if (tmp2 != 1) ret = 0;
-                            sub = sub->next;
-                        }
-                        tmp = pctxt->state;
-                        xmlAutomataNewCountedTrans(pctxt->am, tmp,
-                                                   oldstate, counter);
-                        pctxt->state =
-                            xmlAutomataNewCounterTrans(pctxt->am, tmp,
-                                                       NULL, counter);
-                        if (ret == 1)
-                            xmlAutomataNewEpsilon(pctxt->am,
-                                                oldstate, pctxt->state);
-
-                    } else {
-                        pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                            oldstate, NULL);
-                        oldstate = pctxt->state;
-
-                        sub = particle->children->children;
-                        while (sub != NULL) {
-                            tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                            if (tmp2 != 1) ret = 0;
-                            sub = sub->next;
-                        }
-                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state,
-                                              oldstate);
-                        /*
-                         * epsilon needed to block previous trans from
-                         * being allowed to enter back from another
-                         * construct
-                         */
-                        pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                                            pctxt->state, NULL);
-                        if (particle->minOccurs == 0) {
-                            xmlAutomataNewEpsilon(pctxt->am,
-                                oldstate, pctxt->state);
-                            ret = 1;
-                        }
-                    }
-                } else if ((particle->maxOccurs > 1)
-                           || (particle->minOccurs > 1)) {
-                    xmlAutomataStatePtr tmp;
-                    int counter;
-
-                    pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                        oldstate, NULL);
-                    oldstate = pctxt->state;
-
-                    counter = xmlAutomataNewCounter(pctxt->am,
-                        particle->minOccurs - 1,
-                        particle->maxOccurs - 1);
-
-                    sub = particle->children->children;
-                    while (sub != NULL) {
-                        tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                        if (tmp2 != 1) ret = 0;
-                        sub = sub->next;
-                    }
-                    tmp = pctxt->state;
-                    xmlAutomataNewCountedTrans(pctxt->am,
-                        tmp, oldstate, counter);
-                    pctxt->state =
-                        xmlAutomataNewCounterTrans(pctxt->am, tmp, NULL,
-                                                   counter);
-                    if ((particle->minOccurs == 0) || (ret == 1)) {
-                        xmlAutomataNewEpsilon(pctxt->am,
-                                            oldstate, pctxt->state);
-                        ret = 1;
-                    }
-                } else {
-                    sub = particle->children->children;
-                    while (sub != NULL) {
-                        tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                        if (tmp2 != 1) ret = 0;
-                        sub = sub->next;
-                    }
-
-                    /*
-                     * epsilon needed to block previous trans from
-                     * being allowed to enter back from another
-                     * construct
-                     */
-                    pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                                        pctxt->state, NULL);
-
-                    if (particle->minOccurs == 0) {
-                        xmlAutomataNewEpsilon(pctxt->am, oldstate,
-                                              pctxt->state);
-                        ret = 1;
-                    }
-                }
-            }
-            break;
-        }
-        case XML_SCHEMA_TYPE_CHOICE:{
-            xmlSchemaTreeItemPtr sub;
-            xmlAutomataStatePtr start, end;
-
-            ret = 0;
-            start = pctxt->state;
-            end = xmlAutomataNewState(pctxt->am);
-
-            /*
-             * iterate over the subtypes and remerge the end with an
-             * epsilon transition
-             */
-            if (particle->maxOccurs == 1) {
-                sub = particle->children->children;
-                while (sub != NULL) {
-                    pctxt->state = start;
-                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                    if (tmp2 == 1) ret = 1;
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
-                    sub = sub->next;
-                }
-            } else {
-                int counter;
-                xmlAutomataStatePtr hop, base;
-                int maxOccurs = particle->maxOccurs == UNBOUNDED ?
-                    UNBOUNDED : particle->maxOccurs - 1;
-                int minOccurs =
-                    particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
-
-                /*
-                 * use a counter to keep track of the number of transtions
-                 * which went through the choice.
-                 */
-                counter =
-                    xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
-                hop = xmlAutomataNewState(pctxt->am);
-                base = xmlAutomataNewState(pctxt->am);
-
-                sub = particle->children->children;
-                while (sub != NULL) {
-                    pctxt->state = base;
-                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
-                                        (xmlSchemaParticlePtr) sub);
-                    if (tmp2 == 1) ret = 1;
-                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
-                    sub = sub->next;
-                }
-                xmlAutomataNewEpsilon(pctxt->am, start, base);
-                xmlAutomataNewCountedTrans(pctxt->am, hop, base, counter);
-                xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
-                if (ret == 1)
-                    xmlAutomataNewEpsilon(pctxt->am, base, end);
-            }
-            if (particle->minOccurs == 0) {
-                xmlAutomataNewEpsilon(pctxt->am, start, end);
-                ret = 1;
-            }
-            pctxt->state = end;
-            break;
-        }
-        case XML_SCHEMA_TYPE_ALL:{
-            xmlAutomataStatePtr start, tmp;
-            xmlSchemaParticlePtr sub;
-            xmlSchemaElementPtr elemDecl;
-
-            ret = 1;
-
-            sub = (xmlSchemaParticlePtr) particle->children->children;
-            if (sub == NULL)
-                break;
-
-            ret = 0;
-
-            start = pctxt->state;
-            tmp = xmlAutomataNewState(pctxt->am);
-            xmlAutomataNewEpsilon(pctxt->am, pctxt->state, tmp);
-            pctxt->state = tmp;
-            while (sub != NULL) {
-                pctxt->state = tmp;
-
-                elemDecl = (xmlSchemaElementPtr) sub->children;
-                if (elemDecl == NULL) {
-                    PERROR_INT("xmlSchemaBuildAContentModel",
-                        "<element> particle has no term");
-                    return(ret);
-                };
-                /*
-                * NOTE: The {max occurs} of all the particles in the
-                * {particles} of the group must be 0 or 1; this is
-                * already ensured during the parse of the content of
-                * <all>.
-                */
-                if (elemDecl->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
-                    int counter;
-
-                    /*
-                     * This is an abstract group, we need to share
-                     * the same counter for all the element transitions
-                     * derived from the group
-                     */
-                    counter = xmlAutomataNewCounter(pctxt->am,
-                                       sub->minOccurs, sub->maxOccurs);
-                    xmlSchemaBuildContentModelForSubstGroup(pctxt,
-                                       sub, counter, pctxt->state);
-                } else {
-                    if ((sub->minOccurs == 1) &&
-                        (sub->maxOccurs == 1)) {
-                        xmlAutomataNewOnceTrans2(pctxt->am, pctxt->state,
-                                                pctxt->state,
-                                                elemDecl->name,
-                                                elemDecl->targetNamespace,
-                                                1, 1, elemDecl);
-                    } else if ((sub->minOccurs == 0) &&
-                        (sub->maxOccurs == 1)) {
-
-                        xmlAutomataNewCountTrans2(pctxt->am, pctxt->state,
-                                                 pctxt->state,
-                                                 elemDecl->name,
-                                                 elemDecl->targetNamespace,
-                                                 0,
-                                                 1,
-                                                 elemDecl);
-                    }
-                }
-                sub = (xmlSchemaParticlePtr) sub->next;
-            }
-            pctxt->state =
-                xmlAutomataNewAllTrans(pctxt->am, pctxt->state, NULL, 0);
-            if (particle->minOccurs == 0) {
-                xmlAutomataNewEpsilon(pctxt->am, start, pctxt->state);
-                ret = 1;
-            }
-            break;
-        }
-        case XML_SCHEMA_TYPE_GROUP:
-            /*
-            * If we hit a model group definition, then this means that
-            * it was empty, thus was not substituted for the containing
-            * model group. Just do nothing in this case.
-            * TODO: But the group should be substituted and not occur at
-            * all in the content model at this point. Fix this.
-            */
-            ret = 1;
-            break;
-        default:
-            xmlSchemaInternalErr2(ACTXT_CAST pctxt,
-                "xmlSchemaBuildAContentModel",
-                "found unexpected term of type '%s' in content model",
-                WXS_ITEM_TYPE_NAME(particle->children), NULL);
-            return(ret);
-    }
-    return(ret);
-}
-
-/**
- * xmlSchemaBuildContentModel:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- * @name:  the element name
- *
- * Builds the content model of the complex type.
- */
-static void
-xmlSchemaBuildContentModel(xmlSchemaTypePtr type,
-                           xmlSchemaParserCtxtPtr ctxt)
-{
-    if ((type->type != XML_SCHEMA_TYPE_COMPLEX) ||
-        (type->contModel != NULL) ||
-        ((type->contentType != XML_SCHEMA_CONTENT_ELEMENTS) &&
-        (type->contentType != XML_SCHEMA_CONTENT_MIXED)))
-        return;
-
-#ifdef DEBUG_CONTENT
-    xmlGenericError(xmlGenericErrorContext,
-                    "Building content model for %s\n", name);
-#endif
-    ctxt->am = NULL;
-    ctxt->am = xmlNewAutomata();
-    if (ctxt->am == NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-            "Cannot create automata for complex type %s\n", type->name);
-        return;
-    }
-    ctxt->state = xmlAutomataGetInitState(ctxt->am);
-    /*
-    * Build the automaton.
-    */
-    xmlSchemaBuildAContentModel(ctxt, WXS_TYPE_PARTICLE(type));
-    xmlAutomataSetFinalState(ctxt->am, ctxt->state);
-    type->contModel = xmlAutomataCompile(ctxt->am);
-    if (type->contModel == NULL) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_INTERNAL,
-            WXS_BASIC_CAST type, type->node,
-            "Failed to compile the content model", NULL);
-    } else if (xmlRegexpIsDeterminist(type->contModel) != 1) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_NOT_DETERMINISTIC,
-            /* XML_SCHEMAS_ERR_NOTDETERMINIST, */
-            WXS_BASIC_CAST type, type->node,
-            "The content model is not determinist", NULL);
-    } else {
-#ifdef DEBUG_CONTENT_REGEXP
-        xmlGenericError(xmlGenericErrorContext,
-                        "Content model of %s:\n", type->name);
-        xmlRegexpPrint(stderr, type->contModel);
-#endif
-    }
-    ctxt->state = NULL;
-    xmlFreeAutomata(ctxt->am);
-    ctxt->am = NULL;
-}
-
-/**
- * xmlSchemaResolveElementReferences:
- * @elem:  the schema element context
- * @ctxt:  the schema parser context
- *
- * Resolves the references of an element declaration
- * or particle, which has an element declaration as it's
- * term.
- */
-static void
-xmlSchemaResolveElementReferences(xmlSchemaElementPtr elemDecl,
-                                  xmlSchemaParserCtxtPtr ctxt)
-{
-    if ((ctxt == NULL) || (elemDecl == NULL) ||
-        ((elemDecl != NULL) &&
-        (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_RESOLVED)))
-        return;
-    elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_RESOLVED;
-
-    if ((elemDecl->subtypes == NULL) && (elemDecl->namedType != NULL)) {
-        xmlSchemaTypePtr type;
-
-        /* (type definition) ... otherwise the type definition `resolved`
-        * to by the `actual value` of the type [attribute] ...
-        */
-        type = xmlSchemaGetType(ctxt->schema, elemDecl->namedType,
-            elemDecl->namedTypeNs);
-        if (type == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST elemDecl, elemDecl->node,
-                "type", elemDecl->namedType, elemDecl->namedTypeNs,
-                XML_SCHEMA_TYPE_BASIC, "type definition");
-        } else
-            elemDecl->subtypes = type;
-    }
-    if (elemDecl->substGroup != NULL) {
-        xmlSchemaElementPtr substHead;
-
-        /*
-        * FIXME TODO: Do we need a new field in _xmlSchemaElement for
-        * substitutionGroup?
-        */
-        substHead = xmlSchemaGetElem(ctxt->schema, elemDecl->substGroup,
-            elemDecl->substGroupNs);
-        if (substHead == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST elemDecl, NULL,
-                "substitutionGroup", elemDecl->substGroup,
-                elemDecl->substGroupNs, XML_SCHEMA_TYPE_ELEMENT, NULL);
-        } else {
-            xmlSchemaResolveElementReferences(substHead, ctxt);
-            /*
-            * Set the "substitution group affiliation".
-            * NOTE that now we use the "refDecl" field for this.
-            */
-            WXS_SUBST_HEAD(elemDecl) = substHead;
-            /*
-            * The type definitions is set to:
-            * SPEC "...the {type definition} of the element
-            * declaration `resolved` to by the `actual value`
-            * of the substitutionGroup [attribute], if present"
-            */
-            if (elemDecl->subtypes == NULL)
-                elemDecl->subtypes = substHead->subtypes;
-        }
-    }
-    /*
-    * SPEC "The definition of anyType serves as the default type definition
-    * for element declarations whose XML representation does not specify one."
-    */
-    if ((elemDecl->subtypes == NULL) &&
-        (elemDecl->namedType == NULL) &&
-        (elemDecl->substGroup == NULL))
-        elemDecl->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
-}
-
-/**
- * xmlSchemaResolveUnionMemberTypes:
- * @ctxt:  the schema parser context
- * @type:  the schema simple type definition
- *
- * Checks and builds the "member type definitions" property of the union
- * simple type. This handles part (1), part (2) is done in
- * xmlSchemaFinishMemberTypeDefinitionsProperty()
- *
- * Returns -1 in case of an internal error, 0 otherwise.
- */
-static int
-xmlSchemaResolveUnionMemberTypes(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaTypePtr type)
-{
-
-    xmlSchemaTypeLinkPtr link, lastLink, newLink;
-    xmlSchemaTypePtr memberType;
-
-    /*
-    * SPEC (1) "If the <union> alternative is chosen, then [Definition:]
-    * define the explicit members as the type definitions `resolved`
-    * to by the items in the `actual value` of the memberTypes [attribute],
-    * if any, followed by the type definitions corresponding to the
-    * <simpleType>s among the [children] of <union>, if any."
-    */
-    /*
-    * Resolve references.
-    */
-    link = type->memberTypes;
-    lastLink = NULL;
-    while (link != NULL) {
-        const xmlChar *name, *nsName;
-
-        name = ((xmlSchemaQNameRefPtr) link->type)->name;
-        nsName = ((xmlSchemaQNameRefPtr) link->type)->targetNamespace;
-
-        memberType = xmlSchemaGetType(ctxt->schema, name, nsName);
-        if ((memberType == NULL) || (! WXS_IS_SIMPLE(memberType))) {
-            xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST type, type->node, "memberTypes",
-                name, nsName, XML_SCHEMA_TYPE_SIMPLE, NULL);
-            /*
-            * Remove the member type link.
-            */
-            if (lastLink == NULL)
-                type->memberTypes = link->next;
-            else
-                lastLink->next = link->next;
-            newLink = link;
-            link = link->next;
-            xmlFree(newLink);
-        } else {
-            link->type = memberType;
-            lastLink = link;
-            link = link->next;
-        }
-    }
-    /*
-    * Add local simple types,
-    */
-    memberType = type->subtypes;
-    while (memberType != NULL) {
-        link = (xmlSchemaTypeLinkPtr) xmlMalloc(sizeof(xmlSchemaTypeLink));
-        if (link == NULL) {
-            xmlSchemaPErrMemory(ctxt, "allocating a type link", NULL);
-            return (-1);
-        }
-        link->type = memberType;
-        link->next = NULL;
-        if (lastLink == NULL)
-            type->memberTypes = link;
-        else
-            lastLink->next = link;
-        lastLink = link;
-        memberType = memberType->next;
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaIsDerivedFromBuiltInType:
- * @ctxt:  the schema parser context
- * @type:  the type definition
- * @valType: the value type
- *
- *
- * Returns 1 if the type has the given value type, or
- * is derived from such a type.
- */
-static int
-xmlSchemaIsDerivedFromBuiltInType(xmlSchemaTypePtr type, int valType)
-{
-    if (type == NULL)
-        return (0);
-    if (WXS_IS_COMPLEX(type))
-        return (0);
-    if (type->type == XML_SCHEMA_TYPE_BASIC) {
-        if (type->builtInType == valType)
-            return(1);
-        if ((type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) ||
-            (type->builtInType == XML_SCHEMAS_ANYTYPE))
-            return (0);
-        return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
-    }
-    return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
-}
-
-#if 0
-/**
- * xmlSchemaIsDerivedFromBuiltInType:
- * @ctxt:  the schema parser context
- * @type:  the type definition
- * @valType: the value type
- *
- *
- * Returns 1 if the type has the given value type, or
- * is derived from such a type.
- */
-static int
-xmlSchemaIsUserDerivedFromBuiltInType(xmlSchemaTypePtr type, int valType)
-{
-    if (type == NULL)
-        return (0);
-    if (WXS_IS_COMPLEX(type))
-        return (0);
-    if (type->type == XML_SCHEMA_TYPE_BASIC) {
-        if (type->builtInType == valType)
-            return(1);
-        return (0);
-    } else
-        return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
-
-    return (0);
-}
-
-static xmlSchemaTypePtr
-xmlSchemaQueryBuiltInType(xmlSchemaTypePtr type)
-{
-    if (type == NULL)
-        return (NULL);
-    if (WXS_IS_COMPLEX(type))
-        return (NULL);
-    if (type->type == XML_SCHEMA_TYPE_BASIC)
-        return(type);
-    return(xmlSchemaQueryBuiltInType(type->subtypes));
-}
-#endif
-
-/**
- * xmlSchemaGetPrimitiveType:
- * @type:  the simpleType definition
- *
- * Returns the primitive type of the given type or
- * NULL in case of error.
- */
-static xmlSchemaTypePtr
-xmlSchemaGetPrimitiveType(xmlSchemaTypePtr type)
-{
-
-    while (type != NULL) {
-        /*
-        * Note that anySimpleType is actually not a primitive type
-        * but we need that here.
-        */
-        if ((type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) ||
-           (type->flags & XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE))
-            return (type);
-        type = type->baseType;
-    }
-
-    return (NULL);
-}
-
-#if 0
-/**
- * xmlSchemaGetBuiltInTypeAncestor:
- * @type:  the simpleType definition
- *
- * Returns the primitive type of the given type or
- * NULL in case of error.
- */
-static xmlSchemaTypePtr
-xmlSchemaGetBuiltInTypeAncestor(xmlSchemaTypePtr type)
-{
-    if (WXS_IS_LIST(type) || WXS_IS_UNION(type))
-        return (0);
-    while (type != NULL) {
-        if (type->type == XML_SCHEMA_TYPE_BASIC)
-            return (type);
-        type = type->baseType;
-    }
-
-    return (NULL);
-}
-#endif
-
-/**
- * xmlSchemaCloneWildcardNsConstraints:
- * @ctxt:  the schema parser context
- * @dest:  the destination wildcard
- * @source: the source wildcard
- *
- * Clones the namespace constraints of source
- * and assignes them to dest.
- * Returns -1 on internal error, 0 otherwise.
- */
-static int
-xmlSchemaCloneWildcardNsConstraints(xmlSchemaParserCtxtPtr ctxt,
-                                    xmlSchemaWildcardPtr dest,
-                                    xmlSchemaWildcardPtr source)
-{
-    xmlSchemaWildcardNsPtr cur, tmp, last;
-
-    if ((source == NULL) || (dest == NULL))
-        return(-1);
-    dest->any = source->any;
-    cur = source->nsSet;
-    last = NULL;
-    while (cur != NULL) {
-        tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
-        if (tmp == NULL)
-            return(-1);
-        tmp->value = cur->value;
-        if (last == NULL)
-            dest->nsSet = tmp;
-        else
-            last->next = tmp;
-        last = tmp;
-        cur = cur->next;
-    }
-    if (dest->negNsSet != NULL)
-        xmlSchemaFreeWildcardNsSet(dest->negNsSet);
-    if (source->negNsSet != NULL) {
-        dest->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
-        if (dest->negNsSet == NULL)
-            return(-1);
-        dest->negNsSet->value = source->negNsSet->value;
-    } else
-        dest->negNsSet = NULL;
-    return(0);
-}
-
-/**
- * xmlSchemaUnionWildcards:
- * @ctxt:  the schema parser context
- * @completeWild:  the first wildcard
- * @curWild: the second wildcard
- *
- * Unions the namespace constraints of the given wildcards.
- * @completeWild will hold the resulting union.
- * Returns a positive error code on failure, -1 in case of an
- * internal error, 0 otherwise.
- */
-static int
-xmlSchemaUnionWildcards(xmlSchemaParserCtxtPtr ctxt,
-                            xmlSchemaWildcardPtr completeWild,
-                            xmlSchemaWildcardPtr curWild)
-{
-    xmlSchemaWildcardNsPtr cur, curB, tmp;
-
-    /*
-    * 1 If O1 and O2 are the same value, then that value must be the
-    * value.
-    */
-    if ((completeWild->any == curWild->any) &&
-        ((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
-        ((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
-
-        if ((completeWild->negNsSet == NULL) ||
-            (completeWild->negNsSet->value == curWild->negNsSet->value)) {
-
-            if (completeWild->nsSet != NULL) {
-                int found = 0;
-
-                /*
-                * Check equality of sets.
-                */
-                cur = completeWild->nsSet;
-                while (cur != NULL) {
-                    found = 0;
-                    curB = curWild->nsSet;
-                    while (curB != NULL) {
-                        if (cur->value == curB->value) {
-                            found = 1;
-                            break;
-                        }
-                        curB = curB->next;
-                    }
-                    if (!found)
-                        break;
-                    cur = cur->next;
-                }
-                if (found)
-                    return(0);
-            } else
-                return(0);
-        }
-    }
-    /*
-    * 2 If either O1 or O2 is any, then any must be the value
-    */
-    if (completeWild->any != curWild->any) {
-        if (completeWild->any == 0) {
-            completeWild->any = 1;
-            if (completeWild->nsSet != NULL) {
-                xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                completeWild->nsSet = NULL;
-            }
-            if (completeWild->negNsSet != NULL) {
-                xmlFree(completeWild->negNsSet);
-                completeWild->negNsSet = NULL;
-            }
-        }
-        return (0);
-    }
-    /*
-    * 3 If both O1 and O2 are sets of (namespace names or `absent`),
-    * then the union of those sets must be the value.
-    */
-    if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
-        int found;
-        xmlSchemaWildcardNsPtr start;
-
-        cur = curWild->nsSet;
-        start = completeWild->nsSet;
-        while (cur != NULL) {
-            found = 0;
-            curB = start;
-            while (curB != NULL) {
-                if (cur->value == curB->value) {
-                    found = 1;
-                    break;
-                }
-                curB = curB->next;
-            }
-            if (!found) {
-                tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
-                if (tmp == NULL)
-                    return (-1);
-                tmp->value = cur->value;
-                tmp->next = completeWild->nsSet;
-                completeWild->nsSet = tmp;
-            }
-            cur = cur->next;
-        }
-
-        return(0);
-    }
-    /*
-    * 4 If the two are negations of different values (namespace names
-    * or `absent`), then a pair of not and `absent` must be the value.
-    */
-    if ((completeWild->negNsSet != NULL) &&
-        (curWild->negNsSet != NULL) &&
-        (completeWild->negNsSet->value != curWild->negNsSet->value)) {
-        completeWild->negNsSet->value = NULL;
-
-        return(0);
-    }
-    /*
-     * 5.
-     */
-    if (((completeWild->negNsSet != NULL) &&
-        (completeWild->negNsSet->value != NULL) &&
-        (curWild->nsSet != NULL)) ||
-        ((curWild->negNsSet != NULL) &&
-        (curWild->negNsSet->value != NULL) &&
-        (completeWild->nsSet != NULL))) {
-
-        int nsFound, absentFound = 0;
-
-        if (completeWild->nsSet != NULL) {
-            cur = completeWild->nsSet;
-            curB = curWild->negNsSet;
-        } else {
-            cur = curWild->nsSet;
-            curB = completeWild->negNsSet;
-        }
-        nsFound = 0;
-        while (cur != NULL) {
-            if (cur->value == NULL)
-                absentFound = 1;
-            else if (cur->value == curB->value)
-                nsFound = 1;
-            if (nsFound && absentFound)
-                break;
-            cur = cur->next;
-        }
-
-        if (nsFound && absentFound) {
-            /*
-            * 5.1 If the set S includes both the negated namespace
-            * name and `absent`, then any must be the value.
-            */
-            completeWild->any = 1;
-            if (completeWild->nsSet != NULL) {
-                xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                completeWild->nsSet = NULL;
-            }
-            if (completeWild->negNsSet != NULL) {
-                xmlFree(completeWild->negNsSet);
-                completeWild->negNsSet = NULL;
-            }
-        } else if (nsFound && (!absentFound)) {
-            /*
-            * 5.2 If the set S includes the negated namespace name
-            * but not `absent`, then a pair of not and `absent` must
-            * be the value.
-            */
-            if (completeWild->nsSet != NULL) {
-                xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                completeWild->nsSet = NULL;
-            }
-            if (completeWild->negNsSet == NULL) {
-                completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
-                if (completeWild->negNsSet == NULL)
-                    return (-1);
-            }
-            completeWild->negNsSet->value = NULL;
-        } else if ((!nsFound) && absentFound) {
-            /*
-            * 5.3 If the set S includes `absent` but not the negated
-            * namespace name, then the union is not expressible.
-            */
-            xmlSchemaPErr(ctxt, completeWild->node,
-                XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
-                "The union of the wilcard is not expressible.\n",
-                NULL, NULL);
-            return(XML_SCHEMAP_UNION_NOT_EXPRESSIBLE);
-        } else if ((!nsFound) && (!absentFound)) {
-            /*
-            * 5.4 If the set S does not include either the negated namespace
-            * name or `absent`, then whichever of O1 or O2 is a pair of not
-            * and a namespace name must be the value.
-            */
-            if (completeWild->negNsSet == NULL) {
-                if (completeWild->nsSet != NULL) {
-                    xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                    completeWild->nsSet = NULL;
-                }
-                completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
-                if (completeWild->negNsSet == NULL)
-                    return (-1);
-                completeWild->negNsSet->value = curWild->negNsSet->value;
-            }
-        }
-        return (0);
-    }
-    /*
-     * 6.
-     */
-    if (((completeWild->negNsSet != NULL) &&
-        (completeWild->negNsSet->value == NULL) &&
-        (curWild->nsSet != NULL)) ||
-        ((curWild->negNsSet != NULL) &&
-        (curWild->negNsSet->value == NULL) &&
-        (completeWild->nsSet != NULL))) {
-
-        if (completeWild->nsSet != NULL) {
-            cur = completeWild->nsSet;
-        } else {
-            cur = curWild->nsSet;
-        }
-        while (cur != NULL) {
-            if (cur->value == NULL) {
-                /*
-                * 6.1 If the set S includes `absent`, then any must be the
-                * value.
-                */
-                completeWild->any = 1;
-                if (completeWild->nsSet != NULL) {
-                    xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                    completeWild->nsSet = NULL;
-                }
-                if (completeWild->negNsSet != NULL) {
-                    xmlFree(completeWild->negNsSet);
-                    completeWild->negNsSet = NULL;
-                }
-                return (0);
-            }
-            cur = cur->next;
-        }
-        if (completeWild->negNsSet == NULL) {
-            /*
-            * 6.2 If the set S does not include `absent`, then a pair of not
-            * and `absent` must be the value.
-            */
-            if (completeWild->nsSet != NULL) {
-                xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
-                completeWild->nsSet = NULL;
-            }
-            completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
-            if (completeWild->negNsSet == NULL)
-                return (-1);
-            completeWild->negNsSet->value = NULL;
-        }
-        return (0);
-    }
-    return (0);
-
-}
-
-/**
- * xmlSchemaIntersectWildcards:
- * @ctxt:  the schema parser context
- * @completeWild:  the first wildcard
- * @curWild: the second wildcard
- *
- * Intersects the namespace constraints of the given wildcards.
- * @completeWild will hold the resulting intersection.
- * Returns a positive error code on failure, -1 in case of an
- * internal error, 0 otherwise.
- */
-static int
-xmlSchemaIntersectWildcards(xmlSchemaParserCtxtPtr ctxt,
-                            xmlSchemaWildcardPtr completeWild,
-                            xmlSchemaWildcardPtr curWild)
-{
-    xmlSchemaWildcardNsPtr cur, curB, prev,  tmp;
-
-    /*
-    * 1 If O1 and O2 are the same value, then that value must be the
-    * value.
-    */
-    if ((completeWild->any == curWild->any) &&
-        ((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
-        ((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
-
-        if ((completeWild->negNsSet == NULL) ||
-            (completeWild->negNsSet->value == curWild->negNsSet->value)) {
-
-            if (completeWild->nsSet != NULL) {
-                int found = 0;
-
-                /*
-                * Check equality of sets.
-                */
-                cur = completeWild->nsSet;
-                while (cur != NULL) {
-                    found = 0;
-                    curB = curWild->nsSet;
-                    while (curB != NULL) {
-                        if (cur->value == curB->value) {
-                            found = 1;
-                            break;
-                        }
-                        curB = curB->next;
-                    }
-                    if (!found)
-                        break;
-                    cur = cur->next;
-                }
-                if (found)
-                    return(0);
-            } else
-                return(0);
-        }
-    }
-    /*
-    * 2 If either O1 or O2 is any, then the other must be the value.
-    */
-    if ((completeWild->any != curWild->any) && (completeWild->any)) {
-        if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
-            return(-1);
-        return(0);
-    }
-    /*
-    * 3 If either O1 or O2 is a pair of not and a value (a namespace
-    * name or `absent`) and the other is a set of (namespace names or
-    * `absent`), then that set, minus the negated value if it was in
-    * the set, minus `absent` if it was in the set, must be the value.
-    */
-    if (((completeWild->negNsSet != NULL) && (curWild->nsSet != NULL)) ||
-        ((curWild->negNsSet != NULL) && (completeWild->nsSet != NULL))) {
-        const xmlChar *neg;
-
-        if (completeWild->nsSet == NULL) {
-            neg = completeWild->negNsSet->value;
-            if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
-                return(-1);
-        } else
-            neg = curWild->negNsSet->value;
-        /*
-        * Remove absent and negated.
-        */
-        prev = NULL;
-        cur = completeWild->nsSet;
-        while (cur != NULL) {
-            if (cur->value == NULL) {
-                if (prev == NULL)
-                    completeWild->nsSet = cur->next;
-                else
-                    prev->next = cur->next;
-                xmlFree(cur);
-                break;
-            }
-            prev = cur;
-            cur = cur->next;
-        }
-        if (neg != NULL) {
-            prev = NULL;
-            cur = completeWild->nsSet;
-            while (cur != NULL) {
-                if (cur->value == neg) {
-                    if (prev == NULL)
-                        completeWild->nsSet = cur->next;
-                    else
-                        prev->next = cur->next;
-                    xmlFree(cur);
-                    break;
-                }
-                prev = cur;
-                cur = cur->next;
-            }
-        }
-
-        return(0);
-    }
-    /*
-    * 4 If both O1 and O2 are sets of (namespace names or `absent`),
-    * then the intersection of those sets must be the value.
-    */
-    if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
-        int found;
-
-        cur = completeWild->nsSet;
-        prev = NULL;
-        while (cur != NULL) {
-            found = 0;
-            curB = curWild->nsSet;
-            while (curB != NULL) {
-                if (cur->value == curB->value) {
-                    found = 1;
-                    break;
-                }
-                curB = curB->next;
-            }
-            if (!found) {
-                if (prev == NULL)
-                    completeWild->nsSet = cur->next;
-                else
-                    prev->next = cur->next;
-                tmp = cur->next;
-                xmlFree(cur);
-                cur = tmp;
-                continue;
-            }
-            prev = cur;
-            cur = cur->next;
-        }
-
-        return(0);
-    }
-    /* 5 If the two are negations of different namespace names,
-    * then the intersection is not expressible
-    */
-    if ((completeWild->negNsSet != NULL) &&
-        (curWild->negNsSet != NULL) &&
-        (completeWild->negNsSet->value != curWild->negNsSet->value) &&
-        (completeWild->negNsSet->value != NULL) &&
-        (curWild->negNsSet->value != NULL)) {
-
-        xmlSchemaPErr(ctxt, completeWild->node, XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
-            "The intersection of the wilcard is not expressible.\n",
-            NULL, NULL);
-        return(XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE);
-    }
-    /*
-    * 6 If the one is a negation of a namespace name and the other
-    * is a negation of `absent`, then the one which is the negation
-    * of a namespace name must be the value.
-    */
-    if ((completeWild->negNsSet != NULL) && (curWild->negNsSet != NULL) &&
-        (completeWild->negNsSet->value != curWild->negNsSet->value) &&
-        (completeWild->negNsSet->value == NULL)) {
-        completeWild->negNsSet->value =  curWild->negNsSet->value;
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaIsWildcardNsConstraintSubset:
- * @ctxt:  the schema parser context
- * @sub:  the first wildcard
- * @super: the second wildcard
- *
- * Schema Component Constraint: Wildcard Subset (cos-ns-subset)
- *
- * Returns 0 if the namespace constraint of @sub is an intensional
- * subset of @super, 1 otherwise.
- */
-static int
-xmlSchemaCheckCOSNSSubset(xmlSchemaWildcardPtr sub,
-                          xmlSchemaWildcardPtr super)
-{
-    /*
-    * 1 super must be any.
-    */
-    if (super->any)
-        return (0);
-    /*
-    * 2.1 sub must be a pair of not and a namespace name or `absent`.
-    * 2.2 super must be a pair of not and the same value.
-    */
-    if ((sub->negNsSet != NULL) &&
-        (super->negNsSet != NULL) &&
-        (sub->negNsSet->value == super->negNsSet->value))
-        return (0);
-    /*
-    * 3.1 sub must be a set whose members are either namespace names or `absent`.
-    */
-    if (sub->nsSet != NULL) {
-        /*
-        * 3.2.1 super must be the same set or a superset thereof.
-        */
-        if (super->nsSet != NULL) {
-            xmlSchemaWildcardNsPtr cur, curB;
-            int found = 0;
-
-            cur = sub->nsSet;
-            while (cur != NULL) {
-                found = 0;
-                curB = super->nsSet;
-                while (curB != NULL) {
-                    if (cur->value == curB->value) {
-                        found = 1;
-                        break;
-                    }
-                    curB = curB->next;
-                }
-                if (!found)
-                    return (1);
-                cur = cur->next;
-            }
-            if (found)
-                return (0);
-        } else if (super->negNsSet != NULL) {
-            xmlSchemaWildcardNsPtr cur;
-            /*
-            * 3.2.2 super must be a pair of not and a namespace name or
-            * `absent` and that value must not be in sub's set.
-            */
-            cur = sub->nsSet;
-            while (cur != NULL) {
-                if (cur->value == super->negNsSet->value)
-                    return (1);
-                cur = cur->next;
-            }
-            return (0);
-        }
-    }
-    return (1);
-}
-
-static int
-xmlSchemaGetEffectiveValueConstraint(xmlSchemaAttributeUsePtr attruse,
-                                     int *fixed,
-                                     const xmlChar **value,
-                                     xmlSchemaValPtr *val)
-{
-    *fixed = 0;
-    *value = NULL;
-    if (val != 0)
-        *val = NULL;
-
-    if (attruse->defValue != NULL) {
-        *value = attruse->defValue;
-        if (val != NULL)
-            *val = attruse->defVal;
-        if (attruse->flags & XML_SCHEMA_ATTR_USE_FIXED)
-            *fixed = 1;
-        return(1);
-    } else if ((attruse->attrDecl != NULL) &&
-        (attruse->attrDecl->defValue != NULL)) {
-        *value = attruse->attrDecl->defValue;
-        if (val != NULL)
-            *val = attruse->attrDecl->defVal;
-        if (attruse->attrDecl->flags & XML_SCHEMAS_ATTR_FIXED)
-            *fixed = 1;
-        return(1);
-    }
-    return(0);
-}
-/**
- * xmlSchemaCheckCVCWildcardNamespace:
- * @wild:  the wildcard
- * @ns:  the namespace
- *
- * Validation Rule: Wildcard allows Namespace Name
- * (cvc-wildcard-namespace)
- *
- * Returns 0 if the given namespace matches the wildcard,
- * 1 otherwise and -1 on API errors.
- */
-static int
-xmlSchemaCheckCVCWildcardNamespace(xmlSchemaWildcardPtr wild,
-                                   const xmlChar* ns)
-{
-    if (wild == NULL)
-        return(-1);
-
-    if (wild->any)
-        return(0);
-    else if (wild->nsSet != NULL) {
-        xmlSchemaWildcardNsPtr cur;
-
-        cur = wild->nsSet;
-        while (cur != NULL) {
-            if (xmlStrEqual(cur->value, ns))
-                return(0);
-            cur = cur->next;
-        }
-    } else if ((wild->negNsSet != NULL) && (ns != NULL) &&
-        (!xmlStrEqual(wild->negNsSet->value, ns)))
-        return(0);
-
-    return(1);
-}
-
-#define XML_SCHEMA_ACTION_DERIVE 0
-#define XML_SCHEMA_ACTION_REDEFINE 1
-
-#define WXS_ACTION_STR(a) \
-((a) == XML_SCHEMA_ACTION_DERIVE) ? (const xmlChar *) "base" : (const xmlChar *) "redefined"
-
-/*
-* Schema Component Constraint:
-*   Derivation Valid (Restriction, Complex)
-*   derivation-ok-restriction (2) - (4)
-*
-* ATTENTION:
-* In XML Schema 1.1 this will be:
-* Validation Rule:
-*     Checking complex type subsumption (practicalSubsumption) (1, 2 and 3)
-*
-*/
-static int
-xmlSchemaCheckDerivationOKRestriction2to4(xmlSchemaParserCtxtPtr pctxt,
-                                       int action,
-                                       xmlSchemaBasicItemPtr item,
-                                       xmlSchemaBasicItemPtr baseItem,
-                                       xmlSchemaItemListPtr uses,
-                                       xmlSchemaItemListPtr baseUses,
-                                       xmlSchemaWildcardPtr wild,
-                                       xmlSchemaWildcardPtr baseWild)
-{
-    xmlSchemaAttributeUsePtr cur = NULL, bcur;
-    int i, j, found; /* err = 0; */
-    const xmlChar *bEffValue;
-    int effFixed;
-
-    if (uses != NULL) {
-        for (i = 0; i < uses->nbItems; i++) {
-            cur = uses->items[i];
-            found = 0;
-            if (baseUses == NULL)
-                goto not_found;
-            for (j = 0; j < baseUses->nbItems; j++) {
-                bcur = baseUses->items[j];
-                if ((WXS_ATTRUSE_DECL_NAME(cur) ==
-                        WXS_ATTRUSE_DECL_NAME(bcur)) &&
-                    (WXS_ATTRUSE_DECL_TNS(cur) ==
-                        WXS_ATTRUSE_DECL_TNS(bcur)))
-                {
-                    /*
-                    * (2.1) "If there is an attribute use in the {attribute
-                    * uses} of the {base type definition} (call this B) whose
-                    * {attribute declaration} has the same {name} and {target
-                    * namespace}, then  all of the following must be true:"
-                    */
-                    found = 1;
-
-                    if ((cur->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
-                        (bcur->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED))
-                    {
-                        xmlChar *str = NULL;
-                        /*
-                        * (2.1.1) "one of the following must be true:"
-                        * (2.1.1.1) "B's {required} is false."
-                        * (2.1.1.2) "R's {required} is true."
-                        */
-                        xmlSchemaPAttrUseErr4(pctxt,
-                            XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
-                            WXS_ITEM_NODE(item), item, cur,
-                            "The 'optional' attribute use is inconsistent "
-                            "with the corresponding 'required' attribute use of "
-                            "the %s %s",
-                            WXS_ACTION_STR(action),
-                            xmlSchemaGetComponentDesignation(&str, baseItem),
-                            NULL, NULL);
-                        FREE_AND_NULL(str);
-                        /* err = pctxt->err; */
-                    } else if (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt,
-                        WXS_ATTRUSE_TYPEDEF(cur),
-                        WXS_ATTRUSE_TYPEDEF(bcur), 0) != 0)
-                    {
-                        xmlChar *strA = NULL, *strB = NULL, *strC = NULL;
-
-                        /*
-                        * SPEC (2.1.2) "R's {attribute declaration}'s
-                        * {type definition} must be validly derived from
-                        * B's {type definition} given the empty set as
-                        * defined in Type Derivation OK (Simple) ($3.14.6)."
-                        */
-                        xmlSchemaPAttrUseErr4(pctxt,
-                            XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
-                            WXS_ITEM_NODE(item), item, cur,
-                            "The attribute declaration's %s "
-                            "is not validly derived from "
-                            "the corresponding %s of the "
-                            "attribute declaration in the %s %s",
-                            xmlSchemaGetComponentDesignation(&strA,
-                                WXS_ATTRUSE_TYPEDEF(cur)),
-                            xmlSchemaGetComponentDesignation(&strB,
-                                WXS_ATTRUSE_TYPEDEF(bcur)),
-                            WXS_ACTION_STR(action),
-                            xmlSchemaGetComponentDesignation(&strC, baseItem));
-                            /* xmlSchemaGetComponentDesignation(&str, baseItem), */
-                        FREE_AND_NULL(strA);
-                        FREE_AND_NULL(strB);
-                        FREE_AND_NULL(strC);
-                        /* err = pctxt->err; */
-                    } else {
-                        /*
-                        * 2.1.3 [Definition:]  Let the effective value
-                        * constraint of an attribute use be its {value
-                        * constraint}, if present, otherwise its {attribute
-                        * declaration}'s {value constraint} .
-                        */
-                        xmlSchemaGetEffectiveValueConstraint(bcur,
-                            &effFixed, &bEffValue, NULL);
-                        /*
-                        * 2.1.3 ... one of the following must be true
-                        *
-                        * 2.1.3.1 B's `effective value constraint` is
-                        * `absent` or default.
-                        */
-                        if ((bEffValue != NULL) &&
-                            (effFixed == 1)) {
-                            const xmlChar *rEffValue = NULL;
-
-                            xmlSchemaGetEffectiveValueConstraint(bcur,
-                                &effFixed, &rEffValue, NULL);
-                            /*
-                            * 2.1.3.2 R's `effective value constraint` is
-                            * fixed with the same string as B's.
-                            * MAYBE TODO: Compare the computed values.
-                            *       Hmm, it says "same string" so
-                            *       string-equality might really be sufficient.
-                            */
-                            if ((effFixed == 0) ||
-                                (! WXS_ARE_DEFAULT_STR_EQUAL(rEffValue, bEffValue)))
-                            {
-                                xmlChar *str = NULL;
-
-                                xmlSchemaPAttrUseErr4(pctxt,
-                                    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
-                                    WXS_ITEM_NODE(item), item, cur,
-                                    "The effective value constraint of the "
-                                    "attribute use is inconsistent with "
-                                    "its correspondent in the %s %s",
-                                    WXS_ACTION_STR(action),
-                                    xmlSchemaGetComponentDesignation(&str,
-                                        baseItem),
-                                    NULL, NULL);
-                                FREE_AND_NULL(str);
-                                /* err = pctxt->err; */
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-not_found:
-            if (!found) {
-                /*
-                * (2.2) "otherwise the {base type definition} must have an
-                * {attribute wildcard} and the {target namespace} of the
-                * R's {attribute declaration} must be `valid` with respect
-                * to that wildcard, as defined in Wildcard allows Namespace
-                * Name ($3.10.4)."
-                */
-                if ((baseWild == NULL) ||
-                    (xmlSchemaCheckCVCWildcardNamespace(baseWild,
-                    (WXS_ATTRUSE_DECL(cur))->targetNamespace) != 0))
-                {
-                    xmlChar *str = NULL;
-
-                    xmlSchemaPAttrUseErr4(pctxt,
-                        XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
-                        WXS_ITEM_NODE(item), item, cur,
-                        "Neither a matching attribute use, "
-                        "nor a matching wildcard exists in the %s %s",
-                        WXS_ACTION_STR(action),
-                        xmlSchemaGetComponentDesignation(&str, baseItem),
-                        NULL, NULL);
-                    FREE_AND_NULL(str);
-                    /* err = pctxt->err; */
-                }
-            }
-        }
-    }
-    /*
-    * SPEC derivation-ok-restriction (3):
-    * (3) "For each attribute use in the {attribute uses} of the {base type
-    * definition} whose {required} is true, there must be an attribute
-    * use with an {attribute declaration} with the same {name} and
-    * {target namespace} as its {attribute declaration} in the {attribute
-    * uses} of the complex type definition itself whose {required} is true.
-    */
-    if (baseUses != NULL) {
-        for (j = 0; j < baseUses->nbItems; j++) {
-            bcur = baseUses->items[j];
-            if (bcur->occurs != XML_SCHEMAS_ATTR_USE_REQUIRED)
-                continue;
-            found = 0;
-            if (uses != NULL) {
-                for (i = 0; i < uses->nbItems; i++) {
-                    cur = uses->items[i];
-                    if ((WXS_ATTRUSE_DECL_NAME(cur) ==
-                        WXS_ATTRUSE_DECL_NAME(bcur)) &&
-                        (WXS_ATTRUSE_DECL_TNS(cur) ==
-                        WXS_ATTRUSE_DECL_TNS(bcur))) {
-                        found = 1;
-                        break;
-                    }
-                }
-            }
-            if (!found) {
-                xmlChar *strA = NULL, *strB = NULL;
-
-                xmlSchemaCustomErr4(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
-                    NULL, item,
-                    "A matching attribute use for the "
-                    "'required' %s of the %s %s is missing",
-                    xmlSchemaGetComponentDesignation(&strA, bcur),
-                    WXS_ACTION_STR(action),
-                    xmlSchemaGetComponentDesignation(&strB, baseItem),
-                    NULL);
-                FREE_AND_NULL(strA);
-                FREE_AND_NULL(strB);
-            }
-        }
-    }
-    /*
-    * derivation-ok-restriction (4)
-    */
-    if (wild != NULL) {
-        /*
-        * (4) "If there is an {attribute wildcard}, all of the
-        * following must be true:"
-        */
-        if (baseWild == NULL) {
-            xmlChar *str = NULL;
-
-            /*
-            * (4.1) "The {base type definition} must also have one."
-            */
-            xmlSchemaCustomErr4(ACTXT_CAST pctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
-                NULL, item,
-                "The %s has an attribute wildcard, "
-                "but the %s %s '%s' does not have one",
-                WXS_ITEM_TYPE_NAME(item),
-                WXS_ACTION_STR(action),
-                WXS_ITEM_TYPE_NAME(baseItem),
-                xmlSchemaGetComponentQName(&str, baseItem));
-            FREE_AND_NULL(str);
-            return(pctxt->err);
-        } else if ((baseWild->any == 0) &&
-                xmlSchemaCheckCOSNSSubset(wild, baseWild))
-        {
-            xmlChar *str = NULL;
-            /*
-            * (4.2) "The complex type definition's {attribute wildcard}'s
-            * {namespace constraint} must be a subset of the {base type
-            * definition}'s {attribute wildcard}'s {namespace constraint},
-            * as defined by Wildcard Subset ($3.10.6)."
-            */
-            xmlSchemaCustomErr4(ACTXT_CAST pctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
-                NULL, item,
-                "The attribute wildcard is not a valid "
-                "subset of the wildcard in the %s %s '%s'",
-                WXS_ACTION_STR(action),
-                WXS_ITEM_TYPE_NAME(baseItem),
-                xmlSchemaGetComponentQName(&str, baseItem),
-                NULL);
-            FREE_AND_NULL(str);
-            return(pctxt->err);
-        }
-        /* 4.3 Unless the {base type definition} is the `ur-type
-        * definition`, the complex type definition's {attribute
-        * wildcard}'s {process contents} must be identical to or
-        * stronger than the {base type definition}'s {attribute
-        * wildcard}'s {process contents}, where strict is stronger
-        * than lax is stronger than skip.
-        */
-        if ((! WXS_IS_ANYTYPE(baseItem)) &&
-            (wild->processContents < baseWild->processContents)) {
-            xmlChar *str = NULL;
-            xmlSchemaCustomErr4(ACTXT_CAST pctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
-                NULL, baseItem,
-                "The {process contents} of the attribute wildcard is "
-                "weaker than the one in the %s %s '%s'",
-                WXS_ACTION_STR(action),
-                WXS_ITEM_TYPE_NAME(baseItem),
-                xmlSchemaGetComponentQName(&str, baseItem),
-                NULL);
-            FREE_AND_NULL(str)
-                return(pctxt->err);
-        }
-    }
-    return(0);
-}
-
-
-static int
-xmlSchemaExpandAttributeGroupRefs(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaBasicItemPtr item,
-                                  xmlSchemaWildcardPtr *completeWild,
-                                  xmlSchemaItemListPtr list,
-                                  xmlSchemaItemListPtr prohibs);
-/**
- * xmlSchemaFixupTypeAttributeUses:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- *
- * Builds the wildcard and the attribute uses on the given complex type.
- * Returns -1 if an internal error occurs, 0 otherwise.
- *
- * ATTENTION TODO: Experimantally this uses pointer comparisons for
- * strings, so recheck this if we start to hardcode some schemata, since
- * they might not be in the same dict.
- * NOTE: It is allowed to "extend" the xs:anyType type.
- */
-static int
-xmlSchemaFixupTypeAttributeUses(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr baseType = NULL;
-    xmlSchemaAttributeUsePtr use;
-    xmlSchemaItemListPtr uses, baseUses, prohibs = NULL;
-
-    if (type->baseType == NULL) {
-        PERROR_INT("xmlSchemaFixupTypeAttributeUses",
-            "no base type");
-        return (-1);
-    }
-    baseType = type->baseType;
-    if (WXS_IS_TYPE_NOT_FIXED(baseType))
-        if (xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt) == -1)
-            return(-1);
-
-    uses = type->attrUses;
-    baseUses = baseType->attrUses;
-    /*
-    * Expand attribute group references. And build the 'complete'
-    * wildcard, i.e. intersect multiple wildcards.
-    * Move attribute prohibitions into a separate list.
-    */
-    if (uses != NULL) {
-        if (WXS_IS_RESTRICTION(type)) {
-            /*
-            * This one will transfer all attr. prohibitions
-            * into pctxt->attrProhibs.
-            */
-            if (xmlSchemaExpandAttributeGroupRefs(pctxt,
-                WXS_BASIC_CAST type, &(type->attributeWildcard), uses,
-                pctxt->attrProhibs) == -1)
-            {
-                PERROR_INT("xmlSchemaFixupTypeAttributeUses",
-                "failed to expand attributes");
-            }
-            if (pctxt->attrProhibs->nbItems != 0)
-                prohibs = pctxt->attrProhibs;
-        } else {
-            if (xmlSchemaExpandAttributeGroupRefs(pctxt,
-                WXS_BASIC_CAST type, &(type->attributeWildcard), uses,
-                NULL) == -1)
-            {
-                PERROR_INT("xmlSchemaFixupTypeAttributeUses",
-                "failed to expand attributes");
-            }
-        }
-    }
-    /*
-    * Inherit the attribute uses of the base type.
-    */
-    if (baseUses != NULL) {
-        int i, j;
-        xmlSchemaAttributeUseProhibPtr pro;
-
-        if (WXS_IS_RESTRICTION(type)) {
-            int usesCount;
-            xmlSchemaAttributeUsePtr tmp;
-
-            if (uses != NULL)
-                usesCount = uses->nbItems;
-            else
-                usesCount = 0;
-
-            /* Restriction. */
-            for (i = 0; i < baseUses->nbItems; i++) {
-                use = baseUses->items[i];
-                if (prohibs) {
-                    /*
-                    * Filter out prohibited uses.
-                    */
-                    for (j = 0; j < prohibs->nbItems; j++) {
-                        pro = prohibs->items[j];
-                        if ((WXS_ATTRUSE_DECL_NAME(use) == pro->name) &&
-                            (WXS_ATTRUSE_DECL_TNS(use) ==
-                                pro->targetNamespace))
-                        {
-                            goto inherit_next;
-                        }
-                    }
-                }
-                if (usesCount) {
-                    /*
-                    * Filter out existing uses.
-                    */
-                    for (j = 0; j < usesCount; j++) {
-                        tmp = uses->items[j];
-                        if ((WXS_ATTRUSE_DECL_NAME(use) ==
-                                WXS_ATTRUSE_DECL_NAME(tmp)) &&
-                            (WXS_ATTRUSE_DECL_TNS(use) ==
-                                WXS_ATTRUSE_DECL_TNS(tmp)))
-                        {
-                            goto inherit_next;
-                        }
-                    }
-                }
-                if (uses == NULL) {
-                    type->attrUses = xmlSchemaItemListCreate();
-                    if (type->attrUses == NULL)
-                        goto exit_failure;
-                    uses = type->attrUses;
-                }
-                xmlSchemaItemListAddSize(uses, 2, use);
-inherit_next: {}
-            }
-        } else {
-            /* Extension. */
-            for (i = 0; i < baseUses->nbItems; i++) {
-                use = baseUses->items[i];
-                if (uses == NULL) {
-                    type->attrUses = xmlSchemaItemListCreate();
-                    if (type->attrUses == NULL)
-                        goto exit_failure;
-                    uses = type->attrUses;
-                }
-                xmlSchemaItemListAddSize(uses, baseUses->nbItems, use);
-            }
-        }
-    }
-    /*
-    * Shrink attr. uses.
-    */
-    if (uses) {
-        if (uses->nbItems == 0) {
-            xmlSchemaItemListFree(uses);
-            type->attrUses = NULL;
-        }
-        /*
-        * TODO: We could shrink the size of the array
-        * to fit the actual number of items.
-        */
-    }
-    /*
-    * Compute the complete wildcard.
-    */
-    if (WXS_IS_EXTENSION(type)) {
-        if (baseType->attributeWildcard != NULL) {
-            /*
-            * (3.2.2.1) "If the `base wildcard` is non-`absent`, then
-            * the appropriate case among the following:"
-            */
-            if (type->attributeWildcard != NULL) {
-                /*
-                * Union the complete wildcard with the base wildcard.
-                * SPEC {attribute wildcard}
-                * (3.2.2.1.2) "otherwise a wildcard whose {process contents}
-                * and {annotation} are those of the `complete wildcard`,
-                * and whose {namespace constraint} is the intensional union
-                * of the {namespace constraint} of the `complete wildcard`
-                * and of the `base wildcard`, as defined in Attribute
-                * Wildcard Union ($3.10.6)."
-                */
-                if (xmlSchemaUnionWildcards(pctxt, type->attributeWildcard,
-                    baseType->attributeWildcard) == -1)
-                    goto exit_failure;
-            } else {
-                /*
-                * (3.2.2.1.1) "If the `complete wildcard` is `absent`,
-                * then the `base wildcard`."
-                */
-                type->attributeWildcard = baseType->attributeWildcard;
-            }
-        } else {
-            /*
-            * (3.2.2.2) "otherwise (the `base wildcard` is `absent`) the
-            * `complete wildcard`"
-            * NOOP
-            */
-        }
-    } else {
-        /*
-        * SPEC {attribute wildcard}
-        * (3.1) "If the <restriction> alternative is chosen, then the
-        * `complete wildcard`;"
-        * NOOP
-        */
-    }
-
-    return (0);
-
-exit_failure:
-    return(-1);
-}
-
-/**
- * xmlSchemaTypeFinalContains:
- * @schema:  the schema
- * @type:  the type definition
- * @final: the final
- *
- * Evaluates if a type definition contains the given "final".
- * This does take "finalDefault" into account as well.
- *
- * Returns 1 if the type does containt the given "final",
- * 0 otherwise.
- */
-static int
-xmlSchemaTypeFinalContains(xmlSchemaTypePtr type, int final)
-{
-    if (type == NULL)
-        return (0);
-    if (type->flags & final)
-        return (1);
-    else
-        return (0);
-}
-
-/**
- * xmlSchemaGetUnionSimpleTypeMemberTypes:
- * @type:  the Union Simple Type
- *
- * Returns a list of member types of @type if existing,
- * returns NULL otherwise.
- */
-static xmlSchemaTypeLinkPtr
-xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type)
-{
-    while ((type != NULL) && (type->type == XML_SCHEMA_TYPE_SIMPLE)) {
-        if (type->memberTypes != NULL)
-            return (type->memberTypes);
-        else
-            type = type->baseType;
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaGetParticleTotalRangeMin:
- * @particle: the particle
- *
- * Schema Component Constraint: Effective Total Range
- * (all and sequence) + (choice)
- *
- * Returns the minimun Effective Total Range.
- */
-static int
-xmlSchemaGetParticleTotalRangeMin(xmlSchemaParticlePtr particle)
-{
-    if ((particle->children == NULL) ||
-        (particle->minOccurs == 0))
-        return (0);
-    if (particle->children->type == XML_SCHEMA_TYPE_CHOICE) {
-        int min = -1, cur;
-        xmlSchemaParticlePtr part =
-            (xmlSchemaParticlePtr) particle->children->children;
-
-        if (part == NULL)
-            return (0);
-        while (part != NULL) {
-            if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
-                (part->children->type == XML_SCHEMA_TYPE_ANY))
-                cur = part->minOccurs;
-            else
-                cur = xmlSchemaGetParticleTotalRangeMin(part);
-            if (cur == 0)
-                return (0);
-            if ((min > cur) || (min == -1))
-                min = cur;
-            part = (xmlSchemaParticlePtr) part->next;
-        }
-        return (particle->minOccurs * min);
-    } else {
-        /* <all> and <sequence> */
-        int sum = 0;
-        xmlSchemaParticlePtr part =
-            (xmlSchemaParticlePtr) particle->children->children;
-
-        if (part == NULL)
-            return (0);
-        do {
-            if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
-                (part->children->type == XML_SCHEMA_TYPE_ANY))
-                sum += part->minOccurs;
-            else
-                sum += xmlSchemaGetParticleTotalRangeMin(part);
-            part = (xmlSchemaParticlePtr) part->next;
-        } while (part != NULL);
-        return (particle->minOccurs * sum);
-    }
-}
-
-#if 0
-/**
- * xmlSchemaGetParticleTotalRangeMax:
- * @particle: the particle
- *
- * Schema Component Constraint: Effective Total Range
- * (all and sequence) + (choice)
- *
- * Returns the maximum Effective Total Range.
- */
-static int
-xmlSchemaGetParticleTotalRangeMax(xmlSchemaParticlePtr particle)
-{
-    if ((particle->children == NULL) ||
-        (particle->children->children == NULL))
-        return (0);
-    if (particle->children->type == XML_SCHEMA_TYPE_CHOICE) {
-        int max = -1, cur;
-        xmlSchemaParticlePtr part =
-            (xmlSchemaParticlePtr) particle->children->children;
-
-        for (; part != NULL; part = (xmlSchemaParticlePtr) part->next) {
-            if (part->children == NULL)
-                continue;
-            if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
-                (part->children->type == XML_SCHEMA_TYPE_ANY))
-                cur = part->maxOccurs;
-            else
-                cur = xmlSchemaGetParticleTotalRangeMax(part);
-            if (cur == UNBOUNDED)
-                return (UNBOUNDED);
-            if ((max < cur) || (max == -1))
-                max = cur;
-        }
-        /* TODO: Handle overflows? */
-        return (particle->maxOccurs * max);
-    } else {
-        /* <all> and <sequence> */
-        int sum = 0, cur;
-        xmlSchemaParticlePtr part =
-            (xmlSchemaParticlePtr) particle->children->children;
-
-        for (; part != NULL; part = (xmlSchemaParticlePtr) part->next) {
-            if (part->children == NULL)
-                continue;
-            if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
-                (part->children->type == XML_SCHEMA_TYPE_ANY))
-                cur = part->maxOccurs;
-            else
-                cur = xmlSchemaGetParticleTotalRangeMax(part);
-            if (cur == UNBOUNDED)
-                return (UNBOUNDED);
-            if ((cur > 0) && (particle->maxOccurs == UNBOUNDED))
-                return (UNBOUNDED);
-            sum += cur;
-        }
-        /* TODO: Handle overflows? */
-        return (particle->maxOccurs * sum);
-    }
-}
-#endif
-
-/**
- * xmlSchemaIsParticleEmptiable:
- * @particle: the particle
- *
- * Schema Component Constraint: Particle Emptiable
- * Checks whether the given particle is emptiable.
- *
- * Returns 1 if emptiable, 0 otherwise.
- */
-static int
-xmlSchemaIsParticleEmptiable(xmlSchemaParticlePtr particle)
-{
-    /*
-    * SPEC (1) "Its {min occurs} is 0."
-    */
-    if ((particle == NULL) || (particle->minOccurs == 0) ||
-        (particle->children == NULL))
-        return (1);
-    /*
-    * SPEC (2) "Its {term} is a group and the minimum part of the
-    * effective total range of that group, [...] is 0."
-    */
-    if (WXS_IS_MODEL_GROUP(particle->children)) {
-        if (xmlSchemaGetParticleTotalRangeMin(particle) == 0)
-            return (1);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaCheckCOSSTDerivedOK:
- * @actxt: a context
- * @type:  the derived simple type definition
- * @baseType:  the base type definition
- * @subset: the subset of ('restriction', ect.)
- *
- * Schema Component Constraint:
- * Type Derivation OK (Simple) (cos-st-derived-OK)
- *
- * Checks wheter @type can be validly
- * derived from @baseType.
- *
- * Returns 0 on success, an positive error code otherwise.
- */
-static int
-xmlSchemaCheckCOSSTDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
-                             xmlSchemaTypePtr type,
-                             xmlSchemaTypePtr baseType,
-                             int subset)
-{
-    /*
-    * 1 They are the same type definition.
-    * TODO: The identy check might have to be more complex than this.
-    */
-    if (type == baseType)
-        return (0);
-    /*
-    * 2.1 restriction is not in the subset, or in the {final}
-    * of its own {base type definition};
-    *
-    * NOTE that this will be used also via "xsi:type".
-    *
-    * TODO: Revise this, it looks strange. How can the "type"
-    * not be fixed or *in* fixing?
-    */
-    if (WXS_IS_TYPE_NOT_FIXED(type))
-        if (xmlSchemaTypeFixup(type, actxt) == -1)
-            return(-1);
-    if (WXS_IS_TYPE_NOT_FIXED(baseType))
-        if (xmlSchemaTypeFixup(baseType, actxt) == -1)
-            return(-1);
-    if ((subset & SUBSET_RESTRICTION) ||
-        (xmlSchemaTypeFinalContains(type->baseType,
-            XML_SCHEMAS_TYPE_FINAL_RESTRICTION))) {
-        return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_1);
-    }
-    /* 2.2 */
-    if (type->baseType == baseType) {
-        /*
-        * 2.2.1 D's `base type definition` is B.
-        */
-        return (0);
-    }
-    /*
-    * 2.2.2 D's `base type definition` is not the `ur-type definition`
-    * and is validly derived from B given the subset, as defined by this
-    * constraint.
-    */
-    if ((! WXS_IS_ANYTYPE(type->baseType)) &&
-        (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
-            baseType, subset) == 0)) {
-        return (0);
-    }
-    /*
-    * 2.2.3 D's {variety} is list or union and B is the `simple ur-type
-    * definition`.
-    */
-    if (WXS_IS_ANY_SIMPLE_TYPE(baseType) &&
-        (WXS_IS_LIST(type) || WXS_IS_UNION(type))) {
-        return (0);
-    }
-    /*
-    * 2.2.4 B's {variety} is union and D is validly derived from a type
-    * definition in B's {member type definitions} given the subset, as
-    * defined by this constraint.
-    *
-    * NOTE: This seems not to involve built-in types, since there is no
-    * built-in Union Simple Type.
-    */
-    if (WXS_IS_UNION(baseType)) {
-        xmlSchemaTypeLinkPtr cur;
-
-        cur = baseType->memberTypes;
-        while (cur != NULL) {
-            if (WXS_IS_TYPE_NOT_FIXED(cur->type))
-                if (xmlSchemaTypeFixup(cur->type, actxt) == -1)
-                    return(-1);
-            if (xmlSchemaCheckCOSSTDerivedOK(actxt,
-                    type, cur->type, subset) == 0)
-            {
-                /*
-                * It just has to be validly derived from at least one
-                * member-type.
-                */
-                return (0);
-            }
-            cur = cur->next;
-        }
-    }
-    return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_2);
-}
-
-/**
- * xmlSchemaCheckTypeDefCircularInternal:
- * @pctxt:  the schema parser context
- * @ctxtType:  the type definition
- * @ancestor: an ancestor of @ctxtType
- *
- * Checks st-props-correct (2) + ct-props-correct (3).
- * Circular type definitions are not allowed.
- *
- * Returns XML_SCHEMAP_ST_PROPS_CORRECT_2 if the given type is
- * circular, 0 otherwise.
- */
-static int
-xmlSchemaCheckTypeDefCircularInternal(xmlSchemaParserCtxtPtr pctxt,
-                           xmlSchemaTypePtr ctxtType,
-                           xmlSchemaTypePtr ancestor)
-{
-    int ret;
-
-    if ((ancestor == NULL) || (ancestor->type == XML_SCHEMA_TYPE_BASIC))
-        return (0);
-
-    if (ctxtType == ancestor) {
-        xmlSchemaPCustomErr(pctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_2,
-            WXS_BASIC_CAST ctxtType, WXS_ITEM_NODE(ctxtType),
-            "The definition is circular", NULL);
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_2);
-    }
-    if (ancestor->flags & XML_SCHEMAS_TYPE_MARKED) {
-        /*
-        * Avoid inifinite recursion on circular types not yet checked.
-        */
-        return (0);
-    }
-    ancestor->flags |= XML_SCHEMAS_TYPE_MARKED;
-    ret = xmlSchemaCheckTypeDefCircularInternal(pctxt, ctxtType,
-        ancestor->baseType);
-    ancestor->flags ^= XML_SCHEMAS_TYPE_MARKED;
-    return (ret);
-}
-
-/**
- * xmlSchemaCheckTypeDefCircular:
- * @item:  the complex/simple type definition
- * @ctxt:  the parser context
- * @name:  the name
- *
- * Checks for circular type definitions.
- */
-static void
-xmlSchemaCheckTypeDefCircular(xmlSchemaTypePtr item,
-                              xmlSchemaParserCtxtPtr ctxt)
-{
-    if ((item == NULL) ||
-        (item->type == XML_SCHEMA_TYPE_BASIC) ||
-        (item->baseType == NULL))
-        return;
-    xmlSchemaCheckTypeDefCircularInternal(ctxt, item,
-        item->baseType);
-}
-
-/*
-* Simple Type Definition Representation OK (src-simple-type) 4
-*
-* "4 Circular union type definition is disallowed. That is, if the
-* <union> alternative is chosen, there must not be any entries in the
-* memberTypes [attribute] at any depth which resolve to the component
-* corresponding to the <simpleType>."
-*
-* Note that this should work on the *representation* of a component,
-* thus assumes any union types in the member types not being yet
-* substituted. At this stage we need the variety of the types
-* to be already computed.
-*/
-static int
-xmlSchemaCheckUnionTypeDefCircularRecur(xmlSchemaParserCtxtPtr pctxt,
-                                        xmlSchemaTypePtr ctxType,
-                                        xmlSchemaTypeLinkPtr members)
-{
-    xmlSchemaTypeLinkPtr member;
-    xmlSchemaTypePtr memberType;
-
-    member = members;
-    while (member != NULL) {
-        memberType = member->type;
-        while ((memberType != NULL) &&
-            (memberType->type != XML_SCHEMA_TYPE_BASIC)) {
-            if (memberType == ctxType) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
-                    WXS_BASIC_CAST ctxType, NULL,
-                    "The union type definition is circular", NULL);
-                return (XML_SCHEMAP_SRC_SIMPLE_TYPE_4);
-            }
-            if ((WXS_IS_UNION(memberType)) &&
-                ((memberType->flags & XML_SCHEMAS_TYPE_MARKED) == 0))
-            {
-                int res;
-                memberType->flags |= XML_SCHEMAS_TYPE_MARKED;
-                res = xmlSchemaCheckUnionTypeDefCircularRecur(pctxt,
-                    ctxType,
-                    xmlSchemaGetUnionSimpleTypeMemberTypes(memberType));
-                memberType->flags ^= XML_SCHEMAS_TYPE_MARKED;
-                if (res != 0)
-                    return(res);
-            }
-            memberType = memberType->baseType;
-        }
-        member = member->next;
-    }
-    return(0);
-}
-
-static int
-xmlSchemaCheckUnionTypeDefCircular(xmlSchemaParserCtxtPtr pctxt,
-                                   xmlSchemaTypePtr type)
-{
-    if (! WXS_IS_UNION(type))
-        return(0);
-    return(xmlSchemaCheckUnionTypeDefCircularRecur(pctxt, type,
-        type->memberTypes));
-}
-
-/**
- * xmlSchemaResolveTypeReferences:
- * @item:  the complex/simple type definition
- * @ctxt:  the parser context
- * @name:  the name
- *
- * Resolvese type definition references
- */
-static void
-xmlSchemaResolveTypeReferences(xmlSchemaTypePtr typeDef,
-                         xmlSchemaParserCtxtPtr ctxt)
-{
-    if (typeDef == NULL)
-        return;
-
-    /*
-    * Resolve the base type.
-    */
-    if (typeDef->baseType == NULL) {
-        typeDef->baseType = xmlSchemaGetType(ctxt->schema,
-            typeDef->base, typeDef->baseNs);
-        if (typeDef->baseType == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST typeDef, typeDef->node,
-                "base", typeDef->base, typeDef->baseNs,
-                XML_SCHEMA_TYPE_SIMPLE, NULL);
-            return;
-        }
-    }
-    if (WXS_IS_SIMPLE(typeDef)) {
-        if (WXS_IS_UNION(typeDef)) {
-            /*
-            * Resolve the memberTypes.
-            */
-            xmlSchemaResolveUnionMemberTypes(ctxt, typeDef);
-            return;
-        } else if (WXS_IS_LIST(typeDef)) {
-            /*
-            * Resolve the itemType.
-            */
-            if ((typeDef->subtypes == NULL) && (typeDef->base != NULL)) {
-
-                typeDef->subtypes = xmlSchemaGetType(ctxt->schema,
-                    typeDef->base, typeDef->baseNs);
-
-                if ((typeDef->subtypes == NULL) ||
-                    (! WXS_IS_SIMPLE(typeDef->subtypes)))
-                {
-                    typeDef->subtypes = NULL;
-                    xmlSchemaPResCompAttrErr(ctxt,
-                        XML_SCHEMAP_SRC_RESOLVE,
-                        WXS_BASIC_CAST typeDef, typeDef->node,
-                        "itemType", typeDef->base, typeDef->baseNs,
-                        XML_SCHEMA_TYPE_SIMPLE, NULL);
-                }
-            }
-            return;
-        }
-    }
-    /*
-    * The ball of letters below means, that if we have a particle
-    * which has a QName-helper component as its {term}, we want
-    * to resolve it...
-    */
-    else if ((WXS_TYPE_CONTENTTYPE(typeDef) != NULL) &&
-        ((WXS_TYPE_CONTENTTYPE(typeDef))->type ==
-            XML_SCHEMA_TYPE_PARTICLE) &&
-        (WXS_TYPE_PARTICLE_TERM(typeDef) != NULL) &&
-        ((WXS_TYPE_PARTICLE_TERM(typeDef))->type ==
-            XML_SCHEMA_EXTRA_QNAMEREF))
-    {
-        xmlSchemaQNameRefPtr ref =
-            WXS_QNAME_CAST WXS_TYPE_PARTICLE_TERM(typeDef);
-        xmlSchemaModelGroupDefPtr groupDef;
-
-        /*
-        * URGENT TODO: Test this.
-        */
-        WXS_TYPE_PARTICLE_TERM(typeDef) = NULL;
-        /*
-        * Resolve the MG definition reference.
-        */
-        groupDef =
-            WXS_MODEL_GROUPDEF_CAST xmlSchemaGetNamedComponent(ctxt->schema,
-                ref->itemType, ref->name, ref->targetNamespace);
-        if (groupDef == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
-                NULL, WXS_ITEM_NODE(WXS_TYPE_PARTICLE(typeDef)),
-                "ref", ref->name, ref->targetNamespace, ref->itemType,
-                NULL);
-            /* Remove the particle. */
-            WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
-        } else if (WXS_MODELGROUPDEF_MODEL(groupDef) == NULL)
-            /* Remove the particle. */
-            WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
-        else {
-            /*
-            * Assign the MG definition's {model group} to the
-            * particle's {term}.
-            */
-            WXS_TYPE_PARTICLE_TERM(typeDef) = WXS_MODELGROUPDEF_MODEL(groupDef);
-
-            if (WXS_MODELGROUPDEF_MODEL(groupDef)->type == XML_SCHEMA_TYPE_ALL) {
-                /*
-                * SPEC cos-all-limited (1.2)
-                * "1.2 the {term} property of a particle with
-                * {max occurs}=1 which is part of a pair which constitutes
-                * the {content type} of a complex type definition."
-                */
-                if ((WXS_TYPE_PARTICLE(typeDef))->maxOccurs != 1) {
-                    xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                        /* TODO: error code */
-                        XML_SCHEMAP_COS_ALL_LIMITED,
-                        WXS_ITEM_NODE(WXS_TYPE_PARTICLE(typeDef)), NULL,
-                        "The particle's {max occurs} must be 1, since the "
-                        "reference resolves to an 'all' model group",
-                        NULL, NULL);
-                }
-            }
-        }
-    }
-}
-
-
-
-/**
- * xmlSchemaCheckSTPropsCorrect:
- * @ctxt:  the schema parser context
- * @type:  the simple type definition
- *
- * Checks st-props-correct.
- *
- * Returns 0 if the properties are correct,
- * if not, a positive error code and -1 on internal
- * errors.
- */
-static int
-xmlSchemaCheckSTPropsCorrect(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr baseType = type->baseType;
-    xmlChar *str = NULL;
-
-    /* STATE: error funcs converted. */
-    /*
-    * Schema Component Constraint: Simple Type Definition Properties Correct
-    *
-    * NOTE: This is somehow redundant, since we actually built a simple type
-    * to have all the needed information; this acts as an self test.
-    */
-    /* Base type: If the datatype has been `derived` by `restriction`
-    * then the Simple Type Definition component from which it is `derived`,
-    * otherwise the Simple Type Definition for anySimpleType ($4.1.6).
-    */
-    if (baseType == NULL) {
-        /*
-        * TODO: Think about: "modulo the impact of Missing
-        * Sub-components ($5.3)."
-        */
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_1,
-            WXS_BASIC_CAST type, NULL,
-            "No base type existent", NULL);
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
-
-    }
-    if (! WXS_IS_SIMPLE(baseType)) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_1,
-            WXS_BASIC_CAST type, NULL,
-            "The base type '%s' is not a simple type",
-            xmlSchemaGetComponentQName(&str, baseType));
-        FREE_AND_NULL(str)
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
-    }
-    if ((WXS_IS_LIST(type) || WXS_IS_UNION(type)) &&
-        (WXS_IS_RESTRICTION(type) == 0) &&
-        ((! WXS_IS_ANY_SIMPLE_TYPE(baseType)) &&
-         (baseType->type != XML_SCHEMA_TYPE_SIMPLE))) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_1,
-            WXS_BASIC_CAST type, NULL,
-            "A type, derived by list or union, must have "
-            "the simple ur-type definition as base type, not '%s'",
-            xmlSchemaGetComponentQName(&str, baseType));
-        FREE_AND_NULL(str)
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
-    }
-    /*
-    * Variety: One of {atomic, list, union}.
-    */
-    if ((! WXS_IS_ATOMIC(type)) && (! WXS_IS_UNION(type)) &&
-        (! WXS_IS_LIST(type))) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_1,
-            WXS_BASIC_CAST type, NULL,
-            "The variety is absent", NULL);
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
-    }
-    /* TODO: Finish this. Hmm, is this finished? */
-
-    /*
-    * 3 The {final} of the {base type definition} must not contain restriction.
-    */
-    if (xmlSchemaTypeFinalContains(baseType,
-        XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_ST_PROPS_CORRECT_3,
-            WXS_BASIC_CAST type, NULL,
-            "The 'final' of its base type '%s' must not contain "
-            "'restriction'",
-            xmlSchemaGetComponentQName(&str, baseType));
-        FREE_AND_NULL(str)
-        return (XML_SCHEMAP_ST_PROPS_CORRECT_3);
-    }
-
-    /*
-    * 2 All simple type definitions must be derived ultimately from the `simple
-    * ur-type definition` (so circular definitions are disallowed). That is, it
-    * must be possible to reach a built-in primitive datatype or the `simple
-    * ur-type definition` by repeatedly following the {base type definition}.
-    *
-    * NOTE: this is done in xmlSchemaCheckTypeDefCircular().
-    */
-    return (0);
-}
-
-/**
- * xmlSchemaCheckCOSSTRestricts:
- * @ctxt:  the schema parser context
- * @type:  the simple type definition
- *
- * Schema Component Constraint:
- * Derivation Valid (Restriction, Simple) (cos-st-restricts)
-
- * Checks if the given @type (simpleType) is derived validly by restriction.
- * STATUS:
- *
- * Returns -1 on internal errors, 0 if the type is validly derived,
- * a positive error code otherwise.
- */
-static int
-xmlSchemaCheckCOSSTRestricts(xmlSchemaParserCtxtPtr pctxt,
-                             xmlSchemaTypePtr type)
-{
-    xmlChar *str = NULL;
-
-    if (type->type != XML_SCHEMA_TYPE_SIMPLE) {
-        PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-            "given type is not a user-derived simpleType");
-        return (-1);
-    }
-
-    if (WXS_IS_ATOMIC(type)) {
-        xmlSchemaTypePtr primitive;
-        /*
-        * 1.1 The {base type definition} must be an atomic simple
-        * type definition or a built-in primitive datatype.
-        */
-        if (! WXS_IS_ATOMIC(type->baseType)) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
-                WXS_BASIC_CAST type, NULL,
-                "The base type '%s' is not an atomic simple type",
-                xmlSchemaGetComponentQName(&str, type->baseType));
-            FREE_AND_NULL(str)
-            return (XML_SCHEMAP_COS_ST_RESTRICTS_1_1);
-        }
-        /* 1.2 The {final} of the {base type definition} must not contain
-        * restriction.
-        */
-        /* OPTIMIZE TODO : This is already done in xmlSchemaCheckStPropsCorrect */
-        if (xmlSchemaTypeFinalContains(type->baseType,
-            XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
-                WXS_BASIC_CAST type, NULL,
-                "The final of its base type '%s' must not contain 'restriction'",
-                xmlSchemaGetComponentQName(&str, type->baseType));
-            FREE_AND_NULL(str)
-            return (XML_SCHEMAP_COS_ST_RESTRICTS_1_2);
-        }
-
-        /*
-        * 1.3.1 DF must be an allowed constraining facet for the {primitive
-        * type definition}, as specified in the appropriate subsection of 3.2
-        * Primitive datatypes.
-        */
-        if (type->facets != NULL) {
-            xmlSchemaFacetPtr facet;
-            int ok = 1;
-
-            primitive = xmlSchemaGetPrimitiveType(type);
-            if (primitive == NULL) {
-                PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-                    "failed to get primitive type");
-                return (-1);
-            }
-            facet = type->facets;
-            do {
-                if (xmlSchemaIsBuiltInTypeFacet(primitive, facet->type) == 0) {
-                    ok = 0;
-                    xmlSchemaPIllegalFacetAtomicErr(pctxt,
-                        XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
-                        type, primitive, facet);
-                }
-                facet = facet->next;
-            } while (facet != NULL);
-            if (ok == 0)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1);
-        }
-        /*
-        * SPEC (1.3.2) "If there is a facet of the same kind in the {facets}
-        * of the {base type definition} (call this BF),then the DF's {value}
-        * must be a valid restriction of BF's {value} as defined in
-        * [XML Schemas: Datatypes]."
-        *
-        * NOTE (1.3.2) Facet derivation constraints are currently handled in
-        * xmlSchemaDeriveAndValidateFacets()
-        */
-    } else if (WXS_IS_LIST(type)) {
-        xmlSchemaTypePtr itemType = NULL;
-
-        itemType = type->subtypes;
-        if ((itemType == NULL) || (! WXS_IS_SIMPLE(itemType))) {
-            PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-                "failed to evaluate the item type");
-            return (-1);
-        }
-        if (WXS_IS_TYPE_NOT_FIXED(itemType))
-            xmlSchemaTypeFixup(itemType, ACTXT_CAST pctxt);
-        /*
-        * 2.1 The {item type definition} must have a {variety} of atomic or
-        * union (in which case all the {member type definitions}
-        * must be atomic).
-        */
-        if ((! WXS_IS_ATOMIC(itemType)) &&
-            (! WXS_IS_UNION(itemType))) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
-                WXS_BASIC_CAST type, NULL,
-                "The item type '%s' does not have a variety of atomic or union",
-                xmlSchemaGetComponentQName(&str, itemType));
-            FREE_AND_NULL(str)
-            return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
-        } else if (WXS_IS_UNION(itemType)) {
-            xmlSchemaTypeLinkPtr member;
-
-            member = itemType->memberTypes;
-            while (member != NULL) {
-                if (! WXS_IS_ATOMIC(member->type)) {
-                    xmlSchemaPCustomErr(pctxt,
-                        XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
-                        WXS_BASIC_CAST type, NULL,
-                        "The item type is a union type, but the "
-                        "member type '%s' of this item type is not atomic",
-                        xmlSchemaGetComponentQName(&str, member->type));
-                    FREE_AND_NULL(str)
-                    return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
-                }
-                member = member->next;
-            }
-        }
-
-        if (WXS_IS_ANY_SIMPLE_TYPE(type->baseType)) {
-            xmlSchemaFacetPtr facet;
-            /*
-            * This is the case if we have: <simpleType><list ..
-            */
-            /*
-            * 2.3.1
-            * 2.3.1.1 The {final} of the {item type definition} must not
-            * contain list.
-            */
-            if (xmlSchemaTypeFinalContains(itemType,
-                XML_SCHEMAS_TYPE_FINAL_LIST)) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "The final of its item type '%s' must not contain 'list'",
-                    xmlSchemaGetComponentQName(&str, itemType));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1);
-            }
-            /*
-            * 2.3.1.2 The {facets} must only contain the whiteSpace
-            * facet component.
-            * OPTIMIZE TODO: the S4S already disallows any facet
-            * to be specified.
-            */
-            if (type->facets != NULL) {
-                facet = type->facets;
-                do {
-                    if (facet->type != XML_SCHEMA_FACET_WHITESPACE) {
-                        xmlSchemaPIllegalFacetListUnionErr(pctxt,
-                            XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
-                            type, facet);
-                        return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2);
-                    }
-                    facet = facet->next;
-                } while (facet != NULL);
-            }
-            /*
-            * MAYBE TODO: (Hmm, not really) Datatypes states:
-            * A `list` datatype can be `derived` from an `atomic` datatype
-            * whose `lexical space` allows space (such as string or anyURI)or
-            * a `union` datatype any of whose {member type definitions}'s
-            * `lexical space` allows space.
-            */
-        } else {
-            /*
-            * This is the case if we have: <simpleType><restriction ...
-            * I.e. the variety of "list" is inherited.
-            */
-            /*
-            * 2.3.2
-            * 2.3.2.1 The {base type definition} must have a {variety} of list.
-            */
-            if (! WXS_IS_LIST(type->baseType)) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "The base type '%s' must be a list type",
-                    xmlSchemaGetComponentQName(&str, type->baseType));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1);
-            }
-            /*
-            * 2.3.2.2 The {final} of the {base type definition} must not
-            * contain restriction.
-            */
-            if (xmlSchemaTypeFinalContains(type->baseType,
-                XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
-                    WXS_BASIC_CAST type, NULL,
-                    "The 'final' of the base type '%s' must not contain 'restriction'",
-                    xmlSchemaGetComponentQName(&str, type->baseType));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2);
-            }
-            /*
-            * 2.3.2.3 The {item type definition} must be validly derived
-            * from the {base type definition}'s {item type definition} given
-            * the empty set, as defined in Type Derivation OK (Simple) ($3.14.6).
-            */
-            {
-                xmlSchemaTypePtr baseItemType;
-
-                baseItemType = type->baseType->subtypes;
-                if ((baseItemType == NULL) || (! WXS_IS_SIMPLE(baseItemType))) {
-                    PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-                        "failed to eval the item type of a base type");
-                    return (-1);
-                }
-                if ((itemType != baseItemType) &&
-                    (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt, itemType,
-                        baseItemType, 0) != 0)) {
-                    xmlChar *strBIT = NULL, *strBT = NULL;
-                    xmlSchemaPCustomErrExt(pctxt,
-                        XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
-                        WXS_BASIC_CAST type, NULL,
-                        "The item type '%s' is not validly derived from "
-                        "the item type '%s' of the base type '%s'",
-                        xmlSchemaGetComponentQName(&str, itemType),
-                        xmlSchemaGetComponentQName(&strBIT, baseItemType),
-                        xmlSchemaGetComponentQName(&strBT, type->baseType));
-
-                    FREE_AND_NULL(str)
-                    FREE_AND_NULL(strBIT)
-                    FREE_AND_NULL(strBT)
-                    return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3);
-                }
-            }
-
-            if (type->facets != NULL) {
-                xmlSchemaFacetPtr facet;
-                int ok = 1;
-                /*
-                * 2.3.2.4 Only length, minLength, maxLength, whiteSpace, pattern
-                * and enumeration facet components are allowed among the {facets}.
-                */
-                facet = type->facets;
-                do {
-                    switch (facet->type) {
-                        case XML_SCHEMA_FACET_LENGTH:
-                        case XML_SCHEMA_FACET_MINLENGTH:
-                        case XML_SCHEMA_FACET_MAXLENGTH:
-                        case XML_SCHEMA_FACET_WHITESPACE:
-                            /*
-                            * TODO: 2.5.1.2 List datatypes
-                            * The value of `whiteSpace` is fixed to the value collapse.
-                            */
-                        case XML_SCHEMA_FACET_PATTERN:
-                        case XML_SCHEMA_FACET_ENUMERATION:
-                            break;
-                        default: {
-                            xmlSchemaPIllegalFacetListUnionErr(pctxt,
-                                XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
-                                type, facet);
-                            /*
-                            * We could return, but it's nicer to report all
-                            * invalid facets.
-                            */
-                            ok = 0;
-                        }
-                    }
-                    facet = facet->next;
-                } while (facet != NULL);
-                if (ok == 0)
-                    return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4);
-                /*
-                * SPEC (2.3.2.5) (same as 1.3.2)
-                *
-                * NOTE (2.3.2.5) This is currently done in
-                * xmlSchemaDeriveAndValidateFacets()
-                */
-            }
-        }
-    } else if (WXS_IS_UNION(type)) {
-        /*
-        * 3.1 The {member type definitions} must all have {variety} of
-        * atomic or list.
-        */
-        xmlSchemaTypeLinkPtr member;
-
-        member = type->memberTypes;
-        while (member != NULL) {
-            if (WXS_IS_TYPE_NOT_FIXED(member->type))
-                xmlSchemaTypeFixup(member->type, ACTXT_CAST pctxt);
-
-            if ((! WXS_IS_ATOMIC(member->type)) &&
-                (! WXS_IS_LIST(member->type))) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "The member type '%s' is neither an atomic, nor a list type",
-                    xmlSchemaGetComponentQName(&str, member->type));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_3_1);
-            }
-            member = member->next;
-        }
-        /*
-        * 3.3.1 If the {base type definition} is the `simple ur-type
-        * definition`
-        */
-        if (type->baseType->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) {
-            /*
-            * 3.3.1.1 All of the {member type definitions} must have a
-            * {final} which does not contain union.
-            */
-            member = type->memberTypes;
-            while (member != NULL) {
-                if (xmlSchemaTypeFinalContains(member->type,
-                    XML_SCHEMAS_TYPE_FINAL_UNION)) {
-                    xmlSchemaPCustomErr(pctxt,
-                        XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
-                        WXS_BASIC_CAST type, NULL,
-                        "The 'final' of member type '%s' contains 'union'",
-                        xmlSchemaGetComponentQName(&str, member->type));
-                    FREE_AND_NULL(str)
-                    return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1);
-                }
-                member = member->next;
-            }
-            /*
-            * 3.3.1.2 The {facets} must be empty.
-            */
-            if (type->facetSet != NULL) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
-                    WXS_BASIC_CAST type, NULL,
-                    "No facets allowed", NULL);
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2);
-            }
-        } else {
-            /*
-            * 3.3.2.1 The {base type definition} must have a {variety} of union.
-            * I.e. the variety of "list" is inherited.
-            */
-            if (! WXS_IS_UNION(type->baseType)) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "The base type '%s' is not a union type",
-                    xmlSchemaGetComponentQName(&str, type->baseType));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1);
-            }
-            /*
-            * 3.3.2.2 The {final} of the {base type definition} must not contain restriction.
-            */
-            if (xmlSchemaTypeFinalContains(type->baseType,
-                XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
-                    WXS_BASIC_CAST type, NULL,
-                    "The 'final' of its base type '%s' must not contain 'restriction'",
-                    xmlSchemaGetComponentQName(&str, type->baseType));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2);
-            }
-            /*
-            * 3.3.2.3 The {member type definitions}, in order, must be validly
-            * derived from the corresponding type definitions in the {base
-            * type definition}'s {member type definitions} given the empty set,
-            * as defined in Type Derivation OK (Simple) ($3.14.6).
-            */
-            {
-                xmlSchemaTypeLinkPtr baseMember;
-
-                /*
-                * OPTIMIZE: if the type is restricting, it has no local defined
-                * member types and inherits the member types of the base type;
-                * thus a check for equality can be skipped.
-                */
-                /*
-                * Even worse: I cannot see a scenario where a restricting
-                * union simple type can have other member types as the member
-                * types of it's base type. This check seems not necessary with
-                * respect to the derivation process in libxml2.
-                * But necessary if constructing types with an API.
-                */
-                if (type->memberTypes != NULL) {
-                    member = type->memberTypes;
-                    baseMember = xmlSchemaGetUnionSimpleTypeMemberTypes(type->baseType);
-                    if ((member == NULL) && (baseMember != NULL)) {
-                        PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-                            "different number of member types in base");
-                    }
-                    while (member != NULL) {
-                        if (baseMember == NULL) {
-                            PERROR_INT("xmlSchemaCheckCOSSTRestricts",
-                            "different number of member types in base");
-                        } else if ((member->type != baseMember->type) &&
-                            (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt,
-                                member->type, baseMember->type, 0) != 0)) {
-                            xmlChar *strBMT = NULL, *strBT = NULL;
-
-                            xmlSchemaPCustomErrExt(pctxt,
-                                XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
-                                WXS_BASIC_CAST type, NULL,
-                                "The member type %s is not validly "
-                                "derived from its corresponding member "
-                                "type %s of the base type %s",
-                                xmlSchemaGetComponentQName(&str, member->type),
-                                xmlSchemaGetComponentQName(&strBMT, baseMember->type),
-                                xmlSchemaGetComponentQName(&strBT, type->baseType));
-                            FREE_AND_NULL(str)
-                            FREE_AND_NULL(strBMT)
-                            FREE_AND_NULL(strBT)
-                            return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3);
-                        }
-                        member = member->next;
-                        if (baseMember != NULL)
-                            baseMember = baseMember->next;
-                    }
-                }
-            }
-            /*
-            * 3.3.2.4 Only pattern and enumeration facet components are
-            * allowed among the {facets}.
-            */
-            if (type->facets != NULL) {
-                xmlSchemaFacetPtr facet;
-                int ok = 1;
-
-                facet = type->facets;
-                do {
-                    if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
-                        (facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
-                        xmlSchemaPIllegalFacetListUnionErr(pctxt,
-                                XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
-                                type, facet);
-                        ok = 0;
-                    }
-                    facet = facet->next;
-                } while (facet != NULL);
-                if (ok == 0)
-                    return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4);
-
-            }
-            /*
-            * SPEC (3.3.2.5) (same as 1.3.2)
-            *
-            * NOTE (3.3.2.5) This is currently done in
-            * xmlSchemaDeriveAndValidateFacets()
-            */
-        }
-    }
-
-    return (0);
-}
-
-/**
- * xmlSchemaCheckSRCSimpleType:
- * @ctxt:  the schema parser context
- * @type:  the simple type definition
- *
- * Checks crc-simple-type constraints.
- *
- * Returns 0 if the constraints are satisfied,
- * if not a positive error code and -1 on internal
- * errors.
- */
-#if 0
-static int
-xmlSchemaCheckSRCSimpleType(xmlSchemaParserCtxtPtr ctxt,
-                            xmlSchemaTypePtr type)
-{
-    /*
-    * src-simple-type.1 The corresponding simple type definition, if any,
-    * must satisfy the conditions set out in Constraints on Simple Type
-    * Definition Schema Components ($3.14.6).
-    */
-    if (WXS_IS_RESTRICTION(type)) {
-        /*
-        * src-simple-type.2 "If the <restriction> alternative is chosen,
-        * either it must have a base [attribute] or a <simpleType> among its
-        * [children], but not both."
-        * NOTE: This is checked in the parse function of <restriction>.
-        */
-        /*
-        *
-        */
-    } else if (WXS_IS_LIST(type)) {
-        /* src-simple-type.3 "If the <list> alternative is chosen, either it must have
-        * an itemType [attribute] or a <simpleType> among its [children],
-        * but not both."
-        *
-        * NOTE: This is checked in the parse function of <list>.
-        */
-    } else if (WXS_IS_UNION(type)) {
-        /*
-        * src-simple-type.4 is checked in xmlSchemaCheckUnionTypeDefCircular().
-        */
-    }
-    return (0);
-}
-#endif
-
-static int
-xmlSchemaCreateVCtxtOnPCtxt(xmlSchemaParserCtxtPtr ctxt)
-{
-   if (ctxt->vctxt == NULL) {
-        ctxt->vctxt = xmlSchemaNewValidCtxt(NULL);
-        if (ctxt->vctxt == NULL) {
-            xmlSchemaPErr(ctxt, NULL,
-                XML_SCHEMAP_INTERNAL,
-                "Internal error: xmlSchemaCreateVCtxtOnPCtxt, "
-                "failed to create a temp. validation context.\n",
-                NULL, NULL);
-            return (-1);
-        }
-        /* TODO: Pass user data. */
-        xmlSchemaSetValidErrors(ctxt->vctxt,
-            ctxt->error, ctxt->warning, ctxt->errCtxt);
-        xmlSchemaSetValidStructuredErrors(ctxt->vctxt,
-            ctxt->serror, ctxt->errCtxt);
-    }
-    return (0);
-}
-
-static int
-xmlSchemaVCheckCVCSimpleType(xmlSchemaAbstractCtxtPtr actxt,
-                             xmlNodePtr node,
-                             xmlSchemaTypePtr type,
-                             const xmlChar *value,
-                             xmlSchemaValPtr *retVal,
-                             int fireErrors,
-                             int normalize,
-                             int isNormalized);
-
-/**
- * xmlSchemaParseCheckCOSValidDefault:
- * @pctxt:  the schema parser context
- * @type:  the simple type definition
- * @value: the default value
- * @node: an optional node (the holder of the value)
- *
- * Schema Component Constraint: Element Default Valid (Immediate)
- * (cos-valid-default)
- * This will be used by the parser only. For the validator there's
- * an other version.
- *
- * Returns 0 if the constraints are satisfied,
- * if not, a positive error code and -1 on internal
- * errors.
- */
-static int
-xmlSchemaParseCheckCOSValidDefault(xmlSchemaParserCtxtPtr pctxt,
-                                   xmlNodePtr node,
-                                   xmlSchemaTypePtr type,
-                                   const xmlChar *value,
-                                   xmlSchemaValPtr *val)
-{
-    int ret = 0;
-
-    /*
-    * cos-valid-default:
-    * Schema Component Constraint: Element Default Valid (Immediate)
-    * For a string to be a valid default with respect to a type
-    * definition the appropriate case among the following must be true:
-    */
-    if WXS_IS_COMPLEX(type) {
-        /*
-        * Complex type.
-        *
-        * SPEC (2.1) "its {content type} must be a simple type definition
-        * or mixed."
-        * SPEC (2.2.2) "If the {content type} is mixed, then the {content
-        * type}'s particle must be `emptiable` as defined by
-        * Particle Emptiable ($3.9.6)."
-        */
-        if ((! WXS_HAS_SIMPLE_CONTENT(type)) &&
-            ((! WXS_HAS_MIXED_CONTENT(type)) || (! WXS_EMPTIABLE(type)))) {
-            /* NOTE that this covers (2.2.2) as well. */
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
-                WXS_BASIC_CAST type, type->node,
-                "For a string to be a valid default, the type definition "
-                "must be a simple type or a complex type with mixed content "
-                "and a particle emptiable", NULL);
-            return(XML_SCHEMAP_COS_VALID_DEFAULT_2_1);
-        }
-    }
-    /*
-    * 1 If the type definition is a simple type definition, then the string
-    * must be `valid` with respect to that definition as defined by String
-    * Valid ($3.14.4).
-    *
-    * AND
-    *
-    * 2.2.1 If the {content type} is a simple type definition, then the
-    * string must be `valid` with respect to that simple type definition
-    * as defined by String Valid ($3.14.4).
-    */
-    if (WXS_IS_SIMPLE(type))
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
-            type, value, val, 1, 1, 0);
-    else if (WXS_HAS_SIMPLE_CONTENT(type))
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
-            type->contentTypeDef, value, val, 1, 1, 0);
-    else
-        return (ret);
-
-    if (ret < 0) {
-        PERROR_INT("xmlSchemaParseCheckCOSValidDefault",
-            "calling xmlSchemaVCheckCVCSimpleType()");
-    }
-
-    return (ret);
-}
-
-/**
- * xmlSchemaCheckCTPropsCorrect:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- *.(4.6) Constraints on Complex Type Definition Schema Components
- * Schema Component Constraint:
- * Complex Type Definition Properties Correct (ct-props-correct)
- * STATUS: (seems) complete
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckCTPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
-                             xmlSchemaTypePtr type)
-{
-    /*
-    * TODO: Correct the error code; XML_SCHEMAP_SRC_CT_1 is used temporarily.
-    *
-    * SPEC (1) "The values of the properties of a complex type definition must
-    * be as described in the property tableau in The Complex Type Definition
-    * Schema Component ($3.4.1), modulo the impact of Missing
-    * Sub-components ($5.3)."
-    */
-    if ((type->baseType != NULL) &&
-        (WXS_IS_SIMPLE(type->baseType)) &&
-        (WXS_IS_EXTENSION(type) == 0)) {
-        /*
-        * SPEC (2) "If the {base type definition} is a simple type definition,
-        * the {derivation method} must be extension."
-        */
-        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-            XML_SCHEMAP_SRC_CT_1,
-            NULL, WXS_BASIC_CAST type,
-            "If the base type is a simple type, the derivation method must be "
-            "'extension'", NULL, NULL);
-        return (XML_SCHEMAP_SRC_CT_1);
-    }
-    /*
-    * SPEC (3) "Circular definitions are disallowed, except for the `ur-type
-    * definition`. That is, it must be possible to reach the `ur-type
-    * definition` by repeatedly following the {base type definition}."
-    *
-    * NOTE (3) is done in xmlSchemaCheckTypeDefCircular().
-    */
-    /*
-    * NOTE that (4) and (5) need the following:
-    *   - attribute uses need to be already inherited (apply attr. prohibitions)
-    *   - attribute group references need to be expanded already
-    *   - simple types need to be typefixed already
-    */
-    if (type->attrUses &&
-        (((xmlSchemaItemListPtr) type->attrUses)->nbItems > 1))
-    {
-        xmlSchemaItemListPtr uses = (xmlSchemaItemListPtr) type->attrUses;
-        xmlSchemaAttributeUsePtr use, tmp;
-        int i, j, hasId = 0;
-
-        for (i = uses->nbItems -1; i >= 0; i--) {
-            use = uses->items[i];
-
-            /*
-            * SPEC ct-props-correct
-            * (4) "Two distinct attribute declarations in the
-            * {attribute uses} must not have identical {name}s and
-            * {target namespace}s."
-            */
-            if (i > 0) {
-                for (j = i -1; j >= 0; j--) {
-                    tmp = uses->items[j];
-                    if ((WXS_ATTRUSE_DECL_NAME(use) ==
-                        WXS_ATTRUSE_DECL_NAME(tmp)) &&
-                        (WXS_ATTRUSE_DECL_TNS(use) ==
-                        WXS_ATTRUSE_DECL_TNS(tmp)))
-                    {
-                        xmlChar *str = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            XML_SCHEMAP_AG_PROPS_CORRECT,
-                            NULL, WXS_BASIC_CAST type,
-                            "Duplicate %s",
-                            xmlSchemaGetComponentDesignation(&str, use),
-                            NULL);
-                        FREE_AND_NULL(str);
-                        /*
-                        * Remove the duplicate.
-                        */
-                        if (xmlSchemaItemListRemove(uses, i) == -1)
-                            goto exit_failure;
-                        goto next_use;
-                    }
-                }
-            }
-            /*
-            * SPEC ct-props-correct
-            * (5) "Two distinct attribute declarations in the
-            * {attribute uses} must not have {type definition}s which
-            * are or are derived from ID."
-            */
-            if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
-                if (xmlSchemaIsDerivedFromBuiltInType(
-                    WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
-                {
-                    if (hasId) {
-                        xmlChar *str = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            XML_SCHEMAP_AG_PROPS_CORRECT,
-                            NULL, WXS_BASIC_CAST type,
-                            "There must not exist more than one attribute "
-                            "declaration of type 'xs:ID' "
-                            "(or derived from 'xs:ID'). The %s violates this "
-                            "constraint",
-                            xmlSchemaGetComponentDesignation(&str, use),
-                            NULL);
-                        FREE_AND_NULL(str);
-                        if (xmlSchemaItemListRemove(uses, i) == -1)
-                            goto exit_failure;
-                    }
-
-                    hasId = 1;
-                }
-            }
-next_use: {}
-        }
-    }
-    return (0);
-exit_failure:
-    return(-1);
-}
-
-static int
-xmlSchemaAreEqualTypes(xmlSchemaTypePtr typeA,
-                       xmlSchemaTypePtr typeB)
-{
-    /*
-    * TODO: This should implement component-identity
-    * in the future.
-    */
-    if ((typeA == NULL) || (typeB == NULL))
-        return (0);
-    return (typeA == typeB);
-}
-
-/**
- * xmlSchemaCheckCOSCTDerivedOK:
- * @ctxt:  the schema parser context
- * @type:  the to-be derived complex type definition
- * @baseType:  the base complex type definition
- * @set: the given set
- *
- * Schema Component Constraint:
- * Type Derivation OK (Complex) (cos-ct-derived-ok)
- *
- * STATUS: completed
- *
- * Returns 0 if the constraints are satisfied, or 1
- * if not.
- */
-static int
-xmlSchemaCheckCOSCTDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
-                             xmlSchemaTypePtr type,
-                             xmlSchemaTypePtr baseType,
-                             int set)
-{
-    int equal = xmlSchemaAreEqualTypes(type, baseType);
-    /* TODO: Error codes. */
-    /*
-    * SPEC "For a complex type definition (call it D, for derived)
-    * to be validly derived from a type definition (call this
-    * B, for base) given a subset of {extension, restriction}
-    * all of the following must be true:"
-    */
-    if (! equal) {
-        /*
-        * SPEC (1) "If B and D are not the same type definition, then the
-        * {derivation method} of D must not be in the subset."
-        */
-        if (((set & SUBSET_EXTENSION) && (WXS_IS_EXTENSION(type))) ||
-            ((set & SUBSET_RESTRICTION) && (WXS_IS_RESTRICTION(type))))
-            return (1);
-    } else {
-        /*
-        * SPEC (2.1) "B and D must be the same type definition."
-        */
-        return (0);
-    }
-    /*
-    * SPEC (2.2) "B must be D's {base type definition}."
-    */
-    if (type->baseType == baseType)
-        return (0);
-    /*
-    * SPEC (2.3.1) "D's {base type definition} must not be the `ur-type
-    * definition`."
-    */
-    if (WXS_IS_ANYTYPE(type->baseType))
-        return (1);
-
-    if (WXS_IS_COMPLEX(type->baseType)) {
-        /*
-        * SPEC (2.3.2.1) "If D's {base type definition} is complex, then it
-        * must be validly derived from B given the subset as defined by this
-        * constraint."
-        */
-        return (xmlSchemaCheckCOSCTDerivedOK(actxt, type->baseType,
-            baseType, set));
-    } else {
-        /*
-        * SPEC (2.3.2.2) "If D's {base type definition} is simple, then it
-        * must be validly derived from B given the subset as defined in Type
-        * Derivation OK (Simple) ($3.14.6).
-        */
-        return (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
-            baseType, set));
-    }
-}
-
-/**
- * xmlSchemaCheckCOSDerivedOK:
- * @type:  the derived simple type definition
- * @baseType:  the base type definition
- *
- * Calls:
- * Type Derivation OK (Simple) AND Type Derivation OK (Complex)
- *
- * Checks wheter @type can be validly derived from @baseType.
- *
- * Returns 0 on success, an positive error code otherwise.
- */
-static int
-xmlSchemaCheckCOSDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
-                           xmlSchemaTypePtr type,
-                           xmlSchemaTypePtr baseType,
-                           int set)
-{
-    if (WXS_IS_SIMPLE(type))
-        return (xmlSchemaCheckCOSSTDerivedOK(actxt, type, baseType, set));
-    else
-        return (xmlSchemaCheckCOSCTDerivedOK(actxt, type, baseType, set));
-}
-
-/**
- * xmlSchemaCheckCOSCTExtends:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.4.6) Constraints on Complex Type Definition Schema Components
- * Schema Component Constraint:
- * Derivation Valid (Extension) (cos-ct-extends)
- *
- * STATUS:
- *   missing:
- *     (1.5)
- *     (1.4.3.2.2.2) "Particle Valid (Extension)"
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckCOSCTExtends(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr base = type->baseType;
-    /*
-    * TODO: Correct the error code; XML_SCHEMAP_COS_CT_EXTENDS_1_1 is used
-    * temporarily only.
-    */
-    /*
-    * SPEC (1) "If the {base type definition} is a complex type definition,
-    * then all of the following must be true:"
-    */
-    if (WXS_IS_COMPLEX(base)) {
-        /*
-        * SPEC (1.1) "The {final} of the {base type definition} must not
-        * contain extension."
-        */
-        if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_COS_CT_EXTENDS_1_1,
-                WXS_BASIC_CAST type, NULL,
-                "The 'final' of the base type definition "
-                "contains 'extension'", NULL);
-            return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
-        }
-
-        /*
-        * ATTENTION: The constrains (1.2) and (1.3) are not applied,
-        * since they are automatically satisfied through the
-        * inheriting mechanism.
-        * Note that even if redefining components, the inheriting mechanism
-        * is used.
-        */
-#if 0
-        /*
-        * SPEC (1.2) "Its {attribute uses} must be a subset of the {attribute
-        * uses}
-        * of the complex type definition itself, that is, for every attribute
-        * use in the {attribute uses} of the {base type definition}, there
-        * must be an attribute use in the {attribute uses} of the complex
-        * type definition itself whose {attribute declaration} has the same
-        * {name}, {target namespace} and {type definition} as its attribute
-        * declaration"
-        */
-        if (base->attrUses != NULL) {
-            int i, j, found;
-            xmlSchemaAttributeUsePtr use, buse;
-
-            for (i = 0; i < (WXS_LIST_CAST base->attrUses)->nbItems; i ++) {
-                buse = (WXS_LIST_CAST base->attrUses)->items[i];
-                found = 0;
-                if (type->attrUses != NULL) {
-                    use = (WXS_LIST_CAST type->attrUses)->items[j];
-                    for (j = 0; j < (WXS_LIST_CAST type->attrUses)->nbItems; j ++)
-                    {
-                        if ((WXS_ATTRUSE_DECL_NAME(use) ==
-                                WXS_ATTRUSE_DECL_NAME(buse)) &&
-                            (WXS_ATTRUSE_DECL_TNS(use) ==
-                                WXS_ATTRUSE_DECL_TNS(buse)) &&
-                            (WXS_ATTRUSE_TYPEDEF(use) ==
-                                WXS_ATTRUSE_TYPEDEF(buse))
-                        {
-                            found = 1;
-                            break;
-                        }
-                    }
-                }
-                if (! found) {
-                    xmlChar *str = NULL;
-
-                    xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                        XML_SCHEMAP_COS_CT_EXTENDS_1_2,
-                        NULL, WXS_BASIC_CAST type,
-                        /*
-                        * TODO: The report does not indicate that also the
-                        * type needs to be the same.
-                        */
-                        "This type is missing a matching correspondent "
-                        "for its {base type}'s %s in its {attribute uses}",
-                        xmlSchemaGetComponentDesignation(&str,
-                            buse->children),
-                        NULL);
-                    FREE_AND_NULL(str)
-                }
-            }
-        }
-        /*
-        * SPEC (1.3) "If it has an {attribute wildcard}, the complex type
-        * definition must also have one, and the base type definition's
-        * {attribute  wildcard}'s {namespace constraint} must be a subset
-        * of the complex  type definition's {attribute wildcard}'s {namespace
-        * constraint}, as defined by Wildcard Subset ($3.10.6)."
-        */
-
-        /*
-        * MAYBE TODO: Enable if ever needed. But this will be needed only
-        * if created the type via a schema construction API.
-        */
-        if (base->attributeWildcard != NULL) {
-            if (type->attributeWilcard == NULL) {
-                xmlChar *str = NULL;
-
-                xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_COS_CT_EXTENDS_1_3,
-                    NULL, type,
-                    "The base %s has an attribute wildcard, "
-                    "but this type is missing an attribute wildcard",
-                    xmlSchemaGetComponentDesignation(&str, base));
-                FREE_AND_NULL(str)
-
-            } else if (xmlSchemaCheckCOSNSSubset(
-                base->attributeWildcard, type->attributeWildcard))
-            {
-                xmlChar *str = NULL;
-
-                xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_COS_CT_EXTENDS_1_3,
-                    NULL, type,
-                    "The attribute wildcard is not a valid "
-                    "superset of the one in the base %s",
-                    xmlSchemaGetComponentDesignation(&str, base));
-                FREE_AND_NULL(str)
-            }
-        }
-#endif
-        /*
-        * SPEC (1.4) "One of the following must be true:"
-        */
-        if ((type->contentTypeDef != NULL) &&
-            (type->contentTypeDef == base->contentTypeDef)) {
-            /*
-            * SPEC (1.4.1) "The {content type} of the {base type definition}
-            * and the {content type} of the complex type definition itself
-            * must be the same simple type definition"
-            * PASS
-            */
-        } else if ((type->contentType == XML_SCHEMA_CONTENT_EMPTY) &&
-            (base->contentType == XML_SCHEMA_CONTENT_EMPTY) ) {
-            /*
-            * SPEC (1.4.2) "The {content type} of both the {base type
-            * definition} and the complex type definition itself must
-            * be empty."
-            * PASS
-            */
-        } else {
-            /*
-            * SPEC (1.4.3) "All of the following must be true:"
-            */
-            if (type->subtypes == NULL) {
-                /*
-                * SPEC 1.4.3.1 The {content type} of the complex type
-                * definition itself must specify a particle.
-                */
-                xmlSchemaPCustomErr(ctxt,
-                    XML_SCHEMAP_COS_CT_EXTENDS_1_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "The content type must specify a particle", NULL);
-                return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
-            }
-            /*
-            * SPEC (1.4.3.2) "One of the following must be true:"
-            */
-            if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
-                /*
-                * SPEC (1.4.3.2.1) "The {content type} of the {base type
-                * definition} must be empty.
-                * PASS
-                */
-            } else {
-                /*
-                * SPEC (1.4.3.2.2) "All of the following must be true:"
-                */
-                if ((type->contentType != base->contentType) ||
-                    ((type->contentType != XML_SCHEMA_CONTENT_MIXED) &&
-                    (type->contentType != XML_SCHEMA_CONTENT_ELEMENTS))) {
-                    /*
-                    * SPEC (1.4.3.2.2.1) "Both {content type}s must be mixed
-                    * or both must be element-only."
-                    */
-                    xmlSchemaPCustomErr(ctxt,
-                        XML_SCHEMAP_COS_CT_EXTENDS_1_1,
-                        WXS_BASIC_CAST type, NULL,
-                        "The content type of both, the type and its base "
-                        "type, must either 'mixed' or 'element-only'", NULL);
-                    return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
-                }
-                /*
-                * URGENT TODO SPEC (1.4.3.2.2.2) "The particle of the
-                * complex type definition must be a `valid extension`
-                * of the {base type definition}'s particle, as defined
-                * in Particle Valid (Extension) ($3.9.6)."
-                *
-                * NOTE that we won't check "Particle Valid (Extension)",
-                * since it is ensured by the derivation process in
-                * xmlSchemaTypeFixup(). We need to implement this when heading
-                * for a construction API
-                * TODO: !! This is needed to be checked if redefining a type !!
-                */
-            }
-            /*
-            * URGENT TODO (1.5)
-            */
-        }
-    } else {
-        /*
-        * SPEC (2) "If the {base type definition} is a simple type definition,
-        * then all of the following must be true:"
-        */
-        if (type->contentTypeDef != base) {
-            /*
-            * SPEC (2.1) "The {content type} must be the same simple type
-            * definition."
-            */
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_COS_CT_EXTENDS_1_1,
-                WXS_BASIC_CAST type, NULL,
-                "The content type must be the simple base type", NULL);
-            return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
-        }
-        if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
-            /*
-            * SPEC (2.2) "The {final} of the {base type definition} must not
-            * contain extension"
-            * NOTE that this is the same as (1.1).
-            */
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_COS_CT_EXTENDS_1_1,
-                WXS_BASIC_CAST type, NULL,
-                "The 'final' of the base type definition "
-                "contains 'extension'", NULL);
-            return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
-        }
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaCheckDerivationOKRestriction:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.4.6) Constraints on Complex Type Definition Schema Components
- * Schema Component Constraint:
- * Derivation Valid (Restriction, Complex) (derivation-ok-restriction)
- *
- * STATUS:
- *   missing:
- *     (5.4.2) ???
- *
- * ATTENTION:
- * In XML Schema 1.1 this will be:
- * Validation Rule: Checking complex type subsumption
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckDerivationOKRestriction(xmlSchemaParserCtxtPtr ctxt,
-                                      xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr base;
-
-    /*
-    * TODO: Correct the error code; XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 is used
-    * temporarily only.
-    */
-    base = type->baseType;
-    if (! WXS_IS_COMPLEX(base)) {
-        xmlSchemaCustomErr(ACTXT_CAST ctxt,
-            XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-            type->node, WXS_BASIC_CAST type,
-            "The base type must be a complex type", NULL, NULL);
-        return(ctxt->err);
-    }
-    if (base->flags & XML_SCHEMAS_TYPE_FINAL_RESTRICTION) {
-        /*
-        * SPEC (1) "The {base type definition} must be a complex type
-        * definition whose {final} does not contain restriction."
-        */
-        xmlSchemaCustomErr(ACTXT_CAST ctxt,
-            XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-            type->node, WXS_BASIC_CAST type,
-            "The 'final' of the base type definition "
-            "contains 'restriction'", NULL, NULL);
-        return (ctxt->err);
-    }
-    /*
-    * SPEC (2), (3) and (4)
-    * Those are handled in a separate function, since the
-    * same constraints are needed for redefinition of
-    * attribute groups as well.
-    */
-    if (xmlSchemaCheckDerivationOKRestriction2to4(ctxt,
-        XML_SCHEMA_ACTION_DERIVE,
-        WXS_BASIC_CAST type, WXS_BASIC_CAST base,
-        type->attrUses, base->attrUses,
-        type->attributeWildcard,
-        base->attributeWildcard) == -1)
-    {
-        return(-1);
-    }
-    /*
-    * SPEC (5) "One of the following must be true:"
-    */
-    if (base->builtInType == XML_SCHEMAS_ANYTYPE) {
-        /*
-        * SPEC (5.1) "The {base type definition} must be the
-        * `ur-type definition`."
-        * PASS
-        */
-    } else if ((type->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
-            (type->contentType == XML_SCHEMA_CONTENT_BASIC)) {
-        /*
-        * SPEC (5.2.1) "The {content type} of the complex type definition
-        * must be a simple type definition"
-        *
-        * SPEC (5.2.2) "One of the following must be true:"
-        */
-        if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
-            (base->contentType == XML_SCHEMA_CONTENT_BASIC))
-        {
-            int err;
-            /*
-            * SPEC (5.2.2.1) "The {content type} of the {base type
-            * definition} must be a simple type definition from which
-            * the {content type} is validly derived given the empty
-            * set as defined in Type Derivation OK (Simple) ($3.14.6)."
-            *
-            * ATTENTION TODO: This seems not needed if the type implicitely
-            * derived from the base type.
-            *
-            */
-            err = xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST ctxt,
-                type->contentTypeDef, base->contentTypeDef, 0);
-            if (err != 0) {
-                xmlChar *strA = NULL, *strB = NULL;
-
-                if (err == -1)
-                    return(-1);
-                xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-                    NULL, WXS_BASIC_CAST type,
-                    "The {content type} %s is not validly derived from the "
-                    "base type's {content type} %s",
-                    xmlSchemaGetComponentDesignation(&strA,
-                        type->contentTypeDef),
-                    xmlSchemaGetComponentDesignation(&strB,
-                        base->contentTypeDef));
-                FREE_AND_NULL(strA);
-                FREE_AND_NULL(strB);
-                return(ctxt->err);
-            }
-        } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
-            (xmlSchemaIsParticleEmptiable(
-                (xmlSchemaParticlePtr) base->subtypes))) {
-            /*
-            * SPEC (5.2.2.2) "The {base type definition} must be mixed
-            * and have a particle which is `emptiable` as defined in
-            * Particle Emptiable ($3.9.6)."
-            * PASS
-            */
-        } else {
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-                WXS_BASIC_CAST type, NULL,
-                "The content type of the base type must be either "
-                "a simple type or 'mixed' and an emptiable particle", NULL);
-            return (ctxt->err);
-        }
-    } else if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
-        /*
-        * SPEC (5.3.1) "The {content type} of the complex type itself must
-        * be empty"
-        */
-        if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
-            /*
-            * SPEC (5.3.2.1) "The {content type} of the {base type
-            * definition} must also be empty."
-            * PASS
-            */
-        } else if (((base->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
-            (base->contentType == XML_SCHEMA_CONTENT_MIXED)) &&
-            xmlSchemaIsParticleEmptiable(
-                (xmlSchemaParticlePtr) base->subtypes)) {
-            /*
-            * SPEC (5.3.2.2) "The {content type} of the {base type
-            * definition} must be elementOnly or mixed and have a particle
-            * which is `emptiable` as defined in Particle Emptiable ($3.9.6)."
-            * PASS
-            */
-        } else {
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-                WXS_BASIC_CAST type, NULL,
-                "The content type of the base type must be either "
-                "empty or 'mixed' (or 'elements-only') and an emptiable "
-                "particle", NULL);
-            return (ctxt->err);
-        }
-    } else if ((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
-        WXS_HAS_MIXED_CONTENT(type)) {
-        /*
-        * SPEC (5.4.1.1) "The {content type} of the complex type definition
-        * itself must be element-only"
-        */
-        if (WXS_HAS_MIXED_CONTENT(type) && (! WXS_HAS_MIXED_CONTENT(base))) {
-            /*
-            * SPEC (5.4.1.2) "The {content type} of the complex type
-            * definition itself and of the {base type definition} must be
-            * mixed"
-            */
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-                WXS_BASIC_CAST type, NULL,
-                "If the content type is 'mixed', then the content type of the "
-                "base type must also be 'mixed'", NULL);
-            return (ctxt->err);
-        }
-        /*
-        * SPEC (5.4.2) "The particle of the complex type definition itself
-        * must be a `valid restriction` of the particle of the {content
-        * type} of the {base type definition} as defined in Particle Valid
-        * (Restriction) ($3.9.6).
-        *
-        * URGENT TODO: (5.4.2)
-        */
-    } else {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
-            WXS_BASIC_CAST type, NULL,
-            "The type is not a valid restriction of its base type", NULL);
-        return (ctxt->err);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaCheckCTComponent:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.4.6) Constraints on Complex Type Definition Schema Components
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckCTComponent(xmlSchemaParserCtxtPtr ctxt,
-                          xmlSchemaTypePtr type)
-{
-    int ret;
-    /*
-    * Complex Type Definition Properties Correct
-    */
-    ret = xmlSchemaCheckCTPropsCorrect(ctxt, type);
-    if (ret != 0)
-        return (ret);
-    if (WXS_IS_EXTENSION(type))
-        ret = xmlSchemaCheckCOSCTExtends(ctxt, type);
-    else
-        ret = xmlSchemaCheckDerivationOKRestriction(ctxt, type);
-    return (ret);
-}
-
-/**
- * xmlSchemaCheckSRCCT:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.4.3) Constraints on XML Representations of Complex Type Definitions:
- * Schema Representation Constraint:
- * Complex Type Definition Representation OK (src-ct)
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckSRCCT(xmlSchemaParserCtxtPtr ctxt,
-                    xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr base;
-    int ret = 0;
-
-    /*
-    * TODO: Adjust the error codes here, as I used
-    * XML_SCHEMAP_SRC_CT_1 only yet.
-    */
-    base = type->baseType;
-    if (! WXS_HAS_SIMPLE_CONTENT(type)) {
-        /*
-        * 1 If the <complexContent> alternative is chosen, the type definition
-        * `resolved` to by the `actual value` of the base [attribute]
-        * must be a complex type definition;
-        */
-        if (! WXS_IS_COMPLEX(base)) {
-            xmlChar *str = NULL;
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_SRC_CT_1,
-                WXS_BASIC_CAST type, type->node,
-                "If using <complexContent>, the base type is expected to be "
-                "a complex type. The base type '%s' is a simple type",
-                xmlSchemaFormatQName(&str, base->targetNamespace,
-                base->name));
-            FREE_AND_NULL(str)
-            return (XML_SCHEMAP_SRC_CT_1);
-        }
-    } else {
-        /*
-        * SPEC
-        * 2 If the <simpleContent> alternative is chosen, all of the
-        * following must be true:
-        * 2.1 The type definition `resolved` to by the `actual value` of the
-        * base [attribute] must be one of the following:
-        */
-        if (WXS_IS_SIMPLE(base)) {
-            if (WXS_IS_EXTENSION(type) == 0) {
-                xmlChar *str = NULL;
-                /*
-                * 2.1.3 only if the <extension> alternative is also
-                * chosen, a simple type definition.
-                */
-                /* TODO: Change error code to ..._SRC_CT_2_1_3. */
-                xmlSchemaPCustomErr(ctxt,
-                    XML_SCHEMAP_SRC_CT_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "If using <simpleContent> and <restriction>, the base "
-                    "type must be a complex type. The base type '%s' is "
-                    "a simple type",
-                    xmlSchemaFormatQName(&str, base->targetNamespace,
-                        base->name));
-                FREE_AND_NULL(str)
-                return (XML_SCHEMAP_SRC_CT_1);
-            }
-        } else {
-            /* Base type is a complex type. */
-            if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
-                (base->contentType == XML_SCHEMA_CONTENT_BASIC)) {
-                /*
-                * 2.1.1 a complex type definition whose {content type} is a
-                * simple type definition;
-                * PASS
-                */
-                if (base->contentTypeDef == NULL) {
-                    xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
-                        WXS_BASIC_CAST type, NULL,
-                        "Internal error: xmlSchemaCheckSRCCT, "
-                        "'%s', base type has no content type",
-                        type->name);
-                    return (-1);
-                }
-            } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
-                (WXS_IS_RESTRICTION(type))) {
-
-                /*
-                * 2.1.2 only if the <restriction> alternative is also
-                * chosen, a complex type definition whose {content type}
-                * is mixed and a particle emptiable.
-                */
-                if (! xmlSchemaIsParticleEmptiable(
-                    (xmlSchemaParticlePtr) base->subtypes)) {
-                    ret = XML_SCHEMAP_SRC_CT_1;
-                } else
-                    /*
-                    * Attention: at this point the <simpleType> child is in
-                    * ->contentTypeDef (put there during parsing).
-                    */
-                    if (type->contentTypeDef == NULL) {
-                    xmlChar *str = NULL;
-                    /*
-                    * 2.2 If clause 2.1.2 above is satisfied, then there
-                    * must be a <simpleType> among the [children] of
-                    * <restriction>.
-                    */
-                    /* TODO: Change error code to ..._SRC_CT_2_2. */
-                    xmlSchemaPCustomErr(ctxt,
-                        XML_SCHEMAP_SRC_CT_1,
-                        WXS_BASIC_CAST type, NULL,
-                        "A <simpleType> is expected among the children "
-                        "of <restriction>, if <simpleContent> is used and "
-                        "the base type '%s' is a complex type",
-                        xmlSchemaFormatQName(&str, base->targetNamespace,
-                        base->name));
-                    FREE_AND_NULL(str)
-                    return (XML_SCHEMAP_SRC_CT_1);
-                }
-            } else {
-                ret = XML_SCHEMAP_SRC_CT_1;
-            }
-        }
-        if (ret > 0) {
-            xmlChar *str = NULL;
-            if (WXS_IS_RESTRICTION(type)) {
-                xmlSchemaPCustomErr(ctxt,
-                    XML_SCHEMAP_SRC_CT_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "If <simpleContent> and <restriction> is used, the "
-                    "base type must be a simple type or a complex type with "
-                    "mixed content and particle emptiable. The base type "
-                    "'%s' is none of those",
-                    xmlSchemaFormatQName(&str, base->targetNamespace,
-                    base->name));
-            } else {
-                xmlSchemaPCustomErr(ctxt,
-                    XML_SCHEMAP_SRC_CT_1,
-                    WXS_BASIC_CAST type, NULL,
-                    "If <simpleContent> and <extension> is used, the "
-                    "base type must be a simple type. The base type '%s' "
-                    "is a complex type",
-                    xmlSchemaFormatQName(&str, base->targetNamespace,
-                    base->name));
-            }
-            FREE_AND_NULL(str)
-        }
-    }
-    /*
-    * SPEC (3) "The corresponding complex type definition component must
-    * satisfy the conditions set out in Constraints on Complex Type
-    * Definition Schema Components ($3.4.6);"
-    * NOTE (3) will be done in xmlSchemaTypeFixup().
-    */
-    /*
-    * SPEC (4) If clause 2.2.1 or clause 2.2.2 in the correspondence specification
-    * above for {attribute wildcard} is satisfied, the intensional
-    * intersection must be expressible, as defined in Attribute Wildcard
-    * Intersection ($3.10.6).
-    * NOTE (4) is done in xmlSchemaFixupTypeAttributeUses().
-    */
-    return (ret);
-}
-
-#ifdef ENABLE_PARTICLE_RESTRICTION
-/**
- * xmlSchemaCheckParticleRangeOK:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Occurrence Range OK (range-ok)
- *
- * STATUS: complete
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckParticleRangeOK(int rmin, int rmax,
-                              int bmin, int bmax)
-{
-    if (rmin < bmin)
-        return (1);
-    if ((bmax != UNBOUNDED) &&
-        (rmax > bmax))
-        return (1);
-    return (0);
-}
-
-/**
- * xmlSchemaCheckRCaseNameAndTypeOK:
- * @ctxt:  the schema parser context
- * @r: the restricting element declaration particle
- * @b: the base element declaration particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Restriction OK (Elt:Elt -- NameAndTypeOK)
- * (rcase-NameAndTypeOK)
- *
- * STATUS:
- *   MISSING (3.2.3)
- *   CLARIFY: (3.2.2)
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseNameAndTypeOK(xmlSchemaParserCtxtPtr ctxt,
-                                 xmlSchemaParticlePtr r,
-                                 xmlSchemaParticlePtr b)
-{
-    xmlSchemaElementPtr elemR, elemB;
-
-    /* TODO: Error codes (rcase-NameAndTypeOK). */
-    elemR = (xmlSchemaElementPtr) r->children;
-    elemB = (xmlSchemaElementPtr) b->children;
-    /*
-    * SPEC (1) "The declarations' {name}s and {target namespace}s are
-    * the same."
-    */
-    if ((elemR != elemB) &&
-        ((! xmlStrEqual(elemR->name, elemB->name)) ||
-        (! xmlStrEqual(elemR->targetNamespace, elemB->targetNamespace))))
-        return (1);
-    /*
-    * SPEC (2) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK ($3.9.6)."
-    */
-    if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
-            b->minOccurs, b->maxOccurs) != 0)
-        return (1);
-    /*
-    * SPEC (3.1) "Both B's declaration's {scope} and R's declaration's
-    * {scope} are global."
-    */
-    if (elemR == elemB)
-        return (0);
-    /*
-    * SPEC (3.2.1) "Either B's {nillable} is true or R's {nillable} is false."
-    */
-    if (((elemB->flags & XML_SCHEMAS_ELEM_NILLABLE) == 0) &&
-        (elemR->flags & XML_SCHEMAS_ELEM_NILLABLE))
-         return (1);
-    /*
-    * SPEC (3.2.2) "either B's declaration's {value constraint} is absent,
-    * or is not fixed, or R's declaration's {value constraint} is fixed
-    * with the same value."
-    */
-    if ((elemB->value != NULL) && (elemB->flags & XML_SCHEMAS_ELEM_FIXED) &&
-        ((elemR->value == NULL) ||
-         ((elemR->flags & XML_SCHEMAS_ELEM_FIXED) == 0) ||
-         /* TODO: Equality of the initial value or normalized or canonical? */
-         (! xmlStrEqual(elemR->value, elemB->value))))
-         return (1);
-    /*
-    * TODO: SPEC (3.2.3) "R's declaration's {identity-constraint
-    * definitions} is a subset of B's declaration's {identity-constraint
-    * definitions}, if any."
-    */
-    if (elemB->idcs != NULL) {
-        /* TODO */
-    }
-    /*
-    * SPEC (3.2.4) "R's declaration's {disallowed substitutions} is a
-    * superset of B's declaration's {disallowed substitutions}."
-    */
-    if (((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) &&
-         ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) == 0)) ||
-        ((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) &&
-         ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) == 0)) ||
-        ((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION) &&
-         ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION) == 0)))
-         return (1);
-    /*
-    * SPEC (3.2.5) "R's {type definition} is validly derived given
-    * {extension, list, union} from B's {type definition}"
-    *
-    * BADSPEC TODO: What's the point of adding "list" and "union" to the
-    * set, if the corresponding constraints handle "restriction" and
-    * "extension" only?
-    *
-    */
-    {
-        int set = 0;
-
-        set |= SUBSET_EXTENSION;
-        set |= SUBSET_LIST;
-        set |= SUBSET_UNION;
-        if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST ctxt, elemR->subtypes,
-            elemB->subtypes, set) != 0)
-            return (1);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaCheckRCaseNSCompat:
- * @ctxt:  the schema parser context
- * @r: the restricting element declaration particle
- * @b: the base wildcard particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Derivation OK (Elt:Any -- NSCompat)
- * (rcase-NSCompat)
- *
- * STATUS: complete
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseNSCompat(xmlSchemaParserCtxtPtr ctxt,
-                            xmlSchemaParticlePtr r,
-                            xmlSchemaParticlePtr b)
-{
-    /* TODO:Error codes (rcase-NSCompat). */
-    /*
-    * SPEC "For an element declaration particle to be a `valid restriction`
-    * of a wildcard particle all of the following must be true:"
-    *
-    * SPEC (1) "The element declaration's {target namespace} is `valid`
-    * with respect to the wildcard's {namespace constraint} as defined by
-    * Wildcard allows Namespace Name ($3.10.4)."
-    */
-    if (xmlSchemaCheckCVCWildcardNamespace((xmlSchemaWildcardPtr) b->children,
-        ((xmlSchemaElementPtr) r->children)->targetNamespace) != 0)
-        return (1);
-    /*
-    * SPEC (2) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK ($3.9.6)."
-    */
-    if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
-            b->minOccurs, b->maxOccurs) != 0)
-        return (1);
-
-    return (0);
-}
-
-/**
- * xmlSchemaCheckRCaseRecurseAsIfGroup:
- * @ctxt:  the schema parser context
- * @r: the restricting element declaration particle
- * @b: the base model group particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Derivation OK (Elt:All/Choice/Sequence -- RecurseAsIfGroup)
- * (rcase-RecurseAsIfGroup)
- *
- * STATUS: TODO
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseRecurseAsIfGroup(xmlSchemaParserCtxtPtr ctxt,
-                                    xmlSchemaParticlePtr r,
-                                    xmlSchemaParticlePtr b)
-{
-    /* TODO: Error codes (rcase-RecurseAsIfGroup). */
-    TODO
-    return (0);
-}
-
-/**
- * xmlSchemaCheckRCaseNSSubset:
- * @ctxt:  the schema parser context
- * @r: the restricting wildcard particle
- * @b: the base wildcard particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Derivation OK (Any:Any -- NSSubset)
- * (rcase-NSSubset)
- *
- * STATUS: complete
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseNSSubset(xmlSchemaParserCtxtPtr ctxt,
-                                    xmlSchemaParticlePtr r,
-                                    xmlSchemaParticlePtr b,
-                                    int isAnyTypeBase)
-{
-    /* TODO: Error codes (rcase-NSSubset). */
-    /*
-    * SPEC (1) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK ($3.9.6)."
-    */
-    if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
-            b->minOccurs, b->maxOccurs))
-        return (1);
-    /*
-    * SPEC (2) "R's {namespace constraint} must be an intensional subset
-    * of B's {namespace constraint} as defined by Wildcard Subset ($3.10.6)."
-    */
-    if (xmlSchemaCheckCOSNSSubset((xmlSchemaWildcardPtr) r->children,
-        (xmlSchemaWildcardPtr) b->children))
-        return (1);
-    /*
-    * SPEC (3) "Unless B is the content model wildcard of the `ur-type
-    * definition`, R's {process contents} must be identical to or stronger
-    * than B's {process contents}, where strict is stronger than lax is
-    * stronger than skip."
-    */
-    if (! isAnyTypeBase) {
-        if ( ((xmlSchemaWildcardPtr) r->children)->processContents <
-            ((xmlSchemaWildcardPtr) b->children)->processContents)
-            return (1);
-    }
-
-    return (0);
-}
-
-/**
- * xmlSchemaCheckCOSParticleRestrict:
- * @ctxt:  the schema parser context
- * @type:  the complex type definition
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Valid (Restriction) (cos-particle-restrict)
- *
- * STATUS: TODO
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckCOSParticleRestrict(xmlSchemaParserCtxtPtr ctxt,
-                                  xmlSchemaParticlePtr r,
-                                  xmlSchemaParticlePtr b)
-{
-    int ret = 0;
-
-    /*part = WXS_TYPE_PARTICLE(type);
-    basePart = WXS_TYPE_PARTICLE(base);
-    */
-
-    TODO
-
-    /*
-    * SPEC (1) "They are the same particle."
-    */
-    if (r == b)
-        return (0);
-
-
-    return (0);
-}
-
-#if 0
-/**
- * xmlSchemaCheckRCaseNSRecurseCheckCardinality:
- * @ctxt:  the schema parser context
- * @r: the model group particle
- * @b: the base wildcard particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Derivation OK (All/Choice/Sequence:Any --
- *                         NSRecurseCheckCardinality)
- * (rcase-NSRecurseCheckCardinality)
- *
- * STATUS: TODO: subst-groups
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseNSRecurseCheckCardinality(xmlSchemaParserCtxtPtr ctxt,
-                                             xmlSchemaParticlePtr r,
-                                             xmlSchemaParticlePtr b)
-{
-    xmlSchemaParticlePtr part;
-    /* TODO: Error codes (rcase-NSRecurseCheckCardinality). */
-    if ((r->children == NULL) || (r->children->children == NULL))
-        return (-1);
-    /*
-    * SPEC "For a group particle to be a `valid restriction` of a
-    * wildcard particle..."
-    *
-    * SPEC (1) "Every member of the {particles} of the group is a `valid
-    * restriction` of the wildcard as defined by
-    * Particle Valid (Restriction) ($3.9.6)."
-    */
-    part = (xmlSchemaParticlePtr) r->children->children;
-    do {
-        if (xmlSchemaCheckCOSParticleRestrict(ctxt, part, b))
-            return (1);
-        part = (xmlSchemaParticlePtr) part->next;
-    } while (part != NULL);
-    /*
-    * SPEC (2) "The effective total range of the group [...] is a
-    * valid restriction of B's occurrence range as defined by
-    * Occurrence Range OK ($3.9.6)."
-    */
-    if (xmlSchemaCheckParticleRangeOK(
-            xmlSchemaGetParticleTotalRangeMin(r),
-            xmlSchemaGetParticleTotalRangeMax(r),
-            b->minOccurs, b->maxOccurs) != 0)
-        return (1);
-    return (0);
-}
-#endif
-
-/**
- * xmlSchemaCheckRCaseRecurse:
- * @ctxt:  the schema parser context
- * @r: the <all> or <sequence> model group particle
- * @b: the base <all> or <sequence> model group particle
- *
- * (3.9.6) Constraints on Particle Schema Components
- * Schema Component Constraint:
- * Particle Derivation OK (All:All,Sequence:Sequence --
-                           Recurse)
- * (rcase-Recurse)
- *
- * STATUS:  ?
- * TODO: subst-groups
- *
- * Returns 0 if the constraints are satisfied, a positive
- * error code if not and -1 if an internal error occured.
- */
-static int
-xmlSchemaCheckRCaseRecurse(xmlSchemaParserCtxtPtr ctxt,
-                           xmlSchemaParticlePtr r,
-                           xmlSchemaParticlePtr b)
-{
-    /* xmlSchemaParticlePtr part; */
-    /* TODO: Error codes (rcase-Recurse). */
-    if ((r->children == NULL) || (b->children == NULL) ||
-        (r->children->type != b->children->type))
-        return (-1);
-    /*
-    * SPEC "For an all or sequence group particle to be a `valid
-    * restriction` of another group particle with the same {compositor}..."
-    *
-    * SPEC (1) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK ($3.9.6)."
-    */
-    if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
-            b->minOccurs, b->maxOccurs))
-        return (1);
-
-
-    return (0);
-}
-
-#endif
-
-#define FACET_RESTR_MUTUAL_ERR(fac1, fac2) \
-    xmlSchemaPCustomErrExt(pctxt,      \
-        XML_SCHEMAP_INVALID_FACET_VALUE, \
-        WXS_BASIC_CAST fac1, fac1->node, \
-        "It is an error for both '%s' and '%s' to be specified on the "\
-        "same type definition", \
-        BAD_CAST xmlSchemaFacetTypeToString(fac1->type), \
-        BAD_CAST xmlSchemaFacetTypeToString(fac2->type), NULL);
-
-#define FACET_RESTR_ERR(fac1, msg) \
-    xmlSchemaPCustomErr(pctxt,      \
-        XML_SCHEMAP_INVALID_FACET_VALUE, \
-        WXS_BASIC_CAST fac1, fac1->node, \
-        msg, NULL);
-
-#define FACET_RESTR_FIXED_ERR(fac) \
-    xmlSchemaPCustomErr(pctxt, \
-        XML_SCHEMAP_INVALID_FACET_VALUE, \
-        WXS_BASIC_CAST fac, fac->node, \
-        "The base type's facet is 'fixed', thus the value must not " \
-        "differ", NULL);
-
-static void
-xmlSchemaDeriveFacetErr(xmlSchemaParserCtxtPtr pctxt,
-                        xmlSchemaFacetPtr facet1,
-                        xmlSchemaFacetPtr facet2,
-                        int lessGreater,
-                        int orEqual,
-                        int ofBase)
-{
-    xmlChar *msg = NULL;
-
-    msg = xmlStrdup(BAD_CAST "'");
-    msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facet1->type));
-    msg = xmlStrcat(msg, BAD_CAST "' has to be");
-    if (lessGreater == 0)
-        msg = xmlStrcat(msg, BAD_CAST " equal to");
-    if (lessGreater == 1)
-        msg = xmlStrcat(msg, BAD_CAST " greater than");
-    else
-        msg = xmlStrcat(msg, BAD_CAST " less than");
-
-    if (orEqual)
-        msg = xmlStrcat(msg, BAD_CAST " or equal to");
-    msg = xmlStrcat(msg, BAD_CAST " '");
-    msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facet2->type));
-    if (ofBase)
-        msg = xmlStrcat(msg, BAD_CAST "' of the base type");
-    else
-        msg = xmlStrcat(msg, BAD_CAST "'");
-
-    xmlSchemaPCustomErr(pctxt,
-        XML_SCHEMAP_INVALID_FACET_VALUE,
-        WXS_BASIC_CAST facet1, NULL,
-        (const char *) msg, NULL);
-
-    if (msg != NULL)
-        xmlFree(msg);
-}
-
-/*
-* xmlSchemaDeriveAndValidateFacets:
-*
-* Schema Component Constraint: Simple Type Restriction (Facets)
-* (st-restrict-facets)
-*/
-static int
-xmlSchemaDeriveAndValidateFacets(xmlSchemaParserCtxtPtr pctxt,
-                                 xmlSchemaTypePtr type)
-{
-    xmlSchemaTypePtr base = type->baseType;
-    xmlSchemaFacetLinkPtr link, cur, last = NULL;
-    xmlSchemaFacetPtr facet, bfacet,
-        flength = NULL, ftotdig = NULL, ffracdig = NULL,
-        fmaxlen = NULL, fminlen = NULL, /* facets of the current type */
-        fmininc = NULL, fmaxinc = NULL,
-        fminexc = NULL, fmaxexc = NULL,
-        bflength = NULL, bftotdig = NULL, bffracdig = NULL,
-        bfmaxlen = NULL, bfminlen = NULL, /* facets of the base type */
-        bfmininc = NULL, bfmaxinc = NULL,
-        bfminexc = NULL, bfmaxexc = NULL;
-    int res; /* err = 0, fixedErr; */
-
-    /*
-    * SPEC st-restrict-facets 1:
-    * "The {variety} of R is the same as that of B."
-    */
-    /*
-    * SPEC st-restrict-facets 2:
-    * "If {variety} is atomic, the {primitive type definition}
-    * of R is the same as that of B."
-    *
-    * NOTE: we leave 1 & 2 out for now, since this will be
-    * satisfied by the derivation process.
-    * CONSTRUCTION TODO: Maybe needed if using a construction API.
-    */
-    /*
-    * SPEC st-restrict-facets 3:
-    * "The {facets} of R are the union of S and the {facets}
-    * of B, eliminating duplicates. To eliminate duplicates,
-    * when a facet of the same kind occurs in both S and the
-    * {facets} of B, the one in the {facets} of B is not
-    * included, with the exception of enumeration and pattern
-    * facets, for which multiple occurrences with distinct values
-    * are allowed."
-    */
-
-    if ((type->facetSet == NULL) && (base->facetSet == NULL))
-        return (0);
-
-    last = type->facetSet;
-    if (last != NULL)
-        while (last->next != NULL)
-            last = last->next;
-
-    for (cur = type->facetSet; cur != NULL; cur = cur->next) {
-        facet = cur->facet;
-        switch (facet->type) {
-            case XML_SCHEMA_FACET_LENGTH:
-                flength = facet; break;
-            case XML_SCHEMA_FACET_MINLENGTH:
-                fminlen = facet; break;
-            case XML_SCHEMA_FACET_MININCLUSIVE:
-                fmininc = facet; break;
-            case XML_SCHEMA_FACET_MINEXCLUSIVE:
-                fminexc = facet; break;
-            case XML_SCHEMA_FACET_MAXLENGTH:
-                fmaxlen = facet; break;
-            case XML_SCHEMA_FACET_MAXINCLUSIVE:
-                fmaxinc = facet; break;
-            case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-                fmaxexc = facet; break;
-            case XML_SCHEMA_FACET_TOTALDIGITS:
-                ftotdig = facet; break;
-            case XML_SCHEMA_FACET_FRACTIONDIGITS:
-                ffracdig = facet; break;
-            default:
-                break;
-        }
-    }
-    for (cur = base->facetSet; cur != NULL; cur = cur->next) {
-        facet = cur->facet;
-        switch (facet->type) {
-            case XML_SCHEMA_FACET_LENGTH:
-                bflength = facet; break;
-            case XML_SCHEMA_FACET_MINLENGTH:
-                bfminlen = facet; break;
-            case XML_SCHEMA_FACET_MININCLUSIVE:
-                bfmininc = facet; break;
-            case XML_SCHEMA_FACET_MINEXCLUSIVE:
-                bfminexc = facet; break;
-            case XML_SCHEMA_FACET_MAXLENGTH:
-                bfmaxlen = facet; break;
-            case XML_SCHEMA_FACET_MAXINCLUSIVE:
-                bfmaxinc = facet; break;
-            case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-                bfmaxexc = facet; break;
-            case XML_SCHEMA_FACET_TOTALDIGITS:
-                bftotdig = facet; break;
-            case XML_SCHEMA_FACET_FRACTIONDIGITS:
-                bffracdig = facet; break;
-            default:
-                break;
-        }
-    }
-    /*
-    * length and minLength or maxLength (2.2) + (3.2)
-    */
-    if (flength && (fminlen || fmaxlen)) {
-        FACET_RESTR_ERR(flength, "It is an error for both 'length' and "
-            "either of 'minLength' or 'maxLength' to be specified on "
-            "the same type definition")
-    }
-    /*
-    * Mutual exclusions in the same derivation step.
-    */
-    if ((fmaxinc) && (fmaxexc)) {
-        /*
-        * SCC "maxInclusive and maxExclusive"
-        */
-        FACET_RESTR_MUTUAL_ERR(fmaxinc, fmaxexc)
-    }
-    if ((fmininc) && (fminexc)) {
-        /*
-        * SCC "minInclusive and minExclusive"
-        */
-        FACET_RESTR_MUTUAL_ERR(fmininc, fminexc)
-    }
-
-    if (flength && bflength) {
-        /*
-        * SCC "length valid restriction"
-        * The values have to be equal.
-        */
-        res = xmlSchemaCompareValues(flength->val, bflength->val);
-        if (res == -2)
-            goto internal_error;
-        if (res != 0)
-            xmlSchemaDeriveFacetErr(pctxt, flength, bflength, 0, 0, 1);
-        if ((res != 0) && (bflength->fixed)) {
-            FACET_RESTR_FIXED_ERR(flength)
-        }
-
-    }
-    if (fminlen && bfminlen) {
-        /*
-        * SCC "minLength valid restriction"
-        * minLength >= BASE minLength
-        */
-        res = xmlSchemaCompareValues(fminlen->val, bfminlen->val);
-        if (res == -2)
-            goto internal_error;
-        if (res == -1)
-            xmlSchemaDeriveFacetErr(pctxt, fminlen, bfminlen, 1, 1, 1);
-        if ((res != 0) && (bfminlen->fixed)) {
-            FACET_RESTR_FIXED_ERR(fminlen)
-        }
-    }
-    if (fmaxlen && bfmaxlen) {
-        /*
-        * SCC "maxLength valid restriction"
-        * maxLength <= BASE minLength
-        */
-        res = xmlSchemaCompareValues(fmaxlen->val, bfmaxlen->val);
-        if (res == -2)
-            goto internal_error;
-        if (res == 1)
-            xmlSchemaDeriveFacetErr(pctxt, fmaxlen, bfmaxlen, -1, 1, 1);
-        if ((res != 0) && (bfmaxlen->fixed)) {
-            FACET_RESTR_FIXED_ERR(fmaxlen)
-        }
-    }
-    /*
-    * SCC "length and minLength or maxLength"
-    */
-    if (! flength)
-        flength = bflength;
-    if (flength) {
-        if (! fminlen)
-            fminlen = bfminlen;
-        if (fminlen) {
-            /* (1.1) length >= minLength */
-            res = xmlSchemaCompareValues(flength->val, fminlen->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1)
-                xmlSchemaDeriveFacetErr(pctxt, flength, fminlen, 1, 1, 0);
-        }
-        if (! fmaxlen)
-            fmaxlen = bfmaxlen;
-        if (fmaxlen) {
-            /* (2.1) length <= maxLength */
-            res = xmlSchemaCompareValues(flength->val, fmaxlen->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1)
-                xmlSchemaDeriveFacetErr(pctxt, flength, fmaxlen, -1, 1, 0);
-        }
-    }
-    if (fmaxinc) {
-        /*
-        * "maxInclusive"
-        */
-        if (fmininc) {
-            /* SCC "maxInclusive >= minInclusive" */
-            res = xmlSchemaCompareValues(fmaxinc->val, fmininc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxinc, fmininc, 1, 1, 0);
-            }
-        }
-        /*
-        * SCC "maxInclusive valid restriction"
-        */
-        if (bfmaxinc) {
-            /* maxInclusive <= BASE maxInclusive */
-            res = xmlSchemaCompareValues(fmaxinc->val, bfmaxinc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1)
-                xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmaxinc, -1, 1, 1);
-            if ((res != 0) && (bfmaxinc->fixed)) {
-                FACET_RESTR_FIXED_ERR(fmaxinc)
-            }
-        }
-        if (bfmaxexc) {
-            /* maxInclusive < BASE maxExclusive */
-            res = xmlSchemaCompareValues(fmaxinc->val, bfmaxexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmaxexc, -1, 0, 1);
-            }
-        }
-        if (bfmininc) {
-            /* maxInclusive >= BASE minInclusive */
-            res = xmlSchemaCompareValues(fmaxinc->val, bfmininc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmininc, 1, 1, 1);
-            }
-        }
-        if (bfminexc) {
-            /* maxInclusive > BASE minExclusive */
-            res = xmlSchemaCompareValues(fmaxinc->val, bfminexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfminexc, 1, 0, 1);
-            }
-        }
-    }
-    if (fmaxexc) {
-        /*
-        * "maxExclusive >= minExclusive"
-        */
-        if (fminexc) {
-            res = xmlSchemaCompareValues(fmaxexc->val, fminexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxexc, fminexc, 1, 1, 0);
-            }
-        }
-        /*
-        * "maxExclusive valid restriction"
-        */
-        if (bfmaxexc) {
-            /* maxExclusive <= BASE maxExclusive */
-            res = xmlSchemaCompareValues(fmaxexc->val, bfmaxexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmaxexc, -1, 1, 1);
-            }
-            if ((res != 0) && (bfmaxexc->fixed)) {
-                FACET_RESTR_FIXED_ERR(fmaxexc)
-            }
-        }
-        if (bfmaxinc) {
-            /* maxExclusive <= BASE maxInclusive */
-            res = xmlSchemaCompareValues(fmaxexc->val, bfmaxinc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmaxinc, -1, 1, 1);
-            }
-        }
-        if (bfmininc) {
-            /* maxExclusive > BASE minInclusive */
-            res = xmlSchemaCompareValues(fmaxexc->val, bfmininc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmininc, 1, 0, 1);
-            }
-        }
-        if (bfminexc) {
-            /* maxExclusive > BASE minExclusive */
-            res = xmlSchemaCompareValues(fmaxexc->val, bfminexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfminexc, 1, 0, 1);
-            }
-        }
-    }
-    if (fminexc) {
-        /*
-        * "minExclusive < maxInclusive"
-        */
-        if (fmaxinc) {
-            res = xmlSchemaCompareValues(fminexc->val, fmaxinc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fminexc, fmaxinc, -1, 0, 0);
-            }
-        }
-        /*
-        * "minExclusive valid restriction"
-        */
-        if (bfminexc) {
-            /* minExclusive >= BASE minExclusive */
-            res = xmlSchemaCompareValues(fminexc->val, bfminexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fminexc, bfminexc, 1, 1, 1);
-            }
-            if ((res != 0) && (bfminexc->fixed)) {
-                FACET_RESTR_FIXED_ERR(fminexc)
-            }
-        }
-        if (bfmaxinc) {
-            /* minExclusive <= BASE maxInclusive */
-            res = xmlSchemaCompareValues(fminexc->val, bfmaxinc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmaxinc, -1, 1, 1);
-            }
-        }
-        if (bfmininc) {
-            /* minExclusive >= BASE minInclusive */
-            res = xmlSchemaCompareValues(fminexc->val, bfmininc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmininc, 1, 1, 1);
-            }
-        }
-        if (bfmaxexc) {
-            /* minExclusive < BASE maxExclusive */
-            res = xmlSchemaCompareValues(fminexc->val, bfmaxexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmaxexc, -1, 0, 1);
-            }
-        }
-    }
-    if (fmininc) {
-        /*
-        * "minInclusive < maxExclusive"
-        */
-        if (fmaxexc) {
-            res = xmlSchemaCompareValues(fmininc->val, fmaxexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmininc, fmaxexc, -1, 0, 0);
-            }
-        }
-        /*
-        * "minExclusive valid restriction"
-        */
-        if (bfmininc) {
-            /* minInclusive >= BASE minInclusive */
-            res = xmlSchemaCompareValues(fmininc->val, bfmininc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == -1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmininc, 1, 1, 1);
-            }
-            if ((res != 0) && (bfmininc->fixed)) {
-                FACET_RESTR_FIXED_ERR(fmininc)
-            }
-        }
-        if (bfmaxinc) {
-            /* minInclusive <= BASE maxInclusive */
-            res = xmlSchemaCompareValues(fmininc->val, bfmaxinc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res == 1) {
-                xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmaxinc, -1, 1, 1);
-            }
-        }
-        if (bfminexc) {
-            /* minInclusive > BASE minExclusive */
-            res = xmlSchemaCompareValues(fmininc->val, bfminexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != 1)
-                xmlSchemaDeriveFacetErr(pctxt, fmininc, bfminexc, 1, 0, 1);
-        }
-        if (bfmaxexc) {
-            /* minInclusive < BASE maxExclusive */
-            res = xmlSchemaCompareValues(fmininc->val, bfmaxexc->val);
-            if (res == -2)
-                goto internal_error;
-            if (res != -1)
-                xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmaxexc, -1, 0, 1);
-        }
-    }
-    if (ftotdig && bftotdig) {
-        /*
-        * SCC " totalDigits valid restriction"
-        * totalDigits <= BASE totalDigits
-        */
-        res = xmlSchemaCompareValues(ftotdig->val, bftotdig->val);
-        if (res == -2)
-            goto internal_error;
-        if (res == 1)
-            xmlSchemaDeriveFacetErr(pctxt, ftotdig, bftotdig,
-            -1, 1, 1);
-        if ((res != 0) && (bftotdig->fixed)) {
-            FACET_RESTR_FIXED_ERR(ftotdig)
-        }
-    }
-    if (ffracdig && bffracdig) {
-        /*
-        * SCC  "fractionDigits valid restriction"
-        * fractionDigits <= BASE fractionDigits
-        */
-        res = xmlSchemaCompareValues(ffracdig->val, bffracdig->val);
-        if (res == -2)
-            goto internal_error;
-        if (res == 1)
-            xmlSchemaDeriveFacetErr(pctxt, ffracdig, bffracdig,
-            -1, 1, 1);
-        if ((res != 0) && (bffracdig->fixed)) {
-            FACET_RESTR_FIXED_ERR(ffracdig)
-        }
-    }
-    /*
-    * SCC "fractionDigits less than or equal to totalDigits"
-    */
-    if (! ftotdig)
-        ftotdig = bftotdig;
-    if (! ffracdig)
-        ffracdig = bffracdig;
-    if (ftotdig && ffracdig) {
-        res = xmlSchemaCompareValues(ffracdig->val, ftotdig->val);
-        if (res == -2)
-            goto internal_error;
-        if (res == 1)
-            xmlSchemaDeriveFacetErr(pctxt, ffracdig, ftotdig,
-                -1, 1, 0);
-    }
-    /*
-    * *Enumerations* won' be added here, since only the first set
-    * of enumerations in the ancestor-or-self axis is used
-    * for validation, plus we need to use the base type of those
-    * enumerations for whitespace.
-    *
-    * *Patterns*: won't be add here, since they are ORed at
-    * type level and ANDed at ancestor level. This will
-    * happed during validation by walking the base axis
-    * of the type.
-    */
-    for (cur = base->facetSet; cur != NULL; cur = cur->next) {
-        bfacet = cur->facet;
-        /*
-        * Special handling of enumerations and patterns.
-        * TODO: hmm, they should not appear in the set, so remove this.
-        */
-        if ((bfacet->type == XML_SCHEMA_FACET_PATTERN) ||
-            (bfacet->type == XML_SCHEMA_FACET_ENUMERATION))
-            continue;
-        /*
-        * Search for a duplicate facet in the current type.
-        */
-        link = type->facetSet;
-        /* err = 0; */
-        /* fixedErr = 0; */
-        while (link != NULL) {
-            facet = link->facet;
-            if (facet->type == bfacet->type) {
-                switch (facet->type) {
-                    case XML_SCHEMA_FACET_WHITESPACE:
-                        /*
-                        * The whitespace must be stronger.
-                        */
-                        if (facet->whitespace < bfacet->whitespace) {
-                            FACET_RESTR_ERR(facet,
-                                "The 'whitespace' value has to be equal to "
-                                "or stronger than the 'whitespace' value of "
-                                "the base type")
-                        }
-                        if ((bfacet->fixed) &&
-                            (facet->whitespace != bfacet->whitespace)) {
-                            FACET_RESTR_FIXED_ERR(facet)
-                        }
-                        break;
-                    default:
-                        break;
-                }
-                /* Duplicate found. */
-                break;
-            }
-            link = link->next;
-        }
-        /*
-        * If no duplicate was found: add the base types's facet
-        * to the set.
-        */
-        if (link == NULL) {
-            link = (xmlSchemaFacetLinkPtr)
-                xmlMalloc(sizeof(xmlSchemaFacetLink));
-            if (link == NULL) {
-                xmlSchemaPErrMemory(pctxt,
-                    "deriving facets, creating a facet link", NULL);
-                return (-1);
-            }
-            link->facet = cur->facet;
-            link->next = NULL;
-            if (last == NULL)
-                type->facetSet = link;
-            else
-                last->next = link;
-            last = link;
-        }
-
-    }
-
-    return (0);
-internal_error:
-    PERROR_INT("xmlSchemaDeriveAndValidateFacets",
-        "an error occured");
-    return (-1);
-}
-
-static int
-xmlSchemaFinishMemberTypeDefinitionsProperty(xmlSchemaParserCtxtPtr pctxt,
-                                             xmlSchemaTypePtr type)
-{
-    xmlSchemaTypeLinkPtr link, lastLink, prevLink, subLink, newLink;
-    /*
-    * The actual value is then formed by replacing any union type
-    * definition in the `explicit members` with the members of their
-    * {member type definitions}, in order.
-    *
-    * TODO: There's a bug entry at
-    * "http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0287.html"
-    * which indicates that we'll keep the union types the future.
-    */
-    link = type->memberTypes;
-    while (link != NULL) {
-
-        if (WXS_IS_TYPE_NOT_FIXED(link->type))
-            xmlSchemaTypeFixup(link->type, ACTXT_CAST pctxt);
-
-        if (WXS_IS_UNION(link->type)) {
-            subLink = xmlSchemaGetUnionSimpleTypeMemberTypes(link->type);
-            if (subLink != NULL) {
-                link->type = subLink->type;
-                if (subLink->next != NULL) {
-                    lastLink = link->next;
-                    subLink = subLink->next;
-                    prevLink = link;
-                    while (subLink != NULL) {
-                        newLink = (xmlSchemaTypeLinkPtr)
-                            xmlMalloc(sizeof(xmlSchemaTypeLink));
-                        if (newLink == NULL) {
-                            xmlSchemaPErrMemory(pctxt, "allocating a type link",
-                                NULL);
-                            return (-1);
-                        }
-                        newLink->type = subLink->type;
-                        prevLink->next = newLink;
-                        prevLink = newLink;
-                        newLink->next = lastLink;
-
-                        subLink = subLink->next;
-                    }
-                }
-            }
-        }
-        link = link->next;
-    }
-    return (0);
-}
-
-static void
-xmlSchemaTypeFixupOptimFacets(xmlSchemaTypePtr type)
-{
-    int has = 0, needVal = 0, normVal = 0;
-
-    has = (type->baseType->flags & XML_SCHEMAS_TYPE_HAS_FACETS) ? 1 : 0;
-    if (has) {
-        needVal = (type->baseType->flags &
-            XML_SCHEMAS_TYPE_FACETSNEEDVALUE) ? 1 : 0;
-        normVal = (type->baseType->flags &
-            XML_SCHEMAS_TYPE_NORMVALUENEEDED) ? 1 : 0;
-    }
-    if (type->facets != NULL) {
-        xmlSchemaFacetPtr fac;
-
-        for (fac = type->facets; fac != NULL; fac = fac->next) {
-            switch (fac->type) {
-                case XML_SCHEMA_FACET_WHITESPACE:
-                    break;
-                case XML_SCHEMA_FACET_PATTERN:
-                    normVal = 1;
-                    has = 1;
-                    break;
-                case XML_SCHEMA_FACET_ENUMERATION:
-                    needVal = 1;
-                    normVal = 1;
-                    has = 1;
-                    break;
-                default:
-                    has = 1;
-                    break;
-            }
-        }
-    }
-    if (normVal)
-        type->flags |= XML_SCHEMAS_TYPE_NORMVALUENEEDED;
-    if (needVal)
-        type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
-    if (has)
-        type->flags |= XML_SCHEMAS_TYPE_HAS_FACETS;
-
-    if (has && (! needVal) && WXS_IS_ATOMIC(type)) {
-        xmlSchemaTypePtr prim = xmlSchemaGetPrimitiveType(type);
-        /*
-        * OPTIMIZE VAL TODO: Some facets need a computed value.
-        */
-        if ((prim->builtInType != XML_SCHEMAS_ANYSIMPLETYPE) &&
-            (prim->builtInType != XML_SCHEMAS_STRING)) {
-            type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
-        }
-    }
-}
-
-static int
-xmlSchemaTypeFixupWhitespace(xmlSchemaTypePtr type)
-{
-
-
-    /*
-    * Evaluate the whitespace-facet value.
-    */
-    if (WXS_IS_LIST(type)) {
-        type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
-        return (0);
-    } else if (WXS_IS_UNION(type))
-        return (0);
-
-    if (type->facetSet != NULL) {
-        xmlSchemaFacetLinkPtr lin;
-
-        for (lin = type->facetSet; lin != NULL; lin = lin->next) {
-            if (lin->facet->type == XML_SCHEMA_FACET_WHITESPACE) {
-                switch (lin->facet->whitespace) {
-                case XML_SCHEMAS_FACET_PRESERVE:
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
-                    break;
-                case XML_SCHEMAS_FACET_REPLACE:
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
-                    break;
-                case XML_SCHEMAS_FACET_COLLAPSE:
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
-                    break;
-                default:
-                    return (-1);
-                }
-                return (0);
-            }
-        }
-    }
-    /*
-    * For all `atomic` datatypes other than string (and types `derived`
-    * by `restriction` from it) the value of whiteSpace is fixed to
-    * collapse
-    */
-    {
-        xmlSchemaTypePtr anc;
-
-        for (anc = type->baseType; anc != NULL &&
-                anc->builtInType != XML_SCHEMAS_ANYTYPE;
-                anc = anc->baseType) {
-
-            if (anc->type == XML_SCHEMA_TYPE_BASIC) {
-                if (anc->builtInType == XML_SCHEMAS_NORMSTRING) {
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
-
-                } else if ((anc->builtInType == XML_SCHEMAS_STRING) ||
-                    (anc->builtInType == XML_SCHEMAS_ANYSIMPLETYPE)) {
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
-
-                } else
-                    type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
-                break;
-            }
-        }
-    }
-    return (0);
-}
-
-static int
-xmlSchemaFixupSimpleTypeStageOne(xmlSchemaParserCtxtPtr pctxt,
-                          xmlSchemaTypePtr type)
-{
-    if (type->type != XML_SCHEMA_TYPE_SIMPLE)
-        return(0);
-    if (! WXS_IS_TYPE_NOT_FIXED_1(type))
-        return(0);
-    type->flags |= XML_SCHEMAS_TYPE_FIXUP_1;
-
-    if (WXS_IS_LIST(type)) {
-        /*
-        * Corresponds to <simpleType><list>...
-        */
-        if (type->subtypes == NULL) {
-            /*
-            * This one is really needed, so get out.
-            */
-            PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
-                "list type has no item-type assigned");
-            return(-1);
-        }
-    } else if (WXS_IS_UNION(type)) {
-        /*
-        * Corresponds to <simpleType><union>...
-        */
-        if (type->memberTypes == NULL) {
-            /*
-            * This one is really needed, so get out.
-            */
-            PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
-                "union type has no member-types assigned");
-            return(-1);
-        }
-    } else {
-        /*
-        * Corresponds to <simpleType><restriction>...
-        */
-        if (type->baseType == NULL) {
-            PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
-                "type has no base-type assigned");
-            return(-1);
-        }
-        if (WXS_IS_TYPE_NOT_FIXED_1(type->baseType))
-            if (xmlSchemaFixupSimpleTypeStageOne(pctxt, type->baseType) == -1)
-                return(-1);
-        /*
-        * Variety
-        * If the <restriction> alternative is chosen, then the
-        * {variety} of the {base type definition}.
-        */
-        if (WXS_IS_ATOMIC(type->baseType))
-            type->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
-        else if (WXS_IS_LIST(type->baseType)) {
-            type->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
-            /*
-            * Inherit the itemType.
-            */
-            type->subtypes = type->baseType->subtypes;
-        } else if (WXS_IS_UNION(type->baseType)) {
-            type->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
-            /*
-            * NOTE that we won't assign the memberTypes of the base,
-            * since this will make trouble when freeing them; we will
-            * use a lookup function to access them instead.
-            */
-        }
-    }
-    return(0);
-}
-
-#ifdef DEBUG_TYPE
-static void
-xmlSchemaDebugFixedType(xmlSchemaParserCtxtPtr pctxt,
-                       xmlSchemaTypePtr type)
-{
-    if (type->node != NULL) {
-        xmlGenericError(xmlGenericErrorContext,
-                        "Type of %s : %s:%d :", name,
-                        type->node->doc->URL,
-                        xmlGetLineNo(type->node));
-    } else {
-        xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
-    }
-    if ((WXS_IS_SIMPLE(type)) || (WXS_IS_COMPLEX(type))) {
-        switch (type->contentType) {
-            case XML_SCHEMA_CONTENT_SIMPLE:
-                xmlGenericError(xmlGenericErrorContext, "simple\n");
-                break;
-            case XML_SCHEMA_CONTENT_ELEMENTS:
-                xmlGenericError(xmlGenericErrorContext, "elements\n");
-                break;
-            case XML_SCHEMA_CONTENT_UNKNOWN:
-                xmlGenericError(xmlGenericErrorContext, "unknown !!!\n");
-                break;
-            case XML_SCHEMA_CONTENT_EMPTY:
-                xmlGenericError(xmlGenericErrorContext, "empty\n");
-                break;
-            case XML_SCHEMA_CONTENT_MIXED:
-                if (xmlSchemaIsParticleEmptiable((xmlSchemaParticlePtr)
-                    type->subtypes))
-                    xmlGenericError(xmlGenericErrorContext,
-                        "mixed as emptiable particle\n");
-                else
-                    xmlGenericError(xmlGenericErrorContext, "mixed\n");
-                break;
-                /* Removed, since not used. */
-                /*
-                case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
-                xmlGenericError(xmlGenericErrorContext, "mixed or elems\n");
-                break;
-                */
-            case XML_SCHEMA_CONTENT_BASIC:
-                xmlGenericError(xmlGenericErrorContext, "basic\n");
-                break;
-            default:
-                xmlGenericError(xmlGenericErrorContext,
-                    "not registered !!!\n");
-                break;
-        }
-    }
-}
-#endif
-
-/*
-* 3.14.6 Constraints on Simple Type Definition Schema Components
-*/
-static int
-xmlSchemaFixupSimpleTypeStageTwo(xmlSchemaParserCtxtPtr pctxt,
-                                 xmlSchemaTypePtr type)
-{
-    int res, olderrs = pctxt->nberrors;
-
-    if (type->type != XML_SCHEMA_TYPE_SIMPLE)
-        return(-1);
-
-    if (! WXS_IS_TYPE_NOT_FIXED(type))
-        return(0);
-
-    type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
-    type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
-
-    if (type->baseType == NULL) {
-        PERROR_INT("xmlSchemaFixupSimpleTypeStageTwo",
-            "missing baseType");
-        goto exit_failure;
-    }
-    if (WXS_IS_TYPE_NOT_FIXED(type->baseType))
-        xmlSchemaTypeFixup(type->baseType, ACTXT_CAST pctxt);
-    /*
-    * If a member type of a union is a union itself, we need to substitute
-    * that member type for its member types.
-    * NOTE that this might change in WXS 1.1; i.e. we will keep the union
-    * types in WXS 1.1.
-    */
-    if ((type->memberTypes != NULL) &&
-        (xmlSchemaFinishMemberTypeDefinitionsProperty(pctxt, type) == -1))
-        return(-1);
-    /*
-    * SPEC src-simple-type 1
-    * "The corresponding simple type definition, if any, must satisfy
-    * the conditions set out in Constraints on Simple Type Definition
-    * Schema Components ($3.14.6)."
-    */
-    /*
-    * Schema Component Constraint: Simple Type Definition Properties Correct
-    * (st-props-correct)
-    */
-    res = xmlSchemaCheckSTPropsCorrect(pctxt, type);
-    HFAILURE HERROR
-    /*
-    * Schema Component Constraint: Derivation Valid (Restriction, Simple)
-    * (cos-st-restricts)
-    */
-    res = xmlSchemaCheckCOSSTRestricts(pctxt, type);
-    HFAILURE HERROR
-    /*
-    * TODO: Removed the error report, since it got annoying to get an
-    * extra error report, if anything failed until now.
-    * Enable this if needed.
-    *
-    * xmlSchemaPErr(ctxt, type->node,
-    *    XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
-    *    "Simple type '%s' does not satisfy the constraints "
-    *    "on simple type definitions.\n",
-    *    type->name, NULL);
-    */
-    /*
-    * Schema Component Constraint: Simple Type Restriction (Facets)
-    * (st-restrict-facets)
-    */
-    res = xmlSchemaCheckFacetValues(type, pctxt);
-    HFAILURE HERROR
-    if ((type->facetSet != NULL) ||
-        (type->baseType->facetSet != NULL)) {
-        res = xmlSchemaDeriveAndValidateFacets(pctxt, type);
-        HFAILURE HERROR
-    }
-    /*
-    * Whitespace value.
-    */
-    res = xmlSchemaTypeFixupWhitespace(type);
-    HFAILURE HERROR
-    xmlSchemaTypeFixupOptimFacets(type);
-
-exit_error:
-#ifdef DEBUG_TYPE
-    xmlSchemaDebugFixedType(pctxt, type);
-#endif
-    if (olderrs != pctxt->nberrors)
-        return(pctxt->err);
-    return(0);
-
-exit_failure:
-#ifdef DEBUG_TYPE
-    xmlSchemaDebugFixedType(pctxt, type);
-#endif
-    return(-1);
-}
-
-static int
-xmlSchemaFixupComplexType(xmlSchemaParserCtxtPtr pctxt,
-                          xmlSchemaTypePtr type)
-{
-    int res = 0, olderrs = pctxt->nberrors;
-    xmlSchemaTypePtr baseType = type->baseType;
-
-    if (! WXS_IS_TYPE_NOT_FIXED(type))
-        return(0);
-    type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
-    if (baseType == NULL) {
-        PERROR_INT("xmlSchemaFixupComplexType",
-            "missing baseType");
-        goto exit_failure;
-    }
-    /*
-    * Fixup the base type.
-    */
-    if (WXS_IS_TYPE_NOT_FIXED(baseType))
-        xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt);
-    if (baseType->flags & XML_SCHEMAS_TYPE_INTERNAL_INVALID) {
-        /*
-        * Skip fixup if the base type is invalid.
-        * TODO: Generate a warning!
-        */
-        return(0);
-    }
-    /*
-    * This basically checks if the base type can be derived.
-    */
-    res = xmlSchemaCheckSRCCT(pctxt, type);
-    HFAILURE HERROR
-    /*
-    * Fixup the content type.
-    */
-    if (type->contentType == XML_SCHEMA_CONTENT_SIMPLE) {
-        /*
-        * Corresponds to <complexType><simpleContent>...
-        */
-        if ((WXS_IS_COMPLEX(baseType)) &&
-            (baseType->contentTypeDef != NULL) &&
-            (WXS_IS_RESTRICTION(type))) {
-            xmlSchemaTypePtr contentBase, content;
-#ifdef ENABLE_NAMED_LOCALS
-            char buf[30];
-            const xmlChar *tmpname;
-#endif
-            /*
-            * SPEC (1) If <restriction> + base type is <complexType>,
-            * "whose own {content type} is a simple type..."
-            */
-            if (type->contentTypeDef != NULL) {
-                /*
-                * SPEC (1.1) "the simple type definition corresponding to the
-                * <simpleType> among the [children] of <restriction> if there
-                * is one;"
-                * Note that this "<simpleType> among the [children]" was put
-                * into ->contentTypeDef during parsing.
-                */
-                contentBase = type->contentTypeDef;
-                type->contentTypeDef = NULL;
-            } else {
-                /*
-                * (1.2) "...otherwise (<restriction> has no <simpleType>
-                * among its [children]), the simple type definition which
-                * is the {content type} of the ... base type."
-                */
-                contentBase = baseType->contentTypeDef;
-            }
-            /*
-            * SPEC
-            * "... a simple type definition which restricts the simple
-            * type definition identified in clause 1.1 or clause 1.2
-            * with a set of facet components"
-            *
-            * Create the anonymous simple type, which will be the content
-            * type of the complex type.
-            */
-#ifdef ENABLE_NAMED_LOCALS
-            snprintf(buf, 29, "#scST%d", ++(pctxt->counter));
-            tmpname = xmlDictLookup(pctxt->dict, BAD_CAST buf, -1);
-            content = xmlSchemaAddType(pctxt, pctxt->schema,
-                XML_SCHEMA_TYPE_SIMPLE, tmpname, type->targetNamespace,
-                type->node, 0);
-#else
-            content = xmlSchemaAddType(pctxt, pctxt->schema,
-                XML_SCHEMA_TYPE_SIMPLE, NULL, type->targetNamespace,
-                type->node, 0);
-#endif
-            if (content == NULL)
-                goto exit_failure;
-            /*
-            * We will use the same node as for the <complexType>
-            * to have it somehow anchored in the schema doc.
-            */
-            content->type = XML_SCHEMA_TYPE_SIMPLE;
-            content->baseType = contentBase;
-            /*
-            * Move the facets, previously anchored on the
-            * complexType during parsing.
-            */
-            content->facets = type->facets;
-            type->facets = NULL;
-            content->facetSet = type->facetSet;
-            type->facetSet = NULL;
-
-            type->contentTypeDef = content;
-            if (WXS_IS_TYPE_NOT_FIXED(contentBase))
-                xmlSchemaTypeFixup(contentBase, ACTXT_CAST pctxt);
-            /*
-            * Fixup the newly created type. We don't need to check
-            * for circularity here.
-            */
-            res = xmlSchemaFixupSimpleTypeStageOne(pctxt, content);
-            HFAILURE HERROR
-            res = xmlSchemaFixupSimpleTypeStageTwo(pctxt, content);
-            HFAILURE HERROR
-
-        } else if ((WXS_IS_COMPLEX(baseType)) &&
-            (baseType->contentType == XML_SCHEMA_CONTENT_MIXED) &&
-            (WXS_IS_RESTRICTION(type))) {
-            /*
-            * SPEC (2) If <restriction> + base is a mixed <complexType> with
-            * an emptiable particle, then a simple type definition which
-            * restricts the <restriction>'s <simpleType> child.
-            */
-            if ((type->contentTypeDef == NULL) ||
-                (type->contentTypeDef->baseType == NULL)) {
-                /*
-                * TODO: Check if this ever happens.
-                */
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_INTERNAL,
-                    WXS_BASIC_CAST type, NULL,
-                    "Internal error: xmlSchemaTypeFixup, "
-                    "complex type '%s': the <simpleContent><restriction> "
-                    "is missing a <simpleType> child, but was not catched "
-                    "by xmlSchemaCheckSRCCT()", type->name);
-                goto exit_failure;
-            }
-        } else if ((WXS_IS_COMPLEX(baseType)) && WXS_IS_EXTENSION(type)) {
-            /*
-            * SPEC (3) If <extension> + base is <complexType> with
-            * <simpleType> content, "...then the {content type} of that
-            * complex type definition"
-            */
-            if (baseType->contentTypeDef == NULL) {
-                /*
-                * TODO: Check if this ever happens. xmlSchemaCheckSRCCT
-                * should have catched this already.
-                */
-                xmlSchemaPCustomErr(pctxt,
-                    XML_SCHEMAP_INTERNAL,
-                    WXS_BASIC_CAST type, NULL,
-                    "Internal error: xmlSchemaTypeFixup, "
-                    "complex type '%s': the <extension>ed base type is "
-                    "a complex type with no simple content type",
-                    type->name);
-                goto exit_failure;
-            }
-            type->contentTypeDef = baseType->contentTypeDef;
-        } else if ((WXS_IS_SIMPLE(baseType)) && WXS_IS_EXTENSION(type)) {
-            /*
-            * SPEC (4) <extension> + base is <simpleType>
-            * "... then that simple type definition"
-            */
-            type->contentTypeDef = baseType;
-        } else {
-            /*
-            * TODO: Check if this ever happens.
-            */
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_INTERNAL,
-                WXS_BASIC_CAST type, NULL,
-                "Internal error: xmlSchemaTypeFixup, "
-                "complex type '%s' with <simpleContent>: unhandled "
-                "derivation case", type->name);
-            goto exit_failure;
-        }
-    } else {
-        int dummySequence = 0;
-        xmlSchemaParticlePtr particle =
-            (xmlSchemaParticlePtr) type->subtypes;
-        /*
-        * Corresponds to <complexType><complexContent>...
-        *
-        * NOTE that the effective mixed was already set during parsing of
-        * <complexType> and <complexContent>; its flag value is
-        * XML_SCHEMAS_TYPE_MIXED.
-        *
-        * Compute the "effective content":
-        * (2.1.1) + (2.1.2) + (2.1.3)
-        */
-        if ((particle == NULL) ||
-            ((particle->type == XML_SCHEMA_TYPE_PARTICLE) &&
-            ((particle->children->type == XML_SCHEMA_TYPE_ALL) ||
-            (particle->children->type == XML_SCHEMA_TYPE_SEQUENCE) ||
-            ((particle->children->type == XML_SCHEMA_TYPE_CHOICE) &&
-            (particle->minOccurs == 0))) &&
-            ( ((xmlSchemaTreeItemPtr) particle->children)->children == NULL))) {
-            if (type->flags & XML_SCHEMAS_TYPE_MIXED) {
-                /*
-                * SPEC (2.1.4) "If the `effective mixed` is true, then
-                * a particle whose properties are as follows:..."
-                *
-                * Empty sequence model group with
-                * minOccurs/maxOccurs = 1 (i.e. a "particle emptiable").
-                * NOTE that we sill assign it the <complexType> node to
-                * somehow anchor it in the doc.
-                */
-                if ((particle == NULL) ||
-                    (particle->children->type != XML_SCHEMA_TYPE_SEQUENCE)) {
-                    /*
-                    * Create the particle.
-                    */
-                    particle = xmlSchemaAddParticle(pctxt,
-                        type->node, 1, 1);
-                    if (particle == NULL)
-                        goto exit_failure;
-                    /*
-                    * Create the model group.
-                    */ /* URGENT TODO: avoid adding to pending items. */
-                    particle->children = (xmlSchemaTreeItemPtr)
-                        xmlSchemaAddModelGroup(pctxt, pctxt->schema,
-                        XML_SCHEMA_TYPE_SEQUENCE, type->node);
-                    if (particle->children == NULL)
-                        goto exit_failure;
-
-                    type->subtypes = (xmlSchemaTypePtr) particle;
-                }
-                dummySequence = 1;
-                type->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
-            } else {
-                /*
-                * SPEC (2.1.5) "otherwise empty"
-                */
-                type->contentType = XML_SCHEMA_CONTENT_EMPTY;
-            }
-        } else {
-            /*
-            * SPEC (2.2) "otherwise the particle corresponding to the
-            * <all>, <choice>, <group> or <sequence> among the
-            * [children]."
-            */
-            type->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
-        }
-        /*
-        * Compute the "content type".
-        */
-        if (WXS_IS_RESTRICTION(type)) {
-            /*
-            * SPEC (3.1) "If <restriction>..."
-            * (3.1.1) + (3.1.2) */
-            if (type->contentType != XML_SCHEMA_CONTENT_EMPTY) {
-                if (type->flags & XML_SCHEMAS_TYPE_MIXED)
-                    type->contentType = XML_SCHEMA_CONTENT_MIXED;
-            }
-        } else {
-            /*
-            * SPEC (3.2) "If <extension>..."
-            */
-            if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
-                /*
-                * SPEC (3.2.1)
-                * "If the `effective content` is empty, then the
-                *  {content type} of the [...] base ..."
-                */
-                type->contentType = baseType->contentType;
-                type->subtypes = baseType->subtypes;
-                /*
-                * Fixes bug #347316:
-                * This is the case when the base type has a simple
-                * type definition as content.
-                */
-                type->contentTypeDef = baseType->contentTypeDef;
-                /*
-                * NOTE that the effective mixed is ignored here.
-                */
-            } else if (baseType->contentType == XML_SCHEMA_CONTENT_EMPTY) {
-                /*
-                * SPEC (3.2.2)
-                */
-                if (type->flags & XML_SCHEMAS_TYPE_MIXED)
-                    type->contentType = XML_SCHEMA_CONTENT_MIXED;
-            } else {
-                /*
-                * SPEC (3.2.3)
-                */
-                if (type->flags & XML_SCHEMAS_TYPE_MIXED)
-                    type->contentType = XML_SCHEMA_CONTENT_MIXED;
-                    /*
-                    * "A model group whose {compositor} is sequence and whose
-                    * {particles} are..."
-                    */
-                if ((WXS_TYPE_PARTICLE(type) != NULL) &&
-                    (WXS_TYPE_PARTICLE_TERM(type) != NULL) &&
-                    ((WXS_TYPE_PARTICLE_TERM(type))->type ==
-                        XML_SCHEMA_TYPE_ALL))
-                {
-                    /*
-                    * SPEC cos-all-limited (1)
-                    */
-                    xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                        /* TODO: error code */
-                        XML_SCHEMAP_COS_ALL_LIMITED,
-                        WXS_ITEM_NODE(type), NULL,
-                        "The type has an 'all' model group in its "
-                        "{content type} and thus cannot be derived from "
-                        "a non-empty type, since this would produce a "
-                        "'sequence' model group containing the 'all' "
-                        "model group; 'all' model groups are not "
-                        "allowed to appear inside other model groups",
-                        NULL, NULL);
-
-                } else if ((WXS_TYPE_PARTICLE(baseType) != NULL) &&
-                    (WXS_TYPE_PARTICLE_TERM(baseType) != NULL) &&
-                    ((WXS_TYPE_PARTICLE_TERM(baseType))->type ==
-                        XML_SCHEMA_TYPE_ALL))
-                {
-                    /*
-                    * SPEC cos-all-limited (1)
-                    */
-                    xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                        /* TODO: error code */
-                        XML_SCHEMAP_COS_ALL_LIMITED,
-                        WXS_ITEM_NODE(type), NULL,
-                        "A type cannot be derived by extension from a type "
-                        "which has an 'all' model group in its "
-                        "{content type}, since this would produce a "
-                        "'sequence' model group containing the 'all' "
-                        "model group; 'all' model groups are not "
-                        "allowed to appear inside other model groups",
-                        NULL, NULL);
-
-                } else if (! dummySequence) {
-                    xmlSchemaTreeItemPtr effectiveContent =
-                        (xmlSchemaTreeItemPtr) type->subtypes;
-                    /*
-                    * Create the particle.
-                    */
-                    particle = xmlSchemaAddParticle(pctxt,
-                        type->node, 1, 1);
-                    if (particle == NULL)
-                        goto exit_failure;
-                    /*
-                    * Create the "sequence" model group.
-                    */
-                    particle->children = (xmlSchemaTreeItemPtr)
-                        xmlSchemaAddModelGroup(pctxt, pctxt->schema,
-                        XML_SCHEMA_TYPE_SEQUENCE, type->node);
-                    if (particle->children == NULL)
-                        goto exit_failure;
-                    WXS_TYPE_CONTENTTYPE(type) = (xmlSchemaTypePtr) particle;
-                    /*
-                    * SPEC "the particle of the {content type} of
-                    * the ... base ..."
-                    * Create a duplicate of the base type's particle
-                    * and assign its "term" to it.
-                    */
-                    particle->children->children =
-                        (xmlSchemaTreeItemPtr) xmlSchemaAddParticle(pctxt,
-                        type->node,
-                        ((xmlSchemaParticlePtr) baseType->subtypes)->minOccurs,
-                        ((xmlSchemaParticlePtr) baseType->subtypes)->maxOccurs);
-                    if (particle->children->children == NULL)
-                        goto exit_failure;
-                    particle = (xmlSchemaParticlePtr)
-                        particle->children->children;
-                    particle->children =
-                        ((xmlSchemaParticlePtr) baseType->subtypes)->children;
-                    /*
-                    * SPEC "followed by the `effective content`."
-                    */
-                    particle->next = effectiveContent;
-                    /*
-                    * This all will result in:
-                    * new-particle
-                    *   --> new-sequence(
-                    *         new-particle
-                    *           --> base-model,
-                    *         this-particle
-                    *           --> this-model
-                    *       )
-                    */
-                } else {
-                    /*
-                    * This is the case when there is already an empty
-                    * <sequence> with minOccurs==maxOccurs==1.
-                    * Just add the base types's content type.
-                    * NOTE that, although we miss to add an intermediate
-                    * <sequence>, this should produce no difference to
-                    * neither the regex compilation of the content model,
-                    * nor to the complex type contraints.
-                    */
-                    particle->children->children =
-                        (xmlSchemaTreeItemPtr) baseType->subtypes;
-                }
-            }
-        }
-    }
-    /*
-    * Now fixup attribute uses:
-    *   - expand attr. group references
-    *     - intersect attribute wildcards
-    *   - inherit attribute uses of the base type
-    *   - inherit or union attr. wildcards if extending
-    *   - apply attr. use prohibitions if restricting
-    */
-    res = xmlSchemaFixupTypeAttributeUses(pctxt, type);
-    HFAILURE HERROR
-    /*
-    * Apply the complex type component constraints; this will not
-    * check attributes, since this is done in
-    * xmlSchemaFixupTypeAttributeUses().
-    */
-    res = xmlSchemaCheckCTComponent(pctxt, type);
-    HFAILURE HERROR
-
-#ifdef DEBUG_TYPE
-    xmlSchemaDebugFixedType(pctxt, type);
-#endif
-    if (olderrs != pctxt->nberrors)
-        return(pctxt->err);
-    else
-        return(0);
-
-exit_error:
-    type->flags |= XML_SCHEMAS_TYPE_INTERNAL_INVALID;
-#ifdef DEBUG_TYPE
-    xmlSchemaDebugFixedType(pctxt, type);
-#endif
-    return(pctxt->err);
-
-exit_failure:
-    type->flags |= XML_SCHEMAS_TYPE_INTERNAL_INVALID;
-#ifdef DEBUG_TYPE
-    xmlSchemaDebugFixedType(pctxt, type);
-#endif
-    return(-1);
-}
-
-
-/**
- * xmlSchemaTypeFixup:
- * @typeDecl:  the schema type definition
- * @ctxt:  the schema parser context
- *
- * Fixes the content model of the type.
- * URGENT TODO: We need an int result!
- */
-static int
-xmlSchemaTypeFixup(xmlSchemaTypePtr type,
-                   xmlSchemaAbstractCtxtPtr actxt)
-{
-    if (type == NULL)
-        return(0);
-    if (actxt->type != XML_SCHEMA_CTXT_PARSER) {
-        AERROR_INT("xmlSchemaTypeFixup",
-            "this function needs a parser context");
-        return(-1);
-    }
-    if (! WXS_IS_TYPE_NOT_FIXED(type))
-        return(0);
-    if (type->type == XML_SCHEMA_TYPE_COMPLEX)
-        return(xmlSchemaFixupComplexType(PCTXT_CAST actxt, type));
-    else if (type->type == XML_SCHEMA_TYPE_SIMPLE)
-        return(xmlSchemaFixupSimpleTypeStageTwo(PCTXT_CAST actxt, type));
-    return(0);
-}
-
-/**
- * xmlSchemaCheckFacet:
- * @facet:  the facet
- * @typeDecl:  the schema type definition
- * @pctxt:  the schema parser context or NULL
- * @name: the optional name of the type
- *
- * Checks and computes the values of facets.
- *
- * Returns 0 if valid, a positive error code if not valid and
- *         -1 in case of an internal or API error.
- */
-int
-xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
-                    xmlSchemaTypePtr typeDecl,
-                    xmlSchemaParserCtxtPtr pctxt,
-                    const xmlChar * name ATTRIBUTE_UNUSED)
-{
-    int ret = 0, ctxtGiven;
-
-    if ((facet == NULL) || (typeDecl == NULL))
-        return(-1);
-    /*
-    * TODO: will the parser context be given if used from
-    * the relaxNG module?
-    */
-    if (pctxt == NULL)
-        ctxtGiven = 0;
-    else
-        ctxtGiven = 1;
-
-    switch (facet->type) {
-        case XML_SCHEMA_FACET_MININCLUSIVE:
-        case XML_SCHEMA_FACET_MINEXCLUSIVE:
-        case XML_SCHEMA_FACET_MAXINCLUSIVE:
-        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-        case XML_SCHEMA_FACET_ENUMERATION: {
-                /*
-                 * Okay we need to validate the value
-                 * at that point.
-                 */
-                xmlSchemaTypePtr base;
-
-                /* 4.3.5.5 Constraints on enumeration Schema Components
-                * Schema Component Constraint: enumeration valid restriction
-                * It is an `error` if any member of {value} is not in the
-                * `value space` of {base type definition}.
-                *
-                * minInclusive, maxInclusive, minExclusive, maxExclusive:
-                * The value `must` be in the
-                * `value space` of the `base type`.
-                */
-                /*
-                * This function is intended to deliver a compiled value
-                * on the facet. In this implementation of XML Schemata the
-                * type holding a facet, won't be a built-in type.
-                * Thus to ensure that other API
-                * calls (relaxng) do work, if the given type is a built-in
-                * type, we will assume that the given built-in type *is
-                * already* the base type.
-                */
-                if (typeDecl->type != XML_SCHEMA_TYPE_BASIC) {
-                    base = typeDecl->baseType;
-                    if (base == NULL) {
-                        PERROR_INT("xmlSchemaCheckFacet",
-                            "a type user derived type has no base type");
-                        return (-1);
-                    }
-                } else
-                    base = typeDecl;
-
-                if (! ctxtGiven) {
-                    /*
-                    * A context is needed if called from RelaxNG.
-                    */
-                    pctxt = xmlSchemaNewParserCtxt("*");
-                    if (pctxt == NULL)
-                        return (-1);
-                }
-                /*
-                * NOTE: This call does not check the content nodes,
-                * since they are not available:
-                * facet->node is just the node holding the facet
-                * definition, *not* the attribute holding the *value*
-                * of the facet.
-                */
-                ret = xmlSchemaVCheckCVCSimpleType(
-                    ACTXT_CAST pctxt, facet->node, base,
-                    facet->value, &(facet->val), 1, 1, 0);
-                if (ret != 0) {
-                    if (ret < 0) {
-                        /* No error message for RelaxNG. */
-                        if (ctxtGiven) {
-                            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                                XML_SCHEMAP_INTERNAL, facet->node, NULL,
-                                "Internal error: xmlSchemaCheckFacet, "
-                                "failed to validate the value '%s' of the "
-                                "facet '%s' against the base type",
-                                facet->value, xmlSchemaFacetTypeToString(facet->type));
-                        }
-                        goto internal_error;
-                    }
-                    ret = XML_SCHEMAP_INVALID_FACET_VALUE;
-                    /* No error message for RelaxNG. */
-                    if (ctxtGiven) {
-                        xmlChar *str = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            ret, facet->node, WXS_BASIC_CAST facet,
-                            "The value '%s' of the facet does not validate "
-                            "against the base type '%s'",
-                            facet->value,
-                            xmlSchemaFormatQName(&str,
-                                base->targetNamespace, base->name));
-                        FREE_AND_NULL(str);
-                    }
-                    goto exit;
-                } else if (facet->val == NULL) {
-                    if (ctxtGiven) {
-                        PERROR_INT("xmlSchemaCheckFacet",
-                            "value was not computed");
-                    }
-                    TODO
-                }
-                break;
-            }
-        case XML_SCHEMA_FACET_PATTERN:
-            facet->regexp = xmlRegexpCompile(facet->value);
-            if (facet->regexp == NULL) {
-                ret = XML_SCHEMAP_REGEXP_INVALID;
-                /* No error message for RelaxNG. */
-                if (ctxtGiven) {
-                    xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                        ret, facet->node, WXS_BASIC_CAST typeDecl,
-                        "The value '%s' of the facet 'pattern' is not a "
-                        "valid regular expression",
-                        facet->value, NULL);
-                }
-            }
-            break;
-        case XML_SCHEMA_FACET_TOTALDIGITS:
-        case XML_SCHEMA_FACET_FRACTIONDIGITS:
-        case XML_SCHEMA_FACET_LENGTH:
-        case XML_SCHEMA_FACET_MAXLENGTH:
-        case XML_SCHEMA_FACET_MINLENGTH:
-
-            if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) {
-                ret = xmlSchemaValidatePredefinedType(
-                    xmlSchemaGetBuiltInType(XML_SCHEMAS_PINTEGER),
-                    facet->value, &(facet->val));
-            } else {
-                ret = xmlSchemaValidatePredefinedType(
-                    xmlSchemaGetBuiltInType(XML_SCHEMAS_NNINTEGER),
-                    facet->value, &(facet->val));
-            }
-            if (ret != 0) {
-                if (ret < 0) {
-                    /* No error message for RelaxNG. */
-                    if (ctxtGiven) {
-                        PERROR_INT("xmlSchemaCheckFacet",
-                            "validating facet value");
-                    }
-                    goto internal_error;
-                }
-                ret = XML_SCHEMAP_INVALID_FACET_VALUE;
-                /* No error message for RelaxNG. */
-                if (ctxtGiven) {
-                    /* error code */
-                    xmlSchemaCustomErr4(ACTXT_CAST pctxt,
-                        ret, facet->node, WXS_BASIC_CAST typeDecl,
-                        "The value '%s' of the facet '%s' is not a valid '%s'",
-                        facet->value,
-                        xmlSchemaFacetTypeToString(facet->type),
-                        (facet->type != XML_SCHEMA_FACET_TOTALDIGITS) ?
-                            BAD_CAST "nonNegativeInteger" :
-                            BAD_CAST "positiveInteger",
-                        NULL);
-                }
-            }
-            break;
-
-        case XML_SCHEMA_FACET_WHITESPACE:{
-                if (xmlStrEqual(facet->value, BAD_CAST "preserve")) {
-                    facet->whitespace = XML_SCHEMAS_FACET_PRESERVE;
-                } else if (xmlStrEqual(facet->value, BAD_CAST "replace")) {
-                    facet->whitespace = XML_SCHEMAS_FACET_REPLACE;
-                } else if (xmlStrEqual(facet->value, BAD_CAST "collapse")) {
-                    facet->whitespace = XML_SCHEMAS_FACET_COLLAPSE;
-                } else {
-                    ret = XML_SCHEMAP_INVALID_FACET_VALUE;
-                    /* No error message for RelaxNG. */
-                    if (ctxtGiven) {
-                        /* error was previously: XML_SCHEMAP_INVALID_WHITE_SPACE */
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            ret, facet->node, WXS_BASIC_CAST typeDecl,
-                            "The value '%s' of the facet 'whitespace' is not "
-                            "valid", facet->value, NULL);
-                    }
-                }
-            }
-        default:
-            break;
-    }
-exit:
-    if ((! ctxtGiven) && (pctxt != NULL))
-        xmlSchemaFreeParserCtxt(pctxt);
-    return (ret);
-internal_error:
-    if ((! ctxtGiven) && (pctxt != NULL))
-        xmlSchemaFreeParserCtxt(pctxt);
-    return (-1);
-}
-
-/**
- * xmlSchemaCheckFacetValues:
- * @typeDecl:  the schema type definition
- * @ctxt:  the schema parser context
- *
- * Checks the default values types, especially for facets
- */
-static int
-xmlSchemaCheckFacetValues(xmlSchemaTypePtr typeDecl,
-                          xmlSchemaParserCtxtPtr pctxt)
-{
-    int res, olderrs = pctxt->nberrors;
-    const xmlChar *name = typeDecl->name;
-    /*
-    * NOTE: It is intended to use the facets list, instead
-    * of facetSet.
-    */
-    if (typeDecl->facets != NULL) {
-        xmlSchemaFacetPtr facet = typeDecl->facets;
-
-        /*
-        * Temporarily assign the "schema" to the validation context
-        * of the parser context. This is needed for NOTATION validation.
-        */
-        if (pctxt->vctxt == NULL) {
-            if (xmlSchemaCreateVCtxtOnPCtxt(pctxt) == -1)
-                return(-1);
-        }
-        pctxt->vctxt->schema = pctxt->schema;
-        while (facet != NULL) {
-            res = xmlSchemaCheckFacet(facet, typeDecl, pctxt, name);
-            HFAILURE
-            facet = facet->next;
-        }
-        pctxt->vctxt->schema = NULL;
-    }
-    if (olderrs != pctxt->nberrors)
-        return(pctxt->err);
-    return(0);
-exit_failure:
-    return(-1);
-}
-
-/**
- * xmlSchemaGetCircModelGrDefRef:
- * @ctxtMGroup: the searched model group
- * @selfMGroup: the second searched model group
- * @particle: the first particle
- *
- * This one is intended to be used by
- * xmlSchemaCheckGroupDefCircular only.
- *
- * Returns the particle with the circular model group definition reference,
- * otherwise NULL.
- */
-static xmlSchemaTreeItemPtr
-xmlSchemaGetCircModelGrDefRef(xmlSchemaModelGroupDefPtr groupDef,
-                              xmlSchemaTreeItemPtr particle)
-{
-    xmlSchemaTreeItemPtr circ = NULL;
-    xmlSchemaTreeItemPtr term;
-    xmlSchemaModelGroupDefPtr gdef;
-
-    for (; particle != NULL; particle = particle->next) {
-        term = particle->children;
-        if (term == NULL)
-            continue;
-        switch (term->type) {
-            case XML_SCHEMA_TYPE_GROUP:
-                gdef = (xmlSchemaModelGroupDefPtr) term;
-                if (gdef == groupDef)
-                    return (particle);
-                /*
-                * Mark this model group definition to avoid infinite
-                * recursion on circular references not yet examined.
-                */
-                if (gdef->flags & XML_SCHEMA_MODEL_GROUP_DEF_MARKED)
-                    continue;
-                if (gdef->children != NULL) {
-                    gdef->flags |= XML_SCHEMA_MODEL_GROUP_DEF_MARKED;
-                    circ = xmlSchemaGetCircModelGrDefRef(groupDef,
-                        gdef->children->children);
-                    gdef->flags ^= XML_SCHEMA_MODEL_GROUP_DEF_MARKED;
-                    if (circ != NULL)
-                        return (circ);
-                }
-                break;
-            case XML_SCHEMA_TYPE_SEQUENCE:
-            case XML_SCHEMA_TYPE_CHOICE:
-            case XML_SCHEMA_TYPE_ALL:
-                circ = xmlSchemaGetCircModelGrDefRef(groupDef, term->children);
-                if (circ != NULL)
-                    return (circ);
-                break;
-            default:
-                break;
-        }
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaCheckGroupDefCircular:
- * @item:  the model group definition
- * @ctxt:  the parser context
- * @name:  the name
- *
- * Checks for circular references to model group definitions.
- */
-static void
-xmlSchemaCheckGroupDefCircular(xmlSchemaModelGroupDefPtr item,
-                               xmlSchemaParserCtxtPtr ctxt)
-{
-    /*
-    * Schema Component Constraint: Model Group Correct
-    * 2 Circular groups are disallowed. That is, within the {particles}
-    * of a group there must not be at any depth a particle whose {term}
-    * is the group itself.
-    */
-    if ((item == NULL) ||
-        (item->type != XML_SCHEMA_TYPE_GROUP) ||
-        (item->children == NULL))
-        return;
-    {
-        xmlSchemaTreeItemPtr circ;
-
-        circ = xmlSchemaGetCircModelGrDefRef(item, item->children->children);
-        if (circ != NULL) {
-            xmlChar *str = NULL;
-            /*
-            * TODO: The error report is not adequate: this constraint
-            * is defined for model groups but not definitions, but since
-            * there cannot be any circular model groups without a model group
-            * definition (if not using a construction API), we check those
-            * defintions only.
-            */
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_MG_PROPS_CORRECT_2,
-                NULL, WXS_ITEM_NODE(circ),
-                "Circular reference to the model group definition '%s' "
-                "defined", xmlSchemaFormatQName(&str,
-                    item->targetNamespace, item->name));
-            FREE_AND_NULL(str)
-            /*
-            * NOTE: We will cut the reference to avoid further
-            * confusion of the processor. This is a fatal error.
-            */
-            circ->children = NULL;
-        }
-    }
-}
-
-/**
- * xmlSchemaModelGroupToModelGroupDefFixup:
- * @ctxt:  the parser context
- * @mg:  the model group
- *
- * Assigns the model group of model group definitions to the "term"
- * of the referencing particle.
- * In xmlSchemaResolveModelGroupParticleReferences the model group
- * definitions were assigned to the "term", since needed for the
- * circularity check.
- *
- * Schema Component Constraint:
- *     All Group Limited (cos-all-limited) (1.2)
- */
-static void
-xmlSchemaModelGroupToModelGroupDefFixup(
-    xmlSchemaParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
-    xmlSchemaModelGroupPtr mg)
-{
-    xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
-
-    while (particle != NULL) {
-        if ((WXS_PARTICLE_TERM(particle) == NULL) ||
-            ((WXS_PARTICLE_TERM(particle))->type !=
-                XML_SCHEMA_TYPE_GROUP))
-        {
-            particle = WXS_PTC_CAST particle->next;
-            continue;
-        }
-        if (WXS_MODELGROUPDEF_MODEL(WXS_PARTICLE_TERM(particle)) == NULL) {
-            /*
-            * TODO: Remove the particle.
-            */
-            WXS_PARTICLE_TERM(particle) = NULL;
-            particle = WXS_PTC_CAST particle->next;
-            continue;
-        }
-        /*
-        * Assign the model group to the {term} of the particle.
-        */
-        WXS_PARTICLE_TERM(particle) =
-            WXS_TREE_CAST WXS_MODELGROUPDEF_MODEL(WXS_PARTICLE_TERM(particle));
-
-        particle = WXS_PTC_CAST particle->next;
-    }
-}
-
-/**
- * xmlSchemaCheckAttrGroupCircularRecur:
- * @ctxtGr: the searched attribute group
- * @attr: the current attribute list to be processed
- *
- * This one is intended to be used by
- * xmlSchemaCheckAttrGroupCircular only.
- *
- * Returns the circular attribute grou reference, otherwise NULL.
- */
-static xmlSchemaQNameRefPtr
-xmlSchemaCheckAttrGroupCircularRecur(xmlSchemaAttributeGroupPtr ctxtGr,
-                                     xmlSchemaItemListPtr list)
-{
-    xmlSchemaAttributeGroupPtr gr;
-    xmlSchemaQNameRefPtr ref, circ;
-    int i;
-    /*
-    * We will search for an attribute group reference which
-    * references the context attribute group.
-    */
-    for (i = 0; i < list->nbItems; i++) {
-        ref = list->items[i];
-        if ((ref->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
-            (ref->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
-            (ref->item != NULL))
-        {
-            gr = WXS_ATTR_GROUP_CAST ref->item;
-            if (gr == ctxtGr)
-                return(ref);
-            if (gr->flags & XML_SCHEMAS_ATTRGROUP_MARKED)
-                continue;
-            /*
-            * Mark as visited to avoid infinite recursion on
-            * circular references not yet examined.
-            */
-            if ((gr->attrUses) &&
-                (gr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS))
-            {
-                gr->flags |= XML_SCHEMAS_ATTRGROUP_MARKED;
-                circ = xmlSchemaCheckAttrGroupCircularRecur(ctxtGr,
-                    (xmlSchemaItemListPtr) gr->attrUses);
-                gr->flags ^= XML_SCHEMAS_ATTRGROUP_MARKED;
-                if (circ != NULL)
-                    return (circ);
-            }
-
-        }
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaCheckAttrGroupCircular:
- * attrGr:  the attribute group definition
- * @ctxt:  the parser context
- * @name:  the name
- *
- * Checks for circular references of attribute groups.
- */
-static int
-xmlSchemaCheckAttrGroupCircular(xmlSchemaAttributeGroupPtr attrGr,
-                                xmlSchemaParserCtxtPtr ctxt)
-{
-    /*
-    * Schema Representation Constraint:
-    * Attribute Group Definition Representation OK
-    * 3 Circular group reference is disallowed outside <redefine>.
-    * That is, unless this element information item's parent is
-    * <redefine>, then among the [children], if any, there must
-    * not be an <attributeGroup> with ref [attribute] which resolves
-    * to the component corresponding to this <attributeGroup>. Indirect
-    * circularity is also ruled out. That is, when QName resolution
-    * (Schema Document) ($3.15.3) is applied to a `QName` arising from
-    * any <attributeGroup>s with a ref [attribute] among the [children],
-    * it must not be the case that a `QName` is encountered at any depth
-    * which resolves to the component corresponding to this <attributeGroup>.
-    */
-    if (attrGr->attrUses == NULL)
-        return(0);
-    else if ((attrGr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS) == 0)
-        return(0);
-    else {
-        xmlSchemaQNameRefPtr circ;
-
-        circ = xmlSchemaCheckAttrGroupCircularRecur(attrGr,
-            (xmlSchemaItemListPtr) attrGr->attrUses);
-        if (circ != NULL) {
-            xmlChar *str = NULL;
-            /*
-            * TODO: Report the referenced attr group as QName.
-            */
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
-                NULL, WXS_ITEM_NODE(WXS_BASIC_CAST circ),
-                "Circular reference to the attribute group '%s' "
-                "defined", xmlSchemaGetComponentQName(&str, attrGr));
-            FREE_AND_NULL(str);
-            /*
-            * NOTE: We will cut the reference to avoid further
-            * confusion of the processor.
-            * BADSPEC TODO: The spec should define how to process in this case.
-            */
-            circ->item = NULL;
-            return(ctxt->err);
-        }
-    }
-    return(0);
-}
-
-static int
-xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaAttributeGroupPtr attrGr);
-
-/**
- * xmlSchemaExpandAttributeGroupRefs:
- * @pctxt: the parser context
- * @node: the node of the component holding the attribute uses
- * @completeWild: the intersected wildcard to be returned
- * @list: the attribute uses
- *
- * Substitutes contained attribute group references
- * for their attribute uses. Wilcards are intersected.
- * Attribute use prohibitions are removed from the list
- * and returned via the @prohibs list.
- * Pointlessness of attr. prohibs, if a matching attr. decl
- * is existent a well, are checked.
- */
-static int
-xmlSchemaExpandAttributeGroupRefs(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaBasicItemPtr item,
-                                  xmlSchemaWildcardPtr *completeWild,
-                                  xmlSchemaItemListPtr list,
-                                  xmlSchemaItemListPtr prohibs)
-{
-    xmlSchemaAttributeGroupPtr gr;
-    xmlSchemaAttributeUsePtr use;
-    xmlSchemaItemListPtr sublist;
-    int i, j;
-    int created = (*completeWild == NULL) ? 0 : 1;
-
-    if (prohibs)
-        prohibs->nbItems = 0;
-
-    for (i = 0; i < list->nbItems; i++) {
-        use = list->items[i];
-
-        if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
-            if (prohibs == NULL) {
-                PERROR_INT("xmlSchemaExpandAttributeGroupRefs",
-                    "unexpected attr prohibition found");
-                return(-1);
-            }
-            /*
-            * Remove from attribute uses.
-            */
-            if (xmlSchemaItemListRemove(list, i) == -1)
-                return(-1);
-            i--;
-            /*
-            * Note that duplicate prohibitions were already
-            * handled at parsing time.
-            */
-            /*
-            * Add to list of prohibitions.
-            */
-            xmlSchemaItemListAddSize(prohibs, 2, use);
-            continue;
-        }
-        if ((use->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
-            ((WXS_QNAME_CAST use)->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP))
-        {
-            if ((WXS_QNAME_CAST use)->item == NULL)
-                return(-1);
-            gr = WXS_ATTR_GROUP_CAST (WXS_QNAME_CAST use)->item;
-            /*
-            * Expand the referenced attr. group.
-            * TODO: remove this, this is done in a previous step, so
-            * already done here.
-            */
-            if ((gr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED) == 0) {
-                if (xmlSchemaAttributeGroupExpandRefs(pctxt, gr) == -1)
-                    return(-1);
-            }
-            /*
-            * Build the 'complete' wildcard; i.e. intersect multiple
-            * wildcards.
-            */
-            if (gr->attributeWildcard != NULL) {
-                if (*completeWild == NULL) {
-                    *completeWild = gr->attributeWildcard;
-                } else {
-                    if (! created) {
-                        xmlSchemaWildcardPtr tmpWild;
-
-                         /*
-                        * Copy the first encountered wildcard as context,
-                        * except for the annotation.
-                        *
-                        * Although the complete wildcard might not correspond
-                        * to any node in the schema, we will anchor it on
-                        * the node of the owner component.
-                        */
-                        tmpWild =  xmlSchemaAddWildcard(pctxt, pctxt->schema,
-                            XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
-                            WXS_ITEM_NODE(item));
-                        if (tmpWild == NULL)
-                            return(-1);
-                        if (xmlSchemaCloneWildcardNsConstraints(pctxt,
-                            tmpWild, *completeWild) == -1)
-                            return (-1);
-                        tmpWild->processContents = (*completeWild)->processContents;
-                        *completeWild = tmpWild;
-                        created = 1;
-                    }
-
-                    if (xmlSchemaIntersectWildcards(pctxt, *completeWild,
-                        gr->attributeWildcard) == -1)
-                        return(-1);
-                }
-            }
-            /*
-            * Just remove the reference if the referenced group does not
-            * contain any attribute uses.
-            */
-            sublist = ((xmlSchemaItemListPtr) gr->attrUses);
-            if ((sublist == NULL) || sublist->nbItems == 0) {
-                if (xmlSchemaItemListRemove(list, i) == -1)
-                    return(-1);
-                i--;
-                continue;
-            }
-            /*
-            * Add the attribute uses.
-            */
-            list->items[i] = sublist->items[0];
-            if (sublist->nbItems != 1) {
-                for (j = 1; j < sublist->nbItems; j++) {
-                    i++;
-                    if (xmlSchemaItemListInsert(list,
-                            sublist->items[j], i) == -1)
-                        return(-1);
-                }
-            }
-        }
-
-    }
-    /*
-    * Handle pointless prohibitions of declared attributes.
-    */
-    if (prohibs && (prohibs->nbItems != 0) && (list->nbItems != 0)) {
-        xmlSchemaAttributeUseProhibPtr prohib;
-
-        for (i = prohibs->nbItems -1; i >= 0; i--) {
-            prohib = prohibs->items[i];
-            for (j = 0; j < list->nbItems; j++) {
-                use = list->items[j];
-
-                if ((prohib->name == WXS_ATTRUSE_DECL_NAME(use)) &&
-                    (prohib->targetNamespace == WXS_ATTRUSE_DECL_TNS(use)))
-                {
-                    xmlChar *str = NULL;
-
-                    xmlSchemaCustomWarning(ACTXT_CAST pctxt,
-                        XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
-                        prohib->node, NULL,
-                        "Skipping pointless attribute use prohibition "
-                        "'%s', since a corresponding attribute use "
-                        "exists already in the type definition",
-                        xmlSchemaFormatQName(&str,
-                            prohib->targetNamespace, prohib->name),
-                        NULL, NULL);
-                    FREE_AND_NULL(str);
-                    /*
-                    * Remove the prohibition.
-                    */
-                    if (xmlSchemaItemListRemove(prohibs, i) == -1)
-                        return(-1);
-                    break;
-                }
-            }
-        }
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaAttributeGroupExpandRefs:
- * @pctxt:  the parser context
- * @attrGr:  the attribute group definition
- *
- * Computation of:
- * {attribute uses} property
- * {attribute wildcard} property
- *
- * Substitutes contained attribute group references
- * for their attribute uses. Wilcards are intersected.
- */
-static int
-xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaAttributeGroupPtr attrGr)
-{
-    if ((attrGr->attrUses == NULL) ||
-        (attrGr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED))
-        return(0);
-
-    attrGr->flags |= XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED;
-    if (xmlSchemaExpandAttributeGroupRefs(pctxt, WXS_BASIC_CAST attrGr,
-        &(attrGr->attributeWildcard), attrGr->attrUses, NULL) == -1)
-        return(-1);
-    return(0);
-}
-
-/**
- * xmlSchemaAttributeGroupExpandRefs:
- * @pctxt:  the parser context
- * @attrGr:  the attribute group definition
- *
- * Substitutes contained attribute group references
- * for their attribute uses. Wilcards are intersected.
- *
- * Schema Component Constraint:
- *    Attribute Group Definition Properties Correct (ag-props-correct)
- */
-static int
-xmlSchemaCheckAGPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
-                                  xmlSchemaAttributeGroupPtr attrGr)
-{
-    /*
-    * SPEC ag-props-correct
-    * (1) "The values of the properties of an attribute group definition
-    * must be as described in the property tableau in The Attribute
-    * Group Definition Schema Component ($3.6.1), modulo the impact of
-    * Missing Sub-components ($5.3);"
-    */
-
-    if ((attrGr->attrUses != NULL) &&
-        (WXS_LIST_CAST attrGr->attrUses)->nbItems > 1)
-    {
-        xmlSchemaItemListPtr uses = WXS_LIST_CAST attrGr->attrUses;
-        xmlSchemaAttributeUsePtr use, tmp;
-        int i, j, hasId = 0;
-
-        for (i = uses->nbItems -1; i >= 0; i--) {
-            use = uses->items[i];
-            /*
-            * SPEC ag-props-correct
-            * (2) "Two distinct members of the {attribute uses} must not have
-            * {attribute declaration}s both of whose {name}s match and whose
-            * {target namespace}s are identical."
-            */
-            if (i > 0) {
-                for (j = i -1; j >= 0; j--) {
-                    tmp = uses->items[j];
-                    if ((WXS_ATTRUSE_DECL_NAME(use) ==
-                        WXS_ATTRUSE_DECL_NAME(tmp)) &&
-                        (WXS_ATTRUSE_DECL_TNS(use) ==
-                        WXS_ATTRUSE_DECL_TNS(tmp)))
-                    {
-                        xmlChar *str = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            XML_SCHEMAP_AG_PROPS_CORRECT,
-                            attrGr->node, WXS_BASIC_CAST attrGr,
-                            "Duplicate %s",
-                            xmlSchemaGetComponentDesignation(&str, use),
-                            NULL);
-                        FREE_AND_NULL(str);
-                        /*
-                        * Remove the duplicate.
-                        */
-                        if (xmlSchemaItemListRemove(uses, i) == -1)
-                            return(-1);
-                        goto next_use;
-                    }
-                }
-            }
-            /*
-            * SPEC ag-props-correct
-            * (3) "Two distinct members of the {attribute uses} must not have
-            * {attribute declaration}s both of whose {type definition}s are or
-            * are derived from ID."
-            * TODO: Does 'derived' include member-types of unions?
-            */
-            if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
-                if (xmlSchemaIsDerivedFromBuiltInType(
-                    WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
-                {
-                    if (hasId) {
-                        xmlChar *str = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            XML_SCHEMAP_AG_PROPS_CORRECT,
-                            attrGr->node, WXS_BASIC_CAST attrGr,
-                            "There must not exist more than one attribute "
-                            "declaration of type 'xs:ID' "
-                            "(or derived from 'xs:ID'). The %s violates this "
-                            "constraint",
-                            xmlSchemaGetComponentDesignation(&str, use),
-                            NULL);
-                        FREE_AND_NULL(str);
-                        if (xmlSchemaItemListRemove(uses, i) == -1)
-                            return(-1);
-                    }
-                    hasId = 1;
-                }
-            }
-next_use: {}
-        }
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaResolveAttrGroupReferences:
- * @attrgrpDecl:  the schema attribute definition
- * @ctxt:  the schema parser context
- * @name:  the attribute name
- *
- * Resolves references to attribute group definitions.
- */
-static int
-xmlSchemaResolveAttrGroupReferences(xmlSchemaQNameRefPtr ref,
-                                    xmlSchemaParserCtxtPtr ctxt)
-{
-    xmlSchemaAttributeGroupPtr group;
-
-    if (ref->item != NULL)
-        return(0);
-    group = xmlSchemaGetAttributeGroup(ctxt->schema,
-        ref->name,
-        ref->targetNamespace);
-    if (group == NULL) {
-        xmlSchemaPResCompAttrErr(ctxt,
-            XML_SCHEMAP_SRC_RESOLVE,
-            NULL, ref->node,
-            "ref", ref->name, ref->targetNamespace,
-            ref->itemType, NULL);
-        return(ctxt->err);
-    }
-    ref->item = WXS_BASIC_CAST group;
-    return(0);
-}
-
-/**
- * xmlSchemaCheckAttrPropsCorrect:
- * @item:  an schema attribute declaration/use
- * @ctxt:  a schema parser context
- * @name:  the name of the attribute
- *
- *
- * Schema Component Constraint:
- *    Attribute Declaration Properties Correct (a-props-correct)
- *
- * Validates the value constraints of an attribute declaration/use.
- * NOTE that this needs the simle type definitions to be already
- *   builded and checked.
- */
-static int
-xmlSchemaCheckAttrPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
-                               xmlSchemaAttributePtr attr)
-{
-
-    /*
-    * SPEC a-props-correct (1)
-    * "The values of the properties of an attribute declaration must
-    * be as described in the property tableau in The Attribute
-    * Declaration Schema Component ($3.2.1), modulo the impact of
-    * Missing Sub-components ($5.3)."
-    */
-
-    if (WXS_ATTR_TYPEDEF(attr) == NULL)
-        return(0);
-
-    if (attr->defValue != NULL) {
-        int ret;
-
-        /*
-        * SPEC a-props-correct (3)
-        * "If the {type definition} is or is derived from ID then there
-        * must not be a {value constraint}."
-        */
-        if (xmlSchemaIsDerivedFromBuiltInType(
-            WXS_ATTR_TYPEDEF(attr), XML_SCHEMAS_ID))
-        {
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_A_PROPS_CORRECT_3,
-                NULL, WXS_BASIC_CAST attr,
-                "Value constraints are not allowed if the type definition "
-                "is or is derived from xs:ID",
-                NULL, NULL);
-            return(pctxt->err);
-        }
-        /*
-        * SPEC a-props-correct (2)
-        * "if there is a {value constraint}, the canonical lexical
-        * representation of its value must be `valid` with respect
-        * to the {type definition} as defined in String Valid ($3.14.4)."
-        * TODO: Don't care about the *canonical* stuff here, this requirement
-        * will be removed in WXS 1.1 anyway.
-        */
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt,
-            attr->node, WXS_ATTR_TYPEDEF(attr),
-            attr->defValue, &(attr->defVal),
-            1, 1, 0);
-        if (ret != 0) {
-            if (ret < 0) {
-                PERROR_INT("xmlSchemaCheckAttrPropsCorrect",
-                    "calling xmlSchemaVCheckCVCSimpleType()");
-                return(-1);
-            }
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_A_PROPS_CORRECT_2,
-                NULL, WXS_BASIC_CAST attr,
-                "The value of the value constraint is not valid",
-                NULL, NULL);
-            return(pctxt->err);
-        }
-    }
-
-    return(0);
-}
-
-static xmlSchemaElementPtr
-xmlSchemaCheckSubstGroupCircular(xmlSchemaElementPtr elemDecl,
-                                 xmlSchemaElementPtr ancestor)
-{
-    xmlSchemaElementPtr ret;
-
-    if (WXS_SUBST_HEAD(ancestor) == NULL)
-        return (NULL);
-    if (WXS_SUBST_HEAD(ancestor) == elemDecl)
-        return (ancestor);
-
-    if (WXS_SUBST_HEAD(ancestor)->flags & XML_SCHEMAS_ELEM_CIRCULAR)
-        return (NULL);
-    WXS_SUBST_HEAD(ancestor)->flags |= XML_SCHEMAS_ELEM_CIRCULAR;
-    ret = xmlSchemaCheckSubstGroupCircular(elemDecl,
-        WXS_SUBST_HEAD(ancestor));
-    WXS_SUBST_HEAD(ancestor)->flags ^= XML_SCHEMAS_ELEM_CIRCULAR;
-
-    return (ret);
-}
-
-/**
- * xmlSchemaCheckElemPropsCorrect:
- * @ctxt:  a schema parser context
- * @decl: the element declaration
- * @name:  the name of the attribute
- *
- * Schema Component Constraint:
- * Element Declaration Properties Correct (e-props-correct)
- *
- * STATUS:
- *   missing: (6)
- */
-static int
-xmlSchemaCheckElemPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
-                               xmlSchemaElementPtr elemDecl)
-{
-    int ret = 0;
-    xmlSchemaTypePtr typeDef = WXS_ELEM_TYPEDEF(elemDecl);
-    /*
-    * SPEC (1) "The values of the properties of an element declaration
-    * must be as described in the property tableau in The Element
-    * Declaration Schema Component ($3.3.1), modulo the impact of Missing
-    * Sub-components ($5.3)."
-    */
-    if (WXS_SUBST_HEAD(elemDecl) != NULL) {
-        xmlSchemaElementPtr head = WXS_SUBST_HEAD(elemDecl), circ;
-
-        xmlSchemaCheckElementDeclComponent(head, pctxt);
-        /*
-        * SPEC (3) "If there is a non-`absent` {substitution group
-        * affiliation}, then {scope} must be global."
-        */
-        if ((elemDecl->flags & XML_SCHEMAS_ELEM_GLOBAL) == 0) {
-            xmlSchemaPCustomErr(pctxt,
-                XML_SCHEMAP_E_PROPS_CORRECT_3,
-                WXS_BASIC_CAST elemDecl, NULL,
-                "Only global element declarations can have a "
-                "substitution group affiliation", NULL);
-            ret = XML_SCHEMAP_E_PROPS_CORRECT_3;
-        }
-        /*
-        * TODO: SPEC (6) "Circular substitution groups are disallowed.
-        * That is, it must not be possible to return to an element declaration
-        * by repeatedly following the {substitution group affiliation}
-        * property."
-        */
-        if (head == elemDecl)
-            circ = head;
-        else if (WXS_SUBST_HEAD(head) != NULL)
-            circ = xmlSchemaCheckSubstGroupCircular(head, head);
-        else
-            circ = NULL;
-        if (circ != NULL) {
-            xmlChar *strA = NULL, *strB = NULL;
-
-            xmlSchemaPCustomErrExt(pctxt,
-                XML_SCHEMAP_E_PROPS_CORRECT_6,
-                WXS_BASIC_CAST circ, NULL,
-                "The element declaration '%s' defines a circular "
-                "substitution group to element declaration '%s'",
-                xmlSchemaGetComponentQName(&strA, circ),
-                xmlSchemaGetComponentQName(&strB, head),
-                NULL);
-            FREE_AND_NULL(strA)
-            FREE_AND_NULL(strB)
-            ret = XML_SCHEMAP_E_PROPS_CORRECT_6;
-        }
-        /*
-        * SPEC (4) "If there is a {substitution group affiliation},
-        * the {type definition}
-        * of the element declaration must be validly derived from the {type
-        * definition} of the {substitution group affiliation}, given the value
-        * of the {substitution group exclusions} of the {substitution group
-        * affiliation}, as defined in Type Derivation OK (Complex) ($3.4.6)
-        * (if the {type definition} is complex) or as defined in
-        * Type Derivation OK (Simple) ($3.14.6) (if the {type definition} is
-        * simple)."
-        *
-        * NOTE: {substitution group exclusions} means the values of the
-        * attribute "final".
-        */
-
-        if (typeDef != WXS_ELEM_TYPEDEF(WXS_SUBST_HEAD(elemDecl))) {
-            int set = 0;
-
-            if (head->flags & XML_SCHEMAS_ELEM_FINAL_EXTENSION)
-                set |= SUBSET_EXTENSION;
-            if (head->flags & XML_SCHEMAS_ELEM_FINAL_RESTRICTION)
-                set |= SUBSET_RESTRICTION;
-
-            if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST pctxt, typeDef,
-                WXS_ELEM_TYPEDEF(head), set) != 0) {
-                xmlChar *strA = NULL, *strB = NULL, *strC = NULL;
-
-                ret = XML_SCHEMAP_E_PROPS_CORRECT_4;
-                xmlSchemaPCustomErrExt(pctxt,
-                    XML_SCHEMAP_E_PROPS_CORRECT_4,
-                    WXS_BASIC_CAST elemDecl, NULL,
-                    "The type definition '%s' was "
-                    "either rejected by the substitution group "
-                    "affiliation '%s', or not validly derived from its type "
-                    "definition '%s'",
-                    xmlSchemaGetComponentQName(&strA, typeDef),
-                    xmlSchemaGetComponentQName(&strB, head),
-                    xmlSchemaGetComponentQName(&strC, WXS_ELEM_TYPEDEF(head)));
-                FREE_AND_NULL(strA)
-                FREE_AND_NULL(strB)
-                FREE_AND_NULL(strC)
-            }
-        }
-    }
-    /*
-    * SPEC (5) "If the {type definition} or {type definition}'s
-    * {content type}
-    * is or is derived from ID then there must not be a {value constraint}.
-    * Note: The use of ID as a type definition for elements goes beyond
-    * XML 1.0, and should be avoided if backwards compatibility is desired"
-    */
-    if ((elemDecl->value != NULL) &&
-        ((WXS_IS_SIMPLE(typeDef) &&
-          xmlSchemaIsDerivedFromBuiltInType(typeDef, XML_SCHEMAS_ID)) ||
-         (WXS_IS_COMPLEX(typeDef) &&
-          WXS_HAS_SIMPLE_CONTENT(typeDef) &&
-          xmlSchemaIsDerivedFromBuiltInType(typeDef->contentTypeDef,
-            XML_SCHEMAS_ID)))) {
-
-        ret = XML_SCHEMAP_E_PROPS_CORRECT_5;
-        xmlSchemaPCustomErr(pctxt,
-            XML_SCHEMAP_E_PROPS_CORRECT_5,
-            WXS_BASIC_CAST elemDecl, NULL,
-            "The type definition (or type definition's content type) is or "
-            "is derived from ID; value constraints are not allowed in "
-            "conjunction with such a type definition", NULL);
-    } else if (elemDecl->value != NULL) {
-        int vcret;
-        xmlNodePtr node = NULL;
-
-        /*
-        * SPEC (2) "If there is a {value constraint}, the canonical lexical
-        * representation of its value must be `valid` with respect to the
-        * {type definition} as defined in Element Default Valid (Immediate)
-        * ($3.3.6)."
-        */
-        if (typeDef == NULL) {
-            xmlSchemaPErr(pctxt, elemDecl->node,
-                XML_SCHEMAP_INTERNAL,
-                "Internal error: xmlSchemaCheckElemPropsCorrect, "
-                "type is missing... skipping validation of "
-                "the value constraint", NULL, NULL);
-            return (-1);
-        }
-        if (elemDecl->node != NULL) {
-            if (elemDecl->flags & XML_SCHEMAS_ELEM_FIXED)
-                node = (xmlNodePtr) xmlHasProp(elemDecl->node,
-                    BAD_CAST "fixed");
-            else
-                node = (xmlNodePtr) xmlHasProp(elemDecl->node,
-                    BAD_CAST "default");
-        }
-        vcret = xmlSchemaParseCheckCOSValidDefault(pctxt, node,
-            typeDef, elemDecl->value, &(elemDecl->defVal));
-        if (vcret != 0) {
-            if (vcret < 0) {
-                PERROR_INT("xmlSchemaElemCheckValConstr",
-                    "failed to validate the value constraint of an "
-                    "element declaration");
-                return (-1);
-            }
-            return (vcret);
-        }
-    }
-
-    return (ret);
-}
-
-/**
- * xmlSchemaCheckElemSubstGroup:
- * @ctxt:  a schema parser context
- * @decl: the element declaration
- * @name:  the name of the attribute
- *
- * Schema Component Constraint:
- * Substitution Group (cos-equiv-class)
- *
- * In Libxml2 the subst. groups will be precomputed, in terms of that
- * a list will be built for each subst. group head, holding all direct
- * referents to this head.
- * NOTE that this function needs:
- *   1. circular subst. groups to be checked beforehand
- *   2. the declaration's type to be derived from the head's type
- *
- * STATUS:
- *
- */
-static void
-xmlSchemaCheckElemSubstGroup(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaElementPtr elemDecl)
-{
-    if ((WXS_SUBST_HEAD(elemDecl) == NULL) ||
-        /* SPEC (1) "Its {abstract} is false." */
-        (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT))
-        return;
-    {
-        xmlSchemaElementPtr head;
-        xmlSchemaTypePtr headType, type;
-        int set, methSet;
-        /*
-        * SPEC (2) "It is validly substitutable for HEAD subject to HEAD's
-        * {disallowed substitutions} as the blocking constraint, as defined in
-        * Substitution Group OK (Transitive) ($3.3.6)."
-        */
-        for (head = WXS_SUBST_HEAD(elemDecl); head != NULL;
-            head = WXS_SUBST_HEAD(head)) {
-            set = 0;
-            methSet = 0;
-            /*
-            * The blocking constraints.
-            */
-            if (head->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION)
-                continue;
-            headType = head->subtypes;
-            type = elemDecl->subtypes;
-            if (headType == type)
-                goto add_member;
-            if (head->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION)
-                set |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
-            if (head->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION)
-                set |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
-            /*
-            * SPEC: Substitution Group OK (Transitive) (2.3)
-            * "The set of all {derivation method}s involved in the
-            * derivation of D's {type definition} from C's {type definition}
-            * does not intersect with the union of the blocking constraint,
-            * C's {prohibited substitutions} (if C is complex, otherwise the
-            * empty set) and the {prohibited substitutions} (respectively the
-            * empty set) of any intermediate {type definition}s in the
-            * derivation of D's {type definition} from C's {type definition}."
-            */
-            /*
-            * OPTIMIZE TODO: Optimize this a bit, since, if traversing the
-            * subst.head axis, the methSet does not need to be computed for
-            * the full depth over and over.
-            */
-            /*
-            * The set of all {derivation method}s involved in the derivation
-            */
-            while ((type != NULL) && (type != headType)) {
-                if ((WXS_IS_EXTENSION(type)) &&
-                    ((methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
-                    methSet |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
-
-                if (WXS_IS_RESTRICTION(type) &&
-                    ((methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
-                    methSet |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
-
-                type = type->baseType;
-            }
-            /*
-            * The {prohibited substitutions} of all intermediate types +
-            * the head's type.
-            */
-            type = elemDecl->subtypes->baseType;
-            while (type != NULL) {
-                if (WXS_IS_COMPLEX(type)) {
-                    if ((type->flags &
-                            XML_SCHEMAS_TYPE_BLOCK_EXTENSION) &&
-                        ((set & XML_SCHEMAS_TYPE_BLOCK_EXTENSION) == 0))
-                    set |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
-                    if ((type->flags &
-                            XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) &&
-                        ((set & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
-                    set |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
-                } else
-                    break;
-                if (type == headType)
-                    break;
-                type = type->baseType;
-            }
-            if ((set != 0) &&
-                (((set & XML_SCHEMAS_TYPE_BLOCK_EXTENSION) &&
-                (methSet & XML_SCHEMAS_TYPE_BLOCK_EXTENSION)) ||
-                ((set & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) &&
-                (methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION)))) {
-                continue;
-            }
-add_member:
-            xmlSchemaAddElementSubstitutionMember(ctxt, head, elemDecl);
-            if ((head->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) == 0)
-                head->flags |= XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD;
-        }
-    }
-}
-
-#ifdef WXS_ELEM_DECL_CONS_ENABLED /* enable when finished */
-/**
- * xmlSchemaCheckElementDeclComponent
- * @pctxt: the schema parser context
- * @ctxtComponent: the context component (an element declaration)
- * @ctxtParticle: the first particle of the context component
- * @searchParticle: the element declaration particle to be analysed
- *
- * Schema Component Constraint: Element Declarations Consistent
- */
-static int
-xmlSchemaCheckElementDeclConsistent(xmlSchemaParserCtxtPtr pctxt,
-                                    xmlSchemaBasicItemPtr ctxtComponent,
-                                    xmlSchemaParticlePtr ctxtParticle,
-                                    xmlSchemaParticlePtr searchParticle,
-                                    xmlSchemaParticlePtr curParticle,
-                                    int search)
-{
-    return(0);
-
-    int ret = 0;
-    xmlSchemaParticlePtr cur = curParticle;
-    if (curParticle == NULL) {
-        return(0);
-    }
-    if (WXS_PARTICLE_TERM(curParticle) == NULL) {
-        /*
-        * Just return in this case. A missing "term" of the particle
-        * might arise due to an invalid "term" component.
-        */
-        return(0);
-    }
-    while (cur != NULL) {
-        switch (WXS_PARTICLE_TERM(cur)->type) {
-            case XML_SCHEMA_TYPE_ANY:
-                break;
-            case XML_SCHEMA_TYPE_ELEMENT:
-                if (search == 0) {
-                    ret = xmlSchemaCheckElementDeclConsistent(pctxt,
-                        ctxtComponent, ctxtParticle, cur, ctxtParticle, 1);
-                    if (ret != 0)
-                        return(ret);
-                } else {
-                    xmlSchemaElementPtr elem =
-                        WXS_ELEM_CAST(WXS_PARTICLE_TERM(cur));
-                    /*
-                    * SPEC Element Declarations Consistent:
-                    * "If the {particles} contains, either directly,
-                    * indirectly (that is, within the {particles} of a
-                    * contained model group, recursively) or `implicitly`
-                    * two or more element declaration particles with
-                    * the same {name} and {target namespace}, then
-                    * all their type definitions must be the same
-                    * top-level definition [...]"
-                    */
-                    if (xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->name,
-                            WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->name) &&
-                        xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
-                            WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->targetNamespace))
-                    {
-                        xmlChar *strA = NULL, *strB = NULL;
-
-                        xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                            /* TODO: error code */
-                            XML_SCHEMAP_COS_NONAMBIG,
-                            WXS_ITEM_NODE(cur), NULL,
-                            "In the content model of %s, there are multiple "
-                            "element declarations for '%s' with different "
-                            "type definitions",
-                            xmlSchemaGetComponentDesignation(&strA,
-                                ctxtComponent),
-                            xmlSchemaFormatQName(&strB,
-                                WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
-                                WXS_PARTICLE_TERM_AS_ELEM(cur)->name));
-                        FREE_AND_NULL(strA);
-                        FREE_AND_NULL(strB);
-                        return(XML_SCHEMAP_COS_NONAMBIG);
-                    }
-                }
-                break;
-            case XML_SCHEMA_TYPE_SEQUENCE: {
-                break;
-                }
-            case XML_SCHEMA_TYPE_CHOICE:{
-                /*
-                xmlSchemaTreeItemPtr sub;
-
-                sub = WXS_PARTICLE_TERM(particle)->children;  (xmlSchemaParticlePtr)
-                while (sub != NULL) {
-                    ret = xmlSchemaCheckElementDeclConsistent(pctxt, ctxtComponent,
-                        ctxtParticle, ctxtElem);
-                    if (ret != 0)
-                        return(ret);
-                    sub = sub->next;
-                }
-                */
-                break;
-                }
-            case XML_SCHEMA_TYPE_ALL:
-                break;
-            case XML_SCHEMA_TYPE_GROUP:
-                break;
-            default:
-                xmlSchemaInternalErr2(ACTXT_CAST pctxt,
-                    "xmlSchemaCheckElementDeclConsistent",
-                    "found unexpected term of type '%s' in content model",
-                    WXS_ITEM_TYPE_NAME(WXS_PARTICLE_TERM(cur)), NULL);
-                return(-1);
-        }
-        cur = (xmlSchemaParticlePtr) cur->next;
-    }
-
-exit:
-    return(ret);
-}
-#endif
-
-/**
- * xmlSchemaCheckElementDeclComponent
- * @item:  an schema element declaration/particle
- * @ctxt:  a schema parser context
- * @name:  the name of the attribute
- *
- * Validates the value constraints of an element declaration.
- * Adds substitution group members.
- */
-static void
-xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
-                                   xmlSchemaParserCtxtPtr ctxt)
-{
-    if (elemDecl == NULL)
-        return;
-    if (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED)
-        return;
-    elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_CHECKED;
-    if (xmlSchemaCheckElemPropsCorrect(ctxt, elemDecl) == 0) {
-        /*
-        * Adds substitution group members.
-        */
-        xmlSchemaCheckElemSubstGroup(ctxt, elemDecl);
-    }
-}
-
-/**
- * xmlSchemaResolveModelGroupParticleReferences:
- * @particle:  a particle component
- * @ctxt:  a parser context
- *
- * Resolves references of a model group's {particles} to
- * model group definitions and to element declarations.
- */
-static void
-xmlSchemaResolveModelGroupParticleReferences(
-    xmlSchemaParserCtxtPtr ctxt,
-    xmlSchemaModelGroupPtr mg)
-{
-    xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
-    xmlSchemaQNameRefPtr ref;
-    xmlSchemaBasicItemPtr refItem;
-
-    /*
-    * URGENT TODO: Test this.
-    */
-    while (particle != NULL) {
-        if ((WXS_PARTICLE_TERM(particle) == NULL) ||
-            ((WXS_PARTICLE_TERM(particle))->type !=
-                XML_SCHEMA_EXTRA_QNAMEREF))
-        {
-            goto next_particle;
-        }
-        ref = WXS_QNAME_CAST WXS_PARTICLE_TERM(particle);
-        /*
-        * Resolve the reference.
-        * NULL the {term} by default.
-        */
-        particle->children = NULL;
-
-        refItem = xmlSchemaGetNamedComponent(ctxt->schema,
-            ref->itemType, ref->name, ref->targetNamespace);
-        if (refItem == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
-                NULL, WXS_ITEM_NODE(particle), "ref", ref->name,
-                ref->targetNamespace, ref->itemType, NULL);
-            /* TODO: remove the particle. */
-            goto next_particle;
-        }
-        if (refItem->type == XML_SCHEMA_TYPE_GROUP) {
-            if (WXS_MODELGROUPDEF_MODEL(refItem) == NULL)
-                /* TODO: remove the particle. */
-                goto next_particle;
-            /*
-            * NOTE that we will assign the model group definition
-            * itself to the "term" of the particle. This will ease
-            * the check for circular model group definitions. After
-            * that the "term" will be assigned the model group of the
-            * model group definition.
-            */
-            if ((WXS_MODELGROUPDEF_MODEL(refItem))->type ==
-                    XML_SCHEMA_TYPE_ALL) {
-                /*
-                * SPEC cos-all-limited (1)
-                * SPEC cos-all-limited (1.2)
-                * "It appears only as the value of one or both of the
-                * following properties:"
-                * (1.1) "the {model group} property of a model group
-                *        definition."
-                * (1.2) "the {term} property of a particle [... of] the "
-                * {content type} of a complex type definition."
-                */
-                xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                    /* TODO: error code */
-                    XML_SCHEMAP_COS_ALL_LIMITED,
-                    WXS_ITEM_NODE(particle), NULL,
-                    "A model group definition is referenced, but "
-                    "it contains an 'all' model group, which "
-                    "cannot be contained by model groups",
-                    NULL, NULL);
-                /* TODO: remove the particle. */
-                goto next_particle;
-            }
-            particle->children = (xmlSchemaTreeItemPtr) refItem;
-        } else {
-            /*
-            * TODO: Are referenced element declarations the only
-            * other components we expect here?
-            */
-            particle->children = (xmlSchemaTreeItemPtr) refItem;
-        }
-next_particle:
-        particle = WXS_PTC_CAST particle->next;
-    }
-}
-
-static int
-xmlSchemaAreValuesEqual(xmlSchemaValPtr x,
-                       xmlSchemaValPtr y)
-{
-    xmlSchemaTypePtr tx, ty, ptx, pty;
-    int ret;
-
-    while (x != NULL) {
-        /* Same types. */
-        tx = xmlSchemaGetBuiltInType(xmlSchemaGetValType(x));
-        ty = xmlSchemaGetBuiltInType(xmlSchemaGetValType(y));
-        ptx = xmlSchemaGetPrimitiveType(tx);
-        pty = xmlSchemaGetPrimitiveType(ty);
-        /*
-        * (1) if a datatype T' is `derived` by `restriction` from an
-        * atomic datatype T then the `value space` of T' is a subset of
-        * the `value space` of T. */
-        /*
-        * (2) if datatypes T' and T'' are `derived` by `restriction`
-        * from a common atomic ancestor T then the `value space`s of T'
-        * and T'' may overlap.
-        */
-        if (ptx != pty)
-            return(0);
-        /*
-        * We assume computed values to be normalized, so do a fast
-        * string comparison for string based types.
-        */
-        if ((ptx->builtInType == XML_SCHEMAS_STRING) ||
-            WXS_IS_ANY_SIMPLE_TYPE(ptx)) {
-            if (! xmlStrEqual(
-                xmlSchemaValueGetAsString(x),
-                xmlSchemaValueGetAsString(y)))
-                return (0);
-        } else {
-            ret = xmlSchemaCompareValuesWhtsp(
-                x, XML_SCHEMA_WHITESPACE_PRESERVE,
-                y, XML_SCHEMA_WHITESPACE_PRESERVE);
-            if (ret == -2)
-                return(-1);
-            if (ret != 0)
-                return(0);
-        }
-        /*
-        * Lists.
-        */
-        x = xmlSchemaValueGetNext(x);
-        if (x != NULL) {
-            y = xmlSchemaValueGetNext(y);
-            if (y == NULL)
-                return (0);
-        } else if (xmlSchemaValueGetNext(y) != NULL)
-            return (0);
-        else
-            return (1);
-    }
-    return (0);
-}
-
-/**
- * xmlSchemaResolveAttrUseReferences:
- * @item:  an attribute use
- * @ctxt:  a parser context
- *
- * Resolves the referenced attribute declaration.
- */
-static int
-xmlSchemaResolveAttrUseReferences(xmlSchemaAttributeUsePtr ause,
-                                  xmlSchemaParserCtxtPtr ctxt)
-{
-    if ((ctxt == NULL) || (ause == NULL))
-        return(-1);
-    if ((ause->attrDecl == NULL) ||
-        (ause->attrDecl->type != XML_SCHEMA_EXTRA_QNAMEREF))
-        return(0);
-
-    {
-        xmlSchemaQNameRefPtr ref = WXS_QNAME_CAST ause->attrDecl;
-
-        /*
-        * TODO: Evaluate, what errors could occur if the declaration is not
-        * found.
-        */
-        ause->attrDecl = xmlSchemaGetAttributeDecl(ctxt->schema,
-            ref->name, ref->targetNamespace);
-        if (ause->attrDecl == NULL) {
-            xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST ause, ause->node,
-                "ref", ref->name, ref->targetNamespace,
-                XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
-            return(ctxt->err);;
-        }
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaCheckAttrUsePropsCorrect:
- * @ctxt:  a parser context
- * @use:  an attribute use
- *
- * Schema Component Constraint:
- * Attribute Use Correct (au-props-correct)
- *
- */
-static int
-xmlSchemaCheckAttrUsePropsCorrect(xmlSchemaParserCtxtPtr ctxt,
-                             xmlSchemaAttributeUsePtr use)
-{
-    if ((ctxt == NULL) || (use == NULL))
-        return(-1);
-    if ((use->defValue == NULL) || (WXS_ATTRUSE_DECL(use) == NULL) ||
-        ((WXS_ATTRUSE_DECL(use))->type != XML_SCHEMA_TYPE_ATTRIBUTE))
-        return(0);
-
-    /*
-    * SPEC au-props-correct (1)
-    * "The values of the properties of an attribute use must be as
-    * described in the property tableau in The Attribute Use Schema
-    * Component ($3.5.1), modulo the impact of Missing
-    * Sub-components ($5.3)."
-    */
-
-    if (((WXS_ATTRUSE_DECL(use))->defValue != NULL) &&
-        ((WXS_ATTRUSE_DECL(use))->flags & XML_SCHEMAS_ATTR_FIXED) &&
-        ((use->flags & XML_SCHEMA_ATTR_USE_FIXED) == 0))
-    {
-        xmlSchemaPCustomErr(ctxt,
-            XML_SCHEMAP_AU_PROPS_CORRECT_2,
-            WXS_BASIC_CAST use, NULL,
-            "The attribute declaration has a 'fixed' value constraint "
-            ", thus the attribute use must also have a 'fixed' value "
-            "constraint",
-            NULL);
-        return(ctxt->err);
-    }
-    /*
-    * Compute and check the value constraint's value.
-    */
-    if ((use->defVal != NULL) && (WXS_ATTRUSE_TYPEDEF(use) != NULL)) {
-        int ret;
-        /*
-        * TODO: The spec seems to be missing a check of the
-        * value constraint of the attribute use. We will do it here.
-        */
-        /*
-        * SPEC a-props-correct (3)
-        */
-        if (xmlSchemaIsDerivedFromBuiltInType(
-            WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
-        {
-            xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                XML_SCHEMAP_AU_PROPS_CORRECT,
-                NULL, WXS_BASIC_CAST use,
-                "Value constraints are not allowed if the type definition "
-                "is or is derived from xs:ID",
-                NULL, NULL);
-            return(ctxt->err);
-        }
-
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST ctxt,
-            use->node, WXS_ATTRUSE_TYPEDEF(use),
-            use->defValue, &(use->defVal),
-            1, 1, 0);
-        if (ret != 0) {
-            if (ret < 0) {
-                PERROR_INT2("xmlSchemaCheckAttrUsePropsCorrect",
-                    "calling xmlSchemaVCheckCVCSimpleType()");
-                return(-1);
-            }
-            xmlSchemaCustomErr(ACTXT_CAST ctxt,
-                XML_SCHEMAP_AU_PROPS_CORRECT,
-                NULL, WXS_BASIC_CAST use,
-                "The value of the value constraint is not valid",
-                NULL, NULL);
-            return(ctxt->err);
-        }
-    }
-    /*
-    * SPEC au-props-correct (2)
-    * "If the {attribute declaration} has a fixed
-    * {value constraint}, then if the attribute use itself has a
-    * {value constraint}, it must also be fixed and its value must match
-    * that of the {attribute declaration}'s {value constraint}."
-    */
-    if (((WXS_ATTRUSE_DECL(use))->defVal != NULL) &&
-        (((WXS_ATTRUSE_DECL(use))->flags & XML_SCHEMA_ATTR_USE_FIXED) == 0))
-    {
-        if (! xmlSchemaAreValuesEqual(use->defVal,
-                (WXS_ATTRUSE_DECL(use))->defVal))
-        {
-            xmlSchemaPCustomErr(ctxt,
-                XML_SCHEMAP_AU_PROPS_CORRECT_2,
-                WXS_BASIC_CAST use, NULL,
-                "The 'fixed' value constraint of the attribute use "
-                "must match the attribute declaration's value "
-                "constraint '%s'",
-                (WXS_ATTRUSE_DECL(use))->defValue);
-        }
-        return(ctxt->err);
-    }
-    return(0);
-}
-
-
-
-
-/**
- * xmlSchemaResolveAttrTypeReferences:
- * @item:  an attribute declaration
- * @ctxt:  a parser context
- *
- * Resolves the referenced type definition component.
- */
-static int
-xmlSchemaResolveAttrTypeReferences(xmlSchemaAttributePtr item,
-                                   xmlSchemaParserCtxtPtr ctxt)
-{
-    /*
-    * The simple type definition corresponding to the <simpleType> element
-    * information item in the [children], if present, otherwise the simple
-    * type definition `resolved` to by the `actual value` of the type
-    * [attribute], if present, otherwise the `simple ur-type definition`.
-    */
-    if (item->flags & XML_SCHEMAS_ATTR_INTERNAL_RESOLVED)
-        return(0);
-    item->flags |= XML_SCHEMAS_ATTR_INTERNAL_RESOLVED;
-    if (item->subtypes != NULL)
-        return(0);
-    if (item->typeName != NULL) {
-        xmlSchemaTypePtr type;
-
-        type = xmlSchemaGetType(ctxt->schema, item->typeName,
-            item->typeNs);
-        if ((type == NULL) || (! WXS_IS_SIMPLE(type))) {
-            xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST item, item->node,
-                "type", item->typeName, item->typeNs,
-                XML_SCHEMA_TYPE_SIMPLE, NULL);
-            return(ctxt->err);
-        } else
-            item->subtypes = type;
-
-    } else {
-        /*
-        * The type defaults to the xs:anySimpleType.
-        */
-        item->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
-    }
-    return(0);
-}
-
-/**
- * xmlSchemaResolveIDCKeyReferences:
- * @idc:  the identity-constraint definition
- * @ctxt:  the schema parser context
- * @name:  the attribute name
- *
- * Resolve keyRef references to key/unique IDCs.
- * Schema Component Constraint:
- *   Identity-constraint Definition Properties Correct (c-props-correct)
- */
-static int
-xmlSchemaResolveIDCKeyReferences(xmlSchemaIDCPtr idc,
-                          xmlSchemaParserCtxtPtr pctxt)
-{
-    if (idc->type != XML_SCHEMA_TYPE_IDC_KEYREF)
-        return(0);
-    if (idc->ref->name != NULL) {
-        idc->ref->item = (xmlSchemaBasicItemPtr)
-            xmlSchemaGetIDC(pctxt->schema, idc->ref->name,
-                idc->ref->targetNamespace);
-        if (idc->ref->item == NULL) {
-            /*
-            * TODO: It is actually not an error to fail to resolve
-            * at this stage. BUT we need to be that strict!
-            */
-            xmlSchemaPResCompAttrErr(pctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
-                WXS_BASIC_CAST idc, idc->node,
-                "refer", idc->ref->name,
-                idc->ref->targetNamespace,
-                XML_SCHEMA_TYPE_IDC_KEY, NULL);
-            return(pctxt->err);
-        } else if (idc->ref->item->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
-            /*
-            * SPEC c-props-correct (1)
-            */
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_C_PROPS_CORRECT,
-                NULL, WXS_BASIC_CAST idc,
-                "The keyref references a keyref",
-                NULL, NULL);
-            idc->ref->item = NULL;
-            return(pctxt->err);
-        } else {
-            if (idc->nbFields !=
-                ((xmlSchemaIDCPtr) idc->ref->item)->nbFields) {
-                xmlChar *str = NULL;
-                xmlSchemaIDCPtr refer;
-
-                refer = (xmlSchemaIDCPtr) idc->ref->item;
-                /*
-                * SPEC c-props-correct(2)
-                * "If the {identity-constraint category} is keyref,
-                * the cardinality of the {fields} must equal that of
-                * the {fields} of the {referenced key}.
-                */
-                xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                    XML_SCHEMAP_C_PROPS_CORRECT,
-                    NULL, WXS_BASIC_CAST idc,
-                    "The cardinality of the keyref differs from the "
-                    "cardinality of the referenced key/unique '%s'",
-                    xmlSchemaFormatQName(&str, refer->targetNamespace,
-                        refer->name),
-                    NULL);
-                FREE_AND_NULL(str)
-                return(pctxt->err);
-            }
-        }
-    }
-    return(0);
-}
-
-static int
-xmlSchemaResolveAttrUseProhibReferences(xmlSchemaAttributeUseProhibPtr prohib,
-                                       xmlSchemaParserCtxtPtr pctxt)
-{
-    if (xmlSchemaGetAttributeDecl(pctxt->schema, prohib->name,
-        prohib->targetNamespace) == NULL) {
-
-        xmlSchemaPResCompAttrErr(pctxt,
-            XML_SCHEMAP_SRC_RESOLVE,
-            NULL, prohib->node,
-            "ref", prohib->name, prohib->targetNamespace,
-            XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
-        return(XML_SCHEMAP_SRC_RESOLVE);
-    }
-    return(0);
-}
-
-#define WXS_REDEFINED_TYPE(c) \
-(((xmlSchemaTypePtr) item)->flags & XML_SCHEMAS_TYPE_REDEFINED)
-
-#define WXS_REDEFINED_MODEL_GROUP_DEF(c) \
-(((xmlSchemaModelGroupDefPtr) item)->flags & XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED)
-
-#define WXS_REDEFINED_ATTR_GROUP(c) \
-(((xmlSchemaAttributeGroupPtr) item)->flags & XML_SCHEMAS_ATTRGROUP_REDEFINED)
-
-static int
-xmlSchemaCheckSRCRedefineFirst(xmlSchemaParserCtxtPtr pctxt)
-{
-    int err = 0;
-    xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
-    xmlSchemaBasicItemPtr prev, item;
-    int wasRedefined;
-
-    if (redef == NULL)
-        return(0);
-
-    do {
-        item = redef->item;
-        /*
-        * First try to locate the redefined component in the
-        * schema graph starting with the redefined schema.
-        * NOTE: According to this schema bug entry:
-        *   http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005OctDec/0019.html
-        *   it's not clear if the referenced component needs to originate
-        *   from the <redefine>d schema _document_ or the schema; the latter
-        *   would include all imported and included sub-schemas of the
-        *   <redefine>d schema. Currenlty we latter approach is used.
-        *   SUPPLEMENT: It seems that the WG moves towards the latter
-        *   approach, so we are doing it right.
-        *
-        */
-        prev = xmlSchemaFindRedefCompInGraph(
-            redef->targetBucket, item->type,
-            redef->refName, redef->refTargetNs);
-        if (prev == NULL) {
-            xmlChar *str = NULL;
-            xmlNodePtr node;
-
-            /*
-            * SPEC src-redefine:
-            * (6.2.1) "The `actual value` of its own name attribute plus
-            * target namespace must successfully `resolve` to a model
-            * group definition in I."
-            * (7.2.1) "The `actual value` of its own name attribute plus
-            * target namespace must successfully `resolve` to an attribute
-            * group definition in I."
-
-            *
-            * Note that, if we are redefining with the use of references
-            * to components, the spec assumes the src-resolve to be used;
-            * but this won't assure that we search only *inside* the
-            * redefined schema.
-            */
-            if (redef->reference)
-                node = WXS_ITEM_NODE(redef->reference);
-            else
-                node = WXS_ITEM_NODE(item);
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                /*
-                * TODO: error code.
-                * Probably XML_SCHEMAP_SRC_RESOLVE, if this is using the
-                * reference kind.
-                */
-                XML_SCHEMAP_SRC_REDEFINE, node, NULL,
-                "The %s '%s' to be redefined could not be found in "
-                "the redefined schema",
-                WXS_ITEM_TYPE_NAME(item),
-                xmlSchemaFormatQName(&str, redef->refTargetNs,
-                    redef->refName));
-            FREE_AND_NULL(str);
-            err = pctxt->err;
-            redef = redef->next;
-            continue;
-        }
-        /*
-        * TODO: Obtaining and setting the redefinition state is really
-        * clumsy.
-        */
-        wasRedefined = 0;
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_COMPLEX:
-            case XML_SCHEMA_TYPE_SIMPLE:
-                if ((WXS_TYPE_CAST prev)->flags &
-                    XML_SCHEMAS_TYPE_REDEFINED)
-                {
-                    wasRedefined = 1;
-                    break;
-                }
-                /* Mark it as redefined. */
-                (WXS_TYPE_CAST prev)->flags |= XML_SCHEMAS_TYPE_REDEFINED;
-                /*
-                * Assign the redefined type to the
-                * base type of the redefining type.
-                * TODO: How
-                */
-                ((xmlSchemaTypePtr) item)->baseType =
-                    (xmlSchemaTypePtr) prev;
-                break;
-            case XML_SCHEMA_TYPE_GROUP:
-                if ((WXS_MODEL_GROUPDEF_CAST prev)->flags &
-                    XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED)
-                {
-                    wasRedefined = 1;
-                    break;
-                }
-                /* Mark it as redefined. */
-                (WXS_MODEL_GROUPDEF_CAST prev)->flags |=
-                    XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED;
-                if (redef->reference != NULL) {
-                    /*
-                    * Overwrite the QName-reference with the
-                    * referenced model group def.
-                    */
-                    (WXS_PTC_CAST redef->reference)->children =
-                        WXS_TREE_CAST prev;
-                }
-                redef->target = prev;
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                if ((WXS_ATTR_GROUP_CAST prev)->flags &
-                    XML_SCHEMAS_ATTRGROUP_REDEFINED)
-                {
-                    wasRedefined = 1;
-                    break;
-                }
-                (WXS_ATTR_GROUP_CAST prev)->flags |=
-                    XML_SCHEMAS_ATTRGROUP_REDEFINED;
-                if (redef->reference != NULL) {
-                    /*
-                    * Assign the redefined attribute group to the
-                    * QName-reference component.
-                    * This is the easy case, since we will just
-                    * expand the redefined group.
-                    */
-                    (WXS_QNAME_CAST redef->reference)->item = prev;
-                    redef->target = NULL;
-                } else {
-                    /*
-                    * This is the complicated case: we need
-                    * to apply src-redefine (7.2.2) at a later
-                    * stage, i.e. when attribute group references
-                    * have beed expanded and simple types have
-                    * beed fixed.
-                    */
-                    redef->target = prev;
-                }
-                break;
-            default:
-                PERROR_INT("xmlSchemaResolveRedefReferences",
-                    "Unexpected redefined component type");
-                return(-1);
-        }
-        if (wasRedefined) {
-            xmlChar *str = NULL;
-            xmlNodePtr node;
-
-            if (redef->reference)
-                node = WXS_ITEM_NODE(redef->reference);
-            else
-                node = WXS_ITEM_NODE(redef->item);
-
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                /* TODO: error code. */
-                XML_SCHEMAP_SRC_REDEFINE,
-                node, NULL,
-                "The referenced %s was already redefined. Multiple "
-                "redefinition of the same component is not supported",
-                xmlSchemaGetComponentDesignation(&str, prev),
-                NULL);
-            FREE_AND_NULL(str)
-            err = pctxt->err;
-            redef = redef->next;
-            continue;
-        }
-        redef = redef->next;
-    } while (redef != NULL);
-
-    return(err);
-}
-
-static int
-xmlSchemaCheckSRCRedefineSecond(xmlSchemaParserCtxtPtr pctxt)
-{
-    int err = 0;
-    xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
-    xmlSchemaBasicItemPtr item;
-
-    if (redef == NULL)
-        return(0);
-
-    do {
-        if (redef->target == NULL) {
-            redef = redef->next;
-            continue;
-        }
-        item = redef->item;
-
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_SIMPLE:
-            case XML_SCHEMA_TYPE_COMPLEX:
-                /*
-                * Since the spec wants the {name} of the redefined
-                * type to be 'absent', we'll NULL it.
-                */
-                (WXS_TYPE_CAST redef->target)->name = NULL;
-
-                /*
-                * TODO: Seems like there's nothing more to do. The normal
-                * inheritance mechanism is used. But not 100% sure.
-                */
-                break;
-            case XML_SCHEMA_TYPE_GROUP:
-                /*
-                * URGENT TODO:
-                * SPEC src-redefine:
-                * (6.2.2) "The {model group} of the model group definition
-                * which corresponds to it per XML Representation of Model
-                * Group Definition Schema Components ($3.7.2) must be a
-                * `valid restriction` of the {model group} of that model
-                * group definition in I, as defined in Particle Valid
-                * (Restriction) ($3.9.6)."
-                */
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                /*
-                * SPEC src-redefine:
-                * (7.2.2) "The {attribute uses} and {attribute wildcard} of
-                * the attribute group definition which corresponds to it
-                * per XML Representation of Attribute Group Definition Schema
-                * Components ($3.6.2) must be `valid restrictions` of the
-                * {attribute uses} and {attribute wildcard} of that attribute
-                * group definition in I, as defined in clause 2, clause 3 and
-                * clause 4 of Derivation Valid (Restriction, Complex)
-                * ($3.4.6) (where references to the base type definition are
-                * understood as references to the attribute group definition
-                * in I)."
-                */
-                err = xmlSchemaCheckDerivationOKRestriction2to4(pctxt,
-                    XML_SCHEMA_ACTION_REDEFINE,
-                    item, redef->target,
-                    (WXS_ATTR_GROUP_CAST item)->attrUses,
-                    (WXS_ATTR_GROUP_CAST redef->target)->attrUses,
-                    (WXS_ATTR_GROUP_CAST item)->attributeWildcard,
-                    (WXS_ATTR_GROUP_CAST redef->target)->attributeWildcard);
-                if (err == -1)
-                    return(-1);
-                break;
-            default:
-                break;
-        }
-        redef = redef->next;
-    } while (redef != NULL);
-    return(0);
-}
-
-
-static int
-xmlSchemaAddComponents(xmlSchemaParserCtxtPtr pctxt,
-                       xmlSchemaBucketPtr bucket)
-{
-    xmlSchemaBasicItemPtr item;
-    int err;
-    xmlHashTablePtr *table;
-    const xmlChar *name;
-    int i;
-
-#define WXS_GET_GLOBAL_HASH(c, slot) { \
-    if (WXS_IS_BUCKET_IMPMAIN((c)->type)) \
-        table = &(WXS_IMPBUCKET((c))->schema->slot); \
-    else \
-        table = &(WXS_INCBUCKET((c))->ownerImport->schema->slot); }
-
-    /*
-    * Add global components to the schema's hash tables.
-    * This is the place where duplicate components will be
-    * detected.
-    * TODO: I think normally we should support imports of the
-    *   same namespace from multiple locations. We don't do currently,
-    *   but if we do then according to:
-    *   http://www.w3.org/Bugs/Public/show_bug.cgi?id=2224
-    *   we would need, if imported directly, to import redefined
-    *   components as well to be able to catch clashing components.
-    *   (I hope I'll still know what this means after some months :-()
-    */
-    if (bucket == NULL)
-        return(-1);
-    if (bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED)
-        return(0);
-    bucket->flags |= XML_SCHEMA_BUCKET_COMPS_ADDED;
-
-    for (i = 0; i < bucket->globals->nbItems; i++) {
-        item = bucket->globals->items[i];
-        table = NULL;
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_COMPLEX:
-            case XML_SCHEMA_TYPE_SIMPLE:
-                if (WXS_REDEFINED_TYPE(item))
-                    continue;
-                name = (WXS_TYPE_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, typeDecl)
-                break;
-            case XML_SCHEMA_TYPE_ELEMENT:
-                name = (WXS_ELEM_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, elemDecl)
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTE:
-                name = (WXS_ATTR_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, attrDecl)
-                break;
-            case XML_SCHEMA_TYPE_GROUP:
-                if (WXS_REDEFINED_MODEL_GROUP_DEF(item))
-                    continue;
-                name = (WXS_MODEL_GROUPDEF_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, groupDecl)
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                if (WXS_REDEFINED_ATTR_GROUP(item))
-                    continue;
-                name = (WXS_ATTR_GROUP_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, attrgrpDecl)
-                break;
-            case XML_SCHEMA_TYPE_IDC_KEY:
-            case XML_SCHEMA_TYPE_IDC_UNIQUE:
-            case XML_SCHEMA_TYPE_IDC_KEYREF:
-                name = (WXS_IDC_CAST item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, idcDef)
-                break;
-            case XML_SCHEMA_TYPE_NOTATION:
-                name = ((xmlSchemaNotationPtr) item)->name;
-                WXS_GET_GLOBAL_HASH(bucket, notaDecl)
-                break;
-            default:
-                PERROR_INT("xmlSchemaAddComponents",
-                    "Unexpected global component type");
-                continue;
-        }
-        if (*table == NULL) {
-            *table = xmlHashCreateDict(10, pctxt->dict);
-            if (*table == NULL) {
-                PERROR_INT("xmlSchemaAddComponents",
-                    "failed to create a component hash table");
-                return(-1);
-            }
-        }
-        err = xmlHashAddEntry(*table, name, item);
-        if (err != 0) {
-            xmlChar *str = NULL;
-
-            xmlSchemaCustomErr(ACTXT_CAST pctxt,
-                XML_SCHEMAP_REDEFINED_TYPE,
-                WXS_ITEM_NODE(item),
-                WXS_BASIC_CAST item,
-                "A global %s '%s' does already exist",
-                WXS_ITEM_TYPE_NAME(item),
-                xmlSchemaGetComponentQName(&str, item));
-            FREE_AND_NULL(str);
-        }
-    }
-    /*
-    * Process imported/included schemas.
-    */
-    if (bucket->relations != NULL) {
-        xmlSchemaSchemaRelationPtr rel = bucket->relations;
-        do {
-            if ((rel->bucket != NULL) &&
-                ((rel->bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED) == 0)) {
-                if (xmlSchemaAddComponents(pctxt, rel->bucket) == -1)
-                    return(-1);
-            }
-            rel = rel->next;
-        } while (rel != NULL);
-    }
-    return(0);
-}
-
-static int
-xmlSchemaFixupComponents(xmlSchemaParserCtxtPtr pctxt,
-                         xmlSchemaBucketPtr rootBucket)
-{
-    xmlSchemaConstructionCtxtPtr con = pctxt->constructor;
-    xmlSchemaTreeItemPtr item, *items;
-    int nbItems, i, ret = 0;
-    xmlSchemaBucketPtr oldbucket = con->bucket;
-    xmlSchemaElementPtr elemDecl;
-
-#define FIXHFAILURE if (pctxt->err == XML_SCHEMAP_INTERNAL) goto exit_failure;
-
-    if ((con->pending == NULL) ||
-        (con->pending->nbItems == 0))
-        return(0);
-
-    /*
-    * Since xmlSchemaFixupComplexType() will create new particles
-    * (local components), and those particle components need a bucket
-    * on the constructor, we'll assure here that the constructor has
-    * a bucket.
-    * TODO: Think about storing locals _only_ on the main bucket.
-    */
-    if (con->bucket == NULL)
-        con->bucket = rootBucket;
-
-    /* TODO:
-    * SPEC (src-redefine):
-    * (6.2) "If it has no such self-reference, then all of the
-    * following must be true:"
-
-    * (6.2.2) The {model group} of the model group definition which
-    * corresponds to it per XML Representation of Model Group
-    * Definition Schema Components ($3.7.2) must be a `valid
-    * restriction` of the {model group} of that model group definition
-    * in I, as defined in Particle Valid (Restriction) ($3.9.6)."
-    */
-    xmlSchemaCheckSRCRedefineFirst(pctxt);
-
-    /*
-    * Add global components to the schemata's hash tables.
-    */
-    xmlSchemaAddComponents(pctxt, rootBucket);
-
-    pctxt->ctxtType = NULL;
-    items = (xmlSchemaTreeItemPtr *) con->pending->items;
-    nbItems = con->pending->nbItems;
-    /*
-    * Now that we have parsed *all* the schema document(s) and converted
-    * them to schema components, we can resolve references, apply component
-    * constraints, create the FSA from the content model, etc.
-    */
-    /*
-    * Resolve references of..
-    *
-    * 1. element declarations:
-    *   - the type definition
-    *   - the substitution group affiliation
-    * 2. simple/complex types:
-    *   - the base type definition
-    *   - the memberTypes of union types
-    *   - the itemType of list types
-    * 3. attributes declarations and attribute uses:
-    *   - the type definition
-    *   - if an attribute use, then the attribute declaration
-    * 4. attribute group references:
-    *   - the attribute group definition
-    * 5. particles:
-    *   - the term of the particle (e.g. a model group)
-    * 6. IDC key-references:
-    *   - the referenced IDC 'key' or 'unique' definition
-    * 7. Attribute prohibitions which had a "ref" attribute.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_ELEMENT:
-                xmlSchemaResolveElementReferences(
-                    (xmlSchemaElementPtr) item, pctxt);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_TYPE_COMPLEX:
-            case XML_SCHEMA_TYPE_SIMPLE:
-                xmlSchemaResolveTypeReferences(
-                    (xmlSchemaTypePtr) item, pctxt);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTE:
-                xmlSchemaResolveAttrTypeReferences(
-                    (xmlSchemaAttributePtr) item, pctxt);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-                xmlSchemaResolveAttrUseReferences(
-                    (xmlSchemaAttributeUsePtr) item, pctxt);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_EXTRA_QNAMEREF:
-                if ((WXS_QNAME_CAST item)->itemType ==
-                    XML_SCHEMA_TYPE_ATTRIBUTEGROUP)
-                {
-                    xmlSchemaResolveAttrGroupReferences(
-                        WXS_QNAME_CAST item, pctxt);
-                }
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_TYPE_SEQUENCE:
-            case XML_SCHEMA_TYPE_CHOICE:
-            case XML_SCHEMA_TYPE_ALL:
-                xmlSchemaResolveModelGroupParticleReferences(pctxt,
-                    WXS_MODEL_GROUP_CAST item);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_TYPE_IDC_KEY:
-            case XML_SCHEMA_TYPE_IDC_UNIQUE:
-            case XML_SCHEMA_TYPE_IDC_KEYREF:
-                xmlSchemaResolveIDCKeyReferences(
-                    (xmlSchemaIDCPtr) item, pctxt);
-                FIXHFAILURE;
-                break;
-            case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
-                /*
-                * Handle attribue prohibition which had a
-                * "ref" attribute.
-                */
-                xmlSchemaResolveAttrUseProhibReferences(
-                    WXS_ATTR_PROHIB_CAST item, pctxt);
-                FIXHFAILURE;
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Now that all references are resolved we
-    * can check for circularity of...
-    * 1. the base axis of type definitions
-    * 2. nested model group definitions
-    * 3. nested attribute group definitions
-    * TODO: check for circual substitution groups.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        /*
-        * Let's better stop on the first error here.
-        */
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_COMPLEX:
-            case XML_SCHEMA_TYPE_SIMPLE:
-                xmlSchemaCheckTypeDefCircular(
-                    (xmlSchemaTypePtr) item, pctxt);
-                FIXHFAILURE;
-                if (pctxt->nberrors != 0)
-                    goto exit_error;
-                break;
-            case XML_SCHEMA_TYPE_GROUP:
-                xmlSchemaCheckGroupDefCircular(
-                    (xmlSchemaModelGroupDefPtr) item, pctxt);
-                FIXHFAILURE;
-                if (pctxt->nberrors != 0)
-                    goto exit_error;
-                break;
-            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                xmlSchemaCheckAttrGroupCircular(
-                    (xmlSchemaAttributeGroupPtr) item, pctxt);
-                FIXHFAILURE;
-                if (pctxt->nberrors != 0)
-                    goto exit_error;
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * Model group definition references:
-    * Such a reference is reflected by a particle at the component
-    * level. Until now the 'term' of such particles pointed
-    * to the model group definition; this was done, in order to
-    * ease circularity checks. Now we need to set the 'term' of
-    * such particles to the model group of the model group definition.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_SEQUENCE:
-            case XML_SCHEMA_TYPE_CHOICE:
-                xmlSchemaModelGroupToModelGroupDefFixup(pctxt,
-                    WXS_MODEL_GROUP_CAST item);
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * Expand attribute group references of attribute group definitions.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-                if ((! WXS_ATTR_GROUP_EXPANDED(item)) &&
-                    WXS_ATTR_GROUP_HAS_REFS(item))
-                {
-                    xmlSchemaAttributeGroupExpandRefs(pctxt,
-                        WXS_ATTR_GROUP_CAST item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * First compute the variety of simple types. This is needed as
-    * a seperate step, since otherwise we won't be able to detect
-    * circular union types in all cases.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_SIMPLE:
-                if (WXS_IS_TYPE_NOT_FIXED_1((xmlSchemaTypePtr) item)) {
-                    xmlSchemaFixupSimpleTypeStageOne(pctxt,
-                        (xmlSchemaTypePtr) item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * Detect circular union types. Note that this needs the variety to
-    * be already computed.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_SIMPLE:
-                if (((xmlSchemaTypePtr) item)->memberTypes != NULL) {
-                    xmlSchemaCheckUnionTypeDefCircular(pctxt,
-                        (xmlSchemaTypePtr) item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Do the complete type fixup for simple types.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_SIMPLE:
-                if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
-                    xmlSchemaFixupSimpleTypeStageTwo(pctxt, WXS_TYPE_CAST item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * At this point we need build and check all simple types.
-    */
-    /*
-    * Apply contraints for attribute declarations.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_ATTRIBUTE:
-                xmlSchemaCheckAttrPropsCorrect(pctxt, WXS_ATTR_CAST item);
-                FIXHFAILURE;
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * Apply constraints for attribute uses.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
-                if (((xmlSchemaAttributeUsePtr)item)->defValue != NULL) {
-                    xmlSchemaCheckAttrUsePropsCorrect(pctxt,
-                        WXS_ATTR_USE_CAST item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Apply constraints for attribute group definitions.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-        case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
-            if (( (WXS_ATTR_GROUP_CAST item)->attrUses != NULL) &&
-                ( (WXS_LIST_CAST (WXS_ATTR_GROUP_CAST item)->attrUses)->nbItems > 1))
-            {
-                xmlSchemaCheckAGPropsCorrect(pctxt, WXS_ATTR_GROUP_CAST item);
-                FIXHFAILURE;
-            }
-            break;
-        default:
-            break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Apply constraints for redefinitions.
-    */
-    if (WXS_CONSTRUCTOR(pctxt)->redefs != NULL)
-        xmlSchemaCheckSRCRedefineSecond(pctxt);
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Complex types are builded and checked.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = con->pending->items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_COMPLEX:
-                if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
-                    xmlSchemaFixupComplexType(pctxt, WXS_TYPE_CAST item);
-                    FIXHFAILURE;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * The list could have changed, since xmlSchemaFixupComplexType()
-    * will create particles and model groups in some cases.
-    */
-    items = (xmlSchemaTreeItemPtr *) con->pending->items;
-    nbItems = con->pending->nbItems;
-
-    /*
-    * Apply some constraints for element declarations.
-    */
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_ELEMENT:
-                elemDecl = (xmlSchemaElementPtr) item;
-
-                if ((elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED) == 0)
-                {
-                    xmlSchemaCheckElementDeclComponent(
-                        (xmlSchemaElementPtr) elemDecl, pctxt);
-                    FIXHFAILURE;
-                }
-
-#ifdef WXS_ELEM_DECL_CONS_ENABLED
-                /*
-                * Schema Component Constraint: Element Declarations Consistent
-                * Apply this constraint to local types of element declarations.
-                */
-                if ((WXS_ELEM_TYPEDEF(elemDecl) != NULL) &&
-                    (WXS_IS_COMPLEX(WXS_ELEM_TYPEDEF(elemDecl))) &&
-                    (WXS_TYPE_IS_LOCAL(WXS_ELEM_TYPEDEF(elemDecl))))
-                {
-                    xmlSchemaCheckElementDeclConsistent(pctxt,
-                        WXS_BASIC_CAST elemDecl,
-                        WXS_TYPE_PARTICLE(WXS_ELEM_TYPEDEF(elemDecl)),
-                        NULL, NULL, 0);
-                }
-#endif
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-
-    /*
-    * Finally we can build the automaton from the content model of
-    * complex types.
-    */
-
-    for (i = 0; i < nbItems; i++) {
-        item = items[i];
-        switch (item->type) {
-            case XML_SCHEMA_TYPE_COMPLEX:
-                xmlSchemaBuildContentModel((xmlSchemaTypePtr) item, pctxt);
-                /* FIXHFAILURE; */
-                break;
-            default:
-                break;
-        }
-    }
-    if (pctxt->nberrors != 0)
-        goto exit_error;
-    /*
-    * URGENT TODO: cos-element-consistent
-    */
-    goto exit;
-
-exit_error:
-    ret = pctxt->err;
-    goto exit;
-
-exit_failure:
-    ret = -1;
-
-exit:
-    /*
-    * Reset the constructor. This is needed for XSI acquisition, since
-    * those items will be processed over and over again for every XSI
-    * if not cleared here.
-    */
-    con->bucket = oldbucket;
-    con->pending->nbItems = 0;
-    if (con->substGroups != NULL) {
-        xmlHashFree(con->substGroups,
-            (xmlHashDeallocator) xmlSchemaSubstGroupFree);
-        con->substGroups = NULL;
-    }
-    if (con->redefs != NULL) {
-        xmlSchemaRedefListFree(con->redefs);
-        con->redefs = NULL;
-    }
-    return(ret);
-}
-/**
- * xmlSchemaParse:
- * @ctxt:  a schema validation context
- *
- * parse a schema definition resource and build an internal
- * XML Shema struture which can be used to validate instances.
- *
- * Returns the internal XML Schema structure built from the resource or
- *         NULL in case of error
- */
-xmlSchemaPtr
-xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
-{
-    xmlSchemaPtr mainSchema = NULL;
-    xmlSchemaBucketPtr bucket = NULL;
-    int res;
-
-    /*
-    * This one is used if the schema to be parsed was specified via
-    * the API; i.e. not automatically by the validated instance document.
-    */
-
-    xmlSchemaInitTypes();
-
-    if (ctxt == NULL)
-        return (NULL);
-
-    /* TODO: Init the context. Is this all we need?*/
-    ctxt->nberrors = 0;
-    ctxt->err = 0;
-    ctxt->counter = 0;
-
-    /* Create the *main* schema. */
-    mainSchema = xmlSchemaNewSchema(ctxt);
-    if (mainSchema == NULL)
-        goto exit_failure;
-    /*
-    * Create the schema constructor.
-    */
-    if (ctxt->constructor == NULL) {
-        ctxt->constructor = xmlSchemaConstructionCtxtCreate(ctxt->dict);
-        if (ctxt->constructor == NULL)
-            return(NULL);
-        /* Take ownership of the constructor to be able to free it. */
-        ctxt->ownsConstructor = 1;
-    }
-    ctxt->constructor->mainSchema = mainSchema;
-    /*
-    * Locate and add the schema document.
-    */
-    res = xmlSchemaAddSchemaDoc(ctxt, XML_SCHEMA_SCHEMA_MAIN,
-        ctxt->URL, ctxt->doc, ctxt->buffer, ctxt->size, NULL,
-        NULL, NULL, &bucket);
-    if (res == -1)
-        goto exit_failure;
-    if (res != 0)
-        goto exit;
-
-    if (bucket == NULL) {
-        /* TODO: Error code, actually we failed to *locate* the schema. */
-        if (ctxt->URL)
-            xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
-                NULL, NULL,
-                "Failed to locate the main schema resource at '%s'",
-                ctxt->URL, NULL);
-        else
-            xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
-                NULL, NULL,
-                "Failed to locate the main schema resource",
-                    NULL, NULL);
-        goto exit;
-    }
-    /* Then do the parsing for good. */
-    if (xmlSchemaParseNewDocWithContext(ctxt, mainSchema, bucket) == -1)
-        goto exit_failure;
-    if (ctxt->nberrors != 0)
-        goto exit;
-
-    mainSchema->doc = bucket->doc;
-    mainSchema->preserve = ctxt->preserve;
-
-    ctxt->schema = mainSchema;
-
-    if (xmlSchemaFixupComponents(ctxt, WXS_CONSTRUCTOR(ctxt)->mainBucket) == -1)
-        goto exit_failure;
-
-    /*
-    * TODO: This is not nice, since we cannot distinguish from the
-    * result if there was an internal error or not.
-    */
-exit:
-    if (ctxt->nberrors != 0) {
-        if (mainSchema) {
-            xmlSchemaFree(mainSchema);
-            mainSchema = NULL;
-        }
-        if (ctxt->constructor) {
-            xmlSchemaConstructionCtxtFree(ctxt->constructor);
-            ctxt->constructor = NULL;
-            ctxt->ownsConstructor = 0;
-        }
-    }
-    ctxt->schema = NULL;
-    return(mainSchema);
-exit_failure:
-    /*
-    * Quite verbose, but should catch internal errors, which were
-    * not communitated.
-    */
-    if (mainSchema) {
-        xmlSchemaFree(mainSchema);
-        mainSchema = NULL;
-    }
-    if (ctxt->constructor) {
-        xmlSchemaConstructionCtxtFree(ctxt->constructor);
-        ctxt->constructor = NULL;
-        ctxt->ownsConstructor = 0;
-    }
-    PERROR_INT2("xmlSchemaParse",
-        "An internal error occured");
-    ctxt->schema = NULL;
-    return(NULL);
-}
-
-/**
- * xmlSchemaSetParserErrors:
- * @ctxt:  a schema validation context
- * @err:  the error callback
- * @warn:  the warning callback
- * @ctx:  contextual data for the callbacks
- *
- * Set the callback functions used to handle errors for a validation context
- */
-void
-xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
-                         xmlSchemaValidityErrorFunc err,
-                         xmlSchemaValidityWarningFunc warn, void *ctx)
-{
-    if (ctxt == NULL)
-        return;
-    ctxt->error = err;
-    ctxt->warning = warn;
-    ctxt->errCtxt = ctx;
-    if (ctxt->vctxt != NULL)
-        xmlSchemaSetValidErrors(ctxt->vctxt, err, warn, ctx);
-}
-
-/**
- * xmlSchemaSetParserStructuredErrors:
- * @ctxt:  a schema parser context
- * @serror:  the structured error function
- * @ctx: the functions context
- *
- * Set the structured error callback
- */
-void
-xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt,
-                                   xmlStructuredErrorFunc serror,
-                                   void *ctx)
-{
-    if (ctxt == NULL)
-        return;
-    ctxt->serror = serror;
-    ctxt->errCtxt = ctx;
-    if (ctxt->vctxt != NULL)
-        xmlSchemaSetValidStructuredErrors(ctxt->vctxt, serror, ctx);
-}
-
-/**
- * xmlSchemaGetParserErrors:
- * @ctxt:  a XMl-Schema parser context
- * @err: the error callback result
- * @warn: the warning callback result
- * @ctx: contextual data for the callbacks result
- *
- * Get the callback information used to handle errors for a parser context
- *
- * Returns -1 in case of failure, 0 otherwise
- */
-int
-xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
-                         xmlSchemaValidityErrorFunc * err,
-                         xmlSchemaValidityWarningFunc * warn, void **ctx)
-{
-        if (ctxt == NULL)
-                return(-1);
-        if (err != NULL)
-                *err = ctxt->error;
-        if (warn != NULL)
-                *warn = ctxt->warning;
-        if (ctx != NULL)
-                *ctx = ctxt->errCtxt;
-        return(0);
-}
-
-/**
- * xmlSchemaFacetTypeToString:
- * @type:  the facet type
- *
- * Convert the xmlSchemaTypeType to a char string.
- *
- * Returns the char string representation of the facet type if the
- *     type is a facet and an "Internal Error" string otherwise.
- */
-static const xmlChar *
-xmlSchemaFacetTypeToString(xmlSchemaTypeType type)
-{
-    switch (type) {
-        case XML_SCHEMA_FACET_PATTERN:
-            return (BAD_CAST "pattern");
-        case XML_SCHEMA_FACET_MAXEXCLUSIVE:
-            return (BAD_CAST "maxExclusive");
-        case XML_SCHEMA_FACET_MAXINCLUSIVE:
-            return (BAD_CAST "maxInclusive");
-        case XML_SCHEMA_FACET_MINEXCLUSIVE:
-            return (BAD_CAST "minExclusive");
-        case XML_SCHEMA_FACET_MININCLUSIVE:
-            return (BAD_CAST "minInclusive");
-        case XML_SCHEMA_FACET_WHITESPACE:
-            return (BAD_CAST "whiteSpace");
-        case XML_SCHEMA_FACET_ENUMERATION:
-            return (BAD_CAST "enumeration");
-        case XML_SCHEMA_FACET_LENGTH:
-            return (BAD_CAST "length");
-        case XML_SCHEMA_FACET_MAXLENGTH:
-            return (BAD_CAST "maxLength");
-        case XML_SCHEMA_FACET_MINLENGTH:
-            return (BAD_CAST "minLength");
-        case XML_SCHEMA_FACET_TOTALDIGITS:
-            return (BAD_CAST "totalDigits");
-        case XML_SCHEMA_FACET_FRACTIONDIGITS:
-            return (BAD_CAST "fractionDigits");
-        default:
-            break;
-    }
-    return (BAD_CAST "Internal Error");
-}
-
-static xmlSchemaWhitespaceValueType
-xmlSchemaGetWhiteSpaceFacetValue(xmlSchemaTypePtr type)
-{
-    /*
-    * The normalization type can be changed only for types which are derived
-    * from xsd:string.
-    */
-    if (type->type == XML_SCHEMA_TYPE_BASIC) {
-        /*
-        * Note that we assume a whitespace of preserve for anySimpleType.
-        */
-        if ((type->builtInType == XML_SCHEMAS_STRING) ||
-            (type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE))
-            return(XML_SCHEMA_WHITESPACE_PRESERVE);
-        else if (type->builtInType == XML_SCHEMAS_NORMSTRING)
-            return(XML_SCHEMA_WHITESPACE_REPLACE);
-        else {
-            /*
-            * For all `atomic` datatypes other than string (and types `derived`
-            * by `restriction` from it) the value of whiteSpace is fixed to
-            * collapse
-            * Note that this includes built-in list datatypes.
-            */
-            return(XML_SCHEMA_WHITESPACE_COLLAPSE);
-        }
-    } else if (WXS_IS_LIST(type)) {
-        /*
-        * For list types the facet "whiteSpace" is fixed to "collapse".
-        */
-        return (XML_SCHEMA_WHITESPACE_COLLAPSE);
-    } else if (WXS_IS_UNION(type)) {
-        return (XML_SCHEMA_WHITESPACE_UNKNOWN);
-    } else if (WXS_IS_ATOMIC(type)) {
-        if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE)
-            return (XML_SCHEMA_WHITESPACE_PRESERVE);
-        else if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_REPLACE)
-            return (XML_SCHEMA_WHITESPACE_REPLACE);
-        else
-            return (XML_SCHEMA_WHITESPACE_COLLAPSE);
-    }
-    return (-1);
-}
-
-/************************************************************************
- *                                                                      *
- *                      Simple type validation                          *
- *                                                                      *
- ************************************************************************/
-
-
-/************************************************************************
- *                                                                      *
- *                      DOM Validation code                             *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaAssembleByLocation:
- * @pctxt:  a schema parser context
- * @vctxt:  a schema validation context
- * @schema: the existing schema
- * @node: the node that fired the assembling
- * @nsName: the namespace name of the new schema
- * @location: the location of the schema
- *
- * Expands an existing schema by an additional schema.
- *
- * Returns 0 if the new schema is correct, a positive error code
- * number otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaAssembleByLocation(xmlSchemaValidCtxtPtr vctxt,
-                            xmlSchemaPtr schema,
-                            xmlNodePtr node,
-                            const xmlChar *nsName,
-                            const xmlChar *location)
-{
-    int ret = 0;
-    xmlSchemaParserCtxtPtr pctxt;
-    xmlSchemaBucketPtr bucket = NULL;
-
-    if ((vctxt == NULL) || (schema == NULL))
-        return (-1);
-
-    if (vctxt->pctxt == NULL) {
-        VERROR_INT("xmlSchemaAssembleByLocation",
-            "no parser context available");
-        return(-1);
-    }
-    pctxt = vctxt->pctxt;
-    if (pctxt->constructor == NULL) {
-        PERROR_INT("xmlSchemaAssembleByLocation",
-            "no constructor");
-        return(-1);
-    }
-    /*
-    * Acquire the schema document.
-    */
-    location = xmlSchemaBuildAbsoluteURI(pctxt->dict,
-        location, node);
-    /*
-    * Note that we pass XML_SCHEMA_SCHEMA_IMPORT here;
-    * the process will automatically change this to
-    * XML_SCHEMA_SCHEMA_MAIN if it is the first schema document.
-    */
-    ret = xmlSchemaAddSchemaDoc(pctxt, XML_SCHEMA_SCHEMA_IMPORT,
-        location, NULL, NULL, 0, node, NULL, nsName,
-        &bucket);
-    if (ret != 0)
-        return(ret);
-    if (bucket == NULL) {
-        /*
-        * Generate a warning that the document could not be located.
-        */
-        xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
-            node, NULL,
-            "The document at location '%s' could not be acquired",
-            location, NULL, NULL);
-        return(ret);
-    }
-    /*
-    * The first located schema will be handled as if all other
-    * schemas imported by XSI were imported by this first schema.
-    */
-    if ((bucket != NULL) &&
-        (WXS_CONSTRUCTOR(pctxt)->bucket == NULL))
-        WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
-    /*
-    * TODO: Is this handled like an import? I.e. is it not an error
-    * if the schema cannot be located?
-    */
-    if ((bucket == NULL) || (! CAN_PARSE_SCHEMA(bucket)))
-        return(0);
-    /*
-    * We will reuse the parser context for every schema imported
-    * directly via XSI. So reset the context.
-    */
-    pctxt->nberrors = 0;
-    pctxt->err = 0;
-    pctxt->doc = bucket->doc;
-
-    ret = xmlSchemaParseNewDocWithContext(pctxt, schema, bucket);
-    if (ret == -1) {
-        pctxt->doc = NULL;
-        goto exit_failure;
-    }
-    /* Paranoid error channelling. */
-    if ((ret == 0) && (pctxt->nberrors != 0))
-        ret = pctxt->err;
-    if (pctxt->nberrors == 0) {
-        /*
-        * Only bother to fixup pending components, if there was
-        * no error yet.
-        * For every XSI acquired schema (and its sub-schemata) we will
-        * fixup the components.
-        */
-        xmlSchemaFixupComponents(pctxt, bucket);
-        ret = pctxt->err;
-        /*
-        * Not nice, but we need somehow to channel the schema parser
-        * error to the validation context.
-        */
-        if ((ret != 0) && (vctxt->err == 0))
-            vctxt->err = ret;
-        vctxt->nberrors += pctxt->nberrors;
-    } else {
-        /* Add to validation error sum. */
-        vctxt->nberrors += pctxt->nberrors;
-    }
-    pctxt->doc = NULL;
-    return(ret);
-exit_failure:
-    pctxt->doc = NULL;
-    return (-1);
-}
-
-static xmlSchemaAttrInfoPtr
-xmlSchemaGetMetaAttrInfo(xmlSchemaValidCtxtPtr vctxt,
-                         int metaType)
-{
-    if (vctxt->nbAttrInfos == 0)
-        return (NULL);
-    {
-        int i;
-        xmlSchemaAttrInfoPtr iattr;
-
-        for (i = 0; i < vctxt->nbAttrInfos; i++) {
-            iattr = vctxt->attrInfos[i];
-            if (iattr->metaType == metaType)
-                return (iattr);
-        }
-
-    }
-    return (NULL);
-}
-
-/**
- * xmlSchemaAssembleByXSI:
- * @vctxt:  a schema validation context
- *
- * Expands an existing schema by an additional schema using
- * the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute
- * of an instance. If xsi:noNamespaceSchemaLocation is used, @noNamespace
- * must be set to 1.
- *
- * Returns 0 if the new schema is correct, a positive error code
- * number otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaAssembleByXSI(xmlSchemaValidCtxtPtr vctxt)
-{
-    const xmlChar *cur, *end;
-    const xmlChar *nsname = NULL, *location;
-    int count = 0;
-    int ret = 0;
-    xmlSchemaAttrInfoPtr iattr;
-
-    /*
-    * Parse the value; we will assume an even number of values
-    * to be given (this is how Xerces and XSV work).
-    *
-    * URGENT TODO: !! This needs to work for both
-    * @noNamespaceSchemaLocation AND @schemaLocation on the same
-    * element !!
-    */
-    iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-        XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC);
-    if (iattr == NULL)
-        iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-        XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC);
-    if (iattr == NULL)
-        return (0);
-    cur = iattr->value;
-    do {
-        /*
-        * TODO: Move the string parsing mechanism away from here.
-        */
-        if (iattr->metaType == XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC) {
-            /*
-            * Get the namespace name.
-            */
-            while (IS_BLANK_CH(*cur))
-                cur++;
-            end = cur;
-            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-                end++;
-            if (end == cur)
-                break;
-            count++; /* TODO: Don't use the schema's dict. */
-            nsname = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
-            cur = end;
-        }
-        /*
-        * Get the URI.
-        */
-        while (IS_BLANK_CH(*cur))
-            cur++;
-        end = cur;
-        while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-            end++;
-        if (end == cur) {
-            if (iattr->metaType ==
-                XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC)
-            {
-                /*
-                * If using @schemaLocation then tuples are expected.
-                * I.e. the namespace name *and* the document's URI.
-                */
-                xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
-                    iattr->node, NULL,
-                    "The value must consist of tuples: the target namespace "
-                    "name and the document's URI", NULL, NULL, NULL);
-            }
-            break;
-        }
-        count++; /* TODO: Don't use the schema's dict. */
-        location = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
-        cur = end;
-        ret = xmlSchemaAssembleByLocation(vctxt, vctxt->schema,
-            iattr->node, nsname, location);
-        if (ret == -1) {
-            VERROR_INT("xmlSchemaAssembleByXSI",
-                "assembling schemata");
-            return (-1);
-        }
-    } while (*cur != 0);
-    return (ret);
-}
-
-static const xmlChar *
-xmlSchemaLookupNamespace(xmlSchemaValidCtxtPtr vctxt,
-                         const xmlChar *prefix)
-{
-    if (vctxt->sax != NULL) {
-        int i, j;
-        xmlSchemaNodeInfoPtr inode;
-
-        for (i = vctxt->depth; i >= 0; i--) {
-            if (vctxt->elemInfos[i]->nbNsBindings != 0) {
-                inode = vctxt->elemInfos[i];
-                for (j = 0; j < inode->nbNsBindings * 2; j += 2) {
-                    if (((prefix == NULL) &&
-                            (inode->nsBindings[j] == NULL)) ||
-                        ((prefix != NULL) && xmlStrEqual(prefix,
-                            inode->nsBindings[j]))) {
-
-                        /*
-                        * Note that the namespace bindings are already
-                        * in a string dict.
-                        */
-                        return (inode->nsBindings[j+1]);
-                    }
-                }
-            }
-        }
-        return (NULL);
-#ifdef LIBXML_READER_ENABLED
-    } else if (vctxt->reader != NULL) {
-        xmlChar *nsName;
-
-        nsName = xmlTextReaderLookupNamespace(vctxt->reader, prefix);
-        if (nsName != NULL) {
-            const xmlChar *ret;
-
-            ret = xmlDictLookup(vctxt->dict, nsName, -1);
-            xmlFree(nsName);
-            return (ret);
-        } else
-            return (NULL);
-#endif
-    } else {
-        xmlNsPtr ns;
-
-        if ((vctxt->inode->node == NULL) ||
-            (vctxt->inode->node->doc == NULL)) {
-            VERROR_INT("xmlSchemaLookupNamespace",
-                "no node or node's doc avaliable");
-            return (NULL);
-        }
-        ns = xmlSearchNs(vctxt->inode->node->doc,
-            vctxt->inode->node, prefix);
-        if (ns != NULL)
-            return (ns->href);
-        return (NULL);
-    }
-}
-
-/*
-* This one works on the schema of the validation context.
-*/
-static int
-xmlSchemaValidateNotation(xmlSchemaValidCtxtPtr vctxt,
-                          xmlSchemaPtr schema,
-                          xmlNodePtr node,
-                          const xmlChar *value,
-                          xmlSchemaValPtr *val,
-                          int valNeeded)
-{
-    int ret;
-
-    if (vctxt && (vctxt->schema == NULL)) {
-        VERROR_INT("xmlSchemaValidateNotation",
-            "a schema is needed on the validation context");
-        return (-1);
-    }
-    ret = xmlValidateQName(value, 1);
-    if (ret != 0)
-        return (ret);
-    {
-        xmlChar *localName = NULL;
-        xmlChar *prefix = NULL;
-
-        localName = xmlSplitQName2(value, &prefix);
-        if (prefix != NULL) {
-            const xmlChar *nsName = NULL;
-
-            if (vctxt != NULL)
-                nsName = xmlSchemaLookupNamespace(vctxt, BAD_CAST prefix);
-            else if (node != NULL) {
-                xmlNsPtr ns = xmlSearchNs(node->doc, node, prefix);
-                if (ns != NULL)
-                    nsName = ns->href;
-            } else {
-                xmlFree(prefix);
-                xmlFree(localName);
-                return (1);
-            }
-            if (nsName == NULL) {
-                xmlFree(prefix);
-                xmlFree(localName);
-                return (1);
-            }
-            if (xmlSchemaGetNotation(schema, localName, nsName) != NULL) {
-                if ((valNeeded) && (val != NULL)) {
-                    (*val) = xmlSchemaNewNOTATIONValue(xmlStrdup(localName),
-                                                       xmlStrdup(nsName));
-                    if (*val == NULL)
-                        ret = -1;
-                }
-            } else
-                ret = 1;
-            xmlFree(prefix);
-            xmlFree(localName);
-        } else {
-            if (xmlSchemaGetNotation(schema, value, NULL) != NULL) {
-                if (valNeeded && (val != NULL)) {
-                    (*val) = xmlSchemaNewNOTATIONValue(
-                        BAD_CAST xmlStrdup(value), NULL);
-                    if (*val == NULL)
-                        ret = -1;
-                }
-            } else
-                return (1);
-        }
-    }
-    return (ret);
-}
-
-static int
-xmlSchemaVAddNodeQName(xmlSchemaValidCtxtPtr vctxt,
-                       const xmlChar* lname,
-                       const xmlChar* nsname)
-{
-    int i;
-
-    lname = xmlDictLookup(vctxt->dict, lname, -1);
-    if (lname == NULL)
-        return(-1);
-    if (nsname != NULL) {
-        nsname = xmlDictLookup(vctxt->dict, nsname, -1);
-        if (nsname == NULL)
-            return(-1);
-    }
-    for (i = 0; i < vctxt->nodeQNames->nbItems; i += 2) {
-        if ((vctxt->nodeQNames->items [i] == lname) &&
-            (vctxt->nodeQNames->items[i +1] == nsname))
-            /* Already there */
-            return(i);
-    }
-    /* Add new entry. */
-    i = vctxt->nodeQNames->nbItems;
-    xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) lname);
-    xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) nsname);
-    return(i);
-}
-
-/************************************************************************
- *                                                                      *
- *  Validation of identity-constraints (IDC)                            *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaAugmentIDC:
- * @idcDef: the IDC definition
- *
- * Creates an augmented IDC definition item.
- *
- * Returns the item, or NULL on internal errors.
- */
-static void
-xmlSchemaAugmentIDC(xmlSchemaIDCPtr idcDef,
-                    xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaIDCAugPtr aidc;
-
-    aidc = (xmlSchemaIDCAugPtr) xmlMalloc(sizeof(xmlSchemaIDCAug));
-    if (aidc == NULL) {
-        xmlSchemaVErrMemory(vctxt,
-            "xmlSchemaAugmentIDC: allocating an augmented IDC definition",
-            NULL);
-        return;
-    }
-    aidc->keyrefDepth = -1;
-    aidc->def = idcDef;
-    aidc->next = NULL;
-    if (vctxt->aidcs == NULL)
-        vctxt->aidcs = aidc;
-    else {
-        aidc->next = vctxt->aidcs;
-        vctxt->aidcs = aidc;
-    }
-    /*
-    * Save if we have keyrefs at all.
-    */
-    if ((vctxt->hasKeyrefs == 0) &&
-        (idcDef->type == XML_SCHEMA_TYPE_IDC_KEYREF))
-        vctxt->hasKeyrefs = 1;
-}
-
-/**
- * xmlSchemaAugmentImportedIDC:
- * @imported: the imported schema
- *
- * Creates an augmented IDC definition for the imported schema.
- */
-static void
-xmlSchemaAugmentImportedIDC(xmlSchemaImportPtr imported, xmlSchemaValidCtxtPtr vctxt) {
-    if (imported->schema->idcDef != NULL) {
-            xmlHashScan(imported->schema->idcDef ,
-            (xmlHashScanner) xmlSchemaAugmentIDC, vctxt);
-    }
-}
-
-/**
- * xmlSchemaIDCNewBinding:
- * @idcDef: the IDC definition of this binding
- *
- * Creates a new IDC binding.
- *
- * Returns the new IDC binding, NULL on internal errors.
- */
-static xmlSchemaPSVIIDCBindingPtr
-xmlSchemaIDCNewBinding(xmlSchemaIDCPtr idcDef)
-{
-    xmlSchemaPSVIIDCBindingPtr ret;
-
-    ret = (xmlSchemaPSVIIDCBindingPtr) xmlMalloc(
-            sizeof(xmlSchemaPSVIIDCBinding));
-    if (ret == NULL) {
-        xmlSchemaVErrMemory(NULL,
-            "allocating a PSVI IDC binding item", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaPSVIIDCBinding));
-    ret->definition = idcDef;
-    return (ret);
-}
-
-/**
- * xmlSchemaIDCStoreNodeTableItem:
- * @vctxt: the WXS validation context
- * @item: the IDC node table item
- *
- * The validation context is used to store IDC node table items.
- * They are stored to avoid copying them if IDC node-tables are merged
- * with corresponding parent IDC node-tables (bubbling).
- *
- * Returns 0 if succeeded, -1 on internal errors.
- */
-static int
-xmlSchemaIDCStoreNodeTableItem(xmlSchemaValidCtxtPtr vctxt,
-                               xmlSchemaPSVIIDCNodePtr item)
-{
-    /*
-    * Add to gobal list.
-    */
-    if (vctxt->idcNodes == NULL) {
-        vctxt->idcNodes = (xmlSchemaPSVIIDCNodePtr *)
-            xmlMalloc(20 * sizeof(xmlSchemaPSVIIDCNodePtr));
-        if (vctxt->idcNodes == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "allocating the IDC node table item list", NULL);
-            return (-1);
-        }
-        vctxt->sizeIdcNodes = 20;
-    } else if (vctxt->sizeIdcNodes <= vctxt->nbIdcNodes) {
-        vctxt->sizeIdcNodes *= 2;
-        vctxt->idcNodes = (xmlSchemaPSVIIDCNodePtr *)
-            xmlRealloc(vctxt->idcNodes, vctxt->sizeIdcNodes *
-            sizeof(xmlSchemaPSVIIDCNodePtr));
-        if (vctxt->idcNodes == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "re-allocating the IDC node table item list", NULL);
-            return (-1);
-        }
-    }
-    vctxt->idcNodes[vctxt->nbIdcNodes++] = item;
-
-    return (0);
-}
-
-/**
- * xmlSchemaIDCStoreKey:
- * @vctxt: the WXS validation context
- * @item: the IDC key
- *
- * The validation context is used to store an IDC key.
- *
- * Returns 0 if succeeded, -1 on internal errors.
- */
-static int
-xmlSchemaIDCStoreKey(xmlSchemaValidCtxtPtr vctxt,
-                     xmlSchemaPSVIIDCKeyPtr key)
-{
-    /*
-    * Add to gobal list.
-    */
-    if (vctxt->idcKeys == NULL) {
-        vctxt->idcKeys = (xmlSchemaPSVIIDCKeyPtr *)
-            xmlMalloc(40 * sizeof(xmlSchemaPSVIIDCKeyPtr));
-        if (vctxt->idcKeys == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "allocating the IDC key storage list", NULL);
-            return (-1);
-        }
-        vctxt->sizeIdcKeys = 40;
-    } else if (vctxt->sizeIdcKeys <= vctxt->nbIdcKeys) {
-        vctxt->sizeIdcKeys *= 2;
-        vctxt->idcKeys = (xmlSchemaPSVIIDCKeyPtr *)
-            xmlRealloc(vctxt->idcKeys, vctxt->sizeIdcKeys *
-            sizeof(xmlSchemaPSVIIDCKeyPtr));
-        if (vctxt->idcKeys == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "re-allocating the IDC key storage list", NULL);
-            return (-1);
-        }
-    }
-    vctxt->idcKeys[vctxt->nbIdcKeys++] = key;
-
-    return (0);
-}
-
-/**
- * xmlSchemaIDCAppendNodeTableItem:
- * @bind: the IDC binding
- * @ntItem: the node-table item
- *
- * Appends the IDC node-table item to the binding.
- *
- * Returns 0 on success and -1 on internal errors.
- */
-static int
-xmlSchemaIDCAppendNodeTableItem(xmlSchemaPSVIIDCBindingPtr bind,
-                                xmlSchemaPSVIIDCNodePtr ntItem)
-{
-    if (bind->nodeTable == NULL) {
-        bind->sizeNodes = 10;
-        bind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
-            xmlMalloc(10 * sizeof(xmlSchemaPSVIIDCNodePtr));
-        if (bind->nodeTable == NULL) {
-            xmlSchemaVErrMemory(NULL,
-                "allocating an array of IDC node-table items", NULL);
-            return(-1);
-        }
-    } else if (bind->sizeNodes <= bind->nbNodes) {
-        bind->sizeNodes *= 2;
-        bind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
-            xmlRealloc(bind->nodeTable, bind->sizeNodes *
-                sizeof(xmlSchemaPSVIIDCNodePtr));
-        if (bind->nodeTable == NULL) {
-            xmlSchemaVErrMemory(NULL,
-                "re-allocating an array of IDC node-table items", NULL);
-            return(-1);
-        }
-    }
-    bind->nodeTable[bind->nbNodes++] = ntItem;
-    return(0);
-}
-
-/**
- * xmlSchemaIDCAcquireBinding:
- * @vctxt: the WXS validation context
- * @matcher: the IDC matcher
- *
- * Looks up an PSVI IDC binding, for the IDC definition and
- * of the given matcher. If none found, a new one is created
- * and added to the IDC table.
- *
- * Returns an IDC binding or NULL on internal errors.
- */
-static xmlSchemaPSVIIDCBindingPtr
-xmlSchemaIDCAcquireBinding(xmlSchemaValidCtxtPtr vctxt,
-                          xmlSchemaIDCMatcherPtr matcher)
-{
-    xmlSchemaNodeInfoPtr ielem;
-
-    ielem = vctxt->elemInfos[matcher->depth];
-
-    if (ielem->idcTable == NULL) {
-        ielem->idcTable = xmlSchemaIDCNewBinding(matcher->aidc->def);
-        if (ielem->idcTable == NULL)
-            return (NULL);
-        return(ielem->idcTable);
-    } else {
-        xmlSchemaPSVIIDCBindingPtr bind = NULL;
-
-        bind = ielem->idcTable;
-        do {
-            if (bind->definition == matcher->aidc->def)
-                return(bind);
-            if (bind->next == NULL) {
-                bind->next = xmlSchemaIDCNewBinding(matcher->aidc->def);
-                if (bind->next == NULL)
-                    return (NULL);
-                return(bind->next);
-            }
-            bind = bind->next;
-        } while (bind != NULL);
-    }
-    return (NULL);
-}
-
-static xmlSchemaItemListPtr
-xmlSchemaIDCAcquireTargetList(xmlSchemaValidCtxtPtr vctxt ATTRIBUTE_UNUSED,
-                             xmlSchemaIDCMatcherPtr matcher)
-{
-    if (matcher->targets == NULL)
-        matcher->targets = xmlSchemaItemListCreate();
-    return(matcher->targets);
-}
-
-/**
- * xmlSchemaIDCFreeKey:
- * @key: the IDC key
- *
- * Frees an IDC key together with its compiled value.
- */
-static void
-xmlSchemaIDCFreeKey(xmlSchemaPSVIIDCKeyPtr key)
-{
-    if (key->val != NULL)
-        xmlSchemaFreeValue(key->val);
-    xmlFree(key);
-}
-
-/**
- * xmlSchemaIDCFreeBinding:
- *
- * Frees an IDC binding. Note that the node table-items
- * are not freed.
- */
-static void
-xmlSchemaIDCFreeBinding(xmlSchemaPSVIIDCBindingPtr bind)
-{
-    if (bind->nodeTable != NULL)
-        xmlFree(bind->nodeTable);
-    if (bind->dupls != NULL)
-        xmlSchemaItemListFree(bind->dupls);
-    xmlFree(bind);
-}
-
-/**
- * xmlSchemaIDCFreeIDCTable:
- * @bind: the first IDC binding in the list
- *
- * Frees an IDC table, i.e. all the IDC bindings in the list.
- */
-static void
-xmlSchemaIDCFreeIDCTable(xmlSchemaPSVIIDCBindingPtr bind)
-{
-    xmlSchemaPSVIIDCBindingPtr prev;
-
-    while (bind != NULL) {
-        prev = bind;
-        bind = bind->next;
-        xmlSchemaIDCFreeBinding(prev);
-    }
-}
-
-/**
- * xmlSchemaIDCFreeMatcherList:
- * @matcher: the first IDC matcher in the list
- *
- * Frees a list of IDC matchers.
- */
-static void
-xmlSchemaIDCFreeMatcherList(xmlSchemaIDCMatcherPtr matcher)
-{
-    xmlSchemaIDCMatcherPtr next;
-
-    while (matcher != NULL) {
-        next = matcher->next;
-        if (matcher->keySeqs != NULL) {
-            int i;
-            for (i = 0; i < matcher->sizeKeySeqs; i++)
-                if (matcher->keySeqs[i] != NULL)
-                    xmlFree(matcher->keySeqs[i]);
-            xmlFree(matcher->keySeqs);
-        }
-        if (matcher->targets != NULL) {
-            if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
-                int i;
-                xmlSchemaPSVIIDCNodePtr idcNode;
-                /*
-                * Node-table items for keyrefs are not stored globally
-                * to the validation context, since they are not bubbled.
-                * We need to free them here.
-                */
-                for (i = 0; i < matcher->targets->nbItems; i++) {
-                    idcNode =
-                        (xmlSchemaPSVIIDCNodePtr) matcher->targets->items[i];
-                    xmlFree(idcNode->keys);
-                    xmlFree(idcNode);
-                }
-            }
-            xmlSchemaItemListFree(matcher->targets);
-        }
-        xmlFree(matcher);
-        matcher = next;
-    }
-}
-
-/**
- * xmlSchemaIDCReleaseMatcherList:
- * @vctxt: the WXS validation context
- * @matcher: the first IDC matcher in the list
- *
- * Caches a list of IDC matchers for reuse.
- */
-static void
-xmlSchemaIDCReleaseMatcherList(xmlSchemaValidCtxtPtr vctxt,
-                               xmlSchemaIDCMatcherPtr matcher)
-{
-    xmlSchemaIDCMatcherPtr next;
-
-    while (matcher != NULL) {
-        next = matcher->next;
-        if (matcher->keySeqs != NULL) {
-            int i;
-            /*
-            * Don't free the array, but only the content.
-            */
-            for (i = 0; i < matcher->sizeKeySeqs; i++)
-                if (matcher->keySeqs[i] != NULL) {
-                    xmlFree(matcher->keySeqs[i]);
-                    matcher->keySeqs[i] = NULL;
-                }
-        }
-        if (matcher->targets) {
-            if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
-                int i;
-                xmlSchemaPSVIIDCNodePtr idcNode;
-                /*
-                * Node-table items for keyrefs are not stored globally
-                * to the validation context, since they are not bubbled.
-                * We need to free them here.
-                */
-                for (i = 0; i < matcher->targets->nbItems; i++) {
-                    idcNode =
-                        (xmlSchemaPSVIIDCNodePtr) matcher->targets->items[i];
-                    xmlFree(idcNode->keys);
-                    xmlFree(idcNode);
-                }
-            }
-            xmlSchemaItemListFree(matcher->targets);
-            matcher->targets = NULL;
-        }
-        matcher->next = NULL;
-        /*
-        * Cache the matcher.
-        */
-        if (vctxt->idcMatcherCache != NULL)
-            matcher->nextCached = vctxt->idcMatcherCache;
-        vctxt->idcMatcherCache = matcher;
-
-        matcher = next;
-    }
-}
-
-/**
- * xmlSchemaIDCAddStateObject:
- * @vctxt: the WXS validation context
- * @matcher: the IDC matcher
- * @sel: the XPath information
- * @parent: the parent "selector" state object if any
- * @type: "selector" or "field"
- *
- * Creates/reuses and activates state objects for the given
- * XPath information; if the XPath expression consists of unions,
- * multiple state objects are created for every unioned expression.
- *
- * Returns 0 on success and -1 on internal errors.
- */
-static int
-xmlSchemaIDCAddStateObject(xmlSchemaValidCtxtPtr vctxt,
-                        xmlSchemaIDCMatcherPtr matcher,
-                        xmlSchemaIDCSelectPtr sel,
-                        int type)
-{
-    xmlSchemaIDCStateObjPtr sto;
-
-    /*
-    * Reuse the state objects from the pool.
-    */
-    if (vctxt->xpathStatePool != NULL) {
-        sto = vctxt->xpathStatePool;
-        vctxt->xpathStatePool = sto->next;
-        sto->next = NULL;
-    } else {
-        /*
-        * Create a new state object.
-        */
-        sto = (xmlSchemaIDCStateObjPtr) xmlMalloc(sizeof(xmlSchemaIDCStateObj));
-        if (sto == NULL) {
-            xmlSchemaVErrMemory(NULL,
-                "allocating an IDC state object", NULL);
-            return (-1);
-        }
-        memset(sto, 0, sizeof(xmlSchemaIDCStateObj));
-    }
-    /*
-    * Add to global list.
-    */
-    if (vctxt->xpathStates != NULL)
-        sto->next = vctxt->xpathStates;
-    vctxt->xpathStates = sto;
-
-    /*
-    * Free the old xpath validation context.
-    */
-    if (sto->xpathCtxt != NULL)
-        xmlFreeStreamCtxt((xmlStreamCtxtPtr) sto->xpathCtxt);
-
-    /*
-    * Create a new XPath (pattern) validation context.
-    */
-    sto->xpathCtxt = (void *) xmlPatternGetStreamCtxt(
-        (xmlPatternPtr) sel->xpathComp);
-    if (sto->xpathCtxt == NULL) {
-        VERROR_INT("xmlSchemaIDCAddStateObject",
-            "failed to create an XPath validation context");
-        return (-1);
-    }
-    sto->type = type;
-    sto->depth = vctxt->depth;
-    sto->matcher = matcher;
-    sto->sel = sel;
-    sto->nbHistory = 0;
-
-#ifdef DEBUG_IDC
-    xmlGenericError(xmlGenericErrorContext, "IDC:   STO push '%s'\n",
-        sto->sel->xpath);
-#endif
-    return (0);
-}
-
-/**
- * xmlSchemaXPathEvaluate:
- * @vctxt: the WXS validation context
- * @nodeType: the nodeType of the current node
- *
- * Evaluates all active XPath state objects.
- *
- * Returns the number of IC "field" state objects which resolved to
- * this node, 0 if none resolved and -1 on internal errors.
- */
-static int
-xmlSchemaXPathEvaluate(xmlSchemaValidCtxtPtr vctxt,
-                       xmlElementType nodeType)
-{
-    xmlSchemaIDCStateObjPtr sto, head = NULL, first;
-    int res, resolved = 0, depth = vctxt->depth;
-
-    if (vctxt->xpathStates == NULL)
-        return (0);
-
-    if (nodeType == XML_ATTRIBUTE_NODE)
-        depth++;
-#ifdef DEBUG_IDC
-    {
-        xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext,
-            "IDC: EVAL on %s, depth %d, type %d\n",
-            xmlSchemaFormatQName(&str, vctxt->inode->nsName,
-                vctxt->inode->localName), depth, nodeType);
-        FREE_AND_NULL(str)
-    }
-#endif
-    /*
-    * Process all active XPath state objects.
-    */
-    first = vctxt->xpathStates;
-    sto = first;
-    while (sto != head) {
-#ifdef DEBUG_IDC
-        if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR)
-            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] selector '%s'\n",
-                sto->matcher->aidc->def->name, sto->sel->xpath);
-        else
-            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] field '%s'\n",
-                sto->matcher->aidc->def->name, sto->sel->xpath);
-#endif
-        if (nodeType == XML_ELEMENT_NODE)
-            res = xmlStreamPush((xmlStreamCtxtPtr) sto->xpathCtxt,
-                vctxt->inode->localName, vctxt->inode->nsName);
-        else
-            res = xmlStreamPushAttr((xmlStreamCtxtPtr) sto->xpathCtxt,
-                vctxt->inode->localName, vctxt->inode->nsName);
-
-        if (res == -1) {
-            VERROR_INT("xmlSchemaXPathEvaluate",
-                "calling xmlStreamPush()");
-            return (-1);
-        }
-        if (res == 0)
-            goto next_sto;
-        /*
-        * Full match.
-        */
-#ifdef DEBUG_IDC
-        xmlGenericError(xmlGenericErrorContext, "IDC:     "
-            "MATCH\n");
-#endif
-        /*
-        * Register a match in the state object history.
-        */
-        if (sto->history == NULL) {
-            sto->history = (int *) xmlMalloc(5 * sizeof(int));
-            if (sto->history == NULL) {
-                xmlSchemaVErrMemory(NULL,
-                    "allocating the state object history", NULL);
-                return(-1);
-            }
-            sto->sizeHistory = 5;
-        } else if (sto->sizeHistory <= sto->nbHistory) {
-            sto->sizeHistory *= 2;
-            sto->history = (int *) xmlRealloc(sto->history,
-                sto->sizeHistory * sizeof(int));
-            if (sto->history == NULL) {
-                xmlSchemaVErrMemory(NULL,
-                    "re-allocating the state object history", NULL);
-                return(-1);
-            }
-        }
-        sto->history[sto->nbHistory++] = depth;
-
-#ifdef DEBUG_IDC
-        xmlGenericError(xmlGenericErrorContext, "IDC:       push match '%d'\n",
-            vctxt->depth);
-#endif
-
-        if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
-            xmlSchemaIDCSelectPtr sel;
-            /*
-            * Activate state objects for the IDC fields of
-            * the IDC selector.
-            */
-#ifdef DEBUG_IDC
-            xmlGenericError(xmlGenericErrorContext, "IDC:     "
-                "activating field states\n");
-#endif
-            sel = sto->matcher->aidc->def->fields;
-            while (sel != NULL) {
-                if (xmlSchemaIDCAddStateObject(vctxt, sto->matcher,
-                    sel, XPATH_STATE_OBJ_TYPE_IDC_FIELD) == -1)
-                    return (-1);
-                sel = sel->next;
-            }
-        } else if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_FIELD) {
-            /*
-            * An IDC key node was found by the IDC field.
-            */
-#ifdef DEBUG_IDC
-            xmlGenericError(xmlGenericErrorContext,
-                "IDC:     key found\n");
-#endif
-            /*
-            * Notify that the character value of this node is
-            * needed.
-            */
-            if (resolved == 0) {
-                if ((vctxt->inode->flags &
-                    XML_SCHEMA_NODE_INFO_VALUE_NEEDED) == 0)
-                vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_VALUE_NEEDED;
-            }
-            resolved++;
-        }
-next_sto:
-        if (sto->next == NULL) {
-            /*
-            * Evaluate field state objects created on this node as well.
-            */
-            head = first;
-            sto = vctxt->xpathStates;
-        } else
-            sto = sto->next;
-    }
-    return (resolved);
-}
-
-static const xmlChar *
-xmlSchemaFormatIDCKeySequence(xmlSchemaValidCtxtPtr vctxt,
-                              xmlChar **buf,
-                              xmlSchemaPSVIIDCKeyPtr *seq,
-                              int count)
-{
-    int i, res;
-    xmlChar *value = NULL;
-
-    *buf = xmlStrdup(BAD_CAST "[");
-    for (i = 0; i < count; i++) {
-        *buf = xmlStrcat(*buf, BAD_CAST "'");
-        res = xmlSchemaGetCanonValueWhtspExt(seq[i]->val,
-            xmlSchemaGetWhiteSpaceFacetValue(seq[i]->type),
-            &value);
-        if (res == 0)
-            *buf = xmlStrcat(*buf, BAD_CAST value);
-        else {
-            VERROR_INT("xmlSchemaFormatIDCKeySequence",
-                "failed to compute a canonical value");
-            *buf = xmlStrcat(*buf, BAD_CAST "???");
-        }
-        if (i < count -1)
-            *buf = xmlStrcat(*buf, BAD_CAST "', ");
-        else
-            *buf = xmlStrcat(*buf, BAD_CAST "'");
-        if (value != NULL) {
-            xmlFree(value);
-            value = NULL;
-        }
-    }
-    *buf = xmlStrcat(*buf, BAD_CAST "]");
-
-    return (BAD_CAST *buf);
-}
-
-/**
- * xmlSchemaXPathPop:
- * @vctxt: the WXS validation context
- *
- * Pops all XPath states.
- *
- * Returns 0 on success and -1 on internal errors.
- */
-static int
-xmlSchemaXPathPop(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaIDCStateObjPtr sto;
-    int res;
-
-    if (vctxt->xpathStates == NULL)
-        return(0);
-    sto = vctxt->xpathStates;
-    do {
-        res = xmlStreamPop((xmlStreamCtxtPtr) sto->xpathCtxt);
-        if (res == -1)
-            return (-1);
-        sto = sto->next;
-    } while (sto != NULL);
-    return(0);
-}
-
-/**
- * xmlSchemaXPathProcessHistory:
- * @vctxt: the WXS validation context
- * @type: the simple/complex type of the current node if any at all
- * @val: the precompiled value
- *
- * Processes and pops the history items of the IDC state objects.
- * IDC key-sequences are validated/created on IDC bindings.
- *
- * Returns 0 on success and -1 on internal errors.
- */
-static int
-xmlSchemaXPathProcessHistory(xmlSchemaValidCtxtPtr vctxt,
-                             int depth)
-{
-    xmlSchemaIDCStateObjPtr sto, nextsto;
-    int res, matchDepth;
-    xmlSchemaPSVIIDCKeyPtr key = NULL;
-    xmlSchemaTypePtr type = vctxt->inode->typeDef, simpleType = NULL;
-
-    if (vctxt->xpathStates == NULL)
-        return (0);
-    sto = vctxt->xpathStates;
-
-#ifdef DEBUG_IDC
-    {
-        xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext,
-            "IDC: BACK on %s, depth %d\n",
-            xmlSchemaFormatQName(&str, vctxt->inode->nsName,
-                vctxt->inode->localName), vctxt->depth);
-        FREE_AND_NULL(str)
-    }
-#endif
-    /*
-    * Evaluate the state objects.
-    */
-    while (sto != NULL) {
-        res = xmlStreamPop((xmlStreamCtxtPtr) sto->xpathCtxt);
-        if (res == -1) {
-            VERROR_INT("xmlSchemaXPathProcessHistory",
-                "calling xmlStreamPop()");
-            return (-1);
-        }
-#ifdef DEBUG_IDC
-        xmlGenericError(xmlGenericErrorContext, "IDC:   stream pop '%s'\n",
-            sto->sel->xpath);
-#endif
-        if (sto->nbHistory == 0)
-            goto deregister_check;
-
-        matchDepth = sto->history[sto->nbHistory -1];
-
-        /*
-        * Only matches at the current depth are of interest.
-        */
-        if (matchDepth != depth) {
-            sto = sto->next;
-            continue;
-        }
-        if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_FIELD) {
-            /*
-            * NOTE: According to
-            *   http://www.w3.org/Bugs/Public/show_bug.cgi?id=2198
-            *   ... the simple-content of complex types is also allowed.
-            */
-
-            if (WXS_IS_COMPLEX(type)) {
-                if (WXS_HAS_SIMPLE_CONTENT(type)) {
-                    /*
-                    * Sanity check for complex types with simple content.
-                    */
-                    simpleType = type->contentTypeDef;
-                    if (simpleType == NULL) {
-                        VERROR_INT("xmlSchemaXPathProcessHistory",
-                            "field resolves to a CT with simple content "
-                            "but the CT is missing the ST definition");
-                        return (-1);
-                    }
-                } else
-                    simpleType = NULL;
-            } else
-                simpleType = type;
-            if (simpleType == NULL) {
-                xmlChar *str = NULL;
-
-                /*
-                * Not qualified if the field resolves to a node of non
-                * simple type.
-                */
-                xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_IDC, NULL,
-                    WXS_BASIC_CAST sto->matcher->aidc->def,
-                    "The XPath '%s' of a field of %s does evaluate to a node of "
-                    "non-simple type",
-                    sto->sel->xpath,
-                    xmlSchemaGetIDCDesignation(&str, sto->matcher->aidc->def));
-                FREE_AND_NULL(str);
-                sto->nbHistory--;
-                goto deregister_check;
-            }
-
-            if ((key == NULL) && (vctxt->inode->val == NULL)) {
-                /*
-                * Failed to provide the normalized value; maybe
-                * the value was invalid.
-                */
-                VERROR(XML_SCHEMAV_CVC_IDC,
-                    WXS_BASIC_CAST sto->matcher->aidc->def,
-                    "Warning: No precomputed value available, the value "
-                    "was either invalid or something strange happend");
-                sto->nbHistory--;
-                goto deregister_check;
-            } else {
-                xmlSchemaIDCMatcherPtr matcher = sto->matcher;
-                xmlSchemaPSVIIDCKeyPtr *keySeq;
-                int pos, idx;
-
-                /*
-                * The key will be anchored on the matcher's list of
-                * key-sequences. The position in this list is determined
-                * by the target node's depth relative to the matcher's
-                * depth of creation (i.e. the depth of the scope element).
-                *
-                * Element        Depth    Pos   List-entries
-                * <scope>          0              NULL
-                *   <bar>          1              NULL
-                *     <target/>    2       2      target
-                *   <bar>
-                * </scope>
-                *
-                * The size of the list is only dependant on the depth of
-                * the tree.
-                * An entry will be NULLed in selector_leave, i.e. when
-                * we hit the target's
-                */
-                pos = sto->depth - matcher->depth;
-                idx = sto->sel->index;
-
-                /*
-                * Create/grow the array of key-sequences.
-                */
-                if (matcher->keySeqs == NULL) {
-                    if (pos > 9)
-                        matcher->sizeKeySeqs = pos * 2;
-                    else
-                        matcher->sizeKeySeqs = 10;
-                    matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
-                        xmlMalloc(matcher->sizeKeySeqs *
-                        sizeof(xmlSchemaPSVIIDCKeyPtr *));
-                    if (matcher->keySeqs == NULL) {
-                        xmlSchemaVErrMemory(NULL,
-                            "allocating an array of key-sequences",
-                            NULL);
-                        return(-1);
-                    }
-                    memset(matcher->keySeqs, 0,
-                        matcher->sizeKeySeqs *
-                        sizeof(xmlSchemaPSVIIDCKeyPtr *));
-                } else if (pos >= matcher->sizeKeySeqs) {
-                    int i = matcher->sizeKeySeqs;
-
-                    matcher->sizeKeySeqs *= 2;
-                    matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
-                        xmlRealloc(matcher->keySeqs,
-                        matcher->sizeKeySeqs *
-                        sizeof(xmlSchemaPSVIIDCKeyPtr *));
-                    if (matcher->keySeqs == NULL) {
-                        xmlSchemaVErrMemory(NULL,
-                            "reallocating an array of key-sequences",
-                            NULL);
-                        return (-1);
-                    }
-                    /*
-                    * The array needs to be NULLed.
-                    * TODO: Use memset?
-                    */
-                    for (; i < matcher->sizeKeySeqs; i++)
-                        matcher->keySeqs[i] = NULL;
-                }
-
-                /*
-                * Get/create the key-sequence.
-                */
-                keySeq = matcher->keySeqs[pos];
-                if (keySeq == NULL) {
-                    goto create_sequence;
-                } else if (keySeq[idx] != NULL) {
-                    xmlChar *str = NULL;
-                    /*
-                    * cvc-identity-constraint:
-                    * 3 For each node in the `target node set` all
-                    * of the {fields}, with that node as the context
-                    * node, evaluate to either an empty node-set or
-                    * a node-set with exactly one member, which must
-                    * have a simple type.
-                    *
-                    * The key was already set; report an error.
-                    */
-                    xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                        XML_SCHEMAV_CVC_IDC, NULL,
-                        WXS_BASIC_CAST matcher->aidc->def,
-                        "The XPath '%s' of a field of %s evaluates to a "
-                        "node-set with more than one member",
-                        sto->sel->xpath,
-                        xmlSchemaGetIDCDesignation(&str, matcher->aidc->def));
-                    FREE_AND_NULL(str);
-                    sto->nbHistory--;
-                    goto deregister_check;
-                } else
-                    goto create_key;
-
-create_sequence:
-                /*
-                * Create a key-sequence.
-                */
-                keySeq = (xmlSchemaPSVIIDCKeyPtr *) xmlMalloc(
-                    matcher->aidc->def->nbFields *
-                    sizeof(xmlSchemaPSVIIDCKeyPtr));
-                if (keySeq == NULL) {
-                    xmlSchemaVErrMemory(NULL,
-                        "allocating an IDC key-sequence", NULL);
-                    return(-1);
-                }
-                memset(keySeq, 0, matcher->aidc->def->nbFields *
-                    sizeof(xmlSchemaPSVIIDCKeyPtr));
-                matcher->keySeqs[pos] = keySeq;
-create_key:
-                /*
-                * Create a key once per node only.
-                */
-                if (key == NULL) {
-                    key = (xmlSchemaPSVIIDCKeyPtr) xmlMalloc(
-                        sizeof(xmlSchemaPSVIIDCKey));
-                    if (key == NULL) {
-                        xmlSchemaVErrMemory(NULL,
-                            "allocating a IDC key", NULL);
-                        xmlFree(keySeq);
-                        matcher->keySeqs[pos] = NULL;
-                        return(-1);
-                    }
-                    /*
-                    * Consume the compiled value.
-                    */
-                    key->type = simpleType;
-                    key->val = vctxt->inode->val;
-                    vctxt->inode->val = NULL;
-                    /*
-                    * Store the key in a global list.
-                    */
-                    if (xmlSchemaIDCStoreKey(vctxt, key) == -1) {
-                        xmlSchemaIDCFreeKey(key);
-                        return (-1);
-                    }
-                }
-                keySeq[idx] = key;
-            }
-        } else if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
-
-            xmlSchemaPSVIIDCKeyPtr **keySeq = NULL;
-            /* xmlSchemaPSVIIDCBindingPtr bind; */
-            xmlSchemaPSVIIDCNodePtr ntItem;
-            xmlSchemaIDCMatcherPtr matcher;
-            xmlSchemaIDCPtr idc;
-            xmlSchemaItemListPtr targets;
-            int pos, i, j, nbKeys;
-            /*
-            * Here we have the following scenario:
-            * An IDC 'selector' state object resolved to a target node,
-            * during the time this target node was in the
-            * ancestor-or-self axis, the 'field' state object(s) looked
-            * out for matching nodes to create a key-sequence for this
-            * target node. Now we are back to this target node and need
-            * to put the key-sequence, together with the target node
-            * itself, into the node-table of the corresponding IDC
-            * binding.
-            */
-            matcher = sto->matcher;
-            idc = matcher->aidc->def;
-            nbKeys = idc->nbFields;
-            pos = depth - matcher->depth;
-            /*
-            * Check if the matcher has any key-sequences at all, plus
-            * if it has a key-sequence for the current target node.
-            */
-            if ((matcher->keySeqs == NULL) ||
-                (matcher->sizeKeySeqs <= pos)) {
-                if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
-                    goto selector_key_error;
-                else
-                    goto selector_leave;
-            }
-
-            keySeq = &(matcher->keySeqs[pos]);
-            if (*keySeq == NULL) {
-                if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
-                    goto selector_key_error;
-                else
-                    goto selector_leave;
-            }
-
-            for (i = 0; i < nbKeys; i++) {
-                if ((*keySeq)[i] == NULL) {
-                    /*
-                    * Not qualified, if not all fields did resolve.
-                    */
-                    if (idc->type == XML_SCHEMA_TYPE_IDC_KEY) {
-                        /*
-                        * All fields of a "key" IDC must resolve.
-                        */
-                        goto selector_key_error;
-                    }
-                    goto selector_leave;
-                }
-            }
-            /*
-            * All fields did resolve.
-            */
-
-            /*
-            * 4.1 If the {identity-constraint category} is unique(/key),
-            * then no two members of the `qualified node set` have
-            * `key-sequences` whose members are pairwise equal, as
-            * defined by Equal in [XML Schemas: Datatypes].
-            *
-            * Get the IDC binding from the matcher and check for
-            * duplicate key-sequences.
-            */
-#if 0
-            bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
-#endif
-            targets = xmlSchemaIDCAcquireTargetList(vctxt, matcher);
-            if ((idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) &&
-                (targets->nbItems != 0)) {
-                xmlSchemaPSVIIDCKeyPtr ckey, bkey, *bkeySeq;
-
-                i = 0;
-                res = 0;
-                /*
-                * Compare the key-sequences, key by key.
-                */
-                do {
-                    bkeySeq =
-                        ((xmlSchemaPSVIIDCNodePtr) targets->items[i])->keys;
-                    for (j = 0; j < nbKeys; j++) {
-                        ckey = (*keySeq)[j];
-                        bkey = bkeySeq[j];
-                        res = xmlSchemaAreValuesEqual(ckey->val, bkey->val);
-                        if (res == -1) {
-                            return (-1);
-                        } else if (res == 0) {
-                            /*
-                            * One of the keys differs, so the key-sequence
-                            * won't be equal; get out.
-                            */
-                            break;
-                        }
-                    }
-                    if (res == 1) {
-                        /*
-                        * Duplicate key-sequence found.
-                        */
-                        break;
-                    }
-                    i++;
-                } while (i < targets->nbItems);
-                if (i != targets->nbItems) {
-                    xmlChar *str = NULL, *strB = NULL;
-                    /*
-                    * TODO: Try to report the key-sequence.
-                    */
-                    xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                        XML_SCHEMAV_CVC_IDC, NULL,
-                        WXS_BASIC_CAST idc,
-                        "Duplicate key-sequence %s in %s",
-                        xmlSchemaFormatIDCKeySequence(vctxt, &str,
-                            (*keySeq), nbKeys),
-                        xmlSchemaGetIDCDesignation(&strB, idc));
-                    FREE_AND_NULL(str);
-                    FREE_AND_NULL(strB);
-                    goto selector_leave;
-                }
-            }
-            /*
-            * Add a node-table item to the IDC binding.
-            */
-            ntItem = (xmlSchemaPSVIIDCNodePtr) xmlMalloc(
-                sizeof(xmlSchemaPSVIIDCNode));
-            if (ntItem == NULL) {
-                xmlSchemaVErrMemory(NULL,
-                    "allocating an IDC node-table item", NULL);
-                xmlFree(*keySeq);
-                *keySeq = NULL;
-                return(-1);
-            }
-            memset(ntItem, 0, sizeof(xmlSchemaPSVIIDCNode));
-
-            /*
-            * Store the node-table item in a global list.
-            */
-            if (idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) {
-                if (xmlSchemaIDCStoreNodeTableItem(vctxt, ntItem) == -1) {
-                    xmlFree(ntItem);
-                    xmlFree(*keySeq);
-                    *keySeq = NULL;
-                    return (-1);
-                }
-                ntItem->nodeQNameID = -1;
-            } else {
-                /*
-                * Save a cached QName for this node on the IDC node, to be
-                * able to report it, even if the node is not saved.
-                */
-                ntItem->nodeQNameID = xmlSchemaVAddNodeQName(vctxt,
-                    vctxt->inode->localName, vctxt->inode->nsName);
-                if (ntItem->nodeQNameID == -1) {
-                    xmlFree(ntItem);
-                    xmlFree(*keySeq);
-                    *keySeq = NULL;
-                    return (-1);
-                }
-            }
-            /*
-            * Init the node-table item: Save the node, position and
-            * consume the key-sequence.
-            */
-            ntItem->node = vctxt->node;
-            ntItem->nodeLine = vctxt->inode->nodeLine;
-            ntItem->keys = *keySeq;
-            *keySeq = NULL;
-#if 0
-            if (xmlSchemaIDCAppendNodeTableItem(bind, ntItem) == -1)
-#endif
-            if (xmlSchemaItemListAdd(targets, ntItem) == -1) {
-                if (idc->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
-                    /*
-                    * Free the item, since keyref items won't be
-                    * put on a global list.
-                    */
-                    xmlFree(ntItem->keys);
-                    xmlFree(ntItem);
-                }
-                return (-1);
-            }
-
-            goto selector_leave;
-selector_key_error:
-            {
-                xmlChar *str = NULL;
-                /*
-                * 4.2.1 (KEY) The `target node set` and the
-                * `qualified node set` are equal, that is, every
-                * member of the `target node set` is also a member
-                * of the `qualified node set` and vice versa.
-                */
-                xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_IDC, NULL,
-                    WXS_BASIC_CAST idc,
-                    "Not all fields of %s evaluate to a node",
-                    xmlSchemaGetIDCDesignation(&str, idc), NULL);
-                FREE_AND_NULL(str);
-            }
-selector_leave:
-            /*
-            * Free the key-sequence if not added to the IDC table.
-            */
-            if ((keySeq != NULL) && (*keySeq != NULL)) {
-                xmlFree(*keySeq);
-                *keySeq = NULL;
-            }
-        } /* if selector */
-
-        sto->nbHistory--;
-
-deregister_check:
-        /*
-        * Deregister state objects if they reach the depth of creation.
-        */
-        if ((sto->nbHistory == 0) && (sto->depth == depth)) {
-#ifdef DEBUG_IDC
-            xmlGenericError(xmlGenericErrorContext, "IDC:   STO pop '%s'\n",
-                sto->sel->xpath);
-#endif
-            if (vctxt->xpathStates != sto) {
-                VERROR_INT("xmlSchemaXPathProcessHistory",
-                    "The state object to be removed is not the first "
-                    "in the list");
-            }
-            nextsto = sto->next;
-            /*
-            * Unlink from the list of active XPath state objects.
-            */
-            vctxt->xpathStates = sto->next;
-            sto->next = vctxt->xpathStatePool;
-            /*
-            * Link it to the pool of reusable state objects.
-            */
-            vctxt->xpathStatePool = sto;
-            sto = nextsto;
-        } else
-            sto = sto->next;
-    } /* while (sto != NULL) */
-    return (0);
-}
-
-/**
- * xmlSchemaIDCRegisterMatchers:
- * @vctxt: the WXS validation context
- * @elemDecl: the element declaration
- *
- * Creates helper objects to evaluate IDC selectors/fields
- * successively.
- *
- * Returns 0 if OK and -1 on internal errors.
- */
-static int
-xmlSchemaIDCRegisterMatchers(xmlSchemaValidCtxtPtr vctxt,
-                             xmlSchemaElementPtr elemDecl)
-{
-    xmlSchemaIDCMatcherPtr matcher, last = NULL;
-    xmlSchemaIDCPtr idc, refIdc;
-    xmlSchemaIDCAugPtr aidc;
-
-    idc = (xmlSchemaIDCPtr) elemDecl->idcs;
-    if (idc == NULL)
-        return (0);
-
-#ifdef DEBUG_IDC
-    {
-        xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext,
-            "IDC: REGISTER on %s, depth %d\n",
-            (char *) xmlSchemaFormatQName(&str, vctxt->inode->nsName,
-                vctxt->inode->localName), vctxt->depth);
-        FREE_AND_NULL(str)
-    }
-#endif
-    if (vctxt->inode->idcMatchers != NULL) {
-        VERROR_INT("xmlSchemaIDCRegisterMatchers",
-            "The chain of IDC matchers is expected to be empty");
-        return (-1);
-    }
-    do {
-        if (idc->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
-            /*
-            * Since IDCs bubbles are expensive we need to know the
-            * depth at which the bubbles should stop; this will be
-            * the depth of the top-most keyref IDC. If no keyref
-            * references a key/unique IDC, the keyrefDepth will
-            * be -1, indicating that no bubbles are needed.
-            */
-            refIdc = (xmlSchemaIDCPtr) idc->ref->item;
-            if (refIdc != NULL) {
-                /*
-                * Remember that we have keyrefs on this node.
-                */
-                vctxt->inode->hasKeyrefs = 1;
-                /*
-                * Lookup the referenced augmented IDC info.
-                */
-                aidc = vctxt->aidcs;
-                while (aidc != NULL) {
-                    if (aidc->def == refIdc)
-                        break;
-                    aidc = aidc->next;
-                }
-                if (aidc == NULL) {
-                    VERROR_INT("xmlSchemaIDCRegisterMatchers",
-                        "Could not find an augmented IDC item for an IDC "
-                        "definition");
-                    return (-1);
-                }
-                if ((aidc->keyrefDepth == -1) ||
-                    (vctxt->depth < aidc->keyrefDepth))
-                    aidc->keyrefDepth = vctxt->depth;
-            }
-        }
-        /*
-        * Lookup the augmented IDC item for the IDC definition.
-        */
-        aidc = vctxt->aidcs;
-        while (aidc != NULL) {
-            if (aidc->def == idc)
-                break;
-            aidc = aidc->next;
-        }
-        if (aidc == NULL) {
-            VERROR_INT("xmlSchemaIDCRegisterMatchers",
-                "Could not find an augmented IDC item for an IDC definition");
-            return (-1);
-        }
-        /*
-        * Create an IDC matcher for every IDC definition.
-        */
-        if (vctxt->idcMatcherCache != NULL) {
-            /*
-            * Reuse a cached matcher.
-            */
-            matcher = vctxt->idcMatcherCache;
-            vctxt->idcMatcherCache = matcher->nextCached;
-            matcher->nextCached = NULL;
-        } else {
-            matcher = (xmlSchemaIDCMatcherPtr)
-                xmlMalloc(sizeof(xmlSchemaIDCMatcher));
-            if (matcher == NULL) {
-                xmlSchemaVErrMemory(vctxt,
-                    "allocating an IDC matcher", NULL);
-                return (-1);
-            }
-            memset(matcher, 0, sizeof(xmlSchemaIDCMatcher));
-        }
-        if (last == NULL)
-            vctxt->inode->idcMatchers = matcher;
-        else
-            last->next = matcher;
-        last = matcher;
-
-        matcher->type = IDC_MATCHER;
-        matcher->depth = vctxt->depth;
-        matcher->aidc = aidc;
-        matcher->idcType = aidc->def->type;
-#ifdef DEBUG_IDC
-        xmlGenericError(xmlGenericErrorContext, "IDC:   register matcher\n");
-#endif
-        /*
-        * Init the automaton state object.
-        */
-        if (xmlSchemaIDCAddStateObject(vctxt, matcher,
-            idc->selector, XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) == -1)
-            return (-1);
-
-        idc = idc->next;
-    } while (idc != NULL);
-    return (0);
-}
-
-static int
-xmlSchemaIDCFillNodeTables(xmlSchemaValidCtxtPtr vctxt,
-                           xmlSchemaNodeInfoPtr ielem)
-{
-    xmlSchemaPSVIIDCBindingPtr bind;
-    int res, i, j, k, nbTargets, nbFields, nbDupls, nbNodeTable;
-    xmlSchemaPSVIIDCKeyPtr *keys, *ntkeys;
-    xmlSchemaPSVIIDCNodePtr *targets, *dupls;
-
-    xmlSchemaIDCMatcherPtr matcher = ielem->idcMatchers;
-    /* vctxt->createIDCNodeTables */
-    while (matcher != NULL) {
-        /*
-        * Skip keyref IDCs and empty IDC target-lists.
-        */
-        if ((matcher->aidc->def->type == XML_SCHEMA_TYPE_IDC_KEYREF) ||
-            WXS_ILIST_IS_EMPTY(matcher->targets))
-        {
-            matcher = matcher->next;
-            continue;
-        }
-        /*
-        * If we _want_ the IDC node-table to be created in any case
-        * then do so. Otherwise create them only if keyrefs need them.
-        */
-        if ((! vctxt->createIDCNodeTables) &&
-            ((matcher->aidc->keyrefDepth == -1) ||
-             (matcher->aidc->keyrefDepth > vctxt->depth)))
-        {
-            matcher = matcher->next;
-            continue;
-        }
-        /*
-        * Get/create the IDC binding on this element for the IDC definition.
-        */
-        bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
-
-        if (! WXS_ILIST_IS_EMPTY(bind->dupls)) {
-            dupls = (xmlSchemaPSVIIDCNodePtr *) bind->dupls->items;
-            nbDupls = bind->dupls->nbItems;
-        } else {
-            dupls = NULL;
-            nbDupls = 0;
-        }
-        if (bind->nodeTable != NULL) {
-            nbNodeTable = bind->nbNodes;
-        } else {
-            nbNodeTable = 0;
-        }
-
-        if ((nbNodeTable == 0) && (nbDupls == 0)) {
-            /*
-            * Transfer all IDC target-nodes to the IDC node-table.
-            */
-            bind->nodeTable =
-                (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
-            bind->sizeNodes = matcher->targets->sizeItems;
-            bind->nbNodes = matcher->targets->nbItems;
-
-            matcher->targets->items = NULL;
-            matcher->targets->sizeItems = 0;
-            matcher->targets->nbItems = 0;
-        } else {
-            /*
-            * Compare the key-sequences and add to the IDC node-table.
-            */
-            nbTargets = matcher->targets->nbItems;
-            targets = (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
-            nbFields = matcher->aidc->def->nbFields;
-            i = 0;
-            do {
-                keys = targets[i]->keys;
-                if (nbDupls) {
-                    /*
-                    * Search in already found duplicates first.
-                    */
-                    j = 0;
-                    do {
-                        if (nbFields == 1) {
-                            res = xmlSchemaAreValuesEqual(keys[0]->val,
-                                dupls[j]->keys[0]->val);
-                            if (res == -1)
-                                goto internal_error;
-                            if (res == 1) {
-                                /*
-                                * Equal key-sequence.
-                                */
-                                goto next_target;
-                            }
-                        } else {
-                            res = 0;
-                            ntkeys = dupls[j]->keys;
-                            for (k = 0; k < nbFields; k++) {
-                                res = xmlSchemaAreValuesEqual(keys[k]->val,
-                                    ntkeys[k]->val);
-                                if (res == -1)
-                                    goto internal_error;
-                                if (res == 0) {
-                                    /*
-                                    * One of the keys differs.
-                                    */
-                                    break;
-                                }
-                            }
-                            if (res == 1) {
-                                /*
-                                * Equal key-sequence found.
-                                */
-                                goto next_target;
-                            }
-                        }
-                        j++;
-                    } while (j < nbDupls);
-                }
-                if (nbNodeTable) {
-                    j = 0;
-                    do {
-                        if (nbFields == 1) {
-                            res = xmlSchemaAreValuesEqual(keys[0]->val,
-                                bind->nodeTable[j]->keys[0]->val);
-                            if (res == -1)
-                                goto internal_error;
-                            if (res == 0) {
-                                /*
-                                * The key-sequence differs.
-                                */
-                                goto next_node_table_entry;
-                            }
-                        } else {
-                            res = 0;
-                            ntkeys = bind->nodeTable[j]->keys;
-                            for (k = 0; k < nbFields; k++) {
-                                res = xmlSchemaAreValuesEqual(keys[k]->val,
-                                    ntkeys[k]->val);
-                                if (res == -1)
-                                    goto internal_error;
-                                if (res == 0) {
-                                    /*
-                                    * One of the keys differs.
-                                    */
-                                    goto next_node_table_entry;
-                                }
-                            }
-                        }
-                        /*
-                        * Add the duplicate to the list of duplicates.
-                        */
-                        if (bind->dupls == NULL) {
-                            bind->dupls = xmlSchemaItemListCreate();
-                            if (bind->dupls == NULL)
-                                goto internal_error;
-                        }
-                        if (xmlSchemaItemListAdd(bind->dupls, bind->nodeTable[j]) == -1)
-                            goto internal_error;
-                        /*
-                        * Remove the duplicate entry from the IDC node-table.
-                        */
-                        bind->nodeTable[j] = bind->nodeTable[bind->nbNodes -1];
-                        bind->nbNodes--;
-
-                        goto next_target;
-
-next_node_table_entry:
-                        j++;
-                    } while (j < nbNodeTable);
-                }
-                /*
-                * If everything is fine, then add the IDC target-node to
-                * the IDC node-table.
-                */
-                if (xmlSchemaIDCAppendNodeTableItem(bind, targets[i]) == -1)
-                    goto internal_error;
-
-next_target:
-                i++;
-            } while (i < nbTargets);
-        }
-        matcher = matcher->next;
-    }
-    return(0);
-
-internal_error:
-    return(-1);
-}
-
-/**
- * xmlSchemaBubbleIDCNodeTables:
- * @depth: the current tree depth
- *
- * Merges IDC bindings of an element at @depth into the corresponding IDC
- * bindings of its parent element. If a duplicate note-table entry is found,
- * both, the parent node-table entry and child entry are discarded from the
- * node-table of the parent.
- *
- * Returns 0 if OK and -1 on internal errors.
- */
-static int
-xmlSchemaBubbleIDCNodeTables(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaPSVIIDCBindingPtr bind; /* IDC bindings of the current node. */
-    xmlSchemaPSVIIDCBindingPtr *parTable, parBind = NULL; /* parent IDC bindings. */
-    xmlSchemaPSVIIDCNodePtr node, parNode = NULL, *dupls, *parNodes; /* node-table entries. */
-    xmlSchemaIDCAugPtr aidc;
-    int i, j, k, ret = 0, nbFields, oldNum, oldDupls;
-
-    bind = vctxt->inode->idcTable;
-    if (bind == NULL) {
-        /* Fine, no table, no bubbles. */
-        return (0);
-    }
-
-    parTable = &(vctxt->elemInfos[vctxt->depth -1]->idcTable);
-    /*
-    * Walk all bindings; create new or add to existing bindings.
-    * Remove duplicate key-sequences.
-    */
-    while (bind != NULL) {
-
-        if ((bind->nbNodes == 0) && WXS_ILIST_IS_EMPTY(bind->dupls))
-            goto next_binding;
-        /*
-        * Check if the key/unique IDC table needs to be bubbled.
-        */
-        if (! vctxt->createIDCNodeTables) {
-            aidc = vctxt->aidcs;
-            do {
-                if (aidc->def == bind->definition) {
-                    if ((aidc->keyrefDepth == -1) ||
-                        (aidc->keyrefDepth >= vctxt->depth)) {
-                        goto next_binding;
-                    }
-                    break;
-                }
-                aidc = aidc->next;
-            } while (aidc != NULL);
-        }
-
-        if (parTable != NULL)
-            parBind = *parTable;
-        /*
-        * Search a matching parent binding for the
-        * IDC definition.
-        */
-        while (parBind != NULL) {
-            if (parBind->definition == bind->definition)
-                break;
-            parBind = parBind->next;
-        }
-
-        if (parBind != NULL) {
-            /*
-            * Compare every node-table entry of the child node,
-            * i.e. the key-sequence within, ...
-            */
-            oldNum = parBind->nbNodes; /* Skip newly added items. */
-
-            if (! WXS_ILIST_IS_EMPTY(parBind->dupls)) {
-                oldDupls = parBind->dupls->nbItems;
-                dupls = (xmlSchemaPSVIIDCNodePtr *) parBind->dupls->items;
-            } else {
-                dupls = NULL;
-                oldDupls = 0;
-            }
-
-            parNodes = parBind->nodeTable;
-            nbFields = bind->definition->nbFields;
-
-            for (i = 0; i < bind->nbNodes; i++) {
-                node = bind->nodeTable[i];
-                if (node == NULL)
-                    continue;
-                /*
-                * ...with every key-sequence of the parent node, already
-                * evaluated to be a duplicate key-sequence.
-                */
-                if (oldDupls) {
-                    j = 0;
-                    while (j < oldDupls) {
-                        if (nbFields == 1) {
-                            ret = xmlSchemaAreValuesEqual(
-                                node->keys[0]->val,
-                                dupls[j]->keys[0]->val);
-                            if (ret == -1)
-                                goto internal_error;
-                            if (ret == 0) {
-                                j++;
-                                continue;
-                            }
-                        } else {
-                            parNode = dupls[j];
-                            for (k = 0; k < nbFields; k++) {
-                                ret = xmlSchemaAreValuesEqual(
-                                    node->keys[k]->val,
-                                    parNode->keys[k]->val);
-                                if (ret == -1)
-                                    goto internal_error;
-                                if (ret == 0)
-                                    break;
-                            }
-                        }
-                        if (ret == 1)
-                            /* Duplicate found. */
-                            break;
-                        j++;
-                    }
-                    if (j != oldDupls) {
-                        /* Duplicate found. Skip this entry. */
-                        continue;
-                    }
-                }
-                /*
-                * ... and with every key-sequence of the parent node.
-                */
-                if (oldNum) {
-                    j = 0;
-                    while (j < oldNum) {
-                        parNode = parNodes[j];
-                        if (nbFields == 1) {
-                            ret = xmlSchemaAreValuesEqual(
-                                node->keys[0]->val,
-                                parNode->keys[0]->val);
-                            if (ret == -1)
-                                goto internal_error;
-                            if (ret == 0) {
-                                j++;
-                                continue;
-                            }
-                        } else {
-                            for (k = 0; k < nbFields; k++) {
-                                ret = xmlSchemaAreValuesEqual(
-                                    node->keys[k]->val,
-                                    parNode->keys[k]->val);
-                                if (ret == -1)
-                                    goto internal_error;
-                                if (ret == 0)
-                                    break;
-                            }
-                        }
-                        if (ret == 1)
-                            /* Duplicate found. */
-                            break;
-                        j++;
-                    }
-                    if (j != oldNum) {
-                        /*
-                        * Handle duplicates. Move the duplicate in
-                        * the parent's node-table to the list of
-                        * duplicates.
-                        */
-                        oldNum--;
-                        parBind->nbNodes--;
-                        /*
-                        * Move last old item to pos of duplicate.
-                        */
-                        parNodes[j] = parNodes[oldNum];
-
-                        if (parBind->nbNodes != oldNum) {
-                            /*
-                            * If new items exist, move last new item to
-                            * last of old items.
-                            */
-                            parNodes[oldNum] =
-                                parNodes[parBind->nbNodes];
-                        }
-                        if (parBind->dupls == NULL) {
-                            parBind->dupls = xmlSchemaItemListCreate();
-                            if (parBind->dupls == NULL)
-                                goto internal_error;
-                        }
-                        xmlSchemaItemListAdd(parBind->dupls, parNode);
-                    } else {
-                        /*
-                        * Add the node-table entry (node and key-sequence) of
-                        * the child node to the node table of the parent node.
-                        */
-                        if (parBind->nodeTable == NULL) {
-                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
-                                xmlMalloc(10 * sizeof(xmlSchemaPSVIIDCNodePtr));
-                            if (parBind->nodeTable == NULL) {
-                                xmlSchemaVErrMemory(NULL,
-                                    "allocating IDC list of node-table items", NULL);
-                                goto internal_error;
-                            }
-                            parBind->sizeNodes = 1;
-                        } else if (parBind->nbNodes >= parBind->sizeNodes) {
-                            parBind->sizeNodes *= 2;
-                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
-                                xmlRealloc(parBind->nodeTable, parBind->sizeNodes *
-                                sizeof(xmlSchemaPSVIIDCNodePtr));
-                            if (parBind->nodeTable == NULL) {
-                                xmlSchemaVErrMemory(NULL,
-                                    "re-allocating IDC list of node-table items", NULL);
-                                goto internal_error;
-                            }
-                        }
-                        parNodes = parBind->nodeTable;
-                        /*
-                        * Append the new node-table entry to the 'new node-table
-                        * entries' section.
-                        */
-                        parNodes[parBind->nbNodes++] = node;
-                    }
-
-                }
-
-            }
-        } else {
-            /*
-            * No binding for the IDC was found: create a new one and
-            * copy all node-tables.
-            */
-            parBind = xmlSchemaIDCNewBinding(bind->definition);
-            if (parBind == NULL)
-                goto internal_error;
-
-            /*
-            * TODO: Hmm, how to optimize the initial number of
-            * allocated entries?
-            */
-            if (bind->nbNodes != 0) {
-                /*
-                * Add all IDC node-table entries.
-                */
-                if (! vctxt->psviExposeIDCNodeTables) {
-                    /*
-                    * Just move the entries.
-                    * NOTE: this is quite save here, since
-                    * all the keyref lookups have already been
-                    * performed.
-                    */
-                    parBind->nodeTable = bind->nodeTable;
-                    bind->nodeTable = NULL;
-                    parBind->sizeNodes = bind->sizeNodes;
-                    bind->sizeNodes = 0;
-                    parBind->nbNodes = bind->nbNodes;
-                    bind->nbNodes = 0;
-                } else {
-                    /*
-                    * Copy the entries.
-                    */
-                    parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
-                        xmlMalloc(bind->nbNodes *
-                        sizeof(xmlSchemaPSVIIDCNodePtr));
-                    if (parBind->nodeTable == NULL) {
-                        xmlSchemaVErrMemory(NULL,
-                            "allocating an array of IDC node-table "
-                            "items", NULL);
-                        xmlSchemaIDCFreeBinding(parBind);
-                        goto internal_error;
-                    }
-                    parBind->sizeNodes = bind->nbNodes;
-                    parBind->nbNodes = bind->nbNodes;
-                    memcpy(parBind->nodeTable, bind->nodeTable,
-                        bind->nbNodes * sizeof(xmlSchemaPSVIIDCNodePtr));
-                }
-            }
-            if (bind->dupls) {
-                /*
-                * Move the duplicates.
-                */
-                if (parBind->dupls != NULL)
-                    xmlSchemaItemListFree(parBind->dupls);
-                parBind->dupls = bind->dupls;
-                bind->dupls = NULL;
-            }
-            if (parTable != NULL) {
-                if (*parTable == NULL)
-                    *parTable = parBind;
-                else {
-                    parBind->next = *parTable;
-                    *parTable = parBind;
-                }
-            }
-        }
-
-next_binding:
-        bind = bind->next;
-    }
-    return (0);
-
-internal_error:
-    return(-1);
-}
-
-/**
- * xmlSchemaCheckCVCIDCKeyRef:
- * @vctxt: the WXS validation context
- * @elemDecl: the element declaration
- *
- * Check the cvc-idc-keyref constraints.
- */
-static int
-xmlSchemaCheckCVCIDCKeyRef(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaIDCMatcherPtr matcher;
-    xmlSchemaPSVIIDCBindingPtr bind;
-
-    matcher = vctxt->inode->idcMatchers;
-    /*
-    * Find a keyref.
-    */
-    while (matcher != NULL) {
-        if ((matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) &&
-            matcher->targets &&
-            matcher->targets->nbItems)
-        {
-            int i, j, k, res, nbFields, hasDupls;
-            xmlSchemaPSVIIDCKeyPtr *refKeys, *keys;
-            xmlSchemaPSVIIDCNodePtr refNode = NULL;
-
-            nbFields = matcher->aidc->def->nbFields;
-
-            /*
-            * Find the IDC node-table for the referenced IDC key/unique.
-            */
-            bind = vctxt->inode->idcTable;
-            while (bind != NULL) {
-                if ((xmlSchemaIDCPtr) matcher->aidc->def->ref->item ==
-                    bind->definition)
-                    break;
-                bind = bind->next;
-            }
-            hasDupls = (bind && bind->dupls && bind->dupls->nbItems) ? 1 : 0;
-            /*
-            * Search for a matching key-sequences.
-            */
-            for (i = 0; i < matcher->targets->nbItems; i++) {
-                res = 0;
-                refNode = matcher->targets->items[i];
-                if (bind != NULL) {
-                    refKeys = refNode->keys;
-                    for (j = 0; j < bind->nbNodes; j++) {
-                        keys = bind->nodeTable[j]->keys;
-                        for (k = 0; k < nbFields; k++) {
-                            res = xmlSchemaAreValuesEqual(keys[k]->val,
-                                refKeys[k]->val);
-                            if (res == 0)
-                                break;
-                            else if (res == -1) {
-                                return (-1);
-                            }
-                        }
-                        if (res == 1) {
-                            /*
-                            * Match found.
-                            */
-                            break;
-                        }
-                    }
-                    if ((res == 0) && hasDupls) {
-                        /*
-                        * Search in duplicates
-                        */
-                        for (j = 0; j < bind->dupls->nbItems; j++) {
-                            keys = ((xmlSchemaPSVIIDCNodePtr)
-                                bind->dupls->items[j])->keys;
-                            for (k = 0; k < nbFields; k++) {
-                                res = xmlSchemaAreValuesEqual(keys[k]->val,
-                                    refKeys[k]->val);
-                                if (res == 0)
-                                    break;
-                                else if (res == -1) {
-                                    return (-1);
-                                }
-                            }
-                            if (res == 1) {
-                                /*
-                                * Match in duplicates found.
-                                */
-                                xmlChar *str = NULL, *strB = NULL;
-                                xmlSchemaKeyrefErr(vctxt,
-                                    XML_SCHEMAV_CVC_IDC, refNode,
-                                    (xmlSchemaTypePtr) matcher->aidc->def,
-                                    "More than one match found for "
-                                    "key-sequence %s of keyref '%s'",
-                                    xmlSchemaFormatIDCKeySequence(vctxt, &str,
-                                        refNode->keys, nbFields),
-                                    xmlSchemaGetComponentQName(&strB,
-                                        matcher->aidc->def));
-                                FREE_AND_NULL(str);
-                                FREE_AND_NULL(strB);
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                if (res == 0) {
-                    xmlChar *str = NULL, *strB = NULL;
-                    xmlSchemaKeyrefErr(vctxt,
-                        XML_SCHEMAV_CVC_IDC, refNode,
-                        (xmlSchemaTypePtr) matcher->aidc->def,
-                        "No match found for key-sequence %s of keyref '%s'",
-                        xmlSchemaFormatIDCKeySequence(vctxt, &str,
-                            refNode->keys, nbFields),
-                        xmlSchemaGetComponentQName(&strB, matcher->aidc->def));
-                    FREE_AND_NULL(str);
-                    FREE_AND_NULL(strB);
-                }
-            }
-        }
-        matcher = matcher->next;
-    }
-    /* TODO: Return an error if any error encountered. */
-    return (0);
-}
-
-/************************************************************************
- *                                                                      *
- *                      XML Reader validation code                      *
- *                                                                      *
- ************************************************************************/
-
-static xmlSchemaAttrInfoPtr
-xmlSchemaGetFreshAttrInfo(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaAttrInfoPtr iattr;
-    /*
-    * Grow/create list of attribute infos.
-    */
-    if (vctxt->attrInfos == NULL) {
-        vctxt->attrInfos = (xmlSchemaAttrInfoPtr *)
-            xmlMalloc(sizeof(xmlSchemaAttrInfoPtr));
-        vctxt->sizeAttrInfos = 1;
-        if (vctxt->attrInfos == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "allocating attribute info list", NULL);
-            return (NULL);
-        }
-    } else if (vctxt->sizeAttrInfos <= vctxt->nbAttrInfos) {
-        vctxt->sizeAttrInfos++;
-        vctxt->attrInfos = (xmlSchemaAttrInfoPtr *)
-            xmlRealloc(vctxt->attrInfos,
-                vctxt->sizeAttrInfos * sizeof(xmlSchemaAttrInfoPtr));
-        if (vctxt->attrInfos == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "re-allocating attribute info list", NULL);
-            return (NULL);
-        }
-    } else {
-        iattr = vctxt->attrInfos[vctxt->nbAttrInfos++];
-        if (iattr->localName != NULL) {
-            VERROR_INT("xmlSchemaGetFreshAttrInfo",
-                "attr info not cleared");
-            return (NULL);
-        }
-        iattr->nodeType = XML_ATTRIBUTE_NODE;
-        return (iattr);
-    }
-    /*
-    * Create an attribute info.
-    */
-    iattr = (xmlSchemaAttrInfoPtr)
-        xmlMalloc(sizeof(xmlSchemaAttrInfo));
-    if (iattr == NULL) {
-        xmlSchemaVErrMemory(vctxt, "creating new attribute info", NULL);
-        return (NULL);
-    }
-    memset(iattr, 0, sizeof(xmlSchemaAttrInfo));
-    iattr->nodeType = XML_ATTRIBUTE_NODE;
-    vctxt->attrInfos[vctxt->nbAttrInfos++] = iattr;
-
-    return (iattr);
-}
-
-static int
-xmlSchemaValidatorPushAttribute(xmlSchemaValidCtxtPtr vctxt,
-                        xmlNodePtr attrNode,
-                        int nodeLine,
-                        const xmlChar *localName,
-                        const xmlChar *nsName,
-                        int ownedNames,
-                        xmlChar *value,
-                        int ownedValue)
-{
-    xmlSchemaAttrInfoPtr attr;
-
-    attr = xmlSchemaGetFreshAttrInfo(vctxt);
-    if (attr == NULL) {
-        VERROR_INT("xmlSchemaPushAttribute",
-            "calling xmlSchemaGetFreshAttrInfo()");
-        return (-1);
-    }
-    attr->node = attrNode;
-    attr->nodeLine = nodeLine;
-    attr->state = XML_SCHEMAS_ATTR_UNKNOWN;
-    attr->localName = localName;
-    attr->nsName = nsName;
-    if (ownedNames)
-        attr->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
-    /*
-    * Evaluate if it's an XSI attribute.
-    */
-    if (nsName != NULL) {
-        if (xmlStrEqual(localName, BAD_CAST "nil")) {
-            if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
-                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NIL;
-            }
-        } else if (xmlStrEqual(localName, BAD_CAST "type")) {
-            if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
-                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_TYPE;
-            }
-        } else if (xmlStrEqual(localName, BAD_CAST "schemaLocation")) {
-            if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
-                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC;
-            }
-        } else if (xmlStrEqual(localName, BAD_CAST "noNamespaceSchemaLocation")) {
-            if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
-                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC;
-            }
-        } else if (xmlStrEqual(attr->nsName, xmlNamespaceNs)) {
-            attr->metaType = XML_SCHEMA_ATTR_INFO_META_XMLNS;
-        }
-    }
-    attr->value = value;
-    if (ownedValue)
-        attr->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
-    if (attr->metaType != 0)
-        attr->state = XML_SCHEMAS_ATTR_META;
-    return (0);
-}
-
-/**
- * xmlSchemaClearElemInfo:
- * @vctxt: the WXS validation context
- * @ielem: the element information item
- */
-static void
-xmlSchemaClearElemInfo(xmlSchemaValidCtxtPtr vctxt,
-                       xmlSchemaNodeInfoPtr ielem)
-{
-    ielem->hasKeyrefs = 0;
-    ielem->appliedXPath = 0;
-    if (ielem->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES) {
-        FREE_AND_NULL(ielem->localName);
-        FREE_AND_NULL(ielem->nsName);
-    } else {
-        ielem->localName = NULL;
-        ielem->nsName = NULL;
-    }
-    if (ielem->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
-        FREE_AND_NULL(ielem->value);
-    } else {
-        ielem->value = NULL;
-    }
-    if (ielem->val != NULL) {
-        /*
-        * PSVI TODO: Be careful not to free it when the value is
-        * exposed via PSVI.
-        */
-        xmlSchemaFreeValue(ielem->val);
-        ielem->val = NULL;
-    }
-    if (ielem->idcMatchers != NULL) {
-        /*
-        * REVISIT OPTIMIZE TODO: Use a pool of IDC matchers.
-        *   Does it work?
-        */
-        xmlSchemaIDCReleaseMatcherList(vctxt, ielem->idcMatchers);
-#if 0
-        xmlSchemaIDCFreeMatcherList(ielem->idcMatchers);
-#endif
-        ielem->idcMatchers = NULL;
-    }
-    if (ielem->idcTable != NULL) {
-        /*
-        * OPTIMIZE TODO: Use a pool of IDC tables??.
-        */
-        xmlSchemaIDCFreeIDCTable(ielem->idcTable);
-        ielem->idcTable = NULL;
-    }
-    if (ielem->regexCtxt != NULL) {
-        xmlRegFreeExecCtxt(ielem->regexCtxt);
-        ielem->regexCtxt = NULL;
-    }
-    if (ielem->nsBindings != NULL) {
-        xmlFree((xmlChar **)ielem->nsBindings);
-        ielem->nsBindings = NULL;
-        ielem->nbNsBindings = 0;
-        ielem->sizeNsBindings = 0;
-    }
-}
-
-/**
- * xmlSchemaGetFreshElemInfo:
- * @vctxt: the schema validation context
- *
- * Creates/reuses and initializes the element info item for
- * the currect tree depth.
- *
- * Returns the element info item or NULL on API or internal errors.
- */
-static xmlSchemaNodeInfoPtr
-xmlSchemaGetFreshElemInfo(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaNodeInfoPtr info = NULL;
-
-    if (vctxt->depth > vctxt->sizeElemInfos) {
-        VERROR_INT("xmlSchemaGetFreshElemInfo",
-            "inconsistent depth encountered");
-        return (NULL);
-    }
-    if (vctxt->elemInfos == NULL) {
-        vctxt->elemInfos = (xmlSchemaNodeInfoPtr *)
-            xmlMalloc(10 * sizeof(xmlSchemaNodeInfoPtr));
-        if (vctxt->elemInfos == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "allocating the element info array", NULL);
-            return (NULL);
-        }
-        memset(vctxt->elemInfos, 0, 10 * sizeof(xmlSchemaNodeInfoPtr));
-        vctxt->sizeElemInfos = 10;
-    } else if (vctxt->sizeElemInfos <= vctxt->depth) {
-        int i = vctxt->sizeElemInfos;
-
-        vctxt->sizeElemInfos *= 2;
-        vctxt->elemInfos = (xmlSchemaNodeInfoPtr *)
-            xmlRealloc(vctxt->elemInfos, vctxt->sizeElemInfos *
-            sizeof(xmlSchemaNodeInfoPtr));
-        if (vctxt->elemInfos == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "re-allocating the element info array", NULL);
-            return (NULL);
-        }
-        /*
-        * We need the new memory to be NULLed.
-        * TODO: Use memset instead?
-        */
-        for (; i < vctxt->sizeElemInfos; i++)
-            vctxt->elemInfos[i] = NULL;
-    } else
-        info = vctxt->elemInfos[vctxt->depth];
-
-    if (info == NULL) {
-        info = (xmlSchemaNodeInfoPtr)
-            xmlMalloc(sizeof(xmlSchemaNodeInfo));
-        if (info == NULL) {
-            xmlSchemaVErrMemory(vctxt,
-                "allocating an element info", NULL);
-            return (NULL);
-        }
-        vctxt->elemInfos[vctxt->depth] = info;
-    } else {
-        if (info->localName != NULL) {
-            VERROR_INT("xmlSchemaGetFreshElemInfo",
-                "elem info has not been cleared");
-            return (NULL);
-        }
-    }
-    memset(info, 0, sizeof(xmlSchemaNodeInfo));
-    info->nodeType = XML_ELEMENT_NODE;
-    info->depth = vctxt->depth;
-
-    return (info);
-}
-
-#define ACTIVATE_ATTRIBUTE(item) vctxt->inode = (xmlSchemaNodeInfoPtr) item;
-#define ACTIVATE_ELEM vctxt->inode = vctxt->elemInfos[vctxt->depth];
-#define ACTIVATE_PARENT_ELEM vctxt->inode = vctxt->elemInfos[vctxt->depth -1];
-
-static int
-xmlSchemaValidateFacets(xmlSchemaAbstractCtxtPtr actxt,
-                        xmlNodePtr node,
-                        xmlSchemaTypePtr type,
-                        xmlSchemaValType valType,
-                        const xmlChar * value,
-                        xmlSchemaValPtr val,
-                        unsigned long length,
-                        int fireErrors)
-{
-    int ret, error = 0;
-
-    xmlSchemaTypePtr tmpType;
-    xmlSchemaFacetLinkPtr facetLink;
-    xmlSchemaFacetPtr facet;
-    unsigned long len = 0;
-    xmlSchemaWhitespaceValueType ws;
-
-    /*
-    * In Libxml2, derived built-in types have currently no explicit facets.
-    */
-    if (type->type == XML_SCHEMA_TYPE_BASIC)
-        return (0);
-
-    /*
-    * NOTE: Do not jump away, if the facetSet of the given type is
-    * empty: until now, "pattern" and "enumeration" facets of the
-    * *base types* need to be checked as well.
-    */
-    if (type->facetSet == NULL)
-        goto pattern_and_enum;
-
-    if (! WXS_IS_ATOMIC(type)) {
-        if (WXS_IS_LIST(type))
-            goto WXS_IS_LIST;
-        else
-            goto pattern_and_enum;
-    }
-
-    /*
-    * Whitespace handling is only of importance for string-based
-    * types.
-    */
-    tmpType = xmlSchemaGetPrimitiveType(type);
-    if ((tmpType->builtInType == XML_SCHEMAS_STRING) ||
-        WXS_IS_ANY_SIMPLE_TYPE(tmpType)) {
-        ws = xmlSchemaGetWhiteSpaceFacetValue(type);
-    } else
-        ws = XML_SCHEMA_WHITESPACE_COLLAPSE;
-
-    /*
-    * If the value was not computed (for string or
-    * anySimpleType based types), then use the provided
-    * type.
-    */
-    if (val != NULL)
-        valType = xmlSchemaGetValType(val);
-
-    ret = 0;
-    for (facetLink = type->facetSet; facetLink != NULL;
-        facetLink = facetLink->next) {
-        /*
-        * Skip the pattern "whiteSpace": it is used to
-        * format the character content beforehand.
-        */
-        switch (facetLink->facet->type) {
-            case XML_SCHEMA_FACET_WHITESPACE:
-            case XML_SCHEMA_FACET_PATTERN:
-            case XML_SCHEMA_FACET_ENUMERATION:
-                continue;
-            case XML_SCHEMA_FACET_LENGTH:
-            case XML_SCHEMA_FACET_MINLENGTH:
-            case XML_SCHEMA_FACET_MAXLENGTH:
-                ret = xmlSchemaValidateLengthFacetWhtsp(facetLink->facet,
-                    valType, value, val, &len, ws);
-                break;
-            default:
-                ret = xmlSchemaValidateFacetWhtsp(facetLink->facet, ws,
-                    valType, value, val, ws);
-                break;
-        }
-        if (ret < 0) {
-            AERROR_INT("xmlSchemaValidateFacets",
-                "validating against a atomic type facet");
-            return (-1);
-        } else if (ret > 0) {
-            if (fireErrors)
-                xmlSchemaFacetErr(actxt, ret, node,
-                value, len, type, facetLink->facet, NULL, NULL, NULL);
-            else
-                return (ret);
-            if (error == 0)
-                error = ret;
-        }
-        ret = 0;
-    }
-
-WXS_IS_LIST:
-    if (! WXS_IS_LIST(type))
-        goto pattern_and_enum;
-    /*
-    * "length", "minLength" and "maxLength" of list types.
-    */
-    ret = 0;
-    for (facetLink = type->facetSet; facetLink != NULL;
-        facetLink = facetLink->next) {
-
-        switch (facetLink->facet->type) {
-            case XML_SCHEMA_FACET_LENGTH:
-            case XML_SCHEMA_FACET_MINLENGTH:
-            case XML_SCHEMA_FACET_MAXLENGTH:
-                ret = xmlSchemaValidateListSimpleTypeFacet(facetLink->facet,
-                    value, length, NULL);
-                break;
-            default:
-                continue;
-        }
-        if (ret < 0) {
-            AERROR_INT("xmlSchemaValidateFacets",
-                "validating against a list type facet");
-            return (-1);
-        } else if (ret > 0) {
-            if (fireErrors)
-                xmlSchemaFacetErr(actxt, ret, node,
-                value, length, type, facetLink->facet, NULL, NULL, NULL);
-            else
-                return (ret);
-            if (error == 0)
-                error = ret;
-        }
-        ret = 0;
-    }
-
-pattern_and_enum:
-    if (error >= 0) {
-        int found = 0;
-        /*
-        * Process enumerations. Facet values are in the value space
-        * of the defining type's base type. This seems to be a bug in the
-        * XML Schema 1.0 spec. Use the whitespace type of the base type.
-        * Only the first set of enumerations in the ancestor-or-self axis
-        * is used for validation.
-        */
-        ret = 0;
-        tmpType = type;
-        do {
-            for (facet = tmpType->facets; facet != NULL; facet = facet->next) {
-                if (facet->type != XML_SCHEMA_FACET_ENUMERATION)
-                    continue;
-                found = 1;
-                ret = xmlSchemaAreValuesEqual(facet->val, val);
-                if (ret == 1)
-                    break;
-                else if (ret < 0) {
-                    AERROR_INT("xmlSchemaValidateFacets",
-                        "validating against an enumeration facet");
-                    return (-1);
-                }
-            }
-            if (ret != 0)
-                break;
-            /*
-            * Break on the first set of enumerations. Any additional
-            *  enumerations which might be existent on the ancestors
-            *  of the current type are restricted by this set; thus
-            *  *must* *not* be taken into account.
-            */
-            if (found)
-                break;
-            tmpType = tmpType->baseType;
-        } while ((tmpType != NULL) &&
-            (tmpType->type != XML_SCHEMA_TYPE_BASIC));
-        if (found && (ret == 0)) {
-            ret = XML_SCHEMAV_CVC_ENUMERATION_VALID;
-            if (fireErrors) {
-                xmlSchemaFacetErr(actxt, ret, node,
-                    value, 0, type, NULL, NULL, NULL, NULL);
-            } else
-                return (ret);
-            if (error == 0)
-                error = ret;
-        }
-    }
-
-    if (error >= 0) {
-        int found;
-        /*
-        * Process patters. Pattern facets are ORed at type level
-        * and ANDed if derived. Walk the base type axis.
-        */
-        tmpType = type;
-        facet = NULL;
-        do {
-            found = 0;
-            for (facetLink = tmpType->facetSet; facetLink != NULL;
-                facetLink = facetLink->next) {
-                if (facetLink->facet->type != XML_SCHEMA_FACET_PATTERN)
-                    continue;
-                found = 1;
-                /*
-                * NOTE that for patterns, @value needs to be the
-                * normalized vaule.
-                */
-                ret = xmlRegexpExec(facetLink->facet->regexp, value);
-                if (ret == 1)
-                    break;
-                else if (ret < 0) {
-                    AERROR_INT("xmlSchemaValidateFacets",
-                        "validating against a pattern facet");
-                    return (-1);
-                } else {
-                    /*
-                    * Save the last non-validating facet.
-                    */
-                    facet = facetLink->facet;
-                }
-            }
-            if (found && (ret != 1)) {
-                ret = XML_SCHEMAV_CVC_PATTERN_VALID;
-                if (fireErrors) {
-                    xmlSchemaFacetErr(actxt, ret, node,
-                        value, 0, type, facet, NULL, NULL, NULL);
-                } else
-                    return (ret);
-                if (error == 0)
-                    error = ret;
-                break;
-            }
-            tmpType = tmpType->baseType;
-        } while ((tmpType != NULL) && (tmpType->type != XML_SCHEMA_TYPE_BASIC));
-    }
-
-    return (error);
-}
-
-static xmlChar *
-xmlSchemaNormalizeValue(xmlSchemaTypePtr type,
-                        const xmlChar *value)
-{
-    switch (xmlSchemaGetWhiteSpaceFacetValue(type)) {
-        case XML_SCHEMA_WHITESPACE_COLLAPSE:
-            return (xmlSchemaCollapseString(value));
-        case XML_SCHEMA_WHITESPACE_REPLACE:
-            return (xmlSchemaWhiteSpaceReplace(value));
-        default:
-            return (NULL);
-    }
-}
-
-static int
-xmlSchemaValidateQName(xmlSchemaValidCtxtPtr vctxt,
-                       const xmlChar *value,
-                       xmlSchemaValPtr *val,
-                       int valNeeded)
-{
-    int ret;
-    const xmlChar *nsName;
-    xmlChar *local, *prefix = NULL;
-
-    ret = xmlValidateQName(value, 1);
-    if (ret != 0) {
-        if (ret == -1) {
-            VERROR_INT("xmlSchemaValidateQName",
-                "calling xmlValidateQName()");
-            return (-1);
-        }
-        return( XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1);
-    }
-    /*
-    * NOTE: xmlSplitQName2 will always return a duplicated
-    * strings.
-    */
-    local = xmlSplitQName2(value, &prefix);
-    if (local == NULL)
-        local = xmlStrdup(value);
-    /*
-    * OPTIMIZE TODO: Use flags for:
-    *  - is there any namespace binding?
-    *  - is there a default namespace?
-    */
-    nsName = xmlSchemaLookupNamespace(vctxt, prefix);
-
-    if (prefix != NULL) {
-        xmlFree(prefix);
-        /*
-        * A namespace must be found if the prefix is
-        * NOT NULL.
-        */
-        if (nsName == NULL) {
-            ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
-            xmlSchemaCustomErr(ACTXT_CAST vctxt, ret, NULL,
-                WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
-                "The QName value '%s' has no "
-                "corresponding namespace declaration in "
-                "scope", value, NULL);
-            if (local != NULL)
-                xmlFree(local);
-            return (ret);
-        }
-    }
-    if (valNeeded && val) {
-        if (nsName != NULL)
-            *val = xmlSchemaNewQNameValue(
-                BAD_CAST xmlStrdup(nsName), BAD_CAST local);
-        else
-            *val = xmlSchemaNewQNameValue(NULL,
-                BAD_CAST local);
-    } else
-        xmlFree(local);
-    return (0);
-}
-
-/*
-* cvc-simple-type
-*/
-static int
-xmlSchemaVCheckCVCSimpleType(xmlSchemaAbstractCtxtPtr actxt,
-                             xmlNodePtr node,
-                             xmlSchemaTypePtr type,
-                             const xmlChar *value,
-                             xmlSchemaValPtr *retVal,
-                             int fireErrors,
-                             int normalize,
-                             int isNormalized)
-{
-    int ret = 0, valNeeded = (retVal) ? 1 : 0;
-    xmlSchemaValPtr val = NULL;
-    /* xmlSchemaWhitespaceValueType ws; */
-    xmlChar *normValue = NULL;
-
-#define NORMALIZE(atype) \
-    if ((! isNormalized) && \
-    (normalize || (type->flags & XML_SCHEMAS_TYPE_NORMVALUENEEDED))) { \
-        normValue = xmlSchemaNormalizeValue(atype, value); \
-        if (normValue != NULL) \
-            value = normValue; \
-        isNormalized = 1; \
-    }
-
-    if ((retVal != NULL) && (*retVal != NULL)) {
-        xmlSchemaFreeValue(*retVal);
-        *retVal = NULL;
-    }
-    /*
-    * 3.14.4 Simple Type Definition Validation Rules
-    * Validation Rule: String Valid
-    */
-    /*
-    * 1 It is schema-valid with respect to that definition as defined
-    * by Datatype Valid in [XML Schemas: Datatypes].
-    */
-    /*
-    * 2.1 If The definition is ENTITY or is validly derived from ENTITY given
-    * the empty set, as defined in Type Derivation OK (Simple) ($3.14.6), then
-    * the string must be a `declared entity name`.
-    */
-    /*
-    * 2.2 If The definition is ENTITIES or is validly derived from ENTITIES
-    * given the empty set, as defined in Type Derivation OK (Simple) ($3.14.6),
-    * then every whitespace-delimited substring of the string must be a `declared
-    * entity name`.
-    */
-    /*
-    * 2.3 otherwise no further condition applies.
-    */
-    if ((! valNeeded) && (type->flags & XML_SCHEMAS_TYPE_FACETSNEEDVALUE))
-        valNeeded = 1;
-    if (value == NULL)
-        value = BAD_CAST "";
-    if (WXS_IS_ANY_SIMPLE_TYPE(type) || WXS_IS_ATOMIC(type)) {
-        xmlSchemaTypePtr biType; /* The built-in type. */
-        /*
-        * SPEC (1.2.1) "if {variety} is `atomic` then the string must `match`
-        * a literal in the `lexical space` of {base type definition}"
-        */
-        /*
-        * Whitespace-normalize.
-        */
-        NORMALIZE(type);
-        if (type->type != XML_SCHEMA_TYPE_BASIC) {
-            /*
-            * Get the built-in type.
-            */
-            biType = type->baseType;
-            while ((biType != NULL) &&
-                (biType->type != XML_SCHEMA_TYPE_BASIC))
-                biType = biType->baseType;
-
-            if (biType == NULL) {
-                AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                    "could not get the built-in type");
-                goto internal_error;
-            }
-        } else
-            biType = type;
-        /*
-        * NOTATIONs need to be processed here, since they need
-        * to lookup in the hashtable of NOTATION declarations of the schema.
-        */
-        if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
-            switch (biType->builtInType) {
-                case XML_SCHEMAS_NOTATION:
-                    ret = xmlSchemaValidateNotation(
-                        (xmlSchemaValidCtxtPtr) actxt,
-                        ((xmlSchemaValidCtxtPtr) actxt)->schema,
-                        NULL, value, &val, valNeeded);
-                    break;
-                case XML_SCHEMAS_QNAME:
-                    ret = xmlSchemaValidateQName((xmlSchemaValidCtxtPtr) actxt,
-                        value, &val, valNeeded);
-                    break;
-                default:
-                    /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
-                    if (valNeeded)
-                        ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, &val, node);
-                    else
-                        ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, NULL, node);
-                    break;
-            }
-        } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
-            switch (biType->builtInType) {
-                case XML_SCHEMAS_NOTATION:
-                    ret = xmlSchemaValidateNotation(NULL,
-                        ((xmlSchemaParserCtxtPtr) actxt)->schema, node,
-                        value, &val, valNeeded);
-                    break;
-                default:
-                    /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
-                    if (valNeeded)
-                        ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, &val, node);
-                    else
-                        ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, NULL, node);
-                    break;
-            }
-        } else {
-            /*
-            * Validation via a public API is not implemented yet.
-            */
-            TODO
-            goto internal_error;
-        }
-        if (ret != 0) {
-            if (ret < 0) {
-                AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                    "validating against a built-in type");
-                goto internal_error;
-            }
-            if (WXS_IS_LIST(type))
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
-            else
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
-        }
-        if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
-            /*
-            * Check facets.
-            */
-            ret = xmlSchemaValidateFacets(actxt, node, type,
-                (xmlSchemaValType) biType->builtInType, value, val,
-                0, fireErrors);
-            if (ret != 0) {
-                if (ret < 0) {
-                    AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                        "validating facets of atomic simple type");
-                    goto internal_error;
-                }
-                if (WXS_IS_LIST(type))
-                    ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
-                else
-                    ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
-            }
-        }
-        if (fireErrors && (ret > 0))
-            xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
-    } else if (WXS_IS_LIST(type)) {
-
-        xmlSchemaTypePtr itemType;
-        const xmlChar *cur, *end;
-        xmlChar *tmpValue = NULL;
-        unsigned long len = 0;
-        xmlSchemaValPtr prevVal = NULL, curVal = NULL;
-        /* 1.2.2 if {variety} is `list` then the string must be a sequence
-        * of white space separated tokens, each of which `match`es a literal
-        * in the `lexical space` of {item type definition}
-        */
-        /*
-        * Note that XML_SCHEMAS_TYPE_NORMVALUENEEDED will be set if
-        * the list type has an enum or pattern facet.
-        */
-        NORMALIZE(type);
-        /*
-        * VAL TODO: Optimize validation of empty values.
-        * VAL TODO: We do not have computed values for lists.
-        */
-        itemType = WXS_LIST_ITEMTYPE(type);
-        cur = value;
-        do {
-            while (IS_BLANK_CH(*cur))
-                cur++;
-            end = cur;
-            while ((*end != 0) && (!(IS_BLANK_CH(*end))))
-                end++;
-            if (end == cur)
-                break;
-            tmpValue = xmlStrndup(cur, end - cur);
-            len++;
-
-            if (valNeeded)
-                ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
-                    tmpValue, &curVal, fireErrors, 0, 1);
-            else
-                ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
-                    tmpValue, NULL, fireErrors, 0, 1);
-            FREE_AND_NULL(tmpValue);
-            if (curVal != NULL) {
-                /*
-                * Add to list of computed values.
-                */
-                if (val == NULL)
-                    val = curVal;
-                else
-                    xmlSchemaValueAppend(prevVal, curVal);
-                prevVal = curVal;
-                curVal = NULL;
-            }
-            if (ret != 0) {
-                if (ret < 0) {
-                    AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                        "validating an item of list simple type");
-                    goto internal_error;
-                }
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
-                break;
-            }
-            cur = end;
-        } while (*cur != 0);
-        FREE_AND_NULL(tmpValue);
-        if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
-            /*
-            * Apply facets (pattern, enumeration).
-            */
-            ret = xmlSchemaValidateFacets(actxt, node, type,
-                XML_SCHEMAS_UNKNOWN, value, val,
-                len, fireErrors);
-            if (ret != 0) {
-                if (ret < 0) {
-                    AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                        "validating facets of list simple type");
-                    goto internal_error;
-                }
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
-            }
-        }
-        if (fireErrors && (ret > 0)) {
-            /*
-            * Report the normalized value.
-            */
-            normalize = 1;
-            NORMALIZE(type);
-            xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
-        }
-    } else if (WXS_IS_UNION(type)) {
-        xmlSchemaTypeLinkPtr memberLink;
-        /*
-        * TODO: For all datatypes `derived` by `union`  whiteSpace does
-        * not apply directly; however, the normalization behavior of `union`
-        * types is controlled by the value of whiteSpace on that one of the
-        * `memberTypes` against which the `union` is successfully validated.
-        *
-        * This means that the value is normalized by the first validating
-        * member type, then the facets of the union type are applied. This
-        * needs changing of the value!
-        */
-
-        /*
-        * 1.2.3 if {variety} is `union` then the string must `match` a
-        * literal in the `lexical space` of at least one member of
-        * {member type definitions}
-        */
-        memberLink = xmlSchemaGetUnionSimpleTypeMemberTypes(type);
-        if (memberLink == NULL) {
-            AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                "union simple type has no member types");
-            goto internal_error;
-        }
-        /*
-        * Always normalize union type values, since we currently
-        * cannot store the whitespace information with the value
-        * itself; otherwise a later value-comparison would be
-        * not possible.
-        */
-        while (memberLink != NULL) {
-            if (valNeeded)
-                ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
-                    memberLink->type, value, &val, 0, 1, 0);
-            else
-                ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
-                    memberLink->type, value, NULL, 0, 1, 0);
-            if (ret <= 0)
-                break;
-            memberLink = memberLink->next;
-        }
-        if (ret != 0) {
-            if (ret < 0) {
-                AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                    "validating members of union simple type");
-                goto internal_error;
-            }
-            ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
-        }
-        /*
-        * Apply facets (pattern, enumeration).
-        */
-        if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
-            /*
-            * The normalization behavior of `union` types is controlled by
-            * the value of whiteSpace on that one of the `memberTypes`
-            * against which the `union` is successfully validated.
-            */
-            NORMALIZE(memberLink->type);
-            ret = xmlSchemaValidateFacets(actxt, node, type,
-                XML_SCHEMAS_UNKNOWN, value, val,
-                0, fireErrors);
-            if (ret != 0) {
-                if (ret < 0) {
-                    AERROR_INT("xmlSchemaVCheckCVCSimpleType",
-                        "validating facets of union simple type");
-                    goto internal_error;
-                }
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
-            }
-        }
-        if (fireErrors && (ret > 0))
-            xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
-    }
-
-    if (normValue != NULL)
-        xmlFree(normValue);
-    if (ret == 0) {
-        if (retVal != NULL)
-            *retVal = val;
-        else if (val != NULL)
-            xmlSchemaFreeValue(val);
-    } else if (val != NULL)
-        xmlSchemaFreeValue(val);
-    return (ret);
-internal_error:
-    if (normValue != NULL)
-        xmlFree(normValue);
-    if (val != NULL)
-        xmlSchemaFreeValue(val);
-    return (-1);
-}
-
-static int
-xmlSchemaVExpandQName(xmlSchemaValidCtxtPtr vctxt,
-                           const xmlChar *value,
-                           const xmlChar **nsName,
-                           const xmlChar **localName)
-{
-    int ret = 0;
-
-    if ((nsName == NULL) || (localName == NULL))
-        return (-1);
-    *nsName = NULL;
-    *localName = NULL;
-
-    ret = xmlValidateQName(value, 1);
-    if (ret == -1)
-        return (-1);
-    if (ret > 0) {
-        xmlSchemaSimpleTypeErr(ACTXT_CAST vctxt,
-            XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, NULL,
-            value, xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), 1);
-        return (1);
-    }
-    {
-        xmlChar *local = NULL;
-        xmlChar *prefix;
-
-        /*
-        * NOTE: xmlSplitQName2 will return a duplicated
-        * string.
-        */
-        local = xmlSplitQName2(value, &prefix);
-        if (local == NULL)
-            *localName = xmlDictLookup(vctxt->dict, value, -1);
-        else {
-            *localName = xmlDictLookup(vctxt->dict, local, -1);
-            xmlFree(local);
-        }
-
-        *nsName = xmlSchemaLookupNamespace(vctxt, prefix);
-
-        if (prefix != NULL) {
-            xmlFree(prefix);
-            /*
-            * A namespace must be found if the prefix is NOT NULL.
-            */
-            if (*nsName == NULL) {
-                xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, NULL,
-                    WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
-                    "The QName value '%s' has no "
-                    "corresponding namespace declaration in scope",
-                    value, NULL);
-                return (2);
-            }
-        }
-    }
-    return (0);
-}
-
-static int
-xmlSchemaProcessXSIType(xmlSchemaValidCtxtPtr vctxt,
-                        xmlSchemaAttrInfoPtr iattr,
-                        xmlSchemaTypePtr *localType,
-                        xmlSchemaElementPtr elemDecl)
-{
-    int ret = 0;
-    /*
-    * cvc-elt (3.3.4) : (4)
-    * AND
-    * Schema-Validity Assessment (Element) (cvc-assess-elt)
-    *   (1.2.1.2.1) - (1.2.1.2.4)
-    * Handle 'xsi:type'.
-    */
-    if (localType == NULL)
-        return (-1);
-    *localType = NULL;
-    if (iattr == NULL)
-        return (0);
-    else {
-        const xmlChar *nsName = NULL, *local = NULL;
-        /*
-        * TODO: We should report a *warning* that the type was overriden
-        * by the instance.
-        */
-        ACTIVATE_ATTRIBUTE(iattr);
-        /*
-        * (cvc-elt) (3.3.4) : (4.1)
-        * (cvc-assess-elt) (1.2.1.2.2)
-        */
-        ret = xmlSchemaVExpandQName(vctxt, iattr->value,
-            &nsName, &local);
-        if (ret != 0) {
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidateElementByDeclaration",
-                    "calling xmlSchemaQNameExpand() to validate the "
-                    "attribute 'xsi:type'");
-                goto internal_error;
-            }
-            goto exit;
-        }
-        /*
-        * (cvc-elt) (3.3.4) : (4.2)
-        * (cvc-assess-elt) (1.2.1.2.3)
-        */
-        *localType = xmlSchemaGetType(vctxt->schema, local, nsName);
-        if (*localType == NULL) {
-            xmlChar *str = NULL;
-
-            xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                XML_SCHEMAV_CVC_ELT_4_2, NULL,
-                WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
-                "The QName value '%s' of the xsi:type attribute does not "
-                "resolve to a type definition",
-                xmlSchemaFormatQName(&str, nsName, local), NULL);
-            FREE_AND_NULL(str);
-            ret = vctxt->err;
-            goto exit;
-        }
-        if (elemDecl != NULL) {
-            int set = 0;
-
-            /*
-            * SPEC cvc-elt (3.3.4) : (4.3) (Type Derivation OK)
-            * "The `local type definition` must be validly
-            * derived from the {type definition} given the union of
-            * the {disallowed substitutions} and the {type definition}'s
-            * {prohibited substitutions}, as defined in
-            * Type Derivation OK (Complex) ($3.4.6)
-            * (if it is a complex type definition),
-            * or given {disallowed substitutions} as defined in Type
-            * Derivation OK (Simple) ($3.14.6) (if it is a simple type
-            * definition)."
-            *
-            * {disallowed substitutions}: the "block" on the element decl.
-            * {prohibited substitutions}: the "block" on the type def.
-            */
-            /*
-            * OPTIMIZE TODO: We could map types already evaluated
-            * to be validly derived from other types to avoid checking
-            * this over and over for the same types.
-            */
-            if ((elemDecl->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) ||
-                (elemDecl->subtypes->flags &
-                    XML_SCHEMAS_TYPE_BLOCK_EXTENSION))
-                set |= SUBSET_EXTENSION;
-
-            if ((elemDecl->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) ||
-                (elemDecl->subtypes->flags &
-                    XML_SCHEMAS_TYPE_BLOCK_RESTRICTION))
-                set |= SUBSET_RESTRICTION;
-
-            /*
-            * REMOVED and CHANGED since this produced a parser context
-            * which adds to the string dict of the schema. So this would
-            * change the schema and we don't want this. We don't need
-            * the parser context anymore.
-            *
-            * if ((vctxt->pctxt == NULL) &&
-            *   (xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1))
-            *       return (-1);
-            */
-
-            if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST vctxt, *localType,
-                elemDecl->subtypes, set) != 0) {
-                xmlChar *str = NULL;
-
-                xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_ELT_4_3, NULL, NULL,
-                    "The type definition '%s', specified by xsi:type, is "
-                    "blocked or not validly derived from the type definition "
-                    "of the element declaration",
-                    xmlSchemaFormatQName(&str,
-                        (*localType)->targetNamespace,
-                        (*localType)->name),
-                    NULL);
-                FREE_AND_NULL(str);
-                ret = vctxt->err;
-                *localType = NULL;
-            }
-        }
-    }
-exit:
-    ACTIVATE_ELEM;
-    return (ret);
-internal_error:
-    ACTIVATE_ELEM;
-    return (-1);
-}
-
-static int
-xmlSchemaValidateElemDecl(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaElementPtr elemDecl = vctxt->inode->decl;
-    xmlSchemaTypePtr actualType;
-
-    /*
-    * cvc-elt (3.3.4) : 1
-    */
-    if (elemDecl == NULL) {
-        VERROR(XML_SCHEMAV_CVC_ELT_1, NULL,
-            "No matching declaration available");
-        return (vctxt->err);
-    }
-    actualType = WXS_ELEM_TYPEDEF(elemDecl);
-    /*
-    * cvc-elt (3.3.4) : 2
-    */
-    if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
-        VERROR(XML_SCHEMAV_CVC_ELT_2, NULL,
-            "The element declaration is abstract");
-        return (vctxt->err);
-    }
-    if (actualType == NULL) {
-        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
-            "The type definition is absent");
-        return (XML_SCHEMAV_CVC_TYPE_1);
-    }
-    if (vctxt->nbAttrInfos != 0) {
-        int ret;
-        xmlSchemaAttrInfoPtr iattr;
-        /*
-        * cvc-elt (3.3.4) : 3
-        * Handle 'xsi:nil'.
-        */
-        iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-            XML_SCHEMA_ATTR_INFO_META_XSI_NIL);
-        if (iattr) {
-            ACTIVATE_ATTRIBUTE(iattr);
-            /*
-            * Validate the value.
-            */
-            ret = xmlSchemaVCheckCVCSimpleType(
-                ACTXT_CAST vctxt, NULL,
-                xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
-                iattr->value, &(iattr->val), 1, 0, 0);
-            ACTIVATE_ELEM;
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidateElemDecl",
-                    "calling xmlSchemaVCheckCVCSimpleType() to "
-                    "validate the attribute 'xsi:nil'");
-                return (-1);
-            }
-            if (ret == 0) {
-                if ((elemDecl->flags & XML_SCHEMAS_ELEM_NILLABLE) == 0) {
-                    /*
-                    * cvc-elt (3.3.4) : 3.1
-                    */
-                    VERROR(XML_SCHEMAV_CVC_ELT_3_1, NULL,
-                        "The element is not 'nillable'");
-                    /* Does not return an error on purpose. */
-                } else {
-                    if (xmlSchemaValueGetAsBoolean(iattr->val)) {
-                        /*
-                        * cvc-elt (3.3.4) : 3.2.2
-                        */
-                        if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) &&
-                            (elemDecl->value != NULL)) {
-                            VERROR(XML_SCHEMAV_CVC_ELT_3_2_2, NULL,
-                                "The element cannot be 'nilled' because "
-                                "there is a fixed value constraint defined "
-                                "for it");
-                             /* Does not return an error on purpose. */
-                        } else
-                            vctxt->inode->flags |=
-                                XML_SCHEMA_ELEM_INFO_NILLED;
-                    }
-                }
-            }
-        }
-        /*
-        * cvc-elt (3.3.4) : 4
-        * Handle 'xsi:type'.
-        */
-        iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-            XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
-        if (iattr) {
-            xmlSchemaTypePtr localType = NULL;
-
-            ret = xmlSchemaProcessXSIType(vctxt, iattr, &localType,
-                elemDecl);
-            if (ret != 0) {
-                if (ret == -1) {
-                    VERROR_INT("xmlSchemaValidateElemDecl",
-                        "calling xmlSchemaProcessXSIType() to "
-                        "process the attribute 'xsi:type'");
-                    return (-1);
-                }
-                /* Does not return an error on purpose. */
-            }
-            if (localType != NULL) {
-                vctxt->inode->flags |= XML_SCHEMA_ELEM_INFO_LOCAL_TYPE;
-                actualType = localType;
-            }
-        }
-    }
-    /*
-    * IDC: Register identity-constraint XPath matchers.
-    */
-    if ((elemDecl->idcs != NULL) &&
-        (xmlSchemaIDCRegisterMatchers(vctxt, elemDecl) == -1))
-            return (-1);
-    /*
-    * No actual type definition.
-    */
-    if (actualType == NULL) {
-        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
-            "The type definition is absent");
-        return (XML_SCHEMAV_CVC_TYPE_1);
-    }
-    /*
-    * Remember the actual type definition.
-    */
-    vctxt->inode->typeDef = actualType;
-
-    return (0);
-}
-
-static int
-xmlSchemaVAttributesSimple(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaAttrInfoPtr iattr;
-    int ret = 0, i;
-
-    /*
-    * SPEC cvc-type (3.1.1)
-    * "The attributes of must be empty, excepting those whose namespace
-    * name is identical to http://www.w3.org/2001/XMLSchema-instance and
-    * whose local name is one of type, nil, schemaLocation or
-    * noNamespaceSchemaLocation."
-    */
-    if (vctxt->nbAttrInfos == 0)
-        return (0);
-    for (i = 0; i < vctxt->nbAttrInfos; i++) {
-        iattr = vctxt->attrInfos[i];
-        if (! iattr->metaType) {
-            ACTIVATE_ATTRIBUTE(iattr)
-            xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
-                XML_SCHEMAV_CVC_TYPE_3_1_1, iattr, NULL);
-            ret = XML_SCHEMAV_CVC_TYPE_3_1_1;
-        }
-    }
-    ACTIVATE_ELEM
-    return (ret);
-}
-
-/*
-* Cleanup currently used attribute infos.
-*/
-static void
-xmlSchemaClearAttrInfos(xmlSchemaValidCtxtPtr vctxt)
-{
-    int i;
-    xmlSchemaAttrInfoPtr attr;
-
-    if (vctxt->nbAttrInfos == 0)
-        return;
-    for (i = 0; i < vctxt->nbAttrInfos; i++) {
-        attr = vctxt->attrInfos[i];
-        if (attr->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES) {
-            if (attr->localName != NULL)
-                xmlFree((xmlChar *) attr->localName);
-            if (attr->nsName != NULL)
-                xmlFree((xmlChar *) attr->nsName);
-        }
-        if (attr->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
-            if (attr->value != NULL)
-                xmlFree((xmlChar *) attr->value);
-        }
-        if (attr->val != NULL) {
-            xmlSchemaFreeValue(attr->val);
-            attr->val = NULL;
-        }
-        memset(attr, 0, sizeof(xmlSchemaAttrInfo));
-    }
-    vctxt->nbAttrInfos = 0;
-}
-
-/*
-* 3.4.4 Complex Type Definition Validation Rules
-*   Element Locally Valid (Complex Type) (cvc-complex-type)
-* 3.2.4 Attribute Declaration Validation Rules
-*   Validation Rule: Attribute Locally Valid (cvc-attribute)
-*   Attribute Locally Valid (Use) (cvc-au)
-*
-* Only "assessed" attribute information items will be visible to
-* IDCs. I.e. not "lax" (without declaration) and "skip" wild attributes.
-*/
-static int
-xmlSchemaVAttributesComplex(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaTypePtr type = vctxt->inode->typeDef;
-    xmlSchemaItemListPtr attrUseList;
-    xmlSchemaAttributeUsePtr attrUse = NULL;
-    xmlSchemaAttributePtr attrDecl = NULL;
-    xmlSchemaAttrInfoPtr iattr, tmpiattr;
-    int i, j, found, nbAttrs, nbUses;
-    int xpathRes = 0, res, wildIDs = 0, fixed;
-    xmlNodePtr defAttrOwnerElem = NULL;
-
-    /*
-    * SPEC (cvc-attribute)
-    * (1) "The declaration must not be `absent` (see Missing
-    * Sub-components ($5.3) for how this can fail to be
-    * the case)."
-    * (2) "Its {type definition} must not be absent."
-    *
-    * NOTE (1) + (2): This is not handled here, since we currently do not
-    * allow validation against schemas which have missing sub-components.
-    *
-    * SPEC (cvc-complex-type)
-    * (3) "For each attribute information item in the element information
-    * item's [attributes] excepting those whose [namespace name] is
-    * identical to http://www.w3.org/2001/XMLSchema-instance and whose
-    * [local name] is one of type, nil, schemaLocation or
-    * noNamespaceSchemaLocation, the appropriate case among the following
-    * must be true:
-    *
-    */
-    attrUseList = (xmlSchemaItemListPtr) type->attrUses;
-    /*
-    * @nbAttrs is the number of attributes present in the instance.
-    */
-    nbAttrs = vctxt->nbAttrInfos;
-    if (attrUseList != NULL)
-        nbUses = attrUseList->nbItems;
-    else
-        nbUses = 0;
-    for (i = 0; i < nbUses; i++) {
-        found = 0;
-        attrUse = attrUseList->items[i];
-        attrDecl = WXS_ATTRUSE_DECL(attrUse);
-        for (j = 0; j < nbAttrs; j++) {
-            iattr = vctxt->attrInfos[j];
-            /*
-            * SPEC (cvc-complex-type) (3)
-            * Skip meta attributes.
-            */
-            if (iattr->metaType)
-                continue;
-            if (iattr->localName[0] != attrDecl->name[0])
-                continue;
-            if (!xmlStrEqual(iattr->localName, attrDecl->name))
-                continue;
-            if (!xmlStrEqual(iattr->nsName, attrDecl->targetNamespace))
-                continue;
-            found = 1;
-            /*
-            * SPEC (cvc-complex-type)
-            * (3.1) "If there is among the {attribute uses} an attribute
-            * use with an {attribute declaration} whose {name} matches
-            * the attribute information item's [local name] and whose
-            * {target namespace} is identical to the attribute information
-            * item's [namespace name] (where an `absent` {target namespace}
-            * is taken to be identical to a [namespace name] with no value),
-            * then the attribute information must be `valid` with respect
-            * to that attribute use as per Attribute Locally Valid (Use)
-            * ($3.5.4). In this case the {attribute declaration} of that
-            * attribute use is the `context-determined declaration` for the
-            * attribute information item with respect to Schema-Validity
-            * Assessment (Attribute) ($3.2.4) and
-            * Assessment Outcome (Attribute) ($3.2.5).
-            */
-            iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
-            iattr->use = attrUse;
-            /*
-            * Context-determined declaration.
-            */
-            iattr->decl = attrDecl;
-            iattr->typeDef = attrDecl->subtypes;
-            break;
-        }
-
-        if (found)
-            continue;
-
-        if (attrUse->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED) {
-            /*
-            * Handle non-existent, required attributes.
-            *
-            * SPEC (cvc-complex-type)
-            * (4) "The {attribute declaration} of each attribute use in
-            * the {attribute uses} whose {required} is true matches one
-            * of the attribute information items in the element information
-            * item's [attributes] as per clause 3.1 above."
-            */
-            tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
-            if (tmpiattr == NULL) {
-                VERROR_INT(
-                    "xmlSchemaVAttributesComplex",
-                    "calling xmlSchemaGetFreshAttrInfo()");
-                return (-1);
-            }
-            tmpiattr->state = XML_SCHEMAS_ATTR_ERR_MISSING;
-            tmpiattr->use = attrUse;
-            tmpiattr->decl = attrDecl;
-        } else if ((attrUse->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
-            ((attrUse->defValue != NULL) ||
-             (attrDecl->defValue != NULL))) {
-            /*
-            * Handle non-existent, optional, default/fixed attributes.
-            */
-            tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
-            if (tmpiattr == NULL) {
-                VERROR_INT(
-                    "xmlSchemaVAttributesComplex",
-                    "calling xmlSchemaGetFreshAttrInfo()");
-                return (-1);
-            }
-            tmpiattr->state = XML_SCHEMAS_ATTR_DEFAULT;
-            tmpiattr->use = attrUse;
-            tmpiattr->decl = attrDecl;
-            tmpiattr->typeDef = attrDecl->subtypes;
-            tmpiattr->localName = attrDecl->name;
-            tmpiattr->nsName = attrDecl->targetNamespace;
-        }
-    }
-
-    if (vctxt->nbAttrInfos == 0)
-        return (0);
-    /*
-    * Validate against the wildcard.
-    */
-    if (type->attributeWildcard != NULL) {
-        /*
-        * SPEC (cvc-complex-type)
-        * (3.2.1) "There must be an {attribute wildcard}."
-        */
-        for (i = 0; i < nbAttrs; i++) {
-            iattr = vctxt->attrInfos[i];
-            /*
-            * SPEC (cvc-complex-type) (3)
-            * Skip meta attributes.
-            */
-            if (iattr->state != XML_SCHEMAS_ATTR_UNKNOWN)
-                continue;
-            /*
-            * SPEC (cvc-complex-type)
-            * (3.2.2) "The attribute information item must be `valid` with
-            * respect to it as defined in Item Valid (Wildcard) ($3.10.4)."
-            *
-            * SPEC Item Valid (Wildcard) (cvc-wildcard)
-            * "... its [namespace name] must be `valid` with respect to
-            * the wildcard constraint, as defined in Wildcard allows
-            * Namespace Name ($3.10.4)."
-            */
-            if (xmlSchemaCheckCVCWildcardNamespace(type->attributeWildcard,
-                    iattr->nsName) == 0) {
-                /*
-                * Handle processContents.
-                *
-                * SPEC (cvc-wildcard):
-                * processContents | context-determined declaration:
-                * "strict"          "mustFind"
-                * "lax"             "none"
-                * "skip"            "skip"
-                */
-                if (type->attributeWildcard->processContents ==
-                    XML_SCHEMAS_ANY_SKIP) {
-                     /*
-                    * context-determined declaration = "skip"
-                    *
-                    * SPEC PSVI Assessment Outcome (Attribute)
-                    * [validity] = "notKnown"
-                    * [validation attempted] = "none"
-                    */
-                    iattr->state = XML_SCHEMAS_ATTR_WILD_SKIP;
-                    continue;
-                }
-                /*
-                * Find an attribute declaration.
-                */
-                iattr->decl = xmlSchemaGetAttributeDecl(vctxt->schema,
-                    iattr->localName, iattr->nsName);
-                if (iattr->decl != NULL) {
-                    iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
-                    /*
-                    * SPEC (cvc-complex-type)
-                    * (5) "Let [Definition:]  the wild IDs be the set of
-                    * all attribute information item to which clause 3.2
-                    * applied and whose `validation` resulted in a
-                    * `context-determined declaration` of mustFind or no
-                    * `context-determined declaration` at all, and whose
-                    * [local name] and [namespace name] resolve (as
-                    * defined by QName resolution (Instance) ($3.15.4)) to
-                    * an attribute declaration whose {type definition} is
-                    * or is derived from ID. Then all of the following
-                    * must be true:"
-                    */
-                    iattr->typeDef = WXS_ATTR_TYPEDEF(iattr->decl);
-                    if (xmlSchemaIsDerivedFromBuiltInType(
-                        iattr->typeDef, XML_SCHEMAS_ID)) {
-                        /*
-                        * SPEC (5.1) "There must be no more than one
-                        * item in `wild IDs`."
-                        */
-                        if (wildIDs != 0) {
-                            /* VAL TODO */
-                            iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID;
-                            TODO
-                            continue;
-                        }
-                        wildIDs++;
-                        /*
-                        * SPEC (cvc-complex-type)
-                        * (5.2) "If `wild IDs` is non-empty, there must not
-                        * be any attribute uses among the {attribute uses}
-                        * whose {attribute declaration}'s {type definition}
-                        * is or is derived from ID."
-                        */
-                        if (attrUseList != NULL) {
-                            for (j = 0; j < attrUseList->nbItems; j++) {
-                                if (xmlSchemaIsDerivedFromBuiltInType(
-                                    WXS_ATTRUSE_TYPEDEF(attrUseList->items[j]),
-                                    XML_SCHEMAS_ID)) {
-                                    /* URGENT VAL TODO: implement */
-                            iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID;
-                                    TODO
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                } else if (type->attributeWildcard->processContents ==
-                    XML_SCHEMAS_ANY_LAX) {
-                    iattr->state = XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL;
-                    /*
-                    * SPEC PSVI Assessment Outcome (Attribute)
-                    * [validity] = "notKnown"
-                    * [validation attempted] = "none"
-                    */
-                } else {
-                    iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL;
-                }
-            }
-        }
-    }
-
-    if (vctxt->nbAttrInfos == 0)
-        return (0);
-
-    /*
-    * Get the owner element; needed for creation of default attributes.
-    * This fixes bug #341337, reported by David Grohmann.
-    */
-    if (vctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) {
-        xmlSchemaNodeInfoPtr ielem = vctxt->elemInfos[vctxt->depth];
-        if (ielem && ielem->node && ielem->node->doc)
-            defAttrOwnerElem = ielem->node;
-    }
-    /*
-    * Validate values, create default attributes, evaluate IDCs.
-    */
-    for (i = 0; i < vctxt->nbAttrInfos; i++) {
-        iattr = vctxt->attrInfos[i];
-        /*
-        * VAL TODO: Note that we won't try to resolve IDCs to
-        * "lax" and "skip" validated attributes. Check what to
-        * do in this case.
-        */
-        if ((iattr->state != XML_SCHEMAS_ATTR_ASSESSED) &&
-            (iattr->state != XML_SCHEMAS_ATTR_DEFAULT))
-            continue;
-        /*
-        * VAL TODO: What to do if the type definition is missing?
-        */
-        if (iattr->typeDef == NULL) {
-            iattr->state = XML_SCHEMAS_ATTR_ERR_NO_TYPE;
-            continue;
-        }
-
-        ACTIVATE_ATTRIBUTE(iattr);
-        fixed = 0;
-        xpathRes = 0;
-
-        if (vctxt->xpathStates != NULL) {
-            /*
-            * Evaluate IDCs.
-            */
-            xpathRes = xmlSchemaXPathEvaluate(vctxt,
-                XML_ATTRIBUTE_NODE);
-            if (xpathRes == -1) {
-                VERROR_INT("xmlSchemaVAttributesComplex",
-                    "calling xmlSchemaXPathEvaluate()");
-                goto internal_error;
-            }
-        }
-
-        if (iattr->state == XML_SCHEMAS_ATTR_DEFAULT) {
-            /*
-            * Default/fixed attributes.
-            * We need the value only if we need to resolve IDCs or
-            * will create default attributes.
-            */
-            if ((xpathRes) || (defAttrOwnerElem)) {
-                if (iattr->use->defValue != NULL) {
-                    iattr->value = (xmlChar *) iattr->use->defValue;
-                    iattr->val = iattr->use->defVal;
-                } else {
-                    iattr->value = (xmlChar *) iattr->decl->defValue;
-                    iattr->val = iattr->decl->defVal;
-                }
-                /*
-                * IDCs will consume the precomputed default value,
-                * so we need to clone it.
-                */
-                if (iattr->val == NULL) {
-                    VERROR_INT("xmlSchemaVAttributesComplex",
-                        "default/fixed value on an attribute use was "
-                        "not precomputed");
-                    goto internal_error;
-                }
-                iattr->val = xmlSchemaCopyValue(iattr->val);
-                if (iattr->val == NULL) {
-                    VERROR_INT("xmlSchemaVAttributesComplex",
-                        "calling xmlSchemaCopyValue()");
-                    goto internal_error;
-                }
-            }
-            /*
-            * PSVI: Add the default attribute to the current element.
-            * VAL TODO: Should we use the *normalized* value? This currently
-            *   uses the *initial* value.
-            */
-
-            if (defAttrOwnerElem) {
-                xmlChar *normValue;
-                const xmlChar *value;
-
-                value = iattr->value;
-                /*
-                * Normalize the value.
-                */
-                normValue = xmlSchemaNormalizeValue(iattr->typeDef,
-                    iattr->value);
-                if (normValue != NULL)
-                    value = BAD_CAST normValue;
-
-                if (iattr->nsName == NULL) {
-                    if (xmlNewProp(defAttrOwnerElem,
-                        iattr->localName, value) == NULL) {
-                        VERROR_INT("xmlSchemaVAttributesComplex",
-                            "calling xmlNewProp()");
-                        if (normValue != NULL)
-                            xmlFree(normValue);
-                        goto internal_error;
-                    }
-                } else {
-                    xmlNsPtr ns;
-
-                    ns = xmlSearchNsByHref(defAttrOwnerElem->doc,
-                        defAttrOwnerElem, iattr->nsName);
-                    if (ns == NULL) {
-                        xmlChar prefix[12];
-                        int counter = 0;
-
-                        /*
-                        * Create a namespace declaration on the validation
-                        * root node if no namespace declaration is in scope.
-                        */
-                        do {
-                            snprintf((char *) prefix, 12, "p%d", counter++);
-                            ns = xmlSearchNs(defAttrOwnerElem->doc,
-                                defAttrOwnerElem, BAD_CAST prefix);
-                            if (counter > 1000) {
-                                VERROR_INT(
-                                    "xmlSchemaVAttributesComplex",
-                                    "could not compute a ns prefix for a "
-                                    "default/fixed attribute");
-                                if (normValue != NULL)
-                                    xmlFree(normValue);
-                                goto internal_error;
-                            }
-                        } while (ns != NULL);
-                        ns = xmlNewNs(vctxt->validationRoot,
-                            iattr->nsName, BAD_CAST prefix);
-                    }
-                    /*
-                    * TODO:
-                    * http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0406.html
-                    * If we have QNames: do we need to ensure there's a
-                    * prefix defined for the QName?
-                    */
-                    xmlNewNsProp(defAttrOwnerElem, ns, iattr->localName, value);
-                }
-                if (normValue != NULL)
-                    xmlFree(normValue);
-            }
-            /*
-            * Go directly to IDC evaluation.
-            */
-            goto eval_idcs;
-        }
-        /*
-        * Validate the value.
-        */
-        if (vctxt->value != NULL) {
-            /*
-            * Free last computed value; just for safety reasons.
-            */
-            xmlSchemaFreeValue(vctxt->value);
-            vctxt->value = NULL;
-        }
-        /*
-        * Note that the attribute *use* can be unavailable, if
-        * the attribute was a wild attribute.
-        */
-        if ((iattr->decl->flags & XML_SCHEMAS_ATTR_FIXED) ||
-            ((iattr->use != NULL) &&
-             (iattr->use->flags & XML_SCHEMAS_ATTR_FIXED)))
-            fixed = 1;
-        else
-            fixed = 0;
-        /*
-        * SPEC (cvc-attribute)
-        * (3) "The item's `normalized value` must be locally `valid`
-        * with respect to that {type definition} as per
-        * String Valid ($3.14.4)."
-        *
-        * VAL TODO: Do we already have the
-        * "normalized attribute value" here?
-        */
-        if (xpathRes || fixed) {
-            iattr->flags |= XML_SCHEMA_NODE_INFO_VALUE_NEEDED;
-            /*
-            * Request a computed value.
-            */
-            res = xmlSchemaVCheckCVCSimpleType(
-                ACTXT_CAST vctxt,
-                iattr->node, iattr->typeDef, iattr->value, &(iattr->val),
-                1, 1, 0);
-        } else {
-            res = xmlSchemaVCheckCVCSimpleType(
-                ACTXT_CAST vctxt,
-                iattr->node, iattr->typeDef, iattr->value, NULL,
-                1, 0, 0);
-        }
-
-        if (res != 0) {
-            if (res == -1) {
-                VERROR_INT("xmlSchemaVAttributesComplex",
-                    "calling xmlSchemaStreamValidateSimpleTypeValue()");
-                goto internal_error;
-            }
-            iattr->state = XML_SCHEMAS_ATTR_INVALID_VALUE;
-            /*
-            * SPEC PSVI Assessment Outcome (Attribute)
-            * [validity] = "invalid"
-            */
-            goto eval_idcs;
-        }
-
-        if (fixed) {
-            /*
-            * SPEC Attribute Locally Valid (Use) (cvc-au)
-            * "For an attribute information item to be `valid`
-            * with respect to an attribute use its *normalized*
-            * value must match the *canonical* lexical
-            * representation of the attribute use's {value
-            * constraint}value, if it is present and fixed."
-            *
-            * VAL TODO: The requirement for the *canonical* value
-            * will be removed in XML Schema 1.1.
-            */
-            /*
-            * SPEC Attribute Locally Valid (cvc-attribute)
-            * (4) "The item's *actual* value must match the *value* of
-            * the {value constraint}, if it is present and fixed."
-            */
-            if (iattr->val == NULL) {
-                /* VAL TODO: A value was not precomputed. */
-                TODO
-                goto eval_idcs;
-            }
-            if ((iattr->use != NULL) &&
-                (iattr->use->defValue != NULL)) {
-                if (iattr->use->defVal == NULL) {
-                    /* VAL TODO: A default value was not precomputed. */
-                    TODO
-                    goto eval_idcs;
-                }
-                iattr->vcValue = iattr->use->defValue;
-                /*
-                if (xmlSchemaCompareValuesWhtsp(attr->val,
-                    (xmlSchemaWhitespaceValueType) ws,
-                    attr->use->defVal,
-                    (xmlSchemaWhitespaceValueType) ws) != 0) {
-                */
-                if (! xmlSchemaAreValuesEqual(iattr->val, iattr->use->defVal))
-                    iattr->state = XML_SCHEMAS_ATTR_ERR_FIXED_VALUE;
-            } else {
-                if (iattr->decl->defVal == NULL) {
-                    /* VAL TODO: A default value was not precomputed. */
-                    TODO
-                    goto eval_idcs;
-                }
-                iattr->vcValue = iattr->decl->defValue;
-                /*
-                if (xmlSchemaCompareValuesWhtsp(attr->val,
-                    (xmlSchemaWhitespaceValueType) ws,
-                    attrDecl->defVal,
-                    (xmlSchemaWhitespaceValueType) ws) != 0) {
-                */
-                if (! xmlSchemaAreValuesEqual(iattr->val, iattr->decl->defVal))
-                    iattr->state = XML_SCHEMAS_ATTR_ERR_FIXED_VALUE;
-            }
-            /*
-            * [validity] = "valid"
-            */
-        }
-eval_idcs:
-        /*
-        * Evaluate IDCs.
-        */
-        if (xpathRes) {
-            if (xmlSchemaXPathProcessHistory(vctxt,
-                vctxt->depth +1) == -1) {
-                VERROR_INT("xmlSchemaVAttributesComplex",
-                    "calling xmlSchemaXPathEvaluate()");
-                goto internal_error;
-            }
-        } else if (vctxt->xpathStates != NULL)
-            xmlSchemaXPathPop(vctxt);
-    }
-
-    /*
-    * Report errors.
-    */
-    for (i = 0; i < vctxt->nbAttrInfos; i++) {
-        iattr = vctxt->attrInfos[i];
-        if ((iattr->state == XML_SCHEMAS_ATTR_META) ||
-            (iattr->state == XML_SCHEMAS_ATTR_ASSESSED) ||
-            (iattr->state == XML_SCHEMAS_ATTR_WILD_SKIP) ||
-            (iattr->state == XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL))
-            continue;
-        ACTIVATE_ATTRIBUTE(iattr);
-        switch (iattr->state) {
-            case XML_SCHEMAS_ATTR_ERR_MISSING: {
-                    xmlChar *str = NULL;
-                    ACTIVATE_ELEM;
-                    xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                        XML_SCHEMAV_CVC_COMPLEX_TYPE_4, NULL, NULL,
-                        "The attribute '%s' is required but missing",
-                        xmlSchemaFormatQName(&str,
-                            iattr->decl->targetNamespace,
-                            iattr->decl->name),
-                        NULL);
-                    FREE_AND_NULL(str)
-                    break;
-                }
-            case XML_SCHEMAS_ATTR_ERR_NO_TYPE:
-                VERROR(XML_SCHEMAV_CVC_ATTRIBUTE_2, NULL,
-                    "The type definition is absent");
-                break;
-            case XML_SCHEMAS_ATTR_ERR_FIXED_VALUE:
-                xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_AU, NULL, NULL,
-                    "The value '%s' does not match the fixed "
-                    "value constraint '%s'",
-                    iattr->value, iattr->vcValue);
-                break;
-            case XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL:
-                VERROR(XML_SCHEMAV_CVC_WILDCARD, NULL,
-                    "No matching global attribute declaration available, but "
-                    "demanded by the strict wildcard");
-                break;
-            case XML_SCHEMAS_ATTR_UNKNOWN:
-                if (iattr->metaType)
-                    break;
-                /*
-                * MAYBE VAL TODO: One might report different error messages
-                * for the following errors.
-                */
-                if (type->attributeWildcard == NULL) {
-                    xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
-                        XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, iattr, NULL);
-                } else {
-                    xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
-                        XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, iattr, NULL);
-                }
-                break;
-            default:
-                break;
-        }
-    }
-
-    ACTIVATE_ELEM;
-    return (0);
-internal_error:
-    ACTIVATE_ELEM;
-    return (-1);
-}
-
-static int
-xmlSchemaValidateElemWildcard(xmlSchemaValidCtxtPtr vctxt,
-                              int *skip)
-{
-    xmlSchemaWildcardPtr wild = (xmlSchemaWildcardPtr) vctxt->inode->decl;
-    /*
-    * The namespace of the element was already identified to be
-    * matching the wildcard.
-    */
-    if ((skip == NULL) || (wild == NULL) ||
-        (wild->type != XML_SCHEMA_TYPE_ANY)) {
-        VERROR_INT("xmlSchemaValidateElemWildcard",
-            "bad arguments");
-        return (-1);
-    }
-    *skip = 0;
-    if (wild->processContents == XML_SCHEMAS_ANY_SKIP) {
-        /*
-        * URGENT VAL TODO: Either we need to position the stream to the
-        * next sibling, or walk the whole subtree.
-        */
-        *skip = 1;
-        return (0);
-    }
-    {
-        xmlSchemaElementPtr decl = NULL;
-
-        decl = xmlSchemaGetElem(vctxt->schema,
-            vctxt->inode->localName, vctxt->inode->nsName);
-        if (decl != NULL) {
-            vctxt->inode->decl = decl;
-            return (0);
-        }
-    }
-    if (wild->processContents == XML_SCHEMAS_ANY_STRICT) {
-        /* VAL TODO: Change to proper error code. */
-        VERROR(XML_SCHEMAV_CVC_ELT_1, NULL, /* WXS_BASIC_CAST wild */
-            "No matching global element declaration available, but "
-            "demanded by the strict wildcard");
-        return (vctxt->err);
-    }
-    if (vctxt->nbAttrInfos != 0) {
-        xmlSchemaAttrInfoPtr iattr;
-        /*
-        * SPEC Validation Rule: Schema-Validity Assessment (Element)
-        * (1.2.1.2.1) - (1.2.1.2.3 )
-        *
-        * Use the xsi:type attribute for the type definition.
-        */
-        iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-            XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
-        if (iattr != NULL) {
-            if (xmlSchemaProcessXSIType(vctxt, iattr,
-                &(vctxt->inode->typeDef), NULL) == -1) {
-                VERROR_INT("xmlSchemaValidateElemWildcard",
-                    "calling xmlSchemaProcessXSIType() to "
-                    "process the attribute 'xsi:nil'");
-                return (-1);
-            }
-            /*
-            * Don't return an error on purpose.
-            */
-            return (0);
-        }
-    }
-    /*
-    * SPEC Validation Rule: Schema-Validity Assessment (Element)
-    *
-    * Fallback to "anyType".
-    */
-    vctxt->inode->typeDef =
-        xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
-    return (0);
-}
-
-/*
-* xmlSchemaCheckCOSValidDefault:
-*
-* This will be called if: not nilled, no content and a default/fixed
-* value is provided.
-*/
-
-static int
-xmlSchemaCheckCOSValidDefault(xmlSchemaValidCtxtPtr vctxt,
-                              const xmlChar *value,
-                              xmlSchemaValPtr *val)
-{
-    int ret = 0;
-    xmlSchemaNodeInfoPtr inode = vctxt->inode;
-
-    /*
-    * cos-valid-default:
-    * Schema Component Constraint: Element Default Valid (Immediate)
-    * For a string to be a valid default with respect to a type
-    * definition the appropriate case among the following must be true:
-    */
-    if WXS_IS_COMPLEX(inode->typeDef) {
-        /*
-        * Complex type.
-        *
-        * SPEC (2.1) "its {content type} must be a simple type definition
-        * or mixed."
-        * SPEC (2.2.2) "If the {content type} is mixed, then the {content
-        * type}'s particle must be `emptiable` as defined by
-        * Particle Emptiable ($3.9.6)."
-        */
-        if ((! WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) &&
-            ((! WXS_HAS_MIXED_CONTENT(inode->typeDef)) ||
-             (! WXS_EMPTIABLE(inode->typeDef)))) {
-            ret = XML_SCHEMAP_COS_VALID_DEFAULT_2_1;
-            /* NOTE that this covers (2.2.2) as well. */
-            VERROR(ret, NULL,
-                "For a string to be a valid default, the type definition "
-                "must be a simple type or a complex type with simple content "
-                "or mixed content and a particle emptiable");
-            return(ret);
-        }
-    }
-    /*
-    * 1 If the type definition is a simple type definition, then the string
-    * must be `valid` with respect to that definition as defined by String
-    * Valid ($3.14.4).
-    *
-    * AND
-    *
-    * 2.2.1 If the {content type} is a simple type definition, then the
-    * string must be `valid` with respect to that simple type definition
-    * as defined by String Valid ($3.14.4).
-    */
-    if (WXS_IS_SIMPLE(inode->typeDef)) {
-
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
-            NULL, inode->typeDef, value, val, 1, 1, 0);
-
-    } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
-
-        ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
-            NULL, inode->typeDef->contentTypeDef, value, val, 1, 1, 0);
-    }
-    if (ret < 0) {
-        VERROR_INT("xmlSchemaCheckCOSValidDefault",
-            "calling xmlSchemaVCheckCVCSimpleType()");
-    }
-    return (ret);
-}
-
-static void
-xmlSchemaVContentModelCallback(xmlSchemaValidCtxtPtr vctxt ATTRIBUTE_UNUSED,
-                               const xmlChar * name ATTRIBUTE_UNUSED,
-                               xmlSchemaElementPtr item,
-                               xmlSchemaNodeInfoPtr inode)
-{
-    inode->decl = item;
-#ifdef DEBUG_CONTENT
-    {
-        xmlChar *str = NULL;
-
-        if (item->type == XML_SCHEMA_TYPE_ELEMENT) {
-            xmlGenericError(xmlGenericErrorContext,
-                "AUTOMATON callback for '%s' [declaration]\n",
-                xmlSchemaFormatQName(&str,
-                inode->localName, inode->nsName));
-        } else {
-            xmlGenericError(xmlGenericErrorContext,
-                    "AUTOMATON callback for '%s' [wildcard]\n",
-                    xmlSchemaFormatQName(&str,
-                    inode->localName, inode->nsName));
-
-        }
-        FREE_AND_NULL(str)
-    }
-#endif
-}
-
-static int
-xmlSchemaValidatorPushElem(xmlSchemaValidCtxtPtr vctxt)
-{
-    vctxt->inode = xmlSchemaGetFreshElemInfo(vctxt);
-    if (vctxt->inode == NULL) {
-        VERROR_INT("xmlSchemaValidatorPushElem",
-            "calling xmlSchemaGetFreshElemInfo()");
-        return (-1);
-    }
-    vctxt->nbAttrInfos = 0;
-    return (0);
-}
-
-static int
-xmlSchemaVCheckINodeDataType(xmlSchemaValidCtxtPtr vctxt,
-                             xmlSchemaNodeInfoPtr inode,
-                             xmlSchemaTypePtr type,
-                             const xmlChar *value)
-{
-    if (inode->flags & XML_SCHEMA_NODE_INFO_VALUE_NEEDED)
-        return (xmlSchemaVCheckCVCSimpleType(
-            ACTXT_CAST vctxt, NULL,
-            type, value, &(inode->val), 1, 1, 0));
-    else
-        return (xmlSchemaVCheckCVCSimpleType(
-            ACTXT_CAST vctxt, NULL,
-            type, value, NULL, 1, 0, 0));
-}
-
-
-
-/*
-* Process END of element.
-*/
-static int
-xmlSchemaValidatorPopElem(xmlSchemaValidCtxtPtr vctxt)
-{
-    int ret = 0;
-    xmlSchemaNodeInfoPtr inode = vctxt->inode;
-
-    if (vctxt->nbAttrInfos != 0)
-        xmlSchemaClearAttrInfos(vctxt);
-    if (inode->flags & XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED) {
-        /*
-        * This element was not expected;
-        * we will not validate child elements of broken parents.
-        * Skip validation of all content of the parent.
-        */
-        vctxt->skipDepth = vctxt->depth -1;
-        goto end_elem;
-    }
-    if ((inode->typeDef == NULL) ||
-        (inode->flags & XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE)) {
-        /*
-        * 1. the type definition might be missing if the element was
-        *    error prone
-        * 2. it might be abstract.
-        */
-        goto end_elem;
-    }
-    /*
-    * Check the content model.
-    */
-    if ((inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) ||
-        (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)) {
-
-        /*
-        * Workaround for "anyType".
-        */
-        if (inode->typeDef->builtInType == XML_SCHEMAS_ANYTYPE)
-            goto character_content;
-
-        if ((inode->flags & XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT) == 0) {
-            xmlChar *values[10];
-            int terminal, nbval = 10, nbneg;
-
-            if (inode->regexCtxt == NULL) {
-                /*
-                * Create the regex context.
-                */
-                inode->regexCtxt =
-                    xmlRegNewExecCtxt(inode->typeDef->contModel,
-                    (xmlRegExecCallbacks) xmlSchemaVContentModelCallback,
-                    vctxt);
-                if (inode->regexCtxt == NULL) {
-                    VERROR_INT("xmlSchemaValidatorPopElem",
-                        "failed to create a regex context");
-                    goto internal_error;
-                }
-#ifdef DEBUG_AUTOMATA
-                xmlGenericError(xmlGenericErrorContext,
-                    "AUTOMATON create on '%s'\n", inode->localName);
-#endif
-            }
-
-            /*
-             * Do not check further content if the node has been nilled
-             */
-            if (INODE_NILLED(inode)) {
-                ret = 0;
-#ifdef DEBUG_AUTOMATA
-                xmlGenericError(xmlGenericErrorContext,
-                    "AUTOMATON succeeded on nilled '%s'\n",
-                    inode->localName);
-#endif
-                goto skip_nilled;
-            }
-
-            /*
-            * Get hold of the still expected content, since a further
-            * call to xmlRegExecPushString() will loose this information.
-            */
-            xmlRegExecNextValues(inode->regexCtxt,
-                &nbval, &nbneg, &values[0], &terminal);
-            ret = xmlRegExecPushString(inode->regexCtxt, NULL, NULL);
-            if ((ret<0) || ((ret==0) && (!INODE_NILLED(inode)))) {
-                /*
-                * Still missing something.
-                */
-                ret = 1;
-                inode->flags |=
-                    XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT;
-                xmlSchemaComplexTypeErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_ELEMENT_CONTENT, NULL, NULL,
-                    "Missing child element(s)",
-                    nbval, nbneg, values);
-#ifdef DEBUG_AUTOMATA
-                xmlGenericError(xmlGenericErrorContext,
-                    "AUTOMATON missing ERROR on '%s'\n",
-                    inode->localName);
-#endif
-            } else {
-                /*
-                * Content model is satisfied.
-                */
-                ret = 0;
-#ifdef DEBUG_AUTOMATA
-                xmlGenericError(xmlGenericErrorContext,
-                    "AUTOMATON succeeded on '%s'\n",
-                    inode->localName);
-#endif
-            }
-
-        }
-    }
-
-skip_nilled:
-
-    if (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)
-        goto end_elem;
-
-character_content:
-
-    if (vctxt->value != NULL) {
-        xmlSchemaFreeValue(vctxt->value);
-        vctxt->value = NULL;
-    }
-    /*
-    * Check character content.
-    */
-    if (inode->decl == NULL) {
-        /*
-        * Speedup if no declaration exists.
-        */
-        if (WXS_IS_SIMPLE(inode->typeDef)) {
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                inode, inode->typeDef, inode->value);
-        } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                inode, inode->typeDef->contentTypeDef,
-                inode->value);
-        }
-        if (ret < 0) {
-            VERROR_INT("xmlSchemaValidatorPopElem",
-                "calling xmlSchemaVCheckCVCSimpleType()");
-            goto internal_error;
-        }
-        goto end_elem;
-    }
-    /*
-    * cvc-elt (3.3.4) : 5
-    * The appropriate case among the following must be true:
-    */
-    /*
-    * cvc-elt (3.3.4) : 5.1
-    * If the declaration has a {value constraint},
-    * the item has neither element nor character [children] and
-    * clause 3.2 has not applied, then all of the following must be true:
-    */
-    if ((inode->decl->value != NULL) &&
-        (inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY) &&
-        (! INODE_NILLED(inode))) {
-        /*
-        * cvc-elt (3.3.4) : 5.1.1
-        * If the `actual type definition` is a `local type definition`
-        * then the canonical lexical representation of the {value constraint}
-        * value must be a valid default for the `actual type definition` as
-        * defined in Element Default Valid (Immediate) ($3.3.6).
-        */
-        /*
-        * NOTE: 'local' above means types acquired by xsi:type.
-        * NOTE: Although the *canonical* value is stated, it is not
-        * relevant if canonical or not. Additionally XML Schema 1.1
-        * will removed this requirement as well.
-        */
-        if (inode->flags & XML_SCHEMA_ELEM_INFO_LOCAL_TYPE) {
-
-            ret = xmlSchemaCheckCOSValidDefault(vctxt,
-                inode->decl->value, &(inode->val));
-            if (ret != 0) {
-                if (ret < 0) {
-                    VERROR_INT("xmlSchemaValidatorPopElem",
-                        "calling xmlSchemaCheckCOSValidDefault()");
-                    goto internal_error;
-                }
-                goto end_elem;
-            }
-            /*
-            * Stop here, to avoid redundant validation of the value
-            * (see following).
-            */
-            goto default_psvi;
-        }
-        /*
-        * cvc-elt (3.3.4) : 5.1.2
-        * The element information item with the canonical lexical
-        * representation of the {value constraint} value used as its
-        * `normalized value` must be `valid` with respect to the
-        * `actual type definition` as defined by Element Locally Valid (Type)
-        * ($3.3.4).
-        */
-        if (WXS_IS_SIMPLE(inode->typeDef)) {
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                inode, inode->typeDef, inode->decl->value);
-        } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                inode, inode->typeDef->contentTypeDef,
-                inode->decl->value);
-        }
-        if (ret != 0) {
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidatorPopElem",
-                    "calling xmlSchemaVCheckCVCSimpleType()");
-                goto internal_error;
-            }
-            goto end_elem;
-        }
-
-default_psvi:
-        /*
-        * PSVI: Create a text node on the instance element.
-        */
-        if ((vctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) &&
-            (inode->node != NULL)) {
-            xmlNodePtr textChild;
-            xmlChar *normValue;
-            /*
-            * VAL TODO: Normalize the value.
-            */
-            normValue = xmlSchemaNormalizeValue(inode->typeDef,
-                inode->decl->value);
-            if (normValue != NULL) {
-                textChild = xmlNewText(BAD_CAST normValue);
-                xmlFree(normValue);
-            } else
-                textChild = xmlNewText(inode->decl->value);
-            if (textChild == NULL) {
-                VERROR_INT("xmlSchemaValidatorPopElem",
-                    "calling xmlNewText()");
-                goto internal_error;
-            } else
-                xmlAddChild(inode->node, textChild);
-        }
-
-    } else if (! INODE_NILLED(inode)) {
-        /*
-        * 5.2.1 The element information item must be `valid` with respect
-        * to the `actual type definition` as defined by Element Locally
-        * Valid (Type) ($3.3.4).
-        */
-        if (WXS_IS_SIMPLE(inode->typeDef)) {
-             /*
-            * SPEC (cvc-type) (3.1)
-            * "If the type definition is a simple type definition, ..."
-            * (3.1.3) "If clause 3.2 of Element Locally Valid
-            * (Element) ($3.3.4) did not apply, then the `normalized value`
-            * must be `valid` with respect to the type definition as defined
-            * by String Valid ($3.14.4).
-            */
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                    inode, inode->typeDef, inode->value);
-        } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
-            /*
-            * SPEC (cvc-type) (3.2) "If the type definition is a complex type
-            * definition, then the element information item must be
-            * `valid` with respect to the type definition as per
-            * Element Locally Valid (Complex Type) ($3.4.4);"
-            *
-            * SPEC (cvc-complex-type) (2.2)
-            * "If the {content type} is a simple type definition, ...
-            * the `normalized value` of the element information item is
-            * `valid` with respect to that simple type definition as
-            * defined by String Valid ($3.14.4)."
-            */
-            ret = xmlSchemaVCheckINodeDataType(vctxt,
-                inode, inode->typeDef->contentTypeDef, inode->value);
-        }
-        if (ret != 0) {
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidatorPopElem",
-                    "calling xmlSchemaVCheckCVCSimpleType()");
-                goto internal_error;
-            }
-            goto end_elem;
-        }
-        /*
-        * 5.2.2 If there is a fixed {value constraint} and clause 3.2 has
-        * not applied, all of the following must be true:
-        */
-        if ((inode->decl->value != NULL) &&
-            (inode->decl->flags & XML_SCHEMAS_ELEM_FIXED)) {
-
-            /*
-            * TODO: We will need a computed value, when comparison is
-            * done on computed values.
-            */
-            /*
-            * 5.2.2.1 The element information item must have no element
-            * information item [children].
-            */
-            if (inode->flags &
-                    XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT) {
-                ret = XML_SCHEMAV_CVC_ELT_5_2_2_1;
-                VERROR(ret, NULL,
-                    "The content must not containt element nodes since "
-                    "there is a fixed value constraint");
-                goto end_elem;
-            } else {
-                /*
-                * 5.2.2.2 The appropriate case among the following must
-                * be true:
-                */
-                if (WXS_HAS_MIXED_CONTENT(inode->typeDef)) {
-                    /*
-                    * 5.2.2.2.1 If the {content type} of the `actual type
-                    * definition` is mixed, then the *initial value* of the
-                    * item must match the canonical lexical representation
-                    * of the {value constraint} value.
-                    *
-                    * ... the *initial value* of an element information
-                    * item is the string composed of, in order, the
-                    * [character code] of each character information item in
-                    * the [children] of that element information item.
-                    */
-                    if (! xmlStrEqual(inode->value, inode->decl->value)){
-                        /*
-                        * VAL TODO: Report invalid & expected values as well.
-                        * VAL TODO: Implement the canonical stuff.
-                        */
-                        ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_1;
-                        xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                            ret, NULL, NULL,
-                            "The initial value '%s' does not match the fixed "
-                            "value constraint '%s'",
-                            inode->value, inode->decl->value);
-                        goto end_elem;
-                    }
-                } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
-                    /*
-                    * 5.2.2.2.2 If the {content type} of the `actual type
-                    * definition` is a simple type definition, then the
-                    * *actual value* of the item must match the canonical
-                    * lexical representation of the {value constraint} value.
-                    */
-                    /*
-                    * VAL TODO: *actual value* is the normalized value, impl.
-                    *           this.
-                    * VAL TODO: Report invalid & expected values as well.
-                    * VAL TODO: Implement a comparison with the computed values.
-                    */
-                    if (! xmlStrEqual(inode->value,
-                            inode->decl->value)) {
-                        ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_2;
-                        xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                            ret, NULL, NULL,
-                            "The actual value '%s' does not match the fixed "
-                            "value constraint '%s'",
-                            inode->value,
-                            inode->decl->value);
-                        goto end_elem;
-                    }
-                }
-            }
-        }
-    }
-
-end_elem:
-    if (vctxt->depth < 0) {
-        /* TODO: raise error? */
-        return (0);
-    }
-    if (vctxt->depth == vctxt->skipDepth)
-        vctxt->skipDepth = -1;
-    /*
-    * Evaluate the history of XPath state objects.
-    */
-    if (inode->appliedXPath &&
-        (xmlSchemaXPathProcessHistory(vctxt, vctxt->depth) == -1))
-        goto internal_error;
-    /*
-    * MAYBE TODO:
-    * SPEC (6) "The element information item must be `valid` with
-    * respect to each of the {identity-constraint definitions} as per
-    * Identity-constraint Satisfied ($3.11.4)."
-    */
-    /*
-    * PSVI TODO: If we expose IDC node-tables via PSVI then the tables
-    *   need to be built in any case.
-    *   We will currently build IDC node-tables and bubble them only if
-    *   keyrefs do exist.
-    */
-
-    /*
-    * Add the current IDC target-nodes to the IDC node-tables.
-    */
-    if ((inode->idcMatchers != NULL) &&
-        (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
-    {
-        if (xmlSchemaIDCFillNodeTables(vctxt, inode) == -1)
-            goto internal_error;
-    }
-    /*
-    * Validate IDC keyrefs.
-    */
-    if (vctxt->inode->hasKeyrefs)
-        if (xmlSchemaCheckCVCIDCKeyRef(vctxt) == -1)
-            goto internal_error;
-    /*
-    * Merge/free the IDC table.
-    */
-    if (inode->idcTable != NULL) {
-#ifdef DEBUG_IDC_NODE_TABLE
-        xmlSchemaDebugDumpIDCTable(stdout,
-            inode->nsName,
-            inode->localName,
-            inode->idcTable);
-#endif
-        if ((vctxt->depth > 0) &&
-            (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
-        {
-            /*
-            * Merge the IDC node table with the table of the parent node.
-            */
-            if (xmlSchemaBubbleIDCNodeTables(vctxt) == -1)
-                goto internal_error;
-        }
-    }
-    /*
-    * Clear the current ielem.
-    * VAL TODO: Don't free the PSVI IDC tables if they are
-    * requested for the PSVI.
-    */
-    xmlSchemaClearElemInfo(vctxt, inode);
-    /*
-    * Skip further processing if we are on the validation root.
-    */
-    if (vctxt->depth == 0) {
-        vctxt->depth--;
-        vctxt->inode = NULL;
-        return (0);
-    }
-    /*
-    * Reset the keyrefDepth if needed.
-    */
-    if (vctxt->aidcs != NULL) {
-        xmlSchemaIDCAugPtr aidc = vctxt->aidcs;
-        do {
-            if (aidc->keyrefDepth == vctxt->depth) {
-                /*
-                * A 'keyrefDepth' of a key/unique IDC matches the current
-                * depth, this means that we are leaving the scope of the
-                * top-most keyref IDC which refers to this IDC.
-                */
-                aidc->keyrefDepth = -1;
-            }
-            aidc = aidc->next;
-        } while (aidc != NULL);
-    }
-    vctxt->depth--;
-    vctxt->inode = vctxt->elemInfos[vctxt->depth];
-    /*
-    * VAL TODO: 7 If the element information item is the `validation root`, it must be
-    * `valid` per Validation Root Valid (ID/IDREF) ($3.3.4).
-    */
-    return (ret);
-
-internal_error:
-    vctxt->err = -1;
-    return (-1);
-}
-
-/*
-* 3.4.4 Complex Type Definition Validation Rules
-* Validation Rule: Element Locally Valid (Complex Type) (cvc-complex-type)
-*/
-static int
-xmlSchemaValidateChildElem(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlSchemaNodeInfoPtr pielem;
-    xmlSchemaTypePtr ptype;
-    int ret = 0;
-
-    if (vctxt->depth <= 0) {
-        VERROR_INT("xmlSchemaValidateChildElem",
-            "not intended for the validation root");
-        return (-1);
-    }
-    pielem = vctxt->elemInfos[vctxt->depth -1];
-    if (pielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
-        pielem->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
-    /*
-    * Handle 'nilled' elements.
-    */
-    if (INODE_NILLED(pielem)) {
-        /*
-        * SPEC (cvc-elt) (3.3.4) : (3.2.1)
-        */
-        ACTIVATE_PARENT_ELEM;
-        ret = XML_SCHEMAV_CVC_ELT_3_2_1;
-        VERROR(ret, NULL,
-            "Neither character nor element content is allowed, "
-            "because the element was 'nilled'");
-        ACTIVATE_ELEM;
-        goto unexpected_elem;
-    }
-
-    ptype = pielem->typeDef;
-
-    if (ptype->builtInType == XML_SCHEMAS_ANYTYPE) {
-        /*
-        * Workaround for "anyType": we have currently no content model
-        * assigned for "anyType", so handle it explicitely.
-        * "anyType" has an unbounded, lax "any" wildcard.
-        */
-        vctxt->inode->decl = xmlSchemaGetElem(vctxt->schema,
-            vctxt->inode->localName,
-            vctxt->inode->nsName);
-
-        if (vctxt->inode->decl == NULL) {
-            xmlSchemaAttrInfoPtr iattr;
-            /*
-            * Process "xsi:type".
-            * SPEC (cvc-assess-elt) (1.2.1.2.1) - (1.2.1.2.3)
-            */
-            iattr = xmlSchemaGetMetaAttrInfo(vctxt,
-                XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
-            if (iattr != NULL) {
-                ret = xmlSchemaProcessXSIType(vctxt, iattr,
-                    &(vctxt->inode->typeDef), NULL);
-                if (ret != 0) {
-                    if (ret == -1) {
-                        VERROR_INT("xmlSchemaValidateChildElem",
-                            "calling xmlSchemaProcessXSIType() to "
-                            "process the attribute 'xsi:nil'");
-                        return (-1);
-                    }
-                    return (ret);
-                }
-            } else {
-                 /*
-                 * Fallback to "anyType".
-                 *
-                 * SPEC (cvc-assess-elt)
-                 * "If the item cannot be `strictly assessed`, [...]
-                 * an element information item's schema validity may be laxly
-                 * assessed if its `context-determined declaration` is not
-                 * skip by `validating` with respect to the `ur-type
-                 * definition` as per Element Locally Valid (Type) ($3.3.4)."
-                */
-                vctxt->inode->typeDef =
-                    xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
-            }
-        }
-        return (0);
-    }
-
-    switch (ptype->contentType) {
-        case XML_SCHEMA_CONTENT_EMPTY:
-            /*
-            * SPEC (2.1) "If the {content type} is empty, then the
-            * element information item has no character or element
-            * information item [children]."
-            */
-            ACTIVATE_PARENT_ELEM
-            ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1;
-            VERROR(ret, NULL,
-                "Element content is not allowed, "
-                "because the content type is empty");
-            ACTIVATE_ELEM
-            goto unexpected_elem;
-            break;
-
-        case XML_SCHEMA_CONTENT_MIXED:
-        case XML_SCHEMA_CONTENT_ELEMENTS: {
-            xmlRegExecCtxtPtr regexCtxt;
-            xmlChar *values[10];
-            int terminal, nbval = 10, nbneg;
-
-            /* VAL TODO: Optimized "anyType" validation.*/
-
-            if (ptype->contModel == NULL) {
-                VERROR_INT("xmlSchemaValidateChildElem",
-                    "type has elem content but no content model");
-                return (-1);
-            }
-            /*
-            * Safety belf for evaluation if the cont. model was already
-            * examined to be invalid.
-            */
-            if (pielem->flags & XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT) {
-                VERROR_INT("xmlSchemaValidateChildElem",
-                    "validating elem, but elem content is already invalid");
-                return (-1);
-            }
-
-            regexCtxt = pielem->regexCtxt;
-            if (regexCtxt == NULL) {
-                /*
-                * Create the regex context.
-                */
-                regexCtxt = xmlRegNewExecCtxt(ptype->contModel,
-                    (xmlRegExecCallbacks) xmlSchemaVContentModelCallback,
-                    vctxt);
-                if (regexCtxt == NULL) {
-                    VERROR_INT("xmlSchemaValidateChildElem",
-                        "failed to create a regex context");
-                    return (-1);
-                }
-                pielem->regexCtxt = regexCtxt;
-#ifdef DEBUG_AUTOMATA
-                xmlGenericError(xmlGenericErrorContext, "AUTOMATA create on '%s'\n",
-                    pielem->localName);
-#endif
-            }
-
-            /*
-            * SPEC (2.4) "If the {content type} is element-only or mixed,
-            * then the sequence of the element information item's
-            * element information item [children], if any, taken in
-            * order, is `valid` with respect to the {content type}'s
-            * particle, as defined in Element Sequence Locally Valid
-            * (Particle) ($3.9.4)."
-            */
-            ret = xmlRegExecPushString2(regexCtxt,
-                vctxt->inode->localName,
-                vctxt->inode->nsName,
-                vctxt->inode);
-#ifdef DEBUG_AUTOMATA
-            if (ret < 0)
-                xmlGenericError(xmlGenericErrorContext,
-                "AUTOMATON push ERROR for '%s' on '%s'\n",
-                vctxt->inode->localName, pielem->localName);
-            else
-                xmlGenericError(xmlGenericErrorContext,
-                "AUTOMATON push OK for '%s' on '%s'\n",
-                vctxt->inode->localName, pielem->localName);
-#endif
-            if (vctxt->err == XML_SCHEMAV_INTERNAL) {
-                VERROR_INT("xmlSchemaValidateChildElem",
-                    "calling xmlRegExecPushString2()");
-                return (-1);
-            }
-            if (ret < 0) {
-                xmlRegExecErrInfo(regexCtxt, NULL, &nbval, &nbneg,
-                    &values[0], &terminal);
-                xmlSchemaComplexTypeErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_ELEMENT_CONTENT, NULL,NULL,
-                    "This element is not expected",
-                    nbval, nbneg, values);
-                ret = vctxt->err;
-                goto unexpected_elem;
-            } else
-                ret = 0;
-        }
-            break;
-        case XML_SCHEMA_CONTENT_SIMPLE:
-        case XML_SCHEMA_CONTENT_BASIC:
-            ACTIVATE_PARENT_ELEM
-            if (WXS_IS_COMPLEX(ptype)) {
-                /*
-                * SPEC (cvc-complex-type) (2.2)
-                * "If the {content type} is a simple type definition, then
-                * the element information item has no element information
-                * item [children], ..."
-                */
-                ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2;
-                VERROR(ret, NULL, "Element content is not allowed, "
-                    "because the content type is a simple type definition");
-            } else {
-                /*
-                * SPEC (cvc-type) (3.1.2) "The element information item must
-                * have no element information item [children]."
-                */
-                ret = XML_SCHEMAV_CVC_TYPE_3_1_2;
-                VERROR(ret, NULL, "Element content is not allowed, "
-                    "because the type definition is simple");
-            }
-            ACTIVATE_ELEM
-            ret = vctxt->err;
-            goto unexpected_elem;
-            break;
-
-        default:
-            break;
-    }
-    return (ret);
-unexpected_elem:
-    /*
-    * Pop this element and set the skipDepth to skip
-    * all further content of the parent element.
-    */
-    vctxt->skipDepth = vctxt->depth;
-    vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED;
-    pielem->flags |= XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT;
-    return (ret);
-}
-
-#define XML_SCHEMA_PUSH_TEXT_PERSIST 1
-#define XML_SCHEMA_PUSH_TEXT_CREATED 2
-#define XML_SCHEMA_PUSH_TEXT_VOLATILE 3
-
-static int
-xmlSchemaVPushText(xmlSchemaValidCtxtPtr vctxt,
-                  int nodeType, const xmlChar *value, int len,
-                  int mode, int *consumed)
-{
-    /*
-    * Unfortunately we have to duplicate the text sometimes.
-    * OPTIMIZE: Maybe we could skip it, if:
-    *   1. content type is simple
-    *   2. whitespace is "collapse"
-    *   3. it consists of whitespace only
-    *
-    * Process character content.
-    */
-    if (consumed != NULL)
-        *consumed = 0;
-    if (INODE_NILLED(vctxt->inode)) {
-        /*
-        * SPEC cvc-elt (3.3.4 - 3.2.1)
-        * "The element information item must have no character or
-        * element information item [children]."
-        */
-        VERROR(XML_SCHEMAV_CVC_ELT_3_2_1, NULL,
-            "Neither character nor element content is allowed "
-            "because the element is 'nilled'");
-        return (vctxt->err);
-    }
-    /*
-    * SPEC (2.1) "If the {content type} is empty, then the
-    * element information item has no character or element
-    * information item [children]."
-    */
-    if (vctxt->inode->typeDef->contentType ==
-            XML_SCHEMA_CONTENT_EMPTY) {
-        VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, NULL,
-            "Character content is not allowed, "
-            "because the content type is empty");
-        return (vctxt->err);
-    }
-
-    if (vctxt->inode->typeDef->contentType ==
-            XML_SCHEMA_CONTENT_ELEMENTS) {
-        if ((nodeType != XML_TEXT_NODE) ||
-            (! xmlSchemaIsBlank((xmlChar *) value, len))) {
-            /*
-            * SPEC cvc-complex-type (2.3)
-            * "If the {content type} is element-only, then the
-            * element information item has no character information
-            * item [children] other than those whose [character
-            * code] is defined as a white space in [XML 1.0 (Second
-            * Edition)]."
-            */
-            VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, NULL,
-                "Character content other than whitespace is not allowed "
-                "because the content type is 'element-only'");
-            return (vctxt->err);
-        }
-        return (0);
-    }
-
-    if ((value == NULL) || (value[0] == 0))
-        return (0);
-    /*
-    * Save the value.
-    * NOTE that even if the content type is *mixed*, we need the
-    * *initial value* for default/fixed value constraints.
-    */
-    if ((vctxt->inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) &&
-        ((vctxt->inode->decl == NULL) ||
-        (vctxt->inode->decl->value == NULL)))
-        return (0);
-
-    if (vctxt->inode->value == NULL) {
-        /*
-        * Set the value.
-        */
-        switch (mode) {
-            case XML_SCHEMA_PUSH_TEXT_PERSIST:
-                /*
-                * When working on a tree.
-                */
-                vctxt->inode->value = value;
-                break;
-            case XML_SCHEMA_PUSH_TEXT_CREATED:
-                /*
-                * When working with the reader.
-                * The value will be freed by the element info.
-                */
-                vctxt->inode->value = value;
-                if (consumed != NULL)
-                    *consumed = 1;
-                vctxt->inode->flags |=
-                    XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
-                break;
-            case XML_SCHEMA_PUSH_TEXT_VOLATILE:
-                /*
-                * When working with SAX.
-                * The value will be freed by the element info.
-                */
-                if (len != -1)
-                    vctxt->inode->value = BAD_CAST xmlStrndup(value, len);
-                else
-                    vctxt->inode->value = BAD_CAST xmlStrdup(value);
-                vctxt->inode->flags |=
-                    XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
-                break;
-            default:
-                break;
-        }
-    } else {
-        if (len < 0)
-            len = xmlStrlen(value);
-        /*
-        * Concat the value.
-        */
-        if (vctxt->inode->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
-            vctxt->inode->value = BAD_CAST xmlStrncat(
-                (xmlChar *) vctxt->inode->value, value, len);
-        } else {
-            vctxt->inode->value =
-                BAD_CAST xmlStrncatNew(vctxt->inode->value, value, len);
-            vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
-        }
-    }
-
-    return (0);
-}
-
-static int
-xmlSchemaValidateElem(xmlSchemaValidCtxtPtr vctxt)
-{
-    int ret = 0;
-
-    if ((vctxt->skipDepth != -1) &&
-        (vctxt->depth >= vctxt->skipDepth)) {
-        VERROR_INT("xmlSchemaValidateElem",
-            "in skip-state");
-        goto internal_error;
-    }
-    if (vctxt->xsiAssemble) {
-        /*
-        * We will stop validation if there was an error during
-        * dynamic schema construction.
-        * Note that we simply set @skipDepth to 0, this could
-        * mean that a streaming document via SAX would be
-        * still read to the end but it won't be validated any more.
-        * TODO: If we are sure how to stop the validation at once
-        *   for all input scenarios, then this should be changed to
-        *   instantly stop the validation.
-        */
-        ret = xmlSchemaAssembleByXSI(vctxt);
-        if (ret != 0) {
-            if (ret == -1)
-                goto internal_error;
-            vctxt->skipDepth = 0;
-            return(ret);
-        }
-        /*
-         * Augment the IDC definitions for the main schema and all imported ones
-         * NOTE: main schema is the first in the imported list
-         */
-        xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
-    }
-    if (vctxt->depth > 0) {
-        /*
-        * Validate this element against the content model
-        * of the parent.
-        */
-        ret = xmlSchemaValidateChildElem(vctxt);
-        if (ret != 0) {
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidateElem",
-                    "calling xmlSchemaStreamValidateChildElement()");
-                goto internal_error;
-            }
-            goto exit;
-        }
-        if (vctxt->depth == vctxt->skipDepth)
-            goto exit;
-        if ((vctxt->inode->decl == NULL) &&
-            (vctxt->inode->typeDef == NULL)) {
-            VERROR_INT("xmlSchemaValidateElem",
-                "the child element was valid but neither the "
-                "declaration nor the type was set");
-            goto internal_error;
-        }
-    } else {
-        /*
-        * Get the declaration of the validation root.
-        */
-        vctxt->inode->decl = xmlSchemaGetElem(vctxt->schema,
-            vctxt->inode->localName,
-            vctxt->inode->nsName);
-        if (vctxt->inode->decl == NULL) {
-            ret = XML_SCHEMAV_CVC_ELT_1;
-            VERROR(ret, NULL,
-                "No matching global declaration available "
-                "for the validation root");
-            goto exit;
-        }
-    }
-
-    if (vctxt->inode->decl == NULL)
-        goto type_validation;
-
-    if (vctxt->inode->decl->type == XML_SCHEMA_TYPE_ANY) {
-        int skip;
-        /*
-        * Wildcards.
-        */
-        ret = xmlSchemaValidateElemWildcard(vctxt, &skip);
-        if (ret != 0) {
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaValidateElem",
-                    "calling xmlSchemaValidateElemWildcard()");
-                goto internal_error;
-            }
-            goto exit;
-        }
-        if (skip) {
-            vctxt->skipDepth = vctxt->depth;
-            goto exit;
-        }
-        /*
-        * The declaration might be set by the wildcard validation,
-        * when the processContents is "lax" or "strict".
-        */
-        if (vctxt->inode->decl->type != XML_SCHEMA_TYPE_ELEMENT) {
-            /*
-            * Clear the "decl" field to not confuse further processing.
-            */
-            vctxt->inode->decl = NULL;
-            goto type_validation;
-        }
-    }
-    /*
-    * Validate against the declaration.
-    */
-    ret = xmlSchemaValidateElemDecl(vctxt);
-    if (ret != 0) {
-        if (ret < 0) {
-            VERROR_INT("xmlSchemaValidateElem",
-                "calling xmlSchemaValidateElemDecl()");
-            goto internal_error;
-        }
-        goto exit;
-    }
-    /*
-    * Validate against the type definition.
-    */
-type_validation:
-
-    if (vctxt->inode->typeDef == NULL) {
-        vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
-        ret = XML_SCHEMAV_CVC_TYPE_1;
-        VERROR(ret, NULL,
-            "The type definition is absent");
-        goto exit;
-    }
-    if (vctxt->inode->typeDef->flags & XML_SCHEMAS_TYPE_ABSTRACT) {
-        vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
-        ret = XML_SCHEMAV_CVC_TYPE_2;
-            VERROR(ret, NULL,
-            "The type definition is abstract");
-        goto exit;
-    }
-    /*
-    * Evaluate IDCs. Do it here, since new IDC matchers are registered
-    * during validation against the declaration. This must be done
-    * _before_ attribute validation.
-    */
-    if (vctxt->xpathStates != NULL) {
-        ret = xmlSchemaXPathEvaluate(vctxt, XML_ELEMENT_NODE);
-        vctxt->inode->appliedXPath = 1;
-        if (ret == -1) {
-            VERROR_INT("xmlSchemaValidateElem",
-                "calling xmlSchemaXPathEvaluate()");
-            goto internal_error;
-        }
-    }
-    /*
-    * Validate attributes.
-    */
-    if (WXS_IS_COMPLEX(vctxt->inode->typeDef)) {
-        if ((vctxt->nbAttrInfos != 0) ||
-            (vctxt->inode->typeDef->attrUses != NULL)) {
-
-            ret = xmlSchemaVAttributesComplex(vctxt);
-        }
-    } else if (vctxt->nbAttrInfos != 0) {
-
-        ret = xmlSchemaVAttributesSimple(vctxt);
-    }
-    /*
-    * Clear registered attributes.
-    */
-    if (vctxt->nbAttrInfos != 0)
-        xmlSchemaClearAttrInfos(vctxt);
-    if (ret == -1) {
-        VERROR_INT("xmlSchemaValidateElem",
-            "calling attributes validation");
-        goto internal_error;
-    }
-    /*
-    * Don't return an error if attributes are invalid on purpose.
-    */
-    ret = 0;
-
-exit:
-    if (ret != 0)
-        vctxt->skipDepth = vctxt->depth;
-    return (ret);
-internal_error:
-    return (-1);
-}
-
-#ifdef XML_SCHEMA_READER_ENABLED
-static int
-xmlSchemaVReaderWalk(xmlSchemaValidCtxtPtr vctxt)
-{
-    const int WHTSP = 13, SIGN_WHTSP = 14, END_ELEM = 15;
-    int depth, nodeType, ret = 0, consumed;
-    xmlSchemaNodeInfoPtr ielem;
-
-    vctxt->depth = -1;
-    ret = xmlTextReaderRead(vctxt->reader);
-    /*
-    * Move to the document element.
-    */
-    while (ret == 1) {
-        nodeType = xmlTextReaderNodeType(vctxt->reader);
-        if (nodeType == XML_ELEMENT_NODE)
-            goto root_found;
-        ret = xmlTextReaderRead(vctxt->reader);
-    }
-    goto exit;
-
-root_found:
-
-    do {
-        depth = xmlTextReaderDepth(vctxt->reader);
-        nodeType = xmlTextReaderNodeType(vctxt->reader);
-
-        if (nodeType == XML_ELEMENT_NODE) {
-
-            vctxt->depth++;
-            if (xmlSchemaValidatorPushElem(vctxt) == -1) {
-                VERROR_INT("xmlSchemaVReaderWalk",
-                    "calling xmlSchemaValidatorPushElem()");
-                goto internal_error;
-            }
-            ielem = vctxt->inode;
-            ielem->localName = xmlTextReaderLocalName(vctxt->reader);
-            ielem->nsName = xmlTextReaderNamespaceUri(vctxt->reader);
-            ielem->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
-            /*
-            * Is the element empty?
-            */
-            ret = xmlTextReaderIsEmptyElement(vctxt->reader);
-            if (ret == -1) {
-                VERROR_INT("xmlSchemaVReaderWalk",
-                    "calling xmlTextReaderIsEmptyElement()");
-                goto internal_error;
-            }
-            if (ret) {
-                ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
-            }
-            /*
-            * Register attributes.
-            */
-            vctxt->nbAttrInfos = 0;
-            ret = xmlTextReaderMoveToFirstAttribute(vctxt->reader);
-            if (ret == -1) {
-                VERROR_INT("xmlSchemaVReaderWalk",
-                    "calling xmlTextReaderMoveToFirstAttribute()");
-                goto internal_error;
-            }
-            if (ret == 1) {
-                do {
-                    /*
-                    * VAL TODO: How do we know that the reader works on a
-                    * node tree, to be able to pass a node here?
-                    */
-                    if (xmlSchemaValidatorPushAttribute(vctxt, NULL,
-                        (const xmlChar *) xmlTextReaderLocalName(vctxt->reader),
-                        xmlTextReaderNamespaceUri(vctxt->reader), 1,
-                        xmlTextReaderValue(vctxt->reader), 1) == -1) {
-
-                        VERROR_INT("xmlSchemaVReaderWalk",
-                            "calling xmlSchemaValidatorPushAttribute()");
-                        goto internal_error;
-                    }
-                    ret = xmlTextReaderMoveToNextAttribute(vctxt->reader);
-                    if (ret == -1) {
-                        VERROR_INT("xmlSchemaVReaderWalk",
-                            "calling xmlTextReaderMoveToFirstAttribute()");
-                        goto internal_error;
-                    }
-                } while (ret == 1);
-                /*
-                * Back to element position.
-                */
-                ret = xmlTextReaderMoveToElement(vctxt->reader);
-                if (ret == -1) {
-                    VERROR_INT("xmlSchemaVReaderWalk",
-                        "calling xmlTextReaderMoveToElement()");
-                    goto internal_error;
-                }
-            }
-            /*
-            * Validate the element.
-            */
-            ret= xmlSchemaValidateElem(vctxt);
-            if (ret != 0) {
-                if (ret == -1) {
-                    VERROR_INT("xmlSchemaVReaderWalk",
-                        "calling xmlSchemaValidateElem()");
-                    goto internal_error;
-                }
-                goto exit;
-            }
-            if (vctxt->depth == vctxt->skipDepth) {
-                int curDepth;
-                /*
-                * Skip all content.
-                */
-                if ((ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY) == 0) {
-                    ret = xmlTextReaderRead(vctxt->reader);
-                    curDepth = xmlTextReaderDepth(vctxt->reader);
-                    while ((ret == 1) && (curDepth != depth)) {
-                        ret = xmlTextReaderRead(vctxt->reader);
-                        curDepth = xmlTextReaderDepth(vctxt->reader);
-                    }
-                    if (ret < 0) {
-                        /*
-                        * VAL TODO: A reader error occured; what to do here?
-                        */
-                        ret = 1;
-                        goto exit;
-                    }
-                }
-                goto leave_elem;
-            }
-            /*
-            * READER VAL TODO: Is an END_ELEM really never called
-            * if the elem is empty?
-            */
-            if (ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
-                goto leave_elem;
-        } else if (nodeType == END_ELEM) {
-            /*
-            * Process END of element.
-            */
-leave_elem:
-            ret = xmlSchemaValidatorPopElem(vctxt);
-            if (ret != 0) {
-                if (ret < 0) {
-                    VERROR_INT("xmlSchemaVReaderWalk",
-                        "calling xmlSchemaValidatorPopElem()");
-                    goto internal_error;
-                }
-                goto exit;
-            }
-            if (vctxt->depth >= 0)
-                ielem = vctxt->inode;
-            else
-                ielem = NULL;
-        } else if ((nodeType == XML_TEXT_NODE) ||
-            (nodeType == XML_CDATA_SECTION_NODE) ||
-            (nodeType == WHTSP) ||
-            (nodeType == SIGN_WHTSP)) {
-            /*
-            * Process character content.
-            */
-            xmlChar *value;
-
-            if ((nodeType == WHTSP) || (nodeType == SIGN_WHTSP))
-                nodeType = XML_TEXT_NODE;
-
-            value = xmlTextReaderValue(vctxt->reader);
-            ret = xmlSchemaVPushText(vctxt, nodeType, BAD_CAST value,
-                -1, XML_SCHEMA_PUSH_TEXT_CREATED, &consumed);
-            if (! consumed)
-                xmlFree(value);
-            if (ret == -1) {
-                VERROR_INT("xmlSchemaVReaderWalk",
-                    "calling xmlSchemaVPushText()");
-                goto internal_error;
-            }
-        } else if ((nodeType == XML_ENTITY_NODE) ||
-            (nodeType == XML_ENTITY_REF_NODE)) {
-            /*
-            * VAL TODO: What to do with entities?
-            */
-            TODO
-        }
-        /*
-        * Read next node.
-        */
-        ret = xmlTextReaderRead(vctxt->reader);
-    } while (ret == 1);
-
-exit:
-    return (ret);
-internal_error:
-    return (-1);
-}
-#endif
-
-/************************************************************************
- *                                                                      *
- *                      SAX validation handlers                         *
- *                                                                      *
- ************************************************************************/
-
-/*
-* Process text content.
-*/
-static void
-xmlSchemaSAXHandleText(void *ctx,
-                       const xmlChar * ch,
-                       int len)
-{
-    xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
-
-    if (vctxt->depth < 0)
-        return;
-    if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
-        return;
-    if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
-        vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
-    if (xmlSchemaVPushText(vctxt, XML_TEXT_NODE, ch, len,
-        XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
-        VERROR_INT("xmlSchemaSAXHandleCDataSection",
-            "calling xmlSchemaVPushText()");
-        vctxt->err = -1;
-        xmlStopParser(vctxt->parserCtxt);
-    }
-}
-
-/*
-* Process CDATA content.
-*/
-static void
-xmlSchemaSAXHandleCDataSection(void *ctx,
-                             const xmlChar * ch,
-                             int len)
-{
-    xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
-
-    if (vctxt->depth < 0)
-        return;
-    if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
-        return;
-    if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
-        vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
-    if (xmlSchemaVPushText(vctxt, XML_CDATA_SECTION_NODE, ch, len,
-        XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
-        VERROR_INT("xmlSchemaSAXHandleCDataSection",
-            "calling xmlSchemaVPushText()");
-        vctxt->err = -1;
-        xmlStopParser(vctxt->parserCtxt);
-    }
-}
-
-static void
-xmlSchemaSAXHandleReference(void *ctx ATTRIBUTE_UNUSED,
-                            const xmlChar * name ATTRIBUTE_UNUSED)
-{
-    xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
-
-    if (vctxt->depth < 0)
-        return;
-    if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
-        return;
-    /* SAX VAL TODO: What to do here? */
-    TODO
-}
-
-static void
-xmlSchemaSAXHandleStartElementNs(void *ctx,
-                                 const xmlChar * localname,
-                                 const xmlChar * prefix ATTRIBUTE_UNUSED,
-                                 const xmlChar * URI,
-                                 int nb_namespaces,
-                                 const xmlChar ** namespaces,
-                                 int nb_attributes,
-                                 int nb_defaulted ATTRIBUTE_UNUSED,
-                                 const xmlChar ** attributes)
-{
-    xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
-    int ret;
-    xmlSchemaNodeInfoPtr ielem;
-    int i, j;
-
-    /*
-    * SAX VAL TODO: What to do with nb_defaulted?
-    */
-    /*
-    * Skip elements if inside a "skip" wildcard or invalid.
-    */
-    vctxt->depth++;
-    if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
-        return;
-    /*
-    * Push the element.
-    */
-    if (xmlSchemaValidatorPushElem(vctxt) == -1) {
-        VERROR_INT("xmlSchemaSAXHandleStartElementNs",
-            "calling xmlSchemaValidatorPushElem()");
-        goto internal_error;
-    }
-    ielem = vctxt->inode;
-    /*
-    * TODO: Is this OK?
-    */
-    ielem->nodeLine = xmlSAX2GetLineNumber(vctxt->parserCtxt);
-    ielem->localName = localname;
-    ielem->nsName = URI;
-    ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
-    /*
-    * Register namespaces on the elem info.
-    */
-    if (nb_namespaces != 0) {
-        /*
-        * Although the parser builds its own namespace list,
-        * we have no access to it, so we'll use an own one.
-        */
-        for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {
-            /*
-            * Store prefix and namespace name.
-            */
-            if (ielem->nsBindings == NULL) {
-                ielem->nsBindings =
-                    (const xmlChar **) xmlMalloc(10 *
-                        sizeof(const xmlChar *));
-                if (ielem->nsBindings == NULL) {
-                    xmlSchemaVErrMemory(vctxt,
-                        "allocating namespace bindings for SAX validation",
-                        NULL);
-                    goto internal_error;
-                }
-                ielem->nbNsBindings = 0;
-                ielem->sizeNsBindings = 5;
-            } else if (ielem->sizeNsBindings <= ielem->nbNsBindings) {
-                ielem->sizeNsBindings *= 2;
-                ielem->nsBindings =
-                    (const xmlChar **) xmlRealloc(
-                        (void *) ielem->nsBindings,
-                        ielem->sizeNsBindings * 2 * sizeof(const xmlChar *));
-                if (ielem->nsBindings == NULL) {
-                    xmlSchemaVErrMemory(vctxt,
-                        "re-allocating namespace bindings for SAX validation",
-                        NULL);
-                    goto internal_error;
-                }
-            }
-
-            ielem->nsBindings[ielem->nbNsBindings * 2] = namespaces[j];
-            if (namespaces[j+1][0] == 0) {
-                /*
-                * Handle xmlns="".
-                */
-                ielem->nsBindings[ielem->nbNsBindings * 2 + 1] = NULL;
-            } else
-                ielem->nsBindings[ielem->nbNsBindings * 2 + 1] =
-                    namespaces[j+1];
-            ielem->nbNsBindings++;
-        }
-    }
-    /*
-    * Register attributes.
-    * SAX VAL TODO: We are not adding namespace declaration
-    * attributes yet.
-    */
-    if (nb_attributes != 0) {
-        int valueLen, k, l;
-        xmlChar *value;
-
-        for (j = 0, i = 0; i < nb_attributes; i++, j += 5) {
-            /*
-            * Duplicate the value, changing any &#38; to a literal ampersand.
-            *
-            * libxml2 differs from normal SAX here in that it escapes all ampersands
-            * as &#38; instead of delivering the raw converted string. Changing the
-            * behavior at this point would break applications that use this API, so
-            * we are forced to work around it.
-            */
-            valueLen = attributes[j+4] - attributes[j+3];
-            value = xmlMallocAtomic(valueLen + 1);
-            if (value == NULL) {
-                xmlSchemaVErrMemory(vctxt,
-                    "allocating string for decoded attribute",
-                    NULL);
-                goto internal_error;
-            }
-            for (k = 0, l = 0; k < valueLen; l++) {
-                if (k < valueLen - 4 &&
-                    attributes[j+3][k+0] == '&' &&
-                    attributes[j+3][k+1] == '#' &&
-                    attributes[j+3][k+2] == '3' &&
-                    attributes[j+3][k+3] == '8' &&
-                    attributes[j+3][k+4] == ';') {
-                    value[l] = '&';
-                    k += 5;
-                } else {
-                    value[l] = attributes[j+3][k];
-                    k++;
-                }
-            }
-            value[l] = '\0';
-            /*
-            * TODO: Set the node line.
-            */
-            ret = xmlSchemaValidatorPushAttribute(vctxt,
-                NULL, ielem->nodeLine, attributes[j], attributes[j+2], 0,
-                value, 1);
-            if (ret == -1) {
-                VERROR_INT("xmlSchemaSAXHandleStartElementNs",
-                    "calling xmlSchemaValidatorPushAttribute()");
-                goto internal_error;
-            }
-        }
-    }
-    /*
-    * Validate the element.
-    */
-    ret = xmlSchemaValidateElem(vctxt);
-    if (ret != 0) {
-        if (ret == -1) {
-            VERROR_INT("xmlSchemaSAXHandleStartElementNs",
-                "calling xmlSchemaValidateElem()");
-            goto internal_error;
-        }
-        goto exit;
-    }
-
-exit:
-    return;
-internal_error:
-    vctxt->err = -1;
-    xmlStopParser(vctxt->parserCtxt);
-    return;
-}
-
-static void
-xmlSchemaSAXHandleEndElementNs(void *ctx,
-                               const xmlChar * localname ATTRIBUTE_UNUSED,
-                               const xmlChar * prefix ATTRIBUTE_UNUSED,
-                               const xmlChar * URI ATTRIBUTE_UNUSED)
-{
-    xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
-    int res;
-
-    /*
-    * Skip elements if inside a "skip" wildcard or if invalid.
-    */
-    if (vctxt->skipDepth != -1) {
-        if (vctxt->depth > vctxt->skipDepth) {
-            vctxt->depth--;
-            return;
-        } else
-            vctxt->skipDepth = -1;
-    }
-    /*
-    * SAX VAL TODO: Just a temporary check.
-    */
-    if ((!xmlStrEqual(vctxt->inode->localName, localname)) ||
-        (!xmlStrEqual(vctxt->inode->nsName, URI))) {
-        VERROR_INT("xmlSchemaSAXHandleEndElementNs",
-            "elem pop mismatch");
-    }
-    res = xmlSchemaValidatorPopElem(vctxt);
-    if (res != 0) {
-        if (res < 0) {
-            VERROR_INT("xmlSchemaSAXHandleEndElementNs",
-                "calling xmlSchemaValidatorPopElem()");
-            goto internal_error;
-        }
-        goto exit;
-    }
-exit:
-    return;
-internal_error:
-    vctxt->err = -1;
-    xmlStopParser(vctxt->parserCtxt);
-    return;
-}
-
-/************************************************************************
- *                                                                      *
- *                      Validation interfaces                           *
- *                                                                      *
- ************************************************************************/
-
-/**
- * xmlSchemaNewValidCtxt:
- * @schema:  a precompiled XML Schemas
- *
- * Create an XML Schemas validation context based on the given schema.
- *
- * Returns the validation context or NULL in case of error
- */
-xmlSchemaValidCtxtPtr
-xmlSchemaNewValidCtxt(xmlSchemaPtr schema)
-{
-    xmlSchemaValidCtxtPtr ret;
-
-    ret = (xmlSchemaValidCtxtPtr) xmlMalloc(sizeof(xmlSchemaValidCtxt));
-    if (ret == NULL) {
-        xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
-        return (NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaValidCtxt));
-    ret->type = XML_SCHEMA_CTXT_VALIDATOR;
-    ret->dict = xmlDictCreate();
-    ret->nodeQNames = xmlSchemaItemListCreate();
-    ret->schema = schema;
-    return (ret);
-}
-
-/**
- * xmlSchemaValidateSetFilename:
- * @vctxt: the schema validation context
- * @filename: the file name
- *
- * Workaround to provide file error reporting information when this is
- * not provided by current APIs
- */
-void
-xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt, const char *filename) {
-    if (vctxt == NULL)
-        return;
-    if (vctxt->filename != NULL)
-        xmlFree(vctxt->filename);
-    if (filename != NULL)
-        vctxt->filename = (char *) xmlStrdup((const xmlChar *) filename);
-    else
-        vctxt->filename = NULL;
-}
-
-/**
- * xmlSchemaClearValidCtxt:
- * @vctxt: the schema validation context
- *
- * Free the resources associated to the schema validation context;
- * leaves some fields alive intended for reuse of the context.
- */
-static void
-xmlSchemaClearValidCtxt(xmlSchemaValidCtxtPtr vctxt)
-{
-    if (vctxt == NULL)
-        return;
-
-    /*
-    * TODO: Should we clear the flags?
-    *   Might be problematic if one reuses the context
-    *   and assumes that the options remain the same.
-    */
-    vctxt->flags = 0;
-    vctxt->validationRoot = NULL;
-    vctxt->doc = NULL;
-#ifdef LIBXML_READER_ENABLED
-    vctxt->reader = NULL;
-#endif
-    vctxt->hasKeyrefs = 0;
-
-    if (vctxt->value != NULL) {
-        xmlSchemaFreeValue(vctxt->value);
-        vctxt->value = NULL;
-    }
-    /*
-    * Augmented IDC information.
-    */
-    if (vctxt->aidcs != NULL) {
-        xmlSchemaIDCAugPtr cur = vctxt->aidcs, next;
-        do {
-            next = cur->next;
-            xmlFree(cur);
-            cur = next;
-        } while (cur != NULL);
-        vctxt->aidcs = NULL;
-    }
-    if (vctxt->idcMatcherCache != NULL) {
-        xmlSchemaIDCMatcherPtr matcher = vctxt->idcMatcherCache, tmp;
-
-        while (matcher) {
-            tmp = matcher;
-            matcher = matcher->nextCached;
-            xmlSchemaIDCFreeMatcherList(tmp);
-        }
-        vctxt->idcMatcherCache = NULL;
-    }
-
-
-    if (vctxt->idcNodes != NULL) {
-        int i;
-        xmlSchemaPSVIIDCNodePtr item;
-
-        for (i = 0; i < vctxt->nbIdcNodes; i++) {
-            item = vctxt->idcNodes[i];
-            xmlFree(item->keys);
-            xmlFree(item);
-        }
-        xmlFree(vctxt->idcNodes);
-        vctxt->idcNodes = NULL;
-        vctxt->nbIdcNodes = 0;
-        vctxt->sizeIdcNodes = 0;
-    }
-    /*
-    * Note that we won't delete the XPath state pool here.
-    */
-    if (vctxt->xpathStates != NULL) {
-        xmlSchemaFreeIDCStateObjList(vctxt->xpathStates);
-        vctxt->xpathStates = NULL;
-    }
-    /*
-    * Attribute info.
-    */
-    if (vctxt->nbAttrInfos != 0) {
-        xmlSchemaClearAttrInfos(vctxt);
-    }
-    /*
-    * Element info.
-    */
-    if (vctxt->elemInfos != NULL) {
-        int i;
-        xmlSchemaNodeInfoPtr ei;
-
-        for (i = 0; i < vctxt->sizeElemInfos; i++) {
-            ei = vctxt->elemInfos[i];
-            if (ei == NULL)
-                break;
-            xmlSchemaClearElemInfo(vctxt, ei);
-        }
-    }
-    xmlSchemaItemListClear(vctxt->nodeQNames);
-    /* Recreate the dict. */
-    xmlDictFree(vctxt->dict);
-    /*
-    * TODO: Is is save to recreate it? Do we have a scenario
-    * where the user provides the dict?
-    */
-    vctxt->dict = xmlDictCreate();
-
-    if (vctxt->filename != NULL) {
-        xmlFree(vctxt->filename);
-        vctxt->filename = NULL;
-    }
-}
-
-/**
- * xmlSchemaFreeValidCtxt:
- * @ctxt:  the schema validation context
- *
- * Free the resources associated to the schema validation context
- */
-void
-xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
-{
-    if (ctxt == NULL)
-        return;
-    if (ctxt->value != NULL)
-        xmlSchemaFreeValue(ctxt->value);
-    if (ctxt->pctxt != NULL)
-        xmlSchemaFreeParserCtxt(ctxt->pctxt);
-    if (ctxt->idcNodes != NULL) {
-        int i;
-        xmlSchemaPSVIIDCNodePtr item;
-
-        for (i = 0; i < ctxt->nbIdcNodes; i++) {
-            item = ctxt->idcNodes[i];
-            xmlFree(item->keys);
-            xmlFree(item);
-        }
-        xmlFree(ctxt->idcNodes);
-    }
-    if (ctxt->idcKeys != NULL) {
-        int i;
-        for (i = 0; i < ctxt->nbIdcKeys; i++)
-            xmlSchemaIDCFreeKey(ctxt->idcKeys[i]);
-        xmlFree(ctxt->idcKeys);
-    }
-
-    if (ctxt->xpathStates != NULL) {
-        xmlSchemaFreeIDCStateObjList(ctxt->xpathStates);
-        ctxt->xpathStates = NULL;
-    }
-    if (ctxt->xpathStatePool != NULL) {
-        xmlSchemaFreeIDCStateObjList(ctxt->xpathStatePool);
-        ctxt->xpathStatePool = NULL;
-    }
-
-    /*
-    * Augmented IDC information.
-    */
-    if (ctxt->aidcs != NULL) {
-        xmlSchemaIDCAugPtr cur = ctxt->aidcs, next;
-        do {
-            next = cur->next;
-            xmlFree(cur);
-            cur = next;
-        } while (cur != NULL);
-    }
-    if (ctxt->attrInfos != NULL) {
-        int i;
-        xmlSchemaAttrInfoPtr attr;
-
-        /* Just a paranoid call to the cleanup. */
-        if (ctxt->nbAttrInfos != 0)
-            xmlSchemaClearAttrInfos(ctxt);
-        for (i = 0; i < ctxt->sizeAttrInfos; i++) {
-            attr = ctxt->attrInfos[i];
-            xmlFree(attr);
-        }
-        xmlFree(ctxt->attrInfos);
-    }
-    if (ctxt->elemInfos != NULL) {
-        int i;
-        xmlSchemaNodeInfoPtr ei;
-
-        for (i = 0; i < ctxt->sizeElemInfos; i++) {
-            ei = ctxt->elemInfos[i];
-            if (ei == NULL)
-                break;
-            xmlSchemaClearElemInfo(ctxt, ei);
-            xmlFree(ei);
-        }
-        xmlFree(ctxt->elemInfos);
-    }
-    if (ctxt->nodeQNames != NULL)
-        xmlSchemaItemListFree(ctxt->nodeQNames);
-    if (ctxt->dict != NULL)
-        xmlDictFree(ctxt->dict);
-    if (ctxt->filename != NULL)
-        xmlFree(ctxt->filename);
-    xmlFree(ctxt);
-}
-
-/**
- * xmlSchemaIsValid:
- * @ctxt: the schema validation context
- *
- * Check if any error was detected during validation.
- *
- * Returns 1 if valid so far, 0 if errors were detected, and -1 in case
- *         of internal error.
- */
-int
-xmlSchemaIsValid(xmlSchemaValidCtxtPtr ctxt)
-{
-    if (ctxt == NULL)
-        return(-1);
-    return(ctxt->err == 0);
-}
-
-/**
- * xmlSchemaSetValidErrors:
- * @ctxt:  a schema validation context
- * @err:  the error function
- * @warn: the warning function
- * @ctx: the functions context
- *
- * Set the error and warning callback informations
- */
-void
-xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt,
-                        xmlSchemaValidityErrorFunc err,
-                        xmlSchemaValidityWarningFunc warn, void *ctx)
-{
-    if (ctxt == NULL)
-        return;
-    ctxt->error = err;
-    ctxt->warning = warn;
-    ctxt->errCtxt = ctx;
-    if (ctxt->pctxt != NULL)
-        xmlSchemaSetParserErrors(ctxt->pctxt, err, warn, ctx);
-}
-
-/**
- * xmlSchemaSetValidStructuredErrors:
- * @ctxt:  a schema validation context
- * @serror:  the structured error function
- * @ctx: the functions context
- *
- * Set the structured error callback
- */
-void
-xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
-                                  xmlStructuredErrorFunc serror, void *ctx)
-{
-    if (ctxt == NULL)
-        return;
-        ctxt->serror = serror;
-    ctxt->error = NULL;
-    ctxt->warning = NULL;
-    ctxt->errCtxt = ctx;
-    if (ctxt->pctxt != NULL)
-        xmlSchemaSetParserStructuredErrors(ctxt->pctxt, serror, ctx);
-}
-
-/**
- * xmlSchemaGetValidErrors:
- * @ctxt: a XML-Schema validation context
- * @err: the error function result
- * @warn: the warning function result
- * @ctx: the functions context result
- *
- * Get the error and warning callback informations
- *
- * Returns -1 in case of error and 0 otherwise
- */
-int
-xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt,
-                        xmlSchemaValidityErrorFunc * err,
-                        xmlSchemaValidityWarningFunc * warn, void **ctx)
-{
-        if (ctxt == NULL)
-                return (-1);
-        if (err != NULL)
-                *err = ctxt->error;
-        if (warn != NULL)
-                *warn = ctxt->warning;
-        if (ctx != NULL)
-                *ctx = ctxt->errCtxt;
-        return (0);
-}
-
-
-/**
- * xmlSchemaSetValidOptions:
- * @ctxt:       a schema validation context
- * @options: a combination of xmlSchemaValidOption
- *
- * Sets the options to be used during the validation.
- *
- * Returns 0 in case of success, -1 in case of an
- * API error.
- */
-int
-xmlSchemaSetValidOptions(xmlSchemaValidCtxtPtr ctxt,
-                         int options)
-
-{
-    int i;
-
-    if (ctxt == NULL)
-        return (-1);
-    /*
-    * WARNING: Change the start value if adding to the
-    * xmlSchemaValidOption.
-    * TODO: Is there an other, more easy to maintain,
-    * way?
-    */
-    for (i = 1; i < (int) sizeof(int) * 8; i++) {
-        if (options & 1<<i)
-            return (-1);
-    }
-    ctxt->options = options;
-    return (0);
-}
-
-/**
- * xmlSchemaValidCtxtGetOptions:
- * @ctxt: a schema validation context
- *
- * Get the validation context options.
- *
- * Returns the option combination or -1 on error.
- */
-int
-xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt)
-
-{
-    if (ctxt == NULL)
-        return (-1);
-    else
-        return (ctxt->options);
-}
-
-static int
-xmlSchemaVDocWalk(xmlSchemaValidCtxtPtr vctxt)
-{
-    xmlAttrPtr attr;
-    int ret = 0;
-    xmlSchemaNodeInfoPtr ielem = NULL;
-    xmlNodePtr node, valRoot;
-    const xmlChar *nsName;
-
-    /* DOC VAL TODO: Move this to the start function. */
-    if (vctxt->validationRoot != NULL)
-        valRoot = vctxt->validationRoot;
-    else
-        valRoot = xmlDocGetRootElement(vctxt->doc);
-    if (valRoot == NULL) {
-        /* VAL TODO: Error code? */
-        VERROR(1, NULL, "The document has no document element");
-        return (1);
-    }
-    vctxt->depth = -1;
-    vctxt->validationRoot = valRoot;
-    node = valRoot;
-    while (node != NULL) {
-        if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
-            goto next_sibling;
-        if (node->type == XML_ELEMENT_NODE) {
-
-            /*
-            * Init the node-info.
-            */
-            vctxt->depth++;
-            if (xmlSchemaValidatorPushElem(vctxt) == -1)
-                goto internal_error;
-            ielem = vctxt->inode;
-            ielem->node = node;
-            ielem->nodeLine = node->line;
-            ielem->localName = node->name;
-            if (node->ns != NULL)
-                ielem->nsName = node->ns->href;
-            ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
-            /*
-            * Register attributes.
-            * DOC VAL TODO: We do not register namespace declaration
-            * attributes yet.
-            */
-            vctxt->nbAttrInfos = 0;
-            if (node->properties != NULL) {
-                attr = node->properties;
-                do {
-                    if (attr->ns != NULL)
-                        nsName = attr->ns->href;
-                    else
-                        nsName = NULL;
-                    ret = xmlSchemaValidatorPushAttribute(vctxt,
-                        (xmlNodePtr) attr,
-                        /*
-                        * Note that we give it the line number of the
-                        * parent element.
-                        */
-                        ielem->nodeLine,
-                        attr->name, nsName, 0,
-                        xmlNodeListGetString(attr->doc, attr->children, 1), 1);
-                    if (ret == -1) {
-                        VERROR_INT("xmlSchemaDocWalk",
-                            "calling xmlSchemaValidatorPushAttribute()");
-                        goto internal_error;
-                    }
-                    attr = attr->next;
-                } while (attr);
-            }
-            /*
-            * Validate the element.
-            */
-            ret = xmlSchemaValidateElem(vctxt);
-            if (ret != 0) {
-                if (ret == -1) {
-                    VERROR_INT("xmlSchemaDocWalk",
-                        "calling xmlSchemaValidateElem()");
-                    goto internal_error;
-                }
-                /*
-                * Don't stop validation; just skip the content
-                * of this element.
-                */
-                goto leave_node;
-            }
-            if ((vctxt->skipDepth != -1) &&
-                (vctxt->depth >= vctxt->skipDepth))
-                goto leave_node;
-        } else if ((node->type == XML_TEXT_NODE) ||
-            (node->type == XML_CDATA_SECTION_NODE)) {
-            /*
-            * Process character content.
-            */
-            if ((ielem != NULL) && (ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY))
-                ielem->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
-            ret = xmlSchemaVPushText(vctxt, node->type, node->content,
-                -1, XML_SCHEMA_PUSH_TEXT_PERSIST, NULL);
-            if (ret < 0) {
-                VERROR_INT("xmlSchemaVDocWalk",
-                    "calling xmlSchemaVPushText()");
-                goto internal_error;
-            }
-            /*
-            * DOC VAL TODO: Should we skip further validation of the
-            * element content here?
-            */
-        } else if ((node->type == XML_ENTITY_NODE) ||
-            (node->type == XML_ENTITY_REF_NODE)) {
-            /*
-            * DOC VAL TODO: What to do with entities?
-            */
-            VERROR_INT("xmlSchemaVDocWalk",
-                "there is at least one entity reference in the node-tree "
-                "currently being validated. Processing of entities with "
-                "this XML Schema processor is not supported (yet). Please "
-                "substitute entities before validation.");
-            goto internal_error;
-        } else {
-            goto leave_node;
-            /*
-            * DOC VAL TODO: XInclude nodes, etc.
-            */
-        }
-        /*
-        * Walk the doc.
-        */
-        if (node->children != NULL) {
-            node = node->children;
-            continue;
-        }
-leave_node:
-        if (node->type == XML_ELEMENT_NODE) {
-            /*
-            * Leaving the scope of an element.
-            */
-            if (node != vctxt->inode->node) {
-                VERROR_INT("xmlSchemaVDocWalk",
-                    "element position mismatch");
-                goto internal_error;
-            }
-            ret = xmlSchemaValidatorPopElem(vctxt);
-            if (ret != 0) {
-                if (ret < 0) {
-                    VERROR_INT("xmlSchemaVDocWalk",
-                        "calling xmlSchemaValidatorPopElem()");
-                    goto internal_error;
-                }
-            }
-            if (node == valRoot)
-                goto exit;
-        }
-next_sibling:
-        if (node->next != NULL)
-            node = node->next;
-        else {
-            node = node->parent;
-            goto leave_node;
-        }
-    }
-
-exit:
-    return (ret);
-internal_error:
-    return (-1);
-}
-
-static int
-xmlSchemaPreRun(xmlSchemaValidCtxtPtr vctxt) {
-    /*
-    * Some initialization.
-    */
-    vctxt->err = 0;
-    vctxt->nberrors = 0;
-    vctxt->depth = -1;
-    vctxt->skipDepth = -1;
-    vctxt->xsiAssemble = 0;
-    vctxt->hasKeyrefs = 0;
-#ifdef ENABLE_IDC_NODE_TABLES_TEST
-    vctxt->createIDCNodeTables = 1;
-#else
-    vctxt->createIDCNodeTables = 0;
-#endif
-    /*
-    * Create a schema + parser if necessary.
-    */
-    if (vctxt->schema == NULL) {
-        xmlSchemaParserCtxtPtr pctxt;
-
-        vctxt->xsiAssemble = 1;
-        /*
-        * If not schema was given then we will create a schema
-        * dynamically using XSI schema locations.
-        *
-        * Create the schema parser context.
-        */
-        if ((vctxt->pctxt == NULL) &&
-           (xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1))
-           return (-1);
-        pctxt = vctxt->pctxt;
-        pctxt->xsiAssemble = 1;
-        /*
-        * Create the schema.
-        */
-        vctxt->schema = xmlSchemaNewSchema(pctxt);
-        if (vctxt->schema == NULL)
-            return (-1);
-        /*
-        * Create the schema construction context.
-        */
-        pctxt->constructor = xmlSchemaConstructionCtxtCreate(pctxt->dict);
-        if (pctxt->constructor == NULL)
-            return(-1);
-        pctxt->constructor->mainSchema = vctxt->schema;
-        /*
-        * Take ownership of the constructor to be able to free it.
-        */
-        pctxt->ownsConstructor = 1;
-    }
-    /*
-    * Augment the IDC definitions for the main schema and all imported ones
-    * NOTE: main schema if the first in the imported list
-    */
-    xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
-
-    return(0);
-}
-
-static void
-xmlSchemaPostRun(xmlSchemaValidCtxtPtr vctxt) {
-    if (vctxt->xsiAssemble) {
-        if (vctxt->schema != NULL) {
-            xmlSchemaFree(vctxt->schema);
-            vctxt->schema = NULL;
-        }
-    }
-    xmlSchemaClearValidCtxt(vctxt);
-}
-
-static int
-xmlSchemaVStart(xmlSchemaValidCtxtPtr vctxt)
-{
-    int ret = 0;
-
-    if (xmlSchemaPreRun(vctxt) < 0)
-        return(-1);
-
-    if (vctxt->doc != NULL) {
-        /*
-         * Tree validation.
-         */
-        ret = xmlSchemaVDocWalk(vctxt);
-#ifdef LIBXML_READER_ENABLED
-    } else if (vctxt->reader != NULL) {
-        /*
-         * XML Reader validation.
-         */
-#ifdef XML_SCHEMA_READER_ENABLED
-        ret = xmlSchemaVReaderWalk(vctxt);
-#endif
-#endif
-    } else if ((vctxt->sax != NULL) && (vctxt->parserCtxt != NULL)) {
-        /*
-         * SAX validation.
-         */
-        ret = xmlParseDocument(vctxt->parserCtxt);
-    } else {
-        VERROR_INT("xmlSchemaVStart",
-            "no instance to validate");
-        ret = -1;
-    }
-
-    xmlSchemaPostRun(vctxt);
-    if (ret == 0)
-        ret = vctxt->err;
-    return (ret);
-}
-
-/**
- * xmlSchemaValidateOneElement:
- * @ctxt:  a schema validation context
- * @elem:  an element node
- *
- * Validate a branch of a tree, starting with the given @elem.
- *
- * Returns 0 if the element and its subtree is valid, a positive error
- * code number otherwise and -1 in case of an internal or API error.
- */
-int
-xmlSchemaValidateOneElement(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem)
-{
-    if ((ctxt == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE))
-        return (-1);
-
-    if (ctxt->schema == NULL)
-        return (-1);
-
-    ctxt->doc = elem->doc;
-    ctxt->node = elem;
-    ctxt->validationRoot = elem;
-    return(xmlSchemaVStart(ctxt));
-}
-
-/**
- * xmlSchemaValidateDoc:
- * @ctxt:  a schema validation context
- * @doc:  a parsed document tree
- *
- * Validate a document tree in memory.
- *
- * Returns 0 if the document is schemas valid, a positive error code
- *     number otherwise and -1 in case of internal or API error.
- */
-int
-xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
-{
-    if ((ctxt == NULL) || (doc == NULL))
-        return (-1);
-
-    ctxt->doc = doc;
-    ctxt->node = xmlDocGetRootElement(doc);
-    if (ctxt->node == NULL) {
-        xmlSchemaCustomErr(ACTXT_CAST ctxt,
-            XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
-            (xmlNodePtr) doc, NULL,
-            "The document has no document element", NULL, NULL);
-        return (ctxt->err);
-    }
-    ctxt->validationRoot = ctxt->node;
-    return (xmlSchemaVStart(ctxt));
-}
-
-
-/************************************************************************
- *                                                                      *
- *              Function and data for SAX streaming API                 *
- *                                                                      *
- ************************************************************************/
-typedef struct _xmlSchemaSplitSAXData xmlSchemaSplitSAXData;
-typedef xmlSchemaSplitSAXData *xmlSchemaSplitSAXDataPtr;
-
-struct _xmlSchemaSplitSAXData {
-    xmlSAXHandlerPtr      user_sax;
-    void                 *user_data;
-    xmlSchemaValidCtxtPtr ctxt;
-    xmlSAXHandlerPtr      schemas_sax;
-};
-
-#define XML_SAX_PLUG_MAGIC 0xdc43ba21
-
-struct _xmlSchemaSAXPlug {
-    unsigned int magic;
-
-    /* the original callbacks informations */
-    xmlSAXHandlerPtr     *user_sax_ptr;
-    xmlSAXHandlerPtr      user_sax;
-    void                **user_data_ptr;
-    void                 *user_data;
-
-    /* the block plugged back and validation informations */
-    xmlSAXHandler         schemas_sax;
-    xmlSchemaValidCtxtPtr ctxt;
-};
-
-/* All those functions just bounces to the user provided SAX handlers */
-static void
-internalSubsetSplit(void *ctx, const xmlChar *name,
-               const xmlChar *ExternalID, const xmlChar *SystemID)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->internalSubset != NULL))
-        ctxt->user_sax->internalSubset(ctxt->user_data, name, ExternalID,
-                                       SystemID);
-}
-
-static int
-isStandaloneSplit(void *ctx)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->isStandalone != NULL))
-        return(ctxt->user_sax->isStandalone(ctxt->user_data));
-    return(0);
-}
-
-static int
-hasInternalSubsetSplit(void *ctx)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->hasInternalSubset != NULL))
-        return(ctxt->user_sax->hasInternalSubset(ctxt->user_data));
-    return(0);
-}
-
-static int
-hasExternalSubsetSplit(void *ctx)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->hasExternalSubset != NULL))
-        return(ctxt->user_sax->hasExternalSubset(ctxt->user_data));
-    return(0);
-}
-
-static void
-externalSubsetSplit(void *ctx, const xmlChar *name,
-               const xmlChar *ExternalID, const xmlChar *SystemID)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->externalSubset != NULL))
-        ctxt->user_sax->externalSubset(ctxt->user_data, name, ExternalID,
-                                       SystemID);
-}
-
-static xmlParserInputPtr
-resolveEntitySplit(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->resolveEntity != NULL))
-        return(ctxt->user_sax->resolveEntity(ctxt->user_data, publicId,
-                                             systemId));
-    return(NULL);
-}
-
-static xmlEntityPtr
-getEntitySplit(void *ctx, const xmlChar *name)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->getEntity != NULL))
-        return(ctxt->user_sax->getEntity(ctxt->user_data, name));
-    return(NULL);
-}
-
-static xmlEntityPtr
-getParameterEntitySplit(void *ctx, const xmlChar *name)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->getParameterEntity != NULL))
-        return(ctxt->user_sax->getParameterEntity(ctxt->user_data, name));
-    return(NULL);
-}
-
-
-static void
-entityDeclSplit(void *ctx, const xmlChar *name, int type,
-          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->entityDecl != NULL))
-        ctxt->user_sax->entityDecl(ctxt->user_data, name, type, publicId,
-                                   systemId, content);
-}
-
-static void
-attributeDeclSplit(void *ctx, const xmlChar * elem,
-                   const xmlChar * name, int type, int def,
-                   const xmlChar * defaultValue, xmlEnumerationPtr tree)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->attributeDecl != NULL)) {
-        ctxt->user_sax->attributeDecl(ctxt->user_data, elem, name, type,
-                                      def, defaultValue, tree);
-    } else {
-        xmlFreeEnumeration(tree);
-    }
-}
-
-static void
-elementDeclSplit(void *ctx, const xmlChar *name, int type,
-            xmlElementContentPtr content)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->elementDecl != NULL))
-        ctxt->user_sax->elementDecl(ctxt->user_data, name, type, content);
-}
-
-static void
-notationDeclSplit(void *ctx, const xmlChar *name,
-             const xmlChar *publicId, const xmlChar *systemId)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->notationDecl != NULL))
-        ctxt->user_sax->notationDecl(ctxt->user_data, name, publicId,
-                                     systemId);
-}
-
-static void
-unparsedEntityDeclSplit(void *ctx, const xmlChar *name,
-                   const xmlChar *publicId, const xmlChar *systemId,
-                   const xmlChar *notationName)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->unparsedEntityDecl != NULL))
-        ctxt->user_sax->unparsedEntityDecl(ctxt->user_data, name, publicId,
-                                           systemId, notationName);
-}
-
-static void
-setDocumentLocatorSplit(void *ctx, xmlSAXLocatorPtr loc)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->setDocumentLocator != NULL))
-        ctxt->user_sax->setDocumentLocator(ctxt->user_data, loc);
-}
-
-static void
-startDocumentSplit(void *ctx)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->startDocument != NULL))
-        ctxt->user_sax->startDocument(ctxt->user_data);
-}
-
-static void
-endDocumentSplit(void *ctx)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->endDocument != NULL))
-        ctxt->user_sax->endDocument(ctxt->user_data);
-}
-
-static void
-processingInstructionSplit(void *ctx, const xmlChar *target,
-                      const xmlChar *data)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->processingInstruction != NULL))
-        ctxt->user_sax->processingInstruction(ctxt->user_data, target, data);
-}
-
-static void
-commentSplit(void *ctx, const xmlChar *value)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->comment != NULL))
-        ctxt->user_sax->comment(ctxt->user_data, value);
-}
-
-/*
- * Varargs error callbacks to the user application, harder ...
- */
-
-static void XMLCDECL
-warningSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->warning != NULL)) {
-        TODO
-    }
-}
-static void XMLCDECL
-errorSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->error != NULL)) {
-        TODO
-    }
-}
-static void XMLCDECL
-fatalErrorSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->fatalError != NULL)) {
-        TODO
-    }
-}
-
-/*
- * Those are function where both the user handler and the schemas handler
- * need to be called.
- */
-static void
-charactersSplit(void *ctx, const xmlChar *ch, int len)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt->user_sax != NULL) && (ctxt->user_sax->characters != NULL))
-        ctxt->user_sax->characters(ctxt->user_data, ch, len);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleText(ctxt->ctxt, ch, len);
-}
-
-static void
-ignorableWhitespaceSplit(void *ctx, const xmlChar *ch, int len)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->ignorableWhitespace != NULL))
-        ctxt->user_sax->ignorableWhitespace(ctxt->user_data, ch, len);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleText(ctxt->ctxt, ch, len);
-}
-
-static void
-cdataBlockSplit(void *ctx, const xmlChar *value, int len)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->cdataBlock != NULL))
-        ctxt->user_sax->cdataBlock(ctxt->user_data, value, len);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleCDataSection(ctxt->ctxt, value, len);
-}
-
-static void
-referenceSplit(void *ctx, const xmlChar *name)
-{
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->reference != NULL))
-        ctxt->user_sax->reference(ctxt->user_data, name);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleReference(ctxt->user_data, name);
-}
-
-static void
-startElementNsSplit(void *ctx, const xmlChar * localname,
-                    const xmlChar * prefix, const xmlChar * URI,
-                    int nb_namespaces, const xmlChar ** namespaces,
-                    int nb_attributes, int nb_defaulted,
-                    const xmlChar ** attributes) {
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->startElementNs != NULL))
-        ctxt->user_sax->startElementNs(ctxt->user_data, localname, prefix,
-                                       URI, nb_namespaces, namespaces,
-                                       nb_attributes, nb_defaulted,
-                                       attributes);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleStartElementNs(ctxt->ctxt, localname, prefix,
-                                         URI, nb_namespaces, namespaces,
-                                         nb_attributes, nb_defaulted,
-                                         attributes);
-}
-
-static void
-endElementNsSplit(void *ctx, const xmlChar * localname,
-                    const xmlChar * prefix, const xmlChar * URI) {
-    xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
-    if (ctxt == NULL)
-        return;
-    if ((ctxt->user_sax != NULL) &&
-        (ctxt->user_sax->endElementNs != NULL))
-        ctxt->user_sax->endElementNs(ctxt->user_data, localname, prefix, URI);
-    if (ctxt->ctxt != NULL)
-        xmlSchemaSAXHandleEndElementNs(ctxt->ctxt, localname, prefix, URI);
-}
-
-/**
- * xmlSchemaSAXPlug:
- * @ctxt:  a schema validation context
- * @sax:  a pointer to the original xmlSAXHandlerPtr
- * @user_data:  a pointer to the original SAX user data pointer
- *
- * Plug a SAX based validation layer in a SAX parsing event flow.
- * The original @saxptr and @dataptr data are replaced by new pointers
- * but the calls to the original will be maintained.
- *
- * Returns a pointer to a data structure needed to unplug the validation layer
- *         or NULL in case of errors.
- */
-xmlSchemaSAXPlugPtr
-xmlSchemaSAXPlug(xmlSchemaValidCtxtPtr ctxt,
-                 xmlSAXHandlerPtr *sax, void **user_data)
-{
-    xmlSchemaSAXPlugPtr ret;
-    xmlSAXHandlerPtr old_sax;
-
-    if ((ctxt == NULL) || (sax == NULL) || (user_data == NULL))
-        return(NULL);
-
-    /*
-     * We only allow to plug into SAX2 event streams
-     */
-    old_sax = *sax;
-    if ((old_sax != NULL) && (old_sax->initialized != XML_SAX2_MAGIC))
-        return(NULL);
-    if ((old_sax != NULL) &&
-        (old_sax->startElementNs == NULL) && (old_sax->endElementNs == NULL) &&
-        ((old_sax->startElement != NULL) || (old_sax->endElement != NULL)))
-        return(NULL);
-
-    /*
-     * everything seems right allocate the local data needed for that layer
-     */
-    ret = (xmlSchemaSAXPlugPtr) xmlMalloc(sizeof(xmlSchemaSAXPlugStruct));
-    if (ret == NULL) {
-        return(NULL);
-    }
-    memset(ret, 0, sizeof(xmlSchemaSAXPlugStruct));
-    ret->magic = XML_SAX_PLUG_MAGIC;
-    ret->schemas_sax.initialized = XML_SAX2_MAGIC;
-    ret->ctxt = ctxt;
-    ret->user_sax_ptr = sax;
-    ret->user_sax = old_sax;
-    if (old_sax == NULL) {
-        /*
-         * go direct, no need for the split block and functions.
-         */
-        ret->schemas_sax.startElementNs = xmlSchemaSAXHandleStartElementNs;
-        ret->schemas_sax.endElementNs = xmlSchemaSAXHandleEndElementNs;
-        /*
-         * Note that we use the same text-function for both, to prevent
-         * the parser from testing for ignorable whitespace.
-         */
-        ret->schemas_sax.ignorableWhitespace = xmlSchemaSAXHandleText;
-        ret->schemas_sax.characters = xmlSchemaSAXHandleText;
-
-        ret->schemas_sax.cdataBlock = xmlSchemaSAXHandleCDataSection;
-        ret->schemas_sax.reference = xmlSchemaSAXHandleReference;
-
-        ret->user_data = ctxt;
-        *user_data = ctxt;
-    } else {
-       /*
-        * for each callback unused by Schemas initialize it to the Split
-        * routine only if non NULL in the user block, this can speed up
-        * things at the SAX level.
-        */
-        if (old_sax->internalSubset != NULL)
-            ret->schemas_sax.internalSubset = internalSubsetSplit;
-        if (old_sax->isStandalone != NULL)
-            ret->schemas_sax.isStandalone = isStandaloneSplit;
-        if (old_sax->hasInternalSubset != NULL)
-            ret->schemas_sax.hasInternalSubset = hasInternalSubsetSplit;
-        if (old_sax->hasExternalSubset != NULL)
-            ret->schemas_sax.hasExternalSubset = hasExternalSubsetSplit;
-        if (old_sax->resolveEntity != NULL)
-            ret->schemas_sax.resolveEntity = resolveEntitySplit;
-        if (old_sax->getEntity != NULL)
-            ret->schemas_sax.getEntity = getEntitySplit;
-        if (old_sax->entityDecl != NULL)
-            ret->schemas_sax.entityDecl = entityDeclSplit;
-        if (old_sax->notationDecl != NULL)
-            ret->schemas_sax.notationDecl = notationDeclSplit;
-        if (old_sax->attributeDecl != NULL)
-            ret->schemas_sax.attributeDecl = attributeDeclSplit;
-        if (old_sax->elementDecl != NULL)
-            ret->schemas_sax.elementDecl = elementDeclSplit;
-        if (old_sax->unparsedEntityDecl != NULL)
-            ret->schemas_sax.unparsedEntityDecl = unparsedEntityDeclSplit;
-        if (old_sax->setDocumentLocator != NULL)
-            ret->schemas_sax.setDocumentLocator = setDocumentLocatorSplit;
-        if (old_sax->startDocument != NULL)
-            ret->schemas_sax.startDocument = startDocumentSplit;
-        if (old_sax->endDocument != NULL)
-            ret->schemas_sax.endDocument = endDocumentSplit;
-        if (old_sax->processingInstruction != NULL)
-            ret->schemas_sax.processingInstruction = processingInstructionSplit;
-        if (old_sax->comment != NULL)
-            ret->schemas_sax.comment = commentSplit;
-        if (old_sax->warning != NULL)
-            ret->schemas_sax.warning = warningSplit;
-        if (old_sax->error != NULL)
-            ret->schemas_sax.error = errorSplit;
-        if (old_sax->fatalError != NULL)
-            ret->schemas_sax.fatalError = fatalErrorSplit;
-        if (old_sax->getParameterEntity != NULL)
-            ret->schemas_sax.getParameterEntity = getParameterEntitySplit;
-        if (old_sax->externalSubset != NULL)
-            ret->schemas_sax.externalSubset = externalSubsetSplit;
-
-        /*
-         * the 6 schemas callback have to go to the splitter functions
-         * Note that we use the same text-function for ignorableWhitespace
-         * if possible, to prevent the parser from testing for ignorable
-         * whitespace.
-         */
-        ret->schemas_sax.characters = charactersSplit;
-        if ((old_sax->ignorableWhitespace != NULL) &&
-            (old_sax->ignorableWhitespace != old_sax->characters))
-            ret->schemas_sax.ignorableWhitespace = ignorableWhitespaceSplit;
-        else
-            ret->schemas_sax.ignorableWhitespace = charactersSplit;
-        ret->schemas_sax.cdataBlock = cdataBlockSplit;
-        ret->schemas_sax.reference = referenceSplit;
-        ret->schemas_sax.startElementNs = startElementNsSplit;
-        ret->schemas_sax.endElementNs = endElementNsSplit;
-
-        ret->user_data_ptr = user_data;
-        ret->user_data = *user_data;
-        *user_data = ret;
-    }
-
-    /*
-     * plug the pointers back.
-     */
-    *sax = &(ret->schemas_sax);
-    ctxt->sax = *sax;
-    ctxt->flags |= XML_SCHEMA_VALID_CTXT_FLAG_STREAM;
-    xmlSchemaPreRun(ctxt);
-    return(ret);
-}
-
-/**
- * xmlSchemaSAXUnplug:
- * @plug:  a data structure returned by xmlSchemaSAXPlug
- *
- * Unplug a SAX based validation layer in a SAX parsing event flow.
- * The original pointers used in the call are restored.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-int
-xmlSchemaSAXUnplug(xmlSchemaSAXPlugPtr plug)
-{
-    xmlSAXHandlerPtr *sax;
-    void **user_data;
-
-    if ((plug == NULL) || (plug->magic != XML_SAX_PLUG_MAGIC))
-        return(-1);
-    plug->magic = 0;
-
-    xmlSchemaPostRun(plug->ctxt);
-    /* restore the data */
-    sax = plug->user_sax_ptr;
-    *sax = plug->user_sax;
-    if (plug->user_sax != NULL) {
-        user_data = plug->user_data_ptr;
-        *user_data = plug->user_data;
-    }
-
-    /* free and return */
-    xmlFree(plug);
-    return(0);
-}
-
-/**
- * xmlSchemaValidateSetLocator:
- * @vctxt: a schema validation context
- * @f: the locator function pointer
- * @ctxt: the locator context
- *
- * Allows to set a locator function to the validation context,
- * which will be used to provide file and line information since
- * those are not provided as part of the SAX validation flow
- * Setting @f to NULL disable the locator.
- */
-
-void
-xmlSchemaValidateSetLocator(xmlSchemaValidCtxtPtr vctxt,
-                            xmlSchemaValidityLocatorFunc f,
-                            void *ctxt)
-{
-    if (vctxt == NULL) return;
-    vctxt->locFunc = f;
-    vctxt->locCtxt = ctxt;
-}
-
-/**
- * xmlSchemaValidateStreamLocator:
- * @ctx: the xmlTextReaderPtr used
- * @file: returned file information
- * @line: returned line information
- *
- * Internal locator function for the readers
- *
- * Returns 0 in case the Schema validation could be (des)activated and
- *         -1 in case of error.
- */
-static int
-xmlSchemaValidateStreamLocator(void *ctx, const char **file,
-                               unsigned long *line) {
-    xmlParserCtxtPtr ctxt;
-
-    if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
-        return(-1);
-
-    if (file != NULL)
-        *file = NULL;
-    if (line != NULL)
-        *line = 0;
-
-    ctxt = (xmlParserCtxtPtr) ctx;
-    if (ctxt->input != NULL) {
-       if (file != NULL)
-           *file = ctxt->input->filename;
-       if (line != NULL)
-           *line = ctxt->input->line;
-       return(0);
-    }
-    return(-1);
-}
-
-/**
- * xmlSchemaValidateStream:
- * @ctxt:  a schema validation context
- * @input:  the input to use for reading the data
- * @enc:  an optional encoding information
- * @sax:  a SAX handler for the resulting events
- * @user_data:  the context to provide to the SAX handler.
- *
- * Validate an input based on a flow of SAX event from the parser
- * and forward the events to the @sax handler with the provided @user_data
- * the user provided @sax handler must be a SAX2 one.
- *
- * Returns 0 if the document is schemas valid, a positive error code
- *     number otherwise and -1 in case of internal or API error.
- */
-int
-xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt,
-                        xmlParserInputBufferPtr input, xmlCharEncoding enc,
-                        xmlSAXHandlerPtr sax, void *user_data)
-{
-    xmlSchemaSAXPlugPtr plug = NULL;
-    xmlSAXHandlerPtr old_sax = NULL;
-    xmlParserCtxtPtr pctxt = NULL;
-    xmlParserInputPtr inputStream = NULL;
-    int ret;
-
-    if ((ctxt == NULL) || (input == NULL))
-        return (-1);
-
-    /*
-     * prepare the parser
-     */
-    pctxt = xmlNewParserCtxt();
-    if (pctxt == NULL)
-        return (-1);
-    old_sax = pctxt->sax;
-    pctxt->sax = sax;
-    pctxt->userData = user_data;
-#if 0
-    if (options)
-        xmlCtxtUseOptions(pctxt, options);
-#endif
-    pctxt->linenumbers = 1;
-    xmlSchemaValidateSetLocator(ctxt, xmlSchemaValidateStreamLocator, pctxt);
-
-    inputStream = xmlNewIOInputStream(pctxt, input, enc);;
-    if (inputStream == NULL) {
-        ret = -1;
-        goto done;
-    }
-    inputPush(pctxt, inputStream);
-    ctxt->parserCtxt = pctxt;
-    ctxt->input = input;
-
-    /*
-     * Plug the validation and launch the parsing
-     */
-    plug = xmlSchemaSAXPlug(ctxt, &(pctxt->sax), &(pctxt->userData));
-    if (plug == NULL) {
-        ret = -1;
-        goto done;
-    }
-    ctxt->input = input;
-    ctxt->enc = enc;
-    ctxt->sax = pctxt->sax;
-    ctxt->flags |= XML_SCHEMA_VALID_CTXT_FLAG_STREAM;
-    ret = xmlSchemaVStart(ctxt);
-
-    if ((ret == 0) && (! ctxt->parserCtxt->wellFormed)) {
-        ret = ctxt->parserCtxt->errNo;
-        if (ret == 0)
-            ret = 1;
-    }
-
-done:
-    ctxt->parserCtxt = NULL;
-    ctxt->sax = NULL;
-    ctxt->input = NULL;
-    if (plug != NULL) {
-        xmlSchemaSAXUnplug(plug);
-    }
-    /* cleanup */
-    if (pctxt != NULL) {
-        pctxt->sax = old_sax;
-        xmlFreeParserCtxt(pctxt);
-    }
-    return (ret);
-}
-
-/**
- * xmlSchemaValidateFile:
- * @ctxt: a schema validation context
- * @filename: the URI of the instance
- * @options: a future set of options, currently unused
- *
- * Do a schemas validation of the given resource, it will use the
- * SAX streamable validation internally.
- *
- * Returns 0 if the document is valid, a positive error code
- *     number otherwise and -1 in case of an internal or API error.
- */
-int
-xmlSchemaValidateFile(xmlSchemaValidCtxtPtr ctxt,
-                      const char * filename,
-                      int options ATTRIBUTE_UNUSED)
-{
-    int ret;
-    xmlParserInputBufferPtr input;
-
-    if ((ctxt == NULL) || (filename == NULL))
-        return (-1);
-
-    input = xmlParserInputBufferCreateFilename(filename,
-        XML_CHAR_ENCODING_NONE);
-    if (input == NULL)
-        return (-1);
-    ret = xmlSchemaValidateStream(ctxt, input, XML_CHAR_ENCODING_NONE,
-        NULL, NULL);
-    return (ret);
-}
-
-/**
- * xmlSchemaValidCtxtGetParserCtxt:
- * @ctxt: a schema validation context
- *
- * allow access to the parser context of the schema validation context
- *
- * Returns the parser context of the schema validation context or NULL
- *         in case of error.
- */
-xmlParserCtxtPtr
-xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt)
-{
-    if (ctxt == NULL)
-        return(NULL);
-    return (ctxt->parserCtxt);
-}
-
-#define bottom_xmlschemas
-#include "elfgcchack.h"
-#endif /* LIBXML_SCHEMAS_ENABLED */