Globals


Annotated List
Files
Globals
Hierarchy
Index

src/arraylist.h

src/breakpoint.h

src/callstack.h

src/cmds.h

src/debugXSL.h

src/files.h

src/help.h

src/options.h

src/search.h

src/utils.h

src/xsldbg.h

Global member Documentation

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:
initialThe initial size of list
deleteFunctionthe 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:
listA valid list

int  arrayListEmpty (arrayListPtr list)

arrayListEmpty

#include <src/arraylist.h>

Empties the list of its content

Parameters:
listA 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:
listA 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:
listA 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:
listA valid list
itemA 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:
listA valid list
position0 =< 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:
listA valid list
position0 =< 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>

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:
breakPointIs 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:
urlNon-null, non-empty file name that has been loaded by debugger
lineNumberlineNumber >= 0 and is available in url specified and points to an xml element
temlateNameThe template name of break point or NULL
modeName: The mode of breakpoint or NULL
typeValid 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:
breakPointIs 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:
breakPointA valid breakpoint
enableEnable 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:
urlNon-null, non-empty file name that has been loaded by debugger
lineNumberlineNumber >= 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:
payloadValid breakPointPtr
namenot 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:
fileIs valid, or NULL to use libxslt's error display function
breakPointA 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:
urlNon-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:
nodeIs 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:
templThe current template being applied
sourceThe 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:
depthThe 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:
depthThe 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:
depth0 < 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:
templThe source node being executed
nodeThe data node being processed
rootThe template being applied to "node"
ctxttransform 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:
argIs valid and in UTF-8
stepupIf != 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:
argIs valid and in UTF-8
styleIs valid
ctxtIs valid

Returns: 1 on success, 0 otherwise

int  xslDbgShellDelete (xmlChar * arg)

xslDbgShellDelete

#include <src/debugXSL.h>

Delete break point specified by arg

Parameters:
argIs 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:
payloadIs valid xslBreakPointPtr
dataEnable type, a pointer to an integer for a value of
nameNot 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:
payloadIs valid xslBreakPointPtr
dataNot used
nameNot used

void  xslDbgShellValidateBreakPoint (void *payload, void *data, xmlChar * name)

xslDbgShellValidateBreakPoint

#include <src/debugXSL.h>

Print an warning if a breakpoint is invalid

Parameters:
payloadIs valid xslBreakPointPtr
dataNot used
nameNot used

int  xslDbgShellPrintStyleSheets (xmlChar * arg)

xslDbgShellPrintStyleSheets

#include <src/debugXSL.h>

Print stylesheets that can be found in loaded stylsheet

Parameters:
argThe 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:
styleCtxtIs valid
ctxtNot used
argNot used
verboseIf 1 then print extra messages about templates found, otherwise print normal messages only
allFilesIf 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:
ctxtThe current shell context
argWhat xpath to display and in UTF-8
dirIf 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:
styleCtxtCurrent stylesheet context
ctxtCurrent shell context
argThe 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:
styleCtxtThe current stylesheet context
argThe name of variable to look for '$' prefix is optional and in UTF-8
typeIs 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:
argIs 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:
argIs 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:
argIs valid encoding supported by libxml2

int  xslDbgShellChangeWd (xmlChar * path)

xslDbgShellChangeWd

#include <src/debugXSL.h>

Parameters:
pathOperating 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:
nameThe name of command string to be executed by operating system shell
verboseIf 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:
argA 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:
argNot used

Returns: 1 on success, 0 otherwise

int  xslDbgShellSetOption (xmlChar * arg)

xslDbgShellSetOption

#include <src/debugXSL.h>

Set the value of an option

Parameters:
argis 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:
argNot used

Returns: 1 on success, 0 otherwise

int  xslDbgShellWalk (xmlChar * arg)

xslDbgShellWalk

#include <src/debugXSL.h>

Start walking through the stylesheet.

Parameters:
argAn 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:
styleCtxtIs valid
styleIs valid
argThe 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:
styleCtxtIs valid
argIs 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:
uriIs valid as provided by libxslt
firstNodeIs valid
lastNodeIs 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:
nodeIs valid and has a doc parent
uriIs 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:
textIs 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:
testIs 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:
encodingIs 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:
deviceTerminal 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:
searchInfIs 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:
pathThe 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:
pathThe xml file to load
fileTypeA 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:
reloadedIf = -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:
fileNameIs 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:
fileNameMay be NULL
fileMay 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:
uriA 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:
nodeA 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:
fileNameA 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:
fileTypeIs 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:
argsIs valid or empty string

Returns: 1 on success, 0 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:
optionNameA 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:
IDA 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:
optionTypeIs a valid integer option
valueIs the valid to adopt

Returns: 1 on success, 0 otherwise

int  optionsGetIntOption (OptionTypeEnum optionType)

optionsGetIntOption

#include <src/options.h>

Parameters:
optionTypeIs 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:
optionTypeA valid string option
valueThe 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:
optionTypeA 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:
nameIs valid
valueIs 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:
itemIs 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:
optionTypeIs 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:
docIs 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:
valueIs 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 ()

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:
typeWhat 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:
infoA 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:
nodeIs 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:
fileNameValid 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:
queryThe Query to run. If NULL then query defaults to "//search/ *"
tempFileWhere do we load the search dataBase from to execute query. If tempFile is NULL default is "search.data"
outputFileWhere 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:
styleCtxtNot used
styleIs valid
dataNot used but MUST be NULL for the moment
variableTypesWhat 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:
payloadA valid breakPointPtr
dataThe criteria to look for and a valid searchInfoPtr of type SEARCH_BREAKPOINT
nameNot 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:
payloadA valid xmlNodePtr
dataThe criteria to look for and a valid searchInfo of type SEARCH_NODE
nameNot 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:
ctxtValid ctxt to look into
urlNon-null, non-empty file name that has been loaded by debugger
lineNumberlineNumber >= 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:
styleA Valid stylesheet collection to look into
nameValid 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:
templateNameValid 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:
idThe 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:
queryThe 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:
walkFuncThe function to callback for each break point found
dataThe 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:
walkFuncThe function to callback for each template found
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each stylesheet found
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each gobal variable found
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each local variable found
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each included stylesheet
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each xsl:include instruction found
dataThe extra data to pass onto walkFunc
styleThe 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:
walkFuncThe function to callback for each child/sibling found
dataThe extra data to pass onto walkFunc
nodeValid xmlNodePtr

xmlNodePtr  searchBreakPointNode (breakPointPtr breakPtr)

searchBreakPointNode

#include <src/search.h>

Convert breakPtr into search dataBase format

Parameters:
breakPtrIs 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:
templNodeA 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:
globalVariableA 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:
localVariableIs 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:
styleIs 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:
includeIs 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:
callStackItemIs 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:
nodeIs valid

int  trimString (xmlChar * text)

trimString

#include <src/utils.h>

Remove leading and trailing spaces off text stores result back into text

Parameters:
textA 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:
textInThe string to split
maxStringsThe max number of strings to put into out
outIs 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:
nameIs valid
matchListA 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:
pathThe name of temporary file to loa

Returns: The temporary file after reloading it if successful, NULL otherwise


Generated by: keith on linux on Thu Aug 1 20:53:44 2002, using kdoc 2.0a53.