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