Annotation of embedaddon/libxml2/schematron.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * schematron.c : implementation of the Schematron schema validity checking
                      3:  *
                      4:  * See Copyright for the status of this software.
                      5:  *
                      6:  * Daniel Veillard <daniel@veillard.com>
                      7:  */
                      8: 
                      9: /*
                     10:  * TODO:
                     11:  * + double check the semantic, especially
                     12:  *        - multiple rules applying in a single pattern/node
                     13:  *        - the semantic of libxml2 patterns vs. XSLT production referenced
                     14:  *          by the spec.
                     15:  * + export of results in SVRL
                     16:  * + full parsing and coverage of the spec, conformance of the input to the
                     17:  *   spec
                     18:  * + divergences between the draft and the ISO proposed standard :-(
                     19:  * + hook and test include
                     20:  * + try and compare with the XSLT version
                     21:  */
                     22: 
                     23: #define IN_LIBXML
                     24: #include "libxml.h"
                     25: 
                     26: #ifdef LIBXML_SCHEMATRON_ENABLED
                     27: 
                     28: #include <string.h>
                     29: #include <libxml/parser.h>
                     30: #include <libxml/tree.h>
                     31: #include <libxml/uri.h>
                     32: #include <libxml/xpath.h>
                     33: #include <libxml/xpathInternals.h>
                     34: #include <libxml/pattern.h>
                     35: #include <libxml/schematron.h>
                     36: 
                     37: #define SCHEMATRON_PARSE_OPTIONS XML_PARSE_NOENT
                     38: 
                     39: #define SCT_OLD_NS BAD_CAST "http://www.ascc.net/xml/schematron"
                     40: 
                     41: #define XML_SCHEMATRON_NS BAD_CAST "http://purl.oclc.org/dsdl/schematron"
                     42: 
                     43: 
                     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:                         "%s", 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 */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>