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