Return to pdx.1 CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx

Annotation of 42BSD/ucb/pascal/pdx/pdx.1, revision 1.1

1.1     ! root        1: .TH pdx 1
        !             2: .SH NAME
        !             3: pdx - pascal debugger
        !             4: .SH SYNOPSIS
        !             5: pdx [\fB-r\fP] [\fIobjfile\fP]
        !             6: .SH DESCRIPTION
        !             7: \fIPdx\fP is a tool for source level debugging and execution of
        !             8: Pascal programs.
        !             9: The \fIobjfile\fP is an object file produced by the Pascal translator \fIpi\fP(1).
        !            10: If no \fIobjfile\fP is specified, \fIpdx\fP looks
        !            11: for a file named ``obj'' in the current directory.
        !            12: The object file contains a symbol table which includes the name of the
        !            13: all the source files translated by \fIpi\fP to create it.
        !            14: These files are available for perusal while using the debugger.
        !            15: .PP
        !            16: If the file ``.pdxinit'' exists in the current directory, then the
        !            17: debugger commands in it are executed.
        !            18: .PP
        !            19: The \fB-r\fP option causes the \fIobjfile\fP to be executed immediately;
        !            20: if it terminates successfully \fIpdx\fP exits.
        !            21: Otherwise it reports the reason for termination
        !            22: and offers the user the option of entering the debugger
        !            23: or simply letting \fIpx\fP continue with a traceback.
        !            24: If \fB-r\fP is not specified, \fIpdx\fP just prompts and waits for a command.
        !            25: .PP
        !            26: The commands are:
        !            27: .TP
        !            28: \fBrun\fP [\fIargs\fP] [\fB<\fP \fIfilename\fP] [\fB>\fP \fIfilename\fP]
        !            29: Start executing \fIobjfile\fP, passing \fIargs\fP as command line arguments;
        !            30: \fB<\fP or \fB>\fP can be used to redirect input or output in the usual manner.
        !            31: .TP
        !            32: \fBtrace\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]
        !            33: .ns
        !            34: .TP
        !            35: \fBtrace\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]
        !            36: .ns
        !            37: .TP
        !            38: \fBtrace\fP \fIprocedure/function\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]
        !            39: .ns
        !            40: .TP
        !            41: \fBtrace\fP \fIexpression\fP \fBat\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]
        !            42: .ns
        !            43: .TP
        !            44: \fBtrace\fP \fIvariable\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]
        !            45: Have tracing information printed when the program is executed.
        !            46: A number is associated with the command that is used
        !            47: to turn the tracing off (see the \fBdelete\fP command).
        !            48: .sp 1
        !            49: The first argument describes what is to be traced.
        !            50: If it is a \fIsource-line-number\fP, then the line is printed
        !            51: immediately prior to being executed.
        !            52: Source line numbers in a file other than the current one
        !            53: must be preceded by the name of the file and a colon, e.g.
        !            54: ``mumble.p:17''.
        !            55: .sp 1
        !            56: If the argument is a procedure or function name then
        !            57: every time it is called, information is printed telling
        !            58: what routine called it, from what source line it was called,
        !            59: and what parameters were passed to it.
        !            60: In addition, its return is noted, and if it's a function
        !            61: then the value it is returning is also printed.
        !            62: .sp 1
        !            63: If the argument is an \fIexpression\fP with an \fBat\fP clause
        !            64: then the value of the expression is printed whenever the
        !            65: identified source line is reached.
        !            66: .sp 1
        !            67: If the argument is a variable then the name and value of the variable
        !            68: is printed whenever it changes.
        !            69: Execution is substantially slower during this form of tracing.
        !            70: .sp 1
        !            71: If no argument is specified then all source lines are printed
        !            72: before they are executed.
        !            73: Execution is substantially slower during this form of tracing.
        !            74: .sp 1
        !            75: The clause ``\fBin\fP \fIprocedure/function\fP'' restricts tracing information
        !            76: to be printed only while executing inside the given procedure
        !            77: or function.
        !            78: .sp 1
        !            79: \fICondition\fP is a Pascal boolean expression and is
        !            80: evaluated prior to printing the tracing information;
        !            81: if it is false then the information is not printed.
        !            82: .sp 1
        !            83: There is no restriction on the amount of information
        !            84: that can be traced.
        !            85: .br
        !            86: .ne 10
        !            87: .IP "\fBstop\fP \fBif\fP \fIcondition\fP"
        !            88: .ns
        !            89: .IP "\fBstop\fP \fBat\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]"
        !            90: .ns
        !            91: .IP "\fBstop\fP \fBin\fP \fIprocedure/function\fP [\fBif\fP \fIcondition\fP]"
        !            92: .ns
        !            93: .IP "\fBstop\fP \fIvariable\fP [\fBif\fP \fIcondition\fP]"
        !            94: Stop execution when the given line is reached, procedure or function
        !            95: called, variable changed, or condition true.
        !            96: .IP "\fBdelete\fP \fIcommand-number\fP"
        !            97: The trace or stop corresponding to the given number is removed.
        !            98: The numbers associated with traces and stops are printed by
        !            99: the \fBstatus\fP command.
        !           100: .IP "\fBstatus\fP [\fB>\fP \fIfilename\fP]"
        !           101: Print out
        !           102: the currently active \fBtrace\fP and \fBstop\fP commands.
        !           103: .IP \fBcont\fP
        !           104: Continue execution from where it stopped.
        !           105: This can only be
        !           106: done when the program was stopped by an interrupt
        !           107: or through use of the \fBstop\fP command.
        !           108: .IP \fBstep\fP
        !           109: Execute one source line.
        !           110: .IP \fBnext\fP
        !           111: Execute up to the next source line.
        !           112: The difference between this and \fBstep\fP is that
        !           113: if the line contains a call to a procedure or function
        !           114: the \fBstep\fP command will stop at the beginning of that
        !           115: block, while the \fBnext\fP command will not.
        !           116: .IP "\fBprint\fP \fIexpression\fP [\fB,\fP \fIexpression\fP ...]"
        !           117: Print out the values of the Pascal expressions.
        !           118: Variables declared in an outer block but having
        !           119: the same identifier as one in the current block may be
        !           120: referenced as ``\fIblock-name\fP\ \fB.\fP\ \fIvariable\fP''.
        !           121: .IP "\fBwhatis\fP \fIidentifier\fP"
        !           122: Print the declaration of the given identifier.
        !           123: .IP "\fBwhich\fP \fIidentifier\fP"
        !           124: Print the full qualification of the given identifer, i.e.
        !           125: the outer blocks that the identifier is associated with.
        !           126: .IP "\fBassign\fP \fIvariable\fP \fIexpression\fP"
        !           127: Assign the value of the expression to the variable.
        !           128: .IP "\fBcall\fP \fIprocedure(parameters)\fP"
        !           129: Execute the object code associated with the named procedure or function.
        !           130: .IP \fBhelp\fP
        !           131: Print out a synopsis of \fIpdx\fP commands.
        !           132: .IP \fBgripe\fP
        !           133: Invokes a mail program to send a message to the person in charge of \fIpdx\fP.
        !           134: .IP \fBwhere\fP
        !           135: Print out
        !           136: a list of the active procedures and functions and the respective source
        !           137: line where they are called.
        !           138: .TP
        !           139: \fBsource\fP \fIfilename\fP
        !           140: Read \fIpdx\fP commands from the given \fIfilename\fP.
        !           141: Especially useful when the \fIfilename\fP has been created by redirecting
        !           142: a \fBstatus\fP command from an earlier debugging session.
        !           143: .IP "\fBdump\fP [\fB>\fP \fIfilename\fP]"
        !           144: Print the names and values of all active
        !           145: data.
        !           146: .IP "\fBlist\fP [\fIsource-line-number\fP [\fB,\fP \fIsource-line-number\fP]]"
        !           147: .ns
        !           148: .IP "\fBlist\fP \fIprocedure/function\fP"
        !           149: List the lines in the current source file from the first line number to
        !           150: the second inclusive.
        !           151: As in the editor
        !           152: ``$'' can be used to refer to the last line.
        !           153: If no lines are specified, the entire file is listed.
        !           154: If the name of a procedure or function is given
        !           155: lines \fIn-k\fP to \fIn+k\fP are listed where \fIn\fP is the first statement
        !           156: in the procedure or function and \fIk\fP is small.
        !           157: .IP "\fBfile\fP [\fIfilename\fP]"
        !           158: Change the current source file name to \fIfilename\fP.
        !           159: If none is specified then the current source file name is printed.
        !           160: .IP "\fBedit\fP [\fIfilename\fP]"
        !           161: .ns
        !           162: .IP "\fBedit\fP \fIprocedure/function-name\fP"
        !           163: Invoke an editor on \fIfilename\fP or the current source file if none
        !           164: is specified.
        !           165: If a \fIprocedure\fP or \fIfunction\fP name is specified,
        !           166: the editor is invoked on the file that contains it.
        !           167: Which editor is invoked by default depends on the installation.
        !           168: The default can be overridden by setting the environment variable
        !           169: EDITOR to the name of the desired editor.
        !           170: .IP \fBpi\fP
        !           171: Recompile the program and read in the new symbol table information.
        !           172: .IP "\fBsh\fP \fIcommand-line\fP"
        !           173: Pass the command line to the shell for execution.
        !           174: The SHELL environment variable determines which shell is used.
        !           175: .IP "\fBalias\fP \fInew-command-name\fP \fIold-command-name\fP"
        !           176: This command makes \fIpdx\fP respond to \fInew-command-name\fP
        !           177: the way it used to respond to \fIold-command-name\fP.
        !           178: .IP "\fBquit\fP"
        !           179: Exit \fIpdx\fP.
        !           180: .sp 4
        !           181: .PP
        !           182: The following commands deal with the program at the \fIpx\fP instruction
        !           183: level rather than source level.
        !           184: They are not intended for general use.
        !           185: .TP
        !           186: \fBtracei\fP [\fIaddress\fP] [\fBif\fP \fIcond\fP]
        !           187: .ns
        !           188: .TP
        !           189: \fBtracei\fP [\fIvariable\fP] [\fBat\fP \fIaddress\fP] [\fBif\fP \fIcond\fP]
        !           190: .ns
        !           191: .TP
        !           192: \fBstopi\fP [\fIaddress\fP] [\fBif\fP \fIcond\fP]
        !           193: .ns
        !           194: .TP
        !           195: \fBstopi\fP [\fBat\fP] [\fIaddress\fP] [\fBif\fP \fIcond\fP]
        !           196: Turn on tracing or set a stop using a \fIpx\fP machine
        !           197: instruction addresses.
        !           198: .TP
        !           199: \fBxi\fP \fIaddress\fP [\fB,\fP \fIaddress\fP]
        !           200: Print the instructions starting at the first \fIaddress\fP.
        !           201: Instructions up to
        !           202: the second \fIaddress\fP are printed.
        !           203: .TP
        !           204: \fBxd\fP \fIaddress\fP [\fB,\fP \fIaddress\fP]
        !           205: Print in octal the specified data location(s).
        !           206: .SH FILES
        !           207: .nr In 25
        !           208: .in +\n(Inn
        !           209: .ta \n(Inn
        !           210: .br
        !           211: .nr wg 1v
        !           212: .ie \n(.h=\n(vk .nr wg -\n(vhu
        !           213: .el .nr vh 0
        !           214: .if \n(wg>0 \{\
        !           215: .sp \n(wgu
        !           216: .nr vh +\n(wgu \}
        !           217: .nr vk \n(.h
        !           218: .ti -\n(Inn
        !           219: \&obj  \c
        !           220: Pascal object file
        !           221: .br
        !           222: .nr wg 0v
        !           223: .ie \n(.h=\n(vk .nr wg -\n(vhu
        !           224: .el .nr vh 0
        !           225: .if \n(wg>0 \{\
        !           226: .sp \n(wgu
        !           227: .nr vh +\n(wgu \}
        !           228: .nr vk \n(.h
        !           229: .ti -\n(Inn
        !           230: \&\&.pdxinit   \c
        !           231: \fIPdx\fP initialization file
        !           232: .in -\n(Inn
        !           233: .br
        !           234: .nr wg 1v
        !           235: .ie \n(.h=\n(vk .nr wg -\n(vhu
        !           236: .el .nr vh 0
        !           237: .if \n(wg>0 \{\
        !           238: .sp \n(wgu
        !           239: .nr vh +\n(wgu \}
        !           240: .nr vk \n(.h
        !           241: .SH SEE ALSO
        !           242: pi(1), px(1)
        !           243: .br
        !           244: \fIAn Introduction to Pdx\fP
        !           245: .SH BUGS
        !           246: \fIPdx\fP does not understand sets,
        !           247: and provides no information about files.
        !           248: .sp 1
        !           249: The \fIwhatis\fP command doesn't quite work for variant records.
        !           250: .sp 1
        !           251: Bad things will happen if a procedure invoked with
        !           252: the \fBcall\fP command does a non-local goto.
        !           253: .sp 1
        !           254: The commands \fBstep\fP and \fBnext\fP should be able to take a \fIcount\fP
        !           255: that specifies how many lines to execute.
        !           256: .sp 1
        !           257: There should be commands \fBstepi\fP and \fBnexti\fP that correspond
        !           258: to \fBstep\fP and \fBnext\fP but work at the instruction level.
        !           259: .sp 1
        !           260: There should be a way to get an address associated with
        !           261: a line number, procedure or function, and variable.
        !           262: .sp 1
        !           263: Most of the command names are too long.
        !           264: .sp 1
        !           265: The alias facility is quite weak.
        !           266: .sp 1
        !           267: A \fIcsh\fP-like history capability would improve the situation.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.