Appendix C. Predefined dbx Variables
Prev |  | Next

## Appendix C. Predefined dbx Variables`` ````

Predefined dbx variables are listed in Table C-1. The predefined variable names begin with “$” so that they do not conflict with variable, command, or alias names.

Table C-1. Predefined `dbx` Variables

Variable | Default | Description
--- | --- | ---
$addrfmt | “0x%x” | Specifies the format for addresses. This can be set to any format valid for the C language `printf`(3S) function.
$addrfmt64 | “0x%x” | Specifies the format for 64-bit addresses. This can be set to any format valid for the C language `printf`(3S) function.
$assignverify |  | Prints the new value of a variable after an `assign`.
$casesense | 2 | If 0, symbol names are case sensitive. If 1, symbol names are not case sensitive. If 2, the case sensitivity of symbol names depends on the case sensitivity of the language in which the symbol was defined.
$ctypenames | 1 | If 1, the words “unsigned,” “short,” “long,” “int,” “char,” “struct,” “union,” and “enum” are keywords usable only in type casts. If 0, “struct,” “union,” and “enum” are ordinary words with no predefined meaning (in C modules, the others are still known as C types).
$curevent |  | The last event number as seen by the `status` command.
$curline |  | The current line in the source code being executed.
$curpc |  | The current program counter.
$cursrcline |  | The current source listing line plus one.
$debugrld | 0 | If the value is 1, `dbx` allows you to set traps in `rld` code, so you can debug bugs in run-time initialization of C++ global variables and the like.
$defaultin |  | The name of the file that `dbx` uses when the `` ```record input` or the `playback input` command is executed with no argument.
$defaultout |  | The name of the file that `dbx` uses when the `record output` or the `playback output` command is executed with no argument.
$editor | `vi` | The name of the editor to invoke (with the `` ```edit` command). Default value is set to the value of the EDITOR environment variable. If EDITOR missing, it defaults to `vi`.
$fp_precise | 0 | (Systems with floating-point precise mode only.) A nonzero value specifies that the `run` command instructs the operating system to run the program in floating-point precise mode (a nondebug mode). The debugged process performs SGI_SET_FP_PRECISE and SGI_SET_FP_PRESERVE `syssgi` system calls.
$framereg | 1 | If 1, all references to registers are to the registers of the current activation level. If 0, all references are to the hardware registers (the registers of activation level 0).
$groupforktoo | 0 | If 0, adds only processes created with the `sproc`(2) system call to the process group list automatically. If 1, then adds processes created with either the `fork`(2) or `sproc` system calls to process group list.
$hexchars | 0 | If nonzero, outputs characters in hexadecimal, using C format “%x”. This affects char type variables, including those in structures. It does not affect arrays of characters, which are printed using the “%.*s” format.
$hexdoubles | 0 | If nonzero, float and double values print as normal, with a trailing output of `hex ffffffff` and `hex` `ffffffff 00000000`, respectively. These are hex representations of the bits of the float and double.
$hexin | 0 | If nonzero, input constants are assumed to be in hexadecimal. This overrides $octin.
$hexints | 0 | If nonzero, outputs integers in hexadecimal format. This overrides $octints.
$hexstrings | 0 | If nonzero, outputs strings and arrays in hexadecimal. For character arrays, if nonzero, the null byte is not taken as a terminator. Instead, prints the entire array (or $maxlen values, whichever is less). If 0, then a null byte in a C or C++ character array is taken as the end of the array (the length of the array and $maxstrlen can terminate the array printing before a null byte is found).
$historyevent |  | The current history line number.
$lastchild |  | The process ID of the last child process created by a `fork` or `sproc` system call.
$lines | 100 | The number of lines in the history list.
$listwindow | 10 | Specifies how many lines the `list` command lists.
$maxstrlen | 128 | Maximum length printed for zero-terminated char strings and arrays. Prints char arrays for array-length, $maxstrlen bytes, or up to a null byte, whichever comes first (see $hexstrings).
$mp_program | 0 | If 0, `dbx` treats calls to `sproc` in the same way as it treats calls to `fork`. If 1, child processes created by calls to `sproc` are allowed to run; they block on multiprocessor synchronization code emitted by mp Fortran code. When you set $mp_program to 1, mp Fortran code is easier to debug.
$newevent |  | After every command creating an event, this variable is set to the event's number. The $newevent variable is useful in writing scripts that do not use hard-coded event numbers.
$newpgrpevent |  | Displays the value of the latest `pgrp` event created by `stop[i]`, `trace[i]`, and `when[i]`... `pgrp`. Useful when writing scripts that then do `delete` `pgrp#` `pgrp` with a symbolic (`dbx` variable) `pgrp#`.
$octin | 0 | If nonzero, assumes input constants are in octal ( $hexin overrides $octin).
$octints | 0 | If nonzero, outputs integers in octal format ( $hexints takes precedence).
$page | 1 | Specifies whether or not to page when `dbx` output scrolls information off the current screen. A nonzero value turns on paging; a 0 turns it off.
$pager | `more` | The name of the program used to display output from `dbx`.
$pagewidth | 80 | The width of the window in characters (assumes a fixed-width font). Used by `dbx` to calculate how many screen lines are output. `dbx` never inserts newlines; the window software wraps the lines.
$pagewindow | 23 | Specifies how many lines print when information is longer than one screen. This can be changed to match the number of lines on any terminal. If set to 0, 1 is used.
$pendingtraps | 0 | Uses no pending traps. If nonzero, allows traps that cannot be satisfied immediately to pend until they can be satisfied. This is useful for debugging programs that use `dlopen()` to load symbols as it allows setting breakpoints before the `dlopen()` call. Similar to`$debugrld`, but `$pendingtraps` does not allow setting breakpoints in `rld`. When set to nonzero, mistyped procedure names cause a pending trap to be set.
$piaddtohist | 1 | If 1, adds commands read from files using the `` ```playback input` command to the command history. If 0, does not add the commands to the history.
$pid |  | The current process for kernel debugging (`-` k).
$pid0 |  | Set by `dbx` to the process ID of the running process (also called the object file).
$pimode | 0 | If 1, `dbx` prints the commands read from files using the`` `playback input` command. If 0, `dbx` does not print the commands. In either case, `dbx` prints the output resulting from such commands.
$printdata | 0 | Used when disassembling. If 1, prints register contents alongside disassembled instructions. If 0, just prints disassembled instructions.
$printwhilestep | 0 | If 0, prints only the next line to be executed. If nonzero, prints each line that is executed while it single steps.
$printwide | 0 | If 0, prints arrays one element per line. If nonzero, prints arrays compactly (wide).
$procaddr |  | This variable applies only if you invoke `dbx` with the `-` k option (that is, it is not available unless you are doing kernel debugging). Whenever $pid is set, `dbx` sets $procaddr to the address of the process table entry for that process.
$prompt | `dbx` | The prompt for ```dbx`.
$promptonfork | 0 | If 0, `dbx` does not add the child process to the process pool. Both the child process and the parent process continue to run. If 1, `dbx` stops the parent process and asks if you want to add the child process to the process pool. If you answer yes, then `dbx` adds the child process to the pool and stops the child process; if you answer no, `dbx` allows the child process to run and does not place it in the process pool. If 2, `dbx` automatically stops both the parent and child processes and adds the child process to the process pool.
$regstyle | 0 | If 0, `dbx` uses the alternate form of the register name (for example, “zero” instead of “r0” and “t1” instead of “r9”). If nonzero, `dbx` uses the machine name (“r0” through “r31”).
$repeatmode | 0 | If nonzero, entering a null line (entering a newline on an empty line) repeats the last command. If 0, ```dbx` performs no action.
$rimode | 0 | If 1, `dbx` records commands you enter in addition to output when using the `record` `output` command. If 0, `dbx` does not copy the commands.
$showbreakaddrs | 0 | If nonzero, show the address of each breakpoint placed in the code each time it is placed. Removal of the breakpoints is not shown. If multiple breakpoints are placed at one location, only one of the placements is shown. Since breakpoints are frequently placed and removed by `dbx`, the volume of output can be annoying when tracing.
$stacktracelimit |  | Limits to the depth of the stack trace.
$stepintoall | 0 | If 0, `step` steps into only those procedures that are compiled with the debugging option `-` g. step steps over all other procedures. If 1 or 2, `step` steps into all procedures. Note that when you debug a source file compiled without symbols or compiled with optimization, the line numbers may sometimes jump erratically. Also note that if `dbx` cannot locate a source file, then it cannot display source lines as you step through a procedure.
$tagfile | `tags` | The name of a file of tags, as created by `ctags`(1). Used by the `tag` command.

Prev | Table of Contents | Next
Appendix B. Predefined Aliases |  | Index