1: /*
2: * relaxng.c : implementation of the Relax-NG handling and validity checking
3: *
4: * See Copyright for the status of this software.
5: *
6: * Daniel Veillard <veillard@redhat.com>
7: */
8:
9: /**
10: * TODO:
11: * - add support for DTD compatibility spec
12: * http://www.oasis-open.org/committees/relax-ng/compatibility-20011203.html
13: * - report better mem allocations pbms at runtime and abort immediately.
14: */
15:
16: #define IN_LIBXML
17: #include "libxml.h"
18:
19: #ifdef LIBXML_SCHEMAS_ENABLED
20:
21: #include <string.h>
22: #include <stdio.h>
23: #include <libxml/xmlmemory.h>
24: #include <libxml/parser.h>
25: #include <libxml/parserInternals.h>
26: #include <libxml/hash.h>
27: #include <libxml/uri.h>
28:
29: #include <libxml/relaxng.h>
30:
31: #include <libxml/xmlschemastypes.h>
32: #include <libxml/xmlautomata.h>
33: #include <libxml/xmlregexp.h>
34: #include <libxml/xmlschemastypes.h>
35:
36: /*
37: * The Relax-NG namespace
38: */
39: static const xmlChar *xmlRelaxNGNs = (const xmlChar *)
40: "http://relaxng.org/ns/structure/1.0";
41:
42: #define IS_RELAXNG(node, typ) \
43: ((node != NULL) && (node->ns != NULL) && \
44: (node->type == XML_ELEMENT_NODE) && \
45: (xmlStrEqual(node->name, (const xmlChar *) typ)) && \
46: (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
47:
48:
49: #if 0
50: #define DEBUG 1
51:
52: #define DEBUG_GRAMMAR 1
53:
54: #define DEBUG_CONTENT 1
55:
56: #define DEBUG_TYPE 1
57:
58: #define DEBUG_VALID 1
59:
60: #define DEBUG_INTERLEAVE 1
61:
62: #define DEBUG_LIST 1
63:
64: #define DEBUG_INCLUDE 1
65:
66: #define DEBUG_ERROR 1
67:
68: #define DEBUG_COMPILE 1
69:
70: #define DEBUG_PROGRESSIVE 1
71: #endif
72:
73: #define MAX_ERROR 5
74:
75: #define TODO \
76: xmlGenericError(xmlGenericErrorContext, \
77: "Unimplemented block at %s:%d\n", \
78: __FILE__, __LINE__);
79:
80: typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema;
81: typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr;
82:
83: typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine;
84: typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr;
85:
86: typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument;
87: typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr;
88:
89: typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude;
90: typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;
91:
92: typedef enum {
93: XML_RELAXNG_COMBINE_UNDEFINED = 0, /* undefined */
94: XML_RELAXNG_COMBINE_CHOICE, /* choice */
95: XML_RELAXNG_COMBINE_INTERLEAVE /* interleave */
96: } xmlRelaxNGCombine;
97:
98: typedef enum {
99: XML_RELAXNG_CONTENT_ERROR = -1,
100: XML_RELAXNG_CONTENT_EMPTY = 0,
101: XML_RELAXNG_CONTENT_SIMPLE,
102: XML_RELAXNG_CONTENT_COMPLEX
103: } xmlRelaxNGContentType;
104:
105: typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar;
106: typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr;
107:
108: struct _xmlRelaxNGGrammar {
109: xmlRelaxNGGrammarPtr parent; /* the parent grammar if any */
110: xmlRelaxNGGrammarPtr children; /* the children grammar if any */
111: xmlRelaxNGGrammarPtr next; /* the next grammar if any */
112: xmlRelaxNGDefinePtr start; /* <start> content */
113: xmlRelaxNGCombine combine; /* the default combine value */
114: xmlRelaxNGDefinePtr startList; /* list of <start> definitions */
115: xmlHashTablePtr defs; /* define* */
116: xmlHashTablePtr refs; /* references */
117: };
118:
119:
120: typedef enum {
121: XML_RELAXNG_NOOP = -1, /* a no operation from simplification */
122: XML_RELAXNG_EMPTY = 0, /* an empty pattern */
123: XML_RELAXNG_NOT_ALLOWED, /* not allowed top */
124: XML_RELAXNG_EXCEPT, /* except present in nameclass defs */
125: XML_RELAXNG_TEXT, /* textual content */
126: XML_RELAXNG_ELEMENT, /* an element */
127: XML_RELAXNG_DATATYPE, /* extenal data type definition */
128: XML_RELAXNG_PARAM, /* extenal data type parameter */
129: XML_RELAXNG_VALUE, /* value from an extenal data type definition */
130: XML_RELAXNG_LIST, /* a list of patterns */
131: XML_RELAXNG_ATTRIBUTE, /* an attrbute following a pattern */
132: XML_RELAXNG_DEF, /* a definition */
133: XML_RELAXNG_REF, /* reference to a definition */
134: XML_RELAXNG_EXTERNALREF, /* reference to an external def */
135: XML_RELAXNG_PARENTREF, /* reference to a def in the parent grammar */
136: XML_RELAXNG_OPTIONAL, /* optional patterns */
137: XML_RELAXNG_ZEROORMORE, /* zero or more non empty patterns */
138: XML_RELAXNG_ONEORMORE, /* one or more non empty patterns */
139: XML_RELAXNG_CHOICE, /* a choice between non empty patterns */
140: XML_RELAXNG_GROUP, /* a pair/group of non empty patterns */
141: XML_RELAXNG_INTERLEAVE, /* interleaving choice of non-empty patterns */
142: XML_RELAXNG_START /* Used to keep track of starts on grammars */
143: } xmlRelaxNGType;
144:
145: #define IS_NULLABLE (1 << 0)
146: #define IS_NOT_NULLABLE (1 << 1)
147: #define IS_INDETERMINIST (1 << 2)
148: #define IS_MIXED (1 << 3)
149: #define IS_TRIABLE (1 << 4)
150: #define IS_PROCESSED (1 << 5)
151: #define IS_COMPILABLE (1 << 6)
152: #define IS_NOT_COMPILABLE (1 << 7)
153: #define IS_EXTERNAL_REF (1 << 8)
154:
155: struct _xmlRelaxNGDefine {
156: xmlRelaxNGType type; /* the type of definition */
157: xmlNodePtr node; /* the node in the source */
158: xmlChar *name; /* the element local name if present */
159: xmlChar *ns; /* the namespace local name if present */
160: xmlChar *value; /* value when available */
161: void *data; /* data lib or specific pointer */
162: xmlRelaxNGDefinePtr content; /* the expected content */
163: xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
164: xmlRelaxNGDefinePtr next; /* list within grouping sequences */
165: xmlRelaxNGDefinePtr attrs; /* list of attributes for elements */
166: xmlRelaxNGDefinePtr nameClass; /* the nameClass definition if any */
167: xmlRelaxNGDefinePtr nextHash; /* next define in defs/refs hash tables */
168: short depth; /* used for the cycle detection */
169: short dflags; /* define related flags */
170: xmlRegexpPtr contModel; /* a compiled content model if available */
171: };
172:
173: /**
174: * _xmlRelaxNG:
175: *
176: * A RelaxNGs definition
177: */
178: struct _xmlRelaxNG {
179: void *_private; /* unused by the library for users or bindings */
180: xmlRelaxNGGrammarPtr topgrammar;
181: xmlDocPtr doc;
182:
183: int idref; /* requires idref checking */
184:
185: xmlHashTablePtr defs; /* define */
186: xmlHashTablePtr refs; /* references */
187: xmlRelaxNGDocumentPtr documents; /* all the documents loaded */
188: xmlRelaxNGIncludePtr includes; /* all the includes loaded */
189: int defNr; /* number of defines used */
190: xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */
191:
192: };
193:
194: #define XML_RELAXNG_IN_ATTRIBUTE (1 << 0)
195: #define XML_RELAXNG_IN_ONEORMORE (1 << 1)
196: #define XML_RELAXNG_IN_LIST (1 << 2)
197: #define XML_RELAXNG_IN_DATAEXCEPT (1 << 3)
198: #define XML_RELAXNG_IN_START (1 << 4)
199: #define XML_RELAXNG_IN_OOMGROUP (1 << 5)
200: #define XML_RELAXNG_IN_OOMINTERLEAVE (1 << 6)
201: #define XML_RELAXNG_IN_EXTERNALREF (1 << 7)
202: #define XML_RELAXNG_IN_ANYEXCEPT (1 << 8)
203: #define XML_RELAXNG_IN_NSEXCEPT (1 << 9)
204:
205: struct _xmlRelaxNGParserCtxt {
206: void *userData; /* user specific data block */
207: xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
208: xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
209: xmlStructuredErrorFunc serror;
210: xmlRelaxNGValidErr err;
211:
212: xmlRelaxNGPtr schema; /* The schema in use */
213: xmlRelaxNGGrammarPtr grammar; /* the current grammar */
214: xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */
215: int flags; /* parser flags */
216: int nbErrors; /* number of errors at parse time */
217: int nbWarnings; /* number of warnings at parse time */
218: const xmlChar *define; /* the current define scope */
219: xmlRelaxNGDefinePtr def; /* the current define */
220:
221: int nbInterleaves;
222: xmlHashTablePtr interleaves; /* keep track of all the interleaves */
223:
224: xmlRelaxNGDocumentPtr documents; /* all the documents loaded */
225: xmlRelaxNGIncludePtr includes; /* all the includes loaded */
226: xmlChar *URL;
227: xmlDocPtr document;
228:
229: int defNr; /* number of defines used */
230: int defMax; /* number of defines aloocated */
231: xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */
232:
233: const char *buffer;
234: int size;
235:
236: /* the document stack */
237: xmlRelaxNGDocumentPtr doc; /* Current parsed external ref */
238: int docNr; /* Depth of the parsing stack */
239: int docMax; /* Max depth of the parsing stack */
240: xmlRelaxNGDocumentPtr *docTab; /* array of docs */
241:
242: /* the include stack */
243: xmlRelaxNGIncludePtr inc; /* Current parsed include */
244: int incNr; /* Depth of the include parsing stack */
245: int incMax; /* Max depth of the parsing stack */
246: xmlRelaxNGIncludePtr *incTab; /* array of incs */
247:
248: int idref; /* requires idref checking */
249:
250: /* used to compile content models */
251: xmlAutomataPtr am; /* the automata */
252: xmlAutomataStatePtr state; /* used to build the automata */
253:
254: int crng; /* compact syntax and other flags */
255: int freedoc; /* need to free the document */
256: };
257:
258: #define FLAGS_IGNORABLE 1
259: #define FLAGS_NEGATIVE 2
260: #define FLAGS_MIXED_CONTENT 4
261: #define FLAGS_NOERROR 8
262:
263: /**
264: * xmlRelaxNGInterleaveGroup:
265: *
266: * A RelaxNGs partition set associated to lists of definitions
267: */
268: typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup;
269: typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr;
270: struct _xmlRelaxNGInterleaveGroup {
271: xmlRelaxNGDefinePtr rule; /* the rule to satisfy */
272: xmlRelaxNGDefinePtr *defs; /* the array of element definitions */
273: xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */
274: };
275:
276: #define IS_DETERMINIST 1
277: #define IS_NEEDCHECK 2
278:
279: /**
280: * xmlRelaxNGPartitions:
281: *
282: * A RelaxNGs partition associated to an interleave group
283: */
284: typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition;
285: typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr;
286: struct _xmlRelaxNGPartition {
287: int nbgroups; /* number of groups in the partitions */
288: xmlHashTablePtr triage; /* hash table used to direct nodes to the
289: * right group when possible */
290: int flags; /* determinist ? */
291: xmlRelaxNGInterleaveGroupPtr *groups;
292: };
293:
294: /**
295: * xmlRelaxNGValidState:
296: *
297: * A RelaxNGs validation state
298: */
299: #define MAX_ATTR 20
300: typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState;
301: typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr;
302: struct _xmlRelaxNGValidState {
303: xmlNodePtr node; /* the current node */
304: xmlNodePtr seq; /* the sequence of children left to validate */
305: int nbAttrs; /* the number of attributes */
306: int maxAttrs; /* the size of attrs */
307: int nbAttrLeft; /* the number of attributes left to validate */
308: xmlChar *value; /* the value when operating on string */
309: xmlChar *endvalue; /* the end value when operating on string */
310: xmlAttrPtr *attrs; /* the array of attributes */
311: };
312:
313: /**
314: * xmlRelaxNGStates:
315: *
316: * A RelaxNGs container for validation state
317: */
318: typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
319: typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
320: struct _xmlRelaxNGStates {
321: int nbState; /* the number of states */
322: int maxState; /* the size of the array */
323: xmlRelaxNGValidStatePtr *tabState;
324: };
325:
326: #define ERROR_IS_DUP 1
327:
328: /**
329: * xmlRelaxNGValidError:
330: *
331: * A RelaxNGs validation error
332: */
333: typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError;
334: typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr;
335: struct _xmlRelaxNGValidError {
336: xmlRelaxNGValidErr err; /* the error number */
337: int flags; /* flags */
338: xmlNodePtr node; /* the current node */
339: xmlNodePtr seq; /* the current child */
340: const xmlChar *arg1; /* first arg */
341: const xmlChar *arg2; /* second arg */
342: };
343:
344: /**
345: * xmlRelaxNGValidCtxt:
346: *
347: * A RelaxNGs validation context
348: */
349:
350: struct _xmlRelaxNGValidCtxt {
351: void *userData; /* user specific data block */
352: xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
353: xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
354: xmlStructuredErrorFunc serror;
355: int nbErrors; /* number of errors in validation */
356:
357: xmlRelaxNGPtr schema; /* The schema in use */
358: xmlDocPtr doc; /* the document being validated */
359: int flags; /* validation flags */
360: int depth; /* validation depth */
361: int idref; /* requires idref checking */
362: int errNo; /* the first error found */
363:
364: /*
365: * Errors accumulated in branches may have to be stacked to be
366: * provided back when it's sure they affect validation.
367: */
368: xmlRelaxNGValidErrorPtr err; /* Last error */
369: int errNr; /* Depth of the error stack */
370: int errMax; /* Max depth of the error stack */
371: xmlRelaxNGValidErrorPtr errTab; /* stack of errors */
372:
373: xmlRelaxNGValidStatePtr state; /* the current validation state */
374: xmlRelaxNGStatesPtr states; /* the accumulated state list */
375:
376: xmlRelaxNGStatesPtr freeState; /* the pool of free valid states */
377: int freeStatesNr;
378: int freeStatesMax;
379: xmlRelaxNGStatesPtr *freeStates; /* the pool of free state groups */
380:
381: /*
382: * This is used for "progressive" validation
383: */
384: xmlRegExecCtxtPtr elem; /* the current element regexp */
385: int elemNr; /* the number of element validated */
386: int elemMax; /* the max depth of elements */
387: xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */
388: int pstate; /* progressive state */
389: xmlNodePtr pnode; /* the current node */
390: xmlRelaxNGDefinePtr pdef; /* the non-streamable definition */
391: int perr; /* signal error in content model
392: * outside the regexp */
393: };
394:
395: /**
396: * xmlRelaxNGInclude:
397: *
398: * Structure associated to a RelaxNGs document element
399: */
400: struct _xmlRelaxNGInclude {
401: xmlRelaxNGIncludePtr next; /* keep a chain of includes */
402: xmlChar *href; /* the normalized href value */
403: xmlDocPtr doc; /* the associated XML document */
404: xmlRelaxNGDefinePtr content; /* the definitions */
405: xmlRelaxNGPtr schema; /* the schema */
406: };
407:
408: /**
409: * xmlRelaxNGDocument:
410: *
411: * Structure associated to a RelaxNGs document element
412: */
413: struct _xmlRelaxNGDocument {
414: xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
415: xmlChar *href; /* the normalized href value */
416: xmlDocPtr doc; /* the associated XML document */
417: xmlRelaxNGDefinePtr content; /* the definitions */
418: xmlRelaxNGPtr schema; /* the schema */
419: int externalRef; /* 1 if an external ref */
420: };
421:
422:
423: /************************************************************************
424: * *
425: * Some factorized error routines *
426: * *
427: ************************************************************************/
428:
429: /**
430: * xmlRngPErrMemory:
431: * @ctxt: an Relax-NG parser context
432: * @extra: extra informations
433: *
434: * Handle a redefinition of attribute error
435: */
436: static void
437: xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
438: {
439: xmlStructuredErrorFunc schannel = NULL;
440: xmlGenericErrorFunc channel = NULL;
441: void *data = NULL;
442:
443: if (ctxt != NULL) {
444: if (ctxt->serror != NULL)
445: schannel = ctxt->serror;
446: else
447: channel = ctxt->error;
448: data = ctxt->userData;
449: ctxt->nbErrors++;
450: }
451: if (extra)
452: __xmlRaiseError(schannel, channel, data,
453: NULL, NULL, XML_FROM_RELAXNGP,
454: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
455: NULL, NULL, 0, 0,
456: "Memory allocation failed : %s\n", extra);
457: else
458: __xmlRaiseError(schannel, channel, data,
459: NULL, NULL, XML_FROM_RELAXNGP,
460: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
461: NULL, NULL, 0, 0, "Memory allocation failed\n");
462: }
463:
464: /**
465: * xmlRngVErrMemory:
466: * @ctxt: a Relax-NG validation context
467: * @extra: extra informations
468: *
469: * Handle a redefinition of attribute error
470: */
471: static void
472: xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
473: {
474: xmlStructuredErrorFunc schannel = NULL;
475: xmlGenericErrorFunc channel = NULL;
476: void *data = NULL;
477:
478: if (ctxt != NULL) {
479: if (ctxt->serror != NULL)
480: schannel = ctxt->serror;
481: else
482: channel = ctxt->error;
483: data = ctxt->userData;
484: ctxt->nbErrors++;
485: }
486: if (extra)
487: __xmlRaiseError(schannel, channel, data,
488: NULL, NULL, XML_FROM_RELAXNGV,
489: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
490: NULL, NULL, 0, 0,
491: "Memory allocation failed : %s\n", extra);
492: else
493: __xmlRaiseError(schannel, channel, data,
494: NULL, NULL, XML_FROM_RELAXNGV,
495: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
496: NULL, NULL, 0, 0, "Memory allocation failed\n");
497: }
498:
499: /**
500: * xmlRngPErr:
501: * @ctxt: a Relax-NG parser context
502: * @node: the node raising the error
503: * @error: the error code
504: * @msg: message
505: * @str1: extra info
506: * @str2: extra info
507: *
508: * Handle a Relax NG Parsing error
509: */
510: static void
511: xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
512: const char *msg, const xmlChar * str1, const xmlChar * str2)
513: {
514: xmlStructuredErrorFunc schannel = NULL;
515: xmlGenericErrorFunc channel = NULL;
516: void *data = NULL;
517:
518: if (ctxt != NULL) {
519: if (ctxt->serror != NULL)
520: schannel = ctxt->serror;
521: else
522: channel = ctxt->error;
523: data = ctxt->userData;
524: ctxt->nbErrors++;
525: }
526: __xmlRaiseError(schannel, channel, data,
527: NULL, node, XML_FROM_RELAXNGP,
528: error, XML_ERR_ERROR, NULL, 0,
529: (const char *) str1, (const char *) str2, NULL, 0, 0,
530: msg, str1, str2);
531: }
532:
533: /**
534: * xmlRngVErr:
535: * @ctxt: a Relax-NG validation context
536: * @node: the node raising the error
537: * @error: the error code
538: * @msg: message
539: * @str1: extra info
540: * @str2: extra info
541: *
542: * Handle a Relax NG Validation error
543: */
544: static void
545: xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
546: const char *msg, const xmlChar * str1, const xmlChar * str2)
547: {
548: xmlStructuredErrorFunc schannel = NULL;
549: xmlGenericErrorFunc channel = NULL;
550: void *data = NULL;
551:
552: if (ctxt != NULL) {
553: if (ctxt->serror != NULL)
554: schannel = ctxt->serror;
555: else
556: channel = ctxt->error;
557: data = ctxt->userData;
558: ctxt->nbErrors++;
559: }
560: __xmlRaiseError(schannel, channel, data,
561: NULL, node, XML_FROM_RELAXNGV,
562: error, XML_ERR_ERROR, NULL, 0,
563: (const char *) str1, (const char *) str2, NULL, 0, 0,
564: msg, str1, str2);
565: }
566:
567: /************************************************************************
568: * *
569: * Preliminary type checking interfaces *
570: * *
571: ************************************************************************/
572:
573: /**
574: * xmlRelaxNGTypeHave:
575: * @data: data needed for the library
576: * @type: the type name
577: * @value: the value to check
578: *
579: * Function provided by a type library to check if a type is exported
580: *
581: * Returns 1 if yes, 0 if no and -1 in case of error.
582: */
583: typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);
584:
585: /**
586: * xmlRelaxNGTypeCheck:
587: * @data: data needed for the library
588: * @type: the type name
589: * @value: the value to check
590: * @result: place to store the result if needed
591: *
592: * Function provided by a type library to check if a value match a type
593: *
594: * Returns 1 if yes, 0 if no and -1 in case of error.
595: */
596: typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
597: const xmlChar * value, void **result,
598: xmlNodePtr node);
599:
600: /**
601: * xmlRelaxNGFacetCheck:
602: * @data: data needed for the library
603: * @type: the type name
604: * @facet: the facet name
605: * @val: the facet value
606: * @strval: the string value
607: * @value: the value to check
608: *
609: * Function provided by a type library to check a value facet
610: *
611: * Returns 1 if yes, 0 if no and -1 in case of error.
612: */
613: typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
614: const xmlChar * facet,
615: const xmlChar * val,
616: const xmlChar * strval, void *value);
617:
618: /**
619: * xmlRelaxNGTypeFree:
620: * @data: data needed for the library
621: * @result: the value to free
622: *
623: * Function provided by a type library to free a returned result
624: */
625: typedef void (*xmlRelaxNGTypeFree) (void *data, void *result);
626:
627: /**
628: * xmlRelaxNGTypeCompare:
629: * @data: data needed for the library
630: * @type: the type name
631: * @value1: the first value
632: * @value2: the second value
633: *
634: * Function provided by a type library to compare two values accordingly
635: * to a type.
636: *
637: * Returns 1 if yes, 0 if no and -1 in case of error.
638: */
639: typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type,
640: const xmlChar * value1,
641: xmlNodePtr ctxt1,
642: void *comp1,
643: const xmlChar * value2,
644: xmlNodePtr ctxt2);
645: typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary;
646: typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr;
647: struct _xmlRelaxNGTypeLibrary {
648: const xmlChar *namespace; /* the datatypeLibrary value */
649: void *data; /* data needed for the library */
650: xmlRelaxNGTypeHave have; /* the export function */
651: xmlRelaxNGTypeCheck check; /* the checking function */
652: xmlRelaxNGTypeCompare comp; /* the compare function */
653: xmlRelaxNGFacetCheck facet; /* the facet check function */
654: xmlRelaxNGTypeFree freef; /* the freeing function */
655: };
656:
657: /************************************************************************
658: * *
659: * Allocation functions *
660: * *
661: ************************************************************************/
662: static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
663: static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
664: static void xmlRelaxNGNormExtSpace(xmlChar * value);
665: static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
666: static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
667: ATTRIBUTE_UNUSED,
668: xmlRelaxNGValidStatePtr state1,
669: xmlRelaxNGValidStatePtr state2);
670: static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
671: xmlRelaxNGValidStatePtr state);
672:
673: /**
674: * xmlRelaxNGFreeDocument:
675: * @docu: a document structure
676: *
677: * Deallocate a RelaxNG document structure.
678: */
679: static void
680: xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
681: {
682: if (docu == NULL)
683: return;
684:
685: if (docu->href != NULL)
686: xmlFree(docu->href);
687: if (docu->doc != NULL)
688: xmlFreeDoc(docu->doc);
689: if (docu->schema != NULL)
690: xmlRelaxNGFreeInnerSchema(docu->schema);
691: xmlFree(docu);
692: }
693:
694: /**
695: * xmlRelaxNGFreeDocumentList:
696: * @docu: a list of document structure
697: *
698: * Deallocate a RelaxNG document structures.
699: */
700: static void
701: xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
702: {
703: xmlRelaxNGDocumentPtr next;
704:
705: while (docu != NULL) {
706: next = docu->next;
707: xmlRelaxNGFreeDocument(docu);
708: docu = next;
709: }
710: }
711:
712: /**
713: * xmlRelaxNGFreeInclude:
714: * @incl: a include structure
715: *
716: * Deallocate a RelaxNG include structure.
717: */
718: static void
719: xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl)
720: {
721: if (incl == NULL)
722: return;
723:
724: if (incl->href != NULL)
725: xmlFree(incl->href);
726: if (incl->doc != NULL)
727: xmlFreeDoc(incl->doc);
728: if (incl->schema != NULL)
729: xmlRelaxNGFree(incl->schema);
730: xmlFree(incl);
731: }
732:
733: /**
734: * xmlRelaxNGFreeIncludeList:
735: * @incl: a include structure list
736: *
737: * Deallocate a RelaxNG include structure.
738: */
739: static void
740: xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
741: {
742: xmlRelaxNGIncludePtr next;
743:
744: while (incl != NULL) {
745: next = incl->next;
746: xmlRelaxNGFreeInclude(incl);
747: incl = next;
748: }
749: }
750:
751: /**
752: * xmlRelaxNGNewRelaxNG:
753: * @ctxt: a Relax-NG validation context (optional)
754: *
755: * Allocate a new RelaxNG structure.
756: *
757: * Returns the newly allocated structure or NULL in case or error
758: */
759: static xmlRelaxNGPtr
760: xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
761: {
762: xmlRelaxNGPtr ret;
763:
764: ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
765: if (ret == NULL) {
766: xmlRngPErrMemory(ctxt, NULL);
767: return (NULL);
768: }
769: memset(ret, 0, sizeof(xmlRelaxNG));
770:
771: return (ret);
772: }
773:
774: /**
775: * xmlRelaxNGFreeInnerSchema:
776: * @schema: a schema structure
777: *
778: * Deallocate a RelaxNG schema structure.
779: */
780: static void
781: xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema)
782: {
783: if (schema == NULL)
784: return;
785:
786: if (schema->doc != NULL)
787: xmlFreeDoc(schema->doc);
788: if (schema->defTab != NULL) {
789: int i;
790:
791: for (i = 0; i < schema->defNr; i++)
792: xmlRelaxNGFreeDefine(schema->defTab[i]);
793: xmlFree(schema->defTab);
794: }
795:
796: xmlFree(schema);
797: }
798:
799: /**
800: * xmlRelaxNGFree:
801: * @schema: a schema structure
802: *
803: * Deallocate a RelaxNG structure.
804: */
805: void
806: xmlRelaxNGFree(xmlRelaxNGPtr schema)
807: {
808: if (schema == NULL)
809: return;
810:
811: if (schema->topgrammar != NULL)
812: xmlRelaxNGFreeGrammar(schema->topgrammar);
813: if (schema->doc != NULL)
814: xmlFreeDoc(schema->doc);
815: if (schema->documents != NULL)
816: xmlRelaxNGFreeDocumentList(schema->documents);
817: if (schema->includes != NULL)
818: xmlRelaxNGFreeIncludeList(schema->includes);
819: if (schema->defTab != NULL) {
820: int i;
821:
822: for (i = 0; i < schema->defNr; i++)
823: xmlRelaxNGFreeDefine(schema->defTab[i]);
824: xmlFree(schema->defTab);
825: }
826:
827: xmlFree(schema);
828: }
829:
830: /**
831: * xmlRelaxNGNewGrammar:
832: * @ctxt: a Relax-NG validation context (optional)
833: *
834: * Allocate a new RelaxNG grammar.
835: *
836: * Returns the newly allocated structure or NULL in case or error
837: */
838: static xmlRelaxNGGrammarPtr
839: xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
840: {
841: xmlRelaxNGGrammarPtr ret;
842:
843: ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
844: if (ret == NULL) {
845: xmlRngPErrMemory(ctxt, NULL);
846: return (NULL);
847: }
848: memset(ret, 0, sizeof(xmlRelaxNGGrammar));
849:
850: return (ret);
851: }
852:
853: /**
854: * xmlRelaxNGFreeGrammar:
855: * @grammar: a grammar structure
856: *
857: * Deallocate a RelaxNG grammar structure.
858: */
859: static void
860: xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
861: {
862: if (grammar == NULL)
863: return;
864:
865: if (grammar->children != NULL) {
866: xmlRelaxNGFreeGrammar(grammar->children);
867: }
868: if (grammar->next != NULL) {
869: xmlRelaxNGFreeGrammar(grammar->next);
870: }
871: if (grammar->refs != NULL) {
872: xmlHashFree(grammar->refs, NULL);
873: }
874: if (grammar->defs != NULL) {
875: xmlHashFree(grammar->defs, NULL);
876: }
877:
878: xmlFree(grammar);
879: }
880:
881: /**
882: * xmlRelaxNGNewDefine:
883: * @ctxt: a Relax-NG validation context
884: * @node: the node in the input document.
885: *
886: * Allocate a new RelaxNG define.
887: *
888: * Returns the newly allocated structure or NULL in case or error
889: */
890: static xmlRelaxNGDefinePtr
891: xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
892: {
893: xmlRelaxNGDefinePtr ret;
894:
895: if (ctxt->defMax == 0) {
896: ctxt->defMax = 16;
897: ctxt->defNr = 0;
898: ctxt->defTab = (xmlRelaxNGDefinePtr *)
899: xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
900: if (ctxt->defTab == NULL) {
901: xmlRngPErrMemory(ctxt, "allocating define\n");
902: return (NULL);
903: }
904: } else if (ctxt->defMax <= ctxt->defNr) {
905: xmlRelaxNGDefinePtr *tmp;
906:
907: ctxt->defMax *= 2;
908: tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
909: ctxt->defMax *
910: sizeof
911: (xmlRelaxNGDefinePtr));
912: if (tmp == NULL) {
913: xmlRngPErrMemory(ctxt, "allocating define\n");
914: return (NULL);
915: }
916: ctxt->defTab = tmp;
917: }
918: ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine));
919: if (ret == NULL) {
920: xmlRngPErrMemory(ctxt, "allocating define\n");
921: return (NULL);
922: }
923: memset(ret, 0, sizeof(xmlRelaxNGDefine));
924: ctxt->defTab[ctxt->defNr++] = ret;
925: ret->node = node;
926: ret->depth = -1;
927: return (ret);
928: }
929:
930: /**
931: * xmlRelaxNGFreePartition:
932: * @partitions: a partition set structure
933: *
934: * Deallocate RelaxNG partition set structures.
935: */
936: static void
937: xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions)
938: {
939: xmlRelaxNGInterleaveGroupPtr group;
940: int j;
941:
942: if (partitions != NULL) {
943: if (partitions->groups != NULL) {
944: for (j = 0; j < partitions->nbgroups; j++) {
945: group = partitions->groups[j];
946: if (group != NULL) {
947: if (group->defs != NULL)
948: xmlFree(group->defs);
949: if (group->attrs != NULL)
950: xmlFree(group->attrs);
951: xmlFree(group);
952: }
953: }
954: xmlFree(partitions->groups);
955: }
956: if (partitions->triage != NULL) {
957: xmlHashFree(partitions->triage, NULL);
958: }
959: xmlFree(partitions);
960: }
961: }
962:
963: /**
964: * xmlRelaxNGFreeDefine:
965: * @define: a define structure
966: *
967: * Deallocate a RelaxNG define structure.
968: */
969: static void
970: xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define)
971: {
972: if (define == NULL)
973: return;
974:
975: if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) {
976: xmlRelaxNGTypeLibraryPtr lib;
977:
978: lib = (xmlRelaxNGTypeLibraryPtr) define->data;
979: if ((lib != NULL) && (lib->freef != NULL))
980: lib->freef(lib->data, (void *) define->attrs);
981: }
982: if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE))
983: xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data);
984: if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE))
985: xmlHashFree((xmlHashTablePtr) define->data, NULL);
986: if (define->name != NULL)
987: xmlFree(define->name);
988: if (define->ns != NULL)
989: xmlFree(define->ns);
990: if (define->value != NULL)
991: xmlFree(define->value);
992: if (define->contModel != NULL)
993: xmlRegFreeRegexp(define->contModel);
994: xmlFree(define);
995: }
996:
997: /**
998: * xmlRelaxNGNewStates:
999: * @ctxt: a Relax-NG validation context
1000: * @size: the default size for the container
1001: *
1002: * Allocate a new RelaxNG validation state container
1003: *
1004: * Returns the newly allocated structure or NULL in case or error
1005: */
1006: static xmlRelaxNGStatesPtr
1007: xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
1008: {
1009: xmlRelaxNGStatesPtr ret;
1010:
1011: if ((ctxt != NULL) &&
1012: (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) {
1013: ctxt->freeStatesNr--;
1014: ret = ctxt->freeStates[ctxt->freeStatesNr];
1015: ret->nbState = 0;
1016: return (ret);
1017: }
1018: if (size < 16)
1019: size = 16;
1020:
1021: ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
1022: (size -
1023: 1) *
1024: sizeof(xmlRelaxNGValidStatePtr));
1025: if (ret == NULL) {
1026: xmlRngVErrMemory(ctxt, "allocating states\n");
1027: return (NULL);
1028: }
1029: ret->nbState = 0;
1030: ret->maxState = size;
1031: ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
1032: sizeof
1033: (xmlRelaxNGValidStatePtr));
1034: if (ret->tabState == NULL) {
1035: xmlRngVErrMemory(ctxt, "allocating states\n");
1036: xmlFree(ret);
1037: return (NULL);
1038: }
1039: return (ret);
1040: }
1041:
1042: /**
1043: * xmlRelaxNGAddStateUniq:
1044: * @ctxt: a Relax-NG validation context
1045: * @states: the states container
1046: * @state: the validation state
1047: *
1048: * Add a RelaxNG validation state to the container without checking
1049: * for unicity.
1050: *
1051: * Return 1 in case of success and 0 if this is a duplicate and -1 on error
1052: */
1053: static int
1054: xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
1055: xmlRelaxNGStatesPtr states,
1056: xmlRelaxNGValidStatePtr state)
1057: {
1058: if (state == NULL) {
1059: return (-1);
1060: }
1061: if (states->nbState >= states->maxState) {
1062: xmlRelaxNGValidStatePtr *tmp;
1063: int size;
1064:
1065: size = states->maxState * 2;
1066: tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
1067: (size) *
1068: sizeof
1069: (xmlRelaxNGValidStatePtr));
1070: if (tmp == NULL) {
1071: xmlRngVErrMemory(ctxt, "adding states\n");
1072: return (-1);
1073: }
1074: states->tabState = tmp;
1075: states->maxState = size;
1076: }
1077: states->tabState[states->nbState++] = state;
1078: return (1);
1079: }
1080:
1081: /**
1082: * xmlRelaxNGAddState:
1083: * @ctxt: a Relax-NG validation context
1084: * @states: the states container
1085: * @state: the validation state
1086: *
1087: * Add a RelaxNG validation state to the container
1088: *
1089: * Return 1 in case of success and 0 if this is a duplicate and -1 on error
1090: */
1091: static int
1092: xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
1093: xmlRelaxNGStatesPtr states,
1094: xmlRelaxNGValidStatePtr state)
1095: {
1096: int i;
1097:
1098: if (state == NULL) {
1099: return (-1);
1100: }
1101: if (states->nbState >= states->maxState) {
1102: xmlRelaxNGValidStatePtr *tmp;
1103: int size;
1104:
1105: size = states->maxState * 2;
1106: tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
1107: (size) *
1108: sizeof
1109: (xmlRelaxNGValidStatePtr));
1110: if (tmp == NULL) {
1111: xmlRngVErrMemory(ctxt, "adding states\n");
1112: return (-1);
1113: }
1114: states->tabState = tmp;
1115: states->maxState = size;
1116: }
1117: for (i = 0; i < states->nbState; i++) {
1118: if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
1119: xmlRelaxNGFreeValidState(ctxt, state);
1120: return (0);
1121: }
1122: }
1123: states->tabState[states->nbState++] = state;
1124: return (1);
1125: }
1126:
1127: /**
1128: * xmlRelaxNGFreeStates:
1129: * @ctxt: a Relax-NG validation context
1130: * @states: teh container
1131: *
1132: * Free a RelaxNG validation state container
1133: */
1134: static void
1135: xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
1136: xmlRelaxNGStatesPtr states)
1137: {
1138: if (states == NULL)
1139: return;
1140: if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
1141: ctxt->freeStatesMax = 40;
1142: ctxt->freeStatesNr = 0;
1143: ctxt->freeStates = (xmlRelaxNGStatesPtr *)
1144: xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
1145: if (ctxt->freeStates == NULL) {
1146: xmlRngVErrMemory(ctxt, "storing states\n");
1147: }
1148: } else if ((ctxt != NULL)
1149: && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
1150: xmlRelaxNGStatesPtr *tmp;
1151:
1152: tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
1153: 2 * ctxt->freeStatesMax *
1154: sizeof
1155: (xmlRelaxNGStatesPtr));
1156: if (tmp == NULL) {
1157: xmlRngVErrMemory(ctxt, "storing states\n");
1158: xmlFree(states->tabState);
1159: xmlFree(states);
1160: return;
1161: }
1162: ctxt->freeStates = tmp;
1163: ctxt->freeStatesMax *= 2;
1164: }
1165: if ((ctxt == NULL) || (ctxt->freeStates == NULL)) {
1166: xmlFree(states->tabState);
1167: xmlFree(states);
1168: } else {
1169: ctxt->freeStates[ctxt->freeStatesNr++] = states;
1170: }
1171: }
1172:
1173: /**
1174: * xmlRelaxNGNewValidState:
1175: * @ctxt: a Relax-NG validation context
1176: * @node: the current node or NULL for the document
1177: *
1178: * Allocate a new RelaxNG validation state
1179: *
1180: * Returns the newly allocated structure or NULL in case or error
1181: */
1182: static xmlRelaxNGValidStatePtr
1183: xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1184: {
1185: xmlRelaxNGValidStatePtr ret;
1186: xmlAttrPtr attr;
1187: xmlAttrPtr attrs[MAX_ATTR];
1188: int nbAttrs = 0;
1189: xmlNodePtr root = NULL;
1190:
1191: if (node == NULL) {
1192: root = xmlDocGetRootElement(ctxt->doc);
1193: if (root == NULL)
1194: return (NULL);
1195: } else {
1196: attr = node->properties;
1197: while (attr != NULL) {
1198: if (nbAttrs < MAX_ATTR)
1199: attrs[nbAttrs++] = attr;
1200: else
1201: nbAttrs++;
1202: attr = attr->next;
1203: }
1204: }
1205: if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1206: ctxt->freeState->nbState--;
1207: ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1208: } else {
1209: ret =
1210: (xmlRelaxNGValidStatePtr)
1211: xmlMalloc(sizeof(xmlRelaxNGValidState));
1212: if (ret == NULL) {
1213: xmlRngVErrMemory(ctxt, "allocating states\n");
1214: return (NULL);
1215: }
1216: memset(ret, 0, sizeof(xmlRelaxNGValidState));
1217: }
1218: ret->value = NULL;
1219: ret->endvalue = NULL;
1220: if (node == NULL) {
1221: ret->node = (xmlNodePtr) ctxt->doc;
1222: ret->seq = root;
1223: } else {
1224: ret->node = node;
1225: ret->seq = node->children;
1226: }
1227: ret->nbAttrs = 0;
1228: if (nbAttrs > 0) {
1229: if (ret->attrs == NULL) {
1230: if (nbAttrs < 4)
1231: ret->maxAttrs = 4;
1232: else
1233: ret->maxAttrs = nbAttrs;
1234: ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
1235: sizeof(xmlAttrPtr));
1236: if (ret->attrs == NULL) {
1237: xmlRngVErrMemory(ctxt, "allocating states\n");
1238: return (ret);
1239: }
1240: } else if (ret->maxAttrs < nbAttrs) {
1241: xmlAttrPtr *tmp;
1242:
1243: tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs *
1244: sizeof(xmlAttrPtr));
1245: if (tmp == NULL) {
1246: xmlRngVErrMemory(ctxt, "allocating states\n");
1247: return (ret);
1248: }
1249: ret->attrs = tmp;
1250: ret->maxAttrs = nbAttrs;
1251: }
1252: ret->nbAttrs = nbAttrs;
1253: if (nbAttrs < MAX_ATTR) {
1254: memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs);
1255: } else {
1256: attr = node->properties;
1257: nbAttrs = 0;
1258: while (attr != NULL) {
1259: ret->attrs[nbAttrs++] = attr;
1260: attr = attr->next;
1261: }
1262: }
1263: }
1264: ret->nbAttrLeft = ret->nbAttrs;
1265: return (ret);
1266: }
1267:
1268: /**
1269: * xmlRelaxNGCopyValidState:
1270: * @ctxt: a Relax-NG validation context
1271: * @state: a validation state
1272: *
1273: * Copy the validation state
1274: *
1275: * Returns the newly allocated structure or NULL in case or error
1276: */
1277: static xmlRelaxNGValidStatePtr
1278: xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
1279: xmlRelaxNGValidStatePtr state)
1280: {
1281: xmlRelaxNGValidStatePtr ret;
1282: unsigned int maxAttrs;
1283: xmlAttrPtr *attrs;
1284:
1285: if (state == NULL)
1286: return (NULL);
1287: if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1288: ctxt->freeState->nbState--;
1289: ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1290: } else {
1291: ret =
1292: (xmlRelaxNGValidStatePtr)
1293: xmlMalloc(sizeof(xmlRelaxNGValidState));
1294: if (ret == NULL) {
1295: xmlRngVErrMemory(ctxt, "allocating states\n");
1296: return (NULL);
1297: }
1298: memset(ret, 0, sizeof(xmlRelaxNGValidState));
1299: }
1300: attrs = ret->attrs;
1301: maxAttrs = ret->maxAttrs;
1302: memcpy(ret, state, sizeof(xmlRelaxNGValidState));
1303: ret->attrs = attrs;
1304: ret->maxAttrs = maxAttrs;
1305: if (state->nbAttrs > 0) {
1306: if (ret->attrs == NULL) {
1307: ret->maxAttrs = state->maxAttrs;
1308: ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
1309: sizeof(xmlAttrPtr));
1310: if (ret->attrs == NULL) {
1311: xmlRngVErrMemory(ctxt, "allocating states\n");
1312: ret->nbAttrs = 0;
1313: return (ret);
1314: }
1315: } else if (ret->maxAttrs < state->nbAttrs) {
1316: xmlAttrPtr *tmp;
1317:
1318: tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs *
1319: sizeof(xmlAttrPtr));
1320: if (tmp == NULL) {
1321: xmlRngVErrMemory(ctxt, "allocating states\n");
1322: ret->nbAttrs = 0;
1323: return (ret);
1324: }
1325: ret->maxAttrs = state->maxAttrs;
1326: ret->attrs = tmp;
1327: }
1328: memcpy(ret->attrs, state->attrs,
1329: state->nbAttrs * sizeof(xmlAttrPtr));
1330: }
1331: return (ret);
1332: }
1333:
1334: /**
1335: * xmlRelaxNGEqualValidState:
1336: * @ctxt: a Relax-NG validation context
1337: * @state1: a validation state
1338: * @state2: a validation state
1339: *
1340: * Compare the validation states for equality
1341: *
1342: * Returns 1 if equald, 0 otherwise
1343: */
1344: static int
1345: xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
1346: xmlRelaxNGValidStatePtr state1,
1347: xmlRelaxNGValidStatePtr state2)
1348: {
1349: int i;
1350:
1351: if ((state1 == NULL) || (state2 == NULL))
1352: return (0);
1353: if (state1 == state2)
1354: return (1);
1355: if (state1->node != state2->node)
1356: return (0);
1357: if (state1->seq != state2->seq)
1358: return (0);
1359: if (state1->nbAttrLeft != state2->nbAttrLeft)
1360: return (0);
1361: if (state1->nbAttrs != state2->nbAttrs)
1362: return (0);
1363: if (state1->endvalue != state2->endvalue)
1364: return (0);
1365: if ((state1->value != state2->value) &&
1366: (!xmlStrEqual(state1->value, state2->value)))
1367: return (0);
1368: for (i = 0; i < state1->nbAttrs; i++) {
1369: if (state1->attrs[i] != state2->attrs[i])
1370: return (0);
1371: }
1372: return (1);
1373: }
1374:
1375: /**
1376: * xmlRelaxNGFreeValidState:
1377: * @state: a validation state structure
1378: *
1379: * Deallocate a RelaxNG validation state structure.
1380: */
1381: static void
1382: xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
1383: xmlRelaxNGValidStatePtr state)
1384: {
1385: if (state == NULL)
1386: return;
1387:
1388: if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
1389: ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
1390: }
1391: if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
1392: if (state->attrs != NULL)
1393: xmlFree(state->attrs);
1394: xmlFree(state);
1395: } else {
1396: xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
1397: }
1398: }
1399:
1400: /************************************************************************
1401: * *
1402: * Semi internal functions *
1403: * *
1404: ************************************************************************/
1405:
1406: /**
1407: * xmlRelaxParserSetFlag:
1408: * @ctxt: a RelaxNG parser context
1409: * @flags: a set of flags values
1410: *
1411: * Semi private function used to pass informations to a parser context
1412: * which are a combination of xmlRelaxNGParserFlag .
1413: *
1414: * Returns 0 if success and -1 in case of error
1415: */
1416: int
1417: xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
1418: {
1419: if (ctxt == NULL) return(-1);
1420: if (flags & XML_RELAXNGP_FREE_DOC) {
1421: ctxt->crng |= XML_RELAXNGP_FREE_DOC;
1422: flags -= XML_RELAXNGP_FREE_DOC;
1423: }
1424: if (flags & XML_RELAXNGP_CRNG) {
1425: ctxt->crng |= XML_RELAXNGP_CRNG;
1426: flags -= XML_RELAXNGP_CRNG;
1427: }
1428: if (flags != 0) return(-1);
1429: return(0);
1430: }
1431:
1432: /************************************************************************
1433: * *
1434: * Document functions *
1435: * *
1436: ************************************************************************/
1437: static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
1438: xmlDocPtr doc);
1439:
1440: /**
1441: * xmlRelaxNGIncludePush:
1442: * @ctxt: the parser context
1443: * @value: the element doc
1444: *
1445: * Pushes a new include on top of the include stack
1446: *
1447: * Returns 0 in case of error, the index in the stack otherwise
1448: */
1449: static int
1450: xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
1451: xmlRelaxNGIncludePtr value)
1452: {
1453: if (ctxt->incTab == NULL) {
1454: ctxt->incMax = 4;
1455: ctxt->incNr = 0;
1456: ctxt->incTab =
1457: (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
1458: sizeof(ctxt->incTab[0]));
1459: if (ctxt->incTab == NULL) {
1460: xmlRngPErrMemory(ctxt, "allocating include\n");
1461: return (0);
1462: }
1463: }
1464: if (ctxt->incNr >= ctxt->incMax) {
1465: ctxt->incMax *= 2;
1466: ctxt->incTab =
1467: (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
1468: ctxt->incMax *
1469: sizeof(ctxt->incTab[0]));
1470: if (ctxt->incTab == NULL) {
1471: xmlRngPErrMemory(ctxt, "allocating include\n");
1472: return (0);
1473: }
1474: }
1475: ctxt->incTab[ctxt->incNr] = value;
1476: ctxt->inc = value;
1477: return (ctxt->incNr++);
1478: }
1479:
1480: /**
1481: * xmlRelaxNGIncludePop:
1482: * @ctxt: the parser context
1483: *
1484: * Pops the top include from the include stack
1485: *
1486: * Returns the include just removed
1487: */
1488: static xmlRelaxNGIncludePtr
1489: xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
1490: {
1491: xmlRelaxNGIncludePtr ret;
1492:
1493: if (ctxt->incNr <= 0)
1494: return (NULL);
1495: ctxt->incNr--;
1496: if (ctxt->incNr > 0)
1497: ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
1498: else
1499: ctxt->inc = NULL;
1500: ret = ctxt->incTab[ctxt->incNr];
1501: ctxt->incTab[ctxt->incNr] = NULL;
1502: return (ret);
1503: }
1504:
1505: /**
1506: * xmlRelaxNGRemoveRedefine:
1507: * @ctxt: the parser context
1508: * @URL: the normalized URL
1509: * @target: the included target
1510: * @name: the define name to eliminate
1511: *
1512: * Applies the elimination algorithm of 4.7
1513: *
1514: * Returns 0 in case of error, 1 in case of success.
1515: */
1516: static int
1517: xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
1518: const xmlChar * URL ATTRIBUTE_UNUSED,
1519: xmlNodePtr target, const xmlChar * name)
1520: {
1521: int found = 0;
1522: xmlNodePtr tmp, tmp2;
1523: xmlChar *name2;
1524:
1525: #ifdef DEBUG_INCLUDE
1526: if (name == NULL)
1527: xmlGenericError(xmlGenericErrorContext,
1528: "Elimination of <include> start from %s\n", URL);
1529: else
1530: xmlGenericError(xmlGenericErrorContext,
1531: "Elimination of <include> define %s from %s\n",
1532: name, URL);
1533: #endif
1534: tmp = target;
1535: while (tmp != NULL) {
1536: tmp2 = tmp->next;
1537: if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) {
1538: found = 1;
1539: xmlUnlinkNode(tmp);
1540: xmlFreeNode(tmp);
1541: } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) {
1542: name2 = xmlGetProp(tmp, BAD_CAST "name");
1543: xmlRelaxNGNormExtSpace(name2);
1544: if (name2 != NULL) {
1545: if (xmlStrEqual(name, name2)) {
1546: found = 1;
1547: xmlUnlinkNode(tmp);
1548: xmlFreeNode(tmp);
1549: }
1550: xmlFree(name2);
1551: }
1552: } else if (IS_RELAXNG(tmp, "include")) {
1553: xmlChar *href = NULL;
1554: xmlRelaxNGDocumentPtr inc = tmp->psvi;
1555:
1556: if ((inc != NULL) && (inc->doc != NULL) &&
1557: (inc->doc->children != NULL)) {
1558:
1559: if (xmlStrEqual
1560: (inc->doc->children->name, BAD_CAST "grammar")) {
1561: #ifdef DEBUG_INCLUDE
1562: href = xmlGetProp(tmp, BAD_CAST "href");
1563: #endif
1564: if (xmlRelaxNGRemoveRedefine(ctxt, href,
1565: xmlDocGetRootElement(inc->doc)->children,
1566: name) == 1) {
1567: found = 1;
1568: }
1569: #ifdef DEBUG_INCLUDE
1570: if (href != NULL)
1571: xmlFree(href);
1572: #endif
1573: }
1574: }
1575: }
1576: tmp = tmp2;
1577: }
1578: return (found);
1579: }
1580:
1581: /**
1582: * xmlRelaxNGLoadInclude:
1583: * @ctxt: the parser context
1584: * @URL: the normalized URL
1585: * @node: the include node.
1586: * @ns: the namespace passed from the context.
1587: *
1588: * First lookup if the document is already loaded into the parser context,
1589: * check against recursion. If not found the resource is loaded and
1590: * the content is preprocessed before being returned back to the caller.
1591: *
1592: * Returns the xmlRelaxNGIncludePtr or NULL in case of error
1593: */
1594: static xmlRelaxNGIncludePtr
1595: xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
1596: xmlNodePtr node, const xmlChar * ns)
1597: {
1598: xmlRelaxNGIncludePtr ret = NULL;
1599: xmlDocPtr doc;
1600: int i;
1601: xmlNodePtr root, cur;
1602:
1603: #ifdef DEBUG_INCLUDE
1604: xmlGenericError(xmlGenericErrorContext,
1605: "xmlRelaxNGLoadInclude(%s)\n", URL);
1606: #endif
1607:
1608: /*
1609: * check against recursion in the stack
1610: */
1611: for (i = 0; i < ctxt->incNr; i++) {
1612: if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
1613: xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
1614: "Detected an Include recursion for %s\n", URL,
1615: NULL);
1616: return (NULL);
1617: }
1618: }
1619:
1620: /*
1621: * load the document
1622: */
1623: doc = xmlReadFile((const char *) URL,NULL,0);
1624: if (doc == NULL) {
1625: xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1626: "xmlRelaxNG: could not load %s\n", URL, NULL);
1627: return (NULL);
1628: }
1629: #ifdef DEBUG_INCLUDE
1630: xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
1631: #endif
1632:
1633: /*
1634: * Allocate the document structures and register it first.
1635: */
1636: ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
1637: if (ret == NULL) {
1638: xmlRngPErrMemory(ctxt, "allocating include\n");
1639: xmlFreeDoc(doc);
1640: return (NULL);
1641: }
1642: memset(ret, 0, sizeof(xmlRelaxNGInclude));
1643: ret->doc = doc;
1644: ret->href = xmlStrdup(URL);
1645: ret->next = ctxt->includes;
1646: ctxt->includes = ret;
1647:
1648: /*
1649: * transmit the ns if needed
1650: */
1651: if (ns != NULL) {
1652: root = xmlDocGetRootElement(doc);
1653: if (root != NULL) {
1654: if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
1655: xmlSetProp(root, BAD_CAST "ns", ns);
1656: }
1657: }
1658: }
1659:
1660: /*
1661: * push it on the stack
1662: */
1663: xmlRelaxNGIncludePush(ctxt, ret);
1664:
1665: /*
1666: * Some preprocessing of the document content, this include recursing
1667: * in the include stack.
1668: */
1669: #ifdef DEBUG_INCLUDE
1670: xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
1671: #endif
1672:
1673: doc = xmlRelaxNGCleanupDoc(ctxt, doc);
1674: if (doc == NULL) {
1675: ctxt->inc = NULL;
1676: return (NULL);
1677: }
1678:
1679: /*
1680: * Pop up the include from the stack
1681: */
1682: xmlRelaxNGIncludePop(ctxt);
1683:
1684: #ifdef DEBUG_INCLUDE
1685: xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
1686: #endif
1687: /*
1688: * Check that the top element is a grammar
1689: */
1690: root = xmlDocGetRootElement(doc);
1691: if (root == NULL) {
1692: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1693: "xmlRelaxNG: included document is empty %s\n", URL,
1694: NULL);
1695: return (NULL);
1696: }
1697: if (!IS_RELAXNG(root, "grammar")) {
1698: xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1699: "xmlRelaxNG: included document %s root is not a grammar\n",
1700: URL, NULL);
1701: return (NULL);
1702: }
1703:
1704: /*
1705: * Elimination of redefined rules in the include.
1706: */
1707: cur = node->children;
1708: while (cur != NULL) {
1709: if (IS_RELAXNG(cur, "start")) {
1710: int found = 0;
1711:
1712: found =
1713: xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
1714: if (!found) {
1715: xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1716: "xmlRelaxNG: include %s has a start but not the included grammar\n",
1717: URL, NULL);
1718: }
1719: } else if (IS_RELAXNG(cur, "define")) {
1720: xmlChar *name;
1721:
1722: name = xmlGetProp(cur, BAD_CAST "name");
1723: if (name == NULL) {
1724: xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1725: "xmlRelaxNG: include %s has define without name\n",
1726: URL, NULL);
1727: } else {
1728: int found;
1729:
1730: xmlRelaxNGNormExtSpace(name);
1731: found = xmlRelaxNGRemoveRedefine(ctxt, URL,
1732: root->children, name);
1733: if (!found) {
1734: xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1735: "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
1736: URL, name);
1737: }
1738: xmlFree(name);
1739: }
1740: }
1741: cur = cur->next;
1742: }
1743:
1744:
1745: return (ret);
1746: }
1747:
1748: /**
1749: * xmlRelaxNGValidErrorPush:
1750: * @ctxt: the validation context
1751: * @err: the error code
1752: * @arg1: the first string argument
1753: * @arg2: the second string argument
1754: * @dup: arg need to be duplicated
1755: *
1756: * Pushes a new error on top of the error stack
1757: *
1758: * Returns 0 in case of error, the index in the stack otherwise
1759: */
1760: static int
1761: xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
1762: xmlRelaxNGValidErr err, const xmlChar * arg1,
1763: const xmlChar * arg2, int dup)
1764: {
1765: xmlRelaxNGValidErrorPtr cur;
1766:
1767: #ifdef DEBUG_ERROR
1768: xmlGenericError(xmlGenericErrorContext,
1769: "Pushing error %d at %d on stack\n", err, ctxt->errNr);
1770: #endif
1771: if (ctxt->errTab == NULL) {
1772: ctxt->errMax = 8;
1773: ctxt->errNr = 0;
1774: ctxt->errTab =
1775: (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
1776: sizeof
1777: (xmlRelaxNGValidError));
1778: if (ctxt->errTab == NULL) {
1779: xmlRngVErrMemory(ctxt, "pushing error\n");
1780: return (0);
1781: }
1782: ctxt->err = NULL;
1783: }
1784: if (ctxt->errNr >= ctxt->errMax) {
1785: ctxt->errMax *= 2;
1786: ctxt->errTab =
1787: (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
1788: ctxt->errMax *
1789: sizeof
1790: (xmlRelaxNGValidError));
1791: if (ctxt->errTab == NULL) {
1792: xmlRngVErrMemory(ctxt, "pushing error\n");
1793: return (0);
1794: }
1795: ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1796: }
1797: if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
1798: (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1799: return (ctxt->errNr);
1800: cur = &ctxt->errTab[ctxt->errNr];
1801: cur->err = err;
1802: if (dup) {
1803: cur->arg1 = xmlStrdup(arg1);
1804: cur->arg2 = xmlStrdup(arg2);
1805: cur->flags = ERROR_IS_DUP;
1806: } else {
1807: cur->arg1 = arg1;
1808: cur->arg2 = arg2;
1809: cur->flags = 0;
1810: }
1811: if (ctxt->state != NULL) {
1812: cur->node = ctxt->state->node;
1813: cur->seq = ctxt->state->seq;
1814: } else {
1815: cur->node = NULL;
1816: cur->seq = NULL;
1817: }
1818: ctxt->err = cur;
1819: return (ctxt->errNr++);
1820: }
1821:
1822: /**
1823: * xmlRelaxNGValidErrorPop:
1824: * @ctxt: the validation context
1825: *
1826: * Pops the top error from the error stack
1827: */
1828: static void
1829: xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
1830: {
1831: xmlRelaxNGValidErrorPtr cur;
1832:
1833: if (ctxt->errNr <= 0) {
1834: ctxt->err = NULL;
1835: return;
1836: }
1837: ctxt->errNr--;
1838: if (ctxt->errNr > 0)
1839: ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1840: else
1841: ctxt->err = NULL;
1842: cur = &ctxt->errTab[ctxt->errNr];
1843: if (cur->flags & ERROR_IS_DUP) {
1844: if (cur->arg1 != NULL)
1845: xmlFree((xmlChar *) cur->arg1);
1846: cur->arg1 = NULL;
1847: if (cur->arg2 != NULL)
1848: xmlFree((xmlChar *) cur->arg2);
1849: cur->arg2 = NULL;
1850: cur->flags = 0;
1851: }
1852: }
1853:
1854: /**
1855: * xmlRelaxNGDocumentPush:
1856: * @ctxt: the parser context
1857: * @value: the element doc
1858: *
1859: * Pushes a new doc on top of the doc stack
1860: *
1861: * Returns 0 in case of error, the index in the stack otherwise
1862: */
1863: static int
1864: xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
1865: xmlRelaxNGDocumentPtr value)
1866: {
1867: if (ctxt->docTab == NULL) {
1868: ctxt->docMax = 4;
1869: ctxt->docNr = 0;
1870: ctxt->docTab =
1871: (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
1872: sizeof(ctxt->docTab[0]));
1873: if (ctxt->docTab == NULL) {
1874: xmlRngPErrMemory(ctxt, "adding document\n");
1875: return (0);
1876: }
1877: }
1878: if (ctxt->docNr >= ctxt->docMax) {
1879: ctxt->docMax *= 2;
1880: ctxt->docTab =
1881: (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
1882: ctxt->docMax *
1883: sizeof(ctxt->docTab[0]));
1884: if (ctxt->docTab == NULL) {
1885: xmlRngPErrMemory(ctxt, "adding document\n");
1886: return (0);
1887: }
1888: }
1889: ctxt->docTab[ctxt->docNr] = value;
1890: ctxt->doc = value;
1891: return (ctxt->docNr++);
1892: }
1893:
1894: /**
1895: * xmlRelaxNGDocumentPop:
1896: * @ctxt: the parser context
1897: *
1898: * Pops the top doc from the doc stack
1899: *
1900: * Returns the doc just removed
1901: */
1902: static xmlRelaxNGDocumentPtr
1903: xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
1904: {
1905: xmlRelaxNGDocumentPtr ret;
1906:
1907: if (ctxt->docNr <= 0)
1908: return (NULL);
1909: ctxt->docNr--;
1910: if (ctxt->docNr > 0)
1911: ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
1912: else
1913: ctxt->doc = NULL;
1914: ret = ctxt->docTab[ctxt->docNr];
1915: ctxt->docTab[ctxt->docNr] = NULL;
1916: return (ret);
1917: }
1918:
1919: /**
1920: * xmlRelaxNGLoadExternalRef:
1921: * @ctxt: the parser context
1922: * @URL: the normalized URL
1923: * @ns: the inherited ns if any
1924: *
1925: * First lookup if the document is already loaded into the parser context,
1926: * check against recursion. If not found the resource is loaded and
1927: * the content is preprocessed before being returned back to the caller.
1928: *
1929: * Returns the xmlRelaxNGDocumentPtr or NULL in case of error
1930: */
1931: static xmlRelaxNGDocumentPtr
1932: xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
1933: const xmlChar * URL, const xmlChar * ns)
1934: {
1935: xmlRelaxNGDocumentPtr ret = NULL;
1936: xmlDocPtr doc;
1937: xmlNodePtr root;
1938: int i;
1939:
1940: /*
1941: * check against recursion in the stack
1942: */
1943: for (i = 0; i < ctxt->docNr; i++) {
1944: if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
1945: xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
1946: "Detected an externalRef recursion for %s\n", URL,
1947: NULL);
1948: return (NULL);
1949: }
1950: }
1951:
1952: /*
1953: * load the document
1954: */
1955: doc = xmlReadFile((const char *) URL,NULL,0);
1956: if (doc == NULL) {
1957: xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
1958: "xmlRelaxNG: could not load %s\n", URL, NULL);
1959: return (NULL);
1960: }
1961:
1962: /*
1963: * Allocate the document structures and register it first.
1964: */
1965: ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
1966: if (ret == NULL) {
1967: xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
1968: "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
1969: xmlFreeDoc(doc);
1970: return (NULL);
1971: }
1972: memset(ret, 0, sizeof(xmlRelaxNGDocument));
1973: ret->doc = doc;
1974: ret->href = xmlStrdup(URL);
1975: ret->next = ctxt->documents;
1976: ret->externalRef = 1;
1977: ctxt->documents = ret;
1978:
1979: /*
1980: * transmit the ns if needed
1981: */
1982: if (ns != NULL) {
1983: root = xmlDocGetRootElement(doc);
1984: if (root != NULL) {
1985: if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
1986: xmlSetProp(root, BAD_CAST "ns", ns);
1987: }
1988: }
1989: }
1990:
1991: /*
1992: * push it on the stack and register it in the hash table
1993: */
1994: xmlRelaxNGDocumentPush(ctxt, ret);
1995:
1996: /*
1997: * Some preprocessing of the document content
1998: */
1999: doc = xmlRelaxNGCleanupDoc(ctxt, doc);
2000: if (doc == NULL) {
2001: ctxt->doc = NULL;
2002: return (NULL);
2003: }
2004:
2005: xmlRelaxNGDocumentPop(ctxt);
2006:
2007: return (ret);
2008: }
2009:
2010: /************************************************************************
2011: * *
2012: * Error functions *
2013: * *
2014: ************************************************************************/
2015:
2016: #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
2017: #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
2018: #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
2019: #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
2020: #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
2021:
2022: static const char *
2023: xmlRelaxNGDefName(xmlRelaxNGDefinePtr def)
2024: {
2025: if (def == NULL)
2026: return ("none");
2027: switch (def->type) {
2028: case XML_RELAXNG_EMPTY:
2029: return ("empty");
2030: case XML_RELAXNG_NOT_ALLOWED:
2031: return ("notAllowed");
2032: case XML_RELAXNG_EXCEPT:
2033: return ("except");
2034: case XML_RELAXNG_TEXT:
2035: return ("text");
2036: case XML_RELAXNG_ELEMENT:
2037: return ("element");
2038: case XML_RELAXNG_DATATYPE:
2039: return ("datatype");
2040: case XML_RELAXNG_VALUE:
2041: return ("value");
2042: case XML_RELAXNG_LIST:
2043: return ("list");
2044: case XML_RELAXNG_ATTRIBUTE:
2045: return ("attribute");
2046: case XML_RELAXNG_DEF:
2047: return ("def");
2048: case XML_RELAXNG_REF:
2049: return ("ref");
2050: case XML_RELAXNG_EXTERNALREF:
2051: return ("externalRef");
2052: case XML_RELAXNG_PARENTREF:
2053: return ("parentRef");
2054: case XML_RELAXNG_OPTIONAL:
2055: return ("optional");
2056: case XML_RELAXNG_ZEROORMORE:
2057: return ("zeroOrMore");
2058: case XML_RELAXNG_ONEORMORE:
2059: return ("oneOrMore");
2060: case XML_RELAXNG_CHOICE:
2061: return ("choice");
2062: case XML_RELAXNG_GROUP:
2063: return ("group");
2064: case XML_RELAXNG_INTERLEAVE:
2065: return ("interleave");
2066: case XML_RELAXNG_START:
2067: return ("start");
2068: case XML_RELAXNG_NOOP:
2069: return ("noop");
2070: case XML_RELAXNG_PARAM:
2071: return ("param");
2072: }
2073: return ("unknown");
2074: }
2075:
2076: /**
2077: * xmlRelaxNGGetErrorString:
2078: * @err: the error code
2079: * @arg1: the first string argument
2080: * @arg2: the second string argument
2081: *
2082: * computes a formatted error string for the given error code and args
2083: *
2084: * Returns the error string, it must be deallocated by the caller
2085: */
2086: static xmlChar *
2087: xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
2088: const xmlChar * arg2)
2089: {
2090: char msg[1000];
2091:
2092: if (arg1 == NULL)
2093: arg1 = BAD_CAST "";
2094: if (arg2 == NULL)
2095: arg2 = BAD_CAST "";
2096:
2097: msg[0] = 0;
2098: switch (err) {
2099: case XML_RELAXNG_OK:
2100: return (NULL);
2101: case XML_RELAXNG_ERR_MEMORY:
2102: return (xmlCharStrdup("out of memory\n"));
2103: case XML_RELAXNG_ERR_TYPE:
2104: snprintf(msg, 1000, "failed to validate type %s\n", arg1);
2105: break;
2106: case XML_RELAXNG_ERR_TYPEVAL:
2107: snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1,
2108: arg2);
2109: break;
2110: case XML_RELAXNG_ERR_DUPID:
2111: snprintf(msg, 1000, "ID %s redefined\n", arg1);
2112: break;
2113: case XML_RELAXNG_ERR_TYPECMP:
2114: snprintf(msg, 1000, "failed to compare type %s\n", arg1);
2115: break;
2116: case XML_RELAXNG_ERR_NOSTATE:
2117: return (xmlCharStrdup("Internal error: no state\n"));
2118: case XML_RELAXNG_ERR_NODEFINE:
2119: return (xmlCharStrdup("Internal error: no define\n"));
2120: case XML_RELAXNG_ERR_INTERNAL:
2121: snprintf(msg, 1000, "Internal error: %s\n", arg1);
2122: break;
2123: case XML_RELAXNG_ERR_LISTEXTRA:
2124: snprintf(msg, 1000, "Extra data in list: %s\n", arg1);
2125: break;
2126: case XML_RELAXNG_ERR_INTERNODATA:
2127: return (xmlCharStrdup
2128: ("Internal: interleave block has no data\n"));
2129: case XML_RELAXNG_ERR_INTERSEQ:
2130: return (xmlCharStrdup("Invalid sequence in interleave\n"));
2131: case XML_RELAXNG_ERR_INTEREXTRA:
2132: snprintf(msg, 1000, "Extra element %s in interleave\n", arg1);
2133: break;
2134: case XML_RELAXNG_ERR_ELEMNAME:
2135: snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1,
2136: arg2);
2137: break;
2138: case XML_RELAXNG_ERR_ELEMNONS:
2139: snprintf(msg, 1000, "Expecting a namespace for element %s\n",
2140: arg1);
2141: break;
2142: case XML_RELAXNG_ERR_ELEMWRONGNS:
2143: snprintf(msg, 1000,
2144: "Element %s has wrong namespace: expecting %s\n", arg1,
2145: arg2);
2146: break;
2147: case XML_RELAXNG_ERR_ELEMWRONG:
2148: snprintf(msg, 1000, "Did not expect element %s there\n", arg1);
2149: break;
2150: case XML_RELAXNG_ERR_TEXTWRONG:
2151: snprintf(msg, 1000,
2152: "Did not expect text in element %s content\n", arg1);
2153: break;
2154: case XML_RELAXNG_ERR_ELEMEXTRANS:
2155: snprintf(msg, 1000, "Expecting no namespace for element %s\n",
2156: arg1);
2157: break;
2158: case XML_RELAXNG_ERR_ELEMNOTEMPTY:
2159: snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1);
2160: break;
2161: case XML_RELAXNG_ERR_NOELEM:
2162: snprintf(msg, 1000, "Expecting an element %s, got nothing\n",
2163: arg1);
2164: break;
2165: case XML_RELAXNG_ERR_NOTELEM:
2166: return (xmlCharStrdup("Expecting an element got text\n"));
2167: case XML_RELAXNG_ERR_ATTRVALID:
2168: snprintf(msg, 1000, "Element %s failed to validate attributes\n",
2169: arg1);
2170: break;
2171: case XML_RELAXNG_ERR_CONTENTVALID:
2172: snprintf(msg, 1000, "Element %s failed to validate content\n",
2173: arg1);
2174: break;
2175: case XML_RELAXNG_ERR_EXTRACONTENT:
2176: snprintf(msg, 1000, "Element %s has extra content: %s\n",
2177: arg1, arg2);
2178: break;
2179: case XML_RELAXNG_ERR_INVALIDATTR:
2180: snprintf(msg, 1000, "Invalid attribute %s for element %s\n",
2181: arg1, arg2);
2182: break;
2183: case XML_RELAXNG_ERR_LACKDATA:
2184: snprintf(msg, 1000, "Datatype element %s contains no data\n",
2185: arg1);
2186: break;
2187: case XML_RELAXNG_ERR_DATAELEM:
2188: snprintf(msg, 1000, "Datatype element %s has child elements\n",
2189: arg1);
2190: break;
2191: case XML_RELAXNG_ERR_VALELEM:
2192: snprintf(msg, 1000, "Value element %s has child elements\n",
2193: arg1);
2194: break;
2195: case XML_RELAXNG_ERR_LISTELEM:
2196: snprintf(msg, 1000, "List element %s has child elements\n",
2197: arg1);
2198: break;
2199: case XML_RELAXNG_ERR_DATATYPE:
2200: snprintf(msg, 1000, "Error validating datatype %s\n", arg1);
2201: break;
2202: case XML_RELAXNG_ERR_VALUE:
2203: snprintf(msg, 1000, "Error validating value %s\n", arg1);
2204: break;
2205: case XML_RELAXNG_ERR_LIST:
2206: return (xmlCharStrdup("Error validating list\n"));
2207: case XML_RELAXNG_ERR_NOGRAMMAR:
2208: return (xmlCharStrdup("No top grammar defined\n"));
2209: case XML_RELAXNG_ERR_EXTRADATA:
2210: return (xmlCharStrdup("Extra data in the document\n"));
2211: default:
2212: return (xmlCharStrdup("Unknown error !\n"));
2213: }
2214: if (msg[0] == 0) {
2215: snprintf(msg, 1000, "Unknown error code %d\n", err);
2216: }
2217: msg[1000 - 1] = 0;
2218: return (xmlStrdup((xmlChar *) msg));
2219: }
2220:
2221: /**
2222: * xmlRelaxNGShowValidError:
2223: * @ctxt: the validation context
2224: * @err: the error number
2225: * @node: the node
2226: * @child: the node child generating the problem.
2227: * @arg1: the first argument
2228: * @arg2: the second argument
2229: *
2230: * Show a validation error.
2231: */
2232: static void
2233: xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
2234: xmlRelaxNGValidErr err, xmlNodePtr node,
2235: xmlNodePtr child, const xmlChar * arg1,
2236: const xmlChar * arg2)
2237: {
2238: xmlChar *msg;
2239:
2240: if (ctxt->flags & FLAGS_NOERROR)
2241: return;
2242:
2243: #ifdef DEBUG_ERROR
2244: xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
2245: #endif
2246: msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
2247: if (msg == NULL)
2248: return;
2249:
2250: if (ctxt->errNo == XML_RELAXNG_OK)
2251: ctxt->errNo = err;
2252: xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2253: (const char *) msg, arg1, arg2);
2254: xmlFree(msg);
2255: }
2256:
2257: /**
2258: * xmlRelaxNGPopErrors:
2259: * @ctxt: the validation context
2260: * @level: the error level in the stack
2261: *
2262: * pop and discard all errors until the given level is reached
2263: */
2264: static void
2265: xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
2266: {
2267: int i;
2268: xmlRelaxNGValidErrorPtr err;
2269:
2270: #ifdef DEBUG_ERROR
2271: xmlGenericError(xmlGenericErrorContext,
2272: "Pop errors till level %d\n", level);
2273: #endif
2274: for (i = level; i < ctxt->errNr; i++) {
2275: err = &ctxt->errTab[i];
2276: if (err->flags & ERROR_IS_DUP) {
2277: if (err->arg1 != NULL)
2278: xmlFree((xmlChar *) err->arg1);
2279: err->arg1 = NULL;
2280: if (err->arg2 != NULL)
2281: xmlFree((xmlChar *) err->arg2);
2282: err->arg2 = NULL;
2283: err->flags = 0;
2284: }
2285: }
2286: ctxt->errNr = level;
2287: if (ctxt->errNr <= 0)
2288: ctxt->err = NULL;
2289: }
2290:
2291: /**
2292: * xmlRelaxNGDumpValidError:
2293: * @ctxt: the validation context
2294: *
2295: * Show all validation error over a given index.
2296: */
2297: static void
2298: xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
2299: {
2300: int i, j, k;
2301: xmlRelaxNGValidErrorPtr err, dup;
2302:
2303: #ifdef DEBUG_ERROR
2304: xmlGenericError(xmlGenericErrorContext,
2305: "Dumping error stack %d errors\n", ctxt->errNr);
2306: #endif
2307: for (i = 0, k = 0; i < ctxt->errNr; i++) {
2308: err = &ctxt->errTab[i];
2309: if (k < MAX_ERROR) {
2310: for (j = 0; j < i; j++) {
2311: dup = &ctxt->errTab[j];
2312: if ((err->err == dup->err) && (err->node == dup->node) &&
2313: (xmlStrEqual(err->arg1, dup->arg1)) &&
2314: (xmlStrEqual(err->arg2, dup->arg2))) {
2315: goto skip;
2316: }
2317: }
2318: xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2319: err->arg1, err->arg2);
2320: k++;
2321: }
2322: skip:
2323: if (err->flags & ERROR_IS_DUP) {
2324: if (err->arg1 != NULL)
2325: xmlFree((xmlChar *) err->arg1);
2326: err->arg1 = NULL;
2327: if (err->arg2 != NULL)
2328: xmlFree((xmlChar *) err->arg2);
2329: err->arg2 = NULL;
2330: err->flags = 0;
2331: }
2332: }
2333: ctxt->errNr = 0;
2334: }
2335:
2336: /**
2337: * xmlRelaxNGAddValidError:
2338: * @ctxt: the validation context
2339: * @err: the error number
2340: * @arg1: the first argument
2341: * @arg2: the second argument
2342: * @dup: need to dup the args
2343: *
2344: * Register a validation error, either generating it if it's sure
2345: * or stacking it for later handling if unsure.
2346: */
2347: static void
2348: xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
2349: xmlRelaxNGValidErr err, const xmlChar * arg1,
2350: const xmlChar * arg2, int dup)
2351: {
2352: if (ctxt == NULL)
2353: return;
2354: if (ctxt->flags & FLAGS_NOERROR)
2355: return;
2356:
2357: #ifdef DEBUG_ERROR
2358: xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
2359: #endif
2360: /*
2361: * generate the error directly
2362: */
2363: if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
2364: (ctxt->flags & FLAGS_NEGATIVE)) {
2365: xmlNodePtr node, seq;
2366:
2367: /*
2368: * Flush first any stacked error which might be the
2369: * real cause of the problem.
2370: */
2371: if (ctxt->errNr != 0)
2372: xmlRelaxNGDumpValidError(ctxt);
2373: if (ctxt->state != NULL) {
2374: node = ctxt->state->node;
2375: seq = ctxt->state->seq;
2376: } else {
2377: node = seq = NULL;
2378: }
2379: if ((node == NULL) && (seq == NULL)) {
2380: node = ctxt->pnode;
2381: }
2382: xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2383: }
2384: /*
2385: * Stack the error for later processing if needed
2386: */
2387: else {
2388: xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
2389: }
2390: }
2391:
2392:
2393: /************************************************************************
2394: * *
2395: * Type library hooks *
2396: * *
2397: ************************************************************************/
2398: static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
2399: const xmlChar * str);
2400:
2401: /**
2402: * xmlRelaxNGSchemaTypeHave:
2403: * @data: data needed for the library
2404: * @type: the type name
2405: *
2406: * Check if the given type is provided by
2407: * the W3C XMLSchema Datatype library.
2408: *
2409: * Returns 1 if yes, 0 if no and -1 in case of error.
2410: */
2411: static int
2412: xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
2413: {
2414: xmlSchemaTypePtr typ;
2415:
2416: if (type == NULL)
2417: return (-1);
2418: typ = xmlSchemaGetPredefinedType(type,
2419: BAD_CAST
2420: "http://www.w3.org/2001/XMLSchema");
2421: if (typ == NULL)
2422: return (0);
2423: return (1);
2424: }
2425:
2426: /**
2427: * xmlRelaxNGSchemaTypeCheck:
2428: * @data: data needed for the library
2429: * @type: the type name
2430: * @value: the value to check
2431: * @node: the node
2432: *
2433: * Check if the given type and value are validated by
2434: * the W3C XMLSchema Datatype library.
2435: *
2436: * Returns 1 if yes, 0 if no and -1 in case of error.
2437: */
2438: static int
2439: xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
2440: const xmlChar * type,
2441: const xmlChar * value,
2442: void **result, xmlNodePtr node)
2443: {
2444: xmlSchemaTypePtr typ;
2445: int ret;
2446:
2447: if ((type == NULL) || (value == NULL))
2448: return (-1);
2449: typ = xmlSchemaGetPredefinedType(type,
2450: BAD_CAST
2451: "http://www.w3.org/2001/XMLSchema");
2452: if (typ == NULL)
2453: return (-1);
2454: ret = xmlSchemaValPredefTypeNode(typ, value,
2455: (xmlSchemaValPtr *) result, node);
2456: if (ret == 2) /* special ID error code */
2457: return (2);
2458: if (ret == 0)
2459: return (1);
2460: if (ret > 0)
2461: return (0);
2462: return (-1);
2463: }
2464:
2465: /**
2466: * xmlRelaxNGSchemaFacetCheck:
2467: * @data: data needed for the library
2468: * @type: the type name
2469: * @facet: the facet name
2470: * @val: the facet value
2471: * @strval: the string value
2472: * @value: the value to check
2473: *
2474: * Function provided by a type library to check a value facet
2475: *
2476: * Returns 1 if yes, 0 if no and -1 in case of error.
2477: */
2478: static int
2479: xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
2480: const xmlChar * type, const xmlChar * facetname,
2481: const xmlChar * val, const xmlChar * strval,
2482: void *value)
2483: {
2484: xmlSchemaFacetPtr facet;
2485: xmlSchemaTypePtr typ;
2486: int ret;
2487:
2488: if ((type == NULL) || (strval == NULL))
2489: return (-1);
2490: typ = xmlSchemaGetPredefinedType(type,
2491: BAD_CAST
2492: "http://www.w3.org/2001/XMLSchema");
2493: if (typ == NULL)
2494: return (-1);
2495:
2496: facet = xmlSchemaNewFacet();
2497: if (facet == NULL)
2498: return (-1);
2499:
2500: if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
2501: facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
2502: } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
2503: facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
2504: } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
2505: facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
2506: } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
2507: facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
2508: } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
2509: facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
2510: } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
2511: facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
2512: } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
2513: facet->type = XML_SCHEMA_FACET_PATTERN;
2514: } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
2515: facet->type = XML_SCHEMA_FACET_ENUMERATION;
2516: } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
2517: facet->type = XML_SCHEMA_FACET_WHITESPACE;
2518: } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
2519: facet->type = XML_SCHEMA_FACET_LENGTH;
2520: } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
2521: facet->type = XML_SCHEMA_FACET_MAXLENGTH;
2522: } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) {
2523: facet->type = XML_SCHEMA_FACET_MINLENGTH;
2524: } else {
2525: xmlSchemaFreeFacet(facet);
2526: return (-1);
2527: }
2528: facet->value = val;
2529: ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
2530: if (ret != 0) {
2531: xmlSchemaFreeFacet(facet);
2532: return (-1);
2533: }
2534: ret = xmlSchemaValidateFacet(typ, facet, strval, value);
2535: xmlSchemaFreeFacet(facet);
2536: if (ret != 0)
2537: return (-1);
2538: return (0);
2539: }
2540:
2541: /**
2542: * xmlRelaxNGSchemaFreeValue:
2543: * @data: data needed for the library
2544: * @value: the value to free
2545: *
2546: * Function provided by a type library to free a Schemas value
2547: *
2548: * Returns 1 if yes, 0 if no and -1 in case of error.
2549: */
2550: static void
2551: xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
2552: {
2553: xmlSchemaFreeValue(value);
2554: }
2555:
2556: /**
2557: * xmlRelaxNGSchemaTypeCompare:
2558: * @data: data needed for the library
2559: * @type: the type name
2560: * @value1: the first value
2561: * @value2: the second value
2562: *
2563: * Compare two values for equality accordingly a type from the W3C XMLSchema
2564: * Datatype library.
2565: *
2566: * Returns 1 if equal, 0 if no and -1 in case of error.
2567: */
2568: static int
2569: xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
2570: const xmlChar * type,
2571: const xmlChar * value1,
2572: xmlNodePtr ctxt1,
2573: void *comp1,
2574: const xmlChar * value2, xmlNodePtr ctxt2)
2575: {
2576: int ret;
2577: xmlSchemaTypePtr typ;
2578: xmlSchemaValPtr res1 = NULL, res2 = NULL;
2579:
2580: if ((type == NULL) || (value1 == NULL) || (value2 == NULL))
2581: return (-1);
2582: typ = xmlSchemaGetPredefinedType(type,
2583: BAD_CAST
2584: "http://www.w3.org/2001/XMLSchema");
2585: if (typ == NULL)
2586: return (-1);
2587: if (comp1 == NULL) {
2588: ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
2589: if (ret != 0)
2590: return (-1);
2591: if (res1 == NULL)
2592: return (-1);
2593: } else {
2594: res1 = (xmlSchemaValPtr) comp1;
2595: }
2596: ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
2597: if (ret != 0) {
2598: if ((comp1 == NULL) && (res1 != NULL))
2599: xmlSchemaFreeValue(res1);
2600: return (-1);
2601: }
2602: if (res1 == NULL) {
2603: return (-1);
2604: }
2605: ret = xmlSchemaCompareValues(res1, res2);
2606: if (res1 != (xmlSchemaValPtr) comp1)
2607: xmlSchemaFreeValue(res1);
2608: xmlSchemaFreeValue(res2);
2609: if (ret == -2)
2610: return (-1);
2611: if (ret == 0)
2612: return (1);
2613: return (0);
2614: }
2615:
2616: /**
2617: * xmlRelaxNGDefaultTypeHave:
2618: * @data: data needed for the library
2619: * @type: the type name
2620: *
2621: * Check if the given type is provided by
2622: * the default datatype library.
2623: *
2624: * Returns 1 if yes, 0 if no and -1 in case of error.
2625: */
2626: static int
2627: xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
2628: const xmlChar * type)
2629: {
2630: if (type == NULL)
2631: return (-1);
2632: if (xmlStrEqual(type, BAD_CAST "string"))
2633: return (1);
2634: if (xmlStrEqual(type, BAD_CAST "token"))
2635: return (1);
2636: return (0);
2637: }
2638:
2639: /**
2640: * xmlRelaxNGDefaultTypeCheck:
2641: * @data: data needed for the library
2642: * @type: the type name
2643: * @value: the value to check
2644: * @node: the node
2645: *
2646: * Check if the given type and value are validated by
2647: * the default datatype library.
2648: *
2649: * Returns 1 if yes, 0 if no and -1 in case of error.
2650: */
2651: static int
2652: xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED,
2653: const xmlChar * type ATTRIBUTE_UNUSED,
2654: const xmlChar * value ATTRIBUTE_UNUSED,
2655: void **result ATTRIBUTE_UNUSED,
2656: xmlNodePtr node ATTRIBUTE_UNUSED)
2657: {
2658: if (value == NULL)
2659: return (-1);
2660: if (xmlStrEqual(type, BAD_CAST "string"))
2661: return (1);
2662: if (xmlStrEqual(type, BAD_CAST "token")) {
2663: return (1);
2664: }
2665:
2666: return (0);
2667: }
2668:
2669: /**
2670: * xmlRelaxNGDefaultTypeCompare:
2671: * @data: data needed for the library
2672: * @type: the type name
2673: * @value1: the first value
2674: * @value2: the second value
2675: *
2676: * Compare two values accordingly a type from the default
2677: * datatype library.
2678: *
2679: * Returns 1 if yes, 0 if no and -1 in case of error.
2680: */
2681: static int
2682: xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
2683: const xmlChar * type,
2684: const xmlChar * value1,
2685: xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
2686: void *comp1 ATTRIBUTE_UNUSED,
2687: const xmlChar * value2,
2688: xmlNodePtr ctxt2 ATTRIBUTE_UNUSED)
2689: {
2690: int ret = -1;
2691:
2692: if (xmlStrEqual(type, BAD_CAST "string")) {
2693: ret = xmlStrEqual(value1, value2);
2694: } else if (xmlStrEqual(type, BAD_CAST "token")) {
2695: if (!xmlStrEqual(value1, value2)) {
2696: xmlChar *nval, *nvalue;
2697:
2698: /*
2699: * TODO: trivial optimizations are possible by
2700: * computing at compile-time
2701: */
2702: nval = xmlRelaxNGNormalize(NULL, value1);
2703: nvalue = xmlRelaxNGNormalize(NULL, value2);
2704:
2705: if ((nval == NULL) || (nvalue == NULL))
2706: ret = -1;
2707: else if (xmlStrEqual(nval, nvalue))
2708: ret = 1;
2709: else
2710: ret = 0;
2711: if (nval != NULL)
2712: xmlFree(nval);
2713: if (nvalue != NULL)
2714: xmlFree(nvalue);
2715: } else
2716: ret = 1;
2717: }
2718: return (ret);
2719: }
2720:
2721: static int xmlRelaxNGTypeInitialized = 0;
2722: static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
2723:
2724: /**
2725: * xmlRelaxNGFreeTypeLibrary:
2726: * @lib: the type library structure
2727: * @namespace: the URI bound to the library
2728: *
2729: * Free the structure associated to the type library
2730: */
2731: static void
2732: xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
2733: const xmlChar * namespace ATTRIBUTE_UNUSED)
2734: {
2735: if (lib == NULL)
2736: return;
2737: if (lib->namespace != NULL)
2738: xmlFree((xmlChar *) lib->namespace);
2739: xmlFree(lib);
2740: }
2741:
2742: /**
2743: * xmlRelaxNGRegisterTypeLibrary:
2744: * @namespace: the URI bound to the library
2745: * @data: data associated to the library
2746: * @have: the provide function
2747: * @check: the checking function
2748: * @comp: the comparison function
2749: *
2750: * Register a new type library
2751: *
2752: * Returns 0 in case of success and -1 in case of error.
2753: */
2754: static int
2755: xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
2756: xmlRelaxNGTypeHave have,
2757: xmlRelaxNGTypeCheck check,
2758: xmlRelaxNGTypeCompare comp,
2759: xmlRelaxNGFacetCheck facet,
2760: xmlRelaxNGTypeFree freef)
2761: {
2762: xmlRelaxNGTypeLibraryPtr lib;
2763: int ret;
2764:
2765: if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) ||
2766: (check == NULL) || (comp == NULL))
2767: return (-1);
2768: if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
2769: xmlGenericError(xmlGenericErrorContext,
2770: "Relax-NG types library '%s' already registered\n",
2771: namespace);
2772: return (-1);
2773: }
2774: lib =
2775: (xmlRelaxNGTypeLibraryPtr)
2776: xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
2777: if (lib == NULL) {
2778: xmlRngVErrMemory(NULL, "adding types library\n");
2779: return (-1);
2780: }
2781: memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
2782: lib->namespace = xmlStrdup(namespace);
2783: lib->data = data;
2784: lib->have = have;
2785: lib->comp = comp;
2786: lib->check = check;
2787: lib->facet = facet;
2788: lib->freef = freef;
2789: ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib);
2790: if (ret < 0) {
2791: xmlGenericError(xmlGenericErrorContext,
2792: "Relax-NG types library failed to register '%s'\n",
2793: namespace);
2794: xmlRelaxNGFreeTypeLibrary(lib, namespace);
2795: return (-1);
2796: }
2797: return (0);
2798: }
2799:
2800: /**
2801: * xmlRelaxNGInitTypes:
2802: *
2803: * Initilize the default type libraries.
2804: *
2805: * Returns 0 in case of success and -1 in case of error.
2806: */
2807: int
2808: xmlRelaxNGInitTypes(void)
2809: {
2810: if (xmlRelaxNGTypeInitialized != 0)
2811: return (0);
2812: xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
2813: if (xmlRelaxNGRegisteredTypes == NULL) {
2814: xmlGenericError(xmlGenericErrorContext,
2815: "Failed to allocate sh table for Relax-NG types\n");
2816: return (-1);
2817: }
2818: xmlRelaxNGRegisterTypeLibrary(BAD_CAST
2819: "http://www.w3.org/2001/XMLSchema-datatypes",
2820: NULL, xmlRelaxNGSchemaTypeHave,
2821: xmlRelaxNGSchemaTypeCheck,
2822: xmlRelaxNGSchemaTypeCompare,
2823: xmlRelaxNGSchemaFacetCheck,
2824: xmlRelaxNGSchemaFreeValue);
2825: xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL,
2826: xmlRelaxNGDefaultTypeHave,
2827: xmlRelaxNGDefaultTypeCheck,
2828: xmlRelaxNGDefaultTypeCompare, NULL,
2829: NULL);
2830: xmlRelaxNGTypeInitialized = 1;
2831: return (0);
2832: }
2833:
2834: /**
2835: * xmlRelaxNGCleanupTypes:
2836: *
2837: * Cleanup the default Schemas type library associated to RelaxNG
2838: */
2839: void
2840: xmlRelaxNGCleanupTypes(void)
2841: {
2842: xmlSchemaCleanupTypes();
2843: if (xmlRelaxNGTypeInitialized == 0)
2844: return;
2845: xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
2846: xmlRelaxNGFreeTypeLibrary);
2847: xmlRelaxNGTypeInitialized = 0;
2848: }
2849:
2850: /************************************************************************
2851: * *
2852: * Compiling element content into regexp *
2853: * *
2854: * Sometime the element content can be compiled into a pure regexp, *
2855: * This allows a faster execution and streamability at that level *
2856: * *
2857: ************************************************************************/
2858:
2859: /* from automata.c but not exported */
2860: void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
2861:
2862:
2863: static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
2864: xmlRelaxNGDefinePtr def);
2865:
2866: /**
2867: * xmlRelaxNGIsCompileable:
2868: * @define: the definition to check
2869: *
2870: * Check if a definition is nullable.
2871: *
2872: * Returns 1 if yes, 0 if no and -1 in case of error
2873: */
2874: static int
2875: xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
2876: {
2877: int ret = -1;
2878:
2879: if (def == NULL) {
2880: return (-1);
2881: }
2882: if ((def->type != XML_RELAXNG_ELEMENT) &&
2883: (def->dflags & IS_COMPILABLE))
2884: return (1);
2885: if ((def->type != XML_RELAXNG_ELEMENT) &&
2886: (def->dflags & IS_NOT_COMPILABLE))
2887: return (0);
2888: switch (def->type) {
2889: case XML_RELAXNG_NOOP:
2890: ret = xmlRelaxNGIsCompileable(def->content);
2891: break;
2892: case XML_RELAXNG_TEXT:
2893: case XML_RELAXNG_EMPTY:
2894: ret = 1;
2895: break;
2896: case XML_RELAXNG_ELEMENT:
2897: /*
2898: * Check if the element content is compileable
2899: */
2900: if (((def->dflags & IS_NOT_COMPILABLE) == 0) &&
2901: ((def->dflags & IS_COMPILABLE) == 0)) {
2902: xmlRelaxNGDefinePtr list;
2903:
2904: list = def->content;
2905: while (list != NULL) {
2906: ret = xmlRelaxNGIsCompileable(list);
2907: if (ret != 1)
2908: break;
2909: list = list->next;
2910: }
2911: /*
2912: * Because the routine is recursive, we must guard against
2913: * discovering both COMPILABLE and NOT_COMPILABLE
2914: */
2915: if (ret == 0) {
2916: def->dflags &= ~IS_COMPILABLE;
2917: def->dflags |= IS_NOT_COMPILABLE;
2918: }
2919: if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE))
2920: def->dflags |= IS_COMPILABLE;
2921: #ifdef DEBUG_COMPILE
2922: if (ret == 1) {
2923: xmlGenericError(xmlGenericErrorContext,
2924: "element content for %s is compilable\n",
2925: def->name);
2926: } else if (ret == 0) {
2927: xmlGenericError(xmlGenericErrorContext,
2928: "element content for %s is not compilable\n",
2929: def->name);
2930: } else {
2931: xmlGenericError(xmlGenericErrorContext,
2932: "Problem in RelaxNGIsCompileable for element %s\n",
2933: def->name);
2934: }
2935: #endif
2936: }
2937: /*
2938: * All elements return a compileable status unless they
2939: * are generic like anyName
2940: */
2941: if ((def->nameClass != NULL) || (def->name == NULL))
2942: ret = 0;
2943: else
2944: ret = 1;
2945: return (ret);
2946: case XML_RELAXNG_REF:
2947: case XML_RELAXNG_EXTERNALREF:
2948: case XML_RELAXNG_PARENTREF:
2949: if (def->depth == -20) {
2950: return (1);
2951: } else {
2952: xmlRelaxNGDefinePtr list;
2953:
2954: def->depth = -20;
2955: list = def->content;
2956: while (list != NULL) {
2957: ret = xmlRelaxNGIsCompileable(list);
2958: if (ret != 1)
2959: break;
2960: list = list->next;
2961: }
2962: }
2963: break;
2964: case XML_RELAXNG_START:
2965: case XML_RELAXNG_OPTIONAL:
2966: case XML_RELAXNG_ZEROORMORE:
2967: case XML_RELAXNG_ONEORMORE:
2968: case XML_RELAXNG_CHOICE:
2969: case XML_RELAXNG_GROUP:
2970: case XML_RELAXNG_DEF:{
2971: xmlRelaxNGDefinePtr list;
2972:
2973: list = def->content;
2974: while (list != NULL) {
2975: ret = xmlRelaxNGIsCompileable(list);
2976: if (ret != 1)
2977: break;
2978: list = list->next;
2979: }
2980: break;
2981: }
2982: case XML_RELAXNG_EXCEPT:
2983: case XML_RELAXNG_ATTRIBUTE:
2984: case XML_RELAXNG_INTERLEAVE:
2985: case XML_RELAXNG_DATATYPE:
2986: case XML_RELAXNG_LIST:
2987: case XML_RELAXNG_PARAM:
2988: case XML_RELAXNG_VALUE:
2989: case XML_RELAXNG_NOT_ALLOWED:
2990: ret = 0;
2991: break;
2992: }
2993: if (ret == 0)
2994: def->dflags |= IS_NOT_COMPILABLE;
2995: if (ret == 1)
2996: def->dflags |= IS_COMPILABLE;
2997: #ifdef DEBUG_COMPILE
2998: if (ret == 1) {
2999: xmlGenericError(xmlGenericErrorContext,
3000: "RelaxNGIsCompileable %s : true\n",
3001: xmlRelaxNGDefName(def));
3002: } else if (ret == 0) {
3003: xmlGenericError(xmlGenericErrorContext,
3004: "RelaxNGIsCompileable %s : false\n",
3005: xmlRelaxNGDefName(def));
3006: } else {
3007: xmlGenericError(xmlGenericErrorContext,
3008: "Problem in RelaxNGIsCompileable %s\n",
3009: xmlRelaxNGDefName(def));
3010: }
3011: #endif
3012: return (ret);
3013: }
3014:
3015: /**
3016: * xmlRelaxNGCompile:
3017: * ctxt: the RelaxNG parser context
3018: * @define: the definition tree to compile
3019: *
3020: * Compile the set of definitions, it works recursively, till the
3021: * element boundaries, where it tries to compile the content if possible
3022: *
3023: * Returns 0 if success and -1 in case of error
3024: */
3025: static int
3026: xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3027: {
3028: int ret = 0;
3029: xmlRelaxNGDefinePtr list;
3030:
3031: if ((ctxt == NULL) || (def == NULL))
3032: return (-1);
3033:
3034: switch (def->type) {
3035: case XML_RELAXNG_START:
3036: if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
3037: xmlAutomataPtr oldam = ctxt->am;
3038: xmlAutomataStatePtr oldstate = ctxt->state;
3039:
3040: def->depth = -25;
3041:
3042: list = def->content;
3043: ctxt->am = xmlNewAutomata();
3044: if (ctxt->am == NULL)
3045: return (-1);
3046:
3047: /*
3048: * assume identical strings but not same pointer are different
3049: * atoms, needed for non-determinism detection
3050: * That way if 2 elements with the same name are in a choice
3051: * branch the automata is found non-deterministic and
3052: * we fallback to the normal validation which does the right
3053: * thing of exploring both choices.
3054: */
3055: xmlAutomataSetFlags(ctxt->am, 1);
3056:
3057: ctxt->state = xmlAutomataGetInitState(ctxt->am);
3058: while (list != NULL) {
3059: xmlRelaxNGCompile(ctxt, list);
3060: list = list->next;
3061: }
3062: xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3063: if (xmlAutomataIsDeterminist(ctxt->am))
3064: def->contModel = xmlAutomataCompile(ctxt->am);
3065:
3066: xmlFreeAutomata(ctxt->am);
3067: ctxt->state = oldstate;
3068: ctxt->am = oldam;
3069: }
3070: break;
3071: case XML_RELAXNG_ELEMENT:
3072: if ((ctxt->am != NULL) && (def->name != NULL)) {
3073: ctxt->state = xmlAutomataNewTransition2(ctxt->am,
3074: ctxt->state, NULL,
3075: def->name, def->ns,
3076: def);
3077: }
3078: if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
3079: xmlAutomataPtr oldam = ctxt->am;
3080: xmlAutomataStatePtr oldstate = ctxt->state;
3081:
3082: def->depth = -25;
3083:
3084: list = def->content;
3085: ctxt->am = xmlNewAutomata();
3086: if (ctxt->am == NULL)
3087: return (-1);
3088: xmlAutomataSetFlags(ctxt->am, 1);
3089: ctxt->state = xmlAutomataGetInitState(ctxt->am);
3090: while (list != NULL) {
3091: xmlRelaxNGCompile(ctxt, list);
3092: list = list->next;
3093: }
3094: xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3095: def->contModel = xmlAutomataCompile(ctxt->am);
3096: if (!xmlRegexpIsDeterminist(def->contModel)) {
3097: #ifdef DEBUG_COMPILE
3098: xmlGenericError(xmlGenericErrorContext,
3099: "Content model not determinist %s\n",
3100: def->name);
3101: #endif
3102: /*
3103: * we can only use the automata if it is determinist
3104: */
3105: xmlRegFreeRegexp(def->contModel);
3106: def->contModel = NULL;
3107: }
3108: xmlFreeAutomata(ctxt->am);
3109: ctxt->state = oldstate;
3110: ctxt->am = oldam;
3111: } else {
3112: xmlAutomataPtr oldam = ctxt->am;
3113:
3114: /*
3115: * we can't build the content model for this element content
3116: * but it still might be possible to build it for some of its
3117: * children, recurse.
3118: */
3119: ret = xmlRelaxNGTryCompile(ctxt, def);
3120: ctxt->am = oldam;
3121: }
3122: break;
3123: case XML_RELAXNG_NOOP:
3124: ret = xmlRelaxNGCompile(ctxt, def->content);
3125: break;
3126: case XML_RELAXNG_OPTIONAL:{
3127: xmlAutomataStatePtr oldstate = ctxt->state;
3128:
3129: list = def->content;
3130: while (list != NULL) {
3131: xmlRelaxNGCompile(ctxt, list);
3132: list = list->next;
3133: }
3134: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
3135: break;
3136: }
3137: case XML_RELAXNG_ZEROORMORE:{
3138: xmlAutomataStatePtr oldstate;
3139:
3140: ctxt->state =
3141: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3142: oldstate = ctxt->state;
3143: list = def->content;
3144: while (list != NULL) {
3145: xmlRelaxNGCompile(ctxt, list);
3146: list = list->next;
3147: }
3148: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3149: ctxt->state =
3150: xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3151: break;
3152: }
3153: case XML_RELAXNG_ONEORMORE:{
3154: xmlAutomataStatePtr oldstate;
3155:
3156: list = def->content;
3157: while (list != NULL) {
3158: xmlRelaxNGCompile(ctxt, list);
3159: list = list->next;
3160: }
3161: oldstate = ctxt->state;
3162: list = def->content;
3163: while (list != NULL) {
3164: xmlRelaxNGCompile(ctxt, list);
3165: list = list->next;
3166: }
3167: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3168: ctxt->state =
3169: xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3170: break;
3171: }
3172: case XML_RELAXNG_CHOICE:{
3173: xmlAutomataStatePtr target = NULL;
3174: xmlAutomataStatePtr oldstate = ctxt->state;
3175:
3176: list = def->content;
3177: while (list != NULL) {
3178: ctxt->state = oldstate;
3179: ret = xmlRelaxNGCompile(ctxt, list);
3180: if (ret != 0)
3181: break;
3182: if (target == NULL)
3183: target = ctxt->state;
3184: else {
3185: xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
3186: target);
3187: }
3188: list = list->next;
3189: }
3190: ctxt->state = target;
3191:
3192: break;
3193: }
3194: case XML_RELAXNG_REF:
3195: case XML_RELAXNG_EXTERNALREF:
3196: case XML_RELAXNG_PARENTREF:
3197: case XML_RELAXNG_GROUP:
3198: case XML_RELAXNG_DEF:
3199: list = def->content;
3200: while (list != NULL) {
3201: ret = xmlRelaxNGCompile(ctxt, list);
3202: if (ret != 0)
3203: break;
3204: list = list->next;
3205: }
3206: break;
3207: case XML_RELAXNG_TEXT:{
3208: xmlAutomataStatePtr oldstate;
3209:
3210: ctxt->state =
3211: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3212: oldstate = ctxt->state;
3213: xmlRelaxNGCompile(ctxt, def->content);
3214: xmlAutomataNewTransition(ctxt->am, ctxt->state,
3215: ctxt->state, BAD_CAST "#text",
3216: NULL);
3217: ctxt->state =
3218: xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3219: break;
3220: }
3221: case XML_RELAXNG_EMPTY:
3222: ctxt->state =
3223: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3224: break;
3225: case XML_RELAXNG_EXCEPT:
3226: case XML_RELAXNG_ATTRIBUTE:
3227: case XML_RELAXNG_INTERLEAVE:
3228: case XML_RELAXNG_NOT_ALLOWED:
3229: case XML_RELAXNG_DATATYPE:
3230: case XML_RELAXNG_LIST:
3231: case XML_RELAXNG_PARAM:
3232: case XML_RELAXNG_VALUE:
3233: /* This should not happen and generate an internal error */
3234: fprintf(stderr, "RNG internal error trying to compile %s\n",
3235: xmlRelaxNGDefName(def));
3236: break;
3237: }
3238: return (ret);
3239: }
3240:
3241: /**
3242: * xmlRelaxNGTryCompile:
3243: * ctxt: the RelaxNG parser context
3244: * @define: the definition tree to compile
3245: *
3246: * Try to compile the set of definitions, it works recursively,
3247: * possibly ignoring parts which cannot be compiled.
3248: *
3249: * Returns 0 if success and -1 in case of error
3250: */
3251: static int
3252: xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3253: {
3254: int ret = 0;
3255: xmlRelaxNGDefinePtr list;
3256:
3257: if ((ctxt == NULL) || (def == NULL))
3258: return (-1);
3259:
3260: if ((def->type == XML_RELAXNG_START) ||
3261: (def->type == XML_RELAXNG_ELEMENT)) {
3262: ret = xmlRelaxNGIsCompileable(def);
3263: if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
3264: ctxt->am = NULL;
3265: ret = xmlRelaxNGCompile(ctxt, def);
3266: #ifdef DEBUG_PROGRESSIVE
3267: if (ret == 0) {
3268: if (def->type == XML_RELAXNG_START)
3269: xmlGenericError(xmlGenericErrorContext,
3270: "compiled the start\n");
3271: else
3272: xmlGenericError(xmlGenericErrorContext,
3273: "compiled element %s\n", def->name);
3274: } else {
3275: if (def->type == XML_RELAXNG_START)
3276: xmlGenericError(xmlGenericErrorContext,
3277: "failed to compile the start\n");
3278: else
3279: xmlGenericError(xmlGenericErrorContext,
3280: "failed to compile element %s\n",
3281: def->name);
3282: }
3283: #endif
3284: return (ret);
3285: }
3286: }
3287: switch (def->type) {
3288: case XML_RELAXNG_NOOP:
3289: ret = xmlRelaxNGTryCompile(ctxt, def->content);
3290: break;
3291: case XML_RELAXNG_TEXT:
3292: case XML_RELAXNG_DATATYPE:
3293: case XML_RELAXNG_LIST:
3294: case XML_RELAXNG_PARAM:
3295: case XML_RELAXNG_VALUE:
3296: case XML_RELAXNG_EMPTY:
3297: case XML_RELAXNG_ELEMENT:
3298: ret = 0;
3299: break;
3300: case XML_RELAXNG_OPTIONAL:
3301: case XML_RELAXNG_ZEROORMORE:
3302: case XML_RELAXNG_ONEORMORE:
3303: case XML_RELAXNG_CHOICE:
3304: case XML_RELAXNG_GROUP:
3305: case XML_RELAXNG_DEF:
3306: case XML_RELAXNG_START:
3307: case XML_RELAXNG_REF:
3308: case XML_RELAXNG_EXTERNALREF:
3309: case XML_RELAXNG_PARENTREF:
3310: list = def->content;
3311: while (list != NULL) {
3312: ret = xmlRelaxNGTryCompile(ctxt, list);
3313: if (ret != 0)
3314: break;
3315: list = list->next;
3316: }
3317: break;
3318: case XML_RELAXNG_EXCEPT:
3319: case XML_RELAXNG_ATTRIBUTE:
3320: case XML_RELAXNG_INTERLEAVE:
3321: case XML_RELAXNG_NOT_ALLOWED:
3322: ret = 0;
3323: break;
3324: }
3325: return (ret);
3326: }
3327:
3328: /************************************************************************
3329: * *
3330: * Parsing functions *
3331: * *
3332: ************************************************************************/
3333:
3334: static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr
3335: ctxt, xmlNodePtr node);
3336: static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr
3337: ctxt, xmlNodePtr node);
3338: static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr
3339: ctxt, xmlNodePtr nodes,
3340: int group);
3341: static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr
3342: ctxt, xmlNodePtr node);
3343: static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
3344: xmlNodePtr node);
3345: static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
3346: xmlNodePtr nodes);
3347: static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr
3348: ctxt, xmlNodePtr node,
3349: xmlRelaxNGDefinePtr
3350: def);
3351: static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr
3352: ctxt, xmlNodePtr nodes);
3353: static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
3354: xmlRelaxNGDefinePtr define,
3355: xmlNodePtr elem);
3356:
3357:
3358: #define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content))
3359:
3360: /**
3361: * xmlRelaxNGIsNullable:
3362: * @define: the definition to verify
3363: *
3364: * Check if a definition is nullable.
3365: *
3366: * Returns 1 if yes, 0 if no and -1 in case of error
3367: */
3368: static int
3369: xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
3370: {
3371: int ret;
3372:
3373: if (define == NULL)
3374: return (-1);
3375:
3376: if (define->dflags & IS_NULLABLE)
3377: return (1);
3378: if (define->dflags & IS_NOT_NULLABLE)
3379: return (0);
3380: switch (define->type) {
3381: case XML_RELAXNG_EMPTY:
3382: case XML_RELAXNG_TEXT:
3383: ret = 1;
3384: break;
3385: case XML_RELAXNG_NOOP:
3386: case XML_RELAXNG_DEF:
3387: case XML_RELAXNG_REF:
3388: case XML_RELAXNG_EXTERNALREF:
3389: case XML_RELAXNG_PARENTREF:
3390: case XML_RELAXNG_ONEORMORE:
3391: ret = xmlRelaxNGIsNullable(define->content);
3392: break;
3393: case XML_RELAXNG_EXCEPT:
3394: case XML_RELAXNG_NOT_ALLOWED:
3395: case XML_RELAXNG_ELEMENT:
3396: case XML_RELAXNG_DATATYPE:
3397: case XML_RELAXNG_PARAM:
3398: case XML_RELAXNG_VALUE:
3399: case XML_RELAXNG_LIST:
3400: case XML_RELAXNG_ATTRIBUTE:
3401: ret = 0;
3402: break;
3403: case XML_RELAXNG_CHOICE:{
3404: xmlRelaxNGDefinePtr list = define->content;
3405:
3406: while (list != NULL) {
3407: ret = xmlRelaxNGIsNullable(list);
3408: if (ret != 0)
3409: goto done;
3410: list = list->next;
3411: }
3412: ret = 0;
3413: break;
3414: }
3415: case XML_RELAXNG_START:
3416: case XML_RELAXNG_INTERLEAVE:
3417: case XML_RELAXNG_GROUP:{
3418: xmlRelaxNGDefinePtr list = define->content;
3419:
3420: while (list != NULL) {
3421: ret = xmlRelaxNGIsNullable(list);
3422: if (ret != 1)
3423: goto done;
3424: list = list->next;
3425: }
3426: return (1);
3427: }
3428: default:
3429: return (-1);
3430: }
3431: done:
3432: if (ret == 0)
3433: define->dflags |= IS_NOT_NULLABLE;
3434: if (ret == 1)
3435: define->dflags |= IS_NULLABLE;
3436: return (ret);
3437: }
3438:
3439: /**
3440: * xmlRelaxNGIsBlank:
3441: * @str: a string
3442: *
3443: * Check if a string is ignorable c.f. 4.2. Whitespace
3444: *
3445: * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
3446: */
3447: static int
3448: xmlRelaxNGIsBlank(xmlChar * str)
3449: {
3450: if (str == NULL)
3451: return (1);
3452: while (*str != 0) {
3453: if (!(IS_BLANK_CH(*str)))
3454: return (0);
3455: str++;
3456: }
3457: return (1);
3458: }
3459:
3460: /**
3461: * xmlRelaxNGGetDataTypeLibrary:
3462: * @ctxt: a Relax-NG parser context
3463: * @node: the current data or value element
3464: *
3465: * Applies algorithm from 4.3. datatypeLibrary attribute
3466: *
3467: * Returns the datatypeLibary value or NULL if not found
3468: */
3469: static xmlChar *
3470: xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
3471: xmlNodePtr node)
3472: {
3473: xmlChar *ret, *escape;
3474:
3475: if (node == NULL)
3476: return(NULL);
3477:
3478: if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
3479: ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3480: if (ret != NULL) {
3481: if (ret[0] == 0) {
3482: xmlFree(ret);
3483: return (NULL);
3484: }
3485: escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
3486: if (escape == NULL) {
3487: return (ret);
3488: }
3489: xmlFree(ret);
3490: return (escape);
3491: }
3492: }
3493: node = node->parent;
3494: while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
3495: ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3496: if (ret != NULL) {
3497: if (ret[0] == 0) {
3498: xmlFree(ret);
3499: return (NULL);
3500: }
3501: escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
3502: if (escape == NULL) {
3503: return (ret);
3504: }
3505: xmlFree(ret);
3506: return (escape);
3507: }
3508: node = node->parent;
3509: }
3510: return (NULL);
3511: }
3512:
3513: /**
3514: * xmlRelaxNGParseValue:
3515: * @ctxt: a Relax-NG parser context
3516: * @node: the data node.
3517: *
3518: * parse the content of a RelaxNG value node.
3519: *
3520: * Returns the definition pointer or NULL in case of error
3521: */
3522: static xmlRelaxNGDefinePtr
3523: xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3524: {
3525: xmlRelaxNGDefinePtr def = NULL;
3526: xmlRelaxNGTypeLibraryPtr lib = NULL;
3527: xmlChar *type;
3528: xmlChar *library;
3529: int success = 0;
3530:
3531: def = xmlRelaxNGNewDefine(ctxt, node);
3532: if (def == NULL)
3533: return (NULL);
3534: def->type = XML_RELAXNG_VALUE;
3535:
3536: type = xmlGetProp(node, BAD_CAST "type");
3537: if (type != NULL) {
3538: xmlRelaxNGNormExtSpace(type);
3539: if (xmlValidateNCName(type, 0)) {
3540: xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3541: "value type '%s' is not an NCName\n", type, NULL);
3542: }
3543: library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3544: if (library == NULL)
3545: library =
3546: xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
3547:
3548: def->name = type;
3549: def->ns = library;
3550:
3551: lib = (xmlRelaxNGTypeLibraryPtr)
3552: xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
3553: if (lib == NULL) {
3554: xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3555: "Use of unregistered type library '%s'\n", library,
3556: NULL);
3557: def->data = NULL;
3558: } else {
3559: def->data = lib;
3560: if (lib->have == NULL) {
3561: xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3562: "Internal error with type library '%s': no 'have'\n",
3563: library, NULL);
3564: } else {
3565: success = lib->have(lib->data, def->name);
3566: if (success != 1) {
3567: xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3568: "Error type '%s' is not exported by type library '%s'\n",
3569: def->name, library);
3570: }
3571: }
3572: }
3573: }
3574: if (node->children == NULL) {
3575: def->value = xmlStrdup(BAD_CAST "");
3576: } else if (((node->children->type != XML_TEXT_NODE) &&
3577: (node->children->type != XML_CDATA_SECTION_NODE)) ||
3578: (node->children->next != NULL)) {
3579: xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3580: "Expecting a single text value for <value>content\n",
3581: NULL, NULL);
3582: } else if (def != NULL) {
3583: def->value = xmlNodeGetContent(node);
3584: if (def->value == NULL) {
3585: xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3586: "Element <value> has no content\n", NULL, NULL);
3587: } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
3588: void *val = NULL;
3589:
3590: success =
3591: lib->check(lib->data, def->name, def->value, &val, node);
3592: if (success != 1) {
3593: xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3594: "Value '%s' is not acceptable for type '%s'\n",
3595: def->value, def->name);
3596: } else {
3597: if (val != NULL)
3598: def->attrs = val;
3599: }
3600: }
3601: }
3602: return (def);
3603: }
3604:
3605: /**
3606: * xmlRelaxNGParseData:
3607: * @ctxt: a Relax-NG parser context
3608: * @node: the data node.
3609: *
3610: * parse the content of a RelaxNG data node.
3611: *
3612: * Returns the definition pointer or NULL in case of error
3613: */
3614: static xmlRelaxNGDefinePtr
3615: xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3616: {
3617: xmlRelaxNGDefinePtr def = NULL, except;
3618: xmlRelaxNGDefinePtr param, lastparam = NULL;
3619: xmlRelaxNGTypeLibraryPtr lib;
3620: xmlChar *type;
3621: xmlChar *library;
3622: xmlNodePtr content;
3623: int tmp;
3624:
3625: type = xmlGetProp(node, BAD_CAST "type");
3626: if (type == NULL) {
3627: xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
3628: NULL);
3629: return (NULL);
3630: }
3631: xmlRelaxNGNormExtSpace(type);
3632: if (xmlValidateNCName(type, 0)) {
3633: xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3634: "data type '%s' is not an NCName\n", type, NULL);
3635: }
3636: library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3637: if (library == NULL)
3638: library =
3639: xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
3640:
3641: def = xmlRelaxNGNewDefine(ctxt, node);
3642: if (def == NULL) {
3643: xmlFree(type);
3644: return (NULL);
3645: }
3646: def->type = XML_RELAXNG_DATATYPE;
3647: def->name = type;
3648: def->ns = library;
3649:
3650: lib = (xmlRelaxNGTypeLibraryPtr)
3651: xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
3652: if (lib == NULL) {
3653: xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3654: "Use of unregistered type library '%s'\n", library,
3655: NULL);
3656: def->data = NULL;
3657: } else {
3658: def->data = lib;
3659: if (lib->have == NULL) {
3660: xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3661: "Internal error with type library '%s': no 'have'\n",
3662: library, NULL);
3663: } else {
3664: tmp = lib->have(lib->data, def->name);
3665: if (tmp != 1) {
3666: xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3667: "Error type '%s' is not exported by type library '%s'\n",
3668: def->name, library);
3669: } else
3670: if ((xmlStrEqual
3671: (library,
3672: BAD_CAST
3673: "http://www.w3.org/2001/XMLSchema-datatypes"))
3674: && ((xmlStrEqual(def->name, BAD_CAST "IDREF"))
3675: || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) {
3676: ctxt->idref = 1;
3677: }
3678: }
3679: }
3680: content = node->children;
3681:
3682: /*
3683: * Handle optional params
3684: */
3685: while (content != NULL) {
3686: if (!xmlStrEqual(content->name, BAD_CAST "param"))
3687: break;
3688: if (xmlStrEqual(library,
3689: BAD_CAST "http://relaxng.org/ns/structure/1.0")) {
3690: xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
3691: "Type library '%s' does not allow type parameters\n",
3692: library, NULL);
3693: content = content->next;
3694: while ((content != NULL) &&
3695: (xmlStrEqual(content->name, BAD_CAST "param")))
3696: content = content->next;
3697: } else {
3698: param = xmlRelaxNGNewDefine(ctxt, node);
3699: if (param != NULL) {
3700: param->type = XML_RELAXNG_PARAM;
3701: param->name = xmlGetProp(content, BAD_CAST "name");
3702: if (param->name == NULL) {
3703: xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
3704: "param has no name\n", NULL, NULL);
3705: }
3706: param->value = xmlNodeGetContent(content);
3707: if (lastparam == NULL) {
3708: def->attrs = lastparam = param;
3709: } else {
3710: lastparam->next = param;
3711: lastparam = param;
3712: }
3713: if (lib != NULL) {
3714: }
3715: }
3716: content = content->next;
3717: }
3718: }
3719: /*
3720: * Handle optional except
3721: */
3722: if ((content != NULL)
3723: && (xmlStrEqual(content->name, BAD_CAST "except"))) {
3724: xmlNodePtr child;
3725: xmlRelaxNGDefinePtr tmp2, last = NULL;
3726:
3727: except = xmlRelaxNGNewDefine(ctxt, node);
3728: if (except == NULL) {
3729: return (def);
3730: }
3731: except->type = XML_RELAXNG_EXCEPT;
3732: child = content->children;
3733: def->content = except;
3734: if (child == NULL) {
3735: xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
3736: "except has no content\n", NULL, NULL);
3737: }
3738: while (child != NULL) {
3739: tmp2 = xmlRelaxNGParsePattern(ctxt, child);
3740: if (tmp2 != NULL) {
3741: if (last == NULL) {
3742: except->content = last = tmp2;
3743: } else {
3744: last->next = tmp2;
3745: last = tmp2;
3746: }
3747: }
3748: child = child->next;
3749: }
3750: content = content->next;
3751: }
3752: /*
3753: * Check there is no unhandled data
3754: */
3755: if (content != NULL) {
3756: xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
3757: "Element data has unexpected content %s\n",
3758: content->name, NULL);
3759: }
3760:
3761: return (def);
3762: }
3763:
3764: static const xmlChar *invalidName = BAD_CAST "\1";
3765:
3766: /**
3767: * xmlRelaxNGCompareNameClasses:
3768: * @defs1: the first element/attribute defs
3769: * @defs2: the second element/attribute defs
3770: * @name: the restriction on the name
3771: * @ns: the restriction on the namespace
3772: *
3773: * Compare the 2 lists of element definitions. The comparison is
3774: * that if both lists do not accept the same QNames, it returns 1
3775: * If the 2 lists can accept the same QName the comparison returns 0
3776: *
3777: * Returns 1 disttinct, 0 if equal
3778: */
3779: static int
3780: xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
3781: xmlRelaxNGDefinePtr def2)
3782: {
3783: int ret = 1;
3784: xmlNode node;
3785: xmlNs ns;
3786: xmlRelaxNGValidCtxt ctxt;
3787:
3788: memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
3789:
3790: ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
3791:
3792: if ((def1->type == XML_RELAXNG_ELEMENT) ||
3793: (def1->type == XML_RELAXNG_ATTRIBUTE)) {
3794: if (def2->type == XML_RELAXNG_TEXT)
3795: return (1);
3796: if (def1->name != NULL) {
3797: node.name = def1->name;
3798: } else {
3799: node.name = invalidName;
3800: }
3801: if (def1->ns != NULL) {
3802: if (def1->ns[0] == 0) {
3803: node.ns = NULL;
3804: } else {
3805: node.ns = &ns;
3806: ns.href = def1->ns;
3807: }
3808: } else {
3809: node.ns = NULL;
3810: }
3811: if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3812: if (def1->nameClass != NULL) {
3813: ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
3814: } else {
3815: ret = 0;
3816: }
3817: } else {
3818: ret = 1;
3819: }
3820: } else if (def1->type == XML_RELAXNG_TEXT) {
3821: if (def2->type == XML_RELAXNG_TEXT)
3822: return (0);
3823: return (1);
3824: } else if (def1->type == XML_RELAXNG_EXCEPT) {
3825: TODO ret = 0;
3826: } else {
3827: TODO ret = 0;
3828: }
3829: if (ret == 0)
3830: return (ret);
3831: if ((def2->type == XML_RELAXNG_ELEMENT) ||
3832: (def2->type == XML_RELAXNG_ATTRIBUTE)) {
3833: if (def2->name != NULL) {
3834: node.name = def2->name;
3835: } else {
3836: node.name = invalidName;
3837: }
3838: node.ns = &ns;
3839: if (def2->ns != NULL) {
3840: if (def2->ns[0] == 0) {
3841: node.ns = NULL;
3842: } else {
3843: ns.href = def2->ns;
3844: }
3845: } else {
3846: ns.href = invalidName;
3847: }
3848: if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
3849: if (def2->nameClass != NULL) {
3850: ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
3851: } else {
3852: ret = 0;
3853: }
3854: } else {
3855: ret = 1;
3856: }
3857: } else {
3858: TODO ret = 0;
3859: }
3860:
3861: return (ret);
3862: }
3863:
3864: /**
3865: * xmlRelaxNGCompareElemDefLists:
3866: * @ctxt: a Relax-NG parser context
3867: * @defs1: the first list of element/attribute defs
3868: * @defs2: the second list of element/attribute defs
3869: *
3870: * Compare the 2 lists of element or attribute definitions. The comparison
3871: * is that if both lists do not accept the same QNames, it returns 1
3872: * If the 2 lists can accept the same QName the comparison returns 0
3873: *
3874: * Returns 1 disttinct, 0 if equal
3875: */
3876: static int
3877: xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
3878: ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
3879: xmlRelaxNGDefinePtr * def2)
3880: {
3881: xmlRelaxNGDefinePtr *basedef2 = def2;
3882:
3883: if ((def1 == NULL) || (def2 == NULL))
3884: return (1);
3885: if ((*def1 == NULL) || (*def2 == NULL))
3886: return (1);
3887: while (*def1 != NULL) {
3888: while ((*def2) != NULL) {
3889: if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
3890: return (0);
3891: def2++;
3892: }
3893: def2 = basedef2;
3894: def1++;
3895: }
3896: return (1);
3897: }
3898:
3899: /**
3900: * xmlRelaxNGGenerateAttributes:
3901: * @ctxt: a Relax-NG parser context
3902: * @def: the definition definition
3903: *
3904: * Check if the definition can only generate attributes
3905: *
3906: * Returns 1 if yes, 0 if no and -1 in case of error.
3907: */
3908: static int
3909: xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
3910: xmlRelaxNGDefinePtr def)
3911: {
3912: xmlRelaxNGDefinePtr parent, cur, tmp;
3913:
3914: /*
3915: * Don't run that check in case of error. Infinite recursion
3916: * becomes possible.
3917: */
3918: if (ctxt->nbErrors != 0)
3919: return (-1);
3920:
3921: parent = NULL;
3922: cur = def;
3923: while (cur != NULL) {
3924: if ((cur->type == XML_RELAXNG_ELEMENT) ||
3925: (cur->type == XML_RELAXNG_TEXT) ||
3926: (cur->type == XML_RELAXNG_DATATYPE) ||
3927: (cur->type == XML_RELAXNG_PARAM) ||
3928: (cur->type == XML_RELAXNG_LIST) ||
3929: (cur->type == XML_RELAXNG_VALUE) ||
3930: (cur->type == XML_RELAXNG_EMPTY))
3931: return (0);
3932: if ((cur->type == XML_RELAXNG_CHOICE) ||
3933: (cur->type == XML_RELAXNG_INTERLEAVE) ||
3934: (cur->type == XML_RELAXNG_GROUP) ||
3935: (cur->type == XML_RELAXNG_ONEORMORE) ||
3936: (cur->type == XML_RELAXNG_ZEROORMORE) ||
3937: (cur->type == XML_RELAXNG_OPTIONAL) ||
3938: (cur->type == XML_RELAXNG_PARENTREF) ||
3939: (cur->type == XML_RELAXNG_EXTERNALREF) ||
3940: (cur->type == XML_RELAXNG_REF) ||
3941: (cur->type == XML_RELAXNG_DEF)) {
3942: if (cur->content != NULL) {
3943: parent = cur;
3944: cur = cur->content;
3945: tmp = cur;
3946: while (tmp != NULL) {
3947: tmp->parent = parent;
3948: tmp = tmp->next;
3949: }
3950: continue;
3951: }
3952: }
3953: if (cur == def)
3954: break;
3955: if (cur->next != NULL) {
3956: cur = cur->next;
3957: continue;
3958: }
3959: do {
3960: cur = cur->parent;
3961: if (cur == NULL)
3962: break;
3963: if (cur == def)
3964: return (1);
3965: if (cur->next != NULL) {
3966: cur = cur->next;
3967: break;
3968: }
3969: } while (cur != NULL);
3970: }
3971: return (1);
3972: }
3973:
3974: /**
3975: * xmlRelaxNGGetElements:
3976: * @ctxt: a Relax-NG parser context
3977: * @def: the definition definition
3978: * @eora: gather elements (0) or attributes (1)
3979: *
3980: * Compute the list of top elements a definition can generate
3981: *
3982: * Returns a list of elements or NULL if none was found.
3983: */
3984: static xmlRelaxNGDefinePtr *
3985: xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
3986: xmlRelaxNGDefinePtr def, int eora)
3987: {
3988: xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
3989: int len = 0;
3990: int max = 0;
3991:
3992: /*
3993: * Don't run that check in case of error. Infinite recursion
3994: * becomes possible.
3995: */
3996: if (ctxt->nbErrors != 0)
3997: return (NULL);
3998:
3999: parent = NULL;
4000: cur = def;
4001: while (cur != NULL) {
4002: if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) ||
4003: (cur->type == XML_RELAXNG_TEXT))) ||
4004: ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) {
4005: if (ret == NULL) {
4006: max = 10;
4007: ret = (xmlRelaxNGDefinePtr *)
4008: xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr));
4009: if (ret == NULL) {
4010: xmlRngPErrMemory(ctxt, "getting element list\n");
4011: return (NULL);
4012: }
4013: } else if (max <= len) {
4014: xmlRelaxNGDefinePtr *temp;
4015:
4016: max *= 2;
4017: temp = xmlRealloc(ret,
4018: (max + 1) * sizeof(xmlRelaxNGDefinePtr));
4019: if (temp == NULL) {
4020: xmlRngPErrMemory(ctxt, "getting element list\n");
4021: xmlFree(ret);
4022: return (NULL);
4023: }
4024: ret = temp;
4025: }
4026: ret[len++] = cur;
4027: ret[len] = NULL;
4028: } else if ((cur->type == XML_RELAXNG_CHOICE) ||
4029: (cur->type == XML_RELAXNG_INTERLEAVE) ||
4030: (cur->type == XML_RELAXNG_GROUP) ||
4031: (cur->type == XML_RELAXNG_ONEORMORE) ||
4032: (cur->type == XML_RELAXNG_ZEROORMORE) ||
4033: (cur->type == XML_RELAXNG_OPTIONAL) ||
4034: (cur->type == XML_RELAXNG_PARENTREF) ||
4035: (cur->type == XML_RELAXNG_REF) ||
4036: (cur->type == XML_RELAXNG_DEF) ||
4037: (cur->type == XML_RELAXNG_EXTERNALREF)) {
4038: /*
4039: * Don't go within elements or attributes or string values.
4040: * Just gather the element top list
4041: */
4042: if (cur->content != NULL) {
4043: parent = cur;
4044: cur = cur->content;
4045: tmp = cur;
4046: while (tmp != NULL) {
4047: tmp->parent = parent;
4048: tmp = tmp->next;
4049: }
4050: continue;
4051: }
4052: }
4053: if (cur == def)
4054: break;
4055: if (cur->next != NULL) {
4056: cur = cur->next;
4057: continue;
4058: }
4059: do {
4060: cur = cur->parent;
4061: if (cur == NULL)
4062: break;
4063: if (cur == def)
4064: return (ret);
4065: if (cur->next != NULL) {
4066: cur = cur->next;
4067: break;
4068: }
4069: } while (cur != NULL);
4070: }
4071: return (ret);
4072: }
4073:
4074: /**
4075: * xmlRelaxNGCheckChoiceDeterminism:
4076: * @ctxt: a Relax-NG parser context
4077: * @def: the choice definition
4078: *
4079: * Also used to find indeterministic pattern in choice
4080: */
4081: static void
4082: xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
4083: xmlRelaxNGDefinePtr def)
4084: {
4085: xmlRelaxNGDefinePtr **list;
4086: xmlRelaxNGDefinePtr cur;
4087: int nbchild = 0, i, j, ret;
4088: int is_nullable = 0;
4089: int is_indeterminist = 0;
4090: xmlHashTablePtr triage = NULL;
4091: int is_triable = 1;
4092:
4093: if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
4094: return;
4095:
4096: if (def->dflags & IS_PROCESSED)
4097: return;
4098:
4099: /*
4100: * Don't run that check in case of error. Infinite recursion
4101: * becomes possible.
4102: */
4103: if (ctxt->nbErrors != 0)
4104: return;
4105:
4106: is_nullable = xmlRelaxNGIsNullable(def);
4107:
4108: cur = def->content;
4109: while (cur != NULL) {
4110: nbchild++;
4111: cur = cur->next;
4112: }
4113:
4114: list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
4115: sizeof(xmlRelaxNGDefinePtr
4116: *));
4117: if (list == NULL) {
4118: xmlRngPErrMemory(ctxt, "building choice\n");
4119: return;
4120: }
4121: i = 0;
4122: /*
4123: * a bit strong but safe
4124: */
4125: if (is_nullable == 0) {
4126: triage = xmlHashCreate(10);
4127: } else {
4128: is_triable = 0;
4129: }
4130: cur = def->content;
4131: while (cur != NULL) {
4132: list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
4133: if ((list[i] == NULL) || (list[i][0] == NULL)) {
4134: is_triable = 0;
4135: } else if (is_triable == 1) {
4136: xmlRelaxNGDefinePtr *tmp;
4137: int res;
4138:
4139: tmp = list[i];
4140: while ((*tmp != NULL) && (is_triable == 1)) {
4141: if ((*tmp)->type == XML_RELAXNG_TEXT) {
4142: res = xmlHashAddEntry2(triage,
4143: BAD_CAST "#text", NULL,
4144: (void *) cur);
4145: if (res != 0)
4146: is_triable = -1;
4147: } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
4148: ((*tmp)->name != NULL)) {
4149: if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4150: res = xmlHashAddEntry2(triage,
4151: (*tmp)->name, NULL,
4152: (void *) cur);
4153: else
4154: res = xmlHashAddEntry2(triage,
4155: (*tmp)->name, (*tmp)->ns,
4156: (void *) cur);
4157: if (res != 0)
4158: is_triable = -1;
4159: } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
4160: if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4161: res = xmlHashAddEntry2(triage,
4162: BAD_CAST "#any", NULL,
4163: (void *) cur);
4164: else
4165: res = xmlHashAddEntry2(triage,
4166: BAD_CAST "#any", (*tmp)->ns,
4167: (void *) cur);
4168: if (res != 0)
4169: is_triable = -1;
4170: } else {
4171: is_triable = -1;
4172: }
4173: tmp++;
4174: }
4175: }
4176: i++;
4177: cur = cur->next;
4178: }
4179:
4180: for (i = 0; i < nbchild; i++) {
4181: if (list[i] == NULL)
4182: continue;
4183: for (j = 0; j < i; j++) {
4184: if (list[j] == NULL)
4185: continue;
4186: ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4187: if (ret == 0) {
4188: is_indeterminist = 1;
4189: }
4190: }
4191: }
4192: for (i = 0; i < nbchild; i++) {
4193: if (list[i] != NULL)
4194: xmlFree(list[i]);
4195: }
4196:
4197: xmlFree(list);
4198: if (is_indeterminist) {
4199: def->dflags |= IS_INDETERMINIST;
4200: }
4201: if (is_triable == 1) {
4202: def->dflags |= IS_TRIABLE;
4203: def->data = triage;
4204: } else if (triage != NULL) {
4205: xmlHashFree(triage, NULL);
4206: }
4207: def->dflags |= IS_PROCESSED;
4208: }
4209:
4210: /**
4211: * xmlRelaxNGCheckGroupAttrs:
4212: * @ctxt: a Relax-NG parser context
4213: * @def: the group definition
4214: *
4215: * Detects violations of rule 7.3
4216: */
4217: static void
4218: xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
4219: xmlRelaxNGDefinePtr def)
4220: {
4221: xmlRelaxNGDefinePtr **list;
4222: xmlRelaxNGDefinePtr cur;
4223: int nbchild = 0, i, j, ret;
4224:
4225: if ((def == NULL) ||
4226: ((def->type != XML_RELAXNG_GROUP) &&
4227: (def->type != XML_RELAXNG_ELEMENT)))
4228: return;
4229:
4230: if (def->dflags & IS_PROCESSED)
4231: return;
4232:
4233: /*
4234: * Don't run that check in case of error. Infinite recursion
4235: * becomes possible.
4236: */
4237: if (ctxt->nbErrors != 0)
4238: return;
4239:
4240: cur = def->attrs;
4241: while (cur != NULL) {
4242: nbchild++;
4243: cur = cur->next;
4244: }
4245: cur = def->content;
4246: while (cur != NULL) {
4247: nbchild++;
4248: cur = cur->next;
4249: }
4250:
4251: list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
4252: sizeof(xmlRelaxNGDefinePtr
4253: *));
4254: if (list == NULL) {
4255: xmlRngPErrMemory(ctxt, "building group\n");
4256: return;
4257: }
4258: i = 0;
4259: cur = def->attrs;
4260: while (cur != NULL) {
4261: list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4262: i++;
4263: cur = cur->next;
4264: }
4265: cur = def->content;
4266: while (cur != NULL) {
4267: list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4268: i++;
4269: cur = cur->next;
4270: }
4271:
4272: for (i = 0; i < nbchild; i++) {
4273: if (list[i] == NULL)
4274: continue;
4275: for (j = 0; j < i; j++) {
4276: if (list[j] == NULL)
4277: continue;
4278: ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4279: if (ret == 0) {
4280: xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4281: "Attributes conflicts in group\n", NULL, NULL);
4282: }
4283: }
4284: }
4285: for (i = 0; i < nbchild; i++) {
4286: if (list[i] != NULL)
4287: xmlFree(list[i]);
4288: }
4289:
4290: xmlFree(list);
4291: def->dflags |= IS_PROCESSED;
4292: }
4293:
4294: /**
4295: * xmlRelaxNGComputeInterleaves:
4296: * @def: the interleave definition
4297: * @ctxt: a Relax-NG parser context
4298: * @name: the definition name
4299: *
4300: * A lot of work for preprocessing interleave definitions
4301: * is potentially needed to get a decent execution speed at runtime
4302: * - trying to get a total order on the element nodes generated
4303: * by the interleaves, order the list of interleave definitions
4304: * following that order.
4305: * - if <text/> is used to handle mixed content, it is better to
4306: * flag this in the define and simplify the runtime checking
4307: * algorithm
4308: */
4309: static void
4310: xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
4311: xmlRelaxNGParserCtxtPtr ctxt,
4312: xmlChar * name ATTRIBUTE_UNUSED)
4313: {
4314: xmlRelaxNGDefinePtr cur, *tmp;
4315:
4316: xmlRelaxNGPartitionPtr partitions = NULL;
4317: xmlRelaxNGInterleaveGroupPtr *groups = NULL;
4318: xmlRelaxNGInterleaveGroupPtr group;
4319: int i, j, ret, res;
4320: int nbgroups = 0;
4321: int nbchild = 0;
4322: int is_mixed = 0;
4323: int is_determinist = 1;
4324:
4325: /*
4326: * Don't run that check in case of error. Infinite recursion
4327: * becomes possible.
4328: */
4329: if (ctxt->nbErrors != 0)
4330: return;
4331:
4332: #ifdef DEBUG_INTERLEAVE
4333: xmlGenericError(xmlGenericErrorContext,
4334: "xmlRelaxNGComputeInterleaves(%s)\n", name);
4335: #endif
4336: cur = def->content;
4337: while (cur != NULL) {
4338: nbchild++;
4339: cur = cur->next;
4340: }
4341:
4342: #ifdef DEBUG_INTERLEAVE
4343: xmlGenericError(xmlGenericErrorContext, " %d child\n", nbchild);
4344: #endif
4345: groups = (xmlRelaxNGInterleaveGroupPtr *)
4346: xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
4347: if (groups == NULL)
4348: goto error;
4349: cur = def->content;
4350: while (cur != NULL) {
4351: groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr)
4352: xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup));
4353: if (groups[nbgroups] == NULL)
4354: goto error;
4355: if (cur->type == XML_RELAXNG_TEXT)
4356: is_mixed++;
4357: groups[nbgroups]->rule = cur;
4358: groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
4359: groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
4360: nbgroups++;
4361: cur = cur->next;
4362: }
4363: #ifdef DEBUG_INTERLEAVE
4364: xmlGenericError(xmlGenericErrorContext, " %d groups\n", nbgroups);
4365: #endif
4366:
4367: /*
4368: * Let's check that all rules makes a partitions according to 7.4
4369: */
4370: partitions = (xmlRelaxNGPartitionPtr)
4371: xmlMalloc(sizeof(xmlRelaxNGPartition));
4372: if (partitions == NULL)
4373: goto error;
4374: memset(partitions, 0, sizeof(xmlRelaxNGPartition));
4375: partitions->nbgroups = nbgroups;
4376: partitions->triage = xmlHashCreate(nbgroups);
4377: for (i = 0; i < nbgroups; i++) {
4378: group = groups[i];
4379: for (j = i + 1; j < nbgroups; j++) {
4380: if (groups[j] == NULL)
4381: continue;
4382:
4383: ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
4384: groups[j]->defs);
4385: if (ret == 0) {
4386: xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4387: "Element or text conflicts in interleave\n",
4388: NULL, NULL);
4389: }
4390: ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
4391: groups[j]->attrs);
4392: if (ret == 0) {
4393: xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4394: "Attributes conflicts in interleave\n", NULL,
4395: NULL);
4396: }
4397: }
4398: tmp = group->defs;
4399: if ((tmp != NULL) && (*tmp != NULL)) {
4400: while (*tmp != NULL) {
4401: if ((*tmp)->type == XML_RELAXNG_TEXT) {
4402: res = xmlHashAddEntry2(partitions->triage,
4403: BAD_CAST "#text", NULL,
4404: (void *) (long) (i + 1));
4405: if (res != 0)
4406: is_determinist = -1;
4407: } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
4408: ((*tmp)->name != NULL)) {
4409: if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4410: res = xmlHashAddEntry2(partitions->triage,
4411: (*tmp)->name, NULL,
4412: (void *) (long) (i + 1));
4413: else
4414: res = xmlHashAddEntry2(partitions->triage,
4415: (*tmp)->name, (*tmp)->ns,
4416: (void *) (long) (i + 1));
4417: if (res != 0)
4418: is_determinist = -1;
4419: } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
4420: if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4421: res = xmlHashAddEntry2(partitions->triage,
4422: BAD_CAST "#any", NULL,
4423: (void *) (long) (i + 1));
4424: else
4425: res = xmlHashAddEntry2(partitions->triage,
4426: BAD_CAST "#any", (*tmp)->ns,
4427: (void *) (long) (i + 1));
4428: if ((*tmp)->nameClass != NULL)
4429: is_determinist = 2;
4430: if (res != 0)
4431: is_determinist = -1;
4432: } else {
4433: is_determinist = -1;
4434: }
4435: tmp++;
4436: }
4437: } else {
4438: is_determinist = 0;
4439: }
4440: }
4441: partitions->groups = groups;
4442:
4443: /*
4444: * and save the partition list back in the def
4445: */
4446: def->data = partitions;
4447: if (is_mixed != 0)
4448: def->dflags |= IS_MIXED;
4449: if (is_determinist == 1)
4450: partitions->flags = IS_DETERMINIST;
4451: if (is_determinist == 2)
4452: partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
4453: return;
4454:
4455: error:
4456: xmlRngPErrMemory(ctxt, "in interleave computation\n");
4457: if (groups != NULL) {
4458: for (i = 0; i < nbgroups; i++)
4459: if (groups[i] != NULL) {
4460: if (groups[i]->defs != NULL)
4461: xmlFree(groups[i]->defs);
4462: xmlFree(groups[i]);
4463: }
4464: xmlFree(groups);
4465: }
4466: xmlRelaxNGFreePartition(partitions);
4467: }
4468:
4469: /**
4470: * xmlRelaxNGParseInterleave:
4471: * @ctxt: a Relax-NG parser context
4472: * @node: the data node.
4473: *
4474: * parse the content of a RelaxNG interleave node.
4475: *
4476: * Returns the definition pointer or NULL in case of error
4477: */
4478: static xmlRelaxNGDefinePtr
4479: xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4480: {
4481: xmlRelaxNGDefinePtr def = NULL;
4482: xmlRelaxNGDefinePtr last = NULL, cur;
4483: xmlNodePtr child;
4484:
4485: def = xmlRelaxNGNewDefine(ctxt, node);
4486: if (def == NULL) {
4487: return (NULL);
4488: }
4489: def->type = XML_RELAXNG_INTERLEAVE;
4490:
4491: if (ctxt->interleaves == NULL)
4492: ctxt->interleaves = xmlHashCreate(10);
4493: if (ctxt->interleaves == NULL) {
4494: xmlRngPErrMemory(ctxt, "create interleaves\n");
4495: } else {
4496: char name[32];
4497:
4498: snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
4499: if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
4500: xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4501: "Failed to add %s to hash table\n",
4502: (const xmlChar *) name, NULL);
4503: }
4504: }
4505: child = node->children;
4506: if (child == NULL) {
4507: xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4508: "Element interleave is empty\n", NULL, NULL);
4509: }
4510: while (child != NULL) {
4511: if (IS_RELAXNG(child, "element")) {
4512: cur = xmlRelaxNGParseElement(ctxt, child);
4513: } else {
4514: cur = xmlRelaxNGParsePattern(ctxt, child);
4515: }
4516: if (cur != NULL) {
4517: cur->parent = def;
4518: if (last == NULL) {
4519: def->content = last = cur;
4520: } else {
4521: last->next = cur;
4522: last = cur;
4523: }
4524: }
4525: child = child->next;
4526: }
4527:
4528: return (def);
4529: }
4530:
4531: /**
4532: * xmlRelaxNGParseInclude:
4533: * @ctxt: a Relax-NG parser context
4534: * @node: the include node
4535: *
4536: * Integrate the content of an include node in the current grammar
4537: *
4538: * Returns 0 in case of success or -1 in case of error
4539: */
4540: static int
4541: xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4542: {
4543: xmlRelaxNGIncludePtr incl;
4544: xmlNodePtr root;
4545: int ret = 0, tmp;
4546:
4547: incl = node->psvi;
4548: if (incl == NULL) {
4549: xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4550: "Include node has no data\n", NULL, NULL);
4551: return (-1);
4552: }
4553: root = xmlDocGetRootElement(incl->doc);
4554: if (root == NULL) {
4555: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4556: NULL, NULL);
4557: return (-1);
4558: }
4559: if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
4560: xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4561: "Include document root is not a grammar\n", NULL, NULL);
4562: return (-1);
4563: }
4564:
4565: /*
4566: * Merge the definition from both the include and the internal list
4567: */
4568: if (root->children != NULL) {
4569: tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
4570: if (tmp != 0)
4571: ret = -1;
4572: }
4573: if (node->children != NULL) {
4574: tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4575: if (tmp != 0)
4576: ret = -1;
4577: }
4578: return (ret);
4579: }
4580:
4581: /**
4582: * xmlRelaxNGParseDefine:
4583: * @ctxt: a Relax-NG parser context
4584: * @node: the define node
4585: *
4586: * parse the content of a RelaxNG define element node.
4587: *
4588: * Returns 0 in case of success or -1 in case of error
4589: */
4590: static int
4591: xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4592: {
4593: xmlChar *name;
4594: int ret = 0, tmp;
4595: xmlRelaxNGDefinePtr def;
4596: const xmlChar *olddefine;
4597:
4598: name = xmlGetProp(node, BAD_CAST "name");
4599: if (name == NULL) {
4600: xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4601: "define has no name\n", NULL, NULL);
4602: } else {
4603: xmlRelaxNGNormExtSpace(name);
4604: if (xmlValidateNCName(name, 0)) {
4605: xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4606: "define name '%s' is not an NCName\n", name, NULL);
4607: }
4608: def = xmlRelaxNGNewDefine(ctxt, node);
4609: if (def == NULL) {
4610: xmlFree(name);
4611: return (-1);
4612: }
4613: def->type = XML_RELAXNG_DEF;
4614: def->name = name;
4615: if (node->children == NULL) {
4616: xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4617: "define has no children\n", NULL, NULL);
4618: } else {
4619: olddefine = ctxt->define;
4620: ctxt->define = name;
4621: def->content =
4622: xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4623: ctxt->define = olddefine;
4624: }
4625: if (ctxt->grammar->defs == NULL)
4626: ctxt->grammar->defs = xmlHashCreate(10);
4627: if (ctxt->grammar->defs == NULL) {
4628: xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4629: "Could not create definition hash\n", NULL, NULL);
4630: ret = -1;
4631: } else {
4632: tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
4633: if (tmp < 0) {
4634: xmlRelaxNGDefinePtr prev;
4635:
4636: prev = xmlHashLookup(ctxt->grammar->defs, name);
4637: if (prev == NULL) {
4638: xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4639: "Internal error on define aggregation of %s\n",
4640: name, NULL);
4641: ret = -1;
4642: } else {
4643: while (prev->nextHash != NULL)
4644: prev = prev->nextHash;
4645: prev->nextHash = def;
4646: }
4647: }
4648: }
4649: }
4650: return (ret);
4651: }
4652:
4653: /**
4654: * xmlRelaxNGParseImportRef:
4655: * @payload: the parser context
4656: * @data: the current grammar
4657: * @name: the reference name
4658: *
4659: * Import import one references into the current grammar
4660: */
4661: static void
4662: xmlRelaxNGParseImportRef(void *payload, void *data, xmlChar *name) {
4663: xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
4664: xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
4665: int tmp;
4666:
4667: def->dflags |= IS_EXTERNAL_REF;
4668:
4669: tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def);
4670: if (tmp < 0) {
4671: xmlRelaxNGDefinePtr prev;
4672:
4673: prev = (xmlRelaxNGDefinePtr)
4674: xmlHashLookup(ctxt->grammar->refs, def->name);
4675: if (prev == NULL) {
4676: if (def->name != NULL) {
4677: xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4678: "Error refs definitions '%s'\n",
4679: def->name, NULL);
4680: } else {
4681: xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4682: "Error refs definitions\n",
4683: NULL, NULL);
4684: }
4685: } else {
4686: def->nextHash = prev->nextHash;
4687: prev->nextHash = def;
4688: }
4689: }
4690: }
4691:
4692: /**
4693: * xmlRelaxNGParseImportRefs:
4694: * @ctxt: the parser context
4695: * @grammar: the sub grammar
4696: *
4697: * Import references from the subgrammar into the current grammar
4698: *
4699: * Returns 0 in case of success, -1 in case of failure
4700: */
4701: static int
4702: xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt,
4703: xmlRelaxNGGrammarPtr grammar) {
4704: if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL))
4705: return(-1);
4706: if (grammar->refs == NULL)
4707: return(0);
4708: if (ctxt->grammar->refs == NULL)
4709: ctxt->grammar->refs = xmlHashCreate(10);
4710: if (ctxt->grammar->refs == NULL) {
4711: xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4712: "Could not create references hash\n", NULL, NULL);
4713: return(-1);
4714: }
4715: xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt);
4716: return(0);
4717: }
4718:
4719: /**
4720: * xmlRelaxNGProcessExternalRef:
4721: * @ctxt: the parser context
4722: * @node: the externlRef node
4723: *
4724: * Process and compile an externlRef node
4725: *
4726: * Returns the xmlRelaxNGDefinePtr or NULL in case of error
4727: */
4728: static xmlRelaxNGDefinePtr
4729: xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4730: {
4731: xmlRelaxNGDocumentPtr docu;
4732: xmlNodePtr root, tmp;
4733: xmlChar *ns;
4734: int newNs = 0, oldflags;
4735: xmlRelaxNGDefinePtr def;
4736:
4737: docu = node->psvi;
4738: if (docu != NULL) {
4739: def = xmlRelaxNGNewDefine(ctxt, node);
4740: if (def == NULL)
4741: return (NULL);
4742: def->type = XML_RELAXNG_EXTERNALREF;
4743:
4744: if (docu->content == NULL) {
4745: /*
4746: * Then do the parsing for good
4747: */
4748: root = xmlDocGetRootElement(docu->doc);
4749: if (root == NULL) {
4750: xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4751: "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
4752: NULL);
4753: return (NULL);
4754: }
4755: /*
4756: * ns transmission rules
4757: */
4758: ns = xmlGetProp(root, BAD_CAST "ns");
4759: if (ns == NULL) {
4760: tmp = node;
4761: while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) {
4762: ns = xmlGetProp(tmp, BAD_CAST "ns");
4763: if (ns != NULL) {
4764: break;
4765: }
4766: tmp = tmp->parent;
4767: }
4768: if (ns != NULL) {
4769: xmlSetProp(root, BAD_CAST "ns", ns);
4770: newNs = 1;
4771: xmlFree(ns);
4772: }
4773: } else {
4774: xmlFree(ns);
4775: }
4776:
4777: /*
4778: * Parsing to get a precompiled schemas.
4779: */
4780: oldflags = ctxt->flags;
4781: ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
4782: docu->schema = xmlRelaxNGParseDocument(ctxt, root);
4783: ctxt->flags = oldflags;
4784: if ((docu->schema != NULL) &&
4785: (docu->schema->topgrammar != NULL)) {
4786: docu->content = docu->schema->topgrammar->start;
4787: if (docu->schema->topgrammar->refs)
4788: xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar);
4789: }
4790:
4791: /*
4792: * the externalRef may be reused in a different ns context
4793: */
4794: if (newNs == 1) {
4795: xmlUnsetProp(root, BAD_CAST "ns");
4796: }
4797: }
4798: def->content = docu->content;
4799: } else {
4800: def = NULL;
4801: }
4802: return (def);
4803: }
4804:
4805: /**
4806: * xmlRelaxNGParsePattern:
4807: * @ctxt: a Relax-NG parser context
4808: * @node: the pattern node.
4809: *
4810: * parse the content of a RelaxNG pattern node.
4811: *
4812: * Returns the definition pointer or NULL in case of error or if no
4813: * pattern is generated.
4814: */
4815: static xmlRelaxNGDefinePtr
4816: xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4817: {
4818: xmlRelaxNGDefinePtr def = NULL;
4819:
4820: if (node == NULL) {
4821: return (NULL);
4822: }
4823: if (IS_RELAXNG(node, "element")) {
4824: def = xmlRelaxNGParseElement(ctxt, node);
4825: } else if (IS_RELAXNG(node, "attribute")) {
4826: def = xmlRelaxNGParseAttribute(ctxt, node);
4827: } else if (IS_RELAXNG(node, "empty")) {
4828: def = xmlRelaxNGNewDefine(ctxt, node);
4829: if (def == NULL)
4830: return (NULL);
4831: def->type = XML_RELAXNG_EMPTY;
4832: if (node->children != NULL) {
4833: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4834: "empty: had a child node\n", NULL, NULL);
4835: }
4836: } else if (IS_RELAXNG(node, "text")) {
4837: def = xmlRelaxNGNewDefine(ctxt, node);
4838: if (def == NULL)
4839: return (NULL);
4840: def->type = XML_RELAXNG_TEXT;
4841: if (node->children != NULL) {
4842: xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4843: "text: had a child node\n", NULL, NULL);
4844: }
4845: } else if (IS_RELAXNG(node, "zeroOrMore")) {
4846: def = xmlRelaxNGNewDefine(ctxt, node);
4847: if (def == NULL)
4848: return (NULL);
4849: def->type = XML_RELAXNG_ZEROORMORE;
4850: if (node->children == NULL) {
4851: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4852: "Element %s is empty\n", node->name, NULL);
4853: } else {
4854: def->content =
4855: xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4856: }
4857: } else if (IS_RELAXNG(node, "oneOrMore")) {
4858: def = xmlRelaxNGNewDefine(ctxt, node);
4859: if (def == NULL)
4860: return (NULL);
4861: def->type = XML_RELAXNG_ONEORMORE;
4862: if (node->children == NULL) {
4863: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4864: "Element %s is empty\n", node->name, NULL);
4865: } else {
4866: def->content =
4867: xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4868: }
4869: } else if (IS_RELAXNG(node, "optional")) {
4870: def = xmlRelaxNGNewDefine(ctxt, node);
4871: if (def == NULL)
4872: return (NULL);
4873: def->type = XML_RELAXNG_OPTIONAL;
4874: if (node->children == NULL) {
4875: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4876: "Element %s is empty\n", node->name, NULL);
4877: } else {
4878: def->content =
4879: xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4880: }
4881: } else if (IS_RELAXNG(node, "choice")) {
4882: def = xmlRelaxNGNewDefine(ctxt, node);
4883: if (def == NULL)
4884: return (NULL);
4885: def->type = XML_RELAXNG_CHOICE;
4886: if (node->children == NULL) {
4887: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4888: "Element %s is empty\n", node->name, NULL);
4889: } else {
4890: def->content =
4891: xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4892: }
4893: } else if (IS_RELAXNG(node, "group")) {
4894: def = xmlRelaxNGNewDefine(ctxt, node);
4895: if (def == NULL)
4896: return (NULL);
4897: def->type = XML_RELAXNG_GROUP;
4898: if (node->children == NULL) {
4899: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4900: "Element %s is empty\n", node->name, NULL);
4901: } else {
4902: def->content =
4903: xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4904: }
4905: } else if (IS_RELAXNG(node, "ref")) {
4906: def = xmlRelaxNGNewDefine(ctxt, node);
4907: if (def == NULL)
4908: return (NULL);
4909: def->type = XML_RELAXNG_REF;
4910: def->name = xmlGetProp(node, BAD_CAST "name");
4911: if (def->name == NULL) {
4912: xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4913: NULL, NULL);
4914: } else {
4915: xmlRelaxNGNormExtSpace(def->name);
4916: if (xmlValidateNCName(def->name, 0)) {
4917: xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4918: "ref name '%s' is not an NCName\n", def->name,
4919: NULL);
4920: }
4921: }
4922: if (node->children != NULL) {
4923: xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4924: NULL, NULL);
4925: }
4926: if (ctxt->grammar->refs == NULL)
4927: ctxt->grammar->refs = xmlHashCreate(10);
4928: if (ctxt->grammar->refs == NULL) {
4929: xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4930: "Could not create references hash\n", NULL, NULL);
4931: def = NULL;
4932: } else {
4933: int tmp;
4934:
4935: tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
4936: if (tmp < 0) {
4937: xmlRelaxNGDefinePtr prev;
4938:
4939: prev = (xmlRelaxNGDefinePtr)
4940: xmlHashLookup(ctxt->grammar->refs, def->name);
4941: if (prev == NULL) {
4942: if (def->name != NULL) {
4943: xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4944: "Error refs definitions '%s'\n",
4945: def->name, NULL);
4946: } else {
4947: xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4948: "Error refs definitions\n",
4949: NULL, NULL);
4950: }
4951: def = NULL;
4952: } else {
4953: def->nextHash = prev->nextHash;
4954: prev->nextHash = def;
4955: }
4956: }
4957: }
4958: } else if (IS_RELAXNG(node, "data")) {
4959: def = xmlRelaxNGParseData(ctxt, node);
4960: } else if (IS_RELAXNG(node, "value")) {
4961: def = xmlRelaxNGParseValue(ctxt, node);
4962: } else if (IS_RELAXNG(node, "list")) {
4963: def = xmlRelaxNGNewDefine(ctxt, node);
4964: if (def == NULL)
4965: return (NULL);
4966: def->type = XML_RELAXNG_LIST;
4967: if (node->children == NULL) {
4968: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4969: "Element %s is empty\n", node->name, NULL);
4970: } else {
4971: def->content =
4972: xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4973: }
4974: } else if (IS_RELAXNG(node, "interleave")) {
4975: def = xmlRelaxNGParseInterleave(ctxt, node);
4976: } else if (IS_RELAXNG(node, "externalRef")) {
4977: def = xmlRelaxNGProcessExternalRef(ctxt, node);
4978: } else if (IS_RELAXNG(node, "notAllowed")) {
4979: def = xmlRelaxNGNewDefine(ctxt, node);
4980: if (def == NULL)
4981: return (NULL);
4982: def->type = XML_RELAXNG_NOT_ALLOWED;
4983: if (node->children != NULL) {
4984: xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
4985: "xmlRelaxNGParse: notAllowed element is not empty\n",
4986: NULL, NULL);
4987: }
4988: } else if (IS_RELAXNG(node, "grammar")) {
4989: xmlRelaxNGGrammarPtr grammar, old;
4990: xmlRelaxNGGrammarPtr oldparent;
4991:
4992: #ifdef DEBUG_GRAMMAR
4993: xmlGenericError(xmlGenericErrorContext,
4994: "Found <grammar> pattern\n");
4995: #endif
4996:
4997: oldparent = ctxt->parentgrammar;
4998: old = ctxt->grammar;
4999: ctxt->parentgrammar = old;
5000: grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
5001: if (old != NULL) {
5002: ctxt->grammar = old;
5003: ctxt->parentgrammar = oldparent;
5004: #if 0
5005: if (grammar != NULL) {
5006: grammar->next = old->next;
5007: old->next = grammar;
5008: }
5009: #endif
5010: }
5011: if (grammar != NULL)
5012: def = grammar->start;
5013: else
5014: def = NULL;
5015: } else if (IS_RELAXNG(node, "parentRef")) {
5016: if (ctxt->parentgrammar == NULL) {
5017: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
5018: "Use of parentRef without a parent grammar\n", NULL,
5019: NULL);
5020: return (NULL);
5021: }
5022: def = xmlRelaxNGNewDefine(ctxt, node);
5023: if (def == NULL)
5024: return (NULL);
5025: def->type = XML_RELAXNG_PARENTREF;
5026: def->name = xmlGetProp(node, BAD_CAST "name");
5027: if (def->name == NULL) {
5028: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
5029: "parentRef has no name\n", NULL, NULL);
5030: } else {
5031: xmlRelaxNGNormExtSpace(def->name);
5032: if (xmlValidateNCName(def->name, 0)) {
5033: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
5034: "parentRef name '%s' is not an NCName\n",
5035: def->name, NULL);
5036: }
5037: }
5038: if (node->children != NULL) {
5039: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
5040: "parentRef is not empty\n", NULL, NULL);
5041: }
5042: if (ctxt->parentgrammar->refs == NULL)
5043: ctxt->parentgrammar->refs = xmlHashCreate(10);
5044: if (ctxt->parentgrammar->refs == NULL) {
5045: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5046: "Could not create references hash\n", NULL, NULL);
5047: def = NULL;
5048: } else if (def->name != NULL) {
5049: int tmp;
5050:
5051: tmp =
5052: xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
5053: if (tmp < 0) {
5054: xmlRelaxNGDefinePtr prev;
5055:
5056: prev = (xmlRelaxNGDefinePtr)
5057: xmlHashLookup(ctxt->parentgrammar->refs, def->name);
5058: if (prev == NULL) {
5059: xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5060: "Internal error parentRef definitions '%s'\n",
5061: def->name, NULL);
5062: def = NULL;
5063: } else {
5064: def->nextHash = prev->nextHash;
5065: prev->nextHash = def;
5066: }
5067: }
5068: }
5069: } else if (IS_RELAXNG(node, "mixed")) {
5070: if (node->children == NULL) {
5071: xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
5072: NULL, NULL);
5073: def = NULL;
5074: } else {
5075: def = xmlRelaxNGParseInterleave(ctxt, node);
5076: if (def != NULL) {
5077: xmlRelaxNGDefinePtr tmp;
5078:
5079: if ((def->content != NULL) && (def->content->next != NULL)) {
5080: tmp = xmlRelaxNGNewDefine(ctxt, node);
5081: if (tmp != NULL) {
5082: tmp->type = XML_RELAXNG_GROUP;
5083: tmp->content = def->content;
5084: def->content = tmp;
5085: }
5086: }
5087:
5088: tmp = xmlRelaxNGNewDefine(ctxt, node);
5089: if (tmp == NULL)
5090: return (def);
5091: tmp->type = XML_RELAXNG_TEXT;
5092: tmp->next = def->content;
5093: def->content = tmp;
5094: }
5095: }
5096: } else {
5097: xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
5098: "Unexpected node %s is not a pattern\n", node->name,
5099: NULL);
5100: def = NULL;
5101: }
5102: return (def);
5103: }
5104:
5105: /**
5106: * xmlRelaxNGParseAttribute:
5107: * @ctxt: a Relax-NG parser context
5108: * @node: the element node
5109: *
5110: * parse the content of a RelaxNG attribute node.
5111: *
5112: * Returns the definition pointer or NULL in case of error.
5113: */
5114: static xmlRelaxNGDefinePtr
5115: xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5116: {
5117: xmlRelaxNGDefinePtr ret, cur;
5118: xmlNodePtr child;
5119: int old_flags;
5120:
5121: ret = xmlRelaxNGNewDefine(ctxt, node);
5122: if (ret == NULL)
5123: return (NULL);
5124: ret->type = XML_RELAXNG_ATTRIBUTE;
5125: ret->parent = ctxt->def;
5126: child = node->children;
5127: if (child == NULL) {
5128: xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5129: "xmlRelaxNGParseattribute: attribute has no children\n",
5130: NULL, NULL);
5131: return (ret);
5132: }
5133: old_flags = ctxt->flags;
5134: ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
5135: cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5136: if (cur != NULL)
5137: child = child->next;
5138:
5139: if (child != NULL) {
5140: cur = xmlRelaxNGParsePattern(ctxt, child);
5141: if (cur != NULL) {
5142: switch (cur->type) {
5143: case XML_RELAXNG_EMPTY:
5144: case XML_RELAXNG_NOT_ALLOWED:
5145: case XML_RELAXNG_TEXT:
5146: case XML_RELAXNG_ELEMENT:
5147: case XML_RELAXNG_DATATYPE:
5148: case XML_RELAXNG_VALUE:
5149: case XML_RELAXNG_LIST:
5150: case XML_RELAXNG_REF:
5151: case XML_RELAXNG_PARENTREF:
5152: case XML_RELAXNG_EXTERNALREF:
5153: case XML_RELAXNG_DEF:
5154: case XML_RELAXNG_ONEORMORE:
5155: case XML_RELAXNG_ZEROORMORE:
5156: case XML_RELAXNG_OPTIONAL:
5157: case XML_RELAXNG_CHOICE:
5158: case XML_RELAXNG_GROUP:
5159: case XML_RELAXNG_INTERLEAVE:
5160: case XML_RELAXNG_ATTRIBUTE:
5161: ret->content = cur;
5162: cur->parent = ret;
5163: break;
5164: case XML_RELAXNG_START:
5165: case XML_RELAXNG_PARAM:
5166: case XML_RELAXNG_EXCEPT:
5167: xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5168: "attribute has invalid content\n", NULL,
5169: NULL);
5170: break;
5171: case XML_RELAXNG_NOOP:
5172: xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5173: "RNG Internal error, noop found in attribute\n",
5174: NULL, NULL);
5175: break;
5176: }
5177: }
5178: child = child->next;
5179: }
5180: if (child != NULL) {
5181: xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5182: "attribute has multiple children\n", NULL, NULL);
5183: }
5184: ctxt->flags = old_flags;
5185: return (ret);
5186: }
5187:
5188: /**
5189: * xmlRelaxNGParseExceptNameClass:
5190: * @ctxt: a Relax-NG parser context
5191: * @node: the except node
5192: * @attr: 1 if within an attribute, 0 if within an element
5193: *
5194: * parse the content of a RelaxNG nameClass node.
5195: *
5196: * Returns the definition pointer or NULL in case of error.
5197: */
5198: static xmlRelaxNGDefinePtr
5199: xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
5200: xmlNodePtr node, int attr)
5201: {
5202: xmlRelaxNGDefinePtr ret, cur, last = NULL;
5203: xmlNodePtr child;
5204:
5205: if (!IS_RELAXNG(node, "except")) {
5206: xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5207: "Expecting an except node\n", NULL, NULL);
5208: return (NULL);
5209: }
5210: if (node->next != NULL) {
5211: xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5212: "exceptNameClass allows only a single except node\n",
5213: NULL, NULL);
5214: }
5215: if (node->children == NULL) {
5216: xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5217: NULL, NULL);
5218: return (NULL);
5219: }
5220:
5221: ret = xmlRelaxNGNewDefine(ctxt, node);
5222: if (ret == NULL)
5223: return (NULL);
5224: ret->type = XML_RELAXNG_EXCEPT;
5225: child = node->children;
5226: while (child != NULL) {
5227: cur = xmlRelaxNGNewDefine(ctxt, child);
5228: if (cur == NULL)
5229: break;
5230: if (attr)
5231: cur->type = XML_RELAXNG_ATTRIBUTE;
5232: else
5233: cur->type = XML_RELAXNG_ELEMENT;
5234:
5235: if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
5236: if (last == NULL) {
5237: ret->content = cur;
5238: } else {
5239: last->next = cur;
5240: }
5241: last = cur;
5242: }
5243: child = child->next;
5244: }
5245:
5246: return (ret);
5247: }
5248:
5249: /**
5250: * xmlRelaxNGParseNameClass:
5251: * @ctxt: a Relax-NG parser context
5252: * @node: the nameClass node
5253: * @def: the current definition
5254: *
5255: * parse the content of a RelaxNG nameClass node.
5256: *
5257: * Returns the definition pointer or NULL in case of error.
5258: */
5259: static xmlRelaxNGDefinePtr
5260: xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
5261: xmlRelaxNGDefinePtr def)
5262: {
5263: xmlRelaxNGDefinePtr ret, tmp;
5264: xmlChar *val;
5265:
5266: ret = def;
5267: if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
5268: (IS_RELAXNG(node, "nsName"))) {
5269: if ((def->type != XML_RELAXNG_ELEMENT) &&
5270: (def->type != XML_RELAXNG_ATTRIBUTE)) {
5271: ret = xmlRelaxNGNewDefine(ctxt, node);
5272: if (ret == NULL)
5273: return (NULL);
5274: ret->parent = def;
5275: if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
5276: ret->type = XML_RELAXNG_ATTRIBUTE;
5277: else
5278: ret->type = XML_RELAXNG_ELEMENT;
5279: }
5280: }
5281: if (IS_RELAXNG(node, "name")) {
5282: val = xmlNodeGetContent(node);
5283: xmlRelaxNGNormExtSpace(val);
5284: if (xmlValidateNCName(val, 0)) {
5285: if (node->parent != NULL)
5286: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5287: "Element %s name '%s' is not an NCName\n",
5288: node->parent->name, val);
5289: else
5290: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5291: "name '%s' is not an NCName\n",
5292: val, NULL);
5293: }
5294: ret->name = val;
5295: val = xmlGetProp(node, BAD_CAST "ns");
5296: ret->ns = val;
5297: if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5298: (val != NULL) &&
5299: (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
5300: xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5301: "Attribute with namespace '%s' is not allowed\n",
5302: val, NULL);
5303: }
5304: if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5305: (val != NULL) &&
5306: (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
5307: xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5308: "Attribute with QName 'xmlns' is not allowed\n",
5309: val, NULL);
5310: }
5311: } else if (IS_RELAXNG(node, "anyName")) {
5312: ret->name = NULL;
5313: ret->ns = NULL;
5314: if (node->children != NULL) {
5315: ret->nameClass =
5316: xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5317: (def->type ==
5318: XML_RELAXNG_ATTRIBUTE));
5319: }
5320: } else if (IS_RELAXNG(node, "nsName")) {
5321: ret->name = NULL;
5322: ret->ns = xmlGetProp(node, BAD_CAST "ns");
5323: if (ret->ns == NULL) {
5324: xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5325: "nsName has no ns attribute\n", NULL, NULL);
5326: }
5327: if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5328: (ret->ns != NULL) &&
5329: (xmlStrEqual
5330: (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
5331: xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5332: "Attribute with namespace '%s' is not allowed\n",
5333: ret->ns, NULL);
5334: }
5335: if (node->children != NULL) {
5336: ret->nameClass =
5337: xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5338: (def->type ==
5339: XML_RELAXNG_ATTRIBUTE));
5340: }
5341: } else if (IS_RELAXNG(node, "choice")) {
5342: xmlNodePtr child;
5343: xmlRelaxNGDefinePtr last = NULL;
5344:
5345: ret = xmlRelaxNGNewDefine(ctxt, node);
5346: if (ret == NULL)
5347: return (NULL);
5348: ret->parent = def;
5349: ret->type = XML_RELAXNG_CHOICE;
5350:
5351: if (node->children == NULL) {
5352: xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5353: "Element choice is empty\n", NULL, NULL);
5354: } else {
5355:
5356: child = node->children;
5357: while (child != NULL) {
5358: tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
5359: if (tmp != NULL) {
5360: if (last == NULL) {
5361: last = ret->nameClass = tmp;
5362: } else {
5363: last->next = tmp;
5364: last = tmp;
5365: }
5366: }
5367: child = child->next;
5368: }
5369: }
5370: } else {
5371: xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5372: "expecting name, anyName, nsName or choice : got %s\n",
5373: (node == NULL ? (const xmlChar *) "nothing" : node->name),
5374: NULL);
5375: return (NULL);
5376: }
5377: if (ret != def) {
5378: if (def->nameClass == NULL) {
5379: def->nameClass = ret;
5380: } else {
5381: tmp = def->nameClass;
5382: while (tmp->next != NULL) {
5383: tmp = tmp->next;
5384: }
5385: tmp->next = ret;
5386: }
5387: }
5388: return (ret);
5389: }
5390:
5391: /**
5392: * xmlRelaxNGParseElement:
5393: * @ctxt: a Relax-NG parser context
5394: * @node: the element node
5395: *
5396: * parse the content of a RelaxNG element node.
5397: *
5398: * Returns the definition pointer or NULL in case of error.
5399: */
5400: static xmlRelaxNGDefinePtr
5401: xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5402: {
5403: xmlRelaxNGDefinePtr ret, cur, last;
5404: xmlNodePtr child;
5405: const xmlChar *olddefine;
5406:
5407: ret = xmlRelaxNGNewDefine(ctxt, node);
5408: if (ret == NULL)
5409: return (NULL);
5410: ret->type = XML_RELAXNG_ELEMENT;
5411: ret->parent = ctxt->def;
5412: child = node->children;
5413: if (child == NULL) {
5414: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5415: "xmlRelaxNGParseElement: element has no children\n",
5416: NULL, NULL);
5417: return (ret);
5418: }
5419: cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5420: if (cur != NULL)
5421: child = child->next;
5422:
5423: if (child == NULL) {
5424: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5425: "xmlRelaxNGParseElement: element has no content\n",
5426: NULL, NULL);
5427: return (ret);
5428: }
5429: olddefine = ctxt->define;
5430: ctxt->define = NULL;
5431: last = NULL;
5432: while (child != NULL) {
5433: cur = xmlRelaxNGParsePattern(ctxt, child);
5434: if (cur != NULL) {
5435: cur->parent = ret;
5436: switch (cur->type) {
5437: case XML_RELAXNG_EMPTY:
5438: case XML_RELAXNG_NOT_ALLOWED:
5439: case XML_RELAXNG_TEXT:
5440: case XML_RELAXNG_ELEMENT:
5441: case XML_RELAXNG_DATATYPE:
5442: case XML_RELAXNG_VALUE:
5443: case XML_RELAXNG_LIST:
5444: case XML_RELAXNG_REF:
5445: case XML_RELAXNG_PARENTREF:
5446: case XML_RELAXNG_EXTERNALREF:
5447: case XML_RELAXNG_DEF:
5448: case XML_RELAXNG_ZEROORMORE:
5449: case XML_RELAXNG_ONEORMORE:
5450: case XML_RELAXNG_OPTIONAL:
5451: case XML_RELAXNG_CHOICE:
5452: case XML_RELAXNG_GROUP:
5453: case XML_RELAXNG_INTERLEAVE:
5454: if (last == NULL) {
5455: ret->content = last = cur;
5456: } else {
5457: if ((last->type == XML_RELAXNG_ELEMENT) &&
5458: (ret->content == last)) {
5459: ret->content = xmlRelaxNGNewDefine(ctxt, node);
5460: if (ret->content != NULL) {
5461: ret->content->type = XML_RELAXNG_GROUP;
5462: ret->content->content = last;
5463: } else {
5464: ret->content = last;
5465: }
5466: }
5467: last->next = cur;
5468: last = cur;
5469: }
5470: break;
5471: case XML_RELAXNG_ATTRIBUTE:
5472: cur->next = ret->attrs;
5473: ret->attrs = cur;
5474: break;
5475: case XML_RELAXNG_START:
5476: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5477: "RNG Internal error, start found in element\n",
5478: NULL, NULL);
5479: break;
5480: case XML_RELAXNG_PARAM:
5481: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5482: "RNG Internal error, param found in element\n",
5483: NULL, NULL);
5484: break;
5485: case XML_RELAXNG_EXCEPT:
5486: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5487: "RNG Internal error, except found in element\n",
5488: NULL, NULL);
5489: break;
5490: case XML_RELAXNG_NOOP:
5491: xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5492: "RNG Internal error, noop found in element\n",
5493: NULL, NULL);
5494: break;
5495: }
5496: }
5497: child = child->next;
5498: }
5499: ctxt->define = olddefine;
5500: return (ret);
5501: }
5502:
5503: /**
5504: * xmlRelaxNGParsePatterns:
5505: * @ctxt: a Relax-NG parser context
5506: * @nodes: list of nodes
5507: * @group: use an implicit <group> for elements
5508: *
5509: * parse the content of a RelaxNG start node.
5510: *
5511: * Returns the definition pointer or NULL in case of error.
5512: */
5513: static xmlRelaxNGDefinePtr
5514: xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
5515: int group)
5516: {
5517: xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent;
5518:
5519: parent = ctxt->def;
5520: while (nodes != NULL) {
5521: if (IS_RELAXNG(nodes, "element")) {
5522: cur = xmlRelaxNGParseElement(ctxt, nodes);
5523: if (def == NULL) {
5524: def = last = cur;
5525: } else {
5526: if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) &&
5527: (def == last)) {
5528: def = xmlRelaxNGNewDefine(ctxt, nodes);
5529: def->type = XML_RELAXNG_GROUP;
5530: def->content = last;
5531: }
5532: last->next = cur;
5533: last = cur;
5534: }
5535: cur->parent = parent;
5536: } else {
5537: cur = xmlRelaxNGParsePattern(ctxt, nodes);
5538: if (cur != NULL) {
5539: if (def == NULL) {
5540: def = last = cur;
5541: } else {
5542: last->next = cur;
5543: last = cur;
5544: }
5545: }
5546: }
5547: nodes = nodes->next;
5548: }
5549: return (def);
5550: }
5551:
5552: /**
5553: * xmlRelaxNGParseStart:
5554: * @ctxt: a Relax-NG parser context
5555: * @nodes: start children nodes
5556: *
5557: * parse the content of a RelaxNG start node.
5558: *
5559: * Returns 0 in case of success, -1 in case of error
5560: */
5561: static int
5562: xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
5563: {
5564: int ret = 0;
5565: xmlRelaxNGDefinePtr def = NULL, last;
5566:
5567: if (nodes == NULL) {
5568: xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
5569: NULL, NULL);
5570: return (-1);
5571: }
5572: if (IS_RELAXNG(nodes, "empty")) {
5573: def = xmlRelaxNGNewDefine(ctxt, nodes);
5574: if (def == NULL)
5575: return (-1);
5576: def->type = XML_RELAXNG_EMPTY;
5577: if (nodes->children != NULL) {
5578: xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
5579: "element empty is not empty\n", NULL, NULL);
5580: }
5581: } else if (IS_RELAXNG(nodes, "notAllowed")) {
5582: def = xmlRelaxNGNewDefine(ctxt, nodes);
5583: if (def == NULL)
5584: return (-1);
5585: def->type = XML_RELAXNG_NOT_ALLOWED;
5586: if (nodes->children != NULL) {
5587: xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
5588: "element notAllowed is not empty\n", NULL, NULL);
5589: }
5590: } else {
5591: def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
5592: }
5593: if (ctxt->grammar->start != NULL) {
5594: last = ctxt->grammar->start;
5595: while (last->next != NULL)
5596: last = last->next;
5597: last->next = def;
5598: } else {
5599: ctxt->grammar->start = def;
5600: }
5601: nodes = nodes->next;
5602: if (nodes != NULL) {
5603: xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
5604: "start more than one children\n", NULL, NULL);
5605: return (-1);
5606: }
5607: return (ret);
5608: }
5609:
5610: /**
5611: * xmlRelaxNGParseGrammarContent:
5612: * @ctxt: a Relax-NG parser context
5613: * @nodes: grammar children nodes
5614: *
5615: * parse the content of a RelaxNG grammar node.
5616: *
5617: * Returns 0 in case of success, -1 in case of error
5618: */
5619: static int
5620: xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
5621: xmlNodePtr nodes)
5622: {
5623: int ret = 0, tmp;
5624:
5625: if (nodes == NULL) {
5626: xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
5627: "grammar has no children\n", NULL, NULL);
5628: return (-1);
5629: }
5630: while (nodes != NULL) {
5631: if (IS_RELAXNG(nodes, "start")) {
5632: if (nodes->children == NULL) {
5633: xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
5634: "start has no children\n", NULL, NULL);
5635: } else {
5636: tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
5637: if (tmp != 0)
5638: ret = -1;
5639: }
5640: } else if (IS_RELAXNG(nodes, "define")) {
5641: tmp = xmlRelaxNGParseDefine(ctxt, nodes);
5642: if (tmp != 0)
5643: ret = -1;
5644: } else if (IS_RELAXNG(nodes, "include")) {
5645: tmp = xmlRelaxNGParseInclude(ctxt, nodes);
5646: if (tmp != 0)
5647: ret = -1;
5648: } else {
5649: xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
5650: "grammar has unexpected child %s\n", nodes->name,
5651: NULL);
5652: ret = -1;
5653: }
5654: nodes = nodes->next;
5655: }
5656: return (ret);
5657: }
5658:
5659: /**
5660: * xmlRelaxNGCheckReference:
5661: * @ref: the ref
5662: * @ctxt: a Relax-NG parser context
5663: * @name: the name associated to the defines
5664: *
5665: * Applies the 4.17. combine attribute rule for all the define
5666: * element of a given grammar using the same name.
5667: */
5668: static void
5669: xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
5670: xmlRelaxNGParserCtxtPtr ctxt,
5671: const xmlChar * name)
5672: {
5673: xmlRelaxNGGrammarPtr grammar;
5674: xmlRelaxNGDefinePtr def, cur;
5675:
5676: /*
5677: * Those rules don't apply to imported ref from xmlRelaxNGParseImportRef
5678: */
5679: if (ref->dflags & IS_EXTERNAL_REF)
5680: return;
5681:
5682: grammar = ctxt->grammar;
5683: if (grammar == NULL) {
5684: xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5685: "Internal error: no grammar in CheckReference %s\n",
5686: name, NULL);
5687: return;
5688: }
5689: if (ref->content != NULL) {
5690: xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5691: "Internal error: reference has content in CheckReference %s\n",
5692: name, NULL);
5693: return;
5694: }
5695: if (grammar->defs != NULL) {
5696: def = xmlHashLookup(grammar->defs, name);
5697: if (def != NULL) {
5698: cur = ref;
5699: while (cur != NULL) {
5700: cur->content = def;
5701: cur = cur->nextHash;
5702: }
5703: } else {
5704: xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5705: "Reference %s has no matching definition\n", name,
5706: NULL);
5707: }
5708: } else {
5709: xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5710: "Reference %s has no matching definition\n", name,
5711: NULL);
5712: }
5713: }
5714:
5715: /**
5716: * xmlRelaxNGCheckCombine:
5717: * @define: the define(s) list
5718: * @ctxt: a Relax-NG parser context
5719: * @name: the name associated to the defines
5720: *
5721: * Applies the 4.17. combine attribute rule for all the define
5722: * element of a given grammar using the same name.
5723: */
5724: static void
5725: xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
5726: xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
5727: {
5728: xmlChar *combine;
5729: int choiceOrInterleave = -1;
5730: int missing = 0;
5731: xmlRelaxNGDefinePtr cur, last, tmp, tmp2;
5732:
5733: if (define->nextHash == NULL)
5734: return;
5735: cur = define;
5736: while (cur != NULL) {
5737: combine = xmlGetProp(cur->node, BAD_CAST "combine");
5738: if (combine != NULL) {
5739: if (xmlStrEqual(combine, BAD_CAST "choice")) {
5740: if (choiceOrInterleave == -1)
5741: choiceOrInterleave = 1;
5742: else if (choiceOrInterleave == 0) {
5743: xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5744: "Defines for %s use both 'choice' and 'interleave'\n",
5745: name, NULL);
5746: }
5747: } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
5748: if (choiceOrInterleave == -1)
5749: choiceOrInterleave = 0;
5750: else if (choiceOrInterleave == 1) {
5751: xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5752: "Defines for %s use both 'choice' and 'interleave'\n",
5753: name, NULL);
5754: }
5755: } else {
5756: xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5757: "Defines for %s use unknown combine value '%s''\n",
5758: name, combine);
5759: }
5760: xmlFree(combine);
5761: } else {
5762: if (missing == 0)
5763: missing = 1;
5764: else {
5765: xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5766: "Some defines for %s needs the combine attribute\n",
5767: name, NULL);
5768: }
5769: }
5770:
5771: cur = cur->nextHash;
5772: }
5773: #ifdef DEBUG
5774: xmlGenericError(xmlGenericErrorContext,
5775: "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
5776: name, choiceOrInterleave);
5777: #endif
5778: if (choiceOrInterleave == -1)
5779: choiceOrInterleave = 0;
5780: cur = xmlRelaxNGNewDefine(ctxt, define->node);
5781: if (cur == NULL)
5782: return;
5783: if (choiceOrInterleave == 0)
5784: cur->type = XML_RELAXNG_INTERLEAVE;
5785: else
5786: cur->type = XML_RELAXNG_CHOICE;
5787: tmp = define;
5788: last = NULL;
5789: while (tmp != NULL) {
5790: if (tmp->content != NULL) {
5791: if (tmp->content->next != NULL) {
5792: /*
5793: * we need first to create a wrapper.
5794: */
5795: tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5796: if (tmp2 == NULL)
5797: break;
5798: tmp2->type = XML_RELAXNG_GROUP;
5799: tmp2->content = tmp->content;
5800: } else {
5801: tmp2 = tmp->content;
5802: }
5803: if (last == NULL) {
5804: cur->content = tmp2;
5805: } else {
5806: last->next = tmp2;
5807: }
5808: last = tmp2;
5809: }
5810: tmp->content = cur;
5811: tmp = tmp->nextHash;
5812: }
5813: define->content = cur;
5814: if (choiceOrInterleave == 0) {
5815: if (ctxt->interleaves == NULL)
5816: ctxt->interleaves = xmlHashCreate(10);
5817: if (ctxt->interleaves == NULL) {
5818: xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5819: "Failed to create interleaves hash table\n", NULL,
5820: NULL);
5821: } else {
5822: char tmpname[32];
5823:
5824: snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5825: if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5826: 0) {
5827: xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5828: "Failed to add %s to hash table\n",
5829: (const xmlChar *) tmpname, NULL);
5830: }
5831: }
5832: }
5833: }
5834:
5835: /**
5836: * xmlRelaxNGCombineStart:
5837: * @ctxt: a Relax-NG parser context
5838: * @grammar: the grammar
5839: *
5840: * Applies the 4.17. combine rule for all the start
5841: * element of a given grammar.
5842: */
5843: static void
5844: xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
5845: xmlRelaxNGGrammarPtr grammar)
5846: {
5847: xmlRelaxNGDefinePtr starts;
5848: xmlChar *combine;
5849: int choiceOrInterleave = -1;
5850: int missing = 0;
5851: xmlRelaxNGDefinePtr cur;
5852:
5853: starts = grammar->start;
5854: if ((starts == NULL) || (starts->next == NULL))
5855: return;
5856: cur = starts;
5857: while (cur != NULL) {
5858: if ((cur->node == NULL) || (cur->node->parent == NULL) ||
5859: (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
5860: combine = NULL;
5861: xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5862: "Internal error: start element not found\n", NULL,
5863: NULL);
5864: } else {
5865: combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
5866: }
5867:
5868: if (combine != NULL) {
5869: if (xmlStrEqual(combine, BAD_CAST "choice")) {
5870: if (choiceOrInterleave == -1)
5871: choiceOrInterleave = 1;
5872: else if (choiceOrInterleave == 0) {
5873: xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5874: "<start> use both 'choice' and 'interleave'\n",
5875: NULL, NULL);
5876: }
5877: } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
5878: if (choiceOrInterleave == -1)
5879: choiceOrInterleave = 0;
5880: else if (choiceOrInterleave == 1) {
5881: xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5882: "<start> use both 'choice' and 'interleave'\n",
5883: NULL, NULL);
5884: }
5885: } else {
5886: xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5887: "<start> uses unknown combine value '%s''\n",
5888: combine, NULL);
5889: }
5890: xmlFree(combine);
5891: } else {
5892: if (missing == 0)
5893: missing = 1;
5894: else {
5895: xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5896: "Some <start> element miss the combine attribute\n",
5897: NULL, NULL);
5898: }
5899: }
5900:
5901: cur = cur->next;
5902: }
5903: #ifdef DEBUG
5904: xmlGenericError(xmlGenericErrorContext,
5905: "xmlRelaxNGCombineStart(): merging <start>: %d\n",
5906: choiceOrInterleave);
5907: #endif
5908: if (choiceOrInterleave == -1)
5909: choiceOrInterleave = 0;
5910: cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5911: if (cur == NULL)
5912: return;
5913: if (choiceOrInterleave == 0)
5914: cur->type = XML_RELAXNG_INTERLEAVE;
5915: else
5916: cur->type = XML_RELAXNG_CHOICE;
5917: cur->content = grammar->start;
5918: grammar->start = cur;
5919: if (choiceOrInterleave == 0) {
5920: if (ctxt->interleaves == NULL)
5921: ctxt->interleaves = xmlHashCreate(10);
5922: if (ctxt->interleaves == NULL) {
5923: xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5924: "Failed to create interleaves hash table\n", NULL,
5925: NULL);
5926: } else {
5927: char tmpname[32];
5928:
5929: snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5930: if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5931: 0) {
5932: xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5933: "Failed to add %s to hash table\n",
5934: (const xmlChar *) tmpname, NULL);
5935: }
5936: }
5937: }
5938: }
5939:
5940: /**
5941: * xmlRelaxNGCheckCycles:
5942: * @ctxt: a Relax-NG parser context
5943: * @nodes: grammar children nodes
5944: * @depth: the counter
5945: *
5946: * Check for cycles.
5947: *
5948: * Returns 0 if check passed, and -1 in case of error
5949: */
5950: static int
5951: xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
5952: xmlRelaxNGDefinePtr cur, int depth)
5953: {
5954: int ret = 0;
5955:
5956: while ((ret == 0) && (cur != NULL)) {
5957: if ((cur->type == XML_RELAXNG_REF) ||
5958: (cur->type == XML_RELAXNG_PARENTREF)) {
5959: if (cur->depth == -1) {
5960: cur->depth = depth;
5961: ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5962: cur->depth = -2;
5963: } else if (depth == cur->depth) {
5964: xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
5965: "Detected a cycle in %s references\n",
5966: cur->name, NULL);
5967: return (-1);
5968: }
5969: } else if (cur->type == XML_RELAXNG_ELEMENT) {
5970: ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
5971: } else {
5972: ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5973: }
5974: cur = cur->next;
5975: }
5976: return (ret);
5977: }
5978:
5979: /**
5980: * xmlRelaxNGTryUnlink:
5981: * @ctxt: a Relax-NG parser context
5982: * @cur: the definition to unlink
5983: * @parent: the parent definition
5984: * @prev: the previous sibling definition
5985: *
5986: * Try to unlink a definition. If not possble make it a NOOP
5987: *
5988: * Returns the new prev definition
5989: */
5990: static xmlRelaxNGDefinePtr
5991: xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
5992: xmlRelaxNGDefinePtr cur,
5993: xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
5994: {
5995: if (prev != NULL) {
5996: prev->next = cur->next;
5997: } else {
5998: if (parent != NULL) {
5999: if (parent->content == cur)
6000: parent->content = cur->next;
6001: else if (parent->attrs == cur)
6002: parent->attrs = cur->next;
6003: else if (parent->nameClass == cur)
6004: parent->nameClass = cur->next;
6005: } else {
6006: cur->type = XML_RELAXNG_NOOP;
6007: prev = cur;
6008: }
6009: }
6010: return (prev);
6011: }
6012:
6013: /**
6014: * xmlRelaxNGSimplify:
6015: * @ctxt: a Relax-NG parser context
6016: * @nodes: grammar children nodes
6017: *
6018: * Check for simplification of empty and notAllowed
6019: */
6020: static void
6021: xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
6022: xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent)
6023: {
6024: xmlRelaxNGDefinePtr prev = NULL;
6025:
6026: while (cur != NULL) {
6027: if ((cur->type == XML_RELAXNG_REF) ||
6028: (cur->type == XML_RELAXNG_PARENTREF)) {
6029: if (cur->depth != -3) {
6030: cur->depth = -3;
6031: xmlRelaxNGSimplify(ctxt, cur->content, cur);
6032: }
6033: } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
6034: cur->parent = parent;
6035: if ((parent != NULL) &&
6036: ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
6037: (parent->type == XML_RELAXNG_LIST) ||
6038: (parent->type == XML_RELAXNG_GROUP) ||
6039: (parent->type == XML_RELAXNG_INTERLEAVE) ||
6040: (parent->type == XML_RELAXNG_ONEORMORE) ||
6041: (parent->type == XML_RELAXNG_ZEROORMORE))) {
6042: parent->type = XML_RELAXNG_NOT_ALLOWED;
6043: break;
6044: }
6045: if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) {
6046: prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6047: } else
6048: prev = cur;
6049: } else if (cur->type == XML_RELAXNG_EMPTY) {
6050: cur->parent = parent;
6051: if ((parent != NULL) &&
6052: ((parent->type == XML_RELAXNG_ONEORMORE) ||
6053: (parent->type == XML_RELAXNG_ZEROORMORE))) {
6054: parent->type = XML_RELAXNG_EMPTY;
6055: break;
6056: }
6057: if ((parent != NULL) &&
6058: ((parent->type == XML_RELAXNG_GROUP) ||
6059: (parent->type == XML_RELAXNG_INTERLEAVE))) {
6060: prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6061: } else
6062: prev = cur;
6063: } else {
6064: cur->parent = parent;
6065: if (cur->content != NULL)
6066: xmlRelaxNGSimplify(ctxt, cur->content, cur);
6067: if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL))
6068: xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
6069: if (cur->nameClass != NULL)
6070: xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
6071: /*
6072: * On Elements, try to move attribute only generating rules on
6073: * the attrs rules.
6074: */
6075: if (cur->type == XML_RELAXNG_ELEMENT) {
6076: int attronly;
6077: xmlRelaxNGDefinePtr tmp, pre;
6078:
6079: while (cur->content != NULL) {
6080: attronly =
6081: xmlRelaxNGGenerateAttributes(ctxt, cur->content);
6082: if (attronly == 1) {
6083: /*
6084: * migrate cur->content to attrs
6085: */
6086: tmp = cur->content;
6087: cur->content = tmp->next;
6088: tmp->next = cur->attrs;
6089: cur->attrs = tmp;
6090: } else {
6091: /*
6092: * cur->content can generate elements or text
6093: */
6094: break;
6095: }
6096: }
6097: pre = cur->content;
6098: while ((pre != NULL) && (pre->next != NULL)) {
6099: tmp = pre->next;
6100: attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
6101: if (attronly == 1) {
6102: /*
6103: * migrate tmp to attrs
6104: */
6105: pre->next = tmp->next;
6106: tmp->next = cur->attrs;
6107: cur->attrs = tmp;
6108: } else {
6109: pre = tmp;
6110: }
6111: }
6112: }
6113: /*
6114: * This may result in a simplification
6115: */
6116: if ((cur->type == XML_RELAXNG_GROUP) ||
6117: (cur->type == XML_RELAXNG_INTERLEAVE)) {
6118: if (cur->content == NULL)
6119: cur->type = XML_RELAXNG_EMPTY;
6120: else if (cur->content->next == NULL) {
6121: if ((parent == NULL) && (prev == NULL)) {
6122: cur->type = XML_RELAXNG_NOOP;
6123: } else if (prev == NULL) {
6124: parent->content = cur->content;
6125: cur->content->next = cur->next;
6126: cur = cur->content;
6127: } else {
6128: cur->content->next = cur->next;
6129: prev->next = cur->content;
6130: cur = cur->content;
6131: }
6132: }
6133: }
6134: /*
6135: * the current node may have been transformed back
6136: */
6137: if ((cur->type == XML_RELAXNG_EXCEPT) &&
6138: (cur->content != NULL) &&
6139: (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) {
6140: prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6141: } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
6142: if ((parent != NULL) &&
6143: ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
6144: (parent->type == XML_RELAXNG_LIST) ||
6145: (parent->type == XML_RELAXNG_GROUP) ||
6146: (parent->type == XML_RELAXNG_INTERLEAVE) ||
6147: (parent->type == XML_RELAXNG_ONEORMORE) ||
6148: (parent->type == XML_RELAXNG_ZEROORMORE))) {
6149: parent->type = XML_RELAXNG_NOT_ALLOWED;
6150: break;
6151: }
6152: if ((parent != NULL) &&
6153: (parent->type == XML_RELAXNG_CHOICE)) {
6154: prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6155: } else
6156: prev = cur;
6157: } else if (cur->type == XML_RELAXNG_EMPTY) {
6158: if ((parent != NULL) &&
6159: ((parent->type == XML_RELAXNG_ONEORMORE) ||
6160: (parent->type == XML_RELAXNG_ZEROORMORE))) {
6161: parent->type = XML_RELAXNG_EMPTY;
6162: break;
6163: }
6164: if ((parent != NULL) &&
6165: ((parent->type == XML_RELAXNG_GROUP) ||
6166: (parent->type == XML_RELAXNG_INTERLEAVE) ||
6167: (parent->type == XML_RELAXNG_CHOICE))) {
6168: prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6169: } else
6170: prev = cur;
6171: } else {
6172: prev = cur;
6173: }
6174: }
6175: cur = cur->next;
6176: }
6177: }
6178:
6179: /**
6180: * xmlRelaxNGGroupContentType:
6181: * @ct1: the first content type
6182: * @ct2: the second content type
6183: *
6184: * Try to group 2 content types
6185: *
6186: * Returns the content type
6187: */
6188: static xmlRelaxNGContentType
6189: xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
6190: xmlRelaxNGContentType ct2)
6191: {
6192: if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
6193: (ct2 == XML_RELAXNG_CONTENT_ERROR))
6194: return (XML_RELAXNG_CONTENT_ERROR);
6195: if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
6196: return (ct2);
6197: if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
6198: return (ct1);
6199: if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
6200: (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
6201: return (XML_RELAXNG_CONTENT_COMPLEX);
6202: return (XML_RELAXNG_CONTENT_ERROR);
6203: }
6204:
6205: /**
6206: * xmlRelaxNGMaxContentType:
6207: * @ct1: the first content type
6208: * @ct2: the second content type
6209: *
6210: * Compute the max content-type
6211: *
6212: * Returns the content type
6213: */
6214: static xmlRelaxNGContentType
6215: xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
6216: xmlRelaxNGContentType ct2)
6217: {
6218: if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
6219: (ct2 == XML_RELAXNG_CONTENT_ERROR))
6220: return (XML_RELAXNG_CONTENT_ERROR);
6221: if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) ||
6222: (ct2 == XML_RELAXNG_CONTENT_SIMPLE))
6223: return (XML_RELAXNG_CONTENT_SIMPLE);
6224: if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) ||
6225: (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
6226: return (XML_RELAXNG_CONTENT_COMPLEX);
6227: return (XML_RELAXNG_CONTENT_EMPTY);
6228: }
6229:
6230: /**
6231: * xmlRelaxNGCheckRules:
6232: * @ctxt: a Relax-NG parser context
6233: * @cur: the current definition
6234: * @flags: some accumulated flags
6235: * @ptype: the parent type
6236: *
6237: * Check for rules in section 7.1 and 7.2
6238: *
6239: * Returns the content type of @cur
6240: */
6241: static xmlRelaxNGContentType
6242: xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
6243: xmlRelaxNGDefinePtr cur, int flags,
6244: xmlRelaxNGType ptype)
6245: {
6246: int nflags;
6247: xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;
6248:
6249: while (cur != NULL) {
6250: ret = XML_RELAXNG_CONTENT_EMPTY;
6251: if ((cur->type == XML_RELAXNG_REF) ||
6252: (cur->type == XML_RELAXNG_PARENTREF)) {
6253: /*
6254: * This should actually be caught by list//element(ref) at the
6255: * element boundaries, c.f. Bug #159968 local refs are dropped
6256: * in step 4.19.
6257: */
6258: #if 0
6259: if (flags & XML_RELAXNG_IN_LIST) {
6260: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6261: "Found forbidden pattern list//ref\n", NULL,
6262: NULL);
6263: }
6264: #endif
6265: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6266: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6267: "Found forbidden pattern data/except//ref\n",
6268: NULL, NULL);
6269: }
6270: if (cur->content == NULL) {
6271: if (cur->type == XML_RELAXNG_PARENTREF)
6272: xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6273: "Internal found no define for parent refs\n",
6274: NULL, NULL);
6275: else
6276: xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6277: "Internal found no define for ref %s\n",
6278: (cur->name ? cur->name: BAD_CAST "null"), NULL);
6279: }
6280: if (cur->depth > -4) {
6281: cur->depth = -4;
6282: ret = xmlRelaxNGCheckRules(ctxt, cur->content,
6283: flags, cur->type);
6284: cur->depth = ret - 15;
6285: } else if (cur->depth == -4) {
6286: ret = XML_RELAXNG_CONTENT_COMPLEX;
6287: } else {
6288: ret = (xmlRelaxNGContentType) (cur->depth + 15);
6289: }
6290: } else if (cur->type == XML_RELAXNG_ELEMENT) {
6291: /*
6292: * The 7.3 Attribute derivation rule for groups is plugged there
6293: */
6294: xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6295: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6296: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6297: "Found forbidden pattern data/except//element(ref)\n",
6298: NULL, NULL);
6299: }
6300: if (flags & XML_RELAXNG_IN_LIST) {
6301: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6302: "Found forbidden pattern list//element(ref)\n",
6303: NULL, NULL);
6304: }
6305: if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6306: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6307: "Found forbidden pattern attribute//element(ref)\n",
6308: NULL, NULL);
6309: }
6310: if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6311: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6312: "Found forbidden pattern attribute//element(ref)\n",
6313: NULL, NULL);
6314: }
6315: /*
6316: * reset since in the simple form elements are only child
6317: * of grammar/define
6318: */
6319: nflags = 0;
6320: ret =
6321: xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
6322: if (ret != XML_RELAXNG_CONTENT_EMPTY) {
6323: xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6324: "Element %s attributes have a content type error\n",
6325: cur->name, NULL);
6326: }
6327: ret =
6328: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6329: cur->type);
6330: if (ret == XML_RELAXNG_CONTENT_ERROR) {
6331: xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6332: "Element %s has a content type error\n",
6333: cur->name, NULL);
6334: } else {
6335: ret = XML_RELAXNG_CONTENT_COMPLEX;
6336: }
6337: } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
6338: if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6339: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6340: "Found forbidden pattern attribute//attribute\n",
6341: NULL, NULL);
6342: }
6343: if (flags & XML_RELAXNG_IN_LIST) {
6344: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6345: "Found forbidden pattern list//attribute\n",
6346: NULL, NULL);
6347: }
6348: if (flags & XML_RELAXNG_IN_OOMGROUP) {
6349: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6350: "Found forbidden pattern oneOrMore//group//attribute\n",
6351: NULL, NULL);
6352: }
6353: if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
6354: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6355: "Found forbidden pattern oneOrMore//interleave//attribute\n",
6356: NULL, NULL);
6357: }
6358: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6359: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6360: "Found forbidden pattern data/except//attribute\n",
6361: NULL, NULL);
6362: }
6363: if (flags & XML_RELAXNG_IN_START) {
6364: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6365: "Found forbidden pattern start//attribute\n",
6366: NULL, NULL);
6367: }
6368: if ((!(flags & XML_RELAXNG_IN_ONEORMORE))
6369: && (cur->name == NULL)) {
6370: if (cur->ns == NULL) {
6371: xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6372: "Found anyName attribute without oneOrMore ancestor\n",
6373: NULL, NULL);
6374: } else {
6375: xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6376: "Found nsName attribute without oneOrMore ancestor\n",
6377: NULL, NULL);
6378: }
6379: }
6380: nflags = flags | XML_RELAXNG_IN_ATTRIBUTE;
6381: xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
6382: ret = XML_RELAXNG_CONTENT_EMPTY;
6383: } else if ((cur->type == XML_RELAXNG_ONEORMORE) ||
6384: (cur->type == XML_RELAXNG_ZEROORMORE)) {
6385: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6386: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6387: "Found forbidden pattern data/except//oneOrMore\n",
6388: NULL, NULL);
6389: }
6390: if (flags & XML_RELAXNG_IN_START) {
6391: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6392: "Found forbidden pattern start//oneOrMore\n",
6393: NULL, NULL);
6394: }
6395: nflags = flags | XML_RELAXNG_IN_ONEORMORE;
6396: ret =
6397: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6398: cur->type);
6399: ret = xmlRelaxNGGroupContentType(ret, ret);
6400: } else if (cur->type == XML_RELAXNG_LIST) {
6401: if (flags & XML_RELAXNG_IN_LIST) {
6402: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6403: "Found forbidden pattern list//list\n", NULL,
6404: NULL);
6405: }
6406: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6407: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6408: "Found forbidden pattern data/except//list\n",
6409: NULL, NULL);
6410: }
6411: if (flags & XML_RELAXNG_IN_START) {
6412: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6413: "Found forbidden pattern start//list\n", NULL,
6414: NULL);
6415: }
6416: nflags = flags | XML_RELAXNG_IN_LIST;
6417: ret =
6418: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6419: cur->type);
6420: } else if (cur->type == XML_RELAXNG_GROUP) {
6421: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6422: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6423: "Found forbidden pattern data/except//group\n",
6424: NULL, NULL);
6425: }
6426: if (flags & XML_RELAXNG_IN_START) {
6427: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6428: "Found forbidden pattern start//group\n", NULL,
6429: NULL);
6430: }
6431: if (flags & XML_RELAXNG_IN_ONEORMORE)
6432: nflags = flags | XML_RELAXNG_IN_OOMGROUP;
6433: else
6434: nflags = flags;
6435: ret =
6436: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6437: cur->type);
6438: /*
6439: * The 7.3 Attribute derivation rule for groups is plugged there
6440: */
6441: xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6442: } else if (cur->type == XML_RELAXNG_INTERLEAVE) {
6443: if (flags & XML_RELAXNG_IN_LIST) {
6444: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6445: "Found forbidden pattern list//interleave\n",
6446: NULL, NULL);
6447: }
6448: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6449: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6450: "Found forbidden pattern data/except//interleave\n",
6451: NULL, NULL);
6452: }
6453: if (flags & XML_RELAXNG_IN_START) {
6454: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6455: "Found forbidden pattern start//interleave\n",
6456: NULL, NULL);
6457: }
6458: if (flags & XML_RELAXNG_IN_ONEORMORE)
6459: nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE;
6460: else
6461: nflags = flags;
6462: ret =
6463: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6464: cur->type);
6465: } else if (cur->type == XML_RELAXNG_EXCEPT) {
6466: if ((cur->parent != NULL) &&
6467: (cur->parent->type == XML_RELAXNG_DATATYPE))
6468: nflags = flags | XML_RELAXNG_IN_DATAEXCEPT;
6469: else
6470: nflags = flags;
6471: ret =
6472: xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6473: cur->type);
6474: } else if (cur->type == XML_RELAXNG_DATATYPE) {
6475: if (flags & XML_RELAXNG_IN_START) {
6476: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6477: "Found forbidden pattern start//data\n", NULL,
6478: NULL);
6479: }
6480: xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6481: ret = XML_RELAXNG_CONTENT_SIMPLE;
6482: } else if (cur->type == XML_RELAXNG_VALUE) {
6483: if (flags & XML_RELAXNG_IN_START) {
6484: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
6485: "Found forbidden pattern start//value\n", NULL,
6486: NULL);
6487: }
6488: xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6489: ret = XML_RELAXNG_CONTENT_SIMPLE;
6490: } else if (cur->type == XML_RELAXNG_TEXT) {
6491: if (flags & XML_RELAXNG_IN_LIST) {
6492: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6493: "Found forbidden pattern list//text\n", NULL,
6494: NULL);
6495: }
6496: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6497: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6498: "Found forbidden pattern data/except//text\n",
6499: NULL, NULL);
6500: }
6501: if (flags & XML_RELAXNG_IN_START) {
6502: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6503: "Found forbidden pattern start//text\n", NULL,
6504: NULL);
6505: }
6506: ret = XML_RELAXNG_CONTENT_COMPLEX;
6507: } else if (cur->type == XML_RELAXNG_EMPTY) {
6508: if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6509: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6510: "Found forbidden pattern data/except//empty\n",
6511: NULL, NULL);
6512: }
6513: if (flags & XML_RELAXNG_IN_START) {
6514: xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6515: "Found forbidden pattern start//empty\n", NULL,
6516: NULL);
6517: }
6518: ret = XML_RELAXNG_CONTENT_EMPTY;
6519: } else if (cur->type == XML_RELAXNG_CHOICE) {
6520: xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
6521: ret =
6522: xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6523: } else {
6524: ret =
6525: xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6526: }
6527: cur = cur->next;
6528: if (ptype == XML_RELAXNG_GROUP) {
6529: val = xmlRelaxNGGroupContentType(val, ret);
6530: } else if (ptype == XML_RELAXNG_INTERLEAVE) {
6531: /*
6532: * TODO: scan complain that tmp is never used, seems on purpose
6533: * need double-checking
6534: */
6535: tmp = xmlRelaxNGGroupContentType(val, ret);
6536: if (tmp != XML_RELAXNG_CONTENT_ERROR)
6537: tmp = xmlRelaxNGMaxContentType(val, ret);
6538: } else if (ptype == XML_RELAXNG_CHOICE) {
6539: val = xmlRelaxNGMaxContentType(val, ret);
6540: } else if (ptype == XML_RELAXNG_LIST) {
6541: val = XML_RELAXNG_CONTENT_SIMPLE;
6542: } else if (ptype == XML_RELAXNG_EXCEPT) {
6543: if (ret == XML_RELAXNG_CONTENT_ERROR)
6544: val = XML_RELAXNG_CONTENT_ERROR;
6545: else
6546: val = XML_RELAXNG_CONTENT_SIMPLE;
6547: } else {
6548: val = xmlRelaxNGGroupContentType(val, ret);
6549: }
6550:
6551: }
6552: return (val);
6553: }
6554:
6555: /**
6556: * xmlRelaxNGParseGrammar:
6557: * @ctxt: a Relax-NG parser context
6558: * @nodes: grammar children nodes
6559: *
6560: * parse a Relax-NG <grammar> node
6561: *
6562: * Returns the internal xmlRelaxNGGrammarPtr built or
6563: * NULL in case of error
6564: */
6565: static xmlRelaxNGGrammarPtr
6566: xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
6567: {
6568: xmlRelaxNGGrammarPtr ret, tmp, old;
6569:
6570: #ifdef DEBUG_GRAMMAR
6571: xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n");
6572: #endif
6573:
6574: ret = xmlRelaxNGNewGrammar(ctxt);
6575: if (ret == NULL)
6576: return (NULL);
6577:
6578: /*
6579: * Link the new grammar in the tree
6580: */
6581: ret->parent = ctxt->grammar;
6582: if (ctxt->grammar != NULL) {
6583: tmp = ctxt->grammar->children;
6584: if (tmp == NULL) {
6585: ctxt->grammar->children = ret;
6586: } else {
6587: while (tmp->next != NULL)
6588: tmp = tmp->next;
6589: tmp->next = ret;
6590: }
6591: }
6592:
6593: old = ctxt->grammar;
6594: ctxt->grammar = ret;
6595: xmlRelaxNGParseGrammarContent(ctxt, nodes);
6596: ctxt->grammar = ret;
6597: if (ctxt->grammar == NULL) {
6598: xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
6599: "Failed to parse <grammar> content\n", NULL, NULL);
6600: } else if (ctxt->grammar->start == NULL) {
6601: xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
6602: "Element <grammar> has no <start>\n", NULL, NULL);
6603: }
6604:
6605: /*
6606: * Apply 4.17 mergingd rules to defines and starts
6607: */
6608: xmlRelaxNGCombineStart(ctxt, ret);
6609: if (ret->defs != NULL) {
6610: xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
6611: ctxt);
6612: }
6613:
6614: /*
6615: * link together defines and refs in this grammar
6616: */
6617: if (ret->refs != NULL) {
6618: xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
6619: ctxt);
6620: }
6621:
6622:
6623: /* @@@@ */
6624:
6625: ctxt->grammar = old;
6626: return (ret);
6627: }
6628:
6629: /**
6630: * xmlRelaxNGParseDocument:
6631: * @ctxt: a Relax-NG parser context
6632: * @node: the root node of the RelaxNG schema
6633: *
6634: * parse a Relax-NG definition resource and build an internal
6635: * xmlRelaxNG struture which can be used to validate instances.
6636: *
6637: * Returns the internal XML RelaxNG structure built or
6638: * NULL in case of error
6639: */
6640: static xmlRelaxNGPtr
6641: xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6642: {
6643: xmlRelaxNGPtr schema = NULL;
6644: const xmlChar *olddefine;
6645: xmlRelaxNGGrammarPtr old;
6646:
6647: if ((ctxt == NULL) || (node == NULL))
6648: return (NULL);
6649:
6650: schema = xmlRelaxNGNewRelaxNG(ctxt);
6651: if (schema == NULL)
6652: return (NULL);
6653:
6654: olddefine = ctxt->define;
6655: ctxt->define = NULL;
6656: if (IS_RELAXNG(node, "grammar")) {
6657: schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6658: } else {
6659: xmlRelaxNGGrammarPtr tmp, ret;
6660:
6661: schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
6662: if (schema->topgrammar == NULL) {
6663: return (schema);
6664: }
6665: /*
6666: * Link the new grammar in the tree
6667: */
6668: ret->parent = ctxt->grammar;
6669: if (ctxt->grammar != NULL) {
6670: tmp = ctxt->grammar->children;
6671: if (tmp == NULL) {
6672: ctxt->grammar->children = ret;
6673: } else {
6674: while (tmp->next != NULL)
6675: tmp = tmp->next;
6676: tmp->next = ret;
6677: }
6678: }
6679: old = ctxt->grammar;
6680: ctxt->grammar = ret;
6681: xmlRelaxNGParseStart(ctxt, node);
6682: if (old != NULL)
6683: ctxt->grammar = old;
6684: }
6685: ctxt->define = olddefine;
6686: if (schema->topgrammar->start != NULL) {
6687: xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
6688: if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
6689: xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
6690: while ((schema->topgrammar->start != NULL) &&
6691: (schema->topgrammar->start->type == XML_RELAXNG_NOOP) &&
6692: (schema->topgrammar->start->next != NULL))
6693: schema->topgrammar->start =
6694: schema->topgrammar->start->content;
6695: xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
6696: XML_RELAXNG_IN_START, XML_RELAXNG_NOOP);
6697: }
6698: }
6699: #ifdef DEBUG
6700: if (schema == NULL)
6701: xmlGenericError(xmlGenericErrorContext,
6702: "xmlRelaxNGParseDocument() failed\n");
6703: #endif
6704:
6705: return (schema);
6706: }
6707:
6708: /************************************************************************
6709: * *
6710: * Reading RelaxNGs *
6711: * *
6712: ************************************************************************/
6713:
6714: /**
6715: * xmlRelaxNGNewParserCtxt:
6716: * @URL: the location of the schema
6717: *
6718: * Create an XML RelaxNGs parse context for that file/resource expected
6719: * to contain an XML RelaxNGs file.
6720: *
6721: * Returns the parser context or NULL in case of error
6722: */
6723: xmlRelaxNGParserCtxtPtr
6724: xmlRelaxNGNewParserCtxt(const char *URL)
6725: {
6726: xmlRelaxNGParserCtxtPtr ret;
6727:
6728: if (URL == NULL)
6729: return (NULL);
6730:
6731: ret =
6732: (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6733: if (ret == NULL) {
6734: xmlRngPErrMemory(NULL, "building parser\n");
6735: return (NULL);
6736: }
6737: memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6738: ret->URL = xmlStrdup((const xmlChar *) URL);
6739: ret->error = xmlGenericError;
6740: ret->userData = xmlGenericErrorContext;
6741: return (ret);
6742: }
6743:
6744: /**
6745: * xmlRelaxNGNewMemParserCtxt:
6746: * @buffer: a pointer to a char array containing the schemas
6747: * @size: the size of the array
6748: *
6749: * Create an XML RelaxNGs parse context for that memory buffer expected
6750: * to contain an XML RelaxNGs file.
6751: *
6752: * Returns the parser context or NULL in case of error
6753: */
6754: xmlRelaxNGParserCtxtPtr
6755: xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
6756: {
6757: xmlRelaxNGParserCtxtPtr ret;
6758:
6759: if ((buffer == NULL) || (size <= 0))
6760: return (NULL);
6761:
6762: ret =
6763: (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6764: if (ret == NULL) {
6765: xmlRngPErrMemory(NULL, "building parser\n");
6766: return (NULL);
6767: }
6768: memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6769: ret->buffer = buffer;
6770: ret->size = size;
6771: ret->error = xmlGenericError;
6772: ret->userData = xmlGenericErrorContext;
6773: return (ret);
6774: }
6775:
6776: /**
6777: * xmlRelaxNGNewDocParserCtxt:
6778: * @doc: a preparsed document tree
6779: *
6780: * Create an XML RelaxNGs parser context for that document.
6781: * Note: since the process of compiling a RelaxNG schemas modifies the
6782: * document, the @doc parameter is duplicated internally.
6783: *
6784: * Returns the parser context or NULL in case of error
6785: */
6786: xmlRelaxNGParserCtxtPtr
6787: xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
6788: {
6789: xmlRelaxNGParserCtxtPtr ret;
6790: xmlDocPtr copy;
6791:
6792: if (doc == NULL)
6793: return (NULL);
6794: copy = xmlCopyDoc(doc, 1);
6795: if (copy == NULL)
6796: return (NULL);
6797:
6798: ret =
6799: (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6800: if (ret == NULL) {
6801: xmlRngPErrMemory(NULL, "building parser\n");
6802: return (NULL);
6803: }
6804: memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6805: ret->document = copy;
6806: ret->freedoc = 1;
6807: ret->userData = xmlGenericErrorContext;
6808: return (ret);
6809: }
6810:
6811: /**
6812: * xmlRelaxNGFreeParserCtxt:
6813: * @ctxt: the schema parser context
6814: *
6815: * Free the resources associated to the schema parser context
6816: */
6817: void
6818: xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
6819: {
6820: if (ctxt == NULL)
6821: return;
6822: if (ctxt->URL != NULL)
6823: xmlFree(ctxt->URL);
6824: if (ctxt->doc != NULL)
6825: xmlRelaxNGFreeDocument(ctxt->doc);
6826: if (ctxt->interleaves != NULL)
6827: xmlHashFree(ctxt->interleaves, NULL);
6828: if (ctxt->documents != NULL)
6829: xmlRelaxNGFreeDocumentList(ctxt->documents);
6830: if (ctxt->includes != NULL)
6831: xmlRelaxNGFreeIncludeList(ctxt->includes);
6832: if (ctxt->docTab != NULL)
6833: xmlFree(ctxt->docTab);
6834: if (ctxt->incTab != NULL)
6835: xmlFree(ctxt->incTab);
6836: if (ctxt->defTab != NULL) {
6837: int i;
6838:
6839: for (i = 0; i < ctxt->defNr; i++)
6840: xmlRelaxNGFreeDefine(ctxt->defTab[i]);
6841: xmlFree(ctxt->defTab);
6842: }
6843: if ((ctxt->document != NULL) && (ctxt->freedoc))
6844: xmlFreeDoc(ctxt->document);
6845: xmlFree(ctxt);
6846: }
6847:
6848: /**
6849: * xmlRelaxNGNormExtSpace:
6850: * @value: a value
6851: *
6852: * Removes the leading and ending spaces of the value
6853: * The string is modified "in situ"
6854: */
6855: static void
6856: xmlRelaxNGNormExtSpace(xmlChar * value)
6857: {
6858: xmlChar *start = value;
6859: xmlChar *cur = value;
6860:
6861: if (value == NULL)
6862: return;
6863:
6864: while (IS_BLANK_CH(*cur))
6865: cur++;
6866: if (cur == start) {
6867: do {
6868: while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
6869: cur++;
6870: if (*cur == 0)
6871: return;
6872: start = cur;
6873: while (IS_BLANK_CH(*cur))
6874: cur++;
6875: if (*cur == 0) {
6876: *start = 0;
6877: return;
6878: }
6879: } while (1);
6880: } else {
6881: do {
6882: while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
6883: *start++ = *cur++;
6884: if (*cur == 0) {
6885: *start = 0;
6886: return;
6887: }
6888: /* don't try to normalize the inner spaces */
6889: while (IS_BLANK_CH(*cur))
6890: cur++;
6891: if (*cur == 0) {
6892: *start = 0;
6893: return;
6894: }
6895: *start++ = *cur++;
6896: } while (1);
6897: }
6898: }
6899:
6900: /**
6901: * xmlRelaxNGCleanupAttributes:
6902: * @ctxt: a Relax-NG parser context
6903: * @node: a Relax-NG node
6904: *
6905: * Check all the attributes on the given node
6906: */
6907: static void
6908: xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6909: {
6910: xmlAttrPtr cur, next;
6911:
6912: cur = node->properties;
6913: while (cur != NULL) {
6914: next = cur->next;
6915: if ((cur->ns == NULL) ||
6916: (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
6917: if (xmlStrEqual(cur->name, BAD_CAST "name")) {
6918: if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
6919: (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
6920: (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
6921: (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
6922: (!xmlStrEqual(node->name, BAD_CAST "param")) &&
6923: (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6924: xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6925: "Attribute %s is not allowed on %s\n",
6926: cur->name, node->name);
6927: }
6928: } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
6929: if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
6930: (!xmlStrEqual(node->name, BAD_CAST "data"))) {
6931: xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6932: "Attribute %s is not allowed on %s\n",
6933: cur->name, node->name);
6934: }
6935: } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
6936: if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
6937: (!xmlStrEqual(node->name, BAD_CAST "include"))) {
6938: xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6939: "Attribute %s is not allowed on %s\n",
6940: cur->name, node->name);
6941: }
6942: } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
6943: if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
6944: (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6945: xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6946: "Attribute %s is not allowed on %s\n",
6947: cur->name, node->name);
6948: }
6949: } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
6950: xmlChar *val;
6951: xmlURIPtr uri;
6952:
6953: val = xmlNodeListGetString(node->doc, cur->children, 1);
6954: if (val != NULL) {
6955: if (val[0] != 0) {
6956: uri = xmlParseURI((const char *) val);
6957: if (uri == NULL) {
6958: xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6959: "Attribute %s contains invalid URI %s\n",
6960: cur->name, val);
6961: } else {
6962: if (uri->scheme == NULL) {
6963: xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6964: "Attribute %s URI %s is not absolute\n",
6965: cur->name, val);
6966: }
6967: if (uri->fragment != NULL) {
6968: xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6969: "Attribute %s URI %s has a fragment ID\n",
6970: cur->name, val);
6971: }
6972: xmlFreeURI(uri);
6973: }
6974: }
6975: xmlFree(val);
6976: }
6977: } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
6978: xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
6979: "Unknown attribute %s on %s\n", cur->name,
6980: node->name);
6981: }
6982: }
6983: cur = next;
6984: }
6985: }
6986:
6987: /**
6988: * xmlRelaxNGCleanupTree:
6989: * @ctxt: a Relax-NG parser context
6990: * @root: an xmlNodePtr subtree
6991: *
6992: * Cleanup the subtree from unwanted nodes for parsing, resolve
6993: * Include and externalRef lookups.
6994: */
6995: static void
6996: xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
6997: {
6998: xmlNodePtr cur, delete;
6999:
7000: delete = NULL;
7001: cur = root;
7002: while (cur != NULL) {
7003: if (delete != NULL) {
7004: xmlUnlinkNode(delete);
7005: xmlFreeNode(delete);
7006: delete = NULL;
7007: }
7008: if (cur->type == XML_ELEMENT_NODE) {
7009: /*
7010: * Simplification 4.1. Annotations
7011: */
7012: if ((cur->ns == NULL) ||
7013: (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
7014: if ((cur->parent != NULL) &&
7015: (cur->parent->type == XML_ELEMENT_NODE) &&
7016: ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) ||
7017: (xmlStrEqual(cur->parent->name, BAD_CAST "value")) ||
7018: (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) {
7019: xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
7020: "element %s doesn't allow foreign elements\n",
7021: cur->parent->name, NULL);
7022: }
7023: delete = cur;
7024: goto skip_children;
7025: } else {
7026: xmlRelaxNGCleanupAttributes(ctxt, cur);
7027: if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) {
7028: xmlChar *href, *ns, *base, *URL;
7029: xmlRelaxNGDocumentPtr docu;
7030: xmlNodePtr tmp;
7031: xmlURIPtr uri;
7032:
7033: ns = xmlGetProp(cur, BAD_CAST "ns");
7034: if (ns == NULL) {
7035: tmp = cur->parent;
7036: while ((tmp != NULL) &&
7037: (tmp->type == XML_ELEMENT_NODE)) {
7038: ns = xmlGetProp(tmp, BAD_CAST "ns");
7039: if (ns != NULL)
7040: break;
7041: tmp = tmp->parent;
7042: }
7043: }
7044: href = xmlGetProp(cur, BAD_CAST "href");
7045: if (href == NULL) {
7046: xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7047: "xmlRelaxNGParse: externalRef has no href attribute\n",
7048: NULL, NULL);
7049: if (ns != NULL)
7050: xmlFree(ns);
7051: delete = cur;
7052: goto skip_children;
7053: }
7054: uri = xmlParseURI((const char *) href);
7055: if (uri == NULL) {
7056: xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7057: "Incorrect URI for externalRef %s\n",
7058: href, NULL);
7059: if (ns != NULL)
7060: xmlFree(ns);
7061: if (href != NULL)
7062: xmlFree(href);
7063: delete = cur;
7064: goto skip_children;
7065: }
7066: if (uri->fragment != NULL) {
7067: xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7068: "Fragment forbidden in URI for externalRef %s\n",
7069: href, NULL);
7070: if (ns != NULL)
7071: xmlFree(ns);
7072: xmlFreeURI(uri);
7073: if (href != NULL)
7074: xmlFree(href);
7075: delete = cur;
7076: goto skip_children;
7077: }
7078: xmlFreeURI(uri);
7079: base = xmlNodeGetBase(cur->doc, cur);
7080: URL = xmlBuildURI(href, base);
7081: if (URL == NULL) {
7082: xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7083: "Failed to compute URL for externalRef %s\n",
7084: href, NULL);
7085: if (ns != NULL)
7086: xmlFree(ns);
7087: if (href != NULL)
7088: xmlFree(href);
7089: if (base != NULL)
7090: xmlFree(base);
7091: delete = cur;
7092: goto skip_children;
7093: }
7094: if (href != NULL)
7095: xmlFree(href);
7096: if (base != NULL)
7097: xmlFree(base);
7098: docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
7099: if (docu == NULL) {
7100: xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
7101: "Failed to load externalRef %s\n", URL,
7102: NULL);
7103: if (ns != NULL)
7104: xmlFree(ns);
7105: xmlFree(URL);
7106: delete = cur;
7107: goto skip_children;
7108: }
7109: if (ns != NULL)
7110: xmlFree(ns);
7111: xmlFree(URL);
7112: cur->psvi = docu;
7113: } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
7114: xmlChar *href, *ns, *base, *URL;
7115: xmlRelaxNGIncludePtr incl;
7116: xmlNodePtr tmp;
7117:
7118: href = xmlGetProp(cur, BAD_CAST "href");
7119: if (href == NULL) {
7120: xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7121: "xmlRelaxNGParse: include has no href attribute\n",
7122: NULL, NULL);
7123: delete = cur;
7124: goto skip_children;
7125: }
7126: base = xmlNodeGetBase(cur->doc, cur);
7127: URL = xmlBuildURI(href, base);
7128: if (URL == NULL) {
7129: xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7130: "Failed to compute URL for include %s\n",
7131: href, NULL);
7132: if (href != NULL)
7133: xmlFree(href);
7134: if (base != NULL)
7135: xmlFree(base);
7136: delete = cur;
7137: goto skip_children;
7138: }
7139: if (href != NULL)
7140: xmlFree(href);
7141: if (base != NULL)
7142: xmlFree(base);
7143: ns = xmlGetProp(cur, BAD_CAST "ns");
7144: if (ns == NULL) {
7145: tmp = cur->parent;
7146: while ((tmp != NULL) &&
7147: (tmp->type == XML_ELEMENT_NODE)) {
7148: ns = xmlGetProp(tmp, BAD_CAST "ns");
7149: if (ns != NULL)
7150: break;
7151: tmp = tmp->parent;
7152: }
7153: }
7154: incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
7155: if (ns != NULL)
7156: xmlFree(ns);
7157: if (incl == NULL) {
7158: xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
7159: "Failed to load include %s\n", URL,
7160: NULL);
7161: xmlFree(URL);
7162: delete = cur;
7163: goto skip_children;
7164: }
7165: xmlFree(URL);
7166: cur->psvi = incl;
7167: } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
7168: (xmlStrEqual(cur->name, BAD_CAST "attribute")))
7169: {
7170: xmlChar *name, *ns;
7171: xmlNodePtr text = NULL;
7172:
7173: /*
7174: * Simplification 4.8. name attribute of element
7175: * and attribute elements
7176: */
7177: name = xmlGetProp(cur, BAD_CAST "name");
7178: if (name != NULL) {
7179: if (cur->children == NULL) {
7180: text =
7181: xmlNewChild(cur, cur->ns, BAD_CAST "name",
7182: name);
7183: } else {
7184: xmlNodePtr node;
7185:
7186: node = xmlNewDocNode(cur->doc, cur->ns,
7187: BAD_CAST "name", NULL);
7188: if (node != NULL) {
7189: xmlAddPrevSibling(cur->children, node);
7190: text = xmlNewText(name);
7191: xmlAddChild(node, text);
7192: text = node;
7193: }
7194: }
7195: if (text == NULL) {
7196: xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
7197: "Failed to create a name %s element\n",
7198: name, NULL);
7199: }
7200: xmlUnsetProp(cur, BAD_CAST "name");
7201: xmlFree(name);
7202: ns = xmlGetProp(cur, BAD_CAST "ns");
7203: if (ns != NULL) {
7204: if (text != NULL) {
7205: xmlSetProp(text, BAD_CAST "ns", ns);
7206: /* xmlUnsetProp(cur, BAD_CAST "ns"); */
7207: }
7208: xmlFree(ns);
7209: } else if (xmlStrEqual(cur->name,
7210: BAD_CAST "attribute")) {
7211: xmlSetProp(text, BAD_CAST "ns", BAD_CAST "");
7212: }
7213: }
7214: } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) ||
7215: (xmlStrEqual(cur->name, BAD_CAST "nsName")) ||
7216: (xmlStrEqual(cur->name, BAD_CAST "value"))) {
7217: /*
7218: * Simplification 4.8. name attribute of element
7219: * and attribute elements
7220: */
7221: if (xmlHasProp(cur, BAD_CAST "ns") == NULL) {
7222: xmlNodePtr node;
7223: xmlChar *ns = NULL;
7224:
7225: node = cur->parent;
7226: while ((node != NULL) &&
7227: (node->type == XML_ELEMENT_NODE)) {
7228: ns = xmlGetProp(node, BAD_CAST "ns");
7229: if (ns != NULL) {
7230: break;
7231: }
7232: node = node->parent;
7233: }
7234: if (ns == NULL) {
7235: xmlSetProp(cur, BAD_CAST "ns", BAD_CAST "");
7236: } else {
7237: xmlSetProp(cur, BAD_CAST "ns", ns);
7238: xmlFree(ns);
7239: }
7240: }
7241: if (xmlStrEqual(cur->name, BAD_CAST "name")) {
7242: xmlChar *name, *local, *prefix;
7243:
7244: /*
7245: * Simplification: 4.10. QNames
7246: */
7247: name = xmlNodeGetContent(cur);
7248: if (name != NULL) {
7249: local = xmlSplitQName2(name, &prefix);
7250: if (local != NULL) {
7251: xmlNsPtr ns;
7252:
7253: ns = xmlSearchNs(cur->doc, cur, prefix);
7254: if (ns == NULL) {
7255: xmlRngPErr(ctxt, cur,
7256: XML_RNGP_PREFIX_UNDEFINED,
7257: "xmlRelaxNGParse: no namespace for prefix %s\n",
7258: prefix, NULL);
7259: } else {
7260: xmlSetProp(cur, BAD_CAST "ns",
7261: ns->href);
7262: xmlNodeSetContent(cur, local);
7263: }
7264: xmlFree(local);
7265: xmlFree(prefix);
7266: }
7267: xmlFree(name);
7268: }
7269: }
7270: /*
7271: * 4.16
7272: */
7273: if (xmlStrEqual(cur->name, BAD_CAST "nsName")) {
7274: if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7275: xmlRngPErr(ctxt, cur,
7276: XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
7277: "Found nsName/except//nsName forbidden construct\n",
7278: NULL, NULL);
7279: }
7280: }
7281: } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
7282: (cur != root)) {
7283: int oldflags = ctxt->flags;
7284:
7285: /*
7286: * 4.16
7287: */
7288: if ((cur->parent != NULL) &&
7289: (xmlStrEqual
7290: (cur->parent->name, BAD_CAST "anyName"))) {
7291: ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
7292: xmlRelaxNGCleanupTree(ctxt, cur);
7293: ctxt->flags = oldflags;
7294: goto skip_children;
7295: } else if ((cur->parent != NULL) &&
7296: (xmlStrEqual
7297: (cur->parent->name, BAD_CAST "nsName"))) {
7298: ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
7299: xmlRelaxNGCleanupTree(ctxt, cur);
7300: ctxt->flags = oldflags;
7301: goto skip_children;
7302: }
7303: } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) {
7304: /*
7305: * 4.16
7306: */
7307: if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
7308: xmlRngPErr(ctxt, cur,
7309: XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
7310: "Found anyName/except//anyName forbidden construct\n",
7311: NULL, NULL);
7312: } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7313: xmlRngPErr(ctxt, cur,
7314: XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
7315: "Found nsName/except//anyName forbidden construct\n",
7316: NULL, NULL);
7317: }
7318: }
7319: /*
7320: * Thisd is not an else since "include" is transformed
7321: * into a div
7322: */
7323: if (xmlStrEqual(cur->name, BAD_CAST "div")) {
7324: xmlChar *ns;
7325: xmlNodePtr child, ins, tmp;
7326:
7327: /*
7328: * implements rule 4.11
7329: */
7330:
7331: ns = xmlGetProp(cur, BAD_CAST "ns");
7332:
7333: child = cur->children;
7334: ins = cur;
7335: while (child != NULL) {
7336: if (ns != NULL) {
7337: if (!xmlHasProp(child, BAD_CAST "ns")) {
7338: xmlSetProp(child, BAD_CAST "ns", ns);
7339: }
7340: }
7341: tmp = child->next;
7342: xmlUnlinkNode(child);
7343: ins = xmlAddNextSibling(ins, child);
7344: child = tmp;
7345: }
7346: if (ns != NULL)
7347: xmlFree(ns);
7348: /*
7349: * Since we are about to delete cur, if it's nsDef is non-NULL we
7350: * need to preserve it (it contains the ns definitions for the
7351: * children we just moved). We'll just stick it on to the end
7352: * of cur->parent's list, since it's never going to be re-serialized
7353: * (bug 143738).
7354: */
7355: if (cur->nsDef != NULL) {
7356: xmlNsPtr parDef = (xmlNsPtr)&cur->parent->nsDef;
7357: while (parDef->next != NULL)
7358: parDef = parDef->next;
7359: parDef->next = cur->nsDef;
7360: cur->nsDef = NULL;
7361: }
7362: delete = cur;
7363: goto skip_children;
7364: }
7365: }
7366: }
7367: /*
7368: * Simplification 4.2 whitespaces
7369: */
7370: else if ((cur->type == XML_TEXT_NODE) ||
7371: (cur->type == XML_CDATA_SECTION_NODE)) {
7372: if (IS_BLANK_NODE(cur)) {
7373: if (cur->parent->type == XML_ELEMENT_NODE) {
7374: if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
7375: &&
7376: (!xmlStrEqual
7377: (cur->parent->name, BAD_CAST "param")))
7378: delete = cur;
7379: } else {
7380: delete = cur;
7381: goto skip_children;
7382: }
7383: }
7384: } else {
7385: delete = cur;
7386: goto skip_children;
7387: }
7388:
7389: /*
7390: * Skip to next node
7391: */
7392: if (cur->children != NULL) {
7393: if ((cur->children->type != XML_ENTITY_DECL) &&
7394: (cur->children->type != XML_ENTITY_REF_NODE) &&
7395: (cur->children->type != XML_ENTITY_NODE)) {
7396: cur = cur->children;
7397: continue;
7398: }
7399: }
7400: skip_children:
7401: if (cur->next != NULL) {
7402: cur = cur->next;
7403: continue;
7404: }
7405:
7406: do {
7407: cur = cur->parent;
7408: if (cur == NULL)
7409: break;
7410: if (cur == root) {
7411: cur = NULL;
7412: break;
7413: }
7414: if (cur->next != NULL) {
7415: cur = cur->next;
7416: break;
7417: }
7418: } while (cur != NULL);
7419: }
7420: if (delete != NULL) {
7421: xmlUnlinkNode(delete);
7422: xmlFreeNode(delete);
7423: delete = NULL;
7424: }
7425: }
7426:
7427: /**
7428: * xmlRelaxNGCleanupDoc:
7429: * @ctxt: a Relax-NG parser context
7430: * @doc: an xmldocPtr document pointer
7431: *
7432: * Cleanup the document from unwanted nodes for parsing, resolve
7433: * Include and externalRef lookups.
7434: *
7435: * Returns the cleaned up document or NULL in case of error
7436: */
7437: static xmlDocPtr
7438: xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
7439: {
7440: xmlNodePtr root;
7441:
7442: /*
7443: * Extract the root
7444: */
7445: root = xmlDocGetRootElement(doc);
7446: if (root == NULL) {
7447: xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7448: ctxt->URL, NULL);
7449: return (NULL);
7450: }
7451: xmlRelaxNGCleanupTree(ctxt, root);
7452: return (doc);
7453: }
7454:
7455: /**
7456: * xmlRelaxNGParse:
7457: * @ctxt: a Relax-NG parser context
7458: *
7459: * parse a schema definition resource and build an internal
7460: * XML Shema struture which can be used to validate instances.
7461: *
7462: * Returns the internal XML RelaxNG structure built from the resource or
7463: * NULL in case of error
7464: */
7465: xmlRelaxNGPtr
7466: xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
7467: {
7468: xmlRelaxNGPtr ret = NULL;
7469: xmlDocPtr doc;
7470: xmlNodePtr root;
7471:
7472: xmlRelaxNGInitTypes();
7473:
7474: if (ctxt == NULL)
7475: return (NULL);
7476:
7477: /*
7478: * First step is to parse the input document into an DOM/Infoset
7479: */
7480: if (ctxt->URL != NULL) {
7481: doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
7482: if (doc == NULL) {
7483: xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7484: "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
7485: NULL);
7486: return (NULL);
7487: }
7488: } else if (ctxt->buffer != NULL) {
7489: doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
7490: if (doc == NULL) {
7491: xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7492: "xmlRelaxNGParse: could not parse schemas\n", NULL,
7493: NULL);
7494: return (NULL);
7495: }
7496: doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7497: ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7498: } else if (ctxt->document != NULL) {
7499: doc = ctxt->document;
7500: } else {
7501: xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
7502: "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
7503: return (NULL);
7504: }
7505: ctxt->document = doc;
7506:
7507: /*
7508: * Some preprocessing of the document content
7509: */
7510: doc = xmlRelaxNGCleanupDoc(ctxt, doc);
7511: if (doc == NULL) {
7512: xmlFreeDoc(ctxt->document);
7513: ctxt->document = NULL;
7514: return (NULL);
7515: }
7516:
7517: /*
7518: * Then do the parsing for good
7519: */
7520: root = xmlDocGetRootElement(doc);
7521: if (root == NULL) {
7522: xmlRngPErr(ctxt, (xmlNodePtr) doc,
7523: XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7524: (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
7525:
7526: xmlFreeDoc(ctxt->document);
7527: ctxt->document = NULL;
7528: return (NULL);
7529: }
7530: ret = xmlRelaxNGParseDocument(ctxt, root);
7531: if (ret == NULL) {
7532: xmlFreeDoc(ctxt->document);
7533: ctxt->document = NULL;
7534: return (NULL);
7535: }
7536:
7537: /*
7538: * Check the ref/defines links
7539: */
7540: /*
7541: * try to preprocess interleaves
7542: */
7543: if (ctxt->interleaves != NULL) {
7544: xmlHashScan(ctxt->interleaves,
7545: (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
7546: }
7547:
7548: /*
7549: * if there was a parsing error return NULL
7550: */
7551: if (ctxt->nbErrors > 0) {
7552: xmlRelaxNGFree(ret);
7553: ctxt->document = NULL;
7554: xmlFreeDoc(doc);
7555: return (NULL);
7556: }
7557:
7558: /*
7559: * try to compile (parts of) the schemas
7560: */
7561: if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) {
7562: if (ret->topgrammar->start->type != XML_RELAXNG_START) {
7563: xmlRelaxNGDefinePtr def;
7564:
7565: def = xmlRelaxNGNewDefine(ctxt, NULL);
7566: if (def != NULL) {
7567: def->type = XML_RELAXNG_START;
7568: def->content = ret->topgrammar->start;
7569: ret->topgrammar->start = def;
7570: }
7571: }
7572: xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
7573: }
7574:
7575: /*
7576: * Transfer the pointer for cleanup at the schema level.
7577: */
7578: ret->doc = doc;
7579: ctxt->document = NULL;
7580: ret->documents = ctxt->documents;
7581: ctxt->documents = NULL;
7582:
7583: ret->includes = ctxt->includes;
7584: ctxt->includes = NULL;
7585: ret->defNr = ctxt->defNr;
7586: ret->defTab = ctxt->defTab;
7587: ctxt->defTab = NULL;
7588: if (ctxt->idref == 1)
7589: ret->idref = 1;
7590:
7591: return (ret);
7592: }
7593:
7594: /**
7595: * xmlRelaxNGSetParserErrors:
7596: * @ctxt: a Relax-NG validation context
7597: * @err: the error callback
7598: * @warn: the warning callback
7599: * @ctx: contextual data for the callbacks
7600: *
7601: * Set the callback functions used to handle errors for a validation context
7602: */
7603: void
7604: xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7605: xmlRelaxNGValidityErrorFunc err,
7606: xmlRelaxNGValidityWarningFunc warn, void *ctx)
7607: {
7608: if (ctxt == NULL)
7609: return;
7610: ctxt->error = err;
7611: ctxt->warning = warn;
7612: ctxt->serror = NULL;
7613: ctxt->userData = ctx;
7614: }
7615:
7616: /**
7617: * xmlRelaxNGGetParserErrors:
7618: * @ctxt: a Relax-NG validation context
7619: * @err: the error callback result
7620: * @warn: the warning callback result
7621: * @ctx: contextual data for the callbacks result
7622: *
7623: * Get the callback information used to handle errors for a validation context
7624: *
7625: * Returns -1 in case of failure, 0 otherwise.
7626: */
7627: int
7628: xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
7629: xmlRelaxNGValidityErrorFunc * err,
7630: xmlRelaxNGValidityWarningFunc * warn, void **ctx)
7631: {
7632: if (ctxt == NULL)
7633: return (-1);
7634: if (err != NULL)
7635: *err = ctxt->error;
7636: if (warn != NULL)
7637: *warn = ctxt->warning;
7638: if (ctx != NULL)
7639: *ctx = ctxt->userData;
7640: return (0);
7641: }
7642:
7643: /**
7644: * xmlRelaxNGSetParserStructuredErrors:
7645: * @ctxt: a Relax-NG parser context
7646: * @serror: the error callback
7647: * @ctx: contextual data for the callbacks
7648: *
7649: * Set the callback functions used to handle errors for a parsing context
7650: */
7651: void
7652: xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt,
7653: xmlStructuredErrorFunc serror,
7654: void *ctx)
7655: {
7656: if (ctxt == NULL)
7657: return;
7658: ctxt->serror = serror;
7659: ctxt->error = NULL;
7660: ctxt->warning = NULL;
7661: ctxt->userData = ctx;
7662: }
7663:
7664: #ifdef LIBXML_OUTPUT_ENABLED
7665:
7666: /************************************************************************
7667: * *
7668: * Dump back a compiled form *
7669: * *
7670: ************************************************************************/
7671: static void xmlRelaxNGDumpDefine(FILE * output,
7672: xmlRelaxNGDefinePtr define);
7673:
7674: /**
7675: * xmlRelaxNGDumpDefines:
7676: * @output: the file output
7677: * @defines: a list of define structures
7678: *
7679: * Dump a RelaxNG structure back
7680: */
7681: static void
7682: xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines)
7683: {
7684: while (defines != NULL) {
7685: xmlRelaxNGDumpDefine(output, defines);
7686: defines = defines->next;
7687: }
7688: }
7689:
7690: /**
7691: * xmlRelaxNGDumpDefine:
7692: * @output: the file output
7693: * @define: a define structure
7694: *
7695: * Dump a RelaxNG structure back
7696: */
7697: static void
7698: xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
7699: {
7700: if (define == NULL)
7701: return;
7702: switch (define->type) {
7703: case XML_RELAXNG_EMPTY:
7704: fprintf(output, "<empty/>\n");
7705: break;
7706: case XML_RELAXNG_NOT_ALLOWED:
7707: fprintf(output, "<notAllowed/>\n");
7708: break;
7709: case XML_RELAXNG_TEXT:
7710: fprintf(output, "<text/>\n");
7711: break;
7712: case XML_RELAXNG_ELEMENT:
7713: fprintf(output, "<element>\n");
7714: if (define->name != NULL) {
7715: fprintf(output, "<name");
7716: if (define->ns != NULL)
7717: fprintf(output, " ns=\"%s\"", define->ns);
7718: fprintf(output, ">%s</name>\n", define->name);
7719: }
7720: xmlRelaxNGDumpDefines(output, define->attrs);
7721: xmlRelaxNGDumpDefines(output, define->content);
7722: fprintf(output, "</element>\n");
7723: break;
7724: case XML_RELAXNG_LIST:
7725: fprintf(output, "<list>\n");
7726: xmlRelaxNGDumpDefines(output, define->content);
7727: fprintf(output, "</list>\n");
7728: break;
7729: case XML_RELAXNG_ONEORMORE:
7730: fprintf(output, "<oneOrMore>\n");
7731: xmlRelaxNGDumpDefines(output, define->content);
7732: fprintf(output, "</oneOrMore>\n");
7733: break;
7734: case XML_RELAXNG_ZEROORMORE:
7735: fprintf(output, "<zeroOrMore>\n");
7736: xmlRelaxNGDumpDefines(output, define->content);
7737: fprintf(output, "</zeroOrMore>\n");
7738: break;
7739: case XML_RELAXNG_CHOICE:
7740: fprintf(output, "<choice>\n");
7741: xmlRelaxNGDumpDefines(output, define->content);
7742: fprintf(output, "</choice>\n");
7743: break;
7744: case XML_RELAXNG_GROUP:
7745: fprintf(output, "<group>\n");
7746: xmlRelaxNGDumpDefines(output, define->content);
7747: fprintf(output, "</group>\n");
7748: break;
7749: case XML_RELAXNG_INTERLEAVE:
7750: fprintf(output, "<interleave>\n");
7751: xmlRelaxNGDumpDefines(output, define->content);
7752: fprintf(output, "</interleave>\n");
7753: break;
7754: case XML_RELAXNG_OPTIONAL:
7755: fprintf(output, "<optional>\n");
7756: xmlRelaxNGDumpDefines(output, define->content);
7757: fprintf(output, "</optional>\n");
7758: break;
7759: case XML_RELAXNG_ATTRIBUTE:
7760: fprintf(output, "<attribute>\n");
7761: xmlRelaxNGDumpDefines(output, define->content);
7762: fprintf(output, "</attribute>\n");
7763: break;
7764: case XML_RELAXNG_DEF:
7765: fprintf(output, "<define");
7766: if (define->name != NULL)
7767: fprintf(output, " name=\"%s\"", define->name);
7768: fprintf(output, ">\n");
7769: xmlRelaxNGDumpDefines(output, define->content);
7770: fprintf(output, "</define>\n");
7771: break;
7772: case XML_RELAXNG_REF:
7773: fprintf(output, "<ref");
7774: if (define->name != NULL)
7775: fprintf(output, " name=\"%s\"", define->name);
7776: fprintf(output, ">\n");
7777: xmlRelaxNGDumpDefines(output, define->content);
7778: fprintf(output, "</ref>\n");
7779: break;
7780: case XML_RELAXNG_PARENTREF:
7781: fprintf(output, "<parentRef");
7782: if (define->name != NULL)
7783: fprintf(output, " name=\"%s\"", define->name);
7784: fprintf(output, ">\n");
7785: xmlRelaxNGDumpDefines(output, define->content);
7786: fprintf(output, "</parentRef>\n");
7787: break;
7788: case XML_RELAXNG_EXTERNALREF:
7789: fprintf(output, "<externalRef>");
7790: xmlRelaxNGDumpDefines(output, define->content);
7791: fprintf(output, "</externalRef>\n");
7792: break;
7793: case XML_RELAXNG_DATATYPE:
7794: case XML_RELAXNG_VALUE:
7795: TODO break;
7796: case XML_RELAXNG_START:
7797: case XML_RELAXNG_EXCEPT:
7798: case XML_RELAXNG_PARAM:
7799: TODO break;
7800: case XML_RELAXNG_NOOP:
7801: xmlRelaxNGDumpDefines(output, define->content);
7802: break;
7803: }
7804: }
7805:
7806: /**
7807: * xmlRelaxNGDumpGrammar:
7808: * @output: the file output
7809: * @grammar: a grammar structure
7810: * @top: is this a top grammar
7811: *
7812: * Dump a RelaxNG structure back
7813: */
7814: static void
7815: xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top)
7816: {
7817: if (grammar == NULL)
7818: return;
7819:
7820: fprintf(output, "<grammar");
7821: if (top)
7822: fprintf(output, " xmlns=\"http://relaxng.org/ns/structure/1.0\"");
7823: switch (grammar->combine) {
7824: case XML_RELAXNG_COMBINE_UNDEFINED:
7825: break;
7826: case XML_RELAXNG_COMBINE_CHOICE:
7827: fprintf(output, " combine=\"choice\"");
7828: break;
7829: case XML_RELAXNG_COMBINE_INTERLEAVE:
7830: fprintf(output, " combine=\"interleave\"");
7831: break;
7832: default:
7833: fprintf(output, " <!-- invalid combine value -->");
7834: }
7835: fprintf(output, ">\n");
7836: if (grammar->start == NULL) {
7837: fprintf(output, " <!-- grammar had no start -->");
7838: } else {
7839: fprintf(output, "<start>\n");
7840: xmlRelaxNGDumpDefine(output, grammar->start);
7841: fprintf(output, "</start>\n");
7842: }
7843: /* TODO ? Dump the defines ? */
7844: fprintf(output, "</grammar>\n");
7845: }
7846:
7847: /**
7848: * xmlRelaxNGDump:
7849: * @output: the file output
7850: * @schema: a schema structure
7851: *
7852: * Dump a RelaxNG structure back
7853: */
7854: void
7855: xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
7856: {
7857: if (output == NULL)
7858: return;
7859: if (schema == NULL) {
7860: fprintf(output, "RelaxNG empty or failed to compile\n");
7861: return;
7862: }
7863: fprintf(output, "RelaxNG: ");
7864: if (schema->doc == NULL) {
7865: fprintf(output, "no document\n");
7866: } else if (schema->doc->URL != NULL) {
7867: fprintf(output, "%s\n", schema->doc->URL);
7868: } else {
7869: fprintf(output, "\n");
7870: }
7871: if (schema->topgrammar == NULL) {
7872: fprintf(output, "RelaxNG has no top grammar\n");
7873: return;
7874: }
7875: xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1);
7876: }
7877:
7878: /**
7879: * xmlRelaxNGDumpTree:
7880: * @output: the file output
7881: * @schema: a schema structure
7882: *
7883: * Dump the transformed RelaxNG tree.
7884: */
7885: void
7886: xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema)
7887: {
7888: if (output == NULL)
7889: return;
7890: if (schema == NULL) {
7891: fprintf(output, "RelaxNG empty or failed to compile\n");
7892: return;
7893: }
7894: if (schema->doc == NULL) {
7895: fprintf(output, "no document\n");
7896: } else {
7897: xmlDocDump(output, schema->doc);
7898: }
7899: }
7900: #endif /* LIBXML_OUTPUT_ENABLED */
7901:
7902: /************************************************************************
7903: * *
7904: * Validation of compiled content *
7905: * *
7906: ************************************************************************/
7907: static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
7908: xmlRelaxNGDefinePtr define);
7909:
7910: /**
7911: * xmlRelaxNGValidateCompiledCallback:
7912: * @exec: the regular expression instance
7913: * @token: the token which matched
7914: * @transdata: callback data, the define for the subelement if available
7915: @ @inputdata: callback data, the Relax NG validation context
7916: *
7917: * Handle the callback and if needed validate the element children.
7918: */
7919: static void
7920: xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED,
7921: const xmlChar * token,
7922: void *transdata, void *inputdata)
7923: {
7924: xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
7925: xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
7926: int ret;
7927:
7928: #ifdef DEBUG_COMPILE
7929: xmlGenericError(xmlGenericErrorContext,
7930: "Compiled callback for: '%s'\n", token);
7931: #endif
7932: if (ctxt == NULL) {
7933: fprintf(stderr, "callback on %s missing context\n", token);
7934: return;
7935: }
7936: if (define == NULL) {
7937: if (token[0] == '#')
7938: return;
7939: fprintf(stderr, "callback on %s missing define\n", token);
7940: if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7941: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7942: return;
7943: }
7944: if ((ctxt == NULL) || (define == NULL)) {
7945: fprintf(stderr, "callback on %s missing info\n", token);
7946: if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
7947: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7948: return;
7949: } else if (define->type != XML_RELAXNG_ELEMENT) {
7950: fprintf(stderr, "callback on %s define is not element\n", token);
7951: if (ctxt->errNo == XML_RELAXNG_OK)
7952: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
7953: return;
7954: }
7955: ret = xmlRelaxNGValidateDefinition(ctxt, define);
7956: if (ret != 0)
7957: ctxt->perr = ret;
7958: }
7959:
7960: /**
7961: * xmlRelaxNGValidateCompiledContent:
7962: * @ctxt: the RelaxNG validation context
7963: * @regexp: the regular expression as compiled
7964: * @content: list of children to test against the regexp
7965: *
7966: * Validate the content model of an element or start using the regexp
7967: *
7968: * Returns 0 in case of success, -1 in case of error.
7969: */
7970: static int
7971: xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
7972: xmlRegexpPtr regexp, xmlNodePtr content)
7973: {
7974: xmlRegExecCtxtPtr exec;
7975: xmlNodePtr cur;
7976: int ret = 0;
7977: int oldperr;
7978:
7979: if ((ctxt == NULL) || (regexp == NULL))
7980: return (-1);
7981: oldperr = ctxt->perr;
7982: exec = xmlRegNewExecCtxt(regexp,
7983: xmlRelaxNGValidateCompiledCallback, ctxt);
7984: ctxt->perr = 0;
7985: cur = content;
7986: while (cur != NULL) {
7987: ctxt->state->seq = cur;
7988: switch (cur->type) {
7989: case XML_TEXT_NODE:
7990: case XML_CDATA_SECTION_NODE:
7991: if (xmlIsBlankNode(cur))
7992: break;
7993: ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
7994: if (ret < 0) {
7995: VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG,
7996: cur->parent->name);
7997: }
7998: break;
7999: case XML_ELEMENT_NODE:
8000: if (cur->ns != NULL) {
8001: ret = xmlRegExecPushString2(exec, cur->name,
8002: cur->ns->href, ctxt);
8003: } else {
8004: ret = xmlRegExecPushString(exec, cur->name, ctxt);
8005: }
8006: if (ret < 0) {
8007: VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, cur->name);
8008: }
8009: break;
8010: default:
8011: break;
8012: }
8013: if (ret < 0)
8014: break;
8015: /*
8016: * Switch to next element
8017: */
8018: cur = cur->next;
8019: }
8020: ret = xmlRegExecPushString(exec, NULL, NULL);
8021: if (ret == 1) {
8022: ret = 0;
8023: ctxt->state->seq = NULL;
8024: } else if (ret == 0) {
8025: /*
8026: * TODO: get some of the names needed to exit the current state of exec
8027: */
8028: VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
8029: ret = -1;
8030: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8031: xmlRelaxNGDumpValidError(ctxt);
8032: } else {
8033: ret = -1;
8034: }
8035: xmlRegFreeExecCtxt(exec);
8036: /*
8037: * There might be content model errors outside of the pure
8038: * regexp validation, e.g. for attribute values.
8039: */
8040: if ((ret == 0) && (ctxt->perr != 0)) {
8041: ret = ctxt->perr;
8042: }
8043: ctxt->perr = oldperr;
8044: return (ret);
8045: }
8046:
8047: /************************************************************************
8048: * *
8049: * Progressive validation of when possible *
8050: * *
8051: ************************************************************************/
8052: static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
8053: xmlRelaxNGDefinePtr defines);
8054: static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
8055: int dolog);
8056: static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
8057:
8058: /**
8059: * xmlRelaxNGElemPush:
8060: * @ctxt: the validation context
8061: * @exec: the regexp runtime for the new content model
8062: *
8063: * Push a new regexp for the current node content model on the stack
8064: *
8065: * Returns 0 in case of success and -1 in case of error.
8066: */
8067: static int
8068: xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
8069: {
8070: if (ctxt->elemTab == NULL) {
8071: ctxt->elemMax = 10;
8072: ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
8073: sizeof
8074: (xmlRegExecCtxtPtr));
8075: if (ctxt->elemTab == NULL) {
8076: xmlRngVErrMemory(ctxt, "validating\n");
8077: return (-1);
8078: }
8079: }
8080: if (ctxt->elemNr >= ctxt->elemMax) {
8081: ctxt->elemMax *= 2;
8082: ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
8083: ctxt->elemMax *
8084: sizeof
8085: (xmlRegExecCtxtPtr));
8086: if (ctxt->elemTab == NULL) {
8087: xmlRngVErrMemory(ctxt, "validating\n");
8088: return (-1);
8089: }
8090: }
8091: ctxt->elemTab[ctxt->elemNr++] = exec;
8092: ctxt->elem = exec;
8093: return (0);
8094: }
8095:
8096: /**
8097: * xmlRelaxNGElemPop:
8098: * @ctxt: the validation context
8099: *
8100: * Pop the regexp of the current node content model from the stack
8101: *
8102: * Returns the exec or NULL if empty
8103: */
8104: static xmlRegExecCtxtPtr
8105: xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
8106: {
8107: xmlRegExecCtxtPtr ret;
8108:
8109: if (ctxt->elemNr <= 0)
8110: return (NULL);
8111: ctxt->elemNr--;
8112: ret = ctxt->elemTab[ctxt->elemNr];
8113: ctxt->elemTab[ctxt->elemNr] = NULL;
8114: if (ctxt->elemNr > 0)
8115: ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
8116: else
8117: ctxt->elem = NULL;
8118: return (ret);
8119: }
8120:
8121: /**
8122: * xmlRelaxNGValidateProgressiveCallback:
8123: * @exec: the regular expression instance
8124: * @token: the token which matched
8125: * @transdata: callback data, the define for the subelement if available
8126: @ @inputdata: callback data, the Relax NG validation context
8127: *
8128: * Handle the callback and if needed validate the element children.
8129: * some of the in/out informations are passed via the context in @inputdata.
8130: */
8131: static void
8132: xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec
8133: ATTRIBUTE_UNUSED,
8134: const xmlChar * token,
8135: void *transdata, void *inputdata)
8136: {
8137: xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
8138: xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
8139: xmlRelaxNGValidStatePtr state, oldstate;
8140: xmlNodePtr node;
8141: int ret = 0, oldflags;
8142:
8143: #ifdef DEBUG_PROGRESSIVE
8144: xmlGenericError(xmlGenericErrorContext,
8145: "Progressive callback for: '%s'\n", token);
8146: #endif
8147: if (ctxt == NULL) {
8148: fprintf(stderr, "callback on %s missing context\n", token);
8149: return;
8150: }
8151: node = ctxt->pnode;
8152: ctxt->pstate = 1;
8153: if (define == NULL) {
8154: if (token[0] == '#')
8155: return;
8156: fprintf(stderr, "callback on %s missing define\n", token);
8157: if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8158: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8159: ctxt->pstate = -1;
8160: return;
8161: }
8162: if ((ctxt == NULL) || (define == NULL)) {
8163: fprintf(stderr, "callback on %s missing info\n", token);
8164: if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
8165: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8166: ctxt->pstate = -1;
8167: return;
8168: } else if (define->type != XML_RELAXNG_ELEMENT) {
8169: fprintf(stderr, "callback on %s define is not element\n", token);
8170: if (ctxt->errNo == XML_RELAXNG_OK)
8171: ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
8172: ctxt->pstate = -1;
8173: return;
8174: }
8175: if (node->type != XML_ELEMENT_NODE) {
8176: VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
8177: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8178: xmlRelaxNGDumpValidError(ctxt);
8179: ctxt->pstate = -1;
8180: return;
8181: }
8182: if (define->contModel == NULL) {
8183: /*
8184: * this node cannot be validated in a streamable fashion
8185: */
8186: #ifdef DEBUG_PROGRESSIVE
8187: xmlGenericError(xmlGenericErrorContext,
8188: "Element '%s' validation is not streamable\n",
8189: token);
8190: #endif
8191: ctxt->pstate = 0;
8192: ctxt->pdef = define;
8193: return;
8194: }
8195: exec = xmlRegNewExecCtxt(define->contModel,
8196: xmlRelaxNGValidateProgressiveCallback, ctxt);
8197: if (exec == NULL) {
8198: ctxt->pstate = -1;
8199: return;
8200: }
8201: xmlRelaxNGElemPush(ctxt, exec);
8202:
8203: /*
8204: * Validate the attributes part of the content.
8205: */
8206: state = xmlRelaxNGNewValidState(ctxt, node);
8207: if (state == NULL) {
8208: ctxt->pstate = -1;
8209: return;
8210: }
8211: oldstate = ctxt->state;
8212: ctxt->state = state;
8213: if (define->attrs != NULL) {
8214: ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
8215: if (ret != 0) {
8216: ctxt->pstate = -1;
8217: VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
8218: }
8219: }
8220: if (ctxt->state != NULL) {
8221: ctxt->state->seq = NULL;
8222: ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
8223: if (ret != 0) {
8224: ctxt->pstate = -1;
8225: }
8226: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
8227: } else if (ctxt->states != NULL) {
8228: int tmp = -1, i;
8229:
8230: oldflags = ctxt->flags;
8231:
8232: for (i = 0; i < ctxt->states->nbState; i++) {
8233: state = ctxt->states->tabState[i];
8234: ctxt->state = state;
8235: ctxt->state->seq = NULL;
8236:
8237: if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
8238: tmp = 0;
8239: break;
8240: }
8241: }
8242: if (tmp != 0) {
8243: /*
8244: * validation error, log the message for the "best" one
8245: */
8246: ctxt->flags |= FLAGS_IGNORABLE;
8247: xmlRelaxNGLogBestError(ctxt);
8248: }
8249: for (i = 0; i < ctxt->states->nbState; i++) {
8250: xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
8251: }
8252: xmlRelaxNGFreeStates(ctxt, ctxt->states);
8253: ctxt->states = NULL;
8254: if ((ret == 0) && (tmp == -1))
8255: ctxt->pstate = -1;
8256: ctxt->flags = oldflags;
8257: }
8258: if (ctxt->pstate == -1) {
8259: if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
8260: xmlRelaxNGDumpValidError(ctxt);
8261: }
8262: }
8263: ctxt->state = oldstate;
8264: }
8265:
8266: /**
8267: * xmlRelaxNGValidatePushElement:
8268: * @ctxt: the validation context
8269: * @doc: a document instance
8270: * @elem: an element instance
8271: *
8272: * Push a new element start on the RelaxNG validation stack.
8273: *
8274: * returns 1 if no validation problem was found or 0 if validating the
8275: * element requires a full node, and -1 in case of error.
8276: */
8277: int
8278: xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
8279: xmlDocPtr doc ATTRIBUTE_UNUSED,
8280: xmlNodePtr elem)
8281: {
8282: int ret = 1;
8283:
8284: if ((ctxt == NULL) || (elem == NULL))
8285: return (-1);
8286:
8287: #ifdef DEBUG_PROGRESSIVE
8288: xmlGenericError(xmlGenericErrorContext, "PushElem %s\n", elem->name);
8289: #endif
8290: if (ctxt->elem == 0) {
8291: xmlRelaxNGPtr schema;
8292: xmlRelaxNGGrammarPtr grammar;
8293: xmlRegExecCtxtPtr exec;
8294: xmlRelaxNGDefinePtr define;
8295:
8296: schema = ctxt->schema;
8297: if (schema == NULL) {
8298: VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
8299: return (-1);
8300: }
8301: grammar = schema->topgrammar;
8302: if ((grammar == NULL) || (grammar->start == NULL)) {
8303: VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
8304: return (-1);
8305: }
8306: define = grammar->start;
8307: if (define->contModel == NULL) {
8308: ctxt->pdef = define;
8309: return (0);
8310: }
8311: exec = xmlRegNewExecCtxt(define->contModel,
8312: xmlRelaxNGValidateProgressiveCallback,
8313: ctxt);
8314: if (exec == NULL) {
8315: return (-1);
8316: }
8317: xmlRelaxNGElemPush(ctxt, exec);
8318: }
8319: ctxt->pnode = elem;
8320: ctxt->pstate = 0;
8321: if (elem->ns != NULL) {
8322: ret =
8323: xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
8324: ctxt);
8325: } else {
8326: ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
8327: }
8328: if (ret < 0) {
8329: VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name);
8330: } else {
8331: if (ctxt->pstate == 0)
8332: ret = 0;
8333: else if (ctxt->pstate < 0)
8334: ret = -1;
8335: else
8336: ret = 1;
8337: }
8338: #ifdef DEBUG_PROGRESSIVE
8339: if (ret < 0)
8340: xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
8341: elem->name);
8342: #endif
8343: return (ret);
8344: }
8345:
8346: /**
8347: * xmlRelaxNGValidatePushCData:
8348: * @ctxt: the RelaxNG validation context
8349: * @data: some character data read
8350: * @len: the length of the data
8351: *
8352: * check the CData parsed for validation in the current stack
8353: *
8354: * returns 1 if no validation problem was found or -1 otherwise
8355: */
8356: int
8357: xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
8358: const xmlChar * data, int len ATTRIBUTE_UNUSED)
8359: {
8360: int ret = 1;
8361:
8362: if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
8363: return (-1);
8364:
8365: #ifdef DEBUG_PROGRESSIVE
8366: xmlGenericError(xmlGenericErrorContext, "CDATA %s %d\n", data, len);
8367: #endif
8368:
8369: while (*data != 0) {
8370: if (!IS_BLANK_CH(*data))
8371: break;
8372: data++;
8373: }
8374: if (*data == 0)
8375: return (1);
8376:
8377: ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
8378: if (ret < 0) {
8379: VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, BAD_CAST " TODO ");
8380: #ifdef DEBUG_PROGRESSIVE
8381: xmlGenericError(xmlGenericErrorContext, "CDATA failed\n");
8382: #endif
8383:
8384: return (-1);
8385: }
8386: return (1);
8387: }
8388:
8389: /**
8390: * xmlRelaxNGValidatePopElement:
8391: * @ctxt: the RelaxNG validation context
8392: * @doc: a document instance
8393: * @elem: an element instance
8394: *
8395: * Pop the element end from the RelaxNG validation stack.
8396: *
8397: * returns 1 if no validation problem was found or 0 otherwise
8398: */
8399: int
8400: xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
8401: xmlDocPtr doc ATTRIBUTE_UNUSED,
8402: xmlNodePtr elem)
8403: {
8404: int ret;
8405: xmlRegExecCtxtPtr exec;
8406:
8407: if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
8408: return (-1);
8409: #ifdef DEBUG_PROGRESSIVE
8410: xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name);
8411: #endif
8412: /*
8413: * verify that we reached a terminal state of the content model.
8414: */
8415: exec = xmlRelaxNGElemPop(ctxt);
8416: ret = xmlRegExecPushString(exec, NULL, NULL);
8417: if (ret == 0) {
8418: /*
8419: * TODO: get some of the names needed to exit the current state of exec
8420: */
8421: VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
8422: ret = -1;
8423: } else if (ret < 0) {
8424: ret = -1;
8425: } else {
8426: ret = 1;
8427: }
8428: xmlRegFreeExecCtxt(exec);
8429: #ifdef DEBUG_PROGRESSIVE
8430: if (ret < 0)
8431: xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
8432: elem->name);
8433: #endif
8434: return (ret);
8435: }
8436:
8437: /**
8438: * xmlRelaxNGValidateFullElement:
8439: * @ctxt: the validation context
8440: * @doc: a document instance
8441: * @elem: an element instance
8442: *
8443: * Validate a full subtree when xmlRelaxNGValidatePushElement() returned
8444: * 0 and the content of the node has been expanded.
8445: *
8446: * returns 1 if no validation problem was found or -1 in case of error.
8447: */
8448: int
8449: xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
8450: xmlDocPtr doc ATTRIBUTE_UNUSED,
8451: xmlNodePtr elem)
8452: {
8453: int ret;
8454: xmlRelaxNGValidStatePtr state;
8455:
8456: if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
8457: return (-1);
8458: #ifdef DEBUG_PROGRESSIVE
8459: xmlGenericError(xmlGenericErrorContext, "FullElem %s\n", elem->name);
8460: #endif
8461: state = xmlRelaxNGNewValidState(ctxt, elem->parent);
8462: if (state == NULL) {
8463: return (-1);
8464: }
8465: state->seq = elem;
8466: ctxt->state = state;
8467: ctxt->errNo = XML_RELAXNG_OK;
8468: ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
8469: if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
8470: ret = -1;
8471: else
8472: ret = 1;
8473: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
8474: ctxt->state = NULL;
8475: #ifdef DEBUG_PROGRESSIVE
8476: if (ret < 0)
8477: xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
8478: elem->name);
8479: #endif
8480: return (ret);
8481: }
8482:
8483: /************************************************************************
8484: * *
8485: * Generic interpreted validation implementation *
8486: * *
8487: ************************************************************************/
8488: static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8489: xmlRelaxNGDefinePtr define);
8490:
8491: /**
8492: * xmlRelaxNGSkipIgnored:
8493: * @ctxt: a schema validation context
8494: * @node: the top node.
8495: *
8496: * Skip ignorable nodes in that context
8497: *
8498: * Returns the new sibling or NULL in case of error.
8499: */
8500: static xmlNodePtr
8501: xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
8502: xmlNodePtr node)
8503: {
8504: /*
8505: * TODO complete and handle entities
8506: */
8507: while ((node != NULL) &&
8508: ((node->type == XML_COMMENT_NODE) ||
8509: (node->type == XML_PI_NODE) ||
8510: (node->type == XML_XINCLUDE_START) ||
8511: (node->type == XML_XINCLUDE_END) ||
8512: (((node->type == XML_TEXT_NODE) ||
8513: (node->type == XML_CDATA_SECTION_NODE)) &&
8514: ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
8515: (IS_BLANK_NODE(node)))))) {
8516: node = node->next;
8517: }
8518: return (node);
8519: }
8520:
8521: /**
8522: * xmlRelaxNGNormalize:
8523: * @ctxt: a schema validation context
8524: * @str: the string to normalize
8525: *
8526: * Implements the normalizeWhiteSpace( s ) function from
8527: * section 6.2.9 of the spec
8528: *
8529: * Returns the new string or NULL in case of error.
8530: */
8531: static xmlChar *
8532: xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
8533: {
8534: xmlChar *ret, *p;
8535: const xmlChar *tmp;
8536: int len;
8537:
8538: if (str == NULL)
8539: return (NULL);
8540: tmp = str;
8541: while (*tmp != 0)
8542: tmp++;
8543: len = tmp - str;
8544:
8545: ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
8546: if (ret == NULL) {
8547: xmlRngVErrMemory(ctxt, "validating\n");
8548: return (NULL);
8549: }
8550: p = ret;
8551: while (IS_BLANK_CH(*str))
8552: str++;
8553: while (*str != 0) {
8554: if (IS_BLANK_CH(*str)) {
8555: while (IS_BLANK_CH(*str))
8556: str++;
8557: if (*str == 0)
8558: break;
8559: *p++ = ' ';
8560: } else
8561: *p++ = *str++;
8562: }
8563: *p = 0;
8564: return (ret);
8565: }
8566:
8567: /**
8568: * xmlRelaxNGValidateDatatype:
8569: * @ctxt: a Relax-NG validation context
8570: * @value: the string value
8571: * @type: the datatype definition
8572: * @node: the node
8573: *
8574: * Validate the given value against the dataype
8575: *
8576: * Returns 0 if the validation succeeded or an error code.
8577: */
8578: static int
8579: xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
8580: const xmlChar * value,
8581: xmlRelaxNGDefinePtr define, xmlNodePtr node)
8582: {
8583: int ret, tmp;
8584: xmlRelaxNGTypeLibraryPtr lib;
8585: void *result = NULL;
8586: xmlRelaxNGDefinePtr cur;
8587:
8588: if ((define == NULL) || (define->data == NULL)) {
8589: return (-1);
8590: }
8591: lib = (xmlRelaxNGTypeLibraryPtr) define->data;
8592: if (lib->check != NULL) {
8593: if ((define->attrs != NULL) &&
8594: (define->attrs->type == XML_RELAXNG_PARAM)) {
8595: ret =
8596: lib->check(lib->data, define->name, value, &result, node);
8597: } else {
8598: ret = lib->check(lib->data, define->name, value, NULL, node);
8599: }
8600: } else
8601: ret = -1;
8602: if (ret < 0) {
8603: VALID_ERR2(XML_RELAXNG_ERR_TYPE, define->name);
8604: if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
8605: lib->freef(lib->data, result);
8606: return (-1);
8607: } else if (ret == 1) {
8608: ret = 0;
8609: } else if (ret == 2) {
8610: VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
8611: } else {
8612: VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value);
8613: ret = -1;
8614: }
8615: cur = define->attrs;
8616: while ((ret == 0) && (cur != NULL) && (cur->type == XML_RELAXNG_PARAM)) {
8617: if (lib->facet != NULL) {
8618: tmp = lib->facet(lib->data, define->name, cur->name,
8619: cur->value, value, result);
8620: if (tmp != 0)
8621: ret = -1;
8622: }
8623: cur = cur->next;
8624: }
8625: if ((ret == 0) && (define->content != NULL)) {
8626: const xmlChar *oldvalue, *oldendvalue;
8627:
8628: oldvalue = ctxt->state->value;
8629: oldendvalue = ctxt->state->endvalue;
8630: ctxt->state->value = (xmlChar *) value;
8631: ctxt->state->endvalue = NULL;
8632: ret = xmlRelaxNGValidateValue(ctxt, define->content);
8633: ctxt->state->value = (xmlChar *) oldvalue;
8634: ctxt->state->endvalue = (xmlChar *) oldendvalue;
8635: }
8636: if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
8637: lib->freef(lib->data, result);
8638: return (ret);
8639: }
8640:
8641: /**
8642: * xmlRelaxNGNextValue:
8643: * @ctxt: a Relax-NG validation context
8644: *
8645: * Skip to the next value when validating within a list
8646: *
8647: * Returns 0 if the operation succeeded or an error code.
8648: */
8649: static int
8650: xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
8651: {
8652: xmlChar *cur;
8653:
8654: cur = ctxt->state->value;
8655: if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
8656: ctxt->state->value = NULL;
8657: ctxt->state->endvalue = NULL;
8658: return (0);
8659: }
8660: while (*cur != 0)
8661: cur++;
8662: while ((cur != ctxt->state->endvalue) && (*cur == 0))
8663: cur++;
8664: if (cur == ctxt->state->endvalue)
8665: ctxt->state->value = NULL;
8666: else
8667: ctxt->state->value = cur;
8668: return (0);
8669: }
8670:
8671: /**
8672: * xmlRelaxNGValidateValueList:
8673: * @ctxt: a Relax-NG validation context
8674: * @defines: the list of definitions to verify
8675: *
8676: * Validate the given set of definitions for the current value
8677: *
8678: * Returns 0 if the validation succeeded or an error code.
8679: */
8680: static int
8681: xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
8682: xmlRelaxNGDefinePtr defines)
8683: {
8684: int ret = 0;
8685:
8686: while (defines != NULL) {
8687: ret = xmlRelaxNGValidateValue(ctxt, defines);
8688: if (ret != 0)
8689: break;
8690: defines = defines->next;
8691: }
8692: return (ret);
8693: }
8694:
8695: /**
8696: * xmlRelaxNGValidateValue:
8697: * @ctxt: a Relax-NG validation context
8698: * @define: the definition to verify
8699: *
8700: * Validate the given definition for the current value
8701: *
8702: * Returns 0 if the validation succeeded or an error code.
8703: */
8704: static int
8705: xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
8706: xmlRelaxNGDefinePtr define)
8707: {
8708: int ret = 0, oldflags;
8709: xmlChar *value;
8710:
8711: value = ctxt->state->value;
8712: switch (define->type) {
8713: case XML_RELAXNG_EMPTY:{
8714: if ((value != NULL) && (value[0] != 0)) {
8715: int idx = 0;
8716:
8717: while (IS_BLANK_CH(value[idx]))
8718: idx++;
8719: if (value[idx] != 0)
8720: ret = -1;
8721: }
8722: break;
8723: }
8724: case XML_RELAXNG_TEXT:
8725: break;
8726: case XML_RELAXNG_VALUE:{
8727: if (!xmlStrEqual(value, define->value)) {
8728: if (define->name != NULL) {
8729: xmlRelaxNGTypeLibraryPtr lib;
8730:
8731: lib = (xmlRelaxNGTypeLibraryPtr) define->data;
8732: if ((lib != NULL) && (lib->comp != NULL)) {
8733: ret = lib->comp(lib->data, define->name,
8734: define->value, define->node,
8735: (void *) define->attrs,
8736: value, ctxt->state->node);
8737: } else
8738: ret = -1;
8739: if (ret < 0) {
8740: VALID_ERR2(XML_RELAXNG_ERR_TYPECMP,
8741: define->name);
8742: return (-1);
8743: } else if (ret == 1) {
8744: ret = 0;
8745: } else {
8746: ret = -1;
8747: }
8748: } else {
8749: xmlChar *nval, *nvalue;
8750:
8751: /*
8752: * TODO: trivial optimizations are possible by
8753: * computing at compile-time
8754: */
8755: nval = xmlRelaxNGNormalize(ctxt, define->value);
8756: nvalue = xmlRelaxNGNormalize(ctxt, value);
8757:
8758: if ((nval == NULL) || (nvalue == NULL) ||
8759: (!xmlStrEqual(nval, nvalue)))
8760: ret = -1;
8761: if (nval != NULL)
8762: xmlFree(nval);
8763: if (nvalue != NULL)
8764: xmlFree(nvalue);
8765: }
8766: }
8767: if (ret == 0)
8768: xmlRelaxNGNextValue(ctxt);
8769: break;
8770: }
8771: case XML_RELAXNG_DATATYPE:{
8772: ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
8773: ctxt->state->seq);
8774: if (ret == 0)
8775: xmlRelaxNGNextValue(ctxt);
8776:
8777: break;
8778: }
8779: case XML_RELAXNG_CHOICE:{
8780: xmlRelaxNGDefinePtr list = define->content;
8781: xmlChar *oldvalue;
8782:
8783: oldflags = ctxt->flags;
8784: ctxt->flags |= FLAGS_IGNORABLE;
8785:
8786: oldvalue = ctxt->state->value;
8787: while (list != NULL) {
8788: ret = xmlRelaxNGValidateValue(ctxt, list);
8789: if (ret == 0) {
8790: break;
8791: }
8792: ctxt->state->value = oldvalue;
8793: list = list->next;
8794: }
8795: ctxt->flags = oldflags;
8796: if (ret != 0) {
8797: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
8798: xmlRelaxNGDumpValidError(ctxt);
8799: } else {
8800: if (ctxt->errNr > 0)
8801: xmlRelaxNGPopErrors(ctxt, 0);
8802: }
8803: break;
8804: }
8805: case XML_RELAXNG_LIST:{
8806: xmlRelaxNGDefinePtr list = define->content;
8807: xmlChar *oldvalue, *oldend, *val, *cur;
8808:
8809: #ifdef DEBUG_LIST
8810: int nb_values = 0;
8811: #endif
8812:
8813: oldvalue = ctxt->state->value;
8814: oldend = ctxt->state->endvalue;
8815:
8816: val = xmlStrdup(oldvalue);
8817: if (val == NULL) {
8818: val = xmlStrdup(BAD_CAST "");
8819: }
8820: if (val == NULL) {
8821: VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
8822: return (-1);
8823: }
8824: cur = val;
8825: while (*cur != 0) {
8826: if (IS_BLANK_CH(*cur)) {
8827: *cur = 0;
8828: cur++;
8829: #ifdef DEBUG_LIST
8830: nb_values++;
8831: #endif
8832: while (IS_BLANK_CH(*cur))
8833: *cur++ = 0;
8834: } else
8835: cur++;
8836: }
8837: #ifdef DEBUG_LIST
8838: xmlGenericError(xmlGenericErrorContext,
8839: "list value: '%s' found %d items\n",
8840: oldvalue, nb_values);
8841: nb_values = 0;
8842: #endif
8843: ctxt->state->endvalue = cur;
8844: cur = val;
8845: while ((*cur == 0) && (cur != ctxt->state->endvalue))
8846: cur++;
8847:
8848: ctxt->state->value = cur;
8849:
8850: while (list != NULL) {
8851: if (ctxt->state->value == ctxt->state->endvalue)
8852: ctxt->state->value = NULL;
8853: ret = xmlRelaxNGValidateValue(ctxt, list);
8854: if (ret != 0) {
8855: #ifdef DEBUG_LIST
8856: xmlGenericError(xmlGenericErrorContext,
8857: "Failed to validate value: '%s' with %d rule\n",
8858: ctxt->state->value, nb_values);
8859: #endif
8860: break;
8861: }
8862: #ifdef DEBUG_LIST
8863: nb_values++;
8864: #endif
8865: list = list->next;
8866: }
8867:
8868: if ((ret == 0) && (ctxt->state->value != NULL) &&
8869: (ctxt->state->value != ctxt->state->endvalue)) {
8870: VALID_ERR2(XML_RELAXNG_ERR_LISTEXTRA,
8871: ctxt->state->value);
8872: ret = -1;
8873: }
8874: xmlFree(val);
8875: ctxt->state->value = oldvalue;
8876: ctxt->state->endvalue = oldend;
8877: break;
8878: }
8879: case XML_RELAXNG_ONEORMORE:
8880: ret = xmlRelaxNGValidateValueList(ctxt, define->content);
8881: if (ret != 0) {
8882: break;
8883: }
8884: /* no break on purpose */
8885: case XML_RELAXNG_ZEROORMORE:{
8886: xmlChar *cur, *temp;
8887:
8888: if ((ctxt->state->value == NULL) ||
8889: (*ctxt->state->value == 0)) {
8890: ret = 0;
8891: break;
8892: }
8893: oldflags = ctxt->flags;
8894: ctxt->flags |= FLAGS_IGNORABLE;
8895: cur = ctxt->state->value;
8896: temp = NULL;
8897: while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
8898: (temp != cur)) {
8899: temp = cur;
8900: ret =
8901: xmlRelaxNGValidateValueList(ctxt, define->content);
8902: if (ret != 0) {
8903: ctxt->state->value = temp;
8904: ret = 0;
8905: break;
8906: }
8907: cur = ctxt->state->value;
8908: }
8909: ctxt->flags = oldflags;
8910: if (ctxt->errNr > 0)
8911: xmlRelaxNGPopErrors(ctxt, 0);
8912: break;
8913: }
8914: case XML_RELAXNG_OPTIONAL:{
8915: xmlChar *temp;
8916:
8917: if ((ctxt->state->value == NULL) ||
8918: (*ctxt->state->value == 0)) {
8919: ret = 0;
8920: break;
8921: }
8922: oldflags = ctxt->flags;
8923: ctxt->flags |= FLAGS_IGNORABLE;
8924: temp = ctxt->state->value;
8925: ret = xmlRelaxNGValidateValue(ctxt, define->content);
8926: ctxt->flags = oldflags;
8927: if (ret != 0) {
8928: ctxt->state->value = temp;
8929: if (ctxt->errNr > 0)
8930: xmlRelaxNGPopErrors(ctxt, 0);
8931: ret = 0;
8932: break;
8933: }
8934: if (ctxt->errNr > 0)
8935: xmlRelaxNGPopErrors(ctxt, 0);
8936: break;
8937: }
8938: case XML_RELAXNG_EXCEPT:{
8939: xmlRelaxNGDefinePtr list;
8940:
8941: list = define->content;
8942: while (list != NULL) {
8943: ret = xmlRelaxNGValidateValue(ctxt, list);
8944: if (ret == 0) {
8945: ret = -1;
8946: break;
8947: } else
8948: ret = 0;
8949: list = list->next;
8950: }
8951: break;
8952: }
8953: case XML_RELAXNG_DEF:
8954: case XML_RELAXNG_GROUP:{
8955: xmlRelaxNGDefinePtr list;
8956:
8957: list = define->content;
8958: while (list != NULL) {
8959: ret = xmlRelaxNGValidateValue(ctxt, list);
8960: if (ret != 0) {
8961: ret = -1;
8962: break;
8963: } else
8964: ret = 0;
8965: list = list->next;
8966: }
8967: break;
8968: }
8969: case XML_RELAXNG_REF:
8970: case XML_RELAXNG_PARENTREF:
8971: if (define->content == NULL) {
8972: VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
8973: ret = -1;
8974: } else {
8975: ret = xmlRelaxNGValidateValue(ctxt, define->content);
8976: }
8977: break;
8978: default:
8979: TODO ret = -1;
8980: }
8981: return (ret);
8982: }
8983:
8984: /**
8985: * xmlRelaxNGValidateValueContent:
8986: * @ctxt: a Relax-NG validation context
8987: * @defines: the list of definitions to verify
8988: *
8989: * Validate the given definitions for the current value
8990: *
8991: * Returns 0 if the validation succeeded or an error code.
8992: */
8993: static int
8994: xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
8995: xmlRelaxNGDefinePtr defines)
8996: {
8997: int ret = 0;
8998:
8999: while (defines != NULL) {
9000: ret = xmlRelaxNGValidateValue(ctxt, defines);
9001: if (ret != 0)
9002: break;
9003: defines = defines->next;
9004: }
9005: return (ret);
9006: }
9007:
9008: /**
9009: * xmlRelaxNGAttributeMatch:
9010: * @ctxt: a Relax-NG validation context
9011: * @define: the definition to check
9012: * @prop: the attribute
9013: *
9014: * Check if the attribute matches the definition nameClass
9015: *
9016: * Returns 1 if the attribute matches, 0 if no, or -1 in case of error
9017: */
9018: static int
9019: xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
9020: xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
9021: {
9022: int ret;
9023:
9024: if (define->name != NULL) {
9025: if (!xmlStrEqual(define->name, prop->name))
9026: return (0);
9027: }
9028: if (define->ns != NULL) {
9029: if (define->ns[0] == 0) {
9030: if (prop->ns != NULL)
9031: return (0);
9032: } else {
9033: if ((prop->ns == NULL) ||
9034: (!xmlStrEqual(define->ns, prop->ns->href)))
9035: return (0);
9036: }
9037: }
9038: if (define->nameClass == NULL)
9039: return (1);
9040: define = define->nameClass;
9041: if (define->type == XML_RELAXNG_EXCEPT) {
9042: xmlRelaxNGDefinePtr list;
9043:
9044: list = define->content;
9045: while (list != NULL) {
9046: ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
9047: if (ret == 1)
9048: return (0);
9049: if (ret < 0)
9050: return (ret);
9051: list = list->next;
9052: }
9053: } else {
9054: TODO}
9055: return (1);
9056: }
9057:
9058: /**
9059: * xmlRelaxNGValidateAttribute:
9060: * @ctxt: a Relax-NG validation context
9061: * @define: the definition to verify
9062: *
9063: * Validate the given attribute definition for that node
9064: *
9065: * Returns 0 if the validation succeeded or an error code.
9066: */
9067: static int
9068: xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
9069: xmlRelaxNGDefinePtr define)
9070: {
9071: int ret = 0, i;
9072: xmlChar *value, *oldvalue;
9073: xmlAttrPtr prop = NULL, tmp;
9074: xmlNodePtr oldseq;
9075:
9076: if (ctxt->state->nbAttrLeft <= 0)
9077: return (-1);
9078: if (define->name != NULL) {
9079: for (i = 0; i < ctxt->state->nbAttrs; i++) {
9080: tmp = ctxt->state->attrs[i];
9081: if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) {
9082: if ((((define->ns == NULL) || (define->ns[0] == 0)) &&
9083: (tmp->ns == NULL)) ||
9084: ((tmp->ns != NULL) &&
9085: (xmlStrEqual(define->ns, tmp->ns->href)))) {
9086: prop = tmp;
9087: break;
9088: }
9089: }
9090: }
9091: if (prop != NULL) {
9092: value = xmlNodeListGetString(prop->doc, prop->children, 1);
9093: oldvalue = ctxt->state->value;
9094: oldseq = ctxt->state->seq;
9095: ctxt->state->seq = (xmlNodePtr) prop;
9096: ctxt->state->value = value;
9097: ctxt->state->endvalue = NULL;
9098: ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9099: if (ctxt->state->value != NULL)
9100: value = ctxt->state->value;
9101: if (value != NULL)
9102: xmlFree(value);
9103: ctxt->state->value = oldvalue;
9104: ctxt->state->seq = oldseq;
9105: if (ret == 0) {
9106: /*
9107: * flag the attribute as processed
9108: */
9109: ctxt->state->attrs[i] = NULL;
9110: ctxt->state->nbAttrLeft--;
9111: }
9112: } else {
9113: ret = -1;
9114: }
9115: #ifdef DEBUG
9116: xmlGenericError(xmlGenericErrorContext,
9117: "xmlRelaxNGValidateAttribute(%s): %d\n",
9118: define->name, ret);
9119: #endif
9120: } else {
9121: for (i = 0; i < ctxt->state->nbAttrs; i++) {
9122: tmp = ctxt->state->attrs[i];
9123: if ((tmp != NULL) &&
9124: (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
9125: prop = tmp;
9126: break;
9127: }
9128: }
9129: if (prop != NULL) {
9130: value = xmlNodeListGetString(prop->doc, prop->children, 1);
9131: oldvalue = ctxt->state->value;
9132: oldseq = ctxt->state->seq;
9133: ctxt->state->seq = (xmlNodePtr) prop;
9134: ctxt->state->value = value;
9135: ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9136: if (ctxt->state->value != NULL)
9137: value = ctxt->state->value;
9138: if (value != NULL)
9139: xmlFree(value);
9140: ctxt->state->value = oldvalue;
9141: ctxt->state->seq = oldseq;
9142: if (ret == 0) {
9143: /*
9144: * flag the attribute as processed
9145: */
9146: ctxt->state->attrs[i] = NULL;
9147: ctxt->state->nbAttrLeft--;
9148: }
9149: } else {
9150: ret = -1;
9151: }
9152: #ifdef DEBUG
9153: if (define->ns != NULL) {
9154: xmlGenericError(xmlGenericErrorContext,
9155: "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n",
9156: define->ns, ret);
9157: } else {
9158: xmlGenericError(xmlGenericErrorContext,
9159: "xmlRelaxNGValidateAttribute(anyName): %d\n",
9160: ret);
9161: }
9162: #endif
9163: }
9164:
9165: return (ret);
9166: }
9167:
9168: /**
9169: * xmlRelaxNGValidateAttributeList:
9170: * @ctxt: a Relax-NG validation context
9171: * @define: the list of definition to verify
9172: *
9173: * Validate the given node against the list of attribute definitions
9174: *
9175: * Returns 0 if the validation succeeded or an error code.
9176: */
9177: static int
9178: xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
9179: xmlRelaxNGDefinePtr defines)
9180: {
9181: int ret = 0, res;
9182: int needmore = 0;
9183: xmlRelaxNGDefinePtr cur;
9184:
9185: cur = defines;
9186: while (cur != NULL) {
9187: if (cur->type == XML_RELAXNG_ATTRIBUTE) {
9188: if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
9189: ret = -1;
9190: } else
9191: needmore = 1;
9192: cur = cur->next;
9193: }
9194: if (!needmore)
9195: return (ret);
9196: cur = defines;
9197: while (cur != NULL) {
9198: if (cur->type != XML_RELAXNG_ATTRIBUTE) {
9199: if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9200: res = xmlRelaxNGValidateDefinition(ctxt, cur);
9201: if (res < 0)
9202: ret = -1;
9203: } else {
9204: VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
9205: return (-1);
9206: }
9207: if (res == -1) /* continues on -2 */
9208: break;
9209: }
9210: cur = cur->next;
9211: }
9212:
9213: return (ret);
9214: }
9215:
9216: /**
9217: * xmlRelaxNGNodeMatchesList:
9218: * @node: the node
9219: * @list: a NULL terminated array of definitions
9220: *
9221: * Check if a node can be matched by one of the definitions
9222: *
9223: * Returns 1 if matches 0 otherwise
9224: */
9225: static int
9226: xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
9227: {
9228: xmlRelaxNGDefinePtr cur;
9229: int i = 0, tmp;
9230:
9231: if ((node == NULL) || (list == NULL))
9232: return (0);
9233:
9234: cur = list[i++];
9235: while (cur != NULL) {
9236: if ((node->type == XML_ELEMENT_NODE) &&
9237: (cur->type == XML_RELAXNG_ELEMENT)) {
9238: tmp = xmlRelaxNGElementMatch(NULL, cur, node);
9239: if (tmp == 1)
9240: return (1);
9241: } else if (((node->type == XML_TEXT_NODE) ||
9242: (node->type == XML_CDATA_SECTION_NODE)) &&
9243: (cur->type == XML_RELAXNG_TEXT)) {
9244: return (1);
9245: }
9246: cur = list[i++];
9247: }
9248: return (0);
9249: }
9250:
9251: /**
9252: * xmlRelaxNGValidateInterleave:
9253: * @ctxt: a Relax-NG validation context
9254: * @define: the definition to verify
9255: *
9256: * Validate an interleave definition for a node.
9257: *
9258: * Returns 0 if the validation succeeded or an error code.
9259: */
9260: static int
9261: xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
9262: xmlRelaxNGDefinePtr define)
9263: {
9264: int ret = 0, i, nbgroups;
9265: int errNr = ctxt->errNr;
9266: int oldflags;
9267:
9268: xmlRelaxNGValidStatePtr oldstate;
9269: xmlRelaxNGPartitionPtr partitions;
9270: xmlRelaxNGInterleaveGroupPtr group = NULL;
9271: xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem;
9272: xmlNodePtr *list = NULL, *lasts = NULL;
9273:
9274: if (define->data != NULL) {
9275: partitions = (xmlRelaxNGPartitionPtr) define->data;
9276: nbgroups = partitions->nbgroups;
9277: } else {
9278: VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
9279: return (-1);
9280: }
9281: /*
9282: * Optimizations for MIXED
9283: */
9284: oldflags = ctxt->flags;
9285: if (define->dflags & IS_MIXED) {
9286: ctxt->flags |= FLAGS_MIXED_CONTENT;
9287: if (nbgroups == 2) {
9288: /*
9289: * this is a pure <mixed> case
9290: */
9291: if (ctxt->state != NULL)
9292: ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9293: ctxt->state->seq);
9294: if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT)
9295: ret = xmlRelaxNGValidateDefinition(ctxt,
9296: partitions->groups[1]->
9297: rule);
9298: else
9299: ret = xmlRelaxNGValidateDefinition(ctxt,
9300: partitions->groups[0]->
9301: rule);
9302: if (ret == 0) {
9303: if (ctxt->state != NULL)
9304: ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9305: ctxt->state->
9306: seq);
9307: }
9308: ctxt->flags = oldflags;
9309: return (ret);
9310: }
9311: }
9312:
9313: /*
9314: * Build arrays to store the first and last node of the chain
9315: * pertaining to each group
9316: */
9317: list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
9318: if (list == NULL) {
9319: xmlRngVErrMemory(ctxt, "validating\n");
9320: return (-1);
9321: }
9322: memset(list, 0, nbgroups * sizeof(xmlNodePtr));
9323: lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
9324: if (lasts == NULL) {
9325: xmlRngVErrMemory(ctxt, "validating\n");
9326: return (-1);
9327: }
9328: memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));
9329:
9330: /*
9331: * Walk the sequence of children finding the right group and
9332: * sorting them in sequences.
9333: */
9334: cur = ctxt->state->seq;
9335: cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9336: start = cur;
9337: while (cur != NULL) {
9338: ctxt->state->seq = cur;
9339: if ((partitions->triage != NULL) &&
9340: (partitions->flags & IS_DETERMINIST)) {
9341: void *tmp = NULL;
9342:
9343: if ((cur->type == XML_TEXT_NODE) ||
9344: (cur->type == XML_CDATA_SECTION_NODE)) {
9345: tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text",
9346: NULL);
9347: } else if (cur->type == XML_ELEMENT_NODE) {
9348: if (cur->ns != NULL) {
9349: tmp = xmlHashLookup2(partitions->triage, cur->name,
9350: cur->ns->href);
9351: if (tmp == NULL)
9352: tmp = xmlHashLookup2(partitions->triage,
9353: BAD_CAST "#any",
9354: cur->ns->href);
9355: } else
9356: tmp =
9357: xmlHashLookup2(partitions->triage, cur->name,
9358: NULL);
9359: if (tmp == NULL)
9360: tmp =
9361: xmlHashLookup2(partitions->triage, BAD_CAST "#any",
9362: NULL);
9363: }
9364:
9365: if (tmp == NULL) {
9366: i = nbgroups;
9367: } else {
9368: i = ((long) tmp) - 1;
9369: if (partitions->flags & IS_NEEDCHECK) {
9370: group = partitions->groups[i];
9371: if (!xmlRelaxNGNodeMatchesList(cur, group->defs))
9372: i = nbgroups;
9373: }
9374: }
9375: } else {
9376: for (i = 0; i < nbgroups; i++) {
9377: group = partitions->groups[i];
9378: if (group == NULL)
9379: continue;
9380: if (xmlRelaxNGNodeMatchesList(cur, group->defs))
9381: break;
9382: }
9383: }
9384: /*
9385: * We break as soon as an element not matched is found
9386: */
9387: if (i >= nbgroups) {
9388: break;
9389: }
9390: if (lasts[i] != NULL) {
9391: lasts[i]->next = cur;
9392: lasts[i] = cur;
9393: } else {
9394: list[i] = cur;
9395: lasts[i] = cur;
9396: }
9397: if (cur->next != NULL)
9398: lastchg = cur->next;
9399: else
9400: lastchg = cur;
9401: cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
9402: }
9403: if (ret != 0) {
9404: VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
9405: ret = -1;
9406: goto done;
9407: }
9408: lastelem = cur;
9409: oldstate = ctxt->state;
9410: for (i = 0; i < nbgroups; i++) {
9411: ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
9412: group = partitions->groups[i];
9413: if (lasts[i] != NULL) {
9414: last = lasts[i]->next;
9415: lasts[i]->next = NULL;
9416: }
9417: ctxt->state->seq = list[i];
9418: ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
9419: if (ret != 0)
9420: break;
9421: if (ctxt->state != NULL) {
9422: cur = ctxt->state->seq;
9423: cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9424: xmlRelaxNGFreeValidState(ctxt, oldstate);
9425: oldstate = ctxt->state;
9426: ctxt->state = NULL;
9427: if (cur != NULL) {
9428: VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
9429: ret = -1;
9430: ctxt->state = oldstate;
9431: goto done;
9432: }
9433: } else if (ctxt->states != NULL) {
9434: int j;
9435: int found = 0;
9436: int best = -1;
9437: int lowattr = -1;
9438:
9439: /*
9440: * PBM: what happen if there is attributes checks in the interleaves
9441: */
9442:
9443: for (j = 0; j < ctxt->states->nbState; j++) {
9444: cur = ctxt->states->tabState[j]->seq;
9445: cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9446: if (cur == NULL) {
9447: if (found == 0) {
9448: lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9449: best = j;
9450: }
9451: found = 1;
9452: if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9453: /* try to keep the latest one to mach old heuristic */
9454: lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9455: best = j;
9456: }
9457: if (lowattr == 0)
9458: break;
9459: } else if (found == 0) {
9460: if (lowattr == -1) {
9461: lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9462: best = j;
9463: } else
9464: if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9465: /* try to keep the latest one to mach old heuristic */
9466: lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9467: best = j;
9468: }
9469: }
9470: }
9471: /*
9472: * BIG PBM: here we pick only one restarting point :-(
9473: */
9474: if (ctxt->states->nbState > 0) {
9475: xmlRelaxNGFreeValidState(ctxt, oldstate);
9476: if (best != -1) {
9477: oldstate = ctxt->states->tabState[best];
9478: ctxt->states->tabState[best] = NULL;
9479: } else {
9480: oldstate =
9481: ctxt->states->tabState[ctxt->states->nbState - 1];
9482: ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
9483: ctxt->states->nbState--;
9484: }
9485: }
9486: for (j = 0; j < ctxt->states->nbState ; j++) {
9487: xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
9488: }
9489: xmlRelaxNGFreeStates(ctxt, ctxt->states);
9490: ctxt->states = NULL;
9491: if (found == 0) {
9492: if (cur == NULL) {
9493: VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA,
9494: (const xmlChar *) "noname");
9495: } else {
9496: VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
9497: }
9498: ret = -1;
9499: ctxt->state = oldstate;
9500: goto done;
9501: }
9502: } else {
9503: ret = -1;
9504: break;
9505: }
9506: if (lasts[i] != NULL) {
9507: lasts[i]->next = last;
9508: }
9509: }
9510: if (ctxt->state != NULL)
9511: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
9512: ctxt->state = oldstate;
9513: ctxt->state->seq = lastelem;
9514: if (ret != 0) {
9515: VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
9516: ret = -1;
9517: goto done;
9518: }
9519:
9520: done:
9521: ctxt->flags = oldflags;
9522: /*
9523: * builds the next links chain from the prev one
9524: */
9525: cur = lastchg;
9526: while (cur != NULL) {
9527: if ((cur == start) || (cur->prev == NULL))
9528: break;
9529: cur->prev->next = cur;
9530: cur = cur->prev;
9531: }
9532: if (ret == 0) {
9533: if (ctxt->errNr > errNr)
9534: xmlRelaxNGPopErrors(ctxt, errNr);
9535: }
9536:
9537: xmlFree(list);
9538: xmlFree(lasts);
9539: return (ret);
9540: }
9541:
9542: /**
9543: * xmlRelaxNGValidateDefinitionList:
9544: * @ctxt: a Relax-NG validation context
9545: * @define: the list of definition to verify
9546: *
9547: * Validate the given node content against the (list) of definitions
9548: *
9549: * Returns 0 if the validation succeeded or an error code.
9550: */
9551: static int
9552: xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
9553: xmlRelaxNGDefinePtr defines)
9554: {
9555: int ret = 0, res;
9556:
9557:
9558: if (defines == NULL) {
9559: VALID_ERR2(XML_RELAXNG_ERR_INTERNAL,
9560: BAD_CAST "NULL definition list");
9561: return (-1);
9562: }
9563: while (defines != NULL) {
9564: if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9565: res = xmlRelaxNGValidateDefinition(ctxt, defines);
9566: if (res < 0)
9567: ret = -1;
9568: } else {
9569: VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
9570: return (-1);
9571: }
9572: if (res == -1) /* continues on -2 */
9573: break;
9574: defines = defines->next;
9575: }
9576:
9577: return (ret);
9578: }
9579:
9580: /**
9581: * xmlRelaxNGElementMatch:
9582: * @ctxt: a Relax-NG validation context
9583: * @define: the definition to check
9584: * @elem: the element
9585: *
9586: * Check if the element matches the definition nameClass
9587: *
9588: * Returns 1 if the element matches, 0 if no, or -1 in case of error
9589: */
9590: static int
9591: xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
9592: xmlRelaxNGDefinePtr define, xmlNodePtr elem)
9593: {
9594: int ret = 0, oldflags = 0;
9595:
9596: if (define->name != NULL) {
9597: if (!xmlStrEqual(elem->name, define->name)) {
9598: VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name);
9599: return (0);
9600: }
9601: }
9602: if ((define->ns != NULL) && (define->ns[0] != 0)) {
9603: if (elem->ns == NULL) {
9604: VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name);
9605: return (0);
9606: } else if (!xmlStrEqual(elem->ns->href, define->ns)) {
9607: VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS,
9608: elem->name, define->ns);
9609: return (0);
9610: }
9611: } else if ((elem->ns != NULL) && (define->ns != NULL) &&
9612: (define->name == NULL)) {
9613: VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name);
9614: return (0);
9615: } else if ((elem->ns != NULL) && (define->name != NULL)) {
9616: VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
9617: return (0);
9618: }
9619:
9620: if (define->nameClass == NULL)
9621: return (1);
9622:
9623: define = define->nameClass;
9624: if (define->type == XML_RELAXNG_EXCEPT) {
9625: xmlRelaxNGDefinePtr list;
9626:
9627: if (ctxt != NULL) {
9628: oldflags = ctxt->flags;
9629: ctxt->flags |= FLAGS_IGNORABLE;
9630: }
9631:
9632: list = define->content;
9633: while (list != NULL) {
9634: ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9635: if (ret == 1) {
9636: if (ctxt != NULL)
9637: ctxt->flags = oldflags;
9638: return (0);
9639: }
9640: if (ret < 0) {
9641: if (ctxt != NULL)
9642: ctxt->flags = oldflags;
9643: return (ret);
9644: }
9645: list = list->next;
9646: }
9647: ret = 1;
9648: if (ctxt != NULL) {
9649: ctxt->flags = oldflags;
9650: }
9651: } else if (define->type == XML_RELAXNG_CHOICE) {
9652: xmlRelaxNGDefinePtr list;
9653:
9654: if (ctxt != NULL) {
9655: oldflags = ctxt->flags;
9656: ctxt->flags |= FLAGS_IGNORABLE;
9657: }
9658:
9659: list = define->nameClass;
9660: while (list != NULL) {
9661: ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9662: if (ret == 1) {
9663: if (ctxt != NULL)
9664: ctxt->flags = oldflags;
9665: return (1);
9666: }
9667: if (ret < 0) {
9668: if (ctxt != NULL)
9669: ctxt->flags = oldflags;
9670: return (ret);
9671: }
9672: list = list->next;
9673: }
9674: if (ctxt != NULL) {
9675: if (ret != 0) {
9676: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9677: xmlRelaxNGDumpValidError(ctxt);
9678: } else {
9679: if (ctxt->errNr > 0)
9680: xmlRelaxNGPopErrors(ctxt, 0);
9681: }
9682: }
9683: ret = 0;
9684: if (ctxt != NULL) {
9685: ctxt->flags = oldflags;
9686: }
9687: } else {
9688: TODO ret = -1;
9689: }
9690: return (ret);
9691: }
9692:
9693: /**
9694: * xmlRelaxNGBestState:
9695: * @ctxt: a Relax-NG validation context
9696: *
9697: * Find the "best" state in the ctxt->states list of states to report
9698: * errors about. I.e. a state with no element left in the child list
9699: * or the one with the less attributes left.
9700: * This is called only if a falidation error was detected
9701: *
9702: * Returns the index of the "best" state or -1 in case of error
9703: */
9704: static int
9705: xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
9706: {
9707: xmlRelaxNGValidStatePtr state;
9708: int i, tmp;
9709: int best = -1;
9710: int value = 1000000;
9711:
9712: if ((ctxt == NULL) || (ctxt->states == NULL) ||
9713: (ctxt->states->nbState <= 0))
9714: return (-1);
9715:
9716: for (i = 0; i < ctxt->states->nbState; i++) {
9717: state = ctxt->states->tabState[i];
9718: if (state == NULL)
9719: continue;
9720: if (state->seq != NULL) {
9721: if ((best == -1) || (value > 100000)) {
9722: value = 100000;
9723: best = i;
9724: }
9725: } else {
9726: tmp = state->nbAttrLeft;
9727: if ((best == -1) || (value > tmp)) {
9728: value = tmp;
9729: best = i;
9730: }
9731: }
9732: }
9733: return (best);
9734: }
9735:
9736: /**
9737: * xmlRelaxNGLogBestError:
9738: * @ctxt: a Relax-NG validation context
9739: *
9740: * Find the "best" state in the ctxt->states list of states to report
9741: * errors about and log it.
9742: */
9743: static void
9744: xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
9745: {
9746: int best;
9747:
9748: if ((ctxt == NULL) || (ctxt->states == NULL) ||
9749: (ctxt->states->nbState <= 0))
9750: return;
9751:
9752: best = xmlRelaxNGBestState(ctxt);
9753: if ((best >= 0) && (best < ctxt->states->nbState)) {
9754: ctxt->state = ctxt->states->tabState[best];
9755:
9756: xmlRelaxNGValidateElementEnd(ctxt, 1);
9757: }
9758: }
9759:
9760: /**
9761: * xmlRelaxNGValidateElementEnd:
9762: * @ctxt: a Relax-NG validation context
9763: * @dolog: indicate that error logging should be done
9764: *
9765: * Validate the end of the element, implements check that
9766: * there is nothing left not consumed in the element content
9767: * or in the attribute list.
9768: *
9769: * Returns 0 if the validation succeeded or an error code.
9770: */
9771: static int
9772: xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
9773: {
9774: int i;
9775: xmlRelaxNGValidStatePtr state;
9776:
9777: state = ctxt->state;
9778: if (state->seq != NULL) {
9779: state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
9780: if (state->seq != NULL) {
9781: if (dolog) {
9782: VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
9783: state->node->name, state->seq->name);
9784: }
9785: return (-1);
9786: }
9787: }
9788: for (i = 0; i < state->nbAttrs; i++) {
9789: if (state->attrs[i] != NULL) {
9790: if (dolog) {
9791: VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
9792: state->attrs[i]->name, state->node->name);
9793: }
9794: return (-1 - i);
9795: }
9796: }
9797: return (0);
9798: }
9799:
9800: /**
9801: * xmlRelaxNGValidateState:
9802: * @ctxt: a Relax-NG validation context
9803: * @define: the definition to verify
9804: *
9805: * Validate the current state against the definition
9806: *
9807: * Returns 0 if the validation succeeded or an error code.
9808: */
9809: static int
9810: xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
9811: xmlRelaxNGDefinePtr define)
9812: {
9813: xmlNodePtr node;
9814: int ret = 0, i, tmp, oldflags, errNr;
9815: xmlRelaxNGValidStatePtr oldstate = NULL, state;
9816:
9817: if (define == NULL) {
9818: VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
9819: return (-1);
9820: }
9821:
9822: if (ctxt->state != NULL) {
9823: node = ctxt->state->seq;
9824: } else {
9825: node = NULL;
9826: }
9827: #ifdef DEBUG
9828: for (i = 0; i < ctxt->depth; i++)
9829: xmlGenericError(xmlGenericErrorContext, " ");
9830: xmlGenericError(xmlGenericErrorContext,
9831: "Start validating %s ", xmlRelaxNGDefName(define));
9832: if (define->name != NULL)
9833: xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
9834: if ((node != NULL) && (node->name != NULL))
9835: xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
9836: else
9837: xmlGenericError(xmlGenericErrorContext, "\n");
9838: #endif
9839: ctxt->depth++;
9840: switch (define->type) {
9841: case XML_RELAXNG_EMPTY:
9842: node = xmlRelaxNGSkipIgnored(ctxt, node);
9843: ret = 0;
9844: break;
9845: case XML_RELAXNG_NOT_ALLOWED:
9846: ret = -1;
9847: break;
9848: case XML_RELAXNG_TEXT:
9849: while ((node != NULL) &&
9850: ((node->type == XML_TEXT_NODE) ||
9851: (node->type == XML_COMMENT_NODE) ||
9852: (node->type == XML_PI_NODE) ||
9853: (node->type == XML_CDATA_SECTION_NODE)))
9854: node = node->next;
9855: ctxt->state->seq = node;
9856: break;
9857: case XML_RELAXNG_ELEMENT:
9858: errNr = ctxt->errNr;
9859: node = xmlRelaxNGSkipIgnored(ctxt, node);
9860: if (node == NULL) {
9861: VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name);
9862: ret = -1;
9863: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9864: xmlRelaxNGDumpValidError(ctxt);
9865: break;
9866: }
9867: if (node->type != XML_ELEMENT_NODE) {
9868: VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
9869: ret = -1;
9870: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9871: xmlRelaxNGDumpValidError(ctxt);
9872: break;
9873: }
9874: /*
9875: * This node was already validated successfully against
9876: * this definition.
9877: */
9878: if (node->psvi == define) {
9879: ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9880: if (ctxt->errNr > errNr)
9881: xmlRelaxNGPopErrors(ctxt, errNr);
9882: if (ctxt->errNr != 0) {
9883: while ((ctxt->err != NULL) &&
9884: (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
9885: && (xmlStrEqual(ctxt->err->arg2, node->name)))
9886: ||
9887: ((ctxt->err->err ==
9888: XML_RELAXNG_ERR_ELEMEXTRANS)
9889: && (xmlStrEqual(ctxt->err->arg1, node->name)))
9890: || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
9891: || (ctxt->err->err ==
9892: XML_RELAXNG_ERR_NOTELEM)))
9893: xmlRelaxNGValidErrorPop(ctxt);
9894: }
9895: break;
9896: }
9897:
9898: ret = xmlRelaxNGElementMatch(ctxt, define, node);
9899: if (ret <= 0) {
9900: ret = -1;
9901: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9902: xmlRelaxNGDumpValidError(ctxt);
9903: break;
9904: }
9905: ret = 0;
9906: if (ctxt->errNr != 0) {
9907: if (ctxt->errNr > errNr)
9908: xmlRelaxNGPopErrors(ctxt, errNr);
9909: while ((ctxt->err != NULL) &&
9910: (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
9911: (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9912: ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
9913: (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9914: (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
9915: (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
9916: xmlRelaxNGValidErrorPop(ctxt);
9917: }
9918: errNr = ctxt->errNr;
9919:
9920: oldflags = ctxt->flags;
9921: if (ctxt->flags & FLAGS_MIXED_CONTENT) {
9922: ctxt->flags -= FLAGS_MIXED_CONTENT;
9923: }
9924: state = xmlRelaxNGNewValidState(ctxt, node);
9925: if (state == NULL) {
9926: ret = -1;
9927: if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9928: xmlRelaxNGDumpValidError(ctxt);
9929: break;
9930: }
9931:
9932: oldstate = ctxt->state;
9933: ctxt->state = state;
9934: if (define->attrs != NULL) {
9935: tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
9936: if (tmp != 0) {
9937: ret = -1;
9938: VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
9939: }
9940: }
9941: if (define->contModel != NULL) {
9942: xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
9943: xmlRelaxNGStatesPtr tmpstates = ctxt->states;
9944: xmlNodePtr nseq;
9945:
9946: nstate = xmlRelaxNGNewValidState(ctxt, node);
9947: ctxt->state = nstate;
9948: ctxt->states = NULL;
9949:
9950: tmp = xmlRelaxNGValidateCompiledContent(ctxt,
9951: define->contModel,
9952: ctxt->state->seq);
9953: nseq = ctxt->state->seq;
9954: ctxt->state = tmpstate;
9955: ctxt->states = tmpstates;
9956: xmlRelaxNGFreeValidState(ctxt, nstate);
9957:
9958: #ifdef DEBUG_COMPILE
9959: xmlGenericError(xmlGenericErrorContext,
9960: "Validating content of '%s' : %d\n",
9961: define->name, tmp);
9962: #endif
9963: if (tmp != 0)
9964: ret = -1;
9965:
9966: if (ctxt->states != NULL) {
9967: tmp = -1;
9968:
9969: for (i = 0; i < ctxt->states->nbState; i++) {
9970: state = ctxt->states->tabState[i];
9971: ctxt->state = state;
9972: ctxt->state->seq = nseq;
9973:
9974: if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
9975: tmp = 0;
9976: break;
9977: }
9978: }
9979: if (tmp != 0) {
9980: /*
9981: * validation error, log the message for the "best" one
9982: */
9983: ctxt->flags |= FLAGS_IGNORABLE;
9984: xmlRelaxNGLogBestError(ctxt);
9985: }
9986: for (i = 0; i < ctxt->states->nbState; i++) {
9987: xmlRelaxNGFreeValidState(ctxt,
9988: ctxt->states->
9989: tabState[i]);
9990: }
9991: xmlRelaxNGFreeStates(ctxt, ctxt->states);
9992: ctxt->flags = oldflags;
9993: ctxt->states = NULL;
9994: if ((ret == 0) && (tmp == -1))
9995: ret = -1;
9996: } else {
9997: state = ctxt->state;
9998: if (ctxt->state != NULL)
9999: ctxt->state->seq = nseq;
10000: if (ret == 0)
10001: ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10002: xmlRelaxNGFreeValidState(ctxt, state);
10003: }
10004: } else {
10005: if (define->content != NULL) {
10006: tmp = xmlRelaxNGValidateDefinitionList(ctxt,
10007: define->
10008: content);
10009: if (tmp != 0) {
10010: ret = -1;
10011: if (ctxt->state == NULL) {
10012: ctxt->state = oldstate;
10013: VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
10014: node->name);
10015: ctxt->state = NULL;
10016: } else {
10017: VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
10018: node->name);
10019: }
10020:
10021: }
10022: }
10023: if (ctxt->states != NULL) {
10024: tmp = -1;
10025:
10026: for (i = 0; i < ctxt->states->nbState; i++) {
10027: state = ctxt->states->tabState[i];
10028: ctxt->state = state;
10029:
10030: if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
10031: tmp = 0;
10032: break;
10033: }
10034: }
10035: if (tmp != 0) {
10036: /*
10037: * validation error, log the message for the "best" one
10038: */
10039: ctxt->flags |= FLAGS_IGNORABLE;
10040: xmlRelaxNGLogBestError(ctxt);
10041: }
10042: for (i = 0; i < ctxt->states->nbState; i++) {
10043: xmlRelaxNGFreeValidState(ctxt,
10044: ctxt->states->tabState[i]);
10045: ctxt->states->tabState[i] = NULL;
10046: }
10047: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10048: ctxt->flags = oldflags;
10049: ctxt->states = NULL;
10050: if ((ret == 0) && (tmp == -1))
10051: ret = -1;
10052: } else {
10053: state = ctxt->state;
10054: if (ret == 0)
10055: ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10056: xmlRelaxNGFreeValidState(ctxt, state);
10057: }
10058: }
10059: if (ret == 0) {
10060: node->psvi = define;
10061: }
10062: ctxt->flags = oldflags;
10063: ctxt->state = oldstate;
10064: if (oldstate != NULL)
10065: oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
10066: if (ret != 0) {
10067: if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10068: xmlRelaxNGDumpValidError(ctxt);
10069: ret = 0;
10070: #if 0
10071: } else {
10072: ret = -2;
10073: #endif
10074: }
10075: } else {
10076: if (ctxt->errNr > errNr)
10077: xmlRelaxNGPopErrors(ctxt, errNr);
10078: }
10079:
10080: #ifdef DEBUG
10081: xmlGenericError(xmlGenericErrorContext,
10082: "xmlRelaxNGValidateDefinition(): validated %s : %d",
10083: node->name, ret);
10084: if (oldstate == NULL)
10085: xmlGenericError(xmlGenericErrorContext, ": no state\n");
10086: else if (oldstate->seq == NULL)
10087: xmlGenericError(xmlGenericErrorContext, ": done\n");
10088: else if (oldstate->seq->type == XML_ELEMENT_NODE)
10089: xmlGenericError(xmlGenericErrorContext, ": next elem %s\n",
10090: oldstate->seq->name);
10091: else
10092: xmlGenericError(xmlGenericErrorContext, ": next %s %d\n",
10093: oldstate->seq->name, oldstate->seq->type);
10094: #endif
10095: break;
10096: case XML_RELAXNG_OPTIONAL:{
10097: errNr = ctxt->errNr;
10098: oldflags = ctxt->flags;
10099: ctxt->flags |= FLAGS_IGNORABLE;
10100: oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10101: ret =
10102: xmlRelaxNGValidateDefinitionList(ctxt,
10103: define->content);
10104: if (ret != 0) {
10105: if (ctxt->state != NULL)
10106: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10107: ctxt->state = oldstate;
10108: ctxt->flags = oldflags;
10109: ret = 0;
10110: if (ctxt->errNr > errNr)
10111: xmlRelaxNGPopErrors(ctxt, errNr);
10112: break;
10113: }
10114: if (ctxt->states != NULL) {
10115: xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10116: } else {
10117: ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
10118: if (ctxt->states == NULL) {
10119: xmlRelaxNGFreeValidState(ctxt, oldstate);
10120: ctxt->flags = oldflags;
10121: ret = -1;
10122: if (ctxt->errNr > errNr)
10123: xmlRelaxNGPopErrors(ctxt, errNr);
10124: break;
10125: }
10126: xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10127: xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
10128: ctxt->state = NULL;
10129: }
10130: ctxt->flags = oldflags;
10131: ret = 0;
10132: if (ctxt->errNr > errNr)
10133: xmlRelaxNGPopErrors(ctxt, errNr);
10134: break;
10135: }
10136: case XML_RELAXNG_ONEORMORE:
10137: errNr = ctxt->errNr;
10138: ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10139: if (ret != 0) {
10140: break;
10141: }
10142: if (ctxt->errNr > errNr)
10143: xmlRelaxNGPopErrors(ctxt, errNr);
10144: /* no break on purpose */
10145: case XML_RELAXNG_ZEROORMORE:{
10146: int progress;
10147: xmlRelaxNGStatesPtr states = NULL, res = NULL;
10148: int base, j;
10149:
10150: errNr = ctxt->errNr;
10151: res = xmlRelaxNGNewStates(ctxt, 1);
10152: if (res == NULL) {
10153: ret = -1;
10154: break;
10155: }
10156: /*
10157: * All the input states are also exit states
10158: */
10159: if (ctxt->state != NULL) {
10160: xmlRelaxNGAddStates(ctxt, res,
10161: xmlRelaxNGCopyValidState(ctxt,
10162: ctxt->
10163: state));
10164: } else {
10165: for (j = 0; j < ctxt->states->nbState; j++) {
10166: xmlRelaxNGAddStates(ctxt, res,
10167: xmlRelaxNGCopyValidState(ctxt,
10168: ctxt->states->tabState[j]));
10169: }
10170: }
10171: oldflags = ctxt->flags;
10172: ctxt->flags |= FLAGS_IGNORABLE;
10173: do {
10174: progress = 0;
10175: base = res->nbState;
10176:
10177: if (ctxt->states != NULL) {
10178: states = ctxt->states;
10179: for (i = 0; i < states->nbState; i++) {
10180: ctxt->state = states->tabState[i];
10181: ctxt->states = NULL;
10182: ret = xmlRelaxNGValidateDefinitionList(ctxt,
10183: define->
10184: content);
10185: if (ret == 0) {
10186: if (ctxt->state != NULL) {
10187: tmp = xmlRelaxNGAddStates(ctxt, res,
10188: ctxt->state);
10189: ctxt->state = NULL;
10190: if (tmp == 1)
10191: progress = 1;
10192: } else if (ctxt->states != NULL) {
10193: for (j = 0; j < ctxt->states->nbState;
10194: j++) {
10195: tmp =
10196: xmlRelaxNGAddStates(ctxt, res,
10197: ctxt->states->tabState[j]);
10198: if (tmp == 1)
10199: progress = 1;
10200: }
10201: xmlRelaxNGFreeStates(ctxt,
10202: ctxt->states);
10203: ctxt->states = NULL;
10204: }
10205: } else {
10206: if (ctxt->state != NULL) {
10207: xmlRelaxNGFreeValidState(ctxt,
10208: ctxt->state);
10209: ctxt->state = NULL;
10210: }
10211: }
10212: }
10213: } else {
10214: ret = xmlRelaxNGValidateDefinitionList(ctxt,
10215: define->
10216: content);
10217: if (ret != 0) {
10218: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10219: ctxt->state = NULL;
10220: } else {
10221: base = res->nbState;
10222: if (ctxt->state != NULL) {
10223: tmp = xmlRelaxNGAddStates(ctxt, res,
10224: ctxt->state);
10225: ctxt->state = NULL;
10226: if (tmp == 1)
10227: progress = 1;
10228: } else if (ctxt->states != NULL) {
10229: for (j = 0; j < ctxt->states->nbState; j++) {
10230: tmp = xmlRelaxNGAddStates(ctxt, res,
10231: ctxt->states->tabState[j]);
10232: if (tmp == 1)
10233: progress = 1;
10234: }
10235: if (states == NULL) {
10236: states = ctxt->states;
10237: } else {
10238: xmlRelaxNGFreeStates(ctxt,
10239: ctxt->states);
10240: }
10241: ctxt->states = NULL;
10242: }
10243: }
10244: }
10245: if (progress) {
10246: /*
10247: * Collect all the new nodes added at that step
10248: * and make them the new node set
10249: */
10250: if (res->nbState - base == 1) {
10251: ctxt->state = xmlRelaxNGCopyValidState(ctxt,
10252: res->
10253: tabState
10254: [base]);
10255: } else {
10256: if (states == NULL) {
10257: xmlRelaxNGNewStates(ctxt,
10258: res->nbState - base);
10259: states = ctxt->states;
10260: if (states == NULL) {
10261: progress = 0;
10262: break;
10263: }
10264: }
10265: states->nbState = 0;
10266: for (i = base; i < res->nbState; i++)
10267: xmlRelaxNGAddStates(ctxt, states,
10268: xmlRelaxNGCopyValidState
10269: (ctxt, res->tabState[i]));
10270: ctxt->states = states;
10271: }
10272: }
10273: } while (progress == 1);
10274: if (states != NULL) {
10275: xmlRelaxNGFreeStates(ctxt, states);
10276: }
10277: ctxt->states = res;
10278: ctxt->flags = oldflags;
10279: #if 0
10280: /*
10281: * errors may have to be propagated back...
10282: */
10283: if (ctxt->errNr > errNr)
10284: xmlRelaxNGPopErrors(ctxt, errNr);
10285: #endif
10286: ret = 0;
10287: break;
10288: }
10289: case XML_RELAXNG_CHOICE:{
10290: xmlRelaxNGDefinePtr list = NULL;
10291: xmlRelaxNGStatesPtr states = NULL;
10292:
10293: node = xmlRelaxNGSkipIgnored(ctxt, node);
10294:
10295: errNr = ctxt->errNr;
10296: if ((define->dflags & IS_TRIABLE) && (define->data != NULL) &&
10297: (node != NULL)) {
10298: /*
10299: * node == NULL can't be optimized since IS_TRIABLE
10300: * doesn't account for choice which may lead to
10301: * only attributes.
10302: */
10303: xmlHashTablePtr triage =
10304: (xmlHashTablePtr) define->data;
10305:
10306: /*
10307: * Something we can optimize cleanly there is only one
10308: * possble branch out !
10309: */
10310: if ((node->type == XML_TEXT_NODE) ||
10311: (node->type == XML_CDATA_SECTION_NODE)) {
10312: list =
10313: xmlHashLookup2(triage, BAD_CAST "#text", NULL);
10314: } else if (node->type == XML_ELEMENT_NODE) {
10315: if (node->ns != NULL) {
10316: list = xmlHashLookup2(triage, node->name,
10317: node->ns->href);
10318: if (list == NULL)
10319: list =
10320: xmlHashLookup2(triage, BAD_CAST "#any",
10321: node->ns->href);
10322: } else
10323: list =
10324: xmlHashLookup2(triage, node->name, NULL);
10325: if (list == NULL)
10326: list =
10327: xmlHashLookup2(triage, BAD_CAST "#any",
10328: NULL);
10329: }
10330: if (list == NULL) {
10331: ret = -1;
10332: VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
10333: break;
10334: }
10335: ret = xmlRelaxNGValidateDefinition(ctxt, list);
10336: if (ret == 0) {
10337: }
10338: break;
10339: }
10340:
10341: list = define->content;
10342: oldflags = ctxt->flags;
10343: ctxt->flags |= FLAGS_IGNORABLE;
10344:
10345: while (list != NULL) {
10346: oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10347: ret = xmlRelaxNGValidateDefinition(ctxt, list);
10348: if (ret == 0) {
10349: if (states == NULL) {
10350: states = xmlRelaxNGNewStates(ctxt, 1);
10351: }
10352: if (ctxt->state != NULL) {
10353: xmlRelaxNGAddStates(ctxt, states, ctxt->state);
10354: } else if (ctxt->states != NULL) {
10355: for (i = 0; i < ctxt->states->nbState; i++) {
10356: xmlRelaxNGAddStates(ctxt, states,
10357: ctxt->states->
10358: tabState[i]);
10359: }
10360: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10361: ctxt->states = NULL;
10362: }
10363: } else {
10364: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10365: }
10366: ctxt->state = oldstate;
10367: list = list->next;
10368: }
10369: if (states != NULL) {
10370: xmlRelaxNGFreeValidState(ctxt, oldstate);
10371: ctxt->states = states;
10372: ctxt->state = NULL;
10373: ret = 0;
10374: } else {
10375: ctxt->states = NULL;
10376: }
10377: ctxt->flags = oldflags;
10378: if (ret != 0) {
10379: if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10380: xmlRelaxNGDumpValidError(ctxt);
10381: }
10382: } else {
10383: if (ctxt->errNr > errNr)
10384: xmlRelaxNGPopErrors(ctxt, errNr);
10385: }
10386: break;
10387: }
10388: case XML_RELAXNG_DEF:
10389: case XML_RELAXNG_GROUP:
10390: ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10391: break;
10392: case XML_RELAXNG_INTERLEAVE:
10393: ret = xmlRelaxNGValidateInterleave(ctxt, define);
10394: break;
10395: case XML_RELAXNG_ATTRIBUTE:
10396: ret = xmlRelaxNGValidateAttribute(ctxt, define);
10397: break;
10398: case XML_RELAXNG_START:
10399: case XML_RELAXNG_NOOP:
10400: case XML_RELAXNG_REF:
10401: case XML_RELAXNG_EXTERNALREF:
10402: case XML_RELAXNG_PARENTREF:
10403: ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
10404: break;
10405: case XML_RELAXNG_DATATYPE:{
10406: xmlNodePtr child;
10407: xmlChar *content = NULL;
10408:
10409: child = node;
10410: while (child != NULL) {
10411: if (child->type == XML_ELEMENT_NODE) {
10412: VALID_ERR2(XML_RELAXNG_ERR_DATAELEM,
10413: node->parent->name);
10414: ret = -1;
10415: break;
10416: } else if ((child->type == XML_TEXT_NODE) ||
10417: (child->type == XML_CDATA_SECTION_NODE)) {
10418: content = xmlStrcat(content, child->content);
10419: }
10420: /* TODO: handle entities ... */
10421: child = child->next;
10422: }
10423: if (ret == -1) {
10424: if (content != NULL)
10425: xmlFree(content);
10426: break;
10427: }
10428: if (content == NULL) {
10429: content = xmlStrdup(BAD_CAST "");
10430: if (content == NULL) {
10431: xmlRngVErrMemory(ctxt, "validating\n");
10432: ret = -1;
10433: break;
10434: }
10435: }
10436: ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
10437: ctxt->state->seq);
10438: if (ret == -1) {
10439: VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name);
10440: } else if (ret == 0) {
10441: ctxt->state->seq = NULL;
10442: }
10443: if (content != NULL)
10444: xmlFree(content);
10445: break;
10446: }
10447: case XML_RELAXNG_VALUE:{
10448: xmlChar *content = NULL;
10449: xmlChar *oldvalue;
10450: xmlNodePtr child;
10451:
10452: child = node;
10453: while (child != NULL) {
10454: if (child->type == XML_ELEMENT_NODE) {
10455: VALID_ERR2(XML_RELAXNG_ERR_VALELEM,
10456: node->parent->name);
10457: ret = -1;
10458: break;
10459: } else if ((child->type == XML_TEXT_NODE) ||
10460: (child->type == XML_CDATA_SECTION_NODE)) {
10461: content = xmlStrcat(content, child->content);
10462: }
10463: /* TODO: handle entities ... */
10464: child = child->next;
10465: }
10466: if (ret == -1) {
10467: if (content != NULL)
10468: xmlFree(content);
10469: break;
10470: }
10471: if (content == NULL) {
10472: content = xmlStrdup(BAD_CAST "");
10473: if (content == NULL) {
10474: xmlRngVErrMemory(ctxt, "validating\n");
10475: ret = -1;
10476: break;
10477: }
10478: }
10479: oldvalue = ctxt->state->value;
10480: ctxt->state->value = content;
10481: ret = xmlRelaxNGValidateValue(ctxt, define);
10482: ctxt->state->value = oldvalue;
10483: if (ret == -1) {
10484: VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name);
10485: } else if (ret == 0) {
10486: ctxt->state->seq = NULL;
10487: }
10488: if (content != NULL)
10489: xmlFree(content);
10490: break;
10491: }
10492: case XML_RELAXNG_LIST:{
10493: xmlChar *content;
10494: xmlNodePtr child;
10495: xmlChar *oldvalue, *oldendvalue;
10496: int len;
10497:
10498: /*
10499: * Make sure it's only text nodes
10500: */
10501:
10502: content = NULL;
10503: child = node;
10504: while (child != NULL) {
10505: if (child->type == XML_ELEMENT_NODE) {
10506: VALID_ERR2(XML_RELAXNG_ERR_LISTELEM,
10507: node->parent->name);
10508: ret = -1;
10509: break;
10510: } else if ((child->type == XML_TEXT_NODE) ||
10511: (child->type == XML_CDATA_SECTION_NODE)) {
10512: content = xmlStrcat(content, child->content);
10513: }
10514: /* TODO: handle entities ... */
10515: child = child->next;
10516: }
10517: if (ret == -1) {
10518: if (content != NULL)
10519: xmlFree(content);
10520: break;
10521: }
10522: if (content == NULL) {
10523: content = xmlStrdup(BAD_CAST "");
10524: if (content == NULL) {
10525: xmlRngVErrMemory(ctxt, "validating\n");
10526: ret = -1;
10527: break;
10528: }
10529: }
10530: len = xmlStrlen(content);
10531: oldvalue = ctxt->state->value;
10532: oldendvalue = ctxt->state->endvalue;
10533: ctxt->state->value = content;
10534: ctxt->state->endvalue = content + len;
10535: ret = xmlRelaxNGValidateValue(ctxt, define);
10536: ctxt->state->value = oldvalue;
10537: ctxt->state->endvalue = oldendvalue;
10538: if (ret == -1) {
10539: VALID_ERR(XML_RELAXNG_ERR_LIST);
10540: } else if ((ret == 0) && (node != NULL)) {
10541: ctxt->state->seq = node->next;
10542: }
10543: if (content != NULL)
10544: xmlFree(content);
10545: break;
10546: }
10547: case XML_RELAXNG_EXCEPT:
10548: case XML_RELAXNG_PARAM:
10549: TODO ret = -1;
10550: break;
10551: }
10552: ctxt->depth--;
10553: #ifdef DEBUG
10554: for (i = 0; i < ctxt->depth; i++)
10555: xmlGenericError(xmlGenericErrorContext, " ");
10556: xmlGenericError(xmlGenericErrorContext,
10557: "Validating %s ", xmlRelaxNGDefName(define));
10558: if (define->name != NULL)
10559: xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
10560: if (ret == 0)
10561: xmlGenericError(xmlGenericErrorContext, "suceeded\n");
10562: else
10563: xmlGenericError(xmlGenericErrorContext, "failed\n");
10564: #endif
10565: return (ret);
10566: }
10567:
10568: /**
10569: * xmlRelaxNGValidateDefinition:
10570: * @ctxt: a Relax-NG validation context
10571: * @define: the definition to verify
10572: *
10573: * Validate the current node lists against the definition
10574: *
10575: * Returns 0 if the validation succeeded or an error code.
10576: */
10577: static int
10578: xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
10579: xmlRelaxNGDefinePtr define)
10580: {
10581: xmlRelaxNGStatesPtr states, res;
10582: int i, j, k, ret, oldflags;
10583:
10584: /*
10585: * We should NOT have both ctxt->state and ctxt->states
10586: */
10587: if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10588: TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10589: ctxt->state = NULL;
10590: }
10591:
10592: if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
10593: if (ctxt->states != NULL) {
10594: ctxt->state = ctxt->states->tabState[0];
10595: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10596: ctxt->states = NULL;
10597: }
10598: ret = xmlRelaxNGValidateState(ctxt, define);
10599: if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10600: TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10601: ctxt->state = NULL;
10602: }
10603: if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
10604: ctxt->state = ctxt->states->tabState[0];
10605: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10606: ctxt->states = NULL;
10607: }
10608: return (ret);
10609: }
10610:
10611: states = ctxt->states;
10612: ctxt->states = NULL;
10613: res = NULL;
10614: j = 0;
10615: oldflags = ctxt->flags;
10616: ctxt->flags |= FLAGS_IGNORABLE;
10617: for (i = 0; i < states->nbState; i++) {
10618: ctxt->state = states->tabState[i];
10619: ctxt->states = NULL;
10620: ret = xmlRelaxNGValidateState(ctxt, define);
10621: /*
10622: * We should NOT have both ctxt->state and ctxt->states
10623: */
10624: if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10625: TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10626: ctxt->state = NULL;
10627: }
10628: if (ret == 0) {
10629: if (ctxt->states == NULL) {
10630: if (res != NULL) {
10631: /* add the state to the container */
10632: xmlRelaxNGAddStates(ctxt, res, ctxt->state);
10633: ctxt->state = NULL;
10634: } else {
10635: /* add the state directly in states */
10636: states->tabState[j++] = ctxt->state;
10637: ctxt->state = NULL;
10638: }
10639: } else {
10640: if (res == NULL) {
10641: /* make it the new container and copy other results */
10642: res = ctxt->states;
10643: ctxt->states = NULL;
10644: for (k = 0; k < j; k++)
10645: xmlRelaxNGAddStates(ctxt, res,
10646: states->tabState[k]);
10647: } else {
10648: /* add all the new results to res and reff the container */
10649: for (k = 0; k < ctxt->states->nbState; k++)
10650: xmlRelaxNGAddStates(ctxt, res,
10651: ctxt->states->tabState[k]);
10652: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10653: ctxt->states = NULL;
10654: }
10655: }
10656: } else {
10657: if (ctxt->state != NULL) {
10658: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10659: ctxt->state = NULL;
10660: } else if (ctxt->states != NULL) {
10661: for (k = 0; k < ctxt->states->nbState; k++)
10662: xmlRelaxNGFreeValidState(ctxt,
10663: ctxt->states->tabState[k]);
10664: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10665: ctxt->states = NULL;
10666: }
10667: }
10668: }
10669: ctxt->flags = oldflags;
10670: if (res != NULL) {
10671: xmlRelaxNGFreeStates(ctxt, states);
10672: ctxt->states = res;
10673: ret = 0;
10674: } else if (j > 1) {
10675: states->nbState = j;
10676: ctxt->states = states;
10677: ret = 0;
10678: } else if (j == 1) {
10679: ctxt->state = states->tabState[0];
10680: xmlRelaxNGFreeStates(ctxt, states);
10681: ret = 0;
10682: } else {
10683: ret = -1;
10684: xmlRelaxNGFreeStates(ctxt, states);
10685: if (ctxt->states != NULL) {
10686: xmlRelaxNGFreeStates(ctxt, ctxt->states);
10687: ctxt->states = NULL;
10688: }
10689: }
10690: if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10691: TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10692: ctxt->state = NULL;
10693: }
10694: return (ret);
10695: }
10696:
10697: /**
10698: * xmlRelaxNGValidateDocument:
10699: * @ctxt: a Relax-NG validation context
10700: * @doc: the document
10701: *
10702: * Validate the given document
10703: *
10704: * Returns 0 if the validation succeeded or an error code.
10705: */
10706: static int
10707: xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
10708: {
10709: int ret;
10710: xmlRelaxNGPtr schema;
10711: xmlRelaxNGGrammarPtr grammar;
10712: xmlRelaxNGValidStatePtr state;
10713: xmlNodePtr node;
10714:
10715: if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
10716: return (-1);
10717:
10718: ctxt->errNo = XML_RELAXNG_OK;
10719: schema = ctxt->schema;
10720: grammar = schema->topgrammar;
10721: if (grammar == NULL) {
10722: VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
10723: return (-1);
10724: }
10725: state = xmlRelaxNGNewValidState(ctxt, NULL);
10726: ctxt->state = state;
10727: ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
10728: if ((ctxt->state != NULL) && (state->seq != NULL)) {
10729: state = ctxt->state;
10730: node = state->seq;
10731: node = xmlRelaxNGSkipIgnored(ctxt, node);
10732: if (node != NULL) {
10733: if (ret != -1) {
10734: VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
10735: ret = -1;
10736: }
10737: }
10738: } else if (ctxt->states != NULL) {
10739: int i;
10740: int tmp = -1;
10741:
10742: for (i = 0; i < ctxt->states->nbState; i++) {
10743: state = ctxt->states->tabState[i];
10744: node = state->seq;
10745: node = xmlRelaxNGSkipIgnored(ctxt, node);
10746: if (node == NULL)
10747: tmp = 0;
10748: xmlRelaxNGFreeValidState(ctxt, state);
10749: }
10750: if (tmp == -1) {
10751: if (ret != -1) {
10752: VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
10753: ret = -1;
10754: }
10755: }
10756: }
10757: if (ctxt->state != NULL) {
10758: xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10759: ctxt->state = NULL;
10760: }
10761: if (ret != 0)
10762: xmlRelaxNGDumpValidError(ctxt);
10763: #ifdef DEBUG
10764: else if (ctxt->errNr != 0) {
10765: ctxt->error(ctxt->userData,
10766: "%d Extra error messages left on stack !\n",
10767: ctxt->errNr);
10768: xmlRelaxNGDumpValidError(ctxt);
10769: }
10770: #endif
10771: #ifdef LIBXML_VALID_ENABLED
10772: if (ctxt->idref == 1) {
10773: xmlValidCtxt vctxt;
10774:
10775: memset(&vctxt, 0, sizeof(xmlValidCtxt));
10776: vctxt.valid = 1;
10777: vctxt.error = ctxt->error;
10778: vctxt.warning = ctxt->warning;
10779: vctxt.userData = ctxt->userData;
10780:
10781: if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
10782: ret = -1;
10783: }
10784: #endif /* LIBXML_VALID_ENABLED */
10785: if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
10786: ret = -1;
10787:
10788: return (ret);
10789: }
10790:
10791: /**
10792: * xmlRelaxNGCleanPSVI:
10793: * @node: an input element or document
10794: *
10795: * Call this routine to speed up XPath computation on static documents.
10796: * This stamps all the element nodes with the document order
10797: * Like for line information, the order is kept in the element->content
10798: * field, the value stored is actually - the node number (starting at -1)
10799: * to be able to differentiate from line numbers.
10800: *
10801: * Returns the number of elements found in the document or -1 in case
10802: * of error.
10803: */
10804: static void
10805: xmlRelaxNGCleanPSVI(xmlNodePtr node) {
10806: xmlNodePtr cur;
10807:
10808: if ((node == NULL) ||
10809: ((node->type != XML_ELEMENT_NODE) &&
10810: (node->type != XML_DOCUMENT_NODE) &&
10811: (node->type != XML_HTML_DOCUMENT_NODE)))
10812: return;
10813: if (node->type == XML_ELEMENT_NODE)
10814: node->psvi = NULL;
10815:
10816: cur = node->children;
10817: while (cur != NULL) {
10818: if (cur->type == XML_ELEMENT_NODE) {
10819: cur->psvi = NULL;
10820: if (cur->children != NULL) {
10821: cur = cur->children;
10822: continue;
10823: }
10824: }
10825: if (cur->next != NULL) {
10826: cur = cur->next;
10827: continue;
10828: }
10829: do {
10830: cur = cur->parent;
10831: if (cur == NULL)
10832: break;
10833: if (cur == node) {
10834: cur = NULL;
10835: break;
10836: }
10837: if (cur->next != NULL) {
10838: cur = cur->next;
10839: break;
10840: }
10841: } while (cur != NULL);
10842: }
10843: return;
10844: }
10845: /************************************************************************
10846: * *
10847: * Validation interfaces *
10848: * *
10849: ************************************************************************/
10850:
10851: /**
10852: * xmlRelaxNGNewValidCtxt:
10853: * @schema: a precompiled XML RelaxNGs
10854: *
10855: * Create an XML RelaxNGs validation context based on the given schema
10856: *
10857: * Returns the validation context or NULL in case of error
10858: */
10859: xmlRelaxNGValidCtxtPtr
10860: xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
10861: {
10862: xmlRelaxNGValidCtxtPtr ret;
10863:
10864: ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
10865: if (ret == NULL) {
10866: xmlRngVErrMemory(NULL, "building context\n");
10867: return (NULL);
10868: }
10869: memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
10870: ret->schema = schema;
10871: ret->error = xmlGenericError;
10872: ret->userData = xmlGenericErrorContext;
10873: ret->errNr = 0;
10874: ret->errMax = 0;
10875: ret->err = NULL;
10876: ret->errTab = NULL;
10877: if (schema != NULL)
10878: ret->idref = schema->idref;
10879: ret->states = NULL;
10880: ret->freeState = NULL;
10881: ret->freeStates = NULL;
10882: ret->errNo = XML_RELAXNG_OK;
10883: return (ret);
10884: }
10885:
10886: /**
10887: * xmlRelaxNGFreeValidCtxt:
10888: * @ctxt: the schema validation context
10889: *
10890: * Free the resources associated to the schema validation context
10891: */
10892: void
10893: xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
10894: {
10895: int k;
10896:
10897: if (ctxt == NULL)
10898: return;
10899: if (ctxt->states != NULL)
10900: xmlRelaxNGFreeStates(NULL, ctxt->states);
10901: if (ctxt->freeState != NULL) {
10902: for (k = 0; k < ctxt->freeState->nbState; k++) {
10903: xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
10904: }
10905: xmlRelaxNGFreeStates(NULL, ctxt->freeState);
10906: }
10907: if (ctxt->freeStates != NULL) {
10908: for (k = 0; k < ctxt->freeStatesNr; k++) {
10909: xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
10910: }
10911: xmlFree(ctxt->freeStates);
10912: }
10913: if (ctxt->errTab != NULL)
10914: xmlFree(ctxt->errTab);
10915: if (ctxt->elemTab != NULL) {
10916: xmlRegExecCtxtPtr exec;
10917:
10918: exec = xmlRelaxNGElemPop(ctxt);
10919: while (exec != NULL) {
10920: xmlRegFreeExecCtxt(exec);
10921: exec = xmlRelaxNGElemPop(ctxt);
10922: }
10923: xmlFree(ctxt->elemTab);
10924: }
10925: xmlFree(ctxt);
10926: }
10927:
10928: /**
10929: * xmlRelaxNGSetValidErrors:
10930: * @ctxt: a Relax-NG validation context
10931: * @err: the error function
10932: * @warn: the warning function
10933: * @ctx: the functions context
10934: *
10935: * Set the error and warning callback informations
10936: */
10937: void
10938: xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10939: xmlRelaxNGValidityErrorFunc err,
10940: xmlRelaxNGValidityWarningFunc warn, void *ctx)
10941: {
10942: if (ctxt == NULL)
10943: return;
10944: ctxt->error = err;
10945: ctxt->warning = warn;
10946: ctxt->userData = ctx;
10947: ctxt->serror = NULL;
10948: }
10949:
10950: /**
10951: * xmlRelaxNGSetValidStructuredErrors:
10952: * @ctxt: a Relax-NG validation context
10953: * @serror: the structured error function
10954: * @ctx: the functions context
10955: *
10956: * Set the structured error callback
10957: */
10958: void
10959: xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
10960: xmlStructuredErrorFunc serror, void *ctx)
10961: {
10962: if (ctxt == NULL)
10963: return;
10964: ctxt->serror = serror;
10965: ctxt->error = NULL;
10966: ctxt->warning = NULL;
10967: ctxt->userData = ctx;
10968: }
10969:
10970: /**
10971: * xmlRelaxNGGetValidErrors:
10972: * @ctxt: a Relax-NG validation context
10973: * @err: the error function result
10974: * @warn: the warning function result
10975: * @ctx: the functions context result
10976: *
10977: * Get the error and warning callback informations
10978: *
10979: * Returns -1 in case of error and 0 otherwise
10980: */
10981: int
10982: xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10983: xmlRelaxNGValidityErrorFunc * err,
10984: xmlRelaxNGValidityWarningFunc * warn, void **ctx)
10985: {
10986: if (ctxt == NULL)
10987: return (-1);
10988: if (err != NULL)
10989: *err = ctxt->error;
10990: if (warn != NULL)
10991: *warn = ctxt->warning;
10992: if (ctx != NULL)
10993: *ctx = ctxt->userData;
10994: return (0);
10995: }
10996:
10997: /**
10998: * xmlRelaxNGValidateDoc:
10999: * @ctxt: a Relax-NG validation context
11000: * @doc: a parsed document tree
11001: *
11002: * Validate a document tree in memory.
11003: *
11004: * Returns 0 if the document is valid, a positive error code
11005: * number otherwise and -1 in case of internal or API error.
11006: */
11007: int
11008: xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
11009: {
11010: int ret;
11011:
11012: if ((ctxt == NULL) || (doc == NULL))
11013: return (-1);
11014:
11015: ctxt->doc = doc;
11016:
11017: ret = xmlRelaxNGValidateDocument(ctxt, doc);
11018: /*
11019: * Remove all left PSVI
11020: */
11021: xmlRelaxNGCleanPSVI((xmlNodePtr) doc);
11022:
11023: /*
11024: * TODO: build error codes
11025: */
11026: if (ret == -1)
11027: return (1);
11028: return (ret);
11029: }
11030:
11031: #define bottom_relaxng
11032: #include "elfgcchack.h"
11033: #endif /* LIBXML_SCHEMAS_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to relaxng.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