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 <stddef.h>
24#include <libxml/xmlmemory.h>
25#include <libxml/parser.h>
26#include <libxml/parserInternals.h>
27#include <libxml/hash.h>
28#include <libxml/uri.h>
29
30#include <libxml/relaxng.h>
31
32#include <libxml/xmlschemastypes.h>
33#include <libxml/xmlautomata.h>
34#include <libxml/xmlregexp.h>
35#include <libxml/xmlschemastypes.h>
36
37/*
38 * The Relax-NG namespace
39 */
40static const xmlChar *xmlRelaxNGNs = (const xmlChar *)
41 "http://relaxng.org/ns/structure/1.0";
42
43#define IS_RELAXNG(node, typ) \
44 ((node != NULL) && (node->ns != NULL) && \
45 (node->type == XML_ELEMENT_NODE) && \
46 (xmlStrEqual(node->name, (const xmlChar *) typ)) && \
47 (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
48
49
50#if 0
51#define DEBUG 1
52
53#define DEBUG_GRAMMAR 1
54
55#define DEBUG_CONTENT 1
56
57#define DEBUG_TYPE 1
58
59#define DEBUG_VALID 1
60
61#define DEBUG_INTERLEAVE 1
62
63#define DEBUG_LIST 1
64
65#define DEBUG_INCLUDE 1
66
67#define DEBUG_ERROR 1
68
69#define DEBUG_COMPILE 1
70
71#define DEBUG_PROGRESSIVE 1
72#endif
73
74#define MAX_ERROR 5
75
76#define TODO \
77 xmlGenericError(xmlGenericErrorContext, \
78 "Unimplemented block at %s:%d\n", \
79 __FILE__, __LINE__);
80
81typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema;
82typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr;
83
84typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine;
85typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr;
86
87typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument;
88typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr;
89
90typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude;
91typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;
92
93typedef enum {
94 XML_RELAXNG_COMBINE_UNDEFINED = 0, /* undefined */
95 XML_RELAXNG_COMBINE_CHOICE, /* choice */
96 XML_RELAXNG_COMBINE_INTERLEAVE /* interleave */
97} xmlRelaxNGCombine;
98
99typedef enum {
100 XML_RELAXNG_CONTENT_ERROR = -1,
101 XML_RELAXNG_CONTENT_EMPTY = 0,
102 XML_RELAXNG_CONTENT_SIMPLE,
103 XML_RELAXNG_CONTENT_COMPLEX
104} xmlRelaxNGContentType;
105
106typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar;
107typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr;
108
109struct _xmlRelaxNGGrammar {
110 xmlRelaxNGGrammarPtr parent; /* the parent grammar if any */
111 xmlRelaxNGGrammarPtr children; /* the children grammar if any */
112 xmlRelaxNGGrammarPtr next; /* the next grammar if any */
113 xmlRelaxNGDefinePtr start; /* <start> content */
114 xmlRelaxNGCombine combine; /* the default combine value */
115 xmlRelaxNGDefinePtr startList; /* list of <start> definitions */
116 xmlHashTablePtr defs; /* define* */
117 xmlHashTablePtr refs; /* references */
118};
119
120
121typedef enum {
122 XML_RELAXNG_NOOP = -1, /* a no operation from simplification */
123 XML_RELAXNG_EMPTY = 0, /* an empty pattern */
124 XML_RELAXNG_NOT_ALLOWED, /* not allowed top */
125 XML_RELAXNG_EXCEPT, /* except present in nameclass defs */
126 XML_RELAXNG_TEXT, /* textual content */
127 XML_RELAXNG_ELEMENT, /* an element */
128 XML_RELAXNG_DATATYPE, /* extenal data type definition */
129 XML_RELAXNG_PARAM, /* extenal data type parameter */
130 XML_RELAXNG_VALUE, /* value from an extenal data type definition */
131 XML_RELAXNG_LIST, /* a list of patterns */
132 XML_RELAXNG_ATTRIBUTE, /* an attrbute following a pattern */
133 XML_RELAXNG_DEF, /* a definition */
134 XML_RELAXNG_REF, /* reference to a definition */
135 XML_RELAXNG_EXTERNALREF, /* reference to an external def */
136 XML_RELAXNG_PARENTREF, /* reference to a def in the parent grammar */
137 XML_RELAXNG_OPTIONAL, /* optional patterns */
138 XML_RELAXNG_ZEROORMORE, /* zero or more non empty patterns */
139 XML_RELAXNG_ONEORMORE, /* one or more non empty patterns */
140 XML_RELAXNG_CHOICE, /* a choice between non empty patterns */
141 XML_RELAXNG_GROUP, /* a pair/group of non empty patterns */
142 XML_RELAXNG_INTERLEAVE, /* interleaving choice of non-empty patterns */
143 XML_RELAXNG_START /* Used to keep track of starts on grammars */
144} xmlRelaxNGType;
145
146#define IS_NULLABLE (1 << 0)
147#define IS_NOT_NULLABLE (1 << 1)
148#define IS_INDETERMINIST (1 << 2)
149#define IS_MIXED (1 << 3)
150#define IS_TRIABLE (1 << 4)
151#define IS_PROCESSED (1 << 5)
152#define IS_COMPILABLE (1 << 6)
153#define IS_NOT_COMPILABLE (1 << 7)
154#define IS_EXTERNAL_REF (1 << 8)
155
156struct _xmlRelaxNGDefine {
157 xmlRelaxNGType type; /* the type of definition */
158 xmlNodePtr node; /* the node in the source */
159 xmlChar *name; /* the element local name if present */
160 xmlChar *ns; /* the namespace local name if present */
161 xmlChar *value; /* value when available */
162 void *data; /* data lib or specific pointer */
163 xmlRelaxNGDefinePtr content; /* the expected content */
164 xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
165 xmlRelaxNGDefinePtr next; /* list within grouping sequences */
166 xmlRelaxNGDefinePtr attrs; /* list of attributes for elements */
167 xmlRelaxNGDefinePtr nameClass; /* the nameClass definition if any */
168 xmlRelaxNGDefinePtr nextHash; /* next define in defs/refs hash tables */
169 short depth; /* used for the cycle detection */
170 short dflags; /* define related flags */
171 xmlRegexpPtr contModel; /* a compiled content model if available */
172};
173
174/**
175 * _xmlRelaxNG:
176 *
177 * A RelaxNGs definition
178 */
179struct _xmlRelaxNG {
180 void *_private; /* unused by the library for users or bindings */
181 xmlRelaxNGGrammarPtr topgrammar;
182 xmlDocPtr doc;
183
184 int idref; /* requires idref checking */
185
186 xmlHashTablePtr defs; /* define */
187 xmlHashTablePtr refs; /* references */
188 xmlRelaxNGDocumentPtr documents; /* all the documents loaded */
189 xmlRelaxNGIncludePtr includes; /* all the includes loaded */
190 int defNr; /* number of defines used */
191 xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */
192
193};
194
195#define XML_RELAXNG_IN_ATTRIBUTE (1 << 0)
196#define XML_RELAXNG_IN_ONEORMORE (1 << 1)
197#define XML_RELAXNG_IN_LIST (1 << 2)
198#define XML_RELAXNG_IN_DATAEXCEPT (1 << 3)
199#define XML_RELAXNG_IN_START (1 << 4)
200#define XML_RELAXNG_IN_OOMGROUP (1 << 5)
201#define XML_RELAXNG_IN_OOMINTERLEAVE (1 << 6)
202#define XML_RELAXNG_IN_EXTERNALREF (1 << 7)
203#define XML_RELAXNG_IN_ANYEXCEPT (1 << 8)
204#define XML_RELAXNG_IN_NSEXCEPT (1 << 9)
205
206struct _xmlRelaxNGParserCtxt {
207 void *userData; /* user specific data block */
208 xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
209 xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
210 xmlStructuredErrorFunc serror;
211 xmlRelaxNGValidErr err;
212
213 xmlRelaxNGPtr schema; /* The schema in use */
214 xmlRelaxNGGrammarPtr grammar; /* the current grammar */
215 xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */
216 int flags; /* parser flags */
217 int nbErrors; /* number of errors at parse time */
218 int nbWarnings; /* number of warnings at parse time */
219 const xmlChar *define; /* the current define scope */
220 xmlRelaxNGDefinePtr def; /* the current define */
221
222 int nbInterleaves;
223 xmlHashTablePtr interleaves; /* keep track of all the interleaves */
224
225 xmlRelaxNGDocumentPtr documents; /* all the documents loaded */
226 xmlRelaxNGIncludePtr includes; /* all the includes loaded */
227 xmlChar *URL;
228 xmlDocPtr document;
229
230 int defNr; /* number of defines used */
231 int defMax; /* number of defines aloocated */
232 xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */
233
234 const char *buffer;
235 int size;
236
237 /* the document stack */
238 xmlRelaxNGDocumentPtr doc; /* Current parsed external ref */
239 int docNr; /* Depth of the parsing stack */
240 int docMax; /* Max depth of the parsing stack */
241 xmlRelaxNGDocumentPtr *docTab; /* array of docs */
242
243 /* the include stack */
244 xmlRelaxNGIncludePtr inc; /* Current parsed include */
245 int incNr; /* Depth of the include parsing stack */
246 int incMax; /* Max depth of the parsing stack */
247 xmlRelaxNGIncludePtr *incTab; /* array of incs */
248
249 int idref; /* requires idref checking */
250
251 /* used to compile content models */
252 xmlAutomataPtr am; /* the automata */
253 xmlAutomataStatePtr state; /* used to build the automata */
254
255 int crng; /* compact syntax and other flags */
256 int freedoc; /* need to free the document */
257};
258
259#define FLAGS_IGNORABLE 1
260#define FLAGS_NEGATIVE 2
261#define FLAGS_MIXED_CONTENT 4
262#define FLAGS_NOERROR 8
263
264/**
265 * xmlRelaxNGInterleaveGroup:
266 *
267 * A RelaxNGs partition set associated to lists of definitions
268 */
269typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup;
270typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr;
271struct _xmlRelaxNGInterleaveGroup {
272 xmlRelaxNGDefinePtr rule; /* the rule to satisfy */
273 xmlRelaxNGDefinePtr *defs; /* the array of element definitions */
274 xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */
275};
276
277#define IS_DETERMINIST 1
278#define IS_NEEDCHECK 2
279
280/**
281 * xmlRelaxNGPartitions:
282 *
283 * A RelaxNGs partition associated to an interleave group
284 */
285typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition;
286typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr;
287struct _xmlRelaxNGPartition {
288 int nbgroups; /* number of groups in the partitions */
289 xmlHashTablePtr triage; /* hash table used to direct nodes to the
290 * right group when possible */
291 int flags; /* determinist ? */
292 xmlRelaxNGInterleaveGroupPtr *groups;
293};
294
295/**
296 * xmlRelaxNGValidState:
297 *
298 * A RelaxNGs validation state
299 */
300#define MAX_ATTR 20
301typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState;
302typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr;
303struct _xmlRelaxNGValidState {
304 xmlNodePtr node; /* the current node */
305 xmlNodePtr seq; /* the sequence of children left to validate */
306 int nbAttrs; /* the number of attributes */
307 int maxAttrs; /* the size of attrs */
308 int nbAttrLeft; /* the number of attributes left to validate */
309 xmlChar *value; /* the value when operating on string */
310 xmlChar *endvalue; /* the end value when operating on string */
311 xmlAttrPtr *attrs; /* the array of attributes */
312};
313
314/**
315 * xmlRelaxNGStates:
316 *
317 * A RelaxNGs container for validation state
318 */
319typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
320typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
321struct _xmlRelaxNGStates {
322 int nbState; /* the number of states */
323 int maxState; /* the size of the array */
324 xmlRelaxNGValidStatePtr *tabState;
325};
326
327#define ERROR_IS_DUP 1
328
329/**
330 * xmlRelaxNGValidError:
331 *
332 * A RelaxNGs validation error
333 */
334typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError;
335typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr;
336struct _xmlRelaxNGValidError {
337 xmlRelaxNGValidErr err; /* the error number */
338 int flags; /* flags */
339 xmlNodePtr node; /* the current node */
340 xmlNodePtr seq; /* the current child */
341 const xmlChar *arg1; /* first arg */
342 const xmlChar *arg2; /* second arg */
343};
344
345/**
346 * xmlRelaxNGValidCtxt:
347 *
348 * A RelaxNGs validation context
349 */
350
351struct _xmlRelaxNGValidCtxt {
352 void *userData; /* user specific data block */
353 xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
354 xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
355 xmlStructuredErrorFunc serror;
356 int nbErrors; /* number of errors in validation */
357
358 xmlRelaxNGPtr schema; /* The schema in use */
359 xmlDocPtr doc; /* the document being validated */
360 int flags; /* validation flags */
361 int depth; /* validation depth */
362 int idref; /* requires idref checking */
363 int errNo; /* the first error found */
364
365 /*
366 * Errors accumulated in branches may have to be stacked to be
367 * provided back when it's sure they affect validation.
368 */
369 xmlRelaxNGValidErrorPtr err; /* Last error */
370 int errNr; /* Depth of the error stack */
371 int errMax; /* Max depth of the error stack */
372 xmlRelaxNGValidErrorPtr errTab; /* stack of errors */
373
374 xmlRelaxNGValidStatePtr state; /* the current validation state */
375 xmlRelaxNGStatesPtr states; /* the accumulated state list */
376
377 xmlRelaxNGStatesPtr freeState; /* the pool of free valid states */
378 int freeStatesNr;
379 int freeStatesMax;
380 xmlRelaxNGStatesPtr *freeStates; /* the pool of free state groups */
381
382 /*
383 * This is used for "progressive" validation
384 */
385 xmlRegExecCtxtPtr elem; /* the current element regexp */
386 int elemNr; /* the number of element validated */
387 int elemMax; /* the max depth of elements */
388 xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */
389 int pstate; /* progressive state */
390 xmlNodePtr pnode; /* the current node */
391 xmlRelaxNGDefinePtr pdef; /* the non-streamable definition */
392 int perr; /* signal error in content model
393 * outside the regexp */
394};
395
396/**
397 * xmlRelaxNGInclude:
398 *
399 * Structure associated to a RelaxNGs document element
400 */
401struct _xmlRelaxNGInclude {
402 xmlRelaxNGIncludePtr next; /* keep a chain of includes */
403 xmlChar *href; /* the normalized href value */
404 xmlDocPtr doc; /* the associated XML document */
405 xmlRelaxNGDefinePtr content; /* the definitions */
406 xmlRelaxNGPtr schema; /* the schema */
407};
408
409/**
410 * xmlRelaxNGDocument:
411 *
412 * Structure associated to a RelaxNGs document element
413 */
414struct _xmlRelaxNGDocument {
415 xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
416 xmlChar *href; /* the normalized href value */
417 xmlDocPtr doc; /* the associated XML document */
418 xmlRelaxNGDefinePtr content; /* the definitions */
419 xmlRelaxNGPtr schema; /* the schema */
420 int externalRef; /* 1 if an external ref */
421};
422
423
424/************************************************************************
425 * *
426 * Some factorized error routines *
427 * *
428 ************************************************************************/
429
430/**
431 * xmlRngPErrMemory:
432 * @ctxt: an Relax-NG parser context
433 * @extra: extra informations
434 *
435 * Handle a redefinition of attribute error
436 */
437static void
438xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
439{
440 xmlStructuredErrorFunc schannel = NULL;
441 xmlGenericErrorFunc channel = NULL;
442 void *data = NULL;
443
444 if (ctxt != NULL) {
445 if (ctxt->serror != NULL)
446 schannel = ctxt->serror;
447 else
448 channel = ctxt->error;
449 data = ctxt->userData;
450 ctxt->nbErrors++;
451 }
452 if (extra)
453 __xmlRaiseError(schannel, channel, data,
454 NULL, NULL, XML_FROM_RELAXNGP,
455 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
456 NULL, NULL, 0, 0,
457 "Memory allocation failed : %s\n", extra);
458 else
459 __xmlRaiseError(schannel, channel, data,
460 NULL, NULL, XML_FROM_RELAXNGP,
461 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
462 NULL, NULL, 0, 0, "Memory allocation failed\n");
463}
464
465/**
466 * xmlRngVErrMemory:
467 * @ctxt: a Relax-NG validation context
468 * @extra: extra informations
469 *
470 * Handle a redefinition of attribute error
471 */
472static void
473xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
474{
475 xmlStructuredErrorFunc schannel = NULL;
476 xmlGenericErrorFunc channel = NULL;
477 void *data = NULL;
478
479 if (ctxt != NULL) {
480 if (ctxt->serror != NULL)
481 schannel = ctxt->serror;
482 else
483 channel = ctxt->error;
484 data = ctxt->userData;
485 ctxt->nbErrors++;
486 }
487 if (extra)
488 __xmlRaiseError(schannel, channel, data,
489 NULL, NULL, XML_FROM_RELAXNGV,
490 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
491 NULL, NULL, 0, 0,
492 "Memory allocation failed : %s\n", extra);
493 else
494 __xmlRaiseError(schannel, channel, data,
495 NULL, NULL, XML_FROM_RELAXNGV,
496 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
497 NULL, NULL, 0, 0, "Memory allocation failed\n");
498}
499
500/**
501 * xmlRngPErr:
502 * @ctxt: a Relax-NG parser context
503 * @node: the node raising the error
504 * @error: the error code
505 * @msg: message
506 * @str1: extra info
507 * @str2: extra info
508 *
509 * Handle a Relax NG Parsing error
510 */
511static void LIBXML_ATTR_FORMAT(4,0)
512xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
513 const char *msg, const xmlChar * str1, const xmlChar * str2)
514{
515 xmlStructuredErrorFunc schannel = NULL;
516 xmlGenericErrorFunc channel = NULL;
517 void *data = NULL;
518
519 if (ctxt != NULL) {
520 if (ctxt->serror != NULL)
521 schannel = ctxt->serror;
522 else
523 channel = ctxt->error;
524 data = ctxt->userData;
525 ctxt->nbErrors++;
526 }
527 __xmlRaiseError(schannel, channel, data,
528 NULL, node, XML_FROM_RELAXNGP,
529 error, XML_ERR_ERROR, NULL, 0,
530 (const char *) str1, (const char *) str2, NULL, 0, 0,
531 msg, str1, str2);
532}
533
534/**
535 * xmlRngVErr:
536 * @ctxt: a Relax-NG validation context
537 * @node: the node raising the error
538 * @error: the error code
539 * @msg: message
540 * @str1: extra info
541 * @str2: extra info
542 *
543 * Handle a Relax NG Validation error
544 */
545static void LIBXML_ATTR_FORMAT(4,0)
546xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
547 const char *msg, const xmlChar * str1, const xmlChar * str2)
548{
549 xmlStructuredErrorFunc schannel = NULL;
550 xmlGenericErrorFunc channel = NULL;
551 void *data = NULL;
552
553 if (ctxt != NULL) {
554 if (ctxt->serror != NULL)
555 schannel = ctxt->serror;
556 else
557 channel = ctxt->error;
558 data = ctxt->userData;
559 ctxt->nbErrors++;
560 }
561 __xmlRaiseError(schannel, channel, data,
562 NULL, node, XML_FROM_RELAXNGV,
563 error, XML_ERR_ERROR, NULL, 0,
564 (const char *) str1, (const char *) str2, NULL, 0, 0,
565 msg, str1, str2);
566}
567
568/************************************************************************
569 * *
570 * Preliminary type checking interfaces *
571 * *
572 ************************************************************************/
573
574/**
575 * xmlRelaxNGTypeHave:
576 * @data: data needed for the library
577 * @type: the type name
578 * @value: the value to check
579 *
580 * Function provided by a type library to check if a type is exported
581 *
582 * Returns 1 if yes, 0 if no and -1 in case of error.
583 */
584typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);
585
586/**
587 * xmlRelaxNGTypeCheck:
588 * @data: data needed for the library
589 * @type: the type name
590 * @value: the value to check
591 * @result: place to store the result if needed
592 *
593 * Function provided by a type library to check if a value match a type
594 *
595 * Returns 1 if yes, 0 if no and -1 in case of error.
596 */
597typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
598 const xmlChar * value, void **result,
599 xmlNodePtr node);
600
601/**
602 * xmlRelaxNGFacetCheck:
603 * @data: data needed for the library
604 * @type: the type name
605 * @facet: the facet name
606 * @val: the facet value
607 * @strval: the string value
608 * @value: the value to check
609 *
610 * Function provided by a type library to check a value facet
611 *
612 * Returns 1 if yes, 0 if no and -1 in case of error.
613 */
614typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
615 const xmlChar * facet,
616 const xmlChar * val,
617 const xmlChar * strval, void *value);
618
619/**
620 * xmlRelaxNGTypeFree:
621 * @data: data needed for the library
622 * @result: the value to free
623 *
624 * Function provided by a type library to free a returned result
625 */
626typedef void (*xmlRelaxNGTypeFree) (void *data, void *result);
627
628/**
629 * xmlRelaxNGTypeCompare:
630 * @data: data needed for the library
631 * @type: the type name
632 * @value1: the first value
633 * @value2: the second value
634 *
635 * Function provided by a type library to compare two values accordingly
636 * to a type.
637 *
638 * Returns 1 if yes, 0 if no and -1 in case of error.
639 */
640typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type,
641 const xmlChar * value1,
642 xmlNodePtr ctxt1,
643 void *comp1,
644 const xmlChar * value2,
645 xmlNodePtr ctxt2);
646typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary;
647typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr;
648struct _xmlRelaxNGTypeLibrary {
649 const xmlChar *namespace; /* the datatypeLibrary value */
650 void *data; /* data needed for the library */
651 xmlRelaxNGTypeHave have; /* the export function */
652 xmlRelaxNGTypeCheck check; /* the checking function */
653 xmlRelaxNGTypeCompare comp; /* the compare function */
654 xmlRelaxNGFacetCheck facet; /* the facet check function */
655 xmlRelaxNGTypeFree freef; /* the freeing function */
656};
657
658/************************************************************************
659 * *
660 * Allocation functions *
661 * *
662 ************************************************************************/
663static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
664static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
665static void xmlRelaxNGNormExtSpace(xmlChar * value);
666static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
667static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
668 ATTRIBUTE_UNUSED,
669 xmlRelaxNGValidStatePtr state1,
670 xmlRelaxNGValidStatePtr state2);
671static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
672 xmlRelaxNGValidStatePtr state);
673
674/**
675 * xmlRelaxNGFreeDocument:
676 * @docu: a document structure
677 *
678 * Deallocate a RelaxNG document structure.
679 */
680static void
681xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
682{
683 if (docu == NULL)
684 return;
685
686 if (docu->href != NULL)
687 xmlFree(docu->href);
688 if (docu->doc != NULL)
689 xmlFreeDoc(docu->doc);
690 if (docu->schema != NULL)
691 xmlRelaxNGFreeInnerSchema(docu->schema);
692 xmlFree(docu);
693}
694
695/**
696 * xmlRelaxNGFreeDocumentList:
697 * @docu: a list of document structure
698 *
699 * Deallocate a RelaxNG document structures.
700 */
701static void
702xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
703{
704 xmlRelaxNGDocumentPtr next;
705
706 while (docu != NULL) {
707 next = docu->next;
708 xmlRelaxNGFreeDocument(docu);
709 docu = next;
710 }
711}
712
713/**
714 * xmlRelaxNGFreeInclude:
715 * @incl: a include structure
716 *
717 * Deallocate a RelaxNG include structure.
718 */
719static void
720xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl)
721{
722 if (incl == NULL)
723 return;
724
725 if (incl->href != NULL)
726 xmlFree(incl->href);
727 if (incl->doc != NULL)
728 xmlFreeDoc(incl->doc);
729 if (incl->schema != NULL)
730 xmlRelaxNGFree(incl->schema);
731 xmlFree(incl);
732}
733
734/**
735 * xmlRelaxNGFreeIncludeList:
736 * @incl: a include structure list
737 *
738 * Deallocate a RelaxNG include structure.
739 */
740static void
741xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
742{
743 xmlRelaxNGIncludePtr next;
744
745 while (incl != NULL) {
746 next = incl->next;
747 xmlRelaxNGFreeInclude(incl);
748 incl = next;
749 }
750}
751
752/**
753 * xmlRelaxNGNewRelaxNG:
754 * @ctxt: a Relax-NG validation context (optional)
755 *
756 * Allocate a new RelaxNG structure.
757 *
758 * Returns the newly allocated structure or NULL in case or error
759 */
760static xmlRelaxNGPtr
761xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
762{
763 xmlRelaxNGPtr ret;
764
765 ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
766 if (ret == NULL) {
767 xmlRngPErrMemory(ctxt, NULL);
768 return (NULL);
769 }
770 memset(ret, 0, sizeof(xmlRelaxNG));
771
772 return (ret);
773}
774
775/**
776 * xmlRelaxNGFreeInnerSchema:
777 * @schema: a schema structure
778 *
779 * Deallocate a RelaxNG schema structure.
780 */
781static void
782xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema)
783{
784 if (schema == NULL)
785 return;
786
787 if (schema->doc != NULL)
788 xmlFreeDoc(schema->doc);
789 if (schema->defTab != NULL) {
790 int i;
791
792 for (i = 0; i < schema->defNr; i++)
793 xmlRelaxNGFreeDefine(schema->defTab[i]);
794 xmlFree(schema->defTab);
795 }
796
797 xmlFree(schema);
798}
799
800/**
801 * xmlRelaxNGFree:
802 * @schema: a schema structure
803 *
804 * Deallocate a RelaxNG structure.
805 */
806void
807xmlRelaxNGFree(xmlRelaxNGPtr schema)
808{
809 if (schema == NULL)
810 return;
811
812 if (schema->topgrammar != NULL)
813 xmlRelaxNGFreeGrammar(schema->topgrammar);
814 if (schema->doc != NULL)
815 xmlFreeDoc(schema->doc);
816 if (schema->documents != NULL)
817 xmlRelaxNGFreeDocumentList(schema->documents);
818 if (schema->includes != NULL)
819 xmlRelaxNGFreeIncludeList(schema->includes);
820 if (schema->defTab != NULL) {
821 int i;
822
823 for (i = 0; i < schema->defNr; i++)
824 xmlRelaxNGFreeDefine(schema->defTab[i]);
825 xmlFree(schema->defTab);
826 }
827
828 xmlFree(schema);
829}
830
831/**
832 * xmlRelaxNGNewGrammar:
833 * @ctxt: a Relax-NG validation context (optional)
834 *
835 * Allocate a new RelaxNG grammar.
836 *
837 * Returns the newly allocated structure or NULL in case or error
838 */
839static xmlRelaxNGGrammarPtr
840xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
841{
842 xmlRelaxNGGrammarPtr ret;
843
844 ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
845 if (ret == NULL) {
846 xmlRngPErrMemory(ctxt, NULL);
847 return (NULL);
848 }
849 memset(ret, 0, sizeof(xmlRelaxNGGrammar));
850
851 return (ret);
852}
853
854/**
855 * xmlRelaxNGFreeGrammar:
856 * @grammar: a grammar structure
857 *
858 * Deallocate a RelaxNG grammar structure.
859 */
860static void
861xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
862{
863 if (grammar == NULL)
864 return;
865
866 if (grammar->children != NULL) {
867 xmlRelaxNGFreeGrammar(grammar->children);
868 }
869 if (grammar->next != NULL) {
870 xmlRelaxNGFreeGrammar(grammar->next);
871 }
872 if (grammar->refs != NULL) {
873 xmlHashFree(grammar->refs, NULL);
874 }
875 if (grammar->defs != NULL) {
876 xmlHashFree(grammar->defs, NULL);
877 }
878
879 xmlFree(grammar);
880}
881
882/**
883 * xmlRelaxNGNewDefine:
884 * @ctxt: a Relax-NG validation context
885 * @node: the node in the input document.
886 *
887 * Allocate a new RelaxNG define.
888 *
889 * Returns the newly allocated structure or NULL in case or error
890 */
891static xmlRelaxNGDefinePtr
892xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
893{
894 xmlRelaxNGDefinePtr ret;
895
896 if (ctxt->defMax == 0) {
897 ctxt->defMax = 16;
898 ctxt->defNr = 0;
899 ctxt->defTab = (xmlRelaxNGDefinePtr *)
900 xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
901 if (ctxt->defTab == NULL) {
902 xmlRngPErrMemory(ctxt, "allocating define\n");
903 return (NULL);
904 }
905 } else if (ctxt->defMax <= ctxt->defNr) {
906 xmlRelaxNGDefinePtr *tmp;
907
908 ctxt->defMax *= 2;
909 tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
910 ctxt->defMax *
911 sizeof
912 (xmlRelaxNGDefinePtr));
913 if (tmp == NULL) {
914 xmlRngPErrMemory(ctxt, "allocating define\n");
915 return (NULL);
916 }
917 ctxt->defTab = tmp;
918 }
919 ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine));
920 if (ret == NULL) {
921 xmlRngPErrMemory(ctxt, "allocating define\n");
922 return (NULL);
923 }
924 memset(ret, 0, sizeof(xmlRelaxNGDefine));
925 ctxt->defTab[ctxt->defNr++] = ret;
926 ret->node = node;
927 ret->depth = -1;
928 return (ret);
929}
930
931/**
932 * xmlRelaxNGFreePartition:
933 * @partitions: a partition set structure
934 *
935 * Deallocate RelaxNG partition set structures.
936 */
937static void
938xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions)
939{
940 xmlRelaxNGInterleaveGroupPtr group;
941 int j;
942
943 if (partitions != NULL) {
944 if (partitions->groups != NULL) {
945 for (j = 0; j < partitions->nbgroups; j++) {
946 group = partitions->groups[j];
947 if (group != NULL) {
948 if (group->defs != NULL)
949 xmlFree(group->defs);
950 if (group->attrs != NULL)
951 xmlFree(group->attrs);
952 xmlFree(group);
953 }
954 }
955 xmlFree(partitions->groups);
956 }
957 if (partitions->triage != NULL) {
958 xmlHashFree(partitions->triage, NULL);
959 }
960 xmlFree(partitions);
961 }
962}
963
964/**
965 * xmlRelaxNGFreeDefine:
966 * @define: a define structure
967 *
968 * Deallocate a RelaxNG define structure.
969 */
970static void
971xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define)
972{
973 if (define == NULL)
974 return;
975
976 if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) {
977 xmlRelaxNGTypeLibraryPtr lib;
978
979 lib = (xmlRelaxNGTypeLibraryPtr) define->data;
980 if ((lib != NULL) && (lib->freef != NULL))
981 lib->freef(lib->data, (void *) define->attrs);
982 }
983 if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE))
984 xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data);
985 if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE))
986 xmlHashFree((xmlHashTablePtr) define->data, NULL);
987 if (define->name != NULL)
988 xmlFree(define->name);
989 if (define->ns != NULL)
990 xmlFree(define->ns);
991 if (define->value != NULL)
992 xmlFree(define->value);
993 if (define->contModel != NULL)
994 xmlRegFreeRegexp(define->contModel);
995 xmlFree(define);
996}
997
998/**
999 * xmlRelaxNGNewStates:
1000 * @ctxt: a Relax-NG validation context
1001 * @size: the default size for the container
1002 *
1003 * Allocate a new RelaxNG validation state container
1004 *
1005 * Returns the newly allocated structure or NULL in case or error
1006 */
1007static xmlRelaxNGStatesPtr
1008xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
1009{
1010 xmlRelaxNGStatesPtr ret;
1011
1012 if ((ctxt != NULL) &&
1013 (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) {
1014 ctxt->freeStatesNr--;
1015 ret = ctxt->freeStates[ctxt->freeStatesNr];
1016 ret->nbState = 0;
1017 return (ret);
1018 }
1019 if (size < 16)
1020 size = 16;
1021
1022 ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
1023 (size -
1024 1) *
1025 sizeof(xmlRelaxNGValidStatePtr));
1026 if (ret == NULL) {
1027 xmlRngVErrMemory(ctxt, "allocating states\n");
1028 return (NULL);
1029 }
1030 ret->nbState = 0;
1031 ret->maxState = size;
1032 ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
1033 sizeof
1034 (xmlRelaxNGValidStatePtr));
1035 if (ret->tabState == NULL) {
1036 xmlRngVErrMemory(ctxt, "allocating states\n");
1037 xmlFree(ret);
1038 return (NULL);
1039 }
1040 return (ret);
1041}
1042
1043/**
1044 * xmlRelaxNGAddStateUniq:
1045 * @ctxt: a Relax-NG validation context
1046 * @states: the states container
1047 * @state: the validation state
1048 *
1049 * Add a RelaxNG validation state to the container without checking
1050 * for unicity.
1051 *
1052 * Return 1 in case of success and 0 if this is a duplicate and -1 on error
1053 */
1054static int
1055xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
1056 xmlRelaxNGStatesPtr states,
1057 xmlRelaxNGValidStatePtr state)
1058{
1059 if (state == NULL) {
1060 return (-1);
1061 }
1062 if (states->nbState >= states->maxState) {
1063 xmlRelaxNGValidStatePtr *tmp;
1064 int size;
1065
1066 size = states->maxState * 2;
1067 tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
1068 (size) *
1069 sizeof
1070 (xmlRelaxNGValidStatePtr));
1071 if (tmp == NULL) {
1072 xmlRngVErrMemory(ctxt, "adding states\n");
1073 return (-1);
1074 }
1075 states->tabState = tmp;
1076 states->maxState = size;
1077 }
1078 states->tabState[states->nbState++] = state;
1079 return (1);
1080}
1081
1082/**
1083 * xmlRelaxNGAddState:
1084 * @ctxt: a Relax-NG validation context
1085 * @states: the states container
1086 * @state: the validation state
1087 *
1088 * Add a RelaxNG validation state to the container
1089 *
1090 * Return 1 in case of success and 0 if this is a duplicate and -1 on error
1091 */
1092static int
1093xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
1094 xmlRelaxNGStatesPtr states,
1095 xmlRelaxNGValidStatePtr state)
1096{
1097 int i;
1098
1099 if (state == NULL || states == NULL) {
1100 return (-1);
1101 }
1102 if (states->nbState >= states->maxState) {
1103 xmlRelaxNGValidStatePtr *tmp;
1104 int size;
1105
1106 size = states->maxState * 2;
1107 tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
1108 (size) *
1109 sizeof
1110 (xmlRelaxNGValidStatePtr));
1111 if (tmp == NULL) {
1112 xmlRngVErrMemory(ctxt, "adding states\n");
1113 return (-1);
1114 }
1115 states->tabState = tmp;
1116 states->maxState = size;
1117 }
1118 for (i = 0; i < states->nbState; i++) {
1119 if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
1120 xmlRelaxNGFreeValidState(ctxt, state);
1121 return (0);
1122 }
1123 }
1124 states->tabState[states->nbState++] = state;
1125 return (1);
1126}
1127
1128/**
1129 * xmlRelaxNGFreeStates:
1130 * @ctxt: a Relax-NG validation context
1131 * @states: teh container
1132 *
1133 * Free a RelaxNG validation state container
1134 */
1135static void
1136xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
1137 xmlRelaxNGStatesPtr states)
1138{
1139 if (states == NULL)
1140 return;
1141 if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
1142 ctxt->freeStatesMax = 40;
1143 ctxt->freeStatesNr = 0;
1144 ctxt->freeStates = (xmlRelaxNGStatesPtr *)
1145 xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
1146 if (ctxt->freeStates == NULL) {
1147 xmlRngVErrMemory(ctxt, "storing states\n");
1148 }
1149 } else if ((ctxt != NULL)
1150 && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
1151 xmlRelaxNGStatesPtr *tmp;
1152
1153 tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
1154 2 * ctxt->freeStatesMax *
1155 sizeof
1156 (xmlRelaxNGStatesPtr));
1157 if (tmp == NULL) {
1158 xmlRngVErrMemory(ctxt, "storing states\n");
1159 xmlFree(states->tabState);
1160 xmlFree(states);
1161 return;
1162 }
1163 ctxt->freeStates = tmp;
1164 ctxt->freeStatesMax *= 2;
1165 }
1166 if ((ctxt == NULL) || (ctxt->freeStates == NULL)) {
1167 xmlFree(states->tabState);
1168 xmlFree(states);
1169 } else {
1170 ctxt->freeStates[ctxt->freeStatesNr++] = states;
1171 }
1172}
1173
1174/**
1175 * xmlRelaxNGNewValidState:
1176 * @ctxt: a Relax-NG validation context
1177 * @node: the current node or NULL for the document
1178 *
1179 * Allocate a new RelaxNG validation state
1180 *
1181 * Returns the newly allocated structure or NULL in case or error
1182 */
1183static xmlRelaxNGValidStatePtr
1184xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
1185{
1186 xmlRelaxNGValidStatePtr ret;
1187 xmlAttrPtr attr;
1188 xmlAttrPtr attrs[MAX_ATTR];
1189 int nbAttrs = 0;
1190 xmlNodePtr root = NULL;
1191
1192 if (node == NULL) {
1193 root = xmlDocGetRootElement(ctxt->doc);
1194 if (root == NULL)
1195 return (NULL);
1196 } else {
1197 attr = node->properties;
1198 while (attr != NULL) {
1199 if (nbAttrs < MAX_ATTR)
1200 attrs[nbAttrs++] = attr;
1201 else
1202 nbAttrs++;
1203 attr = attr->next;
1204 }
1205 }
1206 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1207 ctxt->freeState->nbState--;
1208 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1209 } else {
1210 ret =
1211 (xmlRelaxNGValidStatePtr)
1212 xmlMalloc(sizeof(xmlRelaxNGValidState));
1213 if (ret == NULL) {
1214 xmlRngVErrMemory(ctxt, "allocating states\n");
1215 return (NULL);
1216 }
1217 memset(ret, 0, sizeof(xmlRelaxNGValidState));
1218 }
1219 ret->value = NULL;
1220 ret->endvalue = NULL;
1221 if (node == NULL) {
1222 ret->node = (xmlNodePtr) ctxt->doc;
1223 ret->seq = root;
1224 } else {
1225 ret->node = node;
1226 ret->seq = node->children;
1227 }
1228 ret->nbAttrs = 0;
1229 if (nbAttrs > 0) {
1230 if (ret->attrs == NULL) {
1231 if (nbAttrs < 4)
1232 ret->maxAttrs = 4;
1233 else
1234 ret->maxAttrs = nbAttrs;
1235 ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
1236 sizeof(xmlAttrPtr));
1237 if (ret->attrs == NULL) {
1238 xmlRngVErrMemory(ctxt, "allocating states\n");
1239 return (ret);
1240 }
1241 } else if (ret->maxAttrs < nbAttrs) {
1242 xmlAttrPtr *tmp;
1243
1244 tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs *
1245 sizeof(xmlAttrPtr));
1246 if (tmp == NULL) {
1247 xmlRngVErrMemory(ctxt, "allocating states\n");
1248 return (ret);
1249 }
1250 ret->attrs = tmp;
1251 ret->maxAttrs = nbAttrs;
1252 }
1253 ret->nbAttrs = nbAttrs;
1254 if (nbAttrs < MAX_ATTR) {
1255 memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs);
1256 } else {
1257 attr = node->properties;
1258 nbAttrs = 0;
1259 while (attr != NULL) {
1260 ret->attrs[nbAttrs++] = attr;
1261 attr = attr->next;
1262 }
1263 }
1264 }
1265 ret->nbAttrLeft = ret->nbAttrs;
1266 return (ret);
1267}
1268
1269/**
1270 * xmlRelaxNGCopyValidState:
1271 * @ctxt: a Relax-NG validation context
1272 * @state: a validation state
1273 *
1274 * Copy the validation state
1275 *
1276 * Returns the newly allocated structure or NULL in case or error
1277 */
1278static xmlRelaxNGValidStatePtr
1279xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
1280 xmlRelaxNGValidStatePtr state)
1281{
1282 xmlRelaxNGValidStatePtr ret;
1283 unsigned int maxAttrs;
1284 xmlAttrPtr *attrs;
1285
1286 if (state == NULL)
1287 return (NULL);
1288 if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
1289 ctxt->freeState->nbState--;
1290 ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
1291 } else {
1292 ret =
1293 (xmlRelaxNGValidStatePtr)
1294 xmlMalloc(sizeof(xmlRelaxNGValidState));
1295 if (ret == NULL) {
1296 xmlRngVErrMemory(ctxt, "allocating states\n");
1297 return (NULL);
1298 }
1299 memset(ret, 0, sizeof(xmlRelaxNGValidState));
1300 }
1301 attrs = ret->attrs;
1302 maxAttrs = ret->maxAttrs;
1303 memcpy(ret, state, sizeof(xmlRelaxNGValidState));
1304 ret->attrs = attrs;
1305 ret->maxAttrs = maxAttrs;
1306 if (state->nbAttrs > 0) {
1307 if (ret->attrs == NULL) {
1308 ret->maxAttrs = state->maxAttrs;
1309 ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
1310 sizeof(xmlAttrPtr));
1311 if (ret->attrs == NULL) {
1312 xmlRngVErrMemory(ctxt, "allocating states\n");
1313 ret->nbAttrs = 0;
1314 return (ret);
1315 }
1316 } else if (ret->maxAttrs < state->nbAttrs) {
1317 xmlAttrPtr *tmp;
1318
1319 tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs *
1320 sizeof(xmlAttrPtr));
1321 if (tmp == NULL) {
1322 xmlRngVErrMemory(ctxt, "allocating states\n");
1323 ret->nbAttrs = 0;
1324 return (ret);
1325 }
1326 ret->maxAttrs = state->maxAttrs;
1327 ret->attrs = tmp;
1328 }
1329 memcpy(ret->attrs, state->attrs,
1330 state->nbAttrs * sizeof(xmlAttrPtr));
1331 }
1332 return (ret);
1333}
1334
1335/**
1336 * xmlRelaxNGEqualValidState:
1337 * @ctxt: a Relax-NG validation context
1338 * @state1: a validation state
1339 * @state2: a validation state
1340 *
1341 * Compare the validation states for equality
1342 *
1343 * Returns 1 if equald, 0 otherwise
1344 */
1345static int
1346xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
1347 xmlRelaxNGValidStatePtr state1,
1348 xmlRelaxNGValidStatePtr state2)
1349{
1350 int i;
1351
1352 if ((state1 == NULL) || (state2 == NULL))
1353 return (0);
1354 if (state1 == state2)
1355 return (1);
1356 if (state1->node != state2->node)
1357 return (0);
1358 if (state1->seq != state2->seq)
1359 return (0);
1360 if (state1->nbAttrLeft != state2->nbAttrLeft)
1361 return (0);
1362 if (state1->nbAttrs != state2->nbAttrs)
1363 return (0);
1364 if (state1->endvalue != state2->endvalue)
1365 return (0);
1366 if ((state1->value != state2->value) &&
1367 (!xmlStrEqual(state1->value, state2->value)))
1368 return (0);
1369 for (i = 0; i < state1->nbAttrs; i++) {
1370 if (state1->attrs[i] != state2->attrs[i])
1371 return (0);
1372 }
1373 return (1);
1374}
1375
1376/**
1377 * xmlRelaxNGFreeValidState:
1378 * @state: a validation state structure
1379 *
1380 * Deallocate a RelaxNG validation state structure.
1381 */
1382static void
1383xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
1384 xmlRelaxNGValidStatePtr state)
1385{
1386 if (state == NULL)
1387 return;
1388
1389 if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
1390 ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
1391 }
1392 if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
1393 if (state->attrs != NULL)
1394 xmlFree(state->attrs);
1395 xmlFree(state);
1396 } else {
1397 xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
1398 }
1399}
1400
1401/************************************************************************
1402 * *
1403 * Semi internal functions *
1404 * *
1405 ************************************************************************/
1406
1407/**
1408 * xmlRelaxParserSetFlag:
1409 * @ctxt: a RelaxNG parser context
1410 * @flags: a set of flags values
1411 *
1412 * Semi private function used to pass informations to a parser context
1413 * which are a combination of xmlRelaxNGParserFlag .
1414 *
1415 * Returns 0 if success and -1 in case of error
1416 */
1417int
1418xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
1419{
1420 if (ctxt == NULL) return(-1);
1421 if (flags & XML_RELAXNGP_FREE_DOC) {
1422 ctxt->crng |= XML_RELAXNGP_FREE_DOC;
1423 flags -= XML_RELAXNGP_FREE_DOC;
1424 }
1425 if (flags & XML_RELAXNGP_CRNG) {
1426 ctxt->crng |= XML_RELAXNGP_CRNG;
1427 flags -= XML_RELAXNGP_CRNG;
1428 }
1429 if (flags != 0) return(-1);
1430 return(0);
1431}
1432
1433/************************************************************************
1434 * *
1435 * Document functions *
1436 * *
1437 ************************************************************************/
1438static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
1439 xmlDocPtr doc);
1440
1441/**
1442 * xmlRelaxNGIncludePush:
1443 * @ctxt: the parser context
1444 * @value: the element doc
1445 *
1446 * Pushes a new include on top of the include stack
1447 *
1448 * Returns 0 in case of error, the index in the stack otherwise
1449 */
1450static int
1451xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
1452 xmlRelaxNGIncludePtr value)
1453{
1454 if (ctxt->incTab == NULL) {
1455 ctxt->incMax = 4;
1456 ctxt->incNr = 0;
1457 ctxt->incTab =
1458 (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
1459 sizeof(ctxt->incTab[0]));
1460 if (ctxt->incTab == NULL) {
1461 xmlRngPErrMemory(ctxt, "allocating include\n");
1462 return (0);
1463 }
1464 }
1465 if (ctxt->incNr >= ctxt->incMax) {
1466 ctxt->incMax *= 2;
1467 ctxt->incTab =
1468 (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
1469 ctxt->incMax *
1470 sizeof(ctxt->incTab[0]));
1471 if (ctxt->incTab == NULL) {
1472 xmlRngPErrMemory(ctxt, "allocating include\n");
1473 return (0);
1474 }
1475 }
1476 ctxt->incTab[ctxt->incNr] = value;
1477 ctxt->inc = value;
1478 return (ctxt->incNr++);
1479}
1480
1481/**
1482 * xmlRelaxNGIncludePop:
1483 * @ctxt: the parser context
1484 *
1485 * Pops the top include from the include stack
1486 *
1487 * Returns the include just removed
1488 */
1489static xmlRelaxNGIncludePtr
1490xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
1491{
1492 xmlRelaxNGIncludePtr ret;
1493
1494 if (ctxt->incNr <= 0)
1495 return (NULL);
1496 ctxt->incNr--;
1497 if (ctxt->incNr > 0)
1498 ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
1499 else
1500 ctxt->inc = NULL;
1501 ret = ctxt->incTab[ctxt->incNr];
1502 ctxt->incTab[ctxt->incNr] = NULL;
1503 return (ret);
1504}
1505
1506/**
1507 * xmlRelaxNGRemoveRedefine:
1508 * @ctxt: the parser context
1509 * @URL: the normalized URL
1510 * @target: the included target
1511 * @name: the define name to eliminate
1512 *
1513 * Applies the elimination algorithm of 4.7
1514 *
1515 * Returns 0 in case of error, 1 in case of success.
1516 */
1517static int
1518xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
1519 const xmlChar * URL ATTRIBUTE_UNUSED,
1520 xmlNodePtr target, const xmlChar * name)
1521{
1522 int found = 0;
1523 xmlNodePtr tmp, tmp2;
1524 xmlChar *name2;
1525
1526#ifdef DEBUG_INCLUDE
1527 if (name == NULL)
1528 xmlGenericError(xmlGenericErrorContext,
1529 "Elimination of <include> start from %s\n", URL);
1530 else
1531 xmlGenericError(xmlGenericErrorContext,
1532 "Elimination of <include> define %s from %s\n",
1533 name, URL);
1534#endif
1535 tmp = target;
1536 while (tmp != NULL) {
1537 tmp2 = tmp->next;
1538 if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) {
1539 found = 1;
1540 xmlUnlinkNode(tmp);
1541 xmlFreeNode(tmp);
1542 } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) {
1543 name2 = xmlGetProp(tmp, BAD_CAST "name");
1544 xmlRelaxNGNormExtSpace(name2);
1545 if (name2 != NULL) {
1546 if (xmlStrEqual(name, name2)) {
1547 found = 1;
1548 xmlUnlinkNode(tmp);
1549 xmlFreeNode(tmp);
1550 }
1551 xmlFree(name2);
1552 }
1553 } else if (IS_RELAXNG(tmp, "include")) {
1554 xmlChar *href = NULL;
1555 xmlRelaxNGDocumentPtr inc = tmp->psvi;
1556
1557 if ((inc != NULL) && (inc->doc != NULL) &&
1558 (inc->doc->children != NULL)) {
1559
1560 if (xmlStrEqual
1561 (inc->doc->children->name, BAD_CAST "grammar")) {
1562#ifdef DEBUG_INCLUDE
1563 href = xmlGetProp(tmp, BAD_CAST "href");
1564#endif
1565 if (xmlRelaxNGRemoveRedefine(ctxt, href,
1566 xmlDocGetRootElement(inc->doc)->children,
1567 name) == 1) {
1568 found = 1;
1569 }
1570#ifdef DEBUG_INCLUDE
1571 if (href != NULL)
1572 xmlFree(href);
1573#endif
1574 }
1575 }
1576 }
1577 tmp = tmp2;
1578 }
1579 return (found);
1580}
1581
1582/**
1583 * xmlRelaxNGLoadInclude:
1584 * @ctxt: the parser context
1585 * @URL: the normalized URL
1586 * @node: the include node.
1587 * @ns: the namespace passed from the context.
1588 *
1589 * First lookup if the document is already loaded into the parser context,
1590 * check against recursion. If not found the resource is loaded and
1591 * the content is preprocessed before being returned back to the caller.
1592 *
1593 * Returns the xmlRelaxNGIncludePtr or NULL in case of error
1594 */
1595static xmlRelaxNGIncludePtr
1596xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
1597 xmlNodePtr node, const xmlChar * ns)
1598{
1599 xmlRelaxNGIncludePtr ret = NULL;
1600 xmlDocPtr doc;
1601 int i;
1602 xmlNodePtr root, cur;
1603
1604#ifdef DEBUG_INCLUDE
1605 xmlGenericError(xmlGenericErrorContext,
1606 "xmlRelaxNGLoadInclude(%s)\n", URL);
1607#endif
1608
1609 /*
1610 * check against recursion in the stack
1611 */
1612 for (i = 0; i < ctxt->incNr; i++) {
1613 if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
1614 xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
1615 "Detected an Include recursion for %s\n", URL,
1616 NULL);
1617 return (NULL);
1618 }
1619 }
1620
1621 /*
1622 * load the document
1623 */
1624 doc = xmlReadFile((const char *) URL,NULL,0);
1625 if (doc == NULL) {
1626 xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
1627 "xmlRelaxNG: could not load %s\n", URL, NULL);
1628 return (NULL);
1629 }
1630#ifdef DEBUG_INCLUDE
1631 xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
1632#endif
1633
1634 /*
1635 * Allocate the document structures and register it first.
1636 */
1637 ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
1638 if (ret == NULL) {
1639 xmlRngPErrMemory(ctxt, "allocating include\n");
1640 xmlFreeDoc(doc);
1641 return (NULL);
1642 }
1643 memset(ret, 0, sizeof(xmlRelaxNGInclude));
1644 ret->doc = doc;
1645 ret->href = xmlStrdup(URL);
1646 ret->next = ctxt->includes;
1647 ctxt->includes = ret;
1648
1649 /*
1650 * transmit the ns if needed
1651 */
1652 if (ns != NULL) {
1653 root = xmlDocGetRootElement(doc);
1654 if (root != NULL) {
1655 if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
1656 xmlSetProp(root, BAD_CAST "ns", ns);
1657 }
1658 }
1659 }
1660
1661 /*
1662 * push it on the stack
1663 */
1664 xmlRelaxNGIncludePush(ctxt, ret);
1665
1666 /*
1667 * Some preprocessing of the document content, this include recursing
1668 * in the include stack.
1669 */
1670#ifdef DEBUG_INCLUDE
1671 xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
1672#endif
1673
1674 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
1675 if (doc == NULL) {
1676 ctxt->inc = NULL;
1677 return (NULL);
1678 }
1679
1680 /*
1681 * Pop up the include from the stack
1682 */
1683 xmlRelaxNGIncludePop(ctxt);
1684
1685#ifdef DEBUG_INCLUDE
1686 xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
1687#endif
1688 /*
1689 * Check that the top element is a grammar
1690 */
1691 root = xmlDocGetRootElement(doc);
1692 if (root == NULL) {
1693 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
1694 "xmlRelaxNG: included document is empty %s\n", URL,
1695 NULL);
1696 return (NULL);
1697 }
1698 if (!IS_RELAXNG(root, "grammar")) {
1699 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
1700 "xmlRelaxNG: included document %s root is not a grammar\n",
1701 URL, NULL);
1702 return (NULL);
1703 }
1704
1705 /*
1706 * Elimination of redefined rules in the include.
1707 */
1708 cur = node->children;
1709 while (cur != NULL) {
1710 if (IS_RELAXNG(cur, "start")) {
1711 int found = 0;
1712
1713 found =
1714 xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
1715 if (!found) {
1716 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
1717 "xmlRelaxNG: include %s has a start but not the included grammar\n",
1718 URL, NULL);
1719 }
1720 } else if (IS_RELAXNG(cur, "define")) {
1721 xmlChar *name;
1722
1723 name = xmlGetProp(cur, BAD_CAST "name");
1724 if (name == NULL) {
1725 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
1726 "xmlRelaxNG: include %s has define without name\n",
1727 URL, NULL);
1728 } else {
1729 int found;
1730
1731 xmlRelaxNGNormExtSpace(name);
1732 found = xmlRelaxNGRemoveRedefine(ctxt, URL,
1733 root->children, name);
1734 if (!found) {
1735 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
1736 "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
1737 URL, name);
1738 }
1739 xmlFree(name);
1740 }
1741 }
1742 cur = cur->next;
1743 }
1744
1745
1746 return (ret);
1747}
1748
1749/**
1750 * xmlRelaxNGValidErrorPush:
1751 * @ctxt: the validation context
1752 * @err: the error code
1753 * @arg1: the first string argument
1754 * @arg2: the second string argument
1755 * @dup: arg need to be duplicated
1756 *
1757 * Pushes a new error on top of the error stack
1758 *
1759 * Returns 0 in case of error, the index in the stack otherwise
1760 */
1761static int
1762xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
1763 xmlRelaxNGValidErr err, const xmlChar * arg1,
1764 const xmlChar * arg2, int dup)
1765{
1766 xmlRelaxNGValidErrorPtr cur;
1767
1768#ifdef DEBUG_ERROR
1769 xmlGenericError(xmlGenericErrorContext,
1770 "Pushing error %d at %d on stack\n", err, ctxt->errNr);
1771#endif
1772 if (ctxt->errTab == NULL) {
1773 ctxt->errMax = 8;
1774 ctxt->errNr = 0;
1775 ctxt->errTab =
1776 (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
1777 sizeof
1778 (xmlRelaxNGValidError));
1779 if (ctxt->errTab == NULL) {
1780 xmlRngVErrMemory(ctxt, "pushing error\n");
1781 return (0);
1782 }
1783 ctxt->err = NULL;
1784 }
1785 if (ctxt->errNr >= ctxt->errMax) {
1786 ctxt->errMax *= 2;
1787 ctxt->errTab =
1788 (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
1789 ctxt->errMax *
1790 sizeof
1791 (xmlRelaxNGValidError));
1792 if (ctxt->errTab == NULL) {
1793 xmlRngVErrMemory(ctxt, "pushing error\n");
1794 return (0);
1795 }
1796 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1797 }
1798 if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
1799 (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
1800 return (ctxt->errNr);
1801 cur = &ctxt->errTab[ctxt->errNr];
1802 cur->err = err;
1803 if (dup) {
1804 cur->arg1 = xmlStrdup(arg1);
1805 cur->arg2 = xmlStrdup(arg2);
1806 cur->flags = ERROR_IS_DUP;
1807 } else {
1808 cur->arg1 = arg1;
1809 cur->arg2 = arg2;
1810 cur->flags = 0;
1811 }
1812 if (ctxt->state != NULL) {
1813 cur->node = ctxt->state->node;
1814 cur->seq = ctxt->state->seq;
1815 } else {
1816 cur->node = NULL;
1817 cur->seq = NULL;
1818 }
1819 ctxt->err = cur;
1820 return (ctxt->errNr++);
1821}
1822
1823/**
1824 * xmlRelaxNGValidErrorPop:
1825 * @ctxt: the validation context
1826 *
1827 * Pops the top error from the error stack
1828 */
1829static void
1830xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
1831{
1832 xmlRelaxNGValidErrorPtr cur;
1833
1834 if (ctxt->errNr <= 0) {
1835 ctxt->err = NULL;
1836 return;
1837 }
1838 ctxt->errNr--;
1839 if (ctxt->errNr > 0)
1840 ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
1841 else
1842 ctxt->err = NULL;
1843 cur = &ctxt->errTab[ctxt->errNr];
1844 if (cur->flags & ERROR_IS_DUP) {
1845 if (cur->arg1 != NULL)
1846 xmlFree((xmlChar *) cur->arg1);
1847 cur->arg1 = NULL;
1848 if (cur->arg2 != NULL)
1849 xmlFree((xmlChar *) cur->arg2);
1850 cur->arg2 = NULL;
1851 cur->flags = 0;
1852 }
1853}
1854
1855/**
1856 * xmlRelaxNGDocumentPush:
1857 * @ctxt: the parser context
1858 * @value: the element doc
1859 *
1860 * Pushes a new doc on top of the doc stack
1861 *
1862 * Returns 0 in case of error, the index in the stack otherwise
1863 */
1864static int
1865xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
1866 xmlRelaxNGDocumentPtr value)
1867{
1868 if (ctxt->docTab == NULL) {
1869 ctxt->docMax = 4;
1870 ctxt->docNr = 0;
1871 ctxt->docTab =
1872 (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
1873 sizeof(ctxt->docTab[0]));
1874 if (ctxt->docTab == NULL) {
1875 xmlRngPErrMemory(ctxt, "adding document\n");
1876 return (0);
1877 }
1878 }
1879 if (ctxt->docNr >= ctxt->docMax) {
1880 ctxt->docMax *= 2;
1881 ctxt->docTab =
1882 (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
1883 ctxt->docMax *
1884 sizeof(ctxt->docTab[0]));
1885 if (ctxt->docTab == NULL) {
1886 xmlRngPErrMemory(ctxt, "adding document\n");
1887 return (0);
1888 }
1889 }
1890 ctxt->docTab[ctxt->docNr] = value;
1891 ctxt->doc = value;
1892 return (ctxt->docNr++);
1893}
1894
1895/**
1896 * xmlRelaxNGDocumentPop:
1897 * @ctxt: the parser context
1898 *
1899 * Pops the top doc from the doc stack
1900 *
1901 * Returns the doc just removed
1902 */
1903static xmlRelaxNGDocumentPtr
1904xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
1905{
1906 xmlRelaxNGDocumentPtr ret;
1907
1908 if (ctxt->docNr <= 0)
1909 return (NULL);
1910 ctxt->docNr--;
1911 if (ctxt->docNr > 0)
1912 ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
1913 else
1914 ctxt->doc = NULL;
1915 ret = ctxt->docTab[ctxt->docNr];
1916 ctxt->docTab[ctxt->docNr] = NULL;
1917 return (ret);
1918}
1919
1920/**
1921 * xmlRelaxNGLoadExternalRef:
1922 * @ctxt: the parser context
1923 * @URL: the normalized URL
1924 * @ns: the inherited ns if any
1925 *
1926 * First lookup if the document is already loaded into the parser context,
1927 * check against recursion. If not found the resource is loaded and
1928 * the content is preprocessed before being returned back to the caller.
1929 *
1930 * Returns the xmlRelaxNGDocumentPtr or NULL in case of error
1931 */
1932static xmlRelaxNGDocumentPtr
1933xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
1934 const xmlChar * URL, const xmlChar * ns)
1935{
1936 xmlRelaxNGDocumentPtr ret = NULL;
1937 xmlDocPtr doc;
1938 xmlNodePtr root;
1939 int i;
1940
1941 /*
1942 * check against recursion in the stack
1943 */
1944 for (i = 0; i < ctxt->docNr; i++) {
1945 if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
1946 xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
1947 "Detected an externalRef recursion for %s\n", URL,
1948 NULL);
1949 return (NULL);
1950 }
1951 }
1952
1953 /*
1954 * load the document
1955 */
1956 doc = xmlReadFile((const char *) URL,NULL,0);
1957 if (doc == NULL) {
1958 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
1959 "xmlRelaxNG: could not load %s\n", URL, NULL);
1960 return (NULL);
1961 }
1962
1963 /*
1964 * Allocate the document structures and register it first.
1965 */
1966 ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
1967 if (ret == NULL) {
1968 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
1969 "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
1970 xmlFreeDoc(doc);
1971 return (NULL);
1972 }
1973 memset(ret, 0, sizeof(xmlRelaxNGDocument));
1974 ret->doc = doc;
1975 ret->href = xmlStrdup(URL);
1976 ret->next = ctxt->documents;
1977 ret->externalRef = 1;
1978 ctxt->documents = ret;
1979
1980 /*
1981 * transmit the ns if needed
1982 */
1983 if (ns != NULL) {
1984 root = xmlDocGetRootElement(doc);
1985 if (root != NULL) {
1986 if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
1987 xmlSetProp(root, BAD_CAST "ns", ns);
1988 }
1989 }
1990 }
1991
1992 /*
1993 * push it on the stack and register it in the hash table
1994 */
1995 xmlRelaxNGDocumentPush(ctxt, ret);
1996
1997 /*
1998 * Some preprocessing of the document content
1999 */
2000 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
2001 if (doc == NULL) {
2002 ctxt->doc = NULL;
2003 return (NULL);
2004 }
2005
2006 xmlRelaxNGDocumentPop(ctxt);
2007
2008 return (ret);
2009}
2010
2011/************************************************************************
2012 * *
2013 * Error functions *
2014 * *
2015 ************************************************************************/
2016
2017#define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
2018#define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
2019#define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
2020#define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
2021#define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
2022
2023static const char *
2024xmlRelaxNGDefName(xmlRelaxNGDefinePtr def)
2025{
2026 if (def == NULL)
2027 return ("none");
2028 switch (def->type) {
2029 case XML_RELAXNG_EMPTY:
2030 return ("empty");
2031 case XML_RELAXNG_NOT_ALLOWED:
2032 return ("notAllowed");
2033 case XML_RELAXNG_EXCEPT:
2034 return ("except");
2035 case XML_RELAXNG_TEXT:
2036 return ("text");
2037 case XML_RELAXNG_ELEMENT:
2038 return ("element");
2039 case XML_RELAXNG_DATATYPE:
2040 return ("datatype");
2041 case XML_RELAXNG_VALUE:
2042 return ("value");
2043 case XML_RELAXNG_LIST:
2044 return ("list");
2045 case XML_RELAXNG_ATTRIBUTE:
2046 return ("attribute");
2047 case XML_RELAXNG_DEF:
2048 return ("def");
2049 case XML_RELAXNG_REF:
2050 return ("ref");
2051 case XML_RELAXNG_EXTERNALREF:
2052 return ("externalRef");
2053 case XML_RELAXNG_PARENTREF:
2054 return ("parentRef");
2055 case XML_RELAXNG_OPTIONAL:
2056 return ("optional");
2057 case XML_RELAXNG_ZEROORMORE:
2058 return ("zeroOrMore");
2059 case XML_RELAXNG_ONEORMORE:
2060 return ("oneOrMore");
2061 case XML_RELAXNG_CHOICE:
2062 return ("choice");
2063 case XML_RELAXNG_GROUP:
2064 return ("group");
2065 case XML_RELAXNG_INTERLEAVE:
2066 return ("interleave");
2067 case XML_RELAXNG_START:
2068 return ("start");
2069 case XML_RELAXNG_NOOP:
2070 return ("noop");
2071 case XML_RELAXNG_PARAM:
2072 return ("param");
2073 }
2074 return ("unknown");
2075}
2076
2077/**
2078 * xmlRelaxNGGetErrorString:
2079 * @err: the error code
2080 * @arg1: the first string argument
2081 * @arg2: the second string argument
2082 *
2083 * computes a formatted error string for the given error code and args
2084 *
2085 * Returns the error string, it must be deallocated by the caller
2086 */
2087static xmlChar *
2088xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
2089 const xmlChar * arg2)
2090{
2091 char msg[1000];
2092 xmlChar *result;
2093
2094 if (arg1 == NULL)
2095 arg1 = BAD_CAST "";
2096 if (arg2 == NULL)
2097 arg2 = BAD_CAST "";
2098
2099 msg[0] = 0;
2100 switch (err) {
2101 case XML_RELAXNG_OK:
2102 return (NULL);
2103 case XML_RELAXNG_ERR_MEMORY:
2104 return (xmlCharStrdup("out of memory\n"));
2105 case XML_RELAXNG_ERR_TYPE:
2106 snprintf(msg, 1000, "failed to validate type %s\n", arg1);
2107 break;
2108 case XML_RELAXNG_ERR_TYPEVAL:
2109 snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1,
2110 arg2);
2111 break;
2112 case XML_RELAXNG_ERR_DUPID:
2113 snprintf(msg, 1000, "ID %s redefined\n", arg1);
2114 break;
2115 case XML_RELAXNG_ERR_TYPECMP:
2116 snprintf(msg, 1000, "failed to compare type %s\n", arg1);
2117 break;
2118 case XML_RELAXNG_ERR_NOSTATE:
2119 return (xmlCharStrdup("Internal error: no state\n"));
2120 case XML_RELAXNG_ERR_NODEFINE:
2121 return (xmlCharStrdup("Internal error: no define\n"));
2122 case XML_RELAXNG_ERR_INTERNAL:
2123 snprintf(msg, 1000, "Internal error: %s\n", arg1);
2124 break;
2125 case XML_RELAXNG_ERR_LISTEXTRA:
2126 snprintf(msg, 1000, "Extra data in list: %s\n", arg1);
2127 break;
2128 case XML_RELAXNG_ERR_INTERNODATA:
2129 return (xmlCharStrdup
2130 ("Internal: interleave block has no data\n"));
2131 case XML_RELAXNG_ERR_INTERSEQ:
2132 return (xmlCharStrdup("Invalid sequence in interleave\n"));
2133 case XML_RELAXNG_ERR_INTEREXTRA:
2134 snprintf(msg, 1000, "Extra element %s in interleave\n", arg1);
2135 break;
2136 case XML_RELAXNG_ERR_ELEMNAME:
2137 snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1,
2138 arg2);
2139 break;
2140 case XML_RELAXNG_ERR_ELEMNONS:
2141 snprintf(msg, 1000, "Expecting a namespace for element %s\n",
2142 arg1);
2143 break;
2144 case XML_RELAXNG_ERR_ELEMWRONGNS:
2145 snprintf(msg, 1000,
2146 "Element %s has wrong namespace: expecting %s\n", arg1,
2147 arg2);
2148 break;
2149 case XML_RELAXNG_ERR_ELEMWRONG:
2150 snprintf(msg, 1000, "Did not expect element %s there\n", arg1);
2151 break;
2152 case XML_RELAXNG_ERR_TEXTWRONG:
2153 snprintf(msg, 1000,
2154 "Did not expect text in element %s content\n", arg1);
2155 break;
2156 case XML_RELAXNG_ERR_ELEMEXTRANS:
2157 snprintf(msg, 1000, "Expecting no namespace for element %s\n",
2158 arg1);
2159 break;
2160 case XML_RELAXNG_ERR_ELEMNOTEMPTY:
2161 snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1);
2162 break;
2163 case XML_RELAXNG_ERR_NOELEM:
2164 snprintf(msg, 1000, "Expecting an element %s, got nothing\n",
2165 arg1);
2166 break;
2167 case XML_RELAXNG_ERR_NOTELEM:
2168 return (xmlCharStrdup("Expecting an element got text\n"));
2169 case XML_RELAXNG_ERR_ATTRVALID:
2170 snprintf(msg, 1000, "Element %s failed to validate attributes\n",
2171 arg1);
2172 break;
2173 case XML_RELAXNG_ERR_CONTENTVALID:
2174 snprintf(msg, 1000, "Element %s failed to validate content\n",
2175 arg1);
2176 break;
2177 case XML_RELAXNG_ERR_EXTRACONTENT:
2178 snprintf(msg, 1000, "Element %s has extra content: %s\n",
2179 arg1, arg2);
2180 break;
2181 case XML_RELAXNG_ERR_INVALIDATTR:
2182 snprintf(msg, 1000, "Invalid attribute %s for element %s\n",
2183 arg1, arg2);
2184 break;
2185 case XML_RELAXNG_ERR_LACKDATA:
2186 snprintf(msg, 1000, "Datatype element %s contains no data\n",
2187 arg1);
2188 break;
2189 case XML_RELAXNG_ERR_DATAELEM:
2190 snprintf(msg, 1000, "Datatype element %s has child elements\n",
2191 arg1);
2192 break;
2193 case XML_RELAXNG_ERR_VALELEM:
2194 snprintf(msg, 1000, "Value element %s has child elements\n",
2195 arg1);
2196 break;
2197 case XML_RELAXNG_ERR_LISTELEM:
2198 snprintf(msg, 1000, "List element %s has child elements\n",
2199 arg1);
2200 break;
2201 case XML_RELAXNG_ERR_DATATYPE:
2202 snprintf(msg, 1000, "Error validating datatype %s\n", arg1);
2203 break;
2204 case XML_RELAXNG_ERR_VALUE:
2205 snprintf(msg, 1000, "Error validating value %s\n", arg1);
2206 break;
2207 case XML_RELAXNG_ERR_LIST:
2208 return (xmlCharStrdup("Error validating list\n"));
2209 case XML_RELAXNG_ERR_NOGRAMMAR:
2210 return (xmlCharStrdup("No top grammar defined\n"));
2211 case XML_RELAXNG_ERR_EXTRADATA:
2212 return (xmlCharStrdup("Extra data in the document\n"));
2213 default:
2214 return (xmlCharStrdup("Unknown error !\n"));
2215 }
2216 if (msg[0] == 0) {
2217 snprintf(msg, 1000, "Unknown error code %d\n", err);
2218 }
2219 msg[1000 - 1] = 0;
2220 result = xmlCharStrdup(msg);
2221 return (xmlEscapeFormatString(&result));
2222}
2223
2224/**
2225 * xmlRelaxNGShowValidError:
2226 * @ctxt: the validation context
2227 * @err: the error number
2228 * @node: the node
2229 * @child: the node child generating the problem.
2230 * @arg1: the first argument
2231 * @arg2: the second argument
2232 *
2233 * Show a validation error.
2234 */
2235static void
2236xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
2237 xmlRelaxNGValidErr err, xmlNodePtr node,
2238 xmlNodePtr child, const xmlChar * arg1,
2239 const xmlChar * arg2)
2240{
2241 xmlChar *msg;
2242
2243 if (ctxt->flags & FLAGS_NOERROR)
2244 return;
2245
2246#ifdef DEBUG_ERROR
2247 xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
2248#endif
2249 msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
2250 if (msg == NULL)
2251 return;
2252
2253 if (ctxt->errNo == XML_RELAXNG_OK)
2254 ctxt->errNo = err;
2255 xmlRngVErr(ctxt, (child == NULL ? node : child), err,
2256 (const char *) msg, arg1, arg2);
2257 xmlFree(msg);
2258}
2259
2260/**
2261 * xmlRelaxNGPopErrors:
2262 * @ctxt: the validation context
2263 * @level: the error level in the stack
2264 *
2265 * pop and discard all errors until the given level is reached
2266 */
2267static void
2268xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
2269{
2270 int i;
2271 xmlRelaxNGValidErrorPtr err;
2272
2273#ifdef DEBUG_ERROR
2274 xmlGenericError(xmlGenericErrorContext,
2275 "Pop errors till level %d\n", level);
2276#endif
2277 for (i = level; i < ctxt->errNr; i++) {
2278 err = &ctxt->errTab[i];
2279 if (err->flags & ERROR_IS_DUP) {
2280 if (err->arg1 != NULL)
2281 xmlFree((xmlChar *) err->arg1);
2282 err->arg1 = NULL;
2283 if (err->arg2 != NULL)
2284 xmlFree((xmlChar *) err->arg2);
2285 err->arg2 = NULL;
2286 err->flags = 0;
2287 }
2288 }
2289 ctxt->errNr = level;
2290 if (ctxt->errNr <= 0)
2291 ctxt->err = NULL;
2292}
2293
2294/**
2295 * xmlRelaxNGDumpValidError:
2296 * @ctxt: the validation context
2297 *
2298 * Show all validation error over a given index.
2299 */
2300static void
2301xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
2302{
2303 int i, j, k;
2304 xmlRelaxNGValidErrorPtr err, dup;
2305
2306#ifdef DEBUG_ERROR
2307 xmlGenericError(xmlGenericErrorContext,
2308 "Dumping error stack %d errors\n", ctxt->errNr);
2309#endif
2310 for (i = 0, k = 0; i < ctxt->errNr; i++) {
2311 err = &ctxt->errTab[i];
2312 if (k < MAX_ERROR) {
2313 for (j = 0; j < i; j++) {
2314 dup = &ctxt->errTab[j];
2315 if ((err->err == dup->err) && (err->node == dup->node) &&
2316 (xmlStrEqual(err->arg1, dup->arg1)) &&
2317 (xmlStrEqual(err->arg2, dup->arg2))) {
2318 goto skip;
2319 }
2320 }
2321 xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
2322 err->arg1, err->arg2);
2323 k++;
2324 }
2325 skip:
2326 if (err->flags & ERROR_IS_DUP) {
2327 if (err->arg1 != NULL)
2328 xmlFree((xmlChar *) err->arg1);
2329 err->arg1 = NULL;
2330 if (err->arg2 != NULL)
2331 xmlFree((xmlChar *) err->arg2);
2332 err->arg2 = NULL;
2333 err->flags = 0;
2334 }
2335 }
2336 ctxt->errNr = 0;
2337}
2338
2339/**
2340 * xmlRelaxNGAddValidError:
2341 * @ctxt: the validation context
2342 * @err: the error number
2343 * @arg1: the first argument
2344 * @arg2: the second argument
2345 * @dup: need to dup the args
2346 *
2347 * Register a validation error, either generating it if it's sure
2348 * or stacking it for later handling if unsure.
2349 */
2350static void
2351xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
2352 xmlRelaxNGValidErr err, const xmlChar * arg1,
2353 const xmlChar * arg2, int dup)
2354{
2355 if (ctxt == NULL)
2356 return;
2357 if (ctxt->flags & FLAGS_NOERROR)
2358 return;
2359
2360#ifdef DEBUG_ERROR
2361 xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
2362#endif
2363 /*
2364 * generate the error directly
2365 */
2366 if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
2367 (ctxt->flags & FLAGS_NEGATIVE)) {
2368 xmlNodePtr node, seq;
2369
2370 /*
2371 * Flush first any stacked error which might be the
2372 * real cause of the problem.
2373 */
2374 if (ctxt->errNr != 0)
2375 xmlRelaxNGDumpValidError(ctxt);
2376 if (ctxt->state != NULL) {
2377 node = ctxt->state->node;
2378 seq = ctxt->state->seq;
2379 } else {
2380 node = seq = NULL;
2381 }
2382 if ((node == NULL) && (seq == NULL)) {
2383 node = ctxt->pnode;
2384 }
2385 xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
2386 }
2387 /*
2388 * Stack the error for later processing if needed
2389 */
2390 else {
2391 xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
2392 }
2393}
2394
2395
2396/************************************************************************
2397 * *
2398 * Type library hooks *
2399 * *
2400 ************************************************************************/
2401static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
2402 const xmlChar * str);
2403
2404/**
2405 * xmlRelaxNGSchemaTypeHave:
2406 * @data: data needed for the library
2407 * @type: the type name
2408 *
2409 * Check if the given type is provided by
2410 * the W3C XMLSchema Datatype library.
2411 *
2412 * Returns 1 if yes, 0 if no and -1 in case of error.
2413 */
2414static int
2415xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
2416{
2417 xmlSchemaTypePtr typ;
2418
2419 if (type == NULL)
2420 return (-1);
2421 typ = xmlSchemaGetPredefinedType(type,
2422 BAD_CAST
2423 "http://www.w3.org/2001/XMLSchema");
2424 if (typ == NULL)
2425 return (0);
2426 return (1);
2427}
2428
2429/**
2430 * xmlRelaxNGSchemaTypeCheck:
2431 * @data: data needed for the library
2432 * @type: the type name
2433 * @value: the value to check
2434 * @node: the node
2435 *
2436 * Check if the given type and value are validated by
2437 * the W3C XMLSchema Datatype library.
2438 *
2439 * Returns 1 if yes, 0 if no and -1 in case of error.
2440 */
2441static int
2442xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
2443 const xmlChar * type,
2444 const xmlChar * value,
2445 void **result, xmlNodePtr node)
2446{
2447 xmlSchemaTypePtr typ;
2448 int ret;
2449
2450 if ((type == NULL) || (value == NULL))
2451 return (-1);
2452 typ = xmlSchemaGetPredefinedType(type,
2453 BAD_CAST
2454 "http://www.w3.org/2001/XMLSchema");
2455 if (typ == NULL)
2456 return (-1);
2457 ret = xmlSchemaValPredefTypeNode(typ, value,
2458 (xmlSchemaValPtr *) result, node);
2459 if (ret == 2) /* special ID error code */
2460 return (2);
2461 if (ret == 0)
2462 return (1);
2463 if (ret > 0)
2464 return (0);
2465 return (-1);
2466}
2467
2468/**
2469 * xmlRelaxNGSchemaFacetCheck:
2470 * @data: data needed for the library
2471 * @type: the type name
2472 * @facet: the facet name
2473 * @val: the facet value
2474 * @strval: the string value
2475 * @value: the value to check
2476 *
2477 * Function provided by a type library to check a value facet
2478 *
2479 * Returns 1 if yes, 0 if no and -1 in case of error.
2480 */
2481static int
2482xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
2483 const xmlChar * type, const xmlChar * facetname,
2484 const xmlChar * val, const xmlChar * strval,
2485 void *value)
2486{
2487 xmlSchemaFacetPtr facet;
2488 xmlSchemaTypePtr typ;
2489 int ret;
2490
2491 if ((type == NULL) || (strval == NULL))
2492 return (-1);
2493 typ = xmlSchemaGetPredefinedType(type,
2494 BAD_CAST
2495 "http://www.w3.org/2001/XMLSchema");
2496 if (typ == NULL)
2497 return (-1);
2498
2499 facet = xmlSchemaNewFacet();
2500 if (facet == NULL)
2501 return (-1);
2502
2503 if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
2504 facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
2505 } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
2506 facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
2507 } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
2508 facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
2509 } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
2510 facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
2511 } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
2512 facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
2513 } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
2514 facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
2515 } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
2516 facet->type = XML_SCHEMA_FACET_PATTERN;
2517 } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
2518 facet->type = XML_SCHEMA_FACET_ENUMERATION;
2519 } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
2520 facet->type = XML_SCHEMA_FACET_WHITESPACE;
2521 } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
2522 facet->type = XML_SCHEMA_FACET_LENGTH;
2523 } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
2524 facet->type = XML_SCHEMA_FACET_MAXLENGTH;
2525 } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) {
2526 facet->type = XML_SCHEMA_FACET_MINLENGTH;
2527 } else {
2528 xmlSchemaFreeFacet(facet);
2529 return (-1);
2530 }
2531 facet->value = val;
2532 ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
2533 if (ret != 0) {
2534 xmlSchemaFreeFacet(facet);
2535 return (-1);
2536 }
2537 ret = xmlSchemaValidateFacet(typ, facet, strval, value);
2538 xmlSchemaFreeFacet(facet);
2539 if (ret != 0)
2540 return (-1);
2541 return (0);
2542}
2543
2544/**
2545 * xmlRelaxNGSchemaFreeValue:
2546 * @data: data needed for the library
2547 * @value: the value to free
2548 *
2549 * Function provided by a type library to free a Schemas value
2550 *
2551 * Returns 1 if yes, 0 if no and -1 in case of error.
2552 */
2553static void
2554xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
2555{
2556 xmlSchemaFreeValue(value);
2557}
2558
2559/**
2560 * xmlRelaxNGSchemaTypeCompare:
2561 * @data: data needed for the library
2562 * @type: the type name
2563 * @value1: the first value
2564 * @value2: the second value
2565 *
2566 * Compare two values for equality accordingly a type from the W3C XMLSchema
2567 * Datatype library.
2568 *
2569 * Returns 1 if equal, 0 if no and -1 in case of error.
2570 */
2571static int
2572xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
2573 const xmlChar * type,
2574 const xmlChar * value1,
2575 xmlNodePtr ctxt1,
2576 void *comp1,
2577 const xmlChar * value2, xmlNodePtr ctxt2)
2578{
2579 int ret;
2580 xmlSchemaTypePtr typ;
2581 xmlSchemaValPtr res1 = NULL, res2 = NULL;
2582
2583 if ((type == NULL) || (value1 == NULL) || (value2 == NULL))
2584 return (-1);
2585 typ = xmlSchemaGetPredefinedType(type,
2586 BAD_CAST
2587 "http://www.w3.org/2001/XMLSchema");
2588 if (typ == NULL)
2589 return (-1);
2590 if (comp1 == NULL) {
2591 ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
2592 if (ret != 0)
2593 return (-1);
2594 if (res1 == NULL)
2595 return (-1);
2596 } else {
2597 res1 = (xmlSchemaValPtr) comp1;
2598 }
2599 ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
2600 if (ret != 0) {
2601 if (res1 != (xmlSchemaValPtr) comp1)
2602 xmlSchemaFreeValue(res1);
2603 return (-1);
2604 }
2605 ret = xmlSchemaCompareValues(res1, res2);
2606 if (res1 != (xmlSchemaValPtr) comp1)
2607 xmlSchemaFreeValue(res1);
2608 xmlSchemaFreeValue(res2);
2609 if (ret == -2)
2610 return (-1);
2611 if (ret == 0)
2612 return (1);
2613 return (0);
2614}
2615
2616/**
2617 * xmlRelaxNGDefaultTypeHave:
2618 * @data: data needed for the library
2619 * @type: the type name
2620 *
2621 * Check if the given type is provided by
2622 * the default datatype library.
2623 *
2624 * Returns 1 if yes, 0 if no and -1 in case of error.
2625 */
2626static int
2627xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
2628 const xmlChar * type)
2629{
2630 if (type == NULL)
2631 return (-1);
2632 if (xmlStrEqual(type, BAD_CAST "string"))
2633 return (1);
2634 if (xmlStrEqual(type, BAD_CAST "token"))
2635 return (1);
2636 return (0);
2637}
2638
2639/**
2640 * xmlRelaxNGDefaultTypeCheck:
2641 * @data: data needed for the library
2642 * @type: the type name
2643 * @value: the value to check
2644 * @node: the node
2645 *
2646 * Check if the given type and value are validated by
2647 * the default datatype library.
2648 *
2649 * Returns 1 if yes, 0 if no and -1 in case of error.
2650 */
2651static int
2652xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED,
2653 const xmlChar * type ATTRIBUTE_UNUSED,
2654 const xmlChar * value ATTRIBUTE_UNUSED,
2655 void **result ATTRIBUTE_UNUSED,
2656 xmlNodePtr node ATTRIBUTE_UNUSED)
2657{
2658 if (value == NULL)
2659 return (-1);
2660 if (xmlStrEqual(type, BAD_CAST "string"))
2661 return (1);
2662 if (xmlStrEqual(type, BAD_CAST "token")) {
2663 return (1);
2664 }
2665
2666 return (0);
2667}
2668
2669/**
2670 * xmlRelaxNGDefaultTypeCompare:
2671 * @data: data needed for the library
2672 * @type: the type name
2673 * @value1: the first value
2674 * @value2: the second value
2675 *
2676 * Compare two values accordingly a type from the default
2677 * datatype library.
2678 *
2679 * Returns 1 if yes, 0 if no and -1 in case of error.
2680 */
2681static int
2682xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
2683 const xmlChar * type,
2684 const xmlChar * value1,
2685 xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
2686 void *comp1 ATTRIBUTE_UNUSED,
2687 const xmlChar * value2,
2688 xmlNodePtr ctxt2 ATTRIBUTE_UNUSED)
2689{
2690 int ret = -1;
2691
2692 if (xmlStrEqual(type, BAD_CAST "string")) {
2693 ret = xmlStrEqual(value1, value2);
2694 } else if (xmlStrEqual(type, BAD_CAST "token")) {
2695 if (!xmlStrEqual(value1, value2)) {
2696 xmlChar *nval, *nvalue;
2697
2698 /*
2699 * TODO: trivial optimizations are possible by
2700 * computing at compile-time
2701 */
2702 nval = xmlRelaxNGNormalize(NULL, value1);
2703 nvalue = xmlRelaxNGNormalize(NULL, value2);
2704
2705 if ((nval == NULL) || (nvalue == NULL))
2706 ret = -1;
2707 else if (xmlStrEqual(nval, nvalue))
2708 ret = 1;
2709 else
2710 ret = 0;
2711 if (nval != NULL)
2712 xmlFree(nval);
2713 if (nvalue != NULL)
2714 xmlFree(nvalue);
2715 } else
2716 ret = 1;
2717 }
2718 return (ret);
2719}
2720
2721static int xmlRelaxNGTypeInitialized = 0;
2722static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
2723
2724/**
2725 * xmlRelaxNGFreeTypeLibrary:
2726 * @lib: the type library structure
2727 * @namespace: the URI bound to the library
2728 *
2729 * Free the structure associated to the type library
2730 */
2731static void
2732xmlRelaxNGFreeTypeLibrary(void *payload,
2733 const xmlChar * namespace ATTRIBUTE_UNUSED)
2734{
2735 xmlRelaxNGTypeLibraryPtr lib = (xmlRelaxNGTypeLibraryPtr) payload;
2736 if (lib == NULL)
2737 return;
2738 if (lib->namespace != NULL)
2739 xmlFree((xmlChar *) lib->namespace);
2740 xmlFree(lib);
2741}
2742
2743/**
2744 * xmlRelaxNGRegisterTypeLibrary:
2745 * @namespace: the URI bound to the library
2746 * @data: data associated to the library
2747 * @have: the provide function
2748 * @check: the checking function
2749 * @comp: the comparison function
2750 *
2751 * Register a new type library
2752 *
2753 * Returns 0 in case of success and -1 in case of error.
2754 */
2755static int
2756xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
2757 xmlRelaxNGTypeHave have,
2758 xmlRelaxNGTypeCheck check,
2759 xmlRelaxNGTypeCompare comp,
2760 xmlRelaxNGFacetCheck facet,
2761 xmlRelaxNGTypeFree freef)
2762{
2763 xmlRelaxNGTypeLibraryPtr lib;
2764 int ret;
2765
2766 if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) ||
2767 (check == NULL) || (comp == NULL))
2768 return (-1);
2769 if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
2770 xmlGenericError(xmlGenericErrorContext,
2771 "Relax-NG types library '%s' already registered\n",
2772 namespace);
2773 return (-1);
2774 }
2775 lib =
2776 (xmlRelaxNGTypeLibraryPtr)
2777 xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
2778 if (lib == NULL) {
2779 xmlRngVErrMemory(NULL, "adding types library\n");
2780 return (-1);
2781 }
2782 memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
2783 lib->namespace = xmlStrdup(namespace);
2784 lib->data = data;
2785 lib->have = have;
2786 lib->comp = comp;
2787 lib->check = check;
2788 lib->facet = facet;
2789 lib->freef = freef;
2790 ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib);
2791 if (ret < 0) {
2792 xmlGenericError(xmlGenericErrorContext,
2793 "Relax-NG types library failed to register '%s'\n",
2794 namespace);
2795 xmlRelaxNGFreeTypeLibrary(lib, namespace);
2796 return (-1);
2797 }
2798 return (0);
2799}
2800
2801/**
2802 * xmlRelaxNGInitTypes:
2803 *
2804 * Initilize the default type libraries.
2805 *
2806 * Returns 0 in case of success and -1 in case of error.
2807 */
2808int
2809xmlRelaxNGInitTypes(void)
2810{
2811 if (xmlRelaxNGTypeInitialized != 0)
2812 return (0);
2813 xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
2814 if (xmlRelaxNGRegisteredTypes == NULL) {
2815 xmlGenericError(xmlGenericErrorContext,
2816 "Failed to allocate sh table for Relax-NG types\n");
2817 return (-1);
2818 }
2819 xmlRelaxNGRegisterTypeLibrary(BAD_CAST
2820 "http://www.w3.org/2001/XMLSchema-datatypes",
2821 NULL, xmlRelaxNGSchemaTypeHave,
2822 xmlRelaxNGSchemaTypeCheck,
2823 xmlRelaxNGSchemaTypeCompare,
2824 xmlRelaxNGSchemaFacetCheck,
2825 xmlRelaxNGSchemaFreeValue);
2826 xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL,
2827 xmlRelaxNGDefaultTypeHave,
2828 xmlRelaxNGDefaultTypeCheck,
2829 xmlRelaxNGDefaultTypeCompare, NULL,
2830 NULL);
2831 xmlRelaxNGTypeInitialized = 1;
2832 return (0);
2833}
2834
2835/**
2836 * xmlRelaxNGCleanupTypes:
2837 *
2838 * Cleanup the default Schemas type library associated to RelaxNG
2839 */
2840void
2841xmlRelaxNGCleanupTypes(void)
2842{
2843 xmlSchemaCleanupTypes();
2844 if (xmlRelaxNGTypeInitialized == 0)
2845 return;
2846 xmlHashFree(xmlRelaxNGRegisteredTypes, xmlRelaxNGFreeTypeLibrary);
2847 xmlRelaxNGTypeInitialized = 0;
2848}
2849
2850/************************************************************************
2851 * *
2852 * Compiling element content into regexp *
2853 * *
2854 * Sometime the element content can be compiled into a pure regexp, *
2855 * This allows a faster execution and streamability at that level *
2856 * *
2857 ************************************************************************/
2858
2859/* from automata.c but not exported */
2860void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
2861
2862
2863static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
2864 xmlRelaxNGDefinePtr def);
2865
2866/**
2867 * xmlRelaxNGIsCompileable:
2868 * @define: the definition to check
2869 *
2870 * Check if a definition is nullable.
2871 *
2872 * Returns 1 if yes, 0 if no and -1 in case of error
2873 */
2874static int
2875xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
2876{
2877 int ret = -1;
2878
2879 if (def == NULL) {
2880 return (-1);
2881 }
2882 if ((def->type != XML_RELAXNG_ELEMENT) &&
2883 (def->dflags & IS_COMPILABLE))
2884 return (1);
2885 if ((def->type != XML_RELAXNG_ELEMENT) &&
2886 (def->dflags & IS_NOT_COMPILABLE))
2887 return (0);
2888 switch (def->type) {
2889 case XML_RELAXNG_NOOP:
2890 ret = xmlRelaxNGIsCompileable(def->content);
2891 break;
2892 case XML_RELAXNG_TEXT:
2893 case XML_RELAXNG_EMPTY:
2894 ret = 1;
2895 break;
2896 case XML_RELAXNG_ELEMENT:
2897 /*
2898 * Check if the element content is compileable
2899 */
2900 if (((def->dflags & IS_NOT_COMPILABLE) == 0) &&
2901 ((def->dflags & IS_COMPILABLE) == 0)) {
2902 xmlRelaxNGDefinePtr list;
2903
2904 list = def->content;
2905 while (list != NULL) {
2906 ret = xmlRelaxNGIsCompileable(list);
2907 if (ret != 1)
2908 break;
2909 list = list->next;
2910 }
2911 /*
2912 * Because the routine is recursive, we must guard against
2913 * discovering both COMPILABLE and NOT_COMPILABLE
2914 */
2915 if (ret == 0) {
2916 def->dflags &= ~IS_COMPILABLE;
2917 def->dflags |= IS_NOT_COMPILABLE;
2918 }
2919 if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE))
2920 def->dflags |= IS_COMPILABLE;
2921#ifdef DEBUG_COMPILE
2922 if (ret == 1) {
2923 xmlGenericError(xmlGenericErrorContext,
2924 "element content for %s is compilable\n",
2925 def->name);
2926 } else if (ret == 0) {
2927 xmlGenericError(xmlGenericErrorContext,
2928 "element content for %s is not compilable\n",
2929 def->name);
2930 } else {
2931 xmlGenericError(xmlGenericErrorContext,
2932 "Problem in RelaxNGIsCompileable for element %s\n",
2933 def->name);
2934 }
2935#endif
2936 }
2937 /*
2938 * All elements return a compileable status unless they
2939 * are generic like anyName
2940 */
2941 if ((def->nameClass != NULL) || (def->name == NULL))
2942 ret = 0;
2943 else
2944 ret = 1;
2945 return (ret);
2946 case XML_RELAXNG_REF:
2947 case XML_RELAXNG_EXTERNALREF:
2948 case XML_RELAXNG_PARENTREF:
2949 if (def->depth == -20) {
2950 return (1);
2951 } else {
2952 xmlRelaxNGDefinePtr list;
2953
2954 def->depth = -20;
2955 list = def->content;
2956 while (list != NULL) {
2957 ret = xmlRelaxNGIsCompileable(list);
2958 if (ret != 1)
2959 break;
2960 list = list->next;
2961 }
2962 }
2963 break;
2964 case XML_RELAXNG_START:
2965 case XML_RELAXNG_OPTIONAL:
2966 case XML_RELAXNG_ZEROORMORE:
2967 case XML_RELAXNG_ONEORMORE:
2968 case XML_RELAXNG_CHOICE:
2969 case XML_RELAXNG_GROUP:
2970 case XML_RELAXNG_DEF:{
2971 xmlRelaxNGDefinePtr list;
2972
2973 list = def->content;
2974 while (list != NULL) {
2975 ret = xmlRelaxNGIsCompileable(list);
2976 if (ret != 1)
2977 break;
2978 list = list->next;
2979 }
2980 break;
2981 }
2982 case XML_RELAXNG_EXCEPT:
2983 case XML_RELAXNG_ATTRIBUTE:
2984 case XML_RELAXNG_INTERLEAVE:
2985 case XML_RELAXNG_DATATYPE:
2986 case XML_RELAXNG_LIST:
2987 case XML_RELAXNG_PARAM:
2988 case XML_RELAXNG_VALUE:
2989 case XML_RELAXNG_NOT_ALLOWED:
2990 ret = 0;
2991 break;
2992 }
2993 if (ret == 0)
2994 def->dflags |= IS_NOT_COMPILABLE;
2995 if (ret == 1)
2996 def->dflags |= IS_COMPILABLE;
2997#ifdef DEBUG_COMPILE
2998 if (ret == 1) {
2999 xmlGenericError(xmlGenericErrorContext,
3000 "RelaxNGIsCompileable %s : true\n",
3001 xmlRelaxNGDefName(def));
3002 } else if (ret == 0) {
3003 xmlGenericError(xmlGenericErrorContext,
3004 "RelaxNGIsCompileable %s : false\n",
3005 xmlRelaxNGDefName(def));
3006 } else {
3007 xmlGenericError(xmlGenericErrorContext,
3008 "Problem in RelaxNGIsCompileable %s\n",
3009 xmlRelaxNGDefName(def));
3010 }
3011#endif
3012 return (ret);
3013}
3014
3015/**
3016 * xmlRelaxNGCompile:
3017 * ctxt: the RelaxNG parser context
3018 * @define: the definition tree to compile
3019 *
3020 * Compile the set of definitions, it works recursively, till the
3021 * element boundaries, where it tries to compile the content if possible
3022 *
3023 * Returns 0 if success and -1 in case of error
3024 */
3025static int
3026xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3027{
3028 int ret = 0;
3029 xmlRelaxNGDefinePtr list;
3030
3031 if ((ctxt == NULL) || (def == NULL))
3032 return (-1);
3033
3034 switch (def->type) {
3035 case XML_RELAXNG_START:
3036 if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
3037 xmlAutomataPtr oldam = ctxt->am;
3038 xmlAutomataStatePtr oldstate = ctxt->state;
3039
3040 def->depth = -25;
3041
3042 list = def->content;
3043 ctxt->am = xmlNewAutomata();
3044 if (ctxt->am == NULL)
3045 return (-1);
3046
3047 /*
3048 * assume identical strings but not same pointer are different
3049 * atoms, needed for non-determinism detection
3050 * That way if 2 elements with the same name are in a choice
3051 * branch the automata is found non-deterministic and
3052 * we fallback to the normal validation which does the right
3053 * thing of exploring both choices.
3054 */
3055 xmlAutomataSetFlags(ctxt->am, 1);
3056
3057 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3058 while (list != NULL) {
3059 xmlRelaxNGCompile(ctxt, list);
3060 list = list->next;
3061 }
3062 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3063 if (xmlAutomataIsDeterminist(ctxt->am))
3064 def->contModel = xmlAutomataCompile(ctxt->am);
3065
3066 xmlFreeAutomata(ctxt->am);
3067 ctxt->state = oldstate;
3068 ctxt->am = oldam;
3069 }
3070 break;
3071 case XML_RELAXNG_ELEMENT:
3072 if ((ctxt->am != NULL) && (def->name != NULL)) {
3073 ctxt->state = xmlAutomataNewTransition2(ctxt->am,
3074 ctxt->state, NULL,
3075 def->name, def->ns,
3076 def);
3077 }
3078 if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
3079 xmlAutomataPtr oldam = ctxt->am;
3080 xmlAutomataStatePtr oldstate = ctxt->state;
3081
3082 def->depth = -25;
3083
3084 list = def->content;
3085 ctxt->am = xmlNewAutomata();
3086 if (ctxt->am == NULL)
3087 return (-1);
3088 xmlAutomataSetFlags(ctxt->am, 1);
3089 ctxt->state = xmlAutomataGetInitState(ctxt->am);
3090 while (list != NULL) {
3091 xmlRelaxNGCompile(ctxt, list);
3092 list = list->next;
3093 }
3094 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
3095 def->contModel = xmlAutomataCompile(ctxt->am);
3096 if (!xmlRegexpIsDeterminist(def->contModel)) {
3097#ifdef DEBUG_COMPILE
3098 xmlGenericError(xmlGenericErrorContext,
3099 "Content model not determinist %s\n",
3100 def->name);
3101#endif
3102 /*
3103 * we can only use the automata if it is determinist
3104 */
3105 xmlRegFreeRegexp(def->contModel);
3106 def->contModel = NULL;
3107 }
3108 xmlFreeAutomata(ctxt->am);
3109 ctxt->state = oldstate;
3110 ctxt->am = oldam;
3111 } else {
3112 xmlAutomataPtr oldam = ctxt->am;
3113
3114 /*
3115 * we can't build the content model for this element content
3116 * but it still might be possible to build it for some of its
3117 * children, recurse.
3118 */
3119 ret = xmlRelaxNGTryCompile(ctxt, def);
3120 ctxt->am = oldam;
3121 }
3122 break;
3123 case XML_RELAXNG_NOOP:
3124 ret = xmlRelaxNGCompile(ctxt, def->content);
3125 break;
3126 case XML_RELAXNG_OPTIONAL:{
3127 xmlAutomataStatePtr oldstate = ctxt->state;
3128
3129 list = def->content;
3130 while (list != NULL) {
3131 xmlRelaxNGCompile(ctxt, list);
3132 list = list->next;
3133 }
3134 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
3135 break;
3136 }
3137 case XML_RELAXNG_ZEROORMORE:{
3138 xmlAutomataStatePtr oldstate;
3139
3140 ctxt->state =
3141 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3142 oldstate = ctxt->state;
3143 list = def->content;
3144 while (list != NULL) {
3145 xmlRelaxNGCompile(ctxt, list);
3146 list = list->next;
3147 }
3148 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3149 ctxt->state =
3150 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3151 break;
3152 }
3153 case XML_RELAXNG_ONEORMORE:{
3154 xmlAutomataStatePtr oldstate;
3155
3156 list = def->content;
3157 while (list != NULL) {
3158 xmlRelaxNGCompile(ctxt, list);
3159 list = list->next;
3160 }
3161 oldstate = ctxt->state;
3162 list = def->content;
3163 while (list != NULL) {
3164 xmlRelaxNGCompile(ctxt, list);
3165 list = list->next;
3166 }
3167 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
3168 ctxt->state =
3169 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3170 break;
3171 }
3172 case XML_RELAXNG_CHOICE:{
3173 xmlAutomataStatePtr target = NULL;
3174 xmlAutomataStatePtr oldstate = ctxt->state;
3175
3176 list = def->content;
3177 while (list != NULL) {
3178 ctxt->state = oldstate;
3179 ret = xmlRelaxNGCompile(ctxt, list);
3180 if (ret != 0)
3181 break;
3182 if (target == NULL)
3183 target = ctxt->state;
3184 else {
3185 xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
3186 target);
3187 }
3188 list = list->next;
3189 }
3190 ctxt->state = target;
3191
3192 break;
3193 }
3194 case XML_RELAXNG_REF:
3195 case XML_RELAXNG_EXTERNALREF:
3196 case XML_RELAXNG_PARENTREF:
3197 case XML_RELAXNG_GROUP:
3198 case XML_RELAXNG_DEF:
3199 list = def->content;
3200 while (list != NULL) {
3201 ret = xmlRelaxNGCompile(ctxt, list);
3202 if (ret != 0)
3203 break;
3204 list = list->next;
3205 }
3206 break;
3207 case XML_RELAXNG_TEXT:{
3208 xmlAutomataStatePtr oldstate;
3209
3210 ctxt->state =
3211 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3212 oldstate = ctxt->state;
3213 xmlRelaxNGCompile(ctxt, def->content);
3214 xmlAutomataNewTransition(ctxt->am, ctxt->state,
3215 ctxt->state, BAD_CAST "#text",
3216 NULL);
3217 ctxt->state =
3218 xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
3219 break;
3220 }
3221 case XML_RELAXNG_EMPTY:
3222 ctxt->state =
3223 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
3224 break;
3225 case XML_RELAXNG_EXCEPT:
3226 case XML_RELAXNG_ATTRIBUTE:
3227 case XML_RELAXNG_INTERLEAVE:
3228 case XML_RELAXNG_NOT_ALLOWED:
3229 case XML_RELAXNG_DATATYPE:
3230 case XML_RELAXNG_LIST:
3231 case XML_RELAXNG_PARAM:
3232 case XML_RELAXNG_VALUE:
3233 /* This should not happen and generate an internal error */
3234 fprintf(stderr, "RNG internal error trying to compile %s\n",
3235 xmlRelaxNGDefName(def));
3236 break;
3237 }
3238 return (ret);
3239}
3240
3241/**
3242 * xmlRelaxNGTryCompile:
3243 * ctxt: the RelaxNG parser context
3244 * @define: the definition tree to compile
3245 *
3246 * Try to compile the set of definitions, it works recursively,
3247 * possibly ignoring parts which cannot be compiled.
3248 *
3249 * Returns 0 if success and -1 in case of error
3250 */
3251static int
3252xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
3253{
3254 int ret = 0;
3255 xmlRelaxNGDefinePtr list;
3256
3257 if ((ctxt == NULL) || (def == NULL))
3258 return (-1);
3259
3260 if ((def->type == XML_RELAXNG_START) ||
3261 (def->type == XML_RELAXNG_ELEMENT)) {
3262 ret = xmlRelaxNGIsCompileable(def);
3263 if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
3264 ctxt->am = NULL;
3265 ret = xmlRelaxNGCompile(ctxt, def);
3266#ifdef DEBUG_PROGRESSIVE
3267 if (ret == 0) {
3268 if (def->type == XML_RELAXNG_START)
3269 xmlGenericError(xmlGenericErrorContext,
3270 "compiled the start\n");
3271 else
3272 xmlGenericError(xmlGenericErrorContext,
3273 "compiled element %s\n", def->name);
3274 } else {
3275 if (def->type == XML_RELAXNG_START)
3276 xmlGenericError(xmlGenericErrorContext,
3277 "failed to compile the start\n");
3278 else
3279 xmlGenericError(xmlGenericErrorContext,
3280 "failed to compile element %s\n",
3281 def->name);
3282 }
3283#endif
3284 return (ret);
3285 }
3286 }
3287 switch (def->type) {
3288 case XML_RELAXNG_NOOP:
3289 ret = xmlRelaxNGTryCompile(ctxt, def->content);
3290 break;
3291 case XML_RELAXNG_TEXT:
3292 case XML_RELAXNG_DATATYPE:
3293 case XML_RELAXNG_LIST:
3294 case XML_RELAXNG_PARAM:
3295 case XML_RELAXNG_VALUE:
3296 case XML_RELAXNG_EMPTY:
3297 case XML_RELAXNG_ELEMENT:
3298 ret = 0;
3299 break;
3300 case XML_RELAXNG_OPTIONAL:
3301 case XML_RELAXNG_ZEROORMORE:
3302 case XML_RELAXNG_ONEORMORE:
3303 case XML_RELAXNG_CHOICE:
3304 case XML_RELAXNG_GROUP:
3305 case XML_RELAXNG_DEF:
3306 case XML_RELAXNG_START:
3307 case XML_RELAXNG_REF:
3308 case XML_RELAXNG_EXTERNALREF:
3309 case XML_RELAXNG_PARENTREF:
3310 list = def->content;
3311 while (list != NULL) {
3312 ret = xmlRelaxNGTryCompile(ctxt, list);
3313 if (ret != 0)
3314 break;
3315 list = list->next;
3316 }
3317 break;
3318 case XML_RELAXNG_EXCEPT:
3319 case XML_RELAXNG_ATTRIBUTE:
3320 case XML_RELAXNG_INTERLEAVE:
3321 case XML_RELAXNG_NOT_ALLOWED:
3322 ret = 0;
3323 break;
3324 }
3325 return (ret);
3326}
3327
3328/************************************************************************
3329 * *
3330 * Parsing functions *
3331 * *
3332 ************************************************************************/
3333
3334static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr
3335 ctxt, xmlNodePtr node);
3336static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr
3337 ctxt, xmlNodePtr node);
3338static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr
3339 ctxt, xmlNodePtr nodes,
3340 int group);
3341static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr
3342 ctxt, xmlNodePtr node);
3343static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
3344 xmlNodePtr node);
3345static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
3346 xmlNodePtr nodes);
3347static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr
3348 ctxt, xmlNodePtr node,
3349 xmlRelaxNGDefinePtr
3350 def);
3351static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr
3352 ctxt, xmlNodePtr nodes);
3353static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
3354 xmlRelaxNGDefinePtr define,
3355 xmlNodePtr elem);
3356
3357
3358#define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content))
3359
3360/**
3361 * xmlRelaxNGIsNullable:
3362 * @define: the definition to verify
3363 *
3364 * Check if a definition is nullable.
3365 *
3366 * Returns 1 if yes, 0 if no and -1 in case of error
3367 */
3368static int
3369xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
3370{
3371 int ret;
3372
3373 if (define == NULL)
3374 return (-1);
3375
3376 if (define->dflags & IS_NULLABLE)
3377 return (1);
3378 if (define->dflags & IS_NOT_NULLABLE)
3379 return (0);
3380 switch (define->type) {
3381 case XML_RELAXNG_EMPTY:
3382 case XML_RELAXNG_TEXT:
3383 ret = 1;
3384 break;
3385 case XML_RELAXNG_NOOP:
3386 case XML_RELAXNG_DEF:
3387 case XML_RELAXNG_REF:
3388 case XML_RELAXNG_EXTERNALREF:
3389 case XML_RELAXNG_PARENTREF:
3390 case XML_RELAXNG_ONEORMORE:
3391 ret = xmlRelaxNGIsNullable(define->content);
3392 break;
3393 case XML_RELAXNG_EXCEPT:
3394 case XML_RELAXNG_NOT_ALLOWED:
3395 case XML_RELAXNG_ELEMENT:
3396 case XML_RELAXNG_DATATYPE:
3397 case XML_RELAXNG_PARAM:
3398 case XML_RELAXNG_VALUE:
3399 case XML_RELAXNG_LIST:
3400 case XML_RELAXNG_ATTRIBUTE:
3401 ret = 0;
3402 break;
3403 case XML_RELAXNG_CHOICE:{
3404 xmlRelaxNGDefinePtr list = define->content;
3405
3406 while (list != NULL) {
3407 ret = xmlRelaxNGIsNullable(list);
3408 if (ret != 0)
3409 goto done;
3410 list = list->next;
3411 }
3412 ret = 0;
3413 break;
3414 }
3415 case XML_RELAXNG_START:
3416 case XML_RELAXNG_INTERLEAVE:
3417 case XML_RELAXNG_GROUP:{
3418 xmlRelaxNGDefinePtr list = define->content;
3419
3420 while (list != NULL) {
3421 ret = xmlRelaxNGIsNullable(list);
3422 if (ret != 1)
3423 goto done;
3424 list = list->next;
3425 }
3426 return (1);
3427 }
3428 default:
3429 return (-1);
3430 }
3431 done:
3432 if (ret == 0)
3433 define->dflags |= IS_NOT_NULLABLE;
3434 if (ret == 1)
3435 define->dflags |= IS_NULLABLE;
3436 return (ret);
3437}
3438
3439/**
3440 * xmlRelaxNGIsBlank:
3441 * @str: a string
3442 *
3443 * Check if a string is ignorable c.f. 4.2. Whitespace
3444 *
3445 * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
3446 */
3447static int
3448xmlRelaxNGIsBlank(xmlChar * str)
3449{
3450 if (str == NULL)
3451 return (1);
3452 while (*str != 0) {
3453 if (!(IS_BLANK_CH(*str)))
3454 return (0);
3455 str++;
3456 }
3457 return (1);
3458}
3459
3460/**
3461 * xmlRelaxNGGetDataTypeLibrary:
3462 * @ctxt: a Relax-NG parser context
3463 * @node: the current data or value element
3464 *
3465 * Applies algorithm from 4.3. datatypeLibrary attribute
3466 *
3467 * Returns the datatypeLibary value or NULL if not found
3468 */
3469static xmlChar *
3470xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
3471 xmlNodePtr node)
3472{
3473 xmlChar *ret, *escape;
3474
3475 if (node == NULL)
3476 return(NULL);
3477
3478 if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
3479 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3480 if (ret != NULL) {
3481 if (ret[0] == 0) {
3482 xmlFree(ret);
3483 return (NULL);
3484 }
3485 escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
3486 if (escape == NULL) {
3487 return (ret);
3488 }
3489 xmlFree(ret);
3490 return (escape);
3491 }
3492 }
3493 node = node->parent;
3494 while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
3495 ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
3496 if (ret != NULL) {
3497 if (ret[0] == 0) {
3498 xmlFree(ret);
3499 return (NULL);
3500 }
3501 escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
3502 if (escape == NULL) {
3503 return (ret);
3504 }
3505 xmlFree(ret);
3506 return (escape);
3507 }
3508 node = node->parent;
3509 }
3510 return (NULL);
3511}
3512
3513/**
3514 * xmlRelaxNGParseValue:
3515 * @ctxt: a Relax-NG parser context
3516 * @node: the data node.
3517 *
3518 * parse the content of a RelaxNG value node.
3519 *
3520 * Returns the definition pointer or NULL in case of error
3521 */
3522static xmlRelaxNGDefinePtr
3523xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3524{
3525 xmlRelaxNGDefinePtr def = NULL;
3526 xmlRelaxNGTypeLibraryPtr lib = NULL;
3527 xmlChar *type;
3528 xmlChar *library;
3529 int success = 0;
3530
3531 def = xmlRelaxNGNewDefine(ctxt, node);
3532 if (def == NULL)
3533 return (NULL);
3534 def->type = XML_RELAXNG_VALUE;
3535
3536 type = xmlGetProp(node, BAD_CAST "type");
3537 if (type != NULL) {
3538 xmlRelaxNGNormExtSpace(type);
3539 if (xmlValidateNCName(type, 0)) {
3540 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3541 "value type '%s' is not an NCName\n", type, NULL);
3542 }
3543 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3544 if (library == NULL)
3545 library =
3546 xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
3547
3548 def->name = type;
3549 def->ns = library;
3550
3551 lib = (xmlRelaxNGTypeLibraryPtr)
3552 xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
3553 if (lib == NULL) {
3554 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3555 "Use of unregistered type library '%s'\n", library,
3556 NULL);
3557 def->data = NULL;
3558 } else {
3559 def->data = lib;
3560 if (lib->have == NULL) {
3561 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3562 "Internal error with type library '%s': no 'have'\n",
3563 library, NULL);
3564 } else {
3565 success = lib->have(lib->data, def->name);
3566 if (success != 1) {
3567 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3568 "Error type '%s' is not exported by type library '%s'\n",
3569 def->name, library);
3570 }
3571 }
3572 }
3573 }
3574 if (node->children == NULL) {
3575 def->value = xmlStrdup(BAD_CAST "");
3576 } else if (((node->children->type != XML_TEXT_NODE) &&
3577 (node->children->type != XML_CDATA_SECTION_NODE)) ||
3578 (node->children->next != NULL)) {
3579 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
3580 "Expecting a single text value for <value>content\n",
3581 NULL, NULL);
3582 } else if (def != NULL) {
3583 def->value = xmlNodeGetContent(node);
3584 if (def->value == NULL) {
3585 xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
3586 "Element <value> has no content\n", NULL, NULL);
3587 } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
3588 void *val = NULL;
3589
3590 success =
3591 lib->check(lib->data, def->name, def->value, &val, node);
3592 if (success != 1) {
3593 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
3594 "Value '%s' is not acceptable for type '%s'\n",
3595 def->value, def->name);
3596 } else {
3597 if (val != NULL)
3598 def->attrs = val;
3599 }
3600 }
3601 }
3602 return (def);
3603}
3604
3605/**
3606 * xmlRelaxNGParseData:
3607 * @ctxt: a Relax-NG parser context
3608 * @node: the data node.
3609 *
3610 * parse the content of a RelaxNG data node.
3611 *
3612 * Returns the definition pointer or NULL in case of error
3613 */
3614static xmlRelaxNGDefinePtr
3615xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
3616{
3617 xmlRelaxNGDefinePtr def = NULL, except;
3618 xmlRelaxNGDefinePtr param, lastparam = NULL;
3619 xmlRelaxNGTypeLibraryPtr lib;
3620 xmlChar *type;
3621 xmlChar *library;
3622 xmlNodePtr content;
3623 int tmp;
3624
3625 type = xmlGetProp(node, BAD_CAST "type");
3626 if (type == NULL) {
3627 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
3628 NULL);
3629 return (NULL);
3630 }
3631 xmlRelaxNGNormExtSpace(type);
3632 if (xmlValidateNCName(type, 0)) {
3633 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
3634 "data type '%s' is not an NCName\n", type, NULL);
3635 }
3636 library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
3637 if (library == NULL)
3638 library =
3639 xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
3640
3641 def = xmlRelaxNGNewDefine(ctxt, node);
3642 if (def == NULL) {
3643 xmlFree(type);
3644 return (NULL);
3645 }
3646 def->type = XML_RELAXNG_DATATYPE;
3647 def->name = type;
3648 def->ns = library;
3649
3650 lib = (xmlRelaxNGTypeLibraryPtr)
3651 xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
3652 if (lib == NULL) {
3653 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
3654 "Use of unregistered type library '%s'\n", library,
3655 NULL);
3656 def->data = NULL;
3657 } else {
3658 def->data = lib;
3659 if (lib->have == NULL) {
3660 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
3661 "Internal error with type library '%s': no 'have'\n",
3662 library, NULL);
3663 } else {
3664 tmp = lib->have(lib->data, def->name);
3665 if (tmp != 1) {
3666 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
3667 "Error type '%s' is not exported by type library '%s'\n",
3668 def->name, library);
3669 } else
3670 if ((xmlStrEqual
3671 (library,
3672 BAD_CAST
3673 "http://www.w3.org/2001/XMLSchema-datatypes"))
3674 && ((xmlStrEqual(def->name, BAD_CAST "IDREF"))
3675 || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) {
3676 ctxt->idref = 1;
3677 }
3678 }
3679 }
3680 content = node->children;
3681
3682 /*
3683 * Handle optional params
3684 */
3685 while (content != NULL) {
3686 if (!xmlStrEqual(content->name, BAD_CAST "param"))
3687 break;
3688 if (xmlStrEqual(library,
3689 BAD_CAST "http://relaxng.org/ns/structure/1.0")) {
3690 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
3691 "Type library '%s' does not allow type parameters\n",
3692 library, NULL);
3693 content = content->next;
3694 while ((content != NULL) &&
3695 (xmlStrEqual(content->name, BAD_CAST "param")))
3696 content = content->next;
3697 } else {
3698 param = xmlRelaxNGNewDefine(ctxt, node);
3699 if (param != NULL) {
3700 param->type = XML_RELAXNG_PARAM;
3701 param->name = xmlGetProp(content, BAD_CAST "name");
3702 if (param->name == NULL) {
3703 xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
3704 "param has no name\n", NULL, NULL);
3705 }
3706 param->value = xmlNodeGetContent(content);
3707 if (lastparam == NULL) {
3708 def->attrs = lastparam = param;
3709 } else {
3710 lastparam->next = param;
3711 lastparam = param;
3712 }
3713 if (lib != NULL) {
3714 }
3715 }
3716 content = content->next;
3717 }
3718 }
3719 /*
3720 * Handle optional except
3721 */
3722 if ((content != NULL)
3723 && (xmlStrEqual(content->name, BAD_CAST "except"))) {
3724 xmlNodePtr child;
3725 xmlRelaxNGDefinePtr tmp2, last = NULL;
3726
3727 except = xmlRelaxNGNewDefine(ctxt, node);
3728 if (except == NULL) {
3729 return (def);
3730 }
3731 except->type = XML_RELAXNG_EXCEPT;
3732 child = content->children;
3733 def->content = except;
3734 if (child == NULL) {
3735 xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
3736 "except has no content\n", NULL, NULL);
3737 }
3738 while (child != NULL) {
3739 tmp2 = xmlRelaxNGParsePattern(ctxt, child);
3740 if (tmp2 != NULL) {
3741 if (last == NULL) {
3742 except->content = last = tmp2;
3743 } else {
3744 last->next = tmp2;
3745 last = tmp2;
3746 }
3747 }
3748 child = child->next;
3749 }
3750 content = content->next;
3751 }
3752 /*
3753 * Check there is no unhandled data
3754 */
3755 if (content != NULL) {
3756 xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
3757 "Element data has unexpected content %s\n",
3758 content->name, NULL);
3759 }
3760
3761 return (def);
3762}
3763
3764static const xmlChar *invalidName = BAD_CAST "\1";
3765
3766/**
3767 * xmlRelaxNGCompareNameClasses:
3768 * @defs1: the first element/attribute defs
3769 * @defs2: the second element/attribute defs
3770 * @name: the restriction on the name
3771 * @ns: the restriction on the namespace
3772 *
3773 * Compare the 2 lists of element definitions. The comparison is
3774 * that if both lists do not accept the same QNames, it returns 1
3775 * If the 2 lists can accept the same QName the comparison returns 0
3776 *
3777 * Returns 1 disttinct, 0 if equal
3778 */
3779static int
3780xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
3781 xmlRelaxNGDefinePtr def2)
3782{
3783 int ret = 1;
3784 xmlNode node;
3785 xmlNs ns;
3786 xmlRelaxNGValidCtxt ctxt;
3787
3788 memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
3789
3790 ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
3791
3792 if ((def1->type == XML_RELAXNG_ELEMENT) ||
3793 (def1->type == XML_RELAXNG_ATTRIBUTE)) {
3794 if (def2->type == XML_RELAXNG_TEXT)
3795 return (1);
3796 if (def1->name != NULL) {
3797 node.name = def1->name;
3798 } else {
3799 node.name = invalidName;
3800 }
3801 if (def1->ns != NULL) {
3802 if (def1->ns[0] == 0) {
3803 node.ns = NULL;
3804 } else {
3805 node.ns = &ns;
3806 ns.href = def1->ns;
3807 }
3808 } else {
3809 node.ns = NULL;
3810 }
3811 if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
3812 if (def1->nameClass != NULL) {
3813 ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
3814 } else {
3815 ret = 0;
3816 }
3817 } else {
3818 ret = 1;
3819 }
3820 } else if (def1->type == XML_RELAXNG_TEXT) {
3821 if (def2->type == XML_RELAXNG_TEXT)
3822 return (0);
3823 return (1);
3824 } else if (def1->type == XML_RELAXNG_EXCEPT) {
3825 ret = xmlRelaxNGCompareNameClasses(def1->content, def2);
3826 if (ret == 0)
3827 ret = 1;
3828 else if (ret == 1)
3829 ret = 0;
3830 } else {
3831 TODO ret = 0;
3832 }
3833 if (ret == 0)
3834 return (ret);
3835 if ((def2->type == XML_RELAXNG_ELEMENT) ||
3836 (def2->type == XML_RELAXNG_ATTRIBUTE)) {
3837 if (def2->name != NULL) {
3838 node.name = def2->name;
3839 } else {
3840 node.name = invalidName;
3841 }
3842 node.ns = &ns;
3843 if (def2->ns != NULL) {
3844 if (def2->ns[0] == 0) {
3845 node.ns = NULL;
3846 } else {
3847 ns.href = def2->ns;
3848 }
3849 } else {
3850 ns.href = invalidName;
3851 }
3852 if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
3853 if (def2->nameClass != NULL) {
3854 ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
3855 } else {
3856 ret = 0;
3857 }
3858 } else {
3859 ret = 1;
3860 }
3861 } else {
3862 TODO ret = 0;
3863 }
3864
3865 return (ret);
3866}
3867
3868/**
3869 * xmlRelaxNGCompareElemDefLists:
3870 * @ctxt: a Relax-NG parser context
3871 * @defs1: the first list of element/attribute defs
3872 * @defs2: the second list of element/attribute defs
3873 *
3874 * Compare the 2 lists of element or attribute definitions. The comparison
3875 * is that if both lists do not accept the same QNames, it returns 1
3876 * If the 2 lists can accept the same QName the comparison returns 0
3877 *
3878 * Returns 1 disttinct, 0 if equal
3879 */
3880static int
3881xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
3882 ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
3883 xmlRelaxNGDefinePtr * def2)
3884{
3885 xmlRelaxNGDefinePtr *basedef2 = def2;
3886
3887 if ((def1 == NULL) || (def2 == NULL))
3888 return (1);
3889 if ((*def1 == NULL) || (*def2 == NULL))
3890 return (1);
3891 while (*def1 != NULL) {
3892 while ((*def2) != NULL) {
3893 if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
3894 return (0);
3895 def2++;
3896 }
3897 def2 = basedef2;
3898 def1++;
3899 }
3900 return (1);
3901}
3902
3903/**
3904 * xmlRelaxNGGenerateAttributes:
3905 * @ctxt: a Relax-NG parser context
3906 * @def: the definition definition
3907 *
3908 * Check if the definition can only generate attributes
3909 *
3910 * Returns 1 if yes, 0 if no and -1 in case of error.
3911 */
3912static int
3913xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
3914 xmlRelaxNGDefinePtr def)
3915{
3916 xmlRelaxNGDefinePtr parent, cur, tmp;
3917
3918 /*
3919 * Don't run that check in case of error. Infinite recursion
3920 * becomes possible.
3921 */
3922 if (ctxt->nbErrors != 0)
3923 return (-1);
3924
3925 parent = NULL;
3926 cur = def;
3927 while (cur != NULL) {
3928 if ((cur->type == XML_RELAXNG_ELEMENT) ||
3929 (cur->type == XML_RELAXNG_TEXT) ||
3930 (cur->type == XML_RELAXNG_DATATYPE) ||
3931 (cur->type == XML_RELAXNG_PARAM) ||
3932 (cur->type == XML_RELAXNG_LIST) ||
3933 (cur->type == XML_RELAXNG_VALUE) ||
3934 (cur->type == XML_RELAXNG_EMPTY))
3935 return (0);
3936 if ((cur->type == XML_RELAXNG_CHOICE) ||
3937 (cur->type == XML_RELAXNG_INTERLEAVE) ||
3938 (cur->type == XML_RELAXNG_GROUP) ||
3939 (cur->type == XML_RELAXNG_ONEORMORE) ||
3940 (cur->type == XML_RELAXNG_ZEROORMORE) ||
3941 (cur->type == XML_RELAXNG_OPTIONAL) ||
3942 (cur->type == XML_RELAXNG_PARENTREF) ||
3943 (cur->type == XML_RELAXNG_EXTERNALREF) ||
3944 (cur->type == XML_RELAXNG_REF) ||
3945 (cur->type == XML_RELAXNG_DEF)) {
3946 if (cur->content != NULL) {
3947 parent = cur;
3948 cur = cur->content;
3949 tmp = cur;
3950 while (tmp != NULL) {
3951 tmp->parent = parent;
3952 tmp = tmp->next;
3953 }
3954 continue;
3955 }
3956 }
3957 if (cur == def)
3958 break;
3959 if (cur->next != NULL) {
3960 cur = cur->next;
3961 continue;
3962 }
3963 do {
3964 cur = cur->parent;
3965 if (cur == NULL)
3966 break;
3967 if (cur == def)
3968 return (1);
3969 if (cur->next != NULL) {
3970 cur = cur->next;
3971 break;
3972 }
3973 } while (cur != NULL);
3974 }
3975 return (1);
3976}
3977
3978/**
3979 * xmlRelaxNGGetElements:
3980 * @ctxt: a Relax-NG parser context
3981 * @def: the definition definition
3982 * @eora: gather elements (0) or attributes (1)
3983 *
3984 * Compute the list of top elements a definition can generate
3985 *
3986 * Returns a list of elements or NULL if none was found.
3987 */
3988static xmlRelaxNGDefinePtr *
3989xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
3990 xmlRelaxNGDefinePtr def, int eora)
3991{
3992 xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
3993 int len = 0;
3994 int max = 0;
3995
3996 /*
3997 * Don't run that check in case of error. Infinite recursion
3998 * becomes possible.
3999 */
4000 if (ctxt->nbErrors != 0)
4001 return (NULL);
4002
4003 parent = NULL;
4004 cur = def;
4005 while (cur != NULL) {
4006 if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) ||
4007 (cur->type == XML_RELAXNG_TEXT))) ||
4008 ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) {
4009 if (ret == NULL) {
4010 max = 10;
4011 ret = (xmlRelaxNGDefinePtr *)
4012 xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr));
4013 if (ret == NULL) {
4014 xmlRngPErrMemory(ctxt, "getting element list\n");
4015 return (NULL);
4016 }
4017 } else if (max <= len) {
4018 xmlRelaxNGDefinePtr *temp;
4019
4020 max *= 2;
4021 temp = xmlRealloc(ret,
4022 (max + 1) * sizeof(xmlRelaxNGDefinePtr));
4023 if (temp == NULL) {
4024 xmlRngPErrMemory(ctxt, "getting element list\n");
4025 xmlFree(ret);
4026 return (NULL);
4027 }
4028 ret = temp;
4029 }
4030 ret[len++] = cur;
4031 ret[len] = NULL;
4032 } else if ((cur->type == XML_RELAXNG_CHOICE) ||
4033 (cur->type == XML_RELAXNG_INTERLEAVE) ||
4034 (cur->type == XML_RELAXNG_GROUP) ||
4035 (cur->type == XML_RELAXNG_ONEORMORE) ||
4036 (cur->type == XML_RELAXNG_ZEROORMORE) ||
4037 (cur->type == XML_RELAXNG_OPTIONAL) ||
4038 (cur->type == XML_RELAXNG_PARENTREF) ||
4039 (cur->type == XML_RELAXNG_REF) ||
4040 (cur->type == XML_RELAXNG_DEF) ||
4041 (cur->type == XML_RELAXNG_EXTERNALREF)) {
4042 /*
4043 * Don't go within elements or attributes or string values.
4044 * Just gather the element top list
4045 */
4046 if (cur->content != NULL) {
4047 parent = cur;
4048 cur = cur->content;
4049 tmp = cur;
4050 while (tmp != NULL) {
4051 tmp->parent = parent;
4052 tmp = tmp->next;
4053 }
4054 continue;
4055 }
4056 }
4057 if (cur == def)
4058 break;
4059 if (cur->next != NULL) {
4060 cur = cur->next;
4061 continue;
4062 }
4063 do {
4064 cur = cur->parent;
4065 if (cur == NULL)
4066 break;
4067 if (cur == def)
4068 return (ret);
4069 if (cur->next != NULL) {
4070 cur = cur->next;
4071 break;
4072 }
4073 } while (cur != NULL);
4074 }
4075 return (ret);
4076}
4077
4078/**
4079 * xmlRelaxNGCheckChoiceDeterminism:
4080 * @ctxt: a Relax-NG parser context
4081 * @def: the choice definition
4082 *
4083 * Also used to find indeterministic pattern in choice
4084 */
4085static void
4086xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
4087 xmlRelaxNGDefinePtr def)
4088{
4089 xmlRelaxNGDefinePtr **list;
4090 xmlRelaxNGDefinePtr cur;
4091 int nbchild = 0, i, j, ret;
4092 int is_nullable = 0;
4093 int is_indeterminist = 0;
4094 xmlHashTablePtr triage = NULL;
4095 int is_triable = 1;
4096
4097 if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
4098 return;
4099
4100 if (def->dflags & IS_PROCESSED)
4101 return;
4102
4103 /*
4104 * Don't run that check in case of error. Infinite recursion
4105 * becomes possible.
4106 */
4107 if (ctxt->nbErrors != 0)
4108 return;
4109
4110 is_nullable = xmlRelaxNGIsNullable(def);
4111
4112 cur = def->content;
4113 while (cur != NULL) {
4114 nbchild++;
4115 cur = cur->next;
4116 }
4117
4118 list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
4119 sizeof(xmlRelaxNGDefinePtr
4120 *));
4121 if (list == NULL) {
4122 xmlRngPErrMemory(ctxt, "building choice\n");
4123 return;
4124 }
4125 i = 0;
4126 /*
4127 * a bit strong but safe
4128 */
4129 if (is_nullable == 0) {
4130 triage = xmlHashCreate(10);
4131 } else {
4132 is_triable = 0;
4133 }
4134 cur = def->content;
4135 while (cur != NULL) {
4136 list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
4137 if ((list[i] == NULL) || (list[i][0] == NULL)) {
4138 is_triable = 0;
4139 } else if (is_triable == 1) {
4140 xmlRelaxNGDefinePtr *tmp;
4141 int res;
4142
4143 tmp = list[i];
4144 while ((*tmp != NULL) && (is_triable == 1)) {
4145 if ((*tmp)->type == XML_RELAXNG_TEXT) {
4146 res = xmlHashAddEntry2(triage,
4147 BAD_CAST "#text", NULL,
4148 (void *) cur);
4149 if (res != 0)
4150 is_triable = -1;
4151 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
4152 ((*tmp)->name != NULL)) {
4153 if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4154 res = xmlHashAddEntry2(triage,
4155 (*tmp)->name, NULL,
4156 (void *) cur);
4157 else
4158 res = xmlHashAddEntry2(triage,
4159 (*tmp)->name, (*tmp)->ns,
4160 (void *) cur);
4161 if (res != 0)
4162 is_triable = -1;
4163 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
4164 if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4165 res = xmlHashAddEntry2(triage,
4166 BAD_CAST "#any", NULL,
4167 (void *) cur);
4168 else
4169 res = xmlHashAddEntry2(triage,
4170 BAD_CAST "#any", (*tmp)->ns,
4171 (void *) cur);
4172 if (res != 0)
4173 is_triable = -1;
4174 } else {
4175 is_triable = -1;
4176 }
4177 tmp++;
4178 }
4179 }
4180 i++;
4181 cur = cur->next;
4182 }
4183
4184 for (i = 0; i < nbchild; i++) {
4185 if (list[i] == NULL)
4186 continue;
4187 for (j = 0; j < i; j++) {
4188 if (list[j] == NULL)
4189 continue;
4190 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4191 if (ret == 0) {
4192 is_indeterminist = 1;
4193 }
4194 }
4195 }
4196 for (i = 0; i < nbchild; i++) {
4197 if (list[i] != NULL)
4198 xmlFree(list[i]);
4199 }
4200
4201 xmlFree(list);
4202 if (is_indeterminist) {
4203 def->dflags |= IS_INDETERMINIST;
4204 }
4205 if (is_triable == 1) {
4206 def->dflags |= IS_TRIABLE;
4207 def->data = triage;
4208 } else if (triage != NULL) {
4209 xmlHashFree(triage, NULL);
4210 }
4211 def->dflags |= IS_PROCESSED;
4212}
4213
4214/**
4215 * xmlRelaxNGCheckGroupAttrs:
4216 * @ctxt: a Relax-NG parser context
4217 * @def: the group definition
4218 *
4219 * Detects violations of rule 7.3
4220 */
4221static void
4222xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
4223 xmlRelaxNGDefinePtr def)
4224{
4225 xmlRelaxNGDefinePtr **list;
4226 xmlRelaxNGDefinePtr cur;
4227 int nbchild = 0, i, j, ret;
4228
4229 if ((def == NULL) ||
4230 ((def->type != XML_RELAXNG_GROUP) &&
4231 (def->type != XML_RELAXNG_ELEMENT)))
4232 return;
4233
4234 if (def->dflags & IS_PROCESSED)
4235 return;
4236
4237 /*
4238 * Don't run that check in case of error. Infinite recursion
4239 * becomes possible.
4240 */
4241 if (ctxt->nbErrors != 0)
4242 return;
4243
4244 cur = def->attrs;
4245 while (cur != NULL) {
4246 nbchild++;
4247 cur = cur->next;
4248 }
4249 cur = def->content;
4250 while (cur != NULL) {
4251 nbchild++;
4252 cur = cur->next;
4253 }
4254
4255 list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
4256 sizeof(xmlRelaxNGDefinePtr
4257 *));
4258 if (list == NULL) {
4259 xmlRngPErrMemory(ctxt, "building group\n");
4260 return;
4261 }
4262 i = 0;
4263 cur = def->attrs;
4264 while (cur != NULL) {
4265 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4266 i++;
4267 cur = cur->next;
4268 }
4269 cur = def->content;
4270 while (cur != NULL) {
4271 list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
4272 i++;
4273 cur = cur->next;
4274 }
4275
4276 for (i = 0; i < nbchild; i++) {
4277 if (list[i] == NULL)
4278 continue;
4279 for (j = 0; j < i; j++) {
4280 if (list[j] == NULL)
4281 continue;
4282 ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
4283 if (ret == 0) {
4284 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
4285 "Attributes conflicts in group\n", NULL, NULL);
4286 }
4287 }
4288 }
4289 for (i = 0; i < nbchild; i++) {
4290 if (list[i] != NULL)
4291 xmlFree(list[i]);
4292 }
4293
4294 xmlFree(list);
4295 def->dflags |= IS_PROCESSED;
4296}
4297
4298/**
4299 * xmlRelaxNGComputeInterleaves:
4300 * @def: the interleave definition
4301 * @ctxt: a Relax-NG parser context
4302 * @name: the definition name
4303 *
4304 * A lot of work for preprocessing interleave definitions
4305 * is potentially needed to get a decent execution speed at runtime
4306 * - trying to get a total order on the element nodes generated
4307 * by the interleaves, order the list of interleave definitions
4308 * following that order.
4309 * - if <text/> is used to handle mixed content, it is better to
4310 * flag this in the define and simplify the runtime checking
4311 * algorithm
4312 */
4313static void
4314xmlRelaxNGComputeInterleaves(void *payload, void *data,
4315 const xmlChar * name ATTRIBUTE_UNUSED)
4316{
4317 xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
4318 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
4319 xmlRelaxNGDefinePtr cur, *tmp;
4320
4321 xmlRelaxNGPartitionPtr partitions = NULL;
4322 xmlRelaxNGInterleaveGroupPtr *groups = NULL;
4323 xmlRelaxNGInterleaveGroupPtr group;
4324 int i, j, ret, res;
4325 int nbgroups = 0;
4326 int nbchild = 0;
4327 int is_mixed = 0;
4328 int is_determinist = 1;
4329
4330 /*
4331 * Don't run that check in case of error. Infinite recursion
4332 * becomes possible.
4333 */
4334 if (ctxt->nbErrors != 0)
4335 return;
4336
4337#ifdef DEBUG_INTERLEAVE
4338 xmlGenericError(xmlGenericErrorContext,
4339 "xmlRelaxNGComputeInterleaves(%s)\n", name);
4340#endif
4341 cur = def->content;
4342 while (cur != NULL) {
4343 nbchild++;
4344 cur = cur->next;
4345 }
4346
4347#ifdef DEBUG_INTERLEAVE
4348 xmlGenericError(xmlGenericErrorContext, " %d child\n", nbchild);
4349#endif
4350 groups = (xmlRelaxNGInterleaveGroupPtr *)
4351 xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
4352 if (groups == NULL)
4353 goto error;
4354 cur = def->content;
4355 while (cur != NULL) {
4356 groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr)
4357 xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup));
4358 if (groups[nbgroups] == NULL)
4359 goto error;
4360 if (cur->type == XML_RELAXNG_TEXT)
4361 is_mixed++;
4362 groups[nbgroups]->rule = cur;
4363 groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
4364 groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
4365 nbgroups++;
4366 cur = cur->next;
4367 }
4368#ifdef DEBUG_INTERLEAVE
4369 xmlGenericError(xmlGenericErrorContext, " %d groups\n", nbgroups);
4370#endif
4371
4372 /*
4373 * Let's check that all rules makes a partitions according to 7.4
4374 */
4375 partitions = (xmlRelaxNGPartitionPtr)
4376 xmlMalloc(sizeof(xmlRelaxNGPartition));
4377 if (partitions == NULL)
4378 goto error;
4379 memset(partitions, 0, sizeof(xmlRelaxNGPartition));
4380 partitions->nbgroups = nbgroups;
4381 partitions->triage = xmlHashCreate(nbgroups);
4382 for (i = 0; i < nbgroups; i++) {
4383 group = groups[i];
4384 for (j = i + 1; j < nbgroups; j++) {
4385 if (groups[j] == NULL)
4386 continue;
4387
4388 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
4389 groups[j]->defs);
4390 if (ret == 0) {
4391 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
4392 "Element or text conflicts in interleave\n",
4393 NULL, NULL);
4394 }
4395 ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
4396 groups[j]->attrs);
4397 if (ret == 0) {
4398 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
4399 "Attributes conflicts in interleave\n", NULL,
4400 NULL);
4401 }
4402 }
4403 tmp = group->defs;
4404 if ((tmp != NULL) && (*tmp != NULL)) {
4405 while (*tmp != NULL) {
4406 if ((*tmp)->type == XML_RELAXNG_TEXT) {
4407 res = xmlHashAddEntry2(partitions->triage,
4408 BAD_CAST "#text", NULL,
4409 (void *) (ptrdiff_t) (i + 1));
4410 if (res != 0)
4411 is_determinist = -1;
4412 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
4413 ((*tmp)->name != NULL)) {
4414 if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4415 res = xmlHashAddEntry2(partitions->triage,
4416 (*tmp)->name, NULL,
4417 (void *) (ptrdiff_t) (i + 1));
4418 else
4419 res = xmlHashAddEntry2(partitions->triage,
4420 (*tmp)->name, (*tmp)->ns,
4421 (void *) (ptrdiff_t) (i + 1));
4422 if (res != 0)
4423 is_determinist = -1;
4424 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
4425 if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
4426 res = xmlHashAddEntry2(partitions->triage,
4427 BAD_CAST "#any", NULL,
4428 (void *) (ptrdiff_t) (i + 1));
4429 else
4430 res = xmlHashAddEntry2(partitions->triage,
4431 BAD_CAST "#any", (*tmp)->ns,
4432 (void *) (ptrdiff_t) (i + 1));
4433 if ((*tmp)->nameClass != NULL)
4434 is_determinist = 2;
4435 if (res != 0)
4436 is_determinist = -1;
4437 } else {
4438 is_determinist = -1;
4439 }
4440 tmp++;
4441 }
4442 } else {
4443 is_determinist = 0;
4444 }
4445 }
4446 partitions->groups = groups;
4447
4448 /*
4449 * and save the partition list back in the def
4450 */
4451 def->data = partitions;
4452 if (is_mixed != 0)
4453 def->dflags |= IS_MIXED;
4454 if (is_determinist == 1)
4455 partitions->flags = IS_DETERMINIST;
4456 if (is_determinist == 2)
4457 partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
4458 return;
4459
4460 error:
4461 xmlRngPErrMemory(ctxt, "in interleave computation\n");
4462 if (groups != NULL) {
4463 for (i = 0; i < nbgroups; i++)
4464 if (groups[i] != NULL) {
4465 if (groups[i]->defs != NULL)
4466 xmlFree(groups[i]->defs);
4467 xmlFree(groups[i]);
4468 }
4469 xmlFree(groups);
4470 }
4471 xmlRelaxNGFreePartition(partitions);
4472}
4473
4474/**
4475 * xmlRelaxNGParseInterleave:
4476 * @ctxt: a Relax-NG parser context
4477 * @node: the data node.
4478 *
4479 * parse the content of a RelaxNG interleave node.
4480 *
4481 * Returns the definition pointer or NULL in case of error
4482 */
4483static xmlRelaxNGDefinePtr
4484xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4485{
4486 xmlRelaxNGDefinePtr def = NULL;
4487 xmlRelaxNGDefinePtr last = NULL, cur;
4488 xmlNodePtr child;
4489
4490 def = xmlRelaxNGNewDefine(ctxt, node);
4491 if (def == NULL) {
4492 return (NULL);
4493 }
4494 def->type = XML_RELAXNG_INTERLEAVE;
4495
4496 if (ctxt->interleaves == NULL)
4497 ctxt->interleaves = xmlHashCreate(10);
4498 if (ctxt->interleaves == NULL) {
4499 xmlRngPErrMemory(ctxt, "create interleaves\n");
4500 } else {
4501 char name[32];
4502
4503 snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
4504 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
4505 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
4506 "Failed to add %s to hash table\n",
4507 (const xmlChar *) name, NULL);
4508 }
4509 }
4510 child = node->children;
4511 if (child == NULL) {
4512 xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
4513 "Element interleave is empty\n", NULL, NULL);
4514 }
4515 while (child != NULL) {
4516 if (IS_RELAXNG(child, "element")) {
4517 cur = xmlRelaxNGParseElement(ctxt, child);
4518 } else {
4519 cur = xmlRelaxNGParsePattern(ctxt, child);
4520 }
4521 if (cur != NULL) {
4522 cur->parent = def;
4523 if (last == NULL) {
4524 def->content = last = cur;
4525 } else {
4526 last->next = cur;
4527 last = cur;
4528 }
4529 }
4530 child = child->next;
4531 }
4532
4533 return (def);
4534}
4535
4536/**
4537 * xmlRelaxNGParseInclude:
4538 * @ctxt: a Relax-NG parser context
4539 * @node: the include node
4540 *
4541 * Integrate the content of an include node in the current grammar
4542 *
4543 * Returns 0 in case of success or -1 in case of error
4544 */
4545static int
4546xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4547{
4548 xmlRelaxNGIncludePtr incl;
4549 xmlNodePtr root;
4550 int ret = 0, tmp;
4551
4552 incl = node->psvi;
4553 if (incl == NULL) {
4554 xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
4555 "Include node has no data\n", NULL, NULL);
4556 return (-1);
4557 }
4558 root = xmlDocGetRootElement(incl->doc);
4559 if (root == NULL) {
4560 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
4561 NULL, NULL);
4562 return (-1);
4563 }
4564 if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
4565 xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
4566 "Include document root is not a grammar\n", NULL, NULL);
4567 return (-1);
4568 }
4569
4570 /*
4571 * Merge the definition from both the include and the internal list
4572 */
4573 if (root->children != NULL) {
4574 tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
4575 if (tmp != 0)
4576 ret = -1;
4577 }
4578 if (node->children != NULL) {
4579 tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
4580 if (tmp != 0)
4581 ret = -1;
4582 }
4583 return (ret);
4584}
4585
4586/**
4587 * xmlRelaxNGParseDefine:
4588 * @ctxt: a Relax-NG parser context
4589 * @node: the define node
4590 *
4591 * parse the content of a RelaxNG define element node.
4592 *
4593 * Returns 0 in case of success or -1 in case of error
4594 */
4595static int
4596xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4597{
4598 xmlChar *name;
4599 int ret = 0, tmp;
4600 xmlRelaxNGDefinePtr def;
4601 const xmlChar *olddefine;
4602
4603 name = xmlGetProp(node, BAD_CAST "name");
4604 if (name == NULL) {
4605 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
4606 "define has no name\n", NULL, NULL);
4607 } else {
4608 xmlRelaxNGNormExtSpace(name);
4609 if (xmlValidateNCName(name, 0)) {
4610 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
4611 "define name '%s' is not an NCName\n", name, NULL);
4612 }
4613 def = xmlRelaxNGNewDefine(ctxt, node);
4614 if (def == NULL) {
4615 xmlFree(name);
4616 return (-1);
4617 }
4618 def->type = XML_RELAXNG_DEF;
4619 def->name = name;
4620 if (node->children == NULL) {
4621 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
4622 "define has no children\n", NULL, NULL);
4623 } else {
4624 olddefine = ctxt->define;
4625 ctxt->define = name;
4626 def->content =
4627 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4628 ctxt->define = olddefine;
4629 }
4630 if (ctxt->grammar->defs == NULL)
4631 ctxt->grammar->defs = xmlHashCreate(10);
4632 if (ctxt->grammar->defs == NULL) {
4633 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4634 "Could not create definition hash\n", NULL, NULL);
4635 ret = -1;
4636 } else {
4637 tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
4638 if (tmp < 0) {
4639 xmlRelaxNGDefinePtr prev;
4640
4641 prev = xmlHashLookup(ctxt->grammar->defs, name);
4642 if (prev == NULL) {
4643 xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
4644 "Internal error on define aggregation of %s\n",
4645 name, NULL);
4646 ret = -1;
4647 } else {
4648 while (prev->nextHash != NULL)
4649 prev = prev->nextHash;
4650 prev->nextHash = def;
4651 }
4652 }
4653 }
4654 }
4655 return (ret);
4656}
4657
4658/**
4659 * xmlRelaxNGParseImportRef:
4660 * @payload: the parser context
4661 * @data: the current grammar
4662 * @name: the reference name
4663 *
4664 * Import import one references into the current grammar
4665 */
4666static void
4667xmlRelaxNGParseImportRef(void *payload, void *data, const xmlChar *name) {
4668 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
4669 xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
4670 int tmp;
4671
4672 def->dflags |= IS_EXTERNAL_REF;
4673
4674 tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def);
4675 if (tmp < 0) {
4676 xmlRelaxNGDefinePtr prev;
4677
4678 prev = (xmlRelaxNGDefinePtr)
4679 xmlHashLookup(ctxt->grammar->refs, def->name);
4680 if (prev == NULL) {
4681 if (def->name != NULL) {
4682 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4683 "Error refs definitions '%s'\n",
4684 def->name, NULL);
4685 } else {
4686 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4687 "Error refs definitions\n",
4688 NULL, NULL);
4689 }
4690 } else {
4691 def->nextHash = prev->nextHash;
4692 prev->nextHash = def;
4693 }
4694 }
4695}
4696
4697/**
4698 * xmlRelaxNGParseImportRefs:
4699 * @ctxt: the parser context
4700 * @grammar: the sub grammar
4701 *
4702 * Import references from the subgrammar into the current grammar
4703 *
4704 * Returns 0 in case of success, -1 in case of failure
4705 */
4706static int
4707xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt,
4708 xmlRelaxNGGrammarPtr grammar) {
4709 if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL))
4710 return(-1);
4711 if (grammar->refs == NULL)
4712 return(0);
4713 if (ctxt->grammar->refs == NULL)
4714 ctxt->grammar->refs = xmlHashCreate(10);
4715 if (ctxt->grammar->refs == NULL) {
4716 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
4717 "Could not create references hash\n", NULL, NULL);
4718 return(-1);
4719 }
4720 xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt);
4721 return(0);
4722}
4723
4724/**
4725 * xmlRelaxNGProcessExternalRef:
4726 * @ctxt: the parser context
4727 * @node: the externlRef node
4728 *
4729 * Process and compile an externlRef node
4730 *
4731 * Returns the xmlRelaxNGDefinePtr or NULL in case of error
4732 */
4733static xmlRelaxNGDefinePtr
4734xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4735{
4736 xmlRelaxNGDocumentPtr docu;
4737 xmlNodePtr root, tmp;
4738 xmlChar *ns;
4739 int newNs = 0, oldflags;
4740 xmlRelaxNGDefinePtr def;
4741
4742 docu = node->psvi;
4743 if (docu != NULL) {
4744 def = xmlRelaxNGNewDefine(ctxt, node);
4745 if (def == NULL)
4746 return (NULL);
4747 def->type = XML_RELAXNG_EXTERNALREF;
4748
4749 if (docu->content == NULL) {
4750 /*
4751 * Then do the parsing for good
4752 */
4753 root = xmlDocGetRootElement(docu->doc);
4754 if (root == NULL) {
4755 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
4756 "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
4757 NULL);
4758 return (NULL);
4759 }
4760 /*
4761 * ns transmission rules
4762 */
4763 ns = xmlGetProp(root, BAD_CAST "ns");
4764 if (ns == NULL) {
4765 tmp = node;
4766 while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) {
4767 ns = xmlGetProp(tmp, BAD_CAST "ns");
4768 if (ns != NULL) {
4769 break;
4770 }
4771 tmp = tmp->parent;
4772 }
4773 if (ns != NULL) {
4774 xmlSetProp(root, BAD_CAST "ns", ns);
4775 newNs = 1;
4776 xmlFree(ns);
4777 }
4778 } else {
4779 xmlFree(ns);
4780 }
4781
4782 /*
4783 * Parsing to get a precompiled schemas.
4784 */
4785 oldflags = ctxt->flags;
4786 ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
4787 docu->schema = xmlRelaxNGParseDocument(ctxt, root);
4788 ctxt->flags = oldflags;
4789 if ((docu->schema != NULL) &&
4790 (docu->schema->topgrammar != NULL)) {
4791 docu->content = docu->schema->topgrammar->start;
4792 if (docu->schema->topgrammar->refs)
4793 xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar);
4794 }
4795
4796 /*
4797 * the externalRef may be reused in a different ns context
4798 */
4799 if (newNs == 1) {
4800 xmlUnsetProp(root, BAD_CAST "ns");
4801 }
4802 }
4803 def->content = docu->content;
4804 } else {
4805 def = NULL;
4806 }
4807 return (def);
4808}
4809
4810/**
4811 * xmlRelaxNGParsePattern:
4812 * @ctxt: a Relax-NG parser context
4813 * @node: the pattern node.
4814 *
4815 * parse the content of a RelaxNG pattern node.
4816 *
4817 * Returns the definition pointer or NULL in case of error or if no
4818 * pattern is generated.
4819 */
4820static xmlRelaxNGDefinePtr
4821xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
4822{
4823 xmlRelaxNGDefinePtr def = NULL;
4824
4825 if (node == NULL) {
4826 return (NULL);
4827 }
4828 if (IS_RELAXNG(node, "element")) {
4829 def = xmlRelaxNGParseElement(ctxt, node);
4830 } else if (IS_RELAXNG(node, "attribute")) {
4831 def = xmlRelaxNGParseAttribute(ctxt, node);
4832 } else if (IS_RELAXNG(node, "empty")) {
4833 def = xmlRelaxNGNewDefine(ctxt, node);
4834 if (def == NULL)
4835 return (NULL);
4836 def->type = XML_RELAXNG_EMPTY;
4837 if (node->children != NULL) {
4838 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
4839 "empty: had a child node\n", NULL, NULL);
4840 }
4841 } else if (IS_RELAXNG(node, "text")) {
4842 def = xmlRelaxNGNewDefine(ctxt, node);
4843 if (def == NULL)
4844 return (NULL);
4845 def->type = XML_RELAXNG_TEXT;
4846 if (node->children != NULL) {
4847 xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
4848 "text: had a child node\n", NULL, NULL);
4849 }
4850 } else if (IS_RELAXNG(node, "zeroOrMore")) {
4851 def = xmlRelaxNGNewDefine(ctxt, node);
4852 if (def == NULL)
4853 return (NULL);
4854 def->type = XML_RELAXNG_ZEROORMORE;
4855 if (node->children == NULL) {
4856 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4857 "Element %s is empty\n", node->name, NULL);
4858 } else {
4859 def->content =
4860 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4861 }
4862 } else if (IS_RELAXNG(node, "oneOrMore")) {
4863 def = xmlRelaxNGNewDefine(ctxt, node);
4864 if (def == NULL)
4865 return (NULL);
4866 def->type = XML_RELAXNG_ONEORMORE;
4867 if (node->children == NULL) {
4868 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4869 "Element %s is empty\n", node->name, NULL);
4870 } else {
4871 def->content =
4872 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4873 }
4874 } else if (IS_RELAXNG(node, "optional")) {
4875 def = xmlRelaxNGNewDefine(ctxt, node);
4876 if (def == NULL)
4877 return (NULL);
4878 def->type = XML_RELAXNG_OPTIONAL;
4879 if (node->children == NULL) {
4880 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4881 "Element %s is empty\n", node->name, NULL);
4882 } else {
4883 def->content =
4884 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
4885 }
4886 } else if (IS_RELAXNG(node, "choice")) {
4887 def = xmlRelaxNGNewDefine(ctxt, node);
4888 if (def == NULL)
4889 return (NULL);
4890 def->type = XML_RELAXNG_CHOICE;
4891 if (node->children == NULL) {
4892 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4893 "Element %s is empty\n", node->name, NULL);
4894 } else {
4895 def->content =
4896 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4897 }
4898 } else if (IS_RELAXNG(node, "group")) {
4899 def = xmlRelaxNGNewDefine(ctxt, node);
4900 if (def == NULL)
4901 return (NULL);
4902 def->type = XML_RELAXNG_GROUP;
4903 if (node->children == NULL) {
4904 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4905 "Element %s is empty\n", node->name, NULL);
4906 } else {
4907 def->content =
4908 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4909 }
4910 } else if (IS_RELAXNG(node, "ref")) {
4911 def = xmlRelaxNGNewDefine(ctxt, node);
4912 if (def == NULL)
4913 return (NULL);
4914 def->type = XML_RELAXNG_REF;
4915 def->name = xmlGetProp(node, BAD_CAST "name");
4916 if (def->name == NULL) {
4917 xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
4918 NULL, NULL);
4919 } else {
4920 xmlRelaxNGNormExtSpace(def->name);
4921 if (xmlValidateNCName(def->name, 0)) {
4922 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
4923 "ref name '%s' is not an NCName\n", def->name,
4924 NULL);
4925 }
4926 }
4927 if (node->children != NULL) {
4928 xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
4929 NULL, NULL);
4930 }
4931 if (ctxt->grammar->refs == NULL)
4932 ctxt->grammar->refs = xmlHashCreate(10);
4933 if (ctxt->grammar->refs == NULL) {
4934 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4935 "Could not create references hash\n", NULL, NULL);
4936 def = NULL;
4937 } else {
4938 int tmp;
4939
4940 tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
4941 if (tmp < 0) {
4942 xmlRelaxNGDefinePtr prev;
4943
4944 prev = (xmlRelaxNGDefinePtr)
4945 xmlHashLookup(ctxt->grammar->refs, def->name);
4946 if (prev == NULL) {
4947 if (def->name != NULL) {
4948 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4949 "Error refs definitions '%s'\n",
4950 def->name, NULL);
4951 } else {
4952 xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
4953 "Error refs definitions\n",
4954 NULL, NULL);
4955 }
4956 def = NULL;
4957 } else {
4958 def->nextHash = prev->nextHash;
4959 prev->nextHash = def;
4960 }
4961 }
4962 }
4963 } else if (IS_RELAXNG(node, "data")) {
4964 def = xmlRelaxNGParseData(ctxt, node);
4965 } else if (IS_RELAXNG(node, "value")) {
4966 def = xmlRelaxNGParseValue(ctxt, node);
4967 } else if (IS_RELAXNG(node, "list")) {
4968 def = xmlRelaxNGNewDefine(ctxt, node);
4969 if (def == NULL)
4970 return (NULL);
4971 def->type = XML_RELAXNG_LIST;
4972 if (node->children == NULL) {
4973 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
4974 "Element %s is empty\n", node->name, NULL);
4975 } else {
4976 def->content =
4977 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
4978 }
4979 } else if (IS_RELAXNG(node, "interleave")) {
4980 def = xmlRelaxNGParseInterleave(ctxt, node);
4981 } else if (IS_RELAXNG(node, "externalRef")) {
4982 def = xmlRelaxNGProcessExternalRef(ctxt, node);
4983 } else if (IS_RELAXNG(node, "notAllowed")) {
4984 def = xmlRelaxNGNewDefine(ctxt, node);
4985 if (def == NULL)
4986 return (NULL);
4987 def->type = XML_RELAXNG_NOT_ALLOWED;
4988 if (node->children != NULL) {
4989 xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
4990 "xmlRelaxNGParse: notAllowed element is not empty\n",
4991 NULL, NULL);
4992 }
4993 } else if (IS_RELAXNG(node, "grammar")) {
4994 xmlRelaxNGGrammarPtr grammar, old;
4995 xmlRelaxNGGrammarPtr oldparent;
4996
4997#ifdef DEBUG_GRAMMAR
4998 xmlGenericError(xmlGenericErrorContext,
4999 "Found <grammar> pattern\n");
5000#endif
5001
5002 oldparent = ctxt->parentgrammar;
5003 old = ctxt->grammar;
5004 ctxt->parentgrammar = old;
5005 grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
5006 if (old != NULL) {
5007 ctxt->grammar = old;
5008 ctxt->parentgrammar = oldparent;
5009#if 0
5010 if (grammar != NULL) {
5011 grammar->next = old->next;
5012 old->next = grammar;
5013 }
5014#endif
5015 }
5016 if (grammar != NULL)
5017 def = grammar->start;
5018 else
5019 def = NULL;
5020 } else if (IS_RELAXNG(node, "parentRef")) {
5021 if (ctxt->parentgrammar == NULL) {
5022 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
5023 "Use of parentRef without a parent grammar\n", NULL,
5024 NULL);
5025 return (NULL);
5026 }
5027 def = xmlRelaxNGNewDefine(ctxt, node);
5028 if (def == NULL)
5029 return (NULL);
5030 def->type = XML_RELAXNG_PARENTREF;
5031 def->name = xmlGetProp(node, BAD_CAST "name");
5032 if (def->name == NULL) {
5033 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
5034 "parentRef has no name\n", NULL, NULL);
5035 } else {
5036 xmlRelaxNGNormExtSpace(def->name);
5037 if (xmlValidateNCName(def->name, 0)) {
5038 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
5039 "parentRef name '%s' is not an NCName\n",
5040 def->name, NULL);
5041 }
5042 }
5043 if (node->children != NULL) {
5044 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
5045 "parentRef is not empty\n", NULL, NULL);
5046 }
5047 if (ctxt->parentgrammar->refs == NULL)
5048 ctxt->parentgrammar->refs = xmlHashCreate(10);
5049 if (ctxt->parentgrammar->refs == NULL) {
5050 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5051 "Could not create references hash\n", NULL, NULL);
5052 def = NULL;
5053 } else if (def->name != NULL) {
5054 int tmp;
5055
5056 tmp =
5057 xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
5058 if (tmp < 0) {
5059 xmlRelaxNGDefinePtr prev;
5060
5061 prev = (xmlRelaxNGDefinePtr)
5062 xmlHashLookup(ctxt->parentgrammar->refs, def->name);
5063 if (prev == NULL) {
5064 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
5065 "Internal error parentRef definitions '%s'\n",
5066 def->name, NULL);
5067 def = NULL;
5068 } else {
5069 def->nextHash = prev->nextHash;
5070 prev->nextHash = def;
5071 }
5072 }
5073 }
5074 } else if (IS_RELAXNG(node, "mixed")) {
5075 if (node->children == NULL) {
5076 xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
5077 NULL, NULL);
5078 def = NULL;
5079 } else {
5080 def = xmlRelaxNGParseInterleave(ctxt, node);
5081 if (def != NULL) {
5082 xmlRelaxNGDefinePtr tmp;
5083
5084 if ((def->content != NULL) && (def->content->next != NULL)) {
5085 tmp = xmlRelaxNGNewDefine(ctxt, node);
5086 if (tmp != NULL) {
5087 tmp->type = XML_RELAXNG_GROUP;
5088 tmp->content = def->content;
5089 def->content = tmp;
5090 }
5091 }
5092
5093 tmp = xmlRelaxNGNewDefine(ctxt, node);
5094 if (tmp == NULL)
5095 return (def);
5096 tmp->type = XML_RELAXNG_TEXT;
5097 tmp->next = def->content;
5098 def->content = tmp;
5099 }
5100 }
5101 } else {
5102 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
5103 "Unexpected node %s is not a pattern\n", node->name,
5104 NULL);
5105 def = NULL;
5106 }
5107 return (def);
5108}
5109
5110/**
5111 * xmlRelaxNGParseAttribute:
5112 * @ctxt: a Relax-NG parser context
5113 * @node: the element node
5114 *
5115 * parse the content of a RelaxNG attribute node.
5116 *
5117 * Returns the definition pointer or NULL in case of error.
5118 */
5119static xmlRelaxNGDefinePtr
5120xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5121{
5122 xmlRelaxNGDefinePtr ret, cur;
5123 xmlNodePtr child;
5124 int old_flags;
5125
5126 ret = xmlRelaxNGNewDefine(ctxt, node);
5127 if (ret == NULL)
5128 return (NULL);
5129 ret->type = XML_RELAXNG_ATTRIBUTE;
5130 ret->parent = ctxt->def;
5131 child = node->children;
5132 if (child == NULL) {
5133 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
5134 "xmlRelaxNGParseattribute: attribute has no children\n",
5135 NULL, NULL);
5136 return (ret);
5137 }
5138 old_flags = ctxt->flags;
5139 ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
5140 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5141 if (cur != NULL)
5142 child = child->next;
5143
5144 if (child != NULL) {
5145 cur = xmlRelaxNGParsePattern(ctxt, child);
5146 if (cur != NULL) {
5147 switch (cur->type) {
5148 case XML_RELAXNG_EMPTY:
5149 case XML_RELAXNG_NOT_ALLOWED:
5150 case XML_RELAXNG_TEXT:
5151 case XML_RELAXNG_ELEMENT:
5152 case XML_RELAXNG_DATATYPE:
5153 case XML_RELAXNG_VALUE:
5154 case XML_RELAXNG_LIST:
5155 case XML_RELAXNG_REF:
5156 case XML_RELAXNG_PARENTREF:
5157 case XML_RELAXNG_EXTERNALREF:
5158 case XML_RELAXNG_DEF:
5159 case XML_RELAXNG_ONEORMORE:
5160 case XML_RELAXNG_ZEROORMORE:
5161 case XML_RELAXNG_OPTIONAL:
5162 case XML_RELAXNG_CHOICE:
5163 case XML_RELAXNG_GROUP:
5164 case XML_RELAXNG_INTERLEAVE:
5165 case XML_RELAXNG_ATTRIBUTE:
5166 ret->content = cur;
5167 cur->parent = ret;
5168 break;
5169 case XML_RELAXNG_START:
5170 case XML_RELAXNG_PARAM:
5171 case XML_RELAXNG_EXCEPT:
5172 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
5173 "attribute has invalid content\n", NULL,
5174 NULL);
5175 break;
5176 case XML_RELAXNG_NOOP:
5177 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
5178 "RNG Internal error, noop found in attribute\n",
5179 NULL, NULL);
5180 break;
5181 }
5182 }
5183 child = child->next;
5184 }
5185 if (child != NULL) {
5186 xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
5187 "attribute has multiple children\n", NULL, NULL);
5188 }
5189 ctxt->flags = old_flags;
5190 return (ret);
5191}
5192
5193/**
5194 * xmlRelaxNGParseExceptNameClass:
5195 * @ctxt: a Relax-NG parser context
5196 * @node: the except node
5197 * @attr: 1 if within an attribute, 0 if within an element
5198 *
5199 * parse the content of a RelaxNG nameClass node.
5200 *
5201 * Returns the definition pointer or NULL in case of error.
5202 */
5203static xmlRelaxNGDefinePtr
5204xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
5205 xmlNodePtr node, int attr)
5206{
5207 xmlRelaxNGDefinePtr ret, cur, last = NULL;
5208 xmlNodePtr child;
5209
5210 if (!IS_RELAXNG(node, "except")) {
5211 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
5212 "Expecting an except node\n", NULL, NULL);
5213 return (NULL);
5214 }
5215 if (node->next != NULL) {
5216 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
5217 "exceptNameClass allows only a single except node\n",
5218 NULL, NULL);
5219 }
5220 if (node->children == NULL) {
5221 xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
5222 NULL, NULL);
5223 return (NULL);
5224 }
5225
5226 ret = xmlRelaxNGNewDefine(ctxt, node);
5227 if (ret == NULL)
5228 return (NULL);
5229 ret->type = XML_RELAXNG_EXCEPT;
5230 child = node->children;
5231 while (child != NULL) {
5232 cur = xmlRelaxNGNewDefine(ctxt, child);
5233 if (cur == NULL)
5234 break;
5235 if (attr)
5236 cur->type = XML_RELAXNG_ATTRIBUTE;
5237 else
5238 cur->type = XML_RELAXNG_ELEMENT;
5239
5240 if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
5241 if (last == NULL) {
5242 ret->content = cur;
5243 } else {
5244 last->next = cur;
5245 }
5246 last = cur;
5247 }
5248 child = child->next;
5249 }
5250
5251 return (ret);
5252}
5253
5254/**
5255 * xmlRelaxNGParseNameClass:
5256 * @ctxt: a Relax-NG parser context
5257 * @node: the nameClass node
5258 * @def: the current definition
5259 *
5260 * parse the content of a RelaxNG nameClass node.
5261 *
5262 * Returns the definition pointer or NULL in case of error.
5263 */
5264static xmlRelaxNGDefinePtr
5265xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
5266 xmlRelaxNGDefinePtr def)
5267{
5268 xmlRelaxNGDefinePtr ret, tmp;
5269 xmlChar *val;
5270
5271 ret = def;
5272 if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
5273 (IS_RELAXNG(node, "nsName"))) {
5274 if ((def->type != XML_RELAXNG_ELEMENT) &&
5275 (def->type != XML_RELAXNG_ATTRIBUTE)) {
5276 ret = xmlRelaxNGNewDefine(ctxt, node);
5277 if (ret == NULL)
5278 return (NULL);
5279 ret->parent = def;
5280 if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
5281 ret->type = XML_RELAXNG_ATTRIBUTE;
5282 else
5283 ret->type = XML_RELAXNG_ELEMENT;
5284 }
5285 }
5286 if (IS_RELAXNG(node, "name")) {
5287 val = xmlNodeGetContent(node);
5288 xmlRelaxNGNormExtSpace(val);
5289 if (xmlValidateNCName(val, 0)) {
5290 if (node->parent != NULL)
5291 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5292 "Element %s name '%s' is not an NCName\n",
5293 node->parent->name, val);
5294 else
5295 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
5296 "name '%s' is not an NCName\n",
5297 val, NULL);
5298 }
5299 ret->name = val;
5300 val = xmlGetProp(node, BAD_CAST "ns");
5301 ret->ns = val;
5302 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5303 (val != NULL) &&
5304 (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
5305 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5306 "Attribute with namespace '%s' is not allowed\n",
5307 val, NULL);
5308 }
5309 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5310 (val != NULL) &&
5311 (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
5312 xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
5313 "Attribute with QName 'xmlns' is not allowed\n",
5314 val, NULL);
5315 }
5316 } else if (IS_RELAXNG(node, "anyName")) {
5317 ret->name = NULL;
5318 ret->ns = NULL;
5319 if (node->children != NULL) {
5320 ret->nameClass =
5321 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5322 (def->type ==
5323 XML_RELAXNG_ATTRIBUTE));
5324 }
5325 } else if (IS_RELAXNG(node, "nsName")) {
5326 ret->name = NULL;
5327 ret->ns = xmlGetProp(node, BAD_CAST "ns");
5328 if (ret->ns == NULL) {
5329 xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
5330 "nsName has no ns attribute\n", NULL, NULL);
5331 }
5332 if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
5333 (ret->ns != NULL) &&
5334 (xmlStrEqual
5335 (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
5336 xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
5337 "Attribute with namespace '%s' is not allowed\n",
5338 ret->ns, NULL);
5339 }
5340 if (node->children != NULL) {
5341 ret->nameClass =
5342 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
5343 (def->type ==
5344 XML_RELAXNG_ATTRIBUTE));
5345 }
5346 } else if (IS_RELAXNG(node, "choice")) {
5347 xmlNodePtr child;
5348 xmlRelaxNGDefinePtr last = NULL;
5349
5350 ret = xmlRelaxNGNewDefine(ctxt, node);
5351 if (ret == NULL)
5352 return (NULL);
5353 ret->parent = def;
5354 ret->type = XML_RELAXNG_CHOICE;
5355
5356 if (node->children == NULL) {
5357 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
5358 "Element choice is empty\n", NULL, NULL);
5359 } else {
5360
5361 child = node->children;
5362 while (child != NULL) {
5363 tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
5364 if (tmp != NULL) {
5365 if (last == NULL) {
5366 last = ret->nameClass = tmp;
5367 } else {
5368 last->next = tmp;
5369 last = tmp;
5370 }
5371 }
5372 child = child->next;
5373 }
5374 }
5375 } else {
5376 xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
5377 "expecting name, anyName, nsName or choice : got %s\n",
5378 (node == NULL ? (const xmlChar *) "nothing" : node->name),
5379 NULL);
5380 return (NULL);
5381 }
5382 if (ret != def) {
5383 if (def->nameClass == NULL) {
5384 def->nameClass = ret;
5385 } else {
5386 tmp = def->nameClass;
5387 while (tmp->next != NULL) {
5388 tmp = tmp->next;
5389 }
5390 tmp->next = ret;
5391 }
5392 }
5393 return (ret);
5394}
5395
5396/**
5397 * xmlRelaxNGParseElement:
5398 * @ctxt: a Relax-NG parser context
5399 * @node: the element node
5400 *
5401 * parse the content of a RelaxNG element node.
5402 *
5403 * Returns the definition pointer or NULL in case of error.
5404 */
5405static xmlRelaxNGDefinePtr
5406xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
5407{
5408 xmlRelaxNGDefinePtr ret, cur, last;
5409 xmlNodePtr child;
5410 const xmlChar *olddefine;
5411
5412 ret = xmlRelaxNGNewDefine(ctxt, node);
5413 if (ret == NULL)
5414 return (NULL);
5415 ret->type = XML_RELAXNG_ELEMENT;
5416 ret->parent = ctxt->def;
5417 child = node->children;
5418 if (child == NULL) {
5419 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
5420 "xmlRelaxNGParseElement: element has no children\n",
5421 NULL, NULL);
5422 return (ret);
5423 }
5424 cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
5425 if (cur != NULL)
5426 child = child->next;
5427
5428 if (child == NULL) {
5429 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
5430 "xmlRelaxNGParseElement: element has no content\n",
5431 NULL, NULL);
5432 return (ret);
5433 }
5434 olddefine = ctxt->define;
5435 ctxt->define = NULL;
5436 last = NULL;
5437 while (child != NULL) {
5438 cur = xmlRelaxNGParsePattern(ctxt, child);
5439 if (cur != NULL) {
5440 cur->parent = ret;
5441 switch (cur->type) {
5442 case XML_RELAXNG_EMPTY:
5443 case XML_RELAXNG_NOT_ALLOWED:
5444 case XML_RELAXNG_TEXT:
5445 case XML_RELAXNG_ELEMENT:
5446 case XML_RELAXNG_DATATYPE:
5447 case XML_RELAXNG_VALUE:
5448 case XML_RELAXNG_LIST:
5449 case XML_RELAXNG_REF:
5450 case XML_RELAXNG_PARENTREF:
5451 case XML_RELAXNG_EXTERNALREF:
5452 case XML_RELAXNG_DEF:
5453 case XML_RELAXNG_ZEROORMORE:
5454 case XML_RELAXNG_ONEORMORE:
5455 case XML_RELAXNG_OPTIONAL:
5456 case XML_RELAXNG_CHOICE:
5457 case XML_RELAXNG_GROUP:
5458 case XML_RELAXNG_INTERLEAVE:
5459 if (last == NULL) {
5460 ret->content = last = cur;
5461 } else {
5462 if ((last->type == XML_RELAXNG_ELEMENT) &&
5463 (ret->content == last)) {
5464 ret->content = xmlRelaxNGNewDefine(ctxt, node);
5465 if (ret->content != NULL) {
5466 ret->content->type = XML_RELAXNG_GROUP;
5467 ret->content->content = last;
5468 } else {
5469 ret->content = last;
5470 }
5471 }
5472 last->next = cur;
5473 last = cur;
5474 }
5475 break;
5476 case XML_RELAXNG_ATTRIBUTE:
5477 cur->next = ret->attrs;
5478 ret->attrs = cur;
5479 break;
5480 case XML_RELAXNG_START:
5481 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5482 "RNG Internal error, start found in element\n",
5483 NULL, NULL);
5484 break;
5485 case XML_RELAXNG_PARAM:
5486 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5487 "RNG Internal error, param found in element\n",
5488 NULL, NULL);
5489 break;
5490 case XML_RELAXNG_EXCEPT:
5491 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5492 "RNG Internal error, except found in element\n",
5493 NULL, NULL);
5494 break;
5495 case XML_RELAXNG_NOOP:
5496 xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
5497 "RNG Internal error, noop found in element\n",
5498 NULL, NULL);
5499 break;
5500 }
5501 }
5502 child = child->next;
5503 }
5504 ctxt->define = olddefine;
5505 return (ret);
5506}
5507
5508/**
5509 * xmlRelaxNGParsePatterns:
5510 * @ctxt: a Relax-NG parser context
5511 * @nodes: list of nodes
5512 * @group: use an implicit <group> for elements
5513 *
5514 * parse the content of a RelaxNG start node.
5515 *
5516 * Returns the definition pointer or NULL in case of error.
5517 */
5518static xmlRelaxNGDefinePtr
5519xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
5520 int group)
5521{
5522 xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent;
5523
5524 parent = ctxt->def;
5525 while (nodes != NULL) {
5526 if (IS_RELAXNG(nodes, "element")) {
5527 cur = xmlRelaxNGParseElement(ctxt, nodes);
5528 if (def == NULL) {
5529 def = last = cur;
5530 } else {
5531 if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) &&
5532 (def == last)) {
5533 def = xmlRelaxNGNewDefine(ctxt, nodes);
5534 def->type = XML_RELAXNG_GROUP;
5535 def->content = last;
5536 }
5537 last->next = cur;
5538 last = cur;
5539 }
5540 cur->parent = parent;
5541 } else {
5542 cur = xmlRelaxNGParsePattern(ctxt, nodes);
5543 if (cur != NULL) {
5544 if (def == NULL) {
5545 def = last = cur;
5546 } else {
5547 last->next = cur;
5548 last = cur;
5549 }
5550 }
5551 }
5552 nodes = nodes->next;
5553 }
5554 return (def);
5555}
5556
5557/**
5558 * xmlRelaxNGParseStart:
5559 * @ctxt: a Relax-NG parser context
5560 * @nodes: start children nodes
5561 *
5562 * parse the content of a RelaxNG start node.
5563 *
5564 * Returns 0 in case of success, -1 in case of error
5565 */
5566static int
5567xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
5568{
5569 int ret = 0;
5570 xmlRelaxNGDefinePtr def = NULL, last;
5571
5572 if (nodes == NULL) {
5573 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
5574 NULL, NULL);
5575 return (-1);
5576 }
5577 if (IS_RELAXNG(nodes, "empty")) {
5578 def = xmlRelaxNGNewDefine(ctxt, nodes);
5579 if (def == NULL)
5580 return (-1);
5581 def->type = XML_RELAXNG_EMPTY;
5582 if (nodes->children != NULL) {
5583 xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
5584 "element empty is not empty\n", NULL, NULL);
5585 }
5586 } else if (IS_RELAXNG(nodes, "notAllowed")) {
5587 def = xmlRelaxNGNewDefine(ctxt, nodes);
5588 if (def == NULL)
5589 return (-1);
5590 def->type = XML_RELAXNG_NOT_ALLOWED;
5591 if (nodes->children != NULL) {
5592 xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
5593 "element notAllowed is not empty\n", NULL, NULL);
5594 }
5595 } else {
5596 def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
5597 }
5598 if (ctxt->grammar->start != NULL) {
5599 last = ctxt->grammar->start;
5600 while (last->next != NULL)
5601 last = last->next;
5602 last->next = def;
5603 } else {
5604 ctxt->grammar->start = def;
5605 }
5606 nodes = nodes->next;
5607 if (nodes != NULL) {
5608 xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
5609 "start more than one children\n", NULL, NULL);
5610 return (-1);
5611 }
5612 return (ret);
5613}
5614
5615/**
5616 * xmlRelaxNGParseGrammarContent:
5617 * @ctxt: a Relax-NG parser context
5618 * @nodes: grammar children nodes
5619 *
5620 * parse the content of a RelaxNG grammar node.
5621 *
5622 * Returns 0 in case of success, -1 in case of error
5623 */
5624static int
5625xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
5626 xmlNodePtr nodes)
5627{
5628 int ret = 0, tmp;
5629
5630 if (nodes == NULL) {
5631 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
5632 "grammar has no children\n", NULL, NULL);
5633 return (-1);
5634 }
5635 while (nodes != NULL) {
5636 if (IS_RELAXNG(nodes, "start")) {
5637 if (nodes->children == NULL) {
5638 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
5639 "start has no children\n", NULL, NULL);
5640 } else {
5641 tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
5642 if (tmp != 0)
5643 ret = -1;
5644 }
5645 } else if (IS_RELAXNG(nodes, "define")) {
5646 tmp = xmlRelaxNGParseDefine(ctxt, nodes);
5647 if (tmp != 0)
5648 ret = -1;
5649 } else if (IS_RELAXNG(nodes, "include")) {
5650 tmp = xmlRelaxNGParseInclude(ctxt, nodes);
5651 if (tmp != 0)
5652 ret = -1;
5653 } else {
5654 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
5655 "grammar has unexpected child %s\n", nodes->name,
5656 NULL);
5657 ret = -1;
5658 }
5659 nodes = nodes->next;
5660 }
5661 return (ret);
5662}
5663
5664/**
5665 * xmlRelaxNGCheckReference:
5666 * @ref: the ref
5667 * @ctxt: a Relax-NG parser context
5668 * @name: the name associated to the defines
5669 *
5670 * Applies the 4.17. combine attribute rule for all the define
5671 * element of a given grammar using the same name.
5672 */
5673static void
5674xmlRelaxNGCheckReference(void *payload, void *data, const xmlChar * name)
5675{
5676 xmlRelaxNGDefinePtr ref = (xmlRelaxNGDefinePtr) payload;
5677 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
5678 xmlRelaxNGGrammarPtr grammar;
5679 xmlRelaxNGDefinePtr def, cur;
5680
5681 /*
5682 * Those rules don't apply to imported ref from xmlRelaxNGParseImportRef
5683 */
5684 if (ref->dflags & IS_EXTERNAL_REF)
5685 return;
5686
5687 grammar = ctxt->grammar;
5688 if (grammar == NULL) {
5689 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5690 "Internal error: no grammar in CheckReference %s\n",
5691 name, NULL);
5692 return;
5693 }
5694 if (ref->content != NULL) {
5695 xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
5696 "Internal error: reference has content in CheckReference %s\n",
5697 name, NULL);
5698 return;
5699 }
5700 if (grammar->defs != NULL) {
5701 def = xmlHashLookup(grammar->defs, name);
5702 if (def != NULL) {
5703 cur = ref;
5704 while (cur != NULL) {
5705 cur->content = def;
5706 cur = cur->nextHash;
5707 }
5708 } else {
5709 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5710 "Reference %s has no matching definition\n", name,
5711 NULL);
5712 }
5713 } else {
5714 xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
5715 "Reference %s has no matching definition\n", name,
5716 NULL);
5717 }
5718}
5719
5720/**
5721 * xmlRelaxNGCheckCombine:
5722 * @define: the define(s) list
5723 * @ctxt: a Relax-NG parser context
5724 * @name: the name associated to the defines
5725 *
5726 * Applies the 4.17. combine attribute rule for all the define
5727 * element of a given grammar using the same name.
5728 */
5729static void
5730xmlRelaxNGCheckCombine(void *payload, void *data, const xmlChar * name)
5731{
5732 xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) payload;
5733 xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
5734 xmlChar *combine;
5735 int choiceOrInterleave = -1;
5736 int missing = 0;
5737 xmlRelaxNGDefinePtr cur, last, tmp, tmp2;
5738
5739 if (define->nextHash == NULL)
5740 return;
5741 cur = define;
5742 while (cur != NULL) {
5743 combine = xmlGetProp(cur->node, BAD_CAST "combine");
5744 if (combine != NULL) {
5745 if (xmlStrEqual(combine, BAD_CAST "choice")) {
5746 if (choiceOrInterleave == -1)
5747 choiceOrInterleave = 1;
5748 else if (choiceOrInterleave == 0) {
5749 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5750 "Defines for %s use both 'choice' and 'interleave'\n",
5751 name, NULL);
5752 }
5753 } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
5754 if (choiceOrInterleave == -1)
5755 choiceOrInterleave = 0;
5756 else if (choiceOrInterleave == 1) {
5757 xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
5758 "Defines for %s use both 'choice' and 'interleave'\n",
5759 name, NULL);
5760 }
5761 } else {
5762 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
5763 "Defines for %s use unknown combine value '%s''\n",
5764 name, combine);
5765 }
5766 xmlFree(combine);
5767 } else {
5768 if (missing == 0)
5769 missing = 1;
5770 else {
5771 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
5772 "Some defines for %s needs the combine attribute\n",
5773 name, NULL);
5774 }
5775 }
5776
5777 cur = cur->nextHash;
5778 }
5779#ifdef DEBUG
5780 xmlGenericError(xmlGenericErrorContext,
5781 "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
5782 name, choiceOrInterleave);
5783#endif
5784 if (choiceOrInterleave == -1)
5785 choiceOrInterleave = 0;
5786 cur = xmlRelaxNGNewDefine(ctxt, define->node);
5787 if (cur == NULL)
5788 return;
5789 if (choiceOrInterleave == 0)
5790 cur->type = XML_RELAXNG_INTERLEAVE;
5791 else
5792 cur->type = XML_RELAXNG_CHOICE;
5793 tmp = define;
5794 last = NULL;
5795 while (tmp != NULL) {
5796 if (tmp->content != NULL) {
5797 if (tmp->content->next != NULL) {
5798 /*
5799 * we need first to create a wrapper.
5800 */
5801 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
5802 if (tmp2 == NULL)
5803 break;
5804 tmp2->type = XML_RELAXNG_GROUP;
5805 tmp2->content = tmp->content;
5806 } else {
5807 tmp2 = tmp->content;
5808 }
5809 if (last == NULL) {
5810 cur->content = tmp2;
5811 } else {
5812 last->next = tmp2;
5813 }
5814 last = tmp2;
5815 }
5816 tmp->content = cur;
5817 tmp = tmp->nextHash;
5818 }
5819 define->content = cur;
5820 if (choiceOrInterleave == 0) {
5821 if (ctxt->interleaves == NULL)
5822 ctxt->interleaves = xmlHashCreate(10);
5823 if (ctxt->interleaves == NULL) {
5824 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5825 "Failed to create interleaves hash table\n", NULL,
5826 NULL);
5827 } else {
5828 char tmpname[32];
5829
5830 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5831 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5832 0) {
5833 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5834 "Failed to add %s to hash table\n",
5835 (const xmlChar *) tmpname, NULL);
5836 }
5837 }
5838 }
5839}
5840
5841/**
5842 * xmlRelaxNGCombineStart:
5843 * @ctxt: a Relax-NG parser context
5844 * @grammar: the grammar
5845 *
5846 * Applies the 4.17. combine rule for all the start
5847 * element of a given grammar.
5848 */
5849static void
5850xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
5851 xmlRelaxNGGrammarPtr grammar)
5852{
5853 xmlRelaxNGDefinePtr starts;
5854 xmlChar *combine;
5855 int choiceOrInterleave = -1;
5856 int missing = 0;
5857 xmlRelaxNGDefinePtr cur;
5858
5859 starts = grammar->start;
5860 if ((starts == NULL) || (starts->next == NULL))
5861 return;
5862 cur = starts;
5863 while (cur != NULL) {
5864 if ((cur->node == NULL) || (cur->node->parent == NULL) ||
5865 (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
5866 combine = NULL;
5867 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
5868 "Internal error: start element not found\n", NULL,
5869 NULL);
5870 } else {
5871 combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
5872 }
5873
5874 if (combine != NULL) {
5875 if (xmlStrEqual(combine, BAD_CAST "choice")) {
5876 if (choiceOrInterleave == -1)
5877 choiceOrInterleave = 1;
5878 else if (choiceOrInterleave == 0) {
5879 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5880 "<start> use both 'choice' and 'interleave'\n",
5881 NULL, NULL);
5882 }
5883 } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
5884 if (choiceOrInterleave == -1)
5885 choiceOrInterleave = 0;
5886 else if (choiceOrInterleave == 1) {
5887 xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
5888 "<start> use both 'choice' and 'interleave'\n",
5889 NULL, NULL);
5890 }
5891 } else {
5892 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
5893 "<start> uses unknown combine value '%s''\n",
5894 combine, NULL);
5895 }
5896 xmlFree(combine);
5897 } else {
5898 if (missing == 0)
5899 missing = 1;
5900 else {
5901 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
5902 "Some <start> element miss the combine attribute\n",
5903 NULL, NULL);
5904 }
5905 }
5906
5907 cur = cur->next;
5908 }
5909#ifdef DEBUG
5910 xmlGenericError(xmlGenericErrorContext,
5911 "xmlRelaxNGCombineStart(): merging <start>: %d\n",
5912 choiceOrInterleave);
5913#endif
5914 if (choiceOrInterleave == -1)
5915 choiceOrInterleave = 0;
5916 cur = xmlRelaxNGNewDefine(ctxt, starts->node);
5917 if (cur == NULL)
5918 return;
5919 if (choiceOrInterleave == 0)
5920 cur->type = XML_RELAXNG_INTERLEAVE;
5921 else
5922 cur->type = XML_RELAXNG_CHOICE;
5923 cur->content = grammar->start;
5924 grammar->start = cur;
5925 if (choiceOrInterleave == 0) {
5926 if (ctxt->interleaves == NULL)
5927 ctxt->interleaves = xmlHashCreate(10);
5928 if (ctxt->interleaves == NULL) {
5929 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5930 "Failed to create interleaves hash table\n", NULL,
5931 NULL);
5932 } else {
5933 char tmpname[32];
5934
5935 snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
5936 if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
5937 0) {
5938 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
5939 "Failed to add %s to hash table\n",
5940 (const xmlChar *) tmpname, NULL);
5941 }
5942 }
5943 }
5944}
5945
5946/**
5947 * xmlRelaxNGCheckCycles:
5948 * @ctxt: a Relax-NG parser context
5949 * @nodes: grammar children nodes
5950 * @depth: the counter
5951 *
5952 * Check for cycles.
5953 *
5954 * Returns 0 if check passed, and -1 in case of error
5955 */
5956static int
5957xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
5958 xmlRelaxNGDefinePtr cur, int depth)
5959{
5960 int ret = 0;
5961
5962 while ((ret == 0) && (cur != NULL)) {
5963 if ((cur->type == XML_RELAXNG_REF) ||
5964 (cur->type == XML_RELAXNG_PARENTREF)) {
5965 if (cur->depth == -1) {
5966 cur->depth = depth;
5967 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5968 cur->depth = -2;
5969 } else if (depth == cur->depth) {
5970 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
5971 "Detected a cycle in %s references\n",
5972 cur->name, NULL);
5973 return (-1);
5974 }
5975 } else if (cur->type == XML_RELAXNG_ELEMENT) {
5976 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
5977 } else {
5978 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
5979 }
5980 cur = cur->next;
5981 }
5982 return (ret);
5983}
5984
5985/**
5986 * xmlRelaxNGTryUnlink:
5987 * @ctxt: a Relax-NG parser context
5988 * @cur: the definition to unlink
5989 * @parent: the parent definition
5990 * @prev: the previous sibling definition
5991 *
5992 * Try to unlink a definition. If not possble make it a NOOP
5993 *
5994 * Returns the new prev definition
5995 */
5996static xmlRelaxNGDefinePtr
5997xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
5998 xmlRelaxNGDefinePtr cur,
5999 xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
6000{
6001 if (prev != NULL) {
6002 prev->next = cur->next;
6003 } else {
6004 if (parent != NULL) {
6005 if (parent->content == cur)
6006 parent->content = cur->next;
6007 else if (parent->attrs == cur)
6008 parent->attrs = cur->next;
6009 else if (parent->nameClass == cur)
6010 parent->nameClass = cur->next;
6011 } else {
6012 cur->type = XML_RELAXNG_NOOP;
6013 prev = cur;
6014 }
6015 }
6016 return (prev);
6017}
6018
6019/**
6020 * xmlRelaxNGSimplify:
6021 * @ctxt: a Relax-NG parser context
6022 * @nodes: grammar children nodes
6023 *
6024 * Check for simplification of empty and notAllowed
6025 */
6026static void
6027xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
6028 xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent)
6029{
6030 xmlRelaxNGDefinePtr prev = NULL;
6031
6032 while (cur != NULL) {
6033 if ((cur->type == XML_RELAXNG_REF) ||
6034 (cur->type == XML_RELAXNG_PARENTREF)) {
6035 if (cur->depth != -3) {
6036 cur->depth = -3;
6037 xmlRelaxNGSimplify(ctxt, cur->content, cur);
6038 }
6039 } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
6040 cur->parent = parent;
6041 if ((parent != NULL) &&
6042 ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
6043 (parent->type == XML_RELAXNG_LIST) ||
6044 (parent->type == XML_RELAXNG_GROUP) ||
6045 (parent->type == XML_RELAXNG_INTERLEAVE) ||
6046 (parent->type == XML_RELAXNG_ONEORMORE) ||
6047 (parent->type == XML_RELAXNG_ZEROORMORE))) {
6048 parent->type = XML_RELAXNG_NOT_ALLOWED;
6049 break;
6050 }
6051 if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) {
6052 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6053 } else
6054 prev = cur;
6055 } else if (cur->type == XML_RELAXNG_EMPTY) {
6056 cur->parent = parent;
6057 if ((parent != NULL) &&
6058 ((parent->type == XML_RELAXNG_ONEORMORE) ||
6059 (parent->type == XML_RELAXNG_ZEROORMORE))) {
6060 parent->type = XML_RELAXNG_EMPTY;
6061 break;
6062 }
6063 if ((parent != NULL) &&
6064 ((parent->type == XML_RELAXNG_GROUP) ||
6065 (parent->type == XML_RELAXNG_INTERLEAVE))) {
6066 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6067 } else
6068 prev = cur;
6069 } else {
6070 cur->parent = parent;
6071 if (cur->content != NULL)
6072 xmlRelaxNGSimplify(ctxt, cur->content, cur);
6073 if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL))
6074 xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
6075 if (cur->nameClass != NULL)
6076 xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
6077 /*
6078 * On Elements, try to move attribute only generating rules on
6079 * the attrs rules.
6080 */
6081 if (cur->type == XML_RELAXNG_ELEMENT) {
6082 int attronly;
6083 xmlRelaxNGDefinePtr tmp, pre;
6084
6085 while (cur->content != NULL) {
6086 attronly =
6087 xmlRelaxNGGenerateAttributes(ctxt, cur->content);
6088 if (attronly == 1) {
6089 /*
6090 * migrate cur->content to attrs
6091 */
6092 tmp = cur->content;
6093 cur->content = tmp->next;
6094 tmp->next = cur->attrs;
6095 cur->attrs = tmp;
6096 } else {
6097 /*
6098 * cur->content can generate elements or text
6099 */
6100 break;
6101 }
6102 }
6103 pre = cur->content;
6104 while ((pre != NULL) && (pre->next != NULL)) {
6105 tmp = pre->next;
6106 attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
6107 if (attronly == 1) {
6108 /*
6109 * migrate tmp to attrs
6110 */
6111 pre->next = tmp->next;
6112 tmp->next = cur->attrs;
6113 cur->attrs = tmp;
6114 } else {
6115 pre = tmp;
6116 }
6117 }
6118 }
6119 /*
6120 * This may result in a simplification
6121 */
6122 if ((cur->type == XML_RELAXNG_GROUP) ||
6123 (cur->type == XML_RELAXNG_INTERLEAVE)) {
6124 if (cur->content == NULL)
6125 cur->type = XML_RELAXNG_EMPTY;
6126 else if (cur->content->next == NULL) {
6127 if ((parent == NULL) && (prev == NULL)) {
6128 cur->type = XML_RELAXNG_NOOP;
6129 } else if (prev == NULL) {
6130 parent->content = cur->content;
6131 cur->content->next = cur->next;
6132 cur = cur->content;
6133 } else {
6134 cur->content->next = cur->next;
6135 prev->next = cur->content;
6136 cur = cur->content;
6137 }
6138 }
6139 }
6140 /*
6141 * the current node may have been transformed back
6142 */
6143 if ((cur->type == XML_RELAXNG_EXCEPT) &&
6144 (cur->content != NULL) &&
6145 (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) {
6146 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6147 } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
6148 if ((parent != NULL) &&
6149 ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
6150 (parent->type == XML_RELAXNG_LIST) ||
6151 (parent->type == XML_RELAXNG_GROUP) ||
6152 (parent->type == XML_RELAXNG_INTERLEAVE) ||
6153 (parent->type == XML_RELAXNG_ONEORMORE) ||
6154 (parent->type == XML_RELAXNG_ZEROORMORE))) {
6155 parent->type = XML_RELAXNG_NOT_ALLOWED;
6156 break;
6157 }
6158 if ((parent != NULL) &&
6159 (parent->type == XML_RELAXNG_CHOICE)) {
6160 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6161 } else
6162 prev = cur;
6163 } else if (cur->type == XML_RELAXNG_EMPTY) {
6164 if ((parent != NULL) &&
6165 ((parent->type == XML_RELAXNG_ONEORMORE) ||
6166 (parent->type == XML_RELAXNG_ZEROORMORE))) {
6167 parent->type = XML_RELAXNG_EMPTY;
6168 break;
6169 }
6170 if ((parent != NULL) &&
6171 ((parent->type == XML_RELAXNG_GROUP) ||
6172 (parent->type == XML_RELAXNG_INTERLEAVE) ||
6173 (parent->type == XML_RELAXNG_CHOICE))) {
6174 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
6175 } else
6176 prev = cur;
6177 } else {
6178 prev = cur;
6179 }
6180 }
6181 cur = cur->next;
6182 }
6183}
6184
6185/**
6186 * xmlRelaxNGGroupContentType:
6187 * @ct1: the first content type
6188 * @ct2: the second content type
6189 *
6190 * Try to group 2 content types
6191 *
6192 * Returns the content type
6193 */
6194static xmlRelaxNGContentType
6195xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
6196 xmlRelaxNGContentType ct2)
6197{
6198 if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
6199 (ct2 == XML_RELAXNG_CONTENT_ERROR))
6200 return (XML_RELAXNG_CONTENT_ERROR);
6201 if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
6202 return (ct2);
6203 if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
6204 return (ct1);
6205 if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
6206 (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
6207 return (XML_RELAXNG_CONTENT_COMPLEX);
6208 return (XML_RELAXNG_CONTENT_ERROR);
6209}
6210
6211/**
6212 * xmlRelaxNGMaxContentType:
6213 * @ct1: the first content type
6214 * @ct2: the second content type
6215 *
6216 * Compute the max content-type
6217 *
6218 * Returns the content type
6219 */
6220static xmlRelaxNGContentType
6221xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
6222 xmlRelaxNGContentType ct2)
6223{
6224 if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
6225 (ct2 == XML_RELAXNG_CONTENT_ERROR))
6226 return (XML_RELAXNG_CONTENT_ERROR);
6227 if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) ||
6228 (ct2 == XML_RELAXNG_CONTENT_SIMPLE))
6229 return (XML_RELAXNG_CONTENT_SIMPLE);
6230 if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) ||
6231 (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
6232 return (XML_RELAXNG_CONTENT_COMPLEX);
6233 return (XML_RELAXNG_CONTENT_EMPTY);
6234}
6235
6236/**
6237 * xmlRelaxNGCheckRules:
6238 * @ctxt: a Relax-NG parser context
6239 * @cur: the current definition
6240 * @flags: some accumulated flags
6241 * @ptype: the parent type
6242 *
6243 * Check for rules in section 7.1 and 7.2
6244 *
6245 * Returns the content type of @cur
6246 */
6247static xmlRelaxNGContentType
6248xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
6249 xmlRelaxNGDefinePtr cur, int flags,
6250 xmlRelaxNGType ptype)
6251{
6252 int nflags;
6253 xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;
6254
6255 while (cur != NULL) {
6256 ret = XML_RELAXNG_CONTENT_EMPTY;
6257 if ((cur->type == XML_RELAXNG_REF) ||
6258 (cur->type == XML_RELAXNG_PARENTREF)) {
6259 /*
6260 * This should actually be caught by list//element(ref) at the
6261 * element boundaries, c.f. Bug #159968 local refs are dropped
6262 * in step 4.19.
6263 */
6264#if 0
6265 if (flags & XML_RELAXNG_IN_LIST) {
6266 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
6267 "Found forbidden pattern list//ref\n", NULL,
6268 NULL);
6269 }
6270#endif
6271 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6272 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
6273 "Found forbidden pattern data/except//ref\n",
6274 NULL, NULL);
6275 }
6276 if (cur->content == NULL) {
6277 if (cur->type == XML_RELAXNG_PARENTREF)
6278 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6279 "Internal found no define for parent refs\n",
6280 NULL, NULL);
6281 else
6282 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
6283 "Internal found no define for ref %s\n",
6284 (cur->name ? cur->name: BAD_CAST "null"), NULL);
6285 }
6286 if (cur->depth > -4) {
6287 cur->depth = -4;
6288 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
6289 flags, cur->type);
6290 cur->depth = ret - 15;
6291 } else if (cur->depth == -4) {
6292 ret = XML_RELAXNG_CONTENT_COMPLEX;
6293 } else {
6294 ret = (xmlRelaxNGContentType) (cur->depth + 15);
6295 }
6296 } else if (cur->type == XML_RELAXNG_ELEMENT) {
6297 /*
6298 * The 7.3 Attribute derivation rule for groups is plugged there
6299 */
6300 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6301 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6302 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
6303 "Found forbidden pattern data/except//element(ref)\n",
6304 NULL, NULL);
6305 }
6306 if (flags & XML_RELAXNG_IN_LIST) {
6307 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
6308 "Found forbidden pattern list//element(ref)\n",
6309 NULL, NULL);
6310 }
6311 if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6312 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6313 "Found forbidden pattern attribute//element(ref)\n",
6314 NULL, NULL);
6315 }
6316 if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6317 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
6318 "Found forbidden pattern attribute//element(ref)\n",
6319 NULL, NULL);
6320 }
6321 /*
6322 * reset since in the simple form elements are only child
6323 * of grammar/define
6324 */
6325 nflags = 0;
6326 ret =
6327 xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
6328 if (ret != XML_RELAXNG_CONTENT_EMPTY) {
6329 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
6330 "Element %s attributes have a content type error\n",
6331 cur->name, NULL);
6332 }
6333 ret =
6334 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6335 cur->type);
6336 if (ret == XML_RELAXNG_CONTENT_ERROR) {
6337 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
6338 "Element %s has a content type error\n",
6339 cur->name, NULL);
6340 } else {
6341 ret = XML_RELAXNG_CONTENT_COMPLEX;
6342 }
6343 } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
6344 if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
6345 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
6346 "Found forbidden pattern attribute//attribute\n",
6347 NULL, NULL);
6348 }
6349 if (flags & XML_RELAXNG_IN_LIST) {
6350 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
6351 "Found forbidden pattern list//attribute\n",
6352 NULL, NULL);
6353 }
6354 if (flags & XML_RELAXNG_IN_OOMGROUP) {
6355 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
6356 "Found forbidden pattern oneOrMore//group//attribute\n",
6357 NULL, NULL);
6358 }
6359 if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
6360 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
6361 "Found forbidden pattern oneOrMore//interleave//attribute\n",
6362 NULL, NULL);
6363 }
6364 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6365 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
6366 "Found forbidden pattern data/except//attribute\n",
6367 NULL, NULL);
6368 }
6369 if (flags & XML_RELAXNG_IN_START) {
6370 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
6371 "Found forbidden pattern start//attribute\n",
6372 NULL, NULL);
6373 }
6374 if ((!(flags & XML_RELAXNG_IN_ONEORMORE))
6375 && (cur->name == NULL)) {
6376 if (cur->ns == NULL) {
6377 xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
6378 "Found anyName attribute without oneOrMore ancestor\n",
6379 NULL, NULL);
6380 } else {
6381 xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
6382 "Found nsName attribute without oneOrMore ancestor\n",
6383 NULL, NULL);
6384 }
6385 }
6386 nflags = flags | XML_RELAXNG_IN_ATTRIBUTE;
6387 xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
6388 ret = XML_RELAXNG_CONTENT_EMPTY;
6389 } else if ((cur->type == XML_RELAXNG_ONEORMORE) ||
6390 (cur->type == XML_RELAXNG_ZEROORMORE)) {
6391 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6392 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
6393 "Found forbidden pattern data/except//oneOrMore\n",
6394 NULL, NULL);
6395 }
6396 if (flags & XML_RELAXNG_IN_START) {
6397 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
6398 "Found forbidden pattern start//oneOrMore\n",
6399 NULL, NULL);
6400 }
6401 nflags = flags | XML_RELAXNG_IN_ONEORMORE;
6402 ret =
6403 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6404 cur->type);
6405 ret = xmlRelaxNGGroupContentType(ret, ret);
6406 } else if (cur->type == XML_RELAXNG_LIST) {
6407 if (flags & XML_RELAXNG_IN_LIST) {
6408 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
6409 "Found forbidden pattern list//list\n", NULL,
6410 NULL);
6411 }
6412 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6413 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
6414 "Found forbidden pattern data/except//list\n",
6415 NULL, NULL);
6416 }
6417 if (flags & XML_RELAXNG_IN_START) {
6418 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
6419 "Found forbidden pattern start//list\n", NULL,
6420 NULL);
6421 }
6422 nflags = flags | XML_RELAXNG_IN_LIST;
6423 ret =
6424 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6425 cur->type);
6426 } else if (cur->type == XML_RELAXNG_GROUP) {
6427 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6428 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
6429 "Found forbidden pattern data/except//group\n",
6430 NULL, NULL);
6431 }
6432 if (flags & XML_RELAXNG_IN_START) {
6433 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
6434 "Found forbidden pattern start//group\n", NULL,
6435 NULL);
6436 }
6437 if (flags & XML_RELAXNG_IN_ONEORMORE)
6438 nflags = flags | XML_RELAXNG_IN_OOMGROUP;
6439 else
6440 nflags = flags;
6441 ret =
6442 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6443 cur->type);
6444 /*
6445 * The 7.3 Attribute derivation rule for groups is plugged there
6446 */
6447 xmlRelaxNGCheckGroupAttrs(ctxt, cur);
6448 } else if (cur->type == XML_RELAXNG_INTERLEAVE) {
6449 if (flags & XML_RELAXNG_IN_LIST) {
6450 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
6451 "Found forbidden pattern list//interleave\n",
6452 NULL, NULL);
6453 }
6454 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6455 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6456 "Found forbidden pattern data/except//interleave\n",
6457 NULL, NULL);
6458 }
6459 if (flags & XML_RELAXNG_IN_START) {
6460 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
6461 "Found forbidden pattern start//interleave\n",
6462 NULL, NULL);
6463 }
6464 if (flags & XML_RELAXNG_IN_ONEORMORE)
6465 nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE;
6466 else
6467 nflags = flags;
6468 ret =
6469 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6470 cur->type);
6471 } else if (cur->type == XML_RELAXNG_EXCEPT) {
6472 if ((cur->parent != NULL) &&
6473 (cur->parent->type == XML_RELAXNG_DATATYPE))
6474 nflags = flags | XML_RELAXNG_IN_DATAEXCEPT;
6475 else
6476 nflags = flags;
6477 ret =
6478 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
6479 cur->type);
6480 } else if (cur->type == XML_RELAXNG_DATATYPE) {
6481 if (flags & XML_RELAXNG_IN_START) {
6482 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
6483 "Found forbidden pattern start//data\n", NULL,
6484 NULL);
6485 }
6486 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6487 ret = XML_RELAXNG_CONTENT_SIMPLE;
6488 } else if (cur->type == XML_RELAXNG_VALUE) {
6489 if (flags & XML_RELAXNG_IN_START) {
6490 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
6491 "Found forbidden pattern start//value\n", NULL,
6492 NULL);
6493 }
6494 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6495 ret = XML_RELAXNG_CONTENT_SIMPLE;
6496 } else if (cur->type == XML_RELAXNG_TEXT) {
6497 if (flags & XML_RELAXNG_IN_LIST) {
6498 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
6499 "Found forbidden pattern list//text\n", NULL,
6500 NULL);
6501 }
6502 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6503 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
6504 "Found forbidden pattern data/except//text\n",
6505 NULL, NULL);
6506 }
6507 if (flags & XML_RELAXNG_IN_START) {
6508 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
6509 "Found forbidden pattern start//text\n", NULL,
6510 NULL);
6511 }
6512 ret = XML_RELAXNG_CONTENT_COMPLEX;
6513 } else if (cur->type == XML_RELAXNG_EMPTY) {
6514 if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
6515 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
6516 "Found forbidden pattern data/except//empty\n",
6517 NULL, NULL);
6518 }
6519 if (flags & XML_RELAXNG_IN_START) {
6520 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
6521 "Found forbidden pattern start//empty\n", NULL,
6522 NULL);
6523 }
6524 ret = XML_RELAXNG_CONTENT_EMPTY;
6525 } else if (cur->type == XML_RELAXNG_CHOICE) {
6526 xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
6527 ret =
6528 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6529 } else {
6530 ret =
6531 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
6532 }
6533 cur = cur->next;
6534 if (ptype == XML_RELAXNG_GROUP) {
6535 val = xmlRelaxNGGroupContentType(val, ret);
6536 } else if (ptype == XML_RELAXNG_INTERLEAVE) {
6537 /*
6538 * TODO: scan complain that tmp is never used, seems on purpose
6539 * need double-checking
6540 */
6541 tmp = xmlRelaxNGGroupContentType(val, ret);
6542 if (tmp != XML_RELAXNG_CONTENT_ERROR)
6543 tmp = xmlRelaxNGMaxContentType(val, ret);
6544 } else if (ptype == XML_RELAXNG_CHOICE) {
6545 val = xmlRelaxNGMaxContentType(val, ret);
6546 } else if (ptype == XML_RELAXNG_LIST) {
6547 val = XML_RELAXNG_CONTENT_SIMPLE;
6548 } else if (ptype == XML_RELAXNG_EXCEPT) {
6549 if (ret == XML_RELAXNG_CONTENT_ERROR)
6550 val = XML_RELAXNG_CONTENT_ERROR;
6551 else
6552 val = XML_RELAXNG_CONTENT_SIMPLE;
6553 } else {
6554 val = xmlRelaxNGGroupContentType(val, ret);
6555 }
6556
6557 }
6558 return (val);
6559}
6560
6561/**
6562 * xmlRelaxNGParseGrammar:
6563 * @ctxt: a Relax-NG parser context
6564 * @nodes: grammar children nodes
6565 *
6566 * parse a Relax-NG <grammar> node
6567 *
6568 * Returns the internal xmlRelaxNGGrammarPtr built or
6569 * NULL in case of error
6570 */
6571static xmlRelaxNGGrammarPtr
6572xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
6573{
6574 xmlRelaxNGGrammarPtr ret, tmp, old;
6575
6576#ifdef DEBUG_GRAMMAR
6577 xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n");
6578#endif
6579
6580 ret = xmlRelaxNGNewGrammar(ctxt);
6581 if (ret == NULL)
6582 return (NULL);
6583
6584 /*
6585 * Link the new grammar in the tree
6586 */
6587 ret->parent = ctxt->grammar;
6588 if (ctxt->grammar != NULL) {
6589 tmp = ctxt->grammar->children;
6590 if (tmp == NULL) {
6591 ctxt->grammar->children = ret;
6592 } else {
6593 while (tmp->next != NULL)
6594 tmp = tmp->next;
6595 tmp->next = ret;
6596 }
6597 }
6598
6599 old = ctxt->grammar;
6600 ctxt->grammar = ret;
6601 xmlRelaxNGParseGrammarContent(ctxt, nodes);
6602 ctxt->grammar = ret;
6603 if (ctxt->grammar == NULL) {
6604 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
6605 "Failed to parse <grammar> content\n", NULL, NULL);
6606 } else if (ctxt->grammar->start == NULL) {
6607 xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
6608 "Element <grammar> has no <start>\n", NULL, NULL);
6609 }
6610
6611 /*
6612 * Apply 4.17 merging rules to defines and starts
6613 */
6614 xmlRelaxNGCombineStart(ctxt, ret);
6615 if (ret->defs != NULL) {
6616 xmlHashScan(ret->defs, xmlRelaxNGCheckCombine, ctxt);
6617 }
6618
6619 /*
6620 * link together defines and refs in this grammar
6621 */
6622 if (ret->refs != NULL) {
6623 xmlHashScan(ret->refs, xmlRelaxNGCheckReference, ctxt);
6624 }
6625
6626
6627 /* @@@@ */
6628
6629 ctxt->grammar = old;
6630 return (ret);
6631}
6632
6633/**
6634 * xmlRelaxNGParseDocument:
6635 * @ctxt: a Relax-NG parser context
6636 * @node: the root node of the RelaxNG schema
6637 *
6638 * parse a Relax-NG definition resource and build an internal
6639 * xmlRelaxNG struture which can be used to validate instances.
6640 *
6641 * Returns the internal XML RelaxNG structure built or
6642 * NULL in case of error
6643 */
6644static xmlRelaxNGPtr
6645xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6646{
6647 xmlRelaxNGPtr schema = NULL;
6648 const xmlChar *olddefine;
6649 xmlRelaxNGGrammarPtr old;
6650
6651 if ((ctxt == NULL) || (node == NULL))
6652 return (NULL);
6653
6654 schema = xmlRelaxNGNewRelaxNG(ctxt);
6655 if (schema == NULL)
6656 return (NULL);
6657
6658 olddefine = ctxt->define;
6659 ctxt->define = NULL;
6660 if (IS_RELAXNG(node, "grammar")) {
6661 schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
6662 if (schema->topgrammar == NULL) {
6663 xmlRelaxNGFree(schema);
6664 return (NULL);
6665 }
6666 } else {
6667 xmlRelaxNGGrammarPtr tmp, ret;
6668
6669 schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
6670 if (schema->topgrammar == NULL) {
6671 xmlRelaxNGFree(schema);
6672 return (NULL);
6673 }
6674 /*
6675 * Link the new grammar in the tree
6676 */
6677 ret->parent = ctxt->grammar;
6678 if (ctxt->grammar != NULL) {
6679 tmp = ctxt->grammar->children;
6680 if (tmp == NULL) {
6681 ctxt->grammar->children = ret;
6682 } else {
6683 while (tmp->next != NULL)
6684 tmp = tmp->next;
6685 tmp->next = ret;
6686 }
6687 }
6688 old = ctxt->grammar;
6689 ctxt->grammar = ret;
6690 xmlRelaxNGParseStart(ctxt, node);
6691 if (old != NULL)
6692 ctxt->grammar = old;
6693 }
6694 ctxt->define = olddefine;
6695 if (schema->topgrammar->start != NULL) {
6696 xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
6697 if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
6698 xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
6699 while ((schema->topgrammar->start != NULL) &&
6700 (schema->topgrammar->start->type == XML_RELAXNG_NOOP) &&
6701 (schema->topgrammar->start->next != NULL))
6702 schema->topgrammar->start =
6703 schema->topgrammar->start->content;
6704 xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
6705 XML_RELAXNG_IN_START, XML_RELAXNG_NOOP);
6706 }
6707 }
6708#ifdef DEBUG
6709 if (schema == NULL)
6710 xmlGenericError(xmlGenericErrorContext,
6711 "xmlRelaxNGParseDocument() failed\n");
6712#endif
6713
6714 return (schema);
6715}
6716
6717/************************************************************************
6718 * *
6719 * Reading RelaxNGs *
6720 * *
6721 ************************************************************************/
6722
6723/**
6724 * xmlRelaxNGNewParserCtxt:
6725 * @URL: the location of the schema
6726 *
6727 * Create an XML RelaxNGs parse context for that file/resource expected
6728 * to contain an XML RelaxNGs file.
6729 *
6730 * Returns the parser context or NULL in case of error
6731 */
6732xmlRelaxNGParserCtxtPtr
6733xmlRelaxNGNewParserCtxt(const char *URL)
6734{
6735 xmlRelaxNGParserCtxtPtr ret;
6736
6737 if (URL == NULL)
6738 return (NULL);
6739
6740 ret =
6741 (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6742 if (ret == NULL) {
6743 xmlRngPErrMemory(NULL, "building parser\n");
6744 return (NULL);
6745 }
6746 memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6747 ret->URL = xmlStrdup((const xmlChar *) URL);
6748 ret->error = xmlGenericError;
6749 ret->userData = xmlGenericErrorContext;
6750 return (ret);
6751}
6752
6753/**
6754 * xmlRelaxNGNewMemParserCtxt:
6755 * @buffer: a pointer to a char array containing the schemas
6756 * @size: the size of the array
6757 *
6758 * Create an XML RelaxNGs parse context for that memory buffer expected
6759 * to contain an XML RelaxNGs file.
6760 *
6761 * Returns the parser context or NULL in case of error
6762 */
6763xmlRelaxNGParserCtxtPtr
6764xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
6765{
6766 xmlRelaxNGParserCtxtPtr ret;
6767
6768 if ((buffer == NULL) || (size <= 0))
6769 return (NULL);
6770
6771 ret =
6772 (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6773 if (ret == NULL) {
6774 xmlRngPErrMemory(NULL, "building parser\n");
6775 return (NULL);
6776 }
6777 memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6778 ret->buffer = buffer;
6779 ret->size = size;
6780 ret->error = xmlGenericError;
6781 ret->userData = xmlGenericErrorContext;
6782 return (ret);
6783}
6784
6785/**
6786 * xmlRelaxNGNewDocParserCtxt:
6787 * @doc: a preparsed document tree
6788 *
6789 * Create an XML RelaxNGs parser context for that document.
6790 * Note: since the process of compiling a RelaxNG schemas modifies the
6791 * document, the @doc parameter is duplicated internally.
6792 *
6793 * Returns the parser context or NULL in case of error
6794 */
6795xmlRelaxNGParserCtxtPtr
6796xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
6797{
6798 xmlRelaxNGParserCtxtPtr ret;
6799 xmlDocPtr copy;
6800
6801 if (doc == NULL)
6802 return (NULL);
6803 copy = xmlCopyDoc(doc, 1);
6804 if (copy == NULL)
6805 return (NULL);
6806
6807 ret =
6808 (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
6809 if (ret == NULL) {
6810 xmlRngPErrMemory(NULL, "building parser\n");
6811 return (NULL);
6812 }
6813 memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
6814 ret->document = copy;
6815 ret->freedoc = 1;
6816 ret->userData = xmlGenericErrorContext;
6817 return (ret);
6818}
6819
6820/**
6821 * xmlRelaxNGFreeParserCtxt:
6822 * @ctxt: the schema parser context
6823 *
6824 * Free the resources associated to the schema parser context
6825 */
6826void
6827xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
6828{
6829 if (ctxt == NULL)
6830 return;
6831 if (ctxt->URL != NULL)
6832 xmlFree(ctxt->URL);
6833 if (ctxt->doc != NULL)
6834 xmlRelaxNGFreeDocument(ctxt->doc);
6835 if (ctxt->interleaves != NULL)
6836 xmlHashFree(ctxt->interleaves, NULL);
6837 if (ctxt->documents != NULL)
6838 xmlRelaxNGFreeDocumentList(ctxt->documents);
6839 if (ctxt->includes != NULL)
6840 xmlRelaxNGFreeIncludeList(ctxt->includes);
6841 if (ctxt->docTab != NULL)
6842 xmlFree(ctxt->docTab);
6843 if (ctxt->incTab != NULL)
6844 xmlFree(ctxt->incTab);
6845 if (ctxt->defTab != NULL) {
6846 int i;
6847
6848 for (i = 0; i < ctxt->defNr; i++)
6849 xmlRelaxNGFreeDefine(ctxt->defTab[i]);
6850 xmlFree(ctxt->defTab);
6851 }
6852 if ((ctxt->document != NULL) && (ctxt->freedoc))
6853 xmlFreeDoc(ctxt->document);
6854 xmlFree(ctxt);
6855}
6856
6857/**
6858 * xmlRelaxNGNormExtSpace:
6859 * @value: a value
6860 *
6861 * Removes the leading and ending spaces of the value
6862 * The string is modified "in situ"
6863 */
6864static void
6865xmlRelaxNGNormExtSpace(xmlChar * value)
6866{
6867 xmlChar *start = value;
6868 xmlChar *cur = value;
6869
6870 if (value == NULL)
6871 return;
6872
6873 while (IS_BLANK_CH(*cur))
6874 cur++;
6875 if (cur == start) {
6876 do {
6877 while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
6878 cur++;
6879 if (*cur == 0)
6880 return;
6881 start = cur;
6882 while (IS_BLANK_CH(*cur))
6883 cur++;
6884 if (*cur == 0) {
6885 *start = 0;
6886 return;
6887 }
6888 } while (1);
6889 } else {
6890 do {
6891 while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
6892 *start++ = *cur++;
6893 if (*cur == 0) {
6894 *start = 0;
6895 return;
6896 }
6897 /* don't try to normalize the inner spaces */
6898 while (IS_BLANK_CH(*cur))
6899 cur++;
6900 if (*cur == 0) {
6901 *start = 0;
6902 return;
6903 }
6904 *start++ = *cur++;
6905 } while (1);
6906 }
6907}
6908
6909/**
6910 * xmlRelaxNGCleanupAttributes:
6911 * @ctxt: a Relax-NG parser context
6912 * @node: a Relax-NG node
6913 *
6914 * Check all the attributes on the given node
6915 */
6916static void
6917xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
6918{
6919 xmlAttrPtr cur, next;
6920
6921 cur = node->properties;
6922 while (cur != NULL) {
6923 next = cur->next;
6924 if ((cur->ns == NULL) ||
6925 (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
6926 if (xmlStrEqual(cur->name, BAD_CAST "name")) {
6927 if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
6928 (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
6929 (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
6930 (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
6931 (!xmlStrEqual(node->name, BAD_CAST "param")) &&
6932 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6933 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6934 "Attribute %s is not allowed on %s\n",
6935 cur->name, node->name);
6936 }
6937 } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
6938 if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
6939 (!xmlStrEqual(node->name, BAD_CAST "data"))) {
6940 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6941 "Attribute %s is not allowed on %s\n",
6942 cur->name, node->name);
6943 }
6944 } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
6945 if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
6946 (!xmlStrEqual(node->name, BAD_CAST "include"))) {
6947 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6948 "Attribute %s is not allowed on %s\n",
6949 cur->name, node->name);
6950 }
6951 } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
6952 if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
6953 (!xmlStrEqual(node->name, BAD_CAST "define"))) {
6954 xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
6955 "Attribute %s is not allowed on %s\n",
6956 cur->name, node->name);
6957 }
6958 } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
6959 xmlChar *val;
6960 xmlURIPtr uri;
6961
6962 val = xmlNodeListGetString(node->doc, cur->children, 1);
6963 if (val != NULL) {
6964 if (val[0] != 0) {
6965 uri = xmlParseURI((const char *) val);
6966 if (uri == NULL) {
6967 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
6968 "Attribute %s contains invalid URI %s\n",
6969 cur->name, val);
6970 } else {
6971 if (uri->scheme == NULL) {
6972 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
6973 "Attribute %s URI %s is not absolute\n",
6974 cur->name, val);
6975 }
6976 if (uri->fragment != NULL) {
6977 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
6978 "Attribute %s URI %s has a fragment ID\n",
6979 cur->name, val);
6980 }
6981 xmlFreeURI(uri);
6982 }
6983 }
6984 xmlFree(val);
6985 }
6986 } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
6987 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
6988 "Unknown attribute %s on %s\n", cur->name,
6989 node->name);
6990 }
6991 }
6992 cur = next;
6993 }
6994}
6995
6996/**
6997 * xmlRelaxNGCleanupTree:
6998 * @ctxt: a Relax-NG parser context
6999 * @root: an xmlNodePtr subtree
7000 *
7001 * Cleanup the subtree from unwanted nodes for parsing, resolve
7002 * Include and externalRef lookups.
7003 */
7004static void
7005xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
7006{
7007 xmlNodePtr cur, delete;
7008
7009 delete = NULL;
7010 cur = root;
7011 while (cur != NULL) {
7012 if (delete != NULL) {
7013 xmlUnlinkNode(delete);
7014 xmlFreeNode(delete);
7015 delete = NULL;
7016 }
7017 if (cur->type == XML_ELEMENT_NODE) {
7018 /*
7019 * Simplification 4.1. Annotations
7020 */
7021 if ((cur->ns == NULL) ||
7022 (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
7023 if ((cur->parent != NULL) &&
7024 (cur->parent->type == XML_ELEMENT_NODE) &&
7025 ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) ||
7026 (xmlStrEqual(cur->parent->name, BAD_CAST "value")) ||
7027 (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) {
7028 xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
7029 "element %s doesn't allow foreign elements\n",
7030 cur->parent->name, NULL);
7031 }
7032 delete = cur;
7033 goto skip_children;
7034 } else {
7035 xmlRelaxNGCleanupAttributes(ctxt, cur);
7036 if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) {
7037 xmlChar *href, *ns, *base, *URL;
7038 xmlRelaxNGDocumentPtr docu;
7039 xmlNodePtr tmp;
7040 xmlURIPtr uri;
7041
7042 ns = xmlGetProp(cur, BAD_CAST "ns");
7043 if (ns == NULL) {
7044 tmp = cur->parent;
7045 while ((tmp != NULL) &&
7046 (tmp->type == XML_ELEMENT_NODE)) {
7047 ns = xmlGetProp(tmp, BAD_CAST "ns");
7048 if (ns != NULL)
7049 break;
7050 tmp = tmp->parent;
7051 }
7052 }
7053 href = xmlGetProp(cur, BAD_CAST "href");
7054 if (href == NULL) {
7055 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7056 "xmlRelaxNGParse: externalRef has no href attribute\n",
7057 NULL, NULL);
7058 if (ns != NULL)
7059 xmlFree(ns);
7060 delete = cur;
7061 goto skip_children;
7062 }
7063 uri = xmlParseURI((const char *) href);
7064 if (uri == NULL) {
7065 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7066 "Incorrect URI for externalRef %s\n",
7067 href, NULL);
7068 if (ns != NULL)
7069 xmlFree(ns);
7070 if (href != NULL)
7071 xmlFree(href);
7072 delete = cur;
7073 goto skip_children;
7074 }
7075 if (uri->fragment != NULL) {
7076 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7077 "Fragment forbidden in URI for externalRef %s\n",
7078 href, NULL);
7079 if (ns != NULL)
7080 xmlFree(ns);
7081 xmlFreeURI(uri);
7082 if (href != NULL)
7083 xmlFree(href);
7084 delete = cur;
7085 goto skip_children;
7086 }
7087 xmlFreeURI(uri);
7088 base = xmlNodeGetBase(cur->doc, cur);
7089 URL = xmlBuildURI(href, base);
7090 if (URL == NULL) {
7091 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7092 "Failed to compute URL for externalRef %s\n",
7093 href, NULL);
7094 if (ns != NULL)
7095 xmlFree(ns);
7096 if (href != NULL)
7097 xmlFree(href);
7098 if (base != NULL)
7099 xmlFree(base);
7100 delete = cur;
7101 goto skip_children;
7102 }
7103 if (href != NULL)
7104 xmlFree(href);
7105 if (base != NULL)
7106 xmlFree(base);
7107 docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
7108 if (docu == NULL) {
7109 xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
7110 "Failed to load externalRef %s\n", URL,
7111 NULL);
7112 if (ns != NULL)
7113 xmlFree(ns);
7114 xmlFree(URL);
7115 delete = cur;
7116 goto skip_children;
7117 }
7118 if (ns != NULL)
7119 xmlFree(ns);
7120 xmlFree(URL);
7121 cur->psvi = docu;
7122 } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
7123 xmlChar *href, *ns, *base, *URL;
7124 xmlRelaxNGIncludePtr incl;
7125 xmlNodePtr tmp;
7126
7127 href = xmlGetProp(cur, BAD_CAST "href");
7128 if (href == NULL) {
7129 xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
7130 "xmlRelaxNGParse: include has no href attribute\n",
7131 NULL, NULL);
7132 delete = cur;
7133 goto skip_children;
7134 }
7135 base = xmlNodeGetBase(cur->doc, cur);
7136 URL = xmlBuildURI(href, base);
7137 if (URL == NULL) {
7138 xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
7139 "Failed to compute URL for include %s\n",
7140 href, NULL);
7141 if (href != NULL)
7142 xmlFree(href);
7143 if (base != NULL)
7144 xmlFree(base);
7145 delete = cur;
7146 goto skip_children;
7147 }
7148 if (href != NULL)
7149 xmlFree(href);
7150 if (base != NULL)
7151 xmlFree(base);
7152 ns = xmlGetProp(cur, BAD_CAST "ns");
7153 if (ns == NULL) {
7154 tmp = cur->parent;
7155 while ((tmp != NULL) &&
7156 (tmp->type == XML_ELEMENT_NODE)) {
7157 ns = xmlGetProp(tmp, BAD_CAST "ns");
7158 if (ns != NULL)
7159 break;
7160 tmp = tmp->parent;
7161 }
7162 }
7163 incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
7164 if (ns != NULL)
7165 xmlFree(ns);
7166 if (incl == NULL) {
7167 xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
7168 "Failed to load include %s\n", URL,
7169 NULL);
7170 xmlFree(URL);
7171 delete = cur;
7172 goto skip_children;
7173 }
7174 xmlFree(URL);
7175 cur->psvi = incl;
7176 } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
7177 (xmlStrEqual(cur->name, BAD_CAST "attribute")))
7178 {
7179 xmlChar *name, *ns;
7180 xmlNodePtr text = NULL;
7181
7182 /*
7183 * Simplification 4.8. name attribute of element
7184 * and attribute elements
7185 */
7186 name = xmlGetProp(cur, BAD_CAST "name");
7187 if (name != NULL) {
7188 if (cur->children == NULL) {
7189 text =
7190 xmlNewChild(cur, cur->ns, BAD_CAST "name",
7191 name);
7192 } else {
7193 xmlNodePtr node;
7194
7195 node = xmlNewDocNode(cur->doc, cur->ns,
7196 BAD_CAST "name", NULL);
7197 if (node != NULL) {
7198 xmlAddPrevSibling(cur->children, node);
7199 text = xmlNewText(name);
7200 xmlAddChild(node, text);
7201 text = node;
7202 }
7203 }
7204 if (text == NULL) {
7205 xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
7206 "Failed to create a name %s element\n",
7207 name, NULL);
7208 }
7209 xmlUnsetProp(cur, BAD_CAST "name");
7210 xmlFree(name);
7211 ns = xmlGetProp(cur, BAD_CAST "ns");
7212 if (ns != NULL) {
7213 if (text != NULL) {
7214 xmlSetProp(text, BAD_CAST "ns", ns);
7215 /* xmlUnsetProp(cur, BAD_CAST "ns"); */
7216 }
7217 xmlFree(ns);
7218 } else if (xmlStrEqual(cur->name,
7219 BAD_CAST "attribute")) {
7220 xmlSetProp(text, BAD_CAST "ns", BAD_CAST "");
7221 }
7222 }
7223 } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) ||
7224 (xmlStrEqual(cur->name, BAD_CAST "nsName")) ||
7225 (xmlStrEqual(cur->name, BAD_CAST "value"))) {
7226 /*
7227 * Simplification 4.8. name attribute of element
7228 * and attribute elements
7229 */
7230 if (xmlHasProp(cur, BAD_CAST "ns") == NULL) {
7231 xmlNodePtr node;
7232 xmlChar *ns = NULL;
7233
7234 node = cur->parent;
7235 while ((node != NULL) &&
7236 (node->type == XML_ELEMENT_NODE)) {
7237 ns = xmlGetProp(node, BAD_CAST "ns");
7238 if (ns != NULL) {
7239 break;
7240 }
7241 node = node->parent;
7242 }
7243 if (ns == NULL) {
7244 xmlSetProp(cur, BAD_CAST "ns", BAD_CAST "");
7245 } else {
7246 xmlSetProp(cur, BAD_CAST "ns", ns);
7247 xmlFree(ns);
7248 }
7249 }
7250 if (xmlStrEqual(cur->name, BAD_CAST "name")) {
7251 xmlChar *name, *local, *prefix;
7252
7253 /*
7254 * Simplification: 4.10. QNames
7255 */
7256 name = xmlNodeGetContent(cur);
7257 if (name != NULL) {
7258 local = xmlSplitQName2(name, &prefix);
7259 if (local != NULL) {
7260 xmlNsPtr ns;
7261
7262 ns = xmlSearchNs(cur->doc, cur, prefix);
7263 if (ns == NULL) {
7264 xmlRngPErr(ctxt, cur,
7265 XML_RNGP_PREFIX_UNDEFINED,
7266 "xmlRelaxNGParse: no namespace for prefix %s\n",
7267 prefix, NULL);
7268 } else {
7269 xmlSetProp(cur, BAD_CAST "ns",
7270 ns->href);
7271 xmlNodeSetContent(cur, local);
7272 }
7273 xmlFree(local);
7274 xmlFree(prefix);
7275 }
7276 xmlFree(name);
7277 }
7278 }
7279 /*
7280 * 4.16
7281 */
7282 if (xmlStrEqual(cur->name, BAD_CAST "nsName")) {
7283 if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7284 xmlRngPErr(ctxt, cur,
7285 XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
7286 "Found nsName/except//nsName forbidden construct\n",
7287 NULL, NULL);
7288 }
7289 }
7290 } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
7291 (cur != root)) {
7292 int oldflags = ctxt->flags;
7293
7294 /*
7295 * 4.16
7296 */
7297 if ((cur->parent != NULL) &&
7298 (xmlStrEqual
7299 (cur->parent->name, BAD_CAST "anyName"))) {
7300 ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
7301 xmlRelaxNGCleanupTree(ctxt, cur);
7302 ctxt->flags = oldflags;
7303 goto skip_children;
7304 } else if ((cur->parent != NULL) &&
7305 (xmlStrEqual
7306 (cur->parent->name, BAD_CAST "nsName"))) {
7307 ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
7308 xmlRelaxNGCleanupTree(ctxt, cur);
7309 ctxt->flags = oldflags;
7310 goto skip_children;
7311 }
7312 } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) {
7313 /*
7314 * 4.16
7315 */
7316 if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
7317 xmlRngPErr(ctxt, cur,
7318 XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
7319 "Found anyName/except//anyName forbidden construct\n",
7320 NULL, NULL);
7321 } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
7322 xmlRngPErr(ctxt, cur,
7323 XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
7324 "Found nsName/except//anyName forbidden construct\n",
7325 NULL, NULL);
7326 }
7327 }
7328 /*
7329 * This is not an else since "include" is transformed
7330 * into a div
7331 */
7332 if (xmlStrEqual(cur->name, BAD_CAST "div")) {
7333 xmlChar *ns;
7334 xmlNodePtr child, ins, tmp;
7335
7336 /*
7337 * implements rule 4.11
7338 */
7339
7340 ns = xmlGetProp(cur, BAD_CAST "ns");
7341
7342 child = cur->children;
7343 ins = cur;
7344 while (child != NULL) {
7345 if (ns != NULL) {
7346 if (!xmlHasProp(child, BAD_CAST "ns")) {
7347 xmlSetProp(child, BAD_CAST "ns", ns);
7348 }
7349 }
7350 tmp = child->next;
7351 xmlUnlinkNode(child);
7352 ins = xmlAddNextSibling(ins, child);
7353 child = tmp;
7354 }
7355 if (ns != NULL)
7356 xmlFree(ns);
7357 /*
7358 * Since we are about to delete cur, if its nsDef is non-NULL we
7359 * need to preserve it (it contains the ns definitions for the
7360 * children we just moved). We'll just stick it on to the end
7361 * of cur->parent's list, since it's never going to be re-serialized
7362 * (bug 143738).
7363 */
7364 if ((cur->nsDef != NULL) && (cur->parent != NULL)) {
7365 xmlNsPtr parDef = (xmlNsPtr)&cur->parent->nsDef;
7366 while (parDef->next != NULL)
7367 parDef = parDef->next;
7368 parDef->next = cur->nsDef;
7369 cur->nsDef = NULL;
7370 }
7371 delete = cur;
7372 goto skip_children;
7373 }
7374 }
7375 }
7376 /*
7377 * Simplification 4.2 whitespaces
7378 */
7379 else if ((cur->type == XML_TEXT_NODE) ||
7380 (cur->type == XML_CDATA_SECTION_NODE)) {
7381 if (IS_BLANK_NODE(cur)) {
7382 if ((cur->parent != NULL) &&
7383 (cur->parent->type == XML_ELEMENT_NODE)) {
7384 if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
7385 &&
7386 (!xmlStrEqual
7387 (cur->parent->name, BAD_CAST "param")))
7388 delete = cur;
7389 } else {
7390 delete = cur;
7391 goto skip_children;
7392 }
7393 }
7394 } else {
7395 delete = cur;
7396 goto skip_children;
7397 }
7398
7399 /*
7400 * Skip to next node
7401 */
7402 if (cur->children != NULL) {
7403 if ((cur->children->type != XML_ENTITY_DECL) &&
7404 (cur->children->type != XML_ENTITY_REF_NODE) &&
7405 (cur->children->type != XML_ENTITY_NODE)) {
7406 cur = cur->children;
7407 continue;
7408 }
7409 }
7410 skip_children:
7411 if (cur->next != NULL) {
7412 cur = cur->next;
7413 continue;
7414 }
7415
7416 do {
7417 cur = cur->parent;
7418 if (cur == NULL)
7419 break;
7420 if (cur == root) {
7421 cur = NULL;
7422 break;
7423 }
7424 if (cur->next != NULL) {
7425 cur = cur->next;
7426 break;
7427 }
7428 } while (cur != NULL);
7429 }
7430 if (delete != NULL) {
7431 xmlUnlinkNode(delete);
7432 xmlFreeNode(delete);
7433 delete = NULL;
7434 }
7435}
7436
7437/**
7438 * xmlRelaxNGCleanupDoc:
7439 * @ctxt: a Relax-NG parser context
7440 * @doc: an xmldocPtr document pointer
7441 *
7442 * Cleanup the document from unwanted nodes for parsing, resolve
7443 * Include and externalRef lookups.
7444 *
7445 * Returns the cleaned up document or NULL in case of error
7446 */
7447static xmlDocPtr
7448xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
7449{
7450 xmlNodePtr root;
7451
7452 /*
7453 * Extract the root
7454 */
7455 root = xmlDocGetRootElement(doc);
7456 if (root == NULL) {
7457 xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7458 ctxt->URL, NULL);
7459 return (NULL);
7460 }
7461 xmlRelaxNGCleanupTree(ctxt, root);
7462 return (doc);
7463}
7464
7465/**
7466 * xmlRelaxNGParse:
7467 * @ctxt: a Relax-NG parser context
7468 *
7469 * parse a schema definition resource and build an internal
7470 * XML Shema struture which can be used to validate instances.
7471 *
7472 * Returns the internal XML RelaxNG structure built from the resource or
7473 * NULL in case of error
7474 */
7475xmlRelaxNGPtr
7476xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
7477{
7478 xmlRelaxNGPtr ret = NULL;
7479 xmlDocPtr doc;
7480 xmlNodePtr root;
7481
7482 xmlRelaxNGInitTypes();
7483
7484 if (ctxt == NULL)
7485 return (NULL);
7486
7487 /*
7488 * First step is to parse the input document into an DOM/Infoset
7489 */
7490 if (ctxt->URL != NULL) {
7491 doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
7492 if (doc == NULL) {
7493 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7494 "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
7495 NULL);
7496 return (NULL);
7497 }
7498 } else if (ctxt->buffer != NULL) {
7499 doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
7500 if (doc == NULL) {
7501 xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
7502 "xmlRelaxNGParse: could not parse schemas\n", NULL,
7503 NULL);
7504 return (NULL);
7505 }
7506 doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7507 ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
7508 } else if (ctxt->document != NULL) {
7509 doc = ctxt->document;
7510 } else {
7511 xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
7512 "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
7513 return (NULL);
7514 }
7515 ctxt->document = doc;
7516
7517 /*
7518 * Some preprocessing of the document content
7519 */
7520 doc = xmlRelaxNGCleanupDoc(ctxt, doc);
7521 if (doc == NULL) {
7522 xmlFreeDoc(ctxt->document);
7523 ctxt->document = NULL;
7524 return (NULL);
7525 }
7526
7527 /*
7528 * Then do the parsing for good
7529 */
7530 root = xmlDocGetRootElement(doc);
7531 if (root == NULL) {
7532 xmlRngPErr(ctxt, (xmlNodePtr) doc,
7533 XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
7534 (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
7535
7536 xmlFreeDoc(ctxt->document);
7537 ctxt->document = NULL;
7538 return (NULL);
7539 }
7540 ret = xmlRelaxNGParseDocument(ctxt, root);
7541 if (ret == NULL) {
7542 xmlFreeDoc(ctxt->document);
7543 ctxt->document = NULL;
7544 return (NULL);
7545 }
7546
7547 /*
7548 * Check the ref/defines links
7549 */
7550 /*
7551 * try to preprocess interleaves
7552 */
7553 if (ctxt->interleaves != NULL) {
7554 xmlHashScan(ctxt->interleaves, 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 */
7612void
7613xmlRelaxNGSetParserErrors(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 */
7636int
7637xmlRelaxNGGetParserErrors(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 */
7660void
7661xmlRelaxNGSetParserStructuredErrors(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 ************************************************************************/
7680static 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 */
7690static void
7691xmlRelaxNGDumpDefines(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 */
7706static void
7707xmlRelaxNGDumpDefine(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 */
7823static void
7824xmlRelaxNGDumpGrammar(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 */
7863void
7864xmlRelaxNGDump(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 */
7894void
7895xmlRelaxNGDumpTree(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 ************************************************************************/
7916static 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 */
7928static void
7929xmlRelaxNGValidateCompiledCallback(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 */
7979static int
7980xmlRelaxNGValidateCompiledContent(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 ************************************************************************/
8061static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
8062 xmlRelaxNGDefinePtr defines);
8063static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
8064 int dolog);
8065static 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 */
8076static int
8077xmlRelaxNGElemPush(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 */
8113static xmlRegExecCtxtPtr
8114xmlRelaxNGElemPop(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 */
8140static void
8141xmlRelaxNGValidateProgressiveCallback(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 */
8286int
8287xmlRelaxNGValidatePushElement(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 */
8365int
8366xmlRelaxNGValidatePushCData(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 */
8408int
8409xmlRelaxNGValidatePopElement(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 */
8457int
8458xmlRelaxNGValidateFullElement(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 ************************************************************************/
8497static 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 */
8509static xmlNodePtr
8510xmlRelaxNGSkipIgnored(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 */
8540static xmlChar *
8541xmlRelaxNGNormalize(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 */
8587static int
8588xmlRelaxNGValidateDatatype(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 */
8658static int
8659xmlRelaxNGNextValue(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 */
8689static int
8690xmlRelaxNGValidateValueList(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 */
8713static int
8714xmlRelaxNGValidateValue(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 /* Falls through. */
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 */
9002static int
9003xmlRelaxNGValidateValueContent(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 */
9027static int
9028xmlRelaxNGAttributeMatch(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 */
9089static int
9090xmlRelaxNGValidateAttribute(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 */
9199static int
9200xmlRelaxNGValidateAttributeList(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 */
9247static int
9248xmlRelaxNGNodeMatchesList(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 */
9282static int
9283xmlRelaxNGValidateInterleave(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 = ((ptrdiff_t) 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 */
9577static int
9578xmlRelaxNGValidateDefinitionList(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 */
9616static int
9617xmlRelaxNGElementMatch(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 */
9730static int
9731xmlRelaxNGBestState(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 */
9769static void
9770xmlRelaxNGLogBestError(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 */
9797static int
9798xmlRelaxNGValidateElementEnd(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 */
9835static int
9836xmlRelaxNGValidateState(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 /* Falls through. */
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 */
10603static int
10604xmlRelaxNGValidateDefinition(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 */
10732static int
10733xmlRelaxNGValidateDocument(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 */
10830static void
10831xmlRelaxNGCleanPSVI(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 */
10885xmlRelaxNGValidCtxtPtr
10886xmlRelaxNGNewValidCtxt(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 */
10918void
10919xmlRelaxNGFreeValidCtxt(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 */
10963void
10964xmlRelaxNGSetValidErrors(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 */
10984void
10985xmlRelaxNGSetValidStructuredErrors(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 */
11007int
11008xmlRelaxNGGetValidErrors(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 */
11033int
11034xmlRelaxNGValidateDoc(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 */
11060