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