FCL/sf/mw/web: comparison webengine/osswebengine/WebCore/platform/symbian/Libxml2/Libxml2

equal deleted inserted replaced

--1:000000000000
+:dd21522fd290
+/*
+* 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.
+*/
+#define IN_LIBXML
+#include "XmlEnglibxml.h"
+#if defined(LIBXML_SCHEMAS_ENABLED) || defined(XMLENGINE_XMLSCHEMA_DATATYPES)
+#include <string.h>
+#include "Libxml2_xmlmemory.h"
+#include "Libxml2_parser.h"
+#include "Libxml2_parserInternals.h"
+#include "Libxml2_hash.h"
+#include "Libxml2_uri.h"
+#include "Libxml2_xmlschemas.h"
+#include "Libxml2_schemasInternals.h"
+#include "Libxml2_xmlschemastypes.h"
+#ifdef LIBXML_AUTOMATA_ENABLED
+#include <xmlautomata.h>
+#endif
+#ifdef LIBXML_REGEXP_ENABLED
+#include <xmlregexp.h>
+#endif
+#include "Libxml2_dict.h"
+/* #define DEBUG 1 */
+/* #define DEBUG_CONTENT 1 */
+/* #define DEBUG_TYPE 1 */
+/* #define DEBUG_CONTENT_REGEXP 1 */
+/* #define DEBUG_AUTOMATA 1 */
+#define UNBOUNDED (1 << 30)
+#define TODO                                \
+xmlGenericError(xmlGenericErrorContext,             \
+"Unimplemented block at %s:%d\n",               \
+__FILE__, __LINE__);
+#define XML_SCHEMAS_DEFAULT_NAMESPACE (const xmlChar*)"the default namespace"
+/*
+* The XML Schemas namespaces
+*/  //TODO: define exported functions that return these Or export these
+static const xmlChar* const xmlSchemaNs = (const xmlChar*)
+"http://www.w3.org/2001/XMLSchema";
+static const xmlChar* const xmlSchemaInstanceNs = (const xmlChar*)
+"http://www.w3.org/2001/XMLSchema-instance";
+/**
+* xmlSchemaFreeAnnot:
+* @annot:  a schema type structure
+*
+* Deallocate a annotation structure
+*/
+static void
+xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot)
+{
+if (annot == NULL)
+return;
+xmlFree(annot);
+}
+/**
+* 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;
+}
+}
+xmlFree(type);
+}
+/**
+* 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);
+#ifdef LIBXML_REGEXP_ENABLED
+if (facet->regexp != NULL)
+xmlRegFreeRegexp(facet->regexp);
+#endif
+if (facet->annot != NULL)
+xmlSchemaFreeAnnot(facet->annot);
+xmlFree(facet);
+}
+#endif /* defined(LIBXML_SCHEMAS_ENABLED) || defined(XMLENGINE_XMLSCHEMA_DATATYPES) */
+#ifdef LIBXML_SCHEMAS_ENABLED
+#define IS_SCHEMA(node, type)                       \
+((node != NULL) && (node->ns != NULL) &&             \
+(xmlStrEqual(node->name, (const xmlChar *) type)) &&        \
+(xmlStrEqual(node->ns->href, xmlSchemaNs)))
+#define XML_SCHEMAS_PARSE_ERROR     1
+#define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
+struct _xmlSchemaParserCtxt {
+void *userData;             /* user specific data block */
+xmlSchemaValidityErrorFunc error;   /* the callback in case of errors */
+xmlSchemaValidityWarningFunc warning;       /* the callback in case of warning */
+xmlSchemaValidError err;
+int nberrors;
+xmlStructuredErrorFunc serror;
+xmlSchemaPtr topschema; /* The main schema */
+xmlHashTablePtr namespaces; /* Hash table of namespaces to schemas */
+xmlSchemaPtr schema;        /* The schema in use */
+const xmlChar *container;   /* the current element, group, ... */
+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;        /* dictionnary for interned string names */
+int        includes;    /* the inclusion level, 0 for root or imports */
+};
+#define XML_SCHEMAS_ATTR_UNKNOWN 1
+#define XML_SCHEMAS_ATTR_CHECKED 2
+typedef struct _xmlSchemaAttrState xmlSchemaAttrState;
+typedef xmlSchemaAttrState *xmlSchemaAttrStatePtr;
+struct _xmlSchemaAttrState {
+xmlAttrPtr attr;
+int state;
+};
+/**
+* xmlSchemaValidCtxt:
+*
+* A Schemas validation context
+*/
+struct _xmlSchemaValidCtxt {
+void *userData;             /* 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;
+void *user_data;
+xmlDocPtr myDoc;
+int err;
+int nberrors;
+xmlNodePtr node;
+xmlNodePtr cur;
+xmlSchemaTypePtr type;
+xmlRegExecCtxtPtr regexp;
+xmlSchemaValPtr value;
+int attrNr;
+int attrBase;
+int attrMax;
+xmlSchemaAttrStatePtr attr;
+};
+/*
+* These are the entries in the schemas importSchemas hash table
+*/
+typedef struct _xmlSchemaImport xmlSchemaImport;
+typedef xmlSchemaImport *xmlSchemaImportPtr;
+struct _xmlSchemaImport {
+const xmlChar *schemaLocation;
+xmlSchemaPtr schema;
+};
+/*
+* These are the entries associated to includes in a schemas
+*/
+typedef struct _xmlSchemaInclude xmlSchemaInclude;
+typedef xmlSchemaInclude *xmlSchemaIncludePtr;
+struct _xmlSchemaInclude {
+xmlSchemaIncludePtr next;
+const xmlChar *schemaLocation;
+xmlDocPtr doc;
+};
+/************************************************************************
+*                                  *
+*          Some predeclarations                *
+*                                  *
+************************************************************************/
+static int xmlSchemaValidateSimpleValue(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr type,
+const xmlChar * value);
+static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static int
+xmlSchemaValidateSimpleValueInternal(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr type,
+const xmlChar * value,
+int fireErrors);
+/************************************************************************
+*                                  *
+*          Datatype error handlers             *
+*                                  *
+************************************************************************/
+/**
+* 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
+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++;
+channel = ctxt->error;
+data = ctxt->userData;
+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
+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);
+}
+/**
+* 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_SCHEMAS_ERR_INTERNAL;
+}
+__xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
+extra);
+}
+/**
+* xmlSchemaVErr3:
+* @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
+xmlSchemaVErr3(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, int error,
+const char *msg, const xmlChar *str1, const xmlChar *str2,
+const xmlChar *str3)
+{
+xmlStructuredErrorFunc schannel = NULL;
+xmlGenericErrorFunc channel = NULL;
+void *data = NULL;
+if (ctxt != NULL) {
+ctxt->nberrors++;
+ctxt->err = error;
+channel = ctxt->error;
+schannel = ctxt->serror;
+data = ctxt->userData;
+}
+/* reajust to global error numbers */
+error += XML_SCHEMAV_NOROOT - XML_SCHEMAS_ERR_NOROOT;
+__xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASV,
+error, XML_ERR_ERROR, NULL, 0,
+(const char *) str1, (const char *) str2,
+(const char *) str3, 0, 0,
+msg, str1, str2, str3);
+}
+/**
+* xmlSchemaVErr:
+* @ctxt: the validation context
+* @node: the context node
+* @error: the error code
+* @msg: the error message
+* @str1: extra data
+* @str2: extra data
+*
+* Handle a validation error
+*/
+static void
+xmlSchemaVErr(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, int error,
+const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+xmlStructuredErrorFunc schannel = NULL;
+xmlGenericErrorFunc channel = NULL;
+void *data = NULL;
+if (ctxt != NULL) {
+ctxt->nberrors++;
+ctxt->err = error;
+channel = ctxt->error;
+data = ctxt->userData;
+schannel = ctxt->serror;
+}
+/* reajust to global error numbers */
+error += XML_SCHEMAV_NOROOT - XML_SCHEMAS_ERR_NOROOT;
+__xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASV,
+error, XML_ERR_ERROR, NULL, 0,
+(const char *) str1, (const char *) str2, NULL, 0, 0,
+msg, str1, str2);
+}
+/************************************************************************
+*                                  *
+*          Allocation functions                *
+*                                  *
+************************************************************************/
+/**
+* xmlSchemaNewSchema:
+* @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);
+}
+/**
+* xmlSchemaFreeImport:
+* @import:  a schema import structure
+*
+* Deallocate an import structure
+*/
+static void
+xmlSchemaFreeImport(xmlSchemaImportPtr import)
+{
+if (import == NULL)
+return;
+xmlSchemaFree(import->schema);
+xmlFree(import);
+}
+/**
+* xmlSchemaFreeInclude:
+* @include:  a schema include structure
+*
+* Deallocate an include structure
+*/
+static void
+xmlSchemaFreeInclude(xmlSchemaIncludePtr include)
+{
+if (include == NULL)
+return;
+xmlFreeDoc(include->doc);
+xmlFree(include);
+}
+/**
+* xmlSchemaFreeIncludeList:
+* @includes:  a schema include list
+*
+* Deallocate an include structure
+*/
+static void
+xmlSchemaFreeIncludeList(xmlSchemaIncludePtr includes)
+{
+xmlSchemaIncludePtr next;
+while (includes != NULL) {
+next = includes->next;
+xmlSchemaFreeInclude(includes);
+includes = next;
+}
+}
+/**
+* xmlSchemaFreeNotation:
+* @schema:  a schema notation structure
+*
+* Deallocate a Schema Notation structure.
+*/
+static void
+xmlSchemaFreeNotation(xmlSchemaNotationPtr nota)
+{
+if (nota == NULL)
+return;
+xmlFree(nota);
+}
+/**
+* xmlSchemaFreeAttribute:
+* @schema:  a schema attribute structure
+*
+* Deallocate a Schema Attribute structure.
+*/
+static void
+xmlSchemaFreeAttribute(xmlSchemaAttributePtr attr)
+{
+if (attr == NULL)
+return;
+xmlFree(attr);
+}
+/**
+* xmlSchemaFreeAttributeGroup:
+* @schema:  a schema attribute group structure
+*
+* Deallocate a Schema Attribute Group structure.
+*/
+static void
+xmlSchemaFreeAttributeGroup(xmlSchemaAttributeGroupPtr attr)
+{
+if (attr == NULL)
+return;
+xmlFree(attr);
+}
+/**
+* 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);
+xmlFree(elem);
+}
+/**
+* xmlSchemaFreeTypeList:
+* @type:  a schema type structure
+*
+* Deallocate a Schema Type structure.
+*/
+static void
+xmlSchemaFreeTypeList(xmlSchemaTypePtr type)
+{
+xmlSchemaTypePtr next;
+while (type != NULL) {
+next = type->redef;
+xmlSchemaFreeType(type);
+type = next;
+}
+}
+/**
+* xmlSchemaFree:
+* @schema:  a schema structure
+*
+* Deallocate a Schema structure.
+*/
+void
+xmlSchemaFree(xmlSchemaPtr schema)
+{
+if (schema == NULL)
+return;
+if (schema->notaDecl != NULL)
+xmlHashFree(schema->notaDecl,
+(xmlHashDeallocator) xmlSchemaFreeNotation);
+if (schema->attrDecl != NULL)
+xmlHashFree(schema->attrDecl,
+(xmlHashDeallocator) xmlSchemaFreeAttribute);
+if (schema->attrgrpDecl != NULL)
+xmlHashFree(schema->attrgrpDecl,
+(xmlHashDeallocator) xmlSchemaFreeAttributeGroup);
+if (schema->elemDecl != NULL)
+xmlHashFree(schema->elemDecl,
+(xmlHashDeallocator) xmlSchemaFreeElement);
+if (schema->typeDecl != NULL)
+xmlHashFree(schema->typeDecl,
+(xmlHashDeallocator) xmlSchemaFreeTypeList);
+if (schema->groupDecl != NULL)
+xmlHashFree(schema->groupDecl,
+(xmlHashDeallocator) xmlSchemaFreeType);
+if (schema->schemasImports != NULL)
+xmlHashFree(schema->schemasImports,
+(xmlHashDeallocator) xmlSchemaFreeImport);
+if (schema->includes != NULL) {
+xmlSchemaFreeIncludeList((xmlSchemaIncludePtr) schema->includes);
+}
+if (schema->annot != NULL)
+xmlSchemaFreeAnnot(schema->annot);
+if (schema->doc != NULL && !schema->preserve)
+xmlFreeDoc(schema->doc);
+xmlDictFree(schema->dict);
+xmlFree(schema);
+}
+/************************************************************************
+*                                  *
+*          Debug functions                 *
+*                                  *
+************************************************************************/
+#ifdef LIBXML_OUTPUT_ENABLED
+/**
+* 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 * context ATTRIBUTE_UNUSED,
+const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+if (elem == NULL)
+return;
+fprintf(output, "Element ");
+if (elem->flags & XML_SCHEMAS_ELEM_TOPLEVEL)
+fprintf(output, "toplevel ");
+fprintf(output, ": %s ", elem->name);
+if (namespace != NULL)
+fprintf(output, "namespace '%s' ", namespace);
+if (elem->flags & XML_SCHEMAS_ELEM_NILLABLE)
+fprintf(output, "nillable ");
+if (elem->flags & XML_SCHEMAS_ELEM_GLOBAL)
+fprintf(output, "global ");
+if (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)
+fprintf(output, "default ");
+if (elem->flags & XML_SCHEMAS_ELEM_FIXED)
+fprintf(output, "fixed ");
+if (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT)
+fprintf(output, "abstract ");
+if (elem->flags & XML_SCHEMAS_ELEM_REF)
+fprintf(output, "ref '%s' ", elem->ref);
+if (elem->id != NULL)
+fprintf(output, "id '%s' ", elem->id);
+fprintf(output, "\n");
+if ((elem->minOccurs != 1) || (elem->maxOccurs != 1)) {
+fprintf(output, "  ");
+if (elem->minOccurs != 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");
+}
+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");
+}
+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");
+}
+if (elem->value != NULL)
+fprintf(output, "  default: %s", elem->value);
+}
+/**
+* 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");
+}
+/**
+* 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");
+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, "unknowntype%d ", type->type);
+break;
+}
+if (type->base != NULL) {
+fprintf(output, "base %s, ", type->base);
+}
+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:
+fprintf(output, "mixed_or_elems ");
+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->minOccurs != 1) || (type->maxOccurs != 1)) {
+fprintf(output, "  ");
+if (type->minOccurs != 1)
+fprintf(output, "min: %d ", type->minOccurs);
+if (type->maxOccurs >= UNBOUNDED)
+fprintf(output, "max: unbounded\n");
+else if (type->maxOccurs != 1)
+fprintf(output, "max: %d\n", type->maxOccurs);
+else
+fprintf(output, "\n");
+}
+if (type->annot != NULL)
+xmlSchemaAnnotDump(output, type->annot);
+if (type->subtypes != NULL) {
+xmlSchemaTypePtr sub = type->subtypes;
+fprintf(output, "  subtypes: ");
+while (sub != NULL) {
+fprintf(output, "%s ", sub->name);
+sub = sub->next;
+}
+fprintf(output, "\n");
+}
+}
+/**
+* xmlSchemaDump:
+* @output:  the file output
+* @schema:  a schema structure
+*
+* Dump a Schema structure.
+*/
+void
+xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
+{
+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);
+}
+#endif /* LIBXML_OUTPUT_ENABLED */
+/************************************************************************
+*                                  *
+*          Utilities                   *
+*                                  *
+************************************************************************/
+/**
+* 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 = xmlGetProp(node, BAD_CAST name);
+if (val == NULL)
+return(NULL);
+ret = xmlDictLookup(ctxt->dict, val, -1);
+xmlFree(val);
+return(ret);
+}
+#if 0
+/**
+* xmlSchemaGetNamespace:
+* @ctxt: the parser context
+* @schema: the schemas containing the declaration
+* @node: the node
+* @qname: the QName to analyze
+*
+* Find the namespace name for the given declaration.
+*
+* Returns the local name for that declaration, as well as the namespace name
+* NOTE: This function is no longer used (Buchcik, May '04)
+*/
+static const xmlChar *
+xmlSchemaGetNamespace(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node, const xmlChar *qname,
+const xmlChar **namespace) {
+int len;
+const xmlChar *name, *prefix, *def = NULL;
+xmlNsPtr ns;
+*namespace = NULL;
+/* TODO: The following seems to be not correct here:
+* 1. The name of a declaration is a NCName, not a QName.
+* 2. The attribute "targetNamespace" is allowed for the
+*    <schema> Element Information Item only.
+* 3. One cannot evaluate the target namespace, by the type
+*    of declaration, since it is dependant on the xxxFormDefault
+*    of <schema> and the form attribute of an <element> or <attribute>.
+*/
+if (xmlStrEqual(node->name, BAD_CAST "element") ||
+xmlStrEqual(node->name, BAD_CAST "attribute") ||
+xmlStrEqual(node->name, BAD_CAST "simpleType") ||
+xmlStrEqual(node->name, BAD_CAST "complexType")) {
+def = xmlSchemaGetProp(ctxt, node, "targetNamespace");
+}
+qname = xmlDictLookup(ctxt->dict, qname, -1); /* intern the string */
+name = xmlSplitQName3(qname, &len);
+if (name == NULL) {
+if (def == NULL) {
+if (xmlStrEqual(node->name, BAD_CAST "element")) {
+if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
+*namespace = schema->targetNamespace;
+} else if (xmlStrEqual(node->name, BAD_CAST "attribute")) {
+if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
+*namespace = schema->targetNamespace;
+} else if ((xmlStrEqual(node->name, BAD_CAST "simpleType")) ||
+(xmlStrEqual(node->name, BAD_CAST "complexType"))) {
+*namespace = schema->targetNamespace;
+}
+} else {
+*namespace = def;
+}
+return(qname);
+}
+name = xmlDictLookup(ctxt->dict, name, -1);
+prefix = xmlDictLookup(ctxt->dict, qname, len);
+if (def != NULL) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_DEF_AND_PREFIX,
+"%s: presence of both prefix %s and targetNamespace\n",
+node->name, prefix);
+}
+ns = xmlSearchNs(node->doc, node, prefix);
+if (ns == NULL) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_PREFIX_UNDEFINED,
+"%s: the QName prefix %s is undefined\n",
+node->name, prefix);
+return(name);
+}
+*namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+return(name);
+}
+#endif
+/************************************************************************
+*                                  *
+*          Parsing functions               *
+*                                  *
+************************************************************************/
+/**
+* xmlSchemaGetElem:
+* @schema:  the schemas context
+* @name:  the element name
+* @ns:  the element namespace
+* @level: how deep is the request
+*
+* Lookup a an element in the schemas or the accessible schemas
+*
+* Returns the element definition or NULL if not found.
+*/
+static xmlSchemaElementPtr
+xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
+const xmlChar * namespace, int level)
+{
+xmlSchemaElementPtr ret;
+xmlSchemaImportPtr import = NULL;
+if ((name == NULL) || (schema == NULL))
+return (NULL);
+if (namespace == NULL) {
+ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+if ((ret != NULL) &&
+((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+return (ret);
+}
+/*
+* This one was removed, since top level element declarations have
+* the target namespace specified in targetNamespace of the <schema>
+* information element, even if elementFormDefault is "unqualified".
+*/
+/* else if ((schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0) {
+if (xmlStrEqual(namespace, schema->targetNamespace))
+ret = xmlHashLookup2(schema->elemDecl, name, NULL);
+else
+ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+if ((ret != NULL) &&
+((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+return (ret);
+}
+*/
+} else {
+ret = xmlHashLookup2(schema->elemDecl, name, namespace);
+if ((ret != NULL) &&
+((level == 0) || (ret->flags & XML_SCHEMAS_ELEM_TOPLEVEL))) {
+return (ret);
+}
+}
+if (level > 0)
+import = xmlHashLookup(schema->schemasImports, namespace);
+if (import != NULL)
+ret = xmlSchemaGetElem(import->schema, name, namespace, level + 1);
+#ifdef DEBUG
+if (ret == NULL) {
+if (namespace == NULL)
+fprintf(stderr, "Unable to lookup type %s", name);
+else
+fprintf(stderr, "Unable to lookup type %s:%s", name,
+namespace);
+}
+#endif
+return (ret);
+}
+/**
+* xmlSchemaGetType:
+* @schema:  the schemas context
+* @name:  the type name
+* @ns:  the type 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 * namespace)
+{
+xmlSchemaTypePtr ret;
+xmlSchemaImportPtr import;
+if (name == NULL)
+return (NULL);
+if (schema != NULL) {
+ret = xmlHashLookup2(schema->typeDecl, name, namespace);
+if (ret != NULL)
+return (ret);
+}
+ret = xmlSchemaGetPredefinedType(name, namespace);
+if (ret != NULL)
+return (ret);
+import = xmlHashLookup(schema->schemasImports, namespace);
+if (import != NULL)
+ret = xmlSchemaGetType(import->schema, name, namespace);
+#ifdef DEBUG
+if (ret == NULL) {
+if (namespace == NULL)
+fprintf(stderr, "Unable to lookup type %s", name);
+else
+fprintf(stderr, "Unable to lookup type %s:%s", name,
+namespace);
+}
+#endif
+return (ret);
+}
+/************************************************************************
+*                                  *
+*          Parsing functions               *
+*                                  *
+************************************************************************/
+#define IS_BLANK_NODE(n)                        \
+(((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content)))
+/**
+* xmlSchemaIsBlank:
+* @str:  a string
+*
+* 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)
+{
+if (str == NULL)
+return (1);
+while (*str != 0) {
+if (!(IS_BLANK_CH(*str)))
+return (0);
+str++;
+}
+return (1);
+}
+/**
+* xmlSchemaAddNotation:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @name:  the item name
+*
+* 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 xmlSchemaNotationPtr
+xmlSchemaAddNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+const xmlChar * name)
+{
+xmlSchemaNotationPtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+if (schema->notaDecl == NULL)
+schema->notaDecl = xmlHashCreate(10);
+if (schema->notaDecl == NULL)
+return (NULL);
+ret = (xmlSchemaNotationPtr) xmlMalloc(sizeof(xmlSchemaNotation));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "add annotation", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaNotation));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+val = xmlHashAddEntry2(schema->notaDecl, name, schema->targetNamespace,
+ret);
+if (val != 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_NOTATION,
+"Notation %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+return (ret);
+}
+/**
+* xmlSchemaAddAttribute:
+* @ctxt:  a schema validation 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 * namespace)
+{
+xmlSchemaAttributePtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+#ifdef DEBUG
+fprintf(stderr, "Adding attribute %s\n", name);
+if (namespace != NULL)
+fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+if (schema->attrDecl == NULL)
+schema->attrDecl = xmlHashCreate(10);
+if (schema->attrDecl == NULL)
+return (NULL);
+ret = (xmlSchemaAttributePtr) xmlMalloc(sizeof(xmlSchemaAttribute));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating attribute", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaAttribute));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+ret->targetNamespace = xmlDictLookup(ctxt->dict, namespace, -1);
+val = xmlHashAddEntry3(schema->attrDecl, name,
+schema->targetNamespace, ctxt->container, ret);
+if (val != 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_ATTR,
+"Attribute %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+return (ret);
+}
+/**
+* xmlSchemaAddAttributeGroup:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @name:  the item name
+*
+* Add an XML schema Attrribute Group declaration
+*
+* Returns the new struture or NULL in case of error
+*/
+static xmlSchemaAttributeGroupPtr
+xmlSchemaAddAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, const xmlChar * name)
+{
+xmlSchemaAttributeGroupPtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+if (schema->attrgrpDecl == NULL)
+schema->attrgrpDecl = xmlHashCreate(10);
+if (schema->attrgrpDecl == NULL)
+return (NULL);
+ret =
+(xmlSchemaAttributeGroupPtr)
+xmlMalloc(sizeof(xmlSchemaAttributeGroup));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating attribute group", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaAttributeGroup));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+val = xmlHashAddEntry3(schema->attrgrpDecl, name,
+schema->targetNamespace, ctxt->container, ret);
+if (val != 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_ATTRGROUP,
+"Attribute group %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+return (ret);
+}
+/**
+* xmlSchemaAddElement:
+* @ctxt:  a schema validation 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, xmlSchemaPtr schema,
+const xmlChar * name, const xmlChar * namespace)
+{
+xmlSchemaElementPtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+#ifdef DEBUG
+fprintf(stderr, "Adding element %s\n", name);
+if (namespace != NULL)
+fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+if (schema->elemDecl == NULL)
+schema->elemDecl = xmlHashCreate(10);
+if (schema->elemDecl == NULL)
+return (NULL);
+ret = (xmlSchemaElementPtr) xmlMalloc(sizeof(xmlSchemaElement));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating element", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaElement));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+ret->targetNamespace = xmlDictLookup(ctxt->dict, namespace, -1);
+val = xmlHashAddEntry3(schema->elemDecl, name,
+namespace, ctxt->container, ret);
+if (val != 0) {
+char buf[100];
+snprintf(buf, 99, "privatieelem %d", ctxt->counter++ + 1);
+val = xmlHashAddEntry3(schema->elemDecl, name, (xmlChar *) buf,
+namespace, ret);
+if (val != 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_ELEMENT,
+"Element %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+}
+return (ret);
+}
+/**
+* xmlSchemaAddType:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @name:  the item name
+* @namespace:  the namespace
+*
+* Add an XML schema Simple Type definition
+* *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,
+const xmlChar * name, const xmlChar * namespace)
+{
+xmlSchemaTypePtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+#ifdef DEBUG
+fprintf(stderr, "Adding type %s\n", name);
+if (namespace != NULL)
+fprintf(stderr, "  target namespace %s\n", namespace);
+#endif
+if (schema->typeDecl == NULL)
+schema->typeDecl = xmlHashCreate(10);
+if (schema->typeDecl == NULL)
+return (NULL);
+ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating type", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaType));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+ret->redef = NULL;
+val = xmlHashAddEntry2(schema->typeDecl, name, namespace, ret);
+if (val != 0) {
+if (ctxt->includes == 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_TYPE,
+"Type %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+} else {
+xmlSchemaTypePtr prev;
+prev = xmlHashLookup2(schema->typeDecl, name, namespace);
+if (prev == NULL) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_ERR_INTERNAL_ERROR,
+"Internal error on type %s definition\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+ret->redef = prev->redef;
+prev->redef = ret;
+}
+}
+ret->minOccurs = 1;
+ret->maxOccurs = 1;
+return (ret);
+}
+/**
+* xmlSchemaAddGroup:
+* @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 xmlSchemaTypePtr
+xmlSchemaAddGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+const xmlChar * name)
+{
+xmlSchemaTypePtr ret = NULL;
+int val;
+if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
+return (NULL);
+if (schema->groupDecl == NULL)
+schema->groupDecl = xmlHashCreate(10);
+if (schema->groupDecl == NULL)
+return (NULL);
+ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
+if (ret == NULL) {
+xmlSchemaPErrMemory(ctxt, "adding group", NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaType));
+ret->name = xmlDictLookup(ctxt->dict, name, -1);
+val =
+xmlHashAddEntry2(schema->groupDecl, name, schema->targetNamespace,
+ret);
+if (val != 0) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) ctxt->doc,
+XML_SCHEMAP_REDEFINED_GROUP,
+"Group %s already defined\n",
+name, NULL);
+xmlFree(ret);
+return (NULL);
+}
+ret->minOccurs = 1;
+ret->maxOccurs = 1;
+return (ret);
+}
+/************************************************************************
+*                                  *
+*      Utilities for parsing                   *
+*                                  *
+************************************************************************/
+/**
+* xmlGetQNameProp:
+* @ctxt:  a schema validation context
+* @node:  a subtree containing XML Schema informations
+* @name:  the attribute name
+* @namespace:  the result namespace if any
+*
+* Extract a QName Attribute value
+*
+* Returns the NCName or NULL if not found, and also update @namespace
+*    with the namespace URI
+*/
+static const xmlChar *
+xmlGetQNameProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
+const char *name, const xmlChar ** namespace)
+{
+const xmlChar *val;
+xmlNsPtr ns;
+const xmlChar *ret, *prefix;
+int len;
+*namespace = NULL;
+val = xmlSchemaGetProp(ctxt, node, name);
+if (val == NULL)
+return (NULL);
+if (!strchr((char *) val, ':')) {
+ns = xmlSearchNs(node->doc, node, 0);
+if (ns) {
+*namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+return (val);
+}
+}
+ret = xmlSplitQName3(val, &len);
+if (ret == NULL) {
+return (val);
+}
+ret = xmlDictLookup(ctxt->dict, ret, -1);
+prefix = xmlDictLookup(ctxt->dict, val, len);
+ns = xmlSearchNs(node->doc, node, prefix);
+if (ns == NULL) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_PREFIX_UNDEFINED,
+"Attribute %s: the QName prefix %s is undefined\n",
+(const xmlChar *) name, prefix);
+} else {
+*namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+}
+return (ret);
+}
+/**
+* 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)
+{
+const xmlChar *val, *cur;
+int ret = 0;
+val = xmlSchemaGetProp(ctxt, node, "maxOccurs");
+if (val == NULL)
+return (1);
+if (xmlStrEqual(val, (const xmlChar *) "unbounded")) {
+return (UNBOUNDED);  /* encoding it with -1 might be another option */
+}
+cur = val;
+while (IS_BLANK_CH(*cur))
+cur++;
+while ((*cur >= '0') && (*cur <= '9')) {
+ret = ret * 10 + (*cur - '0');
+cur++;
+}
+while (IS_BLANK_CH(*cur))
+cur++;
+if (*cur != 0) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MAXOCCURS,
+"invalid value for maxOccurs: %s\n", val, NULL);
+return (1);
+}
+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)
+{
+const xmlChar *val, *cur;
+int ret = 0;
+val = xmlSchemaGetProp(ctxt, node, "minOccurs");
+if (val == NULL)
+return (1);
+cur = val;
+while (IS_BLANK_CH(*cur))
+cur++;
+while ((*cur >= '0') && (*cur <= '9')) {
+ret = ret * 10 + (*cur - '0');
+cur++;
+}
+while (IS_BLANK_CH(*cur))
+cur++;
+if (*cur != 0) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MINOCCURS,
+"invalid value for minOccurs: %s\n", val, NULL);
+return (1);
+}
+return (ret);
+}
+/**
+* xmlGetBooleanProp:
+* @ctxt:  a schema validation context
+* @node:  a subtree containing XML Schema informations
+* @name:  the attribute name
+* @def:  the default value
+*
+* Get is a bolean 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);
+if (xmlStrEqual(val, BAD_CAST "true"))
+def = 1;
+else if (xmlStrEqual(val, BAD_CAST "false"))
+def = 0;
+else {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_BOOLEAN,
+"Attribute %s: the value %s is not boolean\n",
+(const xmlChar *) name, val);
+}
+return (def);
+}
+/************************************************************************
+*                                  *
+*      Shema extraction from an Infoset            *
+*                                  *
+************************************************************************/
+static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
+ctxt, xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
+ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr
+ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node,
+int simple);
+static xmlSchemaTypePtr xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseAll(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaAttributePtr xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr
+ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node,
+int topLevel);
+static xmlSchemaAttributeGroupPtr
+xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaTypePtr xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema,
+xmlNodePtr node);
+static xmlSchemaAttributePtr
+xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node);
+/**
+* xmlSchemaParseAttrDecls:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+* @type:  the hosting type
+*
+* parse a XML schema attrDecls declaration corresponding to
+* <!ENTITY % attrDecls
+*       '((%attribute;| %attributeGroup;)*,(%anyAttribute;)?)'>
+*/
+static xmlNodePtr
+xmlSchemaParseAttrDecls(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr child, xmlSchemaTypePtr type)
+{
+xmlSchemaAttributePtr lastattr, attr;
+lastattr = NULL;
+while ((IS_SCHEMA(child, "attribute")) ||
+(IS_SCHEMA(child, "attributeGroup"))) {
+attr = NULL;
+if (IS_SCHEMA(child, "attribute")) {
+attr = xmlSchemaParseAttribute(ctxt, schema, child, 0);
+} else if (IS_SCHEMA(child, "attributeGroup")) {
+attr = (xmlSchemaAttributePtr)
+xmlSchemaParseAttributeGroup(ctxt, schema, child);
+}
+if (attr != NULL) {
+if (lastattr == NULL) {
+type->attributes = attr;
+lastattr = attr;
+} else {
+lastattr->next = attr;
+lastattr = attr;
+}
+}
+child = child->next;
+}
+if (IS_SCHEMA(child, "anyAttribute")) {
+attr = xmlSchemaParseAnyAttribute(ctxt, schema, child);
+if (attr != NULL) {
+if (lastattr == NULL) {
+type->attributes = attr;
+lastattr = attr;
+} else {
+lastattr->next = attr;
+lastattr = attr;
+}
+}
+child = child->next;
+}
+return (child);
+}
+/**
+* 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, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaAnnotPtr ret;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+ret = xmlSchemaNewAnnot(ctxt, node);
+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);
+}
+facet->id = xmlSchemaGetProp(ctxt, node, "id");
+facet->value = value;
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+facet->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+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);
+}
+/**
+* xmlSchemaParseAny:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Any declaration
+* *WARNING* this interface is highly subject to change
+*
+* Returns the new type structure or NULL in case of error
+*/
+static xmlSchemaTypePtr
+xmlSchemaParseAny(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "any %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_ANY;
+child = node->children;
+type->minOccurs = xmlGetMinOccurs(ctxt, node);
+type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
+"Sequence %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* 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);
+if (ret == NULL) {
+return (NULL);
+}
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
+"notation %s has unexpected content\n", name, NULL);
+}
+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 an attribute def structure or NULL
+*/
+static xmlSchemaAttributePtr
+xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node)
+{
+const xmlChar *processContents;
+xmlSchemaAttributePtr ret;
+xmlNodePtr child = NULL;
+char name[100];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf(name, 99, "anyattr %d", ctxt->counter++ + 1);
+/* local = xmlSchemaGetNamespace(ctxt, schema, node, BAD_CAST "anyattr", &ns); */
+/*
+* TODO: namespace = ((##any | ##other) | List of (anyURI |
+*                    (##targetNamespace | * ##local)) )  : ##any
+*/
+ret = xmlSchemaAddAttribute(ctxt, schema, BAD_CAST name, NULL);
+if (ret == NULL) {
+return (NULL);
+}
+ret->type = XML_SCHEMA_TYPE_ANY_ATTRIBUTE;
+ret->id = xmlSchemaGetProp(ctxt, node, "id");
+processContents = xmlSchemaGetProp(ctxt, node, "processContents");
+if ((processContents == NULL)
+|| (xmlStrEqual(processContents, (const xmlChar *) "strict"))) {
+ret->occurs = XML_SCHEMAS_ANYATTR_STRICT;
+} else if (xmlStrEqual(processContents, (const xmlChar *) "skip")) {
+ret->occurs = XML_SCHEMAS_ANYATTR_SKIP;
+} else if (xmlStrEqual(processContents, (const xmlChar *) "lax")) {
+ret->occurs = XML_SCHEMAS_ANYATTR_LAX;
+} else {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
+"anyAttribute has unexpected content "
+"for processContents: %s\n",
+processContents, NULL);
+ret->occurs = XML_SCHEMAS_ANYATTR_STRICT;
+}
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
+"anyAttribute %s has unexpected content\n",
+(const xmlChar *) name, NULL);
+}
+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 xmlSchemaAttributePtr
+xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node, int topLevel)
+{
+const xmlChar *name, *refNs = NULL, *ref = NULL, *attrVal;
+xmlSchemaAttributePtr ret;
+xmlNodePtr child = NULL;
+char buf[100];
+int hasRefType = 0;
+/*
+* 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
+*
+* TODO: Complete implementation of:
+* 3.2.6 Schema Component Constraint: Attribute Declaration Properties
+*       Correct
+*/
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+/* 3.2.3 : 3.1
+* One of ref or name must be present, but not both
+*/
+if (ref == NULL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_ATTR_NONAME_NOREF,
+"Attribute declaration has no \"name\" or \"ref\"\n",
+NULL, NULL);
+return (NULL);
+}
+hasRefType = 1;
+snprintf(buf, 99, "anonattr %d", ctxt->counter++ + 1);
+name = (const xmlChar *) buf;
+ret = xmlSchemaAddAttribute(ctxt, schema, name, NULL);
+if (!topLevel) {
+/* 3.2.3 : 3.2
+* If ref is present, then all of <simpleType>,
+* form and type must be absent.
+*/
+if (xmlSchemaGetProp(ctxt, node, "form") != NULL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration %s has \"ref\", thus "
+"\"form\" must be absent\n", name, NULL);
+}
+if (xmlSchemaGetProp(ctxt, node, "type") != NULL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration %s has \"ref\", thus "
+"\"type\" must be absent\n", name, NULL);
+}
+}
+} else {
+const xmlChar *ns = NULL;
+/* 3.2.3 : 3.1
+* One of ref or name must be present, but not both
+*/
+if ((!topLevel) && (xmlSchemaGetProp(ctxt, node, "ref") != NULL)) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration has both, \"name\" and "
+"\"ref\"\n", NULL, NULL);
+}
+/* local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); */
+/* Evaluate the target namespace */
+if (schema->targetNamespace != NULL) {
+if (topLevel) {
+ns = schema->targetNamespace;
+} else if (xmlSchemaGetProp(ctxt, node, "form") != NULL) {
+if (xmlStrEqual( xmlSchemaGetProp(ctxt, node, "form"),
+BAD_CAST "qualified")) {
+ns = schema->targetNamespace;
+}
+} else if (schema->flags & XML_SCHEMAS_QUALIF_ATTR) {
+ns = schema->targetNamespace;
+}
+}
+ret = xmlSchemaAddAttribute(ctxt, schema, name, ns);
+/* 3.2.6 Schema Component Constraint: xmlns Not Allowed */
+if (xmlStrEqual(name, BAD_CAST "xmlns")) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_NAME,
+"The name of an attribute declaration must not match "
+"\"xmlns\".\n", NULL, NULL);
+}
+/* 3.2.6 Schema Component Constraint: xsi: Not Allowed */
+if (xmlStrEqual(ret->targetNamespace, xmlSchemaInstanceNs)) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_NAME,
+"The target namespace of an attribute declaration, "
+"must not match \"http://www.w3.org/2001/"
+"XMLSchema-instance\"", NULL, NULL);
+}
+}
+if (ret == NULL) {
+return (NULL);
+}
+ret->type = XML_SCHEMA_TYPE_ATTRIBUTE;
+/* Handle the "use" attribute. */
+attrVal = xmlSchemaGetProp(ctxt, node, "use");
+if (attrVal != NULL) {
+if (xmlStrEqual(attrVal, BAD_CAST "optional"))
+ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
+else if (xmlStrEqual(attrVal, BAD_CAST "prohibited"))
+ret->occurs = XML_SCHEMAS_ATTR_USE_PROHIBITED;
+else if (xmlStrEqual(attrVal, BAD_CAST "required"))
+ret->occurs = XML_SCHEMAS_ATTR_USE_REQUIRED;
+else
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_USE,
+"Attribute declaration %s has an invalid "
+"value for \"use\"\n", name, NULL);
+} else
+ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
+if (xmlSchemaGetProp(ctxt, node, "default") != NULL) {
+/* 3.2.3 : 1
+* default and fixed must not both be present.
+*/
+if (xmlSchemaGetProp(ctxt, node, "fixed") != NULL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration has both, \"default\" "
+"and \"fixed\"\n", NULL, NULL);
+}
+/* 3.2.3 : 2
+* If default and use are both present, use must have
+* the actual value optional.
+*/
+if (ret->occurs != XML_SCHEMAS_ATTR_USE_OPTIONAL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration has \"default\" but "
+"\"use\" is not \"optional\"\n", NULL, NULL);
+}
+}
+ret->ref = ref;
+ret->refNs = refNs;
+/*
+* The setting of XML_SCHEMAS_ATTR_NSDEFAULT is not needed anymore,
+* since the target namespace was already evaluated and took
+* attributeFormDefault into account.
+*/
+/*
+if ((ret->targetNamespace != NULL) &&
+((schema->flags & XML_SCHEMAS_QUALIF_ATTR) == 0) &&
+(xmlStrEqual(ret->targetNamespace, schema->targetNamespace)))
+ret->flags |= XML_SCHEMAS_ATTR_NSDEFAULT;
+*/
+ret->typeName = xmlGetQNameProp(ctxt, node, "type", &(ret->typeNs));
+if (ret->typeName != NULL)
+hasRefType = 1;
+ret->node = node;
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (IS_SCHEMA(child, "simpleType")) {
+if (hasRefType) {
+/* 3.2.3 : 4
+* type and <simpleType> must not both be present.
+*
+* TODO: XML_SCHEMAP_INVALID_ATTR_COMBINATION seems not to be
+* a proper error type here.
+*/
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Attribute declaration %s has both (\"ref\" or "
+"\"type\") and <simpleType>\n", name, NULL);
+} else
+ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child);
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
+"attribute %s has unexpected content\n", name,
+NULL);
+}
+return (ret);
+}
+/**
+* xmlSchemaParseAttributeGroup:
+* @ctxt:  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 or NULL in case of error.
+*/
+static xmlSchemaAttributeGroupPtr
+xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node)
+{
+const xmlChar *name, *refNs = NULL, *ref = NULL;
+xmlSchemaAttributeGroupPtr ret;
+xmlSchemaAttributePtr last = NULL, attr;
+xmlNodePtr child = NULL;
+const xmlChar *oldcontainer;
+char buf[100];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+oldcontainer = ctxt->container;
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+if (ref == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
+"AttributeGroup has no name nor ref\n", NULL,
+NULL);
+return (NULL);
+}
+snprintf(buf, 99, "anonattrgroup %d", ctxt->counter++ + 1);
+name = (const xmlChar *) buf;
+if (name == NULL) {
+xmlSchemaPErrMemory(ctxt, "creating attribute group", node);
+return (NULL);
+}
+}
+ret = xmlSchemaAddAttributeGroup(ctxt, schema, name);
+if (ret == NULL) {
+return (NULL);
+}
+ret->ref = ref;
+ret->refNs = refNs;
+ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
+ret->node = node;
+child = node->children;
+ctxt->container = name;
+if (IS_SCHEMA(child, "annotation")) {
+ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+while ((IS_SCHEMA(child, "attribute")) ||
+(IS_SCHEMA(child, "attributeGroup"))) {
+attr = NULL;
+if (IS_SCHEMA(child, "attribute")) {
+attr = xmlSchemaParseAttribute(ctxt, schema, child, 0);
+} else if (IS_SCHEMA(child, "attributeGroup")) {
+attr = (xmlSchemaAttributePtr)
+xmlSchemaParseAttributeGroup(ctxt, schema, child);
+}
+if (attr != NULL) {
+if (last == NULL) {
+ret->attributes = attr;
+last = attr;
+} else {
+last->next = attr;
+last = attr;
+}
+}
+child = child->next;
+}
+if (IS_SCHEMA(child, "anyAttribute")) {
+TODO
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
+"attribute group %s has unexpected content\n", name,
+NULL);
+}
+ctxt->container = oldcontainer;
+return (ret);
+}
+/**
+* xmlSchemaParseElement:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Element declaration
+* *WARNING* this interface is highly subject to change
+*
+* Returns the parsed element declaration.
+*/
+static xmlSchemaElementPtr
+xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node, int toplevel)
+{
+const xmlChar *name, *fixed;
+const xmlChar *refNs = NULL, *ref = NULL;
+xmlSchemaElementPtr ret;
+xmlNodePtr child = NULL;
+const xmlChar *oldcontainer;
+char buf[100];
+xmlAttrPtr attr;
+/* 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);
+oldcontainer = ctxt->container;
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+/* 3.3.3 : 2.1
+* One of ref or name must be present, but not both
+*/
+if (ref == NULL) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_ELEM_NONAME_NOREF,
+"Element has no name nor ref\n", NULL, NULL);
+return (NULL);
+}
+snprintf(buf, 99, "anonelem %d", ctxt->counter++ + 1);
+name = (const xmlChar *) buf;
+ret = xmlSchemaAddElement(ctxt, schema, name, NULL);
+} else {
+const xmlChar *ns = NULL;
+/* Evaluate the target namespace */
+if (schema->targetNamespace != NULL) {
+if (toplevel) {
+ns = schema->targetNamespace;
+} else if (xmlSchemaGetProp(ctxt, node, "form") != NULL) {
+if (xmlStrEqual( xmlSchemaGetProp(ctxt, node, "form"),
+BAD_CAST "qualified")) {
+ns = schema->targetNamespace;
+}
+} else if (schema->flags & XML_SCHEMAS_QUALIF_ATTR) {
+ns = schema->targetNamespace;
+}
+}
+/*local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); */
+ret = xmlSchemaAddElement(ctxt, schema, name, ns);
+/* 3.3.3 : 2.1
+* One of ref or name must be present, but not both
+*/
+if ((!toplevel) && (xmlSchemaGetProp(ctxt, node, "ref") != NULL)) {
+xmlSchemaPErr(ctxt, node,
+XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Element declaration has both, \"name\" and "
+"\"ref\"\n", NULL, NULL);
+}
+}
+if (ret != NULL)
+ret->node = node;
+if (ret == NULL) {
+return (NULL);
+}
+ret->type = XML_SCHEMA_TYPE_ELEMENT;
+ret->ref = ref;
+ret->refNs = refNs;
+if (ref != NULL)
+ret->flags |= XML_SCHEMAS_ELEM_REF;
+/* 3.3.3 : 2.2 */
+if ((!toplevel) && (ref != NULL)) {
+attr = node->properties;
+while (attr != NULL) {
+if ((attr->ns == NULL) &&
+(!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
+(!xmlStrEqual(attr->name, BAD_CAST "id")) &&
+(!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
+(!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Element declaration %s: only minOccurs, maxOccurs "
+"and id are allowed in addition to ref\n",
+ret->name, NULL);
+}
+attr = attr->next;
+}
+}
+if (toplevel)
+ret->flags |= XML_SCHEMAS_ELEM_TOPLEVEL;
+if (xmlGetBooleanProp(ctxt, node, "nillable", 0))
+ret->flags |= XML_SCHEMAS_ELEM_NILLABLE;
+if (xmlGetBooleanProp(ctxt, node, "abstract", 0))
+ret->flags |= XML_SCHEMAS_ELEM_NILLABLE;
+ctxt->container = name;
+ret->id = xmlSchemaGetProp(ctxt, node, "id");
+ret->namedType =
+xmlGetQNameProp(ctxt, node, "type", &(ret->namedTypeNs));
+ret->substGroup =
+xmlGetQNameProp(ctxt, node, "substitutionGroup",
+&(ret->substGroupNs));
+if ((ret->substGroup != NULL) && (!toplevel)) {
+/* 3.3.6 : 3 */
+/*
+* TODO: This seems to be redundant, since the schema for schemas
+* already prohibits the use of the "substitutionGroup" attribute
+* in local element declarations.
+*/
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_ATTR_COMBINATION,
+"Element declaration %s: substitutionGroup is allowed "
+"on top-level declarations only\n", ret->name, NULL);
+}
+fixed = xmlSchemaGetProp(ctxt, node, "fixed");
+ret->minOccurs = xmlGetMinOccurs(ctxt, node);
+ret->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+ret->value = xmlSchemaGetProp(ctxt, node, "default");
+if ((ret->value != NULL) && (fixed != NULL)) {
+/* 3.3.3 : 1
+* default and fixed must not both be present.
+*/
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_ELEM_DEFAULT_FIXED,
+"Element %s has both default and fixed\n",
+ret->name, NULL);
+} else if (fixed != NULL) {
+ret->flags |= XML_SCHEMAS_ELEM_FIXED;
+ret->value = fixed;
+}
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (ref != NULL) {
+/* 3.3.3 (2.2) */
+while (child != NULL) {
+if ((IS_SCHEMA(child, "complexType")) ||
+(IS_SCHEMA(child, "simpleType")) ||
+(IS_SCHEMA(child, "unique")) ||
+(IS_SCHEMA(child, "key")) ||
+(IS_SCHEMA(child, "keyref"))) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_REF_AND_CONTENT,
+"Element declaration %s: only annotation is "
+"allowed as content in addition to ref\n",
+ret->name, NULL);
+} else {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
+"element %s has unexpected content\n", name, NULL);
+}
+child = child->next;
+}
+} else {
+if (IS_SCHEMA(child, "complexType")) {
+/* 3.3.3 : 3
+* type and either <simpleType> or <complexType> are mutually
+* exclusive
+*/
+if (ret->namedType != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
+"Element declaration %s has both \"type\" "
+"and a local complex type\n",
+ret->name, NULL);
+} else
+ret->subtypes = xmlSchemaParseComplexType(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "simpleType")) {
+/* 3.3.3 : 3
+* type and either <simpleType> or <complexType> are
+* mutually exclusive
+*/
+if (ret->namedType != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
+"Element declaration %s has both \"type\" "
+"and a local simple type\n",
+ret->name, NULL);
+} else
+ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child);
+child = child->next;
+}
+while ((IS_SCHEMA(child, "unique")) ||
+(IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
+TODO child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
+"element %s has unexpected content\n", name, NULL);
+}
+}
+ctxt->container = oldcontainer;
+return (ret);
+}
+/**
+* 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 error, 0 if the declaration is improper and
+*         1 in case of success.
+*/
+static xmlSchemaTypePtr
+xmlSchemaParseUnion(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype, last = NULL;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "union %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_UNION;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->ref = xmlSchemaGetProp(ctxt, node, "memberTypes");
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+while (IS_SCHEMA(child, "simpleType")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseSimpleType(ctxt, schema, child);
+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) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_UNION_CHILD,
+"Union %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* 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, subtype;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "list %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_LIST;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->ref = xmlGetQNameProp(ctxt, node, "ref", &(type->refNs));
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "simpleType")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseSimpleType(ctxt, schema, child);
+child = child->next;
+type->subtypes = subtype;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_LIST_CHILD,
+"List %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* 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)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+const xmlChar *name;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+char buf[100];
+snprintf(buf, 99, "simpleType %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, (const xmlChar *)buf, NULL);
+} else {
+/* local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); */
+type = xmlSchemaAddType(ctxt, schema, name, schema->targetNamespace);
+}
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_SIMPLE;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "restriction")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseRestriction(ctxt, schema, child, 1);
+child = child->next;
+} else if (IS_SCHEMA(child, "list")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseList(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "union")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseUnion(ctxt, schema, child);
+child = child->next;
+}
+type->subtypes = subtype;
+if (subtype == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD,
+"SimpleType %s does not define a variety\n",
+type->name, NULL);
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
+"SimpleType %s has unexpected content\n",
+type->name, NULL);
+}
+return (type);
+}
+/**
+* xmlSchemaParseGroup:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Group 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
+xmlSchemaParseGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+const xmlChar *name;
+const xmlChar *ref = NULL, *refNs = NULL;
+char buf[100];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+ref = xmlGetQNameProp(ctxt, node, "ref", &refNs);
+if (ref == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_GROUP_NONAME_NOREF,
+"Group has no name nor ref\n", NULL, NULL);
+return (NULL);
+}
+if (refNs == NULL)
+refNs = schema->targetNamespace;
+snprintf(buf, 99, "anongroup %d", ctxt->counter++ + 1);
+name = (const xmlChar *) buf;
+}
+type = xmlSchemaAddGroup(ctxt, schema, name);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_GROUP;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->ref = ref;
+type->refNs = refNs;
+type->minOccurs = xmlGetMinOccurs(ctxt, node);
+type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "all")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseAll(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseSequence(ctxt, schema, child);
+child = child->next;
+}
+if (subtype != NULL)
+type->subtypes = subtype;
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
+"Group %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* xmlSchemaParseAll:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema All 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
+xmlSchemaParseAll(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype, last = NULL;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "all%d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_ALL;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->minOccurs = xmlGetMinOccurs(ctxt, node);
+if (type->minOccurs > 1)
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MINOCCURS,
+"invalid value for minOccurs (must be 0 or 1)\n", NULL, NULL);
+type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+if (type->maxOccurs > 1)
+xmlSchemaPErr(ctxt, node, XML_SCHEMAP_INVALID_MAXOCCURS,
+"invalid value for maxOccurs (must be 0 or 1)\n", NULL, NULL);
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+while (IS_SCHEMA(child, "element")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseElement(ctxt, schema, child, 0);
+if (subtype != NULL) {
+if (subtype->minOccurs > 1)
+xmlSchemaPErr(ctxt, child, XML_SCHEMAP_INVALID_MINOCCURS,
+"invalid value for minOccurs (must be 0 or 1)\n",
+NULL, NULL);
+if (subtype->maxOccurs > 1)
+xmlSchemaPErr(ctxt, child, XML_SCHEMAP_INVALID_MAXOCCURS,
+"invalid value for maxOccurs (must be 0 or 1)\n",
+NULL, NULL);
+if (last == NULL) {
+type->subtypes = subtype;
+last = subtype;
+} else {
+last->next = subtype;
+last = subtype;
+}
+last->next = NULL;
+}
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_ALL_CHILD,
+"All %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* xmlSchemaImportSchema
+*
+* @ctxt:  a schema validation context
+* @schemaLocation:  an URI defining where to find the imported schema
+*
+* import a XML schema
+* *WARNING* this interface is highly subject to change
+*
+* Returns -1 in case of error and 1 in case of success.
+*/
+static xmlSchemaImportPtr
+xmlSchemaImportSchema(xmlSchemaParserCtxtPtr ctxt,
+const xmlChar *schemaLocation)
+{
+xmlSchemaImportPtr import;
+xmlSchemaParserCtxtPtr newctxt;
+newctxt = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+if (newctxt == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating schama parser context",
+NULL);
+return (NULL);
+}
+memset(newctxt, 0, sizeof(xmlSchemaParserCtxt));
+/* Keep the same dictionnary for parsing, really */
+xmlDictReference(ctxt->dict);
+newctxt->dict = ctxt->dict;
+newctxt->includes = 0;
+newctxt->URL = xmlDictLookup(newctxt->dict, schemaLocation, -1);
+xmlSchemaSetParserErrors(newctxt, ctxt->error, ctxt->warning,
+ctxt->userData);
+import = (xmlSchemaImport*) xmlMalloc(sizeof(xmlSchemaImport));
+if (import == NULL) {
+xmlSchemaPErrMemory(NULL, "allocating imported schema",
+NULL);
+xmlSchemaFreeParserCtxt(newctxt);
+return (NULL);
+}
+memset(import, 0, sizeof(xmlSchemaImport));
+import->schemaLocation = xmlDictLookup(ctxt->dict, schemaLocation, -1);
+import->schema = xmlSchemaParse(newctxt);
+if (import->schema == NULL) {
+/* FIXME use another error enum here ? */
+xmlSchemaPErr(ctxt, NULL, XML_SCHEMAS_ERR_INTERNAL,
+"failed to import schema at location %s\n",
+schemaLocation, NULL);
+xmlSchemaFreeParserCtxt(newctxt);
+if (import->schemaLocation != NULL)
+xmlFree((xmlChar *)import->schemaLocation);
+xmlFree(import);
+return NULL;
+}
+xmlSchemaFreeParserCtxt(newctxt);
+return import;
+}
+/**
+* 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 -1 in case of error, 0 if the declaration is improper and
+*         1 in case of success.
+*/
+static int
+xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlNodePtr child = NULL;
+xmlSchemaImportPtr import = NULL;
+const xmlChar *namespace;
+const xmlChar *schemaLocation;
+const xmlChar *previous;
+xmlURIPtr check;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (-1);
+namespace = xmlSchemaGetProp(ctxt, node, "namespace");
+if (namespace != NULL) {
+check = xmlParseURI((const char *) namespace);
+if (check == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
+"Import namespace attribute is not an URI: %s\n",
+namespace, NULL);
+return (-1);
+} else {
+xmlFreeURI(check);
+}
+}
+schemaLocation = xmlSchemaGetProp(ctxt, node, "schemaLocation");
+if (schemaLocation != NULL) {
+xmlChar *base = NULL;
+xmlChar *URI = NULL;
+check = xmlParseURI((const char *) schemaLocation);
+if (check == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
+"Import schemaLocation attribute is not an URI: %s\n",
+schemaLocation, NULL);
+return (-1);
+} else {
+xmlFreeURI(check);
+}
+base = xmlNodeGetBase(node->doc, node);
+if (base == NULL) {
+URI = xmlBuildURI(schemaLocation, node->doc->URL);
+} else {
+URI = xmlBuildURI(schemaLocation, base);
+xmlFree(base);
+}
+if (URI != NULL) {
+schemaLocation = xmlDictLookup(ctxt->dict, URI, -1);
+xmlFree(URI);
+}
+}
+if (schema->schemasImports == NULL) {
+schema->schemasImports = xmlHashCreate(10);
+if (schema->schemasImports == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_FAILED_BUILD_IMPORT,
+"Internal: failed to build import table\n",
+NULL, NULL);
+return (-1);
+}
+}
+if (namespace == NULL) {
+import = xmlHashLookup(schema->schemasImports,
+XML_SCHEMAS_DEFAULT_NAMESPACE);
+if (import != NULL)
+previous = import->schemaLocation;
+else
+previous = NULL;
+if (schemaLocation != NULL) {
+if (previous != NULL) {
+if (!xmlStrEqual(schemaLocation, previous)) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
+"Redefining import for default namespace "
+"with a different URI: %s\n",
+schemaLocation, NULL);
+}
+} else {
+import = xmlSchemaImportSchema(ctxt, schemaLocation);
+if (import == NULL) {
+return (-1);
+}
+xmlHashAddEntry(schema->schemasImports,
+XML_SCHEMAS_DEFAULT_NAMESPACE,
+import);
+}
+}
+} else {
+import = xmlHashLookup(schema->schemasImports, namespace);
+if (import != NULL)
+previous = import->schemaLocation;
+else
+previous = NULL;
+if (schemaLocation != NULL) {
+if (previous != NULL) {
+if (!xmlStrEqual(schemaLocation, previous)) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
+"Redefining import for namespace %s with "
+"a different URI: %s\n",
+namespace, schemaLocation);
+}
+} else {
+import = xmlSchemaImportSchema(ctxt, schemaLocation);
+if (import == NULL) {
+return (-1);
+}
+xmlHashAddEntry(schema->schemasImports,
+namespace, import);
+}
+}
+}
+child = node->children;
+while (IS_SCHEMA(child, "annotation")) {
+/*
+* the annotations here are simply discarded ...
+*/
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
+"Import has unexpected content\n", NULL, NULL);
+return (-1);
+}
+return (1);
+}
+/**
+* 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;
+}
+}
+/**
+* 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 void
+xmlSchemaParseSchemaTopLevel(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr nodes)
+{
+xmlNodePtr child;
+xmlSchemaAnnotPtr annot;
+if ((ctxt == NULL) || (schema == NULL) || (nodes == NULL))
+return;
+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, schema, child);
+if (schema->annot == NULL)
+schema->annot = annot;
+else
+xmlSchemaFreeAnnot(annot);
+} else if (IS_SCHEMA(child, "import")) {
+xmlSchemaParseImport(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "include")) {
+ctxt->includes++;
+xmlSchemaParseInclude(ctxt, schema, child);
+ctxt->includes--;
+} else if (IS_SCHEMA(child, "redefine")) {
+TODO
+}
+child = child->next;
+}
+while (child != NULL) {
+if (IS_SCHEMA(child, "complexType")) {
+xmlSchemaParseComplexType(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "simpleType")) {
+xmlSchemaParseSimpleType(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "element")) {
+xmlSchemaParseElement(ctxt, schema, child, 1);
+child = child->next;
+} else if (IS_SCHEMA(child, "attribute")) {
+xmlSchemaParseAttribute(ctxt, schema, child, 1);
+child = child->next;
+} else if (IS_SCHEMA(child, "attributeGroup")) {
+xmlSchemaParseAttributeGroup(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "group")) {
+xmlSchemaParseGroup(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "notation")) {
+xmlSchemaParseNotation(ctxt, schema, child);
+child = child->next;
+} else {
+xmlSchemaPErr2(ctxt, NULL, child,
+XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
+"Schemas: unexpected element %s here \n",
+child->name, NULL);
+child = child->next;
+}
+while (IS_SCHEMA(child, "annotation")) {
+annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+if (schema->annot == NULL)
+schema->annot = annot;
+else
+xmlSchemaFreeAnnot(annot);
+child = child->next;
+}
+}
+}
+/**
+* xmlSchemaParseInclude:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Include definition
+*
+* Returns -1 in case of error, 0 if the declaration is improper and
+*         1 in case of success.
+*/
+static int
+xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlNodePtr child = NULL;
+const xmlChar *schemaLocation;
+xmlURIPtr check;
+xmlDocPtr doc;
+xmlNodePtr root;
+xmlSchemaIncludePtr include;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (-1);
+/*
+* Preliminary step, extract the URI-Reference for the include and
+* make an URI from the base.
+*/
+schemaLocation = xmlSchemaGetProp(ctxt, node, "schemaLocation");
+if (schemaLocation != NULL) {
+xmlChar *base = NULL;
+xmlChar *URI = NULL;
+check = xmlParseURI((const char *) schemaLocation);
+if (check == NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
+"Include schemaLocation attribute is not an URI: %s\n",
+schemaLocation, NULL);
+return (-1);
+} else {
+xmlFreeURI(check);
+}
+base = xmlNodeGetBase(node->doc, node);
+if (base == NULL) {
+URI = xmlBuildURI(schemaLocation, node->doc->URL);
+} else {
+URI = xmlBuildURI(schemaLocation, base);
+xmlFree(base);
+}
+if (URI != NULL) {
+schemaLocation = xmlDictLookup(ctxt->dict, URI, -1);
+xmlFree(URI);
+}
+} else {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
+"Include schemaLocation attribute missing\n",
+NULL, NULL);
+return (-1);
+}
+child = node->children;
+while (IS_SCHEMA(child, "annotation")) {
+/*
+* the annotations here are simply discarded ...
+*/
+child = child->next;
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
+"Include has unexpected content\n", NULL, NULL);
+return (-1);
+}
+/*
+* First step is to parse the input document into an DOM/Infoset
+*/
+doc = xmlReadFile((const char *) schemaLocation, NULL,
+SCHEMAS_PARSE_OPTIONS);
+if (doc == NULL) {
+xmlSchemaPErr(ctxt, NULL,
+XML_SCHEMAP_FAILED_LOAD,
+"xmlSchemaParse: could not load %s\n",
+ctxt->URL, NULL);
+return(-1);
+}
+/*
+* Then extract the root of the schema
+*/
+root = xmlDocGetRootElement(doc);
+if (root == NULL) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+XML_SCHEMAP_NOROOT,
+"schemas %s has no root", schemaLocation, NULL);
+xmlFreeDoc(doc);
+return (-1);
+}
+/*
+* Remove all the blank text nodes
+*/
+xmlSchemaCleanupDoc(ctxt, root);
+/*
+* Check the schemas top level element
+*/
+if (!IS_SCHEMA(root, "schema")) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+XML_SCHEMAP_NOT_SCHEMA,
+"File %s is not a schemas", schemaLocation, NULL);
+xmlFreeDoc(doc);
+return (-1);
+}
+/*
+* register the include
+*/
+include = (xmlSchemaIncludePtr) xmlMalloc(sizeof(xmlSchemaInclude));
+if (include == NULL) {
+xmlSchemaPErrMemory(ctxt, "allocating included schema", NULL);
+xmlFreeDoc(doc);
+return (-1);
+}
+memset(include, 0, sizeof(xmlSchemaInclude));
+include->schemaLocation = xmlDictLookup(ctxt->dict, schemaLocation, -1);
+include->doc = doc;
+include->next = schema->includes;
+schema->includes = include;
+/*
+* parse the declarations in the included file like if they
+* were in the original file.
+*/
+xmlSchemaParseSchemaTopLevel(ctxt, schema, root->children);
+return (1);
+}
+/**
+* xmlSchemaParseChoice:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Choice 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
+xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype, last = NULL;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "choice %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_CHOICE;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->minOccurs = xmlGetMinOccurs(ctxt, node);
+type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+while ((IS_SCHEMA(child, "element")) ||
+(IS_SCHEMA(child, "group")) ||
+(IS_SCHEMA(child, "any")) ||
+(IS_SCHEMA(child, "choice")) ||
+(IS_SCHEMA(child, "sequence"))) {
+subtype = NULL;
+if (IS_SCHEMA(child, "element")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseElement(ctxt, schema, child, 0);
+} else if (IS_SCHEMA(child, "group")) {
+subtype = xmlSchemaParseGroup(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "any")) {
+subtype = xmlSchemaParseAny(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = xmlSchemaParseSequence(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+}
+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) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
+"Choice %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* xmlSchemaParseSequence:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Sequence 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
+xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype, last = NULL;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "sequence %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_SEQUENCE;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->minOccurs = xmlGetMinOccurs(ctxt, node);
+type->maxOccurs = xmlGetMaxOccurs(ctxt, node);
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+while ((IS_SCHEMA(child, "element")) ||
+(IS_SCHEMA(child, "group")) ||
+(IS_SCHEMA(child, "any")) ||
+(IS_SCHEMA(child, "choice")) ||
+(IS_SCHEMA(child, "sequence"))) {
+subtype = NULL;
+if (IS_SCHEMA(child, "element")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseElement(ctxt, schema, child, 0);
+} else if (IS_SCHEMA(child, "group")) {
+subtype = xmlSchemaParseGroup(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "any")) {
+subtype = xmlSchemaParseAny(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = xmlSchemaParseSequence(ctxt, schema, child);
+}
+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) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
+"Sequence %s has unexpected content\n", type->name,
+NULL);
+}
+return (type);
+}
+/**
+* xmlSchemaParseRestriction:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+* @simple:  is that part of a simple type.
+*
+* 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, int simple)
+{
+xmlSchemaTypePtr type, subtype;
+xmlSchemaFacetPtr facet, lastfacet = NULL;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+const xmlChar *oldcontainer;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+oldcontainer = ctxt->container;
+snprintf((char *) name, 30, "restriction %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_RESTRICTION;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+type->base = xmlGetQNameProp(ctxt, node, "base", &(type->baseNs));
+if ((!simple) && (type->base == NULL)) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
+"Restriction %s has no base\n", type->name, NULL);
+}
+ctxt->container = name;
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "all")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseAll(ctxt, schema, child);
+child = child->next;
+type->subtypes = subtype;
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+child = child->next;
+type->subtypes = subtype;
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseSequence(ctxt, schema, child);
+child = child->next;
+type->subtypes = subtype;
+} else if (IS_SCHEMA(child, "group")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseGroup(ctxt, schema, child);
+child = child->next;
+type->subtypes = subtype;
+} else {
+if (IS_SCHEMA(child, "simpleType")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseSimpleType(ctxt, schema, child);
+child = child->next;
+type->baseType = subtype;
+}
+/*
+* Facets
+*/
+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;
+lastfacet = facet;
+} else {
+lastfacet->next = facet;
+lastfacet = facet;
+}
+lastfacet->next = NULL;
+}
+child = child->next;
+}
+}
+child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
+"Restriction %s has unexpected content\n",
+type->name, NULL);
+}
+ctxt->container = oldcontainer;
+return (type);
+}
+/**
+* xmlSchemaParseExtension:
+* @ctxt:  a schema validation context
+* @schema:  the schema being built
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema Extension definition
+* *WARNING* this interface is highly subject to change
+*
+* Returns the type definition or NULL in case of error
+*/
+static xmlSchemaTypePtr
+xmlSchemaParseExtension(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
+xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+const xmlChar *oldcontainer;
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+oldcontainer = ctxt->container;
+snprintf((char *) name, 30, "extension %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_EXTENSION;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+ctxt->container = name;
+type->base = xmlGetQNameProp(ctxt, node, "base", &(type->baseNs));
+if (type->base == NULL) {
+xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_EXTENSION_NO_BASE,
+"Extension %s has no base\n", type->name, NULL);
+}
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "all")) {
+subtype = xmlSchemaParseAll(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = xmlSchemaParseSequence(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "group")) {
+subtype = xmlSchemaParseGroup(ctxt, schema, child);
+child = child->next;
+}
+if (subtype != NULL)
+type->subtypes = subtype;
+child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
+"Extension %s has unexpected content\n", type->name,
+NULL);
+}
+ctxt->container = oldcontainer;
+return (type);
+}
+/**
+* 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 xmlSchemaTypePtr
+xmlSchemaParseSimpleContent(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "simpleContent %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_SIMPLE_CONTENT;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "restriction")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseRestriction(ctxt, schema, child, 0);
+child = child->next;
+} else if (IS_SCHEMA(child, "extension")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseExtension(ctxt, schema, child);
+child = child->next;
+}
+type->subtypes = subtype;
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
+"SimpleContent %s has unexpected content\n",
+type->name, NULL);
+}
+return (type);
+}
+/**
+* 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 xmlSchemaTypePtr
+xmlSchemaParseComplexContent(xmlSchemaParserCtxtPtr ctxt,
+xmlSchemaPtr schema, xmlNodePtr node)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+xmlChar name[30];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+snprintf((char *) name, 30, "complexContent %d", ctxt->counter++ + 1);
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+if (type == NULL)
+return (NULL);
+type->node = node;
+type->type = XML_SCHEMA_TYPE_COMPLEX_CONTENT;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+subtype = NULL;
+if (IS_SCHEMA(child, "restriction")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseRestriction(ctxt, schema, child, 0);
+child = child->next;
+} else if (IS_SCHEMA(child, "extension")) {
+subtype = (xmlSchemaTypePtr)
+xmlSchemaParseExtension(ctxt, schema, child);
+child = child->next;
+}
+type->subtypes = subtype;
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
+"ComplexContent %s has unexpected content\n",
+type->name, NULL);
+}
+return (type);
+}
+/**
+* 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)
+{
+xmlSchemaTypePtr type, subtype;
+xmlNodePtr child = NULL;
+const xmlChar *name;
+const xmlChar *oldcontainer;
+char buf[100];
+if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
+return (NULL);
+oldcontainer = ctxt->container;
+name = xmlSchemaGetProp(ctxt, node, "name");
+if (name == NULL) {
+snprintf(buf, 99, "complexType %d", ctxt->counter++ + 1);
+name = (const xmlChar *)buf;
+type = xmlSchemaAddType(ctxt, schema, name, NULL);
+} else {
+/* local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); */
+type = xmlSchemaAddType(ctxt, schema, name, schema->targetNamespace);
+}
+if (type == NULL) {
+return (NULL);
+}
+if (xmlGetBooleanProp(ctxt, node, "mixed", 0))
+type->flags |= XML_SCHEMAS_TYPE_MIXED;
+type->node = node;
+type->type = XML_SCHEMA_TYPE_COMPLEX;
+type->id = xmlSchemaGetProp(ctxt, node, "id");
+ctxt->container = name;
+child = node->children;
+if (IS_SCHEMA(child, "annotation")) {
+type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
+child = child->next;
+}
+if (IS_SCHEMA(child, "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;
+type->subtypes = xmlSchemaParseSimpleContent(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "complexContent")) {
+type->subtypes = xmlSchemaParseComplexContent(ctxt, schema, child);
+child = child->next;
+} else {
+subtype = NULL;
+if (IS_SCHEMA(child, "all")) {
+subtype = xmlSchemaParseAll(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "choice")) {
+subtype = xmlSchemaParseChoice(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "sequence")) {
+subtype = xmlSchemaParseSequence(ctxt, schema, child);
+child = child->next;
+} else if (IS_SCHEMA(child, "group")) {
+subtype = xmlSchemaParseGroup(ctxt, schema, child);
+child = child->next;
+}
+if (subtype != NULL)
+type->subtypes = subtype;
+child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
+}
+if (child != NULL) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
+"ComplexType %s has unexpected content\n",
+type->name, NULL);
+}
+ctxt->container = oldcontainer;
+return (type);
+}
+/**
+* xmlSchemaParseSchema:
+* @ctxt:  a schema validation context
+* @node:  a subtree containing XML Schema informations
+*
+* parse a XML schema definition from a node set
+* *WARNING* this interface is highly subject to change
+*
+* Returns the internal XML Schema structure built from the resource or
+*         NULL in case of error
+*/
+static xmlSchemaPtr
+xmlSchemaParseSchema(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
+{
+xmlSchemaPtr schema = NULL;
+xmlNodePtr child = NULL;
+const xmlChar *val;
+int nberrors;
+if ((ctxt == NULL) || (node == NULL))
+return (NULL);
+nberrors = ctxt->nberrors;
+ctxt->nberrors = 0;
+if (IS_SCHEMA(node, "schema")) {
+schema = xmlSchemaNewSchema(ctxt);
+if (schema == NULL)
+return (NULL);
+val = xmlSchemaGetProp(ctxt, node, "targetNamespace");
+if (val != NULL) {
+schema->targetNamespace = xmlDictLookup(ctxt->dict, val, -1);
+} else {
+schema->targetNamespace = NULL;
+}
+schema->id = xmlSchemaGetProp(ctxt, node, "id");
+schema->version = xmlSchemaGetProp(ctxt, node, "version");
+val = xmlSchemaGetProp(ctxt, node, "elementFormDefault");
+if (val != NULL) {
+if (xmlStrEqual(val, BAD_CAST "qualified"))
+schema->flags |= XML_SCHEMAS_QUALIF_ELEM;
+else if (!xmlStrEqual(val, BAD_CAST "unqualified")) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
+"Invalid value %s for elementFormDefault\n",
+val, NULL);
+}
+} else {
+schema->flags |= XML_SCHEMAS_QUALIF_ELEM;
+}
+val = xmlSchemaGetProp(ctxt, node, "attributeFormDefault");
+if (val != NULL) {
+if (xmlStrEqual(val, BAD_CAST "qualified"))
+schema->flags |= XML_SCHEMAS_QUALIF_ATTR;
+else if (!xmlStrEqual(val, BAD_CAST "unqualified")) {
+xmlSchemaPErr2(ctxt, node, child,
+XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
+"Invalid value %s for attributeFormDefault\n",
+val, NULL);
+}
+}
+xmlSchemaParseSchemaTopLevel(ctxt, schema, node->children);
+} else {
+xmlDocPtr doc;
+doc = node->doc;
+if ((doc != NULL) && (doc->URL != NULL)) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+XML_SCHEMAP_NOT_SCHEMA,
+"File %s is not a schemas", doc->URL, NULL);
+} else {
+xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+XML_SCHEMAP_NOT_SCHEMA,
+"File is not a schemas", NULL, NULL);
+}
+return(NULL);
+}
+if (ctxt->nberrors != 0) {
+if (schema != NULL) {
+xmlSchemaFree(schema);
+schema = NULL;
+}
+}
+ctxt->nberrors = nberrors;
+#ifdef DEBUG
+if (schema == NULL)
+xmlGenericError(xmlGenericErrorContext,
+"xmlSchemaParse() failed\n");
+#endif
+return (schema);
+}
+/************************************************************************
+*                                  *
+*          Validating using Schemas            *
+*                                  *
+************************************************************************/
+/************************************************************************
+*                                  *
+*          Reading/Writing Schemas             *
+*                                  *
+************************************************************************/
+/**
+* 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 = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+if (ret == NULL) {
+xmlSchemaPErrMemory(NULL, "allocating schama parser context",
+NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+ret->dict = xmlDictCreate();
+ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
+ret->includes = 0;
+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 = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+if (ret == NULL) {
+xmlSchemaPErrMemory(NULL, "allocating schama parser context",
+NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+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 = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
+if (ret == NULL) {
+xmlSchemaPErrMemory(NULL, "allocating schema parser context",
+NULL);
+return (NULL);
+}
+memset(ret, 0, sizeof(xmlSchemaParserCtxt));
+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);
+xmlDictFree(ctxt->dict);
+xmlFree(ctxt);
+}
+/************************************************************************
+*                                  *
+*          Building the content models         *
+*                                  *
+************************************************************************/
+/**
+* xmlSchemaBuildAContentModel:
+* @type:  the schema type definition
+* @ctxt:  the schema parser context
+* @name:  the element name whose content is being built
+*
+* Generate the automata sequence needed for that type
+*/
+static void
+xmlSchemaBuildAContentModel(xmlSchemaTypePtr type,
+xmlSchemaParserCtxtPtr ctxt,
+const xmlChar * name)
+{
+if (type == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+"Found unexpected type = NULL in %s content model\n",
+name);
+return;
+}
+switch (type->type) {
+case XML_SCHEMA_TYPE_ANY:
+/* TODO : handle the namespace too */
+/* TODO : make that a specific transition type */
+TODO ctxt->state =
+xmlAutomataNewTransition(ctxt->am, ctxt->state, NULL,
+BAD_CAST "*", NULL);
+break;
+case XML_SCHEMA_TYPE_ELEMENT:{
+xmlSchemaElementPtr elem = (xmlSchemaElementPtr) type;
+/* TODO : handle the namespace too */
+xmlAutomataStatePtr oldstate = ctxt->state;
+if (elem->maxOccurs >= UNBOUNDED) {
+if (elem->minOccurs > 1) {
+xmlAutomataStatePtr tmp;
+int counter;
+ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+oldstate,
+NULL);
+oldstate = ctxt->state;
+counter = xmlAutomataNewCounter(ctxt->am,
+elem->minOccurs -
+1, UNBOUNDED);
+if (elem->refDecl != NULL) {
+xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+elem->refDecl,
+ctxt,
+elem->refDecl->
+name);
+} else {
+ctxt->state =
+xmlAutomataNewTransition(ctxt->am,
+ctxt->state, NULL,
+elem->name, type);
+}
+tmp = ctxt->state;
+xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+counter);
+ctxt->state =
+xmlAutomataNewCounterTrans(ctxt->am, tmp, NULL,
+counter);
+} else {
+if (elem->refDecl != NULL) {
+xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+elem->refDecl,
+ctxt,
+elem->refDecl->
+name);
+} else {
+ctxt->state =
+xmlAutomataNewTransition(ctxt->am,
+ctxt->state, NULL,
+elem->name, type);
+}
+xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
+oldstate);
+if (elem->minOccurs == 0) {
+/* basically an elem* */
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+}
+} else if ((elem->maxOccurs > 1) || (elem->minOccurs > 1)) {
+xmlAutomataStatePtr tmp;
+int counter;
+ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+oldstate, NULL);
+oldstate = ctxt->state;
+counter = xmlAutomataNewCounter(ctxt->am,
+elem->minOccurs - 1,
+elem->maxOccurs - 1);
+if (elem->refDecl != NULL) {
+xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+elem->refDecl, ctxt,
+elem->refDecl->name);
+} else {
+ctxt->state = xmlAutomataNewTransition(ctxt->am,
+ctxt->state,
+NULL,
+elem->name,
+type);
+}
+tmp = ctxt->state;
+xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+counter);
+ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, tmp,
+NULL,
+counter);
+if (elem->minOccurs == 0) {
+/* basically an elem? */
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+} else {
+if (elem->refDecl != NULL) {
+xmlSchemaBuildAContentModel((xmlSchemaTypePtr)
+elem->refDecl, ctxt,
+elem->refDecl->name);
+} else {
+ctxt->state = xmlAutomataNewTransition(ctxt->am,
+ctxt->state,
+NULL,
+elem->name,
+type);
+}
+if (elem->minOccurs == 0) {
+/* basically an elem? */
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+}
+break;
+}
+case XML_SCHEMA_TYPE_SEQUENCE:{
+xmlSchemaTypePtr subtypes;
+/*
+* If max and min occurances are default (1) then
+* simply iterate over the subtypes
+*/
+if ((type->minOccurs == 1) && (type->maxOccurs == 1)) {
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+subtypes = subtypes->next;
+}
+} else {
+xmlAutomataStatePtr oldstate = ctxt->state;
+if (type->maxOccurs >= UNBOUNDED) {
+if (type->minOccurs > 1) {
+xmlAutomataStatePtr tmp;
+int counter;
+ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+oldstate,
+NULL);
+oldstate = ctxt->state;
+counter = xmlAutomataNewCounter(ctxt->am,
+type->
+minOccurs - 1,
+UNBOUNDED);
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt,
+name);
+subtypes = subtypes->next;
+}
+tmp = ctxt->state;
+xmlAutomataNewCountedTrans(ctxt->am, tmp,
+oldstate, counter);
+ctxt->state =
+xmlAutomataNewCounterTrans(ctxt->am, tmp,
+NULL, counter);
+} else {
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt,
+name);
+subtypes = subtypes->next;
+}
+xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
+oldstate);
+if (type->minOccurs == 0) {
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+}
+} else if ((type->maxOccurs > 1)
+|| (type->minOccurs > 1)) {
+xmlAutomataStatePtr tmp;
+int counter;
+ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
+oldstate,
+NULL);
+oldstate = ctxt->state;
+counter = xmlAutomataNewCounter(ctxt->am,
+type->minOccurs -
+1,
+type->maxOccurs -
+1);
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt,
+name);
+subtypes = subtypes->next;
+}
+tmp = ctxt->state;
+xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
+counter);
+ctxt->state =
+xmlAutomataNewCounterTrans(ctxt->am, tmp, NULL,
+counter);
+if (type->minOccurs == 0) {
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+} else {
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt,
+name);
+subtypes = subtypes->next;
+}
+if (type->minOccurs == 0) {
+xmlAutomataNewEpsilon(ctxt->am, oldstate,
+ctxt->state);
+}
+}
+}
+break;
+}
+case XML_SCHEMA_TYPE_CHOICE:{
+xmlSchemaTypePtr subtypes;
+xmlAutomataStatePtr start, end;
+start = ctxt->state;
+end = xmlAutomataNewState(ctxt->am);
+/*
+* iterate over the subtypes and remerge the end with an
+* epsilon transition
+*/
+if (type->maxOccurs == 1) {
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+ctxt->state = start;
+xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
+subtypes = subtypes->next;
+}
+} else {
+int counter;
+xmlAutomataStatePtr hop;
+int maxOccurs = type->maxOccurs == UNBOUNDED ?
+UNBOUNDED : type->maxOccurs - 1;
+int minOccurs =
+type->minOccurs < 1 ? 0 : type->minOccurs - 1;
+/*
+* use a counter to keep track of the number of transtions
+* which went through the choice.
+*/
+counter =
+xmlAutomataNewCounter(ctxt->am, minOccurs,
+maxOccurs);
+hop = xmlAutomataNewState(ctxt->am);
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+ctxt->state = start;
+xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
+subtypes = subtypes->next;
+}
+xmlAutomataNewCountedTrans(ctxt->am, hop, start,
+counter);
+xmlAutomataNewCounterTrans(ctxt->am, hop, end,
+counter);
+}
+if (type->minOccurs == 0) {
+xmlAutomataNewEpsilon(ctxt->am, start, end);
+}
+ctxt->state = end;
+break;
+}
+case XML_SCHEMA_TYPE_ALL:{
+xmlAutomataStatePtr start;
+xmlSchemaTypePtr subtypes;
+xmlSchemaElementPtr elem = (xmlSchemaElementPtr) type;
+int lax;
+subtypes = type->subtypes;
+if (subtypes == NULL)
+break;
+start = ctxt->state;
+while (subtypes != NULL) {
+ctxt->state = start;
+/*
+* the following 'if' was needed to fix bug 139897
+* not quite sure why it only needs to be done for
+* elements with a 'ref', but it seems to work ok.
+*/
+if (subtypes->ref != NULL)
+xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+elem = (xmlSchemaElementPtr) subtypes;
+/* TODO : handle the namespace too */
+if ((elem->minOccurs == 1) && (elem->maxOccurs == 1)) {
+xmlAutomataNewOnceTrans(ctxt->am, ctxt->state,
+ctxt->state, elem->name, 1,
+1, subtypes);
+} else {
+xmlAutomataNewCountTrans(ctxt->am, ctxt->state,
+ctxt->state, elem->name,
+elem->minOccurs,
+elem->maxOccurs,
+subtypes);
+}
+subtypes = subtypes->next;
+}
+lax = type->minOccurs == 0;
+ctxt->state =
+xmlAutomataNewAllTrans(ctxt->am, ctxt->state, NULL,
+lax);
+break;
+}
+case XML_SCHEMA_TYPE_RESTRICTION:
+if (type->subtypes != NULL)
+xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+break;
+case XML_SCHEMA_TYPE_EXTENSION:
+if (type->baseType != NULL) {
+xmlSchemaTypePtr subtypes;
+if (type->recurse) {
+xmlSchemaPErr(ctxt, type->node,
+XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+"Schemas: extension type %s is recursive\n",
+type->name, NULL);
+return;
+}
+type->recurse = 1;
+xmlSchemaBuildAContentModel(type->baseType, ctxt, name);
+type->recurse = 0;
+subtypes = type->subtypes;
+while (subtypes != NULL) {
+xmlSchemaBuildAContentModel(subtypes, ctxt, name);
+subtypes = subtypes->next;
+}
+} else if (type->subtypes != NULL)
+xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+break;
+case XML_SCHEMA_TYPE_GROUP:
+if (type->subtypes == NULL) {
+xmlSchemaTypePtr rgroup;
+if (type->ref != NULL) {
+rgroup = xmlHashLookup2(ctxt->schema->groupDecl, type->ref,
+type->refNs);
+if (rgroup == NULL) {
+xmlSchemaPErr(ctxt, type->node,
+XML_SCHEMAP_UNKNOWN_REF,
+"Schemas: group %s reference %s is not found",
+name, type->ref);
+return;
+}
+xmlSchemaBuildAContentModel(rgroup, ctxt, name);
+break;
+}
+}
+case XML_SCHEMA_TYPE_COMPLEX:
+case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
+if (type->subtypes != NULL)
+xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
+break;
+default:
+xmlGenericError(xmlGenericErrorContext,
+"Found unexpected type %d in %s content model\n",
+type->type, name);
+return;
+}
+}
+/**
+* xmlSchemaBuildContentModel:
+* @elem:  the element
+* @ctxt:  the schema parser context
+* @name:  the element name
+*
+* Builds the content model of the element.
+*/
+static void
+xmlSchemaBuildContentModel(xmlSchemaElementPtr elem,
+xmlSchemaParserCtxtPtr ctxt,
+const xmlChar * name)
+{
+xmlAutomataStatePtr start;
+if (elem->contModel != NULL)
+return;
+if (elem->subtypes == NULL) {
+elem->contentType = XML_SCHEMA_CONTENT_ANY;
+return;
+}
+if (elem->subtypes->type != XML_SCHEMA_TYPE_COMPLEX)
+return;
+if ((elem->subtypes->contentType == XML_SCHEMA_CONTENT_BASIC) ||
+(elem->subtypes->contentType == XML_SCHEMA_CONTENT_SIMPLE))
+return;
+#ifdef DEBUG_CONTENT
+xmlGenericError(xmlGenericErrorContext,
+"Building content model for %s\n", name);
+#endif
+ctxt->am = xmlNewAutomata();
+if (ctxt->am == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+"Cannot create automata for elem %s\n", name);
+return;
+}
+start = ctxt->state = xmlAutomataGetInitState(ctxt->am);
+xmlSchemaBuildAContentModel(elem->subtypes, ctxt, name);
+xmlAutomataSetFinalState(ctxt->am, ctxt->state);
+elem->contModel = xmlAutomataCompile(ctxt->am);
+if (elem->contModel == NULL) {
+xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAS_ERR_INTERNAL,
+"failed to compile %s content model\n", name, NULL);
+} else if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
+xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAS_ERR_NOTDETERMINIST,
+"Content model of %s is not determinist:\n", name,
+NULL);
+} else {
+#ifdef DEBUG_CONTENT_REGEXP
+xmlGenericError(xmlGenericErrorContext,
+"Content model of %s:\n", name);
+xmlRegexpPrint(stderr, elem->contModel);
+#endif
+}
+ctxt->state = NULL;
+xmlFreeAutomata(ctxt->am);
+ctxt->am = NULL;
+}
+/**
+* xmlSchemaRefFixupCallback:
+* @elem:  the schema element context
+* @ctxt:  the schema parser context
+*
+* Free the resources associated to the schema parser context
+*/
+static void
+xmlSchemaRefFixupCallback(xmlSchemaElementPtr elem,
+xmlSchemaParserCtxtPtr ctxt,
+const xmlChar * name,
+const xmlChar * context ATTRIBUTE_UNUSED,
+const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
+if ((ctxt == NULL) || (elem == NULL))
+return;
+if (elem->ref != NULL) {
+xmlSchemaElementPtr elemDecl;
+if (elem->subtypes != NULL) {
+xmlSchemaPErr(ctxt, elem->node,
+XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
+"Schemas: element %s have both ref and subtype\n",
+name, NULL);
+return;
+}
+elemDecl = xmlSchemaGetElem(ctxt->schema, elem->ref, elem->refNs, 0);
+if (elemDecl == NULL) {
+xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_UNKNOWN_REF,
+"Schemas: element %s ref to %s not found\n",
+name, elem->ref);
+return;
+}
+elem->refDecl = elemDecl;
+} else if (elem->namedType != NULL) {
+xmlSchemaTypePtr typeDecl;
+if (elem->subtypes != NULL) {
+xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_TYPE_AND_SUBTYPE,
+"Schemas: element %s have both type and subtype\n",
+name, NULL);
+return;
+}
+typeDecl = xmlSchemaGetType(ctxt->schema, elem->namedType,
+elem->namedTypeNs);
+if (typeDecl == NULL) {
+xmlSchemaPErr(ctxt, elem->node, XML_SCHEMAP_UNKNOWN_TYPE,
+"Schemas: element %s type %s not found\n", name,
+elem->namedType);
+return;
+}
+elem->subtypes = typeDecl;
+}
+}
+/**
+* xmlSchemaParseListRefFixup:
+* @type:  the schema type definition
+* @ctxt:  the schema parser context
+*
+* Fixup of the itemType reference of the list type.
+*/
+static void
+xmlSchemaParseListRefFixup(xmlSchemaTypePtr type, xmlSchemaParserCtxtPtr ctxt)
+{
+const xmlChar *itemType, *namespace;
+xmlSchemaTypePtr subtype;
+/* Handle the "itemType" attribute. */
+itemType = xmlGetQNameProp(ctxt, type->node, "itemType", &namespace);
+if (itemType != NULL) {
+/* Do not allow more that one item type. */
+if (type->subtypes != NULL) {
+xmlSchemaPErr(ctxt, type->node,
+XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
+"List %s has more than one item type defined\n",
+type->name, NULL);
+}
+subtype = xmlSchemaGetType(ctxt->schema, itemType, namespace);
+if (subtype == NULL) {
+xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_UNKNOWN_TYPE,
+"List %s references an unknown item type: %s\n",
+type->name, xmlSchemaGetProp(ctxt, type->node,
+"itemType"));
+} else
+type->subtypes = subtype;
+}
+}
+/**
+* xmlSchemaParseUnionRefCheck:
+* @typeDecl:  the schema type definition
+* @ctxt:  the schema parser context
+*
+* Checks the memberTypes references of the union type.
+*/
+static void
+xmlSchemaParseUnionRefCheck(xmlSchemaTypePtr type,
+xmlSchemaParserCtxtPtr ctxt)
+{
+const xmlChar *cur, *end, *prefix, *ncName, *namespace;
+xmlChar *tmp;
+xmlSchemaTypePtr subtype;
+xmlNsPtr ns;
+int len;
+if ((type->type != XML_SCHEMA_TYPE_UNION) || (type->ref == NULL))
+return;
+cur = type->ref;
+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);
+ncName = xmlSplitQName3(tmp, &len);
+if (ncName != NULL) {
+prefix = xmlDictLookup(ctxt->dict, tmp, len);
+} else {
+prefix = NULL;
+ncName = tmp;
+}
+ns = xmlSearchNs(type->node->doc, type->node, prefix);
+if (ns == NULL) {
+if (prefix != NULL) {
+xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_PREFIX_UNDEFINED,
+"Union %s: the namespace prefix of member type "
+"%s is undefined\n",
+type->name, (const xmlChar *) tmp);
+}
+namespace = NULL;
+} else {
+namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
+}
+/* Lookup the referenced type */
+subtype = xmlSchemaGetType(ctxt->schema, ncName, namespace);
+if (subtype == NULL) {
+xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
+"Union %s references an unknown member type %s\n",
+type->name,  (const xmlChar *) tmp);
+}
+xmlFree(tmp);
+cur = end;
+} while (*cur != 0);
+}
+/**
+* xmlSchemaTypeFixup:
+* @typeDecl:  the schema type definition
+* @ctxt:  the schema parser context
+*
+* Fixes the content model of the type.
+*/
+static void
+xmlSchemaTypeFixup(xmlSchemaTypePtr typeDecl,
+xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+if (typeDecl == NULL)
+return;
+if (name == NULL)
+name = typeDecl->name;
+if (typeDecl->contentType == XML_SCHEMA_CONTENT_UNKNOWN) {
+switch (typeDecl->type) {
+case XML_SCHEMA_TYPE_SIMPLE_CONTENT:{
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+if (typeDecl->subtypes != NULL)
+typeDecl->contentType =
+typeDecl->subtypes->contentType;
+break;
+}
+case XML_SCHEMA_TYPE_RESTRICTION:{
+if (typeDecl->subtypes != NULL)
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+if (typeDecl->base != NULL) {
+xmlSchemaTypePtr baseType;
+baseType =
+xmlSchemaGetType(ctxt->schema, typeDecl->base,
+typeDecl->baseNs);
+if (baseType == NULL) {
+xmlSchemaPErr(ctxt, typeDecl->node,
+XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+"Schemas: type %s base type %s not found\n",
+name, typeDecl->base);
+}
+typeDecl->baseType = baseType;
+}
+if (typeDecl->subtypes == NULL)
+if (typeDecl->baseType != NULL) {
+/* The base type might be not "type fixed" yet,
+* so do it now. */
+if (typeDecl->baseType->contentType ==
+XML_SCHEMA_CONTENT_UNKNOWN)
+xmlSchemaTypeFixup(typeDecl->baseType, ctxt, NULL);
+typeDecl->contentType =
+typeDecl->baseType->contentType;
+} else
+/* 1.1.1 */
+typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+else if ((typeDecl->subtypes->subtypes == NULL) &&
+((typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_ALL)
+|| (typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_SEQUENCE)))
+/* 1.1.2 */
+typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+else if ((typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_CHOICE)
+&& (typeDecl->subtypes->subtypes == NULL))
+/* 1.1.3 */
+typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+else {
+/* 1.2 and 2.X are applied at the other layer */
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_ELEMENTS;
+}
+break;
+}
+case XML_SCHEMA_TYPE_EXTENSION:{
+xmlSchemaContentType explicitContentType;
+xmlSchemaTypePtr base;
+if (typeDecl->base != NULL) {
+xmlSchemaTypePtr baseType;
+baseType =
+xmlSchemaGetType(ctxt->schema, typeDecl->base,
+typeDecl->baseNs);
+if (baseType == NULL) {
+xmlSchemaPErr(ctxt, typeDecl->node,
+XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+"Schemas: type %s base type %s not found\n",
+name, typeDecl->base);
+}
+typeDecl->baseType = baseType;
+}
+if (typeDecl->subtypes != NULL)
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+explicitContentType = XML_SCHEMA_CONTENT_ELEMENTS;
+if (typeDecl->subtypes == NULL)
+/* 1.1.1 */
+explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+else if ((typeDecl->subtypes->subtypes == NULL) &&
+((typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_ALL)
+|| (typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_SEQUENCE)))
+/* 1.1.2 */
+explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+else if ((typeDecl->subtypes->type ==
+XML_SCHEMA_TYPE_CHOICE)
+&& (typeDecl->subtypes->subtypes == NULL))
+/* 1.1.3 */
+explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
+base = xmlSchemaGetType(ctxt->schema, typeDecl->base,
+typeDecl->baseNs);
+if (base == NULL) {
+xmlSchemaPErr(ctxt, typeDecl->node,
+XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+"Schemas: base type %s of type %s not found\n",
+typeDecl->base, name);
+return;
+}
+if (typeDecl->recurse) {
+xmlSchemaPErr(ctxt, typeDecl->node,
+XML_SCHEMAP_UNKNOWN_BASE_TYPE,
+"Schemas: extension type %s is recursive\n",
+name, NULL);
+return;
+}
+typeDecl->recurse = 1;
+xmlSchemaTypeFixup(base, ctxt, NULL);
+typeDecl->recurse = 0;
+if (explicitContentType == XML_SCHEMA_CONTENT_EMPTY) {
+/* 2.1 */
+typeDecl->contentType = base->contentType;
+} else if (base->contentType ==
+XML_SCHEMA_CONTENT_EMPTY) {
+/* 2.2 imbitable ! */
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_ELEMENTS;
+} else {
+/* 2.3 imbitable pareil ! */
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_ELEMENTS;
+}
+break;
+}
+case XML_SCHEMA_TYPE_COMPLEX:{
+if (typeDecl->subtypes == NULL) {
+typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_MIXED;
+} else {
+if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_MIXED;
+else {
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt,
+NULL);
+if (typeDecl->subtypes != NULL)
+typeDecl->contentType =
+typeDecl->subtypes->contentType;
+}
+if (typeDecl->attributes == NULL)
+typeDecl->attributes =
+typeDecl->subtypes->attributes;
+}
+break;
+}
+case XML_SCHEMA_TYPE_COMPLEX_CONTENT:{
+if (typeDecl->subtypes == NULL) {
+typeDecl->contentType = XML_SCHEMA_CONTENT_EMPTY;
+if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_MIXED;
+} else {
+if (typeDecl->flags & XML_SCHEMAS_TYPE_MIXED)
+typeDecl->contentType =
+XML_SCHEMA_CONTENT_MIXED;
+else {
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt,
+NULL);
+if (typeDecl->subtypes != NULL)
+typeDecl->contentType =
+typeDecl->subtypes->contentType;
+}
+if (typeDecl->attributes == NULL)
+typeDecl->attributes =
+typeDecl->subtypes->attributes;
+}
+break;
+}
+case XML_SCHEMA_TYPE_SEQUENCE:
+case XML_SCHEMA_TYPE_GROUP:
+case XML_SCHEMA_TYPE_ALL:
+case XML_SCHEMA_TYPE_CHOICE:
+typeDecl->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
+break;
+case XML_SCHEMA_TYPE_BASIC:
+case XML_SCHEMA_TYPE_ANY:
+case XML_SCHEMA_TYPE_FACET:
+case XML_SCHEMA_TYPE_SIMPLE:
+case XML_SCHEMA_TYPE_UR:
+case XML_SCHEMA_TYPE_ELEMENT:
+case XML_SCHEMA_TYPE_ATTRIBUTE:
+case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
+case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
+case XML_SCHEMA_TYPE_NOTATION:
+case XML_SCHEMA_TYPE_LIST:
+xmlSchemaParseListRefFixup(typeDecl, ctxt);
+case XML_SCHEMA_TYPE_UNION:
+xmlSchemaParseUnionRefCheck(typeDecl, ctxt);
+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:
+typeDecl->contentType = XML_SCHEMA_CONTENT_SIMPLE;
+if (typeDecl->subtypes != NULL)
+xmlSchemaTypeFixup(typeDecl->subtypes, ctxt, NULL);
+break;
+}
+}
+#ifdef DEBUG_TYPE
+if (typeDecl->node != NULL) {
+xmlGenericError(xmlGenericErrorContext,
+"Type of %s : %s:%d :", name,
+typeDecl->node->doc->URL,
+xmlGetLineNo(typeDecl->node));
+} else {
+xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
+}
+switch (typeDecl->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:
+xmlGenericError(xmlGenericErrorContext, "mixed\n");
+break;
+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
+}
+///#if defined(LIBXML_SCHEMAS_ENABLED)
+/**
+* xmlSchemaCheckFacet:
+* @facet:  the facet
+* @typeDecl:  the schema type definition
+* @ctxt:  the schema parser context or NULL
+* @name: name of the type
+*
+* Checks the default values types, especially for facets
+*
+* Returns 0 if okay or -1 in cae of error
+*/
+int
+xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
+xmlSchemaTypePtr typeDecl,
+xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+static xmlSchemaTypePtr nonNegativeIntegerType = NULL;
+int ret = 0;
+if (nonNegativeIntegerType == NULL) {
+nonNegativeIntegerType =
+xmlSchemaGetPredefinedType(BAD_CAST "nonNegativeInteger",
+xmlSchemaNs);
+}
+switch (facet->type) {
+case XML_SCHEMA_FACET_MININCLUSIVE:
+case XML_SCHEMA_FACET_MINEXCLUSIVE:
+case XML_SCHEMA_FACET_MAXINCLUSIVE:
+case XML_SCHEMA_FACET_MAXEXCLUSIVE:{
+/*
+* Okay we need to validate the value
+* at that point.
+*/
+xmlSchemaValidCtxtPtr vctxt;
+vctxt = xmlSchemaNewValidCtxt(NULL);
+if (vctxt == NULL)
+break;
+xmlSchemaValidateSimpleValue(vctxt, typeDecl,
+facet->value);
+facet->val = vctxt->value;
+vctxt->value = NULL;
+if (facet->val == NULL) {
+/* error code */
+if (ctxt != NULL) {
+xmlSchemaPErr(ctxt, facet->node,
+XML_SCHEMAP_INVALID_FACET,
+"Schemas: type %s facet value %s invalid\n",
+name, facet->value);
+}
+ret = -1;
+}
+xmlSchemaFreeValidCtxt(vctxt);
+break;
+}
+case XML_SCHEMA_FACET_ENUMERATION:{
+/*
+* Okay we need to validate the value
+* at that point.
+*/
+xmlSchemaValidCtxtPtr vctxt;
+int tmp;
+vctxt = xmlSchemaNewValidCtxt(NULL);
+if (vctxt == NULL)
+break;
+tmp = xmlSchemaValidateSimpleValue(vctxt, typeDecl,
+facet->value);
+if (tmp != 0) {
+if (ctxt != NULL) {
+xmlSchemaPErr(ctxt, facet->node,
+XML_SCHEMAP_INVALID_ENUM,
+"Schemas: type %s enumeration value %s invalid\n",
+name, facet->value);
+}
+ret = -1;
+}
+xmlSchemaFreeValidCtxt(vctxt);
+break;
+}
+case XML_SCHEMA_FACET_PATTERN:
+facet->regexp = xmlRegexpCompile(facet->value);
+if (facet->regexp == NULL) {
+xmlSchemaPErr(ctxt, typeDecl->node,
+XML_SCHEMAP_REGEXP_INVALID,
+"Schemas: type %s facet regexp %s invalid\n",
+name, facet->value);
+ret = -1;
+}
+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:{
+int tmp;
+tmp =
+xmlSchemaValidatePredefinedType(nonNegativeIntegerType,
+facet->value,
+&facet->val);
+if (tmp != 0) {
+/* error code */
+if (ctxt != NULL) {
+xmlSchemaPErr(ctxt, facet->node,
+XML_SCHEMAP_INVALID_FACET_VALUE,
+"Schemas: type %s facet value %s invalid\n",
+name, facet->value);
+}
+ret = -1;
+}
+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 {
+if (ctxt != NULL) {
+xmlSchemaPErr(ctxt, facet->node,
+XML_SCHEMAP_INVALID_WHITE_SPACE,
+"Schemas: type %s whiteSpace value %s invalid\n",
+name, facet->value);
+}
+ret = -1;
+}
+}
+default:
+break;
+}
+return (ret);
+}
+/**
+* xmlSchemaCheckDefaults:
+* @typeDecl:  the schema type definition
+* @ctxt:  the schema parser context
+*
+* Checks the default values types, especially for facets
+*/
+static void
+xmlSchemaCheckDefaults(xmlSchemaTypePtr typeDecl,
+xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+if (name == NULL)
+name = typeDecl->name;
+if (typeDecl->type == XML_SCHEMA_TYPE_RESTRICTION) {
+if (typeDecl->facets != NULL) {
+xmlSchemaFacetPtr facet = typeDecl->facets;
+while (facet != NULL) {
+xmlSchemaCheckFacet(facet, typeDecl, ctxt, name);
+facet = facet->next;
+}
+}
+}
+}
+/**
+* xmlSchemaAttrGrpFixup:
+* @attrgrpDecl:  the schema attribute definition
+* @ctxt:  the schema parser context
+* @name:  the attribute name
+*
+* Fixes finish doing the computations on the attributes definitions
+*/
+static void
+xmlSchemaAttrGrpFixup(xmlSchemaAttributeGroupPtr attrgrpDecl,
+xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+if (name == NULL)
+name = attrgrpDecl->name;
+if (attrgrpDecl->attributes != NULL)
+return;
+if (attrgrpDecl->ref != NULL) {
+xmlSchemaAttributeGroupPtr ref;
+ref = xmlHashLookup2(ctxt->schema->attrgrpDecl, attrgrpDecl->ref,
+attrgrpDecl->refNs);
+if (ref == NULL) {
+xmlSchemaPErr(ctxt, attrgrpDecl->node,
+XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
+"Schemas: attribute group %s reference %s not found\n",
+name, attrgrpDecl->ref);
+return;
+}
+xmlSchemaAttrGrpFixup(ref, ctxt, NULL);
+attrgrpDecl->attributes = ref->attributes;
+} else {
+xmlSchemaPErr(ctxt, attrgrpDecl->node, XML_SCHEMAP_NOATTR_NOREF,
+"Schemas: attribute %s has no attributes nor reference\n",
+name, NULL);
+}
+}
+/**
+* xmlSchemaAttrFixup:
+* @attrDecl:  the schema attribute definition
+* @ctxt:  the schema parser context
+* @name:  the attribute name
+*
+* Fixes finish doing the computations on the attributes definitions
+*/
+static void
+xmlSchemaAttrFixup(xmlSchemaAttributePtr attrDecl,
+xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
+{
+if (name == NULL)
+name = attrDecl->name;
+if (attrDecl->subtypes != NULL)
+return;
+if (attrDecl->typeName != NULL) {
+xmlSchemaTypePtr type;
+type = xmlSchemaGetType(ctxt->schema, attrDecl->typeName,
+attrDecl->typeNs);
+if (type == NULL) {
+xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_UNKNOWN_TYPE,
+"Schemas: attribute %s type %s not found\n",
+name, attrDecl->typeName);
+}
+attrDecl->subtypes = type;
+} else if (attrDecl->ref != NULL) {
+xmlSchemaAttributePtr ref;
+ref = xmlHashLookup2(ctxt->schema->attrDecl, attrDecl->ref,
+attrDecl->refNs);
+if (ref == NULL) {
+xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_UNKNOWN_REF,
+"Schemas: attribute %s reference %s not found\n",
+name, attrDecl->ref);
+return;
+}
+xmlSchemaAttrFixup(ref, ctxt, NULL);
+attrDecl->subtypes = ref->subtypes;
+} else if (attrDecl->type != XML_SCHEMA_TYPE_ANY_ATTRIBUTE) {
+xmlSchemaPErr(ctxt, attrDecl->node, XML_SCHEMAP_NOTYPE_NOREF,
+"Schemas: attribute %s has no type nor reference\n",
+name, NULL);
+}
+}
+/**
+* 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.
+* *WARNING* this interface is highly subject to change
+*
+* Returns the internal XML Schema structure built from the resource or
+*         NULL in case of error
+*/
+xmlSchemaPtr
+xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
+{
+xmlSchemaPtr ret = NULL;
+xmlDocPtr doc;
+xmlNodePtr root;
+int nberrors;
+int preserve = 0;
+xmlSchemaInitTypes();
+if (ctxt == NULL)
+return (NULL);
+nberrors = ctxt->nberrors;
+ctxt->nberrors = 0;
+ctxt->counter = 0;
+ctxt->container = NULL;
+/*
+* First step is to parse the input document into an DOM/Infoset
+*/
+if (ctxt->URL != NULL) {
+doc = xmlReadFile((const char *) ctxt->URL, NULL,
+SCHEMAS_PARSE_OPTIONS);
+if (doc == NULL) {
+xmlSchemaPErr(ctxt, NULL,
+XML_SCHEMAP_FAILED_LOAD,
+"xmlSchemaParse: could not load %s\n",
+ctxt->URL, NULL);
+return (NULL);
+}
+} else if (ctxt->buffer != NULL) {
+doc = xmlReadMemory(ctxt->buffer, ctxt->size, NULL, NULL,
+SCHEMAS_PARSE_OPTIONS);
+if (doc == NULL) {
+xmlSchemaPErr(ctxt, NULL,
+XML_SCHEMAP_FAILED_PARSE,
+"xmlSchemaParse: could not parse\n",
+NULL, NULL);
+return (NULL);
+}
+doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
+ctxt->URL = xmlDictLookup(ctxt->dict, BAD_CAST "in_memory_buffer", -1);
+} else if (ctxt->doc != NULL) {
+doc = ctxt->doc;
+preserve = 1;
+} else {
+xmlSchemaPErr(ctxt, NULL,
+XML_SCHEMAP_NOTHING_TO_PARSE,
+"xmlSchemaParse: could not parse\n",
+NULL, NULL);
+return (NULL);
+}
+/*
+* Then extract the root and Schema parse it
+*/
+root = xmlDocGetRootElement(doc);
+if (root == NULL) {
+xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
+XML_SCHEMAP_NOROOT,
+"schemas has no root", NULL, NULL);
+if (!preserve) {
+xmlFreeDoc(doc);
+}
+return (NULL);
+}
+/*
+* Remove all the blank text nodes
+*/
+xmlSchemaCleanupDoc(ctxt, root);
+/*
+* Then do the parsing for good
+*/
+ret = xmlSchemaParseSchema(ctxt, root);
+if (ret == NULL) {
+if (!preserve) {
+xmlFreeDoc(doc);
+}
+return (NULL);
+}
+ret->doc = doc;
+ret->preserve = preserve;
+/*
+* Then fix all the references.
+*/
+ctxt->schema = ret;
+xmlHashScanFull(ret->elemDecl,
+(xmlHashScannerFull) xmlSchemaRefFixupCallback, ctxt);
+/*
+* Then fixup all attributes declarations
+*/
+xmlHashScan(ret->attrDecl, (xmlHashScanner) xmlSchemaAttrFixup, ctxt);
+/*
+* Then fixup all attributes group declarations
+*/
+xmlHashScan(ret->attrgrpDecl, (xmlHashScanner) xmlSchemaAttrGrpFixup,
+ctxt);
+/*
+* Then fixup all types properties
+*/
+xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaTypeFixup, ctxt);
+/*
+* Then build the content model for all elements
+*/
+xmlHashScan(ret->elemDecl,
+(xmlHashScanner) xmlSchemaBuildContentModel, ctxt);
+/*
+* Then check the defaults part of the type like facets values
+*/
+xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaCheckDefaults,
+ctxt);
+if (ctxt->nberrors != 0) {
+xmlSchemaFree(ret);
+ret = NULL;
+}
+return (ret);
+}
+/**
+* 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->userData = ctx;
+}
+/**
+* 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 char *
+xmlSchemaFacetTypeToString(xmlSchemaTypeType type)
+{
+switch (type) {
+case XML_SCHEMA_FACET_PATTERN:
+return ("pattern");
+case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+return ("maxExclusive");
+case XML_SCHEMA_FACET_MAXINCLUSIVE:
+return ("maxInclusive");
+case XML_SCHEMA_FACET_MINEXCLUSIVE:
+return ("minExclusive");
+case XML_SCHEMA_FACET_MININCLUSIVE:
+return ("minInclusive");
+case XML_SCHEMA_FACET_WHITESPACE:
+return ("whiteSpace");
+case XML_SCHEMA_FACET_ENUMERATION:
+return ("enumeration");
+case XML_SCHEMA_FACET_LENGTH:
+return ("length");
+case XML_SCHEMA_FACET_MAXLENGTH:
+return ("maxLength");
+case XML_SCHEMA_FACET_MINLENGTH:
+return ("minLength");
+case XML_SCHEMA_FACET_TOTALDIGITS:
+return ("totalDigits");
+case XML_SCHEMA_FACET_FRACTIONDIGITS:
+return ("fractionDigits");
+default:
+break;
+}
+return ("Internal Error");
+}
+/**
+* xmlSchemaValidateFacetsInternal:
+* @ctxt:  a schema validation context
+* @base:  the base type
+* @facets:  the list of facets to check
+* @value:  the lexical repr of the value to validate
+* @val:  the precomputed value
+* @fireErrors:  if 0, only internal errors will be fired;
+*       otherwise all errors will be fired.
+*
+* Check a value against all facet conditions
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateFacetsInternal(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr base,
+xmlSchemaFacetPtr facets,
+const xmlChar * value, int fireErrors)
+{
+int ret = 0;
+int tmp = 0;
+xmlSchemaTypeType type;
+xmlSchemaFacetPtr facet = facets;
+while (facet != NULL) {
+type = facet->type;
+if (type == XML_SCHEMA_FACET_ENUMERATION) {
+tmp = 1;
+while (facet != NULL) {
+tmp =
+xmlSchemaValidateFacet(base, facet, value,
+ctxt->value);
+if (tmp == 0) {
+return 0;
+}
+facet = facet->next;
+}
+} else
+tmp = xmlSchemaValidateFacet(base, facet, value, ctxt->value);
+if (tmp != 0) {
+ret = tmp;
+if (fireErrors)
+xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_FACET,
+"Failed to validate type with facet %s\n",
+(const xmlChar *) xmlSchemaFacetTypeToString(type),
+NULL);
+}
+if (facet != NULL)
+facet = facet->next;
+}
+return (ret);
+}
+/**
+* xmlSchemaValidateFacets:
+* @ctxt:  a schema validation context
+* @base:  the base type
+* @facets:  the list of facets to check
+* @value:  the lexical repr of the value to validate
+* @val:  the precomputed value
+*
+* Check a value against all facet conditions
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateFacets(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr base,
+xmlSchemaFacetPtr facets, const xmlChar * value)
+{
+return(xmlSchemaValidateFacetsInternal(ctxt, base, facets, value, 1));
+}
+/************************************************************************
+*                                  *
+*          Simple type validation              *
+*                                  *
+************************************************************************/
+/**
+* xmlSchemaValidateSimpleValueUnion:
+* @ctxt:  a schema validation context
+* @type:  the type declaration
+* @value:  the value to validate
+*
+* Validates a value against a union.
+*
+* Returns 0 if the value is valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleValueUnion(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr type, const xmlChar * value)
+{
+int ret = 0;
+const xmlChar *cur, *end, *prefix, *ncName;
+xmlChar *tmp;
+xmlSchemaTypePtr subtype;
+xmlNsPtr ns;
+int len;
+/* Process referenced memberTypes. */
+cur = type->ref;
+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);
+ncName = xmlSplitQName3(tmp, &len);
+if (ncName != NULL) {
+prefix = xmlStrndup(tmp, len);
+/* prefix = xmlDictLookup(ctxt->doc->dict, tmp, len); */
+} else {
+prefix = NULL;
+ncName = tmp;
+}
+/* We won't do additional checks here,
+* since they have been performed during parsing. */
+ns = xmlSearchNs(type->node->doc, type->node, prefix);
+/* namespace = xmlDictLookup(ctxt->doc->dict, ns->href, -1); */
+subtype = xmlSchemaGetType(ctxt->schema, ncName, ns->href);
+if (tmp != NULL)
+xmlFree(tmp);
+if (prefix != NULL)
+xmlFree((void *)prefix);
+ret = xmlSchemaValidateSimpleValueInternal(ctxt, subtype, value, 0);
+if ((ret == 0) || (ret == -1)) {
+return (ret);
+}
+cur = end;
+} while (*cur != 0);
+if (type->subtypes != NULL) {
+subtype = type->subtypes;
+do {
+ret = xmlSchemaValidateSimpleValueInternal(ctxt, subtype, value, 0);
+if ((ret == 0) || (ret == -1)) {
+return (ret);
+}
+subtype = subtype->next;
+} while (subtype != NULL);
+}
+return (ret);
+}
+/**
+* xmlSchemaValidateSimpleValue:
+* @ctxt:  a schema validation context
+* @type:  the type declaration
+* @value:  the value to validate
+*
+* Validate a value against a simple type
+*
+* Returns 0 if the value is valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleValue(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr type, const xmlChar * value)
+{
+return (xmlSchemaValidateSimpleValueInternal(ctxt, type, value, 1));
+}
+/**
+* xmlSchemaValidateSimpleValue:
+* @ctxt:  a schema validation context
+* @type:  the type declaration
+* @value:  the value to validate
+* @fireErrors:  if 0, only internal errors will be fired;
+*       otherwise all errors will be fired.
+*
+* Validate a value against a simple type
+*
+* Returns 0 if the value is valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleValueInternal(xmlSchemaValidCtxtPtr ctxt,
+xmlSchemaTypePtr type,
+const xmlChar * value,
+int fireErrors)
+{
+int ret = 0;
+/*
+* First normalize the value accordingly to Schema Datatype
+* 4.3.6 whiteSpace definition of the whiteSpace facet of type
+*
+* Then check the normalized value against the lexical space of the
+* type.
+*/
+if (type->type == XML_SCHEMA_TYPE_BASIC) {
+if (ctxt->value != NULL) {
+xmlSchemaFreeValue(ctxt->value);
+ctxt->value = NULL;
+}
+ret = xmlSchemaValPredefTypeNode(type, value, &(ctxt->value),
+ctxt->cur);
+if ((fireErrors) && (ret != 0)) {
+xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_VALUE,
+"Failed to validate basic type %s\n",
+type->name, NULL);
+}
+} else if (type->type == XML_SCHEMA_TYPE_RESTRICTION) {
+xmlSchemaTypePtr base;
+xmlSchemaFacetPtr facet;
+base = type->baseType;
+if (base != NULL) {
+ret = xmlSchemaValidateSimpleValueInternal(ctxt, base,
+value, fireErrors);
+} else if (type->subtypes != NULL) {
+TODO
+}
+/*
+* Do not validate facets or attributes when working on
+* building the Schemas
+*/
+if (ctxt->schema != NULL) {
+if (ret == 0) {
+facet = type->facets;
+ret = xmlSchemaValidateFacetsInternal(ctxt, base, facet,
+value, fireErrors);
+}
+}
+} else if (type->type == XML_SCHEMA_TYPE_SIMPLE) {
+xmlSchemaTypePtr base;
+base = type->subtypes;
+if (base != NULL) {
+ret = xmlSchemaValidateSimpleValueInternal(ctxt, base,
+value, fireErrors);
+} else {
+TODO}
+} else if (type->type == XML_SCHEMA_TYPE_LIST) {
+xmlSchemaTypePtr base;
+const xmlChar *cur, *end;
+xmlChar *tmp;
+int ret2;
+base = type->subtypes;
+if (base == NULL) {
+xmlSchemaVErr(ctxt, type->node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal: List type %s has no base type\n",
+type->name, NULL);
+return (-1);
+}
+cur = value;
+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);
+ret2 = xmlSchemaValidateSimpleValueInternal(ctxt, base,
+tmp, fireErrors);
+xmlFree(tmp);
+if (ret2 != 0)
+ret = 1;
+cur = end;
+} while (*cur != 0);
+}  else if (type->type == XML_SCHEMA_TYPE_UNION) {
+ret = xmlSchemaValidateSimpleValueUnion(ctxt, type, value);
+if ((fireErrors) && (ret != 0)) {
+xmlSchemaVErr(ctxt, ctxt->cur, XML_SCHEMAS_ERR_VALUE,
+"Failed to validate type %s\n", type->name, NULL);
+}
+} else {
+TODO
+}
+return (ret);
+}
+/************************************************************************
+*                                  *
+*          DOM Validation code             *
+*                                  *
+************************************************************************/
+static int xmlSchemaValidateContent(xmlSchemaValidCtxtPtr ctxt,
+xmlNodePtr node);
+static int xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt,
+xmlNodePtr elem,
+xmlSchemaAttributePtr attributes);
+static int xmlSchemaValidateType(xmlSchemaValidCtxtPtr ctxt,
+xmlNodePtr elem,
+xmlSchemaElementPtr elemDecl,
+xmlSchemaTypePtr type);
+/**
+* xmlSchemaRegisterAttributes:
+* @ctxt:  a schema validation context
+* @attrs:  a list of attributes
+*
+* Register the list of attributes as the set to be validated on that element
+*
+* Returns -1 in case of error, 0 otherwise
+*/
+static int
+xmlSchemaRegisterAttributes(xmlSchemaValidCtxtPtr ctxt, xmlAttrPtr attrs)
+{
+while (attrs != NULL) {
+if ((attrs->ns != NULL) &&
+(xmlStrEqual(attrs->ns->href, xmlSchemaInstanceNs))) {
+attrs = attrs->next;
+continue;
+}
+if (ctxt->attrNr >= ctxt->attrMax) {
+xmlSchemaAttrStatePtr tmp;
+ctxt->attrMax *= 2;
+tmp = (xmlSchemaAttrStatePtr)
+xmlRealloc(ctxt->attr, ctxt->attrMax *
+sizeof(xmlSchemaAttrState));
+if (tmp == NULL) {
+xmlSchemaVErrMemory(ctxt, "registering attributes", NULL);
+ctxt->attrMax /= 2;
+return (-1);
+}
+ctxt->attr = tmp;
+}
+ctxt->attr[ctxt->attrNr].attr = attrs;
+ctxt->attr[ctxt->attrNr].state = XML_SCHEMAS_ATTR_UNKNOWN;
+ctxt->attrNr++;
+attrs = attrs->next;
+}
+return (0);
+}
+/**
+* xmlSchemaCheckAttributes:
+* @ctxt:  a schema validation context
+* @node:  the node carrying it.
+*
+* Check that the registered set of attributes on the current node
+* has been properly validated.
+*
+* Returns 0 if validity constraints are met, 1 otherwise.
+*/
+static int
+xmlSchemaCheckAttributes(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+int ret = 0;
+int i;
+for (i = ctxt->attrBase; i < ctxt->attrNr; i++) {
+if (ctxt->attr[i].attr == NULL)
+break;
+if (ctxt->attr[i].state == XML_SCHEMAS_ATTR_UNKNOWN) {
+ret = 1;
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ATTRUNKNOWN,
+"Attribute %s on %s is unknown\n",
+ctxt->attr[i].attr->name, node->name);
+}
+}
+return (ret);
+}
+#if 0       /* Not currently used - remove if ever needed */
+/**
+* xmlSchemaValidateSimpleContent:
+* @ctxt:  a schema validation context
+* @elem:  an element
+* @type:  the type declaration
+*
+* Validate the content of an element expected to be a simple type
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleContent(xmlSchemaValidCtxtPtr ctxt,
+xmlNodePtr node ATTRIBUTE_UNUSED)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type, base;
+xmlChar *value;
+int ret = 0;
+child = ctxt->node;
+type = ctxt->type;
+/*
+* Validation Rule: Element Locally Valid (Type): 3.1.3
+*/
+value = xmlNodeGetContent(child);
+/* xmlSchemaValidateSimpleValue(ctxt, type, value); */
+switch (type->type) {
+case XML_SCHEMA_TYPE_RESTRICTION:{
+xmlSchemaFacetPtr facet;
+base = type->baseType;
+if (base != NULL) {
+ret = xmlSchemaValidateSimpleValue(ctxt, base, value);
+} else {
+TODO}
+if (ret == 0) {
+facet = type->facets;
+ret =
+xmlSchemaValidateFacets(ctxt, base, facet, value);
+}
+if ((ret == 0) && (type->attributes != NULL)) {
+ret = xmlSchemaValidateAttributes(ctxt, node,
+type->attributes);
+}
+break;
+}
+case XML_SCHEMA_TYPE_EXTENSION:{
+TODO
+break;
+}
+default:
+TODO
+}
+if (value != NULL)
+xmlFree(value);
+return (ret);
+}
+#endif
+/**
+* xmlSchemaValidateCheckNodeList
+* @nodelist: the list of nodes
+*
+* Check the node list is only made of text nodes and entities pointing
+* to text nodes
+*
+* Returns 1 if true, 0 if false and -1 in case of error
+*/
+static int
+xmlSchemaValidateCheckNodeList(xmlNodePtr nodelist)
+{
+while (nodelist != NULL) {
+if (nodelist->type == XML_ENTITY_REF_NODE) {
+TODO                /* implement recursion in the entity content */
+}
+if ((nodelist->type != XML_TEXT_NODE) &&
+(nodelist->type != XML_COMMENT_NODE) &&
+(nodelist->type != XML_PI_NODE) &&
+(nodelist->type != XML_CDATA_SECTION_NODE)) {
+return (0);
+}
+nodelist = nodelist->next;
+}
+return (1);
+}
+/**
+* xmlSchemaSkipIgnored:
+* @ctxt:  a schema validation context
+* @type:  the current type context
+* @node:  the top node.
+*
+* Skip ignorable nodes in that context
+*
+* Returns the new sibling
+*     number otherwise and -1 in case of internal or API error.
+*/
+static xmlNodePtr
+xmlSchemaSkipIgnored(xmlSchemaValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
+xmlSchemaTypePtr type, xmlNodePtr node)
+{
+int mixed = 0;
+/*
+* TODO complete and handle entities
+*/
+mixed = ((type->contentType == XML_SCHEMA_CONTENT_MIXED) ||
+(type->contentType == XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS));
+while ((node != NULL) &&
+((node->type == XML_COMMENT_NODE) ||
+((mixed == 1) && (node->type == XML_TEXT_NODE)) ||
+(((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) &&
+(node->type == XML_TEXT_NODE) && (IS_BLANK_NODE(node)))))) {
+node = node->next;
+}
+return (node);
+}
+/**
+* xmlSchemaValidateCallback:
+* @ctxt:  a schema validation context
+* @name:  the name of the element detected (might be NULL)
+* @type:  the type
+*
+* A transition has been made in the automata associated to an element
+* content model
+*/
+static void
+xmlSchemaValidateCallback(xmlSchemaValidCtxtPtr ctxt,
+const xmlChar * name ATTRIBUTE_UNUSED,
+xmlSchemaTypePtr type, xmlNodePtr node)
+{
+xmlSchemaTypePtr oldtype = ctxt->type;
+xmlNodePtr oldnode = ctxt->node;
+#ifdef DEBUG_CONTENT
+xmlGenericError(xmlGenericErrorContext,
+"xmlSchemaValidateCallback: %s, %s, %s\n",
+name, type->name, node->name);
+#endif
+ctxt->type = type;
+ctxt->node = node;
+xmlSchemaValidateContent(ctxt, node);
+ctxt->type = oldtype;
+ctxt->node = oldnode;
+}
+#if 0
+/**
+* xmlSchemaValidateSimpleRestrictionType:
+* @ctxt:  a schema validation context
+* @node:  the top node.
+*
+* Validate the content of a restriction type.
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleRestrictionType(xmlSchemaValidCtxtPtr ctxt,
+xmlNodePtr node)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type;
+int ret;
+child = ctxt->node;
+type = ctxt->type;
+if ((ctxt == NULL) || (type == NULL)) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleRestrictionType %s\n",
+node->name, NULL);
+return (-1);
+}
+/*
+* Only text and text based entities references shall be found there
+*/
+ret = xmlSchemaValidateCheckNodeList(child);
+if (ret < 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleType %s content\n",
+node->name, NULL);
+return (-1);
+} else if (ret == 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTSIMPLE,
+"Element %s content is not a simple type\n",
+node->name, NULL);
+return (-1);
+}
+ctxt->type = type->subtypes;
+xmlSchemaValidateContent(ctxt, node);
+ctxt->type = type;
+return (ret);
+}
+#endif
+/**
+* xmlSchemaValidateSimpleType:
+* @ctxt:  a schema validation context
+* @node:  the top node.
+*
+* Validate the content of an simple type.
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateSimpleType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type, base, variety;
+xmlAttrPtr attr;
+int ret;
+xmlChar *value;
+child = ctxt->node;
+type = ctxt->type;
+if ((ctxt == NULL) || (type == NULL)) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleType %s\n",
+node->name, NULL);
+return (-1);
+}
+/*
+* Only text and text based entities references shall be found there
+*/
+ret = xmlSchemaValidateCheckNodeList(child);
+if (ret < 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleType %s content\n",
+node->name, NULL);
+return (-1);
+} else if (ret == 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTSIMPLE,
+"Element %s content is not a simple type\n",
+node->name, NULL);
+return (-1);
+}
+/*
+* Validation Rule: Element Locally Valid (Type): 3.1.1
+*/
+attr = node->properties;
+while (attr != NULL) {
+if ((attr->ns == NULL) ||
+(!xmlStrEqual(attr->ns->href, xmlSchemaInstanceNs)) ||
+((!xmlStrEqual(attr->name, BAD_CAST "type")) &&
+(!xmlStrEqual(attr->name, BAD_CAST "nil")) &&
+(!xmlStrEqual(attr->name, BAD_CAST "schemasLocation")) &&
+(!xmlStrEqual
+(attr->name, BAD_CAST "noNamespaceSchemaLocation")))) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDATTR,
+"Element %s: attribute %s should not be present\n",
+node->name, attr->name);
+return (ctxt->err);
+}
+}
+/* TODO:
+* If {variety} is ·atomic· then the {variety} of {base type definition}
+* must be ·atomic·.
+* If {variety} is ·list· then the {variety} of {item type definition}
+* must be either ·atomic· or ·union·.
+* If {variety} is ·union· then {member type definitions} must be a list
+* of datatype definitions.
+*/
+if (type->subtypes == NULL) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleType; "
+"simple type %s does not define a variety\n",
+node->name, NULL);
+return (ctxt->err);
+}
+/* Varieties: Restriction or List or Union. */
+variety = type->subtypes;
+ctxt->type = variety;
+value = xmlNodeGetContent(child);
+switch (variety->type) {
+case XML_SCHEMA_TYPE_RESTRICTION:{
+xmlSchemaFacetPtr facet;
+base = variety->baseType;
+if (base != NULL) {
+ret = xmlSchemaValidateSimpleValue(ctxt, base, value);
+} else {
+TODO}
+if (ret == 0) {
+facet = variety->facets;
+ret =
+xmlSchemaValidateFacets(ctxt, base, facet, value);
+}
+if ((ret == 0) && (variety->attributes != NULL)) {
+ret = xmlSchemaValidateAttributes(ctxt, node,
+variety->attributes);
+}
+break;
+}
+case XML_SCHEMA_TYPE_LIST:
+case XML_SCHEMA_TYPE_UNION: {
+ret = xmlSchemaValidateSimpleValue(ctxt, variety, value);
+break;
+}
+default:{
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateSimpleType; "
+"simple type %s defines unknown content: %s\n",
+variety->name, NULL);
+ret = ctxt->err;
+}
+}
+if (value != NULL)
+xmlFree(value);
+/* This was removed, since a simple content is not a content of a
+* simple type, but of a complex type.
+* ret = xmlSchemaValidateSimpleContent(ctxt, node);
+*/
+ctxt->type = type;
+return (ret);
+}
+/**
+* xmlSchemaValidateElementType:
+* @ctxt:  a schema validation context
+* @node:  the top node.
+*
+* Validate the content of an element type.
+* Validation Rule: Element Locally Valid (Complex Type)
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateElementType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type;
+xmlRegExecCtxtPtr oldregexp;        /* cont model of the parent */
+xmlSchemaElementPtr decl;
+int ret, attrBase;
+oldregexp = ctxt->regexp;
+child = ctxt->node;
+type = ctxt->type;
+if ((ctxt == NULL) || (type == NULL)) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateElementType\n",
+node->name, NULL);
+return (-1);
+}
+if (child == NULL) {
+if (type->minOccurs > 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_MISSING,
+"Element %s: missing child %s\n",
+node->name, type->name);
+}
+return (ctxt->err);
+}
+/*
+* Verify the element matches
+*/
+if (!xmlStrEqual(child->name, type->name)) {
+xmlSchemaVErr3(ctxt, node, XML_SCHEMAS_ERR_WRONGELEM,
+"Element %s: missing child %s found %s\n",
+node->name, type->name, child->name);
+return (ctxt->err);
+}
+/*
+* Verify the attributes
+*/
+attrBase = ctxt->attrBase;
+ctxt->attrBase = ctxt->attrNr;
+xmlSchemaRegisterAttributes(ctxt, child->properties);
+xmlSchemaValidateAttributes(ctxt, child, type->attributes);
+/*
+* Verify the element content recursively
+*/
+decl = (xmlSchemaElementPtr) type;
+oldregexp = ctxt->regexp;
+if (decl->contModel != NULL) {
+ctxt->regexp = xmlRegNewExecCtxt(decl->contModel,
+(xmlRegExecCallbacks)
+xmlSchemaValidateCallback, ctxt);
+#ifdef DEBUG_AUTOMATA
+xmlGenericError(xmlGenericErrorContext, "====> %s\n", node->name);
+#endif
+}
+xmlSchemaValidateType(ctxt, child, (xmlSchemaElementPtr) type,
+type->subtypes);
+if (decl->contModel != NULL) {
+ret = xmlRegExecPushString(ctxt->regexp, NULL, NULL);
+#ifdef DEBUG_AUTOMATA
+xmlGenericError(xmlGenericErrorContext,
+"====> %s : %d\n", node->name, ret);
+#endif
+if (ret == 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ELEMCONT,
+"Element %s content check failed\n",
+node->name, NULL);
+} else if (ret < 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_ELEMCONT,
+"Element %s content check failure\n",
+node->name, NULL);
+#ifdef DEBUG_CONTENT
+} else {
+xmlGenericError(xmlGenericErrorContext,
+"Element %s content check succeeded\n",
+node->name);
+#endif
+}
+xmlRegFreeExecCtxt(ctxt->regexp);
+}
+/*
+* Verify that all attributes were Schemas-validated
+*/
+xmlSchemaCheckAttributes(ctxt, node);
+ctxt->attrNr = ctxt->attrBase;
+ctxt->attrBase = attrBase;
+ctxt->regexp = oldregexp;
+ctxt->node = child;
+ctxt->type = type;
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateBasicType:
+* @ctxt:  a schema validation context
+* @node:  the top node.
+*
+* Validate the content of an element expected to be a basic type type
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateBasicType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+int ret;
+xmlNodePtr child, cur;
+xmlSchemaTypePtr type;
+xmlChar *value;             /* lexical representation */
+child = ctxt->node;
+type = ctxt->type;
+if ((ctxt == NULL) || (type == NULL)) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: xmlSchemaValidateBasicType\n",
+node->name, NULL);
+return (-1);
+}
+/*
+* First check the content model of the node.
+*/
+cur = child;
+while (cur != NULL) {
+switch (cur->type) {
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+break;
+case XML_ENTITY_REF_NODE:
+case XML_ENTITY_NODE:
+TODO break;
+case XML_ELEMENT_NODE:
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDELEM,
+"Element %s: child %s should not be present\n",
+node->name, cur->name);
+return (ctxt->err);
+case XML_ATTRIBUTE_NODE:
+case XML_DOCUMENT_NODE:
+case XML_DOCUMENT_TYPE_NODE:
+case XML_DOCUMENT_FRAG_NODE:
+case XML_NOTATION_NODE:
+case XML_HTML_DOCUMENT_NODE:
+case XML_DTD_NODE:
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_NAMESPACE_DECL:
+#ifdef LIBXML_DOCB_ENABLED
+case XML_DOCB_DOCUMENT_NODE:
+#endif
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INVALIDELEM,
+"Element %s: node type of node unexpected here\n",
+node->name, NULL);
+return (ctxt->err);
+}
+cur = cur->next;
+}
+if (child == NULL)
+value = NULL;
+else
+value = xmlNodeGetContent(child->parent);
+if (ctxt->value != NULL) {
+xmlSchemaFreeValue(ctxt->value);
+ctxt->value = NULL;
+}
+ret = xmlSchemaValidatePredefinedType(type, value, &(ctxt->value));
+if (value != NULL)
+xmlFree(value);
+if (ret != 0) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_VALUE,
+"Element %s: failed to validate basic type %s\n",
+node->name, type->name);
+}
+return (ret);
+}
+/**
+* xmlSchemaValidateComplexType:
+* @ctxt:  a schema validation context
+* @node:  the top node.
+*
+* Validate the content of an element expected to be a complex type type
+* xmlschema-1.html#cvc-complex-type
+* Validation Rule: Element Locally Valid (Complex Type)
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateComplexType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type, subtype;
+int ret;
+child = ctxt->node;
+type = ctxt->type;
+ctxt->cur = node;
+switch (type->contentType) {
+case XML_SCHEMA_CONTENT_EMPTY:
+if (type->baseType != NULL) {
+} else if (child != NULL) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_NOTEMPTY,
+"Element %s is supposed to be empty\n",
+node->name, NULL);
+}
+if (type->attributes != NULL) {
+xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+}
+subtype = type->subtypes;
+while (subtype != NULL) {
+ctxt->type = subtype;
+xmlSchemaValidateComplexType(ctxt, node);
+subtype = subtype->next;
+}
+break;
+case XML_SCHEMA_CONTENT_ELEMENTS:
+case XML_SCHEMA_CONTENT_MIXED:
+case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
+/*
+* Skip ignorable nodes in that context
+*/
+child = xmlSchemaSkipIgnored(ctxt, type, child);
+while (child != NULL) {
+if (child->type == XML_ELEMENT_NODE) {
+ret = xmlRegExecPushString(ctxt->regexp,
+child->name, child);
+#ifdef DEBUG_AUTOMATA
+if (ret < 0)
+xmlGenericError(xmlGenericErrorContext,
+"  --> %s Error\n", child->name);
+else
+xmlGenericError(xmlGenericErrorContext,
+"  --> %s\n", child->name);
+#endif
+}
+child = child->next;
+/*
+* Skip ignorable nodes in that context
+*/
+child = xmlSchemaSkipIgnored(ctxt, type, child);
+}
+if (((type->contentType == XML_SCHEMA_CONTENT_MIXED) ||
+(type->contentType == XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS)) &&
+(type->subtypes != NULL)) {
+TODO
+}
+if (type->attributes != NULL) {
+xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+}
+break;
+case XML_SCHEMA_CONTENT_BASIC:{
+if (type->subtypes != NULL) {
+ctxt->type = type->subtypes;
+xmlSchemaValidateComplexType(ctxt, node);
+}
+if (type->baseType != NULL) {
+ctxt->type = type->baseType;
+if (type->baseType->type == XML_SCHEMA_TYPE_BASIC)
+xmlSchemaValidateBasicType(ctxt, node);
+else if (type->baseType->type == XML_SCHEMA_TYPE_COMPLEX)
+xmlSchemaValidateComplexType(ctxt, node);
+else if (type->baseType->type == XML_SCHEMA_TYPE_SIMPLE)
+xmlSchemaValidateSimpleType(ctxt, node);
+else
+xmlGenericError(xmlGenericErrorContext,
+"unexpected content type of base: %d\n",
+type->contentType);
+}
+if (type->attributes != NULL) {
+xmlSchemaValidateAttributes(ctxt, node,
+type->attributes);
+}
+ctxt->type = type;
+break;
+}
+case XML_SCHEMA_CONTENT_SIMPLE:{
+if (type->subtypes != NULL) {
+ctxt->type = type->subtypes;
+xmlSchemaValidateComplexType(ctxt, node);
+}
+if (type->baseType != NULL) {
+ctxt->type = type->baseType;
+xmlSchemaValidateComplexType(ctxt, node);
+}
+if (type->attributes != NULL) {
+xmlSchemaValidateAttributes(ctxt, node,
+type->attributes);
+}
+ctxt->type = type;
+break;
+}
+default:
+TODO xmlGenericError(xmlGenericErrorContext,
+"unimplemented content type %d\n",
+type->contentType);
+}
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateContent:
+* @ctxt:  a schema validation context
+* @elem:  an element
+* @type:  the type declaration
+*
+* Validate the content of an element against the type.
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateContent(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node)
+{
+xmlNodePtr child;
+xmlSchemaTypePtr type;
+child = ctxt->node;
+type = ctxt->type;
+ctxt->cur = node;
+xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+ctxt->cur = node;
+switch (type->type) {
+case XML_SCHEMA_TYPE_ANY:
+/* Any type will do it, fine */
+TODO                /* handle recursivity */
+break;
+case XML_SCHEMA_TYPE_COMPLEX:
+xmlSchemaValidateComplexType(ctxt, node);
+break;
+case XML_SCHEMA_TYPE_ELEMENT:{
+xmlSchemaElementPtr decl = (xmlSchemaElementPtr) type;
+/*
+* Handle element reference here
+*/
+if (decl->ref != NULL) {
+if (decl->refDecl == NULL) {
+xmlSchemaVErr(ctxt, node, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: element reference %s "
+"not resolved\n", decl->ref, NULL);
+return (-1);
+}
+ctxt->type = (xmlSchemaTypePtr) decl->refDecl;
+decl = decl->refDecl;
+}
+/* TODO: Should "xmlSchemaValidateElement" be called instead? */
+xmlSchemaValidateElementType(ctxt, node);
+ctxt->type = type;
+break;
+}
+case XML_SCHEMA_TYPE_BASIC:
+xmlSchemaValidateBasicType(ctxt, node);
+break;
+case XML_SCHEMA_TYPE_FACET:
+TODO break;
+case XML_SCHEMA_TYPE_SIMPLE:
+xmlSchemaValidateSimpleType(ctxt, node);
+break;
+case XML_SCHEMA_TYPE_SEQUENCE:
+TODO break;
+case XML_SCHEMA_TYPE_CHOICE:
+TODO break;
+case XML_SCHEMA_TYPE_ALL:
+TODO break;
+case XML_SCHEMA_TYPE_SIMPLE_CONTENT:
+TODO break;
+case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
+TODO break;
+case XML_SCHEMA_TYPE_UR:
+TODO break;
+case XML_SCHEMA_TYPE_RESTRICTION:
+/*xmlSchemaValidateRestrictionType(ctxt, node); */
+TODO break;
+case XML_SCHEMA_TYPE_EXTENSION:
+TODO break;
+case XML_SCHEMA_TYPE_ATTRIBUTE:
+TODO break;
+case XML_SCHEMA_TYPE_GROUP:
+TODO break;
+case XML_SCHEMA_TYPE_NOTATION:
+TODO break;
+case XML_SCHEMA_TYPE_LIST:
+TODO break;
+case XML_SCHEMA_TYPE_UNION:
+TODO break;
+case XML_SCHEMA_FACET_MININCLUSIVE:
+TODO break;
+case XML_SCHEMA_FACET_MINEXCLUSIVE:
+TODO break;
+case XML_SCHEMA_FACET_MAXINCLUSIVE:
+TODO break;
+case XML_SCHEMA_FACET_MAXEXCLUSIVE:
+TODO break;
+case XML_SCHEMA_FACET_TOTALDIGITS:
+TODO break;
+case XML_SCHEMA_FACET_FRACTIONDIGITS:
+TODO break;
+case XML_SCHEMA_FACET_PATTERN:
+TODO break;
+case XML_SCHEMA_FACET_ENUMERATION:
+TODO break;
+case XML_SCHEMA_FACET_WHITESPACE:
+TODO break;
+case XML_SCHEMA_FACET_LENGTH:
+TODO break;
+case XML_SCHEMA_FACET_MAXLENGTH:
+TODO break;
+case XML_SCHEMA_FACET_MINLENGTH:
+TODO break;
+case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
+TODO break;
+case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
+TODO break;
+}
+xmlSchemaValidateAttributes(ctxt, node, type->attributes);
+if (ctxt->node == NULL)
+return (ctxt->err);
+ctxt->node = ctxt->node->next;
+ctxt->type = type->next;
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateType:
+* @ctxt:  a schema validation context
+* @elem:  an element
+* @type:  the list of type declarations
+*
+* Validate the content of an element against the types.
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateType(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem,
+xmlSchemaElementPtr elemDecl, xmlSchemaTypePtr type)
+{
+xmlChar *nil;
+if ((elem == NULL) || (type == NULL) || (elemDecl == NULL))
+return (0);
+/*
+* 3.3.4 : 2
+*/
+if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ISABSTRACT,
+"Element declaration %s is abstract\n",
+elemDecl->name, NULL);
+/* Changed, since the element declaration is abstract and not
+* the element itself. */
+/* xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ISABSTRACT,
+"Element %s is abstract\n", elem->name, NULL); */
+return (ctxt->err);
+}
+/*
+* 3.3.4: 3
+*/
+nil = xmlGetNsProp(elem, BAD_CAST "nil", xmlSchemaInstanceNs);
+if (elemDecl->flags & XML_SCHEMAS_ELEM_NILLABLE) {
+/* 3.3.4: 3.2 */
+if (xmlStrEqual(nil, BAD_CAST "true")) {
+if (elem->children != NULL) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTEMPTY,
+"Element %s is not empty\n", elem->name, NULL);
+return (ctxt->err);
+}
+if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) &&
+(elemDecl->value != NULL)) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_HAVEDEFAULT,
+"Empty element %s cannot get a fixed value\n",
+elem->name, NULL);
+return (ctxt->err);
+}
+}
+} else {
+/* 3.3.4: 3.1 */
+if (nil != NULL) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTNILLABLE,
+"Element %s with xs:nil but not nillable\n",
+elem->name, NULL);
+xmlFree(nil);
+return (ctxt->err);
+}
+}
+/* TODO 3.3.4: 4 if the element carries xs:type */
+ctxt->type = elemDecl->subtypes;
+ctxt->node = elem->children;
+xmlSchemaValidateContent(ctxt, elem);
+xmlSchemaValidateAttributes(ctxt, elem, elemDecl->attributes);
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateAttributes:
+* @ctxt:  a schema validation context
+* @elem:  an element
+* @attributes:  the list of attribute declarations
+*
+* Validate the attributes of an element.
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem,
+xmlSchemaAttributePtr attributes)
+{
+int i, ret;
+xmlAttrPtr attr;
+xmlChar *value;
+xmlSchemaAttributeGroupPtr group = NULL;
+int found;
+if (attributes == NULL)
+return (0);
+while (attributes != NULL) {
+found = 0;
+/*
+* Handle attribute groups
+*/
+if (attributes->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
+group = (xmlSchemaAttributeGroupPtr) attributes;
+xmlSchemaValidateAttributes(ctxt, elem, group->attributes);
+attributes = group->next;
+continue;
+}
+for (i = ctxt->attrBase; i < ctxt->attrNr; i++) {
+attr = ctxt->attr[i].attr;
+if (attr == NULL)
+continue;
+if (attributes->ref != NULL) {
+if (!xmlStrEqual(attr->name, attributes->ref))
+continue;
+if (attr->ns != NULL) {
+if ((attributes->refNs == NULL) ||
+(!xmlStrEqual(attr->ns->href, attributes->refNs)))
+continue;
+} else if (attributes->refNs != NULL) {
+continue;
+}
+} else {
+if (!xmlStrEqual(attr->name, attributes->name))
+continue;
+/*
+* handle the namespaces checks here
+*/
+if (attr->ns == NULL) {
+/*
+* accept an unqualified attribute only if the target
+* namespace of the declaration is absent.
+*/
+if (attributes->targetNamespace != NULL)
+/*
+* This check was removed, since the target namespace
+* was evaluated during parsing and already took
+* "attributeFormDefault" into account.
+*/
+/* ((attributes->flags & XML_SCHEMAS_ATTR_NSDEFAULT) == 0)) */
+continue;
+} else {
+if (attributes->targetNamespace == NULL)
+continue;
+if (!xmlStrEqual(attributes->targetNamespace,
+attr->ns->href))
+continue;
+}
+}
+found = 1;
+ctxt->cur = (xmlNodePtr) attributes;
+if (attributes->subtypes == NULL) {
+xmlSchemaVErr(ctxt, (xmlNodePtr) attr, XML_SCHEMAS_ERR_INTERNAL,
+"Internal error: attribute %s type not resolved\n",
+attr->name, NULL);
+continue;
+}
+if (attributes->occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_INVALIDATTR,
+"attribute %s on %s is prohibited\n",
+attributes->name, elem->name);
+/* Setting the state to XML_SCHEMAS_ATTR_CHECKED seems
+* not very logical but it suppresses the
+* "attribute is unknown" error report. Please change
+* this if you know better */
+ctxt->attr[i].state = XML_SCHEMAS_ATTR_CHECKED;
+break;
+}
+value = xmlNodeListGetString(elem->doc, attr->children, 1);
+ret = xmlSchemaValidateSimpleValue(ctxt, attributes->subtypes,
+value);
+if (ret != 0) {
+xmlSchemaVErr(ctxt, (xmlNodePtr) attr,
+XML_SCHEMAS_ERR_ATTRINVALID,
+"attribute %s on %s does not match type\n",
+attr->name, elem->name);
+} else {
+ctxt->attr[i].state = XML_SCHEMAS_ATTR_CHECKED;
+}
+if (value != NULL) {
+xmlFree(value);
+}
+}
+if ((!found) && (attributes->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED)) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_MISSING,
+"required attribute %s on %s is missing\n",
+attributes->name, elem->name);
+}
+attributes = attributes->next;
+}
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateElement:
+* @ctxt:  a schema validation context
+* @elem:  an element
+*
+* Validate an element in a tree
+*
+* Returns 0 if the element is schemas valid, a positive error code
+*     number otherwise and -1 in case of internal or API error.
+*/
+static int
+xmlSchemaValidateElement(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem)
+{
+xmlSchemaElementPtr elemDecl;
+int ret, attrBase;
+if (elem->ns != NULL) {
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+elem->name, elem->ns->href, NULL);
+} else {
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+elem->name, NULL, NULL);
+}
+/*
+* special case whe elementFormDefault is unqualified for top-level elem.
+*/
+/*
+* This was removed, since elementFormDefault does not apply to top-level
+* element declarations.
+*/
+/*
+if ((elemDecl == NULL) && (elem->ns != NULL) &&
+(elem->parent != NULL) && (elem->parent->type != XML_ELEMENT_NODE) &&
+(xmlStrEqual(ctxt->schema->targetNamespace, elem->ns->href)) &&
+((ctxt->schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0)) {
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+elem->name, NULL, NULL);
+}
+*/
+/*
+* 3.3.4 : 1
+*/
+if (elemDecl == NULL) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_UNDECLAREDELEM,
+"Element %s not declared\n", elem->name, NULL);
+return (ctxt->err);
+}
+if (elemDecl->subtypes == NULL) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_NOTYPE,
+"Element %s has no type\n", elem->name, NULL);
+return (ctxt->err);
+}
+/*
+* Verify the attributes
+*/
+attrBase = ctxt->attrBase;
+ctxt->attrBase = ctxt->attrNr;
+xmlSchemaRegisterAttributes(ctxt, elem->properties);
+xmlSchemaValidateAttributes(ctxt, elem, elemDecl->attributes);
+/*
+* Verify the element content recursively
+*/
+if (elemDecl->contModel != NULL) {
+ctxt->regexp = xmlRegNewExecCtxt(elemDecl->contModel,
+(xmlRegExecCallbacks)
+xmlSchemaValidateCallback, ctxt);
+#ifdef DEBUG_AUTOMATA
+xmlGenericError(xmlGenericErrorContext, "====> %s\n", elem->name);
+#endif
+}
+xmlSchemaValidateType(ctxt, elem, elemDecl, elemDecl->subtypes);
+if (elemDecl->contModel != NULL) {
+ret = xmlRegExecPushString(ctxt->regexp, NULL, NULL);
+#ifdef DEBUG_AUTOMATA
+xmlGenericError(xmlGenericErrorContext,
+"====> %s : %d\n", elem->name, ret);
+#endif
+if (ret == 0) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ELEMCONT,
+"Element %s content check failed\n",
+elem->name, NULL);
+} else if (ret < 0) {
+xmlSchemaVErr(ctxt, elem, XML_SCHEMAS_ERR_ELEMCONT,
+"Element %s content check failed\n",
+elem->name, NULL);
+#ifdef DEBUG_CONTENT
+} else {
+xmlGenericError(xmlGenericErrorContext,
+"Element %s content check succeeded\n",
+elem->name);
+#endif
+}
+xmlRegFreeExecCtxt(ctxt->regexp);
+}
+/*
+* Verify that all attributes were Schemas-validated
+*/
+xmlSchemaCheckAttributes(ctxt, elem);
+ctxt->attrNr = ctxt->attrBase;
+ctxt->attrBase = attrBase;
+return (ctxt->err);
+}
+/**
+* xmlSchemaValidateDocument:
+* @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.
+*/
+static int
+xmlSchemaValidateDocument(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
+{
+xmlNodePtr root;
+xmlSchemaElementPtr elemDecl;
+root = xmlDocGetRootElement(doc);
+if (root == NULL) {
+xmlSchemaVErr(ctxt, (xmlNodePtr) doc, XML_SCHEMAS_ERR_NOROOT,
+"document has no root\n", NULL, NULL);
+return (ctxt->err);
+}
+if (root->ns != NULL)
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+root->name, root->ns->href, NULL);
+else
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+root->name, NULL, NULL);
+/*
+* special case whe elementFormDefault is unqualified for top-level elem.
+*/
+if ((elemDecl == NULL) && (root->ns != NULL) &&
+(xmlStrEqual(ctxt->schema->targetNamespace, root->ns->href)) &&
+((ctxt->schema->flags & XML_SCHEMAS_QUALIF_ELEM) == 0)) {
+elemDecl = xmlHashLookup3(ctxt->schema->elemDecl,
+root->name, NULL, NULL);
+}
+if (elemDecl == NULL) {
+xmlSchemaVErr(ctxt, root, XML_SCHEMAS_ERR_UNDECLAREDELEM,
+"Element %s not declared\n", root->name, NULL);
+} else if ((elemDecl->flags & XML_SCHEMAS_ELEM_TOPLEVEL) == 0) {
+xmlSchemaVErr(ctxt, root, XML_SCHEMAS_ERR_NOTTOPLEVEL,
+"Root element %s not toplevel\n", root->name, NULL);
+}
+/*
+* Okay, start the recursive validation
+*/
+xmlSchemaValidateElement(ctxt, root);
+return (ctxt->err);
+}
+/************************************************************************
+*                                  *
+*          SAX Validation code             *
+*                                  *
+************************************************************************/
+/************************************************************************
+*                                  *
+*          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->schema = schema;
+ret->attrNr = 0;
+ret->attrMax = 10;
+ret->attr = (xmlSchemaAttrStatePtr) xmlMalloc(ret->attrMax *
+sizeof
+(xmlSchemaAttrState));
+if (ret->attr == NULL) {
+xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
+free(ret);
+return (NULL);
+}
+memset(ret->attr, 0, ret->attrMax * sizeof(xmlSchemaAttrState));
+return (ret);
+}
+/**
+* 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->attr != NULL)
+xmlFree(ctxt->attr);
+if (ctxt->value != NULL)
+xmlSchemaFreeValue(ctxt->value);
+xmlFree(ctxt);
+}
+/**
+* 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->userData = ctx;
+}
+/**
+* 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)
+{
+int ret;
+if ((ctxt == NULL) || (doc == NULL))
+return (-1);
+ctxt->doc = doc;
+ret = xmlSchemaValidateDocument(ctxt, doc);
+return (ret);
+}
+/**
+* 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 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
+xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt,
+xmlParserInputBufferPtr input, xmlCharEncoding enc,
+xmlSAXHandlerPtr sax, void *user_data)
+{
+if ((ctxt == NULL) || (input == NULL))
+return (-1);
+ctxt->input = input;
+ctxt->enc = enc;
+ctxt->sax = sax;
+ctxt->user_data = user_data;
+TODO return (0);
+}
+#endif /* LIBXML_SCHEMAS_ENABLED */