#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 UNBOUNDED (1 << 30)
#define TODO \
xmlGenericError(xmlGenericErrorContext, \
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
#define XML_SCHEMAS_NO_NAMESPACE (const xmlChar *) "##"
static const xmlChar *xmlSchemaNs = (const xmlChar *)
"http://www.w3.org/2001/XMLSchema";
static const xmlChar *xmlSchemaInstanceNs = (const xmlChar *)
"http://www.w3.org/2001/XMLSchema-instance";
static const xmlChar *xmlSchemaElemDesElemDecl = (const xmlChar *)
"Element decl.";
static const xmlChar *xmlSchemaElemDesElemRef = (const xmlChar *)
"Element ref.";
static const xmlChar *xmlSchemaElemDesAttrDecl = (const xmlChar *)
"Attribute decl.";
static const xmlChar *xmlSchemaElemDesAttrRef = (const xmlChar *)
"Attribute ref.";
static const xmlChar *xmlSchemaElemDesST = (const xmlChar *)
"ST";
static const xmlChar *xmlSchemaElemDesCT = (const xmlChar *)
"CT";
#define IS_SCHEMA(node, type) \
((node != NULL) && (node->ns != NULL) && \
(xmlStrEqual(node->name, (const xmlChar *) type)) && \
(xmlStrEqual(node->ns->href, xmlSchemaNs)))
#define FREE_AND_NULL(str) \
if (str != NULL) { \
xmlFree(str); \
str = NULL; \
}
#define IS_ANYTYPE(item) \
((item->type == XML_SCHEMA_TYPE_BASIC) && \
(item->builtInType == XML_SCHEMAS_ANYTYPE))
#define IS_COMPLEX_TYPE(item) \
((item->type == XML_SCHEMA_TYPE_COMPLEX) || \
(item->builtInType == XML_SCHEMAS_ANYTYPE))
#define IS_SIMPLE_TYPE(item) \
((item->type == XML_SCHEMA_TYPE_SIMPLE) || \
((item->type == XML_SCHEMA_TYPE_BASIC) && \
(item->builtInType != XML_SCHEMAS_ANYTYPE)))
#define XML_SCHEMAS_VAL_WTSP_PRESERVE 0
#define XML_SCHEMAS_VAL_WTSP_REPLACE 1
#define XML_SCHEMAS_VAL_WTSP_COLLAPSE 2
#define XML_SCHEMAS_PARSE_ERROR 1
#define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
typedef struct _xmlSchemaAssemble xmlSchemaAssemble;
typedef xmlSchemaAssemble *xmlSchemaAssemblePtr;
struct _xmlSchemaAssemble {
void **items;
int nbItems;
int sizeItems;
};
struct _xmlSchemaParserCtxt {
void *userData;
xmlSchemaValidityErrorFunc error;
xmlSchemaValidityWarningFunc warning;
xmlSchemaValidError err;
int nberrors;
xmlStructuredErrorFunc serror;
xmlSchemaPtr topschema;
xmlHashTablePtr namespaces;
xmlSchemaPtr schema;
const xmlChar *container;
int counter;
const xmlChar *URL;
xmlDocPtr doc;
int preserve;
const char *buffer;
int size;
xmlAutomataPtr am;
xmlAutomataStatePtr start;
xmlAutomataStatePtr end;
xmlAutomataStatePtr state;
xmlDictPtr dict;
int includes;
xmlSchemaTypePtr ctxtType;
xmlSchemaTypePtr parentItem;
xmlSchemaAssemblePtr assemble;
int options;
xmlSchemaValidCtxtPtr vctxt;
};
#define XML_SCHEMAS_ATTR_UNKNOWN 1
#define XML_SCHEMAS_ATTR_CHECKED 2
#define XML_SCHEMAS_ATTR_PROHIBITED 3
#define XML_SCHEMAS_ATTR_MISSING 4
#define XML_SCHEMAS_ATTR_INVALID_VALUE 5
#define XML_SCHEMAS_ATTR_TYPE_NOT_RESOLVED 6
#define XML_SCHEMAS_ATTR_INVALID_FIXED_VALUE 7
#define XML_SCHEMAS_ATTR_DEFAULT 8
typedef struct _xmlSchemaAttrState xmlSchemaAttrState;
typedef xmlSchemaAttrState *xmlSchemaAttrStatePtr;
struct _xmlSchemaAttrState {
xmlSchemaAttrStatePtr next;
xmlAttrPtr attr;
int state;
xmlSchemaAttributePtr decl;
const xmlChar *value;
};
struct _xmlSchemaValidCtxt {
void *userData;
xmlSchemaValidityErrorFunc error;
xmlSchemaValidityWarningFunc warning;
xmlStructuredErrorFunc serror;
xmlSchemaPtr schema;
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;
xmlSchemaAttrStatePtr attrTop;
xmlSchemaAttrStatePtr attr;
int valueWS;
int options;
xmlNodePtr validationRoot;
xmlSchemaParserCtxtPtr pctxt;
int xsiAssemble;
};
typedef struct _xmlSchemaImport xmlSchemaImport;
typedef xmlSchemaImport *xmlSchemaImportPtr;
struct _xmlSchemaImport {
const xmlChar *schemaLocation;
xmlSchemaPtr schema;
xmlDocPtr doc;
int isMain;
};
typedef struct _xmlSchemaInclude xmlSchemaInclude;
typedef xmlSchemaInclude *xmlSchemaIncludePtr;
struct _xmlSchemaInclude {
xmlSchemaIncludePtr next;
const xmlChar *schemaLocation;
xmlDocPtr doc;
};
typedef struct _xmlSchemaParticle xmlSchemaParticle;
typedef xmlSchemaParticle *xmlSchemaParticlePtr;
struct _xmlSchemaParticle {
xmlSchemaTypeType type;
xmlSchemaParticlePtr next;
int minOccurs;
int maxOccurs;
xmlSchemaTypePtr term;
};
typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
struct _xmlSchemaModelGroup {
xmlSchemaTypeType type;
int compositor;
xmlSchemaParticlePtr particles;
xmlSchemaAnnotPtr annot;
};
typedef struct _xmlSchemaModelGroupDef xmlSchemaModelGroupDef;
typedef xmlSchemaModelGroupDef *xmlSchemaModelGroupDefPtr;
struct _xmlSchemaModelGroupDef {
xmlSchemaTypeType type;
const xmlChar *name;
const xmlChar *targetNamespace;
xmlSchemaModelGroupPtr modelGroup;
xmlSchemaAnnotPtr annot;
};
static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static void
xmlSchemaTypeFixup(xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr ctxt, const xmlChar * name);
static const char *
xmlSchemaFacetTypeToString(xmlSchemaTypeType type);
static int
xmlSchemaValidateSimpleTypeValue(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
const xmlChar *value,
int fireErrors,
int applyFacets,
int normalize,
int checkNodes);
static int
xmlSchemaValidateElementByDeclaration(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaElementPtr elemDecl);
static int
xmlSchemaValidateElementByWildcard(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type);
static int
xmlSchemaHasElemOrCharContent(xmlNodePtr node);
static int
xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node);
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);
}
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);
}
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);
}
static void
xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
const xmlChar * strData1, const xmlChar * strData2,
const xmlChar * strData3, const char *msg, const xmlChar * str1,
const xmlChar * str2, const xmlChar * str3, const xmlChar * str4,
const xmlChar * str5)
{
xmlGenericErrorFunc channel = NULL;
xmlStructuredErrorFunc schannel = NULL;
void *data = NULL;
if (ctxt != NULL) {
ctxt->nberrors++;
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 *) strData1, (const char *) strData2,
(const char *) strData3, 0, 0, msg, str1, str2,
str3, str4, str5);
}
static void
xmlSchemaVErrMemory(xmlSchemaValidCtxtPtr ctxt,
const char *extra, xmlNodePtr node)
{
if (ctxt != NULL) {
ctxt->nberrors++;
ctxt->err = XML_SCHEMAV_INTERNAL;
}
__xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
extra);
}
static void
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;
}
__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);
}
static void
xmlSchemaVErrExt(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr node, int error,
const char *msg, const xmlChar * str1,
const xmlChar * str2, const xmlChar * str3,
const xmlChar * str4, const xmlChar * str5)
{
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;
}
__xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
error, XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
msg, str1, str2, str3, str4, str5);
}
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;
}
__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);
}
static const xmlChar *
xmlSchemaGetAttrName(xmlSchemaAttributePtr attr)
{
if (attr->ref != NULL)
return(attr->ref);
else
return(attr->name);
}
static const xmlChar *
xmlSchemaGetAttrTargetNsURI(xmlSchemaAttributePtr attr)
{
if (attr->ref != NULL)
return (attr->refNs);
else
return(attr->targetNamespace);
}
static const xmlChar*
xmlSchemaFormatNsUriLocal(xmlChar **buf,
const xmlChar *uri, const xmlChar *local)
{
if (*buf != NULL)
xmlFree(*buf);
if (uri == NULL) {
*buf = xmlStrdup(BAD_CAST "{'");
*buf = xmlStrcat(*buf, local);
} else {
*buf = xmlStrdup(BAD_CAST "{'");
*buf = xmlStrcat(*buf, uri);
*buf = xmlStrcat(*buf, BAD_CAST "', '");
*buf = xmlStrcat(*buf, local);
}
*buf = xmlStrcat(*buf, BAD_CAST "'}");
return ((const xmlChar *) *buf);
}
static const xmlChar*
xmlSchemaFormatNsPrefixLocal(xmlChar **buf,
xmlNsPtr ns, const xmlChar *local)
{
if (*buf != NULL) {
xmlFree(*buf);
*buf = NULL;
}
if ((ns == NULL) || (ns->prefix == NULL))
return(local);
else {
*buf = xmlStrdup(ns->prefix);
*buf = xmlStrcat(*buf, BAD_CAST ":");
*buf = xmlStrcat(*buf, local);
}
return ((const xmlChar *) *buf);
}
static xmlChar*
xmlSchemaFormatItemForReport(xmlChar **buf,
const xmlChar *itemDes,
xmlSchemaTypePtr item,
xmlNodePtr itemNode,
int parsing)
{
xmlChar *str = NULL;
int named = 1;
if (*buf != NULL) {
xmlFree(*buf);
*buf = NULL;
}
if (itemDes != NULL) {
*buf = xmlStrdup(itemDes);
} else if (item != NULL) {
if (item->type == XML_SCHEMA_TYPE_BASIC) {
if (item->builtInType == XML_SCHEMAS_ANYTYPE)
*buf = xmlStrdup(BAD_CAST "'anyType'");
else if (item->builtInType == XML_SCHEMAS_ANYSIMPLETYPE)
*buf = xmlStrdup(BAD_CAST "'anySimpleType'");
else {
*buf = xmlStrdup(BAD_CAST "'");
*buf = xmlStrcat(*buf, item->name);
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
} else if (item->type == XML_SCHEMA_TYPE_SIMPLE) {
if (item->flags & XML_SCHEMAS_TYPE_GLOBAL) {
*buf = xmlStrdup(xmlSchemaElemDesST);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, item->name);
*buf = xmlStrcat(*buf, BAD_CAST "'");
} else {
*buf = xmlStrdup(xmlSchemaElemDesST);
*buf = xmlStrcat(*buf, BAD_CAST " local");
}
} else if (item->type == XML_SCHEMA_TYPE_COMPLEX) {
if (item->flags & XML_SCHEMAS_TYPE_GLOBAL) {
*buf = xmlStrdup(xmlSchemaElemDesCT);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, item->name);
*buf = xmlStrcat(*buf, BAD_CAST "'");
} else {
*buf = xmlStrdup(xmlSchemaElemDesCT);
*buf = xmlStrcat(*buf, BAD_CAST " local");
}
} else if (item->type == XML_SCHEMA_TYPE_ATTRIBUTE) {
xmlSchemaAttributePtr attr;
attr = (xmlSchemaAttributePtr) item;
if ((attr->flags & XML_SCHEMAS_TYPE_GLOBAL) ||
(attr->ref == NULL)) {
*buf = xmlStrdup(xmlSchemaElemDesAttrDecl);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, attr->name);
*buf = xmlStrcat(*buf, BAD_CAST "'");
} else {
*buf = xmlStrdup(xmlSchemaElemDesAttrRef);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, attr->refPrefix);
*buf = xmlStrcat(*buf, BAD_CAST ":");
*buf = xmlStrcat(*buf, attr->ref);
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
} else if (item->type == XML_SCHEMA_TYPE_ELEMENT) {
xmlSchemaElementPtr elem;
elem = (xmlSchemaElementPtr) item;
if ((elem->flags & XML_SCHEMAS_TYPE_GLOBAL) ||
(elem->ref == NULL)) {
*buf = xmlStrdup(xmlSchemaElemDesElemDecl);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, elem->name);
*buf = xmlStrcat(*buf, BAD_CAST "'");
} else {
*buf = xmlStrdup(xmlSchemaElemDesElemRef);
*buf = xmlStrcat(*buf, BAD_CAST " '");
*buf = xmlStrcat(*buf, elem->refPrefix);
*buf = xmlStrcat(*buf, BAD_CAST ":");
*buf = xmlStrcat(*buf, elem->ref);
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
} else
named = 0;
} else
named = 0;
if ((named == 0) && (itemNode != NULL)) {
xmlNodePtr elem;
if (itemNode->type == XML_ATTRIBUTE_NODE)
elem = itemNode->parent;
else
elem = itemNode;
*buf = xmlStrdup(BAD_CAST "Element '");
if (parsing)
*buf = xmlStrcat(*buf, elem->name);
else
*buf = xmlStrcat(*buf,
xmlSchemaFormatNsPrefixLocal(&str, elem->ns, elem->name));
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
if ((itemNode != NULL) && (itemNode->type == XML_ATTRIBUTE_NODE)) {
*buf = xmlStrcat(*buf, BAD_CAST ", attribute '");
*buf = xmlStrcat(*buf, xmlSchemaFormatNsPrefixLocal(&str,
itemNode->ns, itemNode->name));
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
FREE_AND_NULL(str);
return (*buf);
}
static void
xmlSchemaPRequestItemDes(xmlChar **buf,
xmlSchemaTypePtr item,
xmlNodePtr itemNode)
{
if ((buf == 0) || (*buf != NULL))
return;
if (itemNode->type == XML_ATTRIBUTE_NODE)
itemNode = itemNode->parent;
xmlSchemaFormatItemForReport(buf, NULL, item, itemNode, 1);
}
static const xmlChar *
xmlSchemaFormatFacetEnumSet(xmlChar **buf, xmlSchemaTypePtr type)
{
xmlSchemaFacetLinkPtr link;
if (*buf != NULL)
xmlFree(*buf);
*buf = NULL;
for (link = type->facetSet; link != NULL; link = link->next) {
if (link->facet->type == XML_SCHEMA_FACET_ENUMERATION) {
if (*buf == NULL) {
*buf = xmlStrdup(BAD_CAST "'");
*buf = xmlStrcat(*buf, link->facet->value);
*buf = xmlStrcat(*buf, BAD_CAST "'");
} else {
*buf = xmlStrcat(*buf, BAD_CAST ", '");
*buf = xmlStrcat(*buf, link->facet->value);
*buf = xmlStrcat(*buf, BAD_CAST "'");
}
}
}
return ((const xmlChar *) *buf);
}
static void
xmlSchemaVFacetErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlNodePtr node,
const xmlChar *value,
unsigned long length,
xmlSchemaTypePtr type,
xmlSchemaFacetPtr facet,
const char *message,
const xmlChar *str1,
const xmlChar *str2,
const xmlChar *str3)
{
xmlChar *str = NULL, *msg = NULL;
xmlSchemaTypeType facetType;
xmlSchemaFormatItemForReport(&msg, NULL, NULL, node, 0);
msg = xmlStrcat(msg, BAD_CAST " [");
msg = xmlStrcat(msg, xmlSchemaFormatItemForReport(&str, NULL, type, NULL, 0));
msg = xmlStrcat(msg, BAD_CAST ", facet '");
if (error == XML_SCHEMAV_CVC_ENUMERATION_VALID) {
facetType = XML_SCHEMA_FACET_ENUMERATION;
} else
facetType = facet->type;
msg = xmlStrcat(msg, BAD_CAST xmlSchemaFacetTypeToString(facetType));
msg = xmlStrcat(msg, BAD_CAST "']: ");
if (message == NULL) {
if ((facetType == XML_SCHEMA_FACET_LENGTH) ||
(facetType == XML_SCHEMA_FACET_MINLENGTH) ||
(facetType == XML_SCHEMA_FACET_MAXLENGTH)) {
char len[25], actLen[25];
if (node->type == XML_ATTRIBUTE_NODE)
msg = xmlStrcat(msg, BAD_CAST "The value '%s' has a length of '%s'; ");
else
msg = xmlStrcat(msg, BAD_CAST "The value has a length of '%s'; ");
snprintf(len, 24, "%lu", xmlSchemaGetFacetValueAsULong(facet));
snprintf(actLen, 24, "%lu", length);
if (facetType == XML_SCHEMA_FACET_LENGTH)
msg = xmlStrcat(msg,
BAD_CAST "this differs from the allowed length of '%s'.\n");
else if (facetType == XML_SCHEMA_FACET_MAXLENGTH)
msg = xmlStrcat(msg,
BAD_CAST "this exceeds the allowed maximum length of '%s'.\n");
else if (facetType == XML_SCHEMA_FACET_MINLENGTH)
msg = xmlStrcat(msg,
BAD_CAST "this underruns the allowed minimum length of '%s'.\n");
if (node->type == XML_ATTRIBUTE_NODE)
xmlSchemaVErrExt(ctxt, node, error,
(const char *) msg,
value, (const xmlChar *) actLen, (const xmlChar *) len,
NULL, NULL);
else
xmlSchemaVErr(ctxt, node, error,
(const char *) msg,
(const xmlChar *) actLen, (const xmlChar *) len);
} else if (facetType == XML_SCHEMA_FACET_ENUMERATION) {
msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not an element "
"of the set {%s}.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, value,
xmlSchemaFormatFacetEnumSet(&str, type));
} else if (facetType == XML_SCHEMA_FACET_PATTERN) {
msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not accepted "
"by the pattern '%s'.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, value,
facet->value);
} else if (node->type == XML_ATTRIBUTE_NODE) {
msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not facet-valid.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, value, NULL);
} else {
msg = xmlStrcat(msg, BAD_CAST "The value is not facet-valid.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, NULL, NULL);
}
} else {
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
xmlSchemaVErr3(ctxt, node, error, (const char *) msg, str1, str2, str3);
}
FREE_AND_NULL(str)
xmlFree(msg);
}
static void
xmlSchemaVSimpleTypeErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlNodePtr node,
const xmlChar *value,
xmlSchemaTypePtr type)
{
xmlChar *str = NULL, *msg = NULL;
xmlSchemaFormatItemForReport(&msg, NULL, NULL, node, 0);
msg = xmlStrcat(msg, BAD_CAST " [");
msg = xmlStrcat(msg, xmlSchemaFormatItemForReport(&str, NULL, type, NULL, 0));
if (node->type == XML_ATTRIBUTE_NODE) {
msg = xmlStrcat(msg, BAD_CAST "]: The value '%s' is not valid.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, value, NULL);
} else {
msg = xmlStrcat(msg, BAD_CAST "]: The character content is not valid.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, NULL, NULL);
}
FREE_AND_NULL(str)
xmlFree(msg);
}
static void
xmlSchemaVComplexTypeErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlNodePtr node,
xmlSchemaTypePtr type,
const char *message)
{
xmlChar *str = NULL, *msg = NULL;
xmlSchemaFormatItemForReport(&msg, NULL, NULL, node, 0);
if (type != NULL) {
msg = xmlStrcat(msg, BAD_CAST " [");
msg = xmlStrcat(msg, xmlSchemaFormatItemForReport(&str, NULL, type, NULL, 0));
msg = xmlStrcat(msg, BAD_CAST "]");
}
msg = xmlStrcat(msg, BAD_CAST ": %s.\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg,
(const xmlChar *) message, NULL);
FREE_AND_NULL(str)
xmlFree(msg);
}
static void
xmlSchemaPMissingAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr ownerElem,
const char *name,
const char *message)
{
xmlChar *des = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, ownerElem, 1);
des = *ownerDes;
} else
des = *ownerDes;
if (message != NULL)
xmlSchemaPErr(ctxt, ownerElem, error, "%s: %s.\n", BAD_CAST des, BAD_CAST message);
else
xmlSchemaPErr(ctxt, ownerElem, error,
"%s: The attribute '%s' is required but missing.\n",
BAD_CAST des, BAD_CAST name);
if (ownerDes == NULL)
FREE_AND_NULL(des);
}
static const char *
xmlSchemaCompTypeToString(xmlSchemaTypeType type)
{
switch (type) {
case XML_SCHEMA_TYPE_SIMPLE:
return("simple type definition");
case XML_SCHEMA_TYPE_COMPLEX:
return("complex type definition");
case XML_SCHEMA_TYPE_ELEMENT:
return("element declaration");
case XML_SCHEMA_TYPE_ATTRIBUTE:
return("attribute declaration");
case XML_SCHEMA_TYPE_GROUP:
return("model group definition");
case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
return("attribute group definition");
case XML_SCHEMA_TYPE_NOTATION:
return("notation declaration");
default:
return("Not a schema component");
}
}
static void
xmlSchemaPResCompAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr ownerElem,
const char *name,
const xmlChar *refName,
const xmlChar *refURI,
xmlSchemaTypeType refType,
const char *refTypeStr)
{
xmlChar *des = NULL, *strA = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, ownerElem, 1);
des = *ownerDes;
} else
des = *ownerDes;
if (refTypeStr == NULL)
refTypeStr = xmlSchemaCompTypeToString(refType);
xmlSchemaPErrExt(ctxt, ownerElem, error,
NULL, NULL, NULL,
"%s, attribute '%s': The QName value %s does not resolve to a(n) "
"%s.\n", BAD_CAST des, BAD_CAST name,
xmlSchemaFormatNsUriLocal(&strA, refURI, refName),
BAD_CAST refTypeStr, NULL);
if (ownerDes == NULL)
FREE_AND_NULL(des)
FREE_AND_NULL(strA)
}
static void
xmlSchemaPCustomAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
const char *msg)
{
xmlChar *des = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, attr->parent, 1);
des = *ownerDes;
} else
des = *ownerDes;
xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
"%s, attribute '%s': %s.\n",
BAD_CAST des, attr->name, (const xmlChar *) msg, NULL, NULL);
if (ownerDes == NULL)
FREE_AND_NULL(des);
}
static void
xmlSchemaPIllegalAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr)
{
xmlChar *des = NULL, *strA = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, attr->parent, 1);
des = *ownerDes;
} else
des = *ownerDes;
xmlSchemaPErr(ctxt, (xmlNodePtr) attr, error,
"%s: The attribute '%s' is not allowed.\n", BAD_CAST des,
xmlSchemaFormatNsPrefixLocal(&strA, attr->ns, attr->name));
if (ownerDes == NULL)
FREE_AND_NULL(des);
FREE_AND_NULL(strA);
}
static void
xmlSchemaPAquireDes(xmlChar **des,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlNodePtr itemElem)
{
if (itemDes == NULL)
xmlSchemaFormatItemForReport(des, NULL, item, itemElem, 1);
else if (*itemDes == NULL) {
xmlSchemaFormatItemForReport(itemDes, NULL, item, itemElem, 1);
*des = *itemDes;
} else
*des = *itemDes;
}
static void
xmlSchemaPCustomErrExt(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlNodePtr itemElem,
const char *message,
const xmlChar *str1,
const xmlChar *str2,
const xmlChar *str3)
{
xmlChar *des = NULL, *msg = NULL;
xmlSchemaPAquireDes(&des, itemDes, item, itemElem);
msg = xmlStrdup(BAD_CAST "%s: ");
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
if ((itemElem == NULL) && (item != NULL))
itemElem = item->node;
xmlSchemaPErrExt(ctxt, itemElem, error, NULL, NULL, NULL,
(const char *) msg, BAD_CAST des, str1, str2, str3, NULL);
if (itemDes == NULL)
FREE_AND_NULL(des);
FREE_AND_NULL(msg);
}
static void
xmlSchemaPCustomErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlNodePtr itemElem,
const char *message,
const xmlChar *str1)
{
xmlSchemaPCustomErrExt(ctxt, error, itemDes, item, itemElem, message,
str1, NULL, NULL);
}
static void
xmlSchemaPAttrUseErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlNodePtr itemElem,
const xmlSchemaAttributePtr attr,
const char *message,
const xmlChar *str1)
{
xmlChar *des = NULL, *strA = NULL, *msg = NULL;
xmlSchemaPAquireDes(&des, itemDes, item, itemElem);
xmlSchemaFormatNsUriLocal(&strA, xmlSchemaGetAttrTargetNsURI(attr),
xmlSchemaGetAttrName(attr));
msg = xmlStrdup(BAD_CAST "%s, attr. use %s: ");
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
if ((itemElem == NULL) && (item != NULL))
itemElem = item->node;
xmlSchemaPErrExt(ctxt, itemElem, error, NULL, NULL, NULL,
(const char *) msg, BAD_CAST des, BAD_CAST strA, str1, NULL, NULL);
if (itemDes == NULL)
FREE_AND_NULL(des);
FREE_AND_NULL(strA);
xmlFree(msg);
}
static void
xmlSchemaPIllegalFacetAtomicErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlSchemaTypePtr baseItem,
xmlSchemaFacetPtr facet)
{
xmlChar *des = NULL, *strT = NULL;
xmlSchemaPAquireDes(&des, itemDes, item, item->node);
xmlSchemaPErrExt(ctxt, item->node, error, NULL, NULL, NULL,
"%s: The facet '%s' is not allowed on types derived from the "
"type %s.\n",
BAD_CAST des, BAD_CAST xmlSchemaFacetTypeToString(facet->type),
xmlSchemaFormatItemForReport(&strT, NULL, baseItem, NULL, 1),
NULL, NULL);
if (itemDes == NULL)
FREE_AND_NULL(des);
FREE_AND_NULL(strT);
}
static void
xmlSchemaPIllegalFacetListUnionErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **itemDes,
xmlSchemaTypePtr item,
xmlSchemaFacetPtr facet)
{
xmlChar *des = NULL, *strT = NULL;
xmlSchemaPAquireDes(&des, itemDes, item, item->node);
xmlSchemaPErr(ctxt, item->node, error,
"%s: The facet '%s' is not allowed.\n",
BAD_CAST des, BAD_CAST xmlSchemaFacetTypeToString(facet->type));
if (itemDes == NULL)
FREE_AND_NULL(des);
FREE_AND_NULL(strT);
}
static void
xmlSchemaPMutualExclAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
const char *name1,
const char *name2)
{
xmlChar *des = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, attr->parent, 1);
des = *ownerDes;
} else
des = *ownerDes;
xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
"%s: The attributes '%s' and '%s' are mutually exclusive.\n",
BAD_CAST des, BAD_CAST name1, BAD_CAST name2, NULL, NULL);
if (ownerDes == NULL)
FREE_AND_NULL(des)
}
static void
xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr node,
xmlSchemaTypePtr type,
const char *typeDes,
const xmlChar *value,
const char *message,
const xmlChar *str1,
const xmlChar *str2)
{
xmlChar *des = NULL, *strA = NULL, *strT = NULL;
if (ownerDes == NULL)
xmlSchemaPRequestItemDes(&des, ownerItem, node);
else if (*ownerDes == NULL) {
xmlSchemaPRequestItemDes(ownerDes, ownerItem, node);
des = *ownerDes;
} else
des = *ownerDes;
if (type != NULL)
typeDes = (const char *) xmlSchemaFormatItemForReport(&strT, NULL, type, NULL, 1);
if (message == NULL) {
if (node->type == XML_ATTRIBUTE_NODE) {
xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
"%s, attribute '%s' [%s]: The value '%s' is not "
"valid.\n",
BAD_CAST des, xmlSchemaFormatNsPrefixLocal(&strA, node->ns,
node->name), BAD_CAST typeDes, value, NULL);
} else {
xmlSchemaPErr(ctxt, node, error,
"%s [%s]: The character content is not valid.\n",
BAD_CAST des, BAD_CAST typeDes);
}
} else {
xmlChar *msg;
msg = xmlStrdup(BAD_CAST "%s");
if (node->type == XML_ATTRIBUTE_NODE)
msg = xmlStrcat(msg, BAD_CAST ", attribute '%s'");
msg = xmlStrcat(msg, BAD_CAST " [%s]: ");
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
if (node->type == XML_ATTRIBUTE_NODE) {
xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
(const char *) msg,
BAD_CAST des, xmlSchemaFormatNsPrefixLocal(&strA,
node->ns, node->name), BAD_CAST typeDes, str1, str2);
} else {
xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
(const char *) msg,
BAD_CAST des, BAD_CAST typeDes, str1, str2, NULL);
}
xmlFree(msg);
}
FREE_AND_NULL(strA)
FREE_AND_NULL(strT)
if (ownerDes == NULL)
FREE_AND_NULL(des)
}
static void
xmlSchemaPContentErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr ownerElem,
xmlNodePtr child,
const char *message,
const char *content)
{
xmlChar *des = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem, 1);
else if (*ownerDes == NULL) {
xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, ownerElem, 1);
des = *ownerDes;
} else
des = *ownerDes;
if (message != NULL)
xmlSchemaPErr2(ctxt, ownerElem, child, error,
"%s: %s.\n",
BAD_CAST des, BAD_CAST message);
else {
if (content != NULL) {
xmlSchemaPErr2(ctxt, ownerElem, child, error,
"%s: The content is not valid. Expected is %s.\n",
BAD_CAST des, BAD_CAST content);
} else {
xmlSchemaPErr2(ctxt, ownerElem, child, error,
"%s: The content is not valid.\n",
BAD_CAST des, NULL);
}
}
if (ownerDes == NULL)
FREE_AND_NULL(des)
}
static void
xmlSchemaVIllegalAttrErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlAttrPtr attr)
{
xmlChar *strE = NULL, *strA = NULL;
xmlSchemaVErr(ctxt, (xmlNodePtr) attr,
error,
"%s: The attribute '%s' is not allowed.\n",
xmlSchemaFormatItemForReport(&strE, NULL, NULL, attr->parent, 0),
xmlSchemaFormatNsPrefixLocal(&strA, attr->ns, attr->name));
FREE_AND_NULL(strE)
FREE_AND_NULL(strA)
}
static void
xmlSchemaVCustomErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlNodePtr node,
xmlSchemaTypePtr type,
const char *message,
const xmlChar *str1)
{
xmlChar *msg = NULL, *str = NULL;
if (node == NULL) {
xmlSchemaVErr(ctxt, NULL,
XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaVCustomErr, no node "
"given.\n", NULL, NULL);
return;
}
if (node->type != XML_DOCUMENT_NODE) {
xmlSchemaFormatItemForReport(&msg, NULL, NULL, node, 0);
if (type != NULL) {
msg = xmlStrcat(msg, BAD_CAST " [");
msg = xmlStrcat(msg, xmlSchemaFormatItemForReport(&str, NULL, type, NULL, 0));
msg = xmlStrcat(msg, BAD_CAST "]");
}
msg = xmlStrcat(msg, BAD_CAST ": ");
} else
msg = xmlStrdup((const xmlChar *) "");
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, str1, NULL);
FREE_AND_NULL(msg)
FREE_AND_NULL(str)
}
static const char *
xmlSchemaWildcardPCToString(int pc)
{
switch (pc) {
case XML_SCHEMAS_ANY_SKIP:
return ("skip");
case XML_SCHEMAS_ANY_LAX:
return ("lax");
case XML_SCHEMAS_ANY_STRICT:
return ("strict");
default:
return ("invalid process contents");
}
}
static void
xmlSchemaVWildcardErr(xmlSchemaValidCtxtPtr ctxt,
xmlParserErrors error,
xmlNodePtr node,
xmlSchemaWildcardPtr wild,
const char *message)
{
xmlChar *des = NULL, *msg = NULL;
xmlSchemaFormatItemForReport(&des, NULL, NULL, node, 0);
msg = xmlStrdup(BAD_CAST "%s, [");
msg = xmlStrcat(msg, BAD_CAST xmlSchemaWildcardPCToString(wild->processContents));
msg = xmlStrcat(msg, BAD_CAST " WC]: ");
msg = xmlStrcat(msg, (const xmlChar *) message);
msg = xmlStrcat(msg, BAD_CAST ".\n");
xmlSchemaVErr(ctxt, node, error, (const char *) msg, BAD_CAST des, NULL);
FREE_AND_NULL(des);
FREE_AND_NULL(msg);
}
static void
xmlSchemaVMissingAttrErr(xmlSchemaValidCtxtPtr ctxt,
xmlNodePtr elem,
xmlSchemaAttributePtr type)
{
const xmlChar *name, *uri;
xmlChar *strE = NULL, *strA = NULL;
if (type->ref != NULL) {
name = type->ref;
uri = type->refNs;
} else {
name = type->name;
uri = type->targetNamespace;
}
xmlSchemaVErr(ctxt, elem,
XML_SCHEMAV_CVC_COMPLEX_TYPE_4,
"%s: The attribute %s is required but missing.\n",
xmlSchemaFormatItemForReport(&strE, NULL, NULL, elem, 0),
xmlSchemaFormatNsUriLocal(&strA, uri, name));
FREE_AND_NULL(strE)
FREE_AND_NULL(strA)
}
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);
}
static xmlSchemaAssemblePtr
xmlSchemaNewAssemble(void)
{
xmlSchemaAssemblePtr ret;
ret = (xmlSchemaAssemblePtr) xmlMalloc(sizeof(xmlSchemaAssemble));
if (ret == NULL) {
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaAssemble));
ret->items = NULL;
return (ret);
}
xmlSchemaFacetPtr
xmlSchemaNewFacet(void)
{
xmlSchemaFacetPtr ret;
ret = (xmlSchemaFacetPtr) xmlMalloc(sizeof(xmlSchemaFacet));
if (ret == NULL) {
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaFacet));
return (ret);
}
static xmlSchemaAnnotPtr
xmlSchemaNewAnnot(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
{
xmlSchemaAnnotPtr ret;
ret = (xmlSchemaAnnotPtr) xmlMalloc(sizeof(xmlSchemaAnnot));
if (ret == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating annotation", node);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaAnnot));
ret->content = node;
return (ret);
}
static void
xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot)
{
if (annot == NULL)
return;
xmlFree(annot);
}
static void
xmlSchemaFreeImport(xmlSchemaImportPtr import)
{
if (import == NULL)
return;
xmlSchemaFree(import->schema);
xmlFreeDoc(import->doc);
xmlFree(import);
}
static void
xmlSchemaFreeInclude(xmlSchemaIncludePtr include)
{
if (include == NULL)
return;
xmlFreeDoc(include->doc);
xmlFree(include);
}
static void
xmlSchemaFreeIncludeList(xmlSchemaIncludePtr includes)
{
xmlSchemaIncludePtr next;
while (includes != NULL) {
next = includes->next;
xmlSchemaFreeInclude(includes);
includes = next;
}
}
static void
xmlSchemaFreeNotation(xmlSchemaNotationPtr nota)
{
if (nota == NULL)
return;
xmlFree(nota);
}
static void
xmlSchemaFreeAttribute(xmlSchemaAttributePtr attr)
{
if (attr == NULL)
return;
if (attr->annot != NULL)
xmlSchemaFreeAnnot(attr->annot);
if (attr->defVal != NULL)
xmlSchemaFreeValue(attr->defVal);
xmlFree(attr);
}
static void
xmlSchemaFreeWildcardNsSet(xmlSchemaWildcardNsPtr set)
{
xmlSchemaWildcardNsPtr next;
while (set != NULL) {
next = set->next;
xmlFree(set);
set = next;
}
}
void
xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard)
{
if (wildcard == NULL)
return;
if (wildcard->annot != NULL)
xmlSchemaFreeAnnot(wildcard->annot);
if (wildcard->nsSet != NULL)
xmlSchemaFreeWildcardNsSet(wildcard->nsSet);
if (wildcard->negNsSet != NULL)
xmlFree(wildcard->negNsSet);
xmlFree(wildcard);
}
static void
xmlSchemaFreeAttributeGroup(xmlSchemaAttributeGroupPtr attr)
{
if (attr == NULL)
return;
if (attr->annot != NULL)
xmlSchemaFreeAnnot(attr->annot);
if ((attr->flags & XML_SCHEMAS_ATTRGROUP_GLOBAL) &&
(attr->attributeWildcard != NULL))
xmlSchemaFreeWildcard(attr->attributeWildcard);
xmlFree(attr);
}
static void
xmlSchemaFreeAttributeUseList(xmlSchemaAttributeLinkPtr attrUse)
{
xmlSchemaAttributeLinkPtr next;
while (attrUse != NULL) {
next = attrUse->next;
xmlFree(attrUse);
attrUse = next;
}
}
static void
xmlSchemaFreeTypeLinkList(xmlSchemaTypeLinkPtr link)
{
xmlSchemaTypeLinkPtr next;
while (link != NULL) {
next = link->next;
xmlFree(link);
link = next;
}
}
static void
xmlSchemaFreeElement(xmlSchemaElementPtr elem)
{
if (elem == NULL)
return;
if (elem->annot != NULL)
xmlSchemaFreeAnnot(elem->annot);
if (elem->contModel != NULL)
xmlRegFreeRegexp(elem->contModel);
if (elem->defVal != NULL)
xmlSchemaFreeValue(elem->defVal);
xmlFree(elem);
}
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);
}
void
xmlSchemaFreeType(xmlSchemaTypePtr type)
{
if (type == NULL)
return;
if (type->annot != NULL)
xmlSchemaFreeAnnot(type->annot);
if (type->facets != NULL) {
xmlSchemaFacetPtr facet, next;
facet = type->facets;
while (facet != NULL) {
next = facet->next;
xmlSchemaFreeFacet(facet);
facet = next;
}
}
if (type->type != XML_SCHEMA_TYPE_BASIC) {
if (type->attributeUses != NULL)
xmlSchemaFreeAttributeUseList(type->attributeUses);
if ((type->attributeWildcard != NULL) &&
((type->type != XML_SCHEMA_TYPE_COMPLEX) ||
(type->flags & XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD))) {
xmlSchemaFreeWildcard(type->attributeWildcard);
}
}
if (type->memberTypes != NULL)
xmlSchemaFreeTypeLinkList(type->memberTypes);
if (type->facetSet != NULL) {
xmlSchemaFacetLinkPtr next, link;
link = type->facetSet;
do {
next = link->next;
xmlFree(link);
link = next;
} while (link != NULL);
}
if (type->contModel != NULL)
xmlRegFreeRegexp(type->contModel);
xmlFree(type);
}
static void
xmlSchemaFreeTypeList(xmlSchemaTypePtr type)
{
xmlSchemaTypePtr next;
while (type != NULL) {
next = type->redef;
xmlSchemaFreeType(type);
type = next;
}
}
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);
}
#ifdef LIBXML_OUTPUT_ENABLED
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_GLOBAL)
fprintf(output, "global ");
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_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);
}
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");
}
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:
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");
}
}
void
xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
{
if (output == NULL)
return;
if (schema == NULL) {
fprintf(output, "Schemas: NULL\n");
return;
}
fprintf(output, "Schemas: ");
if (schema->name != NULL)
fprintf(output, "%s, ", schema->name);
else
fprintf(output, "no name, ");
if (schema->targetNamespace != NULL)
fprintf(output, "%s", (const char *) schema->targetNamespace);
else
fprintf(output, "no target namespace");
fprintf(output, "\n");
if (schema->annot != NULL)
xmlSchemaAnnotDump(output, schema->annot);
xmlHashScan(schema->typeDecl, (xmlHashScanner) xmlSchemaTypeDump,
output);
xmlHashScanFull(schema->elemDecl,
(xmlHashScannerFull) xmlSchemaElementDump, output);
}
#endif
static xmlAttrPtr
xmlSchemaGetPropNode(xmlNodePtr node, const char *name)
{
xmlAttrPtr prop;
if ((node == NULL) || (name == NULL))
return(NULL);
prop = node->properties;
while (prop != NULL) {
if ((prop->ns == NULL) && xmlStrEqual(prop->name, BAD_CAST name))
return(prop);
prop = prop->next;
}
return (NULL);
}
static xmlAttrPtr
xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
{
xmlAttrPtr prop;
if ((node == NULL) || (name == NULL))
return(NULL);
prop = node->properties;
while (prop != NULL) {
if ((prop->ns != NULL) &&
xmlStrEqual(prop->name, BAD_CAST name) &&
xmlStrEqual(prop->ns->href, BAD_CAST uri))
return(prop);
prop = prop->next;
}
return (NULL);
}
static const xmlChar *
xmlSchemaGetNodeContent(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
{
xmlChar *val;
const xmlChar *ret;
val = xmlNodeGetContent(node);
if (val == NULL)
return(NULL);
ret = xmlDictLookup(ctxt->dict, val, -1);
xmlFree(val);
return(ret);
}
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);
}
static xmlSchemaElementPtr
xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * namespace)
{
xmlSchemaElementPtr ret;
if ((name == NULL) || (schema == NULL))
return (NULL);
ret = xmlHashLookup2(schema->elemDecl, name, namespace);
if ((ret != NULL) &&
(ret->flags & XML_SCHEMAS_ELEM_GLOBAL)) {
return (ret);
} else
ret = NULL;
#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);
}
static xmlSchemaTypePtr
xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * namespace)
{
xmlSchemaTypePtr ret;
if (name == NULL)
return (NULL);
if (schema != NULL) {
ret = xmlHashLookup2(schema->typeDecl, name, namespace);
if ((ret != NULL) && (ret->flags & XML_SCHEMAS_TYPE_GLOBAL))
return (ret);
}
ret = xmlSchemaGetPredefinedType(name, namespace);
if (ret != NULL)
return (ret);
#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);
}
static xmlSchemaAttributePtr
xmlSchemaGetAttribute(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * namespace)
{
xmlSchemaAttributePtr ret;
if ((name == NULL) || (schema == NULL))
return (NULL);
ret = xmlHashLookup2(schema->attrDecl, name, namespace);
if ((ret != NULL) && (ret->flags & XML_SCHEMAS_ATTR_GLOBAL))
return (ret);
else
ret = NULL;
#ifdef DEBUG
if (ret == NULL) {
if (namespace == NULL)
fprintf(stderr, "Unable to lookup attribute %s", name);
else
fprintf(stderr, "Unable to lookup attribute %s:%s", name,
namespace);
}
#endif
return (ret);
}
static xmlSchemaAttributeGroupPtr
xmlSchemaGetAttributeGroup(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * namespace)
{
xmlSchemaAttributeGroupPtr ret;
if ((name == NULL) || (schema == NULL))
return (NULL);
ret = xmlHashLookup2(schema->attrgrpDecl, name, namespace);
if ((ret != NULL) && (ret->flags & XML_SCHEMAS_ATTRGROUP_GLOBAL))
return (ret);
else
ret = NULL;
#ifdef DEBUG
if (ret == NULL) {
if (namespace == NULL)
fprintf(stderr, "Unable to lookup attribute group %s", name);
else
fprintf(stderr, "Unable to lookup attribute group %s:%s", name,
namespace);
}
#endif
return (ret);
}
static xmlSchemaTypePtr
xmlSchemaGetGroup(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * namespace)
{
xmlSchemaTypePtr ret;
if ((name == NULL) || (schema == NULL))
return (NULL);
ret = xmlHashLookup2(schema->groupDecl, name, namespace);
if ((ret != NULL) && (ret->flags & XML_SCHEMAS_TYPE_GLOBAL))
return (ret);
else
ret = NULL;
#ifdef DEBUG
if (ret == NULL) {
if (namespace == NULL)
fprintf(stderr, "Unable to lookup group %s", name);
else
fprintf(stderr, "Unable to lookup group %s:%s", name,
namespace);
}
#endif
return (ret);
}
#define IS_BLANK_NODE(n) \
(((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content)))
static int
xmlSchemaIsBlank(xmlChar * str)
{
if (str == NULL)
return (1);
while (*str != 0) {
if (!(IS_BLANK_CH(*str)))
return (0);
str++;
}
return (1);
}
static int
xmlSchemaAddAssembledItem(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr item)
{
static int growSize = 100;
xmlSchemaAssemblePtr ass;
ass = ctxt->assemble;
if (ass->sizeItems < 0) {
return (0);
}
if (ass->sizeItems <= 0) {
ass->items = (void **) xmlMalloc(growSize * sizeof(xmlSchemaTypePtr));
if (ass->items == NULL) {
xmlSchemaPErrMemory(ctxt,
"allocating new item buffer", NULL);
return (-1);
}
ass->sizeItems = growSize;
} else if (ass->sizeItems <= ass->nbItems) {
ass->sizeItems *= 2;
ass->items = (void **) xmlRealloc(ass->items,
ass->sizeItems * sizeof(xmlSchemaTypePtr));
if (ass->items == NULL) {
xmlSchemaPErrMemory(ctxt,
"growing item buffer", NULL);
ass->sizeItems = 0;
return (-1);
}
}
((xmlSchemaTypePtr *) ass->items)[ass->nbItems++] = (void *) item;
return (0);
}
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,
"Annotation declaration '%s' is already declared.\n",
name, NULL);
xmlFree(ret);
return (NULL);
}
return (ret);
}
static xmlSchemaAttributePtr
xmlSchemaAddAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
const xmlChar * name, const xmlChar * namespace,
xmlNodePtr node)
{
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) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_REDEFINED_ATTR,
NULL, NULL, node,
"A global attribute declaration with the name '%s' does already exist", name);
xmlFree(ret);
return (NULL);
}
if (ctxt->assemble != NULL)
xmlSchemaAddAssembledItem(ctxt, (xmlSchemaTypePtr) ret);
return (ret);
}
static xmlSchemaAttributeGroupPtr
xmlSchemaAddAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, const xmlChar * name,
xmlNodePtr node)
{
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) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_REDEFINED_ATTRGROUP,
NULL, NULL, node,
"A global attribute group definition with the name '%s' does already exist", name);
xmlFree(ret);
return (NULL);
}
if (ctxt->assemble != NULL)
xmlSchemaAddAssembledItem(ctxt, (xmlSchemaTypePtr) ret);
return (ret);
}
static xmlSchemaElementPtr
xmlSchemaAddElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
const xmlChar * name, const xmlChar * namespace,
xmlNodePtr node, int topLevel)
{
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) {
if (topLevel) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_REDEFINED_ELEMENT,
NULL, NULL, node,
"A global element declaration with the name '%s' does "
"already exist", name);
xmlFree(ret);
return (NULL);
} else {
char buf[30];
snprintf(buf, 29, "#eCont %d", ctxt->counter++ + 1);
val = xmlHashAddEntry3(schema->elemDecl, name, (xmlChar *) buf,
namespace, ret);
if (val != 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, NULL, node,
"Internal error: xmlSchemaAddElement, "
"a dublicate element declaration with the name '%s' "
"could not be added to the hash.", name);
xmlFree(ret);
return (NULL);
}
}
}
if (ctxt->assemble != NULL)
xmlSchemaAddAssembledItem(ctxt, (xmlSchemaTypePtr) ret);
return (ret);
}
static xmlSchemaTypePtr
xmlSchemaAddType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
const xmlChar * name, const xmlChar * namespace,
xmlNodePtr node)
{
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) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_REDEFINED_TYPE,
NULL, NULL, node,
"A global type definition with the name '%s' does already exist", name);
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: xmlSchemaAddType, on type "
"'%s'.\n",
name, NULL);
xmlFree(ret);
return (NULL);
}
ret->redef = prev->redef;
prev->redef = ret;
}
}
ret->minOccurs = 1;
ret->maxOccurs = 1;
ret->attributeUses = NULL;
ret->attributeWildcard = NULL;
if (ctxt->assemble != NULL)
xmlSchemaAddAssembledItem(ctxt,ret);
return (ret);
}
static xmlSchemaTypePtr
xmlSchemaAddGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
const xmlChar * name, xmlNodePtr node)
{
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) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_REDEFINED_GROUP,
NULL, NULL, node,
"A global model group definition with the name '%s' does already exist", name);
xmlFree(ret);
return (NULL);
}
ret->minOccurs = 1;
ret->maxOccurs = 1;
if (ctxt->assemble != NULL)
xmlSchemaAddAssembledItem(ctxt, (xmlSchemaTypePtr) ret);
return (ret);
}
static xmlSchemaWildcardNsPtr
xmlSchemaNewWildcardNsConstraint(xmlSchemaParserCtxtPtr ctxt)
{
xmlSchemaWildcardNsPtr ret;
ret = (xmlSchemaWildcardNsPtr)
xmlMalloc(sizeof(xmlSchemaWildcardNs));
if (ret == NULL) {
xmlSchemaPErrMemory(ctxt, "creating wildcard namespace constraint", NULL);
return (NULL);
}
ret->value = NULL;
ret->next = NULL;
return (ret);
}
static xmlSchemaWildcardPtr
xmlSchemaAddWildcard(xmlSchemaParserCtxtPtr ctxt)
{
xmlSchemaWildcardPtr ret = NULL;
if (ctxt == NULL)
return (NULL);
ret = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
if (ret == NULL) {
xmlSchemaPErrMemory(ctxt, "adding wildcard", NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaWildcard));
ret->minOccurs = 1;
ret->maxOccurs = 1;
return (ret);
}
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;
xmlAttrPtr attr;
*namespace = NULL;
attr = xmlSchemaGetPropNode(node, name);
if (attr == NULL)
return (NULL);
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (val == NULL)
return (NULL);
if (!strchr((char *) val, ':')) {
ns = xmlSearchNs(node->doc, node, 0);
if (ns) {
*namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
return (val);
}
}
ret = xmlSplitQName3(val, &len);
if (ret == NULL) {
return (val);
}
ret = xmlDictLookup(ctxt->dict, ret, -1);
prefix = xmlDictLookup(ctxt->dict, val, len);
ns = xmlSearchNs(node->doc, node, prefix);
if (ns == NULL) {
xmlSchemaPSimpleTypeErr(ctxt, XML_SCHEMAP_PREFIX_UNDEFINED,
NULL, NULL, (xmlNodePtr) attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), NULL, val,
"The QName value '%s' has no corresponding namespace "
"declaration in scope", val, NULL);
} else {
*namespace = xmlDictLookup(ctxt->dict, ns->href, -1);
}
return (ret);
}
static int
xmlSchemaPValAttrNodeQNameValue(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
const xmlChar *value,
const xmlChar **uri,
const xmlChar **prefix,
const xmlChar **local)
{
const xmlChar *pref;
xmlNsPtr ns;
int len, ret;
*uri = NULL;
*local = NULL;
if (prefix != 0)
*prefix = NULL;
ret = xmlValidateQName(value, 1);
if (ret > 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
ownerDes, ownerItem, (xmlNodePtr) attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
"QName", value,
NULL, NULL, NULL);
*local = value;
return (ctxt->err);
} else if (ret < 0)
return (-1);
if (!strchr((char *) value, ':')) {
ns = xmlSearchNs(attr->doc, attr->parent, 0);
if (ns)
*uri = xmlDictLookup(ctxt->dict, ns->href, -1);
else if (schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) {
*uri = schema->targetNamespace;
}
*local = value;
return (0);
}
*local = xmlSplitQName3(value, &len);
*local = xmlDictLookup(ctxt->dict, *local, -1);
pref = xmlDictLookup(ctxt->dict, value, len);
if (prefix != 0)
*prefix = pref;
ns = xmlSearchNs(attr->doc, attr->parent, pref);
if (ns == NULL) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
ownerDes, ownerItem, (xmlNodePtr) attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), "QName", value,
"The QName value '%s' has no corresponding namespace "
"declaration in scope", value, NULL);
return (ctxt->err);
} else {
*uri = xmlDictLookup(ctxt->dict, ns->href, -1);
}
return (0);
}
static int
xmlSchemaPValAttrNodeQName(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
const xmlChar **uri,
const xmlChar **prefix,
const xmlChar **local)
{
const xmlChar *value;
value = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
return (xmlSchemaPValAttrNodeQNameValue(ctxt, schema,
ownerDes, ownerItem, attr, value, uri, prefix, local));
}
static int
xmlSchemaPValAttrQName(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr ownerElem,
const char *name,
const xmlChar **uri,
const xmlChar **prefix,
const xmlChar **local)
{
xmlAttrPtr attr;
attr = xmlSchemaGetPropNode(ownerElem, name);
if (attr == NULL) {
*local = NULL;
*uri = NULL;
return (0);
}
return (xmlSchemaPValAttrNodeQName(ctxt, schema,
ownerDes, ownerItem, attr, uri, prefix, local));
}
static int
xmlGetMaxOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
int min, int max, int def, const char *expected)
{
const xmlChar *val, *cur;
int ret = 0;
xmlAttrPtr attr;
attr = xmlSchemaGetPropNode(node, "maxOccurs");
if (attr == NULL)
return (def);
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlStrEqual(val, (const xmlChar *) "unbounded")) {
if (max != UNBOUNDED) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL, expected,
val, NULL, NULL, NULL);
return (def);
} else
return (UNBOUNDED);
}
cur = val;
while (IS_BLANK_CH(*cur))
cur++;
if (*cur == 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL, expected,
val, NULL, NULL, NULL);
return (def);
}
while ((*cur >= '0') && (*cur <= '9')) {
ret = ret * 10 + (*cur - '0');
cur++;
}
while (IS_BLANK_CH(*cur))
cur++;
if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL, expected,
val, NULL, NULL, NULL);
return (def);
}
return (ret);
}
static int
xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
int min, int max, int def, const char *expected)
{
const xmlChar *val, *cur;
int ret = 0;
xmlAttrPtr attr;
attr = xmlSchemaGetPropNode(node, "minOccurs");
if (attr == NULL)
return (def);
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
cur = val;
while (IS_BLANK_CH(*cur))
cur++;
if (*cur == 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL, expected,
val, NULL, NULL, NULL);
return (def);
}
while ((*cur >= '0') && (*cur <= '9')) {
ret = ret * 10 + (*cur - '0');
cur++;
}
while (IS_BLANK_CH(*cur))
cur++;
if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL, expected,
val, NULL, NULL, NULL);
return (def);
}
return (ret);
}
static int
xmlSchemaPGetBoolNodeValue(xmlSchemaParserCtxtPtr ctxt,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr node)
{
xmlChar *value = NULL;
int res = 0;
value = xmlNodeGetContent(node);
if (xmlStrEqual(BAD_CAST value, BAD_CAST "true"))
res = 1;
else if (xmlStrEqual(BAD_CAST value, BAD_CAST "false"))
res = 0;
else if (xmlStrEqual(BAD_CAST value, BAD_CAST "1"))
res = 1;
else if (xmlStrEqual(BAD_CAST value, BAD_CAST "0"))
res = 0;
else {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_INVALID_BOOLEAN,
ownerDes, ownerItem, node,
xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
"(1 | 0 | true | false)", BAD_CAST value,
NULL, NULL, NULL);
}
if (value != NULL)
xmlFree(value);
return (res);
}
static int
xmlGetBooleanProp(xmlSchemaParserCtxtPtr ctxt,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
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 if (xmlStrEqual(val, BAD_CAST "1"))
def = 1;
else if (xmlStrEqual(val, BAD_CAST "0"))
def = 0;
else {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_INVALID_BOOLEAN,
ownerDes, ownerItem, node,
xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
"(1 | 0 | true | false)", val, NULL, NULL, NULL);
}
return (def);
}
static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
ctxt, xmlSchemaPtr schema,
xmlNodePtr node,
int topLevel);
static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
ctxt,
xmlSchemaPtr schema,
xmlNodePtr node,
int topLevel);
static xmlSchemaTypePtr xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr
ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static xmlSchemaTypePtr xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static xmlSchemaTypePtr xmlSchemaParseAll(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static xmlSchemaAttributePtr xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr
ctxt,
xmlSchemaPtr schema,
xmlNodePtr node,
int topLevel);
static xmlSchemaAttributeGroupPtr
xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node,
int topLevel);
static xmlSchemaTypePtr xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static xmlSchemaTypePtr xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node);
static xmlSchemaWildcardPtr
xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node);
static int
xmlSchemaPValAttrNodeValue(xmlSchemaParserCtxtPtr ctxt,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
const xmlChar *value,
xmlSchemaTypePtr type)
{
int ret = 0;
if ((ctxt == NULL) || (type == NULL) || (attr == NULL))
return (-1);
if (type->type != XML_SCHEMA_TYPE_BASIC) {
xmlSchemaPErr(ctxt, (xmlNodePtr) attr,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaPvalueAttrNode, the given "
"type '%s' is not a built-in type.\n",
type->name, NULL);
return (-1);
}
switch (type->builtInType) {
case XML_SCHEMAS_NCNAME:
ret = xmlValidateNCName(value, 1);
break;
case XML_SCHEMAS_QNAME:
xmlSchemaPErr(ctxt, (xmlNodePtr) attr,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaPvalueAttrNode, use "
"the function xmlSchemaExtractSchemaQNamePropvalueidated "
"for extracting QName valueues instead.\n",
NULL, NULL);
return (-1);
case XML_SCHEMAS_ANYURI:
if (value != NULL) {
xmlURIPtr uri = xmlParseURI((const char *) value);
if (uri == NULL)
ret = 1;
else
xmlFreeURI(uri);
}
break;
case XML_SCHEMAS_TOKEN: {
const xmlChar *cur = value;
if (IS_BLANK_CH(*cur)) {
ret = 1;
} else while (*cur != 0) {
if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
ret = 1;
break;
} else if (*cur == ' ') {
cur++;
if ((*cur == 0) || (*cur == ' ')) {
ret = 1;
break;
}
} else {
cur++;
}
}
}
break;
case XML_SCHEMAS_LANGUAGE:
if (xmlCheckLanguageID(value) != 1)
ret = 1;
break;
default: {
xmlSchemaPErr(ctxt, (xmlNodePtr) attr,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaPvalueAttrNode, "
"valueidation using the type '%s' is not implemented "
"yet.\n",
type->name, NULL);
return (-1);
}
}
if (ret > 0) {
if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
ownerDes, ownerItem, (xmlNodePtr) attr,
type, NULL, value,
NULL, NULL, NULL);
return(XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2);
} else {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
ownerDes, ownerItem, (xmlNodePtr) attr,
type, NULL, value,
NULL, NULL, NULL);
return(XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1);
}
}
return (ret);
}
static int
xmlSchemaPValAttrNode(xmlSchemaParserCtxtPtr ctxt,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlAttrPtr attr,
xmlSchemaTypePtr type,
const xmlChar **value)
{
const xmlChar *val;
if ((ctxt == NULL) || (type == NULL) || (attr == NULL))
return (-1);
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (value != NULL)
*value = val;
return (xmlSchemaPValAttrNodeValue(ctxt, ownerDes, ownerItem, attr,
val, type));
}
static int
xmlSchemaPValAttr(xmlSchemaParserCtxtPtr ctxt,
xmlChar **ownerDes,
xmlSchemaTypePtr ownerItem,
xmlNodePtr ownerElem,
const char *name,
xmlSchemaTypePtr type,
const xmlChar **value)
{
xmlAttrPtr attr;
if ((ctxt == NULL) || (type == NULL)) {
if (value != NULL)
*value = NULL;
return (-1);
}
if (type->type != XML_SCHEMA_TYPE_BASIC) {
if (value != NULL)
*value = NULL;
xmlSchemaPErr(ctxt, ownerElem,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaPValAttr, the given "
"type '%s' is not a built-in type.\n",
type->name, NULL);
return (-1);
}
attr = xmlSchemaGetPropNode(ownerElem, name);
if (attr == NULL) {
if (value != NULL)
*value = NULL;
return (0);
}
return (xmlSchemaPValAttrNode(ctxt, ownerDes, ownerItem, attr,
type, value));
}
static xmlNodePtr
xmlSchemaParseAttrDecls(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr child, xmlSchemaTypePtr type)
{
xmlSchemaAttributePtr lastattr, attr;
lastattr = NULL;
while ((IS_SCHEMA(child, "attribute")) ||
(IS_SCHEMA(child, "attributeGroup"))) {
attr = NULL;
if (IS_SCHEMA(child, "attribute")) {
attr = xmlSchemaParseAttribute(ctxt, schema, child, 0);
} else if (IS_SCHEMA(child, "attributeGroup")) {
attr = (xmlSchemaAttributePtr)
xmlSchemaParseAttributeGroup(ctxt, schema, child, 0);
}
if (attr != NULL) {
if (lastattr == NULL) {
if (type->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP)
((xmlSchemaAttributeGroupPtr) type)->attributes = attr;
else
type->attributes = attr;
lastattr = attr;
} else {
lastattr->next = attr;
lastattr = attr;
}
}
child = child->next;
}
return (child);
}
static xmlSchemaAnnotPtr
xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaAnnotPtr ret;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
int barked = 0;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
ret = xmlSchemaNewAnnot(ctxt, node);
attr = node->properties;
while (attr != NULL) {
if (((attr->ns == NULL) &&
(!xmlStrEqual(attr->name, BAD_CAST "id"))) ||
((attr->ns != NULL) &&
xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
child = node->children;
while (child != NULL) {
if (IS_SCHEMA(child, "appinfo")) {
attr = child->properties;
while (attr != NULL) {
if (((attr->ns == NULL) &&
(!xmlStrEqual(attr->name, BAD_CAST "source"))) ||
((attr->ns != NULL) &&
xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
xmlSchemaPValAttr(ctxt, NULL, NULL, child, "source",
xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
child = child->next;
} else if (IS_SCHEMA(child, "documentation")) {
attr = child->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if (!xmlStrEqual(attr->name, BAD_CAST "source")) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else {
if (xmlStrEqual(attr->ns->href, xmlSchemaNs) ||
(xmlStrEqual(attr->name, BAD_CAST "lang") &&
(!xmlStrEqual(attr->ns->href, XML_XML_NAMESPACE)))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
}
attr = attr->next;
}
attr = xmlSchemaGetPropNodeNs(child, (const char *) XML_XML_NAMESPACE, "lang");
if (attr != NULL)
xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_LANGUAGE), NULL);
child = child->next;
} else {
if (!barked)
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
NULL, NULL, node, child, NULL, "(appinfo | documentation)*");
barked = 1;
child = child->next;
}
}
return (ret);
}
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;
if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
(facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
const xmlChar *fixed;
fixed = xmlSchemaGetProp(ctxt, node, "fixed");
if (fixed != NULL) {
if (xmlStrEqual(fixed, BAD_CAST "true"))
facet->fixed = 1;
}
}
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
facet->annot = xmlSchemaParseAnnotation(ctxt, 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);
}
static int
xmlSchemaParseWildcardNs(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlSchemaWildcardPtr wildc,
xmlNodePtr node)
{
const xmlChar *pc, *ns, *dictnsItem;
int ret = 0;
xmlChar *nsItem;
xmlSchemaWildcardNsPtr tmp, lastNs = NULL;
xmlAttrPtr attr;
pc = xmlSchemaGetProp(ctxt, node, "processContents");
if ((pc == NULL)
|| (xmlStrEqual(pc, (const xmlChar *) "strict"))) {
wildc->processContents = XML_SCHEMAS_ANY_STRICT;
} else if (xmlStrEqual(pc, (const xmlChar *) "skip")) {
wildc->processContents = XML_SCHEMAS_ANY_SKIP;
} else if (xmlStrEqual(pc, (const xmlChar *) "lax")) {
wildc->processContents = XML_SCHEMAS_ANY_LAX;
} else {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
NULL, NULL, node,
NULL, "(strict | skip | lax)", pc,
NULL, NULL, NULL);
wildc->processContents = XML_SCHEMAS_ANY_STRICT;
ret = XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD;
}
attr = xmlSchemaGetPropNode(node, "namespace");
ns = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if ((ns == NULL) || (xmlStrEqual(ns, BAD_CAST "##any")))
wildc->any = 1;
else if (xmlStrEqual(ns, BAD_CAST "##other")) {
wildc->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
if (wildc->negNsSet == NULL) {
return (-1);
}
wildc->negNsSet->value = schema->targetNamespace;
} else {
const xmlChar *end, *cur;
cur = ns;
do {
while (IS_BLANK_CH(*cur))
cur++;
end = cur;
while ((*end != 0) && (!(IS_BLANK_CH(*end))))
end++;
if (end == cur)
break;
nsItem = xmlStrndup(cur, end - cur);
if ((xmlStrEqual(nsItem, BAD_CAST "##other")) ||
(xmlStrEqual(nsItem, BAD_CAST "##any"))) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
NULL, NULL, (xmlNodePtr) attr,
NULL,
"((##any | ##other) | List of (anyURI | "
"(##targetNamespace | ##local)))",
nsItem, NULL, NULL, NULL);
ret = XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER;
} else {
if (xmlStrEqual(nsItem, BAD_CAST "##targetNamespace")) {
dictnsItem = schema->targetNamespace;
} else if (xmlStrEqual(nsItem, BAD_CAST "##local")) {
dictnsItem = NULL;
} else {
xmlSchemaPValAttrNodeValue(ctxt, NULL, NULL, attr,
nsItem, xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI));
dictnsItem = xmlDictLookup(ctxt->dict, nsItem, -1);
}
tmp = wildc->nsSet;
while (tmp != NULL) {
if (dictnsItem == tmp->value)
break;
tmp = tmp->next;
}
if (tmp == NULL) {
tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
if (tmp == NULL) {
xmlFree(nsItem);
return (-1);
}
tmp->value = dictnsItem;
tmp->next = NULL;
if (wildc->nsSet == NULL)
wildc->nsSet = tmp;
else
lastNs->next = tmp;
lastNs = tmp;
}
}
xmlFree(nsItem);
cur = end;
} while (*cur != 0);
}
return (ret);
}
static int
xmlSchemaPCheckParticleCorrect_2(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr item,
xmlNodePtr node,
int minOccurs,
int maxOccurs) {
if (maxOccurs != UNBOUNDED) {
if (maxOccurs < 1) {
xmlSchemaPCustomAttrErr(ctxt,
XML_SCHEMAP_P_PROPS_CORRECT_2_2,
NULL, item, xmlSchemaGetPropNode(node, "maxOccurs"),
"The value must be greater than or equal to 1");
return (XML_SCHEMAP_P_PROPS_CORRECT_2_2);
} else if (minOccurs > maxOccurs) {
xmlSchemaPCustomAttrErr(ctxt,
XML_SCHEMAP_P_PROPS_CORRECT_2_1,
NULL, item, xmlSchemaGetPropNode(node, "minOccurs"),
"The value must not be greater than the value of 'maxOccurs'");
return (XML_SCHEMAP_P_PROPS_CORRECT_2_1);
}
}
return (0);
}
static xmlSchemaTypePtr
xmlSchemaParseAny(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlSchemaWildcardPtr wildc;
int minOccurs, maxOccurs;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
"(nonNegativeInteger | unbounded)");
minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1,
"nonNegativeInteger");
if ((minOccurs == 0) && (maxOccurs == 0))
return (NULL);
snprintf((char *) name, 30, "any %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_ANY;
wildc = xmlSchemaAddWildcard(ctxt);
type->maxOccurs = maxOccurs;
type->minOccurs = minOccurs;
xmlSchemaPCheckParticleCorrect_2(ctxt, type,
node, type->minOccurs, type->maxOccurs);
type->attributeWildcard = wildc;
xmlSchemaParseWildcardNs(ctxt, schema, wildc, node);
child = node->children;
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);
}
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);
}
static xmlSchemaWildcardPtr
xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node)
{
xmlSchemaWildcardPtr ret;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
ret = xmlSchemaAddWildcard(ctxt);
if (ret == NULL) {
return (NULL);
}
ret->type = XML_SCHEMA_TYPE_ANY_ATTRIBUTE;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
(!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
if (xmlSchemaParseWildcardNs(ctxt, schema, ret, node) != 0) {
xmlSchemaFreeWildcard(ret);
return (NULL);
}
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
NULL, NULL, node, child,
NULL, "(annotation?)");
}
return (ret);
}
static xmlSchemaAttributePtr
xmlSchemaParseAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int topLevel)
{
const xmlChar *name, *attrValue;
xmlChar *repName = NULL;
xmlSchemaAttributePtr ret;
xmlNodePtr child = NULL;
xmlAttrPtr attr, nameAttr;
int isRef = 0;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
attr = xmlSchemaGetPropNode(node, "ref");
nameAttr = xmlSchemaGetPropNode(node, "name");
if ((attr == NULL) && (nameAttr == NULL)) {
xmlSchemaPMissingAttrErr(ctxt, XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
(xmlChar **) &xmlSchemaElemDesAttrDecl, NULL, node, NULL,
"One of the attributes 'ref' or 'name' must be present");
return (NULL);
}
if ((topLevel) || (attr == NULL)) {
if (nameAttr == NULL) {
xmlSchemaPMissingAttrErr(ctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
(xmlChar **) &xmlSchemaElemDesAttrDecl, NULL, node,
"name", NULL);
return (NULL);
}
} else
isRef = 1;
if (isRef) {
char buf[50];
const xmlChar *refNs = NULL, *ref = NULL, *refPrefix = NULL;
if (xmlSchemaPValAttrNodeQName(ctxt, schema,
(xmlChar **) &xmlSchemaElemDesAttrRef, NULL, attr, &refNs,
&refPrefix, &ref) != 0) {
return (NULL);
}
snprintf(buf, 49, "#aRef %d", ctxt->counter++ + 1);
name = (const xmlChar *) buf;
ret = xmlSchemaAddAttribute(ctxt, schema, name, NULL, node);
if (ret == NULL) {
if (repName != NULL)
xmlFree(repName);
return (NULL);
}
ret->type = XML_SCHEMA_TYPE_ATTRIBUTE;
ret->node = node;
ret->refNs = refNs;
ret->refPrefix = refPrefix;
ret->ref = ref;
if (nameAttr != NULL)
xmlSchemaPMutualExclAttrErr(ctxt, XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
&repName, (xmlSchemaTypePtr) ret, nameAttr,
"ref", "name");
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if (xmlStrEqual(attr->name, BAD_CAST "type") ||
xmlStrEqual(attr->name, BAD_CAST "form")) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_SRC_ATTRIBUTE_3_2, &repName,
(xmlSchemaTypePtr) ret, attr);
} else if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
(!xmlStrEqual(attr->name, BAD_CAST "use")) &&
(!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "name")) &&
(!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
(!xmlStrEqual(attr->name, BAD_CAST "default"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
attr = attr->next;
}
} else {
const xmlChar *ns = NULL;
if (xmlSchemaPValAttrNode(ctxt,
(xmlChar **) &xmlSchemaElemDesAttrDecl, NULL, nameAttr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
return (NULL);
}
if (xmlStrEqual(name, BAD_CAST "xmlns")) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_NO_XMLNS,
&repName, NULL, (xmlNodePtr) nameAttr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), "NCName", NULL,
"The value must not match 'xmlns'",
NULL, NULL);
if (repName != NULL)
xmlFree(repName);
return (NULL);
}
if (topLevel) {
ns = schema->targetNamespace;
} else {
attr = xmlSchemaGetPropNode(node, "form");
if (attr != NULL) {
attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
ns = schema->targetNamespace;
} else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified")) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&repName, NULL, (xmlNodePtr) attr,
NULL, "(qualified | unqualified)",
attrValue, NULL, NULL, NULL);
}
} else if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
ns = schema->targetNamespace;
}
ret = xmlSchemaAddAttribute(ctxt, schema, name, ns, node);
if (ret == NULL) {
if (repName != NULL)
xmlFree(repName);
return (NULL);
}
ret->type = XML_SCHEMA_TYPE_ATTRIBUTE;
ret->node = node;
if (topLevel)
ret->flags |= XML_SCHEMAS_ATTR_GLOBAL;
if (xmlStrEqual(ret->targetNamespace, xmlSchemaInstanceNs)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_NO_XSI,
&repName, (xmlSchemaTypePtr) ret, node,
"The target namespace must not match '%s'",
xmlSchemaInstanceNs);
}
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "default")) &&
(!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
(!xmlStrEqual(attr->name, BAD_CAST "name")) &&
(!xmlStrEqual(attr->name, BAD_CAST "type"))) {
if ((topLevel) ||
((!xmlStrEqual(attr->name, BAD_CAST "form")) &&
(!xmlStrEqual(attr->name, BAD_CAST "use")))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt, XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
attr = attr->next;
}
xmlSchemaPValAttrQName(ctxt, schema, &repName, (xmlSchemaTypePtr) ret,
node, "type", &ret->typeNs, NULL, &ret->typeName);
}
ret->id = xmlSchemaGetProp(ctxt, node, "id");
ret->defValue = xmlSchemaGetProp(ctxt, node, "fixed");
if (ret->defValue != NULL)
ret->flags |= XML_SCHEMAS_ATTR_FIXED;
attr = xmlSchemaGetPropNode(node, "default");
if (attr != NULL) {
if (ret->flags & XML_SCHEMAS_ATTR_FIXED) {
xmlSchemaPMutualExclAttrErr(ctxt, XML_SCHEMAP_SRC_ATTRIBUTE_1,
&repName, (xmlSchemaTypePtr) ret, attr, "default", "fixed");
} else
ret->defValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
}
if (topLevel == 0) {
attr = xmlSchemaGetPropNode(node, "use");
if (attr != NULL) {
attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlStrEqual(attrValue, BAD_CAST "optional"))
ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
else if (xmlStrEqual(attrValue, BAD_CAST "prohibited"))
ret->occurs = XML_SCHEMAS_ATTR_USE_PROHIBITED;
else if (xmlStrEqual(attrValue, BAD_CAST "required"))
ret->occurs = XML_SCHEMAS_ATTR_USE_REQUIRED;
else
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_INVALID_ATTR_USE,
&repName, (xmlSchemaTypePtr) ret, (xmlNodePtr) attr,
NULL, "(optional | prohibited | required)",
attrValue, NULL, NULL, NULL);
} else
ret->occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
if ((ret->occurs != XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
(ret->defValue != NULL) &&
((ret->flags & XML_SCHEMAS_ATTR_FIXED) == 0)) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_SRC_ATTRIBUTE_2,
&repName, (xmlSchemaTypePtr) ret, (xmlNodePtr) attr,
NULL, "(optional | prohibited | required)", NULL,
"The value must be 'optional' if the attribute "
"'default' is present as well", NULL, NULL);
}
}
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
if (isRef) {
if (child != NULL) {
if (IS_SCHEMA(child, "simpleType"))
xmlSchemaPContentErr(ctxt, XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
&repName, (xmlSchemaTypePtr) ret, node, child, NULL,
"(annotation?)");
else
xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, node, child, NULL,
"(annotation?)");
}
} else {
if (IS_SCHEMA(child, "simpleType")) {
if (ret->typeName != NULL) {
xmlSchemaPContentErr(ctxt, XML_SCHEMAP_SRC_ATTRIBUTE_4,
&repName, (xmlSchemaTypePtr) ret, node, child,
"The attribute 'type' and the <simpleType> child "
"are mutually exclusive", NULL);
} else
ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
child = child->next;
}
if (child != NULL)
xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, node, child, NULL,
"(annotation?, simpleType?)");
}
if (repName != NULL)
xmlFree(repName);
return (ret);
}
static xmlSchemaAttributeGroupPtr
xmlSchemaParseAttributeGroup(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node,
int topLevel)
{
const xmlChar *name;
xmlSchemaAttributeGroupPtr ret;
xmlNodePtr child = NULL;
const xmlChar *oldcontainer;
xmlAttrPtr attr, nameAttr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
nameAttr = xmlSchemaGetPropNode(node, "name");
attr = xmlSchemaGetPropNode(node, "ref");
if ((topLevel) || (attr == NULL)) {
if (nameAttr == NULL) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_MISSING,
NULL, NULL, node, "name", NULL);
return (NULL);
}
name = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) nameAttr);
if (xmlSchemaPValAttrNode(ctxt,
NULL, NULL, nameAttr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
return (NULL);
}
ret = xmlSchemaAddAttributeGroup(ctxt, schema, name, node);
if (ret == NULL)
return (NULL);
ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
ret->flags |= XML_SCHEMAS_ATTRGROUP_GLOBAL;
ret->node = node;
} else {
char buf[50];
const xmlChar *refNs = NULL, *ref = NULL, *refPrefix;
if (attr == NULL) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_MISSING,
NULL, NULL, node, "ref", NULL);
}
xmlSchemaPValAttrNodeQName(ctxt, schema,
NULL, NULL, attr, &refNs, &refPrefix, &ref);
snprintf(buf, 49, "#aGrRef %d", ctxt->counter++ + 1);
name = (const xmlChar *) buf;
if (name == NULL) {
xmlSchemaPErrMemory(ctxt, "creating internal name for an "
"attribute group definition reference", node);
return (NULL);
}
ret = xmlSchemaAddAttributeGroup(ctxt, schema, name, node);
if (ret == NULL)
return (NULL);
ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
ret->ref = ref;
ret->refNs = refNs;
ret->refPrefix = refPrefix;
ret->node = node;
}
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((((topLevel == 0) && (!xmlStrEqual(attr->name, BAD_CAST "ref"))) ||
(topLevel && (!xmlStrEqual(attr->name, BAD_CAST "name")))) &&
(!xmlStrEqual(attr->name, BAD_CAST "id")))
{
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
oldcontainer = ctxt->container;
ctxt->container = name;
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
if (topLevel) {
child = xmlSchemaParseAttrDecls(ctxt, schema, child, (xmlSchemaTypePtr) ret);
if (IS_SCHEMA(child, "anyAttribute")) {
ret->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
child = child->next;
}
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
NULL, NULL, node, child, NULL,
"(annotation?)");
}
ctxt->container = oldcontainer;
return (ret);
}
static int
xmlSchemaPValAttrFormDefault(const xmlChar *value,
int *flags,
int flagQualified)
{
if (xmlStrEqual(value, BAD_CAST "qualified")) {
if ((*flags & flagQualified) == 0)
*flags |= flagQualified;
} else if (!xmlStrEqual(value, BAD_CAST "unqualified"))
return (1);
return (0);
}
static int
xmlSchemaPValAttrBlockFinal(const xmlChar *value,
int *flags,
int flagAll,
int flagExtension,
int flagRestriction,
int flagSubstitution,
int flagList,
int flagUnion)
{
int ret = 0;
if (value == NULL)
return (1);
if (xmlStrEqual(value, BAD_CAST "#all")) {
if (flagAll != -1)
*flags |= flagAll;
else {
if (flagExtension != -1)
*flags |= flagExtension;
if (flagRestriction != -1)
*flags |= flagRestriction;
if (flagSubstitution != -1)
*flags |= flagSubstitution;
if (flagList != -1)
*flags |= flagList;
if (flagUnion != -1)
*flags |= flagUnion;
}
} else {
const xmlChar *end, *cur = value;
xmlChar *item;
do {
while (IS_BLANK_CH(*cur))
cur++;
end = cur;
while ((*end != 0) && (!(IS_BLANK_CH(*end))))
end++;
if (end == cur)
break;
item = xmlStrndup(cur, end - cur);
if (xmlStrEqual(item, BAD_CAST "extension")) {
if (flagExtension != -1) {
if ((*flags & flagExtension) == 0)
*flags |= flagExtension;
} else
ret = 1;
} else if (xmlStrEqual(item, BAD_CAST "restriction")) {
if (flagRestriction != -1) {
if ((*flags & flagRestriction) == 0)
*flags |= flagRestriction;
} else
ret = 1;
} else if (xmlStrEqual(item, BAD_CAST "substitution")) {
if (flagSubstitution != -1) {
if ((*flags & flagSubstitution) == 0)
*flags |= flagSubstitution;
} else
ret = 1;
} else if (xmlStrEqual(item, BAD_CAST "list")) {
if (flagList != -1) {
if ((*flags & flagList) == 0)
*flags |= flagList;
} else
ret = 1;
} else if (xmlStrEqual(item, BAD_CAST "union")) {
if (flagUnion != -1) {
if ((*flags & flagUnion) == 0)
*flags |= flagUnion;
} else
ret = 1;
} else
ret = 1;
if (item != NULL)
xmlFree(item);
cur = end;
} while ((ret == 0) && (*cur != 0));
}
return (ret);
}
static xmlSchemaElementPtr
xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int topLevel)
{
const xmlChar *name = NULL;
const xmlChar *attrValue;
xmlChar *repName = NULL;
xmlSchemaElementPtr ret;
xmlNodePtr child = NULL;
const xmlChar *oldcontainer;
xmlAttrPtr attr, nameAttr;
int minOccurs, maxOccurs;
int isRef = 0;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
oldcontainer = ctxt->container;
nameAttr = xmlSchemaGetPropNode(node, "name");
attr = xmlSchemaGetPropNode(node, "ref");
if ((topLevel) || (attr == NULL)) {
if (nameAttr == NULL) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_MISSING,
(xmlChar **) &xmlSchemaElemDesElemDecl, NULL, node,
"name", NULL);
return (NULL);
}
name = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) nameAttr);
} else {
isRef = 1;
}
minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger");
maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(nonNegativeInteger | unbounded)");
if ((minOccurs == 0) && (maxOccurs == 0))
return (NULL);
if (isRef) {
char buf[50];
const xmlChar *refNs = NULL, *ref = NULL, *refPrefix;
xmlSchemaPValAttrNodeQName(ctxt, schema,
(xmlChar **) &xmlSchemaElemDesAttrRef,
NULL, attr, &refNs, &refPrefix, &ref);
snprintf(buf, 49, "#eRef %d", ctxt->counter++ + 1);
name = (const xmlChar *) buf;
ret = xmlSchemaAddElement(ctxt, schema, name, NULL, node, 0);
if (ret == NULL) {
if (repName != NULL)
xmlFree(repName);
return (NULL);
}
ret->type = XML_SCHEMA_TYPE_ELEMENT;
ret->node = node;
ret->ref = ref;
ret->refNs = refNs;
ret->refPrefix = refPrefix;
ret->flags |= XML_SCHEMAS_ELEM_REF;
if (nameAttr != NULL) {
xmlSchemaPMutualExclAttrErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_2_1,
&repName, (xmlSchemaTypePtr) ret, nameAttr,
"ref", "name");
}
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if (xmlStrEqual(attr->name, BAD_CAST "ref") ||
xmlStrEqual(attr->name, BAD_CAST "name") ||
xmlStrEqual(attr->name, BAD_CAST "id") ||
xmlStrEqual(attr->name, BAD_CAST "maxOccurs") ||
xmlStrEqual(attr->name, BAD_CAST "minOccurs"))
{
attr = attr->next;
continue;
} else {
xmlSchemaPCustomAttrErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_2_2,
&repName, (xmlSchemaTypePtr) ret, attr,
"Only the attributes 'minOccurs', 'maxOccurs' and "
"'id' are allowed in addition to 'ref'");
break;
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
attr = attr->next;
}
} else {
const xmlChar *ns = NULL, *fixed;
if (xmlSchemaPValAttrNode(ctxt,
(xmlChar **) &xmlSchemaElemDesElemDecl, NULL, nameAttr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0)
return (NULL);
if (topLevel) {
ns = schema->targetNamespace;
} else {
attr = xmlSchemaGetPropNode(node, "form");
if (attr != NULL) {
attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
ns = schema->targetNamespace;
} else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified")) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&repName, NULL, (xmlNodePtr) attr,
NULL, "(qualified | unqualified)",
attrValue, NULL, NULL, NULL);
}
} else if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
ns = schema->targetNamespace;
}
ret = xmlSchemaAddElement(ctxt, schema, name, ns, node, topLevel);
if (ret == NULL) {
if (repName != NULL)
xmlFree(repName);
return (NULL);
}
ret->type = XML_SCHEMA_TYPE_ELEMENT;
ret->node = node;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
(!xmlStrEqual(attr->name, BAD_CAST "type")) &&
(!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "default")) &&
(!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
(!xmlStrEqual(attr->name, BAD_CAST "block")) &&
(!xmlStrEqual(attr->name, BAD_CAST "nillable")))
{
if (topLevel == 0) {
if ((!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
(!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
(!xmlStrEqual(attr->name, BAD_CAST "form")))
{
if (xmlStrEqual(attr->name, BAD_CAST "substitutionGroup")) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_E_PROPS_CORRECT_3,
&repName, (xmlSchemaTypePtr) ret, attr);
} else {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
}
} else if ((!xmlStrEqual(attr->name, BAD_CAST "final")) &&
(!xmlStrEqual(attr->name, BAD_CAST "abstract")) &&
(!xmlStrEqual(attr->name, BAD_CAST "substitutionGroup"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, attr);
}
attr = attr->next;
}
if (topLevel) {
ret->flags |= XML_SCHEMAS_ELEM_GLOBAL;
ret->flags |= XML_SCHEMAS_ELEM_TOPLEVEL;
xmlSchemaPValAttrQName(ctxt, schema, &repName,
(xmlSchemaTypePtr) ret, node, "substitutionGroup",
&(ret->substGroupNs), NULL, &(ret->substGroup));
if (xmlGetBooleanProp(ctxt, &repName, (xmlSchemaTypePtr) ret,
node, "abstract", 0))
ret->flags |= XML_SCHEMAS_ELEM_ABSTRACT;
attr = xmlSchemaGetPropNode(node, "final");
if (attr == NULL) {
ret->flags |= XML_SCHEMAS_ELEM_FINAL_ABSENT;
} else {
attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(attrValue, &(ret->flags),
-1,
XML_SCHEMAS_ELEM_FINAL_EXTENSION,
XML_SCHEMAS_ELEM_FINAL_RESTRICTION, -1, -1, -1) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&repName, (xmlSchemaTypePtr) ret, (xmlNodePtr) attr,
NULL, "(#all | List of (extension | restriction))",
attrValue, NULL, NULL, NULL);
}
}
}
attr = xmlSchemaGetPropNode(node, "block");
if (attr == NULL) {
ret->flags |= XML_SCHEMAS_ELEM_BLOCK_ABSENT;
} else {
attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(attrValue, &(ret->flags),
-1,
XML_SCHEMAS_ELEM_BLOCK_EXTENSION,
XML_SCHEMAS_ELEM_BLOCK_RESTRICTION,
XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION, -1, -1) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&repName, (xmlSchemaTypePtr) ret, (xmlNodePtr) attr,
NULL, "(#all | List of (extension | "
"restriction | substitution))", attrValue,
NULL, NULL, NULL);
}
}
if (xmlGetBooleanProp(ctxt, &repName, (xmlSchemaTypePtr) ret,
node, "nillable", 0))
ret->flags |= XML_SCHEMAS_ELEM_NILLABLE;
xmlSchemaPValAttrQName(ctxt, schema,
&repName, (xmlSchemaTypePtr) ret, node,
"type", &(ret->namedTypeNs), NULL, &(ret->namedType));
ret->value = xmlSchemaGetProp(ctxt, node, "default");
attr = xmlSchemaGetPropNode(node, "fixed");
if (attr != NULL) {
fixed = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (ret->value != NULL) {
xmlSchemaPMutualExclAttrErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_1,
&repName, (xmlSchemaTypePtr) ret, attr,
"default", "fixed");
} else {
ret->flags |= XML_SCHEMAS_ELEM_FIXED;
ret->value = fixed;
}
}
}
ret->id = xmlSchemaGetProp(ctxt, node, "id");
ret->minOccurs = minOccurs;
ret->maxOccurs = maxOccurs;
if (topLevel != 1)
xmlSchemaPCheckParticleCorrect_2(ctxt, (xmlSchemaTypePtr) ret,
node, minOccurs, maxOccurs);
ctxt->container = name;
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
ret->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
if (isRef) {
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_2_2,
&repName, (xmlSchemaTypePtr) ret, node, child,
NULL, "(annotation?)");
}
} else {
if (IS_SCHEMA(child, "complexType")) {
if (ret->namedType != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_3,
&repName, (xmlSchemaTypePtr) ret, node, child,
"The attribute 'type' and the <complexType> child are "
"mutually exclusive", NULL);
} else
ret->subtypes = xmlSchemaParseComplexType(ctxt, schema, child, 0);
child = child->next;
} else if (IS_SCHEMA(child, "simpleType")) {
if (ret->namedType != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_SRC_ELEMENT_3,
&repName, (xmlSchemaTypePtr) ret, node, child,
"The attribute 'type' and the <simpleType> child are "
"mutually exclusive", NULL);
} else
ret->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
child = child->next;
}
while ((IS_SCHEMA(child, "unique")) ||
(IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
TODO child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
&repName, (xmlSchemaTypePtr) ret, node, child,
NULL, "(annotation?, ((simpleType | complexType)?, "
"(unique | key | keyref)*))");
}
}
ctxt->container = oldcontainer;
if (repName != NULL)
xmlFree(repName);
return (ret);
}
static xmlSchemaTypePtr
xmlSchemaParseUnion(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype, last = NULL;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
snprintf((char *) name, 30, "#union %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->type = XML_SCHEMA_TYPE_UNION;
type->node = node;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "memberTypes"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
attr = attr->next;
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
type->base = 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, 0);
if (subtype != NULL) {
if (last == NULL) {
type->subtypes = subtype;
last = subtype;
} else {
last->next = subtype;
last = subtype;
}
last->next = NULL;
}
child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_UNION_CHILD,
NULL, type, node, child, NULL, "(annotation?, simpleType*)");
}
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
snprintf((char *) name, 30, "#list %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_LIST;
type->id = xmlSchemaGetProp(ctxt, node, "id");
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "itemType"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
attr = attr->next;
}
xmlSchemaPValAttrQName(ctxt, schema, NULL, NULL,
node, "itemType", &(type->baseNs), NULL, &(type->base));
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
subtype = NULL;
if (IS_SCHEMA(child, "simpleType")) {
if (type->base != NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
NULL, type, node,
"The attribute 'itemType' and the <simpleType> child "
"are mutually exclusive", NULL);
} else {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseSimpleType(ctxt, schema, child, 0);
type->subtypes = subtype;
}
child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_LIST_CHILD,
NULL, type, node, child, NULL, "(annotation?, simpleType?)");
}
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int topLevel)
{
xmlSchemaTypePtr type, subtype, oldCtxtType, oldParentItem;
xmlNodePtr child = NULL;
const xmlChar *attrValue = NULL;
xmlChar *des = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
if (topLevel) {
attr = xmlSchemaGetPropNode(node, "name");
if (attr == NULL) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_MISSING,
(xmlChar **) &xmlSchemaElemDesST, NULL, node,
"name", NULL);
return (NULL);
} else if (xmlSchemaPValAttrNode(ctxt,
(xmlChar **) &xmlSchemaElemDesST, NULL, attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &attrValue) != 0) {
return (NULL);
}
}
if (topLevel == 0) {
char buf[40];
snprintf(buf, 39, "#ST %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, (const xmlChar *)buf, NULL, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_SIMPLE;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
attr = attr->next;
}
} else {
type = xmlSchemaAddType(ctxt, schema, attrValue, schema->targetNamespace, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_SIMPLE;
type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "name")) &&
(!xmlStrEqual(attr->name, BAD_CAST "final"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
attr = attr->next;
}
attr = xmlSchemaGetPropNode(node, "final");
if (attr == NULL) {
type->flags |= XML_SCHEMAS_TYPE_FINAL_DEFAULT;
} else {
attrValue = xmlSchemaGetProp(ctxt, node, "final");
if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
-1, -1, XML_SCHEMAS_TYPE_FINAL_RESTRICTION, -1,
XML_SCHEMAS_TYPE_FINAL_LIST,
XML_SCHEMAS_TYPE_FINAL_UNION) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&des, type, (xmlNodePtr) attr,
NULL, "(#all | List of (list | union | restriction)",
attrValue, NULL, NULL, NULL);
}
}
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
oldCtxtType = ctxt->ctxtType;
oldParentItem = ctxt->parentItem;
ctxt->ctxtType = type;
ctxt->parentItem = type;
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);
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) || (subtype == NULL)) {
xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
&des, type, node, child, NULL,
"(annotation?, (restriction | list | union))");
}
ctxt->parentItem = oldParentItem;
ctxt->ctxtType = oldCtxtType;
FREE_AND_NULL(des)
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int topLevel)
{
xmlSchemaTypePtr type, subtype;
xmlNodePtr child = NULL;
const xmlChar *name;
const xmlChar *ref = NULL, *refNs = NULL;
char buf[100];
int minOccurs, maxOccurs;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger");
maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(nonNegativeInteger | unbounded)");
if ((minOccurs == 0) && (maxOccurs == 0)) {
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 definition or particle: One of the attributes \"name\" "
"or \"ref\" must be present.\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, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_GROUP;
if (topLevel)
type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
type->id = xmlSchemaGetProp(ctxt, node, "id");
type->ref = ref;
type->refNs = refNs;
type->minOccurs = minOccurs;
type->maxOccurs = maxOccurs;
xmlSchemaPCheckParticleCorrect_2(ctxt, type,
node, type->minOccurs, type->maxOccurs);
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 definition \"%s\" has unexpected content.\n", type->name,
NULL);
}
return (type);
}
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, node);
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, 0, 1, 1, "(0 | 1)");
type->maxOccurs = xmlGetMaxOccurs(ctxt, node, 1, 1, 1, "1");
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> has unexpected content.\n", type->name,
NULL);
}
return (type);
}
static void
xmlSchemaCleanupDoc(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr root)
{
xmlNodePtr delete, cur;
if ((ctxt == NULL) || (root == NULL)) return;
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;
}
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;
}
}
#if 0
static xmlSchemaImportPtr
xmlSchemaImportSchema(xmlSchemaParserCtxtPtr ctxt,
const xmlChar *schemaLocation)
{
xmlSchemaImportPtr import;
xmlSchemaParserCtxtPtr newctxt;
newctxt = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
if (newctxt == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating schema parser context",
NULL);
return (NULL);
}
memset(newctxt, 0, sizeof(xmlSchemaParserCtxt));
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) {
xmlSchemaPErr(ctxt, NULL, XML_SCHEMAP_INTERNAL,
"Failed to import schema from location \"%s\".\n",
schemaLocation, NULL);
xmlSchemaFreeParserCtxt(newctxt);
xmlFree(import);
return NULL;
}
xmlSchemaFreeParserCtxt(newctxt);
return import;
}
#endif
static void
xmlSchemaClearSchemaDefaults(xmlSchemaPtr schema)
{
if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
schema->flags ^= XML_SCHEMAS_QUALIF_ELEM;
if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
schema->flags ^= XML_SCHEMAS_QUALIF_ATTR;
if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_EXTENSION;
if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION;
if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_LIST)
schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_LIST;
if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_UNION)
schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_UNION;
if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION;
if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION;
if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION)
schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION;
}
static void
xmlSchemaParseSchemaDefaults(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlAttrPtr attr;
const xmlChar *val;
attr = xmlSchemaGetPropNode(node, "elementFormDefault");
if (attr != NULL) {
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrFormDefault(val, &schema->flags,
XML_SCHEMAS_QUALIF_ELEM) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL,
"(qualified | unqualified)", val, NULL, NULL, NULL);
}
}
attr = xmlSchemaGetPropNode(node, "attributeFormDefault");
if (attr != NULL) {
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrFormDefault(val, &schema->flags,
XML_SCHEMAS_QUALIF_ATTR) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL,
"(qualified | unqualified)", val, NULL, NULL, NULL);
}
}
attr = xmlSchemaGetPropNode(node, "finalDefault");
if (attr != NULL) {
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
XML_SCHEMAS_FINAL_DEFAULT_EXTENSION,
XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION,
-1,
XML_SCHEMAS_FINAL_DEFAULT_LIST,
XML_SCHEMAS_FINAL_DEFAULT_UNION) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL,
"(#all | List of (extension | restriction | list | union))",
val, NULL, NULL, NULL);
}
}
attr = xmlSchemaGetPropNode(node, "blockDefault");
if (attr != NULL) {
val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION,
XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION,
XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION, -1, -1) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
NULL, NULL, (xmlNodePtr) attr, NULL,
"(#all | List of (extension | restriction | substitution))",
val, NULL, NULL, NULL);
}
}
}
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, 1);
child = child->next;
} else if (IS_SCHEMA(child, "simpleType")) {
xmlSchemaParseSimpleType(ctxt, schema, child, 1);
child = child->next;
} else if (IS_SCHEMA(child, "element")) {
xmlSchemaParseElement(ctxt, schema, child, 1);
child = child->next;
} else if (IS_SCHEMA(child, "attribute")) {
xmlSchemaParseAttribute(ctxt, schema, child, 1);
child = child->next;
} else if (IS_SCHEMA(child, "attributeGroup")) {
xmlSchemaParseAttributeGroup(ctxt, schema, child, 1);
child = child->next;
} else if (IS_SCHEMA(child, "group")) {
xmlSchemaParseGroup(ctxt, schema, child, 1);
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,
"Unexpected element \"%s\" as child of <schema>.\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;
}
}
ctxt->parentItem = NULL;
ctxt->ctxtType = NULL;
}
static xmlSchemaImportPtr
xmlSchemaAddImport(xmlSchemaParserCtxtPtr ctxt,
xmlHashTablePtr *imports,
const xmlChar *nsName)
{
xmlSchemaImportPtr ret;
if (*imports == NULL) {
*imports = xmlHashCreate(10);
if (*imports == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_FAILED_BUILD_IMPORT,
NULL, NULL, (xmlNodePtr) ctxt->doc,
"Internal error: failed to build the import table",
NULL);
return (NULL);
}
}
ret = (xmlSchemaImport*) xmlMalloc(sizeof(xmlSchemaImport));
if (ret == NULL) {
xmlSchemaPErrMemory(NULL, "allocating import struct", NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaImport));
if (nsName == NULL)
nsName = XML_SCHEMAS_NO_NAMESPACE;
xmlHashAddEntry(*imports, nsName, ret);
return (ret);
}
static int
xmlSchemaAcquireSchemaDoc(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node,
const xmlChar *nsName,
const xmlChar *location,
xmlDocPtr *doc,
const xmlChar **targetNamespace,
int absolute)
{
xmlParserCtxtPtr parserCtxt;
xmlSchemaImportPtr import;
const xmlChar *ns;
xmlNodePtr root;
*doc = NULL;
if (location == NULL) {
return (0);
}
if (nsName == NULL)
ns = XML_SCHEMAS_NO_NAMESPACE;
else
ns = nsName;
import = xmlHashLookup(schema->schemasImports, ns);
if (import != NULL) {
return (0);
}
if ((absolute == 0) && (node != NULL)) {
xmlChar *base, *URI;
base = xmlNodeGetBase(node->doc, node);
if (base == NULL) {
URI = xmlBuildURI(location, node->doc->URL);
} else {
URI = xmlBuildURI(location, base);
xmlFree(base);
}
if (URI != NULL) {
location = xmlDictLookup(ctxt->dict, URI, -1);
xmlFree(URI);
}
}
parserCtxt = xmlNewParserCtxt();
if (parserCtxt == NULL) {
xmlSchemaPErrMemory(NULL, "xmlSchemaParseImport: "
"allocating a parser context", NULL);
return(-1);
}
*doc = xmlCtxtReadFile(parserCtxt, (const char *) location,
NULL, SCHEMAS_PARSE_OPTIONS);
if (*doc == NULL) {
xmlErrorPtr lerr;
lerr = xmlGetLastError();
if ((lerr != NULL) && (lerr->domain == XML_FROM_IO)) {
xmlFreeParserCtxt(parserCtxt);
return(0);
}
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_2_1,
NULL, NULL, node,
"Failed to parse the resource '%s' for import",
location);
xmlFreeParserCtxt(parserCtxt);
return(XML_SCHEMAP_SRC_IMPORT_2_1);
}
xmlFreeParserCtxt(parserCtxt);
root = xmlDocGetRootElement(*doc);
if (root == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_2_1,
NULL, NULL, node,
"The XML document '%s' to be imported has no document "
"element", location);
xmlFreeDoc(*doc);
*doc = NULL;
return (XML_SCHEMAP_SRC_IMPORT_2_1);
}
xmlSchemaCleanupDoc(ctxt, root);
if (!IS_SCHEMA(root, "schema")) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_2_1,
NULL, NULL, node,
"The XML document '%s' to be imported is not a XML schema document",
location);
xmlFreeDoc(*doc);
*doc = NULL;
return (XML_SCHEMAP_SRC_IMPORT_2_1);
}
*targetNamespace = xmlSchemaGetProp(ctxt, root, "targetNamespace");
if (nsName == NULL) {
if (*targetNamespace != NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_3_2,
NULL, NULL, node,
"The XML schema to be imported is not expected "
"to have a target namespace; this differs from "
"its target namespace of '%s'", *targetNamespace);
xmlFreeDoc(*doc);
*doc = NULL;
return (XML_SCHEMAP_SRC_IMPORT_3_2);
}
} else {
if (*targetNamespace == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_3_1,
NULL, NULL, node,
"The XML schema to be imported is expected to have a target "
"namespace of '%s'", nsName);
xmlFreeDoc(*doc);
*doc = NULL;
return (XML_SCHEMAP_SRC_IMPORT_3_1);
} else if (!xmlStrEqual(*targetNamespace, nsName)) {
xmlSchemaPCustomErrExt(ctxt,
XML_SCHEMAP_SRC_IMPORT_3_1,
NULL, NULL, node,
"The XML schema to be imported is expected to have a "
"target namespace of '%s'; this differs from "
"its target namespace of '%s'",
nsName, *targetNamespace, NULL);
xmlFreeDoc(*doc);
*doc = NULL;
return (XML_SCHEMAP_SRC_IMPORT_3_1);
}
}
import = xmlSchemaAddImport(ctxt, &(schema->schemasImports), nsName);
if (import == NULL) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_FAILED_BUILD_IMPORT,
NULL, NULL, NULL,
"Internal error: xmlSchemaAcquireSchemaDoc, "
"failed to build import table", NULL);
xmlFreeDoc(*doc);
*doc = NULL;
return (-1);
}
import->schemaLocation = location;
import->doc = *doc;
return (0);
}
static int
xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlNodePtr child;
const xmlChar *namespace = NULL;
const xmlChar *schemaLocation = NULL;
const xmlChar *targetNamespace, *oldTNS, *url;
xmlAttrPtr attr;
xmlDocPtr doc;
xmlNodePtr root;
int flags, ret = 0;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (-1);
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
(!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
if (xmlSchemaPValAttr(ctxt, NULL, NULL, node,
"namespace", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
&namespace) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
NULL, NULL, node,
xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
NULL, namespace, NULL, NULL, NULL);
return (XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI);
}
if (xmlSchemaPValAttr(ctxt, NULL, NULL, node,
"schemaLocation", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
&schemaLocation) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
NULL, NULL, node,
xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
NULL, namespace, NULL, NULL, NULL);
return (XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI);
}
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
NULL, NULL, node, child, NULL,
"(annotation?)");
}
if (namespace != NULL) {
if (xmlStrEqual(schema->targetNamespace, namespace)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_1_1,
NULL, NULL, node,
"The value of the attribute 'namespace' must not match "
"the target namespace '%s' of the importing schema",
schema->targetNamespace);
return (XML_SCHEMAP_SRC_IMPORT_1_1);
}
} else {
if (schema->targetNamespace == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_IMPORT_1_2,
NULL, NULL, node,
"The attribute 'namespace' must be existent if "
"the importing schema has no target namespace",
NULL);
return (XML_SCHEMAP_SRC_IMPORT_1_2);
}
}
ret = xmlSchemaAcquireSchemaDoc(ctxt, schema, node, namespace,
schemaLocation, &doc, &targetNamespace, 0);
if (ret != 0) {
if (doc != NULL)
xmlFreeDoc(doc);
return (ret);
} else if (doc != NULL) {
url = ctxt->URL;
ctxt->URL = doc->URL;
flags = schema->flags;
oldTNS = schema->targetNamespace;
root = xmlDocGetRootElement(doc);
xmlSchemaClearSchemaDefaults(schema);
xmlSchemaParseSchemaDefaults(ctxt, schema, root);
schema->targetNamespace = targetNamespace;
xmlSchemaParseSchemaTopLevel(ctxt, schema, root->children);
schema->flags = flags;
schema->targetNamespace = oldTNS;
ctxt->URL = url;
}
return (0);
}
static int
xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlNodePtr child = NULL;
const xmlChar *schemaLocation, *targetNamespace;
xmlDocPtr doc;
xmlNodePtr root;
xmlSchemaIncludePtr include;
int wasConvertingNs = 0;
xmlAttrPtr attr;
int saveFlags;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (-1);
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
attr = xmlSchemaGetPropNode(node, "schemaLocation");
if (attr != NULL) {
xmlChar *base = NULL;
xmlChar *uri = NULL;
if (xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), &schemaLocation) != 0)
return (-1);
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 {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
NULL, NULL, node, "schemaLocation", NULL);
return (-1);
}
child = node->children;
while (IS_SCHEMA(child, "annotation")) {
child = child->next;
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
NULL, NULL, node, child, NULL,
"(annotation?)");
}
doc = xmlReadFile((const char *) schemaLocation, NULL,
SCHEMAS_PARSE_OPTIONS);
if (doc == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_FAILED_LOAD,
NULL, NULL, node,
"Failed to load the document '%s' for inclusion", schemaLocation);
return(-1);
}
root = xmlDocGetRootElement(doc);
if (root == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_NOROOT,
NULL, NULL, node,
"The included document '%s' has no document "
"element", schemaLocation);
xmlFreeDoc(doc);
return (-1);
}
xmlSchemaCleanupDoc(ctxt, root);
if (!IS_SCHEMA(root, "schema")) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_NOT_SCHEMA,
NULL, NULL, node,
"The document '%s' to be included is not a schema document",
schemaLocation);
xmlFreeDoc(doc);
return (-1);
}
targetNamespace = xmlSchemaGetProp(ctxt, root, "targetNamespace");
if (targetNamespace != NULL) {
if (schema->targetNamespace == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_INCLUDE,
NULL, NULL, node,
"The target namespace of the included schema "
"'%s' has to be absent, since the including schema "
"has no target namespace",
schemaLocation);
xmlFreeDoc(doc);
return (-1);
} else if (!xmlStrEqual(targetNamespace, schema->targetNamespace)) {
xmlSchemaPCustomErrExt(ctxt,
XML_SCHEMAP_SRC_INCLUDE,
NULL, NULL, node,
"The target namespace '%s' of the included schema '%s' "
"differs from '%s' of the including schema",
targetNamespace, schemaLocation, schema->targetNamespace);
xmlFreeDoc(doc);
return (-1);
}
} else if (schema->targetNamespace != NULL) {
if ((schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) == 0) {
schema->flags |= XML_SCHEMAS_INCLUDING_CONVERT_NS;
} else
wasConvertingNs = 1;
}
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;
saveFlags = schema->flags;
xmlSchemaClearSchemaDefaults(schema);
xmlSchemaParseSchemaDefaults(ctxt, schema, root);
xmlSchemaParseSchemaTopLevel(ctxt, schema, root->children);
schema->flags = saveFlags;
if ((wasConvertingNs == 0) &&
(schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS))
schema->flags ^= XML_SCHEMAS_INCLUDING_CONVERT_NS;
return (1);
}
static xmlSchemaTypePtr
xmlSchemaParseChoice(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype, last = NULL;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
snprintf((char *) name, 30, "choice %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_CHOICE;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
(!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
attr = attr->next;
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
type->minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger");
type->maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
"(nonNegativeInteger | unbounded)");
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, 0);
} 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) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
NULL, type, node, child, NULL,
"(annotation?, (element | group | choice | sequence | any)*)");
}
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseSequence(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype, last = NULL;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlAttrPtr attr;
const xmlChar *oldcontainer;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
oldcontainer = ctxt->container;
snprintf((char *) name, 30, "#seq %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_SEQUENCE;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
(!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
attr = attr->next;
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
type->minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger");
type->maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
"(nonNegativeInteger | unbounded)");
ctxt->container = (const xmlChar *) name;
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, 0);
} 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) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
NULL, type, node, child, NULL,
"(annotation?, (element | group | choice | sequence | any)*)");
}
ctxt->container = oldcontainer;
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype;
xmlNodePtr child = NULL;
xmlChar name[30];
const xmlChar *oldcontainer;
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
oldcontainer = ctxt->container;
snprintf((char *) name, 30, "#restr %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->type = XML_SCHEMA_TYPE_RESTRICTION;
type->node = node;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "base"))) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, type, attr);
}
attr = attr->next;
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
type->base = xmlGetQNameProp(ctxt, node, "base", &(type->baseNs));
if ((type->base == NULL) &&
(ctxt->ctxtType->type == XML_SCHEMA_TYPE_COMPLEX)) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
NULL, type, node, "base", NULL);
}
ctxt->container = name;
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
subtype = NULL;
if (ctxt->parentItem->type == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
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, 0);
child = child->next;
type->subtypes = subtype;
}
} else if (ctxt->ctxtType->type == XML_SCHEMA_TYPE_SIMPLE) {
if (IS_SCHEMA(child, "simpleType")) {
if (type->base != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
NULL, NULL, type->node, child,
"The attribute 'base' and the <simpleType> child are "
"mutually exclusive", NULL);
} else {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseSimpleType(ctxt, schema, child, 0);
type->baseType = subtype;
}
child = child->next;
}
} else if (ctxt->parentItem->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
if (IS_SCHEMA(child, "simpleType")) {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseSimpleType(ctxt, schema, child, 0);
type->subtypes = subtype;
child = child->next;
}
}
if ((ctxt->ctxtType->type == XML_SCHEMA_TYPE_SIMPLE) ||
(ctxt->parentItem->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT)) {
xmlSchemaFacetPtr facet, lastfacet = NULL;
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)
ctxt->ctxtType->facets = facet;
else
lastfacet->next = facet;
lastfacet = facet;
lastfacet->next = NULL;
}
child = child->next;
}
if (lastfacet != NULL) {
xmlSchemaFacetLinkPtr facetLink, lastFacetLink = NULL;
facet = ctxt->ctxtType->facets;
do {
facetLink = (xmlSchemaFacetLinkPtr) xmlMalloc(sizeof(xmlSchemaFacetLink));
if (facetLink == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating a facet link", NULL);
xmlFree(facetLink);
return (NULL);
}
facetLink->facet = facet;
facetLink->next = NULL;
if (lastFacetLink == NULL)
ctxt->ctxtType->facetSet = facetLink;
else
lastFacetLink->next = facetLink;
lastFacetLink = facetLink;
facet = facet->next;
} while (facet != NULL);
}
}
if (ctxt->ctxtType->type == XML_SCHEMA_TYPE_COMPLEX) {
child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
if (IS_SCHEMA(child, "anyAttribute")) {
ctxt->ctxtType->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
child = child->next;
}
}
if (child != NULL) {
if (ctxt->parentItem->type == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
NULL, type, node, child, NULL,
"annotation?, (group | all | choice | sequence)?, "
"((attribute | attributeGroup)*, anyAttribute?))");
} else if (ctxt->parentItem->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
NULL, type, node, child, NULL,
"(annotation?, (simpleType?, (minExclusive | minInclusive | "
"maxExclusive | maxInclusive | totalDigits | fractionDigits | "
"length | minLength | maxLength | enumeration | whiteSpace | "
"pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))");
} else {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
NULL, type, node, child, NULL,
"(annotation?, (simpleType?, (minExclusive | minInclusive | "
"maxExclusive | maxInclusive | totalDigits | fractionDigits | "
"length | minLength | maxLength | enumeration | whiteSpace | "
"pattern)*))");
}
}
ctxt->container = oldcontainer;
return (type);
}
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, node);
if (type == NULL)
return (NULL);
type->type = XML_SCHEMA_TYPE_EXTENSION;
type->node = node;
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>: The attribute \"base\" is missing.\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, 0);
child = child->next;
}
if (subtype != NULL)
type->subtypes = subtype;
if ((ctxt->ctxtType != NULL) &&
(ctxt->ctxtType->type == XML_SCHEMA_TYPE_COMPLEX)) {
child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
if (IS_SCHEMA(child, "anyAttribute")) {
ctxt->ctxtType->attributeWildcard =
xmlSchemaParseAnyAttribute(ctxt, schema, child);
child = child->next;
}
}
if (child != NULL) {
xmlSchemaPErr2(ctxt, node, child,
XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
"<extension> has unexpected content.\n", type->name,
NULL);
}
ctxt->container = oldcontainer;
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseSimpleContent(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype, oldParentItem;
xmlNodePtr child = NULL;
xmlChar name[30];
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
snprintf((char *) name, 30, "simpleContent %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->type = XML_SCHEMA_TYPE_SIMPLE_CONTENT;
type->node = node;
type->id = xmlSchemaGetProp(ctxt, node, "id");
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
oldParentItem = ctxt->parentItem;
ctxt->parentItem = type;
subtype = NULL;
if (IS_SCHEMA(child, "restriction")) {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseRestriction(ctxt, schema, child);
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> has unexpected content.\n",
NULL, NULL);
}
ctxt->parentItem = oldParentItem;
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseComplexContent(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node)
{
xmlSchemaTypePtr type, subtype, oldParentItem;
xmlNodePtr child = NULL;
xmlChar name[30];
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
snprintf((char *) name, 30, "#CC %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, name, NULL, node);
if (type == NULL)
return (NULL);
type->type = XML_SCHEMA_TYPE_COMPLEX_CONTENT;
type->node = node;
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
(!xmlStrEqual(attr->name, BAD_CAST "mixed")))
{
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
NULL, NULL, attr);
}
attr = attr->next;
}
type->id = xmlSchemaGetProp(ctxt, node, "id");
if (xmlGetBooleanProp(ctxt, NULL, type, node, "mixed", 0)) {
if ((ctxt->ctxtType->flags & XML_SCHEMAS_TYPE_MIXED) == 0)
ctxt->ctxtType->flags |= XML_SCHEMAS_TYPE_MIXED;
}
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
oldParentItem = ctxt->parentItem;
ctxt->parentItem = type;
subtype = NULL;
if (IS_SCHEMA(child, "restriction")) {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseRestriction(ctxt, schema, child);
child = child->next;
} else if (IS_SCHEMA(child, "extension")) {
subtype = (xmlSchemaTypePtr)
xmlSchemaParseExtension(ctxt, schema, child);
child = child->next;
}
type->subtypes = subtype;
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
NULL, NULL, node, child,
NULL, "(annotation?, (restriction | extension))");
}
ctxt->parentItem = oldParentItem;
return (type);
}
static xmlSchemaTypePtr
xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int topLevel)
{
xmlSchemaTypePtr type, subtype, ctxtType;
xmlNodePtr child = NULL;
const xmlChar *name = NULL;
const xmlChar *oldcontainer;
xmlAttrPtr attr;
const xmlChar *attrValue;
xmlChar *des = NULL;
char buf[40];
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
ctxtType = ctxt->ctxtType;
if (topLevel) {
attr = xmlSchemaGetPropNode(node, "name");
if (attr == NULL) {
xmlSchemaPMissingAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_MISSING,
(xmlChar **) &xmlSchemaElemDesCT, NULL, node,
"name", NULL);
return (NULL);
} else if (xmlSchemaPValAttrNode(ctxt,
(xmlChar **) &xmlSchemaElemDesCT, NULL, attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
return (NULL);
}
}
if (topLevel == 0) {
snprintf(buf, 39, "#CT %d", ctxt->counter++ + 1);
type = xmlSchemaAddType(ctxt, schema, (const xmlChar *)buf, NULL, node);
if (type == NULL)
return (NULL);
name = (const xmlChar *) buf;
type->node = node;
type->type = XML_SCHEMA_TYPE_COMPLEX;
} else {
type = xmlSchemaAddType(ctxt, schema, name, schema->targetNamespace, node);
if (type == NULL)
return (NULL);
type->node = node;
type->type = XML_SCHEMA_TYPE_COMPLEX;
type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
type->flags |= XML_SCHEMAS_TYPE_FINAL_DEFAULT;
type->flags |= XML_SCHEMAS_TYPE_BLOCK_DEFAULT;
}
attr = node->properties;
while (attr != NULL) {
if (attr->ns == NULL) {
if (xmlStrEqual(attr->name, BAD_CAST "id")) {
type->id = xmlSchemaGetProp(ctxt, node, "id");
} else if (xmlStrEqual(attr->name, BAD_CAST "mixed")) {
if (xmlSchemaPGetBoolNodeValue(ctxt, &des, type,
(xmlNodePtr) attr))
type->flags |= XML_SCHEMAS_TYPE_MIXED;
} else if (topLevel) {
if (xmlStrEqual(attr->name, BAD_CAST "name")) {
} else if (xmlStrEqual(attr->name, BAD_CAST "abstract")) {
if (xmlSchemaPGetBoolNodeValue(ctxt, &des, type,
(xmlNodePtr) attr))
type->flags |= XML_SCHEMAS_TYPE_ABSTRACT;
} else if (xmlStrEqual(attr->name, BAD_CAST "final")) {
attrValue = xmlSchemaGetNodeContent(ctxt,
(xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(attrValue,
&(type->flags),
-1,
XML_SCHEMAS_TYPE_FINAL_EXTENSION,
XML_SCHEMAS_TYPE_FINAL_RESTRICTION,
-1, -1, -1) != 0)
{
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&des, type, (xmlNodePtr) attr,
NULL,
"(#all | List of (extension | restriction))",
attrValue, NULL, NULL, NULL);
}
} else if (xmlStrEqual(attr->name, BAD_CAST "block")) {
attrValue = xmlSchemaGetNodeContent(ctxt,
(xmlNodePtr) attr);
if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
-1,
XML_SCHEMAS_TYPE_BLOCK_EXTENSION,
XML_SCHEMAS_TYPE_BLOCK_RESTRICTION,
-1, -1, -1) != 0) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
&des, type, (xmlNodePtr) attr,
NULL,
"(#all | List of (extension | restriction)) ",
attrValue, NULL, NULL, NULL);
}
} else {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
} else {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
} else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
xmlSchemaPIllegalAttrErr(ctxt,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
&des, type, attr);
}
attr = attr->next;
}
type->flags |= XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD;
oldcontainer = ctxt->container;
ctxt->container = name;
child = node->children;
if (IS_SCHEMA(child, "annotation")) {
type->annot = xmlSchemaParseAnnotation(ctxt, schema, child);
child = child->next;
}
ctxt->ctxtType = type;
if (IS_SCHEMA(child, "simpleContent")) {
if (type->flags & XML_SCHEMAS_TYPE_MIXED)
type->flags ^= XML_SCHEMAS_TYPE_MIXED;
type->subtypes = xmlSchemaParseSimpleContent(ctxt, schema, child);
child = child->next;
} else if (IS_SCHEMA(child, "complexContent")) {
type->subtypes = xmlSchemaParseComplexContent(ctxt, schema, child);
child = child->next;
} else {
subtype = NULL;
if (IS_SCHEMA(child, "all")) {
subtype = xmlSchemaParseAll(ctxt, schema, child);
child = child->next;
} else if (IS_SCHEMA(child, "choice")) {
subtype = xmlSchemaParseChoice(ctxt, schema, child);
child = child->next;
} else if (IS_SCHEMA(child, "sequence")) {
subtype = xmlSchemaParseSequence(ctxt, schema, child);
child = child->next;
} else if (IS_SCHEMA(child, "group")) {
subtype = xmlSchemaParseGroup(ctxt, schema, child, 0);
child = child->next;
}
if (subtype != NULL)
type->subtypes = subtype;
child = xmlSchemaParseAttrDecls(ctxt, schema, child, type);
if (IS_SCHEMA(child, "anyAttribute")) {
type->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
child = child->next;
}
}
if (child != NULL) {
xmlSchemaPContentErr(ctxt,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
&des, type, node, child,
NULL, "(annotation?, (simpleContent | complexContent | "
"((group | all | choice | sequence)?, ((attribute | "
"attributeGroup)*, anyAttribute?))))");
}
FREE_AND_NULL(des);
ctxt->container = oldcontainer;
ctxt->ctxtType = ctxtType;
return (type);
}
static xmlSchemaPtr
xmlSchemaParseSchema(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
{
xmlSchemaPtr schema = NULL;
const xmlChar *val;
int nberrors;
xmlAttrPtr attr;
if ((ctxt == NULL) || (node == NULL))
return (NULL);
nberrors = ctxt->nberrors;
ctxt->nberrors = 0;
if (IS_SCHEMA(node, "schema")) {
xmlSchemaImportPtr import;
schema = xmlSchemaNewSchema(ctxt);
if (schema == NULL)
return (NULL);
attr = xmlSchemaGetPropNode(node, "targetNamespace");
if (attr != NULL) {
xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), &val);
schema->targetNamespace = xmlDictLookup(ctxt->dict, val, -1);
} else {
schema->targetNamespace = NULL;
}
import = xmlSchemaAddImport(ctxt, &(schema->schemasImports),
schema->targetNamespace);
if (import == NULL) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_FAILED_BUILD_IMPORT,
NULL, NULL, (xmlNodePtr) ctxt->doc,
"Internal error: xmlSchemaParseSchema, "
"failed to add an import entry", NULL);
xmlSchemaFree(schema);
schema = NULL;
return (NULL);
}
import->schemaLocation = ctxt->URL;
schema->id = xmlSchemaGetProp(ctxt, node, "id");
xmlSchemaPValAttr(ctxt, NULL, NULL, node, "version",
xmlSchemaGetBuiltInType(XML_SCHEMAS_TOKEN), &(schema->version));
xmlSchemaParseSchemaDefaults(ctxt, schema, node);
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,
"The file \"%s\" is not a XML schema.\n", doc->URL, NULL);
} else {
xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
XML_SCHEMAP_NOT_SCHEMA,
"The file is not a XML schema.\n", NULL, NULL);
}
return(NULL);
}
if (ctxt->nberrors != 0) {
if (schema != NULL) {
xmlSchemaFree(schema);
schema = NULL;
}
}
if (schema != NULL)
schema->counter = ctxt->counter;
ctxt->nberrors = nberrors;
#ifdef DEBUG
if (schema == NULL)
xmlGenericError(xmlGenericErrorContext,
"xmlSchemaParse() failed\n");
#endif
return (schema);
}
#if 0
static int
xmlSchemaParserCtxtSetOptions(xmlSchemaParserCtxtPtr ctxt,
int options)
{
int i;
if (ctxt == NULL)
return (-1);
for (i = 1; i < (int) sizeof(int) * 8; i++) {
if (options & 1<<i) {
return (-1);
}
}
ctxt->options = options;
return (0);
}
static int
xmlSchemaParserCtxtGetOptions(xmlSchemaParserCtxtPtr ctxt)
{
if (ctxt == NULL)
return (-1);
else
return (ctxt->options);
}
void *curItems;
int nbCurItems;
int sizeCurItems;
#endif
xmlSchemaParserCtxtPtr
xmlSchemaNewParserCtxt(const char *URL)
{
xmlSchemaParserCtxtPtr ret;
if (URL == 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->dict = xmlDictCreate();
ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
ret->includes = 0;
return (ret);
}
static xmlSchemaParserCtxtPtr
xmlSchemaNewParserCtxtUseDict(const char *URL, xmlDictPtr dict)
{
xmlSchemaParserCtxtPtr ret;
ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
if (ret == NULL) {
xmlSchemaPErrMemory(NULL, "allocating schema parser context",
NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaParserCtxt));
ret->dict = dict;
xmlDictReference(dict);
if (URL != NULL)
ret->URL = xmlDictLookup(dict, (const xmlChar *) URL, -1);
ret->includes = 0;
return (ret);
}
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 schema parser context",
NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaParserCtxt));
ret->buffer = buffer;
ret->size = size;
ret->dict = xmlDictCreate();
return (ret);
}
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();
ret->preserve = 1;
return (ret);
}
void
xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt)
{
if (ctxt == NULL)
return;
if (ctxt->doc != NULL && !ctxt->preserve)
xmlFreeDoc(ctxt->doc);
if (ctxt->assemble != NULL) {
xmlFree((xmlSchemaTypePtr *) ctxt->assemble->items);
xmlFree(ctxt->assemble);
}
if (ctxt->vctxt != NULL) {
xmlSchemaFreeValidCtxt(ctxt->vctxt);
}
xmlDictFree(ctxt->dict);
xmlFree(ctxt);
}
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: {
xmlAutomataStatePtr start, end;
xmlSchemaWildcardPtr wild;
xmlSchemaWildcardNsPtr ns;
wild = type->attributeWildcard;
if (wild == NULL) {
xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaBuildAContentModel, "
"no wildcard on xsd:any.\n", NULL, NULL);
return;
}
start = ctxt->state;
end = xmlAutomataNewState(ctxt->am);
if (type->maxOccurs == 1) {
if (wild->any == 1) {
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", BAD_CAST "*", type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", NULL, type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
} else if (wild->nsSet != NULL) {
ns = wild->nsSet;
do {
ctxt->state = start;
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
ctxt->state, NULL, BAD_CAST "*", ns->value, type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
ns = ns->next;
} while (ns != NULL);
} else if (wild->negNsSet != NULL) {
xmlAutomataStatePtr deadEnd;
deadEnd = xmlAutomataNewState(ctxt->am);
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
start, deadEnd, BAD_CAST "*", wild->negNsSet->value, type);
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", BAD_CAST "*", type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
}
} else {
int counter;
xmlAutomataStatePtr hop;
int maxOccurs =
type->maxOccurs == UNBOUNDED ? UNBOUNDED : type->maxOccurs - 1;
int minOccurs =
type->minOccurs < 1 ? 0 : type->minOccurs - 1;
counter = xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs);
hop = xmlAutomataNewState(ctxt->am);
if (wild->any == 1) {
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", BAD_CAST "*", type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", NULL, type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
} else if (wild->nsSet != NULL) {
ns = wild->nsSet;
do {
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", ns->value, type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
ns = ns->next;
} while (ns != NULL);
} else if (wild->negNsSet != NULL) {
xmlAutomataStatePtr deadEnd;
deadEnd = xmlAutomataNewState(ctxt->am);
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
start, deadEnd, BAD_CAST "*", wild->negNsSet->value, type);
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
start, NULL, BAD_CAST "*", BAD_CAST "*", type);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
}
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_ELEMENT:{
xmlAutomataStatePtr oldstate;
xmlSchemaElementPtr particle, elemDecl;
particle = (xmlSchemaElementPtr) type;
if (particle->ref != NULL) {
if (particle->refDecl == NULL) {
break;
} else {
elemDecl = particle->refDecl;
}
} else {
elemDecl = particle;
}
oldstate = ctxt->state;
if (particle->maxOccurs >= UNBOUNDED) {
if (particle->minOccurs > 1) {
xmlAutomataStatePtr tmp;
int counter;
ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
oldstate, NULL);
oldstate = ctxt->state;
counter = xmlAutomataNewCounter(ctxt->am,
particle->minOccurs - 1, UNBOUNDED);
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
ctxt->state, NULL,
elemDecl->name,
elemDecl->targetNamespace,
(xmlSchemaTypePtr) elemDecl);
tmp = ctxt->state;
xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
counter);
ctxt->state =
xmlAutomataNewCounterTrans(ctxt->am, tmp, NULL,
counter);
} else {
ctxt->state =
xmlAutomataNewTransition2(ctxt->am,
ctxt->state, NULL,
elemDecl->name,
elemDecl->targetNamespace,
(xmlSchemaTypePtr) elemDecl);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
oldstate);
if (particle->minOccurs == 0) {
xmlAutomataNewEpsilon(ctxt->am, oldstate,
ctxt->state);
}
}
} else if ((particle->maxOccurs > 1) || (particle->minOccurs > 1)) {
xmlAutomataStatePtr tmp;
int counter;
ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
oldstate, NULL);
oldstate = ctxt->state;
counter = xmlAutomataNewCounter(ctxt->am,
particle->minOccurs - 1,
particle->maxOccurs - 1);
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
ctxt->state,
NULL,
elemDecl->name,
elemDecl->targetNamespace,
(xmlSchemaTypePtr) elemDecl);
tmp = ctxt->state;
xmlAutomataNewCountedTrans(ctxt->am, tmp, oldstate,
counter);
ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, tmp,
NULL, counter);
if (particle->minOccurs == 0) {
xmlAutomataNewEpsilon(ctxt->am, oldstate,
ctxt->state);
}
} else {
ctxt->state = xmlAutomataNewTransition2(ctxt->am,
ctxt->state,
NULL,
elemDecl->name,
elemDecl->targetNamespace,
(xmlSchemaTypePtr) elemDecl);
if (particle->minOccurs == 0) {
xmlAutomataNewEpsilon(ctxt->am, oldstate,
ctxt->state);
}
}
break;
}
case XML_SCHEMA_TYPE_SEQUENCE:{
xmlSchemaTypePtr 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);
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;
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;
int lax;
subtypes = type->subtypes;
if (subtypes == NULL)
break;
start = ctxt->state;
while (subtypes != NULL) {
ctxt->state = start;
if (subtypes->ref != NULL)
xmlSchemaBuildAContentModel(subtypes, ctxt, name);
elem = (xmlSchemaElementPtr) subtypes;
if ((elem->minOccurs == 1) && (elem->maxOccurs == 1)) {
xmlAutomataNewOnceTrans2(ctxt->am, ctxt->state,
ctxt->state,
elem->name,
elem->targetNamespace,
1, 1, subtypes);
} else if ((elem->minOccurs == 0) &&
(elem->maxOccurs == 1)) {
xmlAutomataNewCountTrans2(ctxt->am, ctxt->state,
ctxt->state,
elem->name,
elem->targetNamespace,
0,
1,
subtypes);
}
subtypes = subtypes->next;
}
lax = type->minOccurs == 0;
ctxt->state =
xmlAutomataNewAllTrans(ctxt->am, ctxt->state, NULL,
lax);
break;
}
case XML_SCHEMA_TYPE_RESTRICTION:
if (type->subtypes != NULL)
xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
break;
case XML_SCHEMA_TYPE_EXTENSION:
if (type->baseType != NULL) {
xmlSchemaTypePtr subtypes;
if (type->recurse) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_UNKNOWN_BASE_TYPE,
NULL, type, type->node,
"This item is circular", NULL);
return;
}
type->recurse = 1;
xmlSchemaBuildAContentModel(type->baseType, ctxt, name);
type->recurse = 0;
subtypes = type->subtypes;
while (subtypes != NULL) {
xmlSchemaBuildAContentModel(subtypes, ctxt, name);
subtypes = subtypes->next;
}
} else if (type->subtypes != NULL)
xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
break;
case XML_SCHEMA_TYPE_GROUP:
if ((type->ref != NULL) && (type->subtypes != NULL) &&
(type->subtypes->subtypes != NULL)) {
xmlSchemaTypePtr modelGr;
xmlAutomataStatePtr start, end;
modelGr = type->subtypes->subtypes;
start = ctxt->state;
end = xmlAutomataNewState(ctxt->am);
if (type->maxOccurs == 1) {
ctxt->state = start;
xmlSchemaBuildAContentModel(modelGr, ctxt, name);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end);
} else {
int counter;
xmlAutomataStatePtr hop;
int maxOccurs = type->maxOccurs == UNBOUNDED ?
UNBOUNDED : type->maxOccurs - 1;
int minOccurs =
type->minOccurs < 1 ? 0 : type->minOccurs - 1;
counter =
xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs);
hop = xmlAutomataNewState(ctxt->am);
ctxt->state = start;
xmlSchemaBuildAContentModel(modelGr, ctxt, name);
xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop);
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;
}
break;
case XML_SCHEMA_TYPE_COMPLEX:
case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
if (type->subtypes != NULL)
xmlSchemaBuildAContentModel(type->subtypes, ctxt, name);
break;
case XML_SCHEMA_TYPE_SIMPLE_CONTENT:
break;
default:
xmlGenericError(xmlGenericErrorContext,
"Found unexpected type %d in %s content model\n",
type->type, name);
return;
}
}
static void
xmlSchemaBuildContentModel(xmlSchemaTypePtr type,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name)
{
xmlAutomataStatePtr start;
if ((type->type != XML_SCHEMA_TYPE_COMPLEX) || (type->ref != NULL) ||
(type->contentType == XML_SCHEMA_CONTENT_BASIC) ||
(type->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
(type->contModel != NULL))
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 complex tpye %s\n", name);
return;
}
start = ctxt->state = xmlAutomataGetInitState(ctxt->am);
xmlSchemaBuildAContentModel(type, ctxt, name);
xmlAutomataSetFinalState(ctxt->am, ctxt->state);
type->contModel = xmlAutomataCompile(ctxt->am);
if (type->contModel == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, type->node,
"Failed to compile the content model", NULL);
} else if (xmlRegexpIsDeterminist(type->contModel) != 1) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_NOT_DETERMINISTIC,
NULL, type, type->node,
"The content model is not determinist", NULL);
} else {
#ifdef DEBUG_CONTENT_REGEXP
xmlGenericError(xmlGenericErrorContext,
"Content model of %s:\n", name);
xmlRegexpPrint(stderr, type->contModel);
#endif
}
ctxt->state = NULL;
xmlFreeAutomata(ctxt->am);
ctxt->am = NULL;
}
static void
xmlSchemaRefFixupCallback(xmlSchemaElementPtr elem,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED,
const xmlChar * context ATTRIBUTE_UNUSED,
const xmlChar * namespace ATTRIBUTE_UNUSED)
{
if ((ctxt == NULL) || (elem == NULL) ||
((elem != NULL) && (elem->flags & XML_SCHEMAS_ELEM_INTERNAL_RESOLVED)))
return;
elem->flags |= XML_SCHEMAS_ELEM_INTERNAL_RESOLVED;
if (elem->ref != NULL) {
xmlSchemaElementPtr elemDecl;
elemDecl = xmlSchemaGetElem(ctxt->schema, elem->ref, elem->refNs);
if (elemDecl == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) elem, elem->node,
"ref", elem->ref, elem->refNs,
XML_SCHEMA_TYPE_ELEMENT, NULL);
} else
elem->refDecl = elemDecl;
} else {
if ((elem->subtypes == NULL) && (elem->namedType != NULL)) {
xmlSchemaTypePtr type;
type = xmlSchemaGetType(ctxt->schema, elem->namedType,
elem->namedTypeNs);
if (type == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) elem, elem->node,
"type", elem->namedType, elem->namedTypeNs,
XML_SCHEMA_TYPE_BASIC, "type definition");
} else
elem->subtypes = type;
}
if (elem->substGroup != NULL) {
xmlSchemaElementPtr substHead;
substHead = xmlSchemaGetElem(ctxt->schema, elem->substGroup,
elem->substGroupNs);
if (substHead == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) elem, NULL,
"substitutionGroup", elem->substGroup, elem->substGroupNs,
XML_SCHEMA_TYPE_ELEMENT, NULL);
} else {
xmlSchemaRefFixupCallback(substHead, ctxt, NULL, NULL, NULL);
if (elem->subtypes == NULL)
elem->subtypes = substHead->subtypes;
}
}
if ((elem->subtypes == NULL) && (elem->namedType == NULL) &&
(elem->substGroup == NULL))
elem->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
}
}
static void
xmlSchemaParseListRefFixup(xmlSchemaTypePtr type, xmlSchemaParserCtxtPtr ctxt)
{
if (((type->base == NULL) &&
(type->subtypes == NULL)) ||
((type->base != NULL) &&
(type->subtypes != NULL))) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
NULL, type, type->node,
"The attribute 'itemType' and the <simpleType> child "
"are mutually exclusive", NULL);
} else if (type->base!= NULL) {
type->subtypes = xmlSchemaGetType(ctxt->schema, type->base, type->baseNs);
if (type->subtypes == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, type, type->node,
"itemType", type->base, type->baseNs,
XML_SCHEMA_TYPE_SIMPLE, NULL);
}
}
if ((type->subtypes != NULL) &&
(type->subtypes->contentType == XML_SCHEMA_CONTENT_UNKNOWN))
xmlSchemaTypeFixup(type->subtypes, ctxt, NULL);
}
static int
xmlSchemaParseUnionRefCheck(xmlSchemaTypePtr type,
xmlSchemaParserCtxtPtr ctxt)
{
xmlSchemaTypeLinkPtr link, lastLink = NULL, prevLink, subLink, newLink;
xmlSchemaTypePtr memberType, ctxtType;
if (type->type != XML_SCHEMA_TYPE_UNION)
return (-1);
if (ctxt->ctxtType == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaParseUnionRefCheck, no parent type "
"available", NULL, NULL);
return (-1);
}
if ((type->base == NULL) &&
(type->subtypes == NULL)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
NULL, NULL, type->node,
"Either the attribute 'memberTypes' must be non-empty "
"or there must be at least one <simpleType> child", NULL);
}
ctxtType = ctxt->ctxtType;
if (type->base != NULL) {
xmlAttrPtr attr;
const xmlChar *cur, *end;
xmlChar *tmp;
const xmlChar *localName, *uri;
attr = xmlSchemaGetPropNode(type->node, "memberTypes");
cur = type->base;
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);
xmlSchemaPValAttrNodeQNameValue(ctxt, ctxt->schema, NULL,
NULL, attr, BAD_CAST tmp, &uri, NULL, &localName);
memberType = xmlSchemaGetType(ctxt->schema, localName, uri);
if (memberType == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
NULL, NULL, type->node, "memberTypes", localName, uri,
XML_SCHEMA_TYPE_SIMPLE, NULL);
} else {
if (memberType->contentType == XML_SCHEMA_CONTENT_UNKNOWN)
xmlSchemaTypeFixup(memberType, ctxt, NULL);
link = (xmlSchemaTypeLinkPtr) xmlMalloc(sizeof(xmlSchemaTypeLink));
if (link == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating a type link", NULL);
return (-1);
}
link->type = memberType;
link->next = NULL;
if (lastLink == NULL)
ctxtType->memberTypes = link;
else
lastLink->next = link;
lastLink = link;
}
xmlFree(tmp);
cur = end;
} while (*cur != 0);
}
memberType = type->subtypes;
while (memberType != NULL) {
if (memberType->contentType == XML_SCHEMA_CONTENT_UNKNOWN)
xmlSchemaTypeFixup(memberType, ctxt, NULL);
link = (xmlSchemaTypeLinkPtr) xmlMalloc(sizeof(xmlSchemaTypeLink));
if (link == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating a type link", NULL);
return (-1);
}
link->type = memberType;
link->next = NULL;
if (lastLink == NULL)
ctxtType->memberTypes = link;
else
lastLink->next = link;
lastLink = link;
memberType = memberType->next;
}
link = ctxtType->memberTypes;
while (link != NULL) {
if (link->type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
subLink = link->type->memberTypes;
if (subLink != NULL) {
link->type = subLink->type;
if (subLink->next != NULL) {
lastLink = link->next;
subLink = subLink->next;
prevLink = link;
while (subLink != NULL) {
newLink = (xmlSchemaTypeLinkPtr)
xmlMalloc(sizeof(xmlSchemaTypeLink));
if (newLink == NULL) {
xmlSchemaPErrMemory(ctxt, "allocating a type link",
NULL);
return (-1);
}
newLink->type = memberType;
prevLink->next = newLink;
prevLink = newLink;
newLink->next = lastLink;
subLink = subLink->next;
}
}
}
}
link = link->next;
}
return (0);
}
static int
xmlSchemaIsDerivedFromBuiltInType(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type, int valType)
{
if ((type->type == XML_SCHEMA_TYPE_BASIC) &&
(type->contentType == XML_SCHEMA_CONTENT_BASIC)) {
if (type->builtInType == valType)
return(1);
} else if (type->type == XML_SCHEMA_TYPE_ATTRIBUTE) {
if (((xmlSchemaAttributePtr) type)->subtypes != NULL)
return(xmlSchemaIsDerivedFromBuiltInType(ctxt,
((xmlSchemaAttributePtr) type)->subtypes, valType));
} else if ((type->type == XML_SCHEMA_TYPE_RESTRICTION) ||
(type->type == XML_SCHEMA_TYPE_EXTENSION)) {
if (type->baseType != NULL)
return(xmlSchemaIsDerivedFromBuiltInType(ctxt, type->baseType,
valType));
} else if ((type->subtypes != NULL) &&
((type->subtypes->type == XML_SCHEMA_TYPE_COMPLEX) ||
(type->subtypes->type == XML_SCHEMA_TYPE_COMPLEX_CONTENT) ||
(type->subtypes->type == XML_SCHEMA_TYPE_SIMPLE) ||
(type->subtypes->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT))) {
return(xmlSchemaIsDerivedFromBuiltInType(ctxt, type->subtypes,
valType));
}
return (0);
}
static xmlSchemaTypePtr
xmlSchemaGetPrimitiveType(xmlSchemaTypePtr type)
{
while (type != NULL) {
if (type->flags & XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE)
return (type);
type = type->baseType;
}
return (NULL);
}
static int
xmlSchemaBuildAttributeUsesOwned(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaAttributePtr cur,
xmlSchemaAttributeLinkPtr *uses,
xmlSchemaAttributeLinkPtr *lastUse)
{
xmlSchemaAttributeLinkPtr tmp;
while (cur != NULL) {
if (cur->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
if (xmlSchemaBuildAttributeUsesOwned(ctxt,
((xmlSchemaAttributeGroupPtr) cur)->attributes, uses,
lastUse) == -1) {
return (-1);
}
} else {
tmp = (xmlSchemaAttributeLinkPtr)
xmlMalloc(sizeof(xmlSchemaAttributeLink));
if (tmp == NULL) {
xmlSchemaPErrMemory(ctxt, "building attribute uses", NULL);
return (-1);
}
tmp->attr = cur;
tmp->next = NULL;
if (*uses == NULL)
*uses = tmp;
else
(*lastUse)->next = tmp;
*lastUse = tmp;
}
cur = cur->next;
}
return (0);
}
static int
xmlSchemaCloneWildcardNsConstraints(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaWildcardPtr *dest,
xmlSchemaWildcardPtr source)
{
xmlSchemaWildcardNsPtr cur, tmp, last;
if ((source == NULL) || (*dest == NULL))
return(-1);
(*dest)->any = source->any;
cur = source->nsSet;
last = NULL;
while (cur != NULL) {
tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
if (tmp == NULL)
return(-1);
tmp->value = cur->value;
if (last == NULL)
(*dest)->nsSet = tmp;
else
last->next = tmp;
last = tmp;
cur = cur->next;
}
if ((*dest)->negNsSet != NULL)
xmlSchemaFreeWildcardNsSet((*dest)->negNsSet);
if (source->negNsSet != NULL) {
(*dest)->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
if ((*dest)->negNsSet == NULL)
return(-1);
(*dest)->negNsSet->value = source->negNsSet->value;
} else
(*dest)->negNsSet = NULL;
return(0);
}
static int
xmlSchemaUnionWildcards(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaWildcardPtr completeWild,
xmlSchemaWildcardPtr curWild)
{
xmlSchemaWildcardNsPtr cur, curB, tmp;
if ((completeWild->any == curWild->any) &&
((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
if ((completeWild->negNsSet == NULL) ||
(completeWild->negNsSet->value == curWild->negNsSet->value)) {
if (completeWild->nsSet != NULL) {
int found = 0;
cur = completeWild->nsSet;
while (cur != NULL) {
found = 0;
curB = curWild->nsSet;
while (curB != NULL) {
if (cur->value == curB->value) {
found = 1;
break;
}
curB = curB->next;
}
if (!found)
break;
cur = cur->next;
}
if (found)
return(0);
} else
return(0);
}
}
if (completeWild->any != curWild->any) {
if (completeWild->any == 0) {
completeWild->any = 1;
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
if (completeWild->negNsSet != NULL) {
xmlFree(completeWild->negNsSet);
completeWild->negNsSet = NULL;
}
}
return (0);
}
if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
int found;
xmlSchemaWildcardNsPtr start;
cur = curWild->nsSet;
start = completeWild->nsSet;
while (cur != NULL) {
found = 0;
curB = start;
while (curB != NULL) {
if (cur->value == curB->value) {
found = 1;
break;
}
curB = curB->next;
}
if (!found) {
tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
if (tmp == NULL)
return (-1);
tmp->value = cur->value;
tmp->next = completeWild->nsSet;
completeWild->nsSet = tmp;
}
cur = cur->next;
}
return(0);
}
if ((completeWild->negNsSet != NULL) &&
(curWild->negNsSet != NULL) &&
(completeWild->negNsSet->value != curWild->negNsSet->value)) {
completeWild->negNsSet->value = NULL;
return(0);
}
if (((completeWild->negNsSet != NULL) &&
(completeWild->negNsSet->value != NULL) &&
(curWild->nsSet != NULL)) ||
((curWild->negNsSet != NULL) &&
(curWild->negNsSet->value != NULL) &&
(completeWild->nsSet != NULL))) {
int nsFound, absentFound = 0;
if (completeWild->nsSet != NULL) {
cur = completeWild->nsSet;
curB = curWild->negNsSet;
} else {
cur = curWild->nsSet;
curB = completeWild->negNsSet;
}
nsFound = 0;
while (cur != NULL) {
if (cur->value == NULL)
absentFound = 1;
else if (cur->value == curB->value)
nsFound = 1;
if (nsFound && absentFound)
break;
cur = cur->next;
}
if (nsFound && absentFound) {
completeWild->any = 1;
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
if (completeWild->negNsSet != NULL) {
xmlFree(completeWild->negNsSet);
completeWild->negNsSet = NULL;
}
} else if (nsFound && (!absentFound)) {
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
if (completeWild->negNsSet == NULL) {
completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
if (completeWild->negNsSet == NULL)
return (-1);
}
completeWild->negNsSet->value = NULL;
} else if ((!nsFound) && absentFound) {
xmlSchemaPErr(ctxt, completeWild->node,
XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
"The union of the wilcard is not expressible.\n",
NULL, NULL);
return(XML_SCHEMAP_UNION_NOT_EXPRESSIBLE);
} else if ((!nsFound) && (!absentFound)) {
if (completeWild->negNsSet == NULL) {
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
if (completeWild->negNsSet == NULL)
return (-1);
completeWild->negNsSet->value = curWild->negNsSet->value;
}
}
return (0);
}
if (((completeWild->negNsSet != NULL) &&
(completeWild->negNsSet->value == NULL) &&
(curWild->nsSet != NULL)) ||
((curWild->negNsSet != NULL) &&
(curWild->negNsSet->value == NULL) &&
(completeWild->nsSet != NULL))) {
if (completeWild->nsSet != NULL) {
cur = completeWild->nsSet;
} else {
cur = curWild->nsSet;
}
while (cur != NULL) {
if (cur->value == NULL) {
completeWild->any = 1;
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
if (completeWild->negNsSet != NULL) {
xmlFree(completeWild->negNsSet);
completeWild->negNsSet = NULL;
}
return (0);
}
cur = cur->next;
}
if (completeWild->negNsSet == NULL) {
if (completeWild->nsSet != NULL) {
xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
completeWild->nsSet = NULL;
}
completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
if (completeWild->negNsSet == NULL)
return (-1);
completeWild->negNsSet->value = NULL;
}
return (0);
}
return (0);
}
static int
xmlSchemaIntersectWildcards(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaWildcardPtr completeWild,
xmlSchemaWildcardPtr curWild)
{
xmlSchemaWildcardNsPtr cur, curB, prev, tmp;
if ((completeWild->any == curWild->any) &&
((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
if ((completeWild->negNsSet == NULL) ||
(completeWild->negNsSet->value == curWild->negNsSet->value)) {
if (completeWild->nsSet != NULL) {
int found = 0;
cur = completeWild->nsSet;
while (cur != NULL) {
found = 0;
curB = curWild->nsSet;
while (curB != NULL) {
if (cur->value == curB->value) {
found = 1;
break;
}
curB = curB->next;
}
if (!found)
break;
cur = cur->next;
}
if (found)
return(0);
} else
return(0);
}
}
if ((completeWild->any != curWild->any) && (completeWild->any)) {
if (xmlSchemaCloneWildcardNsConstraints(ctxt, &completeWild, curWild) == -1)
return(-1);
return(0);
}
if (((completeWild->negNsSet != NULL) && (curWild->nsSet != NULL)) ||
((curWild->negNsSet != NULL) && (completeWild->nsSet != NULL))) {
const xmlChar *neg;
if (completeWild->nsSet == NULL) {
neg = completeWild->negNsSet->value;
if (xmlSchemaCloneWildcardNsConstraints(ctxt, &completeWild, curWild) == -1)
return(-1);
} else
neg = curWild->negNsSet->value;
prev = NULL;
cur = completeWild->nsSet;
while (cur != NULL) {
if (cur->value == NULL) {
if (prev == NULL)
completeWild->nsSet = cur->next;
else
prev->next = cur->next;
xmlFree(cur);
break;
}
prev = cur;
cur = cur->next;
}
if (neg != NULL) {
prev = NULL;
cur = completeWild->nsSet;
while (cur != NULL) {
if (cur->value == neg) {
if (prev == NULL)
completeWild->nsSet = cur->next;
else
prev->next = cur->next;
xmlFree(cur);
break;
}
prev = cur;
cur = cur->next;
}
}
return(0);
}
if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
int found;
cur = completeWild->nsSet;
prev = NULL;
while (cur != NULL) {
found = 0;
curB = curWild->nsSet;
while (curB != NULL) {
if (cur->value == curB->value) {
found = 1;
break;
}
curB = curB->next;
}
if (!found) {
if (prev == NULL)
completeWild->nsSet = cur->next;
else
prev->next = cur->next;
tmp = cur->next;
xmlFree(cur);
cur = tmp;
continue;
}
prev = cur;
cur = cur->next;
}
return(0);
}
if ((completeWild->negNsSet != NULL) &&
(curWild->negNsSet != NULL) &&
(completeWild->negNsSet->value != curWild->negNsSet->value) &&
(completeWild->negNsSet->value != NULL) &&
(curWild->negNsSet->value != NULL)) {
xmlSchemaPErr(ctxt, completeWild->node, XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
"The intersection of the wilcard is not expressible.\n",
NULL, NULL);
return(XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE);
}
if ((completeWild->negNsSet != NULL) && (curWild->negNsSet != NULL) &&
(completeWild->negNsSet->value != curWild->negNsSet->value) &&
(completeWild->negNsSet->value == NULL)) {
completeWild->negNsSet->value = curWild->negNsSet->value;
}
return(0);
}
static int
xmlSchemaIsWildcardNsConstraintSubset(xmlSchemaWildcardPtr wildA,
xmlSchemaWildcardPtr wildB)
{
if (wildB->any)
return (1);
if ((wildA->negNsSet != NULL) &&
(wildB->negNsSet != NULL) &&
(wildA->negNsSet->value == wildA->negNsSet->value))
return (1);
if (wildA->nsSet != NULL) {
if (wildB->nsSet != NULL) {
xmlSchemaWildcardNsPtr cur, curB;
int found = 0;
cur = wildA->nsSet;
while (cur != NULL) {
found = 0;
curB = wildB->nsSet;
while (curB != NULL) {
if (cur->value == curB->value) {
found = 1;
break;
}
curB = curB->next;
}
if (!found)
return (0);
cur = cur->next;
}
if (found)
return (1);
} else if (wildB->negNsSet != NULL) {
xmlSchemaWildcardNsPtr cur;
cur = wildA->nsSet;
while (cur != NULL) {
if (cur->value == wildB->negNsSet->value)
return (0);
cur = cur->next;
}
return (1);
}
}
return (0);
}
static int
xmlSchemaBuildCompleteAttributeWildcard(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaAttributePtr attrs,
xmlSchemaWildcardPtr *completeWild)
{
while (attrs != NULL) {
if (attrs->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
xmlSchemaAttributeGroupPtr group;
group = (xmlSchemaAttributeGroupPtr) attrs;
if (group->ref != NULL) {
if (group->refItem == NULL) {
attrs = attrs->next;
continue;
} else
group = group->refItem;
}
if ((group->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED) == 0) {
if (group->attributes != NULL) {
if (xmlSchemaBuildCompleteAttributeWildcard(ctxt,
group->attributes, &group->attributeWildcard) == -1)
return (-1);
}
group->flags |= XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED;
}
if (group->attributeWildcard != NULL) {
if (*completeWild == NULL) {
*completeWild = xmlSchemaAddWildcard(ctxt);
(*completeWild)->type = XML_SCHEMA_TYPE_ANY_ATTRIBUTE;
if (xmlSchemaCloneWildcardNsConstraints(ctxt,
completeWild, group->attributeWildcard) == -1)
return (-1);
(*completeWild)->processContents = group->attributeWildcard->processContents;
(*completeWild)->node = group->attributeWildcard->node;
} else if (xmlSchemaIntersectWildcards(ctxt, *completeWild, group->attributeWildcard) == -1) {
xmlSchemaFreeWildcard(*completeWild);
return (-1);
}
}
}
attrs = attrs->next;
}
return (0);
}
static int
xmlSchemaGetEffectiveValueConstraint(xmlSchemaAttributePtr item,
int *fixed,
const xmlChar **value,
xmlSchemaValPtr *val)
{
*fixed = 0;
*value = NULL;
if (val != 0)
*val = NULL;
if (item->defValue == NULL)
item = item->refDecl;
if (item == NULL)
return (0);
if (item->defValue != NULL) {
*value = item->defValue;
if (val != 0)
*val = item->defVal;
if (item->flags & XML_SCHEMAS_ATTR_FIXED)
*fixed = 1;
return (1);
}
return (0);
}
static int
xmlSchemaMatchesWildcardNs(xmlSchemaWildcardPtr wild, const xmlChar* ns)
{
if (wild == NULL)
return(0);
if (wild->any)
return(1);
else if (wild->nsSet != NULL) {
xmlSchemaWildcardNsPtr cur;
cur = wild->nsSet;
while (cur != NULL) {
if (xmlStrEqual(cur->value, ns))
return(1);
cur = cur->next;
}
} else if ((wild->negNsSet != NULL) && (ns != NULL) &&
(!xmlStrEqual(wild->negNsSet->value, ns)))
return(1);
return(0);
}
static int
xmlSchemaBuildAttributeValidation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaTypePtr type)
{
xmlSchemaTypePtr baseType = NULL;
xmlSchemaAttributeLinkPtr cur, base, tmp, id = NULL, prev = NULL, uses = NULL,
lastUse = NULL, lastBaseUse = NULL;
xmlSchemaAttributePtr attrs;
xmlSchemaTypePtr anyType;
int baseIsAnyType = 0;
xmlChar *str = NULL;
int err = 0;
anyType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
if (type->attributeUses != NULL) {
xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaBuildAttributeValidation: "
"attribute uses already builded.\n",
NULL, NULL);
return (-1);
}
if (type->baseType == NULL) {
xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaBuildAttributeValidation: "
"complex type '%s' has no base type.\n",
type->name, NULL);
return (-1);
}
baseType = type->baseType;
if (baseType == anyType)
baseIsAnyType = 1;
if (!baseIsAnyType) {
if (baseType != NULL) {
for (cur = baseType->attributeUses; cur != NULL; cur = cur->next) {
tmp = (xmlSchemaAttributeLinkPtr)
xmlMalloc(sizeof(xmlSchemaAttributeLink));
if (tmp == NULL) {
xmlSchemaPErrMemory(ctxt,
"building attribute uses of complexType", NULL);
return (-1);
}
tmp->attr = cur->attr;
tmp->next = NULL;
if (type->attributeUses == NULL) {
type->attributeUses = tmp;
} else
lastBaseUse->next = tmp;
lastBaseUse = tmp;
}
}
}
if ((type->subtypes != NULL) &&
((type->subtypes->type == XML_SCHEMA_TYPE_COMPLEX_CONTENT) ||
(type->subtypes->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT))) {
attrs = type->subtypes->subtypes->attributes;
} else {
attrs = type->attributes;
}
err = xmlSchemaBuildCompleteAttributeWildcard(ctxt,
attrs, &type->attributeWildcard);
if (err == -1) {
xmlSchemaPErr(ctxt, type->node, XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaBuildAttributeValidation: "
"failed to build an intersected attribute wildcard.\n",
NULL, NULL);
return (-1);
}
if ((type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) &&
((baseIsAnyType) ||
((baseType != NULL) &&
(baseType->type == XML_SCHEMA_TYPE_COMPLEX) &&
(baseType->attributeWildcard != NULL)))) {
if (type->attributeWildcard != NULL) {
if (xmlSchemaUnionWildcards(ctxt, type->attributeWildcard,
baseType->attributeWildcard) == -1)
return (-1);
} else {
if (type->flags & XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD)
type->flags ^= XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD;
type->attributeWildcard = baseType->attributeWildcard;
}
}
if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION) {
if (type->attributeWildcard != NULL) {
if (baseType->attributeWildcard == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
NULL, type, NULL,
"The type has an attribute wildcard, "
"but the base type %s does not have one",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (1);
} else if (xmlSchemaIsWildcardNsConstraintSubset(
type->attributeWildcard, baseType->attributeWildcard) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
NULL, type, NULL,
"The attribute wildcard is not a valid "
"subset of the wildcard in the base type %s",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (1);
}
if ((type->baseType != anyType) &&
(type->attributeWildcard->processContents <
baseType->attributeWildcard->processContents)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
NULL, type, NULL,
"The 'process contents' of the attribute wildcard is weaker than "
"the one in the base type %s",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (1);
}
}
} else if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) {
if ((baseType->attributeWildcard != NULL) &&
(baseType->attributeWildcard != type->attributeWildcard)) {
if (xmlSchemaIsWildcardNsConstraintSubset(
baseType->attributeWildcard, type->attributeWildcard) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_CT_EXTENDS_1_3,
NULL, type, NULL,
"The attribute wildcard is not a valid "
"superset of the one in the base type %s",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (1);
}
}
}
if (attrs != NULL) {
if (xmlSchemaBuildAttributeUsesOwned(ctxt, attrs,
&uses, &lastUse) == -1) {
return (-1);
}
}
if ((uses != NULL) && ((type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) == 0)) {
cur = uses;
while (cur != NULL) {
tmp = cur->next;
while (tmp != NULL) {
if ((xmlStrEqual(xmlSchemaGetAttrName(cur->attr),
xmlSchemaGetAttrName(tmp->attr))) &&
(xmlStrEqual(xmlSchemaGetAttrTargetNsURI(cur->attr ),
xmlSchemaGetAttrTargetNsURI(tmp->attr)))) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_CT_PROPS_CORRECT_4,
NULL, type, NULL, cur->attr,
"Duplicate attribute use %s specified",
xmlSchemaFormatNsUriLocal(&str,
xmlSchemaGetAttrTargetNsURI(tmp->attr),
xmlSchemaGetAttrName(tmp->attr))
);
FREE_AND_NULL(str)
break;
}
tmp = tmp->next;
}
cur = cur->next;
}
}
if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION) {
if (baseIsAnyType) {
type->attributeUses = uses;
} else {
int found;
const xmlChar *bEffValue;
int effFixed;
cur = uses;
while (cur != NULL) {
found = 0;
base = type->attributeUses;
while (base != NULL) {
if (xmlStrEqual(xmlSchemaGetAttrName(cur->attr),
xmlSchemaGetAttrName(base->attr)) &&
xmlStrEqual(xmlSchemaGetAttrTargetNsURI(cur->attr),
xmlSchemaGetAttrTargetNsURI(base->attr))) {
found = 1;
if ((cur->attr->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
(base->attr->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED)) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
NULL, type, NULL, cur->attr,
"The 'optional' use is inconsistent with a matching "
"'required' use of the base type", NULL);
} else if ((cur->attr->occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) &&
(base->attr->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
NULL, type, NULL,
"A matching attribute use for the 'required' "
"attribute use %s of the base type is missing",
xmlSchemaFormatNsUriLocal(&str,
xmlSchemaGetAttrTargetNsURI(base->attr),
xmlSchemaGetAttrName(base->attr)));
FREE_AND_NULL(str)
} else {
xmlSchemaGetEffectiveValueConstraint(base->attr, &effFixed,
&bEffValue, 0);
if ((bEffValue != NULL) &&
(effFixed == 1)) {
const xmlChar *rEffValue = NULL;
xmlSchemaGetEffectiveValueConstraint(base->attr, &effFixed,
&rEffValue, 0);
if ((effFixed == 0) ||
(! xmlStrEqual(rEffValue, bEffValue))) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
NULL, type, NULL, cur->attr,
"The effective value constraint of the "
"attribute use is inconsistent with "
"its correspondent of the base type",
NULL);
}
}
base->attr = cur->attr;
}
break;
}
base = base->next;
}
if (!found) {
if (cur->attr->occurs != XML_SCHEMAS_ATTR_USE_PROHIBITED) {
if ((type->attributeWildcard != NULL) &&
xmlSchemaMatchesWildcardNs(type->attributeWildcard,
cur->attr->targetNamespace))
found = 1;
if (!found) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
NULL, type, NULL, cur->attr,
"Neither a matching attribute use, "
"nor a matching wildcard in the base type does exist",
NULL);
} else {
tmp = cur;
if (prev != NULL)
prev->next = cur->next;
else
uses = cur->next;
cur = cur->next;
if (type->attributeUses == NULL) {
type->attributeUses = tmp;
} else
lastBaseUse->next = tmp;
lastBaseUse = tmp;
continue;
}
}
}
prev = cur;
cur = cur->next;
}
if (uses != NULL)
xmlSchemaFreeAttributeUseList(uses);
}
} else if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) {
if (uses != NULL) {
if (type->attributeUses == NULL) {
type->attributeUses = uses;
} else
lastBaseUse->next = uses;
}
} else {
type->attributeUses = uses;
}
if (type->attributeUses != NULL) {
cur = type->attributeUses;
prev = NULL;
while (cur != NULL) {
if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) {
tmp = cur->next;
while (tmp != NULL) {
if ((xmlStrEqual(xmlSchemaGetAttrName(cur->attr),
xmlSchemaGetAttrName(tmp->attr))) &&
(xmlStrEqual(xmlSchemaGetAttrTargetNsURI(cur->attr ),
xmlSchemaGetAttrTargetNsURI(tmp->attr)))) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_CT_PROPS_CORRECT_4,
NULL, type, NULL, tmp->attr,
"Duplicate attribute use specified", NULL);
break;
}
tmp = tmp->next;
}
}
if ((cur->attr->subtypes != NULL) &&
(xmlSchemaIsDerivedFromBuiltInType(ctxt, (xmlSchemaTypePtr) cur->attr, XML_SCHEMAS_ID))) {
if (id != NULL) {
xmlSchemaPAttrUseErr(ctxt,
XML_SCHEMAP_CT_PROPS_CORRECT_5,
NULL, type, NULL, cur->attr,
"There must not exist more than one attribute use, "
"declared of type 'ID' or derived from it",
NULL);
FREE_AND_NULL(str)
}
id = cur;
}
if (cur->attr->occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
tmp = cur;
if (prev == NULL)
type->attributeUses = cur->next;
else
prev->next = cur->next;
cur = cur->next;
xmlFree(tmp);
} else {
prev = cur;
cur = cur->next;
}
}
}
if ((baseType != NULL) && (!baseIsAnyType) &&
(baseType->type == XML_SCHEMA_TYPE_COMPLEX) &&
(baseType->contentType == XML_SCHEMA_CONTENT_UNKNOWN)) {
xmlSchemaPErr(ctxt, baseType->node, XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaBuildAttributeValidation: "
"attribute uses not builded on base type '%s'.\n",
baseType->name, NULL);
}
return (0);
}
static int
xmlSchemaTypeFinalContains(xmlSchemaPtr schema, xmlSchemaTypePtr type, int final)
{
int tfinal = final, tflags = type->flags;
if (type == NULL)
return (0);
if (type->flags & XML_SCHEMAS_TYPE_FINAL_DEFAULT) {
switch (final) {
case XML_SCHEMAS_TYPE_FINAL_RESTRICTION:
tfinal = XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION;
break;
case XML_SCHEMAS_TYPE_FINAL_EXTENSION:
tfinal = XML_SCHEMAS_FINAL_DEFAULT_EXTENSION;
break;
case XML_SCHEMAS_TYPE_FINAL_LIST:
tfinal = XML_SCHEMAS_FINAL_DEFAULT_LIST;
break;
case XML_SCHEMAS_TYPE_FINAL_UNION:
tfinal = XML_SCHEMAS_FINAL_DEFAULT_UNION;
break;
}
tflags = schema->flags;
}
if (tflags & tfinal)
return (1);
else
return (0);
}
static xmlSchemaTypeLinkPtr
xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type)
{
while (type != NULL) {
if (type->memberTypes != NULL)
return (type->memberTypes);
else
type = type->baseType;
}
return (NULL);
}
static xmlSchemaTypePtr
xmlSchemaGetListSimpleTypeItemType(xmlSchemaTypePtr type)
{
if ((type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) == 0)
return (NULL);
if (type->type == XML_SCHEMA_TYPE_BASIC)
return (xmlSchemaGetBuiltInListSimpleTypeItemType(type));
if (type->subtypes->type == XML_SCHEMA_TYPE_LIST)
return (type->subtypes->subtypes);
else {
return (xmlSchemaGetListSimpleTypeItemType(type->baseType));
}
}
static int
xmlSchemaCheckCOSSTDerivedOK(xmlSchemaPtr schema,
xmlSchemaTypePtr type,
xmlSchemaTypePtr baseType,
int subset)
{
if (type == baseType)
return (0);
if ((subset & XML_SCHEMAS_TYPE_FINAL_RESTRICTION) ||
(xmlSchemaTypeFinalContains(schema,
type->baseType, XML_SCHEMAS_TYPE_FINAL_RESTRICTION))) {
return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_1);
}
if (type->baseType == baseType) {
return (0);
}
if ((type->baseType != xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE)) &&
(xmlSchemaCheckCOSSTDerivedOK(schema, type->baseType, baseType, subset) == 0)) {
return (0);
}
if (((type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) ||
(type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION)) &&
(baseType == xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE))) {
return (0);
}
if (baseType->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
xmlSchemaTypeLinkPtr cur;
cur = baseType->memberTypes;
while (cur != NULL) {
if (xmlSchemaCheckCOSSTDerivedOK(schema, type,
cur->type, subset) == 0)
return (0);
cur = cur->next;
}
}
return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_2);
}
static int
xmlSchemaCheckSTPropsCorrect(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr baseType = type->baseType, anySimpleType,
anyType;
xmlChar *str = NULL;
anySimpleType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
anyType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
if (baseType == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_1,
NULL, type, NULL,
"No base type existent", NULL);
return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
}
if ((baseType->type != XML_SCHEMA_TYPE_SIMPLE) &&
((baseType->type != XML_SCHEMA_TYPE_BASIC) ||
(baseType == anyType))) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_1,
NULL, type, NULL,
"The base type %s is not a simple type",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
}
if ((baseType != anySimpleType) &&
(type->subtypes->type != XML_SCHEMA_TYPE_RESTRICTION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_1,
NULL, type, NULL,
"A type, derived by list or union, must have"
"the simple ur-type definition as base type, not %s",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
}
if (((type->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC) == 0) &&
((type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) == 0) &&
((type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) == 0)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_1,
NULL, type, NULL,
"The variety is absent", NULL);
return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
}
baseType = type->baseType;
while ((baseType != NULL) && (baseType->type != XML_SCHEMA_TYPE_BASIC)) {
if (baseType->contentType == XML_SCHEMA_CONTENT_UNKNOWN)
xmlSchemaTypeFixup(baseType, ctxt, NULL);
if (baseType == anySimpleType)
break;
else if (baseType == type) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_2,
NULL, type, NULL,
"The definition is circular", NULL);
return (XML_SCHEMAP_ST_PROPS_CORRECT_2);
}
baseType = baseType->baseType;
}
if (xmlSchemaTypeFinalContains(ctxt->schema, baseType,
XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_ST_PROPS_CORRECT_3,
NULL, type, NULL,
"The 'final' of its base type %s must not contain "
"'restriction'",
xmlSchemaFormatItemForReport(&str, NULL, baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_ST_PROPS_CORRECT_3);
}
return (0);
}
static int
xmlSchemaCheckCOSSTRestricts(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlChar *str = NULL;
if (type->type != XML_SCHEMA_TYPE_SIMPLE) {
xmlSchemaPErr(ctxt, type->node,
XML_ERR_INTERNAL_ERROR,
"xmlSchemaCheckDerivationValidSimpleRestriction: The given "
"type '%s' is not a user-derived simpleType.\n",
type->name, NULL);
return (-1);
}
if (type->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC) {
xmlSchemaTypePtr primitive;
if ((type->baseType->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
NULL, type, NULL,
"The base type %s is not an atomic simple type",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_1_1);
}
if (xmlSchemaTypeFinalContains(ctxt->schema, type->baseType,
XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
NULL, type, NULL,
"The final of its base type %s must not contain 'restriction'",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_1_2);
}
if (type->facets != NULL) {
xmlSchemaFacetPtr facet;
int ok = 1;
primitive = xmlSchemaGetPrimitiveType(type);
if (primitive == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_ERR_INTERNAL_ERROR,
"xmlSchemaCheckDerivationValidSimpleRestriction: failed "
"to get primitive type of type '%s'.\n",
type->name, NULL);
return (-1);
}
facet = type->facets;
do {
if (xmlSchemaIsBuiltInTypeFacet(primitive, facet->type) == 0) {
ok = 0;
xmlSchemaPIllegalFacetAtomicErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
NULL, type, primitive, facet);
}
facet = facet->next;
} while (facet != NULL);
if (ok == 0)
return (XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1);
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
xmlSchemaTypePtr itemType = NULL;
itemType = xmlSchemaGetListSimpleTypeItemType(type);
if (itemType == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_ERR_INTERNAL_ERROR,
"Internal error: xmlSchemaCheckDerivationValidSimpleRestriction: "
"failed to evaluate the item type of type '%s'.\n",
type->name, NULL);
return (-1);
}
if (((itemType->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC) == 0) &&
((itemType->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) == 0)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
NULL, type, NULL,
"The item type %s must have a variety of atomic or union",
xmlSchemaFormatItemForReport(&str, NULL, itemType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
} else if (itemType->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
xmlSchemaTypeLinkPtr member;
member = itemType->memberTypes;
while (member != NULL) {
if ((member->type->flags &
XML_SCHEMAS_TYPE_VARIETY_ATOMIC) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
NULL, type, NULL,
"The item type is a union type, but the "
"member type %s of this item type is not atomic",
xmlSchemaFormatItemForReport(&str, NULL, member->type, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
}
member = member->next;
}
}
if (type->baseType == xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE)) {
xmlSchemaFacetPtr facet;
if (xmlSchemaTypeFinalContains(ctxt->schema,
itemType, XML_SCHEMAS_TYPE_FINAL_LIST)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
NULL, type, NULL,
"The final of its item type %s must not contain 'list'",
xmlSchemaFormatItemForReport(&str, NULL, itemType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1);
}
if (type->facets != NULL) {
facet = type->facets;
do {
if (facet->type != XML_SCHEMA_FACET_WHITESPACE) {
xmlSchemaPIllegalFacetListUnionErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
NULL, type, facet);
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2);
}
facet = facet->next;
} while (facet != NULL);
}
} else {
if ((type->baseType->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
NULL, type, NULL,
"The base type %s must be a list type",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1);
}
if (xmlSchemaTypeFinalContains(ctxt->schema, type->baseType,
XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
NULL, type, NULL,
"The final of the base type %s must not contain 'restriction'",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2);
}
{
xmlSchemaTypePtr baseItemType;
baseItemType = xmlSchemaGetListSimpleTypeItemType(type->baseType);
if (baseItemType == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_ERR_INTERNAL_ERROR,
"xmlSchemaCheckDerivationValidSimpleRestriction: "
"List simple type '%s': Failed to "
"evaluate the item type of its base type '%s'.\n",
type->name, type->baseType->name);
return (-1);
}
if ((itemType != baseItemType) &&
(xmlSchemaCheckCOSSTDerivedOK(ctxt->schema, itemType,
baseItemType, 0) != 0)) {
xmlChar *strBIT = NULL, *strBT = NULL;
xmlSchemaPCustomErrExt(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
NULL, type, NULL,
"The item type %s is not validly derived from the "
"item type %s of the base type %s",
xmlSchemaFormatItemForReport(&str, NULL, itemType, NULL, 1),
xmlSchemaFormatItemForReport(&strBIT, NULL, baseItemType, NULL, 1),
xmlSchemaFormatItemForReport(&strBT, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
FREE_AND_NULL(strBIT)
FREE_AND_NULL(strBT)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3);
}
}
if (type->facets != NULL) {
xmlSchemaFacetPtr facet;
int ok = 1;
facet = type->facets;
do {
switch (facet->type) {
case XML_SCHEMA_FACET_LENGTH:
case XML_SCHEMA_FACET_MINLENGTH:
case XML_SCHEMA_FACET_MAXLENGTH:
case XML_SCHEMA_FACET_WHITESPACE:
case XML_SCHEMA_FACET_PATTERN:
case XML_SCHEMA_FACET_ENUMERATION:
break;
default: {
xmlSchemaPIllegalFacetListUnionErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
NULL, type, facet);
ok = 0;
}
}
facet = facet->next;
} while (facet != NULL);
if (ok == 0)
return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4);
}
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
xmlSchemaTypeLinkPtr member;
member = type->memberTypes;
while (member != NULL) {
if (((member->type->flags &
XML_SCHEMAS_TYPE_VARIETY_ATOMIC) == 0) &&
((member->type->flags &
XML_SCHEMAS_TYPE_VARIETY_LIST) == 0)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
NULL, type, NULL,
"The member type %s is neither an atomic, nor a list type",
xmlSchemaFormatItemForReport(&str, NULL, member->type, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_1);
}
member = member->next;
}
if (type->baseType == xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE)) {
member = type->memberTypes;
while (member != NULL) {
if (xmlSchemaTypeFinalContains(ctxt->schema, member->type,
XML_SCHEMAS_TYPE_FINAL_UNION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
NULL, type, NULL,
"The final of member type %s contains 'union'",
xmlSchemaFormatItemForReport(&str, NULL, member->type, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1);
}
member = member->next;
}
if (type->facetSet != NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
NULL, type, NULL,
"No facets allowed", NULL);
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2);
}
} else {
if ((type->baseType->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
NULL, type, NULL,
"The base type %s is not a union type",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1);
}
if (xmlSchemaTypeFinalContains(ctxt->schema, type->baseType,
XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
NULL, type, NULL,
"The final of its base type %s must not contain 'restriction'",
xmlSchemaFormatItemForReport(&str, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2);
}
{
xmlSchemaTypeLinkPtr baseMember;
if (type->memberTypes != NULL) {
member = type->memberTypes;
baseMember = xmlSchemaGetUnionSimpleTypeMemberTypes(type->baseType);
if ((member == NULL) && (baseMember != NULL)) {
xmlSchemaPErr(ctxt, type->node,
XML_SCHEMAP_INTERNAL,
"Internal error: "
"xmlSchemaCheckDerivationValidSimpleRestriction "
"(3.3.2.3), union simple type '%s', unequal number "
"of member types in the base type\n",
type->name, NULL);
}
while (member != NULL) {
if (baseMember == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_SCHEMAP_INTERNAL,
"Internal error: "
"xmlSchemaCheckDerivationValidSimpleRestriction "
"(3.3.2.3), union simple type '%s', unequal number "
"of member types in the base type.\n",
type->name, NULL);
}
if ((member->type != baseMember->type) &&
(xmlSchemaCheckCOSSTDerivedOK(ctxt->schema,
member->type, baseMember->type, 0) != 0)) {
xmlChar *strBMT = NULL, *strBT = NULL;
xmlSchemaPCustomErrExt(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
NULL, type, NULL,
"The member type %s is not validly derived from its "
"corresponding member type %s of the base type %s",
xmlSchemaFormatItemForReport(&str, NULL, member->type, NULL, 1),
xmlSchemaFormatItemForReport(&strBMT, NULL, baseMember->type, NULL, 1),
xmlSchemaFormatItemForReport(&strBT, NULL, type->baseType, NULL, 1));
FREE_AND_NULL(str)
FREE_AND_NULL(strBMT)
FREE_AND_NULL(strBT)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3);
}
member = member->next;
baseMember = baseMember->next;
}
}
}
if (type->facets != NULL) {
xmlSchemaFacetPtr facet;
int ok = 1;
facet = type->facets;
do {
if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
(facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
xmlSchemaPIllegalFacetListUnionErr(ctxt,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
NULL, type, facet);
ok = 0;
}
facet = facet->next;
} while (facet != NULL);
if (ok == 0)
return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4);
}
}
}
return (0);
}
static int
xmlSchemaCheckSRCSimpleType(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
if (type->subtypes == NULL) {
xmlSchemaPErr(ctxt, type->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckSRCSimpleType, "
"no subtype on simple type '%s'.\n",
type->name, NULL);
return (-1);
}
if ((xmlSchemaCheckSTPropsCorrect(ctxt, type) != 0) ||
(xmlSchemaCheckCOSSTRestricts(ctxt, type) != 0)) {
return (XML_SCHEMAP_SRC_SIMPLE_TYPE_1);
}
if (type->subtypes->type == XML_SCHEMA_TYPE_RESTRICTION) {
} else if (type->subtypes->type == XML_SCHEMA_TYPE_LIST) {
if (((type->subtypes->base == NULL) &&
(type->baseType == NULL)) ||
((type->subtypes->base != NULL) &&
(type->subtypes->baseType != NULL))) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
NULL, type, NULL,
"Either the attribute 'itemType' or the <simpleType> child "
"must be present on the <list> child ", NULL);
return (XML_SCHEMAP_SRC_SIMPLE_TYPE_3);
}
} else if (type->subtypes->type == XML_SCHEMA_TYPE_UNION) {
xmlSchemaTypeLinkPtr member;
xmlSchemaTypePtr ancestor, anySimpleType;
anySimpleType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
member = type->memberTypes;
while (member != NULL) {
ancestor = member->type;
while ((ancestor != NULL) && (ancestor->type != XML_SCHEMA_TYPE_BASIC)) {
if (ancestor->contentType == XML_SCHEMA_CONTENT_UNKNOWN)
xmlSchemaTypeFixup(ancestor, ctxt, NULL);
if (ancestor == anySimpleType)
break;
else if (ancestor == type) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
NULL, type, NULL,
"The definition is circular", NULL);
return (XML_SCHEMAP_SRC_SIMPLE_TYPE_4);
} else if (ancestor->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
}
ancestor = ancestor->baseType;
}
member = member->next;
}
}
return (0);
}
#if 0
static int
xmlSchemaCheckCVCSimpleType(xmlSchemaValidCtxtPtr ctxt,
const xmlChar * value,
xmlSchemaTypePtr type,
int fireErrors)
{
int ret;
ret = xmlSchemaValidateSimpleTypeValue(ctxt, type, value,
fireErrors, 1, 1, 1);
return (ret);
return (0);
}
#endif
static int
xmlSchemaCreatePCtxtOnVCtxt(xmlSchemaValidCtxtPtr vctxt)
{
if (vctxt->pctxt == NULL) {
vctxt->pctxt =xmlSchemaNewParserCtxtUseDict("*", vctxt->schema->dict);
if (vctxt->pctxt == NULL) {
xmlSchemaVErr(vctxt, NULL,
XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaCreatePCtxtOnVCtxt, "
"failed to create a temp. parser context.\n",
NULL, NULL);
return (-1);
}
xmlSchemaSetParserErrors(vctxt->pctxt, vctxt->error, vctxt->warning, NULL);
}
return (0);
}
static int
xmlSchemaCreateVCtxtOnPCtxt(xmlSchemaParserCtxtPtr ctxt)
{
if (ctxt->vctxt == NULL) {
ctxt->vctxt = xmlSchemaNewValidCtxt(NULL);
if (ctxt->vctxt == NULL) {
xmlSchemaPErr(ctxt, NULL,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCreatePCtxtOnVCtxt, "
"failed to create a temp. validation context.\n",
NULL, NULL);
return (-1);
}
xmlSchemaSetValidErrors(ctxt->vctxt, ctxt->error, ctxt->warning, NULL);
}
return (0);
}
static int
xmlSchemaCheckCOSValidDefault(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaValidCtxtPtr vctxt,
xmlSchemaTypePtr type,
const xmlChar *value,
xmlNodePtr node)
{
int ret = 0;
if ((pctxt == NULL) || (vctxt == NULL)) {
xmlSchemaPErr(pctxt, node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckCOSValidDefault, "
"bad arguments: the parser and/or validation context is "
"missing.\n",
NULL, NULL);
return (-1);
}
if IS_COMPLEX_TYPE(type) {
if ((type->contentType != XML_SCHEMA_CONTENT_SIMPLE) &&
(type->contentType != XML_SCHEMA_CONTENT_BASIC) &&
(type->contentType != XML_SCHEMA_CONTENT_MIXED)) {
xmlSchemaPSimpleTypeErr(pctxt,
XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
NULL, NULL, node,
type, NULL, NULL,
"If the type of a constraint value is complex, its content "
"type must be mixed or a simple type",
NULL, NULL);
return(XML_SCHEMAP_COS_VALID_DEFAULT_2_1);
}
if (type->contentType == XML_SCHEMA_CONTENT_MIXED) {
return (0);
}
}
vctxt->node = node;
vctxt->cur = NULL;
ret = xmlSchemaValidateSimpleTypeValue(vctxt, type, value, 1, 1, 1, 0);
if (ret < 0) {
xmlSchemaPErr(pctxt, node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckCOSValidDefault, "
"while validating a value constaint value.\n",
NULL, NULL);
}
return (ret);
}
#if 0
static xmlSchemaTypePtr
xmlSchemaGetSTContentOfCT(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr orig = type, anyType;
anyType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
while ((type != NULL) && (type != anyType) &&
(type->type == XML_SCHEMA_TYPE_COMPLEX)) {
if (type->type == XML_SCHEMA_TYPE_SIMPLE)
return(type);
type = type->baseType;
}
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, orig, NULL,
"Internal error: xmlSchemaGetSTContentTypeOfCT, "
"no simple type for the content of complex type '%s' could be "
"computed", orig->name);
return (NULL);
}
static int
xmlSchemaCheckCOSCTExtends(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr base;
base = type->baseType;
if (base == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaCheckCOSCTExtends, "
"the complex type '%s' has no base type", type->name);
return (-1);
}
if (base->type == XML_SCHEMA_TYPE_COMPLEX) {
if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_COS_CT_EXTENDS_1_1,
NULL, type, NULL,
"The 'final' of the base type definition "
"contains extension", NULL);
return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
}
} else {
}
}
static int
xmlSchemaCheckSRCCT(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr base, content;
int OK = 0;
base = type->baseType;
if (base == NULL) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL, NULL, type, NULL,
"Internal error: xmlSchemaCheckSRCCT, '%s', no base type",
type->name);
return (-1);
}
if (type->subtypes != NULL) {
if (type->subtypes->type == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
if IS_COMPLEX_TYPE(base) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"The base type is not a complex type", NULL);
return (XML_SCHEMAP_SRC_CT_1);
}
} else if (type->subtypes->type == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
if IS_SIMPLE_TYPE(base) {
if (type->flags &
XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"A complex type (simple content) cannot restrict "
"an other simple type",
NULL);
return (XML_SCHEMAP_SRC_CT_1);
}
OK = 1;
} else {
if (base->contentType = XML_SCHEMA_CONTENT_MIXED) {
if ((type->flags &
XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION) == 0) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"A complex type (simple content) cannot "
"extend an other complex type which has a "
"content type of: 'mixed' and emptiable particle",
NULL);
return (XML_SCHEMAP_SRC_CT_1);
}
if (type->subtypes->subtypes == NULL) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaCheckSRCCT, "
"'%s', <simpleContent> has no <restriction>",
type->name);
return (-1);
}
if (type->subtypes->subtypes->type !=
XML_SCHEMA_TYPE_SIMPLE) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"A <simpleType> is expected among the children "
"of <restriction>", NULL);
return (XML_SCHEMAP_SRC_CT_1);
}
OK = 1;
} else {
if (base->contentType == XML_SCHEMA_CONTENT_ELEMENTS) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"A complex type (simple content) cannot "
"be derived from the complex type '%s'",
base->name);
return (XML_SCHEMAP_SRC_CT_1);
}
content = base->contentTypeDef;
if (content == NULL) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaCheckSRCCT, "
"'%s', base type has no content type",
type->name);
return (-1);
}
if (content->type != XML_SCHEMA_TYPE_SIMPLE) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_CT_1,
NULL, type, NULL,
"A complex type (simple content) cannot "
"be derived from the complex type '%s'",
base->name);
return (XML_SCHEMAP_SRC_CT_1);
}
}
}
}
}
}
#endif
static void
xmlSchemaGroupDefFixup(xmlSchemaTypePtr group,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
group->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
if ((group->ref != NULL) && (group->subtypes == NULL)) {
xmlSchemaTypePtr groupDef;
groupDef = xmlSchemaGetGroup(ctxt->schema, group->ref,
group->refNs);
if (groupDef == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, group, NULL,
"ref", group->ref, group->refNs,
XML_SCHEMA_TYPE_GROUP, NULL);
return;
}
group->subtypes = groupDef;
}
}
#if 0
static int
xmlSchemaComputeContentType(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr base, res = NULL;
base = type->baseType;
if (base == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"the complex type '%s' has no base type", type->name);
return (-1);
}
if (IS_ANYTYPE(base) || (type->subtypes->type ==
XML_SCHEMA_TYPE_COMPLEX_CONTENT)) {
xmlSchemaTypePtr start;
if (type->flags & XML_SCHEMAS_TYPE_MIXED)
type->contentType = XML_SCHEMA_CONTENT_MIXED;
if (IS_ANYTYPE(base))
start = type;
else
start = type->subtypes;
} else {
xmlSchemaTypePtr baseContentItem;
if IS_COMPLEX_TYPE(base) {
if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION) {
if (base->contentType == XML_SCHEMA_CONTENT_MIXED) {
res = type->subtypes->subtypes;
if (res == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (restricting): <simpleContent> has no "
"<restriction>",
type->name);
return (-1);
}
res->subtypes;
if (res == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (restricting): <restriction> has no "
"mandatory <simpleType>",
type->name);
return (-1);
}
} else {
baseContentItem = base->contentTypeDef;
if (baseContentItem == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (restricting), the base type has no "
"content type", type->name);
return (-1);
}
if IS_SIMPLE_TYPE(baseContentItem) {
res = type->subtypes->subtypes;
if (res == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (restricting): <simpleType> has no "
"<restriction>", type->name);
return (-1);
}
res = res->subtypes;
if (res == NULL) {
res = baseContentItem;
}
}
}
} else {
res = base->contentTypeDef;
if (res == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (extending), the base type has no content "
"type", type->name);
return (-1);
}
if (! IS_SIMPLE_TYPE(res)) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"CT '%s' (extending), the content type of the "
"base is not a simple type", type->name);
return (-1);
}
}
} else
if (type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) {
res = base;
}
type->contentTypeDef = res;
if (res == NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_INTERNAL,
NULL, type, NULL,
"Internal error: xmlSchemaGetContentType, "
"'%s', the content type could not be determined",
type->name);
return (-1);
}
}
}
#endif
static void
xmlSchemaTypeFixup(xmlSchemaTypePtr item,
xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
{
xmlSchemaTypePtr ctxtType;
if (item == NULL)
return;
if (ctxt->ctxtType == NULL) {
switch (item->type) {
case XML_SCHEMA_TYPE_SIMPLE_CONTENT:
case XML_SCHEMA_TYPE_COMPLEX_CONTENT:
case XML_SCHEMA_TYPE_UNION:
case XML_SCHEMA_TYPE_RESTRICTION:
case XML_SCHEMA_TYPE_EXTENSION:
return;
default:
break;
}
}
if (name == NULL)
name = item->name;
if (item->contentType == XML_SCHEMA_CONTENT_UNKNOWN) {
switch (item->type) {
case XML_SCHEMA_TYPE_SIMPLE_CONTENT:{
if (item->subtypes != NULL) {
if (item->subtypes->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN) {
xmlSchemaTypeFixup(item->subtypes, ctxt,
NULL);
}
item->contentType =
XML_SCHEMA_CONTENT_SIMPLE;
}
break;
}
case XML_SCHEMA_TYPE_RESTRICTION:{
xmlSchemaTypePtr base = NULL;
ctxt->ctxtType->flags |=
XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
if (item->baseType != NULL)
base = item->baseType;
else if (item->base != NULL) {
base =
xmlSchemaGetType(ctxt->schema, item->base,
item->baseNs);
if (base == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, NULL,
(xmlNodePtr) xmlSchemaGetPropNode(item->node, "base"),
"base", item->base, item->baseNs,
XML_SCHEMA_TYPE_BASIC, "type definition");
} else if (base->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN) {
xmlSchemaTypeFixup(base, ctxt, NULL);
}
}
ctxt->ctxtType->baseType = base;
if (ctxt->ctxtType->type == XML_SCHEMA_TYPE_COMPLEX) {
if (item->subtypes == NULL)
item->contentType = XML_SCHEMA_CONTENT_EMPTY;
else if ((item->subtypes->subtypes == NULL) &&
((item->subtypes->type ==
XML_SCHEMA_TYPE_ALL)
|| (item->subtypes->type ==
XML_SCHEMA_TYPE_SEQUENCE)))
item->contentType = XML_SCHEMA_CONTENT_EMPTY;
else if ((item->subtypes->type ==
XML_SCHEMA_TYPE_CHOICE)
&& (item->subtypes->subtypes == NULL))
item->contentType = XML_SCHEMA_CONTENT_EMPTY;
else {
item->contentType =
XML_SCHEMA_CONTENT_ELEMENTS;
}
} else {
}
break;
}
case XML_SCHEMA_TYPE_EXTENSION:{
xmlSchemaTypePtr base = NULL;
xmlSchemaContentType explicitContentType;
ctxt->ctxtType->flags |=
XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION;
if (item->recurse) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_UNKNOWN_BASE_TYPE,
NULL, item, item->node,
"This item is circular", NULL);
return;
}
if (item->base != NULL) {
base =
xmlSchemaGetType(ctxt->schema, item->base,
item->baseNs);
if (base == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, item, item->node,
"base", item->base, item->baseNs,
XML_SCHEMA_TYPE_BASIC, "type definition");
} else if (base->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN) {
item->recurse = 1;
xmlSchemaTypeFixup(base, ctxt, NULL);
item->recurse = 0;
}
ctxt->ctxtType->baseType = base;
item->baseType = base;
}
if ((item->subtypes != NULL) &&
(item->subtypes->contentType == XML_SCHEMA_CONTENT_UNKNOWN))
xmlSchemaTypeFixup(item->subtypes, ctxt, NULL);
explicitContentType = XML_SCHEMA_CONTENT_ELEMENTS;
if (item->subtypes == NULL)
explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
else if ((item->subtypes->subtypes == NULL) &&
((item->subtypes->type ==
XML_SCHEMA_TYPE_ALL)
|| (item->subtypes->type ==
XML_SCHEMA_TYPE_SEQUENCE)))
explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
else if ((item->subtypes->type ==
XML_SCHEMA_TYPE_CHOICE)
&& (item->subtypes->subtypes == NULL))
explicitContentType = XML_SCHEMA_CONTENT_EMPTY;
if (base != NULL) {
if (explicitContentType == XML_SCHEMA_CONTENT_EMPTY) {
item->contentType = base->contentType;
} else if (base->contentType ==
XML_SCHEMA_CONTENT_EMPTY) {
item->contentType =
XML_SCHEMA_CONTENT_ELEMENTS;
} else {
item->contentType =
XML_SCHEMA_CONTENT_ELEMENTS;
}
}
break;
}
case XML_SCHEMA_TYPE_COMPLEX:{
ctxtType = ctxt->ctxtType;
ctxt->ctxtType = item;
if (item->subtypes == NULL)
item->contentType = XML_SCHEMA_CONTENT_EMPTY;
if ((item->subtypes == NULL) ||
((item->subtypes->type !=
XML_SCHEMA_TYPE_SIMPLE_CONTENT) &&
(item->subtypes->type !=
XML_SCHEMA_TYPE_COMPLEX_CONTENT))) {
item->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
item->flags |=
XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
item->contentType = item->baseType->contentType;
}
if ((item->subtypes != NULL) &&
(item->subtypes->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN)) {
xmlSchemaTypeFixup(item->subtypes, ctxt, NULL);
}
if (item->flags & XML_SCHEMAS_TYPE_MIXED) {
item->contentType = XML_SCHEMA_CONTENT_MIXED;
} else if (item->subtypes != NULL) {
item->contentType =
item->subtypes->contentType;
}
xmlSchemaBuildAttributeValidation(ctxt, item);
ctxt->ctxtType = ctxtType;
break;
}
case XML_SCHEMA_TYPE_COMPLEX_CONTENT:{
if (item->subtypes == NULL) {
item->contentType = XML_SCHEMA_CONTENT_EMPTY;
if (item->flags & XML_SCHEMAS_TYPE_MIXED)
item->contentType =
XML_SCHEMA_CONTENT_MIXED;
} else {
if (item->flags & XML_SCHEMAS_TYPE_MIXED) {
item->contentType =
XML_SCHEMA_CONTENT_MIXED;
} else {
xmlSchemaTypeFixup(item->subtypes, ctxt,
NULL);
if (item->subtypes != NULL)
item->contentType =
item->subtypes->contentType;
}
}
break;
}
case XML_SCHEMA_TYPE_SIMPLE:
ctxtType = ctxt->ctxtType;
item->contentType = XML_SCHEMA_CONTENT_SIMPLE;
if (item->subtypes->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN) {
ctxt->ctxtType = item;
xmlSchemaTypeFixup(item->subtypes, ctxt, NULL);
}
if ((item->baseType != NULL) &&
(item->baseType->contentType ==
XML_SCHEMA_CONTENT_UNKNOWN)) {
ctxt->ctxtType = item;
xmlSchemaTypeFixup(item->baseType, ctxt, NULL);
}
if (item->subtypes->type ==
XML_SCHEMA_TYPE_LIST) {
item->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
item->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
} else if (item->subtypes->type ==
XML_SCHEMA_TYPE_UNION) {
item->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
item->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
} else if (item->subtypes->type ==
XML_SCHEMA_TYPE_RESTRICTION) {
xmlSchemaFacetLinkPtr facet, cur, last = NULL;
if (item->baseType != NULL) {
if (item->baseType->flags &
XML_SCHEMAS_TYPE_VARIETY_ATOMIC)
item->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
else if (item->baseType->flags &
XML_SCHEMAS_TYPE_VARIETY_LIST)
item->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
else if (item->baseType->flags &
XML_SCHEMAS_TYPE_VARIETY_UNION)
item->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
if (item->baseType->facetSet != NULL) {
last = item->facetSet;
if (last != NULL)
while (last->next != NULL)
last = last->next;
cur = item->baseType->facetSet;
for (; cur != NULL; cur = cur->next) {
if (cur->facet->type ==
XML_SCHEMA_FACET_PATTERN)
continue;
facet = NULL;
if ((item->facetSet != NULL) &&
(cur->facet->type !=
XML_SCHEMA_FACET_PATTERN) &&
(cur->facet->type !=
XML_SCHEMA_FACET_ENUMERATION)) {
facet = item->facetSet;
do {
if (cur->facet->type ==
facet->facet->type)
break;
facet = facet->next;
} while (facet != NULL);
}
if (facet == NULL) {
facet = (xmlSchemaFacetLinkPtr)
xmlMalloc(sizeof(xmlSchemaFacetLink));
if (facet == NULL) {
xmlSchemaPErrMemory(ctxt,
"fixing simpleType", NULL);
return;
}
facet->facet = cur->facet;
facet->next = NULL;
if (last == NULL)
item->facetSet = facet;
else
last->next = facet;
last = facet;
}
}
}
}
}
xmlSchemaCheckSRCSimpleType(ctxt, item);
ctxt->ctxtType = ctxtType;
break;
case XML_SCHEMA_TYPE_SEQUENCE:
case XML_SCHEMA_TYPE_ALL:
case XML_SCHEMA_TYPE_CHOICE:
item->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
break;
case XML_SCHEMA_TYPE_GROUP:
break;
case XML_SCHEMA_TYPE_LIST:
xmlSchemaParseListRefFixup(item, ctxt);
item->contentType = XML_SCHEMA_CONTENT_SIMPLE;
break;
case XML_SCHEMA_TYPE_UNION:
xmlSchemaParseUnionRefCheck(item, ctxt);
item->contentType = XML_SCHEMA_CONTENT_SIMPLE;
break;
case XML_SCHEMA_TYPE_BASIC:
case XML_SCHEMA_TYPE_ANY:
case XML_SCHEMA_TYPE_FACET:
case XML_SCHEMA_TYPE_UR:
case XML_SCHEMA_TYPE_ELEMENT:
case XML_SCHEMA_TYPE_ATTRIBUTE:
case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
case XML_SCHEMA_TYPE_NOTATION:
case XML_SCHEMA_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:
item->contentType = XML_SCHEMA_CONTENT_SIMPLE;
if (item->subtypes != NULL)
xmlSchemaTypeFixup(item->subtypes, ctxt, NULL);
break;
}
}
#ifdef DEBUG_TYPE
if (item->node != NULL) {
xmlGenericError(xmlGenericErrorContext,
"Type of %s : %s:%d :", name,
item->node->doc->URL,
xmlGetLineNo(item->node));
} else {
xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
}
switch (item->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_BASIC:
xmlGenericError(xmlGenericErrorContext, "basic\n");
break;
default:
xmlGenericError(xmlGenericErrorContext,
"not registered !!!\n");
break;
}
#endif
}
int
xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
{
xmlSchemaTypePtr nonNegativeIntegerType = NULL;
int ret = 0, reuseValCtxt = 0;
if ((facet == NULL) || (typeDecl == NULL))
return(-1);
if (nonNegativeIntegerType == NULL) {
nonNegativeIntegerType =
xmlSchemaGetBuiltInType(XML_SCHEMAS_NNINTEGER);
}
switch (facet->type) {
case XML_SCHEMA_FACET_MININCLUSIVE:
case XML_SCHEMA_FACET_MINEXCLUSIVE:
case XML_SCHEMA_FACET_MAXINCLUSIVE:
case XML_SCHEMA_FACET_MAXEXCLUSIVE:
case XML_SCHEMA_FACET_ENUMERATION: {
xmlSchemaValidCtxtPtr vctxt;
xmlSchemaTypePtr base;
if (typeDecl->type != XML_SCHEMA_TYPE_BASIC) {
base = typeDecl->baseType;
if (base == NULL) {
xmlSchemaPErr(ctxt, typeDecl->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckFacet, "
"the type '%s' has no base type.\n",
typeDecl->name, NULL);
return (-1);
}
} else
base = typeDecl;
if (ctxt != NULL) {
reuseValCtxt = 1;
if (ctxt->vctxt == NULL) {
if (xmlSchemaCreateVCtxtOnPCtxt(ctxt) == -1)
return (-1);
}
vctxt = ctxt->vctxt;
} else {
vctxt = xmlSchemaNewValidCtxt(NULL);
if (vctxt == NULL) {
xmlSchemaPErr(ctxt, typeDecl->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckFacet, "
"creating a new validation context.\n",
NULL, NULL);
return (-1);
}
}
vctxt->node = facet->node;
vctxt->cur = NULL;
ret = xmlSchemaValidateSimpleTypeValue(vctxt, base,
facet->value, 0, 1, 1, 0);
facet->val = vctxt->value;
vctxt->value = NULL;
if (ret > 0) {
if (ctxt != NULL) {
xmlSchemaPErrExt(ctxt, facet->node,
XML_SCHEMAP_INVALID_FACET,
NULL, NULL, NULL,
"Type definition '%s': The value '%s' of the "
"facet '%s' is not valid.\n",
name, facet->value,
BAD_CAST xmlSchemaFacetTypeToString(facet->type),
NULL, NULL);
}
ret = -1;
} else if (ret < 0) {
xmlSchemaPErrExt(ctxt, facet->node,
XML_SCHEMAP_INTERNAL,
NULL, NULL, NULL,
"Internal error: xmlSchemaCheckFacet, "
"failed to validate the value '%s' name of the "
"facet '%s' against the base type '%s'.\n",
facet->value,
BAD_CAST xmlSchemaFacetTypeToString(facet->type),
base->name, NULL, NULL);
ret = -1;
}
if (reuseValCtxt == 0)
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,
"Type definition '%s': The value '%s' of the "
"facet 'pattern' is not valid.\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) {
if (ctxt != NULL) {
xmlSchemaPErrExt(ctxt, facet->node,
XML_SCHEMAP_INVALID_FACET_VALUE,
NULL, NULL, NULL,
"Type definition '%s': The value '%s' of the "
"facet '%s' is not valid.\n",
name, facet->value,
BAD_CAST xmlSchemaFacetTypeToString(facet->type),
NULL, NULL);
}
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,
"Type definition '%s': The value '%s' of the "
"facet 'whiteSpace' is not valid.\n",
name, facet->value);
}
ret = -1;
}
}
default:
break;
}
return (ret);
}
static void
xmlSchemaCheckDefaults(xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
{
if (name == NULL)
name = typeDecl->name;
if (typeDecl->facets != NULL) {
xmlSchemaFacetPtr facet = typeDecl->facets;
while (facet != NULL) {
xmlSchemaCheckFacet(facet, typeDecl, ctxt, name);
facet = facet->next;
}
}
}
static xmlSchemaTypePtr
xmlSchemaGetCircModelGrDefRef(xmlSchemaTypePtr ctxtGrDef,
xmlSchemaTypePtr gr)
{
xmlSchemaTypePtr circ = NULL;
int marked;
while (gr != NULL) {
if (((gr->type == XML_SCHEMA_TYPE_GROUP) ||
(gr->type == XML_SCHEMA_TYPE_ALL) ||
(gr->type == XML_SCHEMA_TYPE_SEQUENCE) ||
(gr->type == XML_SCHEMA_TYPE_CHOICE)) &&
(gr->subtypes != NULL)) {
marked = 0;
if ((gr->type == XML_SCHEMA_TYPE_GROUP) &&
(gr->ref != NULL)) {
if (gr->subtypes == ctxtGrDef)
return (gr);
else if (gr->subtypes->flags &
XML_SCHEMAS_TYPE_MARKED) {
gr = gr->next;
continue;
} else {
gr->subtypes->flags |= XML_SCHEMAS_TYPE_MARKED;
marked = 1;
}
if (gr->subtypes->subtypes != NULL)
circ = xmlSchemaGetCircModelGrDefRef(ctxtGrDef,
gr->subtypes->subtypes);
if (marked)
gr->subtypes->flags ^= XML_SCHEMAS_TYPE_MARKED;
if (circ != NULL)
return (circ);
} else {
circ = xmlSchemaGetCircModelGrDefRef(ctxtGrDef,
(xmlSchemaTypePtr) gr->subtypes);
if (circ != NULL)
return (circ);
}
}
gr = gr->next;
}
return (NULL);
}
static void
xmlSchemaCheckGroupDefCircular(xmlSchemaTypePtr modelGrDef,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
if ((modelGrDef->type != XML_SCHEMA_TYPE_GROUP) ||
((modelGrDef->flags & XML_SCHEMAS_TYPE_GLOBAL) == 0) ||
(modelGrDef->subtypes == NULL))
return;
else {
xmlSchemaTypePtr circ;
circ = xmlSchemaGetCircModelGrDefRef(modelGrDef, modelGrDef->subtypes);
if (circ != NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_MG_PROPS_CORRECT_2,
NULL, NULL, circ->node,
"Circular reference to the model group definition '%s' "
"defined", modelGrDef->name);
circ->subtypes = NULL;
}
}
}
static xmlSchemaAttributeGroupPtr
xmlSchemaGetCircAttrGrRef(xmlSchemaAttributeGroupPtr ctxtGr,
xmlSchemaAttributePtr attr)
{
xmlSchemaAttributeGroupPtr circ = NULL, gr;
int marked;
while (attr != NULL) {
marked = 0;
if (attr->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
gr = (xmlSchemaAttributeGroupPtr) attr;
if (gr->refItem != NULL) {
if (gr->refItem == ctxtGr)
return (gr);
else if (gr->refItem->flags &
XML_SCHEMAS_ATTRGROUP_MARKED) {
attr = attr->next;
continue;
} else {
gr->refItem->flags |= XML_SCHEMAS_ATTRGROUP_MARKED;
marked = 1;
}
}
if (gr->attributes != NULL)
circ = xmlSchemaGetCircAttrGrRef(ctxtGr, gr->attributes);
if (marked)
gr->refItem->flags ^= XML_SCHEMAS_ATTRGROUP_MARKED;
if (circ != NULL)
return (circ);
}
attr = attr->next;
}
return (NULL);
}
static void
xmlSchemaCheckAttributeGroupCircular(xmlSchemaAttributeGroupPtr attrGr,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
if (((attrGr->flags & XML_SCHEMAS_ATTRGROUP_GLOBAL) == 0) ||
(attrGr->attributes == NULL))
return;
else {
xmlSchemaAttributeGroupPtr circ;
circ = xmlSchemaGetCircAttrGrRef(attrGr, attrGr->attributes);
if (circ != NULL) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
NULL, NULL, circ->node,
"Circular reference to the attribute group '%s' "
"defined", attrGr->name);
circ->attributes = NULL;
circ->refItem = NULL;
}
}
}
static void
xmlSchemaAttrGrpFixup(xmlSchemaAttributeGroupPtr attrgrp,
xmlSchemaParserCtxtPtr ctxt, const xmlChar * name)
{
if (name == NULL)
name = attrgrp->name;
if (attrgrp->attributes != NULL)
return;
if (attrgrp->ref != NULL) {
xmlSchemaAttributeGroupPtr ref;
ref = xmlSchemaGetAttributeGroup(ctxt->schema, attrgrp->ref,
attrgrp->refNs);
if (ref == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) attrgrp, attrgrp->node,
"ref", attrgrp->ref, attrgrp->refNs,
XML_SCHEMA_TYPE_ATTRIBUTEGROUP, NULL);
return;
}
attrgrp->refItem = ref;
xmlSchemaAttrGrpFixup(ref, ctxt, NULL);
attrgrp->attributes = ref->attributes;
attrgrp->attributeWildcard = ref->attributeWildcard;
}
}
static void
xmlSchemaCheckAttrValConstr(xmlSchemaAttributePtr item,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
if (item->defValue != NULL) {
int ret;
xmlNodePtr node;
xmlSchemaTypePtr type;
if (item->subtypes == NULL) {
xmlSchemaPErr(ctxt, item->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckAttrValConstr, "
"type is missing... skipping validation of "
"value constraint", NULL, NULL);
return;
}
type = item->subtypes;
if (ctxt->vctxt == NULL) {
if (xmlSchemaCreateVCtxtOnPCtxt(ctxt) == -1) {
xmlSchemaPErr(ctxt, item->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckAttrValConstr, "
"creating a new validation context.\n",
NULL, NULL);
return;
}
}
if (item->flags & XML_SCHEMAS_ATTR_FIXED)
node = (xmlNodePtr) xmlHasProp(item->node, BAD_CAST "fixed");
else
node = (xmlNodePtr) xmlHasProp(item->node, BAD_CAST "default");
ctxt->vctxt->node = node;
ctxt->vctxt->cur = NULL;
ret = xmlSchemaValidateSimpleTypeValue(ctxt->vctxt, type,
item->defValue, 0, 1, 1, 0);
if (ret == 0) {
item->defVal = ctxt->vctxt->value;
ctxt->vctxt->value = NULL;
} else if (ret > 0) {
if (ctxt != NULL) {
xmlSchemaPSimpleTypeErr(ctxt,
XML_SCHEMAP_A_PROPS_CORRECT_2,
NULL, NULL, node,
type, NULL, item->defValue,
NULL, NULL, NULL);
}
} else if (ret < 0) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
NULL, NULL, node,
"Internal error: xmlSchemaAttrCheckValConstr, "
"failed to validate the value constraint of the "
"attribute decl/use against the type '%s'",
type->name);
}
}
}
#if 0
static int
xmlSchemaCheckElemPropsCorrect(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaElementPtr edecl)
{
}
#endif
static void
xmlSchemaCheckElemValConstr(xmlSchemaElementPtr decl,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
if (decl->value != NULL) {
int ret;
xmlNodePtr node = NULL;
xmlSchemaTypePtr type;
if (decl->subtypes == NULL) {
xmlSchemaPErr(ctxt, decl->node,
XML_SCHEMAP_INTERNAL,
"Internal error: xmlSchemaCheckElemValConstr, "
"type is missing... skipping validation of "
"the value constraint", NULL, NULL);
return;
}
if (xmlSchemaCreateVCtxtOnPCtxt(ctxt) == -1)
return;
type = decl->subtypes;
if (decl->node != NULL) {
if (decl->flags & XML_SCHEMAS_ELEM_FIXED)
node = (xmlNodePtr) xmlHasProp(decl->node, BAD_CAST "fixed");
else
node = (xmlNodePtr) xmlHasProp(decl->node, BAD_CAST "default");
}
ctxt->vctxt->node = node;
ctxt->vctxt->cur = NULL;
ret = xmlSchemaCheckCOSValidDefault(ctxt, ctxt->vctxt, type, decl->value,
node);
if (ret == 0) {
decl->defVal = ctxt->vctxt->value;
ctxt->vctxt->value = NULL;
} else if (ret < 0) {
xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
NULL, NULL, node,
"Internal error: xmlSchemaElemCheckValConstr, "
"failed to validate the value constraint of the "
"element declaration '%s'",
decl->name);
}
}
}
static void
xmlSchemaAttrFixup(xmlSchemaAttributePtr item,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
if (item->flags & XML_SCHEMAS_ATTR_INTERNAL_RESOLVED)
return;
item->flags |= XML_SCHEMAS_ATTR_INTERNAL_RESOLVED;
if (item->subtypes != NULL)
return;
if (item->typeName != NULL) {
xmlSchemaTypePtr type;
type = xmlSchemaGetType(ctxt->schema, item->typeName,
item->typeNs);
if ((type == NULL) || (! IS_SIMPLE_TYPE(type))) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) item, item->node,
"type", item->typeName, item->typeNs,
XML_SCHEMA_TYPE_SIMPLE, NULL);
} else
item->subtypes = type;
} else if (item->ref != NULL) {
xmlSchemaAttributePtr decl;
decl = xmlSchemaGetAttribute(ctxt->schema, item->ref, item->refNs);
if (decl == NULL) {
xmlSchemaPResCompAttrErr(ctxt,
XML_SCHEMAP_SRC_RESOLVE,
NULL, (xmlSchemaTypePtr) item, item->node,
"ref", item->ref, item->refNs,
XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
return;
}
item->refDecl = decl;
xmlSchemaAttrFixup(decl, ctxt, NULL);
item->subtypes = decl->subtypes;
if ((decl->flags & XML_SCHEMAS_ATTR_FIXED) &&
(item->defValue != NULL)) {
if (((item->flags & XML_SCHEMAS_ATTR_FIXED) == 0) ||
(!xmlStrEqual(item->defValue, decl->defValue))) {
xmlSchemaPCustomErr(ctxt,
XML_SCHEMAP_AU_PROPS_CORRECT_2,
NULL, NULL, item->node,
"The value constraint must be fixed "
"and match the referenced attribute "
"declarations's value constraint '%s'",
decl->defValue);
}
}
} else {
item->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
}
}
xmlSchemaPtr
xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
{
xmlSchemaPtr ret = NULL;
xmlDocPtr doc;
xmlNodePtr root;
int preserve = 0;
xmlSchemaInitTypes();
if (ctxt == NULL)
return (NULL);
ctxt->nberrors = 0;
ctxt->counter = 0;
ctxt->container = NULL;
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);
}
root = xmlDocGetRootElement(doc);
if (root == NULL) {
xmlSchemaPErr(ctxt, (xmlNodePtr) doc,
XML_SCHEMAP_NOROOT,
"The schema has no document element.\n", NULL, NULL);
if (!preserve) {
xmlFreeDoc(doc);
}
return (NULL);
}
xmlSchemaCleanupDoc(ctxt, root);
ret = xmlSchemaParseSchema(ctxt, root);
if (ret == NULL) {
if (!preserve) {
xmlFreeDoc(doc);
}
return (NULL);
}
ret->doc = doc;
ret->preserve = preserve;
ctxt->schema = ret;
ctxt->ctxtType = NULL;
ctxt->parentItem = NULL;
xmlHashScan(ret->attrDecl, (xmlHashScanner) xmlSchemaAttrFixup, ctxt);
xmlHashScan(ret->attrgrpDecl, (xmlHashScanner) xmlSchemaAttrGrpFixup,
ctxt);
xmlHashScan(ret->attrgrpDecl, (xmlHashScanner)
xmlSchemaCheckAttributeGroupCircular, ctxt);
xmlHashScan(ret->groupDecl, (xmlHashScanner) xmlSchemaGroupDefFixup, ctxt);
xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaTypeFixup, ctxt);
xmlHashScanFull(ret->elemDecl,
(xmlHashScannerFull) xmlSchemaRefFixupCallback, ctxt);
xmlHashScan(ret->groupDecl, (xmlHashScanner)
xmlSchemaCheckGroupDefCircular, ctxt);
xmlHashScan(ret->typeDecl,
(xmlHashScanner) xmlSchemaBuildContentModel, ctxt);
xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaCheckDefaults,
ctxt);
xmlHashScan(ret->attrDecl, (xmlHashScanner) xmlSchemaCheckAttrValConstr, ctxt);
xmlHashScan(ret->elemDecl, (xmlHashScanner) xmlSchemaCheckElemValConstr, ctxt);
if (ctxt->nberrors != 0) {
xmlSchemaFree(ret);
ret = NULL;
}
return (ret);
}
void
xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn, void *ctx)
{
if (ctxt == NULL)
return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->userData = ctx;
}
int
xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc * err,
xmlSchemaValidityWarningFunc * warn, void **ctx)
{
if (ctxt == NULL)
return(-1);
if (err != NULL)
*err = ctxt->error;
if (warn != NULL)
*warn = ctxt->warning;
if (ctx != NULL)
*ctx = ctxt->userData;
return(0);
}
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");
}
static xmlChar *
xmlSchemaWhiteSpaceReplace(const xmlChar *value) {
const xmlChar *cur = value;
xmlChar *ret = NULL, *mcur;
if (value == NULL)
return(NULL);
while ((*cur != 0) &&
(((*cur) != 0xd) && ((*cur) != 0x9) && ((*cur) != 0xa))) {
cur++;
}
if (*cur == 0)
return (NULL);
ret = xmlStrdup(value);
mcur = (xmlChar *) (ret + (cur - value));
do {
if ( ((*mcur) == 0xd) || ((*mcur) == 0x9) || ((*mcur) == 0xa) )
*mcur = ' ';
mcur++;
} while (*mcur != 0);
return(ret);
}
static int
xmlSchemaGetWhiteSpaceFacetValue(xmlSchemaTypePtr type)
{
xmlSchemaTypePtr anc;
if (type->type == XML_SCHEMA_TYPE_BASIC) {
if ((type->builtInType == XML_SCHEMAS_STRING) &&
(type->builtInType == XML_SCHEMAS_NORMSTRING))
return(XML_SCHEMAS_VAL_WTSP_PRESERVE);
else {
return(XML_SCHEMAS_VAL_WTSP_COLLAPSE);
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
return (XML_SCHEMAS_VAL_WTSP_COLLAPSE);
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
return (-1);
} else if (type->facetSet != NULL) {
xmlSchemaTypePtr anyST;
xmlSchemaFacetLinkPtr lin;
anyST = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
anc = type->baseType;
do {
if ((anc->type == XML_SCHEMA_TYPE_BASIC) &&
(anc->builtInType == XML_SCHEMAS_STRING)) {
lin = type->facetSet;
do {
if (lin->facet->type == XML_SCHEMA_FACET_WHITESPACE) {
if (lin->facet->whitespace ==
XML_SCHEMAS_FACET_COLLAPSE) {
return(XML_SCHEMAS_VAL_WTSP_COLLAPSE);
} else if (lin->facet->whitespace ==
XML_SCHEMAS_FACET_REPLACE) {
return(XML_SCHEMAS_VAL_WTSP_REPLACE);
} else
return(XML_SCHEMAS_VAL_WTSP_PRESERVE);
break;
}
lin = lin->next;
} while (lin != NULL);
break;
}
anc = anc->baseType;
} while (anc != anyST);
return (XML_SCHEMAS_VAL_WTSP_COLLAPSE);
}
return (-1);
}
static int
xmlSchemaValidateFacetsInternal(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
const xmlChar * value,
unsigned long length,
int fireErrors)
{
int ret = 0;
xmlNodePtr node;
xmlSchemaTypePtr biType;
xmlSchemaTypePtr tmpType;
xmlSchemaFacetLinkPtr facetLink;
int retFacet;
xmlSchemaFacetPtr facet;
unsigned long len = 0;
#ifdef DEBUG_UNION_VALIDATION
printf("Facets of type: '%s'\n", (const char *) type->name);
printf(" fireErrors: %d\n", fireErrors);
#endif
node = ctxt->node;
biType = type->baseType;
while ((biType != NULL) && (biType->type != XML_SCHEMA_TYPE_BASIC))
biType = biType->baseType;
if (biType == NULL) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateFacetsInternal, "
"the base type axis of the given type '%s' does not resolve to "
"a built-in type.\n",
type->name, NULL);
return (-1);
}
if (type->facetSet != NULL) {
facetLink = type->facetSet;
while (facetLink != NULL) {
facet = facetLink->facet;
switch (facet->type) {
case XML_SCHEMA_FACET_WHITESPACE:
case XML_SCHEMA_FACET_PATTERN:
case XML_SCHEMA_FACET_ENUMERATION:
break;
case XML_SCHEMA_FACET_LENGTH:
case XML_SCHEMA_FACET_MINLENGTH:
case XML_SCHEMA_FACET_MAXLENGTH:
if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
ret = xmlSchemaValidateListSimpleTypeFacet(facet,
value, length, 0);
len = length;
} else
ret = xmlSchemaValidateLengthFacet(biType, facet,
value, ctxt->value, &len);
break;
default:
ret = xmlSchemaValidateFacet(biType, facet, value,
ctxt->value);
}
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateFacetsInternal, "
"validating facet of type '%s'.\n",
type->name, NULL);
break;
} else if ((ret > 0) && (fireErrors)) {
xmlSchemaVFacetErr(ctxt, ret, node, value, len,
type, facet, NULL, NULL, NULL, NULL);
}
facetLink = facetLink->next;
}
if (ret >= 0) {
retFacet = 0;
facetLink = type->facetSet;
while (facetLink != NULL) {
if (facetLink->facet->type == XML_SCHEMA_FACET_ENUMERATION) {
retFacet = xmlSchemaValidateFacet(biType, facetLink->facet,
value, ctxt->value);
if (retFacet <= 0)
break;
}
facetLink = facetLink->next;
}
if (retFacet > 0) {
ret = XML_SCHEMAV_CVC_ENUMERATION_VALID;
if (fireErrors)
xmlSchemaVFacetErr(ctxt, ret, node,
value, 0, type, NULL, NULL, NULL, NULL, NULL);
} else if (retFacet < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateFacetsInternal, "
"validating facet of type '%s'.\n",
BAD_CAST "enumeration", NULL);
ret = -1;
}
}
}
if (ret >= 0) {
tmpType = type;
facet = NULL;
do {
retFacet = 0;
for (facetLink = tmpType->facetSet; facetLink != NULL;
facetLink = facetLink->next) {
if (facetLink->facet->type != XML_SCHEMA_FACET_PATTERN)
continue;
retFacet = xmlSchemaValidateFacet(biType, facetLink->facet,
value, ctxt->value);
if (retFacet == 0)
break;
else if (retFacet < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateFacetsInternal, "
"validating 'pattern' facet '%s' of type '%s'.\n",
facetLink->facet->value, tmpType->name);
ret = -1;
break;
} else
facet = facetLink->facet;
}
if (retFacet != 0)
break;
tmpType = tmpType->baseType;
} while ((tmpType != NULL) && (tmpType->type != XML_SCHEMA_TYPE_BASIC));
if (retFacet > 0) {
ret = XML_SCHEMAV_CVC_PATTERN_VALID;
if (fireErrors) {
xmlSchemaVFacetErr(ctxt, ret, node, value, 0, type, facet,
NULL, NULL, NULL, NULL);
}
}
}
return (ret);
}
static int xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt,
xmlNodePtr elem,
xmlSchemaTypePtr type);
static int xmlSchemaValidateElementByType(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
int valSimpleContent);
static void
xmlSchemaFreeAttributeStates(xmlSchemaAttrStatePtr state)
{
xmlSchemaAttrStatePtr tmp;
while (state != NULL) {
tmp = state;
state = state->next;
xmlFree(tmp);
}
}
static int
xmlSchemaRegisterAttributes(xmlSchemaValidCtxtPtr ctxt, xmlAttrPtr attrs)
{
xmlSchemaAttrStatePtr tmp;
ctxt->attr = NULL;
ctxt->attrTop = NULL;
while (attrs != NULL) {
if ((attrs->ns != NULL) &&
(xmlStrEqual(attrs->ns->href, xmlSchemaInstanceNs))) {
attrs = attrs->next;
continue;
}
tmp = (xmlSchemaAttrStatePtr)
xmlMalloc(sizeof(xmlSchemaAttrState));
if (tmp == NULL) {
xmlSchemaVErrMemory(ctxt, "registering attributes", NULL);
return (-1);
}
tmp->attr = attrs;
tmp->state = XML_SCHEMAS_ATTR_UNKNOWN;
tmp->next = NULL;
tmp->decl = NULL;
if (ctxt->attr == NULL)
ctxt->attr = tmp;
else
ctxt->attrTop->next = tmp;
ctxt->attrTop = tmp;
attrs = attrs->next;
}
return (0);
}
#if 0
static int
xmlSchemaValidateCheckNodeList(xmlNodePtr nodelist)
{
while (nodelist != NULL) {
if (nodelist->type == XML_ENTITY_REF_NODE) {
TODO
}
if ((nodelist->type != XML_TEXT_NODE) &&
(nodelist->type != XML_COMMENT_NODE) &&
(nodelist->type != XML_PI_NODE) &&
(nodelist->type != XML_CDATA_SECTION_NODE)) {
return (0);
}
nodelist = nodelist->next;
}
return (1);
}
#endif
static void
xmlSchemaPostSchemaAssembleFixup(xmlSchemaParserCtxtPtr ctxt)
{
int i, nbItems;
xmlSchemaTypePtr item, *items;
nbItems = ctxt->assemble->nbItems;
items = (xmlSchemaTypePtr *) ctxt->assemble->items;
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_ATTRIBUTE:
xmlSchemaAttrFixup((xmlSchemaAttributePtr) item, ctxt, NULL);
break;
case XML_SCHEMA_TYPE_ELEMENT:
xmlSchemaRefFixupCallback((xmlSchemaElementPtr) item, ctxt,
NULL, NULL, NULL);
break;
case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
xmlSchemaAttrGrpFixup((xmlSchemaAttributeGroupPtr) item,
ctxt, NULL);
break;
case XML_SCHEMA_TYPE_GROUP:
xmlSchemaGroupDefFixup(item, ctxt, NULL);
default:
break;
}
}
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_GROUP:
xmlSchemaCheckGroupDefCircular(item, ctxt, NULL);
break;
case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
xmlSchemaCheckAttributeGroupCircular(
(xmlSchemaAttributeGroupPtr) item, ctxt, NULL);
break;
default:
break;
}
}
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_SIMPLE:
case XML_SCHEMA_TYPE_COMPLEX:
xmlSchemaTypeFixup(item, ctxt, NULL);
break;
default:
break;
}
}
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_SIMPLE:
case XML_SCHEMA_TYPE_COMPLEX:
xmlSchemaCheckDefaults(item, ctxt, NULL);
break;
default:
break;
}
}
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_COMPLEX:
xmlSchemaBuildContentModel(item, ctxt, NULL);
break;
default:
break;
}
}
for (i = 0; i < nbItems; i++) {
item = items[i];
switch (item->type) {
case XML_SCHEMA_TYPE_ATTRIBUTE:
xmlSchemaCheckAttrValConstr((xmlSchemaAttributePtr) item, ctxt, NULL);
break;
case XML_SCHEMA_TYPE_ELEMENT:
xmlSchemaCheckElemValConstr((xmlSchemaElementPtr) item, ctxt, NULL);
break;
default:
break;
}
}
}
static int
xmlSchemaAssembleByLocation(xmlSchemaValidCtxtPtr vctxt,
xmlSchemaPtr schema,
xmlNodePtr node,
const xmlChar *nsName,
const xmlChar *location)
{
const xmlChar *targetNs, *oldtns;
xmlDocPtr doc, olddoc;
int oldflags, ret = 0;
xmlNodePtr docElem;
xmlSchemaParserCtxtPtr pctxt;
if ((vctxt == NULL) || (schema == NULL))
return (-1);
if ((vctxt->pctxt == NULL) &&
(xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1)) {
xmlSchemaVErr(vctxt, node,
XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaAssembleByLocation, "
"failed to create a temp. parser context.\n",
NULL, NULL);
return (-1);
}
pctxt = vctxt->pctxt;
pctxt->counter = schema->counter;
ret = xmlSchemaAcquireSchemaDoc(pctxt, schema, node,
nsName, location, &doc, &targetNs, 0);
if (ret != 0) {
if (doc != NULL)
xmlFreeDoc(doc);
} else if (doc != NULL) {
docElem = xmlDocGetRootElement(doc);
if (pctxt->assemble == NULL) {
pctxt->assemble = xmlSchemaNewAssemble();
if (pctxt->assemble == NULL) {
xmlSchemaVErrMemory(vctxt,
"Memory error: xmlSchemaAssembleByLocation, "
"allocating assemble info", NULL);
xmlFreeDoc(doc);
return (-1);
}
}
oldflags = schema->flags;
oldtns = schema->targetNamespace;
olddoc = schema->doc;
xmlSchemaClearSchemaDefaults(schema);
schema->targetNamespace = targetNs;
pctxt->schema = schema;
pctxt->ctxtType = NULL;
pctxt->parentItem = NULL;
xmlSchemaParseSchemaDefaults(pctxt, schema, docElem);
xmlSchemaParseSchemaTopLevel(pctxt, schema, docElem->children);
xmlSchemaPostSchemaAssembleFixup(pctxt);
schema->counter = pctxt->counter;
pctxt->assemble->nbItems = 0;
schema->flags = oldflags;
schema->targetNamespace = oldtns;
schema->doc = olddoc;
ret = pctxt->err;
}
return (ret);
}
static int
xmlSchemaAssembleByXSIAttr(xmlSchemaValidCtxtPtr vctxt,
xmlAttrPtr xsiAttr,
int noNamespace)
{
xmlChar *value;
const xmlChar *cur, *end;
const xmlChar *nsname = NULL, *location;
int count = 0;
int ret = 0;
if (xsiAttr == NULL) {
xmlSchemaVCustomErr(vctxt, XML_SCHEMAV_INTERNAL,
NULL, NULL,
"Internal error: xmlSchemaAssembleByXSIAttr, "
"bad arguments", NULL);
return (-1);
}
value = xmlNodeGetContent((xmlNodePtr) xsiAttr);
cur = value;
do {
if (noNamespace != 1) {
while (IS_BLANK_CH(*cur))
cur++;
end = cur;
while ((*end != 0) && (!(IS_BLANK_CH(*end))))
end++;
if (end == cur)
break;
count++;
nsname = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
cur = end;
}
while (IS_BLANK_CH(*cur))
cur++;
end = cur;
while ((*end != 0) && (!(IS_BLANK_CH(*end))))
end++;
if (end == cur)
break;
count++;
location = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
cur = end;
ret = xmlSchemaAssembleByLocation(vctxt, vctxt->schema,
xsiAttr->parent, nsname, location);
if (ret == -1) {
xmlSchemaVCustomErr(vctxt,
XML_SCHEMAV_INTERNAL,
(xmlNodePtr) xsiAttr, NULL,
"Internal error: xmlSchemaAssembleByXSIAttr, "
"assembling schemata", NULL);
if (value != NULL)
xmlFree(value);
return (-1);
}
} while (*cur != 0);
if (value != NULL)
xmlFree(value);
return (ret);
}
static int
xmlSchemaAssembleByXSIElem(xmlSchemaValidCtxtPtr vctxt,
xmlNodePtr elem)
{
int ret = 0, retNs = 0;
xmlAttrPtr attr;
attr = xmlHasNsProp(elem, BAD_CAST "schemaLocation", xmlSchemaInstanceNs);
if (attr != NULL) {
retNs = xmlSchemaAssembleByXSIAttr(vctxt, attr, 0);
if (retNs == -1)
return (-1);
}
attr = xmlHasNsProp(elem, BAD_CAST "noNamespaceSchemaLocation", xmlSchemaInstanceNs);
if (attr != NULL) {
ret = xmlSchemaAssembleByXSIAttr(vctxt, attr, 1);
if (ret == -1)
return (-1);
}
if (retNs != 0)
return (retNs);
else
return (ret);
}
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;
ctxt->cur = node->children;
if (ctxt->xsiAssemble) {
int ret;
ret = xmlSchemaAssembleByXSIElem(ctxt, ctxt->node);
if (ret == -1) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
ctxt->node, NULL,
"Internal error: xmlSchemaValidateElement, "
"assembling schema by xsi", NULL);
return;
}
}
switch (type->type) {
case XML_SCHEMA_TYPE_ELEMENT: {
if (((xmlSchemaElementPtr) ctxt->type)->ref != NULL) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
node, NULL,
"Internal error: xmlSchemaValidateCallback, "
"element declaration 'reference' encountered, "
"but an element declaration was expected",
NULL);
return;
}
xmlSchemaValidateElementByDeclaration(ctxt,
(xmlSchemaElementPtr) type);
break;
}
case XML_SCHEMA_TYPE_ANY:
xmlSchemaValidateElementByWildcard(ctxt, type);
break;
default:
break;
}
ctxt->type = oldtype;
ctxt->node = oldnode;
}
static int
xmlSchemaValidateSimpleTypeValue(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
const xmlChar *value,
int fireErrors,
int applyFacets,
int normalize,
int checkNodes)
{
xmlNodePtr node;
int ret = 0;
xmlChar *normValue = NULL;
int wtsp;
node = ctxt->node;
wtsp = ctxt->valueWS;
if (normalize &&
(ctxt->valueWS != XML_SCHEMAS_VAL_WTSP_COLLAPSE)) {
int norm = xmlSchemaGetWhiteSpaceFacetValue(type);
if ((norm != -1) && (norm > ctxt->valueWS)) {
if (norm == XML_SCHEMAS_VAL_WTSP_COLLAPSE)
normValue = xmlSchemaCollapseString(value);
else
normValue = xmlSchemaWhiteSpaceReplace(value);
ctxt->valueWS = norm;
if (normValue != NULL)
value = (const xmlChar *) normValue;
}
}
if ((checkNodes == 1) && (ctxt->cur != NULL)) {
xmlNodePtr cur = ctxt->cur;
do {
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: {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
node, type,
"Element '%s' found in simple type content",
cur->name);
return (XML_SCHEMAV_INTERNAL);
}
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
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
node, NULL,
"Node of unexpected type found in simple type content",
NULL);
return (XML_SCHEMAV_INTERNAL);
}
cur = cur->next;
} while (cur != NULL);
}
if (type->type == XML_SCHEMA_TYPE_COMPLEX) {
xmlSchemaTypePtr base, anyType;
anyType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
base = type->baseType;
while ((base != NULL) &&
(base->type != XML_SCHEMA_TYPE_SIMPLE) &&
(base->type != XML_SCHEMA_TYPE_BASIC) &&
(base != anyType)) {
base = base->baseType;
}
ret = xmlSchemaValidateSimpleTypeValue(ctxt, base, value, 1, 0, 1, 0);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating complex type '%s'\n",
type->name, NULL);
} else if ((ret == 0) && (applyFacets) && (type->facetSet != NULL)) {
ret = xmlSchemaValidateFacetsInternal(ctxt, type,
value, 0, fireErrors);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating facets of complex type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
if (fireErrors)
xmlSchemaVSimpleTypeErr(ctxt, ret, node, value, type);
}
}
} else if (type->type == XML_SCHEMA_TYPE_BASIC) {
if (ctxt->value != NULL) {
xmlSchemaFreeValue(ctxt->value);
ctxt->value = NULL;
}
ret = xmlSchemaValPredefTypeNodeNoNorm(type, value, &(ctxt->value), node);
if (ret > 0) {
if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST)
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
else
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
if (fireErrors)
xmlSchemaVSimpleTypeErr(ctxt, ret, node, value, type);
} else if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating built-in type '%s'\n", type->name, NULL);
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC) {
ret = xmlSchemaValidateSimpleTypeValue(ctxt, type->baseType, value, 0, 0, 0, 0);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating atomic simple type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
if (fireErrors)
xmlSchemaVSimpleTypeErr(ctxt, ret, node, value, type);
} else if ((applyFacets) && (type->facetSet != NULL)) {
ret = xmlSchemaValidateFacetsInternal(ctxt, type,
value, 0, fireErrors);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating facets of atomic simple type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
}
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_LIST) {
xmlSchemaTypePtr tmpType;
const xmlChar *cur, *end;
xmlChar *tmp;
unsigned long len = 0;
tmpType = xmlSchemaGetListSimpleTypeItemType(type);
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);
len++;
ret = xmlSchemaValidateSimpleTypeValue(ctxt, tmpType, tmp, 0, 1, 0, 0);
xmlFree(tmp);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating an item of list simple type '%s'\n",
type->name, NULL);
break;
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
if (fireErrors)
xmlSchemaVSimpleTypeErr(ctxt, ret, node, value, type);
break;
}
cur = end;
} while (*cur != 0);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating list simple type '%s'\n",
type->name, NULL);
} else if ((ret == 0) && (applyFacets)) {
ret = xmlSchemaValidateFacetsInternal(ctxt, type,
value, len, fireErrors);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating facets of list simple type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
}
}
} else if (type->flags & XML_SCHEMAS_TYPE_VARIETY_UNION) {
xmlSchemaTypeLinkPtr memberLink;
#ifdef DEBUG_UNION_VALIDATION
printf("Union ST : '%s'\n", (const char *) type->name);
printf(" fireErrors : %d\n", fireErrors);
printf(" applyFacets: %d\n", applyFacets);
#endif
memberLink = xmlSchemaGetUnionSimpleTypeMemberTypes(type);
if (memberLink == NULL) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"union simple type '%s' has no member types\n",
type->name, NULL);
ret = -1;
}
if (ret == 0) {
while (memberLink != NULL) {
ret = xmlSchemaValidateSimpleTypeValue(ctxt, memberLink->type,
value, 0, 1, 1, 0);
if ((ret <= 0) || (ret == 0))
break;
memberLink = memberLink->next;
}
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating members of union simple type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
if (fireErrors)
xmlSchemaVSimpleTypeErr(ctxt, ret, node, value, type);
}
}
if ((ret == 0) && (applyFacets) && (type->facetSet != NULL)) {
int mws;
if (normValue != NULL) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"the value was already normalized for the union simple "
"type '%s'.\n", type->name, NULL);
}
mws = xmlSchemaGetWhiteSpaceFacetValue(memberLink->type);
if (mws > ctxt->valueWS) {
if (mws == XML_SCHEMAS_VAL_WTSP_COLLAPSE)
normValue = xmlSchemaCollapseString(value);
else
normValue = xmlSchemaWhiteSpaceReplace(value);
if (normValue != NULL)
value = (const xmlChar *) normValue;
}
ret = xmlSchemaValidateFacetsInternal(ctxt, type,
value, 0, fireErrors);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateSimpleTypeValue, "
"validating facets of union simple type '%s'\n",
type->name, NULL);
} else if (ret > 0) {
ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
}
}
}
ctxt->valueWS = wtsp;
if (normValue != NULL)
xmlFree(normValue);
return (ret);
}
static int
xmlSchemaValidateElementBySimpleType(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
int valSimpleContent)
{
xmlSchemaTypePtr oldtype;
xmlNodePtr node;
xmlAttrPtr attr;
xmlNodePtr cur;
int ret = 0, retval = 0;
if ((ctxt == NULL) || (type == NULL)) {
xmlSchemaVCustomErr(ctxt, XML_SCHEMAV_INTERNAL, NULL, NULL,
"Internal error: xmlSchemaValidateElementBySimpleType, "
"bad arguments", NULL);
return (-1);
}
oldtype = ctxt->type;
node = ctxt->node;
cur = node->children;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_TYPE_3_1_2,
node, type,
"No element content allowed", NULL);
ret = XML_SCHEMAV_CVC_TYPE_3_1_2;
}
cur = cur->next;
}
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 "schemaLocation")) &&
(!xmlStrEqual
(attr->name, BAD_CAST "noNamespaceSchemaLocation")))) {
xmlSchemaVIllegalAttrErr(ctxt,
XML_SCHEMAV_CVC_TYPE_3_1_1, attr);
ret = XML_SCHEMAV_CVC_TYPE_3_1_1;
}
attr = attr->next;
}
if ((valSimpleContent == 1) &&
((type->type != XML_SCHEMA_TYPE_BASIC) ||
(type->builtInType != XML_SCHEMAS_ANYSIMPLETYPE))) {
xmlChar *value;
value = xmlNodeGetContent(node);
retval = xmlSchemaValidateSimpleTypeValue(ctxt, type, value,
1, 1, 1, 0);
if (value != NULL)
xmlFree(value);
if (retval != 0)
ret = retval;
}
ctxt->type = oldtype;
return (ret);
}
static int
xmlSchemaValQNameAcquire(const xmlChar *value, xmlNodePtr node,
xmlChar **nsName, xmlChar **localName)
{
int ret;
xmlChar *local = NULL;
if ((nsName == NULL) || (localName == NULL) || (node == NULL))
return (-1);
*nsName = NULL;
*localName = NULL;
ret = xmlValidateQName(value, 1);
if (ret == 0) {
xmlChar *prefix;
xmlNsPtr ns;
local = xmlSplitQName2(value, &prefix);
if (local == NULL)
local = xmlStrdup(value);
ns = xmlSearchNs(node->doc, node, prefix);
if (ns != NULL) {
*nsName = xmlStrdup(ns->href);
} else if (prefix != NULL) {
xmlFree(prefix);
if (local != NULL)
xmlFree(local);
return (2);
}
*localName = local;
if (prefix != NULL)
xmlFree(prefix);
} else
return (1);
return (ret);
}
static int
xmlSchemaHasElemContent(xmlNodePtr node)
{
if (node == NULL)
return (0);
node = node->children;
while (node != NULL) {
if (node->type == XML_ELEMENT_NODE)
return (1);
node = node->next;
}
return (0);
}
static int
xmlSchemaHasElemOrCharContent(xmlNodePtr node)
{
if (node == NULL)
return (0);
node = node->children;
while (node != NULL) {
switch (node->type) {
case XML_ELEMENT_NODE:
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_ENTITY_REF_NODE:
case XML_ENTITY_NODE:
return (1);
break;
default:
break;
}
node = node->next;
}
return (0);
}
static int
xmlSchemaValidateElementByDeclaration(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaElementPtr elemDecl)
{
xmlNodePtr elem;
int ret = 0;
xmlSchemaTypePtr actualType = NULL;
xmlAttrPtr attr;
xmlChar *attrValue;
int nilled = 0, elemHasContent = -1;
if (ctxt == NULL) {
xmlSchemaVErr(ctxt, NULL, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"bad arguments.\n",
NULL, NULL);
return (-1);
}
elem = ctxt->node;
if (elemDecl == NULL) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_1,
elem, NULL,
"No matching declaration available", NULL);
return (ctxt->err);
}
if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_2,
elem, NULL,
"The element declaration is abstract", NULL);
return (ctxt->err);
}
attr = xmlHasNsProp(elem, BAD_CAST "nil", xmlSchemaInstanceNs);
if (attr != NULL) {
attrValue = xmlNodeGetContent((xmlNodePtr) attr);
ctxt->node = (xmlNodePtr) attr;
ctxt->cur = attr->children;
ret = xmlSchemaValidateSimpleTypeValue(ctxt,
xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
BAD_CAST attrValue, 1, 1, 1, 1);
ctxt->node = elem;
ctxt->type = (xmlSchemaTypePtr) elemDecl;
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
(xmlNodePtr) attr, (xmlSchemaTypePtr) elemDecl,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"validating the attribute 'xsi:nil'", NULL);
if (attrValue != NULL)
xmlFree(attrValue);
return (-1);
}
if ((elemDecl->flags & XML_SCHEMAS_ELEM_NILLABLE) == 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_3_1,
elem, NULL,
"The element is not 'nillable'", NULL);
} else {
if (xmlStrEqual(BAD_CAST attrValue, BAD_CAST "true") ||
xmlStrEqual(BAD_CAST attrValue, BAD_CAST "1")) {
ret = 0;
elemHasContent = xmlSchemaHasElemOrCharContent(elem);
if (elemHasContent == 1) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_3_2_1,
elem, (xmlSchemaTypePtr) elemDecl,
"The 'nilled' element must have no character or "
"element content", NULL);
ret = XML_SCHEMAV_CVC_ELT_3_2_1;
}
if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) &&
(elemDecl->value != NULL)) {
xmlSchemaVCustomErr(ctxt, XML_SCHEMAV_CVC_ELT_3_2_2,
elem, (xmlSchemaTypePtr) elemDecl,
"There is a fixed value constraint defined for "
"the 'nilled' element", NULL);
ret = XML_SCHEMAV_CVC_ELT_3_2_2;
}
if (ret == 0)
nilled = 1;
}
}
if (attrValue != NULL)
xmlFree(attrValue);
}
actualType = elemDecl->subtypes;
attr = xmlHasNsProp(elem, BAD_CAST "type", xmlSchemaInstanceNs);
if (attr != NULL) {
xmlChar *nsName = NULL, *local = NULL;
attrValue = xmlNodeGetContent((xmlNodePtr) attr);
ret = xmlSchemaValQNameAcquire(attrValue, attr->parent,
&nsName, &local);
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
(xmlNodePtr) attr, (xmlSchemaTypePtr) elemDecl,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"validating the attribute 'xsi:type'", NULL);;
FREE_AND_NULL(attrValue)
FREE_AND_NULL(nsName)
FREE_AND_NULL(local)
return (-1);
} else if (ret == 1) {
xmlSchemaVSimpleTypeErr(ctxt,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
(xmlNodePtr) attr, attrValue,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME));
} else if (ret == 2) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
(xmlNodePtr) attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
"The QName value '%s' has no "
"corresponding namespace declaration in scope",
attrValue);
} else {
actualType = xmlSchemaGetType(ctxt->schema, local, nsName);
if (actualType == NULL) {
xmlChar *strA = NULL;
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_4_2,
(xmlNodePtr) attr,
xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
"The value %s does not resolve to a type "
"definition",
xmlSchemaFormatNsUriLocal(&strA, nsName, local));
FREE_AND_NULL(strA);
} else {
}
}
FREE_AND_NULL(attrValue)
FREE_AND_NULL(nsName)
FREE_AND_NULL(local)
}
if (actualType == NULL) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_TYPE_1,
elem, (xmlSchemaTypePtr) elemDecl,
"The type definition is absent");
return (XML_SCHEMAV_CVC_TYPE_1);
}
if (elemHasContent == -1)
elemHasContent = xmlSchemaHasElemOrCharContent(elem);
if ((elemHasContent == 0) && (nilled == 0) && (elemDecl->value != NULL)) {
ret = 0;
if (actualType != elemDecl->subtypes) {
xmlSchemaCreatePCtxtOnVCtxt(ctxt);
ret = xmlSchemaCheckCOSValidDefault(ctxt->pctxt, ctxt, actualType,
elemDecl->value, NULL);
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
elem, actualType,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"validating a default value", NULL);
return (-1);
}
}
if (ret == 0) {
if (actualType != elemDecl->subtypes)
ret = xmlSchemaValidateElementByType(ctxt, actualType, 0);
else
ret = xmlSchemaValidateElementByType(ctxt, actualType, 0);
ctxt->node = elem;
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
elem, actualType,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"validating against the type", NULL);
return (-1);
}
if (ctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) {
xmlNodePtr textChild;
textChild = xmlNewText(elemDecl->value);
if (textChild == NULL) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
elem, actualType,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"could not create a default text node for the instance",
NULL);
} else
xmlAddChild(elem, textChild);
}
}
} else {
ret = xmlSchemaValidateElementByType(ctxt, actualType, 1);
ctxt->node = elem;
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
elem, actualType,
"Internal error: xmlSchemaValidateElementByDeclaration, "
"validating a default value", NULL);
return (-1);
}
if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) && (nilled == 0)) {
if (xmlSchemaHasElemContent(elem)) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_5_2_2_1,
elem, (xmlSchemaTypePtr) elemDecl,
"Elements in the content are not allowed if it is "
"constrained by a fixed value", NULL);
} else {
if (actualType->contentType == XML_SCHEMA_CONTENT_MIXED) {
xmlChar *value;
value = xmlNodeListGetString(elem->doc, elem->children, 1);
if (! xmlStrEqual(BAD_CAST value, elemDecl->value)) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
elem, (xmlSchemaTypePtr) elemDecl,
"The value does not match the cononical "
"lexical representation of the fixed constraint",
NULL);
}
if (value != NULL)
xmlFree(value);
} else if ((actualType->contentType ==
XML_SCHEMA_CONTENT_SIMPLE) ||
(actualType->contentType == XML_SCHEMA_CONTENT_BASIC)) {
xmlChar *value;
value = xmlNodeListGetString(elem->doc, elem->children, 1);
if (! xmlStrEqual(BAD_CAST value, elemDecl->value)) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_5_2_2_2_2,
elem, (xmlSchemaTypePtr) elemDecl,
"The normalized value does not match the cononical "
"lexical representation of the fixed constraint",
NULL);
}
if (value != NULL)
xmlFree(value);
}
}
}
}
return (ctxt->err);
}
static int
xmlSchemaValidateElementByWildcardInternal(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaWildcardPtr wild,
xmlNodePtr node)
{
const xmlChar *uri;
int ret = 0;
xmlNodePtr child;
if (ctxt->xsiAssemble) {
ret = xmlSchemaAssembleByXSIElem(ctxt, ctxt->node);
if (ret == -1) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
ctxt->node, NULL,
"Internal error: xmlSchemaValidateElement, "
"assembling schema by xsi", NULL);
return (-1);
}
}
if (wild->processContents != XML_SCHEMAS_ANY_SKIP) {
xmlSchemaElementPtr decl = NULL;
if (node->ns != NULL)
decl = xmlHashLookup3(ctxt->schema->elemDecl,
node->name, node->ns->href, NULL);
else
decl = xmlHashLookup3(ctxt->schema->elemDecl, node->name, NULL, NULL);
if (decl != NULL) {
ctxt->node = node;
ret = xmlSchemaValidateElementByDeclaration(ctxt, decl);
if (ret < 0) {
xmlSchemaVErr(ctxt, node, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateAnyInternal, "
"validating an element in the context of a wildcard.",
NULL, NULL);
} else if (ret > 0)
return (ret);
} else if (wild->processContents == XML_SCHEMAS_ANY_STRICT) {
xmlSchemaVWildcardErr(ctxt, XML_SCHEMAV_CVC_ELT_1,
node, wild, "No matching global declaration available");
return (ctxt->err);
}
}
if (node->children != NULL) {
child = node->children;
do {
if (child->type == XML_ELEMENT_NODE) {
if (child->ns != NULL)
uri = child->ns->href;
else
uri = NULL;
if (xmlSchemaMatchesWildcardNs(wild, uri) == 0) {
xmlSchemaVWildcardErr(ctxt, XML_SCHEMAV_ELEMENT_CONTENT,
child, wild,
"The namespace of the element is not allowed");
return (ctxt->err);
}
ret = xmlSchemaValidateElementByWildcardInternal(ctxt,
wild, child);
if (ret != 0)
return (ret);
}
child = child->next;
} while (child != NULL);
}
return (0);
}
static int
xmlSchemaValidateElementByWildcard(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
if ((type == NULL) || (type->type != XML_SCHEMA_TYPE_ANY) ||
(ctxt->node == NULL)) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL, ctxt->node, NULL,
"Internal error: xmlSchemaValidateElementByWildcard, "
"bad arguments", NULL);
return (-1);
}
return(xmlSchemaValidateElementByWildcardInternal(ctxt,
type->attributeWildcard, ctxt->node));
}
static int
xmlSchemaValidateElementByAnyType(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type)
{
xmlSchemaTypePtr oldtype;
xmlNodePtr top, cur;
xmlSchemaElementPtr decl;
int skipContent, ret;
if ((type == NULL) || (ctxt->node == NULL))
return (-1);
if (ctxt->node->children == NULL)
return (0);
oldtype = ctxt->type;
top = ctxt->node;
cur = ctxt->node->children;
while (cur != NULL) {
skipContent = 0;
if (cur->type == XML_ELEMENT_NODE) {
if (cur->ns != NULL)
decl = xmlHashLookup3(ctxt->schema->elemDecl,
cur->name, cur->ns->href, NULL);
else
decl = xmlHashLookup3(ctxt->schema->elemDecl, cur->name, NULL, NULL);
if (decl != NULL) {
ctxt->node = cur;
ret = xmlSchemaValidateElementByDeclaration(ctxt, decl);
ctxt->node = top;
if (ret < 0) {
xmlSchemaVErr(ctxt, cur, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateAnyTypeContent, "
"validating an element in the context of a wildcard.",
NULL, NULL);
return (ret);
} else if (ret > 0)
return (ret);
skipContent = 1;
}
}
if ((skipContent == 0) && (cur->children != NULL)) {
cur = cur->children;
} else if ((cur != top) && (cur->next != NULL)) {
cur = cur->next;
} else if (cur != top) {
while (cur != top) {
if (cur->parent != NULL)
cur = cur->parent;
if ((cur != top) && (cur->next != NULL)) {
cur = cur->next;
break;
}
if (cur->parent == NULL) {
cur = NULL;
break;
}
}
if (cur == top)
cur = NULL;
} else
break;
}
ctxt->type = oldtype;
return (0);
}
static int
xmlSchemaValidateElementByComplexType(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
int valSimpleContent)
{
xmlSchemaTypePtr oldtype;
xmlNodePtr elem, child;
int ret = 0;
const xmlChar *nsUri;
xmlSchemaAttrStatePtr attrs = NULL, attrTop = NULL;
if ((ctxt == NULL) || (type->type != XML_SCHEMA_TYPE_COMPLEX))
return (-1);
oldtype = ctxt->type;
ctxt->type = type;
elem = ctxt->node;
attrs = ctxt->attr;
attrTop = ctxt->attrTop;
xmlSchemaRegisterAttributes(ctxt, elem->properties);
xmlSchemaValidateAttributes(ctxt, elem, type);
if (ctxt->attr != NULL)
xmlSchemaFreeAttributeStates(ctxt->attr);
ctxt->attr = attrs;
ctxt->attrTop = attrTop;
switch (type->contentType) {
case XML_SCHEMA_CONTENT_EMPTY: {
if (xmlSchemaHasElemOrCharContent(elem) == 1) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
elem, type,
"Character or element content is not allowed, "
"because the content type is empty");
}
break;
}
case XML_SCHEMA_CONTENT_MIXED:
if ((type->subtypes == NULL) &&
(type->baseType->builtInType == XML_SCHEMAS_ANYTYPE)) {
ret = xmlSchemaValidateElementByAnyType(ctxt, type->baseType);
break;
}
case XML_SCHEMA_CONTENT_ELEMENTS:
{
xmlRegExecCtxtPtr oldregexp = NULL;
if (type->contModel != NULL) {
oldregexp = ctxt->regexp;
ctxt->regexp = xmlRegNewExecCtxt(type->contModel,
(xmlRegExecCallbacks)
xmlSchemaValidateCallback, ctxt);
#ifdef DEBUG_AUTOMATA
xmlGenericError(xmlGenericErrorContext, "====> %s\n", elem->name);
#endif
}
child = elem->children;
while (child != NULL) {
if (child->type == XML_ELEMENT_NODE) {
if (child->ns != NULL)
nsUri = child->ns->href;
else
nsUri = NULL;
ret = xmlRegExecPushString2(ctxt->regexp,
child->name, nsUri, child);
#ifdef DEBUG_AUTOMATA
if (ret < 0)
xmlGenericError(xmlGenericErrorContext,
" --> %s Error\n", child->name);
else
xmlGenericError(xmlGenericErrorContext,
" --> %s\n", child->name);
#endif
} else if ((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) &&
(((child->type == XML_TEXT_NODE) && (!IS_BLANK_NODE(child))) ||
(child->type == XML_ENTITY_NODE) ||
(child->type == XML_ENTITY_REF_NODE) ||
(child->type == XML_CDATA_SECTION_NODE))) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
elem, type,
"Character content is not allowed, "
"because the content type is element-only");
break;
}
child = child->next;
}
if (type->contModel != NULL) {
ret = xmlRegExecPushString(ctxt->regexp, NULL, NULL);
#ifdef DEBUG_AUTOMATA
xmlGenericError(xmlGenericErrorContext,
"====> %s : %d\n", elem->name, ret);
#endif
if (ret == 0) {
xmlSchemaVCustomErr(ctxt, XML_SCHEMAV_ELEMENT_CONTENT,
elem, type, "The element content is not valid", NULL);
} else if (ret < 0) {
xmlSchemaVCustomErr(ctxt, XML_SCHEMAV_ELEMENT_CONTENT,
elem, type, "The element content is not valid", NULL);
#ifdef DEBUG_CONTENT
} else {
xmlGenericError(xmlGenericErrorContext,
"Element %s content check succeeded\n",
elem->name);
#endif
}
xmlRegFreeExecCtxt(ctxt->regexp);
ctxt->regexp = oldregexp;
}
}
break;
case XML_SCHEMA_CONTENT_SIMPLE:
case XML_SCHEMA_CONTENT_BASIC:
if (valSimpleContent == 1) {
xmlChar *value = NULL;
child = elem->children;
while (child != NULL) {
if (child->type == XML_ELEMENT_NODE) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
elem, type,
"Element content is not allowed, because "
"the content type is a simple type");
ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2;
break;
}
child = child->next;
}
ctxt->node = elem;
ctxt->cur = elem->children;
if (ret == 0) {
if (elem->children == NULL)
value = NULL;
else
value = xmlNodeGetContent(elem);
ret = xmlSchemaValidateSimpleTypeValue(ctxt, type, value, 1, 1, 1, 0);
if (ret > 0) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
elem, type,
"The character content is not valid");
ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2;
} else if (ret < 0) {
xmlSchemaVErr(ctxt, elem, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateComplexType, "
"Element '%s': Error while validating character "
"content against complex type '%s'.\n",
elem->name, type->name);
if (value != NULL)
xmlFree(value);
ctxt->type = oldtype;
return (-1);
}
}
if (ret == 0) {
ret = xmlSchemaValidateFacetsInternal(ctxt,
type, value, 0, 1);
if (ret > 0) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
elem, type,
"The character content is not valid");
ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2;
} else if (ret < 0) {
xmlSchemaVErr(ctxt, elem, XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateComplexType, "
"Element '%s': Error while validating character "
"content against complex type '%s'; failed to "
"apply facets.\n",
type->name, NULL);
if (value != NULL)
xmlFree(value);
ctxt->type = oldtype;
return (-1);
}
}
if (value != NULL)
xmlFree(value);
}
break;
default:
TODO xmlGenericError(xmlGenericErrorContext,
"unimplemented content type %d\n",
type->contentType);
}
ctxt->type = oldtype;
return (ctxt->err);
}
static int
xmlSchemaValidateElementByType(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaTypePtr type,
int valSimpleContent)
{
int ret;
if ((ctxt == NULL) || (type == NULL)) {
xmlSchemaVCustomErr(ctxt, XML_SCHEMAV_INTERNAL, NULL, NULL,
"Internal error: xmlSchemaValidateElementByType, "
"bad arguments", NULL);
return (-1);
}
if (type == NULL) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_TYPE_1,
ctxt->node, NULL,
"The type definition is absent");
return (XML_SCHEMAV_CVC_TYPE_1);
}
if (type->flags & XML_SCHEMAS_TYPE_ABSTRACT) {
xmlSchemaVComplexTypeErr(ctxt,
XML_SCHEMAV_CVC_TYPE_2,
ctxt->node, type,
"The type definition is abstract");
return (XML_SCHEMAV_CVC_TYPE_2);
}
switch (type->type) {
case XML_SCHEMA_TYPE_COMPLEX:
ret = xmlSchemaValidateElementByComplexType(ctxt, type,
valSimpleContent);
break;
case XML_SCHEMA_TYPE_SIMPLE:
ret = xmlSchemaValidateElementBySimpleType(ctxt, type,
valSimpleContent);
break;
case XML_SCHEMA_TYPE_BASIC:
if (type->builtInType == XML_SCHEMAS_ANYTYPE)
ret = xmlSchemaValidateElementByAnyType(ctxt, type);
else
ret = xmlSchemaValidateElementBySimpleType(ctxt, type,
valSimpleContent);
break;
default:
ret = -1;
break;
}
if (ret == -1)
return (-1);
else
return (ret);
}
static int
xmlSchemaCheckAttrLocallyValid(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaAttributePtr decl,
xmlSchemaAttrStatePtr state,
xmlAttrPtr attr)
{
xmlChar *value;
const xmlChar *defValue;
xmlSchemaValPtr defVal;
int fixed;
int ret;
if (decl->subtypes == NULL) {
state->state = XML_SCHEMAS_ATTR_TYPE_NOT_RESOLVED;
return (XML_SCHEMAS_ATTR_TYPE_NOT_RESOLVED);
}
value = xmlNodeListGetString(attr->doc, attr->children, 1);
ctxt->node = (xmlNodePtr) attr;
ctxt->cur = attr->children;
ret = xmlSchemaValidateSimpleTypeValue(ctxt, decl->subtypes,
value, 1, 1, 1, 1);
if (ret > 0) {
state->state = XML_SCHEMAS_ATTR_INVALID_VALUE;
} else if (ret == 0) {
state->state = XML_SCHEMAS_ATTR_CHECKED;
if (xmlSchemaGetEffectiveValueConstraint(decl,
&fixed, &defValue, &defVal) && (fixed == 1)) {
if (((ctxt->value != NULL) &&
(xmlSchemaCompareValues(ctxt->value, defVal) != 0)) ||
((ctxt->value == NULL) &&
(! xmlStrEqual(defValue, BAD_CAST value)))) {
state->state =
XML_SCHEMAS_ATTR_INVALID_FIXED_VALUE;
}
}
}
if (value != NULL) {
xmlFree(value);
}
return (ret);
}
static int
xmlSchemaValidateAttributes(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem, xmlSchemaTypePtr type)
{
const xmlChar *nsURI;
int ret;
xmlAttrPtr attr;
const xmlChar *defValue;
xmlSchemaValPtr defVal;
int fixed;
xmlSchemaAttributeLinkPtr attrUse = NULL;
xmlSchemaAttributePtr attrDecl;
int found;
xmlSchemaAttrStatePtr curState, reqAttrStates = NULL, reqAttrStatesTop = NULL;
xmlSchemaAttrStatePtr defAttrStates = NULL, defAttrStatesTop = NULL;
xmlNodePtr oldnode;
#ifdef DEBUG_ATTR_VALIDATION
int redundant = 0;
#endif
if (type == xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE))
return (0);
oldnode = ctxt->node;
if (type != NULL)
attrUse = type->attributeUses;
while (attrUse != NULL) {
found = 0;
attrDecl = attrUse->attr;
#ifdef DEBUG_ATTR_VALIDATION
printf("attr use - name: %s\n", xmlSchemaGetAttrName(attrDecl));
printf("attr use - use: %d\n", attrDecl->occurs);
#endif
for (curState = ctxt->attr; curState != NULL; curState = curState->next) {
if (curState->decl == attrUse->attr) {
#ifdef DEBUG_ATTR_VALIDATION
redundant = 1;
#endif
}
attr = curState->attr;
#ifdef DEBUG_ATTR_VALIDATION
printf("attr - name: %s\n", attr->name);
if (attr->ns != NULL)
printf("attr - ns: %s\n", attr->ns->href);
else
printf("attr - ns: none\n");
#endif
if (attr == NULL)
continue;
if (attrDecl->ref != NULL) {
if (!xmlStrEqual(attr->name, attrDecl->ref))
continue;
if (attr->ns != NULL) {
if ((attrDecl->refNs == NULL) ||
(!xmlStrEqual(attr->ns->href, attrDecl->refNs)))
continue;
} else if (attrDecl->refNs != NULL) {
continue;
}
} else {
if (!xmlStrEqual(attr->name, attrDecl->name))
continue;
if (attr->ns == NULL) {
if (attrDecl->targetNamespace != NULL)
continue;
} else {
if (attrDecl->targetNamespace == NULL)
continue;
if (!xmlStrEqual(attrDecl->targetNamespace,
attr->ns->href))
continue;
}
}
#ifdef DEBUG_ATTR_VALIDATION
printf("found\n");
#endif
found = 1;
curState->decl = attrDecl;
ret = xmlSchemaCheckAttrLocallyValid(ctxt, attrDecl, curState, attr);
}
if (!found) {
if (attrDecl->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED) {
xmlSchemaAttrStatePtr tmp;
#ifdef DEBUG_ATTR_VALIDATION
printf("required attr not found\n");
#endif
tmp = (xmlSchemaAttrStatePtr) xmlMalloc(sizeof(xmlSchemaAttrState));
if (tmp == NULL) {
xmlSchemaVErrMemory(ctxt, "registering required attributes", NULL);
ctxt->node = oldnode;
return (-1);
}
tmp->attr = NULL;
tmp->state = XML_SCHEMAS_ATTR_MISSING;
tmp->decl = attrDecl;
tmp->next = NULL;
if (reqAttrStates == NULL) {
reqAttrStates = tmp;
reqAttrStatesTop = tmp;
} else {
reqAttrStatesTop->next = tmp;
reqAttrStatesTop = tmp;
}
} else if ((attrDecl->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
(xmlSchemaGetEffectiveValueConstraint(attrDecl,
&fixed, &defValue, &defVal))) {
xmlSchemaAttrStatePtr tmp;
tmp = (xmlSchemaAttrStatePtr)
xmlMalloc(sizeof(xmlSchemaAttrState));
if (tmp == NULL) {
xmlSchemaVErrMemory(ctxt,
"registering schema specified attributes", NULL);
ctxt->node = oldnode;
return (-1);
}
tmp->attr = NULL;
tmp->state = XML_SCHEMAS_ATTR_DEFAULT;
tmp->decl = attrDecl;
tmp->value = defValue;
tmp->next = NULL;
if (defAttrStates == NULL) {
defAttrStates = tmp;
defAttrStates = tmp;
} else {
defAttrStates->next = tmp;
defAttrStatesTop = tmp;
}
}
}
attrUse = attrUse->next;
}
if (reqAttrStates != NULL) {
if (ctxt->attr == NULL) {
ctxt->attr = reqAttrStates;
} else {
ctxt->attrTop->next = reqAttrStates;
}
ctxt->attrTop = reqAttrStatesTop;
}
if ((type != NULL) && (type->attributeWildcard != NULL)) {
#ifdef DEBUG_ATTR_VALIDATION
xmlSchemaWildcardNsPtr ns;
printf("matching wildcard: [%d] of complexType: %s\n", type->attributeWildcard, type->name);
if (type->attributeWildcard->processContents ==
XML_SCHEMAS_ANY_LAX)
printf("processContents: lax\n");
else if (type->attributeWildcard->processContents ==
XML_SCHEMAS_ANY_STRICT)
printf("processContents: strict\n");
else
printf("processContents: skip\n");
if (type->attributeWildcard->any)
printf("type: any\n");
else if (type->attributeWildcard->negNsSet != NULL) {
printf("type: negated\n");
if (type->attributeWildcard->negNsSet->value == NULL)
printf("ns: (absent)\n");
else
printf("ns: %s\n", type->attributeWildcard->negNsSet->value);
} else if (type->attributeWildcard->nsSet != NULL) {
printf("type: set\n");
ns = type->attributeWildcard->nsSet;
while (ns != NULL) {
if (ns->value == NULL)
printf("ns: (absent)\n");
else
printf("ns: %s\n", ns->value);
ns = ns->next;
}
} else
printf("empty\n");
#endif
curState = ctxt->attr;
while (curState != NULL) {
if (curState->state == XML_SCHEMAS_ATTR_UNKNOWN) {
if (curState->attr->ns != NULL)
nsURI = curState->attr->ns->href;
else
nsURI = NULL;
if (xmlSchemaMatchesWildcardNs(type->attributeWildcard,
nsURI)) {
if ((type->attributeWildcard->processContents ==
XML_SCHEMAS_ANY_LAX) ||
(type->attributeWildcard->processContents ==
XML_SCHEMAS_ANY_STRICT)) {
attr = curState->attr;
attrDecl = xmlSchemaGetAttribute(ctxt->schema,
attr->name, nsURI);
curState->decl = attrDecl;
if (attrDecl != NULL) {
curState->decl = attrDecl;
ret = xmlSchemaCheckAttrLocallyValid(ctxt, attrDecl, curState, attr);
} else if (type->attributeWildcard->processContents ==
XML_SCHEMAS_ANY_LAX) {
curState->state = XML_SCHEMAS_ATTR_CHECKED;
}
} else
curState->state = XML_SCHEMAS_ATTR_CHECKED;
}
}
curState = curState->next;
}
}
if (ctxt->attr != NULL) {
curState = ctxt->attr;
while ((curState != NULL) && (curState != ctxt->attrTop->next)) {
if (curState->state != XML_SCHEMAS_ATTR_CHECKED) {
attr = curState->attr;
if (curState->decl != NULL) {
if (curState->decl->ref != NULL)
attrDecl = curState->decl->refDecl;
else
attrDecl = curState->decl;
} else
attrDecl = NULL;
if (curState->state == XML_SCHEMAS_ATTR_MISSING) {
xmlSchemaVMissingAttrErr(ctxt, elem, attrDecl);
} else if (curState->state ==
XML_SCHEMAS_ATTR_TYPE_NOT_RESOLVED) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ATTRIBUTE_2,
(xmlNodePtr) attr,
(xmlSchemaTypePtr) attrDecl,
"The type definition is absent",
NULL);
} else if (curState->state ==
XML_SCHEMAS_ATTR_INVALID_FIXED_VALUE) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_AU,
(xmlNodePtr) attr, (xmlSchemaTypePtr) attrDecl,
"The value does not match the fixed value "
"constraint", NULL);
} else if (curState->state == XML_SCHEMAS_ATTR_UNKNOWN) {
if ((type == NULL) || (type->attributeWildcard == NULL)) {
xmlSchemaVIllegalAttrErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, attr);
} else {
xmlSchemaVIllegalAttrErr(ctxt,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, attr);
}
}
}
curState = curState->next;
}
}
if (ctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) {
curState = defAttrStates;
while (curState != NULL) {
attrDecl = curState->decl;
if (attrDecl->ref != NULL)
attrDecl = attrDecl->refDecl;
if (attrDecl->targetNamespace == NULL) {
xmlNewProp(elem, attrDecl->name, curState->value);
} else {
xmlNsPtr ns;
ns = xmlSearchNsByHref(elem->doc, elem,
attrDecl->targetNamespace);
if (ns == NULL) {
xmlChar prefix[12];
int counter = 1;
attr = curState->attr;
snprintf((char *) prefix, sizeof(prefix), "p");
ns = xmlSearchNs(elem->doc, elem, BAD_CAST prefix);
while (ns != NULL) {
if (counter > 1000) {
xmlSchemaVErr(ctxt, (xmlNodePtr) attr,
XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaValidateAttributes, "
"could not compute a ns prefix for "
"default/fixed attribute '%s'.\n",
attrDecl->name, NULL);
break;
}
snprintf((char *) prefix,
sizeof(prefix), "p%d", counter++);
ns = xmlSearchNs(elem->doc, elem,
BAD_CAST prefix);
}
if (ns == NULL) {
ns = xmlNewNs(ctxt->validationRoot,
attrDecl->targetNamespace, BAD_CAST prefix);
xmlNewNsProp(elem, ns, attrDecl->name,
curState->value);
}
} else {
xmlNewNsProp(elem, ns, attrDecl->name,
curState->value);
}
}
curState = curState->next;
}
}
if (defAttrStates != NULL)
xmlSchemaFreeAttributeStates(defAttrStates);
#ifdef DEBUG_ATTR_VALIDATION
if (redundant)
xmlGenericError(xmlGenericErrorContext,
"xmlSchemaValidateAttributes: redundant call by type: %s\n",
type->name);
#endif
ctxt->node = oldnode;
return (ctxt->err);
}
static int
xmlSchemaValidateElement(xmlSchemaValidCtxtPtr ctxt)
{
xmlSchemaElementPtr elemDecl;
int ret = 0;
if (ctxt->schema == NULL) {
if (ctxt->pctxt == NULL)
ctxt->pctxt = xmlSchemaNewParserCtxt("*");
if (ctxt->pctxt == NULL)
return (-1);
ctxt->schema = xmlSchemaNewSchema(ctxt->pctxt);
if (ctxt->schema == NULL)
return (-1);
ctxt->pctxt->error = ctxt->error;
ctxt->pctxt->warning = ctxt->warning;
ctxt->xsiAssemble = 1;
} else
ctxt->xsiAssemble = 0;
if (ctxt->xsiAssemble) {
ret = xmlSchemaAssembleByXSIElem(ctxt, ctxt->node);
if (ret == -1) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL,
ctxt->node, NULL,
"Internal error: xmlSchemaValidateElement, "
"assembling schema by xsi", NULL);
}
}
if (ret != -1) {
if (ctxt->node->ns != NULL)
elemDecl = xmlSchemaGetElem(ctxt->schema, ctxt->node->name,
ctxt->node->ns->href);
else
elemDecl = xmlSchemaGetElem(ctxt->schema, ctxt->node->name, NULL);
if (elemDecl == NULL) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_CVC_ELT_1,
ctxt->node, NULL,
"No matching global declaration available", NULL);
ret = XML_SCHEMAV_CVC_ELT_1;
} else {
ret = xmlSchemaValidateElementByDeclaration(ctxt, elemDecl);
if (ret < 0) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_INTERNAL, ctxt->node, NULL,
"Internal error: xmlSchemaValidateElement, "
"calling validation by declaration", NULL);
}
}
}
if (ctxt->xsiAssemble) {
if (ctxt->schema != NULL) {
xmlSchemaFree(ctxt->schema);
ctxt->schema = NULL;
}
}
return (ret);
}
int
xmlSchemaValidateOneElement(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem)
{
if ((ctxt == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE))
return (-1);
if (ctxt->schema == NULL) {
xmlSchemaVErr(ctxt, NULL,
XML_SCHEMAV_INTERNAL,
"API error: xmlSchemaValidateOneElement, "
"no schema specified.\n", NULL, NULL);
return (-1);
}
ctxt->doc = elem->doc;
ctxt->err = 0;
ctxt->nberrors = 0;
ctxt->node = elem;
ctxt->validationRoot = elem;
return (xmlSchemaValidateElement(ctxt));
}
static int
xmlSchemaValidateDocument(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
{
xmlNodePtr root;
root = xmlDocGetRootElement(doc);
if (root == NULL) {
xmlSchemaVCustomErr(ctxt,
XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
(xmlNodePtr) doc, NULL,
"The document has no document element", NULL);
return (ctxt->err);
}
ctxt->node = root;
ctxt->validationRoot = root;
xmlSchemaValidateElement(ctxt);
return (ctxt->err);
}
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->attrTop = NULL;
ret->attr = NULL;
return (ret);
}
void
xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
{
if (ctxt == NULL)
return;
if (ctxt->attr != NULL)
xmlSchemaFreeAttributeStates(ctxt->attr);
if (ctxt->value != NULL)
xmlSchemaFreeValue(ctxt->value);
if (ctxt->pctxt != NULL) {
xmlSchemaFreeParserCtxt(ctxt->pctxt);
}
xmlFree(ctxt);
}
void
xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn, void *ctx)
{
if (ctxt == NULL)
return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->userData = ctx;
if (ctxt->pctxt != NULL)
xmlSchemaSetParserErrors(ctxt->pctxt, err, warn, ctx);
}
int
xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt,
xmlSchemaValidityErrorFunc * err,
xmlSchemaValidityWarningFunc * warn, void **ctx)
{
if (ctxt == NULL)
return (-1);
if (err != NULL)
*err = ctxt->error;
if (warn != NULL)
*warn = ctxt->warning;
if (ctx != NULL)
*ctx = ctxt->userData;
return (0);
}
int
xmlSchemaSetValidOptions(xmlSchemaValidCtxtPtr ctxt,
int options)
{
int i;
if (ctxt == NULL)
return (-1);
for (i = 1; i < (int) sizeof(int) * 8; i++) {
if (options & 1<<i) {
xmlSchemaVErr(ctxt, NULL,
XML_SCHEMAV_INTERNAL,
"Internal error: xmlSchemaSetValidOptions, "
"invalid option argument.\n", NULL, NULL);
return (-1);
}
}
ctxt->options = options;
return (0);
}
int
xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt)
{
if (ctxt == NULL)
return (-1);
else
return (ctxt->options);
}
int
xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
{
int ret;
if ((ctxt == NULL) || (doc == NULL))
return (-1);
ctxt->doc = doc;
ctxt->err = 0;
ctxt->nberrors = 0;
ret = xmlSchemaValidateDocument(ctxt, doc);
return (ret);
}
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