Adding xmllint.c missing from CVs too, Daniel.
diff --git a/xmllint.c b/xmllint.c
new file mode 100644
index 0000000..aa58625
--- /dev/null
+++ b/xmllint.c
@@ -0,0 +1,620 @@
+/*
+ * xmllint.c : a small tester program for XML input.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel.Veillard@w3.org
+ */
+
+#ifdef WIN32
+#include "win32config.h"
+#else
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_LIBREADLINE
+#include <readline/readline.h>
+#ifdef HAVE_LIBHISTORY
+#include <readline/history.h>
+#endif
+#endif
+
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/debugXML.h>
+
+#ifdef LIBXML_DEBUG_ENABLED
+static int debug = 0;
+static int shell = 0;
+static int debugent = 0;
+#endif
+static int copy = 0;
+static int recovery = 0;
+static int noent = 0;
+static int noout = 0;
+static int nowrap = 0;
+static int valid = 0;
+static int postvalid = 0;
+static int repeat = 0;
+static int insert = 0;
+static int compress = 0;
+static int html = 0;
+static int htmlout = 0;
+static int push = 0;
+static int noblanks = 0;
+
+extern int xmlDoValidityCheckingDefaultValue;
+extern int xmlGetWarningsDefaultValue;
+
+/************************************************************************
+ * *
+ * HTML ouput *
+ * *
+ ************************************************************************/
+char buffer[50000];
+
+void
+xmlHTMLEncodeSend(void) {
+ char *result;
+
+ result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);
+ if (result) {
+ fprintf(stderr, "%s", result);
+ xmlFree(result);
+ }
+ buffer[0] = 0;
+}
+
+/**
+ * xmlHTMLPrintFileInfo:
+ * @input: an xmlParserInputPtr input
+ *
+ * Displays the associated file and line informations for the current input
+ */
+
+void
+xmlHTMLPrintFileInfo(xmlParserInputPtr input) {
+ fprintf(stderr, "<p>");
+ if (input != NULL) {
+ if (input->filename) {
+ sprintf(&buffer[strlen(buffer)], "%s:%d: ", input->filename,
+ input->line);
+ } else {
+ sprintf(&buffer[strlen(buffer)], "Entity: line %d: ", input->line);
+ }
+ }
+ xmlHTMLEncodeSend();
+}
+
+/**
+ * xmlHTMLPrintFileContext:
+ * @input: an xmlParserInputPtr input
+ *
+ * Displays current context within the input content for error tracking
+ */
+
+void
+xmlHTMLPrintFileContext(xmlParserInputPtr input) {
+ const xmlChar *cur, *base;
+ int n;
+
+ if (input == NULL) return;
+ fprintf(stderr, "<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)) {
+ sprintf(&buffer[strlen(buffer)], "%c", (unsigned char) *cur++);
+ n++;
+ }
+ sprintf(&buffer[strlen(buffer)], "\n");
+ cur = input->cur;
+ while ((*cur == '\n') || (*cur == '\r'))
+ cur--;
+ n = 0;
+ while ((cur != base) && (n++ < 80)) {
+ sprintf(&buffer[strlen(buffer)], " ");
+ base++;
+ }
+ sprintf(&buffer[strlen(buffer)],"^\n");
+ xmlHTMLEncodeSend();
+ fprintf(stderr, "</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.
+ */
+void
+xmlHTMLError(void *ctx, const char *msg, ...)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlParserInputPtr input;
+ xmlParserInputPtr cur = NULL;
+ va_list args;
+
+ buffer[0] = 0;
+ input = ctxt->input;
+ if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
+ cur = input;
+ input = ctxt->inputTab[ctxt->inputNr - 2];
+ }
+
+ xmlHTMLPrintFileInfo(input);
+
+ fprintf(stderr, "<b>error</b>: ");
+ va_start(args, msg);
+ vsprintf(&buffer[strlen(buffer)], msg, args);
+ va_end(args);
+ xmlHTMLEncodeSend();
+ fprintf(stderr, "</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.
+ */
+void
+xmlHTMLWarning(void *ctx, const char *msg, ...)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlParserInputPtr input;
+ xmlParserInputPtr cur = NULL;
+ va_list args;
+
+ buffer[0] = 0;
+ input = ctxt->input;
+ if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
+ cur = input;
+ input = ctxt->inputTab[ctxt->inputNr - 2];
+ }
+
+
+ xmlHTMLPrintFileInfo(input);
+
+ fprintf(stderr, "<b>warning</b>: ");
+ va_start(args, msg);
+ vsprintf(&buffer[strlen(buffer)], msg, args);
+ va_end(args);
+ xmlHTMLEncodeSend();
+ fprintf(stderr, "</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.
+ */
+void
+xmlHTMLValidityError(void *ctx, const char *msg, ...)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlParserInputPtr input;
+ va_list args;
+
+ buffer[0] = 0;
+ input = ctxt->input;
+ if ((input->filename == NULL) && (ctxt->inputNr > 1))
+ input = ctxt->inputTab[ctxt->inputNr - 2];
+
+ xmlHTMLPrintFileInfo(input);
+
+ fprintf(stderr, "<b>validity error</b>: ");
+ va_start(args, msg);
+ vsprintf(&buffer[strlen(buffer)], msg, args);
+ va_end(args);
+ xmlHTMLEncodeSend();
+ fprintf(stderr, "</p>\n");
+
+ xmlHTMLPrintFileContext(input);
+ xmlHTMLEncodeSend();
+}
+
+/**
+ * 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.
+ */
+void
+xmlHTMLValidityWarning(void *ctx, const char *msg, ...)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlParserInputPtr input;
+ va_list args;
+
+ buffer[0] = 0;
+ input = ctxt->input;
+ if ((input->filename == NULL) && (ctxt->inputNr > 1))
+ input = ctxt->inputTab[ctxt->inputNr - 2];
+
+ xmlHTMLPrintFileInfo(input);
+
+ fprintf(stderr, "<b>validity warning</b>: ");
+ va_start(args, msg);
+ vsprintf(&buffer[strlen(buffer)], msg, args);
+ va_end(args);
+ xmlHTMLEncodeSend();
+ fprintf(stderr, "</p>\n");
+
+ xmlHTMLPrintFileContext(input);
+ xmlHTMLEncodeSend();
+}
+
+/************************************************************************
+ * *
+ * Shell Interface *
+ * *
+ ************************************************************************/
+/**
+ * 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.
+ */
+char *
+xmlShellReadline(char *prompt) {
+#ifdef HAVE_LIBREADLINE
+ char *line_read;
+
+ /* Get a line from the user. */
+ line_read = readline (prompt);
+
+ /* If the line has any text in it, save it on the history. */
+ if (line_read && *line_read)
+ add_history (line_read);
+
+ return (line_read);
+#else
+ char line_read[501];
+
+ if (prompt != NULL)
+ fprintf(stdout, "%s", prompt);
+ if (!fgets(line_read, 500, stdin))
+ return(NULL);
+ line_read[500] = 0;
+ return(strdup(line_read));
+#endif
+}
+
+/************************************************************************
+ * *
+ * Test processing *
+ * *
+ ************************************************************************/
+void parseAndPrintFile(char *filename) {
+ xmlDocPtr doc = NULL, tmp;
+
+#ifdef LIBXML_HTML_ENABLED
+ if (html) {
+ doc = htmlParseFile(filename, NULL);
+ } else {
+#endif /* LIBXML_HTML_ENABLED */
+ /*
+ * build an XML tree from a string;
+ */
+ if (push) {
+ FILE *f;
+
+ f = fopen(filename, "r");
+ if (f != NULL) {
+ int res, size = 3;
+ char chars[1024];
+ xmlParserCtxtPtr ctxt;
+
+ if (repeat)
+ size = 1024;
+ res = fread(chars, 1, 4, f);
+ if (res > 0) {
+ ctxt = xmlCreatePushParserCtxt(NULL, NULL,
+ chars, res, filename);
+ while ((res = fread(chars, 1, size, f)) > 0) {
+ xmlParseChunk(ctxt, chars, res, 0);
+ }
+ xmlParseChunk(ctxt, chars, 0, 1);
+ doc = ctxt->myDoc;
+ xmlFreeParserCtxt(ctxt);
+ }
+ }
+ } else if (recovery) {
+ doc = xmlRecoverFile(filename);
+ } else if (htmlout) {
+ int ret;
+ xmlParserCtxtPtr ctxt;
+ xmlSAXHandler silent, *old;
+
+ ctxt = xmlCreateFileParserCtxt(filename);
+ memcpy(&silent, ctxt->sax, sizeof(silent));
+ old = ctxt->sax;
+ silent.error = xmlHTMLError;
+ if (xmlGetWarningsDefaultValue)
+ silent.warning = xmlHTMLWarning;
+ else
+ silent.warning = NULL;
+ silent.fatalError = xmlHTMLError;
+ ctxt->sax = &silent;
+ ctxt->vctxt.error = xmlHTMLValidityError;
+ if (xmlGetWarningsDefaultValue)
+ ctxt->vctxt.warning = xmlHTMLValidityWarning;
+ else
+ ctxt->vctxt.warning = NULL;
+
+ xmlParseDocument(ctxt);
+
+ ret = ctxt->wellFormed;
+ doc = ctxt->myDoc;
+ ctxt->sax = old;
+ xmlFreeParserCtxt(ctxt);
+ if (!ret) {
+ xmlFreeDoc(doc);
+ doc = NULL;
+ }
+ } else
+ doc = xmlParseFile(filename);
+#ifdef LIBXML_HTML_ENABLED
+ }
+#endif
+
+#ifdef LIBXML_DEBUG_ENABLED
+ /*
+ * shell interraction
+ */
+ if (shell)
+ xmlShell(doc, filename, xmlShellReadline, stdout);
+#endif
+
+ /*
+ * test intermediate copy if needed.
+ */
+ if (copy) {
+ tmp = doc;
+ doc = xmlCopyDoc(doc, 1);
+ xmlFreeDoc(tmp);
+ }
+
+ if ((insert) && (!html)) {
+ const xmlChar* list[256];
+ int nb, i;
+ xmlNodePtr node;
+
+ if (doc->children != NULL) {
+ node = doc->children;
+ while ((node != NULL) && (node->last == NULL)) node = node->next;
+ if (node != NULL) {
+ nb = xmlValidGetValidElements(node->last, NULL, list, 256);
+ if (nb < 0) {
+ printf("could not get valid list of elements\n");
+ } else if (nb == 0) {
+ printf("No element can be indersted under root\n");
+ } else {
+ printf("%d element types can be indersted under root:\n",
+ nb);
+ for (i = 0;i < nb;i++) {
+ printf("%s\n", list[i]);
+ }
+ }
+ }
+ }
+ }else if (noout == 0) {
+ /*
+ * print it.
+ */
+#ifdef LIBXML_DEBUG_ENABLED
+ if (!debug) {
+#endif
+ if (compress)
+ xmlSaveFile("-", doc);
+ else
+ xmlDocDump(stdout, doc);
+#ifdef LIBXML_DEBUG_ENABLED
+ } else
+ xmlDebugDumpDocument(stdout, doc);
+#endif
+ }
+
+ /*
+ * A posteriori validation test
+ */
+ if (postvalid) {
+ xmlValidCtxt cvp;
+ cvp.userData = (void *) stderr; cvp.error = (xmlValidityErrorFunc) fprintf; cvp.warning = (xmlValidityWarningFunc) fprintf;
+ xmlValidateDocument(&cvp, doc);
+ }
+
+#ifdef LIBXML_DEBUG_ENABLED
+ if ((debugent) && (!html))
+ xmlDebugDumpEntities(stdout, doc);
+#endif
+
+ /*
+ * free it.
+ */
+ xmlFreeDoc(doc);
+}
+
+int main(int argc, char **argv) {
+ int i, count;
+ int files = 0;
+
+ for (i = 1; i < argc ; i++) {
+#ifdef LIBXML_DEBUG_ENABLED
+ if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
+ debug++;
+ else if ((!strcmp(argv[i], "-debugent")) || (!strcmp(argv[i], "--debugent")))
+ debugent++;
+ else if ((!strcmp(argv[i], "-shell")) ||
+ (!strcmp(argv[i], "--shell"))) {
+ shell++;
+ noout = 1;
+ } else
+#endif
+ if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
+ copy++;
+ else if ((!strcmp(argv[i], "-recover")) ||
+ (!strcmp(argv[i], "--recover")))
+ recovery++;
+ else if ((!strcmp(argv[i], "-noent")) ||
+ (!strcmp(argv[i], "--noent")))
+ noent++;
+ else if ((!strcmp(argv[i], "-noout")) ||
+ (!strcmp(argv[i], "--noout")))
+ noout++;
+ else if ((!strcmp(argv[i], "-htmlout")) ||
+ (!strcmp(argv[i], "--htmlout")))
+ htmlout++;
+#ifdef LIBXML_HTML_ENABLED
+ else if ((!strcmp(argv[i], "-html")) ||
+ (!strcmp(argv[i], "--html"))) {
+ html++;
+ }
+#endif /* LIBXML_HTML_ENABLED */
+ else if ((!strcmp(argv[i], "-nowrap")) ||
+ (!strcmp(argv[i], "--nowrap")))
+ nowrap++;
+ else if ((!strcmp(argv[i], "-valid")) ||
+ (!strcmp(argv[i], "--valid")))
+ valid++;
+ else if ((!strcmp(argv[i], "-postvalid")) ||
+ (!strcmp(argv[i], "--postvalid")))
+ postvalid++;
+ else if ((!strcmp(argv[i], "-insert")) ||
+ (!strcmp(argv[i], "--insert")))
+ insert++;
+ else if ((!strcmp(argv[i], "-repeat")) ||
+ (!strcmp(argv[i], "--repeat")))
+ repeat++;
+ else if ((!strcmp(argv[i], "-push")) ||
+ (!strcmp(argv[i], "--push")))
+ push++;
+ else if ((!strcmp(argv[i], "-compress")) ||
+ (!strcmp(argv[i], "--compress"))) {
+ compress++;
+ xmlSetCompressMode(9);
+ }
+ else if ((!strcmp(argv[i], "-nowarning")) ||
+ (!strcmp(argv[i], "--nowarning"))) {
+ xmlGetWarningsDefaultValue = 0;
+ }
+ else if ((!strcmp(argv[i], "-noblanks")) ||
+ (!strcmp(argv[i], "--noblanks"))) {
+ noblanks++;
+ xmlKeepBlanksDefault(0);
+ }
+ }
+ if (noent != 0) xmlSubstituteEntitiesDefault(1);
+ if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
+ if ((htmlout) && (!nowrap)) {
+ fprintf(stderr,
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
+ fprintf(stderr, "\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
+ fprintf(stderr,
+ "<html><head><title>%s output</title></head>\n",
+ argv[0]);
+ fprintf(stderr,
+ "<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
+ argv[0]);
+ }
+ for (i = 1; i < argc ; i++) {
+ if (argv[i][0] != '-') {
+ if (repeat) {
+ for (count = 0;count < 100 * repeat;count++)
+ parseAndPrintFile(argv[i]);
+ } else
+ parseAndPrintFile(argv[i]);
+ files ++;
+ }
+ }
+ if ((htmlout) && (!nowrap)) {
+ fprintf(stderr, "</body></html>\n");
+ }
+ if (files == 0) {
+ printf("Usage : %s [--debug] [--debugent] [--copy] [--recover] [--noent] [--noout] [--valid] [--repeat] XMLfiles ...\n",
+ argv[0]);
+ printf("\tParse the XML files and output the result of the parsing\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");
+#endif
+ printf("\t--copy : used to test the internal copy implementation\n");
+ printf("\t--recover : output what was parsable on broken XML documents\n");
+ printf("\t--noent : substitute entity references by their value\n");
+ printf("\t--noout : don't output the result tree\n");
+ printf("\t--htmlout : output results as HTML\n");
+ printf("\t--nowarp : do not put HTML doc wrapper\n");
+ 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--repeat : repeat 100 times, for timing or profiling\n");
+ printf("\t--insert : ad-hoc test for valid insertions\n");
+ printf("\t--compress : turn on gzip compression of output\n");
+#ifdef LIBXML_HTML_ENABLED
+ printf("\t--html : use the HTML parser\n");
+#endif
+ printf("\t--push : use the push mode of the parser\n");
+ printf("\t--nowarning : do not emit warnings from parser/validator\n");
+ printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
+ }
+ xmlCleanupParser();
+ xmlMemoryDump();
+
+ return(0);
+}