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