Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/xmlschemastypes.c

 /*
  * 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
@@ skipping 22 matching lines @@
 #endif
 
 #define DEBUG
 
 #ifndef LIBXML_XPATH_ENABLED
 extern double xmlXPathNAN;
 extern double xmlXPathPINF;
 extern double xmlXPathNINF;
 #endif
 
-#define TODO                                                            \
+#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))
 
@@ skipping 14 matching lines @@
     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;
+    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;
@@ skipping 93 matching lines @@
 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                         *
+ *                      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                              *
+ *                      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
@@ skipping 15 matching lines @@
 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, 
+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->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:      
+    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;      
+            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);
 }
@@ skipping 60 matching lines @@
  *
  * 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, 
+                                                     XML_SCHEMAS_ANYTYPE,
                                                      NULL);
     xmlSchemaTypeAnyTypeDef->baseType = xmlSchemaTypeAnyTypeDef;
     xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
     /*
     * Init the content type.
     */
-    xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;    
+    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;      
+        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;    
+        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;    
+        wild->processContents = XML_SCHEMAS_ANY_LAX;
         xmlSchemaTypeAnyTypeDef->attributeWildcard = wild;
     }
-    xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType", 
+    xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType",
                                                            XML_SCHEMAS_ANYSIMPLETYPE,
                                                            xmlSchemaTypeAnyTypeDef);
     /*
     * primitive datatypes
     */
     xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string",
                                                     XML_SCHEMAS_STRING,
                                                     xmlSchemaTypeAnySimpleTypeDef);
     xmlSchemaTypeDecimalDef = xmlSchemaInitBasicType("decimal",
                                                      XML_SCHEMAS_DECIMAL,
@@ skipping 38 matching lines @@
                                                     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);    
+                                                    xmlSchemaTypeAnySimpleTypeDef);
     xmlSchemaTypeQNameDef = xmlSchemaInitBasicType("QName",
                                                    XML_SCHEMAS_QNAME,
                                                    xmlSchemaTypeAnySimpleTypeDef);
 
     /*
      * derived datatypes
      */
     xmlSchemaTypeIntegerDef = xmlSchemaInitBasicType("integer",
                                                      XML_SCHEMAS_INTEGER,
                                                      xmlSchemaTypeDecimalDef);
@@ skipping 49 matching lines @@
     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);        
+                                                   xmlSchemaTypeNCNameDef);
     xmlSchemaTypeEntityDef = xmlSchemaInitBasicType("ENTITY",
                                                     XML_SCHEMAS_ENTITY,
                                                     xmlSchemaTypeNCNameDef);
     /*
     * Derived list types.
     */
     /* ENTITIES */
     xmlSchemaTypeEntitiesDef = xmlSchemaInitBasicType("ENTITIES",
                                                       XML_SCHEMAS_ENTITIES,
                                                       xmlSchemaTypeAnySimpleTypeDef);
@@ skipping 11 matching lines @@
     xmlSchemaTypeNmtokensDef->subtypes = xmlSchemaTypeNmtokenDef;
 
     xmlSchemaTypesInitialized = 1;
 }
 
 /**
  * xmlSchemaCleanupTypes:
  *
  * Cleanup the default XML Schemas type library
  */
-void    
+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) 
+        xmlSchemaFreeWildcard((xmlSchemaWildcardPtr)
             particle->children->children->children);
         xmlFree((xmlSchemaParticlePtr) particle->children->children);
         /* Sequence model group. */
         xmlFree((xmlSchemaModelGroupPtr) particle->children);
         xmlFree((xmlSchemaParticlePtr) particle);
-        xmlSchemaTypeAnyTypeDef->subtypes = NULL;       
+        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);     
+                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_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); 
+                return (0);
         case XML_SCHEMAS_TIME:
-        case XML_SCHEMAS_GDAY: 
+        case XML_SCHEMAS_GDAY:
         case XML_SCHEMAS_GMONTH:
-        case XML_SCHEMAS_GMONTHDAY: 
-        case XML_SCHEMAS_GYEAR: 
+        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);                                      
+                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);
+            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);
@@ skipping 55 matching lines @@
             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);       
+            return (xmlSchemaTypeAnyTypeDef);
         default:
             return (NULL);
     }
 }
 
 /**
  * xmlSchemaValueAppend:
  * @prev: the value
  * @cur: the value to be appended
  *
@@ skipping 31 matching lines @@
  * 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:
@@ skipping 12 matching lines @@
 /**
  * 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. 
+ * 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)
 {
@@ skipping 61 matching lines @@
     val->value.qname.uri = (xmlChar *) namespaceName;
     return(val);
 }
 
 /**
  * xmlSchemaFreeValue:
  * @value:  the value to free
  *
  * Cleanup the default XML Schemas type library
  */
-void    
+void
 xmlSchemaFreeValue(xmlSchemaValPtr value) {
     xmlSchemaValPtr prev;
 
-    while (value != NULL) {     
+    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_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
@@ skipping 15 matching lines @@
  *
  * 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: 
+        case XML_SCHEMAS_NMTOKENS:
             return (xmlSchemaTypeNmtokenDef );
-        case XML_SCHEMAS_IDREFS: 
+        case XML_SCHEMAS_IDREFS:
             return (xmlSchemaTypeIdrefDef);
         case XML_SCHEMAS_ENTITIES:
             return (xmlSchemaTypeEntityDef);
         default:
             return (NULL);
     }
 }
 
 /****************************************************************
  *                                                              *
@@ skipping 231 matching lines @@
  *
  * 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;    
+    const xmlChar *cur = *str;
     int ret = 0;
     int value = 0;
 
     PARSE_2_DIGITS(value, cur, ret);
     if (ret != 0)
-        return ret;    
+        return ret;
     if (*cur != ':')
         return 1;
     if (!VALID_HOUR(value))
         return 2;
     cur++;
 
     /* the ':' insures this string is xs:time */
     dt->hour = value;
 
     PARSE_2_DIGITS(value, cur, ret);
@@ skipping 245 matching lines @@
          * 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);
+            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)))) {
@@ skipping 217 matching lines @@
                 }
 
                 break;          /* exit loop */
             }
             /* no date designators found? */
             if ((++seq == 3) || (seq == 6))
                 goto error;
         }
         cur++;
         if (collapse)
-            while IS_WSP_BLANK_CH(*cur) cur++;        
+            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;
@@ skipping 35 matching lines @@
 /**
  * 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; 
+    const xmlChar *cur = value;
+    xmlChar *ret = NULL, *mcur;
 
-    if (value == NULL) 
+    if (value == NULL)
         return(NULL);
-    
-    while ((*cur != 0) && 
+
+    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);           
+    } 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.
@@ skipping 124 matching lines @@
  * 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'))) 
+    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) {
@@ skipping 55 matching lines @@
      * 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_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:            
+        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:                
+        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++;
                         }
@@ skipping 58 matching lines @@
                     } 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;           
+                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++;
 
@@ skipping 53 matching lines @@
                     } 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
-                        */
+                        * 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--;
                                 }
                             }
@@ skipping 38 matching lines @@
         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:{
+        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) {
@@ skipping 52 matching lines @@
                         *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'))
+                    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++;
 
@@ skipping 107 matching lines @@
                             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) {             
+            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;
@@ skipping 264 matching lines @@
                     } else {
                         if (local != NULL)
                             xmlFree(local);
                         if (uri != NULL)
                             xmlFree(uri);
                         goto error;
                     }
                 }
                 goto done;
             }
-        case XML_SCHEMAS_ANYURI:{               
+        case XML_SCHEMAS_ANYURI:{
                 if (*value != 0) {
                     xmlURIPtr uri;
                     xmlChar *tmpval, *cur;
-                    if (normOnTheFly) {             
+                    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 == '`' ||
@@ skipping 68 matching lines @@
                     }
 
                     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;
@@ skipping 390 matching lines @@
 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) && 
+    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)))
@@ skipping 136 matching lines @@
         { 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);
+    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)
@@ skipping 62 matching lines @@
  * 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.
@@ skipping 25 matching lines @@
             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_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:
@@ skipping 121 matching lines @@
 
     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 
+             * Coverity detected an overrun in daysInMonth
              * of size 12 at position 12 with index variable "((r)->mon - 1)"
              */
-            if (tmon < 0)
-                tmon = 0;
+            if (tmon < 1)
+                tmon = 1;
             if (tmon > 12)
                 tmon = 12;
             tempdays += MAX_DAYINMONTH(tyr, tmon);
             carry = -1;
-        } else if (tempdays > (long) MAX_DAYINMONTH(r->year, r->mon)) {
+        } 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))
@@ skipping 44 matching lines @@
     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 
+ * 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;
@@ skipping 159 matching lines @@
         } 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;
@@ skipping 120 matching lines @@
  *
  * 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)
@@ skipping 33 matching lines @@
  * 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.
@@ skipping 68 matching lines @@
  * 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++;            
-            /* 
+            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) {
@@ skipping 13 matching lines @@
                 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
@@ skipping 12 matching lines @@
  * 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);
+                    return(-1);
                 else
                     return(1);
-            }       
+            }
         } else {
             if IS_WSP_BLANK_CH(*x) {
                 if ((0x20 - *y) < 0)
-                    return(-1);
+                    return(-1);
                 else
                     return(1);
             }
             tmp = *x - *y;
             if (tmp < 0)
-                return(-1);
+                return(-1);
             if (tmp > 0)
-                return(1);
+                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++;
@@ skipping 172 matching lines @@
             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_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) {           
+            if (ytype == XML_SCHEMAS_QNAME) {
                 TODO
                 if (y == NULL)
-                    return(-2);    
+                    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 
+                        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)) &&
@@ skipping 50 matching lines @@
                     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);    
+            return (-2);
         case XML_SCHEMAS_IDREFS:
         case XML_SCHEMAS_ENTITIES:
         case XML_SCHEMAS_NMTOKENS:
             TODO
             break;
     }
     return -2;
 }
 
 /**
@@ skipping 14 matching lines @@
         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 (x->type == XML_SCHEMAS_NORMSTRING)
+    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:
@@ skipping 132 matching lines @@
         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 
+        /*
+        * NOTE: That we can pass NULL as xmlSchemaValPtr to
         * xmlSchemaValidateFacet, since the remaining facet types
-        * are: XML_SCHEMA_FACET_PATTERN, XML_SCHEMA_FACET_ENUMERATION. 
+        * are: XML_SCHEMA_FACET_PATTERN, XML_SCHEMA_FACET_ENUMERATION.
         */
-        return(xmlSchemaValidateFacet(NULL, facet, value, NULL));   
+        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" 
+ * 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)  
+                                     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);
     }
@@ skipping 13 matching lines @@
                     * 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_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:
-                /*
+            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" 
+ * 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, 
+xmlSchemaValidateLengthFacet(xmlSchemaTypePtr type,
                              xmlSchemaFacetPtr facet,
                              const xmlChar *value,
                              xmlSchemaValPtr val,
-                             unsigned long *length)  
+                             unsigned long *length)
 {
     if (type == NULL)
         return(-1);
     return (xmlSchemaValidateLengthFacetInternal(facet,
         type->builtInType, value, val, length,
         XML_SCHEMA_WHITESPACE_UNKNOWN));
 }
 
 /**
- * xmlSchemaValidateLengthFacetWhtsp: 
+ * 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" 
+ * 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,
@@ skipping 14 matching lines @@
  * @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,                               
+                               xmlSchemaValType valType,
                                const xmlChar *value,
                                xmlSchemaValPtr val,
                                xmlSchemaWhitespaceValueType ws)
 {
     int ret;
 
     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);
             ret = xmlRegexpExec(facet->regexp, value);
             if (ret == 1)
                 return(0);
             if (ret == 0)
                 return(XML_SCHEMAV_CVC_PATTERN_VALID);
@@ skipping 80 matching lines @@
                 (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:                        
+                    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_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;             
+                            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);
@@ skipping 89 matching lines @@
  * 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,                       
+                            xmlSchemaValType valType,
                             const xmlChar *value,
                             xmlSchemaValPtr val,
                             xmlSchemaWhitespaceValueType ws)
 {
      return(xmlSchemaValidateFacetInternal(facet, fws, valType,
          value, val, ws));
 }
 
 #if 0
 #ifndef DBL_DIG
@@ skipping 40 matching lines @@
             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 
+             * 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');           
+            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 a the cononical lexical representation of the 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 = 
+                *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_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 = 
+            *retValue =
                 BAD_CAST xmlSchemaCollapseString(BAD_CAST val->value.str);
             if (*retValue == NULL)
-                *retValue = 
+                *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) && 
+            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)
@@ skipping 13 matching lines @@
                 }
                 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.
@@ skipping 116 matching lines @@
             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;        
+            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), 
+                        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;              
+            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.                   
+                    /*
+                    * 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)
@@ skipping 23 matching lines @@
         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];           
-                /* 
+                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;      
+            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 a the cononical representation 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)
 {
@@ skipping 22 matching lines @@
                 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 */