Load /tmp/tmp.BmUFjT/libxml2-2.6.13 intoupstream/2.6.13

packages/libxml2/branches/upstream/current.

1 files changed, 131 insertions, 13 deletions

diff --git a/xmlschemastypes.c b/xmlschemastypes.c
index 78e10fc..9ebcfd9 100644
--- a/xmlschemastypes.c
+++ b/xmlschemastypes.c
@@ -226,7 +226,8 @@ xmlSchemaInitBasicType(const char *name, xmlSchemaValType type,
 	(type == XML_SCHEMAS_NMTOKENS) ||
 	(type == XML_SCHEMAS_ENTITIES)) 
 	ret->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
-    else if (type != XML_SCHEMAS_UNKNOWN)
+    else if ((type != XML_SCHEMAS_ANYTYPE) &&
+	(type != XML_SCHEMAS_ANYSIMPLETYPE))
 	ret->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
     ret->contentType = XML_SCHEMA_CONTENT_BASIC;
     switch (type) {
@@ -277,7 +278,7 @@ xmlSchemaInitTypes(void)
     * 3.4.7 Built-in Complex Type Definition
     */
     xmlSchemaTypeAnyTypeDef = xmlSchemaInitBasicType("anyType",
-                                                     XML_SCHEMAS_UNKNOWN, 
+                                                     XML_SCHEMAS_ANYTYPE, 
 						     NULL);
     xmlSchemaTypeAnyTypeDef->baseType = xmlSchemaTypeAnyTypeDef;
     xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
@@ -286,7 +287,7 @@ xmlSchemaInitTypes(void)
 
 	wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
 	if (wild == NULL) {
-	    xmlSchemaTypeErrMemory(NULL, "could not create a wildcard on anyType");
+	    xmlSchemaTypeErrMemory(NULL, "could not create an attribute wildcard on anyType");
 	    return;
 	}
 	memset(wild, 0, sizeof(xmlSchemaWildcard));
@@ -297,7 +298,7 @@ xmlSchemaInitTypes(void)
 	xmlSchemaTypeAnyTypeDef->attributeWildcard = wild;
     }
     xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType", 
-                                                           XML_SCHEMAS_UNKNOWN,
+                                                           XML_SCHEMAS_ANYSIMPLETYPE,
 							   xmlSchemaTypeAnyTypeDef);
     /*
     * primitive datatypes
@@ -1732,6 +1733,13 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value,
     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)) {
@@ -1744,10 +1752,11 @@ xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value,
     }
 
     switch (type->builtInType) {
-        case XML_SCHEMAS_UNKNOWN:
-            if (type == xmlSchemaTypeAnySimpleTypeDef)
-                goto return0;
+        case XML_SCHEMAS_UNKNOWN:            
             goto error;
+	case XML_SCHEMAS_ANYTYPE:
+	case XML_SCHEMAS_ANYSIMPLETYPE:
+	    goto return0;
         case XML_SCHEMAS_STRING:
             goto return0;
         case XML_SCHEMAS_NORMSTRING:{
@@ -2697,6 +2706,26 @@ xmlSchemaValPredefTypeNode(xmlSchemaTypePtr type, const xmlChar *value,
 }
 
 /**
+ * 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));
+}
+
+/**
  * xmlSchemaValidatePredefinedType:
  * @type: the predefined type
  * @value: the value to check
@@ -3527,6 +3556,8 @@ xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) {
 
     switch (x->type) {
 	case XML_SCHEMAS_UNKNOWN:
+	case XML_SCHEMAS_ANYTYPE:
+	case XML_SCHEMAS_ANYSIMPLETYPE:
 	    return(-2);
         case XML_SCHEMAS_INTEGER:
         case XML_SCHEMAS_NPINTEGER:
@@ -3667,9 +3698,6 @@ xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) {
         case XML_SCHEMAS_NMTOKENS:
 	    TODO
 	    break;
-	case XML_SCHEMAS_ANYTYPE:
-	case XML_SCHEMAS_ANYSIMPLETYPE:
-	    break;
     }
     return -2;
 }
@@ -3720,6 +3748,15 @@ xmlSchemaNormLen(const xmlChar *value) {
     return(ret);
 }
 
+unsigned long
+xmlSchemaGetFacetValueAsULong(xmlSchemaFacetPtr facet)
+{
+    /*
+    * TODO: Check if this is a decimal.
+    */
+    return ((unsigned long) facet->val->value.decimal.lo);
+}
+
 /**
  * xmlSchemaValidateListSimpleTypeFacet:
  * @facet:  the facet to check
@@ -3744,17 +3781,20 @@ xmlSchemaValidateListSimpleTypeFacet(xmlSchemaFacetPtr facet,
     */
     if (facet->type == XML_SCHEMA_FACET_LENGTH) {
 	if (actualLen != facet->val->value.decimal.lo) {
-	    *expectedLen = facet->val->value.decimal.lo;
+	    if (expectedLen != 0)
+		*expectedLen = facet->val->value.decimal.lo;
 	    return (XML_SCHEMAV_CVC_LENGTH_VALID);
 	}	
     } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
 	if (actualLen < facet->val->value.decimal.lo) {
-	     *expectedLen = facet->val->value.decimal.lo;
+	    if (expectedLen != 0)
+		*expectedLen = facet->val->value.decimal.lo;
 	    return (XML_SCHEMAV_CVC_MINLENGTH_VALID);
 	}
     } else if (facet->type == XML_SCHEMA_FACET_MAXLENGTH) {
 	if (actualLen > facet->val->value.decimal.lo) {
-	     *expectedLen = facet->val->value.decimal.lo;
+	    if (expectedLen != 0)
+		*expectedLen = facet->val->value.decimal.lo;
 	    return (XML_SCHEMAV_CVC_MAXLENGTH_VALID);
 	}
     } else
@@ -3769,6 +3809,84 @@ xmlSchemaValidateListSimpleTypeFacet(xmlSchemaFacetPtr facet,
 
 /**
  * xmlSchemaValidateFacet:
+ * @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)  
+{
+    unsigned int len = 0;
+
+    *length = 0;
+    if ((facet->type != XML_SCHEMA_FACET_LENGTH) &&
+	(facet->type != XML_SCHEMA_FACET_MAXLENGTH) &&
+	(facet->type != XML_SCHEMA_FACET_MINLENGTH))
+	return (-1);
+	
+    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 (type->builtInType) {
+	    case XML_SCHEMAS_IDREF:
+	    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:
+		len = xmlSchemaNormLen(value);
+		break;
+	    case XML_SCHEMAS_STRING:
+	    /*
+	    * FIXME: What exactly to do with anyURI?
+	    */
+	    case XML_SCHEMAS_ANYURI:
+		if (value != NULL)
+		    len = xmlUTF8Strlen(value);
+		break;
+	    default:
+		TODO
+	}
+    }
+    *length = (unsigned long) len;
+    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);
+}
+
+/**
+ * xmlSchemaValidateFacet:
  * @base:  the base type
  * @facet:  the facet to check
  * @value:  the lexical repr of the value to validate