Annotation of embedaddon/libxml2/include/libxml/schemasInternals.h, revision 1.1.1.2

1.1       misho       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,
1.1.1.2 ! misho     107:     XML_SCHEMA_TYPE_PARTICLE = 25,
        !           108:     XML_SCHEMA_TYPE_ATTRIBUTE_USE,
1.1       misho     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__ */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>