Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/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 112 matching lines @@
 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 */
 static int recovery = 0;
 static int noent = 0;
+static int noenc = 0;
 static int noblanks = 0;
 static int noout = 0;
 static int nowrap = 0;
 #ifdef LIBXML_OUTPUT_ENABLED
 static int format = 0;
 static const char *output = NULL;
 static int compress = 0;
 static int oldout = 0;
 #endif /* LIBXML_OUTPUT_ENABLED */
 #ifdef LIBXML_VALID_ENABLED
@@ skipping 12 matching lines @@
 static char * schematron = NULL;
 static xmlSchematronPtr wxschematron = NULL;
 #endif
 static int repeat = 0;
 static int insert = 0;
 #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
 static int html = 0;
 static int xmlout = 0;
 #endif
 static int htmlout = 0;
+#if defined(LIBXML_HTML_ENABLED)
+static int nodefdtd = 0;
+#endif
 #ifdef LIBXML_PUSH_ENABLED
 static int push = 0;
+static int pushsize = 4096;
 #endif /* LIBXML_PUSH_ENABLED */
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
 static int memory = 0;
 #endif
 static int testIO = 0;
 static char *encoding = NULL;
 #ifdef LIBXML_XINCLUDE_ENABLED
 static int xinclude = 0;
 #endif
 static int dtdattrs = 0;
 static int loaddtd = 0;
 static xmllintReturnCode progresult = XMLLINT_RETURN_OK;
@@ skipping 19 matching lines @@
 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 options = XML_PARSE_COMPACT | XML_PARSE_BIG_LINES;
 static int sax = 0;
 static int oldxml10 = 0;
 
 /************************************************************************
  *                                                                      *
  *               Entity loading control and customization.              *
  *                                                                      *
  ************************************************************************/
 #define MAX_PATHS 64
 #ifdef _WIN32
@@ skipping 290 matching lines @@
      * Do nothing
      */
 }
 static void XMLCDECL
 endTimer(char *format, ...)
 {
     /*
      * We cannot do anything because we don't have a timing function
      */
 #ifdef HAVE_STDARG_H
+    va_list ap;
     va_start(ap, format);
     vfprintf(stderr, format, ap);
     va_end(ap);
-    fprintf(stderr, " was not timed\n", msec);
+    fprintf(stderr, " was not timed\n");
 #else
     /* We don't have gettimeofday, time or stdarg.h, what crazy world is
      * this ?!
      */
 #endif
 }
 #endif
 /************************************************************************
  *                                                                      *
  *                      HTML ouput                                      *
@@ skipping 1124 matching lines @@
 #ifdef LIBXML_SCHEMAS_ENABLED
     if (wxschemas != NULL) {
         int ret;
         xmlSchemaValidCtxtPtr vctxt;
 
         vctxt = xmlSchemaNewValidCtxt(wxschemas);
         xmlSchemaSetValidErrors(vctxt,
                 (xmlSchemaValidityErrorFunc) fprintf,
                 (xmlSchemaValidityWarningFunc) fprintf,
                 stderr);
+        xmlSchemaValidateSetFilename(vctxt, filename);
 
         ret = xmlSchemaValidateStream(vctxt, buf, 0, handler,
                                       (void *)user_data);
         if (repeat == 0) {
             if (ret == 0) {
                 fprintf(stderr, "%s validates\n", filename);
             } else if (ret > 0) {
                 fprintf(stderr, "%s fails to validate\n", filename);
                 progresult = XMLLINT_ERR_VALID;
             } else {
@@ skipping 134 matching lines @@
         }
         if (path != NULL)
             xmlFree(path);
     }
 #endif
 }
 
 static void streamFile(char *filename) {
     xmlTextReaderPtr reader;
     int ret;
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
     int fd = -1;
     struct stat info;
     const char *base = NULL;
     xmlParserInputBufferPtr input = NULL;
 
     if (memory) {
         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)
+        if (base == (void *) MAP_FAILED) {
+            close(fd);
+            fprintf(stderr, "mmap failure for file %s\n", filename);
+            progresult = XMLLINT_ERR_RDFILE;
             return;
+        }
 
         reader = xmlReaderForMemory(base, info.st_size, filename,
                                     NULL, options);
     } else
 #endif
         reader = xmlReaderForFile(filename, NULL, options);
 #ifdef LIBXML_PATTERN_ENABLED
     if (pattern != NULL) {
         patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
         if (patternc == NULL) {
@@ skipping 16 matching lines @@
     }
 #endif
 
 
     if (reader != NULL) {
 #ifdef LIBXML_VALID_ENABLED
         if (valid)
             xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
         else
 #endif /* LIBXML_VALID_ENABLED */
-            xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
+            if (loaddtd)
+                xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
 #ifdef LIBXML_SCHEMAS_ENABLED
         if (relaxng != NULL) {
             if ((timing) && (!repeat)) {
                 startTimer();
             }
             ret = xmlTextReaderRelaxNGValidate(reader, relaxng);
             if (ret < 0) {
                 xmlGenericError(xmlGenericErrorContext,
                         "Relax-NG schema %s failed to compile\n", relaxng);
                 progresult = XMLLINT_ERR_SCHEMACOMP;
@@ skipping 80 matching lines @@
     } else {
         fprintf(stderr, "Unable to open %s\n", filename);
         progresult = XMLLINT_ERR_UNCLASS;
     }
 #ifdef LIBXML_PATTERN_ENABLED
     if (patstream != NULL) {
         xmlFreeStreamCtxt(patstream);
         patstream = NULL;
     }
 #endif
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
     if (memory) {
         xmlFreeParserInputBuffer(input);
         munmap((char *) base, info.st_size);
         close(fd);
     }
 #endif
 }
 
 static void walkDoc(xmlDocPtr doc) {
     xmlTextReaderPtr reader;
@@ skipping 79 matching lines @@
  ************************************************************************/
 
 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) {
+            if ((cur->nodesetval == NULL) || (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;
             }
@@ skipping 44 matching lines @@
 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);
+    ctxt->node = (xmlNodePtr) 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);
@@ skipping 27 matching lines @@
         }
     }
 #endif /* LIBXML_TREE_ENABLED */
 #ifdef LIBXML_HTML_ENABLED
 #ifdef LIBXML_PUSH_ENABLED
     else if ((html) && (push)) {
         FILE *f;
 
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
         f = fopen(filename, "rb");
+#elif defined(__OS400__)
+        f = fopen(filename, "rb");
 #else
         f = fopen(filename, "r");
 #endif
         if (f != NULL) {
-            int res, size = 3;
+            int res;
             char chars[4096];
             htmlParserCtxtPtr ctxt;
 
-            /* if (repeat) */
-                size = 4096;
             res = fread(chars, 1, 4, f);
             if (res > 0) {
                 ctxt = htmlCreatePushParserCtxt(NULL, NULL,
                             chars, res, filename, XML_CHAR_ENCODING_NONE);
-                while ((res = fread(chars, 1, size, f)) > 0) {
+                xmlCtxtUseOptions(ctxt, options);
+                while ((res = fread(chars, 1, pushsize, f)) > 0) {
                     htmlParseChunk(ctxt, chars, res, 0);
                 }
                 htmlParseChunk(ctxt, chars, 0, 1);
                 doc = ctxt->myDoc;
                 htmlFreeParserCtxt(ctxt);
             }
             fclose(f);
         }
     }
 #endif /* LIBXML_PUSH_ENABLED */
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
     else if ((html) && (memory)) {
         int fd;
         struct stat info;
         const char *base;
         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)
+        if (base == (void *) MAP_FAILED) {
+            close(fd);
+            fprintf(stderr, "mmap failure for file %s\n", filename);
+            progresult = XMLLINT_ERR_RDFILE;
             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
         /*
          * build an XML tree from a string;
          */
         if (push) {
             FILE *f;
 
             /* '-' Usually means stdin -<sven@zen.org> */
             if ((filename[0] == '-') && (filename[1] == 0)) {
               f = stdin;
             } else {
 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
                 f = fopen(filename, "rb");
+#elif defined(__OS400__)
+                f = fopen(filename, "rb");
 #else
                 f = fopen(filename, "r");
 #endif
             }
             if (f != NULL) {
                 int ret;
                 int res, size = 1024;
                 char chars[1024];
                 xmlParserCtxtPtr ctxt;
 
@@ skipping 21 matching lines @@
         } 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__)
                 f = fopen(filename, "rb");
+#elif defined(__OS400__)
+                f = fopen(filename, "rb");
 #else
                 f = fopen(filename, "r");
 #endif
                 if (f != NULL) {
                     if (rectxt == NULL)
                         doc = xmlReadIO((xmlInputReadCallback) myRead,
                                         (xmlInputCloseCallback) myClose, f,
                                         filename, NULL, options);
                     else
                         doc = xmlCtxtReadIO(rectxt,
@@ skipping 16 matching lines @@
                 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
+#ifdef HAVE_MMAP
         } else if (memory) {
             int fd;
             struct stat info;
             const char *base;
             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)
+            if (base == (void *) MAP_FAILED) {
+                close(fd);
+                fprintf(stderr, "mmap failure for file %s\n", filename);
+                progresult = XMLLINT_ERR_RDFILE;
                 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);
@@ skipping 153 matching lines @@
 #endif
             if ((timing) && (!repeat)) {
                 startTimer();
             }
 #ifdef LIBXML_HTML_ENABLED
             if ((html) && (!xmlout)) {
                 if (compress) {
                     htmlSaveFile(output ? output : "-", doc);
                 }
                 else if (encoding != NULL) {
-                    if ( format ) {
+                    if (format == 1) {
                         htmlSaveFileFormat(output ? output : "-", doc, encoding, 1);
                     }
                     else {
                         htmlSaveFileFormat(output ? output : "-", doc, encoding, 0);
                     }
                 }
-                else if (format) {
+                else if (format == 1) {
                     htmlSaveFileFormat(output ? output : "-", doc, NULL, 1);
                 }
                 else {
                     FILE *out;
                     if (output == NULL)
                         out = stdout;
                     else {
                         out = fopen(output,"wb");
                     }
                     if (out != NULL) {
@@ skipping 12 matching lines @@
                 }
             } else
 #endif
 #ifdef LIBXML_C14N_ENABLED
             if (canonical) {
                 xmlChar *result = NULL;
                 int size;
 
                 size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_0, NULL, 1, &result);
                 if (size >= 0) {
-                    write(1, result, size);
+                    if (write(1, result, size) == -1) {
+                        fprintf(stderr, "Can't write data\n");
+                    }
                     xmlFree(result);
                 } else {
                     fprintf(stderr, "Failed to canonicalize\n");
                     progresult = XMLLINT_ERR_OUT;
                 }
-            } else if (canonical) {
+            } else if (canonical_11) {
                 xmlChar *result = NULL;
                 int size;
 
                 size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_1, NULL, 1, &result);
                 if (size >= 0) {
-                    write(1, result, size);
+                    if (write(1, result, size) == -1) {
+                        fprintf(stderr, "Can't write data\n");
+                    }
                     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, XML_C14N_EXCLUSIVE_1_0, NULL, 1, &result);
                 if (size >= 0) {
-                    write(1, result, size);
+                    if (write(1, result, size) == -1) {
+                        fprintf(stderr, "Can't write data\n");
+                    }
                     xmlFree(result);
                 } else {
                     fprintf(stderr, "Failed to canonicalize\n");
                     progresult = XMLLINT_ERR_OUT;
                 }
             } else
 #endif
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
             if (memory) {
                 xmlChar *result;
                 int len;
 
                 if (encoding != NULL) {
-                    if ( format ) {
+                    if (format == 1) {
                         xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
                     } else {
                         xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
                     }
                 } else {
-                    if (format)
+                    if (format == 1)
                         xmlDocDumpFormatMemory(doc, &result, &len, 1);
                     else
                         xmlDocDumpMemory(doc, &result, &len);
                 }
                 if (result == NULL) {
                     fprintf(stderr, "Failed to save\n");
                     progresult = XMLLINT_ERR_OUT;
                 } else {
-                    write(1, result, len);
+                    if (write(1, result, len) == -1) {
+                        fprintf(stderr, "Can't write data\n");
+                    }
                     xmlFree(result);
                 }
 
             } else
-#endif /* HAVE_SYS_MMAN_H */
+#endif /* HAVE_MMAP */
             if (compress) {
                 xmlSaveFile(output ? output : "-", doc);
             } else if (oldout) {
                 if (encoding != NULL) {
-                    if ( format ) {
+                    if (format == 1) {
                         ret = xmlSaveFormatFileEnc(output ? output : "-", doc,
                                                    encoding, 1);
                     }
                     else {
                         ret = xmlSaveFileEnc(output ? output : "-", doc,
                                              encoding);
                     }
                     if (ret < 0) {
                         fprintf(stderr, "failed save to %s\n",
                                 output ? output : "-");
                         progresult = XMLLINT_ERR_OUT;
                     }
-                } else if (format) {
+                } else if (format == 1) {
                     ret = xmlSaveFormatFile(output ? output : "-", doc, 1);
                     if (ret < 0) {
                         fprintf(stderr, "failed save to %s\n",
                                 output ? output : "-");
                         progresult = XMLLINT_ERR_OUT;
                     }
                 } else {
                     FILE *out;
                     if (output == NULL)
                         out = stdout;
                     else {
                         out = fopen(output,"wb");
                     }
                     if (out != NULL) {
                         if (xmlDocDump(out, doc) < 0)
                             progresult = XMLLINT_ERR_OUT;
 
                         if (output != NULL)
                             fclose(out);
                     } else {
                         fprintf(stderr, "failed to open %s\n", output);
                         progresult = XMLLINT_ERR_OUT;
                     }
                 }
             } else {
                 xmlSaveCtxtPtr ctxt;
                 int saveOpts = 0;
 
-                if (format)
+                if (format == 1)
                     saveOpts |= XML_SAVE_FORMAT;
+                else if (format == 2)
+                    saveOpts |= XML_SAVE_WSNONSIG;
 
 #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);
@@ skipping 269 matching lines @@
     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 ");
+    if (xmlHasFeature(XML_WITH_LZMA)) fprintf(stderr, "Lzma ");
     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--noenc : ignore any encoding specified inside the document\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--load-trace : print trace of all external entities 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");
     printf("\t--postvalid : do a posteriori validation, i.e after parsing\n");
     printf("\t--dtdvalid URL : do a posteriori validation against a given DTD\n");
     printf("\t--dtdvalidfpi FPI : same but name the DTD with a Public Identifier\n");
 #endif /* LIBXML_VALID_ENABLED */
     printf("\t--timing : print some timings\n");
     printf("\t--output file or -o file: save to a given file\n");
     printf("\t--repeat : repeat 100 times, for timing or profiling\n");
     printf("\t--insert : ad-hoc test for valid insertions\n");
 #ifdef LIBXML_OUTPUT_ENABLED
 #ifdef HAVE_ZLIB_H
     printf("\t--compress : turn on gzip compression of output\n");
 #endif
 #endif /* LIBXML_OUTPUT_ENABLED */
 #ifdef LIBXML_HTML_ENABLED
     printf("\t--html : use the HTML parser\n");
     printf("\t--xmlout : force to use the XML serializer when using --html\n");
+    printf("\t--nodefdtd : do not default HTML doctype\n");
 #endif
 #ifdef LIBXML_PUSH_ENABLED
     printf("\t--push : use the push mode of the parser\n");
+    printf("\t--pushsmall : use the push mode of the parser using tiny increments\n");
 #endif /* LIBXML_PUSH_ENABLED */
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
     printf("\t--memory : parse from memory\n");
 #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");
+    printf("\t--pretty STYLE : pretty-print in a particular style\n");
+    printf("\t                 0 Do not pretty print\n");
+    printf("\t                 1 Format the XML content, as --format\n");
+    printf("\t                 2 Add whitespace inside tags, preserving content\n");
 #endif /* LIBXML_OUTPUT_ENABLED */
     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");
@@ skipping 23 matching lines @@
 #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");
+    printf("\t--xpath expr: evaluate the XPath expression, imply --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));
+    if (node->_private == NULL) {
+        fprintf(stderr, "Out of memory in xmllint:registerNode()\n");
+        exit(XMLLINT_ERR_MEM);
+    }
     *(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--;
@@ skipping 36 matching lines @@
                  (!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], "-noenc")) ||
+                 (!strcmp(argv[i], "--noenc"))) {
+            noenc++;
+            options |= XML_PARSE_IGNORE_ENC;
         } 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;
         } else if ((!strcmp(argv[i], "-nodict")) ||
                  (!strcmp(argv[i], "--nodict"))) {
             options |= XML_PARSE_NODICT;
         } else if ((!strcmp(argv[i], "-version")) ||
@@ skipping 18 matching lines @@
                  (!strcmp(argv[i], "--nowrap")))
             nowrap++;
 #ifdef LIBXML_HTML_ENABLED
         else if ((!strcmp(argv[i], "-html")) ||
                  (!strcmp(argv[i], "--html"))) {
             html++;
         }
         else if ((!strcmp(argv[i], "-xmlout")) ||
                  (!strcmp(argv[i], "--xmlout"))) {
             xmlout++;
+        } else if ((!strcmp(argv[i], "-nodefdtd")) ||
+                 (!strcmp(argv[i], "--nodefdtd"))) {
+            nodefdtd++;
+            options |= HTML_PARSE_NODEFDTD;
         }
 #endif /* LIBXML_HTML_ENABLED */
         else if ((!strcmp(argv[i], "-loaddtd")) ||
                  (!strcmp(argv[i], "--loaddtd"))) {
             loaddtd++;
             options |= XML_PARSE_DTDLOAD;
         } else if ((!strcmp(argv[i], "-dtdattr")) ||
                  (!strcmp(argv[i], "--dtdattr"))) {
             loaddtd++;
             dtdattrs++;
@@ skipping 39 matching lines @@
                  (!strcmp(argv[i], "--repeat"))) {
             if (repeat)
                 repeat *= 10;
             else
                 repeat = 100;
         }
 #ifdef LIBXML_PUSH_ENABLED
         else if ((!strcmp(argv[i], "-push")) ||
                  (!strcmp(argv[i], "--push")))
             push++;
+        else if ((!strcmp(argv[i], "-pushsmall")) ||
+                 (!strcmp(argv[i], "--pushsmall"))) {
+            push++;
+            pushsize = 10;
+        }
 #endif /* LIBXML_PUSH_ENABLED */
-#ifdef HAVE_SYS_MMAN_H
+#ifdef HAVE_MMAP
         else if ((!strcmp(argv[i], "-memory")) ||
                  (!strcmp(argv[i], "--memory")))
             memory++;
 #endif
         else if ((!strcmp(argv[i], "-testIO")) ||
                  (!strcmp(argv[i], "--testIO")))
             testIO++;
 #ifdef LIBXML_XINCLUDE_ENABLED
         else if ((!strcmp(argv[i], "-xinclude")) ||
                  (!strcmp(argv[i], "--xinclude"))) {
@@ skipping 71 matching lines @@
                  (!strcmp(argv[i], "--encode"))) {
             i++;
             encoding = argv[i];
             /*
              * OK it's for testing purposes
              */
             xmlAddEncodingAlias("UTF-8", "DVEnc");
         }
         else if ((!strcmp(argv[i], "-noblanks")) ||
                  (!strcmp(argv[i], "--noblanks"))) {
-             noblanks++;
-             xmlKeepBlanksDefault(0);
+            noblanks++;
+            xmlKeepBlanksDefault(0);
+            options |= XML_PARSE_NOBLANKS;
         }
         else if ((!strcmp(argv[i], "-maxmem")) ||
                  (!strcmp(argv[i], "--maxmem"))) {
              i++;
              if (sscanf(argv[i], "%d", &maxmem) == 1) {
                  xmlMemSetup(myFreeFunc, myMallocFunc, myReallocFunc,
                              myStrdupFunc);
              } else {
                  maxmem = 0;
              }
         }
         else if ((!strcmp(argv[i], "-format")) ||
                  (!strcmp(argv[i], "--format"))) {
              noblanks++;
 #ifdef LIBXML_OUTPUT_ENABLED
-             format++;
+             format = 1;
 #endif /* LIBXML_OUTPUT_ENABLED */
              xmlKeepBlanksDefault(0);
         }
+        else if ((!strcmp(argv[i], "-pretty")) ||
+                 (!strcmp(argv[i], "--pretty"))) {
+             i++;
+#ifdef LIBXML_OUTPUT_ENABLED
+       if (argv[i] != NULL) {
+                 format = atoi(argv[i]);
+                 if (format == 1) {
+                     noblanks++;
+                     xmlKeepBlanksDefault(0);
+                 }
+       }
+#endif /* LIBXML_OUTPUT_ENABLED */
+        }
 #ifdef LIBXML_READER_ENABLED
         else if ((!strcmp(argv[i], "-stream")) ||
                  (!strcmp(argv[i], "--stream"))) {
              stream++;
         }
         else if ((!strcmp(argv[i], "-walker")) ||
                  (!strcmp(argv[i], "--walker"))) {
              walker++;
              noout++;
         }
@@ skipping 266 matching lines @@
         if ((!strcmp(argv[i], "-relaxng")) ||
                  (!strcmp(argv[i], "--relaxng"))) {
             i++;
             continue;
         }
         if ((!strcmp(argv[i], "-maxmem")) ||
                  (!strcmp(argv[i], "--maxmem"))) {
             i++;
             continue;
         }
+        if ((!strcmp(argv[i], "-pretty")) ||
+                 (!strcmp(argv[i], "--pretty"))) {
+            i++;
+            continue;
+        }
         if ((!strcmp(argv[i], "-schema")) ||
                  (!strcmp(argv[i], "--schema"))) {
             i++;
             continue;
         }
         if ((!strcmp(argv[i], "-schematron")) ||
                  (!strcmp(argv[i], "--schematron"))) {
             i++;
             continue;
         }
@@ skipping 84 matching lines @@
 #ifdef LIBXML_PATTERN_ENABLED
     if (patternc != NULL)
         xmlFreePattern(patternc);
 #endif
     xmlCleanupParser();
     xmlMemoryDump();
 
     return(progresult);
 }