Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/xsltproc/xsltproc.c

+/*
+ * xsltproc.c: user program for the XSL Transformation 1.0 engine
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxslt/libxslt.h"
+#include "libexslt/exslt.h"
+#include <stdio.h>
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+#include <libxml/xmlmemory.h>
+#include <libxml/debugXML.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/xmlIO.h>
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+#ifdef LIBXML_CATALOG_ENABLED
+#include <libxml/catalog.h>
+#endif
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/uri.h>
+
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/extensions.h>
+#include <libxslt/security.h>
+
+#include <libexslt/exsltconfig.h>
+
+#if defined(WIN32) && !defined (__CYGWIN__)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <winsock2.h>
+#define gettimeofday(p1,p2)
+#define snprintf _snprintf
+#endif /* _MS_VER */
+#else /* WIN32 */
+#if defined(HAVE_SYS_TIME_H)
+#include <sys/time.h>
+#elif defined(HAVE_TIME_H)
+#include <time.h>
+#endif
+#endif /* WIN32 */
+
+#ifdef HAVE_SYS_TIMEB_H
+#include <sys/timeb.h>
+#endif
+
+static int debug = 0;
+static int repeat = 0;
+static int timing = 0;
+static int dumpextensions = 0;
+static int novalid = 0;
+static int nodtdattr = 0;
+static int noout = 0;
+static int nodict = 0;
+#ifdef LIBXML_HTML_ENABLED
+static int html = 0;
+#endif
+static char *encoding = NULL;
+static int load_trace = 0;
+#ifdef LIBXML_XINCLUDE_ENABLED
+static int xinclude = 0;
+static int xincludestyle = 0;
+#endif
+static int profile = 0;
+
+#define MAX_PARAMETERS 64
+#define MAX_PATHS 64
+
+static int options = XSLT_PARSE_OPTIONS;
+static const char *params[MAX_PARAMETERS + 1];
+static int nbparams = 0;
+static xmlChar *strparams[MAX_PARAMETERS + 1];
+static int nbstrparams = 0;
+static xmlChar *paths[MAX_PATHS + 1];
+static int nbpaths = 0;
+static char *output = NULL;
+static int errorno = 0;
+static const char *writesubtree = NULL;
+
+/*
+ * Entity loading control and customization.
+ */
+static
+void parsePath(const xmlChar *path) {
+    const xmlChar *cur;
+
+    if (path == NULL)
+        return;
+    while (*path != 0) {
+        if (nbpaths >= MAX_PATHS) {
+            fprintf(stderr, "MAX_PATHS reached: too many paths\n");
+            return;
+        }
+        cur = path;
+        while ((*cur == ' ') || (*cur == ':'))
+            cur++;
+        path = cur;
+        while ((*cur != 0) && (*cur != ' ') && (*cur != ':'))
+            cur++;
+        if (cur != path) {
+            paths[nbpaths] = xmlStrndup(path, cur - path);
+            if (paths[nbpaths] != NULL)
+                nbpaths++;
+            path = cur;
+        }
+    }
+}
+
+xmlExternalEntityLoader defaultEntityLoader = NULL;
+
+static xmlParserInputPtr
+xsltprocExternalEntityLoader(const char *URL, const char *ID,
+                             xmlParserCtxtPtr ctxt) {
+    xmlParserInputPtr ret;
+    warningSAXFunc warning = NULL;
+
+    int i;
+    const char *lastsegment = URL;
+    const char *iter = URL;
+
+    if (nbpaths > 0) {
+        while (*iter != 0) {
+            if (*iter == '/')
+                lastsegment = iter + 1;
+            iter++;
+        }
+    }
+
+    if ((ctxt != NULL) && (ctxt->sax != NULL)) {
+        warning = ctxt->sax->warning;
+        ctxt->sax->warning = NULL;
+    }
+
+    if (defaultEntityLoader != NULL) {
+        ret = defaultEntityLoader(URL, ID, ctxt);
+        if (ret != NULL) {
+            if (warning != NULL)
+                ctxt->sax->warning = warning;
+            if (load_trace) {
+                fprintf \
+                        (stderr,
+                         "Loaded URL=\"%s\" ID=\"%s\"\n",
+                         URL ? URL : "(null)",
+                         ID ? ID : "(null)");
+            }
+            return(ret);
+        }
+    }
+    for (i = 0;i < nbpaths;i++) {
+        xmlChar *newURL;
+
+        newURL = xmlStrdup((const xmlChar *) paths[i]);
+        newURL = xmlStrcat(newURL, (const xmlChar *) "/");
+        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 (load_trace) {
+                    fprintf \
+                        (stderr,
+                         "Loaded URL=\"%s\" ID=\"%s\"\n",
+                         newURL,
+                         ID ? ID : "(null)");
+                }
+                xmlFree(newURL);
+                return(ret);
+            }
+            xmlFree(newURL);
+        }
+    }
+    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);
+}
+
+/*
+ * Internal timing routines to remove the necessity to have unix-specific
+ * function calls
+ */
+#ifndef HAVE_GETTIMEOFDAY
+#ifdef HAVE_SYS_TIMEB_H
+#ifdef HAVE_SYS_TIME_H
+#ifdef HAVE_FTIME
+
+int
+my_gettimeofday(struct timeval *tvp, void *tzp)
+{
+        struct timeb timebuffer;
+
+        ftime(&timebuffer);
+        if (tvp) {
+                tvp->tv_sec = timebuffer.time;
+                tvp->tv_usec = timebuffer.millitm * 1000L;
+        }
+        return (0);
+}
+#define HAVE_GETTIMEOFDAY 1
+#define gettimeofday my_gettimeofday
+
+#endif /* HAVE_FTIME */
+#endif /* HAVE_SYS_TIME_H */
+#endif /* HAVE_SYS_TIMEB_H */
+#endif /* !HAVE_GETTIMEOFDAY */
+
+#if defined(HAVE_GETTIMEOFDAY)
+static struct timeval begin, endtime;
+/*
+ * startTimer: call where you want to start timing
+ */
+static void startTimer(void)
+{
+    gettimeofday(&begin,NULL);
+}
+/*
+ * endTimer: call where you want to stop timing and to print out a
+ *           message about the timing performed; format is a printf
+ *           type argument
+ */
+static void endTimer(const char *format, ...)
+{
+    long msec;
+    va_list ap;
+
+    gettimeofday(&endtime, NULL);
+    msec = endtime.tv_sec - begin.tv_sec;
+    msec *= 1000;
+    msec += (endtime.tv_usec - begin.tv_usec) / 1000;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, format);
+    vfprintf(stderr,format,ap);
+    va_end(ap);
+
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#elif defined(HAVE_TIME_H)
+/*
+ * No gettimeofday function, so we have to make do with calling clock.
+ * This is obviously less accurate, but there's little we can do about
+ * that.
+ */
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 100
+#endif
+
+clock_t begin, endtime;
+static void startTimer(void)
+{
+    begin=clock();
+}
+static void endTimer(char *format, ...)
+{
+    long msec;
+    va_list ap;
+
+    endtime=clock();
+    msec = ((endtime-begin) * 1000) / CLOCKS_PER_SEC;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    va_start(ap, format);
+    vfprintf(stderr,format,ap);
+    va_end(ap);
+    fprintf(stderr, " took %ld ms\n", msec);
+}
+#else
+/*
+ * We don't have a gettimeofday or time.h, so we just don't do timing
+ */
+static void startTimer(void)
+{
+  /*
+   * Do nothing
+   */
+}
+static void endTimer(char *format, ...)
+{
+  /*
+   * We cannot do anything because we don't have a timing function
+   */
+#ifdef HAVE_STDARG_H
+    va_start(ap, format);
+    vfprintf(stderr,format,ap);
+    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
+
+/*
+ * xsltSubtreeCheck:
+ *
+ * allow writes only on a subtree specified on the command line
+ */
+static int
+xsltSubtreeCheck(xsltSecurityPrefsPtr sec ATTRIBUTE_UNUSED,
+                  xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED,
+                  const char *value ATTRIBUTE_UNUSED) {
+    int len, ret;
+
+    if (writesubtree == NULL)
+        return(0);
+    if (value == NULL)
+        return(-1);
+
+    len = xmlStrlen(BAD_CAST writesubtree);
+    ret = xmlStrncmp(BAD_CAST writesubtree, BAD_CAST value, len);
+    if (ret == 0)
+        return(1);
+    return(0);
+}
+
+static void
+xsltProcess(xmlDocPtr doc, xsltStylesheetPtr cur, const char *filename) {
+    xmlDocPtr res;
+    xsltTransformContextPtr ctxt;
+
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (xinclude) {
+        int ret;
+
+        if (timing)
+            startTimer();
+#if LIBXML_VERSION >= 20603
+        ret = xmlXIncludeProcessFlags(doc, XSLT_PARSE_OPTIONS);
+#else
+        ret = xmlXIncludeProcess(doc);
+#endif
+        if (timing) {
+            endTimer("XInclude processing %s", filename);
+        }
+
+        if (ret < 0) {
+            errorno = 6;
+            return;
+        }
+    }
+#endif
+    if (timing)
+        startTimer();
+    if (output == NULL) {
+        if (repeat) {
+            int j;
+
+            for (j = 1; j < repeat; j++) {
+                res = xsltApplyStylesheet(cur, doc, params);
+                xmlFreeDoc(res);
+                xmlFreeDoc(doc);
+#ifdef LIBXML_HTML_ENABLED
+                if (html)
+                    doc = htmlReadFile(filename, encoding, options);
+                else
+#endif
+                    doc = xmlReadFile(filename, encoding, options);
+            }
+        }
+        ctxt = xsltNewTransformContext(cur, doc);
+        if (ctxt == NULL)
+            return;
+        xsltSetCtxtParseOptions(ctxt, options);
+#ifdef LIBXML_XINCLUDE_ENABLED
+        if (xinclude)
+            ctxt->xinclude = 1;
+#endif
+        if (profile) {
+            res = xsltApplyStylesheetUser(cur, doc, params, NULL,
+                                          stderr, ctxt);
+        } else {
+            res = xsltApplyStylesheetUser(cur, doc, params, NULL,
+                                          NULL, ctxt);
+        }
+        if (ctxt->state == XSLT_STATE_ERROR)
+            errorno = 9;
+        else if (ctxt->state == XSLT_STATE_STOPPED)
+            errorno = 10;
+        xsltFreeTransformContext(ctxt);
+        if (timing) {
+            if (repeat)
+                endTimer("Applying stylesheet %d times", repeat);
+            else
+                endTimer("Applying stylesheet");
+        }
+        xmlFreeDoc(doc);
+        if (res == NULL) {
+            fprintf(stderr, "no result for %s\n", filename);
+            return;
+        }
+        if (noout) {
+            xmlFreeDoc(res);
+            return;
+        }
+#ifdef LIBXML_DEBUG_ENABLED
+        if (debug)
+            xmlDebugDumpDocument(stdout, res);
+        else {
+#endif
+            if (cur->methodURI == NULL) {
+                if (timing)
+                    startTimer();
+                xsltSaveResultToFile(stdout, res, cur);
+                if (timing)
+                    endTimer("Saving result");
+            } else {
+                if (xmlStrEqual
+                    (cur->method, (const xmlChar *) "xhtml")) {
+                    fprintf(stderr, "non standard output xhtml\n");
+                    if (timing)
+                        startTimer();
+                    xsltSaveResultToFile(stdout, res, cur);
+                    if (timing)
+                        endTimer("Saving result");
+                } else {
+                    fprintf(stderr,
+                            "Unsupported non standard output %s\n",
+                            cur->method);
+                    errorno = 7;
+                }
+            }
+#ifdef LIBXML_DEBUG_ENABLED
+        }
+#endif
+
+        xmlFreeDoc(res);
+    } else {
+        int ret;
+        ctxt = xsltNewTransformContext(cur, doc);
+        if (ctxt == NULL)
+            return;
+        xsltSetCtxtParseOptions(ctxt, options);
+#ifdef LIBXML_XINCLUDE_ENABLED
+        if (xinclude)
+            ctxt->xinclude = 1;
+#endif
+        ctxt->maxTemplateDepth = xsltMaxDepth;
+        ctxt->maxTemplateVars = xsltMaxVars;
+
+        if (profile) {
+            ret = xsltRunStylesheetUser(cur, doc, params, output,
+                                        NULL, NULL, stderr, ctxt);
+        } else {
+            ret = xsltRunStylesheetUser(cur, doc, params, output,
+                                        NULL, NULL, NULL, ctxt);
+        }
+        if (ret == -1)
+            errorno = 11;
+        else if (ctxt->state == XSLT_STATE_ERROR)
+            errorno = 9;
+        else if (ctxt->state == XSLT_STATE_STOPPED)
+            errorno = 10;
+        xsltFreeTransformContext(ctxt);
+        if (timing)
+            endTimer("Running stylesheet and saving result");
+        xmlFreeDoc(doc);
+    }
+}
+
+static void usage(const char *name) {
+    printf("Usage: %s [options] stylesheet file [file ...]\n", name);
+    printf("   Options:\n");
+    printf("\t--version or -V: show the version of libxml and libxslt used\n");
+    printf("\t--verbose or -v: show logs of what's happening\n");
+    printf("\t--output file or -o file: save to a given file\n");
+    printf("\t--timing: display the time used\n");
+    printf("\t--repeat: run the transformation 20 times\n");
+#ifdef LIBXML_DEBUG_ENABLED
+    printf("\t--debug: dump the tree of the result instead\n");
+#endif
+    printf("\t--dumpextensions: dump the registered extension elements and functions to stdout\n");
+    printf("\t--novalid skip the DTD loading phase\n");
+    printf("\t--nodtdattr do not default attributes from the DTD\n");
+    printf("\t--noout: do not dump the result\n");
+    printf("\t--maxdepth val : increase the maximum depth (default %d)\n", xsltMaxDepth);
+    printf("\t--maxvars val : increase the maximum variables (default %d)\n", xsltMaxVars);
+    printf("\t--maxparserdepth val : increase the maximum parser depth\n");
+#ifdef LIBXML_HTML_ENABLED
+    printf("\t--html: the input document is(are) an HTML file(s)\n");
+#endif
+    printf("\t--encoding: the input document character encoding\n");
+    printf("\t--param name value : pass a (parameter,value) pair\n");
+    printf("\t       value is an UTF8 XPath expression.\n");
+    printf("\t       string values must be quoted like \"'string'\"\n or");
+    printf("\t       use stringparam to avoid it\n");
+    printf("\t--stringparam name value : pass a (parameter, UTF8 string value) pair\n");
+    printf("\t--path 'paths': provide a set of paths for resources\n");
+    printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
+    printf("\t--nowrite : refuse to write to any file or resource\n");
+    printf("\t--nomkdir : refuse to create directories\n");
+    printf("\t--writesubtree path : allow file write only with the path subtree\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         file:///etc/xml/catalog are activated by default\n");
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+    printf("\t--xinclude : do XInclude processing on document input\n");
+    printf("\t--xincludestyle : do XInclude processing on stylesheets\n");
+#endif
+    printf("\t--load-trace : print trace of all external entites loaded\n");
+    printf("\t--profile or --norman : dump profiling informations \n");
+    printf("\nProject libxslt home page: http://xmlsoft.org/XSLT/\n");
+    printf("To report bugs and get help: http://xmlsoft.org/XSLT/bugs.html\n");
+}
+
+int
+main(int argc, char **argv)
+{
+    int i;
+    xsltStylesheetPtr cur = NULL;
+    xmlDocPtr doc, style;
+    xsltSecurityPrefsPtr sec = NULL;
+
+    if (argc <= 1) {
+        usage(argv[0]);
+        return (1);
+    }
+
+    xmlInitMemory();
+
+    LIBXML_TEST_VERSION
+
+    sec = xsltNewSecurityPrefs();
+    xsltSetDefaultSecurityPrefs(sec);
+    defaultEntityLoader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);
+
+    for (i = 1; i < argc; i++) {
+        if (!strcmp(argv[i], "-"))
+            break;
+
+        if (argv[i][0] != '-')
+            continue;
+#ifdef LIBXML_DEBUG_ENABLED
+        if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
+            debug++;
+        } else
+#endif
+        if ((!strcmp(argv[i], "-v")) ||
+                (!strcmp(argv[i], "-verbose")) ||
+                (!strcmp(argv[i], "--verbose"))) {
+            xsltSetGenericDebugFunc(stderr, NULL);
+        } else if ((!strcmp(argv[i], "-o")) ||
+                   (!strcmp(argv[i], "-output")) ||
+                   (!strcmp(argv[i], "--output"))) {
+            i++;
+#if defined(WIN32) || defined (__CYGWIN__)
+            output = xmlCanonicPath(argv[i]);
+            if (output == NULL)
+#endif
+                output = (char *) xmlStrdup((xmlChar *) argv[i]);
+        } else if ((!strcmp(argv[i], "-V")) ||
+                   (!strcmp(argv[i], "-version")) ||
+                   (!strcmp(argv[i], "--version"))) {
+            printf("Using libxml %s, libxslt %s and libexslt %s\n",
+                   xmlParserVersion, xsltEngineVersion, exsltLibraryVersion);
+            printf
+    ("xsltproc was compiled against libxml %d, libxslt %d and libexslt %d\n",
+                 LIBXML_VERSION, LIBXSLT_VERSION, LIBEXSLT_VERSION);
+            printf("libxslt %d was compiled against libxml %d\n",
+                   xsltLibxsltVersion, xsltLibxmlVersion);
+            printf("libexslt %d was compiled against libxml %d\n",
+                   exsltLibexsltVersion, exsltLibxmlVersion);
+        } else if ((!strcmp(argv[i], "-repeat"))
+                   || (!strcmp(argv[i], "--repeat"))) {
+            if (repeat == 0)
+                repeat = 20;
+            else
+                repeat = 100;
+        } else if ((!strcmp(argv[i], "-novalid")) ||
+                   (!strcmp(argv[i], "--novalid"))) {
+            novalid++;
+        } else if ((!strcmp(argv[i], "-nodtdattr")) ||
+                   (!strcmp(argv[i], "--nodtdattr"))) {
+            nodtdattr++;
+        } else if ((!strcmp(argv[i], "-noout")) ||
+                   (!strcmp(argv[i], "--noout"))) {
+            noout++;
+#ifdef LIBXML_HTML_ENABLED
+        } else if ((!strcmp(argv[i], "-html")) ||
+                   (!strcmp(argv[i], "--html"))) {
+            html++;
+#endif
+        } else if ((!strcmp(argv[i], "-encoding")) ||
+                   (!strcmp(argv[i], "--encoding"))) {
+            encoding = argv[++i];
+        } else if ((!strcmp(argv[i], "-timing")) ||
+                   (!strcmp(argv[i], "--timing"))) {
+            timing++;
+        } else if ((!strcmp(argv[i], "-profile")) ||
+                   (!strcmp(argv[i], "--profile"))) {
+            profile++;
+        } else if ((!strcmp(argv[i], "-nodict")) ||
+                   (!strcmp(argv[i], "--nodict"))) {
+            nodict++;
+        } else if ((!strcmp(argv[i], "-norman")) ||
+                   (!strcmp(argv[i], "--norman"))) {
+            profile++;
+        } else if ((!strcmp(argv[i], "-nonet")) ||
+                   (!strcmp(argv[i], "--nonet"))) {
+            defaultEntityLoader = xmlNoNetExternalEntityLoader;
+        } else if ((!strcmp(argv[i], "-nowrite")) ||
+                   (!strcmp(argv[i], "--nowrite"))) {
+            xsltSetSecurityPrefs(sec, XSLT_SECPREF_WRITE_FILE,
+                                 xsltSecurityForbid);
+            xsltSetSecurityPrefs(sec, XSLT_SECPREF_CREATE_DIRECTORY,
+                                 xsltSecurityForbid);
+            xsltSetSecurityPrefs(sec, XSLT_SECPREF_WRITE_NETWORK,
+                                 xsltSecurityForbid);
+        } else if ((!strcmp(argv[i], "-nomkdir")) ||
+                   (!strcmp(argv[i], "--nomkdir"))) {
+            xsltSetSecurityPrefs(sec, XSLT_SECPREF_CREATE_DIRECTORY,
+                                 xsltSecurityForbid);
+        } else if ((!strcmp(argv[i], "-writesubtree")) ||
+                   (!strcmp(argv[i], "--writesubtree"))) {
+            i++;
+            writesubtree = argv[i];
+            xsltSetSecurityPrefs(sec, XSLT_SECPREF_WRITE_FILE,
+                                 xsltSubtreeCheck);
+        } else if ((!strcmp(argv[i], "-path")) ||
+                   (!strcmp(argv[i], "--path"))) {
+            i++;
+            parsePath(BAD_CAST argv[i]);
+#ifdef LIBXML_CATALOG_ENABLED
+        } else if ((!strcmp(argv[i], "-catalogs")) ||
+                   (!strcmp(argv[i], "--catalogs"))) {
+            const char *catalogs;
+
+            catalogs = getenv("SGML_CATALOG_FILES");
+            if (catalogs == NULL) {
+                fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
+            } else {
+                xmlLoadCatalogs(catalogs);
+            }
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+        } else if ((!strcmp(argv[i], "-xinclude")) ||
+                   (!strcmp(argv[i], "--xinclude"))) {
+            xinclude++;
+        } else if ((!strcmp(argv[i], "-xincludestyle")) ||
+                   (!strcmp(argv[i], "--xincludestyle"))) {
+            xincludestyle++;
+            xsltSetXIncludeDefault(1);
+#endif
+        } else if ((!strcmp(argv[i], "-load-trace")) ||
+                   (!strcmp(argv[i], "--load-trace"))) {
+            load_trace++;
+        } else if ((!strcmp(argv[i], "-param")) ||
+                   (!strcmp(argv[i], "--param"))) {
+            i++;
+            params[nbparams++] = argv[i++];
+            params[nbparams++] = argv[i];
+            if (nbparams >= MAX_PARAMETERS) {
+                fprintf(stderr, "too many params increase MAX_PARAMETERS \n");
+                return (2);
+            }
+        } else if ((!strcmp(argv[i], "-stringparam")) ||
+                   (!strcmp(argv[i], "--stringparam"))) {
+            const xmlChar *string;
+            xmlChar *value;
+
+            i++;
+            params[nbparams++] = argv[i++];
+            string = (const xmlChar *) argv[i];
+            if (xmlStrchr(string, '"')) {
+                if (xmlStrchr(string, '\'')) {
+                    fprintf(stderr,
+                    "stringparam contains both quote and double-quotes !\n");
+                    return(8);
+                }
+                value = xmlStrdup((const xmlChar *)"'");
+                value = xmlStrcat(value, string);
+                value = xmlStrcat(value, (const xmlChar *)"'");
+            } else {
+                value = xmlStrdup((const xmlChar *)"\"");
+                value = xmlStrcat(value, string);
+                value = xmlStrcat(value, (const xmlChar *)"\"");
+            }
+
+            params[nbparams++] = (const char *) value;
+            strparams[nbstrparams++] = value;
+            if (nbparams >= MAX_PARAMETERS) {
+                fprintf(stderr, "too many params increase MAX_PARAMETERS \n");
+                return (2);
+            }
+        } else if ((!strcmp(argv[i], "-maxdepth")) ||
+                   (!strcmp(argv[i], "--maxdepth"))) {
+            int value;
+
+            i++;
+            if (sscanf(argv[i], "%d", &value) == 1) {
+                if (value > 0)
+                    xsltMaxDepth = value;
+            }
+        } else if ((!strcmp(argv[i], "-maxvars")) ||
+                   (!strcmp(argv[i], "--maxvars"))) {
+            int value;
+
+            i++;
+            if (sscanf(argv[i], "%d", &value) == 1) {
+                if (value > 0)
+                    xsltMaxVars = value;
+            }
+        } else if ((!strcmp(argv[i], "-maxparserdepth")) ||
+                   (!strcmp(argv[i], "--maxparserdepth"))) {
+            int value;
+
+            i++;
+            if (sscanf(argv[i], "%d", &value) == 1) {
+                if (value > 0)
+                    xmlParserMaxDepth = value;
+            }
+        } else if ((!strcmp(argv[i],"-dumpextensions"))||
+                        (!strcmp(argv[i],"--dumpextensions"))) {
+                dumpextensions++;
+        } else {
+            fprintf(stderr, "Unknown option %s\n", argv[i]);
+            usage(argv[0]);
+            return (3);
+        }
+    }
+    params[nbparams] = NULL;
+
+    if (novalid != 0)
+        options = XML_PARSE_NOENT | XML_PARSE_NOCDATA;
+    else if (nodtdattr)
+        options = XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_NOCDATA;
+    if (nodict != 0)
+        options |= XML_PARSE_NODICT;
+
+    /*
+     * Register the EXSLT extensions and the test module
+     */
+    exsltRegisterAll();
+    xsltRegisterTestModule();
+
+    if (dumpextensions)
+        xsltDebugDumpExtensions(NULL);
+
+    for (i = 1; i < argc; i++) {
+        if ((!strcmp(argv[i], "-maxdepth")) ||
+            (!strcmp(argv[i], "--maxdepth"))) {
+            i++;
+            continue;
+        } else if ((!strcmp(argv[i], "-maxparserdepth")) ||
+            (!strcmp(argv[i], "--maxparserdepth"))) {
+            i++;
+            continue;
+        } else if ((!strcmp(argv[i], "-o")) ||
+                   (!strcmp(argv[i], "-output")) ||
+                   (!strcmp(argv[i], "--output"))) {
+            i++;
+            continue;
+        } else if ((!strcmp(argv[i], "-encoding")) ||
+                   (!strcmp(argv[i], "--encoding"))) {
+            i++;
+            continue;
+        } else if ((!strcmp(argv[i], "-writesubtree")) ||
+                   (!strcmp(argv[i], "--writesubtree"))) {
+            i++;
+            continue;
+        } else if ((!strcmp(argv[i], "-path")) ||
+                   (!strcmp(argv[i], "--path"))) {
+            i++;
+            continue;
+        }
+        if ((!strcmp(argv[i], "-param")) || (!strcmp(argv[i], "--param"))) {
+            i += 2;
+            continue;
+        }
+        if ((!strcmp(argv[i], "-stringparam")) ||
+            (!strcmp(argv[i], "--stringparam"))) {
+            i += 2;
+            continue;
+        }
+        if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
+            if (timing)
+                startTimer();
+            style = xmlReadFile((const char *) argv[i], NULL, options);
+            if (timing)
+                endTimer("Parsing stylesheet %s", argv[i]);
+#ifdef LIBXML_XINCLUDE_ENABLED
+            if (xincludestyle) {
+                if (style != NULL) {
+                    if (timing)
+                        startTimer();
+#if LIBXML_VERSION >= 20603
+                    xmlXIncludeProcessFlags(style, XSLT_PARSE_OPTIONS);
+#else
+                    xmlXIncludeProcess(style);
+#endif
+                    if (timing) {
+                        endTimer("XInclude processing %s", argv[i]);
+                    }
+                }
+            }
+#endif
+            if (style == NULL) {
+                fprintf(stderr,  "cannot parse %s\n", argv[i]);
+                cur = NULL;
+                errorno = 4;
+            } else {
+                cur = xsltLoadStylesheetPI(style);
+                if (cur != NULL) {
+                    /* it is an embedded stylesheet */
+                    xsltProcess(style, cur, argv[i]);
+                    xsltFreeStylesheet(cur);
+                    cur = NULL;
+                    goto done;
+                }
+                cur = xsltParseStylesheetDoc(style);
+                if (cur != NULL) {
+                    if (cur->errors != 0) {
+                        errorno = 5;
+                        goto done;
+                    }
+                    i++;
+                } else {
+                    xmlFreeDoc(style);
+                    errorno = 5;
+                    goto done;
+                }
+            }
+            break;
+
+        }
+    }
+
+
+    if ((cur != NULL) && (cur->errors == 0)) {
+        for (; i < argc; i++) {
+            doc = NULL;
+            if (timing)
+                startTimer();
+#ifdef LIBXML_HTML_ENABLED
+            if (html)
+                doc = htmlReadFile(argv[i], encoding, options);
+            else
+#endif
+                doc = xmlReadFile(argv[i], encoding, options);
+            if (doc == NULL) {
+                fprintf(stderr, "unable to parse %s\n", argv[i]);
+                errorno = 6;
+                continue;
+            }
+            if (timing)
+                endTimer("Parsing document %s", argv[i]);
+            xsltProcess(doc, cur, argv[i]);
+        }
+    }
+done:
+    if (cur != NULL)
+        xsltFreeStylesheet(cur);
+    for (i = 0;i < nbstrparams;i++)
+        xmlFree(strparams[i]);
+    if (output != NULL)
+        xmlFree(output);
+    xsltFreeSecurityPrefs(sec);
+    xsltCleanupGlobals();
+    xmlCleanupParser();
+    xmlMemoryDump();
+    return(errorno);
+}
+