Update libxml to 2.7.7.

third_party/libxml/xmllint.c

 /*
  * xmllint.c : a small tester program for XML input.
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #include "libxml.h"
 
@@ skipping 90 matching lines @@
 #ifdef LIBXML_OUTPUT_ENABLED
 #include <libxml/xmlsave.h>
 #endif
 
 #ifndef XML_XML_DEFAULT_CATALOG
 #define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
 #endif
 
 typedef enum {
     XMLLINT_RETURN_OK = 0,      /* No error */
-    XMLLINT_ERR_UNCLASS,        /* Unclassified */
-    XMLLINT_ERR_DTD,            /* Error in DTD */
-    XMLLINT_ERR_VALID,          /* Validation error */
-    XMLLINT_ERR_RDFILE,         /* CtxtReadFile error */
-    XMLLINT_ERR_SCHEMACOMP,     /* Schema compilation */
-    XMLLINT_ERR_OUT,            /* Error writing output */
-    XMLLINT_ERR_SCHEMAPAT,      /* Error in schema pattern */
-    XMLLINT_ERR_RDREGIS,        /* Error in Reader registration */
-    XMLLINT_ERR_MEM             /* Out of memory error */
+    XMLLINT_ERR_UNCLASS = 1,    /* Unclassified */
+    XMLLINT_ERR_DTD = 2,        /* Error in DTD */
+    XMLLINT_ERR_VALID = 3,      /* Validation error */
+    XMLLINT_ERR_RDFILE = 4,     /* CtxtReadFile error */
+    XMLLINT_ERR_SCHEMACOMP = 5, /* Schema compilation */
+    XMLLINT_ERR_OUT = 6,        /* Error writing output */
+    XMLLINT_ERR_SCHEMAPAT = 7,  /* Error in schema pattern */
+    XMLLINT_ERR_RDREGIS = 8,    /* Error in Reader registration */
+    XMLLINT_ERR_MEM = 9,        /* Out of memory error */
+    XMLLINT_ERR_XPATH = 10      /* XPath evaluation error */
 } xmllintReturnCode;
 #ifdef LIBXML_DEBUG_ENABLED
 static int shell = 0;
 static int debugent = 0;
 #endif
 static int debug = 0;
 static int maxmem = 0;
 #ifdef LIBXML_TREE_ENABLED
 static int copy = 0;
 #endif /* LIBXML_TREE_ENABLED */
@@ skipping 47 matching lines @@
 static xmllintReturnCode progresult = XMLLINT_RETURN_OK;
 static int timing = 0;
 static int generate = 0;
 static int dropdtd = 0;
 #ifdef LIBXML_CATALOG_ENABLED
 static int catalogs = 0;
 static int nocatalogs = 0;
 #endif
 #ifdef LIBXML_C14N_ENABLED
 static int canonical = 0;
+static int canonical_11 = 0;
 static int exc_canonical = 0;
 #endif
 #ifdef LIBXML_READER_ENABLED
 static int stream = 0;
 static int walker = 0;
 #endif /* LIBXML_READER_ENABLED */
 static int chkregister = 0;
 static int nbregister = 0;
 #ifdef LIBXML_SAX1_ENABLED
 static int sax1 = 0;
 #endif /* LIBXML_SAX1_ENABLED */
 #ifdef LIBXML_PATTERN_ENABLED
 static const char *pattern = NULL;
 static xmlPatternPtr patternc = NULL;
 static xmlStreamCtxtPtr patstream = NULL;
 #endif
+#ifdef LIBXML_XPATH_ENABLED
+static const char *xpathquery = NULL;
+#endif
 static int options = XML_PARSE_COMPACT;
 static int sax = 0;
+static int oldxml10 = 0;
 
 /************************************************************************
  *                                                                      *
  *               Entity loading control and customization.              *
  *                                                                      *
  ************************************************************************/
 #define MAX_PATHS 64
 #ifdef _WIN32
 # define PATH_SEPARATOR ';'
 #else
@@ skipping 24 matching lines @@
             paths[nbpaths] = xmlStrndup(path, cur - path);
             if (paths[nbpaths] != NULL)
                 nbpaths++;
             path = cur;
         }
     }
 }
 
 static xmlExternalEntityLoader defaultEntityLoader = NULL;
 
-static xmlParserInputPtr 
+static xmlParserInputPtr
 xmllintExternalEntityLoader(const char *URL, const char *ID,
                              xmlParserCtxtPtr ctxt) {
     xmlParserInputPtr ret;
     warningSAXFunc warning = NULL;
     errorSAXFunc err = NULL;
 
     int i;
     const char *lastsegment = URL;
     const char *iter = URL;
 
@@ skipping 37 matching lines @@
         newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
         if (newURL != NULL) {
             ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
             if (ret != NULL) {
                 if (warning != NULL)
                     ctxt->sax->warning = warning;
                 if (err != NULL)
                     ctxt->sax->error = err;
                 if (load_trace) {
                     fprintf \
-                        (stderr,
-                         "Loaded URL=\"%s\" ID=\"%s\"\n",
+                        (stderr,
+                         "Loaded URL=\"%s\" ID=\"%s\"\n",
                          newURL,
-                         ID ? ID : "(null)");
+                         ID ? ID : "(null)");
                 }
                 xmlFree(newURL);
                 return(ret);
             }
             xmlFree(newURL);
         }
     }
     if (err != NULL)
         ctxt->sax->error = err;
     if (warning != NULL) {
         ctxt->sax->warning = warning;
         if (URL != NULL)
             warning(ctxt, "failed to load external entity \"%s\"\n", URL);
         else if (ID != NULL)
             warning(ctxt, "failed to load external entity \"%s\"\n", ID);
     }
     return(NULL);
 }
 /************************************************************************
- *                                                                      *
+ *                                                                      *
  * Memory allocation consumption debugging                              *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 
 static void
 OOM(void)
 {
     fprintf(stderr, "Ran out of memory needs > %d bytes\n", maxmem);
     progresult = XMLLINT_ERR_MEM;
 }
 
 static void
@@ skipping 40 matching lines @@
     if (ret != NULL) {
         if (xmlMemUsed() > maxmem) {
             OOM();
             xmlFree(ret);
             return (NULL);
         }
     }
     return (ret);
 }
 /************************************************************************
- *                                                                      *
+ *                                                                      *
  * Internal timing routines to remove the necessity to have             *
  * unix-specific function calls.                                        *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 
-#ifndef HAVE_GETTIMEOFDAY 
+#ifndef HAVE_GETTIMEOFDAY
 #ifdef HAVE_SYS_TIMEB_H
 #ifdef HAVE_SYS_TIME_H
 #ifdef HAVE_FTIME
 
 static int
 my_gettimeofday(struct timeval *tvp, void *tzp)
 {
         struct timeb timebuffer;
 
         ftime(&timebuffer);
@@ skipping 105 matching lines @@
     va_end(ap);
     fprintf(stderr, " was not timed\n", msec);
 #else
     /* We don't have gettimeofday, time or stdarg.h, what crazy world is
      * this ?!
      */
 #endif
 }
 #endif
 /************************************************************************
- *                                                                      *
- *                      HTML ouput                                      *
- *                                                                      *
+ *                                                                      *
+ *                      HTML ouput                                      *
+ *                                                                      *
  ************************************************************************/
 static char buffer[50000];
 
 static void
 xmlHTMLEncodeSend(void) {
     char *result;
 
     result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);
     if (result) {
         xmlGenericError(xmlGenericErrorContext, "%s", result);
         xmlFree(result);
     }
     buffer[0] = 0;
 }
 
 /**
  * xmlHTMLPrintFileInfo:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays the associated file and line informations for the current input
  */
 
 static void
 xmlHTMLPrintFileInfo(xmlParserInputPtr input) {
     int len;
     xmlGenericError(xmlGenericErrorContext, "<p>");
 
     len = strlen(buffer);
     if (input != NULL) {
         if (input->filename) {
             snprintf(&buffer[len], sizeof(buffer) - len, "%s:%d: ", input->filename,
                     input->line);
         } else {
             snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", input->line);
         }
     }
     xmlHTMLEncodeSend();
 }
 
 /**
  * xmlHTMLPrintFileContext:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays current context within the input content for error tracking
  */
 
 static void
 xmlHTMLPrintFileContext(xmlParserInputPtr input) {
     const xmlChar *cur, *base;
     int len;
     int n;
 
     if (input == NULL) return;
     xmlGenericError(xmlGenericErrorContext, "<pre>\n");
     cur = input->cur;
     base = input->base;
     while ((cur > base) && ((*cur == '\n') || (*cur == '\r'))) {
         cur--;
     }
     n = 0;
     while ((n++ < 80) && (cur > base) && (*cur != '\n') && (*cur != '\r'))
         cur--;
     if ((*cur == '\n') || (*cur == '\r')) cur++;
     base = cur;
     n = 0;
     while ((*cur != 0) && (*cur != '\n') && (*cur != '\r') && (n < 79)) {
         len = strlen(buffer);
-        snprintf(&buffer[len], sizeof(buffer) - len, "%c", 
+        snprintf(&buffer[len], sizeof(buffer) - len, "%c",
                     (unsigned char) *cur++);
         n++;
     }
     len = strlen(buffer);
     snprintf(&buffer[len], sizeof(buffer) - len, "\n");
     cur = input->cur;
     while ((*cur == '\n') || (*cur == '\r'))
         cur--;
     n = 0;
     while ((cur != base) && (n++ < 80)) {
         len = strlen(buffer);
         snprintf(&buffer[len], sizeof(buffer) - len, " ");
         base++;
     }
     len = strlen(buffer);
     snprintf(&buffer[len], sizeof(buffer) - len, "^\n");
     xmlHTMLEncodeSend();
     xmlGenericError(xmlGenericErrorContext, "</pre>");
 }
 
 /**
  * xmlHTMLError:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format an error messages, gives file, line, position and
  * extra parameters.
  */
 static void XMLCDECL
 xmlHTMLError(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input;
     va_list args;
     int len;
 
     buffer[0] = 0;
     input = ctxt->input;
     if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
         input = ctxt->inputTab[ctxt->inputNr - 2];
     }
-        
+
     xmlHTMLPrintFileInfo(input);
 
     xmlGenericError(xmlGenericErrorContext, "<b>error</b>: ");
     va_start(args, msg);
     len = strlen(buffer);
     vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
     va_end(args);
     xmlHTMLEncodeSend();
     xmlGenericError(xmlGenericErrorContext, "</p>\n");
 
     xmlHTMLPrintFileContext(input);
     xmlHTMLEncodeSend();
 }
 
 /**
  * xmlHTMLWarning:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format a warning messages, gives file, line, position and
  * extra parameters.
  */
 static void XMLCDECL
 xmlHTMLWarning(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input;
     va_list args;
     int len;
 
     buffer[0] = 0;
     input = ctxt->input;
     if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
         input = ctxt->inputTab[ctxt->inputNr - 2];
     }
-        
+
 
     xmlHTMLPrintFileInfo(input);
-        
+
     xmlGenericError(xmlGenericErrorContext, "<b>warning</b>: ");
     va_start(args, msg);
-    len = strlen(buffer);    
+    len = strlen(buffer);
     vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
     va_end(args);
     xmlHTMLEncodeSend();
     xmlGenericError(xmlGenericErrorContext, "</p>\n");
 
     xmlHTMLPrintFileContext(input);
     xmlHTMLEncodeSend();
 }
 
 /**
  * xmlHTMLValidityError:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format an validity error messages, gives file,
  * line, position and extra parameters.
  */
 static void XMLCDECL
 xmlHTMLValidityError(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input;
     va_list args;
     int len;
 
     buffer[0] = 0;
     input = ctxt->input;
     if ((input->filename == NULL) && (ctxt->inputNr > 1))
         input = ctxt->inputTab[ctxt->inputNr - 2];
-        
+
     xmlHTMLPrintFileInfo(input);
 
     xmlGenericError(xmlGenericErrorContext, "<b>validity error</b>: ");
     len = strlen(buffer);
     va_start(args, msg);
     vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
     va_end(args);
     xmlHTMLEncodeSend();
     xmlGenericError(xmlGenericErrorContext, "</p>\n");
 
     xmlHTMLPrintFileContext(input);
     xmlHTMLEncodeSend();
     progresult = XMLLINT_ERR_VALID;
 }
 
 /**
  * xmlHTMLValidityWarning:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format a validity warning messages, gives file, line,
  * position and extra parameters.
  */
 static void XMLCDECL
 xmlHTMLValidityWarning(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input;
     va_list args;
     int len;
 
     buffer[0] = 0;
     input = ctxt->input;
     if ((input->filename == NULL) && (ctxt->inputNr > 1))
         input = ctxt->inputTab[ctxt->inputNr - 2];
 
     xmlHTMLPrintFileInfo(input);
-        
+
     xmlGenericError(xmlGenericErrorContext, "<b>validity warning</b>: ");
     va_start(args, msg);
-    len = strlen(buffer); 
+    len = strlen(buffer);
     vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);
     va_end(args);
     xmlHTMLEncodeSend();
     xmlGenericError(xmlGenericErrorContext, "</p>\n");
 
     xmlHTMLPrintFileContext(input);
     xmlHTMLEncodeSend();
 }
 
 /************************************************************************
- *                                                                      *
- *                      Shell Interface                                 *
- *                                                                      *
+ *                                                                      *
+ *                      Shell Interface                                 *
+ *                                                                      *
  ************************************************************************/
 #ifdef LIBXML_DEBUG_ENABLED
 #ifdef LIBXML_XPATH_ENABLED
 /**
  * xmlShellReadline:
  * @prompt:  the prompt value
  *
  * Read a string
- * 
+ *
  * Returns a pointer to it or NULL on EOF the caller is expected to
  *     free the returned string.
  */
 static char *
 xmlShellReadline(char *prompt) {
 #ifdef HAVE_LIBREADLINE
     char *line_read;
 
     /* Get a line from the user. */
     line_read = readline (prompt);
@@ skipping 18 matching lines @@
     if (ret != NULL) {
         memcpy (ret, line_read, len + 1);
     }
     return(ret);
 #endif
 }
 #endif /* LIBXML_XPATH_ENABLED */
 #endif /* LIBXML_DEBUG_ENABLED */
 
 /************************************************************************
- *                                                                      *
- *                      I/O Interfaces                                  *
- *                                                                      *
+ *                                                                      *
+ *                      I/O Interfaces                                  *
+ *                                                                      *
  ************************************************************************/
 
 static int myRead(FILE *f, char * buf, int len) {
     return(fread(buf, 1, len, f));
 }
 static void myClose(FILE *f) {
   if (f != stdin) {
     fclose(f);
   }
 }
 
 /************************************************************************
  *                                                                      *
- *                      SAX based tests                                 *
+ *                      SAX based tests                                 *
  *                                                                      *
  ************************************************************************/
 
 /*
  * empty SAX block
  */
 static xmlSAXHandler emptySAXHandlerStruct = {
     NULL, /* internalSubset */
     NULL, /* isStandalone */
     NULL, /* hasInternalSubset */
@@ skipping 149 matching lines @@
  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  */
 static xmlParserInputPtr
 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
 {
     callbacks++;
     if (noout)
         return(NULL);
     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
 
-    
+
     fprintf(stdout, "SAX.resolveEntity(");
     if (publicId != NULL)
         fprintf(stdout, "%s", (char *)publicId);
     else
         fprintf(stdout, " ");
     if (systemId != NULL)
         fprintf(stdout, ", %s)\n", (char *)systemId);
     else
         fprintf(stdout, ", )\n");
     return(NULL);
@@ skipping 34 matching lines @@
     if (noout)
         return(NULL);
     fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
     return(NULL);
 }
 
 
 /**
  * entityDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the entity name 
- * @type:  the entity type 
+ * @name:  the entity name
+ * @type:  the entity type
  * @publicId: The public ID of the entity
  * @systemId: The system ID of the entity
  * @content: the entity value (without processing).
  *
  * An entity definition has been parsed
  */
 static void
 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
 {
 const xmlChar *nullstr = BAD_CAST "(null)";
     /* not all libraries handle printing null pointers nicely */
     if (publicId == NULL)
         publicId = nullstr;
     if (systemId == NULL)
         systemId = nullstr;
     if (content == NULL)
         content = (xmlChar *)nullstr;
     callbacks++;
     if (noout)
         return;
     fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
             name, type, publicId, systemId, content);
 }
 
 /**
  * attributeDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the attribute name 
- * @type:  the attribute type 
+ * @name:  the attribute name
+ * @type:  the attribute type
  *
  * An attribute definition has been parsed
  */
 static void
 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
                    const xmlChar * name, int type, int def,
                    const xmlChar * defaultValue, xmlEnumerationPtr tree)
 {
     callbacks++;
     if (noout)
         return;
     if (defaultValue == NULL)
         fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
                 elem, name, type, def);
     else
         fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
                 elem, name, type, def, defaultValue);
     xmlFreeEnumeration(tree);
 }
 
 /**
  * elementDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the element name 
- * @type:  the element type 
+ * @name:  the element name
+ * @type:  the element type
  * @content: the element value (without processing).
  *
  * An element definition has been parsed
  */
 static void
 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
             xmlElementContentPtr content ATTRIBUTE_UNUSED)
 {
     callbacks++;
     if (noout)
@@ skipping 165 matching lines @@
     out[i] = 0;
 
     fprintf(stdout, "SAX.characters(%s, %d)\n", out, len);
 }
 
 /**
  * referenceDebug:
  * @ctxt:  An XML parser context
  * @name:  The entity name
  *
- * called when an entity reference is detected. 
+ * called when an entity reference is detected.
  */
 static void
 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 {
     callbacks++;
     if (noout)
         return;
     fprintf(stdout, "SAX.reference(%s)\n", name);
 }
 
@@ skipping 215 matching lines @@
     fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
     if (prefix == NULL)
         fprintf(stdout, ", NULL");
     else
         fprintf(stdout, ", %s", (char *) prefix);
     if (URI == NULL)
         fprintf(stdout, ", NULL");
     else
         fprintf(stdout, ", '%s'", (char *) URI);
     fprintf(stdout, ", %d", nb_namespaces);
-    
+
     if (namespaces != NULL) {
         for (i = 0;i < nb_namespaces * 2;i++) {
             fprintf(stdout, ", xmlns");
             if (namespaces[i] != NULL)
                 fprintf(stdout, ":%s", namespaces[i]);
             i++;
             fprintf(stdout, "='%s'", namespaces[i]);
         }
     }
     fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
@@ skipping 142 matching lines @@
         }
         old_sax = ctxt->sax;
         ctxt->sax = handler;
         ctxt->userData = (void *) user_data;
         inputStream = xmlNewIOInputStream(ctxt, buf, XML_CHAR_ENCODING_NONE);
         if (inputStream == NULL) {
             xmlFreeParserInputBuffer(buf);
             goto error;
         }
         inputPush(ctxt, inputStream);
-        
+
         /* do the parsing */
         xmlParseDocument(ctxt);
 
         if (ctxt->myDoc != NULL) {
             fprintf(stderr, "SAX generated a doc !\n");
             xmlFreeDoc(ctxt->myDoc);
             ctxt->myDoc = NULL;
         }
     }
 
 error:
     if (ctxt != NULL) {
         ctxt->sax = old_sax;
         xmlFreeParserCtxt(ctxt);
     }
 }
 
 /************************************************************************
- *                                                                      *
- *                      Stream Test processing                          *
- *                                                                      *
+ *                                                                      *
+ *                      Stream Test processing                          *
+ *                                                                      *
  ************************************************************************/
 #ifdef LIBXML_READER_ENABLED
 static void processNode(xmlTextReaderPtr reader) {
     const xmlChar *name, *value;
     int type, empty;
 
     type = xmlTextReaderNodeType(reader);
     empty = xmlTextReaderIsEmptyElement(reader);
 
     if (debug) {
         name = xmlTextReaderConstName(reader);
         if (name == NULL)
             name = BAD_CAST "--";
 
         value = xmlTextReaderConstValue(reader);
 
-        
-        printf("%d %d %s %d %d", 
+
+        printf("%d %d %s %d %d",
                 xmlTextReaderDepth(reader),
                 type,
                 name,
                 empty,
                 xmlTextReaderHasValue(reader));
         if (value == NULL)
             printf("\n");
         else {
             printf(" %s\n", value);
         }
     }
 #ifdef LIBXML_PATTERN_ENABLED
     if (patternc) {
         xmlChar *path = NULL;
         int match = -1;
-        
+
         if (type == XML_READER_TYPE_ELEMENT) {
             /* do the check only on element start */
             match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader));
 
             if (match) {
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
                 path = xmlGetNodePath(xmlTextReaderCurrentNode(reader));
                 printf("Node %s matches pattern %s\n", path, pattern);
+#else
+                printf("Node %s matches pattern %s\n",
+                       xmlTextReaderConstName(reader), pattern);
+#endif
             }
         }
         if (patstream != NULL) {
             int ret;
 
             if (type == XML_READER_TYPE_ELEMENT) {
                 ret = xmlStreamPush(patstream,
                                     xmlTextReaderConstLocalName(reader),
                                     xmlTextReaderConstNamespaceUri(reader));
                 if (ret < 0) {
                     fprintf(stderr, "xmlStreamPush() failure\n");
                     xmlFreeStreamCtxt(patstream);
                     patstream = NULL;
                 } else if (ret != match) {
+#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
                     if (path == NULL) {
                         path = xmlGetNodePath(
                                        xmlTextReaderCurrentNode(reader));
                     }
+#endif
                     fprintf(stderr,
                             "xmlPatternMatch and xmlStreamPush disagree\n");
-                    fprintf(stderr,
-                            "  pattern %s node %s\n",
-                            pattern, path);
+                    if (path != NULL)
+                        fprintf(stderr, "  pattern %s node %s\n",
+                                pattern, path);
+                    else
+                        fprintf(stderr, "  pattern %s node %s\n",
+                            pattern, xmlTextReaderConstName(reader));
                 }
-                
 
-            } 
+            }
             if ((type == XML_READER_TYPE_END_ELEMENT) ||
                 ((type == XML_READER_TYPE_ELEMENT) && (empty))) {
                 ret = xmlStreamPop(patstream);
                 if (ret < 0) {
                     fprintf(stderr, "xmlStreamPop() failure\n");
                     xmlFreeStreamCtxt(patstream);
                     patstream = NULL;
                 }
             }
         }
         if (path != NULL)
             xmlFree(path);
     }
 #endif
 }
 
 static void streamFile(char *filename) {
     xmlTextReaderPtr reader;
     int ret;
 #ifdef HAVE_SYS_MMAN_H
     int fd = -1;
     struct stat info;
     const char *base = NULL;
     xmlParserInputBufferPtr input = NULL;
 
     if (memory) {
-        if (stat(filename, &info) < 0) 
+        if (stat(filename, &info) < 0)
             return;
         if ((fd = open(filename, O_RDONLY)) < 0)
             return;
         base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
         if (base == (void *) MAP_FAILED)
             return;
 
         reader = xmlReaderForMemory(base, info.st_size, filename,
                                     NULL, options);
     } else
@@ skipping 148 matching lines @@
     const xmlChar *namespaces[22];
     int i;
     xmlNsPtr ns;
 
     root = xmlDocGetRootElement(doc);
     for (ns = root->nsDef, i = 0;ns != NULL && i < 20;ns=ns->next) {
         namespaces[i++] = ns->href;
         namespaces[i++] = ns->prefix;
     }
     namespaces[i++] = NULL;
-    namespaces[i++] = NULL;
+    namespaces[i] = NULL;
 
     if (pattern != NULL) {
         patternc = xmlPatterncompile((const xmlChar *) pattern, doc->dict,
                                      0, &namespaces[0]);
         if (patternc == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                     "Pattern %s failed to compile\n", pattern);
             progresult = XMLLINT_ERR_SCHEMAPAT;
             pattern = NULL;
         }
@@ skipping 39 matching lines @@
     }
 #ifdef LIBXML_PATTERN_ENABLED
     if (patstream != NULL) {
         xmlFreeStreamCtxt(patstream);
         patstream = NULL;
     }
 #endif
 }
 #endif /* LIBXML_READER_ENABLED */
 
+#ifdef LIBXML_XPATH_ENABLED
 /************************************************************************
- *                                                                      *
- *                      Tree Test processing                            *
- *                                                                      *
+ *                                                                      *
+ *                      XPath Query                                     *
+ *                                                                      *
+ ************************************************************************/
+
+static void doXPathDump(xmlXPathObjectPtr cur) {
+    switch(cur->type) {
+        case XPATH_NODESET: {
+            int i;
+            xmlNodePtr node;
+#ifdef LIBXML_OUTPUT_ENABLED
+            xmlSaveCtxtPtr ctxt;
+
+            if (cur->nodesetval->nodeNr <= 0) {
+                fprintf(stderr, "XPath set is empty\n");
+                progresult = XMLLINT_ERR_XPATH;
+                break;
+            }
+            ctxt = xmlSaveToFd(1, NULL, 0);
+            if (ctxt == NULL) {
+                fprintf(stderr, "Out of memory for XPath\n");
+                progresult = XMLLINT_ERR_MEM;
+                return;
+            }
+            for (i = 0;i < cur->nodesetval->nodeNr;i++) {
+                node = cur->nodesetval->nodeTab[i];
+                xmlSaveTree(ctxt, node);
+            }
+            xmlSaveClose(ctxt);
+#else
+            printf("xpath returned %d nodes\n", cur->nodesetval->nodeNr);
+#endif
+            break;
+        }
+        case XPATH_BOOLEAN:
+            if (cur->boolval) printf("true");
+            else printf("false");
+            break;
+        case XPATH_NUMBER:
+            switch (xmlXPathIsInf(cur->floatval)) {
+            case 1:
+                printf("Infinity");
+                break;
+            case -1:
+                printf("-Infinity");
+                break;
+            default:
+                if (xmlXPathIsNaN(cur->floatval)) {
+                    printf("NaN");
+                } else {
+                    printf("%0g", cur->floatval);
+                }
+            }
+            break;
+        case XPATH_STRING:
+            printf("%s", (const char *) cur->stringval);
+            break;
+        case XPATH_UNDEFINED:
+            fprintf(stderr, "XPath Object is uninitialized\n");
+            progresult = XMLLINT_ERR_XPATH;
+            break;
+        default:
+            fprintf(stderr, "XPath object of unexpected type\n");
+            progresult = XMLLINT_ERR_XPATH;
+            break;
+    }
+}
+
+static void doXPathQuery(xmlDocPtr doc, const char *query) {
+    xmlXPathContextPtr ctxt;
+    xmlXPathObjectPtr res;
+
+    ctxt = xmlXPathNewContext(doc);
+    if (ctxt == NULL) {
+        fprintf(stderr, "Out of memory for XPath\n");
+        progresult = XMLLINT_ERR_MEM;
+        return;
+    }
+    ctxt->node = xmlDocGetRootElement(doc);
+    res = xmlXPathEval(BAD_CAST query, ctxt);
+    xmlXPathFreeContext(ctxt);
+
+    if (res == NULL) {
+        fprintf(stderr, "XPath evaluation failure\n");
+        progresult = XMLLINT_ERR_XPATH;
+        return;
+    }
+    doXPathDump(res);
+    xmlXPathFreeObject(res);
+}
+#endif /* LIBXML_XPATH_ENABLED */
+
+/************************************************************************
+ *                                                                      *
+ *                      Tree Test processing                            *
+ *                                                                      *
  ************************************************************************/
 static void parseAndPrintFile(char *filename, xmlParserCtxtPtr rectxt) {
     xmlDocPtr doc = NULL;
 #ifdef LIBXML_TREE_ENABLED
     xmlDocPtr tmp;
 #endif /* LIBXML_TREE_ENABLED */
 
     if ((timing) && (!repeat))
         startTimer();
-    
+
 
 #ifdef LIBXML_TREE_ENABLED
     if (filename == NULL) {
         if (generate) {
             xmlNodePtr n;
 
             doc = xmlNewDoc(BAD_CAST "1.0");
             n = xmlNewDocNode(doc, NULL, BAD_CAST "info", NULL);
             xmlNodeSetContent(n, BAD_CAST "abc");
             xmlDocSetRootElement(doc, n);
@@ skipping 30 matching lines @@
             }
             fclose(f);
         }
     }
 #endif /* LIBXML_PUSH_ENABLED */
 #ifdef HAVE_SYS_MMAN_H
     else if ((html) && (memory)) {
         int fd;
         struct stat info;
         const char *base;
-        if (stat(filename, &info) < 0) 
+        if (stat(filename, &info) < 0)
             return;
         if ((fd = open(filename, O_RDONLY)) < 0)
             return;
         base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
         if (base == (void *) MAP_FAILED)
             return;
 
         doc = htmlReadMemory((char *) base, info.st_size, filename,
                              NULL, options);
-            
+
         munmap((char *) base, info.st_size);
         close(fd);
     }
 #endif
     else if (html) {
         doc = htmlReadFile(filename, NULL, options);
     }
 #endif /* LIBXML_HTML_ENABLED */
     else {
 #ifdef LIBXML_PUSH_ENABLED
@@ skipping 30 matching lines @@
                     }
                     xmlParseChunk(ctxt, chars, 0, 1);
                     doc = ctxt->myDoc;
                     ret = ctxt->wellFormed;
                     xmlFreeParserCtxt(ctxt);
                     if (!ret) {
                         xmlFreeDoc(doc);
                         doc = NULL;
                     }
                 }
+                if (f != stdin)
+                    fclose(f);
             }
         } else
 #endif /* LIBXML_PUSH_ENABLED */
         if (testIO) {
             if ((filename[0] == '-') && (filename[1] == 0)) {
                 doc = xmlReadFd(0, NULL, NULL, options);
             } else {
                 FILE *f;
 
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
@@ skipping 14 matching lines @@
                 } else
                     doc = NULL;
             }
         } else if (htmlout) {
             xmlParserCtxtPtr ctxt;
 
             if (rectxt == NULL)
                 ctxt = xmlNewParserCtxt();
             else
                 ctxt = rectxt;
-            if (ctxt == NULL) {       
+            if (ctxt == NULL) {
                 doc = NULL;
             } else {
                 ctxt->sax->error = xmlHTMLError;
                 ctxt->sax->warning = xmlHTMLWarning;
                 ctxt->vctxt.error = xmlHTMLValidityError;
                 ctxt->vctxt.warning = xmlHTMLValidityWarning;
 
                 doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
 
                 if (rectxt == NULL)
                     xmlFreeParserCtxt(ctxt);
             }
 #ifdef HAVE_SYS_MMAN_H
         } else if (memory) {
             int fd;
             struct stat info;
             const char *base;
-            if (stat(filename, &info) < 0) 
+            if (stat(filename, &info) < 0)
                 return;
             if ((fd = open(filename, O_RDONLY)) < 0)
                 return;
             base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
             if (base == (void *) MAP_FAILED)
                 return;
 
             if (rectxt == NULL)
                 doc = xmlReadMemory((char *) base, info.st_size,
                                     filename, NULL, options);
             else
                 doc = xmlCtxtReadMemory(rectxt, (char *) base, info.st_size,
                                         filename, NULL, options);
-                
+
             munmap((char *) base, info.st_size);
             close(fd);
 #endif
 #ifdef LIBXML_VALID_ENABLED
         } else if (valid) {
             xmlParserCtxtPtr ctxt = NULL;
 
             if (rectxt == NULL)
                 ctxt = xmlNewParserCtxt();
             else
                 ctxt = rectxt;
-            if (ctxt == NULL) {       
+            if (ctxt == NULL) {
                 doc = NULL;
             } else {
                 doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
 
                 if (ctxt->valid == 0)
                     progresult = XMLLINT_ERR_RDFILE;
                 if (rectxt == NULL)
                     xmlFreeParserCtxt(ctxt);
             }
 #endif /* LIBXML_VALID_ENABLED */
@@ skipping 42 matching lines @@
             startTimer();
         }
         if (xmlXIncludeProcessFlags(doc, options) < 0)
             progresult = XMLLINT_ERR_UNCLASS;
         if ((timing) && (!repeat)) {
             endTimer("Xinclude processing");
         }
     }
 #endif
 
+#ifdef LIBXML_XPATH_ENABLED
+    if (xpathquery != NULL) {
+        doXPathQuery(doc, xpathquery);
+    }
+#endif
+
 #ifdef LIBXML_DEBUG_ENABLED
 #ifdef LIBXML_XPATH_ENABLED
     /*
      * shell interaction
      */
     if (shell) {
         xmlXPathOrderDocElems(doc);
         xmlShell(doc, filename, xmlShellReadline, stdout);
     }
 #endif
@@ skipping 38 matching lines @@
                 } else if (nb == 0) {
                     fprintf(stderr, "No element can be inserted under root\n");
                 } else {
                     fprintf(stderr, "%d element types can be inserted under root:\n",
                            nb);
                     for (i = 0;i < nb;i++) {
                          fprintf(stderr, "%s\n", (char *) list[i]);
                     }
                 }
             }
-        }    
+        }
     }else
 #endif /* LIBXML_VALID_ENABLED */
 #ifdef LIBXML_READER_ENABLED
     if (walker) {
         walkDoc(doc);
     }
 #endif /* LIBXML_READER_ENABLED */
 #ifdef LIBXML_OUTPUT_ENABLED
     if (noout == 0) {
         int ret;
@@ skipping 44 matching lines @@
                 if ((timing) && (!repeat)) {
                     endTimer("Saving");
                 }
             } else
 #endif
 #ifdef LIBXML_C14N_ENABLED
             if (canonical) {
                 xmlChar *result = NULL;
                 int size;
 
-                size = xmlC14NDocDumpMemory(doc, NULL, 0, NULL, 1, &result);
+                size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_0, NULL, 1, &result);
                 if (size >= 0) {
                     write(1, result, size);
                     xmlFree(result);
+                } else {
+                    fprintf(stderr, "Failed to canonicalize\n");
+                    progresult = XMLLINT_ERR_OUT;
+                }
+            } else if (canonical) {
+                xmlChar *result = NULL;
+                int size;
+
+                size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_1, NULL, 1, &result);
+                if (size >= 0) {
+                    write(1, result, size);
+                    xmlFree(result);
                 } else {
                     fprintf(stderr, "Failed to canonicalize\n");
                     progresult = XMLLINT_ERR_OUT;
                 }
             } else
             if (exc_canonical) {
                 xmlChar *result = NULL;
                 int size;
 
-                size = xmlC14NDocDumpMemory(doc, NULL, 1, NULL, 1, &result);
+                size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_EXCLUSIVE_1_0, NULL, 1, &result);
                 if (size >= 0) {
                     write(1, result, size);
                     xmlFree(result);
                 } else {
                     fprintf(stderr, "Failed to canonicalize\n");
                     progresult = XMLLINT_ERR_OUT;
                 }
             } else
 #endif
 #ifdef HAVE_SYS_MMAN_H
             if (memory) {
                 xmlChar *result;
                 int len;
 
                 if (encoding != NULL) {
                     if ( format ) {
                         xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
-                    } else { 
+                    } else {
                         xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
                     }
                 } else {
                     if (format)
                         xmlDocDumpFormatMemory(doc, &result, &len, 1);
                     else
                         xmlDocDumpMemory(doc, &result, &len);
                 }
                 if (result == NULL) {
                     fprintf(stderr, "Failed to save\n");
@@ skipping 47 matching lines @@
                         progresult = XMLLINT_ERR_OUT;
                     }
                 }
             } else {
                 xmlSaveCtxtPtr ctxt;
                 int saveOpts = 0;
 
                 if (format)
                     saveOpts |= XML_SAVE_FORMAT;
 
+#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
+                if (xmlout)
+                    saveOpts |= XML_SAVE_AS_XML;
+#endif
+
                 if (output == NULL)
                     ctxt = xmlSaveToFd(1, encoding, saveOpts);
                 else
                     ctxt = xmlSaveToFilename(output, encoding, saveOpts);
 
                 if (ctxt != NULL) {
                     if (xmlSaveDoc(ctxt, doc) < 0) {
                         fprintf(stderr, "failed save to %s\n",
                                 output ? output : "-");
                         progresult = XMLLINT_ERR_OUT;
@@ skipping 32 matching lines @@
     /*
      * A posteriori validation test
      */
     if ((dtdvalid != NULL) || (dtdvalidfpi != NULL)) {
         xmlDtdPtr dtd;
 
         if ((timing) && (!repeat)) {
             startTimer();
         }
         if (dtdvalid != NULL)
-            dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid); 
+            dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid);
         else
-            dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL); 
+            dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL);
         if ((timing) && (!repeat)) {
             endTimer("Parsing DTD");
         }
         if (dtd == NULL) {
             if (dtdvalid != NULL)
                 xmlGenericError(xmlGenericErrorContext,
                         "Could not parse DTD %s\n", dtdvalid);
             else
                 xmlGenericError(xmlGenericErrorContext,
                         "Could not parse DTD %s\n", dtdvalidfpi);
@@ skipping 150 matching lines @@
             progresult = XMLLINT_ERR_VALID;
         }
         xmlSchemaFreeValidCtxt(ctxt);
         if ((timing) && (!repeat)) {
             endTimer("Validating");
         }
     }
 #endif
 
 #ifdef LIBXML_DEBUG_ENABLED
+#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
     if ((debugent) && (!html))
         xmlDebugDumpEntities(stderr, doc);
 #endif
+#endif
 
     /*
      * free it.
      */
     if ((timing) && (!repeat)) {
         startTimer();
     }
     xmlFreeDoc(doc);
     if ((timing) && (!repeat)) {
         endTimer("Freeing");
     }
 }
 
 /************************************************************************
- *                                                                      *
- *                      Usage and Main                                  *
- *                                                                      *
+ *                                                                      *
+ *                      Usage and Main                                  *
+ *                                                                      *
  ************************************************************************/
 
 static void showVersion(const char *name) {
     fprintf(stderr, "%s: using libxml version %s\n", name, xmlParserVersion);
     fprintf(stderr, "   compiled with: ");
     if (xmlHasFeature(XML_WITH_THREAD)) fprintf(stderr, "Threads ");
     if (xmlHasFeature(XML_WITH_TREE)) fprintf(stderr, "Tree ");
     if (xmlHasFeature(XML_WITH_OUTPUT)) fprintf(stderr, "Output ");
     if (xmlHasFeature(XML_WITH_PUSH)) fprintf(stderr, "Push ");
     if (xmlHasFeature(XML_WITH_READER)) fprintf(stderr, "Reader ");
     if (xmlHasFeature(XML_WITH_PATTERN)) fprintf(stderr, "Patterns ");
     if (xmlHasFeature(XML_WITH_WRITER)) fprintf(stderr, "Writer ");
     if (xmlHasFeature(XML_WITH_SAX1)) fprintf(stderr, "SAXv1 ");
-    if (xmlHasFeature(XML_WITH_FTP)) fprintf(stderr, "FTP "); 
-    if (xmlHasFeature(XML_WITH_HTTP)) fprintf(stderr, "HTTP "); 
+    if (xmlHasFeature(XML_WITH_FTP)) fprintf(stderr, "FTP ");
+    if (xmlHasFeature(XML_WITH_HTTP)) fprintf(stderr, "HTTP ");
     if (xmlHasFeature(XML_WITH_VALID)) fprintf(stderr, "DTDValid ");
-    if (xmlHasFeature(XML_WITH_HTML)) fprintf(stderr, "HTML "); 
-    if (xmlHasFeature(XML_WITH_LEGACY)) fprintf(stderr, "Legacy "); 
-    if (xmlHasFeature(XML_WITH_C14N)) fprintf(stderr, "C14N "); 
-    if (xmlHasFeature(XML_WITH_CATALOG)) fprintf(stderr, "Catalog "); 
-    if (xmlHasFeature(XML_WITH_XPATH)) fprintf(stderr, "XPath "); 
-    if (xmlHasFeature(XML_WITH_XPTR)) fprintf(stderr, "XPointer "); 
-    if (xmlHasFeature(XML_WITH_XINCLUDE)) fprintf(stderr, "XInclude "); 
-    if (xmlHasFeature(XML_WITH_ICONV)) fprintf(stderr, "Iconv "); 
-    if (xmlHasFeature(XML_WITH_ISO8859X)) fprintf(stderr, "ISO8859X "); 
-    if (xmlHasFeature(XML_WITH_UNICODE)) fprintf(stderr, "Unicode "); 
-    if (xmlHasFeature(XML_WITH_REGEXP)) fprintf(stderr, "Regexps "); 
-    if (xmlHasFeature(XML_WITH_AUTOMATA)) fprintf(stderr, "Automata "); 
-    if (xmlHasFeature(XML_WITH_EXPR)) fprintf(stderr, "Expr "); 
-    if (xmlHasFeature(XML_WITH_SCHEMAS)) fprintf(stderr, "Schemas "); 
-    if (xmlHasFeature(XML_WITH_SCHEMATRON)) fprintf(stderr, "Schematron "); 
-    if (xmlHasFeature(XML_WITH_MODULES)) fprintf(stderr, "Modules "); 
-    if (xmlHasFeature(XML_WITH_DEBUG)) fprintf(stderr, "Debug "); 
-    if (xmlHasFeature(XML_WITH_DEBUG_MEM)) fprintf(stderr, "MemDebug "); 
-    if (xmlHasFeature(XML_WITH_DEBUG_RUN)) fprintf(stderr, "RunDebug "); 
+    if (xmlHasFeature(XML_WITH_HTML)) fprintf(stderr, "HTML ");
+    if (xmlHasFeature(XML_WITH_LEGACY)) fprintf(stderr, "Legacy ");
+    if (xmlHasFeature(XML_WITH_C14N)) fprintf(stderr, "C14N ");
+    if (xmlHasFeature(XML_WITH_CATALOG)) fprintf(stderr, "Catalog ");
+    if (xmlHasFeature(XML_WITH_XPATH)) fprintf(stderr, "XPath ");
+    if (xmlHasFeature(XML_WITH_XPTR)) fprintf(stderr, "XPointer ");
+    if (xmlHasFeature(XML_WITH_XINCLUDE)) fprintf(stderr, "XInclude ");
+    if (xmlHasFeature(XML_WITH_ICONV)) fprintf(stderr, "Iconv ");
+    if (xmlHasFeature(XML_WITH_ISO8859X)) fprintf(stderr, "ISO8859X ");
+    if (xmlHasFeature(XML_WITH_UNICODE)) fprintf(stderr, "Unicode ");
+    if (xmlHasFeature(XML_WITH_REGEXP)) fprintf(stderr, "Regexps ");
+    if (xmlHasFeature(XML_WITH_AUTOMATA)) fprintf(stderr, "Automata ");
+    if (xmlHasFeature(XML_WITH_EXPR)) fprintf(stderr, "Expr ");
+    if (xmlHasFeature(XML_WITH_SCHEMAS)) fprintf(stderr, "Schemas ");
+    if (xmlHasFeature(XML_WITH_SCHEMATRON)) fprintf(stderr, "Schematron ");
+    if (xmlHasFeature(XML_WITH_MODULES)) fprintf(stderr, "Modules ");
+    if (xmlHasFeature(XML_WITH_DEBUG)) fprintf(stderr, "Debug ");
+    if (xmlHasFeature(XML_WITH_DEBUG_MEM)) fprintf(stderr, "MemDebug ");
+    if (xmlHasFeature(XML_WITH_DEBUG_RUN)) fprintf(stderr, "RunDebug ");
     if (xmlHasFeature(XML_WITH_ZLIB)) fprintf(stderr, "Zlib ");
     fprintf(stderr, "\n");
 }
 
 static void usage(const char *name) {
     printf("Usage : %s [options] XMLfiles ...\n", name);
 #ifdef LIBXML_OUTPUT_ENABLED
     printf("\tParse the XML files and output the result of the parsing\n");
 #else
     printf("\tParse the XML files\n");
 #endif /* LIBXML_OUTPUT_ENABLED */
     printf("\t--version : display the version of the XML library used\n");
 #ifdef LIBXML_DEBUG_ENABLED
     printf("\t--debug : dump a debug tree of the in-memory document\n");
     printf("\t--shell : run a navigating shell\n");
     printf("\t--debugent : debug the entities defined in the document\n");
 #else
 #ifdef LIBXML_READER_ENABLED
     printf("\t--debug : dump the nodes content when using --stream\n");
 #endif /* LIBXML_READER_ENABLED */
 #endif
 #ifdef LIBXML_TREE_ENABLED
     printf("\t--copy : used to test the internal copy implementation\n");
 #endif /* LIBXML_TREE_ENABLED */
     printf("\t--recover : output what was parsable on broken XML documents\n");
+    printf("\t--huge : remove any internal arbitrary parser limits\n");
     printf("\t--noent : substitute entity references by their value\n");
     printf("\t--noout : don't output the result tree\n");
     printf("\t--path 'paths': provide a set of paths for resources\n");
     printf("\t--load-trace : print trace of all external entites loaded\n");
     printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
     printf("\t--nocompact : do not generate compact text nodes\n");
     printf("\t--htmlout : output results as HTML\n");
     printf("\t--nowrap : do not put HTML doc wrapper\n");
 #ifdef LIBXML_VALID_ENABLED
     printf("\t--valid : validate the document in addition to std well-formed check\n");
@@ skipping 22 matching lines @@
 #endif
     printf("\t--maxmem nbbytes : limits memory allocation to nbbytes bytes\n");
     printf("\t--nowarning : do not emit warnings from parser/validator\n");
     printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
     printf("\t--nocdata : replace cdata section with text nodes\n");
 #ifdef LIBXML_OUTPUT_ENABLED
     printf("\t--format : reformat/reindent the input\n");
     printf("\t--encode encoding : output in the given encoding\n");
     printf("\t--dropdtd : remove the DOCTYPE of the input docs\n");
 #endif /* LIBXML_OUTPUT_ENABLED */
-    printf("\t--c14n : save in W3C canonical format (with comments)\n");
+    printf("\t--c14n : save in W3C canonical format v1.0 (with comments)\n");
+    printf("\t--c14n11 : save in W3C canonical format v1.1 (with comments)\n");
     printf("\t--exc-c14n : save in W3C exclusive canonical format (with comments)\n");
 #ifdef LIBXML_C14N_ENABLED
 #endif /* LIBXML_C14N_ENABLED */
     printf("\t--nsclean : remove redundant namespace declarations\n");
     printf("\t--testIO : test user I/O support\n");
 #ifdef LIBXML_CATALOG_ENABLED
     printf("\t--catalogs : use SGML catalogs from $SGML_CATALOG_FILES\n");
     printf("\t             otherwise XML Catalogs starting from \n");
     printf("\t         %s are activated by default\n", XML_XML_DEFAULT_CATALOG);
     printf("\t--nocatalogs: deactivate all catalogs\n");
 #endif
     printf("\t--auto : generate a small doc on the fly\n");
 #ifdef LIBXML_XINCLUDE_ENABLED
     printf("\t--xinclude : do XInclude processing\n");
     printf("\t--noxincludenode : same but do not generate XInclude nodes\n");
+    printf("\t--nofixup-base-uris : do not fixup xml:base uris\n");
 #endif
     printf("\t--loaddtd : fetch external DTD\n");
     printf("\t--dtdattr : loaddtd + populate the tree with inherited attributes \n");
 #ifdef LIBXML_READER_ENABLED
     printf("\t--stream : use the streaming interface to process very large files\n");
     printf("\t--walker : create a reader and walk though the resulting doc\n");
 #endif /* LIBXML_READER_ENABLED */
 #ifdef LIBXML_PATTERN_ENABLED
     printf("\t--pattern pattern_value : test the pattern support\n");
 #endif
     printf("\t--chkregister : verify the node registration code\n");
 #ifdef LIBXML_SCHEMAS_ENABLED
     printf("\t--relaxng schema : do RelaxNG validation against the schema\n");
     printf("\t--schema schema : do validation against the WXS schema\n");
 #endif
 #ifdef LIBXML_SCHEMATRON_ENABLED
     printf("\t--schematron schema : do validation against a schematron\n");
 #endif
 #ifdef LIBXML_SAX1_ENABLED
     printf("\t--sax1: use the old SAX1 interfaces for processing\n");
 #endif
     printf("\t--sax: do not build a tree but work just at the SAX level\n");
+    printf("\t--oldxml10: use XML-1.0 parsing rules before the 5th edition\n");
+#ifdef LIBXML_XPATH_ENABLED
+    printf("\t--xpath expr: evaluate the XPath expression, inply --noout\n");
+#endif
 
     printf("\nLibxml project home page: http://xmlsoft.org/\n");
     printf("To report bugs or get some help check: http://xmlsoft.org/bugs.html\n");
 }
 
 static void registerNode(xmlNodePtr node)
 {
     node->_private = malloc(sizeof(long));
     *(long*)node->_private = (long) 0x81726354;
     nbregister++;
 }
 
 static void deregisterNode(xmlNodePtr node)
 {
     assert(node->_private != NULL);
     assert(*(long*)node->_private == (long) 0x81726354);
     free(node->_private);
     nbregister--;
 }
 
 int
 main(int argc, char **argv) {
     int i, acount;
     int files = 0;
     int version = 0;
     const char* indent;
-    
+
     if (argc <= 1) {
         usage(argv[0]);
         return(1);
     }
     LIBXML_TEST_VERSION
     for (i = 1; i < argc ; i++) {
         if (!strcmp(argv[i], "-"))
             break;
 
         if (argv[i][0] != '-')
             continue;
         if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
             debug++;
         else
 #ifdef LIBXML_DEBUG_ENABLED
         if ((!strcmp(argv[i], "-shell")) ||
                  (!strcmp(argv[i], "--shell"))) {
             shell++;
             noout = 1;
-        } else 
+        } else
 #endif
 #ifdef LIBXML_TREE_ENABLED
         if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
             copy++;
         else
 #endif /* LIBXML_TREE_ENABLED */
         if ((!strcmp(argv[i], "-recover")) ||
                  (!strcmp(argv[i], "--recover"))) {
             recovery++;
             options |= XML_PARSE_RECOVER;
+        } else if ((!strcmp(argv[i], "-huge")) ||
+                 (!strcmp(argv[i], "--huge"))) {
+            options |= XML_PARSE_HUGE;
         } else if ((!strcmp(argv[i], "-noent")) ||
                  (!strcmp(argv[i], "--noent"))) {
             noent++;
             options |= XML_PARSE_NOENT;
         } else if ((!strcmp(argv[i], "-nsclean")) ||
                  (!strcmp(argv[i], "--nsclean"))) {
             options |= XML_PARSE_NSCLEAN;
         } else if ((!strcmp(argv[i], "-nocdata")) ||
                  (!strcmp(argv[i], "--nocdata"))) {
             options |= XML_PARSE_NOCDATA;
@@ skipping 102 matching lines @@
                  (!strcmp(argv[i], "--xinclude"))) {
             xinclude++;
             options |= XML_PARSE_XINCLUDE;
         }
         else if ((!strcmp(argv[i], "-noxincludenode")) ||
                  (!strcmp(argv[i], "--noxincludenode"))) {
             xinclude++;
             options |= XML_PARSE_XINCLUDE;
             options |= XML_PARSE_NOXINCNODE;
         }
+        else if ((!strcmp(argv[i], "-nofixup-base-uris")) ||
+                 (!strcmp(argv[i], "--nofixup-base-uris"))) {
+            xinclude++;
+            options |= XML_PARSE_XINCLUDE;
+            options |= XML_PARSE_NOBASEFIX;
+        }
 #endif
 #ifdef LIBXML_OUTPUT_ENABLED
 #ifdef HAVE_ZLIB_H
         else if ((!strcmp(argv[i], "-compress")) ||
                  (!strcmp(argv[i], "--compress"))) {
             compress++;
             xmlSetCompressMode(9);
         }
 #endif
 #endif /* LIBXML_OUTPUT_ENABLED */
         else if ((!strcmp(argv[i], "-nowarning")) ||
                  (!strcmp(argv[i], "--nowarning"))) {
             xmlGetWarningsDefaultValue = 0;
             xmlPedanticParserDefault(0);
             options |= XML_PARSE_NOWARNING;
         }
         else if ((!strcmp(argv[i], "-pedantic")) ||
                  (!strcmp(argv[i], "--pedantic"))) {
             xmlGetWarningsDefaultValue = 1;
             xmlPedanticParserDefault(1);
             options |= XML_PARSE_PEDANTIC;
         }
 #ifdef LIBXML_DEBUG_ENABLED
         else if ((!strcmp(argv[i], "-debugent")) ||
                  (!strcmp(argv[i], "--debugent"))) {
             debugent++;
             xmlParserDebugEntities = 1;
-        } 
+        }
 #endif
 #ifdef LIBXML_C14N_ENABLED
         else if ((!strcmp(argv[i], "-c14n")) ||
                  (!strcmp(argv[i], "--c14n"))) {
             canonical++;
             options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
-        } 
+        }
+        else if ((!strcmp(argv[i], "-c14n11")) ||
+                 (!strcmp(argv[i], "--c14n11"))) {
+            canonical_11++;
+            options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
+        }
         else if ((!strcmp(argv[i], "-exc-c14n")) ||
                  (!strcmp(argv[i], "--exc-c14n"))) {
             exc_canonical++;
             options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
-        } 
+        }
 #endif
 #ifdef LIBXML_CATALOG_ENABLED
         else if ((!strcmp(argv[i], "-catalogs")) ||
                  (!strcmp(argv[i], "--catalogs"))) {
             catalogs++;
         } else if ((!strcmp(argv[i], "-nocatalogs")) ||
                  (!strcmp(argv[i], "--nocatalogs"))) {
             nocatalogs++;
-        } 
+        }
 #endif
         else if ((!strcmp(argv[i], "-encode")) ||
                  (!strcmp(argv[i], "--encode"))) {
             i++;
             encoding = argv[i];
             /*
              * OK it's for testing purposes
              */
             xmlAddEncodingAlias("UTF-8", "DVEnc");
         }
@@ skipping 27 matching lines @@
         }
         else if ((!strcmp(argv[i], "-walker")) ||
                  (!strcmp(argv[i], "--walker"))) {
              walker++;
              noout++;
         }
 #endif /* LIBXML_READER_ENABLED */
 #ifdef LIBXML_SAX1_ENABLED
         else if ((!strcmp(argv[i], "-sax1")) ||
                  (!strcmp(argv[i], "--sax1"))) {
-             sax1++;
+            sax1++;
+            options |= XML_PARSE_SAX1;
         }
 #endif /* LIBXML_SAX1_ENABLED */
         else if ((!strcmp(argv[i], "-sax")) ||
                  (!strcmp(argv[i], "--sax"))) {
-             sax++;
+            sax++;
         }
         else if ((!strcmp(argv[i], "-chkregister")) ||
                  (!strcmp(argv[i], "--chkregister"))) {
-             chkregister++;
+            chkregister++;
 #ifdef LIBXML_SCHEMAS_ENABLED
         } else if ((!strcmp(argv[i], "-relaxng")) ||
                  (!strcmp(argv[i], "--relaxng"))) {
             i++;
             relaxng = argv[i];
             noent++;
             options |= XML_PARSE_NOENT;
         } else if ((!strcmp(argv[i], "-schema")) ||
                  (!strcmp(argv[i], "--schema"))) {
             i++;
@@ skipping 20 matching lines @@
         } else if ((!strcmp(argv[i], "-path")) ||
                    (!strcmp(argv[i], "--path"))) {
             i++;
             parsePath(BAD_CAST argv[i]);
 #ifdef LIBXML_PATTERN_ENABLED
         } else if ((!strcmp(argv[i], "-pattern")) ||
                    (!strcmp(argv[i], "--pattern"))) {
             i++;
             pattern = argv[i];
 #endif
+#ifdef LIBXML_XPATH_ENABLED
+        } else if ((!strcmp(argv[i], "-xpath")) ||
+                   (!strcmp(argv[i], "--xpath"))) {
+            i++;
+            noout++;
+            xpathquery = argv[i];
+#endif
+        } else if ((!strcmp(argv[i], "-oldxml10")) ||
+                   (!strcmp(argv[i], "--oldxml10"))) {
+            oldxml10++;
+            options |= XML_PARSE_OLD10;
         } else {
             fprintf(stderr, "Unknown option %s\n", argv[i]);
             usage(argv[0]);
             return(1);
         }
     }
 
 #ifdef LIBXML_CATALOG_ENABLED
     if (nocatalogs == 0) {
         if (catalogs) {
@@ skipping 13 matching lines @@
     if (sax1)
         xmlSAXDefaultVersion(1);
     else
         xmlSAXDefaultVersion(2);
 #endif /* LIBXML_SAX1_ENABLED */
 
     if (chkregister) {
         xmlRegisterNodeDefault(registerNode);
         xmlDeregisterNodeDefault(deregisterNode);
     }
-    
+
     indent = getenv("XMLLINT_INDENT");
     if(indent != NULL) {
         xmlTreeIndentString = indent;
     }
-    
+
 
     defaultEntityLoader = xmlGetExternalEntityLoader();
     xmlSetExternalEntityLoader(xmllintExternalEntityLoader);
 
     xmlLineNumbersDefault(1);
     if (loaddtd != 0)
         xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
     if (dtdattrs)
         xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
     if (noent != 0) xmlSubstituteEntitiesDefault(1);
 #ifdef LIBXML_VALID_ENABLED
     if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
 #endif /* LIBXML_VALID_ENABLED */
     if ((htmlout) && (!nowrap)) {
         xmlGenericError(xmlGenericErrorContext,
          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
         xmlGenericError(xmlGenericErrorContext,
                 "\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
         xmlGenericError(xmlGenericErrorContext,
          "<html><head><title>%s output</title></head>\n",
                 argv[0]);
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
          "<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
                 argv[0]);
     }
 
 #ifdef LIBXML_SCHEMATRON_ENABLED
     if ((schematron != NULL) && (sax == 0)
 #ifdef LIBXML_READER_ENABLED
         && (stream == 0)
 #endif /* LIBXML_READER_ENABLED */
         ) {
         xmlSchematronParserCtxtPtr ctxt;
 
         /* forces loading the DTDs */
-        xmlLoadExtDtdDefaultValue |= 1; 
+        xmlLoadExtDtdDefaultValue |= 1;
         options |= XML_PARSE_DTDLOAD;
         if (timing) {
             startTimer();
         }
         ctxt = xmlSchematronNewParserCtxt(schematron);
 #if 0
         xmlSchematronSetParserErrors(ctxt,
                 (xmlSchematronValidityErrorFunc) fprintf,
                 (xmlSchematronValidityWarningFunc) fprintf,
                 stderr);
@@ skipping 13 matching lines @@
 #endif
 #ifdef LIBXML_SCHEMAS_ENABLED
     if ((relaxng != NULL) && (sax == 0)
 #ifdef LIBXML_READER_ENABLED
         && (stream == 0)
 #endif /* LIBXML_READER_ENABLED */
         ) {
         xmlRelaxNGParserCtxtPtr ctxt;
 
         /* forces loading the DTDs */
-        xmlLoadExtDtdDefaultValue |= 1; 
+        xmlLoadExtDtdDefaultValue |= 1;
         options |= XML_PARSE_DTDLOAD;
         if (timing) {
             startTimer();
         }
         ctxt = xmlRelaxNGNewParserCtxt(relaxng);
         xmlRelaxNGSetParserErrors(ctxt,
                 (xmlRelaxNGValidityErrorFunc) fprintf,
                 (xmlRelaxNGValidityWarningFunc) fprintf,
                 stderr);
         relaxngschemas = xmlRelaxNGParse(ctxt);
@@ skipping 59 matching lines @@
                    (!strcmp(argv[i], "-output")) ||
                    (!strcmp(argv[i], "--output"))) {
             i++;
             continue;
         }
 #ifdef LIBXML_VALID_ENABLED
         if ((!strcmp(argv[i], "-dtdvalid")) ||
                  (!strcmp(argv[i], "--dtdvalid"))) {
             i++;
             continue;
-        } 
+        }
         if ((!strcmp(argv[i], "-path")) ||
                    (!strcmp(argv[i], "--path"))) {
             i++;
             continue;
         }
         if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
                  (!strcmp(argv[i], "--dtdvalidfpi"))) {
             i++;
             continue;
         }
@@ skipping 18 matching lines @@
             i++;
             continue;
         }
 #ifdef LIBXML_PATTERN_ENABLED
         if ((!strcmp(argv[i], "-pattern")) ||
             (!strcmp(argv[i], "--pattern"))) {
             i++;
             continue;
         }
 #endif
+#ifdef LIBXML_XPATH_ENABLED
+        if ((!strcmp(argv[i], "-xpath")) ||
+            (!strcmp(argv[i], "--xpath"))) {
+            i++;
+            continue;
+        }
+#endif
         if ((timing) && (repeat))
             startTimer();
         /* Remember file names.  "-" means stdin.  <sven@zen.org> */
         if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
             if (repeat) {
                 xmlParserCtxtPtr ctxt = NULL;
 
                 for (acount = 0;acount < repeat;acount++) {
 #ifdef LIBXML_READER_ENABLED
                     if (stream != 0) {
@@ skipping 31 matching lines @@
                     fprintf(stderr, "Registration count off: %d\n", nbregister);
                     progresult = XMLLINT_ERR_RDREGIS;
                 }
             }
             files ++;
             if ((timing) && (repeat)) {
                 endTimer("%d iterations", repeat);
             }
         }
     }
-    if (generate) 
+    if (generate)
         parseAndPrintFile(NULL, NULL);
     if ((htmlout) && (!nowrap)) {
         xmlGenericError(xmlGenericErrorContext, "</body></html>\n");
     }
     if ((files == 0) && (!generate) && (version == 0)) {
         usage(argv[0]);
     }
 #ifdef LIBXML_SCHEMATRON_ENABLED
     if (wxschematron != NULL)
         xmlSchematronFree(wxschematron);
 #endif
 #ifdef LIBXML_SCHEMAS_ENABLED
     if (relaxngschemas != NULL)
         xmlRelaxNGFree(relaxngschemas);
     if (wxschemas != NULL)
         xmlSchemaFree(wxschemas);
     xmlRelaxNGCleanupTypes();
 #endif
 #ifdef LIBXML_PATTERN_ENABLED
     if (patternc != NULL)
         xmlFreePattern(patternc);
 #endif
     xmlCleanupParser();
     xmlMemoryDump();
 
     return(progresult);
 }