Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/libxml/src/xmlschemastypes.c

Issue 2804483002: Check in the libxml roll script. (Closed)
Patch Set: Code review feedback for the roll script. Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/libxml/src/xmlschemas.c ('k') | third_party/libxml/src/xpointer.c » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/libxml/src/xmlschemastypes.c
diff --git a/third_party/libxml/src/xmlschemastypes.c b/third_party/libxml/src/xmlschemastypes.c
deleted file mode 100644
index 5f38599044632541a6b5337f87614fdc98a00b71..0000000000000000000000000000000000000000
--- a/third_party/libxml/src/xmlschemastypes.c
+++ /dev/null
@@ -1,6152 +0,0 @@
-/*
- * schemastypes.c : implementation of the XML Schema Datatypes
- * definition and validity checking
- *
- * See Copyright for the status of this software.
- *
- * Daniel Veillard <veillard@redhat.com>
- */
-
-#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/valid.h>
-#include <libxml/xpath.h>
-#include <libxml/uri.h>
-
-#include <libxml/xmlschemas.h>
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemastypes.h>
-
-#ifdef HAVE_MATH_H
-#include <math.h>
-#endif
-#ifdef HAVE_FLOAT_H
-#include <float.h>
-#endif
-
-#define DEBUG
-
-#ifndef LIBXML_XPATH_ENABLED
-extern double xmlXPathNAN;
-extern double xmlXPathPINF;
-extern double xmlXPathNINF;
-#endif
-
-#define TODO \
- xmlGenericError(xmlGenericErrorContext, \
- "Unimplemented block at %s:%d\n", \
- __FILE__, __LINE__);
-
-#define XML_SCHEMAS_NAMESPACE_NAME \
- (const xmlChar *)"http://www.w3.org/2001/XMLSchema"
-
-#define IS_WSP_REPLACE_CH(c) ((((c) == 0x9) || ((c) == 0xa)) || \
- ((c) == 0xd))
-
-#define IS_WSP_SPACE_CH(c) ((c) == 0x20)
-
-#define IS_WSP_BLANK_CH(c) IS_BLANK_CH(c)
-
-/* Date value */
-typedef struct _xmlSchemaValDate xmlSchemaValDate;
-typedef xmlSchemaValDate *xmlSchemaValDatePtr;
-struct _xmlSchemaValDate {
- long year;
- unsigned int mon :4; /* 1 <= mon <= 12 */
- unsigned int day :5; /* 1 <= day <= 31 */
- unsigned int hour :5; /* 0 <= hour <= 24 */
- unsigned int min :6; /* 0 <= min <= 59 */
- double sec;
- unsigned int tz_flag :1; /* is tzo explicitely set? */
- signed int tzo :12; /* -1440 <= tzo <= 1440;
- currently only -840 to +840 are needed */
-};
-
-/* Duration value */
-typedef struct _xmlSchemaValDuration xmlSchemaValDuration;
-typedef xmlSchemaValDuration *xmlSchemaValDurationPtr;
-struct _xmlSchemaValDuration {
- long mon; /* mon stores years also */
- long day;
- double sec; /* sec stores min and hour also */
-};
-
-typedef struct _xmlSchemaValDecimal xmlSchemaValDecimal;
-typedef xmlSchemaValDecimal *xmlSchemaValDecimalPtr;
-struct _xmlSchemaValDecimal {
- /* would use long long but not portable */
- unsigned long lo;
- unsigned long mi;
- unsigned long hi;
- unsigned int extra;
- unsigned int sign:1;
- unsigned int frac:7;
- unsigned int total:8;
-};
-
-typedef struct _xmlSchemaValQName xmlSchemaValQName;
-typedef xmlSchemaValQName *xmlSchemaValQNamePtr;
-struct _xmlSchemaValQName {
- xmlChar *name;
- xmlChar *uri;
-};
-
-typedef struct _xmlSchemaValHex xmlSchemaValHex;
-typedef xmlSchemaValHex *xmlSchemaValHexPtr;
-struct _xmlSchemaValHex {
- xmlChar *str;
- unsigned int total;
-};
-
-typedef struct _xmlSchemaValBase64 xmlSchemaValBase64;
-typedef xmlSchemaValBase64 *xmlSchemaValBase64Ptr;
-struct _xmlSchemaValBase64 {
- xmlChar *str;
- unsigned int total;
-};
-
-struct _xmlSchemaVal {
- xmlSchemaValType type;
- struct _xmlSchemaVal *next;
- union {
- xmlSchemaValDecimal decimal;
- xmlSchemaValDate date;
- xmlSchemaValDuration dur;
- xmlSchemaValQName qname;
- xmlSchemaValHex hex;
- xmlSchemaValBase64 base64;
- float f;
- double d;
- int b;
- xmlChar *str;
- } value;
-};
-
-static int xmlSchemaTypesInitialized = 0;
-static xmlHashTablePtr xmlSchemaTypesBank = NULL;
-
-/*
- * Basic types
- */
-static xmlSchemaTypePtr xmlSchemaTypeStringDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeAnyTypeDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeAnySimpleTypeDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeDecimalDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeDatetimeDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeDateDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeTimeDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeGYearDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeGYearMonthDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeGDayDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeGMonthDayDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeGMonthDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeDurationDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeFloatDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeBooleanDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeDoubleDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeHexBinaryDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeBase64BinaryDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeAnyURIDef = NULL;
-
-/*
- * Derived types
- */
-static xmlSchemaTypePtr xmlSchemaTypePositiveIntegerDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNonPositiveIntegerDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNegativeIntegerDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNonNegativeIntegerDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeIntegerDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeLongDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeIntDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeShortDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeByteDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeUnsignedLongDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeUnsignedIntDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeUnsignedShortDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeUnsignedByteDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNormStringDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeTokenDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeLanguageDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNameDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeQNameDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNCNameDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeIdDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeIdrefDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeIdrefsDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeEntityDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeEntitiesDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNotationDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNmtokenDef = NULL;
-static xmlSchemaTypePtr xmlSchemaTypeNmtokensDef = NULL;
-
-/************************************************************************
- * *
- * Datatype error handlers *
- * *
- ************************************************************************/
-/**
- * xmlSchemaTypeErrMemory:
- * @extra: extra informations
- *
- * Handle an out of memory condition
- */
-static void
-xmlSchemaTypeErrMemory(xmlNodePtr node, const char *extra)
-{
- __xmlSimpleError(XML_FROM_DATATYPE, XML_ERR_NO_MEMORY, node, NULL, extra);
-}
-
-/************************************************************************
- * *
- * Base types support *
- * *
- ************************************************************************/
-
-/**
- * xmlSchemaNewValue:
- * @type: the value type
- *
- * Allocate a new simple type value
- *
- * Returns a pointer to the new value or NULL in case of error
- */
-static xmlSchemaValPtr
-xmlSchemaNewValue(xmlSchemaValType type) {
- xmlSchemaValPtr value;
-
- value = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
- if (value == NULL) {
- return(NULL);
- }
- memset(value, 0, sizeof(xmlSchemaVal));
- value->type = type;
- return(value);
-}
-
-static xmlSchemaFacetPtr
-xmlSchemaNewMinLengthFacet(int value)
-{
- xmlSchemaFacetPtr ret;
-
- ret = xmlSchemaNewFacet();
- if (ret == NULL) {
- return(NULL);
- }
- ret->type = XML_SCHEMA_FACET_MINLENGTH;
- ret->val = xmlSchemaNewValue(XML_SCHEMAS_NNINTEGER);
- if (ret->val == NULL) {
- xmlFree(ret);
- return(NULL);
- }
- ret->val->value.decimal.lo = value;
- return (ret);
-}
-
-/*
- * xmlSchemaInitBasicType:
- * @name: the type name
- * @type: the value type associated
- *
- * Initialize one primitive built-in type
- */
-static xmlSchemaTypePtr
-xmlSchemaInitBasicType(const char *name, xmlSchemaValType type,
- xmlSchemaTypePtr baseType) {
- xmlSchemaTypePtr ret;
-
- ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
- if (ret == NULL) {
- xmlSchemaTypeErrMemory(NULL, "could not initialize basic types");
- return(NULL);
- }
- memset(ret, 0, sizeof(xmlSchemaType));
- ret->name = (const xmlChar *)name;
- ret->targetNamespace = XML_SCHEMAS_NAMESPACE_NAME;
- ret->type = XML_SCHEMA_TYPE_BASIC;
- ret->baseType = baseType;
- ret->contentType = XML_SCHEMA_CONTENT_BASIC;
- /*
- * Primitive types.
- */
- 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;
- break;
- default:
- break;
- }
- /*
- * Set variety.
- */
- switch (type) {
- case XML_SCHEMAS_ANYTYPE:
- case XML_SCHEMAS_ANYSIMPLETYPE:
- break;
- case XML_SCHEMAS_IDREFS:
- case XML_SCHEMAS_NMTOKENS:
- case XML_SCHEMAS_ENTITIES:
- ret->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
- ret->facets = xmlSchemaNewMinLengthFacet(1);
- ret->flags |= XML_SCHEMAS_TYPE_HAS_FACETS;
- break;
- default:
- ret->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
- break;
- }
- xmlHashAddEntry2(xmlSchemaTypesBank, ret->name,
- XML_SCHEMAS_NAMESPACE_NAME, ret);
- ret->builtInType = type;
- return(ret);
-}
-
-/*
-* WARNING: Those type reside normally in xmlschemas.c but are
-* redefined here locally in oder of being able to use them for xs:anyType-
-* TODO: Remove those definition if we move the types to a header file.
-* TODO: Always keep those structs up-to-date with the originals.
-*/
-#define UNBOUNDED (1 << 30)
-
-typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
-typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
-struct _xmlSchemaTreeItem {
- xmlSchemaTypeType type;
- xmlSchemaAnnotPtr annot;
- xmlSchemaTreeItemPtr next;
- xmlSchemaTreeItemPtr children;
-};
-
-typedef struct _xmlSchemaParticle xmlSchemaParticle;
-typedef xmlSchemaParticle *xmlSchemaParticlePtr;
-struct _xmlSchemaParticle {
- xmlSchemaTypeType type;
- xmlSchemaAnnotPtr annot;
- xmlSchemaTreeItemPtr next;
- xmlSchemaTreeItemPtr children;
- int minOccurs;
- int maxOccurs;
- xmlNodePtr node;
-};
-
-typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
-typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
-struct _xmlSchemaModelGroup {
- xmlSchemaTypeType type;
- xmlSchemaAnnotPtr annot;
- xmlSchemaTreeItemPtr next;
- xmlSchemaTreeItemPtr children;
- xmlNodePtr node;
-};
-
-static xmlSchemaParticlePtr
-xmlSchemaAddParticle(void)
-{
- xmlSchemaParticlePtr ret = NULL;
-
- ret = (xmlSchemaParticlePtr)
- xmlMalloc(sizeof(xmlSchemaParticle));
- if (ret == NULL) {
- xmlSchemaTypeErrMemory(NULL, "allocating particle component");
- return (NULL);
- }
- memset(ret, 0, sizeof(xmlSchemaParticle));
- ret->type = XML_SCHEMA_TYPE_PARTICLE;
- ret->minOccurs = 1;
- ret->maxOccurs = 1;
- return (ret);
-}
-
-/*
- * xmlSchemaInitTypes:
- *
- * Initialize the default XML Schemas type library
- */
-void
-xmlSchemaInitTypes(void)
-{
- if (xmlSchemaTypesInitialized != 0)
- return;
- xmlSchemaTypesBank = xmlHashCreate(40);
-
-
- /*
- * 3.4.7 Built-in Complex Type Definition
- */
- xmlSchemaTypeAnyTypeDef = xmlSchemaInitBasicType("anyType",
- XML_SCHEMAS_ANYTYPE,
- NULL);
- xmlSchemaTypeAnyTypeDef->baseType = xmlSchemaTypeAnyTypeDef;
- xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
- /*
- * Init the content type.
- */
- xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
- {
- xmlSchemaParticlePtr particle;
- xmlSchemaModelGroupPtr sequence;
- xmlSchemaWildcardPtr wild;
- /* First particle. */
- particle = xmlSchemaAddParticle();
- if (particle == NULL)
- return;
- xmlSchemaTypeAnyTypeDef->subtypes = (xmlSchemaTypePtr) particle;
- /* Sequence model group. */
- sequence = (xmlSchemaModelGroupPtr)
- xmlMalloc(sizeof(xmlSchemaModelGroup));
- if (sequence == NULL) {
- xmlSchemaTypeErrMemory(NULL, "allocating model group component");
- return;
- }
- memset(sequence, 0, sizeof(xmlSchemaModelGroup));
- sequence->type = XML_SCHEMA_TYPE_SEQUENCE;
- particle->children = (xmlSchemaTreeItemPtr) sequence;
- /* Second particle. */
- particle = xmlSchemaAddParticle();
- if (particle == NULL)
- return;
- particle->minOccurs = 0;
- particle->maxOccurs = UNBOUNDED;
- sequence->children = (xmlSchemaTreeItemPtr) particle;
- /* The wildcard */
- wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
- if (wild == NULL) {
- xmlSchemaTypeErrMemory(NULL, "allocating wildcard component");
- return;
- }
- memset(wild, 0, sizeof(xmlSchemaWildcard));
- wild->type = XML_SCHEMA_TYPE_ANY;
- wild->any = 1;
- wild->processContents = XML_SCHEMAS_ANY_LAX;
- particle->children = (xmlSchemaTreeItemPtr) wild;
- /*
- * Create the attribute wildcard.
- */
- wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
- if (wild == NULL) {
- xmlSchemaTypeErrMemory(NULL, "could not create an attribute "
- "wildcard on anyType");
- return;
- }
- memset(wild, 0, sizeof(xmlSchemaWildcard));
- wild->any = 1;
- wild->processContents = XML_SCHEMAS_ANY_LAX;
- xmlSchemaTypeAnyTypeDef->attributeWildcard = wild;
- }
- xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType",
- XML_SCHEMAS_ANYSIMPLETYPE,
- xmlSchemaTypeAnyTypeDef);
- /*
- * primitive datatypes
- */
- xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string",
- XML_SCHEMAS_STRING,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeDecimalDef = xmlSchemaInitBasicType("decimal",
- XML_SCHEMAS_DECIMAL,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeDateDef = xmlSchemaInitBasicType("date",
- XML_SCHEMAS_DATE,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeDatetimeDef = xmlSchemaInitBasicType("dateTime",
- XML_SCHEMAS_DATETIME,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeTimeDef = xmlSchemaInitBasicType("time",
- XML_SCHEMAS_TIME,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeGYearDef = xmlSchemaInitBasicType("gYear",
- XML_SCHEMAS_GYEAR,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeGYearMonthDef = xmlSchemaInitBasicType("gYearMonth",
- XML_SCHEMAS_GYEARMONTH,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeGMonthDef = xmlSchemaInitBasicType("gMonth",
- XML_SCHEMAS_GMONTH,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeGMonthDayDef = xmlSchemaInitBasicType("gMonthDay",
- XML_SCHEMAS_GMONTHDAY,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeGDayDef = xmlSchemaInitBasicType("gDay",
- XML_SCHEMAS_GDAY,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeDurationDef = xmlSchemaInitBasicType("duration",
- XML_SCHEMAS_DURATION,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeFloatDef = xmlSchemaInitBasicType("float",
- XML_SCHEMAS_FLOAT,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeDoubleDef = xmlSchemaInitBasicType("double",
- XML_SCHEMAS_DOUBLE,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeBooleanDef = xmlSchemaInitBasicType("boolean",
- XML_SCHEMAS_BOOLEAN,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeAnyURIDef = xmlSchemaInitBasicType("anyURI",
- XML_SCHEMAS_ANYURI,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeHexBinaryDef = xmlSchemaInitBasicType("hexBinary",
- XML_SCHEMAS_HEXBINARY,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeBase64BinaryDef
- = 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,
- xmlSchemaTypeDecimalDef);
- xmlSchemaTypeNonPositiveIntegerDef =
- xmlSchemaInitBasicType("nonPositiveInteger",
- XML_SCHEMAS_NPINTEGER,
- xmlSchemaTypeIntegerDef);
- xmlSchemaTypeNegativeIntegerDef =
- xmlSchemaInitBasicType("negativeInteger", XML_SCHEMAS_NINTEGER,
- xmlSchemaTypeNonPositiveIntegerDef);
- xmlSchemaTypeLongDef =
- xmlSchemaInitBasicType("long", XML_SCHEMAS_LONG,
- xmlSchemaTypeIntegerDef);
- xmlSchemaTypeIntDef = xmlSchemaInitBasicType("int", XML_SCHEMAS_INT,
- xmlSchemaTypeLongDef);
- xmlSchemaTypeShortDef = xmlSchemaInitBasicType("short",
- XML_SCHEMAS_SHORT,
- xmlSchemaTypeIntDef);
- xmlSchemaTypeByteDef = xmlSchemaInitBasicType("byte",
- XML_SCHEMAS_BYTE,
- xmlSchemaTypeShortDef);
- xmlSchemaTypeNonNegativeIntegerDef =
- xmlSchemaInitBasicType("nonNegativeInteger",
- XML_SCHEMAS_NNINTEGER,
- xmlSchemaTypeIntegerDef);
- xmlSchemaTypeUnsignedLongDef =
- xmlSchemaInitBasicType("unsignedLong", XML_SCHEMAS_ULONG,
- xmlSchemaTypeNonNegativeIntegerDef);
- xmlSchemaTypeUnsignedIntDef =
- xmlSchemaInitBasicType("unsignedInt", XML_SCHEMAS_UINT,
- xmlSchemaTypeUnsignedLongDef);
- xmlSchemaTypeUnsignedShortDef =
- xmlSchemaInitBasicType("unsignedShort", XML_SCHEMAS_USHORT,
- xmlSchemaTypeUnsignedIntDef);
- xmlSchemaTypeUnsignedByteDef =
- xmlSchemaInitBasicType("unsignedByte", XML_SCHEMAS_UBYTE,
- xmlSchemaTypeUnsignedShortDef);
- xmlSchemaTypePositiveIntegerDef =
- xmlSchemaInitBasicType("positiveInteger", XML_SCHEMAS_PINTEGER,
- xmlSchemaTypeNonNegativeIntegerDef);
- xmlSchemaTypeNormStringDef = xmlSchemaInitBasicType("normalizedString",
- XML_SCHEMAS_NORMSTRING,
- xmlSchemaTypeStringDef);
- xmlSchemaTypeTokenDef = xmlSchemaInitBasicType("token",
- XML_SCHEMAS_TOKEN,
- xmlSchemaTypeNormStringDef);
- xmlSchemaTypeLanguageDef = xmlSchemaInitBasicType("language",
- 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,
- xmlSchemaTypeNCNameDef);
- xmlSchemaTypeEntityDef = xmlSchemaInitBasicType("ENTITY",
- XML_SCHEMAS_ENTITY,
- xmlSchemaTypeNCNameDef);
- /*
- * Derived list types.
- */
- /* ENTITIES */
- xmlSchemaTypeEntitiesDef = xmlSchemaInitBasicType("ENTITIES",
- XML_SCHEMAS_ENTITIES,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeEntitiesDef->subtypes = xmlSchemaTypeEntityDef;
- /* IDREFS */
- xmlSchemaTypeIdrefsDef = xmlSchemaInitBasicType("IDREFS",
- XML_SCHEMAS_IDREFS,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeIdrefsDef->subtypes = xmlSchemaTypeIdrefDef;
-
- /* NMTOKENS */
- xmlSchemaTypeNmtokensDef = xmlSchemaInitBasicType("NMTOKENS",
- XML_SCHEMAS_NMTOKENS,
- xmlSchemaTypeAnySimpleTypeDef);
- xmlSchemaTypeNmtokensDef->subtypes = xmlSchemaTypeNmtokenDef;
-
- xmlSchemaTypesInitialized = 1;
-}
-
-/**
- * xmlSchemaCleanupTypes:
- *
- * Cleanup the default XML Schemas type library
- */
-void
-xmlSchemaCleanupTypes(void) {
- if (xmlSchemaTypesInitialized == 0)
- return;
- /*
- * Free xs:anyType.
- */
- {
- xmlSchemaParticlePtr particle;
- /* Attribute wildcard. */
- xmlSchemaFreeWildcard(xmlSchemaTypeAnyTypeDef->attributeWildcard);
- /* Content type. */
- particle = (xmlSchemaParticlePtr) xmlSchemaTypeAnyTypeDef->subtypes;
- /* Wildcard. */
- xmlSchemaFreeWildcard((xmlSchemaWildcardPtr)
- particle->children->children->children);
- xmlFree((xmlSchemaParticlePtr) particle->children->children);
- /* Sequence model group. */
- xmlFree((xmlSchemaModelGroupPtr) particle->children);
- xmlFree((xmlSchemaParticlePtr) particle);
- xmlSchemaTypeAnyTypeDef->subtypes = NULL;
- }
- xmlHashFree(xmlSchemaTypesBank, (xmlHashDeallocator) xmlSchemaFreeType);
- xmlSchemaTypesInitialized = 0;
-}
-
-/**
- * xmlSchemaIsBuiltInTypeFacet:
- * @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 == NULL)
- return (-1);
- 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:
- break;
- }
- 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);
- }
-}
-
-/**
- * xmlSchemaValueAppend:
- * @prev: the value
- * @cur: the value to be appended
- *
- * Appends a next sibling to a list of computed values.
- *
- * Returns 0 if succeeded and -1 on API errors.
- */
-int
-xmlSchemaValueAppend(xmlSchemaValPtr prev, xmlSchemaValPtr cur) {
-
- if ((prev == NULL) || (cur == NULL))
- return (-1);
- prev->next = cur;
- return (0);
-}
-
-/**
- * xmlSchemaValueGetNext:
- * @cur: the value
- *
- * Accessor for the next sibling of a list of computed values.
- *
- * Returns the next value or NULL if there was none, or on
- * API errors.
- */
-xmlSchemaValPtr
-xmlSchemaValueGetNext(xmlSchemaValPtr cur) {
-
- if (cur == NULL)
- return (NULL);
- return (cur->next);
-}
-
-/**
- * xmlSchemaValueGetAsString:
- * @val: the value
- *
- * Accessor for the string value of a computed value.
- *
- * Returns the string value or NULL if there was none, or on
- * API errors.
- */
-const xmlChar *
-xmlSchemaValueGetAsString(xmlSchemaValPtr val)
-{
- if (val == NULL)
- return (NULL);
- switch (val->type) {
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- case XML_SCHEMAS_ANYSIMPLETYPE:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_ENTITY:
- case XML_SCHEMAS_ANYURI:
- return (BAD_CAST val->value.str);
- default:
- break;
- }
- return (NULL);
-}
-
-/**
- * xmlSchemaValueGetAsBoolean:
- * @val: the value
- *
- * Accessor for the boolean value of a computed value.
- *
- * Returns 1 if true and 0 if false, or in case of an error. Hmm.
- */
-int
-xmlSchemaValueGetAsBoolean(xmlSchemaValPtr val)
-{
- if ((val == NULL) || (val->type != XML_SCHEMAS_BOOLEAN))
- return (0);
- return (val->value.b);
-}
-
-/**
- * xmlSchemaNewStringValue:
- * @type: the value type
- * @value: the value
- *
- * Allocate a new simple type value. The type can be
- * of XML_SCHEMAS_STRING.
- * WARNING: This one is intended to be expanded for other
- * string based types. We need this for anySimpleType as well.
- * The given value is consumed and freed with the struct.
- *
- * Returns a pointer to the new value or NULL in case of error
- */
-xmlSchemaValPtr
-xmlSchemaNewStringValue(xmlSchemaValType type,
- const xmlChar *value)
-{
- xmlSchemaValPtr val;
-
- if (type != XML_SCHEMAS_STRING)
- return(NULL);
- val = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
- if (val == NULL) {
- return(NULL);
- }
- memset(val, 0, sizeof(xmlSchemaVal));
- val->type = type;
- val->value.str = (xmlChar *) value;
- return(val);
-}
-
-/**
- * xmlSchemaNewNOTATIONValue:
- * @name: the notation name
- * @ns: the notation namespace name or NULL
- *
- * Allocate a new NOTATION value.
- * The given values are consumed and freed with the struct.
- *
- * Returns a pointer to the new value or NULL in case of error
- */
-xmlSchemaValPtr
-xmlSchemaNewNOTATIONValue(const xmlChar *name,
- const xmlChar *ns)
-{
- xmlSchemaValPtr val;
-
- val = xmlSchemaNewValue(XML_SCHEMAS_NOTATION);
- if (val == NULL)
- return (NULL);
-
- val->value.qname.name = (xmlChar *)name;
- if (ns != NULL)
- val->value.qname.uri = (xmlChar *)ns;
- return(val);
-}
-
-/**
- * xmlSchemaNewQNameValue:
- * @namespaceName: the namespace name
- * @localName: the local name
- *
- * Allocate a new QName value.
- * The given values are consumed and freed with the struct.
- *
- * Returns a pointer to the new value or NULL in case of an error.
- */
-xmlSchemaValPtr
-xmlSchemaNewQNameValue(const xmlChar *namespaceName,
- const xmlChar *localName)
-{
- xmlSchemaValPtr val;
-
- val = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
- if (val == NULL)
- return (NULL);
-
- val->value.qname.name = (xmlChar *) localName;
- val->value.qname.uri = (xmlChar *) namespaceName;
- return(val);
-}
-
-/**
- * xmlSchemaFreeValue:
- * @value: the value to free
- *
- * Cleanup the default XML Schemas type library
- */
-void
-xmlSchemaFreeValue(xmlSchemaValPtr value) {
- xmlSchemaValPtr prev;
-
- while (value != NULL) {
- switch (value->type) {
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NMTOKENS:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_IDREFS:
- case XML_SCHEMAS_ENTITY:
- case XML_SCHEMAS_ENTITIES:
- case XML_SCHEMAS_ANYURI:
- case XML_SCHEMAS_ANYSIMPLETYPE:
- if (value->value.str != NULL)
- xmlFree(value->value.str);
- break;
- case XML_SCHEMAS_NOTATION:
- case XML_SCHEMAS_QNAME:
- if (value->value.qname.uri != NULL)
- xmlFree(value->value.qname.uri);
- if (value->value.qname.name != NULL)
- xmlFree(value->value.qname.name);
- break;
- case XML_SCHEMAS_HEXBINARY:
- if (value->value.hex.str != NULL)
- xmlFree(value->value.hex.str);
- break;
- case XML_SCHEMAS_BASE64BINARY:
- if (value->value.base64.str != NULL)
- xmlFree(value->value.base64.str);
- break;
- default:
- break;
- }
- prev = value;
- value = value->next;
- xmlFree(prev);
- }
-}
-
-/**
- * xmlSchemaGetPredefinedType:
- * @name: the type name
- * @ns: the URI of the namespace usually "http://www.w3.org/2001/XMLSchema"
- *
- * Lookup a type in the default XML Schemas type library
- *
- * Returns the type if found, NULL otherwise
- */
-xmlSchemaTypePtr
-xmlSchemaGetPredefinedType(const xmlChar *name, const xmlChar *ns) {
- if (xmlSchemaTypesInitialized == 0)
- xmlSchemaInitTypes();
- if (name == NULL)
- return(NULL);
- return((xmlSchemaTypePtr) xmlHashLookup2(xmlSchemaTypesBank, name, ns));
-}
-
-/**
- * xmlSchemaGetBuiltInListSimpleTypeItemType:
- * @type: the built-in simple type.
- *
- * Lookup function
- *
- * 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 == NULL) || (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 *
- * *
- ****************************************************************/
-
-#define IS_TZO_CHAR(c) \
- ((c == 0) || (c == 'Z') || (c == '+') || (c == '-'))
-
-#define VALID_YEAR(yr) (yr != 0)
-#define VALID_MONTH(mon) ((mon >= 1) && (mon <= 12))
-/* VALID_DAY should only be used when month is unknown */
-#define VALID_DAY(day) ((day >= 1) && (day <= 31))
-#define VALID_HOUR(hr) ((hr >= 0) && (hr <= 23))
-#define VALID_MIN(min) ((min >= 0) && (min <= 59))
-#define VALID_SEC(sec) ((sec >= 0) && (sec < 60))
-#define VALID_TZO(tzo) ((tzo > -840) && (tzo < 840))
-#define IS_LEAP(y) \
- (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
-
-static const unsigned int daysInMonth[12] =
- { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-static const unsigned int daysInMonthLeap[12] =
- { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-#define MAX_DAYINMONTH(yr,mon) \
- (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1])
-
-#define VALID_MDAY(dt) \
- (IS_LEAP(dt->year) ? \
- (dt->day <= daysInMonthLeap[dt->mon - 1]) : \
- (dt->day <= daysInMonth[dt->mon - 1]))
-
-#define VALID_DATE(dt) \
- (VALID_YEAR(dt->year) && VALID_MONTH(dt->mon) && VALID_MDAY(dt))
-
-#define VALID_END_OF_DAY(dt) \
- ((dt)->hour == 24 && (dt)->min == 0 && (dt)->sec == 0)
-
-#define VALID_TIME(dt) \
- (((VALID_HOUR(dt->hour) && VALID_MIN(dt->min) && \
- VALID_SEC(dt->sec)) || VALID_END_OF_DAY(dt)) && \
- VALID_TZO(dt->tzo))
-
-#define VALID_DATETIME(dt) \
- (VALID_DATE(dt) && VALID_TIME(dt))
-
-#define SECS_PER_MIN (60)
-#define SECS_PER_HOUR (60 * SECS_PER_MIN)
-#define SECS_PER_DAY (24 * SECS_PER_HOUR)
-
-static const long dayInYearByMonth[12] =
- { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
-static const long dayInLeapYearByMonth[12] =
- { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
-
-#define DAY_IN_YEAR(day, month, year) \
- ((IS_LEAP(year) ? \
- dayInLeapYearByMonth[month - 1] : \
- dayInYearByMonth[month - 1]) + day)
-
-#ifdef DEBUG
-#define DEBUG_DATE(dt) \
- xmlGenericError(xmlGenericErrorContext, \
- "type=%o %04ld-%02u-%02uT%02u:%02u:%03f", \
- dt->type,dt->value.date.year,dt->value.date.mon, \
- dt->value.date.day,dt->value.date.hour,dt->value.date.min, \
- dt->value.date.sec); \
- if (dt->value.date.tz_flag) \
- if (dt->value.date.tzo != 0) \
- xmlGenericError(xmlGenericErrorContext, \
- "%+05d\n",dt->value.date.tzo); \
- else \
- xmlGenericError(xmlGenericErrorContext, "Z\n"); \
- else \
- xmlGenericError(xmlGenericErrorContext,"\n")
-#else
-#define DEBUG_DATE(dt)
-#endif
-
-/**
- * _xmlSchemaParseGYear:
- * @dt: pointer to a date structure
- * @str: pointer to the string to analyze
- *
- * Parses a xs:gYear without time zone and fills in the appropriate
- * field of the @dt structure. @str is updated to point just after the
- * xs:gYear. It is supposed that @dt->year is big enough to contain
- * the year.
- *
- * Returns 0 or the error code
- */
-static int
-_xmlSchemaParseGYear (xmlSchemaValDatePtr dt, const xmlChar **str) {
- const xmlChar *cur = *str, *firstChar;
- int isneg = 0, digcnt = 0;
-
- if (((*cur < '0') || (*cur > '9')) &&
- (*cur != '-') && (*cur != '+'))
- return -1;
-
- if (*cur == '-') {
- isneg = 1;
- cur++;
- }
-
- firstChar = cur;
-
- while ((*cur >= '0') && (*cur <= '9')) {
- dt->year = dt->year * 10 + (*cur - '0');
- cur++;
- digcnt++;
- }
-
- /* year must be at least 4 digits (CCYY); over 4
- * digits cannot have a leading zero. */
- if ((digcnt < 4) || ((digcnt > 4) && (*firstChar == '0')))
- return 1;
-
- if (isneg)
- dt->year = - dt->year;
-
- if (!VALID_YEAR(dt->year))
- return 2;
-
- *str = cur;
- return 0;
-}
-
-/**
- * PARSE_2_DIGITS:
- * @num: the integer to fill in
- * @cur: an #xmlChar *
- * @invalid: an integer
- *
- * Parses a 2-digits integer and updates @num with the value. @cur is
- * updated to point just after the integer.
- * In case of error, @invalid is set to %TRUE, values of @num and
- * @cur are undefined.
- */
-#define PARSE_2_DIGITS(num, cur, invalid) \
- if ((cur[0] < '0') || (cur[0] > '9') || \
- (cur[1] < '0') || (cur[1] > '9')) \
- invalid = 1; \
- else \
- num = (cur[0] - '0') * 10 + (cur[1] - '0'); \
- cur += 2;
-
-/**
- * PARSE_FLOAT:
- * @num: the double to fill in
- * @cur: an #xmlChar *
- * @invalid: an integer
- *
- * Parses a float and updates @num with the value. @cur is
- * updated to point just after the float. The float must have a
- * 2-digits integer part and may or may not have a decimal part.
- * In case of error, @invalid is set to %TRUE, values of @num and
- * @cur are undefined.
- */
-#define PARSE_FLOAT(num, cur, invalid) \
- PARSE_2_DIGITS(num, cur, invalid); \
- if (!invalid && (*cur == '.')) { \
- double mult = 1; \
- cur++; \
- if ((*cur < '0') || (*cur > '9')) \
- invalid = 1; \
- while ((*cur >= '0') && (*cur <= '9')) { \
- mult /= 10; \
- num += (*cur - '0') * mult; \
- cur++; \
- } \
- }
-
-/**
- * _xmlSchemaParseGMonth:
- * @dt: pointer to a date structure
- * @str: pointer to the string to analyze
- *
- * Parses a xs:gMonth without time zone and fills in the appropriate
- * field of the @dt structure. @str is updated to point just after the
- * xs:gMonth.
- *
- * Returns 0 or the error code
- */
-static int
-_xmlSchemaParseGMonth (xmlSchemaValDatePtr dt, const xmlChar **str) {
- const xmlChar *cur = *str;
- int ret = 0;
- unsigned int value = 0;
-
- PARSE_2_DIGITS(value, cur, ret);
- if (ret != 0)
- return ret;
-
- if (!VALID_MONTH(value))
- return 2;
-
- dt->mon = value;
-
- *str = cur;
- return 0;
-}
-
-/**
- * _xmlSchemaParseGDay:
- * @dt: pointer to a date structure
- * @str: pointer to the string to analyze
- *
- * Parses a xs:gDay without time zone and fills in the appropriate
- * field of the @dt structure. @str is updated to point just after the
- * xs:gDay.
- *
- * Returns 0 or the error code
- */
-static int
-_xmlSchemaParseGDay (xmlSchemaValDatePtr dt, const xmlChar **str) {
- const xmlChar *cur = *str;
- int ret = 0;
- unsigned int value = 0;
-
- PARSE_2_DIGITS(value, cur, ret);
- if (ret != 0)
- return ret;
-
- if (!VALID_DAY(value))
- return 2;
-
- dt->day = value;
- *str = cur;
- return 0;
-}
-
-/**
- * _xmlSchemaParseTime:
- * @dt: pointer to a date structure
- * @str: pointer to the string to analyze
- *
- * Parses a xs:time without time zone and fills in the appropriate
- * fields of the @dt structure. @str is updated to point just after the
- * xs:time.
- * In case of error, values of @dt fields are undefined.
- *
- * Returns 0 or the error code
- */
-static int
-_xmlSchemaParseTime (xmlSchemaValDatePtr dt, const xmlChar **str) {
- const xmlChar *cur = *str;
- int ret = 0;
- int value = 0;
-
- PARSE_2_DIGITS(value, cur, ret);
- if (ret != 0)
- return ret;
- if (*cur != ':')
- return 1;
- if (!VALID_HOUR(value) && value != 24 /* Allow end-of-day hour */)
- return 2;
- cur++;
-
- /* the ':' insures this string is xs:time */
- dt->hour = value;
-
- PARSE_2_DIGITS(value, cur, ret);
- if (ret != 0)
- return ret;
- if (!VALID_MIN(value))
- return 2;
- dt->min = value;
-
- if (*cur != ':')
- return 1;
- cur++;
-
- PARSE_FLOAT(dt->sec, cur, ret);
- if (ret != 0)
- return ret;
-
- if (!VALID_TIME(dt))
- return 2;
-
- *str = cur;
- return 0;
-}
-
-/**
- * _xmlSchemaParseTimeZone:
- * @dt: pointer to a date structure
- * @str: pointer to the string to analyze
- *
- * Parses a time zone without time zone and fills in the appropriate
- * field of the @dt structure. @str is updated to point just after the
- * time zone.
- *
- * Returns 0 or the error code
- */
-static int
-_xmlSchemaParseTimeZone (xmlSchemaValDatePtr dt, const xmlChar **str) {
- const xmlChar *cur;
- int ret = 0;
-
- if (str == NULL)
- return -1;
- cur = *str;
-
- switch (*cur) {
- case 0:
- dt->tz_flag = 0;
- dt->tzo = 0;
- break;
-
- case 'Z':
- dt->tz_flag = 1;
- dt->tzo = 0;
- cur++;
- break;
-
- case '+':
- case '-': {
- int isneg = 0, tmp = 0;
- isneg = (*cur == '-');
-
- cur++;
-
- PARSE_2_DIGITS(tmp, cur, ret);
- if (ret != 0)
- return ret;
- if (!VALID_HOUR(tmp))
- return 2;
-
- if (*cur != ':')
- return 1;
- cur++;
-
- dt->tzo = tmp * 60;
-
- PARSE_2_DIGITS(tmp, cur, ret);
- if (ret != 0)
- return ret;
- if (!VALID_MIN(tmp))
- return 2;
-
- dt->tzo += tmp;
- if (isneg)
- dt->tzo = - dt->tzo;
-
- if (!VALID_TZO(dt->tzo))
- return 2;
-
- dt->tz_flag = 1;
- break;
- }
- default:
- return 1;
- }
-
- *str = cur;
- return 0;
-}
-
-/**
- * _xmlSchemaBase64Decode:
- * @ch: a character
- *
- * Converts a base64 encoded character to its base 64 value.
- *
- * Returns 0-63 (value), 64 (pad), or -1 (not recognized)
- */
-static int
-_xmlSchemaBase64Decode (const xmlChar ch) {
- if (('A' <= ch) && (ch <= 'Z')) return ch - 'A';
- if (('a' <= ch) && (ch <= 'z')) return ch - 'a' + 26;
- if (('0' <= ch) && (ch <= '9')) return ch - '0' + 52;
- if ('+' == ch) return 62;
- if ('/' == ch) return 63;
- if ('=' == ch) return 64;
- return -1;
-}
-
-/****************************************************************
- * *
- * XML Schema Dates/Times Datatypes Handling *
- * *
- ****************************************************************/
-
-/**
- * PARSE_DIGITS:
- * @num: the integer to fill in
- * @cur: an #xmlChar *
- * @num_type: an integer flag
- *
- * Parses a digits integer and updates @num with the value. @cur is
- * updated to point just after the integer.
- * In case of error, @num_type is set to -1, values of @num and
- * @cur are undefined.
- */
-#define PARSE_DIGITS(num, cur, num_type) \
- if ((*cur < '0') || (*cur > '9')) \
- num_type = -1; \
- else \
- while ((*cur >= '0') && (*cur <= '9')) { \
- num = num * 10 + (*cur - '0'); \
- cur++; \
- }
-
-/**
- * PARSE_NUM:
- * @num: the double to fill in
- * @cur: an #xmlChar *
- * @num_type: an integer flag
- *
- * Parses a float or integer and updates @num with the value. @cur is
- * updated to point just after the number. If the number is a float,
- * then it must have an integer part and a decimal part; @num_type will
- * be set to 1. If there is no decimal part, @num_type is set to zero.
- * In case of error, @num_type is set to -1, values of @num and
- * @cur are undefined.
- */
-#define PARSE_NUM(num, cur, num_type) \
- num = 0; \
- PARSE_DIGITS(num, cur, num_type); \
- if (!num_type && (*cur == '.')) { \
- double mult = 1; \
- cur++; \
- if ((*cur < '0') || (*cur > '9')) \
- num_type = -1; \
- else \
- num_type = 1; \
- while ((*cur >= '0') && (*cur <= '9')) { \
- mult /= 10; \
- num += (*cur - '0') * mult; \
- cur++; \
- } \
- }
-
-/**
- * xmlSchemaValidateDates:
- * @type: the expected type or XML_SCHEMAS_UNKNOWN
- * @dateTime: string to analyze
- * @val: the return computed value
- *
- * Check that @dateTime conforms to the lexical space of one of the date types.
- * if true a value is computed and returned in @val.
- *
- * Returns 0 if this validates, a positive error code number otherwise
- * and -1 in case of internal or API error.
- */
-static int
-xmlSchemaValidateDates (xmlSchemaValType type,
- const xmlChar *dateTime, xmlSchemaValPtr *val,
- int collapse) {
- xmlSchemaValPtr dt;
- int ret;
- const xmlChar *cur = dateTime;
-
-#define RETURN_TYPE_IF_VALID(t) \
- if (IS_TZO_CHAR(*cur)) { \
- ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur); \
- if (ret == 0) { \
- if (*cur != 0) \
- goto error; \
- dt->type = t; \
- goto done; \
- } \
- }
-
- if (dateTime == NULL)
- return -1;
-
- if (collapse)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- if ((*cur != '-') && (*cur < '0') && (*cur > '9'))
- return 1;
-
- dt = xmlSchemaNewValue(XML_SCHEMAS_UNKNOWN);
- if (dt == NULL)
- return -1;
-
- if ((cur[0] == '-') && (cur[1] == '-')) {
- /*
- * It's an incomplete date (xs:gMonthDay, xs:gMonth or
- * xs:gDay)
- */
- cur += 2;
-
- /* is it an xs:gDay? */
- if (*cur == '-') {
- if (type == XML_SCHEMAS_GMONTH)
- goto error;
- ++cur;
- ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
- if (ret != 0)
- goto error;
-
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_GDAY);
-
- goto error;
- }
-
- /*
- * it should be an xs:gMonthDay or xs:gMonth
- */
- ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
- if (ret != 0)
- goto error;
-
- /*
- * a '-' char could indicate this type is xs:gMonthDay or
- * a negative time zone offset. Check for xs:gMonthDay first.
- * Also the first three char's of a negative tzo (-MM:SS) can
- * appear to be a valid day; so even if the day portion
- * of the xs:gMonthDay verifies, we must insure it was not
- * a tzo.
- */
- if (*cur == '-') {
- const xmlChar *rewnd = cur;
- cur++;
-
- ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
- if ((ret == 0) && ((*cur == 0) || (*cur != ':'))) {
-
- /*
- * we can use the VALID_MDAY macro to validate the month
- * and day because the leap year test will flag year zero
- * as a leap year (even though zero is an invalid year).
- * FUTURE TODO: Zero will become valid in XML Schema 1.1
- * probably.
- */
- if (VALID_MDAY((&(dt->value.date)))) {
-
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTHDAY);
-
- goto error;
- }
- }
-
- /*
- * not xs:gMonthDay so rewind and check if just xs:gMonth
- * with an optional time zone.
- */
- cur = rewnd;
- }
-
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTH);
-
- goto error;
- }
-
- /*
- * It's a right-truncated date or an xs:time.
- * Try to parse an xs:time then fallback on right-truncated dates.
- */
- if ((*cur >= '0') && (*cur <= '9')) {
- ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
- if (ret == 0) {
- /* it's an xs:time */
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_TIME);
- }
- }
-
- /* fallback on date parsing */
- cur = dateTime;
-
- ret = _xmlSchemaParseGYear(&(dt->value.date), &cur);
- if (ret != 0)
- goto error;
-
- /* is it an xs:gYear? */
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEAR);
-
- if (*cur != '-')
- goto error;
- cur++;
-
- ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
- if (ret != 0)
- goto error;
-
- /* is it an xs:gYearMonth? */
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEARMONTH);
-
- if (*cur != '-')
- goto error;
- cur++;
-
- ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
- if ((ret != 0) || !VALID_DATE((&(dt->value.date))))
- goto error;
-
- /* is it an xs:date? */
- RETURN_TYPE_IF_VALID(XML_SCHEMAS_DATE);
-
- if (*cur != 'T')
- goto error;
- cur++;
-
- /* it should be an xs:dateTime */
- ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
- if (ret != 0)
- goto error;
-
- ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur);
- if (collapse)
- while IS_WSP_BLANK_CH(*cur) cur++;
- if ((ret != 0) || (*cur != 0) || (!(VALID_DATETIME((&(dt->value.date))))))
- goto error;
-
-
- dt->type = XML_SCHEMAS_DATETIME;
-
-done:
-#if 1
- if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type))
- goto error;
-#else
- /*
- * insure the parsed type is equal to or less significant (right
- * truncated) than the desired type.
- */
- if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type)) {
-
- /* time only matches time */
- if ((type == XML_SCHEMAS_TIME) && (dt->type == XML_SCHEMAS_TIME))
- goto error;
-
- if ((type == XML_SCHEMAS_DATETIME) &&
- ((dt->type != XML_SCHEMAS_DATE) ||
- (dt->type != XML_SCHEMAS_GYEARMONTH) ||
- (dt->type != XML_SCHEMAS_GYEAR)))
- goto error;
-
- if ((type == XML_SCHEMAS_DATE) &&
- ((dt->type != XML_SCHEMAS_GYEAR) ||
- (dt->type != XML_SCHEMAS_GYEARMONTH)))
- goto error;
-
- if ((type == XML_SCHEMAS_GYEARMONTH) && (dt->type != XML_SCHEMAS_GYEAR))
- goto error;
-
- if ((type == XML_SCHEMAS_GMONTHDAY) && (dt->type != XML_SCHEMAS_GMONTH))
- goto error;
- }
-#endif
-
- if (val != NULL)
- *val = dt;
- else
- xmlSchemaFreeValue(dt);
-
- return 0;
-
-error:
- if (dt != NULL)
- xmlSchemaFreeValue(dt);
- return 1;
-}
-
-/**
- * xmlSchemaValidateDuration:
- * @type: the predefined type
- * @duration: string to analyze
- * @val: the return computed value
- *
- * Check that @duration conforms to the lexical space of the duration type.
- * if true a value is computed and returned in @val.
- *
- * Returns 0 if this validates, a positive error code number otherwise
- * and -1 in case of internal or API error.
- */
-static int
-xmlSchemaValidateDuration (xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
- const xmlChar *duration, xmlSchemaValPtr *val,
- int collapse) {
- const xmlChar *cur = duration;
- xmlSchemaValPtr dur;
- int isneg = 0;
- unsigned int seq = 0;
- double num;
- int num_type = 0; /* -1 = invalid, 0 = int, 1 = floating */
- const xmlChar desig[] = {'Y', 'M', 'D', 'H', 'M', 'S'};
- const double multi[] = { 0.0, 0.0, 86400.0, 3600.0, 60.0, 1.0, 0.0};
-
- if (duration == NULL)
- return -1;
-
- if (collapse)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- if (*cur == '-') {
- isneg = 1;
- cur++;
- }
-
- /* duration must start with 'P' (after sign) */
- if (*cur++ != 'P')
- return 1;
-
- if (*cur == 0)
- return 1;
-
- dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
- if (dur == NULL)
- return -1;
-
- while (*cur != 0) {
-
- /* input string should be empty or invalid date/time item */
- if (seq >= sizeof(desig))
- goto error;
-
- /* T designator must be present for time items */
- if (*cur == 'T') {
- if (seq <= 3) {
- seq = 3;
- cur++;
- } else
- return 1;
- } else if (seq == 3)
- goto error;
-
- /* parse the number portion of the item */
- PARSE_NUM(num, cur, num_type);
-
- if ((num_type == -1) || (*cur == 0))
- goto error;
-
- /* update duration based on item type */
- while (seq < sizeof(desig)) {
- if (*cur == desig[seq]) {
-
- /* verify numeric type; only seconds can be float */
- if ((num_type != 0) && (seq < (sizeof(desig)-1)))
- goto error;
-
- switch (seq) {
- case 0:
- dur->value.dur.mon = (long)num * 12;
- break;
- case 1:
- dur->value.dur.mon += (long)num;
- break;
- default:
- /* convert to seconds using multiplier */
- dur->value.dur.sec += num * multi[seq];
- seq++;
- break;
- }
-
- break; /* exit loop */
- }
- /* no date designators found? */
- if ((++seq == 3) || (seq == 6))
- goto error;
- }
- cur++;
- if (collapse)
- while IS_WSP_BLANK_CH(*cur) cur++;
- }
-
- if (isneg) {
- dur->value.dur.mon = -dur->value.dur.mon;
- dur->value.dur.day = -dur->value.dur.day;
- dur->value.dur.sec = -dur->value.dur.sec;
- }
-
- if (val != NULL)
- *val = dur;
- else
- xmlSchemaFreeValue(dur);
-
- return 0;
-
-error:
- if (dur != NULL)
- xmlSchemaFreeValue(dur);
- return 1;
-}
-
-/**
- * xmlSchemaStrip:
- * @value: a value
- *
- * Removes the leading and ending spaces of a string
- *
- * Returns the new string or NULL if no change was required.
- */
-static xmlChar *
-xmlSchemaStrip(const xmlChar *value) {
- const xmlChar *start = value, *end, *f;
-
- if (value == NULL) return(NULL);
- while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
- end = start;
- while (*end != 0) end++;
- f = end;
- end--;
- while ((end > start) && (IS_BLANK_CH(*end))) end--;
- end++;
- if ((start == value) && (f == end)) return(NULL);
- return(xmlStrndup(start, end - start));
-}
-
-/**
- * xmlSchemaWhiteSpaceReplace:
- * @value: a value
- *
- * Replaces 0xd, 0x9 and 0xa with a space.
- *
- * Returns the new string or NULL if no change was required.
- */
-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);
- /* TODO FIXME: I guess gcc will bark at this. */
- mcur = (xmlChar *) (ret + (cur - value));
- do {
- if ( ((*mcur) == 0xd) || ((*mcur) == 0x9) || ((*mcur) == 0xa) )
- *mcur = ' ';
- mcur++;
- } while (*mcur != 0);
- return(ret);
-}
-
-/**
- * xmlSchemaCollapseString:
- * @value: a value
- *
- * Removes and normalize white spaces in the string
- *
- * Returns the new string or NULL if no change was required.
- */
-xmlChar *
-xmlSchemaCollapseString(const xmlChar *value) {
- const xmlChar *start = value, *end, *f;
- xmlChar *g;
- int col = 0;
-
- if (value == NULL) return(NULL);
- while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
- end = start;
- while (*end != 0) {
- if ((*end == ' ') && (IS_BLANK_CH(end[1]))) {
- col = end - start;
- break;
- } else if ((*end == 0xa) || (*end == 0x9) || (*end == 0xd)) {
- col = end - start;
- break;
- }
- end++;
- }
- if (col == 0) {
- f = end;
- end--;
- while ((end > start) && (IS_BLANK_CH(*end))) end--;
- end++;
- if ((start == value) && (f == end)) return(NULL);
- return(xmlStrndup(start, end - start));
- }
- start = xmlStrdup(start);
- if (start == NULL) return(NULL);
- g = (xmlChar *) (start + col);
- end = g;
- while (*end != 0) {
- if (IS_BLANK_CH(*end)) {
- end++;
- while (IS_BLANK_CH(*end)) end++;
- if (*end != 0)
- *g++ = ' ';
- } else
- *g++ = *end++;
- }
- *g = 0;
- return((xmlChar *) start);
-}
-
-/**
- * xmlSchemaValAtomicListNode:
- * @type: the predefined atomic type for a token in the list
- * @value: the list value to check
- * @ret: the return computed value
- * @node: the node containing the value
- *
- * Check that a value conforms to the lexical space of the predefined
- * list type. if true a value is computed and returned in @ret.
- *
- * Returns the number of items if this validates, a negative error code
- * number otherwise
- */
-static int
-xmlSchemaValAtomicListNode(xmlSchemaTypePtr type, const xmlChar *value,
- xmlSchemaValPtr *ret, xmlNodePtr node) {
- xmlChar *val, *cur, *endval;
- int nb_values = 0;
- int tmp = 0;
-
- if (value == NULL) {
- return(-1);
- }
- val = xmlStrdup(value);
- if (val == NULL) {
- return(-1);
- }
- if (ret != NULL) {
- *ret = NULL;
- }
- cur = val;
- /*
- * Split the list
- */
- while (IS_BLANK_CH(*cur)) *cur++ = 0;
- while (*cur != 0) {
- if (IS_BLANK_CH(*cur)) {
- *cur = 0;
- cur++;
- while (IS_BLANK_CH(*cur)) *cur++ = 0;
- } else {
- nb_values++;
- cur++;
- while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
- }
- }
- if (nb_values == 0) {
- xmlFree(val);
- return(nb_values);
- }
- endval = cur;
- cur = val;
- while ((*cur == 0) && (cur != endval)) cur++;
- while (cur != endval) {
- tmp = xmlSchemaValPredefTypeNode(type, cur, NULL, node);
- if (tmp != 0)
- break;
- while (*cur != 0) cur++;
- while ((*cur == 0) && (cur != endval)) cur++;
- }
- /* TODO what return value ? c.f. bug #158628
- if (ret != NULL) {
- TODO
- } */
- xmlFree(val);
- if (tmp == 0)
- return(nb_values);
- return(-1);
-}
-
-/**
- * xmlSchemaParseUInt:
- * @str: pointer to the string R/W
- * @llo: pointer to the low result
- * @lmi: pointer to the mid result
- * @lhi: pointer to the high result
- *
- * Parse an unsigned long into 3 fields.
- *
- * Returns the number of significant digits in the number or
- * -1 if overflow of the capacity and -2 if it's not a number.
- */
-static int
-xmlSchemaParseUInt(const xmlChar **str, unsigned long *llo,
- unsigned long *lmi, unsigned long *lhi) {
- unsigned long lo = 0, mi = 0, hi = 0;
- const xmlChar *tmp, *cur = *str;
- int ret = 0, i = 0;
-
- if (!((*cur >= '0') && (*cur <= '9')))
- return(-2);
-
- while (*cur == '0') { /* ignore leading zeroes */
- cur++;
- }
- tmp = cur;
- while ((*tmp != 0) && (*tmp >= '0') && (*tmp <= '9')) {
- i++;tmp++;ret++;
- }
- if (i > 24) {
- *str = tmp;
- return(-1);
- }
- while (i > 16) {
- hi = hi * 10 + (*cur++ - '0');
- i--;
- }
- while (i > 8) {
- mi = mi * 10 + (*cur++ - '0');
- i--;
- }
- while (i > 0) {
- lo = lo * 10 + (*cur++ - '0');
- i--;
- }
-
- *str = cur;
- *llo = lo;
- *lmi = mi;
- *lhi = hi;
- return(ret);
-}
-
-/**
- * xmlSchemaValAtomicType:
- * @type: the predefined type
- * @value: the value to check
- * @val: the return computed value
- * @node: the node containing the value
- * flags: flags to control the vlidation
- *
- * 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.
- */
-static int
-xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value,
- xmlSchemaValPtr * val, xmlNodePtr node, int flags,
- xmlSchemaWhitespaceValueType ws,
- int normOnTheFly, int applyNorm, int createStringValue)
-{
- xmlSchemaValPtr v;
- xmlChar *norm = NULL;
- int ret = 0;
-
- if (xmlSchemaTypesInitialized == 0)
- xmlSchemaInitTypes();
- if (type == NULL)
- return (-1);
-
- /*
- * validating a non existant text node is similar to validating
- * an empty one.
- */
- if (value == NULL)
- value = BAD_CAST "";
-
- if (val != NULL)
- *val = NULL;
- if ((flags == 0) && (value != NULL)) {
-
- if ((type->builtInType != XML_SCHEMAS_STRING) &&
- (type->builtInType != XML_SCHEMAS_ANYTYPE) &&
- (type->builtInType != XML_SCHEMAS_ANYSIMPLETYPE)) {
- if (type->builtInType == XML_SCHEMAS_NORMSTRING)
- norm = xmlSchemaWhiteSpaceReplace(value);
- else
- norm = xmlSchemaCollapseString(value);
- if (norm != NULL)
- value = norm;
- }
- }
-
- switch (type->builtInType) {
- case XML_SCHEMAS_UNKNOWN:
- goto error;
- case XML_SCHEMAS_ANYTYPE:
- case XML_SCHEMAS_ANYSIMPLETYPE:
- if ((createStringValue) && (val != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_ANYSIMPLETYPE);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- case XML_SCHEMAS_STRING:
- if (! normOnTheFly) {
- const xmlChar *cur = value;
-
- if (ws == XML_SCHEMA_WHITESPACE_REPLACE) {
- while (*cur != 0) {
- if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
- goto return1;
- } else {
- cur++;
- }
- }
- } else if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE) {
- while (*cur != 0) {
- if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
- goto return1;
- } else if IS_WSP_SPACE_CH(*cur) {
- cur++;
- if IS_WSP_SPACE_CH(*cur)
- goto return1;
- } else {
- cur++;
- }
- }
- }
- }
- if (createStringValue && (val != NULL)) {
- if (applyNorm) {
- if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- norm = xmlSchemaCollapseString(value);
- else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
- norm = xmlSchemaWhiteSpaceReplace(value);
- if (norm != NULL)
- value = norm;
- }
- v = xmlSchemaNewValue(XML_SCHEMAS_STRING);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- case XML_SCHEMAS_NORMSTRING:{
- if (normOnTheFly) {
- if (applyNorm) {
- if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- norm = xmlSchemaCollapseString(value);
- else
- norm = xmlSchemaWhiteSpaceReplace(value);
- if (norm != NULL)
- value = norm;
- }
- } else {
- const xmlChar *cur = value;
- while (*cur != 0) {
- if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
- goto return1;
- } else {
- cur++;
- }
- }
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_NORMSTRING);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_DECIMAL:{
- const xmlChar *cur = value;
- unsigned int len, neg, integ, hasLeadingZeroes;
- xmlChar cval[25];
- xmlChar *cptr = cval;
-
- if ((cur == NULL) || (*cur == 0))
- goto return1;
-
- /*
- * xs:decimal has a whitespace-facet value of 'collapse'.
- */
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- /*
- * First we handle an optional sign.
- */
- neg = 0;
- if (*cur == '-') {
- neg = 1;
- cur++;
- } else if (*cur == '+')
- cur++;
- /*
- * Disallow: "", "-", "- "
- */
- if (*cur == 0)
- goto return1;
- /*
- * Next we "pre-parse" the number, in preparation for calling
- * the common routine xmlSchemaParseUInt. We get rid of any
- * leading zeroes (because we have reserved only 25 chars),
- * and note the position of a decimal point.
- */
- len = 0;
- integ = ~0u;
- hasLeadingZeroes = 0;
- /*
- * Skip leading zeroes.
- */
- while (*cur == '0') {
- cur++;
- hasLeadingZeroes = 1;
- }
- if (*cur != 0) {
- do {
- if ((*cur >= '0') && (*cur <= '9')) {
- *cptr++ = *cur++;
- len++;
- } else if (*cur == '.') {
- cur++;
- integ = len;
- do {
- if ((*cur >= '0') && (*cur <= '9')) {
- *cptr++ = *cur++;
- len++;
- } else
- break;
- } while (len < 24);
- /*
- * Disallow "." but allow "00."
- */
- if ((len == 0) && (!hasLeadingZeroes))
- goto return1;
- break;
- } else
- break;
- } while (len < 24);
- }
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
- if (*cur != 0)
- goto return1; /* error if any extraneous chars */
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_DECIMAL);
- if (v != NULL) {
- /*
- * Now evaluate the significant digits of the number
- */
- if (len != 0) {
-
- if (integ != ~0u) {
- /*
- * Get rid of trailing zeroes in the
- * fractional part.
- */
- while ((len != integ) && (*(cptr-1) == '0')) {
- cptr--;
- len--;
- }
- }
- /*
- * Terminate the (preparsed) string.
- */
- if (len != 0) {
- *cptr = 0;
- cptr = cval;
-
- xmlSchemaParseUInt((const xmlChar **)&cptr,
- &v->value.decimal.lo,
- &v->value.decimal.mi,
- &v->value.decimal.hi);
- }
- }
- /*
- * Set the total digits to 1 if a zero value.
- */
- v->value.decimal.sign = neg;
- if (len == 0) {
- /* Speedup for zero values. */
- v->value.decimal.total = 1;
- } else {
- v->value.decimal.total = len;
- if (integ == ~0u)
- v->value.decimal.frac = 0;
- else
- v->value.decimal.frac = len - integ;
- }
- *val = v;
- }
- }
- goto return0;
- }
- 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:
- ret = xmlSchemaValidateDates(type->builtInType, value, val,
- normOnTheFly);
- break;
- case XML_SCHEMAS_DURATION:
- ret = xmlSchemaValidateDuration(type, value, val,
- normOnTheFly);
- break;
- case XML_SCHEMAS_FLOAT:
- case XML_SCHEMAS_DOUBLE: {
- const xmlChar *cur = value;
- int neg = 0;
- int digits_before = 0;
- int digits_after = 0;
-
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- if ((cur[0] == 'N') && (cur[1] == 'a') && (cur[2] == 'N')) {
- cur += 3;
- if (*cur != 0)
- goto return1;
- if (val != NULL) {
- if (type == xmlSchemaTypeFloatDef) {
- v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
- if (v != NULL) {
- v->value.f = (float) xmlXPathNAN;
- } else {
- xmlSchemaFreeValue(v);
- goto error;
- }
- } else {
- v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
- if (v != NULL) {
- v->value.d = xmlXPathNAN;
- } else {
- xmlSchemaFreeValue(v);
- goto error;
- }
- }
- *val = v;
- }
- goto return0;
- }
- if (*cur == '-') {
- neg = 1;
- cur++;
- }
- if ((cur[0] == 'I') && (cur[1] == 'N') && (cur[2] == 'F')) {
- cur += 3;
- if (*cur != 0)
- goto return1;
- if (val != NULL) {
- if (type == xmlSchemaTypeFloatDef) {
- v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
- if (v != NULL) {
- if (neg)
- v->value.f = (float) xmlXPathNINF;
- else
- v->value.f = (float) xmlXPathPINF;
- } else {
- xmlSchemaFreeValue(v);
- goto error;
- }
- } else {
- v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
- if (v != NULL) {
- if (neg)
- v->value.d = xmlXPathNINF;
- else
- v->value.d = xmlXPathPINF;
- } else {
- xmlSchemaFreeValue(v);
- goto error;
- }
- }
- *val = v;
- }
- goto return0;
- }
- if ((neg == 0) && (*cur == '+'))
- cur++;
- if ((cur[0] == 0) || (cur[0] == '+') || (cur[0] == '-'))
- goto return1;
- while ((*cur >= '0') && (*cur <= '9')) {
- cur++;
- digits_before++;
- }
- if (*cur == '.') {
- cur++;
- while ((*cur >= '0') && (*cur <= '9')) {
- cur++;
- digits_after++;
- }
- }
- if ((digits_before == 0) && (digits_after == 0))
- goto return1;
- if ((*cur == 'e') || (*cur == 'E')) {
- cur++;
- if ((*cur == '-') || (*cur == '+'))
- cur++;
- while ((*cur >= '0') && (*cur <= '9'))
- cur++;
- }
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- if (*cur != 0)
- goto return1;
- if (val != NULL) {
- if (type == xmlSchemaTypeFloatDef) {
- v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
- if (v != NULL) {
- /*
- * TODO: sscanf seems not to give the correct
- * value for extremely high/low values.
- * E.g. "1E-149" results in zero.
- */
- if (sscanf((const char *) value, "%f",
- &(v->value.f)) == 1) {
- *val = v;
- } else {
- xmlSchemaFreeValue(v);
- goto return1;
- }
- } else {
- goto error;
- }
- } else {
- v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
- if (v != NULL) {
- /*
- * TODO: sscanf seems not to give the correct
- * value for extremely high/low values.
- */
- if (sscanf((const char *) value, "%lf",
- &(v->value.d)) == 1) {
- *val = v;
- } else {
- xmlSchemaFreeValue(v);
- goto return1;
- }
- } else {
- goto error;
- }
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_BOOLEAN:{
- const xmlChar *cur = value;
-
- if (normOnTheFly) {
- while IS_WSP_BLANK_CH(*cur) cur++;
- if (*cur == '0') {
- ret = 0;
- cur++;
- } else if (*cur == '1') {
- ret = 1;
- cur++;
- } else if (*cur == 't') {
- cur++;
- if ((*cur++ == 'r') && (*cur++ == 'u') &&
- (*cur++ == 'e')) {
- ret = 1;
- } else
- goto return1;
- } else if (*cur == 'f') {
- cur++;
- if ((*cur++ == 'a') && (*cur++ == 'l') &&
- (*cur++ == 's') && (*cur++ == 'e')) {
- ret = 0;
- } else
- goto return1;
- } else
- goto return1;
- if (*cur != 0) {
- while IS_WSP_BLANK_CH(*cur) cur++;
- if (*cur != 0)
- goto return1;
- }
- } else {
- if ((cur[0] == '0') && (cur[1] == 0))
- ret = 0;
- else if ((cur[0] == '1') && (cur[1] == 0))
- ret = 1;
- else if ((cur[0] == 't') && (cur[1] == 'r')
- && (cur[2] == 'u') && (cur[3] == 'e')
- && (cur[4] == 0))
- ret = 1;
- else if ((cur[0] == 'f') && (cur[1] == 'a')
- && (cur[2] == 'l') && (cur[3] == 's')
- && (cur[4] == 'e') && (cur[5] == 0))
- ret = 0;
- else
- goto return1;
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_BOOLEAN);
- if (v != NULL) {
- v->value.b = ret;
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_TOKEN:{
- const xmlChar *cur = value;
-
- if (! normOnTheFly) {
- while (*cur != 0) {
- if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
- goto return1;
- } else if (*cur == ' ') {
- cur++;
- if (*cur == 0)
- goto return1;
- if (*cur == ' ')
- goto return1;
- } else {
- cur++;
- }
- }
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_TOKEN);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_LANGUAGE:
- if (normOnTheFly) {
- norm = xmlSchemaCollapseString(value);
- if (norm != NULL)
- value = norm;
- }
- if (xmlCheckLanguageID(value) == 1) {
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_LANGUAGE);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- }
- goto return1;
- case XML_SCHEMAS_NMTOKEN:
- if (xmlValidateNMToken(value, 1) == 0) {
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_NMTOKEN);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto return0;
- }
- goto return1;
- case XML_SCHEMAS_NMTOKENS:
- ret = xmlSchemaValAtomicListNode(xmlSchemaTypeNmtokenDef,
- value, val, node);
- if (ret > 0)
- ret = 0;
- else
- ret = 1;
- goto done;
- case XML_SCHEMAS_NAME:
- ret = xmlValidateName(value, 1);
- if ((ret == 0) && (val != NULL) && (value != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_NAME);
- if (v != NULL) {
- const xmlChar *start = value, *end;
- while (IS_BLANK_CH(*start)) start++;
- end = start;
- while ((*end != 0) && (!IS_BLANK_CH(*end))) end++;
- v->value.str = xmlStrndup(start, end - start);
- *val = v;
- } else {
- goto error;
- }
- }
- goto done;
- case XML_SCHEMAS_QNAME:{
- const xmlChar *uri = NULL;
- xmlChar *local = NULL;
-
- ret = xmlValidateQName(value, 1);
- if (ret != 0)
- goto done;
- if (node != NULL) {
- xmlChar *prefix;
- xmlNsPtr ns;
-
- local = xmlSplitQName2(value, &prefix);
- ns = xmlSearchNs(node->doc, node, prefix);
- if ((ns == NULL) && (prefix != NULL)) {
- xmlFree(prefix);
- if (local != NULL)
- xmlFree(local);
- goto return1;
- }
- if (ns != NULL)
- uri = ns->href;
- if (prefix != NULL)
- xmlFree(prefix);
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
- if (v == NULL) {
- if (local != NULL)
- xmlFree(local);
- goto error;
- }
- if (local != NULL)
- v->value.qname.name = local;
- else
- v->value.qname.name = xmlStrdup(value);
- if (uri != NULL)
- v->value.qname.uri = xmlStrdup(uri);
- *val = v;
- } else
- if (local != NULL)
- xmlFree(local);
- goto done;
- }
- case XML_SCHEMAS_NCNAME:
- ret = xmlValidateNCName(value, 1);
- if ((ret == 0) && (val != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_NCNAME);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- goto done;
- case XML_SCHEMAS_ID:
- ret = xmlValidateNCName(value, 1);
- if ((ret == 0) && (val != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_ID);
- if (v != NULL) {
- v->value.str = xmlStrdup(value);
- *val = v;
- } else {
- goto error;
- }
- }
- if ((ret == 0) && (node != NULL) &&
- (node->type == XML_ATTRIBUTE_NODE)) {
- xmlAttrPtr attr = (xmlAttrPtr) node;
-
- /*
- * NOTE: the IDness might have already be declared in the DTD
- */
- if (attr->atype != XML_ATTRIBUTE_ID) {
- xmlIDPtr res;
- xmlChar *strip;
-
- strip = xmlSchemaStrip(value);
- if (strip != NULL) {
- res = xmlAddID(NULL, node->doc, strip, attr);
- xmlFree(strip);
- } else
- res = xmlAddID(NULL, node->doc, value, attr);
- if (res == NULL) {
- ret = 2;
- } else {
- attr->atype = XML_ATTRIBUTE_ID;
- }
- }
- }
- goto done;
- case XML_SCHEMAS_IDREF:
- ret = xmlValidateNCName(value, 1);
- if ((ret == 0) && (val != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_IDREF);
- if (v == NULL)
- goto error;
- v->value.str = xmlStrdup(value);
- *val = v;
- }
- if ((ret == 0) && (node != NULL) &&
- (node->type == XML_ATTRIBUTE_NODE)) {
- xmlAttrPtr attr = (xmlAttrPtr) node;
- xmlChar *strip;
-
- strip = xmlSchemaStrip(value);
- if (strip != NULL) {
- xmlAddRef(NULL, node->doc, strip, attr);
- xmlFree(strip);
- } else
- xmlAddRef(NULL, node->doc, value, attr);
- attr->atype = XML_ATTRIBUTE_IDREF;
- }
- goto done;
- case XML_SCHEMAS_IDREFS:
- ret = xmlSchemaValAtomicListNode(xmlSchemaTypeIdrefDef,
- value, val, node);
- if (ret < 0)
- ret = 2;
- else
- ret = 0;
- if ((ret == 0) && (node != NULL) &&
- (node->type == XML_ATTRIBUTE_NODE)) {
- xmlAttrPtr attr = (xmlAttrPtr) node;
-
- attr->atype = XML_ATTRIBUTE_IDREFS;
- }
- goto done;
- case XML_SCHEMAS_ENTITY:{
- xmlChar *strip;
-
- ret = xmlValidateNCName(value, 1);
- if ((node == NULL) || (node->doc == NULL))
- ret = 3;
- if (ret == 0) {
- xmlEntityPtr ent;
-
- strip = xmlSchemaStrip(value);
- if (strip != NULL) {
- ent = xmlGetDocEntity(node->doc, strip);
- xmlFree(strip);
- } else {
- ent = xmlGetDocEntity(node->doc, value);
- }
- if ((ent == NULL) ||
- (ent->etype !=
- XML_EXTERNAL_GENERAL_UNPARSED_ENTITY))
- ret = 4;
- }
- if ((ret == 0) && (val != NULL)) {
- TODO;
- }
- if ((ret == 0) && (node != NULL) &&
- (node->type == XML_ATTRIBUTE_NODE)) {
- xmlAttrPtr attr = (xmlAttrPtr) node;
-
- attr->atype = XML_ATTRIBUTE_ENTITY;
- }
- goto done;
- }
- case XML_SCHEMAS_ENTITIES:
- if ((node == NULL) || (node->doc == NULL))
- goto return3;
- ret = xmlSchemaValAtomicListNode(xmlSchemaTypeEntityDef,
- value, val, node);
- if (ret <= 0)
- ret = 1;
- else
- ret = 0;
- if ((ret == 0) && (node != NULL) &&
- (node->type == XML_ATTRIBUTE_NODE)) {
- xmlAttrPtr attr = (xmlAttrPtr) node;
-
- attr->atype = XML_ATTRIBUTE_ENTITIES;
- }
- goto done;
- case XML_SCHEMAS_NOTATION:{
- xmlChar *uri = NULL;
- xmlChar *local = NULL;
-
- ret = xmlValidateQName(value, 1);
- if ((ret == 0) && (node != NULL)) {
- xmlChar *prefix;
-
- local = xmlSplitQName2(value, &prefix);
- if (prefix != NULL) {
- xmlNsPtr ns;
-
- ns = xmlSearchNs(node->doc, node, prefix);
- if (ns == NULL)
- ret = 1;
- else if (val != NULL)
- uri = xmlStrdup(ns->href);
- }
- if ((local != NULL) && ((val == NULL) || (ret != 0)))
- xmlFree(local);
- if (prefix != NULL)
- xmlFree(prefix);
- }
- if ((node == NULL) || (node->doc == NULL))
- ret = 3;
- if (ret == 0) {
- ret = xmlValidateNotationUse(NULL, node->doc, value);
- if (ret == 1)
- ret = 0;
- else
- ret = 1;
- }
- if ((ret == 0) && (val != NULL)) {
- v = xmlSchemaNewValue(XML_SCHEMAS_NOTATION);
- if (v != NULL) {
- if (local != NULL)
- v->value.qname.name = local;
- else
- v->value.qname.name = xmlStrdup(value);
- if (uri != NULL)
- v->value.qname.uri = uri;
-
- *val = v;
- } else {
- if (local != NULL)
- xmlFree(local);
- if (uri != NULL)
- xmlFree(uri);
- goto error;
- }
- }
- goto done;
- }
- case XML_SCHEMAS_ANYURI:{
- if (*value != 0) {
- xmlURIPtr uri;
- xmlChar *tmpval, *cur;
- if (normOnTheFly) {
- norm = xmlSchemaCollapseString(value);
- if (norm != NULL)
- value = norm;
- }
- tmpval = xmlStrdup(value);
- for (cur = tmpval; *cur; ++cur) {
- if (*cur < 32 || *cur >= 127 || *cur == ' ' ||
- *cur == '<' || *cur == '>' || *cur == '"' ||
- *cur == '{' || *cur == '}' || *cur == '|' ||
- *cur == '\\' || *cur == '^' || *cur == '`' ||
- *cur == '\'')
- *cur = '_';
- }
- uri = xmlParseURI((const char *) tmpval);
- xmlFree(tmpval);
- if (uri == NULL)
- goto return1;
- xmlFreeURI(uri);
- }
-
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_ANYURI);
- if (v == NULL)
- goto error;
- v->value.str = xmlStrdup(value);
- *val = v;
- }
- goto return0;
- }
- case XML_SCHEMAS_HEXBINARY:{
- const xmlChar *cur = value, *start;
- xmlChar *base;
- int total, i = 0;
-
- if (cur == NULL)
- goto return1;
-
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- start = cur;
- while (((*cur >= '0') && (*cur <= '9')) ||
- ((*cur >= 'A') && (*cur <= 'F')) ||
- ((*cur >= 'a') && (*cur <= 'f'))) {
- i++;
- cur++;
- }
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
-
- if (*cur != 0)
- goto return1;
- if ((i % 2) != 0)
- goto return1;
-
- if (val != NULL) {
-
- v = xmlSchemaNewValue(XML_SCHEMAS_HEXBINARY);
- if (v == NULL)
- goto error;
- /*
- * Copy only the normalized piece.
- * CRITICAL TODO: Check this.
- */
- cur = xmlStrndup(start, i);
- if (cur == NULL) {
- xmlSchemaTypeErrMemory(node, "allocating hexbin data");
- xmlFree(v);
- goto return1;
- }
-
- total = i / 2; /* number of octets */
-
- base = (xmlChar *) cur;
- while (i-- > 0) {
- if (*base >= 'a')
- *base = *base - ('a' - 'A');
- base++;
- }
-
- v->value.hex.str = (xmlChar *) cur;
- v->value.hex.total = total;
- *val = v;
- }
- goto return0;
- }
- case XML_SCHEMAS_BASE64BINARY:{
- /* ISSUE:
- *
- * Ignore all stray characters? (yes, currently)
- * Worry about long lines? (no, currently)
- *
- * rfc2045.txt:
- *
- * "The encoded output stream must be represented in lines of
- * no more than 76 characters each. All line breaks or other
- * characters not found in Table 1 must be ignored by decoding
- * software. In base64 data, characters other than those in
- * Table 1, line breaks, and other white space probably
- * indicate a transmission error, about which a warning
- * message or even a message rejection might be appropriate
- * under some circumstances." */
- const xmlChar *cur = value;
- xmlChar *base;
- int total, i = 0, pad = 0;
-
- if (cur == NULL)
- goto return1;
-
- for (; *cur; ++cur) {
- int decc;
-
- decc = _xmlSchemaBase64Decode(*cur);
- if (decc < 0) ;
- else if (decc < 64)
- i++;
- else
- break;
- }
- for (; *cur; ++cur) {
- int decc;
-
- decc = _xmlSchemaBase64Decode(*cur);
- if (decc < 0) ;
- else if (decc < 64)
- goto return1;
- if (decc == 64)
- pad++;
- }
-
- /* rfc2045.txt: "Special processing is performed if fewer than
- * 24 bits are available at the end of the data being encoded.
- * A full encoding quantum is always completed at the end of a
- * body. When fewer than 24 input bits are available in an
- * input group, zero bits are added (on the right) to form an
- * integral number of 6-bit groups. Padding at the end of the
- * data is performed using the "=" character. Since all
- * base64 input is an integral number of octets, only the
- * following cases can arise: (1) the final quantum of
- * encoding input is an integral multiple of 24 bits; here,
- * the final unit of encoded output will be an integral
- * multiple ofindent: Standard input:701: Warning:old style
- * assignment ambiguity in "=*". Assuming "= *" 4 characters
- * with no "=" padding, (2) the final
- * quantum of encoding input is exactly 8 bits; here, the
- * final unit of encoded output will be two characters
- * followed by two "=" padding characters, or (3) the final
- * quantum of encoding input is exactly 16 bits; here, the
- * final unit of encoded output will be three characters
- * followed by one "=" padding character." */
-
- total = 3 * (i / 4);
- if (pad == 0) {
- if (i % 4 != 0)
- goto return1;
- } else if (pad == 1) {
- int decc;
-
- if (i % 4 != 3)
- goto return1;
- for (decc = _xmlSchemaBase64Decode(*cur);
- (decc < 0) || (decc > 63);
- decc = _xmlSchemaBase64Decode(*cur))
- --cur;
- /* 16bits in 24bits means 2 pad bits: nnnnnn nnmmmm mmmm00*/
- /* 00111100 -> 0x3c */
- if (decc & ~0x3c)
- goto return1;
- total += 2;
- } else if (pad == 2) {
- int decc;
-
- if (i % 4 != 2)
- goto return1;
- for (decc = _xmlSchemaBase64Decode(*cur);
- (decc < 0) || (decc > 63);
- decc = _xmlSchemaBase64Decode(*cur))
- --cur;
- /* 8bits in 12bits means 4 pad bits: nnnnnn nn0000 */
- /* 00110000 -> 0x30 */
- if (decc & ~0x30)
- goto return1;
- total += 1;
- } else
- goto return1;
-
- if (val != NULL) {
- v = xmlSchemaNewValue(XML_SCHEMAS_BASE64BINARY);
- if (v == NULL)
- goto error;
- base =
- (xmlChar *) xmlMallocAtomic((i + pad + 1) *
- sizeof(xmlChar));
- if (base == NULL) {
- xmlSchemaTypeErrMemory(node, "allocating base64 data");
- xmlFree(v);
- goto return1;
- }
- v->value.base64.str = base;
- for (cur = value; *cur; ++cur)
- if (_xmlSchemaBase64Decode(*cur) >= 0) {
- *base = *cur;
- ++base;
- }
- *base = 0;
- v->value.base64.total = total;
- *val = v;
- }
- goto return0;
- }
- case XML_SCHEMAS_INTEGER:
- case XML_SCHEMAS_PINTEGER:
- case XML_SCHEMAS_NPINTEGER:
- case XML_SCHEMAS_NINTEGER:
- case XML_SCHEMAS_NNINTEGER:{
- const xmlChar *cur = value;
- unsigned long lo, mi, hi;
- int sign = 0;
-
- if (cur == NULL)
- goto return1;
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
- if (*cur == '-') {
- sign = 1;
- cur++;
- } else if (*cur == '+')
- cur++;
- ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
- if (ret < 0)
- goto return1;
- if (normOnTheFly)
- while IS_WSP_BLANK_CH(*cur) cur++;
- if (*cur != 0)
- goto return1;
- if (type->builtInType == XML_SCHEMAS_NPINTEGER) {
- if ((sign == 0) &&
- ((hi != 0) || (mi != 0) || (lo != 0)))
- goto return1;
- } else if (type->builtInType == XML_SCHEMAS_PINTEGER) {
- if (sign == 1)
- goto return1;
- if ((hi == 0) && (mi == 0) && (lo == 0))
- goto return1;
- } else if (type->builtInType == XML_SCHEMAS_NINTEGER) {
- if (sign == 0)
- goto return1;
- if ((hi == 0) && (mi == 0) && (lo == 0))
- goto return1;
- } else if (type->builtInType == XML_SCHEMAS_NNINTEGER) {
- if ((sign == 1) &&
- ((hi != 0) || (mi != 0) || (lo != 0)))
- goto return1;
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(type->builtInType);
- if (v != NULL) {
- if (ret == 0)
- ret++;
- v->value.decimal.lo = lo;
- v->value.decimal.mi = mi;
- v->value.decimal.hi = hi;
- v->value.decimal.sign = sign;
- v->value.decimal.frac = 0;
- v->value.decimal.total = ret;
- *val = v;
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_LONG:
- case XML_SCHEMAS_BYTE:
- case XML_SCHEMAS_SHORT:
- case XML_SCHEMAS_INT:{
- const xmlChar *cur = value;
- unsigned long lo, mi, hi;
- int sign = 0;
-
- if (cur == NULL)
- goto return1;
- if (*cur == '-') {
- sign = 1;
- cur++;
- } else if (*cur == '+')
- cur++;
- ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
- if (ret < 0)
- goto return1;
- if (*cur != 0)
- goto return1;
- if (type->builtInType == XML_SCHEMAS_LONG) {
- if (hi >= 922) {
- if (hi > 922)
- goto return1;
- if (mi >= 33720368) {
- if (mi > 33720368)
- goto return1;
- if ((sign == 0) && (lo > 54775807))
- goto return1;
- if ((sign == 1) && (lo > 54775808))
- goto return1;
- }
- }
- } else if (type->builtInType == XML_SCHEMAS_INT) {
- if (hi != 0)
- goto return1;
- if (mi >= 21) {
- if (mi > 21)
- goto return1;
- if ((sign == 0) && (lo > 47483647))
- goto return1;
- if ((sign == 1) && (lo > 47483648))
- goto return1;
- }
- } 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->builtInType == XML_SCHEMAS_BYTE) {
- if ((mi != 0) || (hi != 0))
- goto return1;
- if ((sign == 1) && (lo > 128))
- goto return1;
- if ((sign == 0) && (lo > 127))
- goto return1;
- }
- if (val != NULL) {
- v = xmlSchemaNewValue(type->builtInType);
- if (v != NULL) {
- v->value.decimal.lo = lo;
- v->value.decimal.mi = mi;
- v->value.decimal.hi = hi;
- v->value.decimal.sign = sign;
- v->value.decimal.frac = 0;
- v->value.decimal.total = ret;
- *val = v;
- }
- }
- goto return0;
- }
- case XML_SCHEMAS_UINT:
- case XML_SCHEMAS_ULONG:
- case XML_SCHEMAS_USHORT:
- case XML_SCHEMAS_UBYTE:{
- const xmlChar *cur = value;
- unsigned long lo, mi, hi;
-
- if (cur == NULL)
- goto return1;
- ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
- if (ret < 0)
- goto return1;
- if (*cur != 0)
- goto return1;
- if (type->builtInType == XML_SCHEMAS_ULONG) {
- if (hi >= 1844) {
- if (hi > 1844)
- goto return1;
- if (mi >= 67440737) {
- if (mi > 67440737)
- goto return1;
- if (lo > 9551615)
- goto return1;
- }
- }
- } else if (type->builtInType == XML_SCHEMAS_UINT) {
- if (hi != 0)
- goto return1;
- if (mi >= 42) {
- if (mi > 42)
- goto return1;
- if (lo > 94967295)
- goto return1;
- }
- } else if (type->builtInType == XML_SCHEMAS_USHORT) {
- if ((mi != 0) || (hi != 0))
- goto return1;
- if (lo > 65535)
- goto return1;
- } 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->builtInType);
- if (v != NULL) {
- v->value.decimal.lo = lo;
- v->value.decimal.mi = mi;
- v->value.decimal.hi = hi;
- v->value.decimal.sign = 0;
- v->value.decimal.frac = 0;
- v->value.decimal.total = ret;
- *val = v;
- }
- }
- goto return0;
- }
- }
-
- done:
- if (norm != NULL)
- xmlFree(norm);
- return (ret);
- return3:
- if (norm != NULL)
- xmlFree(norm);
- return (3);
- return1:
- if (norm != NULL)
- xmlFree(norm);
- return (1);
- return0:
- if (norm != NULL)
- xmlFree(norm);
- return (0);
- error:
- if (norm != NULL)
- xmlFree(norm);
- return (-1);
-}
-
-/**
- * xmlSchemaValPredefTypeNode:
- * @type: the predefined type
- * @value: the value to check
- * @val: the return computed value
- * @node: the node containing the value
- *
- * Check that a value conforms to the lexical space of the predefined type.
- * if true a value is computed and returned in @val.
- *
- * Returns 0 if this validates, a positive error code number otherwise
- * and -1 in case of internal or API error.
- */
-int
-xmlSchemaValPredefTypeNode(xmlSchemaTypePtr type, const xmlChar *value,
- xmlSchemaValPtr *val, xmlNodePtr node) {
- return(xmlSchemaValAtomicType(type, value, val, node, 0,
- XML_SCHEMA_WHITESPACE_UNKNOWN, 1, 1, 0));
-}
-
-/**
- * xmlSchemaValPredefTypeNodeNoNorm:
- * @type: the predefined type
- * @value: the value to check
- * @val: the return computed value
- * @node: the node containing the value
- *
- * Check that a value conforms to the lexical space of the predefined type.
- * if true a value is computed and returned in @val.
- * This one does apply any normalization to the value.
- *
- * Returns 0 if this validates, a positive error code number otherwise
- * and -1 in case of internal or API error.
- */
-int
-xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, const xmlChar *value,
- xmlSchemaValPtr *val, xmlNodePtr node) {
- return(xmlSchemaValAtomicType(type, value, val, node, 1,
- XML_SCHEMA_WHITESPACE_UNKNOWN, 1, 0, 1));
-}
-
-/**
- * xmlSchemaValidatePredefinedType:
- * @type: the predefined type
- * @value: the value to check
- * @val: the return computed value
- *
- * Check that a value conforms to the lexical space of the predefined type.
- * if true a value is computed and returned in @val.
- *
- * Returns 0 if this validates, a positive error code number otherwise
- * and -1 in case of internal or API error.
- */
-int
-xmlSchemaValidatePredefinedType(xmlSchemaTypePtr type, const xmlChar *value,
- xmlSchemaValPtr *val) {
- return(xmlSchemaValPredefTypeNode(type, value, val, NULL));
-}
-
-/**
- * xmlSchemaCompareDecimals:
- * @x: a first decimal value
- * @y: a second decimal value
- *
- * Compare 2 decimals
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y and -2 in case of error
- */
-static int
-xmlSchemaCompareDecimals(xmlSchemaValPtr x, xmlSchemaValPtr y)
-{
- xmlSchemaValPtr swp;
- int order = 1, integx, integy, dlen;
- unsigned long hi, mi, lo;
-
- /*
- * First test: If x is -ve and not zero
- */
- if ((x->value.decimal.sign) &&
- ((x->value.decimal.lo != 0) ||
- (x->value.decimal.mi != 0) ||
- (x->value.decimal.hi != 0))) {
- /*
- * Then if y is -ve and not zero reverse the compare
- */
- if ((y->value.decimal.sign) &&
- ((y->value.decimal.lo != 0) ||
- (y->value.decimal.mi != 0) ||
- (y->value.decimal.hi != 0)))
- order = -1;
- /*
- * Otherwise (y >= 0) we have the answer
- */
- else
- return (-1);
- /*
- * If x is not -ve and y is -ve we have the answer
- */
- } else if ((y->value.decimal.sign) &&
- ((y->value.decimal.lo != 0) ||
- (y->value.decimal.mi != 0) ||
- (y->value.decimal.hi != 0))) {
- return (1);
- }
- /*
- * If it's not simply determined by a difference in sign,
- * then we need to compare the actual values of the two nums.
- * To do this, we start by looking at the integral parts.
- * If the number of integral digits differ, then we have our
- * answer.
- */
- integx = x->value.decimal.total - x->value.decimal.frac;
- integy = y->value.decimal.total - y->value.decimal.frac;
- /*
- * NOTE: We changed the "total" for values like "0.1"
- * (or "-0.1" or ".1") to be 1, which was 2 previously.
- * Therefore the special case, when such values are
- * compared with 0, needs to be handled separately;
- * otherwise a zero would be recognized incorrectly as
- * greater than those values. This has the nice side effect
- * that we gain an overall optimized comparison with zeroes.
- * Note that a "0" has a "total" of 1 already.
- */
- if (integx == 1) {
- if (x->value.decimal.lo == 0) {
- if (integy != 1)
- return -order;
- else if (y->value.decimal.lo != 0)
- return -order;
- else
- return(0);
- }
- }
- if (integy == 1) {
- if (y->value.decimal.lo == 0) {
- if (integx != 1)
- return order;
- else if (x->value.decimal.lo != 0)
- return order;
- else
- return(0);
- }
- }
-
- if (integx > integy)
- return order;
- else if (integy > integx)
- return -order;
-
- /*
- * If the number of integral digits is the same for both numbers,
- * then things get a little more complicated. We need to "normalize"
- * the numbers in order to properly compare them. To do this, we
- * look at the total length of each number (length => number of
- * significant digits), and divide the "shorter" by 10 (decreasing
- * the length) until they are of equal length.
- */
- dlen = x->value.decimal.total - y->value.decimal.total;
- if (dlen < 0) { /* y has more digits than x */
- swp = x;
- hi = y->value.decimal.hi;
- mi = y->value.decimal.mi;
- lo = y->value.decimal.lo;
- dlen = -dlen;
- order = -order;
- } else { /* x has more digits than y */
- swp = y;
- hi = x->value.decimal.hi;
- mi = x->value.decimal.mi;
- lo = x->value.decimal.lo;
- }
- while (dlen > 8) { /* in effect, right shift by 10**8 */
- lo = mi;
- mi = hi;
- hi = 0;
- dlen -= 8;
- }
- while (dlen > 0) {
- unsigned long rem1, rem2;
- rem1 = (hi % 10) * 100000000L;
- hi = hi / 10;
- rem2 = (mi % 10) * 100000000L;
- mi = (mi + rem1) / 10;
- lo = (lo + rem2) / 10;
- dlen--;
- }
- if (hi > swp->value.decimal.hi) {
- return order;
- } else if (hi == swp->value.decimal.hi) {
- if (mi > swp->value.decimal.mi) {
- return order;
- } else if (mi == swp->value.decimal.mi) {
- if (lo > swp->value.decimal.lo) {
- return order;
- } else if (lo == swp->value.decimal.lo) {
- if (x->value.decimal.total == y->value.decimal.total) {
- return 0;
- } else {
- return order;
- }
- }
- }
- }
- return -order;
-}
-
-/**
- * xmlSchemaCompareDurations:
- * @x: a first duration value
- * @y: a second duration value
- *
- * Compare 2 durations
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareDurations(xmlSchemaValPtr x, xmlSchemaValPtr y)
-{
- long carry, mon, day;
- double sec;
- int invert = 1;
- long xmon, xday, myear, minday, maxday;
- static const long dayRange [2][12] = {
- { 0, 28, 59, 89, 120, 150, 181, 212, 242, 273, 303, 334, },
- { 0, 31, 62, 92, 123, 153, 184, 215, 245, 276, 306, 337} };
-
- if ((x == NULL) || (y == NULL))
- return -2;
-
- /* months */
- mon = x->value.dur.mon - y->value.dur.mon;
-
- /* seconds */
- sec = x->value.dur.sec - y->value.dur.sec;
- carry = (long)(sec / SECS_PER_DAY);
- sec -= ((double)carry) * SECS_PER_DAY;
-
- /* days */
- day = x->value.dur.day - y->value.dur.day + carry;
-
- /* easy test */
- if (mon == 0) {
- if (day == 0)
- if (sec == 0.0)
- return 0;
- else if (sec < 0.0)
- return -1;
- else
- return 1;
- else if (day < 0)
- return -1;
- else
- return 1;
- }
-
- if (mon > 0) {
- if ((day >= 0) && (sec >= 0.0))
- return 1;
- else {
- xmon = mon;
- xday = -day;
- }
- } else if ((day <= 0) && (sec <= 0.0)) {
- return -1;
- } else {
- invert = -1;
- xmon = -mon;
- xday = day;
- }
-
- myear = xmon / 12;
- if (myear == 0) {
- minday = 0;
- maxday = 0;
- } else {
- maxday = 366 * ((myear + 3) / 4) +
- 365 * ((myear - 1) % 4);
- minday = maxday - 1;
- }
-
- xmon = xmon % 12;
- minday += dayRange[0][xmon];
- maxday += dayRange[1][xmon];
-
- if ((maxday == minday) && (maxday == xday))
- return(0); /* can this really happen ? */
- if (maxday < xday)
- return(-invert);
- if (minday > xday)
- return(invert);
-
- /* indeterminate */
- return 2;
-}
-
-/*
- * macros for adding date/times and durations
- */
-#define FQUOTIENT(a,b) (floor(((double)a/(double)b)))
-#define MODULO(a,b) (a - FQUOTIENT(a,b) * b)
-#define FQUOTIENT_RANGE(a,low,high) (FQUOTIENT((a-low),(high-low)))
-#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));
- ret->next = NULL;
- return ret;
-}
-
-/**
- * xmlSchemaCopyValue:
- * @val: the precomputed value to be copied
- *
- * Copies the precomputed value. This duplicates any string within.
- *
- * Returns the copy or NULL if a copy for a data-type is not implemented.
- */
-xmlSchemaValPtr
-xmlSchemaCopyValue(xmlSchemaValPtr val)
-{
- xmlSchemaValPtr ret = NULL, prev = NULL, cur;
-
- /*
- * Copy the string values.
- */
- while (val != NULL) {
- switch (val->type) {
- case XML_SCHEMAS_ANYTYPE:
- case XML_SCHEMAS_IDREFS:
- case XML_SCHEMAS_ENTITIES:
- case XML_SCHEMAS_NMTOKENS:
- xmlSchemaFreeValue(ret);
- return (NULL);
- case XML_SCHEMAS_ANYSIMPLETYPE:
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_ENTITY:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_ANYURI:
- cur = xmlSchemaDupVal(val);
- if (val->value.str != NULL)
- cur->value.str = xmlStrdup(BAD_CAST val->value.str);
- break;
- case XML_SCHEMAS_QNAME:
- case XML_SCHEMAS_NOTATION:
- cur = xmlSchemaDupVal(val);
- if (val->value.qname.name != NULL)
- cur->value.qname.name =
- xmlStrdup(BAD_CAST val->value.qname.name);
- if (val->value.qname.uri != NULL)
- cur->value.qname.uri =
- xmlStrdup(BAD_CAST val->value.qname.uri);
- break;
- case XML_SCHEMAS_HEXBINARY:
- cur = xmlSchemaDupVal(val);
- if (val->value.hex.str != NULL)
- cur->value.hex.str = xmlStrdup(BAD_CAST val->value.hex.str);
- break;
- case XML_SCHEMAS_BASE64BINARY:
- cur = xmlSchemaDupVal(val);
- if (val->value.base64.str != NULL)
- cur->value.base64.str =
- xmlStrdup(BAD_CAST val->value.base64.str);
- break;
- default:
- cur = xmlSchemaDupVal(val);
- break;
- }
- if (ret == NULL)
- ret = cur;
- else
- prev->next = cur;
- prev = cur;
- val = val->next;
- }
- 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. The returned #xmlSchemaVal is the same type as
- * @dt. The calling program is responsible for freeing the returned value.
- *
- * Returns a pointer to a new #xmlSchemaVal or NULL if error.
- */
-static xmlSchemaValPtr
-_xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur)
-{
- xmlSchemaValPtr ret, tmp;
- long carry, tempdays, temp;
- xmlSchemaValDatePtr r, d;
- xmlSchemaValDurationPtr u;
-
- if ((dt == NULL) || (dur == NULL))
- return NULL;
-
- ret = xmlSchemaNewValue(dt->type);
- 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 = &(tmp->value.date);
- u = &(dur->value.dur);
-
- /* normalization */
- if (d->mon == 0)
- d->mon = 1;
-
- /* normalize for time zone offset */
- u->sec -= (d->tzo * 60);
- d->tzo = 0;
-
- /* normalization */
- if (d->day == 0)
- d->day = 1;
-
- /* month */
- carry = d->mon + u->mon;
- r->mon = (unsigned int) MODULO_RANGE(carry, 1, 13);
- carry = (long) FQUOTIENT_RANGE(carry, 1, 13);
-
- /* year (may be modified later) */
- r->year = d->year + carry;
- if (r->year == 0) {
- if (d->year > 0)
- r->year--;
- else
- r->year++;
- }
-
- /* time zone */
- r->tzo = d->tzo;
- r->tz_flag = d->tz_flag;
-
- /* seconds */
- r->sec = d->sec + u->sec;
- carry = (long) FQUOTIENT((long)r->sec, 60);
- if (r->sec != 0.0) {
- r->sec = MODULO(r->sec, 60.0);
- }
-
- /* minute */
- carry += d->min;
- r->min = (unsigned int) MODULO(carry, 60);
- carry = (long) FQUOTIENT(carry, 60);
-
- /* hours */
- carry += d->hour;
- r->hour = (unsigned int) MODULO(carry, 24);
- carry = (long)FQUOTIENT(carry, 24);
-
- /*
- * days
- * Note we use tempdays because the temporary values may need more
- * than 5 bits
- */
- if ((VALID_YEAR(r->year)) && (VALID_MONTH(r->mon)) &&
- (d->day > MAX_DAYINMONTH(r->year, r->mon)))
- tempdays = MAX_DAYINMONTH(r->year, r->mon);
- else if (d->day < 1)
- tempdays = 1;
- else
- tempdays = d->day;
-
- tempdays += u->day + carry;
-
- while (1) {
- if (tempdays < 1) {
- long tmon = (long) MODULO_RANGE((int)r->mon-1, 1, 13);
- long tyr = r->year + (long)FQUOTIENT_RANGE((int)r->mon-1, 1, 13);
- if (tyr == 0)
- tyr--;
- /*
- * Coverity detected an overrun in daysInMonth
- * of size 12 at position 12 with index variable "((r)->mon - 1)"
- */
- if (tmon < 1)
- tmon = 1;
- if (tmon > 12)
- tmon = 12;
- tempdays += MAX_DAYINMONTH(tyr, tmon);
- carry = -1;
- } else if (VALID_YEAR(r->year) && VALID_MONTH(r->mon) &&
- tempdays > (long) MAX_DAYINMONTH(r->year, r->mon)) {
- tempdays = tempdays - MAX_DAYINMONTH(r->year, r->mon);
- carry = 1;
- } else
- break;
-
- temp = r->mon + carry;
- r->mon = (unsigned int) MODULO_RANGE(temp, 1, 13);
- r->year = r->year + (unsigned int) FQUOTIENT_RANGE(temp, 1, 13);
- if (r->year == 0) {
- if (temp < 1)
- r->year--;
- else
- r->year++;
- }
- }
-
- r->day = tempdays;
-
- /*
- * adjust the date/time type to the date values
- */
- if (ret->type != XML_SCHEMAS_DATETIME) {
- if ((r->hour) || (r->min) || (r->sec))
- ret->type = XML_SCHEMAS_DATETIME;
- else if (ret->type != XML_SCHEMAS_DATE) {
- if ((r->mon != 1) && (r->day != 1))
- ret->type = XML_SCHEMAS_DATE;
- else if ((ret->type != XML_SCHEMAS_GYEARMONTH) && (r->mon != 1))
- ret->type = XML_SCHEMAS_GYEARMONTH;
- }
- }
-
- xmlSchemaFreeValue(tmp);
-
- return ret;
-}
-
-/**
- * xmlSchemaDateNormalize:
- * @dt: an #xmlSchemaValPtr of a date/time type value.
- * @offset: number of seconds to adjust @dt by.
- *
- * 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)
-{
- xmlSchemaValPtr dur, ret;
-
- if (dt == NULL)
- return NULL;
-
- if (((dt->type != XML_SCHEMAS_TIME) &&
- (dt->type != XML_SCHEMAS_DATETIME) &&
- (dt->type != XML_SCHEMAS_DATE)) || (dt->value.date.tzo == 0))
- return xmlSchemaDupVal(dt);
-
- dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
- if (dur == NULL)
- return NULL;
-
- dur->value.date.sec -= offset;
-
- ret = _xmlSchemaDateAdd(dt, dur);
- if (ret == NULL)
- return NULL;
-
- xmlSchemaFreeValue(dur);
-
- /* ret->value.date.tzo = 0; */
- return ret;
-}
-
-/**
- * _xmlSchemaDateCastYMToDays:
- * @dt: an #xmlSchemaValPtr
- *
- * Convert mon and year of @dt to total number of days. Take the
- * number of years since (or before) 1 AD and add the number of leap
- * years. This is a function because negative
- * years must be handled a little differently and there is no zero year.
- *
- * Returns number of days.
- */
-static long
-_xmlSchemaDateCastYMToDays (const xmlSchemaValPtr dt)
-{
- long ret;
- int mon;
-
- mon = dt->value.date.mon;
- if (mon <= 0) mon = 1; /* normalization */
-
- if (dt->value.date.year <= 0)
- ret = (dt->value.date.year * 365) +
- (((dt->value.date.year+1)/4)-((dt->value.date.year+1)/100)+
- ((dt->value.date.year+1)/400)) +
- DAY_IN_YEAR(0, mon, dt->value.date.year);
- else
- ret = ((dt->value.date.year-1) * 365) +
- (((dt->value.date.year-1)/4)-((dt->value.date.year-1)/100)+
- ((dt->value.date.year-1)/400)) +
- DAY_IN_YEAR(0, mon, dt->value.date.year);
-
- return ret;
-}
-
-/**
- * TIME_TO_NUMBER:
- * @dt: an #xmlSchemaValPtr
- *
- * Calculates the number of seconds in the time portion of @dt.
- *
- * Returns seconds.
- */
-#define TIME_TO_NUMBER(dt) \
- ((double)((dt->value.date.hour * SECS_PER_HOUR) + \
- (dt->value.date.min * SECS_PER_MIN) + \
- (dt->value.date.tzo * SECS_PER_MIN)) + \
- dt->value.date.sec)
-
-/**
- * xmlSchemaCompareDates:
- * @x: a first date/time value
- * @y: a second date/time value
- *
- * Compare 2 date/times
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareDates (xmlSchemaValPtr x, xmlSchemaValPtr y)
-{
- unsigned char xmask, ymask, xor_mask, and_mask;
- xmlSchemaValPtr p1, p2, q1, q2;
- long p1d, p2d, q1d, q2d;
-
- if ((x == NULL) || (y == NULL))
- return -2;
-
- if (x->value.date.tz_flag) {
-
- if (!y->value.date.tz_flag) {
- p1 = xmlSchemaDateNormalize(x, 0);
- p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
- /* normalize y + 14:00 */
- q1 = xmlSchemaDateNormalize(y, (14 * SECS_PER_HOUR));
-
- q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
- if (p1d < q1d) {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- return -1;
- } else if (p1d == q1d) {
- double sec;
-
- sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
- if (sec < 0.0) {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- return -1;
- } else {
- int ret = 0;
- /* normalize y - 14:00 */
- q2 = xmlSchemaDateNormalize(y, -(14 * SECS_PER_HOUR));
- q2d = _xmlSchemaDateCastYMToDays(q2) + q2->value.date.day;
- if (p1d > q2d)
- ret = 1;
- else if (p1d == q2d) {
- sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q2);
- if (sec > 0.0)
- ret = 1;
- else
- ret = 2; /* indeterminate */
- }
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- xmlSchemaFreeValue(q2);
- if (ret != 0)
- return(ret);
- }
- } else {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- }
- }
- } else if (y->value.date.tz_flag) {
- q1 = xmlSchemaDateNormalize(y, 0);
- q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
-
- /* normalize x - 14:00 */
- p1 = xmlSchemaDateNormalize(x, -(14 * SECS_PER_HOUR));
- p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
-
- if (p1d < q1d) {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- return -1;
- } else if (p1d == q1d) {
- double sec;
-
- sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
- if (sec < 0.0) {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- return -1;
- } else {
- int ret = 0;
- /* normalize x + 14:00 */
- p2 = xmlSchemaDateNormalize(x, (14 * SECS_PER_HOUR));
- p2d = _xmlSchemaDateCastYMToDays(p2) + p2->value.date.day;
-
- if (p2d > q1d) {
- ret = 1;
- } else if (p2d == q1d) {
- sec = TIME_TO_NUMBER(p2) - TIME_TO_NUMBER(q1);
- if (sec > 0.0)
- ret = 1;
- else
- ret = 2; /* indeterminate */
- }
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- xmlSchemaFreeValue(p2);
- if (ret != 0)
- return(ret);
- }
- } else {
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- }
- }
-
- /*
- * if the same type then calculate the difference
- */
- if (x->type == y->type) {
- int ret = 0;
- q1 = xmlSchemaDateNormalize(y, 0);
- q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
-
- p1 = xmlSchemaDateNormalize(x, 0);
- p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
-
- if (p1d < q1d) {
- ret = -1;
- } else if (p1d > q1d) {
- ret = 1;
- } else {
- double sec;
-
- sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
- if (sec < 0.0)
- ret = -1;
- else if (sec > 0.0)
- ret = 1;
-
- }
- xmlSchemaFreeValue(p1);
- xmlSchemaFreeValue(q1);
- return(ret);
- }
-
- switch (x->type) {
- case XML_SCHEMAS_DATETIME:
- xmask = 0xf;
- break;
- case XML_SCHEMAS_DATE:
- xmask = 0x7;
- break;
- case XML_SCHEMAS_GYEAR:
- xmask = 0x1;
- break;
- case XML_SCHEMAS_GMONTH:
- xmask = 0x2;
- break;
- case XML_SCHEMAS_GDAY:
- xmask = 0x3;
- break;
- case XML_SCHEMAS_GYEARMONTH:
- xmask = 0x3;
- break;
- case XML_SCHEMAS_GMONTHDAY:
- xmask = 0x6;
- break;
- case XML_SCHEMAS_TIME:
- xmask = 0x8;
- break;
- default:
- xmask = 0;
- break;
- }
-
- switch (y->type) {
- case XML_SCHEMAS_DATETIME:
- ymask = 0xf;
- break;
- case XML_SCHEMAS_DATE:
- ymask = 0x7;
- break;
- case XML_SCHEMAS_GYEAR:
- ymask = 0x1;
- break;
- case XML_SCHEMAS_GMONTH:
- ymask = 0x2;
- break;
- case XML_SCHEMAS_GDAY:
- ymask = 0x3;
- break;
- case XML_SCHEMAS_GYEARMONTH:
- ymask = 0x3;
- break;
- case XML_SCHEMAS_GMONTHDAY:
- ymask = 0x6;
- break;
- case XML_SCHEMAS_TIME:
- ymask = 0x8;
- break;
- default:
- ymask = 0;
- break;
- }
-
- xor_mask = xmask ^ ymask; /* mark type differences */
- and_mask = xmask & ymask; /* mark field specification */
-
- /* year */
- if (xor_mask & 1)
- return 2; /* indeterminate */
- else if (and_mask & 1) {
- if (x->value.date.year < y->value.date.year)
- return -1;
- else if (x->value.date.year > y->value.date.year)
- return 1;
- }
-
- /* month */
- if (xor_mask & 2)
- return 2; /* indeterminate */
- else if (and_mask & 2) {
- if (x->value.date.mon < y->value.date.mon)
- return -1;
- else if (x->value.date.mon > y->value.date.mon)
- return 1;
- }
-
- /* day */
- if (xor_mask & 4)
- return 2; /* indeterminate */
- else if (and_mask & 4) {
- if (x->value.date.day < y->value.date.day)
- return -1;
- else if (x->value.date.day > y->value.date.day)
- return 1;
- }
-
- /* time */
- if (xor_mask & 8)
- return 2; /* indeterminate */
- else if (and_mask & 8) {
- if (x->value.date.hour < y->value.date.hour)
- return -1;
- else if (x->value.date.hour > y->value.date.hour)
- return 1;
- else if (x->value.date.min < y->value.date.min)
- return -1;
- else if (x->value.date.min > y->value.date.min)
- return 1;
- else if (x->value.date.sec < y->value.date.sec)
- return -1;
- else if (x->value.date.sec > y->value.date.sec)
- return 1;
- }
-
- return 0;
-}
-
-/**
- * xmlSchemaComparePreserveReplaceStrings:
- * @x: a first string value
- * @y: a second string value
- * @invert: inverts the result if x < y or x > y.
- *
- * Compare 2 string for their normalized values.
- * @x is a string with whitespace of "preserve", @y is
- * a string with a whitespace of "replace". I.e. @x could
- * be an "xsd:string" and @y an "xsd:normalizedString".
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
- * case of error
- */
-static int
-xmlSchemaComparePreserveReplaceStrings(const xmlChar *x,
- const xmlChar *y,
- int invert)
-{
- int tmp;
-
- while ((*x != 0) && (*y != 0)) {
- if (IS_WSP_REPLACE_CH(*y)) {
- if (! IS_WSP_SPACE_CH(*x)) {
- if ((*x - 0x20) < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- } else {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- } else {
- tmp = *x - *y;
- if (tmp < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- }
- if (tmp > 0) {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- x++;
- y++;
- }
- if (*x != 0) {
- if (invert)
- return(-1);
- else
- return(1);
- }
- if (*y != 0) {
- if (invert)
- return(1);
- else
- return(-1);
- }
- return(0);
-}
-
-/**
- * xmlSchemaComparePreserveCollapseStrings:
- * @x: a first string value
- * @y: a second string value
- *
- * Compare 2 string for their normalized values.
- * @x is a string with whitespace of "preserve", @y is
- * a string with a whitespace of "collapse". I.e. @x could
- * be an "xsd:string" and @y an "xsd:normalizedString".
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
- * case of error
- */
-static int
-xmlSchemaComparePreserveCollapseStrings(const xmlChar *x,
- const xmlChar *y,
- int invert)
-{
- int tmp;
-
- /*
- * Skip leading blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
-
- while ((*x != 0) && (*y != 0)) {
- if IS_WSP_BLANK_CH(*y) {
- if (! IS_WSP_SPACE_CH(*x)) {
- /*
- * The yv character would have been replaced to 0x20.
- */
- if ((*x - 0x20) < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- } else {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- x++;
- y++;
- /*
- * Skip contiguous blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
- } else {
- tmp = *x++ - *y++;
- if (tmp < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- }
- if (tmp > 0) {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- }
- if (*x != 0) {
- if (invert)
- return(-1);
- else
- return(1);
- }
- if (*y != 0) {
- /*
- * Skip trailing blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
- if (*y != 0) {
- if (invert)
- return(1);
- else
- return(-1);
- }
- }
- return(0);
-}
-
-/**
- * xmlSchemaComparePreserveCollapseStrings:
- * @x: a first string value
- * @y: a second string value
- *
- * Compare 2 string for their normalized values.
- * @x is a string with whitespace of "preserve", @y is
- * a string with a whitespace of "collapse". I.e. @x could
- * be an "xsd:string" and @y an "xsd:normalizedString".
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareReplaceCollapseStrings(const xmlChar *x,
- const xmlChar *y,
- int invert)
-{
- int tmp;
-
- /*
- * Skip leading blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
-
- while ((*x != 0) && (*y != 0)) {
- if IS_WSP_BLANK_CH(*y) {
- if (! IS_WSP_BLANK_CH(*x)) {
- /*
- * The yv character would have been replaced to 0x20.
- */
- if ((*x - 0x20) < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- } else {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- x++;
- y++;
- /*
- * Skip contiguous blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
- } else {
- if IS_WSP_BLANK_CH(*x) {
- /*
- * The xv character would have been replaced to 0x20.
- */
- if ((0x20 - *y) < 0) {
- if (invert)
- return(1);
- else
- return(-1);
- } else {
- if (invert)
- return(-1);
- else
- return(1);
- }
- }
- tmp = *x++ - *y++;
- if (tmp < 0)
- return(-1);
- if (tmp > 0)
- return(1);
- }
- }
- if (*x != 0) {
- if (invert)
- return(-1);
- else
- return(1);
- }
- if (*y != 0) {
- /*
- * Skip trailing blank chars of the collapsed string.
- */
- while IS_WSP_BLANK_CH(*y)
- y++;
- if (*y != 0) {
- if (invert)
- return(1);
- else
- return(-1);
- }
- }
- return(0);
-}
-
-
-/**
- * xmlSchemaCompareReplacedStrings:
- * @x: a first string value
- * @y: a second string value
- *
- * Compare 2 string for their normalized values.
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareReplacedStrings(const xmlChar *x,
- const xmlChar *y)
-{
- int tmp;
-
- while ((*x != 0) && (*y != 0)) {
- if IS_WSP_BLANK_CH(*y) {
- if (! IS_WSP_BLANK_CH(*x)) {
- if ((*x - 0x20) < 0)
- return(-1);
- else
- return(1);
- }
- } else {
- if IS_WSP_BLANK_CH(*x) {
- if ((0x20 - *y) < 0)
- return(-1);
- else
- return(1);
- }
- tmp = *x - *y;
- if (tmp < 0)
- return(-1);
- if (tmp > 0)
- return(1);
- }
- x++;
- y++;
- }
- if (*x != 0)
- return(1);
- if (*y != 0)
- return(-1);
- return(0);
-}
-
-/**
- * xmlSchemaCompareNormStrings:
- * @x: a first string value
- * @y: a second string value
- *
- * Compare 2 string for their normalized values.
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareNormStrings(const xmlChar *x,
- const xmlChar *y) {
- int tmp;
-
- while (IS_BLANK_CH(*x)) x++;
- while (IS_BLANK_CH(*y)) y++;
- while ((*x != 0) && (*y != 0)) {
- if (IS_BLANK_CH(*x)) {
- if (!IS_BLANK_CH(*y)) {
- tmp = *x - *y;
- return(tmp);
- }
- while (IS_BLANK_CH(*x)) x++;
- while (IS_BLANK_CH(*y)) y++;
- } else {
- tmp = *x++ - *y++;
- if (tmp < 0)
- return(-1);
- if (tmp > 0)
- return(1);
- }
- }
- if (*x != 0) {
- while (IS_BLANK_CH(*x)) x++;
- if (*x != 0)
- return(1);
- }
- if (*y != 0) {
- while (IS_BLANK_CH(*y)) y++;
- if (*y != 0)
- return(-1);
- }
- return(0);
-}
-
-/**
- * xmlSchemaCompareFloats:
- * @x: a first float or double value
- * @y: a second float or double value
- *
- * Compare 2 values
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareFloats(xmlSchemaValPtr x, xmlSchemaValPtr y) {
- double d1, d2;
-
- if ((x == NULL) || (y == NULL))
- return(-2);
-
- /*
- * Cast everything to doubles.
- */
- if (x->type == XML_SCHEMAS_DOUBLE)
- d1 = x->value.d;
- else if (x->type == XML_SCHEMAS_FLOAT)
- d1 = x->value.f;
- else
- return(-2);
-
- if (y->type == XML_SCHEMAS_DOUBLE)
- d2 = y->value.d;
- else if (y->type == XML_SCHEMAS_FLOAT)
- d2 = y->value.f;
- else
- return(-2);
-
- /*
- * Check for special cases.
- */
- if (xmlXPathIsNaN(d1)) {
- if (xmlXPathIsNaN(d2))
- return(0);
- return(1);
- }
- if (xmlXPathIsNaN(d2))
- return(-1);
- if (d1 == xmlXPathPINF) {
- if (d2 == xmlXPathPINF)
- return(0);
- return(1);
- }
- if (d2 == xmlXPathPINF)
- return(-1);
- if (d1 == xmlXPathNINF) {
- if (d2 == xmlXPathNINF)
- return(0);
- return(-1);
- }
- if (d2 == xmlXPathNINF)
- return(1);
-
- /*
- * basic tests, the last one we should have equality, but
- * portability is more important than speed and handling
- * NaN or Inf in a portable way is always a challenge, so ...
- */
- if (d1 < d2)
- return(-1);
- if (d1 > d2)
- return(1);
- if (d1 == d2)
- return(0);
- return(2);
-}
-
-/**
- * xmlSchemaCompareValues:
- * @x: a first value
- * @xvalue: the first value as a string (optional)
- * @xwtsp: the whitespace type
- * @y: a second value
- * @xvalue: the second value as a string (optional)
- * @ywtsp: the whitespace type
- *
- * Compare 2 values
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, 3 if not
- * comparable and -2 in case of error
- */
-static int
-xmlSchemaCompareValuesInternal(xmlSchemaValType xtype,
- xmlSchemaValPtr x,
- const xmlChar *xvalue,
- xmlSchemaWhitespaceValueType xws,
- xmlSchemaValType ytype,
- xmlSchemaValPtr y,
- const xmlChar *yvalue,
- xmlSchemaWhitespaceValueType yws)
-{
- switch (xtype) {
- case XML_SCHEMAS_UNKNOWN:
- case XML_SCHEMAS_ANYTYPE:
- return(-2);
- case XML_SCHEMAS_INTEGER:
- case XML_SCHEMAS_NPINTEGER:
- case XML_SCHEMAS_NINTEGER:
- case XML_SCHEMAS_NNINTEGER:
- case XML_SCHEMAS_PINTEGER:
- case XML_SCHEMAS_INT:
- case XML_SCHEMAS_UINT:
- case XML_SCHEMAS_LONG:
- case XML_SCHEMAS_ULONG:
- case XML_SCHEMAS_SHORT:
- case XML_SCHEMAS_USHORT:
- case XML_SCHEMAS_BYTE:
- case XML_SCHEMAS_UBYTE:
- case XML_SCHEMAS_DECIMAL:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (ytype == xtype)
- return(xmlSchemaCompareDecimals(x, y));
- if ((ytype == XML_SCHEMAS_DECIMAL) ||
- (ytype == XML_SCHEMAS_INTEGER) ||
- (ytype == XML_SCHEMAS_NPINTEGER) ||
- (ytype == XML_SCHEMAS_NINTEGER) ||
- (ytype == XML_SCHEMAS_NNINTEGER) ||
- (ytype == XML_SCHEMAS_PINTEGER) ||
- (ytype == XML_SCHEMAS_INT) ||
- (ytype == XML_SCHEMAS_UINT) ||
- (ytype == XML_SCHEMAS_LONG) ||
- (ytype == XML_SCHEMAS_ULONG) ||
- (ytype == XML_SCHEMAS_SHORT) ||
- (ytype == XML_SCHEMAS_USHORT) ||
- (ytype == XML_SCHEMAS_BYTE) ||
- (ytype == XML_SCHEMAS_UBYTE))
- return(xmlSchemaCompareDecimals(x, y));
- return(-2);
- case XML_SCHEMAS_DURATION:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (ytype == XML_SCHEMAS_DURATION)
- return(xmlSchemaCompareDurations(x, y));
- return(-2);
- 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:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if ((ytype == XML_SCHEMAS_DATETIME) ||
- (ytype == XML_SCHEMAS_TIME) ||
- (ytype == XML_SCHEMAS_GDAY) ||
- (ytype == XML_SCHEMAS_GMONTH) ||
- (ytype == XML_SCHEMAS_GMONTHDAY) ||
- (ytype == XML_SCHEMAS_GYEAR) ||
- (ytype == XML_SCHEMAS_DATE) ||
- (ytype == XML_SCHEMAS_GYEARMONTH))
- return (xmlSchemaCompareDates(x, y));
- return (-2);
- /*
- * Note that we will support comparison of string types against
- * anySimpleType as well.
- */
- case XML_SCHEMAS_ANYSIMPLETYPE:
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_ENTITY:
- case XML_SCHEMAS_ANYURI:
- {
- const xmlChar *xv, *yv;
-
- if (x == NULL)
- xv = xvalue;
- else
- xv = x->value.str;
- if (y == NULL)
- yv = yvalue;
- else
- yv = y->value.str;
- /*
- * TODO: Compare those against QName.
- */
- if (ytype == XML_SCHEMAS_QNAME) {
- TODO
- if (y == NULL)
- return(-2);
- return (-2);
- }
- if ((ytype == XML_SCHEMAS_ANYSIMPLETYPE) ||
- (ytype == XML_SCHEMAS_STRING) ||
- (ytype == XML_SCHEMAS_NORMSTRING) ||
- (ytype == XML_SCHEMAS_TOKEN) ||
- (ytype == XML_SCHEMAS_LANGUAGE) ||
- (ytype == XML_SCHEMAS_NMTOKEN) ||
- (ytype == XML_SCHEMAS_NAME) ||
- (ytype == XML_SCHEMAS_NCNAME) ||
- (ytype == XML_SCHEMAS_ID) ||
- (ytype == XML_SCHEMAS_IDREF) ||
- (ytype == XML_SCHEMAS_ENTITY) ||
- (ytype == XML_SCHEMAS_ANYURI)) {
-
- if (xws == XML_SCHEMA_WHITESPACE_PRESERVE) {
-
- if (yws == XML_SCHEMA_WHITESPACE_PRESERVE) {
- /* TODO: What about x < y or x > y. */
- if (xmlStrEqual(xv, yv))
- return (0);
- else
- return (2);
- } else if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
- return (xmlSchemaComparePreserveReplaceStrings(xv, yv, 0));
- else if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- return (xmlSchemaComparePreserveCollapseStrings(xv, yv, 0));
-
- } else if (xws == XML_SCHEMA_WHITESPACE_REPLACE) {
-
- if (yws == XML_SCHEMA_WHITESPACE_PRESERVE)
- return (xmlSchemaComparePreserveReplaceStrings(yv, xv, 1));
- if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
- return (xmlSchemaCompareReplacedStrings(xv, yv));
- if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- return (xmlSchemaCompareReplaceCollapseStrings(xv, yv, 0));
-
- } else if (xws == XML_SCHEMA_WHITESPACE_COLLAPSE) {
-
- if (yws == XML_SCHEMA_WHITESPACE_PRESERVE)
- return (xmlSchemaComparePreserveCollapseStrings(yv, xv, 1));
- if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
- return (xmlSchemaCompareReplaceCollapseStrings(yv, xv, 1));
- if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- return (xmlSchemaCompareNormStrings(xv, yv));
- } else
- return (-2);
-
- }
- return (-2);
- }
- case XML_SCHEMAS_QNAME:
- case XML_SCHEMAS_NOTATION:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if ((ytype == XML_SCHEMAS_QNAME) ||
- (ytype == XML_SCHEMAS_NOTATION)) {
- if ((xmlStrEqual(x->value.qname.name, y->value.qname.name)) &&
- (xmlStrEqual(x->value.qname.uri, y->value.qname.uri)))
- return(0);
- return(2);
- }
- return (-2);
- case XML_SCHEMAS_FLOAT:
- case XML_SCHEMAS_DOUBLE:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if ((ytype == XML_SCHEMAS_FLOAT) ||
- (ytype == XML_SCHEMAS_DOUBLE))
- return (xmlSchemaCompareFloats(x, y));
- return (-2);
- case XML_SCHEMAS_BOOLEAN:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (ytype == XML_SCHEMAS_BOOLEAN) {
- if (x->value.b == y->value.b)
- return(0);
- if (x->value.b == 0)
- return(-1);
- return(1);
- }
- return (-2);
- case XML_SCHEMAS_HEXBINARY:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (ytype == XML_SCHEMAS_HEXBINARY) {
- if (x->value.hex.total == y->value.hex.total) {
- int ret = xmlStrcmp(x->value.hex.str, y->value.hex.str);
- if (ret > 0)
- return(1);
- else if (ret == 0)
- return(0);
- }
- else if (x->value.hex.total > y->value.hex.total)
- return(1);
-
- return(-1);
- }
- return (-2);
- case XML_SCHEMAS_BASE64BINARY:
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (ytype == XML_SCHEMAS_BASE64BINARY) {
- if (x->value.base64.total == y->value.base64.total) {
- int ret = xmlStrcmp(x->value.base64.str,
- y->value.base64.str);
- if (ret > 0)
- return(1);
- else if (ret == 0)
- return(0);
- else
- return(-1);
- }
- else if (x->value.base64.total > y->value.base64.total)
- return(1);
- else
- return(-1);
- }
- return (-2);
- case XML_SCHEMAS_IDREFS:
- case XML_SCHEMAS_ENTITIES:
- case XML_SCHEMAS_NMTOKENS:
- TODO
- break;
- }
- return -2;
-}
-
-/**
- * xmlSchemaCompareValues:
- * @x: a first value
- * @y: a second value
- *
- * Compare 2 values
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-int
-xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) {
- xmlSchemaWhitespaceValueType xws, yws;
-
- if ((x == NULL) || (y == NULL))
- return(-2);
- if (x->type == XML_SCHEMAS_STRING)
- xws = XML_SCHEMA_WHITESPACE_PRESERVE;
- else if (x->type == XML_SCHEMAS_NORMSTRING)
- xws = XML_SCHEMA_WHITESPACE_REPLACE;
- else
- xws = XML_SCHEMA_WHITESPACE_COLLAPSE;
-
- if (y->type == XML_SCHEMAS_STRING)
- yws = XML_SCHEMA_WHITESPACE_PRESERVE;
- else if (y->type == XML_SCHEMAS_NORMSTRING)
- yws = XML_SCHEMA_WHITESPACE_REPLACE;
- else
- yws = XML_SCHEMA_WHITESPACE_COLLAPSE;
-
- return(xmlSchemaCompareValuesInternal(x->type, x, NULL, xws, y->type,
- y, NULL, yws));
-}
-
-/**
- * xmlSchemaCompareValuesWhtsp:
- * @x: a first value
- * @xws: the whitespace value of x
- * @y: a second value
- * @yws: the whitespace value of y
- *
- * Compare 2 values
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-int
-xmlSchemaCompareValuesWhtsp(xmlSchemaValPtr x,
- xmlSchemaWhitespaceValueType xws,
- xmlSchemaValPtr y,
- xmlSchemaWhitespaceValueType yws)
-{
- if ((x == NULL) || (y == NULL))
- return(-2);
- return(xmlSchemaCompareValuesInternal(x->type, x, NULL, xws, y->type,
- y, NULL, yws));
-}
-
-/**
- * xmlSchemaCompareValuesWhtspExt:
- * @x: a first value
- * @xws: the whitespace value of x
- * @y: a second value
- * @yws: the whitespace value of y
- *
- * Compare 2 values
- *
- * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
- * case of error
- */
-static int
-xmlSchemaCompareValuesWhtspExt(xmlSchemaValType xtype,
- xmlSchemaValPtr x,
- const xmlChar *xvalue,
- xmlSchemaWhitespaceValueType xws,
- xmlSchemaValType ytype,
- xmlSchemaValPtr y,
- const xmlChar *yvalue,
- xmlSchemaWhitespaceValueType yws)
-{
- return(xmlSchemaCompareValuesInternal(xtype, x, xvalue, xws, ytype, y,
- yvalue, yws));
-}
-
-/**
- * xmlSchemaNormLen:
- * @value: a string
- *
- * Computes the UTF8 length of the normalized value of the string
- *
- * Returns the length or -1 in case of error.
- */
-static int
-xmlSchemaNormLen(const xmlChar *value) {
- const xmlChar *utf;
- int ret = 0;
-
- if (value == NULL)
- return(-1);
- utf = value;
- while (IS_BLANK_CH(*utf)) utf++;
- while (*utf != 0) {
- if (utf[0] & 0x80) {
- if ((utf[1] & 0xc0) != 0x80)
- return(-1);
- if ((utf[0] & 0xe0) == 0xe0) {
- if ((utf[2] & 0xc0) != 0x80)
- return(-1);
- if ((utf[0] & 0xf0) == 0xf0) {
- if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
- return(-1);
- utf += 4;
- } else {
- utf += 3;
- }
- } else {
- utf += 2;
- }
- } else if (IS_BLANK_CH(*utf)) {
- while (IS_BLANK_CH(*utf)) utf++;
- if (*utf == 0)
- break;
- } else {
- utf++;
- }
- ret++;
- }
- return(ret);
-}
-
-/**
- * xmlSchemaGetFacetValueAsULong:
- * @facet: an schemas type facet
- *
- * Extract the value of a facet
- *
- * Returns the value as a long
- */
-unsigned long
-xmlSchemaGetFacetValueAsULong(xmlSchemaFacetPtr facet)
-{
- /*
- * TODO: Check if this is a decimal.
- */
- if (facet == NULL)
- return 0;
- return ((unsigned long) facet->val->value.decimal.lo);
-}
-
-/**
- * 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)
-{
- if (facet == NULL)
- return(-1);
- /*
- * 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) {
- if (expectedLen != NULL)
- *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) {
- if (expectedLen != NULL)
- *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) {
- if (expectedLen != NULL)
- *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);
-}
-
-/**
- * xmlSchemaValidateLengthFacet:
- * @type: the built-in type
- * @facet: the facet to check
- * @value: the lexical repr. of the value to be validated
- * @val: the precomputed value
- * @ws: the whitespace type of the value
- * @length: the actual length of the value
- *
- * Checka a value against a "length", "minLength" and "maxLength"
- * facet; sets @length to the computed length of @value.
- *
- * Returns 0 if the value is valid, a positive error code
- * otherwise and -1 in case of an internal or API error.
- */
-static int
-xmlSchemaValidateLengthFacetInternal(xmlSchemaFacetPtr facet,
- xmlSchemaValType valType,
- const xmlChar *value,
- xmlSchemaValPtr val,
- unsigned long *length,
- xmlSchemaWhitespaceValueType ws)
-{
- unsigned int len = 0;
-
- if ((length == NULL) || (facet == NULL))
- return (-1);
- *length = 0;
- if ((facet->type != XML_SCHEMA_FACET_LENGTH) &&
- (facet->type != XML_SCHEMA_FACET_MAXLENGTH) &&
- (facet->type != XML_SCHEMA_FACET_MINLENGTH))
- return (-1);
-
- /*
- * TODO: length, maxLength and minLength must be of type
- * nonNegativeInteger only. Check if decimal is used somehow.
- */
- if ((facet->val == NULL) ||
- ((facet->val->type != XML_SCHEMAS_DECIMAL) &&
- (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
- (facet->val->value.decimal.frac != 0)) {
- return(-1);
- }
- if ((val != NULL) && (val->type == XML_SCHEMAS_HEXBINARY))
- len = val->value.hex.total;
- else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY))
- len = val->value.base64.total;
- else {
- switch (valType) {
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- if (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
- /*
- * This is to ensure API compatibility with the old
- * xmlSchemaValidateLengthFacet(). Anyway, this was and
- * is not the correct handling.
- * TODO: Get rid of this case somehow.
- */
- if (valType == XML_SCHEMAS_STRING)
- len = xmlUTF8Strlen(value);
- else
- len = xmlSchemaNormLen(value);
- } else if (value != NULL) {
- if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- len = xmlSchemaNormLen(value);
- else
- /*
- * Should be OK for "preserve" as well.
- */
- len = xmlUTF8Strlen(value);
- }
- break;
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- /*
- * FIXME: What exactly to do with anyURI?
- */
- case XML_SCHEMAS_ANYURI:
- if (value != NULL)
- len = xmlSchemaNormLen(value);
- break;
- case XML_SCHEMAS_QNAME:
- case XML_SCHEMAS_NOTATION:
- /*
- * For QName and NOTATION, those facets are
- * deprecated and should be ignored.
- */
- return (0);
- default:
- TODO
- }
- }
- *length = (unsigned long) len;
- /*
- * TODO: Return the whole expected value, i.e. "lo", "mi" and "hi".
- */
- if (facet->type == XML_SCHEMA_FACET_LENGTH) {
- if (len != facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_LENGTH_VALID);
- } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
- if (len < facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_MINLENGTH_VALID);
- } else {
- if (len > facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_MAXLENGTH_VALID);
- }
-
- return (0);
-}
-
-/**
- * xmlSchemaValidateLengthFacet:
- * @type: the built-in type
- * @facet: the facet to check
- * @value: the lexical repr. of the value to be validated
- * @val: the precomputed value
- * @length: the actual length of the value
- *
- * Checka a value against a "length", "minLength" and "maxLength"
- * facet; sets @length to the computed length of @value.
- *
- * Returns 0 if the value is valid, a positive error code
- * otherwise and -1 in case of an internal or API error.
- */
-int
-xmlSchemaValidateLengthFacet(xmlSchemaTypePtr type,
- xmlSchemaFacetPtr facet,
- const xmlChar *value,
- xmlSchemaValPtr val,
- unsigned long *length)
-{
- if (type == NULL)
- return(-1);
- return (xmlSchemaValidateLengthFacetInternal(facet,
- type->builtInType, value, val, length,
- XML_SCHEMA_WHITESPACE_UNKNOWN));
-}
-
-/**
- * xmlSchemaValidateLengthFacetWhtsp:
- * @facet: the facet to check
- * @valType: the built-in type
- * @value: the lexical repr. of the value to be validated
- * @val: the precomputed value
- * @ws: the whitespace type of the value
- * @length: the actual length of the value
- *
- * Checka a value against a "length", "minLength" and "maxLength"
- * facet; sets @length to the computed length of @value.
- *
- * Returns 0 if the value is valid, a positive error code
- * otherwise and -1 in case of an internal or API error.
- */
-int
-xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet,
- xmlSchemaValType valType,
- const xmlChar *value,
- xmlSchemaValPtr val,
- unsigned long *length,
- xmlSchemaWhitespaceValueType ws)
-{
- return (xmlSchemaValidateLengthFacetInternal(facet, valType, value, val,
- length, ws));
-}
-
-/**
- * xmlSchemaValidateFacetInternal:
- * @facet: the facet to check
- * @fws: the whitespace type of the facet's value
- * @valType: the built-in type of the value
- * @value: the lexical repr of the value to validate
- * @val: the precomputed value
- * @ws: the whitespace type of the value
- *
- * Check a value against a facet condition
- *
- * Returns 0 if the element is schemas valid, a positive error code
- * number otherwise and -1 in case of internal or API error.
- */
-static int
-xmlSchemaValidateFacetInternal(xmlSchemaFacetPtr facet,
- xmlSchemaWhitespaceValueType fws,
- xmlSchemaValType valType,
- const xmlChar *value,
- xmlSchemaValPtr val,
- xmlSchemaWhitespaceValueType ws)
-{
- int ret;
- int stringType;
-
- if (facet == NULL)
- return(-1);
-
- switch (facet->type) {
- case XML_SCHEMA_FACET_PATTERN:
- /*
- * NOTE that for patterns, the @value needs to be the normalized
- * value, *not* the lexical initial value or the canonical value.
- */
- if (value == NULL)
- return(-1);
- /*
- * If string-derived type, regexp must be tested on the value space of
- * the datatype.
- * See https://www.w3.org/TR/xmlschema-2/#rf-pattern
- */
- stringType = val && ((val->type >= XML_SCHEMAS_STRING && val->type <= XML_SCHEMAS_NORMSTRING)
- || (val->type >= XML_SCHEMAS_TOKEN && val->type <= XML_SCHEMAS_NCNAME));
- ret = xmlRegexpExec(facet->regexp,
- (stringType && val->value.str) ? val->value.str : value);
- if (ret == 1)
- return(0);
- if (ret == 0)
- return(XML_SCHEMAV_CVC_PATTERN_VALID);
- return(ret);
- case XML_SCHEMA_FACET_MAXEXCLUSIVE:
- ret = xmlSchemaCompareValues(val, facet->val);
- if (ret == -2)
- return(-1);
- if (ret == -1)
- return(0);
- return(XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID);
- case XML_SCHEMA_FACET_MAXINCLUSIVE:
- ret = xmlSchemaCompareValues(val, facet->val);
- if (ret == -2)
- return(-1);
- if ((ret == -1) || (ret == 0))
- return(0);
- return(XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID);
- case XML_SCHEMA_FACET_MINEXCLUSIVE:
- ret = xmlSchemaCompareValues(val, facet->val);
- if (ret == -2)
- return(-1);
- if (ret == 1)
- return(0);
- return(XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID);
- case XML_SCHEMA_FACET_MININCLUSIVE:
- ret = xmlSchemaCompareValues(val, facet->val);
- if (ret == -2)
- return(-1);
- if ((ret == 1) || (ret == 0))
- return(0);
- 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 (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
- /*
- * This is to ensure API compatibility with the old
- * xmlSchemaValidateFacet().
- * TODO: Get rid of this case.
- */
- if ((facet->value != NULL) &&
- (xmlStrEqual(facet->value, value)))
- return(0);
- } else {
- ret = xmlSchemaCompareValuesWhtspExt(facet->val->type,
- facet->val, facet->value, fws, valType, val,
- value, ws);
- if (ret == -2)
- return(-1);
- if (ret == 0)
- return(0);
- }
- return(XML_SCHEMAV_CVC_ENUMERATION_VALID);
- case XML_SCHEMA_FACET_LENGTH:
- /*
- * SPEC (1.3) "if {primitive type definition} is QName or NOTATION,
- * then any {value} is facet-valid."
- */
- if ((valType == XML_SCHEMAS_QNAME) ||
- (valType == XML_SCHEMAS_NOTATION))
- return (0);
- /* No break on purpose. */
- case XML_SCHEMA_FACET_MAXLENGTH:
- case XML_SCHEMA_FACET_MINLENGTH: {
- unsigned int len = 0;
-
- if ((valType == XML_SCHEMAS_QNAME) ||
- (valType == XML_SCHEMAS_NOTATION))
- return (0);
- /*
- * TODO: length, maxLength and minLength must be of type
- * nonNegativeInteger only. Check if decimal is used somehow.
- */
- if ((facet->val == NULL) ||
- ((facet->val->type != XML_SCHEMAS_DECIMAL) &&
- (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
- (facet->val->value.decimal.frac != 0)) {
- return(-1);
- }
- if ((val != NULL) && (val->type == XML_SCHEMAS_HEXBINARY))
- len = val->value.hex.total;
- else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY))
- len = val->value.base64.total;
- else {
- switch (valType) {
- case XML_SCHEMAS_STRING:
- case XML_SCHEMAS_NORMSTRING:
- if (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
- /*
- * This is to ensure API compatibility with the old
- * xmlSchemaValidateFacet(). Anyway, this was and
- * is not the correct handling.
- * TODO: Get rid of this case somehow.
- */
- if (valType == XML_SCHEMAS_STRING)
- len = xmlUTF8Strlen(value);
- else
- len = xmlSchemaNormLen(value);
- } else if (value != NULL) {
- if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- len = xmlSchemaNormLen(value);
- else
- /*
- * Should be OK for "preserve" as well.
- */
- len = xmlUTF8Strlen(value);
- }
- break;
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_ANYURI:
- if (value != NULL)
- len = xmlSchemaNormLen(value);
- break;
- default:
- TODO
- }
- }
- if (facet->type == XML_SCHEMA_FACET_LENGTH) {
- if (len != facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_LENGTH_VALID);
- } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
- if (len < facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_MINLENGTH_VALID);
- } else {
- if (len > facet->val->value.decimal.lo)
- return(XML_SCHEMAV_CVC_MAXLENGTH_VALID);
- }
- break;
- }
- case XML_SCHEMA_FACET_TOTALDIGITS:
- case XML_SCHEMA_FACET_FRACTIONDIGITS:
-
- if ((facet->val == NULL) ||
- ((facet->val->type != XML_SCHEMAS_PINTEGER) &&
- (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
- (facet->val->value.decimal.frac != 0)) {
- return(-1);
- }
- if ((val == NULL) ||
- ((val->type != XML_SCHEMAS_DECIMAL) &&
- (val->type != XML_SCHEMAS_INTEGER) &&
- (val->type != XML_SCHEMAS_NPINTEGER) &&
- (val->type != XML_SCHEMAS_NINTEGER) &&
- (val->type != XML_SCHEMAS_NNINTEGER) &&
- (val->type != XML_SCHEMAS_PINTEGER) &&
- (val->type != XML_SCHEMAS_INT) &&
- (val->type != XML_SCHEMAS_UINT) &&
- (val->type != XML_SCHEMAS_LONG) &&
- (val->type != XML_SCHEMAS_ULONG) &&
- (val->type != XML_SCHEMAS_SHORT) &&
- (val->type != XML_SCHEMAS_USHORT) &&
- (val->type != XML_SCHEMAS_BYTE) &&
- (val->type != XML_SCHEMAS_UBYTE))) {
- return(-1);
- }
- if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) {
- if (val->value.decimal.total > facet->val->value.decimal.lo)
- 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(XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID);
- }
- break;
- default:
- TODO
- }
- return(0);
-
-}
-
-/**
- * xmlSchemaValidateFacet:
- * @base: the base type
- * @facet: the facet to check
- * @value: the lexical repr of the value to validate
- * @val: the precomputed value
- *
- * Check a value against a facet condition
- *
- * Returns 0 if the element is schemas valid, a positive error code
- * number otherwise and -1 in case of internal or API error.
- */
-int
-xmlSchemaValidateFacet(xmlSchemaTypePtr base,
- xmlSchemaFacetPtr facet,
- const xmlChar *value,
- xmlSchemaValPtr val)
-{
- /*
- * This tries to ensure API compatibility regarding the old
- * xmlSchemaValidateFacet() and the new xmlSchemaValidateFacetInternal() and
- * xmlSchemaValidateFacetWhtsp().
- */
- if (val != NULL)
- return(xmlSchemaValidateFacetInternal(facet,
- XML_SCHEMA_WHITESPACE_UNKNOWN, val->type, value, val,
- XML_SCHEMA_WHITESPACE_UNKNOWN));
- else if (base != NULL)
- return(xmlSchemaValidateFacetInternal(facet,
- XML_SCHEMA_WHITESPACE_UNKNOWN, base->builtInType, value, val,
- XML_SCHEMA_WHITESPACE_UNKNOWN));
- return(-1);
-}
-
-/**
- * xmlSchemaValidateFacetWhtsp:
- * @facet: the facet to check
- * @fws: the whitespace type of the facet's value
- * @valType: the built-in type of the value
- * @value: the lexical (or normalized for pattern) repr of the value to validate
- * @val: the precomputed value
- * @ws: the whitespace type of the value
- *
- * Check a value against a facet condition. This takes value normalization
- * according to the specified whitespace types into account.
- * Note that @value needs to be the *normalized* value if the facet
- * is of type "pattern".
- *
- * Returns 0 if the element is schemas valid, a positive error code
- * number otherwise and -1 in case of internal or API error.
- */
-int
-xmlSchemaValidateFacetWhtsp(xmlSchemaFacetPtr facet,
- xmlSchemaWhitespaceValueType fws,
- xmlSchemaValType valType,
- const xmlChar *value,
- xmlSchemaValPtr val,
- xmlSchemaWhitespaceValueType ws)
-{
- return(xmlSchemaValidateFacetInternal(facet, fws, valType,
- value, val, ws));
-}
-
-#if 0
-#ifndef DBL_DIG
-#define DBL_DIG 16
-#endif
-#ifndef DBL_EPSILON
-#define DBL_EPSILON 1E-9
-#endif
-
-#define INTEGER_DIGITS DBL_DIG
-#define FRACTION_DIGITS (DBL_DIG + 1)
-#define EXPONENT_DIGITS (3 + 2)
-
-/**
- * xmlXPathFormatNumber:
- * @number: number to format
- * @buffer: output buffer
- * @buffersize: size of output buffer
- *
- * Convert the number into a string representation.
- */
-static void
-xmlSchemaFormatFloat(double number, char buffer[], int buffersize)
-{
- switch (xmlXPathIsInf(number)) {
- case 1:
- if (buffersize > (int)sizeof("INF"))
- snprintf(buffer, buffersize, "INF");
- break;
- case -1:
- if (buffersize > (int)sizeof("-INF"))
- snprintf(buffer, buffersize, "-INF");
- break;
- default:
- if (xmlXPathIsNaN(number)) {
- if (buffersize > (int)sizeof("NaN"))
- snprintf(buffer, buffersize, "NaN");
- } else if (number == 0) {
- snprintf(buffer, buffersize, "0.0E0");
- } else {
- /* 3 is sign, decimal point, and terminating zero */
- char work[DBL_DIG + EXPONENT_DIGITS + 3];
- int integer_place, fraction_place;
- char *ptr;
- char *after_fraction;
- double absolute_value;
- int size;
-
- absolute_value = fabs(number);
-
- /*
- * Result is in work, and after_fraction points
- * just past the fractional part.
- * Use scientific notation
- */
- integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
- fraction_place = DBL_DIG - 1;
- snprintf(work, sizeof(work),"%*.*e",
- integer_place, fraction_place, number);
- after_fraction = strchr(work + DBL_DIG, 'e');
- /* Remove fractional trailing zeroes */
- ptr = after_fraction;
- while (*(--ptr) == '0')
- ;
- if (*ptr != '.')
- ptr++;
- while ((*ptr++ = *after_fraction++) != 0);
-
- /* Finally copy result back to caller */
- size = strlen(work) + 1;
- if (size > buffersize) {
- work[buffersize - 1] = 0;
- size = buffersize;
- }
- memmove(buffer, work, size);
- }
- break;
- }
-}
-#endif
-
-/**
- * xmlSchemaGetCanonValue:
- * @val: the precomputed value
- * @retValue: the returned value
- *
- * Get the canonical lexical representation of the value.
- * The caller has to FREE the returned retValue.
- *
- * WARNING: Some value types are not supported yet, resulting
- * in a @retValue of "???".
- *
- * TODO: XML Schema 1.0 does not define canonical representations
- * for: duration, gYearMonth, gYear, gMonthDay, gMonth, gDay,
- * anyURI, QName, NOTATION. This will be fixed in XML Schema 1.1.
- *
- *
- * Returns 0 if the value could be built, 1 if the value type is
- * not supported yet and -1 in case of API errors.
- */
-int
-xmlSchemaGetCanonValue(xmlSchemaValPtr val, const xmlChar **retValue)
-{
- if ((retValue == NULL) || (val == NULL))
- return (-1);
- *retValue = NULL;
- switch (val->type) {
- case XML_SCHEMAS_STRING:
- if (val->value.str == NULL)
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
- else
- *retValue =
- BAD_CAST xmlStrdup((const xmlChar *) val->value.str);
- break;
- case XML_SCHEMAS_NORMSTRING:
- if (val->value.str == NULL)
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
- else {
- *retValue = xmlSchemaWhiteSpaceReplace(
- (const xmlChar *) val->value.str);
- if ((*retValue) == NULL)
- *retValue = BAD_CAST xmlStrdup(
- (const xmlChar *) val->value.str);
- }
- break;
- case XML_SCHEMAS_TOKEN:
- case XML_SCHEMAS_LANGUAGE:
- case XML_SCHEMAS_NMTOKEN:
- case XML_SCHEMAS_NAME:
- case XML_SCHEMAS_NCNAME:
- case XML_SCHEMAS_ID:
- case XML_SCHEMAS_IDREF:
- case XML_SCHEMAS_ENTITY:
- case XML_SCHEMAS_NOTATION: /* Unclear */
- case XML_SCHEMAS_ANYURI: /* Unclear */
- if (val->value.str == NULL)
- return (-1);
- *retValue =
- BAD_CAST xmlSchemaCollapseString(BAD_CAST val->value.str);
- if (*retValue == NULL)
- *retValue =
- BAD_CAST xmlStrdup((const xmlChar *) val->value.str);
- break;
- case XML_SCHEMAS_QNAME:
- /* TODO: Unclear in XML Schema 1.0. */
- if (val->value.qname.uri == NULL) {
- *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.qname.name);
- return (0);
- } else {
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "{");
- *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
- BAD_CAST val->value.qname.uri);
- *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
- BAD_CAST "}");
- *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
- BAD_CAST val->value.qname.uri);
- }
- break;
- case XML_SCHEMAS_DECIMAL:
- /*
- * TODO: Lookout for a more simple implementation.
- */
- if ((val->value.decimal.total == 1) &&
- (val->value.decimal.lo == 0)) {
- *retValue = xmlStrdup(BAD_CAST "0.0");
- } else {
- xmlSchemaValDecimal dec = val->value.decimal;
- int bufsize;
- char *buf = NULL, *offs;
-
- /* Add room for the decimal point as well. */
- bufsize = dec.total + 2;
- if (dec.sign)
- bufsize++;
- /* Add room for leading/trailing zero. */
- if ((dec.frac == 0) || (dec.frac == dec.total))
- bufsize++;
- buf = xmlMalloc(bufsize);
- if (buf == NULL)
- return(-1);
- offs = buf;
- if (dec.sign)
- *offs++ = '-';
- if (dec.frac == dec.total) {
- *offs++ = '0';
- *offs++ = '.';
- }
- if (dec.hi != 0)
- snprintf(offs, bufsize - (offs - buf),
- "%lu%lu%lu", dec.hi, dec.mi, dec.lo);
- else if (dec.mi != 0)
- snprintf(offs, bufsize - (offs - buf),
- "%lu%lu", dec.mi, dec.lo);
- else
- snprintf(offs, bufsize - (offs - buf),
- "%lu", dec.lo);
-
- if (dec.frac != 0) {
- if (dec.frac != dec.total) {
- int diff = dec.total - dec.frac;
- /*
- * Insert the decimal point.
- */
- memmove(offs + diff + 1, offs + diff, dec.frac +1);
- offs[diff] = '.';
- } else {
- unsigned int i = 0;
- /*
- * Insert missing zeroes behind the decimal point.
- */
- while (*(offs + i) != 0)
- i++;
- if (i < dec.total) {
- memmove(offs + (dec.total - i), offs, i +1);
- memset(offs, '0', dec.total - i);
- }
- }
- } else {
- /*
- * Append decimal point and zero.
- */
- offs = buf + bufsize - 1;
- *offs-- = 0;
- *offs-- = '0';
- *offs-- = '.';
- }
- *retValue = BAD_CAST buf;
- }
- break;
- case XML_SCHEMAS_INTEGER:
- case XML_SCHEMAS_PINTEGER:
- case XML_SCHEMAS_NPINTEGER:
- case XML_SCHEMAS_NINTEGER:
- case XML_SCHEMAS_NNINTEGER:
- case XML_SCHEMAS_LONG:
- case XML_SCHEMAS_BYTE:
- case XML_SCHEMAS_SHORT:
- case XML_SCHEMAS_INT:
- case XML_SCHEMAS_UINT:
- case XML_SCHEMAS_ULONG:
- case XML_SCHEMAS_USHORT:
- case XML_SCHEMAS_UBYTE:
- if ((val->value.decimal.total == 1) &&
- (val->value.decimal.lo == 0))
- *retValue = xmlStrdup(BAD_CAST "0");
- else {
- xmlSchemaValDecimal dec = val->value.decimal;
- int bufsize = dec.total + 1;
-
- /* Add room for the decimal point as well. */
- if (dec.sign)
- bufsize++;
- *retValue = xmlMalloc(bufsize);
- if (*retValue == NULL)
- return(-1);
- if (dec.hi != 0) {
- if (dec.sign)
- snprintf((char *) *retValue, bufsize,
- "-%lu%lu%lu", dec.hi, dec.mi, dec.lo);
- else
- snprintf((char *) *retValue, bufsize,
- "%lu%lu%lu", dec.hi, dec.mi, dec.lo);
- } else if (dec.mi != 0) {
- if (dec.sign)
- snprintf((char *) *retValue, bufsize,
- "-%lu%lu", dec.mi, dec.lo);
- else
- snprintf((char *) *retValue, bufsize,
- "%lu%lu", dec.mi, dec.lo);
- } else {
- if (dec.sign)
- snprintf((char *) *retValue, bufsize, "-%lu", dec.lo);
- else
- snprintf((char *) *retValue, bufsize, "%lu", dec.lo);
- }
- }
- break;
- case XML_SCHEMAS_BOOLEAN:
- if (val->value.b)
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "true");
- else
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "false");
- break;
- case XML_SCHEMAS_DURATION: {
- char buf[100];
- unsigned long year;
- unsigned long mon, day, hour = 0, min = 0;
- double sec = 0, left;
-
- /* TODO: Unclear in XML Schema 1.0 */
- /*
- * TODO: This results in a normalized output of the value
- * - which is NOT conformant to the spec -
- * since the exact values of each property are not
- * recoverable. Think about extending the structure to
- * provide a field for every property.
- */
- year = (unsigned long) FQUOTIENT(labs(val->value.dur.mon), 12);
- mon = labs(val->value.dur.mon) - 12 * year;
-
- day = (unsigned long) FQUOTIENT(fabs(val->value.dur.sec), 86400);
- left = fabs(val->value.dur.sec) - day * 86400;
- if (left > 0) {
- hour = (unsigned long) FQUOTIENT(left, 3600);
- left = left - (hour * 3600);
- if (left > 0) {
- min = (unsigned long) FQUOTIENT(left, 60);
- sec = left - (min * 60);
- }
- }
- if ((val->value.dur.mon < 0) || (val->value.dur.sec < 0))
- snprintf(buf, 100, "P%luY%luM%luDT%luH%luM%.14gS",
- year, mon, day, hour, min, sec);
- else
- snprintf(buf, 100, "-P%luY%luM%luDT%luH%luM%.14gS",
- year, mon, day, hour, min, sec);
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_GYEAR: {
- char buf[30];
- /* TODO: Unclear in XML Schema 1.0 */
- /* TODO: What to do with the timezone? */
- snprintf(buf, 30, "%04ld", val->value.date.year);
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_GMONTH: {
- /* TODO: Unclear in XML Schema 1.0 */
- /* TODO: What to do with the timezone? */
- *retValue = xmlMalloc(6);
- if (*retValue == NULL)
- return(-1);
- snprintf((char *) *retValue, 6, "--%02u",
- val->value.date.mon);
- }
- break;
- case XML_SCHEMAS_GDAY: {
- /* TODO: Unclear in XML Schema 1.0 */
- /* TODO: What to do with the timezone? */
- *retValue = xmlMalloc(6);
- if (*retValue == NULL)
- return(-1);
- snprintf((char *) *retValue, 6, "---%02u",
- val->value.date.day);
- }
- break;
- case XML_SCHEMAS_GMONTHDAY: {
- /* TODO: Unclear in XML Schema 1.0 */
- /* TODO: What to do with the timezone? */
- *retValue = xmlMalloc(8);
- if (*retValue == NULL)
- return(-1);
- snprintf((char *) *retValue, 8, "--%02u-%02u",
- val->value.date.mon, val->value.date.day);
- }
- break;
- case XML_SCHEMAS_GYEARMONTH: {
- char buf[35];
- /* TODO: Unclear in XML Schema 1.0 */
- /* TODO: What to do with the timezone? */
- if (val->value.date.year < 0)
- snprintf(buf, 35, "-%04ld-%02u",
- labs(val->value.date.year),
- val->value.date.mon);
- else
- snprintf(buf, 35, "%04ld-%02u",
- val->value.date.year, val->value.date.mon);
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_TIME:
- {
- char buf[30];
-
- if (val->value.date.tz_flag) {
- xmlSchemaValPtr norm;
-
- norm = xmlSchemaDateNormalize(val, 0);
- if (norm == NULL)
- return (-1);
- /*
- * TODO: Check if "%.14g" is portable.
- */
- snprintf(buf, 30,
- "%02u:%02u:%02.14gZ",
- norm->value.date.hour,
- norm->value.date.min,
- norm->value.date.sec);
- xmlSchemaFreeValue(norm);
- } else {
- snprintf(buf, 30,
- "%02u:%02u:%02.14g",
- val->value.date.hour,
- val->value.date.min,
- val->value.date.sec);
- }
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_DATE:
- {
- char buf[30];
-
- if (val->value.date.tz_flag) {
- xmlSchemaValPtr norm;
-
- norm = xmlSchemaDateNormalize(val, 0);
- if (norm == NULL)
- return (-1);
- /*
- * TODO: Append the canonical value of the
- * recoverable timezone and not "Z".
- */
- snprintf(buf, 30,
- "%04ld:%02u:%02uZ",
- norm->value.date.year, norm->value.date.mon,
- norm->value.date.day);
- xmlSchemaFreeValue(norm);
- } else {
- snprintf(buf, 30,
- "%04ld:%02u:%02u",
- val->value.date.year, val->value.date.mon,
- val->value.date.day);
- }
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_DATETIME:
- {
- char buf[50];
-
- if (val->value.date.tz_flag) {
- xmlSchemaValPtr norm;
-
- norm = xmlSchemaDateNormalize(val, 0);
- if (norm == NULL)
- return (-1);
- /*
- * TODO: Check if "%.14g" is portable.
- */
- snprintf(buf, 50,
- "%04ld:%02u:%02uT%02u:%02u:%02.14gZ",
- norm->value.date.year, norm->value.date.mon,
- norm->value.date.day, norm->value.date.hour,
- norm->value.date.min, norm->value.date.sec);
- xmlSchemaFreeValue(norm);
- } else {
- snprintf(buf, 50,
- "%04ld:%02u:%02uT%02u:%02u:%02.14g",
- val->value.date.year, val->value.date.mon,
- val->value.date.day, val->value.date.hour,
- val->value.date.min, val->value.date.sec);
- }
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_HEXBINARY:
- *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.hex.str);
- break;
- case XML_SCHEMAS_BASE64BINARY:
- /*
- * TODO: Is the following spec piece implemented?:
- * SPEC: "Note: For some values the canonical form defined
- * above does not conform to [RFC 2045], which requires breaking
- * with linefeeds at appropriate intervals."
- */
- *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.base64.str);
- break;
- case XML_SCHEMAS_FLOAT: {
- char buf[30];
- /*
- * |m| < 16777216, -149 <= e <= 104.
- * TODO: Handle, NaN, INF, -INF. The format is not
- * yet conformant. The c type float does not cover
- * the whole range.
- */
- snprintf(buf, 30, "%01.14e", val->value.f);
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- case XML_SCHEMAS_DOUBLE: {
- char buf[40];
- /* |m| < 9007199254740992, -1075 <= e <= 970 */
- /*
- * TODO: Handle, NaN, INF, -INF. The format is not
- * yet conformant. The c type float does not cover
- * the whole range.
- */
- snprintf(buf, 40, "%01.14e", val->value.d);
- *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
- }
- break;
- default:
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "???");
- return (1);
- }
- if (*retValue == NULL)
- return(-1);
- return (0);
-}
-
-/**
- * xmlSchemaGetCanonValueWhtsp:
- * @val: the precomputed value
- * @retValue: the returned value
- * @ws: the whitespace type of the value
- *
- * Get the canonical representation of the value.
- * The caller has to free the returned @retValue.
- *
- * Returns 0 if the value could be built, 1 if the value type is
- * not supported yet and -1 in case of API errors.
- */
-int
-xmlSchemaGetCanonValueWhtsp(xmlSchemaValPtr val,
- const xmlChar **retValue,
- xmlSchemaWhitespaceValueType ws)
-{
- if ((retValue == NULL) || (val == NULL))
- return (-1);
- if ((ws == XML_SCHEMA_WHITESPACE_UNKNOWN) ||
- (ws > XML_SCHEMA_WHITESPACE_COLLAPSE))
- return (-1);
-
- *retValue = NULL;
- switch (val->type) {
- case XML_SCHEMAS_STRING:
- if (val->value.str == NULL)
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
- else if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- *retValue = xmlSchemaCollapseString(val->value.str);
- else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
- *retValue = xmlSchemaWhiteSpaceReplace(val->value.str);
- if ((*retValue) == NULL)
- *retValue = BAD_CAST xmlStrdup(val->value.str);
- break;
- case XML_SCHEMAS_NORMSTRING:
- if (val->value.str == NULL)
- *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
- else {
- if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
- *retValue = xmlSchemaCollapseString(val->value.str);
- else
- *retValue = xmlSchemaWhiteSpaceReplace(val->value.str);
- if ((*retValue) == NULL)
- *retValue = BAD_CAST xmlStrdup(val->value.str);
- }
- break;
- default:
- return (xmlSchemaGetCanonValue(val, retValue));
- }
- return (0);
-}
-
-/**
- * xmlSchemaGetValType:
- * @val: a schemas value
- *
- * Accessor for the type of a value
- *
- * Returns the xmlSchemaValType of the value
- */
-xmlSchemaValType
-xmlSchemaGetValType(xmlSchemaValPtr val)
-{
- if (val == NULL)
- return(XML_SCHEMAS_UNKNOWN);
- return (val->type);
-}
-
-#define bottom_xmlschemastypes
-#include "elfgcchack.h"
-#endif /* LIBXML_SCHEMAS_ENABLED */
« no previous file with comments | « third_party/libxml/src/xmlschemas.c ('k') | third_party/libxml/src/xpointer.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698