jBASE - DEBUG Options

Command List

?
Display a help screen showing all available debug commands and the program status.

>filename
Open and truncate the file filename and send it the current breakpoints and trace table entries. This can be used in future to replicate the current environment by the use of the command. note that you may write debugger scripts yourself with an editor rather than use the > command.

<filename

Open the file filename, then read and execute each line as if it has been entered at the keyboard. Any current trace or breakpoint table entries are deleted then replaced by those recorded in filename.

!command
Spawn another process and execute the command. The previous command thus used can also be recalled and executed by the !! command.

<Ctrl>+D
Display the next 11 lines of source in the current file.

Nn
Set the current display line to line nn in the current file and then display the line. Note that the program execution counter remains unchanged, it is only the display pointer that is changed. A command such as s (see later) will correctly execute the next line in the programmed sequence, not the newly displayed line.

#text
Ignored, and so can be used as a comment line in debugger scripts later executed with the command.


a{-nn} {mm}
Kills the jBC program and any parent process or program that called it. The program aborts with an exit code of 203, and the kill signal is sent to any parent process. The nn value is used to change the exit code, whilst the mm value changes the signal number sent with the kill command. Operation of this command can be altered by setting the Command Level Restart option - see the Systems Housekeeping chapter of the System Administrators Reference Manual for more details.

b
Display all currently active breakpoints.

b {-t} nn{,file}
Set a breakpoint at line nn in the current file or that specified by the file modifier. If the -t option is specified then the breakpoint will cause a display of all the trace variables rather than halting the program.

b {-t} varname
This form of the b command will cause the debugger to be entered whenever the contents of the specified variable are changed.

b {-t} ex1 op ex2 {AND|OR .....}
Set a breakpoint at the line whose value is obtained by performing the operation op on expressions ex1 and ex2. The operator can be one of eq, !=, <>equal is also available. See later for a full description of expressions. The -t option will cause the debugger to display all the trace points rather than halting program execution.

c
Continue execution of the program.

d {-tbed} {*nn}
Delete breakpoint and/or trace table entries, and will normally prompt for confirmation. The t and b switches refer to trace and breakpoints respectively. The * switch deletes all of the specified entries without prompting. The nn switch deletes the entry nn in the given trace or breakpoint table, also without prompting. The d and e switches respectively disable or enable the given entry without removing it from the table.

e name
Edit the file specified by name. This file is then the file used by other debug commands such as <Ctrl>+D.

end
Synonym for 'quit'.

f {on|off}
A debug breakpoint is set for a filename change. This break can be set to on or off. If the program is continued (C command) the debugger will be entered the next time the source file changes.

h {-rs{n}} {nn|on|off }
Displays a history of the source lines executed, and current status of the debugger commands used. The on and off switches toggle the recording of lines executed, and when on, the nn value gives the number of executed lines to display (1024 maximum). The -r switch displays in reverse order, and -s{n} shows n source lines.

j {-g}
The j command displays a complete history of both GOSUB and external subroutine calls. When issued without options the command will only display information about the current program or subroutine. The -g (global) option will show a breakdown of the entire application.

l {-acf{nn}} text
Locate the string text in the current file. The switches used are: a to look for every occurrence; c to make the search case insensitive; nn to limit the search to the next nn lines; f to start the search from the start of the file. The command l/ will execute the previous locate.

m
Displays the current memory status. Shows space allocated by the function malloc().

n {nn}
Displays the next nn lines of source from the current file, which is automatically loaded by the debugger if the p command has been used or it resides in the current working directory.

off
Enter o or off to log off. If you enter off (or OFF), the effect is immediate. If you enter o (or O), you will be prompted for confirmation. The same restrictions apply as for the OFF command; if there are non-jBASE programs active, OFF will only terminate jBASE programs until it encounters the first non-jBASE program - probably the login shell.

p {pathlist}
Defines the list of directories and pathnames (delimited by that the debugger will then search to find source codes. p without a pathlist displays the current Path.

q {nn}
Quit the program. nn is the termination status returned to any calling program.

r device
The debugger will take all input from, and send all output to, the specified device. Note that if the device is another terminal (or Xterm shell), that you will need to prevent the target shell from interfering with the input stream by issuing the sleep command to it. A large value should be used or the sleep should be issued repeatedly in a loop.

s {-t{m}d} {nn}
Continue execution of jBC code in single line steps before returning to debug. The value nn changes the number of lines executed before returning to debug. The -t switch is used to display the trace table after every line executed, rather than wait for entry to debug. The d switch sets a delay before executing each line of code. m is used to set the delay in seconds (default is 5 deci-seconds).

S {-t{m}d} {nn}
Same as s except this will 'step over' subroutine calls, the code within the subroutine will not be displayed.

t
Display the current trace table.

t {-fg} expr
Add the value specified by expr to the trace table. When debug is entered, all the values in the table are displayed. The f switch is used to fully evaluate expr, whilst the g switch extends the display of expr to all levels.

v {-gmsrv} {expr}
Evaluate expr and display the result. The effects of the switches are: g to extend the display of expr to all data areas. m to allow variable modification within expr. When a variable is modified with the m option binary characters may be entered using the octal sequence
nn. The sequence
ne immediately without asking for confirmation.

d -bd
The d switch is used to disable the entries referred to. In this case, all of the breakpoints are disabled. As a result the execution of the code will continue as if there were no breakpoints set. The complementary e switch can be used to re-enable the entries.

d *
This deletes all trace and breakpoint table entries without asking for confirmation. Care should be taken with this, as the system generated t0 entry is also deleted.

d -t 4
This command deletes the fourth entry, t4, in the variable trace table. No confirmation is asked for, and the later entries do not shuffle up the table, i.e. entry t5 will remain as t5.

d -b 2
This deletes the second entry in the breakpoint table. No confirmation is asked for.

d -b *
This will delete all the breakpoint table entries without asking for confirmation.



Execution History

h {-rs{n}}{nn|on|off}

-r display lines in reverse order
-s display n lines of source (default is 1)
nn limit the history buffer to nn lines of source
on/off toggle the saving of source lines executed

This command keeps track of the source command lines executed during a debug session. The last 1024 lines are held in a circular buffer, and when full, the most recent command line displaces the oldest. It can be toggled on or off, and it is normally switched off by default. The command and switches have no effect unless activated by switching on. Commands executed from subroutines and CHAINed programs will also be displayed.

h on
This will switch on the command line audit, and every line of code subsequently executed during the debug session will be logged for reference, until the command is switched off or the debug session ends. The following commands assume the command line history is switched on.

h 20
This sets the number of lines of code to display at 20 lines. The default, and maximum value is 1024.

h
Used in its simplest form, the command displays all the entries in the buffer to the maximum number set.

h -s3
This displays the last three lines of code executed.

h -rs10
The last 10 lines of code executed are displayed in reverse order, i.e. the command last executed is shown first.

h off
This switches off the history trace.



Locating Strings
l{-acf}{nn}text

-a show all occurrences (defaults to the first occurrence)
-c ignore the case of any text
-f start the search from the first line of the source
-nn limit the search to the next nn lines of source
text text to locate

This command locates text in the source file currently being executed and displays the line or lines of code containing it. The file to be searched may be changed by using other debug commands such as e.

l Heading
Used in its simplest form, the command will search the source from the current line position, to the end of the file, for the first occurrence of the text 'Heading'. If an exact match is found, then the line is displayed.

l -c Heading
The -c switch is used to ignore the case of the text. In this case, the first line found with the 'Heading' text in any variety of upper and lower case letters will be displayed.

l -a NAME
The -a switch is used to locate and display ALL the source lines containing the text 'NAME' in upper case letters only.

l -ac name
This command will display all lines of source code that contain the text name, with the characters being in any combination of upper or lower case letters.

l -a22 NAME
The characters NAME will be searched for, and if located in the next 22 lines starting from the current one, each line where it is found will be displayed.

l -f INVOICE.b NAME
The -f switch is used to search from the beginning and display the first line found containing the characters NAME from the file INVOICE.b held in the /usr/tutor/BP directory.

l -acf ./PAYMENTS.b money
The most complex form of the command as shown will search the PAYMENTS.b source, held in the current directory, and display every line from it that has the text money in any variation of upper or lower case letters.



Execution - Single Stepping

s{-tcgd{n}}{nn}

-t display trace table after each source line executed
-c only count the lines of source in the same CALL level
-g only count the lines of source in the same GOSUB level
-d{n} enter a delay in increments of 100 milliseconds between executing lines of source. This is incremented by the n value entered.
nn execute the next nn lines of source before re-entering debug

This command is used to execute the program in steps and to re-enter debug after the execution of a given number of lines of code. Traced variables are displayed after debug is re-entered, and any screen display within the executed code is shown as normal.

s
The simplest form of the command executes the next line of the code and then re-enters debug.

s -t
The next line of code is executed and the contents of all entries in the trace table are shown.

s -t4
The next four lines of code are executed displaying the trace table entries before re-entering debug.

s 20
This command executes the next 20 lines of code before re-entering debug.

s -td5 200
The command executes the next 200 lines of code. The -d switch sets a delay in increments of 100 milliseconds between each line executed. The 5 denotes that a 500 millisecond, or half second delay is set before executing the next line. The default value is 1, or 100 milliseconds. The -t switch ensures that the trace commands are shown after the execution of every line. While this process is continuing, debug can be entered by breaking into the program as normal. This is a very useful command to use when a run-time error occurs in a program, and the area of code responsible needs to be found quickly. With the -d switch set, it is also possible to speed up or slow down the execution of the code if the initial value chosen is too fast or slow. This is done by entering a number from the keyboard in the range 0-9, which alters the delay to the given number of 100 milliseconds increments.

s -d3t 500
The command will execute the next 500 lines of code with a delay factor of 300 milliseconds between each line. The speed of execution can be increased or decreased by pressing the numbers 0-9 on the keyboard during execution. In addition to this, the -t switch means that the contents of the variables trace table will be displayed after every line of code executed.



Display Variable

V{-gvmrs}
V ANS
The simplest form of the command will display the contents of the variable next to the variable name, in this case ANS. This will only produce a display if the source is at level 1, or in the home directory. If the variable has not been assigned, the value (NULL) is displayed. If the value assigned happens to be null, however, then a blank (null) will be displayed next to the variable name.

v -g ANS
If the variable in question resides in a different data area to the local level (COMMON or NAMED COMMON), then the -g switch should be used to display the variable contents. This extends the display of the variable to data levels, and is particularly useful when executing a subroutine in a sub-directory or library.

v -m ANS
The -m switch displays the variable and contents, but in addition allows the user to modify the contents. An equal sign is shown after the variable contents, and any characters or numbers entered followed by a carriage return are taken to be the new value of the variable. Entering a carriage return leaves the variable contents unchanged. The character sequence
nn is replaced by the binary character defined by the octal number nnn. Therefore the sequence 376 would be
replaced by a field mark.

v -gv ANS
This command displays the value held in variable ANS no matter what the current level of the source. In addition, the -v switch shows the type of variable (string or numeric), its memory location, and size.

v -r NAME
This command displays the contents of the variable NAME at the start of the next line. The -r switch provides a raw character view of the variable name and value.

v -s NAME
The -s switch shows a short view of the variable being the first 128 bytes.
The * and ? characters can also be used within the variable name as wild card characters. The ? denoting a single occurrence of any character, and the * denoting any number of occurrences of any character.

Examples:

v A* displays all variables beginning with the letter A
v A??? displays all four letter variables beginning with the letter A
v *-INV displays all variables ending with the characters -INV
v *ENP* displays all variables with the characters ENP within their name
v LIS(2,*) displays every element in the second row of the dimensioned array LIS

U can also see this in jBASE website..
_________________
King Arthur

Hi,

Does any one have complete help for jBASE debug?
_________________
M A L A I