NAME

decladebug − Invokes the command-line interface to the DECladebug sourcecode- and machine-level symbolic debugger. 

SYNOPSIS

decladebug [-I dir ] [-c file ]
 [-prompt string] executable_file core_file
 [-rn node_or_address [,udp_port]]
 [-pid process_id]
 [-rfn arbitrary_string]  [-rinsist]

DESCRIPTION

The DECladebug debugger debugs programs compiled by the DEC Ada, C, C++, COBOL, and Fortran 90 and Fortran 77 compilers. Pascal is not supported, but the debugger will step through a Pascal routine and return to the calling program. 

For full source-level debugging capability, compile the source code with the compiler option that includes the symbol table information in the compiled executable file. Limited debugging capability is available for executables that do not have symbol table information. 

You can control program execution, specify when the debugger should take control from the target program, and examine the program state. 

The debugger displays target program source listings if the source files are located in the current directory or a directory specified with the -I option to the decladebug command or the use debugger command. 

To leave the debugger, enter the quit command. 

To debug a core file, specify the executable file and the core file when invoking the debugger. You can examine the program stack trace and program variables at the instant the system encountered the irrecoverable error. 

To debug programs running on remote systems, specify the options -rn, -pid, -rfn, or -rinsist. 

Options

executable_fileSpecifies the program executable file. If the file is not in the current directory, specify the pathname. 

core_fileSpecifies the core file. If the core file is not in the current directory, specify the pathname. 

-ISpecifies the directory containing the source code for the target program.  Use multiple -I options to specify more than one directory. The debugger searches directories in the order in which they were specified on the command line. 

-cSpecifies an initialization command file. The default initialization file is .dbxinit. 

-promptSpecifies a debugger prompt.  The default debugger prompt is (decladebug).  If the prompt argument contains spaces or special characters, enclose the argument in quotes. 

-rnSpecifies the internet node name or IP address of the node on which the remote debugger server is running.  Optionally specifies the UDP port that connects to the port. 

-pidSpecifies the process id of the process to be debugged. 

-rfnSpecifies the file name (or other identifier) of the image to be loaded on the remote system.  This option defaults to the the local object file name and is passed to the remote system uninterrupted.  When using this option, use quotation marks to avoid shell command line interpretation on the local system.  Use only with -rn; do not combine with -pid. 

-rinsistConnects to a running remote process using the insist protocol message instead of the connect protocol message.  This option functions as a request to the server to connect to the client, even if another client is already connected.  Use only with -rn and -pid. 

Commands

Enter DECladebug commands at the debugger prompt. 

You can enter more than one command on the same line by separating each command with a semicolon. Commands are executed in the same order in which they are entered in the command line. 

Continue command input to another line by entering a backslash at the end of each line. The maximum command-line length is 255 characters. 

The following table lists the DECladebug commands, and groups them in functionally related sets:

#
Enter a comment.

alias, unalias
Define, view, or delete a debugger command alias.

attach, detach
Attach or detach from a running process.

catch, ignore
Examine and change the list of operating system signals trapped by the debugger.

history, !
Repeat and list previously used commands.

list, use, unuse, file, /, ?
Select and view program source code.

listobj
Display the names of shared libraries.

load, unload
Loads or unloads an image file and optionally, a core file.

stopi, tracei, wheni, nexti, stepi, printreqs
Machine-code level commands.

print, printf, dump, assign, whatis, which, whereis
Examine program expressions and change their values.

quit, help
Exit and get help about the debugger.

run, rerun, cont, next, step, return, call, goto, kill
Execute a program under debugger control.

sh
Execute a Bourne shell command.

set, unset
Define, view, or delete a debugger variable.

source, playback, input, record input, record output, record io
Read in or save a file containing debugger input data or output data.

stop, when, trace, status, delete, enable, disable
Set, list, delete, enable, and disable program breakpoints and tracepoints.

stop thread, when thread, wheni thread, trace thread, tracei thread
Controls execution of one or more threads in a process.

set thread state
Modifies thread state information.

thread, show thread, show condition, show mutex
View information available from the debugger about threads in your application.

where, up, down, func
Examine the stack trace and change the function scope.

class
Change or display the class scope.

Command Descriptions

startaddress , endaddress / mode startaddress / count mode

You can display stored values as character strings, machine instructions, or decimal, octal, hexadecimal, or real numbers. Specify the address and the number of words or bytes (count) information in hexadecimal, octal, or decimal. The display mode must be specified along with the address range. The modes are:

dPrint a short word in decimal

DPrint a long word in decimal

oPrint a short word in octal

OPrint a long word in octal

xPrint a short word in hexadecimal

XPrint a long word in hexadecimal

bPrint a byte in octal

cPrint a byte as a character

sPrint a string of characters (a C-style string that ends in null)

fPrint a single-precision real number

gPrint a double-precision real number

iDisassemble machine instructions

# comment

When the debugger encounters the # command, it ignores all inputs until the end of the line. The # command must be the first identifier on the command line. (White space may precede the # command.) 

!! or ![-]integer or !text

To repeat the last command line, enter two exclamation points (!!) or press the Return key. You can also enter !-1. 

To repeat a command line entered during the current debugging session, enter an exclamation point followed by the integer associated with the command line.  (Use the history command to see a list of commands used.) For example, to repeat the seventh command used in the current debugging session, enter !7.  Enter !-3 to repeat the third-to-last command. 

To repeat the most recent command starting with a string, use the last form of the command. For example, to repeat a command that started with bp, enter !bp. 

/ [string] or ? [string]

Use the string search commands / and ? to locate text in the source code. The / character invokes a forward search; the ? character invokes a backwards search. Enter / or ? without an argument to find the next location of the previously specified text. 

The search begins from the current position of the program counter. If no program counter exists for the current source file, the search begins after the last source line displayed by the debugger. 

alias [aliasname ] alias aliasname [(argument)] "[aliasname] string" unalias aliasname

Enter the alias command without an argument to display all aliases and their definitions.  Specify an alias name to display the definition for that alias. 

Use the second form to define a new alias or to redefine an existing alias. The definition can contain the name of another alias, if the nested alias is the first identifier in the definition. Invoke the alias by entering the alias name, including an argument if the alias definition specified an argument. 

The following example defines a nested alias and invokes the alias: (decladebug)alias begin "stop in main; run" (decladebug)alias pv(x) "begin; print(x)" (decladebug)pv(i)

Use the unalias command to delete an alias. 

Alias commands may contain no more than 56 arguments. 

The following predefined aliases are included with the debugger:

aassign

bstop at

bpstop in

ccont

ddelete

efile

ffunc

hhistory

jstatus

llist

li$curpc/10i; set $curpc=$curpc+40

nnext

ninexti

pdprintf ""%d""

poprintf ""0%o""

prprintreqs

psprintf ""%s""

pxprintf ""0x%1x""

qquit

rrerun

rirecord input

rorecord output

sstep

sistepi

twhere

ulist $curline-9:10

Wlist $curline-10:20

wlist $curline-5:10

wi$curpc-20/10i

?help

assign target = expression

Use the assign command to change the value of a variable, memory address, or expression that is accessible according to the scope and visibility rules of the language.  The expression can be any expression that is valid in the current context. 

For C++: assign [classname::]member = ["filename"]‘expression assign [object.]member = ["filename"]‘expression

Use the assign command to modify static and object data members in a class, and variables declared as reference types, type const, or type static.  Note that the address referred to by a reference type may not be changed, but the value at that address may be changed. 

attach process_id  image_file

Use the attach command to connect to a running process.  Supply the process ID number and image file name. 

call function([parameter])

Use the call command to execute a single function. Specify the function as if you were calling it from within the program. If the function has no parameters, specify empty parentheses. 

Nest called functions by setting a breakpoint in a function and executing it using the call command. When execution suspends at the breakpoint, use the call command to execute the nested function. 

For C++:

When you set the $overloadmenu debugger variable to 1, and call an overloaded function, the debugger will list the overloaded functions and call the function you specify. 

catch [signal]

Enter the catch command or the ignore command without an argument to see which operating system signals the debugger currently traps or ignores. Use the catch command or the ignore command followed by an argument to trap or ignore, respectively, that signal. 

Only one signal at a time can be added to, or removed from, the list of trapped or ignored signals. 

class [classname]

For C++ only:

Use the class command without an argument to display the current class scope.  Specify an argument to change the class scope. Once the class scope is set, refer to members of the class omitting the classname:: prefix. 

Setting the class scope nullifies the function scope. 

cont [signal]

Use the cont command without a parameter value to resume program execution until a breakpoint, a signal, an error, or the end of the program is encountered.  Specify a parameter value to send an operating system signal to the program continuing execution. 

For multithreaded applications, use the cont command to resume execution of the current thread that was put on hold as a result of a step command.  As the current thread resumes, the other threads run freely. 

The signal parameter value can be either a signal number or a string name (for example, SIGSEGV).  The default is 0, which allows the program to continue execution without specifying a signal.  If you specify a signal parameter value, the program continues execution with that signal. 

delete integer[,...] delete all delete ∗

Enter the delete command followed by the number or numbers associated with a breakpoint or trace (as listed by the status command) to remove the specified breakpoint or tracepoint. 

Enter the delete all command or the delete ∗ command to remove all breakpoints and tracepoints. 

detach [process_id_list]

Use the detach command to detach from a running process you specify from the process ID list.  Specifying a process ID and detaching from the process disables your ability to debug the process.  If you do not specify a process ID from the list, DECladebug detaches from the current process. 

disable integer[,...] disable all disable ∗

Enter the disable command followed by the number or numbers associated with a breakpoint or trace (as listed by the status command) to disable the breakpoint or trace.  Enter the disable all command or the disable ∗ command, to disable all breakpoints and traces. 

The disabled breakpoint is displayed in response to the status command, but it is ignored during execution. Disabled breakpoints remain disabled until they are explicitly reactivated or deleted. 

down [number]

Use the up command or the down command without an argument to change the function scope to the function located one level up or down the stack. Enter a number argument to change the function scope to the function up or down the specified number of levels.  If the number of levels exceeds the number of active functions on the stack, the function scope moves up or down as many levels as possible and the debugger issues a warning message. 

When the function scope changes, the debugger displays the source line corresponding to the last point of execution in that function. 

dump [function] or dump .

Use the dump command without an argument to list the parameters and local variables in the current function. To list the parameters and local variables in an active function, specify it as an argument. 

Enter the dump . command to list the parameters and local variables for all functions active on the stack. 

enable integer[,...] enable all enable ∗

Enter the enable command followed by the number or numbers associated with a breakpoint or trace (as listed by the status command) to enable a breakpoint or trace. 

Enter the enable all command or the enable ∗ command to activate all previously disabled breakpoints and traces. 

file [filename]

Enter the file command without an argument to display the name of the current file scope.  Include a filename as an argument to change the file scope. Change the file scope to see the source code or set a breakpoint in a function not in the file currently being executed. 

func [function] func [integer]

Use the func command without an argument to display the current function scope. To change the function scope to a function currently active on the stack, specify either the name of the function or the number corresponding to the stack activation level. (Enter the where command to display the stack trace.) 

When the function scope is changed, the debugger displays the source line corresponding to the last point of execution in that function. 

goto linenumber

Use the goto command to branch to a line located in the function where execution is suspended. When you branch to a line, the source code between the line where execution suspended and the specified line is not executed. 

help [command]

Enter the help command without an argument to display a list of debugger commands. Include a command argument to display a description of that command. 

history [integer]

Enter the history command without an argument to display previously executed commands. The debugger displays the number of command lines defined for the $historylines debugger variable. (The default is 20 lines of user input.)  Include an integer argument to display that number of previous commands. 

ignore [signal]

Enter the catch command or the ignore command without an argument to see which operating system signals the debugger currently traps or ignores. Use the catch command or the ignore command followed by an argument to trap or ignore, respectively, that signal. 

Only one signal at a time can be added to, or removed from, the list of trapped or ignored signals. 

kill [process_id_list]

Use the kill command to terminate the current program process and leave the debugger running.  To terminate a particular process, enter the kill command with a process ID from the process ID list.  When a process terminates, breakpoints and traces previously set are retained. You can later rerun the program. 

list startline [,endline ] list startline [:count] list function

The list command displays source-code lines beginning with the source line corresponding to the position of the program counter, the last line listed if multiple list commands are issued, or the line number specified as the first argument to the list command. Specify the exact range of source-code lines by including either the endline or the number of lines you want to display. The arguments may be expressions that evaluate to integer values. 

To display the source code for a particular function, enter the function as an argument. 

listobj

Use the listobj command to list shared libraries that have been loaded. 

load [image_file [core_file]] unload process_id_list or image_file

The load command loads an image file and optionally a core file.  After loading an image file, specify the run command to start program execution. 

The unload command removes all related symbol table information that the debugger associated with the process being debugged, specified by either a process id or image file. 

next

Use the next and the step commands to execute a line of source code.  When the next line to be executed contains a function call, the next command executes the function being called and returns to the line immediately after the function call. The step command executes only the first line of the function. 

nexti

Use the stepi command and the nexti command to execute a machine instruction. When the instruction contains a function call, the stepi command steps into the function being called, and the nexti command executes the function being called. 

playback input filename

Use the source command and the playback input command to execute debugger commands contained within a file.  (Note that you can also execute debugger commands when you invoke DECladebug by creating an initialization file named .dbxinit.  By default DECladebug searches for this file during startup.)  Format commands as if they were entered at the debugger prompt. 

When a command file is executed the value of the $pimode debugger variable determines whether the commands are echoed. If the $pimode variable is set to 1, commands are echoed; if $pimode is set to 0 (the default), commands are not echoed. The debugger output resulting from the commands is always echoed. 

print expression [,...]

The print command displays the current value of a variable or expression that is visible in the current context, as defined by the scope and visibility rules of the program language.  The expression can be any expression that is valid in the current context. 

For C++:

print ∗this print object print [object.]member print ∗(derived_class∗)object

Use the print command to display the value of an object, including inherited members and the value of data members in an object. Type casts can be used to interpret a base class object as a derived class object, or to interpret a derived class object as a base class object. To interpret a base class type object as the derived type, use the last form of the print command. 

printf [format [expression,...]]

Use the printf command to format and display a complex structure. The format argument is a string expression of characters and conversion specifications, using the same format specifiers as the printf C function. 

printregs

Use the printregs command to display the contents of all machine registers.  Register values are given in both decimal and hexadecimal. The list of registers displayed by the debugger is machine dependent. 

quit

Use the quit command to end the debugging session and return to the operating system prompt. 

record input filename record output filename record io filename

Use the record input command to save all the debugger commands to a file. The commands in the file can be executed by using the source command or the playback input command. 

The record output command saves all debugger output to a file. The output is simultaneously echoed to the screen. (The program output is not saved.) 

The record io command saves both input to and output from the debugger. 

To stop recording debugger input or output, exit the debugger. 

return [function]

Use the return command without an argument to continue execution of the current function until it returns to its caller. If you include a function name, execution continues until control is returned to the specified function. The function must be active on the call stack. 

run [program arguments] [io redirection] rerun [program arguments] [io redirections]

Use the run and rerun commands to start program execution. Enter program flags, options, and input and output redirections as arguments. If the rerun command is specified without arguments, the arguments entered with the previous run command are used. 

set [variable = definition] unset variable

To examine the definitions of all debugger variables, enter the set command without arguments.  (Use the print command to display the definition of a single debugger variable.) 

To define a debugger variable, enter the set command followed by a variable name, an equal sign, and a definition. Enclose string definitions in quotes. The definition can be any expression allowed by the language of the program being debugged. 

Use the unset command to delete a variable. 

The debugger contains many predefined variables to describe the current state of the debugger, and to allow you to customize the debugger environment. You can delete and redefine the predefined debugger variables in the same way you define your own variables. If you delete a predefined debugger variable, the debugger uses the default value for that variable. 

The debugger has the following predefined variables:

$ascii
With the default value of 1, allows the print command to print character-type data as ASCII characters, only when the bit value is that of a printable ASCII character.  (Other bit values are printed as octal numbers.)  With a value of 0, all printable ISO Latin-1 characters are printed as characters.) 

$curfile
Specifies the current source-code file.

$curline
Specifies the current line in the source file.

$cursrcline
Specifies the line number of the last line of source code listed plus one.

$curevent
Sets to the event number of the current event at the start of an event, allowing its use within the expression of an event.

$curpc
Specifies the current point of program execution. The $curpc variable is used by the wi and li aliases. 

$curthread
Specifies the thread to which the debugger context is currently set.

$decints
When set to a nonzero value, all integers debugger are displayed as decimal numbers.

$eventecho
When set to a nonzero value, echoes events (such as breakpoints) with event numbers when executed. The default is 1.

$hexints
When set to a nonzero value, all integers will be displayed as hexadecimal numbers.

$historylines
Specifies the number of previously input commands listed in response to the history command. The default is 20. 

$indent
If nonzero, specifies that structures will be printed with added indentation to render them more readable.

$lang
Specifies the programming language used in the program being debugged. For mixed-language programs, $lang is continuously updated to reflect the language being debugged. 

$listwindow
Specifies how many lines the list command displays.  The default is 20. 

$main
Specifies the name of the function that the debugger enters first. The default is main(), but this can be set to any function. This variable is useful when debugging languages whose primary function is called something other than main(). 

$maxstrlen
Specifies the maximum number of characters to print when the value of a string is printed. The default is 128.

$octints
When set to a nonzero value, all integers printed by the debugger will be displayed as octal numbers.

$overloadmenu
When debugging C++ programs only, if this variable is set to 1, a menu of overloaded functions is displayed so you can select the desired function from the list of type signatures of the function. When set to 0, no menu is displayed, and you must disambiguate overloaded functions by providing the full type signature. The default is 0.

$pimode
Specifies whether the playback input command echoes input.  If set to 1, commands from the script file are echoed.  If set to 0, commands are not echoed.  The default is 0. 

$prompt
Specifies the debugger prompt. The default is (decladebug). 

$stepg0
When set to 0, the debugger steps over calls to routines that are compiled with with no symbol information. When set to 1, the debugger will step into these calls. The default is 0.

$threadlevel
Enables DECladebug to determine whether you are working with DECthreads or native threads.  The default is "decthreads"; specify "native" for native threads.

$verbose
Specifies whether debugger output should include all possible program information, including base pointers and virtual function pointers (relevant only when debugging C++ programs).

set [thread thread_identifier_list] state == active set [thread thread_identifier_list] state == cancel set [thread thread_identifier_list] state == held set [thread thread_identifier_list] state == unheld

Use the set thread state command to set the current state of a thread, condition variable, or mutex.  If you supply one or more thread identifiers, the debugger sets the current state of the thread or threads you specify.  If you omit the thread identifier specification, the debugger sets the current state of all threads to the thread state specified at the command line. 

sh command

Use the sh command to execute a Bourne shell command. Do not enclose the shell command and its arguments in quotations.  For example:

(decladebug)sh ls -l sample.c

show condition [condition_variable_list] show condition [condition_identifier_list] with state == wait

Use the show condition command to list information about currently available condition variables.  If you supply one or more condition identifiers, the debugger displays information about those condition variables that you specify, provided that the list matches the identity of currently available condition variables.  If you omit the condition variable specification, the debugger displays information about all condition variables currently available. 

Use the show condition command with state == wait to display information exclusively for condition identifiers that have one or more threads waiting on them. 

show mutex [mutex_identifier_list] show mutex [mutex_identifier_list] with state == locked

Use the show mutex command to list information about currently available mutexes.  If you specify one or more mutex identifiers, the debugger displays information about only those mutexes that you specify provided that the list matches the identity of currently available mutexes.  If you omit the mutex identifier specification, the debugger displays information about all mutexes currently available. 

Use the show mutex command with state == locked to display information exclusively for locked mutexes. 

show thread [thread_identifier_list] show thread [thread_identifier_list] with state == ready show thread [thread_identifier_list] with state == blocked show thread [thread_identifier_list] with state == running show thread [thread_identifier_list] with state == terminated show thread [thread_identifier_list] with state == detached

Use the show thread command to list all the threads known to the debugger.  If you specify one or more thread identifiers, the debugger displays information about the threads that you specify, if the thread matches what you specified in the list.  If you omit a thread specification, the debugger displays information for all threads. 

Use the show thread command to list threads that have specific characteristics, such as threads that are currently  blocked.  To display lists of thread characteristics, use one of the alternate syntaxes listed above. 

source filename

Use the source command and the playback input command to execute debugger commands contained within a file.  (Note that you can also execute debugger commands when you invoke DECladebug by creating an initialization file named .dbxinit.  By default, DECladebug searches for this file during startup.)  Format commands as if they were entered at the debugger prompt. 

When a command file is executed, the value of the $pimode debugger variable determines whether the commands are echoed. If the $pimode variable is set to 1, commands are echoed; if $pimode is set to 0 (the default), commands are not echoed. The debugger output resulting from the commands is always echoed. 

status

The status command lists all breakpoints and tracepoints, the reference number associated with each, and whether the breakpoint is disabled. 

step

Use the next and the step commands to execute a line of source code.  When the next line to be executed contains a function call, the next command executes the function being called and returns to the line immediately after the function call. The step command executes only the first line of the function. 

For multithreaded applications, use these commands to step the current thread while putting all other threads on hold. 

stepi

Use the stepi command and the nexti command to execute a machine instruction. When the instruction contains a function call, the stepi command steps into the function being called, and the nexti command executes the function being called. 

stop variable stop [variable] if expression stop [variable] at linenumber [if expression] stop [variable] "filename":linenumber stop [variable] in function [if expression] stop [variable] "filename" ‘function [if expression] stop [variable] [thread thread_identifier_list]
 [at linenumber] [if expression] stop [variable] [thread thread_identifier_list]
 [in function] [if expression]

Enter the stop command without a variable argument to suspend program execution and return to the prompt. 

Enter the stop command with a variable argument to suspend program execution when the variable changes. 

Specify an expression to suspend execution when the expression evaluates to true.  When you specify both an expression and a variable, execution suspends only if the specified expression evaluates to true and the variable has changed. 

To suspend execution when a line or function is encountered, use the third, fourth, or fifth form.  If you specify a variable, execution suspends only if the variable has changed when the line or function is encountered.  If you specify an expression, execution suspends only if the expression evaluates true when the line or function is encountered.  If you specify both a variable and an expression, execution suspends only if the variable has changed and the expression evaluates to true when the line or function is encountered. 

Specify a filename and function to instruct DECladebug to stop in a particular function in the specified file, thus eliminating ambiguity. 

Use forms 7 and 8 for multithreaded applications.  The thread_identifier_list parameter identifies one or more threads of the current debugging level (native or DECthreads).  If you specify one or more thread identifiers, execution suspends only if the variable has changed when the line or function is encountered in those threads. 

The following example shows how to suspend program execution when line number 10 is encountered and the variable f is equal to 2:

(decladebug)stop at 10 if f==2

For C++:

stop in [classname::]function stop in object.function stop in objectprt->function stop in object.function if (&object==this) stop in [classname::]classname[(type signature)] stop in [classname::]~classname stop in [classname::]function(type signature|void) stop in all function

The first form of the stop command sets a breakpoint in a member function using the static class type information. This form presumes that run-time information from an object is needed to determine the address of the function at which to set the breakpoint. 

If you need run-time information to determine the correct virtual function, use the second or third form to qualify the function name with the object when you set the breakpoint. Note that this way of setting the breakpoint causes the debugger to stop at the member function in all objects declared with the same class type as the specified object. 

To set a breakpoint that stops only in the member function for this specific object and not all instances of the same class type, use the fourth form of the stop command. 

The fifth and sixth forms set breakpoints in a constructor and destructor, respectively. 

To set a breakpoint in a specific version of an overloaded function, either set $overloadmenu to 1, enter the command stop in function, and choose the appropriate function from the menu, or specify the function and the type signature as arguments to the command. If the overloaded function has no parameters, void must be explicitly specified. 

Use the last form to set a breakpoint in all versions of an overloaded function. 

(decladebug)stop at 10 if f==2

stopi variable stopi [variable] if expression stopi [variable] in function [if expression] stopi [variable] at address [if expression]

Enter the stopi command with a variable to suspend execution when the variable value changes. 

Specify an expression to suspend execution when the expression evaluates to true.  When you specify both a variable and an expression, execution suspends only if the specified expression evaluates to true and the variable has changed. 

To suspend execution when an address or function is encountered, use the third or fourth form.  If you specify a variable, execution suspends only if the variable has changed when the address or function is encountered.  If you specify an expression, execution suspends only if the expression evaluates to true when the address or function is encountered.  If you specify both a variable and an expression, execution suspends only if the variable has changed and the expression evaluates to true when the address or function is encountered. 

The stopi command is different from the stop command because the debugger checks the breakpoint set with the stopi command after executing each machine instruction. Thus, the debugger performance is affected when you use the stopi command. 

The breakpoint in the following example stops program execution if the value of variable i changes while executing the function factorial: (decladebug)stopi i in factorial

thread [thread_identifier]

Use the thread command to identify or set the current thread context.  If you supply a thread identifier, the debugger sets the current context to the thread you specify.  If you omit the thread identification, the debugger displays the current thread context. 

trace [variable] [if expression] trace [variable] at linenumber [if expression] trace [variable] in function [if expression] trace [variable] [thread thread_identifier_list]
 [at linenumber] [if expression] trace [variable] [thread thread_identifier_list]
 [in function] [if expression]

When you use the trace command without an argument, the debugger prints a message, but does not suspend program execution when each function is entered.  Specify a variable to print a message when the variable value changes.  Specify an expression to print a message when an expression evaluates to true. When you specify both a variable and an expression, a message is printed only if the expression evaluates to true and the variable has changed. 

To print a message when a line or function is encountered, use the second or third form.  If you specify a variable, a message is printed only if the variable has changed when the line or function is encountered. If you specify an expression, a message is printed only if the expression evaluates to true when the line or function is encountered. If you specify both a variable and an expression, a message is printed only if the variable has changed and the expression evaluates to true when the line or function is encountered. 

The following example traces the variable f when the program is executing the function main: (decladebug)trace f in main

Use the trace thread command to set tracepoints in specific threads.  If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify.  If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application. 

tracei [variable] [if expression] tracei [variable] at address [if expression] tracei [variable] in function [if expression] tracei [variable] [thread thread_identifier_list]
 [at linenumber] [if expression] tracei [variable] [thread thread_identifier_list]
 [in function] [if expression]

When you use the tracei command the debugger prints a message, but does not suspend program execution.  Specify a variable to print a message when the variable value changes.  Specify an expression to print a message when an expression evaluates to true.  When you specify both a variable and an expression, a message is printed only if the expression evaluates to true and the variable has changed. 

To print a message when an address or function is encountered, use the second or third form.  If you specify a variable, a message is printed only if the variable has changed when the address or function is encountered.  If you specify an expression, a message is printed only if the expression evaluates to true when the address or function is encountered.  If you specify both a variable and an expression, a message is printed only if the variable has changed and the expression evaluates to true when the address or function is encountered. 

The tracei command differs from the trace command in that the debugger evaluates the tracepoint set with the tracei command after the debugger executes each machine instruction. Thus, when you use the tracei command, the debugger performance is affected. 

In the following example, a breakpoint is set to print a message every time the function factorial is entered:

(decladebug)tracei factorial

Use the tracei thread command to set tracepoints in specific threads.  If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify.  If you omit the thread identifier specification, the debugger sets a tracepoint in all threads of the application. 

up [number]

Use the up command or the down command without an argument to change the function scope to the function located one level up or down the stack. Enter a number argument to change the function scope to the function up or down the specified number of levels.  If the number of levels exceeds the number of active functions on the stack, the function scope moves up or down as many levels as possible and the debugger issues a warning message. 

When the function scope changes, the debugger displays the source line corresponding to the last point of execution in that function. 

use [directory] unuse [directory] unuse ∗

Enter the use command without an argument, to list the directories the debugger searches for source-code files.  Specify a directory argument to make source-code files in that directory available to the debugger. (You can also use the decladebug command -I option to specify search directories.) 

Enter the unuse command without an argument to set the search list to the default, the home directory, the current directory, and the directory containing the executable file. Include the name of a directory to remove it from the search list. The asterisk (∗) argument removes all directories from the search list. 

whatis expression

The whatis command prints the type of the specified expression. The expression can be any expression that follows the syntax, scope, and visibility rules of the program language. 

For C++:

whatis classname whatis [classname::]member whatis [classname::]function

The first form of the whatis command displays the class type.  The second form displays the type of a member function or data member.  To display all versions of an overloaded function, use the third form. 

when variable {command[;...]} when variable [if expression] {command[;...]} when [variable] at linenumber [if expression]
 {command[;...]} when [variable] in function [if expression]
 {command[;...]} when [variable] [thread thread_identifier_list∗O]
 [at linenumber] [if expression]  {command[;...]} when [variable] [thread thread_identifier_list∗O]
 [in function] [if expression]  {command[;...]}

Use the when command to suspend program execution and execute the specified command when the variable changes value. The debugger command must be enclosed in braces. Separate multiple commands with semicolons. 

To execute a command when an expression evaluates to true, use the second form.  When you specify a variable and an expression, the command is executed only if the expression evaluates true and the variable has changed. 

To execute commands when a line or function is encountered, use the third form or fourth form.  If you specify a variable, the command is executed only if the variable has changed when the line or function is encountered.  If you specify an expression, the command is executed only if the expression evaluates true when the line or function is encountered. If you specify a variable and an expression, the command is executed only if the variable has changed and the expression evaluates to true when the line or function is encountered. 

For example: (decladebug)when at 5 {list;where}

Use the when thread command to set tracepoints in specific threads.  If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify.  If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application. 

wheni variable {command[;...]} wheni [variable] if expression {command[;...]} wheni [variable] at address [if expression]
 {command[;...]} wheni [variable] in function [if expression]
 {command[;...]} wheni [thread thread_identifier_list] [at line_number]
 [if expression] {command[;...]} wheni [thread thread_identifier_list] [in function]
 [if expression] {command[;...]}

Use the wheni command to suspend program execution and execute the specified command when the variable changes value.  The debugger command must be enclosed in braces.  Separate multiple commands with semicolons. 

To execute a command when an expression evaluates to true, use the second form.  When you specify a variable and an expression, the command is executed only if the expression evaluates to true and the variable has changed. 

To execute a command when an address or function is encountered, use the third or fourth form.  If you specify a variable, the command is executed only if the variable has changed when the address or function is encountered.  If you specify an expression, the command is executed only if the expression evaluates to true when the address or function is encountered.  If you specify a variable and an expression, the command is executed only if the variable has changed and the expression evaluates to true when the address or function is encountered. 

The wheni command differs from the when command in that the debugger evaluates the tracepoint set with the wheni command after each machine instruction is executed.  Thus, using the wheni command effects performance. 

For example, the following command stops program execution, lists ten lines of source code and displays the stack trace when the value of the variable i is equal to 3 in the function main:

(decladebug)wheni in main if i == 3 {w;where}

Use the command to set tracepoints in specific threads.  If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify.  If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application. 

where [number]

The where command displays the stack trace of currently active functions. Include a number argument to list that number of levels at the top of the stack. Each active function is designated by a number which can be used as an argument to the func command. 

whereis expression

The whereis command shows all declarations of the expression. Each declaration is fully qualified with scope information. 

which expression

The which command shows the fully qualified scope information for the instance of the specified expression in the current scope. If available to the debugger, the name of the source file containing the function in which the expression is declared, the name of the function, and the name of the expression are included. The components of the qualification are separated by period (.) characters. 

RESTRICTIONS

The maximum command-line length is 255 characters. 

Alias commands may contain no more than 56 arguments. 

FILES

a.outDefault object file name

coreDefault core dump file name

.dbxinitInitialization file DECladebug searches for at startup

RELATED INFORMATION

ada1 c891 cc1 cxx1 cobol1 f771 f901 printf1 signal3 DECladebug Debugger Manual: Command-Line Interface.