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