xmlschemastypes.c

   1 /*
   2  * schemastypes.c : implementation of the XML Schema Datatypes
   3  *             definition and validity checking
   4  *
   5  * See Copyright for the status of this software.
   6  *
   7  * Daniel Veillard <veillard@redhat.com>
   8  */
   9
  10 #define IN_LIBXML
  11 #include "libxml.h"
  12
  13 #ifdef LIBXML_SCHEMAS_ENABLED
  14
  15 #include <string.h>
  16 #include <libxml/xmlmemory.h>
  17 #include <libxml/parser.h>
  18 #include <libxml/parserInternals.h>
  19 #include <libxml/hash.h>
  20 #include <libxml/valid.h>
  21 #include <libxml/xpath.h>
  22 #include <libxml/uri.h>
  23
  24 #include <libxml/xmlschemas.h>
  25 #include <libxml/schemasInternals.h>
  26 #include <libxml/xmlschemastypes.h>
  27
  28 #ifdef HAVE_MATH_H
  29 #include <math.h>
  30 #endif
  31 #ifdef HAVE_FLOAT_H
  32 #include <float.h>
  33 #endif
  34
  35 #define DEBUG
  36
  37 #ifndef LIBXML_XPATH_ENABLED
  38 extern double xmlXPathNAN;
  39 extern double xmlXPathPINF;
  40 extern double xmlXPathNINF;
  41 #endif
  42
  43 #define TODO                                                            \
  44     xmlGenericError(xmlGenericErrorContext,                             \
  45             "Unimplemented block at %s:%d\n",                           \
  46             __FILE__, __LINE__);
  47
  48 #define XML_SCHEMAS_NAMESPACE_NAME \
  49     (const xmlChar *)"http://www.w3.org/2001/XMLSchema"
  50
  51 #define IS_WSP_REPLACE_CH(c)    ((((c) == 0x9) || ((c) == 0xa)) || \
  52                                  ((c) == 0xd))
  53
  54 #define IS_WSP_SPACE_CH(c)      ((c) == 0x20)
  55
  56 #define IS_WSP_BLANK_CH(c) IS_BLANK_CH(c)
  57
  58 /* Date value */
  59 typedef struct _xmlSchemaValDate xmlSchemaValDate;
  60 typedef xmlSchemaValDate *xmlSchemaValDatePtr;
  61 struct _xmlSchemaValDate {
  62     long                year;
  63     unsigned int        mon     :4;     /* 1 <=  mon    <= 12   */
  64     unsigned int        day     :5;     /* 1 <=  day    <= 31   */
  65     unsigned int        hour    :5;     /* 0 <=  hour   <= 23   */
  66     unsigned int        min     :6;     /* 0 <=  min    <= 59   */
  67     double              sec;
  68     unsigned int        tz_flag :1;     /* is tzo explicitely set? */
  69     signed int          tzo     :12;    /* -1440 <= tzo <= 1440;
  70                                            currently only -840 to +840 are needed */
  71 };
  72
  73 /* Duration value */
  74 typedef struct _xmlSchemaValDuration xmlSchemaValDuration;
  75 typedef xmlSchemaValDuration *xmlSchemaValDurationPtr;
  76 struct _xmlSchemaValDuration {
  77     long                mon;            /* mon stores years also */
  78     long                day;
  79     double              sec;            /* sec stores min and hour also */
  80 };
  81
  82 typedef struct _xmlSchemaValDecimal xmlSchemaValDecimal;
  83 typedef xmlSchemaValDecimal *xmlSchemaValDecimalPtr;
  84 struct _xmlSchemaValDecimal {
  85     /* would use long long but not portable */
  86     unsigned long lo;
  87     unsigned long mi;
  88     unsigned long hi;
  89     unsigned int extra;
  90     unsigned int sign:1;
  91     unsigned int frac:7;
  92     unsigned int total:8;
  93 };
  94
  95 typedef struct _xmlSchemaValQName xmlSchemaValQName;
  96 typedef xmlSchemaValQName *xmlSchemaValQNamePtr;
  97 struct _xmlSchemaValQName {
  98     xmlChar *name;
  99     xmlChar *uri;
 100 };
 101
 102 typedef struct _xmlSchemaValHex xmlSchemaValHex;
 103 typedef xmlSchemaValHex *xmlSchemaValHexPtr;
 104 struct _xmlSchemaValHex {
 105     xmlChar     *str;
 106     unsigned int total;
 107 };
 108
 109 typedef struct _xmlSchemaValBase64 xmlSchemaValBase64;
 110 typedef xmlSchemaValBase64 *xmlSchemaValBase64Ptr;
 111 struct _xmlSchemaValBase64 {
 112     xmlChar     *str;
 113     unsigned int total;
 114 };
 115
 116 struct _xmlSchemaVal {
 117     xmlSchemaValType type;
 118     struct _xmlSchemaVal *next;
 119     union {
 120         xmlSchemaValDecimal     decimal;
 121         xmlSchemaValDate        date;
 122         xmlSchemaValDuration    dur;
 123         xmlSchemaValQName       qname;
 124         xmlSchemaValHex         hex;
 125         xmlSchemaValBase64      base64;
 126         float                   f;
 127         double                  d;
 128         int                     b;
 129         xmlChar                *str;
 130     } value;
 131 };
 132
 133 static int xmlSchemaTypesInitialized = 0;
 134 static xmlHashTablePtr xmlSchemaTypesBank = NULL;
 135
 136 /*
 137  * Basic types
 138  */
 139 static xmlSchemaTypePtr xmlSchemaTypeStringDef = NULL;
 140 static xmlSchemaTypePtr xmlSchemaTypeAnyTypeDef = NULL;
 141 static xmlSchemaTypePtr xmlSchemaTypeAnySimpleTypeDef = NULL;
 142 static xmlSchemaTypePtr xmlSchemaTypeDecimalDef = NULL;
 143 static xmlSchemaTypePtr xmlSchemaTypeDatetimeDef = NULL;
 144 static xmlSchemaTypePtr xmlSchemaTypeDateDef = NULL;
 145 static xmlSchemaTypePtr xmlSchemaTypeTimeDef = NULL;
 146 static xmlSchemaTypePtr xmlSchemaTypeGYearDef = NULL;
 147 static xmlSchemaTypePtr xmlSchemaTypeGYearMonthDef = NULL;
 148 static xmlSchemaTypePtr xmlSchemaTypeGDayDef = NULL;
 149 static xmlSchemaTypePtr xmlSchemaTypeGMonthDayDef = NULL;
 150 static xmlSchemaTypePtr xmlSchemaTypeGMonthDef = NULL;
 151 static xmlSchemaTypePtr xmlSchemaTypeDurationDef = NULL;
 152 static xmlSchemaTypePtr xmlSchemaTypeFloatDef = NULL;
 153 static xmlSchemaTypePtr xmlSchemaTypeBooleanDef = NULL;
 154 static xmlSchemaTypePtr xmlSchemaTypeDoubleDef = NULL;
 155 static xmlSchemaTypePtr xmlSchemaTypeHexBinaryDef = NULL;
 156 static xmlSchemaTypePtr xmlSchemaTypeBase64BinaryDef = NULL;
 157 static xmlSchemaTypePtr xmlSchemaTypeAnyURIDef = NULL;
 158
 159 /*
 160  * Derived types
 161  */
 162 static xmlSchemaTypePtr xmlSchemaTypePositiveIntegerDef = NULL;
 163 static xmlSchemaTypePtr xmlSchemaTypeNonPositiveIntegerDef = NULL;
 164 static xmlSchemaTypePtr xmlSchemaTypeNegativeIntegerDef = NULL;
 165 static xmlSchemaTypePtr xmlSchemaTypeNonNegativeIntegerDef = NULL;
 166 static xmlSchemaTypePtr xmlSchemaTypeIntegerDef = NULL;
 167 static xmlSchemaTypePtr xmlSchemaTypeLongDef = NULL;
 168 static xmlSchemaTypePtr xmlSchemaTypeIntDef = NULL;
 169 static xmlSchemaTypePtr xmlSchemaTypeShortDef = NULL;
 170 static xmlSchemaTypePtr xmlSchemaTypeByteDef = NULL;
 171 static xmlSchemaTypePtr xmlSchemaTypeUnsignedLongDef = NULL;
 172 static xmlSchemaTypePtr xmlSchemaTypeUnsignedIntDef = NULL;
 173 static xmlSchemaTypePtr xmlSchemaTypeUnsignedShortDef = NULL;
 174 static xmlSchemaTypePtr xmlSchemaTypeUnsignedByteDef = NULL;
 175 static xmlSchemaTypePtr xmlSchemaTypeNormStringDef = NULL;
 176 static xmlSchemaTypePtr xmlSchemaTypeTokenDef = NULL;
 177 static xmlSchemaTypePtr xmlSchemaTypeLanguageDef = NULL;
 178 static xmlSchemaTypePtr xmlSchemaTypeNameDef = NULL;
 179 static xmlSchemaTypePtr xmlSchemaTypeQNameDef = NULL;
 180 static xmlSchemaTypePtr xmlSchemaTypeNCNameDef = NULL;
 181 static xmlSchemaTypePtr xmlSchemaTypeIdDef = NULL;
 182 static xmlSchemaTypePtr xmlSchemaTypeIdrefDef = NULL;
 183 static xmlSchemaTypePtr xmlSchemaTypeIdrefsDef = NULL;
 184 static xmlSchemaTypePtr xmlSchemaTypeEntityDef = NULL;
 185 static xmlSchemaTypePtr xmlSchemaTypeEntitiesDef = NULL;
 186 static xmlSchemaTypePtr xmlSchemaTypeNotationDef = NULL;
 187 static xmlSchemaTypePtr xmlSchemaTypeNmtokenDef = NULL;
 188 static xmlSchemaTypePtr xmlSchemaTypeNmtokensDef = NULL;
 189
 190 /************************************************************************
 191  *                                                                      *
 192  *                      Datatype error handlers                         *
 193  *                                                                      *
 194  ************************************************************************/
 195 /**
 196  * xmlSchemaTypeErrMemory:
 197  * @extra:  extra informations
 198  *
 199  * Handle an out of memory condition
 200  */
 201 static void
 202 xmlSchemaTypeErrMemory(xmlNodePtr node, const char *extra)
 203 {
 204     __xmlSimpleError(XML_FROM_DATATYPE, XML_ERR_NO_MEMORY, node, NULL, extra);
 205 }
 206
 207 /************************************************************************
 208  *                                                                      *
 209  *                      Base types support                              *
 210  *                                                                      *
 211  ************************************************************************/
 212
 213 /**
 214  * xmlSchemaNewValue:
 215  * @type:  the value type
 216  *
 217  * Allocate a new simple type value
 218  *
 219  * Returns a pointer to the new value or NULL in case of error
 220  */
 221 static xmlSchemaValPtr
 222 xmlSchemaNewValue(xmlSchemaValType type) {
 223     xmlSchemaValPtr value;
 224
 225     value = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
 226     if (value == NULL) {
 227         return(NULL);
 228     }
 229     memset(value, 0, sizeof(xmlSchemaVal));
 230     value->type = type;
 231     return(value);
 232 }
 233
 234 static xmlSchemaFacetPtr
 235 xmlSchemaNewMinLengthFacet(int value)
 236 {
 237     xmlSchemaFacetPtr ret;
 238
 239     ret = xmlSchemaNewFacet();
 240     if (ret == NULL) {
 241         return(NULL);
 242     }
 243     ret->type = XML_SCHEMA_FACET_MINLENGTH;
 244     ret->val = xmlSchemaNewValue(XML_SCHEMAS_NNINTEGER);
 245     ret->val->value.decimal.lo = value;
 246     return (ret);
 247 }
 248
 249 /*
 250  * xmlSchemaInitBasicType:
 251  * @name:  the type name
 252  * @type:  the value type associated
 253  *
 254  * Initialize one primitive built-in type
 255  */
 256 static xmlSchemaTypePtr
 257 xmlSchemaInitBasicType(const char *name, xmlSchemaValType type,
 258                        xmlSchemaTypePtr baseType) {
 259     xmlSchemaTypePtr ret;
 260
 261     ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
 262     if (ret == NULL) {
 263         xmlSchemaTypeErrMemory(NULL, "could not initialize basic types");
 264         return(NULL);
 265     }
 266     memset(ret, 0, sizeof(xmlSchemaType));
 267     ret->name = (const xmlChar *)name;
 268     ret->targetNamespace = XML_SCHEMAS_NAMESPACE_NAME;
 269     ret->type = XML_SCHEMA_TYPE_BASIC;
 270     ret->baseType = baseType;
 271     ret->contentType = XML_SCHEMA_CONTENT_BASIC;
 272     /*
 273     * Primitive types.
 274     */
 275     switch (type) {
 276         case XML_SCHEMAS_STRING:
 277         case XML_SCHEMAS_DECIMAL:
 278         case XML_SCHEMAS_DATE:
 279         case XML_SCHEMAS_DATETIME:
 280         case XML_SCHEMAS_TIME:
 281         case XML_SCHEMAS_GYEAR:
 282         case XML_SCHEMAS_GYEARMONTH:
 283         case XML_SCHEMAS_GMONTH:
 284         case XML_SCHEMAS_GMONTHDAY:
 285         case XML_SCHEMAS_GDAY:
 286         case XML_SCHEMAS_DURATION:
 287         case XML_SCHEMAS_FLOAT:
 288         case XML_SCHEMAS_DOUBLE:
 289         case XML_SCHEMAS_BOOLEAN:
 290         case XML_SCHEMAS_ANYURI:
 291         case XML_SCHEMAS_HEXBINARY:
 292         case XML_SCHEMAS_BASE64BINARY:
 293         case XML_SCHEMAS_QNAME:
 294         case XML_SCHEMAS_NOTATION:
 295             ret->flags |= XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE;
 296             break;
 297         default:
 298             break;
 299     }
 300     /*
 301     * Set variety.
 302     */
 303     switch (type) {
 304         case XML_SCHEMAS_ANYTYPE:
 305         case XML_SCHEMAS_ANYSIMPLETYPE:
 306             break;
 307         case XML_SCHEMAS_IDREFS:
 308         case XML_SCHEMAS_NMTOKENS:
 309         case XML_SCHEMAS_ENTITIES:
 310             ret->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
 311             ret->facets = xmlSchemaNewMinLengthFacet(1);
 312             ret->flags |= XML_SCHEMAS_TYPE_HAS_FACETS;
 313             break;
 314         default:
 315             ret->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
 316             break;
 317     }
 318     xmlHashAddEntry2(xmlSchemaTypesBank, ret->name,
 319                      XML_SCHEMAS_NAMESPACE_NAME, ret);
 320     ret->builtInType = type;
 321     return(ret);
 322 }
 323
 324 /*
 325 * WARNING: Those type reside normally in xmlschemas.c but are
 326 * redefined here locally in oder of being able to use them for xs:anyType-
 327 * TODO: Remove those definition if we move the types to a header file.
 328 * TODO: Always keep those structs up-to-date with the originals.
 329 */
 330 #define UNBOUNDED (1 << 30)
 331
 332 typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
 333 typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
 334 struct _xmlSchemaTreeItem {
 335     xmlSchemaTypeType type;
 336     xmlSchemaAnnotPtr annot;
 337     xmlSchemaTreeItemPtr next;
 338     xmlSchemaTreeItemPtr children;
 339 };
 340
 341 typedef struct _xmlSchemaParticle xmlSchemaParticle;
 342 typedef xmlSchemaParticle *xmlSchemaParticlePtr;
 343 struct _xmlSchemaParticle {
 344     xmlSchemaTypeType type;
 345     xmlSchemaAnnotPtr annot;
 346     xmlSchemaTreeItemPtr next;
 347     xmlSchemaTreeItemPtr children;
 348     int minOccurs;
 349     int maxOccurs;
 350     xmlNodePtr node;
 351 };
 352
 353 typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
 354 typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
 355 struct _xmlSchemaModelGroup {
 356     xmlSchemaTypeType type;
 357     xmlSchemaAnnotPtr annot;
 358     xmlSchemaTreeItemPtr next;
 359     xmlSchemaTreeItemPtr children;
 360     xmlNodePtr node;
 361 };
 362
 363 static xmlSchemaParticlePtr
 364 xmlSchemaAddParticle(void)
 365 {
 366     xmlSchemaParticlePtr ret = NULL;
 367
 368     ret = (xmlSchemaParticlePtr)
 369         xmlMalloc(sizeof(xmlSchemaParticle));
 370     if (ret == NULL) {
 371         xmlSchemaTypeErrMemory(NULL, "allocating particle component");
 372         return (NULL);
 373     }
 374     memset(ret, 0, sizeof(xmlSchemaParticle));
 375     ret->type = XML_SCHEMA_TYPE_PARTICLE;
 376     ret->minOccurs = 1;
 377     ret->maxOccurs = 1;
 378     return (ret);
 379 }
 380
 381 /*
 382  * xmlSchemaInitTypes:
 383  *
 384  * Initialize the default XML Schemas type library
 385  */
 386 void
 387 xmlSchemaInitTypes(void)
 388 {
 389     if (xmlSchemaTypesInitialized != 0)
 390         return;
 391     xmlSchemaTypesBank = xmlHashCreate(40);
 392
 393
 394     /*
 395     * 3.4.7 Built-in Complex Type Definition
 396     */
 397     xmlSchemaTypeAnyTypeDef = xmlSchemaInitBasicType("anyType",
 398                                                      XML_SCHEMAS_ANYTYPE,
 399                                                      NULL);
 400     xmlSchemaTypeAnyTypeDef->baseType = xmlSchemaTypeAnyTypeDef;
 401     xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
 402     /*
 403     * Init the content type.
 404     */
 405     xmlSchemaTypeAnyTypeDef->contentType = XML_SCHEMA_CONTENT_MIXED;
 406     {
 407         xmlSchemaParticlePtr particle;
 408         xmlSchemaModelGroupPtr sequence;
 409         xmlSchemaWildcardPtr wild;
 410         /* First particle. */
 411         particle = xmlSchemaAddParticle();
 412         if (particle == NULL)
 413             return;
 414         xmlSchemaTypeAnyTypeDef->subtypes = (xmlSchemaTypePtr) particle;
 415         /* Sequence model group. */
 416         sequence = (xmlSchemaModelGroupPtr)
 417             xmlMalloc(sizeof(xmlSchemaModelGroup));
 418         if (sequence == NULL) {
 419             xmlSchemaTypeErrMemory(NULL, "allocating model group component");
 420             return;
 421         }
 422         memset(sequence, 0, sizeof(xmlSchemaModelGroup));
 423         sequence->type = XML_SCHEMA_TYPE_SEQUENCE;
 424         particle->children = (xmlSchemaTreeItemPtr) sequence;
 425         /* Second particle. */
 426         particle = xmlSchemaAddParticle();
 427         if (particle == NULL)
 428             return;
 429         particle->minOccurs = 0;
 430         particle->maxOccurs = UNBOUNDED;
 431         sequence->children = (xmlSchemaTreeItemPtr) particle;
 432         /* The wildcard */
 433         wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
 434         if (wild == NULL) {
 435             xmlSchemaTypeErrMemory(NULL, "allocating wildcard component");
 436             return;
 437         }
 438         memset(wild, 0, sizeof(xmlSchemaWildcard));
 439         wild->type = XML_SCHEMA_TYPE_ANY;
 440         wild->any = 1;
 441         wild->processContents = XML_SCHEMAS_ANY_LAX;
 442         particle->children = (xmlSchemaTreeItemPtr) wild;
 443         /*
 444         * Create the attribute wildcard.
 445         */
 446         wild = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
 447         if (wild == NULL) {
 448             xmlSchemaTypeErrMemory(NULL, "could not create an attribute "
 449                 "wildcard on anyType");
 450             return;
 451         }
 452         memset(wild, 0, sizeof(xmlSchemaWildcard));
 453         wild->any = 1;
 454         wild->processContents = XML_SCHEMAS_ANY_LAX;
 455         xmlSchemaTypeAnyTypeDef->attributeWildcard = wild;
 456     }
 457     xmlSchemaTypeAnySimpleTypeDef = xmlSchemaInitBasicType("anySimpleType",
 458                                                            XML_SCHEMAS_ANYSIMPLETYPE,
 459                                                            xmlSchemaTypeAnyTypeDef);
 460     /*
 461     * primitive datatypes
 462     */
 463     xmlSchemaTypeStringDef = xmlSchemaInitBasicType("string",
 464                                                     XML_SCHEMAS_STRING,
 465                                                     xmlSchemaTypeAnySimpleTypeDef);
 466     xmlSchemaTypeDecimalDef = xmlSchemaInitBasicType("decimal",
 467                                                      XML_SCHEMAS_DECIMAL,
 468                                                      xmlSchemaTypeAnySimpleTypeDef);
 469     xmlSchemaTypeDateDef = xmlSchemaInitBasicType("date",
 470                                                   XML_SCHEMAS_DATE,
 471                                                   xmlSchemaTypeAnySimpleTypeDef);
 472     xmlSchemaTypeDatetimeDef = xmlSchemaInitBasicType("dateTime",
 473                                                       XML_SCHEMAS_DATETIME,
 474                                                       xmlSchemaTypeAnySimpleTypeDef);
 475     xmlSchemaTypeTimeDef = xmlSchemaInitBasicType("time",
 476                                                   XML_SCHEMAS_TIME,
 477                                                   xmlSchemaTypeAnySimpleTypeDef);
 478     xmlSchemaTypeGYearDef = xmlSchemaInitBasicType("gYear",
 479                                                    XML_SCHEMAS_GYEAR,
 480                                                    xmlSchemaTypeAnySimpleTypeDef);
 481     xmlSchemaTypeGYearMonthDef = xmlSchemaInitBasicType("gYearMonth",
 482                                                         XML_SCHEMAS_GYEARMONTH,
 483                                                         xmlSchemaTypeAnySimpleTypeDef);
 484     xmlSchemaTypeGMonthDef = xmlSchemaInitBasicType("gMonth",
 485                                                     XML_SCHEMAS_GMONTH,
 486                                                     xmlSchemaTypeAnySimpleTypeDef);
 487     xmlSchemaTypeGMonthDayDef = xmlSchemaInitBasicType("gMonthDay",
 488                                                        XML_SCHEMAS_GMONTHDAY,
 489                                                        xmlSchemaTypeAnySimpleTypeDef);
 490     xmlSchemaTypeGDayDef = xmlSchemaInitBasicType("gDay",
 491                                                   XML_SCHEMAS_GDAY,
 492                                                   xmlSchemaTypeAnySimpleTypeDef);
 493     xmlSchemaTypeDurationDef = xmlSchemaInitBasicType("duration",
 494                                                       XML_SCHEMAS_DURATION,
 495                                                       xmlSchemaTypeAnySimpleTypeDef);
 496     xmlSchemaTypeFloatDef = xmlSchemaInitBasicType("float",
 497                                                    XML_SCHEMAS_FLOAT,
 498                                                    xmlSchemaTypeAnySimpleTypeDef);
 499     xmlSchemaTypeDoubleDef = xmlSchemaInitBasicType("double",
 500                                                     XML_SCHEMAS_DOUBLE,
 501                                                     xmlSchemaTypeAnySimpleTypeDef);
 502     xmlSchemaTypeBooleanDef = xmlSchemaInitBasicType("boolean",
 503                                                      XML_SCHEMAS_BOOLEAN,
 504                                                      xmlSchemaTypeAnySimpleTypeDef);
 505     xmlSchemaTypeAnyURIDef = xmlSchemaInitBasicType("anyURI",
 506                                                     XML_SCHEMAS_ANYURI,
 507                                                     xmlSchemaTypeAnySimpleTypeDef);
 508     xmlSchemaTypeHexBinaryDef = xmlSchemaInitBasicType("hexBinary",
 509                                                      XML_SCHEMAS_HEXBINARY,
 510                                                      xmlSchemaTypeAnySimpleTypeDef);
 511     xmlSchemaTypeBase64BinaryDef
 512         = xmlSchemaInitBasicType("base64Binary", XML_SCHEMAS_BASE64BINARY,
 513         xmlSchemaTypeAnySimpleTypeDef);
 514     xmlSchemaTypeNotationDef = xmlSchemaInitBasicType("NOTATION",
 515                                                     XML_SCHEMAS_NOTATION,
 516                                                     xmlSchemaTypeAnySimpleTypeDef);
 517     xmlSchemaTypeQNameDef = xmlSchemaInitBasicType("QName",
 518                                                    XML_SCHEMAS_QNAME,
 519                                                    xmlSchemaTypeAnySimpleTypeDef);
 520
 521     /*
 522      * derived datatypes
 523      */
 524     xmlSchemaTypeIntegerDef = xmlSchemaInitBasicType("integer",
 525                                                      XML_SCHEMAS_INTEGER,
 526                                                      xmlSchemaTypeDecimalDef);
 527     xmlSchemaTypeNonPositiveIntegerDef =
 528         xmlSchemaInitBasicType("nonPositiveInteger",
 529                                XML_SCHEMAS_NPINTEGER,
 530                                xmlSchemaTypeIntegerDef);
 531     xmlSchemaTypeNegativeIntegerDef =
 532         xmlSchemaInitBasicType("negativeInteger", XML_SCHEMAS_NINTEGER,
 533         xmlSchemaTypeNonPositiveIntegerDef);
 534     xmlSchemaTypeLongDef =
 535         xmlSchemaInitBasicType("long", XML_SCHEMAS_LONG,
 536         xmlSchemaTypeIntegerDef);
 537     xmlSchemaTypeIntDef = xmlSchemaInitBasicType("int", XML_SCHEMAS_INT,
 538         xmlSchemaTypeLongDef);
 539     xmlSchemaTypeShortDef = xmlSchemaInitBasicType("short",
 540                                                    XML_SCHEMAS_SHORT,
 541                                                    xmlSchemaTypeIntDef);
 542     xmlSchemaTypeByteDef = xmlSchemaInitBasicType("byte",
 543                                                   XML_SCHEMAS_BYTE,
 544                                                   xmlSchemaTypeShortDef);
 545     xmlSchemaTypeNonNegativeIntegerDef =
 546         xmlSchemaInitBasicType("nonNegativeInteger",
 547                                XML_SCHEMAS_NNINTEGER,
 548                                xmlSchemaTypeIntegerDef);
 549     xmlSchemaTypeUnsignedLongDef =
 550         xmlSchemaInitBasicType("unsignedLong", XML_SCHEMAS_ULONG,
 551         xmlSchemaTypeNonNegativeIntegerDef);
 552     xmlSchemaTypeUnsignedIntDef =
 553         xmlSchemaInitBasicType("unsignedInt", XML_SCHEMAS_UINT,
 554         xmlSchemaTypeUnsignedLongDef);
 555     xmlSchemaTypeUnsignedShortDef =
 556         xmlSchemaInitBasicType("unsignedShort", XML_SCHEMAS_USHORT,
 557         xmlSchemaTypeUnsignedIntDef);
 558     xmlSchemaTypeUnsignedByteDef =
 559         xmlSchemaInitBasicType("unsignedByte", XML_SCHEMAS_UBYTE,
 560         xmlSchemaTypeUnsignedShortDef);
 561     xmlSchemaTypePositiveIntegerDef =
 562         xmlSchemaInitBasicType("positiveInteger", XML_SCHEMAS_PINTEGER,
 563         xmlSchemaTypeNonNegativeIntegerDef);
 564     xmlSchemaTypeNormStringDef = xmlSchemaInitBasicType("normalizedString",
 565                                                         XML_SCHEMAS_NORMSTRING,
 566                                                         xmlSchemaTypeStringDef);
 567     xmlSchemaTypeTokenDef = xmlSchemaInitBasicType("token",
 568                                                    XML_SCHEMAS_TOKEN,
 569                                                    xmlSchemaTypeNormStringDef);
 570     xmlSchemaTypeLanguageDef = xmlSchemaInitBasicType("language",
 571                                                       XML_SCHEMAS_LANGUAGE,
 572                                                       xmlSchemaTypeTokenDef);
 573     xmlSchemaTypeNameDef = xmlSchemaInitBasicType("Name",
 574                                                   XML_SCHEMAS_NAME,
 575                                                   xmlSchemaTypeTokenDef);
 576     xmlSchemaTypeNmtokenDef = xmlSchemaInitBasicType("NMTOKEN",
 577                                                      XML_SCHEMAS_NMTOKEN,
 578                                                      xmlSchemaTypeTokenDef);
 579     xmlSchemaTypeNCNameDef = xmlSchemaInitBasicType("NCName",
 580                                                     XML_SCHEMAS_NCNAME,
 581                                                     xmlSchemaTypeNameDef);
 582     xmlSchemaTypeIdDef = xmlSchemaInitBasicType("ID", XML_SCHEMAS_ID,
 583                                                     xmlSchemaTypeNCNameDef);
 584     xmlSchemaTypeIdrefDef = xmlSchemaInitBasicType("IDREF",
 585                                                    XML_SCHEMAS_IDREF,
 586                                                    xmlSchemaTypeNCNameDef);
 587     xmlSchemaTypeEntityDef = xmlSchemaInitBasicType("ENTITY",
 588                                                     XML_SCHEMAS_ENTITY,
 589                                                     xmlSchemaTypeNCNameDef);
 590     /*
 591     * Derived list types.
 592     */
 593     /* ENTITIES */
 594     xmlSchemaTypeEntitiesDef = xmlSchemaInitBasicType("ENTITIES",
 595                                                       XML_SCHEMAS_ENTITIES,
 596                                                       xmlSchemaTypeAnySimpleTypeDef);
 597     xmlSchemaTypeEntitiesDef->subtypes = xmlSchemaTypeEntityDef;
 598     /* IDREFS */
 599     xmlSchemaTypeIdrefsDef = xmlSchemaInitBasicType("IDREFS",
 600                                                     XML_SCHEMAS_IDREFS,
 601                                                     xmlSchemaTypeAnySimpleTypeDef);
 602     xmlSchemaTypeIdrefsDef->subtypes = xmlSchemaTypeIdrefDef;
 603
 604     /* NMTOKENS */
 605     xmlSchemaTypeNmtokensDef = xmlSchemaInitBasicType("NMTOKENS",
 606                                                       XML_SCHEMAS_NMTOKENS,
 607                                                       xmlSchemaTypeAnySimpleTypeDef);
 608     xmlSchemaTypeNmtokensDef->subtypes = xmlSchemaTypeNmtokenDef;
 609
 610     xmlSchemaTypesInitialized = 1;
 611 }
 612
 613 /**
 614  * xmlSchemaCleanupTypes:
 615  *
 616  * Cleanup the default XML Schemas type library
 617  */
 618 void
 619 xmlSchemaCleanupTypes(void) {
 620     if (xmlSchemaTypesInitialized == 0)
 621         return;
 622     /*
 623     * Free xs:anyType.
 624     */
 625     {
 626         xmlSchemaParticlePtr particle;
 627         /* Attribute wildcard. */
 628         xmlSchemaFreeWildcard(xmlSchemaTypeAnyTypeDef->attributeWildcard);
 629         /* Content type. */
 630         particle = (xmlSchemaParticlePtr) xmlSchemaTypeAnyTypeDef->subtypes;
 631         /* Wildcard. */
 632         xmlSchemaFreeWildcard((xmlSchemaWildcardPtr)
 633             particle->children->children->children);
 634         xmlFree((xmlSchemaParticlePtr) particle->children->children);
 635         /* Sequence model group. */
 636         xmlFree((xmlSchemaModelGroupPtr) particle->children);
 637         xmlFree((xmlSchemaParticlePtr) particle);
 638         xmlSchemaTypeAnyTypeDef->subtypes = NULL;
 639     }
 640     xmlHashFree(xmlSchemaTypesBank, (xmlHashDeallocator) xmlSchemaFreeType);
 641     xmlSchemaTypesInitialized = 0;
 642 }
 643
 644 /**
 645  * xmlSchemaIsBuiltInTypeFacet:
 646  * @type: the built-in type
 647  * @facetType:  the facet type
 648  *
 649  * Evaluates if a specific facet can be
 650  * used in conjunction with a type.
 651  *
 652  * Returns 1 if the facet can be used with the given built-in type,
 653  * 0 otherwise and -1 in case the type is not a built-in type.
 654  */
 655 int
 656 xmlSchemaIsBuiltInTypeFacet(xmlSchemaTypePtr type, int facetType)
 657 {
 658     if (type == NULL)
 659         return (-1);
 660     if (type->type != XML_SCHEMA_TYPE_BASIC)
 661         return (-1);
 662     switch (type->builtInType) {
 663         case XML_SCHEMAS_BOOLEAN:
 664             if ((facetType == XML_SCHEMA_FACET_PATTERN) ||
 665                 (facetType == XML_SCHEMA_FACET_WHITESPACE))
 666                 return (1);
 667             else
 668                 return (0);
 669         case XML_SCHEMAS_STRING:
 670         case XML_SCHEMAS_NOTATION:
 671         case XML_SCHEMAS_QNAME:
 672         case XML_SCHEMAS_ANYURI:
 673         case XML_SCHEMAS_BASE64BINARY:
 674         case XML_SCHEMAS_HEXBINARY:
 675             if ((facetType == XML_SCHEMA_FACET_LENGTH) ||
 676                 (facetType == XML_SCHEMA_FACET_MINLENGTH) ||
 677                 (facetType == XML_SCHEMA_FACET_MAXLENGTH) ||
 678                 (facetType == XML_SCHEMA_FACET_PATTERN) ||
 679                 (facetType == XML_SCHEMA_FACET_ENUMERATION) ||
 680                 (facetType == XML_SCHEMA_FACET_WHITESPACE))
 681                 return (1);
 682             else
 683                 return (0);
 684         case XML_SCHEMAS_DECIMAL:
 685             if ((facetType == XML_SCHEMA_FACET_TOTALDIGITS) ||
 686                 (facetType == XML_SCHEMA_FACET_FRACTIONDIGITS) ||
 687                 (facetType == XML_SCHEMA_FACET_PATTERN) ||
 688                 (facetType == XML_SCHEMA_FACET_WHITESPACE) ||
 689                 (facetType == XML_SCHEMA_FACET_ENUMERATION) ||
 690                 (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) ||
 691                 (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) ||
 692                 (facetType == XML_SCHEMA_FACET_MININCLUSIVE) ||
 693                 (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE))
 694                 return (1);
 695             else
 696                 return (0);
 697         case XML_SCHEMAS_TIME:
 698         case XML_SCHEMAS_GDAY:
 699         case XML_SCHEMAS_GMONTH:
 700         case XML_SCHEMAS_GMONTHDAY:
 701         case XML_SCHEMAS_GYEAR:
 702         case XML_SCHEMAS_GYEARMONTH:
 703         case XML_SCHEMAS_DATE:
 704         case XML_SCHEMAS_DATETIME:
 705         case XML_SCHEMAS_DURATION:
 706         case XML_SCHEMAS_FLOAT:
 707         case XML_SCHEMAS_DOUBLE:
 708             if ((facetType == XML_SCHEMA_FACET_PATTERN) ||
 709                 (facetType == XML_SCHEMA_FACET_ENUMERATION) ||
 710                 (facetType == XML_SCHEMA_FACET_WHITESPACE) ||
 711                 (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) ||
 712                 (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) ||
 713                 (facetType == XML_SCHEMA_FACET_MININCLUSIVE) ||
 714                 (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE))
 715                 return (1);
 716             else
 717                 return (0);
 718         default:
 719             break;
 720     }
 721     return (0);
 722 }
 723
 724 /**
 725  * xmlSchemaGetBuiltInType:
 726  * @type:  the type of the built in type
 727  *
 728  * Gives you the type struct for a built-in
 729  * type by its type id.
 730  *
 731  * Returns the type if found, NULL otherwise.
 732  */
 733 xmlSchemaTypePtr
 734 xmlSchemaGetBuiltInType(xmlSchemaValType type)
 735 {
 736     if (xmlSchemaTypesInitialized == 0)
 737         xmlSchemaInitTypes();
 738     switch (type) {
 739
 740         case XML_SCHEMAS_ANYSIMPLETYPE:
 741             return (xmlSchemaTypeAnySimpleTypeDef);
 742         case XML_SCHEMAS_STRING:
 743             return (xmlSchemaTypeStringDef);
 744         case XML_SCHEMAS_NORMSTRING:
 745             return (xmlSchemaTypeNormStringDef);
 746         case XML_SCHEMAS_DECIMAL:
 747             return (xmlSchemaTypeDecimalDef);
 748         case XML_SCHEMAS_TIME:
 749             return (xmlSchemaTypeTimeDef);
 750         case XML_SCHEMAS_GDAY:
 751             return (xmlSchemaTypeGDayDef);
 752         case XML_SCHEMAS_GMONTH:
 753             return (xmlSchemaTypeGMonthDef);
 754         case XML_SCHEMAS_GMONTHDAY:
 755             return (xmlSchemaTypeGMonthDayDef);
 756         case XML_SCHEMAS_GYEAR:
 757             return (xmlSchemaTypeGYearDef);
 758         case XML_SCHEMAS_GYEARMONTH:
 759             return (xmlSchemaTypeGYearMonthDef);
 760         case XML_SCHEMAS_DATE:
 761             return (xmlSchemaTypeDateDef);
 762         case XML_SCHEMAS_DATETIME:
 763             return (xmlSchemaTypeDatetimeDef);
 764         case XML_SCHEMAS_DURATION:
 765             return (xmlSchemaTypeDurationDef);
 766         case XML_SCHEMAS_FLOAT:
 767             return (xmlSchemaTypeFloatDef);
 768         case XML_SCHEMAS_DOUBLE:
 769             return (xmlSchemaTypeDoubleDef);
 770         case XML_SCHEMAS_BOOLEAN:
 771             return (xmlSchemaTypeBooleanDef);
 772         case XML_SCHEMAS_TOKEN:
 773             return (xmlSchemaTypeTokenDef);
 774         case XML_SCHEMAS_LANGUAGE:
 775             return (xmlSchemaTypeLanguageDef);
 776         case XML_SCHEMAS_NMTOKEN:
 777             return (xmlSchemaTypeNmtokenDef);
 778         case XML_SCHEMAS_NMTOKENS:
 779             return (xmlSchemaTypeNmtokensDef);
 780         case XML_SCHEMAS_NAME:
 781             return (xmlSchemaTypeNameDef);
 782         case XML_SCHEMAS_QNAME:
 783             return (xmlSchemaTypeQNameDef);
 784         case XML_SCHEMAS_NCNAME:
 785             return (xmlSchemaTypeNCNameDef);
 786         case XML_SCHEMAS_ID:
 787             return (xmlSchemaTypeIdDef);
 788         case XML_SCHEMAS_IDREF:
 789             return (xmlSchemaTypeIdrefDef);
 790         case XML_SCHEMAS_IDREFS:
 791             return (xmlSchemaTypeIdrefsDef);
 792         case XML_SCHEMAS_ENTITY:
 793             return (xmlSchemaTypeEntityDef);
 794         case XML_SCHEMAS_ENTITIES:
 795             return (xmlSchemaTypeEntitiesDef);
 796         case XML_SCHEMAS_NOTATION:
 797             return (xmlSchemaTypeNotationDef);
 798         case XML_SCHEMAS_ANYURI:
 799             return (xmlSchemaTypeAnyURIDef);
 800         case XML_SCHEMAS_INTEGER:
 801             return (xmlSchemaTypeIntegerDef);
 802         case XML_SCHEMAS_NPINTEGER:
 803             return (xmlSchemaTypeNonPositiveIntegerDef);
 804         case XML_SCHEMAS_NINTEGER:
 805             return (xmlSchemaTypeNegativeIntegerDef);
 806         case XML_SCHEMAS_NNINTEGER:
 807             return (xmlSchemaTypeNonNegativeIntegerDef);
 808         case XML_SCHEMAS_PINTEGER:
 809             return (xmlSchemaTypePositiveIntegerDef);
 810         case XML_SCHEMAS_INT:
 811             return (xmlSchemaTypeIntDef);
 812         case XML_SCHEMAS_UINT:
 813             return (xmlSchemaTypeUnsignedIntDef);
 814         case XML_SCHEMAS_LONG:
 815             return (xmlSchemaTypeLongDef);
 816         case XML_SCHEMAS_ULONG:
 817             return (xmlSchemaTypeUnsignedLongDef);
 818         case XML_SCHEMAS_SHORT:
 819             return (xmlSchemaTypeShortDef);
 820         case XML_SCHEMAS_USHORT:
 821             return (xmlSchemaTypeUnsignedShortDef);
 822         case XML_SCHEMAS_BYTE:
 823             return (xmlSchemaTypeByteDef);
 824         case XML_SCHEMAS_UBYTE:
 825             return (xmlSchemaTypeUnsignedByteDef);
 826         case XML_SCHEMAS_HEXBINARY:
 827             return (xmlSchemaTypeHexBinaryDef);
 828         case XML_SCHEMAS_BASE64BINARY:
 829             return (xmlSchemaTypeBase64BinaryDef);
 830         case XML_SCHEMAS_ANYTYPE:
 831             return (xmlSchemaTypeAnyTypeDef);
 832         default:
 833             return (NULL);
 834     }
 835 }
 836
 837 /**
 838  * xmlSchemaValueAppend:
 839  * @prev: the value
 840  * @cur: the value to be appended
 841  *
 842  * Appends a next sibling to a list of computed values.
 843  *
 844  * Returns 0 if succeeded and -1 on API errors.
 845  */
 846 int
 847 xmlSchemaValueAppend(xmlSchemaValPtr prev, xmlSchemaValPtr cur) {
 848
 849     if ((prev == NULL) || (cur == NULL))
 850         return (-1);
 851     prev->next = cur;
 852     return (0);
 853 }
 854
 855 /**
 856  * xmlSchemaValueGetNext:
 857  * @cur: the value
 858  *
 859  * Accessor for the next sibling of a list of computed values.
 860  *
 861  * Returns the next value or NULL if there was none, or on
 862  *         API errors.
 863  */
 864 xmlSchemaValPtr
 865 xmlSchemaValueGetNext(xmlSchemaValPtr cur) {
 866
 867     if (cur == NULL)
 868         return (NULL);
 869     return (cur->next);
 870 }
 871
 872 /**
 873  * xmlSchemaValueGetAsString:
 874  * @val: the value
 875  *
 876  * Accessor for the string value of a computed value.
 877  *
 878  * Returns the string value or NULL if there was none, or on
 879  *         API errors.
 880  */
 881 const xmlChar *
 882 xmlSchemaValueGetAsString(xmlSchemaValPtr val)
 883 {
 884     if (val == NULL)
 885         return (NULL);
 886     switch (val->type) {
 887         case XML_SCHEMAS_STRING:
 888         case XML_SCHEMAS_NORMSTRING:
 889         case XML_SCHEMAS_ANYSIMPLETYPE:
 890         case XML_SCHEMAS_TOKEN:
 891         case XML_SCHEMAS_LANGUAGE:
 892         case XML_SCHEMAS_NMTOKEN:
 893         case XML_SCHEMAS_NAME:
 894         case XML_SCHEMAS_NCNAME:
 895         case XML_SCHEMAS_ID:
 896         case XML_SCHEMAS_IDREF:
 897         case XML_SCHEMAS_ENTITY:
 898         case XML_SCHEMAS_ANYURI:
 899             return (BAD_CAST val->value.str);
 900         default:
 901             break;
 902     }
 903     return (NULL);
 904 }
 905
 906 /**
 907  * xmlSchemaValueGetAsBoolean:
 908  * @val: the value
 909  *
 910  * Accessor for the boolean value of a computed value.
 911  *
 912  * Returns 1 if true and 0 if false, or in case of an error. Hmm.
 913  */
 914 int
 915 xmlSchemaValueGetAsBoolean(xmlSchemaValPtr val)
 916 {
 917     if ((val == NULL) || (val->type != XML_SCHEMAS_BOOLEAN))
 918         return (0);
 919     return (val->value.b);
 920 }
 921
 922 /**
 923  * xmlSchemaNewStringValue:
 924  * @type:  the value type
 925  * @value:  the value
 926  *
 927  * Allocate a new simple type value. The type can be
 928  * of XML_SCHEMAS_STRING.
 929  * WARNING: This one is intended to be expanded for other
 930  * string based types. We need this for anySimpleType as well.
 931  * The given value is consumed and freed with the struct.
 932  *
 933  * Returns a pointer to the new value or NULL in case of error
 934  */
 935 xmlSchemaValPtr
 936 xmlSchemaNewStringValue(xmlSchemaValType type,
 937                         const xmlChar *value)
 938 {
 939     xmlSchemaValPtr val;
 940
 941     if (type != XML_SCHEMAS_STRING)
 942         return(NULL);
 943     val = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
 944     if (val == NULL) {
 945         return(NULL);
 946     }
 947     memset(val, 0, sizeof(xmlSchemaVal));
 948     val->type = type;
 949     val->value.str = (xmlChar *) value;
 950     return(val);
 951 }
 952
 953 /**
 954  * xmlSchemaNewNOTATIONValue:
 955  * @name:  the notation name
 956  * @ns: the notation namespace name or NULL
 957  *
 958  * Allocate a new NOTATION value.
 959  * The given values are consumed and freed with the struct.
 960  *
 961  * Returns a pointer to the new value or NULL in case of error
 962  */
 963 xmlSchemaValPtr
 964 xmlSchemaNewNOTATIONValue(const xmlChar *name,
 965                           const xmlChar *ns)
 966 {
 967     xmlSchemaValPtr val;
 968
 969     val = xmlSchemaNewValue(XML_SCHEMAS_NOTATION);
 970     if (val == NULL)
 971         return (NULL);
 972
 973     val->value.qname.name = (xmlChar *)name;
 974     if (ns != NULL)
 975         val->value.qname.uri = (xmlChar *)ns;
 976     return(val);
 977 }
 978
 979 /**
 980  * xmlSchemaNewQNameValue:
 981  * @namespaceName: the namespace name
 982  * @localName: the local name
 983  *
 984  * Allocate a new QName value.
 985  * The given values are consumed and freed with the struct.
 986  *
 987  * Returns a pointer to the new value or NULL in case of an error.
 988  */
 989 xmlSchemaValPtr
 990 xmlSchemaNewQNameValue(const xmlChar *namespaceName,
 991                        const xmlChar *localName)
 992 {
 993     xmlSchemaValPtr val;
 994
 995     val = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
 996     if (val == NULL)
 997         return (NULL);
 998
 999     val->value.qname.name = (xmlChar *) localName;
1000     val->value.qname.uri = (xmlChar *) namespaceName;
1001     return(val);
1002 }
1003
1004 /**
1005  * xmlSchemaFreeValue:
1006  * @value:  the value to free
1007  *
1008  * Cleanup the default XML Schemas type library
1009  */
1010 void
1011 xmlSchemaFreeValue(xmlSchemaValPtr value) {
1012     xmlSchemaValPtr prev;
1013
1014     while (value != NULL) {
1015         switch (value->type) {
1016             case XML_SCHEMAS_STRING:
1017             case XML_SCHEMAS_NORMSTRING:
1018             case XML_SCHEMAS_TOKEN:
1019             case XML_SCHEMAS_LANGUAGE:
1020             case XML_SCHEMAS_NMTOKEN:
1021             case XML_SCHEMAS_NMTOKENS:
1022             case XML_SCHEMAS_NAME:
1023             case XML_SCHEMAS_NCNAME:
1024             case XML_SCHEMAS_ID:
1025             case XML_SCHEMAS_IDREF:
1026             case XML_SCHEMAS_IDREFS:
1027             case XML_SCHEMAS_ENTITY:
1028             case XML_SCHEMAS_ENTITIES:
1029             case XML_SCHEMAS_ANYURI:
1030             case XML_SCHEMAS_ANYSIMPLETYPE:
1031                 if (value->value.str != NULL)
1032                     xmlFree(value->value.str);
1033                 break;
1034             case XML_SCHEMAS_NOTATION:
1035             case XML_SCHEMAS_QNAME:
1036                 if (value->value.qname.uri != NULL)
1037                     xmlFree(value->value.qname.uri);
1038                 if (value->value.qname.name != NULL)
1039                     xmlFree(value->value.qname.name);
1040                 break;
1041             case XML_SCHEMAS_HEXBINARY:
1042                 if (value->value.hex.str != NULL)
1043                     xmlFree(value->value.hex.str);
1044                 break;
1045             case XML_SCHEMAS_BASE64BINARY:
1046                 if (value->value.base64.str != NULL)
1047                     xmlFree(value->value.base64.str);
1048                 break;
1049             default:
1050                 break;
1051         }
1052         prev = value;
1053         value = value->next;
1054         xmlFree(prev);
1055     }
1056 }
1057
1058 /**
1059  * xmlSchemaGetPredefinedType:
1060  * @name: the type name
1061  * @ns:  the URI of the namespace usually "http://www.w3.org/2001/XMLSchema"
1062  *
1063  * Lookup a type in the default XML Schemas type library
1064  *
1065  * Returns the type if found, NULL otherwise
1066  */
1067 xmlSchemaTypePtr
1068 xmlSchemaGetPredefinedType(const xmlChar *name, const xmlChar *ns) {
1069     if (xmlSchemaTypesInitialized == 0)
1070         xmlSchemaInitTypes();
1071     if (name == NULL)
1072         return(NULL);
1073     return((xmlSchemaTypePtr) xmlHashLookup2(xmlSchemaTypesBank, name, ns));
1074 }
1075
1076 /**
1077  * xmlSchemaGetBuiltInListSimpleTypeItemType:
1078  * @type: the built-in simple type.
1079  *
1080  * Lookup function
1081  *
1082  * Returns the item type of @type as defined by the built-in datatype
1083  * hierarchy of XML Schema Part 2: Datatypes, or NULL in case of an error.
1084  */
1085 xmlSchemaTypePtr
1086 xmlSchemaGetBuiltInListSimpleTypeItemType(xmlSchemaTypePtr type)
1087 {
1088     if ((type == NULL) || (type->type != XML_SCHEMA_TYPE_BASIC))
1089         return (NULL);
1090     switch (type->builtInType) {
1091         case XML_SCHEMAS_NMTOKENS:
1092             return (xmlSchemaTypeNmtokenDef );
1093         case XML_SCHEMAS_IDREFS:
1094             return (xmlSchemaTypeIdrefDef);
1095         case XML_SCHEMAS_ENTITIES:
1096             return (xmlSchemaTypeEntityDef);
1097         default:
1098             return (NULL);
1099     }
1100 }
1101
1102 /****************************************************************
1103  *                                                              *
1104  *              Convenience macros and functions                *
1105  *                                                              *
1106  ****************************************************************/
1107
1108 #define IS_TZO_CHAR(c)                                          \
1109         ((c == 0) || (c == 'Z') || (c == '+') || (c == '-'))
1110
1111 #define VALID_YEAR(yr)          (yr != 0)
1112 #define VALID_MONTH(mon)        ((mon >= 1) && (mon <= 12))
1113 /* VALID_DAY should only be used when month is unknown */
1114 #define VALID_DAY(day)          ((day >= 1) && (day <= 31))
1115 #define VALID_HOUR(hr)          ((hr >= 0) && (hr <= 23))
1116 #define VALID_MIN(min)          ((min >= 0) && (min <= 59))
1117 #define VALID_SEC(sec)          ((sec >= 0) && (sec < 60))
1118 #define VALID_TZO(tzo)          ((tzo > -840) && (tzo < 840))
1119 #define IS_LEAP(y)                                              \
1120         (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
1121
1122 static const unsigned int daysInMonth[12] =
1123         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
1124 static const unsigned int daysInMonthLeap[12] =
1125         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
1126
1127 #define MAX_DAYINMONTH(yr,mon)                                  \
1128         (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1])
1129
1130 #define VALID_MDAY(dt)                                          \
1131         (IS_LEAP(dt->year) ?                                    \
1132             (dt->day <= daysInMonthLeap[dt->mon - 1]) :         \
1133             (dt->day <= daysInMonth[dt->mon - 1]))
1134
1135 #define VALID_DATE(dt)                                          \
1136         (VALID_YEAR(dt->year) && VALID_MONTH(dt->mon) && VALID_MDAY(dt))
1137
1138 #define VALID_TIME(dt)                                          \
1139         (VALID_HOUR(dt->hour) && VALID_MIN(dt->min) &&          \
1140          VALID_SEC(dt->sec) && VALID_TZO(dt->tzo))
1141
1142 #define VALID_DATETIME(dt)                                      \
1143         (VALID_DATE(dt) && VALID_TIME(dt))
1144
1145 #define SECS_PER_MIN            (60)
1146 #define SECS_PER_HOUR           (60 * SECS_PER_MIN)
1147 #define SECS_PER_DAY            (24 * SECS_PER_HOUR)
1148
1149 static const long dayInYearByMonth[12] =
1150         { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
1151 static const long dayInLeapYearByMonth[12] =
1152         { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
1153
1154 #define DAY_IN_YEAR(day, month, year)                           \
1155         ((IS_LEAP(year) ?                                       \
1156                 dayInLeapYearByMonth[month - 1] :               \
1157                 dayInYearByMonth[month - 1]) + day)
1158
1159 #ifdef DEBUG
1160 #define DEBUG_DATE(dt)                                                  \
1161     xmlGenericError(xmlGenericErrorContext,                             \
1162         "type=%o %04ld-%02u-%02uT%02u:%02u:%03f",                       \
1163         dt->type,dt->value.date.year,dt->value.date.mon,                \
1164         dt->value.date.day,dt->value.date.hour,dt->value.date.min,      \
1165         dt->value.date.sec);                                            \
1166     if (dt->value.date.tz_flag)                                         \
1167         if (dt->value.date.tzo != 0)                                    \
1168             xmlGenericError(xmlGenericErrorContext,                     \
1169                 "%+05d\n",dt->value.date.tzo);                          \
1170         else                                                            \
1171             xmlGenericError(xmlGenericErrorContext, "Z\n");             \
1172     else                                                                \
1173         xmlGenericError(xmlGenericErrorContext,"\n")
1174 #else
1175 #define DEBUG_DATE(dt)
1176 #endif
1177
1178 /**
1179  * _xmlSchemaParseGYear:
1180  * @dt:  pointer to a date structure
1181  * @str: pointer to the string to analyze
1182  *
1183  * Parses a xs:gYear without time zone and fills in the appropriate
1184  * field of the @dt structure. @str is updated to point just after the
1185  * xs:gYear. It is supposed that @dt->year is big enough to contain
1186  * the year.
1187  *
1188  * Returns 0 or the error code
1189  */
1190 static int
1191 _xmlSchemaParseGYear (xmlSchemaValDatePtr dt, const xmlChar **str) {
1192     const xmlChar *cur = *str, *firstChar;
1193     int isneg = 0, digcnt = 0;
1194
1195     if (((*cur < '0') || (*cur > '9')) &&
1196         (*cur != '-') && (*cur != '+'))
1197         return -1;
1198
1199     if (*cur == '-') {
1200         isneg = 1;
1201         cur++;
1202     }
1203
1204     firstChar = cur;
1205
1206     while ((*cur >= '0') && (*cur <= '9')) {
1207         dt->year = dt->year * 10 + (*cur - '0');
1208         cur++;
1209         digcnt++;
1210     }
1211
1212     /* year must be at least 4 digits (CCYY); over 4
1213      * digits cannot have a leading zero. */
1214     if ((digcnt < 4) || ((digcnt > 4) && (*firstChar == '0')))
1215         return 1;
1216
1217     if (isneg)
1218         dt->year = - dt->year;
1219
1220     if (!VALID_YEAR(dt->year))
1221         return 2;
1222
1223     *str = cur;
1224     return 0;
1225 }
1226
1227 /**
1228  * PARSE_2_DIGITS:
1229  * @num:  the integer to fill in
1230  * @cur:  an #xmlChar *
1231  * @invalid: an integer
1232  *
1233  * Parses a 2-digits integer and updates @num with the value. @cur is
1234  * updated to point just after the integer.
1235  * In case of error, @invalid is set to %TRUE, values of @num and
1236  * @cur are undefined.
1237  */
1238 #define PARSE_2_DIGITS(num, cur, invalid)                       \
1239         if ((cur[0] < '0') || (cur[0] > '9') ||                 \
1240             (cur[1] < '0') || (cur[1] > '9'))                   \
1241             invalid = 1;                                        \
1242         else                                                    \
1243             num = (cur[0] - '0') * 10 + (cur[1] - '0');         \
1244         cur += 2;
1245
1246 /**
1247  * PARSE_FLOAT:
1248  * @num:  the double to fill in
1249  * @cur:  an #xmlChar *
1250  * @invalid: an integer
1251  *
1252  * Parses a float and updates @num with the value. @cur is
1253  * updated to point just after the float. The float must have a
1254  * 2-digits integer part and may or may not have a decimal part.
1255  * In case of error, @invalid is set to %TRUE, values of @num and
1256  * @cur are undefined.
1257  */
1258 #define PARSE_FLOAT(num, cur, invalid)                          \
1259         PARSE_2_DIGITS(num, cur, invalid);                      \
1260         if (!invalid && (*cur == '.')) {                        \
1261             double mult = 1;                                    \
1262             cur++;                                              \
1263             if ((*cur < '0') || (*cur > '9'))                   \
1264                 invalid = 1;                                    \
1265             while ((*cur >= '0') && (*cur <= '9')) {            \
1266                 mult /= 10;                                     \
1267                 num += (*cur - '0') * mult;                     \
1268                 cur++;                                          \
1269             }                                                   \
1270         }
1271
1272 /**
1273  * _xmlSchemaParseGMonth:
1274  * @dt:  pointer to a date structure
1275  * @str: pointer to the string to analyze
1276  *
1277  * Parses a xs:gMonth without time zone and fills in the appropriate
1278  * field of the @dt structure. @str is updated to point just after the
1279  * xs:gMonth.
1280  *
1281  * Returns 0 or the error code
1282  */
1283 static int
1284 _xmlSchemaParseGMonth (xmlSchemaValDatePtr dt, const xmlChar **str) {
1285     const xmlChar *cur = *str;
1286     int ret = 0;
1287     unsigned int value = 0;
1288
1289     PARSE_2_DIGITS(value, cur, ret);
1290     if (ret != 0)
1291         return ret;
1292
1293     if (!VALID_MONTH(value))
1294         return 2;
1295
1296     dt->mon = value;
1297
1298     *str = cur;
1299     return 0;
1300 }
1301
1302 /**
1303  * _xmlSchemaParseGDay:
1304  * @dt:  pointer to a date structure
1305  * @str: pointer to the string to analyze
1306  *
1307  * Parses a xs:gDay without time zone and fills in the appropriate
1308  * field of the @dt structure. @str is updated to point just after the
1309  * xs:gDay.
1310  *
1311  * Returns 0 or the error code
1312  */
1313 static int
1314 _xmlSchemaParseGDay (xmlSchemaValDatePtr dt, const xmlChar **str) {
1315     const xmlChar *cur = *str;
1316     int ret = 0;
1317     unsigned int value = 0;
1318
1319     PARSE_2_DIGITS(value, cur, ret);
1320     if (ret != 0)
1321         return ret;
1322
1323     if (!VALID_DAY(value))
1324         return 2;
1325
1326     dt->day = value;
1327     *str = cur;
1328     return 0;
1329 }
1330
1331 /**
1332  * _xmlSchemaParseTime:
1333  * @dt:  pointer to a date structure
1334  * @str: pointer to the string to analyze
1335  *
1336  * Parses a xs:time without time zone and fills in the appropriate
1337  * fields of the @dt structure. @str is updated to point just after the
1338  * xs:time.
1339  * In case of error, values of @dt fields are undefined.
1340  *
1341  * Returns 0 or the error code
1342  */
1343 static int
1344 _xmlSchemaParseTime (xmlSchemaValDatePtr dt, const xmlChar **str) {
1345     const xmlChar *cur = *str;
1346     int ret = 0;
1347     int value = 0;
1348
1349     PARSE_2_DIGITS(value, cur, ret);
1350     if (ret != 0)
1351         return ret;
1352     if (*cur != ':')
1353         return 1;
1354     if (!VALID_HOUR(value))
1355         return 2;
1356     cur++;
1357
1358     /* the ':' insures this string is xs:time */
1359     dt->hour = value;
1360
1361     PARSE_2_DIGITS(value, cur, ret);
1362     if (ret != 0)
1363         return ret;
1364     if (!VALID_MIN(value))
1365         return 2;
1366     dt->min = value;
1367
1368     if (*cur != ':')
1369         return 1;
1370     cur++;
1371
1372     PARSE_FLOAT(dt->sec, cur, ret);
1373     if (ret != 0)
1374         return ret;
1375
1376     if ((!VALID_SEC(dt->sec)) || (!VALID_TZO(dt->tzo)))
1377         return 2;
1378
1379     *str = cur;
1380     return 0;
1381 }
1382
1383 /**
1384  * _xmlSchemaParseTimeZone:
1385  * @dt:  pointer to a date structure
1386  * @str: pointer to the string to analyze
1387  *
1388  * Parses a time zone without time zone and fills in the appropriate
1389  * field of the @dt structure. @str is updated to point just after the
1390  * time zone.
1391  *
1392  * Returns 0 or the error code
1393  */
1394 static int
1395 _xmlSchemaParseTimeZone (xmlSchemaValDatePtr dt, const xmlChar **str) {
1396     const xmlChar *cur;
1397     int ret = 0;
1398
1399     if (str == NULL)
1400         return -1;
1401     cur = *str;
1402
1403     switch (*cur) {
1404     case 0:
1405         dt->tz_flag = 0;
1406         dt->tzo = 0;
1407         break;
1408
1409     case 'Z':
1410         dt->tz_flag = 1;
1411         dt->tzo = 0;
1412         cur++;
1413         break;
1414
1415     case '+':
1416     case '-': {
1417         int isneg = 0, tmp = 0;
1418         isneg = (*cur == '-');
1419
1420         cur++;
1421
1422         PARSE_2_DIGITS(tmp, cur, ret);
1423         if (ret != 0)
1424             return ret;
1425         if (!VALID_HOUR(tmp))
1426             return 2;
1427
1428         if (*cur != ':')
1429             return 1;
1430         cur++;
1431
1432         dt->tzo = tmp * 60;
1433
1434         PARSE_2_DIGITS(tmp, cur, ret);
1435         if (ret != 0)
1436             return ret;
1437         if (!VALID_MIN(tmp))
1438             return 2;
1439
1440         dt->tzo += tmp;
1441         if (isneg)
1442             dt->tzo = - dt->tzo;
1443
1444         if (!VALID_TZO(dt->tzo))
1445             return 2;
1446
1447         dt->tz_flag = 1;
1448         break;
1449       }
1450     default:
1451         return 1;
1452     }
1453
1454     *str = cur;
1455     return 0;
1456 }
1457
1458 /**
1459  * _xmlSchemaBase64Decode:
1460  * @ch: a character
1461  *
1462  * Converts a base64 encoded character to its base 64 value.
1463  *
1464  * Returns 0-63 (value), 64 (pad), or -1 (not recognized)
1465  */
1466 static int
1467 _xmlSchemaBase64Decode (const xmlChar ch) {
1468     if (('A' <= ch) && (ch <= 'Z')) return ch - 'A';
1469     if (('a' <= ch) && (ch <= 'z')) return ch - 'a' + 26;
1470     if (('0' <= ch) && (ch <= '9')) return ch - '0' + 52;
1471     if ('+' == ch) return 62;
1472     if ('/' == ch) return 63;
1473     if ('=' == ch) return 64;
1474     return -1;
1475 }
1476
1477 /****************************************************************
1478  *                                                              *
1479  *      XML Schema Dates/Times Datatypes Handling               *
1480  *                                                              *
1481  ****************************************************************/
1482
1483 /**
1484  * PARSE_DIGITS:
1485  * @num:  the integer to fill in
1486  * @cur:  an #xmlChar *
1487  * @num_type: an integer flag
1488  *
1489  * Parses a digits integer and updates @num with the value. @cur is
1490  * updated to point just after the integer.
1491  * In case of error, @num_type is set to -1, values of @num and
1492  * @cur are undefined.
1493  */
1494 #define PARSE_DIGITS(num, cur, num_type)                        \
1495         if ((*cur < '0') || (*cur > '9'))                       \
1496             num_type = -1;                                      \
1497         else                                                    \
1498             while ((*cur >= '0') && (*cur <= '9')) {            \
1499                 num = num * 10 + (*cur - '0');                  \
1500                 cur++;                                          \
1501             }
1502
1503 /**
1504  * PARSE_NUM:
1505  * @num:  the double to fill in
1506  * @cur:  an #xmlChar *
1507  * @num_type: an integer flag
1508  *
1509  * Parses a float or integer and updates @num with the value. @cur is
1510  * updated to point just after the number. If the number is a float,
1511  * then it must have an integer part and a decimal part; @num_type will
1512  * be set to 1. If there is no decimal part, @num_type is set to zero.
1513  * In case of error, @num_type is set to -1, values of @num and
1514  * @cur are undefined.
1515  */
1516 #define PARSE_NUM(num, cur, num_type)                           \
1517         num = 0;                                                \
1518         PARSE_DIGITS(num, cur, num_type);                       \
1519         if (!num_type && (*cur == '.')) {                       \
1520             double mult = 1;                                    \
1521             cur++;                                              \
1522             if ((*cur < '0') || (*cur > '9'))                   \
1523                 num_type = -1;                                  \
1524             else                                                \
1525                 num_type = 1;                                   \
1526             while ((*cur >= '0') && (*cur <= '9')) {            \
1527                 mult /= 10;                                     \
1528                 num += (*cur - '0') * mult;                     \
1529                 cur++;                                          \
1530             }                                                   \
1531         }
1532
1533 /**
1534  * xmlSchemaValidateDates:
1535  * @type: the expected type or XML_SCHEMAS_UNKNOWN
1536  * @dateTime:  string to analyze
1537  * @val:  the return computed value
1538  *
1539  * Check that @dateTime conforms to the lexical space of one of the date types.
1540  * if true a value is computed and returned in @val.
1541  *
1542  * Returns 0 if this validates, a positive error code number otherwise
1543  *         and -1 in case of internal or API error.
1544  */
1545 static int
1546 xmlSchemaValidateDates (xmlSchemaValType type,
1547                         const xmlChar *dateTime, xmlSchemaValPtr *val,
1548                         int collapse) {
1549     xmlSchemaValPtr dt;
1550     int ret;
1551     const xmlChar *cur = dateTime;
1552
1553 #define RETURN_TYPE_IF_VALID(t)                                 \
1554     if (IS_TZO_CHAR(*cur)) {                                    \
1555         ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur); \
1556         if (ret == 0) {                                         \
1557             if (*cur != 0)                                      \
1558                 goto error;                                     \
1559             dt->type = t;                                       \
1560             goto done;                                          \
1561         }                                                       \
1562     }
1563
1564     if (dateTime == NULL)
1565         return -1;
1566
1567     if (collapse)
1568         while IS_WSP_BLANK_CH(*cur) cur++;
1569
1570     if ((*cur != '-') && (*cur < '0') && (*cur > '9'))
1571         return 1;
1572
1573     dt = xmlSchemaNewValue(XML_SCHEMAS_UNKNOWN);
1574     if (dt == NULL)
1575         return -1;
1576
1577     if ((cur[0] == '-') && (cur[1] == '-')) {
1578         /*
1579          * It's an incomplete date (xs:gMonthDay, xs:gMonth or
1580          * xs:gDay)
1581          */
1582         cur += 2;
1583
1584         /* is it an xs:gDay? */
1585         if (*cur == '-') {
1586             if (type == XML_SCHEMAS_GMONTH)
1587                 goto error;
1588           ++cur;
1589             ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
1590             if (ret != 0)
1591                 goto error;
1592
1593             RETURN_TYPE_IF_VALID(XML_SCHEMAS_GDAY);
1594
1595             goto error;
1596         }
1597
1598         /*
1599          * it should be an xs:gMonthDay or xs:gMonth
1600          */
1601         ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
1602         if (ret != 0)
1603             goto error;
1604
1605         /*
1606          * a '-' char could indicate this type is xs:gMonthDay or
1607          * a negative time zone offset. Check for xs:gMonthDay first.
1608          * Also the first three char's of a negative tzo (-MM:SS) can
1609          * appear to be a valid day; so even if the day portion
1610          * of the xs:gMonthDay verifies, we must insure it was not
1611          * a tzo.
1612          */
1613         if (*cur == '-') {
1614             const xmlChar *rewnd = cur;
1615             cur++;
1616
1617             ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
1618             if ((ret == 0) && ((*cur == 0) || (*cur != ':'))) {
1619
1620                 /*
1621                  * we can use the VALID_MDAY macro to validate the month
1622                  * and day because the leap year test will flag year zero
1623                  * as a leap year (even though zero is an invalid year).
1624                  * FUTURE TODO: Zero will become valid in XML Schema 1.1
1625                  * probably.
1626                  */
1627                 if (VALID_MDAY((&(dt->value.date)))) {
1628
1629                     RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTHDAY);
1630
1631                     goto error;
1632                 }
1633             }
1634
1635             /*
1636              * not xs:gMonthDay so rewind and check if just xs:gMonth
1637              * with an optional time zone.
1638              */
1639             cur = rewnd;
1640         }
1641
1642         RETURN_TYPE_IF_VALID(XML_SCHEMAS_GMONTH);
1643
1644         goto error;
1645     }
1646
1647     /*
1648      * It's a right-truncated date or an xs:time.
1649      * Try to parse an xs:time then fallback on right-truncated dates.
1650      */
1651     if ((*cur >= '0') && (*cur <= '9')) {
1652         ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
1653         if (ret == 0) {
1654             /* it's an xs:time */
1655             RETURN_TYPE_IF_VALID(XML_SCHEMAS_TIME);
1656         }
1657     }
1658
1659     /* fallback on date parsing */
1660     cur = dateTime;
1661
1662     ret = _xmlSchemaParseGYear(&(dt->value.date), &cur);
1663     if (ret != 0)
1664         goto error;
1665
1666     /* is it an xs:gYear? */
1667     RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEAR);
1668
1669     if (*cur != '-')
1670         goto error;
1671     cur++;
1672
1673     ret = _xmlSchemaParseGMonth(&(dt->value.date), &cur);
1674     if (ret != 0)
1675         goto error;
1676
1677     /* is it an xs:gYearMonth? */
1678     RETURN_TYPE_IF_VALID(XML_SCHEMAS_GYEARMONTH);
1679
1680     if (*cur != '-')
1681         goto error;
1682     cur++;
1683
1684     ret = _xmlSchemaParseGDay(&(dt->value.date), &cur);
1685     if ((ret != 0) || !VALID_DATE((&(dt->value.date))))
1686         goto error;
1687
1688     /* is it an xs:date? */
1689     RETURN_TYPE_IF_VALID(XML_SCHEMAS_DATE);
1690
1691     if (*cur != 'T')
1692         goto error;
1693     cur++;
1694
1695     /* it should be an xs:dateTime */
1696     ret = _xmlSchemaParseTime(&(dt->value.date), &cur);
1697     if (ret != 0)
1698         goto error;
1699
1700     ret = _xmlSchemaParseTimeZone(&(dt->value.date), &cur);
1701     if (collapse)
1702         while IS_WSP_BLANK_CH(*cur) cur++;
1703     if ((ret != 0) || (*cur != 0) || (!(VALID_DATETIME((&(dt->value.date))))))
1704         goto error;
1705
1706
1707     dt->type = XML_SCHEMAS_DATETIME;
1708
1709 done:
1710 #if 1
1711     if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type))
1712         goto error;
1713 #else
1714     /*
1715      * insure the parsed type is equal to or less significant (right
1716      * truncated) than the desired type.
1717      */
1718     if ((type != XML_SCHEMAS_UNKNOWN) && (type != dt->type)) {
1719
1720         /* time only matches time */
1721         if ((type == XML_SCHEMAS_TIME) && (dt->type == XML_SCHEMAS_TIME))
1722             goto error;
1723
1724         if ((type == XML_SCHEMAS_DATETIME) &&
1725             ((dt->type != XML_SCHEMAS_DATE) ||
1726              (dt->type != XML_SCHEMAS_GYEARMONTH) ||
1727              (dt->type != XML_SCHEMAS_GYEAR)))
1728             goto error;
1729
1730         if ((type == XML_SCHEMAS_DATE) &&
1731             ((dt->type != XML_SCHEMAS_GYEAR) ||
1732              (dt->type != XML_SCHEMAS_GYEARMONTH)))
1733             goto error;
1734
1735         if ((type == XML_SCHEMAS_GYEARMONTH) && (dt->type != XML_SCHEMAS_GYEAR))
1736             goto error;
1737
1738         if ((type == XML_SCHEMAS_GMONTHDAY) && (dt->type != XML_SCHEMAS_GMONTH))
1739             goto error;
1740     }
1741 #endif
1742
1743     if (val != NULL)
1744         *val = dt;
1745     else
1746         xmlSchemaFreeValue(dt);
1747
1748     return 0;
1749
1750 error:
1751     if (dt != NULL)
1752         xmlSchemaFreeValue(dt);
1753     return 1;
1754 }
1755
1756 /**
1757  * xmlSchemaValidateDuration:
1758  * @type: the predefined type
1759  * @duration:  string to analyze
1760  * @val:  the return computed value
1761  *
1762  * Check that @duration conforms to the lexical space of the duration type.
1763  * if true a value is computed and returned in @val.
1764  *
1765  * Returns 0 if this validates, a positive error code number otherwise
1766  *         and -1 in case of internal or API error.
1767  */
1768 static int
1769 xmlSchemaValidateDuration (xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
1770                            const xmlChar *duration, xmlSchemaValPtr *val,
1771                            int collapse) {
1772     const xmlChar  *cur = duration;
1773     xmlSchemaValPtr dur;
1774     int isneg = 0;
1775     unsigned int seq = 0;
1776     double         num;
1777     int            num_type = 0;  /* -1 = invalid, 0 = int, 1 = floating */
1778     const xmlChar  desig[]  = {'Y', 'M', 'D', 'H', 'M', 'S'};
1779     const double   multi[]  = { 0.0, 0.0, 86400.0, 3600.0, 60.0, 1.0, 0.0};
1780
1781     if (duration == NULL)
1782         return -1;
1783
1784     if (collapse)
1785         while IS_WSP_BLANK_CH(*cur) cur++;
1786
1787     if (*cur == '-') {
1788         isneg = 1;
1789         cur++;
1790     }
1791
1792     /* duration must start with 'P' (after sign) */
1793     if (*cur++ != 'P')
1794         return 1;
1795
1796     if (*cur == 0)
1797         return 1;
1798
1799     dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
1800     if (dur == NULL)
1801         return -1;
1802
1803     while (*cur != 0) {
1804
1805         /* input string should be empty or invalid date/time item */
1806         if (seq >= sizeof(desig))
1807             goto error;
1808
1809         /* T designator must be present for time items */
1810         if (*cur == 'T') {
1811             if (seq <= 3) {
1812                 seq = 3;
1813                 cur++;
1814             } else
1815                 return 1;
1816         } else if (seq == 3)
1817             goto error;
1818
1819         /* parse the number portion of the item */
1820         PARSE_NUM(num, cur, num_type);
1821
1822         if ((num_type == -1) || (*cur == 0))
1823             goto error;
1824
1825         /* update duration based on item type */
1826         while (seq < sizeof(desig)) {
1827             if (*cur == desig[seq]) {
1828
1829                 /* verify numeric type; only seconds can be float */
1830                 if ((num_type != 0) && (seq < (sizeof(desig)-1)))
1831                     goto error;
1832
1833                 switch (seq) {
1834                     case 0:
1835                         dur->value.dur.mon = (long)num * 12;
1836                         break;
1837                     case 1:
1838                         dur->value.dur.mon += (long)num;
1839                         break;
1840                     default:
1841                         /* convert to seconds using multiplier */
1842                         dur->value.dur.sec += num * multi[seq];
1843                         seq++;
1844                         break;
1845                 }
1846
1847                 break;          /* exit loop */
1848             }
1849             /* no date designators found? */
1850             if ((++seq == 3) || (seq == 6))
1851                 goto error;
1852         }
1853         cur++;
1854         if (collapse)
1855             while IS_WSP_BLANK_CH(*cur) cur++;
1856     }
1857
1858     if (isneg) {
1859         dur->value.dur.mon = -dur->value.dur.mon;
1860         dur->value.dur.day = -dur->value.dur.day;
1861         dur->value.dur.sec = -dur->value.dur.sec;
1862     }
1863
1864     if (val != NULL)
1865         *val = dur;
1866     else
1867         xmlSchemaFreeValue(dur);
1868
1869     return 0;
1870
1871 error:
1872     if (dur != NULL)
1873         xmlSchemaFreeValue(dur);
1874     return 1;
1875 }
1876
1877 /**
1878  * xmlSchemaStrip:
1879  * @value: a value
1880  *
1881  * Removes the leading and ending spaces of a string
1882  *
1883  * Returns the new string or NULL if no change was required.
1884  */
1885 static xmlChar *
1886 xmlSchemaStrip(const xmlChar *value) {
1887     const xmlChar *start = value, *end, *f;
1888
1889     if (value == NULL) return(NULL);
1890     while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
1891     end = start;
1892     while (*end != 0) end++;
1893     f = end;
1894     end--;
1895     while ((end > start) && (IS_BLANK_CH(*end))) end--;
1896     end++;
1897     if ((start == value) && (f == end)) return(NULL);
1898     return(xmlStrndup(start, end - start));
1899 }
1900
1901 /**
1902  * xmlSchemaWhiteSpaceReplace:
1903  * @value: a value
1904  *
1905  * Replaces 0xd, 0x9 and 0xa with a space.
1906  *
1907  * Returns the new string or NULL if no change was required.
1908  */
1909 xmlChar *
1910 xmlSchemaWhiteSpaceReplace(const xmlChar *value) {
1911     const xmlChar *cur = value;
1912     xmlChar *ret = NULL, *mcur;
1913
1914     if (value == NULL)
1915         return(NULL);
1916
1917     while ((*cur != 0) &&
1918         (((*cur) != 0xd) && ((*cur) != 0x9) && ((*cur) != 0xa))) {
1919         cur++;
1920     }
1921     if (*cur == 0)
1922         return (NULL);
1923     ret = xmlStrdup(value);
1924     /* TODO FIXME: I guess gcc will bark at this. */
1925     mcur = (xmlChar *)  (ret + (cur - value));
1926     do {
1927         if ( ((*mcur) == 0xd) || ((*mcur) == 0x9) || ((*mcur) == 0xa) )
1928             *mcur = ' ';
1929         mcur++;
1930     } while (*mcur != 0);
1931     return(ret);
1932 }
1933
1934 /**
1935  * xmlSchemaCollapseString:
1936  * @value: a value
1937  *
1938  * Removes and normalize white spaces in the string
1939  *
1940  * Returns the new string or NULL if no change was required.
1941  */
1942 xmlChar *
1943 xmlSchemaCollapseString(const xmlChar *value) {
1944     const xmlChar *start = value, *end, *f;
1945     xmlChar *g;
1946     int col = 0;
1947
1948     if (value == NULL) return(NULL);
1949     while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
1950     end = start;
1951     while (*end != 0) {
1952         if ((*end == ' ') && (IS_BLANK_CH(end[1]))) {
1953             col = end - start;
1954             break;
1955         } else if ((*end == 0xa) || (*end == 0x9) || (*end == 0xd)) {
1956             col = end - start;
1957             break;
1958         }
1959         end++;
1960     }
1961     if (col == 0) {
1962         f = end;
1963         end--;
1964         while ((end > start) && (IS_BLANK_CH(*end))) end--;
1965         end++;
1966         if ((start == value) && (f == end)) return(NULL);
1967         return(xmlStrndup(start, end - start));
1968     }
1969     start = xmlStrdup(start);
1970     if (start == NULL) return(NULL);
1971     g = (xmlChar *) (start + col);
1972     end = g;
1973     while (*end != 0) {
1974         if (IS_BLANK_CH(*end)) {
1975             end++;
1976             while (IS_BLANK_CH(*end)) end++;
1977             if (*end != 0)
1978                 *g++ = ' ';
1979         } else
1980             *g++ = *end++;
1981     }
1982     *g = 0;
1983     return((xmlChar *) start);
1984 }
1985
1986 /**
1987  * xmlSchemaValAtomicListNode:
1988  * @type: the predefined atomic type for a token in the list
1989  * @value: the list value to check
1990  * @ret:  the return computed value
1991  * @node:  the node containing the value
1992  *
1993  * Check that a value conforms to the lexical space of the predefined
1994  * list type. if true a value is computed and returned in @ret.
1995  *
1996  * Returns the number of items if this validates, a negative error code
1997  *         number otherwise
1998  */
1999 static int
2000 xmlSchemaValAtomicListNode(xmlSchemaTypePtr type, const xmlChar *value,
2001                            xmlSchemaValPtr *ret, xmlNodePtr node) {
2002     xmlChar *val, *cur, *endval;
2003     int nb_values = 0;
2004     int tmp = 0;
2005
2006     if (value == NULL) {
2007         return(-1);
2008     }
2009     val = xmlStrdup(value);
2010     if (val == NULL) {
2011         return(-1);
2012     }
2013     if (ret != NULL) {
2014         *ret = NULL;
2015     }
2016     cur = val;
2017     /*
2018      * Split the list
2019      */
2020     while (IS_BLANK_CH(*cur)) *cur++ = 0;
2021     while (*cur != 0) {
2022         if (IS_BLANK_CH(*cur)) {
2023             *cur = 0;
2024             cur++;
2025             while (IS_BLANK_CH(*cur)) *cur++ = 0;
2026         } else {
2027             nb_values++;
2028             cur++;
2029             while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
2030         }
2031     }
2032     if (nb_values == 0) {
2033         xmlFree(val);
2034         return(nb_values);
2035     }
2036     endval = cur;
2037     cur = val;
2038     while ((*cur == 0) && (cur != endval)) cur++;
2039     while (cur != endval) {
2040         tmp = xmlSchemaValPredefTypeNode(type, cur, NULL, node);
2041         if (tmp != 0)
2042             break;
2043         while (*cur != 0) cur++;
2044         while ((*cur == 0) && (cur != endval)) cur++;
2045     }
2046     /* TODO what return value ? c.f. bug #158628
2047     if (ret != NULL) {
2048         TODO
2049     } */
2050     xmlFree(val);
2051     if (tmp == 0)
2052         return(nb_values);
2053     return(-1);
2054 }
2055
2056 /**
2057  * xmlSchemaParseUInt:
2058  * @str: pointer to the string R/W
2059  * @llo: pointer to the low result
2060  * @lmi: pointer to the mid result
2061  * @lhi: pointer to the high result
2062  *
2063  * Parse an unsigned long into 3 fields.
2064  *
2065  * Returns the number of significant digits in the number or
2066  * -1 if overflow of the capacity and -2 if it's not a number.
2067  */
2068 static int
2069 xmlSchemaParseUInt(const xmlChar **str, unsigned long *llo,
2070                    unsigned long *lmi, unsigned long *lhi) {
2071     unsigned long lo = 0, mi = 0, hi = 0;
2072     const xmlChar *tmp, *cur = *str;
2073     int ret = 0, i = 0;
2074
2075     if (!((*cur >= '0') && (*cur <= '9')))
2076         return(-2);
2077
2078     while (*cur == '0') {        /* ignore leading zeroes */
2079         cur++;
2080     }
2081     tmp = cur;
2082     while ((*tmp != 0) && (*tmp >= '0') && (*tmp <= '9')) {
2083         i++;tmp++;ret++;
2084     }
2085     if (i > 24) {
2086         *str = tmp;
2087         return(-1);
2088     }
2089     while (i > 16) {
2090         hi = hi * 10 + (*cur++ - '0');
2091         i--;
2092     }
2093     while (i > 8) {
2094         mi = mi * 10 + (*cur++ - '0');
2095         i--;
2096     }
2097     while (i > 0) {
2098         lo = lo * 10 + (*cur++ - '0');
2099         i--;
2100     }
2101
2102     *str = cur;
2103     *llo = lo;
2104     *lmi = mi;
2105     *lhi = hi;
2106     return(ret);
2107 }
2108
2109 /**
2110  * xmlSchemaValAtomicType:
2111  * @type: the predefined type
2112  * @value: the value to check
2113  * @val:  the return computed value
2114  * @node:  the node containing the value
2115  * flags:  flags to control the vlidation
2116  *
2117  * Check that a value conforms to the lexical space of the atomic type.
2118  * if true a value is computed and returned in @val.
2119  * This checks the value space for list types as well (IDREFS, NMTOKENS).
2120  *
2121  * Returns 0 if this validates, a positive error code number otherwise
2122  *         and -1 in case of internal or API error.
2123  */
2124 static int
2125 xmlSchemaValAtomicType(xmlSchemaTypePtr type, const xmlChar * value,
2126                        xmlSchemaValPtr * val, xmlNodePtr node, int flags,
2127                        xmlSchemaWhitespaceValueType ws,
2128                        int normOnTheFly, int applyNorm, int createStringValue)
2129 {
2130     xmlSchemaValPtr v;
2131     xmlChar *norm = NULL;
2132     int ret = 0;
2133
2134     if (xmlSchemaTypesInitialized == 0)
2135         xmlSchemaInitTypes();
2136     if (type == NULL)
2137         return (-1);
2138
2139     /*
2140      * validating a non existant text node is similar to validating
2141      * an empty one.
2142      */
2143     if (value == NULL)
2144         value = BAD_CAST "";
2145
2146     if (val != NULL)
2147         *val = NULL;
2148     if ((flags == 0) && (value != NULL)) {
2149
2150         if ((type->builtInType != XML_SCHEMAS_STRING) &&
2151           (type->builtInType != XML_SCHEMAS_ANYTYPE) &&
2152           (type->builtInType != XML_SCHEMAS_ANYSIMPLETYPE)) {
2153             if (type->builtInType == XML_SCHEMAS_NORMSTRING)
2154                 norm = xmlSchemaWhiteSpaceReplace(value);
2155             else
2156                 norm = xmlSchemaCollapseString(value);
2157             if (norm != NULL)
2158                 value = norm;
2159         }
2160     }
2161
2162     switch (type->builtInType) {
2163         case XML_SCHEMAS_UNKNOWN:
2164             goto error;
2165         case XML_SCHEMAS_ANYTYPE:
2166         case XML_SCHEMAS_ANYSIMPLETYPE:
2167             if ((createStringValue) && (val != NULL)) {
2168                 v = xmlSchemaNewValue(XML_SCHEMAS_ANYSIMPLETYPE);
2169                 if (v != NULL) {
2170                     v->value.str = xmlStrdup(value);
2171                     *val = v;
2172                 } else {
2173                     goto error;
2174                 }
2175             }
2176             goto return0;
2177         case XML_SCHEMAS_STRING:
2178             if (! normOnTheFly) {
2179                 const xmlChar *cur = value;
2180
2181                 if (ws == XML_SCHEMA_WHITESPACE_REPLACE) {
2182                     while (*cur != 0) {
2183                         if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
2184                             goto return1;
2185                         } else {
2186                             cur++;
2187                         }
2188                     }
2189                 } else if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE) {
2190                     while (*cur != 0) {
2191                         if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
2192                             goto return1;
2193                         } else if IS_WSP_SPACE_CH(*cur) {
2194                             cur++;
2195                             if IS_WSP_SPACE_CH(*cur)
2196                                 goto return1;
2197                         } else {
2198                             cur++;
2199                         }
2200                     }
2201                 }
2202             }
2203             if (createStringValue && (val != NULL)) {
2204                 if (applyNorm) {
2205                     if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
2206                         norm = xmlSchemaCollapseString(value);
2207                     else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
2208                         norm = xmlSchemaWhiteSpaceReplace(value);
2209                     if (norm != NULL)
2210                         value = norm;
2211                 }
2212                 v = xmlSchemaNewValue(XML_SCHEMAS_STRING);
2213                 if (v != NULL) {
2214                     v->value.str = xmlStrdup(value);
2215                     *val = v;
2216                 } else {
2217                     goto error;
2218                 }
2219             }
2220             goto return0;
2221         case XML_SCHEMAS_NORMSTRING:{
2222                 if (normOnTheFly) {
2223                     if (applyNorm) {
2224                         if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
2225                             norm = xmlSchemaCollapseString(value);
2226                         else
2227                             norm = xmlSchemaWhiteSpaceReplace(value);
2228                         if (norm != NULL)
2229                             value = norm;
2230                     }
2231                 } else {
2232                     const xmlChar *cur = value;
2233                     while (*cur != 0) {
2234                         if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
2235                             goto return1;
2236                         } else {
2237                             cur++;
2238                         }
2239                     }
2240                 }
2241                 if (val != NULL) {
2242                     v = xmlSchemaNewValue(XML_SCHEMAS_NORMSTRING);
2243                     if (v != NULL) {
2244                         v->value.str = xmlStrdup(value);
2245                         *val = v;
2246                     } else {
2247                         goto error;
2248                     }
2249                 }
2250                 goto return0;
2251             }
2252         case XML_SCHEMAS_DECIMAL:{
2253                 const xmlChar *cur = value;
2254                 unsigned int len, neg, integ, hasLeadingZeroes;
2255                 xmlChar cval[25];
2256                 xmlChar *cptr = cval;
2257
2258                 if ((cur == NULL) || (*cur == 0))
2259                     goto return1;
2260
2261                 /*
2262                 * xs:decimal has a whitespace-facet value of 'collapse'.
2263                 */
2264                 if (normOnTheFly)
2265                     while IS_WSP_BLANK_CH(*cur) cur++;
2266
2267                 /*
2268                 * First we handle an optional sign.
2269                 */
2270                 neg = 0;
2271                 if (*cur == '-') {
2272                     neg = 1;
2273                     cur++;
2274                 } else if (*cur == '+')
2275                     cur++;
2276                 /*
2277                 * Disallow: "", "-", "- "
2278                 */
2279                 if (*cur == 0)
2280                     goto return1;
2281                 /*
2282                  * Next we "pre-parse" the number, in preparation for calling
2283                  * the common routine xmlSchemaParseUInt.  We get rid of any
2284                  * leading zeroes (because we have reserved only 25 chars),
2285                  * and note the position of a decimal point.
2286                  */
2287                 len = 0;
2288                 integ = ~0u;
2289                 hasLeadingZeroes = 0;
2290                 /*
2291                 * Skip leading zeroes.
2292                 */
2293                 while (*cur == '0') {
2294                     cur++;
2295                     hasLeadingZeroes = 1;
2296                 }
2297                 if (*cur != 0) {
2298                     do {
2299                         if ((*cur >= '0') && (*cur <= '9')) {
2300                             *cptr++ = *cur++;
2301                             len++;
2302                         } else if (*cur == '.') {
2303                             cur++;
2304                             integ = len;
2305                             do {
2306                                 if ((*cur >= '0') && (*cur <= '9')) {
2307                                     *cptr++ = *cur++;
2308                                     len++;
2309                                 } else
2310                                     break;
2311                             } while (len < 24);
2312                             /*
2313                             * Disallow "." but allow "00."
2314                             */
2315                             if ((len == 0) && (!hasLeadingZeroes))
2316                                 goto return1;
2317                             break;
2318                         } else
2319                             break;
2320                     } while (len < 24);
2321                 }
2322                 if (normOnTheFly)
2323                     while IS_WSP_BLANK_CH(*cur) cur++;
2324                 if (*cur != 0)
2325                     goto return1; /* error if any extraneous chars */
2326                 if (val != NULL) {
2327                     v = xmlSchemaNewValue(XML_SCHEMAS_DECIMAL);
2328                     if (v != NULL) {
2329                         /*
2330                         * Now evaluate the significant digits of the number
2331                         */
2332                         if (len != 0) {
2333
2334                             if (integ != ~0u) {
2335                                 /*
2336                                 * Get rid of trailing zeroes in the
2337                                 * fractional part.
2338                                 */
2339                                 while ((len != integ) && (*(cptr-1) == '0')) {
2340                                     cptr--;
2341                                     len--;
2342                                 }
2343                             }
2344                             /*
2345                             * Terminate the (preparsed) string.
2346                             */
2347                             if (len != 0) {
2348                                 *cptr = 0;
2349                                 cptr = cval;
2350
2351                                 xmlSchemaParseUInt((const xmlChar **)&cptr,
2352                                     &v->value.decimal.lo,
2353                                     &v->value.decimal.mi,
2354                                     &v->value.decimal.hi);
2355                             }
2356                         }
2357                         /*
2358                         * Set the total digits to 1 if a zero value.
2359                         */
2360                         v->value.decimal.sign = neg;
2361                         if (len == 0) {
2362                             /* Speedup for zero values. */
2363                             v->value.decimal.total = 1;
2364                         } else {
2365                             v->value.decimal.total = len;
2366                             if (integ == ~0u)
2367                                 v->value.decimal.frac = 0;
2368                             else
2369                                 v->value.decimal.frac = len - integ;
2370                         }
2371                         *val = v;
2372                     }
2373                 }
2374                 goto return0;
2375             }
2376         case XML_SCHEMAS_TIME:
2377         case XML_SCHEMAS_GDAY:
2378         case XML_SCHEMAS_GMONTH:
2379         case XML_SCHEMAS_GMONTHDAY:
2380         case XML_SCHEMAS_GYEAR:
2381         case XML_SCHEMAS_GYEARMONTH:
2382         case XML_SCHEMAS_DATE:
2383         case XML_SCHEMAS_DATETIME:
2384             ret = xmlSchemaValidateDates(type->builtInType, value, val,
2385                 normOnTheFly);
2386             break;
2387         case XML_SCHEMAS_DURATION:
2388             ret = xmlSchemaValidateDuration(type, value, val,
2389                 normOnTheFly);
2390             break;
2391         case XML_SCHEMAS_FLOAT:
2392         case XML_SCHEMAS_DOUBLE: {
2393                 const xmlChar *cur = value;
2394                 int neg = 0;
2395                 int digits_before = 0;
2396                 int digits_after = 0;
2397
2398                 if (normOnTheFly)
2399                     while IS_WSP_BLANK_CH(*cur) cur++;
2400
2401                 if ((cur[0] == 'N') && (cur[1] == 'a') && (cur[2] == 'N')) {
2402                     cur += 3;
2403                     if (*cur != 0)
2404                         goto return1;
2405                     if (val != NULL) {
2406                         if (type == xmlSchemaTypeFloatDef) {
2407                             v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
2408                             if (v != NULL) {
2409                                 v->value.f = (float) xmlXPathNAN;
2410                             } else {
2411                                 xmlSchemaFreeValue(v);
2412                                 goto error;
2413                             }
2414                         } else {
2415                             v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
2416                             if (v != NULL) {
2417                                 v->value.d = xmlXPathNAN;
2418                             } else {
2419                                 xmlSchemaFreeValue(v);
2420                                 goto error;
2421                             }
2422                         }
2423                         *val = v;
2424                     }
2425                     goto return0;
2426                 }
2427                 if (*cur == '-') {
2428                     neg = 1;
2429                     cur++;
2430                 }
2431                 if ((cur[0] == 'I') && (cur[1] == 'N') && (cur[2] == 'F')) {
2432                     cur += 3;
2433                     if (*cur != 0)
2434                         goto return1;
2435                     if (val != NULL) {
2436                         if (type == xmlSchemaTypeFloatDef) {
2437                             v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
2438                             if (v != NULL) {
2439                                 if (neg)
2440                                     v->value.f = (float) xmlXPathNINF;
2441                                 else
2442                                     v->value.f = (float) xmlXPathPINF;
2443                             } else {
2444                                 xmlSchemaFreeValue(v);
2445                                 goto error;
2446                             }
2447                         } else {
2448                             v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
2449                             if (v != NULL) {
2450                                 if (neg)
2451                                     v->value.d = xmlXPathNINF;
2452                                 else
2453                                     v->value.d = xmlXPathPINF;
2454                             } else {
2455                                 xmlSchemaFreeValue(v);
2456                                 goto error;
2457                             }
2458                         }
2459                         *val = v;
2460                     }
2461                     goto return0;
2462                 }
2463                 if ((neg == 0) && (*cur == '+'))
2464                     cur++;
2465                 if ((cur[0] == 0) || (cur[0] == '+') || (cur[0] == '-'))
2466                     goto return1;
2467                 while ((*cur >= '0') && (*cur <= '9')) {
2468                     cur++;
2469                     digits_before++;
2470                 }
2471                 if (*cur == '.') {
2472                     cur++;
2473                     while ((*cur >= '0') && (*cur <= '9')) {
2474                         cur++;
2475                         digits_after++;
2476                     }
2477                 }
2478                 if ((digits_before == 0) && (digits_after == 0))
2479                     goto return1;
2480                 if ((*cur == 'e') || (*cur == 'E')) {
2481                     cur++;
2482                     if ((*cur == '-') || (*cur == '+'))
2483                         cur++;
2484                     while ((*cur >= '0') && (*cur <= '9'))
2485                         cur++;
2486                 }
2487                 if (normOnTheFly)
2488                     while IS_WSP_BLANK_CH(*cur) cur++;
2489
2490                 if (*cur != 0)
2491                     goto return1;
2492                 if (val != NULL) {
2493                     if (type == xmlSchemaTypeFloatDef) {
2494                         v = xmlSchemaNewValue(XML_SCHEMAS_FLOAT);
2495                         if (v != NULL) {
2496                             /*
2497                             * TODO: sscanf seems not to give the correct
2498                             * value for extremely high/low values.
2499                             * E.g. "1E-149" results in zero.
2500                             */
2501                             if (sscanf((const char *) value, "%f",
2502                                  &(v->value.f)) == 1) {
2503                                 *val = v;
2504                             } else {
2505                                 xmlSchemaFreeValue(v);
2506                                 goto return1;
2507                             }
2508                         } else {
2509                             goto error;
2510                         }
2511                     } else {
2512                         v = xmlSchemaNewValue(XML_SCHEMAS_DOUBLE);
2513                         if (v != NULL) {
2514                             /*
2515                             * TODO: sscanf seems not to give the correct
2516                             * value for extremely high/low values.
2517                             */
2518                             if (sscanf((const char *) value, "%lf",
2519                                  &(v->value.d)) == 1) {
2520                                 *val = v;
2521                             } else {
2522                                 xmlSchemaFreeValue(v);
2523                                 goto return1;
2524                             }
2525                         } else {
2526                             goto error;
2527                         }
2528                     }
2529                 }
2530                 goto return0;
2531             }
2532         case XML_SCHEMAS_BOOLEAN:{
2533                 const xmlChar *cur = value;
2534
2535                 if (normOnTheFly) {
2536                     while IS_WSP_BLANK_CH(*cur) cur++;
2537                     if (*cur == '0') {
2538                         ret = 0;
2539                         cur++;
2540                     } else if (*cur == '1') {
2541                         ret = 1;
2542                         cur++;
2543                     } else if (*cur == 't') {
2544                         cur++;
2545                         if ((*cur++ == 'r') && (*cur++ == 'u') &&
2546                             (*cur++ == 'e')) {
2547                             ret = 1;
2548                         } else
2549                             goto return1;
2550                     } else if (*cur == 'f') {
2551                         cur++;
2552                         if ((*cur++ == 'a') && (*cur++ == 'l') &&
2553                             (*cur++ == 's') && (*cur++ == 'e')) {
2554                             ret = 0;
2555                         } else
2556                             goto return1;
2557                     } else
2558                         goto return1;
2559                     if (*cur != 0) {
2560                         while IS_WSP_BLANK_CH(*cur) cur++;
2561                         if (*cur != 0)
2562                             goto return1;
2563                     }
2564                 } else {
2565                     if ((cur[0] == '0') && (cur[1] == 0))
2566                         ret = 0;
2567                     else if ((cur[0] == '1') && (cur[1] == 0))
2568                         ret = 1;
2569                     else if ((cur[0] == 't') && (cur[1] == 'r')
2570                         && (cur[2] == 'u') && (cur[3] == 'e')
2571                         && (cur[4] == 0))
2572                         ret = 1;
2573                     else if ((cur[0] == 'f') && (cur[1] == 'a')
2574                         && (cur[2] == 'l') && (cur[3] == 's')
2575                         && (cur[4] == 'e') && (cur[5] == 0))
2576                         ret = 0;
2577                     else
2578                         goto return1;
2579                 }
2580                 if (val != NULL) {
2581                     v = xmlSchemaNewValue(XML_SCHEMAS_BOOLEAN);
2582                     if (v != NULL) {
2583                         v->value.b = ret;
2584                         *val = v;
2585                     } else {
2586                         goto error;
2587                     }
2588                 }
2589                 goto return0;
2590             }
2591         case XML_SCHEMAS_TOKEN:{
2592                 const xmlChar *cur = value;
2593
2594                 if (! normOnTheFly) {
2595                     while (*cur != 0) {
2596                         if ((*cur == 0xd) || (*cur == 0xa) || (*cur == 0x9)) {
2597                             goto return1;
2598                         } else if (*cur == ' ') {
2599                             cur++;
2600                             if (*cur == 0)
2601                                 goto return1;
2602                             if (*cur == ' ')
2603                                 goto return1;
2604                         } else {
2605                             cur++;
2606                         }
2607                     }
2608                 }
2609                 if (val != NULL) {
2610                     v = xmlSchemaNewValue(XML_SCHEMAS_TOKEN);
2611                     if (v != NULL) {
2612                         v->value.str = xmlStrdup(value);
2613                         *val = v;
2614                     } else {
2615                         goto error;
2616                     }
2617                 }
2618                 goto return0;
2619             }
2620         case XML_SCHEMAS_LANGUAGE:
2621             if (normOnTheFly) {
2622                 norm = xmlSchemaCollapseString(value);
2623                 if (norm != NULL)
2624                     value = norm;
2625             }
2626             if (xmlCheckLanguageID(value) == 1) {
2627                 if (val != NULL) {
2628                     v = xmlSchemaNewValue(XML_SCHEMAS_LANGUAGE);
2629                     if (v != NULL) {
2630                         v->value.str = xmlStrdup(value);
2631                         *val = v;
2632                     } else {
2633                         goto error;
2634                     }
2635                 }
2636                 goto return0;
2637             }
2638             goto return1;
2639         case XML_SCHEMAS_NMTOKEN:
2640             if (xmlValidateNMToken(value, 1) == 0) {
2641                 if (val != NULL) {
2642                     v = xmlSchemaNewValue(XML_SCHEMAS_NMTOKEN);
2643                     if (v != NULL) {
2644                         v->value.str = xmlStrdup(value);
2645                         *val = v;
2646                     } else {
2647                         goto error;
2648                     }
2649                 }
2650                 goto return0;
2651             }
2652             goto return1;
2653         case XML_SCHEMAS_NMTOKENS:
2654             ret = xmlSchemaValAtomicListNode(xmlSchemaTypeNmtokenDef,
2655                                              value, val, node);
2656             if (ret > 0)
2657                 ret = 0;
2658             else
2659                 ret = 1;
2660             goto done;
2661         case XML_SCHEMAS_NAME:
2662             ret = xmlValidateName(value, 1);
2663             if ((ret == 0) && (val != NULL) && (value != NULL)) {
2664                 v = xmlSchemaNewValue(XML_SCHEMAS_NAME);
2665                 if (v != NULL) {
2666                      const xmlChar *start = value, *end;
2667                      while (IS_BLANK_CH(*start)) start++;
2668                      end = start;
2669                      while ((*end != 0) && (!IS_BLANK_CH(*end))) end++;
2670                      v->value.str = xmlStrndup(start, end - start);
2671                     *val = v;
2672                 } else {
2673                     goto error;
2674                 }
2675             }
2676             goto done;
2677         case XML_SCHEMAS_QNAME:{
2678                 const xmlChar *uri = NULL;
2679                 xmlChar *local = NULL;
2680
2681                 ret = xmlValidateQName(value, 1);
2682                 if (ret != 0)
2683                     goto done;
2684                 if (node != NULL) {
2685                     xmlChar *prefix;
2686                     xmlNsPtr ns;
2687
2688                     local = xmlSplitQName2(value, &prefix);
2689                     ns = xmlSearchNs(node->doc, node, prefix);
2690                     if ((ns == NULL) && (prefix != NULL)) {
2691                         xmlFree(prefix);
2692                         if (local != NULL)
2693                             xmlFree(local);
2694                         goto return1;
2695                     }
2696                     if (ns != NULL)
2697                         uri = ns->href;
2698                     if (prefix != NULL)
2699                         xmlFree(prefix);
2700                 }
2701                 if (val != NULL) {
2702                     v = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
2703                     if (v == NULL) {
2704                         if (local != NULL)
2705                             xmlFree(local);
2706                         goto error;
2707                     }
2708                     if (local != NULL)
2709                         v->value.qname.name = local;
2710                     else
2711                         v->value.qname.name = xmlStrdup(value);
2712                     if (uri != NULL)
2713                         v->value.qname.uri = xmlStrdup(uri);
2714                     *val = v;
2715                 } else
2716                     if (local != NULL)
2717                         xmlFree(local);
2718                 goto done;
2719             }
2720         case XML_SCHEMAS_NCNAME:
2721             ret = xmlValidateNCName(value, 1);
2722             if ((ret == 0) && (val != NULL)) {
2723                 v = xmlSchemaNewValue(XML_SCHEMAS_NCNAME);
2724                 if (v != NULL) {
2725                     v->value.str = xmlStrdup(value);
2726                     *val = v;
2727                 } else {
2728                     goto error;
2729                 }
2730             }
2731             goto done;
2732         case XML_SCHEMAS_ID:
2733             ret = xmlValidateNCName(value, 1);
2734             if ((ret == 0) && (val != NULL)) {
2735                 v = xmlSchemaNewValue(XML_SCHEMAS_ID);
2736                 if (v != NULL) {
2737                     v->value.str = xmlStrdup(value);
2738                     *val = v;
2739                 } else {
2740                     goto error;
2741                 }
2742             }
2743             if ((ret == 0) && (node != NULL) &&
2744                 (node->type == XML_ATTRIBUTE_NODE)) {
2745                 xmlAttrPtr attr = (xmlAttrPtr) node;
2746
2747                 /*
2748                  * NOTE: the IDness might have already be declared in the DTD
2749                  */
2750                 if (attr->atype != XML_ATTRIBUTE_ID) {
2751                     xmlIDPtr res;
2752                     xmlChar *strip;
2753
2754                     strip = xmlSchemaStrip(value);
2755                     if (strip != NULL) {
2756                         res = xmlAddID(NULL, node->doc, strip, attr);
2757                         xmlFree(strip);
2758                     } else
2759                         res = xmlAddID(NULL, node->doc, value, attr);
2760                     if (res == NULL) {
2761                         ret = 2;
2762                     } else {
2763                         attr->atype = XML_ATTRIBUTE_ID;
2764                     }
2765                 }
2766             }
2767             goto done;
2768         case XML_SCHEMAS_IDREF:
2769             ret = xmlValidateNCName(value, 1);
2770             if ((ret == 0) && (val != NULL)) {
2771                 v = xmlSchemaNewValue(XML_SCHEMAS_IDREF);
2772                 if (v == NULL)
2773                     goto error;
2774                 v->value.str = xmlStrdup(value);
2775                 *val = v;
2776             }
2777             if ((ret == 0) && (node != NULL) &&
2778                 (node->type == XML_ATTRIBUTE_NODE)) {
2779                 xmlAttrPtr attr = (xmlAttrPtr) node;
2780                 xmlChar *strip;
2781
2782                 strip = xmlSchemaStrip(value);
2783                 if (strip != NULL) {
2784                     xmlAddRef(NULL, node->doc, strip, attr);
2785                     xmlFree(strip);
2786                 } else
2787                     xmlAddRef(NULL, node->doc, value, attr);
2788                 attr->atype = XML_ATTRIBUTE_IDREF;
2789             }
2790             goto done;
2791         case XML_SCHEMAS_IDREFS:
2792             ret = xmlSchemaValAtomicListNode(xmlSchemaTypeIdrefDef,
2793                                              value, val, node);
2794             if (ret < 0)
2795                 ret = 2;
2796             else
2797                 ret = 0;
2798             if ((ret == 0) && (node != NULL) &&
2799                 (node->type == XML_ATTRIBUTE_NODE)) {
2800                 xmlAttrPtr attr = (xmlAttrPtr) node;
2801
2802                 attr->atype = XML_ATTRIBUTE_IDREFS;
2803             }
2804             goto done;
2805         case XML_SCHEMAS_ENTITY:{
2806                 xmlChar *strip;
2807
2808                 ret = xmlValidateNCName(value, 1);
2809                 if ((node == NULL) || (node->doc == NULL))
2810                     ret = 3;
2811                 if (ret == 0) {
2812                     xmlEntityPtr ent;
2813
2814                     strip = xmlSchemaStrip(value);
2815                     if (strip != NULL) {
2816                         ent = xmlGetDocEntity(node->doc, strip);
2817                         xmlFree(strip);
2818                     } else {
2819                         ent = xmlGetDocEntity(node->doc, value);
2820                     }
2821                     if ((ent == NULL) ||
2822                         (ent->etype !=
2823                          XML_EXTERNAL_GENERAL_UNPARSED_ENTITY))
2824                         ret = 4;
2825                 }
2826                 if ((ret == 0) && (val != NULL)) {
2827                     TODO;
2828                 }
2829                 if ((ret == 0) && (node != NULL) &&
2830                     (node->type == XML_ATTRIBUTE_NODE)) {
2831                     xmlAttrPtr attr = (xmlAttrPtr) node;
2832
2833                     attr->atype = XML_ATTRIBUTE_ENTITY;
2834                 }
2835                 goto done;
2836             }
2837         case XML_SCHEMAS_ENTITIES:
2838             if ((node == NULL) || (node->doc == NULL))
2839                 goto return3;
2840             ret = xmlSchemaValAtomicListNode(xmlSchemaTypeEntityDef,
2841                                              value, val, node);
2842             if (ret <= 0)
2843                 ret = 1;
2844             else
2845                 ret = 0;
2846             if ((ret == 0) && (node != NULL) &&
2847                 (node->type == XML_ATTRIBUTE_NODE)) {
2848                 xmlAttrPtr attr = (xmlAttrPtr) node;
2849
2850                 attr->atype = XML_ATTRIBUTE_ENTITIES;
2851             }
2852             goto done;
2853         case XML_SCHEMAS_NOTATION:{
2854                 xmlChar *uri = NULL;
2855                 xmlChar *local = NULL;
2856
2857                 ret = xmlValidateQName(value, 1);
2858                 if ((ret == 0) && (node != NULL)) {
2859                     xmlChar *prefix;
2860
2861                     local = xmlSplitQName2(value, &prefix);
2862                     if (prefix != NULL) {
2863                         xmlNsPtr ns;
2864
2865                         ns = xmlSearchNs(node->doc, node, prefix);
2866                         if (ns == NULL)
2867                             ret = 1;
2868                         else if (val != NULL)
2869                             uri = xmlStrdup(ns->href);
2870                     }
2871                     if ((local != NULL) && ((val == NULL) || (ret != 0)))
2872                         xmlFree(local);
2873                     if (prefix != NULL)
2874                         xmlFree(prefix);
2875                 }
2876                 if ((node == NULL) || (node->doc == NULL))
2877                     ret = 3;
2878                 if (ret == 0) {
2879                     ret = xmlValidateNotationUse(NULL, node->doc, value);
2880                     if (ret == 1)
2881                         ret = 0;
2882                     else
2883                         ret = 1;
2884                 }
2885                 if ((ret == 0) && (val != NULL)) {
2886                     v = xmlSchemaNewValue(XML_SCHEMAS_NOTATION);
2887                     if (v != NULL) {
2888                         if (local != NULL)
2889                             v->value.qname.name = local;
2890                         else
2891                             v->value.qname.name = xmlStrdup(value);
2892                         if (uri != NULL)
2893                             v->value.qname.uri = uri;
2894
2895                         *val = v;
2896                     } else {
2897                         if (local != NULL)
2898                             xmlFree(local);
2899                         if (uri != NULL)
2900                             xmlFree(uri);
2901                         goto error;
2902                     }
2903                 }
2904                 goto done;
2905             }
2906         case XML_SCHEMAS_ANYURI:{
2907                 if (*value != 0) {
2908                     xmlURIPtr uri;
2909                     xmlChar *tmpval, *cur;
2910                     if (normOnTheFly) {
2911                         norm = xmlSchemaCollapseString(value);
2912                         if (norm != NULL)
2913                             value = norm;
2914                     }
2915                     tmpval = xmlStrdup(value);
2916                     for (cur = tmpval; *cur; ++cur) {
2917                         if (*cur < 32 || *cur >= 127 || *cur == ' ' ||
2918                             *cur == '<' || *cur == '>' || *cur == '"' ||
2919                             *cur == '{' || *cur == '}' || *cur == '|' ||
2920                             *cur == '\\' || *cur == '^' || *cur == '`' ||
2921                             *cur == '\'')
2922                             *cur = '_';
2923                     }
2924                     uri = xmlParseURI((const char *) tmpval);
2925                     xmlFree(tmpval);
2926                     if (uri == NULL)
2927                         goto return1;
2928                     xmlFreeURI(uri);
2929                 }
2930
2931                 if (val != NULL) {
2932                     v = xmlSchemaNewValue(XML_SCHEMAS_ANYURI);
2933                     if (v == NULL)
2934                         goto error;
2935                     v->value.str = xmlStrdup(value);
2936                     *val = v;
2937                 }
2938                 goto return0;
2939             }
2940         case XML_SCHEMAS_HEXBINARY:{
2941                 const xmlChar *cur = value, *start;
2942                 xmlChar *base;
2943                 int total, i = 0;
2944
2945                 if (cur == NULL)
2946                     goto return1;
2947
2948                 if (normOnTheFly)
2949                     while IS_WSP_BLANK_CH(*cur) cur++;
2950
2951                 start = cur;
2952                 while (((*cur >= '0') && (*cur <= '9')) ||
2953                        ((*cur >= 'A') && (*cur <= 'F')) ||
2954                        ((*cur >= 'a') && (*cur <= 'f'))) {
2955                     i++;
2956                     cur++;
2957                 }
2958                 if (normOnTheFly)
2959                     while IS_WSP_BLANK_CH(*cur) cur++;
2960
2961                 if (*cur != 0)
2962                     goto return1;
2963                 if ((i % 2) != 0)
2964                     goto return1;
2965
2966                 if (val != NULL) {
2967
2968                     v = xmlSchemaNewValue(XML_SCHEMAS_HEXBINARY);
2969                     if (v == NULL)
2970                         goto error;
2971                     /*
2972                     * Copy only the normalized piece.
2973                     * CRITICAL TODO: Check this.
2974                     */
2975                     cur = xmlStrndup(start, i);
2976                     if (cur == NULL) {
2977                         xmlSchemaTypeErrMemory(node, "allocating hexbin data");
2978                         xmlFree(v);
2979                         goto return1;
2980                     }
2981
2982                     total = i / 2;      /* number of octets */
2983
2984                     base = (xmlChar *) cur;
2985                     while (i-- > 0) {
2986                         if (*base >= 'a')
2987                             *base = *base - ('a' - 'A');
2988                         base++;
2989                     }
2990
2991                     v->value.hex.str = (xmlChar *) cur;
2992                     v->value.hex.total = total;
2993                     *val = v;
2994                 }
2995                 goto return0;
2996             }
2997         case XML_SCHEMAS_BASE64BINARY:{
2998                 /* ISSUE:
2999                  *
3000                  * Ignore all stray characters? (yes, currently)
3001                  * Worry about long lines? (no, currently)
3002                  *
3003                  * rfc2045.txt:
3004                  *
3005                  * "The encoded output stream must be represented in lines of
3006                  * no more than 76 characters each.  All line breaks or other
3007                  * characters not found in Table 1 must be ignored by decoding
3008                  * software.  In base64 data, characters other than those in
3009                  * Table 1, line breaks, and other white space probably
3010                  * indicate a transmission error, about which a warning
3011                  * message or even a message rejection might be appropriate
3012                  * under some circumstances." */
3013                 const xmlChar *cur = value;
3014                 xmlChar *base;
3015                 int total, i = 0, pad = 0;
3016
3017                 if (cur == NULL)
3018                     goto return1;
3019
3020                 for (; *cur; ++cur) {
3021                     int decc;
3022
3023                     decc = _xmlSchemaBase64Decode(*cur);
3024                     if (decc < 0) ;
3025                     else if (decc < 64)
3026                         i++;
3027                     else
3028                         break;
3029                 }
3030                 for (; *cur; ++cur) {
3031                     int decc;
3032
3033                     decc = _xmlSchemaBase64Decode(*cur);
3034                     if (decc < 0) ;
3035                     else if (decc < 64)
3036                         goto return1;
3037                     if (decc == 64)
3038                         pad++;
3039                 }
3040
3041                 /* rfc2045.txt: "Special processing is performed if fewer than
3042                  * 24 bits are available at the end of the data being encoded.
3043                  * A full encoding quantum is always completed at the end of a
3044                  * body.  When fewer than 24 input bits are available in an
3045                  * input group, zero bits are added (on the right) to form an
3046                  * integral number of 6-bit groups.  Padding at the end of the
3047                  * data is performed using the "=" character.  Since all
3048                  * base64 input is an integral number of octets, only the
3049                  * following cases can arise: (1) the final quantum of
3050                  * encoding input is an integral multiple of 24 bits; here,
3051                  * the final unit of encoded output will be an integral
3052                  * multiple ofindent: Standard input:701: Warning:old style
3053                  * assignment ambiguity in "=*".  Assuming "= *" 4 characters
3054                  * with no "=" padding, (2) the final
3055                  * quantum of encoding input is exactly 8 bits; here, the
3056                  * final unit of encoded output will be two characters
3057                  * followed by two "=" padding characters, or (3) the final
3058                  * quantum of encoding input is exactly 16 bits; here, the
3059                  * final unit of encoded output will be three characters
3060                  * followed by one "=" padding character." */
3061
3062                 total = 3 * (i / 4);
3063                 if (pad == 0) {
3064                     if (i % 4 != 0)
3065                         goto return1;
3066                 } else if (pad == 1) {
3067                     int decc;
3068
3069                     if (i % 4 != 3)
3070                         goto return1;
3071                     for (decc = _xmlSchemaBase64Decode(*cur);
3072                          (decc < 0) || (decc > 63);
3073                          decc = _xmlSchemaBase64Decode(*cur))
3074                         --cur;
3075                     /* 16bits in 24bits means 2 pad bits: nnnnnn nnmmmm mmmm00*/
3076                     /* 00111100 -> 0x3c */
3077                     if (decc & ~0x3c)
3078                         goto return1;
3079                     total += 2;
3080                 } else if (pad == 2) {
3081                     int decc;
3082
3083                     if (i % 4 != 2)
3084                         goto return1;
3085                     for (decc = _xmlSchemaBase64Decode(*cur);
3086                          (decc < 0) || (decc > 63);
3087                          decc = _xmlSchemaBase64Decode(*cur))
3088                         --cur;
3089                     /* 8bits in 12bits means 4 pad bits: nnnnnn nn0000 */
3090                     /* 00110000 -> 0x30 */
3091                     if (decc & ~0x30)
3092                         goto return1;
3093                     total += 1;
3094                 } else
3095                     goto return1;
3096
3097                 if (val != NULL) {
3098                     v = xmlSchemaNewValue(XML_SCHEMAS_BASE64BINARY);
3099                     if (v == NULL)
3100                         goto error;
3101                     base =
3102                         (xmlChar *) xmlMallocAtomic((i + pad + 1) *
3103                                                     sizeof(xmlChar));
3104                     if (base == NULL) {
3105                         xmlSchemaTypeErrMemory(node, "allocating base64 data");
3106                         xmlFree(v);
3107                         goto return1;
3108                     }
3109                     v->value.base64.str = base;
3110                     for (cur = value; *cur; ++cur)
3111                         if (_xmlSchemaBase64Decode(*cur) >= 0) {
3112                             *base = *cur;
3113                             ++base;
3114                         }
3115                     *base = 0;
3116                     v->value.base64.total = total;
3117                     *val = v;
3118                 }
3119                 goto return0;
3120             }
3121         case XML_SCHEMAS_INTEGER:
3122         case XML_SCHEMAS_PINTEGER:
3123         case XML_SCHEMAS_NPINTEGER:
3124         case XML_SCHEMAS_NINTEGER:
3125         case XML_SCHEMAS_NNINTEGER:{
3126                 const xmlChar *cur = value;
3127                 unsigned long lo, mi, hi;
3128                 int sign = 0;
3129
3130                 if (cur == NULL)
3131                     goto return1;
3132                 if (normOnTheFly)
3133                     while IS_WSP_BLANK_CH(*cur) cur++;
3134                 if (*cur == '-') {
3135                     sign = 1;
3136                     cur++;
3137                 } else if (*cur == '+')
3138                     cur++;
3139                 ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
3140                 if (ret < 0)
3141                     goto return1;
3142                 if (normOnTheFly)
3143                     while IS_WSP_BLANK_CH(*cur) cur++;
3144                 if (*cur != 0)
3145                     goto return1;
3146                 if (type->builtInType == XML_SCHEMAS_NPINTEGER) {
3147                     if ((sign == 0) &&
3148                         ((hi != 0) || (mi != 0) || (lo != 0)))
3149                         goto return1;
3150                 } else if (type->builtInType == XML_SCHEMAS_PINTEGER) {
3151                     if (sign == 1)
3152                         goto return1;
3153                     if ((hi == 0) && (mi == 0) && (lo == 0))
3154                         goto return1;
3155                 } else if (type->builtInType == XML_SCHEMAS_NINTEGER) {
3156                     if (sign == 0)
3157                         goto return1;
3158                     if ((hi == 0) && (mi == 0) && (lo == 0))
3159                         goto return1;
3160                 } else if (type->builtInType == XML_SCHEMAS_NNINTEGER) {
3161                     if ((sign == 1) &&
3162                         ((hi != 0) || (mi != 0) || (lo != 0)))
3163                         goto return1;
3164                 }
3165                 if (val != NULL) {
3166                     v = xmlSchemaNewValue(type->builtInType);
3167                     if (v != NULL) {
3168                         if (ret == 0)
3169                             ret++;
3170                         v->value.decimal.lo = lo;
3171                         v->value.decimal.mi = mi;
3172                         v->value.decimal.hi = hi;
3173                         v->value.decimal.sign = sign;
3174                         v->value.decimal.frac = 0;
3175                         v->value.decimal.total = ret;
3176                         *val = v;
3177                     }
3178                 }
3179                 goto return0;
3180             }
3181         case XML_SCHEMAS_LONG:
3182         case XML_SCHEMAS_BYTE:
3183         case XML_SCHEMAS_SHORT:
3184         case XML_SCHEMAS_INT:{
3185                 const xmlChar *cur = value;
3186                 unsigned long lo, mi, hi;
3187                 int sign = 0;
3188
3189                 if (cur == NULL)
3190                     goto return1;
3191                 if (*cur == '-') {
3192                     sign = 1;
3193                     cur++;
3194                 } else if (*cur == '+')
3195                     cur++;
3196                 ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
3197                 if (ret < 0)
3198                     goto return1;
3199                 if (*cur != 0)
3200                     goto return1;
3201                 if (type->builtInType == XML_SCHEMAS_LONG) {
3202                     if (hi >= 922) {
3203                         if (hi > 922)
3204                             goto return1;
3205                         if (mi >= 33720368) {
3206                             if (mi > 33720368)
3207                                 goto return1;
3208                             if ((sign == 0) && (lo > 54775807))
3209                                 goto return1;
3210                             if ((sign == 1) && (lo > 54775808))
3211                                 goto return1;
3212                         }
3213                     }
3214                 } else if (type->builtInType == XML_SCHEMAS_INT) {
3215                     if (hi != 0)
3216                         goto return1;
3217                     if (mi >= 21) {
3218                         if (mi > 21)
3219                             goto return1;
3220                         if ((sign == 0) && (lo > 47483647))
3221                             goto return1;
3222                         if ((sign == 1) && (lo > 47483648))
3223                             goto return1;
3224                     }
3225                 } else if (type->builtInType == XML_SCHEMAS_SHORT) {
3226                     if ((mi != 0) || (hi != 0))
3227                         goto return1;
3228                     if ((sign == 1) && (lo > 32768))
3229                         goto return1;
3230                     if ((sign == 0) && (lo > 32767))
3231                         goto return1;
3232                 } else if (type->builtInType == XML_SCHEMAS_BYTE) {
3233                     if ((mi != 0) || (hi != 0))
3234                         goto return1;
3235                     if ((sign == 1) && (lo > 128))
3236                         goto return1;
3237                     if ((sign == 0) && (lo > 127))
3238                         goto return1;
3239                 }
3240                 if (val != NULL) {
3241                     v = xmlSchemaNewValue(type->builtInType);
3242                     if (v != NULL) {
3243                         v->value.decimal.lo = lo;
3244                         v->value.decimal.mi = mi;
3245                         v->value.decimal.hi = hi;
3246                         v->value.decimal.sign = sign;
3247                         v->value.decimal.frac = 0;
3248                         v->value.decimal.total = ret;
3249                         *val = v;
3250                     }
3251                 }
3252                 goto return0;
3253             }
3254         case XML_SCHEMAS_UINT:
3255         case XML_SCHEMAS_ULONG:
3256         case XML_SCHEMAS_USHORT:
3257         case XML_SCHEMAS_UBYTE:{
3258                 const xmlChar *cur = value;
3259                 unsigned long lo, mi, hi;
3260
3261                 if (cur == NULL)
3262                     goto return1;
3263                 ret = xmlSchemaParseUInt(&cur, &lo, &mi, &hi);
3264                 if (ret < 0)
3265                     goto return1;
3266                 if (*cur != 0)
3267                     goto return1;
3268                 if (type->builtInType == XML_SCHEMAS_ULONG) {
3269                     if (hi >= 1844) {
3270                         if (hi > 1844)
3271                             goto return1;
3272                         if (mi >= 67440737) {
3273                             if (mi > 67440737)
3274                                 goto return1;
3275                             if (lo > 9551615)
3276                                 goto return1;
3277                         }
3278                     }
3279                 } else if (type->builtInType == XML_SCHEMAS_UINT) {
3280                     if (hi != 0)
3281                         goto return1;
3282                     if (mi >= 42) {
3283                         if (mi > 42)
3284                             goto return1;
3285                         if (lo > 94967295)
3286                             goto return1;
3287                     }
3288                 } else if (type->builtInType == XML_SCHEMAS_USHORT) {
3289                     if ((mi != 0) || (hi != 0))
3290                         goto return1;
3291                     if (lo > 65535)
3292                         goto return1;
3293                 } else if (type->builtInType == XML_SCHEMAS_UBYTE) {
3294                     if ((mi != 0) || (hi != 0))
3295                         goto return1;
3296                     if (lo > 255)
3297                         goto return1;
3298                 }
3299                 if (val != NULL) {
3300                     v = xmlSchemaNewValue(type->builtInType);
3301                     if (v != NULL) {
3302                         v->value.decimal.lo = lo;
3303                         v->value.decimal.mi = mi;
3304                         v->value.decimal.hi = hi;
3305                         v->value.decimal.sign = 0;
3306                         v->value.decimal.frac = 0;
3307                         v->value.decimal.total = ret;
3308                         *val = v;
3309                     }
3310                 }
3311                 goto return0;
3312             }
3313     }
3314
3315   done:
3316     if (norm != NULL)
3317         xmlFree(norm);
3318     return (ret);
3319   return3:
3320     if (norm != NULL)
3321         xmlFree(norm);
3322     return (3);
3323   return1:
3324     if (norm != NULL)
3325         xmlFree(norm);
3326     return (1);
3327   return0:
3328     if (norm != NULL)
3329         xmlFree(norm);
3330     return (0);
3331   error:
3332     if (norm != NULL)
3333         xmlFree(norm);
3334     return (-1);
3335 }
3336
3337 /**
3338  * xmlSchemaValPredefTypeNode:
3339  * @type: the predefined type
3340  * @value: the value to check
3341  * @val:  the return computed value
3342  * @node:  the node containing the value
3343  *
3344  * Check that a value conforms to the lexical space of the predefined type.
3345  * if true a value is computed and returned in @val.
3346  *
3347  * Returns 0 if this validates, a positive error code number otherwise
3348  *         and -1 in case of internal or API error.
3349  */
3350 int
3351 xmlSchemaValPredefTypeNode(xmlSchemaTypePtr type, const xmlChar *value,
3352                            xmlSchemaValPtr *val, xmlNodePtr node) {
3353     return(xmlSchemaValAtomicType(type, value, val, node, 0,
3354         XML_SCHEMA_WHITESPACE_UNKNOWN, 1, 1, 0));
3355 }
3356
3357 /**
3358  * xmlSchemaValPredefTypeNodeNoNorm:
3359  * @type: the predefined type
3360  * @value: the value to check
3361  * @val:  the return computed value
3362  * @node:  the node containing the value
3363  *
3364  * Check that a value conforms to the lexical space of the predefined type.
3365  * if true a value is computed and returned in @val.
3366  * This one does apply any normalization to the value.
3367  *
3368  * Returns 0 if this validates, a positive error code number otherwise
3369  *         and -1 in case of internal or API error.
3370  */
3371 int
3372 xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, const xmlChar *value,
3373                                  xmlSchemaValPtr *val, xmlNodePtr node) {
3374     return(xmlSchemaValAtomicType(type, value, val, node, 1,
3375         XML_SCHEMA_WHITESPACE_UNKNOWN, 1, 0, 1));
3376 }
3377
3378 /**
3379  * xmlSchemaValidatePredefinedType:
3380  * @type: the predefined type
3381  * @value: the value to check
3382  * @val:  the return computed value
3383  *
3384  * Check that a value conforms to the lexical space of the predefined type.
3385  * if true a value is computed and returned in @val.
3386  *
3387  * Returns 0 if this validates, a positive error code number otherwise
3388  *         and -1 in case of internal or API error.
3389  */
3390 int
3391 xmlSchemaValidatePredefinedType(xmlSchemaTypePtr type, const xmlChar *value,
3392                                 xmlSchemaValPtr *val) {
3393     return(xmlSchemaValPredefTypeNode(type, value, val, NULL));
3394 }
3395
3396 /**
3397  * xmlSchemaCompareDecimals:
3398  * @x:  a first decimal value
3399  * @y:  a second decimal value
3400  *
3401  * Compare 2 decimals
3402  *
3403  * Returns -1 if x < y, 0 if x == y, 1 if x > y and -2 in case of error
3404  */
3405 static int
3406 xmlSchemaCompareDecimals(xmlSchemaValPtr x, xmlSchemaValPtr y)
3407 {
3408     xmlSchemaValPtr swp;
3409     int order = 1, integx, integy, dlen;
3410     unsigned long hi, mi, lo;
3411
3412     /*
3413      * First test: If x is -ve and not zero
3414      */
3415     if ((x->value.decimal.sign) &&
3416         ((x->value.decimal.lo != 0) ||
3417          (x->value.decimal.mi != 0) ||
3418          (x->value.decimal.hi != 0))) {
3419         /*
3420          * Then if y is -ve and not zero reverse the compare
3421          */
3422         if ((y->value.decimal.sign) &&
3423             ((y->value.decimal.lo != 0) ||
3424              (y->value.decimal.mi != 0) ||
3425              (y->value.decimal.hi != 0)))
3426             order = -1;
3427         /*
3428          * Otherwise (y >= 0) we have the answer
3429          */
3430         else
3431             return (-1);
3432     /*
3433      * If x is not -ve and y is -ve we have the answer
3434      */
3435     } else if ((y->value.decimal.sign) &&
3436                ((y->value.decimal.lo != 0) ||
3437                 (y->value.decimal.mi != 0) ||
3438                 (y->value.decimal.hi != 0))) {
3439         return (1);
3440     }
3441     /*
3442      * If it's not simply determined by a difference in sign,
3443      * then we need to compare the actual values of the two nums.
3444      * To do this, we start by looking at the integral parts.
3445      * If the number of integral digits differ, then we have our
3446      * answer.
3447      */
3448     integx = x->value.decimal.total - x->value.decimal.frac;
3449     integy = y->value.decimal.total - y->value.decimal.frac;
3450     /*
3451     * NOTE: We changed the "total" for values like "0.1"
3452     *   (or "-0.1" or ".1") to be 1, which was 2 previously.
3453     *   Therefore the special case, when such values are
3454     *   compared with 0, needs to be handled separately;
3455     *   otherwise a zero would be recognized incorrectly as
3456     *   greater than those values. This has the nice side effect
3457     *   that we gain an overall optimized comparison with zeroes.
3458     * Note that a "0" has a "total" of 1 already.
3459     */
3460     if (integx == 1) {
3461         if (x->value.decimal.lo == 0) {
3462             if (integy != 1)
3463                 return -order;
3464             else if (y->value.decimal.lo != 0)
3465                 return -order;
3466             else
3467                 return(0);
3468         }
3469     }
3470     if (integy == 1) {
3471         if (y->value.decimal.lo == 0) {
3472             if (integx != 1)
3473                 return order;
3474             else if (x->value.decimal.lo != 0)
3475                 return order;
3476             else
3477                 return(0);
3478         }
3479     }
3480
3481     if (integx > integy)
3482         return order;
3483     else if (integy > integx)
3484         return -order;
3485
3486     /*
3487      * If the number of integral digits is the same for both numbers,
3488      * then things get a little more complicated.  We need to "normalize"
3489      * the numbers in order to properly compare them.  To do this, we
3490      * look at the total length of each number (length => number of
3491      * significant digits), and divide the "shorter" by 10 (decreasing
3492      * the length) until they are of equal length.
3493      */
3494     dlen = x->value.decimal.total - y->value.decimal.total;
3495     if (dlen < 0) {     /* y has more digits than x */
3496         swp = x;
3497         hi = y->value.decimal.hi;
3498         mi = y->value.decimal.mi;
3499         lo = y->value.decimal.lo;
3500         dlen = -dlen;
3501         order = -order;
3502     } else {            /* x has more digits than y */
3503         swp = y;
3504         hi = x->value.decimal.hi;
3505         mi = x->value.decimal.mi;
3506         lo = x->value.decimal.lo;
3507     }
3508     while (dlen > 8) {  /* in effect, right shift by 10**8 */
3509         lo = mi;
3510         mi = hi;
3511         hi = 0;
3512         dlen -= 8;
3513     }
3514     while (dlen > 0) {
3515         unsigned long rem1, rem2;
3516         rem1 = (hi % 10) * 100000000L;
3517         hi = hi / 10;
3518         rem2 = (mi % 10) * 100000000L;
3519         mi = (mi + rem1) / 10;
3520         lo = (lo + rem2) / 10;
3521         dlen--;
3522     }
3523     if (hi > swp->value.decimal.hi) {
3524         return order;
3525     } else if (hi == swp->value.decimal.hi) {
3526         if (mi > swp->value.decimal.mi) {
3527             return order;
3528         } else if (mi == swp->value.decimal.mi) {
3529             if (lo > swp->value.decimal.lo) {
3530                 return order;
3531             } else if (lo == swp->value.decimal.lo) {
3532                 if (x->value.decimal.total == y->value.decimal.total) {
3533                     return 0;
3534                 } else {
3535                     return order;
3536                 }
3537             }
3538         }
3539     }
3540     return -order;
3541 }
3542
3543 /**
3544  * xmlSchemaCompareDurations:
3545  * @x:  a first duration value
3546  * @y:  a second duration value
3547  *
3548  * Compare 2 durations
3549  *
3550  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
3551  * case of error
3552  */
3553 static int
3554 xmlSchemaCompareDurations(xmlSchemaValPtr x, xmlSchemaValPtr y)
3555 {
3556     long carry, mon, day;
3557     double sec;
3558     int invert = 1;
3559     long xmon, xday, myear, minday, maxday;
3560     static const long dayRange [2][12] = {
3561         { 0, 28, 59, 89, 120, 150, 181, 212, 242, 273, 303, 334, },
3562         { 0, 31, 62, 92, 123, 153, 184, 215, 245, 276, 306, 337} };
3563
3564     if ((x == NULL) || (y == NULL))
3565         return -2;
3566
3567     /* months */
3568     mon = x->value.dur.mon - y->value.dur.mon;
3569
3570     /* seconds */
3571     sec = x->value.dur.sec - y->value.dur.sec;
3572     carry = (long)sec / SECS_PER_DAY;
3573     sec -= (double)(carry * SECS_PER_DAY);
3574
3575     /* days */
3576     day = x->value.dur.day - y->value.dur.day + carry;
3577
3578     /* easy test */
3579     if (mon == 0) {
3580         if (day == 0)
3581             if (sec == 0.0)
3582                 return 0;
3583             else if (sec < 0.0)
3584                 return -1;
3585             else
3586                 return 1;
3587         else if (day < 0)
3588             return -1;
3589         else
3590             return 1;
3591     }
3592
3593     if (mon > 0) {
3594         if ((day >= 0) && (sec >= 0.0))
3595             return 1;
3596         else {
3597             xmon = mon;
3598             xday = -day;
3599         }
3600     } else if ((day <= 0) && (sec <= 0.0)) {
3601         return -1;
3602     } else {
3603         invert = -1;
3604         xmon = -mon;
3605         xday = day;
3606     }
3607
3608     myear = xmon / 12;
3609     if (myear == 0) {
3610         minday = 0;
3611         maxday = 0;
3612     } else {
3613         maxday = 366 * ((myear + 3) / 4) +
3614                  365 * ((myear - 1) % 4);
3615         minday = maxday - 1;
3616     }
3617
3618     xmon = xmon % 12;
3619     minday += dayRange[0][xmon];
3620     maxday += dayRange[1][xmon];
3621
3622     if ((maxday == minday) && (maxday == xday))
3623         return(0); /* can this really happen ? */
3624     if (maxday < xday)
3625         return(-invert);
3626     if (minday > xday)
3627         return(invert);
3628
3629     /* indeterminate */
3630     return 2;
3631 }
3632
3633 /*
3634  * macros for adding date/times and durations
3635  */
3636 #define FQUOTIENT(a,b)                  (floor(((double)a/(double)b)))
3637 #define MODULO(a,b)                     (a - FQUOTIENT(a,b) * b)
3638 #define FQUOTIENT_RANGE(a,low,high)     (FQUOTIENT((a-low),(high-low)))
3639 #define MODULO_RANGE(a,low,high)        ((MODULO((a-low),(high-low)))+low)
3640
3641 /**
3642  * xmlSchemaDupVal:
3643  * @v: the #xmlSchemaValPtr value to duplicate
3644  *
3645  * Makes a copy of @v. The calling program is responsible for freeing
3646  * the returned value.
3647  *
3648  * returns a pointer to a duplicated #xmlSchemaValPtr or NULL if error.
3649  */
3650 static xmlSchemaValPtr
3651 xmlSchemaDupVal (xmlSchemaValPtr v)
3652 {
3653     xmlSchemaValPtr ret = xmlSchemaNewValue(v->type);
3654     if (ret == NULL)
3655         return NULL;
3656
3657     memcpy(ret, v, sizeof(xmlSchemaVal));
3658     ret->next = NULL;
3659     return ret;
3660 }
3661
3662 /**
3663  * xmlSchemaCopyValue:
3664  * @val:  the precomputed value to be copied
3665  *
3666  * Copies the precomputed value. This duplicates any string within.
3667  *
3668  * Returns the copy or NULL if a copy for a data-type is not implemented.
3669  */
3670 xmlSchemaValPtr
3671 xmlSchemaCopyValue(xmlSchemaValPtr val)
3672 {
3673     xmlSchemaValPtr ret = NULL, prev = NULL, cur;
3674
3675     /*
3676     * Copy the string values.
3677     */
3678     while (val != NULL) {
3679         switch (val->type) {
3680             case XML_SCHEMAS_ANYTYPE:
3681             case XML_SCHEMAS_IDREFS:
3682             case XML_SCHEMAS_ENTITIES:
3683             case XML_SCHEMAS_NMTOKENS:
3684                 xmlSchemaFreeValue(ret);
3685                 return (NULL);
3686             case XML_SCHEMAS_ANYSIMPLETYPE:
3687             case XML_SCHEMAS_STRING:
3688             case XML_SCHEMAS_NORMSTRING:
3689             case XML_SCHEMAS_TOKEN:
3690             case XML_SCHEMAS_LANGUAGE:
3691             case XML_SCHEMAS_NAME:
3692             case XML_SCHEMAS_NCNAME:
3693             case XML_SCHEMAS_ID:
3694             case XML_SCHEMAS_IDREF:
3695             case XML_SCHEMAS_ENTITY:
3696             case XML_SCHEMAS_NMTOKEN:
3697             case XML_SCHEMAS_ANYURI:
3698                 cur = xmlSchemaDupVal(val);
3699                 if (val->value.str != NULL)
3700                     cur->value.str = xmlStrdup(BAD_CAST val->value.str);
3701                 break;
3702             case XML_SCHEMAS_QNAME:
3703             case XML_SCHEMAS_NOTATION:
3704                 cur = xmlSchemaDupVal(val);
3705                 if (val->value.qname.name != NULL)
3706                     cur->value.qname.name =
3707                     xmlStrdup(BAD_CAST val->value.qname.name);
3708                 if (val->value.qname.uri != NULL)
3709                     cur->value.qname.uri =
3710                     xmlStrdup(BAD_CAST val->value.qname.uri);
3711                 break;
3712             case XML_SCHEMAS_HEXBINARY:
3713                 cur = xmlSchemaDupVal(val);
3714                 if (val->value.hex.str != NULL)
3715                     cur->value.hex.str = xmlStrdup(BAD_CAST val->value.hex.str);
3716                 break;
3717             case XML_SCHEMAS_BASE64BINARY:
3718                 cur = xmlSchemaDupVal(val);
3719                 if (val->value.base64.str != NULL)
3720                     cur->value.base64.str =
3721                     xmlStrdup(BAD_CAST val->value.base64.str);
3722                 break;
3723             default:
3724                 cur = xmlSchemaDupVal(val);
3725                 break;
3726         }
3727         if (ret == NULL)
3728             ret = cur;
3729         else
3730             prev->next = cur;
3731         prev = cur;
3732         val = val->next;
3733     }
3734     return (ret);
3735 }
3736
3737 /**
3738  * _xmlSchemaDateAdd:
3739  * @dt: an #xmlSchemaValPtr
3740  * @dur: an #xmlSchemaValPtr of type #XS_DURATION
3741  *
3742  * Compute a new date/time from @dt and @dur. This function assumes @dt
3743  * is either #XML_SCHEMAS_DATETIME, #XML_SCHEMAS_DATE, #XML_SCHEMAS_GYEARMONTH,
3744  * or #XML_SCHEMAS_GYEAR. The returned #xmlSchemaVal is the same type as
3745  * @dt. The calling program is responsible for freeing the returned value.
3746  *
3747  * Returns a pointer to a new #xmlSchemaVal or NULL if error.
3748  */
3749 static xmlSchemaValPtr
3750 _xmlSchemaDateAdd (xmlSchemaValPtr dt, xmlSchemaValPtr dur)
3751 {
3752     xmlSchemaValPtr ret, tmp;
3753     long carry, tempdays, temp;
3754     xmlSchemaValDatePtr r, d;
3755     xmlSchemaValDurationPtr u;
3756
3757     if ((dt == NULL) || (dur == NULL))
3758         return NULL;
3759
3760     ret = xmlSchemaNewValue(dt->type);
3761     if (ret == NULL)
3762         return NULL;
3763
3764     /* make a copy so we don't alter the original value */
3765     tmp = xmlSchemaDupVal(dt);
3766     if (tmp == NULL) {
3767         xmlSchemaFreeValue(ret);
3768         return NULL;
3769     }
3770
3771     r = &(ret->value.date);
3772     d = &(tmp->value.date);
3773     u = &(dur->value.dur);
3774
3775     /* normalization */
3776     if (d->mon == 0)
3777         d->mon = 1;
3778
3779     /* normalize for time zone offset */
3780     u->sec -= (d->tzo * 60);
3781     d->tzo = 0;
3782
3783     /* normalization */
3784     if (d->day == 0)
3785         d->day = 1;
3786
3787     /* month */
3788     carry  = d->mon + u->mon;
3789     r->mon = (unsigned int) MODULO_RANGE(carry, 1, 13);
3790     carry  = (long) FQUOTIENT_RANGE(carry, 1, 13);
3791
3792     /* year (may be modified later) */
3793     r->year = d->year + carry;
3794     if (r->year == 0) {
3795         if (d->year > 0)
3796             r->year--;
3797         else
3798             r->year++;
3799     }
3800
3801     /* time zone */
3802     r->tzo     = d->tzo;
3803     r->tz_flag = d->tz_flag;
3804
3805     /* seconds */
3806     r->sec = d->sec + u->sec;
3807     carry  = (long) FQUOTIENT((long)r->sec, 60);
3808     if (r->sec != 0.0) {
3809         r->sec = MODULO(r->sec, 60.0);
3810     }
3811
3812     /* minute */
3813     carry += d->min;
3814     r->min = (unsigned int) MODULO(carry, 60);
3815     carry  = (long) FQUOTIENT(carry, 60);
3816
3817     /* hours */
3818     carry  += d->hour;
3819     r->hour = (unsigned int) MODULO(carry, 24);
3820     carry   = (long)FQUOTIENT(carry, 24);
3821
3822     /*
3823      * days
3824      * Note we use tempdays because the temporary values may need more
3825      * than 5 bits
3826      */
3827     if ((VALID_YEAR(r->year)) && (VALID_MONTH(r->mon)) &&
3828                   (d->day > MAX_DAYINMONTH(r->year, r->mon)))
3829         tempdays = MAX_DAYINMONTH(r->year, r->mon);
3830     else if (d->day < 1)
3831         tempdays = 1;
3832     else
3833         tempdays = d->day;
3834
3835     tempdays += u->day + carry;
3836
3837     while (1) {
3838         if (tempdays < 1) {
3839             long tmon = (long) MODULO_RANGE((int)r->mon-1, 1, 13);
3840             long tyr  = r->year + (long)FQUOTIENT_RANGE((int)r->mon-1, 1, 13);
3841             if (tyr == 0)
3842                 tyr--;
3843             /*
3844              * Coverity detected an overrun in daysInMonth
3845              * of size 12 at position 12 with index variable "((r)->mon - 1)"
3846              */
3847             if (tmon < 0)
3848                 tmon = 0;
3849             if (tmon > 12)
3850                 tmon = 12;
3851             tempdays += MAX_DAYINMONTH(tyr, tmon);
3852             carry = -1;
3853         } else if (tempdays > (long) MAX_DAYINMONTH(r->year, r->mon)) {
3854             tempdays = tempdays - MAX_DAYINMONTH(r->year, r->mon);
3855             carry = 1;
3856         } else
3857             break;
3858
3859         temp = r->mon + carry;
3860         r->mon = (unsigned int) MODULO_RANGE(temp, 1, 13);
3861         r->year = r->year + (unsigned int) FQUOTIENT_RANGE(temp, 1, 13);
3862         if (r->year == 0) {
3863             if (temp < 1)
3864                 r->year--;
3865             else
3866                 r->year++;
3867         }
3868     }
3869
3870     r->day = tempdays;
3871
3872     /*
3873      * adjust the date/time type to the date values
3874      */
3875     if (ret->type != XML_SCHEMAS_DATETIME) {
3876         if ((r->hour) || (r->min) || (r->sec))
3877             ret->type = XML_SCHEMAS_DATETIME;
3878         else if (ret->type != XML_SCHEMAS_DATE) {
3879             if ((r->mon != 1) && (r->day != 1))
3880                 ret->type = XML_SCHEMAS_DATE;
3881             else if ((ret->type != XML_SCHEMAS_GYEARMONTH) && (r->mon != 1))
3882                 ret->type = XML_SCHEMAS_GYEARMONTH;
3883         }
3884     }
3885
3886     xmlSchemaFreeValue(tmp);
3887
3888     return ret;
3889 }
3890
3891 /**
3892  * xmlSchemaDateNormalize:
3893  * @dt: an #xmlSchemaValPtr of a date/time type value.
3894  * @offset: number of seconds to adjust @dt by.
3895  *
3896  * Normalize @dt to GMT time. The @offset parameter is subtracted from
3897  * the return value is a time-zone offset is present on @dt.
3898  *
3899  * Returns a normalized copy of @dt or NULL if error.
3900  */
3901 static xmlSchemaValPtr
3902 xmlSchemaDateNormalize (xmlSchemaValPtr dt, double offset)
3903 {
3904     xmlSchemaValPtr dur, ret;
3905
3906     if (dt == NULL)
3907         return NULL;
3908
3909     if (((dt->type != XML_SCHEMAS_TIME) &&
3910          (dt->type != XML_SCHEMAS_DATETIME) &&
3911          (dt->type != XML_SCHEMAS_DATE)) || (dt->value.date.tzo == 0))
3912         return xmlSchemaDupVal(dt);
3913
3914     dur = xmlSchemaNewValue(XML_SCHEMAS_DURATION);
3915     if (dur == NULL)
3916         return NULL;
3917
3918     dur->value.date.sec -= offset;
3919
3920     ret = _xmlSchemaDateAdd(dt, dur);
3921     if (ret == NULL)
3922         return NULL;
3923
3924     xmlSchemaFreeValue(dur);
3925
3926     /* ret->value.date.tzo = 0; */
3927     return ret;
3928 }
3929
3930 /**
3931  * _xmlSchemaDateCastYMToDays:
3932  * @dt: an #xmlSchemaValPtr
3933  *
3934  * Convert mon and year of @dt to total number of days. Take the
3935  * number of years since (or before) 1 AD and add the number of leap
3936  * years. This is a function  because negative
3937  * years must be handled a little differently and there is no zero year.
3938  *
3939  * Returns number of days.
3940  */
3941 static long
3942 _xmlSchemaDateCastYMToDays (const xmlSchemaValPtr dt)
3943 {
3944     long ret;
3945     int mon;
3946
3947     mon = dt->value.date.mon;
3948     if (mon <= 0) mon = 1; /* normalization */
3949
3950     if (dt->value.date.year <= 0)
3951         ret = (dt->value.date.year * 365) +
3952               (((dt->value.date.year+1)/4)-((dt->value.date.year+1)/100)+
3953                ((dt->value.date.year+1)/400)) +
3954               DAY_IN_YEAR(0, mon, dt->value.date.year);
3955     else
3956         ret = ((dt->value.date.year-1) * 365) +
3957               (((dt->value.date.year-1)/4)-((dt->value.date.year-1)/100)+
3958                ((dt->value.date.year-1)/400)) +
3959               DAY_IN_YEAR(0, mon, dt->value.date.year);
3960
3961     return ret;
3962 }
3963
3964 /**
3965  * TIME_TO_NUMBER:
3966  * @dt:  an #xmlSchemaValPtr
3967  *
3968  * Calculates the number of seconds in the time portion of @dt.
3969  *
3970  * Returns seconds.
3971  */
3972 #define TIME_TO_NUMBER(dt)                              \
3973     ((double)((dt->value.date.hour * SECS_PER_HOUR) +   \
3974               (dt->value.date.min * SECS_PER_MIN) +     \
3975               (dt->value.date.tzo * SECS_PER_MIN)) +    \
3976                dt->value.date.sec)
3977
3978 /**
3979  * xmlSchemaCompareDates:
3980  * @x:  a first date/time value
3981  * @y:  a second date/time value
3982  *
3983  * Compare 2 date/times
3984  *
3985  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
3986  * case of error
3987  */
3988 static int
3989 xmlSchemaCompareDates (xmlSchemaValPtr x, xmlSchemaValPtr y)
3990 {
3991     unsigned char xmask, ymask, xor_mask, and_mask;
3992     xmlSchemaValPtr p1, p2, q1, q2;
3993     long p1d, p2d, q1d, q2d;
3994
3995     if ((x == NULL) || (y == NULL))
3996         return -2;
3997
3998     if (x->value.date.tz_flag) {
3999
4000         if (!y->value.date.tz_flag) {
4001             p1 = xmlSchemaDateNormalize(x, 0);
4002             p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
4003             /* normalize y + 14:00 */
4004             q1 = xmlSchemaDateNormalize(y, (14 * SECS_PER_HOUR));
4005
4006             q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
4007             if (p1d < q1d) {
4008                 xmlSchemaFreeValue(p1);
4009                 xmlSchemaFreeValue(q1);
4010                 return -1;
4011             } else if (p1d == q1d) {
4012                 double sec;
4013
4014                 sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
4015                 if (sec < 0.0) {
4016                     xmlSchemaFreeValue(p1);
4017                     xmlSchemaFreeValue(q1);
4018                     return -1;
4019                 } else {
4020                     int ret = 0;
4021                     /* normalize y - 14:00 */
4022                     q2 = xmlSchemaDateNormalize(y, -(14 * SECS_PER_HOUR));
4023                     q2d = _xmlSchemaDateCastYMToDays(q2) + q2->value.date.day;
4024                     if (p1d > q2d)
4025                         ret = 1;
4026                     else if (p1d == q2d) {
4027                         sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q2);
4028                         if (sec > 0.0)
4029                             ret = 1;
4030                         else
4031                             ret = 2; /* indeterminate */
4032                     }
4033                     xmlSchemaFreeValue(p1);
4034                     xmlSchemaFreeValue(q1);
4035                     xmlSchemaFreeValue(q2);
4036                     if (ret != 0)
4037                         return(ret);
4038                 }
4039             } else {
4040                 xmlSchemaFreeValue(p1);
4041                 xmlSchemaFreeValue(q1);
4042             }
4043         }
4044     } else if (y->value.date.tz_flag) {
4045         q1 = xmlSchemaDateNormalize(y, 0);
4046         q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
4047
4048         /* normalize x - 14:00 */
4049         p1 = xmlSchemaDateNormalize(x, -(14 * SECS_PER_HOUR));
4050         p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
4051
4052         if (p1d < q1d) {
4053             xmlSchemaFreeValue(p1);
4054             xmlSchemaFreeValue(q1);
4055             return -1;
4056         } else if (p1d == q1d) {
4057             double sec;
4058
4059             sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
4060             if (sec < 0.0) {
4061                 xmlSchemaFreeValue(p1);
4062                 xmlSchemaFreeValue(q1);
4063                 return -1;
4064             } else {
4065                 int ret = 0;
4066                 /* normalize x + 14:00 */
4067                 p2 = xmlSchemaDateNormalize(x, (14 * SECS_PER_HOUR));
4068                 p2d = _xmlSchemaDateCastYMToDays(p2) + p2->value.date.day;
4069
4070                 if (p2d > q1d) {
4071                     ret = 1;
4072                 } else if (p2d == q1d) {
4073                     sec = TIME_TO_NUMBER(p2) - TIME_TO_NUMBER(q1);
4074                     if (sec > 0.0)
4075                         ret = 1;
4076                     else
4077                         ret = 2; /* indeterminate */
4078                 }
4079                 xmlSchemaFreeValue(p1);
4080                 xmlSchemaFreeValue(q1);
4081                 xmlSchemaFreeValue(p2);
4082                 if (ret != 0)
4083                     return(ret);
4084             }
4085         } else {
4086             xmlSchemaFreeValue(p1);
4087             xmlSchemaFreeValue(q1);
4088         }
4089     }
4090
4091     /*
4092      * if the same type then calculate the difference
4093      */
4094     if (x->type == y->type) {
4095         int ret = 0;
4096         q1 = xmlSchemaDateNormalize(y, 0);
4097         q1d = _xmlSchemaDateCastYMToDays(q1) + q1->value.date.day;
4098
4099         p1 = xmlSchemaDateNormalize(x, 0);
4100         p1d = _xmlSchemaDateCastYMToDays(p1) + p1->value.date.day;
4101
4102         if (p1d < q1d) {
4103             ret = -1;
4104         } else if (p1d > q1d) {
4105             ret = 1;
4106         } else {
4107             double sec;
4108
4109             sec = TIME_TO_NUMBER(p1) - TIME_TO_NUMBER(q1);
4110             if (sec < 0.0)
4111                 ret = -1;
4112             else if (sec > 0.0)
4113                 ret = 1;
4114
4115         }
4116         xmlSchemaFreeValue(p1);
4117         xmlSchemaFreeValue(q1);
4118         return(ret);
4119     }
4120
4121     switch (x->type) {
4122         case XML_SCHEMAS_DATETIME:
4123             xmask = 0xf;
4124             break;
4125         case XML_SCHEMAS_DATE:
4126             xmask = 0x7;
4127             break;
4128         case XML_SCHEMAS_GYEAR:
4129             xmask = 0x1;
4130             break;
4131         case XML_SCHEMAS_GMONTH:
4132             xmask = 0x2;
4133             break;
4134         case XML_SCHEMAS_GDAY:
4135             xmask = 0x3;
4136             break;
4137         case XML_SCHEMAS_GYEARMONTH:
4138             xmask = 0x3;
4139             break;
4140         case XML_SCHEMAS_GMONTHDAY:
4141             xmask = 0x6;
4142             break;
4143         case XML_SCHEMAS_TIME:
4144             xmask = 0x8;
4145             break;
4146         default:
4147             xmask = 0;
4148             break;
4149     }
4150
4151     switch (y->type) {
4152         case XML_SCHEMAS_DATETIME:
4153             ymask = 0xf;
4154             break;
4155         case XML_SCHEMAS_DATE:
4156             ymask = 0x7;
4157             break;
4158         case XML_SCHEMAS_GYEAR:
4159             ymask = 0x1;
4160             break;
4161         case XML_SCHEMAS_GMONTH:
4162             ymask = 0x2;
4163             break;
4164         case XML_SCHEMAS_GDAY:
4165             ymask = 0x3;
4166             break;
4167         case XML_SCHEMAS_GYEARMONTH:
4168             ymask = 0x3;
4169             break;
4170         case XML_SCHEMAS_GMONTHDAY:
4171             ymask = 0x6;
4172             break;
4173         case XML_SCHEMAS_TIME:
4174             ymask = 0x8;
4175             break;
4176         default:
4177             ymask = 0;
4178             break;
4179     }
4180
4181     xor_mask = xmask ^ ymask;           /* mark type differences */
4182     and_mask = xmask & ymask;           /* mark field specification */
4183
4184     /* year */
4185     if (xor_mask & 1)
4186         return 2; /* indeterminate */
4187     else if (and_mask & 1) {
4188         if (x->value.date.year < y->value.date.year)
4189             return -1;
4190         else if (x->value.date.year > y->value.date.year)
4191             return 1;
4192     }
4193
4194     /* month */
4195     if (xor_mask & 2)
4196         return 2; /* indeterminate */
4197     else if (and_mask & 2) {
4198         if (x->value.date.mon < y->value.date.mon)
4199             return -1;
4200         else if (x->value.date.mon > y->value.date.mon)
4201             return 1;
4202     }
4203
4204     /* day */
4205     if (xor_mask & 4)
4206         return 2; /* indeterminate */
4207     else if (and_mask & 4) {
4208         if (x->value.date.day < y->value.date.day)
4209             return -1;
4210         else if (x->value.date.day > y->value.date.day)
4211             return 1;
4212     }
4213
4214     /* time */
4215     if (xor_mask & 8)
4216         return 2; /* indeterminate */
4217     else if (and_mask & 8) {
4218         if (x->value.date.hour < y->value.date.hour)
4219             return -1;
4220         else if (x->value.date.hour > y->value.date.hour)
4221             return 1;
4222         else if (x->value.date.min < y->value.date.min)
4223             return -1;
4224         else if (x->value.date.min > y->value.date.min)
4225             return 1;
4226         else if (x->value.date.sec < y->value.date.sec)
4227             return -1;
4228         else if (x->value.date.sec > y->value.date.sec)
4229             return 1;
4230     }
4231
4232     return 0;
4233 }
4234
4235 /**
4236  * xmlSchemaComparePreserveReplaceStrings:
4237  * @x:  a first string value
4238  * @y:  a second string value
4239  * @invert: inverts the result if x < y or x > y.
4240  *
4241  * Compare 2 string for their normalized values.
4242  * @x is a string with whitespace of "preserve", @y is
4243  * a string with a whitespace of "replace". I.e. @x could
4244  * be an "xsd:string" and @y an "xsd:normalizedString".
4245  *
4246  * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
4247  * case of error
4248  */
4249 static int
4250 xmlSchemaComparePreserveReplaceStrings(const xmlChar *x,
4251                                        const xmlChar *y,
4252                                        int invert)
4253 {
4254     int tmp;
4255
4256     while ((*x != 0) && (*y != 0)) {
4257         if (IS_WSP_REPLACE_CH(*y)) {
4258             if (! IS_WSP_SPACE_CH(*x)) {
4259                 if ((*x - 0x20) < 0) {
4260                     if (invert)
4261                         return(1);
4262                     else
4263                         return(-1);
4264                 } else {
4265                     if (invert)
4266                         return(-1);
4267                     else
4268                         return(1);
4269                 }
4270             }
4271         } else {
4272             tmp = *x - *y;
4273             if (tmp < 0) {
4274                 if (invert)
4275                     return(1);
4276                 else
4277                     return(-1);
4278             }
4279             if (tmp > 0) {
4280                 if (invert)
4281                     return(-1);
4282                 else
4283                     return(1);
4284             }
4285         }
4286         x++;
4287         y++;
4288     }
4289     if (*x != 0) {
4290         if (invert)
4291             return(-1);
4292         else
4293             return(1);
4294     }
4295     if (*y != 0) {
4296         if (invert)
4297             return(1);
4298         else
4299             return(-1);
4300     }
4301     return(0);
4302 }
4303
4304 /**
4305  * xmlSchemaComparePreserveCollapseStrings:
4306  * @x:  a first string value
4307  * @y:  a second string value
4308  *
4309  * Compare 2 string for their normalized values.
4310  * @x is a string with whitespace of "preserve", @y is
4311  * a string with a whitespace of "collapse". I.e. @x could
4312  * be an "xsd:string" and @y an "xsd:normalizedString".
4313  *
4314  * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
4315  * case of error
4316  */
4317 static int
4318 xmlSchemaComparePreserveCollapseStrings(const xmlChar *x,
4319                                         const xmlChar *y,
4320                                         int invert)
4321 {
4322     int tmp;
4323
4324     /*
4325     * Skip leading blank chars of the collapsed string.
4326     */
4327     while IS_WSP_BLANK_CH(*y)
4328         y++;
4329
4330     while ((*x != 0) && (*y != 0)) {
4331         if IS_WSP_BLANK_CH(*y) {
4332             if (! IS_WSP_SPACE_CH(*x)) {
4333                 /*
4334                 * The yv character would have been replaced to 0x20.
4335                 */
4336                 if ((*x - 0x20) < 0) {
4337                     if (invert)
4338                         return(1);
4339                     else
4340                         return(-1);
4341                 } else {
4342                     if (invert)
4343                         return(-1);
4344                     else
4345                         return(1);
4346                 }
4347             }
4348             x++;
4349             y++;
4350             /*
4351             * Skip contiguous blank chars of the collapsed string.
4352             */
4353             while IS_WSP_BLANK_CH(*y)
4354                 y++;
4355         } else {
4356             tmp = *x++ - *y++;
4357             if (tmp < 0) {
4358                 if (invert)
4359                     return(1);
4360                 else
4361                     return(-1);
4362             }
4363             if (tmp > 0) {
4364                 if (invert)
4365                     return(-1);
4366                 else
4367                     return(1);
4368             }
4369         }
4370     }
4371     if (*x != 0) {
4372          if (invert)
4373              return(-1);
4374          else
4375              return(1);
4376     }
4377     if (*y != 0) {
4378         /*
4379         * Skip trailing blank chars of the collapsed string.
4380         */
4381         while IS_WSP_BLANK_CH(*y)
4382             y++;
4383         if (*y != 0) {
4384             if (invert)
4385                 return(1);
4386             else
4387                 return(-1);
4388         }
4389     }
4390     return(0);
4391 }
4392
4393 /**
4394  * xmlSchemaComparePreserveCollapseStrings:
4395  * @x:  a first string value
4396  * @y:  a second string value
4397  *
4398  * Compare 2 string for their normalized values.
4399  * @x is a string with whitespace of "preserve", @y is
4400  * a string with a whitespace of "collapse". I.e. @x could
4401  * be an "xsd:string" and @y an "xsd:normalizedString".
4402  *
4403  * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
4404  * case of error
4405  */
4406 static int
4407 xmlSchemaCompareReplaceCollapseStrings(const xmlChar *x,
4408                                        const xmlChar *y,
4409                                        int invert)
4410 {
4411     int tmp;
4412
4413     /*
4414     * Skip leading blank chars of the collapsed string.
4415     */
4416     while IS_WSP_BLANK_CH(*y)
4417         y++;
4418
4419     while ((*x != 0) && (*y != 0)) {
4420         if IS_WSP_BLANK_CH(*y) {
4421             if (! IS_WSP_BLANK_CH(*x)) {
4422                 /*
4423                 * The yv character would have been replaced to 0x20.
4424                 */
4425                 if ((*x - 0x20) < 0) {
4426                     if (invert)
4427                         return(1);
4428                     else
4429                         return(-1);
4430                 } else {
4431                     if (invert)
4432                         return(-1);
4433                     else
4434                         return(1);
4435                 }
4436             }
4437             x++;
4438             y++;
4439             /*
4440             * Skip contiguous blank chars of the collapsed string.
4441             */
4442             while IS_WSP_BLANK_CH(*y)
4443                 y++;
4444         } else {
4445             if IS_WSP_BLANK_CH(*x) {
4446                 /*
4447                 * The xv character would have been replaced to 0x20.
4448                 */
4449                 if ((0x20 - *y) < 0) {
4450                     if (invert)
4451                         return(1);
4452                     else
4453                         return(-1);
4454                 } else {
4455                     if (invert)
4456                         return(-1);
4457                     else
4458                         return(1);
4459                 }
4460             }
4461             tmp = *x++ - *y++;
4462             if (tmp < 0)
4463                 return(-1);
4464             if (tmp > 0)
4465                 return(1);
4466         }
4467     }
4468     if (*x != 0) {
4469          if (invert)
4470              return(-1);
4471          else
4472              return(1);
4473     }
4474     if (*y != 0) {
4475         /*
4476         * Skip trailing blank chars of the collapsed string.
4477         */
4478         while IS_WSP_BLANK_CH(*y)
4479             y++;
4480         if (*y != 0) {
4481             if (invert)
4482                 return(1);
4483             else
4484                 return(-1);
4485         }
4486     }
4487     return(0);
4488 }
4489
4490
4491 /**
4492  * xmlSchemaCompareReplacedStrings:
4493  * @x:  a first string value
4494  * @y:  a second string value
4495  *
4496  * Compare 2 string for their normalized values.
4497  *
4498  * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
4499  * case of error
4500  */
4501 static int
4502 xmlSchemaCompareReplacedStrings(const xmlChar *x,
4503                                 const xmlChar *y)
4504 {
4505     int tmp;
4506
4507     while ((*x != 0) && (*y != 0)) {
4508         if IS_WSP_BLANK_CH(*y) {
4509             if (! IS_WSP_BLANK_CH(*x)) {
4510                 if ((*x - 0x20) < 0)
4511                     return(-1);
4512                 else
4513                     return(1);
4514             }
4515         } else {
4516             if IS_WSP_BLANK_CH(*x) {
4517                 if ((0x20 - *y) < 0)
4518                     return(-1);
4519                 else
4520                     return(1);
4521             }
4522             tmp = *x - *y;
4523             if (tmp < 0)
4524                 return(-1);
4525             if (tmp > 0)
4526                 return(1);
4527         }
4528         x++;
4529         y++;
4530     }
4531     if (*x != 0)
4532         return(1);
4533     if (*y != 0)
4534         return(-1);
4535     return(0);
4536 }
4537
4538 /**
4539  * xmlSchemaCompareNormStrings:
4540  * @x:  a first string value
4541  * @y:  a second string value
4542  *
4543  * Compare 2 string for their normalized values.
4544  *
4545  * Returns -1 if x < y, 0 if x == y, 1 if x > y, and -2 in
4546  * case of error
4547  */
4548 static int
4549 xmlSchemaCompareNormStrings(const xmlChar *x,
4550                             const xmlChar *y) {
4551     int tmp;
4552
4553     while (IS_BLANK_CH(*x)) x++;
4554     while (IS_BLANK_CH(*y)) y++;
4555     while ((*x != 0) && (*y != 0)) {
4556         if (IS_BLANK_CH(*x)) {
4557             if (!IS_BLANK_CH(*y)) {
4558                 tmp = *x - *y;
4559                 return(tmp);
4560             }
4561             while (IS_BLANK_CH(*x)) x++;
4562             while (IS_BLANK_CH(*y)) y++;
4563         } else {
4564             tmp = *x++ - *y++;
4565             if (tmp < 0)
4566                 return(-1);
4567             if (tmp > 0)
4568                 return(1);
4569         }
4570     }
4571     if (*x != 0) {
4572         while (IS_BLANK_CH(*x)) x++;
4573         if (*x != 0)
4574             return(1);
4575     }
4576     if (*y != 0) {
4577         while (IS_BLANK_CH(*y)) y++;
4578         if (*y != 0)
4579             return(-1);
4580     }
4581     return(0);
4582 }
4583
4584 /**
4585  * xmlSchemaCompareFloats:
4586  * @x:  a first float or double value
4587  * @y:  a second float or double value
4588  *
4589  * Compare 2 values
4590  *
4591  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
4592  * case of error
4593  */
4594 static int
4595 xmlSchemaCompareFloats(xmlSchemaValPtr x, xmlSchemaValPtr y) {
4596     double d1, d2;
4597
4598     if ((x == NULL) || (y == NULL))
4599         return(-2);
4600
4601     /*
4602      * Cast everything to doubles.
4603      */
4604     if (x->type == XML_SCHEMAS_DOUBLE)
4605         d1 = x->value.d;
4606     else if (x->type == XML_SCHEMAS_FLOAT)
4607         d1 = x->value.f;
4608     else
4609         return(-2);
4610
4611     if (y->type == XML_SCHEMAS_DOUBLE)
4612         d2 = y->value.d;
4613     else if (y->type == XML_SCHEMAS_FLOAT)
4614         d2 = y->value.f;
4615     else
4616         return(-2);
4617
4618     /*
4619      * Check for special cases.
4620      */
4621     if (xmlXPathIsNaN(d1)) {
4622         if (xmlXPathIsNaN(d2))
4623             return(0);
4624         return(1);
4625     }
4626     if (xmlXPathIsNaN(d2))
4627         return(-1);
4628     if (d1 == xmlXPathPINF) {
4629         if (d2 == xmlXPathPINF)
4630             return(0);
4631         return(1);
4632     }
4633     if (d2 == xmlXPathPINF)
4634         return(-1);
4635     if (d1 == xmlXPathNINF) {
4636         if (d2 == xmlXPathNINF)
4637             return(0);
4638         return(-1);
4639     }
4640     if (d2 == xmlXPathNINF)
4641         return(1);
4642
4643     /*
4644      * basic tests, the last one we should have equality, but
4645      * portability is more important than speed and handling
4646      * NaN or Inf in a portable way is always a challenge, so ...
4647      */
4648     if (d1 < d2)
4649         return(-1);
4650     if (d1 > d2)
4651         return(1);
4652     if (d1 == d2)
4653         return(0);
4654     return(2);
4655 }
4656
4657 /**
4658  * xmlSchemaCompareValues:
4659  * @x:  a first value
4660  * @xvalue: the first value as a string (optional)
4661  * @xwtsp: the whitespace type
4662  * @y:  a second value
4663  * @xvalue: the second value as a string (optional)
4664  * @ywtsp: the whitespace type
4665  *
4666  * Compare 2 values
4667  *
4668  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, 3 if not
4669  * comparable and -2 in case of error
4670  */
4671 static int
4672 xmlSchemaCompareValuesInternal(xmlSchemaValType xtype,
4673                                xmlSchemaValPtr x,
4674                                const xmlChar *xvalue,
4675                                xmlSchemaWhitespaceValueType xws,
4676                                xmlSchemaValType ytype,
4677                                xmlSchemaValPtr y,
4678                                const xmlChar *yvalue,
4679                                xmlSchemaWhitespaceValueType yws)
4680 {
4681     switch (xtype) {
4682         case XML_SCHEMAS_UNKNOWN:
4683         case XML_SCHEMAS_ANYTYPE:
4684             return(-2);
4685         case XML_SCHEMAS_INTEGER:
4686         case XML_SCHEMAS_NPINTEGER:
4687         case XML_SCHEMAS_NINTEGER:
4688         case XML_SCHEMAS_NNINTEGER:
4689         case XML_SCHEMAS_PINTEGER:
4690         case XML_SCHEMAS_INT:
4691         case XML_SCHEMAS_UINT:
4692         case XML_SCHEMAS_LONG:
4693         case XML_SCHEMAS_ULONG:
4694         case XML_SCHEMAS_SHORT:
4695         case XML_SCHEMAS_USHORT:
4696         case XML_SCHEMAS_BYTE:
4697         case XML_SCHEMAS_UBYTE:
4698         case XML_SCHEMAS_DECIMAL:
4699             if ((x == NULL) || (y == NULL))
4700                 return(-2);
4701             if (ytype == xtype)
4702                 return(xmlSchemaCompareDecimals(x, y));
4703             if ((ytype == XML_SCHEMAS_DECIMAL) ||
4704                 (ytype == XML_SCHEMAS_INTEGER) ||
4705                 (ytype == XML_SCHEMAS_NPINTEGER) ||
4706                 (ytype == XML_SCHEMAS_NINTEGER) ||
4707                 (ytype == XML_SCHEMAS_NNINTEGER) ||
4708                 (ytype == XML_SCHEMAS_PINTEGER) ||
4709                 (ytype == XML_SCHEMAS_INT) ||
4710                 (ytype == XML_SCHEMAS_UINT) ||
4711                 (ytype == XML_SCHEMAS_LONG) ||
4712                 (ytype == XML_SCHEMAS_ULONG) ||
4713                 (ytype == XML_SCHEMAS_SHORT) ||
4714                 (ytype == XML_SCHEMAS_USHORT) ||
4715                 (ytype == XML_SCHEMAS_BYTE) ||
4716                 (ytype == XML_SCHEMAS_UBYTE))
4717                 return(xmlSchemaCompareDecimals(x, y));
4718             return(-2);
4719         case XML_SCHEMAS_DURATION:
4720             if ((x == NULL) || (y == NULL))
4721                 return(-2);
4722             if (ytype == XML_SCHEMAS_DURATION)
4723                 return(xmlSchemaCompareDurations(x, y));
4724             return(-2);
4725         case XML_SCHEMAS_TIME:
4726         case XML_SCHEMAS_GDAY:
4727         case XML_SCHEMAS_GMONTH:
4728         case XML_SCHEMAS_GMONTHDAY:
4729         case XML_SCHEMAS_GYEAR:
4730         case XML_SCHEMAS_GYEARMONTH:
4731         case XML_SCHEMAS_DATE:
4732         case XML_SCHEMAS_DATETIME:
4733             if ((x == NULL) || (y == NULL))
4734                 return(-2);
4735             if ((ytype == XML_SCHEMAS_DATETIME)  ||
4736                 (ytype == XML_SCHEMAS_TIME)      ||
4737                 (ytype == XML_SCHEMAS_GDAY)      ||
4738                 (ytype == XML_SCHEMAS_GMONTH)    ||
4739                 (ytype == XML_SCHEMAS_GMONTHDAY) ||
4740                 (ytype == XML_SCHEMAS_GYEAR)     ||
4741                 (ytype == XML_SCHEMAS_DATE)      ||
4742                 (ytype == XML_SCHEMAS_GYEARMONTH))
4743                 return (xmlSchemaCompareDates(x, y));
4744             return (-2);
4745         /*
4746         * Note that we will support comparison of string types against
4747         * anySimpleType as well.
4748         */
4749         case XML_SCHEMAS_ANYSIMPLETYPE:
4750         case XML_SCHEMAS_STRING:
4751         case XML_SCHEMAS_NORMSTRING:
4752         case XML_SCHEMAS_TOKEN:
4753         case XML_SCHEMAS_LANGUAGE:
4754         case XML_SCHEMAS_NMTOKEN:
4755         case XML_SCHEMAS_NAME:
4756         case XML_SCHEMAS_NCNAME:
4757         case XML_SCHEMAS_ID:
4758         case XML_SCHEMAS_IDREF:
4759         case XML_SCHEMAS_ENTITY:
4760         case XML_SCHEMAS_ANYURI:
4761         {
4762             const xmlChar *xv, *yv;
4763
4764             if (x == NULL)
4765                 xv = xvalue;
4766             else
4767                 xv = x->value.str;
4768             if (y == NULL)
4769                 yv = yvalue;
4770             else
4771                 yv = y->value.str;
4772             /*
4773             * TODO: Compare those against QName.
4774             */
4775             if (ytype == XML_SCHEMAS_QNAME) {
4776                 TODO
4777                 if (y == NULL)
4778                     return(-2);
4779                 return (-2);
4780             }
4781             if ((ytype == XML_SCHEMAS_ANYSIMPLETYPE) ||
4782                 (ytype == XML_SCHEMAS_STRING) ||
4783                 (ytype == XML_SCHEMAS_NORMSTRING) ||
4784                 (ytype == XML_SCHEMAS_TOKEN) ||
4785                 (ytype == XML_SCHEMAS_LANGUAGE) ||
4786                 (ytype == XML_SCHEMAS_NMTOKEN) ||
4787                 (ytype == XML_SCHEMAS_NAME) ||
4788                 (ytype == XML_SCHEMAS_NCNAME) ||
4789                 (ytype == XML_SCHEMAS_ID) ||
4790                 (ytype == XML_SCHEMAS_IDREF) ||
4791                 (ytype == XML_SCHEMAS_ENTITY) ||
4792                 (ytype == XML_SCHEMAS_ANYURI)) {
4793
4794                 if (xws == XML_SCHEMA_WHITESPACE_PRESERVE) {
4795
4796                     if (yws == XML_SCHEMA_WHITESPACE_PRESERVE) {
4797                         /* TODO: What about x < y or x > y. */
4798                         if (xmlStrEqual(xv, yv))
4799                             return (0);
4800                         else
4801                             return (2);
4802                     } else if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
4803                         return (xmlSchemaComparePreserveReplaceStrings(xv, yv, 0));
4804                     else if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
4805                         return (xmlSchemaComparePreserveCollapseStrings(xv, yv, 0));
4806
4807                 } else if (xws == XML_SCHEMA_WHITESPACE_REPLACE) {
4808
4809                     if (yws == XML_SCHEMA_WHITESPACE_PRESERVE)
4810                         return (xmlSchemaComparePreserveReplaceStrings(yv, xv, 1));
4811                     if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
4812                         return (xmlSchemaCompareReplacedStrings(xv, yv));
4813                     if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
4814                         return (xmlSchemaCompareReplaceCollapseStrings(xv, yv, 0));
4815
4816                 } else if (xws == XML_SCHEMA_WHITESPACE_COLLAPSE) {
4817
4818                     if (yws == XML_SCHEMA_WHITESPACE_PRESERVE)
4819                         return (xmlSchemaComparePreserveCollapseStrings(yv, xv, 1));
4820                     if (yws == XML_SCHEMA_WHITESPACE_REPLACE)
4821                         return (xmlSchemaCompareReplaceCollapseStrings(yv, xv, 1));
4822                     if (yws == XML_SCHEMA_WHITESPACE_COLLAPSE)
4823                         return (xmlSchemaCompareNormStrings(xv, yv));
4824                 } else
4825                     return (-2);
4826
4827             }
4828             return (-2);
4829         }
4830         case XML_SCHEMAS_QNAME:
4831         case XML_SCHEMAS_NOTATION:
4832             if ((x == NULL) || (y == NULL))
4833                 return(-2);
4834             if ((ytype == XML_SCHEMAS_QNAME) ||
4835                 (ytype == XML_SCHEMAS_NOTATION)) {
4836                 if ((xmlStrEqual(x->value.qname.name, y->value.qname.name)) &&
4837                     (xmlStrEqual(x->value.qname.uri, y->value.qname.uri)))
4838                     return(0);
4839                 return(2);
4840             }
4841             return (-2);
4842         case XML_SCHEMAS_FLOAT:
4843         case XML_SCHEMAS_DOUBLE:
4844             if ((x == NULL) || (y == NULL))
4845                 return(-2);
4846             if ((ytype == XML_SCHEMAS_FLOAT) ||
4847                 (ytype == XML_SCHEMAS_DOUBLE))
4848                 return (xmlSchemaCompareFloats(x, y));
4849             return (-2);
4850         case XML_SCHEMAS_BOOLEAN:
4851             if ((x == NULL) || (y == NULL))
4852                 return(-2);
4853             if (ytype == XML_SCHEMAS_BOOLEAN) {
4854                 if (x->value.b == y->value.b)
4855                     return(0);
4856                 if (x->value.b == 0)
4857                     return(-1);
4858                 return(1);
4859             }
4860             return (-2);
4861         case XML_SCHEMAS_HEXBINARY:
4862             if ((x == NULL) || (y == NULL))
4863                 return(-2);
4864             if (ytype == XML_SCHEMAS_HEXBINARY) {
4865                 if (x->value.hex.total == y->value.hex.total) {
4866                     int ret = xmlStrcmp(x->value.hex.str, y->value.hex.str);
4867                     if (ret > 0)
4868                         return(1);
4869                     else if (ret == 0)
4870                         return(0);
4871                 }
4872                 else if (x->value.hex.total > y->value.hex.total)
4873                     return(1);
4874
4875                 return(-1);
4876             }
4877             return (-2);
4878         case XML_SCHEMAS_BASE64BINARY:
4879             if ((x == NULL) || (y == NULL))
4880                 return(-2);
4881             if (ytype == XML_SCHEMAS_BASE64BINARY) {
4882                 if (x->value.base64.total == y->value.base64.total) {
4883                     int ret = xmlStrcmp(x->value.base64.str,
4884                                         y->value.base64.str);
4885                     if (ret > 0)
4886                         return(1);
4887                     else if (ret == 0)
4888                         return(0);
4889                     else
4890                         return(-1);
4891                 }
4892                 else if (x->value.base64.total > y->value.base64.total)
4893                     return(1);
4894                 else
4895                     return(-1);
4896             }
4897             return (-2);
4898         case XML_SCHEMAS_IDREFS:
4899         case XML_SCHEMAS_ENTITIES:
4900         case XML_SCHEMAS_NMTOKENS:
4901             TODO
4902             break;
4903     }
4904     return -2;
4905 }
4906
4907 /**
4908  * xmlSchemaCompareValues:
4909  * @x:  a first value
4910  * @y:  a second value
4911  *
4912  * Compare 2 values
4913  *
4914  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
4915  * case of error
4916  */
4917 int
4918 xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y) {
4919     xmlSchemaWhitespaceValueType xws, yws;
4920
4921     if ((x == NULL) || (y == NULL))
4922         return(-2);
4923     if (x->type == XML_SCHEMAS_STRING)
4924         xws = XML_SCHEMA_WHITESPACE_PRESERVE;
4925     else if (x->type == XML_SCHEMAS_NORMSTRING)
4926         xws = XML_SCHEMA_WHITESPACE_REPLACE;
4927     else
4928         xws = XML_SCHEMA_WHITESPACE_COLLAPSE;
4929
4930     if (y->type == XML_SCHEMAS_STRING)
4931         yws = XML_SCHEMA_WHITESPACE_PRESERVE;
4932     else if (x->type == XML_SCHEMAS_NORMSTRING)
4933         yws = XML_SCHEMA_WHITESPACE_REPLACE;
4934     else
4935         yws = XML_SCHEMA_WHITESPACE_COLLAPSE;
4936
4937     return(xmlSchemaCompareValuesInternal(x->type, x, NULL, xws, y->type,
4938         y, NULL, yws));
4939 }
4940
4941 /**
4942  * xmlSchemaCompareValuesWhtsp:
4943  * @x:  a first value
4944  * @xws: the whitespace value of x
4945  * @y:  a second value
4946  * @yws: the whitespace value of y
4947  *
4948  * Compare 2 values
4949  *
4950  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
4951  * case of error
4952  */
4953 int
4954 xmlSchemaCompareValuesWhtsp(xmlSchemaValPtr x,
4955                             xmlSchemaWhitespaceValueType xws,
4956                             xmlSchemaValPtr y,
4957                             xmlSchemaWhitespaceValueType yws)
4958 {
4959     if ((x == NULL) || (y == NULL))
4960         return(-2);
4961     return(xmlSchemaCompareValuesInternal(x->type, x, NULL, xws, y->type,
4962         y, NULL, yws));
4963 }
4964
4965 /**
4966  * xmlSchemaCompareValuesWhtspExt:
4967  * @x:  a first value
4968  * @xws: the whitespace value of x
4969  * @y:  a second value
4970  * @yws: the whitespace value of y
4971  *
4972  * Compare 2 values
4973  *
4974  * Returns -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in
4975  * case of error
4976  */
4977 static int
4978 xmlSchemaCompareValuesWhtspExt(xmlSchemaValType xtype,
4979                                xmlSchemaValPtr x,
4980                                const xmlChar *xvalue,
4981                                xmlSchemaWhitespaceValueType xws,
4982                                xmlSchemaValType ytype,
4983                                xmlSchemaValPtr y,
4984                                const xmlChar *yvalue,
4985                                xmlSchemaWhitespaceValueType yws)
4986 {
4987     return(xmlSchemaCompareValuesInternal(xtype, x, xvalue, xws, ytype, y,
4988         yvalue, yws));
4989 }
4990
4991 /**
4992  * xmlSchemaNormLen:
4993  * @value:  a string
4994  *
4995  * Computes the UTF8 length of the normalized value of the string
4996  *
4997  * Returns the length or -1 in case of error.
4998  */
4999 static int
5000 xmlSchemaNormLen(const xmlChar *value) {
5001     const xmlChar *utf;
5002     int ret = 0;
5003
5004     if (value == NULL)
5005         return(-1);
5006     utf = value;
5007     while (IS_BLANK_CH(*utf)) utf++;
5008     while (*utf != 0) {
5009         if (utf[0] & 0x80) {
5010             if ((utf[1] & 0xc0) != 0x80)
5011                 return(-1);
5012             if ((utf[0] & 0xe0) == 0xe0) {
5013                 if ((utf[2] & 0xc0) != 0x80)
5014                     return(-1);
5015                 if ((utf[0] & 0xf0) == 0xf0) {
5016                     if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
5017                         return(-1);
5018                     utf += 4;
5019                 } else {
5020                     utf += 3;
5021                 }
5022             } else {
5023                 utf += 2;
5024             }
5025         } else if (IS_BLANK_CH(*utf)) {
5026             while (IS_BLANK_CH(*utf)) utf++;
5027             if (*utf == 0)
5028                 break;
5029         } else {
5030             utf++;
5031         }
5032         ret++;
5033     }
5034     return(ret);
5035 }
5036
5037 /**
5038  * xmlSchemaGetFacetValueAsULong:
5039  * @facet: an schemas type facet
5040  *
5041  * Extract the value of a facet
5042  *
5043  * Returns the value as a long
5044  */
5045 unsigned long
5046 xmlSchemaGetFacetValueAsULong(xmlSchemaFacetPtr facet)
5047 {
5048     /*
5049     * TODO: Check if this is a decimal.
5050     */
5051     if (facet == NULL)
5052         return 0;
5053     return ((unsigned long) facet->val->value.decimal.lo);
5054 }
5055
5056 /**
5057  * xmlSchemaValidateListSimpleTypeFacet:
5058  * @facet:  the facet to check
5059  * @value:  the lexical repr of the value to validate
5060  * @actualLen:  the number of list items
5061  * @expectedLen: the resulting expected number of list items
5062  *
5063  * Checks the value of a list simple type against a facet.
5064  *
5065  * Returns 0 if the value is valid, a positive error code
5066  * number otherwise and -1 in case of an internal error.
5067  */
5068 int
5069 xmlSchemaValidateListSimpleTypeFacet(xmlSchemaFacetPtr facet,
5070                                      const xmlChar *value,
5071                                      unsigned long actualLen,
5072                                      unsigned long *expectedLen)
5073 {
5074     if (facet == NULL)
5075         return(-1);
5076     /*
5077     * TODO: Check if this will work with large numbers.
5078     * (compare value.decimal.mi and value.decimal.hi as well?).
5079     */
5080     if (facet->type == XML_SCHEMA_FACET_LENGTH) {
5081         if (actualLen != facet->val->value.decimal.lo) {
5082             if (expectedLen != NULL)
5083                 *expectedLen = facet->val->value.decimal.lo;
5084             return (XML_SCHEMAV_CVC_LENGTH_VALID);
5085         }
5086     } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
5087         if (actualLen < facet->val->value.decimal.lo) {
5088             if (expectedLen != NULL)
5089                 *expectedLen = facet->val->value.decimal.lo;
5090             return (XML_SCHEMAV_CVC_MINLENGTH_VALID);
5091         }
5092     } else if (facet->type == XML_SCHEMA_FACET_MAXLENGTH) {
5093         if (actualLen > facet->val->value.decimal.lo) {
5094             if (expectedLen != NULL)
5095                 *expectedLen = facet->val->value.decimal.lo;
5096             return (XML_SCHEMAV_CVC_MAXLENGTH_VALID);
5097         }
5098     } else
5099         /*
5100         * NOTE: That we can pass NULL as xmlSchemaValPtr to
5101         * xmlSchemaValidateFacet, since the remaining facet types
5102         * are: XML_SCHEMA_FACET_PATTERN, XML_SCHEMA_FACET_ENUMERATION.
5103         */
5104         return(xmlSchemaValidateFacet(NULL, facet, value, NULL));
5105     return (0);
5106 }
5107
5108 /**
5109  * xmlSchemaValidateLengthFacet:
5110  * @type:  the built-in type
5111  * @facet:  the facet to check
5112  * @value:  the lexical repr. of the value to be validated
5113  * @val:  the precomputed value
5114  * @ws: the whitespace type of the value
5115  * @length: the actual length of the value
5116  *
5117  * Checka a value against a "length", "minLength" and "maxLength"
5118  * facet; sets @length to the computed length of @value.
5119  *
5120  * Returns 0 if the value is valid, a positive error code
5121  * otherwise and -1 in case of an internal or API error.
5122  */
5123 static int
5124 xmlSchemaValidateLengthFacetInternal(xmlSchemaFacetPtr facet,
5125                                      xmlSchemaTypeType valType,
5126                                      const xmlChar *value,
5127                                      xmlSchemaValPtr val,
5128                                      unsigned long *length,
5129                                      xmlSchemaWhitespaceValueType ws)
5130 {
5131     unsigned int len = 0;
5132
5133     if ((length == NULL) || (facet == NULL))
5134         return (-1);
5135     *length = 0;
5136     if ((facet->type != XML_SCHEMA_FACET_LENGTH) &&
5137         (facet->type != XML_SCHEMA_FACET_MAXLENGTH) &&
5138         (facet->type != XML_SCHEMA_FACET_MINLENGTH))
5139         return (-1);
5140
5141     /*
5142     * TODO: length, maxLength and minLength must be of type
5143     * nonNegativeInteger only. Check if decimal is used somehow.
5144     */
5145     if ((facet->val == NULL) ||
5146         ((facet->val->type != XML_SCHEMAS_DECIMAL) &&
5147          (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
5148         (facet->val->value.decimal.frac != 0)) {
5149         return(-1);
5150     }
5151     if ((val != NULL) && (val->type == XML_SCHEMAS_HEXBINARY))
5152         len = val->value.hex.total;
5153     else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY))
5154         len = val->value.base64.total;
5155     else {
5156         switch (valType) {
5157             case XML_SCHEMAS_STRING:
5158             case XML_SCHEMAS_NORMSTRING:
5159                 if (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
5160                     /*
5161                     * This is to ensure API compatibility with the old
5162                     * xmlSchemaValidateLengthFacet(). Anyway, this was and
5163                     * is not the correct handling.
5164                     * TODO: Get rid of this case somehow.
5165                     */
5166                     if (valType == XML_SCHEMAS_STRING)
5167                         len = xmlUTF8Strlen(value);
5168                     else
5169                         len = xmlSchemaNormLen(value);
5170                 } else if (value != NULL) {
5171                     if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
5172                         len = xmlSchemaNormLen(value);
5173                     else
5174                     /*
5175                     * Should be OK for "preserve" as well.
5176                     */
5177                     len = xmlUTF8Strlen(value);
5178                 }
5179                 break;
5180             case XML_SCHEMAS_IDREF:
5181             case XML_SCHEMAS_TOKEN:
5182             case XML_SCHEMAS_LANGUAGE:
5183             case XML_SCHEMAS_NMTOKEN:
5184             case XML_SCHEMAS_NAME:
5185             case XML_SCHEMAS_NCNAME:
5186             case XML_SCHEMAS_ID:
5187                 /*
5188                 * FIXME: What exactly to do with anyURI?
5189                 */
5190             case XML_SCHEMAS_ANYURI:
5191                 if (value != NULL)
5192                     len = xmlSchemaNormLen(value);
5193                 break;
5194             case XML_SCHEMAS_QNAME:
5195             case XML_SCHEMAS_NOTATION:
5196                 /*
5197                 * For QName and NOTATION, those facets are
5198                 * deprecated and should be ignored.
5199                 */
5200                 return (0);
5201             default:
5202                 TODO
5203         }
5204     }
5205     *length = (unsigned long) len;
5206     /*
5207     * TODO: Return the whole expected value, i.e. "lo", "mi" and "hi".
5208     */
5209     if (facet->type == XML_SCHEMA_FACET_LENGTH) {
5210         if (len != facet->val->value.decimal.lo)
5211             return(XML_SCHEMAV_CVC_LENGTH_VALID);
5212     } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
5213         if (len < facet->val->value.decimal.lo)
5214             return(XML_SCHEMAV_CVC_MINLENGTH_VALID);
5215     } else {
5216         if (len > facet->val->value.decimal.lo)
5217             return(XML_SCHEMAV_CVC_MAXLENGTH_VALID);
5218     }
5219
5220     return (0);
5221 }
5222
5223 /**
5224  * xmlSchemaValidateLengthFacet:
5225  * @type:  the built-in type
5226  * @facet:  the facet to check
5227  * @value:  the lexical repr. of the value to be validated
5228  * @val:  the precomputed value
5229  * @length: the actual length of the value
5230  *
5231  * Checka a value against a "length", "minLength" and "maxLength"
5232  * facet; sets @length to the computed length of @value.
5233  *
5234  * Returns 0 if the value is valid, a positive error code
5235  * otherwise and -1 in case of an internal or API error.
5236  */
5237 int
5238 xmlSchemaValidateLengthFacet(xmlSchemaTypePtr type,
5239                              xmlSchemaFacetPtr facet,
5240                              const xmlChar *value,
5241                              xmlSchemaValPtr val,
5242                              unsigned long *length)
5243 {
5244     if (type == NULL)
5245         return(-1);
5246     return (xmlSchemaValidateLengthFacetInternal(facet,
5247         type->builtInType, value, val, length,
5248         XML_SCHEMA_WHITESPACE_UNKNOWN));
5249 }
5250
5251 /**
5252  * xmlSchemaValidateLengthFacetWhtsp:
5253  * @facet:  the facet to check
5254  * @valType:  the built-in type
5255  * @value:  the lexical repr. of the value to be validated
5256  * @val:  the precomputed value
5257  * @ws: the whitespace type of the value
5258  * @length: the actual length of the value
5259  *
5260  * Checka a value against a "length", "minLength" and "maxLength"
5261  * facet; sets @length to the computed length of @value.
5262  *
5263  * Returns 0 if the value is valid, a positive error code
5264  * otherwise and -1 in case of an internal or API error.
5265  */
5266 int
5267 xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet,
5268                                   xmlSchemaValType valType,
5269                                   const xmlChar *value,
5270                                   xmlSchemaValPtr val,
5271                                   unsigned long *length,
5272                                   xmlSchemaWhitespaceValueType ws)
5273 {
5274     return (xmlSchemaValidateLengthFacetInternal(facet, valType, value, val,
5275         length, ws));
5276 }
5277
5278 /**
5279  * xmlSchemaValidateFacetInternal:
5280  * @facet:  the facet to check
5281  * @fws: the whitespace type of the facet's value
5282  * @valType: the built-in type of the value
5283  * @value:  the lexical repr of the value to validate
5284  * @val:  the precomputed value
5285  * @ws: the whitespace type of the value
5286  *
5287  * Check a value against a facet condition
5288  *
5289  * Returns 0 if the element is schemas valid, a positive error code
5290  *     number otherwise and -1 in case of internal or API error.
5291  */
5292 static int
5293 xmlSchemaValidateFacetInternal(xmlSchemaFacetPtr facet,
5294                                xmlSchemaWhitespaceValueType fws,
5295                                xmlSchemaValType valType,
5296                                const xmlChar *value,
5297                                xmlSchemaValPtr val,
5298                                xmlSchemaWhitespaceValueType ws)
5299 {
5300     int ret;
5301
5302     if (facet == NULL)
5303         return(-1);
5304
5305     switch (facet->type) {
5306         case XML_SCHEMA_FACET_PATTERN:
5307             /*
5308             * NOTE that for patterns, the @value needs to be the normalized
5309             * value, *not* the lexical initial value or the canonical value.
5310             */
5311             if (value == NULL)
5312                 return(-1);
5313             ret = xmlRegexpExec(facet->regexp, value);
5314             if (ret == 1)
5315                 return(0);
5316             if (ret == 0)
5317                 return(XML_SCHEMAV_CVC_PATTERN_VALID);
5318             return(ret);
5319         case XML_SCHEMA_FACET_MAXEXCLUSIVE:
5320             ret = xmlSchemaCompareValues(val, facet->val);
5321             if (ret == -2)
5322                 return(-1);
5323             if (ret == -1)
5324                 return(0);
5325             return(XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID);
5326         case XML_SCHEMA_FACET_MAXINCLUSIVE:
5327             ret = xmlSchemaCompareValues(val, facet->val);
5328             if (ret == -2)
5329                 return(-1);
5330             if ((ret == -1) || (ret == 0))
5331                 return(0);
5332             return(XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID);
5333         case XML_SCHEMA_FACET_MINEXCLUSIVE:
5334             ret = xmlSchemaCompareValues(val, facet->val);
5335             if (ret == -2)
5336                 return(-1);
5337             if (ret == 1)
5338                 return(0);
5339             return(XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID);
5340         case XML_SCHEMA_FACET_MININCLUSIVE:
5341             ret = xmlSchemaCompareValues(val, facet->val);
5342             if (ret == -2)
5343                 return(-1);
5344             if ((ret == 1) || (ret == 0))
5345                 return(0);
5346             return(XML_SCHEMAV_CVC_MININCLUSIVE_VALID);
5347         case XML_SCHEMA_FACET_WHITESPACE:
5348             /* TODO whitespaces */
5349             /*
5350             * NOTE: Whitespace should be handled to normalize
5351             * the value to be validated against a the facets;
5352             * not to normalize the value in-between.
5353             */
5354             return(0);
5355         case  XML_SCHEMA_FACET_ENUMERATION:
5356             if (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
5357                 /*
5358                 * This is to ensure API compatibility with the old
5359                 * xmlSchemaValidateFacet().
5360                 * TODO: Get rid of this case.
5361                 */
5362                 if ((facet->value != NULL) &&
5363                     (xmlStrEqual(facet->value, value)))
5364                     return(0);
5365             } else {
5366                 ret = xmlSchemaCompareValuesWhtspExt(facet->val->type,
5367                     facet->val, facet->value, fws, valType, val,
5368                     value, ws);
5369                 if (ret == -2)
5370                     return(-1);
5371                 if (ret == 0)
5372                     return(0);
5373             }
5374             return(XML_SCHEMAV_CVC_ENUMERATION_VALID);
5375         case XML_SCHEMA_FACET_LENGTH:
5376             /*
5377             * SPEC (1.3) "if {primitive type definition} is QName or NOTATION,
5378             * then any {value} is facet-valid."
5379             */
5380             if ((valType == XML_SCHEMAS_QNAME) ||
5381                 (valType == XML_SCHEMAS_NOTATION))
5382                 return (0);
5383             /* No break on purpose. */
5384         case XML_SCHEMA_FACET_MAXLENGTH:
5385         case XML_SCHEMA_FACET_MINLENGTH: {
5386             unsigned int len = 0;
5387
5388             if ((valType == XML_SCHEMAS_QNAME) ||
5389                 (valType == XML_SCHEMAS_NOTATION))
5390                 return (0);
5391             /*
5392             * TODO: length, maxLength and minLength must be of type
5393             * nonNegativeInteger only. Check if decimal is used somehow.
5394             */
5395             if ((facet->val == NULL) ||
5396                 ((facet->val->type != XML_SCHEMAS_DECIMAL) &&
5397                  (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
5398                 (facet->val->value.decimal.frac != 0)) {
5399                 return(-1);
5400             }
5401             if ((val != NULL) && (val->type == XML_SCHEMAS_HEXBINARY))
5402                 len = val->value.hex.total;
5403             else if ((val != NULL) && (val->type == XML_SCHEMAS_BASE64BINARY))
5404                 len = val->value.base64.total;
5405             else {
5406                 switch (valType) {
5407                     case XML_SCHEMAS_STRING:
5408                     case XML_SCHEMAS_NORMSTRING:
5409                         if (ws == XML_SCHEMA_WHITESPACE_UNKNOWN) {
5410                             /*
5411                             * This is to ensure API compatibility with the old
5412                             * xmlSchemaValidateFacet(). Anyway, this was and
5413                             * is not the correct handling.
5414                             * TODO: Get rid of this case somehow.
5415                             */
5416                             if (valType == XML_SCHEMAS_STRING)
5417                                 len = xmlUTF8Strlen(value);
5418                             else
5419                                 len = xmlSchemaNormLen(value);
5420                         } else if (value != NULL) {
5421                             if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
5422                                 len = xmlSchemaNormLen(value);
5423                             else
5424                                 /*
5425                                 * Should be OK for "preserve" as well.
5426                                 */
5427                                 len = xmlUTF8Strlen(value);
5428                         }
5429                         break;
5430                     case XML_SCHEMAS_IDREF:
5431                     case XML_SCHEMAS_TOKEN:
5432                     case XML_SCHEMAS_LANGUAGE:
5433                     case XML_SCHEMAS_NMTOKEN:
5434                     case XML_SCHEMAS_NAME:
5435                     case XML_SCHEMAS_NCNAME:
5436                     case XML_SCHEMAS_ID:
5437                     case XML_SCHEMAS_ANYURI:
5438                         if (value != NULL)
5439                             len = xmlSchemaNormLen(value);
5440                         break;
5441                     default:
5442                         TODO
5443                 }
5444             }
5445             if (facet->type == XML_SCHEMA_FACET_LENGTH) {
5446                 if (len != facet->val->value.decimal.lo)
5447                     return(XML_SCHEMAV_CVC_LENGTH_VALID);
5448             } else if (facet->type == XML_SCHEMA_FACET_MINLENGTH) {
5449                 if (len < facet->val->value.decimal.lo)
5450                     return(XML_SCHEMAV_CVC_MINLENGTH_VALID);
5451             } else {
5452                 if (len > facet->val->value.decimal.lo)
5453                     return(XML_SCHEMAV_CVC_MAXLENGTH_VALID);
5454             }
5455             break;
5456         }
5457         case XML_SCHEMA_FACET_TOTALDIGITS:
5458         case XML_SCHEMA_FACET_FRACTIONDIGITS:
5459
5460             if ((facet->val == NULL) ||
5461                 ((facet->val->type != XML_SCHEMAS_PINTEGER) &&
5462                  (facet->val->type != XML_SCHEMAS_NNINTEGER)) ||
5463                 (facet->val->value.decimal.frac != 0)) {
5464                 return(-1);
5465             }
5466             if ((val == NULL) ||
5467                 ((val->type != XML_SCHEMAS_DECIMAL) &&
5468                  (val->type != XML_SCHEMAS_INTEGER) &&
5469                  (val->type != XML_SCHEMAS_NPINTEGER) &&
5470                  (val->type != XML_SCHEMAS_NINTEGER) &&
5471                  (val->type != XML_SCHEMAS_NNINTEGER) &&
5472                  (val->type != XML_SCHEMAS_PINTEGER) &&
5473                  (val->type != XML_SCHEMAS_INT) &&
5474                  (val->type != XML_SCHEMAS_UINT) &&
5475                  (val->type != XML_SCHEMAS_LONG) &&
5476                  (val->type != XML_SCHEMAS_ULONG) &&
5477                  (val->type != XML_SCHEMAS_SHORT) &&
5478                  (val->type != XML_SCHEMAS_USHORT) &&
5479                  (val->type != XML_SCHEMAS_BYTE) &&
5480                  (val->type != XML_SCHEMAS_UBYTE))) {
5481                 return(-1);
5482             }
5483             if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) {
5484                 if (val->value.decimal.total > facet->val->value.decimal.lo)
5485                     return(XML_SCHEMAV_CVC_TOTALDIGITS_VALID);
5486
5487             } else if (facet->type == XML_SCHEMA_FACET_FRACTIONDIGITS) {
5488                 if (val->value.decimal.frac > facet->val->value.decimal.lo)
5489                     return(XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID);
5490             }
5491             break;
5492         default:
5493             TODO
5494     }
5495     return(0);
5496
5497 }
5498
5499 /**
5500  * xmlSchemaValidateFacet:
5501  * @base:  the base type
5502  * @facet:  the facet to check
5503  * @value:  the lexical repr of the value to validate
5504  * @val:  the precomputed value
5505  *
5506  * Check a value against a facet condition
5507  *
5508  * Returns 0 if the element is schemas valid, a positive error code
5509  *     number otherwise and -1 in case of internal or API error.
5510  */
5511 int
5512 xmlSchemaValidateFacet(xmlSchemaTypePtr base,
5513                        xmlSchemaFacetPtr facet,
5514                        const xmlChar *value,
5515                        xmlSchemaValPtr val)
5516 {
5517     /*
5518     * This tries to ensure API compatibility regarding the old
5519     * xmlSchemaValidateFacet() and the new xmlSchemaValidateFacetInternal() and
5520     * xmlSchemaValidateFacetWhtsp().
5521     */
5522     if (val != NULL)
5523         return(xmlSchemaValidateFacetInternal(facet,
5524             XML_SCHEMA_WHITESPACE_UNKNOWN, val->type, value, val,
5525             XML_SCHEMA_WHITESPACE_UNKNOWN));
5526     else if (base != NULL)
5527         return(xmlSchemaValidateFacetInternal(facet,
5528             XML_SCHEMA_WHITESPACE_UNKNOWN, base->builtInType, value, val,
5529             XML_SCHEMA_WHITESPACE_UNKNOWN));
5530     return(-1);
5531 }
5532
5533 /**
5534  * xmlSchemaValidateFacetWhtsp:
5535  * @facet:  the facet to check
5536  * @fws: the whitespace type of the facet's value
5537  * @valType: the built-in type of the value
5538  * @value:  the lexical (or normalized for pattern) repr of the value to validate
5539  * @val:  the precomputed value
5540  * @ws: the whitespace type of the value
5541  *
5542  * Check a value against a facet condition. This takes value normalization
5543  * according to the specified whitespace types into account.
5544  * Note that @value needs to be the *normalized* value if the facet
5545  * is of type "pattern".
5546  *
5547  * Returns 0 if the element is schemas valid, a positive error code
5548  *     number otherwise and -1 in case of internal or API error.
5549  */
5550 int
5551 xmlSchemaValidateFacetWhtsp(xmlSchemaFacetPtr facet,
5552                             xmlSchemaWhitespaceValueType fws,
5553                             xmlSchemaValType valType,
5554                             const xmlChar *value,
5555                             xmlSchemaValPtr val,
5556                             xmlSchemaWhitespaceValueType ws)
5557 {
5558      return(xmlSchemaValidateFacetInternal(facet, fws, valType,
5559          value, val, ws));
5560 }
5561
5562 #if 0
5563 #ifndef DBL_DIG
5564 #define DBL_DIG 16
5565 #endif
5566 #ifndef DBL_EPSILON
5567 #define DBL_EPSILON 1E-9
5568 #endif
5569
5570 #define INTEGER_DIGITS DBL_DIG
5571 #define FRACTION_DIGITS (DBL_DIG + 1)
5572 #define EXPONENT_DIGITS (3 + 2)
5573
5574 /**
5575  * xmlXPathFormatNumber:
5576  * @number:     number to format
5577  * @buffer:     output buffer
5578  * @buffersize: size of output buffer
5579  *
5580  * Convert the number into a string representation.
5581  */
5582 static void
5583 xmlSchemaFormatFloat(double number, char buffer[], int buffersize)
5584 {
5585     switch (xmlXPathIsInf(number)) {
5586     case 1:
5587         if (buffersize > (int)sizeof("INF"))
5588             snprintf(buffer, buffersize, "INF");
5589         break;
5590     case -1:
5591         if (buffersize > (int)sizeof("-INF"))
5592             snprintf(buffer, buffersize, "-INF");
5593         break;
5594     default:
5595         if (xmlXPathIsNaN(number)) {
5596             if (buffersize > (int)sizeof("NaN"))
5597                 snprintf(buffer, buffersize, "NaN");
5598         } else if (number == 0) {
5599             snprintf(buffer, buffersize, "0.0E0");
5600         } else {
5601             /* 3 is sign, decimal point, and terminating zero */
5602             char work[DBL_DIG + EXPONENT_DIGITS + 3];
5603             int integer_place, fraction_place;
5604             char *ptr;
5605             char *after_fraction;
5606             double absolute_value;
5607             int size;
5608
5609             absolute_value = fabs(number);
5610
5611             /*
5612              * Result is in work, and after_fraction points
5613              * just past the fractional part.
5614              * Use scientific notation
5615             */
5616             integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
5617             fraction_place = DBL_DIG - 1;
5618             snprintf(work, sizeof(work),"%*.*e",
5619                 integer_place, fraction_place, number);
5620             after_fraction = strchr(work + DBL_DIG, 'e');
5621             /* Remove fractional trailing zeroes */
5622             ptr = after_fraction;
5623             while (*(--ptr) == '0')
5624                 ;
5625             if (*ptr != '.')
5626                 ptr++;
5627             while ((*ptr++ = *after_fraction++) != 0);
5628
5629             /* Finally copy result back to caller */
5630             size = strlen(work) + 1;
5631             if (size > buffersize) {
5632                 work[buffersize - 1] = 0;
5633                 size = buffersize;
5634             }
5635             memmove(buffer, work, size);
5636         }
5637         break;
5638     }
5639 }
5640 #endif
5641
5642 /**
5643  * xmlSchemaGetCanonValue:
5644  * @val: the precomputed value
5645  * @retValue: the returned value
5646  *
5647  * Get a the cononical lexical representation of the value.
5648  * The caller has to FREE the returned retValue.
5649  *
5650  * WARNING: Some value types are not supported yet, resulting
5651  * in a @retValue of "???".
5652  *
5653  * TODO: XML Schema 1.0 does not define canonical representations
5654  * for: duration, gYearMonth, gYear, gMonthDay, gMonth, gDay,
5655  * anyURI, QName, NOTATION. This will be fixed in XML Schema 1.1.
5656  *
5657  *
5658  * Returns 0 if the value could be built, 1 if the value type is
5659  * not supported yet and -1 in case of API errors.
5660  */
5661 int
5662 xmlSchemaGetCanonValue(xmlSchemaValPtr val, const xmlChar **retValue)
5663 {
5664     if ((retValue == NULL) || (val == NULL))
5665         return (-1);
5666     *retValue = NULL;
5667     switch (val->type) {
5668         case XML_SCHEMAS_STRING:
5669             if (val->value.str == NULL)
5670                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
5671             else
5672                 *retValue =
5673                     BAD_CAST xmlStrdup((const xmlChar *) val->value.str);
5674             break;
5675         case XML_SCHEMAS_NORMSTRING:
5676             if (val->value.str == NULL)
5677                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
5678             else {
5679                 *retValue = xmlSchemaWhiteSpaceReplace(
5680                     (const xmlChar *) val->value.str);
5681                 if ((*retValue) == NULL)
5682                     *retValue = BAD_CAST xmlStrdup(
5683                         (const xmlChar *) val->value.str);
5684             }
5685             break;
5686         case XML_SCHEMAS_TOKEN:
5687         case XML_SCHEMAS_LANGUAGE:
5688         case XML_SCHEMAS_NMTOKEN:
5689         case XML_SCHEMAS_NAME:
5690         case XML_SCHEMAS_NCNAME:
5691         case XML_SCHEMAS_ID:
5692         case XML_SCHEMAS_IDREF:
5693         case XML_SCHEMAS_ENTITY:
5694         case XML_SCHEMAS_NOTATION: /* Unclear */
5695         case XML_SCHEMAS_ANYURI:   /* Unclear */
5696             if (val->value.str == NULL)
5697                 return (-1);
5698             *retValue =
5699                 BAD_CAST xmlSchemaCollapseString(BAD_CAST val->value.str);
5700             if (*retValue == NULL)
5701                 *retValue =
5702                     BAD_CAST xmlStrdup((const xmlChar *) val->value.str);
5703             break;
5704         case XML_SCHEMAS_QNAME:
5705             /* TODO: Unclear in XML Schema 1.0. */
5706             if (val->value.qname.uri == NULL) {
5707                 *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.qname.name);
5708                 return (0);
5709             } else {
5710                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "{");
5711                 *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
5712                     BAD_CAST val->value.qname.uri);
5713                 *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
5714                     BAD_CAST "}");
5715                 *retValue = BAD_CAST xmlStrcat((xmlChar *) (*retValue),
5716                     BAD_CAST val->value.qname.uri);
5717             }
5718             break;
5719         case XML_SCHEMAS_DECIMAL:
5720             /*
5721             * TODO: Lookout for a more simple implementation.
5722             */
5723             if ((val->value.decimal.total == 1) &&
5724                 (val->value.decimal.lo == 0)) {
5725                 *retValue = xmlStrdup(BAD_CAST "0.0");
5726             } else {
5727                 xmlSchemaValDecimal dec = val->value.decimal;
5728                 int bufsize;
5729                 char *buf = NULL, *offs;
5730
5731                 /* Add room for the decimal point as well. */
5732                 bufsize = dec.total + 2;
5733                 if (dec.sign)
5734                     bufsize++;
5735                 /* Add room for leading/trailing zero. */
5736                 if ((dec.frac == 0) || (dec.frac == dec.total))
5737                     bufsize++;
5738                 buf = xmlMalloc(bufsize);
5739                 if (buf == NULL)
5740                     return(-1);
5741                 offs = buf;
5742                 if (dec.sign)
5743                     *offs++ = '-';
5744                 if (dec.frac == dec.total) {
5745                     *offs++ = '0';
5746                     *offs++ = '.';
5747                 }
5748                 if (dec.hi != 0)
5749                     snprintf(offs, bufsize - (offs - buf),
5750                         "%lu%lu%lu", dec.hi, dec.mi, dec.lo);
5751                 else if (dec.mi != 0)
5752                     snprintf(offs, bufsize - (offs - buf),
5753                         "%lu%lu", dec.mi, dec.lo);
5754                 else
5755                     snprintf(offs, bufsize - (offs - buf),
5756                         "%lu", dec.lo);
5757
5758                 if (dec.frac != 0) {
5759                     if (dec.frac != dec.total) {
5760                         int diff = dec.total - dec.frac;
5761                         /*
5762                         * Insert the decimal point.
5763                         */
5764                         memmove(offs + diff + 1, offs + diff, dec.frac +1);
5765                         offs[diff] = '.';
5766                     } else {
5767                         unsigned int i = 0;
5768                         /*
5769                         * Insert missing zeroes behind the decimal point.
5770                         */
5771                         while (*(offs + i) != 0)
5772                             i++;
5773                         if (i < dec.total) {
5774                             memmove(offs + (dec.total - i), offs, i +1);
5775                             memset(offs, '0', dec.total - i);
5776                         }
5777                     }
5778                 } else {
5779                     /*
5780                     * Append decimal point and zero.
5781                     */
5782                     offs = buf + bufsize - 1;
5783                     *offs-- = 0;
5784                     *offs-- = '0';
5785                     *offs-- = '.';
5786                 }
5787                 *retValue = BAD_CAST buf;
5788             }
5789             break;
5790         case XML_SCHEMAS_INTEGER:
5791         case XML_SCHEMAS_PINTEGER:
5792         case XML_SCHEMAS_NPINTEGER:
5793         case XML_SCHEMAS_NINTEGER:
5794         case XML_SCHEMAS_NNINTEGER:
5795         case XML_SCHEMAS_LONG:
5796         case XML_SCHEMAS_BYTE:
5797         case XML_SCHEMAS_SHORT:
5798         case XML_SCHEMAS_INT:
5799         case XML_SCHEMAS_UINT:
5800         case XML_SCHEMAS_ULONG:
5801         case XML_SCHEMAS_USHORT:
5802         case XML_SCHEMAS_UBYTE:
5803             if ((val->value.decimal.total == 1) &&
5804                 (val->value.decimal.lo == 0))
5805                 *retValue = xmlStrdup(BAD_CAST "0");
5806             else {
5807                 xmlSchemaValDecimal dec = val->value.decimal;
5808                 int bufsize = dec.total + 1;
5809
5810                 /* Add room for the decimal point as well. */
5811                 if (dec.sign)
5812                     bufsize++;
5813                 *retValue = xmlMalloc(bufsize);
5814                 if (*retValue == NULL)
5815                     return(-1);
5816                 if (dec.hi != 0) {
5817                     if (dec.sign)
5818                         snprintf((char *) *retValue, bufsize,
5819                             "-%lu%lu%lu", dec.hi, dec.mi, dec.lo);
5820                     else
5821                         snprintf((char *) *retValue, bufsize,
5822                             "%lu%lu%lu", dec.hi, dec.mi, dec.lo);
5823                 } else if (dec.mi != 0) {
5824                     if (dec.sign)
5825                         snprintf((char *) *retValue, bufsize,
5826                             "-%lu%lu", dec.mi, dec.lo);
5827                     else
5828                         snprintf((char *) *retValue, bufsize,
5829                             "%lu%lu", dec.mi, dec.lo);
5830                 } else {
5831                     if (dec.sign)
5832                         snprintf((char *) *retValue, bufsize, "-%lu", dec.lo);
5833                     else
5834                         snprintf((char *) *retValue, bufsize, "%lu", dec.lo);
5835                 }
5836             }
5837             break;
5838         case XML_SCHEMAS_BOOLEAN:
5839             if (val->value.b)
5840                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "true");
5841             else
5842                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "false");
5843             break;
5844         case XML_SCHEMAS_DURATION: {
5845                 char buf[100];
5846                 unsigned long year;
5847                 unsigned long mon, day, hour = 0, min = 0;
5848                 double sec = 0, left;
5849
5850                 /* TODO: Unclear in XML Schema 1.0 */
5851                 /*
5852                 * TODO: This results in a normalized output of the value
5853                 * - which is NOT conformant to the spec -
5854                 * since the exact values of each property are not
5855                 * recoverable. Think about extending the structure to
5856                 * provide a field for every property.
5857                 */
5858                 year = (unsigned long) FQUOTIENT(labs(val->value.dur.mon), 12);
5859                 mon = labs(val->value.dur.mon) - 12 * year;
5860
5861                 day = (unsigned long) FQUOTIENT(fabs(val->value.dur.sec), 86400);
5862                 left = fabs(val->value.dur.sec) - day * 86400;
5863                 if (left > 0) {
5864                     hour = (unsigned long) FQUOTIENT(left, 3600);
5865                     left = left - (hour * 3600);
5866                     if (left > 0) {
5867                         min = (unsigned long) FQUOTIENT(left, 60);
5868                         sec = left - (min * 60);
5869                     }
5870                 }
5871                 if ((val->value.dur.mon < 0) || (val->value.dur.sec < 0))
5872                     snprintf(buf, 100, "P%luY%luM%luDT%luH%luM%.14gS",
5873                         year, mon, day, hour, min, sec);
5874                 else
5875                     snprintf(buf, 100, "-P%luY%luM%luDT%luH%luM%.14gS",
5876                         year, mon, day, hour, min, sec);
5877                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
5878             }
5879             break;
5880         case XML_SCHEMAS_GYEAR: {
5881                 char buf[30];
5882                 /* TODO: Unclear in XML Schema 1.0 */
5883                 /* TODO: What to do with the timezone? */
5884                 snprintf(buf, 30, "%04ld", val->value.date.year);
5885                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
5886             }
5887             break;
5888         case XML_SCHEMAS_GMONTH: {
5889                 /* TODO: Unclear in XML Schema 1.0 */
5890                 /* TODO: What to do with the timezone? */
5891                 *retValue = xmlMalloc(6);
5892                 if (*retValue == NULL)
5893                     return(-1);
5894                 snprintf((char *) *retValue, 6, "--%02u",
5895                     val->value.date.mon);
5896             }
5897             break;
5898         case XML_SCHEMAS_GDAY: {
5899                 /* TODO: Unclear in XML Schema 1.0 */
5900                 /* TODO: What to do with the timezone? */
5901                 *retValue = xmlMalloc(6);
5902                 if (*retValue == NULL)
5903                     return(-1);
5904                 snprintf((char *) *retValue, 6, "---%02u",
5905                     val->value.date.day);
5906             }
5907             break;
5908         case XML_SCHEMAS_GMONTHDAY: {
5909                 /* TODO: Unclear in XML Schema 1.0 */
5910                 /* TODO: What to do with the timezone? */
5911                 *retValue = xmlMalloc(8);
5912                 if (*retValue == NULL)
5913                     return(-1);
5914                 snprintf((char *) *retValue, 8, "--%02u-%02u",
5915                     val->value.date.mon, val->value.date.day);
5916             }
5917             break;
5918         case XML_SCHEMAS_GYEARMONTH: {
5919                 char buf[35];
5920                 /* TODO: Unclear in XML Schema 1.0 */
5921                 /* TODO: What to do with the timezone? */
5922                 if (val->value.date.year < 0)
5923                     snprintf(buf, 35, "-%04ld-%02u",
5924                         labs(val->value.date.year),
5925                         val->value.date.mon);
5926                 else
5927                     snprintf(buf, 35, "%04ld-%02u",
5928                         val->value.date.year, val->value.date.mon);
5929                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
5930             }
5931             break;
5932         case XML_SCHEMAS_TIME:
5933             {
5934                 char buf[30];
5935
5936                 if (val->value.date.tz_flag) {
5937                     xmlSchemaValPtr norm;
5938
5939                     norm = xmlSchemaDateNormalize(val, 0);
5940                     if (norm == NULL)
5941                         return (-1);
5942                     /*
5943                     * TODO: Check if "%.14g" is portable.
5944                     */
5945                     snprintf(buf, 30,
5946                         "%02u:%02u:%02.14gZ",
5947                         norm->value.date.hour,
5948                         norm->value.date.min,
5949                         norm->value.date.sec);
5950                     xmlSchemaFreeValue(norm);
5951                 } else {
5952                     snprintf(buf, 30,
5953                         "%02u:%02u:%02.14g",
5954                         val->value.date.hour,
5955                         val->value.date.min,
5956                         val->value.date.sec);
5957                 }
5958                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
5959             }
5960             break;
5961         case XML_SCHEMAS_DATE:
5962             {
5963                 char buf[30];
5964
5965                 if (val->value.date.tz_flag) {
5966                     xmlSchemaValPtr norm;
5967
5968                     norm = xmlSchemaDateNormalize(val, 0);
5969                     if (norm == NULL)
5970                         return (-1);
5971                     /*
5972                     * TODO: Append the canonical value of the
5973                     * recoverable timezone and not "Z".
5974                     */
5975                     snprintf(buf, 30,
5976                         "%04ld:%02u:%02uZ",
5977                         norm->value.date.year, norm->value.date.mon,
5978                         norm->value.date.day);
5979                     xmlSchemaFreeValue(norm);
5980                 } else {
5981                     snprintf(buf, 30,
5982                         "%04ld:%02u:%02u",
5983                         val->value.date.year, val->value.date.mon,
5984                         val->value.date.day);
5985                 }
5986                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
5987             }
5988             break;
5989         case XML_SCHEMAS_DATETIME:
5990             {
5991                 char buf[50];
5992
5993                 if (val->value.date.tz_flag) {
5994                     xmlSchemaValPtr norm;
5995
5996                     norm = xmlSchemaDateNormalize(val, 0);
5997                     if (norm == NULL)
5998                         return (-1);
5999                     /*
6000                     * TODO: Check if "%.14g" is portable.
6001                     */
6002                     snprintf(buf, 50,
6003                         "%04ld:%02u:%02uT%02u:%02u:%02.14gZ",
6004                         norm->value.date.year, norm->value.date.mon,
6005                         norm->value.date.day, norm->value.date.hour,
6006                         norm->value.date.min, norm->value.date.sec);
6007                     xmlSchemaFreeValue(norm);
6008                 } else {
6009                     snprintf(buf, 50,
6010                         "%04ld:%02u:%02uT%02u:%02u:%02.14g",
6011                         val->value.date.year, val->value.date.mon,
6012                         val->value.date.day, val->value.date.hour,
6013                         val->value.date.min, val->value.date.sec);
6014                 }
6015                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
6016             }
6017             break;
6018         case XML_SCHEMAS_HEXBINARY:
6019             *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.hex.str);
6020             break;
6021         case XML_SCHEMAS_BASE64BINARY:
6022             /*
6023             * TODO: Is the following spec piece implemented?:
6024             * SPEC: "Note: For some values the canonical form defined
6025             * above does not conform to [RFC 2045], which requires breaking
6026             * with linefeeds at appropriate intervals."
6027             */
6028             *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.base64.str);
6029             break;
6030         case XML_SCHEMAS_FLOAT: {
6031                 char buf[30];
6032                 /*
6033                 * |m| < 16777216, -149 <= e <= 104.
6034                 * TODO: Handle, NaN, INF, -INF. The format is not
6035                 * yet conformant. The c type float does not cover
6036                 * the whole range.
6037                 */
6038                 snprintf(buf, 30, "%01.14e", val->value.f);
6039                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
6040             }
6041             break;
6042         case XML_SCHEMAS_DOUBLE: {
6043                 char buf[40];
6044                 /* |m| < 9007199254740992, -1075 <= e <= 970 */
6045                 /*
6046                 * TODO: Handle, NaN, INF, -INF. The format is not
6047                 * yet conformant. The c type float does not cover
6048                 * the whole range.
6049                 */
6050                 snprintf(buf, 40, "%01.14e", val->value.d);
6051                 *retValue = BAD_CAST xmlStrdup(BAD_CAST buf);
6052             }
6053             break;
6054         default:
6055             *retValue = BAD_CAST xmlStrdup(BAD_CAST "???");
6056             return (1);
6057     }
6058     if (*retValue == NULL)
6059         return(-1);
6060     return (0);
6061 }
6062
6063 /**
6064  * xmlSchemaGetCanonValueWhtsp:
6065  * @val: the precomputed value
6066  * @retValue: the returned value
6067  * @ws: the whitespace type of the value
6068  *
6069  * Get a the cononical representation of the value.
6070  * The caller has to free the returned @retValue.
6071  *
6072  * Returns 0 if the value could be built, 1 if the value type is
6073  * not supported yet and -1 in case of API errors.
6074  */
6075 int
6076 xmlSchemaGetCanonValueWhtsp(xmlSchemaValPtr val,
6077                             const xmlChar **retValue,
6078                             xmlSchemaWhitespaceValueType ws)
6079 {
6080     if ((retValue == NULL) || (val == NULL))
6081         return (-1);
6082     if ((ws == XML_SCHEMA_WHITESPACE_UNKNOWN) ||
6083         (ws > XML_SCHEMA_WHITESPACE_COLLAPSE))
6084         return (-1);
6085
6086     *retValue = NULL;
6087     switch (val->type) {
6088         case XML_SCHEMAS_STRING:
6089             if (val->value.str == NULL)
6090                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
6091             else if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
6092                 *retValue = xmlSchemaCollapseString(val->value.str);
6093             else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
6094                 *retValue = xmlSchemaWhiteSpaceReplace(val->value.str);
6095             if ((*retValue) == NULL)
6096                 *retValue = BAD_CAST xmlStrdup(val->value.str);
6097             break;
6098         case XML_SCHEMAS_NORMSTRING:
6099             if (val->value.str == NULL)
6100                 *retValue = BAD_CAST xmlStrdup(BAD_CAST "");
6101             else {
6102                 if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
6103                     *retValue = xmlSchemaCollapseString(val->value.str);
6104                 else
6105                     *retValue = xmlSchemaWhiteSpaceReplace(val->value.str);
6106                 if ((*retValue) == NULL)
6107                     *retValue = BAD_CAST xmlStrdup(val->value.str);
6108             }
6109             break;
6110         default:
6111             return (xmlSchemaGetCanonValue(val, retValue));
6112     }
6113     return (0);
6114 }
6115
6116 /**
6117  * xmlSchemaGetValType:
6118  * @val: a schemas value
6119  *
6120  * Accessor for the type of a value
6121  *
6122  * Returns the xmlSchemaValType of the value
6123  */
6124 xmlSchemaValType
6125 xmlSchemaGetValType(xmlSchemaValPtr val)
6126 {
6127     if (val == NULL)
6128         return(XML_SCHEMAS_UNKNOWN);
6129     return (val->type);
6130 }
6131
6132 #define bottom_xmlschemastypes
6133 #include "elfgcchack.h"
6134 #endif /* LIBXML_SCHEMAS_ENABLED */