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, 902 insertions, 0 deletions

diff --git a/kxsldbg/kxsldbgpart/libxsldbg/options.cpp b/kxsldbg/kxsldbgpart/libxsldbg/options.cpp
new file mode 100644
index 00000000..9f667eb3
--- /dev/null
+++ b/kxsldbg/kxsldbgpart/libxsldbg/options.cpp
@@ -0,0 +1,902 @@
+
+/***************************************************************************
+                          options.c  -  provide the implementation for option
+                                           related functions
+                             -------------------
+    begin                : Sat Nov 10 2001
+    copyright            : (C) 2001 by Keith Isdale
+    email                : k_isdale@tpg.com.au
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "xsldbg.h"
+#include "xsldbgthread.h"
+#include "options.h"
+#include "arraylist.h"
+#include "xsldbgmsg.h"
+#include "utils.h"
+#include <kglobal.h>
+#include <kstandarddirs.h> 
+#include <qfileinfo.h>
+#include <qstringlist.h>
+
+
+/* keep track of our integer/boolean options */
+static int intOptions[OPTIONS_LAST_INT_OPTIONID - OPTIONS_FIRST_INT_OPTIONID + 1];
+
+/* make use that use of options are safe by only copying
+   critical values from intVolitleOptions just before stylesheet is started
+ */
+int intVolitileOptions[OPTIONS_LAST_INT_OPTIONID - OPTIONS_FIRST_INT_OPTIONID + 1];
+
+/* keep track of our string options */
+static xmlChar *stringOptions[OPTIONS_LAST_STRING_OPTIONID -
+                              OPTIONS_FIRST_STRING_OPTIONID + 1];
+
+/* keep track of our parameters */
+static arrayListPtr parameterList;
+
+/* what are the expressions to be printed out when xsldbg stops */
+static arrayListPtr watchExpressionList;
+
+
+/* the names for our options
+   Items that start with *_ are options that CANNOT be used by the user
+  Once you set an option you need to give a run command to activate
+  new settings */
+const char *optionNames[] = {
+    "xinclude",                 /* Use xinclude during xml parsing */
+    "docbook",                  /* Use of docbook sgml parsing */
+    "timing",                   /* Use of timing */
+    "profile",                  /* Use of profiling */
+    "valid",                    /* Enable file validation */
+    "out",                      /* Enable output to stdout */
+    "html",                     /* Enable the use of html parsing */
+    "debug",                    /* Enable the use of xml tree debugging */
+    "shell",                    /* Enable the use of debugger shell */
+    "gdb",                      /* Run in gdb modem prints more messages */
+    "preferhtml",               /* Prefer html output for search results */
+    "autoencode",               /* Try to use the encoding from the stylesheet */
+    "utf8input",                /* All input from "user" will be in UTF-8 */
+    "stdout",                   /* Print all error messages to  stdout, 
+				 * normally error messages go to stderr */
+    "autorestart",		/* When finishing the debug of a XSLT script 
+				   automaticly restart at the beginning */
+    "verbose",                  /* Be verbose with messages */
+    "repeat",                   /* The number of times to repeat */
+    "*_trace_*",                /* Trace execution */
+    "*_walkspeed_*",            /* How fast do we walk through code */
+    "catalogs",                 /* do we use catalogs in SGML_CATALOG_FILES */
+    "output",                   /* what is the output file name */
+    "source",                   /* The stylesheet source to use */
+    "docspath",                 /* Path of xsldbg's documentation */
+    "catalognames",             /* The names of the catalogs to use when the catalogs option is active */
+    "encoding",                 /* What encoding to use for standard output */
+    "searchresultspath",        /* Where do we store the results of search */
+    "data",                     /* The xml data file to use */
+    NULL                        /* indicate end of list */
+};
+
+
+
+// find the translated help documentation directory
+// langLookupDir code modified from langLookup function in kdebase/khelpcenter/view.cpp 
+
+static QString langLookupDir( const QString &fname )
+{
+    QStringList search;
+
+    // assemble the local search paths
+    QStringList localDoc = KGlobal::dirs()->resourceDirs("html");
+    // also look in each of the KDEDIR paths
+    QString kdeDirs = getenv("KDEDIRS");
+    QStringList kdeDirsList = QStringList::split(":", kdeDirs);
+    if (!kdeDirs.isEmpty() && !kdeDirsList.isEmpty()){
+	for (QStringList::iterator it = kdeDirsList.begin(); it != kdeDirsList.end(); it++)
+          localDoc.append((*it) + "/share/doc/HTML/") ;
+    }
+
+    // look up the different languages
+    for (uint id=0; id < localDoc.count(); id++)
+    {
+        QStringList langs = KGlobal::locale()->languageList();
+        langs.append( "en" );
+        langs.remove( "C" );
+        QStringList::ConstIterator lang;
+        for (lang = langs.begin(); lang != langs.end(); ++lang)
+            search.append(QString("%1%2/%3/%4").arg(localDoc[id]).arg(*lang).arg("xsldbg").arg(fname));
+    }
+
+    // try to locate the file
+    QStringList::Iterator it;
+    for (it = search.begin(); it != search.end(); ++it)
+    {
+	QString baseDir = (*it).left((*it).findRev('/')) ;
+	QFileInfo info(baseDir + "/"+ fname);
+	if (info.exists() && info.isFile() && info.isReadable())
+	  return baseDir;
+    }
+
+    return QString::null;
+}
+
+
+/** 
+ * optionsInit:
+ *
+ * Intialize the options module
+ *
+ * Returns 1 on success,
+ *         0 otherwise
+ */
+int
+optionsInit(void)
+{
+    int optionId;
+
+    for (optionId = 0;
+         optionId <= OPTIONS_LAST_INT_OPTIONID - OPTIONS_FIRST_INT_OPTIONID; optionId++) {
+        intOptions[optionId] = 0;
+        intVolitileOptions[optionId] = 0;
+    }
+
+    for (optionId = 0;
+         optionId <= OPTIONS_LAST_STRING_OPTIONID - OPTIONS_FIRST_STRING_OPTIONID;
+         optionId++) {
+        stringOptions[optionId] = NULL;
+    }
+
+    /* init our parameter list */
+    parameterList = arrayListNew(10, (freeItemFunc) optionsParamItemFree);
+
+    /* setup the docs path */
+    optionsSetStringOption(OPTIONS_DOCS_PATH, (const xmlChar*)(langLookupDir("xsldbghelp.xml").utf8().data()));
+
+    optionsSetIntOption(OPTIONS_TRACE, TRACE_OFF);
+    optionsSetIntOption(OPTIONS_WALK_SPEED, WALKSPEED_STOP);
+    /* always try to use encoding if found */
+    optionsSetIntOption(OPTIONS_AUTOENCODE, 1);
+    /* start up with auto restart turned off */
+    optionsSetIntOption(OPTIONS_AUTORESTART, 0); 	
+    /* start up with gdb mode turned on */
+    optionsSetIntOption(OPTIONS_GDB, 1); 	
+    /* start up with output mode turned on */
+    optionsSetIntOption(OPTIONS_OUT, 1); 	
+    /* start up with validation turned on */
+    optionsSetIntOption(OPTIONS_VALID, 1); 	
+    /* start up with xinclude turned on */
+    optionsSetIntOption(OPTIONS_XINCLUDE, 1); 	
+
+    /* set output default as standard output. Must be changed if not using
+     * xsldbg's command line. Or the tty command is used */
+    optionsSetStringOption(OPTIONS_OUTPUT_FILE_NAME, NULL);
+
+    /* init our list of expressions to watch which are only a list of 
+     strings ie xmlChar*'s  */
+    watchExpressionList = arrayListNew(10, (freeItemFunc) xmlFree);
+
+    return (parameterList && watchExpressionList);
+}
+
+
+/**
+ * optionsFree:
+ *
+ * Free memory used by the options module
+ */
+void
+optionsFree(void)
+{
+    int string_option;
+
+    for (string_option = OPTIONS_FIRST_STRING_OPTIONID;
+         string_option <= OPTIONS_LAST_STRING_OPTIONID; string_option++) {
+        optionsSetStringOption(OptionTypeEnum(string_option), NULL);
+    }
+
+    /* Free up memory used by parameters and watches*/
+    arrayListFree(parameterList);
+    arrayListFree(watchExpressionList);
+    parameterList = NULL;
+    watchExpressionList = NULL;
+}
+
+
+  /**
+   * optionsGetOptionID:
+   * @optionName : A valid option name see documentation for "setoption" 
+   *        command and program usage documentation
+   *
+   * Find the option id for a given option name
+   *
+   * Returns The optionID for @optionName if successful, where  
+   *             OPTIONS_FIRST_OPTIONID<= optionID <= OPTIONS_LAST_OPTIONID,
+   *         otherwise returns -1
+   */
+int
+optionsGetOptionID(xmlChar * optionName)
+{
+    int result = -1;
+    int optID = lookupName(optionName, (xmlChar **) optionNames);
+
+    if (optID >= 0) {
+        result = optID + OPTIONS_FIRST_OPTIONID;
+    }
+
+    return result;
+}
+
+
+  /**
+   * optionsGetOptionName:
+   * @ID : A valid option ID
+   *
+   * Get the name text for an option
+   *
+   * Returns The name of option if @ID is valid, 
+   *         NULL otherwise 
+   */
+const xmlChar *
+optionsGetOptionName(OptionTypeEnum ID)
+{
+    const xmlChar *result = 0;
+    if ( (ID >= OPTIONS_FIRST_OPTIONID) && (ID <= OPTIONS_LAST_OPTIONID)){
+	/* An option ID is always valid at the moment */
+	result = (const xmlChar *) optionNames[ID - OPTIONS_FIRST_OPTIONID];
+    }
+
+    return result;
+}
+
+
+/**
+ * optionsSetIntOption:
+ * @optionType: A valid boolean option
+ * @value: 1 to enable, 0 otherwise
+ *
+ * Set the state of a boolean xsldbg option to @value
+ *
+ * Returns 1 on success,
+ *         0 otherwise
+ */
+int
+optionsSetIntOption(OptionTypeEnum optionType, int value)
+{
+    int type = optionType, result = 1;
+
+    if ((type >= OPTIONS_FIRST_INT_OPTIONID) && (type <= OPTIONS_LAST_INT_OPTIONID)) {
+        /* make sure that use of options are safe by only copying
+         * critical values from intVolitleOptions just before 
+         * stylesheet is started
+         */
+        intVolitileOptions[type - OPTIONS_FIRST_INT_OPTIONID] = value;
+
+        /* the following types must be activated imediately */
+        switch (type) {
+
+            case OPTIONS_TRACE:
+            case OPTIONS_WALK_SPEED:
+            case OPTIONS_GDB:
+                intOptions[type - OPTIONS_FIRST_INT_OPTIONID] = value;
+                break;
+
+            default:
+                break;
+        }
+    } else {
+	if ((type >= OPTIONS_FIRST_OPTIONID) && (type <= OPTIONS_LAST_OPTIONID)){
+	     xsldbgGenericErrorFunc(i18n("Error: Option %1 is not a valid boolean/integer option.\n").arg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
+	}else{
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+	    xsldbgGenericErrorFunc(QString("Error: Invalid arguments for the command %1.\n").arg("setoption"));
+#endif
+	}
+        result = 0;
+    }
+    return result;
+}
+
+
+/**
+ * optionsGetIntOption:
+ * @optionType: A valid boolean option to query
+ *
+ * Return the state of a boolean option
+ *
+ * Returns The state of a boolean xsldbg option. 
+ *         ie 1 for enabled , 0 for disabled
+ */
+int
+optionsGetIntOption(OptionTypeEnum optionType)
+{
+    int type = optionType, result = 0;
+
+    if ((type >= OPTIONS_FIRST_INT_OPTIONID) && (type <= OPTIONS_LAST_INT_OPTIONID)) {
+        result = intOptions[type - OPTIONS_FIRST_INT_OPTIONID];
+    } else {
+	if ((type >= OPTIONS_FIRST_OPTIONID) && (type <= OPTIONS_LAST_OPTIONID)){
+	    xsldbgGenericErrorFunc(i18n("Error: Option %1 is not a valid boolean/integer option.\n").arg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
+	}else{
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+	    xsldbgGenericErrorFunc(QString("Error: Invalid arguments for the command %1.\n").arg("options"));
+#endif
+	}
+    }
+    return result;
+}
+
+
+
+/**
+ * optionsSetStringOption:
+ * @optionType: A valid string option
+ * @value: The value to copy
+ *
+ * Set value for a string xsldbg option to @value. 
+ * Any memory used currently by option @optionType will be freed
+ *
+ * Returns 1 on success,
+ *         0 otherwise
+ */
+int
+optionsSetStringOption(OptionTypeEnum optionType, const xmlChar * value)
+{
+    int type = optionType, result = 0;
+
+    if ((type >= OPTIONS_FIRST_STRING_OPTIONID) &&
+        (type <= OPTIONS_LAST_STRING_OPTIONID)) {
+        int optionId = type - OPTIONS_FIRST_STRING_OPTIONID;
+
+        if (stringOptions[optionId])
+            xmlFree(stringOptions[optionId]);
+        if (value)
+            stringOptions[optionId] =
+                (xmlChar *) xmlMemStrdup((char *) value);
+        else                    /* we want to be able to provide a NULL value */
+            stringOptions[optionId] = NULL;
+        result = 1;
+    } else{
+	if ((type >= OPTIONS_FIRST_OPTIONID) && (type <= OPTIONS_LAST_OPTIONID)){
+	    xsldbgGenericErrorFunc(i18n("Error: Option %1 is not a valid string xsldbg option.\n").arg(xsldbgText(optionNames[type - OPTIONS_LAST_OPTIONID])));
+	}else{
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+	    xsldbgGenericErrorFunc(QString("Error: Invalid arguments for the command %1.\n").arg("setoption"));
+#endif
+	}
+    }
+    return result;
+}
+
+
+/**
+ * optionsGetStringOption:
+ * @optionType: A valid string option 
+ *
+ * Get value for a string xsldbg option of @optionType
+
+ * Returns current option value which may be NULL
+ */
+const xmlChar *
+optionsGetStringOption(OptionTypeEnum optionType)
+{
+    int type = optionType;
+    xmlChar *result = NULL;
+
+    if ((type >= OPTIONS_FIRST_STRING_OPTIONID) &&
+        (type <= OPTIONS_LAST_STRING_OPTIONID)) {
+        int optionId = type - OPTIONS_FIRST_STRING_OPTIONID;
+        result = stringOptions[optionId];
+    } else{
+	if ((type >= OPTIONS_FIRST_OPTIONID) && (type <= OPTIONS_LAST_OPTIONID)){
+	    xsldbgGenericErrorFunc(i18n("Error: Option %1 is not a valid string xsldbg option.\n").arg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
+	}else{
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+	    xsldbgGenericErrorFunc(QString("Error: Invalid arguments for the command %1.\n").arg("options"));
+#endif
+	}
+    }
+    return result;
+}
+
+
+  /**
+   * optionsCopyVolitleOptions:
+   *
+   * Copy volitile options to the working area for xsldbg to be used
+   *   just after xsldbg starts its processing loop
+   */
+void
+optionsCopyVolitleOptions(void)
+{
+    int optionId;
+
+    for (optionId = 0;
+         optionId <= OPTIONS_LAST_INT_OPTIONID - OPTIONS_FIRST_INT_OPTIONID; optionId++) {
+        intOptions[optionId] = intVolitileOptions[optionId];
+    }
+}
+
+
+/**
+ * optionsParamItemNew:
+ * @name: Is valid 
+ * @value: Is valid 
+ *
+ * Create a new libxslt parameter item
+ * Returns non-null if sucessful
+ *         NULL otherwise
+ */
+parameterItemPtr
+optionsParamItemNew(const xmlChar * name, const xmlChar * value)
+{
+    parameterItemPtr result = NULL;
+
+    if (name) {
+        result = (parameterItem *) xmlMalloc(sizeof(parameterItem));
+        if (result) {
+            result->name = (xmlChar *) xmlMemStrdup((char *) name);
+            if (value)
+                result->value = (xmlChar *) xmlMemStrdup((char *) value);
+            else
+                result->value = (xmlChar *) xmlMemStrdup("");
+            result->intValue = -1;
+        }
+    }
+    return result;
+}
+
+
+/**
+ * optionsParamItemFree:
+ * @item: Is valid
+ *
+ * Free memory used by libxslt parameter item @item
+ */
+void
+optionsParamItemFree(parameterItemPtr item)
+{
+    if (item) {
+        if (item->name)
+            xmlFree(item->name);
+        if (item->value)
+            xmlFree(item->value);
+	xmlFree(item);
+    }
+    
+}
+
+
+/**
+ * optionsGetParamItemList:
+ *
+ * Return the list of libxlt parameters
+ *
+ * Returns The list of parameters to provide to libxslt when doing 
+ *           stylesheet transformation if successful
+ *        NULL otherwise
+ */
+arrayListPtr
+optionsGetParamItemList(void)
+{
+    return parameterList;
+}
+
+
+/**
+ * optionsPrintParam:
+ * @paramId: 0 =< paramID < arrayListCount(getParamList())
+ * 
+ * Print parameter information
+ *
+ * Returns 1 on success,
+ *         0 otherwise
+ */
+int
+optionsPrintParam(int paramId)
+{
+    int result = 0;
+    parameterItemPtr paramItem =
+        (parameterItemPtr) arrayListGet(optionsGetParamItemList(),
+                                        paramId);
+
+    if (paramItem && paramItem->name && paramItem->value) {
+        xsldbgGenericErrorFunc(i18n(" Parameter %1 %2=\"%3\"\n").arg(paramId).arg(xsldbgText(paramItem->name)).arg(xsldbgText(paramItem->value)));
+        result = 1;
+    }
+    return result;
+}
+
+
+/**
+ * optionsPrintParamList:
+ *
+ * Prints all items in parameter list
+ *
+ * Returns 1 on success,
+ *         0 otherwise
+ */
+int
+optionsPrintParamList(void)
+{
+    int result = 1;
+    int paramIndex = 0;
+    int itemCount = arrayListCount(optionsGetParamItemList());
+
+    if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
+        if (itemCount > 0) {
+            while (result && (paramIndex < itemCount)) {
+                result = optionsPrintParam(paramIndex++);
+            }
+        }
+    } else {
+        if (itemCount > 0) {
+            xsltGenericError(xsltGenericErrorContext, "\n");
+            while (result && (paramIndex < itemCount)) {
+                result = optionsPrintParam(paramIndex++);
+            }
+        } else
+            xsldbgGenericErrorFunc(i18n("\nNo parameters present.\n"));
+    }
+    return result;
+}
+
+
+  /**
+   * optionsNode:
+   * @optionType : Is valid, option to convert to a xmlNodePtr 
+   *
+   * Convert option into a xmlNodePtr
+   *
+   * Returns the option @optionType as a xmlNodePtr if successful,
+   *          NULL otherwise
+   */
+xmlNodePtr
+optionsNode(OptionTypeEnum optionType)
+{
+    xmlNodePtr node = NULL;
+    char numberBuffer[10];
+    int result = 1;
+
+    numberBuffer[0] = '\0';
+    if (optionType <= OPTIONS_VERBOSE) {
+        /* integer option */
+        node = xmlNewNode(NULL, (xmlChar *) "intoption");
+        if (node) {
+            snprintf(numberBuffer, sizeof(numberBuffer), "%d",
+                     optionsGetIntOption(optionType));
+            result = result && (xmlNewProp
+                                (node, (xmlChar *) "name",
+                                 (xmlChar *) optionNames[optionType -
+                                                         OPTIONS_XINCLUDE])
+                                != NULL);
+            if (result)
+                result = result && (xmlNewProp(node, (xmlChar *) "value",
+                                               (xmlChar *) numberBuffer) !=
+                                    NULL);
+            if (!result) {
+                xmlFreeNode(node);
+                node = NULL;
+            }
+
+        }
+    } else {
+        /* string option */
+        node = xmlNewNode(NULL, (xmlChar *) "stringoption");
+        if (node) {
+            result = result && (xmlNewProp
+                                (node, (xmlChar *) "name",
+                                 (xmlChar *) optionNames[optionType -
+                                                         OPTIONS_XINCLUDE])
+                                != NULL);
+            if (result) {
+                if (optionsGetStringOption(optionType))
+                    result = result && (xmlNewProp
+                                        (node, (xmlChar *) "value",
+                                         optionsGetStringOption
+                                         (optionType)) != NULL);
+                else
+                    result = result && (xmlNewProp
+                                        (node, (xmlChar *) "value",
+                                         (xmlChar *) "") != NULL);
+            }
+
+            if (!result) {
+                xmlFreeNode(node);
+                node = NULL;
+            }
+
+        }
+    }
+    return node;
+}
+
+
+  /**
+   * optionsReadDoc:
+   * @doc : Is valid xsldbg config document, in the format as indicated 
+   *        by config.dtd
+   *
+   * Read options from document provided. 
+   *
+   * Returns 1 if able to read @doc and load options found,
+   *         0 otherwise
+   */
+int
+optionsReadDoc(xmlDocPtr doc)
+{
+    int result = 1;
+    xmlChar *name, *value;
+    int optID;
+    xmlNodePtr node;
+
+    /* very primative search for config node
+     * we skip the DTD and then go straight to the first child of 
+     * config node */
+    if (doc && doc->children->next && doc->children->next->children) {
+        /* find the first configuration option */
+        node = doc->children->next->children;
+        while (node && result) {
+            if (node->type == XML_ELEMENT_NODE) {
+                if (xmlStrCmp(node->name, "intoption") == 0) {
+                    name = xmlGetProp(node, (xmlChar *) "name");
+                    value = xmlGetProp(node, (xmlChar *) "value");
+                    if (name && value && (atoi((char *) value) >= 0)) {
+                        optID = lookupName(name, (xmlChar **) optionNames);
+                        if (optID >= 0)
+                            result =
+                                optionsSetIntOption(OptionTypeEnum(optID + OPTIONS_XINCLUDE),
+                                                    atoi((char *) value));
+                    }
+                    if (name)
+                        xmlFree(name);
+                    if (value)
+                        xmlFree(value);
+                } else if (xmlStrCmp(node->name, "stringoption") == 0) {
+                    name = xmlGetProp(node, (xmlChar *) "name");
+                    value = xmlGetProp(node, (xmlChar *) "value");
+                    if (name && value) {
+                        optID = lookupName(name, (xmlChar **) optionNames);
+                        if (optID >= 0)
+                            result =
+                                optionsSetStringOption(OptionTypeEnum(optID + OPTIONS_XINCLUDE),
+                                                       value);
+                    }
+                    if (name)
+                        xmlFree(name);
+                    if (value)
+                        xmlFree(value);
+                }
+            }
+            node = node->next;
+        }
+    }
+    return result;
+}
+
+
+
+/**
+ * optionsSavetoFile:
+ * @fileName : Must be NON NULL be a local file that can be written to
+ *
+ * Save configuation to file specified
+ *
+ * Returns 1 if able to save options to @fileName,
+ *         0 otherwise
+ */
+int
+optionsSavetoFile(xmlChar * fileName)
+{
+    int result = 0;
+    int optionIndex = 0;
+    xmlDocPtr configDoc;
+    xmlNodePtr rootNode;
+    xmlNodePtr node = NULL;
+
+    if (!fileName) {
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+        xsltGenericError(xsltGenericErrorContext,
+                         "Error: NULL file name provided\n");
+#endif
+        return result;
+    }
+
+    configDoc = xmlNewDoc((xmlChar *) "1.0");
+    rootNode = xmlNewNode(NULL, (xmlChar *) "config");
+
+    if (configDoc && rootNode) {
+        xmlCreateIntSubset(configDoc, (xmlChar *) "config", (xmlChar *)
+                           "-//xsldbg//DTD config XML V1.0//EN",
+                           (xmlChar *) "config.dtd");
+        xmlAddChild((xmlNodePtr) configDoc, rootNode);
+
+        /*now to do the work of adding configuration items */
+        for (optionIndex = OPTIONS_XINCLUDE;
+             optionIndex <= OPTIONS_DATA_FILE_NAME; optionIndex++) {
+            result = 1;
+            if (optionNames[optionIndex - OPTIONS_XINCLUDE][0] == '*')
+                continue;       /* don't save non user options */
+
+            node = optionsNode(OptionTypeEnum(optionIndex));
+            if (node)
+                xmlAddChild(rootNode, node);
+            else {
+                result = 0;
+                break;
+            }
+        }
+
+        if (result) {
+            /* so far so good, now to serialize it to disk */
+            if (!xmlSaveFormatFile((char *) fileName, configDoc, 1))
+                result = 0;
+        }
+
+        xmlFreeDoc(configDoc);
+    } else {
+
+        if (configDoc)
+            xmlFreeDoc(configDoc);
+
+        if (rootNode)
+            xmlFreeNode(rootNode);
+
+    }
+
+    return result;
+}
+
+
+
+  /**
+   * optionsConfigState:
+   * @value : Is valid
+   *
+   * Set/Get the state of configuration loading/saving
+   *
+   * Returns The current/new value of configuration flag. Where
+   *         @value means:
+   *           OPTIONS_CONFIG_READVALUE : No change return current 
+   *               value of read configuration flag
+   *           OPTIONS_CONFIG_WRITING  : Clear flag and return 
+   *               OPTIONS_CONFIG_WRITING which mean configuration 
+   *               file is being written
+   *           OPTIONS_CONFIG_READING : Set flag and return 
+   *               OPTIONS_CONFIG_READING, which means configuration
+   *               file is being read
+   *           OPTIONS_CONFIG_IDLE : We are neither reading or writing 
+   *               configuration and return OPTIONS_CONFIG_IDLE
+   */
+int
+optionsConfigState(OptionsConfigState value)
+{
+    int result = OPTIONS_CONFIG_IDLE;
+
+    /* work around as some compiler refuse to switch on enums */
+    int configValue = value;
+
+    /* hold the current state of configuration reading/writing */
+    static int configState = OPTIONS_CONFIG_IDLE;
+
+    switch (configValue) {
+        case OPTIONS_CONFIG_READVALUE:
+            /* read the current value only */
+            result = configState;
+            break;
+
+        case OPTIONS_CONFIG_READING:
+        case OPTIONS_CONFIG_WRITING:
+            /* update the value */
+            result = configValue;
+            configState = configValue;
+            break;
+    }
+
+    return result;
+}
+
+  /**
+   * optionsAddWatch:
+   * @xPath : A valid xPath to evaluate in a context and 
+   *          has not already been addded
+   *
+   * Add xPath to be evaluated and printed out each time the debugger stops
+   *
+   * Returns 1 if able to add xPath to watched
+   *         0 otherwise
+   */
+  int optionsAddWatch(const xmlChar* xPath)
+{
+  int result = 0;
+  if (!xPath || (xmlStrlen(xPath) == 0)){
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+           xsltGenericError(xsltGenericErrorContext,
+			    "Error: Invalid XPath supplied\n");
+#endif
+  } else{
+    if (optionsGetWatchID(xPath) == 0){
+      xmlChar * nameCopy = xmlStrdup(xPath);
+      if (nameCopy){
+	arrayListAdd(watchExpressionList, nameCopy);
+	result = 1;
+      }
+    }
+  }
+
+  return result;
+}
+
+
+  /** 
+   * optionsGetWatchID:
+   * @xPath : A valid watch expression that has already been added
+   *
+   * Finds the ID of watch expression previously added
+   *
+   * Returns 0 if not found, 
+   *         otherwise returns the ID of watch expression
+   */
+  int optionsGetWatchID(const xmlChar* xPath)
+{
+  int result = 0, counter;
+  xmlChar* watchExpression;
+  if (!xPath){
+#ifdef WITH_XSLDBG_DEBUG_PROCESS
+           xsltGenericError(xsltGenericErrorContext,
+		       "Error: Invalid xPath supplied\n");
+#endif
+  } else{
+    for ( counter = 0; 
+	  counter < arrayListCount(watchExpressionList); 
+				   counter++){
+      watchExpression = (xmlChar*)arrayListGet(watchExpressionList, counter);
+      if (watchExpression){
+	if (xmlStrEqual(xPath, watchExpression)){
+	  result = counter + 1;
+	  break;
+	}
+      }else{
+	break;
+      }
+    }	    
+  }
+ 
+ return result;
+}
+
+  /**
+   * optionsRemoveWatch:
+   * @watchID : A valid watchID as indicated by last optionsPrintWatches
+   * @showWarnings : Print more error messages if 1, 
+   *                  print less if 0
+   *
+   * Remove the watch with given ID from our list of expressions to watch
+   *
+   * Returns 1 if able to remove to watch expression
+   *         0 otherwise
+   */
+  int optionsRemoveWatch(int watchID)
+{
+  return arrayListDelete(watchExpressionList, watchID - 1);
+}
+
+  /**
+   * optionsGetWatchList:
+   * 
+   * Return the current list of expressions to watch
+   *
+   * Return the current list of expressions to watch
+   */
+  arrayListPtr optionsGetWatchList()
+{
+  return watchExpressionList;
+}
+