diff options
Diffstat (limited to 'xmlschemas.c')
| -rw-r--r-- | xmlschemas.c | 6398 |
1 files changed, 6398 insertions, 0 deletions
diff --git a/xmlschemas.c b/xmlschemas.c new file mode 100644 index 0000000..192cfe8 --- /dev/null +++ b/xmlschemas.c @@ -0,0 +1,6398 @@ +/* + * 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 "libxml.h" + +#ifdef LIBXML_SCHEMAS_ENABLED + +#include <string.h> +#include <libxml/xmlmemory.h> +#include <libxml/parser.h> +#include <libxml/parserInternals.h> +#include <libxml/hash.h> +#include <libxml/uri.h> + +#include <libxml/xmlschemas.h> +#include <libxml/schemasInternals.h> +#include <libxml/xmlschemastypes.h> +#include <libxml/xmlautomata.h> +#include <libxml/xmlregexp.h> +#include <libxml/dict.h> + +/* #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 + */ +static const xmlChar *xmlSchemaNs = (const xmlChar *) + "http://www.w3.org/2001/XMLSchema"; + +static const xmlChar *xmlSchemaInstanceNs = (const xmlChar *) + "http://www.w3.org/2001/XMLSchema-instance"; + +#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); +/************************************************************************ + * * + * 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); +} + +/** + * xmlSchemaFreeAnnot: + * @annot: a schema type structure + * + * Deallocate a annotation structure + */ +static void +xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot) +{ + if (annot == NULL) + return; + xmlFree(annot); +} + +/** + * 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); +} + +/** + * xmlSchemaFreeFacet: + * @facet: a schema facet structure + * + * Deallocate a Schema Facet structure. + */ +void +xmlSchemaFreeFacet(xmlSchemaFacetPtr facet) +{ + if (facet == NULL) + return; + if (facet->val != NULL) + xmlSchemaFreeValue(facet->val); + if (facet->regexp != NULL) + xmlRegFreeRegexp(facet->regexp); + if (facet->annot != NULL) + xmlSchemaFreeAnnot(facet->annot); + xmlFree(facet); +} + +/** + * xmlSchemaFreeType: + * @type: a schema type structure + * + * Deallocate a Schema Type structure. + */ +void +xmlSchemaFreeType(xmlSchemaTypePtr type) +{ + if (type == NULL) + return; + if (type->annot != NULL) + xmlSchemaFreeAnnot(type->annot); + if (type->facets != NULL) { + xmlSchemaFacetPtr facet, next; + + facet = type->facets; + while (facet != NULL) { + next = facet->next; + xmlSchemaFreeFacet(facet); + facet = next; + } + } + xmlFree(type); +} + +/** + * 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); +} + +/** + * 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 + */ +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; + + 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); +} + +/************************************************************************ + * * + * 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); + } + } 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(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); +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); + } 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 inproper 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]; + const xmlChar *local, *ns; + + + 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); + ret = xmlSchemaAddAttribute(ctxt, schema, BAD_CAST name, ns); + if (ret == NULL) { + return (NULL); + } + 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 -1 in case of error, 0 if the declaration is inproper and + * 1 in case of success. + */ +static xmlSchemaAttributePtr +xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema, + xmlNodePtr node) +{ + const xmlChar *name, *refNs = NULL, *ref = NULL; + xmlSchemaAttributePtr ret; + xmlNodePtr child = 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_ATTR_NONAME_NOREF, + "Attribute has no name nor ref\n", NULL, NULL); + return (NULL); + } + snprintf(buf, 99, "anonattr %d", ctxt->counter++ + 1); + name = (const xmlChar *) buf; + ret = xmlSchemaAddAttribute(ctxt, schema, name, NULL); + } else { + const xmlChar *local, *ns; + + local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); + ret = xmlSchemaAddAttribute(ctxt, schema, local, ns); + } + if (ret == NULL) { + return (NULL); + } + ret->ref = ref; + ret->refNs = refNs; + 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)); + 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")) { + 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); + } 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 -1 in case of error, 0 if the declaration is inproper and + * 1 in case of success. + */ +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]; + + 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_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 *local, *ns; + + local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); + ret = xmlSchemaAddElement(ctxt, schema, local, ns); + } + 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; + 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)); + 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)) { + 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 (IS_SCHEMA(child, "complexType")) { + ret->subtypes = xmlSchemaParseComplexType(ctxt, schema, child); + child = child->next; + } else if (IS_SCHEMA(child, "simpleType")) { + 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 inproper 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_LIST; + 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 inproper 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 inproper 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 { + const xmlChar *local, *ns; + + local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); + type = xmlSchemaAddType(ctxt, schema, local, ns); + } + 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 (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 inproper 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 inproper 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 inproper 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); + 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 inproper 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 inproper 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 inproper 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, "complexContent %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; + const xmlChar *mixed; + 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, "anontype %d", ctxt->counter++ + 1); + name = (const xmlChar *)buf; + type = xmlSchemaAddType(ctxt, schema, name, NULL); + } else { + const xmlChar *local, *ns; + + local = xmlSchemaGetNamespace(ctxt, schema, node, name, &ns); + type = xmlSchemaAddType(ctxt, schema, local, ns); + } + if (type == NULL) { + return (NULL); + } + + mixed = xmlSchemaGetProp(ctxt, node, "mixed"); + if (mixed != NULL) + 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")) { + 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; + 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; + + xmlSchemaBuildAContentModel(type->baseType, ctxt, name); + 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) { + } + 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; + } +} + +/** + * 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) + 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; + } + xmlSchemaTypeFixup(base, ctxt, NULL); + 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_NOTATION: + case XML_SCHEMA_TYPE_LIST: + case XML_SCHEMA_TYPE_UNION: + 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 +} + +/** + * 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 { + 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"); +} + +/** + * 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) +{ + 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; + 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); +} + +/************************************************************************ + * * + * Simple type validation * + * * + ************************************************************************/ + +/** + * 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) +{ + 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 (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 = xmlSchemaValidateSimpleValue(ctxt, base, value); + } 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 = xmlSchemaValidateFacets(ctxt, base, facet, value); + } + } + } else if (type->type == XML_SCHEMA_TYPE_SIMPLE) { + xmlSchemaTypePtr base; + + base = type->subtypes; + if (base != NULL) { + ret = xmlSchemaValidateSimpleValue(ctxt, base, value); + } 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 = xmlSchemaValidateSimpleValue(ctxt, base, tmp); + xmlFree(tmp); + if (ret2 != 0) + ret = 1; + cur = end; + } while (*cur != 0); + } 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); +} + +/** + * 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); +} + +/** + * 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_PI_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; + xmlAttrPtr attr; + int ret; + + 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); + } + } + + ctxt->type = type->subtypes; + 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->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; + xmlSchemaValidateBasicType(ctxt, node); + } + 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; + } + 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; + } + 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 %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; + + if (attributes == NULL) + return (0); + while (attributes != NULL) { + /* + * 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 declaration + * is unqualified or if the schemas allowed it. + */ + if ((attributes->targetNamespace != NULL) && + ((attributes->flags & XML_SCHEMAS_ATTR_NSDEFAULT) == 0)) + continue; + } else { + if (attributes->targetNamespace == NULL) + continue; + if (!xmlStrEqual(attributes->targetNamespace, + attr->ns->href)) + continue; + } + } + 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; + } + 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); + } + } + 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. + */ + 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 */ |