gettext-tools/gnulib-lib/libxml/schemasInternals.in.h

   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 garanteed 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,
  32     XML_SCHEMAS_NORMSTRING,
  33     XML_SCHEMAS_DECIMAL,
  34     XML_SCHEMAS_TIME,
  35     XML_SCHEMAS_GDAY,
  36     XML_SCHEMAS_GMONTH,
  37     XML_SCHEMAS_GMONTHDAY,
  38     XML_SCHEMAS_GYEAR,
  39     XML_SCHEMAS_GYEARMONTH,
  40     XML_SCHEMAS_DATE,
  41     XML_SCHEMAS_DATETIME,
  42     XML_SCHEMAS_DURATION,
  43     XML_SCHEMAS_FLOAT,
  44     XML_SCHEMAS_DOUBLE,
  45     XML_SCHEMAS_BOOLEAN,
  46     XML_SCHEMAS_TOKEN,
  47     XML_SCHEMAS_LANGUAGE,
  48     XML_SCHEMAS_NMTOKEN,
  49     XML_SCHEMAS_NMTOKENS,
  50     XML_SCHEMAS_NAME,
  51     XML_SCHEMAS_QNAME,
  52     XML_SCHEMAS_NCNAME,
  53     XML_SCHEMAS_ID,
  54     XML_SCHEMAS_IDREF,
  55     XML_SCHEMAS_IDREFS,
  56     XML_SCHEMAS_ENTITY,
  57     XML_SCHEMAS_ENTITIES,
  58     XML_SCHEMAS_NOTATION,
  59     XML_SCHEMAS_ANYURI,
  60     XML_SCHEMAS_INTEGER,
  61     XML_SCHEMAS_NPINTEGER,
  62     XML_SCHEMAS_NINTEGER,
  63     XML_SCHEMAS_NNINTEGER,
  64     XML_SCHEMAS_PINTEGER,
  65     XML_SCHEMAS_INT,
  66     XML_SCHEMAS_UINT,
  67     XML_SCHEMAS_LONG,
  68     XML_SCHEMAS_ULONG,
  69     XML_SCHEMAS_SHORT,
  70     XML_SCHEMAS_USHORT,
  71     XML_SCHEMAS_BYTE,
  72     XML_SCHEMAS_UBYTE,
  73     XML_SCHEMAS_HEXBINARY,
  74     XML_SCHEMAS_BASE64BINARY,
  75     XML_SCHEMAS_ANYTYPE,
  76     XML_SCHEMAS_ANYSIMPLETYPE
  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__ */