VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.14/schematron.c@ 98101

Last change on this file since 98101 was 95312, checked in by vboxsync, 2 years ago

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