VirtualBox

source: vbox/trunk/src/libs/libxml2-2.6.30/schematron.c@ 34034

Last change on this file since 34034 was 6076, checked in by vboxsync, 17 years ago

Merged dmik/s2 branch (r25959:26751) to the trunk.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 45.2 KB
Line 
1/*
2 * schematron.c : implementation of the Schematron schema validity checking
3 *
4 * See Copyright for the status of this software.
5 *
6 * Daniel Veillard <[email protected]>
7 */
8
9/*
10 * TODO:
11 * + double check the semantic, especially
12 * - multiple rules applying in a single pattern/node
13 * - the semantic of libxml2 patterns vs. XSLT production referenced
14 * by the spec.
15 * + export of results in SVRL
16 * + full parsing and coverage of the spec, conformance of the input to the
17 * spec
18 * + divergences between the draft and the ISO proposed standard :-(
19 * + hook and test include
20 * + try and compare with the XSLT version
21 */
22
23#define IN_LIBXML
24#include "libxml.h"
25
26#ifdef LIBXML_SCHEMATRON_ENABLED
27
28#include <string.h>
29#include <libxml/parser.h>
30#include <libxml/tree.h>
31#include <libxml/uri.h>
32#include <libxml/xpath.h>
33#include <libxml/xpathInternals.h>
34#include <libxml/pattern.h>
35#include <libxml/schematron.h>
36
37#define SCHEMATRON_PARSE_OPTIONS XML_PARSE_NOENT
38
39#define SCT_OLD_NS BAD_CAST "http://www.ascc.net/xml/schematron"
40
41#define XML_SCHEMATRON_NS BAD_CAST "http://purl.oclc.org/dsdl/schematron"
42
43
44static const xmlChar *xmlSchematronNs = XML_SCHEMATRON_NS;
45static const xmlChar *xmlOldSchematronNs = SCT_OLD_NS;
46
47#define IS_SCHEMATRON(node, elem) \
48 ((node != NULL) && (node->type == XML_ELEMENT_NODE ) && \
49 (node->ns != NULL) && \
50 (xmlStrEqual(node->name, (const xmlChar *) elem)) && \
51 ((xmlStrEqual(node->ns->href, xmlSchematronNs)) || \
52 (xmlStrEqual(node->ns->href, xmlOldSchematronNs))))
53
54#define NEXT_SCHEMATRON(node) \
55 while (node != NULL) { \
56 if ((node->type == XML_ELEMENT_NODE ) && (node->ns != NULL) && \
57 ((xmlStrEqual(node->ns->href, xmlSchematronNs)) || \
58 (xmlStrEqual(node->ns->href, xmlOldSchematronNs)))) \
59 break; \
60 node = node->next; \
61 }
62
63/**
64 * TODO:
65 *
66 * macro to flag unimplemented blocks
67 */
68#define TODO \
69 xmlGenericError(xmlGenericErrorContext, \
70 "Unimplemented block at %s:%d\n", \
71 __FILE__, __LINE__);
72
73typedef enum {
74 XML_SCHEMATRON_ASSERT=1,
75 XML_SCHEMATRON_REPORT=2
76} xmlSchematronTestType;
77
78/**
79 * _xmlSchematronTest:
80 *
81 * A Schematrons test, either an assert or a report
82 */
83typedef struct _xmlSchematronTest xmlSchematronTest;
84typedef xmlSchematronTest *xmlSchematronTestPtr;
85struct _xmlSchematronTest {
86 xmlSchematronTestPtr next; /* the next test in the list */
87 xmlSchematronTestType type; /* the test type */
88 xmlNodePtr node; /* the node in the tree */
89 xmlChar *test; /* the expression to test */
90 xmlXPathCompExprPtr comp; /* the compiled expression */
91 xmlChar *report; /* the message to report */
92};
93
94/**
95 * _xmlSchematronRule:
96 *
97 * A Schematrons rule
98 */
99typedef struct _xmlSchematronRule xmlSchematronRule;
100typedef xmlSchematronRule *xmlSchematronRulePtr;
101struct _xmlSchematronRule {
102 xmlSchematronRulePtr next; /* the next rule in the list */
103 xmlSchematronRulePtr patnext;/* the next rule in the pattern list */
104 xmlNodePtr node; /* the node in the tree */
105 xmlChar *context; /* the context evaluation rule */
106 xmlSchematronTestPtr tests; /* the list of tests */
107 xmlPatternPtr pattern; /* the compiled pattern associated */
108 xmlChar *report; /* the message to report */
109};
110
111/**
112 * _xmlSchematronPattern:
113 *
114 * A Schematrons pattern
115 */
116typedef struct _xmlSchematronPattern xmlSchematronPattern;
117typedef xmlSchematronPattern *xmlSchematronPatternPtr;
118struct _xmlSchematronPattern {
119 xmlSchematronPatternPtr next;/* the next pattern in the list */
120 xmlSchematronRulePtr rules; /* the list of rules */
121 xmlChar *name; /* the name of the pattern */
122};
123
124/**
125 * _xmlSchematron:
126 *
127 * A Schematrons definition
128 */
129struct _xmlSchematron {
130 const xmlChar *name; /* schema name */
131 int preserve; /* was the document passed by the user */
132 xmlDocPtr doc; /* pointer to the parsed document */
133 int flags; /* specific to this schematron */
134
135 void *_private; /* unused by the library */
136 xmlDictPtr dict; /* the dictionnary used internally */
137
138 const xmlChar *title; /* the title if any */
139
140 int nbNs; /* the number of namespaces */
141
142 int nbPattern; /* the number of patterns */
143 xmlSchematronPatternPtr patterns;/* the patterns found */
144 xmlSchematronRulePtr rules; /* the rules gathered */
145 int nbNamespaces; /* number of namespaces in the array */
146 int maxNamespaces; /* size of the array */
147 const xmlChar **namespaces; /* the array of namespaces */
148};
149
150/**
151 * xmlSchematronValidCtxt:
152 *
153 * A Schematrons validation context
154 */
155struct _xmlSchematronValidCtxt {
156 int type;
157 int flags; /* an or of xmlSchematronValidOptions */
158
159 xmlDictPtr dict;
160 int nberrors;
161 int err;
162
163 xmlSchematronPtr schema;
164 xmlXPathContextPtr xctxt;
165
166 FILE *outputFile; /* if using XML_SCHEMATRON_OUT_FILE */
167 xmlBufferPtr outputBuffer; /* if using XML_SCHEMATRON_OUT_BUFFER */
168 xmlOutputWriteCallback iowrite; /* if using XML_SCHEMATRON_OUT_IO */
169 xmlOutputCloseCallback ioclose;
170 void *ioctx;
171};
172
173struct _xmlSchematronParserCtxt {
174 int type;
175 const xmlChar *URL;
176 xmlDocPtr doc;
177 int preserve; /* Whether the doc should be freed */
178 const char *buffer;
179 int size;
180
181 xmlDictPtr dict; /* dictionnary for interned string names */
182
183 int nberrors;
184 int err;
185 xmlXPathContextPtr xctxt; /* the XPath context used for compilation */
186 xmlSchematronPtr schema;
187
188 int nbNamespaces; /* number of namespaces in the array */
189 int maxNamespaces; /* size of the array */
190 const xmlChar **namespaces; /* the array of namespaces */
191
192 int nbIncludes; /* number of includes in the array */
193 int maxIncludes; /* size of the array */
194 xmlNodePtr *includes; /* the array of includes */
195
196 /* error rreporting data */
197 void *userData; /* user specific data block */
198 xmlSchematronValidityErrorFunc error;/* the callback in case of errors */
199 xmlSchematronValidityWarningFunc warning;/* callback in case of warning */
200 xmlStructuredErrorFunc serror; /* the structured function */
201
202};
203
204#define XML_STRON_CTXT_PARSER 1
205#define XML_STRON_CTXT_VALIDATOR 2
206
207/************************************************************************
208 * *
209 * Error reporting *
210 * *
211 ************************************************************************/
212
213/**
214 * xmlSchematronPErrMemory:
215 * @node: a context node
216 * @extra: extra informations
217 *
218 * Handle an out of memory condition
219 */
220static void
221xmlSchematronPErrMemory(xmlSchematronParserCtxtPtr ctxt,
222 const char *extra, xmlNodePtr node)
223{
224 if (ctxt != NULL)
225 ctxt->nberrors++;
226 __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, node, NULL,
227 extra);
228}
229
230/**
231 * xmlSchematronPErr:
232 * @ctxt: the parsing context
233 * @node: the context node
234 * @error: the error code
235 * @msg: the error message
236 * @str1: extra data
237 * @str2: extra data
238 *
239 * Handle a parser error
240 */
241static void
242xmlSchematronPErr(xmlSchematronParserCtxtPtr ctxt, xmlNodePtr node, int error,
243 const char *msg, const xmlChar * str1, const xmlChar * str2)
244{
245 xmlGenericErrorFunc channel = NULL;
246 xmlStructuredErrorFunc schannel = NULL;
247 void *data = NULL;
248
249 if (ctxt != NULL) {
250 ctxt->nberrors++;
251 channel = ctxt->error;
252 data = ctxt->userData;
253 schannel = ctxt->serror;
254 }
255 __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
256 error, XML_ERR_ERROR, NULL, 0,
257 (const char *) str1, (const char *) str2, NULL, 0, 0,
258 msg, str1, str2);
259}
260
261/**
262 * xmlSchematronVTypeErrMemory:
263 * @node: a context node
264 * @extra: extra informations
265 *
266 * Handle an out of memory condition
267 */
268static void
269xmlSchematronVErrMemory(xmlSchematronValidCtxtPtr ctxt,
270 const char *extra, xmlNodePtr node)
271{
272 if (ctxt != NULL) {
273 ctxt->nberrors++;
274 ctxt->err = XML_SCHEMAV_INTERNAL;
275 }
276 __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
277 extra);
278}
279
280/************************************************************************
281 * *
282 * Parsing and compilation of the Schematrontrons *
283 * *
284 ************************************************************************/
285
286/**
287 * xmlSchematronAddTest:
288 * @ctxt: the schema parsing context
289 * @type: the type of test
290 * @rule: the parent rule
291 * @node: the node hosting the test
292 * @test: the associated test
293 * @report: the associated report string
294 *
295 * Add a test to a schematron
296 *
297 * Returns the new pointer or NULL in case of error
298 */
299static xmlSchematronTestPtr
300xmlSchematronAddTest(xmlSchematronParserCtxtPtr ctxt,
301 xmlSchematronTestType type,
302 xmlSchematronRulePtr rule,
303 xmlNodePtr node, xmlChar *test, xmlChar *report)
304{
305 xmlSchematronTestPtr ret;
306 xmlXPathCompExprPtr comp;
307
308 if ((ctxt == NULL) || (rule == NULL) || (node == NULL) ||
309 (test == NULL))
310 return(NULL);
311
312 /*
313 * try first to compile the test expression
314 */
315 comp = xmlXPathCtxtCompile(ctxt->xctxt, test);
316 if (comp == NULL) {
317 xmlSchematronPErr(ctxt, node,
318 XML_SCHEMAP_NOROOT,
319 "Failed to compile test expression %s",
320 test, NULL);
321 return(NULL);
322 }
323
324 ret = (xmlSchematronTestPtr) xmlMalloc(sizeof(xmlSchematronTest));
325 if (ret == NULL) {
326 xmlSchematronPErrMemory(ctxt, "allocating schema test", node);
327 return (NULL);
328 }
329 memset(ret, 0, sizeof(xmlSchematronTest));
330 ret->type = type;
331 ret->node = node;
332 ret->test = test;
333 ret->comp = comp;
334 ret->report = report;
335 ret->next = NULL;
336 if (rule->tests == NULL) {
337 rule->tests = ret;
338 } else {
339 xmlSchematronTestPtr prev = rule->tests;
340
341 while (prev->next != NULL)
342 prev = prev->next;
343 prev->next = ret;
344 }
345 return (ret);
346}
347
348/**
349 * xmlSchematronFreeTests:
350 * @tests: a list of tests
351 *
352 * Free a list of tests.
353 */
354static void
355xmlSchematronFreeTests(xmlSchematronTestPtr tests) {
356 xmlSchematronTestPtr next;
357
358 while (tests != NULL) {
359 next = tests->next;
360 if (tests->test != NULL)
361 xmlFree(tests->test);
362 if (tests->comp != NULL)
363 xmlXPathFreeCompExpr(tests->comp);
364 if (tests->report != NULL)
365 xmlFree(tests->report);
366 xmlFree(tests);
367 tests = next;
368 }
369}
370
371/**
372 * xmlSchematronAddRule:
373 * @ctxt: the schema parsing context
374 * @schema: a schema structure
375 * @node: the node hosting the rule
376 * @context: the associated context string
377 * @report: the associated report string
378 *
379 * Add a rule to a schematron
380 *
381 * Returns the new pointer or NULL in case of error
382 */
383static xmlSchematronRulePtr
384xmlSchematronAddRule(xmlSchematronParserCtxtPtr ctxt, xmlSchematronPtr schema,
385 xmlSchematronPatternPtr pat, xmlNodePtr node,
386 xmlChar *context, xmlChar *report)
387{
388 xmlSchematronRulePtr ret;
389 xmlPatternPtr pattern;
390
391 if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
392 (context == NULL))
393 return(NULL);
394
395 /*
396 * Try first to compile the pattern
397 */
398 pattern = xmlPatterncompile(context, ctxt->dict, XML_PATTERN_XPATH,
399 ctxt->namespaces);
400 if (pattern == NULL) {
401 xmlSchematronPErr(ctxt, node,
402 XML_SCHEMAP_NOROOT,
403 "Failed to compile context expression %s",
404 context, NULL);
405 }
406
407 ret = (xmlSchematronRulePtr) xmlMalloc(sizeof(xmlSchematronRule));
408 if (ret == NULL) {
409 xmlSchematronPErrMemory(ctxt, "allocating schema rule", node);
410 return (NULL);
411 }
412 memset(ret, 0, sizeof(xmlSchematronRule));
413 ret->node = node;
414 ret->context = context;
415 ret->pattern = pattern;
416 ret->report = report;
417 ret->next = NULL;
418 if (schema->rules == NULL) {
419 schema->rules = ret;
420 } else {
421 xmlSchematronRulePtr prev = schema->rules;
422
423 while (prev->next != NULL)
424 prev = prev->next;
425 prev->next = ret;
426 }
427 ret->patnext = NULL;
428 if (pat->rules == NULL) {
429 pat->rules = ret;
430 } else {
431 xmlSchematronRulePtr prev = pat->rules;
432
433 while (prev->patnext != NULL)
434 prev = prev->patnext;
435 prev->patnext = ret;
436 }
437 return (ret);
438}
439
440/**
441 * xmlSchematronFreeRules:
442 * @rules: a list of rules
443 *
444 * Free a list of rules.
445 */
446static void
447xmlSchematronFreeRules(xmlSchematronRulePtr rules) {
448 xmlSchematronRulePtr next;
449
450 while (rules != NULL) {
451 next = rules->next;
452 if (rules->tests)
453 xmlSchematronFreeTests(rules->tests);
454 if (rules->context != NULL)
455 xmlFree(rules->context);
456 if (rules->pattern)
457 xmlFreePattern(rules->pattern);
458 if (rules->report != NULL)
459 xmlFree(rules->report);
460 xmlFree(rules);
461 rules = next;
462 }
463}
464
465/**
466 * xmlSchematronAddPattern:
467 * @ctxt: the schema parsing context
468 * @schema: a schema structure
469 * @node: the node hosting the pattern
470 * @id: the id or name of the pattern
471 *
472 * Add a pattern to a schematron
473 *
474 * Returns the new pointer or NULL in case of error
475 */
476static xmlSchematronPatternPtr
477xmlSchematronAddPattern(xmlSchematronParserCtxtPtr ctxt,
478 xmlSchematronPtr schema, xmlNodePtr node, xmlChar *name)
479{
480 xmlSchematronPatternPtr ret;
481
482 if ((ctxt == NULL) || (schema == NULL) || (node == NULL) || (name == NULL))
483 return(NULL);
484
485 ret = (xmlSchematronPatternPtr) xmlMalloc(sizeof(xmlSchematronPattern));
486 if (ret == NULL) {
487 xmlSchematronPErrMemory(ctxt, "allocating schema pattern", node);
488 return (NULL);
489 }
490 memset(ret, 0, sizeof(xmlSchematronPattern));
491 ret->name = name;
492 ret->next = NULL;
493 if (schema->patterns == NULL) {
494 schema->patterns = ret;
495 } else {
496 xmlSchematronPatternPtr prev = schema->patterns;
497
498 while (prev->next != NULL)
499 prev = prev->next;
500 prev->next = ret;
501 }
502 return (ret);
503}
504
505/**
506 * xmlSchematronFreePatterns:
507 * @patterns: a list of patterns
508 *
509 * Free a list of patterns.
510 */
511static void
512xmlSchematronFreePatterns(xmlSchematronPatternPtr patterns) {
513 xmlSchematronPatternPtr next;
514
515 while (patterns != NULL) {
516 next = patterns->next;
517 if (patterns->name != NULL)
518 xmlFree(patterns->name);
519 xmlFree(patterns);
520 patterns = next;
521 }
522}
523
524/**
525 * xmlSchematronNewSchematron:
526 * @ctxt: a schema validation context
527 *
528 * Allocate a new Schematron structure.
529 *
530 * Returns the newly allocated structure or NULL in case or error
531 */
532static xmlSchematronPtr
533xmlSchematronNewSchematron(xmlSchematronParserCtxtPtr ctxt)
534{
535 xmlSchematronPtr ret;
536
537 ret = (xmlSchematronPtr) xmlMalloc(sizeof(xmlSchematron));
538 if (ret == NULL) {
539 xmlSchematronPErrMemory(ctxt, "allocating schema", NULL);
540 return (NULL);
541 }
542 memset(ret, 0, sizeof(xmlSchematron));
543 ret->dict = ctxt->dict;
544 xmlDictReference(ret->dict);
545
546 return (ret);
547}
548
549/**
550 * xmlSchematronFree:
551 * @schema: a schema structure
552 *
553 * Deallocate a Schematron structure.
554 */
555void
556xmlSchematronFree(xmlSchematronPtr schema)
557{
558 if (schema == NULL)
559 return;
560
561 if ((schema->doc != NULL) && (!(schema->preserve)))
562 xmlFreeDoc(schema->doc);
563
564 if (schema->namespaces != NULL)
565 xmlFree((char **) schema->namespaces);
566
567 xmlSchematronFreeRules(schema->rules);
568 xmlSchematronFreePatterns(schema->patterns);
569 xmlDictFree(schema->dict);
570 xmlFree(schema);
571}
572
573/**
574 * xmlSchematronNewParserCtxt:
575 * @URL: the location of the schema
576 *
577 * Create an XML Schematrons parse context for that file/resource expected
578 * to contain an XML Schematrons file.
579 *
580 * Returns the parser context or NULL in case of error
581 */
582xmlSchematronParserCtxtPtr
583xmlSchematronNewParserCtxt(const char *URL)
584{
585 xmlSchematronParserCtxtPtr ret;
586
587 if (URL == NULL)
588 return (NULL);
589
590 ret =
591 (xmlSchematronParserCtxtPtr)
592 xmlMalloc(sizeof(xmlSchematronParserCtxt));
593 if (ret == NULL) {
594 xmlSchematronPErrMemory(NULL, "allocating schema parser context",
595 NULL);
596 return (NULL);
597 }
598 memset(ret, 0, sizeof(xmlSchematronParserCtxt));
599 ret->type = XML_STRON_CTXT_PARSER;
600 ret->dict = xmlDictCreate();
601 ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
602 ret->includes = NULL;
603 ret->xctxt = xmlXPathNewContext(NULL);
604 if (ret->xctxt == NULL) {
605 xmlSchematronPErrMemory(NULL, "allocating schema parser XPath context",
606 NULL);
607 xmlSchematronFreeParserCtxt(ret);
608 return (NULL);
609 }
610 ret->xctxt->flags = XML_XPATH_CHECKNS;
611 return (ret);
612}
613
614/**
615 * xmlSchematronNewMemParserCtxt:
616 * @buffer: a pointer to a char array containing the schemas
617 * @size: the size of the array
618 *
619 * Create an XML Schematrons parse context for that memory buffer expected
620 * to contain an XML Schematrons file.
621 *
622 * Returns the parser context or NULL in case of error
623 */
624xmlSchematronParserCtxtPtr
625xmlSchematronNewMemParserCtxt(const char *buffer, int size)
626{
627 xmlSchematronParserCtxtPtr ret;
628
629 if ((buffer == NULL) || (size <= 0))
630 return (NULL);
631
632 ret =
633 (xmlSchematronParserCtxtPtr)
634 xmlMalloc(sizeof(xmlSchematronParserCtxt));
635 if (ret == NULL) {
636 xmlSchematronPErrMemory(NULL, "allocating schema parser context",
637 NULL);
638 return (NULL);
639 }
640 memset(ret, 0, sizeof(xmlSchematronParserCtxt));
641 ret->buffer = buffer;
642 ret->size = size;
643 ret->dict = xmlDictCreate();
644 ret->xctxt = xmlXPathNewContext(NULL);
645 if (ret->xctxt == NULL) {
646 xmlSchematronPErrMemory(NULL, "allocating schema parser XPath context",
647 NULL);
648 xmlSchematronFreeParserCtxt(ret);
649 return (NULL);
650 }
651 return (ret);
652}
653
654/**
655 * xmlSchematronNewDocParserCtxt:
656 * @doc: a preparsed document tree
657 *
658 * Create an XML Schematrons parse context for that document.
659 * NB. The document may be modified during the parsing process.
660 *
661 * Returns the parser context or NULL in case of error
662 */
663xmlSchematronParserCtxtPtr
664xmlSchematronNewDocParserCtxt(xmlDocPtr doc)
665{
666 xmlSchematronParserCtxtPtr ret;
667
668 if (doc == NULL)
669 return (NULL);
670
671 ret =
672 (xmlSchematronParserCtxtPtr)
673 xmlMalloc(sizeof(xmlSchematronParserCtxt));
674 if (ret == NULL) {
675 xmlSchematronPErrMemory(NULL, "allocating schema parser context",
676 NULL);
677 return (NULL);
678 }
679 memset(ret, 0, sizeof(xmlSchematronParserCtxt));
680 ret->doc = doc;
681 ret->dict = xmlDictCreate();
682 /* The application has responsibility for the document */
683 ret->preserve = 1;
684 ret->xctxt = xmlXPathNewContext(doc);
685 if (ret->xctxt == NULL) {
686 xmlSchematronPErrMemory(NULL, "allocating schema parser XPath context",
687 NULL);
688 xmlSchematronFreeParserCtxt(ret);
689 return (NULL);
690 }
691
692 return (ret);
693}
694
695/**
696 * xmlSchematronFreeParserCtxt:
697 * @ctxt: the schema parser context
698 *
699 * Free the resources associated to the schema parser context
700 */
701void
702xmlSchematronFreeParserCtxt(xmlSchematronParserCtxtPtr ctxt)
703{
704 if (ctxt == NULL)
705 return;
706 if (ctxt->doc != NULL && !ctxt->preserve)
707 xmlFreeDoc(ctxt->doc);
708 if (ctxt->xctxt != NULL) {
709 xmlXPathFreeContext(ctxt->xctxt);
710 }
711 if (ctxt->namespaces != NULL)
712 xmlFree((char **) ctxt->namespaces);
713 xmlDictFree(ctxt->dict);
714 xmlFree(ctxt);
715}
716
717#if 0
718/**
719 * xmlSchematronPushInclude:
720 * @ctxt: the schema parser context
721 * @doc: the included document
722 * @cur: the current include node
723 *
724 * Add an included document
725 */
726static void
727xmlSchematronPushInclude(xmlSchematronParserCtxtPtr ctxt,
728 xmlDocPtr doc, xmlNodePtr cur)
729{
730 if (ctxt->includes == NULL) {
731 ctxt->maxIncludes = 10;
732 ctxt->includes = (xmlNodePtr *)
733 xmlMalloc(ctxt->maxIncludes * 2 * sizeof(xmlNodePtr));
734 if (ctxt->includes == NULL) {
735 xmlSchematronPErrMemory(NULL, "allocating parser includes",
736 NULL);
737 return;
738 }
739 ctxt->nbIncludes = 0;
740 } else if (ctxt->nbIncludes + 2 >= ctxt->maxIncludes) {
741 xmlNodePtr *tmp;
742
743 tmp = (xmlNodePtr *)
744 xmlRealloc(ctxt->includes, ctxt->maxIncludes * 4 *
745 sizeof(xmlNodePtr));
746 if (tmp == NULL) {
747 xmlSchematronPErrMemory(NULL, "allocating parser includes",
748 NULL);
749 return;
750 }
751 ctxt->includes = tmp;
752 ctxt->maxIncludes *= 2;
753 }
754 ctxt->includes[2 * ctxt->nbIncludes] = cur;
755 ctxt->includes[2 * ctxt->nbIncludes + 1] = (xmlNodePtr) doc;
756 ctxt->nbIncludes++;
757}
758
759/**
760 * xmlSchematronPopInclude:
761 * @ctxt: the schema parser context
762 *
763 * Pop an include level. The included document is being freed
764 *
765 * Returns the node immediately following the include or NULL if the
766 * include list was empty.
767 */
768static xmlNodePtr
769xmlSchematronPopInclude(xmlSchematronParserCtxtPtr ctxt)
770{
771 xmlDocPtr doc;
772 xmlNodePtr ret;
773
774 if (ctxt->nbIncludes <= 0)
775 return(NULL);
776 ctxt->nbIncludes--;
777 doc = (xmlDocPtr) ctxt->includes[2 * ctxt->nbIncludes + 1];
778 ret = ctxt->includes[2 * ctxt->nbIncludes];
779 xmlFreeDoc(doc);
780 if (ret != NULL)
781 ret = ret->next;
782 if (ret == NULL)
783 return(xmlSchematronPopInclude(ctxt));
784 return(ret);
785}
786#endif
787
788/**
789 * xmlSchematronAddNamespace:
790 * @ctxt: the schema parser context
791 * @prefix: the namespace prefix
792 * @ns: the namespace name
793 *
794 * Add a namespace definition in the context
795 */
796static void
797xmlSchematronAddNamespace(xmlSchematronParserCtxtPtr ctxt,
798 const xmlChar *prefix, const xmlChar *ns)
799{
800 if (ctxt->namespaces == NULL) {
801 ctxt->maxNamespaces = 10;
802 ctxt->namespaces = (const xmlChar **)
803 xmlMalloc(ctxt->maxNamespaces * 2 * sizeof(const xmlChar *));
804 if (ctxt->namespaces == NULL) {
805 xmlSchematronPErrMemory(NULL, "allocating parser namespaces",
806 NULL);
807 return;
808 }
809 ctxt->nbNamespaces = 0;
810 } else if (ctxt->nbNamespaces + 2 >= ctxt->maxNamespaces) {
811 const xmlChar **tmp;
812
813 tmp = (const xmlChar **)
814 xmlRealloc((xmlChar **) ctxt->namespaces, ctxt->maxNamespaces * 4 *
815 sizeof(const xmlChar *));
816 if (tmp == NULL) {
817 xmlSchematronPErrMemory(NULL, "allocating parser namespaces",
818 NULL);
819 return;
820 }
821 ctxt->namespaces = tmp;
822 ctxt->maxNamespaces *= 2;
823 }
824 ctxt->namespaces[2 * ctxt->nbNamespaces] =
825 xmlDictLookup(ctxt->dict, ns, -1);
826 ctxt->namespaces[2 * ctxt->nbNamespaces + 1] =
827 xmlDictLookup(ctxt->dict, prefix, -1);
828 ctxt->nbNamespaces++;
829 ctxt->namespaces[2 * ctxt->nbNamespaces] = NULL;
830 ctxt->namespaces[2 * ctxt->nbNamespaces + 1] = NULL;
831
832}
833
834/**
835 * xmlSchematronParseRule:
836 * @ctxt: a schema validation context
837 * @rule: the rule node
838 *
839 * parse a rule element
840 */
841static void
842xmlSchematronParseRule(xmlSchematronParserCtxtPtr ctxt,
843 xmlSchematronPatternPtr pattern,
844 xmlNodePtr rule)
845{
846 xmlNodePtr cur;
847 int nbChecks = 0;
848 xmlChar *test;
849 xmlChar *context;
850 xmlChar *report;
851 xmlSchematronRulePtr ruleptr;
852 xmlSchematronTestPtr testptr;
853
854 if ((ctxt == NULL) || (rule == NULL)) return;
855
856 context = xmlGetNoNsProp(rule, BAD_CAST "context");
857 if (context == NULL) {
858 xmlSchematronPErr(ctxt, rule,
859 XML_SCHEMAP_NOROOT,
860 "rule has no context attribute",
861 NULL, NULL);
862 return;
863 } else if (context[0] == 0) {
864 xmlSchematronPErr(ctxt, rule,
865 XML_SCHEMAP_NOROOT,
866 "rule has an empty context attribute",
867 NULL, NULL);
868 xmlFree(context);
869 return;
870 } else {
871 ruleptr = xmlSchematronAddRule(ctxt, ctxt->schema, pattern,
872 rule, context, NULL);
873 if (ruleptr == NULL) {
874 xmlFree(context);
875 return;
876 }
877 }
878
879 cur = rule->children;
880 NEXT_SCHEMATRON(cur);
881 while (cur != NULL) {
882 if (IS_SCHEMATRON(cur, "assert")) {
883 nbChecks++;
884 test = xmlGetNoNsProp(cur, BAD_CAST "test");
885 if (test == NULL) {
886 xmlSchematronPErr(ctxt, cur,
887 XML_SCHEMAP_NOROOT,
888 "assert has no test attribute",
889 NULL, NULL);
890 } else if (test[0] == 0) {
891 xmlSchematronPErr(ctxt, cur,
892 XML_SCHEMAP_NOROOT,
893 "assert has an empty test attribute",
894 NULL, NULL);
895 xmlFree(test);
896 } else {
897 /* TODO will need dynamic processing instead */
898 report = xmlNodeGetContent(cur);
899
900 testptr = xmlSchematronAddTest(ctxt, XML_SCHEMATRON_ASSERT,
901 ruleptr, cur, test, report);
902 if (testptr == NULL)
903 xmlFree(test);
904 }
905 } else if (IS_SCHEMATRON(cur, "report")) {
906 nbChecks++;
907 test = xmlGetNoNsProp(cur, BAD_CAST "test");
908 if (test == NULL) {
909 xmlSchematronPErr(ctxt, cur,
910 XML_SCHEMAP_NOROOT,
911 "assert has no test attribute",
912 NULL, NULL);
913 } else if (test[0] == 0) {
914 xmlSchematronPErr(ctxt, cur,
915 XML_SCHEMAP_NOROOT,
916 "assert has an empty test attribute",
917 NULL, NULL);
918 xmlFree(test);
919 } else {
920 /* TODO will need dynamic processing instead */
921 report = xmlNodeGetContent(cur);
922
923 testptr = xmlSchematronAddTest(ctxt, XML_SCHEMATRON_REPORT,
924 ruleptr, cur, test, report);
925 if (testptr == NULL)
926 xmlFree(test);
927 }
928 } else {
929 xmlSchematronPErr(ctxt, cur,
930 XML_SCHEMAP_NOROOT,
931 "Expecting an assert or a report element instead of %s",
932 cur->name, NULL);
933 }
934 cur = cur->next;
935 NEXT_SCHEMATRON(cur);
936 }
937 if (nbChecks == 0) {
938 xmlSchematronPErr(ctxt, rule,
939 XML_SCHEMAP_NOROOT,
940 "rule has no assert nor report element", NULL, NULL);
941 }
942}
943
944/**
945 * xmlSchematronParsePattern:
946 * @ctxt: a schema validation context
947 * @pat: the pattern node
948 *
949 * parse a pattern element
950 */
951static void
952xmlSchematronParsePattern(xmlSchematronParserCtxtPtr ctxt, xmlNodePtr pat)
953{
954 xmlNodePtr cur;
955 xmlSchematronPatternPtr pattern;
956 int nbRules = 0;
957 xmlChar *id;
958
959 if ((ctxt == NULL) || (pat == NULL)) return;
960
961 id = xmlGetNoNsProp(pat, BAD_CAST "id");
962 if (id == NULL) {
963 id = xmlGetNoNsProp(pat, BAD_CAST "name");
964 }
965 pattern = xmlSchematronAddPattern(ctxt, ctxt->schema, pat, id);
966 if (pattern == NULL) {
967 if (id != NULL)
968 xmlFree(id);
969 return;
970 }
971 cur = pat->children;
972 NEXT_SCHEMATRON(cur);
973 while (cur != NULL) {
974 if (IS_SCHEMATRON(cur, "rule")) {
975 xmlSchematronParseRule(ctxt, pattern, cur);
976 nbRules++;
977 } else {
978 xmlSchematronPErr(ctxt, cur,
979 XML_SCHEMAP_NOROOT,
980 "Expecting a rule element instead of %s", cur->name, NULL);
981 }
982 cur = cur->next;
983 NEXT_SCHEMATRON(cur);
984 }
985 if (nbRules == 0) {
986 xmlSchematronPErr(ctxt, pat,
987 XML_SCHEMAP_NOROOT,
988 "Pattern has no rule element", NULL, NULL);
989 }
990}
991
992#if 0
993/**
994 * xmlSchematronLoadInclude:
995 * @ctxt: a schema validation context
996 * @cur: the include element
997 *
998 * Load the include document, Push the current pointer
999 *
1000 * Returns the updated node pointer
1001 */
1002static xmlNodePtr
1003xmlSchematronLoadInclude(xmlSchematronParserCtxtPtr ctxt, xmlNodePtr cur)
1004{
1005 xmlNodePtr ret = NULL;
1006 xmlDocPtr doc = NULL;
1007 xmlChar *href = NULL;
1008 xmlChar *base = NULL;
1009 xmlChar *URI = NULL;
1010
1011 if ((ctxt == NULL) || (cur == NULL))
1012 return(NULL);
1013
1014 href = xmlGetNoNsProp(cur, BAD_CAST "href");
1015 if (href == NULL) {
1016 xmlSchematronPErr(ctxt, cur,
1017 XML_SCHEMAP_NOROOT,
1018 "Include has no href attribute", NULL, NULL);
1019 return(cur->next);
1020 }
1021
1022 /* do the URI base composition, load and find the root */
1023 base = xmlNodeGetBase(cur->doc, cur);
1024 URI = xmlBuildURI(href, base);
1025 doc = xmlReadFile((const char *) URI, NULL, SCHEMATRON_PARSE_OPTIONS);
1026 if (doc == NULL) {
1027 xmlSchematronPErr(ctxt, cur,
1028 XML_SCHEMAP_FAILED_LOAD,
1029 "could not load include '%s'.\n",
1030 URI, NULL);
1031 goto done;
1032 }
1033 ret = xmlDocGetRootElement(doc);
1034 if (ret == NULL) {
1035 xmlSchematronPErr(ctxt, cur,
1036 XML_SCHEMAP_FAILED_LOAD,
1037 "could not find root from include '%s'.\n",
1038 URI, NULL);
1039 goto done;
1040 }
1041
1042 /* Success, push the include for rollback on exit */
1043 xmlSchematronPushInclude(ctxt, doc, cur);
1044
1045done:
1046 if (ret == NULL) {
1047 if (doc != NULL)
1048 xmlFreeDoc(doc);
1049 }
1050 xmlFree(href);
1051 if (base != NULL)
1052 xmlFree(base);
1053 if (URI != NULL)
1054 xmlFree(URI);
1055 return(ret);
1056}
1057#endif
1058
1059/**
1060 * xmlSchematronParse:
1061 * @ctxt: a schema validation context
1062 *
1063 * parse a schema definition resource and build an internal
1064 * XML Shema struture which can be used to validate instances.
1065 *
1066 * Returns the internal XML Schematron structure built from the resource or
1067 * NULL in case of error
1068 */
1069xmlSchematronPtr
1070xmlSchematronParse(xmlSchematronParserCtxtPtr ctxt)
1071{
1072 xmlSchematronPtr ret = NULL;
1073 xmlDocPtr doc;
1074 xmlNodePtr root, cur;
1075 int preserve = 0;
1076
1077 if (ctxt == NULL)
1078 return (NULL);
1079
1080 ctxt->nberrors = 0;
1081
1082 /*
1083 * First step is to parse the input document into an DOM/Infoset
1084 */
1085 if (ctxt->URL != NULL) {
1086 doc = xmlReadFile((const char *) ctxt->URL, NULL,
1087 SCHEMATRON_PARSE_OPTIONS);
1088 if (doc == NULL) {
1089 xmlSchematronPErr(ctxt, NULL,
1090 XML_SCHEMAP_FAILED_LOAD,
1091 "xmlSchematronParse: could not load '%s'.\n",
1092 ctxt->URL, NULL);
1093 return (NULL);
1094 }
1095 ctxt->preserve = 0;
1096 } else if (ctxt->buffer != NULL) {
1097 doc = xmlReadMemory(ctxt->buffer, ctxt->size, NULL, NULL,
1098 SCHEMATRON_PARSE_OPTIONS);
1099 if (doc == NULL) {
1100 xmlSchematronPErr(ctxt, NULL,
1101 XML_SCHEMAP_FAILED_PARSE,
1102 "xmlSchematronParse: could not parse.\n",
1103 NULL, NULL);
1104 return (NULL);
1105 }
1106 doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
1107 ctxt->URL = xmlDictLookup(ctxt->dict, BAD_CAST "in_memory_buffer", -1);
1108 ctxt->preserve = 0;
1109 } else if (ctxt->doc != NULL) {
1110 doc = ctxt->doc;
1111 preserve = 1;
1112 ctxt->preserve = 1;
1113 } else {
1114 xmlSchematronPErr(ctxt, NULL,
1115 XML_SCHEMAP_NOTHING_TO_PARSE,
1116 "xmlSchematronParse: could not parse.\n",
1117 NULL, NULL);
1118 return (NULL);
1119 }
1120
1121 /*
1122 * Then extract the root and Schematron parse it
1123 */
1124 root = xmlDocGetRootElement(doc);
1125 if (root == NULL) {
1126 xmlSchematronPErr(ctxt, (xmlNodePtr) doc,
1127 XML_SCHEMAP_NOROOT,
1128 "The schema has no document element.\n", NULL, NULL);
1129 if (!preserve) {
1130 xmlFreeDoc(doc);
1131 }
1132 return (NULL);
1133 }
1134
1135 if (!IS_SCHEMATRON(root, "schema")) {
1136 xmlSchematronPErr(ctxt, root,
1137 XML_SCHEMAP_NOROOT,
1138 "The XML document '%s' is not a XML schematron document",
1139 ctxt->URL, NULL);
1140 goto exit;
1141 }
1142 ret = xmlSchematronNewSchematron(ctxt);
1143 if (ret == NULL)
1144 goto exit;
1145 ctxt->schema = ret;
1146
1147 /*
1148 * scan the schema elements
1149 */
1150 cur = root->children;
1151 NEXT_SCHEMATRON(cur);
1152 if (IS_SCHEMATRON(cur, "title")) {
1153 xmlChar *title = xmlNodeGetContent(cur);
1154 if (title != NULL) {
1155 ret->title = xmlDictLookup(ret->dict, title, -1);
1156 xmlFree(title);
1157 }
1158 cur = cur->next;
1159 NEXT_SCHEMATRON(cur);
1160 }
1161 while (IS_SCHEMATRON(cur, "ns")) {
1162 xmlChar *prefix = xmlGetNoNsProp(cur, BAD_CAST "prefix");
1163 xmlChar *uri = xmlGetNoNsProp(cur, BAD_CAST "uri");
1164 if ((uri == NULL) || (uri[0] == 0)) {
1165 xmlSchematronPErr(ctxt, cur,
1166 XML_SCHEMAP_NOROOT,
1167 "ns element has no uri", NULL, NULL);
1168 }
1169 if ((prefix == NULL) || (prefix[0] == 0)) {
1170 xmlSchematronPErr(ctxt, cur,
1171 XML_SCHEMAP_NOROOT,
1172 "ns element has no prefix", NULL, NULL);
1173 }
1174 if ((prefix) && (uri)) {
1175 xmlXPathRegisterNs(ctxt->xctxt, prefix, uri);
1176 xmlSchematronAddNamespace(ctxt, prefix, uri);
1177 ret->nbNs++;
1178 }
1179 if (uri)
1180 xmlFree(uri);
1181 if (prefix)
1182 xmlFree(prefix);
1183 cur = cur->next;
1184 NEXT_SCHEMATRON(cur);
1185 }
1186 while (cur != NULL) {
1187 if (IS_SCHEMATRON(cur, "pattern")) {
1188 xmlSchematronParsePattern(ctxt, cur);
1189 ret->nbPattern++;
1190 } else {
1191 xmlSchematronPErr(ctxt, cur,
1192 XML_SCHEMAP_NOROOT,
1193 "Expecting a pattern element instead of %s", cur->name, NULL);
1194 }
1195 cur = cur->next;
1196 NEXT_SCHEMATRON(cur);
1197 }
1198 if (ret->nbPattern == 0) {
1199 xmlSchematronPErr(ctxt, root,
1200 XML_SCHEMAP_NOROOT,
1201 "The schematron document '%s' has no pattern",
1202 ctxt->URL, NULL);
1203 goto exit;
1204 }
1205 /* the original document must be kept for reporting */
1206 ret->doc = doc;
1207 preserve = 1;
1208
1209exit:
1210 if (!preserve) {
1211 xmlFreeDoc(doc);
1212 }
1213 if (ret != NULL) {
1214 if (ctxt->nberrors != 0) {
1215 xmlSchematronFree(ret);
1216 ret = NULL;
1217 } else {
1218 ret->namespaces = ctxt->namespaces;
1219 ret->nbNamespaces = ctxt->nbNamespaces;
1220 ctxt->namespaces = NULL;
1221 }
1222 }
1223 return (ret);
1224}
1225
1226/************************************************************************
1227 * *
1228 * Schematrontron Reports handler *
1229 * *
1230 ************************************************************************/
1231
1232static xmlNodePtr
1233xmlSchematronGetNode(xmlSchematronValidCtxtPtr ctxt,
1234 xmlNodePtr cur, const xmlChar *xpath) {
1235 xmlNodePtr node = NULL;
1236 xmlXPathObjectPtr ret;
1237
1238 if ((ctxt == NULL) || (cur == NULL) || (xpath == NULL))
1239 return(NULL);
1240
1241 ctxt->xctxt->doc = cur->doc;
1242 ctxt->xctxt->node = cur;
1243 ret = xmlXPathEval(xpath, ctxt->xctxt);
1244 if (ret == NULL)
1245 return(NULL);
1246
1247 if ((ret->type == XPATH_NODESET) &&
1248 (ret->nodesetval != NULL) && (ret->nodesetval->nodeNr > 0))
1249 node = ret->nodesetval->nodeTab[0];
1250
1251 xmlXPathFreeObject(ret);
1252 return(node);
1253}
1254
1255/**
1256 * xmlSchematronReportOutput:
1257 * @ctxt: the validation context
1258 * @cur: the current node tested
1259 * @msg: the message output
1260 *
1261 * Output part of the report to whatever channel the user selected
1262 */
1263static void
1264xmlSchematronReportOutput(xmlSchematronValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
1265 xmlNodePtr cur ATTRIBUTE_UNUSED,
1266 const char *msg) {
1267 /* TODO */
1268 fprintf(stderr, "%s", msg);
1269}
1270
1271/**
1272 * xmlSchematronFormatReport:
1273 * @ctxt: the validation context
1274 * @test: the test node
1275 * @cur: the current node tested
1276 *
1277 * Build the string being reported to the user.
1278 *
1279 * Returns a report string or NULL in case of error. The string needs
1280 * to be deallocated by teh caller
1281 */
1282static xmlChar *
1283xmlSchematronFormatReport(xmlSchematronValidCtxtPtr ctxt,
1284 xmlNodePtr test, xmlNodePtr cur) {
1285 xmlChar *ret = NULL;
1286 xmlNodePtr child, node;
1287
1288 if ((test == NULL) || (cur == NULL))
1289 return(ret);
1290
1291 child = test->children;
1292 while (child != NULL) {
1293 if ((child->type == XML_TEXT_NODE) ||
1294 (child->type == XML_CDATA_SECTION_NODE))
1295 ret = xmlStrcat(ret, child->content);
1296 else if (IS_SCHEMATRON(child, "name")) {
1297 xmlChar *path;
1298
1299 path = xmlGetNoNsProp(child, BAD_CAST "path");
1300
1301 node = cur;
1302 if (path != NULL) {
1303 node = xmlSchematronGetNode(ctxt, cur, path);
1304 if (node == NULL)
1305 node = cur;
1306 xmlFree(path);
1307 }
1308
1309 if ((node->ns == NULL) || (node->ns->prefix == NULL))
1310 ret = xmlStrcat(ret, node->name);
1311 else {
1312 ret = xmlStrcat(ret, node->ns->prefix);
1313 ret = xmlStrcat(ret, BAD_CAST ":");
1314 ret = xmlStrcat(ret, node->name);
1315 }
1316 } else {
1317 child = child->next;
1318 continue;
1319 }
1320
1321 /*
1322 * remove superfluous \n
1323 */
1324 if (ret != NULL) {
1325 int len = xmlStrlen(ret);
1326 xmlChar c;
1327
1328 if (len > 0) {
1329 c = ret[len - 1];
1330 if ((c == ' ') || (c == '\n') || (c == '\r') || (c == '\t')) {
1331 while ((c == ' ') || (c == '\n') ||
1332 (c == '\r') || (c == '\t')) {
1333 len--;
1334 if (len == 0)
1335 break;
1336 c = ret[len - 1];
1337 }
1338 ret[len] = ' ';
1339 ret[len + 1] = 0;
1340 }
1341 }
1342 }
1343
1344 child = child->next;
1345 }
1346 return(ret);
1347}
1348
1349/**
1350 * xmlSchematronReportSuccess:
1351 * @ctxt: the validation context
1352 * @test: the compiled test
1353 * @cur: the current node tested
1354 * @success: boolean value for the result
1355 *
1356 * called from the validation engine when an assert or report test have
1357 * been done.
1358 */
1359static void
1360xmlSchematronReportSuccess(xmlSchematronValidCtxtPtr ctxt,
1361 xmlSchematronTestPtr test, xmlNodePtr cur, int success) {
1362 if ((ctxt == NULL) || (cur == NULL) || (test == NULL))
1363 return;
1364 /* if quiet and not SVRL report only failures */
1365 if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) &&
1366 ((ctxt->flags & XML_SCHEMATRON_OUT_XML) == 0) &&
1367 (test->type == XML_SCHEMATRON_REPORT))
1368 return;
1369 if (ctxt->flags & XML_SCHEMATRON_OUT_XML) {
1370 TODO
1371 } else {
1372 xmlChar *path;
1373 char msg[1000];
1374 long line;
1375 const xmlChar *report = NULL;
1376
1377 if (((test->type == XML_SCHEMATRON_REPORT) & (!success)) ||
1378 ((test->type == XML_SCHEMATRON_ASSERT) & (success)))
1379 return;
1380 line = xmlGetLineNo(cur);
1381 path = xmlGetNodePath(cur);
1382 if (path == NULL)
1383 path = (xmlChar *) cur->name;
1384#if 0
1385 if ((test->report != NULL) && (test->report[0] != 0))
1386 report = test->report;
1387#endif
1388 if (test->node != NULL)
1389 report = xmlSchematronFormatReport(ctxt, test->node, cur);
1390 if (report == NULL) {
1391 if (test->type == XML_SCHEMATRON_ASSERT) {
1392 snprintf(msg, 999, "%s line %ld: node failed assert\n",
1393 (const char *) path, line);
1394 } else {
1395 snprintf(msg, 999, "%s line %ld: node failed report\n",
1396 (const char *) path, line);
1397 }
1398 } else {
1399 snprintf(msg, 999, "%s line %ld: %s\n", (const char *) path,
1400 line, (const char *) report);
1401 xmlFree((char *) report);
1402 }
1403 xmlSchematronReportOutput(ctxt, cur, &msg[0]);
1404 if ((path != NULL) && (path != (xmlChar *) cur->name))
1405 xmlFree(path);
1406 }
1407}
1408
1409/**
1410 * xmlSchematronReportPattern:
1411 * @ctxt: the validation context
1412 * @pattern: the current pattern
1413 *
1414 * called from the validation engine when starting to check a pattern
1415 */
1416static void
1417xmlSchematronReportPattern(xmlSchematronValidCtxtPtr ctxt,
1418 xmlSchematronPatternPtr pattern) {
1419 if ((ctxt == NULL) || (pattern == NULL))
1420 return;
1421 if (ctxt->flags & XML_SCHEMATRON_OUT_QUIET)
1422 return;
1423 if (ctxt->flags & XML_SCHEMATRON_OUT_XML) {
1424 TODO
1425 } else {
1426 char msg[1000];
1427
1428 if (pattern->name == NULL)
1429 return;
1430 snprintf(msg, 999, "Pattern: %s\n", (const char *) pattern->name);
1431 xmlSchematronReportOutput(ctxt, NULL, &msg[0]);
1432 }
1433}
1434
1435
1436/************************************************************************
1437 * *
1438 * Validation against a Schematrontron *
1439 * *
1440 ************************************************************************/
1441
1442/**
1443 * xmlSchematronNewValidCtxt:
1444 * @schema: a precompiled XML Schematrons
1445 * @options: a set of xmlSchematronValidOptions
1446 *
1447 * Create an XML Schematrons validation context based on the given schema.
1448 *
1449 * Returns the validation context or NULL in case of error
1450 */
1451xmlSchematronValidCtxtPtr
1452xmlSchematronNewValidCtxt(xmlSchematronPtr schema, int options)
1453{
1454 int i;
1455 xmlSchematronValidCtxtPtr ret;
1456
1457 ret = (xmlSchematronValidCtxtPtr) xmlMalloc(sizeof(xmlSchematronValidCtxt));
1458 if (ret == NULL) {
1459 xmlSchematronVErrMemory(NULL, "allocating validation context",
1460 NULL);
1461 return (NULL);
1462 }
1463 memset(ret, 0, sizeof(xmlSchematronValidCtxt));
1464 ret->type = XML_STRON_CTXT_VALIDATOR;
1465 ret->schema = schema;
1466 ret->xctxt = xmlXPathNewContext(NULL);
1467 ret->flags = options;
1468 if (ret->xctxt == NULL) {
1469 xmlSchematronPErrMemory(NULL, "allocating schema parser XPath context",
1470 NULL);
1471 xmlSchematronFreeValidCtxt(ret);
1472 return (NULL);
1473 }
1474 for (i = 0;i < schema->nbNamespaces;i++) {
1475 if ((schema->namespaces[2 * i] == NULL) ||
1476 (schema->namespaces[2 * i + 1] == NULL))
1477 break;
1478 xmlXPathRegisterNs(ret->xctxt, schema->namespaces[2 * i + 1],
1479 schema->namespaces[2 * i]);
1480 }
1481 return (ret);
1482}
1483
1484/**
1485 * xmlSchematronFreeValidCtxt:
1486 * @ctxt: the schema validation context
1487 *
1488 * Free the resources associated to the schema validation context
1489 */
1490void
1491xmlSchematronFreeValidCtxt(xmlSchematronValidCtxtPtr ctxt)
1492{
1493 if (ctxt == NULL)
1494 return;
1495 if (ctxt->xctxt != NULL)
1496 xmlXPathFreeContext(ctxt->xctxt);
1497 if (ctxt->dict != NULL)
1498 xmlDictFree(ctxt->dict);
1499 xmlFree(ctxt);
1500}
1501
1502static xmlNodePtr
1503xmlSchematronNextNode(xmlNodePtr cur) {
1504 if (cur->children != NULL) {
1505 /*
1506 * Do not descend on entities declarations
1507 */
1508 if (cur->children->type != XML_ENTITY_DECL) {
1509 cur = cur->children;
1510 /*
1511 * Skip DTDs
1512 */
1513 if (cur->type != XML_DTD_NODE)
1514 return(cur);
1515 }
1516 }
1517
1518 while (cur->next != NULL) {
1519 cur = cur->next;
1520 if ((cur->type != XML_ENTITY_DECL) &&
1521 (cur->type != XML_DTD_NODE))
1522 return(cur);
1523 }
1524
1525 do {
1526 cur = cur->parent;
1527 if (cur == NULL) break;
1528 if (cur->type == XML_DOCUMENT_NODE) return(NULL);
1529 if (cur->next != NULL) {
1530 cur = cur->next;
1531 return(cur);
1532 }
1533 } while (cur != NULL);
1534 return(cur);
1535}
1536
1537/**
1538 * xmlSchematronRunTest:
1539 * @ctxt: the schema validation context
1540 * @test: the current test
1541 * @instance: the document instace tree
1542 * @cur: the current node in the instance
1543 *
1544 * Validate a rule against a tree instance at a given position
1545 *
1546 * Returns 1 in case of success, 0 if error and -1 in case of internal error
1547 */
1548static int
1549xmlSchematronRunTest(xmlSchematronValidCtxtPtr ctxt,
1550 xmlSchematronTestPtr test, xmlDocPtr instance, xmlNodePtr cur)
1551{
1552 xmlXPathObjectPtr ret;
1553 int failed;
1554
1555 failed = 0;
1556 ctxt->xctxt->doc = instance;
1557 ctxt->xctxt->node = cur;
1558 ret = xmlXPathCompiledEval(test->comp, ctxt->xctxt);
1559 if (ret == NULL) {
1560 failed = 1;
1561 } else {
1562 switch (ret->type) {
1563 case XPATH_XSLT_TREE:
1564 case XPATH_NODESET:
1565 if ((ret->nodesetval == NULL) ||
1566 (ret->nodesetval->nodeNr == 0))
1567 failed = 1;
1568 break;
1569 case XPATH_BOOLEAN:
1570 failed = !ret->boolval;
1571 break;
1572 case XPATH_NUMBER:
1573 if ((xmlXPathIsNaN(ret->floatval)) ||
1574 (ret->floatval == 0.0))
1575 failed = 1;
1576 break;
1577 case XPATH_STRING:
1578 if ((ret->stringval == NULL) ||
1579 (ret->stringval[0] == 0))
1580 failed = 1;
1581 break;
1582 case XPATH_UNDEFINED:
1583 case XPATH_POINT:
1584 case XPATH_RANGE:
1585 case XPATH_LOCATIONSET:
1586 case XPATH_USERS:
1587 failed = 1;
1588 break;
1589 }
1590 xmlXPathFreeObject(ret);
1591 }
1592 if ((failed) && (test->type == XML_SCHEMATRON_ASSERT))
1593 ctxt->nberrors++;
1594 else if ((!failed) && (test->type == XML_SCHEMATRON_REPORT))
1595 ctxt->nberrors++;
1596
1597 xmlSchematronReportSuccess(ctxt, test, cur, !failed);
1598
1599 return(!failed);
1600}
1601
1602/**
1603 * xmlSchematronValidateDoc:
1604 * @ctxt: the schema validation context
1605 * @instance: the document instace tree
1606 *
1607 * Validate a tree instance against the schematron
1608 *
1609 * Returns 0 in case of success, -1 in case of internal error
1610 * and an error count otherwise.
1611 */
1612int
1613xmlSchematronValidateDoc(xmlSchematronValidCtxtPtr ctxt, xmlDocPtr instance)
1614{
1615 xmlNodePtr cur, root;
1616 xmlSchematronPatternPtr pattern;
1617 xmlSchematronRulePtr rule;
1618 xmlSchematronTestPtr test;
1619
1620 if ((ctxt == NULL) || (ctxt->schema == NULL) ||
1621 (ctxt->schema->rules == NULL) || (instance == NULL))
1622 return(-1);
1623 ctxt->nberrors = 0;
1624 root = xmlDocGetRootElement(instance);
1625 if (root == NULL) {
1626 TODO
1627 ctxt->nberrors++;
1628 return(1);
1629 }
1630 if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) ||
1631 (ctxt->flags == 0)) {
1632 /*
1633 * we are just trying to assert the validity of the document,
1634 * speed primes over the output, run in a single pass
1635 */
1636 cur = root;
1637 while (cur != NULL) {
1638 rule = ctxt->schema->rules;
1639 while (rule != NULL) {
1640 if (xmlPatternMatch(rule->pattern, cur) == 1) {
1641 test = rule->tests;
1642 while (test != NULL) {
1643 xmlSchematronRunTest(ctxt, test, instance, cur);
1644 test = test->next;
1645 }
1646 }
1647 rule = rule->next;
1648 }
1649
1650 cur = xmlSchematronNextNode(cur);
1651 }
1652 } else {
1653 /*
1654 * Process all contexts one at a time
1655 */
1656 pattern = ctxt->schema->patterns;
1657
1658 while (pattern != NULL) {
1659 xmlSchematronReportPattern(ctxt, pattern);
1660
1661 /*
1662 * TODO convert the pattern rule to a direct XPath and
1663 * compute directly instead of using the pattern matching
1664 * over the full document...
1665 * Check the exact semantic
1666 */
1667 cur = root;
1668 while (cur != NULL) {
1669 rule = pattern->rules;
1670 while (rule != NULL) {
1671 if (xmlPatternMatch(rule->pattern, cur) == 1) {
1672 test = rule->tests;
1673 while (test != NULL) {
1674 xmlSchematronRunTest(ctxt, test, instance, cur);
1675 test = test->next;
1676 }
1677 }
1678 rule = rule->patnext;
1679 }
1680
1681 cur = xmlSchematronNextNode(cur);
1682 }
1683 pattern = pattern->next;
1684 }
1685 }
1686 return(ctxt->nberrors);
1687}
1688
1689#ifdef STANDALONE
1690int
1691main(void)
1692{
1693 int ret;
1694 xmlDocPtr instance;
1695 xmlSchematronParserCtxtPtr pctxt;
1696 xmlSchematronValidCtxtPtr vctxt;
1697 xmlSchematronPtr schema = NULL;
1698
1699 pctxt = xmlSchematronNewParserCtxt("tst.sct");
1700 if (pctxt == NULL) {
1701 fprintf(stderr, "failed to build schematron parser\n");
1702 } else {
1703 schema = xmlSchematronParse(pctxt);
1704 if (schema == NULL) {
1705 fprintf(stderr, "failed to compile schematron\n");
1706 }
1707 xmlSchematronFreeParserCtxt(pctxt);
1708 }
1709 instance = xmlReadFile("tst.sct", NULL,
1710 XML_PARSE_NOENT | XML_PARSE_NOCDATA);
1711 if (instance == NULL) {
1712 fprintf(stderr, "failed to parse instance\n");
1713 }
1714 if ((schema != NULL) && (instance != NULL)) {
1715 vctxt = xmlSchematronNewValidCtxt(schema);
1716 if (vctxt == NULL) {
1717 fprintf(stderr, "failed to build schematron validator\n");
1718 } else {
1719 ret = xmlSchematronValidateDoc(vctxt, instance);
1720 xmlSchematronFreeValidCtxt(vctxt);
1721 }
1722 }
1723 xmlSchematronFree(schema);
1724 xmlFreeDoc(instance);
1725
1726 xmlCleanupParser();
1727 xmlMemoryDump();
1728
1729 return (0);
1730}
1731#endif
1732#define bottom_schematron
1733#include "elfgcchack.h"
1734#endif /* LIBXML_SCHEMATRON_ENABLED */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette