1: /*
2: * schemas.c : implementation of the XML Schema handling and
3: * schema validity checking
4: *
5: * See Copyright for the status of this software.
6: *
7: * Daniel Veillard <veillard@redhat.com>
8: */
9:
10: /*
11: * TODO:
12: * - when types are redefined in includes, check that all
13: * types in the redef list are equal
14: * -> need a type equality operation.
15: * - if we don't intend to use the schema for schemas, we
16: * need to validate all schema attributes (ref, type, name)
17: * against their types.
18: * - Eliminate item creation for: ??
19: *
20: * URGENT TODO:
21: * - For xsi-driven schema acquisition, augment the IDCs after every
22: * acquisition episode (xmlSchemaAugmentIDC).
23: *
24: * NOTES:
25: * - Elimated item creation for: <restriction>, <extension>,
26: * <simpleContent>, <complexContent>, <list>, <union>
27: *
28: * PROBLEMS:
29: * - http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0337.html
30: * IDC XPath expression and chameleon includes: the targetNamespace is changed, so
31: * XPath will have trouble to resolve to this namespace, since not known.
32: *
33: *
34: * CONSTRAINTS:
35: *
36: * Schema Component Constraint:
37: * All Group Limited (cos-all-limited)
38: * Status: complete
39: * (1.2)
40: * In xmlSchemaGroupDefReferenceTermFixup() and
41: * (2)
42: * In xmlSchemaParseModelGroup()
43: * TODO: Actually this should go to component-level checks,
44: * but is done here due to performance. Move it to an other layer
45: * is schema construction via an API is implemented.
46: */
47: #define IN_LIBXML
48: #include "libxml.h"
49:
50: #ifdef LIBXML_SCHEMAS_ENABLED
51:
52: #include <string.h>
53: #include <libxml/xmlmemory.h>
54: #include <libxml/parser.h>
55: #include <libxml/parserInternals.h>
56: #include <libxml/hash.h>
57: #include <libxml/uri.h>
58: #include <libxml/xmlschemas.h>
59: #include <libxml/schemasInternals.h>
60: #include <libxml/xmlschemastypes.h>
61: #include <libxml/xmlautomata.h>
62: #include <libxml/xmlregexp.h>
63: #include <libxml/dict.h>
64: #include <libxml/encoding.h>
65: #include <libxml/xmlIO.h>
66: #ifdef LIBXML_PATTERN_ENABLED
67: #include <libxml/pattern.h>
68: #endif
69: #ifdef LIBXML_READER_ENABLED
70: #include <libxml/xmlreader.h>
71: #endif
72:
73: /* #define DEBUG 1 */
74:
75: /* #define DEBUG_CONTENT 1 */
76:
77: /* #define DEBUG_TYPE 1 */
78:
79: /* #define DEBUG_CONTENT_REGEXP 1 */
80:
81: /* #define DEBUG_AUTOMATA 1 */
82:
83: /* #define DEBUG_IDC */
84:
85: /* #define DEBUG_IDC_NODE_TABLE */
86:
87: /* #define WXS_ELEM_DECL_CONS_ENABLED */
88:
89: #ifdef DEBUG_IDC
90: #ifndef DEBUG_IDC_NODE_TABLE
91: #define DEBUG_IDC_NODE_TABLE
92: #endif
93: #endif
94:
95: /* #define ENABLE_PARTICLE_RESTRICTION 1 */
96:
97: #define ENABLE_REDEFINE
98:
99: /* #define ENABLE_NAMED_LOCALS */
100:
101: /* #define ENABLE_IDC_NODE_TABLES_TEST */
102:
103: #define DUMP_CONTENT_MODEL
104:
105: #ifdef LIBXML_READER_ENABLED
106: /* #define XML_SCHEMA_READER_ENABLED */
107: #endif
108:
109: #define UNBOUNDED (1 << 30)
110: #define TODO \
111: xmlGenericError(xmlGenericErrorContext, \
112: "Unimplemented block at %s:%d\n", \
113: __FILE__, __LINE__);
114:
115: #define XML_SCHEMAS_NO_NAMESPACE (const xmlChar *) "##"
116:
117: /*
118: * The XML Schemas namespaces
119: */
120: static const xmlChar *xmlSchemaNs = (const xmlChar *)
121: "http://www.w3.org/2001/XMLSchema";
122:
123: static const xmlChar *xmlSchemaInstanceNs = (const xmlChar *)
124: "http://www.w3.org/2001/XMLSchema-instance";
125:
126: static const xmlChar *xmlNamespaceNs = (const xmlChar *)
127: "http://www.w3.org/2000/xmlns/";
128:
129: /*
130: * Come casting macros.
131: */
132: #define ACTXT_CAST (xmlSchemaAbstractCtxtPtr)
133: #define PCTXT_CAST (xmlSchemaParserCtxtPtr)
134: #define VCTXT_CAST (xmlSchemaValidCtxtPtr)
135: #define WXS_BASIC_CAST (xmlSchemaBasicItemPtr)
136: #define WXS_TREE_CAST (xmlSchemaTreeItemPtr)
137: #define WXS_PTC_CAST (xmlSchemaParticlePtr)
138: #define WXS_TYPE_CAST (xmlSchemaTypePtr)
139: #define WXS_ELEM_CAST (xmlSchemaElementPtr)
140: #define WXS_ATTR_GROUP_CAST (xmlSchemaAttributeGroupPtr)
141: #define WXS_ATTR_CAST (xmlSchemaAttributePtr)
142: #define WXS_ATTR_USE_CAST (xmlSchemaAttributeUsePtr)
143: #define WXS_ATTR_PROHIB_CAST (xmlSchemaAttributeUseProhibPtr)
144: #define WXS_MODEL_GROUPDEF_CAST (xmlSchemaModelGroupDefPtr)
145: #define WXS_MODEL_GROUP_CAST (xmlSchemaModelGroupPtr)
146: #define WXS_IDC_CAST (xmlSchemaIDCPtr)
147: #define WXS_QNAME_CAST (xmlSchemaQNameRefPtr)
148: #define WXS_LIST_CAST (xmlSchemaItemListPtr)
149:
150: /*
151: * Macros to query common properties of components.
152: */
153: #define WXS_ITEM_NODE(i) xmlSchemaGetComponentNode(WXS_BASIC_CAST (i))
154:
155: #define WXS_ITEM_TYPE_NAME(i) xmlSchemaGetComponentTypeStr(WXS_BASIC_CAST (i))
156: /*
157: * Macros for element declarations.
158: */
159: #define WXS_ELEM_TYPEDEF(e) (e)->subtypes
160:
161: #define WXS_SUBST_HEAD(item) (item)->refDecl
162: /*
163: * Macros for attribute declarations.
164: */
165: #define WXS_ATTR_TYPEDEF(a) (a)->subtypes
166: /*
167: * Macros for attribute uses.
168: */
169: #define WXS_ATTRUSE_DECL(au) WXS_ATTR_CAST (WXS_ATTR_USE_CAST (au))->attrDecl
170:
171: #define WXS_ATTRUSE_TYPEDEF(au) WXS_ATTR_TYPEDEF(WXS_ATTRUSE_DECL( WXS_ATTR_USE_CAST au))
172:
173: #define WXS_ATTRUSE_DECL_NAME(au) (WXS_ATTRUSE_DECL(au))->name
174:
175: #define WXS_ATTRUSE_DECL_TNS(au) (WXS_ATTRUSE_DECL(au))->targetNamespace
176: /*
177: * Macros for attribute groups.
178: */
179: #define WXS_ATTR_GROUP_HAS_REFS(ag) ((WXS_ATTR_GROUP_CAST (ag))->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS)
180: #define WXS_ATTR_GROUP_EXPANDED(ag) ((WXS_ATTR_GROUP_CAST (ag))->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED)
181: /*
182: * Macros for particles.
183: */
184: #define WXS_PARTICLE(p) WXS_PTC_CAST (p)
185:
186: #define WXS_PARTICLE_TERM(p) (WXS_PARTICLE(p))->children
187:
188: #define WXS_PARTICLE_TERM_AS_ELEM(p) (WXS_ELEM_CAST WXS_PARTICLE_TERM(p))
189:
190: #define WXS_PARTICLE_MODEL(p) WXS_MODEL_GROUP_CAST WXS_PARTICLE(p)->children
191: /*
192: * Macros for model groups definitions.
193: */
194: #define WXS_MODELGROUPDEF_MODEL(mgd) (WXS_MODEL_GROUP_CAST (mgd))->children
195: /*
196: * Macros for model groups.
197: */
198: #define WXS_IS_MODEL_GROUP(i) \
199: (((i)->type == XML_SCHEMA_TYPE_SEQUENCE) || \
200: ((i)->type == XML_SCHEMA_TYPE_CHOICE) || \
201: ((i)->type == XML_SCHEMA_TYPE_ALL))
202:
203: #define WXS_MODELGROUP_PARTICLE(mg) WXS_PTC_CAST (mg)->children
204: /*
205: * Macros for schema buckets.
206: */
207: #define WXS_IS_BUCKET_INCREDEF(t) (((t) == XML_SCHEMA_SCHEMA_INCLUDE) || \
208: ((t) == XML_SCHEMA_SCHEMA_REDEFINE))
209:
210: #define WXS_IS_BUCKET_IMPMAIN(t) (((t) == XML_SCHEMA_SCHEMA_MAIN) || \
211: ((t) == XML_SCHEMA_SCHEMA_IMPORT))
212:
213: #define WXS_IMPBUCKET(b) ((xmlSchemaImportPtr) (b))
214:
215: #define WXS_INCBUCKET(b) ((xmlSchemaIncludePtr) (b))
216: /*
217: * Macros for complex/simple types.
218: */
219: #define WXS_IS_ANYTYPE(i) \
220: (( (i)->type == XML_SCHEMA_TYPE_BASIC) && \
221: ( (WXS_TYPE_CAST (i))->builtInType == XML_SCHEMAS_ANYTYPE))
222:
223: #define WXS_IS_COMPLEX(i) \
224: (((i)->type == XML_SCHEMA_TYPE_COMPLEX) || \
225: ((i)->builtInType == XML_SCHEMAS_ANYTYPE))
226:
227: #define WXS_IS_SIMPLE(item) \
228: ((item->type == XML_SCHEMA_TYPE_SIMPLE) || \
229: ((item->type == XML_SCHEMA_TYPE_BASIC) && \
230: (item->builtInType != XML_SCHEMAS_ANYTYPE)))
231:
232: #define WXS_IS_ANY_SIMPLE_TYPE(i) \
233: (((i)->type == XML_SCHEMA_TYPE_BASIC) && \
234: ((i)->builtInType == XML_SCHEMAS_ANYSIMPLETYPE))
235:
236: #define WXS_IS_RESTRICTION(t) \
237: ((t)->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION)
238:
239: #define WXS_IS_EXTENSION(t) \
240: ((t)->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION)
241:
242: #define WXS_IS_TYPE_NOT_FIXED(i) \
243: (((i)->type != XML_SCHEMA_TYPE_BASIC) && \
244: (((i)->flags & XML_SCHEMAS_TYPE_INTERNAL_RESOLVED) == 0))
245:
246: #define WXS_IS_TYPE_NOT_FIXED_1(item) \
247: (((item)->type != XML_SCHEMA_TYPE_BASIC) && \
248: (((item)->flags & XML_SCHEMAS_TYPE_FIXUP_1) == 0))
249:
250: #define WXS_TYPE_IS_GLOBAL(t) ((t)->flags & XML_SCHEMAS_TYPE_GLOBAL)
251:
252: #define WXS_TYPE_IS_LOCAL(t) (((t)->flags & XML_SCHEMAS_TYPE_GLOBAL) == 0)
253: /*
254: * Macros for exclusively for complex types.
255: */
256: #define WXS_HAS_COMPLEX_CONTENT(item) \
257: ((item->contentType == XML_SCHEMA_CONTENT_MIXED) || \
258: (item->contentType == XML_SCHEMA_CONTENT_EMPTY) || \
259: (item->contentType == XML_SCHEMA_CONTENT_ELEMENTS))
260:
261: #define WXS_HAS_SIMPLE_CONTENT(item) \
262: ((item->contentType == XML_SCHEMA_CONTENT_SIMPLE) || \
263: (item->contentType == XML_SCHEMA_CONTENT_BASIC))
264:
265: #define WXS_HAS_MIXED_CONTENT(item) \
266: (item->contentType == XML_SCHEMA_CONTENT_MIXED)
267:
268: #define WXS_EMPTIABLE(t) \
269: (xmlSchemaIsParticleEmptiable(WXS_PTC_CAST (t)->subtypes))
270:
271: #define WXS_TYPE_CONTENTTYPE(t) (t)->subtypes
272:
273: #define WXS_TYPE_PARTICLE(t) WXS_PTC_CAST (t)->subtypes
274:
275: #define WXS_TYPE_PARTICLE_TERM(t) WXS_PARTICLE_TERM(WXS_TYPE_PARTICLE(t))
276: /*
277: * Macros for exclusively for simple types.
278: */
279: #define WXS_LIST_ITEMTYPE(t) (t)->subtypes
280:
281: #define WXS_IS_ATOMIC(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_ATOMIC)
282:
283: #define WXS_IS_LIST(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_LIST)
284:
285: #define WXS_IS_UNION(t) (t->flags & XML_SCHEMAS_TYPE_VARIETY_UNION)
286: /*
287: * Misc parser context macros.
288: */
289: #define WXS_CONSTRUCTOR(ctx) (ctx)->constructor
290:
291: #define WXS_HAS_BUCKETS(ctx) \
292: ( (WXS_CONSTRUCTOR((ctx))->buckets != NULL) && \
293: (WXS_CONSTRUCTOR((ctx))->buckets->nbItems > 0) )
294:
295: #define WXS_SUBST_GROUPS(ctx) WXS_CONSTRUCTOR((ctx))->substGroups
296:
297: #define WXS_BUCKET(ctx) WXS_CONSTRUCTOR((ctx))->bucket
298:
299: #define WXS_SCHEMA(ctx) (ctx)->schema
300:
301: #define WXS_ADD_LOCAL(ctx, item) \
302: xmlSchemaAddItemSize(&(WXS_BUCKET(ctx)->locals), 10, item)
303:
304: #define WXS_ADD_GLOBAL(ctx, item) \
305: xmlSchemaAddItemSize(&(WXS_BUCKET(ctx)->globals), 5, item)
306:
307: #define WXS_ADD_PENDING(ctx, item) \
308: xmlSchemaAddItemSize(&((ctx)->constructor->pending), 10, item)
309: /*
310: * xmlSchemaItemList macros.
311: */
312: #define WXS_ILIST_IS_EMPTY(l) ((l == NULL) || ((l)->nbItems == 0))
313: /*
314: * Misc macros.
315: */
316: #define IS_SCHEMA(node, type) \
317: ((node != NULL) && (node->ns != NULL) && \
318: (xmlStrEqual(node->name, (const xmlChar *) type)) && \
319: (xmlStrEqual(node->ns->href, xmlSchemaNs)))
320:
321: #define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; }
322:
323: /*
324: * Since we put the default/fixed values into the dict, we can
325: * use pointer comparison for those values.
326: * REMOVED: (xmlStrEqual((v1), (v2)))
327: */
328: #define WXS_ARE_DEFAULT_STR_EQUAL(v1, v2) ((v1) == (v2))
329:
330: #define INODE_NILLED(item) (item->flags & XML_SCHEMA_ELEM_INFO_NILLED)
331:
332: #define CAN_PARSE_SCHEMA(b) (((b)->doc != NULL) && ((b)->parsed == 0))
333:
334: #define HFAILURE if (res == -1) goto exit_failure;
335:
336: #define HERROR if (res != 0) goto exit_error;
337:
338: #define HSTOP(ctx) if ((ctx)->stop) goto exit;
339: /*
340: * Some flags used for various schema constraints.
341: */
342: #define SUBSET_RESTRICTION 1<<0
343: #define SUBSET_EXTENSION 1<<1
344: #define SUBSET_SUBSTITUTION 1<<2
345: #define SUBSET_LIST 1<<3
346: #define SUBSET_UNION 1<<4
347:
348: typedef struct _xmlSchemaNodeInfo xmlSchemaNodeInfo;
349: typedef xmlSchemaNodeInfo *xmlSchemaNodeInfoPtr;
350:
351: typedef struct _xmlSchemaItemList xmlSchemaItemList;
352: typedef xmlSchemaItemList *xmlSchemaItemListPtr;
353: struct _xmlSchemaItemList {
354: void **items; /* used for dynamic addition of schemata */
355: int nbItems; /* used for dynamic addition of schemata */
356: int sizeItems; /* used for dynamic addition of schemata */
357: };
358:
359: #define XML_SCHEMA_CTXT_PARSER 1
360: #define XML_SCHEMA_CTXT_VALIDATOR 2
361:
362: typedef struct _xmlSchemaAbstractCtxt xmlSchemaAbstractCtxt;
363: typedef xmlSchemaAbstractCtxt *xmlSchemaAbstractCtxtPtr;
364: struct _xmlSchemaAbstractCtxt {
365: int type; /* E.g. XML_SCHEMA_CTXT_VALIDATOR */
366: };
367:
368: typedef struct _xmlSchemaBucket xmlSchemaBucket;
369: typedef xmlSchemaBucket *xmlSchemaBucketPtr;
370:
371: #define XML_SCHEMA_SCHEMA_MAIN 0
372: #define XML_SCHEMA_SCHEMA_IMPORT 1
373: #define XML_SCHEMA_SCHEMA_INCLUDE 2
374: #define XML_SCHEMA_SCHEMA_REDEFINE 3
375:
376: /**
377: * xmlSchemaSchemaRelation:
378: *
379: * Used to create a graph of schema relationships.
380: */
381: typedef struct _xmlSchemaSchemaRelation xmlSchemaSchemaRelation;
382: typedef xmlSchemaSchemaRelation *xmlSchemaSchemaRelationPtr;
383: struct _xmlSchemaSchemaRelation {
384: xmlSchemaSchemaRelationPtr next;
385: int type; /* E.g. XML_SCHEMA_SCHEMA_IMPORT */
386: const xmlChar *importNamespace;
387: xmlSchemaBucketPtr bucket;
388: };
389:
390: #define XML_SCHEMA_BUCKET_MARKED 1<<0
391: #define XML_SCHEMA_BUCKET_COMPS_ADDED 1<<1
392:
393: struct _xmlSchemaBucket {
394: int type;
395: int flags;
396: const xmlChar *schemaLocation;
397: const xmlChar *origTargetNamespace;
398: const xmlChar *targetNamespace;
399: xmlDocPtr doc;
400: xmlSchemaSchemaRelationPtr relations;
401: int located;
402: int parsed;
403: int imported;
404: int preserveDoc;
405: xmlSchemaItemListPtr globals; /* Global components. */
406: xmlSchemaItemListPtr locals; /* Local components. */
407: };
408:
409: /**
410: * xmlSchemaImport:
411: * (extends xmlSchemaBucket)
412: *
413: * Reflects a schema. Holds some information
414: * about the schema and its toplevel components. Duplicate
415: * toplevel components are not checked at this level.
416: */
417: typedef struct _xmlSchemaImport xmlSchemaImport;
418: typedef xmlSchemaImport *xmlSchemaImportPtr;
419: struct _xmlSchemaImport {
420: int type; /* Main OR import OR include. */
421: int flags;
422: const xmlChar *schemaLocation; /* The URI of the schema document. */
423: /* For chameleon includes, @origTargetNamespace will be NULL */
424: const xmlChar *origTargetNamespace;
425: /*
426: * For chameleon includes, @targetNamespace will be the
427: * targetNamespace of the including schema.
428: */
429: const xmlChar *targetNamespace;
430: xmlDocPtr doc; /* The schema node-tree. */
431: /* @relations will hold any included/imported/redefined schemas. */
432: xmlSchemaSchemaRelationPtr relations;
433: int located;
434: int parsed;
435: int imported;
436: int preserveDoc;
437: xmlSchemaItemListPtr globals;
438: xmlSchemaItemListPtr locals;
439: /* The imported schema. */
440: xmlSchemaPtr schema;
441: };
442:
443: /*
444: * (extends xmlSchemaBucket)
445: */
446: typedef struct _xmlSchemaInclude xmlSchemaInclude;
447: typedef xmlSchemaInclude *xmlSchemaIncludePtr;
448: struct _xmlSchemaInclude {
449: int type;
450: int flags;
451: const xmlChar *schemaLocation;
452: const xmlChar *origTargetNamespace;
453: const xmlChar *targetNamespace;
454: xmlDocPtr doc;
455: xmlSchemaSchemaRelationPtr relations;
456: int located;
457: int parsed;
458: int imported;
459: int preserveDoc;
460: xmlSchemaItemListPtr globals; /* Global components. */
461: xmlSchemaItemListPtr locals; /* Local components. */
462:
463: /* The owning main or import schema bucket. */
464: xmlSchemaImportPtr ownerImport;
465: };
466:
467: /**
468: * xmlSchemaBasicItem:
469: *
470: * The abstract base type for schema components.
471: */
472: typedef struct _xmlSchemaBasicItem xmlSchemaBasicItem;
473: typedef xmlSchemaBasicItem *xmlSchemaBasicItemPtr;
474: struct _xmlSchemaBasicItem {
475: xmlSchemaTypeType type;
476: };
477:
478: /**
479: * xmlSchemaAnnotItem:
480: *
481: * The abstract base type for annotated schema components.
482: * (Extends xmlSchemaBasicItem)
483: */
484: typedef struct _xmlSchemaAnnotItem xmlSchemaAnnotItem;
485: typedef xmlSchemaAnnotItem *xmlSchemaAnnotItemPtr;
486: struct _xmlSchemaAnnotItem {
487: xmlSchemaTypeType type;
488: xmlSchemaAnnotPtr annot;
489: };
490:
491: /**
492: * xmlSchemaTreeItem:
493: *
494: * The abstract base type for tree-like structured schema components.
495: * (Extends xmlSchemaAnnotItem)
496: */
497: typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
498: typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
499: struct _xmlSchemaTreeItem {
500: xmlSchemaTypeType type;
501: xmlSchemaAnnotPtr annot;
502: xmlSchemaTreeItemPtr next;
503: xmlSchemaTreeItemPtr children;
504: };
505:
506:
507: #define XML_SCHEMA_ATTR_USE_FIXED 1<<0
508: /**
509: * xmlSchemaAttributeUsePtr:
510: *
511: * The abstract base type for tree-like structured schema components.
512: * (Extends xmlSchemaTreeItem)
513: */
514: typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
515: typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
516: struct _xmlSchemaAttributeUse {
517: xmlSchemaTypeType type;
518: xmlSchemaAnnotPtr annot;
519: xmlSchemaAttributeUsePtr next; /* The next attr. use. */
520: /*
521: * The attr. decl. OR a QName-ref. to an attr. decl. OR
522: * a QName-ref. to an attribute group definition.
523: */
524: xmlSchemaAttributePtr attrDecl;
525:
526: int flags;
527: xmlNodePtr node;
528: int occurs; /* required, optional */
529: const xmlChar * defValue;
530: xmlSchemaValPtr defVal;
531: };
532:
533: /**
534: * xmlSchemaAttributeUseProhibPtr:
535: *
536: * A helper component to reflect attribute prohibitions.
537: * (Extends xmlSchemaBasicItem)
538: */
539: typedef struct _xmlSchemaAttributeUseProhib xmlSchemaAttributeUseProhib;
540: typedef xmlSchemaAttributeUseProhib *xmlSchemaAttributeUseProhibPtr;
541: struct _xmlSchemaAttributeUseProhib {
542: xmlSchemaTypeType type; /* == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB */
543: xmlNodePtr node;
544: const xmlChar *name;
545: const xmlChar *targetNamespace;
546: int isRef;
547: };
548:
549: /**
550: * xmlSchemaRedef:
551: */
552: typedef struct _xmlSchemaRedef xmlSchemaRedef;
553: typedef xmlSchemaRedef *xmlSchemaRedefPtr;
554: struct _xmlSchemaRedef {
555: xmlSchemaRedefPtr next;
556: xmlSchemaBasicItemPtr item; /* The redefining component. */
557: xmlSchemaBasicItemPtr reference; /* The referencing component. */
558: xmlSchemaBasicItemPtr target; /* The to-be-redefined component. */
559: const xmlChar *refName; /* The name of the to-be-redefined component. */
560: const xmlChar *refTargetNs; /* The target namespace of the
561: to-be-redefined comp. */
562: xmlSchemaBucketPtr targetBucket; /* The redefined schema. */
563: };
564:
565: /**
566: * xmlSchemaConstructionCtxt:
567: */
568: typedef struct _xmlSchemaConstructionCtxt xmlSchemaConstructionCtxt;
569: typedef xmlSchemaConstructionCtxt *xmlSchemaConstructionCtxtPtr;
570: struct _xmlSchemaConstructionCtxt {
571: xmlSchemaPtr mainSchema; /* The main schema. */
572: xmlSchemaBucketPtr mainBucket; /* The main schema bucket */
573: xmlDictPtr dict;
574: xmlSchemaItemListPtr buckets; /* List of schema buckets. */
575: /* xmlSchemaItemListPtr relations; */ /* List of schema relations. */
576: xmlSchemaBucketPtr bucket; /* The current schema bucket */
577: xmlSchemaItemListPtr pending; /* All Components of all schemas that
578: need to be fixed. */
579: xmlHashTablePtr substGroups;
580: xmlSchemaRedefPtr redefs;
581: xmlSchemaRedefPtr lastRedef;
582: };
583:
584: #define XML_SCHEMAS_PARSE_ERROR 1
585: #define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
586:
587: struct _xmlSchemaParserCtxt {
588: int type;
589: void *errCtxt; /* user specific error context */
590: xmlSchemaValidityErrorFunc error; /* the callback in case of errors */
591: xmlSchemaValidityWarningFunc warning; /* the callback in case of warning */
592: int err;
593: int nberrors;
594: xmlStructuredErrorFunc serror;
595:
596: xmlSchemaConstructionCtxtPtr constructor;
597: int ownsConstructor; /* TODO: Move this to parser *flags*. */
598:
599: /* xmlSchemaPtr topschema; */
600: /* xmlHashTablePtr namespaces; */
601:
602: xmlSchemaPtr schema; /* The main schema in use */
603: int counter;
604:
605: const xmlChar *URL;
606: xmlDocPtr doc;
607: int preserve; /* Whether the doc should be freed */
608:
609: const char *buffer;
610: int size;
611:
612: /*
613: * Used to build complex element content models
614: */
615: xmlAutomataPtr am;
616: xmlAutomataStatePtr start;
617: xmlAutomataStatePtr end;
618: xmlAutomataStatePtr state;
619:
620: xmlDictPtr dict; /* dictionnary for interned string names */
621: xmlSchemaTypePtr ctxtType; /* The current context simple/complex type */
622: int options;
623: xmlSchemaValidCtxtPtr vctxt;
624: int isS4S;
625: int isRedefine;
626: int xsiAssemble;
627: int stop; /* If the parser should stop; i.e. a critical error. */
628: const xmlChar *targetNamespace;
629: xmlSchemaBucketPtr redefined; /* The schema to be redefined. */
630:
631: xmlSchemaRedefPtr redef; /* Used for redefinitions. */
632: int redefCounter; /* Used for redefinitions. */
633: xmlSchemaItemListPtr attrProhibs;
634: };
635:
636: /**
637: * xmlSchemaQNameRef:
638: *
639: * A component reference item (not a schema component)
640: * (Extends xmlSchemaBasicItem)
641: */
642: typedef struct _xmlSchemaQNameRef xmlSchemaQNameRef;
643: typedef xmlSchemaQNameRef *xmlSchemaQNameRefPtr;
644: struct _xmlSchemaQNameRef {
645: xmlSchemaTypeType type;
646: xmlSchemaBasicItemPtr item; /* The resolved referenced item. */
647: xmlSchemaTypeType itemType;
648: const xmlChar *name;
649: const xmlChar *targetNamespace;
650: xmlNodePtr node;
651: };
652:
653: /**
654: * xmlSchemaParticle:
655: *
656: * A particle component.
657: * (Extends xmlSchemaTreeItem)
658: */
659: typedef struct _xmlSchemaParticle xmlSchemaParticle;
660: typedef xmlSchemaParticle *xmlSchemaParticlePtr;
661: struct _xmlSchemaParticle {
662: xmlSchemaTypeType type;
663: xmlSchemaAnnotPtr annot;
664: xmlSchemaTreeItemPtr next; /* next particle */
665: xmlSchemaTreeItemPtr children; /* the "term" (e.g. a model group,
666: a group definition, a XML_SCHEMA_EXTRA_QNAMEREF (if a reference),
667: etc.) */
668: int minOccurs;
669: int maxOccurs;
670: xmlNodePtr node;
671: };
672:
673: /**
674: * xmlSchemaModelGroup:
675: *
676: * A model group component.
677: * (Extends xmlSchemaTreeItem)
678: */
679: typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
680: typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
681: struct _xmlSchemaModelGroup {
682: xmlSchemaTypeType type; /* XML_SCHEMA_TYPE_SEQUENCE, XML_SCHEMA_TYPE_CHOICE, XML_SCHEMA_TYPE_ALL */
683: xmlSchemaAnnotPtr annot;
684: xmlSchemaTreeItemPtr next; /* not used */
685: xmlSchemaTreeItemPtr children; /* first particle (OR "element decl" OR "wildcard") */
686: xmlNodePtr node;
687: };
688:
689: #define XML_SCHEMA_MODEL_GROUP_DEF_MARKED 1<<0
690: #define XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED 1<<1
691: /**
692: * xmlSchemaModelGroupDef:
693: *
694: * A model group definition component.
695: * (Extends xmlSchemaTreeItem)
696: */
697: typedef struct _xmlSchemaModelGroupDef xmlSchemaModelGroupDef;
698: typedef xmlSchemaModelGroupDef *xmlSchemaModelGroupDefPtr;
699: struct _xmlSchemaModelGroupDef {
700: xmlSchemaTypeType type; /* XML_SCHEMA_TYPE_GROUP */
701: xmlSchemaAnnotPtr annot;
702: xmlSchemaTreeItemPtr next; /* not used */
703: xmlSchemaTreeItemPtr children; /* the "model group" */
704: const xmlChar *name;
705: const xmlChar *targetNamespace;
706: xmlNodePtr node;
707: int flags;
708: };
709:
710: typedef struct _xmlSchemaIDC xmlSchemaIDC;
711: typedef xmlSchemaIDC *xmlSchemaIDCPtr;
712:
713: /**
714: * xmlSchemaIDCSelect:
715: *
716: * The identity-constraint "field" and "selector" item, holding the
717: * XPath expression.
718: */
719: typedef struct _xmlSchemaIDCSelect xmlSchemaIDCSelect;
720: typedef xmlSchemaIDCSelect *xmlSchemaIDCSelectPtr;
721: struct _xmlSchemaIDCSelect {
722: xmlSchemaIDCSelectPtr next;
723: xmlSchemaIDCPtr idc;
724: int index; /* an index position if significant for IDC key-sequences */
725: const xmlChar *xpath; /* the XPath expression */
726: void *xpathComp; /* the compiled XPath expression */
727: };
728:
729: /**
730: * xmlSchemaIDC:
731: *
732: * The identity-constraint definition component.
733: * (Extends xmlSchemaAnnotItem)
734: */
735:
736: struct _xmlSchemaIDC {
737: xmlSchemaTypeType type;
738: xmlSchemaAnnotPtr annot;
739: xmlSchemaIDCPtr next;
740: xmlNodePtr node;
741: const xmlChar *name;
742: const xmlChar *targetNamespace;
743: xmlSchemaIDCSelectPtr selector;
744: xmlSchemaIDCSelectPtr fields;
745: int nbFields;
746: xmlSchemaQNameRefPtr ref;
747: };
748:
749: /**
750: * xmlSchemaIDCAug:
751: *
752: * The augmented IDC information used for validation.
753: */
754: typedef struct _xmlSchemaIDCAug xmlSchemaIDCAug;
755: typedef xmlSchemaIDCAug *xmlSchemaIDCAugPtr;
756: struct _xmlSchemaIDCAug {
757: xmlSchemaIDCAugPtr next; /* next in a list */
758: xmlSchemaIDCPtr def; /* the IDC definition */
759: int keyrefDepth; /* the lowest tree level to which IDC
760: tables need to be bubbled upwards */
761: };
762:
763: /**
764: * xmlSchemaPSVIIDCKeySequence:
765: *
766: * The key sequence of a node table item.
767: */
768: typedef struct _xmlSchemaPSVIIDCKey xmlSchemaPSVIIDCKey;
769: typedef xmlSchemaPSVIIDCKey *xmlSchemaPSVIIDCKeyPtr;
770: struct _xmlSchemaPSVIIDCKey {
771: xmlSchemaTypePtr type;
772: xmlSchemaValPtr val;
773: };
774:
775: /**
776: * xmlSchemaPSVIIDCNode:
777: *
778: * The node table item of a node table.
779: */
780: typedef struct _xmlSchemaPSVIIDCNode xmlSchemaPSVIIDCNode;
781: typedef xmlSchemaPSVIIDCNode *xmlSchemaPSVIIDCNodePtr;
782: struct _xmlSchemaPSVIIDCNode {
783: xmlNodePtr node;
784: xmlSchemaPSVIIDCKeyPtr *keys;
785: int nodeLine;
786: int nodeQNameID;
787:
788: };
789:
790: /**
791: * xmlSchemaPSVIIDCBinding:
792: *
793: * The identity-constraint binding item of the [identity-constraint table].
794: */
795: typedef struct _xmlSchemaPSVIIDCBinding xmlSchemaPSVIIDCBinding;
796: typedef xmlSchemaPSVIIDCBinding *xmlSchemaPSVIIDCBindingPtr;
797: struct _xmlSchemaPSVIIDCBinding {
798: xmlSchemaPSVIIDCBindingPtr next; /* next binding of a specific node */
799: xmlSchemaIDCPtr definition; /* the IDC definition */
800: xmlSchemaPSVIIDCNodePtr *nodeTable; /* array of key-sequences */
801: int nbNodes; /* number of entries in the node table */
802: int sizeNodes; /* size of the node table */
803: xmlSchemaItemListPtr dupls;
804: };
805:
806:
807: #define XPATH_STATE_OBJ_TYPE_IDC_SELECTOR 1
808: #define XPATH_STATE_OBJ_TYPE_IDC_FIELD 2
809:
810: #define XPATH_STATE_OBJ_MATCHES -2
811: #define XPATH_STATE_OBJ_BLOCKED -3
812:
813: typedef struct _xmlSchemaIDCMatcher xmlSchemaIDCMatcher;
814: typedef xmlSchemaIDCMatcher *xmlSchemaIDCMatcherPtr;
815:
816: /**
817: * xmlSchemaIDCStateObj:
818: *
819: * The state object used to evaluate XPath expressions.
820: */
821: typedef struct _xmlSchemaIDCStateObj xmlSchemaIDCStateObj;
822: typedef xmlSchemaIDCStateObj *xmlSchemaIDCStateObjPtr;
823: struct _xmlSchemaIDCStateObj {
824: int type;
825: xmlSchemaIDCStateObjPtr next; /* next if in a list */
826: int depth; /* depth of creation */
827: int *history; /* list of (depth, state-id) tuples */
828: int nbHistory;
829: int sizeHistory;
830: xmlSchemaIDCMatcherPtr matcher; /* the correspondent field/selector
831: matcher */
832: xmlSchemaIDCSelectPtr sel;
833: void *xpathCtxt;
834: };
835:
836: #define IDC_MATCHER 0
837:
838: /**
839: * xmlSchemaIDCMatcher:
840: *
841: * Used to evaluate IDC selectors (and fields).
842: */
843: struct _xmlSchemaIDCMatcher {
844: int type;
845: int depth; /* the tree depth at creation time */
846: xmlSchemaIDCMatcherPtr next; /* next in the list */
847: xmlSchemaIDCMatcherPtr nextCached; /* next in the cache list */
848: xmlSchemaIDCAugPtr aidc; /* the augmented IDC item */
849: int idcType;
850: xmlSchemaPSVIIDCKeyPtr **keySeqs; /* the key-sequences of the target
851: elements */
852: int sizeKeySeqs;
853: xmlSchemaItemListPtr targets; /* list of target-node
854: (xmlSchemaPSVIIDCNodePtr) entries */
855: };
856:
857: /*
858: * Element info flags.
859: */
860: #define XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES 1<<0
861: #define XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES 1<<1
862: #define XML_SCHEMA_ELEM_INFO_NILLED 1<<2
863: #define XML_SCHEMA_ELEM_INFO_LOCAL_TYPE 1<<3
864:
865: #define XML_SCHEMA_NODE_INFO_VALUE_NEEDED 1<<4
866: #define XML_SCHEMA_ELEM_INFO_EMPTY 1<<5
867: #define XML_SCHEMA_ELEM_INFO_HAS_CONTENT 1<<6
868:
869: #define XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT 1<<7
870: #define XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT 1<<8
871: #define XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED 1<<9
872: #define XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE 1<<10
873:
874: /**
875: * xmlSchemaNodeInfo:
876: *
877: * Holds information of an element node.
878: */
879: struct _xmlSchemaNodeInfo {
880: int nodeType;
881: xmlNodePtr node;
882: int nodeLine;
883: const xmlChar *localName;
884: const xmlChar *nsName;
885: const xmlChar *value;
886: xmlSchemaValPtr val; /* the pre-computed value if any */
887: xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
888:
889: int flags; /* combination of node info flags */
890:
891: int valNeeded;
892: int normVal;
893:
894: xmlSchemaElementPtr decl; /* the element/attribute declaration */
895: int depth;
896: xmlSchemaPSVIIDCBindingPtr idcTable; /* the table of PSVI IDC bindings
897: for the scope element*/
898: xmlSchemaIDCMatcherPtr idcMatchers; /* the IDC matchers for the scope
899: element */
900: xmlRegExecCtxtPtr regexCtxt;
901:
902: const xmlChar **nsBindings; /* Namespace bindings on this element */
903: int nbNsBindings;
904: int sizeNsBindings;
905:
906: int hasKeyrefs;
907: int appliedXPath; /* Indicates that an XPath has been applied. */
908: };
909:
910: #define XML_SCHEMAS_ATTR_UNKNOWN 1
911: #define XML_SCHEMAS_ATTR_ASSESSED 2
912: #define XML_SCHEMAS_ATTR_PROHIBITED 3
913: #define XML_SCHEMAS_ATTR_ERR_MISSING 4
914: #define XML_SCHEMAS_ATTR_INVALID_VALUE 5
915: #define XML_SCHEMAS_ATTR_ERR_NO_TYPE 6
916: #define XML_SCHEMAS_ATTR_ERR_FIXED_VALUE 7
917: #define XML_SCHEMAS_ATTR_DEFAULT 8
918: #define XML_SCHEMAS_ATTR_VALIDATE_VALUE 9
919: #define XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL 10
920: #define XML_SCHEMAS_ATTR_HAS_ATTR_USE 11
921: #define XML_SCHEMAS_ATTR_HAS_ATTR_DECL 12
922: #define XML_SCHEMAS_ATTR_WILD_SKIP 13
923: #define XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL 14
924: #define XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID 15
925: #define XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID 16
926: #define XML_SCHEMAS_ATTR_META 17
927: /*
928: * @metaType values of xmlSchemaAttrInfo.
929: */
930: #define XML_SCHEMA_ATTR_INFO_META_XSI_TYPE 1
931: #define XML_SCHEMA_ATTR_INFO_META_XSI_NIL 2
932: #define XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC 3
933: #define XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC 4
934: #define XML_SCHEMA_ATTR_INFO_META_XMLNS 5
935:
936: typedef struct _xmlSchemaAttrInfo xmlSchemaAttrInfo;
937: typedef xmlSchemaAttrInfo *xmlSchemaAttrInfoPtr;
938: struct _xmlSchemaAttrInfo {
939: int nodeType;
940: xmlNodePtr node;
941: int nodeLine;
942: const xmlChar *localName;
943: const xmlChar *nsName;
944: const xmlChar *value;
945: xmlSchemaValPtr val; /* the pre-computed value if any */
946: xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
947: int flags; /* combination of node info flags */
948:
949: xmlSchemaAttributePtr decl; /* the attribute declaration */
950: xmlSchemaAttributeUsePtr use; /* the attribute use */
951: int state;
952: int metaType;
953: const xmlChar *vcValue; /* the value constraint value */
954: xmlSchemaNodeInfoPtr parent;
955: };
956:
957:
958: #define XML_SCHEMA_VALID_CTXT_FLAG_STREAM 1
959: /**
960: * xmlSchemaValidCtxt:
961: *
962: * A Schemas validation context
963: */
964: struct _xmlSchemaValidCtxt {
965: int type;
966: void *errCtxt; /* user specific data block */
967: xmlSchemaValidityErrorFunc error; /* the callback in case of errors */
968: xmlSchemaValidityWarningFunc warning; /* the callback in case of warning */
969: xmlStructuredErrorFunc serror;
970:
971: xmlSchemaPtr schema; /* The schema in use */
972: xmlDocPtr doc;
973: xmlParserInputBufferPtr input;
974: xmlCharEncoding enc;
975: xmlSAXHandlerPtr sax;
976: xmlParserCtxtPtr parserCtxt;
977: void *user_data; /* TODO: What is this for? */
978:
979: int err;
980: int nberrors;
981:
982: xmlNodePtr node;
983: xmlNodePtr cur;
984: /* xmlSchemaTypePtr type; */
985:
986: xmlRegExecCtxtPtr regexp;
987: xmlSchemaValPtr value;
988:
989: int valueWS;
990: int options;
991: xmlNodePtr validationRoot;
992: xmlSchemaParserCtxtPtr pctxt;
993: int xsiAssemble;
994:
995: int depth;
996: xmlSchemaNodeInfoPtr *elemInfos; /* array of element informations */
997: int sizeElemInfos;
998: xmlSchemaNodeInfoPtr inode; /* the current element information */
999:
1000: xmlSchemaIDCAugPtr aidcs; /* a list of augmented IDC informations */
1001:
1002: xmlSchemaIDCStateObjPtr xpathStates; /* first active state object. */
1003: xmlSchemaIDCStateObjPtr xpathStatePool; /* first stored state object. */
1004: xmlSchemaIDCMatcherPtr idcMatcherCache; /* Cache for IDC matcher objects. */
1005:
1006: xmlSchemaPSVIIDCNodePtr *idcNodes; /* list of all IDC node-table entries*/
1007: int nbIdcNodes;
1008: int sizeIdcNodes;
1009:
1010: xmlSchemaPSVIIDCKeyPtr *idcKeys; /* list of all IDC node-table entries */
1011: int nbIdcKeys;
1012: int sizeIdcKeys;
1013:
1014: int flags;
1015:
1016: xmlDictPtr dict;
1017:
1018: #ifdef LIBXML_READER_ENABLED
1019: xmlTextReaderPtr reader;
1020: #endif
1021:
1022: xmlSchemaAttrInfoPtr *attrInfos;
1023: int nbAttrInfos;
1024: int sizeAttrInfos;
1025:
1026: int skipDepth;
1027: xmlSchemaItemListPtr nodeQNames;
1028: int hasKeyrefs;
1029: int createIDCNodeTables;
1030: int psviExposeIDCNodeTables;
1031: };
1032:
1033: /**
1034: * xmlSchemaSubstGroup:
1035: *
1036: *
1037: */
1038: typedef struct _xmlSchemaSubstGroup xmlSchemaSubstGroup;
1039: typedef xmlSchemaSubstGroup *xmlSchemaSubstGroupPtr;
1040: struct _xmlSchemaSubstGroup {
1041: xmlSchemaElementPtr head;
1042: xmlSchemaItemListPtr members;
1043: };
1044:
1045: /************************************************************************
1046: * *
1047: * Some predeclarations *
1048: * *
1049: ************************************************************************/
1050:
1051: static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
1052: xmlSchemaPtr schema,
1053: xmlNodePtr node);
1054: static int xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr ctxt,
1055: xmlSchemaPtr schema,
1056: xmlNodePtr node);
1057: static int
1058: xmlSchemaTypeFixup(xmlSchemaTypePtr type,
1059: xmlSchemaAbstractCtxtPtr ctxt);
1060: static const xmlChar *
1061: xmlSchemaFacetTypeToString(xmlSchemaTypeType type);
1062: static int
1063: xmlSchemaParseImport(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
1064: xmlNodePtr node);
1065: static int
1066: xmlSchemaCheckFacetValues(xmlSchemaTypePtr typeDecl,
1067: xmlSchemaParserCtxtPtr ctxt);
1068: static void
1069: xmlSchemaClearValidCtxt(xmlSchemaValidCtxtPtr vctxt);
1070: static xmlSchemaWhitespaceValueType
1071: xmlSchemaGetWhiteSpaceFacetValue(xmlSchemaTypePtr type);
1072: static xmlSchemaTreeItemPtr
1073: xmlSchemaParseModelGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
1074: xmlNodePtr node, xmlSchemaTypeType type,
1075: int withParticle);
1076: static const xmlChar *
1077: xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item);
1078: static xmlSchemaTypeLinkPtr
1079: xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type);
1080: static void
1081: xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
1082: const char *funcName,
1083: const char *message);
1084: static int
1085: xmlSchemaCheckCOSSTDerivedOK(xmlSchemaAbstractCtxtPtr ctxt,
1086: xmlSchemaTypePtr type,
1087: xmlSchemaTypePtr baseType,
1088: int subset);
1089: static void
1090: xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
1091: xmlSchemaParserCtxtPtr ctxt);
1092: static void
1093: xmlSchemaComponentListFree(xmlSchemaItemListPtr list);
1094: static xmlSchemaQNameRefPtr
1095: xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
1096: xmlSchemaPtr schema,
1097: xmlNodePtr node);
1098:
1099: /************************************************************************
1100: * *
1101: * Helper functions *
1102: * *
1103: ************************************************************************/
1104:
1105: /**
1106: * xmlSchemaItemTypeToStr:
1107: * @type: the type of the schema item
1108: *
1109: * Returns the component name of a schema item.
1110: */
1111: static const xmlChar *
1112: xmlSchemaItemTypeToStr(xmlSchemaTypeType type)
1113: {
1114: switch (type) {
1115: case XML_SCHEMA_TYPE_BASIC:
1116: return(BAD_CAST "simple type definition");
1117: case XML_SCHEMA_TYPE_SIMPLE:
1118: return(BAD_CAST "simple type definition");
1119: case XML_SCHEMA_TYPE_COMPLEX:
1120: return(BAD_CAST "complex type definition");
1121: case XML_SCHEMA_TYPE_ELEMENT:
1122: return(BAD_CAST "element declaration");
1123: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
1124: return(BAD_CAST "attribute use");
1125: case XML_SCHEMA_TYPE_ATTRIBUTE:
1126: return(BAD_CAST "attribute declaration");
1127: case XML_SCHEMA_TYPE_GROUP:
1128: return(BAD_CAST "model group definition");
1129: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1130: return(BAD_CAST "attribute group definition");
1131: case XML_SCHEMA_TYPE_NOTATION:
1132: return(BAD_CAST "notation declaration");
1133: case XML_SCHEMA_TYPE_SEQUENCE:
1134: return(BAD_CAST "model group (sequence)");
1135: case XML_SCHEMA_TYPE_CHOICE:
1136: return(BAD_CAST "model group (choice)");
1137: case XML_SCHEMA_TYPE_ALL:
1138: return(BAD_CAST "model group (all)");
1139: case XML_SCHEMA_TYPE_PARTICLE:
1140: return(BAD_CAST "particle");
1141: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1142: return(BAD_CAST "unique identity-constraint");
1143: /* return(BAD_CAST "IDC (unique)"); */
1144: case XML_SCHEMA_TYPE_IDC_KEY:
1145: return(BAD_CAST "key identity-constraint");
1146: /* return(BAD_CAST "IDC (key)"); */
1147: case XML_SCHEMA_TYPE_IDC_KEYREF:
1148: return(BAD_CAST "keyref identity-constraint");
1149: /* return(BAD_CAST "IDC (keyref)"); */
1150: case XML_SCHEMA_TYPE_ANY:
1151: return(BAD_CAST "wildcard (any)");
1152: case XML_SCHEMA_EXTRA_QNAMEREF:
1153: return(BAD_CAST "[helper component] QName reference");
1154: case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
1155: return(BAD_CAST "[helper component] attribute use prohibition");
1156: default:
1157: return(BAD_CAST "Not a schema component");
1158: }
1159: }
1160:
1161: /**
1162: * xmlSchemaGetComponentTypeStr:
1163: * @type: the type of the schema item
1164: *
1165: * Returns the component name of a schema item.
1166: */
1167: static const xmlChar *
1168: xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item)
1169: {
1170: switch (item->type) {
1171: case XML_SCHEMA_TYPE_BASIC:
1172: if (WXS_IS_COMPLEX(WXS_TYPE_CAST item))
1173: return(BAD_CAST "complex type definition");
1174: else
1175: return(BAD_CAST "simple type definition");
1176: default:
1177: return(xmlSchemaItemTypeToStr(item->type));
1178: }
1179: }
1180:
1181: /**
1182: * xmlSchemaGetComponentNode:
1183: * @item: a schema component
1184: *
1185: * Returns node associated with the schema component.
1186: * NOTE that such a node need not be available; plus, a component's
1187: * node need not to reflect the component directly, since there is no
1188: * one-to-one relationship between the XML Schema representation and
1189: * the component representation.
1190: */
1191: static xmlNodePtr
1192: xmlSchemaGetComponentNode(xmlSchemaBasicItemPtr item)
1193: {
1194: switch (item->type) {
1195: case XML_SCHEMA_TYPE_ELEMENT:
1196: return (((xmlSchemaElementPtr) item)->node);
1197: case XML_SCHEMA_TYPE_ATTRIBUTE:
1198: return (((xmlSchemaAttributePtr) item)->node);
1199: case XML_SCHEMA_TYPE_COMPLEX:
1200: case XML_SCHEMA_TYPE_SIMPLE:
1201: return (((xmlSchemaTypePtr) item)->node);
1202: case XML_SCHEMA_TYPE_ANY:
1203: case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
1204: return (((xmlSchemaWildcardPtr) item)->node);
1205: case XML_SCHEMA_TYPE_PARTICLE:
1206: return (((xmlSchemaParticlePtr) item)->node);
1207: case XML_SCHEMA_TYPE_SEQUENCE:
1208: case XML_SCHEMA_TYPE_CHOICE:
1209: case XML_SCHEMA_TYPE_ALL:
1210: return (((xmlSchemaModelGroupPtr) item)->node);
1211: case XML_SCHEMA_TYPE_GROUP:
1212: return (((xmlSchemaModelGroupDefPtr) item)->node);
1213: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1214: return (((xmlSchemaAttributeGroupPtr) item)->node);
1215: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1216: case XML_SCHEMA_TYPE_IDC_KEY:
1217: case XML_SCHEMA_TYPE_IDC_KEYREF:
1218: return (((xmlSchemaIDCPtr) item)->node);
1219: case XML_SCHEMA_EXTRA_QNAMEREF:
1220: return(((xmlSchemaQNameRefPtr) item)->node);
1221: /* TODO: What to do with NOTATIONs?
1222: case XML_SCHEMA_TYPE_NOTATION:
1223: return (((xmlSchemaNotationPtr) item)->node);
1224: */
1225: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
1226: return (((xmlSchemaAttributeUsePtr) item)->node);
1227: default:
1228: return (NULL);
1229: }
1230: }
1231:
1232: #if 0
1233: /**
1234: * xmlSchemaGetNextComponent:
1235: * @item: a schema component
1236: *
1237: * Returns the next sibling of the schema component.
1238: */
1239: static xmlSchemaBasicItemPtr
1240: xmlSchemaGetNextComponent(xmlSchemaBasicItemPtr item)
1241: {
1242: switch (item->type) {
1243: case XML_SCHEMA_TYPE_ELEMENT:
1244: return ((xmlSchemaBasicItemPtr) ((xmlSchemaElementPtr) item)->next);
1245: case XML_SCHEMA_TYPE_ATTRIBUTE:
1246: return ((xmlSchemaBasicItemPtr) ((xmlSchemaAttributePtr) item)->next);
1247: case XML_SCHEMA_TYPE_COMPLEX:
1248: case XML_SCHEMA_TYPE_SIMPLE:
1249: return ((xmlSchemaBasicItemPtr) ((xmlSchemaTypePtr) item)->next);
1250: case XML_SCHEMA_TYPE_ANY:
1251: case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
1252: return (NULL);
1253: case XML_SCHEMA_TYPE_PARTICLE:
1254: return ((xmlSchemaBasicItemPtr) ((xmlSchemaParticlePtr) item)->next);
1255: case XML_SCHEMA_TYPE_SEQUENCE:
1256: case XML_SCHEMA_TYPE_CHOICE:
1257: case XML_SCHEMA_TYPE_ALL:
1258: return (NULL);
1259: case XML_SCHEMA_TYPE_GROUP:
1260: return (NULL);
1261: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1262: return ((xmlSchemaBasicItemPtr) ((xmlSchemaAttributeGroupPtr) item)->next);
1263: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1264: case XML_SCHEMA_TYPE_IDC_KEY:
1265: case XML_SCHEMA_TYPE_IDC_KEYREF:
1266: return ((xmlSchemaBasicItemPtr) ((xmlSchemaIDCPtr) item)->next);
1267: default:
1268: return (NULL);
1269: }
1270: }
1271: #endif
1272:
1273:
1274: /**
1275: * xmlSchemaFormatQName:
1276: * @buf: the string buffer
1277: * @namespaceName: the namespace name
1278: * @localName: the local name
1279: *
1280: * Returns the given QName in the format "{namespaceName}localName" or
1281: * just "localName" if @namespaceName is NULL.
1282: *
1283: * Returns the localName if @namespaceName is NULL, a formatted
1284: * string otherwise.
1285: */
1286: static const xmlChar*
1287: xmlSchemaFormatQName(xmlChar **buf,
1288: const xmlChar *namespaceName,
1289: const xmlChar *localName)
1290: {
1291: FREE_AND_NULL(*buf)
1292: if (namespaceName != NULL) {
1293: *buf = xmlStrdup(BAD_CAST "{");
1294: *buf = xmlStrcat(*buf, namespaceName);
1295: *buf = xmlStrcat(*buf, BAD_CAST "}");
1296: }
1297: if (localName != NULL) {
1298: if (namespaceName == NULL)
1299: return(localName);
1300: *buf = xmlStrcat(*buf, localName);
1301: } else {
1302: *buf = xmlStrcat(*buf, BAD_CAST "(NULL)");
1303: }
1304: return ((const xmlChar *) *buf);
1305: }
1306:
1307: static const xmlChar*
1308: xmlSchemaFormatQNameNs(xmlChar **buf, xmlNsPtr ns, const xmlChar *localName)
1309: {
1310: if (ns != NULL)
1311: return (xmlSchemaFormatQName(buf, ns->href, localName));
1312: else
1313: return (xmlSchemaFormatQName(buf, NULL, localName));
1314: }
1315:
1316: static const xmlChar *
1317: xmlSchemaGetComponentName(xmlSchemaBasicItemPtr item)
1318: {
1319: switch (item->type) {
1320: case XML_SCHEMA_TYPE_ELEMENT:
1321: return (((xmlSchemaElementPtr) item)->name);
1322: case XML_SCHEMA_TYPE_ATTRIBUTE:
1323: return (((xmlSchemaAttributePtr) item)->name);
1324: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1325: return (((xmlSchemaAttributeGroupPtr) item)->name);
1326: case XML_SCHEMA_TYPE_BASIC:
1327: case XML_SCHEMA_TYPE_SIMPLE:
1328: case XML_SCHEMA_TYPE_COMPLEX:
1329: return (((xmlSchemaTypePtr) item)->name);
1330: case XML_SCHEMA_TYPE_GROUP:
1331: return (((xmlSchemaModelGroupDefPtr) item)->name);
1332: case XML_SCHEMA_TYPE_IDC_KEY:
1333: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1334: case XML_SCHEMA_TYPE_IDC_KEYREF:
1335: return (((xmlSchemaIDCPtr) item)->name);
1336: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
1337: if (WXS_ATTRUSE_DECL(item) != NULL) {
1338: return(xmlSchemaGetComponentName(
1339: WXS_BASIC_CAST WXS_ATTRUSE_DECL(item)));
1340: } else
1341: return(NULL);
1342: case XML_SCHEMA_EXTRA_QNAMEREF:
1343: return (((xmlSchemaQNameRefPtr) item)->name);
1344: case XML_SCHEMA_TYPE_NOTATION:
1345: return (((xmlSchemaNotationPtr) item)->name);
1346: default:
1347: /*
1348: * Other components cannot have names.
1349: */
1350: break;
1351: }
1352: return (NULL);
1353: }
1354:
1355: #define xmlSchemaGetQNameRefName(r) (WXS_QNAME_CAST (r))->name
1356: #define xmlSchemaGetQNameRefTargetNs(r) (WXS_QNAME_CAST (r))->targetNamespace
1357: /*
1358: static const xmlChar *
1359: xmlSchemaGetQNameRefName(void *ref)
1360: {
1361: return(((xmlSchemaQNameRefPtr) ref)->name);
1362: }
1363:
1364: static const xmlChar *
1365: xmlSchemaGetQNameRefTargetNs(void *ref)
1366: {
1367: return(((xmlSchemaQNameRefPtr) ref)->targetNamespace);
1368: }
1369: */
1370:
1371: static const xmlChar *
1372: xmlSchemaGetComponentTargetNs(xmlSchemaBasicItemPtr item)
1373: {
1374: switch (item->type) {
1375: case XML_SCHEMA_TYPE_ELEMENT:
1376: return (((xmlSchemaElementPtr) item)->targetNamespace);
1377: case XML_SCHEMA_TYPE_ATTRIBUTE:
1378: return (((xmlSchemaAttributePtr) item)->targetNamespace);
1379: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1380: return (((xmlSchemaAttributeGroupPtr) item)->targetNamespace);
1381: case XML_SCHEMA_TYPE_BASIC:
1382: return (BAD_CAST "http://www.w3.org/2001/XMLSchema");
1383: case XML_SCHEMA_TYPE_SIMPLE:
1384: case XML_SCHEMA_TYPE_COMPLEX:
1385: return (((xmlSchemaTypePtr) item)->targetNamespace);
1386: case XML_SCHEMA_TYPE_GROUP:
1387: return (((xmlSchemaModelGroupDefPtr) item)->targetNamespace);
1388: case XML_SCHEMA_TYPE_IDC_KEY:
1389: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1390: case XML_SCHEMA_TYPE_IDC_KEYREF:
1391: return (((xmlSchemaIDCPtr) item)->targetNamespace);
1392: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
1393: if (WXS_ATTRUSE_DECL(item) != NULL) {
1394: return(xmlSchemaGetComponentTargetNs(
1395: WXS_BASIC_CAST WXS_ATTRUSE_DECL(item)));
1396: }
1397: /* TODO: Will returning NULL break something? */
1398: break;
1399: case XML_SCHEMA_EXTRA_QNAMEREF:
1400: return (((xmlSchemaQNameRefPtr) item)->targetNamespace);
1401: case XML_SCHEMA_TYPE_NOTATION:
1402: return (((xmlSchemaNotationPtr) item)->targetNamespace);
1403: default:
1404: /*
1405: * Other components cannot have names.
1406: */
1407: break;
1408: }
1409: return (NULL);
1410: }
1411:
1412: static const xmlChar*
1413: xmlSchemaGetComponentQName(xmlChar **buf,
1414: void *item)
1415: {
1416: return (xmlSchemaFormatQName(buf,
1417: xmlSchemaGetComponentTargetNs((xmlSchemaBasicItemPtr) item),
1418: xmlSchemaGetComponentName((xmlSchemaBasicItemPtr) item)));
1419: }
1420:
1421: static const xmlChar*
1422: xmlSchemaGetComponentDesignation(xmlChar **buf, void *item)
1423: {
1424: xmlChar *str = NULL;
1425:
1426: *buf = xmlStrcat(*buf, WXS_ITEM_TYPE_NAME(item));
1427: *buf = xmlStrcat(*buf, BAD_CAST " '");
1428: *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str,
1429: (xmlSchemaBasicItemPtr) item));
1430: *buf = xmlStrcat(*buf, BAD_CAST "'");
1431: FREE_AND_NULL(str);
1432: return(*buf);
1433: }
1434:
1435: static const xmlChar*
1436: xmlSchemaGetIDCDesignation(xmlChar **buf, xmlSchemaIDCPtr idc)
1437: {
1438: return(xmlSchemaGetComponentDesignation(buf, idc));
1439: }
1440:
1441: /**
1442: * xmlSchemaWildcardPCToString:
1443: * @pc: the type of processContents
1444: *
1445: * Returns a string representation of the type of
1446: * processContents.
1447: */
1448: static const xmlChar *
1449: xmlSchemaWildcardPCToString(int pc)
1450: {
1451: switch (pc) {
1452: case XML_SCHEMAS_ANY_SKIP:
1453: return (BAD_CAST "skip");
1454: case XML_SCHEMAS_ANY_LAX:
1455: return (BAD_CAST "lax");
1456: case XML_SCHEMAS_ANY_STRICT:
1457: return (BAD_CAST "strict");
1458: default:
1459: return (BAD_CAST "invalid process contents");
1460: }
1461: }
1462:
1463: /**
1464: * xmlSchemaGetCanonValueWhtspExt:
1465: * @val: the precomputed value
1466: * @retValue: the returned value
1467: * @ws: the whitespace type of the value
1468: *
1469: * Get a the cononical representation of the value.
1470: * The caller has to free the returned retValue.
1471: *
1472: * Returns 0 if the value could be built and -1 in case of
1473: * API errors or if the value type is not supported yet.
1474: */
1475: static int
1476: xmlSchemaGetCanonValueWhtspExt(xmlSchemaValPtr val,
1477: xmlSchemaWhitespaceValueType ws,
1478: xmlChar **retValue)
1479: {
1480: int list;
1481: xmlSchemaValType valType;
1482: const xmlChar *value, *value2 = NULL;
1483:
1484:
1485: if ((retValue == NULL) || (val == NULL))
1486: return (-1);
1487: list = xmlSchemaValueGetNext(val) ? 1 : 0;
1488: *retValue = NULL;
1489: do {
1490: value = NULL;
1491: valType = xmlSchemaGetValType(val);
1492: switch (valType) {
1493: case XML_SCHEMAS_STRING:
1494: case XML_SCHEMAS_NORMSTRING:
1495: case XML_SCHEMAS_ANYSIMPLETYPE:
1496: value = xmlSchemaValueGetAsString(val);
1497: if (value != NULL) {
1498: if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
1499: value2 = xmlSchemaCollapseString(value);
1500: else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
1501: value2 = xmlSchemaWhiteSpaceReplace(value);
1502: if (value2 != NULL)
1503: value = value2;
1504: }
1505: break;
1506: default:
1507: if (xmlSchemaGetCanonValue(val, &value2) == -1) {
1508: if (value2 != NULL)
1509: xmlFree((xmlChar *) value2);
1510: goto internal_error;
1511: }
1512: value = value2;
1513: }
1514: if (*retValue == NULL)
1515: if (value == NULL) {
1516: if (! list)
1517: *retValue = xmlStrdup(BAD_CAST "");
1518: } else
1519: *retValue = xmlStrdup(value);
1520: else if (value != NULL) {
1521: /* List. */
1522: *retValue = xmlStrcat((xmlChar *) *retValue, BAD_CAST " ");
1523: *retValue = xmlStrcat((xmlChar *) *retValue, value);
1524: }
1525: FREE_AND_NULL(value2)
1526: val = xmlSchemaValueGetNext(val);
1527: } while (val != NULL);
1528:
1529: return (0);
1530: internal_error:
1531: if (*retValue != NULL)
1532: xmlFree((xmlChar *) (*retValue));
1533: if (value2 != NULL)
1534: xmlFree((xmlChar *) value2);
1535: return (-1);
1536: }
1537:
1538: /**
1539: * xmlSchemaFormatItemForReport:
1540: * @buf: the string buffer
1541: * @itemDes: the designation of the item
1542: * @itemName: the name of the item
1543: * @item: the item as an object
1544: * @itemNode: the node of the item
1545: * @local: the local name
1546: * @parsing: if the function is used during the parse
1547: *
1548: * Returns a representation of the given item used
1549: * for error reports.
1550: *
1551: * The following order is used to build the resulting
1552: * designation if the arguments are not NULL:
1553: * 1a. If itemDes not NULL -> itemDes
1554: * 1b. If (itemDes not NULL) and (itemName not NULL)
1555: * -> itemDes + itemName
1556: * 2. If the preceding was NULL and (item not NULL) -> item
1557: * 3. If the preceding was NULL and (itemNode not NULL) -> itemNode
1558: *
1559: * If the itemNode is an attribute node, the name of the attribute
1560: * will be appended to the result.
1561: *
1562: * Returns the formatted string and sets @buf to the resulting value.
1563: */
1564: static xmlChar*
1565: xmlSchemaFormatItemForReport(xmlChar **buf,
1566: const xmlChar *itemDes,
1567: xmlSchemaBasicItemPtr item,
1568: xmlNodePtr itemNode)
1569: {
1570: xmlChar *str = NULL;
1571: int named = 1;
1572:
1573: if (*buf != NULL) {
1574: xmlFree(*buf);
1575: *buf = NULL;
1576: }
1577:
1578: if (itemDes != NULL) {
1579: *buf = xmlStrdup(itemDes);
1580: } else if (item != NULL) {
1581: switch (item->type) {
1582: case XML_SCHEMA_TYPE_BASIC: {
1583: xmlSchemaTypePtr type = WXS_TYPE_CAST item;
1584:
1585: if (WXS_IS_ATOMIC(type))
1586: *buf = xmlStrdup(BAD_CAST "atomic type 'xs:");
1587: else if (WXS_IS_LIST(type))
1588: *buf = xmlStrdup(BAD_CAST "list type 'xs:");
1589: else if (WXS_IS_UNION(type))
1590: *buf = xmlStrdup(BAD_CAST "union type 'xs:");
1591: else
1592: *buf = xmlStrdup(BAD_CAST "simple type 'xs:");
1593: *buf = xmlStrcat(*buf, type->name);
1594: *buf = xmlStrcat(*buf, BAD_CAST "'");
1595: }
1596: break;
1597: case XML_SCHEMA_TYPE_SIMPLE: {
1598: xmlSchemaTypePtr type = WXS_TYPE_CAST item;
1599:
1600: if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
1601: *buf = xmlStrdup(BAD_CAST"");
1602: } else {
1603: *buf = xmlStrdup(BAD_CAST "local ");
1604: }
1605: if (WXS_IS_ATOMIC(type))
1606: *buf = xmlStrcat(*buf, BAD_CAST "atomic type");
1607: else if (WXS_IS_LIST(type))
1608: *buf = xmlStrcat(*buf, BAD_CAST "list type");
1609: else if (WXS_IS_UNION(type))
1610: *buf = xmlStrcat(*buf, BAD_CAST "union type");
1611: else
1612: *buf = xmlStrcat(*buf, BAD_CAST "simple type");
1613: if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
1614: *buf = xmlStrcat(*buf, BAD_CAST " '");
1615: *buf = xmlStrcat(*buf, type->name);
1616: *buf = xmlStrcat(*buf, BAD_CAST "'");
1617: }
1618: }
1619: break;
1620: case XML_SCHEMA_TYPE_COMPLEX: {
1621: xmlSchemaTypePtr type = WXS_TYPE_CAST item;
1622:
1623: if (type->flags & XML_SCHEMAS_TYPE_GLOBAL)
1624: *buf = xmlStrdup(BAD_CAST "");
1625: else
1626: *buf = xmlStrdup(BAD_CAST "local ");
1627: *buf = xmlStrcat(*buf, BAD_CAST "complex type");
1628: if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
1629: *buf = xmlStrcat(*buf, BAD_CAST " '");
1630: *buf = xmlStrcat(*buf, type->name);
1631: *buf = xmlStrcat(*buf, BAD_CAST "'");
1632: }
1633: }
1634: break;
1635: case XML_SCHEMA_TYPE_ATTRIBUTE_USE: {
1636: xmlSchemaAttributeUsePtr ause;
1637:
1638: ause = WXS_ATTR_USE_CAST item;
1639: *buf = xmlStrdup(BAD_CAST "attribute use ");
1640: if (WXS_ATTRUSE_DECL(ause) != NULL) {
1641: *buf = xmlStrcat(*buf, BAD_CAST "'");
1642: *buf = xmlStrcat(*buf,
1643: xmlSchemaGetComponentQName(&str, WXS_ATTRUSE_DECL(ause)));
1644: FREE_AND_NULL(str)
1645: *buf = xmlStrcat(*buf, BAD_CAST "'");
1646: } else {
1647: *buf = xmlStrcat(*buf, BAD_CAST "(unknown)");
1648: }
1649: }
1650: break;
1651: case XML_SCHEMA_TYPE_ATTRIBUTE: {
1652: xmlSchemaAttributePtr attr;
1653:
1654: attr = (xmlSchemaAttributePtr) item;
1655: *buf = xmlStrdup(BAD_CAST "attribute decl.");
1656: *buf = xmlStrcat(*buf, BAD_CAST " '");
1657: *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
1658: attr->targetNamespace, attr->name));
1659: FREE_AND_NULL(str)
1660: *buf = xmlStrcat(*buf, BAD_CAST "'");
1661: }
1662: break;
1663: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
1664: xmlSchemaGetComponentDesignation(buf, item);
1665: break;
1666: case XML_SCHEMA_TYPE_ELEMENT: {
1667: xmlSchemaElementPtr elem;
1668:
1669: elem = (xmlSchemaElementPtr) item;
1670: *buf = xmlStrdup(BAD_CAST "element decl.");
1671: *buf = xmlStrcat(*buf, BAD_CAST " '");
1672: *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
1673: elem->targetNamespace, elem->name));
1674: *buf = xmlStrcat(*buf, BAD_CAST "'");
1675: }
1676: break;
1677: case XML_SCHEMA_TYPE_IDC_UNIQUE:
1678: case XML_SCHEMA_TYPE_IDC_KEY:
1679: case XML_SCHEMA_TYPE_IDC_KEYREF:
1680: if (item->type == XML_SCHEMA_TYPE_IDC_UNIQUE)
1681: *buf = xmlStrdup(BAD_CAST "unique '");
1682: else if (item->type == XML_SCHEMA_TYPE_IDC_KEY)
1683: *buf = xmlStrdup(BAD_CAST "key '");
1684: else
1685: *buf = xmlStrdup(BAD_CAST "keyRef '");
1686: *buf = xmlStrcat(*buf, ((xmlSchemaIDCPtr) item)->name);
1687: *buf = xmlStrcat(*buf, BAD_CAST "'");
1688: break;
1689: case XML_SCHEMA_TYPE_ANY:
1690: case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
1691: *buf = xmlStrdup(xmlSchemaWildcardPCToString(
1692: ((xmlSchemaWildcardPtr) item)->processContents));
1693: *buf = xmlStrcat(*buf, BAD_CAST " wildcard");
1694: break;
1695: case XML_SCHEMA_FACET_MININCLUSIVE:
1696: case XML_SCHEMA_FACET_MINEXCLUSIVE:
1697: case XML_SCHEMA_FACET_MAXINCLUSIVE:
1698: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
1699: case XML_SCHEMA_FACET_TOTALDIGITS:
1700: case XML_SCHEMA_FACET_FRACTIONDIGITS:
1701: case XML_SCHEMA_FACET_PATTERN:
1702: case XML_SCHEMA_FACET_ENUMERATION:
1703: case XML_SCHEMA_FACET_WHITESPACE:
1704: case XML_SCHEMA_FACET_LENGTH:
1705: case XML_SCHEMA_FACET_MAXLENGTH:
1706: case XML_SCHEMA_FACET_MINLENGTH:
1707: *buf = xmlStrdup(BAD_CAST "facet '");
1708: *buf = xmlStrcat(*buf, xmlSchemaFacetTypeToString(item->type));
1709: *buf = xmlStrcat(*buf, BAD_CAST "'");
1710: break;
1711: case XML_SCHEMA_TYPE_GROUP: {
1712: *buf = xmlStrdup(BAD_CAST "model group def.");
1713: *buf = xmlStrcat(*buf, BAD_CAST " '");
1714: *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item));
1715: *buf = xmlStrcat(*buf, BAD_CAST "'");
1716: FREE_AND_NULL(str)
1717: }
1718: break;
1719: case XML_SCHEMA_TYPE_SEQUENCE:
1720: case XML_SCHEMA_TYPE_CHOICE:
1721: case XML_SCHEMA_TYPE_ALL:
1722: case XML_SCHEMA_TYPE_PARTICLE:
1723: *buf = xmlStrdup(WXS_ITEM_TYPE_NAME(item));
1724: break;
1725: case XML_SCHEMA_TYPE_NOTATION: {
1726: *buf = xmlStrdup(WXS_ITEM_TYPE_NAME(item));
1727: *buf = xmlStrcat(*buf, BAD_CAST " '");
1728: *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item));
1729: *buf = xmlStrcat(*buf, BAD_CAST "'");
1730: FREE_AND_NULL(str);
1731: }
1732: default:
1733: named = 0;
1734: }
1735: } else
1736: named = 0;
1737:
1738: if ((named == 0) && (itemNode != NULL)) {
1739: xmlNodePtr elem;
1740:
1741: if (itemNode->type == XML_ATTRIBUTE_NODE)
1742: elem = itemNode->parent;
1743: else
1744: elem = itemNode;
1745: *buf = xmlStrdup(BAD_CAST "Element '");
1746: if (elem->ns != NULL) {
1747: *buf = xmlStrcat(*buf,
1748: xmlSchemaFormatQName(&str, elem->ns->href, elem->name));
1749: FREE_AND_NULL(str)
1750: } else
1751: *buf = xmlStrcat(*buf, elem->name);
1752: *buf = xmlStrcat(*buf, BAD_CAST "'");
1753:
1754: }
1755: if ((itemNode != NULL) && (itemNode->type == XML_ATTRIBUTE_NODE)) {
1756: *buf = xmlStrcat(*buf, BAD_CAST ", attribute '");
1757: if (itemNode->ns != NULL) {
1758: *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
1759: itemNode->ns->href, itemNode->name));
1760: FREE_AND_NULL(str)
1761: } else
1762: *buf = xmlStrcat(*buf, itemNode->name);
1763: *buf = xmlStrcat(*buf, BAD_CAST "'");
1764: }
1765: FREE_AND_NULL(str)
1766:
1767: return (*buf);
1768: }
1769:
1770: /**
1771: * xmlSchemaFormatFacetEnumSet:
1772: * @buf: the string buffer
1773: * @type: the type holding the enumeration facets
1774: *
1775: * Builds a string consisting of all enumeration elements.
1776: *
1777: * Returns a string of all enumeration elements.
1778: */
1779: static const xmlChar *
1780: xmlSchemaFormatFacetEnumSet(xmlSchemaAbstractCtxtPtr actxt,
1781: xmlChar **buf, xmlSchemaTypePtr type)
1782: {
1783: xmlSchemaFacetPtr facet;
1784: xmlSchemaWhitespaceValueType ws;
1785: xmlChar *value = NULL;
1786: int res, found = 0;
1787:
1788: if (*buf != NULL)
1789: xmlFree(*buf);
1790: *buf = NULL;
1791:
1792: do {
1793: /*
1794: * Use the whitespace type of the base type.
1795: */
1796: ws = xmlSchemaGetWhiteSpaceFacetValue(type->baseType);
1797: for (facet = type->facets; facet != NULL; facet = facet->next) {
1798: if (facet->type != XML_SCHEMA_FACET_ENUMERATION)
1799: continue;
1800: found = 1;
1801: res = xmlSchemaGetCanonValueWhtspExt(facet->val,
1802: ws, &value);
1803: if (res == -1) {
1804: xmlSchemaInternalErr(actxt,
1805: "xmlSchemaFormatFacetEnumSet",
1806: "compute the canonical lexical representation");
1807: if (*buf != NULL)
1808: xmlFree(*buf);
1809: *buf = NULL;
1810: return (NULL);
1811: }
1812: if (*buf == NULL)
1813: *buf = xmlStrdup(BAD_CAST "'");
1814: else
1815: *buf = xmlStrcat(*buf, BAD_CAST ", '");
1816: *buf = xmlStrcat(*buf, BAD_CAST value);
1817: *buf = xmlStrcat(*buf, BAD_CAST "'");
1818: if (value != NULL) {
1819: xmlFree((xmlChar *)value);
1820: value = NULL;
1821: }
1822: }
1823: /*
1824: * The enumeration facet of a type restricts the enumeration
1825: * facet of the ancestor type; i.e., such restricted enumerations
1826: * do not belong to the set of the given type. Thus we break
1827: * on the first found enumeration.
1828: */
1829: if (found)
1830: break;
1831: type = type->baseType;
1832: } while ((type != NULL) && (type->type != XML_SCHEMA_TYPE_BASIC));
1833:
1834: return ((const xmlChar *) *buf);
1835: }
1836:
1837: /************************************************************************
1838: * *
1839: * Error functions *
1840: * *
1841: ************************************************************************/
1842:
1843: #if 0
1844: static void
1845: xmlSchemaErrMemory(const char *msg)
1846: {
1847: __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, NULL, NULL,
1848: msg);
1849: }
1850: #endif
1851:
1852: static void
1853: xmlSchemaPSimpleErr(const char *msg)
1854: {
1855: __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, NULL, NULL,
1856: msg);
1857: }
1858:
1859: /**
1860: * xmlSchemaPErrMemory:
1861: * @node: a context node
1862: * @extra: extra informations
1863: *
1864: * Handle an out of memory condition
1865: */
1866: static void
1867: xmlSchemaPErrMemory(xmlSchemaParserCtxtPtr ctxt,
1868: const char *extra, xmlNodePtr node)
1869: {
1870: if (ctxt != NULL)
1871: ctxt->nberrors++;
1872: __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, node, NULL,
1873: extra);
1874: }
1875:
1876: /**
1877: * xmlSchemaPErr:
1878: * @ctxt: the parsing context
1879: * @node: the context node
1880: * @error: the error code
1881: * @msg: the error message
1882: * @str1: extra data
1883: * @str2: extra data
1884: *
1885: * Handle a parser error
1886: */
1887: static void
1888: xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
1889: const char *msg, const xmlChar * str1, const xmlChar * str2)
1890: {
1891: xmlGenericErrorFunc channel = NULL;
1892: xmlStructuredErrorFunc schannel = NULL;
1893: void *data = NULL;
1894:
1895: if (ctxt != NULL) {
1896: ctxt->nberrors++;
1897: ctxt->err = error;
1898: channel = ctxt->error;
1899: data = ctxt->errCtxt;
1900: schannel = ctxt->serror;
1901: }
1902: __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
1903: error, XML_ERR_ERROR, NULL, 0,
1904: (const char *) str1, (const char *) str2, NULL, 0, 0,
1905: msg, str1, str2);
1906: }
1907:
1908: /**
1909: * xmlSchemaPErr2:
1910: * @ctxt: the parsing context
1911: * @node: the context node
1912: * @node: the current child
1913: * @error: the error code
1914: * @msg: the error message
1915: * @str1: extra data
1916: * @str2: extra data
1917: *
1918: * Handle a parser error
1919: */
1920: static void
1921: xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
1922: xmlNodePtr child, int error,
1923: const char *msg, const xmlChar * str1, const xmlChar * str2)
1924: {
1925: if (child != NULL)
1926: xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
1927: else
1928: xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
1929: }
1930:
1931:
1932: /**
1933: * xmlSchemaPErrExt:
1934: * @ctxt: the parsing context
1935: * @node: the context node
1936: * @error: the error code
1937: * @strData1: extra data
1938: * @strData2: extra data
1939: * @strData3: extra data
1940: * @msg: the message
1941: * @str1: extra parameter for the message display
1942: * @str2: extra parameter for the message display
1943: * @str3: extra parameter for the message display
1944: * @str4: extra parameter for the message display
1945: * @str5: extra parameter for the message display
1946: *
1947: * Handle a parser error
1948: */
1949: static void
1950: xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
1951: const xmlChar * strData1, const xmlChar * strData2,
1952: const xmlChar * strData3, const char *msg, const xmlChar * str1,
1953: const xmlChar * str2, const xmlChar * str3, const xmlChar * str4,
1954: const xmlChar * str5)
1955: {
1956:
1957: xmlGenericErrorFunc channel = NULL;
1958: xmlStructuredErrorFunc schannel = NULL;
1959: void *data = NULL;
1960:
1961: if (ctxt != NULL) {
1962: ctxt->nberrors++;
1963: ctxt->err = error;
1964: channel = ctxt->error;
1965: data = ctxt->errCtxt;
1966: schannel = ctxt->serror;
1967: }
1968: __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
1969: error, XML_ERR_ERROR, NULL, 0,
1970: (const char *) strData1, (const char *) strData2,
1971: (const char *) strData3, 0, 0, msg, str1, str2,
1972: str3, str4, str5);
1973: }
1974:
1975: /************************************************************************
1976: * *
1977: * Allround error functions *
1978: * *
1979: ************************************************************************/
1980:
1981: /**
1982: * xmlSchemaVTypeErrMemory:
1983: * @node: a context node
1984: * @extra: extra informations
1985: *
1986: * Handle an out of memory condition
1987: */
1988: static void
1989: xmlSchemaVErrMemory(xmlSchemaValidCtxtPtr ctxt,
1990: const char *extra, xmlNodePtr node)
1991: {
1992: if (ctxt != NULL) {
1993: ctxt->nberrors++;
1994: ctxt->err = XML_SCHEMAV_INTERNAL;
1995: }
1996: __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
1997: extra);
1998: }
1999:
2000: static void
2001: xmlSchemaPSimpleInternalErr(xmlNodePtr node,
2002: const char *msg, const xmlChar *str)
2003: {
2004: __xmlSimpleError(XML_FROM_SCHEMASP, XML_SCHEMAP_INTERNAL, node,
2005: msg, (const char *) str);
2006: }
2007:
2008: #define WXS_ERROR_TYPE_ERROR 1
2009: #define WXS_ERROR_TYPE_WARNING 2
2010: /**
2011: * xmlSchemaErr3:
2012: * @ctxt: the validation context
2013: * @node: the context node
2014: * @error: the error code
2015: * @msg: the error message
2016: * @str1: extra data
2017: * @str2: extra data
2018: * @str3: extra data
2019: *
2020: * Handle a validation error
2021: */
2022: static void
2023: xmlSchemaErr4Line(xmlSchemaAbstractCtxtPtr ctxt,
2024: xmlErrorLevel errorLevel,
2025: int error, xmlNodePtr node, int line, const char *msg,
2026: const xmlChar *str1, const xmlChar *str2,
2027: const xmlChar *str3, const xmlChar *str4)
2028: {
2029: xmlStructuredErrorFunc schannel = NULL;
2030: xmlGenericErrorFunc channel = NULL;
2031: void *data = NULL;
2032:
2033: if (ctxt != NULL) {
2034: if (ctxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
2035: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctxt;
2036: const char *file = NULL;
2037: if (errorLevel != XML_ERR_WARNING) {
2038: vctxt->nberrors++;
2039: vctxt->err = error;
2040: channel = vctxt->error;
2041: } else {
2042: channel = vctxt->warning;
2043: }
2044: schannel = vctxt->serror;
2045: data = vctxt->errCtxt;
2046:
2047: /*
2048: * Error node. If we specify a line number, then
2049: * do not channel any node to the error function.
2050: */
2051: if (line == 0) {
2052: if ((node == NULL) &&
2053: (vctxt->depth >= 0) &&
2054: (vctxt->inode != NULL)) {
2055: node = vctxt->inode->node;
2056: }
2057: /*
2058: * Get filename and line if no node-tree.
2059: */
2060: if ((node == NULL) &&
2061: (vctxt->parserCtxt != NULL) &&
2062: (vctxt->parserCtxt->input != NULL)) {
2063: file = vctxt->parserCtxt->input->filename;
2064: line = vctxt->parserCtxt->input->line;
2065: }
2066: } else {
2067: /*
2068: * Override the given node's (if any) position
2069: * and channel only the given line number.
2070: */
2071: node = NULL;
2072: /*
2073: * Get filename.
2074: */
2075: if (vctxt->doc != NULL)
2076: file = (const char *) vctxt->doc->URL;
2077: else if ((vctxt->parserCtxt != NULL) &&
2078: (vctxt->parserCtxt->input != NULL))
2079: file = vctxt->parserCtxt->input->filename;
2080: }
2081: __xmlRaiseError(schannel, channel, data, ctxt,
2082: node, XML_FROM_SCHEMASV,
2083: error, errorLevel, file, line,
2084: (const char *) str1, (const char *) str2,
2085: (const char *) str3, 0, 0, msg, str1, str2, str3, str4);
2086:
2087: } else if (ctxt->type == XML_SCHEMA_CTXT_PARSER) {
2088: xmlSchemaParserCtxtPtr pctxt = (xmlSchemaParserCtxtPtr) ctxt;
2089: if (errorLevel != XML_ERR_WARNING) {
2090: pctxt->nberrors++;
2091: pctxt->err = error;
2092: channel = pctxt->error;
2093: } else {
2094: channel = pctxt->warning;
2095: }
2096: schannel = pctxt->serror;
2097: data = pctxt->errCtxt;
2098: __xmlRaiseError(schannel, channel, data, ctxt,
2099: node, XML_FROM_SCHEMASP, error,
2100: errorLevel, NULL, 0,
2101: (const char *) str1, (const char *) str2,
2102: (const char *) str3, 0, 0, msg, str1, str2, str3, str4);
2103: } else {
2104: TODO
2105: }
2106: }
2107: }
2108:
2109: /**
2110: * xmlSchemaErr3:
2111: * @ctxt: the validation context
2112: * @node: the context node
2113: * @error: the error code
2114: * @msg: the error message
2115: * @str1: extra data
2116: * @str2: extra data
2117: * @str3: extra data
2118: *
2119: * Handle a validation error
2120: */
2121: static void
2122: xmlSchemaErr3(xmlSchemaAbstractCtxtPtr actxt,
2123: int error, xmlNodePtr node, const char *msg,
2124: const xmlChar *str1, const xmlChar *str2, const xmlChar *str3)
2125: {
2126: xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
2127: msg, str1, str2, str3, NULL);
2128: }
2129:
2130: static void
2131: xmlSchemaErr4(xmlSchemaAbstractCtxtPtr actxt,
2132: int error, xmlNodePtr node, const char *msg,
2133: const xmlChar *str1, const xmlChar *str2,
2134: const xmlChar *str3, const xmlChar *str4)
2135: {
2136: xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
2137: msg, str1, str2, str3, str4);
2138: }
2139:
2140: static void
2141: xmlSchemaErr(xmlSchemaAbstractCtxtPtr actxt,
2142: int error, xmlNodePtr node, const char *msg,
2143: const xmlChar *str1, const xmlChar *str2)
2144: {
2145: xmlSchemaErr4(actxt, error, node, msg, str1, str2, NULL, NULL);
2146: }
2147:
2148: static xmlChar *
2149: xmlSchemaFormatNodeForError(xmlChar ** msg,
2150: xmlSchemaAbstractCtxtPtr actxt,
2151: xmlNodePtr node)
2152: {
2153: xmlChar *str = NULL;
2154:
2155: *msg = NULL;
2156: if ((node != NULL) &&
2157: (node->type != XML_ELEMENT_NODE) &&
2158: (node->type != XML_ATTRIBUTE_NODE))
2159: {
2160: /*
2161: * Don't try to format other nodes than element and
2162: * attribute nodes.
2163: * Play save and return an empty string.
2164: */
2165: *msg = xmlStrdup(BAD_CAST "");
2166: return(*msg);
2167: }
2168: if (node != NULL) {
2169: /*
2170: * Work on tree nodes.
2171: */
2172: if (node->type == XML_ATTRIBUTE_NODE) {
2173: xmlNodePtr elem = node->parent;
2174:
2175: *msg = xmlStrdup(BAD_CAST "Element '");
2176: if (elem->ns != NULL)
2177: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2178: elem->ns->href, elem->name));
2179: else
2180: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2181: NULL, elem->name));
2182: FREE_AND_NULL(str);
2183: *msg = xmlStrcat(*msg, BAD_CAST "', ");
2184: *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
2185: } else {
2186: *msg = xmlStrdup(BAD_CAST "Element '");
2187: }
2188: if (node->ns != NULL)
2189: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2190: node->ns->href, node->name));
2191: else
2192: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2193: NULL, node->name));
2194: FREE_AND_NULL(str);
2195: *msg = xmlStrcat(*msg, BAD_CAST "': ");
2196: } else if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
2197: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) actxt;
2198: /*
2199: * Work on node infos.
2200: */
2201: if (vctxt->inode->nodeType == XML_ATTRIBUTE_NODE) {
2202: xmlSchemaNodeInfoPtr ielem =
2203: vctxt->elemInfos[vctxt->depth];
2204:
2205: *msg = xmlStrdup(BAD_CAST "Element '");
2206: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2207: ielem->nsName, ielem->localName));
2208: FREE_AND_NULL(str);
2209: *msg = xmlStrcat(*msg, BAD_CAST "', ");
2210: *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
2211: } else {
2212: *msg = xmlStrdup(BAD_CAST "Element '");
2213: }
2214: *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
2215: vctxt->inode->nsName, vctxt->inode->localName));
2216: FREE_AND_NULL(str);
2217: *msg = xmlStrcat(*msg, BAD_CAST "': ");
2218: } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
2219: /*
2220: * Hmm, no node while parsing?
2221: * Return an empty string, in case NULL will break something.
2222: */
2223: *msg = xmlStrdup(BAD_CAST "");
2224: } else {
2225: TODO
2226: return (NULL);
2227: }
2228: /*
2229: * VAL TODO: The output of the given schema component is currently
2230: * disabled.
2231: */
2232: #if 0
2233: if ((type != NULL) && (xmlSchemaIsGlobalItem(type))) {
2234: *msg = xmlStrcat(*msg, BAD_CAST " [");
2235: *msg = xmlStrcat(*msg, xmlSchemaFormatItemForReport(&str,
2236: NULL, type, NULL, 0));
2237: FREE_AND_NULL(str)
2238: *msg = xmlStrcat(*msg, BAD_CAST "]");
2239: }
2240: #endif
2241: return (*msg);
2242: }
2243:
2244: static void
2245: xmlSchemaInternalErr2(xmlSchemaAbstractCtxtPtr actxt,
2246: const char *funcName,
2247: const char *message,
2248: const xmlChar *str1,
2249: const xmlChar *str2)
2250: {
2251: xmlChar *msg = NULL;
2252:
2253: if (actxt == NULL)
2254: return;
2255: msg = xmlStrdup(BAD_CAST "Internal error: ");
2256: msg = xmlStrcat(msg, BAD_CAST funcName);
2257: msg = xmlStrcat(msg, BAD_CAST ", ");
2258: msg = xmlStrcat(msg, BAD_CAST message);
2259: msg = xmlStrcat(msg, BAD_CAST ".\n");
2260:
2261: if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR)
2262: xmlSchemaErr(actxt, XML_SCHEMAV_INTERNAL, NULL,
2263: (const char *) msg, str1, str2);
2264:
2265: else if (actxt->type == XML_SCHEMA_CTXT_PARSER)
2266: xmlSchemaErr(actxt, XML_SCHEMAP_INTERNAL, NULL,
2267: (const char *) msg, str1, str2);
2268:
2269: FREE_AND_NULL(msg)
2270: }
2271:
2272: static void
2273: xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
2274: const char *funcName,
2275: const char *message)
2276: {
2277: xmlSchemaInternalErr2(actxt, funcName, message, NULL, NULL);
2278: }
2279:
2280: #if 0
2281: static void
2282: xmlSchemaPInternalErr(xmlSchemaParserCtxtPtr pctxt,
2283: const char *funcName,
2284: const char *message,
2285: const xmlChar *str1,
2286: const xmlChar *str2)
2287: {
2288: xmlSchemaInternalErr2(ACTXT_CAST pctxt, funcName, message,
2289: str1, str2);
2290: }
2291: #endif
2292:
2293: static void
2294: xmlSchemaCustomErr4(xmlSchemaAbstractCtxtPtr actxt,
2295: xmlParserErrors error,
2296: xmlNodePtr node,
2297: xmlSchemaBasicItemPtr item,
2298: const char *message,
2299: const xmlChar *str1, const xmlChar *str2,
2300: const xmlChar *str3, const xmlChar *str4)
2301: {
2302: xmlChar *msg = NULL;
2303:
2304: if ((node == NULL) && (item != NULL) &&
2305: (actxt->type == XML_SCHEMA_CTXT_PARSER)) {
2306: node = WXS_ITEM_NODE(item);
2307: xmlSchemaFormatItemForReport(&msg, NULL, item, NULL);
2308: msg = xmlStrcat(msg, BAD_CAST ": ");
2309: } else
2310: xmlSchemaFormatNodeForError(&msg, actxt, node);
2311: msg = xmlStrcat(msg, (const xmlChar *) message);
2312: msg = xmlStrcat(msg, BAD_CAST ".\n");
2313: xmlSchemaErr4(actxt, error, node,
2314: (const char *) msg, str1, str2, str3, str4);
2315: FREE_AND_NULL(msg)
2316: }
2317:
2318: static void
2319: xmlSchemaCustomErr(xmlSchemaAbstractCtxtPtr actxt,
2320: xmlParserErrors error,
2321: xmlNodePtr node,
2322: xmlSchemaBasicItemPtr item,
2323: const char *message,
2324: const xmlChar *str1,
2325: const xmlChar *str2)
2326: {
2327: xmlSchemaCustomErr4(actxt, error, node, item,
2328: message, str1, str2, NULL, NULL);
2329: }
2330:
2331:
2332:
2333: static void
2334: xmlSchemaCustomWarning(xmlSchemaAbstractCtxtPtr actxt,
2335: xmlParserErrors error,
2336: xmlNodePtr node,
2337: xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
2338: const char *message,
2339: const xmlChar *str1,
2340: const xmlChar *str2,
2341: const xmlChar *str3)
2342: {
2343: xmlChar *msg = NULL;
2344:
2345: xmlSchemaFormatNodeForError(&msg, actxt, node);
2346: msg = xmlStrcat(msg, (const xmlChar *) message);
2347: msg = xmlStrcat(msg, BAD_CAST ".\n");
2348:
2349: /* URGENT TODO: Set the error code to something sane. */
2350: xmlSchemaErr4Line(actxt, XML_ERR_WARNING, error, node, 0,
2351: (const char *) msg, str1, str2, str3, NULL);
2352:
2353: FREE_AND_NULL(msg)
2354: }
2355:
2356:
2357:
2358: static void
2359: xmlSchemaKeyrefErr(xmlSchemaValidCtxtPtr vctxt,
2360: xmlParserErrors error,
2361: xmlSchemaPSVIIDCNodePtr idcNode,
2362: xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
2363: const char *message,
2364: const xmlChar *str1,
2365: const xmlChar *str2)
2366: {
2367: xmlChar *msg = NULL, *qname = NULL;
2368:
2369: msg = xmlStrdup(BAD_CAST "Element '%s': ");
2370: msg = xmlStrcat(msg, (const xmlChar *) message);
2371: msg = xmlStrcat(msg, BAD_CAST ".\n");
2372: xmlSchemaErr4Line(ACTXT_CAST vctxt, XML_ERR_ERROR,
2373: error, NULL, idcNode->nodeLine, (const char *) msg,
2374: xmlSchemaFormatQName(&qname,
2375: vctxt->nodeQNames->items[idcNode->nodeQNameID +1],
2376: vctxt->nodeQNames->items[idcNode->nodeQNameID]),
2377: str1, str2, NULL);
2378: FREE_AND_NULL(qname);
2379: FREE_AND_NULL(msg);
2380: }
2381:
2382: static int
2383: xmlSchemaEvalErrorNodeType(xmlSchemaAbstractCtxtPtr actxt,
2384: xmlNodePtr node)
2385: {
2386: if (node != NULL)
2387: return (node->type);
2388: if ((actxt->type == XML_SCHEMA_CTXT_VALIDATOR) &&
2389: (((xmlSchemaValidCtxtPtr) actxt)->inode != NULL))
2390: return ( ((xmlSchemaValidCtxtPtr) actxt)->inode->nodeType);
2391: return (-1);
2392: }
2393:
2394: static int
2395: xmlSchemaIsGlobalItem(xmlSchemaTypePtr item)
2396: {
2397: switch (item->type) {
2398: case XML_SCHEMA_TYPE_COMPLEX:
2399: case XML_SCHEMA_TYPE_SIMPLE:
2400: if (item->flags & XML_SCHEMAS_TYPE_GLOBAL)
2401: return(1);
2402: break;
2403: case XML_SCHEMA_TYPE_GROUP:
2404: return (1);
2405: case XML_SCHEMA_TYPE_ELEMENT:
2406: if ( ((xmlSchemaElementPtr) item)->flags &
2407: XML_SCHEMAS_ELEM_GLOBAL)
2408: return(1);
2409: break;
2410: case XML_SCHEMA_TYPE_ATTRIBUTE:
2411: if ( ((xmlSchemaAttributePtr) item)->flags &
2412: XML_SCHEMAS_ATTR_GLOBAL)
2413: return(1);
2414: break;
2415: /* Note that attribute groups are always global. */
2416: default:
2417: return(1);
2418: }
2419: return (0);
2420: }
2421:
2422: static void
2423: xmlSchemaSimpleTypeErr(xmlSchemaAbstractCtxtPtr actxt,
2424: xmlParserErrors error,
2425: xmlNodePtr node,
2426: const xmlChar *value,
2427: xmlSchemaTypePtr type,
2428: int displayValue)
2429: {
2430: xmlChar *msg = NULL;
2431:
2432: xmlSchemaFormatNodeForError(&msg, actxt, node);
2433:
2434: if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
2435: XML_ATTRIBUTE_NODE))
2436: msg = xmlStrcat(msg, BAD_CAST "'%s' is not a valid value of ");
2437: else
2438: msg = xmlStrcat(msg, BAD_CAST "The character content is not a valid "
2439: "value of ");
2440:
2441: if (! xmlSchemaIsGlobalItem(type))
2442: msg = xmlStrcat(msg, BAD_CAST "the local ");
2443: else
2444: msg = xmlStrcat(msg, BAD_CAST "the ");
2445:
2446: if (WXS_IS_ATOMIC(type))
2447: msg = xmlStrcat(msg, BAD_CAST "atomic type");
2448: else if (WXS_IS_LIST(type))
2449: msg = xmlStrcat(msg, BAD_CAST "list type");
2450: else if (WXS_IS_UNION(type))
2451: msg = xmlStrcat(msg, BAD_CAST "union type");
2452:
2453: if (xmlSchemaIsGlobalItem(type)) {
2454: xmlChar *str = NULL;
2455: msg = xmlStrcat(msg, BAD_CAST " '");
2456: if (type->builtInType != 0) {
2457: msg = xmlStrcat(msg, BAD_CAST "xs:");
2458: msg = xmlStrcat(msg, type->name);
2459: } else
2460: msg = xmlStrcat(msg,
2461: xmlSchemaFormatQName(&str,
2462: type->targetNamespace, type->name));
2463: msg = xmlStrcat(msg, BAD_CAST "'");
2464: FREE_AND_NULL(str);
2465: }
2466: msg = xmlStrcat(msg, BAD_CAST ".\n");
2467: if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
2468: XML_ATTRIBUTE_NODE))
2469: xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
2470: else
2471: xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2472: FREE_AND_NULL(msg)
2473: }
2474:
2475: static const xmlChar *
2476: xmlSchemaFormatErrorNodeQName(xmlChar ** str,
2477: xmlSchemaNodeInfoPtr ni,
2478: xmlNodePtr node)
2479: {
2480: if (node != NULL) {
2481: if (node->ns != NULL)
2482: return (xmlSchemaFormatQName(str, node->ns->href, node->name));
2483: else
2484: return (xmlSchemaFormatQName(str, NULL, node->name));
2485: } else if (ni != NULL)
2486: return (xmlSchemaFormatQName(str, ni->nsName, ni->localName));
2487: return (NULL);
2488: }
2489:
2490: static void
2491: xmlSchemaIllegalAttrErr(xmlSchemaAbstractCtxtPtr actxt,
2492: xmlParserErrors error,
2493: xmlSchemaAttrInfoPtr ni,
2494: xmlNodePtr node)
2495: {
2496: xmlChar *msg = NULL, *str = NULL;
2497:
2498: xmlSchemaFormatNodeForError(&msg, actxt, node);
2499: msg = xmlStrcat(msg, BAD_CAST "The attribute '%s' is not allowed.\n");
2500: xmlSchemaErr(actxt, error, node, (const char *) msg,
2501: xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node),
2502: NULL);
2503: FREE_AND_NULL(str)
2504: FREE_AND_NULL(msg)
2505: }
2506:
2507: static void
2508: xmlSchemaComplexTypeErr(xmlSchemaAbstractCtxtPtr actxt,
2509: xmlParserErrors error,
2510: xmlNodePtr node,
2511: xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
2512: const char *message,
2513: int nbval,
2514: int nbneg,
2515: xmlChar **values)
2516: {
2517: xmlChar *str = NULL, *msg = NULL;
2518: xmlChar *localName, *nsName;
2519: const xmlChar *cur, *end;
2520: int i;
2521:
2522: xmlSchemaFormatNodeForError(&msg, actxt, node);
2523: msg = xmlStrcat(msg, (const xmlChar *) message);
2524: msg = xmlStrcat(msg, BAD_CAST ".");
2525: /*
2526: * Note that is does not make sense to report that we have a
2527: * wildcard here, since the wildcard might be unfolded into
2528: * multiple transitions.
2529: */
2530: if (nbval + nbneg > 0) {
2531: if (nbval + nbneg > 1) {
2532: str = xmlStrdup(BAD_CAST " Expected is one of ( ");
2533: } else
2534: str = xmlStrdup(BAD_CAST " Expected is ( ");
2535: nsName = NULL;
2536:
2537: for (i = 0; i < nbval + nbneg; i++) {
2538: cur = values[i];
2539: if (cur == NULL)
2540: continue;
2541: if ((cur[0] == 'n') && (cur[1] == 'o') && (cur[2] == 't') &&
2542: (cur[3] == ' ')) {
2543: cur += 4;
2544: str = xmlStrcat(str, BAD_CAST "##other");
2545: }
2546: /*
2547: * Get the local name.
2548: */
2549: localName = NULL;
2550:
2551: end = cur;
2552: if (*end == '*') {
2553: localName = xmlStrdup(BAD_CAST "*");
2554: end++;
2555: } else {
2556: while ((*end != 0) && (*end != '|'))
2557: end++;
2558: localName = xmlStrncat(localName, BAD_CAST cur, end - cur);
2559: }
2560: if (*end != 0) {
2561: end++;
2562: /*
2563: * Skip "*|*" if they come with negated expressions, since
2564: * they represent the same negated wildcard.
2565: */
2566: if ((nbneg == 0) || (*end != '*') || (*localName != '*')) {
2567: /*
2568: * Get the namespace name.
2569: */
2570: cur = end;
2571: if (*end == '*') {
2572: nsName = xmlStrdup(BAD_CAST "{*}");
2573: } else {
2574: while (*end != 0)
2575: end++;
2576:
2577: if (i >= nbval)
2578: nsName = xmlStrdup(BAD_CAST "{##other:");
2579: else
2580: nsName = xmlStrdup(BAD_CAST "{");
2581:
2582: nsName = xmlStrncat(nsName, BAD_CAST cur, end - cur);
2583: nsName = xmlStrcat(nsName, BAD_CAST "}");
2584: }
2585: str = xmlStrcat(str, BAD_CAST nsName);
2586: FREE_AND_NULL(nsName)
2587: } else {
2588: FREE_AND_NULL(localName);
2589: continue;
2590: }
2591: }
2592: str = xmlStrcat(str, BAD_CAST localName);
2593: FREE_AND_NULL(localName);
2594:
2595: if (i < nbval + nbneg -1)
2596: str = xmlStrcat(str, BAD_CAST ", ");
2597: }
2598: str = xmlStrcat(str, BAD_CAST " ).\n");
2599: msg = xmlStrcat(msg, BAD_CAST str);
2600: FREE_AND_NULL(str)
2601: } else
2602: msg = xmlStrcat(msg, BAD_CAST "\n");
2603: xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2604: xmlFree(msg);
2605: }
2606:
2607: static void
2608: xmlSchemaFacetErr(xmlSchemaAbstractCtxtPtr actxt,
2609: xmlParserErrors error,
2610: xmlNodePtr node,
2611: const xmlChar *value,
2612: unsigned long length,
2613: xmlSchemaTypePtr type,
2614: xmlSchemaFacetPtr facet,
2615: const char *message,
2616: const xmlChar *str1,
2617: const xmlChar *str2)
2618: {
2619: xmlChar *str = NULL, *msg = NULL;
2620: xmlSchemaTypeType facetType;
2621: int nodeType = xmlSchemaEvalErrorNodeType(actxt, node);
2622:
2623: xmlSchemaFormatNodeForError(&msg, actxt, node);
2624: if (error == XML_SCHEMAV_CVC_ENUMERATION_VALID) {
2625: facetType = XML_SCHEMA_FACET_ENUMERATION;
2626: /*
2627: * If enumerations are validated, one must not expect the
2628: * facet to be given.
2629: */
2630: } else
2631: facetType = facet->type;
2632: msg = xmlStrcat(msg, BAD_CAST "[");
2633: msg = xmlStrcat(msg, BAD_CAST "facet '");
2634: msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facetType));
2635: msg = xmlStrcat(msg, BAD_CAST "'] ");
2636: if (message == NULL) {
2637: /*
2638: * Use a default message.
2639: */
2640: if ((facetType == XML_SCHEMA_FACET_LENGTH) ||
2641: (facetType == XML_SCHEMA_FACET_MINLENGTH) ||
2642: (facetType == XML_SCHEMA_FACET_MAXLENGTH)) {
2643:
2644: char len[25], actLen[25];
2645:
2646: /* FIXME, TODO: What is the max expected string length of the
2647: * this value?
2648: */
2649: if (nodeType == XML_ATTRIBUTE_NODE)
2650: msg = xmlStrcat(msg, BAD_CAST "The value '%s' has a length of '%s'; ");
2651: else
2652: msg = xmlStrcat(msg, BAD_CAST "The value has a length of '%s'; ");
2653:
2654: snprintf(len, 24, "%lu", xmlSchemaGetFacetValueAsULong(facet));
2655: snprintf(actLen, 24, "%lu", length);
2656:
2657: if (facetType == XML_SCHEMA_FACET_LENGTH)
2658: msg = xmlStrcat(msg,
2659: BAD_CAST "this differs from the allowed length of '%s'.\n");
2660: else if (facetType == XML_SCHEMA_FACET_MAXLENGTH)
2661: msg = xmlStrcat(msg,
2662: BAD_CAST "this exceeds the allowed maximum length of '%s'.\n");
2663: else if (facetType == XML_SCHEMA_FACET_MINLENGTH)
2664: msg = xmlStrcat(msg,
2665: BAD_CAST "this underruns the allowed minimum length of '%s'.\n");
2666:
2667: if (nodeType == XML_ATTRIBUTE_NODE)
2668: xmlSchemaErr3(actxt, error, node, (const char *) msg,
2669: value, (const xmlChar *) actLen, (const xmlChar *) len);
2670: else
2671: xmlSchemaErr(actxt, error, node, (const char *) msg,
2672: (const xmlChar *) actLen, (const xmlChar *) len);
2673:
2674: } else if (facetType == XML_SCHEMA_FACET_ENUMERATION) {
2675: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not an element "
2676: "of the set {%s}.\n");
2677: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2678: xmlSchemaFormatFacetEnumSet(actxt, &str, type));
2679: } else if (facetType == XML_SCHEMA_FACET_PATTERN) {
2680: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not accepted "
2681: "by the pattern '%s'.\n");
2682: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2683: facet->value);
2684: } else if (facetType == XML_SCHEMA_FACET_MININCLUSIVE) {
2685: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is less than the "
2686: "minimum value allowed ('%s').\n");
2687: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2688: facet->value);
2689: } else if (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) {
2690: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is greater than the "
2691: "maximum value allowed ('%s').\n");
2692: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2693: facet->value);
2694: } else if (facetType == XML_SCHEMA_FACET_MINEXCLUSIVE) {
2695: msg = xmlStrcat(msg, BAD_CAST "The value '%s' must be greater than "
2696: "'%s'.\n");
2697: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2698: facet->value);
2699: } else if (facetType == XML_SCHEMA_FACET_MAXEXCLUSIVE) {
2700: msg = xmlStrcat(msg, BAD_CAST "The value '%s' must be less than "
2701: "'%s'.\n");
2702: xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2703: facet->value);
2704: } else if (facetType == XML_SCHEMA_FACET_TOTALDIGITS) {
2705: msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more "
2706: "digits than are allowed ('%s').\n");
2707: xmlSchemaErr(actxt, error, node, (const char*) msg, value,
2708: facet->value);
2709: } else if (facetType == XML_SCHEMA_FACET_FRACTIONDIGITS) {
2710: msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more fractional "
2711: "digits than are allowed ('%s').\n");
2712: xmlSchemaErr(actxt, error, node, (const char*) msg, value,
2713: facet->value);
2714: } else if (nodeType == XML_ATTRIBUTE_NODE) {
2715: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not facet-valid.\n");
2716: xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
2717: } else {
2718: msg = xmlStrcat(msg, BAD_CAST "The value is not facet-valid.\n");
2719: xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2720: }
2721: } else {
2722: msg = xmlStrcat(msg, (const xmlChar *) message);
2723: msg = xmlStrcat(msg, BAD_CAST ".\n");
2724: xmlSchemaErr(actxt, error, node, (const char *) msg, str1, str2);
2725: }
2726: FREE_AND_NULL(str)
2727: xmlFree(msg);
2728: }
2729:
2730: #define VERROR(err, type, msg) \
2731: xmlSchemaCustomErr(ACTXT_CAST vctxt, err, NULL, type, msg, NULL, NULL);
2732:
2733: #define VERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST vctxt, func, msg);
2734:
2735: #define PERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST pctxt, func, msg);
2736: #define PERROR_INT2(func, msg) xmlSchemaInternalErr(ACTXT_CAST ctxt, func, msg);
2737:
2738: #define AERROR_INT(func, msg) xmlSchemaInternalErr(actxt, func, msg);
2739:
2740:
2741: /**
2742: * xmlSchemaPMissingAttrErr:
2743: * @ctxt: the schema validation context
2744: * @ownerDes: the designation of the owner
2745: * @ownerName: the name of the owner
2746: * @ownerItem: the owner as a schema object
2747: * @ownerElem: the owner as an element node
2748: * @node: the parent element node of the missing attribute node
2749: * @type: the corresponding type of the attribute node
2750: *
2751: * Reports an illegal attribute.
2752: */
2753: static void
2754: xmlSchemaPMissingAttrErr(xmlSchemaParserCtxtPtr ctxt,
2755: xmlParserErrors error,
2756: xmlSchemaBasicItemPtr ownerItem,
2757: xmlNodePtr ownerElem,
2758: const char *name,
2759: const char *message)
2760: {
2761: xmlChar *des = NULL;
2762:
2763: xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
2764:
2765: if (message != NULL)
2766: xmlSchemaPErr(ctxt, ownerElem, error, "%s: %s.\n", BAD_CAST des, BAD_CAST message);
2767: else
2768: xmlSchemaPErr(ctxt, ownerElem, error,
2769: "%s: The attribute '%s' is required but missing.\n",
2770: BAD_CAST des, BAD_CAST name);
2771: FREE_AND_NULL(des);
2772: }
2773:
2774:
2775: /**
2776: * xmlSchemaPResCompAttrErr:
2777: * @ctxt: the schema validation context
2778: * @error: the error code
2779: * @ownerDes: the designation of the owner
2780: * @ownerItem: the owner as a schema object
2781: * @ownerElem: the owner as an element node
2782: * @name: the name of the attribute holding the QName
2783: * @refName: the referenced local name
2784: * @refURI: the referenced namespace URI
2785: * @message: optional message
2786: *
2787: * Used to report QName attribute values that failed to resolve
2788: * to schema components.
2789: */
2790: static void
2791: xmlSchemaPResCompAttrErr(xmlSchemaParserCtxtPtr ctxt,
2792: xmlParserErrors error,
2793: xmlSchemaBasicItemPtr ownerItem,
2794: xmlNodePtr ownerElem,
2795: const char *name,
2796: const xmlChar *refName,
2797: const xmlChar *refURI,
2798: xmlSchemaTypeType refType,
2799: const char *refTypeStr)
2800: {
2801: xmlChar *des = NULL, *strA = NULL;
2802:
2803: xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
2804: if (refTypeStr == NULL)
2805: refTypeStr = (const char *) xmlSchemaItemTypeToStr(refType);
2806: xmlSchemaPErrExt(ctxt, ownerElem, error,
2807: NULL, NULL, NULL,
2808: "%s, attribute '%s': The QName value '%s' does not resolve to a(n) "
2809: "%s.\n", BAD_CAST des, BAD_CAST name,
2810: xmlSchemaFormatQName(&strA, refURI, refName),
2811: BAD_CAST refTypeStr, NULL);
2812: FREE_AND_NULL(des)
2813: FREE_AND_NULL(strA)
2814: }
2815:
2816: /**
2817: * xmlSchemaPCustomAttrErr:
2818: * @ctxt: the schema parser context
2819: * @error: the error code
2820: * @ownerDes: the designation of the owner
2821: * @ownerItem: the owner as a schema object
2822: * @attr: the illegal attribute node
2823: *
2824: * Reports an illegal attribute during the parse.
2825: */
2826: static void
2827: xmlSchemaPCustomAttrErr(xmlSchemaParserCtxtPtr ctxt,
2828: xmlParserErrors error,
2829: xmlChar **ownerDes,
2830: xmlSchemaBasicItemPtr ownerItem,
2831: xmlAttrPtr attr,
2832: const char *msg)
2833: {
2834: xmlChar *des = NULL;
2835:
2836: if (ownerDes == NULL)
2837: xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent);
2838: else if (*ownerDes == NULL) {
2839: xmlSchemaFormatItemForReport(ownerDes, NULL, ownerItem, attr->parent);
2840: des = *ownerDes;
2841: } else
2842: des = *ownerDes;
2843: if (attr == NULL) {
2844: xmlSchemaPErrExt(ctxt, NULL, error, NULL, NULL, NULL,
2845: "%s, attribute '%s': %s.\n",
2846: BAD_CAST des, (const xmlChar *) "Unknown",
2847: (const xmlChar *) msg, NULL, NULL);
2848: } else {
2849: xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
2850: "%s, attribute '%s': %s.\n",
2851: BAD_CAST des, attr->name, (const xmlChar *) msg, NULL, NULL);
2852: }
2853: if (ownerDes == NULL)
2854: FREE_AND_NULL(des);
2855: }
2856:
2857: /**
2858: * xmlSchemaPIllegalAttrErr:
2859: * @ctxt: the schema parser context
2860: * @error: the error code
2861: * @ownerDes: the designation of the attribute's owner
2862: * @ownerItem: the attribute's owner item
2863: * @attr: the illegal attribute node
2864: *
2865: * Reports an illegal attribute during the parse.
2866: */
2867: static void
2868: xmlSchemaPIllegalAttrErr(xmlSchemaParserCtxtPtr ctxt,
2869: xmlParserErrors error,
2870: xmlSchemaBasicItemPtr ownerComp ATTRIBUTE_UNUSED,
2871: xmlAttrPtr attr)
2872: {
2873: xmlChar *strA = NULL, *strB = NULL;
2874:
2875: xmlSchemaFormatNodeForError(&strA, ACTXT_CAST ctxt, attr->parent);
2876: xmlSchemaErr4(ACTXT_CAST ctxt, error, (xmlNodePtr) attr,
2877: "%sThe attribute '%s' is not allowed.\n", BAD_CAST strA,
2878: xmlSchemaFormatQNameNs(&strB, attr->ns, attr->name),
2879: NULL, NULL);
2880: FREE_AND_NULL(strA);
2881: FREE_AND_NULL(strB);
2882: }
2883:
2884: /**
2885: * xmlSchemaPCustomErr:
2886: * @ctxt: the schema parser context
2887: * @error: the error code
2888: * @itemDes: the designation of the schema item
2889: * @item: the schema item
2890: * @itemElem: the node of the schema item
2891: * @message: the error message
2892: * @str1: an optional param for the error message
2893: * @str2: an optional param for the error message
2894: * @str3: an optional param for the error message
2895: *
2896: * Reports an error during parsing.
2897: */
2898: static void
2899: xmlSchemaPCustomErrExt(xmlSchemaParserCtxtPtr ctxt,
2900: xmlParserErrors error,
2901: xmlSchemaBasicItemPtr item,
2902: xmlNodePtr itemElem,
2903: const char *message,
2904: const xmlChar *str1,
2905: const xmlChar *str2,
2906: const xmlChar *str3)
2907: {
2908: xmlChar *des = NULL, *msg = NULL;
2909:
2910: xmlSchemaFormatItemForReport(&des, NULL, item, itemElem);
2911: msg = xmlStrdup(BAD_CAST "%s: ");
2912: msg = xmlStrcat(msg, (const xmlChar *) message);
2913: msg = xmlStrcat(msg, BAD_CAST ".\n");
2914: if ((itemElem == NULL) && (item != NULL))
2915: itemElem = WXS_ITEM_NODE(item);
2916: xmlSchemaPErrExt(ctxt, itemElem, error, NULL, NULL, NULL,
2917: (const char *) msg, BAD_CAST des, str1, str2, str3, NULL);
2918: FREE_AND_NULL(des);
2919: FREE_AND_NULL(msg);
2920: }
2921:
2922: /**
2923: * xmlSchemaPCustomErr:
2924: * @ctxt: the schema parser context
2925: * @error: the error code
2926: * @itemDes: the designation of the schema item
2927: * @item: the schema item
2928: * @itemElem: the node of the schema item
2929: * @message: the error message
2930: * @str1: the optional param for the error message
2931: *
2932: * Reports an error during parsing.
2933: */
2934: static void
2935: xmlSchemaPCustomErr(xmlSchemaParserCtxtPtr ctxt,
2936: xmlParserErrors error,
2937: xmlSchemaBasicItemPtr item,
2938: xmlNodePtr itemElem,
2939: const char *message,
2940: const xmlChar *str1)
2941: {
2942: xmlSchemaPCustomErrExt(ctxt, error, item, itemElem, message,
2943: str1, NULL, NULL);
2944: }
2945:
2946: /**
2947: * xmlSchemaPAttrUseErr:
2948: * @ctxt: the schema parser context
2949: * @error: the error code
2950: * @itemDes: the designation of the schema type
2951: * @item: the schema type
2952: * @itemElem: the node of the schema type
2953: * @attr: the invalid schema attribute
2954: * @message: the error message
2955: * @str1: the optional param for the error message
2956: *
2957: * Reports an attribute use error during parsing.
2958: */
2959: static void
2960: xmlSchemaPAttrUseErr4(xmlSchemaParserCtxtPtr ctxt,
2961: xmlParserErrors error,
2962: xmlNodePtr node,
2963: xmlSchemaBasicItemPtr ownerItem,
2964: const xmlSchemaAttributeUsePtr attruse,
2965: const char *message,
2966: const xmlChar *str1, const xmlChar *str2,
2967: const xmlChar *str3,const xmlChar *str4)
2968: {
2969: xmlChar *str = NULL, *msg = NULL;
2970:
2971: xmlSchemaFormatItemForReport(&msg, NULL, ownerItem, NULL);
2972: msg = xmlStrcat(msg, BAD_CAST ", ");
2973: msg = xmlStrcat(msg,
2974: BAD_CAST xmlSchemaFormatItemForReport(&str, NULL,
2975: WXS_BASIC_CAST attruse, NULL));
2976: FREE_AND_NULL(str);
2977: msg = xmlStrcat(msg, BAD_CAST ": ");
2978: msg = xmlStrcat(msg, (const xmlChar *) message);
2979: msg = xmlStrcat(msg, BAD_CAST ".\n");
2980: xmlSchemaErr4(ACTXT_CAST ctxt, error, node,
2981: (const char *) msg, str1, str2, str3, str4);
2982: xmlFree(msg);
2983: }
2984:
2985: /**
2986: * xmlSchemaPIllegalFacetAtomicErr:
2987: * @ctxt: the schema parser context
2988: * @error: the error code
2989: * @type: the schema type
2990: * @baseType: the base type of type
2991: * @facet: the illegal facet
2992: *
2993: * Reports an illegal facet for atomic simple types.
2994: */
2995: static void
2996: xmlSchemaPIllegalFacetAtomicErr(xmlSchemaParserCtxtPtr ctxt,
2997: xmlParserErrors error,
2998: xmlSchemaTypePtr type,
2999: xmlSchemaTypePtr baseType,
3000: xmlSchemaFacetPtr facet)
3001: {
3002: xmlChar *des = NULL, *strT = NULL;
3003:
3004: xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST type, type->node);
3005: xmlSchemaPErrExt(ctxt, type->node, error, NULL, NULL, NULL,
3006: "%s: The facet '%s' is not allowed on types derived from the "
3007: "type %s.\n",
3008: BAD_CAST des, xmlSchemaFacetTypeToString(facet->type),
3009: xmlSchemaFormatItemForReport(&strT, NULL, WXS_BASIC_CAST baseType, NULL),
3010: NULL, NULL);
3011: FREE_AND_NULL(des);
3012: FREE_AND_NULL(strT);
3013: }
3014:
3015: /**
3016: * xmlSchemaPIllegalFacetListUnionErr:
3017: * @ctxt: the schema parser context
3018: * @error: the error code
3019: * @itemDes: the designation of the schema item involved
3020: * @item: the schema item involved
3021: * @facet: the illegal facet
3022: *
3023: * Reports an illegal facet for <list> and <union>.
3024: */
3025: static void
3026: xmlSchemaPIllegalFacetListUnionErr(xmlSchemaParserCtxtPtr ctxt,
3027: xmlParserErrors error,
3028: xmlSchemaTypePtr type,
3029: xmlSchemaFacetPtr facet)
3030: {
3031: xmlChar *des = NULL;
3032:
3033: xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST type,
3034: type->node);
3035: xmlSchemaPErr(ctxt, type->node, error,
3036: "%s: The facet '%s' is not allowed.\n",
3037: BAD_CAST des, xmlSchemaFacetTypeToString(facet->type));
3038: FREE_AND_NULL(des);
3039: }
3040:
3041: /**
3042: * xmlSchemaPMutualExclAttrErr:
3043: * @ctxt: the schema validation context
3044: * @error: the error code
3045: * @elemDes: the designation of the parent element node
3046: * @attr: the bad attribute node
3047: * @type: the corresponding type of the attribute node
3048: *
3049: * Reports an illegal attribute.
3050: */
3051: static void
3052: xmlSchemaPMutualExclAttrErr(xmlSchemaParserCtxtPtr ctxt,
3053: xmlParserErrors error,
3054: xmlSchemaBasicItemPtr ownerItem,
3055: xmlAttrPtr attr,
3056: const char *name1,
3057: const char *name2)
3058: {
3059: xmlChar *des = NULL;
3060:
3061: xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST ownerItem, attr->parent);
3062: xmlSchemaPErrExt(ctxt, (xmlNodePtr) attr, error, NULL, NULL, NULL,
3063: "%s: The attributes '%s' and '%s' are mutually exclusive.\n",
3064: BAD_CAST des, BAD_CAST name1, BAD_CAST name2, NULL, NULL);
3065: FREE_AND_NULL(des);
3066: }
3067:
3068: /**
3069: * xmlSchemaPSimpleTypeErr:
3070: * @ctxt: the schema validation context
3071: * @error: the error code
3072: * @type: the type specifier
3073: * @ownerDes: the designation of the owner
3074: * @ownerItem: the schema object if existent
3075: * @node: the validated node
3076: * @value: the validated value
3077: *
3078: * Reports a simple type validation error.
3079: * TODO: Should this report the value of an element as well?
3080: */
3081: static void
3082: xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt,
3083: xmlParserErrors error,
3084: xmlSchemaBasicItemPtr ownerItem ATTRIBUTE_UNUSED,
3085: xmlNodePtr node,
3086: xmlSchemaTypePtr type,
3087: const char *expected,
3088: const xmlChar *value,
3089: const char *message,
3090: const xmlChar *str1,
3091: const xmlChar *str2)
3092: {
3093: xmlChar *msg = NULL;
3094:
3095: xmlSchemaFormatNodeForError(&msg, ACTXT_CAST ctxt, node);
3096: if (message == NULL) {
3097: /*
3098: * Use default messages.
3099: */
3100: if (type != NULL) {
3101: if (node->type == XML_ATTRIBUTE_NODE)
3102: msg = xmlStrcat(msg, BAD_CAST "'%s' is not a valid value of ");
3103: else
3104: msg = xmlStrcat(msg, BAD_CAST "The character content is not a "
3105: "valid value of ");
3106: if (! xmlSchemaIsGlobalItem(type))
3107: msg = xmlStrcat(msg, BAD_CAST "the local ");
3108: else
3109: msg = xmlStrcat(msg, BAD_CAST "the ");
3110:
3111: if (WXS_IS_ATOMIC(type))
3112: msg = xmlStrcat(msg, BAD_CAST "atomic type");
3113: else if (WXS_IS_LIST(type))
3114: msg = xmlStrcat(msg, BAD_CAST "list type");
3115: else if (WXS_IS_UNION(type))
3116: msg = xmlStrcat(msg, BAD_CAST "union type");
3117:
3118: if (xmlSchemaIsGlobalItem(type)) {
3119: xmlChar *str = NULL;
3120: msg = xmlStrcat(msg, BAD_CAST " '");
3121: if (type->builtInType != 0) {
3122: msg = xmlStrcat(msg, BAD_CAST "xs:");
3123: msg = xmlStrcat(msg, type->name);
3124: } else
3125: msg = xmlStrcat(msg,
3126: xmlSchemaFormatQName(&str,
3127: type->targetNamespace, type->name));
3128: msg = xmlStrcat(msg, BAD_CAST "'.");
3129: FREE_AND_NULL(str);
3130: }
3131: } else {
3132: if (node->type == XML_ATTRIBUTE_NODE)
3133: msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not valid.");
3134: else
3135: msg = xmlStrcat(msg, BAD_CAST "The character content is not "
3136: "valid.");
3137: }
3138: if (expected) {
3139: msg = xmlStrcat(msg, BAD_CAST " Expected is '");
3140: msg = xmlStrcat(msg, BAD_CAST expected);
3141: msg = xmlStrcat(msg, BAD_CAST "'.\n");
3142: } else
3143: msg = xmlStrcat(msg, BAD_CAST "\n");
3144: if (node->type == XML_ATTRIBUTE_NODE)
3145: xmlSchemaPErr(ctxt, node, error, (const char *) msg, value, NULL);
3146: else
3147: xmlSchemaPErr(ctxt, node, error, (const char *) msg, NULL, NULL);
3148: } else {
3149: msg = xmlStrcat(msg, BAD_CAST message);
3150: msg = xmlStrcat(msg, BAD_CAST ".\n");
3151: xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
3152: (const char*) msg, str1, str2, NULL, NULL, NULL);
3153: }
3154: /* Cleanup. */
3155: FREE_AND_NULL(msg)
3156: }
3157:
3158: /**
3159: * xmlSchemaPContentErr:
3160: * @ctxt: the schema parser context
3161: * @error: the error code
3162: * @onwerDes: the designation of the holder of the content
3163: * @ownerItem: the owner item of the holder of the content
3164: * @ownerElem: the node of the holder of the content
3165: * @child: the invalid child node
3166: * @message: the optional error message
3167: * @content: the optional string describing the correct content
3168: *
3169: * Reports an error concerning the content of a schema element.
3170: */
3171: static void
3172: xmlSchemaPContentErr(xmlSchemaParserCtxtPtr ctxt,
3173: xmlParserErrors error,
3174: xmlSchemaBasicItemPtr ownerItem,
3175: xmlNodePtr ownerElem,
3176: xmlNodePtr child,
3177: const char *message,
3178: const char *content)
3179: {
3180: xmlChar *des = NULL;
3181:
3182: xmlSchemaFormatItemForReport(&des, NULL, ownerItem, ownerElem);
3183: if (message != NULL)
3184: xmlSchemaPErr2(ctxt, ownerElem, child, error,
3185: "%s: %s.\n",
3186: BAD_CAST des, BAD_CAST message);
3187: else {
3188: if (content != NULL) {
3189: xmlSchemaPErr2(ctxt, ownerElem, child, error,
3190: "%s: The content is not valid. Expected is %s.\n",
3191: BAD_CAST des, BAD_CAST content);
3192: } else {
3193: xmlSchemaPErr2(ctxt, ownerElem, child, error,
3194: "%s: The content is not valid.\n",
3195: BAD_CAST des, NULL);
3196: }
3197: }
3198: FREE_AND_NULL(des)
3199: }
3200:
3201: /************************************************************************
3202: * *
3203: * Streamable error functions *
3204: * *
3205: ************************************************************************/
3206:
3207:
3208:
3209:
3210: /************************************************************************
3211: * *
3212: * Validation helper functions *
3213: * *
3214: ************************************************************************/
3215:
3216:
3217: /************************************************************************
3218: * *
3219: * Allocation functions *
3220: * *
3221: ************************************************************************/
3222:
3223: /**
3224: * xmlSchemaNewSchemaForParserCtxt:
3225: * @ctxt: a schema validation context
3226: *
3227: * Allocate a new Schema structure.
3228: *
3229: * Returns the newly allocated structure or NULL in case or error
3230: */
3231: static xmlSchemaPtr
3232: xmlSchemaNewSchema(xmlSchemaParserCtxtPtr ctxt)
3233: {
3234: xmlSchemaPtr ret;
3235:
3236: ret = (xmlSchemaPtr) xmlMalloc(sizeof(xmlSchema));
3237: if (ret == NULL) {
3238: xmlSchemaPErrMemory(ctxt, "allocating schema", NULL);
3239: return (NULL);
3240: }
3241: memset(ret, 0, sizeof(xmlSchema));
3242: ret->dict = ctxt->dict;
3243: xmlDictReference(ret->dict);
3244:
3245: return (ret);
3246: }
3247:
3248: /**
3249: * xmlSchemaNewFacet:
3250: *
3251: * Allocate a new Facet structure.
3252: *
3253: * Returns the newly allocated structure or NULL in case or error
3254: */
3255: xmlSchemaFacetPtr
3256: xmlSchemaNewFacet(void)
3257: {
3258: xmlSchemaFacetPtr ret;
3259:
3260: ret = (xmlSchemaFacetPtr) xmlMalloc(sizeof(xmlSchemaFacet));
3261: if (ret == NULL) {
3262: return (NULL);
3263: }
3264: memset(ret, 0, sizeof(xmlSchemaFacet));
3265:
3266: return (ret);
3267: }
3268:
3269: /**
3270: * xmlSchemaNewAnnot:
3271: * @ctxt: a schema validation context
3272: * @node: a node
3273: *
3274: * Allocate a new annotation structure.
3275: *
3276: * Returns the newly allocated structure or NULL in case or error
3277: */
3278: static xmlSchemaAnnotPtr
3279: xmlSchemaNewAnnot(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
3280: {
3281: xmlSchemaAnnotPtr ret;
3282:
3283: ret = (xmlSchemaAnnotPtr) xmlMalloc(sizeof(xmlSchemaAnnot));
3284: if (ret == NULL) {
3285: xmlSchemaPErrMemory(ctxt, "allocating annotation", node);
3286: return (NULL);
3287: }
3288: memset(ret, 0, sizeof(xmlSchemaAnnot));
3289: ret->content = node;
3290: return (ret);
3291: }
3292:
3293: static xmlSchemaItemListPtr
3294: xmlSchemaItemListCreate(void)
3295: {
3296: xmlSchemaItemListPtr ret;
3297:
3298: ret = xmlMalloc(sizeof(xmlSchemaItemList));
3299: if (ret == NULL) {
3300: xmlSchemaPErrMemory(NULL,
3301: "allocating an item list structure", NULL);
3302: return (NULL);
3303: }
3304: memset(ret, 0, sizeof(xmlSchemaItemList));
3305: return (ret);
3306: }
3307:
3308: static void
3309: xmlSchemaItemListClear(xmlSchemaItemListPtr list)
3310: {
3311: if (list->items != NULL) {
3312: xmlFree(list->items);
3313: list->items = NULL;
3314: }
3315: list->nbItems = 0;
3316: list->sizeItems = 0;
3317: }
3318:
3319: static int
3320: xmlSchemaItemListAdd(xmlSchemaItemListPtr list, void *item)
3321: {
3322: if (list->items == NULL) {
3323: list->items = (void **) xmlMalloc(
3324: 20 * sizeof(void *));
3325: if (list->items == NULL) {
3326: xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
3327: return(-1);
3328: }
3329: list->sizeItems = 20;
3330: } else if (list->sizeItems <= list->nbItems) {
3331: list->sizeItems *= 2;
3332: list->items = (void **) xmlRealloc(list->items,
3333: list->sizeItems * sizeof(void *));
3334: if (list->items == NULL) {
3335: xmlSchemaPErrMemory(NULL, "growing item list", NULL);
3336: list->sizeItems = 0;
3337: return(-1);
3338: }
3339: }
3340: list->items[list->nbItems++] = item;
3341: return(0);
3342: }
3343:
3344: static int
3345: xmlSchemaItemListAddSize(xmlSchemaItemListPtr list,
3346: int initialSize,
3347: void *item)
3348: {
3349: if (list->items == NULL) {
3350: if (initialSize <= 0)
3351: initialSize = 1;
3352: list->items = (void **) xmlMalloc(
3353: initialSize * sizeof(void *));
3354: if (list->items == NULL) {
3355: xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
3356: return(-1);
3357: }
3358: list->sizeItems = initialSize;
3359: } else if (list->sizeItems <= list->nbItems) {
3360: list->sizeItems *= 2;
3361: list->items = (void **) xmlRealloc(list->items,
3362: list->sizeItems * sizeof(void *));
3363: if (list->items == NULL) {
3364: xmlSchemaPErrMemory(NULL, "growing item list", NULL);
3365: list->sizeItems = 0;
3366: return(-1);
3367: }
3368: }
3369: list->items[list->nbItems++] = item;
3370: return(0);
3371: }
3372:
3373: static int
3374: xmlSchemaItemListInsert(xmlSchemaItemListPtr list, void *item, int idx)
3375: {
3376: if (list->items == NULL) {
3377: list->items = (void **) xmlMalloc(
3378: 20 * sizeof(void *));
3379: if (list->items == NULL) {
3380: xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
3381: return(-1);
3382: }
3383: list->sizeItems = 20;
3384: } else if (list->sizeItems <= list->nbItems) {
3385: list->sizeItems *= 2;
3386: list->items = (void **) xmlRealloc(list->items,
3387: list->sizeItems * sizeof(void *));
3388: if (list->items == NULL) {
3389: xmlSchemaPErrMemory(NULL, "growing item list", NULL);
3390: list->sizeItems = 0;
3391: return(-1);
3392: }
3393: }
3394: /*
3395: * Just append if the index is greater/equal than the item count.
3396: */
3397: if (idx >= list->nbItems) {
3398: list->items[list->nbItems++] = item;
3399: } else {
3400: int i;
3401: for (i = list->nbItems; i > idx; i--)
3402: list->items[i] = list->items[i-1];
3403: list->items[idx] = item;
3404: list->nbItems++;
3405: }
3406: return(0);
3407: }
3408:
3409: #if 0 /* enable if ever needed */
3410: static int
3411: xmlSchemaItemListInsertSize(xmlSchemaItemListPtr list,
3412: int initialSize,
3413: void *item,
3414: int idx)
3415: {
3416: if (list->items == NULL) {
3417: if (initialSize <= 0)
3418: initialSize = 1;
3419: list->items = (void **) xmlMalloc(
3420: initialSize * sizeof(void *));
3421: if (list->items == NULL) {
3422: xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
3423: return(-1);
3424: }
3425: list->sizeItems = initialSize;
3426: } else if (list->sizeItems <= list->nbItems) {
3427: list->sizeItems *= 2;
3428: list->items = (void **) xmlRealloc(list->items,
3429: list->sizeItems * sizeof(void *));
3430: if (list->items == NULL) {
3431: xmlSchemaPErrMemory(NULL, "growing item list", NULL);
3432: list->sizeItems = 0;
3433: return(-1);
3434: }
3435: }
3436: /*
3437: * Just append if the index is greater/equal than the item count.
3438: */
3439: if (idx >= list->nbItems) {
3440: list->items[list->nbItems++] = item;
3441: } else {
3442: int i;
3443: for (i = list->nbItems; i > idx; i--)
3444: list->items[i] = list->items[i-1];
3445: list->items[idx] = item;
3446: list->nbItems++;
3447: }
3448: return(0);
3449: }
3450: #endif
3451:
3452: static int
3453: xmlSchemaItemListRemove(xmlSchemaItemListPtr list, int idx)
3454: {
3455: int i;
3456: if ((list->items == NULL) || (idx >= list->nbItems)) {
3457: xmlSchemaPSimpleErr("Internal error: xmlSchemaItemListRemove, "
3458: "index error.\n");
3459: return(-1);
3460: }
3461:
3462: if (list->nbItems == 1) {
3463: /* TODO: Really free the list? */
3464: xmlFree(list->items);
3465: list->items = NULL;
3466: list->nbItems = 0;
3467: list->sizeItems = 0;
3468: } else if (list->nbItems -1 == idx) {
3469: list->nbItems--;
3470: } else {
3471: for (i = idx; i < list->nbItems -1; i++)
3472: list->items[i] = list->items[i+1];
3473: list->nbItems--;
3474: }
3475: return(0);
3476: }
3477:
3478: /**
3479: * xmlSchemaItemListFree:
3480: * @annot: a schema type structure
3481: *
3482: * Deallocate a annotation structure
3483: */
3484: static void
3485: xmlSchemaItemListFree(xmlSchemaItemListPtr list)
3486: {
3487: if (list == NULL)
3488: return;
3489: if (list->items != NULL)
3490: xmlFree(list->items);
3491: xmlFree(list);
3492: }
3493:
3494: static void
3495: xmlSchemaBucketFree(xmlSchemaBucketPtr bucket)
3496: {
3497: if (bucket == NULL)
3498: return;
3499: if (bucket->globals != NULL) {
3500: xmlSchemaComponentListFree(bucket->globals);
3501: xmlSchemaItemListFree(bucket->globals);
3502: }
3503: if (bucket->locals != NULL) {
3504: xmlSchemaComponentListFree(bucket->locals);
3505: xmlSchemaItemListFree(bucket->locals);
3506: }
3507: if (bucket->relations != NULL) {
3508: xmlSchemaSchemaRelationPtr prev, cur = bucket->relations;
3509: do {
3510: prev = cur;
3511: cur = cur->next;
3512: xmlFree(prev);
3513: } while (cur != NULL);
3514: }
3515: if ((! bucket->preserveDoc) && (bucket->doc != NULL)) {
3516: xmlFreeDoc(bucket->doc);
3517: }
3518: if (bucket->type == XML_SCHEMA_SCHEMA_IMPORT) {
3519: if (WXS_IMPBUCKET(bucket)->schema != NULL)
3520: xmlSchemaFree(WXS_IMPBUCKET(bucket)->schema);
3521: }
3522: xmlFree(bucket);
3523: }
3524:
3525: static xmlSchemaBucketPtr
3526: xmlSchemaBucketCreate(xmlSchemaParserCtxtPtr pctxt,
3527: int type, const xmlChar *targetNamespace)
3528: {
3529: xmlSchemaBucketPtr ret;
3530: int size;
3531: xmlSchemaPtr mainSchema;
3532:
3533: if (WXS_CONSTRUCTOR(pctxt)->mainSchema == NULL) {
3534: PERROR_INT("xmlSchemaBucketCreate",
3535: "no main schema on constructor");
3536: return(NULL);
3537: }
3538: mainSchema = WXS_CONSTRUCTOR(pctxt)->mainSchema;
3539: /* Create the schema bucket. */
3540: if (WXS_IS_BUCKET_INCREDEF(type))
3541: size = sizeof(xmlSchemaInclude);
3542: else
3543: size = sizeof(xmlSchemaImport);
3544: ret = (xmlSchemaBucketPtr) xmlMalloc(size);
3545: if (ret == NULL) {
3546: xmlSchemaPErrMemory(NULL, "allocating schema bucket", NULL);
3547: return(NULL);
3548: }
3549: memset(ret, 0, size);
3550: ret->targetNamespace = targetNamespace;
3551: ret->type = type;
3552: ret->globals = xmlSchemaItemListCreate();
3553: if (ret->globals == NULL) {
3554: xmlFree(ret);
3555: return(NULL);
3556: }
3557: ret->locals = xmlSchemaItemListCreate();
3558: if (ret->locals == NULL) {
3559: xmlFree(ret);
3560: return(NULL);
3561: }
3562: /*
3563: * The following will assure that only the first bucket is marked as
3564: * XML_SCHEMA_SCHEMA_MAIN and it points to the *main* schema.
3565: * For each following import buckets an xmlSchema will be created.
3566: * An xmlSchema will be created for every distinct targetNamespace.
3567: * We assign the targetNamespace to the schemata here.
3568: */
3569: if (! WXS_HAS_BUCKETS(pctxt)) {
3570: if (WXS_IS_BUCKET_INCREDEF(type)) {
3571: PERROR_INT("xmlSchemaBucketCreate",
3572: "first bucket but it's an include or redefine");
3573: xmlSchemaBucketFree(ret);
3574: return(NULL);
3575: }
3576: /* Force the type to be XML_SCHEMA_SCHEMA_MAIN. */
3577: ret->type = XML_SCHEMA_SCHEMA_MAIN;
3578: /* Point to the *main* schema. */
3579: WXS_CONSTRUCTOR(pctxt)->mainBucket = ret;
3580: WXS_IMPBUCKET(ret)->schema = mainSchema;
3581: /*
3582: * Ensure that the main schema gets a targetNamespace.
3583: */
3584: mainSchema->targetNamespace = targetNamespace;
3585: } else {
3586: if (type == XML_SCHEMA_SCHEMA_MAIN) {
3587: PERROR_INT("xmlSchemaBucketCreate",
3588: "main bucket but it's not the first one");
3589: xmlSchemaBucketFree(ret);
3590: return(NULL);
3591: } else if (type == XML_SCHEMA_SCHEMA_IMPORT) {
3592: /*
3593: * Create a schema for imports and assign the
3594: * targetNamespace.
3595: */
3596: WXS_IMPBUCKET(ret)->schema = xmlSchemaNewSchema(pctxt);
3597: if (WXS_IMPBUCKET(ret)->schema == NULL) {
3598: xmlSchemaBucketFree(ret);
3599: return(NULL);
3600: }
3601: WXS_IMPBUCKET(ret)->schema->targetNamespace = targetNamespace;
3602: }
3603: }
3604: if (WXS_IS_BUCKET_IMPMAIN(type)) {
3605: int res;
3606: /*
3607: * Imports go into the "schemasImports" slot of the main *schema*.
3608: * Note that we create an import entry for the main schema as well; i.e.,
3609: * even if there's only one schema, we'll get an import.
3610: */
3611: if (mainSchema->schemasImports == NULL) {
3612: mainSchema->schemasImports = xmlHashCreateDict(5,
3613: WXS_CONSTRUCTOR(pctxt)->dict);
3614: if (mainSchema->schemasImports == NULL) {
3615: xmlSchemaBucketFree(ret);
3616: return(NULL);
3617: }
3618: }
3619: if (targetNamespace == NULL)
3620: res = xmlHashAddEntry(mainSchema->schemasImports,
3621: XML_SCHEMAS_NO_NAMESPACE, ret);
3622: else
3623: res = xmlHashAddEntry(mainSchema->schemasImports,
3624: targetNamespace, ret);
3625: if (res != 0) {
3626: PERROR_INT("xmlSchemaBucketCreate",
3627: "failed to add the schema bucket to the hash");
3628: xmlSchemaBucketFree(ret);
3629: return(NULL);
3630: }
3631: } else {
3632: /* Set the @ownerImport of an include bucket. */
3633: if (WXS_IS_BUCKET_IMPMAIN(WXS_CONSTRUCTOR(pctxt)->bucket->type))
3634: WXS_INCBUCKET(ret)->ownerImport =
3635: WXS_IMPBUCKET(WXS_CONSTRUCTOR(pctxt)->bucket);
3636: else
3637: WXS_INCBUCKET(ret)->ownerImport =
3638: WXS_INCBUCKET(WXS_CONSTRUCTOR(pctxt)->bucket)->ownerImport;
3639:
3640: /* Includes got into the "includes" slot of the *main* schema. */
3641: if (mainSchema->includes == NULL) {
3642: mainSchema->includes = xmlSchemaItemListCreate();
3643: if (mainSchema->includes == NULL) {
3644: xmlSchemaBucketFree(ret);
3645: return(NULL);
3646: }
3647: }
3648: xmlSchemaItemListAdd(mainSchema->includes, ret);
3649: }
3650: /*
3651: * Add to list of all buckets; this is used for lookup
3652: * during schema construction time only.
3653: */
3654: if (xmlSchemaItemListAdd(WXS_CONSTRUCTOR(pctxt)->buckets, ret) == -1)
3655: return(NULL);
3656: return(ret);
3657: }
3658:
3659: static int
3660: xmlSchemaAddItemSize(xmlSchemaItemListPtr *list, int initialSize, void *item)
3661: {
3662: if (*list == NULL) {
3663: *list = xmlSchemaItemListCreate();
3664: if (*list == NULL)
3665: return(-1);
3666: }
3667: xmlSchemaItemListAddSize(*list, initialSize, item);
3668: return(0);
3669: }
3670:
3671: /**
3672: * xmlSchemaFreeAnnot:
3673: * @annot: a schema type structure
3674: *
3675: * Deallocate a annotation structure
3676: */
3677: static void
3678: xmlSchemaFreeAnnot(xmlSchemaAnnotPtr annot)
3679: {
3680: if (annot == NULL)
3681: return;
3682: if (annot->next == NULL) {
3683: xmlFree(annot);
3684: } else {
3685: xmlSchemaAnnotPtr prev;
3686:
3687: do {
3688: prev = annot;
3689: annot = annot->next;
3690: xmlFree(prev);
3691: } while (annot != NULL);
3692: }
3693: }
3694:
3695: /**
3696: * xmlSchemaFreeNotation:
3697: * @schema: a schema notation structure
3698: *
3699: * Deallocate a Schema Notation structure.
3700: */
3701: static void
3702: xmlSchemaFreeNotation(xmlSchemaNotationPtr nota)
3703: {
3704: if (nota == NULL)
3705: return;
3706: xmlFree(nota);
3707: }
3708:
3709: /**
3710: * xmlSchemaFreeAttribute:
3711: * @attr: an attribute declaration
3712: *
3713: * Deallocates an attribute declaration structure.
3714: */
3715: static void
3716: xmlSchemaFreeAttribute(xmlSchemaAttributePtr attr)
3717: {
3718: if (attr == NULL)
3719: return;
3720: if (attr->annot != NULL)
3721: xmlSchemaFreeAnnot(attr->annot);
3722: if (attr->defVal != NULL)
3723: xmlSchemaFreeValue(attr->defVal);
3724: xmlFree(attr);
3725: }
3726:
3727: /**
3728: * xmlSchemaFreeAttributeUse:
3729: * @use: an attribute use
3730: *
3731: * Deallocates an attribute use structure.
3732: */
3733: static void
3734: xmlSchemaFreeAttributeUse(xmlSchemaAttributeUsePtr use)
3735: {
3736: if (use == NULL)
3737: return;
3738: if (use->annot != NULL)
3739: xmlSchemaFreeAnnot(use->annot);
3740: if (use->defVal != NULL)
3741: xmlSchemaFreeValue(use->defVal);
3742: xmlFree(use);
3743: }
3744:
3745: /**
3746: * xmlSchemaFreeAttributeUseProhib:
3747: * @prohib: an attribute use prohibition
3748: *
3749: * Deallocates an attribute use structure.
3750: */
3751: static void
3752: xmlSchemaFreeAttributeUseProhib(xmlSchemaAttributeUseProhibPtr prohib)
3753: {
3754: if (prohib == NULL)
3755: return;
3756: xmlFree(prohib);
3757: }
3758:
3759: /**
3760: * xmlSchemaFreeWildcardNsSet:
3761: * set: a schema wildcard namespace
3762: *
3763: * Deallocates a list of wildcard constraint structures.
3764: */
3765: static void
3766: xmlSchemaFreeWildcardNsSet(xmlSchemaWildcardNsPtr set)
3767: {
3768: xmlSchemaWildcardNsPtr next;
3769:
3770: while (set != NULL) {
3771: next = set->next;
3772: xmlFree(set);
3773: set = next;
3774: }
3775: }
3776:
3777: /**
3778: * xmlSchemaFreeWildcard:
3779: * @wildcard: a wildcard structure
3780: *
3781: * Deallocates a wildcard structure.
3782: */
3783: void
3784: xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard)
3785: {
3786: if (wildcard == NULL)
3787: return;
3788: if (wildcard->annot != NULL)
3789: xmlSchemaFreeAnnot(wildcard->annot);
3790: if (wildcard->nsSet != NULL)
3791: xmlSchemaFreeWildcardNsSet(wildcard->nsSet);
3792: if (wildcard->negNsSet != NULL)
3793: xmlFree(wildcard->negNsSet);
3794: xmlFree(wildcard);
3795: }
3796:
3797: /**
3798: * xmlSchemaFreeAttributeGroup:
3799: * @schema: a schema attribute group structure
3800: *
3801: * Deallocate a Schema Attribute Group structure.
3802: */
3803: static void
3804: xmlSchemaFreeAttributeGroup(xmlSchemaAttributeGroupPtr attrGr)
3805: {
3806: if (attrGr == NULL)
3807: return;
3808: if (attrGr->annot != NULL)
3809: xmlSchemaFreeAnnot(attrGr->annot);
3810: if (attrGr->attrUses != NULL)
3811: xmlSchemaItemListFree(WXS_LIST_CAST attrGr->attrUses);
3812: xmlFree(attrGr);
3813: }
3814:
3815: /**
3816: * xmlSchemaFreeQNameRef:
3817: * @item: a QName reference structure
3818: *
3819: * Deallocatea a QName reference structure.
3820: */
3821: static void
3822: xmlSchemaFreeQNameRef(xmlSchemaQNameRefPtr item)
3823: {
3824: xmlFree(item);
3825: }
3826:
3827: /**
3828: * xmlSchemaFreeTypeLinkList:
3829: * @alink: a type link
3830: *
3831: * Deallocate a list of types.
3832: */
3833: static void
3834: xmlSchemaFreeTypeLinkList(xmlSchemaTypeLinkPtr link)
3835: {
3836: xmlSchemaTypeLinkPtr next;
3837:
3838: while (link != NULL) {
3839: next = link->next;
3840: xmlFree(link);
3841: link = next;
3842: }
3843: }
3844:
3845: static void
3846: xmlSchemaFreeIDCStateObjList(xmlSchemaIDCStateObjPtr sto)
3847: {
3848: xmlSchemaIDCStateObjPtr next;
3849: while (sto != NULL) {
3850: next = sto->next;
3851: if (sto->history != NULL)
3852: xmlFree(sto->history);
3853: if (sto->xpathCtxt != NULL)
3854: xmlFreeStreamCtxt((xmlStreamCtxtPtr) sto->xpathCtxt);
3855: xmlFree(sto);
3856: sto = next;
3857: }
3858: }
3859:
3860: /**
3861: * xmlSchemaFreeIDC:
3862: * @idc: a identity-constraint definition
3863: *
3864: * Deallocates an identity-constraint definition.
3865: */
3866: static void
3867: xmlSchemaFreeIDC(xmlSchemaIDCPtr idcDef)
3868: {
3869: xmlSchemaIDCSelectPtr cur, prev;
3870:
3871: if (idcDef == NULL)
3872: return;
3873: if (idcDef->annot != NULL)
3874: xmlSchemaFreeAnnot(idcDef->annot);
3875: /* Selector */
3876: if (idcDef->selector != NULL) {
3877: if (idcDef->selector->xpathComp != NULL)
3878: xmlFreePattern((xmlPatternPtr) idcDef->selector->xpathComp);
3879: xmlFree(idcDef->selector);
3880: }
3881: /* Fields */
3882: if (idcDef->fields != NULL) {
3883: cur = idcDef->fields;
3884: do {
3885: prev = cur;
3886: cur = cur->next;
3887: if (prev->xpathComp != NULL)
3888: xmlFreePattern((xmlPatternPtr) prev->xpathComp);
3889: xmlFree(prev);
3890: } while (cur != NULL);
3891: }
3892: xmlFree(idcDef);
3893: }
3894:
3895: /**
3896: * xmlSchemaFreeElement:
3897: * @schema: a schema element structure
3898: *
3899: * Deallocate a Schema Element structure.
3900: */
3901: static void
3902: xmlSchemaFreeElement(xmlSchemaElementPtr elem)
3903: {
3904: if (elem == NULL)
3905: return;
3906: if (elem->annot != NULL)
3907: xmlSchemaFreeAnnot(elem->annot);
3908: if (elem->contModel != NULL)
3909: xmlRegFreeRegexp(elem->contModel);
3910: if (elem->defVal != NULL)
3911: xmlSchemaFreeValue(elem->defVal);
3912: xmlFree(elem);
3913: }
3914:
3915: /**
3916: * xmlSchemaFreeFacet:
3917: * @facet: a schema facet structure
3918: *
3919: * Deallocate a Schema Facet structure.
3920: */
3921: void
3922: xmlSchemaFreeFacet(xmlSchemaFacetPtr facet)
3923: {
3924: if (facet == NULL)
3925: return;
3926: if (facet->val != NULL)
3927: xmlSchemaFreeValue(facet->val);
3928: if (facet->regexp != NULL)
3929: xmlRegFreeRegexp(facet->regexp);
3930: if (facet->annot != NULL)
3931: xmlSchemaFreeAnnot(facet->annot);
3932: xmlFree(facet);
3933: }
3934:
3935: /**
3936: * xmlSchemaFreeType:
3937: * @type: a schema type structure
3938: *
3939: * Deallocate a Schema Type structure.
3940: */
3941: void
3942: xmlSchemaFreeType(xmlSchemaTypePtr type)
3943: {
3944: if (type == NULL)
3945: return;
3946: if (type->annot != NULL)
3947: xmlSchemaFreeAnnot(type->annot);
3948: if (type->facets != NULL) {
3949: xmlSchemaFacetPtr facet, next;
3950:
3951: facet = type->facets;
3952: while (facet != NULL) {
3953: next = facet->next;
3954: xmlSchemaFreeFacet(facet);
3955: facet = next;
3956: }
3957: }
3958: if (type->attrUses != NULL)
3959: xmlSchemaItemListFree((xmlSchemaItemListPtr) type->attrUses);
3960: if (type->memberTypes != NULL)
3961: xmlSchemaFreeTypeLinkList(type->memberTypes);
3962: if (type->facetSet != NULL) {
3963: xmlSchemaFacetLinkPtr next, link;
3964:
3965: link = type->facetSet;
3966: do {
3967: next = link->next;
3968: xmlFree(link);
3969: link = next;
3970: } while (link != NULL);
3971: }
3972: if (type->contModel != NULL)
3973: xmlRegFreeRegexp(type->contModel);
3974: xmlFree(type);
3975: }
3976:
3977: /**
3978: * xmlSchemaFreeModelGroupDef:
3979: * @item: a schema model group definition
3980: *
3981: * Deallocates a schema model group definition.
3982: */
3983: static void
3984: xmlSchemaFreeModelGroupDef(xmlSchemaModelGroupDefPtr item)
3985: {
3986: if (item->annot != NULL)
3987: xmlSchemaFreeAnnot(item->annot);
3988: xmlFree(item);
3989: }
3990:
3991: /**
3992: * xmlSchemaFreeModelGroup:
3993: * @item: a schema model group
3994: *
3995: * Deallocates a schema model group structure.
3996: */
3997: static void
3998: xmlSchemaFreeModelGroup(xmlSchemaModelGroupPtr item)
3999: {
4000: if (item->annot != NULL)
4001: xmlSchemaFreeAnnot(item->annot);
4002: xmlFree(item);
4003: }
4004:
4005: static void
4006: xmlSchemaComponentListFree(xmlSchemaItemListPtr list)
4007: {
4008: if ((list == NULL) || (list->nbItems == 0))
4009: return;
4010: {
4011: xmlSchemaTreeItemPtr item;
4012: xmlSchemaTreeItemPtr *items = (xmlSchemaTreeItemPtr *) list->items;
4013: int i;
4014:
4015: for (i = 0; i < list->nbItems; i++) {
4016: item = items[i];
4017: if (item == NULL)
4018: continue;
4019: switch (item->type) {
4020: case XML_SCHEMA_TYPE_SIMPLE:
4021: case XML_SCHEMA_TYPE_COMPLEX:
4022: xmlSchemaFreeType((xmlSchemaTypePtr) item);
4023: break;
4024: case XML_SCHEMA_TYPE_ATTRIBUTE:
4025: xmlSchemaFreeAttribute((xmlSchemaAttributePtr) item);
4026: break;
4027: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
4028: xmlSchemaFreeAttributeUse((xmlSchemaAttributeUsePtr) item);
4029: break;
4030: case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
4031: xmlSchemaFreeAttributeUseProhib(
4032: (xmlSchemaAttributeUseProhibPtr) item);
4033: break;
4034: case XML_SCHEMA_TYPE_ELEMENT:
4035: xmlSchemaFreeElement((xmlSchemaElementPtr) item);
4036: break;
4037: case XML_SCHEMA_TYPE_PARTICLE:
4038: if (item->annot != NULL)
4039: xmlSchemaFreeAnnot(item->annot);
4040: xmlFree(item);
4041: break;
4042: case XML_SCHEMA_TYPE_SEQUENCE:
4043: case XML_SCHEMA_TYPE_CHOICE:
4044: case XML_SCHEMA_TYPE_ALL:
4045: xmlSchemaFreeModelGroup((xmlSchemaModelGroupPtr) item);
4046: break;
4047: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
4048: xmlSchemaFreeAttributeGroup(
4049: (xmlSchemaAttributeGroupPtr) item);
4050: break;
4051: case XML_SCHEMA_TYPE_GROUP:
4052: xmlSchemaFreeModelGroupDef(
4053: (xmlSchemaModelGroupDefPtr) item);
4054: break;
4055: case XML_SCHEMA_TYPE_ANY:
4056: case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
4057: xmlSchemaFreeWildcard((xmlSchemaWildcardPtr) item);
4058: break;
4059: case XML_SCHEMA_TYPE_IDC_KEY:
4060: case XML_SCHEMA_TYPE_IDC_UNIQUE:
4061: case XML_SCHEMA_TYPE_IDC_KEYREF:
4062: xmlSchemaFreeIDC((xmlSchemaIDCPtr) item);
4063: break;
4064: case XML_SCHEMA_TYPE_NOTATION:
4065: xmlSchemaFreeNotation((xmlSchemaNotationPtr) item);
4066: break;
4067: case XML_SCHEMA_EXTRA_QNAMEREF:
4068: xmlSchemaFreeQNameRef((xmlSchemaQNameRefPtr) item);
4069: break;
4070: default: {
4071: /* TODO: This should never be hit. */
4072: xmlSchemaPSimpleInternalErr(NULL,
4073: "Internal error: xmlSchemaComponentListFree, "
4074: "unexpected component type '%s'\n",
4075: (const xmlChar *) WXS_ITEM_TYPE_NAME(item));
4076: }
4077: break;
4078: }
4079: }
4080: list->nbItems = 0;
4081: }
4082: }
4083:
4084: /**
4085: * xmlSchemaFree:
4086: * @schema: a schema structure
4087: *
4088: * Deallocate a Schema structure.
4089: */
4090: void
4091: xmlSchemaFree(xmlSchemaPtr schema)
4092: {
4093: if (schema == NULL)
4094: return;
4095: /* @volatiles is not used anymore :-/ */
4096: if (schema->volatiles != NULL)
4097: TODO
4098: /*
4099: * Note that those slots are not responsible for freeing
4100: * schema components anymore; this will now be done by
4101: * the schema buckets.
4102: */
4103: if (schema->notaDecl != NULL)
4104: xmlHashFree(schema->notaDecl, NULL);
4105: if (schema->attrDecl != NULL)
4106: xmlHashFree(schema->attrDecl, NULL);
4107: if (schema->attrgrpDecl != NULL)
4108: xmlHashFree(schema->attrgrpDecl, NULL);
4109: if (schema->elemDecl != NULL)
4110: xmlHashFree(schema->elemDecl, NULL);
4111: if (schema->typeDecl != NULL)
4112: xmlHashFree(schema->typeDecl, NULL);
4113: if (schema->groupDecl != NULL)
4114: xmlHashFree(schema->groupDecl, NULL);
4115: if (schema->idcDef != NULL)
4116: xmlHashFree(schema->idcDef, NULL);
4117:
4118: if (schema->schemasImports != NULL)
4119: xmlHashFree(schema->schemasImports,
4120: (xmlHashDeallocator) xmlSchemaBucketFree);
4121: if (schema->includes != NULL) {
4122: xmlSchemaItemListPtr list = (xmlSchemaItemListPtr) schema->includes;
4123: int i;
4124: for (i = 0; i < list->nbItems; i++) {
4125: xmlSchemaBucketFree((xmlSchemaBucketPtr) list->items[i]);
4126: }
4127: xmlSchemaItemListFree(list);
4128: }
4129: if (schema->annot != NULL)
4130: xmlSchemaFreeAnnot(schema->annot);
4131: /* Never free the doc here, since this will be done by the buckets. */
4132:
4133: xmlDictFree(schema->dict);
4134: xmlFree(schema);
4135: }
4136:
4137: /************************************************************************
4138: * *
4139: * Debug functions *
4140: * *
4141: ************************************************************************/
4142:
4143: #ifdef LIBXML_OUTPUT_ENABLED
4144:
4145: static void
4146: xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output); /* forward */
4147:
4148: /**
4149: * xmlSchemaElementDump:
4150: * @elem: an element
4151: * @output: the file output
4152: *
4153: * Dump the element
4154: */
4155: static void
4156: xmlSchemaElementDump(xmlSchemaElementPtr elem, FILE * output,
4157: const xmlChar * name ATTRIBUTE_UNUSED,
4158: const xmlChar * namespace ATTRIBUTE_UNUSED,
4159: const xmlChar * context ATTRIBUTE_UNUSED)
4160: {
4161: if (elem == NULL)
4162: return;
4163:
4164:
4165: fprintf(output, "Element");
4166: if (elem->flags & XML_SCHEMAS_ELEM_GLOBAL)
4167: fprintf(output, " (global)");
4168: fprintf(output, ": '%s' ", elem->name);
4169: if (namespace != NULL)
4170: fprintf(output, "ns '%s'", namespace);
4171: fprintf(output, "\n");
4172: #if 0
4173: if ((elem->minOccurs != 1) || (elem->maxOccurs != 1)) {
4174: fprintf(output, " min %d ", elem->minOccurs);
4175: if (elem->maxOccurs >= UNBOUNDED)
4176: fprintf(output, "max: unbounded\n");
4177: else if (elem->maxOccurs != 1)
4178: fprintf(output, "max: %d\n", elem->maxOccurs);
4179: else
4180: fprintf(output, "\n");
4181: }
4182: #endif
4183: /*
4184: * Misc other properties.
4185: */
4186: if ((elem->flags & XML_SCHEMAS_ELEM_NILLABLE) ||
4187: (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT) ||
4188: (elem->flags & XML_SCHEMAS_ELEM_FIXED) ||
4189: (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)) {
4190: fprintf(output, " props: ");
4191: if (elem->flags & XML_SCHEMAS_ELEM_FIXED)
4192: fprintf(output, "[fixed] ");
4193: if (elem->flags & XML_SCHEMAS_ELEM_DEFAULT)
4194: fprintf(output, "[default] ");
4195: if (elem->flags & XML_SCHEMAS_ELEM_ABSTRACT)
4196: fprintf(output, "[abstract] ");
4197: if (elem->flags & XML_SCHEMAS_ELEM_NILLABLE)
4198: fprintf(output, "[nillable] ");
4199: fprintf(output, "\n");
4200: }
4201: /*
4202: * Default/fixed value.
4203: */
4204: if (elem->value != NULL)
4205: fprintf(output, " value: '%s'\n", elem->value);
4206: /*
4207: * Type.
4208: */
4209: if (elem->namedType != NULL) {
4210: fprintf(output, " type: '%s' ", elem->namedType);
4211: if (elem->namedTypeNs != NULL)
4212: fprintf(output, "ns '%s'\n", elem->namedTypeNs);
4213: else
4214: fprintf(output, "\n");
4215: } else if (elem->subtypes != NULL) {
4216: /*
4217: * Dump local types.
4218: */
4219: xmlSchemaTypeDump(elem->subtypes, output);
4220: }
4221: /*
4222: * Substitution group.
4223: */
4224: if (elem->substGroup != NULL) {
4225: fprintf(output, " substitutionGroup: '%s' ", elem->substGroup);
4226: if (elem->substGroupNs != NULL)
4227: fprintf(output, "ns '%s'\n", elem->substGroupNs);
4228: else
4229: fprintf(output, "\n");
4230: }
4231: }
4232:
4233: /**
4234: * xmlSchemaAnnotDump:
4235: * @output: the file output
4236: * @annot: a annotation
4237: *
4238: * Dump the annotation
4239: */
4240: static void
4241: xmlSchemaAnnotDump(FILE * output, xmlSchemaAnnotPtr annot)
4242: {
4243: xmlChar *content;
4244:
4245: if (annot == NULL)
4246: return;
4247:
4248: content = xmlNodeGetContent(annot->content);
4249: if (content != NULL) {
4250: fprintf(output, " Annot: %s\n", content);
4251: xmlFree(content);
4252: } else
4253: fprintf(output, " Annot: empty\n");
4254: }
4255:
4256: /**
4257: * xmlSchemaContentModelDump:
4258: * @particle: the schema particle
4259: * @output: the file output
4260: * @depth: the depth used for intentation
4261: *
4262: * Dump a SchemaType structure
4263: */
4264: static void
4265: xmlSchemaContentModelDump(xmlSchemaParticlePtr particle, FILE * output, int depth)
4266: {
4267: xmlChar *str = NULL;
4268: xmlSchemaTreeItemPtr term;
4269: char shift[100];
4270: int i;
4271:
4272: if (particle == NULL)
4273: return;
4274: for (i = 0;((i < depth) && (i < 25));i++)
4275: shift[2 * i] = shift[2 * i + 1] = ' ';
4276: shift[2 * i] = shift[2 * i + 1] = 0;
4277: fprintf(output, "%s", shift);
4278: if (particle->children == NULL) {
4279: fprintf(output, "MISSING particle term\n");
4280: return;
4281: }
4282: term = particle->children;
4283: if (term == NULL) {
4284: fprintf(output, "(NULL)");
4285: } else {
4286: switch (term->type) {
4287: case XML_SCHEMA_TYPE_ELEMENT:
4288: fprintf(output, "ELEM '%s'", xmlSchemaFormatQName(&str,
4289: ((xmlSchemaElementPtr)term)->targetNamespace,
4290: ((xmlSchemaElementPtr)term)->name));
4291: FREE_AND_NULL(str);
4292: break;
4293: case XML_SCHEMA_TYPE_SEQUENCE:
4294: fprintf(output, "SEQUENCE");
4295: break;
4296: case XML_SCHEMA_TYPE_CHOICE:
4297: fprintf(output, "CHOICE");
4298: break;
4299: case XML_SCHEMA_TYPE_ALL:
4300: fprintf(output, "ALL");
4301: break;
4302: case XML_SCHEMA_TYPE_ANY:
4303: fprintf(output, "ANY");
4304: break;
4305: default:
4306: fprintf(output, "UNKNOWN\n");
4307: return;
4308: }
4309: }
4310: if (particle->minOccurs != 1)
4311: fprintf(output, " min: %d", particle->minOccurs);
4312: if (particle->maxOccurs >= UNBOUNDED)
4313: fprintf(output, " max: unbounded");
4314: else if (particle->maxOccurs != 1)
4315: fprintf(output, " max: %d", particle->maxOccurs);
4316: fprintf(output, "\n");
4317: if (term &&
4318: ((term->type == XML_SCHEMA_TYPE_SEQUENCE) ||
4319: (term->type == XML_SCHEMA_TYPE_CHOICE) ||
4320: (term->type == XML_SCHEMA_TYPE_ALL)) &&
4321: (term->children != NULL)) {
4322: xmlSchemaContentModelDump((xmlSchemaParticlePtr) term->children,
4323: output, depth +1);
4324: }
4325: if (particle->next != NULL)
4326: xmlSchemaContentModelDump((xmlSchemaParticlePtr) particle->next,
4327: output, depth);
4328: }
4329:
4330: /**
4331: * xmlSchemaAttrUsesDump:
4332: * @uses: attribute uses list
4333: * @output: the file output
4334: *
4335: * Dumps a list of attribute use components.
4336: */
4337: static void
4338: xmlSchemaAttrUsesDump(xmlSchemaItemListPtr uses, FILE * output)
4339: {
4340: xmlSchemaAttributeUsePtr use;
4341: xmlSchemaAttributeUseProhibPtr prohib;
4342: xmlSchemaQNameRefPtr ref;
4343: const xmlChar *name, *tns;
4344: xmlChar *str = NULL;
4345: int i;
4346:
4347: if ((uses == NULL) || (uses->nbItems == 0))
4348: return;
4349:
4350: fprintf(output, " attributes:\n");
4351: for (i = 0; i < uses->nbItems; i++) {
4352: use = uses->items[i];
4353: if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
4354: fprintf(output, " [prohibition] ");
4355: prohib = (xmlSchemaAttributeUseProhibPtr) use;
4356: name = prohib->name;
4357: tns = prohib->targetNamespace;
4358: } else if (use->type == XML_SCHEMA_EXTRA_QNAMEREF) {
4359: fprintf(output, " [reference] ");
4360: ref = (xmlSchemaQNameRefPtr) use;
4361: name = ref->name;
4362: tns = ref->targetNamespace;
4363: } else {
4364: fprintf(output, " [use] ");
4365: name = WXS_ATTRUSE_DECL_NAME(use);
4366: tns = WXS_ATTRUSE_DECL_TNS(use);
4367: }
4368: fprintf(output, "'%s'\n",
4369: (const char *) xmlSchemaFormatQName(&str, tns, name));
4370: FREE_AND_NULL(str);
4371: }
4372: }
4373:
4374: /**
4375: * xmlSchemaTypeDump:
4376: * @output: the file output
4377: * @type: a type structure
4378: *
4379: * Dump a SchemaType structure
4380: */
4381: static void
4382: xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output)
4383: {
4384: if (type == NULL) {
4385: fprintf(output, "Type: NULL\n");
4386: return;
4387: }
4388: fprintf(output, "Type: ");
4389: if (type->name != NULL)
4390: fprintf(output, "'%s' ", type->name);
4391: else
4392: fprintf(output, "(no name) ");
4393: if (type->targetNamespace != NULL)
4394: fprintf(output, "ns '%s' ", type->targetNamespace);
4395: switch (type->type) {
4396: case XML_SCHEMA_TYPE_BASIC:
4397: fprintf(output, "[basic] ");
4398: break;
4399: case XML_SCHEMA_TYPE_SIMPLE:
4400: fprintf(output, "[simple] ");
4401: break;
4402: case XML_SCHEMA_TYPE_COMPLEX:
4403: fprintf(output, "[complex] ");
4404: break;
4405: case XML_SCHEMA_TYPE_SEQUENCE:
4406: fprintf(output, "[sequence] ");
4407: break;
4408: case XML_SCHEMA_TYPE_CHOICE:
4409: fprintf(output, "[choice] ");
4410: break;
4411: case XML_SCHEMA_TYPE_ALL:
4412: fprintf(output, "[all] ");
4413: break;
4414: case XML_SCHEMA_TYPE_UR:
4415: fprintf(output, "[ur] ");
4416: break;
4417: case XML_SCHEMA_TYPE_RESTRICTION:
4418: fprintf(output, "[restriction] ");
4419: break;
4420: case XML_SCHEMA_TYPE_EXTENSION:
4421: fprintf(output, "[extension] ");
4422: break;
4423: default:
4424: fprintf(output, "[unknown type %d] ", type->type);
4425: break;
4426: }
4427: fprintf(output, "content: ");
4428: switch (type->contentType) {
4429: case XML_SCHEMA_CONTENT_UNKNOWN:
4430: fprintf(output, "[unknown] ");
4431: break;
4432: case XML_SCHEMA_CONTENT_EMPTY:
4433: fprintf(output, "[empty] ");
4434: break;
4435: case XML_SCHEMA_CONTENT_ELEMENTS:
4436: fprintf(output, "[element] ");
4437: break;
4438: case XML_SCHEMA_CONTENT_MIXED:
4439: fprintf(output, "[mixed] ");
4440: break;
4441: case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
4442: /* not used. */
4443: break;
4444: case XML_SCHEMA_CONTENT_BASIC:
4445: fprintf(output, "[basic] ");
4446: break;
4447: case XML_SCHEMA_CONTENT_SIMPLE:
4448: fprintf(output, "[simple] ");
4449: break;
4450: case XML_SCHEMA_CONTENT_ANY:
4451: fprintf(output, "[any] ");
4452: break;
4453: }
4454: fprintf(output, "\n");
4455: if (type->base != NULL) {
4456: fprintf(output, " base type: '%s'", type->base);
4457: if (type->baseNs != NULL)
4458: fprintf(output, " ns '%s'\n", type->baseNs);
4459: else
4460: fprintf(output, "\n");
4461: }
4462: if (type->attrUses != NULL)
4463: xmlSchemaAttrUsesDump(type->attrUses, output);
4464: if (type->annot != NULL)
4465: xmlSchemaAnnotDump(output, type->annot);
4466: #ifdef DUMP_CONTENT_MODEL
4467: if ((type->type == XML_SCHEMA_TYPE_COMPLEX) &&
4468: (type->subtypes != NULL)) {
4469: xmlSchemaContentModelDump((xmlSchemaParticlePtr) type->subtypes,
4470: output, 1);
4471: }
4472: #endif
4473: }
4474:
4475: /**
4476: * xmlSchemaDump:
4477: * @output: the file output
4478: * @schema: a schema structure
4479: *
4480: * Dump a Schema structure.
4481: */
4482: void
4483: xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
4484: {
4485: if (output == NULL)
4486: return;
4487: if (schema == NULL) {
4488: fprintf(output, "Schemas: NULL\n");
4489: return;
4490: }
4491: fprintf(output, "Schemas: ");
4492: if (schema->name != NULL)
4493: fprintf(output, "%s, ", schema->name);
4494: else
4495: fprintf(output, "no name, ");
4496: if (schema->targetNamespace != NULL)
4497: fprintf(output, "%s", (const char *) schema->targetNamespace);
4498: else
4499: fprintf(output, "no target namespace");
4500: fprintf(output, "\n");
4501: if (schema->annot != NULL)
4502: xmlSchemaAnnotDump(output, schema->annot);
4503: xmlHashScan(schema->typeDecl, (xmlHashScanner) xmlSchemaTypeDump,
4504: output);
4505: xmlHashScanFull(schema->elemDecl,
4506: (xmlHashScannerFull) xmlSchemaElementDump, output);
4507: }
4508:
4509: #ifdef DEBUG_IDC_NODE_TABLE
4510: /**
4511: * xmlSchemaDebugDumpIDCTable:
4512: * @vctxt: the WXS validation context
4513: *
4514: * Displays the current IDC table for debug purposes.
4515: */
4516: static void
4517: xmlSchemaDebugDumpIDCTable(FILE * output,
4518: const xmlChar *namespaceName,
4519: const xmlChar *localName,
4520: xmlSchemaPSVIIDCBindingPtr bind)
4521: {
4522: xmlChar *str = NULL;
4523: const xmlChar *value;
4524: xmlSchemaPSVIIDCNodePtr tab;
4525: xmlSchemaPSVIIDCKeyPtr key;
4526: int i, j, res;
4527:
4528: fprintf(output, "IDC: TABLES on '%s'\n",
4529: xmlSchemaFormatQName(&str, namespaceName, localName));
4530: FREE_AND_NULL(str)
4531:
4532: if (bind == NULL)
4533: return;
4534: do {
4535: fprintf(output, "IDC: BINDING '%s' (%d)\n",
4536: xmlSchemaGetComponentQName(&str,
4537: bind->definition), bind->nbNodes);
4538: FREE_AND_NULL(str)
4539: for (i = 0; i < bind->nbNodes; i++) {
4540: tab = bind->nodeTable[i];
4541: fprintf(output, " ( ");
4542: for (j = 0; j < bind->definition->nbFields; j++) {
4543: key = tab->keys[j];
4544: if ((key != NULL) && (key->val != NULL)) {
4545: res = xmlSchemaGetCanonValue(key->val, &value);
4546: if (res >= 0)
4547: fprintf(output, "'%s' ", value);
4548: else
4549: fprintf(output, "CANON-VALUE-FAILED ");
4550: if (res == 0)
4551: FREE_AND_NULL(value)
4552: } else if (key != NULL)
4553: fprintf(output, "(no val), ");
4554: else
4555: fprintf(output, "(key missing), ");
4556: }
4557: fprintf(output, ")\n");
4558: }
4559: if (bind->dupls && bind->dupls->nbItems) {
4560: fprintf(output, "IDC: dupls (%d):\n", bind->dupls->nbItems);
4561: for (i = 0; i < bind->dupls->nbItems; i++) {
4562: tab = bind->dupls->items[i];
4563: fprintf(output, " ( ");
4564: for (j = 0; j < bind->definition->nbFields; j++) {
4565: key = tab->keys[j];
4566: if ((key != NULL) && (key->val != NULL)) {
4567: res = xmlSchemaGetCanonValue(key->val, &value);
4568: if (res >= 0)
4569: fprintf(output, "'%s' ", value);
4570: else
4571: fprintf(output, "CANON-VALUE-FAILED ");
4572: if (res == 0)
4573: FREE_AND_NULL(value)
4574: } else if (key != NULL)
4575: fprintf(output, "(no val), ");
4576: else
4577: fprintf(output, "(key missing), ");
4578: }
4579: fprintf(output, ")\n");
4580: }
4581: }
4582: bind = bind->next;
4583: } while (bind != NULL);
4584: }
4585: #endif /* DEBUG_IDC */
4586: #endif /* LIBXML_OUTPUT_ENABLED */
4587:
4588: /************************************************************************
4589: * *
4590: * Utilities *
4591: * *
4592: ************************************************************************/
4593:
4594: /**
4595: * xmlSchemaGetPropNode:
4596: * @node: the element node
4597: * @name: the name of the attribute
4598: *
4599: * Seeks an attribute with a name of @name in
4600: * no namespace.
4601: *
4602: * Returns the attribute or NULL if not present.
4603: */
4604: static xmlAttrPtr
4605: xmlSchemaGetPropNode(xmlNodePtr node, const char *name)
4606: {
4607: xmlAttrPtr prop;
4608:
4609: if ((node == NULL) || (name == NULL))
4610: return(NULL);
4611: prop = node->properties;
4612: while (prop != NULL) {
4613: if ((prop->ns == NULL) && xmlStrEqual(prop->name, BAD_CAST name))
4614: return(prop);
4615: prop = prop->next;
4616: }
4617: return (NULL);
4618: }
4619:
4620: /**
4621: * xmlSchemaGetPropNodeNs:
4622: * @node: the element node
4623: * @uri: the uri
4624: * @name: the name of the attribute
4625: *
4626: * Seeks an attribute with a local name of @name and
4627: * a namespace URI of @uri.
4628: *
4629: * Returns the attribute or NULL if not present.
4630: */
4631: static xmlAttrPtr
4632: xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
4633: {
4634: xmlAttrPtr prop;
4635:
4636: if ((node == NULL) || (name == NULL))
4637: return(NULL);
4638: prop = node->properties;
4639: while (prop != NULL) {
4640: if ((prop->ns != NULL) &&
4641: xmlStrEqual(prop->name, BAD_CAST name) &&
4642: xmlStrEqual(prop->ns->href, BAD_CAST uri))
4643: return(prop);
4644: prop = prop->next;
4645: }
4646: return (NULL);
4647: }
4648:
4649: static const xmlChar *
4650: xmlSchemaGetNodeContent(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
4651: {
4652: xmlChar *val;
4653: const xmlChar *ret;
4654:
4655: val = xmlNodeGetContent(node);
4656: if (val == NULL)
4657: val = xmlStrdup((xmlChar *)"");
4658: ret = xmlDictLookup(ctxt->dict, val, -1);
4659: xmlFree(val);
4660: return(ret);
4661: }
4662:
4663: static const xmlChar *
4664: xmlSchemaGetNodeContentNoDict(xmlNodePtr node)
4665: {
4666: return((const xmlChar*) xmlNodeGetContent(node));
4667: }
4668:
4669: /**
4670: * xmlSchemaGetProp:
4671: * @ctxt: the parser context
4672: * @node: the node
4673: * @name: the property name
4674: *
4675: * Read a attribute value and internalize the string
4676: *
4677: * Returns the string or NULL if not present.
4678: */
4679: static const xmlChar *
4680: xmlSchemaGetProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
4681: const char *name)
4682: {
4683: xmlChar *val;
4684: const xmlChar *ret;
4685:
4686: val = xmlGetNoNsProp(node, BAD_CAST name);
4687: if (val == NULL)
4688: return(NULL);
4689: ret = xmlDictLookup(ctxt->dict, val, -1);
4690: xmlFree(val);
4691: return(ret);
4692: }
4693:
4694: /************************************************************************
4695: * *
4696: * Parsing functions *
4697: * *
4698: ************************************************************************/
4699:
4700: #define WXS_FIND_GLOBAL_ITEM(slot) \
4701: if (xmlStrEqual(nsName, schema->targetNamespace)) { \
4702: ret = xmlHashLookup(schema->slot, name); \
4703: if (ret != NULL) goto exit; \
4704: } \
4705: if (xmlHashSize(schema->schemasImports) > 1) { \
4706: xmlSchemaImportPtr import; \
4707: if (nsName == NULL) \
4708: import = xmlHashLookup(schema->schemasImports, \
4709: XML_SCHEMAS_NO_NAMESPACE); \
4710: else \
4711: import = xmlHashLookup(schema->schemasImports, nsName); \
4712: if (import == NULL) \
4713: goto exit; \
4714: ret = xmlHashLookup(import->schema->slot, name); \
4715: }
4716:
4717: /**
4718: * xmlSchemaGetElem:
4719: * @schema: the schema context
4720: * @name: the element name
4721: * @ns: the element namespace
4722: *
4723: * Lookup a global element declaration in the schema.
4724: *
4725: * Returns the element declaration or NULL if not found.
4726: */
4727: static xmlSchemaElementPtr
4728: xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
4729: const xmlChar * nsName)
4730: {
4731: xmlSchemaElementPtr ret = NULL;
4732:
4733: if ((name == NULL) || (schema == NULL))
4734: return(NULL);
4735: if (schema != NULL) {
4736: WXS_FIND_GLOBAL_ITEM(elemDecl)
4737: }
4738: exit:
4739: #ifdef DEBUG
4740: if (ret == NULL) {
4741: if (nsName == NULL)
4742: fprintf(stderr, "Unable to lookup element decl. %s", name);
4743: else
4744: fprintf(stderr, "Unable to lookup element decl. %s:%s", name,
4745: nsName);
4746: }
4747: #endif
4748: return (ret);
4749: }
4750:
4751: /**
4752: * xmlSchemaGetType:
4753: * @schema: the main schema
4754: * @name: the type's name
4755: * nsName: the type's namespace
4756: *
4757: * Lookup a type in the schemas or the predefined types
4758: *
4759: * Returns the group definition or NULL if not found.
4760: */
4761: static xmlSchemaTypePtr
4762: xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
4763: const xmlChar * nsName)
4764: {
4765: xmlSchemaTypePtr ret = NULL;
4766:
4767: if (name == NULL)
4768: return (NULL);
4769: /* First try the built-in types. */
4770: if ((nsName != NULL) && xmlStrEqual(nsName, xmlSchemaNs)) {
4771: ret = xmlSchemaGetPredefinedType(name, nsName);
4772: if (ret != NULL)
4773: goto exit;
4774: /*
4775: * Note that we try the parsed schemas as well here
4776: * since one might have parsed the S4S, which contain more
4777: * than the built-in types.
4778: * TODO: Can we optimize this?
4779: */
4780: }
4781: if (schema != NULL) {
4782: WXS_FIND_GLOBAL_ITEM(typeDecl)
4783: }
4784: exit:
4785:
4786: #ifdef DEBUG
4787: if (ret == NULL) {
4788: if (nsName == NULL)
4789: fprintf(stderr, "Unable to lookup type %s", name);
4790: else
4791: fprintf(stderr, "Unable to lookup type %s:%s", name,
4792: nsName);
4793: }
4794: #endif
4795: return (ret);
4796: }
4797:
4798: /**
4799: * xmlSchemaGetAttributeDecl:
4800: * @schema: the context of the schema
4801: * @name: the name of the attribute
4802: * @ns: the target namespace of the attribute
4803: *
4804: * Lookup a an attribute in the schema or imported schemas
4805: *
4806: * Returns the attribute declaration or NULL if not found.
4807: */
4808: static xmlSchemaAttributePtr
4809: xmlSchemaGetAttributeDecl(xmlSchemaPtr schema, const xmlChar * name,
4810: const xmlChar * nsName)
4811: {
4812: xmlSchemaAttributePtr ret = NULL;
4813:
4814: if ((name == NULL) || (schema == NULL))
4815: return (NULL);
4816: if (schema != NULL) {
4817: WXS_FIND_GLOBAL_ITEM(attrDecl)
4818: }
4819: exit:
4820: #ifdef DEBUG
4821: if (ret == NULL) {
4822: if (nsName == NULL)
4823: fprintf(stderr, "Unable to lookup attribute %s", name);
4824: else
4825: fprintf(stderr, "Unable to lookup attribute %s:%s", name,
4826: nsName);
4827: }
4828: #endif
4829: return (ret);
4830: }
4831:
4832: /**
4833: * xmlSchemaGetAttributeGroup:
4834: * @schema: the context of the schema
4835: * @name: the name of the attribute group
4836: * @ns: the target namespace of the attribute group
4837: *
4838: * Lookup a an attribute group in the schema or imported schemas
4839: *
4840: * Returns the attribute group definition or NULL if not found.
4841: */
4842: static xmlSchemaAttributeGroupPtr
4843: xmlSchemaGetAttributeGroup(xmlSchemaPtr schema, const xmlChar * name,
4844: const xmlChar * nsName)
4845: {
4846: xmlSchemaAttributeGroupPtr ret = NULL;
4847:
4848: if ((name == NULL) || (schema == NULL))
4849: return (NULL);
4850: if (schema != NULL) {
4851: WXS_FIND_GLOBAL_ITEM(attrgrpDecl)
4852: }
4853: exit:
4854: /* TODO:
4855: if ((ret != NULL) && (ret->redef != NULL)) {
4856: * Return the last redefinition. *
4857: ret = ret->redef;
4858: }
4859: */
4860: #ifdef DEBUG
4861: if (ret == NULL) {
4862: if (nsName == NULL)
4863: fprintf(stderr, "Unable to lookup attribute group %s", name);
4864: else
4865: fprintf(stderr, "Unable to lookup attribute group %s:%s", name,
4866: nsName);
4867: }
4868: #endif
4869: return (ret);
4870: }
4871:
4872: /**
4873: * xmlSchemaGetGroup:
4874: * @schema: the context of the schema
4875: * @name: the name of the group
4876: * @ns: the target namespace of the group
4877: *
4878: * Lookup a group in the schema or imported schemas
4879: *
4880: * Returns the group definition or NULL if not found.
4881: */
4882: static xmlSchemaModelGroupDefPtr
4883: xmlSchemaGetGroup(xmlSchemaPtr schema, const xmlChar * name,
4884: const xmlChar * nsName)
4885: {
4886: xmlSchemaModelGroupDefPtr ret = NULL;
4887:
4888: if ((name == NULL) || (schema == NULL))
4889: return (NULL);
4890: if (schema != NULL) {
4891: WXS_FIND_GLOBAL_ITEM(groupDecl)
4892: }
4893: exit:
4894:
4895: #ifdef DEBUG
4896: if (ret == NULL) {
4897: if (nsName == NULL)
4898: fprintf(stderr, "Unable to lookup group %s", name);
4899: else
4900: fprintf(stderr, "Unable to lookup group %s:%s", name,
4901: nsName);
4902: }
4903: #endif
4904: return (ret);
4905: }
4906:
4907: static xmlSchemaNotationPtr
4908: xmlSchemaGetNotation(xmlSchemaPtr schema,
4909: const xmlChar *name,
4910: const xmlChar *nsName)
4911: {
4912: xmlSchemaNotationPtr ret = NULL;
4913:
4914: if ((name == NULL) || (schema == NULL))
4915: return (NULL);
4916: if (schema != NULL) {
4917: WXS_FIND_GLOBAL_ITEM(notaDecl)
4918: }
4919: exit:
4920: return (ret);
4921: }
4922:
4923: static xmlSchemaIDCPtr
4924: xmlSchemaGetIDC(xmlSchemaPtr schema,
4925: const xmlChar *name,
4926: const xmlChar *nsName)
4927: {
4928: xmlSchemaIDCPtr ret = NULL;
4929:
4930: if ((name == NULL) || (schema == NULL))
4931: return (NULL);
4932: if (schema != NULL) {
4933: WXS_FIND_GLOBAL_ITEM(idcDef)
4934: }
4935: exit:
4936: return (ret);
4937: }
4938:
4939: /**
4940: * xmlSchemaGetNamedComponent:
4941: * @schema: the schema
4942: * @name: the name of the group
4943: * @ns: the target namespace of the group
4944: *
4945: * Lookup a group in the schema or imported schemas
4946: *
4947: * Returns the group definition or NULL if not found.
4948: */
4949: static xmlSchemaBasicItemPtr
4950: xmlSchemaGetNamedComponent(xmlSchemaPtr schema,
4951: xmlSchemaTypeType itemType,
4952: const xmlChar *name,
4953: const xmlChar *targetNs)
4954: {
4955: switch (itemType) {
4956: case XML_SCHEMA_TYPE_GROUP:
4957: return ((xmlSchemaBasicItemPtr) xmlSchemaGetGroup(schema,
4958: name, targetNs));
4959: case XML_SCHEMA_TYPE_ELEMENT:
4960: return ((xmlSchemaBasicItemPtr) xmlSchemaGetElem(schema,
4961: name, targetNs));
4962: default:
4963: TODO
4964: return (NULL);
4965: }
4966: }
4967:
4968: /************************************************************************
4969: * *
4970: * Parsing functions *
4971: * *
4972: ************************************************************************/
4973:
4974: #define IS_BLANK_NODE(n) \
4975: (((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content, -1)))
4976:
4977: /**
4978: * xmlSchemaIsBlank:
4979: * @str: a string
4980: * @len: the length of the string or -1
4981: *
4982: * Check if a string is ignorable
4983: *
4984: * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
4985: */
4986: static int
4987: xmlSchemaIsBlank(xmlChar * str, int len)
4988: {
4989: if (str == NULL)
4990: return (1);
4991: if (len < 0) {
4992: while (*str != 0) {
4993: if (!(IS_BLANK_CH(*str)))
4994: return (0);
4995: str++;
4996: }
4997: } else while ((*str != 0) && (len != 0)) {
4998: if (!(IS_BLANK_CH(*str)))
4999: return (0);
5000: str++;
5001: len--;
5002: }
5003:
5004: return (1);
5005: }
5006:
5007: #define WXS_COMP_NAME(c, t) ((t) (c))->name
5008: #define WXS_COMP_TNS(c, t) ((t) (c))->targetNamespace
5009: /*
5010: * xmlSchemaFindRedefCompInGraph:
5011: * ATTENTION TODO: This uses pointer comp. for strings.
5012: */
5013: static xmlSchemaBasicItemPtr
5014: xmlSchemaFindRedefCompInGraph(xmlSchemaBucketPtr bucket,
5015: xmlSchemaTypeType type,
5016: const xmlChar *name,
5017: const xmlChar *nsName)
5018: {
5019: xmlSchemaBasicItemPtr ret;
5020: int i;
5021:
5022: if ((bucket == NULL) || (name == NULL))
5023: return(NULL);
5024: if ((bucket->globals == NULL) ||
5025: (bucket->globals->nbItems == 0))
5026: goto subschemas;
5027: /*
5028: * Search in global components.
5029: */
5030: for (i = 0; i < bucket->globals->nbItems; i++) {
5031: ret = bucket->globals->items[i];
5032: if (ret->type == type) {
5033: switch (type) {
5034: case XML_SCHEMA_TYPE_COMPLEX:
5035: case XML_SCHEMA_TYPE_SIMPLE:
5036: if ((WXS_COMP_NAME(ret, xmlSchemaTypePtr) == name) &&
5037: (WXS_COMP_TNS(ret, xmlSchemaTypePtr) ==
5038: nsName))
5039: {
5040: return(ret);
5041: }
5042: break;
5043: case XML_SCHEMA_TYPE_GROUP:
5044: if ((WXS_COMP_NAME(ret,
5045: xmlSchemaModelGroupDefPtr) == name) &&
5046: (WXS_COMP_TNS(ret,
5047: xmlSchemaModelGroupDefPtr) == nsName))
5048: {
5049: return(ret);
5050: }
5051: break;
5052: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
5053: if ((WXS_COMP_NAME(ret,
5054: xmlSchemaAttributeGroupPtr) == name) &&
5055: (WXS_COMP_TNS(ret,
5056: xmlSchemaAttributeGroupPtr) == nsName))
5057: {
5058: return(ret);
5059: }
5060: break;
5061: default:
5062: /* Should not be hit. */
5063: return(NULL);
5064: }
5065: }
5066: }
5067: subschemas:
5068: /*
5069: * Process imported/included schemas.
5070: */
5071: if (bucket->relations != NULL) {
5072: xmlSchemaSchemaRelationPtr rel = bucket->relations;
5073:
5074: /*
5075: * TODO: Marking the bucket will not avoid multiple searches
5076: * in the same schema, but avoids at least circularity.
5077: */
5078: bucket->flags |= XML_SCHEMA_BUCKET_MARKED;
5079: do {
5080: if ((rel->bucket != NULL) &&
5081: ((rel->bucket->flags & XML_SCHEMA_BUCKET_MARKED) == 0)) {
5082: ret = xmlSchemaFindRedefCompInGraph(rel->bucket,
5083: type, name, nsName);
5084: if (ret != NULL)
5085: return(ret);
5086: }
5087: rel = rel->next;
5088: } while (rel != NULL);
5089: bucket->flags ^= XML_SCHEMA_BUCKET_MARKED;
5090: }
5091: return(NULL);
5092: }
5093:
5094: /**
5095: * xmlSchemaAddNotation:
5096: * @ctxt: a schema parser context
5097: * @schema: the schema being built
5098: * @name: the item name
5099: *
5100: * Add an XML schema annotation declaration
5101: * *WARNING* this interface is highly subject to change
5102: *
5103: * Returns the new struture or NULL in case of error
5104: */
5105: static xmlSchemaNotationPtr
5106: xmlSchemaAddNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
5107: const xmlChar *name, const xmlChar *nsName,
5108: xmlNodePtr node ATTRIBUTE_UNUSED)
5109: {
5110: xmlSchemaNotationPtr ret = NULL;
5111:
5112: if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5113: return (NULL);
5114:
5115: ret = (xmlSchemaNotationPtr) xmlMalloc(sizeof(xmlSchemaNotation));
5116: if (ret == NULL) {
5117: xmlSchemaPErrMemory(ctxt, "add annotation", NULL);
5118: return (NULL);
5119: }
5120: memset(ret, 0, sizeof(xmlSchemaNotation));
5121: ret->type = XML_SCHEMA_TYPE_NOTATION;
5122: ret->name = name;
5123: ret->targetNamespace = nsName;
5124: /* TODO: do we need the node to be set?
5125: * ret->node = node;*/
5126: WXS_ADD_GLOBAL(ctxt, ret);
5127: return (ret);
5128: }
5129:
5130: /**
5131: * xmlSchemaAddAttribute:
5132: * @ctxt: a schema parser context
5133: * @schema: the schema being built
5134: * @name: the item name
5135: * @namespace: the namespace
5136: *
5137: * Add an XML schema Attrribute declaration
5138: * *WARNING* this interface is highly subject to change
5139: *
5140: * Returns the new struture or NULL in case of error
5141: */
5142: static xmlSchemaAttributePtr
5143: xmlSchemaAddAttribute(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
5144: const xmlChar * name, const xmlChar * nsName,
5145: xmlNodePtr node, int topLevel)
5146: {
5147: xmlSchemaAttributePtr ret = NULL;
5148:
5149: if ((ctxt == NULL) || (schema == NULL))
5150: return (NULL);
5151:
5152: ret = (xmlSchemaAttributePtr) xmlMalloc(sizeof(xmlSchemaAttribute));
5153: if (ret == NULL) {
5154: xmlSchemaPErrMemory(ctxt, "allocating attribute", NULL);
5155: return (NULL);
5156: }
5157: memset(ret, 0, sizeof(xmlSchemaAttribute));
5158: ret->type = XML_SCHEMA_TYPE_ATTRIBUTE;
5159: ret->node = node;
5160: ret->name = name;
5161: ret->targetNamespace = nsName;
5162:
5163: if (topLevel)
5164: WXS_ADD_GLOBAL(ctxt, ret);
5165: else
5166: WXS_ADD_LOCAL(ctxt, ret);
5167: WXS_ADD_PENDING(ctxt, ret);
5168: return (ret);
5169: }
5170:
5171: /**
5172: * xmlSchemaAddAttributeUse:
5173: * @ctxt: a schema parser context
5174: * @schema: the schema being built
5175: * @name: the item name
5176: * @namespace: the namespace
5177: *
5178: * Add an XML schema Attrribute declaration
5179: * *WARNING* this interface is highly subject to change
5180: *
5181: * Returns the new struture or NULL in case of error
5182: */
5183: static xmlSchemaAttributeUsePtr
5184: xmlSchemaAddAttributeUse(xmlSchemaParserCtxtPtr pctxt,
5185: xmlNodePtr node)
5186: {
5187: xmlSchemaAttributeUsePtr ret = NULL;
5188:
5189: if (pctxt == NULL)
5190: return (NULL);
5191:
5192: ret = (xmlSchemaAttributeUsePtr) xmlMalloc(sizeof(xmlSchemaAttributeUse));
5193: if (ret == NULL) {
5194: xmlSchemaPErrMemory(pctxt, "allocating attribute", NULL);
5195: return (NULL);
5196: }
5197: memset(ret, 0, sizeof(xmlSchemaAttributeUse));
5198: ret->type = XML_SCHEMA_TYPE_ATTRIBUTE_USE;
5199: ret->node = node;
5200:
5201: WXS_ADD_LOCAL(pctxt, ret);
5202: return (ret);
5203: }
5204:
5205: /*
5206: * xmlSchemaAddRedef:
5207: *
5208: * Adds a redefinition information. This is used at a later stage to:
5209: * resolve references to the redefined components and to check constraints.
5210: */
5211: static xmlSchemaRedefPtr
5212: xmlSchemaAddRedef(xmlSchemaParserCtxtPtr pctxt,
5213: xmlSchemaBucketPtr targetBucket,
5214: void *item,
5215: const xmlChar *refName,
5216: const xmlChar *refTargetNs)
5217: {
5218: xmlSchemaRedefPtr ret;
5219:
5220: ret = (xmlSchemaRedefPtr)
5221: xmlMalloc(sizeof(xmlSchemaRedef));
5222: if (ret == NULL) {
5223: xmlSchemaPErrMemory(pctxt,
5224: "allocating redefinition info", NULL);
5225: return (NULL);
5226: }
5227: memset(ret, 0, sizeof(xmlSchemaRedef));
5228: ret->item = item;
5229: ret->targetBucket = targetBucket;
5230: ret->refName = refName;
5231: ret->refTargetNs = refTargetNs;
5232: if (WXS_CONSTRUCTOR(pctxt)->redefs == NULL)
5233: WXS_CONSTRUCTOR(pctxt)->redefs = ret;
5234: else
5235: WXS_CONSTRUCTOR(pctxt)->lastRedef->next = ret;
5236: WXS_CONSTRUCTOR(pctxt)->lastRedef = ret;
5237:
5238: return (ret);
5239: }
5240:
5241: /**
5242: * xmlSchemaAddAttributeGroupDefinition:
5243: * @ctxt: a schema parser context
5244: * @schema: the schema being built
5245: * @name: the item name
5246: * @nsName: the target namespace
5247: * @node: the corresponding node
5248: *
5249: * Add an XML schema Attrribute Group definition.
5250: *
5251: * Returns the new struture or NULL in case of error
5252: */
5253: static xmlSchemaAttributeGroupPtr
5254: xmlSchemaAddAttributeGroupDefinition(xmlSchemaParserCtxtPtr pctxt,
5255: xmlSchemaPtr schema ATTRIBUTE_UNUSED,
5256: const xmlChar *name,
5257: const xmlChar *nsName,
5258: xmlNodePtr node)
5259: {
5260: xmlSchemaAttributeGroupPtr ret = NULL;
5261:
5262: if ((pctxt == NULL) || (name == NULL))
5263: return (NULL);
5264:
5265: ret = (xmlSchemaAttributeGroupPtr)
5266: xmlMalloc(sizeof(xmlSchemaAttributeGroup));
5267: if (ret == NULL) {
5268: xmlSchemaPErrMemory(pctxt, "allocating attribute group", NULL);
5269: return (NULL);
5270: }
5271: memset(ret, 0, sizeof(xmlSchemaAttributeGroup));
5272: ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
5273: ret->name = name;
5274: ret->targetNamespace = nsName;
5275: ret->node = node;
5276:
5277: /* TODO: Remove the flag. */
5278: ret->flags |= XML_SCHEMAS_ATTRGROUP_GLOBAL;
5279: if (pctxt->isRedefine) {
5280: pctxt->redef = xmlSchemaAddRedef(pctxt, pctxt->redefined,
5281: ret, name, nsName);
5282: if (pctxt->redef == NULL) {
5283: xmlFree(ret);
5284: return(NULL);
5285: }
5286: pctxt->redefCounter = 0;
5287: }
5288: WXS_ADD_GLOBAL(pctxt, ret);
5289: WXS_ADD_PENDING(pctxt, ret);
5290: return (ret);
5291: }
5292:
5293: /**
5294: * xmlSchemaAddElement:
5295: * @ctxt: a schema parser context
5296: * @schema: the schema being built
5297: * @name: the type name
5298: * @namespace: the type namespace
5299: *
5300: * Add an XML schema Element declaration
5301: * *WARNING* this interface is highly subject to change
5302: *
5303: * Returns the new struture or NULL in case of error
5304: */
5305: static xmlSchemaElementPtr
5306: xmlSchemaAddElement(xmlSchemaParserCtxtPtr ctxt,
5307: const xmlChar * name, const xmlChar * nsName,
5308: xmlNodePtr node, int topLevel)
5309: {
5310: xmlSchemaElementPtr ret = NULL;
5311:
5312: if ((ctxt == NULL) || (name == NULL))
5313: return (NULL);
5314:
5315: ret = (xmlSchemaElementPtr) xmlMalloc(sizeof(xmlSchemaElement));
5316: if (ret == NULL) {
5317: xmlSchemaPErrMemory(ctxt, "allocating element", NULL);
5318: return (NULL);
5319: }
5320: memset(ret, 0, sizeof(xmlSchemaElement));
5321: ret->type = XML_SCHEMA_TYPE_ELEMENT;
5322: ret->name = name;
5323: ret->targetNamespace = nsName;
5324: ret->node = node;
5325:
5326: if (topLevel)
5327: WXS_ADD_GLOBAL(ctxt, ret);
5328: else
5329: WXS_ADD_LOCAL(ctxt, ret);
5330: WXS_ADD_PENDING(ctxt, ret);
5331: return (ret);
5332: }
5333:
5334: /**
5335: * xmlSchemaAddType:
5336: * @ctxt: a schema parser context
5337: * @schema: the schema being built
5338: * @name: the item name
5339: * @namespace: the namespace
5340: *
5341: * Add an XML schema item
5342: * *WARNING* this interface is highly subject to change
5343: *
5344: * Returns the new struture or NULL in case of error
5345: */
5346: static xmlSchemaTypePtr
5347: xmlSchemaAddType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
5348: xmlSchemaTypeType type,
5349: const xmlChar * name, const xmlChar * nsName,
5350: xmlNodePtr node, int topLevel)
5351: {
5352: xmlSchemaTypePtr ret = NULL;
5353:
5354: if ((ctxt == NULL) || (schema == NULL))
5355: return (NULL);
5356:
5357: ret = (xmlSchemaTypePtr) xmlMalloc(sizeof(xmlSchemaType));
5358: if (ret == NULL) {
5359: xmlSchemaPErrMemory(ctxt, "allocating type", NULL);
5360: return (NULL);
5361: }
5362: memset(ret, 0, sizeof(xmlSchemaType));
5363: ret->type = type;
5364: ret->name = name;
5365: ret->targetNamespace = nsName;
5366: ret->node = node;
5367: if (topLevel) {
5368: if (ctxt->isRedefine) {
5369: ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
5370: ret, name, nsName);
5371: if (ctxt->redef == NULL) {
5372: xmlFree(ret);
5373: return(NULL);
5374: }
5375: ctxt->redefCounter = 0;
5376: }
5377: WXS_ADD_GLOBAL(ctxt, ret);
5378: } else
5379: WXS_ADD_LOCAL(ctxt, ret);
5380: WXS_ADD_PENDING(ctxt, ret);
5381: return (ret);
5382: }
5383:
5384: static xmlSchemaQNameRefPtr
5385: xmlSchemaNewQNameRef(xmlSchemaParserCtxtPtr pctxt,
5386: xmlSchemaTypeType refType,
5387: const xmlChar *refName,
5388: const xmlChar *refNs)
5389: {
5390: xmlSchemaQNameRefPtr ret;
5391:
5392: ret = (xmlSchemaQNameRefPtr)
5393: xmlMalloc(sizeof(xmlSchemaQNameRef));
5394: if (ret == NULL) {
5395: xmlSchemaPErrMemory(pctxt,
5396: "allocating QName reference item", NULL);
5397: return (NULL);
5398: }
5399: ret->node = NULL;
5400: ret->type = XML_SCHEMA_EXTRA_QNAMEREF;
5401: ret->name = refName;
5402: ret->targetNamespace = refNs;
5403: ret->item = NULL;
5404: ret->itemType = refType;
5405: /*
5406: * Store the reference item in the schema.
5407: */
5408: WXS_ADD_LOCAL(pctxt, ret);
5409: return (ret);
5410: }
5411:
5412: static xmlSchemaAttributeUseProhibPtr
5413: xmlSchemaAddAttributeUseProhib(xmlSchemaParserCtxtPtr pctxt)
5414: {
5415: xmlSchemaAttributeUseProhibPtr ret;
5416:
5417: ret = (xmlSchemaAttributeUseProhibPtr)
5418: xmlMalloc(sizeof(xmlSchemaAttributeUseProhib));
5419: if (ret == NULL) {
5420: xmlSchemaPErrMemory(pctxt,
5421: "allocating attribute use prohibition", NULL);
5422: return (NULL);
5423: }
5424: memset(ret, 0, sizeof(xmlSchemaAttributeUseProhib));
5425: ret->type = XML_SCHEMA_EXTRA_ATTR_USE_PROHIB;
5426: WXS_ADD_LOCAL(pctxt, ret);
5427: return (ret);
5428: }
5429:
5430:
5431: /**
5432: * xmlSchemaAddModelGroup:
5433: * @ctxt: a schema parser context
5434: * @schema: the schema being built
5435: * @type: the "compositor" type of the model group
5436: * @node: the node in the schema doc
5437: *
5438: * Adds a schema model group
5439: * *WARNING* this interface is highly subject to change
5440: *
5441: * Returns the new struture or NULL in case of error
5442: */
5443: static xmlSchemaModelGroupPtr
5444: xmlSchemaAddModelGroup(xmlSchemaParserCtxtPtr ctxt,
5445: xmlSchemaPtr schema,
5446: xmlSchemaTypeType type,
5447: xmlNodePtr node)
5448: {
5449: xmlSchemaModelGroupPtr ret = NULL;
5450:
5451: if ((ctxt == NULL) || (schema == NULL))
5452: return (NULL);
5453:
5454: ret = (xmlSchemaModelGroupPtr)
5455: xmlMalloc(sizeof(xmlSchemaModelGroup));
5456: if (ret == NULL) {
5457: xmlSchemaPErrMemory(ctxt, "allocating model group component",
5458: NULL);
5459: return (NULL);
5460: }
5461: memset(ret, 0, sizeof(xmlSchemaModelGroup));
5462: ret->type = type;
5463: ret->node = node;
5464: WXS_ADD_LOCAL(ctxt, ret);
5465: if ((type == XML_SCHEMA_TYPE_SEQUENCE) ||
5466: (type == XML_SCHEMA_TYPE_CHOICE))
5467: WXS_ADD_PENDING(ctxt, ret);
5468: return (ret);
5469: }
5470:
5471:
5472: /**
5473: * xmlSchemaAddParticle:
5474: * @ctxt: a schema parser context
5475: * @schema: the schema being built
5476: * @node: the corresponding node in the schema doc
5477: * @min: the minOccurs
5478: * @max: the maxOccurs
5479: *
5480: * Adds an XML schema particle component.
5481: * *WARNING* this interface is highly subject to change
5482: *
5483: * Returns the new struture or NULL in case of error
5484: */
5485: static xmlSchemaParticlePtr
5486: xmlSchemaAddParticle(xmlSchemaParserCtxtPtr ctxt,
5487: xmlNodePtr node, int min, int max)
5488: {
5489: xmlSchemaParticlePtr ret = NULL;
5490: if (ctxt == NULL)
5491: return (NULL);
5492:
5493: #ifdef DEBUG
5494: fprintf(stderr, "Adding particle component\n");
5495: #endif
5496: ret = (xmlSchemaParticlePtr)
5497: xmlMalloc(sizeof(xmlSchemaParticle));
5498: if (ret == NULL) {
5499: xmlSchemaPErrMemory(ctxt, "allocating particle component",
5500: NULL);
5501: return (NULL);
5502: }
5503: ret->type = XML_SCHEMA_TYPE_PARTICLE;
5504: ret->annot = NULL;
5505: ret->node = node;
5506: ret->minOccurs = min;
5507: ret->maxOccurs = max;
5508: ret->next = NULL;
5509: ret->children = NULL;
5510:
5511: WXS_ADD_LOCAL(ctxt, ret);
5512: /*
5513: * Note that addition to pending components will be done locally
5514: * to the specific parsing function, since the most particles
5515: * need not to be fixed up (i.e. the reference to be resolved).
5516: * REMOVED: WXS_ADD_PENDING(ctxt, ret);
5517: */
5518: return (ret);
5519: }
5520:
5521: /**
5522: * xmlSchemaAddModelGroupDefinition:
5523: * @ctxt: a schema validation context
5524: * @schema: the schema being built
5525: * @name: the group name
5526: *
5527: * Add an XML schema Group definition
5528: *
5529: * Returns the new struture or NULL in case of error
5530: */
5531: static xmlSchemaModelGroupDefPtr
5532: xmlSchemaAddModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
5533: xmlSchemaPtr schema,
5534: const xmlChar *name,
5535: const xmlChar *nsName,
5536: xmlNodePtr node)
5537: {
5538: xmlSchemaModelGroupDefPtr ret = NULL;
5539:
5540: if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5541: return (NULL);
5542:
5543: ret = (xmlSchemaModelGroupDefPtr)
5544: xmlMalloc(sizeof(xmlSchemaModelGroupDef));
5545: if (ret == NULL) {
5546: xmlSchemaPErrMemory(ctxt, "adding group", NULL);
5547: return (NULL);
5548: }
5549: memset(ret, 0, sizeof(xmlSchemaModelGroupDef));
5550: ret->name = name;
5551: ret->type = XML_SCHEMA_TYPE_GROUP;
5552: ret->node = node;
5553: ret->targetNamespace = nsName;
5554:
5555: if (ctxt->isRedefine) {
5556: ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
5557: ret, name, nsName);
5558: if (ctxt->redef == NULL) {
5559: xmlFree(ret);
5560: return(NULL);
5561: }
5562: ctxt->redefCounter = 0;
5563: }
5564: WXS_ADD_GLOBAL(ctxt, ret);
5565: WXS_ADD_PENDING(ctxt, ret);
5566: return (ret);
5567: }
5568:
5569: /**
5570: * xmlSchemaNewWildcardNs:
5571: * @ctxt: a schema validation context
5572: *
5573: * Creates a new wildcard namespace constraint.
5574: *
5575: * Returns the new struture or NULL in case of error
5576: */
5577: static xmlSchemaWildcardNsPtr
5578: xmlSchemaNewWildcardNsConstraint(xmlSchemaParserCtxtPtr ctxt)
5579: {
5580: xmlSchemaWildcardNsPtr ret;
5581:
5582: ret = (xmlSchemaWildcardNsPtr)
5583: xmlMalloc(sizeof(xmlSchemaWildcardNs));
5584: if (ret == NULL) {
5585: xmlSchemaPErrMemory(ctxt, "creating wildcard namespace constraint", NULL);
5586: return (NULL);
5587: }
5588: ret->value = NULL;
5589: ret->next = NULL;
5590: return (ret);
5591: }
5592:
5593: static xmlSchemaIDCPtr
5594: xmlSchemaAddIDC(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
5595: const xmlChar *name, const xmlChar *nsName,
5596: int category, xmlNodePtr node)
5597: {
5598: xmlSchemaIDCPtr ret = NULL;
5599:
5600: if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5601: return (NULL);
5602:
5603: ret = (xmlSchemaIDCPtr) xmlMalloc(sizeof(xmlSchemaIDC));
5604: if (ret == NULL) {
5605: xmlSchemaPErrMemory(ctxt,
5606: "allocating an identity-constraint definition", NULL);
5607: return (NULL);
5608: }
5609: memset(ret, 0, sizeof(xmlSchemaIDC));
5610: /* The target namespace of the parent element declaration. */
5611: ret->targetNamespace = nsName;
5612: ret->name = name;
5613: ret->type = category;
5614: ret->node = node;
5615:
5616: WXS_ADD_GLOBAL(ctxt, ret);
5617: /*
5618: * Only keyrefs need to be fixup up.
5619: */
5620: if (category == XML_SCHEMA_TYPE_IDC_KEYREF)
5621: WXS_ADD_PENDING(ctxt, ret);
5622: return (ret);
5623: }
5624:
5625: /**
5626: * xmlSchemaAddWildcard:
5627: * @ctxt: a schema validation context
5628: * @schema: a schema
5629: *
5630: * Adds a wildcard.
5631: * It corresponds to a xsd:anyAttribute and xsd:any.
5632: *
5633: * Returns the new struture or NULL in case of error
5634: */
5635: static xmlSchemaWildcardPtr
5636: xmlSchemaAddWildcard(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
5637: xmlSchemaTypeType type, xmlNodePtr node)
5638: {
5639: xmlSchemaWildcardPtr ret = NULL;
5640:
5641: if ((ctxt == NULL) || (schema == NULL))
5642: return (NULL);
5643:
5644: ret = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
5645: if (ret == NULL) {
5646: xmlSchemaPErrMemory(ctxt, "adding wildcard", NULL);
5647: return (NULL);
5648: }
5649: memset(ret, 0, sizeof(xmlSchemaWildcard));
5650: ret->type = type;
5651: ret->node = node;
5652: WXS_ADD_LOCAL(ctxt, ret);
5653: return (ret);
5654: }
5655:
5656: static void
5657: xmlSchemaSubstGroupFree(xmlSchemaSubstGroupPtr group)
5658: {
5659: if (group == NULL)
5660: return;
5661: if (group->members != NULL)
5662: xmlSchemaItemListFree(group->members);
5663: xmlFree(group);
5664: }
5665:
5666: static xmlSchemaSubstGroupPtr
5667: xmlSchemaSubstGroupAdd(xmlSchemaParserCtxtPtr pctxt,
5668: xmlSchemaElementPtr head)
5669: {
5670: xmlSchemaSubstGroupPtr ret;
5671:
5672: /* Init subst group hash. */
5673: if (WXS_SUBST_GROUPS(pctxt) == NULL) {
5674: WXS_SUBST_GROUPS(pctxt) = xmlHashCreateDict(10, pctxt->dict);
5675: if (WXS_SUBST_GROUPS(pctxt) == NULL)
5676: return(NULL);
5677: }
5678: /* Create a new substitution group. */
5679: ret = (xmlSchemaSubstGroupPtr) xmlMalloc(sizeof(xmlSchemaSubstGroup));
5680: if (ret == NULL) {
5681: xmlSchemaPErrMemory(NULL,
5682: "allocating a substitution group container", NULL);
5683: return(NULL);
5684: }
5685: memset(ret, 0, sizeof(xmlSchemaSubstGroup));
5686: ret->head = head;
5687: /* Create list of members. */
5688: ret->members = xmlSchemaItemListCreate();
5689: if (ret->members == NULL) {
5690: xmlSchemaSubstGroupFree(ret);
5691: return(NULL);
5692: }
5693: /* Add subst group to hash. */
5694: if (xmlHashAddEntry2(WXS_SUBST_GROUPS(pctxt),
5695: head->name, head->targetNamespace, ret) != 0) {
5696: PERROR_INT("xmlSchemaSubstGroupAdd",
5697: "failed to add a new substitution container");
5698: xmlSchemaSubstGroupFree(ret);
5699: return(NULL);
5700: }
5701: return(ret);
5702: }
5703:
5704: static xmlSchemaSubstGroupPtr
5705: xmlSchemaSubstGroupGet(xmlSchemaParserCtxtPtr pctxt,
5706: xmlSchemaElementPtr head)
5707: {
5708: if (WXS_SUBST_GROUPS(pctxt) == NULL)
5709: return(NULL);
5710: return(xmlHashLookup2(WXS_SUBST_GROUPS(pctxt),
5711: head->name, head->targetNamespace));
5712:
5713: }
5714:
5715: /**
5716: * xmlSchemaAddElementSubstitutionMember:
5717: * @pctxt: a schema parser context
5718: * @head: the head of the substitution group
5719: * @member: the new member of the substitution group
5720: *
5721: * Allocate a new annotation structure.
5722: *
5723: * Returns the newly allocated structure or NULL in case or error
5724: */
5725: static int
5726: xmlSchemaAddElementSubstitutionMember(xmlSchemaParserCtxtPtr pctxt,
5727: xmlSchemaElementPtr head,
5728: xmlSchemaElementPtr member)
5729: {
5730: xmlSchemaSubstGroupPtr substGroup = NULL;
5731:
5732: if ((pctxt == NULL) || (head == NULL) || (member == NULL))
5733: return (-1);
5734:
5735: substGroup = xmlSchemaSubstGroupGet(pctxt, head);
5736: if (substGroup == NULL)
5737: substGroup = xmlSchemaSubstGroupAdd(pctxt, head);
5738: if (substGroup == NULL)
5739: return(-1);
5740: if (xmlSchemaItemListAdd(substGroup->members, member) == -1)
5741: return(-1);
5742: return(0);
5743: }
5744:
5745: /************************************************************************
5746: * *
5747: * Utilities for parsing *
5748: * *
5749: ************************************************************************/
5750:
5751: /**
5752: * xmlSchemaPValAttrNodeQNameValue:
5753: * @ctxt: a schema parser context
5754: * @schema: the schema context
5755: * @ownerDes: the designation of the parent element
5756: * @ownerItem: the parent as a schema object
5757: * @value: the QName value
5758: * @local: the resulting local part if found, the attribute value otherwise
5759: * @uri: the resulting namespace URI if found
5760: *
5761: * Extracts the local name and the URI of a QName value and validates it.
5762: * This one is intended to be used on attribute values that
5763: * should resolve to schema components.
5764: *
5765: * Returns 0, in case the QName is valid, a positive error code
5766: * if not valid and -1 if an internal error occurs.
5767: */
5768: static int
5769: xmlSchemaPValAttrNodeQNameValue(xmlSchemaParserCtxtPtr ctxt,
5770: xmlSchemaPtr schema,
5771: xmlSchemaBasicItemPtr ownerItem,
5772: xmlAttrPtr attr,
5773: const xmlChar *value,
5774: const xmlChar **uri,
5775: const xmlChar **local)
5776: {
5777: const xmlChar *pref;
5778: xmlNsPtr ns;
5779: int len, ret;
5780:
5781: *uri = NULL;
5782: *local = NULL;
5783: ret = xmlValidateQName(value, 1);
5784: if (ret > 0) {
5785: xmlSchemaPSimpleTypeErr(ctxt,
5786: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
5787: ownerItem, (xmlNodePtr) attr,
5788: xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
5789: NULL, value, NULL, NULL, NULL);
5790: *local = value;
5791: return (ctxt->err);
5792: } else if (ret < 0)
5793: return (-1);
5794:
5795: if (!strchr((char *) value, ':')) {
5796: ns = xmlSearchNs(attr->doc, attr->parent, NULL);
5797: if (ns)
5798: *uri = xmlDictLookup(ctxt->dict, ns->href, -1);
5799: else if (schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) {
5800: /* TODO: move XML_SCHEMAS_INCLUDING_CONVERT_NS to the
5801: * parser context. */
5802: /*
5803: * This one takes care of included schemas with no
5804: * target namespace.
5805: */
5806: *uri = ctxt->targetNamespace;
5807: }
5808: *local = xmlDictLookup(ctxt->dict, value, -1);
5809: return (0);
5810: }
5811: /*
5812: * At this point xmlSplitQName3 has to return a local name.
5813: */
5814: *local = xmlSplitQName3(value, &len);
5815: *local = xmlDictLookup(ctxt->dict, *local, -1);
5816: pref = xmlDictLookup(ctxt->dict, value, len);
5817: ns = xmlSearchNs(attr->doc, attr->parent, pref);
5818: if (ns == NULL) {
5819: xmlSchemaPSimpleTypeErr(ctxt,
5820: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
5821: ownerItem, (xmlNodePtr) attr,
5822: xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), NULL, value,
5823: "The value '%s' of simple type 'xs:QName' has no "
5824: "corresponding namespace declaration in scope", value, NULL);
5825: return (ctxt->err);
5826: } else {
5827: *uri = xmlDictLookup(ctxt->dict, ns->href, -1);
5828: }
5829: return (0);
5830: }
5831:
5832: /**
5833: * xmlSchemaPValAttrNodeQName:
5834: * @ctxt: a schema parser context
5835: * @schema: the schema context
5836: * @ownerDes: the designation of the owner element
5837: * @ownerItem: the owner as a schema object
5838: * @attr: the attribute node
5839: * @local: the resulting local part if found, the attribute value otherwise
5840: * @uri: the resulting namespace URI if found
5841: *
5842: * Extracts and validates the QName of an attribute value.
5843: * This one is intended to be used on attribute values that
5844: * should resolve to schema components.
5845: *
5846: * Returns 0, in case the QName is valid, a positive error code
5847: * if not valid and -1 if an internal error occurs.
5848: */
5849: static int
5850: xmlSchemaPValAttrNodeQName(xmlSchemaParserCtxtPtr ctxt,
5851: xmlSchemaPtr schema,
5852: xmlSchemaBasicItemPtr ownerItem,
5853: xmlAttrPtr attr,
5854: const xmlChar **uri,
5855: const xmlChar **local)
5856: {
5857: const xmlChar *value;
5858:
5859: value = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
5860: return (xmlSchemaPValAttrNodeQNameValue(ctxt, schema,
5861: ownerItem, attr, value, uri, local));
5862: }
5863:
5864: /**
5865: * xmlSchemaPValAttrQName:
5866: * @ctxt: a schema parser context
5867: * @schema: the schema context
5868: * @ownerDes: the designation of the parent element
5869: * @ownerItem: the owner as a schema object
5870: * @ownerElem: the parent node of the attribute
5871: * @name: the name of the attribute
5872: * @local: the resulting local part if found, the attribute value otherwise
5873: * @uri: the resulting namespace URI if found
5874: *
5875: * Extracts and validates the QName of an attribute value.
5876: *
5877: * Returns 0, in case the QName is valid, a positive error code
5878: * if not valid and -1 if an internal error occurs.
5879: */
5880: static int
5881: xmlSchemaPValAttrQName(xmlSchemaParserCtxtPtr ctxt,
5882: xmlSchemaPtr schema,
5883: xmlSchemaBasicItemPtr ownerItem,
5884: xmlNodePtr ownerElem,
5885: const char *name,
5886: const xmlChar **uri,
5887: const xmlChar **local)
5888: {
5889: xmlAttrPtr attr;
5890:
5891: attr = xmlSchemaGetPropNode(ownerElem, name);
5892: if (attr == NULL) {
5893: *local = NULL;
5894: *uri = NULL;
5895: return (0);
5896: }
5897: return (xmlSchemaPValAttrNodeQName(ctxt, schema,
5898: ownerItem, attr, uri, local));
5899: }
5900:
5901: /**
5902: * xmlSchemaPValAttrID:
5903: * @ctxt: a schema parser context
5904: * @schema: the schema context
5905: * @ownerDes: the designation of the parent element
5906: * @ownerItem: the owner as a schema object
5907: * @ownerElem: the parent node of the attribute
5908: * @name: the name of the attribute
5909: *
5910: * Extracts and validates the ID of an attribute value.
5911: *
5912: * Returns 0, in case the ID is valid, a positive error code
5913: * if not valid and -1 if an internal error occurs.
5914: */
5915: static int
5916: xmlSchemaPValAttrNodeID(xmlSchemaParserCtxtPtr ctxt, xmlAttrPtr attr)
5917: {
5918: int ret;
5919: const xmlChar *value;
5920:
5921: if (attr == NULL)
5922: return(0);
5923: value = xmlSchemaGetNodeContentNoDict((xmlNodePtr) attr);
5924: ret = xmlValidateNCName(value, 1);
5925: if (ret == 0) {
5926: /*
5927: * NOTE: the IDness might have already be declared in the DTD
5928: */
5929: if (attr->atype != XML_ATTRIBUTE_ID) {
5930: xmlIDPtr res;
5931: xmlChar *strip;
5932:
5933: /*
5934: * TODO: Use xmlSchemaStrip here; it's not exported at this
5935: * moment.
5936: */
5937: strip = xmlSchemaCollapseString(value);
5938: if (strip != NULL) {
5939: xmlFree((xmlChar *) value);
5940: value = strip;
5941: }
5942: res = xmlAddID(NULL, attr->doc, value, attr);
5943: if (res == NULL) {
5944: ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
5945: xmlSchemaPSimpleTypeErr(ctxt,
5946: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
5947: NULL, (xmlNodePtr) attr,
5948: xmlSchemaGetBuiltInType(XML_SCHEMAS_ID),
5949: NULL, NULL, "Duplicate value '%s' of simple "
5950: "type 'xs:ID'", value, NULL);
5951: } else
5952: attr->atype = XML_ATTRIBUTE_ID;
5953: }
5954: } else if (ret > 0) {
5955: ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
5956: xmlSchemaPSimpleTypeErr(ctxt,
5957: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
5958: NULL, (xmlNodePtr) attr,
5959: xmlSchemaGetBuiltInType(XML_SCHEMAS_ID),
5960: NULL, NULL, "The value '%s' of simple type 'xs:ID' is "
5961: "not a valid 'xs:NCName'",
5962: value, NULL);
5963: }
5964: if (value != NULL)
5965: xmlFree((xmlChar *)value);
5966:
5967: return (ret);
5968: }
5969:
5970: static int
5971: xmlSchemaPValAttrID(xmlSchemaParserCtxtPtr ctxt,
5972: xmlNodePtr ownerElem,
5973: const xmlChar *name)
5974: {
5975: xmlAttrPtr attr;
5976:
5977: attr = xmlSchemaGetPropNode(ownerElem, (const char *) name);
5978: if (attr == NULL)
5979: return(0);
5980: return(xmlSchemaPValAttrNodeID(ctxt, attr));
5981:
5982: }
5983:
5984: /**
5985: * xmlGetMaxOccurs:
5986: * @ctxt: a schema validation context
5987: * @node: a subtree containing XML Schema informations
5988: *
5989: * Get the maxOccurs property
5990: *
5991: * Returns the default if not found, or the value
5992: */
5993: static int
5994: xmlGetMaxOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
5995: int min, int max, int def, const char *expected)
5996: {
5997: const xmlChar *val, *cur;
5998: int ret = 0;
5999: xmlAttrPtr attr;
6000:
6001: attr = xmlSchemaGetPropNode(node, "maxOccurs");
6002: if (attr == NULL)
6003: return (def);
6004: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
6005:
6006: if (xmlStrEqual(val, (const xmlChar *) "unbounded")) {
6007: if (max != UNBOUNDED) {
6008: xmlSchemaPSimpleTypeErr(ctxt,
6009: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6010: /* XML_SCHEMAP_INVALID_MINOCCURS, */
6011: NULL, (xmlNodePtr) attr, NULL, expected,
6012: val, NULL, NULL, NULL);
6013: return (def);
6014: } else
6015: return (UNBOUNDED); /* encoding it with -1 might be another option */
6016: }
6017:
6018: cur = val;
6019: while (IS_BLANK_CH(*cur))
6020: cur++;
6021: if (*cur == 0) {
6022: xmlSchemaPSimpleTypeErr(ctxt,
6023: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6024: /* XML_SCHEMAP_INVALID_MINOCCURS, */
6025: NULL, (xmlNodePtr) attr, NULL, expected,
6026: val, NULL, NULL, NULL);
6027: return (def);
6028: }
6029: while ((*cur >= '0') && (*cur <= '9')) {
6030: ret = ret * 10 + (*cur - '0');
6031: cur++;
6032: }
6033: while (IS_BLANK_CH(*cur))
6034: cur++;
6035: /*
6036: * TODO: Restrict the maximal value to Integer.
6037: */
6038: if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
6039: xmlSchemaPSimpleTypeErr(ctxt,
6040: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6041: /* XML_SCHEMAP_INVALID_MINOCCURS, */
6042: NULL, (xmlNodePtr) attr, NULL, expected,
6043: val, NULL, NULL, NULL);
6044: return (def);
6045: }
6046: return (ret);
6047: }
6048:
6049: /**
6050: * xmlGetMinOccurs:
6051: * @ctxt: a schema validation context
6052: * @node: a subtree containing XML Schema informations
6053: *
6054: * Get the minOccurs property
6055: *
6056: * Returns the default if not found, or the value
6057: */
6058: static int
6059: xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
6060: int min, int max, int def, const char *expected)
6061: {
6062: const xmlChar *val, *cur;
6063: int ret = 0;
6064: xmlAttrPtr attr;
6065:
6066: attr = xmlSchemaGetPropNode(node, "minOccurs");
6067: if (attr == NULL)
6068: return (def);
6069: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
6070: cur = val;
6071: while (IS_BLANK_CH(*cur))
6072: cur++;
6073: if (*cur == 0) {
6074: xmlSchemaPSimpleTypeErr(ctxt,
6075: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6076: /* XML_SCHEMAP_INVALID_MINOCCURS, */
6077: NULL, (xmlNodePtr) attr, NULL, expected,
6078: val, NULL, NULL, NULL);
6079: return (def);
6080: }
6081: while ((*cur >= '0') && (*cur <= '9')) {
6082: ret = ret * 10 + (*cur - '0');
6083: cur++;
6084: }
6085: while (IS_BLANK_CH(*cur))
6086: cur++;
6087: /*
6088: * TODO: Restrict the maximal value to Integer.
6089: */
6090: if ((*cur != 0) || (ret < min) || ((max != -1) && (ret > max))) {
6091: xmlSchemaPSimpleTypeErr(ctxt,
6092: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6093: /* XML_SCHEMAP_INVALID_MINOCCURS, */
6094: NULL, (xmlNodePtr) attr, NULL, expected,
6095: val, NULL, NULL, NULL);
6096: return (def);
6097: }
6098: return (ret);
6099: }
6100:
6101: /**
6102: * xmlSchemaPGetBoolNodeValue:
6103: * @ctxt: a schema validation context
6104: * @ownerDes: owner designation
6105: * @ownerItem: the owner as a schema item
6106: * @node: the node holding the value
6107: *
6108: * Converts a boolean string value into 1 or 0.
6109: *
6110: * Returns 0 or 1.
6111: */
6112: static int
6113: xmlSchemaPGetBoolNodeValue(xmlSchemaParserCtxtPtr ctxt,
6114: xmlSchemaBasicItemPtr ownerItem,
6115: xmlNodePtr node)
6116: {
6117: xmlChar *value = NULL;
6118: int res = 0;
6119:
6120: value = xmlNodeGetContent(node);
6121: /*
6122: * 3.2.2.1 Lexical representation
6123: * An instance of a datatype that is defined as �boolean�
6124: * can have the following legal literals {true, false, 1, 0}.
6125: */
6126: if (xmlStrEqual(BAD_CAST value, BAD_CAST "true"))
6127: res = 1;
6128: else if (xmlStrEqual(BAD_CAST value, BAD_CAST "false"))
6129: res = 0;
6130: else if (xmlStrEqual(BAD_CAST value, BAD_CAST "1"))
6131: res = 1;
6132: else if (xmlStrEqual(BAD_CAST value, BAD_CAST "0"))
6133: res = 0;
6134: else {
6135: xmlSchemaPSimpleTypeErr(ctxt,
6136: XML_SCHEMAP_INVALID_BOOLEAN,
6137: ownerItem, node,
6138: xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
6139: NULL, BAD_CAST value,
6140: NULL, NULL, NULL);
6141: }
6142: if (value != NULL)
6143: xmlFree(value);
6144: return (res);
6145: }
6146:
6147: /**
6148: * xmlGetBooleanProp:
6149: * @ctxt: a schema validation context
6150: * @node: a subtree containing XML Schema informations
6151: * @name: the attribute name
6152: * @def: the default value
6153: *
6154: * Evaluate if a boolean property is set
6155: *
6156: * Returns the default if not found, 0 if found to be false,
6157: * 1 if found to be true
6158: */
6159: static int
6160: xmlGetBooleanProp(xmlSchemaParserCtxtPtr ctxt,
6161: xmlNodePtr node,
6162: const char *name, int def)
6163: {
6164: const xmlChar *val;
6165:
6166: val = xmlSchemaGetProp(ctxt, node, name);
6167: if (val == NULL)
6168: return (def);
6169: /*
6170: * 3.2.2.1 Lexical representation
6171: * An instance of a datatype that is defined as �boolean�
6172: * can have the following legal literals {true, false, 1, 0}.
6173: */
6174: if (xmlStrEqual(val, BAD_CAST "true"))
6175: def = 1;
6176: else if (xmlStrEqual(val, BAD_CAST "false"))
6177: def = 0;
6178: else if (xmlStrEqual(val, BAD_CAST "1"))
6179: def = 1;
6180: else if (xmlStrEqual(val, BAD_CAST "0"))
6181: def = 0;
6182: else {
6183: xmlSchemaPSimpleTypeErr(ctxt,
6184: XML_SCHEMAP_INVALID_BOOLEAN,
6185: NULL,
6186: (xmlNodePtr) xmlSchemaGetPropNode(node, name),
6187: xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
6188: NULL, val, NULL, NULL, NULL);
6189: }
6190: return (def);
6191: }
6192:
6193: /************************************************************************
6194: * *
6195: * Shema extraction from an Infoset *
6196: * *
6197: ************************************************************************/
6198: static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
6199: ctxt, xmlSchemaPtr schema,
6200: xmlNodePtr node,
6201: int topLevel);
6202: static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
6203: ctxt,
6204: xmlSchemaPtr schema,
6205: xmlNodePtr node,
6206: int topLevel);
6207: static xmlSchemaTypePtr xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr
6208: ctxt,
6209: xmlSchemaPtr schema,
6210: xmlNodePtr node,
6211: xmlSchemaTypeType parentType);
6212: static xmlSchemaBasicItemPtr
6213: xmlSchemaParseLocalAttribute(xmlSchemaParserCtxtPtr pctxt,
6214: xmlSchemaPtr schema,
6215: xmlNodePtr node,
6216: xmlSchemaItemListPtr uses,
6217: int parentType);
6218: static xmlSchemaTypePtr xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt,
6219: xmlSchemaPtr schema,
6220: xmlNodePtr node);
6221: static xmlSchemaWildcardPtr
6222: xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
6223: xmlSchemaPtr schema, xmlNodePtr node);
6224:
6225: /**
6226: * xmlSchemaPValAttrNodeValue:
6227: *
6228: * @ctxt: a schema parser context
6229: * @ownerDes: the designation of the parent element
6230: * @ownerItem: the schema object owner if existent
6231: * @attr: the schema attribute node being validated
6232: * @value: the value
6233: * @type: the built-in type to be validated against
6234: *
6235: * Validates a value against the given built-in type.
6236: * This one is intended to be used internally for validation
6237: * of schema attribute values during parsing of the schema.
6238: *
6239: * Returns 0 if the value is valid, a positive error code
6240: * number otherwise and -1 in case of an internal or API error.
6241: */
6242: static int
6243: xmlSchemaPValAttrNodeValue(xmlSchemaParserCtxtPtr pctxt,
6244: xmlSchemaBasicItemPtr ownerItem,
6245: xmlAttrPtr attr,
6246: const xmlChar *value,
6247: xmlSchemaTypePtr type)
6248: {
6249:
6250: int ret = 0;
6251:
6252: /*
6253: * NOTE: Should we move this to xmlschematypes.c? Hmm, but this
6254: * one is really meant to be used internally, so better not.
6255: */
6256: if ((pctxt == NULL) || (type == NULL) || (attr == NULL))
6257: return (-1);
6258: if (type->type != XML_SCHEMA_TYPE_BASIC) {
6259: PERROR_INT("xmlSchemaPValAttrNodeValue",
6260: "the given type is not a built-in type");
6261: return (-1);
6262: }
6263: switch (type->builtInType) {
6264: case XML_SCHEMAS_NCNAME:
6265: case XML_SCHEMAS_QNAME:
6266: case XML_SCHEMAS_ANYURI:
6267: case XML_SCHEMAS_TOKEN:
6268: case XML_SCHEMAS_LANGUAGE:
6269: ret = xmlSchemaValPredefTypeNode(type, value, NULL,
6270: (xmlNodePtr) attr);
6271: break;
6272: default: {
6273: PERROR_INT("xmlSchemaPValAttrNodeValue",
6274: "validation using the given type is not supported while "
6275: "parsing a schema");
6276: return (-1);
6277: }
6278: }
6279: /*
6280: * TODO: Should we use the S4S error codes instead?
6281: */
6282: if (ret < 0) {
6283: PERROR_INT("xmlSchemaPValAttrNodeValue",
6284: "failed to validate a schema attribute value");
6285: return (-1);
6286: } else if (ret > 0) {
6287: if (WXS_IS_LIST(type))
6288: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
6289: else
6290: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
6291: xmlSchemaPSimpleTypeErr(pctxt,
6292: ret, ownerItem, (xmlNodePtr) attr,
6293: type, NULL, value, NULL, NULL, NULL);
6294: }
6295: return (ret);
6296: }
6297:
6298: /**
6299: * xmlSchemaPValAttrNode:
6300: *
6301: * @ctxt: a schema parser context
6302: * @ownerDes: the designation of the parent element
6303: * @ownerItem: the schema object owner if existent
6304: * @attr: the schema attribute node being validated
6305: * @type: the built-in type to be validated against
6306: * @value: the resulting value if any
6307: *
6308: * Extracts and validates a value against the given built-in type.
6309: * This one is intended to be used internally for validation
6310: * of schema attribute values during parsing of the schema.
6311: *
6312: * Returns 0 if the value is valid, a positive error code
6313: * number otherwise and -1 in case of an internal or API error.
6314: */
6315: static int
6316: xmlSchemaPValAttrNode(xmlSchemaParserCtxtPtr ctxt,
6317: xmlSchemaBasicItemPtr ownerItem,
6318: xmlAttrPtr attr,
6319: xmlSchemaTypePtr type,
6320: const xmlChar **value)
6321: {
6322: const xmlChar *val;
6323:
6324: if ((ctxt == NULL) || (type == NULL) || (attr == NULL))
6325: return (-1);
6326:
6327: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
6328: if (value != NULL)
6329: *value = val;
6330:
6331: return (xmlSchemaPValAttrNodeValue(ctxt, ownerItem, attr,
6332: val, type));
6333: }
6334:
6335: /**
6336: * xmlSchemaPValAttr:
6337: *
6338: * @ctxt: a schema parser context
6339: * @node: the element node of the attribute
6340: * @ownerDes: the designation of the parent element
6341: * @ownerItem: the schema object owner if existent
6342: * @ownerElem: the owner element node
6343: * @name: the name of the schema attribute node
6344: * @type: the built-in type to be validated against
6345: * @value: the resulting value if any
6346: *
6347: * Extracts and validates a value against the given built-in type.
6348: * This one is intended to be used internally for validation
6349: * of schema attribute values during parsing of the schema.
6350: *
6351: * Returns 0 if the value is valid, a positive error code
6352: * number otherwise and -1 in case of an internal or API error.
6353: */
6354: static int
6355: xmlSchemaPValAttr(xmlSchemaParserCtxtPtr ctxt,
6356: xmlSchemaBasicItemPtr ownerItem,
6357: xmlNodePtr ownerElem,
6358: const char *name,
6359: xmlSchemaTypePtr type,
6360: const xmlChar **value)
6361: {
6362: xmlAttrPtr attr;
6363:
6364: if ((ctxt == NULL) || (type == NULL)) {
6365: if (value != NULL)
6366: *value = NULL;
6367: return (-1);
6368: }
6369: if (type->type != XML_SCHEMA_TYPE_BASIC) {
6370: if (value != NULL)
6371: *value = NULL;
6372: xmlSchemaPErr(ctxt, ownerElem,
6373: XML_SCHEMAP_INTERNAL,
6374: "Internal error: xmlSchemaPValAttr, the given "
6375: "type '%s' is not a built-in type.\n",
6376: type->name, NULL);
6377: return (-1);
6378: }
6379: attr = xmlSchemaGetPropNode(ownerElem, name);
6380: if (attr == NULL) {
6381: if (value != NULL)
6382: *value = NULL;
6383: return (0);
6384: }
6385: return (xmlSchemaPValAttrNode(ctxt, ownerItem, attr,
6386: type, value));
6387: }
6388:
6389: static int
6390: xmlSchemaCheckReference(xmlSchemaParserCtxtPtr pctxt,
6391: xmlSchemaPtr schema ATTRIBUTE_UNUSED,
6392: xmlNodePtr node,
6393: xmlAttrPtr attr,
6394: const xmlChar *namespaceName)
6395: {
6396: /* TODO: Pointer comparison instead? */
6397: if (xmlStrEqual(pctxt->targetNamespace, namespaceName))
6398: return (0);
6399: if (xmlStrEqual(xmlSchemaNs, namespaceName))
6400: return (0);
6401: /*
6402: * Check if the referenced namespace was <import>ed.
6403: */
6404: if (WXS_BUCKET(pctxt)->relations != NULL) {
6405: xmlSchemaSchemaRelationPtr rel;
6406:
6407: rel = WXS_BUCKET(pctxt)->relations;
6408: do {
6409: if (WXS_IS_BUCKET_IMPMAIN(rel->type) &&
6410: xmlStrEqual(namespaceName, rel->importNamespace))
6411: return (0);
6412: rel = rel->next;
6413: } while (rel != NULL);
6414: }
6415: /*
6416: * No matching <import>ed namespace found.
6417: */
6418: {
6419: xmlNodePtr n = (attr != NULL) ? (xmlNodePtr) attr : node;
6420:
6421: if (namespaceName == NULL)
6422: xmlSchemaCustomErr(ACTXT_CAST pctxt,
6423: XML_SCHEMAP_SRC_RESOLVE, n, NULL,
6424: "References from this schema to components in no "
6425: "namespace are not allowed, since not indicated by an "
6426: "import statement", NULL, NULL);
6427: else
6428: xmlSchemaCustomErr(ACTXT_CAST pctxt,
6429: XML_SCHEMAP_SRC_RESOLVE, n, NULL,
6430: "References from this schema to components in the "
6431: "namespace '%s' are not allowed, since not indicated by an "
6432: "import statement", namespaceName, NULL);
6433: }
6434: return (XML_SCHEMAP_SRC_RESOLVE);
6435: }
6436:
6437: /**
6438: * xmlSchemaParseLocalAttributes:
6439: * @ctxt: a schema validation context
6440: * @schema: the schema being built
6441: * @node: a subtree containing XML Schema informations
6442: * @type: the hosting type where the attributes will be anchored
6443: *
6444: * Parses attribute uses and attribute declarations and
6445: * attribute group references.
6446: */
6447: static int
6448: xmlSchemaParseLocalAttributes(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
6449: xmlNodePtr *child, xmlSchemaItemListPtr *list,
6450: int parentType, int *hasRefs)
6451: {
6452: void *item;
6453:
6454: while ((IS_SCHEMA((*child), "attribute")) ||
6455: (IS_SCHEMA((*child), "attributeGroup"))) {
6456: if (IS_SCHEMA((*child), "attribute")) {
6457: item = xmlSchemaParseLocalAttribute(ctxt, schema, *child,
6458: *list, parentType);
6459: } else {
6460: item = xmlSchemaParseAttributeGroupRef(ctxt, schema, *child);
6461: if ((item != NULL) && (hasRefs != NULL))
6462: *hasRefs = 1;
6463: }
6464: if (item != NULL) {
6465: if (*list == NULL) {
6466: /* TODO: Customize grow factor. */
6467: *list = xmlSchemaItemListCreate();
6468: if (*list == NULL)
6469: return(-1);
6470: }
6471: if (xmlSchemaItemListAddSize(*list, 2, item) == -1)
6472: return(-1);
6473: }
6474: *child = (*child)->next;
6475: }
6476: return (0);
6477: }
6478:
6479: /**
6480: * xmlSchemaParseAnnotation:
6481: * @ctxt: a schema validation context
6482: * @schema: the schema being built
6483: * @node: a subtree containing XML Schema informations
6484: *
6485: * parse a XML schema Attrribute declaration
6486: * *WARNING* this interface is highly subject to change
6487: *
6488: * Returns -1 in case of error, 0 if the declaration is improper and
6489: * 1 in case of success.
6490: */
6491: static xmlSchemaAnnotPtr
6492: xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int needed)
6493: {
6494: xmlSchemaAnnotPtr ret;
6495: xmlNodePtr child = NULL;
6496: xmlAttrPtr attr;
6497: int barked = 0;
6498:
6499: /*
6500: * INFO: S4S completed.
6501: */
6502: /*
6503: * id = ID
6504: * {any attributes with non-schema namespace . . .}>
6505: * Content: (appinfo | documentation)*
6506: */
6507: if ((ctxt == NULL) || (node == NULL))
6508: return (NULL);
6509: if (needed)
6510: ret = xmlSchemaNewAnnot(ctxt, node);
6511: else
6512: ret = NULL;
6513: attr = node->properties;
6514: while (attr != NULL) {
6515: if (((attr->ns == NULL) &&
6516: (!xmlStrEqual(attr->name, BAD_CAST "id"))) ||
6517: ((attr->ns != NULL) &&
6518: xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
6519:
6520: xmlSchemaPIllegalAttrErr(ctxt,
6521: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6522: }
6523: attr = attr->next;
6524: }
6525: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6526: /*
6527: * And now for the children...
6528: */
6529: child = node->children;
6530: while (child != NULL) {
6531: if (IS_SCHEMA(child, "appinfo")) {
6532: /* TODO: make available the content of "appinfo". */
6533: /*
6534: * source = anyURI
6535: * {any attributes with non-schema namespace . . .}>
6536: * Content: ({any})*
6537: */
6538: attr = child->properties;
6539: while (attr != NULL) {
6540: if (((attr->ns == NULL) &&
6541: (!xmlStrEqual(attr->name, BAD_CAST "source"))) ||
6542: ((attr->ns != NULL) &&
6543: xmlStrEqual(attr->ns->href, xmlSchemaNs))) {
6544:
6545: xmlSchemaPIllegalAttrErr(ctxt,
6546: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6547: }
6548: attr = attr->next;
6549: }
6550: xmlSchemaPValAttr(ctxt, NULL, child, "source",
6551: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
6552: child = child->next;
6553: } else if (IS_SCHEMA(child, "documentation")) {
6554: /* TODO: make available the content of "documentation". */
6555: /*
6556: * source = anyURI
6557: * {any attributes with non-schema namespace . . .}>
6558: * Content: ({any})*
6559: */
6560: attr = child->properties;
6561: while (attr != NULL) {
6562: if (attr->ns == NULL) {
6563: if (!xmlStrEqual(attr->name, BAD_CAST "source")) {
6564: xmlSchemaPIllegalAttrErr(ctxt,
6565: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6566: }
6567: } else {
6568: if (xmlStrEqual(attr->ns->href, xmlSchemaNs) ||
6569: (xmlStrEqual(attr->name, BAD_CAST "lang") &&
6570: (!xmlStrEqual(attr->ns->href, XML_XML_NAMESPACE)))) {
6571:
6572: xmlSchemaPIllegalAttrErr(ctxt,
6573: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6574: }
6575: }
6576: attr = attr->next;
6577: }
6578: /*
6579: * Attribute "xml:lang".
6580: */
6581: attr = xmlSchemaGetPropNodeNs(child, (const char *) XML_XML_NAMESPACE, "lang");
6582: if (attr != NULL)
6583: xmlSchemaPValAttrNode(ctxt, NULL, attr,
6584: xmlSchemaGetBuiltInType(XML_SCHEMAS_LANGUAGE), NULL);
6585: child = child->next;
6586: } else {
6587: if (!barked)
6588: xmlSchemaPContentErr(ctxt,
6589: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
6590: NULL, node, child, NULL, "(appinfo | documentation)*");
6591: barked = 1;
6592: child = child->next;
6593: }
6594: }
6595:
6596: return (ret);
6597: }
6598:
6599: /**
6600: * xmlSchemaParseFacet:
6601: * @ctxt: a schema validation context
6602: * @schema: the schema being built
6603: * @node: a subtree containing XML Schema informations
6604: *
6605: * parse a XML schema Facet declaration
6606: * *WARNING* this interface is highly subject to change
6607: *
6608: * Returns the new type structure or NULL in case of error
6609: */
6610: static xmlSchemaFacetPtr
6611: xmlSchemaParseFacet(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
6612: xmlNodePtr node)
6613: {
6614: xmlSchemaFacetPtr facet;
6615: xmlNodePtr child = NULL;
6616: const xmlChar *value;
6617:
6618: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6619: return (NULL);
6620:
6621: facet = xmlSchemaNewFacet();
6622: if (facet == NULL) {
6623: xmlSchemaPErrMemory(ctxt, "allocating facet", node);
6624: return (NULL);
6625: }
6626: facet->node = node;
6627: value = xmlSchemaGetProp(ctxt, node, "value");
6628: if (value == NULL) {
6629: xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_FACET_NO_VALUE,
6630: "Facet %s has no value\n", node->name, NULL);
6631: xmlSchemaFreeFacet(facet);
6632: return (NULL);
6633: }
6634: if (IS_SCHEMA(node, "minInclusive")) {
6635: facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
6636: } else if (IS_SCHEMA(node, "minExclusive")) {
6637: facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
6638: } else if (IS_SCHEMA(node, "maxInclusive")) {
6639: facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
6640: } else if (IS_SCHEMA(node, "maxExclusive")) {
6641: facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
6642: } else if (IS_SCHEMA(node, "totalDigits")) {
6643: facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
6644: } else if (IS_SCHEMA(node, "fractionDigits")) {
6645: facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
6646: } else if (IS_SCHEMA(node, "pattern")) {
6647: facet->type = XML_SCHEMA_FACET_PATTERN;
6648: } else if (IS_SCHEMA(node, "enumeration")) {
6649: facet->type = XML_SCHEMA_FACET_ENUMERATION;
6650: } else if (IS_SCHEMA(node, "whiteSpace")) {
6651: facet->type = XML_SCHEMA_FACET_WHITESPACE;
6652: } else if (IS_SCHEMA(node, "length")) {
6653: facet->type = XML_SCHEMA_FACET_LENGTH;
6654: } else if (IS_SCHEMA(node, "maxLength")) {
6655: facet->type = XML_SCHEMA_FACET_MAXLENGTH;
6656: } else if (IS_SCHEMA(node, "minLength")) {
6657: facet->type = XML_SCHEMA_FACET_MINLENGTH;
6658: } else {
6659: xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_TYPE,
6660: "Unknown facet type %s\n", node->name, NULL);
6661: xmlSchemaFreeFacet(facet);
6662: return (NULL);
6663: }
6664: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6665: facet->value = value;
6666: if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
6667: (facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
6668: const xmlChar *fixed;
6669:
6670: fixed = xmlSchemaGetProp(ctxt, node, "fixed");
6671: if (fixed != NULL) {
6672: if (xmlStrEqual(fixed, BAD_CAST "true"))
6673: facet->fixed = 1;
6674: }
6675: }
6676: child = node->children;
6677:
6678: if (IS_SCHEMA(child, "annotation")) {
6679: facet->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
6680: child = child->next;
6681: }
6682: if (child != NULL) {
6683: xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
6684: "Facet %s has unexpected child content\n",
6685: node->name, NULL);
6686: }
6687: return (facet);
6688: }
6689:
6690: /**
6691: * xmlSchemaParseWildcardNs:
6692: * @ctxt: a schema parser context
6693: * @wildc: the wildcard, already created
6694: * @node: a subtree containing XML Schema informations
6695: *
6696: * Parses the attribute "processContents" and "namespace"
6697: * of a xsd:anyAttribute and xsd:any.
6698: * *WARNING* this interface is highly subject to change
6699: *
6700: * Returns 0 if everything goes fine, a positive error code
6701: * if something is not valid and -1 if an internal error occurs.
6702: */
6703: static int
6704: xmlSchemaParseWildcardNs(xmlSchemaParserCtxtPtr ctxt,
6705: xmlSchemaPtr schema ATTRIBUTE_UNUSED,
6706: xmlSchemaWildcardPtr wildc,
6707: xmlNodePtr node)
6708: {
6709: const xmlChar *pc, *ns, *dictnsItem;
6710: int ret = 0;
6711: xmlChar *nsItem;
6712: xmlSchemaWildcardNsPtr tmp, lastNs = NULL;
6713: xmlAttrPtr attr;
6714:
6715: pc = xmlSchemaGetProp(ctxt, node, "processContents");
6716: if ((pc == NULL)
6717: || (xmlStrEqual(pc, (const xmlChar *) "strict"))) {
6718: wildc->processContents = XML_SCHEMAS_ANY_STRICT;
6719: } else if (xmlStrEqual(pc, (const xmlChar *) "skip")) {
6720: wildc->processContents = XML_SCHEMAS_ANY_SKIP;
6721: } else if (xmlStrEqual(pc, (const xmlChar *) "lax")) {
6722: wildc->processContents = XML_SCHEMAS_ANY_LAX;
6723: } else {
6724: xmlSchemaPSimpleTypeErr(ctxt,
6725: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
6726: NULL, node,
6727: NULL, "(strict | skip | lax)", pc,
6728: NULL, NULL, NULL);
6729: wildc->processContents = XML_SCHEMAS_ANY_STRICT;
6730: ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
6731: }
6732: /*
6733: * Build the namespace constraints.
6734: */
6735: attr = xmlSchemaGetPropNode(node, "namespace");
6736: ns = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
6737: if ((attr == NULL) || (xmlStrEqual(ns, BAD_CAST "##any")))
6738: wildc->any = 1;
6739: else if (xmlStrEqual(ns, BAD_CAST "##other")) {
6740: wildc->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
6741: if (wildc->negNsSet == NULL) {
6742: return (-1);
6743: }
6744: wildc->negNsSet->value = ctxt->targetNamespace;
6745: } else {
6746: const xmlChar *end, *cur;
6747:
6748: cur = ns;
6749: do {
6750: while (IS_BLANK_CH(*cur))
6751: cur++;
6752: end = cur;
6753: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
6754: end++;
6755: if (end == cur)
6756: break;
6757: nsItem = xmlStrndup(cur, end - cur);
6758: if ((xmlStrEqual(nsItem, BAD_CAST "##other")) ||
6759: (xmlStrEqual(nsItem, BAD_CAST "##any"))) {
6760: xmlSchemaPSimpleTypeErr(ctxt,
6761: XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
6762: NULL, (xmlNodePtr) attr,
6763: NULL,
6764: "((##any | ##other) | List of (xs:anyURI | "
6765: "(##targetNamespace | ##local)))",
6766: nsItem, NULL, NULL, NULL);
6767: ret = XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER;
6768: } else {
6769: if (xmlStrEqual(nsItem, BAD_CAST "##targetNamespace")) {
6770: dictnsItem = ctxt->targetNamespace;
6771: } else if (xmlStrEqual(nsItem, BAD_CAST "##local")) {
6772: dictnsItem = NULL;
6773: } else {
6774: /*
6775: * Validate the item (anyURI).
6776: */
6777: xmlSchemaPValAttrNodeValue(ctxt, NULL, attr,
6778: nsItem, xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI));
6779: dictnsItem = xmlDictLookup(ctxt->dict, nsItem, -1);
6780: }
6781: /*
6782: * Avoid dublicate namespaces.
6783: */
6784: tmp = wildc->nsSet;
6785: while (tmp != NULL) {
6786: if (dictnsItem == tmp->value)
6787: break;
6788: tmp = tmp->next;
6789: }
6790: if (tmp == NULL) {
6791: tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
6792: if (tmp == NULL) {
6793: xmlFree(nsItem);
6794: return (-1);
6795: }
6796: tmp->value = dictnsItem;
6797: tmp->next = NULL;
6798: if (wildc->nsSet == NULL)
6799: wildc->nsSet = tmp;
6800: else if (lastNs != NULL)
6801: lastNs->next = tmp;
6802: lastNs = tmp;
6803: }
6804:
6805: }
6806: xmlFree(nsItem);
6807: cur = end;
6808: } while (*cur != 0);
6809: }
6810: return (ret);
6811: }
6812:
6813: static int
6814: xmlSchemaPCheckParticleCorrect_2(xmlSchemaParserCtxtPtr ctxt,
6815: xmlSchemaParticlePtr item ATTRIBUTE_UNUSED,
6816: xmlNodePtr node,
6817: int minOccurs,
6818: int maxOccurs) {
6819:
6820: if ((maxOccurs == 0) && ( minOccurs == 0))
6821: return (0);
6822: if (maxOccurs != UNBOUNDED) {
6823: /*
6824: * TODO: Maybe we should better not create the particle,
6825: * if min/max is invalid, since it could confuse the build of the
6826: * content model.
6827: */
6828: /*
6829: * 3.9.6 Schema Component Constraint: Particle Correct
6830: *
6831: */
6832: if (maxOccurs < 1) {
6833: /*
6834: * 2.2 {max occurs} must be greater than or equal to 1.
6835: */
6836: xmlSchemaPCustomAttrErr(ctxt,
6837: XML_SCHEMAP_P_PROPS_CORRECT_2_2,
6838: NULL, NULL,
6839: xmlSchemaGetPropNode(node, "maxOccurs"),
6840: "The value must be greater than or equal to 1");
6841: return (XML_SCHEMAP_P_PROPS_CORRECT_2_2);
6842: } else if (minOccurs > maxOccurs) {
6843: /*
6844: * 2.1 {min occurs} must not be greater than {max occurs}.
6845: */
6846: xmlSchemaPCustomAttrErr(ctxt,
6847: XML_SCHEMAP_P_PROPS_CORRECT_2_1,
6848: NULL, NULL,
6849: xmlSchemaGetPropNode(node, "minOccurs"),
6850: "The value must not be greater than the value of 'maxOccurs'");
6851: return (XML_SCHEMAP_P_PROPS_CORRECT_2_1);
6852: }
6853: }
6854: return (0);
6855: }
6856:
6857: /**
6858: * xmlSchemaParseAny:
6859: * @ctxt: a schema validation context
6860: * @schema: the schema being built
6861: * @node: a subtree containing XML Schema informations
6862: *
6863: * Parsea a XML schema <any> element. A particle and wildcard
6864: * will be created (except if minOccurs==maxOccurs==0, in this case
6865: * nothing will be created).
6866: * *WARNING* this interface is highly subject to change
6867: *
6868: * Returns the particle or NULL in case of error or if minOccurs==maxOccurs==0
6869: */
6870: static xmlSchemaParticlePtr
6871: xmlSchemaParseAny(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
6872: xmlNodePtr node)
6873: {
6874: xmlSchemaParticlePtr particle;
6875: xmlNodePtr child = NULL;
6876: xmlSchemaWildcardPtr wild;
6877: int min, max;
6878: xmlAttrPtr attr;
6879: xmlSchemaAnnotPtr annot = NULL;
6880:
6881: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6882: return (NULL);
6883: /*
6884: * Check for illegal attributes.
6885: */
6886: attr = node->properties;
6887: while (attr != NULL) {
6888: if (attr->ns == NULL) {
6889: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
6890: (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
6891: (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
6892: (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
6893: (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
6894: xmlSchemaPIllegalAttrErr(ctxt,
6895: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6896: }
6897: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
6898: xmlSchemaPIllegalAttrErr(ctxt,
6899: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
6900: }
6901: attr = attr->next;
6902: }
6903: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6904: /*
6905: * minOccurs/maxOccurs.
6906: */
6907: max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
6908: "(xs:nonNegativeInteger | unbounded)");
6909: min = xmlGetMinOccurs(ctxt, node, 0, -1, 1,
6910: "xs:nonNegativeInteger");
6911: xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
6912: /*
6913: * Create & parse the wildcard.
6914: */
6915: wild = xmlSchemaAddWildcard(ctxt, schema, XML_SCHEMA_TYPE_ANY, node);
6916: if (wild == NULL)
6917: return (NULL);
6918: xmlSchemaParseWildcardNs(ctxt, schema, wild, node);
6919: /*
6920: * And now for the children...
6921: */
6922: child = node->children;
6923: if (IS_SCHEMA(child, "annotation")) {
6924: annot = xmlSchemaParseAnnotation(ctxt, child, 1);
6925: child = child->next;
6926: }
6927: if (child != NULL) {
6928: xmlSchemaPContentErr(ctxt,
6929: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
6930: NULL, node, child,
6931: NULL, "(annotation?)");
6932: }
6933: /*
6934: * No component if minOccurs==maxOccurs==0.
6935: */
6936: if ((min == 0) && (max == 0)) {
6937: /* Don't free the wildcard, since it's already on the list. */
6938: return (NULL);
6939: }
6940: /*
6941: * Create the particle.
6942: */
6943: particle = xmlSchemaAddParticle(ctxt, node, min, max);
6944: if (particle == NULL)
6945: return (NULL);
6946: particle->annot = annot;
6947: particle->children = (xmlSchemaTreeItemPtr) wild;
6948:
6949: return (particle);
6950: }
6951:
6952: /**
6953: * xmlSchemaParseNotation:
6954: * @ctxt: a schema validation context
6955: * @schema: the schema being built
6956: * @node: a subtree containing XML Schema informations
6957: *
6958: * parse a XML schema Notation declaration
6959: *
6960: * Returns the new structure or NULL in case of error
6961: */
6962: static xmlSchemaNotationPtr
6963: xmlSchemaParseNotation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
6964: xmlNodePtr node)
6965: {
6966: const xmlChar *name;
6967: xmlSchemaNotationPtr ret;
6968: xmlNodePtr child = NULL;
6969:
6970: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6971: return (NULL);
6972: name = xmlSchemaGetProp(ctxt, node, "name");
6973: if (name == NULL) {
6974: xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_NOTATION_NO_NAME,
6975: "Notation has no name\n", NULL, NULL);
6976: return (NULL);
6977: }
6978: ret = xmlSchemaAddNotation(ctxt, schema, name,
6979: ctxt->targetNamespace, node);
6980: if (ret == NULL)
6981: return (NULL);
6982: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6983:
6984: child = node->children;
6985: if (IS_SCHEMA(child, "annotation")) {
6986: ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
6987: child = child->next;
6988: }
6989: if (child != NULL) {
6990: xmlSchemaPContentErr(ctxt,
6991: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
6992: NULL, node, child,
6993: NULL, "(annotation?)");
6994: }
6995:
6996: return (ret);
6997: }
6998:
6999: /**
7000: * xmlSchemaParseAnyAttribute:
7001: * @ctxt: a schema validation context
7002: * @schema: the schema being built
7003: * @node: a subtree containing XML Schema informations
7004: *
7005: * parse a XML schema AnyAttrribute declaration
7006: * *WARNING* this interface is highly subject to change
7007: *
7008: * Returns a wildcard or NULL.
7009: */
7010: static xmlSchemaWildcardPtr
7011: xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
7012: xmlSchemaPtr schema, xmlNodePtr node)
7013: {
7014: xmlSchemaWildcardPtr ret;
7015: xmlNodePtr child = NULL;
7016: xmlAttrPtr attr;
7017:
7018: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
7019: return (NULL);
7020:
7021: ret = xmlSchemaAddWildcard(ctxt, schema, XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
7022: node);
7023: if (ret == NULL) {
7024: return (NULL);
7025: }
7026: /*
7027: * Check for illegal attributes.
7028: */
7029: attr = node->properties;
7030: while (attr != NULL) {
7031: if (attr->ns == NULL) {
7032: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
7033: (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
7034: (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
7035: xmlSchemaPIllegalAttrErr(ctxt,
7036: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7037: }
7038: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
7039: xmlSchemaPIllegalAttrErr(ctxt,
7040: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7041: }
7042: attr = attr->next;
7043: }
7044: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
7045: /*
7046: * Parse the namespace list.
7047: */
7048: if (xmlSchemaParseWildcardNs(ctxt, schema, ret, node) != 0)
7049: return (NULL);
7050: /*
7051: * And now for the children...
7052: */
7053: child = node->children;
7054: if (IS_SCHEMA(child, "annotation")) {
7055: ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
7056: child = child->next;
7057: }
7058: if (child != NULL) {
7059: xmlSchemaPContentErr(ctxt,
7060: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7061: NULL, node, child,
7062: NULL, "(annotation?)");
7063: }
7064:
7065: return (ret);
7066: }
7067:
7068:
7069: /**
7070: * xmlSchemaParseAttribute:
7071: * @ctxt: a schema validation context
7072: * @schema: the schema being built
7073: * @node: a subtree containing XML Schema informations
7074: *
7075: * parse a XML schema Attrribute declaration
7076: * *WARNING* this interface is highly subject to change
7077: *
7078: * Returns the attribute declaration.
7079: */
7080: static xmlSchemaBasicItemPtr
7081: xmlSchemaParseLocalAttribute(xmlSchemaParserCtxtPtr pctxt,
7082: xmlSchemaPtr schema,
7083: xmlNodePtr node,
7084: xmlSchemaItemListPtr uses,
7085: int parentType)
7086: {
7087: const xmlChar *attrValue, *name = NULL, *ns = NULL;
7088: xmlSchemaAttributeUsePtr use = NULL;
7089: xmlNodePtr child = NULL;
7090: xmlAttrPtr attr;
7091: const xmlChar *tmpNs = NULL, *tmpName = NULL, *defValue = NULL;
7092: int isRef = 0, occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
7093: int nberrors, hasForm = 0, defValueType = 0;
7094:
7095: #define WXS_ATTR_DEF_VAL_DEFAULT 1
7096: #define WXS_ATTR_DEF_VAL_FIXED 2
7097:
7098: /*
7099: * 3.2.3 Constraints on XML Representations of Attribute Declarations
7100: */
7101:
7102: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7103: return (NULL);
7104: attr = xmlSchemaGetPropNode(node, "ref");
7105: if (attr != NULL) {
7106: if (xmlSchemaPValAttrNodeQName(pctxt, schema,
7107: NULL, attr, &tmpNs, &tmpName) != 0) {
7108: return (NULL);
7109: }
7110: if (xmlSchemaCheckReference(pctxt, schema, node, attr, tmpNs) != 0)
7111: return(NULL);
7112: isRef = 1;
7113: }
7114: nberrors = pctxt->nberrors;
7115: /*
7116: * Check for illegal attributes.
7117: */
7118: attr = node->properties;
7119: while (attr != NULL) {
7120: if (attr->ns == NULL) {
7121: if (isRef) {
7122: if (xmlStrEqual(attr->name, BAD_CAST "id")) {
7123: xmlSchemaPValAttrNodeID(pctxt, attr);
7124: goto attr_next;
7125: } else if (xmlStrEqual(attr->name, BAD_CAST "ref")) {
7126: goto attr_next;
7127: }
7128: } else {
7129: if (xmlStrEqual(attr->name, BAD_CAST "name")) {
7130: goto attr_next;
7131: } else if (xmlStrEqual(attr->name, BAD_CAST "id")) {
7132: xmlSchemaPValAttrNodeID(pctxt, attr);
7133: goto attr_next;
7134: } else if (xmlStrEqual(attr->name, BAD_CAST "type")) {
7135: xmlSchemaPValAttrNodeQName(pctxt, schema, NULL,
7136: attr, &tmpNs, &tmpName);
7137: goto attr_next;
7138: } else if (xmlStrEqual(attr->name, BAD_CAST "form")) {
7139: /*
7140: * Evaluate the target namespace
7141: */
7142: hasForm = 1;
7143: attrValue = xmlSchemaGetNodeContent(pctxt,
7144: (xmlNodePtr) attr);
7145: if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
7146: ns = pctxt->targetNamespace;
7147: } else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified"))
7148: {
7149: xmlSchemaPSimpleTypeErr(pctxt,
7150: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
7151: NULL, (xmlNodePtr) attr,
7152: NULL, "(qualified | unqualified)",
7153: attrValue, NULL, NULL, NULL);
7154: }
7155: goto attr_next;
7156: }
7157: }
7158: if (xmlStrEqual(attr->name, BAD_CAST "use")) {
7159:
7160: attrValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
7161: /* TODO: Maybe we need to normalize the value beforehand. */
7162: if (xmlStrEqual(attrValue, BAD_CAST "optional"))
7163: occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
7164: else if (xmlStrEqual(attrValue, BAD_CAST "prohibited"))
7165: occurs = XML_SCHEMAS_ATTR_USE_PROHIBITED;
7166: else if (xmlStrEqual(attrValue, BAD_CAST "required"))
7167: occurs = XML_SCHEMAS_ATTR_USE_REQUIRED;
7168: else {
7169: xmlSchemaPSimpleTypeErr(pctxt,
7170: XML_SCHEMAP_INVALID_ATTR_USE,
7171: NULL, (xmlNodePtr) attr,
7172: NULL, "(optional | prohibited | required)",
7173: attrValue, NULL, NULL, NULL);
7174: }
7175: goto attr_next;
7176: } else if (xmlStrEqual(attr->name, BAD_CAST "default")) {
7177: /*
7178: * 3.2.3 : 1
7179: * default and fixed must not both be present.
7180: */
7181: if (defValue) {
7182: xmlSchemaPMutualExclAttrErr(pctxt,
7183: XML_SCHEMAP_SRC_ATTRIBUTE_1,
7184: NULL, attr, "default", "fixed");
7185: } else {
7186: defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
7187: defValueType = WXS_ATTR_DEF_VAL_DEFAULT;
7188: }
7189: goto attr_next;
7190: } else if (xmlStrEqual(attr->name, BAD_CAST "fixed")) {
7191: /*
7192: * 3.2.3 : 1
7193: * default and fixed must not both be present.
7194: */
7195: if (defValue) {
7196: xmlSchemaPMutualExclAttrErr(pctxt,
7197: XML_SCHEMAP_SRC_ATTRIBUTE_1,
7198: NULL, attr, "default", "fixed");
7199: } else {
7200: defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
7201: defValueType = WXS_ATTR_DEF_VAL_FIXED;
7202: }
7203: goto attr_next;
7204: }
7205: } else if (! xmlStrEqual(attr->ns->href, xmlSchemaNs))
7206: goto attr_next;
7207:
7208: xmlSchemaPIllegalAttrErr(pctxt,
7209: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7210:
7211: attr_next:
7212: attr = attr->next;
7213: }
7214: /*
7215: * 3.2.3 : 2
7216: * If default and use are both present, use must have
7217: * the actual value optional.
7218: */
7219: if ((defValueType == WXS_ATTR_DEF_VAL_DEFAULT) &&
7220: (occurs != XML_SCHEMAS_ATTR_USE_OPTIONAL)) {
7221: xmlSchemaPSimpleTypeErr(pctxt,
7222: XML_SCHEMAP_SRC_ATTRIBUTE_2,
7223: NULL, node, NULL,
7224: "(optional | prohibited | required)", NULL,
7225: "The value of the attribute 'use' must be 'optional' "
7226: "if the attribute 'default' is present",
7227: NULL, NULL);
7228: }
7229: /*
7230: * We want correct attributes.
7231: */
7232: if (nberrors != pctxt->nberrors)
7233: return(NULL);
7234: if (! isRef) {
7235: xmlSchemaAttributePtr attrDecl;
7236:
7237: /* TODO: move XML_SCHEMAS_QUALIF_ATTR to the parser. */
7238: if ((! hasForm) && (schema->flags & XML_SCHEMAS_QUALIF_ATTR))
7239: ns = pctxt->targetNamespace;
7240: /*
7241: * 3.2.6 Schema Component Constraint: xsi: Not Allowed
7242: * TODO: Move this to the component layer.
7243: */
7244: if (xmlStrEqual(ns, xmlSchemaInstanceNs)) {
7245: xmlSchemaCustomErr(ACTXT_CAST pctxt,
7246: XML_SCHEMAP_NO_XSI,
7247: node, NULL,
7248: "The target namespace must not match '%s'",
7249: xmlSchemaInstanceNs, NULL);
7250: }
7251: attr = xmlSchemaGetPropNode(node, "name");
7252: if (attr == NULL) {
7253: xmlSchemaPMissingAttrErr(pctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
7254: NULL, node, "name", NULL);
7255: return (NULL);
7256: }
7257: if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
7258: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
7259: return (NULL);
7260: }
7261: /*
7262: * 3.2.6 Schema Component Constraint: xmlns Not Allowed
7263: * TODO: Move this to the component layer.
7264: */
7265: if (xmlStrEqual(name, BAD_CAST "xmlns")) {
7266: xmlSchemaPSimpleTypeErr(pctxt,
7267: XML_SCHEMAP_NO_XMLNS,
7268: NULL, (xmlNodePtr) attr,
7269: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), NULL, NULL,
7270: "The value of the attribute must not match 'xmlns'",
7271: NULL, NULL);
7272: return (NULL);
7273: }
7274: if (occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED)
7275: goto check_children;
7276: /*
7277: * Create the attribute use component.
7278: */
7279: use = xmlSchemaAddAttributeUse(pctxt, node);
7280: if (use == NULL)
7281: return(NULL);
7282: use->occurs = occurs;
7283: /*
7284: * Create the attribute declaration.
7285: */
7286: attrDecl = xmlSchemaAddAttribute(pctxt, schema, name, ns, node, 0);
7287: if (attrDecl == NULL)
7288: return (NULL);
7289: if (tmpName != NULL) {
7290: attrDecl->typeName = tmpName;
7291: attrDecl->typeNs = tmpNs;
7292: }
7293: use->attrDecl = attrDecl;
7294: /*
7295: * Value constraint.
7296: */
7297: if (defValue != NULL) {
7298: attrDecl->defValue = defValue;
7299: if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
7300: attrDecl->flags |= XML_SCHEMAS_ATTR_FIXED;
7301: }
7302: } else if (occurs != XML_SCHEMAS_ATTR_USE_PROHIBITED) {
7303: xmlSchemaQNameRefPtr ref;
7304:
7305: /*
7306: * Create the attribute use component.
7307: */
7308: use = xmlSchemaAddAttributeUse(pctxt, node);
7309: if (use == NULL)
7310: return(NULL);
7311: /*
7312: * We need to resolve the reference at later stage.
7313: */
7314: WXS_ADD_PENDING(pctxt, use);
7315: use->occurs = occurs;
7316: /*
7317: * Create a QName reference to the attribute declaration.
7318: */
7319: ref = xmlSchemaNewQNameRef(pctxt, XML_SCHEMA_TYPE_ATTRIBUTE,
7320: tmpName, tmpNs);
7321: if (ref == NULL)
7322: return(NULL);
7323: /*
7324: * Assign the reference. This will be substituted for the
7325: * referenced attribute declaration when the QName is resolved.
7326: */
7327: use->attrDecl = WXS_ATTR_CAST ref;
7328: /*
7329: * Value constraint.
7330: */
7331: if (defValue != NULL)
7332: use->defValue = defValue;
7333: if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
7334: use->flags |= XML_SCHEMA_ATTR_USE_FIXED;
7335: }
7336:
7337: check_children:
7338: /*
7339: * And now for the children...
7340: */
7341: child = node->children;
7342: if (occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
7343: xmlSchemaAttributeUseProhibPtr prohib;
7344:
7345: if (IS_SCHEMA(child, "annotation")) {
7346: xmlSchemaParseAnnotation(pctxt, child, 0);
7347: child = child->next;
7348: }
7349: if (child != NULL) {
7350: xmlSchemaPContentErr(pctxt,
7351: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7352: NULL, node, child, NULL,
7353: "(annotation?)");
7354: }
7355: /*
7356: * Check for pointlessness of attribute prohibitions.
7357: */
7358: if (parentType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
7359: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
7360: XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
7361: node, NULL,
7362: "Skipping attribute use prohibition, since it is "
7363: "pointless inside an <attributeGroup>",
7364: NULL, NULL, NULL);
7365: return(NULL);
7366: } else if (parentType == XML_SCHEMA_TYPE_EXTENSION) {
7367: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
7368: XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
7369: node, NULL,
7370: "Skipping attribute use prohibition, since it is "
7371: "pointless when extending a type",
7372: NULL, NULL, NULL);
7373: return(NULL);
7374: }
7375: if (! isRef) {
7376: tmpName = name;
7377: tmpNs = ns;
7378: }
7379: /*
7380: * Check for duplicate attribute prohibitions.
7381: */
7382: if (uses) {
7383: int i;
7384:
7385: for (i = 0; i < uses->nbItems; i++) {
7386: use = uses->items[i];
7387: if ((use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) &&
7388: (tmpName == (WXS_ATTR_PROHIB_CAST use)->name) &&
7389: (tmpNs == (WXS_ATTR_PROHIB_CAST use)->targetNamespace))
7390: {
7391: xmlChar *str = NULL;
7392:
7393: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
7394: XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
7395: node, NULL,
7396: "Skipping duplicate attribute use prohibition '%s'",
7397: xmlSchemaFormatQName(&str, tmpNs, tmpName),
7398: NULL, NULL);
7399: FREE_AND_NULL(str)
7400: return(NULL);
7401: }
7402: }
7403: }
7404: /*
7405: * Create the attribute prohibition helper component.
7406: */
7407: prohib = xmlSchemaAddAttributeUseProhib(pctxt);
7408: if (prohib == NULL)
7409: return(NULL);
7410: prohib->node = node;
7411: prohib->name = tmpName;
7412: prohib->targetNamespace = tmpNs;
7413: if (isRef) {
7414: /*
7415: * We need at least to resolve to the attribute declaration.
7416: */
7417: WXS_ADD_PENDING(pctxt, prohib);
7418: }
7419: return(WXS_BASIC_CAST prohib);
7420: } else {
7421: if (IS_SCHEMA(child, "annotation")) {
7422: /*
7423: * TODO: Should this go into the attr decl?
7424: */
7425: use->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7426: child = child->next;
7427: }
7428: if (isRef) {
7429: if (child != NULL) {
7430: if (IS_SCHEMA(child, "simpleType"))
7431: /*
7432: * 3.2.3 : 3.2
7433: * If ref is present, then all of <simpleType>,
7434: * form and type must be absent.
7435: */
7436: xmlSchemaPContentErr(pctxt,
7437: XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
7438: NULL, node, child, NULL,
7439: "(annotation?)");
7440: else
7441: xmlSchemaPContentErr(pctxt,
7442: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7443: NULL, node, child, NULL,
7444: "(annotation?)");
7445: }
7446: } else {
7447: if (IS_SCHEMA(child, "simpleType")) {
7448: if (WXS_ATTRUSE_DECL(use)->typeName != NULL) {
7449: /*
7450: * 3.2.3 : 4
7451: * type and <simpleType> must not both be present.
7452: */
7453: xmlSchemaPContentErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_4,
7454: NULL, node, child,
7455: "The attribute 'type' and the <simpleType> child "
7456: "are mutually exclusive", NULL);
7457: } else
7458: WXS_ATTRUSE_TYPEDEF(use) =
7459: xmlSchemaParseSimpleType(pctxt, schema, child, 0);
7460: child = child->next;
7461: }
7462: if (child != NULL)
7463: xmlSchemaPContentErr(pctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7464: NULL, node, child, NULL,
7465: "(annotation?, simpleType?)");
7466: }
7467: }
7468: return (WXS_BASIC_CAST use);
7469: }
7470:
7471:
7472: static xmlSchemaAttributePtr
7473: xmlSchemaParseGlobalAttribute(xmlSchemaParserCtxtPtr pctxt,
7474: xmlSchemaPtr schema,
7475: xmlNodePtr node)
7476: {
7477: const xmlChar *attrValue;
7478: xmlSchemaAttributePtr ret;
7479: xmlNodePtr child = NULL;
7480: xmlAttrPtr attr;
7481:
7482: /*
7483: * Note that the w3c spec assumes the schema to be validated with schema
7484: * for schemas beforehand.
7485: *
7486: * 3.2.3 Constraints on XML Representations of Attribute Declarations
7487: */
7488: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7489: return (NULL);
7490: /*
7491: * 3.2.3 : 3.1
7492: * One of ref or name must be present, but not both
7493: */
7494: attr = xmlSchemaGetPropNode(node, "name");
7495: if (attr == NULL) {
7496: xmlSchemaPMissingAttrErr(pctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
7497: NULL, node, "name", NULL);
7498: return (NULL);
7499: }
7500: if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
7501: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &attrValue) != 0) {
7502: return (NULL);
7503: }
7504: /*
7505: * 3.2.6 Schema Component Constraint: xmlns Not Allowed
7506: * TODO: Move this to the component layer.
7507: */
7508: if (xmlStrEqual(attrValue, BAD_CAST "xmlns")) {
7509: xmlSchemaPSimpleTypeErr(pctxt,
7510: XML_SCHEMAP_NO_XMLNS,
7511: NULL, (xmlNodePtr) attr,
7512: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), NULL, NULL,
7513: "The value of the attribute must not match 'xmlns'",
7514: NULL, NULL);
7515: return (NULL);
7516: }
7517: /*
7518: * 3.2.6 Schema Component Constraint: xsi: Not Allowed
7519: * TODO: Move this to the component layer.
7520: * Or better leave it here and add it to the component layer
7521: * if we have a schema construction API.
7522: */
7523: if (xmlStrEqual(pctxt->targetNamespace, xmlSchemaInstanceNs)) {
7524: xmlSchemaCustomErr(ACTXT_CAST pctxt,
7525: XML_SCHEMAP_NO_XSI, node, NULL,
7526: "The target namespace must not match '%s'",
7527: xmlSchemaInstanceNs, NULL);
7528: }
7529:
7530: ret = xmlSchemaAddAttribute(pctxt, schema, attrValue,
7531: pctxt->targetNamespace, node, 1);
7532: if (ret == NULL)
7533: return (NULL);
7534: ret->flags |= XML_SCHEMAS_ATTR_GLOBAL;
7535:
7536: /*
7537: * Check for illegal attributes.
7538: */
7539: attr = node->properties;
7540: while (attr != NULL) {
7541: if (attr->ns == NULL) {
7542: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
7543: (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
7544: (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
7545: (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
7546: (!xmlStrEqual(attr->name, BAD_CAST "type")))
7547: {
7548: xmlSchemaPIllegalAttrErr(pctxt,
7549: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7550: }
7551: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
7552: xmlSchemaPIllegalAttrErr(pctxt,
7553: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7554: }
7555: attr = attr->next;
7556: }
7557: xmlSchemaPValAttrQName(pctxt, schema, NULL,
7558: node, "type", &ret->typeNs, &ret->typeName);
7559:
7560: xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7561: /*
7562: * Attribute "fixed".
7563: */
7564: ret->defValue = xmlSchemaGetProp(pctxt, node, "fixed");
7565: if (ret->defValue != NULL)
7566: ret->flags |= XML_SCHEMAS_ATTR_FIXED;
7567: /*
7568: * Attribute "default".
7569: */
7570: attr = xmlSchemaGetPropNode(node, "default");
7571: if (attr != NULL) {
7572: /*
7573: * 3.2.3 : 1
7574: * default and fixed must not both be present.
7575: */
7576: if (ret->flags & XML_SCHEMAS_ATTR_FIXED) {
7577: xmlSchemaPMutualExclAttrErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_1,
7578: WXS_BASIC_CAST ret, attr, "default", "fixed");
7579: } else
7580: ret->defValue = xmlSchemaGetNodeContent(pctxt, (xmlNodePtr) attr);
7581: }
7582: /*
7583: * And now for the children...
7584: */
7585: child = node->children;
7586: if (IS_SCHEMA(child, "annotation")) {
7587: ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7588: child = child->next;
7589: }
7590: if (IS_SCHEMA(child, "simpleType")) {
7591: if (ret->typeName != NULL) {
7592: /*
7593: * 3.2.3 : 4
7594: * type and <simpleType> must not both be present.
7595: */
7596: xmlSchemaPContentErr(pctxt, XML_SCHEMAP_SRC_ATTRIBUTE_4,
7597: NULL, node, child,
7598: "The attribute 'type' and the <simpleType> child "
7599: "are mutually exclusive", NULL);
7600: } else
7601: ret->subtypes = xmlSchemaParseSimpleType(pctxt, schema, child, 0);
7602: child = child->next;
7603: }
7604: if (child != NULL)
7605: xmlSchemaPContentErr(pctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7606: NULL, node, child, NULL,
7607: "(annotation?, simpleType?)");
7608:
7609: return (ret);
7610: }
7611:
7612: /**
7613: * xmlSchemaParseAttributeGroupRef:
7614: * @ctxt: a schema validation context
7615: * @schema: the schema being built
7616: * @node: a subtree containing XML Schema informations
7617: *
7618: * Parse an attribute group definition reference.
7619: * Note that a reference to an attribute group does not
7620: * correspond to any component at all.
7621: * *WARNING* this interface is highly subject to change
7622: *
7623: * Returns the attribute group or NULL in case of error.
7624: */
7625: static xmlSchemaQNameRefPtr
7626: xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
7627: xmlSchemaPtr schema,
7628: xmlNodePtr node)
7629: {
7630: xmlSchemaQNameRefPtr ret;
7631: xmlNodePtr child = NULL;
7632: xmlAttrPtr attr;
7633: const xmlChar *refNs = NULL, *ref = NULL;
7634:
7635: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7636: return (NULL);
7637:
7638: attr = xmlSchemaGetPropNode(node, "ref");
7639: if (attr == NULL) {
7640: xmlSchemaPMissingAttrErr(pctxt,
7641: XML_SCHEMAP_S4S_ATTR_MISSING,
7642: NULL, node, "ref", NULL);
7643: return (NULL);
7644: }
7645: xmlSchemaPValAttrNodeQName(pctxt, schema,
7646: NULL, attr, &refNs, &ref);
7647: if (xmlSchemaCheckReference(pctxt, schema, node, attr, refNs) != 0)
7648: return(NULL);
7649:
7650: /*
7651: * Check for illegal attributes.
7652: */
7653: attr = node->properties;
7654: while (attr != NULL) {
7655: if (attr->ns == NULL) {
7656: if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
7657: (!xmlStrEqual(attr->name, BAD_CAST "id")))
7658: {
7659: xmlSchemaPIllegalAttrErr(pctxt,
7660: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7661: }
7662: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
7663: xmlSchemaPIllegalAttrErr(pctxt,
7664: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7665: }
7666: attr = attr->next;
7667: }
7668: /* Attribute ID */
7669: xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7670:
7671: /*
7672: * And now for the children...
7673: */
7674: child = node->children;
7675: if (IS_SCHEMA(child, "annotation")) {
7676: /*
7677: * TODO: We do not have a place to store the annotation, do we?
7678: */
7679: xmlSchemaParseAnnotation(pctxt, child, 0);
7680: child = child->next;
7681: }
7682: if (child != NULL) {
7683: xmlSchemaPContentErr(pctxt,
7684: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7685: NULL, node, child, NULL,
7686: "(annotation?)");
7687: }
7688:
7689: /*
7690: * Handle attribute group redefinitions.
7691: */
7692: if (pctxt->isRedefine && pctxt->redef &&
7693: (pctxt->redef->item->type ==
7694: XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
7695: (ref == pctxt->redef->refName) &&
7696: (refNs == pctxt->redef->refTargetNs))
7697: {
7698: /*
7699: * SPEC src-redefine:
7700: * (7.1) "If it has an <attributeGroup> among its contents
7701: * the �actual value� of whose ref [attribute] is the same
7702: * as the �actual value� of its own name attribute plus
7703: * target namespace, then it must have exactly one such group."
7704: */
7705: if (pctxt->redefCounter != 0) {
7706: xmlChar *str = NULL;
7707:
7708: xmlSchemaCustomErr(ACTXT_CAST pctxt,
7709: XML_SCHEMAP_SRC_REDEFINE, node, NULL,
7710: "The redefining attribute group definition "
7711: "'%s' must not contain more than one "
7712: "reference to the redefined definition",
7713: xmlSchemaFormatQName(&str, refNs, ref), NULL);
7714: FREE_AND_NULL(str);
7715: return(NULL);
7716: }
7717: pctxt->redefCounter++;
7718: /*
7719: * URGENT TODO: How to ensure that the reference will not be
7720: * handled by the normal component resolution mechanism?
7721: */
7722: ret = xmlSchemaNewQNameRef(pctxt,
7723: XML_SCHEMA_TYPE_ATTRIBUTEGROUP, ref, refNs);
7724: if (ret == NULL)
7725: return(NULL);
7726: ret->node = node;
7727: pctxt->redef->reference = WXS_BASIC_CAST ret;
7728: } else {
7729: /*
7730: * Create a QName-reference helper component. We will substitute this
7731: * component for the attribute uses of the referenced attribute group
7732: * definition.
7733: */
7734: ret = xmlSchemaNewQNameRef(pctxt,
7735: XML_SCHEMA_TYPE_ATTRIBUTEGROUP, ref, refNs);
7736: if (ret == NULL)
7737: return(NULL);
7738: ret->node = node;
7739: /* Add to pending items, to be able to resolve the reference. */
7740: WXS_ADD_PENDING(pctxt, ret);
7741: }
7742: return (ret);
7743: }
7744:
7745: /**
7746: * xmlSchemaParseAttributeGroupDefinition:
7747: * @pctxt: a schema validation context
7748: * @schema: the schema being built
7749: * @node: a subtree containing XML Schema informations
7750: *
7751: * parse a XML schema Attribute Group declaration
7752: * *WARNING* this interface is highly subject to change
7753: *
7754: * Returns the attribute group definition or NULL in case of error.
7755: */
7756: static xmlSchemaAttributeGroupPtr
7757: xmlSchemaParseAttributeGroupDefinition(xmlSchemaParserCtxtPtr pctxt,
7758: xmlSchemaPtr schema,
7759: xmlNodePtr node)
7760: {
7761: const xmlChar *name;
7762: xmlSchemaAttributeGroupPtr ret;
7763: xmlNodePtr child = NULL;
7764: xmlAttrPtr attr;
7765: int hasRefs = 0;
7766:
7767: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7768: return (NULL);
7769:
7770: attr = xmlSchemaGetPropNode(node, "name");
7771: if (attr == NULL) {
7772: xmlSchemaPMissingAttrErr(pctxt,
7773: XML_SCHEMAP_S4S_ATTR_MISSING,
7774: NULL, node, "name", NULL);
7775: return (NULL);
7776: }
7777: /*
7778: * The name is crucial, exit if invalid.
7779: */
7780: if (xmlSchemaPValAttrNode(pctxt,
7781: NULL, attr,
7782: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
7783: return (NULL);
7784: }
7785: ret = xmlSchemaAddAttributeGroupDefinition(pctxt, schema,
7786: name, pctxt->targetNamespace, node);
7787: if (ret == NULL)
7788: return (NULL);
7789: /*
7790: * Check for illegal attributes.
7791: */
7792: attr = node->properties;
7793: while (attr != NULL) {
7794: if (attr->ns == NULL) {
7795: if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
7796: (!xmlStrEqual(attr->name, BAD_CAST "id")))
7797: {
7798: xmlSchemaPIllegalAttrErr(pctxt,
7799: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7800: }
7801: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
7802: xmlSchemaPIllegalAttrErr(pctxt,
7803: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
7804: }
7805: attr = attr->next;
7806: }
7807: /* Attribute ID */
7808: xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7809: /*
7810: * And now for the children...
7811: */
7812: child = node->children;
7813: if (IS_SCHEMA(child, "annotation")) {
7814: ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7815: child = child->next;
7816: }
7817: /*
7818: * Parse contained attribute decls/refs.
7819: */
7820: if (xmlSchemaParseLocalAttributes(pctxt, schema, &child,
7821: (xmlSchemaItemListPtr *) &(ret->attrUses),
7822: XML_SCHEMA_TYPE_ATTRIBUTEGROUP, &hasRefs) == -1)
7823: return(NULL);
7824: if (hasRefs)
7825: ret->flags |= XML_SCHEMAS_ATTRGROUP_HAS_REFS;
7826: /*
7827: * Parse the attribute wildcard.
7828: */
7829: if (IS_SCHEMA(child, "anyAttribute")) {
7830: ret->attributeWildcard = xmlSchemaParseAnyAttribute(pctxt,
7831: schema, child);
7832: child = child->next;
7833: }
7834: if (child != NULL) {
7835: xmlSchemaPContentErr(pctxt,
7836: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
7837: NULL, node, child, NULL,
7838: "(annotation?, ((attribute | attributeGroup)*, anyAttribute?))");
7839: }
7840: return (ret);
7841: }
7842:
7843: /**
7844: * xmlSchemaPValAttrFormDefault:
7845: * @value: the value
7846: * @flags: the flags to be modified
7847: * @flagQualified: the specific flag for "qualified"
7848: *
7849: * Returns 0 if the value is valid, 1 otherwise.
7850: */
7851: static int
7852: xmlSchemaPValAttrFormDefault(const xmlChar *value,
7853: int *flags,
7854: int flagQualified)
7855: {
7856: if (xmlStrEqual(value, BAD_CAST "qualified")) {
7857: if ((*flags & flagQualified) == 0)
7858: *flags |= flagQualified;
7859: } else if (!xmlStrEqual(value, BAD_CAST "unqualified"))
7860: return (1);
7861:
7862: return (0);
7863: }
7864:
7865: /**
7866: * xmlSchemaPValAttrBlockFinal:
7867: * @value: the value
7868: * @flags: the flags to be modified
7869: * @flagAll: the specific flag for "#all"
7870: * @flagExtension: the specific flag for "extension"
7871: * @flagRestriction: the specific flag for "restriction"
7872: * @flagSubstitution: the specific flag for "substitution"
7873: * @flagList: the specific flag for "list"
7874: * @flagUnion: the specific flag for "union"
7875: *
7876: * Validates the value of the attribute "final" and "block". The value
7877: * is converted into the specified flag values and returned in @flags.
7878: *
7879: * Returns 0 if the value is valid, 1 otherwise.
7880: */
7881:
7882: static int
7883: xmlSchemaPValAttrBlockFinal(const xmlChar *value,
7884: int *flags,
7885: int flagAll,
7886: int flagExtension,
7887: int flagRestriction,
7888: int flagSubstitution,
7889: int flagList,
7890: int flagUnion)
7891: {
7892: int ret = 0;
7893:
7894: /*
7895: * TODO: This does not check for dublicate entries.
7896: */
7897: if ((flags == NULL) || (value == NULL))
7898: return (-1);
7899: if (value[0] == 0)
7900: return (0);
7901: if (xmlStrEqual(value, BAD_CAST "#all")) {
7902: if (flagAll != -1)
7903: *flags |= flagAll;
7904: else {
7905: if (flagExtension != -1)
7906: *flags |= flagExtension;
7907: if (flagRestriction != -1)
7908: *flags |= flagRestriction;
7909: if (flagSubstitution != -1)
7910: *flags |= flagSubstitution;
7911: if (flagList != -1)
7912: *flags |= flagList;
7913: if (flagUnion != -1)
7914: *flags |= flagUnion;
7915: }
7916: } else {
7917: const xmlChar *end, *cur = value;
7918: xmlChar *item;
7919:
7920: do {
7921: while (IS_BLANK_CH(*cur))
7922: cur++;
7923: end = cur;
7924: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
7925: end++;
7926: if (end == cur)
7927: break;
7928: item = xmlStrndup(cur, end - cur);
7929: if (xmlStrEqual(item, BAD_CAST "extension")) {
7930: if (flagExtension != -1) {
7931: if ((*flags & flagExtension) == 0)
7932: *flags |= flagExtension;
7933: } else
7934: ret = 1;
7935: } else if (xmlStrEqual(item, BAD_CAST "restriction")) {
7936: if (flagRestriction != -1) {
7937: if ((*flags & flagRestriction) == 0)
7938: *flags |= flagRestriction;
7939: } else
7940: ret = 1;
7941: } else if (xmlStrEqual(item, BAD_CAST "substitution")) {
7942: if (flagSubstitution != -1) {
7943: if ((*flags & flagSubstitution) == 0)
7944: *flags |= flagSubstitution;
7945: } else
7946: ret = 1;
7947: } else if (xmlStrEqual(item, BAD_CAST "list")) {
7948: if (flagList != -1) {
7949: if ((*flags & flagList) == 0)
7950: *flags |= flagList;
7951: } else
7952: ret = 1;
7953: } else if (xmlStrEqual(item, BAD_CAST "union")) {
7954: if (flagUnion != -1) {
7955: if ((*flags & flagUnion) == 0)
7956: *flags |= flagUnion;
7957: } else
7958: ret = 1;
7959: } else
7960: ret = 1;
7961: if (item != NULL)
7962: xmlFree(item);
7963: cur = end;
7964: } while ((ret == 0) && (*cur != 0));
7965: }
7966:
7967: return (ret);
7968: }
7969:
7970: static int
7971: xmlSchemaCheckCSelectorXPath(xmlSchemaParserCtxtPtr ctxt,
7972: xmlSchemaIDCPtr idc,
7973: xmlSchemaIDCSelectPtr selector,
7974: xmlAttrPtr attr,
7975: int isField)
7976: {
7977: xmlNodePtr node;
7978:
7979: /*
7980: * c-selector-xpath:
7981: * Schema Component Constraint: Selector Value OK
7982: *
7983: * TODO: 1 The {selector} must be a valid XPath expression, as defined
7984: * in [XPath].
7985: */
7986: if (selector == NULL) {
7987: xmlSchemaPErr(ctxt, idc->node,
7988: XML_SCHEMAP_INTERNAL,
7989: "Internal error: xmlSchemaCheckCSelectorXPath, "
7990: "the selector is not specified.\n", NULL, NULL);
7991: return (-1);
7992: }
7993: if (attr == NULL)
7994: node = idc->node;
7995: else
7996: node = (xmlNodePtr) attr;
7997: if (selector->xpath == NULL) {
7998: xmlSchemaPCustomErr(ctxt,
7999: /* TODO: Adjust error code. */
8000: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
8001: NULL, node,
8002: "The XPath expression of the selector is not valid", NULL);
8003: return (XML_SCHEMAP_S4S_ATTR_INVALID_VALUE);
8004: } else {
8005: const xmlChar **nsArray = NULL;
8006: xmlNsPtr *nsList = NULL;
8007: /*
8008: * Compile the XPath expression.
8009: */
8010: /*
8011: * TODO: We need the array of in-scope namespaces for compilation.
8012: * TODO: Call xmlPatterncompile with different options for selector/
8013: * field.
8014: */
8015: if (attr == NULL)
8016: nsList = NULL;
8017: else
8018: nsList = xmlGetNsList(attr->doc, attr->parent);
8019: /*
8020: * Build an array of prefixes and namespaces.
8021: */
8022: if (nsList != NULL) {
8023: int i, count = 0;
8024:
8025: for (i = 0; nsList[i] != NULL; i++)
8026: count++;
8027:
8028: nsArray = (const xmlChar **) xmlMalloc(
8029: (count * 2 + 1) * sizeof(const xmlChar *));
8030: if (nsArray == NULL) {
8031: xmlSchemaPErrMemory(ctxt, "allocating a namespace array",
8032: NULL);
8033: xmlFree(nsList);
8034: return (-1);
8035: }
8036: for (i = 0; i < count; i++) {
8037: nsArray[2 * i] = nsList[i]->href;
8038: nsArray[2 * i + 1] = nsList[i]->prefix;
8039: }
8040: nsArray[count * 2] = NULL;
8041: xmlFree(nsList);
8042: }
8043: /*
8044: * TODO: Differentiate between "selector" and "field".
8045: */
8046: if (isField)
8047: selector->xpathComp = (void *) xmlPatterncompile(selector->xpath,
8048: NULL, XML_PATTERN_XSFIELD, nsArray);
8049: else
8050: selector->xpathComp = (void *) xmlPatterncompile(selector->xpath,
8051: NULL, XML_PATTERN_XSSEL, nsArray);
8052: if (nsArray != NULL)
8053: xmlFree((xmlChar **) nsArray);
8054:
8055: if (selector->xpathComp == NULL) {
8056: xmlSchemaPCustomErr(ctxt,
8057: /* TODO: Adjust error code? */
8058: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
8059: NULL, node,
8060: "The XPath expression '%s' could not be "
8061: "compiled", selector->xpath);
8062: return (XML_SCHEMAP_S4S_ATTR_INVALID_VALUE);
8063: }
8064: }
8065: return (0);
8066: }
8067:
8068: #define ADD_ANNOTATION(annot) \
8069: xmlSchemaAnnotPtr cur = item->annot; \
8070: if (item->annot == NULL) { \
8071: item->annot = annot; \
8072: return (annot); \
8073: } \
8074: cur = item->annot; \
8075: if (cur->next != NULL) { \
8076: cur = cur->next; \
8077: } \
8078: cur->next = annot;
8079:
8080: /**
8081: * xmlSchemaAssignAnnotation:
8082: * @item: the schema component
8083: * @annot: the annotation
8084: *
8085: * Adds the annotation to the given schema component.
8086: *
8087: * Returns the given annotaion.
8088: */
8089: static xmlSchemaAnnotPtr
8090: xmlSchemaAddAnnotation(xmlSchemaAnnotItemPtr annItem,
8091: xmlSchemaAnnotPtr annot)
8092: {
8093: if ((annItem == NULL) || (annot == NULL))
8094: return (NULL);
8095: switch (annItem->type) {
8096: case XML_SCHEMA_TYPE_ELEMENT: {
8097: xmlSchemaElementPtr item = (xmlSchemaElementPtr) annItem;
8098: ADD_ANNOTATION(annot)
8099: }
8100: break;
8101: case XML_SCHEMA_TYPE_ATTRIBUTE: {
8102: xmlSchemaAttributePtr item = (xmlSchemaAttributePtr) annItem;
8103: ADD_ANNOTATION(annot)
8104: }
8105: break;
8106: case XML_SCHEMA_TYPE_ANY_ATTRIBUTE:
8107: case XML_SCHEMA_TYPE_ANY: {
8108: xmlSchemaWildcardPtr item = (xmlSchemaWildcardPtr) annItem;
8109: ADD_ANNOTATION(annot)
8110: }
8111: break;
8112: case XML_SCHEMA_TYPE_PARTICLE:
8113: case XML_SCHEMA_TYPE_IDC_KEY:
8114: case XML_SCHEMA_TYPE_IDC_KEYREF:
8115: case XML_SCHEMA_TYPE_IDC_UNIQUE: {
8116: xmlSchemaAnnotItemPtr item = (xmlSchemaAnnotItemPtr) annItem;
8117: ADD_ANNOTATION(annot)
8118: }
8119: break;
8120: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP: {
8121: xmlSchemaAttributeGroupPtr item =
8122: (xmlSchemaAttributeGroupPtr) annItem;
8123: ADD_ANNOTATION(annot)
8124: }
8125: break;
8126: case XML_SCHEMA_TYPE_NOTATION: {
8127: xmlSchemaNotationPtr item = (xmlSchemaNotationPtr) annItem;
8128: ADD_ANNOTATION(annot)
8129: }
8130: break;
8131: case XML_SCHEMA_FACET_MININCLUSIVE:
8132: case XML_SCHEMA_FACET_MINEXCLUSIVE:
8133: case XML_SCHEMA_FACET_MAXINCLUSIVE:
8134: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
8135: case XML_SCHEMA_FACET_TOTALDIGITS:
8136: case XML_SCHEMA_FACET_FRACTIONDIGITS:
8137: case XML_SCHEMA_FACET_PATTERN:
8138: case XML_SCHEMA_FACET_ENUMERATION:
8139: case XML_SCHEMA_FACET_WHITESPACE:
8140: case XML_SCHEMA_FACET_LENGTH:
8141: case XML_SCHEMA_FACET_MAXLENGTH:
8142: case XML_SCHEMA_FACET_MINLENGTH: {
8143: xmlSchemaFacetPtr item = (xmlSchemaFacetPtr) annItem;
8144: ADD_ANNOTATION(annot)
8145: }
8146: break;
8147: case XML_SCHEMA_TYPE_SIMPLE:
8148: case XML_SCHEMA_TYPE_COMPLEX: {
8149: xmlSchemaTypePtr item = (xmlSchemaTypePtr) annItem;
8150: ADD_ANNOTATION(annot)
8151: }
8152: break;
8153: case XML_SCHEMA_TYPE_GROUP: {
8154: xmlSchemaModelGroupDefPtr item = (xmlSchemaModelGroupDefPtr) annItem;
8155: ADD_ANNOTATION(annot)
8156: }
8157: break;
8158: case XML_SCHEMA_TYPE_SEQUENCE:
8159: case XML_SCHEMA_TYPE_CHOICE:
8160: case XML_SCHEMA_TYPE_ALL: {
8161: xmlSchemaModelGroupPtr item = (xmlSchemaModelGroupPtr) annItem;
8162: ADD_ANNOTATION(annot)
8163: }
8164: break;
8165: default:
8166: xmlSchemaPCustomErr(NULL,
8167: XML_SCHEMAP_INTERNAL,
8168: NULL, NULL,
8169: "Internal error: xmlSchemaAddAnnotation, "
8170: "The item is not a annotated schema component", NULL);
8171: break;
8172: }
8173: return (annot);
8174: }
8175:
8176: /**
8177: * xmlSchemaParseIDCSelectorAndField:
8178: * @ctxt: a schema validation context
8179: * @schema: the schema being built
8180: * @node: a subtree containing XML Schema informations
8181: *
8182: * Parses a XML Schema identity-contraint definition's
8183: * <selector> and <field> elements.
8184: *
8185: * Returns the parsed identity-constraint definition.
8186: */
8187: static xmlSchemaIDCSelectPtr
8188: xmlSchemaParseIDCSelectorAndField(xmlSchemaParserCtxtPtr ctxt,
8189: xmlSchemaIDCPtr idc,
8190: xmlNodePtr node,
8191: int isField)
8192: {
8193: xmlSchemaIDCSelectPtr item;
8194: xmlNodePtr child = NULL;
8195: xmlAttrPtr attr;
8196:
8197: /*
8198: * Check for illegal attributes.
8199: */
8200: attr = node->properties;
8201: while (attr != NULL) {
8202: if (attr->ns == NULL) {
8203: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8204: (!xmlStrEqual(attr->name, BAD_CAST "xpath"))) {
8205: xmlSchemaPIllegalAttrErr(ctxt,
8206: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8207: }
8208: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
8209: xmlSchemaPIllegalAttrErr(ctxt,
8210: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8211: }
8212: attr = attr->next;
8213: }
8214: /*
8215: * Create the item.
8216: */
8217: item = (xmlSchemaIDCSelectPtr) xmlMalloc(sizeof(xmlSchemaIDCSelect));
8218: if (item == NULL) {
8219: xmlSchemaPErrMemory(ctxt,
8220: "allocating a 'selector' of an identity-constraint definition",
8221: NULL);
8222: return (NULL);
8223: }
8224: memset(item, 0, sizeof(xmlSchemaIDCSelect));
8225: /*
8226: * Attribute "xpath" (mandatory).
8227: */
8228: attr = xmlSchemaGetPropNode(node, "xpath");
8229: if (attr == NULL) {
8230: xmlSchemaPMissingAttrErr(ctxt,
8231: XML_SCHEMAP_S4S_ATTR_MISSING,
8232: NULL, node,
8233: "name", NULL);
8234: } else {
8235: item->xpath = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8236: /*
8237: * URGENT TODO: "field"s have an other syntax than "selector"s.
8238: */
8239:
8240: if (xmlSchemaCheckCSelectorXPath(ctxt, idc, item, attr,
8241: isField) == -1) {
8242: xmlSchemaPErr(ctxt,
8243: (xmlNodePtr) attr,
8244: XML_SCHEMAP_INTERNAL,
8245: "Internal error: xmlSchemaParseIDCSelectorAndField, "
8246: "validating the XPath expression of a IDC selector.\n",
8247: NULL, NULL);
8248: }
8249:
8250: }
8251: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8252: /*
8253: * And now for the children...
8254: */
8255: child = node->children;
8256: if (IS_SCHEMA(child, "annotation")) {
8257: /*
8258: * Add the annotation to the parent IDC.
8259: */
8260: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) idc,
8261: xmlSchemaParseAnnotation(ctxt, child, 1));
8262: child = child->next;
8263: }
8264: if (child != NULL) {
8265: xmlSchemaPContentErr(ctxt,
8266: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8267: NULL, node, child,
8268: NULL, "(annotation?)");
8269: }
8270:
8271: return (item);
8272: }
8273:
8274: /**
8275: * xmlSchemaParseIDC:
8276: * @ctxt: a schema validation context
8277: * @schema: the schema being built
8278: * @node: a subtree containing XML Schema informations
8279: *
8280: * Parses a XML Schema identity-contraint definition.
8281: *
8282: * Returns the parsed identity-constraint definition.
8283: */
8284: static xmlSchemaIDCPtr
8285: xmlSchemaParseIDC(xmlSchemaParserCtxtPtr ctxt,
8286: xmlSchemaPtr schema,
8287: xmlNodePtr node,
8288: xmlSchemaTypeType idcCategory,
8289: const xmlChar *targetNamespace)
8290: {
8291: xmlSchemaIDCPtr item = NULL;
8292: xmlNodePtr child = NULL;
8293: xmlAttrPtr attr;
8294: const xmlChar *name = NULL;
8295: xmlSchemaIDCSelectPtr field = NULL, lastField = NULL;
8296:
8297: /*
8298: * Check for illegal attributes.
8299: */
8300: attr = node->properties;
8301: while (attr != NULL) {
8302: if (attr->ns == NULL) {
8303: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8304: (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
8305: ((idcCategory != XML_SCHEMA_TYPE_IDC_KEYREF) ||
8306: (!xmlStrEqual(attr->name, BAD_CAST "refer")))) {
8307: xmlSchemaPIllegalAttrErr(ctxt,
8308: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8309: }
8310: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
8311: xmlSchemaPIllegalAttrErr(ctxt,
8312: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8313: }
8314: attr = attr->next;
8315: }
8316: /*
8317: * Attribute "name" (mandatory).
8318: */
8319: attr = xmlSchemaGetPropNode(node, "name");
8320: if (attr == NULL) {
8321: xmlSchemaPMissingAttrErr(ctxt,
8322: XML_SCHEMAP_S4S_ATTR_MISSING,
8323: NULL, node,
8324: "name", NULL);
8325: return (NULL);
8326: } else if (xmlSchemaPValAttrNode(ctxt,
8327: NULL, attr,
8328: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
8329: return (NULL);
8330: }
8331: /* Create the component. */
8332: item = xmlSchemaAddIDC(ctxt, schema, name, targetNamespace,
8333: idcCategory, node);
8334: if (item == NULL)
8335: return(NULL);
8336:
8337: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8338: if (idcCategory == XML_SCHEMA_TYPE_IDC_KEYREF) {
8339: /*
8340: * Attribute "refer" (mandatory).
8341: */
8342: attr = xmlSchemaGetPropNode(node, "refer");
8343: if (attr == NULL) {
8344: xmlSchemaPMissingAttrErr(ctxt,
8345: XML_SCHEMAP_S4S_ATTR_MISSING,
8346: NULL, node,
8347: "refer", NULL);
8348: } else {
8349: /*
8350: * Create a reference item.
8351: */
8352: item->ref = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_IDC_KEY,
8353: NULL, NULL);
8354: if (item->ref == NULL)
8355: return (NULL);
8356: xmlSchemaPValAttrNodeQName(ctxt, schema,
8357: NULL, attr,
8358: &(item->ref->targetNamespace),
8359: &(item->ref->name));
8360: xmlSchemaCheckReference(ctxt, schema, node, attr,
8361: item->ref->targetNamespace);
8362: }
8363: }
8364: /*
8365: * And now for the children...
8366: */
8367: child = node->children;
8368: if (IS_SCHEMA(child, "annotation")) {
8369: item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
8370: child = child->next;
8371: }
8372: if (child == NULL) {
8373: xmlSchemaPContentErr(ctxt,
8374: XML_SCHEMAP_S4S_ELEM_MISSING,
8375: NULL, node, child,
8376: "A child element is missing",
8377: "(annotation?, (selector, field+))");
8378: }
8379: /*
8380: * Child element <selector>.
8381: */
8382: if (IS_SCHEMA(child, "selector")) {
8383: item->selector = xmlSchemaParseIDCSelectorAndField(ctxt,
8384: item, child, 0);
8385: child = child->next;
8386: /*
8387: * Child elements <field>.
8388: */
8389: if (IS_SCHEMA(child, "field")) {
8390: do {
8391: field = xmlSchemaParseIDCSelectorAndField(ctxt,
8392: item, child, 1);
8393: if (field != NULL) {
8394: field->index = item->nbFields;
8395: item->nbFields++;
8396: if (lastField != NULL)
8397: lastField->next = field;
8398: else
8399: item->fields = field;
8400: lastField = field;
8401: }
8402: child = child->next;
8403: } while (IS_SCHEMA(child, "field"));
8404: } else {
8405: xmlSchemaPContentErr(ctxt,
8406: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8407: NULL, node, child,
8408: NULL, "(annotation?, (selector, field+))");
8409: }
8410: }
8411: if (child != NULL) {
8412: xmlSchemaPContentErr(ctxt,
8413: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8414: NULL, node, child,
8415: NULL, "(annotation?, (selector, field+))");
8416: }
8417:
8418: return (item);
8419: }
8420:
8421: /**
8422: * xmlSchemaParseElement:
8423: * @ctxt: a schema validation context
8424: * @schema: the schema being built
8425: * @node: a subtree containing XML Schema informations
8426: * @topLevel: indicates if this is global declaration
8427: *
8428: * Parses a XML schema element declaration.
8429: * *WARNING* this interface is highly subject to change
8430: *
8431: * Returns the element declaration or a particle; NULL in case
8432: * of an error or if the particle has minOccurs==maxOccurs==0.
8433: */
8434: static xmlSchemaBasicItemPtr
8435: xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
8436: xmlNodePtr node, int *isElemRef, int topLevel)
8437: {
8438: xmlSchemaElementPtr decl = NULL;
8439: xmlSchemaParticlePtr particle = NULL;
8440: xmlSchemaAnnotPtr annot = NULL;
8441: xmlNodePtr child = NULL;
8442: xmlAttrPtr attr, nameAttr;
8443: int min, max, isRef = 0;
8444: xmlChar *des = NULL;
8445:
8446: /* 3.3.3 Constraints on XML Representations of Element Declarations */
8447: /* TODO: Complete implementation of 3.3.6 */
8448:
8449: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
8450: return (NULL);
8451:
8452: if (isElemRef != NULL)
8453: *isElemRef = 0;
8454: /*
8455: * If we get a "ref" attribute on a local <element> we will assume it's
8456: * a reference - even if there's a "name" attribute; this seems to be more
8457: * robust.
8458: */
8459: nameAttr = xmlSchemaGetPropNode(node, "name");
8460: attr = xmlSchemaGetPropNode(node, "ref");
8461: if ((topLevel) || (attr == NULL)) {
8462: if (nameAttr == NULL) {
8463: xmlSchemaPMissingAttrErr(ctxt,
8464: XML_SCHEMAP_S4S_ATTR_MISSING,
8465: NULL, node, "name", NULL);
8466: return (NULL);
8467: }
8468: } else
8469: isRef = 1;
8470:
8471: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8472: child = node->children;
8473: if (IS_SCHEMA(child, "annotation")) {
8474: annot = xmlSchemaParseAnnotation(ctxt, child, 1);
8475: child = child->next;
8476: }
8477: /*
8478: * Skip particle part if a global declaration.
8479: */
8480: if (topLevel)
8481: goto declaration_part;
8482: /*
8483: * The particle part ==================================================
8484: */
8485: min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
8486: max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(xs:nonNegativeInteger | unbounded)");
8487: xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
8488: particle = xmlSchemaAddParticle(ctxt, node, min, max);
8489: if (particle == NULL)
8490: goto return_null;
8491:
8492: /* ret->flags |= XML_SCHEMAS_ELEM_REF; */
8493:
8494: if (isRef) {
8495: const xmlChar *refNs = NULL, *ref = NULL;
8496: xmlSchemaQNameRefPtr refer = NULL;
8497: /*
8498: * The reference part =============================================
8499: */
8500: if (isElemRef != NULL)
8501: *isElemRef = 1;
8502:
8503: xmlSchemaPValAttrNodeQName(ctxt, schema,
8504: NULL, attr, &refNs, &ref);
8505: xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
8506: /*
8507: * SPEC (3.3.3 : 2.1) "One of ref or name must be present, but not both"
8508: */
8509: if (nameAttr != NULL) {
8510: xmlSchemaPMutualExclAttrErr(ctxt,
8511: XML_SCHEMAP_SRC_ELEMENT_2_1, NULL, nameAttr, "ref", "name");
8512: }
8513: /*
8514: * Check for illegal attributes.
8515: */
8516: attr = node->properties;
8517: while (attr != NULL) {
8518: if (attr->ns == NULL) {
8519: if (xmlStrEqual(attr->name, BAD_CAST "ref") ||
8520: xmlStrEqual(attr->name, BAD_CAST "name") ||
8521: xmlStrEqual(attr->name, BAD_CAST "id") ||
8522: xmlStrEqual(attr->name, BAD_CAST "maxOccurs") ||
8523: xmlStrEqual(attr->name, BAD_CAST "minOccurs"))
8524: {
8525: attr = attr->next;
8526: continue;
8527: } else {
8528: /* SPEC (3.3.3 : 2.2) */
8529: xmlSchemaPCustomAttrErr(ctxt,
8530: XML_SCHEMAP_SRC_ELEMENT_2_2,
8531: NULL, NULL, attr,
8532: "Only the attributes 'minOccurs', 'maxOccurs' and "
8533: "'id' are allowed in addition to 'ref'");
8534: break;
8535: }
8536: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
8537: xmlSchemaPIllegalAttrErr(ctxt,
8538: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8539: }
8540: attr = attr->next;
8541: }
8542: /*
8543: * No children except <annotation> expected.
8544: */
8545: if (child != NULL) {
8546: xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8547: NULL, node, child, NULL, "(annotation?)");
8548: }
8549: if ((min == 0) && (max == 0))
8550: goto return_null;
8551: /*
8552: * Create the reference item and attach it to the particle.
8553: */
8554: refer = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_ELEMENT,
8555: ref, refNs);
8556: if (refer == NULL)
8557: goto return_null;
8558: particle->children = (xmlSchemaTreeItemPtr) refer;
8559: particle->annot = annot;
8560: /*
8561: * Add the particle to pending components, since the reference
8562: * need to be resolved.
8563: */
8564: WXS_ADD_PENDING(ctxt, particle);
8565: return ((xmlSchemaBasicItemPtr) particle);
8566: }
8567: /*
8568: * The declaration part ===============================================
8569: */
8570: declaration_part:
8571: {
8572: const xmlChar *ns = NULL, *fixed, *name, *attrValue;
8573: xmlSchemaIDCPtr curIDC = NULL, lastIDC = NULL;
8574:
8575: if (xmlSchemaPValAttrNode(ctxt, NULL, nameAttr,
8576: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0)
8577: goto return_null;
8578: /*
8579: * Evaluate the target namespace.
8580: */
8581: if (topLevel) {
8582: ns = ctxt->targetNamespace;
8583: } else {
8584: attr = xmlSchemaGetPropNode(node, "form");
8585: if (attr != NULL) {
8586: attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8587: if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
8588: ns = ctxt->targetNamespace;
8589: } else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified")) {
8590: xmlSchemaPSimpleTypeErr(ctxt,
8591: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
8592: NULL, (xmlNodePtr) attr,
8593: NULL, "(qualified | unqualified)",
8594: attrValue, NULL, NULL, NULL);
8595: }
8596: } else if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
8597: ns = ctxt->targetNamespace;
8598: }
8599: decl = xmlSchemaAddElement(ctxt, name, ns, node, topLevel);
8600: if (decl == NULL) {
8601: goto return_null;
8602: }
8603: /*
8604: * Check for illegal attributes.
8605: */
8606: attr = node->properties;
8607: while (attr != NULL) {
8608: if (attr->ns == NULL) {
8609: if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
8610: (!xmlStrEqual(attr->name, BAD_CAST "type")) &&
8611: (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8612: (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
8613: (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
8614: (!xmlStrEqual(attr->name, BAD_CAST "block")) &&
8615: (!xmlStrEqual(attr->name, BAD_CAST "nillable")))
8616: {
8617: if (topLevel == 0) {
8618: if ((!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
8619: (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
8620: (!xmlStrEqual(attr->name, BAD_CAST "form")))
8621: {
8622: xmlSchemaPIllegalAttrErr(ctxt,
8623: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8624: }
8625: } else if ((!xmlStrEqual(attr->name, BAD_CAST "final")) &&
8626: (!xmlStrEqual(attr->name, BAD_CAST "abstract")) &&
8627: (!xmlStrEqual(attr->name, BAD_CAST "substitutionGroup"))) {
8628:
8629: xmlSchemaPIllegalAttrErr(ctxt,
8630: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8631: }
8632: }
8633: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
8634:
8635: xmlSchemaPIllegalAttrErr(ctxt,
8636: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8637: }
8638: attr = attr->next;
8639: }
8640: /*
8641: * Extract/validate attributes.
8642: */
8643: if (topLevel) {
8644: /*
8645: * Process top attributes of global element declarations here.
8646: */
8647: decl->flags |= XML_SCHEMAS_ELEM_GLOBAL;
8648: decl->flags |= XML_SCHEMAS_ELEM_TOPLEVEL;
8649: xmlSchemaPValAttrQName(ctxt, schema,
8650: NULL, node, "substitutionGroup",
8651: &(decl->substGroupNs), &(decl->substGroup));
8652: if (xmlGetBooleanProp(ctxt, node, "abstract", 0))
8653: decl->flags |= XML_SCHEMAS_ELEM_ABSTRACT;
8654: /*
8655: * Attribute "final".
8656: */
8657: attr = xmlSchemaGetPropNode(node, "final");
8658: if (attr == NULL) {
8659: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
8660: decl->flags |= XML_SCHEMAS_ELEM_FINAL_EXTENSION;
8661: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
8662: decl->flags |= XML_SCHEMAS_ELEM_FINAL_RESTRICTION;
8663: } else {
8664: attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8665: if (xmlSchemaPValAttrBlockFinal(attrValue, &(decl->flags),
8666: -1,
8667: XML_SCHEMAS_ELEM_FINAL_EXTENSION,
8668: XML_SCHEMAS_ELEM_FINAL_RESTRICTION, -1, -1, -1) != 0) {
8669: xmlSchemaPSimpleTypeErr(ctxt,
8670: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
8671: NULL, (xmlNodePtr) attr,
8672: NULL, "(#all | List of (extension | restriction))",
8673: attrValue, NULL, NULL, NULL);
8674: }
8675: }
8676: }
8677: /*
8678: * Attribute "block".
8679: */
8680: attr = xmlSchemaGetPropNode(node, "block");
8681: if (attr == NULL) {
8682: /*
8683: * Apply default "block" values.
8684: */
8685: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
8686: decl->flags |= XML_SCHEMAS_ELEM_BLOCK_RESTRICTION;
8687: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
8688: decl->flags |= XML_SCHEMAS_ELEM_BLOCK_EXTENSION;
8689: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION)
8690: decl->flags |= XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION;
8691: } else {
8692: attrValue = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8693: if (xmlSchemaPValAttrBlockFinal(attrValue, &(decl->flags),
8694: -1,
8695: XML_SCHEMAS_ELEM_BLOCK_EXTENSION,
8696: XML_SCHEMAS_ELEM_BLOCK_RESTRICTION,
8697: XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION, -1, -1) != 0) {
8698: xmlSchemaPSimpleTypeErr(ctxt,
8699: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
8700: NULL, (xmlNodePtr) attr,
8701: NULL, "(#all | List of (extension | "
8702: "restriction | substitution))", attrValue,
8703: NULL, NULL, NULL);
8704: }
8705: }
8706: if (xmlGetBooleanProp(ctxt, node, "nillable", 0))
8707: decl->flags |= XML_SCHEMAS_ELEM_NILLABLE;
8708:
8709: attr = xmlSchemaGetPropNode(node, "type");
8710: if (attr != NULL) {
8711: xmlSchemaPValAttrNodeQName(ctxt, schema,
8712: NULL, attr,
8713: &(decl->namedTypeNs), &(decl->namedType));
8714: xmlSchemaCheckReference(ctxt, schema, node,
8715: attr, decl->namedTypeNs);
8716: }
8717: decl->value = xmlSchemaGetProp(ctxt, node, "default");
8718: attr = xmlSchemaGetPropNode(node, "fixed");
8719: if (attr != NULL) {
8720: fixed = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8721: if (decl->value != NULL) {
8722: /*
8723: * 3.3.3 : 1
8724: * default and fixed must not both be present.
8725: */
8726: xmlSchemaPMutualExclAttrErr(ctxt,
8727: XML_SCHEMAP_SRC_ELEMENT_1,
8728: NULL, attr, "default", "fixed");
8729: } else {
8730: decl->flags |= XML_SCHEMAS_ELEM_FIXED;
8731: decl->value = fixed;
8732: }
8733: }
8734: /*
8735: * And now for the children...
8736: */
8737: if (IS_SCHEMA(child, "complexType")) {
8738: /*
8739: * 3.3.3 : 3
8740: * "type" and either <simpleType> or <complexType> are mutually
8741: * exclusive
8742: */
8743: if (decl->namedType != NULL) {
8744: xmlSchemaPContentErr(ctxt,
8745: XML_SCHEMAP_SRC_ELEMENT_3,
8746: NULL, node, child,
8747: "The attribute 'type' and the <complexType> child are "
8748: "mutually exclusive", NULL);
8749: } else
8750: WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseComplexType(ctxt, schema, child, 0);
8751: child = child->next;
8752: } else if (IS_SCHEMA(child, "simpleType")) {
8753: /*
8754: * 3.3.3 : 3
8755: * "type" and either <simpleType> or <complexType> are
8756: * mutually exclusive
8757: */
8758: if (decl->namedType != NULL) {
8759: xmlSchemaPContentErr(ctxt,
8760: XML_SCHEMAP_SRC_ELEMENT_3,
8761: NULL, node, child,
8762: "The attribute 'type' and the <simpleType> child are "
8763: "mutually exclusive", NULL);
8764: } else
8765: WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
8766: child = child->next;
8767: }
8768: while ((IS_SCHEMA(child, "unique")) ||
8769: (IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
8770: if (IS_SCHEMA(child, "unique")) {
8771: curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8772: XML_SCHEMA_TYPE_IDC_UNIQUE, decl->targetNamespace);
8773: } else if (IS_SCHEMA(child, "key")) {
8774: curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8775: XML_SCHEMA_TYPE_IDC_KEY, decl->targetNamespace);
8776: } else if (IS_SCHEMA(child, "keyref")) {
8777: curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8778: XML_SCHEMA_TYPE_IDC_KEYREF, decl->targetNamespace);
8779: }
8780: if (lastIDC != NULL)
8781: lastIDC->next = curIDC;
8782: else
8783: decl->idcs = (void *) curIDC;
8784: lastIDC = curIDC;
8785: child = child->next;
8786: }
8787: if (child != NULL) {
8788: xmlSchemaPContentErr(ctxt,
8789: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8790: NULL, node, child,
8791: NULL, "(annotation?, ((simpleType | complexType)?, "
8792: "(unique | key | keyref)*))");
8793: }
8794: decl->annot = annot;
8795: }
8796: /*
8797: * NOTE: Element Declaration Representation OK 4. will be checked at a
8798: * different layer.
8799: */
8800: FREE_AND_NULL(des)
8801: if (topLevel)
8802: return ((xmlSchemaBasicItemPtr) decl);
8803: else {
8804: particle->children = (xmlSchemaTreeItemPtr) decl;
8805: return ((xmlSchemaBasicItemPtr) particle);
8806: }
8807:
8808: return_null:
8809: FREE_AND_NULL(des);
8810: if (annot != NULL) {
8811: if (particle != NULL)
8812: particle->annot = NULL;
8813: if (decl != NULL)
8814: decl->annot = NULL;
8815: xmlSchemaFreeAnnot(annot);
8816: }
8817: return (NULL);
8818: }
8819:
8820: /**
8821: * xmlSchemaParseUnion:
8822: * @ctxt: a schema validation context
8823: * @schema: the schema being built
8824: * @node: a subtree containing XML Schema informations
8825: *
8826: * parse a XML schema Union definition
8827: * *WARNING* this interface is highly subject to change
8828: *
8829: * Returns -1 in case of internal error, 0 in case of success and a positive
8830: * error code otherwise.
8831: */
8832: static int
8833: xmlSchemaParseUnion(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
8834: xmlNodePtr node)
8835: {
8836: xmlSchemaTypePtr type;
8837: xmlNodePtr child = NULL;
8838: xmlAttrPtr attr;
8839: const xmlChar *cur = NULL;
8840:
8841: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
8842: return (-1);
8843: /* Not a component, don't create it. */
8844: type = ctxt->ctxtType;
8845: /*
8846: * Mark the simple type as being of variety "union".
8847: */
8848: type->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
8849: /*
8850: * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
8851: * then the �simple ur-type definition�."
8852: */
8853: type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
8854: /*
8855: * Check for illegal attributes.
8856: */
8857: attr = node->properties;
8858: while (attr != NULL) {
8859: if (attr->ns == NULL) {
8860: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8861: (!xmlStrEqual(attr->name, BAD_CAST "memberTypes"))) {
8862: xmlSchemaPIllegalAttrErr(ctxt,
8863: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8864: }
8865: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
8866: xmlSchemaPIllegalAttrErr(ctxt,
8867: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
8868: }
8869: attr = attr->next;
8870: }
8871: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8872: /*
8873: * Attribute "memberTypes". This is a list of QNames.
8874: * TODO: Check the value to contain anything.
8875: */
8876: attr = xmlSchemaGetPropNode(node, "memberTypes");
8877: if (attr != NULL) {
8878: const xmlChar *end;
8879: xmlChar *tmp;
8880: const xmlChar *localName, *nsName;
8881: xmlSchemaTypeLinkPtr link, lastLink = NULL;
8882: xmlSchemaQNameRefPtr ref;
8883:
8884: cur = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
8885: type->base = cur;
8886: do {
8887: while (IS_BLANK_CH(*cur))
8888: cur++;
8889: end = cur;
8890: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
8891: end++;
8892: if (end == cur)
8893: break;
8894: tmp = xmlStrndup(cur, end - cur);
8895: if (xmlSchemaPValAttrNodeQNameValue(ctxt, schema,
8896: NULL, attr, BAD_CAST tmp, &nsName, &localName) == 0) {
8897: /*
8898: * Create the member type link.
8899: */
8900: link = (xmlSchemaTypeLinkPtr)
8901: xmlMalloc(sizeof(xmlSchemaTypeLink));
8902: if (link == NULL) {
8903: xmlSchemaPErrMemory(ctxt, "xmlSchemaParseUnion, "
8904: "allocating a type link", NULL);
8905: return (-1);
8906: }
8907: link->type = NULL;
8908: link->next = NULL;
8909: if (lastLink == NULL)
8910: type->memberTypes = link;
8911: else
8912: lastLink->next = link;
8913: lastLink = link;
8914: /*
8915: * Create a reference item.
8916: */
8917: ref = xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_SIMPLE,
8918: localName, nsName);
8919: if (ref == NULL) {
8920: FREE_AND_NULL(tmp)
8921: return (-1);
8922: }
8923: /*
8924: * Assign the reference to the link, it will be resolved
8925: * later during fixup of the union simple type.
8926: */
8927: link->type = (xmlSchemaTypePtr) ref;
8928: }
8929: FREE_AND_NULL(tmp)
8930: cur = end;
8931: } while (*cur != 0);
8932:
8933: }
8934: /*
8935: * And now for the children...
8936: */
8937: child = node->children;
8938: if (IS_SCHEMA(child, "annotation")) {
8939: /*
8940: * Add the annotation to the simple type ancestor.
8941: */
8942: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
8943: xmlSchemaParseAnnotation(ctxt, child, 1));
8944: child = child->next;
8945: }
8946: if (IS_SCHEMA(child, "simpleType")) {
8947: xmlSchemaTypePtr subtype, last = NULL;
8948:
8949: /*
8950: * Anchor the member types in the "subtypes" field of the
8951: * simple type.
8952: */
8953: while (IS_SCHEMA(child, "simpleType")) {
8954: subtype = (xmlSchemaTypePtr)
8955: xmlSchemaParseSimpleType(ctxt, schema, child, 0);
8956: if (subtype != NULL) {
8957: if (last == NULL) {
8958: type->subtypes = subtype;
8959: last = subtype;
8960: } else {
8961: last->next = subtype;
8962: last = subtype;
8963: }
8964: last->next = NULL;
8965: }
8966: child = child->next;
8967: }
8968: }
8969: if (child != NULL) {
8970: xmlSchemaPContentErr(ctxt,
8971: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
8972: NULL, node, child, NULL, "(annotation?, simpleType*)");
8973: }
8974: if ((attr == NULL) && (type->subtypes == NULL)) {
8975: /*
8976: * src-union-memberTypes-or-simpleTypes
8977: * Either the memberTypes [attribute] of the <union> element must
8978: * be non-empty or there must be at least one simpleType [child].
8979: */
8980: xmlSchemaPCustomErr(ctxt,
8981: XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
8982: NULL, node,
8983: "Either the attribute 'memberTypes' or "
8984: "at least one <simpleType> child must be present", NULL);
8985: }
8986: return (0);
8987: }
8988:
8989: /**
8990: * xmlSchemaParseList:
8991: * @ctxt: a schema validation context
8992: * @schema: the schema being built
8993: * @node: a subtree containing XML Schema informations
8994: *
8995: * parse a XML schema List definition
8996: * *WARNING* this interface is highly subject to change
8997: *
8998: * Returns -1 in case of error, 0 if the declaration is improper and
8999: * 1 in case of success.
9000: */
9001: static xmlSchemaTypePtr
9002: xmlSchemaParseList(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
9003: xmlNodePtr node)
9004: {
9005: xmlSchemaTypePtr type;
9006: xmlNodePtr child = NULL;
9007: xmlAttrPtr attr;
9008:
9009: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9010: return (NULL);
9011: /* Not a component, don't create it. */
9012: type = ctxt->ctxtType;
9013: /*
9014: * Mark the type as being of variety "list".
9015: */
9016: type->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
9017: /*
9018: * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
9019: * then the �simple ur-type definition�."
9020: */
9021: type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
9022: /*
9023: * Check for illegal attributes.
9024: */
9025: attr = node->properties;
9026: while (attr != NULL) {
9027: if (attr->ns == NULL) {
9028: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9029: (!xmlStrEqual(attr->name, BAD_CAST "itemType"))) {
9030: xmlSchemaPIllegalAttrErr(ctxt,
9031: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9032: }
9033: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
9034: xmlSchemaPIllegalAttrErr(ctxt,
9035: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9036: }
9037: attr = attr->next;
9038: }
9039:
9040: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9041:
9042: /*
9043: * Attribute "itemType". NOTE that we will use the "ref" and "refNs"
9044: * fields for holding the reference to the itemType.
9045: *
9046: * REVAMP TODO: Use the "base" and "baseNs" fields, since we will remove
9047: * the "ref" fields.
9048: */
9049: xmlSchemaPValAttrQName(ctxt, schema, NULL,
9050: node, "itemType", &(type->baseNs), &(type->base));
9051: /*
9052: * And now for the children...
9053: */
9054: child = node->children;
9055: if (IS_SCHEMA(child, "annotation")) {
9056: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
9057: xmlSchemaParseAnnotation(ctxt, child, 1));
9058: child = child->next;
9059: }
9060: if (IS_SCHEMA(child, "simpleType")) {
9061: /*
9062: * src-list-itemType-or-simpleType
9063: * Either the itemType [attribute] or the <simpleType> [child] of
9064: * the <list> element must be present, but not both.
9065: */
9066: if (type->base != NULL) {
9067: xmlSchemaPCustomErr(ctxt,
9068: XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
9069: NULL, node,
9070: "The attribute 'itemType' and the <simpleType> child "
9071: "are mutually exclusive", NULL);
9072: } else {
9073: type->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
9074: }
9075: child = child->next;
9076: } else if (type->base == NULL) {
9077: xmlSchemaPCustomErr(ctxt,
9078: XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
9079: NULL, node,
9080: "Either the attribute 'itemType' or the <simpleType> child "
9081: "must be present", NULL);
9082: }
9083: if (child != NULL) {
9084: xmlSchemaPContentErr(ctxt,
9085: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
9086: NULL, node, child, NULL, "(annotation?, simpleType?)");
9087: }
9088: if ((type->base == NULL) &&
9089: (type->subtypes == NULL) &&
9090: (xmlSchemaGetPropNode(node, "itemType") == NULL)) {
9091: xmlSchemaPCustomErr(ctxt,
9092: XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
9093: NULL, node,
9094: "Either the attribute 'itemType' or the <simpleType> child "
9095: "must be present", NULL);
9096: }
9097: return (NULL);
9098: }
9099:
9100: /**
9101: * xmlSchemaParseSimpleType:
9102: * @ctxt: a schema validation context
9103: * @schema: the schema being built
9104: * @node: a subtree containing XML Schema informations
9105: *
9106: * parse a XML schema Simple Type definition
9107: * *WARNING* this interface is highly subject to change
9108: *
9109: * Returns -1 in case of error, 0 if the declaration is improper and
9110: * 1 in case of success.
9111: */
9112: static xmlSchemaTypePtr
9113: xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
9114: xmlNodePtr node, int topLevel)
9115: {
9116: xmlSchemaTypePtr type, oldCtxtType;
9117: xmlNodePtr child = NULL;
9118: const xmlChar *attrValue = NULL;
9119: xmlAttrPtr attr;
9120: int hasRestriction = 0;
9121:
9122: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9123: return (NULL);
9124:
9125: if (topLevel) {
9126: attr = xmlSchemaGetPropNode(node, "name");
9127: if (attr == NULL) {
9128: xmlSchemaPMissingAttrErr(ctxt,
9129: XML_SCHEMAP_S4S_ATTR_MISSING,
9130: NULL, node,
9131: "name", NULL);
9132: return (NULL);
9133: } else {
9134: if (xmlSchemaPValAttrNode(ctxt,
9135: NULL, attr,
9136: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &attrValue) != 0)
9137: return (NULL);
9138: /*
9139: * Skip built-in types.
9140: */
9141: if (ctxt->isS4S) {
9142: xmlSchemaTypePtr biType;
9143:
9144: if (ctxt->isRedefine) {
9145: /*
9146: * REDEFINE: Disallow redefinition of built-in-types.
9147: * TODO: It seems that the spec does not say anything
9148: * about this case.
9149: */
9150: xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
9151: NULL, node,
9152: "Redefinition of built-in simple types is not "
9153: "supported", NULL);
9154: return(NULL);
9155: }
9156: biType = xmlSchemaGetPredefinedType(attrValue, xmlSchemaNs);
9157: if (biType != NULL)
9158: return (biType);
9159: }
9160: }
9161: }
9162: /*
9163: * TargetNamespace:
9164: * SPEC "The �actual value� of the targetNamespace [attribute]
9165: * of the <schema> ancestor element information item if present,
9166: * otherwise �absent�.
9167: */
9168: if (topLevel == 0) {
9169: #ifdef ENABLE_NAMED_LOCALS
9170: char buf[40];
9171: #endif
9172: /*
9173: * Parse as local simple type definition.
9174: */
9175: #ifdef ENABLE_NAMED_LOCALS
9176: snprintf(buf, 39, "#ST%d", ctxt->counter++ + 1);
9177: type = xmlSchemaAddType(ctxt, schema,
9178: XML_SCHEMA_TYPE_SIMPLE,
9179: xmlDictLookup(ctxt->dict, (const xmlChar *)buf, -1),
9180: ctxt->targetNamespace, node, 0);
9181: #else
9182: type = xmlSchemaAddType(ctxt, schema,
9183: XML_SCHEMA_TYPE_SIMPLE,
9184: NULL, ctxt->targetNamespace, node, 0);
9185: #endif
9186: if (type == NULL)
9187: return (NULL);
9188: type->type = XML_SCHEMA_TYPE_SIMPLE;
9189: type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
9190: /*
9191: * Check for illegal attributes.
9192: */
9193: attr = node->properties;
9194: while (attr != NULL) {
9195: if (attr->ns == NULL) {
9196: if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
9197: xmlSchemaPIllegalAttrErr(ctxt,
9198: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9199: }
9200: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
9201: xmlSchemaPIllegalAttrErr(ctxt,
9202: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9203: }
9204: attr = attr->next;
9205: }
9206: } else {
9207: /*
9208: * Parse as global simple type definition.
9209: *
9210: * Note that attrValue is the value of the attribute "name" here.
9211: */
9212: type = xmlSchemaAddType(ctxt, schema, XML_SCHEMA_TYPE_SIMPLE,
9213: attrValue, ctxt->targetNamespace, node, 1);
9214: if (type == NULL)
9215: return (NULL);
9216: type->type = XML_SCHEMA_TYPE_SIMPLE;
9217: type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
9218: type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
9219: /*
9220: * Check for illegal attributes.
9221: */
9222: attr = node->properties;
9223: while (attr != NULL) {
9224: if (attr->ns == NULL) {
9225: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9226: (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
9227: (!xmlStrEqual(attr->name, BAD_CAST "final"))) {
9228: xmlSchemaPIllegalAttrErr(ctxt,
9229: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9230: }
9231: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
9232: xmlSchemaPIllegalAttrErr(ctxt,
9233: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9234: }
9235: attr = attr->next;
9236: }
9237: /*
9238: * Attribute "final".
9239: */
9240: attr = xmlSchemaGetPropNode(node, "final");
9241: if (attr == NULL) {
9242: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
9243: type->flags |= XML_SCHEMAS_TYPE_FINAL_RESTRICTION;
9244: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_LIST)
9245: type->flags |= XML_SCHEMAS_TYPE_FINAL_LIST;
9246: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_UNION)
9247: type->flags |= XML_SCHEMAS_TYPE_FINAL_UNION;
9248: } else {
9249: attrValue = xmlSchemaGetProp(ctxt, node, "final");
9250: if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
9251: -1, -1, XML_SCHEMAS_TYPE_FINAL_RESTRICTION, -1,
9252: XML_SCHEMAS_TYPE_FINAL_LIST,
9253: XML_SCHEMAS_TYPE_FINAL_UNION) != 0) {
9254:
9255: xmlSchemaPSimpleTypeErr(ctxt,
9256: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
9257: WXS_BASIC_CAST type, (xmlNodePtr) attr,
9258: NULL, "(#all | List of (list | union | restriction)",
9259: attrValue, NULL, NULL, NULL);
9260: }
9261: }
9262: }
9263: type->targetNamespace = ctxt->targetNamespace;
9264: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9265: /*
9266: * And now for the children...
9267: */
9268: oldCtxtType = ctxt->ctxtType;
9269:
9270: ctxt->ctxtType = type;
9271:
9272: child = node->children;
9273: if (IS_SCHEMA(child, "annotation")) {
9274: type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9275: child = child->next;
9276: }
9277: if (child == NULL) {
9278: xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_MISSING,
9279: NULL, node, child, NULL,
9280: "(annotation?, (restriction | list | union))");
9281: } else if (IS_SCHEMA(child, "restriction")) {
9282: xmlSchemaParseRestriction(ctxt, schema, child,
9283: XML_SCHEMA_TYPE_SIMPLE);
9284: hasRestriction = 1;
9285: child = child->next;
9286: } else if (IS_SCHEMA(child, "list")) {
9287: xmlSchemaParseList(ctxt, schema, child);
9288: child = child->next;
9289: } else if (IS_SCHEMA(child, "union")) {
9290: xmlSchemaParseUnion(ctxt, schema, child);
9291: child = child->next;
9292: }
9293: if (child != NULL) {
9294: xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
9295: NULL, node, child, NULL,
9296: "(annotation?, (restriction | list | union))");
9297: }
9298: /*
9299: * REDEFINE: SPEC src-redefine (5)
9300: * "Within the [children], each <simpleType> must have a
9301: * <restriction> among its [children] ... the �actual value� of whose
9302: * base [attribute] must be the same as the �actual value� of its own
9303: * name attribute plus target namespace;"
9304: */
9305: if (topLevel && ctxt->isRedefine && (! hasRestriction)) {
9306: xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
9307: NULL, node, "This is a redefinition, thus the "
9308: "<simpleType> must have a <restriction> child", NULL);
9309: }
9310:
9311: ctxt->ctxtType = oldCtxtType;
9312: return (type);
9313: }
9314:
9315: /**
9316: * xmlSchemaParseModelGroupDefRef:
9317: * @ctxt: the parser context
9318: * @schema: the schema being built
9319: * @node: the node
9320: *
9321: * Parses a reference to a model group definition.
9322: *
9323: * We will return a particle component with a qname-component or
9324: * NULL in case of an error.
9325: */
9326: static xmlSchemaTreeItemPtr
9327: xmlSchemaParseModelGroupDefRef(xmlSchemaParserCtxtPtr ctxt,
9328: xmlSchemaPtr schema,
9329: xmlNodePtr node)
9330: {
9331: xmlSchemaParticlePtr item;
9332: xmlNodePtr child = NULL;
9333: xmlAttrPtr attr;
9334: const xmlChar *ref = NULL, *refNs = NULL;
9335: int min, max;
9336:
9337: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9338: return (NULL);
9339:
9340: attr = xmlSchemaGetPropNode(node, "ref");
9341: if (attr == NULL) {
9342: xmlSchemaPMissingAttrErr(ctxt,
9343: XML_SCHEMAP_S4S_ATTR_MISSING,
9344: NULL, node, "ref", NULL);
9345: return (NULL);
9346: } else if (xmlSchemaPValAttrNodeQName(ctxt, schema, NULL,
9347: attr, &refNs, &ref) != 0) {
9348: return (NULL);
9349: }
9350: xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
9351: min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
9352: max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
9353: "(xs:nonNegativeInteger | unbounded)");
9354: /*
9355: * Check for illegal attributes.
9356: */
9357: attr = node->properties;
9358: while (attr != NULL) {
9359: if (attr->ns == NULL) {
9360: if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
9361: (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9362: (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
9363: (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs"))) {
9364: xmlSchemaPIllegalAttrErr(ctxt,
9365: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9366: }
9367: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
9368: xmlSchemaPIllegalAttrErr(ctxt,
9369: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9370: }
9371: attr = attr->next;
9372: }
9373: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9374: item = xmlSchemaAddParticle(ctxt, node, min, max);
9375: if (item == NULL)
9376: return (NULL);
9377: /*
9378: * Create a qname-reference and set as the term; it will be substituted
9379: * for the model group after the reference has been resolved.
9380: */
9381: item->children = (xmlSchemaTreeItemPtr)
9382: xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_GROUP, ref, refNs);
9383: xmlSchemaPCheckParticleCorrect_2(ctxt, item, node, min, max);
9384: /*
9385: * And now for the children...
9386: */
9387: child = node->children;
9388: /* TODO: Is annotation even allowed for a model group reference? */
9389: if (IS_SCHEMA(child, "annotation")) {
9390: /*
9391: * TODO: What to do exactly with the annotation?
9392: */
9393: item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9394: child = child->next;
9395: }
9396: if (child != NULL) {
9397: xmlSchemaPContentErr(ctxt,
9398: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
9399: NULL, node, child, NULL,
9400: "(annotation?)");
9401: }
9402: /*
9403: * Corresponds to no component at all if minOccurs==maxOccurs==0.
9404: */
9405: if ((min == 0) && (max == 0))
9406: return (NULL);
9407:
9408: return ((xmlSchemaTreeItemPtr) item);
9409: }
9410:
9411: /**
9412: * xmlSchemaParseModelGroupDefinition:
9413: * @ctxt: a schema validation context
9414: * @schema: the schema being built
9415: * @node: a subtree containing XML Schema informations
9416: *
9417: * Parses a XML schema model group definition.
9418: *
9419: * Note that the contraint src-redefine (6.2) can't be applied until
9420: * references have been resolved. So we will do this at the
9421: * component fixup level.
9422: *
9423: * *WARNING* this interface is highly subject to change
9424: *
9425: * Returns -1 in case of error, 0 if the declaration is improper and
9426: * 1 in case of success.
9427: */
9428: static xmlSchemaModelGroupDefPtr
9429: xmlSchemaParseModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
9430: xmlSchemaPtr schema,
9431: xmlNodePtr node)
9432: {
9433: xmlSchemaModelGroupDefPtr item;
9434: xmlNodePtr child = NULL;
9435: xmlAttrPtr attr;
9436: const xmlChar *name;
9437:
9438: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9439: return (NULL);
9440:
9441: attr = xmlSchemaGetPropNode(node, "name");
9442: if (attr == NULL) {
9443: xmlSchemaPMissingAttrErr(ctxt,
9444: XML_SCHEMAP_S4S_ATTR_MISSING,
9445: NULL, node,
9446: "name", NULL);
9447: return (NULL);
9448: } else if (xmlSchemaPValAttrNode(ctxt, NULL, attr,
9449: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
9450: return (NULL);
9451: }
9452: item = xmlSchemaAddModelGroupDefinition(ctxt, schema, name,
9453: ctxt->targetNamespace, node);
9454: if (item == NULL)
9455: return (NULL);
9456: /*
9457: * Check for illegal attributes.
9458: */
9459: attr = node->properties;
9460: while (attr != NULL) {
9461: if (attr->ns == NULL) {
9462: if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
9463: (!xmlStrEqual(attr->name, BAD_CAST "id"))) {
9464: xmlSchemaPIllegalAttrErr(ctxt,
9465: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9466: }
9467: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
9468: xmlSchemaPIllegalAttrErr(ctxt,
9469: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
9470: }
9471: attr = attr->next;
9472: }
9473: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9474: /*
9475: * And now for the children...
9476: */
9477: child = node->children;
9478: if (IS_SCHEMA(child, "annotation")) {
9479: item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9480: child = child->next;
9481: }
9482: if (IS_SCHEMA(child, "all")) {
9483: item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9484: XML_SCHEMA_TYPE_ALL, 0);
9485: child = child->next;
9486: } else if (IS_SCHEMA(child, "choice")) {
9487: item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9488: XML_SCHEMA_TYPE_CHOICE, 0);
9489: child = child->next;
9490: } else if (IS_SCHEMA(child, "sequence")) {
9491: item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9492: XML_SCHEMA_TYPE_SEQUENCE, 0);
9493: child = child->next;
9494: }
9495:
9496:
9497:
9498: if (child != NULL) {
9499: xmlSchemaPContentErr(ctxt,
9500: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
9501: NULL, node, child, NULL,
9502: "(annotation?, (all | choice | sequence)?)");
9503: }
9504: return (item);
9505: }
9506:
9507: /**
9508: * xmlSchemaCleanupDoc:
9509: * @ctxt: a schema validation context
9510: * @node: the root of the document.
9511: *
9512: * removes unwanted nodes in a schemas document tree
9513: */
9514: static void
9515: xmlSchemaCleanupDoc(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr root)
9516: {
9517: xmlNodePtr delete, cur;
9518:
9519: if ((ctxt == NULL) || (root == NULL)) return;
9520:
9521: /*
9522: * Remove all the blank text nodes
9523: */
9524: delete = NULL;
9525: cur = root;
9526: while (cur != NULL) {
9527: if (delete != NULL) {
9528: xmlUnlinkNode(delete);
9529: xmlFreeNode(delete);
9530: delete = NULL;
9531: }
9532: if (cur->type == XML_TEXT_NODE) {
9533: if (IS_BLANK_NODE(cur)) {
9534: if (xmlNodeGetSpacePreserve(cur) != 1) {
9535: delete = cur;
9536: }
9537: }
9538: } else if ((cur->type != XML_ELEMENT_NODE) &&
9539: (cur->type != XML_CDATA_SECTION_NODE)) {
9540: delete = cur;
9541: goto skip_children;
9542: }
9543:
9544: /*
9545: * Skip to next node
9546: */
9547: if (cur->children != NULL) {
9548: if ((cur->children->type != XML_ENTITY_DECL) &&
9549: (cur->children->type != XML_ENTITY_REF_NODE) &&
9550: (cur->children->type != XML_ENTITY_NODE)) {
9551: cur = cur->children;
9552: continue;
9553: }
9554: }
9555: skip_children:
9556: if (cur->next != NULL) {
9557: cur = cur->next;
9558: continue;
9559: }
9560:
9561: do {
9562: cur = cur->parent;
9563: if (cur == NULL)
9564: break;
9565: if (cur == root) {
9566: cur = NULL;
9567: break;
9568: }
9569: if (cur->next != NULL) {
9570: cur = cur->next;
9571: break;
9572: }
9573: } while (cur != NULL);
9574: }
9575: if (delete != NULL) {
9576: xmlUnlinkNode(delete);
9577: xmlFreeNode(delete);
9578: delete = NULL;
9579: }
9580: }
9581:
9582:
9583: static void
9584: xmlSchemaClearSchemaDefaults(xmlSchemaPtr schema)
9585: {
9586: if (schema->flags & XML_SCHEMAS_QUALIF_ELEM)
9587: schema->flags ^= XML_SCHEMAS_QUALIF_ELEM;
9588:
9589: if (schema->flags & XML_SCHEMAS_QUALIF_ATTR)
9590: schema->flags ^= XML_SCHEMAS_QUALIF_ATTR;
9591:
9592: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
9593: schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_EXTENSION;
9594: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
9595: schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION;
9596: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_LIST)
9597: schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_LIST;
9598: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_UNION)
9599: schema->flags ^= XML_SCHEMAS_FINAL_DEFAULT_UNION;
9600:
9601: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
9602: schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION;
9603: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
9604: schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION;
9605: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION)
9606: schema->flags ^= XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION;
9607: }
9608:
9609: static int
9610: xmlSchemaParseSchemaElement(xmlSchemaParserCtxtPtr ctxt,
9611: xmlSchemaPtr schema,
9612: xmlNodePtr node)
9613: {
9614: xmlAttrPtr attr;
9615: const xmlChar *val;
9616: int res = 0, oldErrs = ctxt->nberrors;
9617:
9618: /*
9619: * Those flags should be moved to the parser context flags,
9620: * since they are not visible at the component level. I.e.
9621: * they are used if processing schema *documents* only.
9622: */
9623: res = xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9624: HFAILURE;
9625:
9626: /*
9627: * Since the version is of type xs:token, we won't bother to
9628: * check it.
9629: */
9630: /* REMOVED:
9631: attr = xmlSchemaGetPropNode(node, "version");
9632: if (attr != NULL) {
9633: res = xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
9634: xmlSchemaGetBuiltInType(XML_SCHEMAS_TOKEN), &val);
9635: HFAILURE;
9636: }
9637: */
9638: attr = xmlSchemaGetPropNode(node, "targetNamespace");
9639: if (attr != NULL) {
9640: res = xmlSchemaPValAttrNode(ctxt, NULL, attr,
9641: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
9642: HFAILURE;
9643: if (res != 0) {
9644: ctxt->stop = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
9645: goto exit;
9646: }
9647: }
9648: attr = xmlSchemaGetPropNode(node, "elementFormDefault");
9649: if (attr != NULL) {
9650: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
9651: res = xmlSchemaPValAttrFormDefault(val, &schema->flags,
9652: XML_SCHEMAS_QUALIF_ELEM);
9653: HFAILURE;
9654: if (res != 0) {
9655: xmlSchemaPSimpleTypeErr(ctxt,
9656: XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
9657: NULL, (xmlNodePtr) attr, NULL,
9658: "(qualified | unqualified)", val, NULL, NULL, NULL);
9659: }
9660: }
9661: attr = xmlSchemaGetPropNode(node, "attributeFormDefault");
9662: if (attr != NULL) {
9663: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
9664: res = xmlSchemaPValAttrFormDefault(val, &schema->flags,
9665: XML_SCHEMAS_QUALIF_ATTR);
9666: HFAILURE;
9667: if (res != 0) {
9668: xmlSchemaPSimpleTypeErr(ctxt,
9669: XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
9670: NULL, (xmlNodePtr) attr, NULL,
9671: "(qualified | unqualified)", val, NULL, NULL, NULL);
9672: }
9673: }
9674: attr = xmlSchemaGetPropNode(node, "finalDefault");
9675: if (attr != NULL) {
9676: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
9677: res = xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
9678: XML_SCHEMAS_FINAL_DEFAULT_EXTENSION,
9679: XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION,
9680: -1,
9681: XML_SCHEMAS_FINAL_DEFAULT_LIST,
9682: XML_SCHEMAS_FINAL_DEFAULT_UNION);
9683: HFAILURE;
9684: if (res != 0) {
9685: xmlSchemaPSimpleTypeErr(ctxt,
9686: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
9687: NULL, (xmlNodePtr) attr, NULL,
9688: "(#all | List of (extension | restriction | list | union))",
9689: val, NULL, NULL, NULL);
9690: }
9691: }
9692: attr = xmlSchemaGetPropNode(node, "blockDefault");
9693: if (attr != NULL) {
9694: val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
9695: res = xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
9696: XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION,
9697: XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION,
9698: XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION, -1, -1);
9699: HFAILURE;
9700: if (res != 0) {
9701: xmlSchemaPSimpleTypeErr(ctxt,
9702: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
9703: NULL, (xmlNodePtr) attr, NULL,
9704: "(#all | List of (extension | restriction | substitution))",
9705: val, NULL, NULL, NULL);
9706: }
9707: }
9708:
9709: exit:
9710: if (oldErrs != ctxt->nberrors)
9711: res = ctxt->err;
9712: return(res);
9713: exit_failure:
9714: return(-1);
9715: }
9716:
9717: /**
9718: * xmlSchemaParseSchemaTopLevel:
9719: * @ctxt: a schema validation context
9720: * @schema: the schemas
9721: * @nodes: the list of top level nodes
9722: *
9723: * Returns the internal XML Schema structure built from the resource or
9724: * NULL in case of error
9725: */
9726: static int
9727: xmlSchemaParseSchemaTopLevel(xmlSchemaParserCtxtPtr ctxt,
9728: xmlSchemaPtr schema, xmlNodePtr nodes)
9729: {
9730: xmlNodePtr child;
9731: xmlSchemaAnnotPtr annot;
9732: int res = 0, oldErrs, tmpOldErrs;
9733:
9734: if ((ctxt == NULL) || (schema == NULL) || (nodes == NULL))
9735: return(-1);
9736:
9737: oldErrs = ctxt->nberrors;
9738: child = nodes;
9739: while ((IS_SCHEMA(child, "include")) ||
9740: (IS_SCHEMA(child, "import")) ||
9741: (IS_SCHEMA(child, "redefine")) ||
9742: (IS_SCHEMA(child, "annotation"))) {
9743: if (IS_SCHEMA(child, "annotation")) {
9744: annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9745: if (schema->annot == NULL)
9746: schema->annot = annot;
9747: else
9748: xmlSchemaFreeAnnot(annot);
9749: } else if (IS_SCHEMA(child, "import")) {
9750: tmpOldErrs = ctxt->nberrors;
9751: res = xmlSchemaParseImport(ctxt, schema, child);
9752: HFAILURE;
9753: HSTOP(ctxt);
9754: if (tmpOldErrs != ctxt->nberrors)
9755: goto exit;
9756: } else if (IS_SCHEMA(child, "include")) {
9757: tmpOldErrs = ctxt->nberrors;
9758: res = xmlSchemaParseInclude(ctxt, schema, child);
9759: HFAILURE;
9760: HSTOP(ctxt);
9761: if (tmpOldErrs != ctxt->nberrors)
9762: goto exit;
9763: } else if (IS_SCHEMA(child, "redefine")) {
9764: tmpOldErrs = ctxt->nberrors;
9765: res = xmlSchemaParseRedefine(ctxt, schema, child);
9766: HFAILURE;
9767: HSTOP(ctxt);
9768: if (tmpOldErrs != ctxt->nberrors)
9769: goto exit;
9770: }
9771: child = child->next;
9772: }
9773: /*
9774: * URGENT TODO: Change the functions to return int results.
9775: * We need especially to catch internal errors.
9776: */
9777: while (child != NULL) {
9778: if (IS_SCHEMA(child, "complexType")) {
9779: xmlSchemaParseComplexType(ctxt, schema, child, 1);
9780: child = child->next;
9781: } else if (IS_SCHEMA(child, "simpleType")) {
9782: xmlSchemaParseSimpleType(ctxt, schema, child, 1);
9783: child = child->next;
9784: } else if (IS_SCHEMA(child, "element")) {
9785: xmlSchemaParseElement(ctxt, schema, child, NULL, 1);
9786: child = child->next;
9787: } else if (IS_SCHEMA(child, "attribute")) {
9788: xmlSchemaParseGlobalAttribute(ctxt, schema, child);
9789: child = child->next;
9790: } else if (IS_SCHEMA(child, "attributeGroup")) {
9791: xmlSchemaParseAttributeGroupDefinition(ctxt, schema, child);
9792: child = child->next;
9793: } else if (IS_SCHEMA(child, "group")) {
9794: xmlSchemaParseModelGroupDefinition(ctxt, schema, child);
9795: child = child->next;
9796: } else if (IS_SCHEMA(child, "notation")) {
9797: xmlSchemaParseNotation(ctxt, schema, child);
9798: child = child->next;
9799: } else {
9800: xmlSchemaPContentErr(ctxt,
9801: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
9802: NULL, child->parent, child,
9803: NULL, "((include | import | redefine | annotation)*, "
9804: "(((simpleType | complexType | group | attributeGroup) "
9805: "| element | attribute | notation), annotation*)*)");
9806: child = child->next;
9807: }
9808: while (IS_SCHEMA(child, "annotation")) {
9809: /*
9810: * TODO: We should add all annotations.
9811: */
9812: annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9813: if (schema->annot == NULL)
9814: schema->annot = annot;
9815: else
9816: xmlSchemaFreeAnnot(annot);
9817: child = child->next;
9818: }
9819: }
9820: exit:
9821: ctxt->ctxtType = NULL;
9822: if (oldErrs != ctxt->nberrors)
9823: res = ctxt->err;
9824: return(res);
9825: exit_failure:
9826: return(-1);
9827: }
9828:
9829: static xmlSchemaSchemaRelationPtr
9830: xmlSchemaSchemaRelationCreate(void)
9831: {
9832: xmlSchemaSchemaRelationPtr ret;
9833:
9834: ret = (xmlSchemaSchemaRelationPtr)
9835: xmlMalloc(sizeof(xmlSchemaSchemaRelation));
9836: if (ret == NULL) {
9837: xmlSchemaPErrMemory(NULL, "allocating schema relation", NULL);
9838: return(NULL);
9839: }
9840: memset(ret, 0, sizeof(xmlSchemaSchemaRelation));
9841: return(ret);
9842: }
9843:
9844: #if 0
9845: static void
9846: xmlSchemaSchemaRelationFree(xmlSchemaSchemaRelationPtr rel)
9847: {
9848: xmlFree(rel);
9849: }
9850: #endif
9851:
9852: static void
9853: xmlSchemaRedefListFree(xmlSchemaRedefPtr redef)
9854: {
9855: xmlSchemaRedefPtr prev;
9856:
9857: while (redef != NULL) {
9858: prev = redef;
9859: redef = redef->next;
9860: xmlFree(prev);
9861: }
9862: }
9863:
9864: static void
9865: xmlSchemaConstructionCtxtFree(xmlSchemaConstructionCtxtPtr con)
9866: {
9867: /*
9868: * After the construction context has been freed, there will be
9869: * no schema graph available any more. Only the schema buckets
9870: * will stay alive, which are put into the "schemasImports" and
9871: * "includes" slots of the xmlSchema.
9872: */
9873: if (con->buckets != NULL)
9874: xmlSchemaItemListFree(con->buckets);
9875: if (con->pending != NULL)
9876: xmlSchemaItemListFree(con->pending);
9877: if (con->substGroups != NULL)
9878: xmlHashFree(con->substGroups,
9879: (xmlHashDeallocator) xmlSchemaSubstGroupFree);
9880: if (con->redefs != NULL)
9881: xmlSchemaRedefListFree(con->redefs);
9882: if (con->dict != NULL)
9883: xmlDictFree(con->dict);
9884: xmlFree(con);
9885: }
9886:
9887: static xmlSchemaConstructionCtxtPtr
9888: xmlSchemaConstructionCtxtCreate(xmlDictPtr dict)
9889: {
9890: xmlSchemaConstructionCtxtPtr ret;
9891:
9892: ret = (xmlSchemaConstructionCtxtPtr)
9893: xmlMalloc(sizeof(xmlSchemaConstructionCtxt));
9894: if (ret == NULL) {
9895: xmlSchemaPErrMemory(NULL,
9896: "allocating schema construction context", NULL);
9897: return (NULL);
9898: }
9899: memset(ret, 0, sizeof(xmlSchemaConstructionCtxt));
9900:
9901: ret->buckets = xmlSchemaItemListCreate();
9902: if (ret->buckets == NULL) {
9903: xmlSchemaPErrMemory(NULL,
9904: "allocating list of schema buckets", NULL);
9905: xmlFree(ret);
9906: return (NULL);
9907: }
9908: ret->pending = xmlSchemaItemListCreate();
9909: if (ret->pending == NULL) {
9910: xmlSchemaPErrMemory(NULL,
9911: "allocating list of pending global components", NULL);
9912: xmlSchemaConstructionCtxtFree(ret);
9913: return (NULL);
9914: }
9915: ret->dict = dict;
9916: xmlDictReference(dict);
9917: return(ret);
9918: }
9919:
9920: static xmlSchemaParserCtxtPtr
9921: xmlSchemaParserCtxtCreate(void)
9922: {
9923: xmlSchemaParserCtxtPtr ret;
9924:
9925: ret = (xmlSchemaParserCtxtPtr) xmlMalloc(sizeof(xmlSchemaParserCtxt));
9926: if (ret == NULL) {
9927: xmlSchemaPErrMemory(NULL, "allocating schema parser context",
9928: NULL);
9929: return (NULL);
9930: }
9931: memset(ret, 0, sizeof(xmlSchemaParserCtxt));
9932: ret->type = XML_SCHEMA_CTXT_PARSER;
9933: ret->attrProhibs = xmlSchemaItemListCreate();
9934: if (ret->attrProhibs == NULL) {
9935: xmlFree(ret);
9936: return(NULL);
9937: }
9938: return(ret);
9939: }
9940:
9941: /**
9942: * xmlSchemaNewParserCtxtUseDict:
9943: * @URL: the location of the schema
9944: * @dict: the dictionary to be used
9945: *
9946: * Create an XML Schemas parse context for that file/resource expected
9947: * to contain an XML Schemas file.
9948: *
9949: * Returns the parser context or NULL in case of error
9950: */
9951: static xmlSchemaParserCtxtPtr
9952: xmlSchemaNewParserCtxtUseDict(const char *URL, xmlDictPtr dict)
9953: {
9954: xmlSchemaParserCtxtPtr ret;
9955:
9956: ret = xmlSchemaParserCtxtCreate();
9957: if (ret == NULL)
9958: return (NULL);
9959: ret->dict = dict;
9960: xmlDictReference(dict);
9961: if (URL != NULL)
9962: ret->URL = xmlDictLookup(dict, (const xmlChar *) URL, -1);
9963: return (ret);
9964: }
9965:
9966: static int
9967: xmlSchemaCreatePCtxtOnVCtxt(xmlSchemaValidCtxtPtr vctxt)
9968: {
9969: if (vctxt->pctxt == NULL) {
9970: if (vctxt->schema != NULL)
9971: vctxt->pctxt =
9972: xmlSchemaNewParserCtxtUseDict("*", vctxt->schema->dict);
9973: else
9974: vctxt->pctxt = xmlSchemaNewParserCtxt("*");
9975: if (vctxt->pctxt == NULL) {
9976: VERROR_INT("xmlSchemaCreatePCtxtOnVCtxt",
9977: "failed to create a temp. parser context");
9978: return (-1);
9979: }
9980: /* TODO: Pass user data. */
9981: xmlSchemaSetParserErrors(vctxt->pctxt, vctxt->error,
9982: vctxt->warning, vctxt->errCtxt);
9983: xmlSchemaSetParserStructuredErrors(vctxt->pctxt, vctxt->serror,
9984: vctxt->errCtxt);
9985: }
9986: return (0);
9987: }
9988:
9989: /**
9990: * xmlSchemaGetSchemaBucket:
9991: * @pctxt: the schema parser context
9992: * @schemaLocation: the URI of the schema document
9993: *
9994: * Returns a schema bucket if it was already parsed.
9995: *
9996: * Returns a schema bucket if it was already parsed from
9997: * @schemaLocation, NULL otherwise.
9998: */
9999: static xmlSchemaBucketPtr
10000: xmlSchemaGetSchemaBucket(xmlSchemaParserCtxtPtr pctxt,
10001: const xmlChar *schemaLocation)
10002: {
10003: xmlSchemaBucketPtr cur;
10004: xmlSchemaItemListPtr list;
10005:
10006: list = pctxt->constructor->buckets;
10007: if (list->nbItems == 0)
10008: return(NULL);
10009: else {
10010: int i;
10011: for (i = 0; i < list->nbItems; i++) {
10012: cur = (xmlSchemaBucketPtr) list->items[i];
10013: /* Pointer comparison! */
10014: if (cur->schemaLocation == schemaLocation)
10015: return(cur);
10016: }
10017: }
10018: return(NULL);
10019: }
10020:
10021: static xmlSchemaBucketPtr
10022: xmlSchemaGetChameleonSchemaBucket(xmlSchemaParserCtxtPtr pctxt,
10023: const xmlChar *schemaLocation,
10024: const xmlChar *targetNamespace)
10025: {
10026: xmlSchemaBucketPtr cur;
10027: xmlSchemaItemListPtr list;
10028:
10029: list = pctxt->constructor->buckets;
10030: if (list->nbItems == 0)
10031: return(NULL);
10032: else {
10033: int i;
10034: for (i = 0; i < list->nbItems; i++) {
10035: cur = (xmlSchemaBucketPtr) list->items[i];
10036: /* Pointer comparison! */
10037: if ((cur->origTargetNamespace == NULL) &&
10038: (cur->schemaLocation == schemaLocation) &&
10039: (cur->targetNamespace == targetNamespace))
10040: return(cur);
10041: }
10042: }
10043: return(NULL);
10044: }
10045:
10046:
10047: #define IS_BAD_SCHEMA_DOC(b) \
10048: (((b)->doc == NULL) && ((b)->schemaLocation != NULL))
10049:
10050: static xmlSchemaBucketPtr
10051: xmlSchemaGetSchemaBucketByTNS(xmlSchemaParserCtxtPtr pctxt,
10052: const xmlChar *targetNamespace,
10053: int imported)
10054: {
10055: xmlSchemaBucketPtr cur;
10056: xmlSchemaItemListPtr list;
10057:
10058: list = pctxt->constructor->buckets;
10059: if (list->nbItems == 0)
10060: return(NULL);
10061: else {
10062: int i;
10063: for (i = 0; i < list->nbItems; i++) {
10064: cur = (xmlSchemaBucketPtr) list->items[i];
10065: if ((! IS_BAD_SCHEMA_DOC(cur)) &&
10066: (cur->origTargetNamespace == targetNamespace) &&
10067: ((imported && cur->imported) ||
10068: ((!imported) && (!cur->imported))))
10069: return(cur);
10070: }
10071: }
10072: return(NULL);
10073: }
10074:
10075: static int
10076: xmlSchemaParseNewDocWithContext(xmlSchemaParserCtxtPtr pctxt,
10077: xmlSchemaPtr schema,
10078: xmlSchemaBucketPtr bucket)
10079: {
10080: int oldFlags;
10081: xmlDocPtr oldDoc;
10082: xmlNodePtr node;
10083: int ret, oldErrs;
10084: xmlSchemaBucketPtr oldbucket = pctxt->constructor->bucket;
10085:
10086: /*
10087: * Save old values; reset the *main* schema.
10088: * URGENT TODO: This is not good; move the per-document information
10089: * to the parser. Get rid of passing the main schema to the
10090: * parsing functions.
10091: */
10092: oldFlags = schema->flags;
10093: oldDoc = schema->doc;
10094: if (schema->flags != 0)
10095: xmlSchemaClearSchemaDefaults(schema);
10096: schema->doc = bucket->doc;
10097: pctxt->schema = schema;
10098: /*
10099: * Keep the current target namespace on the parser *not* on the
10100: * main schema.
10101: */
10102: pctxt->targetNamespace = bucket->targetNamespace;
10103: WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
10104:
10105: if ((bucket->targetNamespace != NULL) &&
10106: xmlStrEqual(bucket->targetNamespace, xmlSchemaNs)) {
10107: /*
10108: * We are parsing the schema for schemas!
10109: */
10110: pctxt->isS4S = 1;
10111: }
10112: /* Mark it as parsed, even if parsing fails. */
10113: bucket->parsed++;
10114: /* Compile the schema doc. */
10115: node = xmlDocGetRootElement(bucket->doc);
10116: ret = xmlSchemaParseSchemaElement(pctxt, schema, node);
10117: if (ret != 0)
10118: goto exit;
10119: /* An empty schema; just get out. */
10120: if (node->children == NULL)
10121: goto exit;
10122: oldErrs = pctxt->nberrors;
10123: ret = xmlSchemaParseSchemaTopLevel(pctxt, schema, node->children);
10124: if (ret != 0)
10125: goto exit;
10126: /*
10127: * TODO: Not nice, but I'm not 100% sure we will get always an error
10128: * as a result of the obove functions; so better rely on pctxt->err
10129: * as well.
10130: */
10131: if ((ret == 0) && (oldErrs != pctxt->nberrors)) {
10132: ret = pctxt->err;
10133: goto exit;
10134: }
10135:
10136: exit:
10137: WXS_CONSTRUCTOR(pctxt)->bucket = oldbucket;
10138: /* Restore schema values. */
10139: schema->doc = oldDoc;
10140: schema->flags = oldFlags;
10141: return(ret);
10142: }
10143:
10144: static int
10145: xmlSchemaParseNewDoc(xmlSchemaParserCtxtPtr pctxt,
10146: xmlSchemaPtr schema,
10147: xmlSchemaBucketPtr bucket)
10148: {
10149: xmlSchemaParserCtxtPtr newpctxt;
10150: int res = 0;
10151:
10152: if (bucket == NULL)
10153: return(0);
10154: if (bucket->parsed) {
10155: PERROR_INT("xmlSchemaParseNewDoc",
10156: "reparsing a schema doc");
10157: return(-1);
10158: }
10159: if (bucket->doc == NULL) {
10160: PERROR_INT("xmlSchemaParseNewDoc",
10161: "parsing a schema doc, but there's no doc");
10162: return(-1);
10163: }
10164: if (pctxt->constructor == NULL) {
10165: PERROR_INT("xmlSchemaParseNewDoc",
10166: "no constructor");
10167: return(-1);
10168: }
10169: /* Create and init the temporary parser context. */
10170: newpctxt = xmlSchemaNewParserCtxtUseDict(
10171: (const char *) bucket->schemaLocation, pctxt->dict);
10172: if (newpctxt == NULL)
10173: return(-1);
10174: newpctxt->constructor = pctxt->constructor;
10175: /*
10176: * TODO: Can we avoid that the parser knows about the main schema?
10177: * It would be better if he knows about the current schema bucket
10178: * only.
10179: */
10180: newpctxt->schema = schema;
10181: xmlSchemaSetParserErrors(newpctxt, pctxt->error, pctxt->warning,
10182: pctxt->errCtxt);
10183: xmlSchemaSetParserStructuredErrors(newpctxt, pctxt->serror,
10184: pctxt->errCtxt);
10185: newpctxt->counter = pctxt->counter;
10186:
10187:
10188: res = xmlSchemaParseNewDocWithContext(newpctxt, schema, bucket);
10189:
10190: /* Channel back errors and cleanup the temporary parser context. */
10191: if (res != 0)
10192: pctxt->err = res;
10193: pctxt->nberrors += newpctxt->nberrors;
10194: pctxt->counter = newpctxt->counter;
10195: newpctxt->constructor = NULL;
10196: /* Free the parser context. */
10197: xmlSchemaFreeParserCtxt(newpctxt);
10198: return(res);
10199: }
10200:
10201: static void
10202: xmlSchemaSchemaRelationAddChild(xmlSchemaBucketPtr bucket,
10203: xmlSchemaSchemaRelationPtr rel)
10204: {
10205: xmlSchemaSchemaRelationPtr cur = bucket->relations;
10206:
10207: if (cur == NULL) {
10208: bucket->relations = rel;
10209: return;
10210: }
10211: while (cur->next != NULL)
10212: cur = cur->next;
10213: cur->next = rel;
10214: }
10215:
10216:
10217: static const xmlChar *
10218: xmlSchemaBuildAbsoluteURI(xmlDictPtr dict, const xmlChar* location,
10219: xmlNodePtr ctxtNode)
10220: {
10221: /*
10222: * Build an absolue location URI.
10223: */
10224: if (location != NULL) {
10225: if (ctxtNode == NULL)
10226: return(location);
10227: else {
10228: xmlChar *base, *URI;
10229: const xmlChar *ret = NULL;
10230:
10231: base = xmlNodeGetBase(ctxtNode->doc, ctxtNode);
10232: if (base == NULL) {
10233: URI = xmlBuildURI(location, ctxtNode->doc->URL);
10234: } else {
10235: URI = xmlBuildURI(location, base);
10236: xmlFree(base);
10237: }
10238: if (URI != NULL) {
10239: ret = xmlDictLookup(dict, URI, -1);
10240: xmlFree(URI);
10241: return(ret);
10242: }
10243: }
10244: }
10245: return(NULL);
10246: }
10247:
10248:
10249:
10250: /**
10251: * xmlSchemaAddSchemaDoc:
10252: * @pctxt: a schema validation context
10253: * @schema: the schema being built
10254: * @node: a subtree containing XML Schema informations
10255: *
10256: * Parse an included (and to-be-redefined) XML schema document.
10257: *
10258: * Returns 0 on success, a positive error code on errors and
10259: * -1 in case of an internal or API error.
10260: */
10261:
10262: static int
10263: xmlSchemaAddSchemaDoc(xmlSchemaParserCtxtPtr pctxt,
10264: int type, /* import or include or redefine */
10265: const xmlChar *schemaLocation,
10266: xmlDocPtr schemaDoc,
10267: const char *schemaBuffer,
10268: int schemaBufferLen,
10269: xmlNodePtr invokingNode,
10270: const xmlChar *sourceTargetNamespace,
10271: const xmlChar *importNamespace,
10272: xmlSchemaBucketPtr *bucket)
10273: {
10274: const xmlChar *targetNamespace = NULL;
10275: xmlSchemaSchemaRelationPtr relation = NULL;
10276: xmlDocPtr doc = NULL;
10277: int res = 0, err = 0, located = 0, preserveDoc = 0;
10278: xmlSchemaBucketPtr bkt = NULL;
10279:
10280: if (bucket != NULL)
10281: *bucket = NULL;
10282:
10283: switch (type) {
10284: case XML_SCHEMA_SCHEMA_IMPORT:
10285: case XML_SCHEMA_SCHEMA_MAIN:
10286: err = XML_SCHEMAP_SRC_IMPORT;
10287: break;
10288: case XML_SCHEMA_SCHEMA_INCLUDE:
10289: err = XML_SCHEMAP_SRC_INCLUDE;
10290: break;
10291: case XML_SCHEMA_SCHEMA_REDEFINE:
10292: err = XML_SCHEMAP_SRC_REDEFINE;
10293: break;
10294: }
10295:
10296:
10297: /* Special handling for the main schema:
10298: * skip the location and relation logic and just parse the doc.
10299: * We need just a bucket to be returned in this case.
10300: */
10301: if ((type == XML_SCHEMA_SCHEMA_MAIN) || (! WXS_HAS_BUCKETS(pctxt)))
10302: goto doc_load;
10303:
10304: /* Note that we expect the location to be an absulute URI. */
10305: if (schemaLocation != NULL) {
10306: bkt = xmlSchemaGetSchemaBucket(pctxt, schemaLocation);
10307: if ((bkt != NULL) &&
10308: (pctxt->constructor->bucket == bkt)) {
10309: /* Report self-imports/inclusions/redefinitions. */
10310:
10311: xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
10312: invokingNode, NULL,
10313: "The schema must not import/include/redefine itself",
10314: NULL, NULL);
10315: goto exit;
10316: }
10317: }
10318: /*
10319: * Create a relation for the graph of schemas.
10320: */
10321: relation = xmlSchemaSchemaRelationCreate();
10322: if (relation == NULL)
10323: return(-1);
10324: xmlSchemaSchemaRelationAddChild(pctxt->constructor->bucket,
10325: relation);
10326: relation->type = type;
10327:
10328: /*
10329: * Save the namespace import information.
10330: */
10331: if (WXS_IS_BUCKET_IMPMAIN(type)) {
10332: relation->importNamespace = importNamespace;
10333: if (schemaLocation == NULL) {
10334: /*
10335: * No location; this is just an import of the namespace.
10336: * Note that we don't assign a bucket to the relation
10337: * in this case.
10338: */
10339: goto exit;
10340: }
10341: targetNamespace = importNamespace;
10342: }
10343:
10344: /* Did we already fetch the doc? */
10345: if (bkt != NULL) {
10346: if ((WXS_IS_BUCKET_IMPMAIN(type)) && (! bkt->imported)) {
10347: /*
10348: * We included/redefined and then try to import a schema,
10349: * but the new location provided for import was different.
10350: */
10351: if (schemaLocation == NULL)
10352: schemaLocation = BAD_CAST "in_memory_buffer";
10353: if (!xmlStrEqual(schemaLocation,
10354: bkt->schemaLocation)) {
10355: xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
10356: invokingNode, NULL,
10357: "The schema document '%s' cannot be imported, since "
10358: "it was already included or redefined",
10359: schemaLocation, NULL);
10360: goto exit;
10361: }
10362: } else if ((! WXS_IS_BUCKET_IMPMAIN(type)) && (bkt->imported)) {
10363: /*
10364: * We imported and then try to include/redefine a schema,
10365: * but the new location provided for the include/redefine
10366: * was different.
10367: */
10368: if (schemaLocation == NULL)
10369: schemaLocation = BAD_CAST "in_memory_buffer";
10370: if (!xmlStrEqual(schemaLocation,
10371: bkt->schemaLocation)) {
10372: xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
10373: invokingNode, NULL,
10374: "The schema document '%s' cannot be included or "
10375: "redefined, since it was already imported",
10376: schemaLocation, NULL);
10377: goto exit;
10378: }
10379: }
10380: }
10381:
10382: if (WXS_IS_BUCKET_IMPMAIN(type)) {
10383: /*
10384: * Given that the schemaLocation [attribute] is only a hint, it is open
10385: * to applications to ignore all but the first <import> for a given
10386: * namespace, regardless of the �actual value� of schemaLocation, but
10387: * such a strategy risks missing useful information when new
10388: * schemaLocations are offered.
10389: *
10390: * We will use the first <import> that comes with a location.
10391: * Further <import>s *with* a location, will result in an error.
10392: * TODO: Better would be to just report a warning here, but
10393: * we'll try it this way until someone complains.
10394: *
10395: * Schema Document Location Strategy:
10396: * 3 Based on the namespace name, identify an existing schema document,
10397: * either as a resource which is an XML document or a <schema> element
10398: * information item, in some local schema repository;
10399: * 5 Attempt to resolve the namespace name to locate such a resource.
10400: *
10401: * NOTE: (3) and (5) are not supported.
10402: */
10403: if (bkt != NULL) {
10404: relation->bucket = bkt;
10405: goto exit;
10406: }
10407: bkt = xmlSchemaGetSchemaBucketByTNS(pctxt,
10408: importNamespace, 1);
10409:
10410: if (bkt != NULL) {
10411: relation->bucket = bkt;
10412: if (bkt->schemaLocation == NULL) {
10413: /* First given location of the schema; load the doc. */
10414: bkt->schemaLocation = schemaLocation;
10415: } else {
10416: if (!xmlStrEqual(schemaLocation,
10417: bkt->schemaLocation)) {
10418: /*
10419: * Additional location given; just skip it.
10420: * URGENT TODO: We should report a warning here.
10421: * res = XML_SCHEMAP_SRC_IMPORT;
10422: */
10423: if (schemaLocation == NULL)
10424: schemaLocation = BAD_CAST "in_memory_buffer";
10425:
10426: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
10427: XML_SCHEMAP_WARN_SKIP_SCHEMA,
10428: invokingNode, NULL,
10429: "Skipping import of schema located at '%s' for the "
10430: "namespace '%s', since this namespace was already "
10431: "imported with the schema located at '%s'",
10432: schemaLocation, importNamespace, bkt->schemaLocation);
10433: }
10434: goto exit;
10435: }
10436: }
10437: /*
10438: * No bucket + first location: load the doc and create a
10439: * bucket.
10440: */
10441: } else {
10442: /* <include> and <redefine> */
10443: if (bkt != NULL) {
10444:
10445: if ((bkt->origTargetNamespace == NULL) &&
10446: (bkt->targetNamespace != sourceTargetNamespace)) {
10447: xmlSchemaBucketPtr chamel;
10448:
10449: /*
10450: * Chameleon include/redefine: skip loading only if it was
10451: * aleady build for the targetNamespace of the including
10452: * schema.
10453: */
10454: /*
10455: * URGENT TODO: If the schema is a chameleon-include then copy
10456: * the components into the including schema and modify the
10457: * targetNamespace of those components, do nothing otherwise.
10458: * NOTE: This is currently worked-around by compiling the
10459: * chameleon for every destinct including targetNamespace; thus
10460: * not performant at the moment.
10461: * TODO: Check when the namespace in wildcards for chameleons
10462: * needs to be converted: before we built wildcard intersections
10463: * or after.
10464: * Answer: after!
10465: */
10466: chamel = xmlSchemaGetChameleonSchemaBucket(pctxt,
10467: schemaLocation, sourceTargetNamespace);
10468: if (chamel != NULL) {
10469: /* A fitting chameleon was already parsed; NOP. */
10470: relation->bucket = chamel;
10471: goto exit;
10472: }
10473: /*
10474: * We need to parse the chameleon again for a different
10475: * targetNamespace.
10476: * CHAMELEON TODO: Optimize this by only parsing the
10477: * chameleon once, and then copying the components to
10478: * the new targetNamespace.
10479: */
10480: bkt = NULL;
10481: } else {
10482: relation->bucket = bkt;
10483: goto exit;
10484: }
10485: }
10486: }
10487: if ((bkt != NULL) && (bkt->doc != NULL)) {
10488: PERROR_INT("xmlSchemaAddSchemaDoc",
10489: "trying to load a schema doc, but a doc is already "
10490: "assigned to the schema bucket");
10491: goto exit_failure;
10492: }
10493:
10494: doc_load:
10495: /*
10496: * Load the document.
10497: */
10498: if (schemaDoc != NULL) {
10499: doc = schemaDoc;
10500: /* Don' free this one, since it was provided by the caller. */
10501: preserveDoc = 1;
10502: /* TODO: Does the context or the doc hold the location? */
10503: if (schemaDoc->URL != NULL)
10504: schemaLocation = xmlDictLookup(pctxt->dict,
10505: schemaDoc->URL, -1);
10506: else
10507: schemaLocation = BAD_CAST "in_memory_buffer";
10508: } else if ((schemaLocation != NULL) || (schemaBuffer != NULL)) {
10509: xmlParserCtxtPtr parserCtxt;
10510:
10511: parserCtxt = xmlNewParserCtxt();
10512: if (parserCtxt == NULL) {
10513: xmlSchemaPErrMemory(NULL, "xmlSchemaGetDoc, "
10514: "allocating a parser context", NULL);
10515: goto exit_failure;
10516: }
10517: if ((pctxt->dict != NULL) && (parserCtxt->dict != NULL)) {
10518: /*
10519: * TODO: Do we have to burden the schema parser dict with all
10520: * the content of the schema doc?
10521: */
10522: xmlDictFree(parserCtxt->dict);
10523: parserCtxt->dict = pctxt->dict;
10524: xmlDictReference(parserCtxt->dict);
10525: }
10526: if (schemaLocation != NULL) {
10527: /* Parse from file. */
10528: doc = xmlCtxtReadFile(parserCtxt, (const char *) schemaLocation,
10529: NULL, SCHEMAS_PARSE_OPTIONS);
10530: } else if (schemaBuffer != NULL) {
10531: /* Parse from memory buffer. */
10532: doc = xmlCtxtReadMemory(parserCtxt, schemaBuffer, schemaBufferLen,
10533: NULL, NULL, SCHEMAS_PARSE_OPTIONS);
10534: schemaLocation = BAD_CAST "in_memory_buffer";
10535: if (doc != NULL)
10536: doc->URL = xmlStrdup(schemaLocation);
10537: }
10538: /*
10539: * For <import>:
10540: * 2.1 The referent is (a fragment of) a resource which is an
10541: * XML document (see clause 1.1), which in turn corresponds to
10542: * a <schema> element information item in a well-formed information
10543: * set, which in turn corresponds to a valid schema.
10544: * TODO: (2.1) fragments of XML documents are not supported.
10545: *
10546: * 2.2 The referent is a <schema> element information item in
10547: * a well-formed information set, which in turn corresponds
10548: * to a valid schema.
10549: * TODO: (2.2) is not supported.
10550: */
10551: if (doc == NULL) {
10552: xmlErrorPtr lerr;
10553: lerr = xmlGetLastError();
10554: /*
10555: * Check if this a parser error, or if the document could
10556: * just not be located.
10557: * TODO: Try to find specific error codes to react only on
10558: * localisation failures.
10559: */
10560: if ((lerr == NULL) || (lerr->domain != XML_FROM_IO)) {
10561: /*
10562: * We assume a parser error here.
10563: */
10564: located = 1;
10565: /* TODO: Error code ?? */
10566: res = XML_SCHEMAP_SRC_IMPORT_2_1;
10567: xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
10568: invokingNode, NULL,
10569: "Failed to parse the XML resource '%s'",
10570: schemaLocation, NULL);
10571: }
10572: }
10573: xmlFreeParserCtxt(parserCtxt);
10574: if ((doc == NULL) && located)
10575: goto exit_error;
10576: } else {
10577: xmlSchemaPErr(pctxt, NULL,
10578: XML_SCHEMAP_NOTHING_TO_PARSE,
10579: "No information for parsing was provided with the "
10580: "given schema parser context.\n",
10581: NULL, NULL);
10582: goto exit_failure;
10583: }
10584: /*
10585: * Preprocess the document.
10586: */
10587: if (doc != NULL) {
10588: xmlNodePtr docElem = NULL;
10589:
10590: located = 1;
10591: docElem = xmlDocGetRootElement(doc);
10592: if (docElem == NULL) {
10593: xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOROOT,
10594: invokingNode, NULL,
10595: "The document '%s' has no document element",
10596: schemaLocation, NULL);
10597: goto exit_error;
10598: }
10599: /*
10600: * Remove all the blank text nodes.
10601: */
10602: xmlSchemaCleanupDoc(pctxt, docElem);
10603: /*
10604: * Check the schema's top level element.
10605: */
10606: if (!IS_SCHEMA(docElem, "schema")) {
10607: xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOT_SCHEMA,
10608: invokingNode, NULL,
10609: "The XML document '%s' is not a schema document",
10610: schemaLocation, NULL);
10611: goto exit_error;
10612: }
10613: /*
10614: * Note that we don't apply a type check for the
10615: * targetNamespace value here.
10616: */
10617: targetNamespace = xmlSchemaGetProp(pctxt, docElem,
10618: "targetNamespace");
10619: }
10620:
10621: /* after_doc_loading: */
10622: if ((bkt == NULL) && located) {
10623: /* Only create a bucket if the schema was located. */
10624: bkt = xmlSchemaBucketCreate(pctxt, type,
10625: targetNamespace);
10626: if (bkt == NULL)
10627: goto exit_failure;
10628: }
10629: if (bkt != NULL) {
10630: bkt->schemaLocation = schemaLocation;
10631: bkt->located = located;
10632: if (doc != NULL) {
10633: bkt->doc = doc;
10634: bkt->targetNamespace = targetNamespace;
10635: bkt->origTargetNamespace = targetNamespace;
10636: if (preserveDoc)
10637: bkt->preserveDoc = 1;
10638: }
10639: if (WXS_IS_BUCKET_IMPMAIN(type))
10640: bkt->imported++;
10641: /*
10642: * Add it to the graph of schemas.
10643: */
10644: if (relation != NULL)
10645: relation->bucket = bkt;
10646: }
10647:
10648: exit:
10649: /*
10650: * Return the bucket explicitely; this is needed for the
10651: * main schema.
10652: */
10653: if (bucket != NULL)
10654: *bucket = bkt;
10655: return (0);
10656:
10657: exit_error:
10658: if ((doc != NULL) && (! preserveDoc)) {
10659: xmlFreeDoc(doc);
10660: if (bkt != NULL)
10661: bkt->doc = NULL;
10662: }
10663: return(pctxt->err);
10664:
10665: exit_failure:
10666: if ((doc != NULL) && (! preserveDoc)) {
10667: xmlFreeDoc(doc);
10668: if (bkt != NULL)
10669: bkt->doc = NULL;
10670: }
10671: return (-1);
10672: }
10673:
10674: /**
10675: * xmlSchemaParseImport:
10676: * @ctxt: a schema validation context
10677: * @schema: the schema being built
10678: * @node: a subtree containing XML Schema informations
10679: *
10680: * parse a XML schema Import definition
10681: * *WARNING* this interface is highly subject to change
10682: *
10683: * Returns 0 in case of success, a positive error code if
10684: * not valid and -1 in case of an internal error.
10685: */
10686: static int
10687: xmlSchemaParseImport(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
10688: xmlNodePtr node)
10689: {
10690: xmlNodePtr child;
10691: const xmlChar *namespaceName = NULL, *schemaLocation = NULL;
10692: const xmlChar *thisTargetNamespace;
10693: xmlAttrPtr attr;
10694: int ret = 0;
10695: xmlSchemaBucketPtr bucket = NULL;
10696:
10697: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
10698: return (-1);
10699:
10700: /*
10701: * Check for illegal attributes.
10702: */
10703: attr = node->properties;
10704: while (attr != NULL) {
10705: if (attr->ns == NULL) {
10706: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
10707: (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
10708: (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
10709: xmlSchemaPIllegalAttrErr(pctxt,
10710: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
10711: }
10712: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
10713: xmlSchemaPIllegalAttrErr(pctxt,
10714: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
10715: }
10716: attr = attr->next;
10717: }
10718: /*
10719: * Extract and validate attributes.
10720: */
10721: if (xmlSchemaPValAttr(pctxt, NULL, node,
10722: "namespace", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
10723: &namespaceName) != 0) {
10724: xmlSchemaPSimpleTypeErr(pctxt,
10725: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
10726: NULL, node,
10727: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
10728: NULL, namespaceName, NULL, NULL, NULL);
10729: return (pctxt->err);
10730: }
10731:
10732: if (xmlSchemaPValAttr(pctxt, NULL, node,
10733: "schemaLocation", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
10734: &schemaLocation) != 0) {
10735: xmlSchemaPSimpleTypeErr(pctxt,
10736: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
10737: NULL, node,
10738: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
10739: NULL, namespaceName, NULL, NULL, NULL);
10740: return (pctxt->err);
10741: }
10742: /*
10743: * And now for the children...
10744: */
10745: child = node->children;
10746: if (IS_SCHEMA(child, "annotation")) {
10747: /*
10748: * the annotation here is simply discarded ...
10749: * TODO: really?
10750: */
10751: child = child->next;
10752: }
10753: if (child != NULL) {
10754: xmlSchemaPContentErr(pctxt,
10755: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
10756: NULL, node, child, NULL,
10757: "(annotation?)");
10758: }
10759: /*
10760: * Apply additional constraints.
10761: *
10762: * Note that it is important to use the original @targetNamespace
10763: * (or none at all), to rule out imports of schemas _with_ a
10764: * @targetNamespace if the importing schema is a chameleon schema
10765: * (with no @targetNamespace).
10766: */
10767: thisTargetNamespace = WXS_BUCKET(pctxt)->origTargetNamespace;
10768: if (namespaceName != NULL) {
10769: /*
10770: * 1.1 If the namespace [attribute] is present, then its �actual value�
10771: * must not match the �actual value� of the enclosing <schema>'s
10772: * targetNamespace [attribute].
10773: */
10774: if (xmlStrEqual(thisTargetNamespace, namespaceName)) {
10775: xmlSchemaPCustomErr(pctxt,
10776: XML_SCHEMAP_SRC_IMPORT_1_1,
10777: NULL, node,
10778: "The value of the attribute 'namespace' must not match "
10779: "the target namespace '%s' of the importing schema",
10780: thisTargetNamespace);
10781: return (pctxt->err);
10782: }
10783: } else {
10784: /*
10785: * 1.2 If the namespace [attribute] is not present, then the enclosing
10786: * <schema> must have a targetNamespace [attribute].
10787: */
10788: if (thisTargetNamespace == NULL) {
10789: xmlSchemaPCustomErr(pctxt,
10790: XML_SCHEMAP_SRC_IMPORT_1_2,
10791: NULL, node,
10792: "The attribute 'namespace' must be existent if "
10793: "the importing schema has no target namespace",
10794: NULL);
10795: return (pctxt->err);
10796: }
10797: }
10798: /*
10799: * Locate and acquire the schema document.
10800: */
10801: if (schemaLocation != NULL)
10802: schemaLocation = xmlSchemaBuildAbsoluteURI(pctxt->dict,
10803: schemaLocation, node);
10804: ret = xmlSchemaAddSchemaDoc(pctxt, XML_SCHEMA_SCHEMA_IMPORT,
10805: schemaLocation, NULL, NULL, 0, node, thisTargetNamespace,
10806: namespaceName, &bucket);
10807:
10808: if (ret != 0)
10809: return(ret);
10810:
10811: /*
10812: * For <import>: "It is *not* an error for the application
10813: * schema reference strategy to fail."
10814: * So just don't parse if no schema document was found.
10815: * Note that we will get no bucket if the schema could not be
10816: * located or if there was no schemaLocation.
10817: */
10818: if ((bucket == NULL) && (schemaLocation != NULL)) {
10819: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
10820: XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
10821: node, NULL,
10822: "Failed to locate a schema at location '%s'. "
10823: "Skipping the import", schemaLocation, NULL, NULL);
10824: }
10825:
10826: if ((bucket != NULL) && CAN_PARSE_SCHEMA(bucket)) {
10827: ret = xmlSchemaParseNewDoc(pctxt, schema, bucket);
10828: }
10829:
10830: return (ret);
10831: }
10832:
10833: static int
10834: xmlSchemaParseIncludeOrRedefineAttrs(xmlSchemaParserCtxtPtr pctxt,
10835: xmlSchemaPtr schema,
10836: xmlNodePtr node,
10837: xmlChar **schemaLocation,
10838: int type)
10839: {
10840: xmlAttrPtr attr;
10841:
10842: if ((pctxt == NULL) || (schema == NULL) || (node == NULL) ||
10843: (schemaLocation == NULL))
10844: return (-1);
10845:
10846: *schemaLocation = NULL;
10847: /*
10848: * Check for illegal attributes.
10849: * Applies for both <include> and <redefine>.
10850: */
10851: attr = node->properties;
10852: while (attr != NULL) {
10853: if (attr->ns == NULL) {
10854: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
10855: (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
10856: xmlSchemaPIllegalAttrErr(pctxt,
10857: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
10858: }
10859: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
10860: xmlSchemaPIllegalAttrErr(pctxt,
10861: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
10862: }
10863: attr = attr->next;
10864: }
10865: xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
10866: /*
10867: * Preliminary step, extract the URI-Reference and make an URI
10868: * from the base.
10869: */
10870: /*
10871: * Attribute "schemaLocation" is mandatory.
10872: */
10873: attr = xmlSchemaGetPropNode(node, "schemaLocation");
10874: if (attr != NULL) {
10875: xmlChar *base = NULL;
10876: xmlChar *uri = NULL;
10877:
10878: if (xmlSchemaPValAttrNode(pctxt, NULL, attr,
10879: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
10880: (const xmlChar **) schemaLocation) != 0)
10881: goto exit_error;
10882: base = xmlNodeGetBase(node->doc, node);
10883: if (base == NULL) {
10884: uri = xmlBuildURI(*schemaLocation, node->doc->URL);
10885: } else {
10886: uri = xmlBuildURI(*schemaLocation, base);
10887: xmlFree(base);
10888: }
10889: if (uri == NULL) {
10890: PERROR_INT("xmlSchemaParseIncludeOrRedefine",
10891: "could not build an URI from the schemaLocation")
10892: goto exit_failure;
10893: }
10894: (*schemaLocation) = (xmlChar *) xmlDictLookup(pctxt->dict, uri, -1);
10895: xmlFree(uri);
10896: } else {
10897: xmlSchemaPMissingAttrErr(pctxt,
10898: XML_SCHEMAP_S4S_ATTR_MISSING,
10899: NULL, node, "schemaLocation", NULL);
10900: goto exit_error;
10901: }
10902: /*
10903: * Report self-inclusion and self-redefinition.
10904: */
10905: if (xmlStrEqual(*schemaLocation, pctxt->URL)) {
10906: if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
10907: xmlSchemaPCustomErr(pctxt,
10908: XML_SCHEMAP_SRC_REDEFINE,
10909: NULL, node,
10910: "The schema document '%s' cannot redefine itself.",
10911: *schemaLocation);
10912: } else {
10913: xmlSchemaPCustomErr(pctxt,
10914: XML_SCHEMAP_SRC_INCLUDE,
10915: NULL, node,
10916: "The schema document '%s' cannot include itself.",
10917: *schemaLocation);
10918: }
10919: goto exit_error;
10920: }
10921:
10922: return(0);
10923: exit_error:
10924: return(pctxt->err);
10925: exit_failure:
10926: return(-1);
10927: }
10928:
10929: static int
10930: xmlSchemaParseIncludeOrRedefine(xmlSchemaParserCtxtPtr pctxt,
10931: xmlSchemaPtr schema,
10932: xmlNodePtr node,
10933: int type)
10934: {
10935: xmlNodePtr child = NULL;
10936: const xmlChar *schemaLocation = NULL;
10937: int res = 0; /* hasRedefinitions = 0 */
10938: int isChameleon = 0, wasChameleon = 0;
10939: xmlSchemaBucketPtr bucket = NULL;
10940:
10941: if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
10942: return (-1);
10943:
10944: /*
10945: * Parse attributes. Note that the returned schemaLocation will
10946: * be already converted to an absolute URI.
10947: */
10948: res = xmlSchemaParseIncludeOrRedefineAttrs(pctxt, schema,
10949: node, (xmlChar **) (&schemaLocation), type);
10950: if (res != 0)
10951: return(res);
10952: /*
10953: * Load and add the schema document.
10954: */
10955: res = xmlSchemaAddSchemaDoc(pctxt, type, schemaLocation, NULL,
10956: NULL, 0, node, pctxt->targetNamespace, NULL, &bucket);
10957: if (res != 0)
10958: return(res);
10959: /*
10960: * If we get no schema bucket back, then this means that the schema
10961: * document could not be located or was broken XML or was not
10962: * a schema document.
10963: */
10964: if ((bucket == NULL) || (bucket->doc == NULL)) {
10965: if (type == XML_SCHEMA_SCHEMA_INCLUDE) {
10966: /*
10967: * WARNING for <include>:
10968: * We will raise an error if the schema cannot be located
10969: * for inclusions, since the that was the feedback from the
10970: * schema people. I.e. the following spec piece will *not* be
10971: * satisfied:
10972: * SPEC src-include: "It is not an error for the �actual value� of the
10973: * schemaLocation [attribute] to fail to resolve it all, in which
10974: * case no corresponding inclusion is performed.
10975: * So do we need a warning report here?"
10976: */
10977: res = XML_SCHEMAP_SRC_INCLUDE;
10978: xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
10979: node, NULL,
10980: "Failed to load the document '%s' for inclusion",
10981: schemaLocation, NULL);
10982: } else {
10983: /*
10984: * NOTE: This was changed to raise an error even if no redefinitions
10985: * are specified.
10986: *
10987: * SPEC src-redefine (1)
10988: * "If there are any element information items among the [children]
10989: * other than <annotation> then the �actual value� of the
10990: * schemaLocation [attribute] must successfully resolve."
10991: * TODO: Ask the WG if a the location has always to resolve
10992: * here as well!
10993: */
10994: res = XML_SCHEMAP_SRC_REDEFINE;
10995: xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
10996: node, NULL,
10997: "Failed to load the document '%s' for redefinition",
10998: schemaLocation, NULL);
10999: }
11000: } else {
11001: /*
11002: * Check targetNamespace sanity before parsing the new schema.
11003: * TODO: Note that we won't check further content if the
11004: * targetNamespace was bad.
11005: */
11006: if (bucket->origTargetNamespace != NULL) {
11007: /*
11008: * SPEC src-include (2.1)
11009: * "SII has a targetNamespace [attribute], and its �actual
11010: * value� is identical to the �actual value� of the targetNamespace
11011: * [attribute] of SII� (which must have such an [attribute])."
11012: */
11013: if (pctxt->targetNamespace == NULL) {
11014: xmlSchemaCustomErr(ACTXT_CAST pctxt,
11015: XML_SCHEMAP_SRC_INCLUDE,
11016: node, NULL,
11017: "The target namespace of the included/redefined schema "
11018: "'%s' has to be absent, since the including/redefining "
11019: "schema has no target namespace",
11020: schemaLocation, NULL);
11021: goto exit_error;
11022: } else if (!xmlStrEqual(bucket->origTargetNamespace,
11023: pctxt->targetNamespace)) {
11024: /* TODO: Change error function. */
11025: xmlSchemaPCustomErrExt(pctxt,
11026: XML_SCHEMAP_SRC_INCLUDE,
11027: NULL, node,
11028: "The target namespace '%s' of the included/redefined "
11029: "schema '%s' differs from '%s' of the "
11030: "including/redefining schema",
11031: bucket->origTargetNamespace, schemaLocation,
11032: pctxt->targetNamespace);
11033: goto exit_error;
11034: }
11035: } else if (pctxt->targetNamespace != NULL) {
11036: /*
11037: * Chameleons: the original target namespace will
11038: * differ from the resulting namespace.
11039: */
11040: isChameleon = 1;
11041: if (bucket->parsed &&
11042: bucket->origTargetNamespace != NULL) {
11043: xmlSchemaCustomErr(ACTXT_CAST pctxt,
11044: XML_SCHEMAP_SRC_INCLUDE,
11045: node, NULL,
11046: "The target namespace of the included/redefined schema "
11047: "'%s' has to be absent or the same as the "
11048: "including/redefining schema's target namespace",
11049: schemaLocation, NULL);
11050: goto exit_error;
11051: }
11052: bucket->targetNamespace = pctxt->targetNamespace;
11053: }
11054: }
11055: /*
11056: * Parse the schema.
11057: */
11058: if (bucket && (!bucket->parsed) && (bucket->doc != NULL)) {
11059: if (isChameleon) {
11060: /* TODO: Get rid of this flag on the schema itself. */
11061: if ((schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) == 0) {
11062: schema->flags |= XML_SCHEMAS_INCLUDING_CONVERT_NS;
11063: } else
11064: wasChameleon = 1;
11065: }
11066: xmlSchemaParseNewDoc(pctxt, schema, bucket);
11067: /* Restore chameleon flag. */
11068: if (isChameleon && (!wasChameleon))
11069: schema->flags ^= XML_SCHEMAS_INCLUDING_CONVERT_NS;
11070: }
11071: /*
11072: * And now for the children...
11073: */
11074: child = node->children;
11075: if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
11076: /*
11077: * Parse (simpleType | complexType | group | attributeGroup))*
11078: */
11079: pctxt->redefined = bucket;
11080: /*
11081: * How to proceed if the redefined schema was not located?
11082: */
11083: pctxt->isRedefine = 1;
11084: while (IS_SCHEMA(child, "annotation") ||
11085: IS_SCHEMA(child, "simpleType") ||
11086: IS_SCHEMA(child, "complexType") ||
11087: IS_SCHEMA(child, "group") ||
11088: IS_SCHEMA(child, "attributeGroup")) {
11089: if (IS_SCHEMA(child, "annotation")) {
11090: /*
11091: * TODO: discard or not?
11092: */
11093: } else if (IS_SCHEMA(child, "simpleType")) {
11094: xmlSchemaParseSimpleType(pctxt, schema, child, 1);
11095: } else if (IS_SCHEMA(child, "complexType")) {
11096: xmlSchemaParseComplexType(pctxt, schema, child, 1);
11097: /* hasRedefinitions = 1; */
11098: } else if (IS_SCHEMA(child, "group")) {
11099: /* hasRedefinitions = 1; */
11100: xmlSchemaParseModelGroupDefinition(pctxt,
11101: schema, child);
11102: } else if (IS_SCHEMA(child, "attributeGroup")) {
11103: /* hasRedefinitions = 1; */
11104: xmlSchemaParseAttributeGroupDefinition(pctxt, schema,
11105: child);
11106: }
11107: child = child->next;
11108: }
11109: pctxt->redefined = NULL;
11110: pctxt->isRedefine = 0;
11111: } else {
11112: if (IS_SCHEMA(child, "annotation")) {
11113: /*
11114: * TODO: discard or not?
11115: */
11116: child = child->next;
11117: }
11118: }
11119: if (child != NULL) {
11120: res = XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED;
11121: if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
11122: xmlSchemaPContentErr(pctxt, res,
11123: NULL, node, child, NULL,
11124: "(annotation | (simpleType | complexType | group | attributeGroup))*");
11125: } else {
11126: xmlSchemaPContentErr(pctxt, res,
11127: NULL, node, child, NULL,
11128: "(annotation?)");
11129: }
11130: }
11131: return(res);
11132:
11133: exit_error:
11134: return(pctxt->err);
11135: }
11136:
11137: static int
11138: xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
11139: xmlNodePtr node)
11140: {
11141: int res;
11142: #ifndef ENABLE_REDEFINE
11143: TODO
11144: return(0);
11145: #endif
11146: res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
11147: XML_SCHEMA_SCHEMA_REDEFINE);
11148: if (res != 0)
11149: return(res);
11150: return(0);
11151: }
11152:
11153: static int
11154: xmlSchemaParseInclude(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
11155: xmlNodePtr node)
11156: {
11157: int res;
11158:
11159: res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
11160: XML_SCHEMA_SCHEMA_INCLUDE);
11161: if (res != 0)
11162: return(res);
11163: return(0);
11164: }
11165:
11166: /**
11167: * xmlSchemaParseModelGroup:
11168: * @ctxt: a schema validation context
11169: * @schema: the schema being built
11170: * @node: a subtree containing XML Schema informations
11171: * @type: the "compositor" type
11172: * @particleNeeded: if a a model group with a particle
11173: *
11174: * parse a XML schema Sequence definition.
11175: * Applies parts of:
11176: * Schema Representation Constraint:
11177: * Redefinition Constraints and Semantics (src-redefine)
11178: * (6.1), (6.1.1), (6.1.2)
11179: *
11180: * Schema Component Constraint:
11181: * All Group Limited (cos-all-limited) (2)
11182: * TODO: Actually this should go to component-level checks,
11183: * but is done here due to performance. Move it to an other layer
11184: * is schema construction via an API is implemented.
11185: *
11186: * *WARNING* this interface is highly subject to change
11187: *
11188: * Returns -1 in case of error, 0 if the declaration is improper and
11189: * 1 in case of success.
11190: */
11191: static xmlSchemaTreeItemPtr
11192: xmlSchemaParseModelGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
11193: xmlNodePtr node, xmlSchemaTypeType type,
11194: int withParticle)
11195: {
11196: xmlSchemaModelGroupPtr item;
11197: xmlSchemaParticlePtr particle = NULL;
11198: xmlNodePtr child = NULL;
11199: xmlAttrPtr attr;
11200: int min = 1, max = 1, isElemRef, hasRefs = 0;
11201:
11202: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11203: return (NULL);
11204: /*
11205: * Create a model group with the given compositor.
11206: */
11207: item = xmlSchemaAddModelGroup(ctxt, schema, type, node);
11208: if (item == NULL)
11209: return (NULL);
11210:
11211: if (withParticle) {
11212: if (type == XML_SCHEMA_TYPE_ALL) {
11213: min = xmlGetMinOccurs(ctxt, node, 0, 1, 1, "(0 | 1)");
11214: max = xmlGetMaxOccurs(ctxt, node, 1, 1, 1, "1");
11215: } else {
11216: /* choice + sequence */
11217: min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
11218: max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
11219: "(xs:nonNegativeInteger | unbounded)");
11220: }
11221: xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
11222: /*
11223: * Create a particle
11224: */
11225: particle = xmlSchemaAddParticle(ctxt, node, min, max);
11226: if (particle == NULL)
11227: return (NULL);
11228: particle->children = (xmlSchemaTreeItemPtr) item;
11229: /*
11230: * Check for illegal attributes.
11231: */
11232: attr = node->properties;
11233: while (attr != NULL) {
11234: if (attr->ns == NULL) {
11235: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11236: (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
11237: (!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
11238: xmlSchemaPIllegalAttrErr(ctxt,
11239: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11240: }
11241: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
11242: xmlSchemaPIllegalAttrErr(ctxt,
11243: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11244: }
11245: attr = attr->next;
11246: }
11247: } else {
11248: /*
11249: * Check for illegal attributes.
11250: */
11251: attr = node->properties;
11252: while (attr != NULL) {
11253: if (attr->ns == NULL) {
11254: if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
11255: xmlSchemaPIllegalAttrErr(ctxt,
11256: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11257: }
11258: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
11259: xmlSchemaPIllegalAttrErr(ctxt,
11260: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11261: }
11262: attr = attr->next;
11263: }
11264: }
11265:
11266: /*
11267: * Extract and validate attributes.
11268: */
11269: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11270: /*
11271: * And now for the children...
11272: */
11273: child = node->children;
11274: if (IS_SCHEMA(child, "annotation")) {
11275: item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
11276: child = child->next;
11277: }
11278: if (type == XML_SCHEMA_TYPE_ALL) {
11279: xmlSchemaParticlePtr part, last = NULL;
11280:
11281: while (IS_SCHEMA(child, "element")) {
11282: part = (xmlSchemaParticlePtr) xmlSchemaParseElement(ctxt,
11283: schema, child, &isElemRef, 0);
11284: /*
11285: * SPEC cos-all-limited (2)
11286: * "The {max occurs} of all the particles in the {particles}
11287: * of the ('all') group must be 0 or 1.
11288: */
11289: if (part != NULL) {
11290: if (isElemRef)
11291: hasRefs++;
11292: if (part->minOccurs > 1) {
11293: xmlSchemaPCustomErr(ctxt,
11294: XML_SCHEMAP_COS_ALL_LIMITED,
11295: NULL, child,
11296: "Invalid value for minOccurs (must be 0 or 1)",
11297: NULL);
11298: /* Reset to 1. */
11299: part->minOccurs = 1;
11300: }
11301: if (part->maxOccurs > 1) {
11302: xmlSchemaPCustomErr(ctxt,
11303: XML_SCHEMAP_COS_ALL_LIMITED,
11304: NULL, child,
11305: "Invalid value for maxOccurs (must be 0 or 1)",
11306: NULL);
11307: /* Reset to 1. */
11308: part->maxOccurs = 1;
11309: }
11310: if (last == NULL)
11311: item->children = (xmlSchemaTreeItemPtr) part;
11312: else
11313: last->next = (xmlSchemaTreeItemPtr) part;
11314: last = part;
11315: }
11316: child = child->next;
11317: }
11318: if (child != NULL) {
11319: xmlSchemaPContentErr(ctxt,
11320: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11321: NULL, node, child, NULL,
11322: "(annotation?, (annotation?, element*)");
11323: }
11324: } else {
11325: /* choice + sequence */
11326: xmlSchemaTreeItemPtr part = NULL, last = NULL;
11327:
11328: while ((IS_SCHEMA(child, "element")) ||
11329: (IS_SCHEMA(child, "group")) ||
11330: (IS_SCHEMA(child, "any")) ||
11331: (IS_SCHEMA(child, "choice")) ||
11332: (IS_SCHEMA(child, "sequence"))) {
11333:
11334: if (IS_SCHEMA(child, "element")) {
11335: part = (xmlSchemaTreeItemPtr)
11336: xmlSchemaParseElement(ctxt, schema, child, &isElemRef, 0);
11337: if (part && isElemRef)
11338: hasRefs++;
11339: } else if (IS_SCHEMA(child, "group")) {
11340: part =
11341: xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11342: if (part != NULL)
11343: hasRefs++;
11344: /*
11345: * Handle redefinitions.
11346: */
11347: if (ctxt->isRedefine && ctxt->redef &&
11348: (ctxt->redef->item->type == XML_SCHEMA_TYPE_GROUP) &&
11349: part && part->children)
11350: {
11351: if ((xmlSchemaGetQNameRefName(part->children) ==
11352: ctxt->redef->refName) &&
11353: (xmlSchemaGetQNameRefTargetNs(part->children) ==
11354: ctxt->redef->refTargetNs))
11355: {
11356: /*
11357: * SPEC src-redefine:
11358: * (6.1) "If it has a <group> among its contents at
11359: * some level the �actual value� of whose ref
11360: * [attribute] is the same as the �actual value� of
11361: * its own name attribute plus target namespace, then
11362: * all of the following must be true:"
11363: * (6.1.1) "It must have exactly one such group."
11364: */
11365: if (ctxt->redefCounter != 0) {
11366: xmlChar *str = NULL;
11367:
11368: xmlSchemaCustomErr(ACTXT_CAST ctxt,
11369: XML_SCHEMAP_SRC_REDEFINE, child, NULL,
11370: "The redefining model group definition "
11371: "'%s' must not contain more than one "
11372: "reference to the redefined definition",
11373: xmlSchemaFormatQName(&str,
11374: ctxt->redef->refTargetNs,
11375: ctxt->redef->refName),
11376: NULL);
11377: FREE_AND_NULL(str)
11378: part = NULL;
11379: } else if (((WXS_PARTICLE(part))->minOccurs != 1) ||
11380: ((WXS_PARTICLE(part))->maxOccurs != 1))
11381: {
11382: xmlChar *str = NULL;
11383: /*
11384: * SPEC src-redefine:
11385: * (6.1.2) "The �actual value� of both that
11386: * group's minOccurs and maxOccurs [attribute]
11387: * must be 1 (or �absent�).
11388: */
11389: xmlSchemaCustomErr(ACTXT_CAST ctxt,
11390: XML_SCHEMAP_SRC_REDEFINE, child, NULL,
11391: "The redefining model group definition "
11392: "'%s' must not contain a reference to the "
11393: "redefined definition with a "
11394: "maxOccurs/minOccurs other than 1",
11395: xmlSchemaFormatQName(&str,
11396: ctxt->redef->refTargetNs,
11397: ctxt->redef->refName),
11398: NULL);
11399: FREE_AND_NULL(str)
11400: part = NULL;
11401: }
11402: ctxt->redef->reference = WXS_BASIC_CAST part;
11403: ctxt->redefCounter++;
11404: }
11405: }
11406: } else if (IS_SCHEMA(child, "any")) {
11407: part = (xmlSchemaTreeItemPtr)
11408: xmlSchemaParseAny(ctxt, schema, child);
11409: } else if (IS_SCHEMA(child, "choice")) {
11410: part = xmlSchemaParseModelGroup(ctxt, schema, child,
11411: XML_SCHEMA_TYPE_CHOICE, 1);
11412: } else if (IS_SCHEMA(child, "sequence")) {
11413: part = xmlSchemaParseModelGroup(ctxt, schema, child,
11414: XML_SCHEMA_TYPE_SEQUENCE, 1);
11415: }
11416: if (part != NULL) {
11417: if (last == NULL)
11418: item->children = part;
11419: else
11420: last->next = part;
11421: last = part;
11422: }
11423: child = child->next;
11424: }
11425: if (child != NULL) {
11426: xmlSchemaPContentErr(ctxt,
11427: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11428: NULL, node, child, NULL,
11429: "(annotation?, (element | group | choice | sequence | any)*)");
11430: }
11431: }
11432: if ((max == 0) && (min == 0))
11433: return (NULL);
11434: if (hasRefs) {
11435: /*
11436: * We need to resolve references.
11437: */
11438: WXS_ADD_PENDING(ctxt, item);
11439: }
11440: if (withParticle)
11441: return ((xmlSchemaTreeItemPtr) particle);
11442: else
11443: return ((xmlSchemaTreeItemPtr) item);
11444: }
11445:
11446: /**
11447: * xmlSchemaParseRestriction:
11448: * @ctxt: a schema validation context
11449: * @schema: the schema being built
11450: * @node: a subtree containing XML Schema informations
11451: *
11452: * parse a XML schema Restriction definition
11453: * *WARNING* this interface is highly subject to change
11454: *
11455: * Returns the type definition or NULL in case of error
11456: */
11457: static xmlSchemaTypePtr
11458: xmlSchemaParseRestriction(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
11459: xmlNodePtr node, xmlSchemaTypeType parentType)
11460: {
11461: xmlSchemaTypePtr type;
11462: xmlNodePtr child = NULL;
11463: xmlAttrPtr attr;
11464:
11465: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11466: return (NULL);
11467: /* Not a component, don't create it. */
11468: type = ctxt->ctxtType;
11469: type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
11470:
11471: /*
11472: * Check for illegal attributes.
11473: */
11474: attr = node->properties;
11475: while (attr != NULL) {
11476: if (attr->ns == NULL) {
11477: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11478: (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11479: xmlSchemaPIllegalAttrErr(ctxt,
11480: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11481: }
11482: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
11483: xmlSchemaPIllegalAttrErr(ctxt,
11484: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11485: }
11486: attr = attr->next;
11487: }
11488: /*
11489: * Extract and validate attributes.
11490: */
11491: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11492: /*
11493: * Attribute
11494: */
11495: /*
11496: * Extract the base type. The "base" attribute is mandatory if inside
11497: * a complex type or if redefining.
11498: *
11499: * SPEC (1.2) "...otherwise (<restriction> has no <simpleType> "
11500: * among its [children]), the simple type definition which is
11501: * the {content type} of the type definition �resolved� to by
11502: * the �actual value� of the base [attribute]"
11503: */
11504: if (xmlSchemaPValAttrQName(ctxt, schema, NULL, node, "base",
11505: &(type->baseNs), &(type->base)) == 0)
11506: {
11507: if ((type->base == NULL) && (type->type == XML_SCHEMA_TYPE_COMPLEX)) {
11508: xmlSchemaPMissingAttrErr(ctxt,
11509: XML_SCHEMAP_S4S_ATTR_MISSING,
11510: NULL, node, "base", NULL);
11511: } else if ((ctxt->isRedefine) &&
11512: (type->flags & XML_SCHEMAS_TYPE_GLOBAL))
11513: {
11514: if (type->base == NULL) {
11515: xmlSchemaPMissingAttrErr(ctxt,
11516: XML_SCHEMAP_S4S_ATTR_MISSING,
11517: NULL, node, "base", NULL);
11518: } else if ((! xmlStrEqual(type->base, type->name)) ||
11519: (! xmlStrEqual(type->baseNs, type->targetNamespace)))
11520: {
11521: xmlChar *str1 = NULL, *str2 = NULL;
11522: /*
11523: * REDEFINE: SPEC src-redefine (5)
11524: * "Within the [children], each <simpleType> must have a
11525: * <restriction> among its [children] ... the �actual value� of
11526: * whose base [attribute] must be the same as the �actual value�
11527: * of its own name attribute plus target namespace;"
11528: */
11529: xmlSchemaPCustomErrExt(ctxt, XML_SCHEMAP_SRC_REDEFINE,
11530: NULL, node, "This is a redefinition, but the QName "
11531: "value '%s' of the 'base' attribute does not match the "
11532: "type's designation '%s'",
11533: xmlSchemaFormatQName(&str1, type->baseNs, type->base),
11534: xmlSchemaFormatQName(&str2, type->targetNamespace,
11535: type->name), NULL);
11536: FREE_AND_NULL(str1);
11537: FREE_AND_NULL(str2);
11538: /* Avoid confusion and erase the values. */
11539: type->base = NULL;
11540: type->baseNs = NULL;
11541: }
11542: }
11543: }
11544: /*
11545: * And now for the children...
11546: */
11547: child = node->children;
11548: if (IS_SCHEMA(child, "annotation")) {
11549: /*
11550: * Add the annotation to the simple type ancestor.
11551: */
11552: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
11553: xmlSchemaParseAnnotation(ctxt, child, 1));
11554: child = child->next;
11555: }
11556: if (parentType == XML_SCHEMA_TYPE_SIMPLE) {
11557: /*
11558: * Corresponds to <simpleType><restriction><simpleType>.
11559: */
11560: if (IS_SCHEMA(child, "simpleType")) {
11561: if (type->base != NULL) {
11562: /*
11563: * src-restriction-base-or-simpleType
11564: * Either the base [attribute] or the simpleType [child] of the
11565: * <restriction> element must be present, but not both.
11566: */
11567: xmlSchemaPContentErr(ctxt,
11568: XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
11569: NULL, node, child,
11570: "The attribute 'base' and the <simpleType> child are "
11571: "mutually exclusive", NULL);
11572: } else {
11573: type->baseType = (xmlSchemaTypePtr)
11574: xmlSchemaParseSimpleType(ctxt, schema, child, 0);
11575: }
11576: child = child->next;
11577: } else if (type->base == NULL) {
11578: xmlSchemaPContentErr(ctxt,
11579: XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
11580: NULL, node, child,
11581: "Either the attribute 'base' or a <simpleType> child "
11582: "must be present", NULL);
11583: }
11584: } else if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
11585: /*
11586: * Corresponds to <complexType><complexContent><restriction>...
11587: * followed by:
11588: *
11589: * Model groups <all>, <choice> and <sequence>.
11590: */
11591: if (IS_SCHEMA(child, "all")) {
11592: type->subtypes = (xmlSchemaTypePtr)
11593: xmlSchemaParseModelGroup(ctxt, schema, child,
11594: XML_SCHEMA_TYPE_ALL, 1);
11595: child = child->next;
11596: } else if (IS_SCHEMA(child, "choice")) {
11597: type->subtypes = (xmlSchemaTypePtr)
11598: xmlSchemaParseModelGroup(ctxt,
11599: schema, child, XML_SCHEMA_TYPE_CHOICE, 1);
11600: child = child->next;
11601: } else if (IS_SCHEMA(child, "sequence")) {
11602: type->subtypes = (xmlSchemaTypePtr)
11603: xmlSchemaParseModelGroup(ctxt, schema, child,
11604: XML_SCHEMA_TYPE_SEQUENCE, 1);
11605: child = child->next;
11606: /*
11607: * Model group reference <group>.
11608: */
11609: } else if (IS_SCHEMA(child, "group")) {
11610: type->subtypes = (xmlSchemaTypePtr)
11611: xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11612: /*
11613: * Note that the reference will be resolved in
11614: * xmlSchemaResolveTypeReferences();
11615: */
11616: child = child->next;
11617: }
11618: } else if (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
11619: /*
11620: * Corresponds to <complexType><simpleContent><restriction>...
11621: *
11622: * "1.1 the simple type definition corresponding to the <simpleType>
11623: * among the [children] of <restriction> if there is one;"
11624: */
11625: if (IS_SCHEMA(child, "simpleType")) {
11626: /*
11627: * We will store the to-be-restricted simple type in
11628: * type->contentTypeDef *temporarily*.
11629: */
11630: type->contentTypeDef = (xmlSchemaTypePtr)
11631: xmlSchemaParseSimpleType(ctxt, schema, child, 0);
11632: if ( type->contentTypeDef == NULL)
11633: return (NULL);
11634: child = child->next;
11635: }
11636: }
11637:
11638: if ((parentType == XML_SCHEMA_TYPE_SIMPLE) ||
11639: (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT)) {
11640: xmlSchemaFacetPtr facet, lastfacet = NULL;
11641: /*
11642: * Corresponds to <complexType><simpleContent><restriction>...
11643: * <simpleType><restriction>...
11644: */
11645:
11646: /*
11647: * Add the facets to the simple type ancestor.
11648: */
11649: /*
11650: * TODO: Datatypes: 4.1.3 Constraints on XML Representation of
11651: * Simple Type Definition Schema Representation Constraint:
11652: * *Single Facet Value*
11653: */
11654: while ((IS_SCHEMA(child, "minInclusive")) ||
11655: (IS_SCHEMA(child, "minExclusive")) ||
11656: (IS_SCHEMA(child, "maxInclusive")) ||
11657: (IS_SCHEMA(child, "maxExclusive")) ||
11658: (IS_SCHEMA(child, "totalDigits")) ||
11659: (IS_SCHEMA(child, "fractionDigits")) ||
11660: (IS_SCHEMA(child, "pattern")) ||
11661: (IS_SCHEMA(child, "enumeration")) ||
11662: (IS_SCHEMA(child, "whiteSpace")) ||
11663: (IS_SCHEMA(child, "length")) ||
11664: (IS_SCHEMA(child, "maxLength")) ||
11665: (IS_SCHEMA(child, "minLength"))) {
11666: facet = xmlSchemaParseFacet(ctxt, schema, child);
11667: if (facet != NULL) {
11668: if (lastfacet == NULL)
11669: type->facets = facet;
11670: else
11671: lastfacet->next = facet;
11672: lastfacet = facet;
11673: lastfacet->next = NULL;
11674: }
11675: child = child->next;
11676: }
11677: /*
11678: * Create links for derivation and validation.
11679: */
11680: if (type->facets != NULL) {
11681: xmlSchemaFacetLinkPtr facetLink, lastFacetLink = NULL;
11682:
11683: facet = type->facets;
11684: do {
11685: facetLink = (xmlSchemaFacetLinkPtr)
11686: xmlMalloc(sizeof(xmlSchemaFacetLink));
11687: if (facetLink == NULL) {
11688: xmlSchemaPErrMemory(ctxt, "allocating a facet link", NULL);
11689: xmlFree(facetLink);
11690: return (NULL);
11691: }
11692: facetLink->facet = facet;
11693: facetLink->next = NULL;
11694: if (lastFacetLink == NULL)
11695: type->facetSet = facetLink;
11696: else
11697: lastFacetLink->next = facetLink;
11698: lastFacetLink = facetLink;
11699: facet = facet->next;
11700: } while (facet != NULL);
11701: }
11702: }
11703: if (type->type == XML_SCHEMA_TYPE_COMPLEX) {
11704: /*
11705: * Attribute uses/declarations.
11706: */
11707: if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
11708: (xmlSchemaItemListPtr *) &(type->attrUses),
11709: XML_SCHEMA_TYPE_RESTRICTION, NULL) == -1)
11710: return(NULL);
11711: /*
11712: * Attribute wildcard.
11713: */
11714: if (IS_SCHEMA(child, "anyAttribute")) {
11715: type->attributeWildcard =
11716: xmlSchemaParseAnyAttribute(ctxt, schema, child);
11717: child = child->next;
11718: }
11719: }
11720: if (child != NULL) {
11721: if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
11722: xmlSchemaPContentErr(ctxt,
11723: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11724: NULL, node, child, NULL,
11725: "annotation?, (group | all | choice | sequence)?, "
11726: "((attribute | attributeGroup)*, anyAttribute?))");
11727: } else if (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
11728: xmlSchemaPContentErr(ctxt,
11729: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11730: NULL, node, child, NULL,
11731: "(annotation?, (simpleType?, (minExclusive | minInclusive | "
11732: "maxExclusive | maxInclusive | totalDigits | fractionDigits | "
11733: "length | minLength | maxLength | enumeration | whiteSpace | "
11734: "pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))");
11735: } else {
11736: /* Simple type */
11737: xmlSchemaPContentErr(ctxt,
11738: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11739: NULL, node, child, NULL,
11740: "(annotation?, (simpleType?, (minExclusive | minInclusive | "
11741: "maxExclusive | maxInclusive | totalDigits | fractionDigits | "
11742: "length | minLength | maxLength | enumeration | whiteSpace | "
11743: "pattern)*))");
11744: }
11745: }
11746: return (NULL);
11747: }
11748:
11749: /**
11750: * xmlSchemaParseExtension:
11751: * @ctxt: a schema validation context
11752: * @schema: the schema being built
11753: * @node: a subtree containing XML Schema informations
11754: *
11755: * Parses an <extension>, which is found inside a
11756: * <simpleContent> or <complexContent>.
11757: * *WARNING* this interface is highly subject to change.
11758: *
11759: * TODO: Returns the type definition or NULL in case of error
11760: */
11761: static xmlSchemaTypePtr
11762: xmlSchemaParseExtension(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
11763: xmlNodePtr node, xmlSchemaTypeType parentType)
11764: {
11765: xmlSchemaTypePtr type;
11766: xmlNodePtr child = NULL;
11767: xmlAttrPtr attr;
11768:
11769: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11770: return (NULL);
11771: /* Not a component, don't create it. */
11772: type = ctxt->ctxtType;
11773: type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION;
11774:
11775: /*
11776: * Check for illegal attributes.
11777: */
11778: attr = node->properties;
11779: while (attr != NULL) {
11780: if (attr->ns == NULL) {
11781: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11782: (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11783: xmlSchemaPIllegalAttrErr(ctxt,
11784: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11785: }
11786: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
11787: xmlSchemaPIllegalAttrErr(ctxt,
11788: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11789: }
11790: attr = attr->next;
11791: }
11792:
11793: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11794:
11795: /*
11796: * Attribute "base" - mandatory.
11797: */
11798: if ((xmlSchemaPValAttrQName(ctxt, schema, NULL, node,
11799: "base", &(type->baseNs), &(type->base)) == 0) &&
11800: (type->base == NULL)) {
11801: xmlSchemaPMissingAttrErr(ctxt,
11802: XML_SCHEMAP_S4S_ATTR_MISSING,
11803: NULL, node, "base", NULL);
11804: }
11805: /*
11806: * And now for the children...
11807: */
11808: child = node->children;
11809: if (IS_SCHEMA(child, "annotation")) {
11810: /*
11811: * Add the annotation to the type ancestor.
11812: */
11813: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
11814: xmlSchemaParseAnnotation(ctxt, child, 1));
11815: child = child->next;
11816: }
11817: if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
11818: /*
11819: * Corresponds to <complexType><complexContent><extension>... and:
11820: *
11821: * Model groups <all>, <choice>, <sequence> and <group>.
11822: */
11823: if (IS_SCHEMA(child, "all")) {
11824: type->subtypes = (xmlSchemaTypePtr)
11825: xmlSchemaParseModelGroup(ctxt, schema,
11826: child, XML_SCHEMA_TYPE_ALL, 1);
11827: child = child->next;
11828: } else if (IS_SCHEMA(child, "choice")) {
11829: type->subtypes = (xmlSchemaTypePtr)
11830: xmlSchemaParseModelGroup(ctxt, schema,
11831: child, XML_SCHEMA_TYPE_CHOICE, 1);
11832: child = child->next;
11833: } else if (IS_SCHEMA(child, "sequence")) {
11834: type->subtypes = (xmlSchemaTypePtr)
11835: xmlSchemaParseModelGroup(ctxt, schema,
11836: child, XML_SCHEMA_TYPE_SEQUENCE, 1);
11837: child = child->next;
11838: } else if (IS_SCHEMA(child, "group")) {
11839: type->subtypes = (xmlSchemaTypePtr)
11840: xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11841: /*
11842: * Note that the reference will be resolved in
11843: * xmlSchemaResolveTypeReferences();
11844: */
11845: child = child->next;
11846: }
11847: }
11848: if (child != NULL) {
11849: /*
11850: * Attribute uses/declarations.
11851: */
11852: if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
11853: (xmlSchemaItemListPtr *) &(type->attrUses),
11854: XML_SCHEMA_TYPE_EXTENSION, NULL) == -1)
11855: return(NULL);
11856: /*
11857: * Attribute wildcard.
11858: */
11859: if (IS_SCHEMA(child, "anyAttribute")) {
11860: ctxt->ctxtType->attributeWildcard =
11861: xmlSchemaParseAnyAttribute(ctxt, schema, child);
11862: child = child->next;
11863: }
11864: }
11865: if (child != NULL) {
11866: if (parentType == XML_SCHEMA_TYPE_COMPLEX_CONTENT) {
11867: /* Complex content extension. */
11868: xmlSchemaPContentErr(ctxt,
11869: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11870: NULL, node, child, NULL,
11871: "(annotation?, ((group | all | choice | sequence)?, "
11872: "((attribute | attributeGroup)*, anyAttribute?)))");
11873: } else {
11874: /* Simple content extension. */
11875: xmlSchemaPContentErr(ctxt,
11876: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11877: NULL, node, child, NULL,
11878: "(annotation?, ((attribute | attributeGroup)*, "
11879: "anyAttribute?))");
11880: }
11881: }
11882: return (NULL);
11883: }
11884:
11885: /**
11886: * xmlSchemaParseSimpleContent:
11887: * @ctxt: a schema validation context
11888: * @schema: the schema being built
11889: * @node: a subtree containing XML Schema informations
11890: *
11891: * parse a XML schema SimpleContent definition
11892: * *WARNING* this interface is highly subject to change
11893: *
11894: * Returns the type definition or NULL in case of error
11895: */
11896: static int
11897: xmlSchemaParseSimpleContent(xmlSchemaParserCtxtPtr ctxt,
11898: xmlSchemaPtr schema, xmlNodePtr node,
11899: int *hasRestrictionOrExtension)
11900: {
11901: xmlSchemaTypePtr type;
11902: xmlNodePtr child = NULL;
11903: xmlAttrPtr attr;
11904:
11905: if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
11906: (hasRestrictionOrExtension == NULL))
11907: return (-1);
11908: *hasRestrictionOrExtension = 0;
11909: /* Not a component, don't create it. */
11910: type = ctxt->ctxtType;
11911: type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
11912: /*
11913: * Check for illegal attributes.
11914: */
11915: attr = node->properties;
11916: while (attr != NULL) {
11917: if (attr->ns == NULL) {
11918: if ((!xmlStrEqual(attr->name, BAD_CAST "id"))) {
11919: xmlSchemaPIllegalAttrErr(ctxt,
11920: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11921: }
11922: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
11923: xmlSchemaPIllegalAttrErr(ctxt,
11924: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
11925: }
11926: attr = attr->next;
11927: }
11928:
11929: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11930:
11931: /*
11932: * And now for the children...
11933: */
11934: child = node->children;
11935: if (IS_SCHEMA(child, "annotation")) {
11936: /*
11937: * Add the annotation to the complex type ancestor.
11938: */
11939: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
11940: xmlSchemaParseAnnotation(ctxt, child, 1));
11941: child = child->next;
11942: }
11943: if (child == NULL) {
11944: xmlSchemaPContentErr(ctxt,
11945: XML_SCHEMAP_S4S_ELEM_MISSING,
11946: NULL, node, NULL, NULL,
11947: "(annotation?, (restriction | extension))");
11948: }
11949: if (child == NULL) {
11950: xmlSchemaPContentErr(ctxt,
11951: XML_SCHEMAP_S4S_ELEM_MISSING,
11952: NULL, node, NULL, NULL,
11953: "(annotation?, (restriction | extension))");
11954: }
11955: if (IS_SCHEMA(child, "restriction")) {
11956: xmlSchemaParseRestriction(ctxt, schema, child,
11957: XML_SCHEMA_TYPE_SIMPLE_CONTENT);
11958: (*hasRestrictionOrExtension) = 1;
11959: child = child->next;
11960: } else if (IS_SCHEMA(child, "extension")) {
11961: xmlSchemaParseExtension(ctxt, schema, child,
11962: XML_SCHEMA_TYPE_SIMPLE_CONTENT);
11963: (*hasRestrictionOrExtension) = 1;
11964: child = child->next;
11965: }
11966: if (child != NULL) {
11967: xmlSchemaPContentErr(ctxt,
11968: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
11969: NULL, node, child, NULL,
11970: "(annotation?, (restriction | extension))");
11971: }
11972: return (0);
11973: }
11974:
11975: /**
11976: * xmlSchemaParseComplexContent:
11977: * @ctxt: a schema validation context
11978: * @schema: the schema being built
11979: * @node: a subtree containing XML Schema informations
11980: *
11981: * parse a XML schema ComplexContent definition
11982: * *WARNING* this interface is highly subject to change
11983: *
11984: * Returns the type definition or NULL in case of error
11985: */
11986: static int
11987: xmlSchemaParseComplexContent(xmlSchemaParserCtxtPtr ctxt,
11988: xmlSchemaPtr schema, xmlNodePtr node,
11989: int *hasRestrictionOrExtension)
11990: {
11991: xmlSchemaTypePtr type;
11992: xmlNodePtr child = NULL;
11993: xmlAttrPtr attr;
11994:
11995: if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
11996: (hasRestrictionOrExtension == NULL))
11997: return (-1);
11998: *hasRestrictionOrExtension = 0;
11999: /* Not a component, don't create it. */
12000: type = ctxt->ctxtType;
12001: /*
12002: * Check for illegal attributes.
12003: */
12004: attr = node->properties;
12005: while (attr != NULL) {
12006: if (attr->ns == NULL) {
12007: if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
12008: (!xmlStrEqual(attr->name, BAD_CAST "mixed")))
12009: {
12010: xmlSchemaPIllegalAttrErr(ctxt,
12011: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
12012: }
12013: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
12014: xmlSchemaPIllegalAttrErr(ctxt,
12015: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
12016: }
12017: attr = attr->next;
12018: }
12019:
12020: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
12021:
12022: /*
12023: * Set the 'mixed' on the complex type ancestor.
12024: */
12025: if (xmlGetBooleanProp(ctxt, node, "mixed", 0)) {
12026: if ((type->flags & XML_SCHEMAS_TYPE_MIXED) == 0)
12027: type->flags |= XML_SCHEMAS_TYPE_MIXED;
12028: }
12029: child = node->children;
12030: if (IS_SCHEMA(child, "annotation")) {
12031: /*
12032: * Add the annotation to the complex type ancestor.
12033: */
12034: xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
12035: xmlSchemaParseAnnotation(ctxt, child, 1));
12036: child = child->next;
12037: }
12038: if (child == NULL) {
12039: xmlSchemaPContentErr(ctxt,
12040: XML_SCHEMAP_S4S_ELEM_MISSING,
12041: NULL, node, NULL,
12042: NULL, "(annotation?, (restriction | extension))");
12043: }
12044: if (child == NULL) {
12045: xmlSchemaPContentErr(ctxt,
12046: XML_SCHEMAP_S4S_ELEM_MISSING,
12047: NULL, node, NULL,
12048: NULL, "(annotation?, (restriction | extension))");
12049: }
12050: if (IS_SCHEMA(child, "restriction")) {
12051: xmlSchemaParseRestriction(ctxt, schema, child,
12052: XML_SCHEMA_TYPE_COMPLEX_CONTENT);
12053: (*hasRestrictionOrExtension) = 1;
12054: child = child->next;
12055: } else if (IS_SCHEMA(child, "extension")) {
12056: xmlSchemaParseExtension(ctxt, schema, child,
12057: XML_SCHEMA_TYPE_COMPLEX_CONTENT);
12058: (*hasRestrictionOrExtension) = 1;
12059: child = child->next;
12060: }
12061: if (child != NULL) {
12062: xmlSchemaPContentErr(ctxt,
12063: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
12064: NULL, node, child,
12065: NULL, "(annotation?, (restriction | extension))");
12066: }
12067: return (0);
12068: }
12069:
12070: /**
12071: * xmlSchemaParseComplexType:
12072: * @ctxt: a schema validation context
12073: * @schema: the schema being built
12074: * @node: a subtree containing XML Schema informations
12075: *
12076: * parse a XML schema Complex Type definition
12077: * *WARNING* this interface is highly subject to change
12078: *
12079: * Returns the type definition or NULL in case of error
12080: */
12081: static xmlSchemaTypePtr
12082: xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
12083: xmlNodePtr node, int topLevel)
12084: {
12085: xmlSchemaTypePtr type, ctxtType;
12086: xmlNodePtr child = NULL;
12087: const xmlChar *name = NULL;
12088: xmlAttrPtr attr;
12089: const xmlChar *attrValue;
12090: #ifdef ENABLE_NAMED_LOCALS
12091: char buf[40];
12092: #endif
12093: int final = 0, block = 0, hasRestrictionOrExtension = 0;
12094:
12095:
12096: if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
12097: return (NULL);
12098:
12099: ctxtType = ctxt->ctxtType;
12100:
12101: if (topLevel) {
12102: attr = xmlSchemaGetPropNode(node, "name");
12103: if (attr == NULL) {
12104: xmlSchemaPMissingAttrErr(ctxt,
12105: XML_SCHEMAP_S4S_ATTR_MISSING, NULL, node, "name", NULL);
12106: return (NULL);
12107: } else if (xmlSchemaPValAttrNode(ctxt, NULL, attr,
12108: xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
12109: return (NULL);
12110: }
12111: }
12112:
12113: if (topLevel == 0) {
12114: /*
12115: * Parse as local complex type definition.
12116: */
12117: #ifdef ENABLE_NAMED_LOCALS
12118: snprintf(buf, 39, "#CT%d", ctxt->counter++ + 1);
12119: type = xmlSchemaAddType(ctxt, schema,
12120: XML_SCHEMA_TYPE_COMPLEX,
12121: xmlDictLookup(ctxt->dict, (const xmlChar *)buf, -1),
12122: ctxt->targetNamespace, node, 0);
12123: #else
12124: type = xmlSchemaAddType(ctxt, schema,
12125: XML_SCHEMA_TYPE_COMPLEX,
12126: NULL, ctxt->targetNamespace, node, 0);
12127: #endif
12128: if (type == NULL)
12129: return (NULL);
12130: name = type->name;
12131: type->node = node;
12132: type->type = XML_SCHEMA_TYPE_COMPLEX;
12133: /*
12134: * TODO: We need the target namespace.
12135: */
12136: } else {
12137: /*
12138: * Parse as global complex type definition.
12139: */
12140: type = xmlSchemaAddType(ctxt, schema,
12141: XML_SCHEMA_TYPE_COMPLEX,
12142: name, ctxt->targetNamespace, node, 1);
12143: if (type == NULL)
12144: return (NULL);
12145: type->node = node;
12146: type->type = XML_SCHEMA_TYPE_COMPLEX;
12147: type->flags |= XML_SCHEMAS_TYPE_GLOBAL;
12148: }
12149: type->targetNamespace = ctxt->targetNamespace;
12150: /*
12151: * Handle attributes.
12152: */
12153: attr = node->properties;
12154: while (attr != NULL) {
12155: if (attr->ns == NULL) {
12156: if (xmlStrEqual(attr->name, BAD_CAST "id")) {
12157: /*
12158: * Attribute "id".
12159: */
12160: xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
12161: } else if (xmlStrEqual(attr->name, BAD_CAST "mixed")) {
12162: /*
12163: * Attribute "mixed".
12164: */
12165: if (xmlSchemaPGetBoolNodeValue(ctxt,
12166: NULL, (xmlNodePtr) attr))
12167: type->flags |= XML_SCHEMAS_TYPE_MIXED;
12168: } else if (topLevel) {
12169: /*
12170: * Attributes of global complex type definitions.
12171: */
12172: if (xmlStrEqual(attr->name, BAD_CAST "name")) {
12173: /* Pass. */
12174: } else if (xmlStrEqual(attr->name, BAD_CAST "abstract")) {
12175: /*
12176: * Attribute "abstract".
12177: */
12178: if (xmlSchemaPGetBoolNodeValue(ctxt,
12179: NULL, (xmlNodePtr) attr))
12180: type->flags |= XML_SCHEMAS_TYPE_ABSTRACT;
12181: } else if (xmlStrEqual(attr->name, BAD_CAST "final")) {
12182: /*
12183: * Attribute "final".
12184: */
12185: attrValue = xmlSchemaGetNodeContent(ctxt,
12186: (xmlNodePtr) attr);
12187: if (xmlSchemaPValAttrBlockFinal(attrValue,
12188: &(type->flags),
12189: -1,
12190: XML_SCHEMAS_TYPE_FINAL_EXTENSION,
12191: XML_SCHEMAS_TYPE_FINAL_RESTRICTION,
12192: -1, -1, -1) != 0)
12193: {
12194: xmlSchemaPSimpleTypeErr(ctxt,
12195: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
12196: NULL, (xmlNodePtr) attr, NULL,
12197: "(#all | List of (extension | restriction))",
12198: attrValue, NULL, NULL, NULL);
12199: } else
12200: final = 1;
12201: } else if (xmlStrEqual(attr->name, BAD_CAST "block")) {
12202: /*
12203: * Attribute "block".
12204: */
12205: attrValue = xmlSchemaGetNodeContent(ctxt,
12206: (xmlNodePtr) attr);
12207: if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
12208: -1,
12209: XML_SCHEMAS_TYPE_BLOCK_EXTENSION,
12210: XML_SCHEMAS_TYPE_BLOCK_RESTRICTION,
12211: -1, -1, -1) != 0) {
12212: xmlSchemaPSimpleTypeErr(ctxt,
12213: XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
12214: NULL, (xmlNodePtr) attr, NULL,
12215: "(#all | List of (extension | restriction)) ",
12216: attrValue, NULL, NULL, NULL);
12217: } else
12218: block = 1;
12219: } else {
12220: xmlSchemaPIllegalAttrErr(ctxt,
12221: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
12222: }
12223: } else {
12224: xmlSchemaPIllegalAttrErr(ctxt,
12225: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
12226: }
12227: } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
12228: xmlSchemaPIllegalAttrErr(ctxt,
12229: XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
12230: }
12231: attr = attr->next;
12232: }
12233: if (! block) {
12234: /*
12235: * Apply default "block" values.
12236: */
12237: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
12238: type->flags |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
12239: if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION)
12240: type->flags |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
12241: }
12242: if (! final) {
12243: /*
12244: * Apply default "block" values.
12245: */
12246: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION)
12247: type->flags |= XML_SCHEMAS_TYPE_FINAL_RESTRICTION;
12248: if (schema->flags & XML_SCHEMAS_FINAL_DEFAULT_EXTENSION)
12249: type->flags |= XML_SCHEMAS_TYPE_FINAL_EXTENSION;
12250: }
12251: /*
12252: * And now for the children...
12253: */
12254: child = node->children;
12255: if (IS_SCHEMA(child, "annotation")) {
12256: type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
12257: child = child->next;
12258: }
12259: ctxt->ctxtType = type;
12260: if (IS_SCHEMA(child, "simpleContent")) {
12261: /*
12262: * <complexType><simpleContent>...
12263: * 3.4.3 : 2.2
12264: * Specifying mixed='true' when the <simpleContent>
12265: * alternative is chosen has no effect
12266: */
12267: if (type->flags & XML_SCHEMAS_TYPE_MIXED)
12268: type->flags ^= XML_SCHEMAS_TYPE_MIXED;
12269: xmlSchemaParseSimpleContent(ctxt, schema, child,
12270: &hasRestrictionOrExtension);
12271: child = child->next;
12272: } else if (IS_SCHEMA(child, "complexContent")) {
12273: /*
12274: * <complexType><complexContent>...
12275: */
12276: type->contentType = XML_SCHEMA_CONTENT_EMPTY;
12277: xmlSchemaParseComplexContent(ctxt, schema, child,
12278: &hasRestrictionOrExtension);
12279: child = child->next;
12280: } else {
12281: /*
12282: * E.g <complexType><sequence>... or <complexType><attribute>... etc.
12283: *
12284: * SPEC
12285: * "...the third alternative (neither <simpleContent> nor
12286: * <complexContent>) is chosen. This case is understood as shorthand
12287: * for complex content restricting the �ur-type definition�, and the
12288: * details of the mappings should be modified as necessary.
12289: */
12290: type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
12291: type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
12292: /*
12293: * Parse model groups.
12294: */
12295: if (IS_SCHEMA(child, "all")) {
12296: type->subtypes = (xmlSchemaTypePtr)
12297: xmlSchemaParseModelGroup(ctxt, schema, child,
12298: XML_SCHEMA_TYPE_ALL, 1);
12299: child = child->next;
12300: } else if (IS_SCHEMA(child, "choice")) {
12301: type->subtypes = (xmlSchemaTypePtr)
12302: xmlSchemaParseModelGroup(ctxt, schema, child,
12303: XML_SCHEMA_TYPE_CHOICE, 1);
12304: child = child->next;
12305: } else if (IS_SCHEMA(child, "sequence")) {
12306: type->subtypes = (xmlSchemaTypePtr)
12307: xmlSchemaParseModelGroup(ctxt, schema, child,
12308: XML_SCHEMA_TYPE_SEQUENCE, 1);
12309: child = child->next;
12310: } else if (IS_SCHEMA(child, "group")) {
12311: type->subtypes = (xmlSchemaTypePtr)
12312: xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
12313: /*
12314: * Note that the reference will be resolved in
12315: * xmlSchemaResolveTypeReferences();
12316: */
12317: child = child->next;
12318: }
12319: /*
12320: * Parse attribute decls/refs.
12321: */
12322: if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
12323: (xmlSchemaItemListPtr *) &(type->attrUses),
12324: XML_SCHEMA_TYPE_RESTRICTION, NULL) == -1)
12325: return(NULL);
12326: /*
12327: * Parse attribute wildcard.
12328: */
12329: if (IS_SCHEMA(child, "anyAttribute")) {
12330: type->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
12331: child = child->next;
12332: }
12333: }
12334: if (child != NULL) {
12335: xmlSchemaPContentErr(ctxt,
12336: XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
12337: NULL, node, child,
12338: NULL, "(annotation?, (simpleContent | complexContent | "
12339: "((group | all | choice | sequence)?, ((attribute | "
12340: "attributeGroup)*, anyAttribute?))))");
12341: }
12342: /*
12343: * REDEFINE: SPEC src-redefine (5)
12344: */
12345: if (topLevel && ctxt->isRedefine && (! hasRestrictionOrExtension)) {
12346: xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
12347: NULL, node, "This is a redefinition, thus the "
12348: "<complexType> must have a <restriction> or <extension> "
12349: "grand-child", NULL);
12350: }
12351: ctxt->ctxtType = ctxtType;
12352: return (type);
12353: }
12354:
12355: /************************************************************************
12356: * *
12357: * Validating using Schemas *
12358: * *
12359: ************************************************************************/
12360:
12361: /************************************************************************
12362: * *
12363: * Reading/Writing Schemas *
12364: * *
12365: ************************************************************************/
12366:
12367: #if 0 /* Will be enabled if it is clear what options are needed. */
12368: /**
12369: * xmlSchemaParserCtxtSetOptions:
12370: * @ctxt: a schema parser context
12371: * @options: a combination of xmlSchemaParserOption
12372: *
12373: * Sets the options to be used during the parse.
12374: *
12375: * Returns 0 in case of success, -1 in case of an
12376: * API error.
12377: */
12378: static int
12379: xmlSchemaParserCtxtSetOptions(xmlSchemaParserCtxtPtr ctxt,
12380: int options)
12381:
12382: {
12383: int i;
12384:
12385: if (ctxt == NULL)
12386: return (-1);
12387: /*
12388: * WARNING: Change the start value if adding to the
12389: * xmlSchemaParseOption.
12390: */
12391: for (i = 1; i < (int) sizeof(int) * 8; i++) {
12392: if (options & 1<<i) {
12393: return (-1);
12394: }
12395: }
12396: ctxt->options = options;
12397: return (0);
12398: }
12399:
12400: /**
12401: * xmlSchemaValidCtxtGetOptions:
12402: * @ctxt: a schema parser context
12403: *
12404: * Returns the option combination of the parser context.
12405: */
12406: static int
12407: xmlSchemaParserCtxtGetOptions(xmlSchemaParserCtxtPtr ctxt)
12408:
12409: {
12410: if (ctxt == NULL)
12411: return (-1);
12412: else
12413: return (ctxt->options);
12414: }
12415: #endif
12416:
12417: /**
12418: * xmlSchemaNewParserCtxt:
12419: * @URL: the location of the schema
12420: *
12421: * Create an XML Schemas parse context for that file/resource expected
12422: * to contain an XML Schemas file.
12423: *
12424: * Returns the parser context or NULL in case of error
12425: */
12426: xmlSchemaParserCtxtPtr
12427: xmlSchemaNewParserCtxt(const char *URL)
12428: {
12429: xmlSchemaParserCtxtPtr ret;
12430:
12431: if (URL == NULL)
12432: return (NULL);
12433:
12434: ret = xmlSchemaParserCtxtCreate();
12435: if (ret == NULL)
12436: return(NULL);
12437: ret->dict = xmlDictCreate();
12438: ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
12439: return (ret);
12440: }
12441:
12442: /**
12443: * xmlSchemaNewMemParserCtxt:
12444: * @buffer: a pointer to a char array containing the schemas
12445: * @size: the size of the array
12446: *
12447: * Create an XML Schemas parse context for that memory buffer expected
12448: * to contain an XML Schemas file.
12449: *
12450: * Returns the parser context or NULL in case of error
12451: */
12452: xmlSchemaParserCtxtPtr
12453: xmlSchemaNewMemParserCtxt(const char *buffer, int size)
12454: {
12455: xmlSchemaParserCtxtPtr ret;
12456:
12457: if ((buffer == NULL) || (size <= 0))
12458: return (NULL);
12459: ret = xmlSchemaParserCtxtCreate();
12460: if (ret == NULL)
12461: return(NULL);
12462: ret->buffer = buffer;
12463: ret->size = size;
12464: ret->dict = xmlDictCreate();
12465: return (ret);
12466: }
12467:
12468: /**
12469: * xmlSchemaNewDocParserCtxt:
12470: * @doc: a preparsed document tree
12471: *
12472: * Create an XML Schemas parse context for that document.
12473: * NB. The document may be modified during the parsing process.
12474: *
12475: * Returns the parser context or NULL in case of error
12476: */
12477: xmlSchemaParserCtxtPtr
12478: xmlSchemaNewDocParserCtxt(xmlDocPtr doc)
12479: {
12480: xmlSchemaParserCtxtPtr ret;
12481:
12482: if (doc == NULL)
12483: return (NULL);
12484: ret = xmlSchemaParserCtxtCreate();
12485: if (ret == NULL)
12486: return(NULL);
12487: ret->doc = doc;
12488: ret->dict = xmlDictCreate();
12489: /* The application has responsibility for the document */
12490: ret->preserve = 1;
12491:
12492: return (ret);
12493: }
12494:
12495: /**
12496: * xmlSchemaFreeParserCtxt:
12497: * @ctxt: the schema parser context
12498: *
12499: * Free the resources associated to the schema parser context
12500: */
12501: void
12502: xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt)
12503: {
12504: if (ctxt == NULL)
12505: return;
12506: if (ctxt->doc != NULL && !ctxt->preserve)
12507: xmlFreeDoc(ctxt->doc);
12508: if (ctxt->vctxt != NULL) {
12509: xmlSchemaFreeValidCtxt(ctxt->vctxt);
12510: }
12511: if (ctxt->ownsConstructor && (ctxt->constructor != NULL)) {
12512: xmlSchemaConstructionCtxtFree(ctxt->constructor);
12513: ctxt->constructor = NULL;
12514: ctxt->ownsConstructor = 0;
12515: }
12516: if (ctxt->attrProhibs != NULL)
12517: xmlSchemaItemListFree(ctxt->attrProhibs);
12518: xmlDictFree(ctxt->dict);
12519: xmlFree(ctxt);
12520: }
12521:
12522: /************************************************************************
12523: * *
12524: * Building the content models *
12525: * *
12526: ************************************************************************/
12527:
12528: /**
12529: * xmlSchemaBuildContentModelForSubstGroup:
12530: *
12531: * Returns 1 if nillable, 0 otherwise
12532: */
12533: static int
12534: xmlSchemaBuildContentModelForSubstGroup(xmlSchemaParserCtxtPtr pctxt,
12535: xmlSchemaParticlePtr particle, int counter, xmlAutomataStatePtr end)
12536: {
12537: xmlAutomataStatePtr start, tmp;
12538: xmlSchemaElementPtr elemDecl, member;
12539: xmlSchemaSubstGroupPtr substGroup;
12540: int i;
12541: int ret = 0;
12542:
12543: elemDecl = (xmlSchemaElementPtr) particle->children;
12544: /*
12545: * Wrap the substitution group with a CHOICE.
12546: */
12547: start = pctxt->state;
12548: if (end == NULL)
12549: end = xmlAutomataNewState(pctxt->am);
12550: substGroup = xmlSchemaSubstGroupGet(pctxt, elemDecl);
12551: if (substGroup == NULL) {
12552: xmlSchemaPErr(pctxt, WXS_ITEM_NODE(particle),
12553: XML_SCHEMAP_INTERNAL,
12554: "Internal error: xmlSchemaBuildContentModelForSubstGroup, "
12555: "declaration is marked having a subst. group but none "
12556: "available.\n", elemDecl->name, NULL);
12557: return(0);
12558: }
12559: if (counter >= 0) {
12560: /*
12561: * NOTE that we put the declaration in, even if it's abstract.
12562: * However, an error will be raised during *validation* if an element
12563: * information item shall be validated against an abstract element
12564: * declaration.
12565: */
12566: tmp = xmlAutomataNewCountedTrans(pctxt->am, start, NULL, counter);
12567: xmlAutomataNewTransition2(pctxt->am, tmp, end,
12568: elemDecl->name, elemDecl->targetNamespace, elemDecl);
12569: /*
12570: * Add subst. group members.
12571: */
12572: for (i = 0; i < substGroup->members->nbItems; i++) {
12573: member = (xmlSchemaElementPtr) substGroup->members->items[i];
12574: xmlAutomataNewTransition2(pctxt->am, tmp, end,
12575: member->name, member->targetNamespace, member);
12576: }
12577: } else if (particle->maxOccurs == 1) {
12578: /*
12579: * NOTE that we put the declaration in, even if it's abstract,
12580: */
12581: xmlAutomataNewEpsilon(pctxt->am,
12582: xmlAutomataNewTransition2(pctxt->am,
12583: start, NULL,
12584: elemDecl->name, elemDecl->targetNamespace, elemDecl), end);
12585: /*
12586: * Add subst. group members.
12587: */
12588: for (i = 0; i < substGroup->members->nbItems; i++) {
12589: member = (xmlSchemaElementPtr) substGroup->members->items[i];
12590: /*
12591: * NOTE: This fixes bug #341150. xmlAutomataNewOnceTrans2()
12592: * was incorrectly used instead of xmlAutomataNewTransition2()
12593: * (seems like a copy&paste bug from the XML_SCHEMA_TYPE_ALL
12594: * section in xmlSchemaBuildAContentModel() ).
12595: * TODO: Check if xmlAutomataNewOnceTrans2() was instead
12596: * intended for the above "counter" section originally. I.e.,
12597: * check xs:all with subst-groups.
12598: *
12599: * tmp = xmlAutomataNewOnceTrans2(pctxt->am, start, NULL,
12600: * member->name, member->targetNamespace,
12601: * 1, 1, member);
12602: */
12603: tmp = xmlAutomataNewTransition2(pctxt->am, start, NULL,
12604: member->name, member->targetNamespace, member);
12605: xmlAutomataNewEpsilon(pctxt->am, tmp, end);
12606: }
12607: } else {
12608: xmlAutomataStatePtr hop;
12609: int maxOccurs = particle->maxOccurs == UNBOUNDED ?
12610: UNBOUNDED : particle->maxOccurs - 1;
12611: int minOccurs = particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
12612:
12613: counter =
12614: xmlAutomataNewCounter(pctxt->am, minOccurs,
12615: maxOccurs);
12616: hop = xmlAutomataNewState(pctxt->am);
12617:
12618: xmlAutomataNewEpsilon(pctxt->am,
12619: xmlAutomataNewTransition2(pctxt->am,
12620: start, NULL,
12621: elemDecl->name, elemDecl->targetNamespace, elemDecl),
12622: hop);
12623: /*
12624: * Add subst. group members.
12625: */
12626: for (i = 0; i < substGroup->members->nbItems; i++) {
12627: member = (xmlSchemaElementPtr) substGroup->members->items[i];
12628: xmlAutomataNewEpsilon(pctxt->am,
12629: xmlAutomataNewTransition2(pctxt->am,
12630: start, NULL,
12631: member->name, member->targetNamespace, member),
12632: hop);
12633: }
12634: xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
12635: xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
12636: }
12637: if (particle->minOccurs == 0) {
12638: xmlAutomataNewEpsilon(pctxt->am, start, end);
12639: ret = 1;
12640: }
12641: pctxt->state = end;
12642: return(ret);
12643: }
12644:
12645: /**
12646: * xmlSchemaBuildContentModelForElement:
12647: *
12648: * Returns 1 if nillable, 0 otherwise
12649: */
12650: static int
12651: xmlSchemaBuildContentModelForElement(xmlSchemaParserCtxtPtr ctxt,
12652: xmlSchemaParticlePtr particle)
12653: {
12654: int ret = 0;
12655:
12656: if (((xmlSchemaElementPtr) particle->children)->flags &
12657: XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
12658: /*
12659: * Substitution groups.
12660: */
12661: ret = xmlSchemaBuildContentModelForSubstGroup(ctxt, particle, -1, NULL);
12662: } else {
12663: xmlSchemaElementPtr elemDecl;
12664: xmlAutomataStatePtr start;
12665:
12666: elemDecl = (xmlSchemaElementPtr) particle->children;
12667:
12668: if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT)
12669: return(0);
12670: if (particle->maxOccurs == 1) {
12671: start = ctxt->state;
12672: ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
12673: elemDecl->name, elemDecl->targetNamespace, elemDecl);
12674: } else if ((particle->maxOccurs >= UNBOUNDED) &&
12675: (particle->minOccurs < 2)) {
12676: /* Special case. */
12677: start = ctxt->state;
12678: ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
12679: elemDecl->name, elemDecl->targetNamespace, elemDecl);
12680: ctxt->state = xmlAutomataNewTransition2(ctxt->am, ctxt->state, ctxt->state,
12681: elemDecl->name, elemDecl->targetNamespace, elemDecl);
12682: } else {
12683: int counter;
12684: int maxOccurs = particle->maxOccurs == UNBOUNDED ?
12685: UNBOUNDED : particle->maxOccurs - 1;
12686: int minOccurs = particle->minOccurs < 1 ?
12687: 0 : particle->minOccurs - 1;
12688:
12689: start = xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
12690: counter = xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs);
12691: ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
12692: elemDecl->name, elemDecl->targetNamespace, elemDecl);
12693: xmlAutomataNewCountedTrans(ctxt->am, ctxt->state, start, counter);
12694: ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, ctxt->state,
12695: NULL, counter);
12696: }
12697: if (particle->minOccurs == 0) {
12698: xmlAutomataNewEpsilon(ctxt->am, start, ctxt->state);
12699: ret = 1;
12700: }
12701: }
12702: return(ret);
12703: }
12704:
12705: /**
12706: * xmlSchemaBuildAContentModel:
12707: * @ctxt: the schema parser context
12708: * @particle: the particle component
12709: * @name: the complex type's name whose content is being built
12710: *
12711: * Create the automaton for the {content type} of a complex type.
12712: *
12713: * Returns 1 if the content is nillable, 0 otherwise
12714: */
12715: static int
12716: xmlSchemaBuildAContentModel(xmlSchemaParserCtxtPtr pctxt,
12717: xmlSchemaParticlePtr particle)
12718: {
12719: int ret = 0, tmp2;
12720:
12721: if (particle == NULL) {
12722: PERROR_INT("xmlSchemaBuildAContentModel", "particle is NULL");
12723: return(1);
12724: }
12725: if (particle->children == NULL) {
12726: /*
12727: * Just return in this case. A missing "term" of the particle
12728: * might arise due to an invalid "term" component.
12729: */
12730: return(1);
12731: }
12732:
12733: switch (particle->children->type) {
12734: case XML_SCHEMA_TYPE_ANY: {
12735: xmlAutomataStatePtr start, end;
12736: xmlSchemaWildcardPtr wild;
12737: xmlSchemaWildcardNsPtr ns;
12738:
12739: wild = (xmlSchemaWildcardPtr) particle->children;
12740:
12741: start = pctxt->state;
12742: end = xmlAutomataNewState(pctxt->am);
12743:
12744: if (particle->maxOccurs == 1) {
12745: if (wild->any == 1) {
12746: /*
12747: * We need to add both transitions:
12748: *
12749: * 1. the {"*", "*"} for elements in a namespace.
12750: */
12751: pctxt->state =
12752: xmlAutomataNewTransition2(pctxt->am,
12753: start, NULL, BAD_CAST "*", BAD_CAST "*", wild);
12754: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
12755: /*
12756: * 2. the {"*"} for elements in no namespace.
12757: */
12758: pctxt->state =
12759: xmlAutomataNewTransition2(pctxt->am,
12760: start, NULL, BAD_CAST "*", NULL, wild);
12761: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
12762:
12763: } else if (wild->nsSet != NULL) {
12764: ns = wild->nsSet;
12765: do {
12766: pctxt->state = start;
12767: pctxt->state = xmlAutomataNewTransition2(pctxt->am,
12768: pctxt->state, NULL, BAD_CAST "*", ns->value, wild);
12769: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
12770: ns = ns->next;
12771: } while (ns != NULL);
12772:
12773: } else if (wild->negNsSet != NULL) {
12774: pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
12775: start, end, BAD_CAST "*", wild->negNsSet->value,
12776: wild);
12777: }
12778: } else {
12779: int counter;
12780: xmlAutomataStatePtr hop;
12781: int maxOccurs =
12782: particle->maxOccurs == UNBOUNDED ? UNBOUNDED :
12783: particle->maxOccurs - 1;
12784: int minOccurs =
12785: particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
12786:
12787: counter = xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
12788: hop = xmlAutomataNewState(pctxt->am);
12789: if (wild->any == 1) {
12790: pctxt->state =
12791: xmlAutomataNewTransition2(pctxt->am,
12792: start, NULL, BAD_CAST "*", BAD_CAST "*", wild);
12793: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
12794: pctxt->state =
12795: xmlAutomataNewTransition2(pctxt->am,
12796: start, NULL, BAD_CAST "*", NULL, wild);
12797: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
12798: } else if (wild->nsSet != NULL) {
12799: ns = wild->nsSet;
12800: do {
12801: pctxt->state =
12802: xmlAutomataNewTransition2(pctxt->am,
12803: start, NULL, BAD_CAST "*", ns->value, wild);
12804: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
12805: ns = ns->next;
12806: } while (ns != NULL);
12807:
12808: } else if (wild->negNsSet != NULL) {
12809: pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
12810: start, hop, BAD_CAST "*", wild->negNsSet->value,
12811: wild);
12812: }
12813: xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
12814: xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
12815: }
12816: if (particle->minOccurs == 0) {
12817: xmlAutomataNewEpsilon(pctxt->am, start, end);
12818: ret = 1;
12819: }
12820: pctxt->state = end;
12821: break;
12822: }
12823: case XML_SCHEMA_TYPE_ELEMENT:
12824: ret = xmlSchemaBuildContentModelForElement(pctxt, particle);
12825: break;
12826: case XML_SCHEMA_TYPE_SEQUENCE:{
12827: xmlSchemaTreeItemPtr sub;
12828:
12829: ret = 1;
12830: /*
12831: * If max and min occurances are default (1) then
12832: * simply iterate over the particles of the <sequence>.
12833: */
12834: if ((particle->minOccurs == 1) && (particle->maxOccurs == 1)) {
12835: sub = particle->children->children;
12836:
12837: while (sub != NULL) {
12838: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12839: (xmlSchemaParticlePtr) sub);
12840: if (tmp2 != 1) ret = 0;
12841: sub = sub->next;
12842: }
12843: } else {
12844: xmlAutomataStatePtr oldstate = pctxt->state;
12845:
12846: if (particle->maxOccurs >= UNBOUNDED) {
12847: if (particle->minOccurs > 1) {
12848: xmlAutomataStatePtr tmp;
12849: int counter;
12850:
12851: pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
12852: oldstate, NULL);
12853: oldstate = pctxt->state;
12854:
12855: counter = xmlAutomataNewCounter(pctxt->am,
12856: particle->minOccurs - 1, UNBOUNDED);
12857:
12858: sub = particle->children->children;
12859: while (sub != NULL) {
12860: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12861: (xmlSchemaParticlePtr) sub);
12862: if (tmp2 != 1) ret = 0;
12863: sub = sub->next;
12864: }
12865: tmp = pctxt->state;
12866: xmlAutomataNewCountedTrans(pctxt->am, tmp,
12867: oldstate, counter);
12868: pctxt->state =
12869: xmlAutomataNewCounterTrans(pctxt->am, tmp,
12870: NULL, counter);
12871: if (ret == 1)
12872: xmlAutomataNewEpsilon(pctxt->am,
12873: oldstate, pctxt->state);
12874:
12875: } else {
12876: pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
12877: oldstate, NULL);
12878: oldstate = pctxt->state;
12879:
12880: sub = particle->children->children;
12881: while (sub != NULL) {
12882: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12883: (xmlSchemaParticlePtr) sub);
12884: if (tmp2 != 1) ret = 0;
12885: sub = sub->next;
12886: }
12887: xmlAutomataNewEpsilon(pctxt->am, pctxt->state,
12888: oldstate);
12889: /*
12890: * epsilon needed to block previous trans from
12891: * being allowed to enter back from another
12892: * construct
12893: */
12894: pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
12895: pctxt->state, NULL);
12896: if (particle->minOccurs == 0) {
12897: xmlAutomataNewEpsilon(pctxt->am,
12898: oldstate, pctxt->state);
12899: ret = 1;
12900: }
12901: }
12902: } else if ((particle->maxOccurs > 1)
12903: || (particle->minOccurs > 1)) {
12904: xmlAutomataStatePtr tmp;
12905: int counter;
12906:
12907: pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
12908: oldstate, NULL);
12909: oldstate = pctxt->state;
12910:
12911: counter = xmlAutomataNewCounter(pctxt->am,
12912: particle->minOccurs - 1,
12913: particle->maxOccurs - 1);
12914:
12915: sub = particle->children->children;
12916: while (sub != NULL) {
12917: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12918: (xmlSchemaParticlePtr) sub);
12919: if (tmp2 != 1) ret = 0;
12920: sub = sub->next;
12921: }
12922: tmp = pctxt->state;
12923: xmlAutomataNewCountedTrans(pctxt->am,
12924: tmp, oldstate, counter);
12925: pctxt->state =
12926: xmlAutomataNewCounterTrans(pctxt->am, tmp, NULL,
12927: counter);
12928: if ((particle->minOccurs == 0) || (ret == 1)) {
12929: xmlAutomataNewEpsilon(pctxt->am,
12930: oldstate, pctxt->state);
12931: ret = 1;
12932: }
12933: } else {
12934: sub = particle->children->children;
12935: while (sub != NULL) {
12936: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12937: (xmlSchemaParticlePtr) sub);
12938: if (tmp2 != 1) ret = 0;
12939: sub = sub->next;
12940: }
12941: if (particle->minOccurs == 0) {
12942: xmlAutomataNewEpsilon(pctxt->am, oldstate,
12943: pctxt->state);
12944: ret = 1;
12945: }
12946: }
12947: }
12948: break;
12949: }
12950: case XML_SCHEMA_TYPE_CHOICE:{
12951: xmlSchemaTreeItemPtr sub;
12952: xmlAutomataStatePtr start, end;
12953:
12954: ret = 0;
12955: start = pctxt->state;
12956: end = xmlAutomataNewState(pctxt->am);
12957:
12958: /*
12959: * iterate over the subtypes and remerge the end with an
12960: * epsilon transition
12961: */
12962: if (particle->maxOccurs == 1) {
12963: sub = particle->children->children;
12964: while (sub != NULL) {
12965: pctxt->state = start;
12966: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12967: (xmlSchemaParticlePtr) sub);
12968: if (tmp2 == 1) ret = 1;
12969: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
12970: sub = sub->next;
12971: }
12972: } else {
12973: int counter;
12974: xmlAutomataStatePtr hop, base;
12975: int maxOccurs = particle->maxOccurs == UNBOUNDED ?
12976: UNBOUNDED : particle->maxOccurs - 1;
12977: int minOccurs =
12978: particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
12979:
12980: /*
12981: * use a counter to keep track of the number of transtions
12982: * which went through the choice.
12983: */
12984: counter =
12985: xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
12986: hop = xmlAutomataNewState(pctxt->am);
12987: base = xmlAutomataNewState(pctxt->am);
12988:
12989: sub = particle->children->children;
12990: while (sub != NULL) {
12991: pctxt->state = base;
12992: tmp2 = xmlSchemaBuildAContentModel(pctxt,
12993: (xmlSchemaParticlePtr) sub);
12994: if (tmp2 == 1) ret = 1;
12995: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
12996: sub = sub->next;
12997: }
12998: xmlAutomataNewEpsilon(pctxt->am, start, base);
12999: xmlAutomataNewCountedTrans(pctxt->am, hop, base, counter);
13000: xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
13001: if (ret == 1)
13002: xmlAutomataNewEpsilon(pctxt->am, base, end);
13003: }
13004: if (particle->minOccurs == 0) {
13005: xmlAutomataNewEpsilon(pctxt->am, start, end);
13006: ret = 1;
13007: }
13008: pctxt->state = end;
13009: break;
13010: }
13011: case XML_SCHEMA_TYPE_ALL:{
13012: xmlAutomataStatePtr start, tmp;
13013: xmlSchemaParticlePtr sub;
13014: xmlSchemaElementPtr elemDecl;
13015:
13016: ret = 1;
13017:
13018: sub = (xmlSchemaParticlePtr) particle->children->children;
13019: if (sub == NULL)
13020: break;
13021:
13022: ret = 0;
13023:
13024: start = pctxt->state;
13025: tmp = xmlAutomataNewState(pctxt->am);
13026: xmlAutomataNewEpsilon(pctxt->am, pctxt->state, tmp);
13027: pctxt->state = tmp;
13028: while (sub != NULL) {
13029: pctxt->state = tmp;
13030:
13031: elemDecl = (xmlSchemaElementPtr) sub->children;
13032: if (elemDecl == NULL) {
13033: PERROR_INT("xmlSchemaBuildAContentModel",
13034: "<element> particle has no term");
13035: return(ret);
13036: };
13037: /*
13038: * NOTE: The {max occurs} of all the particles in the
13039: * {particles} of the group must be 0 or 1; this is
13040: * already ensured during the parse of the content of
13041: * <all>.
13042: */
13043: if (elemDecl->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
13044: int counter;
13045:
13046: /*
13047: * This is an abstract group, we need to share
13048: * the same counter for all the element transitions
13049: * derived from the group
13050: */
13051: counter = xmlAutomataNewCounter(pctxt->am,
13052: sub->minOccurs, sub->maxOccurs);
13053: xmlSchemaBuildContentModelForSubstGroup(pctxt,
13054: sub, counter, pctxt->state);
13055: } else {
13056: if ((sub->minOccurs == 1) &&
13057: (sub->maxOccurs == 1)) {
13058: xmlAutomataNewOnceTrans2(pctxt->am, pctxt->state,
13059: pctxt->state,
13060: elemDecl->name,
13061: elemDecl->targetNamespace,
13062: 1, 1, elemDecl);
13063: } else if ((sub->minOccurs == 0) &&
13064: (sub->maxOccurs == 1)) {
13065:
13066: xmlAutomataNewCountTrans2(pctxt->am, pctxt->state,
13067: pctxt->state,
13068: elemDecl->name,
13069: elemDecl->targetNamespace,
13070: 0,
13071: 1,
13072: elemDecl);
13073: }
13074: }
13075: sub = (xmlSchemaParticlePtr) sub->next;
13076: }
13077: pctxt->state =
13078: xmlAutomataNewAllTrans(pctxt->am, pctxt->state, NULL, 0);
13079: if (particle->minOccurs == 0) {
13080: xmlAutomataNewEpsilon(pctxt->am, start, pctxt->state);
13081: ret = 1;
13082: }
13083: break;
13084: }
13085: case XML_SCHEMA_TYPE_GROUP:
13086: /*
13087: * If we hit a model group definition, then this means that
13088: * it was empty, thus was not substituted for the containing
13089: * model group. Just do nothing in this case.
13090: * TODO: But the group should be substituted and not occur at
13091: * all in the content model at this point. Fix this.
13092: */
13093: ret = 1;
13094: break;
13095: default:
13096: xmlSchemaInternalErr2(ACTXT_CAST pctxt,
13097: "xmlSchemaBuildAContentModel",
13098: "found unexpected term of type '%s' in content model",
13099: WXS_ITEM_TYPE_NAME(particle->children), NULL);
13100: return(ret);
13101: }
13102: return(ret);
13103: }
13104:
13105: /**
13106: * xmlSchemaBuildContentModel:
13107: * @ctxt: the schema parser context
13108: * @type: the complex type definition
13109: * @name: the element name
13110: *
13111: * Builds the content model of the complex type.
13112: */
13113: static void
13114: xmlSchemaBuildContentModel(xmlSchemaTypePtr type,
13115: xmlSchemaParserCtxtPtr ctxt)
13116: {
13117: if ((type->type != XML_SCHEMA_TYPE_COMPLEX) ||
13118: (type->contModel != NULL) ||
13119: ((type->contentType != XML_SCHEMA_CONTENT_ELEMENTS) &&
13120: (type->contentType != XML_SCHEMA_CONTENT_MIXED)))
13121: return;
13122:
13123: #ifdef DEBUG_CONTENT
13124: xmlGenericError(xmlGenericErrorContext,
13125: "Building content model for %s\n", name);
13126: #endif
13127: ctxt->am = NULL;
13128: ctxt->am = xmlNewAutomata();
13129: if (ctxt->am == NULL) {
13130: xmlGenericError(xmlGenericErrorContext,
13131: "Cannot create automata for complex type %s\n", type->name);
13132: return;
13133: }
13134: ctxt->state = xmlAutomataGetInitState(ctxt->am);
13135: /*
13136: * Build the automaton.
13137: */
13138: xmlSchemaBuildAContentModel(ctxt, WXS_TYPE_PARTICLE(type));
13139: xmlAutomataSetFinalState(ctxt->am, ctxt->state);
13140: type->contModel = xmlAutomataCompile(ctxt->am);
13141: if (type->contModel == NULL) {
13142: xmlSchemaPCustomErr(ctxt,
13143: XML_SCHEMAP_INTERNAL,
13144: WXS_BASIC_CAST type, type->node,
13145: "Failed to compile the content model", NULL);
13146: } else if (xmlRegexpIsDeterminist(type->contModel) != 1) {
13147: xmlSchemaPCustomErr(ctxt,
13148: XML_SCHEMAP_NOT_DETERMINISTIC,
13149: /* XML_SCHEMAS_ERR_NOTDETERMINIST, */
13150: WXS_BASIC_CAST type, type->node,
13151: "The content model is not determinist", NULL);
13152: } else {
13153: #ifdef DEBUG_CONTENT_REGEXP
13154: xmlGenericError(xmlGenericErrorContext,
13155: "Content model of %s:\n", type->name);
13156: xmlRegexpPrint(stderr, type->contModel);
13157: #endif
13158: }
13159: ctxt->state = NULL;
13160: xmlFreeAutomata(ctxt->am);
13161: ctxt->am = NULL;
13162: }
13163:
13164: /**
13165: * xmlSchemaResolveElementReferences:
13166: * @elem: the schema element context
13167: * @ctxt: the schema parser context
13168: *
13169: * Resolves the references of an element declaration
13170: * or particle, which has an element declaration as it's
13171: * term.
13172: */
13173: static void
13174: xmlSchemaResolveElementReferences(xmlSchemaElementPtr elemDecl,
13175: xmlSchemaParserCtxtPtr ctxt)
13176: {
13177: if ((ctxt == NULL) || (elemDecl == NULL) ||
13178: ((elemDecl != NULL) &&
13179: (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_RESOLVED)))
13180: return;
13181: elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_RESOLVED;
13182:
13183: if ((elemDecl->subtypes == NULL) && (elemDecl->namedType != NULL)) {
13184: xmlSchemaTypePtr type;
13185:
13186: /* (type definition) ... otherwise the type definition �resolved�
13187: * to by the �actual value� of the type [attribute] ...
13188: */
13189: type = xmlSchemaGetType(ctxt->schema, elemDecl->namedType,
13190: elemDecl->namedTypeNs);
13191: if (type == NULL) {
13192: xmlSchemaPResCompAttrErr(ctxt,
13193: XML_SCHEMAP_SRC_RESOLVE,
13194: WXS_BASIC_CAST elemDecl, elemDecl->node,
13195: "type", elemDecl->namedType, elemDecl->namedTypeNs,
13196: XML_SCHEMA_TYPE_BASIC, "type definition");
13197: } else
13198: elemDecl->subtypes = type;
13199: }
13200: if (elemDecl->substGroup != NULL) {
13201: xmlSchemaElementPtr substHead;
13202:
13203: /*
13204: * FIXME TODO: Do we need a new field in _xmlSchemaElement for
13205: * substitutionGroup?
13206: */
13207: substHead = xmlSchemaGetElem(ctxt->schema, elemDecl->substGroup,
13208: elemDecl->substGroupNs);
13209: if (substHead == NULL) {
13210: xmlSchemaPResCompAttrErr(ctxt,
13211: XML_SCHEMAP_SRC_RESOLVE,
13212: WXS_BASIC_CAST elemDecl, NULL,
13213: "substitutionGroup", elemDecl->substGroup,
13214: elemDecl->substGroupNs, XML_SCHEMA_TYPE_ELEMENT, NULL);
13215: } else {
13216: xmlSchemaResolveElementReferences(substHead, ctxt);
13217: /*
13218: * Set the "substitution group affiliation".
13219: * NOTE that now we use the "refDecl" field for this.
13220: */
13221: WXS_SUBST_HEAD(elemDecl) = substHead;
13222: /*
13223: * The type definitions is set to:
13224: * SPEC "...the {type definition} of the element
13225: * declaration �resolved� to by the �actual value�
13226: * of the substitutionGroup [attribute], if present"
13227: */
13228: if (elemDecl->subtypes == NULL)
13229: elemDecl->subtypes = substHead->subtypes;
13230: }
13231: }
13232: /*
13233: * SPEC "The definition of anyType serves as the default type definition
13234: * for element declarations whose XML representation does not specify one."
13235: */
13236: if ((elemDecl->subtypes == NULL) &&
13237: (elemDecl->namedType == NULL) &&
13238: (elemDecl->substGroup == NULL))
13239: elemDecl->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
13240: }
13241:
13242: /**
13243: * xmlSchemaResolveUnionMemberTypes:
13244: * @ctxt: the schema parser context
13245: * @type: the schema simple type definition
13246: *
13247: * Checks and builds the "member type definitions" property of the union
13248: * simple type. This handles part (1), part (2) is done in
13249: * xmlSchemaFinishMemberTypeDefinitionsProperty()
13250: *
13251: * Returns -1 in case of an internal error, 0 otherwise.
13252: */
13253: static int
13254: xmlSchemaResolveUnionMemberTypes(xmlSchemaParserCtxtPtr ctxt,
13255: xmlSchemaTypePtr type)
13256: {
13257:
13258: xmlSchemaTypeLinkPtr link, lastLink, newLink;
13259: xmlSchemaTypePtr memberType;
13260:
13261: /*
13262: * SPEC (1) "If the <union> alternative is chosen, then [Definition:]
13263: * define the explicit members as the type definitions �resolved�
13264: * to by the items in the �actual value� of the memberTypes [attribute],
13265: * if any, followed by the type definitions corresponding to the
13266: * <simpleType>s among the [children] of <union>, if any."
13267: */
13268: /*
13269: * Resolve references.
13270: */
13271: link = type->memberTypes;
13272: lastLink = NULL;
13273: while (link != NULL) {
13274: const xmlChar *name, *nsName;
13275:
13276: name = ((xmlSchemaQNameRefPtr) link->type)->name;
13277: nsName = ((xmlSchemaQNameRefPtr) link->type)->targetNamespace;
13278:
13279: memberType = xmlSchemaGetType(ctxt->schema, name, nsName);
13280: if ((memberType == NULL) || (! WXS_IS_SIMPLE(memberType))) {
13281: xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
13282: WXS_BASIC_CAST type, type->node, "memberTypes",
13283: name, nsName, XML_SCHEMA_TYPE_SIMPLE, NULL);
13284: /*
13285: * Remove the member type link.
13286: */
13287: if (lastLink == NULL)
13288: type->memberTypes = link->next;
13289: else
13290: lastLink->next = link->next;
13291: newLink = link;
13292: link = link->next;
13293: xmlFree(newLink);
13294: } else {
13295: link->type = memberType;
13296: lastLink = link;
13297: link = link->next;
13298: }
13299: }
13300: /*
13301: * Add local simple types,
13302: */
13303: memberType = type->subtypes;
13304: while (memberType != NULL) {
13305: link = (xmlSchemaTypeLinkPtr) xmlMalloc(sizeof(xmlSchemaTypeLink));
13306: if (link == NULL) {
13307: xmlSchemaPErrMemory(ctxt, "allocating a type link", NULL);
13308: return (-1);
13309: }
13310: link->type = memberType;
13311: link->next = NULL;
13312: if (lastLink == NULL)
13313: type->memberTypes = link;
13314: else
13315: lastLink->next = link;
13316: lastLink = link;
13317: memberType = memberType->next;
13318: }
13319: return (0);
13320: }
13321:
13322: /**
13323: * xmlSchemaIsDerivedFromBuiltInType:
13324: * @ctxt: the schema parser context
13325: * @type: the type definition
13326: * @valType: the value type
13327: *
13328: *
13329: * Returns 1 if the type has the given value type, or
13330: * is derived from such a type.
13331: */
13332: static int
13333: xmlSchemaIsDerivedFromBuiltInType(xmlSchemaTypePtr type, int valType)
13334: {
13335: if (type == NULL)
13336: return (0);
13337: if (WXS_IS_COMPLEX(type))
13338: return (0);
13339: if (type->type == XML_SCHEMA_TYPE_BASIC) {
13340: if (type->builtInType == valType)
13341: return(1);
13342: if ((type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) ||
13343: (type->builtInType == XML_SCHEMAS_ANYTYPE))
13344: return (0);
13345: return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
13346: }
13347: return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
13348: }
13349:
13350: #if 0
13351: /**
13352: * xmlSchemaIsDerivedFromBuiltInType:
13353: * @ctxt: the schema parser context
13354: * @type: the type definition
13355: * @valType: the value type
13356: *
13357: *
13358: * Returns 1 if the type has the given value type, or
13359: * is derived from such a type.
13360: */
13361: static int
13362: xmlSchemaIsUserDerivedFromBuiltInType(xmlSchemaTypePtr type, int valType)
13363: {
13364: if (type == NULL)
13365: return (0);
13366: if (WXS_IS_COMPLEX(type))
13367: return (0);
13368: if (type->type == XML_SCHEMA_TYPE_BASIC) {
13369: if (type->builtInType == valType)
13370: return(1);
13371: return (0);
13372: } else
13373: return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
13374:
13375: return (0);
13376: }
13377:
13378: static xmlSchemaTypePtr
13379: xmlSchemaQueryBuiltInType(xmlSchemaTypePtr type)
13380: {
13381: if (type == NULL)
13382: return (NULL);
13383: if (WXS_IS_COMPLEX(type))
13384: return (NULL);
13385: if (type->type == XML_SCHEMA_TYPE_BASIC)
13386: return(type);
13387: return(xmlSchemaQueryBuiltInType(type->subtypes));
13388: }
13389: #endif
13390:
13391: /**
13392: * xmlSchemaGetPrimitiveType:
13393: * @type: the simpleType definition
13394: *
13395: * Returns the primitive type of the given type or
13396: * NULL in case of error.
13397: */
13398: static xmlSchemaTypePtr
13399: xmlSchemaGetPrimitiveType(xmlSchemaTypePtr type)
13400: {
13401:
13402: while (type != NULL) {
13403: /*
13404: * Note that anySimpleType is actually not a primitive type
13405: * but we need that here.
13406: */
13407: if ((type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) ||
13408: (type->flags & XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE))
13409: return (type);
13410: type = type->baseType;
13411: }
13412:
13413: return (NULL);
13414: }
13415:
13416: #if 0
13417: /**
13418: * xmlSchemaGetBuiltInTypeAncestor:
13419: * @type: the simpleType definition
13420: *
13421: * Returns the primitive type of the given type or
13422: * NULL in case of error.
13423: */
13424: static xmlSchemaTypePtr
13425: xmlSchemaGetBuiltInTypeAncestor(xmlSchemaTypePtr type)
13426: {
13427: if (WXS_IS_LIST(type) || WXS_IS_UNION(type))
13428: return (0);
13429: while (type != NULL) {
13430: if (type->type == XML_SCHEMA_TYPE_BASIC)
13431: return (type);
13432: type = type->baseType;
13433: }
13434:
13435: return (NULL);
13436: }
13437: #endif
13438:
13439: /**
13440: * xmlSchemaCloneWildcardNsConstraints:
13441: * @ctxt: the schema parser context
13442: * @dest: the destination wildcard
13443: * @source: the source wildcard
13444: *
13445: * Clones the namespace constraints of source
13446: * and assignes them to dest.
13447: * Returns -1 on internal error, 0 otherwise.
13448: */
13449: static int
13450: xmlSchemaCloneWildcardNsConstraints(xmlSchemaParserCtxtPtr ctxt,
13451: xmlSchemaWildcardPtr dest,
13452: xmlSchemaWildcardPtr source)
13453: {
13454: xmlSchemaWildcardNsPtr cur, tmp, last;
13455:
13456: if ((source == NULL) || (dest == NULL))
13457: return(-1);
13458: dest->any = source->any;
13459: cur = source->nsSet;
13460: last = NULL;
13461: while (cur != NULL) {
13462: tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
13463: if (tmp == NULL)
13464: return(-1);
13465: tmp->value = cur->value;
13466: if (last == NULL)
13467: dest->nsSet = tmp;
13468: else
13469: last->next = tmp;
13470: last = tmp;
13471: cur = cur->next;
13472: }
13473: if (dest->negNsSet != NULL)
13474: xmlSchemaFreeWildcardNsSet(dest->negNsSet);
13475: if (source->negNsSet != NULL) {
13476: dest->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
13477: if (dest->negNsSet == NULL)
13478: return(-1);
13479: dest->negNsSet->value = source->negNsSet->value;
13480: } else
13481: dest->negNsSet = NULL;
13482: return(0);
13483: }
13484:
13485: /**
13486: * xmlSchemaUnionWildcards:
13487: * @ctxt: the schema parser context
13488: * @completeWild: the first wildcard
13489: * @curWild: the second wildcard
13490: *
13491: * Unions the namespace constraints of the given wildcards.
13492: * @completeWild will hold the resulting union.
13493: * Returns a positive error code on failure, -1 in case of an
13494: * internal error, 0 otherwise.
13495: */
13496: static int
13497: xmlSchemaUnionWildcards(xmlSchemaParserCtxtPtr ctxt,
13498: xmlSchemaWildcardPtr completeWild,
13499: xmlSchemaWildcardPtr curWild)
13500: {
13501: xmlSchemaWildcardNsPtr cur, curB, tmp;
13502:
13503: /*
13504: * 1 If O1 and O2 are the same value, then that value must be the
13505: * value.
13506: */
13507: if ((completeWild->any == curWild->any) &&
13508: ((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
13509: ((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
13510:
13511: if ((completeWild->negNsSet == NULL) ||
13512: (completeWild->negNsSet->value == curWild->negNsSet->value)) {
13513:
13514: if (completeWild->nsSet != NULL) {
13515: int found = 0;
13516:
13517: /*
13518: * Check equality of sets.
13519: */
13520: cur = completeWild->nsSet;
13521: while (cur != NULL) {
13522: found = 0;
13523: curB = curWild->nsSet;
13524: while (curB != NULL) {
13525: if (cur->value == curB->value) {
13526: found = 1;
13527: break;
13528: }
13529: curB = curB->next;
13530: }
13531: if (!found)
13532: break;
13533: cur = cur->next;
13534: }
13535: if (found)
13536: return(0);
13537: } else
13538: return(0);
13539: }
13540: }
13541: /*
13542: * 2 If either O1 or O2 is any, then any must be the value
13543: */
13544: if (completeWild->any != curWild->any) {
13545: if (completeWild->any == 0) {
13546: completeWild->any = 1;
13547: if (completeWild->nsSet != NULL) {
13548: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13549: completeWild->nsSet = NULL;
13550: }
13551: if (completeWild->negNsSet != NULL) {
13552: xmlFree(completeWild->negNsSet);
13553: completeWild->negNsSet = NULL;
13554: }
13555: }
13556: return (0);
13557: }
13558: /*
13559: * 3 If both O1 and O2 are sets of (namespace names or �absent�),
13560: * then the union of those sets must be the value.
13561: */
13562: if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
13563: int found;
13564: xmlSchemaWildcardNsPtr start;
13565:
13566: cur = curWild->nsSet;
13567: start = completeWild->nsSet;
13568: while (cur != NULL) {
13569: found = 0;
13570: curB = start;
13571: while (curB != NULL) {
13572: if (cur->value == curB->value) {
13573: found = 1;
13574: break;
13575: }
13576: curB = curB->next;
13577: }
13578: if (!found) {
13579: tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
13580: if (tmp == NULL)
13581: return (-1);
13582: tmp->value = cur->value;
13583: tmp->next = completeWild->nsSet;
13584: completeWild->nsSet = tmp;
13585: }
13586: cur = cur->next;
13587: }
13588:
13589: return(0);
13590: }
13591: /*
13592: * 4 If the two are negations of different values (namespace names
13593: * or �absent�), then a pair of not and �absent� must be the value.
13594: */
13595: if ((completeWild->negNsSet != NULL) &&
13596: (curWild->negNsSet != NULL) &&
13597: (completeWild->negNsSet->value != curWild->negNsSet->value)) {
13598: completeWild->negNsSet->value = NULL;
13599:
13600: return(0);
13601: }
13602: /*
13603: * 5.
13604: */
13605: if (((completeWild->negNsSet != NULL) &&
13606: (completeWild->negNsSet->value != NULL) &&
13607: (curWild->nsSet != NULL)) ||
13608: ((curWild->negNsSet != NULL) &&
13609: (curWild->negNsSet->value != NULL) &&
13610: (completeWild->nsSet != NULL))) {
13611:
13612: int nsFound, absentFound = 0;
13613:
13614: if (completeWild->nsSet != NULL) {
13615: cur = completeWild->nsSet;
13616: curB = curWild->negNsSet;
13617: } else {
13618: cur = curWild->nsSet;
13619: curB = completeWild->negNsSet;
13620: }
13621: nsFound = 0;
13622: while (cur != NULL) {
13623: if (cur->value == NULL)
13624: absentFound = 1;
13625: else if (cur->value == curB->value)
13626: nsFound = 1;
13627: if (nsFound && absentFound)
13628: break;
13629: cur = cur->next;
13630: }
13631:
13632: if (nsFound && absentFound) {
13633: /*
13634: * 5.1 If the set S includes both the negated namespace
13635: * name and �absent�, then any must be the value.
13636: */
13637: completeWild->any = 1;
13638: if (completeWild->nsSet != NULL) {
13639: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13640: completeWild->nsSet = NULL;
13641: }
13642: if (completeWild->negNsSet != NULL) {
13643: xmlFree(completeWild->negNsSet);
13644: completeWild->negNsSet = NULL;
13645: }
13646: } else if (nsFound && (!absentFound)) {
13647: /*
13648: * 5.2 If the set S includes the negated namespace name
13649: * but not �absent�, then a pair of not and �absent� must
13650: * be the value.
13651: */
13652: if (completeWild->nsSet != NULL) {
13653: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13654: completeWild->nsSet = NULL;
13655: }
13656: if (completeWild->negNsSet == NULL) {
13657: completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
13658: if (completeWild->negNsSet == NULL)
13659: return (-1);
13660: }
13661: completeWild->negNsSet->value = NULL;
13662: } else if ((!nsFound) && absentFound) {
13663: /*
13664: * 5.3 If the set S includes �absent� but not the negated
13665: * namespace name, then the union is not expressible.
13666: */
13667: xmlSchemaPErr(ctxt, completeWild->node,
13668: XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
13669: "The union of the wilcard is not expressible.\n",
13670: NULL, NULL);
13671: return(XML_SCHEMAP_UNION_NOT_EXPRESSIBLE);
13672: } else if ((!nsFound) && (!absentFound)) {
13673: /*
13674: * 5.4 If the set S does not include either the negated namespace
13675: * name or �absent�, then whichever of O1 or O2 is a pair of not
13676: * and a namespace name must be the value.
13677: */
13678: if (completeWild->negNsSet == NULL) {
13679: if (completeWild->nsSet != NULL) {
13680: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13681: completeWild->nsSet = NULL;
13682: }
13683: completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
13684: if (completeWild->negNsSet == NULL)
13685: return (-1);
13686: completeWild->negNsSet->value = curWild->negNsSet->value;
13687: }
13688: }
13689: return (0);
13690: }
13691: /*
13692: * 6.
13693: */
13694: if (((completeWild->negNsSet != NULL) &&
13695: (completeWild->negNsSet->value == NULL) &&
13696: (curWild->nsSet != NULL)) ||
13697: ((curWild->negNsSet != NULL) &&
13698: (curWild->negNsSet->value == NULL) &&
13699: (completeWild->nsSet != NULL))) {
13700:
13701: if (completeWild->nsSet != NULL) {
13702: cur = completeWild->nsSet;
13703: } else {
13704: cur = curWild->nsSet;
13705: }
13706: while (cur != NULL) {
13707: if (cur->value == NULL) {
13708: /*
13709: * 6.1 If the set S includes �absent�, then any must be the
13710: * value.
13711: */
13712: completeWild->any = 1;
13713: if (completeWild->nsSet != NULL) {
13714: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13715: completeWild->nsSet = NULL;
13716: }
13717: if (completeWild->negNsSet != NULL) {
13718: xmlFree(completeWild->negNsSet);
13719: completeWild->negNsSet = NULL;
13720: }
13721: return (0);
13722: }
13723: cur = cur->next;
13724: }
13725: if (completeWild->negNsSet == NULL) {
13726: /*
13727: * 6.2 If the set S does not include �absent�, then a pair of not
13728: * and �absent� must be the value.
13729: */
13730: if (completeWild->nsSet != NULL) {
13731: xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
13732: completeWild->nsSet = NULL;
13733: }
13734: completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
13735: if (completeWild->negNsSet == NULL)
13736: return (-1);
13737: completeWild->negNsSet->value = NULL;
13738: }
13739: return (0);
13740: }
13741: return (0);
13742:
13743: }
13744:
13745: /**
13746: * xmlSchemaIntersectWildcards:
13747: * @ctxt: the schema parser context
13748: * @completeWild: the first wildcard
13749: * @curWild: the second wildcard
13750: *
13751: * Intersects the namespace constraints of the given wildcards.
13752: * @completeWild will hold the resulting intersection.
13753: * Returns a positive error code on failure, -1 in case of an
13754: * internal error, 0 otherwise.
13755: */
13756: static int
13757: xmlSchemaIntersectWildcards(xmlSchemaParserCtxtPtr ctxt,
13758: xmlSchemaWildcardPtr completeWild,
13759: xmlSchemaWildcardPtr curWild)
13760: {
13761: xmlSchemaWildcardNsPtr cur, curB, prev, tmp;
13762:
13763: /*
13764: * 1 If O1 and O2 are the same value, then that value must be the
13765: * value.
13766: */
13767: if ((completeWild->any == curWild->any) &&
13768: ((completeWild->nsSet == NULL) == (curWild->nsSet == NULL)) &&
13769: ((completeWild->negNsSet == NULL) == (curWild->negNsSet == NULL))) {
13770:
13771: if ((completeWild->negNsSet == NULL) ||
13772: (completeWild->negNsSet->value == curWild->negNsSet->value)) {
13773:
13774: if (completeWild->nsSet != NULL) {
13775: int found = 0;
13776:
13777: /*
13778: * Check equality of sets.
13779: */
13780: cur = completeWild->nsSet;
13781: while (cur != NULL) {
13782: found = 0;
13783: curB = curWild->nsSet;
13784: while (curB != NULL) {
13785: if (cur->value == curB->value) {
13786: found = 1;
13787: break;
13788: }
13789: curB = curB->next;
13790: }
13791: if (!found)
13792: break;
13793: cur = cur->next;
13794: }
13795: if (found)
13796: return(0);
13797: } else
13798: return(0);
13799: }
13800: }
13801: /*
13802: * 2 If either O1 or O2 is any, then the other must be the value.
13803: */
13804: if ((completeWild->any != curWild->any) && (completeWild->any)) {
13805: if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
13806: return(-1);
13807: return(0);
13808: }
13809: /*
13810: * 3 If either O1 or O2 is a pair of not and a value (a namespace
13811: * name or �absent�) and the other is a set of (namespace names or
13812: * �absent�), then that set, minus the negated value if it was in
13813: * the set, minus �absent� if it was in the set, must be the value.
13814: */
13815: if (((completeWild->negNsSet != NULL) && (curWild->nsSet != NULL)) ||
13816: ((curWild->negNsSet != NULL) && (completeWild->nsSet != NULL))) {
13817: const xmlChar *neg;
13818:
13819: if (completeWild->nsSet == NULL) {
13820: neg = completeWild->negNsSet->value;
13821: if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
13822: return(-1);
13823: } else
13824: neg = curWild->negNsSet->value;
13825: /*
13826: * Remove absent and negated.
13827: */
13828: prev = NULL;
13829: cur = completeWild->nsSet;
13830: while (cur != NULL) {
13831: if (cur->value == NULL) {
13832: if (prev == NULL)
13833: completeWild->nsSet = cur->next;
13834: else
13835: prev->next = cur->next;
13836: xmlFree(cur);
13837: break;
13838: }
13839: prev = cur;
13840: cur = cur->next;
13841: }
13842: if (neg != NULL) {
13843: prev = NULL;
13844: cur = completeWild->nsSet;
13845: while (cur != NULL) {
13846: if (cur->value == neg) {
13847: if (prev == NULL)
13848: completeWild->nsSet = cur->next;
13849: else
13850: prev->next = cur->next;
13851: xmlFree(cur);
13852: break;
13853: }
13854: prev = cur;
13855: cur = cur->next;
13856: }
13857: }
13858:
13859: return(0);
13860: }
13861: /*
13862: * 4 If both O1 and O2 are sets of (namespace names or �absent�),
13863: * then the intersection of those sets must be the value.
13864: */
13865: if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
13866: int found;
13867:
13868: cur = completeWild->nsSet;
13869: prev = NULL;
13870: while (cur != NULL) {
13871: found = 0;
13872: curB = curWild->nsSet;
13873: while (curB != NULL) {
13874: if (cur->value == curB->value) {
13875: found = 1;
13876: break;
13877: }
13878: curB = curB->next;
13879: }
13880: if (!found) {
13881: if (prev == NULL)
13882: completeWild->nsSet = cur->next;
13883: else
13884: prev->next = cur->next;
13885: tmp = cur->next;
13886: xmlFree(cur);
13887: cur = tmp;
13888: continue;
13889: }
13890: prev = cur;
13891: cur = cur->next;
13892: }
13893:
13894: return(0);
13895: }
13896: /* 5 If the two are negations of different namespace names,
13897: * then the intersection is not expressible
13898: */
13899: if ((completeWild->negNsSet != NULL) &&
13900: (curWild->negNsSet != NULL) &&
13901: (completeWild->negNsSet->value != curWild->negNsSet->value) &&
13902: (completeWild->negNsSet->value != NULL) &&
13903: (curWild->negNsSet->value != NULL)) {
13904:
13905: xmlSchemaPErr(ctxt, completeWild->node, XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
13906: "The intersection of the wilcard is not expressible.\n",
13907: NULL, NULL);
13908: return(XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE);
13909: }
13910: /*
13911: * 6 If the one is a negation of a namespace name and the other
13912: * is a negation of �absent�, then the one which is the negation
13913: * of a namespace name must be the value.
13914: */
13915: if ((completeWild->negNsSet != NULL) && (curWild->negNsSet != NULL) &&
13916: (completeWild->negNsSet->value != curWild->negNsSet->value) &&
13917: (completeWild->negNsSet->value == NULL)) {
13918: completeWild->negNsSet->value = curWild->negNsSet->value;
13919: }
13920: return(0);
13921: }
13922:
13923: /**
13924: * xmlSchemaIsWildcardNsConstraintSubset:
13925: * @ctxt: the schema parser context
13926: * @sub: the first wildcard
13927: * @super: the second wildcard
13928: *
13929: * Schema Component Constraint: Wildcard Subset (cos-ns-subset)
13930: *
13931: * Returns 0 if the namespace constraint of @sub is an intensional
13932: * subset of @super, 1 otherwise.
13933: */
13934: static int
13935: xmlSchemaCheckCOSNSSubset(xmlSchemaWildcardPtr sub,
13936: xmlSchemaWildcardPtr super)
13937: {
13938: /*
13939: * 1 super must be any.
13940: */
13941: if (super->any)
13942: return (0);
13943: /*
13944: * 2.1 sub must be a pair of not and a namespace name or �absent�.
13945: * 2.2 super must be a pair of not and the same value.
13946: */
13947: if ((sub->negNsSet != NULL) &&
13948: (super->negNsSet != NULL) &&
13949: (sub->negNsSet->value == sub->negNsSet->value))
13950: return (0);
13951: /*
13952: * 3.1 sub must be a set whose members are either namespace names or �absent�.
13953: */
13954: if (sub->nsSet != NULL) {
13955: /*
13956: * 3.2.1 super must be the same set or a superset thereof.
13957: */
13958: if (super->nsSet != NULL) {
13959: xmlSchemaWildcardNsPtr cur, curB;
13960: int found = 0;
13961:
13962: cur = sub->nsSet;
13963: while (cur != NULL) {
13964: found = 0;
13965: curB = super->nsSet;
13966: while (curB != NULL) {
13967: if (cur->value == curB->value) {
13968: found = 1;
13969: break;
13970: }
13971: curB = curB->next;
13972: }
13973: if (!found)
13974: return (1);
13975: cur = cur->next;
13976: }
13977: if (found)
13978: return (0);
13979: } else if (super->negNsSet != NULL) {
13980: xmlSchemaWildcardNsPtr cur;
13981: /*
13982: * 3.2.2 super must be a pair of not and a namespace name or
13983: * �absent� and that value must not be in sub's set.
13984: */
13985: cur = sub->nsSet;
13986: while (cur != NULL) {
13987: if (cur->value == super->negNsSet->value)
13988: return (1);
13989: cur = cur->next;
13990: }
13991: return (0);
13992: }
13993: }
13994: return (1);
13995: }
13996:
13997: static int
13998: xmlSchemaGetEffectiveValueConstraint(xmlSchemaAttributeUsePtr attruse,
13999: int *fixed,
14000: const xmlChar **value,
14001: xmlSchemaValPtr *val)
14002: {
14003: *fixed = 0;
14004: *value = NULL;
14005: if (val != 0)
14006: *val = NULL;
14007:
14008: if (attruse->defValue != NULL) {
14009: *value = attruse->defValue;
14010: if (val != NULL)
14011: *val = attruse->defVal;
14012: if (attruse->flags & XML_SCHEMA_ATTR_USE_FIXED)
14013: *fixed = 1;
14014: return(1);
14015: } else if ((attruse->attrDecl != NULL) &&
14016: (attruse->attrDecl->defValue != NULL)) {
14017: *value = attruse->attrDecl->defValue;
14018: if (val != NULL)
14019: *val = attruse->attrDecl->defVal;
14020: if (attruse->attrDecl->flags & XML_SCHEMAS_ATTR_FIXED)
14021: *fixed = 1;
14022: return(1);
14023: }
14024: return(0);
14025: }
14026: /**
14027: * xmlSchemaCheckCVCWildcardNamespace:
14028: * @wild: the wildcard
14029: * @ns: the namespace
14030: *
14031: * Validation Rule: Wildcard allows Namespace Name
14032: * (cvc-wildcard-namespace)
14033: *
14034: * Returns 0 if the given namespace matches the wildcard,
14035: * 1 otherwise and -1 on API errors.
14036: */
14037: static int
14038: xmlSchemaCheckCVCWildcardNamespace(xmlSchemaWildcardPtr wild,
14039: const xmlChar* ns)
14040: {
14041: if (wild == NULL)
14042: return(-1);
14043:
14044: if (wild->any)
14045: return(0);
14046: else if (wild->nsSet != NULL) {
14047: xmlSchemaWildcardNsPtr cur;
14048:
14049: cur = wild->nsSet;
14050: while (cur != NULL) {
14051: if (xmlStrEqual(cur->value, ns))
14052: return(0);
14053: cur = cur->next;
14054: }
14055: } else if ((wild->negNsSet != NULL) && (ns != NULL) &&
14056: (!xmlStrEqual(wild->negNsSet->value, ns)))
14057: return(0);
14058:
14059: return(1);
14060: }
14061:
14062: #define XML_SCHEMA_ACTION_DERIVE 0
14063: #define XML_SCHEMA_ACTION_REDEFINE 1
14064:
14065: #define WXS_ACTION_STR(a) \
14066: ((a) == XML_SCHEMA_ACTION_DERIVE) ? (const xmlChar *) "base" : (const xmlChar *) "redefined"
14067:
14068: /*
14069: * Schema Component Constraint:
14070: * Derivation Valid (Restriction, Complex)
14071: * derivation-ok-restriction (2) - (4)
14072: *
14073: * ATTENTION:
14074: * In XML Schema 1.1 this will be:
14075: * Validation Rule:
14076: * Checking complex type subsumption (practicalSubsumption) (1, 2 and 3)
14077: *
14078: */
14079: static int
14080: xmlSchemaCheckDerivationOKRestriction2to4(xmlSchemaParserCtxtPtr pctxt,
14081: int action,
14082: xmlSchemaBasicItemPtr item,
14083: xmlSchemaBasicItemPtr baseItem,
14084: xmlSchemaItemListPtr uses,
14085: xmlSchemaItemListPtr baseUses,
14086: xmlSchemaWildcardPtr wild,
14087: xmlSchemaWildcardPtr baseWild)
14088: {
14089: xmlSchemaAttributeUsePtr cur = NULL, bcur;
14090: int i, j, found; /* err = 0; */
14091: const xmlChar *bEffValue;
14092: int effFixed;
14093:
14094: if (uses != NULL) {
14095: for (i = 0; i < uses->nbItems; i++) {
14096: cur = uses->items[i];
14097: found = 0;
14098: if (baseUses == NULL)
14099: goto not_found;
14100: for (j = 0; j < baseUses->nbItems; j++) {
14101: bcur = baseUses->items[j];
14102: if ((WXS_ATTRUSE_DECL_NAME(cur) ==
14103: WXS_ATTRUSE_DECL_NAME(bcur)) &&
14104: (WXS_ATTRUSE_DECL_TNS(cur) ==
14105: WXS_ATTRUSE_DECL_TNS(bcur)))
14106: {
14107: /*
14108: * (2.1) "If there is an attribute use in the {attribute
14109: * uses} of the {base type definition} (call this B) whose
14110: * {attribute declaration} has the same {name} and {target
14111: * namespace}, then all of the following must be true:"
14112: */
14113: found = 1;
14114:
14115: if ((cur->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
14116: (bcur->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED))
14117: {
14118: xmlChar *str = NULL;
14119: /*
14120: * (2.1.1) "one of the following must be true:"
14121: * (2.1.1.1) "B's {required} is false."
14122: * (2.1.1.2) "R's {required} is true."
14123: */
14124: xmlSchemaPAttrUseErr4(pctxt,
14125: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
14126: WXS_ITEM_NODE(item), item, cur,
14127: "The 'optional' attribute use is inconsistent "
14128: "with the corresponding 'required' attribute use of "
14129: "the %s %s",
14130: WXS_ACTION_STR(action),
14131: xmlSchemaGetComponentDesignation(&str, baseItem),
14132: NULL, NULL);
14133: FREE_AND_NULL(str);
14134: /* err = pctxt->err; */
14135: } else if (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt,
14136: WXS_ATTRUSE_TYPEDEF(cur),
14137: WXS_ATTRUSE_TYPEDEF(bcur), 0) != 0)
14138: {
14139: xmlChar *strA = NULL, *strB = NULL, *strC = NULL;
14140:
14141: /*
14142: * SPEC (2.1.2) "R's {attribute declaration}'s
14143: * {type definition} must be validly derived from
14144: * B's {type definition} given the empty set as
14145: * defined in Type Derivation OK (Simple) (�3.14.6)."
14146: */
14147: xmlSchemaPAttrUseErr4(pctxt,
14148: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
14149: WXS_ITEM_NODE(item), item, cur,
14150: "The attribute declaration's %s "
14151: "is not validly derived from "
14152: "the corresponding %s of the "
14153: "attribute declaration in the %s %s",
14154: xmlSchemaGetComponentDesignation(&strA,
14155: WXS_ATTRUSE_TYPEDEF(cur)),
14156: xmlSchemaGetComponentDesignation(&strB,
14157: WXS_ATTRUSE_TYPEDEF(bcur)),
14158: WXS_ACTION_STR(action),
14159: xmlSchemaGetComponentDesignation(&strC, baseItem));
14160: /* xmlSchemaGetComponentDesignation(&str, baseItem), */
14161: FREE_AND_NULL(strA);
14162: FREE_AND_NULL(strB);
14163: FREE_AND_NULL(strC);
14164: /* err = pctxt->err; */
14165: } else {
14166: /*
14167: * 2.1.3 [Definition:] Let the effective value
14168: * constraint of an attribute use be its {value
14169: * constraint}, if present, otherwise its {attribute
14170: * declaration}'s {value constraint} .
14171: */
14172: xmlSchemaGetEffectiveValueConstraint(bcur,
14173: &effFixed, &bEffValue, NULL);
14174: /*
14175: * 2.1.3 ... one of the following must be true
14176: *
14177: * 2.1.3.1 B's �effective value constraint� is
14178: * �absent� or default.
14179: */
14180: if ((bEffValue != NULL) &&
14181: (effFixed == 1)) {
14182: const xmlChar *rEffValue = NULL;
14183:
14184: xmlSchemaGetEffectiveValueConstraint(bcur,
14185: &effFixed, &rEffValue, NULL);
14186: /*
14187: * 2.1.3.2 R's �effective value constraint� is
14188: * fixed with the same string as B's.
14189: * MAYBE TODO: Compare the computed values.
14190: * Hmm, it says "same string" so
14191: * string-equality might really be sufficient.
14192: */
14193: if ((effFixed == 0) ||
14194: (! WXS_ARE_DEFAULT_STR_EQUAL(rEffValue, bEffValue)))
14195: {
14196: xmlChar *str = NULL;
14197:
14198: xmlSchemaPAttrUseErr4(pctxt,
14199: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
14200: WXS_ITEM_NODE(item), item, cur,
14201: "The effective value constraint of the "
14202: "attribute use is inconsistent with "
14203: "its correspondent in the %s %s",
14204: WXS_ACTION_STR(action),
14205: xmlSchemaGetComponentDesignation(&str,
14206: baseItem),
14207: NULL, NULL);
14208: FREE_AND_NULL(str);
14209: /* err = pctxt->err; */
14210: }
14211: }
14212: }
14213: break;
14214: }
14215: }
14216: not_found:
14217: if (!found) {
14218: /*
14219: * (2.2) "otherwise the {base type definition} must have an
14220: * {attribute wildcard} and the {target namespace} of the
14221: * R's {attribute declaration} must be �valid� with respect
14222: * to that wildcard, as defined in Wildcard allows Namespace
14223: * Name (�3.10.4)."
14224: */
14225: if ((baseWild == NULL) ||
14226: (xmlSchemaCheckCVCWildcardNamespace(baseWild,
14227: (WXS_ATTRUSE_DECL(cur))->targetNamespace) != 0))
14228: {
14229: xmlChar *str = NULL;
14230:
14231: xmlSchemaPAttrUseErr4(pctxt,
14232: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
14233: WXS_ITEM_NODE(item), item, cur,
14234: "Neither a matching attribute use, "
14235: "nor a matching wildcard exists in the %s %s",
14236: WXS_ACTION_STR(action),
14237: xmlSchemaGetComponentDesignation(&str, baseItem),
14238: NULL, NULL);
14239: FREE_AND_NULL(str);
14240: /* err = pctxt->err; */
14241: }
14242: }
14243: }
14244: }
14245: /*
14246: * SPEC derivation-ok-restriction (3):
14247: * (3) "For each attribute use in the {attribute uses} of the {base type
14248: * definition} whose {required} is true, there must be an attribute
14249: * use with an {attribute declaration} with the same {name} and
14250: * {target namespace} as its {attribute declaration} in the {attribute
14251: * uses} of the complex type definition itself whose {required} is true.
14252: */
14253: if (baseUses != NULL) {
14254: for (j = 0; j < baseUses->nbItems; j++) {
14255: bcur = baseUses->items[j];
14256: if (bcur->occurs != XML_SCHEMAS_ATTR_USE_REQUIRED)
14257: continue;
14258: found = 0;
14259: if (uses != NULL) {
14260: for (i = 0; i < uses->nbItems; i++) {
14261: cur = uses->items[i];
14262: if ((WXS_ATTRUSE_DECL_NAME(cur) ==
14263: WXS_ATTRUSE_DECL_NAME(bcur)) &&
14264: (WXS_ATTRUSE_DECL_TNS(cur) ==
14265: WXS_ATTRUSE_DECL_TNS(bcur))) {
14266: found = 1;
14267: break;
14268: }
14269: }
14270: }
14271: if (!found) {
14272: xmlChar *strA = NULL, *strB = NULL;
14273:
14274: xmlSchemaCustomErr4(ACTXT_CAST pctxt,
14275: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
14276: NULL, item,
14277: "A matching attribute use for the "
14278: "'required' %s of the %s %s is missing",
14279: xmlSchemaGetComponentDesignation(&strA, bcur),
14280: WXS_ACTION_STR(action),
14281: xmlSchemaGetComponentDesignation(&strB, baseItem),
14282: NULL);
14283: FREE_AND_NULL(strA);
14284: FREE_AND_NULL(strB);
14285: }
14286: }
14287: }
14288: /*
14289: * derivation-ok-restriction (4)
14290: */
14291: if (wild != NULL) {
14292: /*
14293: * (4) "If there is an {attribute wildcard}, all of the
14294: * following must be true:"
14295: */
14296: if (baseWild == NULL) {
14297: xmlChar *str = NULL;
14298:
14299: /*
14300: * (4.1) "The {base type definition} must also have one."
14301: */
14302: xmlSchemaCustomErr4(ACTXT_CAST pctxt,
14303: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
14304: NULL, item,
14305: "The %s has an attribute wildcard, "
14306: "but the %s %s '%s' does not have one",
14307: WXS_ITEM_TYPE_NAME(item),
14308: WXS_ACTION_STR(action),
14309: WXS_ITEM_TYPE_NAME(baseItem),
14310: xmlSchemaGetComponentQName(&str, baseItem));
14311: FREE_AND_NULL(str);
14312: return(pctxt->err);
14313: } else if ((baseWild->any == 0) &&
14314: xmlSchemaCheckCOSNSSubset(wild, baseWild))
14315: {
14316: xmlChar *str = NULL;
14317: /*
14318: * (4.2) "The complex type definition's {attribute wildcard}'s
14319: * {namespace constraint} must be a subset of the {base type
14320: * definition}'s {attribute wildcard}'s {namespace constraint},
14321: * as defined by Wildcard Subset (�3.10.6)."
14322: */
14323: xmlSchemaCustomErr4(ACTXT_CAST pctxt,
14324: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
14325: NULL, item,
14326: "The attribute wildcard is not a valid "
14327: "subset of the wildcard in the %s %s '%s'",
14328: WXS_ACTION_STR(action),
14329: WXS_ITEM_TYPE_NAME(baseItem),
14330: xmlSchemaGetComponentQName(&str, baseItem),
14331: NULL);
14332: FREE_AND_NULL(str);
14333: return(pctxt->err);
14334: }
14335: /* 4.3 Unless the {base type definition} is the �ur-type
14336: * definition�, the complex type definition's {attribute
14337: * wildcard}'s {process contents} must be identical to or
14338: * stronger than the {base type definition}'s {attribute
14339: * wildcard}'s {process contents}, where strict is stronger
14340: * than lax is stronger than skip.
14341: */
14342: if ((! WXS_IS_ANYTYPE(baseItem)) &&
14343: (wild->processContents < baseWild->processContents)) {
14344: xmlChar *str = NULL;
14345: xmlSchemaCustomErr4(ACTXT_CAST pctxt,
14346: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
14347: NULL, baseItem,
14348: "The {process contents} of the attribute wildcard is "
14349: "weaker than the one in the %s %s '%s'",
14350: WXS_ACTION_STR(action),
14351: WXS_ITEM_TYPE_NAME(baseItem),
14352: xmlSchemaGetComponentQName(&str, baseItem),
14353: NULL);
14354: FREE_AND_NULL(str)
14355: return(pctxt->err);
14356: }
14357: }
14358: return(0);
14359: }
14360:
14361:
14362: static int
14363: xmlSchemaExpandAttributeGroupRefs(xmlSchemaParserCtxtPtr pctxt,
14364: xmlSchemaBasicItemPtr item,
14365: xmlSchemaWildcardPtr *completeWild,
14366: xmlSchemaItemListPtr list,
14367: xmlSchemaItemListPtr prohibs);
14368: /**
14369: * xmlSchemaFixupTypeAttributeUses:
14370: * @ctxt: the schema parser context
14371: * @type: the complex type definition
14372: *
14373: *
14374: * Builds the wildcard and the attribute uses on the given complex type.
14375: * Returns -1 if an internal error occurs, 0 otherwise.
14376: *
14377: * ATTENTION TODO: Experimantally this uses pointer comparisons for
14378: * strings, so recheck this if we start to hardcode some schemata, since
14379: * they might not be in the same dict.
14380: * NOTE: It is allowed to "extend" the xs:anyType type.
14381: */
14382: static int
14383: xmlSchemaFixupTypeAttributeUses(xmlSchemaParserCtxtPtr pctxt,
14384: xmlSchemaTypePtr type)
14385: {
14386: xmlSchemaTypePtr baseType = NULL;
14387: xmlSchemaAttributeUsePtr use;
14388: xmlSchemaItemListPtr uses, baseUses, prohibs = NULL;
14389:
14390: if (type->baseType == NULL) {
14391: PERROR_INT("xmlSchemaFixupTypeAttributeUses",
14392: "no base type");
14393: return (-1);
14394: }
14395: baseType = type->baseType;
14396: if (WXS_IS_TYPE_NOT_FIXED(baseType))
14397: if (xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt) == -1)
14398: return(-1);
14399:
14400: uses = type->attrUses;
14401: baseUses = baseType->attrUses;
14402: /*
14403: * Expand attribute group references. And build the 'complete'
14404: * wildcard, i.e. intersect multiple wildcards.
14405: * Move attribute prohibitions into a separate list.
14406: */
14407: if (uses != NULL) {
14408: if (WXS_IS_RESTRICTION(type)) {
14409: /*
14410: * This one will transfer all attr. prohibitions
14411: * into pctxt->attrProhibs.
14412: */
14413: if (xmlSchemaExpandAttributeGroupRefs(pctxt,
14414: WXS_BASIC_CAST type, &(type->attributeWildcard), uses,
14415: pctxt->attrProhibs) == -1)
14416: {
14417: PERROR_INT("xmlSchemaFixupTypeAttributeUses",
14418: "failed to expand attributes");
14419: }
14420: if (pctxt->attrProhibs->nbItems != 0)
14421: prohibs = pctxt->attrProhibs;
14422: } else {
14423: if (xmlSchemaExpandAttributeGroupRefs(pctxt,
14424: WXS_BASIC_CAST type, &(type->attributeWildcard), uses,
14425: NULL) == -1)
14426: {
14427: PERROR_INT("xmlSchemaFixupTypeAttributeUses",
14428: "failed to expand attributes");
14429: }
14430: }
14431: }
14432: /*
14433: * Inherit the attribute uses of the base type.
14434: */
14435: if (baseUses != NULL) {
14436: int i, j;
14437: xmlSchemaAttributeUseProhibPtr pro;
14438:
14439: if (WXS_IS_RESTRICTION(type)) {
14440: int usesCount;
14441: xmlSchemaAttributeUsePtr tmp;
14442:
14443: if (uses != NULL)
14444: usesCount = uses->nbItems;
14445: else
14446: usesCount = 0;
14447:
14448: /* Restriction. */
14449: for (i = 0; i < baseUses->nbItems; i++) {
14450: use = baseUses->items[i];
14451: if (prohibs) {
14452: /*
14453: * Filter out prohibited uses.
14454: */
14455: for (j = 0; j < prohibs->nbItems; j++) {
14456: pro = prohibs->items[j];
14457: if ((WXS_ATTRUSE_DECL_NAME(use) == pro->name) &&
14458: (WXS_ATTRUSE_DECL_TNS(use) ==
14459: pro->targetNamespace))
14460: {
14461: goto inherit_next;
14462: }
14463: }
14464: }
14465: if (usesCount) {
14466: /*
14467: * Filter out existing uses.
14468: */
14469: for (j = 0; j < usesCount; j++) {
14470: tmp = uses->items[j];
14471: if ((WXS_ATTRUSE_DECL_NAME(use) ==
14472: WXS_ATTRUSE_DECL_NAME(tmp)) &&
14473: (WXS_ATTRUSE_DECL_TNS(use) ==
14474: WXS_ATTRUSE_DECL_TNS(tmp)))
14475: {
14476: goto inherit_next;
14477: }
14478: }
14479: }
14480: if (uses == NULL) {
14481: type->attrUses = xmlSchemaItemListCreate();
14482: if (type->attrUses == NULL)
14483: goto exit_failure;
14484: uses = type->attrUses;
14485: }
14486: xmlSchemaItemListAddSize(uses, 2, use);
14487: inherit_next: {}
14488: }
14489: } else {
14490: /* Extension. */
14491: for (i = 0; i < baseUses->nbItems; i++) {
14492: use = baseUses->items[i];
14493: if (uses == NULL) {
14494: type->attrUses = xmlSchemaItemListCreate();
14495: if (type->attrUses == NULL)
14496: goto exit_failure;
14497: uses = type->attrUses;
14498: }
14499: xmlSchemaItemListAddSize(uses, baseUses->nbItems, use);
14500: }
14501: }
14502: }
14503: /*
14504: * Shrink attr. uses.
14505: */
14506: if (uses) {
14507: if (uses->nbItems == 0) {
14508: xmlSchemaItemListFree(uses);
14509: type->attrUses = NULL;
14510: }
14511: /*
14512: * TODO: We could shrink the size of the array
14513: * to fit the actual number of items.
14514: */
14515: }
14516: /*
14517: * Compute the complete wildcard.
14518: */
14519: if (WXS_IS_EXTENSION(type)) {
14520: if (baseType->attributeWildcard != NULL) {
14521: /*
14522: * (3.2.2.1) "If the �base wildcard� is non-�absent�, then
14523: * the appropriate case among the following:"
14524: */
14525: if (type->attributeWildcard != NULL) {
14526: /*
14527: * Union the complete wildcard with the base wildcard.
14528: * SPEC {attribute wildcard}
14529: * (3.2.2.1.2) "otherwise a wildcard whose {process contents}
14530: * and {annotation} are those of the �complete wildcard�,
14531: * and whose {namespace constraint} is the intensional union
14532: * of the {namespace constraint} of the �complete wildcard�
14533: * and of the �base wildcard�, as defined in Attribute
14534: * Wildcard Union (�3.10.6)."
14535: */
14536: if (xmlSchemaUnionWildcards(pctxt, type->attributeWildcard,
14537: baseType->attributeWildcard) == -1)
14538: goto exit_failure;
14539: } else {
14540: /*
14541: * (3.2.2.1.1) "If the �complete wildcard� is �absent�,
14542: * then the �base wildcard�."
14543: */
14544: type->attributeWildcard = baseType->attributeWildcard;
14545: }
14546: } else {
14547: /*
14548: * (3.2.2.2) "otherwise (the �base wildcard� is �absent�) the
14549: * �complete wildcard"
14550: * NOOP
14551: */
14552: }
14553: } else {
14554: /*
14555: * SPEC {attribute wildcard}
14556: * (3.1) "If the <restriction> alternative is chosen, then the
14557: * �complete wildcard�;"
14558: * NOOP
14559: */
14560: }
14561:
14562: return (0);
14563:
14564: exit_failure:
14565: return(-1);
14566: }
14567:
14568: /**
14569: * xmlSchemaTypeFinalContains:
14570: * @schema: the schema
14571: * @type: the type definition
14572: * @final: the final
14573: *
14574: * Evaluates if a type definition contains the given "final".
14575: * This does take "finalDefault" into account as well.
14576: *
14577: * Returns 1 if the type does containt the given "final",
14578: * 0 otherwise.
14579: */
14580: static int
14581: xmlSchemaTypeFinalContains(xmlSchemaTypePtr type, int final)
14582: {
14583: if (type == NULL)
14584: return (0);
14585: if (type->flags & final)
14586: return (1);
14587: else
14588: return (0);
14589: }
14590:
14591: /**
14592: * xmlSchemaGetUnionSimpleTypeMemberTypes:
14593: * @type: the Union Simple Type
14594: *
14595: * Returns a list of member types of @type if existing,
14596: * returns NULL otherwise.
14597: */
14598: static xmlSchemaTypeLinkPtr
14599: xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type)
14600: {
14601: while ((type != NULL) && (type->type == XML_SCHEMA_TYPE_SIMPLE)) {
14602: if (type->memberTypes != NULL)
14603: return (type->memberTypes);
14604: else
14605: type = type->baseType;
14606: }
14607: return (NULL);
14608: }
14609:
14610: /**
14611: * xmlSchemaGetParticleTotalRangeMin:
14612: * @particle: the particle
14613: *
14614: * Schema Component Constraint: Effective Total Range
14615: * (all and sequence) + (choice)
14616: *
14617: * Returns the minimun Effective Total Range.
14618: */
14619: static int
14620: xmlSchemaGetParticleTotalRangeMin(xmlSchemaParticlePtr particle)
14621: {
14622: if ((particle->children == NULL) ||
14623: (particle->minOccurs == 0))
14624: return (0);
14625: if (particle->children->type == XML_SCHEMA_TYPE_CHOICE) {
14626: int min = -1, cur;
14627: xmlSchemaParticlePtr part =
14628: (xmlSchemaParticlePtr) particle->children->children;
14629:
14630: if (part == NULL)
14631: return (0);
14632: while (part != NULL) {
14633: if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
14634: (part->children->type == XML_SCHEMA_TYPE_ANY))
14635: cur = part->minOccurs;
14636: else
14637: cur = xmlSchemaGetParticleTotalRangeMin(part);
14638: if (cur == 0)
14639: return (0);
14640: if ((min > cur) || (min == -1))
14641: min = cur;
14642: part = (xmlSchemaParticlePtr) part->next;
14643: }
14644: return (particle->minOccurs * min);
14645: } else {
14646: /* <all> and <sequence> */
14647: int sum = 0;
14648: xmlSchemaParticlePtr part =
14649: (xmlSchemaParticlePtr) particle->children->children;
14650:
14651: if (part == NULL)
14652: return (0);
14653: do {
14654: if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
14655: (part->children->type == XML_SCHEMA_TYPE_ANY))
14656: sum += part->minOccurs;
14657: else
14658: sum += xmlSchemaGetParticleTotalRangeMin(part);
14659: part = (xmlSchemaParticlePtr) part->next;
14660: } while (part != NULL);
14661: return (particle->minOccurs * sum);
14662: }
14663: }
14664:
14665: #if 0
14666: /**
14667: * xmlSchemaGetParticleTotalRangeMax:
14668: * @particle: the particle
14669: *
14670: * Schema Component Constraint: Effective Total Range
14671: * (all and sequence) + (choice)
14672: *
14673: * Returns the maximum Effective Total Range.
14674: */
14675: static int
14676: xmlSchemaGetParticleTotalRangeMax(xmlSchemaParticlePtr particle)
14677: {
14678: if ((particle->children == NULL) ||
14679: (particle->children->children == NULL))
14680: return (0);
14681: if (particle->children->type == XML_SCHEMA_TYPE_CHOICE) {
14682: int max = -1, cur;
14683: xmlSchemaParticlePtr part =
14684: (xmlSchemaParticlePtr) particle->children->children;
14685:
14686: for (; part != NULL; part = (xmlSchemaParticlePtr) part->next) {
14687: if (part->children == NULL)
14688: continue;
14689: if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
14690: (part->children->type == XML_SCHEMA_TYPE_ANY))
14691: cur = part->maxOccurs;
14692: else
14693: cur = xmlSchemaGetParticleTotalRangeMax(part);
14694: if (cur == UNBOUNDED)
14695: return (UNBOUNDED);
14696: if ((max < cur) || (max == -1))
14697: max = cur;
14698: }
14699: /* TODO: Handle overflows? */
14700: return (particle->maxOccurs * max);
14701: } else {
14702: /* <all> and <sequence> */
14703: int sum = 0, cur;
14704: xmlSchemaParticlePtr part =
14705: (xmlSchemaParticlePtr) particle->children->children;
14706:
14707: for (; part != NULL; part = (xmlSchemaParticlePtr) part->next) {
14708: if (part->children == NULL)
14709: continue;
14710: if ((part->children->type == XML_SCHEMA_TYPE_ELEMENT) ||
14711: (part->children->type == XML_SCHEMA_TYPE_ANY))
14712: cur = part->maxOccurs;
14713: else
14714: cur = xmlSchemaGetParticleTotalRangeMax(part);
14715: if (cur == UNBOUNDED)
14716: return (UNBOUNDED);
14717: if ((cur > 0) && (particle->maxOccurs == UNBOUNDED))
14718: return (UNBOUNDED);
14719: sum += cur;
14720: }
14721: /* TODO: Handle overflows? */
14722: return (particle->maxOccurs * sum);
14723: }
14724: }
14725: #endif
14726:
14727: /**
14728: * xmlSchemaIsParticleEmptiable:
14729: * @particle: the particle
14730: *
14731: * Schema Component Constraint: Particle Emptiable
14732: * Checks whether the given particle is emptiable.
14733: *
14734: * Returns 1 if emptiable, 0 otherwise.
14735: */
14736: static int
14737: xmlSchemaIsParticleEmptiable(xmlSchemaParticlePtr particle)
14738: {
14739: /*
14740: * SPEC (1) "Its {min occurs} is 0."
14741: */
14742: if ((particle == NULL) || (particle->minOccurs == 0) ||
14743: (particle->children == NULL))
14744: return (1);
14745: /*
14746: * SPEC (2) "Its {term} is a group and the minimum part of the
14747: * effective total range of that group, [...] is 0."
14748: */
14749: if (WXS_IS_MODEL_GROUP(particle->children)) {
14750: if (xmlSchemaGetParticleTotalRangeMin(particle) == 0)
14751: return (1);
14752: }
14753: return (0);
14754: }
14755:
14756: /**
14757: * xmlSchemaCheckCOSSTDerivedOK:
14758: * @actxt: a context
14759: * @type: the derived simple type definition
14760: * @baseType: the base type definition
14761: * @subset: the subset of ('restriction', ect.)
14762: *
14763: * Schema Component Constraint:
14764: * Type Derivation OK (Simple) (cos-st-derived-OK)
14765: *
14766: * Checks wheter @type can be validly
14767: * derived from @baseType.
14768: *
14769: * Returns 0 on success, an positive error code otherwise.
14770: */
14771: static int
14772: xmlSchemaCheckCOSSTDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
14773: xmlSchemaTypePtr type,
14774: xmlSchemaTypePtr baseType,
14775: int subset)
14776: {
14777: /*
14778: * 1 They are the same type definition.
14779: * TODO: The identy check might have to be more complex than this.
14780: */
14781: if (type == baseType)
14782: return (0);
14783: /*
14784: * 2.1 restriction is not in the subset, or in the {final}
14785: * of its own {base type definition};
14786: *
14787: * NOTE that this will be used also via "xsi:type".
14788: *
14789: * TODO: Revise this, it looks strange. How can the "type"
14790: * not be fixed or *in* fixing?
14791: */
14792: if (WXS_IS_TYPE_NOT_FIXED(type))
14793: if (xmlSchemaTypeFixup(type, actxt) == -1)
14794: return(-1);
14795: if (WXS_IS_TYPE_NOT_FIXED(baseType))
14796: if (xmlSchemaTypeFixup(baseType, actxt) == -1)
14797: return(-1);
14798: if ((subset & SUBSET_RESTRICTION) ||
14799: (xmlSchemaTypeFinalContains(type->baseType,
14800: XML_SCHEMAS_TYPE_FINAL_RESTRICTION))) {
14801: return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_1);
14802: }
14803: /* 2.2 */
14804: if (type->baseType == baseType) {
14805: /*
14806: * 2.2.1 D's �base type definition� is B.
14807: */
14808: return (0);
14809: }
14810: /*
14811: * 2.2.2 D's �base type definition� is not the �ur-type definition�
14812: * and is validly derived from B given the subset, as defined by this
14813: * constraint.
14814: */
14815: if ((! WXS_IS_ANYTYPE(type->baseType)) &&
14816: (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
14817: baseType, subset) == 0)) {
14818: return (0);
14819: }
14820: /*
14821: * 2.2.3 D's {variety} is list or union and B is the �simple ur-type
14822: * definition�.
14823: */
14824: if (WXS_IS_ANY_SIMPLE_TYPE(baseType) &&
14825: (WXS_IS_LIST(type) || WXS_IS_UNION(type))) {
14826: return (0);
14827: }
14828: /*
14829: * 2.2.4 B's {variety} is union and D is validly derived from a type
14830: * definition in B's {member type definitions} given the subset, as
14831: * defined by this constraint.
14832: *
14833: * NOTE: This seems not to involve built-in types, since there is no
14834: * built-in Union Simple Type.
14835: */
14836: if (WXS_IS_UNION(baseType)) {
14837: xmlSchemaTypeLinkPtr cur;
14838:
14839: cur = baseType->memberTypes;
14840: while (cur != NULL) {
14841: if (WXS_IS_TYPE_NOT_FIXED(cur->type))
14842: if (xmlSchemaTypeFixup(cur->type, actxt) == -1)
14843: return(-1);
14844: if (xmlSchemaCheckCOSSTDerivedOK(actxt,
14845: type, cur->type, subset) == 0)
14846: {
14847: /*
14848: * It just has to be validly derived from at least one
14849: * member-type.
14850: */
14851: return (0);
14852: }
14853: cur = cur->next;
14854: }
14855: }
14856: return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_2);
14857: }
14858:
14859: /**
14860: * xmlSchemaCheckTypeDefCircularInternal:
14861: * @pctxt: the schema parser context
14862: * @ctxtType: the type definition
14863: * @ancestor: an ancestor of @ctxtType
14864: *
14865: * Checks st-props-correct (2) + ct-props-correct (3).
14866: * Circular type definitions are not allowed.
14867: *
14868: * Returns XML_SCHEMAP_ST_PROPS_CORRECT_2 if the given type is
14869: * circular, 0 otherwise.
14870: */
14871: static int
14872: xmlSchemaCheckTypeDefCircularInternal(xmlSchemaParserCtxtPtr pctxt,
14873: xmlSchemaTypePtr ctxtType,
14874: xmlSchemaTypePtr ancestor)
14875: {
14876: int ret;
14877:
14878: if ((ancestor == NULL) || (ancestor->type == XML_SCHEMA_TYPE_BASIC))
14879: return (0);
14880:
14881: if (ctxtType == ancestor) {
14882: xmlSchemaPCustomErr(pctxt,
14883: XML_SCHEMAP_ST_PROPS_CORRECT_2,
14884: WXS_BASIC_CAST ctxtType, WXS_ITEM_NODE(ctxtType),
14885: "The definition is circular", NULL);
14886: return (XML_SCHEMAP_ST_PROPS_CORRECT_2);
14887: }
14888: if (ancestor->flags & XML_SCHEMAS_TYPE_MARKED) {
14889: /*
14890: * Avoid inifinite recursion on circular types not yet checked.
14891: */
14892: return (0);
14893: }
14894: ancestor->flags |= XML_SCHEMAS_TYPE_MARKED;
14895: ret = xmlSchemaCheckTypeDefCircularInternal(pctxt, ctxtType,
14896: ancestor->baseType);
14897: ancestor->flags ^= XML_SCHEMAS_TYPE_MARKED;
14898: return (ret);
14899: }
14900:
14901: /**
14902: * xmlSchemaCheckTypeDefCircular:
14903: * @item: the complex/simple type definition
14904: * @ctxt: the parser context
14905: * @name: the name
14906: *
14907: * Checks for circular type definitions.
14908: */
14909: static void
14910: xmlSchemaCheckTypeDefCircular(xmlSchemaTypePtr item,
14911: xmlSchemaParserCtxtPtr ctxt)
14912: {
14913: if ((item == NULL) ||
14914: (item->type == XML_SCHEMA_TYPE_BASIC) ||
14915: (item->baseType == NULL))
14916: return;
14917: xmlSchemaCheckTypeDefCircularInternal(ctxt, item,
14918: item->baseType);
14919: }
14920:
14921: /*
14922: * Simple Type Definition Representation OK (src-simple-type) 4
14923: *
14924: * "4 Circular union type definition is disallowed. That is, if the
14925: * <union> alternative is chosen, there must not be any entries in the
14926: * memberTypes [attribute] at any depth which resolve to the component
14927: * corresponding to the <simpleType>."
14928: *
14929: * Note that this should work on the *representation* of a component,
14930: * thus assumes any union types in the member types not being yet
14931: * substituted. At this stage we need the variety of the types
14932: * to be already computed.
14933: */
14934: static int
14935: xmlSchemaCheckUnionTypeDefCircularRecur(xmlSchemaParserCtxtPtr pctxt,
14936: xmlSchemaTypePtr ctxType,
14937: xmlSchemaTypeLinkPtr members)
14938: {
14939: xmlSchemaTypeLinkPtr member;
14940: xmlSchemaTypePtr memberType;
14941:
14942: member = members;
14943: while (member != NULL) {
14944: memberType = member->type;
14945: while ((memberType != NULL) &&
14946: (memberType->type != XML_SCHEMA_TYPE_BASIC)) {
14947: if (memberType == ctxType) {
14948: xmlSchemaPCustomErr(pctxt,
14949: XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
14950: WXS_BASIC_CAST ctxType, NULL,
14951: "The union type definition is circular", NULL);
14952: return (XML_SCHEMAP_SRC_SIMPLE_TYPE_4);
14953: }
14954: if ((WXS_IS_UNION(memberType)) &&
14955: ((memberType->flags & XML_SCHEMAS_TYPE_MARKED) == 0))
14956: {
14957: int res;
14958: memberType->flags |= XML_SCHEMAS_TYPE_MARKED;
14959: res = xmlSchemaCheckUnionTypeDefCircularRecur(pctxt,
14960: ctxType,
14961: xmlSchemaGetUnionSimpleTypeMemberTypes(memberType));
14962: memberType->flags ^= XML_SCHEMAS_TYPE_MARKED;
14963: if (res != 0)
14964: return(res);
14965: }
14966: memberType = memberType->baseType;
14967: }
14968: member = member->next;
14969: }
14970: return(0);
14971: }
14972:
14973: static int
14974: xmlSchemaCheckUnionTypeDefCircular(xmlSchemaParserCtxtPtr pctxt,
14975: xmlSchemaTypePtr type)
14976: {
14977: if (! WXS_IS_UNION(type))
14978: return(0);
14979: return(xmlSchemaCheckUnionTypeDefCircularRecur(pctxt, type,
14980: type->memberTypes));
14981: }
14982:
14983: /**
14984: * xmlSchemaResolveTypeReferences:
14985: * @item: the complex/simple type definition
14986: * @ctxt: the parser context
14987: * @name: the name
14988: *
14989: * Resolvese type definition references
14990: */
14991: static void
14992: xmlSchemaResolveTypeReferences(xmlSchemaTypePtr typeDef,
14993: xmlSchemaParserCtxtPtr ctxt)
14994: {
14995: if (typeDef == NULL)
14996: return;
14997:
14998: /*
14999: * Resolve the base type.
15000: */
15001: if (typeDef->baseType == NULL) {
15002: typeDef->baseType = xmlSchemaGetType(ctxt->schema,
15003: typeDef->base, typeDef->baseNs);
15004: if (typeDef->baseType == NULL) {
15005: xmlSchemaPResCompAttrErr(ctxt,
15006: XML_SCHEMAP_SRC_RESOLVE,
15007: WXS_BASIC_CAST typeDef, typeDef->node,
15008: "base", typeDef->base, typeDef->baseNs,
15009: XML_SCHEMA_TYPE_SIMPLE, NULL);
15010: return;
15011: }
15012: }
15013: if (WXS_IS_SIMPLE(typeDef)) {
15014: if (WXS_IS_UNION(typeDef)) {
15015: /*
15016: * Resolve the memberTypes.
15017: */
15018: xmlSchemaResolveUnionMemberTypes(ctxt, typeDef);
15019: return;
15020: } else if (WXS_IS_LIST(typeDef)) {
15021: /*
15022: * Resolve the itemType.
15023: */
15024: if ((typeDef->subtypes == NULL) && (typeDef->base != NULL)) {
15025:
15026: typeDef->subtypes = xmlSchemaGetType(ctxt->schema,
15027: typeDef->base, typeDef->baseNs);
15028:
15029: if ((typeDef->subtypes == NULL) ||
15030: (! WXS_IS_SIMPLE(typeDef->subtypes)))
15031: {
15032: typeDef->subtypes = NULL;
15033: xmlSchemaPResCompAttrErr(ctxt,
15034: XML_SCHEMAP_SRC_RESOLVE,
15035: WXS_BASIC_CAST typeDef, typeDef->node,
15036: "itemType", typeDef->base, typeDef->baseNs,
15037: XML_SCHEMA_TYPE_SIMPLE, NULL);
15038: }
15039: }
15040: return;
15041: }
15042: }
15043: /*
15044: * The ball of letters below means, that if we have a particle
15045: * which has a QName-helper component as its {term}, we want
15046: * to resolve it...
15047: */
15048: else if ((WXS_TYPE_CONTENTTYPE(typeDef) != NULL) &&
15049: ((WXS_TYPE_CONTENTTYPE(typeDef))->type ==
15050: XML_SCHEMA_TYPE_PARTICLE) &&
15051: (WXS_TYPE_PARTICLE_TERM(typeDef) != NULL) &&
15052: ((WXS_TYPE_PARTICLE_TERM(typeDef))->type ==
15053: XML_SCHEMA_EXTRA_QNAMEREF))
15054: {
15055: xmlSchemaQNameRefPtr ref =
15056: WXS_QNAME_CAST WXS_TYPE_PARTICLE_TERM(typeDef);
15057: xmlSchemaModelGroupDefPtr groupDef;
15058:
15059: /*
15060: * URGENT TODO: Test this.
15061: */
15062: WXS_TYPE_PARTICLE_TERM(typeDef) = NULL;
15063: /*
15064: * Resolve the MG definition reference.
15065: */
15066: groupDef =
15067: WXS_MODEL_GROUPDEF_CAST xmlSchemaGetNamedComponent(ctxt->schema,
15068: ref->itemType, ref->name, ref->targetNamespace);
15069: if (groupDef == NULL) {
15070: xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
15071: NULL, WXS_ITEM_NODE(WXS_TYPE_PARTICLE(typeDef)),
15072: "ref", ref->name, ref->targetNamespace, ref->itemType,
15073: NULL);
15074: /* Remove the particle. */
15075: WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
15076: } else if (WXS_MODELGROUPDEF_MODEL(groupDef) == NULL)
15077: /* Remove the particle. */
15078: WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
15079: else {
15080: /*
15081: * Assign the MG definition's {model group} to the
15082: * particle's {term}.
15083: */
15084: WXS_TYPE_PARTICLE_TERM(typeDef) = WXS_MODELGROUPDEF_MODEL(groupDef);
15085:
15086: if (WXS_MODELGROUPDEF_MODEL(groupDef)->type == XML_SCHEMA_TYPE_ALL) {
15087: /*
15088: * SPEC cos-all-limited (1.2)
15089: * "1.2 the {term} property of a particle with
15090: * {max occurs}=1 which is part of a pair which constitutes
15091: * the {content type} of a complex type definition."
15092: */
15093: if ((WXS_TYPE_PARTICLE(typeDef))->maxOccurs != 1) {
15094: xmlSchemaCustomErr(ACTXT_CAST ctxt,
15095: /* TODO: error code */
15096: XML_SCHEMAP_COS_ALL_LIMITED,
15097: WXS_ITEM_NODE(WXS_TYPE_PARTICLE(typeDef)), NULL,
15098: "The particle's {max occurs} must be 1, since the "
15099: "reference resolves to an 'all' model group",
15100: NULL, NULL);
15101: }
15102: }
15103: }
15104: }
15105: }
15106:
15107:
15108:
15109: /**
15110: * xmlSchemaCheckSTPropsCorrect:
15111: * @ctxt: the schema parser context
15112: * @type: the simple type definition
15113: *
15114: * Checks st-props-correct.
15115: *
15116: * Returns 0 if the properties are correct,
15117: * if not, a positive error code and -1 on internal
15118: * errors.
15119: */
15120: static int
15121: xmlSchemaCheckSTPropsCorrect(xmlSchemaParserCtxtPtr ctxt,
15122: xmlSchemaTypePtr type)
15123: {
15124: xmlSchemaTypePtr baseType = type->baseType;
15125: xmlChar *str = NULL;
15126:
15127: /* STATE: error funcs converted. */
15128: /*
15129: * Schema Component Constraint: Simple Type Definition Properties Correct
15130: *
15131: * NOTE: This is somehow redundant, since we actually built a simple type
15132: * to have all the needed information; this acts as an self test.
15133: */
15134: /* Base type: If the datatype has been �derived� by �restriction�
15135: * then the Simple Type Definition component from which it is �derived�,
15136: * otherwise the Simple Type Definition for anySimpleType (�4.1.6).
15137: */
15138: if (baseType == NULL) {
15139: /*
15140: * TODO: Think about: "modulo the impact of Missing
15141: * Sub-components (�5.3)."
15142: */
15143: xmlSchemaPCustomErr(ctxt,
15144: XML_SCHEMAP_ST_PROPS_CORRECT_1,
15145: WXS_BASIC_CAST type, NULL,
15146: "No base type existent", NULL);
15147: return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
15148:
15149: }
15150: if (! WXS_IS_SIMPLE(baseType)) {
15151: xmlSchemaPCustomErr(ctxt,
15152: XML_SCHEMAP_ST_PROPS_CORRECT_1,
15153: WXS_BASIC_CAST type, NULL,
15154: "The base type '%s' is not a simple type",
15155: xmlSchemaGetComponentQName(&str, baseType));
15156: FREE_AND_NULL(str)
15157: return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
15158: }
15159: if ( (WXS_IS_LIST(type) || WXS_IS_UNION(type)) &&
15160: (WXS_IS_RESTRICTION(type) == 0) &&
15161: (! WXS_IS_ANY_SIMPLE_TYPE(baseType))) {
15162: xmlSchemaPCustomErr(ctxt,
15163: XML_SCHEMAP_ST_PROPS_CORRECT_1,
15164: WXS_BASIC_CAST type, NULL,
15165: "A type, derived by list or union, must have "
15166: "the simple ur-type definition as base type, not '%s'",
15167: xmlSchemaGetComponentQName(&str, baseType));
15168: FREE_AND_NULL(str)
15169: return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
15170: }
15171: /*
15172: * Variety: One of {atomic, list, union}.
15173: */
15174: if ((! WXS_IS_ATOMIC(type)) && (! WXS_IS_UNION(type)) &&
15175: (! WXS_IS_LIST(type))) {
15176: xmlSchemaPCustomErr(ctxt,
15177: XML_SCHEMAP_ST_PROPS_CORRECT_1,
15178: WXS_BASIC_CAST type, NULL,
15179: "The variety is absent", NULL);
15180: return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
15181: }
15182: /* TODO: Finish this. Hmm, is this finished? */
15183:
15184: /*
15185: * 3 The {final} of the {base type definition} must not contain restriction.
15186: */
15187: if (xmlSchemaTypeFinalContains(baseType,
15188: XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
15189: xmlSchemaPCustomErr(ctxt,
15190: XML_SCHEMAP_ST_PROPS_CORRECT_3,
15191: WXS_BASIC_CAST type, NULL,
15192: "The 'final' of its base type '%s' must not contain "
15193: "'restriction'",
15194: xmlSchemaGetComponentQName(&str, baseType));
15195: FREE_AND_NULL(str)
15196: return (XML_SCHEMAP_ST_PROPS_CORRECT_3);
15197: }
15198:
15199: /*
15200: * 2 All simple type definitions must be derived ultimately from the �simple
15201: * ur-type definition (so� circular definitions are disallowed). That is, it
15202: * must be possible to reach a built-in primitive datatype or the �simple
15203: * ur-type definition� by repeatedly following the {base type definition}.
15204: *
15205: * NOTE: this is done in xmlSchemaCheckTypeDefCircular().
15206: */
15207: return (0);
15208: }
15209:
15210: /**
15211: * xmlSchemaCheckCOSSTRestricts:
15212: * @ctxt: the schema parser context
15213: * @type: the simple type definition
15214: *
15215: * Schema Component Constraint:
15216: * Derivation Valid (Restriction, Simple) (cos-st-restricts)
15217:
15218: * Checks if the given @type (simpleType) is derived validly by restriction.
15219: * STATUS:
15220: *
15221: * Returns -1 on internal errors, 0 if the type is validly derived,
15222: * a positive error code otherwise.
15223: */
15224: static int
15225: xmlSchemaCheckCOSSTRestricts(xmlSchemaParserCtxtPtr pctxt,
15226: xmlSchemaTypePtr type)
15227: {
15228: xmlChar *str = NULL;
15229:
15230: if (type->type != XML_SCHEMA_TYPE_SIMPLE) {
15231: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15232: "given type is not a user-derived simpleType");
15233: return (-1);
15234: }
15235:
15236: if (WXS_IS_ATOMIC(type)) {
15237: xmlSchemaTypePtr primitive;
15238: /*
15239: * 1.1 The {base type definition} must be an atomic simple
15240: * type definition or a built-in primitive datatype.
15241: */
15242: if (! WXS_IS_ATOMIC(type->baseType)) {
15243: xmlSchemaPCustomErr(pctxt,
15244: XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
15245: WXS_BASIC_CAST type, NULL,
15246: "The base type '%s' is not an atomic simple type",
15247: xmlSchemaGetComponentQName(&str, type->baseType));
15248: FREE_AND_NULL(str)
15249: return (XML_SCHEMAP_COS_ST_RESTRICTS_1_1);
15250: }
15251: /* 1.2 The {final} of the {base type definition} must not contain
15252: * restriction.
15253: */
15254: /* OPTIMIZE TODO : This is already done in xmlSchemaCheckStPropsCorrect */
15255: if (xmlSchemaTypeFinalContains(type->baseType,
15256: XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
15257: xmlSchemaPCustomErr(pctxt,
15258: XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
15259: WXS_BASIC_CAST type, NULL,
15260: "The final of its base type '%s' must not contain 'restriction'",
15261: xmlSchemaGetComponentQName(&str, type->baseType));
15262: FREE_AND_NULL(str)
15263: return (XML_SCHEMAP_COS_ST_RESTRICTS_1_2);
15264: }
15265:
15266: /*
15267: * 1.3.1 DF must be an allowed constraining facet for the {primitive
15268: * type definition}, as specified in the appropriate subsection of 3.2
15269: * Primitive datatypes.
15270: */
15271: if (type->facets != NULL) {
15272: xmlSchemaFacetPtr facet;
15273: int ok = 1;
15274:
15275: primitive = xmlSchemaGetPrimitiveType(type);
15276: if (primitive == NULL) {
15277: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15278: "failed to get primitive type");
15279: return (-1);
15280: }
15281: facet = type->facets;
15282: do {
15283: if (xmlSchemaIsBuiltInTypeFacet(primitive, facet->type) == 0) {
15284: ok = 0;
15285: xmlSchemaPIllegalFacetAtomicErr(pctxt,
15286: XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
15287: type, primitive, facet);
15288: }
15289: facet = facet->next;
15290: } while (facet != NULL);
15291: if (ok == 0)
15292: return (XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1);
15293: }
15294: /*
15295: * SPEC (1.3.2) "If there is a facet of the same kind in the {facets}
15296: * of the {base type definition} (call this BF),then the DF's {value}
15297: * must be a valid restriction of BF's {value} as defined in
15298: * [XML Schemas: Datatypes]."
15299: *
15300: * NOTE (1.3.2) Facet derivation constraints are currently handled in
15301: * xmlSchemaDeriveAndValidateFacets()
15302: */
15303: } else if (WXS_IS_LIST(type)) {
15304: xmlSchemaTypePtr itemType = NULL;
15305:
15306: itemType = type->subtypes;
15307: if ((itemType == NULL) || (! WXS_IS_SIMPLE(itemType))) {
15308: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15309: "failed to evaluate the item type");
15310: return (-1);
15311: }
15312: if (WXS_IS_TYPE_NOT_FIXED(itemType))
15313: xmlSchemaTypeFixup(itemType, ACTXT_CAST pctxt);
15314: /*
15315: * 2.1 The {item type definition} must have a {variety} of atomic or
15316: * union (in which case all the {member type definitions}
15317: * must be atomic).
15318: */
15319: if ((! WXS_IS_ATOMIC(itemType)) &&
15320: (! WXS_IS_UNION(itemType))) {
15321: xmlSchemaPCustomErr(pctxt,
15322: XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
15323: WXS_BASIC_CAST type, NULL,
15324: "The item type '%s' does not have a variety of atomic or union",
15325: xmlSchemaGetComponentQName(&str, itemType));
15326: FREE_AND_NULL(str)
15327: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
15328: } else if (WXS_IS_UNION(itemType)) {
15329: xmlSchemaTypeLinkPtr member;
15330:
15331: member = itemType->memberTypes;
15332: while (member != NULL) {
15333: if (! WXS_IS_ATOMIC(member->type)) {
15334: xmlSchemaPCustomErr(pctxt,
15335: XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
15336: WXS_BASIC_CAST type, NULL,
15337: "The item type is a union type, but the "
15338: "member type '%s' of this item type is not atomic",
15339: xmlSchemaGetComponentQName(&str, member->type));
15340: FREE_AND_NULL(str)
15341: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_1);
15342: }
15343: member = member->next;
15344: }
15345: }
15346:
15347: if (WXS_IS_ANY_SIMPLE_TYPE(type->baseType)) {
15348: xmlSchemaFacetPtr facet;
15349: /*
15350: * This is the case if we have: <simpleType><list ..
15351: */
15352: /*
15353: * 2.3.1
15354: * 2.3.1.1 The {final} of the {item type definition} must not
15355: * contain list.
15356: */
15357: if (xmlSchemaTypeFinalContains(itemType,
15358: XML_SCHEMAS_TYPE_FINAL_LIST)) {
15359: xmlSchemaPCustomErr(pctxt,
15360: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
15361: WXS_BASIC_CAST type, NULL,
15362: "The final of its item type '%s' must not contain 'list'",
15363: xmlSchemaGetComponentQName(&str, itemType));
15364: FREE_AND_NULL(str)
15365: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1);
15366: }
15367: /*
15368: * 2.3.1.2 The {facets} must only contain the whiteSpace
15369: * facet component.
15370: * OPTIMIZE TODO: the S4S already disallows any facet
15371: * to be specified.
15372: */
15373: if (type->facets != NULL) {
15374: facet = type->facets;
15375: do {
15376: if (facet->type != XML_SCHEMA_FACET_WHITESPACE) {
15377: xmlSchemaPIllegalFacetListUnionErr(pctxt,
15378: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
15379: type, facet);
15380: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2);
15381: }
15382: facet = facet->next;
15383: } while (facet != NULL);
15384: }
15385: /*
15386: * MAYBE TODO: (Hmm, not really) Datatypes states:
15387: * A �list� datatype can be �derived� from an �atomic� datatype
15388: * whose �lexical space� allows space (such as string or anyURI)or
15389: * a �union� datatype any of whose {member type definitions}'s
15390: * �lexical space� allows space.
15391: */
15392: } else {
15393: /*
15394: * This is the case if we have: <simpleType><restriction ...
15395: * I.e. the variety of "list" is inherited.
15396: */
15397: /*
15398: * 2.3.2
15399: * 2.3.2.1 The {base type definition} must have a {variety} of list.
15400: */
15401: if (! WXS_IS_LIST(type->baseType)) {
15402: xmlSchemaPCustomErr(pctxt,
15403: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
15404: WXS_BASIC_CAST type, NULL,
15405: "The base type '%s' must be a list type",
15406: xmlSchemaGetComponentQName(&str, type->baseType));
15407: FREE_AND_NULL(str)
15408: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1);
15409: }
15410: /*
15411: * 2.3.2.2 The {final} of the {base type definition} must not
15412: * contain restriction.
15413: */
15414: if (xmlSchemaTypeFinalContains(type->baseType,
15415: XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
15416: xmlSchemaPCustomErr(pctxt,
15417: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
15418: WXS_BASIC_CAST type, NULL,
15419: "The 'final' of the base type '%s' must not contain 'restriction'",
15420: xmlSchemaGetComponentQName(&str, type->baseType));
15421: FREE_AND_NULL(str)
15422: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2);
15423: }
15424: /*
15425: * 2.3.2.3 The {item type definition} must be validly derived
15426: * from the {base type definition}'s {item type definition} given
15427: * the empty set, as defined in Type Derivation OK (Simple) (�3.14.6).
15428: */
15429: {
15430: xmlSchemaTypePtr baseItemType;
15431:
15432: baseItemType = type->baseType->subtypes;
15433: if ((baseItemType == NULL) || (! WXS_IS_SIMPLE(baseItemType))) {
15434: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15435: "failed to eval the item type of a base type");
15436: return (-1);
15437: }
15438: if ((itemType != baseItemType) &&
15439: (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt, itemType,
15440: baseItemType, 0) != 0)) {
15441: xmlChar *strBIT = NULL, *strBT = NULL;
15442: xmlSchemaPCustomErrExt(pctxt,
15443: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
15444: WXS_BASIC_CAST type, NULL,
15445: "The item type '%s' is not validly derived from "
15446: "the item type '%s' of the base type '%s'",
15447: xmlSchemaGetComponentQName(&str, itemType),
15448: xmlSchemaGetComponentQName(&strBIT, baseItemType),
15449: xmlSchemaGetComponentQName(&strBT, type->baseType));
15450:
15451: FREE_AND_NULL(str)
15452: FREE_AND_NULL(strBIT)
15453: FREE_AND_NULL(strBT)
15454: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3);
15455: }
15456: }
15457:
15458: if (type->facets != NULL) {
15459: xmlSchemaFacetPtr facet;
15460: int ok = 1;
15461: /*
15462: * 2.3.2.4 Only length, minLength, maxLength, whiteSpace, pattern
15463: * and enumeration facet components are allowed among the {facets}.
15464: */
15465: facet = type->facets;
15466: do {
15467: switch (facet->type) {
15468: case XML_SCHEMA_FACET_LENGTH:
15469: case XML_SCHEMA_FACET_MINLENGTH:
15470: case XML_SCHEMA_FACET_MAXLENGTH:
15471: case XML_SCHEMA_FACET_WHITESPACE:
15472: /*
15473: * TODO: 2.5.1.2 List datatypes
15474: * The value of �whiteSpace� is fixed to the value collapse.
15475: */
15476: case XML_SCHEMA_FACET_PATTERN:
15477: case XML_SCHEMA_FACET_ENUMERATION:
15478: break;
15479: default: {
15480: xmlSchemaPIllegalFacetListUnionErr(pctxt,
15481: XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
15482: type, facet);
15483: /*
15484: * We could return, but it's nicer to report all
15485: * invalid facets.
15486: */
15487: ok = 0;
15488: }
15489: }
15490: facet = facet->next;
15491: } while (facet != NULL);
15492: if (ok == 0)
15493: return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4);
15494: /*
15495: * SPEC (2.3.2.5) (same as 1.3.2)
15496: *
15497: * NOTE (2.3.2.5) This is currently done in
15498: * xmlSchemaDeriveAndValidateFacets()
15499: */
15500: }
15501: }
15502: } else if (WXS_IS_UNION(type)) {
15503: /*
15504: * 3.1 The {member type definitions} must all have {variety} of
15505: * atomic or list.
15506: */
15507: xmlSchemaTypeLinkPtr member;
15508:
15509: member = type->memberTypes;
15510: while (member != NULL) {
15511: if (WXS_IS_TYPE_NOT_FIXED(member->type))
15512: xmlSchemaTypeFixup(member->type, ACTXT_CAST pctxt);
15513:
15514: if ((! WXS_IS_ATOMIC(member->type)) &&
15515: (! WXS_IS_LIST(member->type))) {
15516: xmlSchemaPCustomErr(pctxt,
15517: XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
15518: WXS_BASIC_CAST type, NULL,
15519: "The member type '%s' is neither an atomic, nor a list type",
15520: xmlSchemaGetComponentQName(&str, member->type));
15521: FREE_AND_NULL(str)
15522: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_1);
15523: }
15524: member = member->next;
15525: }
15526: /*
15527: * 3.3.1 If the {base type definition} is the �simple ur-type
15528: * definition�
15529: */
15530: if (type->baseType->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) {
15531: /*
15532: * 3.3.1.1 All of the {member type definitions} must have a
15533: * {final} which does not contain union.
15534: */
15535: member = type->memberTypes;
15536: while (member != NULL) {
15537: if (xmlSchemaTypeFinalContains(member->type,
15538: XML_SCHEMAS_TYPE_FINAL_UNION)) {
15539: xmlSchemaPCustomErr(pctxt,
15540: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
15541: WXS_BASIC_CAST type, NULL,
15542: "The 'final' of member type '%s' contains 'union'",
15543: xmlSchemaGetComponentQName(&str, member->type));
15544: FREE_AND_NULL(str)
15545: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1);
15546: }
15547: member = member->next;
15548: }
15549: /*
15550: * 3.3.1.2 The {facets} must be empty.
15551: */
15552: if (type->facetSet != NULL) {
15553: xmlSchemaPCustomErr(pctxt,
15554: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
15555: WXS_BASIC_CAST type, NULL,
15556: "No facets allowed", NULL);
15557: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2);
15558: }
15559: } else {
15560: /*
15561: * 3.3.2.1 The {base type definition} must have a {variety} of union.
15562: * I.e. the variety of "list" is inherited.
15563: */
15564: if (! WXS_IS_UNION(type->baseType)) {
15565: xmlSchemaPCustomErr(pctxt,
15566: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
15567: WXS_BASIC_CAST type, NULL,
15568: "The base type '%s' is not a union type",
15569: xmlSchemaGetComponentQName(&str, type->baseType));
15570: FREE_AND_NULL(str)
15571: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1);
15572: }
15573: /*
15574: * 3.3.2.2 The {final} of the {base type definition} must not contain restriction.
15575: */
15576: if (xmlSchemaTypeFinalContains(type->baseType,
15577: XML_SCHEMAS_TYPE_FINAL_RESTRICTION)) {
15578: xmlSchemaPCustomErr(pctxt,
15579: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
15580: WXS_BASIC_CAST type, NULL,
15581: "The 'final' of its base type '%s' must not contain 'restriction'",
15582: xmlSchemaGetComponentQName(&str, type->baseType));
15583: FREE_AND_NULL(str)
15584: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2);
15585: }
15586: /*
15587: * 3.3.2.3 The {member type definitions}, in order, must be validly
15588: * derived from the corresponding type definitions in the {base
15589: * type definition}'s {member type definitions} given the empty set,
15590: * as defined in Type Derivation OK (Simple) (�3.14.6).
15591: */
15592: {
15593: xmlSchemaTypeLinkPtr baseMember;
15594:
15595: /*
15596: * OPTIMIZE: if the type is restricting, it has no local defined
15597: * member types and inherits the member types of the base type;
15598: * thus a check for equality can be skipped.
15599: */
15600: /*
15601: * Even worse: I cannot see a scenario where a restricting
15602: * union simple type can have other member types as the member
15603: * types of it's base type. This check seems not necessary with
15604: * respect to the derivation process in libxml2.
15605: * But necessary if constructing types with an API.
15606: */
15607: if (type->memberTypes != NULL) {
15608: member = type->memberTypes;
15609: baseMember = xmlSchemaGetUnionSimpleTypeMemberTypes(type->baseType);
15610: if ((member == NULL) && (baseMember != NULL)) {
15611: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15612: "different number of member types in base");
15613: }
15614: while (member != NULL) {
15615: if (baseMember == NULL) {
15616: PERROR_INT("xmlSchemaCheckCOSSTRestricts",
15617: "different number of member types in base");
15618: } else if ((member->type != baseMember->type) &&
15619: (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt,
15620: member->type, baseMember->type, 0) != 0)) {
15621: xmlChar *strBMT = NULL, *strBT = NULL;
15622:
15623: xmlSchemaPCustomErrExt(pctxt,
15624: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
15625: WXS_BASIC_CAST type, NULL,
15626: "The member type %s is not validly "
15627: "derived from its corresponding member "
15628: "type %s of the base type %s",
15629: xmlSchemaGetComponentQName(&str, member->type),
15630: xmlSchemaGetComponentQName(&strBMT, baseMember->type),
15631: xmlSchemaGetComponentQName(&strBT, type->baseType));
15632: FREE_AND_NULL(str)
15633: FREE_AND_NULL(strBMT)
15634: FREE_AND_NULL(strBT)
15635: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3);
15636: }
15637: member = member->next;
15638: if (baseMember != NULL)
15639: baseMember = baseMember->next;
15640: }
15641: }
15642: }
15643: /*
15644: * 3.3.2.4 Only pattern and enumeration facet components are
15645: * allowed among the {facets}.
15646: */
15647: if (type->facets != NULL) {
15648: xmlSchemaFacetPtr facet;
15649: int ok = 1;
15650:
15651: facet = type->facets;
15652: do {
15653: if ((facet->type != XML_SCHEMA_FACET_PATTERN) &&
15654: (facet->type != XML_SCHEMA_FACET_ENUMERATION)) {
15655: xmlSchemaPIllegalFacetListUnionErr(pctxt,
15656: XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
15657: type, facet);
15658: ok = 0;
15659: }
15660: facet = facet->next;
15661: } while (facet != NULL);
15662: if (ok == 0)
15663: return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4);
15664:
15665: }
15666: /*
15667: * SPEC (3.3.2.5) (same as 1.3.2)
15668: *
15669: * NOTE (3.3.2.5) This is currently done in
15670: * xmlSchemaDeriveAndValidateFacets()
15671: */
15672: }
15673: }
15674:
15675: return (0);
15676: }
15677:
15678: /**
15679: * xmlSchemaCheckSRCSimpleType:
15680: * @ctxt: the schema parser context
15681: * @type: the simple type definition
15682: *
15683: * Checks crc-simple-type constraints.
15684: *
15685: * Returns 0 if the constraints are satisfied,
15686: * if not a positive error code and -1 on internal
15687: * errors.
15688: */
15689: #if 0
15690: static int
15691: xmlSchemaCheckSRCSimpleType(xmlSchemaParserCtxtPtr ctxt,
15692: xmlSchemaTypePtr type)
15693: {
15694: /*
15695: * src-simple-type.1 The corresponding simple type definition, if any,
15696: * must satisfy the conditions set out in Constraints on Simple Type
15697: * Definition Schema Components (�3.14.6).
15698: */
15699: if (WXS_IS_RESTRICTION(type)) {
15700: /*
15701: * src-simple-type.2 "If the <restriction> alternative is chosen,
15702: * either it must have a base [attribute] or a <simpleType> among its
15703: * [children], but not both."
15704: * NOTE: This is checked in the parse function of <restriction>.
15705: */
15706: /*
15707: *
15708: */
15709: } else if (WXS_IS_LIST(type)) {
15710: /* src-simple-type.3 "If the <list> alternative is chosen, either it must have
15711: * an itemType [attribute] or a <simpleType> among its [children],
15712: * but not both."
15713: *
15714: * NOTE: This is checked in the parse function of <list>.
15715: */
15716: } else if (WXS_IS_UNION(type)) {
15717: /*
15718: * src-simple-type.4 is checked in xmlSchemaCheckUnionTypeDefCircular().
15719: */
15720: }
15721: return (0);
15722: }
15723: #endif
15724:
15725: static int
15726: xmlSchemaCreateVCtxtOnPCtxt(xmlSchemaParserCtxtPtr ctxt)
15727: {
15728: if (ctxt->vctxt == NULL) {
15729: ctxt->vctxt = xmlSchemaNewValidCtxt(NULL);
15730: if (ctxt->vctxt == NULL) {
15731: xmlSchemaPErr(ctxt, NULL,
15732: XML_SCHEMAP_INTERNAL,
15733: "Internal error: xmlSchemaCreateVCtxtOnPCtxt, "
15734: "failed to create a temp. validation context.\n",
15735: NULL, NULL);
15736: return (-1);
15737: }
15738: /* TODO: Pass user data. */
15739: xmlSchemaSetValidErrors(ctxt->vctxt,
15740: ctxt->error, ctxt->warning, ctxt->errCtxt);
15741: xmlSchemaSetValidStructuredErrors(ctxt->vctxt,
15742: ctxt->serror, ctxt->errCtxt);
15743: }
15744: return (0);
15745: }
15746:
15747: static int
15748: xmlSchemaVCheckCVCSimpleType(xmlSchemaAbstractCtxtPtr actxt,
15749: xmlNodePtr node,
15750: xmlSchemaTypePtr type,
15751: const xmlChar *value,
15752: xmlSchemaValPtr *retVal,
15753: int fireErrors,
15754: int normalize,
15755: int isNormalized);
15756:
15757: /**
15758: * xmlSchemaParseCheckCOSValidDefault:
15759: * @pctxt: the schema parser context
15760: * @type: the simple type definition
15761: * @value: the default value
15762: * @node: an optional node (the holder of the value)
15763: *
15764: * Schema Component Constraint: Element Default Valid (Immediate)
15765: * (cos-valid-default)
15766: * This will be used by the parser only. For the validator there's
15767: * an other version.
15768: *
15769: * Returns 0 if the constraints are satisfied,
15770: * if not, a positive error code and -1 on internal
15771: * errors.
15772: */
15773: static int
15774: xmlSchemaParseCheckCOSValidDefault(xmlSchemaParserCtxtPtr pctxt,
15775: xmlNodePtr node,
15776: xmlSchemaTypePtr type,
15777: const xmlChar *value,
15778: xmlSchemaValPtr *val)
15779: {
15780: int ret = 0;
15781:
15782: /*
15783: * cos-valid-default:
15784: * Schema Component Constraint: Element Default Valid (Immediate)
15785: * For a string to be a valid default with respect to a type
15786: * definition the appropriate case among the following must be true:
15787: */
15788: if WXS_IS_COMPLEX(type) {
15789: /*
15790: * Complex type.
15791: *
15792: * SPEC (2.1) "its {content type} must be a simple type definition
15793: * or mixed."
15794: * SPEC (2.2.2) "If the {content type} is mixed, then the {content
15795: * type}'s particle must be �emptiable� as defined by
15796: * Particle Emptiable (�3.9.6)."
15797: */
15798: if ((! WXS_HAS_SIMPLE_CONTENT(type)) &&
15799: ((! WXS_HAS_MIXED_CONTENT(type)) || (! WXS_EMPTIABLE(type)))) {
15800: /* NOTE that this covers (2.2.2) as well. */
15801: xmlSchemaPCustomErr(pctxt,
15802: XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
15803: WXS_BASIC_CAST type, type->node,
15804: "For a string to be a valid default, the type definition "
15805: "must be a simple type or a complex type with mixed content "
15806: "and a particle emptiable", NULL);
15807: return(XML_SCHEMAP_COS_VALID_DEFAULT_2_1);
15808: }
15809: }
15810: /*
15811: * 1 If the type definition is a simple type definition, then the string
15812: * must be �valid� with respect to that definition as defined by String
15813: * Valid (�3.14.4).
15814: *
15815: * AND
15816: *
15817: * 2.2.1 If the {content type} is a simple type definition, then the
15818: * string must be �valid� with respect to that simple type definition
15819: * as defined by String Valid (�3.14.4).
15820: */
15821: if (WXS_IS_SIMPLE(type))
15822: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
15823: type, value, val, 1, 1, 0);
15824: else if (WXS_HAS_SIMPLE_CONTENT(type))
15825: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
15826: type->contentTypeDef, value, val, 1, 1, 0);
15827: else
15828: return (ret);
15829:
15830: if (ret < 0) {
15831: PERROR_INT("xmlSchemaParseCheckCOSValidDefault",
15832: "calling xmlSchemaVCheckCVCSimpleType()");
15833: }
15834:
15835: return (ret);
15836: }
15837:
15838: /**
15839: * xmlSchemaCheckCTPropsCorrect:
15840: * @ctxt: the schema parser context
15841: * @type: the complex type definition
15842: *
15843: *.(4.6) Constraints on Complex Type Definition Schema Components
15844: * Schema Component Constraint:
15845: * Complex Type Definition Properties Correct (ct-props-correct)
15846: * STATUS: (seems) complete
15847: *
15848: * Returns 0 if the constraints are satisfied, a positive
15849: * error code if not and -1 if an internal error occured.
15850: */
15851: static int
15852: xmlSchemaCheckCTPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
15853: xmlSchemaTypePtr type)
15854: {
15855: /*
15856: * TODO: Correct the error code; XML_SCHEMAP_SRC_CT_1 is used temporarily.
15857: *
15858: * SPEC (1) "The values of the properties of a complex type definition must
15859: * be as described in the property tableau in The Complex Type Definition
15860: * Schema Component (�3.4.1), modulo the impact of Missing
15861: * Sub-components (�5.3)."
15862: */
15863: if ((type->baseType != NULL) &&
15864: (WXS_IS_SIMPLE(type->baseType)) &&
15865: (WXS_IS_EXTENSION(type) == 0)) {
15866: /*
15867: * SPEC (2) "If the {base type definition} is a simple type definition,
15868: * the {derivation method} must be extension."
15869: */
15870: xmlSchemaCustomErr(ACTXT_CAST pctxt,
15871: XML_SCHEMAP_SRC_CT_1,
15872: NULL, WXS_BASIC_CAST type,
15873: "If the base type is a simple type, the derivation method must be "
15874: "'extension'", NULL, NULL);
15875: return (XML_SCHEMAP_SRC_CT_1);
15876: }
15877: /*
15878: * SPEC (3) "Circular definitions are disallowed, except for the �ur-type
15879: * definition�. That is, it must be possible to reach the �ur-type
15880: * definition by repeatedly following the {base type definition}."
15881: *
15882: * NOTE (3) is done in xmlSchemaCheckTypeDefCircular().
15883: */
15884: /*
15885: * NOTE that (4) and (5) need the following:
15886: * - attribute uses need to be already inherited (apply attr. prohibitions)
15887: * - attribute group references need to be expanded already
15888: * - simple types need to be typefixed already
15889: */
15890: if (type->attrUses &&
15891: (((xmlSchemaItemListPtr) type->attrUses)->nbItems > 1))
15892: {
15893: xmlSchemaItemListPtr uses = (xmlSchemaItemListPtr) type->attrUses;
15894: xmlSchemaAttributeUsePtr use, tmp;
15895: int i, j, hasId = 0;
15896:
15897: for (i = uses->nbItems -1; i >= 0; i--) {
15898: use = uses->items[i];
15899:
15900: /*
15901: * SPEC ct-props-correct
15902: * (4) "Two distinct attribute declarations in the
15903: * {attribute uses} must not have identical {name}s and
15904: * {target namespace}s."
15905: */
15906: if (i > 0) {
15907: for (j = i -1; j >= 0; j--) {
15908: tmp = uses->items[j];
15909: if ((WXS_ATTRUSE_DECL_NAME(use) ==
15910: WXS_ATTRUSE_DECL_NAME(tmp)) &&
15911: (WXS_ATTRUSE_DECL_TNS(use) ==
15912: WXS_ATTRUSE_DECL_TNS(tmp)))
15913: {
15914: xmlChar *str = NULL;
15915:
15916: xmlSchemaCustomErr(ACTXT_CAST pctxt,
15917: XML_SCHEMAP_AG_PROPS_CORRECT,
15918: NULL, WXS_BASIC_CAST type,
15919: "Duplicate %s",
15920: xmlSchemaGetComponentDesignation(&str, use),
15921: NULL);
15922: FREE_AND_NULL(str);
15923: /*
15924: * Remove the duplicate.
15925: */
15926: if (xmlSchemaItemListRemove(uses, i) == -1)
15927: goto exit_failure;
15928: goto next_use;
15929: }
15930: }
15931: }
15932: /*
15933: * SPEC ct-props-correct
15934: * (5) "Two distinct attribute declarations in the
15935: * {attribute uses} must not have {type definition}s which
15936: * are or are derived from ID."
15937: */
15938: if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
15939: if (xmlSchemaIsDerivedFromBuiltInType(
15940: WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
15941: {
15942: if (hasId) {
15943: xmlChar *str = NULL;
15944:
15945: xmlSchemaCustomErr(ACTXT_CAST pctxt,
15946: XML_SCHEMAP_AG_PROPS_CORRECT,
15947: NULL, WXS_BASIC_CAST type,
15948: "There must not exist more than one attribute "
15949: "declaration of type 'xs:ID' "
15950: "(or derived from 'xs:ID'). The %s violates this "
15951: "constraint",
15952: xmlSchemaGetComponentDesignation(&str, use),
15953: NULL);
15954: FREE_AND_NULL(str);
15955: if (xmlSchemaItemListRemove(uses, i) == -1)
15956: goto exit_failure;
15957: }
15958:
15959: hasId = 1;
15960: }
15961: }
15962: next_use: {}
15963: }
15964: }
15965: return (0);
15966: exit_failure:
15967: return(-1);
15968: }
15969:
15970: static int
15971: xmlSchemaAreEqualTypes(xmlSchemaTypePtr typeA,
15972: xmlSchemaTypePtr typeB)
15973: {
15974: /*
15975: * TODO: This should implement component-identity
15976: * in the future.
15977: */
15978: if ((typeA == NULL) || (typeB == NULL))
15979: return (0);
15980: return (typeA == typeB);
15981: }
15982:
15983: /**
15984: * xmlSchemaCheckCOSCTDerivedOK:
15985: * @ctxt: the schema parser context
15986: * @type: the to-be derived complex type definition
15987: * @baseType: the base complex type definition
15988: * @set: the given set
15989: *
15990: * Schema Component Constraint:
15991: * Type Derivation OK (Complex) (cos-ct-derived-ok)
15992: *
15993: * STATUS: completed
15994: *
15995: * Returns 0 if the constraints are satisfied, or 1
15996: * if not.
15997: */
15998: static int
15999: xmlSchemaCheckCOSCTDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
16000: xmlSchemaTypePtr type,
16001: xmlSchemaTypePtr baseType,
16002: int set)
16003: {
16004: int equal = xmlSchemaAreEqualTypes(type, baseType);
16005: /* TODO: Error codes. */
16006: /*
16007: * SPEC "For a complex type definition (call it D, for derived)
16008: * to be validly derived from a type definition (call this
16009: * B, for base) given a subset of {extension, restriction}
16010: * all of the following must be true:"
16011: */
16012: if (! equal) {
16013: /*
16014: * SPEC (1) "If B and D are not the same type definition, then the
16015: * {derivation method} of D must not be in the subset."
16016: */
16017: if (((set & SUBSET_EXTENSION) && (WXS_IS_EXTENSION(type))) ||
16018: ((set & SUBSET_RESTRICTION) && (WXS_IS_RESTRICTION(type))))
16019: return (1);
16020: } else {
16021: /*
16022: * SPEC (2.1) "B and D must be the same type definition."
16023: */
16024: return (0);
16025: }
16026: /*
16027: * SPEC (2.2) "B must be D's {base type definition}."
16028: */
16029: if (type->baseType == baseType)
16030: return (0);
16031: /*
16032: * SPEC (2.3.1) "D's {base type definition} must not be the �ur-type
16033: * definition�."
16034: */
16035: if (WXS_IS_ANYTYPE(type->baseType))
16036: return (1);
16037:
16038: if (WXS_IS_COMPLEX(type->baseType)) {
16039: /*
16040: * SPEC (2.3.2.1) "If D's {base type definition} is complex, then it
16041: * must be validly derived from B given the subset as defined by this
16042: * constraint."
16043: */
16044: return (xmlSchemaCheckCOSCTDerivedOK(actxt, type->baseType,
16045: baseType, set));
16046: } else {
16047: /*
16048: * SPEC (2.3.2.2) "If D's {base type definition} is simple, then it
16049: * must be validly derived from B given the subset as defined in Type
16050: * Derivation OK (Simple) (�3.14.6).
16051: */
16052: return (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
16053: baseType, set));
16054: }
16055: }
16056:
16057: /**
16058: * xmlSchemaCheckCOSDerivedOK:
16059: * @type: the derived simple type definition
16060: * @baseType: the base type definition
16061: *
16062: * Calls:
16063: * Type Derivation OK (Simple) AND Type Derivation OK (Complex)
16064: *
16065: * Checks wheter @type can be validly derived from @baseType.
16066: *
16067: * Returns 0 on success, an positive error code otherwise.
16068: */
16069: static int
16070: xmlSchemaCheckCOSDerivedOK(xmlSchemaAbstractCtxtPtr actxt,
16071: xmlSchemaTypePtr type,
16072: xmlSchemaTypePtr baseType,
16073: int set)
16074: {
16075: if (WXS_IS_SIMPLE(type))
16076: return (xmlSchemaCheckCOSSTDerivedOK(actxt, type, baseType, set));
16077: else
16078: return (xmlSchemaCheckCOSCTDerivedOK(actxt, type, baseType, set));
16079: }
16080:
16081: /**
16082: * xmlSchemaCheckCOSCTExtends:
16083: * @ctxt: the schema parser context
16084: * @type: the complex type definition
16085: *
16086: * (3.4.6) Constraints on Complex Type Definition Schema Components
16087: * Schema Component Constraint:
16088: * Derivation Valid (Extension) (cos-ct-extends)
16089: *
16090: * STATUS:
16091: * missing:
16092: * (1.5)
16093: * (1.4.3.2.2.2) "Particle Valid (Extension)"
16094: *
16095: * Returns 0 if the constraints are satisfied, a positive
16096: * error code if not and -1 if an internal error occured.
16097: */
16098: static int
16099: xmlSchemaCheckCOSCTExtends(xmlSchemaParserCtxtPtr ctxt,
16100: xmlSchemaTypePtr type)
16101: {
16102: xmlSchemaTypePtr base = type->baseType;
16103: /*
16104: * TODO: Correct the error code; XML_SCHEMAP_COS_CT_EXTENDS_1_1 is used
16105: * temporarily only.
16106: */
16107: /*
16108: * SPEC (1) "If the {base type definition} is a complex type definition,
16109: * then all of the following must be true:"
16110: */
16111: if (WXS_IS_COMPLEX(base)) {
16112: /*
16113: * SPEC (1.1) "The {final} of the {base type definition} must not
16114: * contain extension."
16115: */
16116: if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
16117: xmlSchemaPCustomErr(ctxt,
16118: XML_SCHEMAP_COS_CT_EXTENDS_1_1,
16119: WXS_BASIC_CAST type, NULL,
16120: "The 'final' of the base type definition "
16121: "contains 'extension'", NULL);
16122: return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
16123: }
16124:
16125: /*
16126: * ATTENTION: The constrains (1.2) and (1.3) are not applied,
16127: * since they are automatically satisfied through the
16128: * inheriting mechanism.
16129: * Note that even if redefining components, the inheriting mechanism
16130: * is used.
16131: */
16132: #if 0
16133: /*
16134: * SPEC (1.2) "Its {attribute uses} must be a subset of the {attribute
16135: * uses}
16136: * of the complex type definition itself, that is, for every attribute
16137: * use in the {attribute uses} of the {base type definition}, there
16138: * must be an attribute use in the {attribute uses} of the complex
16139: * type definition itself whose {attribute declaration} has the same
16140: * {name}, {target namespace} and {type definition} as its attribute
16141: * declaration"
16142: */
16143: if (base->attrUses != NULL) {
16144: int i, j, found;
16145: xmlSchemaAttributeUsePtr use, buse;
16146:
16147: for (i = 0; i < (WXS_LIST_CAST base->attrUses)->nbItems; i ++) {
16148: buse = (WXS_LIST_CAST base->attrUses)->items[i];
16149: found = 0;
16150: if (type->attrUses != NULL) {
16151: use = (WXS_LIST_CAST type->attrUses)->items[j];
16152: for (j = 0; j < (WXS_LIST_CAST type->attrUses)->nbItems; j ++)
16153: {
16154: if ((WXS_ATTRUSE_DECL_NAME(use) ==
16155: WXS_ATTRUSE_DECL_NAME(buse)) &&
16156: (WXS_ATTRUSE_DECL_TNS(use) ==
16157: WXS_ATTRUSE_DECL_TNS(buse)) &&
16158: (WXS_ATTRUSE_TYPEDEF(use) ==
16159: WXS_ATTRUSE_TYPEDEF(buse))
16160: {
16161: found = 1;
16162: break;
16163: }
16164: }
16165: }
16166: if (! found) {
16167: xmlChar *str = NULL;
16168:
16169: xmlSchemaCustomErr(ACTXT_CAST ctxt,
16170: XML_SCHEMAP_COS_CT_EXTENDS_1_2,
16171: NULL, WXS_BASIC_CAST type,
16172: /*
16173: * TODO: The report does not indicate that also the
16174: * type needs to be the same.
16175: */
16176: "This type is missing a matching correspondent "
16177: "for its {base type}'s %s in its {attribute uses}",
16178: xmlSchemaGetComponentDesignation(&str,
16179: buse->children),
16180: NULL);
16181: FREE_AND_NULL(str)
16182: }
16183: }
16184: }
16185: /*
16186: * SPEC (1.3) "If it has an {attribute wildcard}, the complex type
16187: * definition must also have one, and the base type definition's
16188: * {attribute wildcard}'s {namespace constraint} must be a subset
16189: * of the complex type definition's {attribute wildcard}'s {namespace
16190: * constraint}, as defined by Wildcard Subset (�3.10.6)."
16191: */
16192:
16193: /*
16194: * MAYBE TODO: Enable if ever needed. But this will be needed only
16195: * if created the type via a schema construction API.
16196: */
16197: if (base->attributeWildcard != NULL) {
16198: if (type->attributeWilcard == NULL) {
16199: xmlChar *str = NULL;
16200:
16201: xmlSchemaCustomErr(ACTXT_CAST pctxt,
16202: XML_SCHEMAP_COS_CT_EXTENDS_1_3,
16203: NULL, type,
16204: "The base %s has an attribute wildcard, "
16205: "but this type is missing an attribute wildcard",
16206: xmlSchemaGetComponentDesignation(&str, base));
16207: FREE_AND_NULL(str)
16208:
16209: } else if (xmlSchemaCheckCOSNSSubset(
16210: base->attributeWildcard, type->attributeWildcard))
16211: {
16212: xmlChar *str = NULL;
16213:
16214: xmlSchemaCustomErr(ACTXT_CAST pctxt,
16215: XML_SCHEMAP_COS_CT_EXTENDS_1_3,
16216: NULL, type,
16217: "The attribute wildcard is not a valid "
16218: "superset of the one in the base %s",
16219: xmlSchemaGetComponentDesignation(&str, base));
16220: FREE_AND_NULL(str)
16221: }
16222: }
16223: #endif
16224: /*
16225: * SPEC (1.4) "One of the following must be true:"
16226: */
16227: if ((type->contentTypeDef != NULL) &&
16228: (type->contentTypeDef == base->contentTypeDef)) {
16229: /*
16230: * SPEC (1.4.1) "The {content type} of the {base type definition}
16231: * and the {content type} of the complex type definition itself
16232: * must be the same simple type definition"
16233: * PASS
16234: */
16235: } else if ((type->contentType == XML_SCHEMA_CONTENT_EMPTY) &&
16236: (base->contentType == XML_SCHEMA_CONTENT_EMPTY) ) {
16237: /*
16238: * SPEC (1.4.2) "The {content type} of both the {base type
16239: * definition} and the complex type definition itself must
16240: * be empty."
16241: * PASS
16242: */
16243: } else {
16244: /*
16245: * SPEC (1.4.3) "All of the following must be true:"
16246: */
16247: if (type->subtypes == NULL) {
16248: /*
16249: * SPEC 1.4.3.1 The {content type} of the complex type
16250: * definition itself must specify a particle.
16251: */
16252: xmlSchemaPCustomErr(ctxt,
16253: XML_SCHEMAP_COS_CT_EXTENDS_1_1,
16254: WXS_BASIC_CAST type, NULL,
16255: "The content type must specify a particle", NULL);
16256: return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
16257: }
16258: /*
16259: * SPEC (1.4.3.2) "One of the following must be true:"
16260: */
16261: if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
16262: /*
16263: * SPEC (1.4.3.2.1) "The {content type} of the {base type
16264: * definition} must be empty.
16265: * PASS
16266: */
16267: } else {
16268: /*
16269: * SPEC (1.4.3.2.2) "All of the following must be true:"
16270: */
16271: if ((type->contentType != base->contentType) ||
16272: ((type->contentType != XML_SCHEMA_CONTENT_MIXED) &&
16273: (type->contentType != XML_SCHEMA_CONTENT_ELEMENTS))) {
16274: /*
16275: * SPEC (1.4.3.2.2.1) "Both {content type}s must be mixed
16276: * or both must be element-only."
16277: */
16278: xmlSchemaPCustomErr(ctxt,
16279: XML_SCHEMAP_COS_CT_EXTENDS_1_1,
16280: WXS_BASIC_CAST type, NULL,
16281: "The content type of both, the type and its base "
16282: "type, must either 'mixed' or 'element-only'", NULL);
16283: return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
16284: }
16285: /*
16286: * URGENT TODO SPEC (1.4.3.2.2.2) "The particle of the
16287: * complex type definition must be a �valid extension�
16288: * of the {base type definition}'s particle, as defined
16289: * in Particle Valid (Extension) (�3.9.6)."
16290: *
16291: * NOTE that we won't check "Particle Valid (Extension)",
16292: * since it is ensured by the derivation process in
16293: * xmlSchemaTypeFixup(). We need to implement this when heading
16294: * for a construction API
16295: * TODO: !! This is needed to be checked if redefining a type !!
16296: */
16297: }
16298: /*
16299: * URGENT TODO (1.5)
16300: */
16301: }
16302: } else {
16303: /*
16304: * SPEC (2) "If the {base type definition} is a simple type definition,
16305: * then all of the following must be true:"
16306: */
16307: if (type->contentTypeDef != base) {
16308: /*
16309: * SPEC (2.1) "The {content type} must be the same simple type
16310: * definition."
16311: */
16312: xmlSchemaPCustomErr(ctxt,
16313: XML_SCHEMAP_COS_CT_EXTENDS_1_1,
16314: WXS_BASIC_CAST type, NULL,
16315: "The content type must be the simple base type", NULL);
16316: return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
16317: }
16318: if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
16319: /*
16320: * SPEC (2.2) "The {final} of the {base type definition} must not
16321: * contain extension"
16322: * NOTE that this is the same as (1.1).
16323: */
16324: xmlSchemaPCustomErr(ctxt,
16325: XML_SCHEMAP_COS_CT_EXTENDS_1_1,
16326: WXS_BASIC_CAST type, NULL,
16327: "The 'final' of the base type definition "
16328: "contains 'extension'", NULL);
16329: return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
16330: }
16331: }
16332: return (0);
16333: }
16334:
16335: /**
16336: * xmlSchemaCheckDerivationOKRestriction:
16337: * @ctxt: the schema parser context
16338: * @type: the complex type definition
16339: *
16340: * (3.4.6) Constraints on Complex Type Definition Schema Components
16341: * Schema Component Constraint:
16342: * Derivation Valid (Restriction, Complex) (derivation-ok-restriction)
16343: *
16344: * STATUS:
16345: * missing:
16346: * (5.4.2) ???
16347: *
16348: * ATTENTION:
16349: * In XML Schema 1.1 this will be:
16350: * Validation Rule: Checking complex type subsumption
16351: *
16352: * Returns 0 if the constraints are satisfied, a positive
16353: * error code if not and -1 if an internal error occured.
16354: */
16355: static int
16356: xmlSchemaCheckDerivationOKRestriction(xmlSchemaParserCtxtPtr ctxt,
16357: xmlSchemaTypePtr type)
16358: {
16359: xmlSchemaTypePtr base;
16360:
16361: /*
16362: * TODO: Correct the error code; XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 is used
16363: * temporarily only.
16364: */
16365: base = type->baseType;
16366: if (! WXS_IS_COMPLEX(base)) {
16367: xmlSchemaCustomErr(ACTXT_CAST ctxt,
16368: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16369: type->node, WXS_BASIC_CAST type,
16370: "The base type must be a complex type", NULL, NULL);
16371: return(ctxt->err);
16372: }
16373: if (base->flags & XML_SCHEMAS_TYPE_FINAL_RESTRICTION) {
16374: /*
16375: * SPEC (1) "The {base type definition} must be a complex type
16376: * definition whose {final} does not contain restriction."
16377: */
16378: xmlSchemaCustomErr(ACTXT_CAST ctxt,
16379: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16380: type->node, WXS_BASIC_CAST type,
16381: "The 'final' of the base type definition "
16382: "contains 'restriction'", NULL, NULL);
16383: return (ctxt->err);
16384: }
16385: /*
16386: * SPEC (2), (3) and (4)
16387: * Those are handled in a separate function, since the
16388: * same constraints are needed for redefinition of
16389: * attribute groups as well.
16390: */
16391: if (xmlSchemaCheckDerivationOKRestriction2to4(ctxt,
16392: XML_SCHEMA_ACTION_DERIVE,
16393: WXS_BASIC_CAST type, WXS_BASIC_CAST base,
16394: type->attrUses, base->attrUses,
16395: type->attributeWildcard,
16396: base->attributeWildcard) == -1)
16397: {
16398: return(-1);
16399: }
16400: /*
16401: * SPEC (5) "One of the following must be true:"
16402: */
16403: if (base->builtInType == XML_SCHEMAS_ANYTYPE) {
16404: /*
16405: * SPEC (5.1) "The {base type definition} must be the
16406: * �ur-type definition�."
16407: * PASS
16408: */
16409: } else if ((type->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
16410: (type->contentType == XML_SCHEMA_CONTENT_BASIC)) {
16411: /*
16412: * SPEC (5.2.1) "The {content type} of the complex type definition
16413: * must be a simple type definition"
16414: *
16415: * SPEC (5.2.2) "One of the following must be true:"
16416: */
16417: if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
16418: (base->contentType == XML_SCHEMA_CONTENT_BASIC))
16419: {
16420: int err;
16421: /*
16422: * SPEC (5.2.2.1) "The {content type} of the {base type
16423: * definition} must be a simple type definition from which
16424: * the {content type} is validly derived given the empty
16425: * set as defined in Type Derivation OK (Simple) (�3.14.6)."
16426: *
16427: * ATTENTION TODO: This seems not needed if the type implicitely
16428: * derived from the base type.
16429: *
16430: */
16431: err = xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST ctxt,
16432: type->contentTypeDef, base->contentTypeDef, 0);
16433: if (err != 0) {
16434: xmlChar *strA = NULL, *strB = NULL;
16435:
16436: if (err == -1)
16437: return(-1);
16438: xmlSchemaCustomErr(ACTXT_CAST ctxt,
16439: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16440: NULL, WXS_BASIC_CAST type,
16441: "The {content type} %s is not validly derived from the "
16442: "base type's {content type} %s",
16443: xmlSchemaGetComponentDesignation(&strA,
16444: type->contentTypeDef),
16445: xmlSchemaGetComponentDesignation(&strB,
16446: base->contentTypeDef));
16447: FREE_AND_NULL(strA);
16448: FREE_AND_NULL(strB);
16449: return(ctxt->err);
16450: }
16451: } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
16452: (xmlSchemaIsParticleEmptiable(
16453: (xmlSchemaParticlePtr) base->subtypes))) {
16454: /*
16455: * SPEC (5.2.2.2) "The {base type definition} must be mixed
16456: * and have a particle which is �emptiable� as defined in
16457: * Particle Emptiable (�3.9.6)."
16458: * PASS
16459: */
16460: } else {
16461: xmlSchemaPCustomErr(ctxt,
16462: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16463: WXS_BASIC_CAST type, NULL,
16464: "The content type of the base type must be either "
16465: "a simple type or 'mixed' and an emptiable particle", NULL);
16466: return (ctxt->err);
16467: }
16468: } else if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
16469: /*
16470: * SPEC (5.3.1) "The {content type} of the complex type itself must
16471: * be empty"
16472: */
16473: if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
16474: /*
16475: * SPEC (5.3.2.1) "The {content type} of the {base type
16476: * definition} must also be empty."
16477: * PASS
16478: */
16479: } else if (((base->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
16480: (base->contentType == XML_SCHEMA_CONTENT_MIXED)) &&
16481: xmlSchemaIsParticleEmptiable(
16482: (xmlSchemaParticlePtr) base->subtypes)) {
16483: /*
16484: * SPEC (5.3.2.2) "The {content type} of the {base type
16485: * definition} must be elementOnly or mixed and have a particle
16486: * which is �emptiable� as defined in Particle Emptiable (�3.9.6)."
16487: * PASS
16488: */
16489: } else {
16490: xmlSchemaPCustomErr(ctxt,
16491: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16492: WXS_BASIC_CAST type, NULL,
16493: "The content type of the base type must be either "
16494: "empty or 'mixed' (or 'elements-only') and an emptiable "
16495: "particle", NULL);
16496: return (ctxt->err);
16497: }
16498: } else if ((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
16499: WXS_HAS_MIXED_CONTENT(type)) {
16500: /*
16501: * SPEC (5.4.1.1) "The {content type} of the complex type definition
16502: * itself must be element-only"
16503: */
16504: if (WXS_HAS_MIXED_CONTENT(type) && (! WXS_HAS_MIXED_CONTENT(base))) {
16505: /*
16506: * SPEC (5.4.1.2) "The {content type} of the complex type
16507: * definition itself and of the {base type definition} must be
16508: * mixed"
16509: */
16510: xmlSchemaPCustomErr(ctxt,
16511: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16512: WXS_BASIC_CAST type, NULL,
16513: "If the content type is 'mixed', then the content type of the "
16514: "base type must also be 'mixed'", NULL);
16515: return (ctxt->err);
16516: }
16517: /*
16518: * SPEC (5.4.2) "The particle of the complex type definition itself
16519: * must be a �valid restriction� of the particle of the {content
16520: * type} of the {base type definition} as defined in Particle Valid
16521: * (Restriction) (�3.9.6).
16522: *
16523: * URGENT TODO: (5.4.2)
16524: */
16525: } else {
16526: xmlSchemaPCustomErr(ctxt,
16527: XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
16528: WXS_BASIC_CAST type, NULL,
16529: "The type is not a valid restriction of its base type", NULL);
16530: return (ctxt->err);
16531: }
16532: return (0);
16533: }
16534:
16535: /**
16536: * xmlSchemaCheckCTComponent:
16537: * @ctxt: the schema parser context
16538: * @type: the complex type definition
16539: *
16540: * (3.4.6) Constraints on Complex Type Definition Schema Components
16541: *
16542: * Returns 0 if the constraints are satisfied, a positive
16543: * error code if not and -1 if an internal error occured.
16544: */
16545: static int
16546: xmlSchemaCheckCTComponent(xmlSchemaParserCtxtPtr ctxt,
16547: xmlSchemaTypePtr type)
16548: {
16549: int ret;
16550: /*
16551: * Complex Type Definition Properties Correct
16552: */
16553: ret = xmlSchemaCheckCTPropsCorrect(ctxt, type);
16554: if (ret != 0)
16555: return (ret);
16556: if (WXS_IS_EXTENSION(type))
16557: ret = xmlSchemaCheckCOSCTExtends(ctxt, type);
16558: else
16559: ret = xmlSchemaCheckDerivationOKRestriction(ctxt, type);
16560: return (ret);
16561: }
16562:
16563: /**
16564: * xmlSchemaCheckSRCCT:
16565: * @ctxt: the schema parser context
16566: * @type: the complex type definition
16567: *
16568: * (3.4.3) Constraints on XML Representations of Complex Type Definitions:
16569: * Schema Representation Constraint:
16570: * Complex Type Definition Representation OK (src-ct)
16571: *
16572: * Returns 0 if the constraints are satisfied, a positive
16573: * error code if not and -1 if an internal error occured.
16574: */
16575: static int
16576: xmlSchemaCheckSRCCT(xmlSchemaParserCtxtPtr ctxt,
16577: xmlSchemaTypePtr type)
16578: {
16579: xmlSchemaTypePtr base;
16580: int ret = 0;
16581:
16582: /*
16583: * TODO: Adjust the error codes here, as I used
16584: * XML_SCHEMAP_SRC_CT_1 only yet.
16585: */
16586: base = type->baseType;
16587: if (! WXS_HAS_SIMPLE_CONTENT(type)) {
16588: /*
16589: * 1 If the <complexContent> alternative is chosen, the type definition
16590: * �resolved� to by the �actual value� of the base [attribute]
16591: * must be a complex type definition;
16592: */
16593: if (! WXS_IS_COMPLEX(base)) {
16594: xmlChar *str = NULL;
16595: xmlSchemaPCustomErr(ctxt,
16596: XML_SCHEMAP_SRC_CT_1,
16597: WXS_BASIC_CAST type, type->node,
16598: "If using <complexContent>, the base type is expected to be "
16599: "a complex type. The base type '%s' is a simple type",
16600: xmlSchemaFormatQName(&str, base->targetNamespace,
16601: base->name));
16602: FREE_AND_NULL(str)
16603: return (XML_SCHEMAP_SRC_CT_1);
16604: }
16605: } else {
16606: /*
16607: * SPEC
16608: * 2 If the <simpleContent> alternative is chosen, all of the
16609: * following must be true:
16610: * 2.1 The type definition �resolved� to by the �actual value� of the
16611: * base [attribute] must be one of the following:
16612: */
16613: if (WXS_IS_SIMPLE(base)) {
16614: if (WXS_IS_EXTENSION(type) == 0) {
16615: xmlChar *str = NULL;
16616: /*
16617: * 2.1.3 only if the <extension> alternative is also
16618: * chosen, a simple type definition.
16619: */
16620: /* TODO: Change error code to ..._SRC_CT_2_1_3. */
16621: xmlSchemaPCustomErr(ctxt,
16622: XML_SCHEMAP_SRC_CT_1,
16623: WXS_BASIC_CAST type, NULL,
16624: "If using <simpleContent> and <restriction>, the base "
16625: "type must be a complex type. The base type '%s' is "
16626: "a simple type",
16627: xmlSchemaFormatQName(&str, base->targetNamespace,
16628: base->name));
16629: FREE_AND_NULL(str)
16630: return (XML_SCHEMAP_SRC_CT_1);
16631: }
16632: } else {
16633: /* Base type is a complex type. */
16634: if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
16635: (base->contentType == XML_SCHEMA_CONTENT_BASIC)) {
16636: /*
16637: * 2.1.1 a complex type definition whose {content type} is a
16638: * simple type definition;
16639: * PASS
16640: */
16641: if (base->contentTypeDef == NULL) {
16642: xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_INTERNAL,
16643: WXS_BASIC_CAST type, NULL,
16644: "Internal error: xmlSchemaCheckSRCCT, "
16645: "'%s', base type has no content type",
16646: type->name);
16647: return (-1);
16648: }
16649: } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
16650: (WXS_IS_RESTRICTION(type))) {
16651:
16652: /*
16653: * 2.1.2 only if the <restriction> alternative is also
16654: * chosen, a complex type definition whose {content type}
16655: * is mixed and a particle emptiable.
16656: */
16657: if (! xmlSchemaIsParticleEmptiable(
16658: (xmlSchemaParticlePtr) base->subtypes)) {
16659: ret = XML_SCHEMAP_SRC_CT_1;
16660: } else
16661: /*
16662: * Attention: at this point the <simpleType> child is in
16663: * ->contentTypeDef (put there during parsing).
16664: */
16665: if (type->contentTypeDef == NULL) {
16666: xmlChar *str = NULL;
16667: /*
16668: * 2.2 If clause 2.1.2 above is satisfied, then there
16669: * must be a <simpleType> among the [children] of
16670: * <restriction>.
16671: */
16672: /* TODO: Change error code to ..._SRC_CT_2_2. */
16673: xmlSchemaPCustomErr(ctxt,
16674: XML_SCHEMAP_SRC_CT_1,
16675: WXS_BASIC_CAST type, NULL,
16676: "A <simpleType> is expected among the children "
16677: "of <restriction>, if <simpleContent> is used and "
16678: "the base type '%s' is a complex type",
16679: xmlSchemaFormatQName(&str, base->targetNamespace,
16680: base->name));
16681: FREE_AND_NULL(str)
16682: return (XML_SCHEMAP_SRC_CT_1);
16683: }
16684: } else {
16685: ret = XML_SCHEMAP_SRC_CT_1;
16686: }
16687: }
16688: if (ret > 0) {
16689: xmlChar *str = NULL;
16690: if (WXS_IS_RESTRICTION(type)) {
16691: xmlSchemaPCustomErr(ctxt,
16692: XML_SCHEMAP_SRC_CT_1,
16693: WXS_BASIC_CAST type, NULL,
16694: "If <simpleContent> and <restriction> is used, the "
16695: "base type must be a simple type or a complex type with "
16696: "mixed content and particle emptiable. The base type "
16697: "'%s' is none of those",
16698: xmlSchemaFormatQName(&str, base->targetNamespace,
16699: base->name));
16700: } else {
16701: xmlSchemaPCustomErr(ctxt,
16702: XML_SCHEMAP_SRC_CT_1,
16703: WXS_BASIC_CAST type, NULL,
16704: "If <simpleContent> and <extension> is used, the "
16705: "base type must be a simple type. The base type '%s' "
16706: "is a complex type",
16707: xmlSchemaFormatQName(&str, base->targetNamespace,
16708: base->name));
16709: }
16710: FREE_AND_NULL(str)
16711: }
16712: }
16713: /*
16714: * SPEC (3) "The corresponding complex type definition component must
16715: * satisfy the conditions set out in Constraints on Complex Type
16716: * Definition Schema Components (�3.4.6);"
16717: * NOTE (3) will be done in xmlSchemaTypeFixup().
16718: */
16719: /*
16720: * SPEC (4) If clause 2.2.1 or clause 2.2.2 in the correspondence specification
16721: * above for {attribute wildcard} is satisfied, the intensional
16722: * intersection must be expressible, as defined in Attribute Wildcard
16723: * Intersection (�3.10.6).
16724: * NOTE (4) is done in xmlSchemaFixupTypeAttributeUses().
16725: */
16726: return (ret);
16727: }
16728:
16729: #ifdef ENABLE_PARTICLE_RESTRICTION
16730: /**
16731: * xmlSchemaCheckParticleRangeOK:
16732: * @ctxt: the schema parser context
16733: * @type: the complex type definition
16734: *
16735: * (3.9.6) Constraints on Particle Schema Components
16736: * Schema Component Constraint:
16737: * Occurrence Range OK (range-ok)
16738: *
16739: * STATUS: complete
16740: *
16741: * Returns 0 if the constraints are satisfied, a positive
16742: * error code if not and -1 if an internal error occured.
16743: */
16744: static int
16745: xmlSchemaCheckParticleRangeOK(int rmin, int rmax,
16746: int bmin, int bmax)
16747: {
16748: if (rmin < bmin)
16749: return (1);
16750: if ((bmax != UNBOUNDED) &&
16751: (rmax > bmax))
16752: return (1);
16753: return (0);
16754: }
16755:
16756: /**
16757: * xmlSchemaCheckRCaseNameAndTypeOK:
16758: * @ctxt: the schema parser context
16759: * @r: the restricting element declaration particle
16760: * @b: the base element declaration particle
16761: *
16762: * (3.9.6) Constraints on Particle Schema Components
16763: * Schema Component Constraint:
16764: * Particle Restriction OK (Elt:Elt -- NameAndTypeOK)
16765: * (rcase-NameAndTypeOK)
16766: *
16767: * STATUS:
16768: * MISSING (3.2.3)
16769: * CLARIFY: (3.2.2)
16770: *
16771: * Returns 0 if the constraints are satisfied, a positive
16772: * error code if not and -1 if an internal error occured.
16773: */
16774: static int
16775: xmlSchemaCheckRCaseNameAndTypeOK(xmlSchemaParserCtxtPtr ctxt,
16776: xmlSchemaParticlePtr r,
16777: xmlSchemaParticlePtr b)
16778: {
16779: xmlSchemaElementPtr elemR, elemB;
16780:
16781: /* TODO: Error codes (rcase-NameAndTypeOK). */
16782: elemR = (xmlSchemaElementPtr) r->children;
16783: elemB = (xmlSchemaElementPtr) b->children;
16784: /*
16785: * SPEC (1) "The declarations' {name}s and {target namespace}s are
16786: * the same."
16787: */
16788: if ((elemR != elemB) &&
16789: ((! xmlStrEqual(elemR->name, elemB->name)) ||
16790: (! xmlStrEqual(elemR->targetNamespace, elemB->targetNamespace))))
16791: return (1);
16792: /*
16793: * SPEC (2) "R's occurrence range is a valid restriction of B's
16794: * occurrence range as defined by Occurrence Range OK (�3.9.6)."
16795: */
16796: if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
16797: b->minOccurs, b->maxOccurs) != 0)
16798: return (1);
16799: /*
16800: * SPEC (3.1) "Both B's declaration's {scope} and R's declaration's
16801: * {scope} are global."
16802: */
16803: if (elemR == elemB)
16804: return (0);
16805: /*
16806: * SPEC (3.2.1) "Either B's {nillable} is true or R's {nillable} is false."
16807: */
16808: if (((elemB->flags & XML_SCHEMAS_ELEM_NILLABLE) == 0) &&
16809: (elemR->flags & XML_SCHEMAS_ELEM_NILLABLE))
16810: return (1);
16811: /*
16812: * SPEC (3.2.2) "either B's declaration's {value constraint} is absent,
16813: * or is not fixed, or R's declaration's {value constraint} is fixed
16814: * with the same value."
16815: */
16816: if ((elemB->value != NULL) && (elemB->flags & XML_SCHEMAS_ELEM_FIXED) &&
16817: ((elemR->value == NULL) ||
16818: ((elemR->flags & XML_SCHEMAS_ELEM_FIXED) == 0) ||
16819: /* TODO: Equality of the initial value or normalized or canonical? */
16820: (! xmlStrEqual(elemR->value, elemB->value))))
16821: return (1);
16822: /*
16823: * TODO: SPEC (3.2.3) "R's declaration's {identity-constraint
16824: * definitions} is a subset of B's declaration's {identity-constraint
16825: * definitions}, if any."
16826: */
16827: if (elemB->idcs != NULL) {
16828: /* TODO */
16829: }
16830: /*
16831: * SPEC (3.2.4) "R's declaration's {disallowed substitutions} is a
16832: * superset of B's declaration's {disallowed substitutions}."
16833: */
16834: if (((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) &&
16835: ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) == 0)) ||
16836: ((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) &&
16837: ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) == 0)) ||
16838: ((elemB->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION) &&
16839: ((elemR->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION) == 0)))
16840: return (1);
16841: /*
16842: * SPEC (3.2.5) "R's {type definition} is validly derived given
16843: * {extension, list, union} from B's {type definition}"
16844: *
16845: * BADSPEC TODO: What's the point of adding "list" and "union" to the
16846: * set, if the corresponding constraints handle "restriction" and
16847: * "extension" only?
16848: *
16849: */
16850: {
16851: int set = 0;
16852:
16853: set |= SUBSET_EXTENSION;
16854: set |= SUBSET_LIST;
16855: set |= SUBSET_UNION;
16856: if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST ctxt, elemR->subtypes,
16857: elemB->subtypes, set) != 0)
16858: return (1);
16859: }
16860: return (0);
16861: }
16862:
16863: /**
16864: * xmlSchemaCheckRCaseNSCompat:
16865: * @ctxt: the schema parser context
16866: * @r: the restricting element declaration particle
16867: * @b: the base wildcard particle
16868: *
16869: * (3.9.6) Constraints on Particle Schema Components
16870: * Schema Component Constraint:
16871: * Particle Derivation OK (Elt:Any -- NSCompat)
16872: * (rcase-NSCompat)
16873: *
16874: * STATUS: complete
16875: *
16876: * Returns 0 if the constraints are satisfied, a positive
16877: * error code if not and -1 if an internal error occured.
16878: */
16879: static int
16880: xmlSchemaCheckRCaseNSCompat(xmlSchemaParserCtxtPtr ctxt,
16881: xmlSchemaParticlePtr r,
16882: xmlSchemaParticlePtr b)
16883: {
16884: /* TODO:Error codes (rcase-NSCompat). */
16885: /*
16886: * SPEC "For an element declaration particle to be a �valid restriction�
16887: * of a wildcard particle all of the following must be true:"
16888: *
16889: * SPEC (1) "The element declaration's {target namespace} is �valid�
16890: * with respect to the wildcard's {namespace constraint} as defined by
16891: * Wildcard allows Namespace Name (�3.10.4)."
16892: */
16893: if (xmlSchemaCheckCVCWildcardNamespace((xmlSchemaWildcardPtr) b->children,
16894: ((xmlSchemaElementPtr) r->children)->targetNamespace) != 0)
16895: return (1);
16896: /*
16897: * SPEC (2) "R's occurrence range is a valid restriction of B's
16898: * occurrence range as defined by Occurrence Range OK (�3.9.6)."
16899: */
16900: if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
16901: b->minOccurs, b->maxOccurs) != 0)
16902: return (1);
16903:
16904: return (0);
16905: }
16906:
16907: /**
16908: * xmlSchemaCheckRCaseRecurseAsIfGroup:
16909: * @ctxt: the schema parser context
16910: * @r: the restricting element declaration particle
16911: * @b: the base model group particle
16912: *
16913: * (3.9.6) Constraints on Particle Schema Components
16914: * Schema Component Constraint:
16915: * Particle Derivation OK (Elt:All/Choice/Sequence -- RecurseAsIfGroup)
16916: * (rcase-RecurseAsIfGroup)
16917: *
16918: * STATUS: TODO
16919: *
16920: * Returns 0 if the constraints are satisfied, a positive
16921: * error code if not and -1 if an internal error occured.
16922: */
16923: static int
16924: xmlSchemaCheckRCaseRecurseAsIfGroup(xmlSchemaParserCtxtPtr ctxt,
16925: xmlSchemaParticlePtr r,
16926: xmlSchemaParticlePtr b)
16927: {
16928: /* TODO: Error codes (rcase-RecurseAsIfGroup). */
16929: TODO
16930: return (0);
16931: }
16932:
16933: /**
16934: * xmlSchemaCheckRCaseNSSubset:
16935: * @ctxt: the schema parser context
16936: * @r: the restricting wildcard particle
16937: * @b: the base wildcard particle
16938: *
16939: * (3.9.6) Constraints on Particle Schema Components
16940: * Schema Component Constraint:
16941: * Particle Derivation OK (Any:Any -- NSSubset)
16942: * (rcase-NSSubset)
16943: *
16944: * STATUS: complete
16945: *
16946: * Returns 0 if the constraints are satisfied, a positive
16947: * error code if not and -1 if an internal error occured.
16948: */
16949: static int
16950: xmlSchemaCheckRCaseNSSubset(xmlSchemaParserCtxtPtr ctxt,
16951: xmlSchemaParticlePtr r,
16952: xmlSchemaParticlePtr b,
16953: int isAnyTypeBase)
16954: {
16955: /* TODO: Error codes (rcase-NSSubset). */
16956: /*
16957: * SPEC (1) "R's occurrence range is a valid restriction of B's
16958: * occurrence range as defined by Occurrence Range OK (�3.9.6)."
16959: */
16960: if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
16961: b->minOccurs, b->maxOccurs))
16962: return (1);
16963: /*
16964: * SPEC (2) "R's {namespace constraint} must be an intensional subset
16965: * of B's {namespace constraint} as defined by Wildcard Subset (�3.10.6)."
16966: */
16967: if (xmlSchemaCheckCOSNSSubset((xmlSchemaWildcardPtr) r->children,
16968: (xmlSchemaWildcardPtr) b->children))
16969: return (1);
16970: /*
16971: * SPEC (3) "Unless B is the content model wildcard of the �ur-type
16972: * definition�, R's {process contents} must be identical to or stronger
16973: * than B's {process contents}, where strict is stronger than lax is
16974: * stronger than skip."
16975: */
16976: if (! isAnyTypeBase) {
16977: if ( ((xmlSchemaWildcardPtr) r->children)->processContents <
16978: ((xmlSchemaWildcardPtr) b->children)->processContents)
16979: return (1);
16980: }
16981:
16982: return (0);
16983: }
16984:
16985: /**
16986: * xmlSchemaCheckCOSParticleRestrict:
16987: * @ctxt: the schema parser context
16988: * @type: the complex type definition
16989: *
16990: * (3.9.6) Constraints on Particle Schema Components
16991: * Schema Component Constraint:
16992: * Particle Valid (Restriction) (cos-particle-restrict)
16993: *
16994: * STATUS: TODO
16995: *
16996: * Returns 0 if the constraints are satisfied, a positive
16997: * error code if not and -1 if an internal error occured.
16998: */
16999: static int
17000: xmlSchemaCheckCOSParticleRestrict(xmlSchemaParserCtxtPtr ctxt,
17001: xmlSchemaParticlePtr r,
17002: xmlSchemaParticlePtr b)
17003: {
17004: int ret = 0;
17005:
17006: /*part = WXS_TYPE_PARTICLE(type);
17007: basePart = WXS_TYPE_PARTICLE(base);
17008: */
17009:
17010: TODO
17011:
17012: /*
17013: * SPEC (1) "They are the same particle."
17014: */
17015: if (r == b)
17016: return (0);
17017:
17018:
17019: return (0);
17020: }
17021:
17022: #if 0
17023: /**
17024: * xmlSchemaCheckRCaseNSRecurseCheckCardinality:
17025: * @ctxt: the schema parser context
17026: * @r: the model group particle
17027: * @b: the base wildcard particle
17028: *
17029: * (3.9.6) Constraints on Particle Schema Components
17030: * Schema Component Constraint:
17031: * Particle Derivation OK (All/Choice/Sequence:Any --
17032: * NSRecurseCheckCardinality)
17033: * (rcase-NSRecurseCheckCardinality)
17034: *
17035: * STATUS: TODO: subst-groups
17036: *
17037: * Returns 0 if the constraints are satisfied, a positive
17038: * error code if not and -1 if an internal error occured.
17039: */
17040: static int
17041: xmlSchemaCheckRCaseNSRecurseCheckCardinality(xmlSchemaParserCtxtPtr ctxt,
17042: xmlSchemaParticlePtr r,
17043: xmlSchemaParticlePtr b)
17044: {
17045: xmlSchemaParticlePtr part;
17046: /* TODO: Error codes (rcase-NSRecurseCheckCardinality). */
17047: if ((r->children == NULL) || (r->children->children == NULL))
17048: return (-1);
17049: /*
17050: * SPEC "For a group particle to be a �valid restriction� of a
17051: * wildcard particle..."
17052: *
17053: * SPEC (1) "Every member of the {particles} of the group is a �valid
17054: * restriction� of the wildcard as defined by
17055: * Particle Valid (Restriction) (�3.9.6)."
17056: */
17057: part = (xmlSchemaParticlePtr) r->children->children;
17058: do {
17059: if (xmlSchemaCheckCOSParticleRestrict(ctxt, part, b))
17060: return (1);
17061: part = (xmlSchemaParticlePtr) part->next;
17062: } while (part != NULL);
17063: /*
17064: * SPEC (2) "The effective total range of the group [...] is a
17065: * valid restriction of B's occurrence range as defined by
17066: * Occurrence Range OK (�3.9.6)."
17067: */
17068: if (xmlSchemaCheckParticleRangeOK(
17069: xmlSchemaGetParticleTotalRangeMin(r),
17070: xmlSchemaGetParticleTotalRangeMax(r),
17071: b->minOccurs, b->maxOccurs) != 0)
17072: return (1);
17073: return (0);
17074: }
17075: #endif
17076:
17077: /**
17078: * xmlSchemaCheckRCaseRecurse:
17079: * @ctxt: the schema parser context
17080: * @r: the <all> or <sequence> model group particle
17081: * @b: the base <all> or <sequence> model group particle
17082: *
17083: * (3.9.6) Constraints on Particle Schema Components
17084: * Schema Component Constraint:
17085: * Particle Derivation OK (All:All,Sequence:Sequence --
17086: Recurse)
17087: * (rcase-Recurse)
17088: *
17089: * STATUS: ?
17090: * TODO: subst-groups
17091: *
17092: * Returns 0 if the constraints are satisfied, a positive
17093: * error code if not and -1 if an internal error occured.
17094: */
17095: static int
17096: xmlSchemaCheckRCaseRecurse(xmlSchemaParserCtxtPtr ctxt,
17097: xmlSchemaParticlePtr r,
17098: xmlSchemaParticlePtr b)
17099: {
17100: /* xmlSchemaParticlePtr part; */
17101: /* TODO: Error codes (rcase-Recurse). */
17102: if ((r->children == NULL) || (b->children == NULL) ||
17103: (r->children->type != b->children->type))
17104: return (-1);
17105: /*
17106: * SPEC "For an all or sequence group particle to be a �valid
17107: * restriction� of another group particle with the same {compositor}..."
17108: *
17109: * SPEC (1) "R's occurrence range is a valid restriction of B's
17110: * occurrence range as defined by Occurrence Range OK (�3.9.6)."
17111: */
17112: if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
17113: b->minOccurs, b->maxOccurs))
17114: return (1);
17115:
17116:
17117: return (0);
17118: }
17119:
17120: #endif
17121:
17122: #define FACET_RESTR_MUTUAL_ERR(fac1, fac2) \
17123: xmlSchemaPCustomErrExt(pctxt, \
17124: XML_SCHEMAP_INVALID_FACET_VALUE, \
17125: WXS_BASIC_CAST fac1, fac1->node, \
17126: "It is an error for both '%s' and '%s' to be specified on the "\
17127: "same type definition", \
17128: BAD_CAST xmlSchemaFacetTypeToString(fac1->type), \
17129: BAD_CAST xmlSchemaFacetTypeToString(fac2->type), NULL);
17130:
17131: #define FACET_RESTR_ERR(fac1, msg) \
17132: xmlSchemaPCustomErr(pctxt, \
17133: XML_SCHEMAP_INVALID_FACET_VALUE, \
17134: WXS_BASIC_CAST fac1, fac1->node, \
17135: msg, NULL);
17136:
17137: #define FACET_RESTR_FIXED_ERR(fac) \
17138: xmlSchemaPCustomErr(pctxt, \
17139: XML_SCHEMAP_INVALID_FACET_VALUE, \
17140: WXS_BASIC_CAST fac, fac->node, \
17141: "The base type's facet is 'fixed', thus the value must not " \
17142: "differ", NULL);
17143:
17144: static void
17145: xmlSchemaDeriveFacetErr(xmlSchemaParserCtxtPtr pctxt,
17146: xmlSchemaFacetPtr facet1,
17147: xmlSchemaFacetPtr facet2,
17148: int lessGreater,
17149: int orEqual,
17150: int ofBase)
17151: {
17152: xmlChar *msg = NULL;
17153:
17154: msg = xmlStrdup(BAD_CAST "'");
17155: msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facet1->type));
17156: msg = xmlStrcat(msg, BAD_CAST "' has to be");
17157: if (lessGreater == 0)
17158: msg = xmlStrcat(msg, BAD_CAST " equal to");
17159: if (lessGreater == 1)
17160: msg = xmlStrcat(msg, BAD_CAST " greater than");
17161: else
17162: msg = xmlStrcat(msg, BAD_CAST " less than");
17163:
17164: if (orEqual)
17165: msg = xmlStrcat(msg, BAD_CAST " or equal to");
17166: msg = xmlStrcat(msg, BAD_CAST " '");
17167: msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facet2->type));
17168: if (ofBase)
17169: msg = xmlStrcat(msg, BAD_CAST "' of the base type");
17170: else
17171: msg = xmlStrcat(msg, BAD_CAST "'");
17172:
17173: xmlSchemaPCustomErr(pctxt,
17174: XML_SCHEMAP_INVALID_FACET_VALUE,
17175: WXS_BASIC_CAST facet1, NULL,
17176: (const char *) msg, NULL);
17177:
17178: if (msg != NULL)
17179: xmlFree(msg);
17180: }
17181:
17182: /*
17183: * xmlSchemaDeriveAndValidateFacets:
17184: *
17185: * Schema Component Constraint: Simple Type Restriction (Facets)
17186: * (st-restrict-facets)
17187: */
17188: static int
17189: xmlSchemaDeriveAndValidateFacets(xmlSchemaParserCtxtPtr pctxt,
17190: xmlSchemaTypePtr type)
17191: {
17192: xmlSchemaTypePtr base = type->baseType;
17193: xmlSchemaFacetLinkPtr link, cur, last = NULL;
17194: xmlSchemaFacetPtr facet, bfacet,
17195: flength = NULL, ftotdig = NULL, ffracdig = NULL,
17196: fmaxlen = NULL, fminlen = NULL, /* facets of the current type */
17197: fmininc = NULL, fmaxinc = NULL,
17198: fminexc = NULL, fmaxexc = NULL,
17199: bflength = NULL, bftotdig = NULL, bffracdig = NULL,
17200: bfmaxlen = NULL, bfminlen = NULL, /* facets of the base type */
17201: bfmininc = NULL, bfmaxinc = NULL,
17202: bfminexc = NULL, bfmaxexc = NULL;
17203: int res; /* err = 0, fixedErr; */
17204:
17205: /*
17206: * SPEC st-restrict-facets 1:
17207: * "The {variety} of R is the same as that of B."
17208: */
17209: /*
17210: * SPEC st-restrict-facets 2:
17211: * "If {variety} is atomic, the {primitive type definition}
17212: * of R is the same as that of B."
17213: *
17214: * NOTE: we leave 1 & 2 out for now, since this will be
17215: * satisfied by the derivation process.
17216: * CONSTRUCTION TODO: Maybe needed if using a construction API.
17217: */
17218: /*
17219: * SPEC st-restrict-facets 3:
17220: * "The {facets} of R are the union of S and the {facets}
17221: * of B, eliminating duplicates. To eliminate duplicates,
17222: * when a facet of the same kind occurs in both S and the
17223: * {facets} of B, the one in the {facets} of B is not
17224: * included, with the exception of enumeration and pattern
17225: * facets, for which multiple occurrences with distinct values
17226: * are allowed."
17227: */
17228:
17229: if ((type->facetSet == NULL) && (base->facetSet == NULL))
17230: return (0);
17231:
17232: last = type->facetSet;
17233: if (last != NULL)
17234: while (last->next != NULL)
17235: last = last->next;
17236:
17237: for (cur = type->facetSet; cur != NULL; cur = cur->next) {
17238: facet = cur->facet;
17239: switch (facet->type) {
17240: case XML_SCHEMA_FACET_LENGTH:
17241: flength = facet; break;
17242: case XML_SCHEMA_FACET_MINLENGTH:
17243: fminlen = facet; break;
17244: case XML_SCHEMA_FACET_MININCLUSIVE:
17245: fmininc = facet; break;
17246: case XML_SCHEMA_FACET_MINEXCLUSIVE:
17247: fminexc = facet; break;
17248: case XML_SCHEMA_FACET_MAXLENGTH:
17249: fmaxlen = facet; break;
17250: case XML_SCHEMA_FACET_MAXINCLUSIVE:
17251: fmaxinc = facet; break;
17252: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
17253: fmaxexc = facet; break;
17254: case XML_SCHEMA_FACET_TOTALDIGITS:
17255: ftotdig = facet; break;
17256: case XML_SCHEMA_FACET_FRACTIONDIGITS:
17257: ffracdig = facet; break;
17258: default:
17259: break;
17260: }
17261: }
17262: for (cur = base->facetSet; cur != NULL; cur = cur->next) {
17263: facet = cur->facet;
17264: switch (facet->type) {
17265: case XML_SCHEMA_FACET_LENGTH:
17266: bflength = facet; break;
17267: case XML_SCHEMA_FACET_MINLENGTH:
17268: bfminlen = facet; break;
17269: case XML_SCHEMA_FACET_MININCLUSIVE:
17270: bfmininc = facet; break;
17271: case XML_SCHEMA_FACET_MINEXCLUSIVE:
17272: bfminexc = facet; break;
17273: case XML_SCHEMA_FACET_MAXLENGTH:
17274: bfmaxlen = facet; break;
17275: case XML_SCHEMA_FACET_MAXINCLUSIVE:
17276: bfmaxinc = facet; break;
17277: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
17278: bfmaxexc = facet; break;
17279: case XML_SCHEMA_FACET_TOTALDIGITS:
17280: bftotdig = facet; break;
17281: case XML_SCHEMA_FACET_FRACTIONDIGITS:
17282: bffracdig = facet; break;
17283: default:
17284: break;
17285: }
17286: }
17287: /*
17288: * length and minLength or maxLength (2.2) + (3.2)
17289: */
17290: if (flength && (fminlen || fmaxlen)) {
17291: FACET_RESTR_ERR(flength, "It is an error for both 'length' and "
17292: "either of 'minLength' or 'maxLength' to be specified on "
17293: "the same type definition")
17294: }
17295: /*
17296: * Mutual exclusions in the same derivation step.
17297: */
17298: if ((fmaxinc) && (fmaxexc)) {
17299: /*
17300: * SCC "maxInclusive and maxExclusive"
17301: */
17302: FACET_RESTR_MUTUAL_ERR(fmaxinc, fmaxexc)
17303: }
17304: if ((fmininc) && (fminexc)) {
17305: /*
17306: * SCC "minInclusive and minExclusive"
17307: */
17308: FACET_RESTR_MUTUAL_ERR(fmininc, fminexc)
17309: }
17310:
17311: if (flength && bflength) {
17312: /*
17313: * SCC "length valid restriction"
17314: * The values have to be equal.
17315: */
17316: res = xmlSchemaCompareValues(flength->val, bflength->val);
17317: if (res == -2)
17318: goto internal_error;
17319: if (res != 0)
17320: xmlSchemaDeriveFacetErr(pctxt, flength, bflength, 0, 0, 1);
17321: if ((res != 0) && (bflength->fixed)) {
17322: FACET_RESTR_FIXED_ERR(flength)
17323: }
17324:
17325: }
17326: if (fminlen && bfminlen) {
17327: /*
17328: * SCC "minLength valid restriction"
17329: * minLength >= BASE minLength
17330: */
17331: res = xmlSchemaCompareValues(fminlen->val, bfminlen->val);
17332: if (res == -2)
17333: goto internal_error;
17334: if (res == -1)
17335: xmlSchemaDeriveFacetErr(pctxt, fminlen, bfminlen, 1, 1, 1);
17336: if ((res != 0) && (bfminlen->fixed)) {
17337: FACET_RESTR_FIXED_ERR(fminlen)
17338: }
17339: }
17340: if (fmaxlen && bfmaxlen) {
17341: /*
17342: * SCC "maxLength valid restriction"
17343: * maxLength <= BASE minLength
17344: */
17345: res = xmlSchemaCompareValues(fmaxlen->val, bfmaxlen->val);
17346: if (res == -2)
17347: goto internal_error;
17348: if (res == 1)
17349: xmlSchemaDeriveFacetErr(pctxt, fmaxlen, bfmaxlen, -1, 1, 1);
17350: if ((res != 0) && (bfmaxlen->fixed)) {
17351: FACET_RESTR_FIXED_ERR(fmaxlen)
17352: }
17353: }
17354: /*
17355: * SCC "length and minLength or maxLength"
17356: */
17357: if (! flength)
17358: flength = bflength;
17359: if (flength) {
17360: if (! fminlen)
17361: fminlen = bfminlen;
17362: if (fminlen) {
17363: /* (1.1) length >= minLength */
17364: res = xmlSchemaCompareValues(flength->val, fminlen->val);
17365: if (res == -2)
17366: goto internal_error;
17367: if (res == -1)
17368: xmlSchemaDeriveFacetErr(pctxt, flength, fminlen, 1, 1, 0);
17369: }
17370: if (! fmaxlen)
17371: fmaxlen = bfmaxlen;
17372: if (fmaxlen) {
17373: /* (2.1) length <= maxLength */
17374: res = xmlSchemaCompareValues(flength->val, fmaxlen->val);
17375: if (res == -2)
17376: goto internal_error;
17377: if (res == 1)
17378: xmlSchemaDeriveFacetErr(pctxt, flength, fmaxlen, -1, 1, 0);
17379: }
17380: }
17381: if (fmaxinc) {
17382: /*
17383: * "maxInclusive"
17384: */
17385: if (fmininc) {
17386: /* SCC "maxInclusive >= minInclusive" */
17387: res = xmlSchemaCompareValues(fmaxinc->val, fmininc->val);
17388: if (res == -2)
17389: goto internal_error;
17390: if (res == -1) {
17391: xmlSchemaDeriveFacetErr(pctxt, fmaxinc, fmininc, 1, 1, 0);
17392: }
17393: }
17394: /*
17395: * SCC "maxInclusive valid restriction"
17396: */
17397: if (bfmaxinc) {
17398: /* maxInclusive <= BASE maxInclusive */
17399: res = xmlSchemaCompareValues(fmaxinc->val, bfmaxinc->val);
17400: if (res == -2)
17401: goto internal_error;
17402: if (res == 1)
17403: xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmaxinc, -1, 1, 1);
17404: if ((res != 0) && (bfmaxinc->fixed)) {
17405: FACET_RESTR_FIXED_ERR(fmaxinc)
17406: }
17407: }
17408: if (bfmaxexc) {
17409: /* maxInclusive < BASE maxExclusive */
17410: res = xmlSchemaCompareValues(fmaxinc->val, bfmaxexc->val);
17411: if (res == -2)
17412: goto internal_error;
17413: if (res != -1) {
17414: xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmaxexc, -1, 0, 1);
17415: }
17416: }
17417: if (bfmininc) {
17418: /* maxInclusive >= BASE minInclusive */
17419: res = xmlSchemaCompareValues(fmaxinc->val, bfmininc->val);
17420: if (res == -2)
17421: goto internal_error;
17422: if (res == -1) {
17423: xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfmininc, 1, 1, 1);
17424: }
17425: }
17426: if (bfminexc) {
17427: /* maxInclusive > BASE minExclusive */
17428: res = xmlSchemaCompareValues(fmaxinc->val, bfminexc->val);
17429: if (res == -2)
17430: goto internal_error;
17431: if (res != 1) {
17432: xmlSchemaDeriveFacetErr(pctxt, fmaxinc, bfminexc, 1, 0, 1);
17433: }
17434: }
17435: }
17436: if (fmaxexc) {
17437: /*
17438: * "maxExclusive >= minExclusive"
17439: */
17440: if (fminexc) {
17441: res = xmlSchemaCompareValues(fmaxexc->val, fminexc->val);
17442: if (res == -2)
17443: goto internal_error;
17444: if (res == -1) {
17445: xmlSchemaDeriveFacetErr(pctxt, fmaxexc, fminexc, 1, 1, 0);
17446: }
17447: }
17448: /*
17449: * "maxExclusive valid restriction"
17450: */
17451: if (bfmaxexc) {
17452: /* maxExclusive <= BASE maxExclusive */
17453: res = xmlSchemaCompareValues(fmaxexc->val, bfmaxexc->val);
17454: if (res == -2)
17455: goto internal_error;
17456: if (res == 1) {
17457: xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmaxexc, -1, 1, 1);
17458: }
17459: if ((res != 0) && (bfmaxexc->fixed)) {
17460: FACET_RESTR_FIXED_ERR(fmaxexc)
17461: }
17462: }
17463: if (bfmaxinc) {
17464: /* maxExclusive <= BASE maxInclusive */
17465: res = xmlSchemaCompareValues(fmaxexc->val, bfmaxinc->val);
17466: if (res == -2)
17467: goto internal_error;
17468: if (res == 1) {
17469: xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmaxinc, -1, 1, 1);
17470: }
17471: }
17472: if (bfmininc) {
17473: /* maxExclusive > BASE minInclusive */
17474: res = xmlSchemaCompareValues(fmaxexc->val, bfmininc->val);
17475: if (res == -2)
17476: goto internal_error;
17477: if (res != 1) {
17478: xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfmininc, 1, 0, 1);
17479: }
17480: }
17481: if (bfminexc) {
17482: /* maxExclusive > BASE minExclusive */
17483: res = xmlSchemaCompareValues(fmaxexc->val, bfminexc->val);
17484: if (res == -2)
17485: goto internal_error;
17486: if (res != 1) {
17487: xmlSchemaDeriveFacetErr(pctxt, fmaxexc, bfminexc, 1, 0, 1);
17488: }
17489: }
17490: }
17491: if (fminexc) {
17492: /*
17493: * "minExclusive < maxInclusive"
17494: */
17495: if (fmaxinc) {
17496: res = xmlSchemaCompareValues(fminexc->val, fmaxinc->val);
17497: if (res == -2)
17498: goto internal_error;
17499: if (res != -1) {
17500: xmlSchemaDeriveFacetErr(pctxt, fminexc, fmaxinc, -1, 0, 0);
17501: }
17502: }
17503: /*
17504: * "minExclusive valid restriction"
17505: */
17506: if (bfminexc) {
17507: /* minExclusive >= BASE minExclusive */
17508: res = xmlSchemaCompareValues(fminexc->val, bfminexc->val);
17509: if (res == -2)
17510: goto internal_error;
17511: if (res == -1) {
17512: xmlSchemaDeriveFacetErr(pctxt, fminexc, bfminexc, 1, 1, 1);
17513: }
17514: if ((res != 0) && (bfminexc->fixed)) {
17515: FACET_RESTR_FIXED_ERR(fminexc)
17516: }
17517: }
17518: if (bfmaxinc) {
17519: /* minExclusive <= BASE maxInclusive */
17520: res = xmlSchemaCompareValues(fminexc->val, bfmaxinc->val);
17521: if (res == -2)
17522: goto internal_error;
17523: if (res == 1) {
17524: xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmaxinc, -1, 1, 1);
17525: }
17526: }
17527: if (bfmininc) {
17528: /* minExclusive >= BASE minInclusive */
17529: res = xmlSchemaCompareValues(fminexc->val, bfmininc->val);
17530: if (res == -2)
17531: goto internal_error;
17532: if (res == -1) {
17533: xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmininc, 1, 1, 1);
17534: }
17535: }
17536: if (bfmaxexc) {
17537: /* minExclusive < BASE maxExclusive */
17538: res = xmlSchemaCompareValues(fminexc->val, bfmaxexc->val);
17539: if (res == -2)
17540: goto internal_error;
17541: if (res != -1) {
17542: xmlSchemaDeriveFacetErr(pctxt, fminexc, bfmaxexc, -1, 0, 1);
17543: }
17544: }
17545: }
17546: if (fmininc) {
17547: /*
17548: * "minInclusive < maxExclusive"
17549: */
17550: if (fmaxexc) {
17551: res = xmlSchemaCompareValues(fmininc->val, fmaxexc->val);
17552: if (res == -2)
17553: goto internal_error;
17554: if (res != -1) {
17555: xmlSchemaDeriveFacetErr(pctxt, fmininc, fmaxexc, -1, 0, 0);
17556: }
17557: }
17558: /*
17559: * "minExclusive valid restriction"
17560: */
17561: if (bfmininc) {
17562: /* minInclusive >= BASE minInclusive */
17563: res = xmlSchemaCompareValues(fmininc->val, bfmininc->val);
17564: if (res == -2)
17565: goto internal_error;
17566: if (res == -1) {
17567: xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmininc, 1, 1, 1);
17568: }
17569: if ((res != 0) && (bfmininc->fixed)) {
17570: FACET_RESTR_FIXED_ERR(fmininc)
17571: }
17572: }
17573: if (bfmaxinc) {
17574: /* minInclusive <= BASE maxInclusive */
17575: res = xmlSchemaCompareValues(fmininc->val, bfmaxinc->val);
17576: if (res == -2)
17577: goto internal_error;
17578: if (res == 1) {
17579: xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmaxinc, -1, 1, 1);
17580: }
17581: }
17582: if (bfminexc) {
17583: /* minInclusive > BASE minExclusive */
17584: res = xmlSchemaCompareValues(fmininc->val, bfminexc->val);
17585: if (res == -2)
17586: goto internal_error;
17587: if (res != 1)
17588: xmlSchemaDeriveFacetErr(pctxt, fmininc, bfminexc, 1, 0, 1);
17589: }
17590: if (bfmaxexc) {
17591: /* minInclusive < BASE maxExclusive */
17592: res = xmlSchemaCompareValues(fmininc->val, bfmaxexc->val);
17593: if (res == -2)
17594: goto internal_error;
17595: if (res != -1)
17596: xmlSchemaDeriveFacetErr(pctxt, fmininc, bfmaxexc, -1, 0, 1);
17597: }
17598: }
17599: if (ftotdig && bftotdig) {
17600: /*
17601: * SCC " totalDigits valid restriction"
17602: * totalDigits <= BASE totalDigits
17603: */
17604: res = xmlSchemaCompareValues(ftotdig->val, bftotdig->val);
17605: if (res == -2)
17606: goto internal_error;
17607: if (res == 1)
17608: xmlSchemaDeriveFacetErr(pctxt, ftotdig, bftotdig,
17609: -1, 1, 1);
17610: if ((res != 0) && (bftotdig->fixed)) {
17611: FACET_RESTR_FIXED_ERR(ftotdig)
17612: }
17613: }
17614: if (ffracdig && bffracdig) {
17615: /*
17616: * SCC "fractionDigits valid restriction"
17617: * fractionDigits <= BASE fractionDigits
17618: */
17619: res = xmlSchemaCompareValues(ffracdig->val, bffracdig->val);
17620: if (res == -2)
17621: goto internal_error;
17622: if (res == 1)
17623: xmlSchemaDeriveFacetErr(pctxt, ffracdig, bffracdig,
17624: -1, 1, 1);
17625: if ((res != 0) && (bffracdig->fixed)) {
17626: FACET_RESTR_FIXED_ERR(ffracdig)
17627: }
17628: }
17629: /*
17630: * SCC "fractionDigits less than or equal to totalDigits"
17631: */
17632: if (! ftotdig)
17633: ftotdig = bftotdig;
17634: if (! ffracdig)
17635: ffracdig = bffracdig;
17636: if (ftotdig && ffracdig) {
17637: res = xmlSchemaCompareValues(ffracdig->val, ftotdig->val);
17638: if (res == -2)
17639: goto internal_error;
17640: if (res == 1)
17641: xmlSchemaDeriveFacetErr(pctxt, ffracdig, ftotdig,
17642: -1, 1, 0);
17643: }
17644: /*
17645: * *Enumerations* won' be added here, since only the first set
17646: * of enumerations in the ancestor-or-self axis is used
17647: * for validation, plus we need to use the base type of those
17648: * enumerations for whitespace.
17649: *
17650: * *Patterns*: won't be add here, since they are ORed at
17651: * type level and ANDed at ancestor level. This will
17652: * happed during validation by walking the base axis
17653: * of the type.
17654: */
17655: for (cur = base->facetSet; cur != NULL; cur = cur->next) {
17656: bfacet = cur->facet;
17657: /*
17658: * Special handling of enumerations and patterns.
17659: * TODO: hmm, they should not appear in the set, so remove this.
17660: */
17661: if ((bfacet->type == XML_SCHEMA_FACET_PATTERN) ||
17662: (bfacet->type == XML_SCHEMA_FACET_ENUMERATION))
17663: continue;
17664: /*
17665: * Search for a duplicate facet in the current type.
17666: */
17667: link = type->facetSet;
17668: /* err = 0; */
17669: /* fixedErr = 0; */
17670: while (link != NULL) {
17671: facet = link->facet;
17672: if (facet->type == bfacet->type) {
17673: switch (facet->type) {
17674: case XML_SCHEMA_FACET_WHITESPACE:
17675: /*
17676: * The whitespace must be stronger.
17677: */
17678: if (facet->whitespace < bfacet->whitespace) {
17679: FACET_RESTR_ERR(facet,
17680: "The 'whitespace' value has to be equal to "
17681: "or stronger than the 'whitespace' value of "
17682: "the base type")
17683: }
17684: if ((bfacet->fixed) &&
17685: (facet->whitespace != bfacet->whitespace)) {
17686: FACET_RESTR_FIXED_ERR(facet)
17687: }
17688: break;
17689: default:
17690: break;
17691: }
17692: /* Duplicate found. */
17693: break;
17694: }
17695: link = link->next;
17696: }
17697: /*
17698: * If no duplicate was found: add the base types's facet
17699: * to the set.
17700: */
17701: if (link == NULL) {
17702: link = (xmlSchemaFacetLinkPtr)
17703: xmlMalloc(sizeof(xmlSchemaFacetLink));
17704: if (link == NULL) {
17705: xmlSchemaPErrMemory(pctxt,
17706: "deriving facets, creating a facet link", NULL);
17707: return (-1);
17708: }
17709: link->facet = cur->facet;
17710: link->next = NULL;
17711: if (last == NULL)
17712: type->facetSet = link;
17713: else
17714: last->next = link;
17715: last = link;
17716: }
17717:
17718: }
17719:
17720: return (0);
17721: internal_error:
17722: PERROR_INT("xmlSchemaDeriveAndValidateFacets",
17723: "an error occured");
17724: return (-1);
17725: }
17726:
17727: static int
17728: xmlSchemaFinishMemberTypeDefinitionsProperty(xmlSchemaParserCtxtPtr pctxt,
17729: xmlSchemaTypePtr type)
17730: {
17731: xmlSchemaTypeLinkPtr link, lastLink, prevLink, subLink, newLink;
17732: /*
17733: * The actual value is then formed by replacing any union type
17734: * definition in the �explicit members� with the members of their
17735: * {member type definitions}, in order.
17736: *
17737: * TODO: There's a bug entry at
17738: * "http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0287.html"
17739: * which indicates that we'll keep the union types the future.
17740: */
17741: link = type->memberTypes;
17742: while (link != NULL) {
17743:
17744: if (WXS_IS_TYPE_NOT_FIXED(link->type))
17745: xmlSchemaTypeFixup(link->type, ACTXT_CAST pctxt);
17746:
17747: if (WXS_IS_UNION(link->type)) {
17748: subLink = xmlSchemaGetUnionSimpleTypeMemberTypes(link->type);
17749: if (subLink != NULL) {
17750: link->type = subLink->type;
17751: if (subLink->next != NULL) {
17752: lastLink = link->next;
17753: subLink = subLink->next;
17754: prevLink = link;
17755: while (subLink != NULL) {
17756: newLink = (xmlSchemaTypeLinkPtr)
17757: xmlMalloc(sizeof(xmlSchemaTypeLink));
17758: if (newLink == NULL) {
17759: xmlSchemaPErrMemory(pctxt, "allocating a type link",
17760: NULL);
17761: return (-1);
17762: }
17763: newLink->type = subLink->type;
17764: prevLink->next = newLink;
17765: prevLink = newLink;
17766: newLink->next = lastLink;
17767:
17768: subLink = subLink->next;
17769: }
17770: }
17771: }
17772: }
17773: link = link->next;
17774: }
17775: return (0);
17776: }
17777:
17778: static void
17779: xmlSchemaTypeFixupOptimFacets(xmlSchemaTypePtr type)
17780: {
17781: int has = 0, needVal = 0, normVal = 0;
17782:
17783: has = (type->baseType->flags & XML_SCHEMAS_TYPE_HAS_FACETS) ? 1 : 0;
17784: if (has) {
17785: needVal = (type->baseType->flags &
17786: XML_SCHEMAS_TYPE_FACETSNEEDVALUE) ? 1 : 0;
17787: normVal = (type->baseType->flags &
17788: XML_SCHEMAS_TYPE_NORMVALUENEEDED) ? 1 : 0;
17789: }
17790: if (type->facets != NULL) {
17791: xmlSchemaFacetPtr fac;
17792:
17793: for (fac = type->facets; fac != NULL; fac = fac->next) {
17794: switch (fac->type) {
17795: case XML_SCHEMA_FACET_WHITESPACE:
17796: break;
17797: case XML_SCHEMA_FACET_PATTERN:
17798: normVal = 1;
17799: has = 1;
17800: break;
17801: case XML_SCHEMA_FACET_ENUMERATION:
17802: needVal = 1;
17803: normVal = 1;
17804: has = 1;
17805: break;
17806: default:
17807: has = 1;
17808: break;
17809: }
17810: }
17811: }
17812: if (normVal)
17813: type->flags |= XML_SCHEMAS_TYPE_NORMVALUENEEDED;
17814: if (needVal)
17815: type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
17816: if (has)
17817: type->flags |= XML_SCHEMAS_TYPE_HAS_FACETS;
17818:
17819: if (has && (! needVal) && WXS_IS_ATOMIC(type)) {
17820: xmlSchemaTypePtr prim = xmlSchemaGetPrimitiveType(type);
17821: /*
17822: * OPTIMIZE VAL TODO: Some facets need a computed value.
17823: */
17824: if ((prim->builtInType != XML_SCHEMAS_ANYSIMPLETYPE) &&
17825: (prim->builtInType != XML_SCHEMAS_STRING)) {
17826: type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
17827: }
17828: }
17829: }
17830:
17831: static int
17832: xmlSchemaTypeFixupWhitespace(xmlSchemaTypePtr type)
17833: {
17834:
17835:
17836: /*
17837: * Evaluate the whitespace-facet value.
17838: */
17839: if (WXS_IS_LIST(type)) {
17840: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
17841: return (0);
17842: } else if (WXS_IS_UNION(type))
17843: return (0);
17844:
17845: if (type->facetSet != NULL) {
17846: xmlSchemaFacetLinkPtr lin;
17847:
17848: for (lin = type->facetSet; lin != NULL; lin = lin->next) {
17849: if (lin->facet->type == XML_SCHEMA_FACET_WHITESPACE) {
17850: switch (lin->facet->whitespace) {
17851: case XML_SCHEMAS_FACET_PRESERVE:
17852: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
17853: break;
17854: case XML_SCHEMAS_FACET_REPLACE:
17855: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
17856: break;
17857: case XML_SCHEMAS_FACET_COLLAPSE:
17858: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
17859: break;
17860: default:
17861: return (-1);
17862: }
17863: return (0);
17864: }
17865: }
17866: }
17867: /*
17868: * For all �atomic� datatypes other than string (and types �derived�
17869: * by �restriction� from it) the value of whiteSpace is fixed to
17870: * collapse
17871: */
17872: {
17873: xmlSchemaTypePtr anc;
17874:
17875: for (anc = type->baseType; anc != NULL &&
17876: anc->builtInType != XML_SCHEMAS_ANYTYPE;
17877: anc = anc->baseType) {
17878:
17879: if (anc->type == XML_SCHEMA_TYPE_BASIC) {
17880: if (anc->builtInType == XML_SCHEMAS_NORMSTRING) {
17881: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
17882:
17883: } else if ((anc->builtInType == XML_SCHEMAS_STRING) ||
17884: (anc->builtInType == XML_SCHEMAS_ANYSIMPLETYPE)) {
17885: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
17886:
17887: } else
17888: type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
17889: break;
17890: }
17891: }
17892: }
17893: return (0);
17894: }
17895:
17896: static int
17897: xmlSchemaFixupSimpleTypeStageOne(xmlSchemaParserCtxtPtr pctxt,
17898: xmlSchemaTypePtr type)
17899: {
17900: if (type->type != XML_SCHEMA_TYPE_SIMPLE)
17901: return(0);
17902: if (! WXS_IS_TYPE_NOT_FIXED_1(type))
17903: return(0);
17904: type->flags |= XML_SCHEMAS_TYPE_FIXUP_1;
17905:
17906: if (WXS_IS_LIST(type)) {
17907: /*
17908: * Corresponds to <simpleType><list>...
17909: */
17910: if (type->subtypes == NULL) {
17911: /*
17912: * This one is really needed, so get out.
17913: */
17914: PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
17915: "list type has no item-type assigned");
17916: return(-1);
17917: }
17918: } else if (WXS_IS_UNION(type)) {
17919: /*
17920: * Corresponds to <simpleType><union>...
17921: */
17922: if (type->memberTypes == NULL) {
17923: /*
17924: * This one is really needed, so get out.
17925: */
17926: PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
17927: "union type has no member-types assigned");
17928: return(-1);
17929: }
17930: } else {
17931: /*
17932: * Corresponds to <simpleType><restriction>...
17933: */
17934: if (type->baseType == NULL) {
17935: PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
17936: "type has no base-type assigned");
17937: return(-1);
17938: }
17939: if (WXS_IS_TYPE_NOT_FIXED_1(type->baseType))
17940: if (xmlSchemaFixupSimpleTypeStageOne(pctxt, type->baseType) == -1)
17941: return(-1);
17942: /*
17943: * Variety
17944: * If the <restriction> alternative is chosen, then the
17945: * {variety} of the {base type definition}.
17946: */
17947: if (WXS_IS_ATOMIC(type->baseType))
17948: type->flags |= XML_SCHEMAS_TYPE_VARIETY_ATOMIC;
17949: else if (WXS_IS_LIST(type->baseType)) {
17950: type->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
17951: /*
17952: * Inherit the itemType.
17953: */
17954: type->subtypes = type->baseType->subtypes;
17955: } else if (WXS_IS_UNION(type->baseType)) {
17956: type->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
17957: /*
17958: * NOTE that we won't assign the memberTypes of the base,
17959: * since this will make trouble when freeing them; we will
17960: * use a lookup function to access them instead.
17961: */
17962: }
17963: }
17964: return(0);
17965: }
17966:
17967: #ifdef DEBUG_TYPE
17968: static void
17969: xmlSchemaDebugFixedType(xmlSchemaParserCtxtPtr pctxt,
17970: xmlSchemaTypePtr type)
17971: {
17972: if (type->node != NULL) {
17973: xmlGenericError(xmlGenericErrorContext,
17974: "Type of %s : %s:%d :", name,
17975: type->node->doc->URL,
17976: xmlGetLineNo(type->node));
17977: } else {
17978: xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
17979: }
17980: if ((WXS_IS_SIMPLE(type)) || (WXS_IS_COMPLEX(type))) {
17981: switch (type->contentType) {
17982: case XML_SCHEMA_CONTENT_SIMPLE:
17983: xmlGenericError(xmlGenericErrorContext, "simple\n");
17984: break;
17985: case XML_SCHEMA_CONTENT_ELEMENTS:
17986: xmlGenericError(xmlGenericErrorContext, "elements\n");
17987: break;
17988: case XML_SCHEMA_CONTENT_UNKNOWN:
17989: xmlGenericError(xmlGenericErrorContext, "unknown !!!\n");
17990: break;
17991: case XML_SCHEMA_CONTENT_EMPTY:
17992: xmlGenericError(xmlGenericErrorContext, "empty\n");
17993: break;
17994: case XML_SCHEMA_CONTENT_MIXED:
17995: if (xmlSchemaIsParticleEmptiable((xmlSchemaParticlePtr)
17996: type->subtypes))
17997: xmlGenericError(xmlGenericErrorContext,
17998: "mixed as emptiable particle\n");
17999: else
18000: xmlGenericError(xmlGenericErrorContext, "mixed\n");
18001: break;
18002: /* Removed, since not used. */
18003: /*
18004: case XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS:
18005: xmlGenericError(xmlGenericErrorContext, "mixed or elems\n");
18006: break;
18007: */
18008: case XML_SCHEMA_CONTENT_BASIC:
18009: xmlGenericError(xmlGenericErrorContext, "basic\n");
18010: break;
18011: default:
18012: xmlGenericError(xmlGenericErrorContext,
18013: "not registered !!!\n");
18014: break;
18015: }
18016: }
18017: }
18018: #endif
18019:
18020: /*
18021: * 3.14.6 Constraints on Simple Type Definition Schema Components
18022: */
18023: static int
18024: xmlSchemaFixupSimpleTypeStageTwo(xmlSchemaParserCtxtPtr pctxt,
18025: xmlSchemaTypePtr type)
18026: {
18027: int res, olderrs = pctxt->nberrors;
18028:
18029: if (type->type != XML_SCHEMA_TYPE_SIMPLE)
18030: return(-1);
18031:
18032: if (! WXS_IS_TYPE_NOT_FIXED(type))
18033: return(0);
18034:
18035: type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
18036: type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
18037:
18038: if (type->baseType == NULL) {
18039: PERROR_INT("xmlSchemaFixupSimpleTypeStageTwo",
18040: "missing baseType");
18041: goto exit_failure;
18042: }
18043: if (WXS_IS_TYPE_NOT_FIXED(type->baseType))
18044: xmlSchemaTypeFixup(type->baseType, ACTXT_CAST pctxt);
18045: /*
18046: * If a member type of a union is a union itself, we need to substitute
18047: * that member type for its member types.
18048: * NOTE that this might change in WXS 1.1; i.e. we will keep the union
18049: * types in WXS 1.1.
18050: */
18051: if ((type->memberTypes != NULL) &&
18052: (xmlSchemaFinishMemberTypeDefinitionsProperty(pctxt, type) == -1))
18053: return(-1);
18054: /*
18055: * SPEC src-simple-type 1
18056: * "The corresponding simple type definition, if any, must satisfy
18057: * the conditions set out in Constraints on Simple Type Definition
18058: * Schema Components (�3.14.6)."
18059: */
18060: /*
18061: * Schema Component Constraint: Simple Type Definition Properties Correct
18062: * (st-props-correct)
18063: */
18064: res = xmlSchemaCheckSTPropsCorrect(pctxt, type);
18065: HFAILURE HERROR
18066: /*
18067: * Schema Component Constraint: Derivation Valid (Restriction, Simple)
18068: * (cos-st-restricts)
18069: */
18070: res = xmlSchemaCheckCOSSTRestricts(pctxt, type);
18071: HFAILURE HERROR
18072: /*
18073: * TODO: Removed the error report, since it got annoying to get an
18074: * extra error report, if anything failed until now.
18075: * Enable this if needed.
18076: *
18077: * xmlSchemaPErr(ctxt, type->node,
18078: * XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
18079: * "Simple type '%s' does not satisfy the constraints "
18080: * "on simple type definitions.\n",
18081: * type->name, NULL);
18082: */
18083: /*
18084: * Schema Component Constraint: Simple Type Restriction (Facets)
18085: * (st-restrict-facets)
18086: */
18087: res = xmlSchemaCheckFacetValues(type, pctxt);
18088: HFAILURE HERROR
18089: if ((type->facetSet != NULL) ||
18090: (type->baseType->facetSet != NULL)) {
18091: res = xmlSchemaDeriveAndValidateFacets(pctxt, type);
18092: HFAILURE HERROR
18093: }
18094: /*
18095: * Whitespace value.
18096: */
18097: res = xmlSchemaTypeFixupWhitespace(type);
18098: HFAILURE HERROR
18099: xmlSchemaTypeFixupOptimFacets(type);
18100:
18101: exit_error:
18102: #ifdef DEBUG_TYPE
18103: xmlSchemaDebugFixedType(pctxt, type);
18104: #endif
18105: if (olderrs != pctxt->nberrors)
18106: return(pctxt->err);
18107: return(0);
18108:
18109: exit_failure:
18110: #ifdef DEBUG_TYPE
18111: xmlSchemaDebugFixedType(pctxt, type);
18112: #endif
18113: return(-1);
18114: }
18115:
18116: static int
18117: xmlSchemaFixupComplexType(xmlSchemaParserCtxtPtr pctxt,
18118: xmlSchemaTypePtr type)
18119: {
18120: int res = 0, olderrs = pctxt->nberrors;
18121: xmlSchemaTypePtr baseType = type->baseType;
18122:
18123: if (! WXS_IS_TYPE_NOT_FIXED(type))
18124: return(0);
18125: type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
18126: if (baseType == NULL) {
18127: PERROR_INT("xmlSchemaFixupComplexType",
18128: "missing baseType");
18129: goto exit_failure;
18130: }
18131: /*
18132: * Fixup the base type.
18133: */
18134: if (WXS_IS_TYPE_NOT_FIXED(baseType))
18135: xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt);
18136: if (baseType->flags & XML_SCHEMAS_TYPE_INTERNAL_INVALID) {
18137: /*
18138: * Skip fixup if the base type is invalid.
18139: * TODO: Generate a warning!
18140: */
18141: return(0);
18142: }
18143: /*
18144: * This basically checks if the base type can be derived.
18145: */
18146: res = xmlSchemaCheckSRCCT(pctxt, type);
18147: HFAILURE HERROR
18148: /*
18149: * Fixup the content type.
18150: */
18151: if (type->contentType == XML_SCHEMA_CONTENT_SIMPLE) {
18152: /*
18153: * Corresponds to <complexType><simpleContent>...
18154: */
18155: if ((WXS_IS_COMPLEX(baseType)) &&
18156: (baseType->contentTypeDef != NULL) &&
18157: (WXS_IS_RESTRICTION(type))) {
18158: xmlSchemaTypePtr contentBase, content;
18159: #ifdef ENABLE_NAMED_LOCALS
18160: char buf[30];
18161: const xmlChar *tmpname;
18162: #endif
18163: /*
18164: * SPEC (1) If <restriction> + base type is <complexType>,
18165: * "whose own {content type} is a simple type..."
18166: */
18167: if (type->contentTypeDef != NULL) {
18168: /*
18169: * SPEC (1.1) "the simple type definition corresponding to the
18170: * <simpleType> among the [children] of <restriction> if there
18171: * is one;"
18172: * Note that this "<simpleType> among the [children]" was put
18173: * into ->contentTypeDef during parsing.
18174: */
18175: contentBase = type->contentTypeDef;
18176: type->contentTypeDef = NULL;
18177: } else {
18178: /*
18179: * (1.2) "...otherwise (<restriction> has no <simpleType>
18180: * among its [children]), the simple type definition which
18181: * is the {content type} of the ... base type."
18182: */
18183: contentBase = baseType->contentTypeDef;
18184: }
18185: /*
18186: * SPEC
18187: * "... a simple type definition which restricts the simple
18188: * type definition identified in clause 1.1 or clause 1.2
18189: * with a set of facet components"
18190: *
18191: * Create the anonymous simple type, which will be the content
18192: * type of the complex type.
18193: */
18194: #ifdef ENABLE_NAMED_LOCALS
18195: snprintf(buf, 29, "#scST%d", ++(pctxt->counter));
18196: tmpname = xmlDictLookup(pctxt->dict, BAD_CAST buf, -1);
18197: content = xmlSchemaAddType(pctxt, pctxt->schema,
18198: XML_SCHEMA_TYPE_SIMPLE, tmpname, type->targetNamespace,
18199: type->node, 0);
18200: #else
18201: content = xmlSchemaAddType(pctxt, pctxt->schema,
18202: XML_SCHEMA_TYPE_SIMPLE, NULL, type->targetNamespace,
18203: type->node, 0);
18204: #endif
18205: if (content == NULL)
18206: goto exit_failure;
18207: /*
18208: * We will use the same node as for the <complexType>
18209: * to have it somehow anchored in the schema doc.
18210: */
18211: content->type = XML_SCHEMA_TYPE_SIMPLE;
18212: content->baseType = contentBase;
18213: /*
18214: * Move the facets, previously anchored on the
18215: * complexType during parsing.
18216: */
18217: content->facets = type->facets;
18218: type->facets = NULL;
18219: content->facetSet = type->facetSet;
18220: type->facetSet = NULL;
18221:
18222: type->contentTypeDef = content;
18223: if (WXS_IS_TYPE_NOT_FIXED(contentBase))
18224: xmlSchemaTypeFixup(contentBase, ACTXT_CAST pctxt);
18225: /*
18226: * Fixup the newly created type. We don't need to check
18227: * for circularity here.
18228: */
18229: res = xmlSchemaFixupSimpleTypeStageOne(pctxt, content);
18230: HFAILURE HERROR
18231: res = xmlSchemaFixupSimpleTypeStageTwo(pctxt, content);
18232: HFAILURE HERROR
18233:
18234: } else if ((WXS_IS_COMPLEX(baseType)) &&
18235: (baseType->contentType == XML_SCHEMA_CONTENT_MIXED) &&
18236: (WXS_IS_RESTRICTION(type))) {
18237: /*
18238: * SPEC (2) If <restriction> + base is a mixed <complexType> with
18239: * an emptiable particle, then a simple type definition which
18240: * restricts the <restriction>'s <simpleType> child.
18241: */
18242: if ((type->contentTypeDef == NULL) ||
18243: (type->contentTypeDef->baseType == NULL)) {
18244: /*
18245: * TODO: Check if this ever happens.
18246: */
18247: xmlSchemaPCustomErr(pctxt,
18248: XML_SCHEMAP_INTERNAL,
18249: WXS_BASIC_CAST type, NULL,
18250: "Internal error: xmlSchemaTypeFixup, "
18251: "complex type '%s': the <simpleContent><restriction> "
18252: "is missing a <simpleType> child, but was not catched "
18253: "by xmlSchemaCheckSRCCT()", type->name);
18254: goto exit_failure;
18255: }
18256: } else if ((WXS_IS_COMPLEX(baseType)) && WXS_IS_EXTENSION(type)) {
18257: /*
18258: * SPEC (3) If <extension> + base is <complexType> with
18259: * <simpleType> content, "...then the {content type} of that
18260: * complex type definition"
18261: */
18262: if (baseType->contentTypeDef == NULL) {
18263: /*
18264: * TODO: Check if this ever happens. xmlSchemaCheckSRCCT
18265: * should have catched this already.
18266: */
18267: xmlSchemaPCustomErr(pctxt,
18268: XML_SCHEMAP_INTERNAL,
18269: WXS_BASIC_CAST type, NULL,
18270: "Internal error: xmlSchemaTypeFixup, "
18271: "complex type '%s': the <extension>ed base type is "
18272: "a complex type with no simple content type",
18273: type->name);
18274: goto exit_failure;
18275: }
18276: type->contentTypeDef = baseType->contentTypeDef;
18277: } else if ((WXS_IS_SIMPLE(baseType)) && WXS_IS_EXTENSION(type)) {
18278: /*
18279: * SPEC (4) <extension> + base is <simpleType>
18280: * "... then that simple type definition"
18281: */
18282: type->contentTypeDef = baseType;
18283: } else {
18284: /*
18285: * TODO: Check if this ever happens.
18286: */
18287: xmlSchemaPCustomErr(pctxt,
18288: XML_SCHEMAP_INTERNAL,
18289: WXS_BASIC_CAST type, NULL,
18290: "Internal error: xmlSchemaTypeFixup, "
18291: "complex type '%s' with <simpleContent>: unhandled "
18292: "derivation case", type->name);
18293: goto exit_failure;
18294: }
18295: } else {
18296: int dummySequence = 0;
18297: xmlSchemaParticlePtr particle =
18298: (xmlSchemaParticlePtr) type->subtypes;
18299: /*
18300: * Corresponds to <complexType><complexContent>...
18301: *
18302: * NOTE that the effective mixed was already set during parsing of
18303: * <complexType> and <complexContent>; its flag value is
18304: * XML_SCHEMAS_TYPE_MIXED.
18305: *
18306: * Compute the "effective content":
18307: * (2.1.1) + (2.1.2) + (2.1.3)
18308: */
18309: if ((particle == NULL) ||
18310: ((particle->type == XML_SCHEMA_TYPE_PARTICLE) &&
18311: ((particle->children->type == XML_SCHEMA_TYPE_ALL) ||
18312: (particle->children->type == XML_SCHEMA_TYPE_SEQUENCE) ||
18313: ((particle->children->type == XML_SCHEMA_TYPE_CHOICE) &&
18314: (particle->minOccurs == 0))) &&
18315: ( ((xmlSchemaTreeItemPtr) particle->children)->children == NULL))) {
18316: if (type->flags & XML_SCHEMAS_TYPE_MIXED) {
18317: /*
18318: * SPEC (2.1.4) "If the �effective mixed� is true, then
18319: * a particle whose properties are as follows:..."
18320: *
18321: * Empty sequence model group with
18322: * minOccurs/maxOccurs = 1 (i.e. a "particle emptiable").
18323: * NOTE that we sill assign it the <complexType> node to
18324: * somehow anchor it in the doc.
18325: */
18326: if ((particle == NULL) ||
18327: (particle->children->type != XML_SCHEMA_TYPE_SEQUENCE)) {
18328: /*
18329: * Create the particle.
18330: */
18331: particle = xmlSchemaAddParticle(pctxt,
18332: type->node, 1, 1);
18333: if (particle == NULL)
18334: goto exit_failure;
18335: /*
18336: * Create the model group.
18337: */ /* URGENT TODO: avoid adding to pending items. */
18338: particle->children = (xmlSchemaTreeItemPtr)
18339: xmlSchemaAddModelGroup(pctxt, pctxt->schema,
18340: XML_SCHEMA_TYPE_SEQUENCE, type->node);
18341: if (particle->children == NULL)
18342: goto exit_failure;
18343:
18344: type->subtypes = (xmlSchemaTypePtr) particle;
18345: }
18346: dummySequence = 1;
18347: type->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
18348: } else {
18349: /*
18350: * SPEC (2.1.5) "otherwise empty"
18351: */
18352: type->contentType = XML_SCHEMA_CONTENT_EMPTY;
18353: }
18354: } else {
18355: /*
18356: * SPEC (2.2) "otherwise the particle corresponding to the
18357: * <all>, <choice>, <group> or <sequence> among the
18358: * [children]."
18359: */
18360: type->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
18361: }
18362: /*
18363: * Compute the "content type".
18364: */
18365: if (WXS_IS_RESTRICTION(type)) {
18366: /*
18367: * SPEC (3.1) "If <restriction>..."
18368: * (3.1.1) + (3.1.2) */
18369: if (type->contentType != XML_SCHEMA_CONTENT_EMPTY) {
18370: if (type->flags & XML_SCHEMAS_TYPE_MIXED)
18371: type->contentType = XML_SCHEMA_CONTENT_MIXED;
18372: }
18373: } else {
18374: /*
18375: * SPEC (3.2) "If <extension>..."
18376: */
18377: if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
18378: /*
18379: * SPEC (3.2.1)
18380: * "If the �effective content� is empty, then the
18381: * {content type} of the [...] base ..."
18382: */
18383: type->contentType = baseType->contentType;
18384: type->subtypes = baseType->subtypes;
18385: /*
18386: * Fixes bug #347316:
18387: * This is the case when the base type has a simple
18388: * type definition as content.
18389: */
18390: type->contentTypeDef = baseType->contentTypeDef;
18391: /*
18392: * NOTE that the effective mixed is ignored here.
18393: */
18394: } else if (baseType->contentType == XML_SCHEMA_CONTENT_EMPTY) {
18395: /*
18396: * SPEC (3.2.2)
18397: */
18398: if (type->flags & XML_SCHEMAS_TYPE_MIXED)
18399: type->contentType = XML_SCHEMA_CONTENT_MIXED;
18400: } else {
18401: /*
18402: * SPEC (3.2.3)
18403: */
18404: if (type->flags & XML_SCHEMAS_TYPE_MIXED)
18405: type->contentType = XML_SCHEMA_CONTENT_MIXED;
18406: /*
18407: * "A model group whose {compositor} is sequence and whose
18408: * {particles} are..."
18409: */
18410: if ((WXS_TYPE_PARTICLE(type) != NULL) &&
18411: (WXS_TYPE_PARTICLE_TERM(type) != NULL) &&
18412: ((WXS_TYPE_PARTICLE_TERM(type))->type ==
18413: XML_SCHEMA_TYPE_ALL))
18414: {
18415: /*
18416: * SPEC cos-all-limited (1)
18417: */
18418: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18419: /* TODO: error code */
18420: XML_SCHEMAP_COS_ALL_LIMITED,
18421: WXS_ITEM_NODE(type), NULL,
18422: "The type has an 'all' model group in its "
18423: "{content type} and thus cannot be derived from "
18424: "a non-empty type, since this would produce a "
18425: "'sequence' model group containing the 'all' "
18426: "model group; 'all' model groups are not "
18427: "allowed to appear inside other model groups",
18428: NULL, NULL);
18429:
18430: } else if ((WXS_TYPE_PARTICLE(baseType) != NULL) &&
18431: (WXS_TYPE_PARTICLE_TERM(baseType) != NULL) &&
18432: ((WXS_TYPE_PARTICLE_TERM(baseType))->type ==
18433: XML_SCHEMA_TYPE_ALL))
18434: {
18435: /*
18436: * SPEC cos-all-limited (1)
18437: */
18438: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18439: /* TODO: error code */
18440: XML_SCHEMAP_COS_ALL_LIMITED,
18441: WXS_ITEM_NODE(type), NULL,
18442: "A type cannot be derived by extension from a type "
18443: "which has an 'all' model group in its "
18444: "{content type}, since this would produce a "
18445: "'sequence' model group containing the 'all' "
18446: "model group; 'all' model groups are not "
18447: "allowed to appear inside other model groups",
18448: NULL, NULL);
18449:
18450: } else if (! dummySequence) {
18451: xmlSchemaTreeItemPtr effectiveContent =
18452: (xmlSchemaTreeItemPtr) type->subtypes;
18453: /*
18454: * Create the particle.
18455: */
18456: particle = xmlSchemaAddParticle(pctxt,
18457: type->node, 1, 1);
18458: if (particle == NULL)
18459: goto exit_failure;
18460: /*
18461: * Create the "sequence" model group.
18462: */
18463: particle->children = (xmlSchemaTreeItemPtr)
18464: xmlSchemaAddModelGroup(pctxt, pctxt->schema,
18465: XML_SCHEMA_TYPE_SEQUENCE, type->node);
18466: if (particle->children == NULL)
18467: goto exit_failure;
18468: WXS_TYPE_CONTENTTYPE(type) = (xmlSchemaTypePtr) particle;
18469: /*
18470: * SPEC "the particle of the {content type} of
18471: * the ... base ..."
18472: * Create a duplicate of the base type's particle
18473: * and assign its "term" to it.
18474: */
18475: particle->children->children =
18476: (xmlSchemaTreeItemPtr) xmlSchemaAddParticle(pctxt,
18477: type->node,
18478: ((xmlSchemaParticlePtr) type->subtypes)->minOccurs,
18479: ((xmlSchemaParticlePtr) type->subtypes)->maxOccurs);
18480: if (particle->children->children == NULL)
18481: goto exit_failure;
18482: particle = (xmlSchemaParticlePtr)
18483: particle->children->children;
18484: particle->children =
18485: ((xmlSchemaParticlePtr) baseType->subtypes)->children;
18486: /*
18487: * SPEC "followed by the �effective content�."
18488: */
18489: particle->next = effectiveContent;
18490: /*
18491: * This all will result in:
18492: * new-particle
18493: * --> new-sequence(
18494: * new-particle
18495: * --> base-model,
18496: * this-particle
18497: * --> this-model
18498: * )
18499: */
18500: } else {
18501: /*
18502: * This is the case when there is already an empty
18503: * <sequence> with minOccurs==maxOccurs==1.
18504: * Just add the base types's content type.
18505: * NOTE that, although we miss to add an intermediate
18506: * <sequence>, this should produce no difference to
18507: * neither the regex compilation of the content model,
18508: * nor to the complex type contraints.
18509: */
18510: particle->children->children =
18511: (xmlSchemaTreeItemPtr) baseType->subtypes;
18512: }
18513: }
18514: }
18515: }
18516: /*
18517: * Now fixup attribute uses:
18518: * - expand attr. group references
18519: * - intersect attribute wildcards
18520: * - inherit attribute uses of the base type
18521: * - inherit or union attr. wildcards if extending
18522: * - apply attr. use prohibitions if restricting
18523: */
18524: res = xmlSchemaFixupTypeAttributeUses(pctxt, type);
18525: HFAILURE HERROR
18526: /*
18527: * Apply the complex type component constraints; this will not
18528: * check attributes, since this is done in
18529: * xmlSchemaFixupTypeAttributeUses().
18530: */
18531: res = xmlSchemaCheckCTComponent(pctxt, type);
18532: HFAILURE HERROR
18533:
18534: #ifdef DEBUG_TYPE
18535: xmlSchemaDebugFixedType(pctxt, type);
18536: #endif
18537: if (olderrs != pctxt->nberrors)
18538: return(pctxt->err);
18539: else
18540: return(0);
18541:
18542: exit_error:
18543: type->flags |= XML_SCHEMAS_TYPE_INTERNAL_INVALID;
18544: #ifdef DEBUG_TYPE
18545: xmlSchemaDebugFixedType(pctxt, type);
18546: #endif
18547: return(pctxt->err);
18548:
18549: exit_failure:
18550: type->flags |= XML_SCHEMAS_TYPE_INTERNAL_INVALID;
18551: #ifdef DEBUG_TYPE
18552: xmlSchemaDebugFixedType(pctxt, type);
18553: #endif
18554: return(-1);
18555: }
18556:
18557:
18558: /**
18559: * xmlSchemaTypeFixup:
18560: * @typeDecl: the schema type definition
18561: * @ctxt: the schema parser context
18562: *
18563: * Fixes the content model of the type.
18564: * URGENT TODO: We need an int result!
18565: */
18566: static int
18567: xmlSchemaTypeFixup(xmlSchemaTypePtr type,
18568: xmlSchemaAbstractCtxtPtr actxt)
18569: {
18570: if (type == NULL)
18571: return(0);
18572: if (actxt->type != XML_SCHEMA_CTXT_PARSER) {
18573: AERROR_INT("xmlSchemaTypeFixup",
18574: "this function needs a parser context");
18575: return(-1);
18576: }
18577: if (! WXS_IS_TYPE_NOT_FIXED(type))
18578: return(0);
18579: if (type->type == XML_SCHEMA_TYPE_COMPLEX)
18580: return(xmlSchemaFixupComplexType(PCTXT_CAST actxt, type));
18581: else if (type->type == XML_SCHEMA_TYPE_SIMPLE)
18582: return(xmlSchemaFixupSimpleTypeStageTwo(PCTXT_CAST actxt, type));
18583: return(0);
18584: }
18585:
18586: /**
18587: * xmlSchemaCheckFacet:
18588: * @facet: the facet
18589: * @typeDecl: the schema type definition
18590: * @pctxt: the schema parser context or NULL
18591: * @name: the optional name of the type
18592: *
18593: * Checks and computes the values of facets.
18594: *
18595: * Returns 0 if valid, a positive error code if not valid and
18596: * -1 in case of an internal or API error.
18597: */
18598: int
18599: xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
18600: xmlSchemaTypePtr typeDecl,
18601: xmlSchemaParserCtxtPtr pctxt,
18602: const xmlChar * name ATTRIBUTE_UNUSED)
18603: {
18604: int ret = 0, ctxtGiven;
18605:
18606: if ((facet == NULL) || (typeDecl == NULL))
18607: return(-1);
18608: /*
18609: * TODO: will the parser context be given if used from
18610: * the relaxNG module?
18611: */
18612: if (pctxt == NULL)
18613: ctxtGiven = 0;
18614: else
18615: ctxtGiven = 1;
18616:
18617: switch (facet->type) {
18618: case XML_SCHEMA_FACET_MININCLUSIVE:
18619: case XML_SCHEMA_FACET_MINEXCLUSIVE:
18620: case XML_SCHEMA_FACET_MAXINCLUSIVE:
18621: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
18622: case XML_SCHEMA_FACET_ENUMERATION: {
18623: /*
18624: * Okay we need to validate the value
18625: * at that point.
18626: */
18627: xmlSchemaTypePtr base;
18628:
18629: /* 4.3.5.5 Constraints on enumeration Schema Components
18630: * Schema Component Constraint: enumeration valid restriction
18631: * It is an �error� if any member of {value} is not in the
18632: * �value space� of {base type definition}.
18633: *
18634: * minInclusive, maxInclusive, minExclusive, maxExclusive:
18635: * The value �must� be in the
18636: * �value space� of the �base type�.
18637: */
18638: /*
18639: * This function is intended to deliver a compiled value
18640: * on the facet. In this implementation of XML Schemata the
18641: * type holding a facet, won't be a built-in type.
18642: * Thus to ensure that other API
18643: * calls (relaxng) do work, if the given type is a built-in
18644: * type, we will assume that the given built-in type *is
18645: * already* the base type.
18646: */
18647: if (typeDecl->type != XML_SCHEMA_TYPE_BASIC) {
18648: base = typeDecl->baseType;
18649: if (base == NULL) {
18650: PERROR_INT("xmlSchemaCheckFacet",
18651: "a type user derived type has no base type");
18652: return (-1);
18653: }
18654: } else
18655: base = typeDecl;
18656:
18657: if (! ctxtGiven) {
18658: /*
18659: * A context is needed if called from RelaxNG.
18660: */
18661: pctxt = xmlSchemaNewParserCtxt("*");
18662: if (pctxt == NULL)
18663: return (-1);
18664: }
18665: /*
18666: * NOTE: This call does not check the content nodes,
18667: * since they are not available:
18668: * facet->node is just the node holding the facet
18669: * definition, *not* the attribute holding the *value*
18670: * of the facet.
18671: */
18672: ret = xmlSchemaVCheckCVCSimpleType(
18673: ACTXT_CAST pctxt, facet->node, base,
18674: facet->value, &(facet->val), 1, 1, 0);
18675: if (ret != 0) {
18676: if (ret < 0) {
18677: /* No error message for RelaxNG. */
18678: if (ctxtGiven) {
18679: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18680: XML_SCHEMAP_INTERNAL, facet->node, NULL,
18681: "Internal error: xmlSchemaCheckFacet, "
18682: "failed to validate the value '%s' of the "
18683: "facet '%s' against the base type",
18684: facet->value, xmlSchemaFacetTypeToString(facet->type));
18685: }
18686: goto internal_error;
18687: }
18688: ret = XML_SCHEMAP_INVALID_FACET_VALUE;
18689: /* No error message for RelaxNG. */
18690: if (ctxtGiven) {
18691: xmlChar *str = NULL;
18692:
18693: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18694: ret, facet->node, WXS_BASIC_CAST facet,
18695: "The value '%s' of the facet does not validate "
18696: "against the base type '%s'",
18697: facet->value,
18698: xmlSchemaFormatQName(&str,
18699: base->targetNamespace, base->name));
18700: FREE_AND_NULL(str);
18701: }
18702: goto exit;
18703: } else if (facet->val == NULL) {
18704: if (ctxtGiven) {
18705: PERROR_INT("xmlSchemaCheckFacet",
18706: "value was not computed");
18707: }
18708: TODO
18709: }
18710: break;
18711: }
18712: case XML_SCHEMA_FACET_PATTERN:
18713: facet->regexp = xmlRegexpCompile(facet->value);
18714: if (facet->regexp == NULL) {
18715: ret = XML_SCHEMAP_REGEXP_INVALID;
18716: /* No error message for RelaxNG. */
18717: if (ctxtGiven) {
18718: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18719: ret, facet->node, WXS_BASIC_CAST typeDecl,
18720: "The value '%s' of the facet 'pattern' is not a "
18721: "valid regular expression",
18722: facet->value, NULL);
18723: }
18724: }
18725: break;
18726: case XML_SCHEMA_FACET_TOTALDIGITS:
18727: case XML_SCHEMA_FACET_FRACTIONDIGITS:
18728: case XML_SCHEMA_FACET_LENGTH:
18729: case XML_SCHEMA_FACET_MAXLENGTH:
18730: case XML_SCHEMA_FACET_MINLENGTH:
18731:
18732: if (facet->type == XML_SCHEMA_FACET_TOTALDIGITS) {
18733: ret = xmlSchemaValidatePredefinedType(
18734: xmlSchemaGetBuiltInType(XML_SCHEMAS_PINTEGER),
18735: facet->value, &(facet->val));
18736: } else {
18737: ret = xmlSchemaValidatePredefinedType(
18738: xmlSchemaGetBuiltInType(XML_SCHEMAS_NNINTEGER),
18739: facet->value, &(facet->val));
18740: }
18741: if (ret != 0) {
18742: if (ret < 0) {
18743: /* No error message for RelaxNG. */
18744: if (ctxtGiven) {
18745: PERROR_INT("xmlSchemaCheckFacet",
18746: "validating facet value");
18747: }
18748: goto internal_error;
18749: }
18750: ret = XML_SCHEMAP_INVALID_FACET_VALUE;
18751: /* No error message for RelaxNG. */
18752: if (ctxtGiven) {
18753: /* error code */
18754: xmlSchemaCustomErr4(ACTXT_CAST pctxt,
18755: ret, facet->node, WXS_BASIC_CAST typeDecl,
18756: "The value '%s' of the facet '%s' is not a valid '%s'",
18757: facet->value,
18758: xmlSchemaFacetTypeToString(facet->type),
18759: (facet->type != XML_SCHEMA_FACET_TOTALDIGITS) ?
18760: BAD_CAST "nonNegativeInteger" :
18761: BAD_CAST "positiveInteger",
18762: NULL);
18763: }
18764: }
18765: break;
18766:
18767: case XML_SCHEMA_FACET_WHITESPACE:{
18768: if (xmlStrEqual(facet->value, BAD_CAST "preserve")) {
18769: facet->whitespace = XML_SCHEMAS_FACET_PRESERVE;
18770: } else if (xmlStrEqual(facet->value, BAD_CAST "replace")) {
18771: facet->whitespace = XML_SCHEMAS_FACET_REPLACE;
18772: } else if (xmlStrEqual(facet->value, BAD_CAST "collapse")) {
18773: facet->whitespace = XML_SCHEMAS_FACET_COLLAPSE;
18774: } else {
18775: ret = XML_SCHEMAP_INVALID_FACET_VALUE;
18776: /* No error message for RelaxNG. */
18777: if (ctxtGiven) {
18778: /* error was previously: XML_SCHEMAP_INVALID_WHITE_SPACE */
18779: xmlSchemaCustomErr(ACTXT_CAST pctxt,
18780: ret, facet->node, WXS_BASIC_CAST typeDecl,
18781: "The value '%s' of the facet 'whitespace' is not "
18782: "valid", facet->value, NULL);
18783: }
18784: }
18785: }
18786: default:
18787: break;
18788: }
18789: exit:
18790: if ((! ctxtGiven) && (pctxt != NULL))
18791: xmlSchemaFreeParserCtxt(pctxt);
18792: return (ret);
18793: internal_error:
18794: if ((! ctxtGiven) && (pctxt != NULL))
18795: xmlSchemaFreeParserCtxt(pctxt);
18796: return (-1);
18797: }
18798:
18799: /**
18800: * xmlSchemaCheckFacetValues:
18801: * @typeDecl: the schema type definition
18802: * @ctxt: the schema parser context
18803: *
18804: * Checks the default values types, especially for facets
18805: */
18806: static int
18807: xmlSchemaCheckFacetValues(xmlSchemaTypePtr typeDecl,
18808: xmlSchemaParserCtxtPtr pctxt)
18809: {
18810: int res, olderrs = pctxt->nberrors;
18811: const xmlChar *name = typeDecl->name;
18812: /*
18813: * NOTE: It is intended to use the facets list, instead
18814: * of facetSet.
18815: */
18816: if (typeDecl->facets != NULL) {
18817: xmlSchemaFacetPtr facet = typeDecl->facets;
18818:
18819: /*
18820: * Temporarily assign the "schema" to the validation context
18821: * of the parser context. This is needed for NOTATION validation.
18822: */
18823: if (pctxt->vctxt == NULL) {
18824: if (xmlSchemaCreateVCtxtOnPCtxt(pctxt) == -1)
18825: return(-1);
18826: }
18827: pctxt->vctxt->schema = pctxt->schema;
18828: while (facet != NULL) {
18829: res = xmlSchemaCheckFacet(facet, typeDecl, pctxt, name);
18830: HFAILURE
18831: facet = facet->next;
18832: }
18833: pctxt->vctxt->schema = NULL;
18834: }
18835: if (olderrs != pctxt->nberrors)
18836: return(pctxt->err);
18837: return(0);
18838: exit_failure:
18839: return(-1);
18840: }
18841:
18842: /**
18843: * xmlSchemaGetCircModelGrDefRef:
18844: * @ctxtMGroup: the searched model group
18845: * @selfMGroup: the second searched model group
18846: * @particle: the first particle
18847: *
18848: * This one is intended to be used by
18849: * xmlSchemaCheckGroupDefCircular only.
18850: *
18851: * Returns the particle with the circular model group definition reference,
18852: * otherwise NULL.
18853: */
18854: static xmlSchemaTreeItemPtr
18855: xmlSchemaGetCircModelGrDefRef(xmlSchemaModelGroupDefPtr groupDef,
18856: xmlSchemaTreeItemPtr particle)
18857: {
18858: xmlSchemaTreeItemPtr circ = NULL;
18859: xmlSchemaTreeItemPtr term;
18860: xmlSchemaModelGroupDefPtr gdef;
18861:
18862: for (; particle != NULL; particle = particle->next) {
18863: term = particle->children;
18864: if (term == NULL)
18865: continue;
18866: switch (term->type) {
18867: case XML_SCHEMA_TYPE_GROUP:
18868: gdef = (xmlSchemaModelGroupDefPtr) term;
18869: if (gdef == groupDef)
18870: return (particle);
18871: /*
18872: * Mark this model group definition to avoid infinite
18873: * recursion on circular references not yet examined.
18874: */
18875: if (gdef->flags & XML_SCHEMA_MODEL_GROUP_DEF_MARKED)
18876: continue;
18877: if (gdef->children != NULL) {
18878: gdef->flags |= XML_SCHEMA_MODEL_GROUP_DEF_MARKED;
18879: circ = xmlSchemaGetCircModelGrDefRef(groupDef,
18880: gdef->children->children);
18881: gdef->flags ^= XML_SCHEMA_MODEL_GROUP_DEF_MARKED;
18882: if (circ != NULL)
18883: return (circ);
18884: }
18885: break;
18886: case XML_SCHEMA_TYPE_SEQUENCE:
18887: case XML_SCHEMA_TYPE_CHOICE:
18888: case XML_SCHEMA_TYPE_ALL:
18889: circ = xmlSchemaGetCircModelGrDefRef(groupDef, term->children);
18890: if (circ != NULL)
18891: return (circ);
18892: break;
18893: default:
18894: break;
18895: }
18896: }
18897: return (NULL);
18898: }
18899:
18900: /**
18901: * xmlSchemaCheckGroupDefCircular:
18902: * @item: the model group definition
18903: * @ctxt: the parser context
18904: * @name: the name
18905: *
18906: * Checks for circular references to model group definitions.
18907: */
18908: static void
18909: xmlSchemaCheckGroupDefCircular(xmlSchemaModelGroupDefPtr item,
18910: xmlSchemaParserCtxtPtr ctxt)
18911: {
18912: /*
18913: * Schema Component Constraint: Model Group Correct
18914: * 2 Circular groups are disallowed. That is, within the {particles}
18915: * of a group there must not be at any depth a particle whose {term}
18916: * is the group itself.
18917: */
18918: if ((item == NULL) ||
18919: (item->type != XML_SCHEMA_TYPE_GROUP) ||
18920: (item->children == NULL))
18921: return;
18922: {
18923: xmlSchemaTreeItemPtr circ;
18924:
18925: circ = xmlSchemaGetCircModelGrDefRef(item, item->children->children);
18926: if (circ != NULL) {
18927: xmlChar *str = NULL;
18928: /*
18929: * TODO: The error report is not adequate: this constraint
18930: * is defined for model groups but not definitions, but since
18931: * there cannot be any circular model groups without a model group
18932: * definition (if not using a construction API), we check those
18933: * defintions only.
18934: */
18935: xmlSchemaPCustomErr(ctxt,
18936: XML_SCHEMAP_MG_PROPS_CORRECT_2,
18937: NULL, WXS_ITEM_NODE(circ),
18938: "Circular reference to the model group definition '%s' "
18939: "defined", xmlSchemaFormatQName(&str,
18940: item->targetNamespace, item->name));
18941: FREE_AND_NULL(str)
18942: /*
18943: * NOTE: We will cut the reference to avoid further
18944: * confusion of the processor. This is a fatal error.
18945: */
18946: circ->children = NULL;
18947: }
18948: }
18949: }
18950:
18951: /**
18952: * xmlSchemaModelGroupToModelGroupDefFixup:
18953: * @ctxt: the parser context
18954: * @mg: the model group
18955: *
18956: * Assigns the model group of model group definitions to the "term"
18957: * of the referencing particle.
18958: * In xmlSchemaResolveModelGroupParticleReferences the model group
18959: * definitions were assigned to the "term", since needed for the
18960: * circularity check.
18961: *
18962: * Schema Component Constraint:
18963: * All Group Limited (cos-all-limited) (1.2)
18964: */
18965: static void
18966: xmlSchemaModelGroupToModelGroupDefFixup(
18967: xmlSchemaParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
18968: xmlSchemaModelGroupPtr mg)
18969: {
18970: xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
18971:
18972: while (particle != NULL) {
18973: if ((WXS_PARTICLE_TERM(particle) == NULL) ||
18974: ((WXS_PARTICLE_TERM(particle))->type !=
18975: XML_SCHEMA_TYPE_GROUP))
18976: {
18977: particle = WXS_PTC_CAST particle->next;
18978: continue;
18979: }
18980: if (WXS_MODELGROUPDEF_MODEL(WXS_PARTICLE_TERM(particle)) == NULL) {
18981: /*
18982: * TODO: Remove the particle.
18983: */
18984: WXS_PARTICLE_TERM(particle) = NULL;
18985: particle = WXS_PTC_CAST particle->next;
18986: continue;
18987: }
18988: /*
18989: * Assign the model group to the {term} of the particle.
18990: */
18991: WXS_PARTICLE_TERM(particle) =
18992: WXS_TREE_CAST WXS_MODELGROUPDEF_MODEL(WXS_PARTICLE_TERM(particle));
18993:
18994: particle = WXS_PTC_CAST particle->next;
18995: }
18996: }
18997:
18998: /**
18999: * xmlSchemaCheckAttrGroupCircularRecur:
19000: * @ctxtGr: the searched attribute group
19001: * @attr: the current attribute list to be processed
19002: *
19003: * This one is intended to be used by
19004: * xmlSchemaCheckAttrGroupCircular only.
19005: *
19006: * Returns the circular attribute grou reference, otherwise NULL.
19007: */
19008: static xmlSchemaQNameRefPtr
19009: xmlSchemaCheckAttrGroupCircularRecur(xmlSchemaAttributeGroupPtr ctxtGr,
19010: xmlSchemaItemListPtr list)
19011: {
19012: xmlSchemaAttributeGroupPtr gr;
19013: xmlSchemaQNameRefPtr ref, circ;
19014: int i;
19015: /*
19016: * We will search for an attribute group reference which
19017: * references the context attribute group.
19018: */
19019: for (i = 0; i < list->nbItems; i++) {
19020: ref = list->items[i];
19021: if ((ref->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
19022: (ref->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
19023: (ref->item != NULL))
19024: {
19025: gr = WXS_ATTR_GROUP_CAST ref->item;
19026: if (gr == ctxtGr)
19027: return(ref);
19028: if (gr->flags & XML_SCHEMAS_ATTRGROUP_MARKED)
19029: continue;
19030: /*
19031: * Mark as visited to avoid infinite recursion on
19032: * circular references not yet examined.
19033: */
19034: if ((gr->attrUses) &&
19035: (gr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS))
19036: {
19037: gr->flags |= XML_SCHEMAS_ATTRGROUP_MARKED;
19038: circ = xmlSchemaCheckAttrGroupCircularRecur(ctxtGr,
19039: (xmlSchemaItemListPtr) gr->attrUses);
19040: gr->flags ^= XML_SCHEMAS_ATTRGROUP_MARKED;
19041: if (circ != NULL)
19042: return (circ);
19043: }
19044:
19045: }
19046: }
19047: return (NULL);
19048: }
19049:
19050: /**
19051: * xmlSchemaCheckAttrGroupCircular:
19052: * attrGr: the attribute group definition
19053: * @ctxt: the parser context
19054: * @name: the name
19055: *
19056: * Checks for circular references of attribute groups.
19057: */
19058: static int
19059: xmlSchemaCheckAttrGroupCircular(xmlSchemaAttributeGroupPtr attrGr,
19060: xmlSchemaParserCtxtPtr ctxt)
19061: {
19062: /*
19063: * Schema Representation Constraint:
19064: * Attribute Group Definition Representation OK
19065: * 3 Circular group reference is disallowed outside <redefine>.
19066: * That is, unless this element information item's parent is
19067: * <redefine>, then among the [children], if any, there must
19068: * not be an <attributeGroup> with ref [attribute] which resolves
19069: * to the component corresponding to this <attributeGroup>. Indirect
19070: * circularity is also ruled out. That is, when QName resolution
19071: * (Schema Document) (�3.15.3) is applied to a �QName� arising from
19072: * any <attributeGroup>s with a ref [attribute] among the [children],
19073: * it must not be the case that a �QName� is encountered at any depth
19074: * which resolves to the component corresponding to this <attributeGroup>.
19075: */
19076: if (attrGr->attrUses == NULL)
19077: return(0);
19078: else if ((attrGr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS) == 0)
19079: return(0);
19080: else {
19081: xmlSchemaQNameRefPtr circ;
19082:
19083: circ = xmlSchemaCheckAttrGroupCircularRecur(attrGr,
19084: (xmlSchemaItemListPtr) attrGr->attrUses);
19085: if (circ != NULL) {
19086: xmlChar *str = NULL;
19087: /*
19088: * TODO: Report the referenced attr group as QName.
19089: */
19090: xmlSchemaPCustomErr(ctxt,
19091: XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
19092: NULL, WXS_ITEM_NODE(WXS_BASIC_CAST circ),
19093: "Circular reference to the attribute group '%s' "
19094: "defined", xmlSchemaGetComponentQName(&str, attrGr));
19095: FREE_AND_NULL(str);
19096: /*
19097: * NOTE: We will cut the reference to avoid further
19098: * confusion of the processor.
19099: * BADSPEC TODO: The spec should define how to process in this case.
19100: */
19101: circ->item = NULL;
19102: return(ctxt->err);
19103: }
19104: }
19105: return(0);
19106: }
19107:
19108: static int
19109: xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
19110: xmlSchemaAttributeGroupPtr attrGr);
19111:
19112: /**
19113: * xmlSchemaExpandAttributeGroupRefs:
19114: * @pctxt: the parser context
19115: * @node: the node of the component holding the attribute uses
19116: * @completeWild: the intersected wildcard to be returned
19117: * @list: the attribute uses
19118: *
19119: * Substitutes contained attribute group references
19120: * for their attribute uses. Wilcards are intersected.
19121: * Attribute use prohibitions are removed from the list
19122: * and returned via the @prohibs list.
19123: * Pointlessness of attr. prohibs, if a matching attr. decl
19124: * is existent a well, are checked.
19125: */
19126: static int
19127: xmlSchemaExpandAttributeGroupRefs(xmlSchemaParserCtxtPtr pctxt,
19128: xmlSchemaBasicItemPtr item,
19129: xmlSchemaWildcardPtr *completeWild,
19130: xmlSchemaItemListPtr list,
19131: xmlSchemaItemListPtr prohibs)
19132: {
19133: xmlSchemaAttributeGroupPtr gr;
19134: xmlSchemaAttributeUsePtr use;
19135: xmlSchemaItemListPtr sublist;
19136: int i, j;
19137: int created = (*completeWild == NULL) ? 0 : 1;
19138:
19139: if (prohibs)
19140: prohibs->nbItems = 0;
19141:
19142: for (i = 0; i < list->nbItems; i++) {
19143: use = list->items[i];
19144:
19145: if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
19146: if (prohibs == NULL) {
19147: PERROR_INT("xmlSchemaExpandAttributeGroupRefs",
19148: "unexpected attr prohibition found");
19149: return(-1);
19150: }
19151: /*
19152: * Remove from attribute uses.
19153: */
19154: if (xmlSchemaItemListRemove(list, i) == -1)
19155: return(-1);
19156: i--;
19157: /*
19158: * Note that duplicate prohibitions were already
19159: * handled at parsing time.
19160: */
19161: /*
19162: * Add to list of prohibitions.
19163: */
19164: xmlSchemaItemListAddSize(prohibs, 2, use);
19165: continue;
19166: }
19167: if ((use->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
19168: ((WXS_QNAME_CAST use)->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP))
19169: {
19170: if ((WXS_QNAME_CAST use)->item == NULL)
19171: return(-1);
19172: gr = WXS_ATTR_GROUP_CAST (WXS_QNAME_CAST use)->item;
19173: /*
19174: * Expand the referenced attr. group.
19175: * TODO: remove this, this is done in a previous step, so
19176: * already done here.
19177: */
19178: if ((gr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED) == 0) {
19179: if (xmlSchemaAttributeGroupExpandRefs(pctxt, gr) == -1)
19180: return(-1);
19181: }
19182: /*
19183: * Build the 'complete' wildcard; i.e. intersect multiple
19184: * wildcards.
19185: */
19186: if (gr->attributeWildcard != NULL) {
19187: if (*completeWild == NULL) {
19188: *completeWild = gr->attributeWildcard;
19189: } else {
19190: if (! created) {
19191: xmlSchemaWildcardPtr tmpWild;
19192:
19193: /*
19194: * Copy the first encountered wildcard as context,
19195: * except for the annotation.
19196: *
19197: * Although the complete wildcard might not correspond
19198: * to any node in the schema, we will anchor it on
19199: * the node of the owner component.
19200: */
19201: tmpWild = xmlSchemaAddWildcard(pctxt, pctxt->schema,
19202: XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
19203: WXS_ITEM_NODE(item));
19204: if (tmpWild == NULL)
19205: return(-1);
19206: if (xmlSchemaCloneWildcardNsConstraints(pctxt,
19207: tmpWild, *completeWild) == -1)
19208: return (-1);
19209: tmpWild->processContents = (*completeWild)->processContents;
19210: *completeWild = tmpWild;
19211: created = 1;
19212: }
19213:
19214: if (xmlSchemaIntersectWildcards(pctxt, *completeWild,
19215: gr->attributeWildcard) == -1)
19216: return(-1);
19217: }
19218: }
19219: /*
19220: * Just remove the reference if the referenced group does not
19221: * contain any attribute uses.
19222: */
19223: sublist = ((xmlSchemaItemListPtr) gr->attrUses);
19224: if ((sublist == NULL) || sublist->nbItems == 0) {
19225: if (xmlSchemaItemListRemove(list, i) == -1)
19226: return(-1);
19227: i--;
19228: continue;
19229: }
19230: /*
19231: * Add the attribute uses.
19232: */
19233: list->items[i] = sublist->items[0];
19234: if (sublist->nbItems != 1) {
19235: for (j = 1; j < sublist->nbItems; j++) {
19236: i++;
19237: if (xmlSchemaItemListInsert(list,
19238: sublist->items[j], i) == -1)
19239: return(-1);
19240: }
19241: }
19242: }
19243:
19244: }
19245: /*
19246: * Handle pointless prohibitions of declared attributes.
19247: */
19248: if (prohibs && (prohibs->nbItems != 0) && (list->nbItems != 0)) {
19249: xmlSchemaAttributeUseProhibPtr prohib;
19250:
19251: for (i = prohibs->nbItems -1; i >= 0; i--) {
19252: prohib = prohibs->items[i];
19253: for (j = 0; j < list->nbItems; j++) {
19254: use = list->items[j];
19255:
19256: if ((prohib->name == WXS_ATTRUSE_DECL_NAME(use)) &&
19257: (prohib->targetNamespace == WXS_ATTRUSE_DECL_TNS(use)))
19258: {
19259: xmlChar *str = NULL;
19260:
19261: xmlSchemaCustomWarning(ACTXT_CAST pctxt,
19262: XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
19263: prohib->node, NULL,
19264: "Skipping pointless attribute use prohibition "
19265: "'%s', since a corresponding attribute use "
19266: "exists already in the type definition",
19267: xmlSchemaFormatQName(&str,
19268: prohib->targetNamespace, prohib->name),
19269: NULL, NULL);
19270: FREE_AND_NULL(str);
19271: /*
19272: * Remove the prohibition.
19273: */
19274: if (xmlSchemaItemListRemove(prohibs, i) == -1)
19275: return(-1);
19276: break;
19277: }
19278: }
19279: }
19280: }
19281: return(0);
19282: }
19283:
19284: /**
19285: * xmlSchemaAttributeGroupExpandRefs:
19286: * @pctxt: the parser context
19287: * @attrGr: the attribute group definition
19288: *
19289: * Computation of:
19290: * {attribute uses} property
19291: * {attribute wildcard} property
19292: *
19293: * Substitutes contained attribute group references
19294: * for their attribute uses. Wilcards are intersected.
19295: */
19296: static int
19297: xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
19298: xmlSchemaAttributeGroupPtr attrGr)
19299: {
19300: if ((attrGr->attrUses == NULL) ||
19301: (attrGr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED))
19302: return(0);
19303:
19304: attrGr->flags |= XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED;
19305: if (xmlSchemaExpandAttributeGroupRefs(pctxt, WXS_BASIC_CAST attrGr,
19306: &(attrGr->attributeWildcard), attrGr->attrUses, NULL) == -1)
19307: return(-1);
19308: return(0);
19309: }
19310:
19311: /**
19312: * xmlSchemaAttributeGroupExpandRefs:
19313: * @pctxt: the parser context
19314: * @attrGr: the attribute group definition
19315: *
19316: * Substitutes contained attribute group references
19317: * for their attribute uses. Wilcards are intersected.
19318: *
19319: * Schema Component Constraint:
19320: * Attribute Group Definition Properties Correct (ag-props-correct)
19321: */
19322: static int
19323: xmlSchemaCheckAGPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
19324: xmlSchemaAttributeGroupPtr attrGr)
19325: {
19326: /*
19327: * SPEC ag-props-correct
19328: * (1) "The values of the properties of an attribute group definition
19329: * must be as described in the property tableau in The Attribute
19330: * Group Definition Schema Component (�3.6.1), modulo the impact of
19331: * Missing Sub-components (�5.3);"
19332: */
19333:
19334: if ((attrGr->attrUses != NULL) &&
19335: (WXS_LIST_CAST attrGr->attrUses)->nbItems > 1)
19336: {
19337: xmlSchemaItemListPtr uses = WXS_LIST_CAST attrGr->attrUses;
19338: xmlSchemaAttributeUsePtr use, tmp;
19339: int i, j, hasId = 0;
19340:
19341: for (i = uses->nbItems -1; i >= 0; i--) {
19342: use = uses->items[i];
19343: /*
19344: * SPEC ag-props-correct
19345: * (2) "Two distinct members of the {attribute uses} must not have
19346: * {attribute declaration}s both of whose {name}s match and whose
19347: * {target namespace}s are identical."
19348: */
19349: if (i > 0) {
19350: for (j = i -1; j >= 0; j--) {
19351: tmp = uses->items[j];
19352: if ((WXS_ATTRUSE_DECL_NAME(use) ==
19353: WXS_ATTRUSE_DECL_NAME(tmp)) &&
19354: (WXS_ATTRUSE_DECL_TNS(use) ==
19355: WXS_ATTRUSE_DECL_TNS(tmp)))
19356: {
19357: xmlChar *str = NULL;
19358:
19359: xmlSchemaCustomErr(ACTXT_CAST pctxt,
19360: XML_SCHEMAP_AG_PROPS_CORRECT,
19361: attrGr->node, WXS_BASIC_CAST attrGr,
19362: "Duplicate %s",
19363: xmlSchemaGetComponentDesignation(&str, use),
19364: NULL);
19365: FREE_AND_NULL(str);
19366: /*
19367: * Remove the duplicate.
19368: */
19369: if (xmlSchemaItemListRemove(uses, i) == -1)
19370: return(-1);
19371: goto next_use;
19372: }
19373: }
19374: }
19375: /*
19376: * SPEC ag-props-correct
19377: * (3) "Two distinct members of the {attribute uses} must not have
19378: * {attribute declaration}s both of whose {type definition}s are or
19379: * are derived from ID."
19380: * TODO: Does 'derived' include member-types of unions?
19381: */
19382: if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
19383: if (xmlSchemaIsDerivedFromBuiltInType(
19384: WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
19385: {
19386: if (hasId) {
19387: xmlChar *str = NULL;
19388:
19389: xmlSchemaCustomErr(ACTXT_CAST pctxt,
19390: XML_SCHEMAP_AG_PROPS_CORRECT,
19391: attrGr->node, WXS_BASIC_CAST attrGr,
19392: "There must not exist more than one attribute "
19393: "declaration of type 'xs:ID' "
19394: "(or derived from 'xs:ID'). The %s violates this "
19395: "constraint",
19396: xmlSchemaGetComponentDesignation(&str, use),
19397: NULL);
19398: FREE_AND_NULL(str);
19399: if (xmlSchemaItemListRemove(uses, i) == -1)
19400: return(-1);
19401: }
19402: hasId = 1;
19403: }
19404: }
19405: next_use: {}
19406: }
19407: }
19408: return(0);
19409: }
19410:
19411: /**
19412: * xmlSchemaResolveAttrGroupReferences:
19413: * @attrgrpDecl: the schema attribute definition
19414: * @ctxt: the schema parser context
19415: * @name: the attribute name
19416: *
19417: * Resolves references to attribute group definitions.
19418: */
19419: static int
19420: xmlSchemaResolveAttrGroupReferences(xmlSchemaQNameRefPtr ref,
19421: xmlSchemaParserCtxtPtr ctxt)
19422: {
19423: xmlSchemaAttributeGroupPtr group;
19424:
19425: if (ref->item != NULL)
19426: return(0);
19427: group = xmlSchemaGetAttributeGroup(ctxt->schema,
19428: ref->name,
19429: ref->targetNamespace);
19430: if (group == NULL) {
19431: xmlSchemaPResCompAttrErr(ctxt,
19432: XML_SCHEMAP_SRC_RESOLVE,
19433: NULL, ref->node,
19434: "ref", ref->name, ref->targetNamespace,
19435: ref->itemType, NULL);
19436: return(ctxt->err);
19437: }
19438: ref->item = WXS_BASIC_CAST group;
19439: return(0);
19440: }
19441:
19442: /**
19443: * xmlSchemaCheckAttrPropsCorrect:
19444: * @item: an schema attribute declaration/use
19445: * @ctxt: a schema parser context
19446: * @name: the name of the attribute
19447: *
19448: *
19449: * Schema Component Constraint:
19450: * Attribute Declaration Properties Correct (a-props-correct)
19451: *
19452: * Validates the value constraints of an attribute declaration/use.
19453: * NOTE that this needs the simle type definitions to be already
19454: * builded and checked.
19455: */
19456: static int
19457: xmlSchemaCheckAttrPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
19458: xmlSchemaAttributePtr attr)
19459: {
19460:
19461: /*
19462: * SPEC a-props-correct (1)
19463: * "The values of the properties of an attribute declaration must
19464: * be as described in the property tableau in The Attribute
19465: * Declaration Schema Component (�3.2.1), modulo the impact of
19466: * Missing Sub-components (�5.3)."
19467: */
19468:
19469: if (WXS_ATTR_TYPEDEF(attr) == NULL)
19470: return(0);
19471:
19472: if (attr->defValue != NULL) {
19473: int ret;
19474:
19475: /*
19476: * SPEC a-props-correct (3)
19477: * "If the {type definition} is or is derived from ID then there
19478: * must not be a {value constraint}."
19479: */
19480: if (xmlSchemaIsDerivedFromBuiltInType(
19481: WXS_ATTR_TYPEDEF(attr), XML_SCHEMAS_ID))
19482: {
19483: xmlSchemaCustomErr(ACTXT_CAST pctxt,
19484: XML_SCHEMAP_A_PROPS_CORRECT_3,
19485: NULL, WXS_BASIC_CAST attr,
19486: "Value constraints are not allowed if the type definition "
19487: "is or is derived from xs:ID",
19488: NULL, NULL);
19489: return(pctxt->err);
19490: }
19491: /*
19492: * SPEC a-props-correct (2)
19493: * "if there is a {value constraint}, the canonical lexical
19494: * representation of its value must be �valid� with respect
19495: * to the {type definition} as defined in String Valid (�3.14.4)."
19496: * TODO: Don't care about the *cononical* stuff here, this requirement
19497: * will be removed in WXS 1.1 anyway.
19498: */
19499: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt,
19500: attr->node, WXS_ATTR_TYPEDEF(attr),
19501: attr->defValue, &(attr->defVal),
19502: 1, 1, 0);
19503: if (ret != 0) {
19504: if (ret < 0) {
19505: PERROR_INT("xmlSchemaCheckAttrPropsCorrect",
19506: "calling xmlSchemaVCheckCVCSimpleType()");
19507: return(-1);
19508: }
19509: xmlSchemaCustomErr(ACTXT_CAST pctxt,
19510: XML_SCHEMAP_A_PROPS_CORRECT_2,
19511: NULL, WXS_BASIC_CAST attr,
19512: "The value of the value constraint is not valid",
19513: NULL, NULL);
19514: return(pctxt->err);
19515: }
19516: }
19517:
19518: return(0);
19519: }
19520:
19521: static xmlSchemaElementPtr
19522: xmlSchemaCheckSubstGroupCircular(xmlSchemaElementPtr elemDecl,
19523: xmlSchemaElementPtr ancestor)
19524: {
19525: xmlSchemaElementPtr ret;
19526:
19527: if (WXS_SUBST_HEAD(ancestor) == NULL)
19528: return (NULL);
19529: if (WXS_SUBST_HEAD(ancestor) == elemDecl)
19530: return (ancestor);
19531:
19532: if (WXS_SUBST_HEAD(ancestor)->flags & XML_SCHEMAS_ELEM_CIRCULAR)
19533: return (NULL);
19534: WXS_SUBST_HEAD(ancestor)->flags |= XML_SCHEMAS_ELEM_CIRCULAR;
19535: ret = xmlSchemaCheckSubstGroupCircular(elemDecl,
19536: WXS_SUBST_HEAD(ancestor));
19537: WXS_SUBST_HEAD(ancestor)->flags ^= XML_SCHEMAS_ELEM_CIRCULAR;
19538:
19539: return (ret);
19540: }
19541:
19542: /**
19543: * xmlSchemaCheckElemPropsCorrect:
19544: * @ctxt: a schema parser context
19545: * @decl: the element declaration
19546: * @name: the name of the attribute
19547: *
19548: * Schema Component Constraint:
19549: * Element Declaration Properties Correct (e-props-correct)
19550: *
19551: * STATUS:
19552: * missing: (6)
19553: */
19554: static int
19555: xmlSchemaCheckElemPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
19556: xmlSchemaElementPtr elemDecl)
19557: {
19558: int ret = 0;
19559: xmlSchemaTypePtr typeDef = WXS_ELEM_TYPEDEF(elemDecl);
19560: /*
19561: * SPEC (1) "The values of the properties of an element declaration
19562: * must be as described in the property tableau in The Element
19563: * Declaration Schema Component (�3.3.1), modulo the impact of Missing
19564: * Sub-components (�5.3)."
19565: */
19566: if (WXS_SUBST_HEAD(elemDecl) != NULL) {
19567: xmlSchemaElementPtr head = WXS_SUBST_HEAD(elemDecl), circ;
19568:
19569: xmlSchemaCheckElementDeclComponent(head, pctxt);
19570: /*
19571: * SPEC (3) "If there is a non-�absent� {substitution group
19572: * affiliation}, then {scope} must be global."
19573: */
19574: if ((elemDecl->flags & XML_SCHEMAS_ELEM_GLOBAL) == 0) {
19575: xmlSchemaPCustomErr(pctxt,
19576: XML_SCHEMAP_E_PROPS_CORRECT_3,
19577: WXS_BASIC_CAST elemDecl, NULL,
19578: "Only global element declarations can have a "
19579: "substitution group affiliation", NULL);
19580: ret = XML_SCHEMAP_E_PROPS_CORRECT_3;
19581: }
19582: /*
19583: * TODO: SPEC (6) "Circular substitution groups are disallowed.
19584: * That is, it must not be possible to return to an element declaration
19585: * by repeatedly following the {substitution group affiliation}
19586: * property."
19587: */
19588: if (head == elemDecl)
19589: circ = head;
19590: else if (WXS_SUBST_HEAD(head) != NULL)
19591: circ = xmlSchemaCheckSubstGroupCircular(head, head);
19592: else
19593: circ = NULL;
19594: if (circ != NULL) {
19595: xmlChar *strA = NULL, *strB = NULL;
19596:
19597: xmlSchemaPCustomErrExt(pctxt,
19598: XML_SCHEMAP_E_PROPS_CORRECT_6,
19599: WXS_BASIC_CAST circ, NULL,
19600: "The element declaration '%s' defines a circular "
19601: "substitution group to element declaration '%s'",
19602: xmlSchemaGetComponentQName(&strA, circ),
19603: xmlSchemaGetComponentQName(&strB, head),
19604: NULL);
19605: FREE_AND_NULL(strA)
19606: FREE_AND_NULL(strB)
19607: ret = XML_SCHEMAP_E_PROPS_CORRECT_6;
19608: }
19609: /*
19610: * SPEC (4) "If there is a {substitution group affiliation},
19611: * the {type definition}
19612: * of the element declaration must be validly derived from the {type
19613: * definition} of the {substitution group affiliation}, given the value
19614: * of the {substitution group exclusions} of the {substitution group
19615: * affiliation}, as defined in Type Derivation OK (Complex) (�3.4.6)
19616: * (if the {type definition} is complex) or as defined in
19617: * Type Derivation OK (Simple) (�3.14.6) (if the {type definition} is
19618: * simple)."
19619: *
19620: * NOTE: {substitution group exclusions} means the values of the
19621: * attribute "final".
19622: */
19623:
19624: if (typeDef != WXS_ELEM_TYPEDEF(WXS_SUBST_HEAD(elemDecl))) {
19625: int set = 0;
19626:
19627: if (head->flags & XML_SCHEMAS_ELEM_FINAL_EXTENSION)
19628: set |= SUBSET_EXTENSION;
19629: if (head->flags & XML_SCHEMAS_ELEM_FINAL_RESTRICTION)
19630: set |= SUBSET_RESTRICTION;
19631:
19632: if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST pctxt, typeDef,
19633: WXS_ELEM_TYPEDEF(head), set) != 0) {
19634: xmlChar *strA = NULL, *strB = NULL, *strC = NULL;
19635:
19636: ret = XML_SCHEMAP_E_PROPS_CORRECT_4;
19637: xmlSchemaPCustomErrExt(pctxt,
19638: XML_SCHEMAP_E_PROPS_CORRECT_4,
19639: WXS_BASIC_CAST elemDecl, NULL,
19640: "The type definition '%s' was "
19641: "either rejected by the substitution group "
19642: "affiliation '%s', or not validly derived from its type "
19643: "definition '%s'",
19644: xmlSchemaGetComponentQName(&strA, typeDef),
19645: xmlSchemaGetComponentQName(&strB, head),
19646: xmlSchemaGetComponentQName(&strC, WXS_ELEM_TYPEDEF(head)));
19647: FREE_AND_NULL(strA)
19648: FREE_AND_NULL(strB)
19649: FREE_AND_NULL(strC)
19650: }
19651: }
19652: }
19653: /*
19654: * SPEC (5) "If the {type definition} or {type definition}'s
19655: * {content type}
19656: * is or is derived from ID then there must not be a {value constraint}.
19657: * Note: The use of ID as a type definition for elements goes beyond
19658: * XML 1.0, and should be avoided if backwards compatibility is desired"
19659: */
19660: if ((elemDecl->value != NULL) &&
19661: ((WXS_IS_SIMPLE(typeDef) &&
19662: xmlSchemaIsDerivedFromBuiltInType(typeDef, XML_SCHEMAS_ID)) ||
19663: (WXS_IS_COMPLEX(typeDef) &&
19664: WXS_HAS_SIMPLE_CONTENT(typeDef) &&
19665: xmlSchemaIsDerivedFromBuiltInType(typeDef->contentTypeDef,
19666: XML_SCHEMAS_ID)))) {
19667:
19668: ret = XML_SCHEMAP_E_PROPS_CORRECT_5;
19669: xmlSchemaPCustomErr(pctxt,
19670: XML_SCHEMAP_E_PROPS_CORRECT_5,
19671: WXS_BASIC_CAST elemDecl, NULL,
19672: "The type definition (or type definition's content type) is or "
19673: "is derived from ID; value constraints are not allowed in "
19674: "conjunction with such a type definition", NULL);
19675: } else if (elemDecl->value != NULL) {
19676: int vcret;
19677: xmlNodePtr node = NULL;
19678:
19679: /*
19680: * SPEC (2) "If there is a {value constraint}, the canonical lexical
19681: * representation of its value must be �valid� with respect to the
19682: * {type definition} as defined in Element Default Valid (Immediate)
19683: * (�3.3.6)."
19684: */
19685: if (typeDef == NULL) {
19686: xmlSchemaPErr(pctxt, elemDecl->node,
19687: XML_SCHEMAP_INTERNAL,
19688: "Internal error: xmlSchemaCheckElemPropsCorrect, "
19689: "type is missing... skipping validation of "
19690: "the value constraint", NULL, NULL);
19691: return (-1);
19692: }
19693: if (elemDecl->node != NULL) {
19694: if (elemDecl->flags & XML_SCHEMAS_ELEM_FIXED)
19695: node = (xmlNodePtr) xmlHasProp(elemDecl->node,
19696: BAD_CAST "fixed");
19697: else
19698: node = (xmlNodePtr) xmlHasProp(elemDecl->node,
19699: BAD_CAST "default");
19700: }
19701: vcret = xmlSchemaParseCheckCOSValidDefault(pctxt, node,
19702: typeDef, elemDecl->value, &(elemDecl->defVal));
19703: if (vcret != 0) {
19704: if (vcret < 0) {
19705: PERROR_INT("xmlSchemaElemCheckValConstr",
19706: "failed to validate the value constraint of an "
19707: "element declaration");
19708: return (-1);
19709: }
19710: return (vcret);
19711: }
19712: }
19713:
19714: return (ret);
19715: }
19716:
19717: /**
19718: * xmlSchemaCheckElemSubstGroup:
19719: * @ctxt: a schema parser context
19720: * @decl: the element declaration
19721: * @name: the name of the attribute
19722: *
19723: * Schema Component Constraint:
19724: * Substitution Group (cos-equiv-class)
19725: *
19726: * In Libxml2 the subst. groups will be precomputed, in terms of that
19727: * a list will be built for each subst. group head, holding all direct
19728: * referents to this head.
19729: * NOTE that this function needs:
19730: * 1. circular subst. groups to be checked beforehand
19731: * 2. the declaration's type to be derived from the head's type
19732: *
19733: * STATUS:
19734: *
19735: */
19736: static void
19737: xmlSchemaCheckElemSubstGroup(xmlSchemaParserCtxtPtr ctxt,
19738: xmlSchemaElementPtr elemDecl)
19739: {
19740: if ((WXS_SUBST_HEAD(elemDecl) == NULL) ||
19741: /* SPEC (1) "Its {abstract} is false." */
19742: (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT))
19743: return;
19744: {
19745: xmlSchemaElementPtr head;
19746: xmlSchemaTypePtr headType, type;
19747: int set, methSet;
19748: /*
19749: * SPEC (2) "It is validly substitutable for HEAD subject to HEAD's
19750: * {disallowed substitutions} as the blocking constraint, as defined in
19751: * Substitution Group OK (Transitive) (�3.3.6)."
19752: */
19753: for (head = WXS_SUBST_HEAD(elemDecl); head != NULL;
19754: head = WXS_SUBST_HEAD(head)) {
19755: set = 0;
19756: methSet = 0;
19757: /*
19758: * The blocking constraints.
19759: */
19760: if (head->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION)
19761: continue;
19762: headType = head->subtypes;
19763: type = elemDecl->subtypes;
19764: if (headType == type)
19765: goto add_member;
19766: if (head->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION)
19767: set |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
19768: if (head->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION)
19769: set |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
19770: /*
19771: * SPEC: Substitution Group OK (Transitive) (2.3)
19772: * "The set of all {derivation method}s involved in the
19773: * derivation of D's {type definition} from C's {type definition}
19774: * does not intersect with the union of the blocking constraint,
19775: * C's {prohibited substitutions} (if C is complex, otherwise the
19776: * empty set) and the {prohibited substitutions} (respectively the
19777: * empty set) of any intermediate {type definition}s in the
19778: * derivation of D's {type definition} from C's {type definition}."
19779: */
19780: /*
19781: * OPTIMIZE TODO: Optimize this a bit, since, if traversing the
19782: * subst.head axis, the methSet does not need to be computed for
19783: * the full depth over and over.
19784: */
19785: /*
19786: * The set of all {derivation method}s involved in the derivation
19787: */
19788: while ((type != NULL) && (type != headType)) {
19789: if ((WXS_IS_EXTENSION(type)) &&
19790: ((methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
19791: methSet |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
19792:
19793: if (WXS_IS_RESTRICTION(type) &&
19794: ((methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
19795: methSet |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
19796:
19797: type = type->baseType;
19798: }
19799: /*
19800: * The {prohibited substitutions} of all intermediate types +
19801: * the head's type.
19802: */
19803: type = elemDecl->subtypes->baseType;
19804: while (type != NULL) {
19805: if (WXS_IS_COMPLEX(type)) {
19806: if ((type->flags &
19807: XML_SCHEMAS_TYPE_BLOCK_EXTENSION) &&
19808: ((set & XML_SCHEMAS_TYPE_BLOCK_EXTENSION) == 0))
19809: set |= XML_SCHEMAS_TYPE_BLOCK_EXTENSION;
19810: if ((type->flags &
19811: XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) &&
19812: ((set & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) == 0))
19813: set |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
19814: } else
19815: break;
19816: if (type == headType)
19817: break;
19818: type = type->baseType;
19819: }
19820: if ((set != 0) &&
19821: (((set & XML_SCHEMAS_TYPE_BLOCK_EXTENSION) &&
19822: (methSet & XML_SCHEMAS_TYPE_BLOCK_EXTENSION)) ||
19823: ((set & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION) &&
19824: (methSet & XML_SCHEMAS_TYPE_BLOCK_RESTRICTION)))) {
19825: continue;
19826: }
19827: add_member:
19828: xmlSchemaAddElementSubstitutionMember(ctxt, head, elemDecl);
19829: if ((head->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) == 0)
19830: head->flags |= XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD;
19831: }
19832: }
19833: }
19834:
19835: #ifdef WXS_ELEM_DECL_CONS_ENABLED /* enable when finished */
19836: /**
19837: * xmlSchemaCheckElementDeclComponent
19838: * @pctxt: the schema parser context
19839: * @ctxtComponent: the context component (an element declaration)
19840: * @ctxtParticle: the first particle of the context component
19841: * @searchParticle: the element declaration particle to be analysed
19842: *
19843: * Schema Component Constraint: Element Declarations Consistent
19844: */
19845: static int
19846: xmlSchemaCheckElementDeclConsistent(xmlSchemaParserCtxtPtr pctxt,
19847: xmlSchemaBasicItemPtr ctxtComponent,
19848: xmlSchemaParticlePtr ctxtParticle,
19849: xmlSchemaParticlePtr searchParticle,
19850: xmlSchemaParticlePtr curParticle,
19851: int search)
19852: {
19853: return(0);
19854:
19855: int ret = 0;
19856: xmlSchemaParticlePtr cur = curParticle;
19857: if (curParticle == NULL) {
19858: return(0);
19859: }
19860: if (WXS_PARTICLE_TERM(curParticle) == NULL) {
19861: /*
19862: * Just return in this case. A missing "term" of the particle
19863: * might arise due to an invalid "term" component.
19864: */
19865: return(0);
19866: }
19867: while (cur != NULL) {
19868: switch (WXS_PARTICLE_TERM(cur)->type) {
19869: case XML_SCHEMA_TYPE_ANY:
19870: break;
19871: case XML_SCHEMA_TYPE_ELEMENT:
19872: if (search == 0) {
19873: ret = xmlSchemaCheckElementDeclConsistent(pctxt,
19874: ctxtComponent, ctxtParticle, cur, ctxtParticle, 1);
19875: if (ret != 0)
19876: return(ret);
19877: } else {
19878: xmlSchemaElementPtr elem =
19879: WXS_ELEM_CAST(WXS_PARTICLE_TERM(cur));
19880: /*
19881: * SPEC Element Declarations Consistent:
19882: * "If the {particles} contains, either directly,
19883: * indirectly (that is, within the {particles} of a
19884: * contained model group, recursively) or �implicitly�
19885: * two or more element declaration particles with
19886: * the same {name} and {target namespace}, then
19887: * all their type definitions must be the same
19888: * top-level definition [...]"
19889: */
19890: if (xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->name,
19891: WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->name) &&
19892: xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
19893: WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->targetNamespace))
19894: {
19895: xmlChar *strA = NULL, *strB = NULL;
19896:
19897: xmlSchemaCustomErr(ACTXT_CAST pctxt,
19898: /* TODO: error code */
19899: XML_SCHEMAP_COS_NONAMBIG,
19900: WXS_ITEM_NODE(cur), NULL,
19901: "In the content model of %s, there are multiple "
19902: "element declarations for '%s' with different "
19903: "type definitions",
19904: xmlSchemaGetComponentDesignation(&strA,
19905: ctxtComponent),
19906: xmlSchemaFormatQName(&strB,
19907: WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
19908: WXS_PARTICLE_TERM_AS_ELEM(cur)->name));
19909: FREE_AND_NULL(strA);
19910: FREE_AND_NULL(strB);
19911: return(XML_SCHEMAP_COS_NONAMBIG);
19912: }
19913: }
19914: break;
19915: case XML_SCHEMA_TYPE_SEQUENCE: {
19916: break;
19917: }
19918: case XML_SCHEMA_TYPE_CHOICE:{
19919: /*
19920: xmlSchemaTreeItemPtr sub;
19921:
19922: sub = WXS_PARTICLE_TERM(particle)->children; (xmlSchemaParticlePtr)
19923: while (sub != NULL) {
19924: ret = xmlSchemaCheckElementDeclConsistent(pctxt, ctxtComponent,
19925: ctxtParticle, ctxtElem);
19926: if (ret != 0)
19927: return(ret);
19928: sub = sub->next;
19929: }
19930: */
19931: break;
19932: }
19933: case XML_SCHEMA_TYPE_ALL:
19934: break;
19935: case XML_SCHEMA_TYPE_GROUP:
19936: break;
19937: default:
19938: xmlSchemaInternalErr2(ACTXT_CAST pctxt,
19939: "xmlSchemaCheckElementDeclConsistent",
19940: "found unexpected term of type '%s' in content model",
19941: WXS_ITEM_TYPE_NAME(WXS_PARTICLE_TERM(cur)), NULL);
19942: return(-1);
19943: }
19944: cur = (xmlSchemaParticlePtr) cur->next;
19945: }
19946:
19947: exit:
19948: return(ret);
19949: }
19950: #endif
19951:
19952: /**
19953: * xmlSchemaCheckElementDeclComponent
19954: * @item: an schema element declaration/particle
19955: * @ctxt: a schema parser context
19956: * @name: the name of the attribute
19957: *
19958: * Validates the value constraints of an element declaration.
19959: * Adds substitution group members.
19960: */
19961: static void
19962: xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
19963: xmlSchemaParserCtxtPtr ctxt)
19964: {
19965: if (elemDecl == NULL)
19966: return;
19967: if (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED)
19968: return;
19969: elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_CHECKED;
19970: if (xmlSchemaCheckElemPropsCorrect(ctxt, elemDecl) == 0) {
19971: /*
19972: * Adds substitution group members.
19973: */
19974: xmlSchemaCheckElemSubstGroup(ctxt, elemDecl);
19975: }
19976: }
19977:
19978: /**
19979: * xmlSchemaResolveModelGroupParticleReferences:
19980: * @particle: a particle component
19981: * @ctxt: a parser context
19982: *
19983: * Resolves references of a model group's {particles} to
19984: * model group definitions and to element declarations.
19985: */
19986: static void
19987: xmlSchemaResolveModelGroupParticleReferences(
19988: xmlSchemaParserCtxtPtr ctxt,
19989: xmlSchemaModelGroupPtr mg)
19990: {
19991: xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
19992: xmlSchemaQNameRefPtr ref;
19993: xmlSchemaBasicItemPtr refItem;
19994:
19995: /*
19996: * URGENT TODO: Test this.
19997: */
19998: while (particle != NULL) {
19999: if ((WXS_PARTICLE_TERM(particle) == NULL) ||
20000: ((WXS_PARTICLE_TERM(particle))->type !=
20001: XML_SCHEMA_EXTRA_QNAMEREF))
20002: {
20003: goto next_particle;
20004: }
20005: ref = WXS_QNAME_CAST WXS_PARTICLE_TERM(particle);
20006: /*
20007: * Resolve the reference.
20008: * NULL the {term} by default.
20009: */
20010: particle->children = NULL;
20011:
20012: refItem = xmlSchemaGetNamedComponent(ctxt->schema,
20013: ref->itemType, ref->name, ref->targetNamespace);
20014: if (refItem == NULL) {
20015: xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
20016: NULL, WXS_ITEM_NODE(particle), "ref", ref->name,
20017: ref->targetNamespace, ref->itemType, NULL);
20018: /* TODO: remove the particle. */
20019: goto next_particle;
20020: }
20021: if (refItem->type == XML_SCHEMA_TYPE_GROUP) {
20022: if (WXS_MODELGROUPDEF_MODEL(refItem) == NULL)
20023: /* TODO: remove the particle. */
20024: goto next_particle;
20025: /*
20026: * NOTE that we will assign the model group definition
20027: * itself to the "term" of the particle. This will ease
20028: * the check for circular model group definitions. After
20029: * that the "term" will be assigned the model group of the
20030: * model group definition.
20031: */
20032: if ((WXS_MODELGROUPDEF_MODEL(refItem))->type ==
20033: XML_SCHEMA_TYPE_ALL) {
20034: /*
20035: * SPEC cos-all-limited (1)
20036: * SPEC cos-all-limited (1.2)
20037: * "It appears only as the value of one or both of the
20038: * following properties:"
20039: * (1.1) "the {model group} property of a model group
20040: * definition."
20041: * (1.2) "the {term} property of a particle [... of] the "
20042: * {content type} of a complex type definition."
20043: */
20044: xmlSchemaCustomErr(ACTXT_CAST ctxt,
20045: /* TODO: error code */
20046: XML_SCHEMAP_COS_ALL_LIMITED,
20047: WXS_ITEM_NODE(particle), NULL,
20048: "A model group definition is referenced, but "
20049: "it contains an 'all' model group, which "
20050: "cannot be contained by model groups",
20051: NULL, NULL);
20052: /* TODO: remove the particle. */
20053: goto next_particle;
20054: }
20055: particle->children = (xmlSchemaTreeItemPtr) refItem;
20056: } else {
20057: /*
20058: * TODO: Are referenced element declarations the only
20059: * other components we expect here?
20060: */
20061: particle->children = (xmlSchemaTreeItemPtr) refItem;
20062: }
20063: next_particle:
20064: particle = WXS_PTC_CAST particle->next;
20065: }
20066: }
20067:
20068: static int
20069: xmlSchemaAreValuesEqual(xmlSchemaValPtr x,
20070: xmlSchemaValPtr y)
20071: {
20072: xmlSchemaTypePtr tx, ty, ptx, pty;
20073: int ret;
20074:
20075: while (x != NULL) {
20076: /* Same types. */
20077: tx = xmlSchemaGetBuiltInType(xmlSchemaGetValType(x));
20078: ty = xmlSchemaGetBuiltInType(xmlSchemaGetValType(y));
20079: ptx = xmlSchemaGetPrimitiveType(tx);
20080: pty = xmlSchemaGetPrimitiveType(ty);
20081: /*
20082: * (1) if a datatype T' is �derived� by �restriction� from an
20083: * atomic datatype T then the �value space� of T' is a subset of
20084: * the �value space� of T. */
20085: /*
20086: * (2) if datatypes T' and T'' are �derived� by �restriction�
20087: * from a common atomic ancestor T then the �value space�s of T'
20088: * and T'' may overlap.
20089: */
20090: if (ptx != pty)
20091: return(0);
20092: /*
20093: * We assume computed values to be normalized, so do a fast
20094: * string comparison for string based types.
20095: */
20096: if ((ptx->builtInType == XML_SCHEMAS_STRING) ||
20097: WXS_IS_ANY_SIMPLE_TYPE(ptx)) {
20098: if (! xmlStrEqual(
20099: xmlSchemaValueGetAsString(x),
20100: xmlSchemaValueGetAsString(y)))
20101: return (0);
20102: } else {
20103: ret = xmlSchemaCompareValuesWhtsp(
20104: x, XML_SCHEMA_WHITESPACE_PRESERVE,
20105: y, XML_SCHEMA_WHITESPACE_PRESERVE);
20106: if (ret == -2)
20107: return(-1);
20108: if (ret != 0)
20109: return(0);
20110: }
20111: /*
20112: * Lists.
20113: */
20114: x = xmlSchemaValueGetNext(x);
20115: if (x != NULL) {
20116: y = xmlSchemaValueGetNext(y);
20117: if (y == NULL)
20118: return (0);
20119: } else if (xmlSchemaValueGetNext(y) != NULL)
20120: return (0);
20121: else
20122: return (1);
20123: }
20124: return (0);
20125: }
20126:
20127: /**
20128: * xmlSchemaResolveAttrUseReferences:
20129: * @item: an attribute use
20130: * @ctxt: a parser context
20131: *
20132: * Resolves the referenced attribute declaration.
20133: */
20134: static int
20135: xmlSchemaResolveAttrUseReferences(xmlSchemaAttributeUsePtr ause,
20136: xmlSchemaParserCtxtPtr ctxt)
20137: {
20138: if ((ctxt == NULL) || (ause == NULL))
20139: return(-1);
20140: if ((ause->attrDecl == NULL) ||
20141: (ause->attrDecl->type != XML_SCHEMA_EXTRA_QNAMEREF))
20142: return(0);
20143:
20144: {
20145: xmlSchemaQNameRefPtr ref = WXS_QNAME_CAST ause->attrDecl;
20146:
20147: /*
20148: * TODO: Evaluate, what errors could occur if the declaration is not
20149: * found.
20150: */
20151: ause->attrDecl = xmlSchemaGetAttributeDecl(ctxt->schema,
20152: ref->name, ref->targetNamespace);
20153: if (ause->attrDecl == NULL) {
20154: xmlSchemaPResCompAttrErr(ctxt,
20155: XML_SCHEMAP_SRC_RESOLVE,
20156: WXS_BASIC_CAST ause, ause->node,
20157: "ref", ref->name, ref->targetNamespace,
20158: XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
20159: return(ctxt->err);;
20160: }
20161: }
20162: return(0);
20163: }
20164:
20165: /**
20166: * xmlSchemaCheckAttrUsePropsCorrect:
20167: * @ctxt: a parser context
20168: * @use: an attribute use
20169: *
20170: * Schema Component Constraint:
20171: * Attribute Use Correct (au-props-correct)
20172: *
20173: */
20174: static int
20175: xmlSchemaCheckAttrUsePropsCorrect(xmlSchemaParserCtxtPtr ctxt,
20176: xmlSchemaAttributeUsePtr use)
20177: {
20178: if ((ctxt == NULL) || (use == NULL))
20179: return(-1);
20180: if ((use->defValue == NULL) || (WXS_ATTRUSE_DECL(use) == NULL) ||
20181: ((WXS_ATTRUSE_DECL(use))->type != XML_SCHEMA_TYPE_ATTRIBUTE))
20182: return(0);
20183:
20184: /*
20185: * SPEC au-props-correct (1)
20186: * "The values of the properties of an attribute use must be as
20187: * described in the property tableau in The Attribute Use Schema
20188: * Component (�3.5.1), modulo the impact of Missing
20189: * Sub-components (�5.3)."
20190: */
20191:
20192: if (((WXS_ATTRUSE_DECL(use))->defValue != NULL) &&
20193: ((WXS_ATTRUSE_DECL(use))->flags & XML_SCHEMAS_ATTR_FIXED) &&
20194: ((use->flags & XML_SCHEMA_ATTR_USE_FIXED) == 0))
20195: {
20196: xmlSchemaPCustomErr(ctxt,
20197: XML_SCHEMAP_AU_PROPS_CORRECT_2,
20198: WXS_BASIC_CAST use, NULL,
20199: "The attribute declaration has a 'fixed' value constraint "
20200: ", thus the attribute use must also have a 'fixed' value "
20201: "constraint",
20202: NULL);
20203: return(ctxt->err);
20204: }
20205: /*
20206: * Compute and check the value constraint's value.
20207: */
20208: if ((use->defVal != NULL) && (WXS_ATTRUSE_TYPEDEF(use) != NULL)) {
20209: int ret;
20210: /*
20211: * TODO: The spec seems to be missing a check of the
20212: * value constraint of the attribute use. We will do it here.
20213: */
20214: /*
20215: * SPEC a-props-correct (3)
20216: */
20217: if (xmlSchemaIsDerivedFromBuiltInType(
20218: WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
20219: {
20220: xmlSchemaCustomErr(ACTXT_CAST ctxt,
20221: XML_SCHEMAP_AU_PROPS_CORRECT,
20222: NULL, WXS_BASIC_CAST use,
20223: "Value constraints are not allowed if the type definition "
20224: "is or is derived from xs:ID",
20225: NULL, NULL);
20226: return(ctxt->err);
20227: }
20228:
20229: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST ctxt,
20230: use->node, WXS_ATTRUSE_TYPEDEF(use),
20231: use->defValue, &(use->defVal),
20232: 1, 1, 0);
20233: if (ret != 0) {
20234: if (ret < 0) {
20235: PERROR_INT2("xmlSchemaCheckAttrUsePropsCorrect",
20236: "calling xmlSchemaVCheckCVCSimpleType()");
20237: return(-1);
20238: }
20239: xmlSchemaCustomErr(ACTXT_CAST ctxt,
20240: XML_SCHEMAP_AU_PROPS_CORRECT,
20241: NULL, WXS_BASIC_CAST use,
20242: "The value of the value constraint is not valid",
20243: NULL, NULL);
20244: return(ctxt->err);
20245: }
20246: }
20247: /*
20248: * SPEC au-props-correct (2)
20249: * "If the {attribute declaration} has a fixed
20250: * {value constraint}, then if the attribute use itself has a
20251: * {value constraint}, it must also be fixed and its value must match
20252: * that of the {attribute declaration}'s {value constraint}."
20253: */
20254: if (((WXS_ATTRUSE_DECL(use))->defVal != NULL) &&
20255: (((WXS_ATTRUSE_DECL(use))->flags & XML_SCHEMA_ATTR_USE_FIXED) == 0))
20256: {
20257: if (! xmlSchemaAreValuesEqual(use->defVal,
20258: (WXS_ATTRUSE_DECL(use))->defVal))
20259: {
20260: xmlSchemaPCustomErr(ctxt,
20261: XML_SCHEMAP_AU_PROPS_CORRECT_2,
20262: WXS_BASIC_CAST use, NULL,
20263: "The 'fixed' value constraint of the attribute use "
20264: "must match the attribute declaration's value "
20265: "constraint '%s'",
20266: (WXS_ATTRUSE_DECL(use))->defValue);
20267: }
20268: return(ctxt->err);
20269: }
20270: return(0);
20271: }
20272:
20273:
20274:
20275:
20276: /**
20277: * xmlSchemaResolveAttrTypeReferences:
20278: * @item: an attribute declaration
20279: * @ctxt: a parser context
20280: *
20281: * Resolves the referenced type definition component.
20282: */
20283: static int
20284: xmlSchemaResolveAttrTypeReferences(xmlSchemaAttributePtr item,
20285: xmlSchemaParserCtxtPtr ctxt)
20286: {
20287: /*
20288: * The simple type definition corresponding to the <simpleType> element
20289: * information item in the [children], if present, otherwise the simple
20290: * type definition �resolved� to by the �actual value� of the type
20291: * [attribute], if present, otherwise the �simple ur-type definition�.
20292: */
20293: if (item->flags & XML_SCHEMAS_ATTR_INTERNAL_RESOLVED)
20294: return(0);
20295: item->flags |= XML_SCHEMAS_ATTR_INTERNAL_RESOLVED;
20296: if (item->subtypes != NULL)
20297: return(0);
20298: if (item->typeName != NULL) {
20299: xmlSchemaTypePtr type;
20300:
20301: type = xmlSchemaGetType(ctxt->schema, item->typeName,
20302: item->typeNs);
20303: if ((type == NULL) || (! WXS_IS_SIMPLE(type))) {
20304: xmlSchemaPResCompAttrErr(ctxt,
20305: XML_SCHEMAP_SRC_RESOLVE,
20306: WXS_BASIC_CAST item, item->node,
20307: "type", item->typeName, item->typeNs,
20308: XML_SCHEMA_TYPE_SIMPLE, NULL);
20309: return(ctxt->err);
20310: } else
20311: item->subtypes = type;
20312:
20313: } else {
20314: /*
20315: * The type defaults to the xs:anySimpleType.
20316: */
20317: item->subtypes = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
20318: }
20319: return(0);
20320: }
20321:
20322: /**
20323: * xmlSchemaResolveIDCKeyReferences:
20324: * @idc: the identity-constraint definition
20325: * @ctxt: the schema parser context
20326: * @name: the attribute name
20327: *
20328: * Resolve keyRef references to key/unique IDCs.
20329: * Schema Component Constraint:
20330: * Identity-constraint Definition Properties Correct (c-props-correct)
20331: */
20332: static int
20333: xmlSchemaResolveIDCKeyReferences(xmlSchemaIDCPtr idc,
20334: xmlSchemaParserCtxtPtr pctxt)
20335: {
20336: if (idc->type != XML_SCHEMA_TYPE_IDC_KEYREF)
20337: return(0);
20338: if (idc->ref->name != NULL) {
20339: idc->ref->item = (xmlSchemaBasicItemPtr)
20340: xmlSchemaGetIDC(pctxt->schema, idc->ref->name,
20341: idc->ref->targetNamespace);
20342: if (idc->ref->item == NULL) {
20343: /*
20344: * TODO: It is actually not an error to fail to resolve
20345: * at this stage. BUT we need to be that strict!
20346: */
20347: xmlSchemaPResCompAttrErr(pctxt,
20348: XML_SCHEMAP_SRC_RESOLVE,
20349: WXS_BASIC_CAST idc, idc->node,
20350: "refer", idc->ref->name,
20351: idc->ref->targetNamespace,
20352: XML_SCHEMA_TYPE_IDC_KEY, NULL);
20353: return(pctxt->err);
20354: } else if (idc->ref->item->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
20355: /*
20356: * SPEC c-props-correct (1)
20357: */
20358: xmlSchemaCustomErr(ACTXT_CAST pctxt,
20359: XML_SCHEMAP_C_PROPS_CORRECT,
20360: NULL, WXS_BASIC_CAST idc,
20361: "The keyref references a keyref",
20362: NULL, NULL);
20363: idc->ref->item = NULL;
20364: return(pctxt->err);
20365: } else {
20366: if (idc->nbFields !=
20367: ((xmlSchemaIDCPtr) idc->ref->item)->nbFields) {
20368: xmlChar *str = NULL;
20369: xmlSchemaIDCPtr refer;
20370:
20371: refer = (xmlSchemaIDCPtr) idc->ref->item;
20372: /*
20373: * SPEC c-props-correct(2)
20374: * "If the {identity-constraint category} is keyref,
20375: * the cardinality of the {fields} must equal that of
20376: * the {fields} of the {referenced key}.
20377: */
20378: xmlSchemaCustomErr(ACTXT_CAST pctxt,
20379: XML_SCHEMAP_C_PROPS_CORRECT,
20380: NULL, WXS_BASIC_CAST idc,
20381: "The cardinality of the keyref differs from the "
20382: "cardinality of the referenced key/unique '%s'",
20383: xmlSchemaFormatQName(&str, refer->targetNamespace,
20384: refer->name),
20385: NULL);
20386: FREE_AND_NULL(str)
20387: return(pctxt->err);
20388: }
20389: }
20390: }
20391: return(0);
20392: }
20393:
20394: static int
20395: xmlSchemaResolveAttrUseProhibReferences(xmlSchemaAttributeUseProhibPtr prohib,
20396: xmlSchemaParserCtxtPtr pctxt)
20397: {
20398: if (xmlSchemaGetAttributeDecl(pctxt->schema, prohib->name,
20399: prohib->targetNamespace) == NULL) {
20400:
20401: xmlSchemaPResCompAttrErr(pctxt,
20402: XML_SCHEMAP_SRC_RESOLVE,
20403: NULL, prohib->node,
20404: "ref", prohib->name, prohib->targetNamespace,
20405: XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
20406: return(XML_SCHEMAP_SRC_RESOLVE);
20407: }
20408: return(0);
20409: }
20410:
20411: #define WXS_REDEFINED_TYPE(c) \
20412: (((xmlSchemaTypePtr) item)->flags & XML_SCHEMAS_TYPE_REDEFINED)
20413:
20414: #define WXS_REDEFINED_MODEL_GROUP_DEF(c) \
20415: (((xmlSchemaModelGroupDefPtr) item)->flags & XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED)
20416:
20417: #define WXS_REDEFINED_ATTR_GROUP(c) \
20418: (((xmlSchemaAttributeGroupPtr) item)->flags & XML_SCHEMAS_ATTRGROUP_REDEFINED)
20419:
20420: static int
20421: xmlSchemaCheckSRCRedefineFirst(xmlSchemaParserCtxtPtr pctxt)
20422: {
20423: int err = 0;
20424: xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
20425: xmlSchemaBasicItemPtr prev, item;
20426: int wasRedefined;
20427:
20428: if (redef == NULL)
20429: return(0);
20430:
20431: do {
20432: item = redef->item;
20433: /*
20434: * First try to locate the redefined component in the
20435: * schema graph starting with the redefined schema.
20436: * NOTE: According to this schema bug entry:
20437: * http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005OctDec/0019.html
20438: * it's not clear if the referenced component needs to originate
20439: * from the <redefine>d schema _document_ or the schema; the latter
20440: * would include all imported and included sub-schemas of the
20441: * <redefine>d schema. Currenlty we latter approach is used.
20442: * SUPPLEMENT: It seems that the WG moves towards the latter
20443: * approach, so we are doing it right.
20444: *
20445: */
20446: prev = xmlSchemaFindRedefCompInGraph(
20447: redef->targetBucket, item->type,
20448: redef->refName, redef->refTargetNs);
20449: if (prev == NULL) {
20450: xmlChar *str = NULL;
20451: xmlNodePtr node;
20452:
20453: /*
20454: * SPEC src-redefine:
20455: * (6.2.1) "The �actual value� of its own name attribute plus
20456: * target namespace must successfully �resolve� to a model
20457: * group definition in I."
20458: * (7.2.1) "The �actual value� of its own name attribute plus
20459: * target namespace must successfully �resolve� to an attribute
20460: * group definition in I."
20461:
20462: *
20463: * Note that, if we are redefining with the use of references
20464: * to components, the spec assumes the src-resolve to be used;
20465: * but this won't assure that we search only *inside* the
20466: * redefined schema.
20467: */
20468: if (redef->reference)
20469: node = WXS_ITEM_NODE(redef->reference);
20470: else
20471: node = WXS_ITEM_NODE(item);
20472: xmlSchemaCustomErr(ACTXT_CAST pctxt,
20473: /*
20474: * TODO: error code.
20475: * Probably XML_SCHEMAP_SRC_RESOLVE, if this is using the
20476: * reference kind.
20477: */
20478: XML_SCHEMAP_SRC_REDEFINE, node, NULL,
20479: "The %s '%s' to be redefined could not be found in "
20480: "the redefined schema",
20481: WXS_ITEM_TYPE_NAME(item),
20482: xmlSchemaFormatQName(&str, redef->refTargetNs,
20483: redef->refName));
20484: FREE_AND_NULL(str);
20485: err = pctxt->err;
20486: redef = redef->next;
20487: continue;
20488: }
20489: /*
20490: * TODO: Obtaining and setting the redefinition state is really
20491: * clumsy.
20492: */
20493: wasRedefined = 0;
20494: switch (item->type) {
20495: case XML_SCHEMA_TYPE_COMPLEX:
20496: case XML_SCHEMA_TYPE_SIMPLE:
20497: if ((WXS_TYPE_CAST prev)->flags &
20498: XML_SCHEMAS_TYPE_REDEFINED)
20499: {
20500: wasRedefined = 1;
20501: break;
20502: }
20503: /* Mark it as redefined. */
20504: (WXS_TYPE_CAST prev)->flags |= XML_SCHEMAS_TYPE_REDEFINED;
20505: /*
20506: * Assign the redefined type to the
20507: * base type of the redefining type.
20508: * TODO: How
20509: */
20510: ((xmlSchemaTypePtr) item)->baseType =
20511: (xmlSchemaTypePtr) prev;
20512: break;
20513: case XML_SCHEMA_TYPE_GROUP:
20514: if ((WXS_MODEL_GROUPDEF_CAST prev)->flags &
20515: XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED)
20516: {
20517: wasRedefined = 1;
20518: break;
20519: }
20520: /* Mark it as redefined. */
20521: (WXS_MODEL_GROUPDEF_CAST prev)->flags |=
20522: XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED;
20523: if (redef->reference != NULL) {
20524: /*
20525: * Overwrite the QName-reference with the
20526: * referenced model group def.
20527: */
20528: (WXS_PTC_CAST redef->reference)->children =
20529: WXS_TREE_CAST prev;
20530: }
20531: redef->target = prev;
20532: break;
20533: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
20534: if ((WXS_ATTR_GROUP_CAST prev)->flags &
20535: XML_SCHEMAS_ATTRGROUP_REDEFINED)
20536: {
20537: wasRedefined = 1;
20538: break;
20539: }
20540: (WXS_ATTR_GROUP_CAST prev)->flags |=
20541: XML_SCHEMAS_ATTRGROUP_REDEFINED;
20542: if (redef->reference != NULL) {
20543: /*
20544: * Assign the redefined attribute group to the
20545: * QName-reference component.
20546: * This is the easy case, since we will just
20547: * expand the redefined group.
20548: */
20549: (WXS_QNAME_CAST redef->reference)->item = prev;
20550: redef->target = NULL;
20551: } else {
20552: /*
20553: * This is the complicated case: we need
20554: * to apply src-redefine (7.2.2) at a later
20555: * stage, i.e. when attribute group references
20556: * have beed expanded and simple types have
20557: * beed fixed.
20558: */
20559: redef->target = prev;
20560: }
20561: break;
20562: default:
20563: PERROR_INT("xmlSchemaResolveRedefReferences",
20564: "Unexpected redefined component type");
20565: return(-1);
20566: }
20567: if (wasRedefined) {
20568: xmlChar *str = NULL;
20569: xmlNodePtr node;
20570:
20571: if (redef->reference)
20572: node = WXS_ITEM_NODE(redef->reference);
20573: else
20574: node = WXS_ITEM_NODE(redef->item);
20575:
20576: xmlSchemaCustomErr(ACTXT_CAST pctxt,
20577: /* TODO: error code. */
20578: XML_SCHEMAP_SRC_REDEFINE,
20579: node, NULL,
20580: "The referenced %s was already redefined. Multiple "
20581: "redefinition of the same component is not supported",
20582: xmlSchemaGetComponentDesignation(&str, prev),
20583: NULL);
20584: FREE_AND_NULL(str)
20585: err = pctxt->err;
20586: redef = redef->next;
20587: continue;
20588: }
20589: redef = redef->next;
20590: } while (redef != NULL);
20591:
20592: return(err);
20593: }
20594:
20595: static int
20596: xmlSchemaCheckSRCRedefineSecond(xmlSchemaParserCtxtPtr pctxt)
20597: {
20598: int err = 0;
20599: xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
20600: xmlSchemaBasicItemPtr item;
20601:
20602: if (redef == NULL)
20603: return(0);
20604:
20605: do {
20606: if (redef->target == NULL) {
20607: redef = redef->next;
20608: continue;
20609: }
20610: item = redef->item;
20611:
20612: switch (item->type) {
20613: case XML_SCHEMA_TYPE_SIMPLE:
20614: case XML_SCHEMA_TYPE_COMPLEX:
20615: /*
20616: * Since the spec wants the {name} of the redefined
20617: * type to be 'absent', we'll NULL it.
20618: */
20619: (WXS_TYPE_CAST redef->target)->name = NULL;
20620:
20621: /*
20622: * TODO: Seems like there's nothing more to do. The normal
20623: * inheritance mechanism is used. But not 100% sure.
20624: */
20625: break;
20626: case XML_SCHEMA_TYPE_GROUP:
20627: /*
20628: * URGENT TODO:
20629: * SPEC src-redefine:
20630: * (6.2.2) "The {model group} of the model group definition
20631: * which corresponds to it per XML Representation of Model
20632: * Group Definition Schema Components (�3.7.2) must be a
20633: * �valid restriction� of the {model group} of that model
20634: * group definition in I, as defined in Particle Valid
20635: * (Restriction) (�3.9.6)."
20636: */
20637: break;
20638: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
20639: /*
20640: * SPEC src-redefine:
20641: * (7.2.2) "The {attribute uses} and {attribute wildcard} of
20642: * the attribute group definition which corresponds to it
20643: * per XML Representation of Attribute Group Definition Schema
20644: * Components (�3.6.2) must be �valid restrictions� of the
20645: * {attribute uses} and {attribute wildcard} of that attribute
20646: * group definition in I, as defined in clause 2, clause 3 and
20647: * clause 4 of Derivation Valid (Restriction, Complex)
20648: * (�3.4.6) (where references to the base type definition are
20649: * understood as references to the attribute group definition
20650: * in I)."
20651: */
20652: err = xmlSchemaCheckDerivationOKRestriction2to4(pctxt,
20653: XML_SCHEMA_ACTION_REDEFINE,
20654: item, redef->target,
20655: (WXS_ATTR_GROUP_CAST item)->attrUses,
20656: (WXS_ATTR_GROUP_CAST redef->target)->attrUses,
20657: (WXS_ATTR_GROUP_CAST item)->attributeWildcard,
20658: (WXS_ATTR_GROUP_CAST redef->target)->attributeWildcard);
20659: if (err == -1)
20660: return(-1);
20661: break;
20662: default:
20663: break;
20664: }
20665: redef = redef->next;
20666: } while (redef != NULL);
20667: return(0);
20668: }
20669:
20670:
20671: static int
20672: xmlSchemaAddComponents(xmlSchemaParserCtxtPtr pctxt,
20673: xmlSchemaBucketPtr bucket)
20674: {
20675: xmlSchemaBasicItemPtr item;
20676: int err;
20677: xmlHashTablePtr *table;
20678: const xmlChar *name;
20679: int i;
20680:
20681: #define WXS_GET_GLOBAL_HASH(c, slot) { \
20682: if (WXS_IS_BUCKET_IMPMAIN((c)->type)) \
20683: table = &(WXS_IMPBUCKET((c))->schema->slot); \
20684: else \
20685: table = &(WXS_INCBUCKET((c))->ownerImport->schema->slot); }
20686:
20687: /*
20688: * Add global components to the schema's hash tables.
20689: * This is the place where duplicate components will be
20690: * detected.
20691: * TODO: I think normally we should support imports of the
20692: * same namespace from multiple locations. We don't do currently,
20693: * but if we do then according to:
20694: * http://www.w3.org/Bugs/Public/show_bug.cgi?id=2224
20695: * we would need, if imported directly, to import redefined
20696: * components as well to be able to catch clashing components.
20697: * (I hope I'll still know what this means after some months :-()
20698: */
20699: if (bucket == NULL)
20700: return(-1);
20701: if (bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED)
20702: return(0);
20703: bucket->flags |= XML_SCHEMA_BUCKET_COMPS_ADDED;
20704:
20705: for (i = 0; i < bucket->globals->nbItems; i++) {
20706: item = bucket->globals->items[i];
20707: table = NULL;
20708: switch (item->type) {
20709: case XML_SCHEMA_TYPE_COMPLEX:
20710: case XML_SCHEMA_TYPE_SIMPLE:
20711: if (WXS_REDEFINED_TYPE(item))
20712: continue;
20713: name = (WXS_TYPE_CAST item)->name;
20714: WXS_GET_GLOBAL_HASH(bucket, typeDecl)
20715: break;
20716: case XML_SCHEMA_TYPE_ELEMENT:
20717: name = (WXS_ELEM_CAST item)->name;
20718: WXS_GET_GLOBAL_HASH(bucket, elemDecl)
20719: break;
20720: case XML_SCHEMA_TYPE_ATTRIBUTE:
20721: name = (WXS_ATTR_CAST item)->name;
20722: WXS_GET_GLOBAL_HASH(bucket, attrDecl)
20723: break;
20724: case XML_SCHEMA_TYPE_GROUP:
20725: if (WXS_REDEFINED_MODEL_GROUP_DEF(item))
20726: continue;
20727: name = (WXS_MODEL_GROUPDEF_CAST item)->name;
20728: WXS_GET_GLOBAL_HASH(bucket, groupDecl)
20729: break;
20730: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
20731: if (WXS_REDEFINED_ATTR_GROUP(item))
20732: continue;
20733: name = (WXS_ATTR_GROUP_CAST item)->name;
20734: WXS_GET_GLOBAL_HASH(bucket, attrgrpDecl)
20735: break;
20736: case XML_SCHEMA_TYPE_IDC_KEY:
20737: case XML_SCHEMA_TYPE_IDC_UNIQUE:
20738: case XML_SCHEMA_TYPE_IDC_KEYREF:
20739: name = (WXS_IDC_CAST item)->name;
20740: WXS_GET_GLOBAL_HASH(bucket, idcDef)
20741: break;
20742: case XML_SCHEMA_TYPE_NOTATION:
20743: name = ((xmlSchemaNotationPtr) item)->name;
20744: WXS_GET_GLOBAL_HASH(bucket, notaDecl)
20745: break;
20746: default:
20747: PERROR_INT("xmlSchemaAddComponents",
20748: "Unexpected global component type");
20749: continue;
20750: }
20751: if (*table == NULL) {
20752: *table = xmlHashCreateDict(10, pctxt->dict);
20753: if (*table == NULL) {
20754: PERROR_INT("xmlSchemaAddComponents",
20755: "failed to create a component hash table");
20756: return(-1);
20757: }
20758: }
20759: err = xmlHashAddEntry(*table, name, item);
20760: if (err != 0) {
20761: xmlChar *str = NULL;
20762:
20763: xmlSchemaCustomErr(ACTXT_CAST pctxt,
20764: XML_SCHEMAP_REDEFINED_TYPE,
20765: WXS_ITEM_NODE(item),
20766: WXS_BASIC_CAST item,
20767: "A global %s '%s' does already exist",
20768: WXS_ITEM_TYPE_NAME(item),
20769: xmlSchemaGetComponentQName(&str, item));
20770: FREE_AND_NULL(str);
20771: }
20772: }
20773: /*
20774: * Process imported/included schemas.
20775: */
20776: if (bucket->relations != NULL) {
20777: xmlSchemaSchemaRelationPtr rel = bucket->relations;
20778: do {
20779: if ((rel->bucket != NULL) &&
20780: ((rel->bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED) == 0)) {
20781: if (xmlSchemaAddComponents(pctxt, rel->bucket) == -1)
20782: return(-1);
20783: }
20784: rel = rel->next;
20785: } while (rel != NULL);
20786: }
20787: return(0);
20788: }
20789:
20790: static int
20791: xmlSchemaFixupComponents(xmlSchemaParserCtxtPtr pctxt,
20792: xmlSchemaBucketPtr rootBucket)
20793: {
20794: xmlSchemaConstructionCtxtPtr con = pctxt->constructor;
20795: xmlSchemaTreeItemPtr item, *items;
20796: int nbItems, i, ret = 0;
20797: xmlSchemaBucketPtr oldbucket = con->bucket;
20798: xmlSchemaElementPtr elemDecl;
20799:
20800: #define FIXHFAILURE if (pctxt->err == XML_SCHEMAP_INTERNAL) goto exit_failure;
20801:
20802: if ((con->pending == NULL) ||
20803: (con->pending->nbItems == 0))
20804: return(0);
20805:
20806: /*
20807: * Since xmlSchemaFixupComplexType() will create new particles
20808: * (local components), and those particle components need a bucket
20809: * on the constructor, we'll assure here that the constructor has
20810: * a bucket.
20811: * TODO: Think about storing locals _only_ on the main bucket.
20812: */
20813: if (con->bucket == NULL)
20814: con->bucket = rootBucket;
20815:
20816: /* TODO:
20817: * SPEC (src-redefine):
20818: * (6.2) "If it has no such self-reference, then all of the
20819: * following must be true:"
20820:
20821: * (6.2.2) The {model group} of the model group definition which
20822: * corresponds to it per XML Representation of Model Group
20823: * Definition Schema Components (�3.7.2) must be a �valid
20824: * restriction� of the {model group} of that model group definition
20825: * in I, as defined in Particle Valid (Restriction) (�3.9.6)."
20826: */
20827: xmlSchemaCheckSRCRedefineFirst(pctxt);
20828:
20829: /*
20830: * Add global components to the schemata's hash tables.
20831: */
20832: xmlSchemaAddComponents(pctxt, rootBucket);
20833:
20834: pctxt->ctxtType = NULL;
20835: items = (xmlSchemaTreeItemPtr *) con->pending->items;
20836: nbItems = con->pending->nbItems;
20837: /*
20838: * Now that we have parsed *all* the schema document(s) and converted
20839: * them to schema components, we can resolve references, apply component
20840: * constraints, create the FSA from the content model, etc.
20841: */
20842: /*
20843: * Resolve references of..
20844: *
20845: * 1. element declarations:
20846: * - the type definition
20847: * - the substitution group affiliation
20848: * 2. simple/complex types:
20849: * - the base type definition
20850: * - the memberTypes of union types
20851: * - the itemType of list types
20852: * 3. attributes declarations and attribute uses:
20853: * - the type definition
20854: * - if an attribute use, then the attribute declaration
20855: * 4. attribute group references:
20856: * - the attribute group definition
20857: * 5. particles:
20858: * - the term of the particle (e.g. a model group)
20859: * 6. IDC key-references:
20860: * - the referenced IDC 'key' or 'unique' definition
20861: * 7. Attribute prohibitions which had a "ref" attribute.
20862: */
20863: for (i = 0; i < nbItems; i++) {
20864: item = items[i];
20865: switch (item->type) {
20866: case XML_SCHEMA_TYPE_ELEMENT:
20867: xmlSchemaResolveElementReferences(
20868: (xmlSchemaElementPtr) item, pctxt);
20869: FIXHFAILURE;
20870: break;
20871: case XML_SCHEMA_TYPE_COMPLEX:
20872: case XML_SCHEMA_TYPE_SIMPLE:
20873: xmlSchemaResolveTypeReferences(
20874: (xmlSchemaTypePtr) item, pctxt);
20875: FIXHFAILURE;
20876: break;
20877: case XML_SCHEMA_TYPE_ATTRIBUTE:
20878: xmlSchemaResolveAttrTypeReferences(
20879: (xmlSchemaAttributePtr) item, pctxt);
20880: FIXHFAILURE;
20881: break;
20882: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
20883: xmlSchemaResolveAttrUseReferences(
20884: (xmlSchemaAttributeUsePtr) item, pctxt);
20885: FIXHFAILURE;
20886: break;
20887: case XML_SCHEMA_EXTRA_QNAMEREF:
20888: if ((WXS_QNAME_CAST item)->itemType ==
20889: XML_SCHEMA_TYPE_ATTRIBUTEGROUP)
20890: {
20891: xmlSchemaResolveAttrGroupReferences(
20892: WXS_QNAME_CAST item, pctxt);
20893: }
20894: FIXHFAILURE;
20895: break;
20896: case XML_SCHEMA_TYPE_SEQUENCE:
20897: case XML_SCHEMA_TYPE_CHOICE:
20898: case XML_SCHEMA_TYPE_ALL:
20899: xmlSchemaResolveModelGroupParticleReferences(pctxt,
20900: WXS_MODEL_GROUP_CAST item);
20901: FIXHFAILURE;
20902: break;
20903: case XML_SCHEMA_TYPE_IDC_KEY:
20904: case XML_SCHEMA_TYPE_IDC_UNIQUE:
20905: case XML_SCHEMA_TYPE_IDC_KEYREF:
20906: xmlSchemaResolveIDCKeyReferences(
20907: (xmlSchemaIDCPtr) item, pctxt);
20908: FIXHFAILURE;
20909: break;
20910: case XML_SCHEMA_EXTRA_ATTR_USE_PROHIB:
20911: /*
20912: * Handle attribue prohibition which had a
20913: * "ref" attribute.
20914: */
20915: xmlSchemaResolveAttrUseProhibReferences(
20916: WXS_ATTR_PROHIB_CAST item, pctxt);
20917: FIXHFAILURE;
20918: break;
20919: default:
20920: break;
20921: }
20922: }
20923: if (pctxt->nberrors != 0)
20924: goto exit_error;
20925:
20926: /*
20927: * Now that all references are resolved we
20928: * can check for circularity of...
20929: * 1. the base axis of type definitions
20930: * 2. nested model group definitions
20931: * 3. nested attribute group definitions
20932: * TODO: check for circual substitution groups.
20933: */
20934: for (i = 0; i < nbItems; i++) {
20935: item = items[i];
20936: /*
20937: * Let's better stop on the first error here.
20938: */
20939: switch (item->type) {
20940: case XML_SCHEMA_TYPE_COMPLEX:
20941: case XML_SCHEMA_TYPE_SIMPLE:
20942: xmlSchemaCheckTypeDefCircular(
20943: (xmlSchemaTypePtr) item, pctxt);
20944: FIXHFAILURE;
20945: if (pctxt->nberrors != 0)
20946: goto exit_error;
20947: break;
20948: case XML_SCHEMA_TYPE_GROUP:
20949: xmlSchemaCheckGroupDefCircular(
20950: (xmlSchemaModelGroupDefPtr) item, pctxt);
20951: FIXHFAILURE;
20952: if (pctxt->nberrors != 0)
20953: goto exit_error;
20954: break;
20955: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
20956: xmlSchemaCheckAttrGroupCircular(
20957: (xmlSchemaAttributeGroupPtr) item, pctxt);
20958: FIXHFAILURE;
20959: if (pctxt->nberrors != 0)
20960: goto exit_error;
20961: break;
20962: default:
20963: break;
20964: }
20965: }
20966: if (pctxt->nberrors != 0)
20967: goto exit_error;
20968: /*
20969: * Model group definition references:
20970: * Such a reference is reflected by a particle at the component
20971: * level. Until now the 'term' of such particles pointed
20972: * to the model group definition; this was done, in order to
20973: * ease circularity checks. Now we need to set the 'term' of
20974: * such particles to the model group of the model group definition.
20975: */
20976: for (i = 0; i < nbItems; i++) {
20977: item = items[i];
20978: switch (item->type) {
20979: case XML_SCHEMA_TYPE_SEQUENCE:
20980: case XML_SCHEMA_TYPE_CHOICE:
20981: xmlSchemaModelGroupToModelGroupDefFixup(pctxt,
20982: WXS_MODEL_GROUP_CAST item);
20983: break;
20984: default:
20985: break;
20986: }
20987: }
20988: if (pctxt->nberrors != 0)
20989: goto exit_error;
20990: /*
20991: * Expand attribute group references of attribute group definitions.
20992: */
20993: for (i = 0; i < nbItems; i++) {
20994: item = items[i];
20995: switch (item->type) {
20996: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
20997: if ((! WXS_ATTR_GROUP_EXPANDED(item)) &&
20998: WXS_ATTR_GROUP_HAS_REFS(item))
20999: {
21000: xmlSchemaAttributeGroupExpandRefs(pctxt,
21001: WXS_ATTR_GROUP_CAST item);
21002: FIXHFAILURE;
21003: }
21004: break;
21005: default:
21006: break;
21007: }
21008: }
21009: if (pctxt->nberrors != 0)
21010: goto exit_error;
21011: /*
21012: * First compute the variety of simple types. This is needed as
21013: * a seperate step, since otherwise we won't be able to detect
21014: * circular union types in all cases.
21015: */
21016: for (i = 0; i < nbItems; i++) {
21017: item = items[i];
21018: switch (item->type) {
21019: case XML_SCHEMA_TYPE_SIMPLE:
21020: if (WXS_IS_TYPE_NOT_FIXED_1((xmlSchemaTypePtr) item)) {
21021: xmlSchemaFixupSimpleTypeStageOne(pctxt,
21022: (xmlSchemaTypePtr) item);
21023: FIXHFAILURE;
21024: }
21025: break;
21026: default:
21027: break;
21028: }
21029: }
21030: if (pctxt->nberrors != 0)
21031: goto exit_error;
21032: /*
21033: * Detect circular union types. Note that this needs the variety to
21034: * be already computed.
21035: */
21036: for (i = 0; i < nbItems; i++) {
21037: item = items[i];
21038: switch (item->type) {
21039: case XML_SCHEMA_TYPE_SIMPLE:
21040: if (((xmlSchemaTypePtr) item)->memberTypes != NULL) {
21041: xmlSchemaCheckUnionTypeDefCircular(pctxt,
21042: (xmlSchemaTypePtr) item);
21043: FIXHFAILURE;
21044: }
21045: break;
21046: default:
21047: break;
21048: }
21049: }
21050: if (pctxt->nberrors != 0)
21051: goto exit_error;
21052:
21053: /*
21054: * Do the complete type fixup for simple types.
21055: */
21056: for (i = 0; i < nbItems; i++) {
21057: item = items[i];
21058: switch (item->type) {
21059: case XML_SCHEMA_TYPE_SIMPLE:
21060: if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
21061: xmlSchemaFixupSimpleTypeStageTwo(pctxt, WXS_TYPE_CAST item);
21062: FIXHFAILURE;
21063: }
21064: break;
21065: default:
21066: break;
21067: }
21068: }
21069: if (pctxt->nberrors != 0)
21070: goto exit_error;
21071: /*
21072: * At this point we need build and check all simple types.
21073: */
21074: /*
21075: * Apply contraints for attribute declarations.
21076: */
21077: for (i = 0; i < nbItems; i++) {
21078: item = items[i];
21079: switch (item->type) {
21080: case XML_SCHEMA_TYPE_ATTRIBUTE:
21081: xmlSchemaCheckAttrPropsCorrect(pctxt, WXS_ATTR_CAST item);
21082: FIXHFAILURE;
21083: break;
21084: default:
21085: break;
21086: }
21087: }
21088: if (pctxt->nberrors != 0)
21089: goto exit_error;
21090: /*
21091: * Apply constraints for attribute uses.
21092: */
21093: for (i = 0; i < nbItems; i++) {
21094: item = items[i];
21095: switch (item->type) {
21096: case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
21097: if (((xmlSchemaAttributeUsePtr)item)->defValue != NULL) {
21098: xmlSchemaCheckAttrUsePropsCorrect(pctxt,
21099: WXS_ATTR_USE_CAST item);
21100: FIXHFAILURE;
21101: }
21102: break;
21103: default:
21104: break;
21105: }
21106: }
21107: if (pctxt->nberrors != 0)
21108: goto exit_error;
21109:
21110: /*
21111: * Apply constraints for attribute group definitions.
21112: */
21113: for (i = 0; i < nbItems; i++) {
21114: item = items[i];
21115: switch (item->type) {
21116: case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
21117: if (( (WXS_ATTR_GROUP_CAST item)->attrUses != NULL) &&
21118: ( (WXS_LIST_CAST (WXS_ATTR_GROUP_CAST item)->attrUses)->nbItems > 1))
21119: {
21120: xmlSchemaCheckAGPropsCorrect(pctxt, WXS_ATTR_GROUP_CAST item);
21121: FIXHFAILURE;
21122: }
21123: break;
21124: default:
21125: break;
21126: }
21127: }
21128: if (pctxt->nberrors != 0)
21129: goto exit_error;
21130:
21131: /*
21132: * Apply constraints for redefinitions.
21133: */
21134: if (WXS_CONSTRUCTOR(pctxt)->redefs != NULL)
21135: xmlSchemaCheckSRCRedefineSecond(pctxt);
21136: if (pctxt->nberrors != 0)
21137: goto exit_error;
21138:
21139: /*
21140: * Complex types are builded and checked.
21141: */
21142: for (i = 0; i < nbItems; i++) {
21143: item = con->pending->items[i];
21144: switch (item->type) {
21145: case XML_SCHEMA_TYPE_COMPLEX:
21146: if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
21147: xmlSchemaFixupComplexType(pctxt, WXS_TYPE_CAST item);
21148: FIXHFAILURE;
21149: }
21150: break;
21151: default:
21152: break;
21153: }
21154: }
21155: if (pctxt->nberrors != 0)
21156: goto exit_error;
21157:
21158: /*
21159: * The list could have changed, since xmlSchemaFixupComplexType()
21160: * will create particles and model groups in some cases.
21161: */
21162: items = (xmlSchemaTreeItemPtr *) con->pending->items;
21163: nbItems = con->pending->nbItems;
21164:
21165: /*
21166: * Apply some constraints for element declarations.
21167: */
21168: for (i = 0; i < nbItems; i++) {
21169: item = items[i];
21170: switch (item->type) {
21171: case XML_SCHEMA_TYPE_ELEMENT:
21172: elemDecl = (xmlSchemaElementPtr) item;
21173:
21174: if ((elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED) == 0)
21175: {
21176: xmlSchemaCheckElementDeclComponent(
21177: (xmlSchemaElementPtr) elemDecl, pctxt);
21178: FIXHFAILURE;
21179: }
21180:
21181: #ifdef WXS_ELEM_DECL_CONS_ENABLED
21182: /*
21183: * Schema Component Constraint: Element Declarations Consistent
21184: * Apply this constraint to local types of element declarations.
21185: */
21186: if ((WXS_ELEM_TYPEDEF(elemDecl) != NULL) &&
21187: (WXS_IS_COMPLEX(WXS_ELEM_TYPEDEF(elemDecl))) &&
21188: (WXS_TYPE_IS_LOCAL(WXS_ELEM_TYPEDEF(elemDecl))))
21189: {
21190: xmlSchemaCheckElementDeclConsistent(pctxt,
21191: WXS_BASIC_CAST elemDecl,
21192: WXS_TYPE_PARTICLE(WXS_ELEM_TYPEDEF(elemDecl)),
21193: NULL, NULL, 0);
21194: }
21195: #endif
21196: break;
21197: default:
21198: break;
21199: }
21200: }
21201: if (pctxt->nberrors != 0)
21202: goto exit_error;
21203:
21204: /*
21205: * Finally we can build the automaton from the content model of
21206: * complex types.
21207: */
21208:
21209: for (i = 0; i < nbItems; i++) {
21210: item = items[i];
21211: switch (item->type) {
21212: case XML_SCHEMA_TYPE_COMPLEX:
21213: xmlSchemaBuildContentModel((xmlSchemaTypePtr) item, pctxt);
21214: /* FIXHFAILURE; */
21215: break;
21216: default:
21217: break;
21218: }
21219: }
21220: if (pctxt->nberrors != 0)
21221: goto exit_error;
21222: /*
21223: * URGENT TODO: cos-element-consistent
21224: */
21225: goto exit;
21226:
21227: exit_error:
21228: ret = pctxt->err;
21229: goto exit;
21230:
21231: exit_failure:
21232: ret = -1;
21233:
21234: exit:
21235: /*
21236: * Reset the constructor. This is needed for XSI acquisition, since
21237: * those items will be processed over and over again for every XSI
21238: * if not cleared here.
21239: */
21240: con->bucket = oldbucket;
21241: con->pending->nbItems = 0;
21242: if (con->substGroups != NULL) {
21243: xmlHashFree(con->substGroups,
21244: (xmlHashDeallocator) xmlSchemaSubstGroupFree);
21245: con->substGroups = NULL;
21246: }
21247: if (con->redefs != NULL) {
21248: xmlSchemaRedefListFree(con->redefs);
21249: con->redefs = NULL;
21250: }
21251: return(ret);
21252: }
21253: /**
21254: * xmlSchemaParse:
21255: * @ctxt: a schema validation context
21256: *
21257: * parse a schema definition resource and build an internal
21258: * XML Shema struture which can be used to validate instances.
21259: *
21260: * Returns the internal XML Schema structure built from the resource or
21261: * NULL in case of error
21262: */
21263: xmlSchemaPtr
21264: xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
21265: {
21266: xmlSchemaPtr mainSchema = NULL;
21267: xmlSchemaBucketPtr bucket = NULL;
21268: int res;
21269:
21270: /*
21271: * This one is used if the schema to be parsed was specified via
21272: * the API; i.e. not automatically by the validated instance document.
21273: */
21274:
21275: xmlSchemaInitTypes();
21276:
21277: if (ctxt == NULL)
21278: return (NULL);
21279:
21280: /* TODO: Init the context. Is this all we need?*/
21281: ctxt->nberrors = 0;
21282: ctxt->err = 0;
21283: ctxt->counter = 0;
21284:
21285: /* Create the *main* schema. */
21286: mainSchema = xmlSchemaNewSchema(ctxt);
21287: if (mainSchema == NULL)
21288: goto exit_failure;
21289: /*
21290: * Create the schema constructor.
21291: */
21292: if (ctxt->constructor == NULL) {
21293: ctxt->constructor = xmlSchemaConstructionCtxtCreate(ctxt->dict);
21294: if (ctxt->constructor == NULL)
21295: return(NULL);
21296: /* Take ownership of the constructor to be able to free it. */
21297: ctxt->ownsConstructor = 1;
21298: }
21299: ctxt->constructor->mainSchema = mainSchema;
21300: /*
21301: * Locate and add the schema document.
21302: */
21303: res = xmlSchemaAddSchemaDoc(ctxt, XML_SCHEMA_SCHEMA_MAIN,
21304: ctxt->URL, ctxt->doc, ctxt->buffer, ctxt->size, NULL,
21305: NULL, NULL, &bucket);
21306: if (res == -1)
21307: goto exit_failure;
21308: if (res != 0)
21309: goto exit;
21310:
21311: if (bucket == NULL) {
21312: /* TODO: Error code, actually we failed to *locate* the schema. */
21313: if (ctxt->URL)
21314: xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
21315: NULL, NULL,
21316: "Failed to locate the main schema resource at '%s'",
21317: ctxt->URL, NULL);
21318: else
21319: xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
21320: NULL, NULL,
21321: "Failed to locate the main schema resource",
21322: NULL, NULL);
21323: goto exit;
21324: }
21325: /* Then do the parsing for good. */
21326: if (xmlSchemaParseNewDocWithContext(ctxt, mainSchema, bucket) == -1)
21327: goto exit_failure;
21328: if (ctxt->nberrors != 0)
21329: goto exit;
21330:
21331: mainSchema->doc = bucket->doc;
21332: mainSchema->preserve = ctxt->preserve;
21333:
21334: ctxt->schema = mainSchema;
21335:
21336: if (xmlSchemaFixupComponents(ctxt, WXS_CONSTRUCTOR(ctxt)->mainBucket) == -1)
21337: goto exit_failure;
21338:
21339: /*
21340: * TODO: This is not nice, since we cannot distinguish from the
21341: * result if there was an internal error or not.
21342: */
21343: exit:
21344: if (ctxt->nberrors != 0) {
21345: if (mainSchema) {
21346: xmlSchemaFree(mainSchema);
21347: mainSchema = NULL;
21348: }
21349: if (ctxt->constructor) {
21350: xmlSchemaConstructionCtxtFree(ctxt->constructor);
21351: ctxt->constructor = NULL;
21352: ctxt->ownsConstructor = 0;
21353: }
21354: }
21355: ctxt->schema = NULL;
21356: return(mainSchema);
21357: exit_failure:
21358: /*
21359: * Quite verbose, but should catch internal errors, which were
21360: * not communitated.
21361: */
21362: if (mainSchema) {
21363: xmlSchemaFree(mainSchema);
21364: mainSchema = NULL;
21365: }
21366: if (ctxt->constructor) {
21367: xmlSchemaConstructionCtxtFree(ctxt->constructor);
21368: ctxt->constructor = NULL;
21369: ctxt->ownsConstructor = 0;
21370: }
21371: PERROR_INT2("xmlSchemaParse",
21372: "An internal error occured");
21373: ctxt->schema = NULL;
21374: return(NULL);
21375: }
21376:
21377: /**
21378: * xmlSchemaSetParserErrors:
21379: * @ctxt: a schema validation context
21380: * @err: the error callback
21381: * @warn: the warning callback
21382: * @ctx: contextual data for the callbacks
21383: *
21384: * Set the callback functions used to handle errors for a validation context
21385: */
21386: void
21387: xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
21388: xmlSchemaValidityErrorFunc err,
21389: xmlSchemaValidityWarningFunc warn, void *ctx)
21390: {
21391: if (ctxt == NULL)
21392: return;
21393: ctxt->error = err;
21394: ctxt->warning = warn;
21395: ctxt->errCtxt = ctx;
21396: if (ctxt->vctxt != NULL)
21397: xmlSchemaSetValidErrors(ctxt->vctxt, err, warn, ctx);
21398: }
21399:
21400: /**
21401: * xmlSchemaSetParserStructuredErrors:
21402: * @ctxt: a schema parser context
21403: * @serror: the structured error function
21404: * @ctx: the functions context
21405: *
21406: * Set the structured error callback
21407: */
21408: void
21409: xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt,
21410: xmlStructuredErrorFunc serror,
21411: void *ctx)
21412: {
21413: if (ctxt == NULL)
21414: return;
21415: ctxt->serror = serror;
21416: ctxt->errCtxt = ctx;
21417: if (ctxt->vctxt != NULL)
21418: xmlSchemaSetValidStructuredErrors(ctxt->vctxt, serror, ctx);
21419: }
21420:
21421: /**
21422: * xmlSchemaGetParserErrors:
21423: * @ctxt: a XMl-Schema parser context
21424: * @err: the error callback result
21425: * @warn: the warning callback result
21426: * @ctx: contextual data for the callbacks result
21427: *
21428: * Get the callback information used to handle errors for a parser context
21429: *
21430: * Returns -1 in case of failure, 0 otherwise
21431: */
21432: int
21433: xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
21434: xmlSchemaValidityErrorFunc * err,
21435: xmlSchemaValidityWarningFunc * warn, void **ctx)
21436: {
21437: if (ctxt == NULL)
21438: return(-1);
21439: if (err != NULL)
21440: *err = ctxt->error;
21441: if (warn != NULL)
21442: *warn = ctxt->warning;
21443: if (ctx != NULL)
21444: *ctx = ctxt->errCtxt;
21445: return(0);
21446: }
21447:
21448: /**
21449: * xmlSchemaFacetTypeToString:
21450: * @type: the facet type
21451: *
21452: * Convert the xmlSchemaTypeType to a char string.
21453: *
21454: * Returns the char string representation of the facet type if the
21455: * type is a facet and an "Internal Error" string otherwise.
21456: */
21457: static const xmlChar *
21458: xmlSchemaFacetTypeToString(xmlSchemaTypeType type)
21459: {
21460: switch (type) {
21461: case XML_SCHEMA_FACET_PATTERN:
21462: return (BAD_CAST "pattern");
21463: case XML_SCHEMA_FACET_MAXEXCLUSIVE:
21464: return (BAD_CAST "maxExclusive");
21465: case XML_SCHEMA_FACET_MAXINCLUSIVE:
21466: return (BAD_CAST "maxInclusive");
21467: case XML_SCHEMA_FACET_MINEXCLUSIVE:
21468: return (BAD_CAST "minExclusive");
21469: case XML_SCHEMA_FACET_MININCLUSIVE:
21470: return (BAD_CAST "minInclusive");
21471: case XML_SCHEMA_FACET_WHITESPACE:
21472: return (BAD_CAST "whiteSpace");
21473: case XML_SCHEMA_FACET_ENUMERATION:
21474: return (BAD_CAST "enumeration");
21475: case XML_SCHEMA_FACET_LENGTH:
21476: return (BAD_CAST "length");
21477: case XML_SCHEMA_FACET_MAXLENGTH:
21478: return (BAD_CAST "maxLength");
21479: case XML_SCHEMA_FACET_MINLENGTH:
21480: return (BAD_CAST "minLength");
21481: case XML_SCHEMA_FACET_TOTALDIGITS:
21482: return (BAD_CAST "totalDigits");
21483: case XML_SCHEMA_FACET_FRACTIONDIGITS:
21484: return (BAD_CAST "fractionDigits");
21485: default:
21486: break;
21487: }
21488: return (BAD_CAST "Internal Error");
21489: }
21490:
21491: static xmlSchemaWhitespaceValueType
21492: xmlSchemaGetWhiteSpaceFacetValue(xmlSchemaTypePtr type)
21493: {
21494: /*
21495: * The normalization type can be changed only for types which are derived
21496: * from xsd:string.
21497: */
21498: if (type->type == XML_SCHEMA_TYPE_BASIC) {
21499: /*
21500: * Note that we assume a whitespace of preserve for anySimpleType.
21501: */
21502: if ((type->builtInType == XML_SCHEMAS_STRING) ||
21503: (type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE))
21504: return(XML_SCHEMA_WHITESPACE_PRESERVE);
21505: else if (type->builtInType == XML_SCHEMAS_NORMSTRING)
21506: return(XML_SCHEMA_WHITESPACE_REPLACE);
21507: else {
21508: /*
21509: * For all �atomic� datatypes other than string (and types �derived�
21510: * by �restriction� from it) the value of whiteSpace is fixed to
21511: * collapse
21512: * Note that this includes built-in list datatypes.
21513: */
21514: return(XML_SCHEMA_WHITESPACE_COLLAPSE);
21515: }
21516: } else if (WXS_IS_LIST(type)) {
21517: /*
21518: * For list types the facet "whiteSpace" is fixed to "collapse".
21519: */
21520: return (XML_SCHEMA_WHITESPACE_COLLAPSE);
21521: } else if (WXS_IS_UNION(type)) {
21522: return (XML_SCHEMA_WHITESPACE_UNKNOWN);
21523: } else if (WXS_IS_ATOMIC(type)) {
21524: if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE)
21525: return (XML_SCHEMA_WHITESPACE_PRESERVE);
21526: else if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_REPLACE)
21527: return (XML_SCHEMA_WHITESPACE_REPLACE);
21528: else
21529: return (XML_SCHEMA_WHITESPACE_COLLAPSE);
21530: }
21531: return (-1);
21532: }
21533:
21534: /************************************************************************
21535: * *
21536: * Simple type validation *
21537: * *
21538: ************************************************************************/
21539:
21540:
21541: /************************************************************************
21542: * *
21543: * DOM Validation code *
21544: * *
21545: ************************************************************************/
21546:
21547: /**
21548: * xmlSchemaAssembleByLocation:
21549: * @pctxt: a schema parser context
21550: * @vctxt: a schema validation context
21551: * @schema: the existing schema
21552: * @node: the node that fired the assembling
21553: * @nsName: the namespace name of the new schema
21554: * @location: the location of the schema
21555: *
21556: * Expands an existing schema by an additional schema.
21557: *
21558: * Returns 0 if the new schema is correct, a positive error code
21559: * number otherwise and -1 in case of an internal or API error.
21560: */
21561: static int
21562: xmlSchemaAssembleByLocation(xmlSchemaValidCtxtPtr vctxt,
21563: xmlSchemaPtr schema,
21564: xmlNodePtr node,
21565: const xmlChar *nsName,
21566: const xmlChar *location)
21567: {
21568: int ret = 0;
21569: xmlSchemaParserCtxtPtr pctxt;
21570: xmlSchemaBucketPtr bucket = NULL;
21571:
21572: if ((vctxt == NULL) || (schema == NULL))
21573: return (-1);
21574:
21575: if (vctxt->pctxt == NULL) {
21576: VERROR_INT("xmlSchemaAssembleByLocation",
21577: "no parser context available");
21578: return(-1);
21579: }
21580: pctxt = vctxt->pctxt;
21581: if (pctxt->constructor == NULL) {
21582: PERROR_INT("xmlSchemaAssembleByLocation",
21583: "no constructor");
21584: return(-1);
21585: }
21586: /*
21587: * Acquire the schema document.
21588: */
21589: location = xmlSchemaBuildAbsoluteURI(pctxt->dict,
21590: location, node);
21591: /*
21592: * Note that we pass XML_SCHEMA_SCHEMA_IMPORT here;
21593: * the process will automatically change this to
21594: * XML_SCHEMA_SCHEMA_MAIN if it is the first schema document.
21595: */
21596: ret = xmlSchemaAddSchemaDoc(pctxt, XML_SCHEMA_SCHEMA_IMPORT,
21597: location, NULL, NULL, 0, node, NULL, nsName,
21598: &bucket);
21599: if (ret != 0)
21600: return(ret);
21601: if (bucket == NULL) {
21602: /*
21603: * Generate a warning that the document could not be located.
21604: */
21605: xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
21606: node, NULL,
21607: "The document at location '%s' could not be acquired",
21608: location, NULL, NULL);
21609: return(ret);
21610: }
21611: /*
21612: * The first located schema will be handled as if all other
21613: * schemas imported by XSI were imported by this first schema.
21614: */
21615: if ((bucket != NULL) &&
21616: (WXS_CONSTRUCTOR(pctxt)->bucket == NULL))
21617: WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
21618: /*
21619: * TODO: Is this handled like an import? I.e. is it not an error
21620: * if the schema cannot be located?
21621: */
21622: if ((bucket == NULL) || (! CAN_PARSE_SCHEMA(bucket)))
21623: return(0);
21624: /*
21625: * We will reuse the parser context for every schema imported
21626: * directly via XSI. So reset the context.
21627: */
21628: pctxt->nberrors = 0;
21629: pctxt->err = 0;
21630: pctxt->doc = bucket->doc;
21631:
21632: ret = xmlSchemaParseNewDocWithContext(pctxt, schema, bucket);
21633: if (ret == -1) {
21634: pctxt->doc = NULL;
21635: goto exit_failure;
21636: }
21637: /* Paranoid error channelling. */
21638: if ((ret == 0) && (pctxt->nberrors != 0))
21639: ret = pctxt->err;
21640: if (pctxt->nberrors == 0) {
21641: /*
21642: * Only bother to fixup pending components, if there was
21643: * no error yet.
21644: * For every XSI acquired schema (and its sub-schemata) we will
21645: * fixup the components.
21646: */
21647: xmlSchemaFixupComponents(pctxt, bucket);
21648: ret = pctxt->err;
21649: /*
21650: * Not nice, but we need somehow to channel the schema parser
21651: * error to the validation context.
21652: */
21653: if ((ret != 0) && (vctxt->err == 0))
21654: vctxt->err = ret;
21655: vctxt->nberrors += pctxt->nberrors;
21656: } else {
21657: /* Add to validation error sum. */
21658: vctxt->nberrors += pctxt->nberrors;
21659: }
21660: pctxt->doc = NULL;
21661: return(ret);
21662: exit_failure:
21663: pctxt->doc = NULL;
21664: return (-1);
21665: }
21666:
21667: static xmlSchemaAttrInfoPtr
21668: xmlSchemaGetMetaAttrInfo(xmlSchemaValidCtxtPtr vctxt,
21669: int metaType)
21670: {
21671: if (vctxt->nbAttrInfos == 0)
21672: return (NULL);
21673: {
21674: int i;
21675: xmlSchemaAttrInfoPtr iattr;
21676:
21677: for (i = 0; i < vctxt->nbAttrInfos; i++) {
21678: iattr = vctxt->attrInfos[i];
21679: if (iattr->metaType == metaType)
21680: return (iattr);
21681: }
21682:
21683: }
21684: return (NULL);
21685: }
21686:
21687: /**
21688: * xmlSchemaAssembleByXSI:
21689: * @vctxt: a schema validation context
21690: *
21691: * Expands an existing schema by an additional schema using
21692: * the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute
21693: * of an instance. If xsi:noNamespaceSchemaLocation is used, @noNamespace
21694: * must be set to 1.
21695: *
21696: * Returns 0 if the new schema is correct, a positive error code
21697: * number otherwise and -1 in case of an internal or API error.
21698: */
21699: static int
21700: xmlSchemaAssembleByXSI(xmlSchemaValidCtxtPtr vctxt)
21701: {
21702: const xmlChar *cur, *end;
21703: const xmlChar *nsname = NULL, *location;
21704: int count = 0;
21705: int ret = 0;
21706: xmlSchemaAttrInfoPtr iattr;
21707:
21708: /*
21709: * Parse the value; we will assume an even number of values
21710: * to be given (this is how Xerces and XSV work).
21711: *
21712: * URGENT TODO: !! This needs to work for both
21713: * @noNamespaceSchemaLocation AND @schemaLocation on the same
21714: * element !!
21715: */
21716: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
21717: XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC);
21718: if (iattr == NULL)
21719: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
21720: XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC);
21721: if (iattr == NULL)
21722: return (0);
21723: cur = iattr->value;
21724: do {
21725: /*
21726: * TODO: Move the string parsing mechanism away from here.
21727: */
21728: if (iattr->metaType == XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC) {
21729: /*
21730: * Get the namespace name.
21731: */
21732: while (IS_BLANK_CH(*cur))
21733: cur++;
21734: end = cur;
21735: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
21736: end++;
21737: if (end == cur)
21738: break;
21739: count++; /* TODO: Don't use the schema's dict. */
21740: nsname = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
21741: cur = end;
21742: }
21743: /*
21744: * Get the URI.
21745: */
21746: while (IS_BLANK_CH(*cur))
21747: cur++;
21748: end = cur;
21749: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
21750: end++;
21751: if (end == cur) {
21752: if (iattr->metaType ==
21753: XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC)
21754: {
21755: /*
21756: * If using @schemaLocation then tuples are expected.
21757: * I.e. the namespace name *and* the document's URI.
21758: */
21759: xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
21760: iattr->node, NULL,
21761: "The value must consist of tuples: the target namespace "
21762: "name and the document's URI", NULL, NULL, NULL);
21763: }
21764: break;
21765: }
21766: count++; /* TODO: Don't use the schema's dict. */
21767: location = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
21768: cur = end;
21769: ret = xmlSchemaAssembleByLocation(vctxt, vctxt->schema,
21770: iattr->node, nsname, location);
21771: if (ret == -1) {
21772: VERROR_INT("xmlSchemaAssembleByXSI",
21773: "assembling schemata");
21774: return (-1);
21775: }
21776: } while (*cur != 0);
21777: return (ret);
21778: }
21779:
21780: static const xmlChar *
21781: xmlSchemaLookupNamespace(xmlSchemaValidCtxtPtr vctxt,
21782: const xmlChar *prefix)
21783: {
21784: if (vctxt->sax != NULL) {
21785: int i, j;
21786: xmlSchemaNodeInfoPtr inode;
21787:
21788: for (i = vctxt->depth; i >= 0; i--) {
21789: if (vctxt->elemInfos[i]->nbNsBindings != 0) {
21790: inode = vctxt->elemInfos[i];
21791: for (j = 0; j < inode->nbNsBindings * 2; j += 2) {
21792: if (((prefix == NULL) &&
21793: (inode->nsBindings[j] == NULL)) ||
21794: ((prefix != NULL) && xmlStrEqual(prefix,
21795: inode->nsBindings[j]))) {
21796:
21797: /*
21798: * Note that the namespace bindings are already
21799: * in a string dict.
21800: */
21801: return (inode->nsBindings[j+1]);
21802: }
21803: }
21804: }
21805: }
21806: return (NULL);
21807: #ifdef LIBXML_READER_ENABLED
21808: } else if (vctxt->reader != NULL) {
21809: xmlChar *nsName;
21810:
21811: nsName = xmlTextReaderLookupNamespace(vctxt->reader, prefix);
21812: if (nsName != NULL) {
21813: const xmlChar *ret;
21814:
21815: ret = xmlDictLookup(vctxt->dict, nsName, -1);
21816: xmlFree(nsName);
21817: return (ret);
21818: } else
21819: return (NULL);
21820: #endif
21821: } else {
21822: xmlNsPtr ns;
21823:
21824: if ((vctxt->inode->node == NULL) ||
21825: (vctxt->inode->node->doc == NULL)) {
21826: VERROR_INT("xmlSchemaLookupNamespace",
21827: "no node or node's doc avaliable");
21828: return (NULL);
21829: }
21830: ns = xmlSearchNs(vctxt->inode->node->doc,
21831: vctxt->inode->node, prefix);
21832: if (ns != NULL)
21833: return (ns->href);
21834: return (NULL);
21835: }
21836: }
21837:
21838: /*
21839: * This one works on the schema of the validation context.
21840: */
21841: static int
21842: xmlSchemaValidateNotation(xmlSchemaValidCtxtPtr vctxt,
21843: xmlSchemaPtr schema,
21844: xmlNodePtr node,
21845: const xmlChar *value,
21846: xmlSchemaValPtr *val,
21847: int valNeeded)
21848: {
21849: int ret;
21850:
21851: if (vctxt && (vctxt->schema == NULL)) {
21852: VERROR_INT("xmlSchemaValidateNotation",
21853: "a schema is needed on the validation context");
21854: return (-1);
21855: }
21856: ret = xmlValidateQName(value, 1);
21857: if (ret != 0)
21858: return (ret);
21859: {
21860: xmlChar *localName = NULL;
21861: xmlChar *prefix = NULL;
21862:
21863: localName = xmlSplitQName2(value, &prefix);
21864: if (prefix != NULL) {
21865: const xmlChar *nsName = NULL;
21866:
21867: if (vctxt != NULL)
21868: nsName = xmlSchemaLookupNamespace(vctxt, BAD_CAST prefix);
21869: else if (node != NULL) {
21870: xmlNsPtr ns = xmlSearchNs(node->doc, node, prefix);
21871: if (ns != NULL)
21872: nsName = ns->href;
21873: } else {
21874: xmlFree(prefix);
21875: xmlFree(localName);
21876: return (1);
21877: }
21878: if (nsName == NULL) {
21879: xmlFree(prefix);
21880: xmlFree(localName);
21881: return (1);
21882: }
21883: if (xmlSchemaGetNotation(schema, localName, nsName) != NULL) {
21884: if ((valNeeded) && (val != NULL)) {
21885: (*val) = xmlSchemaNewNOTATIONValue(xmlStrdup(localName),
21886: xmlStrdup(nsName));
21887: if (*val == NULL)
21888: ret = -1;
21889: }
21890: } else
21891: ret = 1;
21892: xmlFree(prefix);
21893: xmlFree(localName);
21894: } else {
21895: if (xmlSchemaGetNotation(schema, value, NULL) != NULL) {
21896: if (valNeeded && (val != NULL)) {
21897: (*val) = xmlSchemaNewNOTATIONValue(
21898: BAD_CAST xmlStrdup(value), NULL);
21899: if (*val == NULL)
21900: ret = -1;
21901: }
21902: } else
21903: return (1);
21904: }
21905: }
21906: return (ret);
21907: }
21908:
21909: static int
21910: xmlSchemaVAddNodeQName(xmlSchemaValidCtxtPtr vctxt,
21911: const xmlChar* lname,
21912: const xmlChar* nsname)
21913: {
21914: int i;
21915:
21916: lname = xmlDictLookup(vctxt->dict, lname, -1);
21917: if (lname == NULL)
21918: return(-1);
21919: if (nsname != NULL) {
21920: nsname = xmlDictLookup(vctxt->dict, nsname, -1);
21921: if (nsname == NULL)
21922: return(-1);
21923: }
21924: for (i = 0; i < vctxt->nodeQNames->nbItems; i += 2) {
21925: if ((vctxt->nodeQNames->items [i] == lname) &&
21926: (vctxt->nodeQNames->items[i +1] == nsname))
21927: /* Already there */
21928: return(i);
21929: }
21930: /* Add new entry. */
21931: i = vctxt->nodeQNames->nbItems;
21932: xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) lname);
21933: xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) nsname);
21934: return(i);
21935: }
21936:
21937: /************************************************************************
21938: * *
21939: * Validation of identity-constraints (IDC) *
21940: * *
21941: ************************************************************************/
21942:
21943: /**
21944: * xmlSchemaAugmentIDC:
21945: * @idcDef: the IDC definition
21946: *
21947: * Creates an augmented IDC definition item.
21948: *
21949: * Returns the item, or NULL on internal errors.
21950: */
21951: static void
21952: xmlSchemaAugmentIDC(xmlSchemaIDCPtr idcDef,
21953: xmlSchemaValidCtxtPtr vctxt)
21954: {
21955: xmlSchemaIDCAugPtr aidc;
21956:
21957: aidc = (xmlSchemaIDCAugPtr) xmlMalloc(sizeof(xmlSchemaIDCAug));
21958: if (aidc == NULL) {
21959: xmlSchemaVErrMemory(vctxt,
21960: "xmlSchemaAugmentIDC: allocating an augmented IDC definition",
21961: NULL);
21962: return;
21963: }
21964: aidc->keyrefDepth = -1;
21965: aidc->def = idcDef;
21966: aidc->next = NULL;
21967: if (vctxt->aidcs == NULL)
21968: vctxt->aidcs = aidc;
21969: else {
21970: aidc->next = vctxt->aidcs;
21971: vctxt->aidcs = aidc;
21972: }
21973: /*
21974: * Save if we have keyrefs at all.
21975: */
21976: if ((vctxt->hasKeyrefs == 0) &&
21977: (idcDef->type == XML_SCHEMA_TYPE_IDC_KEYREF))
21978: vctxt->hasKeyrefs = 1;
21979: }
21980:
21981: /**
21982: * xmlSchemaAugmentImportedIDC:
21983: * @imported: the imported schema
21984: *
21985: * Creates an augmented IDC definition for the imported schema.
21986: */
21987: static void
21988: xmlSchemaAugmentImportedIDC(xmlSchemaImportPtr imported, xmlSchemaValidCtxtPtr vctxt) {
21989: if (imported->schema->idcDef != NULL) {
21990: xmlHashScan(imported->schema->idcDef ,
21991: (xmlHashScanner) xmlSchemaAugmentIDC, vctxt);
21992: }
21993: }
21994:
21995: /**
21996: * xmlSchemaIDCNewBinding:
21997: * @idcDef: the IDC definition of this binding
21998: *
21999: * Creates a new IDC binding.
22000: *
22001: * Returns the new IDC binding, NULL on internal errors.
22002: */
22003: static xmlSchemaPSVIIDCBindingPtr
22004: xmlSchemaIDCNewBinding(xmlSchemaIDCPtr idcDef)
22005: {
22006: xmlSchemaPSVIIDCBindingPtr ret;
22007:
22008: ret = (xmlSchemaPSVIIDCBindingPtr) xmlMalloc(
22009: sizeof(xmlSchemaPSVIIDCBinding));
22010: if (ret == NULL) {
22011: xmlSchemaVErrMemory(NULL,
22012: "allocating a PSVI IDC binding item", NULL);
22013: return (NULL);
22014: }
22015: memset(ret, 0, sizeof(xmlSchemaPSVIIDCBinding));
22016: ret->definition = idcDef;
22017: return (ret);
22018: }
22019:
22020: /**
22021: * xmlSchemaIDCStoreNodeTableItem:
22022: * @vctxt: the WXS validation context
22023: * @item: the IDC node table item
22024: *
22025: * The validation context is used to store IDC node table items.
22026: * They are stored to avoid copying them if IDC node-tables are merged
22027: * with corresponding parent IDC node-tables (bubbling).
22028: *
22029: * Returns 0 if succeeded, -1 on internal errors.
22030: */
22031: static int
22032: xmlSchemaIDCStoreNodeTableItem(xmlSchemaValidCtxtPtr vctxt,
22033: xmlSchemaPSVIIDCNodePtr item)
22034: {
22035: /*
22036: * Add to gobal list.
22037: */
22038: if (vctxt->idcNodes == NULL) {
22039: vctxt->idcNodes = (xmlSchemaPSVIIDCNodePtr *)
22040: xmlMalloc(20 * sizeof(xmlSchemaPSVIIDCNodePtr));
22041: if (vctxt->idcNodes == NULL) {
22042: xmlSchemaVErrMemory(vctxt,
22043: "allocating the IDC node table item list", NULL);
22044: return (-1);
22045: }
22046: vctxt->sizeIdcNodes = 20;
22047: } else if (vctxt->sizeIdcNodes <= vctxt->nbIdcNodes) {
22048: vctxt->sizeIdcNodes *= 2;
22049: vctxt->idcNodes = (xmlSchemaPSVIIDCNodePtr *)
22050: xmlRealloc(vctxt->idcNodes, vctxt->sizeIdcNodes *
22051: sizeof(xmlSchemaPSVIIDCNodePtr));
22052: if (vctxt->idcNodes == NULL) {
22053: xmlSchemaVErrMemory(vctxt,
22054: "re-allocating the IDC node table item list", NULL);
22055: return (-1);
22056: }
22057: }
22058: vctxt->idcNodes[vctxt->nbIdcNodes++] = item;
22059:
22060: return (0);
22061: }
22062:
22063: /**
22064: * xmlSchemaIDCStoreKey:
22065: * @vctxt: the WXS validation context
22066: * @item: the IDC key
22067: *
22068: * The validation context is used to store an IDC key.
22069: *
22070: * Returns 0 if succeeded, -1 on internal errors.
22071: */
22072: static int
22073: xmlSchemaIDCStoreKey(xmlSchemaValidCtxtPtr vctxt,
22074: xmlSchemaPSVIIDCKeyPtr key)
22075: {
22076: /*
22077: * Add to gobal list.
22078: */
22079: if (vctxt->idcKeys == NULL) {
22080: vctxt->idcKeys = (xmlSchemaPSVIIDCKeyPtr *)
22081: xmlMalloc(40 * sizeof(xmlSchemaPSVIIDCKeyPtr));
22082: if (vctxt->idcKeys == NULL) {
22083: xmlSchemaVErrMemory(vctxt,
22084: "allocating the IDC key storage list", NULL);
22085: return (-1);
22086: }
22087: vctxt->sizeIdcKeys = 40;
22088: } else if (vctxt->sizeIdcKeys <= vctxt->nbIdcKeys) {
22089: vctxt->sizeIdcKeys *= 2;
22090: vctxt->idcKeys = (xmlSchemaPSVIIDCKeyPtr *)
22091: xmlRealloc(vctxt->idcKeys, vctxt->sizeIdcKeys *
22092: sizeof(xmlSchemaPSVIIDCKeyPtr));
22093: if (vctxt->idcKeys == NULL) {
22094: xmlSchemaVErrMemory(vctxt,
22095: "re-allocating the IDC key storage list", NULL);
22096: return (-1);
22097: }
22098: }
22099: vctxt->idcKeys[vctxt->nbIdcKeys++] = key;
22100:
22101: return (0);
22102: }
22103:
22104: /**
22105: * xmlSchemaIDCAppendNodeTableItem:
22106: * @bind: the IDC binding
22107: * @ntItem: the node-table item
22108: *
22109: * Appends the IDC node-table item to the binding.
22110: *
22111: * Returns 0 on success and -1 on internal errors.
22112: */
22113: static int
22114: xmlSchemaIDCAppendNodeTableItem(xmlSchemaPSVIIDCBindingPtr bind,
22115: xmlSchemaPSVIIDCNodePtr ntItem)
22116: {
22117: if (bind->nodeTable == NULL) {
22118: bind->sizeNodes = 10;
22119: bind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
22120: xmlMalloc(10 * sizeof(xmlSchemaPSVIIDCNodePtr));
22121: if (bind->nodeTable == NULL) {
22122: xmlSchemaVErrMemory(NULL,
22123: "allocating an array of IDC node-table items", NULL);
22124: return(-1);
22125: }
22126: } else if (bind->sizeNodes <= bind->nbNodes) {
22127: bind->sizeNodes *= 2;
22128: bind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
22129: xmlRealloc(bind->nodeTable, bind->sizeNodes *
22130: sizeof(xmlSchemaPSVIIDCNodePtr));
22131: if (bind->nodeTable == NULL) {
22132: xmlSchemaVErrMemory(NULL,
22133: "re-allocating an array of IDC node-table items", NULL);
22134: return(-1);
22135: }
22136: }
22137: bind->nodeTable[bind->nbNodes++] = ntItem;
22138: return(0);
22139: }
22140:
22141: /**
22142: * xmlSchemaIDCAcquireBinding:
22143: * @vctxt: the WXS validation context
22144: * @matcher: the IDC matcher
22145: *
22146: * Looks up an PSVI IDC binding, for the IDC definition and
22147: * of the given matcher. If none found, a new one is created
22148: * and added to the IDC table.
22149: *
22150: * Returns an IDC binding or NULL on internal errors.
22151: */
22152: static xmlSchemaPSVIIDCBindingPtr
22153: xmlSchemaIDCAcquireBinding(xmlSchemaValidCtxtPtr vctxt,
22154: xmlSchemaIDCMatcherPtr matcher)
22155: {
22156: xmlSchemaNodeInfoPtr ielem;
22157:
22158: ielem = vctxt->elemInfos[matcher->depth];
22159:
22160: if (ielem->idcTable == NULL) {
22161: ielem->idcTable = xmlSchemaIDCNewBinding(matcher->aidc->def);
22162: if (ielem->idcTable == NULL)
22163: return (NULL);
22164: return(ielem->idcTable);
22165: } else {
22166: xmlSchemaPSVIIDCBindingPtr bind = NULL;
22167:
22168: bind = ielem->idcTable;
22169: do {
22170: if (bind->definition == matcher->aidc->def)
22171: return(bind);
22172: if (bind->next == NULL) {
22173: bind->next = xmlSchemaIDCNewBinding(matcher->aidc->def);
22174: if (bind->next == NULL)
22175: return (NULL);
22176: return(bind->next);
22177: }
22178: bind = bind->next;
22179: } while (bind != NULL);
22180: }
22181: return (NULL);
22182: }
22183:
22184: static xmlSchemaItemListPtr
22185: xmlSchemaIDCAcquireTargetList(xmlSchemaValidCtxtPtr vctxt ATTRIBUTE_UNUSED,
22186: xmlSchemaIDCMatcherPtr matcher)
22187: {
22188: if (matcher->targets == NULL)
22189: matcher->targets = xmlSchemaItemListCreate();
22190: return(matcher->targets);
22191: }
22192:
22193: /**
22194: * xmlSchemaIDCFreeKey:
22195: * @key: the IDC key
22196: *
22197: * Frees an IDC key together with its compiled value.
22198: */
22199: static void
22200: xmlSchemaIDCFreeKey(xmlSchemaPSVIIDCKeyPtr key)
22201: {
22202: if (key->val != NULL)
22203: xmlSchemaFreeValue(key->val);
22204: xmlFree(key);
22205: }
22206:
22207: /**
22208: * xmlSchemaIDCFreeBinding:
22209: *
22210: * Frees an IDC binding. Note that the node table-items
22211: * are not freed.
22212: */
22213: static void
22214: xmlSchemaIDCFreeBinding(xmlSchemaPSVIIDCBindingPtr bind)
22215: {
22216: if (bind->nodeTable != NULL)
22217: xmlFree(bind->nodeTable);
22218: if (bind->dupls != NULL)
22219: xmlSchemaItemListFree(bind->dupls);
22220: xmlFree(bind);
22221: }
22222:
22223: /**
22224: * xmlSchemaIDCFreeIDCTable:
22225: * @bind: the first IDC binding in the list
22226: *
22227: * Frees an IDC table, i.e. all the IDC bindings in the list.
22228: */
22229: static void
22230: xmlSchemaIDCFreeIDCTable(xmlSchemaPSVIIDCBindingPtr bind)
22231: {
22232: xmlSchemaPSVIIDCBindingPtr prev;
22233:
22234: while (bind != NULL) {
22235: prev = bind;
22236: bind = bind->next;
22237: xmlSchemaIDCFreeBinding(prev);
22238: }
22239: }
22240:
22241: /**
22242: * xmlSchemaIDCFreeMatcherList:
22243: * @matcher: the first IDC matcher in the list
22244: *
22245: * Frees a list of IDC matchers.
22246: */
22247: static void
22248: xmlSchemaIDCFreeMatcherList(xmlSchemaIDCMatcherPtr matcher)
22249: {
22250: xmlSchemaIDCMatcherPtr next;
22251:
22252: while (matcher != NULL) {
22253: next = matcher->next;
22254: if (matcher->keySeqs != NULL) {
22255: int i;
22256: for (i = 0; i < matcher->sizeKeySeqs; i++)
22257: if (matcher->keySeqs[i] != NULL)
22258: xmlFree(matcher->keySeqs[i]);
22259: xmlFree(matcher->keySeqs);
22260: }
22261: if (matcher->targets != NULL) {
22262: if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
22263: int i;
22264: xmlSchemaPSVIIDCNodePtr idcNode;
22265: /*
22266: * Node-table items for keyrefs are not stored globally
22267: * to the validation context, since they are not bubbled.
22268: * We need to free them here.
22269: */
22270: for (i = 0; i < matcher->targets->nbItems; i++) {
22271: idcNode =
22272: (xmlSchemaPSVIIDCNodePtr) matcher->targets->items[i];
22273: xmlFree(idcNode->keys);
22274: xmlFree(idcNode);
22275: }
22276: }
22277: xmlSchemaItemListFree(matcher->targets);
22278: }
22279: xmlFree(matcher);
22280: matcher = next;
22281: }
22282: }
22283:
22284: /**
22285: * xmlSchemaIDCReleaseMatcherList:
22286: * @vctxt: the WXS validation context
22287: * @matcher: the first IDC matcher in the list
22288: *
22289: * Caches a list of IDC matchers for reuse.
22290: */
22291: static void
22292: xmlSchemaIDCReleaseMatcherList(xmlSchemaValidCtxtPtr vctxt,
22293: xmlSchemaIDCMatcherPtr matcher)
22294: {
22295: xmlSchemaIDCMatcherPtr next;
22296:
22297: while (matcher != NULL) {
22298: next = matcher->next;
22299: if (matcher->keySeqs != NULL) {
22300: int i;
22301: /*
22302: * Don't free the array, but only the content.
22303: */
22304: for (i = 0; i < matcher->sizeKeySeqs; i++)
22305: if (matcher->keySeqs[i] != NULL) {
22306: xmlFree(matcher->keySeqs[i]);
22307: matcher->keySeqs[i] = NULL;
22308: }
22309: }
22310: if (matcher->targets) {
22311: if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
22312: int i;
22313: xmlSchemaPSVIIDCNodePtr idcNode;
22314: /*
22315: * Node-table items for keyrefs are not stored globally
22316: * to the validation context, since they are not bubbled.
22317: * We need to free them here.
22318: */
22319: for (i = 0; i < matcher->targets->nbItems; i++) {
22320: idcNode =
22321: (xmlSchemaPSVIIDCNodePtr) matcher->targets->items[i];
22322: xmlFree(idcNode->keys);
22323: xmlFree(idcNode);
22324: }
22325: }
22326: xmlSchemaItemListFree(matcher->targets);
22327: matcher->targets = NULL;
22328: }
22329: matcher->next = NULL;
22330: /*
22331: * Cache the matcher.
22332: */
22333: if (vctxt->idcMatcherCache != NULL)
22334: matcher->nextCached = vctxt->idcMatcherCache;
22335: vctxt->idcMatcherCache = matcher;
22336:
22337: matcher = next;
22338: }
22339: }
22340:
22341: /**
22342: * xmlSchemaIDCAddStateObject:
22343: * @vctxt: the WXS validation context
22344: * @matcher: the IDC matcher
22345: * @sel: the XPath information
22346: * @parent: the parent "selector" state object if any
22347: * @type: "selector" or "field"
22348: *
22349: * Creates/reuses and activates state objects for the given
22350: * XPath information; if the XPath expression consists of unions,
22351: * multiple state objects are created for every unioned expression.
22352: *
22353: * Returns 0 on success and -1 on internal errors.
22354: */
22355: static int
22356: xmlSchemaIDCAddStateObject(xmlSchemaValidCtxtPtr vctxt,
22357: xmlSchemaIDCMatcherPtr matcher,
22358: xmlSchemaIDCSelectPtr sel,
22359: int type)
22360: {
22361: xmlSchemaIDCStateObjPtr sto;
22362:
22363: /*
22364: * Reuse the state objects from the pool.
22365: */
22366: if (vctxt->xpathStatePool != NULL) {
22367: sto = vctxt->xpathStatePool;
22368: vctxt->xpathStatePool = sto->next;
22369: sto->next = NULL;
22370: } else {
22371: /*
22372: * Create a new state object.
22373: */
22374: sto = (xmlSchemaIDCStateObjPtr) xmlMalloc(sizeof(xmlSchemaIDCStateObj));
22375: if (sto == NULL) {
22376: xmlSchemaVErrMemory(NULL,
22377: "allocating an IDC state object", NULL);
22378: return (-1);
22379: }
22380: memset(sto, 0, sizeof(xmlSchemaIDCStateObj));
22381: }
22382: /*
22383: * Add to global list.
22384: */
22385: if (vctxt->xpathStates != NULL)
22386: sto->next = vctxt->xpathStates;
22387: vctxt->xpathStates = sto;
22388:
22389: /*
22390: * Free the old xpath validation context.
22391: */
22392: if (sto->xpathCtxt != NULL)
22393: xmlFreeStreamCtxt((xmlStreamCtxtPtr) sto->xpathCtxt);
22394:
22395: /*
22396: * Create a new XPath (pattern) validation context.
22397: */
22398: sto->xpathCtxt = (void *) xmlPatternGetStreamCtxt(
22399: (xmlPatternPtr) sel->xpathComp);
22400: if (sto->xpathCtxt == NULL) {
22401: VERROR_INT("xmlSchemaIDCAddStateObject",
22402: "failed to create an XPath validation context");
22403: return (-1);
22404: }
22405: sto->type = type;
22406: sto->depth = vctxt->depth;
22407: sto->matcher = matcher;
22408: sto->sel = sel;
22409: sto->nbHistory = 0;
22410:
22411: #ifdef DEBUG_IDC
22412: xmlGenericError(xmlGenericErrorContext, "IDC: STO push '%s'\n",
22413: sto->sel->xpath);
22414: #endif
22415: return (0);
22416: }
22417:
22418: /**
22419: * xmlSchemaXPathEvaluate:
22420: * @vctxt: the WXS validation context
22421: * @nodeType: the nodeType of the current node
22422: *
22423: * Evaluates all active XPath state objects.
22424: *
22425: * Returns the number of IC "field" state objects which resolved to
22426: * this node, 0 if none resolved and -1 on internal errors.
22427: */
22428: static int
22429: xmlSchemaXPathEvaluate(xmlSchemaValidCtxtPtr vctxt,
22430: xmlElementType nodeType)
22431: {
22432: xmlSchemaIDCStateObjPtr sto, head = NULL, first;
22433: int res, resolved = 0, depth = vctxt->depth;
22434:
22435: if (vctxt->xpathStates == NULL)
22436: return (0);
22437:
22438: if (nodeType == XML_ATTRIBUTE_NODE)
22439: depth++;
22440: #ifdef DEBUG_IDC
22441: {
22442: xmlChar *str = NULL;
22443: xmlGenericError(xmlGenericErrorContext,
22444: "IDC: EVAL on %s, depth %d, type %d\n",
22445: xmlSchemaFormatQName(&str, vctxt->inode->nsName,
22446: vctxt->inode->localName), depth, nodeType);
22447: FREE_AND_NULL(str)
22448: }
22449: #endif
22450: /*
22451: * Process all active XPath state objects.
22452: */
22453: first = vctxt->xpathStates;
22454: sto = first;
22455: while (sto != head) {
22456: #ifdef DEBUG_IDC
22457: if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR)
22458: xmlGenericError(xmlGenericErrorContext, "IDC: ['%s'] selector '%s'\n",
22459: sto->matcher->aidc->def->name, sto->sel->xpath);
22460: else
22461: xmlGenericError(xmlGenericErrorContext, "IDC: ['%s'] field '%s'\n",
22462: sto->matcher->aidc->def->name, sto->sel->xpath);
22463: #endif
22464: if (nodeType == XML_ELEMENT_NODE)
22465: res = xmlStreamPush((xmlStreamCtxtPtr) sto->xpathCtxt,
22466: vctxt->inode->localName, vctxt->inode->nsName);
22467: else
22468: res = xmlStreamPushAttr((xmlStreamCtxtPtr) sto->xpathCtxt,
22469: vctxt->inode->localName, vctxt->inode->nsName);
22470:
22471: if (res == -1) {
22472: VERROR_INT("xmlSchemaXPathEvaluate",
22473: "calling xmlStreamPush()");
22474: return (-1);
22475: }
22476: if (res == 0)
22477: goto next_sto;
22478: /*
22479: * Full match.
22480: */
22481: #ifdef DEBUG_IDC
22482: xmlGenericError(xmlGenericErrorContext, "IDC: "
22483: "MATCH\n");
22484: #endif
22485: /*
22486: * Register a match in the state object history.
22487: */
22488: if (sto->history == NULL) {
22489: sto->history = (int *) xmlMalloc(5 * sizeof(int));
22490: if (sto->history == NULL) {
22491: xmlSchemaVErrMemory(NULL,
22492: "allocating the state object history", NULL);
22493: return(-1);
22494: }
22495: sto->sizeHistory = 5;
22496: } else if (sto->sizeHistory <= sto->nbHistory) {
22497: sto->sizeHistory *= 2;
22498: sto->history = (int *) xmlRealloc(sto->history,
22499: sto->sizeHistory * sizeof(int));
22500: if (sto->history == NULL) {
22501: xmlSchemaVErrMemory(NULL,
22502: "re-allocating the state object history", NULL);
22503: return(-1);
22504: }
22505: }
22506: sto->history[sto->nbHistory++] = depth;
22507:
22508: #ifdef DEBUG_IDC
22509: xmlGenericError(xmlGenericErrorContext, "IDC: push match '%d'\n",
22510: vctxt->depth);
22511: #endif
22512:
22513: if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
22514: xmlSchemaIDCSelectPtr sel;
22515: /*
22516: * Activate state objects for the IDC fields of
22517: * the IDC selector.
22518: */
22519: #ifdef DEBUG_IDC
22520: xmlGenericError(xmlGenericErrorContext, "IDC: "
22521: "activating field states\n");
22522: #endif
22523: sel = sto->matcher->aidc->def->fields;
22524: while (sel != NULL) {
22525: if (xmlSchemaIDCAddStateObject(vctxt, sto->matcher,
22526: sel, XPATH_STATE_OBJ_TYPE_IDC_FIELD) == -1)
22527: return (-1);
22528: sel = sel->next;
22529: }
22530: } else if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_FIELD) {
22531: /*
22532: * An IDC key node was found by the IDC field.
22533: */
22534: #ifdef DEBUG_IDC
22535: xmlGenericError(xmlGenericErrorContext,
22536: "IDC: key found\n");
22537: #endif
22538: /*
22539: * Notify that the character value of this node is
22540: * needed.
22541: */
22542: if (resolved == 0) {
22543: if ((vctxt->inode->flags &
22544: XML_SCHEMA_NODE_INFO_VALUE_NEEDED) == 0)
22545: vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_VALUE_NEEDED;
22546: }
22547: resolved++;
22548: }
22549: next_sto:
22550: if (sto->next == NULL) {
22551: /*
22552: * Evaluate field state objects created on this node as well.
22553: */
22554: head = first;
22555: sto = vctxt->xpathStates;
22556: } else
22557: sto = sto->next;
22558: }
22559: return (resolved);
22560: }
22561:
22562: static const xmlChar *
22563: xmlSchemaFormatIDCKeySequence(xmlSchemaValidCtxtPtr vctxt,
22564: xmlChar **buf,
22565: xmlSchemaPSVIIDCKeyPtr *seq,
22566: int count)
22567: {
22568: int i, res;
22569: xmlChar *value = NULL;
22570:
22571: *buf = xmlStrdup(BAD_CAST "[");
22572: for (i = 0; i < count; i++) {
22573: *buf = xmlStrcat(*buf, BAD_CAST "'");
22574: res = xmlSchemaGetCanonValueWhtspExt(seq[i]->val,
22575: xmlSchemaGetWhiteSpaceFacetValue(seq[i]->type),
22576: &value);
22577: if (res == 0)
22578: *buf = xmlStrcat(*buf, BAD_CAST value);
22579: else {
22580: VERROR_INT("xmlSchemaFormatIDCKeySequence",
22581: "failed to compute a canonical value");
22582: *buf = xmlStrcat(*buf, BAD_CAST "???");
22583: }
22584: if (i < count -1)
22585: *buf = xmlStrcat(*buf, BAD_CAST "', ");
22586: else
22587: *buf = xmlStrcat(*buf, BAD_CAST "'");
22588: if (value != NULL) {
22589: xmlFree(value);
22590: value = NULL;
22591: }
22592: }
22593: *buf = xmlStrcat(*buf, BAD_CAST "]");
22594:
22595: return (BAD_CAST *buf);
22596: }
22597:
22598: /**
22599: * xmlSchemaXPathPop:
22600: * @vctxt: the WXS validation context
22601: *
22602: * Pops all XPath states.
22603: *
22604: * Returns 0 on success and -1 on internal errors.
22605: */
22606: static int
22607: xmlSchemaXPathPop(xmlSchemaValidCtxtPtr vctxt)
22608: {
22609: xmlSchemaIDCStateObjPtr sto;
22610: int res;
22611:
22612: if (vctxt->xpathStates == NULL)
22613: return(0);
22614: sto = vctxt->xpathStates;
22615: do {
22616: res = xmlStreamPop((xmlStreamCtxtPtr) sto->xpathCtxt);
22617: if (res == -1)
22618: return (-1);
22619: sto = sto->next;
22620: } while (sto != NULL);
22621: return(0);
22622: }
22623:
22624: /**
22625: * xmlSchemaXPathProcessHistory:
22626: * @vctxt: the WXS validation context
22627: * @type: the simple/complex type of the current node if any at all
22628: * @val: the precompiled value
22629: *
22630: * Processes and pops the history items of the IDC state objects.
22631: * IDC key-sequences are validated/created on IDC bindings.
22632: *
22633: * Returns 0 on success and -1 on internal errors.
22634: */
22635: static int
22636: xmlSchemaXPathProcessHistory(xmlSchemaValidCtxtPtr vctxt,
22637: int depth)
22638: {
22639: xmlSchemaIDCStateObjPtr sto, nextsto;
22640: int res, matchDepth;
22641: xmlSchemaPSVIIDCKeyPtr key = NULL;
22642: xmlSchemaTypePtr type = vctxt->inode->typeDef, simpleType = NULL;
22643:
22644: if (vctxt->xpathStates == NULL)
22645: return (0);
22646: sto = vctxt->xpathStates;
22647:
22648: #ifdef DEBUG_IDC
22649: {
22650: xmlChar *str = NULL;
22651: xmlGenericError(xmlGenericErrorContext,
22652: "IDC: BACK on %s, depth %d\n",
22653: xmlSchemaFormatQName(&str, vctxt->inode->nsName,
22654: vctxt->inode->localName), vctxt->depth);
22655: FREE_AND_NULL(str)
22656: }
22657: #endif
22658: /*
22659: * Evaluate the state objects.
22660: */
22661: while (sto != NULL) {
22662: res = xmlStreamPop((xmlStreamCtxtPtr) sto->xpathCtxt);
22663: if (res == -1) {
22664: VERROR_INT("xmlSchemaXPathProcessHistory",
22665: "calling xmlStreamPop()");
22666: return (-1);
22667: }
22668: #ifdef DEBUG_IDC
22669: xmlGenericError(xmlGenericErrorContext, "IDC: stream pop '%s'\n",
22670: sto->sel->xpath);
22671: #endif
22672: if (sto->nbHistory == 0)
22673: goto deregister_check;
22674:
22675: matchDepth = sto->history[sto->nbHistory -1];
22676:
22677: /*
22678: * Only matches at the current depth are of interest.
22679: */
22680: if (matchDepth != depth) {
22681: sto = sto->next;
22682: continue;
22683: }
22684: if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_FIELD) {
22685: /*
22686: * NOTE: According to
22687: * http://www.w3.org/Bugs/Public/show_bug.cgi?id=2198
22688: * ... the simple-content of complex types is also allowed.
22689: */
22690:
22691: if (WXS_IS_COMPLEX(type)) {
22692: if (WXS_HAS_SIMPLE_CONTENT(type)) {
22693: /*
22694: * Sanity check for complex types with simple content.
22695: */
22696: simpleType = type->contentTypeDef;
22697: if (simpleType == NULL) {
22698: VERROR_INT("xmlSchemaXPathProcessHistory",
22699: "field resolves to a CT with simple content "
22700: "but the CT is missing the ST definition");
22701: return (-1);
22702: }
22703: } else
22704: simpleType = NULL;
22705: } else
22706: simpleType = type;
22707: if (simpleType == NULL) {
22708: xmlChar *str = NULL;
22709:
22710: /*
22711: * Not qualified if the field resolves to a node of non
22712: * simple type.
22713: */
22714: xmlSchemaCustomErr(ACTXT_CAST vctxt,
22715: XML_SCHEMAV_CVC_IDC, NULL,
22716: WXS_BASIC_CAST sto->matcher->aidc->def,
22717: "The XPath '%s' of a field of %s does evaluate to a node of "
22718: "non-simple type",
22719: sto->sel->xpath,
22720: xmlSchemaGetIDCDesignation(&str, sto->matcher->aidc->def));
22721: FREE_AND_NULL(str);
22722: sto->nbHistory--;
22723: goto deregister_check;
22724: }
22725:
22726: if ((key == NULL) && (vctxt->inode->val == NULL)) {
22727: /*
22728: * Failed to provide the normalized value; maybe
22729: * the value was invalid.
22730: */
22731: VERROR(XML_SCHEMAV_CVC_IDC,
22732: WXS_BASIC_CAST sto->matcher->aidc->def,
22733: "Warning: No precomputed value available, the value "
22734: "was either invalid or something strange happend");
22735: sto->nbHistory--;
22736: goto deregister_check;
22737: } else {
22738: xmlSchemaIDCMatcherPtr matcher = sto->matcher;
22739: xmlSchemaPSVIIDCKeyPtr *keySeq;
22740: int pos, idx;
22741:
22742: /*
22743: * The key will be anchored on the matcher's list of
22744: * key-sequences. The position in this list is determined
22745: * by the target node's depth relative to the matcher's
22746: * depth of creation (i.e. the depth of the scope element).
22747: *
22748: * Element Depth Pos List-entries
22749: * <scope> 0 NULL
22750: * <bar> 1 NULL
22751: * <target/> 2 2 target
22752: * <bar>
22753: * </scope>
22754: *
22755: * The size of the list is only dependant on the depth of
22756: * the tree.
22757: * An entry will be NULLed in selector_leave, i.e. when
22758: * we hit the target's
22759: */
22760: pos = sto->depth - matcher->depth;
22761: idx = sto->sel->index;
22762:
22763: /*
22764: * Create/grow the array of key-sequences.
22765: */
22766: if (matcher->keySeqs == NULL) {
22767: if (pos > 9)
22768: matcher->sizeKeySeqs = pos * 2;
22769: else
22770: matcher->sizeKeySeqs = 10;
22771: matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
22772: xmlMalloc(matcher->sizeKeySeqs *
22773: sizeof(xmlSchemaPSVIIDCKeyPtr *));
22774: if (matcher->keySeqs == NULL) {
22775: xmlSchemaVErrMemory(NULL,
22776: "allocating an array of key-sequences",
22777: NULL);
22778: return(-1);
22779: }
22780: memset(matcher->keySeqs, 0,
22781: matcher->sizeKeySeqs *
22782: sizeof(xmlSchemaPSVIIDCKeyPtr *));
22783: } else if (pos >= matcher->sizeKeySeqs) {
22784: int i = matcher->sizeKeySeqs;
22785:
22786: matcher->sizeKeySeqs *= 2;
22787: matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
22788: xmlRealloc(matcher->keySeqs,
22789: matcher->sizeKeySeqs *
22790: sizeof(xmlSchemaPSVIIDCKeyPtr *));
22791: if (matcher->keySeqs == NULL) {
22792: xmlSchemaVErrMemory(NULL,
22793: "reallocating an array of key-sequences",
22794: NULL);
22795: return (-1);
22796: }
22797: /*
22798: * The array needs to be NULLed.
22799: * TODO: Use memset?
22800: */
22801: for (; i < matcher->sizeKeySeqs; i++)
22802: matcher->keySeqs[i] = NULL;
22803: }
22804:
22805: /*
22806: * Get/create the key-sequence.
22807: */
22808: keySeq = matcher->keySeqs[pos];
22809: if (keySeq == NULL) {
22810: goto create_sequence;
22811: } else if (keySeq[idx] != NULL) {
22812: xmlChar *str = NULL;
22813: /*
22814: * cvc-identity-constraint:
22815: * 3 For each node in the �target node set� all
22816: * of the {fields}, with that node as the context
22817: * node, evaluate to either an empty node-set or
22818: * a node-set with exactly one member, which must
22819: * have a simple type.
22820: *
22821: * The key was already set; report an error.
22822: */
22823: xmlSchemaCustomErr(ACTXT_CAST vctxt,
22824: XML_SCHEMAV_CVC_IDC, NULL,
22825: WXS_BASIC_CAST matcher->aidc->def,
22826: "The XPath '%s' of a field of %s evaluates to a "
22827: "node-set with more than one member",
22828: sto->sel->xpath,
22829: xmlSchemaGetIDCDesignation(&str, matcher->aidc->def));
22830: FREE_AND_NULL(str);
22831: sto->nbHistory--;
22832: goto deregister_check;
22833: } else
22834: goto create_key;
22835:
22836: create_sequence:
22837: /*
22838: * Create a key-sequence.
22839: */
22840: keySeq = (xmlSchemaPSVIIDCKeyPtr *) xmlMalloc(
22841: matcher->aidc->def->nbFields *
22842: sizeof(xmlSchemaPSVIIDCKeyPtr));
22843: if (keySeq == NULL) {
22844: xmlSchemaVErrMemory(NULL,
22845: "allocating an IDC key-sequence", NULL);
22846: return(-1);
22847: }
22848: memset(keySeq, 0, matcher->aidc->def->nbFields *
22849: sizeof(xmlSchemaPSVIIDCKeyPtr));
22850: matcher->keySeqs[pos] = keySeq;
22851: create_key:
22852: /*
22853: * Create a key once per node only.
22854: */
22855: if (key == NULL) {
22856: key = (xmlSchemaPSVIIDCKeyPtr) xmlMalloc(
22857: sizeof(xmlSchemaPSVIIDCKey));
22858: if (key == NULL) {
22859: xmlSchemaVErrMemory(NULL,
22860: "allocating a IDC key", NULL);
22861: xmlFree(keySeq);
22862: matcher->keySeqs[pos] = NULL;
22863: return(-1);
22864: }
22865: /*
22866: * Consume the compiled value.
22867: */
22868: key->type = simpleType;
22869: key->val = vctxt->inode->val;
22870: vctxt->inode->val = NULL;
22871: /*
22872: * Store the key in a global list.
22873: */
22874: if (xmlSchemaIDCStoreKey(vctxt, key) == -1) {
22875: xmlSchemaIDCFreeKey(key);
22876: return (-1);
22877: }
22878: }
22879: keySeq[idx] = key;
22880: }
22881: } else if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
22882:
22883: xmlSchemaPSVIIDCKeyPtr **keySeq = NULL;
22884: /* xmlSchemaPSVIIDCBindingPtr bind; */
22885: xmlSchemaPSVIIDCNodePtr ntItem;
22886: xmlSchemaIDCMatcherPtr matcher;
22887: xmlSchemaIDCPtr idc;
22888: xmlSchemaItemListPtr targets;
22889: int pos, i, j, nbKeys;
22890: /*
22891: * Here we have the following scenario:
22892: * An IDC 'selector' state object resolved to a target node,
22893: * during the time this target node was in the
22894: * ancestor-or-self axis, the 'field' state object(s) looked
22895: * out for matching nodes to create a key-sequence for this
22896: * target node. Now we are back to this target node and need
22897: * to put the key-sequence, together with the target node
22898: * itself, into the node-table of the corresponding IDC
22899: * binding.
22900: */
22901: matcher = sto->matcher;
22902: idc = matcher->aidc->def;
22903: nbKeys = idc->nbFields;
22904: pos = depth - matcher->depth;
22905: /*
22906: * Check if the matcher has any key-sequences at all, plus
22907: * if it has a key-sequence for the current target node.
22908: */
22909: if ((matcher->keySeqs == NULL) ||
22910: (matcher->sizeKeySeqs <= pos)) {
22911: if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
22912: goto selector_key_error;
22913: else
22914: goto selector_leave;
22915: }
22916:
22917: keySeq = &(matcher->keySeqs[pos]);
22918: if (*keySeq == NULL) {
22919: if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
22920: goto selector_key_error;
22921: else
22922: goto selector_leave;
22923: }
22924:
22925: for (i = 0; i < nbKeys; i++) {
22926: if ((*keySeq)[i] == NULL) {
22927: /*
22928: * Not qualified, if not all fields did resolve.
22929: */
22930: if (idc->type == XML_SCHEMA_TYPE_IDC_KEY) {
22931: /*
22932: * All fields of a "key" IDC must resolve.
22933: */
22934: goto selector_key_error;
22935: }
22936: goto selector_leave;
22937: }
22938: }
22939: /*
22940: * All fields did resolve.
22941: */
22942:
22943: /*
22944: * 4.1 If the {identity-constraint category} is unique(/key),
22945: * then no two members of the �qualified node set� have
22946: * �key-sequences� whose members are pairwise equal, as
22947: * defined by Equal in [XML Schemas: Datatypes].
22948: *
22949: * Get the IDC binding from the matcher and check for
22950: * duplicate key-sequences.
22951: */
22952: #if 0
22953: bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
22954: #endif
22955: targets = xmlSchemaIDCAcquireTargetList(vctxt, matcher);
22956: if ((idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) &&
22957: (targets->nbItems != 0)) {
22958: xmlSchemaPSVIIDCKeyPtr ckey, bkey, *bkeySeq;
22959:
22960: i = 0;
22961: res = 0;
22962: /*
22963: * Compare the key-sequences, key by key.
22964: */
22965: do {
22966: bkeySeq =
22967: ((xmlSchemaPSVIIDCNodePtr) targets->items[i])->keys;
22968: for (j = 0; j < nbKeys; j++) {
22969: ckey = (*keySeq)[j];
22970: bkey = bkeySeq[j];
22971: res = xmlSchemaAreValuesEqual(ckey->val, bkey->val);
22972: if (res == -1) {
22973: return (-1);
22974: } else if (res == 0) {
22975: /*
22976: * One of the keys differs, so the key-sequence
22977: * won't be equal; get out.
22978: */
22979: break;
22980: }
22981: }
22982: if (res == 1) {
22983: /*
22984: * Duplicate key-sequence found.
22985: */
22986: break;
22987: }
22988: i++;
22989: } while (i < targets->nbItems);
22990: if (i != targets->nbItems) {
22991: xmlChar *str = NULL, *strB = NULL;
22992: /*
22993: * TODO: Try to report the key-sequence.
22994: */
22995: xmlSchemaCustomErr(ACTXT_CAST vctxt,
22996: XML_SCHEMAV_CVC_IDC, NULL,
22997: WXS_BASIC_CAST idc,
22998: "Duplicate key-sequence %s in %s",
22999: xmlSchemaFormatIDCKeySequence(vctxt, &str,
23000: (*keySeq), nbKeys),
23001: xmlSchemaGetIDCDesignation(&strB, idc));
23002: FREE_AND_NULL(str);
23003: FREE_AND_NULL(strB);
23004: goto selector_leave;
23005: }
23006: }
23007: /*
23008: * Add a node-table item to the IDC binding.
23009: */
23010: ntItem = (xmlSchemaPSVIIDCNodePtr) xmlMalloc(
23011: sizeof(xmlSchemaPSVIIDCNode));
23012: if (ntItem == NULL) {
23013: xmlSchemaVErrMemory(NULL,
23014: "allocating an IDC node-table item", NULL);
23015: xmlFree(*keySeq);
23016: *keySeq = NULL;
23017: return(-1);
23018: }
23019: memset(ntItem, 0, sizeof(xmlSchemaPSVIIDCNode));
23020:
23021: /*
23022: * Store the node-table item in a global list.
23023: */
23024: if (idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) {
23025: if (xmlSchemaIDCStoreNodeTableItem(vctxt, ntItem) == -1) {
23026: xmlFree(ntItem);
23027: xmlFree(*keySeq);
23028: *keySeq = NULL;
23029: return (-1);
23030: }
23031: ntItem->nodeQNameID = -1;
23032: } else {
23033: /*
23034: * Save a cached QName for this node on the IDC node, to be
23035: * able to report it, even if the node is not saved.
23036: */
23037: ntItem->nodeQNameID = xmlSchemaVAddNodeQName(vctxt,
23038: vctxt->inode->localName, vctxt->inode->nsName);
23039: if (ntItem->nodeQNameID == -1) {
23040: xmlFree(ntItem);
23041: xmlFree(*keySeq);
23042: *keySeq = NULL;
23043: return (-1);
23044: }
23045: }
23046: /*
23047: * Init the node-table item: Save the node, position and
23048: * consume the key-sequence.
23049: */
23050: ntItem->node = vctxt->node;
23051: ntItem->nodeLine = vctxt->inode->nodeLine;
23052: ntItem->keys = *keySeq;
23053: *keySeq = NULL;
23054: #if 0
23055: if (xmlSchemaIDCAppendNodeTableItem(bind, ntItem) == -1)
23056: #endif
23057: if (xmlSchemaItemListAdd(targets, ntItem) == -1) {
23058: if (idc->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
23059: /*
23060: * Free the item, since keyref items won't be
23061: * put on a global list.
23062: */
23063: xmlFree(ntItem->keys);
23064: xmlFree(ntItem);
23065: }
23066: return (-1);
23067: }
23068:
23069: goto selector_leave;
23070: selector_key_error:
23071: {
23072: xmlChar *str = NULL;
23073: /*
23074: * 4.2.1 (KEY) The �target node set� and the
23075: * �qualified node set� are equal, that is, every
23076: * member of the �target node set� is also a member
23077: * of the �qualified node set� and vice versa.
23078: */
23079: xmlSchemaCustomErr(ACTXT_CAST vctxt,
23080: XML_SCHEMAV_CVC_IDC, NULL,
23081: WXS_BASIC_CAST idc,
23082: "Not all fields of %s evaluate to a node",
23083: xmlSchemaGetIDCDesignation(&str, idc), NULL);
23084: FREE_AND_NULL(str);
23085: }
23086: selector_leave:
23087: /*
23088: * Free the key-sequence if not added to the IDC table.
23089: */
23090: if ((keySeq != NULL) && (*keySeq != NULL)) {
23091: xmlFree(*keySeq);
23092: *keySeq = NULL;
23093: }
23094: } /* if selector */
23095:
23096: sto->nbHistory--;
23097:
23098: deregister_check:
23099: /*
23100: * Deregister state objects if they reach the depth of creation.
23101: */
23102: if ((sto->nbHistory == 0) && (sto->depth == depth)) {
23103: #ifdef DEBUG_IDC
23104: xmlGenericError(xmlGenericErrorContext, "IDC: STO pop '%s'\n",
23105: sto->sel->xpath);
23106: #endif
23107: if (vctxt->xpathStates != sto) {
23108: VERROR_INT("xmlSchemaXPathProcessHistory",
23109: "The state object to be removed is not the first "
23110: "in the list");
23111: }
23112: nextsto = sto->next;
23113: /*
23114: * Unlink from the list of active XPath state objects.
23115: */
23116: vctxt->xpathStates = sto->next;
23117: sto->next = vctxt->xpathStatePool;
23118: /*
23119: * Link it to the pool of reusable state objects.
23120: */
23121: vctxt->xpathStatePool = sto;
23122: sto = nextsto;
23123: } else
23124: sto = sto->next;
23125: } /* while (sto != NULL) */
23126: return (0);
23127: }
23128:
23129: /**
23130: * xmlSchemaIDCRegisterMatchers:
23131: * @vctxt: the WXS validation context
23132: * @elemDecl: the element declaration
23133: *
23134: * Creates helper objects to evaluate IDC selectors/fields
23135: * successively.
23136: *
23137: * Returns 0 if OK and -1 on internal errors.
23138: */
23139: static int
23140: xmlSchemaIDCRegisterMatchers(xmlSchemaValidCtxtPtr vctxt,
23141: xmlSchemaElementPtr elemDecl)
23142: {
23143: xmlSchemaIDCMatcherPtr matcher, last = NULL;
23144: xmlSchemaIDCPtr idc, refIdc;
23145: xmlSchemaIDCAugPtr aidc;
23146:
23147: idc = (xmlSchemaIDCPtr) elemDecl->idcs;
23148: if (idc == NULL)
23149: return (0);
23150:
23151: #ifdef DEBUG_IDC
23152: {
23153: xmlChar *str = NULL;
23154: xmlGenericError(xmlGenericErrorContext,
23155: "IDC: REGISTER on %s, depth %d\n",
23156: (char *) xmlSchemaFormatQName(&str, vctxt->inode->nsName,
23157: vctxt->inode->localName), vctxt->depth);
23158: FREE_AND_NULL(str)
23159: }
23160: #endif
23161: if (vctxt->inode->idcMatchers != NULL) {
23162: VERROR_INT("xmlSchemaIDCRegisterMatchers",
23163: "The chain of IDC matchers is expected to be empty");
23164: return (-1);
23165: }
23166: do {
23167: if (idc->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
23168: /*
23169: * Since IDCs bubbles are expensive we need to know the
23170: * depth at which the bubbles should stop; this will be
23171: * the depth of the top-most keyref IDC. If no keyref
23172: * references a key/unique IDC, the keyrefDepth will
23173: * be -1, indicating that no bubbles are needed.
23174: */
23175: refIdc = (xmlSchemaIDCPtr) idc->ref->item;
23176: if (refIdc != NULL) {
23177: /*
23178: * Remember that we have keyrefs on this node.
23179: */
23180: vctxt->inode->hasKeyrefs = 1;
23181: /*
23182: * Lookup the referenced augmented IDC info.
23183: */
23184: aidc = vctxt->aidcs;
23185: while (aidc != NULL) {
23186: if (aidc->def == refIdc)
23187: break;
23188: aidc = aidc->next;
23189: }
23190: if (aidc == NULL) {
23191: VERROR_INT("xmlSchemaIDCRegisterMatchers",
23192: "Could not find an augmented IDC item for an IDC "
23193: "definition");
23194: return (-1);
23195: }
23196: if ((aidc->keyrefDepth == -1) ||
23197: (vctxt->depth < aidc->keyrefDepth))
23198: aidc->keyrefDepth = vctxt->depth;
23199: }
23200: }
23201: /*
23202: * Lookup the augmented IDC item for the IDC definition.
23203: */
23204: aidc = vctxt->aidcs;
23205: while (aidc != NULL) {
23206: if (aidc->def == idc)
23207: break;
23208: aidc = aidc->next;
23209: }
23210: if (aidc == NULL) {
23211: VERROR_INT("xmlSchemaIDCRegisterMatchers",
23212: "Could not find an augmented IDC item for an IDC definition");
23213: return (-1);
23214: }
23215: /*
23216: * Create an IDC matcher for every IDC definition.
23217: */
23218: if (vctxt->idcMatcherCache != NULL) {
23219: /*
23220: * Reuse a cached matcher.
23221: */
23222: matcher = vctxt->idcMatcherCache;
23223: vctxt->idcMatcherCache = matcher->nextCached;
23224: matcher->nextCached = NULL;
23225: } else {
23226: matcher = (xmlSchemaIDCMatcherPtr)
23227: xmlMalloc(sizeof(xmlSchemaIDCMatcher));
23228: if (matcher == NULL) {
23229: xmlSchemaVErrMemory(vctxt,
23230: "allocating an IDC matcher", NULL);
23231: return (-1);
23232: }
23233: memset(matcher, 0, sizeof(xmlSchemaIDCMatcher));
23234: }
23235: if (last == NULL)
23236: vctxt->inode->idcMatchers = matcher;
23237: else
23238: last->next = matcher;
23239: last = matcher;
23240:
23241: matcher->type = IDC_MATCHER;
23242: matcher->depth = vctxt->depth;
23243: matcher->aidc = aidc;
23244: matcher->idcType = aidc->def->type;
23245: #ifdef DEBUG_IDC
23246: xmlGenericError(xmlGenericErrorContext, "IDC: register matcher\n");
23247: #endif
23248: /*
23249: * Init the automaton state object.
23250: */
23251: if (xmlSchemaIDCAddStateObject(vctxt, matcher,
23252: idc->selector, XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) == -1)
23253: return (-1);
23254:
23255: idc = idc->next;
23256: } while (idc != NULL);
23257: return (0);
23258: }
23259:
23260: static int
23261: xmlSchemaIDCFillNodeTables(xmlSchemaValidCtxtPtr vctxt,
23262: xmlSchemaNodeInfoPtr ielem)
23263: {
23264: xmlSchemaPSVIIDCBindingPtr bind;
23265: int res, i, j, k, nbTargets, nbFields, nbDupls, nbNodeTable;
23266: xmlSchemaPSVIIDCKeyPtr *keys, *ntkeys;
23267: xmlSchemaPSVIIDCNodePtr *targets, *dupls;
23268:
23269: xmlSchemaIDCMatcherPtr matcher = ielem->idcMatchers;
23270: /* vctxt->createIDCNodeTables */
23271: while (matcher != NULL) {
23272: /*
23273: * Skip keyref IDCs and empty IDC target-lists.
23274: */
23275: if ((matcher->aidc->def->type == XML_SCHEMA_TYPE_IDC_KEYREF) ||
23276: WXS_ILIST_IS_EMPTY(matcher->targets))
23277: {
23278: matcher = matcher->next;
23279: continue;
23280: }
23281: /*
23282: * If we _want_ the IDC node-table to be created in any case
23283: * then do so. Otherwise create them only if keyrefs need them.
23284: */
23285: if ((! vctxt->createIDCNodeTables) &&
23286: ((matcher->aidc->keyrefDepth == -1) ||
23287: (matcher->aidc->keyrefDepth > vctxt->depth)))
23288: {
23289: matcher = matcher->next;
23290: continue;
23291: }
23292: /*
23293: * Get/create the IDC binding on this element for the IDC definition.
23294: */
23295: bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
23296:
23297: if (! WXS_ILIST_IS_EMPTY(bind->dupls)) {
23298: dupls = (xmlSchemaPSVIIDCNodePtr *) bind->dupls->items;
23299: nbDupls = bind->dupls->nbItems;
23300: } else {
23301: dupls = NULL;
23302: nbDupls = 0;
23303: }
23304: if (bind->nodeTable != NULL) {
23305: nbNodeTable = bind->nbNodes;
23306: } else {
23307: nbNodeTable = 0;
23308: }
23309:
23310: if ((nbNodeTable == 0) && (nbDupls == 0)) {
23311: /*
23312: * Transfer all IDC target-nodes to the IDC node-table.
23313: */
23314: bind->nodeTable =
23315: (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
23316: bind->sizeNodes = matcher->targets->sizeItems;
23317: bind->nbNodes = matcher->targets->nbItems;
23318:
23319: matcher->targets->items = NULL;
23320: matcher->targets->sizeItems = 0;
23321: matcher->targets->nbItems = 0;
23322: } else {
23323: /*
23324: * Compare the key-sequences and add to the IDC node-table.
23325: */
23326: nbTargets = matcher->targets->nbItems;
23327: targets = (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
23328: nbFields = matcher->aidc->def->nbFields;
23329: i = 0;
23330: do {
23331: keys = targets[i]->keys;
23332: if (nbDupls) {
23333: /*
23334: * Search in already found duplicates first.
23335: */
23336: j = 0;
23337: do {
23338: if (nbFields == 1) {
23339: res = xmlSchemaAreValuesEqual(keys[0]->val,
23340: dupls[j]->keys[0]->val);
23341: if (res == -1)
23342: goto internal_error;
23343: if (res == 1) {
23344: /*
23345: * Equal key-sequence.
23346: */
23347: goto next_target;
23348: }
23349: } else {
23350: res = 0;
23351: ntkeys = dupls[j]->keys;
23352: for (k = 0; k < nbFields; k++) {
23353: res = xmlSchemaAreValuesEqual(keys[k]->val,
23354: ntkeys[k]->val);
23355: if (res == -1)
23356: goto internal_error;
23357: if (res == 0) {
23358: /*
23359: * One of the keys differs.
23360: */
23361: break;
23362: }
23363: }
23364: if (res == 1) {
23365: /*
23366: * Equal key-sequence found.
23367: */
23368: goto next_target;
23369: }
23370: }
23371: j++;
23372: } while (j < nbDupls);
23373: }
23374: if (nbNodeTable) {
23375: j = 0;
23376: do {
23377: if (nbFields == 1) {
23378: res = xmlSchemaAreValuesEqual(keys[0]->val,
23379: bind->nodeTable[j]->keys[0]->val);
23380: if (res == -1)
23381: goto internal_error;
23382: if (res == 0) {
23383: /*
23384: * The key-sequence differs.
23385: */
23386: goto next_node_table_entry;
23387: }
23388: } else {
23389: res = 0;
23390: ntkeys = bind->nodeTable[j]->keys;
23391: for (k = 0; k < nbFields; k++) {
23392: res = xmlSchemaAreValuesEqual(keys[k]->val,
23393: ntkeys[k]->val);
23394: if (res == -1)
23395: goto internal_error;
23396: if (res == 0) {
23397: /*
23398: * One of the keys differs.
23399: */
23400: goto next_node_table_entry;
23401: }
23402: }
23403: }
23404: /*
23405: * Add the duplicate to the list of duplicates.
23406: */
23407: if (bind->dupls == NULL) {
23408: bind->dupls = xmlSchemaItemListCreate();
23409: if (bind->dupls == NULL)
23410: goto internal_error;
23411: }
23412: if (xmlSchemaItemListAdd(bind->dupls, bind->nodeTable[j]) == -1)
23413: goto internal_error;
23414: /*
23415: * Remove the duplicate entry from the IDC node-table.
23416: */
23417: bind->nodeTable[j] = bind->nodeTable[bind->nbNodes -1];
23418: bind->nbNodes--;
23419:
23420: goto next_target;
23421:
23422: next_node_table_entry:
23423: j++;
23424: } while (j < nbNodeTable);
23425: }
23426: /*
23427: * If everything is fine, then add the IDC target-node to
23428: * the IDC node-table.
23429: */
23430: if (xmlSchemaIDCAppendNodeTableItem(bind, targets[i]) == -1)
23431: goto internal_error;
23432:
23433: next_target:
23434: i++;
23435: } while (i < nbTargets);
23436: }
23437: matcher = matcher->next;
23438: }
23439: return(0);
23440:
23441: internal_error:
23442: return(-1);
23443: }
23444:
23445: /**
23446: * xmlSchemaBubbleIDCNodeTables:
23447: * @depth: the current tree depth
23448: *
23449: * Merges IDC bindings of an element at @depth into the corresponding IDC
23450: * bindings of its parent element. If a duplicate note-table entry is found,
23451: * both, the parent node-table entry and child entry are discarded from the
23452: * node-table of the parent.
23453: *
23454: * Returns 0 if OK and -1 on internal errors.
23455: */
23456: static int
23457: xmlSchemaBubbleIDCNodeTables(xmlSchemaValidCtxtPtr vctxt)
23458: {
23459: xmlSchemaPSVIIDCBindingPtr bind; /* IDC bindings of the current node. */
23460: xmlSchemaPSVIIDCBindingPtr *parTable, parBind = NULL; /* parent IDC bindings. */
23461: xmlSchemaPSVIIDCNodePtr node, parNode = NULL, *dupls, *parNodes; /* node-table entries. */
23462: xmlSchemaIDCAugPtr aidc;
23463: int i, j, k, ret = 0, nbFields, oldNum, oldDupls;
23464:
23465: bind = vctxt->inode->idcTable;
23466: if (bind == NULL) {
23467: /* Fine, no table, no bubbles. */
23468: return (0);
23469: }
23470:
23471: parTable = &(vctxt->elemInfos[vctxt->depth -1]->idcTable);
23472: /*
23473: * Walk all bindings; create new or add to existing bindings.
23474: * Remove duplicate key-sequences.
23475: */
23476: while (bind != NULL) {
23477:
23478: if ((bind->nbNodes == 0) && WXS_ILIST_IS_EMPTY(bind->dupls))
23479: goto next_binding;
23480: /*
23481: * Check if the key/unique IDC table needs to be bubbled.
23482: */
23483: if (! vctxt->createIDCNodeTables) {
23484: aidc = vctxt->aidcs;
23485: do {
23486: if (aidc->def == bind->definition) {
23487: if ((aidc->keyrefDepth == -1) ||
23488: (aidc->keyrefDepth >= vctxt->depth)) {
23489: goto next_binding;
23490: }
23491: break;
23492: }
23493: aidc = aidc->next;
23494: } while (aidc != NULL);
23495: }
23496:
23497: if (parTable != NULL)
23498: parBind = *parTable;
23499: /*
23500: * Search a matching parent binding for the
23501: * IDC definition.
23502: */
23503: while (parBind != NULL) {
23504: if (parBind->definition == bind->definition)
23505: break;
23506: parBind = parBind->next;
23507: }
23508:
23509: if (parBind != NULL) {
23510: /*
23511: * Compare every node-table entry of the child node,
23512: * i.e. the key-sequence within, ...
23513: */
23514: oldNum = parBind->nbNodes; /* Skip newly added items. */
23515:
23516: if (! WXS_ILIST_IS_EMPTY(parBind->dupls)) {
23517: oldDupls = parBind->dupls->nbItems;
23518: dupls = (xmlSchemaPSVIIDCNodePtr *) parBind->dupls->items;
23519: } else {
23520: dupls = NULL;
23521: oldDupls = 0;
23522: }
23523:
23524: parNodes = parBind->nodeTable;
23525: nbFields = bind->definition->nbFields;
23526:
23527: for (i = 0; i < bind->nbNodes; i++) {
23528: node = bind->nodeTable[i];
23529: if (node == NULL)
23530: continue;
23531: /*
23532: * ...with every key-sequence of the parent node, already
23533: * evaluated to be a duplicate key-sequence.
23534: */
23535: if (oldDupls) {
23536: j = 0;
23537: while (j < oldDupls) {
23538: if (nbFields == 1) {
23539: ret = xmlSchemaAreValuesEqual(
23540: node->keys[0]->val,
23541: dupls[j]->keys[0]->val);
23542: if (ret == -1)
23543: goto internal_error;
23544: if (ret == 0) {
23545: j++;
23546: continue;
23547: }
23548: } else {
23549: parNode = dupls[j];
23550: for (k = 0; k < nbFields; k++) {
23551: ret = xmlSchemaAreValuesEqual(
23552: node->keys[k]->val,
23553: parNode->keys[k]->val);
23554: if (ret == -1)
23555: goto internal_error;
23556: if (ret == 0)
23557: break;
23558: }
23559: }
23560: if (ret == 1)
23561: /* Duplicate found. */
23562: break;
23563: j++;
23564: }
23565: if (j != oldDupls) {
23566: /* Duplicate found. Skip this entry. */
23567: continue;
23568: }
23569: }
23570: /*
23571: * ... and with every key-sequence of the parent node.
23572: */
23573: if (oldNum) {
23574: j = 0;
23575: while (j < oldNum) {
23576: parNode = parNodes[j];
23577: if (nbFields == 1) {
23578: ret = xmlSchemaAreValuesEqual(
23579: node->keys[0]->val,
23580: parNode->keys[0]->val);
23581: if (ret == -1)
23582: goto internal_error;
23583: if (ret == 0) {
23584: j++;
23585: continue;
23586: }
23587: } else {
23588: for (k = 0; k < nbFields; k++) {
23589: ret = xmlSchemaAreValuesEqual(
23590: node->keys[k]->val,
23591: parNode->keys[k]->val);
23592: if (ret == -1)
23593: goto internal_error;
23594: if (ret == 0)
23595: break;
23596: }
23597: }
23598: if (ret == 1)
23599: /* Duplicate found. */
23600: break;
23601: j++;
23602: }
23603: if (j != oldNum) {
23604: /*
23605: * Handle duplicates. Move the duplicate in
23606: * the parent's node-table to the list of
23607: * duplicates.
23608: */
23609: oldNum--;
23610: parBind->nbNodes--;
23611: /*
23612: * Move last old item to pos of duplicate.
23613: */
23614: parNodes[j] = parNodes[oldNum];
23615:
23616: if (parBind->nbNodes != oldNum) {
23617: /*
23618: * If new items exist, move last new item to
23619: * last of old items.
23620: */
23621: parNodes[oldNum] =
23622: parNodes[parBind->nbNodes];
23623: }
23624: if (parBind->dupls == NULL) {
23625: parBind->dupls = xmlSchemaItemListCreate();
23626: if (parBind->dupls == NULL)
23627: goto internal_error;
23628: }
23629: xmlSchemaItemListAdd(parBind->dupls, parNode);
23630: } else {
23631: /*
23632: * Add the node-table entry (node and key-sequence) of
23633: * the child node to the node table of the parent node.
23634: */
23635: if (parBind->nodeTable == NULL) {
23636: parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
23637: xmlMalloc(10 * sizeof(xmlSchemaPSVIIDCNodePtr));
23638: if (parBind->nodeTable == NULL) {
23639: xmlSchemaVErrMemory(NULL,
23640: "allocating IDC list of node-table items", NULL);
23641: goto internal_error;
23642: }
23643: parBind->sizeNodes = 1;
23644: } else if (parBind->nbNodes >= parBind->sizeNodes) {
23645: parBind->sizeNodes *= 2;
23646: parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
23647: xmlRealloc(parBind->nodeTable, parBind->sizeNodes *
23648: sizeof(xmlSchemaPSVIIDCNodePtr));
23649: if (parBind->nodeTable == NULL) {
23650: xmlSchemaVErrMemory(NULL,
23651: "re-allocating IDC list of node-table items", NULL);
23652: goto internal_error;
23653: }
23654: }
23655: parNodes = parBind->nodeTable;
23656: /*
23657: * Append the new node-table entry to the 'new node-table
23658: * entries' section.
23659: */
23660: parNodes[parBind->nbNodes++] = node;
23661: }
23662:
23663: }
23664:
23665: }
23666: } else {
23667: /*
23668: * No binding for the IDC was found: create a new one and
23669: * copy all node-tables.
23670: */
23671: parBind = xmlSchemaIDCNewBinding(bind->definition);
23672: if (parBind == NULL)
23673: goto internal_error;
23674:
23675: /*
23676: * TODO: Hmm, how to optimize the initial number of
23677: * allocated entries?
23678: */
23679: if (bind->nbNodes != 0) {
23680: /*
23681: * Add all IDC node-table entries.
23682: */
23683: if (! vctxt->psviExposeIDCNodeTables) {
23684: /*
23685: * Just move the entries.
23686: * NOTE: this is quite save here, since
23687: * all the keyref lookups have already been
23688: * performed.
23689: */
23690: parBind->nodeTable = bind->nodeTable;
23691: bind->nodeTable = NULL;
23692: parBind->sizeNodes = bind->sizeNodes;
23693: bind->sizeNodes = 0;
23694: parBind->nbNodes = bind->nbNodes;
23695: bind->nbNodes = 0;
23696: } else {
23697: /*
23698: * Copy the entries.
23699: */
23700: parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
23701: xmlMalloc(bind->nbNodes *
23702: sizeof(xmlSchemaPSVIIDCNodePtr));
23703: if (parBind->nodeTable == NULL) {
23704: xmlSchemaVErrMemory(NULL,
23705: "allocating an array of IDC node-table "
23706: "items", NULL);
23707: xmlSchemaIDCFreeBinding(parBind);
23708: goto internal_error;
23709: }
23710: parBind->sizeNodes = bind->nbNodes;
23711: parBind->nbNodes = bind->nbNodes;
23712: memcpy(parBind->nodeTable, bind->nodeTable,
23713: bind->nbNodes * sizeof(xmlSchemaPSVIIDCNodePtr));
23714: }
23715: }
23716: if (bind->dupls) {
23717: /*
23718: * Move the duplicates.
23719: */
23720: if (parBind->dupls != NULL)
23721: xmlSchemaItemListFree(parBind->dupls);
23722: parBind->dupls = bind->dupls;
23723: bind->dupls = NULL;
23724: }
23725: if (parTable != NULL) {
23726: if (*parTable == NULL)
23727: *parTable = parBind;
23728: else {
23729: parBind->next = *parTable;
23730: *parTable = parBind;
23731: }
23732: }
23733: }
23734:
23735: next_binding:
23736: bind = bind->next;
23737: }
23738: return (0);
23739:
23740: internal_error:
23741: return(-1);
23742: }
23743:
23744: /**
23745: * xmlSchemaCheckCVCIDCKeyRef:
23746: * @vctxt: the WXS validation context
23747: * @elemDecl: the element declaration
23748: *
23749: * Check the cvc-idc-keyref constraints.
23750: */
23751: static int
23752: xmlSchemaCheckCVCIDCKeyRef(xmlSchemaValidCtxtPtr vctxt)
23753: {
23754: xmlSchemaIDCMatcherPtr matcher;
23755: xmlSchemaPSVIIDCBindingPtr bind;
23756:
23757: matcher = vctxt->inode->idcMatchers;
23758: /*
23759: * Find a keyref.
23760: */
23761: while (matcher != NULL) {
23762: if ((matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) &&
23763: matcher->targets &&
23764: matcher->targets->nbItems)
23765: {
23766: int i, j, k, res, nbFields, hasDupls;
23767: xmlSchemaPSVIIDCKeyPtr *refKeys, *keys;
23768: xmlSchemaPSVIIDCNodePtr refNode = NULL;
23769:
23770: nbFields = matcher->aidc->def->nbFields;
23771:
23772: /*
23773: * Find the IDC node-table for the referenced IDC key/unique.
23774: */
23775: bind = vctxt->inode->idcTable;
23776: while (bind != NULL) {
23777: if ((xmlSchemaIDCPtr) matcher->aidc->def->ref->item ==
23778: bind->definition)
23779: break;
23780: bind = bind->next;
23781: }
23782: hasDupls = (bind && bind->dupls && bind->dupls->nbItems) ? 1 : 0;
23783: /*
23784: * Search for a matching key-sequences.
23785: */
23786: for (i = 0; i < matcher->targets->nbItems; i++) {
23787: res = 0;
23788: refNode = matcher->targets->items[i];
23789: if (bind != NULL) {
23790: refKeys = refNode->keys;
23791: for (j = 0; j < bind->nbNodes; j++) {
23792: keys = bind->nodeTable[j]->keys;
23793: for (k = 0; k < nbFields; k++) {
23794: res = xmlSchemaAreValuesEqual(keys[k]->val,
23795: refKeys[k]->val);
23796: if (res == 0)
23797: break;
23798: else if (res == -1) {
23799: return (-1);
23800: }
23801: }
23802: if (res == 1) {
23803: /*
23804: * Match found.
23805: */
23806: break;
23807: }
23808: }
23809: if ((res == 0) && hasDupls) {
23810: /*
23811: * Search in duplicates
23812: */
23813: for (j = 0; j < bind->dupls->nbItems; j++) {
23814: keys = ((xmlSchemaPSVIIDCNodePtr)
23815: bind->dupls->items[j])->keys;
23816: for (k = 0; k < nbFields; k++) {
23817: res = xmlSchemaAreValuesEqual(keys[k]->val,
23818: refKeys[k]->val);
23819: if (res == 0)
23820: break;
23821: else if (res == -1) {
23822: return (-1);
23823: }
23824: }
23825: if (res == 1) {
23826: /*
23827: * Match in duplicates found.
23828: */
23829: xmlChar *str = NULL, *strB = NULL;
23830: xmlSchemaKeyrefErr(vctxt,
23831: XML_SCHEMAV_CVC_IDC, refNode,
23832: (xmlSchemaTypePtr) matcher->aidc->def,
23833: "More than one match found for "
23834: "key-sequence %s of keyref '%s'",
23835: xmlSchemaFormatIDCKeySequence(vctxt, &str,
23836: refNode->keys, nbFields),
23837: xmlSchemaGetComponentQName(&strB,
23838: matcher->aidc->def));
23839: FREE_AND_NULL(str);
23840: FREE_AND_NULL(strB);
23841: break;
23842: }
23843: }
23844: }
23845: }
23846:
23847: if (res == 0) {
23848: xmlChar *str = NULL, *strB = NULL;
23849: xmlSchemaKeyrefErr(vctxt,
23850: XML_SCHEMAV_CVC_IDC, refNode,
23851: (xmlSchemaTypePtr) matcher->aidc->def,
23852: "No match found for key-sequence %s of keyref '%s'",
23853: xmlSchemaFormatIDCKeySequence(vctxt, &str,
23854: refNode->keys, nbFields),
23855: xmlSchemaGetComponentQName(&strB, matcher->aidc->def));
23856: FREE_AND_NULL(str);
23857: FREE_AND_NULL(strB);
23858: }
23859: }
23860: }
23861: matcher = matcher->next;
23862: }
23863: /* TODO: Return an error if any error encountered. */
23864: return (0);
23865: }
23866:
23867: /************************************************************************
23868: * *
23869: * XML Reader validation code *
23870: * *
23871: ************************************************************************/
23872:
23873: static xmlSchemaAttrInfoPtr
23874: xmlSchemaGetFreshAttrInfo(xmlSchemaValidCtxtPtr vctxt)
23875: {
23876: xmlSchemaAttrInfoPtr iattr;
23877: /*
23878: * Grow/create list of attribute infos.
23879: */
23880: if (vctxt->attrInfos == NULL) {
23881: vctxt->attrInfos = (xmlSchemaAttrInfoPtr *)
23882: xmlMalloc(sizeof(xmlSchemaAttrInfoPtr));
23883: vctxt->sizeAttrInfos = 1;
23884: if (vctxt->attrInfos == NULL) {
23885: xmlSchemaVErrMemory(vctxt,
23886: "allocating attribute info list", NULL);
23887: return (NULL);
23888: }
23889: } else if (vctxt->sizeAttrInfos <= vctxt->nbAttrInfos) {
23890: vctxt->sizeAttrInfos++;
23891: vctxt->attrInfos = (xmlSchemaAttrInfoPtr *)
23892: xmlRealloc(vctxt->attrInfos,
23893: vctxt->sizeAttrInfos * sizeof(xmlSchemaAttrInfoPtr));
23894: if (vctxt->attrInfos == NULL) {
23895: xmlSchemaVErrMemory(vctxt,
23896: "re-allocating attribute info list", NULL);
23897: return (NULL);
23898: }
23899: } else {
23900: iattr = vctxt->attrInfos[vctxt->nbAttrInfos++];
23901: if (iattr->localName != NULL) {
23902: VERROR_INT("xmlSchemaGetFreshAttrInfo",
23903: "attr info not cleared");
23904: return (NULL);
23905: }
23906: iattr->nodeType = XML_ATTRIBUTE_NODE;
23907: return (iattr);
23908: }
23909: /*
23910: * Create an attribute info.
23911: */
23912: iattr = (xmlSchemaAttrInfoPtr)
23913: xmlMalloc(sizeof(xmlSchemaAttrInfo));
23914: if (iattr == NULL) {
23915: xmlSchemaVErrMemory(vctxt, "creating new attribute info", NULL);
23916: return (NULL);
23917: }
23918: memset(iattr, 0, sizeof(xmlSchemaAttrInfo));
23919: iattr->nodeType = XML_ATTRIBUTE_NODE;
23920: vctxt->attrInfos[vctxt->nbAttrInfos++] = iattr;
23921:
23922: return (iattr);
23923: }
23924:
23925: static int
23926: xmlSchemaValidatorPushAttribute(xmlSchemaValidCtxtPtr vctxt,
23927: xmlNodePtr attrNode,
23928: int nodeLine,
23929: const xmlChar *localName,
23930: const xmlChar *nsName,
23931: int ownedNames,
23932: xmlChar *value,
23933: int ownedValue)
23934: {
23935: xmlSchemaAttrInfoPtr attr;
23936:
23937: attr = xmlSchemaGetFreshAttrInfo(vctxt);
23938: if (attr == NULL) {
23939: VERROR_INT("xmlSchemaPushAttribute",
23940: "calling xmlSchemaGetFreshAttrInfo()");
23941: return (-1);
23942: }
23943: attr->node = attrNode;
23944: attr->nodeLine = nodeLine;
23945: attr->state = XML_SCHEMAS_ATTR_UNKNOWN;
23946: attr->localName = localName;
23947: attr->nsName = nsName;
23948: if (ownedNames)
23949: attr->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
23950: /*
23951: * Evaluate if it's an XSI attribute.
23952: */
23953: if (nsName != NULL) {
23954: if (xmlStrEqual(localName, BAD_CAST "nil")) {
23955: if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
23956: attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NIL;
23957: }
23958: } else if (xmlStrEqual(localName, BAD_CAST "type")) {
23959: if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
23960: attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_TYPE;
23961: }
23962: } else if (xmlStrEqual(localName, BAD_CAST "schemaLocation")) {
23963: if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
23964: attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC;
23965: }
23966: } else if (xmlStrEqual(localName, BAD_CAST "noNamespaceSchemaLocation")) {
23967: if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
23968: attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC;
23969: }
23970: } else if (xmlStrEqual(attr->nsName, xmlNamespaceNs)) {
23971: attr->metaType = XML_SCHEMA_ATTR_INFO_META_XMLNS;
23972: }
23973: }
23974: attr->value = value;
23975: if (ownedValue)
23976: attr->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
23977: if (attr->metaType != 0)
23978: attr->state = XML_SCHEMAS_ATTR_META;
23979: return (0);
23980: }
23981:
23982: /**
23983: * xmlSchemaClearElemInfo:
23984: * @vctxt: the WXS validation context
23985: * @ielem: the element information item
23986: */
23987: static void
23988: xmlSchemaClearElemInfo(xmlSchemaValidCtxtPtr vctxt,
23989: xmlSchemaNodeInfoPtr ielem)
23990: {
23991: ielem->hasKeyrefs = 0;
23992: ielem->appliedXPath = 0;
23993: if (ielem->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES) {
23994: FREE_AND_NULL(ielem->localName);
23995: FREE_AND_NULL(ielem->nsName);
23996: } else {
23997: ielem->localName = NULL;
23998: ielem->nsName = NULL;
23999: }
24000: if (ielem->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
24001: FREE_AND_NULL(ielem->value);
24002: } else {
24003: ielem->value = NULL;
24004: }
24005: if (ielem->val != NULL) {
24006: /*
24007: * PSVI TODO: Be careful not to free it when the value is
24008: * exposed via PSVI.
24009: */
24010: xmlSchemaFreeValue(ielem->val);
24011: ielem->val = NULL;
24012: }
24013: if (ielem->idcMatchers != NULL) {
24014: /*
24015: * REVISIT OPTIMIZE TODO: Use a pool of IDC matchers.
24016: * Does it work?
24017: */
24018: xmlSchemaIDCReleaseMatcherList(vctxt, ielem->idcMatchers);
24019: #if 0
24020: xmlSchemaIDCFreeMatcherList(ielem->idcMatchers);
24021: #endif
24022: ielem->idcMatchers = NULL;
24023: }
24024: if (ielem->idcTable != NULL) {
24025: /*
24026: * OPTIMIZE TODO: Use a pool of IDC tables??.
24027: */
24028: xmlSchemaIDCFreeIDCTable(ielem->idcTable);
24029: ielem->idcTable = NULL;
24030: }
24031: if (ielem->regexCtxt != NULL) {
24032: xmlRegFreeExecCtxt(ielem->regexCtxt);
24033: ielem->regexCtxt = NULL;
24034: }
24035: if (ielem->nsBindings != NULL) {
24036: xmlFree((xmlChar **)ielem->nsBindings);
24037: ielem->nsBindings = NULL;
24038: ielem->nbNsBindings = 0;
24039: ielem->sizeNsBindings = 0;
24040: }
24041: }
24042:
24043: /**
24044: * xmlSchemaGetFreshElemInfo:
24045: * @vctxt: the schema validation context
24046: *
24047: * Creates/reuses and initializes the element info item for
24048: * the currect tree depth.
24049: *
24050: * Returns the element info item or NULL on API or internal errors.
24051: */
24052: static xmlSchemaNodeInfoPtr
24053: xmlSchemaGetFreshElemInfo(xmlSchemaValidCtxtPtr vctxt)
24054: {
24055: xmlSchemaNodeInfoPtr info = NULL;
24056:
24057: if (vctxt->depth > vctxt->sizeElemInfos) {
24058: VERROR_INT("xmlSchemaGetFreshElemInfo",
24059: "inconsistent depth encountered");
24060: return (NULL);
24061: }
24062: if (vctxt->elemInfos == NULL) {
24063: vctxt->elemInfos = (xmlSchemaNodeInfoPtr *)
24064: xmlMalloc(10 * sizeof(xmlSchemaNodeInfoPtr));
24065: if (vctxt->elemInfos == NULL) {
24066: xmlSchemaVErrMemory(vctxt,
24067: "allocating the element info array", NULL);
24068: return (NULL);
24069: }
24070: memset(vctxt->elemInfos, 0, 10 * sizeof(xmlSchemaNodeInfoPtr));
24071: vctxt->sizeElemInfos = 10;
24072: } else if (vctxt->sizeElemInfos <= vctxt->depth) {
24073: int i = vctxt->sizeElemInfos;
24074:
24075: vctxt->sizeElemInfos *= 2;
24076: vctxt->elemInfos = (xmlSchemaNodeInfoPtr *)
24077: xmlRealloc(vctxt->elemInfos, vctxt->sizeElemInfos *
24078: sizeof(xmlSchemaNodeInfoPtr));
24079: if (vctxt->elemInfos == NULL) {
24080: xmlSchemaVErrMemory(vctxt,
24081: "re-allocating the element info array", NULL);
24082: return (NULL);
24083: }
24084: /*
24085: * We need the new memory to be NULLed.
24086: * TODO: Use memset instead?
24087: */
24088: for (; i < vctxt->sizeElemInfos; i++)
24089: vctxt->elemInfos[i] = NULL;
24090: } else
24091: info = vctxt->elemInfos[vctxt->depth];
24092:
24093: if (info == NULL) {
24094: info = (xmlSchemaNodeInfoPtr)
24095: xmlMalloc(sizeof(xmlSchemaNodeInfo));
24096: if (info == NULL) {
24097: xmlSchemaVErrMemory(vctxt,
24098: "allocating an element info", NULL);
24099: return (NULL);
24100: }
24101: vctxt->elemInfos[vctxt->depth] = info;
24102: } else {
24103: if (info->localName != NULL) {
24104: VERROR_INT("xmlSchemaGetFreshElemInfo",
24105: "elem info has not been cleared");
24106: return (NULL);
24107: }
24108: }
24109: memset(info, 0, sizeof(xmlSchemaNodeInfo));
24110: info->nodeType = XML_ELEMENT_NODE;
24111: info->depth = vctxt->depth;
24112:
24113: return (info);
24114: }
24115:
24116: #define ACTIVATE_ATTRIBUTE(item) vctxt->inode = (xmlSchemaNodeInfoPtr) item;
24117: #define ACTIVATE_ELEM vctxt->inode = vctxt->elemInfos[vctxt->depth];
24118: #define ACTIVATE_PARENT_ELEM vctxt->inode = vctxt->elemInfos[vctxt->depth -1];
24119:
24120: static int
24121: xmlSchemaValidateFacets(xmlSchemaAbstractCtxtPtr actxt,
24122: xmlNodePtr node,
24123: xmlSchemaTypePtr type,
24124: xmlSchemaValType valType,
24125: const xmlChar * value,
24126: xmlSchemaValPtr val,
24127: unsigned long length,
24128: int fireErrors)
24129: {
24130: int ret, error = 0;
24131:
24132: xmlSchemaTypePtr tmpType;
24133: xmlSchemaFacetLinkPtr facetLink;
24134: xmlSchemaFacetPtr facet;
24135: unsigned long len = 0;
24136: xmlSchemaWhitespaceValueType ws;
24137:
24138: /*
24139: * In Libxml2, derived built-in types have currently no explicit facets.
24140: */
24141: if (type->type == XML_SCHEMA_TYPE_BASIC)
24142: return (0);
24143:
24144: /*
24145: * NOTE: Do not jump away, if the facetSet of the given type is
24146: * empty: until now, "pattern" and "enumeration" facets of the
24147: * *base types* need to be checked as well.
24148: */
24149: if (type->facetSet == NULL)
24150: goto pattern_and_enum;
24151:
24152: if (! WXS_IS_ATOMIC(type)) {
24153: if (WXS_IS_LIST(type))
24154: goto WXS_IS_LIST;
24155: else
24156: goto pattern_and_enum;
24157: }
24158: /*
24159: * Whitespace handling is only of importance for string-based
24160: * types.
24161: */
24162: tmpType = xmlSchemaGetPrimitiveType(type);
24163: if ((tmpType->builtInType == XML_SCHEMAS_STRING) ||
24164: WXS_IS_ANY_SIMPLE_TYPE(tmpType)) {
24165: ws = xmlSchemaGetWhiteSpaceFacetValue(type);
24166: } else
24167: ws = XML_SCHEMA_WHITESPACE_COLLAPSE;
24168: /*
24169: * If the value was not computed (for string or
24170: * anySimpleType based types), then use the provided
24171: * type.
24172: */
24173: if (val == NULL)
24174: valType = valType;
24175: else
24176: valType = xmlSchemaGetValType(val);
24177:
24178: ret = 0;
24179: for (facetLink = type->facetSet; facetLink != NULL;
24180: facetLink = facetLink->next) {
24181: /*
24182: * Skip the pattern "whiteSpace": it is used to
24183: * format the character content beforehand.
24184: */
24185: switch (facetLink->facet->type) {
24186: case XML_SCHEMA_FACET_WHITESPACE:
24187: case XML_SCHEMA_FACET_PATTERN:
24188: case XML_SCHEMA_FACET_ENUMERATION:
24189: continue;
24190: case XML_SCHEMA_FACET_LENGTH:
24191: case XML_SCHEMA_FACET_MINLENGTH:
24192: case XML_SCHEMA_FACET_MAXLENGTH:
24193: ret = xmlSchemaValidateLengthFacetWhtsp(facetLink->facet,
24194: valType, value, val, &len, ws);
24195: break;
24196: default:
24197: ret = xmlSchemaValidateFacetWhtsp(facetLink->facet, ws,
24198: valType, value, val, ws);
24199: break;
24200: }
24201: if (ret < 0) {
24202: AERROR_INT("xmlSchemaValidateFacets",
24203: "validating against a atomic type facet");
24204: return (-1);
24205: } else if (ret > 0) {
24206: if (fireErrors)
24207: xmlSchemaFacetErr(actxt, ret, node,
24208: value, len, type, facetLink->facet, NULL, NULL, NULL);
24209: else
24210: return (ret);
24211: if (error == 0)
24212: error = ret;
24213: }
24214: ret = 0;
24215: }
24216:
24217: WXS_IS_LIST:
24218: if (! WXS_IS_LIST(type))
24219: goto pattern_and_enum;
24220: /*
24221: * "length", "minLength" and "maxLength" of list types.
24222: */
24223: ret = 0;
24224: for (facetLink = type->facetSet; facetLink != NULL;
24225: facetLink = facetLink->next) {
24226:
24227: switch (facetLink->facet->type) {
24228: case XML_SCHEMA_FACET_LENGTH:
24229: case XML_SCHEMA_FACET_MINLENGTH:
24230: case XML_SCHEMA_FACET_MAXLENGTH:
24231: ret = xmlSchemaValidateListSimpleTypeFacet(facetLink->facet,
24232: value, length, NULL);
24233: break;
24234: default:
24235: continue;
24236: }
24237: if (ret < 0) {
24238: AERROR_INT("xmlSchemaValidateFacets",
24239: "validating against a list type facet");
24240: return (-1);
24241: } else if (ret > 0) {
24242: if (fireErrors)
24243: xmlSchemaFacetErr(actxt, ret, node,
24244: value, length, type, facetLink->facet, NULL, NULL, NULL);
24245: else
24246: return (ret);
24247: if (error == 0)
24248: error = ret;
24249: }
24250: ret = 0;
24251: }
24252:
24253: pattern_and_enum:
24254: if (error >= 0) {
24255: int found = 0;
24256: /*
24257: * Process enumerations. Facet values are in the value space
24258: * of the defining type's base type. This seems to be a bug in the
24259: * XML Schema 1.0 spec. Use the whitespace type of the base type.
24260: * Only the first set of enumerations in the ancestor-or-self axis
24261: * is used for validation.
24262: */
24263: ret = 0;
24264: tmpType = type;
24265: do {
24266: for (facet = tmpType->facets; facet != NULL; facet = facet->next) {
24267: if (facet->type != XML_SCHEMA_FACET_ENUMERATION)
24268: continue;
24269: found = 1;
24270: ret = xmlSchemaAreValuesEqual(facet->val, val);
24271: if (ret == 1)
24272: break;
24273: else if (ret < 0) {
24274: AERROR_INT("xmlSchemaValidateFacets",
24275: "validating against an enumeration facet");
24276: return (-1);
24277: }
24278: }
24279: if (ret != 0)
24280: break;
24281: /*
24282: * Break on the first set of enumerations. Any additional
24283: * enumerations which might be existent on the ancestors
24284: * of the current type are restricted by this set; thus
24285: * *must* *not* be taken into account.
24286: */
24287: if (found)
24288: break;
24289: tmpType = tmpType->baseType;
24290: } while ((tmpType != NULL) &&
24291: (tmpType->type != XML_SCHEMA_TYPE_BASIC));
24292: if (found && (ret == 0)) {
24293: ret = XML_SCHEMAV_CVC_ENUMERATION_VALID;
24294: if (fireErrors) {
24295: xmlSchemaFacetErr(actxt, ret, node,
24296: value, 0, type, NULL, NULL, NULL, NULL);
24297: } else
24298: return (ret);
24299: if (error == 0)
24300: error = ret;
24301: }
24302: }
24303:
24304: if (error >= 0) {
24305: int found;
24306: /*
24307: * Process patters. Pattern facets are ORed at type level
24308: * and ANDed if derived. Walk the base type axis.
24309: */
24310: tmpType = type;
24311: facet = NULL;
24312: do {
24313: found = 0;
24314: for (facetLink = tmpType->facetSet; facetLink != NULL;
24315: facetLink = facetLink->next) {
24316: if (facetLink->facet->type != XML_SCHEMA_FACET_PATTERN)
24317: continue;
24318: found = 1;
24319: /*
24320: * NOTE that for patterns, @value needs to be the
24321: * normalized vaule.
24322: */
24323: ret = xmlRegexpExec(facetLink->facet->regexp, value);
24324: if (ret == 1)
24325: break;
24326: else if (ret < 0) {
24327: AERROR_INT("xmlSchemaValidateFacets",
24328: "validating against a pattern facet");
24329: return (-1);
24330: } else {
24331: /*
24332: * Save the last non-validating facet.
24333: */
24334: facet = facetLink->facet;
24335: }
24336: }
24337: if (found && (ret != 1)) {
24338: ret = XML_SCHEMAV_CVC_PATTERN_VALID;
24339: if (fireErrors) {
24340: xmlSchemaFacetErr(actxt, ret, node,
24341: value, 0, type, facet, NULL, NULL, NULL);
24342: } else
24343: return (ret);
24344: if (error == 0)
24345: error = ret;
24346: break;
24347: }
24348: tmpType = tmpType->baseType;
24349: } while ((tmpType != NULL) && (tmpType->type != XML_SCHEMA_TYPE_BASIC));
24350: }
24351:
24352: return (error);
24353: }
24354:
24355: static xmlChar *
24356: xmlSchemaNormalizeValue(xmlSchemaTypePtr type,
24357: const xmlChar *value)
24358: {
24359: switch (xmlSchemaGetWhiteSpaceFacetValue(type)) {
24360: case XML_SCHEMA_WHITESPACE_COLLAPSE:
24361: return (xmlSchemaCollapseString(value));
24362: case XML_SCHEMA_WHITESPACE_REPLACE:
24363: return (xmlSchemaWhiteSpaceReplace(value));
24364: default:
24365: return (NULL);
24366: }
24367: }
24368:
24369: static int
24370: xmlSchemaValidateQName(xmlSchemaValidCtxtPtr vctxt,
24371: const xmlChar *value,
24372: xmlSchemaValPtr *val,
24373: int valNeeded)
24374: {
24375: int ret;
24376: const xmlChar *nsName;
24377: xmlChar *local, *prefix = NULL;
24378:
24379: ret = xmlValidateQName(value, 1);
24380: if (ret != 0) {
24381: if (ret == -1) {
24382: VERROR_INT("xmlSchemaValidateQName",
24383: "calling xmlValidateQName()");
24384: return (-1);
24385: }
24386: return( XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1);
24387: }
24388: /*
24389: * NOTE: xmlSplitQName2 will always return a duplicated
24390: * strings.
24391: */
24392: local = xmlSplitQName2(value, &prefix);
24393: if (local == NULL)
24394: local = xmlStrdup(value);
24395: /*
24396: * OPTIMIZE TODO: Use flags for:
24397: * - is there any namespace binding?
24398: * - is there a default namespace?
24399: */
24400: nsName = xmlSchemaLookupNamespace(vctxt, prefix);
24401:
24402: if (prefix != NULL) {
24403: xmlFree(prefix);
24404: /*
24405: * A namespace must be found if the prefix is
24406: * NOT NULL.
24407: */
24408: if (nsName == NULL) {
24409: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
24410: xmlSchemaCustomErr(ACTXT_CAST vctxt, ret, NULL,
24411: WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
24412: "The QName value '%s' has no "
24413: "corresponding namespace declaration in "
24414: "scope", value, NULL);
24415: if (local != NULL)
24416: xmlFree(local);
24417: return (ret);
24418: }
24419: }
24420: if (valNeeded && val) {
24421: if (nsName != NULL)
24422: *val = xmlSchemaNewQNameValue(
24423: BAD_CAST xmlStrdup(nsName), BAD_CAST local);
24424: else
24425: *val = xmlSchemaNewQNameValue(NULL,
24426: BAD_CAST local);
24427: } else
24428: xmlFree(local);
24429: return (0);
24430: }
24431:
24432: /*
24433: * cvc-simple-type
24434: */
24435: static int
24436: xmlSchemaVCheckCVCSimpleType(xmlSchemaAbstractCtxtPtr actxt,
24437: xmlNodePtr node,
24438: xmlSchemaTypePtr type,
24439: const xmlChar *value,
24440: xmlSchemaValPtr *retVal,
24441: int fireErrors,
24442: int normalize,
24443: int isNormalized)
24444: {
24445: int ret = 0, valNeeded = (retVal) ? 1 : 0;
24446: xmlSchemaValPtr val = NULL;
24447: /* xmlSchemaWhitespaceValueType ws; */
24448: xmlChar *normValue = NULL;
24449:
24450: #define NORMALIZE(atype) \
24451: if ((! isNormalized) && \
24452: (normalize || (type->flags & XML_SCHEMAS_TYPE_NORMVALUENEEDED))) { \
24453: normValue = xmlSchemaNormalizeValue(atype, value); \
24454: if (normValue != NULL) \
24455: value = normValue; \
24456: isNormalized = 1; \
24457: }
24458:
24459: if ((retVal != NULL) && (*retVal != NULL)) {
24460: xmlSchemaFreeValue(*retVal);
24461: *retVal = NULL;
24462: }
24463: /*
24464: * 3.14.4 Simple Type Definition Validation Rules
24465: * Validation Rule: String Valid
24466: */
24467: /*
24468: * 1 It is schema-valid with respect to that definition as defined
24469: * by Datatype Valid in [XML Schemas: Datatypes].
24470: */
24471: /*
24472: * 2.1 If The definition is ENTITY or is validly derived from ENTITY given
24473: * the empty set, as defined in Type Derivation OK (Simple) (�3.14.6), then
24474: * the string must be a �declared entity name�.
24475: */
24476: /*
24477: * 2.2 If The definition is ENTITIES or is validly derived from ENTITIES
24478: * given the empty set, as defined in Type Derivation OK (Simple) (�3.14.6),
24479: * then every whitespace-delimited substring of the string must be a �declared
24480: * entity name�.
24481: */
24482: /*
24483: * 2.3 otherwise no further condition applies.
24484: */
24485: if ((! valNeeded) && (type->flags & XML_SCHEMAS_TYPE_FACETSNEEDVALUE))
24486: valNeeded = 1;
24487: if (value == NULL)
24488: value = BAD_CAST "";
24489: if (WXS_IS_ANY_SIMPLE_TYPE(type) || WXS_IS_ATOMIC(type)) {
24490: xmlSchemaTypePtr biType; /* The built-in type. */
24491: /*
24492: * SPEC (1.2.1) "if {variety} is �atomic� then the string must �match�
24493: * a literal in the �lexical space� of {base type definition}"
24494: */
24495: /*
24496: * Whitespace-normalize.
24497: */
24498: NORMALIZE(type);
24499: if (type->type != XML_SCHEMA_TYPE_BASIC) {
24500: /*
24501: * Get the built-in type.
24502: */
24503: biType = type->baseType;
24504: while ((biType != NULL) &&
24505: (biType->type != XML_SCHEMA_TYPE_BASIC))
24506: biType = biType->baseType;
24507:
24508: if (biType == NULL) {
24509: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24510: "could not get the built-in type");
24511: goto internal_error;
24512: }
24513: } else
24514: biType = type;
24515: /*
24516: * NOTATIONs need to be processed here, since they need
24517: * to lookup in the hashtable of NOTATION declarations of the schema.
24518: */
24519: if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
24520: switch (biType->builtInType) {
24521: case XML_SCHEMAS_NOTATION:
24522: ret = xmlSchemaValidateNotation(
24523: (xmlSchemaValidCtxtPtr) actxt,
24524: ((xmlSchemaValidCtxtPtr) actxt)->schema,
24525: NULL, value, &val, valNeeded);
24526: break;
24527: case XML_SCHEMAS_QNAME:
24528: ret = xmlSchemaValidateQName((xmlSchemaValidCtxtPtr) actxt,
24529: value, &val, valNeeded);
24530: break;
24531: default:
24532: /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
24533: if (valNeeded)
24534: ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
24535: value, &val, node);
24536: else
24537: ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
24538: value, NULL, node);
24539: break;
24540: }
24541: } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
24542: switch (biType->builtInType) {
24543: case XML_SCHEMAS_NOTATION:
24544: ret = xmlSchemaValidateNotation(NULL,
24545: ((xmlSchemaParserCtxtPtr) actxt)->schema, node,
24546: value, &val, valNeeded);
24547: break;
24548: default:
24549: /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
24550: if (valNeeded)
24551: ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
24552: value, &val, node);
24553: else
24554: ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
24555: value, NULL, node);
24556: break;
24557: }
24558: } else {
24559: /*
24560: * Validation via a public API is not implemented yet.
24561: */
24562: TODO
24563: goto internal_error;
24564: }
24565: if (ret != 0) {
24566: if (ret < 0) {
24567: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24568: "validating against a built-in type");
24569: goto internal_error;
24570: }
24571: if (WXS_IS_LIST(type))
24572: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
24573: else
24574: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
24575: }
24576: if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
24577: /*
24578: * Check facets.
24579: */
24580: ret = xmlSchemaValidateFacets(actxt, node, type,
24581: (xmlSchemaValType) biType->builtInType, value, val,
24582: 0, fireErrors);
24583: if (ret != 0) {
24584: if (ret < 0) {
24585: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24586: "validating facets of atomic simple type");
24587: goto internal_error;
24588: }
24589: if (WXS_IS_LIST(type))
24590: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
24591: else
24592: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
24593: }
24594: }
24595: if (fireErrors && (ret > 0))
24596: xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
24597: } else if (WXS_IS_LIST(type)) {
24598:
24599: xmlSchemaTypePtr itemType;
24600: const xmlChar *cur, *end;
24601: xmlChar *tmpValue = NULL;
24602: unsigned long len = 0;
24603: xmlSchemaValPtr prevVal = NULL, curVal = NULL;
24604: /* 1.2.2 if {variety} is �list� then the string must be a sequence
24605: * of white space separated tokens, each of which �match�es a literal
24606: * in the �lexical space� of {item type definition}
24607: */
24608: /*
24609: * Note that XML_SCHEMAS_TYPE_NORMVALUENEEDED will be set if
24610: * the list type has an enum or pattern facet.
24611: */
24612: NORMALIZE(type);
24613: /*
24614: * VAL TODO: Optimize validation of empty values.
24615: * VAL TODO: We do not have computed values for lists.
24616: */
24617: itemType = WXS_LIST_ITEMTYPE(type);
24618: cur = value;
24619: do {
24620: while (IS_BLANK_CH(*cur))
24621: cur++;
24622: end = cur;
24623: while ((*end != 0) && (!(IS_BLANK_CH(*end))))
24624: end++;
24625: if (end == cur)
24626: break;
24627: tmpValue = xmlStrndup(cur, end - cur);
24628: len++;
24629:
24630: if (valNeeded)
24631: ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
24632: tmpValue, &curVal, fireErrors, 0, 1);
24633: else
24634: ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
24635: tmpValue, NULL, fireErrors, 0, 1);
24636: FREE_AND_NULL(tmpValue);
24637: if (curVal != NULL) {
24638: /*
24639: * Add to list of computed values.
24640: */
24641: if (val == NULL)
24642: val = curVal;
24643: else
24644: xmlSchemaValueAppend(prevVal, curVal);
24645: prevVal = curVal;
24646: curVal = NULL;
24647: }
24648: if (ret != 0) {
24649: if (ret < 0) {
24650: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24651: "validating an item of list simple type");
24652: goto internal_error;
24653: }
24654: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
24655: break;
24656: }
24657: cur = end;
24658: } while (*cur != 0);
24659: FREE_AND_NULL(tmpValue);
24660: if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
24661: /*
24662: * Apply facets (pattern, enumeration).
24663: */
24664: ret = xmlSchemaValidateFacets(actxt, node, type,
24665: XML_SCHEMAS_UNKNOWN, value, val,
24666: len, fireErrors);
24667: if (ret != 0) {
24668: if (ret < 0) {
24669: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24670: "validating facets of list simple type");
24671: goto internal_error;
24672: }
24673: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
24674: }
24675: }
24676: if (fireErrors && (ret > 0)) {
24677: /*
24678: * Report the normalized value.
24679: */
24680: normalize = 1;
24681: NORMALIZE(type);
24682: xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
24683: }
24684: } else if (WXS_IS_UNION(type)) {
24685: xmlSchemaTypeLinkPtr memberLink;
24686: /*
24687: * TODO: For all datatypes �derived� by �union� whiteSpace does
24688: * not apply directly; however, the normalization behavior of �union�
24689: * types is controlled by the value of whiteSpace on that one of the
24690: * �memberTypes� against which the �union� is successfully validated.
24691: *
24692: * This means that the value is normalized by the first validating
24693: * member type, then the facets of the union type are applied. This
24694: * needs changing of the value!
24695: */
24696:
24697: /*
24698: * 1.2.3 if {variety} is �union� then the string must �match� a
24699: * literal in the �lexical space� of at least one member of
24700: * {member type definitions}
24701: */
24702: memberLink = xmlSchemaGetUnionSimpleTypeMemberTypes(type);
24703: if (memberLink == NULL) {
24704: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24705: "union simple type has no member types");
24706: goto internal_error;
24707: }
24708: /*
24709: * Always normalize union type values, since we currently
24710: * cannot store the whitespace information with the value
24711: * itself; otherwise a later value-comparison would be
24712: * not possible.
24713: */
24714: while (memberLink != NULL) {
24715: if (valNeeded)
24716: ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
24717: memberLink->type, value, &val, 0, 1, 0);
24718: else
24719: ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
24720: memberLink->type, value, NULL, 0, 1, 0);
24721: if (ret <= 0)
24722: break;
24723: memberLink = memberLink->next;
24724: }
24725: if (ret != 0) {
24726: if (ret < 0) {
24727: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24728: "validating members of union simple type");
24729: goto internal_error;
24730: }
24731: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
24732: }
24733: /*
24734: * Apply facets (pattern, enumeration).
24735: */
24736: if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
24737: /*
24738: * The normalization behavior of �union� types is controlled by
24739: * the value of whiteSpace on that one of the �memberTypes�
24740: * against which the �union� is successfully validated.
24741: */
24742: NORMALIZE(memberLink->type);
24743: ret = xmlSchemaValidateFacets(actxt, node, type,
24744: XML_SCHEMAS_UNKNOWN, value, val,
24745: 0, fireErrors);
24746: if (ret != 0) {
24747: if (ret < 0) {
24748: AERROR_INT("xmlSchemaVCheckCVCSimpleType",
24749: "validating facets of union simple type");
24750: goto internal_error;
24751: }
24752: ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
24753: }
24754: }
24755: if (fireErrors && (ret > 0))
24756: xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
24757: }
24758:
24759: if (normValue != NULL)
24760: xmlFree(normValue);
24761: if (ret == 0) {
24762: if (retVal != NULL)
24763: *retVal = val;
24764: else if (val != NULL)
24765: xmlSchemaFreeValue(val);
24766: } else if (val != NULL)
24767: xmlSchemaFreeValue(val);
24768: return (ret);
24769: internal_error:
24770: if (normValue != NULL)
24771: xmlFree(normValue);
24772: if (val != NULL)
24773: xmlSchemaFreeValue(val);
24774: return (-1);
24775: }
24776:
24777: static int
24778: xmlSchemaVExpandQName(xmlSchemaValidCtxtPtr vctxt,
24779: const xmlChar *value,
24780: const xmlChar **nsName,
24781: const xmlChar **localName)
24782: {
24783: int ret = 0;
24784:
24785: if ((nsName == NULL) || (localName == NULL))
24786: return (-1);
24787: *nsName = NULL;
24788: *localName = NULL;
24789:
24790: ret = xmlValidateQName(value, 1);
24791: if (ret == -1)
24792: return (-1);
24793: if (ret > 0) {
24794: xmlSchemaSimpleTypeErr(ACTXT_CAST vctxt,
24795: XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, NULL,
24796: value, xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), 1);
24797: return (1);
24798: }
24799: {
24800: xmlChar *local = NULL;
24801: xmlChar *prefix;
24802:
24803: /*
24804: * NOTE: xmlSplitQName2 will return a duplicated
24805: * string.
24806: */
24807: local = xmlSplitQName2(value, &prefix);
24808: if (local == NULL)
24809: *localName = xmlDictLookup(vctxt->dict, value, -1);
24810: else {
24811: *localName = xmlDictLookup(vctxt->dict, local, -1);
24812: xmlFree(local);
24813: }
24814:
24815: *nsName = xmlSchemaLookupNamespace(vctxt, prefix);
24816:
24817: if (prefix != NULL) {
24818: xmlFree(prefix);
24819: /*
24820: * A namespace must be found if the prefix is NOT NULL.
24821: */
24822: if (*nsName == NULL) {
24823: xmlSchemaCustomErr(ACTXT_CAST vctxt,
24824: XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, NULL,
24825: WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
24826: "The QName value '%s' has no "
24827: "corresponding namespace declaration in scope",
24828: value, NULL);
24829: return (2);
24830: }
24831: }
24832: }
24833: return (0);
24834: }
24835:
24836: static int
24837: xmlSchemaProcessXSIType(xmlSchemaValidCtxtPtr vctxt,
24838: xmlSchemaAttrInfoPtr iattr,
24839: xmlSchemaTypePtr *localType,
24840: xmlSchemaElementPtr elemDecl)
24841: {
24842: int ret = 0;
24843: /*
24844: * cvc-elt (3.3.4) : (4)
24845: * AND
24846: * Schema-Validity Assessment (Element) (cvc-assess-elt)
24847: * (1.2.1.2.1) - (1.2.1.2.4)
24848: * Handle 'xsi:type'.
24849: */
24850: if (localType == NULL)
24851: return (-1);
24852: *localType = NULL;
24853: if (iattr == NULL)
24854: return (0);
24855: else {
24856: const xmlChar *nsName = NULL, *local = NULL;
24857: /*
24858: * TODO: We should report a *warning* that the type was overriden
24859: * by the instance.
24860: */
24861: ACTIVATE_ATTRIBUTE(iattr);
24862: /*
24863: * (cvc-elt) (3.3.4) : (4.1)
24864: * (cvc-assess-elt) (1.2.1.2.2)
24865: */
24866: ret = xmlSchemaVExpandQName(vctxt, iattr->value,
24867: &nsName, &local);
24868: if (ret != 0) {
24869: if (ret < 0) {
24870: VERROR_INT("xmlSchemaValidateElementByDeclaration",
24871: "calling xmlSchemaQNameExpand() to validate the "
24872: "attribute 'xsi:type'");
24873: goto internal_error;
24874: }
24875: goto exit;
24876: }
24877: /*
24878: * (cvc-elt) (3.3.4) : (4.2)
24879: * (cvc-assess-elt) (1.2.1.2.3)
24880: */
24881: *localType = xmlSchemaGetType(vctxt->schema, local, nsName);
24882: if (*localType == NULL) {
24883: xmlChar *str = NULL;
24884:
24885: xmlSchemaCustomErr(ACTXT_CAST vctxt,
24886: XML_SCHEMAV_CVC_ELT_4_2, NULL,
24887: WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
24888: "The QName value '%s' of the xsi:type attribute does not "
24889: "resolve to a type definition",
24890: xmlSchemaFormatQName(&str, nsName, local), NULL);
24891: FREE_AND_NULL(str);
24892: ret = vctxt->err;
24893: goto exit;
24894: }
24895: if (elemDecl != NULL) {
24896: int set = 0;
24897:
24898: /*
24899: * SPEC cvc-elt (3.3.4) : (4.3) (Type Derivation OK)
24900: * "The �local type definition� must be validly
24901: * derived from the {type definition} given the union of
24902: * the {disallowed substitutions} and the {type definition}'s
24903: * {prohibited substitutions}, as defined in
24904: * Type Derivation OK (Complex) (�3.4.6)
24905: * (if it is a complex type definition),
24906: * or given {disallowed substitutions} as defined in Type
24907: * Derivation OK (Simple) (�3.14.6) (if it is a simple type
24908: * definition)."
24909: *
24910: * {disallowed substitutions}: the "block" on the element decl.
24911: * {prohibited substitutions}: the "block" on the type def.
24912: */
24913: /*
24914: * OPTIMIZE TODO: We could map types already evaluated
24915: * to be validly derived from other types to avoid checking
24916: * this over and over for the same types.
24917: */
24918: if ((elemDecl->flags & XML_SCHEMAS_ELEM_BLOCK_EXTENSION) ||
24919: (elemDecl->subtypes->flags &
24920: XML_SCHEMAS_TYPE_BLOCK_EXTENSION))
24921: set |= SUBSET_EXTENSION;
24922:
24923: if ((elemDecl->flags & XML_SCHEMAS_ELEM_BLOCK_RESTRICTION) ||
24924: (elemDecl->subtypes->flags &
24925: XML_SCHEMAS_TYPE_BLOCK_RESTRICTION))
24926: set |= SUBSET_RESTRICTION;
24927:
24928: /*
24929: * REMOVED and CHANGED since this produced a parser context
24930: * which adds to the string dict of the schema. So this would
24931: * change the schema and we don't want this. We don't need
24932: * the parser context anymore.
24933: *
24934: * if ((vctxt->pctxt == NULL) &&
24935: * (xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1))
24936: * return (-1);
24937: */
24938:
24939: if (xmlSchemaCheckCOSDerivedOK(ACTXT_CAST vctxt, *localType,
24940: elemDecl->subtypes, set) != 0) {
24941: xmlChar *str = NULL;
24942:
24943: xmlSchemaCustomErr(ACTXT_CAST vctxt,
24944: XML_SCHEMAV_CVC_ELT_4_3, NULL, NULL,
24945: "The type definition '%s', specified by xsi:type, is "
24946: "blocked or not validly derived from the type definition "
24947: "of the element declaration",
24948: xmlSchemaFormatQName(&str,
24949: (*localType)->targetNamespace,
24950: (*localType)->name),
24951: NULL);
24952: FREE_AND_NULL(str);
24953: ret = vctxt->err;
24954: *localType = NULL;
24955: }
24956: }
24957: }
24958: exit:
24959: ACTIVATE_ELEM;
24960: return (ret);
24961: internal_error:
24962: ACTIVATE_ELEM;
24963: return (-1);
24964: }
24965:
24966: static int
24967: xmlSchemaValidateElemDecl(xmlSchemaValidCtxtPtr vctxt)
24968: {
24969: xmlSchemaElementPtr elemDecl = vctxt->inode->decl;
24970: xmlSchemaTypePtr actualType;
24971:
24972: /*
24973: * cvc-elt (3.3.4) : 1
24974: */
24975: if (elemDecl == NULL) {
24976: VERROR(XML_SCHEMAV_CVC_ELT_1, NULL,
24977: "No matching declaration available");
24978: return (vctxt->err);
24979: }
24980: actualType = WXS_ELEM_TYPEDEF(elemDecl);
24981: /*
24982: * cvc-elt (3.3.4) : 2
24983: */
24984: if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
24985: VERROR(XML_SCHEMAV_CVC_ELT_2, NULL,
24986: "The element declaration is abstract");
24987: return (vctxt->err);
24988: }
24989: if (actualType == NULL) {
24990: VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
24991: "The type definition is absent");
24992: return (XML_SCHEMAV_CVC_TYPE_1);
24993: }
24994: if (vctxt->nbAttrInfos != 0) {
24995: int ret;
24996: xmlSchemaAttrInfoPtr iattr;
24997: /*
24998: * cvc-elt (3.3.4) : 3
24999: * Handle 'xsi:nil'.
25000: */
25001: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
25002: XML_SCHEMA_ATTR_INFO_META_XSI_NIL);
25003: if (iattr) {
25004: ACTIVATE_ATTRIBUTE(iattr);
25005: /*
25006: * Validate the value.
25007: */
25008: ret = xmlSchemaVCheckCVCSimpleType(
25009: ACTXT_CAST vctxt, NULL,
25010: xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
25011: iattr->value, &(iattr->val), 1, 0, 0);
25012: ACTIVATE_ELEM;
25013: if (ret < 0) {
25014: VERROR_INT("xmlSchemaValidateElemDecl",
25015: "calling xmlSchemaVCheckCVCSimpleType() to "
25016: "validate the attribute 'xsi:nil'");
25017: return (-1);
25018: }
25019: if (ret == 0) {
25020: if ((elemDecl->flags & XML_SCHEMAS_ELEM_NILLABLE) == 0) {
25021: /*
25022: * cvc-elt (3.3.4) : 3.1
25023: */
25024: VERROR(XML_SCHEMAV_CVC_ELT_3_1, NULL,
25025: "The element is not 'nillable'");
25026: /* Does not return an error on purpose. */
25027: } else {
25028: if (xmlSchemaValueGetAsBoolean(iattr->val)) {
25029: /*
25030: * cvc-elt (3.3.4) : 3.2.2
25031: */
25032: if ((elemDecl->flags & XML_SCHEMAS_ELEM_FIXED) &&
25033: (elemDecl->value != NULL)) {
25034: VERROR(XML_SCHEMAV_CVC_ELT_3_2_2, NULL,
25035: "The element cannot be 'nilled' because "
25036: "there is a fixed value constraint defined "
25037: "for it");
25038: /* Does not return an error on purpose. */
25039: } else
25040: vctxt->inode->flags |=
25041: XML_SCHEMA_ELEM_INFO_NILLED;
25042: }
25043: }
25044: }
25045: }
25046: /*
25047: * cvc-elt (3.3.4) : 4
25048: * Handle 'xsi:type'.
25049: */
25050: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
25051: XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
25052: if (iattr) {
25053: xmlSchemaTypePtr localType = NULL;
25054:
25055: ret = xmlSchemaProcessXSIType(vctxt, iattr, &localType,
25056: elemDecl);
25057: if (ret != 0) {
25058: if (ret == -1) {
25059: VERROR_INT("xmlSchemaValidateElemDecl",
25060: "calling xmlSchemaProcessXSIType() to "
25061: "process the attribute 'xsi:type'");
25062: return (-1);
25063: }
25064: /* Does not return an error on purpose. */
25065: }
25066: if (localType != NULL) {
25067: vctxt->inode->flags |= XML_SCHEMA_ELEM_INFO_LOCAL_TYPE;
25068: actualType = localType;
25069: }
25070: }
25071: }
25072: /*
25073: * IDC: Register identity-constraint XPath matchers.
25074: */
25075: if ((elemDecl->idcs != NULL) &&
25076: (xmlSchemaIDCRegisterMatchers(vctxt, elemDecl) == -1))
25077: return (-1);
25078: /*
25079: * No actual type definition.
25080: */
25081: if (actualType == NULL) {
25082: VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
25083: "The type definition is absent");
25084: return (XML_SCHEMAV_CVC_TYPE_1);
25085: }
25086: /*
25087: * Remember the actual type definition.
25088: */
25089: vctxt->inode->typeDef = actualType;
25090:
25091: return (0);
25092: }
25093:
25094: static int
25095: xmlSchemaVAttributesSimple(xmlSchemaValidCtxtPtr vctxt)
25096: {
25097: xmlSchemaAttrInfoPtr iattr;
25098: int ret = 0, i;
25099:
25100: /*
25101: * SPEC cvc-type (3.1.1)
25102: * "The attributes of must be empty, excepting those whose namespace
25103: * name is identical to http://www.w3.org/2001/XMLSchema-instance and
25104: * whose local name is one of type, nil, schemaLocation or
25105: * noNamespaceSchemaLocation."
25106: */
25107: if (vctxt->nbAttrInfos == 0)
25108: return (0);
25109: for (i = 0; i < vctxt->nbAttrInfos; i++) {
25110: iattr = vctxt->attrInfos[i];
25111: if (! iattr->metaType) {
25112: ACTIVATE_ATTRIBUTE(iattr)
25113: xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
25114: XML_SCHEMAV_CVC_TYPE_3_1_1, iattr, NULL);
25115: ret = XML_SCHEMAV_CVC_TYPE_3_1_1;
25116: }
25117: }
25118: ACTIVATE_ELEM
25119: return (ret);
25120: }
25121:
25122: /*
25123: * Cleanup currently used attribute infos.
25124: */
25125: static void
25126: xmlSchemaClearAttrInfos(xmlSchemaValidCtxtPtr vctxt)
25127: {
25128: int i;
25129: xmlSchemaAttrInfoPtr attr;
25130:
25131: if (vctxt->nbAttrInfos == 0)
25132: return;
25133: for (i = 0; i < vctxt->nbAttrInfos; i++) {
25134: attr = vctxt->attrInfos[i];
25135: if (attr->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES) {
25136: if (attr->localName != NULL)
25137: xmlFree((xmlChar *) attr->localName);
25138: if (attr->nsName != NULL)
25139: xmlFree((xmlChar *) attr->nsName);
25140: }
25141: if (attr->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
25142: if (attr->value != NULL)
25143: xmlFree((xmlChar *) attr->value);
25144: }
25145: if (attr->val != NULL) {
25146: xmlSchemaFreeValue(attr->val);
25147: attr->val = NULL;
25148: }
25149: memset(attr, 0, sizeof(xmlSchemaAttrInfo));
25150: }
25151: vctxt->nbAttrInfos = 0;
25152: }
25153:
25154: /*
25155: * 3.4.4 Complex Type Definition Validation Rules
25156: * Element Locally Valid (Complex Type) (cvc-complex-type)
25157: * 3.2.4 Attribute Declaration Validation Rules
25158: * Validation Rule: Attribute Locally Valid (cvc-attribute)
25159: * Attribute Locally Valid (Use) (cvc-au)
25160: *
25161: * Only "assessed" attribute information items will be visible to
25162: * IDCs. I.e. not "lax" (without declaration) and "skip" wild attributes.
25163: */
25164: static int
25165: xmlSchemaVAttributesComplex(xmlSchemaValidCtxtPtr vctxt)
25166: {
25167: xmlSchemaTypePtr type = vctxt->inode->typeDef;
25168: xmlSchemaItemListPtr attrUseList;
25169: xmlSchemaAttributeUsePtr attrUse = NULL;
25170: xmlSchemaAttributePtr attrDecl = NULL;
25171: xmlSchemaAttrInfoPtr iattr, tmpiattr;
25172: int i, j, found, nbAttrs, nbUses;
25173: int xpathRes = 0, res, wildIDs = 0, fixed;
25174: xmlNodePtr defAttrOwnerElem = NULL;
25175:
25176: /*
25177: * SPEC (cvc-attribute)
25178: * (1) "The declaration must not be �absent� (see Missing
25179: * Sub-components (�5.3) for how this can fail to be
25180: * the case)."
25181: * (2) "Its {type definition} must not be absent."
25182: *
25183: * NOTE (1) + (2): This is not handled here, since we currently do not
25184: * allow validation against schemas which have missing sub-components.
25185: *
25186: * SPEC (cvc-complex-type)
25187: * (3) "For each attribute information item in the element information
25188: * item's [attributes] excepting those whose [namespace name] is
25189: * identical to http://www.w3.org/2001/XMLSchema-instance and whose
25190: * [local name] is one of type, nil, schemaLocation or
25191: * noNamespaceSchemaLocation, the appropriate case among the following
25192: * must be true:
25193: *
25194: */
25195: attrUseList = (xmlSchemaItemListPtr) type->attrUses;
25196: /*
25197: * @nbAttrs is the number of attributes present in the instance.
25198: */
25199: nbAttrs = vctxt->nbAttrInfos;
25200: if (attrUseList != NULL)
25201: nbUses = attrUseList->nbItems;
25202: else
25203: nbUses = 0;
25204: for (i = 0; i < nbUses; i++) {
25205: found = 0;
25206: attrUse = attrUseList->items[i];
25207: attrDecl = WXS_ATTRUSE_DECL(attrUse);
25208: for (j = 0; j < nbAttrs; j++) {
25209: iattr = vctxt->attrInfos[j];
25210: /*
25211: * SPEC (cvc-complex-type) (3)
25212: * Skip meta attributes.
25213: */
25214: if (iattr->metaType)
25215: continue;
25216: if (iattr->localName[0] != attrDecl->name[0])
25217: continue;
25218: if (!xmlStrEqual(iattr->localName, attrDecl->name))
25219: continue;
25220: if (!xmlStrEqual(iattr->nsName, attrDecl->targetNamespace))
25221: continue;
25222: found = 1;
25223: /*
25224: * SPEC (cvc-complex-type)
25225: * (3.1) "If there is among the {attribute uses} an attribute
25226: * use with an {attribute declaration} whose {name} matches
25227: * the attribute information item's [local name] and whose
25228: * {target namespace} is identical to the attribute information
25229: * item's [namespace name] (where an �absent� {target namespace}
25230: * is taken to be identical to a [namespace name] with no value),
25231: * then the attribute information must be �valid� with respect
25232: * to that attribute use as per Attribute Locally Valid (Use)
25233: * (�3.5.4). In this case the {attribute declaration} of that
25234: * attribute use is the �context-determined declaration� for the
25235: * attribute information item with respect to Schema-Validity
25236: * Assessment (Attribute) (�3.2.4) and
25237: * Assessment Outcome (Attribute) (�3.2.5).
25238: */
25239: iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
25240: iattr->use = attrUse;
25241: /*
25242: * Context-determined declaration.
25243: */
25244: iattr->decl = attrDecl;
25245: iattr->typeDef = attrDecl->subtypes;
25246: break;
25247: }
25248:
25249: if (found)
25250: continue;
25251:
25252: if (attrUse->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED) {
25253: /*
25254: * Handle non-existent, required attributes.
25255: *
25256: * SPEC (cvc-complex-type)
25257: * (4) "The {attribute declaration} of each attribute use in
25258: * the {attribute uses} whose {required} is true matches one
25259: * of the attribute information items in the element information
25260: * item's [attributes] as per clause 3.1 above."
25261: */
25262: tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
25263: if (tmpiattr == NULL) {
25264: VERROR_INT(
25265: "xmlSchemaVAttributesComplex",
25266: "calling xmlSchemaGetFreshAttrInfo()");
25267: return (-1);
25268: }
25269: tmpiattr->state = XML_SCHEMAS_ATTR_ERR_MISSING;
25270: tmpiattr->use = attrUse;
25271: tmpiattr->decl = attrDecl;
25272: } else if ((attrUse->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
25273: ((attrUse->defValue != NULL) ||
25274: (attrDecl->defValue != NULL))) {
25275: /*
25276: * Handle non-existent, optional, default/fixed attributes.
25277: */
25278: tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
25279: if (tmpiattr == NULL) {
25280: VERROR_INT(
25281: "xmlSchemaVAttributesComplex",
25282: "calling xmlSchemaGetFreshAttrInfo()");
25283: return (-1);
25284: }
25285: tmpiattr->state = XML_SCHEMAS_ATTR_DEFAULT;
25286: tmpiattr->use = attrUse;
25287: tmpiattr->decl = attrDecl;
25288: tmpiattr->typeDef = attrDecl->subtypes;
25289: tmpiattr->localName = attrDecl->name;
25290: tmpiattr->nsName = attrDecl->targetNamespace;
25291: }
25292: }
25293:
25294: if (vctxt->nbAttrInfos == 0)
25295: return (0);
25296: /*
25297: * Validate against the wildcard.
25298: */
25299: if (type->attributeWildcard != NULL) {
25300: /*
25301: * SPEC (cvc-complex-type)
25302: * (3.2.1) "There must be an {attribute wildcard}."
25303: */
25304: for (i = 0; i < nbAttrs; i++) {
25305: iattr = vctxt->attrInfos[i];
25306: /*
25307: * SPEC (cvc-complex-type) (3)
25308: * Skip meta attributes.
25309: */
25310: if (iattr->state != XML_SCHEMAS_ATTR_UNKNOWN)
25311: continue;
25312: /*
25313: * SPEC (cvc-complex-type)
25314: * (3.2.2) "The attribute information item must be �valid� with
25315: * respect to it as defined in Item Valid (Wildcard) (�3.10.4)."
25316: *
25317: * SPEC Item Valid (Wildcard) (cvc-wildcard)
25318: * "... its [namespace name] must be �valid� with respect to
25319: * the wildcard constraint, as defined in Wildcard allows
25320: * Namespace Name (�3.10.4)."
25321: */
25322: if (xmlSchemaCheckCVCWildcardNamespace(type->attributeWildcard,
25323: iattr->nsName) == 0) {
25324: /*
25325: * Handle processContents.
25326: *
25327: * SPEC (cvc-wildcard):
25328: * processContents | context-determined declaration:
25329: * "strict" "mustFind"
25330: * "lax" "none"
25331: * "skip" "skip"
25332: */
25333: if (type->attributeWildcard->processContents ==
25334: XML_SCHEMAS_ANY_SKIP) {
25335: /*
25336: * context-determined declaration = "skip"
25337: *
25338: * SPEC PSVI Assessment Outcome (Attribute)
25339: * [validity] = "notKnown"
25340: * [validation attempted] = "none"
25341: */
25342: iattr->state = XML_SCHEMAS_ATTR_WILD_SKIP;
25343: continue;
25344: }
25345: /*
25346: * Find an attribute declaration.
25347: */
25348: iattr->decl = xmlSchemaGetAttributeDecl(vctxt->schema,
25349: iattr->localName, iattr->nsName);
25350: if (iattr->decl != NULL) {
25351: iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
25352: /*
25353: * SPEC (cvc-complex-type)
25354: * (5) "Let [Definition:] the wild IDs be the set of
25355: * all attribute information item to which clause 3.2
25356: * applied and whose �validation� resulted in a
25357: * �context-determined declaration� of mustFind or no
25358: * �context-determined declaration� at all, and whose
25359: * [local name] and [namespace name] resolve (as
25360: * defined by QName resolution (Instance) (�3.15.4)) to
25361: * an attribute declaration whose {type definition} is
25362: * or is derived from ID. Then all of the following
25363: * must be true:"
25364: */
25365: iattr->typeDef = WXS_ATTR_TYPEDEF(iattr->decl);
25366: if (xmlSchemaIsDerivedFromBuiltInType(
25367: iattr->typeDef, XML_SCHEMAS_ID)) {
25368: /*
25369: * SPEC (5.1) "There must be no more than one
25370: * item in �wild IDs�."
25371: */
25372: if (wildIDs != 0) {
25373: /* VAL TODO */
25374: iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID;
25375: TODO
25376: continue;
25377: }
25378: wildIDs++;
25379: /*
25380: * SPEC (cvc-complex-type)
25381: * (5.2) "If �wild IDs� is non-empty, there must not
25382: * be any attribute uses among the {attribute uses}
25383: * whose {attribute declaration}'s {type definition}
25384: * is or is derived from ID."
25385: */
25386: if (attrUseList != NULL) {
25387: for (j = 0; j < attrUseList->nbItems; j++) {
25388: if (xmlSchemaIsDerivedFromBuiltInType(
25389: WXS_ATTRUSE_TYPEDEF(attrUseList->items[j]),
25390: XML_SCHEMAS_ID)) {
25391: /* URGENT VAL TODO: implement */
25392: iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID;
25393: TODO
25394: break;
25395: }
25396: }
25397: }
25398: }
25399: } else if (type->attributeWildcard->processContents ==
25400: XML_SCHEMAS_ANY_LAX) {
25401: iattr->state = XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL;
25402: /*
25403: * SPEC PSVI Assessment Outcome (Attribute)
25404: * [validity] = "notKnown"
25405: * [validation attempted] = "none"
25406: */
25407: } else {
25408: iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL;
25409: }
25410: }
25411: }
25412: }
25413:
25414: if (vctxt->nbAttrInfos == 0)
25415: return (0);
25416:
25417: /*
25418: * Get the owner element; needed for creation of default attributes.
25419: * This fixes bug #341337, reported by David Grohmann.
25420: */
25421: if (vctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) {
25422: xmlSchemaNodeInfoPtr ielem = vctxt->elemInfos[vctxt->depth];
25423: if (ielem && ielem->node && ielem->node->doc)
25424: defAttrOwnerElem = ielem->node;
25425: }
25426: /*
25427: * Validate values, create default attributes, evaluate IDCs.
25428: */
25429: for (i = 0; i < vctxt->nbAttrInfos; i++) {
25430: iattr = vctxt->attrInfos[i];
25431: /*
25432: * VAL TODO: Note that we won't try to resolve IDCs to
25433: * "lax" and "skip" validated attributes. Check what to
25434: * do in this case.
25435: */
25436: if ((iattr->state != XML_SCHEMAS_ATTR_ASSESSED) &&
25437: (iattr->state != XML_SCHEMAS_ATTR_DEFAULT))
25438: continue;
25439: /*
25440: * VAL TODO: What to do if the type definition is missing?
25441: */
25442: if (iattr->typeDef == NULL) {
25443: iattr->state = XML_SCHEMAS_ATTR_ERR_NO_TYPE;
25444: continue;
25445: }
25446:
25447: ACTIVATE_ATTRIBUTE(iattr);
25448: fixed = 0;
25449: xpathRes = 0;
25450:
25451: if (vctxt->xpathStates != NULL) {
25452: /*
25453: * Evaluate IDCs.
25454: */
25455: xpathRes = xmlSchemaXPathEvaluate(vctxt,
25456: XML_ATTRIBUTE_NODE);
25457: if (xpathRes == -1) {
25458: VERROR_INT("xmlSchemaVAttributesComplex",
25459: "calling xmlSchemaXPathEvaluate()");
25460: goto internal_error;
25461: }
25462: }
25463:
25464: if (iattr->state == XML_SCHEMAS_ATTR_DEFAULT) {
25465: /*
25466: * Default/fixed attributes.
25467: * We need the value only if we need to resolve IDCs or
25468: * will create default attributes.
25469: */
25470: if ((xpathRes) || (defAttrOwnerElem)) {
25471: if (iattr->use->defValue != NULL) {
25472: iattr->value = (xmlChar *) iattr->use->defValue;
25473: iattr->val = iattr->use->defVal;
25474: } else {
25475: iattr->value = (xmlChar *) iattr->decl->defValue;
25476: iattr->val = iattr->decl->defVal;
25477: }
25478: /*
25479: * IDCs will consume the precomputed default value,
25480: * so we need to clone it.
25481: */
25482: if (iattr->val == NULL) {
25483: VERROR_INT("xmlSchemaVAttributesComplex",
25484: "default/fixed value on an attribute use was "
25485: "not precomputed");
25486: goto internal_error;
25487: }
25488: iattr->val = xmlSchemaCopyValue(iattr->val);
25489: if (iattr->val == NULL) {
25490: VERROR_INT("xmlSchemaVAttributesComplex",
25491: "calling xmlSchemaCopyValue()");
25492: goto internal_error;
25493: }
25494: }
25495: /*
25496: * PSVI: Add the default attribute to the current element.
25497: * VAL TODO: Should we use the *normalized* value? This currently
25498: * uses the *initial* value.
25499: */
25500:
25501: if (defAttrOwnerElem) {
25502: xmlChar *normValue;
25503: const xmlChar *value;
25504:
25505: value = iattr->value;
25506: /*
25507: * Normalize the value.
25508: */
25509: normValue = xmlSchemaNormalizeValue(iattr->typeDef,
25510: iattr->value);
25511: if (normValue != NULL)
25512: value = BAD_CAST normValue;
25513:
25514: if (iattr->nsName == NULL) {
25515: if (xmlNewProp(defAttrOwnerElem,
25516: iattr->localName, value) == NULL) {
25517: VERROR_INT("xmlSchemaVAttributesComplex",
25518: "callling xmlNewProp()");
25519: if (normValue != NULL)
25520: xmlFree(normValue);
25521: goto internal_error;
25522: }
25523: } else {
25524: xmlNsPtr ns;
25525:
25526: ns = xmlSearchNsByHref(defAttrOwnerElem->doc,
25527: defAttrOwnerElem, iattr->nsName);
25528: if (ns == NULL) {
25529: xmlChar prefix[12];
25530: int counter = 0;
25531:
25532: /*
25533: * Create a namespace declaration on the validation
25534: * root node if no namespace declaration is in scope.
25535: */
25536: do {
25537: snprintf((char *) prefix, 12, "p%d", counter++);
25538: ns = xmlSearchNs(defAttrOwnerElem->doc,
25539: defAttrOwnerElem, BAD_CAST prefix);
25540: if (counter > 1000) {
25541: VERROR_INT(
25542: "xmlSchemaVAttributesComplex",
25543: "could not compute a ns prefix for a "
25544: "default/fixed attribute");
25545: if (normValue != NULL)
25546: xmlFree(normValue);
25547: goto internal_error;
25548: }
25549: } while (ns != NULL);
25550: ns = xmlNewNs(vctxt->validationRoot,
25551: iattr->nsName, BAD_CAST prefix);
25552: }
25553: /*
25554: * TODO:
25555: * http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0406.html
25556: * If we have QNames: do we need to ensure there's a
25557: * prefix defined for the QName?
25558: */
25559: xmlNewNsProp(defAttrOwnerElem, ns, iattr->localName, value);
25560: }
25561: if (normValue != NULL)
25562: xmlFree(normValue);
25563: }
25564: /*
25565: * Go directly to IDC evaluation.
25566: */
25567: goto eval_idcs;
25568: }
25569: /*
25570: * Validate the value.
25571: */
25572: if (vctxt->value != NULL) {
25573: /*
25574: * Free last computed value; just for safety reasons.
25575: */
25576: xmlSchemaFreeValue(vctxt->value);
25577: vctxt->value = NULL;
25578: }
25579: /*
25580: * Note that the attribute *use* can be unavailable, if
25581: * the attribute was a wild attribute.
25582: */
25583: if ((iattr->decl->flags & XML_SCHEMAS_ATTR_FIXED) ||
25584: ((iattr->use != NULL) &&
25585: (iattr->use->flags & XML_SCHEMAS_ATTR_FIXED)))
25586: fixed = 1;
25587: else
25588: fixed = 0;
25589: /*
25590: * SPEC (cvc-attribute)
25591: * (3) "The item's �normalized value� must be locally �valid�
25592: * with respect to that {type definition} as per
25593: * String Valid (�3.14.4)."
25594: *
25595: * VAL TODO: Do we already have the
25596: * "normalized attribute value" here?
25597: */
25598: if (xpathRes || fixed) {
25599: iattr->flags |= XML_SCHEMA_NODE_INFO_VALUE_NEEDED;
25600: /*
25601: * Request a computed value.
25602: */
25603: res = xmlSchemaVCheckCVCSimpleType(
25604: ACTXT_CAST vctxt,
25605: iattr->node, iattr->typeDef, iattr->value, &(iattr->val),
25606: 1, 1, 0);
25607: } else {
25608: res = xmlSchemaVCheckCVCSimpleType(
25609: ACTXT_CAST vctxt,
25610: iattr->node, iattr->typeDef, iattr->value, NULL,
25611: 1, 0, 0);
25612: }
25613:
25614: if (res != 0) {
25615: if (res == -1) {
25616: VERROR_INT("xmlSchemaVAttributesComplex",
25617: "calling xmlSchemaStreamValidateSimpleTypeValue()");
25618: goto internal_error;
25619: }
25620: iattr->state = XML_SCHEMAS_ATTR_INVALID_VALUE;
25621: /*
25622: * SPEC PSVI Assessment Outcome (Attribute)
25623: * [validity] = "invalid"
25624: */
25625: goto eval_idcs;
25626: }
25627:
25628: if (fixed) {
25629: /*
25630: * SPEC Attribute Locally Valid (Use) (cvc-au)
25631: * "For an attribute information item to be�valid�
25632: * with respect to an attribute use its *normalized*
25633: * value� must match the *canonical* lexical
25634: * representation of the attribute use's {value
25635: * constraint}value, if it is present and fixed."
25636: *
25637: * VAL TODO: The requirement for the *canonical* value
25638: * will be removed in XML Schema 1.1.
25639: */
25640: /*
25641: * SPEC Attribute Locally Valid (cvc-attribute)
25642: * (4) "The item's *actual* value� must match the *value* of
25643: * the {value constraint}, if it is present and fixed."
25644: */
25645: if (iattr->val == NULL) {
25646: /* VAL TODO: A value was not precomputed. */
25647: TODO
25648: goto eval_idcs;
25649: }
25650: if ((iattr->use != NULL) &&
25651: (iattr->use->defValue != NULL)) {
25652: if (iattr->use->defVal == NULL) {
25653: /* VAL TODO: A default value was not precomputed. */
25654: TODO
25655: goto eval_idcs;
25656: }
25657: iattr->vcValue = iattr->use->defValue;
25658: /*
25659: if (xmlSchemaCompareValuesWhtsp(attr->val,
25660: (xmlSchemaWhitespaceValueType) ws,
25661: attr->use->defVal,
25662: (xmlSchemaWhitespaceValueType) ws) != 0) {
25663: */
25664: if (! xmlSchemaAreValuesEqual(iattr->val, iattr->use->defVal))
25665: iattr->state = XML_SCHEMAS_ATTR_ERR_FIXED_VALUE;
25666: } else {
25667: if (iattr->decl->defVal == NULL) {
25668: /* VAL TODO: A default value was not precomputed. */
25669: TODO
25670: goto eval_idcs;
25671: }
25672: iattr->vcValue = iattr->decl->defValue;
25673: /*
25674: if (xmlSchemaCompareValuesWhtsp(attr->val,
25675: (xmlSchemaWhitespaceValueType) ws,
25676: attrDecl->defVal,
25677: (xmlSchemaWhitespaceValueType) ws) != 0) {
25678: */
25679: if (! xmlSchemaAreValuesEqual(iattr->val, iattr->decl->defVal))
25680: iattr->state = XML_SCHEMAS_ATTR_ERR_FIXED_VALUE;
25681: }
25682: /*
25683: * [validity] = "valid"
25684: */
25685: }
25686: eval_idcs:
25687: /*
25688: * Evaluate IDCs.
25689: */
25690: if (xpathRes) {
25691: if (xmlSchemaXPathProcessHistory(vctxt,
25692: vctxt->depth +1) == -1) {
25693: VERROR_INT("xmlSchemaVAttributesComplex",
25694: "calling xmlSchemaXPathEvaluate()");
25695: goto internal_error;
25696: }
25697: } else if (vctxt->xpathStates != NULL)
25698: xmlSchemaXPathPop(vctxt);
25699: }
25700:
25701: /*
25702: * Report errors.
25703: */
25704: for (i = 0; i < vctxt->nbAttrInfos; i++) {
25705: iattr = vctxt->attrInfos[i];
25706: if ((iattr->state == XML_SCHEMAS_ATTR_META) ||
25707: (iattr->state == XML_SCHEMAS_ATTR_ASSESSED) ||
25708: (iattr->state == XML_SCHEMAS_ATTR_WILD_SKIP) ||
25709: (iattr->state == XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL))
25710: continue;
25711: ACTIVATE_ATTRIBUTE(iattr);
25712: switch (iattr->state) {
25713: case XML_SCHEMAS_ATTR_ERR_MISSING: {
25714: xmlChar *str = NULL;
25715: ACTIVATE_ELEM;
25716: xmlSchemaCustomErr(ACTXT_CAST vctxt,
25717: XML_SCHEMAV_CVC_COMPLEX_TYPE_4, NULL, NULL,
25718: "The attribute '%s' is required but missing",
25719: xmlSchemaFormatQName(&str,
25720: iattr->decl->targetNamespace,
25721: iattr->decl->name),
25722: NULL);
25723: FREE_AND_NULL(str)
25724: break;
25725: }
25726: case XML_SCHEMAS_ATTR_ERR_NO_TYPE:
25727: VERROR(XML_SCHEMAV_CVC_ATTRIBUTE_2, NULL,
25728: "The type definition is absent");
25729: break;
25730: case XML_SCHEMAS_ATTR_ERR_FIXED_VALUE:
25731: xmlSchemaCustomErr(ACTXT_CAST vctxt,
25732: XML_SCHEMAV_CVC_AU, NULL, NULL,
25733: "The value '%s' does not match the fixed "
25734: "value constraint '%s'",
25735: iattr->value, iattr->vcValue);
25736: break;
25737: case XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL:
25738: VERROR(XML_SCHEMAV_CVC_WILDCARD, NULL,
25739: "No matching global attribute declaration available, but "
25740: "demanded by the strict wildcard");
25741: break;
25742: case XML_SCHEMAS_ATTR_UNKNOWN:
25743: if (iattr->metaType)
25744: break;
25745: /*
25746: * MAYBE VAL TODO: One might report different error messages
25747: * for the following errors.
25748: */
25749: if (type->attributeWildcard == NULL) {
25750: xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
25751: XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, iattr, NULL);
25752: } else {
25753: xmlSchemaIllegalAttrErr(ACTXT_CAST vctxt,
25754: XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, iattr, NULL);
25755: }
25756: break;
25757: default:
25758: break;
25759: }
25760: }
25761:
25762: ACTIVATE_ELEM;
25763: return (0);
25764: internal_error:
25765: ACTIVATE_ELEM;
25766: return (-1);
25767: }
25768:
25769: static int
25770: xmlSchemaValidateElemWildcard(xmlSchemaValidCtxtPtr vctxt,
25771: int *skip)
25772: {
25773: xmlSchemaWildcardPtr wild = (xmlSchemaWildcardPtr) vctxt->inode->decl;
25774: /*
25775: * The namespace of the element was already identified to be
25776: * matching the wildcard.
25777: */
25778: if ((skip == NULL) || (wild == NULL) ||
25779: (wild->type != XML_SCHEMA_TYPE_ANY)) {
25780: VERROR_INT("xmlSchemaValidateElemWildcard",
25781: "bad arguments");
25782: return (-1);
25783: }
25784: *skip = 0;
25785: if (wild->processContents == XML_SCHEMAS_ANY_SKIP) {
25786: /*
25787: * URGENT VAL TODO: Either we need to position the stream to the
25788: * next sibling, or walk the whole subtree.
25789: */
25790: *skip = 1;
25791: return (0);
25792: }
25793: {
25794: xmlSchemaElementPtr decl = NULL;
25795:
25796: decl = xmlSchemaGetElem(vctxt->schema,
25797: vctxt->inode->localName, vctxt->inode->nsName);
25798: if (decl != NULL) {
25799: vctxt->inode->decl = decl;
25800: return (0);
25801: }
25802: }
25803: if (wild->processContents == XML_SCHEMAS_ANY_STRICT) {
25804: /* VAL TODO: Change to proper error code. */
25805: VERROR(XML_SCHEMAV_CVC_ELT_1, NULL, /* WXS_BASIC_CAST wild */
25806: "No matching global element declaration available, but "
25807: "demanded by the strict wildcard");
25808: return (vctxt->err);
25809: }
25810: if (vctxt->nbAttrInfos != 0) {
25811: xmlSchemaAttrInfoPtr iattr;
25812: /*
25813: * SPEC Validation Rule: Schema-Validity Assessment (Element)
25814: * (1.2.1.2.1) - (1.2.1.2.3 )
25815: *
25816: * Use the xsi:type attribute for the type definition.
25817: */
25818: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
25819: XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
25820: if (iattr != NULL) {
25821: if (xmlSchemaProcessXSIType(vctxt, iattr,
25822: &(vctxt->inode->typeDef), NULL) == -1) {
25823: VERROR_INT("xmlSchemaValidateElemWildcard",
25824: "calling xmlSchemaProcessXSIType() to "
25825: "process the attribute 'xsi:nil'");
25826: return (-1);
25827: }
25828: /*
25829: * Don't return an error on purpose.
25830: */
25831: return (0);
25832: }
25833: }
25834: /*
25835: * SPEC Validation Rule: Schema-Validity Assessment (Element)
25836: *
25837: * Fallback to "anyType".
25838: */
25839: vctxt->inode->typeDef =
25840: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
25841: return (0);
25842: }
25843:
25844: /*
25845: * xmlSchemaCheckCOSValidDefault:
25846: *
25847: * This will be called if: not nilled, no content and a default/fixed
25848: * value is provided.
25849: */
25850:
25851: static int
25852: xmlSchemaCheckCOSValidDefault(xmlSchemaValidCtxtPtr vctxt,
25853: const xmlChar *value,
25854: xmlSchemaValPtr *val)
25855: {
25856: int ret = 0;
25857: xmlSchemaNodeInfoPtr inode = vctxt->inode;
25858:
25859: /*
25860: * cos-valid-default:
25861: * Schema Component Constraint: Element Default Valid (Immediate)
25862: * For a string to be a valid default with respect to a type
25863: * definition the appropriate case among the following must be true:
25864: */
25865: if WXS_IS_COMPLEX(inode->typeDef) {
25866: /*
25867: * Complex type.
25868: *
25869: * SPEC (2.1) "its {content type} must be a simple type definition
25870: * or mixed."
25871: * SPEC (2.2.2) "If the {content type} is mixed, then the {content
25872: * type}'s particle must be �emptiable� as defined by
25873: * Particle Emptiable (�3.9.6)."
25874: */
25875: if ((! WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) &&
25876: ((! WXS_HAS_MIXED_CONTENT(inode->typeDef)) ||
25877: (! WXS_EMPTIABLE(inode->typeDef)))) {
25878: ret = XML_SCHEMAP_COS_VALID_DEFAULT_2_1;
25879: /* NOTE that this covers (2.2.2) as well. */
25880: VERROR(ret, NULL,
25881: "For a string to be a valid default, the type definition "
25882: "must be a simple type or a complex type with simple content "
25883: "or mixed content and a particle emptiable");
25884: return(ret);
25885: }
25886: }
25887: /*
25888: * 1 If the type definition is a simple type definition, then the string
25889: * must be �valid� with respect to that definition as defined by String
25890: * Valid (�3.14.4).
25891: *
25892: * AND
25893: *
25894: * 2.2.1 If the {content type} is a simple type definition, then the
25895: * string must be �valid� with respect to that simple type definition
25896: * as defined by String Valid (�3.14.4).
25897: */
25898: if (WXS_IS_SIMPLE(inode->typeDef)) {
25899:
25900: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
25901: NULL, inode->typeDef, value, val, 1, 1, 0);
25902:
25903: } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
25904:
25905: ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
25906: NULL, inode->typeDef->contentTypeDef, value, val, 1, 1, 0);
25907: }
25908: if (ret < 0) {
25909: VERROR_INT("xmlSchemaCheckCOSValidDefault",
25910: "calling xmlSchemaVCheckCVCSimpleType()");
25911: }
25912: return (ret);
25913: }
25914:
25915: static void
25916: xmlSchemaVContentModelCallback(xmlSchemaValidCtxtPtr vctxt ATTRIBUTE_UNUSED,
25917: const xmlChar * name ATTRIBUTE_UNUSED,
25918: xmlSchemaElementPtr item,
25919: xmlSchemaNodeInfoPtr inode)
25920: {
25921: inode->decl = item;
25922: #ifdef DEBUG_CONTENT
25923: {
25924: xmlChar *str = NULL;
25925:
25926: if (item->type == XML_SCHEMA_TYPE_ELEMENT) {
25927: xmlGenericError(xmlGenericErrorContext,
25928: "AUTOMATON callback for '%s' [declaration]\n",
25929: xmlSchemaFormatQName(&str,
25930: inode->localName, inode->nsName));
25931: } else {
25932: xmlGenericError(xmlGenericErrorContext,
25933: "AUTOMATON callback for '%s' [wildcard]\n",
25934: xmlSchemaFormatQName(&str,
25935: inode->localName, inode->nsName));
25936:
25937: }
25938: FREE_AND_NULL(str)
25939: }
25940: #endif
25941: }
25942:
25943: static int
25944: xmlSchemaValidatorPushElem(xmlSchemaValidCtxtPtr vctxt)
25945: {
25946: vctxt->inode = xmlSchemaGetFreshElemInfo(vctxt);
25947: if (vctxt->inode == NULL) {
25948: VERROR_INT("xmlSchemaValidatorPushElem",
25949: "calling xmlSchemaGetFreshElemInfo()");
25950: return (-1);
25951: }
25952: vctxt->nbAttrInfos = 0;
25953: return (0);
25954: }
25955:
25956: static int
25957: xmlSchemaVCheckINodeDataType(xmlSchemaValidCtxtPtr vctxt,
25958: xmlSchemaNodeInfoPtr inode,
25959: xmlSchemaTypePtr type,
25960: const xmlChar *value)
25961: {
25962: if (inode->flags & XML_SCHEMA_NODE_INFO_VALUE_NEEDED)
25963: return (xmlSchemaVCheckCVCSimpleType(
25964: ACTXT_CAST vctxt, NULL,
25965: type, value, &(inode->val), 1, 1, 0));
25966: else
25967: return (xmlSchemaVCheckCVCSimpleType(
25968: ACTXT_CAST vctxt, NULL,
25969: type, value, NULL, 1, 0, 0));
25970: }
25971:
25972:
25973:
25974: /*
25975: * Process END of element.
25976: */
25977: static int
25978: xmlSchemaValidatorPopElem(xmlSchemaValidCtxtPtr vctxt)
25979: {
25980: int ret = 0;
25981: xmlSchemaNodeInfoPtr inode = vctxt->inode;
25982:
25983: if (vctxt->nbAttrInfos != 0)
25984: xmlSchemaClearAttrInfos(vctxt);
25985: if (inode->flags & XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED) {
25986: /*
25987: * This element was not expected;
25988: * we will not validate child elements of broken parents.
25989: * Skip validation of all content of the parent.
25990: */
25991: vctxt->skipDepth = vctxt->depth -1;
25992: goto end_elem;
25993: }
25994: if ((inode->typeDef == NULL) ||
25995: (inode->flags & XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE)) {
25996: /*
25997: * 1. the type definition might be missing if the element was
25998: * error prone
25999: * 2. it might be abstract.
26000: */
26001: goto end_elem;
26002: }
26003: /*
26004: * Check the content model.
26005: */
26006: if ((inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) ||
26007: (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)) {
26008:
26009: /*
26010: * Workaround for "anyType".
26011: */
26012: if (inode->typeDef->builtInType == XML_SCHEMAS_ANYTYPE)
26013: goto character_content;
26014:
26015: if ((inode->flags & XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT) == 0) {
26016: xmlChar *values[10];
26017: int terminal, nbval = 10, nbneg;
26018:
26019: if (inode->regexCtxt == NULL) {
26020: /*
26021: * Create the regex context.
26022: */
26023: inode->regexCtxt =
26024: xmlRegNewExecCtxt(inode->typeDef->contModel,
26025: (xmlRegExecCallbacks) xmlSchemaVContentModelCallback,
26026: vctxt);
26027: if (inode->regexCtxt == NULL) {
26028: VERROR_INT("xmlSchemaValidatorPopElem",
26029: "failed to create a regex context");
26030: goto internal_error;
26031: }
26032: #ifdef DEBUG_AUTOMATA
26033: xmlGenericError(xmlGenericErrorContext,
26034: "AUTOMATON create on '%s'\n", inode->localName);
26035: #endif
26036: }
26037: /*
26038: * Get hold of the still expected content, since a further
26039: * call to xmlRegExecPushString() will loose this information.
26040: */
26041: xmlRegExecNextValues(inode->regexCtxt,
26042: &nbval, &nbneg, &values[0], &terminal);
26043: ret = xmlRegExecPushString(inode->regexCtxt, NULL, NULL);
26044: if ((ret<0) || ((ret==0) && (!INODE_NILLED(inode)))) {
26045: /*
26046: * Still missing something.
26047: */
26048: ret = 1;
26049: inode->flags |=
26050: XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT;
26051: xmlSchemaComplexTypeErr(ACTXT_CAST vctxt,
26052: XML_SCHEMAV_ELEMENT_CONTENT, NULL, NULL,
26053: "Missing child element(s)",
26054: nbval, nbneg, values);
26055: #ifdef DEBUG_AUTOMATA
26056: xmlGenericError(xmlGenericErrorContext,
26057: "AUTOMATON missing ERROR on '%s'\n",
26058: inode->localName);
26059: #endif
26060: } else {
26061: /*
26062: * Content model is satisfied.
26063: */
26064: ret = 0;
26065: #ifdef DEBUG_AUTOMATA
26066: xmlGenericError(xmlGenericErrorContext,
26067: "AUTOMATON succeeded on '%s'\n",
26068: inode->localName);
26069: #endif
26070: }
26071:
26072: }
26073: }
26074: if (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)
26075: goto end_elem;
26076:
26077: character_content:
26078:
26079: if (vctxt->value != NULL) {
26080: xmlSchemaFreeValue(vctxt->value);
26081: vctxt->value = NULL;
26082: }
26083: /*
26084: * Check character content.
26085: */
26086: if (inode->decl == NULL) {
26087: /*
26088: * Speedup if no declaration exists.
26089: */
26090: if (WXS_IS_SIMPLE(inode->typeDef)) {
26091: ret = xmlSchemaVCheckINodeDataType(vctxt,
26092: inode, inode->typeDef, inode->value);
26093: } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
26094: ret = xmlSchemaVCheckINodeDataType(vctxt,
26095: inode, inode->typeDef->contentTypeDef,
26096: inode->value);
26097: }
26098: if (ret < 0) {
26099: VERROR_INT("xmlSchemaValidatorPopElem",
26100: "calling xmlSchemaVCheckCVCSimpleType()");
26101: goto internal_error;
26102: }
26103: goto end_elem;
26104: }
26105: /*
26106: * cvc-elt (3.3.4) : 5
26107: * The appropriate case among the following must be true:
26108: */
26109: /*
26110: * cvc-elt (3.3.4) : 5.1
26111: * If the declaration has a {value constraint},
26112: * the item has neither element nor character [children] and
26113: * clause 3.2 has not applied, then all of the following must be true:
26114: */
26115: if ((inode->decl->value != NULL) &&
26116: (inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY) &&
26117: (! INODE_NILLED(inode))) {
26118: /*
26119: * cvc-elt (3.3.4) : 5.1.1
26120: * If the �actual type definition� is a �local type definition�
26121: * then the canonical lexical representation of the {value constraint}
26122: * value must be a valid default for the �actual type definition� as
26123: * defined in Element Default Valid (Immediate) (�3.3.6).
26124: */
26125: /*
26126: * NOTE: 'local' above means types acquired by xsi:type.
26127: * NOTE: Although the *canonical* value is stated, it is not
26128: * relevant if canonical or not. Additionally XML Schema 1.1
26129: * will removed this requirement as well.
26130: */
26131: if (inode->flags & XML_SCHEMA_ELEM_INFO_LOCAL_TYPE) {
26132:
26133: ret = xmlSchemaCheckCOSValidDefault(vctxt,
26134: inode->decl->value, &(inode->val));
26135: if (ret != 0) {
26136: if (ret < 0) {
26137: VERROR_INT("xmlSchemaValidatorPopElem",
26138: "calling xmlSchemaCheckCOSValidDefault()");
26139: goto internal_error;
26140: }
26141: goto end_elem;
26142: }
26143: /*
26144: * Stop here, to avoid redundant validation of the value
26145: * (see following).
26146: */
26147: goto default_psvi;
26148: }
26149: /*
26150: * cvc-elt (3.3.4) : 5.1.2
26151: * The element information item with the canonical lexical
26152: * representation of the {value constraint} value used as its
26153: * �normalized value� must be �valid� with respect to the
26154: * �actual type definition� as defined by Element Locally Valid (Type)
26155: * (�3.3.4).
26156: */
26157: if (WXS_IS_SIMPLE(inode->typeDef)) {
26158: ret = xmlSchemaVCheckINodeDataType(vctxt,
26159: inode, inode->typeDef, inode->decl->value);
26160: } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
26161: ret = xmlSchemaVCheckINodeDataType(vctxt,
26162: inode, inode->typeDef->contentTypeDef,
26163: inode->decl->value);
26164: }
26165: if (ret != 0) {
26166: if (ret < 0) {
26167: VERROR_INT("xmlSchemaValidatorPopElem",
26168: "calling xmlSchemaVCheckCVCSimpleType()");
26169: goto internal_error;
26170: }
26171: goto end_elem;
26172: }
26173:
26174: default_psvi:
26175: /*
26176: * PSVI: Create a text node on the instance element.
26177: */
26178: if ((vctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) &&
26179: (inode->node != NULL)) {
26180: xmlNodePtr textChild;
26181: xmlChar *normValue;
26182: /*
26183: * VAL TODO: Normalize the value.
26184: */
26185: normValue = xmlSchemaNormalizeValue(inode->typeDef,
26186: inode->decl->value);
26187: if (normValue != NULL) {
26188: textChild = xmlNewText(BAD_CAST normValue);
26189: xmlFree(normValue);
26190: } else
26191: textChild = xmlNewText(inode->decl->value);
26192: if (textChild == NULL) {
26193: VERROR_INT("xmlSchemaValidatorPopElem",
26194: "calling xmlNewText()");
26195: goto internal_error;
26196: } else
26197: xmlAddChild(inode->node, textChild);
26198: }
26199:
26200: } else if (! INODE_NILLED(inode)) {
26201: /*
26202: * 5.2.1 The element information item must be �valid� with respect
26203: * to the �actual type definition� as defined by Element Locally
26204: * Valid (Type) (�3.3.4).
26205: */
26206: if (WXS_IS_SIMPLE(inode->typeDef)) {
26207: /*
26208: * SPEC (cvc-type) (3.1)
26209: * "If the type definition is a simple type definition, ..."
26210: * (3.1.3) "If clause 3.2 of Element Locally Valid
26211: * (Element) (�3.3.4) did not apply, then the �normalized value�
26212: * must be �valid� with respect to the type definition as defined
26213: * by String Valid (�3.14.4).
26214: */
26215: ret = xmlSchemaVCheckINodeDataType(vctxt,
26216: inode, inode->typeDef, inode->value);
26217: } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
26218: /*
26219: * SPEC (cvc-type) (3.2) "If the type definition is a complex type
26220: * definition, then the element information item must be
26221: * �valid� with respect to the type definition as per
26222: * Element Locally Valid (Complex Type) (�3.4.4);"
26223: *
26224: * SPEC (cvc-complex-type) (2.2)
26225: * "If the {content type} is a simple type definition, ...
26226: * the �normalized value� of the element information item is
26227: * �valid� with respect to that simple type definition as
26228: * defined by String Valid (�3.14.4)."
26229: */
26230: ret = xmlSchemaVCheckINodeDataType(vctxt,
26231: inode, inode->typeDef->contentTypeDef, inode->value);
26232: }
26233: if (ret != 0) {
26234: if (ret < 0) {
26235: VERROR_INT("xmlSchemaValidatorPopElem",
26236: "calling xmlSchemaVCheckCVCSimpleType()");
26237: goto internal_error;
26238: }
26239: goto end_elem;
26240: }
26241: /*
26242: * 5.2.2 If there is a fixed {value constraint} and clause 3.2 has
26243: * not applied, all of the following must be true:
26244: */
26245: if ((inode->decl->value != NULL) &&
26246: (inode->decl->flags & XML_SCHEMAS_ELEM_FIXED)) {
26247:
26248: /*
26249: * TODO: We will need a computed value, when comparison is
26250: * done on computed values.
26251: */
26252: /*
26253: * 5.2.2.1 The element information item must have no element
26254: * information item [children].
26255: */
26256: if (inode->flags &
26257: XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT) {
26258: ret = XML_SCHEMAV_CVC_ELT_5_2_2_1;
26259: VERROR(ret, NULL,
26260: "The content must not containt element nodes since "
26261: "there is a fixed value constraint");
26262: goto end_elem;
26263: } else {
26264: /*
26265: * 5.2.2.2 The appropriate case among the following must
26266: * be true:
26267: */
26268: if (WXS_HAS_MIXED_CONTENT(inode->typeDef)) {
26269: /*
26270: * 5.2.2.2.1 If the {content type} of the �actual type
26271: * definition� is mixed, then the *initial value* of the
26272: * item must match the canonical lexical representation
26273: * of the {value constraint} value.
26274: *
26275: * ... the *initial value* of an element information
26276: * item is the string composed of, in order, the
26277: * [character code] of each character information item in
26278: * the [children] of that element information item.
26279: */
26280: if (! xmlStrEqual(inode->value, inode->decl->value)){
26281: /*
26282: * VAL TODO: Report invalid & expected values as well.
26283: * VAL TODO: Implement the canonical stuff.
26284: */
26285: ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_1;
26286: xmlSchemaCustomErr(ACTXT_CAST vctxt,
26287: ret, NULL, NULL,
26288: "The initial value '%s' does not match the fixed "
26289: "value constraint '%s'",
26290: inode->value, inode->decl->value);
26291: goto end_elem;
26292: }
26293: } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
26294: /*
26295: * 5.2.2.2.2 If the {content type} of the �actual type
26296: * definition� is a simple type definition, then the
26297: * *actual value* of the item must match the canonical
26298: * lexical representation of the {value constraint} value.
26299: */
26300: /*
26301: * VAL TODO: *actual value* is the normalized value, impl.
26302: * this.
26303: * VAL TODO: Report invalid & expected values as well.
26304: * VAL TODO: Implement a comparison with the computed values.
26305: */
26306: if (! xmlStrEqual(inode->value,
26307: inode->decl->value)) {
26308: ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_2;
26309: xmlSchemaCustomErr(ACTXT_CAST vctxt,
26310: ret, NULL, NULL,
26311: "The actual value '%s' does not match the fixed "
26312: "value constraint '%s'",
26313: inode->value,
26314: inode->decl->value);
26315: goto end_elem;
26316: }
26317: }
26318: }
26319: }
26320: }
26321:
26322: end_elem:
26323: if (vctxt->depth < 0) {
26324: /* TODO: raise error? */
26325: return (0);
26326: }
26327: if (vctxt->depth == vctxt->skipDepth)
26328: vctxt->skipDepth = -1;
26329: /*
26330: * Evaluate the history of XPath state objects.
26331: */
26332: if (inode->appliedXPath &&
26333: (xmlSchemaXPathProcessHistory(vctxt, vctxt->depth) == -1))
26334: goto internal_error;
26335: /*
26336: * MAYBE TODO:
26337: * SPEC (6) "The element information item must be �valid� with
26338: * respect to each of the {identity-constraint definitions} as per
26339: * Identity-constraint Satisfied (�3.11.4)."
26340: */
26341: /*
26342: * PSVI TODO: If we expose IDC node-tables via PSVI then the tables
26343: * need to be built in any case.
26344: * We will currently build IDC node-tables and bubble them only if
26345: * keyrefs do exist.
26346: */
26347:
26348: /*
26349: * Add the current IDC target-nodes to the IDC node-tables.
26350: */
26351: if ((inode->idcMatchers != NULL) &&
26352: (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
26353: {
26354: if (xmlSchemaIDCFillNodeTables(vctxt, inode) == -1)
26355: goto internal_error;
26356: }
26357: /*
26358: * Validate IDC keyrefs.
26359: */
26360: if (vctxt->inode->hasKeyrefs)
26361: if (xmlSchemaCheckCVCIDCKeyRef(vctxt) == -1)
26362: goto internal_error;
26363: /*
26364: * Merge/free the IDC table.
26365: */
26366: if (inode->idcTable != NULL) {
26367: #ifdef DEBUG_IDC_NODE_TABLE
26368: xmlSchemaDebugDumpIDCTable(stdout,
26369: inode->nsName,
26370: inode->localName,
26371: inode->idcTable);
26372: #endif
26373: if ((vctxt->depth > 0) &&
26374: (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
26375: {
26376: /*
26377: * Merge the IDC node table with the table of the parent node.
26378: */
26379: if (xmlSchemaBubbleIDCNodeTables(vctxt) == -1)
26380: goto internal_error;
26381: }
26382: }
26383: /*
26384: * Clear the current ielem.
26385: * VAL TODO: Don't free the PSVI IDC tables if they are
26386: * requested for the PSVI.
26387: */
26388: xmlSchemaClearElemInfo(vctxt, inode);
26389: /*
26390: * Skip further processing if we are on the validation root.
26391: */
26392: if (vctxt->depth == 0) {
26393: vctxt->depth--;
26394: vctxt->inode = NULL;
26395: return (0);
26396: }
26397: /*
26398: * Reset the keyrefDepth if needed.
26399: */
26400: if (vctxt->aidcs != NULL) {
26401: xmlSchemaIDCAugPtr aidc = vctxt->aidcs;
26402: do {
26403: if (aidc->keyrefDepth == vctxt->depth) {
26404: /*
26405: * A 'keyrefDepth' of a key/unique IDC matches the current
26406: * depth, this means that we are leaving the scope of the
26407: * top-most keyref IDC which refers to this IDC.
26408: */
26409: aidc->keyrefDepth = -1;
26410: }
26411: aidc = aidc->next;
26412: } while (aidc != NULL);
26413: }
26414: vctxt->depth--;
26415: vctxt->inode = vctxt->elemInfos[vctxt->depth];
26416: /*
26417: * VAL TODO: 7 If the element information item is the �validation root�, it must be
26418: * �valid� per Validation Root Valid (ID/IDREF) (�3.3.4).
26419: */
26420: return (ret);
26421:
26422: internal_error:
26423: vctxt->err = -1;
26424: return (-1);
26425: }
26426:
26427: /*
26428: * 3.4.4 Complex Type Definition Validation Rules
26429: * Validation Rule: Element Locally Valid (Complex Type) (cvc-complex-type)
26430: */
26431: static int
26432: xmlSchemaValidateChildElem(xmlSchemaValidCtxtPtr vctxt)
26433: {
26434: xmlSchemaNodeInfoPtr pielem;
26435: xmlSchemaTypePtr ptype;
26436: int ret = 0;
26437:
26438: if (vctxt->depth <= 0) {
26439: VERROR_INT("xmlSchemaValidateChildElem",
26440: "not intended for the validation root");
26441: return (-1);
26442: }
26443: pielem = vctxt->elemInfos[vctxt->depth -1];
26444: if (pielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
26445: pielem->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
26446: /*
26447: * Handle 'nilled' elements.
26448: */
26449: if (INODE_NILLED(pielem)) {
26450: /*
26451: * SPEC (cvc-elt) (3.3.4) : (3.2.1)
26452: */
26453: ACTIVATE_PARENT_ELEM;
26454: ret = XML_SCHEMAV_CVC_ELT_3_2_1;
26455: VERROR(ret, NULL,
26456: "Neither character nor element content is allowed, "
26457: "because the element was 'nilled'");
26458: ACTIVATE_ELEM;
26459: goto unexpected_elem;
26460: }
26461:
26462: ptype = pielem->typeDef;
26463:
26464: if (ptype->builtInType == XML_SCHEMAS_ANYTYPE) {
26465: /*
26466: * Workaround for "anyType": we have currently no content model
26467: * assigned for "anyType", so handle it explicitely.
26468: * "anyType" has an unbounded, lax "any" wildcard.
26469: */
26470: vctxt->inode->decl = xmlSchemaGetElem(vctxt->schema,
26471: vctxt->inode->localName,
26472: vctxt->inode->nsName);
26473:
26474: if (vctxt->inode->decl == NULL) {
26475: xmlSchemaAttrInfoPtr iattr;
26476: /*
26477: * Process "xsi:type".
26478: * SPEC (cvc-assess-elt) (1.2.1.2.1) - (1.2.1.2.3)
26479: */
26480: iattr = xmlSchemaGetMetaAttrInfo(vctxt,
26481: XML_SCHEMA_ATTR_INFO_META_XSI_TYPE);
26482: if (iattr != NULL) {
26483: ret = xmlSchemaProcessXSIType(vctxt, iattr,
26484: &(vctxt->inode->typeDef), NULL);
26485: if (ret != 0) {
26486: if (ret == -1) {
26487: VERROR_INT("xmlSchemaValidateChildElem",
26488: "calling xmlSchemaProcessXSIType() to "
26489: "process the attribute 'xsi:nil'");
26490: return (-1);
26491: }
26492: return (ret);
26493: }
26494: } else {
26495: /*
26496: * Fallback to "anyType".
26497: *
26498: * SPEC (cvc-assess-elt)
26499: * "If the item cannot be �strictly assessed�, [...]
26500: * an element information item's schema validity may be laxly
26501: * assessed if its �context-determined declaration� is not
26502: * skip by �validating� with respect to the �ur-type
26503: * definition� as per Element Locally Valid (Type) (�3.3.4)."
26504: */
26505: vctxt->inode->typeDef =
26506: xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
26507: }
26508: }
26509: return (0);
26510: }
26511:
26512: switch (ptype->contentType) {
26513: case XML_SCHEMA_CONTENT_EMPTY:
26514: /*
26515: * SPEC (2.1) "If the {content type} is empty, then the
26516: * element information item has no character or element
26517: * information item [children]."
26518: */
26519: ACTIVATE_PARENT_ELEM
26520: ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1;
26521: VERROR(ret, NULL,
26522: "Element content is not allowed, "
26523: "because the content type is empty");
26524: ACTIVATE_ELEM
26525: goto unexpected_elem;
26526: break;
26527:
26528: case XML_SCHEMA_CONTENT_MIXED:
26529: case XML_SCHEMA_CONTENT_ELEMENTS: {
26530: xmlRegExecCtxtPtr regexCtxt;
26531: xmlChar *values[10];
26532: int terminal, nbval = 10, nbneg;
26533:
26534: /* VAL TODO: Optimized "anyType" validation.*/
26535:
26536: if (ptype->contModel == NULL) {
26537: VERROR_INT("xmlSchemaValidateChildElem",
26538: "type has elem content but no content model");
26539: return (-1);
26540: }
26541: /*
26542: * Safety belf for evaluation if the cont. model was already
26543: * examined to be invalid.
26544: */
26545: if (pielem->flags & XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT) {
26546: VERROR_INT("xmlSchemaValidateChildElem",
26547: "validating elem, but elem content is already invalid");
26548: return (-1);
26549: }
26550:
26551: regexCtxt = pielem->regexCtxt;
26552: if (regexCtxt == NULL) {
26553: /*
26554: * Create the regex context.
26555: */
26556: regexCtxt = xmlRegNewExecCtxt(ptype->contModel,
26557: (xmlRegExecCallbacks) xmlSchemaVContentModelCallback,
26558: vctxt);
26559: if (regexCtxt == NULL) {
26560: VERROR_INT("xmlSchemaValidateChildElem",
26561: "failed to create a regex context");
26562: return (-1);
26563: }
26564: pielem->regexCtxt = regexCtxt;
26565: #ifdef DEBUG_AUTOMATA
26566: xmlGenericError(xmlGenericErrorContext, "AUTOMATA create on '%s'\n",
26567: pielem->localName);
26568: #endif
26569: }
26570:
26571: /*
26572: * SPEC (2.4) "If the {content type} is element-only or mixed,
26573: * then the sequence of the element information item's
26574: * element information item [children], if any, taken in
26575: * order, is �valid� with respect to the {content type}'s
26576: * particle, as defined in Element Sequence Locally Valid
26577: * (Particle) (�3.9.4)."
26578: */
26579: ret = xmlRegExecPushString2(regexCtxt,
26580: vctxt->inode->localName,
26581: vctxt->inode->nsName,
26582: vctxt->inode);
26583: #ifdef DEBUG_AUTOMATA
26584: if (ret < 0)
26585: xmlGenericError(xmlGenericErrorContext,
26586: "AUTOMATON push ERROR for '%s' on '%s'\n",
26587: vctxt->inode->localName, pielem->localName);
26588: else
26589: xmlGenericError(xmlGenericErrorContext,
26590: "AUTOMATON push OK for '%s' on '%s'\n",
26591: vctxt->inode->localName, pielem->localName);
26592: #endif
26593: if (vctxt->err == XML_SCHEMAV_INTERNAL) {
26594: VERROR_INT("xmlSchemaValidateChildElem",
26595: "calling xmlRegExecPushString2()");
26596: return (-1);
26597: }
26598: if (ret < 0) {
26599: xmlRegExecErrInfo(regexCtxt, NULL, &nbval, &nbneg,
26600: &values[0], &terminal);
26601: xmlSchemaComplexTypeErr(ACTXT_CAST vctxt,
26602: XML_SCHEMAV_ELEMENT_CONTENT, NULL,NULL,
26603: "This element is not expected",
26604: nbval, nbneg, values);
26605: ret = vctxt->err;
26606: goto unexpected_elem;
26607: } else
26608: ret = 0;
26609: }
26610: break;
26611: case XML_SCHEMA_CONTENT_SIMPLE:
26612: case XML_SCHEMA_CONTENT_BASIC:
26613: ACTIVATE_PARENT_ELEM
26614: if (WXS_IS_COMPLEX(ptype)) {
26615: /*
26616: * SPEC (cvc-complex-type) (2.2)
26617: * "If the {content type} is a simple type definition, then
26618: * the element information item has no element information
26619: * item [children], ..."
26620: */
26621: ret = XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2;
26622: VERROR(ret, NULL, "Element content is not allowed, "
26623: "because the content type is a simple type definition");
26624: } else {
26625: /*
26626: * SPEC (cvc-type) (3.1.2) "The element information item must
26627: * have no element information item [children]."
26628: */
26629: ret = XML_SCHEMAV_CVC_TYPE_3_1_2;
26630: VERROR(ret, NULL, "Element content is not allowed, "
26631: "because the type definition is simple");
26632: }
26633: ACTIVATE_ELEM
26634: ret = vctxt->err;
26635: goto unexpected_elem;
26636: break;
26637:
26638: default:
26639: break;
26640: }
26641: return (ret);
26642: unexpected_elem:
26643: /*
26644: * Pop this element and set the skipDepth to skip
26645: * all further content of the parent element.
26646: */
26647: vctxt->skipDepth = vctxt->depth;
26648: vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED;
26649: pielem->flags |= XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT;
26650: return (ret);
26651: }
26652:
26653: #define XML_SCHEMA_PUSH_TEXT_PERSIST 1
26654: #define XML_SCHEMA_PUSH_TEXT_CREATED 2
26655: #define XML_SCHEMA_PUSH_TEXT_VOLATILE 3
26656:
26657: static int
26658: xmlSchemaVPushText(xmlSchemaValidCtxtPtr vctxt,
26659: int nodeType, const xmlChar *value, int len,
26660: int mode, int *consumed)
26661: {
26662: /*
26663: * Unfortunately we have to duplicate the text sometimes.
26664: * OPTIMIZE: Maybe we could skip it, if:
26665: * 1. content type is simple
26666: * 2. whitespace is "collapse"
26667: * 3. it consists of whitespace only
26668: *
26669: * Process character content.
26670: */
26671: if (consumed != NULL)
26672: *consumed = 0;
26673: if (INODE_NILLED(vctxt->inode)) {
26674: /*
26675: * SPEC cvc-elt (3.3.4 - 3.2.1)
26676: * "The element information item must have no character or
26677: * element information item [children]."
26678: */
26679: VERROR(XML_SCHEMAV_CVC_ELT_3_2_1, NULL,
26680: "Neither character nor element content is allowed "
26681: "because the element is 'nilled'");
26682: return (vctxt->err);
26683: }
26684: /*
26685: * SPEC (2.1) "If the {content type} is empty, then the
26686: * element information item has no character or element
26687: * information item [children]."
26688: */
26689: if (vctxt->inode->typeDef->contentType ==
26690: XML_SCHEMA_CONTENT_EMPTY) {
26691: VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, NULL,
26692: "Character content is not allowed, "
26693: "because the content type is empty");
26694: return (vctxt->err);
26695: }
26696:
26697: if (vctxt->inode->typeDef->contentType ==
26698: XML_SCHEMA_CONTENT_ELEMENTS) {
26699: if ((nodeType != XML_TEXT_NODE) ||
26700: (! xmlSchemaIsBlank((xmlChar *) value, len))) {
26701: /*
26702: * SPEC cvc-complex-type (2.3)
26703: * "If the {content type} is element-only, then the
26704: * element information item has no character information
26705: * item [children] other than those whose [character
26706: * code] is defined as a white space in [XML 1.0 (Second
26707: * Edition)]."
26708: */
26709: VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, NULL,
26710: "Character content other than whitespace is not allowed "
26711: "because the content type is 'element-only'");
26712: return (vctxt->err);
26713: }
26714: return (0);
26715: }
26716:
26717: if ((value == NULL) || (value[0] == 0))
26718: return (0);
26719: /*
26720: * Save the value.
26721: * NOTE that even if the content type is *mixed*, we need the
26722: * *initial value* for default/fixed value constraints.
26723: */
26724: if ((vctxt->inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) &&
26725: ((vctxt->inode->decl == NULL) ||
26726: (vctxt->inode->decl->value == NULL)))
26727: return (0);
26728:
26729: if (vctxt->inode->value == NULL) {
26730: /*
26731: * Set the value.
26732: */
26733: switch (mode) {
26734: case XML_SCHEMA_PUSH_TEXT_PERSIST:
26735: /*
26736: * When working on a tree.
26737: */
26738: vctxt->inode->value = value;
26739: break;
26740: case XML_SCHEMA_PUSH_TEXT_CREATED:
26741: /*
26742: * When working with the reader.
26743: * The value will be freed by the element info.
26744: */
26745: vctxt->inode->value = value;
26746: if (consumed != NULL)
26747: *consumed = 1;
26748: vctxt->inode->flags |=
26749: XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
26750: break;
26751: case XML_SCHEMA_PUSH_TEXT_VOLATILE:
26752: /*
26753: * When working with SAX.
26754: * The value will be freed by the element info.
26755: */
26756: if (len != -1)
26757: vctxt->inode->value = BAD_CAST xmlStrndup(value, len);
26758: else
26759: vctxt->inode->value = BAD_CAST xmlStrdup(value);
26760: vctxt->inode->flags |=
26761: XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
26762: break;
26763: default:
26764: break;
26765: }
26766: } else {
26767: if (len < 0)
26768: len = xmlStrlen(value);
26769: /*
26770: * Concat the value.
26771: */
26772: if (vctxt->inode->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
26773: vctxt->inode->value = BAD_CAST xmlStrncat(
26774: (xmlChar *) vctxt->inode->value, value, len);
26775: } else {
26776: vctxt->inode->value =
26777: BAD_CAST xmlStrncatNew(vctxt->inode->value, value, len);
26778: vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
26779: }
26780: }
26781:
26782: return (0);
26783: }
26784:
26785: static int
26786: xmlSchemaValidateElem(xmlSchemaValidCtxtPtr vctxt)
26787: {
26788: int ret = 0;
26789:
26790: if ((vctxt->skipDepth != -1) &&
26791: (vctxt->depth >= vctxt->skipDepth)) {
26792: VERROR_INT("xmlSchemaValidateElem",
26793: "in skip-state");
26794: goto internal_error;
26795: }
26796: if (vctxt->xsiAssemble) {
26797: /*
26798: * We will stop validation if there was an error during
26799: * dynamic schema construction.
26800: * Note that we simply set @skipDepth to 0, this could
26801: * mean that a streaming document via SAX would be
26802: * still read to the end but it won't be validated any more.
26803: * TODO: If we are sure how to stop the validation at once
26804: * for all input scenarios, then this should be changed to
26805: * instantly stop the validation.
26806: */
26807: ret = xmlSchemaAssembleByXSI(vctxt);
26808: if (ret != 0) {
26809: if (ret == -1)
26810: goto internal_error;
26811: vctxt->skipDepth = 0;
26812: return(ret);
26813: }
26814: /*
26815: * Augment the IDC definitions for the main schema and all imported ones
26816: * NOTE: main schema is the first in the imported list
26817: */
26818: xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
26819: }
26820: if (vctxt->depth > 0) {
26821: /*
26822: * Validate this element against the content model
26823: * of the parent.
26824: */
26825: ret = xmlSchemaValidateChildElem(vctxt);
26826: if (ret != 0) {
26827: if (ret < 0) {
26828: VERROR_INT("xmlSchemaValidateElem",
26829: "calling xmlSchemaStreamValidateChildElement()");
26830: goto internal_error;
26831: }
26832: goto exit;
26833: }
26834: if (vctxt->depth == vctxt->skipDepth)
26835: goto exit;
26836: if ((vctxt->inode->decl == NULL) &&
26837: (vctxt->inode->typeDef == NULL)) {
26838: VERROR_INT("xmlSchemaValidateElem",
26839: "the child element was valid but neither the "
26840: "declaration nor the type was set");
26841: goto internal_error;
26842: }
26843: } else {
26844: /*
26845: * Get the declaration of the validation root.
26846: */
26847: vctxt->inode->decl = xmlSchemaGetElem(vctxt->schema,
26848: vctxt->inode->localName,
26849: vctxt->inode->nsName);
26850: if (vctxt->inode->decl == NULL) {
26851: ret = XML_SCHEMAV_CVC_ELT_1;
26852: VERROR(ret, NULL,
26853: "No matching global declaration available "
26854: "for the validation root");
26855: goto exit;
26856: }
26857: }
26858:
26859: if (vctxt->inode->decl == NULL)
26860: goto type_validation;
26861:
26862: if (vctxt->inode->decl->type == XML_SCHEMA_TYPE_ANY) {
26863: int skip;
26864: /*
26865: * Wildcards.
26866: */
26867: ret = xmlSchemaValidateElemWildcard(vctxt, &skip);
26868: if (ret != 0) {
26869: if (ret < 0) {
26870: VERROR_INT("xmlSchemaValidateElem",
26871: "calling xmlSchemaValidateElemWildcard()");
26872: goto internal_error;
26873: }
26874: goto exit;
26875: }
26876: if (skip) {
26877: vctxt->skipDepth = vctxt->depth;
26878: goto exit;
26879: }
26880: /*
26881: * The declaration might be set by the wildcard validation,
26882: * when the processContents is "lax" or "strict".
26883: */
26884: if (vctxt->inode->decl->type != XML_SCHEMA_TYPE_ELEMENT) {
26885: /*
26886: * Clear the "decl" field to not confuse further processing.
26887: */
26888: vctxt->inode->decl = NULL;
26889: goto type_validation;
26890: }
26891: }
26892: /*
26893: * Validate against the declaration.
26894: */
26895: ret = xmlSchemaValidateElemDecl(vctxt);
26896: if (ret != 0) {
26897: if (ret < 0) {
26898: VERROR_INT("xmlSchemaValidateElem",
26899: "calling xmlSchemaValidateElemDecl()");
26900: goto internal_error;
26901: }
26902: goto exit;
26903: }
26904: /*
26905: * Validate against the type definition.
26906: */
26907: type_validation:
26908:
26909: if (vctxt->inode->typeDef == NULL) {
26910: vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
26911: ret = XML_SCHEMAV_CVC_TYPE_1;
26912: VERROR(ret, NULL,
26913: "The type definition is absent");
26914: goto exit;
26915: }
26916: if (vctxt->inode->typeDef->flags & XML_SCHEMAS_TYPE_ABSTRACT) {
26917: vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
26918: ret = XML_SCHEMAV_CVC_TYPE_2;
26919: VERROR(ret, NULL,
26920: "The type definition is abstract");
26921: goto exit;
26922: }
26923: /*
26924: * Evaluate IDCs. Do it here, since new IDC matchers are registered
26925: * during validation against the declaration. This must be done
26926: * _before_ attribute validation.
26927: */
26928: if (vctxt->xpathStates != NULL) {
26929: ret = xmlSchemaXPathEvaluate(vctxt, XML_ELEMENT_NODE);
26930: vctxt->inode->appliedXPath = 1;
26931: if (ret == -1) {
26932: VERROR_INT("xmlSchemaValidateElem",
26933: "calling xmlSchemaXPathEvaluate()");
26934: goto internal_error;
26935: }
26936: }
26937: /*
26938: * Validate attributes.
26939: */
26940: if (WXS_IS_COMPLEX(vctxt->inode->typeDef)) {
26941: if ((vctxt->nbAttrInfos != 0) ||
26942: (vctxt->inode->typeDef->attrUses != NULL)) {
26943:
26944: ret = xmlSchemaVAttributesComplex(vctxt);
26945: }
26946: } else if (vctxt->nbAttrInfos != 0) {
26947:
26948: ret = xmlSchemaVAttributesSimple(vctxt);
26949: }
26950: /*
26951: * Clear registered attributes.
26952: */
26953: if (vctxt->nbAttrInfos != 0)
26954: xmlSchemaClearAttrInfos(vctxt);
26955: if (ret == -1) {
26956: VERROR_INT("xmlSchemaValidateElem",
26957: "calling attributes validation");
26958: goto internal_error;
26959: }
26960: /*
26961: * Don't return an error if attributes are invalid on purpose.
26962: */
26963: ret = 0;
26964:
26965: exit:
26966: if (ret != 0)
26967: vctxt->skipDepth = vctxt->depth;
26968: return (ret);
26969: internal_error:
26970: return (-1);
26971: }
26972:
26973: #ifdef XML_SCHEMA_READER_ENABLED
26974: static int
26975: xmlSchemaVReaderWalk(xmlSchemaValidCtxtPtr vctxt)
26976: {
26977: const int WHTSP = 13, SIGN_WHTSP = 14, END_ELEM = 15;
26978: int depth, nodeType, ret = 0, consumed;
26979: xmlSchemaNodeInfoPtr ielem;
26980:
26981: vctxt->depth = -1;
26982: ret = xmlTextReaderRead(vctxt->reader);
26983: /*
26984: * Move to the document element.
26985: */
26986: while (ret == 1) {
26987: nodeType = xmlTextReaderNodeType(vctxt->reader);
26988: if (nodeType == XML_ELEMENT_NODE)
26989: goto root_found;
26990: ret = xmlTextReaderRead(vctxt->reader);
26991: }
26992: goto exit;
26993:
26994: root_found:
26995:
26996: do {
26997: depth = xmlTextReaderDepth(vctxt->reader);
26998: nodeType = xmlTextReaderNodeType(vctxt->reader);
26999:
27000: if (nodeType == XML_ELEMENT_NODE) {
27001:
27002: vctxt->depth++;
27003: if (xmlSchemaValidatorPushElem(vctxt) == -1) {
27004: VERROR_INT("xmlSchemaVReaderWalk",
27005: "calling xmlSchemaValidatorPushElem()");
27006: goto internal_error;
27007: }
27008: ielem = vctxt->inode;
27009: ielem->localName = xmlTextReaderLocalName(vctxt->reader);
27010: ielem->nsName = xmlTextReaderNamespaceUri(vctxt->reader);
27011: ielem->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
27012: /*
27013: * Is the element empty?
27014: */
27015: ret = xmlTextReaderIsEmptyElement(vctxt->reader);
27016: if (ret == -1) {
27017: VERROR_INT("xmlSchemaVReaderWalk",
27018: "calling xmlTextReaderIsEmptyElement()");
27019: goto internal_error;
27020: }
27021: if (ret) {
27022: ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
27023: }
27024: /*
27025: * Register attributes.
27026: */
27027: vctxt->nbAttrInfos = 0;
27028: ret = xmlTextReaderMoveToFirstAttribute(vctxt->reader);
27029: if (ret == -1) {
27030: VERROR_INT("xmlSchemaVReaderWalk",
27031: "calling xmlTextReaderMoveToFirstAttribute()");
27032: goto internal_error;
27033: }
27034: if (ret == 1) {
27035: do {
27036: /*
27037: * VAL TODO: How do we know that the reader works on a
27038: * node tree, to be able to pass a node here?
27039: */
27040: if (xmlSchemaValidatorPushAttribute(vctxt, NULL,
27041: (const xmlChar *) xmlTextReaderLocalName(vctxt->reader),
27042: xmlTextReaderNamespaceUri(vctxt->reader), 1,
27043: xmlTextReaderValue(vctxt->reader), 1) == -1) {
27044:
27045: VERROR_INT("xmlSchemaVReaderWalk",
27046: "calling xmlSchemaValidatorPushAttribute()");
27047: goto internal_error;
27048: }
27049: ret = xmlTextReaderMoveToNextAttribute(vctxt->reader);
27050: if (ret == -1) {
27051: VERROR_INT("xmlSchemaVReaderWalk",
27052: "calling xmlTextReaderMoveToFirstAttribute()");
27053: goto internal_error;
27054: }
27055: } while (ret == 1);
27056: /*
27057: * Back to element position.
27058: */
27059: ret = xmlTextReaderMoveToElement(vctxt->reader);
27060: if (ret == -1) {
27061: VERROR_INT("xmlSchemaVReaderWalk",
27062: "calling xmlTextReaderMoveToElement()");
27063: goto internal_error;
27064: }
27065: }
27066: /*
27067: * Validate the element.
27068: */
27069: ret= xmlSchemaValidateElem(vctxt);
27070: if (ret != 0) {
27071: if (ret == -1) {
27072: VERROR_INT("xmlSchemaVReaderWalk",
27073: "calling xmlSchemaValidateElem()");
27074: goto internal_error;
27075: }
27076: goto exit;
27077: }
27078: if (vctxt->depth == vctxt->skipDepth) {
27079: int curDepth;
27080: /*
27081: * Skip all content.
27082: */
27083: if ((ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY) == 0) {
27084: ret = xmlTextReaderRead(vctxt->reader);
27085: curDepth = xmlTextReaderDepth(vctxt->reader);
27086: while ((ret == 1) && (curDepth != depth)) {
27087: ret = xmlTextReaderRead(vctxt->reader);
27088: curDepth = xmlTextReaderDepth(vctxt->reader);
27089: }
27090: if (ret < 0) {
27091: /*
27092: * VAL TODO: A reader error occured; what to do here?
27093: */
27094: ret = 1;
27095: goto exit;
27096: }
27097: }
27098: goto leave_elem;
27099: }
27100: /*
27101: * READER VAL TODO: Is an END_ELEM really never called
27102: * if the elem is empty?
27103: */
27104: if (ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
27105: goto leave_elem;
27106: } else if (nodeType == END_ELEM) {
27107: /*
27108: * Process END of element.
27109: */
27110: leave_elem:
27111: ret = xmlSchemaValidatorPopElem(vctxt);
27112: if (ret != 0) {
27113: if (ret < 0) {
27114: VERROR_INT("xmlSchemaVReaderWalk",
27115: "calling xmlSchemaValidatorPopElem()");
27116: goto internal_error;
27117: }
27118: goto exit;
27119: }
27120: if (vctxt->depth >= 0)
27121: ielem = vctxt->inode;
27122: else
27123: ielem = NULL;
27124: } else if ((nodeType == XML_TEXT_NODE) ||
27125: (nodeType == XML_CDATA_SECTION_NODE) ||
27126: (nodeType == WHTSP) ||
27127: (nodeType == SIGN_WHTSP)) {
27128: /*
27129: * Process character content.
27130: */
27131: xmlChar *value;
27132:
27133: if ((nodeType == WHTSP) || (nodeType == SIGN_WHTSP))
27134: nodeType = XML_TEXT_NODE;
27135:
27136: value = xmlTextReaderValue(vctxt->reader);
27137: ret = xmlSchemaVPushText(vctxt, nodeType, BAD_CAST value,
27138: -1, XML_SCHEMA_PUSH_TEXT_CREATED, &consumed);
27139: if (! consumed)
27140: xmlFree(value);
27141: if (ret == -1) {
27142: VERROR_INT("xmlSchemaVReaderWalk",
27143: "calling xmlSchemaVPushText()");
27144: goto internal_error;
27145: }
27146: } else if ((nodeType == XML_ENTITY_NODE) ||
27147: (nodeType == XML_ENTITY_REF_NODE)) {
27148: /*
27149: * VAL TODO: What to do with entities?
27150: */
27151: TODO
27152: }
27153: /*
27154: * Read next node.
27155: */
27156: ret = xmlTextReaderRead(vctxt->reader);
27157: } while (ret == 1);
27158:
27159: exit:
27160: return (ret);
27161: internal_error:
27162: return (-1);
27163: }
27164: #endif
27165:
27166: /************************************************************************
27167: * *
27168: * SAX validation handlers *
27169: * *
27170: ************************************************************************/
27171:
27172: /*
27173: * Process text content.
27174: */
27175: static void
27176: xmlSchemaSAXHandleText(void *ctx,
27177: const xmlChar * ch,
27178: int len)
27179: {
27180: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
27181:
27182: if (vctxt->depth < 0)
27183: return;
27184: if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
27185: return;
27186: if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
27187: vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
27188: if (xmlSchemaVPushText(vctxt, XML_TEXT_NODE, ch, len,
27189: XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
27190: VERROR_INT("xmlSchemaSAXHandleCDataSection",
27191: "calling xmlSchemaVPushText()");
27192: vctxt->err = -1;
27193: xmlStopParser(vctxt->parserCtxt);
27194: }
27195: }
27196:
27197: /*
27198: * Process CDATA content.
27199: */
27200: static void
27201: xmlSchemaSAXHandleCDataSection(void *ctx,
27202: const xmlChar * ch,
27203: int len)
27204: {
27205: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
27206:
27207: if (vctxt->depth < 0)
27208: return;
27209: if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
27210: return;
27211: if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
27212: vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
27213: if (xmlSchemaVPushText(vctxt, XML_CDATA_SECTION_NODE, ch, len,
27214: XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
27215: VERROR_INT("xmlSchemaSAXHandleCDataSection",
27216: "calling xmlSchemaVPushText()");
27217: vctxt->err = -1;
27218: xmlStopParser(vctxt->parserCtxt);
27219: }
27220: }
27221:
27222: static void
27223: xmlSchemaSAXHandleReference(void *ctx ATTRIBUTE_UNUSED,
27224: const xmlChar * name ATTRIBUTE_UNUSED)
27225: {
27226: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
27227:
27228: if (vctxt->depth < 0)
27229: return;
27230: if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
27231: return;
27232: /* SAX VAL TODO: What to do here? */
27233: TODO
27234: }
27235:
27236: static void
27237: xmlSchemaSAXHandleStartElementNs(void *ctx,
27238: const xmlChar * localname,
27239: const xmlChar * prefix ATTRIBUTE_UNUSED,
27240: const xmlChar * URI,
27241: int nb_namespaces,
27242: const xmlChar ** namespaces,
27243: int nb_attributes,
27244: int nb_defaulted ATTRIBUTE_UNUSED,
27245: const xmlChar ** attributes)
27246: {
27247: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
27248: int ret;
27249: xmlSchemaNodeInfoPtr ielem;
27250: int i, j;
27251:
27252: /*
27253: * SAX VAL TODO: What to do with nb_defaulted?
27254: */
27255: /*
27256: * Skip elements if inside a "skip" wildcard or invalid.
27257: */
27258: vctxt->depth++;
27259: if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
27260: return;
27261: /*
27262: * Push the element.
27263: */
27264: if (xmlSchemaValidatorPushElem(vctxt) == -1) {
27265: VERROR_INT("xmlSchemaSAXHandleStartElementNs",
27266: "calling xmlSchemaValidatorPushElem()");
27267: goto internal_error;
27268: }
27269: ielem = vctxt->inode;
27270: /*
27271: * TODO: Is this OK?
27272: */
27273: ielem->nodeLine = xmlSAX2GetLineNumber(vctxt->parserCtxt);
27274: ielem->localName = localname;
27275: ielem->nsName = URI;
27276: ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
27277: /*
27278: * Register namespaces on the elem info.
27279: */
27280: if (nb_namespaces != 0) {
27281: /*
27282: * Although the parser builds its own namespace list,
27283: * we have no access to it, so we'll use an own one.
27284: */
27285: for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {
27286: /*
27287: * Store prefix and namespace name.
27288: */
27289: if (ielem->nsBindings == NULL) {
27290: ielem->nsBindings =
27291: (const xmlChar **) xmlMalloc(10 *
27292: sizeof(const xmlChar *));
27293: if (ielem->nsBindings == NULL) {
27294: xmlSchemaVErrMemory(vctxt,
27295: "allocating namespace bindings for SAX validation",
27296: NULL);
27297: goto internal_error;
27298: }
27299: ielem->nbNsBindings = 0;
27300: ielem->sizeNsBindings = 5;
27301: } else if (ielem->sizeNsBindings <= ielem->nbNsBindings) {
27302: ielem->sizeNsBindings *= 2;
27303: ielem->nsBindings =
27304: (const xmlChar **) xmlRealloc(
27305: (void *) ielem->nsBindings,
27306: ielem->sizeNsBindings * 2 * sizeof(const xmlChar *));
27307: if (ielem->nsBindings == NULL) {
27308: xmlSchemaVErrMemory(vctxt,
27309: "re-allocating namespace bindings for SAX validation",
27310: NULL);
27311: goto internal_error;
27312: }
27313: }
27314:
27315: ielem->nsBindings[ielem->nbNsBindings * 2] = namespaces[j];
27316: if (namespaces[j+1][0] == 0) {
27317: /*
27318: * Handle xmlns="".
27319: */
27320: ielem->nsBindings[ielem->nbNsBindings * 2 + 1] = NULL;
27321: } else
27322: ielem->nsBindings[ielem->nbNsBindings * 2 + 1] =
27323: namespaces[j+1];
27324: ielem->nbNsBindings++;
27325: }
27326: }
27327: /*
27328: * Register attributes.
27329: * SAX VAL TODO: We are not adding namespace declaration
27330: * attributes yet.
27331: */
27332: if (nb_attributes != 0) {
27333: xmlChar *value;
27334:
27335: for (j = 0, i = 0; i < nb_attributes; i++, j += 5) {
27336: /*
27337: * Duplicate the value.
27338: */
27339: value = xmlStrndup(attributes[j+3],
27340: attributes[j+4] - attributes[j+3]);
27341: /*
27342: * TODO: Set the node line.
27343: */
27344: ret = xmlSchemaValidatorPushAttribute(vctxt,
27345: NULL, ielem->nodeLine, attributes[j], attributes[j+2], 0,
27346: value, 1);
27347: if (ret == -1) {
27348: VERROR_INT("xmlSchemaSAXHandleStartElementNs",
27349: "calling xmlSchemaValidatorPushAttribute()");
27350: goto internal_error;
27351: }
27352: }
27353: }
27354: /*
27355: * Validate the element.
27356: */
27357: ret = xmlSchemaValidateElem(vctxt);
27358: if (ret != 0) {
27359: if (ret == -1) {
27360: VERROR_INT("xmlSchemaSAXHandleStartElementNs",
27361: "calling xmlSchemaValidateElem()");
27362: goto internal_error;
27363: }
27364: goto exit;
27365: }
27366:
27367: exit:
27368: return;
27369: internal_error:
27370: vctxt->err = -1;
27371: xmlStopParser(vctxt->parserCtxt);
27372: return;
27373: }
27374:
27375: static void
27376: xmlSchemaSAXHandleEndElementNs(void *ctx,
27377: const xmlChar * localname ATTRIBUTE_UNUSED,
27378: const xmlChar * prefix ATTRIBUTE_UNUSED,
27379: const xmlChar * URI ATTRIBUTE_UNUSED)
27380: {
27381: xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
27382: int res;
27383:
27384: /*
27385: * Skip elements if inside a "skip" wildcard or if invalid.
27386: */
27387: if (vctxt->skipDepth != -1) {
27388: if (vctxt->depth > vctxt->skipDepth) {
27389: vctxt->depth--;
27390: return;
27391: } else
27392: vctxt->skipDepth = -1;
27393: }
27394: /*
27395: * SAX VAL TODO: Just a temporary check.
27396: */
27397: if ((!xmlStrEqual(vctxt->inode->localName, localname)) ||
27398: (!xmlStrEqual(vctxt->inode->nsName, URI))) {
27399: VERROR_INT("xmlSchemaSAXHandleEndElementNs",
27400: "elem pop mismatch");
27401: }
27402: res = xmlSchemaValidatorPopElem(vctxt);
27403: if (res != 0) {
27404: if (res < 0) {
27405: VERROR_INT("xmlSchemaSAXHandleEndElementNs",
27406: "calling xmlSchemaValidatorPopElem()");
27407: goto internal_error;
27408: }
27409: goto exit;
27410: }
27411: exit:
27412: return;
27413: internal_error:
27414: vctxt->err = -1;
27415: xmlStopParser(vctxt->parserCtxt);
27416: return;
27417: }
27418:
27419: /************************************************************************
27420: * *
27421: * Validation interfaces *
27422: * *
27423: ************************************************************************/
27424:
27425: /**
27426: * xmlSchemaNewValidCtxt:
27427: * @schema: a precompiled XML Schemas
27428: *
27429: * Create an XML Schemas validation context based on the given schema.
27430: *
27431: * Returns the validation context or NULL in case of error
27432: */
27433: xmlSchemaValidCtxtPtr
27434: xmlSchemaNewValidCtxt(xmlSchemaPtr schema)
27435: {
27436: xmlSchemaValidCtxtPtr ret;
27437:
27438: ret = (xmlSchemaValidCtxtPtr) xmlMalloc(sizeof(xmlSchemaValidCtxt));
27439: if (ret == NULL) {
27440: xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
27441: return (NULL);
27442: }
27443: memset(ret, 0, sizeof(xmlSchemaValidCtxt));
27444: ret->type = XML_SCHEMA_CTXT_VALIDATOR;
27445: ret->dict = xmlDictCreate();
27446: ret->nodeQNames = xmlSchemaItemListCreate();
27447: ret->schema = schema;
27448: return (ret);
27449: }
27450:
27451: /**
27452: * xmlSchemaClearValidCtxt:
27453: * @ctxt: the schema validation context
27454: *
27455: * Free the resources associated to the schema validation context;
27456: * leaves some fields alive intended for reuse of the context.
27457: */
27458: static void
27459: xmlSchemaClearValidCtxt(xmlSchemaValidCtxtPtr vctxt)
27460: {
27461: if (vctxt == NULL)
27462: return;
27463:
27464: /*
27465: * TODO: Should we clear the flags?
27466: * Might be problematic if one reuses the context
27467: * and assumes that the options remain the same.
27468: */
27469: vctxt->flags = 0;
27470: vctxt->validationRoot = NULL;
27471: vctxt->doc = NULL;
27472: #ifdef LIBXML_READER_ENABLED
27473: vctxt->reader = NULL;
27474: #endif
27475: vctxt->hasKeyrefs = 0;
27476:
27477: if (vctxt->value != NULL) {
27478: xmlSchemaFreeValue(vctxt->value);
27479: vctxt->value = NULL;
27480: }
27481: /*
27482: * Augmented IDC information.
27483: */
27484: if (vctxt->aidcs != NULL) {
27485: xmlSchemaIDCAugPtr cur = vctxt->aidcs, next;
27486: do {
27487: next = cur->next;
27488: xmlFree(cur);
27489: cur = next;
27490: } while (cur != NULL);
27491: vctxt->aidcs = NULL;
27492: }
27493: if (vctxt->idcMatcherCache != NULL) {
27494: xmlSchemaIDCMatcherPtr matcher = vctxt->idcMatcherCache, tmp;
27495:
27496: while (matcher) {
27497: tmp = matcher;
27498: matcher = matcher->nextCached;
27499: xmlSchemaIDCFreeMatcherList(tmp);
27500: }
27501: vctxt->idcMatcherCache = NULL;
27502: }
27503:
27504:
27505: if (vctxt->idcNodes != NULL) {
27506: int i;
27507: xmlSchemaPSVIIDCNodePtr item;
27508:
27509: for (i = 0; i < vctxt->nbIdcNodes; i++) {
27510: item = vctxt->idcNodes[i];
27511: xmlFree(item->keys);
27512: xmlFree(item);
27513: }
27514: xmlFree(vctxt->idcNodes);
27515: vctxt->idcNodes = NULL;
27516: vctxt->nbIdcNodes = 0;
27517: vctxt->sizeIdcNodes = 0;
27518: }
27519: /*
27520: * Note that we won't delete the XPath state pool here.
27521: */
27522: if (vctxt->xpathStates != NULL) {
27523: xmlSchemaFreeIDCStateObjList(vctxt->xpathStates);
27524: vctxt->xpathStates = NULL;
27525: }
27526: /*
27527: * Attribute info.
27528: */
27529: if (vctxt->nbAttrInfos != 0) {
27530: xmlSchemaClearAttrInfos(vctxt);
27531: }
27532: /*
27533: * Element info.
27534: */
27535: if (vctxt->elemInfos != NULL) {
27536: int i;
27537: xmlSchemaNodeInfoPtr ei;
27538:
27539: for (i = 0; i < vctxt->sizeElemInfos; i++) {
27540: ei = vctxt->elemInfos[i];
27541: if (ei == NULL)
27542: break;
27543: xmlSchemaClearElemInfo(vctxt, ei);
27544: }
27545: }
27546: xmlSchemaItemListClear(vctxt->nodeQNames);
27547: /* Recreate the dict. */
27548: xmlDictFree(vctxt->dict);
27549: /*
27550: * TODO: Is is save to recreate it? Do we have a scenario
27551: * where the user provides the dict?
27552: */
27553: vctxt->dict = xmlDictCreate();
27554: }
27555:
27556: /**
27557: * xmlSchemaFreeValidCtxt:
27558: * @ctxt: the schema validation context
27559: *
27560: * Free the resources associated to the schema validation context
27561: */
27562: void
27563: xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
27564: {
27565: if (ctxt == NULL)
27566: return;
27567: if (ctxt->value != NULL)
27568: xmlSchemaFreeValue(ctxt->value);
27569: if (ctxt->pctxt != NULL)
27570: xmlSchemaFreeParserCtxt(ctxt->pctxt);
27571: if (ctxt->idcNodes != NULL) {
27572: int i;
27573: xmlSchemaPSVIIDCNodePtr item;
27574:
27575: for (i = 0; i < ctxt->nbIdcNodes; i++) {
27576: item = ctxt->idcNodes[i];
27577: xmlFree(item->keys);
27578: xmlFree(item);
27579: }
27580: xmlFree(ctxt->idcNodes);
27581: }
27582: if (ctxt->idcKeys != NULL) {
27583: int i;
27584: for (i = 0; i < ctxt->nbIdcKeys; i++)
27585: xmlSchemaIDCFreeKey(ctxt->idcKeys[i]);
27586: xmlFree(ctxt->idcKeys);
27587: }
27588:
27589: if (ctxt->xpathStates != NULL) {
27590: xmlSchemaFreeIDCStateObjList(ctxt->xpathStates);
27591: ctxt->xpathStates = NULL;
27592: }
27593: if (ctxt->xpathStatePool != NULL) {
27594: xmlSchemaFreeIDCStateObjList(ctxt->xpathStatePool);
27595: ctxt->xpathStatePool = NULL;
27596: }
27597:
27598: /*
27599: * Augmented IDC information.
27600: */
27601: if (ctxt->aidcs != NULL) {
27602: xmlSchemaIDCAugPtr cur = ctxt->aidcs, next;
27603: do {
27604: next = cur->next;
27605: xmlFree(cur);
27606: cur = next;
27607: } while (cur != NULL);
27608: }
27609: if (ctxt->attrInfos != NULL) {
27610: int i;
27611: xmlSchemaAttrInfoPtr attr;
27612:
27613: /* Just a paranoid call to the cleanup. */
27614: if (ctxt->nbAttrInfos != 0)
27615: xmlSchemaClearAttrInfos(ctxt);
27616: for (i = 0; i < ctxt->sizeAttrInfos; i++) {
27617: attr = ctxt->attrInfos[i];
27618: xmlFree(attr);
27619: }
27620: xmlFree(ctxt->attrInfos);
27621: }
27622: if (ctxt->elemInfos != NULL) {
27623: int i;
27624: xmlSchemaNodeInfoPtr ei;
27625:
27626: for (i = 0; i < ctxt->sizeElemInfos; i++) {
27627: ei = ctxt->elemInfos[i];
27628: if (ei == NULL)
27629: break;
27630: xmlSchemaClearElemInfo(ctxt, ei);
27631: xmlFree(ei);
27632: }
27633: xmlFree(ctxt->elemInfos);
27634: }
27635: if (ctxt->nodeQNames != NULL)
27636: xmlSchemaItemListFree(ctxt->nodeQNames);
27637: if (ctxt->dict != NULL)
27638: xmlDictFree(ctxt->dict);
27639: xmlFree(ctxt);
27640: }
27641:
27642: /**
27643: * xmlSchemaIsValid:
27644: * @ctxt: the schema validation context
27645: *
27646: * Check if any error was detected during validation.
27647: *
27648: * Returns 1 if valid so far, 0 if errors were detected, and -1 in case
27649: * of internal error.
27650: */
27651: int
27652: xmlSchemaIsValid(xmlSchemaValidCtxtPtr ctxt)
27653: {
27654: if (ctxt == NULL)
27655: return(-1);
27656: return(ctxt->err == 0);
27657: }
27658:
27659: /**
27660: * xmlSchemaSetValidErrors:
27661: * @ctxt: a schema validation context
27662: * @err: the error function
27663: * @warn: the warning function
27664: * @ctx: the functions context
27665: *
27666: * Set the error and warning callback informations
27667: */
27668: void
27669: xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt,
27670: xmlSchemaValidityErrorFunc err,
27671: xmlSchemaValidityWarningFunc warn, void *ctx)
27672: {
27673: if (ctxt == NULL)
27674: return;
27675: ctxt->error = err;
27676: ctxt->warning = warn;
27677: ctxt->errCtxt = ctx;
27678: if (ctxt->pctxt != NULL)
27679: xmlSchemaSetParserErrors(ctxt->pctxt, err, warn, ctx);
27680: }
27681:
27682: /**
27683: * xmlSchemaSetValidStructuredErrors:
27684: * @ctxt: a schema validation context
27685: * @serror: the structured error function
27686: * @ctx: the functions context
27687: *
27688: * Set the structured error callback
27689: */
27690: void
27691: xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
27692: xmlStructuredErrorFunc serror, void *ctx)
27693: {
27694: if (ctxt == NULL)
27695: return;
27696: ctxt->serror = serror;
27697: ctxt->error = NULL;
27698: ctxt->warning = NULL;
27699: ctxt->errCtxt = ctx;
27700: if (ctxt->pctxt != NULL)
27701: xmlSchemaSetParserStructuredErrors(ctxt->pctxt, serror, ctx);
27702: }
27703:
27704: /**
27705: * xmlSchemaGetValidErrors:
27706: * @ctxt: a XML-Schema validation context
27707: * @err: the error function result
27708: * @warn: the warning function result
27709: * @ctx: the functions context result
27710: *
27711: * Get the error and warning callback informations
27712: *
27713: * Returns -1 in case of error and 0 otherwise
27714: */
27715: int
27716: xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt,
27717: xmlSchemaValidityErrorFunc * err,
27718: xmlSchemaValidityWarningFunc * warn, void **ctx)
27719: {
27720: if (ctxt == NULL)
27721: return (-1);
27722: if (err != NULL)
27723: *err = ctxt->error;
27724: if (warn != NULL)
27725: *warn = ctxt->warning;
27726: if (ctx != NULL)
27727: *ctx = ctxt->errCtxt;
27728: return (0);
27729: }
27730:
27731:
27732: /**
27733: * xmlSchemaSetValidOptions:
27734: * @ctxt: a schema validation context
27735: * @options: a combination of xmlSchemaValidOption
27736: *
27737: * Sets the options to be used during the validation.
27738: *
27739: * Returns 0 in case of success, -1 in case of an
27740: * API error.
27741: */
27742: int
27743: xmlSchemaSetValidOptions(xmlSchemaValidCtxtPtr ctxt,
27744: int options)
27745:
27746: {
27747: int i;
27748:
27749: if (ctxt == NULL)
27750: return (-1);
27751: /*
27752: * WARNING: Change the start value if adding to the
27753: * xmlSchemaValidOption.
27754: * TODO: Is there an other, more easy to maintain,
27755: * way?
27756: */
27757: for (i = 1; i < (int) sizeof(int) * 8; i++) {
27758: if (options & 1<<i)
27759: return (-1);
27760: }
27761: ctxt->options = options;
27762: return (0);
27763: }
27764:
27765: /**
27766: * xmlSchemaValidCtxtGetOptions:
27767: * @ctxt: a schema validation context
27768: *
27769: * Get the validation context options.
27770: *
27771: * Returns the option combination or -1 on error.
27772: */
27773: int
27774: xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt)
27775:
27776: {
27777: if (ctxt == NULL)
27778: return (-1);
27779: else
27780: return (ctxt->options);
27781: }
27782:
27783: static int
27784: xmlSchemaVDocWalk(xmlSchemaValidCtxtPtr vctxt)
27785: {
27786: xmlAttrPtr attr;
27787: int ret = 0;
27788: xmlSchemaNodeInfoPtr ielem = NULL;
27789: xmlNodePtr node, valRoot;
27790: const xmlChar *nsName;
27791:
27792: /* DOC VAL TODO: Move this to the start function. */
27793: valRoot = xmlDocGetRootElement(vctxt->doc);
27794: if (valRoot == NULL) {
27795: /* VAL TODO: Error code? */
27796: VERROR(1, NULL, "The document has no document element");
27797: return (1);
27798: }
27799: vctxt->depth = -1;
27800: vctxt->validationRoot = valRoot;
27801: node = valRoot;
27802: while (node != NULL) {
27803: if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
27804: goto next_sibling;
27805: if (node->type == XML_ELEMENT_NODE) {
27806:
27807: /*
27808: * Init the node-info.
27809: */
27810: vctxt->depth++;
27811: if (xmlSchemaValidatorPushElem(vctxt) == -1)
27812: goto internal_error;
27813: ielem = vctxt->inode;
27814: ielem->node = node;
27815: ielem->nodeLine = node->line;
27816: ielem->localName = node->name;
27817: if (node->ns != NULL)
27818: ielem->nsName = node->ns->href;
27819: ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
27820: /*
27821: * Register attributes.
27822: * DOC VAL TODO: We do not register namespace declaration
27823: * attributes yet.
27824: */
27825: vctxt->nbAttrInfos = 0;
27826: if (node->properties != NULL) {
27827: attr = node->properties;
27828: do {
27829: if (attr->ns != NULL)
27830: nsName = attr->ns->href;
27831: else
27832: nsName = NULL;
27833: ret = xmlSchemaValidatorPushAttribute(vctxt,
27834: (xmlNodePtr) attr,
27835: /*
27836: * Note that we give it the line number of the
27837: * parent element.
27838: */
27839: ielem->nodeLine,
27840: attr->name, nsName, 0,
27841: xmlNodeListGetString(attr->doc, attr->children, 1), 1);
27842: if (ret == -1) {
27843: VERROR_INT("xmlSchemaDocWalk",
27844: "calling xmlSchemaValidatorPushAttribute()");
27845: goto internal_error;
27846: }
27847: attr = attr->next;
27848: } while (attr);
27849: }
27850: /*
27851: * Validate the element.
27852: */
27853: ret = xmlSchemaValidateElem(vctxt);
27854: if (ret != 0) {
27855: if (ret == -1) {
27856: VERROR_INT("xmlSchemaDocWalk",
27857: "calling xmlSchemaValidateElem()");
27858: goto internal_error;
27859: }
27860: /*
27861: * Don't stop validation; just skip the content
27862: * of this element.
27863: */
27864: goto leave_node;
27865: }
27866: if ((vctxt->skipDepth != -1) &&
27867: (vctxt->depth >= vctxt->skipDepth))
27868: goto leave_node;
27869: } else if ((node->type == XML_TEXT_NODE) ||
27870: (node->type == XML_CDATA_SECTION_NODE)) {
27871: /*
27872: * Process character content.
27873: */
27874: if ((ielem != NULL) && (ielem->flags & XML_SCHEMA_ELEM_INFO_EMPTY))
27875: ielem->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
27876: ret = xmlSchemaVPushText(vctxt, node->type, node->content,
27877: -1, XML_SCHEMA_PUSH_TEXT_PERSIST, NULL);
27878: if (ret < 0) {
27879: VERROR_INT("xmlSchemaVDocWalk",
27880: "calling xmlSchemaVPushText()");
27881: goto internal_error;
27882: }
27883: /*
27884: * DOC VAL TODO: Should we skip further validation of the
27885: * element content here?
27886: */
27887: } else if ((node->type == XML_ENTITY_NODE) ||
27888: (node->type == XML_ENTITY_REF_NODE)) {
27889: /*
27890: * DOC VAL TODO: What to do with entities?
27891: */
27892: VERROR_INT("xmlSchemaVDocWalk",
27893: "there is at least one entity reference in the node-tree "
27894: "currently being validated. Processing of entities with "
27895: "this XML Schema processor is not supported (yet). Please "
27896: "substitute entities before validation.");
27897: goto internal_error;
27898: } else {
27899: goto leave_node;
27900: /*
27901: * DOC VAL TODO: XInclude nodes, etc.
27902: */
27903: }
27904: /*
27905: * Walk the doc.
27906: */
27907: if (node->children != NULL) {
27908: node = node->children;
27909: continue;
27910: }
27911: leave_node:
27912: if (node->type == XML_ELEMENT_NODE) {
27913: /*
27914: * Leaving the scope of an element.
27915: */
27916: if (node != vctxt->inode->node) {
27917: VERROR_INT("xmlSchemaVDocWalk",
27918: "element position mismatch");
27919: goto internal_error;
27920: }
27921: ret = xmlSchemaValidatorPopElem(vctxt);
27922: if (ret != 0) {
27923: if (ret < 0) {
27924: VERROR_INT("xmlSchemaVDocWalk",
27925: "calling xmlSchemaValidatorPopElem()");
27926: goto internal_error;
27927: }
27928: }
27929: if (node == valRoot)
27930: goto exit;
27931: }
27932: next_sibling:
27933: if (node->next != NULL)
27934: node = node->next;
27935: else {
27936: node = node->parent;
27937: goto leave_node;
27938: }
27939: }
27940:
27941: exit:
27942: return (ret);
27943: internal_error:
27944: return (-1);
27945: }
27946:
27947: static int
27948: xmlSchemaPreRun(xmlSchemaValidCtxtPtr vctxt) {
27949: /*
27950: * Some initialization.
27951: */
27952: vctxt->err = 0;
27953: vctxt->nberrors = 0;
27954: vctxt->depth = -1;
27955: vctxt->skipDepth = -1;
27956: vctxt->xsiAssemble = 0;
27957: vctxt->hasKeyrefs = 0;
27958: #ifdef ENABLE_IDC_NODE_TABLES_TEST
27959: vctxt->createIDCNodeTables = 1;
27960: #else
27961: vctxt->createIDCNodeTables = 0;
27962: #endif
27963: /*
27964: * Create a schema + parser if necessary.
27965: */
27966: if (vctxt->schema == NULL) {
27967: xmlSchemaParserCtxtPtr pctxt;
27968:
27969: vctxt->xsiAssemble = 1;
27970: /*
27971: * If not schema was given then we will create a schema
27972: * dynamically using XSI schema locations.
27973: *
27974: * Create the schema parser context.
27975: */
27976: if ((vctxt->pctxt == NULL) &&
27977: (xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1))
27978: return (-1);
27979: pctxt = vctxt->pctxt;
27980: pctxt->xsiAssemble = 1;
27981: /*
27982: * Create the schema.
27983: */
27984: vctxt->schema = xmlSchemaNewSchema(pctxt);
27985: if (vctxt->schema == NULL)
27986: return (-1);
27987: /*
27988: * Create the schema construction context.
27989: */
27990: pctxt->constructor = xmlSchemaConstructionCtxtCreate(pctxt->dict);
27991: if (pctxt->constructor == NULL)
27992: return(-1);
27993: pctxt->constructor->mainSchema = vctxt->schema;
27994: /*
27995: * Take ownership of the constructor to be able to free it.
27996: */
27997: pctxt->ownsConstructor = 1;
27998: }
27999: /*
28000: * Augment the IDC definitions for the main schema and all imported ones
28001: * NOTE: main schema if the first in the imported list
28002: */
28003: xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
28004:
28005: return(0);
28006: }
28007:
28008: static void
28009: xmlSchemaPostRun(xmlSchemaValidCtxtPtr vctxt) {
28010: if (vctxt->xsiAssemble) {
28011: if (vctxt->schema != NULL) {
28012: xmlSchemaFree(vctxt->schema);
28013: vctxt->schema = NULL;
28014: }
28015: }
28016: xmlSchemaClearValidCtxt(vctxt);
28017: }
28018:
28019: static int
28020: xmlSchemaVStart(xmlSchemaValidCtxtPtr vctxt)
28021: {
28022: int ret = 0;
28023:
28024: if (xmlSchemaPreRun(vctxt) < 0)
28025: return(-1);
28026:
28027: if (vctxt->doc != NULL) {
28028: /*
28029: * Tree validation.
28030: */
28031: ret = xmlSchemaVDocWalk(vctxt);
28032: #ifdef LIBXML_READER_ENABLED
28033: } else if (vctxt->reader != NULL) {
28034: /*
28035: * XML Reader validation.
28036: */
28037: #ifdef XML_SCHEMA_READER_ENABLED
28038: ret = xmlSchemaVReaderWalk(vctxt);
28039: #endif
28040: #endif
28041: } else if ((vctxt->sax != NULL) && (vctxt->parserCtxt != NULL)) {
28042: /*
28043: * SAX validation.
28044: */
28045: ret = xmlParseDocument(vctxt->parserCtxt);
28046: } else {
28047: VERROR_INT("xmlSchemaVStart",
28048: "no instance to validate");
28049: ret = -1;
28050: }
28051:
28052: xmlSchemaPostRun(vctxt);
28053: if (ret == 0)
28054: ret = vctxt->err;
28055: return (ret);
28056: }
28057:
28058: /**
28059: * xmlSchemaValidateOneElement:
28060: * @ctxt: a schema validation context
28061: * @elem: an element node
28062: *
28063: * Validate a branch of a tree, starting with the given @elem.
28064: *
28065: * Returns 0 if the element and its subtree is valid, a positive error
28066: * code number otherwise and -1 in case of an internal or API error.
28067: */
28068: int
28069: xmlSchemaValidateOneElement(xmlSchemaValidCtxtPtr ctxt, xmlNodePtr elem)
28070: {
28071: if ((ctxt == NULL) || (elem == NULL) || (elem->type != XML_ELEMENT_NODE))
28072: return (-1);
28073:
28074: if (ctxt->schema == NULL)
28075: return (-1);
28076:
28077: ctxt->doc = elem->doc;
28078: ctxt->node = elem;
28079: ctxt->validationRoot = elem;
28080: return(xmlSchemaVStart(ctxt));
28081: }
28082:
28083: /**
28084: * xmlSchemaValidateDoc:
28085: * @ctxt: a schema validation context
28086: * @doc: a parsed document tree
28087: *
28088: * Validate a document tree in memory.
28089: *
28090: * Returns 0 if the document is schemas valid, a positive error code
28091: * number otherwise and -1 in case of internal or API error.
28092: */
28093: int
28094: xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt, xmlDocPtr doc)
28095: {
28096: if ((ctxt == NULL) || (doc == NULL))
28097: return (-1);
28098:
28099: ctxt->doc = doc;
28100: ctxt->node = xmlDocGetRootElement(doc);
28101: if (ctxt->node == NULL) {
28102: xmlSchemaCustomErr(ACTXT_CAST ctxt,
28103: XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
28104: (xmlNodePtr) doc, NULL,
28105: "The document has no document element", NULL, NULL);
28106: return (ctxt->err);
28107: }
28108: ctxt->validationRoot = ctxt->node;
28109: return (xmlSchemaVStart(ctxt));
28110: }
28111:
28112:
28113: /************************************************************************
28114: * *
28115: * Function and data for SAX streaming API *
28116: * *
28117: ************************************************************************/
28118: typedef struct _xmlSchemaSplitSAXData xmlSchemaSplitSAXData;
28119: typedef xmlSchemaSplitSAXData *xmlSchemaSplitSAXDataPtr;
28120:
28121: struct _xmlSchemaSplitSAXData {
28122: xmlSAXHandlerPtr user_sax;
28123: void *user_data;
28124: xmlSchemaValidCtxtPtr ctxt;
28125: xmlSAXHandlerPtr schemas_sax;
28126: };
28127:
28128: #define XML_SAX_PLUG_MAGIC 0xdc43ba21
28129:
28130: struct _xmlSchemaSAXPlug {
28131: unsigned int magic;
28132:
28133: /* the original callbacks informations */
28134: xmlSAXHandlerPtr *user_sax_ptr;
28135: xmlSAXHandlerPtr user_sax;
28136: void **user_data_ptr;
28137: void *user_data;
28138:
28139: /* the block plugged back and validation informations */
28140: xmlSAXHandler schemas_sax;
28141: xmlSchemaValidCtxtPtr ctxt;
28142: };
28143:
28144: /* All those functions just bounces to the user provided SAX handlers */
28145: static void
28146: internalSubsetSplit(void *ctx, const xmlChar *name,
28147: const xmlChar *ExternalID, const xmlChar *SystemID)
28148: {
28149: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28150: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28151: (ctxt->user_sax->internalSubset != NULL))
28152: ctxt->user_sax->internalSubset(ctxt->user_data, name, ExternalID,
28153: SystemID);
28154: }
28155:
28156: static int
28157: isStandaloneSplit(void *ctx)
28158: {
28159: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28160: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28161: (ctxt->user_sax->isStandalone != NULL))
28162: return(ctxt->user_sax->isStandalone(ctxt->user_data));
28163: return(0);
28164: }
28165:
28166: static int
28167: hasInternalSubsetSplit(void *ctx)
28168: {
28169: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28170: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28171: (ctxt->user_sax->hasInternalSubset != NULL))
28172: return(ctxt->user_sax->hasInternalSubset(ctxt->user_data));
28173: return(0);
28174: }
28175:
28176: static int
28177: hasExternalSubsetSplit(void *ctx)
28178: {
28179: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28180: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28181: (ctxt->user_sax->hasExternalSubset != NULL))
28182: return(ctxt->user_sax->hasExternalSubset(ctxt->user_data));
28183: return(0);
28184: }
28185:
28186: static void
28187: externalSubsetSplit(void *ctx, const xmlChar *name,
28188: const xmlChar *ExternalID, const xmlChar *SystemID)
28189: {
28190: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28191: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28192: (ctxt->user_sax->externalSubset != NULL))
28193: ctxt->user_sax->externalSubset(ctxt->user_data, name, ExternalID,
28194: SystemID);
28195: }
28196:
28197: static xmlParserInputPtr
28198: resolveEntitySplit(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
28199: {
28200: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28201: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28202: (ctxt->user_sax->resolveEntity != NULL))
28203: return(ctxt->user_sax->resolveEntity(ctxt->user_data, publicId,
28204: systemId));
28205: return(NULL);
28206: }
28207:
28208: static xmlEntityPtr
28209: getEntitySplit(void *ctx, const xmlChar *name)
28210: {
28211: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28212: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28213: (ctxt->user_sax->getEntity != NULL))
28214: return(ctxt->user_sax->getEntity(ctxt->user_data, name));
28215: return(NULL);
28216: }
28217:
28218: static xmlEntityPtr
28219: getParameterEntitySplit(void *ctx, const xmlChar *name)
28220: {
28221: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28222: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28223: (ctxt->user_sax->getParameterEntity != NULL))
28224: return(ctxt->user_sax->getParameterEntity(ctxt->user_data, name));
28225: return(NULL);
28226: }
28227:
28228:
28229: static void
28230: entityDeclSplit(void *ctx, const xmlChar *name, int type,
28231: const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
28232: {
28233: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28234: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28235: (ctxt->user_sax->entityDecl != NULL))
28236: ctxt->user_sax->entityDecl(ctxt->user_data, name, type, publicId,
28237: systemId, content);
28238: }
28239:
28240: static void
28241: attributeDeclSplit(void *ctx, const xmlChar * elem,
28242: const xmlChar * name, int type, int def,
28243: const xmlChar * defaultValue, xmlEnumerationPtr tree)
28244: {
28245: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28246: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28247: (ctxt->user_sax->attributeDecl != NULL)) {
28248: ctxt->user_sax->attributeDecl(ctxt->user_data, elem, name, type,
28249: def, defaultValue, tree);
28250: } else {
28251: xmlFreeEnumeration(tree);
28252: }
28253: }
28254:
28255: static void
28256: elementDeclSplit(void *ctx, const xmlChar *name, int type,
28257: xmlElementContentPtr content)
28258: {
28259: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28260: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28261: (ctxt->user_sax->elementDecl != NULL))
28262: ctxt->user_sax->elementDecl(ctxt->user_data, name, type, content);
28263: }
28264:
28265: static void
28266: notationDeclSplit(void *ctx, const xmlChar *name,
28267: const xmlChar *publicId, const xmlChar *systemId)
28268: {
28269: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28270: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28271: (ctxt->user_sax->notationDecl != NULL))
28272: ctxt->user_sax->notationDecl(ctxt->user_data, name, publicId,
28273: systemId);
28274: }
28275:
28276: static void
28277: unparsedEntityDeclSplit(void *ctx, const xmlChar *name,
28278: const xmlChar *publicId, const xmlChar *systemId,
28279: const xmlChar *notationName)
28280: {
28281: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28282: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28283: (ctxt->user_sax->unparsedEntityDecl != NULL))
28284: ctxt->user_sax->unparsedEntityDecl(ctxt->user_data, name, publicId,
28285: systemId, notationName);
28286: }
28287:
28288: static void
28289: setDocumentLocatorSplit(void *ctx, xmlSAXLocatorPtr loc)
28290: {
28291: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28292: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28293: (ctxt->user_sax->setDocumentLocator != NULL))
28294: ctxt->user_sax->setDocumentLocator(ctxt->user_data, loc);
28295: }
28296:
28297: static void
28298: startDocumentSplit(void *ctx)
28299: {
28300: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28301: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28302: (ctxt->user_sax->startDocument != NULL))
28303: ctxt->user_sax->startDocument(ctxt->user_data);
28304: }
28305:
28306: static void
28307: endDocumentSplit(void *ctx)
28308: {
28309: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28310: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28311: (ctxt->user_sax->endDocument != NULL))
28312: ctxt->user_sax->endDocument(ctxt->user_data);
28313: }
28314:
28315: static void
28316: processingInstructionSplit(void *ctx, const xmlChar *target,
28317: const xmlChar *data)
28318: {
28319: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28320: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28321: (ctxt->user_sax->processingInstruction != NULL))
28322: ctxt->user_sax->processingInstruction(ctxt->user_data, target, data);
28323: }
28324:
28325: static void
28326: commentSplit(void *ctx, const xmlChar *value)
28327: {
28328: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28329: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28330: (ctxt->user_sax->comment != NULL))
28331: ctxt->user_sax->comment(ctxt->user_data, value);
28332: }
28333:
28334: /*
28335: * Varargs error callbacks to the user application, harder ...
28336: */
28337:
28338: static void XMLCDECL
28339: warningSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
28340: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28341: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28342: (ctxt->user_sax->warning != NULL)) {
28343: TODO
28344: }
28345: }
28346: static void XMLCDECL
28347: errorSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
28348: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28349: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28350: (ctxt->user_sax->error != NULL)) {
28351: TODO
28352: }
28353: }
28354: static void XMLCDECL
28355: fatalErrorSplit(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...) {
28356: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28357: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28358: (ctxt->user_sax->fatalError != NULL)) {
28359: TODO
28360: }
28361: }
28362:
28363: /*
28364: * Those are function where both the user handler and the schemas handler
28365: * need to be called.
28366: */
28367: static void
28368: charactersSplit(void *ctx, const xmlChar *ch, int len)
28369: {
28370: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28371: if (ctxt == NULL)
28372: return;
28373: if ((ctxt->user_sax != NULL) && (ctxt->user_sax->characters != NULL))
28374: ctxt->user_sax->characters(ctxt->user_data, ch, len);
28375: if (ctxt->ctxt != NULL)
28376: xmlSchemaSAXHandleText(ctxt->ctxt, ch, len);
28377: }
28378:
28379: static void
28380: ignorableWhitespaceSplit(void *ctx, const xmlChar *ch, int len)
28381: {
28382: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28383: if (ctxt == NULL)
28384: return;
28385: if ((ctxt->user_sax != NULL) &&
28386: (ctxt->user_sax->ignorableWhitespace != NULL))
28387: ctxt->user_sax->ignorableWhitespace(ctxt->user_data, ch, len);
28388: if (ctxt->ctxt != NULL)
28389: xmlSchemaSAXHandleText(ctxt->ctxt, ch, len);
28390: }
28391:
28392: static void
28393: cdataBlockSplit(void *ctx, const xmlChar *value, int len)
28394: {
28395: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28396: if (ctxt == NULL)
28397: return;
28398: if ((ctxt->user_sax != NULL) &&
28399: (ctxt->user_sax->cdataBlock != NULL))
28400: ctxt->user_sax->cdataBlock(ctxt->user_data, value, len);
28401: if (ctxt->ctxt != NULL)
28402: xmlSchemaSAXHandleCDataSection(ctxt->ctxt, value, len);
28403: }
28404:
28405: static void
28406: referenceSplit(void *ctx, const xmlChar *name)
28407: {
28408: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28409: if (ctxt == NULL)
28410: return;
28411: if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
28412: (ctxt->user_sax->reference != NULL))
28413: ctxt->user_sax->reference(ctxt->user_data, name);
28414: if (ctxt->ctxt != NULL)
28415: xmlSchemaSAXHandleReference(ctxt->user_data, name);
28416: }
28417:
28418: static void
28419: startElementNsSplit(void *ctx, const xmlChar * localname,
28420: const xmlChar * prefix, const xmlChar * URI,
28421: int nb_namespaces, const xmlChar ** namespaces,
28422: int nb_attributes, int nb_defaulted,
28423: const xmlChar ** attributes) {
28424: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28425: if (ctxt == NULL)
28426: return;
28427: if ((ctxt->user_sax != NULL) &&
28428: (ctxt->user_sax->startElementNs != NULL))
28429: ctxt->user_sax->startElementNs(ctxt->user_data, localname, prefix,
28430: URI, nb_namespaces, namespaces,
28431: nb_attributes, nb_defaulted,
28432: attributes);
28433: if (ctxt->ctxt != NULL)
28434: xmlSchemaSAXHandleStartElementNs(ctxt->ctxt, localname, prefix,
28435: URI, nb_namespaces, namespaces,
28436: nb_attributes, nb_defaulted,
28437: attributes);
28438: }
28439:
28440: static void
28441: endElementNsSplit(void *ctx, const xmlChar * localname,
28442: const xmlChar * prefix, const xmlChar * URI) {
28443: xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
28444: if (ctxt == NULL)
28445: return;
28446: if ((ctxt->user_sax != NULL) &&
28447: (ctxt->user_sax->endElementNs != NULL))
28448: ctxt->user_sax->endElementNs(ctxt->user_data, localname, prefix, URI);
28449: if (ctxt->ctxt != NULL)
28450: xmlSchemaSAXHandleEndElementNs(ctxt->ctxt, localname, prefix, URI);
28451: }
28452:
28453: /**
28454: * xmlSchemaSAXPlug:
28455: * @ctxt: a schema validation context
28456: * @sax: a pointer to the original xmlSAXHandlerPtr
28457: * @user_data: a pointer to the original SAX user data pointer
28458: *
28459: * Plug a SAX based validation layer in a SAX parsing event flow.
28460: * The original @saxptr and @dataptr data are replaced by new pointers
28461: * but the calls to the original will be maintained.
28462: *
28463: * Returns a pointer to a data structure needed to unplug the validation layer
28464: * or NULL in case of errors.
28465: */
28466: xmlSchemaSAXPlugPtr
28467: xmlSchemaSAXPlug(xmlSchemaValidCtxtPtr ctxt,
28468: xmlSAXHandlerPtr *sax, void **user_data)
28469: {
28470: xmlSchemaSAXPlugPtr ret;
28471: xmlSAXHandlerPtr old_sax;
28472:
28473: if ((ctxt == NULL) || (sax == NULL) || (user_data == NULL))
28474: return(NULL);
28475:
28476: /*
28477: * We only allow to plug into SAX2 event streams
28478: */
28479: old_sax = *sax;
28480: if ((old_sax != NULL) && (old_sax->initialized != XML_SAX2_MAGIC))
28481: return(NULL);
28482: if ((old_sax != NULL) &&
28483: (old_sax->startElementNs == NULL) && (old_sax->endElementNs == NULL) &&
28484: ((old_sax->startElement != NULL) || (old_sax->endElement != NULL)))
28485: return(NULL);
28486:
28487: /*
28488: * everything seems right allocate the local data needed for that layer
28489: */
28490: ret = (xmlSchemaSAXPlugPtr) xmlMalloc(sizeof(xmlSchemaSAXPlugStruct));
28491: if (ret == NULL) {
28492: return(NULL);
28493: }
28494: memset(ret, 0, sizeof(xmlSchemaSAXPlugStruct));
28495: ret->magic = XML_SAX_PLUG_MAGIC;
28496: ret->schemas_sax.initialized = XML_SAX2_MAGIC;
28497: ret->ctxt = ctxt;
28498: ret->user_sax_ptr = sax;
28499: ret->user_sax = old_sax;
28500: if (old_sax == NULL) {
28501: /*
28502: * go direct, no need for the split block and functions.
28503: */
28504: ret->schemas_sax.startElementNs = xmlSchemaSAXHandleStartElementNs;
28505: ret->schemas_sax.endElementNs = xmlSchemaSAXHandleEndElementNs;
28506: /*
28507: * Note that we use the same text-function for both, to prevent
28508: * the parser from testing for ignorable whitespace.
28509: */
28510: ret->schemas_sax.ignorableWhitespace = xmlSchemaSAXHandleText;
28511: ret->schemas_sax.characters = xmlSchemaSAXHandleText;
28512:
28513: ret->schemas_sax.cdataBlock = xmlSchemaSAXHandleCDataSection;
28514: ret->schemas_sax.reference = xmlSchemaSAXHandleReference;
28515:
28516: ret->user_data = ctxt;
28517: *user_data = ctxt;
28518: } else {
28519: /*
28520: * for each callback unused by Schemas initialize it to the Split
28521: * routine only if non NULL in the user block, this can speed up
28522: * things at the SAX level.
28523: */
28524: if (old_sax->internalSubset != NULL)
28525: ret->schemas_sax.internalSubset = internalSubsetSplit;
28526: if (old_sax->isStandalone != NULL)
28527: ret->schemas_sax.isStandalone = isStandaloneSplit;
28528: if (old_sax->hasInternalSubset != NULL)
28529: ret->schemas_sax.hasInternalSubset = hasInternalSubsetSplit;
28530: if (old_sax->hasExternalSubset != NULL)
28531: ret->schemas_sax.hasExternalSubset = hasExternalSubsetSplit;
28532: if (old_sax->resolveEntity != NULL)
28533: ret->schemas_sax.resolveEntity = resolveEntitySplit;
28534: if (old_sax->getEntity != NULL)
28535: ret->schemas_sax.getEntity = getEntitySplit;
28536: if (old_sax->entityDecl != NULL)
28537: ret->schemas_sax.entityDecl = entityDeclSplit;
28538: if (old_sax->notationDecl != NULL)
28539: ret->schemas_sax.notationDecl = notationDeclSplit;
28540: if (old_sax->attributeDecl != NULL)
28541: ret->schemas_sax.attributeDecl = attributeDeclSplit;
28542: if (old_sax->elementDecl != NULL)
28543: ret->schemas_sax.elementDecl = elementDeclSplit;
28544: if (old_sax->unparsedEntityDecl != NULL)
28545: ret->schemas_sax.unparsedEntityDecl = unparsedEntityDeclSplit;
28546: if (old_sax->setDocumentLocator != NULL)
28547: ret->schemas_sax.setDocumentLocator = setDocumentLocatorSplit;
28548: if (old_sax->startDocument != NULL)
28549: ret->schemas_sax.startDocument = startDocumentSplit;
28550: if (old_sax->endDocument != NULL)
28551: ret->schemas_sax.endDocument = endDocumentSplit;
28552: if (old_sax->processingInstruction != NULL)
28553: ret->schemas_sax.processingInstruction = processingInstructionSplit;
28554: if (old_sax->comment != NULL)
28555: ret->schemas_sax.comment = commentSplit;
28556: if (old_sax->warning != NULL)
28557: ret->schemas_sax.warning = warningSplit;
28558: if (old_sax->error != NULL)
28559: ret->schemas_sax.error = errorSplit;
28560: if (old_sax->fatalError != NULL)
28561: ret->schemas_sax.fatalError = fatalErrorSplit;
28562: if (old_sax->getParameterEntity != NULL)
28563: ret->schemas_sax.getParameterEntity = getParameterEntitySplit;
28564: if (old_sax->externalSubset != NULL)
28565: ret->schemas_sax.externalSubset = externalSubsetSplit;
28566:
28567: /*
28568: * the 6 schemas callback have to go to the splitter functions
28569: * Note that we use the same text-function for ignorableWhitespace
28570: * if possible, to prevent the parser from testing for ignorable
28571: * whitespace.
28572: */
28573: ret->schemas_sax.characters = charactersSplit;
28574: if ((old_sax->ignorableWhitespace != NULL) &&
28575: (old_sax->ignorableWhitespace != old_sax->characters))
28576: ret->schemas_sax.ignorableWhitespace = ignorableWhitespaceSplit;
28577: else
28578: ret->schemas_sax.ignorableWhitespace = charactersSplit;
28579: ret->schemas_sax.cdataBlock = cdataBlockSplit;
28580: ret->schemas_sax.reference = referenceSplit;
28581: ret->schemas_sax.startElementNs = startElementNsSplit;
28582: ret->schemas_sax.endElementNs = endElementNsSplit;
28583:
28584: ret->user_data_ptr = user_data;
28585: ret->user_data = *user_data;
28586: *user_data = ret;
28587: }
28588:
28589: /*
28590: * plug the pointers back.
28591: */
28592: *sax = &(ret->schemas_sax);
28593: ctxt->sax = *sax;
28594: ctxt->flags |= XML_SCHEMA_VALID_CTXT_FLAG_STREAM;
28595: xmlSchemaPreRun(ctxt);
28596: return(ret);
28597: }
28598:
28599: /**
28600: * xmlSchemaSAXUnplug:
28601: * @plug: a data structure returned by xmlSchemaSAXPlug
28602: *
28603: * Unplug a SAX based validation layer in a SAX parsing event flow.
28604: * The original pointers used in the call are restored.
28605: *
28606: * Returns 0 in case of success and -1 in case of failure.
28607: */
28608: int
28609: xmlSchemaSAXUnplug(xmlSchemaSAXPlugPtr plug)
28610: {
28611: xmlSAXHandlerPtr *sax;
28612: void **user_data;
28613:
28614: if ((plug == NULL) || (plug->magic != XML_SAX_PLUG_MAGIC))
28615: return(-1);
28616: plug->magic = 0;
28617:
28618: xmlSchemaPostRun(plug->ctxt);
28619: /* restore the data */
28620: sax = plug->user_sax_ptr;
28621: *sax = plug->user_sax;
28622: if (plug->user_sax != NULL) {
28623: user_data = plug->user_data_ptr;
28624: *user_data = plug->user_data;
28625: }
28626:
28627: /* free and return */
28628: xmlFree(plug);
28629: return(0);
28630: }
28631:
28632: /**
28633: * xmlSchemaValidateStream:
28634: * @ctxt: a schema validation context
28635: * @input: the input to use for reading the data
28636: * @enc: an optional encoding information
28637: * @sax: a SAX handler for the resulting events
28638: * @user_data: the context to provide to the SAX handler.
28639: *
28640: * Validate an input based on a flow of SAX event from the parser
28641: * and forward the events to the @sax handler with the provided @user_data
28642: * the user provided @sax handler must be a SAX2 one.
28643: *
28644: * Returns 0 if the document is schemas valid, a positive error code
28645: * number otherwise and -1 in case of internal or API error.
28646: */
28647: int
28648: xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt,
28649: xmlParserInputBufferPtr input, xmlCharEncoding enc,
28650: xmlSAXHandlerPtr sax, void *user_data)
28651: {
28652: xmlSchemaSAXPlugPtr plug = NULL;
28653: xmlSAXHandlerPtr old_sax = NULL;
28654: xmlParserCtxtPtr pctxt = NULL;
28655: xmlParserInputPtr inputStream = NULL;
28656: int ret;
28657:
28658: if ((ctxt == NULL) || (input == NULL))
28659: return (-1);
28660:
28661: /*
28662: * prepare the parser
28663: */
28664: pctxt = xmlNewParserCtxt();
28665: if (pctxt == NULL)
28666: return (-1);
28667: old_sax = pctxt->sax;
28668: pctxt->sax = sax;
28669: pctxt->userData = user_data;
28670: #if 0
28671: if (options)
28672: xmlCtxtUseOptions(pctxt, options);
28673: #endif
28674: pctxt->linenumbers = 1;
28675:
28676: inputStream = xmlNewIOInputStream(pctxt, input, enc);;
28677: if (inputStream == NULL) {
28678: ret = -1;
28679: goto done;
28680: }
28681: inputPush(pctxt, inputStream);
28682: ctxt->parserCtxt = pctxt;
28683: ctxt->input = input;
28684:
28685: /*
28686: * Plug the validation and launch the parsing
28687: */
28688: plug = xmlSchemaSAXPlug(ctxt, &(pctxt->sax), &(pctxt->userData));
28689: if (plug == NULL) {
28690: ret = -1;
28691: goto done;
28692: }
28693: ctxt->input = input;
28694: ctxt->enc = enc;
28695: ctxt->sax = pctxt->sax;
28696: ctxt->flags |= XML_SCHEMA_VALID_CTXT_FLAG_STREAM;
28697: ret = xmlSchemaVStart(ctxt);
28698:
28699: if ((ret == 0) && (! ctxt->parserCtxt->wellFormed)) {
28700: ret = ctxt->parserCtxt->errNo;
28701: if (ret == 0)
28702: ret = 1;
28703: }
28704:
28705: done:
28706: ctxt->parserCtxt = NULL;
28707: ctxt->sax = NULL;
28708: ctxt->input = NULL;
28709: if (plug != NULL) {
28710: xmlSchemaSAXUnplug(plug);
28711: }
28712: /* cleanup */
28713: if (pctxt != NULL) {
28714: pctxt->sax = old_sax;
28715: xmlFreeParserCtxt(pctxt);
28716: }
28717: return (ret);
28718: }
28719:
28720: /**
28721: * xmlSchemaValidateFile:
28722: * @ctxt: a schema validation context
28723: * @filename: the URI of the instance
28724: * @options: a future set of options, currently unused
28725: *
28726: * Do a schemas validation of the given resource, it will use the
28727: * SAX streamable validation internally.
28728: *
28729: * Returns 0 if the document is valid, a positive error code
28730: * number otherwise and -1 in case of an internal or API error.
28731: */
28732: int
28733: xmlSchemaValidateFile(xmlSchemaValidCtxtPtr ctxt,
28734: const char * filename,
28735: int options ATTRIBUTE_UNUSED)
28736: {
28737: int ret;
28738: xmlParserInputBufferPtr input;
28739:
28740: if ((ctxt == NULL) || (filename == NULL))
28741: return (-1);
28742:
28743: input = xmlParserInputBufferCreateFilename(filename,
28744: XML_CHAR_ENCODING_NONE);
28745: if (input == NULL)
28746: return (-1);
28747: ret = xmlSchemaValidateStream(ctxt, input, XML_CHAR_ENCODING_NONE,
28748: NULL, NULL);
28749: return (ret);
28750: }
28751:
28752: /**
28753: * xmlSchemaValidCtxtGetParserCtxt:
28754: * @ctxt: a schema validation context
28755: *
28756: * allow access to the parser context of the schema validation context
28757: *
28758: * Returns the parser context of the schema validation context or NULL
28759: * in case of error.
28760: */
28761: xmlParserCtxtPtr
28762: xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt)
28763: {
28764: if (ctxt == NULL)
28765: return(NULL);
28766: return (ctxt->parserCtxt);
28767: }
28768:
28769: #define bottom_xmlschemas
28770: #include "elfgcchack.h"
28771: #endif /* LIBXML_SCHEMAS_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlschemas.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2