diff options
Diffstat (limited to 'xmlschemastypes.c')
| -rw-r--r-- | xmlschemastypes.c | 681 |
1 files changed, 514 insertions, 167 deletions
diff --git a/xmlschemastypes.c b/xmlschemastypes.c index 9ed7fb0..78e10fc 100644 --- a/xmlschemastypes.c +++ b/xmlschemastypes.c @@ -39,59 +39,13 @@ #define XML_SCHEMAS_NAMESPACE_NAME \ (const xmlChar *)"http://www.w3.org/2001/XMLSchema" -typedef enum { - XML_SCHEMAS_UNKNOWN = 0, - XML_SCHEMAS_STRING, - XML_SCHEMAS_NORMSTRING, - XML_SCHEMAS_DECIMAL, - XML_SCHEMAS_TIME, - XML_SCHEMAS_GDAY, - XML_SCHEMAS_GMONTH, - XML_SCHEMAS_GMONTHDAY, - XML_SCHEMAS_GYEAR, - XML_SCHEMAS_GYEARMONTH, - XML_SCHEMAS_DATE, - XML_SCHEMAS_DATETIME, - XML_SCHEMAS_DURATION, - XML_SCHEMAS_FLOAT, - XML_SCHEMAS_DOUBLE, - XML_SCHEMAS_BOOLEAN, - XML_SCHEMAS_TOKEN, - XML_SCHEMAS_LANGUAGE, - XML_SCHEMAS_NMTOKEN, - XML_SCHEMAS_NMTOKENS, - XML_SCHEMAS_NAME, - XML_SCHEMAS_QNAME, - XML_SCHEMAS_NCNAME, - XML_SCHEMAS_ID, - XML_SCHEMAS_IDREF, - XML_SCHEMAS_IDREFS, - XML_SCHEMAS_ENTITY, - XML_SCHEMAS_ENTITIES, - XML_SCHEMAS_NOTATION, - XML_SCHEMAS_ANYURI, - XML_SCHEMAS_INTEGER, - XML_SCHEMAS_NPINTEGER, - XML_SCHEMAS_NINTEGER, - XML_SCHEMAS_NNINTEGER, - XML_SCHEMAS_PINTEGER, - XML_SCHEMAS_INT, - XML_SCHEMAS_UINT, - XML_SCHEMAS_LONG, - XML_SCHEMAS_ULONG, - XML_SCHEMAS_SHORT, - XML_SCHEMAS_USHORT, - XML_SCHEMAS_BYTE, - XML_SCHEMAS_UBYTE, - XML_SCHEMAS_HEXBINARY, - XML_SCHEMAS_BASE64BINARY -} xmlSchemaValType; static unsigned long powten[10] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000L, 100000000L, 1000000000L }; + /* Date value */ typedef struct _xmlSchemaValDate xmlSchemaValDate; typedef xmlSchemaValDate *xmlSchemaValDatePtr; @@ -249,10 +203,11 @@ xmlSchemaTypeErrMemory(xmlNodePtr node, const char *extra) * @name: the type name * @type: the value type associated * - * Initialize one default type + * Initialize one primitive built-in type */ static xmlSchemaTypePtr -xmlSchemaInitBasicType(const char *name, xmlSchemaValType type) { +xmlSchemaInitBasicType(const char *name, xmlSchemaValType type, + xmlSchemaTypePtr baseType) { xmlSchemaTypePtr ret; ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType)); @@ -263,10 +218,45 @@ xmlSchemaInitBasicType(const char *name, xmlSchemaValType type) { memset(ret, 0, sizeof(xmlSchemaType)); ret->name = (const xmlChar *)name; ret->type = XML_SCHEMA_TYPE_BASIC; - ret->flags = type; + ret->baseType = baseType; + /* + * Hack to reflect the variety. + */ + if ((type == XML_SCHEMAS_IDREFS) || + (type == XML_SCHEMAS_NMTOKENS) || + (type == XML_SCHEMAS_ENTITIES)) + ret->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST; + else if (type != XML_SCHEMAS_UNKNOWN) + ret->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC; ret->contentType = XML_SCHEMA_CONTENT_BASIC; + switch (type) { + case XML_SCHEMAS_STRING: + case XML_SCHEMAS_DECIMAL: + case XML_SCHEMAS_DATE: + case XML_SCHEMAS_DATETIME: + case XML_SCHEMAS_TIME: + case XML_SCHEMAS_GYEAR: + case XML_SCHEMAS_GYEARMONTH: + case XML_SCHEMAS_GMONTH: + case XML_SCHEMAS_GMONTHDAY: + case XML_SCHEMAS_GDAY: + case XML_SCHEMAS_DURATION: + case XML_SCHEMAS_FLOAT: + case XML_SCHEMAS_DOUBLE: + case XML_SCHEMAS_BOOLEAN: + case XML_SCHEMAS_ANYURI: + case XML_SCHEMAS_HEXBINARY: + case XML_SCHEMAS_BASE64BINARY: + case XML_SCHEMAS_QNAME: + case XML_SCHEMAS_NOTATION: + ret->flags |= XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE; + default: + break; + } + xmlHashAddEntry2(xmlSchemaTypesBank, ret->name, XML_SCHEMAS_NAMESPACE_NAME, ret); + ret->builtInType = type; return(ret); } @@ -282,106 +272,172 @@ xmlSchemaInitTypes(void) return; xmlSchemaTypesBank = xmlHashCreate(40); + /* - * primitive datatypes - */ - xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string", - XML_SCHEMAS_STRING); + * 3.4.7 Built-in Complex Type Definition + */ xmlSchemaTypeAnyTypeDef = xmlSchemaInitBasicType("anyType", - XML_SCHEMAS_UNKNOWN); - xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType", - XML_SCHEMAS_UNKNOWN); + XML_SCHEMAS_UNKNOWN, + NULL); + xmlSchemaTypeAnyTypeDef->baseType = xmlSchemaTypeAnyTypeDef; + xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED; + { + xmlSchemaWildcardPtr wild; + + wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard)); + if (wild == NULL) { + xmlSchemaTypeErrMemory(NULL, "could not create a wildcard on anyType"); + return; + } + memset(wild, 0, sizeof(xmlSchemaWildcard)); + wild->any = 1; + wild->processContents = XML_SCHEMAS_ANY_LAX; + wild->minOccurs = 1; + wild->maxOccurs = 1; + xmlSchemaTypeAnyTypeDef->attributeWildcard = wild; + } + xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType", + XML_SCHEMAS_UNKNOWN, + xmlSchemaTypeAnyTypeDef); + /* + * primitive datatypes + */ + xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string", + XML_SCHEMAS_STRING, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeDecimalDef = xmlSchemaInitBasicType("decimal", - XML_SCHEMAS_DECIMAL); + XML_SCHEMAS_DECIMAL, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeDateDef = xmlSchemaInitBasicType("date", - XML_SCHEMAS_DATE); + XML_SCHEMAS_DATE, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeDatetimeDef = xmlSchemaInitBasicType("dateTime", - XML_SCHEMAS_DATETIME); + XML_SCHEMAS_DATETIME, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeTimeDef = xmlSchemaInitBasicType("time", - XML_SCHEMAS_TIME); + XML_SCHEMAS_TIME, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeGYearDef = xmlSchemaInitBasicType("gYear", - XML_SCHEMAS_GYEAR); + XML_SCHEMAS_GYEAR, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeGYearMonthDef = xmlSchemaInitBasicType("gYearMonth", - XML_SCHEMAS_GYEARMONTH); + XML_SCHEMAS_GYEARMONTH, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeGMonthDef = xmlSchemaInitBasicType("gMonth", - XML_SCHEMAS_GMONTH); + XML_SCHEMAS_GMONTH, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeGMonthDayDef = xmlSchemaInitBasicType("gMonthDay", - XML_SCHEMAS_GMONTHDAY); + XML_SCHEMAS_GMONTHDAY, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeGDayDef = xmlSchemaInitBasicType("gDay", - XML_SCHEMAS_GDAY); + XML_SCHEMAS_GDAY, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeDurationDef = xmlSchemaInitBasicType("duration", - XML_SCHEMAS_DURATION); + XML_SCHEMAS_DURATION, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeFloatDef = xmlSchemaInitBasicType("float", - XML_SCHEMAS_FLOAT); + XML_SCHEMAS_FLOAT, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeDoubleDef = xmlSchemaInitBasicType("double", - XML_SCHEMAS_DOUBLE); + XML_SCHEMAS_DOUBLE, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeBooleanDef = xmlSchemaInitBasicType("boolean", - XML_SCHEMAS_BOOLEAN); + XML_SCHEMAS_BOOLEAN, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeAnyURIDef = xmlSchemaInitBasicType("anyURI", - XML_SCHEMAS_ANYURI); + XML_SCHEMAS_ANYURI, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeHexBinaryDef = xmlSchemaInitBasicType("hexBinary", - XML_SCHEMAS_HEXBINARY); + XML_SCHEMAS_HEXBINARY, + xmlSchemaTypeAnySimpleTypeDef); xmlSchemaTypeBase64BinaryDef - = xmlSchemaInitBasicType("base64Binary", XML_SCHEMAS_BASE64BINARY); + = xmlSchemaInitBasicType("base64Binary", XML_SCHEMAS_BASE64BINARY, + xmlSchemaTypeAnySimpleTypeDef); + xmlSchemaTypeNotationDef = xmlSchemaInitBasicType("NOTATION", + XML_SCHEMAS_NOTATION, + xmlSchemaTypeAnySimpleTypeDef); + xmlSchemaTypeQNameDef = xmlSchemaInitBasicType("QName", + XML_SCHEMAS_QNAME, + xmlSchemaTypeAnySimpleTypeDef); /* * derived datatypes */ xmlSchemaTypeIntegerDef = xmlSchemaInitBasicType("integer", - XML_SCHEMAS_INTEGER);; + XML_SCHEMAS_INTEGER, + xmlSchemaTypeDecimalDef); xmlSchemaTypeNonPositiveIntegerDef = xmlSchemaInitBasicType("nonPositiveInteger", - XML_SCHEMAS_NPINTEGER);; + XML_SCHEMAS_NPINTEGER, + xmlSchemaTypeIntegerDef); xmlSchemaTypeNegativeIntegerDef = - xmlSchemaInitBasicType("negativeInteger", XML_SCHEMAS_NINTEGER);; + xmlSchemaInitBasicType("negativeInteger", XML_SCHEMAS_NINTEGER, + xmlSchemaTypeNonPositiveIntegerDef); xmlSchemaTypeLongDef = - xmlSchemaInitBasicType("long", XML_SCHEMAS_LONG);; - xmlSchemaTypeIntDef = xmlSchemaInitBasicType("int", XML_SCHEMAS_INT);; + xmlSchemaInitBasicType("long", XML_SCHEMAS_LONG, + xmlSchemaTypeIntegerDef); + xmlSchemaTypeIntDef = xmlSchemaInitBasicType("int", XML_SCHEMAS_INT, + xmlSchemaTypeLongDef); xmlSchemaTypeShortDef = xmlSchemaInitBasicType("short", - XML_SCHEMAS_SHORT);; + XML_SCHEMAS_SHORT, + xmlSchemaTypeIntDef); xmlSchemaTypeByteDef = xmlSchemaInitBasicType("byte", - XML_SCHEMAS_BYTE);; + XML_SCHEMAS_BYTE, + xmlSchemaTypeShortDef); xmlSchemaTypeNonNegativeIntegerDef = xmlSchemaInitBasicType("nonNegativeInteger", - XML_SCHEMAS_NNINTEGER); + XML_SCHEMAS_NNINTEGER, + xmlSchemaTypeIntegerDef); xmlSchemaTypeUnsignedLongDef = - xmlSchemaInitBasicType("unsignedLong", XML_SCHEMAS_ULONG);; + xmlSchemaInitBasicType("unsignedLong", XML_SCHEMAS_ULONG, + xmlSchemaTypeNonNegativeIntegerDef); xmlSchemaTypeUnsignedIntDef = - xmlSchemaInitBasicType("unsignedInt", XML_SCHEMAS_UINT);; + xmlSchemaInitBasicType("unsignedInt", XML_SCHEMAS_UINT, + xmlSchemaTypeUnsignedLongDef); xmlSchemaTypeUnsignedShortDef = - xmlSchemaInitBasicType("unsignedShort", XML_SCHEMAS_USHORT);; + xmlSchemaInitBasicType("unsignedShort", XML_SCHEMAS_USHORT, + xmlSchemaTypeUnsignedIntDef); xmlSchemaTypeUnsignedByteDef = - xmlSchemaInitBasicType("unsignedByte", XML_SCHEMAS_UBYTE);; + xmlSchemaInitBasicType("unsignedByte", XML_SCHEMAS_UBYTE, + xmlSchemaTypeUnsignedShortDef); xmlSchemaTypePositiveIntegerDef = - xmlSchemaInitBasicType("positiveInteger", XML_SCHEMAS_PINTEGER); - + xmlSchemaInitBasicType("positiveInteger", XML_SCHEMAS_PINTEGER, + xmlSchemaTypeNonNegativeIntegerDef); xmlSchemaTypeNormStringDef = xmlSchemaInitBasicType("normalizedString", - XML_SCHEMAS_NORMSTRING); + XML_SCHEMAS_NORMSTRING, + xmlSchemaTypeStringDef); xmlSchemaTypeTokenDef = xmlSchemaInitBasicType("token", - XML_SCHEMAS_TOKEN); + XML_SCHEMAS_TOKEN, + xmlSchemaTypeNormStringDef); xmlSchemaTypeLanguageDef = xmlSchemaInitBasicType("language", - XML_SCHEMAS_LANGUAGE); - xmlSchemaTypeIdDef = xmlSchemaInitBasicType("ID", XML_SCHEMAS_ID); + XML_SCHEMAS_LANGUAGE, + xmlSchemaTypeTokenDef); + xmlSchemaTypeNameDef = xmlSchemaInitBasicType("Name", + XML_SCHEMAS_NAME, + xmlSchemaTypeTokenDef); + xmlSchemaTypeNmtokenDef = xmlSchemaInitBasicType("NMTOKEN", + XML_SCHEMAS_NMTOKEN, + xmlSchemaTypeTokenDef); + xmlSchemaTypeNCNameDef = xmlSchemaInitBasicType("NCName", + XML_SCHEMAS_NCNAME, + xmlSchemaTypeNameDef); + xmlSchemaTypeIdDef = xmlSchemaInitBasicType("ID", XML_SCHEMAS_ID, + xmlSchemaTypeNCNameDef); xmlSchemaTypeIdrefDef = xmlSchemaInitBasicType("IDREF", - XML_SCHEMAS_IDREF); + XML_SCHEMAS_IDREF, + xmlSchemaTypeNCNameDef); xmlSchemaTypeIdrefsDef = xmlSchemaInitBasicType("IDREFS", - XML_SCHEMAS_IDREFS); + XML_SCHEMAS_IDREFS, + xmlSchemaTypeIdrefDef); + xmlSchemaTypeNmtokensDef = xmlSchemaInitBasicType("NMTOKENS", + XML_SCHEMAS_NMTOKENS, + xmlSchemaTypeNmtokenDef); xmlSchemaTypeEntityDef = xmlSchemaInitBasicType("ENTITY", - XML_SCHEMAS_ENTITY); + XML_SCHEMAS_ENTITY, + xmlSchemaTypeNCNameDef); xmlSchemaTypeEntitiesDef = xmlSchemaInitBasicType("ENTITIES", - XML_SCHEMAS_ENTITIES); - xmlSchemaTypeNotationDef = xmlSchemaInitBasicType("NOTATION", - XML_SCHEMAS_NOTATION); - xmlSchemaTypeNameDef = xmlSchemaInitBasicType("Name", - XML_SCHEMAS_NAME); - xmlSchemaTypeQNameDef = xmlSchemaInitBasicType("QName", - XML_SCHEMAS_QNAME); - xmlSchemaTypeNCNameDef = xmlSchemaInitBasicType("NCName", - XML_SCHEMAS_NCNAME); - xmlSchemaTypeNmtokenDef = xmlSchemaInitBasicType("NMTOKEN", - XML_SCHEMAS_NMTOKEN); - xmlSchemaTypeNmtokensDef = xmlSchemaInitBasicType("NMTOKENS", - XML_SCHEMAS_NMTOKENS); + XML_SCHEMAS_ENTITIES, + xmlSchemaTypeNCNameDef); xmlSchemaTypesInitialized = 1; } @@ -394,11 +450,203 @@ void xmlSchemaCleanupTypes(void) { if (xmlSchemaTypesInitialized == 0) return; + xmlSchemaFreeWildcard(xmlSchemaTypeAnyTypeDef->attributeWildcard); xmlHashFree(xmlSchemaTypesBank, (xmlHashDeallocator) xmlSchemaFreeType); xmlSchemaTypesInitialized = 0; } /** + * xmlSchemaGetBuiltInType: + * @type: the built-in type + * @facetType: the facet type + * + * Evaluates if a specific facet can be + * used in conjunction with a type. + * + * Returns 1 if the facet can be used with the given built-in type, + * 0 otherwise and -1 in case the type is not a built-in type. + */ +int +xmlSchemaIsBuiltInTypeFacet(xmlSchemaTypePtr type, int facetType) +{ + if (type->type != XML_SCHEMA_TYPE_BASIC) + return (-1); + switch (type->builtInType) { + case XML_SCHEMAS_BOOLEAN: + if ((facetType == XML_SCHEMA_FACET_PATTERN) || + (facetType == XML_SCHEMA_FACET_WHITESPACE)) + return (1); + else + return (0); + case XML_SCHEMAS_STRING: + case XML_SCHEMAS_NOTATION: + case XML_SCHEMAS_QNAME: + case XML_SCHEMAS_ANYURI: + case XML_SCHEMAS_BASE64BINARY: + case XML_SCHEMAS_HEXBINARY: + if ((facetType == XML_SCHEMA_FACET_LENGTH) || + (facetType == XML_SCHEMA_FACET_MINLENGTH) || + (facetType == XML_SCHEMA_FACET_MAXLENGTH) || + (facetType == XML_SCHEMA_FACET_PATTERN) || + (facetType == XML_SCHEMA_FACET_ENUMERATION) || + (facetType == XML_SCHEMA_FACET_WHITESPACE)) + return (1); + else + return (0); + case XML_SCHEMAS_DECIMAL: + if ((facetType == XML_SCHEMA_FACET_TOTALDIGITS) || + (facetType == XML_SCHEMA_FACET_FRACTIONDIGITS) || + (facetType == XML_SCHEMA_FACET_PATTERN) || + (facetType == XML_SCHEMA_FACET_WHITESPACE) || + (facetType == XML_SCHEMA_FACET_ENUMERATION) || + (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MININCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE)) + return (1); + else + return (0); + case XML_SCHEMAS_TIME: + case XML_SCHEMAS_GDAY: + case XML_SCHEMAS_GMONTH: + case XML_SCHEMAS_GMONTHDAY: + case XML_SCHEMAS_GYEAR: + case XML_SCHEMAS_GYEARMONTH: + case XML_SCHEMAS_DATE: + case XML_SCHEMAS_DATETIME: + case XML_SCHEMAS_DURATION: + case XML_SCHEMAS_FLOAT: + case XML_SCHEMAS_DOUBLE: + if ((facetType == XML_SCHEMA_FACET_PATTERN) || + (facetType == XML_SCHEMA_FACET_ENUMERATION) || + (facetType == XML_SCHEMA_FACET_WHITESPACE) || + (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MININCLUSIVE) || + (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE)) + return (1); + else + return (0); + default: + return (0); + } + return (0); +} + +/** + * xmlSchemaGetBuiltInType: + * @type: the type of the built in type + * + * Gives you the type struct for a built-in + * type by its type id. + * + * Returns the type if found, NULL otherwise. + */ +xmlSchemaTypePtr +xmlSchemaGetBuiltInType(xmlSchemaValType type) +{ + if (xmlSchemaTypesInitialized == 0) + xmlSchemaInitTypes(); + switch (type) { + + case XML_SCHEMAS_ANYSIMPLETYPE: + return (xmlSchemaTypeAnySimpleTypeDef); + case XML_SCHEMAS_STRING: + return (xmlSchemaTypeStringDef); + case XML_SCHEMAS_NORMSTRING: + return (xmlSchemaTypeNormStringDef); + case XML_SCHEMAS_DECIMAL: + return (xmlSchemaTypeDecimalDef); + case XML_SCHEMAS_TIME: + return (xmlSchemaTypeTimeDef); + case XML_SCHEMAS_GDAY: + return (xmlSchemaTypeGDayDef); + case XML_SCHEMAS_GMONTH: + return (xmlSchemaTypeGMonthDef); + case XML_SCHEMAS_GMONTHDAY: + return (xmlSchemaTypeGMonthDayDef); + case XML_SCHEMAS_GYEAR: + return (xmlSchemaTypeGYearDef); + case XML_SCHEMAS_GYEARMONTH: + return (xmlSchemaTypeGYearMonthDef); + case XML_SCHEMAS_DATE: + return (xmlSchemaTypeDateDef); + case XML_SCHEMAS_DATETIME: + return (xmlSchemaTypeDatetimeDef); + case XML_SCHEMAS_DURATION: + return (xmlSchemaTypeDurationDef); + case XML_SCHEMAS_FLOAT: + return (xmlSchemaTypeFloatDef); + case XML_SCHEMAS_DOUBLE: + return (xmlSchemaTypeDoubleDef); + case XML_SCHEMAS_BOOLEAN: + return (xmlSchemaTypeBooleanDef); + case XML_SCHEMAS_TOKEN: + return (xmlSchemaTypeTokenDef); + case XML_SCHEMAS_LANGUAGE: + return (xmlSchemaTypeLanguageDef); + case XML_SCHEMAS_NMTOKEN: + return (xmlSchemaTypeNmtokenDef); + case XML_SCHEMAS_NMTOKENS: + return (xmlSchemaTypeNmtokensDef); + case XML_SCHEMAS_NAME: + return (xmlSchemaTypeNameDef); + case XML_SCHEMAS_QNAME: + return (xmlSchemaTypeQNameDef); + case XML_SCHEMAS_NCNAME: + return (xmlSchemaTypeNCNameDef); + case XML_SCHEMAS_ID: + return (xmlSchemaTypeIdDef); + case XML_SCHEMAS_IDREF: + return (xmlSchemaTypeIdrefDef); + case XML_SCHEMAS_IDREFS: + return (xmlSchemaTypeIdrefsDef); + case XML_SCHEMAS_ENTITY: + return (xmlSchemaTypeEntityDef); + case XML_SCHEMAS_ENTITIES: + return (xmlSchemaTypeEntitiesDef); + case XML_SCHEMAS_NOTATION: + return (xmlSchemaTypeNotationDef); + case XML_SCHEMAS_ANYURI: + return (xmlSchemaTypeAnyURIDef); + case XML_SCHEMAS_INTEGER: + return (xmlSchemaTypeIntegerDef); + case XML_SCHEMAS_NPINTEGER: + return (xmlSchemaTypeNonPositiveIntegerDef); + case XML_SCHEMAS_NINTEGER: + return (xmlSchemaTypeNegativeIntegerDef); + case XML_SCHEMAS_NNINTEGER: + return (xmlSchemaTypeNonNegativeIntegerDef); + case XML_SCHEMAS_PINTEGER: + return (xmlSchemaTypePositiveIntegerDef); + case XML_SCHEMAS_INT: + return (xmlSchemaTypeIntDef); + case XML_SCHEMAS_UINT: + return (xmlSchemaTypeUnsignedIntDef); + case XML_SCHEMAS_LONG: + return (xmlSchemaTypeLongDef); + case XML_SCHEMAS_ULONG: + return (xmlSchemaTypeUnsignedLongDef); + case XML_SCHEMAS_SHORT: + return (xmlSchemaTypeShortDef); + case XML_SCHEMAS_USHORT: + return (xmlSchemaTypeUnsignedShortDef); + case XML_SCHEMAS_BYTE: + return (xmlSchemaTypeByteDef); + case XML_SCHEMAS_UBYTE: + return (xmlSchemaTypeUnsignedByteDef); + case XML_SCHEMAS_HEXBINARY: + return (xmlSchemaTypeHexBinaryDef); + case XML_SCHEMAS_BASE64BINARY: + return (xmlSchemaTypeBase64BinaryDef); + case XML_SCHEMAS_ANYTYPE: + return (xmlSchemaTypeAnyTypeDef); + default: + return (NULL); + } +} + +/** * xmlSchemaNewValue: * @type: the value type * @@ -486,6 +734,30 @@ xmlSchemaGetPredefinedType(const xmlChar *name, const xmlChar *ns) { return((xmlSchemaTypePtr) xmlHashLookup2(xmlSchemaTypesBank, name, ns)); } +/** + * xmlSchemaGetBuiltInListSimpleTypeItemType: + * @type: the built-in simple type. + * + * Returns the item type of @type as defined by the built-in datatype + * hierarchy of XML Schema Part 2: Datatypes, or NULL in case of an error. + */ +xmlSchemaTypePtr +xmlSchemaGetBuiltInListSimpleTypeItemType(xmlSchemaTypePtr type) +{ + if (type->type != XML_SCHEMA_TYPE_BASIC) + return (NULL); + switch (type->builtInType) { + case XML_SCHEMAS_NMTOKENS: + return (xmlSchemaTypeNmtokenDef ); + case XML_SCHEMAS_IDREFS: + return (xmlSchemaTypeIdrefDef); + case XML_SCHEMAS_ENTITIES: + return (xmlSchemaTypeEntityDef); + default: + return (NULL); + } +} + /**************************************************************** * * * Convenience macros and functions * @@ -1269,7 +1541,7 @@ xmlSchemaStrip(const xmlChar *value) { * * Returns the new string or NULL if no change was required. */ -static xmlChar * +xmlChar * xmlSchemaCollapseString(const xmlChar *value) { const xmlChar *start = value, *end, *f; xmlChar *g; @@ -1442,6 +1714,7 @@ xmlSchemaParseUInt(const xmlChar **str, unsigned long *llo, * * Check that a value conforms to the lexical space of the atomic type. * if true a value is computed and returned in @val. + * This checks the value space for list types as well (IDREFS, NMTOKENS). * * Returns 0 if this validates, a positive error code number otherwise * and -1 in case of internal or API error. @@ -1455,24 +1728,24 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, int ret = 0; if (xmlSchemaTypesInitialized == 0) - return (-1); + xmlSchemaInitTypes(); if (type == NULL) return (-1); if (val != NULL) *val = NULL; if ((flags == 0) && (value != NULL)) { - if ((type->flags != XML_SCHEMAS_STRING) && - (type->flags != XML_SCHEMAS_NORMSTRING)) { + if ((type->builtInType != XML_SCHEMAS_STRING) && + (type->builtInType != XML_SCHEMAS_NORMSTRING)) { norm = xmlSchemaCollapseString(value); if (norm != NULL) value = norm; } } - switch (type->flags) { + switch (type->builtInType) { case XML_SCHEMAS_UNKNOWN: - if (type == xmlSchemaTypeAnyTypeDef) + if (type == xmlSchemaTypeAnySimpleTypeDef) goto return0; goto error; case XML_SCHEMAS_STRING: @@ -1548,7 +1821,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, case XML_SCHEMAS_GYEARMONTH: case XML_SCHEMAS_DATE: case XML_SCHEMAS_DATETIME: - ret = xmlSchemaValidateDates(type->flags, value, val); + ret = xmlSchemaValidateDates(type->builtInType, value, val); break; case XML_SCHEMAS_DURATION: ret = xmlSchemaValidateDuration(type, value, val); @@ -1649,7 +1922,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, if (v != NULL) { if (sscanf((const char *) value, "%f", &(v->value.f)) == 1) { - *val = v; + *val = v; } else { xmlSchemaFreeValue(v); goto return1; @@ -2210,21 +2483,21 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; if (*cur != 0) goto return1; - if (type->flags == XML_SCHEMAS_NPINTEGER) { + if (type->builtInType == XML_SCHEMAS_NPINTEGER) { if ((sign == 0) && ((hi != 0) || (mi != 0) || (lo != 0))) goto return1; - } else if (type->flags == XML_SCHEMAS_PINTEGER) { + } else if (type->builtInType == XML_SCHEMAS_PINTEGER) { if (sign == 1) goto return1; if ((hi == 0) && (mi == 0) && (lo == 0)) goto return1; - } else if (type->flags == XML_SCHEMAS_NINTEGER) { + } else if (type->builtInType == XML_SCHEMAS_NINTEGER) { if (sign == 0) goto return1; if ((hi == 0) && (mi == 0) && (lo == 0)) goto return1; - } else if (type->flags == XML_SCHEMAS_NNINTEGER) { + } else if (type->builtInType == XML_SCHEMAS_NNINTEGER) { if ((sign == 1) && ((hi != 0) || (mi != 0) || (lo != 0))) goto return1; @@ -2233,7 +2506,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, * We can store a value only if no overflow occured */ if ((ret > 0) && (val != NULL)) { - v = xmlSchemaNewValue(type->flags); + v = xmlSchemaNewValue(type->builtInType); if (v != NULL) { v->value.decimal.lo = lo; v->value.decimal.mi = lo; @@ -2267,7 +2540,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; if (*cur != 0) goto return1; - if (type->flags == XML_SCHEMAS_LONG) { + if (type->builtInType == XML_SCHEMAS_LONG) { if (hi >= 922) { if (hi > 922) goto return1; @@ -2280,7 +2553,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; } } - } else if (type->flags == XML_SCHEMAS_INT) { + } else if (type->builtInType == XML_SCHEMAS_INT) { if (hi != 0) goto return1; if (mi >= 21) { @@ -2291,14 +2564,14 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, if ((sign == 1) && (lo > 47483648)) goto return1; } - } else if (type->flags == XML_SCHEMAS_SHORT) { + } else if (type->builtInType == XML_SCHEMAS_SHORT) { if ((mi != 0) || (hi != 0)) goto return1; if ((sign == 1) && (lo > 32768)) goto return1; if ((sign == 0) && (lo > 32767)) goto return1; - } else if (type->flags == XML_SCHEMAS_BYTE) { + } else if (type->builtInType == XML_SCHEMAS_BYTE) { if ((mi != 0) || (hi != 0)) goto return1; if ((sign == 1) && (lo > 128)) @@ -2307,7 +2580,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; } if (val != NULL) { - v = xmlSchemaNewValue(type->flags); + v = xmlSchemaNewValue(type->builtInType); if (v != NULL) { v->value.decimal.lo = lo; v->value.decimal.mi = lo; @@ -2335,7 +2608,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; if (*cur != 0) goto return1; - if (type->flags == XML_SCHEMAS_ULONG) { + if (type->builtInType == XML_SCHEMAS_ULONG) { if (hi >= 1844) { if (hi > 1844) goto return1; @@ -2346,7 +2619,7 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, goto return1; } } - } else if (type->flags == XML_SCHEMAS_UINT) { + } else if (type->builtInType == XML_SCHEMAS_UINT) { if (hi != 0) goto return1; if (mi >= 42) { @@ -2355,19 +2628,19 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value, if (lo > 94967295) goto return1; } - } else if (type->flags == XML_SCHEMAS_USHORT) { + } else if (type->builtInType == XML_SCHEMAS_USHORT) { if ((mi != 0) || (hi != 0)) goto return1; if (lo > 65535) goto return1; - } else if (type->flags == XML_SCHEMAS_UBYTE) { + } else if (type->builtInType == XML_SCHEMAS_UBYTE) { if ((mi != 0) || (hi != 0)) goto return1; if (lo > 255) goto return1; } if (val != NULL) { - v = xmlSchemaNewValue(type->flags); + v = xmlSchemaNewValue(type->builtInType); if (v != NULL) { v->value.decimal.lo = lo; v->value.decimal.mi = mi; @@ -2477,11 +2750,11 @@ xmlSchemaCompareDecimals(xmlSchemaValPtr x, xmlSchemaValPtr y) if (x->value.decimal.frac == y->value.decimal.frac) { if (x->value.decimal.hi < y->value.decimal.hi) return (-order); - if (x->value.decimal.hi < y->value.decimal.hi) + if (x->value.decimal.hi > y->value.decimal.hi) return (order); if (x->value.decimal.mi < y->value.decimal.mi) return (-order); - if (x->value.decimal.mi < y->value.decimal.mi) + if (x->value.decimal.mi > y->value.decimal.mi) return (order); if (x->value.decimal.lo < y->value.decimal.lo) return (-order); @@ -2608,20 +2881,41 @@ xmlSchemaCompareDurations(xmlSchemaValPtr x, xmlSchemaValPtr y) #define MODULO_RANGE(a,low,high) ((MODULO((a-low),(high-low)))+low) /** + * xmlSchemaDupVal: + * @v: the #xmlSchemaValPtr value to duplicate + * + * Makes a copy of @v. The calling program is responsible for freeing + * the returned value. + * + * returns a pointer to a duplicated #xmlSchemaValPtr or NULL if error. + */ +static xmlSchemaValPtr +xmlSchemaDupVal (xmlSchemaValPtr v) +{ + xmlSchemaValPtr ret = xmlSchemaNewValue(v->type); + if (ret == NULL) + return NULL; + + memcpy(ret, v, sizeof(xmlSchemaVal)); + return ret; +} + +/** * _xmlSchemaDateAdd: * @dt: an #xmlSchemaValPtr * @dur: an #xmlSchemaValPtr of type #XS_DURATION * * Compute a new date/time from @dt and @dur. This function assumes @dt * is either #XML_SCHEMAS_DATETIME, #XML_SCHEMAS_DATE, #XML_SCHEMAS_GYEARMONTH, - * or #XML_SCHEMAS_GYEAR. + * or #XML_SCHEMAS_GYEAR. The returned #xmlSchemaVal is the same type as + * @dt. The calling program is responsible for freeing the returned value. * - * Returns date/time pointer or NULL. + * Returns a pointer to a new #xmlSchemaVal or NULL if error. */ static xmlSchemaValPtr _xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur) { - xmlSchemaValPtr ret; + xmlSchemaValPtr ret, tmp; long carry, tempdays, temp; xmlSchemaValDatePtr r, d; xmlSchemaValDurationPtr u; @@ -2633,8 +2927,15 @@ _xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur) if (ret == NULL) return NULL; + /* make a copy so we don't alter the original value */ + tmp = xmlSchemaDupVal(dt); + if (tmp == NULL) { + xmlSchemaFreeValue(ret); + return NULL; + } + r = &(ret->value.date); - d = &(dt->value.date); + d = &(tmp->value.date); u = &(dur->value.dur); /* normalization */ @@ -2740,32 +3041,20 @@ _xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur) } } - return ret; -} + xmlSchemaFreeValue(tmp); -/** - * xmlSchemaDupVal: - * @v: value to duplicate - * - * returns a duplicated value. - */ -static xmlSchemaValPtr -xmlSchemaDupVal (xmlSchemaValPtr v) -{ - xmlSchemaValPtr ret = xmlSchemaNewValue(v->type); - if (ret == NULL) - return ret; - - memcpy(ret, v, sizeof(xmlSchemaVal)); return ret; } /** * xmlSchemaDateNormalize: - * @dt: an #xmlSchemaValPtr + * @dt: an #xmlSchemaValPtr of a date/time type value. + * @offset: number of seconds to adjust @dt by. * - * Normalize @dt to GMT time. + * Normalize @dt to GMT time. The @offset parameter is subtracted from + * the return value is a time-zone offset is present on @dt. * + * Returns a normalized copy of @dt or NULL if error. */ static xmlSchemaValPtr xmlSchemaDateNormalize (xmlSchemaValPtr dt, double offset) @@ -3378,6 +3667,9 @@ xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) { case XML_SCHEMAS_NMTOKENS: TODO break; + case XML_SCHEMAS_ANYTYPE: + case XML_SCHEMAS_ANYSIMPLETYPE: + break; } return -2; } @@ -3429,6 +3721,53 @@ xmlSchemaNormLen(const xmlChar *value) { } /** + * xmlSchemaValidateListSimpleTypeFacet: + * @facet: the facet to check + * @value: the lexical repr of the value to validate + * @actualLen: the number of list items + * @expectedLen: the resulting expected number of list items + * + * Checks the value of a list simple type against a facet. + * + * Returns 0 if the value is valid, a positive error code + * number otherwise and -1 in case of an internal error. + */ +int +xmlSchemaValidateListSimpleTypeFacet(xmlSchemaFacetPtr facet, + const xmlChar *value, + unsigned long actualLen, + unsigned long *expectedLen) +{ + /* + * TODO: Check if this will work with large numbers. + * (compare value.decimal.mi and value.decimal.hi as well?). + */ + if (facet->type == XML_SCHEMA_FACET_LENGTH) { + if (actualLen != facet->val->value.decimal.lo) { + *expectedLen = facet->val->value.decimal.lo; + return (XML_SCHEMAV_CVC_LENGTH_VALID); + } + } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) { + if (actualLen < facet->val->value.decimal.lo) { + *expectedLen = facet->val->value.decimal.lo; + return (XML_SCHEMAV_CVC_MINLENGTH_VALID); + } + } else if (facet->type == XML_SCHEMA_FACET_MAXLENGTH) { + if (actualLen > facet->val->value.decimal.lo) { + *expectedLen = facet->val->value.decimal.lo; + return (XML_SCHEMAV_CVC_MAXLENGTH_VALID); + } + } else + /* + * NOTE: That we can pass NULL as xmlSchemaValPtr to + * xmlSchemaValidateFacet, since the remaining facet types + * are: XML_SCHEMA_FACET_PATTERN, XML_SCHEMA_FACET_ENUMERATION. + */ + return(xmlSchemaValidateFacet(NULL, facet, value, NULL)); + return (0); +} + +/** * xmlSchemaValidateFacet: * @base: the base type * @facet: the facet to check @@ -3453,8 +3792,7 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, if (ret == 1) return(0); if (ret == 0) { - /* TODO error code */ - return(1); + return(XML_SCHEMAV_CVC_PATTERN_VALID); } return(ret); case XML_SCHEMA_FACET_MAXEXCLUSIVE: @@ -3466,7 +3804,7 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, if (ret == -1) return(0); /* error code */ - return(1); + return(XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID); case XML_SCHEMA_FACET_MAXINCLUSIVE: ret = xmlSchemaCompareValues(val, facet->val); if (ret == -2) { @@ -3476,7 +3814,7 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, if ((ret == -1) || (ret == 0)) return(0); /* error code */ - return(1); + return(XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID); case XML_SCHEMA_FACET_MINEXCLUSIVE: ret = xmlSchemaCompareValues(val, facet->val); if (ret == -2) { @@ -3486,7 +3824,7 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, if (ret == 1) return(0); /* error code */ - return(1); + return(XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID); case XML_SCHEMA_FACET_MININCLUSIVE: ret = xmlSchemaCompareValues(val, facet->val); if (ret == -2) { @@ -3496,15 +3834,20 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, if ((ret == 1) || (ret == 0)) return(0); /* error code */ - return(1); + return(XML_SCHEMAV_CVC_MININCLUSIVE_VALID); case XML_SCHEMA_FACET_WHITESPACE: /* TODO whitespaces */ + /* + * NOTE: Whitespace should be handled to normalize + * the value to be validated against a the facets; + * not to normalize the value in-between. + */ return(0); case XML_SCHEMA_FACET_ENUMERATION: if ((facet->value != NULL) && (xmlStrEqual(facet->value, value))) return(0); - return(1); + return(XML_SCHEMAV_CVC_ENUMERATION_VALID); case XML_SCHEMA_FACET_LENGTH: case XML_SCHEMA_FACET_MAXLENGTH: case XML_SCHEMA_FACET_MINLENGTH: { @@ -3521,7 +3864,7 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY)) len = val->value.base64.total; else { - switch (base->flags) { + switch (base->builtInType) { case XML_SCHEMAS_IDREF: case XML_SCHEMAS_NORMSTRING: case XML_SCHEMAS_TOKEN: @@ -3533,6 +3876,10 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, len = xmlSchemaNormLen(value); break; case XML_SCHEMAS_STRING: + /* + * FIXME: What exactly to do with anyURI? + */ + case XML_SCHEMAS_ANYURI: if (value != NULL) len = xmlUTF8Strlen(value); break; @@ -3542,13 +3889,13 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, } if (facet->type == XML_SCHEMA_FACET_LENGTH) { if (len != facet->val->value.decimal.lo) - return(1); + return(XML_SCHEMAV_CVC_LENGTH_VALID); } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) { if (len < facet->val->value.decimal.lo) - return(1); + return(XML_SCHEMAV_CVC_MINLENGTH_VALID); } else { if (len > facet->val->value.decimal.lo) - return(1); + return(XML_SCHEMAV_CVC_MAXLENGTH_VALID); } break; } @@ -3580,11 +3927,11 @@ xmlSchemaValidateFacet(xmlSchemaTypePtr base ATTRIBUTE_UNUSED, } if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) { if (val->value.decimal.total > facet->val->value.decimal.lo) - return(1); + return(XML_SCHEMAV_CVC_TOTALDIGITS_VALID); } else if (facet->type == XML_SCHEMA_FACET_FRACTIONDIGITS) { if (val->value.decimal.frac > facet->val->value.decimal.lo) - return(1); + return(XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID); } break; default: |