TDE
/
tdewebdev
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdewebdev
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6927d4436e'
${ noResults }
tdewebdev/kxsldbg/kxsldbgpart/libxsldbg/debugXSL.cpp

2119 lines
65 KiB
Raw Normal View History Unescape

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
15 years ago
/***************************************************************************
debugXSL.c - debugger commands to use
-------------------
begin : Sun Sep 16 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. *
* *
***************************************************************************/
/*
* Orinal file : debugXML.c : This is a set of routines used for
* debugging the tree produced by the XML parser.
*
* New file : shell.c : Debug support version
*
* See Copyright for the status of this software.
*
* Daniel Veillard <daniel@veillard.com>
*
* Permission obtained to modify the LGPL'd code and extend to include breakpoints, inspections of
* stylesheet source, xml data, stylesheet variables
*/
#ifdef WIN32
#include <wtypes.h>
#include <winbase.h> /* needed fort the sleep function */
#endif
#include "xsldbg.h"
#include "files.h"
#include "cmds.h" /* list of command Id's */
#include "debug.h"
#include "debugXSL.h"
#include "options.h"
#include "breakpoint.h"
#include "help.h"
#include <stdlib.h>
#include <libxslt/transform.h> /* needed by source command */
#include <libxslt/xsltInternals.h>
#include <libxml/debugXML.h>
#include <stdio.h>
/* language change support */
#ifdef LOCALE_PREFIX
#include <locale.h>
#endif
#include "xsldbgmsg.h"
#include "xsldbgthread.h" /* for get thread status */
#include "xsldbgio.h"
/* current template being processed */
xsltTemplatePtr rootCopy;
/* how may items have been printed */
int printCount;
/* used to sending small amounts data when xsldbg runs as a thread */
xmlChar messageBuffer[2000];
/* To achieve the same fucntionality of a next command
we first do a step, then a step up */
int nextCommandActive = 0;
/* Do we print the values for watches each time the debugger stops */
int showWatchesActive = 1;
extern FILE *terminalIO;
int xsldbgStop = 0;
int xsldbgValidateBreakpoints = BREAKPOINTS_NEED_VALIDATION;
int xsldbgHasLineNumberFix;
bool xsldbgReachedFirstTemplate = false;
/* valid commands of xslDbgShell */
const char *commandNames[] = {
"help",
"bye",
"exit",
"quit",
"step",
"stepup",
"stepdown",
"next", /* next ie step over template function call*/
"continue",
"run",
"templates",
"where",
"frame",
"stylesheets",
"break",
"showbreak",
"delete",
"enable",
"disable",
"ls",
"dir",
"du",
"cat",
"print",
"pwd",
"dump",
"base",
"globals",
"locals",
/* "cat", already listed */
"source",
"data",
"output", /* output file name */
"cd",
/* file related */
/* "output", already listed */
"entities",
"system",
"public",
"encoding",
"validate",
"load",
"save",
"write",
"free",
/* Operating system related */
"chdir",
"shell",
"tty",
/* libxslt parameter related */
"addparam",
"delparam",
"showparam",
"setoption",
"options",
/* extra options */
"trace",
"walk",
"addwatch",
"delwatch",
"showwatch",
/* searching */
"search",
/*variable value change */
"set",
/* language change */
"lang",
NULL /* Indicate the end of list */
};
/* valid commands of xslShell in there alternative|shorter format */
const char *shortCommandNames[] = {
"h",
"bye",
"exit",
"q", /*quit */
"s", /* step */
"up", /*stepup */
"down", /* stepdown */
"n", /* next ie step over function call*/
"c", /* continue */
"r", /* run */
"t", /* templates */
"w", /* where */
"f",
"style",
"b", /* break */
"show",
"d", /* delete */
"e", /* enabled */
"disable",
"ls",
"dir",
"du",
"cat",
"print",
"pwd",
"dump",
"base",
"globals",
"locals",
/* "cat", already listed */
"source",
"data",
"o", /* output file name */
"cd",
/* file related */
/* "output", already listed */
"ent", /* entities command */
"sys", /* sytem command */
"pub", /* public command */
"encoding",
"validate",
"load",
"save",
"write",
"free",
/* Operating system related */
"chdir",
"shell",
"tty",
/* libxslt parameter related */
"addparam",
"delparam",
"showparam",
"setoption",
"options",
/* extra options/commands */
"trace",
"walk",
"watch",
"delwatch",
"watches",
/* searching */
"search",
/*variable value change */
"set",
/* language change */
"lang",
NULL /* Indicate the end of list */
};
/* some convenient short cuts when using cd command*/
const char *cdShortCuts[] = {
"<<",
">>",
"<-",
"->",
NULL /* indicate end of list */
};
/* what to replace shortcuts with */
const char *cdAlternative[] = {
"preceding-sibling::node()",
"following-sibling::node()",
"ancestor::node()",
"descendant::node()",
NULL /* indicate end of list */
};
/* what enum to use for shortcuts */
enum ShortcutsEnum {
DEBUG_PREV_SIBLING = 200,
DEBUG_NEXT_SIBLING,
DEBUG_ANCESTOR_NODE,
DEBUG_DESCENDANT_NODE
};
#include <libxml/xpathInternals.h>
#include <libxslt/extra.h>
#include <string.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/valid.h>
#include <libxml/debugXML.h>
#include <libxml/HTMLtree.h>
#include <libxml/HTMLparser.h>
/* -----------------------------------------
Private function declarations for debugXSL.c
-------------------------------------------*/
/* xslDbgCd :
* Change directories
* @styleCtxt : current stylesheet context
* @ctxt : current shell context
* @arg : path to change to
* @source : is valid
*
* Returns 1 on success,
* 0 otherwise
*/
int xslDbgCd(xsltTransformContextPtr styleCtxt, xmlShellCtxtPtr ctxt,
xmlChar * arg, xmlNodePtr source);
/**
* xslDbgPrintCallStack:
* @arg : the number of frame to print, NULL if all items
*
* Print all items found on the callStack
*
* Returns 1 on success,
* 0 otherwise
*/
int xslDbgPrintCallStack(const xmlChar * arg);
/**
* xslDbgSleep:
* @delay : the number of microseconds to delay exection by
*
* Delay execution by a specified number of microseconds. On some system
* this will not be at all accurate.
*/
void xslDbgSleep(long delay);
/**
* xslDbgWalkContinue:
*
* Delay execution for time as indicated by OPTION_WALK_SPEED
* Can only be called from within shellPrompt!
* OPTION_WALK_SPEED != WALKSPEED_STOP
*
* Returns 1 if walk is to continue,
* 0 otherwise
*/
int xslDbgWalkContinue(void);
/**
* addBreakPointNode:
* @payload : valid breakPointPtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addBreakPointNode(void *payload, void *data,
xmlChar * name);
/**
* addSourceNode:
* @payload : valid xsltStylesheetPtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addSourceNode(void *payload, void *data,
xmlChar * name);
/**
* addTemplateNode:
* @payload : valid xsltTemplatePtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addTemplateNode(void *payload, void *data,
xmlChar * name);
/**
* addGlobalNode:
* @payload : valid xmlNodePtr of global variable
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addGlobalNode(void *payload, void *data,
xmlChar * name);
/**
* addLocalNode:
* @payload : valid xmlNodePtr of local variable
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addLocalNode(void *payload, void *data,
xmlChar * name);
/**
* addIncludeNode:
* @payload : valid xmlNodePtr of include instuction
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addIncludeNode(void *payload, void *data,
xmlChar * name);
/**
* addCallStackItems:
*
* Convert call stack items into format needed, and add to search dataBase
*/
void
addCallStackItems(void);
/**
* shellPrompt:
* @source: The current stylesheet instruction being executed
* @doc: The current document node being processed
* @filename: Not used
* @input: The function to call to when reading commands from stdio
* @output: Where to put the results
* @styleCtxt: Is valid
*
* Present to the user the xsldbg shell
*/
void shellPrompt(xmlNodePtr source, xmlNodePtr doc,
xmlChar * filename,
xmlShellReadlineFunc input,
FILE * output, xsltTransformContextPtr styleCtxt);
/* -------------------------------------
End private functions
---------------------------------------*/
/**
* debugXSLGetTemplate:
*
* Return the last template node found, if an
*
* Returns The last template node found, if any
*/
xsltTemplatePtr
debugXSLGetTemplate(void)
{
return rootCopy;
}
/****************************************************************
* *
* The XSL shell related functions *
* *
****************************************************************/
/* xslDbgCd :
* Change directories
* @styleCtxt : current stylesheet context
* @ctxt : current shell context
* @arg : path to change to and in UTF-8
* @source : is valid
*
* Returns 1 on success,
* 0 otherwise
*/
int
xslDbgCd(xsltTransformContextPtr styleCtxt, xmlShellCtxtPtr ctxt,
xmlChar * arg, xmlNodePtr source)
{
xmlXPathObjectPtr list = NULL;
int result = 0;
int offset = 2; /* in some cases I'm only interested after first two chars */
if (!ctxt) {
xsldbgGenericErrorFunc(i18n("Error: Debugger has no files loaded. Try reloading files.\n"));
return result;
}
if (arg == NULL)
arg = (xmlChar *) "";
if (arg[0] == 0) {
ctxt->node = (xmlNodePtr) ctxt->doc;
} else {
if ((arg[0] == '-') && (xmlStrLen(arg) > 2)) {
if (styleCtxt) {
if (arg[1] == 't') {
xmlNodePtr templateNode;
/* quickly find a template */
/* skip any white spaces */
while (_IS_BLANK(arg[offset]))
offset++;
templateNode =
findTemplateNode(styleCtxt->style, &arg[offset]);
if (!templateNode) {
xsldbgGenericErrorFunc(i18n("Error: The XSLT template named \"%1\" was not found.\n").arg(xsldbgText(&arg[offset])));
return result;
} else {
xsldbgGenericErrorFunc(i18n(" template: \"%1\"\n").arg(xsldbgText(&arg[offset])));
ctxt->node = templateNode;
result = 1;
return result;
}
} else if (arg[1] == 's') {
/*quickly switch to another stylesheet node */
xmlXPathContextPtr pctxt;
if (source) {
pctxt = xmlXPathNewContext(source->doc);
if (pctxt == NULL) {
xmlFree(ctxt);
/* xslDebugStatus = DEBUG_QUIT; */
return result;
}
if (!xmlXPathNsLookup(pctxt, (xmlChar *) "xsl"))
xmlXPathRegisterNs(pctxt, (xmlChar *) "xsl",
XSLT_NAMESPACE);
list =
xmlXPathEval((xmlChar *) & arg[offset], pctxt);
if (pctxt) {
xmlFree(pctxt);
}
} else {
xsldbgGenericErrorFunc(i18n("Error: Unable to cd. No stylesheet loaded.\n"));
}
} else {
xsldbgGenericErrorFunc(i18n("Error: Unknown arguments to the command %1.\n").arg("cd"));
}
} else
xsldbgGenericErrorFunc(i18n("Error: Unable to cd. No stylesheet loaded.\n"));
} else {
xmlNodePtr savenode;
if (styleCtxt) {
savenode = styleCtxt->xpathCtxt->node;
ctxt->pctxt->node = ctxt->node;
styleCtxt->xpathCtxt->node = ctxt->node;
if (!xmlXPathNsLookup(ctxt->pctxt, (xmlChar *) "xsl"))
xmlXPathRegisterNs(ctxt->pctxt, (xmlChar *) "xsl",
XSLT_NAMESPACE);
list = xmlXPathEval((xmlChar *) arg, styleCtxt->xpathCtxt);
styleCtxt->xpathCtxt->node = savenode;
} else if (ctxt->pctxt) {
if (!xmlXPathNsLookup(ctxt->pctxt, (xmlChar *) "xsl"))
xmlXPathRegisterNs(ctxt->pctxt, (xmlChar *) "xsl",
XSLT_NAMESPACE);
list = xmlXPathEval((xmlChar *) arg, ctxt->pctxt);
} else {
xsldbgGenericErrorFunc(i18n("Error: Invalid arguments to the command %1.\n").arg("cd"));
}
}
if (list != NULL) {
switch (list->type) {
case XPATH_NODESET:
if (list->nodesetval) {
if (list->nodesetval->nodeNr == 1) {
ctxt->node = list->nodesetval->nodeTab[0];
/* tell the application about the new line
* number we are looking at */
if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
int breakpoint = 0;
xsldbgUpdateFileDetails(ctxt->node);
notifyXsldbgApp(XSLDBG_MSG_LINE_CHANGED,
&breakpoint);
}
result = 1;
} else
xsldbgGenericErrorFunc(i18n("Warning: XPath %1 is a Node Set with %n child.", "Warning: XPath %1 is a Node Set with %n children.", list->nodesetval->nodeNr).arg(xsldbgText(arg)) + QString("\n"));
} else {
xsldbgGenericErrorFunc(i18n("Warning: XPath %1 is an empty Node Set.\n").arg(xsldbgText(arg)));
}
break;
default:
xmlShellPrintXPathError(list->type, (char *) arg);
}
xmlXPathFreeObject(list);
} else {
xsldbgGenericErrorFunc(i18n("Error: XPath %1 was not found.\n").arg(xsldbgText(arg)));
}
if (ctxt->pctxt)
ctxt->pctxt->node = NULL;
}
return result;
}
/**
* xslDbgPrintCallStack:
* @arg : the number of frame to print, NULL if all items
*
* Print all items found on the callStack
*
* Returns 1 on success,
* 0 otherwise
*/
int
xslDbgPrintCallStack(const xmlChar * arg)
{
int depth = 0;
int result = 1;
callPointPtr callPointItem;
if (arg == NULL) {
if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
notifyListStart(XSLDBG_MSG_CALLSTACK_CHANGED);
/* we send the oldest frame stack first */
for (depth = 1; depth <= callStackGetDepth(); depth++) {
callPointItem = callStackGet(depth);
if (callPointItem && callPointItem->info) {
notifyListQueue(callPointItem);
}
}
notifyListSend();
} else {
xmlChar *nameTemp, *modeTemp;
for (depth = callStackGetDepth(); depth >= 1; depth--) {
callPointItem = callStackGet(depth);
nameTemp = NULL;
modeTemp = NULL;
if (callPointItem && callPointItem->info) {
if (depth == callStackGetDepth()) {
xmlChar *curUrl = xsldbgUrl();
long curLine = xsldbgLineNo();
/* if possible list the current location */
if (rootCopy && (rootCopy->match || rootCopy->name)
&& curUrl) {
xmlChar *rootNameTemp, *rootModeTemp;
rootNameTemp = fullQName(rootCopy->nameURI, rootCopy->name);
rootModeTemp = fullQName(rootCopy->modeURI, rootCopy->mode);
if (rootNameTemp && rootModeTemp){
if (rootCopy->match)
/* display information about the current XSLT template */
xsldbgGenericErrorFunc(i18n("#%1 template: \"%2\" mode: \"%3\"").arg(depth).arg(xsldbgText(rootCopy->match)).arg(xsldbgText(rootModeTemp)));
else
/* display information about the current XSLT template */
xsldbgGenericErrorFunc(i18n("#%1 template: \"%2\" mode: \"%3\"").arg(depth).arg(xsldbgText(rootNameTemp)).arg(xsldbgText(rootModeTemp)));
/* display where we are in the source/document file */
xsldbgGenericErrorFunc(i18n(" in file \"%1\" at line %2\n").arg(xsldbgUrl(curUrl)).arg(curLine));
}else{
xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
result = 0;
}
if (rootNameTemp){
xmlFree(rootNameTemp);
rootNameTemp = NULL;
}
if (rootModeTemp){
xmlFree(rootModeTemp);
rootModeTemp = NULL;
}
} else if (curUrl) {
/* display information about the current XSLT template */
xsldbgGenericErrorFunc(i18n("#%1 template: \"LIBXSLT_DEFAULT\" mode: \"\"").arg(depth));
/* display where we are in the source/document file */
xsldbgGenericErrorFunc(i18n(" in file \"%1\" at line %2\n").arg(xsldbgUrl(curUrl)).arg(curLine));
}
if (curUrl)
xmlFree(curUrl);
}
nameTemp = fullQName(callPointItem->info->templateURI,
callPointItem->info->templateName);
modeTemp = fullQName(callPointItem->info->modeURI,
callPointItem->info->modeName);
if (nameTemp && modeTemp){
/* display information about the current XSLT template */
xsldbgGenericErrorFunc(i18n("#%1 template: \"%2\" mode: \"%3\"").arg(depth - 1).arg(xsldbgText(nameTemp)).arg(xsldbgText(modeTemp)));
if (callPointItem->info->url)
/* display where we are in the source/document file */
xsldbgGenericErrorFunc(i18n(" in file \"%1\" at line %2\n").arg(xsldbgUrl(callPointItem->info->url)).arg(callPointItem->lineNo));
else
xsldbgGenericErrorFunc("\n");
}else{
xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
result = 0;
}
if (nameTemp){
xmlFree(nameTemp);
nameTemp = NULL;
}
if(modeTemp){
xmlFree(modeTemp);
modeTemp = NULL;
}
} else {
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Call stack item not found at depth %d : xslDbgPrintCallStack\n", depth);
#endif
result = 0;
break;
}
}
if (callStackGetDepth() == 0)
xsldbgGenericErrorFunc(i18n("\tNo items in call stack.\n"));
else
xsldbgGenericErrorFunc("\n");
}
} else {
long templateDepth = atol((char *) arg);
if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
/* should never happen but just in case, when running as a
* thread always provide NO params to the where command */
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Notification of a frame not supported\n");
#endif
result = 0;
return result;
}
if (templateDepth >= 0) {
callPointItem = callStackGet(templateDepth + 1);
if (callPointItem && callPointItem->info) {
/* display information about the current XSLT template */
xsldbgGenericErrorFunc(i18n("#%1 template: \"%2\"").arg(templateDepth).arg(xsldbgText(callPointItem->info->templateName)));
/* should alays be present but .. */
if (callPointItem->info->url)
/* display where we are in the source/document file */
xsldbgGenericErrorFunc(i18n(" in file \"%1\" at line %2\n").arg(xsldbgUrl(callPointItem->info->url)).arg(callPointItem->lineNo));
else
xsldbgGenericErrorFunc("\n");
} else {
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Call stack item not found at templateDepth %d : xslDbgPrintCallStack\n", depth);
#endif
result = 0;
}
}
}
return result;
}
/**
* xslDbgSleep:
* @delay : the number of microseconds to delay exection by
*
* Delay execution by a specified number of microseconds. On some system
* this will not be at all accurate.
*/
void
xslDbgSleep(long delay)
{
#ifdef HAVE_USLEEP
usleep(delay);
#else
#ifdef WIN32
Sleep(delay / 1000);
#else
/* try to delay things by doing a lot of floating point
* multiplication
*/
long loop1, loop2;
float f1 = 1.0000001, f2;
for (loop1 = 0; loop1 < 100000 * delay; loop1++)
for (loop2 = 0; loop2 < 100000; loop2++) {
f2 = f1 * f1;
}
#endif
#endif
}
/**
* xslDbgWalkContinue:
*
* Delay execution for time as indicated by OPTION_WALK_SPEED
* Can only be called from within shellPrompt!
* OPTION_WALK_SPEED != WALKSPEED_STOP
*
* Returns 1 if walk is to continue,
* 0 otherwise
*/
int
xslDbgWalkContinue(void)
{
int result = 0, speed = optionsGetIntOption(OPTIONS_WALK_SPEED);
/* We need to ensure that output is realy sent. Otherwise
* walking using xemacs under WIN32 will not work */
fflush(stderr);
switch (speed) {
case WALKSPEED_1:
case WALKSPEED_2:
case WALKSPEED_3:
case WALKSPEED_4:
case WALKSPEED_5:
case WALKSPEED_6:
case WALKSPEED_7:
case WALKSPEED_8:
case WALKSPEED_9:
/* see options.h for defintion of WALKDAY */
xslDbgSleep(speed * WALKDELAY);
result = 1;
break;
default: /* stop walking */
optionsSetIntOption(OPTIONS_WALK_SPEED, WALKSPEED_STOP);
xslDebugStatus = DEBUG_STOP;
break;
}
return result;
}
/**
* addBreakPointNode:
* @payload : valid breakPointPtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addBreakPointNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node = searchBreakPointNode((breakPointPtr) payload);
searchAdd(node);
}
/**
* addSourceNode:
* @payload : valid xsltStylesheetPtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addSourceNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node = searchSourceNode((xsltStylesheetPtr) payload);
searchAdd(node);
}
/**
* addTemplateNode:
* @payload : valid xsltTemplatePtr
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addTemplateNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node =
searchTemplateNode(((xsltTemplatePtr) payload)->elem);
searchAdd(node);
}
/**
* addGlobalNode:
* @payload : valid xmlNodePtr of global variable
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addGlobalNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node = searchGlobalNode((xmlNodePtr) payload);
searchAdd(node);
}
/**
* addLocalNode:
* @payload : valid xmlNodePtr of local variable
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addLocalNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node = searchLocalNode((xmlNodePtr) payload);
searchAdd(node);
}
/**
* addIncludeNode:
* @payload : valid xmlNodePtr of include instuction
* @data : not used
* @name : not used
*
* Convert payload into format needed, and add to search dataBase
*/
void
addIncludeNode(void *payload, void *data,
xmlChar * name)
{
Q_UNUSED(data);
Q_UNUSED(name);
xmlNodePtr node = searchIncludeNode((xmlNodePtr) payload);
searchAdd(node);
}
/**
* addCallStackItems:
*
* Convert call stack items into format needed, and add to search dataBase
*/
void
addCallStackItems(void)
{
callPointPtr item;
xmlNodePtr node;
int depth;
for (depth = callStackGetDepth(); depth > 0; depth--) {
item = callStackGet(depth);
if (item) {
node = searchCallStackNode(item);
if (node)
searchAdd(node);
}
}
}
/**
* updateSearchData:
* @styleCtxt: Not used
* @style: Is valid
* @data: Not used but MUST be NULL for the moment
* @variableTypes: What types of variables to look
*
* Update the searchDatabase
*
* Returns 1 on success,
* 0 otherwise
*/
int
updateSearchData(xsltTransformContextPtr styleCtxt,
xsltStylesheetPtr style,
void *data, VariableTypeEnum variableTypes)
{
Q_UNUSED(styleCtxt);
Q_UNUSED(variableTypes);
int result = 0;
if (!style) {
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Unable to update search database no stylesheet loaded\n");
#endif
return result;
}
searchEmpty();
xsldbgGenericErrorFunc(i18n("Information: Updating search database. This may take a while...\n"));
/* add items to the search dataBase */
addCallStackItems();
xsldbgGenericErrorFunc(i18n("Information: Looking for breakpoints.\n"));
walkBreakPoints((xmlHashScanner) addBreakPointNode, data);
xsldbgGenericErrorFunc(i18n("Information: Looking for imports and top-level stylesheets.\n"));
walkStylesheets((xmlHashScanner) addSourceNode, data, style);
xsldbgGenericErrorFunc(i18n("Information: Looking for xsl:includes.\n"));
walkIncludeInst((xmlHashScanner) addIncludeNode, data, style);
xsldbgGenericErrorFunc(i18n("Information: Looking for templates.\n"));
walkTemplates((xmlHashScanner) addTemplateNode, data, style);
xsldbgGenericErrorFunc(i18n("Information: Looking for global variables.\n"));
walkGlobals((xmlHashScanner) addGlobalNode, data, style);
xsldbgGenericErrorFunc(i18n("Information: Looking for local variables.\n"));
walkLocals((xmlHashScanner) addLocalNode, data, style);
xsldbgGenericErrorFunc(i18n("Information: Formatting output.\n"));
result = searchSave(NULL);
return result;
}
/**
* debugXSLBreak:
* @templ: The source node being executed
* @node: The data node being processed
* @root: The template being applied to "node"
* @ctxt: The transform context for stylesheet being processed
*
* A break point has been found so pass control to user
*/
void
debugXSLBreak(xmlNodePtr templ, xmlNodePtr node, xsltTemplatePtr root,
xsltTransformContextPtr ctxt)
{
xmlDocPtr tempDoc = NULL;
xmlNodePtr tempNode = NULL;
rootCopy = root;
static const xmlChar *lastTemplate = NULL;
xmlBufferPtr buffer = xmlBufferCreate();
static char mybuff[6] = " 0\n\x0";
if (ctxt && templ && root && !xsldbgReachedFirstTemplate)
xsldbgReachedFirstTemplate = true;
if (templ == NULL) {
tempDoc = xmlNewDoc((xmlChar *) "1.0");
if (!tempDoc)
return;
tempNode = xmlNewNode(NULL, (xmlChar *) "xsldbg_default_node");
if (!tempNode) {
xmlFreeDoc(tempDoc);
return;
}
xmlAddChild((xmlNodePtr) tempDoc, tempNode);
templ = tempNode;
}
if (node == NULL)
node = (xmlNodePtr) filesGetMainDoc();
if (node == NULL) {
tempDoc = xmlNewDoc((xmlChar *) "1.0");
if (!tempDoc)
return;
tempNode = xmlNewNode(NULL, (xmlChar *) "xsldbg_default_node");
if (!tempNode) {
xmlFreeDoc(tempDoc);
return;
}
xmlAddChild((xmlNodePtr) tempDoc, tempNode);
node = tempNode;
}
if (root) {
xmlChar *nameTemp = NULL, *modeTemp = NULL;
nameTemp = fullQName(root->nameURI, root->name);
modeTemp = fullQName(root->modeURI, root->mode);
if (!nextCommandActive){
/* we only want messages if we are not
in the process of completing the next command */
if (terminalIO == NULL) {
if (root->match){
xsldbgGenericErrorFunc(i18n("\nReached template: \"%1\" mode: \"%2\"\n").arg(xsldbgText(root->match)).arg(xsldbgText(modeTemp)));
if (lastTemplate != root->match && buffer){
xmlBufferCCat(buffer, "\nreached matched template:");
xmlBufferCat(buffer, root->match);
xmlBufferCCat(buffer, mybuff);
xsltCopyTextString(ctxt, ctxt->insert,xmlBufferContent(buffer),0);
mybuff[1]++;
lastTemplate = root->match;
}
}else{
xsldbgGenericErrorFunc(i18n("\nReached template: \"%1\" mode: \"%2\"\n").arg(xsldbgText(nameTemp)).arg(xsldbgText(modeTemp)));
if (lastTemplate != root->name && buffer){
xmlBufferCCat(buffer, "\nreached named template:");
xmlBufferCat(buffer,root->match);
xmlBufferCCat(buffer,mybuff);
xsltCopyTextString(ctxt, ctxt->insert,xmlBufferContent(buffer),0);
mybuff[1]++;
lastTemplate = root->name;
}
}
if (buffer)
xmlBufferFree(buffer);
} else {
if ((xslDebugStatus == DEBUG_TRACE) ||
(xslDebugStatus == DEBUG_WALK)) {
QString message;
if (root->match)
message = i18n("\nReached template: \"%1\" mode: \"%2\"\n").arg(xsldbgText(root->match)).arg(xsldbgText(modeTemp));
else
message = i18n("\nReached template: \"%1\" mode: \"%2\"\n").arg(xsldbgText(nameTemp)).arg(xsldbgText(modeTemp));
fprintf(terminalIO, "%s", message.local8Bit().data());
}
}
}
if (nameTemp)
xmlFree(nameTemp);
if (modeTemp)
xmlFree(modeTemp);
}
shellPrompt(templ, node, (xmlChar *) "index.xsl",
(xmlShellReadlineFunc) xslDbgShellReadline, stdout, ctxt);
if (tempDoc)
xmlFreeDoc(tempDoc);
}
/* Highly modified function based on xmlShell */
/**
* shellPrompt:
* @source: The current stylesheet instruction being executed
* @doc: The current document node being processed
* @filename: Not used
* @input: The function to call to when reading commands from stdio
* @output: Where to put the results
* @styleCtxt: Is valid
*
* Present to the user the xsldbg shell
*/
void
shellPrompt(xmlNodePtr source, xmlNodePtr doc, xmlChar * filename,
xmlShellReadlineFunc input, FILE * output,
xsltTransformContextPtr styleCtxt)
{
xmlChar prompt[DEBUG_BUFFER_SIZE] = "/ > ";
xmlChar *cmdline = NULL, *cur;
int nbargs = 0;
int loadedFiles = 0;
int commandId = -1; /* stores what was the last
* command id entered by user */
xmlChar command[DEBUG_BUFFER_SIZE]; /* holds the command user entered */
xmlChar arg[DEBUG_BUFFER_SIZE]; /* holds any extra arguments to
* command entered */
xmlChar dir[DEBUG_BUFFER_SIZE]; /* temporary buffer used by where
* and pwd commands */
int cmdResult; /* result of last command */
int shortCutId = -1; /* used by cd command */
int i;
static int showSource = 1; /* Do we first show source or data ? */
xmlChar *baseUri = NULL; /* for used for included xml entities */
const xmlChar *breakUri;
/* for convenience keep track of which node was last
* selected of source and doc */
xmlNodePtr lastSourceNode, lastDocNode;
xmlShellCtxtPtr ctxt;
int exitShell = 0; /* Indicate when to exit xslShell */
if (source == NULL){
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Source NULL in shellPrompt\n");
#endif
return;
}
if (doc == NULL){
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: doc NULL in shellPrompt\n");
#endif
return;
}
if (filename == NULL){
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: fileName NULL in shellPrompt\n");
#endif
return;
}
if (input == NULL){
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Input function NULL in shellPrompt\n");
#endif
return;
}
if (output == NULL){
#ifdef WITH_XSLDBG_DEBUG_PROCESS
xsltGenericError(xsltGenericErrorContext,
"Error: Output NULL in shellPrompt\n");
#endif
return;
}
ctxt = (xmlShellCtxtPtr) xmlMalloc(sizeof(xmlShellCtxt));
if (ctxt == NULL){
xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
return;
}
/* flag that we've received control */
debugGotControl(1);
ctxt->loaded = 0;
lastSourceNode = source;
lastDocNode = doc;
/* show the doc or source first? */
if (showSource) {
ctxt->doc = source->doc;
ctxt->node = source;
xsldbgUpdateFileDetails(source);
} else {
ctxt->doc = doc->doc;
ctxt->node = (xmlNodePtr) doc;
xsldbgUpdateFileDetails((xmlNodePtr) doc);
}
ctxt->input = input;
ctxt->output = output;
ctxt->filename = (char *) xmlStrdup((xmlChar *) filename);
if (xsldbgStop == 1){
xslDebugStatus = DEBUG_STOP;
optionsSetIntOption(OPTIONS_TRACE, TRACE_OFF);
optionsSetIntOption(OPTIONS_WALK_SPEED, WALKSPEED_STOP);
xsldbgStop = 0;
}
/* let any listener know that we got to a new line */
if (xslDebugStatus != DEBUG_TRACE) {
/* don't send notify message if we are tracing stylesheet */
int breakpoint = 1;
notifyXsldbgApp(XSLDBG_MSG_LINE_CHANGED, &breakpoint);
}
/* If using a thread and the thread is running then we don't need to
* send this as the application will see the XSLDBG_MSG_LINE_CHANGED message */
if ((getThreadStatus() == XSLDBG_MSG_THREAD_NOTUSED) ||
(xslDebugStatus == DEBUG_TRACE)) {
QString messageTxt;
if (!nextCommandActive && ctxt->node && ctxt->node && ctxt->node->doc
&& ctxt->node->doc->URL) {
if (!showSource) {
baseUri = filesGetBaseUri(ctxt->node);
if (baseUri != NULL)
breakUri = baseUri;
else
breakUri = ctxt->node->doc->URL;
} else
breakUri = ctxt->node->doc->URL;
if (xmlGetLineNo(ctxt->node) != -1)
messageTxt = i18n("Breakpoint for file \"%1\" at line %2.\n").arg(xsldbgUrl(breakUri)).arg(xmlGetLineNo(ctxt->node));
else
messageTxt = i18n("Breakpoint at text node in file \"%1\".\n").arg(xsldbgUrl(breakUri));
if (baseUri != NULL) {
xmlFree(baseUri);
baseUri = NULL;
}
if (((xslDebugStatus == DEBUG_TRACE) ||
(xslDebugStatus == DEBUG_WALK)) && (terminalIO != NULL))
fprintf(terminalIO, "%s", messageTxt.utf8().data());
else
xsldbgGenericErrorFunc(messageTxt);
}
}
if ((showWatchesActive && (xslDebugStatus == DEBUG_TRACE)) ||
(xslDebugStatus == DEBUG_WALK)){
ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
if (ctxt->pctxt) {
xslDbgShellShowWatches(styleCtxt, ctxt, 0);
xsldbgGenericErrorFunc("\n");
xmlXPathFreeContext(ctxt->pctxt);
ctxt->pctxt = NULL;
}
}
if (xslDebugStatus == DEBUG_TRACE) {
if (ctxt->filename)
xmlFree(ctxt->filename);
xmlFree(ctxt);
return; /* All done. Trace next instruction/node */
}
if (xslDebugStatus == DEBUG_WALK) {
if (xslDbgWalkContinue()) {
if (ctxt->filename)
xmlFree(ctxt->filename);
xmlFree(ctxt);
return; /* All done. Walk to next instruction/node */
}
}
ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
if (ctxt->pctxt == NULL) {
xmlFree(ctxt);
xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
return;
}
if (showWatchesActive){
xslDbgShellShowWatches(styleCtxt, ctxt, 0);
xsldbgGenericErrorFunc("\n");
}
while (!exitShell && (xslDebugStatus != DEBUG_QUIT)) {
if (getThreadStatus() != XSLDBG_MSG_THREAD_RUN) {
if (ctxt->node == (xmlNodePtr) ctxt->doc)
snprintf((char *) prompt, DEBUG_BUFFER_SIZE - 1,
"(xsldbg) %s > ", "/");
else if ((ctxt->node->name) && (ctxt->node->ns))
snprintf((char *) prompt, DEBUG_BUFFER_SIZE - 1,
"(xsldbg) %s:%s > ", ctxt->node->ns->prefix,
ctxt->node->name);
else if (ctxt->node->name)
snprintf((char *) prompt, DEBUG_BUFFER_SIZE - 1,
"(xsldbg) %s > ", ctxt->node->name);
else
snprintf((char *) prompt, DEBUG_BUFFER_SIZE - 1,
"(xsldbg) ? > ");
prompt[sizeof(prompt) - 1] = 0;
/*
* Get a new command line
*/
if (nextCommandActive && (xslDebugStatus == DEBUG_STEP))
/* we are processing the "next command" do the next
part of the command which is the up command */
cmdline = xmlStrdup((xmlChar*)"up");
else
cmdline = (xmlChar *) ctxt->input((char *) prompt);
if (cmdline && (optionsGetIntOption(OPTIONS_UTF8_INPUT) == 0)) {
/* we are getting encoded characters from the command line
* so decode them into UTF-8 */
xmlChar *tempResult = filesDecode(cmdline);
if (tempResult) {
xmlFree(cmdline);
cmdline = tempResult;
}
}
} else {
/* don't need a prompt for running as when running as a thread */
xmlStrCpy(messageBuffer, "");
if (nextCommandActive && (xslDebugStatus == DEBUG_STEP))
/* we are processing the "next command" do the next
part of the command which is the up command */
cmdline = xmlStrdup((xmlChar*)"up");
else
cmdline = (xmlChar *) ctxt->input((char *) messageBuffer);
}
if (cmdline == NULL)
break;
/* don't allow next command to be active more than at one breakpoint */
if (nextCommandActive)
nextCommandActive = 0;
notifyXsldbgApp(XSLDBG_MSG_PROCESSING_INPUT, NULL);
/* remove leading/trailing blanks */
trimString(cmdline);
/*
* Parse the command itself
*/
cur = cmdline;
nbargs = 0;
while ((*cur == ' ') || (*cur == '\t'))
cur++;
i = 0;
while ((*cur != ' ') && (*cur != '\t') &&
(*cur != '\n') && (*cur != '\r')) {
if (*cur == 0)
break;
command[i++] = *cur++;
}
command[i] = 0;
if (i == 0)
continue;
nbargs++;
/*
* Parse the argument
*/
while ((*cur == ' ') || (*cur == '\t'))
cur++;
i = 0;
while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
if (*cur == 0)
break;
arg[i++] = *cur++;
}
arg[i] = 0;
if (i != 0)
nbargs++;
commandId = lookupName(command, (xmlChar **) commandNames);
/* try command shorts if command is not found */
if (commandId < 0)
commandId =
lookupName(command, (xmlChar **) shortCommandNames);
cmdResult = -1; /* flag that it contains no result */
/*
* start interpreting the command
*/
switch (commandId + DEBUG_HELP_CMD) {
/* --- Help related commands --- */
case DEBUG_HELP_CMD:
cmdResult = helpTop(arg);
if (!cmdResult)
xsldbgGenericErrorFunc(i18n("Unable to print local help. Online help can be found at http://xsldbg.sourceforge.net/docs/index.html.\n"));
break;
/* --- Running related commands --- */
case DEBUG_BYE_CMD:
case DEBUG_EXIT_CMD:
case DEBUG_QUIT_CMD:
/* allow the stylesheet to exit */
xslDebugStatus = DEBUG_QUIT;
exitShell++;
cmdResult = 1;
break;
case DEBUG_NEXT_CMD:
xslDebugStatus = DEBUG_STEP;
exitShell++;
cmdResult = 1;
/* Do the the next part of this command
which is the up command */
nextCommandActive = 1;
break;
case DEBUG_STEP_CMD:
xslDebugStatus = DEBUG_STEP;
exitShell++;
cmdResult = 1;
break;
case DEBUG_STEPUP_CMD:
{
xmlChar *noOfFrames = arg;
/* skip until next space character */
while (*noOfFrames && (*noOfFrames != ' ')) {
noOfFrames++;
}
cmdResult = xslDbgShellFrameBreak(noOfFrames, 1);
exitShell++;
}
break;
case DEBUG_STEPDOWN_CMD:
{
xmlChar *noOfFrames = arg;
/* skip until next space character */
while (*noOfFrames && (*noOfFrames != ' ')) {
noOfFrames++;
}
cmdResult = xslDbgShellFrameBreak(noOfFrames, 0);
exitShell++;
}
break;
/* continue to next break point */
case DEBUG_CONT_CMD:
xslDebugStatus = DEBUG_CONT;
exitShell++;
cmdResult = 1;
break;
/* restart */
case DEBUG_RUN_CMD:
xslDebugStatus = DEBUG_RUN_RESTART;
exitShell++;
cmdResult = 1;
break;
/* --- Template related commands --- */
case DEBUG_TEMPLATES_CMD:
{
int allFiles = 1, verbose = 1;
if (xmlStrLen(arg) && (xmlStrCmp(arg, "this") == 0)) {
allFiles = 0;
}
/* be verbose when printing template names */
/* if args is not empty then print names this stylesheet */
cmdResult =
xslDbgShellPrintTemplateNames(styleCtxt, ctxt, arg,
verbose, allFiles);
break;
}
case DEBUG_WHERE_CMD:
/* Print the current working directory as well */
xslDbgPrintCallStack(NULL);
if (getThreadStatus() != XSLDBG_MSG_THREAD_RUN) {
if (!xmlShellPwd(ctxt, (char *) dir, ctxt->node, NULL)){
xsldbgGenericErrorFunc((const char*)dir);
xsldbgGenericErrorFunc("\n");
}
}
cmdResult = 1;
break;
case DEBUG_FRAME_CMD:
cmdResult = xslDbgPrintCallStack(arg);
break;
case DEBUG_STYLESHEETS_CMD:
cmdResult = xslDbgShellPrintStyleSheets(arg);
break;
/* --- Break point related commands --- */
case DEBUG_BREAK_CMD:
if (xmlStrLen(arg)) {
if (styleCtxt)
cmdResult =
xslDbgShellBreak(arg, styleCtxt->style,
styleCtxt);
else
cmdResult = xslDbgShellBreak(arg, NULL, styleCtxt);
} else {
/* select current node to break at */
xmlChar buff[100];
xmlChar *tempBaseName = filesGetBaseUri(ctxt->node);
if (tempBaseName){
snprintf((char *) buff, sizeof(buff), "-l %s %ld",
tempBaseName,
xmlGetLineNo(ctxt->node));
xmlFree(tempBaseName);
}
if (styleCtxt)
cmdResult =
xslDbgShellBreak(buff, styleCtxt->style,
styleCtxt);
else
cmdResult =
xslDbgShellBreak(buff, NULL, styleCtxt);
}
break;
case DEBUG_SHOWBREAK_CMD:
if (getThreadStatus() == XSLDBG_MSG_THREAD_RUN) {
notifyListStart(XSLDBG_MSG_BREAKPOINT_CHANGED);
walkBreakPoints((xmlHashScanner)
xslDbgShellPrintBreakPoint, NULL);
notifyListSend();
} else {
xsldbgGenericErrorFunc("\n");
printCount = 0; /* printCount will get updated by
* xslDbgShellPrintBreakPoint */
walkBreakPoints((xmlHashScanner)
xslDbgShellPrintBreakPoint, NULL);
if (printCount == 0)
xsldbgGenericErrorFunc(i18n("\nNo breakpoints are set for the file.\n"));
else
xsldbgGenericErrorFunc(i18n("\tTotal of %n breakpoint present.","\tTotal of %n breakpoints present.", printCount) + QString("\n"));
}
cmdResult = 1;
break;
case DEBUG_DELETE_CMD:
if (xmlStrLen(arg))
cmdResult = xslDbgShellDelete((xmlChar *) arg);
else {
breakPointPtr breakPtr = NULL;
xmlChar* tempBaseName = filesGetBaseUri(ctxt->node);
if (tempBaseName){
breakPtr =
breakPointGet(tempBaseName,
xmlGetLineNo(ctxt->node));
xmlFree(tempBaseName);
}
if (!breakPtr || !breakPointDelete(breakPtr)) {
xsldbgGenericErrorFunc(i18n("Error: Unable to delete breakpoint.\n"));
cmdResult = 0;
}
}
break;
case DEBUG_ENABLE_CMD:
if (xmlStrLen(arg))
cmdResult =
xslDbgShellEnable(arg, XSL_TOGGLE_BREAKPOINT);
else {
breakPointPtr breakPtr = NULL;
xmlChar * tempBaseName = filesGetBaseUri(ctxt->node);
if (tempBaseName){
breakPtr =
breakPointGet(tempBaseName,
xmlGetLineNo(ctxt->node));
xmlFree(tempBaseName);
}
if (!breakPtr ||
(!breakPointEnable(breakPtr, !(breakPtr->flags & BREAKPOINT_ENABLED)))) {
xsldbgGenericErrorFunc(i18n("Error: Unable to enable/disable breakpoint.\n"));
cmdResult = 0;
}
}
break;
case DEBUG_DISABLE_CMD:
if (xmlStrLen(arg))
cmdResult = xslDbgShellEnable(arg, 0);
else {
breakPointPtr breakPtr = NULL;
xmlChar *tempBaseName = filesGetBaseUri(ctxt->node);
if (tempBaseName){
breakPtr =
breakPointGet(tempBaseName,
xmlGetLineNo(ctxt->node));
xmlFree(tempBaseName);
}
if (!breakPtr || !breakPointEnable(breakPtr, 0)) {
xsldbgGenericErrorFunc(i18n("Error: Unable to enable/disable breakpoint.\n"));
cmdResult = 0;
}
}
break;
/* --- Node view related commands --- */
case DEBUG_LS_CMD:
cmdResult = xslDbgShellPrintList(ctxt, arg, 0);
break;
case DEBUG_DIR_CMD:
cmdResult = xslDbgShellPrintList(ctxt, arg, 1);
break;
case DEBUG_DU_CMD:
xmlShellDu(ctxt, NULL, ctxt->node, NULL);
cmdResult = 1;
break;
case DEBUG_CAT_CMD:
case DEBUG_PRINT_CMD:
cmdResult = xslDbgShellCat(styleCtxt, ctxt, arg);
break;
case DEBUG_PWD_CMD:
if (!xmlShellPwd(ctxt, (char *) dir, ctxt->node, NULL)) {
xmlChar* tempBaseName = filesGetBaseUri(ctxt->node);
if(tempBaseName){
xsldbgGenericErrorFunc("\n");
xsldbgGenericErrorFunc((char*)dir);
xsldbgGenericErrorFunc(i18n(" in file \"%1\" at line %2").arg(xsldbgUrl(tempBaseName)).arg(xmlGetLineNo(ctxt->node)));
xmlFree(tempBaseName);
cmdResult = 1;
}
}
if (cmdResult)
xsldbgGenericErrorFunc("\n");
else
xsldbgGenericErrorFunc(i18n("Error: Unable to print working directory.\n"));
break;
case DEBUG_DUMP_CMD:
xmlDebugDumpDocument(stdout, ctxt->doc);
cmdResult = 1;
break;
case DEBUG_BASE_CMD:
xmlShellBase(ctxt, NULL, ctxt->node, NULL);
cmdResult = 1;
break;
/* --- Variable related commands --- */
case DEBUG_GLOBALS_CMD:
if (loadedFiles == 0)
cmdResult = xslDbgShellPrintVariable(styleCtxt, arg,
DEBUG_GLOBAL_VAR);
else {
xsldbgGenericErrorFunc(i18n("Error: Need to use the run command first.\n"));
cmdResult = 0;
}
break;
case DEBUG_LOCALS_CMD:
if (loadedFiles == 0)
/* if gdb compatability mode is enable print the globals then
* the locals */
if (optionsGetIntOption(OPTIONS_GDB) == 1) {
cmdResult =
xslDbgShellPrintVariable(styleCtxt, arg,
DEBUG_GLOBAL_VAR);
if (cmdResult == 1)
cmdResult =
xslDbgShellPrintVariable(styleCtxt, arg,
DEBUG_LOCAL_VAR);
} else
cmdResult =
xslDbgShellPrintVariable(styleCtxt, arg,
DEBUG_LOCAL_VAR);
else {
xsldbgGenericErrorFunc(i18n("Error: Need to use the run command first.\n"));
cmdResult = 0;
}
break;
/* It's difficult to put the following commands into
* a separe file so they stay here! */
/* --- Node selection related commands --- */
case DEBUG_SOURCE_CMD:
cmdResult = 1; /* only one case where this will command fail */
xsldbgValidateBreakpoints = BREAKPOINTS_NEED_VALIDATION;
if (xmlStrLen(arg) == 0) {
if (ctxt->doc == doc->doc)
lastDocNode = ctxt->node;
ctxt->doc = source->doc;
ctxt->node = lastSourceNode;
if (ctxt->pctxt)
xmlXPathFreeContext(ctxt->pctxt);
ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
showSource = 1;
xsldbgUpdateFileDetails((xmlNodePtr) ctxt->node);
/* let any listener know that we got to a new line */
notifyXsldbgApp(XSLDBG_MSG_LINE_CHANGED, NULL);
if (ctxt->pctxt == NULL) {
xmlFree(ctxt);
xslDebugStatus = DEBUG_QUIT;
return;
} else
break;
} else {
/* load new stylesheet file, actual loading happens later */
xmlChar *expandedName = filesExpandName(arg);
if (expandedName) {
xsldbgGenericErrorFunc(i18n("Load of source deferred. Use the run command.\n"));
optionsSetStringOption(OPTIONS_SOURCE_FILE_NAME,
expandedName);
notifyXsldbgApp(XSLDBG_MSG_FILE_CHANGED, 0L);
loadedFiles = 1;
xmlFree(expandedName);
cmdResult = 1;
} else {
cmdResult = 0;
}
}
break;
case DEBUG_DATA_CMD:
cmdResult = 1; /* only one case where this will command fail */
xsldbgValidateBreakpoints = BREAKPOINTS_NEED_VALIDATION;
if (xmlStrLen(arg) == 0) {
if (ctxt->doc == source->doc)
lastSourceNode = ctxt->node;
ctxt->doc = doc->doc;
ctxt->node = lastDocNode;
if (ctxt->pctxt)
xmlXPathFreeContext(ctxt->pctxt);
ctxt->pctxt = xmlXPathNewContext(ctxt->doc);
showSource = 0;
xsldbgUpdateFileDetails((xmlNodePtr) ctxt->node);
/* let any listener know that we got to a new line */
notifyXsldbgApp(XSLDBG_MSG_LINE_CHANGED, NULL);
if (ctxt->pctxt == NULL) {
xmlFree(ctxt);
xslDebugStatus = DEBUG_QUIT;
return;
} else
break;
} else {
/* load new xml file actual loading hapens later */
xmlChar *expandedName = filesExpandName(arg);
if (expandedName) {
xsldbgGenericErrorFunc(i18n("Load of data file deferred. Use the run command.\n"));
optionsSetStringOption(OPTIONS_DATA_FILE_NAME,
expandedName);
notifyXsldbgApp(XSLDBG_MSG_FILE_CHANGED, 0L);
loadedFiles = 1;
xmlFree(expandedName);
cmdResult = 1;
} else {
cmdResult = 0;
}
}
break;
case DEBUG_OUTPUT_CMD:
/* set the output file name to use */
cmdResult = xslDbgShellOutput(arg);
break;
case DEBUG_CD_CMD:
/* use dir as a working buffer */
xmlStrnCpy(dir, arg, 2);
dir[2] = '\0';
shortCutId = lookupName(dir, (xmlChar **) cdShortCuts);
if (shortCutId >= 0) {
if (xmlStrLen(arg) == 2) {
cmdResult = xslDbgCd(styleCtxt, ctxt, (xmlChar *)
cdAlternative[shortCutId],
source);
} else {
xmlStrCpy(dir, cdAlternative[shortCutId]);
xmlStrCat(dir, &arg[2]);
cmdResult = xslDbgCd(styleCtxt, ctxt, dir, source);
}
} else
cmdResult = xslDbgCd(styleCtxt, ctxt, arg, source);
break;
/* --- File related commands --- */
case DEBUG_ENTITIES_CMD:
cmdResult = xslDbgEntities();
break;
case DEBUG_SYSTEM_CMD:
/* strip off a single argument. I need to do it this
way because I've already public this API */
{
xmlChar *systemID;
if (splitString(arg, 1, &systemID) == 1){
cmdResult = xslDbgSystem(systemID);
}else{
xsldbgGenericErrorFunc(i18n("Error: Invalid arguments for the command %1.\n").arg("system"));
}
}
break;
case DEBUG_PUBLIC_CMD:
/* strip off a single argument. I need to do it this
way because I've already public this API */
{
xmlChar *publicID;
if (splitString(arg, 1, &publicID) == 1){
cmdResult = xslDbgPublic(publicID);
}else{
xsldbgGenericErrorFunc(i18n("Error: Invalid arguments for the command %1.\n").arg("public"));
}
}
break;
case DEBUG_ENCODING_CMD:
cmdResult = xslDbgEncoding(arg);
break;
case DEBUG_VALIDATE_CMD:
xsldbgGenericErrorFunc(i18n("Warning: The %1 command is disabled.\n").arg("validate"));
cmdResult = 0;
/*
* xmlShellValidate(ctxt, arg, NULL, NULL);
*/
break;
case DEBUG_LOAD_CMD:
cmdResult = optionsLoad();
/* restart xsldbg and activate new configuration */
if (cmdResult == 1) {
xslDebugStatus = DEBUG_RUN_RESTART;
exitShell++;
}
break;
case DEBUG_SAVE_CMD:
cmdResult = optionsSave();
break;
case DEBUG_WRITE_CMD:
xsldbgGenericErrorFunc(i18n("Warning: The %1 command is disabled.\n").arg("write"));
cmdResult = 0;
/*
* xmlShellWrite(ctxt, arg, NULL, NULL);
*/
break;
case DEBUG_FREE_CMD:
xsldbgGenericErrorFunc(i18n("Warning: The %1 command is disabled.\n").arg("free"));
cmdResult = 0;
/*
* if (arg[0] == 0) {
* xmlMemShow(stdout, 0);
* } else {
* int len = 0;
* sscanf(arg, "%d", &len);
* xmlMemShow(stdout, len);
* }
*/
break;
/* operating system related */
case DEBUG_CHDIR_CMD:
cmdResult = xslDbgShellChangeWd(arg);
break;
case DEBUG_SHELL_EXEC_CMD:
cmdResult = xslDbgShellExecute(arg, 1);
break;
/* libxslt parameter related commands */
case DEBUG_ADDPARAM_CMD:
cmdResult = xslDbgShellAddParam(arg);
break;
case DEBUG_DELPARAM_CMD:
cmdResult = xslDbgShellDelParam(arg);
break;
case DEBUG_SHOWPARAM_CMD:
cmdResult = xslDbgShellShowParam(arg);
break;
/* option related commmands */
case DEBUG_SETOPTION_CMD:
cmdResult = xslDbgShellSetOption(arg);
break;
case DEBUG_OPTIONS_CMD:
cmdResult = xslDbgShellOptions();
break;
/* misc commands */
case DEBUG_TTY_CMD:
if (openTerminal(arg)) {
/* gdb does to say anything after redirecting its
output */
if (optionsGetIntOption(OPTIONS_GDB) < 2)
xsldbgGenericErrorFunc(i18n("Opening terminal %1.\n").arg(xsldbgText(arg)));
cmdResult = 1;
} else
cmdResult = 0;
break;
/* language selection for messages */
case DEBUG_LANG_CMD:
#ifdef LOCALE_PREFIX
if (xmlStrlen(arg) > 0){
setlocale(LC_MESSAGES, (char*)arg);
textdomain("kdewebdev/xsldsbg");
bindtextdomain("kdewebdev/xsldbg", LOCALE_PREFIX);
cmdResult = 1;
}else{
xsldbgGenericErrorFunc(i18n("Error: Missing arguments for the command %1.\n").arg("lang"));
cmdResult = 0;
}
#else
xsldbgGenericErrorFunc(i18n("Warning: The %1 command is disabled\n").arg("lang"));
cmdResult = 1;
#endif
break;
/* tracing related commands */
case DEBUG_TRACE_CMD:
if (xslDbgShellTrace(arg)) {
exitShell++;
cmdResult = 1;
} else
cmdResult = 0;
break;
case DEBUG_WALK_CMD:
if (xslDbgShellWalk(arg)) {
exitShell++;
cmdResult = 1;
} else
cmdResult = 0;
break;
case DEBUG_ADDWATCH_CMD:
cmdResult = xslDbgShellAddWatch(arg);
break;
case DEBUG_DELWATCH_CMD:
cmdResult = xslDbgShellDeleteWatch(arg);
break;
case DEBUG_SHOWWATCH_CMD:
trimString(arg);
switch (arg[0]){
case '\0':
cmdResult = xslDbgShellShowWatches(styleCtxt, ctxt, 1);
break;
case '0':
case '1':
showWatchesActive = arg[0] - '0';
cmdResult = 1;
break;
default:
xsldbgGenericErrorFunc(i18n("Error: Invalid arguments for the command %1.\n").arg("showmatch"));
}
break;
/* search related commands */
case DEBUG_SEARCH_CMD:
cmdResult =
xslDbgShellSearch(styleCtxt, filesGetStylesheet(),
arg);
break;
case DEBUG_SET_CMD:
cmdResult = xslDbgShellSetVariable(styleCtxt, arg);
break;
default:
xsldbgGenericErrorFunc(i18n("Error: Unknown command %1. Try help.\n").arg(xsldbgText(command)));
cmdResult = 0;
}
/* KDbg likes to get the marker after every command so here it is */
if ((optionsGetIntOption(OPTIONS_GDB) >1) && optionsGetIntOption(OPTIONS_VERBOSE) && !nextCommandActive
&& (commandId != DEBUG_STEPUP_CMD - DEBUG_HELP_CMD)) {
if (ctxt->node && ctxt->node &&
ctxt->node->doc && ctxt->node->doc->URL) {
if (xmlGetLineNo(ctxt->node) != -1)
xsldbgGenericErrorFunc(i18n("Breakpoint for file \"%1\" at line %2.\n").arg(xsldbgUrl(ctxt->node->doc->URL)).arg(xmlGetLineNo(ctxt->node)));
else
xsldbgGenericErrorFunc(i18n("Breakpoint at text node in file \"%1\".\n").arg(xsldbgUrl(ctxt->node->doc->URL)));
}
}
/* notify any listeners of that the command failed */
if (cmdResult == 0 && (xmlStrlen(messageBuffer) > 0)) {
snprintf((char *) messageBuffer, sizeof(messageBuffer),
"\nRequest to xsldbg failed:%s\n", cmdline);
notifyTextXsldbgApp(XSLDBG_MSG_TEXTOUT,
(char *) messageBuffer);
}
xmlFree(cmdline);
cmdline = NULL;
}
xmlXPathFreeContext(ctxt->pctxt);
if (ctxt->filename)
xmlFree(ctxt->filename);
xmlFree(ctxt);
if (cmdline)
xmlFree(cmdline);
}