| Index: third_party/libxslt/xsltproc/xsltproc.c
|
| diff --git a/third_party/libxslt/xsltproc/xsltproc.c b/third_party/libxslt/xsltproc/xsltproc.c
|
| deleted file mode 100644
|
| index 35f37e8b9f0e62ef9c4081eb1398a5f19b5f1931..0000000000000000000000000000000000000000
|
| --- a/third_party/libxslt/xsltproc/xsltproc.c
|
| +++ /dev/null
|
| @@ -1,904 +0,0 @@
|
| -/*
|
| - * 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);
|
| -}
|
| -
|
|
|