• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Summary: internal interfaces for XML Schemas
3  * Description: internal interfaces for the XML Schemas handling
4  *              and schema validity checking
5  *		The Schemas development is a Work In Progress.
6  *              Some of those interfaces are not guaranteed to be API or ABI stable !
7  *
8  * Copy: See Copyright for the status of this software.
9  *
10  * Author: Daniel Veillard
11  */
12 
13 
14 #ifndef __XML_SCHEMA_INTERNALS_H__
15 #define __XML_SCHEMA_INTERNALS_H__
16 
17 #include <libxml/xmlversion.h>
18 
19 #ifdef LIBXML_SCHEMAS_ENABLED
20 
21 #include <libxml/xmlregexp.h>
22 #include <libxml/hash.h>
23 #include <libxml/dict.h>
24 
25 #ifdef __cplusplus
26 extern "C" {
27 #endif
28 
29 typedef enum {
30     XML_SCHEMAS_UNKNOWN = 0,
31     XML_SCHEMAS_STRING = 1,
32     XML_SCHEMAS_NORMSTRING = 2,
33     XML_SCHEMAS_DECIMAL = 3,
34     XML_SCHEMAS_TIME = 4,
35     XML_SCHEMAS_GDAY = 5,
36     XML_SCHEMAS_GMONTH = 6,
37     XML_SCHEMAS_GMONTHDAY = 7,
38     XML_SCHEMAS_GYEAR = 8,
39     XML_SCHEMAS_GYEARMONTH = 9,
40     XML_SCHEMAS_DATE = 10,
41     XML_SCHEMAS_DATETIME = 11,
42     XML_SCHEMAS_DURATION = 12,
43     XML_SCHEMAS_FLOAT = 13,
44     XML_SCHEMAS_DOUBLE = 14,
45     XML_SCHEMAS_BOOLEAN = 15,
46     XML_SCHEMAS_TOKEN = 16,
47     XML_SCHEMAS_LANGUAGE = 17,
48     XML_SCHEMAS_NMTOKEN = 18,
49     XML_SCHEMAS_NMTOKENS = 19,
50     XML_SCHEMAS_NAME = 20,
51     XML_SCHEMAS_QNAME = 21,
52     XML_SCHEMAS_NCNAME = 22,
53     XML_SCHEMAS_ID = 23,
54     XML_SCHEMAS_IDREF = 24,
55     XML_SCHEMAS_IDREFS = 25,
56     XML_SCHEMAS_ENTITY = 26,
57     XML_SCHEMAS_ENTITIES = 27,
58     XML_SCHEMAS_NOTATION = 28,
59     XML_SCHEMAS_ANYURI = 29,
60     XML_SCHEMAS_INTEGER = 30,
61     XML_SCHEMAS_NPINTEGER = 31,
62     XML_SCHEMAS_NINTEGER = 32,
63     XML_SCHEMAS_NNINTEGER = 33,
64     XML_SCHEMAS_PINTEGER = 34,
65     XML_SCHEMAS_INT = 35,
66     XML_SCHEMAS_UINT = 36,
67     XML_SCHEMAS_LONG = 37,
68     XML_SCHEMAS_ULONG = 38,
69     XML_SCHEMAS_SHORT = 39,
70     XML_SCHEMAS_USHORT = 40,
71     XML_SCHEMAS_BYTE = 41,
72     XML_SCHEMAS_UBYTE = 42,
73     XML_SCHEMAS_HEXBINARY = 43,
74     XML_SCHEMAS_BASE64BINARY = 44,
75     XML_SCHEMAS_ANYTYPE = 45,
76     XML_SCHEMAS_ANYSIMPLETYPE = 46
77 } xmlSchemaValType;
78 
79 /*
80  * XML Schemas defines multiple type of types.
81  */
82 typedef enum {
83     XML_SCHEMA_TYPE_BASIC = 1, /* A built-in datatype */
84     XML_SCHEMA_TYPE_ANY,
85     XML_SCHEMA_TYPE_FACET,
86     XML_SCHEMA_TYPE_SIMPLE,
87     XML_SCHEMA_TYPE_COMPLEX,
88     XML_SCHEMA_TYPE_SEQUENCE = 6,
89     XML_SCHEMA_TYPE_CHOICE,
90     XML_SCHEMA_TYPE_ALL,
91     XML_SCHEMA_TYPE_SIMPLE_CONTENT,
92     XML_SCHEMA_TYPE_COMPLEX_CONTENT,
93     XML_SCHEMA_TYPE_UR,
94     XML_SCHEMA_TYPE_RESTRICTION,
95     XML_SCHEMA_TYPE_EXTENSION,
96     XML_SCHEMA_TYPE_ELEMENT,
97     XML_SCHEMA_TYPE_ATTRIBUTE,
98     XML_SCHEMA_TYPE_ATTRIBUTEGROUP,
99     XML_SCHEMA_TYPE_GROUP,
100     XML_SCHEMA_TYPE_NOTATION,
101     XML_SCHEMA_TYPE_LIST,
102     XML_SCHEMA_TYPE_UNION,
103     XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
104     XML_SCHEMA_TYPE_IDC_UNIQUE,
105     XML_SCHEMA_TYPE_IDC_KEY,
106     XML_SCHEMA_TYPE_IDC_KEYREF,
107     XML_SCHEMA_TYPE_PARTICLE = 25,
108     XML_SCHEMA_TYPE_ATTRIBUTE_USE,
109     XML_SCHEMA_FACET_MININCLUSIVE = 1000,
110     XML_SCHEMA_FACET_MINEXCLUSIVE,
111     XML_SCHEMA_FACET_MAXINCLUSIVE,
112     XML_SCHEMA_FACET_MAXEXCLUSIVE,
113     XML_SCHEMA_FACET_TOTALDIGITS,
114     XML_SCHEMA_FACET_FRACTIONDIGITS,
115     XML_SCHEMA_FACET_PATTERN,
116     XML_SCHEMA_FACET_ENUMERATION,
117     XML_SCHEMA_FACET_WHITESPACE,
118     XML_SCHEMA_FACET_LENGTH,
119     XML_SCHEMA_FACET_MAXLENGTH,
120     XML_SCHEMA_FACET_MINLENGTH,
121     XML_SCHEMA_EXTRA_QNAMEREF = 2000,
122     XML_SCHEMA_EXTRA_ATTR_USE_PROHIB
123 } xmlSchemaTypeType;
124 
125 typedef enum {
126     XML_SCHEMA_CONTENT_UNKNOWN = 0,
127     XML_SCHEMA_CONTENT_EMPTY = 1,
128     XML_SCHEMA_CONTENT_ELEMENTS,
129     XML_SCHEMA_CONTENT_MIXED,
130     XML_SCHEMA_CONTENT_SIMPLE,
131     XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS, /* Obsolete */
132     XML_SCHEMA_CONTENT_BASIC,
133     XML_SCHEMA_CONTENT_ANY
134 } xmlSchemaContentType;
135 
136 typedef struct _xmlSchemaVal xmlSchemaVal;
137 typedef xmlSchemaVal *xmlSchemaValPtr;
138 
139 typedef struct _xmlSchemaType xmlSchemaType;
140 typedef xmlSchemaType *xmlSchemaTypePtr;
141 
142 typedef struct _xmlSchemaFacet xmlSchemaFacet;
143 typedef xmlSchemaFacet *xmlSchemaFacetPtr;
144 
145 /**
146  * Annotation
147  */
148 typedef struct _xmlSchemaAnnot xmlSchemaAnnot;
149 typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;
150 struct _xmlSchemaAnnot {
151     struct _xmlSchemaAnnot *next;
152     xmlNodePtr content;         /* the annotation */
153 };
154 
155 /**
156  * XML_SCHEMAS_ANYATTR_SKIP:
157  *
158  * Skip unknown attribute from validation
159  * Obsolete, not used anymore.
160  */
161 #define XML_SCHEMAS_ANYATTR_SKIP        1
162 /**
163  * XML_SCHEMAS_ANYATTR_LAX:
164  *
165  * Ignore validation non definition on attributes
166  * Obsolete, not used anymore.
167  */
168 #define XML_SCHEMAS_ANYATTR_LAX                2
169 /**
170  * XML_SCHEMAS_ANYATTR_STRICT:
171  *
172  * Apply strict validation rules on attributes
173  * Obsolete, not used anymore.
174  */
175 #define XML_SCHEMAS_ANYATTR_STRICT        3
176 /**
177  * XML_SCHEMAS_ANY_SKIP:
178  *
179  * Skip unknown attribute from validation
180  */
181 #define XML_SCHEMAS_ANY_SKIP        1
182 /**
183  * XML_SCHEMAS_ANY_LAX:
184  *
185  * Used by wildcards.
186  * Validate if type found, don't worry if not found
187  */
188 #define XML_SCHEMAS_ANY_LAX                2
189 /**
190  * XML_SCHEMAS_ANY_STRICT:
191  *
192  * Used by wildcards.
193  * Apply strict validation rules
194  */
195 #define XML_SCHEMAS_ANY_STRICT        3
196 /**
197  * XML_SCHEMAS_ATTR_USE_PROHIBITED:
198  *
199  * Used by wildcards.
200  * The attribute is prohibited.
201  */
202 #define XML_SCHEMAS_ATTR_USE_PROHIBITED 0
203 /**
204  * XML_SCHEMAS_ATTR_USE_REQUIRED:
205  *
206  * The attribute is required.
207  */
208 #define XML_SCHEMAS_ATTR_USE_REQUIRED 1
209 /**
210  * XML_SCHEMAS_ATTR_USE_OPTIONAL:
211  *
212  * The attribute is optional.
213  */
214 #define XML_SCHEMAS_ATTR_USE_OPTIONAL 2
215 /**
216  * XML_SCHEMAS_ATTR_GLOBAL:
217  *
218  * allow elements in no namespace
219  */
220 #define XML_SCHEMAS_ATTR_GLOBAL        1 << 0
221 /**
222  * XML_SCHEMAS_ATTR_NSDEFAULT:
223  *
224  * allow elements in no namespace
225  */
226 #define XML_SCHEMAS_ATTR_NSDEFAULT        1 << 7
227 /**
228  * XML_SCHEMAS_ATTR_INTERNAL_RESOLVED:
229  *
230  * this is set when the "type" and "ref" references
231  * have been resolved.
232  */
233 #define XML_SCHEMAS_ATTR_INTERNAL_RESOLVED        1 << 8
234 /**
235  * XML_SCHEMAS_ATTR_FIXED:
236  *
237  * the attribute has a fixed value
238  */
239 #define XML_SCHEMAS_ATTR_FIXED        1 << 9
240 
241 /**
242  * xmlSchemaAttribute:
243  * An attribute definition.
244  */
245 
246 typedef struct _xmlSchemaAttribute xmlSchemaAttribute;
247 typedef xmlSchemaAttribute *xmlSchemaAttributePtr;
248 struct _xmlSchemaAttribute {
249     xmlSchemaTypeType type;
250     struct _xmlSchemaAttribute *next; /* the next attribute (not used?) */
251     const xmlChar *name; /* the name of the declaration */
252     const xmlChar *id; /* Deprecated; not used */
253     const xmlChar *ref; /* Deprecated; not used */
254     const xmlChar *refNs; /* Deprecated; not used */
255     const xmlChar *typeName; /* the local name of the type definition */
256     const xmlChar *typeNs; /* the ns URI of the type definition */
257     xmlSchemaAnnotPtr annot;
258 
259     xmlSchemaTypePtr base; /* Deprecated; not used */
260     int occurs; /* Deprecated; not used */
261     const xmlChar *defValue; /* The initial value of the value constraint */
262     xmlSchemaTypePtr subtypes; /* the type definition */
263     xmlNodePtr node;
264     const xmlChar *targetNamespace;
265     int flags;
266     const xmlChar *refPrefix; /* Deprecated; not used */
267     xmlSchemaValPtr defVal; /* The compiled value constraint */
268     xmlSchemaAttributePtr refDecl; /* Deprecated; not used */
269 };
270 
271 /**
272  * xmlSchemaAttributeLink:
273  * Used to build a list of attribute uses on complexType definitions.
274  * WARNING: Deprecated; not used.
275  */
276 typedef struct _xmlSchemaAttributeLink xmlSchemaAttributeLink;
277 typedef xmlSchemaAttributeLink *xmlSchemaAttributeLinkPtr;
278 struct _xmlSchemaAttributeLink {
279     struct _xmlSchemaAttributeLink *next;/* the next attribute link ... */
280     struct _xmlSchemaAttribute *attr;/* the linked attribute */
281 };
282 
283 /**
284  * XML_SCHEMAS_WILDCARD_COMPLETE:
285  *
286  * If the wildcard is complete.
287  */
288 #define XML_SCHEMAS_WILDCARD_COMPLETE 1 << 0
289 
290 /**
291  * xmlSchemaCharValueLink:
292  * Used to build a list of namespaces on wildcards.
293  */
294 typedef struct _xmlSchemaWildcardNs xmlSchemaWildcardNs;
295 typedef xmlSchemaWildcardNs *xmlSchemaWildcardNsPtr;
296 struct _xmlSchemaWildcardNs {
297     struct _xmlSchemaWildcardNs *next;/* the next constraint link ... */
298     const xmlChar *value;/* the value */
299 };
300 
301 /**
302  * xmlSchemaWildcard.
303  * A wildcard.
304  */
305 typedef struct _xmlSchemaWildcard xmlSchemaWildcard;
306 typedef xmlSchemaWildcard *xmlSchemaWildcardPtr;
307 struct _xmlSchemaWildcard {
308     xmlSchemaTypeType type;        /* The kind of type */
309     const xmlChar *id; /* Deprecated; not used */
310     xmlSchemaAnnotPtr annot;
311     xmlNodePtr node;
312     int minOccurs; /* Deprecated; not used */
313     int maxOccurs; /* Deprecated; not used */
314     int processContents;
315     int any; /* Indicates if the ns constraint is of ##any */
316     xmlSchemaWildcardNsPtr nsSet; /* The list of allowed namespaces */
317     xmlSchemaWildcardNsPtr negNsSet; /* The negated namespace */
318     int flags;
319 };
320 
321 /**
322  * XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED:
323  *
324  * The attribute wildcard has been already builded.
325  */
326 #define XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED 1 << 0
327 /**
328  * XML_SCHEMAS_ATTRGROUP_GLOBAL:
329  *
330  * The attribute wildcard has been already builded.
331  */
332 #define XML_SCHEMAS_ATTRGROUP_GLOBAL 1 << 1
333 /**
334  * XML_SCHEMAS_ATTRGROUP_MARKED:
335  *
336  * Marks the attr group as marked; used for circular checks.
337  */
338 #define XML_SCHEMAS_ATTRGROUP_MARKED 1 << 2
339 
340 /**
341  * XML_SCHEMAS_ATTRGROUP_REDEFINED:
342  *
343  * The attr group was redefined.
344  */
345 #define XML_SCHEMAS_ATTRGROUP_REDEFINED 1 << 3
346 /**
347  * XML_SCHEMAS_ATTRGROUP_HAS_REFS:
348  *
349  * Whether this attr. group contains attr. group references.
350  */
351 #define XML_SCHEMAS_ATTRGROUP_HAS_REFS 1 << 4
352 
353 /**
354  * An attribute group definition.
355  *
356  * xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures
357  * must be kept similar
358  */
359 typedef struct _xmlSchemaAttributeGroup xmlSchemaAttributeGroup;
360 typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr;
361 struct _xmlSchemaAttributeGroup {
362     xmlSchemaTypeType type;        /* The kind of type */
363     struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
364     const xmlChar *name;
365     const xmlChar *id;
366     const xmlChar *ref; /* Deprecated; not used */
367     const xmlChar *refNs; /* Deprecated; not used */
368     xmlSchemaAnnotPtr annot;
369 
370     xmlSchemaAttributePtr attributes; /* Deprecated; not used */
371     xmlNodePtr node;
372     int flags;
373     xmlSchemaWildcardPtr attributeWildcard;
374     const xmlChar *refPrefix; /* Deprecated; not used */
375     xmlSchemaAttributeGroupPtr refItem; /* Deprecated; not used */
376     const xmlChar *targetNamespace;
377     void *attrUses;
378 };
379 
380 /**
381  * xmlSchemaTypeLink:
382  * Used to build a list of types (e.g. member types of
383  * simpleType with variety "union").
384  */
385 typedef struct _xmlSchemaTypeLink xmlSchemaTypeLink;
386 typedef xmlSchemaTypeLink *xmlSchemaTypeLinkPtr;
387 struct _xmlSchemaTypeLink {
388     struct _xmlSchemaTypeLink *next;/* the next type link ... */
389     xmlSchemaTypePtr type;/* the linked type */
390 };
391 
392 /**
393  * xmlSchemaFacetLink:
394  * Used to build a list of facets.
395  */
396 typedef struct _xmlSchemaFacetLink xmlSchemaFacetLink;
397 typedef xmlSchemaFacetLink *xmlSchemaFacetLinkPtr;
398 struct _xmlSchemaFacetLink {
399     struct _xmlSchemaFacetLink *next;/* the next facet link ... */
400     xmlSchemaFacetPtr facet;/* the linked facet */
401 };
402 
403 /**
404  * XML_SCHEMAS_TYPE_MIXED:
405  *
406  * the element content type is mixed
407  */
408 #define XML_SCHEMAS_TYPE_MIXED                1 << 0
409 /**
410  * XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION:
411  *
412  * the simple or complex type has a derivation method of "extension".
413  */
414 #define XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION                1 << 1
415 /**
416  * XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION:
417  *
418  * the simple or complex type has a derivation method of "restriction".
419  */
420 #define XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION                1 << 2
421 /**
422  * XML_SCHEMAS_TYPE_GLOBAL:
423  *
424  * the type is global
425  */
426 #define XML_SCHEMAS_TYPE_GLOBAL                1 << 3
427 /**
428  * XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD:
429  *
430  * the complexType owns an attribute wildcard, i.e.
431  * it can be freed by the complexType
432  */
433 #define XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD    1 << 4 /* Obsolete. */
434 /**
435  * XML_SCHEMAS_TYPE_VARIETY_ABSENT:
436  *
437  * the simpleType has a variety of "absent".
438  * TODO: Actually not necessary :-/, since if
439  * none of the variety flags occur then it's
440  * automatically absent.
441  */
442 #define XML_SCHEMAS_TYPE_VARIETY_ABSENT    1 << 5
443 /**
444  * XML_SCHEMAS_TYPE_VARIETY_LIST:
445  *
446  * the simpleType has a variety of "list".
447  */
448 #define XML_SCHEMAS_TYPE_VARIETY_LIST    1 << 6
449 /**
450  * XML_SCHEMAS_TYPE_VARIETY_UNION:
451  *
452  * the simpleType has a variety of "union".
453  */
454 #define XML_SCHEMAS_TYPE_VARIETY_UNION    1 << 7
455 /**
456  * XML_SCHEMAS_TYPE_VARIETY_ATOMIC:
457  *
458  * the simpleType has a variety of "union".
459  */
460 #define XML_SCHEMAS_TYPE_VARIETY_ATOMIC    1 << 8
461 /**
462  * XML_SCHEMAS_TYPE_FINAL_EXTENSION:
463  *
464  * the complexType has a final of "extension".
465  */
466 #define XML_SCHEMAS_TYPE_FINAL_EXTENSION    1 << 9
467 /**
468  * XML_SCHEMAS_TYPE_FINAL_RESTRICTION:
469  *
470  * the simpleType/complexType has a final of "restriction".
471  */
472 #define XML_SCHEMAS_TYPE_FINAL_RESTRICTION    1 << 10
473 /**
474  * XML_SCHEMAS_TYPE_FINAL_LIST:
475  *
476  * the simpleType has a final of "list".
477  */
478 #define XML_SCHEMAS_TYPE_FINAL_LIST    1 << 11
479 /**
480  * XML_SCHEMAS_TYPE_FINAL_UNION:
481  *
482  * the simpleType has a final of "union".
483  */
484 #define XML_SCHEMAS_TYPE_FINAL_UNION    1 << 12
485 /**
486  * XML_SCHEMAS_TYPE_FINAL_DEFAULT:
487  *
488  * the simpleType has a final of "default".
489  */
490 #define XML_SCHEMAS_TYPE_FINAL_DEFAULT    1 << 13
491 /**
492  * XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE:
493  *
494  * Marks the item as a builtin primitive.
495  */
496 #define XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE    1 << 14
497 /**
498  * XML_SCHEMAS_TYPE_MARKED:
499  *
500  * Marks the item as marked; used for circular checks.
501  */
502 #define XML_SCHEMAS_TYPE_MARKED        1 << 16
503 /**
504  * XML_SCHEMAS_TYPE_BLOCK_DEFAULT:
505  *
506  * the complexType did not specify 'block' so use the default of the
507  * <schema> item.
508  */
509 #define XML_SCHEMAS_TYPE_BLOCK_DEFAULT    1 << 17
510 /**
511  * XML_SCHEMAS_TYPE_BLOCK_EXTENSION:
512  *
513  * the complexType has a 'block' of "extension".
514  */
515 #define XML_SCHEMAS_TYPE_BLOCK_EXTENSION    1 << 18
516 /**
517  * XML_SCHEMAS_TYPE_BLOCK_RESTRICTION:
518  *
519  * the complexType has a 'block' of "restriction".
520  */
521 #define XML_SCHEMAS_TYPE_BLOCK_RESTRICTION    1 << 19
522 /**
523  * XML_SCHEMAS_TYPE_ABSTRACT:
524  *
525  * the simple/complexType is abstract.
526  */
527 #define XML_SCHEMAS_TYPE_ABSTRACT    1 << 20
528 /**
529  * XML_SCHEMAS_TYPE_FACETSNEEDVALUE:
530  *
531  * indicates if the facets need a computed value
532  */
533 #define XML_SCHEMAS_TYPE_FACETSNEEDVALUE    1 << 21
534 /**
535  * XML_SCHEMAS_TYPE_INTERNAL_RESOLVED:
536  *
537  * indicates that the type was typefixed
538  */
539 #define XML_SCHEMAS_TYPE_INTERNAL_RESOLVED    1 << 22
540 /**
541  * XML_SCHEMAS_TYPE_INTERNAL_INVALID:
542  *
543  * indicates that the type is invalid
544  */
545 #define XML_SCHEMAS_TYPE_INTERNAL_INVALID    1 << 23
546 /**
547  * XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE:
548  *
549  * a whitespace-facet value of "preserve"
550  */
551 #define XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE    1 << 24
552 /**
553  * XML_SCHEMAS_TYPE_WHITESPACE_REPLACE:
554  *
555  * a whitespace-facet value of "replace"
556  */
557 #define XML_SCHEMAS_TYPE_WHITESPACE_REPLACE    1 << 25
558 /**
559  * XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE:
560  *
561  * a whitespace-facet value of "collapse"
562  */
563 #define XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE    1 << 26
564 /**
565  * XML_SCHEMAS_TYPE_HAS_FACETS:
566  *
567  * has facets
568  */
569 #define XML_SCHEMAS_TYPE_HAS_FACETS    1 << 27
570 /**
571  * XML_SCHEMAS_TYPE_NORMVALUENEEDED:
572  *
573  * indicates if the facets (pattern) need a normalized value
574  */
575 #define XML_SCHEMAS_TYPE_NORMVALUENEEDED    1 << 28
576 
577 /**
578  * XML_SCHEMAS_TYPE_FIXUP_1:
579  *
580  * First stage of fixup was done.
581  */
582 #define XML_SCHEMAS_TYPE_FIXUP_1    1 << 29
583 
584 /**
585  * XML_SCHEMAS_TYPE_REDEFINED:
586  *
587  * The type was redefined.
588  */
589 #define XML_SCHEMAS_TYPE_REDEFINED    1 << 30
590 /**
591  * XML_SCHEMAS_TYPE_REDEFINING:
592  *
593  * The type redefines an other type.
594  */
595 /* #define XML_SCHEMAS_TYPE_REDEFINING    1 << 31 */
596 
597 /**
598  * _xmlSchemaType:
599  *
600  * Schemas type definition.
601  */
602 struct _xmlSchemaType {
603     xmlSchemaTypeType type; /* The kind of type */
604     struct _xmlSchemaType *next; /* the next type if in a sequence ... */
605     const xmlChar *name;
606     const xmlChar *id ; /* Deprecated; not used */
607     const xmlChar *ref; /* Deprecated; not used */
608     const xmlChar *refNs; /* Deprecated; not used */
609     xmlSchemaAnnotPtr annot;
610     xmlSchemaTypePtr subtypes;
611     xmlSchemaAttributePtr attributes; /* Deprecated; not used */
612     xmlNodePtr node;
613     int minOccurs; /* Deprecated; not used */
614     int maxOccurs; /* Deprecated; not used */
615 
616     int flags;
617     xmlSchemaContentType contentType;
618     const xmlChar *base; /* Base type's local name */
619     const xmlChar *baseNs; /* Base type's target namespace */
620     xmlSchemaTypePtr baseType; /* The base type component */
621     xmlSchemaFacetPtr facets; /* Local facets */
622     struct _xmlSchemaType *redef; /* Deprecated; not used */
623     int recurse; /* Obsolete */
624     xmlSchemaAttributeLinkPtr *attributeUses; /* Deprecated; not used */
625     xmlSchemaWildcardPtr attributeWildcard;
626     int builtInType; /* Type of built-in types. */
627     xmlSchemaTypeLinkPtr memberTypes; /* member-types if a union type. */
628     xmlSchemaFacetLinkPtr facetSet; /* All facets (incl. inherited) */
629     const xmlChar *refPrefix; /* Deprecated; not used */
630     xmlSchemaTypePtr contentTypeDef; /* Used for the simple content of complex types.
631                                         Could we use @subtypes for this? */
632     xmlRegexpPtr contModel; /* Holds the automaton of the content model */
633     const xmlChar *targetNamespace;
634     void *attrUses;
635 };
636 
637 /*
638  * xmlSchemaElement:
639  * An element definition.
640  *
641  * xmlSchemaType, xmlSchemaFacet and xmlSchemaElement start of
642  * structures must be kept similar
643  */
644 /**
645  * XML_SCHEMAS_ELEM_NILLABLE:
646  *
647  * the element is nillable
648  */
649 #define XML_SCHEMAS_ELEM_NILLABLE        1 << 0
650 /**
651  * XML_SCHEMAS_ELEM_GLOBAL:
652  *
653  * the element is global
654  */
655 #define XML_SCHEMAS_ELEM_GLOBAL                1 << 1
656 /**
657  * XML_SCHEMAS_ELEM_DEFAULT:
658  *
659  * the element has a default value
660  */
661 #define XML_SCHEMAS_ELEM_DEFAULT        1 << 2
662 /**
663  * XML_SCHEMAS_ELEM_FIXED:
664  *
665  * the element has a fixed value
666  */
667 #define XML_SCHEMAS_ELEM_FIXED                1 << 3
668 /**
669  * XML_SCHEMAS_ELEM_ABSTRACT:
670  *
671  * the element is abstract
672  */
673 #define XML_SCHEMAS_ELEM_ABSTRACT        1 << 4
674 /**
675  * XML_SCHEMAS_ELEM_TOPLEVEL:
676  *
677  * the element is top level
678  * obsolete: use XML_SCHEMAS_ELEM_GLOBAL instead
679  */
680 #define XML_SCHEMAS_ELEM_TOPLEVEL        1 << 5
681 /**
682  * XML_SCHEMAS_ELEM_REF:
683  *
684  * the element is a reference to a type
685  */
686 #define XML_SCHEMAS_ELEM_REF                1 << 6
687 /**
688  * XML_SCHEMAS_ELEM_NSDEFAULT:
689  *
690  * allow elements in no namespace
691  * Obsolete, not used anymore.
692  */
693 #define XML_SCHEMAS_ELEM_NSDEFAULT        1 << 7
694 /**
695  * XML_SCHEMAS_ELEM_INTERNAL_RESOLVED:
696  *
697  * this is set when "type", "ref", "substitutionGroup"
698  * references have been resolved.
699  */
700 #define XML_SCHEMAS_ELEM_INTERNAL_RESOLVED        1 << 8
701  /**
702  * XML_SCHEMAS_ELEM_CIRCULAR:
703  *
704  * a helper flag for the search of circular references.
705  */
706 #define XML_SCHEMAS_ELEM_CIRCULAR        1 << 9
707 /**
708  * XML_SCHEMAS_ELEM_BLOCK_ABSENT:
709  *
710  * the "block" attribute is absent
711  */
712 #define XML_SCHEMAS_ELEM_BLOCK_ABSENT        1 << 10
713 /**
714  * XML_SCHEMAS_ELEM_BLOCK_EXTENSION:
715  *
716  * disallowed substitutions are absent
717  */
718 #define XML_SCHEMAS_ELEM_BLOCK_EXTENSION        1 << 11
719 /**
720  * XML_SCHEMAS_ELEM_BLOCK_RESTRICTION:
721  *
722  * disallowed substitutions: "restriction"
723  */
724 #define XML_SCHEMAS_ELEM_BLOCK_RESTRICTION        1 << 12
725 /**
726  * XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION:
727  *
728  * disallowed substitutions: "substituion"
729  */
730 #define XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION        1 << 13
731 /**
732  * XML_SCHEMAS_ELEM_FINAL_ABSENT:
733  *
734  * substitution group exclusions are absent
735  */
736 #define XML_SCHEMAS_ELEM_FINAL_ABSENT        1 << 14
737 /**
738  * XML_SCHEMAS_ELEM_FINAL_EXTENSION:
739  *
740  * substitution group exclusions: "extension"
741  */
742 #define XML_SCHEMAS_ELEM_FINAL_EXTENSION        1 << 15
743 /**
744  * XML_SCHEMAS_ELEM_FINAL_RESTRICTION:
745  *
746  * substitution group exclusions: "restriction"
747  */
748 #define XML_SCHEMAS_ELEM_FINAL_RESTRICTION        1 << 16
749 /**
750  * XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD:
751  *
752  * the declaration is a substitution group head
753  */
754 #define XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD        1 << 17
755 /**
756  * XML_SCHEMAS_ELEM_INTERNAL_CHECKED:
757  *
758  * this is set when the elem decl has been checked against
759  * all constraints
760  */
761 #define XML_SCHEMAS_ELEM_INTERNAL_CHECKED        1 << 18
762 
763 typedef struct _xmlSchemaElement xmlSchemaElement;
764 typedef xmlSchemaElement *xmlSchemaElementPtr;
765 struct _xmlSchemaElement {
766     xmlSchemaTypeType type; /* The kind of type */
767     struct _xmlSchemaType *next; /* Not used? */
768     const xmlChar *name;
769     const xmlChar *id; /* Deprecated; not used */
770     const xmlChar *ref; /* Deprecated; not used */
771     const xmlChar *refNs; /* Deprecated; not used */
772     xmlSchemaAnnotPtr annot;
773     xmlSchemaTypePtr subtypes; /* the type definition */
774     xmlSchemaAttributePtr attributes;
775     xmlNodePtr node;
776     int minOccurs; /* Deprecated; not used */
777     int maxOccurs; /* Deprecated; not used */
778 
779     int flags;
780     const xmlChar *targetNamespace;
781     const xmlChar *namedType;
782     const xmlChar *namedTypeNs;
783     const xmlChar *substGroup;
784     const xmlChar *substGroupNs;
785     const xmlChar *scope;
786     const xmlChar *value; /* The original value of the value constraint. */
787     struct _xmlSchemaElement *refDecl; /* This will now be used for the
788                                           substitution group affiliation */
789     xmlRegexpPtr contModel; /* Obsolete for WXS, maybe used for RelaxNG */
790     xmlSchemaContentType contentType;
791     const xmlChar *refPrefix; /* Deprecated; not used */
792     xmlSchemaValPtr defVal; /* The compiled value contraint. */
793     void *idcs; /* The identity-constraint defs */
794 };
795 
796 /*
797  * XML_SCHEMAS_FACET_UNKNOWN:
798  *
799  * unknown facet handling
800  */
801 #define XML_SCHEMAS_FACET_UNKNOWN        0
802 /*
803  * XML_SCHEMAS_FACET_PRESERVE:
804  *
805  * preserve the type of the facet
806  */
807 #define XML_SCHEMAS_FACET_PRESERVE        1
808 /*
809  * XML_SCHEMAS_FACET_REPLACE:
810  *
811  * replace the type of the facet
812  */
813 #define XML_SCHEMAS_FACET_REPLACE        2
814 /*
815  * XML_SCHEMAS_FACET_COLLAPSE:
816  *
817  * collapse the types of the facet
818  */
819 #define XML_SCHEMAS_FACET_COLLAPSE        3
820 /**
821  * A facet definition.
822  */
823 struct _xmlSchemaFacet {
824     xmlSchemaTypeType type;        /* The kind of type */
825     struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
826     const xmlChar *value; /* The original value */
827     const xmlChar *id; /* Obsolete */
828     xmlSchemaAnnotPtr annot;
829     xmlNodePtr node;
830     int fixed; /* XML_SCHEMAS_FACET_PRESERVE, etc. */
831     int whitespace;
832     xmlSchemaValPtr val; /* The compiled value */
833     xmlRegexpPtr    regexp; /* The regex for patterns */
834 };
835 
836 /**
837  * A notation definition.
838  */
839 typedef struct _xmlSchemaNotation xmlSchemaNotation;
840 typedef xmlSchemaNotation *xmlSchemaNotationPtr;
841 struct _xmlSchemaNotation {
842     xmlSchemaTypeType type; /* The kind of type */
843     const xmlChar *name;
844     xmlSchemaAnnotPtr annot;
845     const xmlChar *identifier;
846     const xmlChar *targetNamespace;
847 };
848 
849 /*
850 * TODO: Actually all those flags used for the schema should sit
851 * on the schema parser context, since they are used only
852 * during parsing an XML schema document, and not available
853 * on the component level as per spec.
854 */
855 /**
856  * XML_SCHEMAS_QUALIF_ELEM:
857  *
858  * Reflects elementFormDefault == qualified in
859  * an XML schema document.
860  */
861 #define XML_SCHEMAS_QUALIF_ELEM                1 << 0
862 /**
863  * XML_SCHEMAS_QUALIF_ATTR:
864  *
865  * Reflects attributeFormDefault == qualified in
866  * an XML schema document.
867  */
868 #define XML_SCHEMAS_QUALIF_ATTR            1 << 1
869 /**
870  * XML_SCHEMAS_FINAL_DEFAULT_EXTENSION:
871  *
872  * the schema has "extension" in the set of finalDefault.
873  */
874 #define XML_SCHEMAS_FINAL_DEFAULT_EXTENSION        1 << 2
875 /**
876  * XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION:
877  *
878  * the schema has "restriction" in the set of finalDefault.
879  */
880 #define XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION            1 << 3
881 /**
882  * XML_SCHEMAS_FINAL_DEFAULT_LIST:
883  *
884  * the cshema has "list" in the set of finalDefault.
885  */
886 #define XML_SCHEMAS_FINAL_DEFAULT_LIST            1 << 4
887 /**
888  * XML_SCHEMAS_FINAL_DEFAULT_UNION:
889  *
890  * the schema has "union" in the set of finalDefault.
891  */
892 #define XML_SCHEMAS_FINAL_DEFAULT_UNION            1 << 5
893 /**
894  * XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION:
895  *
896  * the schema has "extension" in the set of blockDefault.
897  */
898 #define XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION            1 << 6
899 /**
900  * XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION:
901  *
902  * the schema has "restriction" in the set of blockDefault.
903  */
904 #define XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION            1 << 7
905 /**
906  * XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION:
907  *
908  * the schema has "substitution" in the set of blockDefault.
909  */
910 #define XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION            1 << 8
911 /**
912  * XML_SCHEMAS_INCLUDING_CONVERT_NS:
913  *
914  * the schema is currently including an other schema with
915  * no target namespace.
916  */
917 #define XML_SCHEMAS_INCLUDING_CONVERT_NS            1 << 9
918 /**
919  * _xmlSchema:
920  *
921  * A Schemas definition
922  */
923 struct _xmlSchema {
924     const xmlChar *name; /* schema name */
925     const xmlChar *targetNamespace; /* the target namespace */
926     const xmlChar *version;
927     const xmlChar *id; /* Obsolete */
928     xmlDocPtr doc;
929     xmlSchemaAnnotPtr annot;
930     int flags;
931 
932     xmlHashTablePtr typeDecl;
933     xmlHashTablePtr attrDecl;
934     xmlHashTablePtr attrgrpDecl;
935     xmlHashTablePtr elemDecl;
936     xmlHashTablePtr notaDecl;
937 
938     xmlHashTablePtr schemasImports;
939 
940     void *_private;        /* unused by the library for users or bindings */
941     xmlHashTablePtr groupDecl;
942     xmlDictPtr      dict;
943     void *includes;     /* the includes, this is opaque for now */
944     int preserve;        /* whether to free the document */
945     int counter; /* used to give ononymous components unique names */
946     xmlHashTablePtr idcDef; /* All identity-constraint defs. */
947     void *volatiles; /* Obsolete */
948 };
949 
950 XMLPUBFUN void XMLCALL         xmlSchemaFreeType        (xmlSchemaTypePtr type);
951 XMLPUBFUN void XMLCALL         xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard);
952 
953 #ifdef __cplusplus
954 }
955 #endif
956 
957 #endif /* LIBXML_SCHEMAS_ENABLED */
958 #endif /* __XML_SCHEMA_INTERNALS_H__ */
959