Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdewebdev@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1367 insertions, 0 deletions

diff --git a/kxsldbg/kxsldbgpart/libxsldbg/xsldbg.cpp b/kxsldbg/kxsldbgpart/libxsldbg/xsldbg.cpp
new file mode 100644
index 00000000..2afdb828
--- /dev/null
+++ b/kxsldbg/kxsldbgpart/libxsldbg/xsldbg.cpp
@@ -0,0 +1,1367 @@
+
+/***************************************************************************
+                          xsldbg.c  -  description
+                             -------------------
+    begin                : Sun Sep 16 2001
+    copyright            : (C) 2001 by Keith Isdale
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+/*
+ * Based on file xsltproc.c
+ *
+ * by  Daniel Veillard 
+ *     [email protected]
+ *
+ *  xsltproc.c is part of libxslt
+ *
+ *
+ */
+
+/* Justin's port version - do not merge into core!!! */
+#define RISCOS_PORT_VERSION "2.01"
+
+#include <kurl.h>
+#include <kdebug.h>
+#include "xsldbg.h"
+#include "debug.h"
+#include "options.h"
+#include "utils.h"
+#include "files.h"
+#include "breakpoint.h"
+#include "debugXSL.h"
+
+#include <libxml/xmlerror.h>
+#include "xsldbgmsg.h"
+#include "xsldbgthread.h"       /* for getThreadStatus */
+#ifdef HAVE_READLINE
+#  include <readline/readline.h>
+#  ifdef HAVE_HISTORY
+#     include <readline/history.h>
+#   endif
+#endif
+
+/* need to setup catch of SIGINT */
+#include <signal.h>
+
+/* needed by printTemplateNames */
+#include <libxslt/transform.h>
+
+/* standard includes from xsltproc*/
+#include <libxslt/xslt.h>
+#include <libexslt/exslt.h>
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/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/xmlerror.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/xmlIO.h>
+#ifdef LIBXML_DOCB_ENABLED
+#include <libxml/DOCBparser.h>
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+
+#include <libxml/catalog.h>
+#include <libxml/parserInternals.h>
+
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/extensions.h>
+#include <libexslt/exsltconfig.h>
+
+#include <kcmdlineargs.h> 
+#include <kglobal.h>
+#include <qfile.h>
+
+#ifdef WIN32
+#ifdef _MSC_VER
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#define gettimeofday(p1,p2)
+#define HAVE_TIME_H
+#include <time.h>
+#define HAVE_STDARG_H
+#include <stdarg.h>
+#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 */
+
+#ifndef HAVE_STAT
+#  ifdef HAVE__STAT
+
+/* MS C library seems to define stat and _stat. The definition
+      *         is identical. Still, mapping them to each other causes a warning. */
+#    ifndef _MSC_VER
+#      define stat(x,y) _stat(x,y)
+#    endif
+#    define HAVE_STAT
+#  endif
+#endif
+
+#ifdef __riscos
+
+/* Global definition of our program name on invocation.
+   This is required such that we can invoke ourselves for processing
+   search or help messages where our executable does not exist on the
+   current run path */
+char *xsldbgCommand = NULL;
+#endif
+
+xmlSAXHandler mySAXhdlr;
+
+FILE *errorFile = NULL; /* we'll set this just before starting debugger */
+
+xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
+                                               const char *ID,
+                                               xmlParserCtxtPtr ctxt);
+
+/* -----------------------------------------
+   Private function declarations for xsldbg.c
+ -------------------------------------------*/
+
+/**
+ * xsldbgInit:
+ * 
+ * Returns 1 if able to allocate memory needed by xsldbg
+ *         0 otherwise
+ */
+int xsldbgInit(void);
+
+
+/**
+ * xsldbgFree:
+ *
+ * Free memory used by xsldbg
+ */
+void xsldbgFree(void);
+
+
+/**
+ * printTemplates:
+ * @style : valid as parsed my xsldbg
+ * @doc :    "    "   "     "    "
+ *  
+ * print out list of template names
+ */
+void printTemplates(xsltStylesheetPtr style, xmlDocPtr doc);
+
+
+/**
+ * catchSigInt:
+ * @value : not used
+ *
+ * Recover from a signal(SIGINT), exit if needed
+ */
+void catchSigInt(int value);
+
+
+/**
+ * catchSigTerm:
+ * @value : not used
+ *
+ * Clean up and exit
+ */
+void
+  catchSigTerm(int value);
+
+/**
+ * xsldbgGenericErrorFunc:
+ * @ctx:  Is Valid
+ * @msg:  Is valid
+ * @...:  other parameters to use
+ * 
+ * Handles print output from xsldbg and passes it to the application if 
+ *  running as a thread otherwise send to stderr
+ */
+void
+  xsldbgGenericErrorFunc(void *ctx, const char *msg, ...);
+
+xmlEntityPtr (*oldGetEntity)( void * user_data, const xmlChar * name);
+
+static xmlEntityPtr xsldbgGetEntity( void * user_data, const xmlChar * name)
+{
+    xmlEntityPtr ent = NULL;
+    if (oldGetEntity){
+	ent =  (oldGetEntity)(user_data, name);
+	if (ent)
+	    filesEntityRef(ent, ent->children, ent->last);
+    }
+    return ent;
+}
+
+/* ------------------------------------- 
+   End private functions
+   ---------------------------------------*/
+
+
+/*
+ * Internal timing routines to remove the necessity to have unix-specific
+ * function calls
+ */
+
+#if defined(HAVE_GETTIMEOFDAY)
+static struct timeval begin, end;
+
+/*
+ * 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 QString& message)
+{
+    long msec;
+
+    gettimeofday(&end, NULL);
+    msec = end.tv_sec - begin.tv_sec;
+    msec *= 1000;
+    msec += (end.tv_usec - begin.tv_usec) / 1000;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    /* Display the time taken to complete this task */
+    xsldbgGenericErrorFunc(i18n("%1 took %2 ms to complete.\n").arg(message).arg(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.
+ */
+
+clock_t begin, end;
+static void
+startTimer(void)
+{
+    begin = clock();
+}
+static void
+endTimer(const QString& message)
+{
+    long msec;
+
+    end = clock();
+    msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
+
+#ifndef HAVE_STDARG_H
+#error "endTimer required stdarg functions"
+#endif
+    /* Display the time taken to complete this task */
+    xsldbgGenericErrorFunc(i18n("%1 took %2 ms to complete.\n").arg(message).arg(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(const QString& message)
+{
+    /*
+     * We can not do anything because we don't have a timing function
+     */
+#ifdef HAVE_STDARG_H
+    /* Display the time taken to complete this task */
+    xsldbgGenericErrorFunc(i18n("%1 took %2 ms to complete.\n"),arg(message).arg(msec));
+#else
+    /* We don't have gettimeofday, time or stdarg.h, what crazy world is
+     * this ?!
+     */
+#endif
+}
+#endif
+
+static void
+xsltProcess(xmlDocPtr doc, xsltStylesheetPtr cur)
+{
+
+    xmlDocPtr res;
+    const char *params[8 * 2 + 2];
+    int bytesWritten = -1;
+    int nbparams = 0;
+    int paramIndex;
+    parameterItemPtr paramItem;
+
+    /* Copy the parameters accross for libxslt */
+    for (paramIndex = 0;
+         paramIndex < arrayListCount(optionsGetParamItemList());
+         paramIndex++) {
+        paramItem = (parameterItemPtr)arrayListGet(optionsGetParamItemList(), paramIndex);
+        if (paramItem) {
+            params[nbparams] = (char *) paramItem->name;
+            params[nbparams + 1] = (char *) paramItem->value;
+            nbparams += 2;
+        }
+    }
+
+    params[nbparams] = NULL;
+
+#ifdef LIBXML_XINCLUDE_ENABLED
+    if (optionsGetIntOption(OPTIONS_XINCLUDE)) {
+        if (optionsGetIntOption(OPTIONS_TIMING))
+            startTimer();
+        xmlXIncludeProcess(doc);
+        if (optionsGetIntOption(OPTIONS_TIMING)) {
+	    /* Display the time taken to do XInclude processing */
+            endTimer(i18n("XInclude processing %1.").arg((const char*)optionsGetStringOption(OPTIONS_DATA_FILE_NAME)));
+        }
+    }
+#endif
+    if (optionsGetIntOption(OPTIONS_TIMING) ||
+        optionsGetIntOption(OPTIONS_PROFILING))
+        startTimer();
+    if ((optionsGetStringOption(OPTIONS_OUTPUT_FILE_NAME) == NULL) ||
+        optionsGetIntOption(OPTIONS_SHELL)) {
+        if (optionsGetIntOption(OPTIONS_REPEAT)) {
+            int j;
+
+            for (j = 1; j < optionsGetIntOption(OPTIONS_REPEAT); j++) {
+                res = xsltApplyStylesheet(cur, doc, params);
+                xmlFreeDoc(res);
+                doc = xsldbgLoadXmlData();
+            }
+        }
+        if (optionsGetIntOption(OPTIONS_PROFILING)) {
+            if (terminalIO != NULL)
+                res = xsltProfileStylesheet(cur, doc, params, terminalIO);
+            else if ((optionsGetStringOption(OPTIONS_OUTPUT_FILE_NAME) ==
+                      NULL) || (getThreadStatus() != XSLDBG_MSG_THREAD_RUN)
+                     || (filesTempFileName(1) == NULL))
+                res = xsltProfileStylesheet(cur, doc, params, stderr);
+            else {
+                /* We now have to output to using notify using 
+                 * temp file #1 */
+                FILE *tempFile = fopen(filesTempFileName(1), "w");
+
+                if (tempFile != NULL) {
+                    res =
+                        xsltProfileStylesheet(cur, doc, params, tempFile);
+                    fclose(tempFile);
+                    /* send the data to application */
+                    notifyXsldbgApp(XSLDBG_MSG_FILEOUT,
+                                    filesTempFileName(1));
+                } else {
+		     xsldbgGenericErrorFunc(i18n("Error: Unable to write temporary results to %1.\n").arg(filesTempFileName(1)));
+                    res = xsltProfileStylesheet(cur, doc, params, stderr);
+                }
+            }
+        } else {
+            res = xsltApplyStylesheet(cur, doc, params);
+        }
+        if (optionsGetIntOption(OPTIONS_PROFILING)) {
+            if (optionsGetIntOption(OPTIONS_REPEAT))
+		/* Display how long it took to apply stylesheet */
+                endTimer(i18n("Applying stylesheet %n time", "Applying stylesheet %n times", optionsGetIntOption(OPTIONS_REPEAT)));
+            else
+		/* Display how long it took to apply stylesheet */
+                endTimer(i18n("Applying stylesheet"));
+        }
+        if (res == NULL) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+            xsltGenericError(xsltGenericErrorContext, "Error: Transformation did not complete writing to file %s\n",
+                             optionsGetStringOption
+                             (OPTIONS_OUTPUT_FILE_NAME));
+#endif
+            return;
+        }
+        if (!optionsGetIntOption(OPTIONS_OUT)) {
+            xmlFreeDoc(res);
+            return;
+        }
+#ifdef LIBXML_DEBUG_ENABLED
+        if (optionsGetIntOption(OPTIONS_DEBUG)) {
+	    if (xslDebugStatus != DEBUG_RUN_RESTART){
+		if (terminalIO != NULL)
+		    xmlDebugDumpDocument(terminalIO, res);
+		else if ((optionsGetStringOption(OPTIONS_OUTPUT_FILE_NAME) ==
+			    NULL) || (getThreadStatus() != XSLDBG_MSG_THREAD_RUN)
+			|| (filesTempFileName(1) == NULL))
+		    xmlDebugDumpDocument(stdout, res);
+		else {
+		    FILE *tempFile = fopen(filesTempFileName(1), "w");
+
+		    if (tempFile) {
+			bytesWritten = 0; // flag that we have writen at least zero bytes
+			xmlDebugDumpDocument(tempFile, res);
+			fclose(tempFile);
+			/* send the data to application */
+			notifyXsldbgApp(XSLDBG_MSG_FILEOUT,
+				filesTempFileName(1));
+		    } else {
+			 xsldbgGenericErrorFunc(i18n("Error: Unable to write temporary results to %1.\n").arg(filesTempFileName(1)));
+			xmlDebugDumpDocument(stdout, res);
+		    }
+
+		}
+	    }
+        } else {
+#endif
+	    if (xslDebugStatus != DEBUG_RUN_RESTART){
+		if (cur->methodURI == NULL) {
+		    if (optionsGetIntOption(OPTIONS_TIMING))
+			startTimer();
+		    if (xslDebugStatus != DEBUG_QUIT) {
+			if (terminalIO != NULL)
+			    bytesWritten = xsltSaveResultToFile(terminalIO, res, cur);
+			else if (optionsGetStringOption
+				(OPTIONS_OUTPUT_FILE_NAME) == NULL)
+			    bytesWritten = xsltSaveResultToFile(stdout, res, cur);
+			else{
+			    bytesWritten = xsltSaveResultToFilename((const char *)
+				    optionsGetStringOption
+				    (OPTIONS_OUTPUT_FILE_NAME),
+				    res, cur, 0);
+		    }
+		    }
+		    if (optionsGetIntOption(OPTIONS_TIMING))
+			/* Indicate how long it took to save to file */
+			endTimer(i18n("Saving result"));
+		} else {
+		    if (xmlStrEqual(cur->method, (const xmlChar *) "xhtml")) {
+			xsldbgGenericErrorFunc(i18n("Warning: Generating non-standard output XHTML.\n"));
+			if (optionsGetIntOption(OPTIONS_TIMING))
+			    startTimer();
+			if (terminalIO != NULL)
+			    bytesWritten = xsltSaveResultToFile(terminalIO, res, cur);
+			else if (optionsGetStringOption
+				(OPTIONS_OUTPUT_FILE_NAME) == NULL)
+			    bytesWritten = xsltSaveResultToFile(stdout, res, cur);
+			else
+			    bytesWritten = xsltSaveResultToFilename((const char *)
+				    optionsGetStringOption
+				    (OPTIONS_OUTPUT_FILE_NAME),
+				    res, cur, 0);
+			if (optionsGetIntOption(OPTIONS_TIMING))
+			    /* Indicate how long it took to save to file */
+			    endTimer(i18n("Saving result"));
+		    } else {
+			xsldbgGenericErrorFunc(i18n("Warning: Unsupported, non-standard output method %1.\n").arg(xsldbgText(cur->method)));
+		    }
+		}
+	    }
+#ifdef LIBXML_DEBUG_ENABLED
+        }
+#endif
+
+        xmlFreeDoc(res);
+    } else {
+        xsltTransformContextPtr userCtxt = xsltNewTransformContext(cur, doc);
+        if (userCtxt){
+        bytesWritten = xsltRunStylesheetUser(cur, doc, params,
+                          (char *)optionsGetStringOption(OPTIONS_OUTPUT_FILE_NAME),
+                          NULL, NULL, NULL, userCtxt);
+        if (optionsGetIntOption(OPTIONS_TIMING))
+            endTimer(i18n("Running stylesheet and saving result"));
+        xsltFreeTransformContext(userCtxt);
+        }else{
+	    xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
+        }
+    }
+    if ((xslDebugStatus != DEBUG_RUN_RESTART) && (bytesWritten == -1))
+	xsldbgGenericErrorFunc(i18n("Error: Unable to save results of transformation to file %1.\n").arg(xsldbgText(optionsGetStringOption(OPTIONS_OUTPUT_FILE_NAME)))); 
+}
+
+int
+xsldbgMain(int argc, char **argv)
+{
+    Q_UNUSED(argc);
+    Q_UNUSED(argv);
+    int i=0, result = 1, noFilesFound = 0;
+    xsltStylesheetPtr cur = NULL;
+    xmlChar *expandedName;      /* contains file name with path expansion if any */
+
+    /* in some cases we always want to bring up a command prompt */
+    int showPrompt;
+
+    /* the xml document we're processing */
+    xmlDocPtr doc;
+    
+    KCmdLineArgs *args = 0;
+    if (getThreadStatus() == XSLDBG_MSG_THREAD_NOTUSED)
+	args = KCmdLineArgs::parsedArgs();
+
+    errorFile = stderr;
+    
+
+    if (args){
+	QString langChoice = args->getOption("lang");
+	if (KGlobal::locale() && !langChoice.isEmpty() && result)
+	    KGlobal::locale()->setLanguage(langChoice);
+    }
+
+#ifdef __riscos
+    /* Remember our invocation command such that we may call ourselves */
+    xsldbgCommand = argv[0];
+#endif
+
+    xmlInitMemory();
+
+
+    LIBXML_TEST_VERSION xmlLineNumbersDefault(1);
+
+    if (!xsldbgInit()) {
+	   xsldbgGenericErrorFunc(i18n("Fatal error: Aborting debugger due to an unrecoverable error.\n"));
+        xsldbgFree();
+        xsltCleanupGlobals();
+        xmlCleanupParser();
+        xmlMemoryDump();
+        return (1);
+    }
+
+
+    if (args){
+	for (i = 0; i < args->count(); i++) {
+	    if (!result)
+		break;
+
+	    if (args->arg(i)[0] != '-') {
+		expandedName = filesExpandName((const xmlChar*)args->arg(i));
+		if (!expandedName) {
+		    result = 0;
+		    break;
+		}
+		switch (noFilesFound) {
+		    case 0:
+			optionsSetStringOption(OPTIONS_SOURCE_FILE_NAME,
+				expandedName);
+			noFilesFound++;
+			break;
+		    case 1:
+			optionsSetStringOption(OPTIONS_DATA_FILE_NAME,
+				expandedName);
+			noFilesFound++;
+			break;
+
+		    default:
+			xsldbgGenericErrorFunc(i18n("Error: Too many file names supplied via command line.\n"));
+			result = 0;
+		}
+		xmlFree(expandedName);
+		continue;
+	    }
+	}  	
+
+
+	 // Handle boolean options
+	for (int optionID = OPTIONS_FIRST_BOOL_OPTIONID; optionID < OPTIONS_LAST_BOOL_OPTIONID; optionID++){
+	    if (optionsGetOptionName(OptionTypeEnum(optionID))){
+		if (args->isSet((char *)optionsGetOptionName(OptionTypeEnum(optionID))))
+		    optionsSetIntOption(OptionTypeEnum
+			    (optionID), 1);
+		else
+		    optionsSetIntOption(OptionTypeEnum(optionID), 0);
+	    }
+	}
+
+	// No extra arguments go straight to the shell? 
+	if (args->count() == 0)
+	    result = optionsSetIntOption(OPTIONS_SHELL, 1);
+
+	// Disable net access? 
+	if (!args->isSet("net")){
+	    char noNetCmd[] = {"nonet 1"}; 
+	    xslDbgShellSetOption((xmlChar*)noNetCmd);
+	}
+    }
+   
+    if (getThreadStatus() != XSLDBG_MSG_THREAD_NOTUSED){
+	result = optionsSetIntOption(OPTIONS_SHELL, 1);
+    }
+    /* copy the volitile options over to xsldbg */
+    optionsCopyVolitleOptions();
+    
+    /*
+     * shell interraction
+     */
+    if (!optionsGetIntOption(OPTIONS_SHELL)) {  /* excecute stylesheet (ie no debugging) */
+        xslDebugStatus = DEBUG_NONE;
+    } else {
+        xslDebugStatus = DEBUG_STOP;
+        xsltGenericError(xsltGenericErrorContext, "XSLDBG %s\n", VERSION);
+    }
+
+    if (optionsGetIntOption(OPTIONS_VALID))
+	xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
+    else
+	xmlLoadExtDtdDefaultValue = 0;
+
+
+    if (args){
+	if (args->isSet("verbose") && result)
+	    xsltSetGenericDebugFunc(stderr, NULL);
+
+	QCString outFile = args->getOption("output");
+	if (!outFile.isEmpty() && result)
+	    result = xslDbgShellOutput((const xmlChar *)QFile::encodeName(outFile).data());
+
+	QCString maxDepth = args->getOption("maxdepth");
+	if (!maxDepth.isEmpty() && result){
+	    bool OK;
+	    int value = maxDepth.toInt(&OK);
+	    if (OK && (value> 0))
+		xsltMaxDepth = value;
+	}
+
+	if (args->isSet("repeat") && result){
+	    if (optionsGetIntOption(OPTIONS_REPEAT) == 0)
+		optionsSetIntOption(OPTIONS_REPEAT, 20);
+	    else
+		optionsSetIntOption(OPTIONS_REPEAT, 100);
+	}
+
+	QCStringList xslParams(args->getOptionList("param"));
+	QCStringList::iterator it;
+	QCString param, paramName, paramValue;
+	int separatorIdx;
+	bool paramOK;
+	for ( it = xslParams.begin(); it != xslParams.end(); ++it){
+	    param = (*it);
+	    paramOK = true;
+	    separatorIdx = param.find(':');
+	    if (separatorIdx > 0){
+		paramName = param.left((uint)separatorIdx);
+		paramValue = param.mid((uint)separatorIdx + 1);
+		if (!paramName.isEmpty() && !paramValue.isEmpty()){
+		    if (arrayListCount(optionsGetParamItemList()) <= 31) {
+			arrayListAdd(optionsGetParamItemList(), optionsParamItemNew((const xmlChar*)paramName.data(), (const xmlChar*)paramValue.data()));
+		    }else{
+			xsldbgGenericErrorFunc(i18n("Warning: Too many libxslt parameters provided via the command line option --param.\n"));
+		    }
+		}else{
+		    paramOK = false;
+		}
+	    }else{
+		paramOK = false;
+	    }
+	    if (!paramOK)
+		xsldbgGenericErrorFunc(i18n("Error: Argument \"%1\" to --param is not in the format <name>:<value>.\n").arg(param.data()));
+	}
+
+	QCString cdPath = args->getOption("cd");
+	if (!cdPath.isEmpty() && result)
+	    result = changeDir((const xmlChar *)QFile::encodeName(cdPath).data());
+
+    }
+
+    if (!result) {
+	KCmdLineArgs::usage(); 
+        xsldbgFree();
+        return (1);
+    }
+
+
+    /*
+     * * Replace entities with their content.
+     */
+    xmlSubstituteEntitiesDefault(1);
+
+    /*
+     * * Register the EXSLT extensions and the test module
+     */
+    exsltRegisterAll();
+    xsltRegisterTestModule();
+
+    
+
+    debugGotControl(0);
+    while (xslDebugStatus != DEBUG_QUIT) {
+	xsldbgReachedFirstTemplate = false;
+	/* don't force xsldbg to show command prompt */
+	showPrompt = 0;
+	cur = NULL;
+	doc = NULL;
+	arrayListEmpty(filesEntityList());
+	xsltSetXIncludeDefault(optionsGetIntOption(OPTIONS_XINCLUDE));
+
+	/* copy the volitile options over to xsldbg */
+	optionsCopyVolitleOptions();
+
+	/* choose where error messages/xsldbg output get sent to */
+	if (optionsGetIntOption(OPTIONS_STDOUT))
+	    errorFile = stdout;
+	else
+	    errorFile = stderr;
+
+	filesLoadCatalogs();
+
+	if (optionsGetIntOption(OPTIONS_SHELL)) {
+	    debugGotControl(0);
+	    xsldbgGenericErrorFunc(i18n("\nStarting stylesheet\n\n"));
+	    if (optionsGetIntOption(OPTIONS_TRACE) == TRACE_OFF)
+		xslDebugStatus = DEBUG_STOP;    /* stop as soon as possible */
+	}
+
+	if ((optionsGetStringOption(OPTIONS_SOURCE_FILE_NAME) == NULL) ||
+		(optionsGetStringOption(OPTIONS_DATA_FILE_NAME) == NULL)) {
+	    /* at least on file name has not been set */
+	    /*goto a xsldbg command prompt */
+	    showPrompt = 1;
+	    if (optionsGetStringOption(OPTIONS_SOURCE_FILE_NAME) == NULL)
+		xsldbgGenericErrorFunc(i18n("Error: No XSLT source file supplied.\n"));
+
+	    if (optionsGetStringOption(OPTIONS_DATA_FILE_NAME) == NULL) {
+		xsldbgGenericErrorFunc(i18n("Error: No XML data file supplied.\n"));
+	    }
+
+	} else {
+	    filesLoadXmlFile(NULL, FILES_SOURCEFILE_TYPE);
+	    cur = filesGetStylesheet();
+	    if ((cur == NULL) || (cur->errors != 0)) {
+		/*goto a xsldbg command prompt */
+		showPrompt = 1;
+		if (xslDebugStatus == DEBUG_NONE) {
+		    xslDebugStatus = DEBUG_QUIT;        /* panic !! */
+		    result = 0;
+		}
+	    }
+	}
+
+	if (showPrompt == 0) {
+	    filesLoadXmlFile(NULL, FILES_XMLFILE_TYPE);
+	    doc = filesGetMainDoc();
+	    if (doc == NULL) {
+		if (xslDebugStatus == DEBUG_NONE) {
+		    xslDebugStatus = DEBUG_QUIT;        /* panic !! */
+		    result = 0;
+		} else {
+		    /*goto a xsldbg command prompt */
+		    showPrompt = 1;
+		}
+	    } else {
+		if (xslDebugStatus != DEBUG_QUIT) {
+		    xsltProcess(doc, cur);
+		    result = 1;
+		}
+	    }
+
+	    if (optionsGetIntOption(OPTIONS_SHELL) && (showPrompt == 0)) {
+		if ((xslDebugStatus != DEBUG_QUIT)
+			&& !debugGotControl(-1)) {
+		    xsldbgGenericErrorFunc(i18n("\nDebugger never received control.\n"));
+		    /*goto a xsldbg command prompt */
+		    showPrompt = 1;
+		    xslDebugStatus = DEBUG_STOP;
+		} else {
+		    xsldbgGenericErrorFunc(i18n("\nFinished stylesheet\n\032\032\n"));
+		    {
+			/* handle trace execution */
+			int trace = optionsGetIntOption(OPTIONS_TRACE);
+
+			switch (trace) {
+			    case TRACE_OFF:
+				/* no trace of execution */
+				break;
+
+			    case TRACE_ON:
+				/* tell xsldbg to stop tracing next time we get here */
+				optionsSetIntOption(OPTIONS_TRACE,
+					TRACE_RUNNING);
+				xslDebugStatus = DEBUG_TRACE;
+				break;
+
+			    case TRACE_RUNNING:
+				/* turn off tracing */
+				xslDebugStatus = DEBUG_CONT;
+				optionsSetIntOption(OPTIONS_TRACE,
+					TRACE_OFF);
+				break;
+			}
+		    }
+		    if (!optionsGetIntOption(OPTIONS_AUTORESTART) && (xslDebugStatus != DEBUG_RUN_RESTART)){ 
+			/* pass control to user they won't be able to do much
+			   other than add breakpoints, quit, run, continue */
+			debugXSLBreak((xmlNodePtr) cur->doc, (xmlNodePtr) doc,
+				NULL, NULL);
+		    }
+		}
+	    } else {
+		/* request to execute stylesheet only  so we're done */
+		xslDebugStatus = DEBUG_QUIT;
+	    }
+	} else {
+	    /* Some sort of problem loading source file has occured. Quit? */
+	    if (xslDebugStatus == DEBUG_NONE) {
+		xslDebugStatus = DEBUG_QUIT;    /* Panic!! */
+		result = 0;
+	    } else {
+		/*goto a xsldbg command prompt */
+		showPrompt = 1;
+	    }
+	}
+
+	if (showPrompt && optionsGetIntOption(OPTIONS_SHELL)) {
+	    xmlDocPtr tempDoc = xmlNewDoc((xmlChar *) "1.0");
+	    xmlNodePtr tempNode =
+		xmlNewNode(NULL, (xmlChar *) "xsldbg_default_node");
+	    if (!tempDoc || !tempNode) {
+		xsldbgFree();
+		return (1);
+	    }
+	    xmlAddChild((xmlNodePtr) tempDoc, tempNode);
+
+	    xsldbgGenericErrorFunc(i18n("Going to the command shell; not all xsldbg commands will work as not all needed have been loaded.\n"));
+	    xslDebugStatus = DEBUG_STOP;
+	    if ((cur == NULL) && (doc == NULL)) {
+		/*no doc's loaded */
+		debugXSLBreak(tempNode, tempNode, NULL, NULL);
+	    } else if ((cur != NULL) && (doc == NULL)) {
+		/* stylesheet is loaded */
+		debugXSLBreak((xmlNodePtr) cur->doc, tempNode, NULL, NULL);
+	    } else if ((cur == NULL) && (doc != NULL)) {
+		/* xml doc is loaded */
+		debugXSLBreak(tempNode, (xmlNodePtr) doc, NULL, NULL);
+	    } else {
+		/* unexpected problem, both docs are loaded */
+		debugXSLBreak((xmlNodePtr) cur->doc, (xmlNodePtr) doc,
+			NULL, NULL);
+	    }
+	    xmlFreeDoc(tempDoc);
+	} else if (showPrompt && !optionsGetIntOption(OPTIONS_SHELL)) {
+	    xslDebugStatus = DEBUG_QUIT;
+	    result = 0;         /* panic */
+	}
+
+	if (optionsGetIntOption(OPTIONS_SHELL)) {
+	    /* force a refesh of both stlesheet and xml data */
+	    filesFreeXmlFile(FILES_SOURCEFILE_TYPE);
+	    filesFreeXmlFile(FILES_XMLFILE_TYPE);
+	}
+    }
+
+    if (!result) {
+	xsldbgGenericErrorFunc(i18n("Fatal error: Aborting debugger due to an unrecoverable error.\n"));
+    }
+    xsldbgFree();
+    xsltCleanupGlobals();
+    xmlCleanupParser();
+    xmlMemoryDump();
+    return !result;
+}
+
+/**
+ * xsldbgLoadStylesheet:
+ *
+ * Load the stylesheet and return it 
+ *
+ * Returns The stylesheet after reloading it if successful
+ *         NULL otherwise
+ */
+xsltStylesheetPtr
+xsldbgLoadStylesheet()
+{
+    xsltStylesheetPtr cur = NULL;
+    xmlDocPtr style;
+
+    if (optionsGetIntOption(OPTIONS_TIMING))
+        startTimer();
+    style = xmlParseFile((const char *) optionsGetStringOption(OPTIONS_SOURCE_FILE_NAME));
+    if (optionsGetIntOption(OPTIONS_TIMING))
+        endTimer(i18n("Parsing stylesheet %1").arg((const char*)optionsGetStringOption(OPTIONS_SOURCE_FILE_NAME)));
+    if (style == NULL) {
+        xsldbgGenericErrorFunc(i18n("Error: Cannot parse file %1.\n").arg(xsldbgUrl(optionsGetStringOption(OPTIONS_SOURCE_FILE_NAME))));
+        cur = NULL;
+        if (!optionsGetIntOption(OPTIONS_SHELL)) {
+            xsldbgGenericErrorFunc(i18n("Fatal error: Aborting debugger due to an unrecoverable error.\n"));
+            xslDebugStatus = DEBUG_QUIT;
+        } else {
+            xsltGenericError(xsltGenericErrorContext, "\n");
+            xslDebugStatus = DEBUG_STOP;
+        }
+    } else {
+        cur = xsltLoadStylesheetPI(style);
+        if (cur != NULL) {
+            /* it is an embedded stylesheet */
+            xsltProcess(style, cur);
+            xsltFreeStylesheet(cur);
+        } else {
+            cur = xsltParseStylesheetDoc(style);
+            if (cur != NULL) {
+                if (cur->indent == 1)
+                    xmlIndentTreeOutput = 1;
+                else
+                    xmlIndentTreeOutput = 0;
+            } else {
+                xmlFreeDoc(style);
+            }
+        }
+    }
+    return cur;
+}
+
+
+
+/**
+ * xsldbgLoadXmlData:
+ *
+ * Load the xml data file and return it  
+ *
+ * Returns The data file after reloading it if successful
+ *         NULL otherwise
+ */
+xmlDocPtr
+xsldbgLoadXmlData(void)
+{
+    xmlDocPtr doc = NULL;
+    xmlSAXHandler mySAXHandler;
+    doc = NULL;
+
+    xmlSAXVersion(&mySAXHandler,2);
+    oldGetEntity = mySAXHandler.getEntity;
+    mySAXHandler.getEntity = xsldbgGetEntity;
+
+    if (optionsGetIntOption(OPTIONS_TIMING))
+        startTimer();
+#ifdef LIBXML_HTML_ENABLED
+    if (optionsGetIntOption(OPTIONS_HTML))
+        doc = htmlParseFile((char *)
+                            optionsGetStringOption(OPTIONS_DATA_FILE_NAME),
+                            NULL);
+    else
+#endif
+#ifdef LIBXML_DOCB_ENABLED
+    if (optionsGetIntOption(OPTIONS_DOCBOOK))
+        doc = docbParseFile((char *)
+                            optionsGetStringOption(OPTIONS_DATA_FILE_NAME),
+                            NULL);
+    else
+#endif
+
+#if LIBXML_VERSION >= 20600
+        doc = xmlSAXParseFile(&mySAXHandler,
+			     (char *) optionsGetStringOption(OPTIONS_DATA_FILE_NAME), 0);
+#else
+        doc = xmlParseFile((char *) optionsGetStringOption(OPTIONS_DATA_FILE_NAME));
+#endif
+    if (doc == NULL) {
+        xsldbgGenericErrorFunc(i18n("Error: Unable to parse file %1.\n").arg(xsldbgUrl(optionsGetStringOption(OPTIONS_DATA_FILE_NAME))));
+        if (!optionsGetIntOption(OPTIONS_SHELL)) {
+            xsldbgGenericErrorFunc(i18n("Fatal error: Aborting debugger due to an unrecoverable error.\n"));
+            xslDebugStatus = DEBUG_QUIT;
+        } else {
+            xsltGenericError(xsltGenericErrorContext, "\n");
+            xslDebugStatus = DEBUG_STOP;
+        }
+    } else if (optionsGetIntOption(OPTIONS_TIMING))
+        endTimer(QString("Parsing document %1").arg(xsldbgUrl(optionsGetStringOption(OPTIONS_DATA_FILE_NAME))).utf8().data());
+
+    return doc;
+}
+
+
+/**
+ * xsldbgLoadXmlTemporary:
+ * @path: The name of temporary file to load 
+ *
+ * Load the temporary data file and return it 
+ *
+ * Returns The temporary file after reloading it if successful,
+ *         NULL otherwise
+ */
+xmlDocPtr
+xsldbgLoadXmlTemporary(const xmlChar * path)
+{
+    xmlDocPtr doc = NULL;
+    doc = NULL;
+
+    if (optionsGetIntOption(OPTIONS_TIMING))
+        startTimer();
+#ifdef LIBXML_HTML_ENABLED
+    if (optionsGetIntOption(OPTIONS_HTML))
+        doc = htmlParseFile((char *) path, NULL);
+    else
+#endif
+#ifdef LIBXML_DOCB_ENABLED
+    if (optionsGetIntOption(OPTIONS_DOCBOOK))
+        doc = docbParseFile((char *) path, NULL);
+    else
+#endif
+        doc = xmlSAXParseFile(&mySAXhdlr, (char *) path, 0);
+    if (doc == NULL) {
+        xsldbgGenericErrorFunc(i18n("Error: Unable to parse file %1.\n").arg(xsldbgUrl(path)));
+    }
+
+    if (optionsGetIntOption(OPTIONS_TIMING)
+        && (xslDebugStatus != DEBUG_QUIT)) {
+        endTimer(QString("Parsing document %1").arg(xsldbgUrl(path)));
+    }
+    return doc;
+}
+
+/**
+ * printTemplates:
+ * @style : valid as parsed my xsldbg
+ * @doc :    "    "   "     "    "
+ *  
+ * print out list of template names
+ */
+void
+printTemplates(xsltStylesheetPtr style, xmlDocPtr doc)
+{
+    xsltTransformContextPtr ctxt = xsltNewTransformContext(style, doc);
+
+    if (ctxt) {
+        /* don't be verbose when printing out template names */
+        xslDbgShellPrintTemplateNames(ctxt, NULL, NULL, 0, 0);
+    } else {
+        xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
+    }
+}
+
+#ifdef WIN32
+
+/* For the windows world we capture the control event */
+BOOL WINAPI
+handler_routine(DWORD dwCtrlType)
+{
+
+    switch (dwCtrlType) {
+        case CTRL_C_EVENT:
+        case CTRL_BREAK_EVENT:
+        case CTRL_CLOSE_EVENT:
+            catchSigInt(SIGINT);
+            break;
+
+        case CTRL_LOGOFF_EVENT:
+        case CTRL_SHUTDOWN_EVENT:
+            xsldbgFree();
+            exit(1);
+            break;
+
+        default:
+            printf("Error: Unknown control event\n");
+            break;
+    }
+
+    return (true);
+}
+
+#endif
+
+#if LIBXML_VERSION >= 2006000
+/* libxml/ handlers */
+void xsldbgStructErrorHandler(void * userData, xmlErrorPtr error)
+{
+    if (error && error->message && (error->level >= 0) && (error->level <= 4)){
+	if (getThreadStatus() != XSLDBG_MSG_THREAD_RUN){
+	    static const char *msgPrefix[4 + 1] = {"", "warning :", "error:", "fatal:"};
+	    if (error->file)
+		xsltGenericError(xsltGenericErrorContext, "%s%s in file \"%s\" line %d", msgPrefix[error->level], error->message, error->file, error->line);
+	    else
+		xsltGenericError(xsltGenericErrorContext, "%s%s", msgPrefix[error->level], error->message);
+
+	}else{
+	    xsltGenericError(xsltGenericErrorContext,"Struct error handler");
+	    notifyXsldbgApp(XSLDBG_MSG_ERROR_MESSAGE, error);
+	}
+    }
+}
+
+void xsldbgSAXErrorHandler(void * ctx, const char * msg, ...)
+{
+    if (ctx)
+	xsldbgStructErrorHandler(0, ((xmlParserCtxtPtr)ctx)->lastError);
+}
+
+void xsldbgSAXWarningHandler(void * ctx, const char * msg, ...)
+{
+    if (ctx)
+	xsldbgStructErrorHandler(0, ((xmlParserCtxtPtr)ctx)->lastError);
+}
+
+#endif
+
+/**
+ * catchSigInt:
+ * @value : not used
+ *
+ * Recover from a signal(SIGINT), exit if needed
+ */
+void
+catchSigInt(int value)
+{
+    Q_UNUSED(value);
+    if ((xslDebugStatus == DEBUG_NONE) || (xsldbgStop == 1) || (xslDebugStatus == DEBUG_STOP)) {
+        xsldbgFree();
+        exit(1);
+    }
+#ifdef __riscos
+    /* re-catch SIGINT - RISC OS resets the handler when the interupt occurs */
+    signal(SIGINT, catchSigInt);
+#endif
+
+    if (xslDebugStatus != DEBUG_STOP) {
+        /* stop running/walking imediately !! */
+        xsldbgStop = 1;
+    }
+}
+
+
+/**
+ * catchSigTerm:
+ * @value : not used
+ *
+ * Clean up and exit
+ */
+void
+catchSigTerm(int value)
+{
+    Q_UNUSED(value);
+    xsldbgFree();
+    exit(1);
+}
+
+
+
+typedef void (*sighandler_t) (int);
+static sighandler_t oldHandler;
+
+static int initialized = 0;
+
+/**
+ * xsldbgInit:
+ * 
+ * Returns 1 if able to allocate memory needed by xsldbg
+ *         0 otherwise
+ */
+int
+xsldbgInit()
+{
+    int result = 0;
+    int xmlVer = 0;
+
+    if (!initialized) {
+        sscanf(xmlParserVersion, "%d", &xmlVer);
+        if (!debugInit()) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+            xsltGenericError(xsltGenericErrorContext,
+                             "Fatal error: Init of debug module failed\n");
+#endif
+            return result;
+        }
+        if (!filesInit()) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+            xsltGenericError(xsltGenericErrorContext,
+                             "Fatal error: Init of files module failed\n");
+#endif
+            return result;
+        }
+
+        if (!optionsInit()) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+            xsltGenericError(xsltGenericErrorContext,
+                             "Fatal error: Init of options module failed\n");
+#endif
+            return result;
+        }
+
+        if (!searchInit()) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+            xsltGenericError(xsltGenericErrorContext,
+                             "Fatal error: Init of search module failed\n");
+#endif
+            return result;
+        }
+
+	
+
+        /* set up the parser */
+        xmlInitParser();
+#if 0
+#if LIBXML_VERSION >= 20600
+     xmlSetGenericErrorFunc(NULL,  NULL);
+     xmlSetStructuredErrorFunc(NULL , (xmlStructuredErrorFunc)xsldbgStructErrorHandler);
+#else
+        xmlSetGenericErrorFunc(0, xsldbgGenericErrorFunc);
+        xsltSetGenericErrorFunc(0, xsldbgGenericErrorFunc);
+#endif    
+#else
+        xmlSetGenericErrorFunc(0, xsldbgGenericErrorFunc);
+        xsltSetGenericErrorFunc(0, xsldbgGenericErrorFunc);
+#endif
+
+	/*
+	 * disable CDATA from being built in the document tree
+	 */
+	xmlDefaultSAXHandlerInit();
+	xmlDefaultSAXHandler.cdataBlock = NULL;
+
+        if (getThreadStatus() != XSLDBG_MSG_THREAD_NOTUSED) {
+            initialized = 1;
+            return 1;           /* this is all we need to do when running as a thread */
+        }
+#ifndef WIN32
+        /* catch SIGINT */
+        oldHandler = signal(SIGINT, catchSigInt);
+#else
+        if (SetConsoleCtrlHandler(handler_routine, true) != true)
+            return result;
+#endif
+
+#ifndef WIN32
+        /* catch SIGTIN tty input available fro child */
+        signal(SIGTERM, catchSigTerm);
+#endif
+        initialized = 1;
+    }
+    return 1;
+}
+
+/**
+ * xsldbgFree:
+ *
+ * Free memory used by xsldbg
+ */
+void
+xsldbgFree()
+{
+    debugFree();
+    filesFree();
+    optionsFree();
+    searchFree();
+#ifndef WIN32
+    if (oldHandler != SIG_ERR)
+        signal(SIGINT, oldHandler);
+#else
+    SetConsoleCtrlHandler(handler_routine, false);
+#endif
+    initialized = 0;
+
+#ifdef HAVE_READLINE
+    /*  rl_free_line_state ();
+      rl_cleanup_after_signal(); */
+#   ifdef HAVE_HISTORY
+       clear_history();
+#   endif    
+#endif
+
+}
+
+
+char msgBuffer[4000];
+
+/**
+ * xsldbgGenericErrorFunc:
+ * @ctx:  Is Valid
+ * @msg:  Is valid
+ * @...:  other parameters to use
+ * 
+ * Handles print output from xsldbg and passes it to the application if 
+ *  running as a thread otherwise send to stderr
+ */
+void
+xsldbgGenericErrorFunc(void *ctx, const char *msg, ...)
+{
+    va_list args;
+    Q_UNUSED(ctx);
+
+    va_start(args, msg);
+    if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
+        vsnprintf(msgBuffer, sizeof(msgBuffer), msg, args);
+
+        notifyTextXsldbgApp(XSLDBG_MSG_TEXTOUT, msgBuffer);
+    } else {
+        xmlChar *encodeResult = NULL;
+
+        vsnprintf(msgBuffer, sizeof(msgBuffer), msg, args);
+        encodeResult = filesEncode((xmlChar *) msgBuffer);
+        if (encodeResult) {
+            fprintf(errorFile, "%s", encodeResult);
+            xmlFree(encodeResult);
+        } else
+            fprintf(errorFile, "%s", msgBuffer);
+    }
+    va_end(args);
+}
+
+void xsldbgGenericErrorFunc(QString const &text)
+{
+    xsldbgGenericErrorFunc(0, "%s", text.utf8().data());
+}
+
+
+QString xsldbgUrl(const char *utf8fUrl)
+{
+    QString tempUrl(utf8fUrl);
+    QString fixedURI;
+    KURL url(tempUrl);
+
+    // May be provided with a URL that only has been encoded and has no protocol prefix ie a local file
+    if ( !tempUrl.startsWith("file:/")  &&  !tempUrl.startsWith("http:/") && !tempUrl.startsWith("ftp:/"))
+	fixedURI = KURL::decode_string(tempUrl);
+    else
+	fixedURI = url.prettyURL();
+
+    return fixedURI;
+}
+
+QString xsldbgUrl(const xmlChar *utf8Url)
+{
+    return xsldbgUrl((const char*)(utf8Url));
+}
+
+QString xsldbgText(const char *utf8Text)
+{
+    return QString::fromUtf8(utf8Text);
+    
+}
+
+QString xsldbgText(const xmlChar *utf8Text)
+{
+    return QString::fromUtf8((const char *)utf8Text);
+}
+