Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(50)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/libxml/src/relaxng.c

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

Powered by Google App Engine
This is Rietveld 408576698