path: root/kxsldbg/kxsldbgpart/libxsldbg/options.cpp

/***************************************************************************
                          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 <tqfileinfo.h>
#include <tqstringlist.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 tdebase/khelpcenter/view.cpp 

static TQString langLookupDir( const TQString &fname )
{
    TQStringList search;

    // assemble the local search paths
    TQStringList localDoc = KGlobal::dirs()->resourceDirs("html");
    // also look in each of the TDEDIR paths
    TQString kdeDirs = getenv("TDEDIRS");
    TQStringList kdeDirsList = TQStringList::split(":", kdeDirs);
    if (!kdeDirs.isEmpty() && !kdeDirsList.isEmpty()){
	for (TQStringList::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++)
    {
        TQStringList langs = KGlobal::locale()->languageList();
        langs.append( "en" );
        langs.remove( "C" );
        TQStringList::ConstIterator lang;
        for (lang = langs.begin(); lang != langs.end(); ++lang)
            search.append(TQString("%1%2/%3/%4").tqarg(localDoc[id]).tqarg(*lang).tqarg("xsldbg").tqarg(fname));
    }

    // try to locate the file
    TQStringList::Iterator it;
    for (it = search.begin(); it != search.end(); ++it)
    {
	TQString baseDir = (*it).left((*it).findRev('/')) ;
	TQFileInfo info(baseDir + "/"+ fname);
	if (info.exists() && info.isFile() && info.isReadable())
	  return baseDir;
    }

    return TQString();
}


/** 
 * 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").tqarg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
	}else{
#ifdef WITH_XSLDBG_DEBUG_PROCESS
	    xsldbgGenericErrorFunc(TQString("Error: Invalid arguments for the command %1.\n").tqarg("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").tqarg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
	}else{
#ifdef WITH_XSLDBG_DEBUG_PROCESS
	    xsldbgGenericErrorFunc(TQString("Error: Invalid arguments for the command %1.\n").tqarg("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").tqarg(xsldbgText(optionNames[type - OPTIONS_LAST_OPTIONID])));
	}else{
#ifdef WITH_XSLDBG_DEBUG_PROCESS
	    xsldbgGenericErrorFunc(TQString("Error: Invalid arguments for the command %1.\n").tqarg("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").tqarg(xsldbgText(optionNames[type - OPTIONS_FIRST_OPTIONID])));
	}else{
#ifdef WITH_XSLDBG_DEBUG_PROCESS
	    xsldbgGenericErrorFunc(TQString("Error: Invalid arguments for the command %1.\n").tqarg("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").tqarg(paramId).tqarg(xsldbgText(paramItem->name)).tqarg(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 (getThreadtqStatus() == 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;
}