Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/schematron.c

 /*
  * schematron.c : implementation of the Schematron schema validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <daniel@veillard.com>
  */
 
 /*
  * TODO:
@@ skipping 35 matching lines @@
 
 #define IS_SCHEMATRON(node, elem)                                       \
    ((node != NULL) && (node->type == XML_ELEMENT_NODE ) &&              \
     (node->ns != NULL) &&                                               \
     (xmlStrEqual(node->name, (const xmlChar *) elem)) &&                \
     ((xmlStrEqual(node->ns->href, xmlSchematronNs)) ||                  \
      (xmlStrEqual(node->ns->href, xmlOldSchematronNs))))
 
 #define NEXT_SCHEMATRON(node)                                           \
    while (node != NULL) {                                               \
-       if ((node->type == XML_ELEMENT_NODE ) && (node->ns != NULL) &&   \
+       if ((node->type == XML_ELEMENT_NODE ) && (node->ns != NULL) &&   \
            ((xmlStrEqual(node->ns->href, xmlSchematronNs)) ||           \
             (xmlStrEqual(node->ns->href, xmlOldSchematronNs))))         \
            break;                                                       \
        node = node->next;                                               \
    }
 
 /**
  * TODO:
  *
  * macro to flag unimplemented blocks
  */
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 typedef enum {
     XML_SCHEMATRON_ASSERT=1,
     XML_SCHEMATRON_REPORT=2
 } xmlSchematronTestType;
 
 /**
@@ skipping 79 matching lines @@
 
     xmlDictPtr dict;
     int nberrors;
     int err;
 
     xmlSchematronPtr schema;
     xmlXPathContextPtr xctxt;
 
     FILE *outputFile;           /* if using XML_SCHEMATRON_OUT_FILE */
     xmlBufferPtr outputBuffer;  /* if using XML_SCHEMATRON_OUT_BUFFER */
+#ifdef LIBXML_OUTPUT_ENABLED
     xmlOutputWriteCallback iowrite; /* if using XML_SCHEMATRON_OUT_IO */
     xmlOutputCloseCallback  ioclose;
+#endif
     void *ioctx;
 
     /* error reporting data */
     void *userData;                      /* user specific data block */
     xmlSchematronValidityErrorFunc error;/* the callback in case of errors */
     xmlSchematronValidityWarningFunc warning;/* callback in case of warning */
     xmlStructuredErrorFunc serror;       /* the structured function */
 };
 
 struct _xmlSchematronParserCtxt {
@@ skipping 53 matching lines @@
 }
 
 /**
  * xmlSchematronPErr:
  * @ctxt: the parsing context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
- * 
+ *
  * Handle a parser error
  */
 static void
 xmlSchematronPErr(xmlSchematronParserCtxtPtr ctxt, xmlNodePtr node, int error,
               const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     xmlGenericErrorFunc channel = NULL;
     xmlStructuredErrorFunc schannel = NULL;
     void *data = NULL;
 
@@ skipping 307 matching lines @@
 xmlSchematronFree(xmlSchematronPtr schema)
 {
     if (schema == NULL)
         return;
 
     if ((schema->doc != NULL) && (!(schema->preserve)))
         xmlFreeDoc(schema->doc);
 
     if (schema->namespaces != NULL)
         xmlFree((char **) schema->namespaces);
-    
+
     xmlSchematronFreeRules(schema->rules);
     xmlSchematronFreePatterns(schema->patterns);
     xmlDictFree(schema->dict);
     xmlFree(schema);
 }
 
 /**
  * xmlSchematronNewParserCtxt:
  * @URL:  the location of the schema
  *
@@ skipping 237 matching lines @@
             xmlRealloc((xmlChar **) ctxt->namespaces, ctxt->maxNamespaces * 4 *
                        sizeof(const xmlChar *));
         if (tmp == NULL) {
             xmlSchematronPErrMemory(NULL, "allocating parser namespaces",
                                     NULL);
             return;
         }
         ctxt->namespaces = tmp;
         ctxt->maxNamespaces *= 2;
     }
-    ctxt->namespaces[2 * ctxt->nbNamespaces] = 
+    ctxt->namespaces[2 * ctxt->nbNamespaces] =
         xmlDictLookup(ctxt->dict, ns, -1);
-    ctxt->namespaces[2 * ctxt->nbNamespaces + 1] = 
+    ctxt->namespaces[2 * ctxt->nbNamespaces + 1] =
         xmlDictLookup(ctxt->dict, prefix, -1);
     ctxt->nbNamespaces++;
     ctxt->namespaces[2 * ctxt->nbNamespaces] = NULL;
     ctxt->namespaces[2 * ctxt->nbNamespaces + 1] = NULL;
 
 }
 
 /**
  * xmlSchematronParseRule:
  * @ctxt:  a schema validation context
@@ skipping 439 matching lines @@
  * @ctxt:  the validation context
  * @test: the test node
  * @cur: the current node tested
  *
  * Build the string being reported to the user.
  *
  * Returns a report string or NULL in case of error. The string needs
  *         to be deallocated by teh caller
  */
 static xmlChar *
-xmlSchematronFormatReport(xmlSchematronValidCtxtPtr ctxt, 
+xmlSchematronFormatReport(xmlSchematronValidCtxtPtr ctxt,
                           xmlNodePtr test, xmlNodePtr cur) {
     xmlChar *ret = NULL;
     xmlNodePtr child, node;
 
     if ((test == NULL) || (cur == NULL))
         return(ret);
 
     child = test->children;
     while (child != NULL) {
         if ((child->type == XML_TEXT_NODE) ||
             (child->type == XML_CDATA_SECTION_NODE))
             ret = xmlStrcat(ret, child->content);
         else if (IS_SCHEMATRON(child, "name")) {
             xmlChar *path;
 
             path = xmlGetNoNsProp(child, BAD_CAST "path");
 
             node = cur;
             if (path != NULL) {
                 node = xmlSchematronGetNode(ctxt, cur, path);
                 if (node == NULL)
                     node = cur;
                 xmlFree(path);
             }
 
-            if ((node->ns == NULL) || (node->ns->prefix == NULL)) 
+            if ((node->ns == NULL) || (node->ns->prefix == NULL))
                 ret = xmlStrcat(ret, node->name);
             else {
                 ret = xmlStrcat(ret, node->ns->prefix);
                 ret = xmlStrcat(ret, BAD_CAST ":");
                 ret = xmlStrcat(ret, node->name);
             }
         } else {
             child = child->next;
             continue;
         }
@@ skipping 30 matching lines @@
  * xmlSchematronReportSuccess:
  * @ctxt:  the validation context
  * @test: the compiled test
  * @cur: the current node tested
  * @success: boolean value for the result
  *
  * called from the validation engine when an assert or report test have
  * been done.
  */
 static void
-xmlSchematronReportSuccess(xmlSchematronValidCtxtPtr ctxt, 
+xmlSchematronReportSuccess(xmlSchematronValidCtxtPtr ctxt,
                    xmlSchematronTestPtr test, xmlNodePtr cur, xmlSchematronPatternPtr pattern, int success) {
     if ((ctxt == NULL) || (cur == NULL) || (test == NULL))
         return;
     /* if quiet and not SVRL report only failures */
     if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) &&
         ((ctxt->flags & XML_SCHEMATRON_OUT_XML) == 0) &&
         (test->type == XML_SCHEMATRON_REPORT))
         return;
     if (ctxt->flags & XML_SCHEMATRON_OUT_XML) {
         TODO
@@ skipping 59 matching lines @@
 }
 
 /**
  * xmlSchematronReportPattern:
  * @ctxt:  the validation context
  * @pattern: the current pattern
  *
  * called from the validation engine when starting to check a pattern
  */
 static void
-xmlSchematronReportPattern(xmlSchematronValidCtxtPtr ctxt, 
+xmlSchematronReportPattern(xmlSchematronValidCtxtPtr ctxt,
                            xmlSchematronPatternPtr pattern) {
     if ((ctxt == NULL) || (pattern == NULL))
         return;
     if ((ctxt->flags & XML_SCHEMATRON_OUT_QUIET) || (ctxt->flags & XML_SCHEMATRON_OUT_ERROR)) /* Error gives pattern name as part of error */
         return;
     if (ctxt->flags & XML_SCHEMATRON_OUT_XML) {
         TODO
     } else {
         char msg[1000];
 
@@ skipping 106 matching lines @@
                 return(cur);
         }
     }
 
     while (cur->next != NULL) {
         cur = cur->next;
         if ((cur->type != XML_ENTITY_DECL) &&
             (cur->type != XML_DTD_NODE))
             return(cur);
     }
-    
+
     do {
         cur = cur->parent;
         if (cur == NULL) break;
         if (cur->type == XML_DOCUMENT_NODE) return(NULL);
         if (cur->next != NULL) {
             cur = cur->next;
             return(cur);
         }
     } while (cur != NULL);
     return(cur);
 }
 
 /**
  * xmlSchematronRunTest:
  * @ctxt:  the schema validation context
  * @test:  the current test
- * @instance:  the document instace tree 
+ * @instance:  the document instace tree
  * @cur:  the current node in the instance
  *
  * Validate a rule against a tree instance at a given position
  *
  * Returns 1 in case of success, 0 if error and -1 in case of internal error
  */
 static int
 xmlSchematronRunTest(xmlSchematronValidCtxtPtr ctxt,
      xmlSchematronTestPtr test, xmlDocPtr instance, xmlNodePtr cur, xmlSchematronPatternPtr pattern)
 {
@@ skipping 43 matching lines @@
         ctxt->nberrors++;
 
     xmlSchematronReportSuccess(ctxt, test, cur, pattern, !failed);
 
     return(!failed);
 }
 
 /**
  * xmlSchematronValidateDoc:
  * @ctxt:  the schema validation context
- * @instance:  the document instace tree 
+ * @instance:  the document instace tree
  *
  * Validate a tree instance against the schematron
  *
  * Returns 0 in case of success, -1 in case of internal error
  *         and an error count otherwise.
  */
 int
 xmlSchematronValidateDoc(xmlSchematronValidCtxtPtr ctxt, xmlDocPtr instance)
 {
     xmlNodePtr cur, root;
@@ skipping 23 matching lines @@
             while (rule != NULL) {
                 if (xmlPatternMatch(rule->pattern, cur) == 1) {
                     test = rule->tests;
                     while (test != NULL) {
                         xmlSchematronRunTest(ctxt, test, instance, cur, (xmlSchematronPatternPtr)rule->pattern);
                         test = test->next;
                     }
                 }
                 rule = rule->next;
             }
-            
+
             cur = xmlSchematronNextNode(cur);
         }
     } else {
         /*
          * Process all contexts one at a time
          */
         pattern = ctxt->schema->patterns;
-        
+
         while (pattern != NULL) {
             xmlSchematronReportPattern(ctxt, pattern);
 
             /*
              * TODO convert the pattern rule to a direct XPath and
              * compute directly instead of using the pattern matching
-             * over the full document... 
+             * over the full document...
              * Check the exact semantic
              */
             cur = root;
             while (cur != NULL) {
                 rule = pattern->rules;
                 while (rule != NULL) {
                     if (xmlPatternMatch(rule->pattern, cur) == 1) {
                         test = rule->tests;
                         while (test != NULL) {
                             xmlSchematronRunTest(ctxt, test, instance, cur, pattern);
                             test = test->next;
                         }
                     }
                     rule = rule->patnext;
                 }
-                
+
                 cur = xmlSchematronNextNode(cur);
             }
             pattern = pattern->next;
         }
     }
     return(ctxt->nberrors);
 }
 
 #ifdef STANDALONE
 int
@@ skipping 34 matching lines @@
 
     xmlCleanupParser();
     xmlMemoryDump();
 
     return (0);
 }
 #endif
 #define bottom_schematron
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMATRON_ENABLED */