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 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  */
    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 #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 
    181 struct _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 informations
    224  *
    225  * Handle an out of memory condition
    226  */
    227 static void
    228 xmlSchematronPErrMemory(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  */
    248 static void LIBXML_ATTR_FORMAT(4,0)
    249 xmlSchematronPErr(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 informations
    272  *
    273  * Handle an out of memory condition
    274  */
    275 static void
    276 xmlSchematronVErrMemory(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  */
    306 static xmlSchematronTestPtr
    307 xmlSchematronAddTest(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  */
    361 static void
    362 xmlSchematronFreeTests(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  */
    390 static xmlSchematronRulePtr
    391 xmlSchematronAddRule(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  */
    453 static void
    454 xmlSchematronFreeRules(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  */
    483 static xmlSchematronPatternPtr
    484 xmlSchematronAddPattern(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  */
    518 static void
    519 xmlSchematronFreePatterns(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  */
    539 static xmlSchematronPtr
    540 xmlSchematronNewSchematron(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  */
    562 void
    563 xmlSchematronFree(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  */
    589 xmlSchematronParserCtxtPtr
    590 xmlSchematronNewParserCtxt(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  */
    631 xmlSchematronParserCtxtPtr
    632 xmlSchematronNewMemParserCtxt(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  */
    670 xmlSchematronParserCtxtPtr
    671 xmlSchematronNewDocParserCtxt(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  */
    708 void
    709 xmlSchematronFreeParserCtxt(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  */
    733 static void
    734 xmlSchematronPushInclude(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  */
    775 static xmlNodePtr
    776 xmlSchematronPopInclude(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  */
    803 static void
    804 xmlSchematronAddNamespace(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  */
    848 static void
    849 xmlSchematronParseRule(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  */
    958 static void
    959 xmlSchematronParsePattern(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  */
   1009 static xmlNodePtr
   1010 xmlSchematronLoadInclude(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 
   1052 done:
   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 Shema struture 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  */
   1076 xmlSchematronPtr
   1077 xmlSchematronParse(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 
   1219 exit:
   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 
   1242 static xmlNodePtr
   1243 xmlSchematronGetNode(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  */
   1273 static void
   1274 xmlSchematronReportOutput(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 teh caller
   1291  */
   1292 static xmlChar *
   1293 xmlSchematronFormatReport(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  */
   1369 static void
   1370 xmlSchematronReportSuccess(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  */
   1449 static void
   1450 xmlSchematronReportPattern(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  */
   1483 void
   1484 xmlSchematronSetValidStructuredErrors(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  */
   1504 xmlSchematronValidCtxtPtr
   1505 xmlSchematronNewValidCtxt(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  */
   1543 void
   1544 xmlSchematronFreeValidCtxt(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 
   1555 static xmlNodePtr
   1556 xmlSchematronNextNode(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 instace 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  */
   1601 static int
   1602 xmlSchematronRunTest(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 instace 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  */
   1665 int
   1666 xmlSchematronValidateDoc(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
   1743 int
   1744 main(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 */
   1788