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