|
|
typedef void (*freeItemFunc) (void *item) | (*freeItemFunc) |
#include <src/arraylist.h>
Provide a fast easy to use array list. Support the basic functions of add delete, empty, count, free
typedef struct _arrayList arrayList | arrayList |
#include <src/arraylist.h>
arrayListPtr arrayListNew (int initialSize,
freeItemFunc deleteFunction)
| arrayListNew |
#include <src/arraylist.h>
Create a new list with a size of initialSize
Parameters:
initial | The initial size of list |
deleteFunction | the Function to call to free items in the list |
Returns: Non-null on success, NULL otherwise
void arrayListFree (arrayListPtr list)
| arrayListFree |
#include <src/arraylist.h>
Free memory assocated with array list, if the array list has a valid deleteFunction then content with be freed with using that deleteFunction
Parameters:
list | A valid list |
int arrayListEmpty (arrayListPtr list)
| arrayListEmpty |
#include <src/arraylist.h>
Empties the list of its content
Parameters:
list | A valid list |
Returns: 1 on success, 0 otherwise
int arrayListSize (arrayListPtr list)
| arrayListSize |
#include <src/arraylist.h>
Return the maximum number elements this list can contain
Parameters:
list | A valid list |
Returns: The maximum number elements this list can contain
int arrayListCount (arrayListPtr list)
| arrayListCount |
#include <src/arraylist.h>
Return the count of number items in list
Parameters:
list | A valid list |
Returns: The count of number items in list
int arrayListAdd (arrayListPtr list, void *item)
| arrayListAdd |
#include <src/arraylist.h>
Add item
to list
Parameters:
list | A valid list |
item | A valid item |
Returns: 1 if able to add item
to end of list
,
0 otherwise
int arrayListDelete (arrayListPtr list, int position)
| arrayListDelete |
#include <src/arraylist.h>
Parameters:
list | A valid list |
position | 0 =< position < arrayListCount(list )
|
Returns: 1 if able to delete element in list
at position position
,
0 otherwise
void * arrayListGet (arrayListPtr list, int position)
| arrayListGet |
#include <src/arraylist.h>
Parameters:
list | A valid list |
position | 0 =< position < arrayListCount(list )
|
Returns: Non-null if able to retrieve element in list
at position
position
,
NULL otherwise
enum DebugStatusEnum { DEBUG_NONE = 0, DEBUG_INIT, DEBUG_STEP, DEBUG_STEPUP, DEBUG_STEPDOWN, DEBUG_NEXT, DEBUG_STOP, DEBUG_CONT, DEBUG_RUN, DEBUG_RUN_RESTART, DEBUG_QUIT, DEBUG_TRACE, DEBUG_WALK } | DebugStatusEnum |
#include <src/breakpoint.h>
Provide a basic break point support
enum BreakPointTypeEnum { DEBUG_BREAK_SOURCE = 300, DEBUG_BREAK_DATA } | BreakPointTypeEnum |
#include <src/breakpoint.h>
enum VariableTypeEnum { DEBUG_GLOBAL_VAR = 200, DEBUG_LOCAL_VAR, DEBUG_ANY_VAR } | VariableTypeEnum |
#include <src/breakpoint.h>
enum BreakPointFlags { BREAKPOINT_ENABLED = 1, BREAKPOINT_ORPHANED = 2, BREAKPOINT_ALLFLAGS = 255 } | BreakPointFlags |
#include <src/breakpoint.h>
enum BreakPointValidationStates { BREAKPOINTS_ARE_VALID, BREAKPOINTS_NEED_VALIDATION, BREAKPOINTS_BEING_VALIDATED } | BreakPointValidationStates |
#include <src/breakpoint.h>
typedef struct _breakPoint breakPoint | breakPoint |
#include <src/breakpoint.h>
int breakPointInit (void)
| breakPointInit |
#include <src/breakpoint.h>
Intialized the breakpoint module
Returns: 1 if breakpoint module has been initialized properly and all memory required has been obtained, 0 otherwise
void breakPointFree (void)
| breakPointFree |
#include <src/breakpoint.h>
Free all memory used by breakpoint module
breakPointPtr breakPointActiveBreakPoint (void)
| breakPointActiveBreakPoint |
#include <src/breakpoint.h>
Get the active break point
Depreciated
Returns: The last break point that we stoped at
void breakPointSetActiveBreakPoint (breakPointPtr breakPtr)
| breakPointSetActiveBreakPoint |
#include <src/breakpoint.h>
Set the active break point
Depreciated
Parameters:
breakPoint | Is valid break point or NULL |
int breakPointAdd (const xmlChar * url, long lineNumber,
const xmlChar * templateName,
const xmlChar * modeName,
BreakPointTypeEnum type)
| breakPointAdd |
#include <src/breakpoint.h>
Add break point at file and line number specified
Parameters:
url | Non-null, non-empty file name that has been loaded by debugger |
lineNumber | lineNumber >= 0 and is available in url specified and
points to an xml element
|
temlateName | The template name of break point or NULL |
modeName | : The mode of breakpoint or NULL |
type | Valid BreakPointTypeEnum |
Returns: 1 if successful, 0 otherwise
int breakPointDelete (breakPointPtr breakPtr)
| breakPointDelete |
#include <src/breakpoint.h>
Delete the break point specified if it can be found using
breakPtr
's url and lineNo
Parameters:
breakPoint | Is valid |
Returns: 1 if successful, 0 otherwise
int breakPointEmpty (void)
| breakPointEmpty |
#include <src/breakpoint.h>
Empty the break point collection
Returns: 1 if able to empty the break point list of its contents, 0 otherwise
int breakPointEnable (breakPointPtr breakPtr, int enable)
| breakPointEnable |
#include <src/breakpoint.h>
Enable or disable a break point
Parameters:
breakPoint | A valid breakpoint |
enable | Enable break point if 1, disable if 0, toggle if -1 |
Returns: 1 if successful, 0 otherwise
breakPointPtr breakPointGet (const xmlChar * url, long lineNumber)
| breakPointGet |
#include <src/breakpoint.h>
Get a break point for the breakpoint collection
Parameters:
url | Non-null, non-empty file name that has been loaded by debugger |
lineNumber | lineNumber >= 0 and is available in url specified
|
Returns: break point if break point exists at location specified, NULL otherwise
xmlHashTablePtr breakPointGetLineNoHash (long lineNo)
| breakPointGetLineNoHash |
#include <src/breakpoint.h>
Return A hash of breakpoints with same line number
Parameters:
lineNo | : Line number of of breakpoints of interest |
Returns: A hash of breakpoints with a line number of lineNo
breakPointPtr breakPointItemNew (void)
| breakPointItemNew |
#include <src/breakpoint.h>
Create a new break point item
Returns: A valid break point with default values set if successful, NULL otherwise
void breakPointItemFree (void *payload, xmlChar * name)
| breakPointItemFree |
#include <src/breakpoint.h>
Free memory associated with this break point
Parameters:
payload | Valid breakPointPtr |
name | not used |
int breakPointLinesCount (void)
| breakPointLinesCount |
#include <src/breakpoint.h>
Return the number of hash tables of break points with the same line number
Returns: the number of hash tables of break points with the same line number
int breakPointPrint (FILE * file, breakPointPtr breakPtr)
| breakPointPrint |
#include <src/breakpoint.h>
Print the details of breakPtr
to file
Parameters:
file | Is valid, or NULL to use libxslt's error display function |
breakPoint | A valid break point |
Returns: 1 if successful, 0 otherwise
int breakPointIsPresent (const xmlChar * url, long lineNumber)
| breakPointIsPresent |
#include <src/breakpoint.h>
Determine if there is a break point at file and line number specified
Parameters:
url | Non-null, non-empty file name that has been loaded by
debugger
@lineNumber lineNumber >= 0 and is available in url specified
|
Returns: 1 if successful, 0 otherwise
int breakPointIsPresentNode (xmlNodePtr node)
| breakPointIsPresentNode |
#include <src/breakpoint.h>
Determine if a node is a break point
Parameters:
node | Is valid |
Returns: 1 on success, 0 otherwise
arrayListPtr breakPointLineList (void)
| breakPointLineList |
#include <src/breakpoint.h>
Return The list of hash tables for break points Dangerous function to use!!
Returns The list of hash tables for break points Dangerous function to use!!
typedef struct _callPointInfo callPointInfo | callPointInfo |
#include <src/callstack.h>
Provide a call stack support
typedef struct _callPoint callPoint | callPoint |
#include <src/callstack.h>
int
callStackInit (void)
| callStackInit |
#include <src/callstack.h>
void
callStackFree (void)
| callStackFree |
#include <src/callstack.h>
int callStackAdd (xsltTemplatePtr templ, xmlNodePtr source)
| callStackAdd |
#include <src/callstack.h>
Add template "call" to call stack
Parameters:
templ | The current template being applied |
source | The source node being processed |
Returns: 1 on success, 0 otherwise
void callStackDrop (void)
| callStackDrop |
#include <src/callstack.h>
Drop the topmost item off the call stack
int callStackStepup (int depth)
| callStackStepup |
#include <src/callstack.h>
Set the frame depth to step up to
Parameters:
depth | The frame depth to step up to
0 < depth <= callDepth()
|
Returns: 1 on success, 0 otherwise
int callStackStepdown (int depth)
| callStackStepdown |
#include <src/callstack.h>
Set the frame depth to step down to
Parameters:
depth | The frame depth to step down to
0 < depth <= callDepth()
|
Returns: 1 on success, 0 otherwise
callPointPtr callStackGet (int depth)
| callStackGet |
#include <src/callstack.h>
Retrieve the call point at specified call depth
Parameters:
depth | 0 < depth <= callDepth()
|
Returns: Non-null a if depth is valid, NULL otherwise
callPointPtr callStackGetTop (void)
| callStackGetTop |
#include <src/callstack.h>
Get the top item in the call stack
Returns: The top of the call stack
int callStackGetDepth (void)
| callStackGetDepth |
#include <src/callstack.h>
Returns: the depth of call stack
enum CommandsEnum { DEBUG_HELP_CMD = 100, DEBUG_BYE_CMD, DEBUG_EXIT_CMD, DEBUG_QUIT_CMD, DEBUG_STEP_CMD, DEBUG_STEPUP_CMD, DEBUG_STEPDOWN_CMD, DEBUG_NEXT_CMD, DEBUG_CONT_CMD, DEBUG_RUN_CMD, DEBUG_TEMPLATES_CMD, DEBUG_WHERE_CMD, DEBUG_FRAME_CMD, DEBUG_STYLESHEETS_CMD, DEBUG_BREAK_CMD, DEBUG_SHOWBREAK_CMD, DEBUG_DELETE_CMD, DEBUG_ENABLE_CMD, DEBUG_DISABLE_CMD, DEBUG_LS_CMD, DEBUG_DIR_CMD, DEBUG_DU_CMD, DEBUG_CAT_CMD, DEBUG_PRINT_CMD, DEBUG_PWD_CMD, DEBUG_DUMP_CMD, DEBUG_BASE_CMD, DEBUG_GLOBALS_CMD, DEBUG_LOCALS_CMD, DEBUG_SOURCE_CMD, DEBUG_DATA_CMD, DEBUG_OUTPUT_CMD, DEBUG_CD_CMD, DEBUG_ENTITIES_CMD, DEBUG_SYSTEM_CMD, DEBUG_PUBLIC_CMD, DEBUG_ENCODING_CMD, DEBUG_VALIDATE_CMD, DEBUG_LOAD_CMD, DEBUG_SAVE_CMD, DEBUG_WRITE_CMD, DEBUG_FREE_CMD, DEBUG_CHDIR_CMD, DEBUG_SHELL_EXEC_CMD, DEBUG_TTY_CMD, DEBUG_ADDPARAM_CMD, DEBUG_DELPARAM_CMD, DEBUG_SHOWPARAM_CMD, DEBUG_SETOPTION_CMD, DEBUG_OPTIONS_CMD, DEBUG_TRACE_CMD, DEBUG_WALK_CMD, DEBUG_ADDWATCH_CMD, DEBUG_DELWATCH_CMD, DEBUG_SHOWWATCH_CMD, DEBUG_SEARCH_CMD, DEBUG_SET_CMD } | CommandsEnum |
#include <src/cmds.h>
* 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. * * *************************************************************************
void debugXSLBreak (xmlNodePtr templ, xmlNodePtr node,
xsltTemplatePtr root, xsltTransformContextPtr ctxt)
| debugXSLBreak |
#include <src/debugXSL.h>
A break point has been found so pass control to user
Parameters:
templ | The source node being executed |
node | The data node being processed |
root | The template being applied to "node" |
ctxt | transform context for stylesheet being processed |
xsltTemplatePtr debugXSLGetTemplate (void)
| debugXSLGetTemplate |
#include <src/debugXSL.h>
Get the last template node found, if any
Returns: the last template node found, if any
int xslDbgShellFrameBreak (xmlChar * arg, int stepup)
| xslDbgShellFrameBreak |
#include <src/debugXSL.h>
Set a "frame" break point either up or down from here
Parameters:
arg | Is valid and in UTF-8 |
stepup | If != 1 then we step up, otherwise step down |
Returns: 1 on success, 0 otherwise
int xslDbgShellBreak (xmlChar * arg, xsltStylesheetPtr style,
xsltTransformContextPtr ctxt)
| xslDbgShellBreak |
#include <src/debugXSL.h>
Add break point specified by arg
Parameters:
arg | Is valid and in UTF-8 |
style | Is valid |
ctxt | Is valid |
Returns: 1 on success, 0 otherwise
int xslDbgShellDelete (xmlChar * arg)
| xslDbgShellDelete |
#include <src/debugXSL.h>
Delete break point specified by arg
Parameters:
arg | Is valid and in UTF-8 |
Returns: 1 on success, 0 otherwise
void xslDbgShellEnableBreakPoint (void *payload, void *data,
xmlChar * name)
| xslDbgShellEnableBreakPoint |
#include <src/debugXSL.h>
Enable/disable break points via use of scan of break points
Parameters:
payload | Is valid xslBreakPointPtr |
data | Enable type, a pointer to an integer for a value of |
name | Not used |
int xslDbgShellEnable (xmlChar * arg, int enableType)
| xslDbgShellEnable |
#include <src/debugXSL.h>
Enable/disable break point specified by arg using enable
Parameters:
arg | : is valid enable "commmand text" and in UTF-8 |
enableType | : enable break point if 1, disable if 0, toggle if -1 |
Returns: 1 if successful, 0 otherwise
void xslDbgShellPrintBreakPoint (void *payload, void *data,
xmlChar * name)
| xslDbgShellPrintBreakPoint |
#include <src/debugXSL.h>
Print data given by scan of break points
Parameters:
payload | Is valid xslBreakPointPtr |
data | Not used |
name | Not used |
void xslDbgShellValidateBreakPoint (void *payload, void *data,
xmlChar * name)
| xslDbgShellValidateBreakPoint |
#include <src/debugXSL.h>
Print an warning if a breakpoint is invalid
Parameters:
payload | Is valid xslBreakPointPtr |
data | Not used |
name | Not used |
int xslDbgShellPrintStyleSheets (xmlChar * arg)
| xslDbgShellPrintStyleSheets |
#include <src/debugXSL.h>
Print stylesheets that can be found in loaded stylsheet
Parameters:
arg | The stylesheets of interests and in UTF-8, is NULL for all stylesheets |
Returns: 1 on success, 0 otherwise
int xslDbgShellPrintTemplateNames (xsltTransformContextPtr styleCtxt,
xmlShellCtxtPtr ctxt,
xmlChar * arg, int verbose,
int allFiles)
| xslDbgShellPrintTemplateNames |
#include <src/debugXSL.h>
Print out the list of template names found that match critieria
Parameters:
styleCtxt | Is valid |
ctxt | Not used |
arg | Not used |
verbose | If 1 then print extra messages about templates found, otherwise print normal messages only |
allFiles | If 1 then look for all templates in stylsheets found in
styleCtxt
otherwise look in the stylesheet found by
debugXSLBreak function
|
Returns: 1 on success, 0 otherwise
int xslDbgShellPrintList (xmlShellCtxtPtr ctxt, xmlChar * arg, int dir)
| xslDbgShellPrintList |
#include <src/debugXSL.h>
Print list of nodes in either ls or dir format
Parameters:
ctxt | The current shell context |
arg | What xpath to display and in UTF-8 |
dir | If 1 print in dir mode, otherwise ls mode |
Returns: 1 on success, 0 otherwise
int xslDbgShellCat (xsltTransformContextPtr styleCtxt,
xmlShellCtxtPtr ctxt, xmlChar * arg)
| xslDbgShellCat |
#include <src/debugXSL.h>
Print the result of an xpath expression. This can include variables if styleCtxt is not NULL
Parameters:
styleCtxt | Current stylesheet context |
ctxt | Current shell context |
arg | The xpath to print and in UTF-8 |
Returns: 1 on success, 0 otherwise
int xslDbgShellPrintVariable (xsltTransformContextPtr styleCtxt,
xmlChar * arg, VariableTypeEnum type)
| xslDbgShellPrintVariable |
#include <src/debugXSL.h>
Print the value variable specified by args.
Parameters:
styleCtxt | The current stylesheet context |
arg | The name of variable to look for '$' prefix is optional and in UTF-8 |
type | Is valid VariableTypeEnum |
Returns: 1 on success, 0 otherwise
int xslDbgShellOutput (xmlChar *arg)
| xslDbgShellOutput |
#include <src/debugXSL.h>
xslDbgShellOutput: @arg : Is valid, either a local file name which will be expanded if needed, or a "file://" protocol URI
Set the output file name to use
Returns 1 on success, 0 otherwise
int xslDbgEntities (void)
| xslDbgEntities |
#include <src/debugXSL.h>
int xslDbgSystem (const xmlChar * arg)
| xslDbgSystem |
#include <src/debugXSL.h>
Print what a system file arg
maps to via the current xml catalog
Parameters:
arg | Is valid in UTF-8 |
Returns: 1 on sucess, 0 otherwise
int xslDbgPublic (const xmlChar * arg)
| xslDbgPublic |
#include <src/debugXSL.h>
Print what a public ID arg
maps to via the current xml catalog
Parameters:
arg | Is valid PublicID in UTF-8 |
Returns: 1 on sucess, 0 otherwise
int xslDbgEncoding (xmlChar * arg)
| xslDbgEncoding |
#include <src/debugXSL.h>
Set current encoding to use for output to standard output
Returns 1 on sucess,
Parameters:
arg | Is valid encoding supported by libxml2 |
int xslDbgShellChangeWd (xmlChar * path)
| xslDbgShellChangeWd |
#include <src/debugXSL.h>
Parameters:
path | Operating system path(directory) to change to and in UTF-8 |
Returns: 1 if able to change xsldbg working direcorty to path
0 otherwise
int xslDbgShellExecute (xmlChar * name, int verbose)
| xslDbgShellExecute |
#include <src/debugXSL.h>
Parameters:
name | The name of command string to be executed by operating system shell |
verbose | If 1 then print extra debugging messages, normal messages otherwise |
Returns: 1 if able to execute command name
,
0 otherwise
int xslDbgShellAddParam (xmlChar * arg)
| xslDbgShellAddParam |
#include <src/debugXSL.h>
int xslDbgShellDelParam (xmlChar * arg)
| xslDbgShellDelParam |
#include <src/debugXSL.h>
Delete a libxslt parameter that was to be sent to libxslt later on
Parameters:
arg | A single white space trimmed libxslt parameter number to look for |
Returns: 1 if able to delete parameter name
,
0 otherwise
int xslDbgShellShowParam (xmlChar * arg)
| xslDbgShellShowParam |
#include <src/debugXSL.h>
Print list of current paramters
Parameters:
arg | Not used |
Returns: 1 on success, 0 otherwise
int xslDbgShellSetOption (xmlChar * arg)
| xslDbgShellSetOption |
#include <src/debugXSL.h>
Set the value of an option
Parameters:
arg | is valid, and in format |
Returns: 1 on success, 0 otherwise
int xslDbgShellOptions (void)
| xslDbgShellOptions |
#include <src/debugXSL.h>
Prints out values for user options
Returns: 1 on success, 0 otherwise
int xslDbgShellShowWatches (xsltTransformContextPtr styleCtxt,
xmlShellCtxtPtr ctx,int showWarnings)
| xslDbgShellShowWatches |
#include <src/debugXSL.h>
xslDbgShellShowWatches: @styleCtxt: the current stylesheet context @ctxt: The current shell context @showWarnings : If 1 then showWarning messages, otherwise do not show warning messages
Print the current watches and their values
Returns 1 on success, 0 otherwise
int xslDbgShellAddWatch (xmlChar* arg)
| xslDbgShellAddWatch |
#include <src/debugXSL.h>
xslDbgShellAddWatch: @arg : A valid xPath of expression to watch the value of
Add expression to list of expressions to watch value of
Returns 1 on success, 0 otherwise
int xslDbgShellDeleteWatch (xmlChar* arg)
| xslDbgShellDeleteWatch |
#include <src/debugXSL.h>
xslDbgShellDeleteWatch: @arg : A watch ID to remove
Delete a given watch ID from our list of expressions to watch
Returns 1 on success, 0 otherwise
int xslDbgShellTrace (xmlChar * arg)
| xslDbgShellTrace |
#include <src/debugXSL.h>
Start the tracing of the stylesheet. First need to restart it.
Parameters:
arg | Not used |
Returns: 1 on success, 0 otherwise
int xslDbgShellWalk (xmlChar * arg)
| xslDbgShellWalk |
#include <src/debugXSL.h>
Start walking through the stylesheet.
Parameters:
arg | An interger between 0 and 9 indicate the speed of walk |
Returns: 1 on success, 0 otherwise
int xslDbgShellSearch (xsltTransformContextPtr styleCtxt,
xsltStylesheetPtr style, xmlChar * arg)
| xslDbgShellSearch |
#include <src/debugXSL.h>
Parameters:
styleCtxt | Is valid |
style | Is valid |
arg | The xpath query to use for searching dataBase |
Returns: 1 if able to run query with arg
,
0 otherwise
int xslDbgShellSetVariable (xsltTransformContextPtr styleCtxt,
xmlChar * arg)
| xslDbgShellSetVariable |
#include <src/debugXSL.h>
Change the value of a global or local variable
Parameters:
styleCtxt | Is valid |
arg | Is valid must be in the format of
|
Returns: 1 on success, 0 otherwise
typedef struct _entityInfo entityInfo | entityInfo |
#include <src/files.h>
Provide a file support
enum FilesSearchFileNameEnum { FILES_SEARCHINPUT, FILES_SEARCHXSL, FILES_SEACHRESULT } | FilesSearchFileNameEnum |
#include <src/files.h>
void filesEntityRef (xmlEntityPtr ent, xmlNodePtr firstNode,
xmlNodePtr lastNode)
| filesEntityRef |
#include <src/files.h>
Fixes the nodes from firstNode to lastNode so that debugging can occur
Parameters:
uri | Is valid as provided by libxslt |
firstNode | Is valid |
lastNode | Is Valid |
arrayListPtr filesEntityList (void)
| filesEntityList |
#include <src/files.h>
Return the list entity names used for documents loaded
Returns: The list entity names used for documents loaded
int filesSetBaseUri (xmlNodePtr node, const xmlChar * uri)
| filesSetBaseUri |
#include <src/files.h>
Set the base uri for this node. Function is used when xml file has external entities in its DTD
Parameters:
node | Is valid and has a doc parent |
uri | Is Valid |
Returns: 1 if successful, 0 otherwise
xmlChar * filesGetBaseUri (xmlNodePtr node)
| filesGetBaseUri |
#include <src/files.h>
Get a copy of the base uri for this node. Function is most usefull used when xml file has external entities in its DTD
Parameters:
node | : Is valid and has a doc parent |
Returns: The a copy of the base uri for this node, NULL otherwise
const char * filesTempFileName (int fileNumber)
| filesTempFileName |
#include <src/files.h>
Return the name of tempfile requested.
This is a platform specific interface
Returns The name of temp file to be used for temporary results if sucessful, NULL otherwise
Parameters:
fleNumber | : Number of temp file required
where fileNumber is
0 : file name used by cat command
1 : file name used by profiling output
|
int filesLoadCatalogs (void)
| filesLoadCatalogs |
#include <src/files.h>
Load the catalogs specifed by OPTIONS_CATALOG_NAMES if OPTIONS_CATALOGS is enabled
Returns: 1 if sucessful 0 otherwise
xmlChar * filesEncode (const xmlChar * text)
| filesEncode |
#include <src/files.h>
Return A string of converted @text
Returns A string of converted @text, may be NULL
Parameters:
text | Is valid, text to translate from UTF-8, |
xmlChar * filesDecode (const xmlChar * text)
| filesDecode |
#include <src/files.h>
Return A string of converted @text
Returns A string of converted @text, may be NULL
Parameters:
test | Is valid, text to translate from current encoding to UTF-8, |
int filesSetEncoding (const char *encoding)
| filesSetEncoding |
#include <src/files.h>
Opens encoding for all standard output to encoding
. If encoding
is NULL then close current encoding and use UTF-8 as output encoding
Returns 1 if successful in setting the encoding of all standard output
to encoding
0 otherwise
Parameters:
encoding | Is a valid encoding supported by the iconv library or NULL |
enum FileTypeEnum { FILES_XMLFILE_TYPE = 100, FILES_SOURCEFILE_TYPE, FILES_TEMPORARYFILE_TYPE } | FileTypeEnum |
#include <src/files.h>
int openTerminal (xmlChar * device)
| openTerminal |
#include <src/files.h>
Open communications to the terminal device device
Parameters:
device | Terminal to redirect i/o to , will not work under win32 |
Returns: 1 if sucessful 0 otherwise
void guessStylesheetName (searchInfoPtr searchInf)
| guessStylesheetName |
#include <src/files.h>
Try to find a matching stylesheet name
Sets the values in searchinf
depending on outcome of search
Parameters:
searchInf | Is valid |
xmlChar * stylePath (void)
| stylePath |
#include <src/files.h>
Return the base path for the top stylesheet ie ie URL minus the actual file name
Returns: The base path for the top stylesheet ie ie URL minus the actual file name
xmlChar * workingPath (void)
| workingPath |
#include <src/files.h>
Return the working directory as set by changeDir function
Returns: the working directory as set by changeDir function
int changeDir (const xmlChar * path)
| changeDir |
#include <src/files.h>
Change working directory to path
Parameters:
path | The operating system path(directory) to adopt as new working directory |
Returns: 1 on success, 0 otherwise
int filesLoadXmlFile (const xmlChar * path, FileTypeEnum fileType)
| filesLoadXmlFile |
#include <src/files.h>
Load specified file type, freeing any memory previously used
Parameters:
path | The xml file to load |
fileType | A valid FileTypeEnum |
Returns: 1 on success, 0 otherwise
int filesFreeXmlFile (FileTypeEnum fileType)
| filesFreeXmlFile |
#include <src/files.h>
Free memory associated with the xml file
Parameters:
fileType | : A valid FileTypeEnum |
Returns: 1 on success, 0 otherwise
xsltStylesheetPtr filesGetStylesheet (void)
| filesGetStylesheet |
#include <src/files.h>
Return the topmost stylesheet
Returns: Non-null on success, NULL otherwise
xmlDocPtr filesGetTemporaryDoc (void)
| filesGetTemporaryDoc |
#include <src/files.h>
Return the current "temporary" document
Returns: non-null on success, NULL otherwise
xmlDocPtr filesGetMainDoc (void)
| filesGetMainDoc |
#include <src/files.h>
Return the main docment
Returns: the main document
int filesReloaded (int reloaded)
| filesReloaded |
#include <src/files.h>
Parameters:
reloaded | If = -1 then ignore reloaded
otherwise change the status of files to value of reloaded
|
Returns: 1 if stylesheet or its xml data file has been "flaged" as reloaded, 0 otherwise
int filesInit (void)
| filesInit |
#include <src/files.h>
Initialize the file module
Returns: 1 on success, 0 otherwise
void filesFree (void)
| filesFree |
#include <src/files.h>
Free memory used by file related structures
int filesIsSourceFile (xmlChar * fileName)
| filesIsSourceFile |
#include <src/files.h>
Test if filename could be a stylesheet
Parameters:
fileName | Is valid |
Returns: True if @name has the ".xsl" extension
int filesMoreFile (const xmlChar * fileName, FILE * file)
| filesMoreFile |
#include <src/files.h>
Do a "more" like print of file specified by @fileName OR @file. If both are provided @file will be used. The content of file chosen must be in UTF-8, and will be printed in the current encoding selected. The function will pause output after FILES_NO_LINES lines have been printed waiting for user to enter "q" to quit or any other text to continue.
Parameters:
fileName | May be NULL |
file | May be NULL |
Returns: 1 if successful, 0 otherwise
const xmlChar * filesSearchResultsPath (void)
| filesSearchResultsPath |
#include <src/files.h>
Get the base path to be used for storing search results
Returns: The base path to be used for storing search results
xmlChar * filesURItoFileName (const xmlChar* uri)
| filesURItoFileName |
#include <src/files.h>
Return A copy of the conversion of @uri to a file name that is suitable to be used with the fopen function. May be NULL, if out of memory, @uri does not use the "file://" protocol, or unable to convert to a valid file name
Returns A copy of the conversion of @uri to a file name that is suitable to be used with the fopen function. May be NULL, if out of memory, @uri does not use the "file://" prefix, or unable to convert to a valid file name
Parameters:
uri | A valid URI that uses the "file://" prefix |
void xsldbgUpdateFileDetails (xmlNodePtr node)
| xsldbgUpdateFileDetails |
#include <src/files.h>
Update the URL and line number that we stoped at
Parameters:
node | A valid node |
int xsldbgLineNo (void)
| xsldbgLineNo |
#include <src/files.h>
What line number are we at
Returns: The current line number of xsldbg, may be -1
xmlChar * xsldbgUrl (void)
| xsldbgUrl |
#include <src/files.h>
What URL did we stop at
Returns: A NEW copy of URL stopped at. Caller must free memory for URL, may be NULL
int filesPlatformInit (void)
| filesPlatformInit |
#include <src/files.h>
Intialize the platform specific files module
This is a platform specific interface
Returns: 1 if sucessful 0 otherwise
void filesPlatformFree (void)
| filesPlatformFree |
#include <src/files.h>
Free memory used by the platform specific files module
This is a platform specific interface
xmlChar * filesExpandName (const xmlChar * fileName)
| filesExpandName |
#include <src/files.h>
Converts a fileName to an absolute path If operating system supports it a leading "~" in the fileName will be converted to the user's home path. Otherwise the same name will be returned
Returns A copy of the converted fileName
or a copy of
the fileName
as supplied. May return NULL
Parameters:
fileName | A valid fileName |
xmlChar * filesSearchFileName (FilesSearchFileNameEnum fileType)
| filesSearchFileName |
#include <src/files.h>
Return a copy of the file name to use as an argument to searching
Parameters:
fileType | Is valid |
Returns: A copy of the file name to use as an argument to searching
int helpTop (const xmlChar * args)
| helpTop |
#include <src/help.h>
Display help about the command in arg
This is a platform specific interface
Parameters:
args | Is valid or empty string |
Returns: 1 on success, 0 otherwise
typedef void (*freeItemFunc) (void *item) | (*freeItemFunc) |
#include <src/options.h>
Provide a fast easy to use array list. Support the basic functions of add delete, empty, count, free
typedef struct _arrayList arrayList | arrayList |
#include <src/options.h>
arrayListPtr arrayListNew (int initialSize,
freeItemFunc deleteFunction)
| arrayListNew |
#include <src/options.h>
Create a new list with a size of initialSize
Parameters:
initial | The initial size of list |
deleteFunction | the Function to call to free items in the list |
Returns: Non-null on success, NULL otherwise
void arrayListFree (arrayListPtr list)
| arrayListFree |
#include <src/options.h>
Free memory assocated with array list, if the array list has a valid deleteFunction then content with be freed with using that deleteFunction
Parameters:
list | A valid list |
int arrayListEmpty (arrayListPtr list)
| arrayListEmpty |
#include <src/options.h>
Empties the list of its content
Parameters:
list | A valid list |
Returns: 1 on success, 0 otherwise
int arrayListSize (arrayListPtr list)
| arrayListSize |
#include <src/options.h>
Return the maximum number elements this list can contain
Parameters:
list | A valid list |
Returns: The maximum number elements this list can contain
int arrayListCount (arrayListPtr list)
| arrayListCount |
#include <src/options.h>
Return the count of number items in list
Parameters:
list | A valid list |
Returns: The count of number items in list
int arrayListAdd (arrayListPtr list, void *item)
| arrayListAdd |
#include <src/options.h>
Add item
to list
Parameters:
list | A valid list |
item | A valid item |
Returns: 1 if able to add item
to end of list
,
0 otherwise
int arrayListDelete (arrayListPtr list, int position)
| arrayListDelete |
#include <src/options.h>
Parameters:
list | A valid list |
position | 0 =< position < arrayListCount(list )
|
Returns: 1 if able to delete element in list
at position position
,
0 otherwise
void * arrayListGet (arrayListPtr list, int position)
| arrayListGet |
#include <src/options.h>
Parameters:
list | A valid list |
position | 0 =< position < arrayListCount(list )
|
Returns: Non-null if able to retrieve element in list
at position
position
,
NULL otherwise
enum OptionsConfigState { OPTIONS_CONFIG_READVALUE = -1, OPTIONS_CONFIG_READING = 1, OPTIONS_CONFIG_WRITING, OPTIONS_CONFIG_IDLE } | OptionsConfigState |
#include <src/options.h>
The largest number lines of text can be print print printing documents This is equivant to gdb shorting of evaluation values
enum OptionsTypeEnum { OPTIONS_VERBOSE, OPTIONS_OUTPUT_FILE_NAME, OPTIONS_SOURCE_FILE_NAME, OPTIONS_DOCS_PATH, OPTIONS_CATALOG_NAMES, OPTIONS_ENCODING, OPTIONS_SEARCH_RESULTS_PATH, OPTIONS_DATA_FILE_NAME } | OptionsTypeEnum |
#include <src/options.h>
enum TraceModeEnum { TRACE_OFF = 600, TRACE_ON, TRACE_RUNNING, TRACE_FINISHED } | TraceModeEnum |
#include <src/options.h>
enum WalkSpeedEnum { WALKSPEED_0 = 0, WALKSPEED_STOP = WALKSPEED_0, WALKSPEED_1, WALKSPEED_FAST = WALKSPEED_1, WALKSPEED_2, WALKSPEED_3, WALKSPEED_4, WALKSPEED_5, WALKSPEED_NORMAL = WALKSPEED_5, WALKSPEED_6, WALKSPEED_7, WALKSPEED_8, WALKSPEED_9, WALKSPEED_SLOW = WALKSPEED_9 } | WalkSpeedEnum |
#include <src/options.h>
typedef struct _parameterItem parameterItem | parameterItem |
#include <src/options.h>
int optionsInit (void)
| optionsInit |
#include <src/options.h>
Initialized the options module
Returns: 1 on success, 0 otherwise
void optionsFree (void)
| optionsFree |
#include <src/options.h>
Free memory used by the options module
int optionsGetOptionID (xmlChar * optionName)
| optionsGetOptionID |
#include <src/options.h>
Find the option id for a given option name
Parameters:
optionName | A valid option name see documentation for "setoption" command and program usage documentation |
Returns: The optionID for @optionName if successful, where OPTIONS_XINCLUDE<= optionID <= OPTIONS_DATA_FILE_NAME, otherwise returns -1
const xmlChar * optionsGetOptionName (OptionTypeEnum ID)
| optionsGetOptionName |
#include <src/options.h>
Get the name text for an option
Returns The name of option if @ID is valid, NULL otherwise
Parameters:
ID | A valid option ID |
int optionsSetIntOption (OptionTypeEnum optionType, int value)
| optionsSetIntOption |
#include <src/options.h>
Set the value of an integer xsldbg option to value
Parameters:
optionType | Is a valid integer option |
value | Is the valid to adopt |
Returns: 1 on success, 0 otherwise
int optionsGetIntOption (OptionTypeEnum optionType)
| optionsGetIntOption |
#include <src/options.h>
Parameters:
optionType | Is a valid integer option |
Returns: The state of a integer xsldbg option
int optionsSetStringOption (OptionTypeEnum optionType,
const xmlChar * value)
| optionsSetStringOption |
#include <src/options.h>
Set value for a string xsldbg option to value
.
Any memory used currently by option optionType
will be freed
Parameters:
optionType | A valid string option |
value | The value to copy |
Returns: 1 on success, 0 otherwise
const xmlChar * optionsGetStringOption (OptionTypeEnum optionType)
| optionsGetStringOption |
#include <src/options.h>
Get value for a string xsldbg option of optionType
Parameters:
optionType | A valid string option |
Returns: current option value which may be NULL
void optionsCopyVolitleOptions (void)
| optionsCopyVolitleOptions |
#include <src/options.h>
Copy volitile options to the working area for xsldbg to be used just after xsldbg starts its processing loop
arrayListPtr optionsGetParamItemList (void)
| optionsGetParamItemList |
#include <src/options.h>
Return the list of libxlt parameters
Returns: The list of parameters to provide to libxslt when doing stylesheet transformation if successful NULL otherwise
parameterItemPtr optionsParamItemNew (const xmlChar * name,
const xmlChar * value)
| optionsParamItemNew |
#include <src/options.h>
Create a new libxslt parameter item
Parameters:
name | Is valid |
value | Is valid |
Returns: non-null if sucessful NULL otherwise
void optionsParamItemFree (parameterItemPtr item)
| optionsParamItemFree |
#include <src/options.h>
Free memory used by libxslt parameter item item
Parameters:
item | Is valid |
int optionsPrintParam (int paramId)
| optionsPrintParam |
#include <src/options.h>
Prints all items in parameter list
Returns: 1 on success, 0 otherwise
int optionsPrintParamList (void)
| optionsPrintParamList |
#include <src/options.h>
Prints all items in parameter list
Returns: 1 on success, 0 otherwise
xmlNodePtr optionsNode (OptionTypeEnum optionType)
| optionsNode |
#include <src/options.h>
Convert option into a xmlNodePtr
Parameters:
optionType | Is valid, option to convert to a xmlNodePtr |
Returns: The option optionType
as a xmlNodePtr if successful,
NULL otherwise
int optionsReadDoc (xmlDocPtr doc)
| optionsReadDoc |
#include <src/options.h>
Read options from document provided.
Parameters:
doc | Is valid xsldbg config document, in the format as indicated by config.dtd |
Returns: 1 if able to read doc
and load options found,
0 otherwise
int optionsSavetoFile (xmlChar * fileName)
| optionsSavetoFile |
#include <src/options.h>
Save configuation to file specified
@fileName : Must be NON NULL be a local file that can be written to
Returns: 1 if able to save options to @fileName, 0 otherwise
int optionsPlatformInit (void)
| optionsPlatformInit |
#include <src/options.h>
Intialize the platform specific options module
This is a platform specific interface
Returns: 1 if sucessful 0 otherwise
void optionsPlatformFree (void)
| optionsPlatformFree |
#include <src/options.h>
Free memory used by the platform specific options module
This is a platform specific interface
xmlChar * optionsConfigFileName (void)
| optionsConfigFileName |
#include <src/options.h>
Return xsldbg's the configuration file name
Returns A copy of the file name that will be used to load xsldbgs configuration from, NULL otherwise
This is a platform specific interface
int optionsLoad (void)
| optionsLoad |
#include <src/options.h>
Load options from configuration file/registry
This is a platform specific interface
Returns 1 if able to load options 0 otherwise
int optionsSave (void)
| optionsSave |
#include <src/options.h>
Save options to configuration file/registry
This is a platform specific interface
Returns 1 if able to load options 0 otherwise
int optionsConfigState (OptionsConfigState value)
| optionsConfigState |
#include <src/options.h>
Set/Get the state of configuration loading/saving. Normally only used by RISC OS
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
Parameters:
value | Is valid |
int optionsAddWatch (const xmlChar* xPath)
| optionsAddWatch |
#include <src/options.h>
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 optionsGetWatchID (const xmlChar* xPath)
| optionsGetWatchID |
#include <src/options.h>
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 optionsRemoveWatch (int watchID)
| optionsRemoveWatch |
#include <src/options.h>
optionsRemoveWatch: @watchID : A valid watchID as indicated by last optionsPrintWatches
Remove the watch with given ID from our list of expressions to watch
Returns 1 if able to remove to watch expression 0 otherwise
arrayListPtr optionsGetWatchList (void)
| optionsGetWatchList |
#include <src/options.h>
optionsGetWatchList:
Return the current list of expressions to watch
Return the current list of expressions to watch
enum SearchEnum { SEARCH_BREAKPOINT = 400, SEARCH_NODE, SEARCH_XSL, SEARCH_VARIABLE } | SearchEnum |
#include <src/search.h>
Provide a searching support
typedef struct _searchInfo searchInfo | searchInfo |
#include <src/search.h>
typedef struct _breakPointSearchData breakPointSearchData | breakPointSearchData |
#include <src/search.h>
typedef struct _nodeSearchData nodeSearchData | nodeSearchData |
#include <src/search.h>
typedef struct _variableSearchData variableSearchData | variableSearchData |
#include <src/search.h>
int searchInit (void)
| searchInit |
#include <src/search.h>
Initialize the search module
Returns: 1 if search structures have been initialized properly and all memory required has been obtained, 0 otherwise
void searchFree (void)
| searchFree |
#include <src/search.h>
Free all memory used by the search module
searchInfoPtr searchNewInfo (SearchEnum type)
| searchNewInfo |
#include <src/search.h>
Create a new search
Parameters:
type | What type of search is required |
Returns: valid search info pointer if successful NULL otherwise
void searchFreeInfo (searchInfoPtr info)
| searchFreeInfo |
#include <src/search.h>
Free memory used by info
Parameters:
info | A valid search info |
int searchEmpty (void)
| searchEmpty |
#include <src/search.h>
Empty the seach dataBase of its contents
Returns: 1 on success, 0 otherwise
xmlDocPtr searchDoc (void)
| searchDoc |
#include <src/search.h>
Return the document used for seaching ie the search dataBase
Returns: the document used for searching Dangerous function to use! Does NOT return a copy of search data so don't free it
xmlNodePtr searchRootNode (void)
| searchRootNode |
#include <src/search.h>
Get the topmost node in the search dataBase
Returns: The topmost xml node in search dataBase. Dangerous function to use! Does NOT return a copy of search root node so don't free it
int searchAdd (xmlNodePtr node)
| searchAdd |
#include <src/search.h>
Add a node to the search dataBase
Parameters:
node | Is valid |
Returns: 1 if able to add node
to top node in search dataBase,
0 otherwise
int searchSave (const xmlChar * fileName)
| searchSave |
#include <src/search.h>
Save the search dataBase to fileName
Parameters:
fileName | Valid file name |
Returns: 1 on success, 0 otherwise
int searchQuery (const xmlChar * tempFile, const xmlChar * outputFile,
const xmlChar * query)
| searchQuery |
#include <src/search.h>
Send query as parameter for execution of search.xsl using
data stored in tempFile
Parameters:
query | The Query to run. If NULL then query defaults to "//search/ *"
|
tempFile | Where do we load the search dataBase from to execute
query. If tempFile is NULL default is "search.data"
|
outputFile | Where do we store the result. If NULL then default to "searchresult.html" |
Returns: 1 on success, 0 otherwise
int updateSearchData (xsltTransformContextPtr styleCtxt,
xsltStylesheetPtr style,
void *data, VariableTypeEnum variableTypes)
| updateSearchData |
#include <src/search.h>
Update the search dataBase
Parameters:
styleCtxt | Not used |
style | Is valid |
data | Not used but MUST be NULL for the moment |
variableTypes | What types of variables to look |
Returns: 1 if able to update the search dataBase, 0 otherwise
void scanForBreakPoint (void *payload, void *data, xmlChar * name)
| scanForBreakPoint |
#include <src/search.h>
Test if break point matches criteria given by data
. If so then
set data
->found to 1 and stores reference to break point found in
data
->data->node
otherwise data
is unchanged
Parameters:
payload | A valid breakPointPtr |
data | The criteria to look for and a valid searchInfoPtr of type SEARCH_BREAKPOINT |
name | Not used |
void scanForNode (void *payload, void *data, xmlChar * name)
| scanForNode |
#include <src/search.h>
Test if node matches criteria given by data
if so then
set data
->found to 1 and stores reference to node found in
data
->data->node.
otherwise data
is unchanged
Parameters:
payload | A valid xmlNodePtr |
data | The criteria to look for and a valid searchInfo of type SEARCH_NODE |
name | Not used |
xmlNodePtr findNodeByLineNo (xsltTransformContextPtr ctxt,
const xmlChar * url, long lineNumber)
| findNodeByLineNo |
#include <src/search.h>
Find the closest line number in file specified that can be a point
Parameters:
ctxt | Valid ctxt to look into |
url | Non-null, non-empty file name that has been loaded by debugger |
lineNumber | lineNumber >= 0 and is available in url
|
Returns: The node at line number specified if successful, NULL otherwise
xmlNodePtr findTemplateNode (xsltStylesheetPtr style,
const xmlChar * name)
| findTemplateNode |
#include <src/search.h>
Find a template node
Parameters:
style | A Valid stylesheet collection to look into |
name | Valid template name to look for |
Returns: The template node found if successful, NULL otherwise
breakPointPtr findBreakPointByName (const xmlChar * templateName)
| findBreakPointByName |
#include <src/search.h>
Find the breakpoint at template with "match" or "name" equal to templateName
Parameters:
templateName | Valid template name to look for |
Returns: The break point that matches templateName
NULL otherwise
breakPointPtr findBreakPointById (int id)
| findBreakPointById |
#include <src/search.h>
Find a break point by its id
Parameters:
id | The break point id to look for |
Returns: The break point with given the break point id if found, NULL otherwise
xmlXPathObjectPtr findNodesByQuery (const xmlChar * query)
| findNodesByQuery |
#include <src/search.h>
Find nodes in search dataBase using an xpath query
Parameters:
query | The xpath query to run, see docs/en/search.dtd for more details |
Returns: The nodes that match the given query on success, NULL otherwise
void walkBreakPoints (xmlHashScanner walkFunc, void *data)
| walkBreakPoints |
#include <src/search.h>
Walks through all break points calling walkFunc for each. The payload sent to walkFunc is of type breakPointPtr
Parameters:
walkFunc | The function to callback for each break point found |
data | The extra data to pass onto walkFunc
|
void walkTemplates (xmlHashScanner walkFunc, void *data,
xsltStylesheetPtr style)
| walkTemplates |
#include <src/search.h>
Walks through all templates found in style
calling walkFunc for each.
The payload of walkFunc is of type xsltTemplatePtr
Parameters:
walkFunc | The function to callback for each template found |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkStylesheets (xmlHashScanner walkFunc, void *data,
xsltStylesheetPtr style)
| walkStylesheets |
#include <src/search.h>
Walks through all stylesheets found in style
calling walkFunc for
each. The payload sent to walkFunc is of type xsltStylesheetPtr
Parameters:
walkFunc | The function to callback for each stylesheet found |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkGlobals (xmlHashScanner walkFunc,
void *data, xsltStylesheetPtr style)
| walkGlobals |
#include <src/search.h>
Call walkFunc for each global variable found in style
. The payload
sent to walkFunc is of type xmlNodePtr
Parameters:
walkFunc | The function to callback for each gobal variable found |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkLocals (xmlHashScanner walkFunc, void *data,
xsltStylesheetPtr style)
| walkLocals |
#include <src/search.h>
Walks through all local variables found in style
calling
walkFunc for each. The payload of walkFunc is of type xmlNodePtr
Parameters:
walkFunc | The function to callback for each local variable found |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkIncludes (xmlHashScanner walkFunc, void *data,
xsltStylesheetPtr style)
| walkIncludes |
#include <src/search.h>
Walks through all included stylesheets found in style
,
calling walkFunc for each. The payload of walkFunc is of
type xmlNodePtr
Parameters:
walkFunc | The function to callback for each included stylesheet |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkIncludeInst (xmlHashScanner walkFunc, void *data,
xsltStylesheetPtr style)
| walkIncludeInst |
#include <src/search.h>
Walks through all xsl:include calling walkFunc for each. The payload of walkFunc is of type xmlNodePtr
Parameters:
walkFunc | The function to callback for each xsl:include instruction found |
data | The extra data to pass onto walkFunc
|
style | The stylesheet to start from |
void walkChildNodes (xmlHashScanner walkFunc, void *data,
xmlNodePtr node)
| walkChildNodes |
#include <src/search.h>
Call walkFunc for each child of node
the payload sent to walkFunc is
a xmlNodePtr
Parameters:
walkFunc | The function to callback for each child/sibling found |
data | The extra data to pass onto walkFunc
|
node | Valid xmlNodePtr |
xmlNodePtr searchBreakPointNode (breakPointPtr breakPtr)
| searchBreakPointNode |
#include <src/search.h>
Convert breakPtr
into search dataBase format
Parameters:
breakPtr | Is valid |
Returns: breakPtr
as a new xmlNode in search dataBase format
if successful,
NULL otherwise
xmlNodePtr searchTemplateNode (xmlNodePtr templNode)
| searchTemplateNode |
#include <src/search.h>
Convert templateNode
into search dataBase format
Parameters:
templNode | A valid template node |
Returns: templNode
as a new xmlNode in search dataBase format
if successful,
NULL otherwise
xmlNodePtr searchGlobalNode (xmlNodePtr globalVariable)
| searchGlobalNode |
#include <src/search.h>
Convert globalVariable
into search dataBase format
Parameters:
globalVariable | A valid xmlNodePtr node |
Returns: globalVariable
as a new xmlNode in search dataBase
format if successful,
NULL otherwise
xmlNodePtr searchLocalNode (xmlNodePtr localVariable)
| searchLocalNode |
#include <src/search.h>
Convert localVariable
into search dataBase format
Parameters:
localVariable | Is valid |
Returns: localVariable
as a new xmlNode in search dataBase
format if successful,
NULL otherwise
xmlNodePtr searchSourceNode (xsltStylesheetPtr style)
| searchSourceNode |
#include <src/search.h>
Convert style
into search dataBase format
Parameters:
style | Is valid |
Returns: style
as a new xmlNode in search dataBase format if successful,
NULL otherwise
xmlNodePtr searchIncludeNode (xmlNodePtr include)
| searchIncludeNode |
#include <src/search.h>
Convert include
into search dataBase format
Parameters:
include | Is a valid xsl:include instruction |
Returns: include
as a new xmlNode in search dataBase format
if successful,
NULL otherwise
xmlNodePtr searchCallStackNode (callPointPtr callStackItem)
| searchCallStackNode |
#include <src/search.h>
Convert include
into search dataBase format
Parameters:
callStackItem | Is valid |
Returns: callStackItem
as a new xmlNode in search dataBase
format if successful,
NULL otherwise
xmlNodePtr searchCommentNode (xmlNodePtr node)
| searchCommentNode |
#include <src/search.h>
Find documentation comment that applies to sourceNode
. If found convert comment
into search dataBase format required
Returns Documentation comment for @node as a new xmlNode in search dataBase format if successful, NULL otherwise
Parameters:
node | Is valid |
int trimString (xmlChar * text)
| trimString |
#include <src/utils.h>
Remove leading and trailing spaces off text
stores result back into text
Parameters:
text | A valid string with leading or trailing spaces |
Returns: 1 on success, 0 otherwise
int splitString (xmlChar * textIn, int maxStrings, xmlChar ** out)
| splitString |
#include <src/utils.h>
Spit string by white space and put into out
Parameters:
textIn | The string to split |
maxStrings | The max number of strings to put into out
|
out | Is valid and at least the size of maxStrings
|
Returns: 1 on success, 0 otherwise
int lookupName (xmlChar * name, xmlChar ** matchList)
| lookupName |
#include <src/utils.h>
Lookup and name in a list
Parameters:
name | Is valid |
matchList | A NULL terminated list of names to use as lookup table |
Returns: The id of name found in matchList
0 otherwise
xmlChar * fullQName (const xmlChar* nameURI, const xmlChar * name)
| fullQName |
#include <src/utils.h>
Join nameURI to name
fullQName:
Parameters:
nameURI | : QName part of name |
name | : Local part of name |
Returns: a copy of "nameURI:name"
xsltStylesheetPtr xsldbgLoadStylesheet (void)
| xsldbgLoadStylesheet |
#include <src/xsldbg.h>
Load the stylesheet and return it
Returns: The stylesheet after reloading it if successful NULL otherwise
xmlDocPtr xsldbgLoadXmlData (void)
| xsldbgLoadXmlData |
#include <src/xsldbg.h>
Load the xml data file and return it
Returns: The stylesheet after reloading it if successful NULL otherwise
xmlDocPtr xsldbgLoadXmlTemporary (const xmlChar * path)
| xsldbgLoadXmlTemporary |
#include <src/xsldbg.h>
Load the temporary data file and return it
Parameters:
path | The name of temporary file to loa |
Returns: The temporary file after reloading it if successful, NULL otherwise
Generated by: keith on crevasse on Sun Jun 29 13:44:41 2003, using kdoc 2.0a54. |