aboutsummaryrefslogtreecommitdiff
path: root/gdb/doc/interim-gdb.texinfo
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/doc/interim-gdb.texinfo')
-rwxr-xr-xgdb/doc/interim-gdb.texinfo7901
1 files changed, 0 insertions, 7901 deletions
diff --git a/gdb/doc/interim-gdb.texinfo b/gdb/doc/interim-gdb.texinfo
index 53a01e4..e69de29 100755
--- a/gdb/doc/interim-gdb.texinfo
+++ b/gdb/doc/interim-gdb.texinfo
@@ -1,7901 +0,0 @@
-_dnl__ -*-Texinfo-*-
-_dnl__ Copyright (c) 1988 1989 1990 1991 Free Software Foundation, Inc.
-\input texinfo
-@setfilename _GDBP__.info
-@c $Id$
-@c THIS MANUAL REQUIRES TEXINFO-2 macros and info-makers to format properly.
-@c
-@c NOTE: this manual is marked up for preprocessing with a collection
-@c of m4 macros called "pretex.m4". If you see <_if__> and <_fi__>
-@c scattered around the source, you have the full source before
-@c preprocessing; if you don't, you have the source configured for
-@c _HOST__ architectures (and you can of course get the full source,
-@c with all configurations, from wherever you got this).
-_if__(0)
-
-THIS IS THE SOURCE PRIOR TO PREPROCESSING. The full source needs to
-be run through m4 before either tex- or info- formatting: for example,
-_0__
- m4 pretex.m4 none.m4 all.m4 gdb.texinfo >gdb-all.texinfo
-_1__
-will produce (assuming your path finds either GNU m4 >= 0.84, or SysV
-m4; Berkeley won't do) a file suitable for formatting. See the text in
-"pretex.m4" for a fuller explanation (and the macro definitions).
-
-_fi__(0)
-_include__(gdbVN.m4)
-@tex
-\def\$#1${{#1}} % Kluge: collect RCS revision info without $...$
-\xdef\manvers{\$Revision$} % For use in headers, footers too
-@end tex
-@c
-@syncodeindex ky cp
-@c FOR UPDATES LEADING TO THIS DRAFT, GDB CHANGELOG CONSULTED BETWEEN:
-@c Fri Sep 20 16:10:52 1991 John Gilmore (gnu at cygnus.com)
-@c Sat Dec 22 02:51:40 1990 John Gilmore (gnu at cygint)
-@ifinfo
-This file documents the GNU debugger _GDBN__.
-
-Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-@ignore
-Permission is granted to process this file through TeX and print the
-results, provided the printed document carries copying permission
-notice identical to this one except for the removal of this paragraph
-(this paragraph not being relevant to the printed manual).
-
-@end ignore
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU General Public License'' is included exactly as
-in the original, and provided that the entire resulting derived work is
-distributed under the terms of a permission notice identical to this
-one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the section entitled ``GNU General Public License'' may be
-included in a translation approved by the Free Software Foundation
-instead of in the original English.
-@end ifinfo
-@c @smallbook
-@setchapternewpage odd
-_if__(_GENERIC__)
-@settitle Using _GDBN__ (<v>_GDB_VN__)
-_fi__(_GENERIC__)
-_if__(!_GENERIC__)
-@settitle Using _GDBN__ <v>_GDB_VN__ (_HOST__)
-_fi__(!_GENERIC__)
-@iftex
-@finalout
-@end iftex
-@titlepage
-@title{Using _GDBN__}
-@subtitle{A Guide to the GNU Source-Level Debugger}
-_if__(!_GENERIC__)
-@subtitle{On _HOST__ Systems}
-_fi__(!_GENERIC__)
-@sp 1
-@c Maybe crank this up to "Fourth Edition" when released at FSF
-@c @subtitle Third Edition---_GDBN__ version _GDB_VN__
-@subtitle _GDBN__ version _GDB_VN__
-@subtitle July 1991
-@author{Richard M. Stallman@qquad @hfill Free Software Foundation}
-@author{Roland H. Pesch@qquad @hfill Cygnus Support}
-@page
-@tex
-{\parskip=0pt
-\hfill rms\@ai.mit.edu, pesch\@cygnus.com\par
-\hfill {\it Using _GDBN__}, \manvers\par
-\hfill \TeX{}info \texinfoversion\par
-}
-@end tex
-
-@vskip 0pt plus 1filll
-Copyright @copyright{} 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU General Public License'' is included exactly as
-in the original, and provided that the entire resulting derived work is
-distributed under the terms of a permission notice identical to this
-one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the section entitled ``GNU General Public License'' may be
-included in a translation approved by the Free Software Foundation
-instead of in the original English.
-@end titlepage
-@page
-
-@node Top, Summary, (dir), (dir)
-@ifinfo
-This file describes version _GDB_VN__ of GDB, the GNU symbolic debugger.
-@end ifinfo
-
-@menu
-* Summary:: Summary of _GDBN__
-* New Features:: New Features in _GDBN__ version _GDB_VN__
-* Sample Session:: A Sample _GDBN__ Session
-* Invocation:: Getting In and Out of _GDBN__
-* Commands:: _GDBN__ Commands
-* Running:: Running Programs Under _GDBN__
-* Stopping:: Stopping and Continuing
-* Stack:: Examining the Stack
-* Source:: Examining Source Files
-* Data:: Examining Data
-* Languages:: Using _GDBN__ with Different Languages
-* Symbols:: Examining the Symbol Table
-* Altering:: Altering Execution
-* _GDBN__ Files:: _GDBN__'s Files
-* Targets:: Specifying a Debugging Target
-* Controlling _GDBN__:: Controlling _GDBN__
-* Sequences:: Canned Sequences of Commands
-* Emacs:: Using _GDBN__ under GNU Emacs
-* _GDBN__ Bugs:: Reporting Bugs in _GDBN__
-* Renamed Commands::
-* Installing _GDBN__:: Installing _GDBN__
-* Copying:: GNU GENERAL PUBLIC LICENSE
-* Index:: Index
-
- --- The Detailed Node Listing ---
-
-Summary of _GDBN__
-
-* Free Software:: Free Software
-* Contributors:: Contributors to _GDBN__
-
-Getting In and Out of _GDBN__
-
-* Starting _GDBN__:: Starting _GDBN__
-* Leaving _GDBN__:: Leaving _GDBN__
-* Shell Commands:: Shell Commands
-
-Starting _GDBN__
-
-* File Options:: Choosing Files
-* Mode Options:: Choosing Modes
-
-_GDBN__ Commands
-
-* Command Syntax:: Command Syntax
-* Help:: Getting Help
-
-Running Programs Under _GDBN__
-
-* Compilation:: Compiling for Debugging
-* Starting:: Starting your Program
-* Arguments:: Your Program's Arguments
-* Environment:: Your Program's Environment
-* Working Directory:: Your Program's Working Directory
-* Input/Output:: Your Program's Input and Output
-* Attach:: Debugging an Already-Running Process
-* Kill Process:: Killing the Child Process
-
-Stopping and Continuing
-
-* Breakpoints:: Breakpoints, Watchpoints, and Exceptions
-* Continuing and Stepping:: Resuming Execution
-* Signals:: Signals
-
-Breakpoints, Watchpoints, and Exceptions
-
-* Set Breaks:: Setting Breakpoints
-* Set Watchpoints:: Setting Watchpoints
-* Exception Handling:: Breakpoints and Exceptions
-* Delete Breaks:: Deleting Breakpoints
-* Disabling:: Disabling Breakpoints
-* Conditions:: Break Conditions
-* Break Commands:: Breakpoint Command Lists
-* Breakpoint Menus:: Breakpoint Menus
-* Error in Breakpoints:: ``Cannot insert breakpoints''
-
-Examining the Stack
-
-* Frames:: Stack Frames
-* Backtrace:: Backtraces
-* Selection:: Selecting a Frame
-* Frame Info:: Information on a Frame
-
-Examining Source Files
-
-* List:: Printing Source Lines
-* Search:: Searching Source Files
-* Source Path:: Specifying Source Directories
-* Machine Code:: Source and Machine Code
-
-Examining Data
-
-* Expressions:: Expressions
-* Variables:: Program Variables
-* Arrays:: Artificial Arrays
-* Output formats:: Output formats
-* Memory:: Examining Memory
-* Auto Display:: Automatic Display
-* Print Settings:: Print Settings
-* Value History:: Value History
-* Convenience Vars:: Convenience Variables
-* Registers:: Registers
-* Floating Point Hardware:: Floating Point Hardware
-
-Using GDB with Different Languages
-
-* Setting:: Switching between source languages
-* Show:: Displaying the language
-* Checks:: Type and Range checks
-* Support:: Supported languages
-
-Switching between source languages
-
-* Manually:: Setting the working language manually
-* Automatically:: Having GDB infer the source language
-
-Type and range Checking
-
-* Type Checking:: An overview of type checking
-* Range Checking:: An overview of range checking
-
-Supported Languages
-
-* C:: C and C++
-* Modula-2:: Modula-2
-
-C and C++
-
-* C Operators:: C and C++ Operators
-* C Constants:: C and C++ Constants
-* Cplusplus expressions:: C++ Expressions
-* C Defaults:: Default settings for C and C++
-* C Checks:: C and C++ Type and Range Checks
-* Debugging C:: _GDBN__ and C
-* Debugging C plus plus:: Special features for C++
-
-Modula-2
-
-* M2 Operators:: Built-in operators
-* Builtin Func/Proc:: Built-in Functions and Procedures
-* M2 Constants:: Modula-2 Constants
-* M2 Defaults:: Default settings for Modula-2
-* Deviations:: Deviations from standard Modula-2
-* M2 Checks:: Modula-2 Type and Range Checks
-* M2 Scope:: The scope operators @code{::} and @code{.}
-* GDB/M2:: GDB and Modula-2
-
-Altering Execution
-
-* Assignment:: Assignment to Variables
-* Jumping:: Continuing at a Different Address
-* Signaling:: Giving the Program a Signal
-* Returning:: Returning from a Function
-* Calling:: Calling your Program's Functions
-* Patching:: Patching your Program
-
-_GDBN__'s Files
-
-* Files:: Commands to Specify Files
-* Symbol Errors:: Errors Reading Symbol Files
-
-Specifying a Debugging Target
-
-* Active Targets:: Active Targets
-* Target Commands:: Commands for Managing Targets
-* Remote:: Remote Debugging
-
-Remote Debugging
-
-* i960-Nindy Remote:: _GDBN__ with a Remote i960 (Nindy)
-* EB29K Remote:: _GDBN__ with a Remote EB29K
-* VxWorks Remote:: _GDBN__ and VxWorks
-
-_GDBN__ with a Remote i960 (Nindy)
-
-* Nindy Startup:: Startup with Nindy
-* Nindy Options:: Options for Nindy
-* Nindy reset:: Nindy Reset Command
-
-_GDBN__ with a Remote EB29K
-
-* Comms (EB29K):: Communications Setup
-* gdb-EB29K:: EB29K cross-debugging
-* Remote Log:: Remote Log
-
-_GDBN__ and VxWorks
-
-* VxWorks connection:: Connecting to VxWorks
-* VxWorks download:: VxWorks Download
-* VxWorks attach:: Running Tasks
-
-Controlling _GDBN__
-
-* Prompt:: Prompt
-* Editing:: Command Editing
-* History:: Command History
-* Screen Size:: Screen Size
-* Numbers:: Numbers
-* Messages/Warnings:: Optional Warnings and Messages
-
-Canned Sequences of Commands
-
-* Define:: User-Defined Commands
-* Command Files:: Command Files
-* Output:: Commands for Controlled Output
-
-Reporting Bugs in _GDBN__
-
-* Bug Criteria:: Have You Found a Bug?
-* Bug Reporting:: How to Report Bugs
-
-Installing GDB
-
-* Subdirectories:: Configuration subdirectories
-* Config Names:: Specifying names for hosts and targets
-* configure Options:: Summary of options for configure
-* Formatting Documentation:: How to format and print GDB documentation
-@end menu
-
-@node Summary, New Features, Top, Top
-@unnumbered Summary of _GDBN__
-
-The purpose of a debugger such as _GDBN__ is to allow you to see what is
-going on ``inside'' another program while it executes---or what another
-program was doing at the moment it crashed.
-
-_GDBN__ can do four main kinds of things (plus other things in support of
-these) to help you catch bugs in the act:
-
-@itemize @bullet
-@item
-Start your program, specifying anything that might affect its behavior.
-
-@item
-Make your program stop on specified conditions.
-
-@item
-Examine what has happened, when your program has stopped.
-
-@item
-Change things in your program, so you can experiment with correcting the
-effects of one bug and go on to learn about another.
-@end itemize
-
-You can use _GDBN__ to debug programs written in C, C++, and Modula-2.
-Fortran support will be added when a GNU Fortran compiler is ready.
-
-@menu
-* Free Software:: Free Software
-* Contributors:: Contributors to GDB
-@end menu
-
-@node Free Software, Contributors, Summary, Summary
-@unnumberedsec Free Software
-_GDBN__ is @dfn{free software}, protected by the GNU General Public License (GPL).
-The GPL gives you the freedom to copy or adapt a licensed
-program---but every person getting a copy also gets with it the
-freedom to modify that copy (which means that they must get access to
-the source code), and the freedom to distribute further copies.
-Typical software companies use copyrights to limit your freedoms; the
-Free Software Foundation uses the GPL to preserve these freedoms.
-
-Fundamentally, the General Public License is a license which says that
-you have these freedoms and that you can't take these freedoms away
-from anyone else.
-
-@c FIXME: (passim) go through all xrefs, expanding to use text headings
-For full details, @pxref{Copying}.
-@node Contributors, , Free Software, Summary
-@unnumberedsec Contributors to GDB
-
-Richard Stallman was the original author of GDB, and of many other GNU
-programs. Many others have contributed to its development. This
-section attempts to credit major contributors. One of the virtues of
-free software is that everyone is free to contribute to it; with
-regret, we cannot actually acknowledge everyone here. The file
-@file{ChangeLog} in the GDB distribution approximates a blow-by-blow
-account.
-
-Changes much prior to version 2.0 are lost in the mists of time.
-
-@quotation
-@emph{Plea:} Additions to this section are particularly welcome. If you
-or your friends (or enemies; let's be evenhanded) have been unfairly
-omitted from this list, we would like to add your names!
-@end quotation
-
-So that they may not regard their long labor as thankless, we
-particularly thank those who shepherded GDB through major releases: John
-Gilmore (releases _GDB_VN__, 4.0); Jim Kingdon (releases 3.9, 3.5, 3.4, 3.3);
-and Randy Smith (releases 3.2, 3.1, 3.0). As major maintainer of GDB
-for some period, each contributed significantly to the structure,
-stability, and capabilities of the entire debugger.
-
-Richard Stallman, assisted at various times by Pete TerMaat, Chris
-Hanson, and Richard Mlynarik, handled releases through 2.8.
-
-Michael Tiemann is the author of most of the GNU C++ support in GDB,
-with significant additional contributions from Per Bothner. James
-Clark wrote the GNU C++ demangler. Early work on C++ was by Peter
-TerMaat (who also did much general update work leading to release 3.0).
-
-GDB _GDB_VN__ uses the BFD subroutine library to examine multiple
-object-file formats; BFD was a joint project of V. Gumby
-Henkel-Wallace, Rich Pixley, Steve Chamberlain, and John Gilmore.
-
-David Johnson wrote the original COFF support; Pace Willison did
-the original support for encapsulated COFF.
-
-Adam de Boor and Bradley Davis contributed the ISI Optimum V support.
-Per Bothner, Noboyuki Hikichi, and Alessandro Forin contributed MIPS
-support. Jean-Daniel Fekete contributed Sun 386i support. Chris
-Hanson improved the HP9000 support. Noboyuki Hikichi and Tomoyuki
-Hasei contributed Sony/News OS 3 support. David Johnson contributed
-Encore Umax support. Jyrki Kuoppala contributed Altos 3068 support.
-Keith Packard contributed NS32K support. Doug Rabson contributed
-Acorn Risc Machine support. Chris Smith contributed Convex support
-(and Fortran debugging). Jonathan Stone contributed Pyramid support.
-Michael Tiemann contributed SPARC support. Tim Tucker contributed
-support for the Gould NP1 and Gould Powernode. Pace Willison
-contributed Intel 386 support. Jay Vosburgh contributed Symmetry
-support.
-
-Rich Schaefer and Peter Schauer helped with support of SunOS shared
-libraries.
-
-Jay Fenlason and Roland McGrath ensured that GDB and GAS agree about
-several machine instruction sets.
-
-Patrick Duval, Ted Goldstein, Vikram Koka and Glenn Engel helped
-develop remote debugging. Intel Corporation and Wind River Systems
-contributed remote debugging modules for their products.
-
-Brian Fox is the author of the readline libraries providing
-command-line editing and command history.
-
-Andrew Beers of SUNY Buffalo wrote the language-switching code and
-the Modula-2 support, and contributed the Languages chapter of this
-manual.
-
-@node New Features, Sample Session, Summary, Top
-@unnumbered New Features since _GDBN__ version 3.5
-
-@table @emph
-@item Targets
-Using the new command @code{target}, you can select at runtime whether
-you are debugging local files, local processes, standalone systems over
-a serial port, realtime systems over a TCP/IP connection, etc. The
-command @code{load} can download programs into a remote system. Serial
-stubs are available for Motorola 680x0 and Intel 80386 remote systems;
-_GDBN__ also supports debugging realtime processes running under
-VxWorks, using SunRPC Remote Procedure Calls over TCP/IP to talk to a
-debugger stub on the target system. Internally, _GDBN__ now uses a
-function vector to mediate access to different targets; if you need to
-add your own support for a remote protocol, this makes it much easier.
-
-@item Watchpoints
-_GDBN__ now sports watchpoints as well as breakpoints. You can use a
-watchpoint to stop execution whenever the value of an expression
-changes, without having to predict a particular place in your program
-where this may happen.
-
-@item Wide Output
-Commands that issue wide output now insert newlines at places designed
-to make the output more readable.
-
-@item Object Code Formats
-_GDBN__ uses a new library called the Binary File Descriptor (BFD)
-Library to permit it to switch dynamically, without reconfiguration or
-recompilation, between different object-file formats. Formats currently
-supported are COFF, a.out, and the Intel 960 b.out; files may be read as
-.o's, archive libraries, or core dumps. BFD is available as a
-subroutine library so that other programs may take advantage of it, and
-the other GNU binary utilities are being converted to use it.
-
-@item Configuration and Ports
-Compile-time configuration (to select a particular architecture and
-operating system) is much easier. The script @code{configure} now
-allows you to configure _GDBN__ as either a native debugger or a
-cross-debugger. @xref{Installing _GDBN__} for details on how to
-configure and on what architectures are now available.
-
-@item Interaction
-The user interface to _GDBN__'s control variables has been simplified
-and consolidated in two commands, @code{set} and @code{show}. Output
-lines are now broken at readable places, rather than overflowing onto
-the next line. You can suppress output of machine-level addresses,
-displaying only source language information.
-
-
-@item C++
-_GDBN__ now supports C++ multiple inheritance (if used with a GCC
-version 2 compiler), and also has limited support for C++ exception
-handling, with the commands @code{catch} and @code{info catch}: _GDBN__
-can break when an exception is raised, before the stack is peeled back
-to the exception handler's context.
-
-@item Modula-2
-_GDBN__ now has preliminary support for the GNU Modula-2 compiler,
-currently under development at the State University of New York at
-Buffalo. Coordinated development of both _GDBN__ and the GNU Modula-2
-compiler will continue through the fall of 1991 and into 1992. Other
-Modula-2 compilers are currently not supported, and attempting to debug
-programs compiled with them will likely result in an error as the symbol
-table of the executable is read in.
-
-@item Command Rationalization
-Many _GDBN__ commands have been renamed to make them easier to remember
-and use. In particular, the subcommands of @code{info} and
-@code{show}/@code{set} are grouped to make the former refer to the state
-of your program, and the latter refer to the state of _GDBN__ itself.
-@xref{Renamed Commands}, for details on what commands were renamed.
-
-@item Shared Libraries
-_GDBN__ _GDB_VN__ can debug programs and core files that use SunOS shared
-libraries.
-
-@item Reference Card
-_GDBN__ _GDB_VN__ has a reference card; @xref{Formatting Documentation} for
-instructions on printing it.
-
-@item Work in Progress
-Kernel debugging for BSD and Mach systems; Tahoe and HPPA architecture
-support.
-
-@end table
-
-@node Sample Session, Invocation, New Features, Top
-@chapter A Sample _GDBN__ Session
-
-You can use this manual at your leisure to read all about _GDBN__.
-However, a handful of commands are enough to get started using the
-debugger. This chapter illustrates these commands.
-
-@iftex
-In this sample session, we emphasize user input like this: @i{input},
-to make it easier to pick out from the surrounding output.
-@end iftex
-
-@c FIXME: this example may not be appropriate for some configs, where
-@c FIXME...primary interest is in remote use.
-_0__
-One of the preliminary versions of GNU @code{m4} (a generic macro
-processor) exhibits the following bug: sometimes, when we change its
-quote strings from the default, the commands used to capture one macro's
-definition in another stop working. In the following short @code{m4}
-session, we define a macro @code{foo} which expands to @code{0000}; we
-then use the @code{m4} builtin @code{defn} to define @code{bar} as the
-same thing. However, when we change the open quote string to
-@code{<QUOTE>} and the close quote string to @code{<UNQUOTE>}, the same
-procedure fails to define a new synonym @code{baz}:
-
-@smallexample
-$ @i{cd gnu/m4}
-$ @i{./m4}
-@i{define(foo,0000)}
-
-@i{foo}
-0000
-@i{define(bar,defn(`foo'))}
-
-@i{bar}
-0000
-@i{changequote(<QUOTE>,<UNQUOTE>)}
-
-@i{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
-@i{baz}
-@i{C-d}
-m4: End of input: 0: fatal error: EOF in string
-@end smallexample
-
-@noindent
-Let's use _GDBN__ to try to see what's going on.
-
-@smallexample
-$ @i{_GDBP__ m4}
-GDB is free software and you are welcome to distribute copies of it
- under certain conditions; type "info copying" to see the conditions.
-There is absolutely no warranty for GDB; type "info warranty" for details.
-GDB _GDB_VN__, Copyright 1991 Free Software Foundation, Inc...
-(_GDBP__)
-@end smallexample
-
-@noindent
-_GDBN__ reads only enough symbol data to know where to find the rest
-when needed; as a result, the first prompt comes up very quickly. We
-then tell _GDBN__ to use a narrower display width than usual, so
-that examples will fit in this manual.
-
-@smallexample
-(_GDBP__) @i{set width 70}
-@end smallexample
-
-@noindent
-Let's see how the @code{m4} builtin @code{changequote} works.
-Having looked at the source, we know the relevant subroutine is
-@code{m4_changequote}, so we set a breakpoint there with _GDBN__'s
-@code{break} command.
-
-@smallexample
-(_GDBP__) @i{break m4_changequote}
-Breakpoint 1 at 0x62f4: file builtin.c, line 879.
-@end smallexample
-
-@noindent
-Using the @code{run} command, we start @code{m4} running under _GDBN__
-control; as long as control does not reach the @code{m4_changequote}
-subroutine, the program runs as usual:
-
-@smallexample
-(_GDBP__) @i{run}
-Starting program: /work/Editorial/gdb/gnu/m4/m4
-@i{define(foo,0000)}
-
-@i{foo}
-0000
-@end smallexample
-
-@noindent
-To trigger the breakpoint, we call @code{changequote}. _GDBN__
-suspends execution of @code{m4}, displaying information about the
-context where it stops.
-
-@smallexample
-@i{changequote(<QUOTE>,<UNQUOTE>)}
-
-Breakpoint 1, m4_changequote (argc=3, argv=0x33c70) at builtin.c:879
-879 if (bad_argc(TOKEN_DATA_TEXT(argv[0]), argc, 1, 3))
-@end smallexample
-
-@noindent
-Now we use the command @code{n} (@code{next}) to advance execution to
-the next line of the current function.
-
-@smallexample
-(_GDBP__) @i{n}
-882 set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1]) : nil,
-@end smallexample
-
-@noindent
-@code{set_quotes} looks like a promising subroutine. We can go into it
-by using the command @code{s} (@code{step}) instead of @code{next}.
-@code{step} goes to the next line to be executed in @emph{any}
-subroutine, so it steps into @code{set_quotes}.
-
-@smallexample
-(_GDBP__) @i{s}
-set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
- at input.c:530
-530 if (lquote != def_lquote)
-@end smallexample
-
-@noindent
-The summary display showing the subroutine where @code{m4} is now
-suspended (and its arguments) is called a stack frame display. We can
-use the @code{backtrace} command (which can also be spelled @code{bt}),
-to see where we are in the stack: it displays a stack frame for each
-active subroutine.
-
-@smallexample
-(_GDBP__) @i{bt}
-#0 set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
- at input.c:530
-#1 0x6344 in m4_changequote (argc=3, argv=0x33c70) at builtin.c:882
-#2 0x8174 in expand_macro (sym=0x33320) at macro.c:242
-#3 0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
- at macro.c:71
-#4 0x79dc in expand_input () at macro.c:40
-#5 0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
-@end smallexample
-
-@noindent
-Let's step through a few more lines to see what happens. The first two
-times, we can use @samp{s}; the next two times we use @code{n} to avoid
-falling into the @code{xstrdup} subroutine.
-@smallexample
-(_GDBP__) @i{s}
-0x3b5c 532 if (rquote != def_rquote)
-(_GDBP__) @i{s}
-0x3b80 535 lquote = (lq == nil || *lq == '\0') ? def_lquote :\
- xstrdup(lq);
-(_GDBP__) @i{n}
-536 rquote = (rq == nil || *rq == '\0') ? def_rquote : xstrdup\
-(rq);
-(_GDBP__) @i{n}
-538 len_lquote = strlen(rquote);
-@end smallexample
-
-@noindent
-The last line displayed looks a little odd; let's examine the variables
-@code{lquote} and @code{rquote} to see if they are in fact the new left
-and right quotes we specified. We can use the command @code{p}
-(@code{print}) to see their values.
-
-@smallexample
-(_GDBP__) @i{p lquote}
-$1 = 0x35d40 "<QUOTE>"
-(_GDBP__) @i{p rquote}
-$2 = 0x35d50 "<UNQUOTE>"
-@end smallexample
-
-@noindent
-@code{lquote} and @code{rquote} are indeed the new left and right quotes.
-Let's look at some context; we can display ten lines of source
-surrounding the current line, with the @code{l} (@code{list}) command.
-
-@smallexample
-(_GDBP__) @i{l}
-533 xfree(rquote);
-534
-535 lquote = (lq == nil || *lq == '\0') ? def_lquote : xstrdup\
-(lq);
-536 rquote = (rq == nil || *rq == '\0') ? def_rquote : xstrdup\
-(rq);
-537
-538 len_lquote = strlen(rquote);
-539 len_rquote = strlen(lquote);
-540 @}
-541
-542 void
-@end smallexample
-
-@noindent
-Let's step past the two lines that set @code{len_lquote} and
-@code{len_rquote}, and then examine the values of those variables.
-
-@smallexample
-(_GDBP__) @i{n}
-539 len_rquote = strlen(lquote);
-(_GDBP__) @i{n}
-540 @}
-(_GDBP__) @i{p len_lquote}
-$3 = 9
-(_GDBP__) @i{p len_rquote}
-$4 = 7
-@end smallexample
-
-@noindent
-That certainly looks wrong, assuming @code{len_lquote} and
-@code{len_rquote} are meant to be the lengths of @code{lquote} and
-@code{rquote} respectively. Let's try setting them to better values.
-We can use the @code{p} command for this, since it'll print the value of
-any expression---and that expression can include subroutine calls and
-assignments.
-
-@smallexample
-(_GDBP__) p len_lquote=strlen(lquote)
-$5 = 7
-(_GDBP__) p len_rquote=strlen(rquote)
-$6 = 9
-@end smallexample
-
-@noindent
-Let's see if that fixes the problem of using the new quotes with the
-@code{m4} built-in @code{defn}. We can allow @code{m4} to continue
-executing with the @code{c} (@code{continue}) command, and then try the
-example that caused trouble initially:
-
-@smallexample
-(_GDBP__) @i{c}
-Continuing.
-
-@i{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
-
-baz
-0000
-@end smallexample
-
-@noindent
-Success! The new quotes now work just as well as the default ones. The
-problem seems to have been just the two typos defining the wrong
-lengths. We'll let @code{m4} exit by giving it an EOF as input.
-
-@smallexample
-@i{C-d}
-Program exited normally.
-@end smallexample
-
-@noindent
-The message @samp{Program exited normally.} is from _GDBN__; it
-indicates @code{m4} has finished executing. We can end our _GDBN__
-session with the _GDBN__ @code{quit} command.
-
-@smallexample
-(_GDBP__) @i{quit}
-_1__@end smallexample
-
-@node Invocation, Commands, Sample Session, Top
-@chapter Getting In and Out of _GDBN__
-
-@menu
-* Starting _GDBN__:: Starting _GDBN__
-* Leaving _GDBN__:: Leaving _GDBN__
-* Shell Commands:: Shell Commands
-@end menu
-
-@node Starting _GDBN__, Leaving _GDBN__, Invocation, Invocation
-@section Starting _GDBN__
-
-_GDBN__ is invoked with the shell command @code{_GDBP__}. Once started,
-it reads commands from the terminal until you tell it to exit.
-
-You can run @code{_GDBP__} with no arguments or options; but the most
-usual way to start _GDBN__ is with one argument or two, specifying an
-executable program as the argument:
-@example
-_GDBP__ program
-@end example
-@noindent
-You can also start with both an executable program and a core file specified:
-@example
-_GDBP__ program core
-@end example
-
-You can, instead, specify a process ID as a second argument, if you want
-to debug a running process:
-@example
-_GDBP__ program 1234
-@end example
-@noindent
-would attach _GDBN__ to process @code{1234} (unless you also have a file
-named @file{1234}; _GDBN__ does check for a core file first).
-
-@noindent
-You can further control how _GDBN__ starts up by using command-line
-options. _GDBN__ itself can remind you of the options available:
-@example
-_GDBP__ -help
-@end example
-@noindent
-will display all available options and briefly describe their use
-(@samp{_GDBP__ -h} is a shorter equivalent).
-
-All options and command line arguments you give are processed
-in sequential order. The order makes a difference when the
-@samp{-x} option is used.
-
-@menu
-* File Options:: Choosing Files
-* Mode Options:: Choosing Modes
-_if__(!_GENERIC__)
-_include__(gdbinv-m.m4)_dnl__
-_fi__(!_GENERIC__)
-@end menu
-
-@node File Options, Mode Options, Starting _GDBN__, Starting _GDBN__
-@subsection Choosing Files
-
-As shown above, any arguments other than options specify an executable
-file and core file; that is, the first argument encountered with no
-associated option flag is equivalent to a @samp{-se} option, and the
-second, if any, is equivalent to a @samp{-c} option. Many options have
-both long and short forms; both are shown here. The long forms are also
-recognized if you truncate them, so long as enough of the option is
-present to be unambiguous. (If you prefer, you can flag option
-arguments with @samp{+} rather than @samp{-}, though we illustrate the
-more usual convention.)
-
-@table @code
-@item -symbols=@var{file}
-@itemx -s @var{file}
-Read symbol table from file @var{file}.
-
-@item -exec=@var{file}
-@itemx -e @var{file}
-Use file @var{file} as the executable file to execute when
-appropriate, and for examining pure data in conjunction with a core
-dump.
-
-@item -se=@var{file}
-Read symbol table from file @var{file} and use it as the executable
-file.
-
-@item -core=@var{file}
-@itemx -c @var{file}
-Use file @var{file} as a core dump to examine.
-
-@item -command=@var{file}
-@itemx -x @var{file}
-Execute _GDBN__ commands from file @var{file}. @xref{Command Files}.
-
-@item -directory=@var{directory}
-@itemx -d @var{directory}
-Add @var{directory} to the path to search for source files.
-@end table
-
-_if__(!_GENERIC__)
-@node Mode Options, Mode Options, File Options, Starting _GDBN__
-_fi__(!_GENERIC__)
-_if__(_GENERIC__)
-@node Mode Options, , File Options, Starting _GDBN__
-_fi__(_GENERIC__)
-@subsection Choosing Modes
-
-@table @code
-@item -nx
-@itemx -n
-Do not execute commands from any @file{_GDBINIT__} initialization files.
-Normally, the commands in these files are executed after all the
-command options and arguments have been processed.
-@xref{Command Files}.
-
-@item -quiet
-@itemx -q
-``Quiet''. Do not print the introductory and copyright messages. These
-messages are also suppressed in batch mode.
-
-@item -batch
-Run in batch mode. Exit with status @code{0} after processing all the command
-files specified with @samp{-x} (and @file{_GDBINIT__}, if not inhibited).
-Exit with nonzero status if an error occurs in executing the _GDBN__
-commands in the command files.
-
-Batch mode may be useful for running _GDBN__ as a filter, for example to
-download and run a program on another computer; in order to make this
-more useful, the message
-@example
-Program exited normally.
-@end example
-@noindent
-(which is ordinarily issued whenever a program running under _GDBN__ control
-terminates) is not issued when running in batch mode.
-
-@item -cd=@var{directory}
-Run _GDBN__ using @var{directory} as its working directory,
-instead of the current directory.
-
-@item -fullname
-@itemx -f
-Emacs sets this option when it runs _GDBN__ as a subprocess. It tells _GDBN__
-to output the full file name and line number in a standard,
-recognizable fashion each time a stack frame is displayed (which
-includes each time the program stops). This recognizable format looks
-like two @samp{\032} characters, followed by the file name, line number
-and character position separated by colons, and a newline. The
-Emacs-to-_GDBN__ interface program uses the two @samp{\032} characters as
-a signal to display the source code for the frame.
-
-@item -b @var{bps}
-Set the line speed (baud rate or bits per second) of any serial
-interface used by _GDBN__ for remote debugging.
-
-@item -tty=@var{device}
-Run using @var{device} for your program's standard input and output.
-@c FIXME: kingdon thinks there's more to -tty. Investigate.
-@end table
-
-_if__(!_GENERIC__)
-_include__(gdbinv-s.m4)
-_fi__(!_GENERIC__)
-
-@node Leaving _GDBN__, Shell Commands, Starting _GDBN__, Invocation
-@section Leaving _GDBN__
-@cindex exiting _GDBN__
-@table @code
-@item quit
-@kindex quit
-@kindex q
-To exit _GDBN__, use the @code{quit} command (abbreviated @code{q}), or type
-an end-of-file character (usually @kbd{C-d}).
-@end table
-
-@cindex interrupt
-An interrupt (often @kbd{C-c}) will not exit from _GDBN__, but rather
-will terminate the action of any _GDBN__ command that is in progress and
-return to _GDBN__ command level. It is safe to type the interrupt
-character at any time because _GDBN__ does not allow it to take effect
-until a time when it is safe.
-
-If you've been using _GDBN__ to control an attached process or device,
-you can release it with the @code{detach} command; @pxref{Attach}.
-
-@node Shell Commands, , Leaving _GDBN__, Invocation
-@section Shell Commands
-If you need to execute occasional shell commands during your
-debugging session, there's no need to leave or suspend _GDBN__; you can
-just use the @code{shell} command.
-
-@table @code
-@item shell @var{command string}
-@kindex shell
-@cindex shell escape
-Directs _GDBN__ to invoke an inferior shell to execute @var{command
-string}. If it exists, the environment variable @code{SHELL} is used
-for the name of the shell to run. Otherwise _GDBN__ uses
-@code{/bin/sh}.
-@end table
-
-The utility @code{make} is often needed in development environments.
-You don't have to use the @code{shell} command for this purpose in _GDBN__:
-
-@table @code
-@item make @var{make-args}
-@kindex make
-@cindex calling make
-Causes _GDBN__ to execute an inferior @code{make} program with the specified
-arguments. This is equivalent to @samp{shell make @var{make-args}}.
-@end table
-
-@node Commands, Running, Invocation, Top
-@chapter _GDBN__ Commands
-
-@menu
-* Command Syntax:: Command Syntax
-* Help:: Getting Help
-@end menu
-
-@node Command Syntax, Help, Commands, Commands
-@section Command Syntax
-A _GDBN__ command is a single line of input. There is no limit on how long
-it can be. It starts with a command name, which is followed by arguments
-whose meaning depends on the command name. For example, the command
-@code{step} accepts an argument which is the number of times to step,
-as in @samp{step 5}. You can also use the @code{step} command with
-no arguments. Some command names do not allow any arguments.
-
-@cindex abbreviation
-_GDBN__ command names may always be truncated if that abbreviation is
-unambiguous. Other possible command abbreviations are listed in the
-documentation for individual commands. In some cases, even ambiguous
-abbreviations are allowed; for example, @code{s} is specially defined as
-equivalent to @code{step} even though there are other commands whose
-names start with @code{s}. You can test abbreviations by using them as
-arguments to the @code{help} command.
-
-@cindex repeating commands
-@kindex RET
-A blank line as input to _GDBN__ (typing just @key{RET}) means to
-repeat the previous command. Certain commands (for example, @code{run})
-will not repeat this way; these are commands for which unintentional
-repetition might cause trouble and which you are unlikely to want to
-repeat.
-
-The @code{list} and @code{x} commands, when you repeat them with
-@key{RET}, construct new arguments rather than repeating
-exactly as typed. This permits easy scanning of source or memory.
-
-_GDBN__ can also use @key{RET} in another way: to partition lengthy
-output, in a way similar to the common utility @code{more}
-(@pxref{Screen Size}). Since it's easy to press one @key{RET} too many
-in this situation, _GDBN__ disables command repetition after any command
-that generates this sort of display.
-
-@kindex #
-@cindex comment
-A line of input starting with @kbd{#} is a comment; it does nothing.
-This is useful mainly in command files (@xref{Command Files}).
-
-@node Help, , Command Syntax, Commands
-@section Getting Help
-@cindex online documentation
-@kindex help
-You can always ask _GDBN__ itself for information on its commands, using the
-command @code{help}.
-
-@table @code
-@item help
-@itemx h
-@kindex h
-You can use @code{help} (abbreviated @code{h}) with no arguments to
-display a short list of named classes of commands:
-@smallexample
-(_GDBP__) help
-List of classes of commands:
-
-running -- Running the program
-stack -- Examining the stack
-data -- Examining data
-breakpoints -- Making program stop at certain points
-files -- Specifying and examining files
-status -- Status inquiries
-support -- Support facilities
-user-defined -- User-defined commands
-aliases -- Aliases of other commands
-obscure -- Obscure features
-
-Type "help" followed by a class name for a list of commands in that class.
-Type "help" followed by command name for full documentation.
-Command name abbreviations are allowed if unambiguous.
-(_GDBP__)
-@end smallexample
-
-@item help @var{class}
-Using one of the general help classes as an argument, you can get a
-list of the individual commands in that class. For example, here is the
-help display for the class @code{status}:
-@smallexample
-(_GDBP__) help status
-Status inquiries.
-
-List of commands:
-
-show -- Generic command for showing things set with "set"
-info -- Generic command for printing status
-
-Type "help" followed by command name for full documentation.
-Command name abbreviations are allowed if unambiguous.
-(_GDBP__)
-@end smallexample
-
-@item help @var{command}
-With a command name as @code{help} argument, _GDBN__ will display a
-short paragraph on how to use that command.
-@end table
-
-In addition to @code{help}, you can use the _GDBN__ commands @code{info}
-and @code{show} to inquire about the state of your program, or the state
-of _GDBN__ itself. Each command supports many topics of inquiry; this
-manual introduces each of them in the appropriate context. The listings
-under @code{info} and under @code{show} in the Index point to
-all the sub-commands.
-@c FIXME: @pxref{Index} used to be here, but even though it shows up in
-@c FIXME...the 'aux' file with a pageno the xref can't find it.
-
-@c @group
-@table @code
-@item info
-@kindex info
-@kindex i
-This command (abbreviated @code{i}) is for describing the state of your
-program; for example, it can list the arguments given to your program
-(@code{info args}), the registers currently in use (@code{info
-registers}), or the breakpoints you've set (@code{info breakpoints}).
-You can get a complete list of the @code{info} sub-commands with
-@w{@code{help info}}.
-
-@kindex show
-@item show
-In contrast, @code{show} is for describing the state of _GDBN__ itself.
-You can change most of the things you can @code{show}, by using the
-related command @code{set}; for example, you can control what number
-system is used for displays with @code{set radix}, or simply inquire
-which is currently in use with @code{show radix}.
-
-@kindex info set
-To display all the settable parameters and their current
-values, you can use @code{show} with no arguments; you may also use
-@code{info set}. Both commands produce the same display.
-@c FIXME: "info set" violates the rule that "info" is for state of
-@c FIXME...program. Ck w/ GNU: "info set" to be called something else,
-@c FIXME...or change desc of rule---eg "state of prog and debugging session"?
-@end table
-@c @end group
-
-Here are three miscellaneous @code{show} subcommands, all of which are
-exceptional in lacking corresponding @code{set} commands:
-
-@table @code
-@kindex show version
-@cindex version number
-@item show version
-Show what version of _GDBN__ is running. You should include this
-information in _GDBN__ bug-reports. If multiple versions of _GDBN__ are
-in use at your site, you may occasionally want to make sure what version
-of _GDBN__ you're running; as _GDBN__ evolves, new commands are
-introduced, and old ones may wither away. The version number is also
-announced when you start _GDBN__ with no arguments.
-
-@kindex show copying
-@item show copying
-Display information about permission for copying _GDBN__.
-
-@kindex show warranty
-@item show warranty
-Display the GNU ``NO WARRANTY'' statement.
-@end table
-
-@node Running, Stopping, Commands, Top
-@chapter Running Programs Under _GDBN__
-
-@menu
-* Compilation:: Compiling for Debugging
-* Starting:: Starting your Program
-* Arguments:: Your Program's Arguments
-* Environment:: Your Program's Environment
-* Working Directory:: Your Program's Working Directory
-* Input/Output:: Your Program's Input and Output
-* Attach:: Debugging an Already-Running Process
-* Kill Process:: Killing the Child Process
-@end menu
-
-@node Compilation, Starting, Running, Running
-@section Compiling for Debugging
-
-In order to debug a program effectively, you need to generate
-debugging information when you compile it. This debugging information
-is stored in the object file; it describes the data type of each
-variable or function and the correspondence between source line numbers
-and addresses in the executable code.
-
-To request debugging information, specify the @samp{-g} option when you run
-the compiler.
-
-Many C compilers are unable to handle the @samp{-g} and @samp{-O}
-options together. Using those compilers, you cannot generate optimized
-executables containing debugging information.
-
-The GNU C compiler supports @samp{-g} with or without @samp{-O}, making it
-possible to debug optimized code. We recommend that you @emph{always} use
-@samp{-g} whenever you compile a program. You may think the program is
-correct, but there's no sense in pushing your luck.
-
-Some things do not work as well with @samp{-g -O} as with just
-@samp{-g}, particularly on machines with instruction scheduling. If in
-doubt, recompile with @samp{-g} alone, and if this fixes the problem,
-please report it as a bug (including a test case!).
-
-Older versions of the GNU C compiler permitted a variant option
-@samp{-gg} for debugging information. _GDBN__ no longer supports this
-format; if your GNU C compiler has this option, do not use it.
-
-@ignore
-@comment As far as I know, there are no cases in which _GDBN__ will
-@comment produce strange output in this case. (but no promises).
-If your program includes archives made with the @code{ar} program, and
-if the object files used as input to @code{ar} were compiled without the
-@samp{-g} option and have names longer than 15 characters, _GDBN__ will get
-confused reading the program's symbol table. No error message will be
-given, but _GDBN__ may behave strangely. The reason for this problem is a
-deficiency in the Unix archive file format, which cannot represent file
-names longer than 15 characters.
-
-To avoid this problem, compile the archive members with the @samp{-g}
-option or use shorter file names. Alternatively, use a version of GNU
-@code{ar} dated more recently than August 1989.
-@end ignore
-
-
-@node Starting, Arguments, Compilation, Running
-@section Starting your Program
-@cindex starting
-@cindex running
-@table @code
-@item run
-@itemx r
-@kindex run
-Use the @code{run} command to start your program under _GDBN__. You
-must first specify the program name
-_if__(_VXWORKS__)
-(except on VxWorks)
-_fi__(_VXWORKS__)
-with an argument to _GDBN__
-(@pxref{Invocation}), or using the @code{file} or @code{exec-file}
-command (@pxref{Files}).
-@refill
-@end table
-
-On targets that support processes, @code{run} creates an inferior
-process and makes that process run your program. On other targets,
-@code{run} jumps to the start of the program.
-
-The execution of a program is affected by certain information it
-receives from its superior. _GDBN__ provides ways to specify this
-information, which you must do @i{before} starting the program. (You
-can change it after starting the program, but such changes will only affect
-the program the next time you start it.) This information may be
-divided into four categories:
-
-@table @asis
-@item The @i{arguments.}
-You specify the arguments to give your program as the arguments of the
-@code{run} command. If a shell is available on your target, the shell
-is used to pass the arguments, so that you may use normal conventions
-(such as wildcard expansion or variable substitution) in
-describing the arguments. In Unix systems, you can control which shell
-is used with the @code{SHELL} environment variable. @xref{Arguments}.@refill
-
-@item The @i{environment.}
-Your program normally inherits its environment from _GDBN__, but you can
-use the _GDBN__ commands @code{set environment} and @code{unset
-environment} to change parts of the environment that will be given to
-the program. @xref{Environment}.@refill
-
-@item The @i{working directory.}
-Your program inherits its working directory from _GDBN__. You can set
-_GDBN__'s working directory with the @code{cd} command in _GDBN__.
-@xref{Working Directory}.
-
-@item The @i{standard input and output.}
-Your program normally uses the same device for standard input and
-standard output as _GDBN__ is using. You can redirect input and output
-in the @code{run} command line, or you can use the @code{tty} command to
-set a different device for your program.
-@xref{Input/Output}.
-
-@cindex pipes
-@emph{Warning:} While input and output redirection work, you can't use
-pipes to pass the output of the program you're debugging to another
-program; if you attempt this, _GDBN__ is likely to wind up debugging the
-wrong program.
-@end table
-
-When you issue the @code{run} command, your program begins to execute
-immediately. @xref{Stopping}, for discussion of how to arrange for your
-program to stop. Once your program has been started by the @code{run}
-command (and then stopped), you may evaluate expressions that involve
-calls to functions in the inferior, using the @code{print} or
-@code{call} commands. @xref{Data}.
-
-If the modification time of your symbol file has changed since the last
-time _GDBN__ read its symbols, _GDBN__ will discard its symbol table and re-read
-it. In this process, it tries to retain your current breakpoints.
-
-@node Arguments, Environment, Starting, Running
-@section Your Program's Arguments
-
-@cindex arguments (to your program)
-The arguments to your program can be specified by the arguments of the
-@code{run} command. They are passed to a shell, which expands wildcard
-characters and performs redirection of I/O, and thence to the program.
-_GDBN__ uses the shell indicated by your environment variable
-@code{SHELL} if it exists; otherwise, _GDBN__ uses @code{/bin/sh}.
-
-@code{run} with no arguments uses the same arguments used by the previous
-@code{run}, or those set by the @code{set args} command.
-
-@kindex set args
-@table @code
-@item set args
-Specify the arguments to be used the next time your program is run. If
-@code{set args} has no arguments, @code{run} will execute your program
-with no arguments. Once you have run your program with arguments,
-using @code{set args} before the next @code{run} is the only way to run
-it again without arguments.
-
-@item show args
-@kindex show args
-Show the arguments to give your program when it is started.
-@end table
-
-@node Environment, Working Directory, Arguments, Running
-@section Your Program's Environment
-
-@cindex environment (of your program)
-The @dfn{environment} consists of a set of environment variables and
-their values. Environment variables conventionally record such things as
-your user name, your home directory, your terminal type, and your search
-path for programs to run. Usually you set up environment variables with
-the shell and they are inherited by all the other programs you run. When
-debugging, it can be useful to try running the program with a modified
-environment without having to start _GDBN__ over again.
-
-@table @code
-@item path @var{directory}
-@kindex path
-Add @var{directory} to the front of the @code{PATH} environment variable
-(the search path for executables), for both _GDBN__ and your program.
-You may specify several directory names, separated by @samp{:} or
-whitespace. If @var{directory} is already in the path, it is moved to
-the front, so it will be searched sooner.
-
-You can use the string @samp{$cwd} to refer to whatever is the current
-working directory at the time _GDBN__ searches the path. If you use
-@samp{.} instead, it refers to the directory where you executed the
-@code{path} command. _GDBN__ fills in the current path where needed in
-the @var{directory} argument, before adding it to the search path.
-@c 'path' is explicitly nonrepeatable, but RMS points out it's silly to
-@c document that, since repeating it would be a no-op.
-
-@item show paths
-@kindex show paths
-Display the list of search paths for executables (the @code{PATH}
-environment variable).
-
-@item show environment @r{[}@var{varname}@r{]}
-@kindex show environment
-Print the value of environment variable @var{varname} to be given to
-your program when it starts. If you don't supply @var{varname},
-print the names and values of all environment variables to be given to
-your program. You can abbreviate @code{environment} as @code{env}.
-
-@item set environment @var{varname} @r{[}=@r{]} @var{value}
-@kindex set environment
-Sets environment variable @var{varname} to @var{value}. The value
-changes for your program only, not for _GDBN__ itself. @var{value} may
-be any string; the values of environment variables are just strings, and
-any interpretation is supplied by your program itself. The @var{value}
-parameter is optional; if it is eliminated, the variable is set to a
-null value.
-@c "any string" here doesn't include leading, trailing
-@c blanks. Gnu asks: does anyone care?
-
-For example, this command:
-
-@example
-set env USER = foo
-@end example
-
-@noindent
-tells a Unix program, when subsequently run, that its user is named
-@samp{foo}. (The spaces around @samp{=} are used for clarity here; they
-are not actually required.)
-
-@item unset environment @var{varname}
-@kindex unset environment
-Remove variable @var{varname} from the environment to be passed to your
-program. This is different from @samp{set env @var{varname} =};
-@code{unset environment} removes the variable from the environment,
-rather than assigning it an empty value.
-@end table
-
-@node Working Directory, Input/Output, Environment, Running
-@section Your Program's Working Directory
-
-@cindex working directory (of your program)
-Each time you start your program with @code{run}, it inherits its
-working directory from the current working directory of _GDBN__. _GDBN__'s
-working directory is initially whatever it inherited from its parent
-process (typically the shell), but you can specify a new working
-directory in _GDBN__ with the @code{cd} command.
-
-The _GDBN__ working directory also serves as a default for the commands
-that specify files for _GDBN__ to operate on. @xref{Files}.
-
-@table @code
-@item cd @var{directory}
-@kindex cd
-Set _GDBN__'s working directory to @var{directory}.
-
-@item pwd
-@kindex pwd
-Print _GDBN__'s working directory.
-@end table
-
-@node Input/Output, Attach, Working Directory, Running
-@section Your Program's Input and Output
-
-@cindex redirection
-@cindex i/o
-@cindex terminal
-By default, the program you run under _GDBN__ does input and output to
-the same terminal that _GDBN__ uses. _GDBN__ switches the terminal to
-its own terminal modes to interact with you, but it records the terminal
-modes your program was using and switches back to them when you continue
-running your program.
-
-@table @code
-@item info terminal
-@kindex info terminal
-Displays _GDBN__'s recorded information about the terminal modes your
-program is using.
-@end table
-
-You can redirect the program's input and/or output using shell
-redirection with the @code{run} command. For example,
-
-_0__@example
-run > outfile
-_1__@end example
-
-@noindent
-starts the program, diverting its output to the file @file{outfile}.
-
-@kindex tty
-@cindex controlling terminal
-Another way to specify where the program should do input and output is
-with the @code{tty} command. This command accepts a file name as
-argument, and causes this file to be the default for future @code{run}
-commands. It also resets the controlling terminal for the child
-process, for future @code{run} commands. For example,
-
-@example
-tty /dev/ttyb
-@end example
-
-@noindent
-directs that processes started with subsequent @code{run} commands
-default to do input and output on the terminal @file{/dev/ttyb} and have
-that as their controlling terminal.
-
-An explicit redirection in @code{run} overrides the @code{tty} command's
-effect on the input/output device, but not its effect on the controlling
-terminal.
-
-When you use the @code{tty} command or redirect input in the @code{run}
-command, only the input @emph{for your program} is affected. The input
-for _GDBN__ still comes from your terminal.
-
-@node Attach, Kill Process, Input/Output, Running
-@section Debugging an Already-Running Process
-@kindex attach
-@cindex attach
-
-@table @code
-@item attach @var{process-id}
-This command
-attaches to a running process---one that was started outside _GDBN__.
-(@code{info files} will show your active targets.) The command takes as
-argument a process ID. The usual way to find out the process-id of
-a Unix process is with the @code{ps} utility, or with the @samp{jobs -l}
-shell command.
-
-@code{attach} will not repeat if you press @key{RET} a second time after
-executing the command.
-@end table
-
-To use @code{attach}, you must be debugging in an environment which
-supports processes. You must also have permission to send the process a
-signal, and it must have the same effective user ID as the _GDBN__
-process.
-
-When using @code{attach}, you should first use the @code{file} command
-to specify the program running in the process and load its symbol table.
-@xref{Files}.
-
-The first thing _GDBN__ does after arranging to debug the specified
-process is to stop it. You can examine and modify an attached process
-with all the _GDBN__ commands that are ordinarily available when you start
-processes with @code{run}. You can insert breakpoints; you can step and
-continue; you can modify storage. If you would rather the process
-continue running, you may use the @code{continue} command after
-attaching _GDBN__ to the process.
-
-@table @code
-@item detach
-@kindex detach
-When you have finished debugging the attached process, you can use the
-@code{detach} command to release it from _GDBN__'s control. Detaching
-the process continues its execution. After the @code{detach} command,
-that process and _GDBN__ become completely independent once more, and you
-are ready to @code{attach} another process or start one with @code{run}.
-@code{detach} will not repeat if you press @key{RET} again after
-executing the command.
-@end table
-
-If you exit _GDBN__ or use the @code{run} command while you have an attached
-process, you kill that process. By default, you will be asked for
-confirmation if you try to do either of these things; you can control
-whether or not you need to confirm by using the @code{set confirm} command
-(@pxref{Messages/Warnings}).
-
-@node Kill Process, , Attach, Running
-@c @group
-@section Killing the Child Process
-
-@table @code
-@item kill
-@kindex kill
-Kill the child process in which your program is running under _GDBN__.
-@end table
-
-This command is useful if you wish to debug a core dump instead of a
-running process. _GDBN__ ignores any core dump file while your program
-is running.
-@c @end group
-
-On some operating systems, a program can't be executed outside _GDBN__
-while you have breakpoints set on it inside _GDBN__. You can use the
-@code{kill} command in this situation to permit running the program
-outside the debugger.
-
-The @code{kill} command is also useful if you wish to recompile and
-relink the program, since on many systems it is impossible to modify an
-executable file while it is running in a process. In this case, when you
-next type @code{run}, _GDBN__ will notice that the file has changed, and
-will re-read the symbol table (while trying to preserve your current
-breakpoint settings).
-
-@node Stopping, Stack, Running, Top
-@chapter Stopping and Continuing
-
-The principal purpose of using a debugger is so that you can stop your
-program before it terminates; or so that, if the program runs into
-trouble, you can investigate and find out why.
-
-Inside _GDBN__, your program may stop for any of several reasons, such
-as a signal, a breakpoint, or reaching a new line after a _GDBN__
-command such as @code{step}. You may then examine and change
-variables, set new breakpoints or remove old ones, and then continue
-execution. Usually, the messages shown by _GDBN__ provide ample
-explanation of the status of your program---but you can also explicitly
-request this information at any time.
-
-@table @code
-@item info program
-@kindex info program
-Display information about the status of your program: whether it is
-running or not, what process it is, and why it stopped.
-@end table
-
-@menu
-* Breakpoints:: Breakpoints, Watchpoints, and Exceptions
-* Continuing and Stepping:: Resuming Execution
-* Signals:: Signals
-@end menu
-
-@node Breakpoints, Continuing and Stepping, Stopping, Stopping
-@section Breakpoints, Watchpoints, and Exceptions
-
-@cindex breakpoints
-A @dfn{breakpoint} makes your program stop whenever a certain point in
-the program is reached. For each breakpoint, you can add various
-conditions to control in finer detail whether the program will stop.
-You can set breakpoints with the @code{break} command and its variants
-(@pxref{Set Breaks}), to specify the place where the program should stop
-by line number, function name or exact address in the program. In
-languages with exception handling (such as GNU C++), you can also set
-breakpoints where an exception is raised (@pxref{Exception Handling}).
-
-@cindex watchpoints
-A @dfn{watchpoint} is a special breakpoint that stops your program when
-the value of an expression changes. You must use a different command to
-set watchpoints (@pxref{Set Watchpoints}), but aside from that, you can
-manage a watchpoint like any other breakpoint: you enable, disable, and
-delete both breakpoints and watchpoints using the same commands.
-
-Each breakpoint or watchpoint is assigned a number when it is created;
-these numbers are successive integers starting with one. In many of the
-commands for controlling various features of breakpoints you use the
-breakpoint number to say which breakpoint you want to change. Each
-breakpoint may be @dfn{enabled} or @dfn{disabled}; if disabled, it has
-no effect on the program until you enable it again.
-
-@menu
-* Set Breaks:: Setting Breakpoints
-* Set Watchpoints:: Setting Watchpoints
-* Exception Handling:: Breakpoints and Exceptions
-* Delete Breaks:: Deleting Breakpoints
-* Disabling:: Disabling Breakpoints
-* Conditions:: Break Conditions
-* Break Commands:: Breakpoint Command Lists
-* Breakpoint Menus:: Breakpoint Menus
-* Error in Breakpoints::
-@end menu
-
-@node Set Breaks, Set Watchpoints, Breakpoints, Breakpoints
-@subsection Setting Breakpoints
-
-@kindex break
-@kindex b
-Breakpoints are set with the @code{break} command (abbreviated @code{b}).
-
-You have several ways to say where the breakpoint should go.
-
-@table @code
-@item break @var{function}
-Set a breakpoint at entry to function @var{function}. When using source
-languages that permit overloading of symbols, such as C++,
-@var{function} may refer to more than one possible place to break.
-@xref{Breakpoint Menus}, for a discussion of that situation.
-
-@item break +@var{offset}
-@itemx break -@var{offset}
-Set a breakpoint some number of lines forward or back from the position
-at which execution stopped in the currently selected frame.
-
-@item break @var{linenum}
-Set a breakpoint at line @var{linenum} in the current source file.
-That file is the last file whose source text was printed. This
-breakpoint will stop the program just before it executes any of the
-code on that line.
-
-@item break @var{filename}:@var{linenum}
-Set a breakpoint at line @var{linenum} in source file @var{filename}.
-
-@item break @var{filename}:@var{function}
-Set a breakpoint at entry to function @var{function} found in file
-@var{filename}. Specifying a file name as well as a function name is
-superfluous except when multiple files contain similarly named
-functions.
-
-@item break *@var{address}
-Set a breakpoint at address @var{address}. You can use this to set
-breakpoints in parts of the program which do not have debugging
-information or source files.
-
-@item break
-When called without any arguments, @code{break} sets a breakpoint at the
-next instruction to be executed in the selected stack frame
-(@pxref{Stack}). In any selected frame but the innermost, this will
-cause the program to stop as soon as control returns to that frame.
-This is similar to the effect of a @code{finish} command in the frame
-inside the selected frame---except that @code{finish} doesn't leave an
-active breakpoint. If you use @code{break} without an argument in the
-innermost frame, _GDBN__ will stop the next time it reaches the current
-location; this may be useful inside loops.
-
-_GDBN__ normally ignores breakpoints when it resumes execution, until at
-least one instruction has been executed. If it did not do this, you
-would be unable to proceed past a breakpoint without first disabling the
-breakpoint. This rule applies whether or not the breakpoint already
-existed when the program stopped.
-
-@item break @dots{} if @var{cond}
-Set a breakpoint with condition @var{cond}; evaluate the expression
-@var{cond} each time the breakpoint is reached, and stop only if the
-value is nonzero---that is, if @var{cond} evaluates as true.
-@samp{@dots{}} stands for one of the possible arguments described above
-(or no argument) specifying where to break. @xref{Conditions}, for more
-information on breakpoint conditions.
-
-@item tbreak @var{args}
-@kindex tbreak
-Set a breakpoint enabled only for one stop. @var{args} are the
-same as for the @code{break} command, and the breakpoint is set in the same
-way, but the breakpoint is automatically disabled the first time it
-is hit. @xref{Disabling}.
-
-@item rbreak @var{regex}
-@kindex rbreak
-@cindex regular expression
-Set breakpoints on all functions matching the regular expression
-@var{regex}. This command
-sets an unconditional breakpoint on all matches, printing a list of all
-breakpoints it set. Once these breakpoints are set, they are treated
-just like the breakpoints set with the @code{break} command. They can
-be deleted, disabled, made conditional, etc., in the standard ways.
-
-When debugging C++ programs, @code{rbreak} is useful for setting
-breakpoints on overloaded functions that are not members of any special
-classes.
-
-@kindex info breakpoints
-@cindex @code{$_} and @code{info breakpoints}
-@item info breakpoints @r{[}@var{n}@r{]}
-@item info break @r{[}@var{n}@r{]}
-Print a list of all breakpoints (but not watchpoints) set and not
-deleted, showing their numbers, where in the program they are, and any
-special features in use for them. Disabled breakpoints are included in
-the list, but marked as disabled. @code{info break} with a breakpoint
-number @var{n} as argument lists only that breakpoint. The convenience
-variable @code{$_} and the default examining-address for the @code{x}
-command are set to the address of the last breakpoint listed
-(@pxref{Memory}). The equivalent command for watchpoints is @code{info
-watch}. @end table
-
-_GDBN__ allows you to set any number of breakpoints at the same place in the
-program. There is nothing silly or meaningless about this. When the
-breakpoints are conditional, this is even useful (@pxref{Conditions}).
-
-@node Set Watchpoints, Exception Handling, Set Breaks, Breakpoints
-@subsection Setting Watchpoints
-@cindex setting watchpoints
-You can use a watchpoint to stop execution whenever the value of an
-expression changes, without having to predict a particular place
-where this may happen.
-
-Watchpoints currently execute two orders of magnitude more slowly than
-other breakpoints, but this can well be worth it to catch errors where
-you have no clue what part of your program is the culprit. Some
-processors provide special hardware to support watchpoint evaluation; future
-releases of _GDBN__ will use such hardware if it is available.
-
-@table @code
-@kindex watch
-@item watch @var{expr}
-Set a watchpoint for an expression.
-
-@kindex info watchpoints
-@item info watchpoints
-This command prints a list of watchpoints; it is otherwise similar to
-@code{info break}.
-@end table
-
-@node Exception Handling, Delete Breaks, Set Watchpoints, Breakpoints
-@subsection Breakpoints and Exceptions
-@cindex exception handlers
-
-Some languages, such as GNU C++, implement exception handling. You can
-use _GDBN__ to examine what caused the program to raise an exception,
-and to list the exceptions the program is prepared to handle at a
-given point in time.
-
-@table @code
-@item catch @var{exceptions}
-@kindex catch
-You can set breakpoints at active exception handlers by using the
-@code{catch} command. @var{exceptions} is a list of names of exceptions
-to catch.
-@end table
-
-You can use @code{info catch} to list active exception handlers;
-@pxref{Frame Info}.
-
-There are currently some limitations to exception handling in _GDBN__.
-These will be corrected in a future release.
-
-@itemize @bullet
-@item
-If you call a function interactively, _GDBN__ normally returns
-control to you when the function has finished executing. If the call
-raises an exception, however, the call may bypass the mechanism that
-returns control to the user and cause the program to simply continue
-running until it hits a breakpoint, catches a signal that _GDBN__ is
-listening for, or exits.
-@item
-You cannot raise an exception interactively.
-@item
-You cannot interactively install an exception handler.
-@end itemize
-
-@cindex raise exceptions
-Sometimes @code{catch} is not the best way to debug exception handling:
-if you need to know exactly where an exception is raised, it's better to
-stop @emph{before} the exception handler is called, since that way you
-can see the stack before any unwinding takes place. If you set a
-breakpoint in an exception handler instead, it may not be easy to find
-out where the exception was raised.
-
-To stop just before an exception handler is called, you need some
-knowledge of the implementation. In the case of GNU C++, exceptions are
-raised by calling a library function named @code{__raise_exception}
-which has the following ANSI C interface:
-
-@example
- /* @var{addr} is where the exception identifier is stored.
- ID is the exception identifier. */
- void __raise_exception (void **@var{addr}, void *@var{id});
-@end example
-
-@noindent
-To make the debugger catch all exceptions before any stack
-unwinding takes place, set a breakpoint on @code{__raise_exception}
-(@pxref{Breakpoints}).
-
-With a conditional breakpoint (@xref{Conditions}) that depends on the
-value of @var{id}, you can stop your program when a specific exception
-is raised. You can use multiple conditional breakpoints to stop the
-program when any of a number of exceptions are raised.
-
-@node Delete Breaks, Disabling, Exception Handling, Breakpoints
-@subsection Deleting Breakpoints
-
-@cindex clearing breakpoints, watchpoints
-@cindex deleting breakpoints, watchpoints
-It is often necessary to eliminate a breakpoint or watchpoint once it
-has done its job and you no longer want the program to stop there. This
-is called @dfn{deleting} the breakpoint. A breakpoint that has been
-deleted no longer exists; it is forgotten.
-
-With the @code{clear} command you can delete breakpoints according to
-where they are in the program. With the @code{delete} command you can
-delete individual breakpoints or watchpoints by specifying their
-breakpoint numbers.
-
-It is not necessary to delete a breakpoint to proceed past it. _GDBN__
-automatically ignores breakpoints on the first instruction to be executed
-when you continue execution without changing the execution address.
-
-@table @code
-@item clear
-@kindex clear
-Delete any breakpoints at the next instruction to be executed in the
-selected stack frame (@pxref{Selection}). When the innermost frame
-is selected, this is a good way to delete a breakpoint that the program
-just stopped at.
-
-@item clear @var{function}
-@itemx clear @var{filename}:@var{function}
-Delete any breakpoints set at entry to the function @var{function}.
-
-@item clear @var{linenum}
-@itemx clear @var{filename}:@var{linenum}
-Delete any breakpoints set at or within the code of the specified line.
-
-@item delete @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
-@cindex delete breakpoints
-@kindex delete
-@kindex d
-Delete the breakpoints or watchpoints of the numbers specified as
-arguments. If no argument is specified, delete all breakpoints (_GDBN__
-asks confirmation, unless you've @code{set confirm off}). You
-can abbreviate this command as @code{d}.
-@end table
-
-@node Disabling, Conditions, Delete Breaks, Breakpoints
-@subsection Disabling Breakpoints
-
-@cindex disabled breakpoints
-@cindex enabled breakpoints
-Rather than deleting a breakpoint or watchpoint, you might prefer to
-@dfn{disable} it. This makes the breakpoint inoperative as if it had
-been deleted, but remembers the information on the breakpoint so that
-you can @dfn{enable} it again later.
-
-You disable and enable breakpoints and watchpoints with the
-@code{enable} and @code{disable} commands, optionally specifying one or
-more breakpoint numbers as arguments. Use @code{info break} or
-@code{info watch} to print a list of breakpoints or watchpoints if you
-don't know which numbers to use.
-
-A breakpoint or watchpoint can have any of four different states of
-enablement:
-
-@itemize @bullet
-@item
-Enabled. The breakpoint will stop the program. A breakpoint set
-with the @code{break} command starts out in this state.
-@item
-Disabled. The breakpoint has no effect on the program.
-@item
-Enabled once. The breakpoint will stop the program, but
-when it does so it will become disabled. A breakpoint set
-with the @code{tbreak} command starts out in this state.
-@item
-Enabled for deletion. The breakpoint will stop the program, but
-immediately after it does so it will be deleted permanently.
-@end itemize
-
-You can use the following commands to enable or disable breakpoints and
-watchpoints:
-
-@table @code
-@item disable @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
-@kindex disable breakpoints
-@kindex disable
-@kindex dis
-Disable the specified breakpoints---or all breakpoints, if none are
-listed. A disabled breakpoint has no effect but is not forgotten. All
-options such as ignore-counts, conditions and commands are remembered in
-case the breakpoint is enabled again later. You may abbreviate
-@code{disable} as @code{dis}.
-
-@item enable @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
-@kindex enable breakpoints
-@kindex enable
-Enable the specified breakpoints (or all defined breakpoints). They
-become effective once again in stopping the program.
-
-@item enable @r{[}breakpoints@r{]} once @var{bnums}@dots{}
-Enable the specified breakpoints temporarily. Each will be disabled
-again the next time it stops the program.
-
-@item enable @r{[}breakpoints@r{]} delete @var{bnums}@dots{}
-Enable the specified breakpoints to work once and then die. Each of
-the breakpoints will be deleted the next time it stops the program.
-@end table
-
-Save for a breakpoint set with @code{tbreak} (@pxref{Set Breaks}),
-breakpoints that you set are initially enabled; subsequently, they become
-disabled or enabled only when you use one of the commands above. (The
-command @code{until} can set and delete a breakpoint of its own, but it
-will not change the state of your other breakpoints;
-@pxref{Continuing and Stepping}.)
-
-@node Conditions, Break Commands, Disabling, Breakpoints
-@subsection Break Conditions
-@cindex conditional breakpoints
-@cindex breakpoint conditions
-
-The simplest sort of breakpoint breaks every time the program reaches a
-specified place. You can also specify a @dfn{condition} for a
-breakpoint. A condition is just a Boolean expression in your
-programming language. (@xref{Expressions}). A breakpoint with a condition
-evaluates the expression each time the program reaches it, and the
-program stops only if the condition is @emph{true}.
-
-This is the converse of using assertions for program validation; in that
-situation, you want to stop when the assertion is violated---that is,
-when the condition is false. In C, if you want to test an assertion expressed
-by the condition @var{assert}, you should set the condition
-@samp{! @var{assert}} on the appropriate breakpoint.
-
-Conditions are also accepted for watchpoints; you may not need them,
-since a watchpoint is inspecting the value of an expression anyhow---but
-it might be simpler, say, to just set a watchpoint on a variable name,
-and specify a condition that tests whether the new value is an interesting
-one.
-
-Break conditions ca have side effects, and may even call functions in
-your program. This can be useful, for example, to activate functions
-that log program progress, or to use your own print functions to format
-special data structures. The effects are completely predictable unless
-there is another enabled breakpoint at the same address. (In that
-case, _GDBN__ might see the other breakpoint first and stop the program
-without checking the condition of this one.) Note that breakpoint
-commands are usually more convenient and flexible for the purpose of
-performing side effects when a breakpoint is reached
-(@pxref{Break Commands}).
-
-Break conditions can be specified when a breakpoint is set, by using
-@samp{if} in the arguments to the @code{break} command. @xref{Set Breaks}.
-They can also be changed at any time with the @code{condition} command.
-The @code{watch} command doesn't recognize the @code{if} keyword;
-@code{condition} is the only way to impose a further condition on a
-watchpoint.
-
-@table @code
-@item condition @var{bnum} @var{expression}
-@kindex condition
-Specify @var{expression} as the break condition for breakpoint or
-watchpoint number @var{bnum}. From now on, this breakpoint will stop
-the program only if the value of @var{expression} is true (nonzero, in
-C). When you use @code{condition}, _GDBN__ checks @var{expression}
-immediately for syntactic correctness, and to determine whether symbols
-in it have referents in the context of your breakpoint. _GDBN__ does
-not actually evaluate @var{expression} at the time the @code{condition}
-command is given, however. @xref{Expressions}.
-
-@item condition @var{bnum}
-Remove the condition from breakpoint number @var{bnum}. It becomes
-an ordinary unconditional breakpoint.
-@end table
-
-@cindex ignore count (of breakpoint)
-A special case of a breakpoint condition is to stop only when the
-breakpoint has been reached a certain number of times. This is so
-useful that there is a special way to do it, using the @dfn{ignore
-count} of the breakpoint. Every breakpoint has an ignore count, which
-is an integer. Most of the time, the ignore count is zero, and
-therefore has no effect. But if the program reaches a breakpoint whose
-ignore count is positive, then instead of stopping, it just decrements
-the ignore count by one and continues. As a result, if the ignore count
-value is @var{n}, the breakpoint will not stop the next @var{n} times it
-is reached.
-
-@table @code
-@item ignore @var{bnum} @var{count}
-@kindex ignore
-Set the ignore count of breakpoint number @var{bnum} to @var{count}.
-The next @var{count} times the breakpoint is reached, your program's
-execution will not stop; other than to decrement the ignore count, _GDBN__
-takes no action.
-
-To make the breakpoint stop the next time it is reached, specify
-a count of zero.
-
-@item continue @var{count}
-@itemx c @var{count}
-@itemx fg @var{count}
-@kindex continue @var{count}
-Continue execution of the program, setting the ignore count of the
-breakpoint that the program stopped at to @var{count} minus one.
-Thus, the program will not stop at this breakpoint until the
-@var{count}'th time it is reached.
-
-An argument to this command is meaningful only when the program stopped
-due to a breakpoint. At other times, the argument to @code{continue} is
-ignored.
-
-The synonym @code{fg} is provided purely for convenience, and has
-exactly the same behavior as other forms of the command.
-@end table
-
-If a breakpoint has a positive ignore count and a condition, the condition
-is not checked. Once the ignore count reaches zero, the condition will
-be checked.
-
-You could achieve the effect of the ignore count with a
-condition such as _0__@w{@samp{$foo-- <= 0}}_1__ using a debugger convenience
-variable that is decremented each time. @xref{Convenience Vars}.
-
-@node Break Commands, Breakpoint Menus, Conditions, Breakpoints
-@subsection Breakpoint Command Lists
-
-@cindex breakpoint commands
-You can give any breakpoint (or watchpoint) a series of commands to
-execute when the program stops due to that breakpoint. For example, you
-might want to print the values of certain expressions, or enable other
-breakpoints.
-
-@table @code
-@item commands @r{[}@var{bnum}@r{]}
-@itemx @dots{} @var{command-list} @dots{}
-@itemx end
-@kindex commands
-@kindex end
-Specify a list of commands for breakpoint number @var{bnum}. The commands
-themselves appear on the following lines. Type a line containing just
-@code{end} to terminate the commands.
-
-To remove all commands from a breakpoint, type @code{commands} followed
-immediately by @code{end}; that is, give no commands.
-
-With no @var{bnum} argument, @code{commands} refers to the last
-breakpoint or watchpoint set (not to the breakpoint most recently
-encountered).
-@end table
-
-Pressing @key{RET} as a means of repeating the last _GDBN__ command is
-disabled within a @var{command-list}.
-
-You can use breakpoint commands to start the program up again. Simply
-use the @code{continue} command, or @code{step}, or any other command
-that resumes execution. Subsequent commands in the command list are
-ignored.
-
-@kindex silent
-If the first command specified is @code{silent}, the usual message about
-stopping at a breakpoint is not printed. This may be desirable for
-breakpoints that are to print a specific message and then continue.
-If the remaining commands too print nothing, you will see no sign that
-the breakpoint was reached at all. @code{silent} is meaningful only
-at the beginning of a breakpoint command list.
-
-The commands @code{echo} and @code{output} that allow you to print precisely
-controlled output are often useful in silent breakpoints. @xref{Output}.
-
-For example, here is how you could use breakpoint commands to print the
-value of @code{x} at entry to @code{foo} whenever @code{x} is positive.
-
-_0__@example
-break foo if x>0
-commands
-silent
-echo x is\040
-output x
-echo \n
-cont
-end
-_1__@end example
-
-One application for breakpoint commands is to compensate for one bug so
-you can test for another. Put a breakpoint just after the erroneous line
-of code, give it a condition to detect the case in which something
-erroneous has been done, and give it commands to assign correct values
-to any variables that need them. End with the @code{continue} command
-so that the program does not stop, and start with the @code{silent}
-command so that no output is produced. Here is an example:
-
-@example
-break 403
-commands
-silent
-set x = y + 4
-cont
-end
-@end example
-
-@cindex lost output
-One deficiency in the operation of automatically continuing breakpoints
-under Unix appears when your program uses raw mode for the terminal.
-_GDBN__ switches back to its own terminal modes (not raw) before executing
-commands, and then must switch back to raw mode when your program is
-continued. This causes any pending terminal input to be lost.
-@c FIXME: revisit below when GNU sys avail.
-@c In the GNU system, this will be fixed by changing the behavior of
-@c terminal modes.
-
-Under Unix, you can get around this problem by writing actions into
-the breakpoint condition rather than in commands. For example
-
-@example
-condition 5 (x = y + 4), 0
-@end example
-
-@noindent
-specifies a condition expression (@xref{Expressions}) that will change
-@code{x} as needed, then always have the value zero so the program will
-not stop. No input is lost here, because _GDBN__ evaluates break
-conditions without changing the terminal modes. When you want to have
-nontrivial conditions for performing the side effects, the operators
-@samp{&&}, @samp{||} and @samp{?@dots{}:} may be useful.
-
-@node Breakpoint Menus, Error in Breakpoints, Break Commands, Breakpoints
-@subsection Breakpoint Menus
-@cindex overloading
-@cindex symbol overloading
-
-Some programming languages (notably C++) permit a single function name
-to be defined several times, for application in different contexts.
-This is called @dfn{overloading}. When a function name is overloaded,
-@samp{break @var{function}} is not enough to tell _GDBN__ where you
-want a breakpoint. _GDBN__ offers you a menu of numbered choices for
-different possible breakpoints, and waits for your selection with the
-prompt @samp{>}. The first two options are always @samp{[0] cancel}
-and @samp{[1] all}. Typing @kbd{1} sets a breakpoint at each
-definition of @var{function}, and typing @kbd{0} aborts the
-@code{break} command without setting any new breakpoints.
-
-For example, the following session excerpt shows an attempt to set a
-breakpoint at the overloaded symbol @code{String::after}.
-We choose three particular definitions of that function name:
-
-@example
-(_GDBP__) b String::after
-[0] cancel
-[1] all
-[2] file:String.cc; line number:867
-[3] file:String.cc; line number:860
-[4] file:String.cc; line number:875
-[5] file:String.cc; line number:853
-[6] file:String.cc; line number:846
-[7] file:String.cc; line number:735
-> 2 4 6
-Breakpoint 1 at 0xb26c: file String.cc, line 867.
-Breakpoint 2 at 0xb344: file String.cc, line 875.
-Breakpoint 3 at 0xafcc: file String.cc, line 846.
-Multiple breakpoints were set.
-Use the "delete" command to delete unwanted breakpoints.
-(_GDBP__)
-@end example
-
-
-@node Error in Breakpoints, , Breakpoint Menus, Breakpoints
-@subsection ``Cannot Insert Breakpoints''
-
-@c FIXME: "cannot insert breakpoints" error, v unclear.
-@c Q in pending mail to Gilmore. ---pesch@cygnus.com, 26mar91
-@c some light may be shed by looking at instances of
-@c ONE_PROCESS_WRITETEXT. But error seems possible otherwise
-@c too. pesch, 20sep91
-Under some operating systems, breakpoints cannot be used in a program if
-any other process is running that program. In this situation,
-attempting to run or continue a program with a breakpoint causes _GDBN__
-to stop the other process.
-
-When this happens, you have three ways to proceed:
-
-@enumerate
-@item
-Remove or disable the breakpoints, then continue.
-
-@item
-Suspend _GDBN__, and copy the file containing the program to a new name.
-Resume _GDBN__ and use the @code{exec-file} command to specify that _GDBN__
-should run the program under that name. Then start the program again.
-
-@c FIXME: RMS commented here "Show example". Maybe when someone
-@c explains the first FIXME: in this section...
-
-@item
-Relink the program so that the text segment is nonsharable, using the
-linker option @samp{-N}. The operating system limitation may not apply
-to nonsharable executables.
-@end enumerate
-
-@node Continuing and Stepping, Signals, Breakpoints, Stopping
-@section Continuing and Stepping
-
-@cindex stepping
-@cindex continuing
-@cindex resuming execution
-@dfn{Continuing} means resuming program execution until your program
-completes normally. In contrast, @dfn{stepping} means resuming program
-execution for a very limited time: one line of source code, or one
-machine instruction. Either when continuing or when stepping, the
-program may stop even sooner, due to a breakpoint or to a signal. (If
-due to a signal, you may want to use @code{handle}, or use @samp{signal
-0} to resume execution; @pxref{Signals}.)
-
-@table @code
-@item continue @r{[}@var{ignore-count}@r{]}
-@kindex continue
-Resume program execution, at the address where the program last stopped;
-any breakpoints set at that address are bypassed. The optional argument
-@var{ignore-count} allows you to specify a further number of times to
-ignore a breakpoint at this location; its effect is like that of
-@code{ignore} (@pxref{Conditions}).
-
-To resume execution at a different place, you can use @code{return}
-(@pxref{Returning}) to go back to the calling function; or @code{jump}
-(@pxref{Jumping}) to go to an arbitrary location in your program.
-
-@end table
-
-A typical technique for using stepping is to set a breakpoint
-(@pxref{Breakpoints}) at the beginning of the function or the section of
-the program in which a problem is believed to lie, run the program until
-it stops at that breakpoint, and then step through the suspect area,
-examining the variables that are interesting, until you see the problem
-happen.
-
-@table @code
-@item step
-@kindex step
-@kindex s
-Continue running the program until control reaches a different source
-line, then stop it and return control to _GDBN__. This command is
-abbreviated @code{s}.
-
-@quotation
-@emph{Warning:} If you use the @code{step} command while control is
-within a function that was compiled without debugging information,
-execution will proceed until control reaches another function.
-@end quotation
-
-@item step @var{count}
-Continue running as in @code{step}, but do so @var{count} times. If a
-breakpoint is reached or a signal not related to stepping occurs before
-@var{count} steps, stepping stops right away.
-
-@item next @r{[}@var{count}@r{]}
-@kindex next
-@kindex n
-Continue to the next source line in the current (innermost) stack frame.
-Similar to @code{step}, but any function calls appearing within the line
-of code are executed without stopping. Execution stops when control
-reaches a different line of code at the stack level which was executing
-when the @code{next} command was given. This command is abbreviated
-@code{n}.
-
-An argument @var{count} is a repeat count, as for @code{step}.
-
-@code{next} within a function that lacks debugging information acts like
-@code{step}, but any function calls appearing within the code of the
-function are executed without stopping.
-
-@item finish
-@kindex finish
-Continue running until just after function in the selected stack frame
-returns. Print the returned value (if any).
-
-Contrast this with the @code{return} command (@pxref{Returning}).
-
-@item until
-@kindex until
-@item u
-@kindex u
-Continue running until a source line past the current line, in the
-current stack frame, is reached. This command is used to avoid single
-stepping through a loop more than once. It is like the @code{next}
-command, except that when @code{until} encounters a jump, it
-automatically continues execution until the program counter is greater
-than the address of the jump.
-
-This means that when you reach the end of a loop after single stepping
-though it, @code{until} will cause the program to continue execution
-until the loop is exited. In contrast, a @code{next} command at the end
-of a loop will simply step back to the beginning of the loop, which
-would force you to step through the next iteration.
-
-@code{until} always stops the program if it attempts to exit the current
-stack frame.
-
-@code{until} may produce somewhat counterintuitive results if the order
-of machine code does not match the order of the source lines. For
-example, in the following excerpt from a debugging session, the @code{f}
-(@code{frame}) command shows that execution is stopped at line
-@code{206}; yet when we use @code{until}, we get to line @code{195}:
-
-@example
-(_GDBP__) f
-#0 main (argc=4, argv=0xf7fffae8) at m4.c:206
-206 expand_input();
-(_GDBP__) until
-195 for ( ; argc > 0; NEXTARG) @{
-@end example
-
-This happened because, for execution efficiency, the compiler had
-generated code for the loop closure test at the end, rather than the
-start, of the loop---even though the test in a C @code{for}-loop is
-written before the body of the loop. The @code{until} command appeared
-to step back to the beginning of the loop when it advanced to this
-expression; however, it has not really gone to an earlier
-statement---not in terms of the actual machine code.
-
-@code{until} with no argument works by means of single
-instruction stepping, and hence is slower than @code{until} with an
-argument.
-
-@item until @var{location}
-@item u @var{location}
-Continue running the program until either the specified location is
-reached, or the current stack frame returns. @var{location}
-is any of the forms of argument acceptable to @code{break}
-(@pxref{Set Breaks}). This form of the command uses breakpoints, and
-hence is quicker than @code{until} without an argument.
-
-@item stepi
-@itemx si
-@kindex stepi
-@kindex si
-Execute one machine instruction, then stop and return to the debugger.
-
-It is often useful to do @samp{display/i $pc} when stepping by machine
-instructions. This will cause the next instruction to be executed to
-be displayed automatically at each stop. @xref{Auto Display}.
-
-An argument is a repeat count, as in @code{step}.
-
-@item nexti
-@itemx ni
-@kindex nexti
-@kindex ni
-Execute one machine instruction, but if it is a function call,
-proceed until the function returns.
-
-An argument is a repeat count, as in @code{next}.
-@end table
-
-
-@node Signals, , Continuing and Stepping, Stopping
-@section Signals
-@cindex signals
-
-A signal is an asynchronous event that can happen in a program. The
-operating system defines the possible kinds of signals, and gives each
-kind a name and a number. For example, in Unix @code{SIGINT} is the
-signal a program gets when you type an interrupt (often @kbd{C-c});
-@code{SIGSEGV} is the signal a program gets from referencing a place in
-memory far away from all the areas in use; @code{SIGALRM} occurs when
-the alarm clock timer goes off (which happens only if the program has
-requested an alarm).
-
-@cindex fatal signals
-Some signals, including @code{SIGALRM}, are a normal part of the
-functioning of the program. Others, such as @code{SIGSEGV}, indicate
-errors; these signals are @dfn{fatal} (kill the program immediately) if the
-program has not specified in advance some other way to handle the signal.
-@code{SIGINT} does not indicate an error in the program, but it is normally
-fatal so it can carry out the purpose of the interrupt: to kill the program.
-
-_GDBN__ has the ability to detect any occurrence of a signal in the program
-running under _GDBN__'s control. You can tell _GDBN__ in advance what to do for
-each kind of signal.
-
-@cindex handling signals
-Normally, _GDBN__ is set up to ignore non-erroneous signals like @code{SIGALRM}
-(so as not to interfere with their role in the functioning of the program)
-but to stop the program immediately whenever an error signal happens.
-You can change these settings with the @code{handle} command.
-
-@table @code
-@item info signals
-@kindex info signals
-Print a table of all the kinds of signals and how _GDBN__ has been told to
-handle each one. You can use this to see the signal numbers of all
-the defined types of signals.
-
-@item handle @var{signal} @var{keywords}@dots{}
-@kindex handle
-Change the way _GDBN__ handles signal @var{signal}. @var{signal} can be the
-number of a signal or its name (with or without the @samp{SIG} at the
-beginning). The @var{keywords} say what change to make.
-@end table
-
-@c @group
-The keywords allowed by the @code{handle} command can be abbreviated.
-Their full names are:
-
-@table @code
-@item nostop
-_GDBN__ should not stop the program when this signal happens. It may
-still print a message telling you that the signal has come in.
-
-@item stop
-_GDBN__ should stop the program when this signal happens. This implies
-the @code{print} keyword as well.
-
-@item print
-_GDBN__ should print a message when this signal happens.
-
-@item noprint
-_GDBN__ should not mention the occurrence of the signal at all. This
-implies the @code{nostop} keyword as well.
-
-@item pass
-_GDBN__ should allow the program to see this signal; the program will be
-able to handle the signal, or may be terminated if the signal is fatal
-and not handled.
-
-@item nopass
-_GDBN__ should not allow the program to see this signal.
-@end table
-@c @end group
-
-When a signal has been set to stop the program, the program cannot see the
-signal until you continue. It will see the signal then, if @code{pass} is
-in effect for the signal in question @i{at that time}. In other words,
-after _GDBN__ reports a signal, you can use the @code{handle} command with
-@code{pass} or @code{nopass} to control whether that signal will be seen by
-the program when you later continue it.
-
-You can also use the @code{signal} command to prevent the program from
-seeing a signal, or cause it to see a signal it normally would not see,
-or to give it any signal at any time. For example, if the program stopped
-due to some sort of memory reference error, you might store correct
-values into the erroneous variables and continue, hoping to see more
-execution; but the program would probably terminate immediately as
-a result of the fatal signal once it sees the signal. To prevent this,
-you can continue with @samp{signal 0}. @xref{Signaling}.
-
-@node Stack, Source, Stopping, Top
-@chapter Examining the Stack
-
-When your program has stopped, the first thing you need to know is where it
-stopped and how it got there.
-
-@cindex call stack
-Each time your program performs a function call, the information about
-where in the program the call was made from is saved in a block of data
-called a @dfn{stack frame}. The frame also contains the arguments of the
-call and the local variables of the function that was called. All the
-stack frames are allocated in a region of memory called the @dfn{call
-stack}.
-
-When your program stops, the _GDBN__ commands for examining the stack allow you
-to see all of this information.
-
-@cindex selected frame
-One of the stack frames is @dfn{selected} by _GDBN__ and many _GDBN__ commands
-refer implicitly to the selected frame. In particular, whenever you ask
-_GDBN__ for the value of a variable in the program, the value is found in the
-selected frame. There are special _GDBN__ commands to select whichever frame
-you are interested in.
-
-When the program stops, _GDBN__ automatically selects the currently executing
-frame and describes it briefly as the @code{frame} command does
-(@pxref{Frame Info}).
-
-@menu
-* Frames:: Stack Frames
-* Backtrace:: Backtraces
-* Selection:: Selecting a Frame
-* Frame Info:: Information on a Frame
-@end menu
-
-@node Frames, Backtrace, Stack, Stack
-@section Stack Frames
-
-@cindex frame
-@cindex stack frame
-The call stack is divided up into contiguous pieces called @dfn{stack
-frames}, or @dfn{frames} for short; each frame is the data associated
-with one call to one function. The frame contains the arguments given
-to the function, the function's local variables, and the address at
-which the function is executing.
-
-@cindex initial frame
-@cindex outermost frame
-@cindex innermost frame
-When your program is started, the stack has only one frame, that of the
-function @code{main}. This is called the @dfn{initial} frame or the
-@dfn{outermost} frame. Each time a function is called, a new frame is
-made. Each time a function returns, the frame for that function invocation
-is eliminated. If a function is recursive, there can be many frames for
-the same function. The frame for the function in which execution is
-actually occurring is called the @dfn{innermost} frame. This is the most
-recently created of all the stack frames that still exist.
-
-@cindex frame pointer
-Inside your program, stack frames are identified by their addresses. A
-stack frame consists of many bytes, each of which has its own address; each
-kind of computer has a convention for choosing one of those bytes whose
-address serves as the address of the frame. Usually this address is kept
-in a register called the @dfn{frame pointer register} while execution is
-going on in that frame.
-
-@cindex frame number
-_GDBN__ assigns numbers to all existing stack frames, starting with
-zero for the innermost frame, one for the frame that called it,
-and so on upward. These numbers do not really exist in your program;
-they are assigned by _GDBN__ to give you a way of designating stack
-frames in _GDBN__ commands.
-
-@cindex frameless execution
-Some compilers allow functions to be compiled so that they operate
-without stack frames. (For example, the @code{_GCC__} option
-@samp{-fomit-frame-pointer} will generate functions without a frame.)
-This is occasionally done with heavily used library functions to save
-the frame setup time. _GDBN__ has limited facilities for dealing with
-these function invocations. If the innermost function invocation has no
-stack frame, _GDBN__ will nevertheless regard it as though it had a
-separate frame, which is numbered zero as usual, allowing correct
-tracing of the function call chain. However, _GDBN__ has no provision
-for frameless functions elsewhere in the stack.
-
-@node Backtrace, Selection, Frames, Stack
-@section Backtraces
-
-A backtrace is a summary of how the program got where it is. It shows one
-line per frame, for many frames, starting with the currently executing
-frame (frame zero), followed by its caller (frame one), and on up the
-stack.
-
-@table @code
-@item backtrace
-@itemx bt
-@kindex backtrace
-@kindex bt
-Print a backtrace of the entire stack: one line per frame for all
-frames in the stack.
-
-You can stop the backtrace at any time by typing the system interrupt
-character, normally @kbd{C-c}.
-
-@item backtrace @var{n}
-@itemx bt @var{n}
-Similar, but print only the innermost @var{n} frames.
-
-@item backtrace -@var{n}
-@itemx bt -@var{n}
-Similar, but print only the outermost @var{n} frames.
-@end table
-
-@kindex where
-@kindex info stack
-@kindex info s
-The names @code{where} and @code{info stack} (abbreviated @code{info s})
-are additional aliases for @code{backtrace}.
-
-Each line in the backtrace shows the frame number and the function name.
-The program counter value is also shown---unless you use @code{set
-print address off}. The backtrace also shows the source file name and
-line number, as well as the arguments to the function. The program
-counter value is omitted if it is at the beginning of the code for that
-line number.
-
-Here is an example of a backtrace. It was made with the command
-@samp{bt 3}, so it shows the innermost three frames.
-
-@smallexample
-@group
-#0 m4_traceon (obs=0x24eb0, argc=1, argv=0x2b8c8) at builtin.c:993
-#1 0x6e38 in expand_macro (sym=0x2b600) at macro.c:242
-#2 0x6840 in expand_token (obs=0x0, t=177664, td=0xf7fffb08)
- at macro.c:71
-(More stack frames follow...)
-@end group
-@end smallexample
-
-@noindent
-The display for frame zero doesn't begin with a program counter
-value, indicating that the program has stopped at the beginning of the
-code for line @code{993} of @code{builtin.c}.
-
-@node Selection, Frame Info, Backtrace, Stack
-@section Selecting a Frame
-
-Most commands for examining the stack and other data in the program work on
-whichever stack frame is selected at the moment. Here are the commands for
-selecting a stack frame; all of them finish by printing a brief description
-of the stack frame just selected.
-
-@table @code
-@item frame @var{n}
-@itemx f @var{n}
-@kindex frame
-@kindex f
-Select frame number @var{n}. Recall that frame zero is the innermost
-(currently executing) frame, frame one is the frame that called the
-innermost one, and so on. The highest-numbered frame is @code{main}'s
-frame.
-
-@item frame @var{addr}
-@itemx f @var{addr}
-Select the frame at address @var{addr}. This is useful mainly if the
-chaining of stack frames has been damaged by a bug, making it
-impossible for _GDBN__ to assign numbers properly to all frames. In
-addition, this can be useful when the program has multiple stacks and
-switches between them.
-
-_if__(_SPARC__)
-On the SPARC architecture, @code{frame} needs two addresses to
-select an arbitrary frame: a frame pointer and a stack pointer.
-@c note to future updaters: this is conditioned on a flag
-@c FRAME_SPECIFICATION_DYADIC in the tm-*.h files, currently only used
-@c by SPARC, hence the specific attribution. Generalize or list all
-@c possibilities if more supported machines start doing this.
-_fi__(_SPARC__)
-
-@item up @var{n}
-@kindex up
-Move @var{n} frames up the stack. For positive numbers @var{n}, this
-advances toward the outermost frame, to higher frame numbers, to frames
-that have existed longer. @var{n} defaults to one.
-
-@item down @var{n}
-@kindex down
-@kindex do
-Move @var{n} frames down the stack. For positive numbers @var{n}, this
-advances toward the innermost frame, to lower frame numbers, to frames
-that were created more recently. @var{n} defaults to one. You may
-abbreviate @code{down} as @code{do}.
-@end table
-
-All of these commands end by printing two lines of output describing the
-frame. The first line shows the frame number, the function name, the
-arguments, and the source file and line number of execution in that
-frame. The second line shows the text of that source line. For
-example:
-
-@smallexample
-(_GDBP__) up
-#1 0x22f0 in main (argc=1, argv=0xf7fffbf4, env=0xf7fffbfc) at env.c:10
-10 read_input_file (argv[i]);
-@end smallexample
-
-After such a printout, the @code{list} command with no arguments will print
-ten lines centered on the point of execution in the frame. @xref{List}.
-
-@table @code
-@item up-silently @var{n}
-@itemx down-silently @var{n}
-@kindex down-silently
-@kindex up-silently
-These two commands are variants of @code{up} and @code{down},
-respectively; they differ in that they do their work silently, without
-causing display of the new frame. They are intended primarily for use
-in _GDBN__ command scripts, where the output might be unnecessary and
-distracting.
-
-@end table
-
-@node Frame Info, , Selection, Stack
-@section Information About a Frame
-
-There are several other commands to print information about the selected
-stack frame.
-
-@table @code
-@item frame
-@itemx f
-When used without any argument, this command does not change which frame
-is selected, but prints a brief description of the currently
-selected stack frame. It can be abbreviated @code{f}. With an
-argument, this command is used to select a stack frame (@pxref{Selection}).
-
-@item info frame
-@kindex info frame
-@itemx info f
-@kindex info f
-This command prints a verbose description of the selected stack frame,
-including the address of the frame, the addresses of the next frame down
-(called by this frame) and the next frame up (caller of this frame), the
-language that the source code corresponding to this frame was written in,
-the address of the frame's arguments, the program counter saved in it
-(the address of execution in the caller frame), and which registers
-were saved in the frame. The verbose description is useful when
-something has gone wrong that has made the stack format fail to fit
-the usual conventions.
-
-@item info frame @var{addr}
-@itemx info f @var{addr}
-Print a verbose description of the frame at address @var{addr},
-without selecting that frame. The selected frame remains unchanged by
-this command.
-
-@item info args
-@kindex info args
-Print the arguments of the selected frame, each on a separate line.
-
-@item info locals
-@kindex info locals
-Print the local variables of the selected frame, each on a separate
-line. These are all variables declared static or automatic within all
-program blocks that execution in this frame is currently inside of.
-
-@item info catch
-@kindex info catch
-@cindex catch exceptions
-@cindex exception handlers
-Print a list of all the exception handlers that are active in the
-current stack frame at the current point of execution. To see other
-exception handlers, visit the associated frame (using the @code{up},
-@code{down}, or @code{frame} commands); then type @code{info catch}.
-@xref{Exception Handling}.
-@end table
-
-@node Source, Data, Stack, Top
-@chapter Examining Source Files
-
-_GDBN__ can print parts of your program's source, since the debugging
-information recorded in your program tells _GDBN__ what source files
-were used to built it. When your program stops, _GDBN__ spontaneously
-prints the line where it stopped. Likewise, when you select a stack
-frame (@pxref{Selection}), _GDBN__ prints the line where execution in
-that frame has stopped. You can print other portions of source files by
-explicit command.
-
-If you use _GDBN__ through its GNU Emacs interface, you may prefer to
-use Emacs facilities to view source; @pxref{Emacs}.
-
-@menu
-* List:: Printing Source Lines
-* Search:: Searching Source Files
-* Source Path:: Specifying Source Directories
-* Machine Code:: Source and Machine Code
-@end menu
-
-@node List, Search, Source, Source
-@section Printing Source Lines
-
-@kindex list
-@kindex l
-To print lines from a source file, use the @code{list} command
-(abbreviated @code{l}). There are several ways to specify what part
-of the file you want to print.
-
-Here are the forms of the @code{list} command most commonly used:
-
-@table @code
-@item list @var{linenum}
-Print lines centered around line number @var{linenum} in the
-current source file.
-
-@item list @var{function}
-Print lines centered around the beginning of function
-@var{function}.
-
-@item list
-Print more lines. If the last lines printed were printed with a
-@code{list} command, this prints lines following the last lines
-printed; however, if the last line printed was a solitary line printed
-as part of displaying a stack frame (@pxref{Stack}), this prints
-lines centered around that line.
-
-@item list -
-Print lines just before the lines last printed.
-@end table
-
-By default, _GDBN__ prints ten source lines with any of these forms of
-the @code{list} command. You can change this using @code{set listsize}:
-
-@table @code
-@item set listsize @var{count}
-@kindex set listsize
-Make the @code{list} command display @var{count} source lines (unless
-the @code{list} argument explicitly specifies some other number).
-
-@item show listsize
-@kindex show listsize
-Display the number of lines that @code{list} will currently display by
-default.
-@end table
-
-Repeating a @code{list} command with @key{RET} discards the argument,
-so it is equivalent to typing just @code{list}. This is more useful
-than listing the same lines again. An exception is made for an
-argument of @samp{-}; that argument is preserved in repetition so that
-each repetition moves up in the source file.
-
-@cindex linespec
-In general, the @code{list} command expects you to supply zero, one or two
-@dfn{linespecs}. Linespecs specify source lines; there are several ways
-of writing them but the effect is always to specify some source line.
-Here is a complete description of the possible arguments for @code{list}:
-
-@table @code
-@item list @var{linespec}
-Print lines centered around the line specified by @var{linespec}.
-
-@item list @var{first},@var{last}
-Print lines from @var{first} to @var{last}. Both arguments are
-linespecs.
-
-@item list ,@var{last}
-Print lines ending with @var{last}.
-
-@item list @var{first},
-Print lines starting with @var{first}.
-
-@item list +
-Print lines just after the lines last printed.
-
-@item list -
-Print lines just before the lines last printed.
-
-@item list
-As described in the preceding table.
-@end table
-
-Here are the ways of specifying a single source line---all the
-kinds of linespec.
-
-@table @code
-@item @var{number}
-Specifies line @var{number} of the current source file.
-When a @code{list} command has two linespecs, this refers to
-the same source file as the first linespec.
-
-@item +@var{offset}
-Specifies the line @var{offset} lines after the last line printed.
-When used as the second linespec in a @code{list} command that has
-two, this specifies the line @var{offset} lines down from the
-first linespec.
-
-@item -@var{offset}
-Specifies the line @var{offset} lines before the last line printed.
-
-@item @var{filename}:@var{number}
-Specifies line @var{number} in the source file @var{filename}.
-
-@item @var{function}
-@c FIXME: "of the open-brace" is C-centric. When we add other langs...
-Specifies the line of the open-brace that begins the body of the
-function @var{function}.
-
-@item @var{filename}:@var{function}
-Specifies the line of the open-brace that begins the body of the
-function @var{function} in the file @var{filename}. You only need the
-file name with a function name to avoid ambiguity when there are
-identically named functions in different source files.
-
-@item *@var{address}
-Specifies the line containing the program address @var{address}.
-@var{address} may be any expression.
-@end table
-
-@node Search, Source Path, List, Source
-@section Searching Source Files
-@cindex searching
-@kindex reverse-search
-
-There are two commands for searching through the current source file for a
-regular expression.
-
-@table @code
-@item forward-search @var{regexp}
-@itemx search @var{regexp}
-@kindex search
-@kindex forward-search
-The command @samp{forward-search @var{regexp}} checks each line, starting
-with the one following the last line listed, for a match for @var{regexp}.
-It lists the line that is found. You can abbreviate the command name
-as @code{fo}. The synonym @samp{search @var{regexp}} is also supported.
-
-@item reverse-search @var{regexp}
-The command @samp{reverse-search @var{regexp}} checks each line, starting
-with the one before the last line listed and going backward, for a match
-for @var{regexp}. It lists the line that is found. You can abbreviate
-this command as @code{rev}.
-@end table
-
-@node Source Path, Machine Code, Search, Source
-@section Specifying Source Directories
-
-@cindex source path
-@cindex directories for source files
-Executable programs sometimes do not record the directories of the source
-files from which they were compiled, just the names. Even when they do,
-the directories could be moved between the compilation and your debugging
-session. _GDBN__ has a list of directories to search for source files;
-this is called the @dfn{source path}. Each time _GDBN__ wants a source file,
-it tries all the directories in the list, in the order they are present
-in the list, until it finds a file with the desired name. Note that
-the executable search path is @emph{not} used for this purpose. Neither is
-the current working directory, unless it happens to be in the source
-path.
-
-If _GDBN__ can't find a source file in the source path, and the object
-program records a directory, _GDBN__ tries that directory too. If the
-source path is empty, and there is no record of the compilation
-directory, _GDBN__ will, as a last resort, look in the current
-directory.
-
-Whenever you reset or rearrange the source path, _GDBN__ will clear out
-any information it has cached about where source files are found, where
-each line is in the file, etc.
-
-@kindex directory
-When you start _GDBN__, its source path is empty.
-To add other directories, use the @code{directory} command.
-
-@table @code
-@item directory @var{dirname} @dots{}
-Add directory @var{dirname} to the front of the source path. Several
-directory names may be given to this command, separated by @samp{:} or
-whitespace. You may specify a directory that is already in the source
-path; this moves it forward, so it will be searched sooner.
-
-You can use the string @samp{$cdir} to refer to the compilation
-directory (if one is recorded), and @samp{$cwd} to refer to the current
-working directory. @samp{$cwd} is not the same as @samp{.}---the former
-tracks the current working directory as it changes during your _GDBN__
-session, while the latter is immediately expanded to the current
-directory at the time you add an entry to the source path.
-
-@item directory
-Reset the source path to empty again. This requires confirmation.
-
-@c RET-repeat for @code{directory} is explicitly disabled, but since
-@c repeating it would be a no-op we don't say that. (thanks to RMS)
-
-@item show directories
-@kindex show directories
-Print the source path: show which directories it contains.
-@end table
-
-If your source path is cluttered with directories that are no longer of
-interest, _GDBN__ may sometimes cause confusion by finding the wrong
-versions of source. You can correct the situation as follows:
-
-@enumerate
-@item
-Use @code{directory} with no argument to reset the source path to empty.
-
-@item
-Use @code{directory} with suitable arguments to reinstall the
-directories you want in the source path. You can add all the
-directories in one command.
-@end enumerate
-
-@node Machine Code, , Source Path, Source
-@section Source and Machine Code
-You can use the command @code{info line} to map source lines to program
-addresses (and viceversa), and the command @code{disassemble} to display
-a range of addresses as machine instructions.
-
-@table @code
-@item info line @var{linespec}
-@kindex info line
-Print the starting and ending addresses of the compiled code for
-source line @var{linespec}. You can specify source lines in any of the
-ways understood by the @code{list} command (@pxref{List}).
-@end table
-
-For example, we can use @code{info line} to inquire on where the object
-code for the first line of function @code{m4_changequote} lies:
-@smallexample
-(_GDBP__) info line m4_changecom
-Line 895 of "builtin.c" starts at pc 0x634c and ends at 0x6350.
-@end smallexample
-
-@noindent
-We can also inquire (using @code{*@var{addr}} as the form for
-@var{linespec}) what source line covers a particular address:
-@smallexample
-(_GDBP__) info line *0x63ff
-Line 926 of "builtin.c" starts at pc 0x63e4 and ends at 0x6404.
-@end smallexample
-
-@cindex @code{$_} and @code{info line}
-After @code{info line}, the default address for the @code{x}
-command is changed to the starting address of the line, so that
-@samp{x/i} is sufficient to begin examining the machine code
-(@pxref{Memory}). Also, this address is saved as the value of the
-convenience variable @code{$_} (@pxref{Convenience Vars}).
-
-@table @code
-@kindex disassemble
-@item disassemble
-This specialized command is provided to dump a range of memory as
-machine instructions. The default memory range is the function
-surrounding the program counter of the selected frame. A single
-argument to this command is a program counter value; the function
-surrounding this value will be dumped. Two arguments (separated by one
-or more spaces) specify a range of addresses (first inclusive, second
-exclusive) to be dumped.
-@end table
-
-We can use @code{disassemble} to inspect the object code
-range shown in the last @code{info line} example:
-
-@smallexample
-(_GDBP__) disas 0x63e4 0x6404
-Dump of assembler code from 0x63e4 to 0x6404:
-0x63e4 <builtin_init+5340>: ble 0x63f8 <builtin_init+5360>
-0x63e8 <builtin_init+5344>: sethi %hi(0x4c00), %o0
-0x63ec <builtin_init+5348>: ld [%i1+4], %o0
-0x63f0 <builtin_init+5352>: b 0x63fc <builtin_init+5364>
-0x63f4 <builtin_init+5356>: ld [%o0+4], %o0
-0x63f8 <builtin_init+5360>: or %o0, 0x1a4, %o0
-0x63fc <builtin_init+5364>: call 0x9288 <path_search>
-0x6400 <builtin_init+5368>: nop
-End of assembler dump.
-(_GDBP__)
-
-@end smallexample
-
-@node Data, Languages, Source, Top
-@chapter Examining Data
-
-@cindex printing data
-@cindex examining data
-@kindex print
-@kindex inspect
-@c "inspect" isn't quite a synonym if you're using Epoch, which we don't
-@c document because it's nonstandard... Under Epoch it displays in a
-@c different window or something like that.
-The usual way to examine data in your program is with the @code{print}
-command (abbreviated @code{p}), or its synonym @code{inspect}. It
-evaluates and prints the value of an expression of the language your
-program is written in (@pxref{Languages}). You type
-
-@example
-print @var{exp}
-@end example
-
-@noindent
-where @var{exp} is an expression (in the source language), and
-the value of @var{exp} is printed in a format appropriate to its data
-type.
-
-A more low-level way of examining data is with the @code{x} command.
-It examines data in memory at a specified address and prints it in a
-specified format. @xref{Memory}.
-
-If you're interested in information about types, or about how the fields
-of a struct or class are declared, use the @code{ptype @var{exp}}
-command rather than @code{print}. @xref{Symbols}.
-
-@menu
-* Expressions:: Expressions
-* Variables:: Program Variables
-* Arrays:: Artificial Arrays
-* Output formats:: Output formats
-* Memory:: Examining Memory
-* Auto Display:: Automatic Display
-* Print Settings:: Print Settings
-* Value History:: Value History
-* Convenience Vars:: Convenience Variables
-* Registers:: Registers
-* Floating Point Hardware:: Floating Point Hardware
-@end menu
-
-@node Expressions, Variables, Data, Data
-@section Expressions
-
-@cindex expressions
-@code{print} and many other _GDBN__ commands accept an expression and
-compute its value. Any kind of constant, variable or operator defined
-by the programming language you are using is legal in an expression in
-_GDBN__. This includes conditional expressions, function calls, casts
-and string constants. It unfortunately does not include symbols defined
-by preprocessor @code{#define} commands.
-
-Because C is so widespread, most of the expressions shown in examples in
-this manual are in C. @xref{Languages,, Using _GDBN__ with Different
-Languages}, for information on how to use expressions in other
-languages.
-
-In this section, we discuss operators that you can use in _GDBN__
-expressions regardless of your programming language.
-
-Casts are supported in all languages, not just in C, because it is so
-useful to cast a number into a pointer so as to examine a structure
-at that address in memory.
-@c FIXME: casts supported---Mod2 true?
-
-_GDBN__ supports these operators in addition to those of programming
-languages:
-
-@table @code
-@item @@
-@samp{@@} is a binary operator for treating parts of memory as arrays.
-@xref{Arrays}, for more information.
-
-@item ::
-@samp{::} allows you to specify a variable in terms of the file or
-function where it is defined. @xref{Variables}.
-
-@item @{@var{type}@} @var{addr}
-Refers to an object of type @var{type} stored at address @var{addr} in
-memory. @var{addr} may be any expression whose value is an integer or
-pointer (but parentheses are required around binary operators, just as in
-a cast). This construct is allowed regardless of what kind of data is
-normally supposed to reside at @var{addr}.@refill
-@end table
-
-@node Variables, Arrays, Expressions, Data
-@section Program Variables
-
-The most common kind of expression to use is the name of a variable
-in your program.
-
-Variables in expressions are understood in the selected stack frame
-(@pxref{Selection}); they must either be global (or static) or be visible
-according to the scope rules of the programming language from the point of
-execution in that frame. This means that in the function
-
-@example
-foo (a)
- int a;
-@{
- bar (a);
- @{
- int b = test ();
- bar (b);
- @}
-@}
-@end example
-
-@noindent
-the variable @code{a} is usable whenever the program is executing
-within the function @code{foo}, but the variable @code{b} is visible
-only while the program is executing inside the block in which @code{b}
-is declared.
-
-@cindex variable name conflict
-There is an exception: you can refer to a variable or function whose
-scope is a single source file even if the current execution point is not
-in this file. But it is possible to have more than one such variable or
-function with the same name (in different source files). If that happens,
-referring to that name has unpredictable effects. If you wish, you can
-specify a variable in a particular file, using the colon-colon notation:
-
-@cindex colon-colon
-@kindex ::
-@example
-@var{file}::@var{variable}
-@end example
-
-@noindent
-Here @var{file} is the name of the source file whose variable you want.
-
-@cindex C++ scope resolution
-This use of @samp{::} is very rarely in conflict with the very similar
-use of the same notation in C++. _GDBN__ also supports use of the C++
-scope resolution operator in _GDBN__ expressions.
-
-@cindex wrong values
-@cindex variable values, wrong
-@quotation
-@emph{Warning:} Occasionally, a local variable may appear to have the
-wrong value at certain points in a function---just after entry to the
-function, and just before exit. You may see this problem when you're
-stepping by machine instructions. This is because on most machines, it
-takes more than one instruction to set up a stack frame (including local
-variable definitions); if you're stepping by machine instructions,
-variables may appear to have the wrong values until the stack frame is
-completely built. On function exit, it usually also takes more than one
-machine instruction to destroy a stack frame; after you begin stepping
-through that group of instructions, local variable definitions may be
-gone.
-@end quotation
-
-@node Arrays, Output formats, Variables, Data
-@section Artificial Arrays
-
-@cindex artificial array
-@kindex @@
-It is often useful to print out several successive objects of the
-same type in memory; a section of an array, or an array of
-dynamically determined size for which only a pointer exists in the
-program.
-
-This can be done by constructing an @dfn{artificial array} with the
-binary operator @samp{@@}. The left operand of @samp{@@} should be
-the first element of the desired array, as an individual object.
-The right operand should be the desired length of the array. The result is
-an array value whose elements are all of the type of the left argument.
-The first element is actually the left argument; the second element
-comes from bytes of memory immediately following those that hold the
-first element, and so on. Here is an example. If a program says
-
-@example
-int *array = (int *) malloc (len * sizeof (int));
-@end example
-
-@noindent
-you can print the contents of @code{array} with
-
-@example
-p *array@@len
-@end example
-
-The left operand of @samp{@@} must reside in memory. Array values made
-with @samp{@@} in this way behave just like other arrays in terms of
-subscripting, and are coerced to pointers when used in expressions.
-Artificial arrays most often appear in expressions via the value history
-(@pxref{Value History}), after printing one out.)
-
-Sometimes the artificial array mechanism isn't quite enough; in
-moderately complex data structures, the elements of interest may not
-actually be adjacent---for example, if you're interested in the values
-of pointers in an array. One useful work-around in this situation is to
-use a convenience variable (@pxref{Convenience Vars}) as a counter in an
-expression that prints the first interesting value, and then repeat that
-expression via @key{RET}. For instance, suppose you have an array
-@code{dtab} of pointers to structures, and you're interested in the
-values of a field @code{fv} in each structure. Here's an example of
-what you might type:
-@example
-set $i = 0
-p dtab[$i++]->fv
-@key{RET}
-@key{RET}
-@dots{}
-@end example
-
-@node Output formats, Memory, Arrays, Data
-@section Output formats
-
-@cindex formatted output
-@cindex output formats
-By default, _GDBN__ prints a value according to its data type. Sometimes
-this is not what you want. For example, you might want to print a number
-in hex, or a pointer in decimal. Or you might want to view data in memory
-at a certain address as a character string or as an instruction. To do
-these things, specify an @dfn{output format} when you print a value.
-
-The simplest use of output formats is to say how to print a value
-already computed. This is done by starting the arguments of the
-@code{print} command with a slash and a format letter. The format
-letters supported are:
-
-@table @code
-@item x
-Regard the bits of the value as an integer, and print the integer in
-hexadecimal.
-
-@item d
-Print as integer in signed decimal.
-
-@item u
-Print as integer in unsigned decimal.
-
-@item o
-Print as integer in octal.
-
-@item t
-Print as integer in binary. The letter @samp{t} stands for ``two''.
-
-@item a
-Print as an address, both absolute in hex and as an offset from the
-nearest preceding symbol. This format can be used to discover where (in
-what function) an unknown address is located:
-@example
-(_GDBP__) p/a 0x54320
-_0__$3 = 0x54320 <_initialize_vx+396>_1__
-@end example
-
-
-@item c
-Regard as an integer and print it as a character constant.
-
-@item f
-Regard the bits of the value as a floating point number and print
-using typical floating point syntax.
-@end table
-
-For example, to print the program counter in hex (@pxref{Registers}), type
-
-@example
-p/x $pc
-@end example
-
-@noindent
-Note that no space is required before the slash; this is because command
-names in _GDBN__ cannot contain a slash.
-
-To reprint the last value in the value history with a different format,
-you can use the @code{print} command with just a format and no
-expression. For example, @samp{p/x} reprints the last value in hex.
-
-@node Memory, Auto Display, Output formats, Data
-@section Examining Memory
-
-@cindex examining memory
-@table @code
-@kindex x
-@item x/@var{nfu} @var{expr}
-The command @code{x} (for `examine') can be used to examine memory
-without being constrained by your program's data types. You can specify
-the unit size @var{u} of memory to inspect, and a repeat count @var{n} of how
-many of those units to display. @code{x} understands the formats
-@var{f} used by @code{print}; two additional formats, @samp{s} (string)
-and @samp{i} (machine instruction) can be used without specifying a unit
-size.
-@end table
-
-For example, @samp{x/3uh 0x54320} is a request to display three halfwords
-(@code{h}) of memory, formatted as unsigned decimal integers (@samp{u}),
-starting at address @code{0x54320}. @samp{x/4xw $sp} prints the four
-words (@samp{w}) of memory above the stack pointer (here, @samp{$sp};
-@pxref{Registers}) in hexadecimal (@samp{x}).
-
-Since the letters indicating unit sizes are all distinct from the
-letters specifying output formats, you don't have to remember whether
-unit size or format comes first; either order will work. The output
-specifications @samp{4xw} and @samp{4wx} mean exactly the same thing.
-
-After the format specification, you supply an expression for the address
-where _GDBN__ is to begin reading from memory. The expression need not
-have a pointer value (though it may); it is always interpreted as an
-integer address of a byte of memory. @xref{Expressions} for more
-information on expressions.
-
-These are the memory units @var{u} you can specify with the @code{x}
-command:
-
-@table @code
-@item b
-Examine individual bytes.
-
-@item h
-Examine halfwords (two bytes each).
-
-@item w
-Examine words (four bytes each).
-
-@cindex word
-Many assemblers and cpu designers still use `word' for a 16-bit quantity,
-as a holdover from specific predecessor machines of the 1970's that really
-did use two-byte words. But more generally the term `word' has always
-referred to the size of quantity that a machine normally operates on and
-stores in its registers. This is 32 bits for all the machines that _GDBN__
-runs on.
-
-@item g
-Examine giant words (8 bytes).
-@end table
-
-You can combine these unit specifications with any of the formats
-described for @code{print}. @xref{Output formats}.
-
-@code{x} has two additional output specifications which derive the unit
-size from the data inspected:
-
-@table @code
-@item s
-Print a null-terminated string of characters. Any explicitly specified
-unit size is ignored; instead, the unit is however many bytes it takes
-to reach a null character (including the null character).
-
-@item i
-Print a machine instruction in assembler syntax (or nearly). Any
-specified unit size is ignored; the number of bytes in an instruction
-varies depending on the type of machine, the opcode and the addressing
-modes used. The command @code{disassemble} gives an alternative way of
-inspecting machine instructions. @xref{Machine Code}.
-@end table
-
-If you omit either the format @var{f} or the unit size @var{u}, @code{x}
-will use the same one that was used last. If you don't use any letters
-or digits after the slash, you can omit the slash as well.
-
-You can also omit the address to examine. Then the address used is just
-after the last unit examined. This is why string and instruction
-formats actually compute a unit-size based on the data: so that the next
-string or instruction examined will start in the right place.
-
-When the @code{print} command shows a value that resides in memory,
-@code{print} also sets the default address for the @code{x} command.
-@code{info line} also sets the default for @code{x}, to the address of
-the start of the machine code for the specified line
-(@pxref{Machine Code}),
-and @code{info breakpoints} sets it to the address of the last
-breakpoint listed (@pxref{Set Breaks}).@refill
-
-When you use @key{RET} to repeat an @code{x} command, the address
-specified previously (if any) is ignored, so that the repeated command
-examines the successive locations in memory rather than the same ones.
-
-You can examine several consecutive units of memory with one command by
-writing a repeat-count after the slash (before the format letters, if
-any). Omitting the repeat count @var{n} displays one unit of the
-appropriate size. The repeat count must be a decimal integer. It has
-the same effect as repeating the @code{x} command @var{n} times except
-that the output may be more compact, with several units per line. For
-example,
-
-@example
-x/10i $pc
-@end example
-
-@noindent
-prints ten instructions starting with the one to be executed next in the
-selected frame. After doing this, you could print a further seven
-instructions with
-
-@example
-x/7
-@end example
-
-@noindent
----where the format and address are allowed to default.
-
-@cindex @code{$_}, @code{$__}, and value history
-The addresses and contents printed by the @code{x} command are not put
-in the value history because there is often too much of them and they
-would get in the way. Instead, _GDBN__ makes these values available for
-subsequent use in expressions as values of the convenience variables
-@code{$_} and @code{$__}. After an @code{x} command, the last address
-examined is available for use in expressions in the convenience variable
-@code{$_}. The contents of that address, as examined, are available in
-the convenience variable @code{$__}.
-
-If the @code{x} command has a repeat count, the address and contents saved
-are from the last memory unit printed; this is not the same as the last
-address printed if several units were printed on the last line of output.
-
-@node Auto Display, Print Settings, Memory, Data
-@section Automatic Display
-@cindex automatic display
-@cindex display of expressions
-
-If you find that you want to print the value of an expression frequently
-(to see how it changes), you might want to add it to the @dfn{automatic
-display list} so that _GDBN__ will print its value each time the program stops.
-Each expression added to the list is given a number to identify it;
-to remove an expression from the list, you specify that number.
-The automatic display looks like this:
-
-@example
-2: foo = 38
-3: bar[5] = (struct hack *) 0x3804
-@end example
-
-@noindent
-showing item numbers, expressions and their current values. As with
-displays you request manually using @code{x} or @code{print}, you can
-specify the output format you prefer; in fact, @code{display} decides
-whether to use @code{print} or @code{x} depending on how elaborate your
-format specification is---it uses @code{x} if you specify a unit size,
-or one of the two formats (@samp{i} and @samp{s}) that are only
-supported by @code{x}; otherwise it uses @code{print}.
-
-@table @code
-@item display @var{exp}
-@kindex display
-Add the expression @var{exp} to the list of expressions to display
-each time the program stops. @xref{Expressions}.
-
-@code{display} will not repeat if you press @key{RET} again after using it.
-
-@item display/@var{fmt} @var{exp}
-For @var{fmt} specifying only a display format and not a size or
-count, add the expression @var{exp} to the auto-display list but
-arranges to display it each time in the specified format @var{fmt}.
-@xref{Output formats}.
-
-@item display/@var{fmt} @var{addr}
-For @var{fmt} @samp{i} or @samp{s}, or including a unit-size or a
-number of units, add the expression @var{addr} as a memory address to
-be examined each time the program stops. Examining means in effect
-doing @samp{x/@var{fmt} @var{addr}}. @xref{Memory}.
-@end table
-
-For example, @samp{display/i $pc} can be helpful, to see the machine
-instruction about to be executed each time execution stops (@samp{$pc}
-is a common name for the program counter; @pxref{Registers}).
-
-@table @code
-@item undisplay @var{dnums}@dots{}
-@itemx delete display @var{dnums}@dots{}
-@kindex delete display
-@kindex undisplay
-Remove item numbers @var{dnums} from the list of expressions to display.
-
-@code{undisplay} will not repeat if you press @key{RET} after using it.
-(Otherwise you would just get the error @samp{No display number @dots{}}.)
-
-@item disable display @var{dnums}@dots{}
-@kindex disable display
-Disable the display of item numbers @var{dnums}. A disabled display
-item is not printed automatically, but is not forgotten. It may be
-enabled again later.
-
-@item enable display @var{dnums}@dots{}
-@kindex enable display
-Enable display of item numbers @var{dnums}. It becomes effective once
-again in auto display of its expression, until you specify otherwise.
-
-@item display
-Display the current values of the expressions on the list, just as is
-done when the program stops.
-
-@item info display
-@kindex info display
-Print the list of expressions previously set up to display
-automatically, each one with its item number, but without showing the
-values. This includes disabled expressions, which are marked as such.
-It also includes expressions which would not be displayed right now
-because they refer to automatic variables not currently available.
-@end table
-
-If a display expression refers to local variables, then it does not make
-sense outside the lexical context for which it was set up. Such an
-expression is disabled when execution enters a context where one of its
-variables is not defined. For example, if you give the command
-@code{display last_char} while inside a function with an argument
-@code{last_char}, then this argument will be displayed while the program
-continues to stop inside that function. When it stops elsewhere---where
-there is no variable @code{last_char}---display is disabled. The next time
-your program stops where @code{last_char} is meaningful, you can enable the
-display expression once again.
-
-@node Print Settings, Value History, Auto Display, Data
-@section Print Settings
-
-@cindex format options
-@cindex print settings
-_GDBN__ provides the following ways to control how arrays, structures,
-and symbols are printed.
-
-@noindent
-These settings are useful for debugging programs in any language:
-
-@table @code
-@item set print address
-@item set print address on
-@kindex set print address
-_GDBN__ will print memory addresses showing the location of stack
-traces, structure values, pointer values, breakpoints, and so forth,
-even when it also displays the contents of those addresses. The default
-is on. For example, this is what a stack frame display looks like, with
-@code{set print address on}:
-@smallexample
-(_GDBP__) f
-#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
- at input.c:530
-530 if (lquote != def_lquote)
-@end smallexample
-
-@item set print address off
-Do not print addresses when displaying their contents. For example,
-this is the same stack frame displayed with @code{set print address off}:
-@example
-(_GDBP__) set print addr off
-(_GDBP__) f
-#0 set_quotes (lq="<<", rq=">>") at input.c:530
-530 if (lquote != def_lquote)
-@end example
-
-@item show print address
-@kindex show print address
-Show whether or not addresses are to be printed.
-
-@item set print array
-@itemx set print array on
-@kindex set print array
-_GDBN__ will pretty print arrays. This format is more convenient to read,
-but uses more space. The default is off.
-
-@item set print array off.
-Return to compressed format for arrays.
-
-@item show print array
-@kindex show print array
-Show whether compressed or pretty format is selected for displaying
-arrays.
-
-@item set print elements @var{number-of-elements}
-@kindex set print elements
-If _GDBN__ is printing a large array, it will stop printing after it has
-printed the number of elements set by the @code{set print elements} command.
-This limit also applies to the display of strings.
-
-@item show print elements
-@kindex show print elements
-Display the number of elements of a large array that _GDBN__ will print
-before losing patience.
-
-@item set print pretty on
-@kindex set print pretty
-Cause _GDBN__ to print structures in an indented format with one member per
-line, like this:
-
-@example
-$1 = @{
- next = 0x0,
- flags = @{
- sweet = 1,
- sour = 1
- @},
- meat = 0x54 "Pork"
-@}
-@end example
-
-@item set print pretty off
-Cause _GDBN__ to print structures in a compact format, like this:
-
-@smallexample
-$1 = @{next = 0x0, flags = @{sweet = 1, sour = 1@}, meat \
-= 0x54 "Pork"@}
-@end smallexample
-
-@noindent
-This is the default format.
-
-@item show print pretty
-@kindex show print pretty
-Show which format _GDBN__ will use to print structures.
-
-@item set print sevenbit-strings on
-@kindex set print sevenbit-strings
-Print using only seven-bit characters; if this option is set,
-_GDBN__ will display any eight-bit characters (in strings or character
-values) using the notation @code{\}@var{nnn}. For example, @kbd{M-a} is
-displayed as @code{\341}.
-
-@item set print sevenbit-strings off
-Print using either seven-bit or eight-bit characters, as required. This
-is the default.
-
-@item show print sevenbit-strings
-@kindex show print sevenbit-strings
-Show whether or not _GDBN__ will print only seven-bit characters.
-
-@item set print union on
-@kindex set print union
-Tell _GDBN__ to print unions which are contained in structures. This is the
-default setting.
-
-@item set print union off
-Tell _GDBN__ not to print unions which are contained in structures.
-
-@item show print union
-@kindex show print union
-Ask _GDBN__ whether or not it will print unions which are contained in
-structures.
-
-For example, given the declarations
-
-@smallexample
-typedef enum @{Tree, Bug@} Species;
-typedef enum @{Big_tree, Acorn, Seedling@} Tree_forms;
-typedef enum @{Caterpillar, Cocoon, Butterfly@} Bug_forms;
-
-struct thing @{
- Species it;
- union @{
- Tree_forms tree;
- Bug_forms bug;
- @} form;
-@};
-
-struct thing foo = @{Tree, @{Acorn@}@};
-@end smallexample
-
-@noindent
-with @code{set print union on} in effect @samp{p foo} would print
-
-@smallexample
-$1 = @{it = Tree, form = @{tree = Acorn, bug = Cocoon@}@}
-@end smallexample
-
-@noindent
-and with @code{set print union off} in effect it would print
-
-@smallexample
-$1 = @{it = Tree, form = @{...@}@}
-@end smallexample
-@end table
-
-@noindent
-These settings are of interest when debugging C++ programs:
-
-@table @code
-@item set print demangle
-@itemx set print demangle on
-@kindex set print demangle
-Print C++ names in their source form rather than in the mangled form
-in which they are passed to the assembler and linker for type-safe linkage.
-The default is on.
-
-@item show print demangle
-@kindex show print demangle
-Show whether C++ names will be printed in mangled or demangled form.
-
-@item set print asm-demangle
-@itemx set print asm-demangle on
-@kindex set print asm-demangle
-Print C++ names in their source form rather than their mangled form, even
-in assembler code printouts such as instruction disassemblies.
-The default is off.
-
-@item show print asm-demangle
-@kindex show print asm-demangle
-Show whether C++ names in assembly listings will be printed in mangled
-or demangled form.
-
-@item set print object
-@itemx set print object on
-@kindex set print object
-When displaying a pointer to an object, identify the @emph{actual}
-(derived) type of the object rather than the @emph{declared} type, using
-the virtual function table.
-
-@item set print object off
-Display only the declared type of objects, without reference to the
-virtual function table. This is the default setting.
-
-@item show print object
-@kindex show print object
-Show whether actual, or declared, object types will be displayed.
-
-@item set print vtbl
-@itemx set print vtbl on
-@kindex set print vtbl
-Pretty print C++ virtual function tables. The default is off.
-
-@item set print vtbl off
-Do not pretty print C++ virtual function tables.
-
-@item show print vtbl
-@kindex show print vtbl
-Show whether C++ virtual function tables are pretty printed, or not.
-
-@end table
-
-@node Value History, Convenience Vars, Print Settings, Data
-@section Value History
-
-@cindex value history
-Values printed by the @code{print} command are saved in _GDBN__'s @dfn{value
-history} so that you can refer to them in other expressions. Values are
-kept until the symbol table is re-read or discarded (for example with
-the @code{file} or @code{symbol-file} commands). When the symbol table
-changes, the value history is discarded, since the values may contain
-pointers back to the types defined in the symbol table.
-
-@cindex @code{$}
-@cindex @code{$$}
-@cindex history number
-The values printed are given @dfn{history numbers} for you to refer to them
-by. These are successive integers starting with one. @code{print} shows you
-the history number assigned to a value by printing @samp{$@var{num} = }
-before the value; here @var{num} is the history number.
-
-To refer to any previous value, use @samp{$} followed by the value's
-history number. The way @code{print} labels its output is designed to
-remind you of this. Just @code{$} refers to the most recent value in
-the history, and @code{$$} refers to the value before that.
-@code{$$@var{n}} refers to the @var{n}th value from the end; @code{$$2}
-is the value just prior to @code{$$}, @code{$$1} is equivalent to
-@code{$$}, and @code{$$0} is equivalent to @code{$}.
-
-For example, suppose you have just printed a pointer to a structure and
-want to see the contents of the structure. It suffices to type
-
-@example
-p *$
-@end example
-
-If you have a chain of structures where the component @code{next} points
-to the next one, you can print the contents of the next one with this:
-
-@example
-p *$.next
-@end example
-
-@noindent
-You can print successive links in the chain by repeating this
-command---which you can do by just typing @key{RET}.
-
-Note that the history records values, not expressions. If the value of
-@code{x} is 4 and you type these commands:
-
-@example
-print x
-set x=5
-@end example
-
-@noindent
-then the value recorded in the value history by the @code{print} command
-remains 4 even though the value of @code{x} has changed.
-
-@table @code
-@kindex show values
-@item show values
-Print the last ten values in the value history, with their item numbers.
-This is like @samp{p@ $$9} repeated ten times, except that @code{show
-values} does not change the history.
-
-@item show values @var{n}
-Print ten history values centered on history item number @var{n}.
-
-@item show values +
-Print ten history values just after the values last printed. If no more
-values are available, produces no display.
-@end table
-
-Pressing @key{RET} to repeat @code{show values @var{n}} has exactly the
-same effect as @samp{show values +}.
-
-@node Convenience Vars, Registers, Value History, Data
-@section Convenience Variables
-
-@cindex convenience variables
-_GDBN__ provides @dfn{convenience variables} that you can use within
-_GDBN__ to hold on to a value and refer to it later. These variables
-exist entirely within _GDBN__; they are not part of your program, and
-setting a convenience variable has no direct effect on further execution
-of your program. That's why you can use them freely.
-
-Convenience variables are prefixed with @samp{$}. Any name preceded by
-@samp{$} can be used for a convenience variable, unless it is one of
-the predefined machine-specific register names (@pxref{Registers}).
-(Value history references, in contrast, are @emph{numbers} preceded
-by @samp{$}. @xref{Value History}.)
-
-You can save a value in a convenience variable with an assignment
-expression, just as you would set a variable in your program. Example:
-
-@example
-set $foo = *object_ptr
-@end example
-
-@noindent
-would save in @code{$foo} the value contained in the object pointed to by
-@code{object_ptr}.
-
-Using a convenience variable for the first time creates it; but its value
-is @code{void} until you assign a new value. You can alter the value with
-another assignment at any time.
-
-Convenience variables have no fixed types. You can assign a convenience
-variable any type of value, including structures and arrays, even if
-that variable already has a value of a different type. The convenience
-variable, when used as an expression, has the type of its current value.
-
-@table @code
-@item show convenience
-@kindex show convenience
-Print a list of convenience variables used so far, and their values.
-Abbreviated @code{show con}.
-@end table
-
-One of the ways to use a convenience variable is as a counter to be
-incremented or a pointer to be advanced. For example, to print
-a field from successive elements of an array of structures:
-
-_0__@example
-set $i = 0
-print bar[$i++]->contents
-@i{@dots{} repeat that command by typing @key{RET}.}
-_1__@end example
-
-Some convenience variables are created automatically by _GDBN__ and given
-values likely to be useful.
-
-@table @code
-@item $_
-@kindex $_
-The variable @code{$_} is automatically set by the @code{x} command to
-the last address examined (@pxref{Memory}). Other commands which
-provide a default address for @code{x} to examine also set @code{$_}
-to that address; these commands include @code{info line} and @code{info
-breakpoint}. The type of @code{$_} is @code{void *} except when set by the
-@code{x} command, in which case it is a pointer to the type of @code{$__}.
-
-@item $__
-@kindex $__
-The variable @code{$__} is automatically set by the @code{x} command
-to the value found in the last address examined. Its type is chosen
-to match the format in which the data was printed.
-@end table
-
-@node Registers, Floating Point Hardware, Convenience Vars, Data
-@section Registers
-
-@cindex registers
-You can refer to machine register contents, in expressions, as variables
-with names starting with @samp{$}. The names of registers are different
-for each machine; use @code{info registers} to see the names used on
-your machine.
-
-@table @code
-@item info registers
-@kindex info registers
-Print the names and values of all registers except floating-point
-registers (in the selected stack frame).
-
-@item info all-registers
-@kindex info all-registers
-@cindex floating point registers
-Print the names and values of all registers, including floating-point
-registers.
-
-@item info registers @var{regname}
-Print the relativized value of register @var{regname}. @var{regname}
-may be any register name valid on the machine you are using, with
-or without the initial @samp{$}.
-@end table
-
-The register names @code{$pc} and @code{$sp} are used on most machines
-for the program counter register and the stack pointer. For example,
-you could print the program counter in hex with
-@example
-p/x $pc
-@end example
-
-@noindent
-or print the instruction to be executed next with
-@example
-x/i $pc
-@end example
-
-@noindent
-or add four to the stack pointer with
-@example
-set $sp += 4
-@end example
-
-@noindent
-The last is a way of removing one word from the stack, on machines where
-stacks grow downward in memory (most machines, nowadays). This assumes
-that the innermost stack frame is selected; setting @code{$sp} is
-not allowed when other stack frames are selected. (To pop entire frames
-off the stack, regardless of machine architecture, use @code{return};
-@pxref{Returning}.)
-
-Often @code{$fp} is used for a register that contains a pointer to the
-current stack frame, and @code{$ps} is sometimes used for a register
-that contains the processor status. These standard register names may
-be available on your machine even though the @code{info registers}
-command shows other names. For example, on the SPARC, @code{info
-registers} displays the processor status register as @code{$psr} but you
-can also refer to it as @code{$ps}.
-
-_GDBN__ always considers the contents of an ordinary register as an
-integer when the register is examined in this way. Some machines have
-special registers which can hold nothing but floating point; these
-registers are considered to have floating point values. There is no way
-to refer to the contents of an ordinary register as floating point value
-(although you can @emph{print} it as a floating point value with
-@samp{print/f $@var{regname}}).
-
-Some registers have distinct ``raw'' and ``virtual'' data formats. This
-means that the data format in which the register contents are saved by
-the operating system is not the same one that your program normally
-sees. For example, the registers of the 68881 floating point
-coprocessor are always saved in ``extended'' (raw) format, but all C
-programs expect to work with ``double'' (virtual) format. In such
-cases, _GDBN__ normally works with the virtual format only (the format that
-makes sense for your program), but the @code{info registers} command
-prints the data in both formats.
-
-Normally, register values are relative to the selected stack frame
-(@pxref{Selection}). This means that you get the value that the
-register would contain if all stack frames farther in were exited and
-their saved registers restored. In order to see the true contents of
-hardware registers, you must select the innermost frame (with
-@samp{frame 0}).
-
-However, _GDBN__ must deduce where registers are saved, from the machine
-code generated by your compiler. If some registers are not saved, or if
-_GDBN__ is unable to locate the saved registers, the selected stack
-frame will make no difference.
-
-@node Floating Point Hardware, , Registers, Data
-@section Floating Point Hardware
-@cindex floating point
-Depending on the host machine architecture, _GDBN__ may be able to give
-you more information about the status of the floating point hardware.
-
-@table @code
-@item info float
-@kindex info float
-If available, provides hardware-dependent information about the floating
-point unit. The exact contents and layout vary depending on the
-floating point chip.
-@end table
-@c FIXME: this is a cop-out. Try to get examples, explanations. Only
-@c FIXME...supported currently on arm's and 386's. Mark properly with
-@c FIXME... m4 macros to isolate general statements from hardware-dep,
-@c FIXME... at that point.
-
-@node Languages, Symbols, Data, Top
-@chapter Using _GDBN__ with Different Languages
-@cindex languages
-
-Although programming languages generally have common aspects, they are
-rarely expressed in the same manner. For instance, in ANSI C,
-dereferencing a pointer @code{p} is accomplished by @code{*p}, but in
-Modula-2, it is accomplished by @code{p^}. Values can also be
-represented (and displayed) differently. Hex numbers in C are written
-like @samp{0x1ae}, while in Modula-2 they appear as @samp{1AEH}.
-
-@cindex working language
-Language-specific information is built into _GDBN__ for some languages,
-allowing you to express operations like the above in the program's
-native language, and allowing _GDBN__ to output values in a manner
-consistent with the syntax of the program's native language. The
-language you use to build expressions, called the @dfn{working
-language}, can be selected manually, or _GDBN__ can set it
-automatically.
-
-@menu
-* Setting:: Switching between source languages
-* Show:: Displaying the language
-* Checks:: Type and Range checks
-* Support:: Supported languages
-@end menu
-
-@node Setting, Show, Languages, Languages
-@section Switching between source languages
-
-There are two ways to control the working language---either have _GDBN__
-set it automatically, or select it manually yourself. You can use the
-@code{set language} command for either purpose. On startup, _GDBN__
-defaults to setting the language automatically.
-
-@menu
-* Manually:: Setting the working language manually
-* Automatically:: Having _GDBN__ infer the source language
-@end menu
-
-@node Manually, Automatically, Setting, Setting
-@subsection Setting the working language
-
-@kindex set language
-To set the language, issue the command @samp{set language @var{lang}},
-where @var{lang} is the name of a language: @code{c} or @code{modula-2}.
-For a list of the supported languages, type @samp{set language}.
-
-Setting the language manually prevents _GDBN__ from updating the working
-language automatically. This can lead to confusion if you try
-to debug a program when the working language is not the same as the
-source language, when an expression is acceptable to both
-languages---but means different things. For instance, if the current
-source file were written in C, and _GDBN__ was parsing Modula-2, a
-command such as:
-
-@example
-print a = b + c
-@end example
-
-@noindent
-might not have the effect you intended. In C, this means to add
-@code{b} and @code{c} and place the result in @code{a}. The result
-printed would be the value of @code{a}. In Modula-2, this means to compare
-@code{a} to the result of @code{b+c}, yielding a @code{BOOLEAN} value.
-
-If you allow _GDBN__ to set the language automatically, then
-you can count on expressions evaluating the same way in your debugging
-session and in your program.
-
-@node Automatically, , Manually, Setting
-@subsection Having _GDBN__ infer the source language
-
-To have _GDBN__ set the working language automatically, use @samp{set
-language local} or @samp{set language auto}. _GDBN__ then infers the
-language that a program was written in by looking at the name of its
-source files, and examining their extensions:
-
-@table @file
-@item *.mod
-Modula-2 source file
-
-@item *.c
-@itemx *.cc
-C or C++ source file.
-@end table
-
-This information is recorded for each function or procedure in a source
-file. When your program stops in a frame (usually by encountering a
-breakpoint), _GDBN__ sets the working language to the language recorded
-for the function in that frame. If the language for a frame is unknown
-(that is, if the function or block corresponding to the frame was
-defined in a source file that does not have a recognized extension), the
-current working language is not changed, and _GDBN__ issues a warning.
-
-This may not seem necessary for most programs, which are written
-entirely in one source language. However, program modules and libraries
-written in one source language can be used by a main program written in
-a different source language. Using @samp{set language auto} in this
-case frees you from having to set the working language manually.
-
-@node Show, Checks, Setting, Languages
-@section Displaying the language
-
-The following commands will help you find out which language is the
-working language, and also what language source files were written in.
-
-@kindex show language
-@kindex info frame
-@kindex info source
-@table @code
-@item show language
-Display the current working language. This is the
-language you can use with commands such as @code{print} to
-build and compute expressions that may involve variables in the program.
-
-@item info frame
-Among the other information listed here (@pxref{Frame Info,,Information
-about a Frame}) is the source language for this frame. This is the
-language that will become the working language if you ever use an
-identifier that is in this frame.
-
-@item info source
-Among the other information listed here (@pxref{Symbols,,Examining the
-Symbol Table}) is the source language of this source file.
-
-@end table
-
-@node Checks, Support, Show, Languages
-@section Type and range Checking
-
-@quotation
-@emph{Warning:} In this release, the _GDBN__ commands for type and range
-checking are included, but they do not yet have any effect. This
-section documents the intended facilities.
-@end quotation
-@c FIXME remove warning when type/range code added
-
-Some languages are designed to guard you against making seemingly common
-errors through a series of compile- and run-time checks. These include
-checking the type of arguments to functions and operators, and making
-sure mathematical overflows are caught at run time. Checks such as
-these help to ensure a program's correctness once it has been compiled
-by eliminating type mismatches, and providing active checks for range
-errors when the program is running.
-
-_GDBN__ can check for conditions like the above if you wish.
-Although _GDBN__ will not check the statements in your program, it
-can check expressions entered directly into _GDBN__ for evaluation via
-the @code{print} command, for example. As with the working language,
-_GDBN__ can also decide whether or not to check automatically based on
-the source language of the program being debugged.
-@xref{Support,,Supported Languages}, for the default settings
-of supported languages.
-
-@menu
-* Type Checking:: An overview of type checking
-* Range Checking:: An overview of range checking
-@end menu
-
-@cindex type checking
-@cindex checks, type
-@node Type Checking, Range Checking, Checks, Checks
-@subsection An overview of type checking
-
-Some languages, such as Modula-2, are strongly typed, meaning that the
-arguments to operators and functions have to be of the correct type,
-otherwise an error occurs. These checks prevent type mismatch
-errors from ever causing any run-time problems. For example,
-
-@example
-1 + 2 @result{} 3
-@error{} 1 + 2.3
-@end example
-
-The second example fails because the @code{CARDINAL} 1 is not
-type-compatible with the @code{REAL} 2.3.
-
-For expressions you use in _GDBN__ commands, you can tell the _GDBN__
-type checker to skip checking; to treat any mismatches as errors and
-abandon the expression; or only issue warnings when type mismatches
-occur, but evaluate the expression anyway. When you choose the last of
-these, _GDBN__ evaluates expressions like the second example above, but
-also issues a warning.
-
-Even though you may turn type checking off, other type-based reasons may
-prevent _GDBN__ from evaluating an expression. For instance, _GDBN__ does not
-know how to add an @code{int} and a @code{struct foo}. These particular
-type errors have nothing to do with the language in use, and usually
-arise from expressions, such as the one described above, which make
-little sense to evaluate anyway.
-
-Each language defines to what degree it is strict about type. For
-instance, both Modula-2 and C require the arguments to arithmetical
-operators to be numbers. In C, enumerated types and pointers can be
-represented as numbers, so that they are valid arguments to mathematical
-operators. @xref{Support,,Supported Languages}, for futher
-details on specific languages.
-
-_GDBN__ provides some additional commands for controlling the type checker:
-
-@kindex set check
-@kindex set check type
-@kindex show check type
-@table @code
-@item set check type auto
-Set type checking on or off based on the current working language.
-@xref{Support,,Supported Languages}, for the default settings for
-each language.
-
-@item set check type on
-@itemx set check type off
-Set type checking on or off, overriding the default setting for the
-current working language. Issue a warning if the setting does not
-match the language's default. If any type mismatches occur in
-evaluating an expression while typechecking is on, _GDBN__ prints a
-message and aborts evaluation of the expression.
-
-@item set check type warn
-Cause the type checker to issue warnings, but to always attempt to
-evaluate the expression. Evaluating the expression may still
-be impossible for other reasons. For example, _GDBN__ cannot add
-numbers and structures.
-
-@item show type
-Show the current setting of the type checker, and whether or not _GDBN__ is
-setting it automatically.
-@end table
-
-@cindex range checking
-@cindex checks, range
-@node Range Checking, , Type Checking, Checks
-@subsection An overview of Range Checking
-
-In some languages (such as Modula-2), it is an error to exceed the
-bounds of a type; this is enforced with run-time checks. Such range
-checking is meant to ensure program correctness by making sure
-computations do not overflow, or indices on an array element access do
-not exceed the bounds of the array.
-
-For expressions you use in _GDBN__ commands, you can tell _GDBN__ to
-ignore range errors; to always treat them as errors and abandon the
-expression; or to issue warnings when a range error occurs but evaluate
-the expression anyway.
-
-A range error can result from numerical overflow, from exceeding an
-array index bound, or when you type in a constant that is not a member
-of any type. Some languages, however, do not treat overflows as an
-error. In many implementations of C, mathematical overflow causes the
-result to ``wrap around'' to lower values---for example, if @var{m} is
-the largest integer value, and @var{s} is the smallest, then
-@example
-@var{m} + 1 @result{} @var{s}
-@end example
-
-This, too, is specific to individual languages, and in some cases
-specific to individual compilers or machines. @xref{Support,,
-Supported Languages}, for further details on specific languages.
-
-_GDBN__ provides some additional commands for controlling the range checker:
-
-@kindex set check
-@kindex set check range
-@kindex show check range
-@table @code
-@item set check range auto
-Set range checking on or off based on the current working language.
-@xref{Support,,Supported Languages}, for the default settings for
-each language.
-
-@item set check range on
-@itemx set check range off
-Set range checking on or off, overriding the default setting for the
-current working language. A warning is issued if the setting does not
-match the language's default. If a range error occurs, then a message
-is printed and evaluation of the expression is aborted.
-
-@item set check range warn
-Output messages when the _GDBN__ range checker detects a range error,
-but attempt to evaluate the expression anyway. Evaluating the
-expression may still be impossible for other reasons, such as accessing
-memory that the process does not own (a typical example from many UNIX
-systems).
-
-@item show range
-Show the current setting of the range checker, and whether or not it is
-being set automatically by _GDBN__.
-@end table
-
-@node Support, , Checks, Languages
-@section Supported Languages
-
-_GDBN__ _GDB_VN__ supports C, C++, and Modula-2. The syntax for C and C++ is
-so closely related that _GDBN__ does not distinguish the two. Some
-_GDBN__ features may be used in expressions regardless of the language
-you use: the _GDBN__ @code{@@} and @code{::} operators, and the
-@samp{@{type@}addr} construct (@pxref{Expressions}) can be used with the constructs of
-any of the supported languages.
-
-The following sections detail to what degree each of these
-source languages is supported by _GDBN__. These sections are
-not meant to be language tutorials or references, but serve only as a
-reference guide to what the _GDBN__ expression parser will accept, and
-what input and output formats should look like for different languages.
-There are many good books written on each of these languages; please
-look to these for a language reference or tutorial.
-
-@menu
-* C:: C and C++
-* Modula-2:: Modula-2
-@end menu
-
-@node C, Modula-2, Support, Support
-@subsection C and C++
-@cindex C and C++
-
-@cindex expressions in C or C++
-Since C and C++ are so closely related, _GDBN__ does not distinguish
-between them when interpreting the expressions recognized in _GDBN__
-commands.
-
-@cindex C++
-@kindex g++
-@cindex GNU C++
-The C++ debugging facilities are jointly implemented by the GNU C++
-compiler and _GDBN__. Therefore, to debug your C++ code effectively,
-you must compile your C++ programs with the GNU C++ compiler,
-@code{g++}.
-
-
-@menu
-* C Operators:: C and C++ Operators
-* C Constants:: C and C++ Constants
-* Cplusplus expressions:: C++ Expressions
-* C Defaults:: Default settings for C and C++
-* C Checks:: C and C++ Type and Range Checks
-* Debugging C:: _GDBN__ and C
-* Debugging C plus plus:: Special features for C++
-@end menu
-
-@cindex C and C++ operators
-@node C Operators, C Constants, C, C
-@subsubsection C and C++ Operators
-
-Operators must be defined on values of specific types. For instance,
-@code{+} is defined on numbers, but not on structures. Operators are
-often defined on groups of types. For the purposes of C and C++, the
-following definitions hold:
-
-@itemize @bullet
-@item
-@emph{Integral types} include @code{int} with any of its storage-class
-specifiers, @code{char}, and @code{enum}s.
-
-@item
-@emph{Floating-point types} include @code{float} and @code{double}.
-
-@item
-@emph{Pointer types} include all types defined as @code{(@var{type}
-*)}.
-
-@item
-@emph{Scalar types} include all of the above.
-
-@end itemize
-
-@noindent
-The following operators are supported. They are listed here
-in order of increasing precedence:
-
-@table @code
-_0__
-@item ,
-The comma or sequencing operator. Expressions in a comma-separated list
-are evaluated from left to right, with the result of the entire
-expression being the last expression evaluated.
-
-@item =
-Assignment. The value of an assignment expression is the value
-assigned. Defined on scalar types.
-
-@item @var{op}=
-Used in an expression of the form @var{a} @var{op}@code{=} @var{b}, and
-translated to @var{a} @code{=} @var{a op b}. @var{op}@code{=} and
-@code{=} have the same precendence. @var{op} is any one of the
-operators @code{|}, @code{^}, @code{&}, @code{<<}, @code{>>}, @code{+},
-@code{-}, @code{*}, @code{/}, @code{%}.
-
-@item ?:
-The ternary operator. @code{@var{a} ? @var{b} : @var{c}} can be thought
-of as: if @var{a} then @var{b} else @var{c}. @var{a} should be of an
-integral type.
-
-@item ||
-Logical OR. Defined on integral types.
-
-@item &&
-Logical AND. Defined on integral types.
-
-@item |
-Bitwise OR. Defined on integral types.
-
-@item ^
-Bitwise exclusive-OR. Defined on integral types.
-
-@item &
-Bitwise AND. Defined on integral types.
-
-@item ==@r{, }!=
-Equality and inequality. Defined on scalar types. The value of these
-expressions is 0 for false and non-zero for true.
-
-@item <@r{, }>@r{, }<=@r{, }>=
-Less than, greater than, less than or equal, greater than or equal.
-Defined on scalar types. The value of these expressions is 0 for false
-and non-zero for true.
-
-@item <<@r{, }>>
-left shift, and right shift. Defined on integral types.
-
-@item @@
-The _GDBN__ ``artificial array'' operator (@pxref{Expressions}).
-
-@item +@r{, }-
-Addition and subtraction. Defined on integral types, floating-point types and
-pointer types.
-
-@item *@r{, }/@r{, }%
-Multiplication, division, and modulus. Multiplication and division are
-defined on integral and floating-point types. Modulus is defined on
-integral types.
-
-@item ++@r{, }--
-Increment and decrement. When appearing before a variable, the
-operation is performed before the variable is used in an expression;
-when appearing after it, the variable's value is used before the
-operation takes place.
-
-@item *
-Pointer dereferencing. Defined on pointer types. Same precedence as
-@code{++}.
-
-@item &
-Address operator. Defined on variables. Same precedence as @code{++}.
-
-@item -
-Negative. Defined on integral and floating-point types. Same
-precedence as @code{++}.
-
-@item !
-Logical negation. Defined on integral types. Same precedence as
-@code{++}.
-
-@item ~
-Bitwise complement operator. Defined on integral types. Same precedence as
-@code{++}.
-
-@item .@r{, }->
-Structure member, and pointer-to-structure member. For convenience,
-_GDBN__ regards the two as equivalent, choosing whether to dereference a
-pointer based on the stored type information.
-Defined on @code{struct}s and @code{union}s.
-
-@item []
-Array indexing. @code{@var{a}[@var{i}]} is defined as
-@code{*(@var{a}+@var{i})}. Same precedence as @code{->}.
-
-@item ()
-Function parameter list. Same precedence as @code{->}.
-
-@item ::
-C++ scope resolution operator. Defined on
-@code{struct}, @code{union}, and @code{class} types.
-
-@item ::
-The _GDBN__ scope operator (@pxref{Expressions}). Same precedence as
-@code{::}, above. _1__
-@end table
-
-@cindex C and C++ constants
-@node C Constants, Cplusplus expressions, C Operators, C
-@subsubsection C and C++ Constants
-
-_GDBN__ allows you to express the constants of C and C++ in the
-following ways:
-
-@itemize @bullet
-
-@item
-Integer constants are a sequence of digits. Octal constants are
-specified by a leading @samp{0} (ie. zero), and hexadecimal constants by
-a leading @samp{0x} or @samp{0X}. Constants may also end with an
-@samp{l}, specifying that the constant should be treated as a
-@code{long} value.
-
-@item
-Floating point constants are a sequence of digits, followed by a decimal
-point, followed by a sequence of digits, and optionally followed by an
-exponent. An exponent is of the form:
-@samp{@w{e@r{[[}+@r{]|}-@r{]}@var{nnn}}}, where @var{nnn} is another
-sequence of digits. The @samp{+} is optional for positive exponents.
-
-@item
-Enumerated constants consist of enumerated identifiers, or their
-integral equivalents.
-
-@item
-Character constants are a single character surrounded by single quotes
-(@code{'}), or a number---the ordinal value of the corresponding character
-(usually its @sc{ASCII} value). Within quotes, the single character may
-be represented by a letter or by @dfn{escape sequences}, which are of
-the form @samp{\@var{nnn}}, where @var{nnn} is the octal representation
-of the character's ordinal value; or of the form @samp{\@var{x}}, where
-@samp{@var{x}} is a predefined special character---for example,
-@samp{\n} for newline.
-
-@item
-String constants are a sequence of character constants surrounded
-by double quotes (@code{"}).
-
-@item
-Pointer constants are an integral value.
-
-@end itemize
-
-
-@node Cplusplus expressions, C Defaults, C Constants, C
-@subsubsection C++ Expressions
-
-@cindex expressions in C++
-_GDBN__'s expression handling has the following extensions to
-interpret a significant subset of C++ expressions:
-
-@enumerate
-
-@cindex member functions
-@item
-Member function calls are allowed; you can use expressions like
-@example
-count = aml->GetOriginal(x, y)
-@end example
-
-@kindex this
-@cindex namespace in C++
-@item
-While a member function is active (in the selected stack frame), your
-expressions have the same namespace available as the member function;
-that is, _GDBN__ allows implicit references to the class instance
-pointer @code{this} following the same rules as C++.
-
-@cindex call overloaded functions
-@cindex type conversions in C++
-@item
-You can call overloaded functions; _GDBN__ will resolve the function
-call to the right definition, with one restriction---you must use
-arguments of the type required by the function that you want to call.
-_GDBN__ will not perform conversions requiring constructors or
-user-defined type operators.
-
-@cindex reference declarations
-@item
-_GDBN__ understands variables declared as C++ references; you can use them in
-expressions just as you do in C++ source---they are automatically
-dereferenced.
-
-In the parameter list shown when _GDBN__ displays a frame, the values of
-reference variables are not displayed (unlike other variables); this
-avoids clutter, since references are often used for large structures.
-The @emph{address} of a reference variable is always shown, unless
-you've specified @samp{set print address off}.
-
-
-@item
-_GDBN__ supports the C++ name resolution operator @code{::}---your
-expressions can use it just as expressions in your program do. Since
-one scope may be defined in another, you can use @code{::} repeatedly if
-necessary, for example in an expression like
-@samp{@var{scope1}::@var{scope2}::@var{name}}. _GDBN__ also allows
-resolving name scope by reference to source files, in both C and C++
-debugging; @pxref{Variables}.
-
-@end enumerate
-
-
-@node C Defaults, C Checks, Cplusplus expressions, C
-@subsubsection C and C++ Defaults
-@cindex C and C++ defaults
-
-If you allow _GDBN__ to set type and range checking automatically, they
-both default to @code{off} whenever the working language changes to
-C/C++. This happens regardless of whether you, or _GDBN__,
-selected the working language.
-
-If you allow _GDBN__ to set the language automatically, it sets the
-working language to C/C++ on entering code compiled from a source file
-whose name ends with @file{.c} or @file{.cc}.
-@xref{Automatically,,Having _GDBN__ infer the source language}, for
-further details.
-
-@node C Checks, Debugging C, C Defaults, C
-@subsubsection C and C++ Type and Range Checks
-@cindex C and C++ checks
-
-@quotation
-@emph{Warning:} in this release, _GDBN__ does not yet perform type or
-range checking.
-@end quotation
-@c FIXME remove warning when type/range checks added
-
-By default, when _GDBN__ parses C or C++ expressions, type checking
-is not used. However, if you turn type checking on, _GDBN__ will
-consider two variables type equivalent if:
-
-@itemize @bullet
-@item
-The two variables are structured and have the same structure, union, or
-enumerated tag.
-
-@item
-Two two variables have the same type name, or types that have been
-declared equivalent through @code{typedef}.
-
-@ignore
-@c leaving this out because neither J Gilmore nor R Pesch understand it.
-@c FIXME--beers?
-@item
-The two @code{struct}, @code{union}, or @code{enum} variables are
-declared in the same declaration. (Note: this may not be true for all C
-compilers.)
-@end ignore
-
-@end itemize
-
-Range checking, if turned on, is done on mathematical operations. Array
-indices are not checked, since they are often used to index a pointer
-that is not itself an array.
-
-@node Debugging C, Debugging C plus plus, C Checks, C
-@subsubsection _GDBN__ and C
-
-The @code{set print union} and @code{show print union} commands apply to
-the @code{union} type. When set to @samp{on}, any @code{union} that is
-inside a @code{struct} or @code{class} will also be printed.
-Otherwise, it will appear as @samp{@{...@}}.
-
-The @code{@@} operator aids in the debugging of dynamic arrays, formed
-with pointers and a memory allocation function. (@pxref{Expressions})
-
-@node Debugging C plus plus, , Debugging C, C
-@subsubsection _GDBN__ Commands for C++
-
-@cindex commands for C++
-Some _GDBN__ commands are particularly useful with C++, and some are
-designed specifically for use with C++. Here is a summary:
-
-@table @code
-@cindex break in overloaded functions
-@item @r{breakpoint menus}
-When you want a breakpoint in a function whose name is overloaded,
-_GDBN__'s breakpoint menus help you specify which function definition
-you want. @xref{Breakpoint Menus}.
-
-@cindex overloading in C++
-@item rbreak @var{regex}
-Setting breakpoints using regular expressions is helpful for setting
-breakpoints on overloaded functions that are not members of any special
-classes.
-@xref{Set Breaks}.
-
-@cindex C++ exception handling
-@item catch @var{exceptions}
-@itemx info catch
-Debug C++ exception handling using these commands. @xref{Exception Handling}.
-
-@cindex inheritance
-@item ptype @var{typename}
-Print inheritance relationships as well as other information for type
-@var{typename}.
-@xref{Symbols}.
-
-@cindex C++ symbol display
-@item set print demangle
-@itemx show print demangle
-@itemx set print asm-demangle
-@itemx show print asm-demangle
-Control whether C++ symbols display in their source form, both when
-displaying code as C++ source and when displaying disassemblies.
-@xref{Print Settings}.
-
-@item set print object
-@itemx show print object
-Choose whether to print derived (actual) or declared types of objects.
-@xref{Print Settings}.
-
-@item set print vtbl
-@itemx show print vtbl
-Control the format for printing virtual function tables.
-@xref{Print Settings}.
-
-@end table
-
-
-@node Modula-2, , C, Support
-@subsection Modula-2
-@cindex Modula-2
-
-The extensions made to _GDBN__ to support Modula-2 support output
-from the GNU Modula-2 compiler (which is currently being developed).
-Other Modula-2 compilers are not currently supported, and attempting to
-debug executables produced by them will most likely result in an error
-as _GDBN__ reads in the executable's symbol table.
-
-@cindex expressions in Modula-2
-@menu
-* M2 Operators:: Built-in operators
-* Builtin Func/Proc:: Built-in Functions and Procedures
-* M2 Constants:: Modula-2 Constants
-* M2 Defaults:: Default settings for Modula-2
-* Deviations:: Deviations from standard Modula-2
-* M2 Checks:: Modula-2 Type and Range Checks
-* M2 Scope:: The scope operators @code{::} and @code{.}
-* GDB/M2:: _GDBN__ and Modula-2
-@end menu
-
-@node M2 Operators, Builtin Func/Proc, Modula-2, Modula-2
-@subsubsection Operators
-@cindex Modula-2 operators
-
-Operators must be defined on values of specific types. For instance,
-@code{+} is defined on numbers, but not on structures. Operators are
-often defined on groups of types. For the purposes of Modula-2, the
-following definitions hold:
-
-@itemize @bullet
-
-@item
-@emph{Integral types} consist of @code{INTEGER}, @code{CARDINAL}, and
-their subranges.
-
-@item
-@emph{Character types} consist of @code{CHAR} and its subranges.
-
-@item
-@emph{Floating-point types} consist of @code{REAL}.
-
-@item
-@emph{Pointer types} consist of anything declared as @code{POINTER TO
-@var{type}}.
-
-@item
-@emph{Scalar types} consist of all of the above.
-
-@item
-@emph{Set types} consist of @code{SET}s and @code{BITSET}s.
-
-@item
-@emph{Boolean types} consist of @code{BOOLEAN}.
-
-@end itemize
-
-@noindent
-The following operators are supported, and appear in order of
-increasing precedence:
-
-@table @code
-_0__
-@item ,
-Function argument or array index separator.
-
-@item :=
-Assignment. The value of @var{var} @code{:=} @var{value} is
-@var{value}.
-
-@item <@r{, }>
-Less than, greater than on integral, floating-point, or enumerated
-types.
-
-@item <=@r{, }>=
-Less than, greater than, less than or equal to, greater than or equal to
-on integral, floating-point and enumerated types, or set inclusion on
-set types. Same precedence as @code{<}.
-
-@item =@r{, }<>@r{, }#
-Equality and two ways of expressing inequality, valid on scalar types.
-Same precedence as @code{<}. In _GDBN__ scripts, only @code{<>} is
-available for inequality, since @code{#} conflicts with the script
-comment character.
-
-@item IN
-Set membership. Defined on set types and the types of their members.
-Same precedence as @code{<}.
-
-@item OR
-Boolean disjunction. Defined on boolean types.
-
-@item AND@r{, }&
-Boolean conjuction. Defined on boolean types.
-
-@item @@
-The _GDBN__ ``artificial array'' operator (@pxref{Expressions}).
-
-@item +@r{, }-
-Addition and subtraction on integral and floating-point types, or union
-and difference on set types.
-
-@item *
-Multiplication on integral and floating-point types, or set intersection
-on set types.
-
-@item /
-Division on floating-point types, or symmetric set difference on set
-types. Same precedence as @code{*}.
-
-@item DIV@r{, }MOD
-Integer division and remainder. Defined on integral types. Same
-precedence as @code{*}.
-
-@item -
-Negative. Defined on @code{INTEGER}s and @code{REAL}s.
-
-@item ^
-Pointer dereferencing. Defined on pointer types.
-
-@item NOT
-Boolean negation. Defined on boolean types. Same precedence as
-@code{^}.
-
-@item .
-@code{RECORD} field selector. Defined on @code{RECORD}s. Same
-precedence as @code{^}.
-
-@item []
-Array indexing. Defined on @code{ARRAY}s. Same precedence as @code{^}.
-
-@item ()
-Procedure argument list. Defined on @code{PROCEDURE}s. Same precedence
-as @code{^}.
-
-@item ::@r{, }.
-_GDBN__ and Modula-2 scope operators.
-
-@end table
-
-@quotation
-@emph{Warning:} Sets and their operations are not yet supported, so _GDBN__
-will treat the use of the operator @code{IN}, or the use of operators
-@code{+}, @code{-}, @code{*}, @code{/}, @code{=}, , @code{<>}, @code{#},
-@code{<=}, and @code{>=} on sets as an error.
-@end quotation
-_1__
-
-@cindex Modula-2 builtins
-@node Builtin Func/Proc, M2 Constants, M2 Operators, Modula-2
-@subsubsection Built-in Functions and Procedures
-
-Modula-2 also makes available several built-in procedures and functions.
-In describing these, the following metavariables are used:
-
-@table @var
-
-@item a
-represents an @code{ARRAY} variable.
-
-@item c
-represents a @code{CHAR} constant or variable.
-
-@item i
-represents a variable or constant of integral type.
-
-@item m
-represents an identifier that belongs to a set. Generally used in the
-same function with the metavariable @var{s}. The type of @var{s} should
-be @code{SET OF @var{mtype}} (where @var{mtype} is the type of @var{m}.
-
-@item n
-represents a variable or constant of integral or floating-point type.
-
-@item r
-represents a variable or constant of floating-point type.
-
-@item t
-represents a type.
-
-@item v
-represents a variable.
-
-@item x
-represents a variable or constant of one of many types. See the
-explanation of the function for details.
-
-@end table
-
-All Modula-2 built-in procedures also return a result, described below.
-
-@table @code
-@item ABS(@var{n})
-Returns the absolute value of @var{n}.
-
-@item CAP(@var{c})
-If @var{c} is a lower case letter, it returns its upper case
-equivalent, otherwise it returns its argument
-
-@item CHR(@var{i})
-Returns the character whose ordinal value is @var{i}.
-
-@item DEC(@var{v})
-Decrements the value in the variable @var{v}. Returns the new value.
-
-@item DEC(@var{v},@var{i})
-Decrements the value in the variable @var{v} by @var{i}. Returns the
-new value.
-
-@item EXCL(@var{m},@var{s})
-Removes the element @var{m} from the set @var{s}. Returns the new
-set.
-
-@item FLOAT(@var{i})
-Returns the floating point equivalent of the integer @var{i}.
-
-@item HIGH(@var{a})
-Returns the index of the last member of @var{a}.
-
-@item INC(@var{v})
-Increments the value in the variable @var{v}. Returns the new value.
-
-@item INC(@var{v},@var{i})
-Increments the value in the variable @var{v} by @var{i}. Returns the
-new value.
-
-@item INCL(@var{m},@var{s})
-Adds the element @var{m} to the set @var{s} if it is not already
-there. Returns the new set.
-
-@item MAX(@var{t})
-Returns the maximum value of the type @var{t}.
-
-@item MIN(@var{t})
-Returns the minimum value of the type @var{t}.
-
-@item ODD(@var{i})
-Returns boolean TRUE if @var{i} is an odd number.
-
-@item ORD(@var{x})
-Returns the ordinal value of its argument. For example, the ordinal
-value of a character is its ASCII value (on machines supporting the
-ASCII character set). @var{x} must be of an ordered type, which include
-integral, character and enumerated types.
-
-@item SIZE(@var{x})
-Returns the size of its argument. @var{x} can be a variable or a type.
-
-@item TRUNC(@var{r})
-Returns the integral part of @var{r}.
-
-@item VAL(@var{t},@var{i})
-Returns the member of the type @var{t} whose ordinal value is @var{i}.
-@end table
-
-@quotation
-@emph{Warning:} Sets and their operations are not yet supported, so
-_GDBN__ will treat the use of procedures @code{INCL} and @code{EXCL} as
-an error.
-@end quotation
-
-@cindex Modula-2 constants
-@node M2 Constants, M2 Defaults, Builtin Func/Proc, Modula-2
-@subsubsection Constants
-
-_GDBN__ allows you to express the constants of Modula-2 in the following
-ways:
-
-@itemize @bullet
-
-@item
-Integer constants are simply a sequence of digits. When used in an
-expression, a constant is interpreted to be type-compatible with the
-rest of the expression. Hexadecimal integers are specified by a
-trailing @samp{H}, and octal integers by a trailing @samp{B}.
-
-@item
-Floating point constants appear as a sequence of digits, followed by a
-decimal point and another sequence of digits. An optional exponent can
-then be specified, in the form @samp{E@r{[}+@r{|}-@r{]}@var{nnn}}, where
-@samp{@r{[}+@r{|}-@r{]}@var{nnn}} is the desired exponent. All of the
-digits of the floating point constant must be valid decimal (base 10)
-digits.
-
-@item
-Character constants consist of a single character enclosed by a pair of
-like quotes, either single (@code{'}) or double (@code{"}). They may
-also be expressed by their ordinal value (their ASCII value, usually)
-followed by a @samp{C}.
-
-@item
-String constants consist of a sequence of characters enclosed by a pair
-of like quotes, either single (@code{'}) or double (@code{"}). Escape
-sequences in the style of C are also allowed. @xref{C Constants}, for a
-brief explanation of escape sequences.
-
-@item
-Enumerated constants consist of an enumerated identifier.
-
-@item
-Boolean constants consist of the identifiers @code{TRUE} and
-@code{FALSE}.
-
-@item
-Pointer constants consist of integral values only.
-
-@item
-Set constants are not yet supported.
-
-@end itemize
-
-@node M2 Defaults, Deviations, M2 Constants, Modula-2
-@subsubsection Modula-2 Defaults
-@cindex Modula-2 defaults
-
-If type and range checking are set automatically by _GDBN__, they
-both default to @code{on} whenever the working language changes to
-Modula-2. This happens regardless of whether you, or _GDBN__,
-selected the working language.
-
-If you allow _GDBN__ to set the language automatically, then entering
-code compiled from a file whose name ends with @file{.mod} will set the
-working language to Modula-2. @xref{Automatically,,Having _GDBN__ set
-the language automatically}, for further details.
-
-@node Deviations, M2 Checks, M2 Defaults, Modula-2
-@subsubsection Deviations from Standard Modula-2
-@cindex Modula-2, deviations from
-
-A few changes have been made to make Modula-2 programs easier to debug.
-This is done primarily via loosening its type strictness:
-
-@itemize @bullet
-@item
-Unlike in standard Modula-2, pointer constants can be formed by
-integers. This allows you to modify pointer variables during
-debugging. (In standard Modula-2, the actual address contained in a
-pointer variable is hidden from you; it can only be modified
-through direct assignment to another pointer variable or expression that
-returned a pointer.)
-
-@item
-C escape sequences can be used in strings and characters to represent
-non-printable characters. _GDBN__ will print out strings with these
-escape sequences embedded. Single non-printable characters are
-printed using the @samp{CHR(@var{nnn})} format.
-
-@item
-The assignment operator (@code{:=}) returns the value of its right-hand
-argument.
-
-@item
-All builtin procedures both modify @emph{and} return their argument.
-
-@end itemize
-
-@node M2 Checks, M2 Scope, Deviations, Modula-2
-@subsubsection Modula-2 Type and Range Checks
-@cindex Modula-2 checks
-
-@quotation
-@emph{Warning:} in this release, _GDBN__ does not yet perform type or
-range checking.
-@end quotation
-@c FIXME remove warning when type/range checks added
-
-_GDBN__ considers two Modula-2 variables type equivalent if:
-
-@itemize @bullet
-@item
-They are of types that have been declared equivalent via a @code{TYPE
-@var{t1} = @var{t2}} statement
-
-@item
-They have been declared on the same line. (Note: This is true of the
-GNU Modula-2 compiler, but it may not be true of other compilers.)
-
-@end itemize
-
-As long as type checking is enabled, any attempt to combine variables
-whose types are not equivalent is an error.
-
-Range checking is done on all mathematical operations, assignment, array
-index bounds, and all builtin functions and procedures.
-
-@node M2 Scope, GDB/M2, M2 Checks, Modula-2
-@subsubsection The scope operators @code{::} and @code{.}
-@cindex scope
-@kindex .
-@kindex ::
-
-There are a few subtle differences between the Modula-2 scope operator
-(@code{.}) and the _GDBN__ scope operator (@code{::}). The two have
-similar syntax:
-
-@example
-
-@var{module} . @var{id}
-@var{scope} :: @var{id}
-
-@end example
-
-@noindent
-where @var{scope} is the name of a module or a procedure,
-@var{module} the name of a module, and @var{id} is any delcared
-identifier within the program, except another module.
-
-Using the @code{::} operator makes _GDBN__ search the scope
-specified by @var{scope} for the identifier @var{id}. If it is not
-found in the specified scope, then _GDBN__ will search all scopes
-enclosing the one specified by @var{scope}.
-
-Using the @code{.} operator makes _GDBN__ search the current scope for
-the identifier specified by @var{id} that was imported from the
-definition module specified by @var{module}. With this operator, it is
-an error if the identifier @var{id} was not imported from definition
-module @var{module}, or if @var{id} is not an identifier in
-@var{module}.
-
-@node GDB/M2, , M2 Scope, Modula-2
-@subsubsection _GDBN__ and Modula-2
-
-Some _GDBN__ commands have little use when debugging Modula-2 programs.
-Five subcommands of @code{set print} and @code{show print} apply
-specifically to C and C++: @samp{vtbl}, @samp{demangle},
-@samp{asm-demangle}, @samp{object}, and @samp{union}. The first four
-apply to C++, and the last to C's @code{union} type, which has no direct
-analogue in Modula-2.
-
-The @code{@@} operator (@pxref{Expressions}), while available
-while using any language, is not useful with Modula-2. Its
-intent is to aid the debugging of @dfn{dynamic arrays}, which cannot be
-created in Modula-2 as they can in C or C++. However, because an
-address can be specified by an integral constant, the construct
-@samp{@{@var{type}@}@var{adrexp}} is still useful. (@pxref{Expressions})
-
-_0__
-@cindex @code{#} in Modula-2
-In _GDBN__ scripts, the Modula-2 inequality operator @code{#} is
-interpreted as the beginning of a comment. Use @code{<>} instead.
-_1__
-
-
-@node Symbols, Altering, Languages, Top
-@chapter Examining the Symbol Table
-
-The commands described in this section allow you to inquire about the
-symbols (names of variables, functions and types) defined in your
-program. This information is inherent in the text of your program and
-does not change as the program executes. _GDBN__ finds it in your
-program's symbol table, in the file indicated when you started _GDBN__
-(@pxref{File Options}), or by one of the file-management commands
-(@pxref{Files}).
-
-@table @code
-@item info address @var{symbol}
-@kindex info address
-Describe where the data for @var{symbol} is stored. For a register
-variable, this says which register it is kept in. For a non-register
-local variable, this prints the stack-frame offset at which the variable
-is always stored.
-
-Note the contrast with @samp{print &@var{symbol}}, which does not work
-at all for a register variables, and for a stack local variable prints
-the exact address of the current instantiation of the variable.
-
-@item whatis @var{exp}
-@kindex whatis
-Print the data type of expression @var{exp}. @var{exp} is not
-actually evaluated, and any side-effecting operations (such as
-assignments or function calls) inside it do not take place.
-@xref{Expressions}.
-
-@item whatis
-Print the data type of @code{$}, the last value in the value history.
-
-@item ptype @var{typename}
-@kindex ptype
-Print a description of data type @var{typename}. @var{typename} may be
-the name of a type, or for C code it may have the form
-@samp{struct @var{struct-tag}}, @samp{union @var{union-tag}} or
-@samp{enum @var{enum-tag}}.@refill
-
-@item ptype @var{exp}
-Print a description of the type of expression @var{exp}. @code{ptype}
-differs from @code{whatis} by printing a detailed description, instead of just
-the name of the type. For example, if your program declares a variable
-as
-@example
-struct complex @{double real; double imag;@} v;
-@end example
-@noindent
-compare the output of the two commands:
-@example
-(_GDBP__) whatis v
-type = struct complex
-(_GDBP__) ptype v
-type = struct complex @{
- double real;
- double imag;
-@}
-@end example
-
-@item info types @var{regexp}
-@itemx info types
-@kindex info types
-Print a brief description of all types whose name matches @var{regexp}
-(or all types in your program, if you supply no argument). Each
-complete typename is matched as though it were a complete line; thus,
-@samp{i type value} gives information on all types in your program whose
-name includes the string @code{value}, but @samp{i type ^value$} gives
-information only on types whose complete name is @code{value}.
-
-This command differs from @code{ptype} in two ways: first, like
-@code{whatis}, it does not print a detailed description; second, it
-lists all source files where a type is defined.
-
-@item info source
-@kindex info source
-Show the name of the current source file---that is, the source file for
-the function containing the current point of execution---and the language
-it was written in.
-
-@item info sources
-@kindex info sources
-Print the names of all source files in the program for which there is
-debugging information, organized into two lists: files whose symbols
-have already been read, and files whose symbols will be read when needed.
-
-@item info functions
-@kindex info functions
-Print the names and data types of all defined functions.
-
-@item info functions @var{regexp}
-Print the names and data types of all defined functions
-whose names contain a match for regular expression @var{regexp}.
-Thus, @samp{info fun step} finds all functions whose names
-include @code{step}; @samp{info fun ^step} finds those whose names
-start with @code{step}.
-
-@item info variables
-@kindex info variables
-Print the names and data types of all variables that are declared
-outside of functions (i.e., excluding local variables).
-
-@item info variables @var{regexp}
-Print the names and data types of all variables (except for local
-variables) whose names contain a match for regular expression
-@var{regexp}.
-
-
-@ignore
-This was never implemented.
-@item info methods
-@itemx info methods @var{regexp}
-@kindex info methods
-The @code{info methods} command permits the user to examine all defined
-methods within C++ program, or (with the @var{regexp} argument) a
-specific set of methods found in the various C++ classes. Many
-C++ classes provide a large number of methods. Thus, the output
-from the @code{ptype} command can be overwhelming and hard to use. The
-@code{info-methods} command filters the methods, printing only those
-which match the regular-expression @var{regexp}.
-@end ignore
-
-@item printsyms @var{filename}
-@kindex printsyms
-Write a dump of debugging symbol data into the file
-@var{filename}. Only symbols with debugging data are included. _GDBN__
-includes all the symbols it already knows about: that is, @var{filename}
-reflects symbols for only those files whose symbols _GDBN__ has read.
-You can find out which files these are using the command @code{info
-files}. The description of @code{symbol-file} describes how _GDBN__
-reads symbols; both commands are described under @ref{Files}.
-@end table
-
-@node Altering, _GDBN__ Files, Symbols, Top
-@chapter Altering Execution
-
-Once you think you have found an error in the program, you might want to
-find out for certain whether correcting the apparent error would lead to
-correct results in the rest of the run. You can find the answer by
-experiment, using the _GDBN__ features for altering execution of the
-program.
-
-For example, you can store new values into variables or memory
-locations, give the program a signal, restart it at a different address,
-or even return prematurely from a function to its caller.
-
-@menu
-* Assignment:: Assignment to Variables
-* Jumping:: Continuing at a Different Address
-* Signaling:: Giving the Program a Signal
-* Returning:: Returning from a Function
-* Calling:: Calling your Program's Functions
-* Patching:: Patching your Program
-@end menu
-
-@node Assignment, Jumping, Altering, Altering
-@section Assignment to Variables
-
-@cindex assignment
-@cindex setting variables
-To alter the value of a variable, evaluate an assignment expression.
-@xref{Expressions}. For example,
-
-@example
-print x=4
-@end example
-
-@noindent
-would store the value 4 into the variable @code{x}, and then print the
-value of the assignment expression (which is 4). @xref{Languages}, for
-more information on operators in supported languages.
-
-@kindex set variable
-@cindex variables, setting
-If you are not interested in seeing the value of the assignment, use the
-@code{set} command instead of the @code{print} command. @code{set} is
-really the same as @code{print} except that the expression's value is not
-printed and is not put in the value history (@pxref{Value History}). The
-expression is evaluated only for its effects.
-
-If the beginning of the argument string of the @code{set} command
-appears identical to a @code{set} subcommand, use the @code{set
-variable} command instead of just @code{set}. This command is identical
-to @code{set} except for its lack of subcommands. For example, a
-program might well have a variable @code{width}---which leads to
-an error if we try to set a new value with just @samp{set width=13}, as
-we might if @code{set width} didn't happen to be a _GDBN__ command:
-@example
-(_GDBP__) whatis width
-type = double
-(_GDBP__) p width
-$4 = 13
-(_GDBP__) set width=47
-Invalid syntax in expression.
-@end example
-@noindent
-The invalid expression, of course, is @samp{=47}. What we can do in
-order to actually set our program's variable @code{width} is
-@example
-(_GDBP__) set var width=47
-@end example
-
-_GDBN__ allows more implicit conversions in assignments than C does; you can
-freely store an integer value into a pointer variable or vice versa, and
-any structure can be converted to any other structure that is the same
-length or shorter.
-@comment FIXME: how do structs align/pad in these conversions?
-@comment /pesch@cygnus.com 18dec1990
-
-To store values into arbitrary places in memory, use the @samp{@{@dots{}@}}
-construct to generate a value of specified type at a specified address
-(@pxref{Expressions}). For example, @code{@{int@}0x83040} refers
-to memory location @code{0x83040} as an integer (which implies a certain size
-and representation in memory), and
-
-@example
-set @{int@}0x83040 = 4
-@end example
-
-@noindent
-stores the value 4 into that memory location.
-
-@node Jumping, Signaling, Assignment, Altering
-@section Continuing at a Different Address
-
-Ordinarily, when you continue the program, you do so at the place where
-it stopped, with the @code{continue} command. You can instead continue at
-an address of your own choosing, with the following commands:
-
-@table @code
-@item jump @var{linespec}
-@kindex jump
-Resume execution at line @var{linespec}. Execution will stop
-immediately if there is a breakpoint there. @xref{List} for a
-description of the different forms of @var{linespec}.
-
-The @code{jump} command does not change the current stack frame, or
-the stack pointer, or the contents of any memory location or any
-register other than the program counter. If line @var{linespec} is in
-a different function from the one currently executing, the results may
-be bizarre if the two functions expect different patterns of arguments or
-of local variables. For this reason, the @code{jump} command requests
-confirmation if the specified line is not in the function currently
-executing. However, even bizarre results are predictable if you are
-well acquainted with the machine-language code of the program.
-
-@item jump *@var{address}
-Resume execution at the instruction at address @var{address}.
-@end table
-
-You can get much the same effect as the @code{jump} command by storing a
-new value into the register @code{$pc}. The difference is that this
-does not start the program running; it only changes the address where it
-@emph{will} run when it is continued. For example,
-
-@example
-set $pc = 0x485
-@end example
-
-@noindent
-causes the next @code{continue} command or stepping command to execute at
-address 0x485, rather than at the address where the program stopped.
-@xref{Continuing and Stepping}.
-
-The most common occasion to use the @code{jump} command is to back up,
-perhaps with more breakpoints set, over a portion of a program that has
-already executed, in order to examine its execution in more detail.
-
-@node Signaling, Returning, Jumping, Altering
-@c @group
-@section Giving the Program a Signal
-
-@table @code
-@item signal @var{signalnum}
-@kindex signal
-Resume execution where the program stopped, but give it immediately the
-signal number @var{signalnum}.
-
-Alternatively, if @var{signalnum} is zero, continue execution without
-giving a signal. This is useful when the program stopped on account of
-a signal and would ordinary see the signal when resumed with the
-@code{continue} command; @samp{signal 0} causes it to resume without a
-signal.
-
-@code{signal} does not repeat when you press @key{RET} a second time
-after executing the command.
-@end table
-@c @end group
-
-@node Returning, Calling, Signaling, Altering
-@section Returning from a Function
-
-@table @code
-@item return
-@itemx return @var{expression}
-@cindex returning from a function
-@kindex return
-You can cancel execution of a function call with the @code{return}
-command. If you give an
-@var{expression} argument, its value is used as the function's return
-value.
-@end table
-
-When you use @code{return}, _GDBN__ discards the selected stack frame
-(and all frames within it). You can think of this as making the
-discarded frame return prematurely. If you wish to specify a value to
-be returned, give that value as the argument to @code{return}.
-
-This pops the selected stack frame (@pxref{Selection}), and any other
-frames inside of it, leaving its caller as the innermost remaining
-frame. That frame becomes selected. The specified value is stored in
-the registers used for returning values of functions.
-
-The @code{return} command does not resume execution; it leaves the
-program stopped in the state that would exist if the function had just
-returned. In contrast, the @code{finish} command
-(@pxref{Continuing and Stepping})
-resumes execution until the selected stack frame returns naturally.@refill
-
-@node Calling, Patching, Returning, Altering
-@section Calling your Program's Functions
-
-@cindex calling functions
-@kindex call
-@table @code
-@item call @var{expr}
-Evaluate the expression @var{expr} without displaying @code{void}
-returned values.
-@end table
-
-You can use this variant of the @code{print} command if you want to
-execute a function from your program, but without cluttering the output
-with @code{void} returned values. The result is printed and saved in
-the value history, if it is not void.
-
-@node Patching, , Calling, Altering
-@section Patching your Program
-@cindex patching binaries
-@cindex writing into executables
-@cindex writing into corefiles
-By default, _GDBN__ opens the file containing your program's executable
-code (or the corefile) read-only. This prevents accidental alterations
-to machine code; but it also prevents you from intentionally patching
-your program's binary.
-
-If you'd like to be able to patch the binary, you can specify that
-explicitly with the @code{set write} command. For example, you might
-want to turn on internal debugging flags, or even to make emergency
-repairs.
-
-@table @code
-@item set write on
-@itemx set write off
-@kindex set write
-If you specify @samp{set write on}, _GDBN__ will open executable and
-core files for both reading and writing; if you specify @samp{set write
-off} (the default), _GDBN__ will open them read-only.
-
-If you've already loaded a file, you must load it
-again (using the @code{exec-file} or @code{core-file} command) after
-changing @code{set write}, for your new setting to take effect.
-
-@item show write
-@kindex show write
-Display whether executable files and core files will be opened for
-writing as well as reading.
-
-@end table
-
-@node _GDBN__ Files, Targets, Altering, Top
-@chapter _GDBN__'s Files
-
-@menu
-* Files:: Commands to Specify Files
-* Symbol Errors:: Errors Reading Symbol Files
-@end menu
-
-@node Files, Symbol Errors, _GDBN__ Files, _GDBN__ Files
-@section Commands to Specify Files
-@cindex core dump file
-@cindex symbol table
-_GDBN__ needs to know the file name of the program to be debugged, both in
-order to read its symbol table and in order to start the program. To
-debug a core dump of a previous run, _GDBN__ must be told the file name of
-the core dump.
-
-The usual way to specify the executable and core dump file names is with
-the command arguments given when you start _GDBN__, as discussed in
-@pxref{Invocation}.
-
-Occasionally it is necessary to change to a different file during a
-_GDBN__ session. Or you may run _GDBN__ and forget to specify the files you
-want to use. In these situations the _GDBN__ commands to specify new files
-are useful.
-
-@table @code
-@item file @var{filename}
-@cindex executable file
-@kindex file
-Use @var{filename} as the program to be debugged. It is read for its
-symbols and for the contents of pure memory. It is also the program
-executed when you use the @code{run} command. If you do not specify a
-directory and the file is not found in _GDBN__'s working directory,
-
-_GDBN__ uses the environment variable @code{PATH} as a list of
-directories to search, just as the shell does when looking for a program
-to run. You can change the value of this variable, for both _GDBN__ and
-your program, using the @code{path} command.
-
-@code{file} with no argument makes _GDBN__ discard any information it
-has on both executable file and the symbol table.
-
-@item exec-file @var{filename}
-@kindex exec-file
-Specify that the program to be run (but not the symbol table) is found
-in @var{filename}. _GDBN__ will search the environment variable @code{PATH}
-if necessary to locate the program.
-
-@item symbol-file @var{filename}
-@kindex symbol-file
-Read symbol table information from file @var{filename}. @code{PATH} is
-searched when necessary. Use the @code{file} command to get both symbol
-table and program to run from the same file.
-
-@code{symbol-file} with no argument clears out _GDBN__'s information on your
-program's symbol table.
-
-The @code{symbol-file} command causes _GDBN__ to forget the contents of its
-convenience variables, the value history, and all breakpoints and
-auto-display expressions. This is because they may contain pointers to
-the internal data recording symbols and data types, which are part of
-the old symbol table data being discarded inside _GDBN__.
-
-@code{symbol-file} will not repeat if you press @key{RET} again after
-executing it once.
-
-On some kinds of object files, the @code{symbol-file} command does not
-actually read the symbol table in full right away. Instead, it scans
-the symbol table quickly to find which source files and which symbols
-are present. The details are read later, one source file at a time,
-when they are needed.
-
-The purpose of this two-stage reading strategy is to make _GDBN__ start up
-faster. For the most part, it is invisible except for occasional pauses
-while the symbol table details for a particular source file are being
-read. (The @code{set verbose} command can turn these pauses into
-messages if desired. @xref{Messages/Warnings}).
-
-When the symbol table is stored in COFF format, @code{symbol-file} does
-read the symbol table data in full right away. We haven't implemented
-the two-stage strategy for COFF yet.
-
-When _GDBN__ is configured for a particular environment, it will
-understand debugging information in whatever format is the standard
-generated for that environment; you may use either a GNU compiler, or
-other compilers that adhere to the local conventions. Best results are
-usually obtained from GNU compilers; for example, using @code{_GCC__}
-you can generate debugging information for optimized code.
-
-@item core-file @var{filename}
-@itemx core @var{filename}
-@kindex core
-@kindex core-file
-Specify the whereabouts of a core dump file to be used as the ``contents
-of memory''. Traditionally, core files contain only some parts of the
-address space of the process that generated them; _GDBN__ can access the
-executable file itself for other parts.
-
-@code{core-file} with no argument specifies that no core file is
-to be used.
-
-Note that the core file is ignored when your program is actually running
-under _GDBN__. So, if you have been running the program and you wish to
-debug a core file instead, you must kill the subprocess in which the
-program is running. To do this, use the @code{kill} command
-(@pxref{Kill Process}).
-
-@item load @var{filename}
-@kindex load
-_if__(_GENERIC__)
-Depending on what remote debugging facilities are configured into
-_GDBN__, the @code{load} command may be available. Where it exists, it
-is meant to make @var{filename} (an executable) available for debugging
-on the remote system---by downloading, or dynamic linking, for example.
-@code{load} also records @var{filename}'s symbol table in _GDBN__, like
-the @code{add-symbol-file} command.
-
-If @code{load} is not available on your _GDBN__, attempting to execute
-it gets the error message ``@code{You can't do that when your target is
-@dots{}}''
-_fi__(_GENERIC__)
-
-_if__(_VXWORKS__)
-On VxWorks, @code{load} will dynamically link @var{filename} on the
-current target system as well as adding its symbols in _GDBN__.
-_fi__(_VXWORKS__)
-
-_if__(_I960__)
-@cindex download to Nindy-960
-With the Nindy interface to an Intel 960 board, @code{load} will
-download @var{filename} to the 960 as well as adding its symbols in
-_GDBN__.
-_fi__(_I960__)
-
-@code{load} will not repeat if you press @key{RET} again after using it.
-
-@item add-symbol-file @var{filename} @var{address}
-@kindex add-symbol-file
-@cindex dynamic linking
-The @code{add-symbol-file} command reads additional symbol table information
-from the file @var{filename}. You would use this command when @var{filename}
-has been dynamically loaded (by some other means) into the program that
-is running. @var{address} should be the memory address at which the
-file has been loaded; _GDBN__ cannot figure this out for itself.
-
-The symbol table of the file @var{filename} is added to the symbol table
-originally read with the @code{symbol-file} command. You can use the
-@code{add-symbol-file} command any number of times; the new symbol data thus
-read keeps adding to the old. To discard all old symbol data instead,
-use the @code{symbol-file} command.
-
-@code{add-symbol-file} will not repeat if you press @key{RET} after using it.
-
-@item info files
-@itemx info target
-@kindex info files
-@kindex info target
-@code{info files} and @code{info target} are synonymous; both print the
-current targets (@pxref{Targets}), including the names of the executable
-and core dump files currently in use by _GDBN__, and the files from
-which symbols were loaded. The command @code{help targets} lists all
-possible targets rather than current ones.
-
-@end table
-
-All file-specifying commands allow both absolute and relative file names
-as arguments. _GDBN__ always converts the file name to an absolute path
-name and remembers it that way.
-
-@cindex shared libraries
-
-_GDBN__ supports the SunOS shared library format. _GDBN__ automatically
-loads symbol definitions from shared libraries when you use the
-@code{run} command, or when you examine a core file. (Before you issue
-the @code{run} command, _GDBN__ won't understand references to a
-function in a shared library, however---unless you're debugging a core
-file).
-@c FIXME: next _GDBN__ release should permit some refs to undef
-@c FIXME...symbols---eg in a break cmd---assuming they're from a shared lib
-
-@table @code
-@item info share
-@itemx info sharedlibrary
-@kindex info sharedlibrary
-@kindex info share
-Print the names of the shared libraries which are currently loaded.
-
-@item sharedlibrary @var{regex}
-@itemx share @var{regex}
-@kindex sharedlibrary
-@kindex share
-This is an obsolescent command; you can use it to explicitly
-load shared object library symbols for files matching a UNIX regular
-expression, but as with files loaded automatically, it will only load
-shared libraries required by your program for a core file or after
-typing @code{run}. If @var{regex} is omitted all shared libraries
-required by your program are loaded.
-@end table
-
-@node Symbol Errors, , Files, _GDBN__ Files
-@section Errors Reading Symbol Files
-While reading a symbol file, _GDBN__ will occasionally encounter
-problems, such as symbol types it does not recognize, or known bugs in
-compiler output. By default, _GDBN__ does not notify you of such
-problems, since they're relatively common and primarily of interest to
-people debugging compilers. If you are interested in seeing information
-about ill-constructed symbol tables, you can either ask _GDBN__ to print
-only one message about each such type of problem, no matter how many
-times the problem occurs; or you can ask _GDBN__ to print more messages,
-to see how many times the problems occur, with the @code{set complaints}
-command (@xref{Messages/Warnings}).
-
-The messages currently printed, and their meanings, are:
-
-@table @code
-@item inner block not inside outer block in @var{symbol}
-
-The symbol information shows where symbol scopes begin and end
-(such as at the start of a function or a block of statements). This
-error indicates that an inner scope block is not fully contained
-in its outer scope blocks.
-
-_GDBN__ circumvents the problem by treating the inner block as if it had
-the same scope as the outer block. In the error message, @var{symbol}
-may be shown as ``@code{(don't know)}'' if the outer block is not a
-function.
-
-@item block at @var{address} out of order
-
-The symbol information for symbol scope blocks should occur in
-order of increasing addresses. This error indicates that it does not
-do so.
-
-_GDBN__ does not circumvent this problem, and will have trouble locating
-symbols in the source file whose symbols being read. (You can often
-determine what source file is affected by specifying @code{set verbose
-on}. @xref{Messages/Warnings}.)
-
-@item bad block start address patched
-
-The symbol information for a symbol scope block has a start address
-smaller than the address of the preceding source line. This is known
-to occur in the SunOS 4.1.1 (and earlier) C compiler.
-
-_GDBN__ circumvents the problem by treating the symbol scope block as
-starting on the previous source line.
-
-@item bad string table offset in symbol @var{n}
-
-@cindex foo
-Symbol number @var{n} contains a pointer into the string table which is
-larger than the size of the string table.
-
-_GDBN__ circumvents the problem by considering the symbol to have the
-name @code{foo}, which may cause other problems if many symbols end up
-with this name.
-
-@item unknown symbol type @code{0x@var{nn}}
-
-The symbol information contains new data types that _GDBN__ does not yet
-know how to read. @code{0x@var{nn}} is the symbol type of the misunderstood
-information, in hexadecimal.
-
-_GDBN__ circumvents the error by ignoring this symbol information. This
-will usually allow the program to be debugged, though certain symbols
-will not be accessible. If you encounter such a problem and feel like
-debugging it, you can debug @code{_GDBP__} with itself, breakpoint on
-@code{complain}, then go up to the function @code{read_dbx_symtab} and
-examine @code{*bufp} to see the symbol.
-
-@item stub type has NULL name
-_GDBN__ could not find the full definition for a struct or class.
-
-@ignore
-@c this is #if 0'd in dbxread.c as of (at least!) 17 may 1991
-@item const/volatile indicator missing, got '@var{X}'
-
-The symbol information for a C++ member function is missing some
-information that the compiler should have output for it.
-@end ignore
-
-@item C++ type mismatch between compiler and debugger
-
-_GDBN__ could not parse a type specification output by the compiler
-for some C++ object.
-
-@end table
-
-@node Targets, Controlling _GDBN__, _GDBN__ Files, Top
-@chapter Specifying a Debugging Target
-@cindex debugging target
-@kindex target
-A @dfn{target} is an interface between the debugger and a particular
-kind of file or process.
-
-Often, you will be able to run _GDBN__ in the same host environment as the
-program you are debugging; in that case, the debugging target can just be
-specified as a side effect of the @code{file} or @code{core} commands.
-When you need more flexibility---for example, running _GDBN__ on a
-physically separate host, controlling standalone systems over a
-serial port, or realtime systems over a TCP/IP connection---you can use
-the @code{target} command.
-
-@menu
-* Active Targets:: Active Targets
-* Target Commands:: Commands for Managing Targets
-* Remote:: Remote Debugging
-@end menu
-
-@node Active Targets, Target Commands, Targets, Targets
-@section Active Targets
-@cindex stacking targets
-@cindex active targets
-@cindex multiple targets
-
-Targets are managed in three @dfn{strata} that correspond to different
-classes of target: processes, core files, and executable files. This
-allows you to (for example) start a process and inspect its activity
-without abandoning your work on a core file.
-
-More than one target can potentially respond to a request. In
-particular, when you access memory _GDBN__ will examine the three strata of
-targets until it finds a target that can handle that particular address.
-Strata are always examined in a fixed order: first a process if there is
-one, then a core file if there is one, and finally an executable file if
-there is one of those.
-
-When you specify a new target in a given stratum, it replaces any target
-previously in that stratum.
-
-To get rid of a target without replacing it, use the @code{detach}
-command. The related command @code{attach} provides you with a way of
-choosing a particular running process as a new target. @xref{Attach}.
-
-@node Target Commands, Remote, Active Targets, Targets
-@section Commands for Managing Targets
-
-@table @code
-@item target @var{type} @var{parameters}
-Connects the _GDBN__ host environment to a target machine or process. A
-target is typically a protocol for talking to debugging facilities. You
-use the argument @var{type} to specify the type or protocol of the
-target machine.
-
-Further @var{parameters} are interpreted by the target protocol, but
-typically include things like device names or host names to connect
-with, process numbers, and baud rates.
-
-The @code{target} command will not repeat if you press @key{RET} again
-after executing the command.
-
-@item help target
-@kindex help target
-Displays the names of all targets available. To display targets
-currently selected, use either @code{info target} or @code{info files}
-(@pxref{Files}).
-
-@item help target @var{name}
-Describe a particular target, including any parameters necessary to
-select it.
-@end table
-
-Here are some common targets (available, or not, depending on the _GDBN__
-configuration):
-
-@table @code
-@item target exec @var{prog}
-@kindex target exec
-An executable file. @samp{target exec @var{prog}} is the same as
-@samp{exec-file @var{prog}}.
-
-@item target core @var{filename}
-@kindex target core
-A core dump file. @samp{target core @var{filename}} is the same as
-@samp{core-file @var{filename}}.
-
-@item target remote @var{dev}
-@kindex target remote
-Remote serial target in _GDBN__-specific protocol. The argument @var{dev}
-specifies what serial device to use for the connection (e.g.
-@file{/dev/ttya}). @xref{Remote}.
-
-_if__(_AMD29K__)
-@item target amd-eb @var{dev} @var{speed} @var{PROG}
-@kindex target amd-eb
-@cindex AMD EB29K
-Remote PC-resident AMD EB29K board, attached over serial lines.
-@var{dev} is the serial device, as for @code{target remote};
-@var{speed} allows you to specify the linespeed; and @var{PROG} is the
-name of the program to be debugged, as it appears to DOS on the PC.
-@xref{EB29K Remote}.
-
-_fi__(_AMD29K__)
-_if__(_I960__)
-@item target nindy @var{devicename}
-@kindex target nindy
-An Intel 960 board controlled by a Nindy Monitor. @var{devicename} is
-the name of the serial device to use for the connection, e.g.
-@file{/dev/ttya}. @xref{i960-Nindy Remote}.
-
-_fi__(_I960__)
-_if__(_VXWORKS__)
-@item target vxworks @var{machinename}
-@kindex target vxworks
-A VxWorks system, attached via TCP/IP. The argument @var{machinename}
-is the target system's machine name or IP address.
-@xref{VxWorks Remote}.
-_fi__(_VXWORKS__)
-@end table
-
-_if__(_GENERIC__)
-Different targets are available on different configurations of _GDBN__; your
-configuration may have more or fewer targets.
-_fi__(_GENERIC__)
-
-@node Remote, , Target Commands, Targets
-@section Remote Debugging
-@cindex remote debugging
-
-_if__(_GENERIC__)
-@menu
-_include__(gdbinv-m.m4)<>_dnl__
-@end menu
-_fi__(_GENERIC__)
-
-If you are trying to debug a program running on a machine that can't run
-_GDBN__ in the usual way, it is often useful to use remote debugging. For
-example, you might use remote debugging on an operating system kernel, or on
-a small system which does not have a general purpose operating system
-powerful enough to run a full-featured debugger.
-
-Some configurations of _GDBN__ have special serial or TCP/IP interfaces
-to make this work with particular debugging targets. In addition,
-_GDBN__ comes with a generic serial protocol (specific to _GDBN__, but
-not specific to any particular target system) which you can use if you
-write the remote stubs---the code that will run on the remote system to
-communicate with _GDBN__.
-
-To use the _GDBN__ remote serial protocol, the program to be debugged on
-the remote machine needs to contain a debugging stub which talks to
-_GDBN__ over the serial line. Several working remote stubs are
-distributed with _GDBN__; see the @file{README} file in the _GDBN__
-distribution for more information.
-
-For details of this communication protocol, see the comments in the
-_GDBN__ source file @file{remote.c}.
-
-To start remote debugging, first run _GDBN__ and specify as an executable file
-the program that is running in the remote machine. This tells _GDBN__ how
-to find the program's symbols and the contents of its pure text. Then
-establish communication using the @code{target remote} command with a device
-name as an argument. For example:
-
-@example
-target remote /dev/ttyb
-@end example
-
-@noindent
-if the serial line is connected to the device named @file{/dev/ttyb}. This
-will stop the remote machine if it is not already stopped.
-
-Now you can use all the usual commands to examine and change data and to
-step and continue the remote program.
-
-To resume the remote program and stop debugging it, use the @code{detach}
-command.
-
-Other remote targets may be available in your
-configuration of _GDBN__; use @code{help targets} to list them.
-
-_if__(_GENERIC__)
-@c Text on starting up GDB in various specific cases; it goes up front
-@c in manuals configured for any of those particular situations, here
-@c otherwise.
-_include__(gdbinv-s.m4)
-_fi__(_GENERIC__)
-
-@node Controlling _GDBN__, Sequences, Targets, Top
-@chapter Controlling _GDBN__
-
-You can alter many aspects of _GDBN__'s interaction with you by using
-the @code{set} command. For commands controlling how _GDBN__ displays
-data, @pxref{Print Settings}; other settings are described here.
-
-@menu
-* Prompt:: Prompt
-* Editing:: Command Editing
-* History:: Command History
-* Screen Size:: Screen Size
-* Numbers:: Numbers
-* Messages/Warnings:: Optional Warnings and Messages
-@end menu
-
-@node Prompt, Editing, Controlling _GDBN__, Controlling _GDBN__
-@section Prompt
-@cindex prompt
-_GDBN__ indicates its readiness to read a command by printing a string
-called the @dfn{prompt}. This string is normally @samp{(_GDBP__)}. You
-can change the prompt string with the @code{set prompt} command. For
-instance, when debugging _GDBN__ with _GDBN__, it is useful to change
-the prompt in one of the _GDBN__<>s so that you can always tell which
-one you are talking to.
-
-@table @code
-@item set prompt @var{newprompt}
-@kindex set prompt
-Directs _GDBN__ to use @var{newprompt} as its prompt string henceforth.
-@kindex show prompt
-@item show prompt
-Prints a line of the form: @samp{Gdb's prompt is: @var{your-prompt}}
-@end table
-
-@node Editing, History, Prompt, Controlling _GDBN__
-@section Command Editing
-@cindex readline
-@cindex command line editing
-_GDBN__ reads its input commands via the @dfn{readline} interface. This
-GNU library provides consistent behavior for programs which provide a
-command line interface to the user. Advantages are @code{emacs}-style
-or @code{vi}-style inline editing of commands, @code{csh}-like history
-substitution, and a storage and recall of command history across
-debugging sessions.
-
-You may control the behavior of command line editing in _GDBN__ with the
-command @code{set}.
-
-@table @code
-@kindex set editing
-@cindex editing
-@item set editing
-@itemx set editing on
-Enable command line editing (enabled by default).
-
-@item set editing off
-Disable command line editing.
-
-@kindex show editing
-@item show editing
-Show whether command line editing is enabled.
-@end table
-
-@node History, Screen Size, Editing, Controlling _GDBN__
-@section Command History
-@table @code
-@cindex history substitution
-@cindex history file
-@kindex set history filename
-@item set history filename @var{fname}
-Set the name of the _GDBN__ command history file to @var{fname}. This is
-the file from which _GDBN__ will read an initial command history
-list or to which it will write this list when it exits. This list is
-accessed through history expansion or through the history
-command editing characters listed below. This file defaults to the
-value of the environment variable @code{GDBHISTFILE}, or to
-@file{./.gdb_history} if this variable is not set.
-
-@cindex history save
-@kindex set history save
-@item set history save
-@itemx set history save on
-Record command history in a file, whose name may be specified with the
-@code{set history filename} command. By default, this option is disabled.
-
-@item set history save off
-Stop recording command history in a file.
-
-@cindex history size
-@kindex set history size
-@item set history size @var{size}
-Set the number of commands which _GDBN__ will keep in its history list.
-This defaults to the value of the environment variable
-@code{HISTSIZE}, or to 256 if this variable is not set.
-@end table
-
-@cindex history expansion
-History expansion assigns special meaning to the character @kbd{!}.
-@iftex
-(@xref{Event Designators}.)
-@end iftex
-Since @kbd{!} is also the logical not operator in C, history expansion
-is off by default. If you decide to enable history expansion with the
-@code{set history expansion on} command, you may sometimes need to
-follow @kbd{!} (when it is used as logical not, in an expression) with
-a space or a tab to prevent it from being expanded. The readline
-history facilities will not attempt substitution on the strings
-@kbd{!=} and @kbd{!(}, even when history expansion is enabled.
-
-The commands to control history expansion are:
-
-@table @code
-
-@kindex set history expansion
-@item set history expansion on
-@itemx set history expansion
-Enable history expansion. History expansion is off by default.
-
-@item set history expansion off
-Disable history expansion.
-
-The readline code comes with more complete documentation of
-editing and history expansion features. Users unfamiliar with @code{emacs}
-or @code{vi} may wish to read it.
-@iftex
-@xref{Command Line Editing}.
-@end iftex
-
-@c @group
-@kindex show history
-@item show history
-@itemx show history filename
-@itemx show history save
-@itemx show history size
-@itemx show history expansion
-These commands display the state of the _GDBN__ history parameters.
-@code{show history} by itself displays all four states.
-@c @end group
-
-@end table
-
-@table @code
-@kindex show commands
-@item show commands
-Display the last ten commands in the command history.
-
-@item show commands @var{n}
-Print ten commands centered on command number @var{n}.
-
-@item show commands +
-Print ten commands just after the commands last printed.
-
-@end table
-
-@node Screen Size, Numbers, History, Controlling _GDBN__
-@section Screen Size
-@cindex size of screen
-@cindex pauses in output
-Certain commands to _GDBN__ may produce large amounts of information
-output to the screen. To help you read all of it, _GDBN__ pauses and
-asks you for input at the end of each page of output. Type @key{RET}
-when you want to continue the output. _GDBN__ also uses the screen
-width setting to determine when to wrap lines of output. Depending on
-what is being printed, it tries to break the line at a readable place,
-rather than simply letting it overflow onto the following line.
-
-Normally _GDBN__ knows the size of the screen from the termcap data base
-together with the value of the @code{TERM} environment variable and the
-@code{stty rows} and @code{stty cols} settings. If this is not correct,
-you can override it with the @code{set height} and @code{set
-width} commands:
-
-@table @code
-@item set height @var{lpp}
-@itemx show height
-@itemx set width @var{cpl}
-@itemx show width
-@kindex set height
-@kindex set width
-@kindex show width
-@kindex show height
-These @code{set} commands specify a screen height of @var{lpp} lines and
-a screen width of @var{cpl} characters. The associated @code{show}
-commands display the current settings.
-
-If you specify a height of zero lines, _GDBN__ will not pause during output
-no matter how long the output is. This is useful if output is to a file
-or to an editor buffer.
-@end table
-
-@node Numbers, Messages/Warnings, Screen Size, Controlling _GDBN__
-@section Numbers
-@cindex number representation
-@cindex entering numbers
-You can always enter numbers in octal, decimal, or hexadecimal in _GDBN__ by
-the usual conventions: octal numbers begin with @samp{0}, decimal
-numbers end with @samp{.}, and hexadecimal numbers begin with @samp{0x}.
-Numbers that begin with none of these are, by default, entered in base
-10; likewise, the default display for numbers---when no particular
-format is specified---is base 10. You can change the default base for
-both input and output with the @code{set radix} command.
-
-@table @code
-@kindex set radix
-@item set radix @var{base}
-Set the default base for numeric input and display. Supported choices
-for @var{base} are decimal 2, 8, 10, 16. @var{base} must itself be
-specified either unambiguously or using the current default radix; for
-example, any of
-
-@example
-set radix 1010
-set radix 012
-set radix 10.
-set radix 0xa
-@end example
-
-@noindent
-will set the base to decimal. On the other hand, @samp{set radix 10}
-will leave the radix unchanged no matter what it was.
-
-@kindex show radix
-@item show radix
-Display the current default base for numeric input and display.
-
-@end table
-
-@node Messages/Warnings, , Numbers, Controlling _GDBN__
-@section Optional Warnings and Messages
-By default, _GDBN__ is silent about its inner workings. If you are running
-on a slow machine, you may want to use the @code{set verbose} command.
-It will make _GDBN__ tell you when it does a lengthy internal operation, so
-you won't think it has crashed.
-
-Currently, the messages controlled by @code{set verbose} are those which
-announce that the symbol table for a source file is being read
-(@pxref{Files}, in the description of the command
-@code{symbol-file}).
-@c The following is the right way to do it, but emacs 18.55 doesn't support
-@c @ref, and neither the emacs lisp manual version of texinfmt or makeinfo
-@c is released.
-@ignore
-see @code{symbol-file} in @ref{Files}).
-@end ignore
-
-@table @code
-@kindex set verbose
-@item set verbose on
-Enables _GDBN__'s output of certain informational messages.
-
-@item set verbose off
-Disables _GDBN__'s output of certain informational messages.
-
-@kindex show verbose
-@item show verbose
-Displays whether @code{set verbose} is on or off.
-@end table
-
-By default, if _GDBN__ encounters bugs in the symbol table of an object
-file, it is silent; but if you are debugging a compiler, you may find
-this information useful (@pxref{Symbol Errors}).
-
-@table @code
-@kindex set complaints
-@item set complaints @var{limit}
-Permits _GDBN__ to output @var{limit} complaints about each type of unusual
-symbols before becoming silent about the problem. Set @var{limit} to
-zero to suppress all complaints; set it to a large number to prevent
-complaints from being suppressed.
-
-@kindex show complaints
-@item show complaints
-Displays how many symbol complaints _GDBN__ is permitted to produce.
-@end table
-
-By default, _GDBN__ is cautious, and asks what sometimes seem to be a
-lot of stupid questions to confirm certain commands. For example, if
-you try to run a program which is already running:
-@example
-(_GDBP__) run
-The program being debugged has been started already.
-Start it from the beginning? (y or n)
-@end example
-
-If you're willing to unflinchingly face the consequences of your own
-commands, you can disable this ``feature'':
-
-@table @code
-@kindex set confirm
-@cindex flinching
-@cindex confirmation
-@cindex stupid questions
-@item set confirm off
-Disables confirmation requests.
-
-@item set confirm on
-Enables confirmation requests (the default).
-
-@item show confirm
-@kindex show confirm
-Displays state of confirmation requests.
-@end table
-
-@c FIXME this doesn't really belong here. But where *does* it belong?
-@cindex reloading symbols
-Some systems allow individual object files that make up your program to
-be replaced without stopping and restarting your program.
-_if__(_VXWORKS__)
-For example, in VxWorks you can simply recompile a defective object file
-and keep on running.
-_fi__(_VXWORKS__)
-If you're running on one of these systems, you can allow _GDBN__ to
-reload the symbols for automatically relinked modules:@refill
-@table @code
-@kindex set symbol-reloading
-@item set symbol-reloading on
-Replace symbol definitions for the corresponding source file when an
-object file with a particular name is seen again.
-
-@item set symbol-reloading off
-Don't replace symbol definitions when re-encountering object files of
-the same name. This is the default state; if you're not running on a
-system that permits automatically relinking modules, you should leave
-@code{symbol-reloading} off, since otherwise _GDBN__ may discard symbols
-when linking large programs, that may contain several modules (from
-different directories or libraries) with the same name.
-
-@item show symbol-reloading
-Show the current @code{on} or @code{off} setting.
-@end table
-
-@node Sequences, Emacs, Controlling _GDBN__, Top
-@chapter Canned Sequences of Commands
-
-Aside from breakpoint commands (@pxref{Break Commands}), _GDBN__ provides two
-ways to store sequences of commands for execution as a unit:
-user-defined commands and command files.
-
-@menu
-* Define:: User-Defined Commands
-* Command Files:: Command Files
-* Output:: Commands for Controlled Output
-@end menu
-
-@node Define, Command Files, Sequences, Sequences
-@section User-Defined Commands
-
-@cindex user-defined command
-A @dfn{user-defined command} is a sequence of _GDBN__ commands to which you
-assign a new name as a command. This is done with the @code{define}
-command.
-
-@table @code
-@item define @var{commandname}
-@kindex define
-Define a command named @var{commandname}. If there is already a command
-by that name, you are asked to confirm that you want to redefine it.
-
-The definition of the command is made up of other _GDBN__ command lines,
-which are given following the @code{define} command. The end of these
-commands is marked by a line containing @code{end}.
-
-@item document @var{commandname}
-@kindex document
-Give documentation to the user-defined command @var{commandname}. The
-command @var{commandname} must already be defined. This command reads
-lines of documentation just as @code{define} reads the lines of the
-command definition, ending with @code{end}. After the @code{document}
-command is finished, @code{help} on command @var{commandname} will print
-the documentation you have specified.
-
-You may use the @code{document} command again to change the
-documentation of a command. Redefining the command with @code{define}
-does not change the documentation.
-
-@item help user-defined
-@kindex help user-defined
-List all user-defined commands, with the first line of the documentation
-(if any) for each.
-
-@item info user
-@itemx info user @var{commandname}
-@kindex info user
-Display the _GDBN__ commands used to define @var{commandname} (but not its
-documentation). If no @var{commandname} is given, display the
-definitions for all user-defined commands.
-@end table
-
-User-defined commands do not take arguments. When they are executed, the
-commands of the definition are not printed. An error in any command
-stops execution of the user-defined command.
-
-Commands that would ask for confirmation if used interactively proceed
-without asking when used inside a user-defined command. Many _GDBN__ commands
-that normally print messages to say what they are doing omit the messages
-when used in a user-defined command.
-
-@node Command Files, Output, Define, Sequences
-@section Command Files
-
-@cindex command files
-A command file for _GDBN__ is a file of lines that are _GDBN__ commands. Comments
-(lines starting with @kbd{#}) may also be included. An empty line in a
-command file does nothing; it does not mean to repeat the last command, as
-it would from the terminal.
-
-@cindex init file
-@cindex @file{_GDBINIT__}
-When you start _GDBN__, it automatically executes commands from its
-@dfn{init files}. These are files named @file{_GDBINIT__}. _GDBN__
-reads the init file (if any) in your home directory and then the init
-file (if any) in the current working directory. (The init files are not
-executed if you use the @samp{-nx} option; @pxref{Mode Options}.) You
-can also request the execution of a command file with the @code{source}
-command:
-
-@table @code
-@item source @var{filename}
-@kindex source
-Execute the command file @var{filename}.
-@end table
-
-The lines in a command file are executed sequentially. They are not
-printed as they are executed. An error in any command terminates execution
-of the command file.
-
-Commands that would ask for confirmation if used interactively proceed
-without asking when used in a command file. Many _GDBN__ commands that
-normally print messages to say what they are doing omit the messages
-when called from command files.
-
-@node Output, , Command Files, Sequences
-@section Commands for Controlled Output
-
-During the execution of a command file or a user-defined command, normal
-_GDBN__ output is suppressed; the only output that appears is what is
-explicitly printed by the commands in the definition. This section
-describes three commands useful for generating exactly the output you
-want.
-
-@table @code
-@item echo @var{text}
-@kindex echo
-@c I don't consider backslash-space a standard C escape sequence
-@c because it's not in ANSI.
-Print @var{text}. Nonprinting characters can be included in @var{text}
-using C escape sequences, such as @samp{\n} to print a newline. @b{No
-newline will be printed unless you specify one.} In addition to the
-standard C escape sequences, a backslash followed by a space stands for a
-space. This is useful for outputting a string with spaces at the
-beginning or the end, since leading and trailing spaces are otherwise
-trimmed from all arguments. Thus, to print @samp{@ and foo =@ }, use the
-command @samp{echo \@ and foo = \@ }.
-@c FIXME: verify hard copy actually issues enspaces for '@ '! Will this
-@c confuse texinfo?
-
-A backslash at the end of @var{text} can be used, as in C, to continue
-the command onto subsequent lines. For example,
-
-@example
-echo This is some text\n\
-which is continued\n\
-onto several lines.\n
-@end example
-
-produces the same output as
-
-@example
-echo This is some text\n
-echo which is continued\n
-echo onto several lines.\n
-@end example
-
-@item output @var{expression}
-@kindex output
-Print the value of @var{expression} and nothing but that value: no
-newlines, no @samp{$@var{nn} = }. The value is not entered in the
-value history either. @xref{Expressions} for more information on
-expressions.
-
-@item output/@var{fmt} @var{expression}
-Print the value of @var{expression} in format @var{fmt}. You can use
-the same formats as for @code{print}; @pxref{Output formats}, for more
-information.
-
-@item printf @var{string}, @var{expressions}@dots{}
-@kindex printf
-Print the values of the @var{expressions} under the control of
-@var{string}. The @var{expressions} are separated by commas and may
-be either numbers or pointers. Their values are printed as specified
-by @var{string}, exactly as if the program were to execute
-
-@example
-printf (@var{string}, @var{expressions}@dots{});
-@end example
-
-For example, you can print two values in hex like this:
-
-@example
-printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo
-@end example
-
-The only backslash-escape sequences that you can use in the format
-string are the simple ones that consist of backslash followed by a
-letter.
-@end table
-
-@node Emacs, _GDBN__ Bugs, Sequences, Top
-@chapter Using _GDBN__ under GNU Emacs
-
-@cindex emacs
-A special interface allows you to use GNU Emacs to view (and
-edit) the source files for the program you are debugging with
-_GDBN__.
-
-To use this interface, use the command @kbd{M-x gdb} in Emacs. Give the
-executable file you want to debug as an argument. This command starts
-_GDBN__ as a subprocess of Emacs, with input and output through a newly
-created Emacs buffer.
-
-Using _GDBN__ under Emacs is just like using _GDBN__ normally except for two
-things:
-
-@itemize @bullet
-@item
-All ``terminal'' input and output goes through the Emacs buffer.
-@end itemize
-
-This applies both to _GDBN__ commands and their output, and to the input
-and output done by the program you are debugging.
-
-This is useful because it means that you can copy the text of previous
-commands and input them again; you can even use parts of the output
-in this way.
-
-All the facilities of Emacs' Shell mode are available for interacting
-with your program. In particular, you can send signals the usual
-way---for example, @kbd{C-c C-c} for an interrupt, @kbd{C-c C-z} for a
-stop.
-
-@itemize @bullet
-@item
-_GDBN__ displays source code through Emacs.
-@end itemize
-
-Each time _GDBN__ displays a stack frame, Emacs automatically finds the
-source file for that frame and puts an arrow (_0__@samp{=>}_1__) at the
-left margin of the current line. Emacs uses a separate buffer for
-source display, and splits the window to show both your _GDBN__ session
-and the source.
-
-Explicit _GDBN__ @code{list} or search commands still produce output as
-usual, but you probably will have no reason to use them.
-
-@quotation
-@emph{Warning:} If the directory where your program resides is not your
-current directory, it can be easy to confuse Emacs about the location of
-the source files, in which case the auxiliary display buffer will not
-appear to show your source. _GDBN__ can find programs by searching your
-environment's @code{PATH} variable, so the _GDBN__ input and output
-session will proceed normally; but Emacs doesn't get enough information
-back from _GDBN__ to locate the source files in this situation. To
-avoid this problem, either start _GDBN__ mode from the directory where
-your program resides, or specify a full path name when prompted for the
-@kbd{M-x gdb} argument.
-
-A similar confusion can result if you use the _GDBN__ @code{file} command to
-switch to debugging a program in some other location, from an existing
-_GDBN__ buffer in Emacs.
-@end quotation
-
-By default, @kbd{M-x gdb} calls the program called @file{gdb}. If
-you need to call _GDBN__ by a different name (for example, if you keep
-several configurations around, with different names) you can set the
-Emacs variable @code{gdb-command-name}; for example,
-@example
-(setq gdb-command-name "mygdb")
-@end example
-@noindent
-(preceded by @kbd{ESC ESC}, or typed in the @code{*scratch*} buffer, or
-in your @file{.emacs} file) will make Emacs call the program named
-``@code{mygdb}'' instead.
-
-In the _GDBN__ I/O buffer, you can use these special Emacs commands in
-addition to the standard Shell mode commands:
-
-@table @kbd
-@item C-h m
-Describe the features of Emacs' _GDBN__ Mode.
-
-@item M-s
-Execute to another source line, like the _GDBN__ @code{step} command; also
-update the display window to show the current file and location.
-
-@item M-n
-Execute to next source line in this function, skipping all function
-calls, like the _GDBN__ @code{next} command. Then update the display window
-to show the current file and location.
-
-@item M-i
-Execute one instruction, like the _GDBN__ @code{stepi} command; update
-display window accordingly.
-
-@item M-x gdb-nexti
-Execute to next instruction, using the _GDBN__ @code{nexti} command; update
-display window accordingly.
-
-@item C-c C-f
-Execute until exit from the selected stack frame, like the _GDBN__
-@code{finish} command.
-
-@item M-c
-Continue execution of the program, like the _GDBN__ @code{continue}
-command. @emph{Warning:} In Emacs v19, this command is @kbd{C-c C-p}.
-
-@item M-u
-Go up the number of frames indicated by the numeric argument
-(@pxref{Arguments, , Numeric Arguments, emacs, The GNU Emacs Manual}),
-like the _GDBN__ @code{up} command. @emph{Warning:} In Emacs v19, this
-command is @kbd{C-c C-u}.@refill
-
-@item M-d
-Go down the number of frames indicated by the numeric argument, like the
-_GDBN__ @code{down} command. @emph{Warning:} In Emacs v19, this command
-is @kbd{C-c C-d}.
-
-@item C-x &
-Read the number where the cursor is positioned, and insert it at the end
-of the _GDBN__ I/O buffer. For example, if you wish to disassemble code
-around an address that was displayed earlier, type @kbd{disassemble};
-then move the cursor to the address display, and pick up the
-argument for @code{disassemble} by typing @kbd{C-x &}.
-
-You can customize this further on the fly by defining elements of the list
-@code{gdb-print-command}; once it is defined, you can format or
-otherwise process numbers picked up by @kbd{C-x &} before they are
-inserted. A numeric argument to @kbd{C-x &} will both indicate that you
-wish special formatting, and act as an index to pick an element of the
-list. If the list element is a string, the number to be inserted is
-formatted using the Emacs function @code{format}; otherwise the number
-is passed as an argument to the corresponding list element.
-
-@end table
-
-In any source file, the Emacs command @kbd{C-x SPC} (@code{gdb-break})
-tells _GDBN__ to set a breakpoint on the source line point is on.
-
-If you accidentally delete the source-display buffer, an easy way to get
-it back is to type the command @code{f} in the _GDBN__ buffer, to
-request a frame display; when you run under Emacs, this will recreate
-the source buffer if necessary to show you the context of the current
-frame.
-
-The source files displayed in Emacs are in ordinary Emacs buffers
-which are visiting the source files in the usual way. You can edit
-the files with these buffers if you wish; but keep in mind that _GDBN__
-communicates with Emacs in terms of line numbers. If you add or
-delete lines from the text, the line numbers that _GDBN__ knows will cease
-to correspond properly to the code.
-
-@c The following dropped because Epoch is nonstandard. Reactivate
-@c if/when v19 does something similar. ---pesch@cygnus.com 19dec1990
-@ignore
-@kindex emacs epoch environment
-@kindex epoch
-@kindex inspect
-
-Version 18 of Emacs has a built-in window system called the @code{epoch}
-environment. Users of this environment can use a new command,
-@code{inspect} which performs identically to @code{print} except that
-each value is printed in its own window.
-@end ignore
-
-@node _GDBN__ Bugs, Renamed Commands, Emacs, Top
-@chapter Reporting Bugs in _GDBN__
-@cindex Bugs in _GDBN__
-@cindex Reporting Bugs in _GDBN__
-
-Your bug reports play an essential role in making _GDBN__ reliable.
-
-Reporting a bug may help you by bringing a solution to your problem, or it
-may not. But in any case the principal function of a bug report is to help
-the entire community by making the next version of _GDBN__ work better. Bug
-reports are your contribution to the maintenance of _GDBN__.
-
-In order for a bug report to serve its purpose, you must include the
-information that enables us to fix the bug.
-
-@menu
-* Bug Criteria:: Have You Found a Bug?
-* Bug Reporting:: How to Report Bugs
-@end menu
-
-@node Bug Criteria, Bug Reporting, _GDBN__ Bugs, _GDBN__ Bugs
-@section Have You Found a Bug?
-@cindex Bug Criteria
-
-If you are not sure whether you have found a bug, here are some guidelines:
-
-@itemize @bullet
-@item
-@cindex Fatal Signal
-@cindex Core Dump
-If the debugger gets a fatal signal, for any input whatever, that is a
-_GDBN__ bug. Reliable debuggers never crash.
-
-@item
-@cindex error on Valid Input
-If _GDBN__ produces an error message for valid input, that is a bug.
-
-@item
-@cindex Invalid Input
-If _GDBN__ does not produce an error message for invalid input,
-that is a bug. However, you should note that your idea of
-``invalid input'' might be our idea of ``an extension'' or ``support
-for traditional practice''.
-
-@item
-If you are an experienced user of debugging tools, your suggestions
-for improvement of _GDBN__ are welcome in any case.
-@end itemize
-
-@node Bug Reporting, , Bug Criteria, _GDBN__ Bugs
-@section How to Report Bugs
-@cindex Bug Reports
-@cindex _GDBN__ Bugs, Reporting
-
-A number of companies and individuals offer support for GNU products.
-If you obtained _GDBN__ from a support organization, we recommend you
-contact that organization first.
-
-Contact information for many support companies and individuals is
-available in the file @file{etc/SERVICE} in the GNU Emacs distribution.
-
-In any event, we also recommend that you send bug reports for _GDBN__ to one
-of these addresses:
-
-@example
-bug-gdb@@prep.ai.mit.edu
-@{ucbvax|mit-eddie|uunet@}!prep.ai.mit.edu!bug-gdb
-@end example
-
-@strong{Do not send bug reports to @samp{info-gdb}, or to
-@samp{help-gdb}, or to any newsgroups.} Most users of _GDBN__ do not want to
-receive bug reports. Those that do, have arranged to receive @samp{bug-gdb}.
-
-The mailing list @samp{bug-gdb} has a newsgroup @samp{gnu.gdb.bug} which
-serves as a repeater. The mailing list and the newsgroup carry exactly
-the same messages. Often people think of posting bug reports to the
-newsgroup instead of mailing them. This appears to work, but it has one
-problem which can be crucial: a newsgroup posting often lacks a mail
-path back to the sender. Thus, if we need to ask for more information,
-we may be unable to reach you. For this reason, it is better to send
-bug reports to the mailing list.
-
-As a last resort, send bug reports on paper to:
-
-@example
-GNU Debugger Bugs
-Free Software Foundation
-545 Tech Square
-Cambridge, MA 02139
-@end example
-
-The fundamental principle of reporting bugs usefully is this:
-@strong{report all the facts}. If you are not sure whether to state a
-fact or leave it out, state it!
-
-Often people omit facts because they think they know what causes the
-problem and assume that some details don't matter. Thus, you might
-assume that the name of the variable you use in an example does not matter.
-Well, probably it doesn't, but one cannot be sure. Perhaps the bug is a
-stray memory reference which happens to fetch from the location where that
-name is stored in memory; perhaps, if the name were different, the contents
-of that location would fool the debugger into doing the right thing despite
-the bug. Play it safe and give a specific, complete example. That is the
-easiest thing for you to do, and the most helpful.
-
-Keep in mind that the purpose of a bug report is to enable us to fix
-the bug if it is new to us. It isn't as important what happens if
-the bug is already known. Therefore, always write your bug reports on
-the assumption that the bug has not been reported previously.
-
-Sometimes people give a few sketchy facts and ask, ``Does this ring a
-bell?'' Those bug reports are useless, and we urge everyone to
-@emph{refuse to respond to them} except to chide the sender to report
-bugs properly.
-
-To enable us to fix the bug, you should include all these things:
-
-@itemize @bullet
-@item
-The version of _GDBN__. _GDBN__ announces it if you start with no
-arguments; you can also print it at any time using @code{show version}.
-
-Without this, we won't know whether there is any point in looking for
-the bug in the current version of _GDBN__.
-
-@item
-A complete input script, and all necessary source files, that will
-reproduce the bug.
-
-@item
-What compiler (and its version) was used to compile _GDBN__---e.g.
-``_GCC__-1.37.1''.
-
-@item
-The command arguments you gave the compiler to compile your example and
-observe the bug. For example, did you use @samp{-O}? To guarantee
-you won't omit something important, list them all.
-
-If we were to try to guess the arguments, we would probably guess wrong
-and then we might not encounter the bug.
-
-@item
-The type of machine you are using, and the operating system name and
-version number.
-
-@item
-A description of what behavior you observe that you believe is
-incorrect. For example, ``It gets a fatal signal.''
-
-Of course, if the bug is that _GDBN__ gets a fatal signal, then we will
-certainly notice it. But if the bug is incorrect output, we might not
-notice unless it is glaringly wrong. We are human, after all. You
-might as well not give us a chance to make a mistake.
-
-Even if the problem you experience is a fatal signal, you should still
-say so explicitly. Suppose something strange is going on, such as,
-your copy of _GDBN__ is out of synch, or you have encountered a
-bug in the C library on your system. (This has happened!) Your copy
-might crash and ours would not. If you told us to expect a crash,
-then when ours fails to crash, we would know that the bug was not
-happening for us. If you had not told us to expect a crash, then we
-would not be able to draw any conclusion from our observations.
-
-@item
-If you wish to suggest changes to the _GDBN__ source, send us context
-diffs. If you even discuss something in the _GDBN__ source, refer to
-it by context, not by line number.
-
-The line numbers in our development sources won't match those in your
-sources. Your line numbers would convey no useful information to us.
-
-@end itemize
-
-Here are some things that are not necessary:
-
-@itemize @bullet
-@item
-A description of the envelope of the bug.
-
-Often people who encounter a bug spend a lot of time investigating
-which changes to the input file will make the bug go away and which
-changes will not affect it.
-
-This is often time consuming and not very useful, because the way we
-will find the bug is by running a single example under the debugger
-with breakpoints, not by pure deduction from a series of examples.
-We recommend that you save your time for something else.
-
-Of course, if you can find a simpler example to report @emph{instead}
-of the original one, that is a convenience for us. Errors in the
-output will be easier to spot, running under the debugger will take
-less time, etc.
-
-However, simplification is not vital; if you don't want to do this,
-report the bug anyway and send us the entire test case you used.
-
-@item
-A patch for the bug.
-
-A patch for the bug does help us if it is a good one. But don't omit
-the necessary information, such as the test case, on the assumption that
-a patch is all we need. We might see problems with your patch and decide
-to fix the problem another way, or we might not understand it at all.
-
-Sometimes with a program as complicated as _GDBN__ it is very hard to
-construct an example that will make the program follow a certain path
-through the code. If you don't send us the example, we won't be able
-to construct one, so we won't be able to verify that the bug is fixed.
-
-And if we can't understand what bug you are trying to fix, or why your
-patch should be an improvement, we won't install it. A test case will
-help us to understand.
-
-@item
-A guess about what the bug is or what it depends on.
-
-Such guesses are usually wrong. Even we can't guess right about such
-things without first using the debugger to find the facts.
-@end itemize
-
-@iftex
-@include rdl-apps.texi
-@end iftex
-
-@node Renamed Commands, Installing _GDBN__, _GDBN__ Bugs, Top
-@appendix Renamed Commands
-
-The following commands were renamed in _GDBN__ 4.0, in order to make the
-command set as a whole more consistent and easier to use and remember:
-
-@kindex add-syms
-@kindex delete environment
-@kindex info copying
-@kindex info convenience
-@kindex info directories
-@kindex info editing
-@kindex info history
-@kindex info targets
-@kindex info values
-@kindex info version
-@kindex info warranty
-@kindex set addressprint
-@kindex set arrayprint
-@kindex set prettyprint
-@kindex set screen-height
-@kindex set screen-width
-@kindex set unionprint
-@kindex set vtblprint
-@kindex set demangle
-@kindex set asm-demangle
-@kindex set sevenbit-strings
-@kindex set array-max
-@kindex set caution
-@kindex set history write
-@kindex show addressprint
-@kindex show arrayprint
-@kindex show prettyprint
-@kindex show screen-height
-@kindex show screen-width
-@kindex show unionprint
-@kindex show vtblprint
-@kindex show demangle
-@kindex show asm-demangle
-@kindex show sevenbit-strings
-@kindex show array-max
-@kindex show caution
-@kindex show history write
-@kindex unset
-
-@ifinfo
-@example
-OLD COMMAND NEW COMMAND
---------------- -------------------------------
-add-syms add-symbol-file
-delete environment unset environment
-info convenience show convenience
-info copying show copying
-info directories show directories
-info editing show commands
-info history show values
-info targets help target
-info values show values
-info version show version
-info warranty show warranty
-set/show addressprint set/show print address
-set/show array-max set/show print elements
-set/show arrayprint set/show print array
-set/show asm-demangle set/show print asm-demangle
-set/show caution set/show confirm
-set/show demangle set/show print demangle
-set/show history write set/show history save
-set/show prettyprint set/show print pretty
-set/show screen-height set/show height
-set/show screen-width set/show width
-set/show sevenbit-strings set/show print sevenbit-strings
-set/show unionprint set/show print union
-set/show vtblprint set/show print vtbl
-
-unset [No longer an alias for delete]
-@end example
-@end ifinfo
-
-@tex
-\vskip \parskip\vskip \baselineskip
-\halign{\tt #\hfil &\qquad#&\tt #\hfil\cr
-{\bf Old Command} &&{\bf New Command}\cr
-add-syms &&add-symbol-file\cr
-delete environment &&unset environment\cr
-info convenience &&show convenience\cr
-info copying &&show copying\cr
-info directories &&show directories \cr
-info editing &&show commands\cr
-info history &&show values\cr
-info targets &&help target\cr
-info values &&show values\cr
-info version &&show version\cr
-info warranty &&show warranty\cr
-set{\rm / }show addressprint &&set{\rm / }show print address\cr
-set{\rm / }show array-max &&set{\rm / }show print elements\cr
-set{\rm / }show arrayprint &&set{\rm / }show print array\cr
-set{\rm / }show asm-demangle &&set{\rm / }show print asm-demangle\cr
-set{\rm / }show caution &&set{\rm / }show confirm\cr
-set{\rm / }show demangle &&set{\rm / }show print demangle\cr
-set{\rm / }show history write &&set{\rm / }show history save\cr
-set{\rm / }show prettyprint &&set{\rm / }show print pretty\cr
-set{\rm / }show screen-height &&set{\rm / }show height\cr
-set{\rm / }show screen-width &&set{\rm / }show width\cr
-set{\rm / }show sevenbit-strings &&set{\rm / }show print sevenbit-strings\cr
-set{\rm / }show unionprint &&set{\rm / }show print union\cr
-set{\rm / }show vtblprint &&set{\rm / }show print vtbl\cr
-\cr
-unset &&\rm(No longer an alias for delete)\cr
-}
-@end tex
-
-@node Installing _GDBN__, Copying, Renamed Commands, Top
-@appendix Installing _GDBN__
-@cindex configuring _GDBN__
-@cindex installation
-
-_GDBN__ comes with a @code{configure} script that automates the process
-of preparing _GDBN__ for installation; you can then use @code{make} to
-build the @code{_GDBP__} program.
-
-The _GDBP__ distribution includes all the source code you need for
-_GDBP__ in a single directory @file{gdb-_GDB_VN__}. That directory in turn
-contains:
-
-@table @code
-@item gdb-_GDB_VN__/configure
-Overall script for configuring _GDBN__ and all its supporting libraries.
-
-@item gdb-_GDB_VN__/gdb
-the source specific to _GDBN__ itself
-
-@item gdb-_GDB_VN__/bfd
-source for the Binary File Descriptor Library
-
-@item gdb-_GDB_VN__/include
-GNU include files
-
-@item gdb-_GDB_VN__/libiberty
-source for the @samp{-liberty} free software library
-
-@item gdb-_GDB_VN__/readline
-source for the GNU command-line interface
-@end table
-@noindent
-Each of these directories has its own @code{configure} script, which are
-used by the overall @code{configure} script in @file{gdb-_GDB_VN__}.
-
-It is most convenient to run @code{configure} from the @file{gdb-_GDB_VN__}
-directory. The simplest way to configure and build _GDBN__ is the
-following:
-@example
-cd gdb-_GDB_VN__
-./configure @var{host}
-make
-@end example
-@noindent
-where @var{host} is something like @samp{sun4} or @samp{decstation}, that
-identifies the platform where _GDBN__ will run. This builds the three
-libraries @file{bfd}, @file{readline}, and @file{libiberty}, then
-@code{gdb} itself. The configured source files, and the binaries, are
-left in the corresponding source directories.
-
-You can install @code{_GDBP__} anywhere; it has no hardwired paths. However,
-you should make sure that the shell on your path (named by the
-@samp{SHELL} environment variable) is publicly readable; some systems
-refuse to let _GDBN__ debug child processes whose programs are not
-readable, and _GDBN__ uses the shell to start your program.
-
-@menu
-* Subdirectories:: Configuration subdirectories
-* Config Names:: Specifying names for hosts and targets
-* configure Options:: Summary of options for configure
-* Formatting Documentation:: How to format and print _GDBN__ documentation
-@end menu
-
-
-@node Subdirectories, Config Names, Installing _GDBN__, Installing _GDBN__
-@section Configuration Subdirectories
-If you want to run _GDBN__ versions for several host or target machines,
-you'll need a different _GDBP__ compiled for each combination of host
-and target. @code{configure} is designed to make this easy by allowing
-you to generate each configuration in a separate subdirectory. If your
-@code{make} program handles the @samp{VPATH} feature (GNU @code{make}
-does), running @code{make} in each of these directories then builds the
-_GDBP__ program specified there.
-
-@code{configure} creates these subdirectories for you when you
-simultaneously specify several configurations; but it's a good habit
-even for a single configuration. You can specify the use of
-subdirectories using the @samp{+subdirs} option (abbreviated
-@samp{+sub}). For example, you can build _GDBN__ on a Sun 4 as follows:
-
-@example
-@group
-cd gdb-_GDB_VN__
-./configure +sub sun4
-cd Host-sparc-sun-sunos4/Target-sparc-sun-sunos4
-make
-@end group
-@end example
-
-When @code{configure} uses subdirectories to build programs or
-libraries, it creates nested directories
-@file{Host-@var{host}/Target-@var{target}}. (As you see in the example,
-the names used for @var{host} and @var{target} may be expanded from your
-@code{configure} argument; @pxref{Config Names}). @code{configure} uses
-these two directory levels because _GDBN__ can be configured for
-cross-compiling: _GDBN__ can run on one machine (the host) while
-debugging programs that run on another machine (the target). You
-specify cross-debugging targets by giving the
-@samp{+target=@var{target}} option to @code{configure}. Specifying only
-hosts still gives you two levels of subdirectory for each host, with the
-same configuration suffix on both; that is, if you give any number of
-hosts but no targets, _GDBN__ will be configured for native debugging on
-each host. On the other hand, whenever you specify both hosts and
-targets on the same command line, @code{configure} creates all
-combinations of the hosts and targets you list.@refill
-
-When you run @code{make} to build a program or library, you must run it
-in a configured directory. If you made a single configuration,
-without subdirectories, run @code{make} in the source directory.
-If you have @file{Host-@var{host}/Target-@var{target}} subdirectories,
-run @code{make} in those subdirectories.
-
-Each @code{configure} and @code{Makefile} under each source directory
-runs recursively, so that typing @code{make} in @file{gdb-_GDB_VN__} (or in a
-@file{gdb-_GDB_VN__/Host-@var{host}/Target-@var{target}} subdirectory)
-builds all the required libraries, then _GDBN__.@refill
-
-If you run @code{configure} from a directory (such as @file{gdb-_GDB_VN__}) that
-contains source directories for multiple libraries or programs,
-@code{configure} creates the @file{Host-@var{host}/Target-@var{target}}
-subdirectories in each library or program's source directory. For
-example, typing:
-@example
-cd gdb-_GDB_VN__
-configure sun4 +target=vxworks960
-@end example
-@noindent
-creates the following directories:
-@smallexample
-gdb-_GDB_VN__/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-gdb-_GDB_VN__/bfd/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-gdb-_GDB_VN__/gdb/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-gdb-_GDB_VN__/libiberty/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-gdb-_GDB_VN__/readline/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-@end smallexample
-@noindent
-The @code{Makefile} in
-@smallexample
-gdb-_GDB_VN__/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-@end smallexample
-@noindent
-will @code{cd} to the appropriate lower-level directories, for example:
-@smallexample
-gdb-_GDB_VN__/bfd/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
-@end smallexample
-@noindent
-building each in turn.
-
-When you have multiple hosts or targets configured, you can run
-@code{make} on them in parallel (for example, if they are NFS-mounted on
-each of the hosts); they will not interfere with each other.
-
-
-@iftex
-@c FIXME isn't there something kinder, gentler than @page?
-@page
-@end iftex
-@node Config Names, configure Options, Subdirectories, Installing _GDBN__
-@section Specifying Names for Hosts and Targets
-
-The specifications used for hosts and targets in the @code{configure}
-script are based on a three-part naming scheme, but some short predefined
-aliases are also supported. The full naming scheme encodes three pieces
-of information in the following pattern:
-@example
-@var{architecture}-@var{vendor}-@var{os}
-@end example
-
-For example, you can use the alias @code{sun4} as a @var{host} argument
-or in a @code{+target=@var{target}} option, but the full name of that
-configuration specifies that the architecture is @samp{sparc}, the
-vendor is @samp{sun}, and the operating system is @samp{sunos4}.
-
-@iftex
-@c I know this is ugly, but @group is useless except in examples now...
-@c (using texinfo 2.52 or so)
-@page
-@end iftex
-
-The following table shows all the architectures, hosts, and OS prefixes
-that @code{configure} recognizes in _GDBN__ _GDB_VN__. Entries in the ``OS
-prefix'' column ending in a @samp{*} may be followed by a release number.
-
-@ifinfo
-@example
-
-ARCHITECTURE VENDOR OS prefix
-------------+-------------+-------------
- | |
- 580 | altos | aix*
- a29k | amdahl | amigados
- alliant | aout | aout
- arm | apollo | bout
- c1 | att | bsd*
- c2 | bull | coff
- cray2 | bcs | ctix*
- h8300 | bout | dynix*
- i386 | cbm | esix*
- i860 | coff | hpux*
- i960 | convergent | irix*
- m68000 | convex | isc*
- m68k | cray | kern
- m88k | dec | mach*
- mips | encore | newsos*
- ns32k | gould | nindy*
- pyramid | hp | none
- romp | ibm | osf*
- rs6000 | intel | sco*
- rtpc | isi | sunos*
- sparc | little | svr4
- tahoe | mips | sym*
- tron | motorola | sysv*
- vax | ncr | ultrix*
- xmp | next | unicos
- ymp | none | unos*
- | nyu | uts
- | sco | v88r*
- | sequent | vms*
- | sgi | vxworks*
- | sony |
- | sun |
- | unicom |
- | utek |
- | wrs |
-
-@end example
-@quotation
-@emph{Warning:} Many combinations of architecture, vendor, and OS are
-untested.
-@end quotation
-@end ifinfo
-@c FIXME: this table is probably screwed in @smallbook. Try setting
-@c FIXME...smallbook fonts?
-@tex
-%\vskip\parskip
-\vskip \baselineskip
-\halign{\hskip\parindent\tt #\hfil &\qquad#&\tt #\hfil &\qquad#&\tt
-#\hfil &\qquad\qquad\it #\hfil\cr
-{\bf Architecture} &&{\bf Vendor} &&{\bf OS prefix}\cr
-\multispan5\hrulefill\cr
- 580 && altos && aix* \cr
- a29k && amdahl && amigados\cr
- alliant && aout && aout \cr
- arm && apollo && bout \cr
- c1 && att && bsd* \cr
- c2 && bull && coff \cr
- cray2 && bcs && ctix* \cr
- h8300 && bout && dynix* \cr
- i386 && cbm && esix* \cr
- i860 && coff && hpux* &Warning: \cr
- i960 && convergent && irix* &Many combinations \cr
- m68000 && convex && isc* &of architecture, vendor \cr
- m68k && cray && kern &and OS are untested. \cr
- m88k && dec && mach* \cr
- mips && encore && newsos* \cr
- ns32k && gould && nindy* \cr
- pyramid && hp && none \cr
- romp && ibm && osf* \cr
- rs6000 && intel && sco* \cr
- rtpc && isi && sunos* \cr
- sparc && little && svr4 \cr
- tahoe && mips && sym* \cr
- tron && motorola && sysv* \cr
- vax && ncr && ultrix* \cr
- xmp && next && unicos \cr
- ymp && none && unos* \cr
- && nyu && uts \cr
- && sco && v88r* \cr
- && sequent && vms* \cr
- && sgi && vxworks*\cr
- && sony &&\cr
- && sun &&\cr
- && unicom &&\cr
- && utek &&\cr
- && wrs &&\cr
-}
-@end tex
-
-The @code{configure} script accompanying _GDBN__ _GDB_VN__ does not provide
-any query facility to list all supported host and target names or
-aliases. @code{configure} calls the Bourne shell script
-@code{config.sub} to map abbreviations to full names; you can read the
-script, if you wish, or you can use it to test your guesses on
-abbreviations---for example:
-@example
-% sh config.sub sun4
-sparc-sun-sunos4
-% sh config.sub sun3
-m68k-sun-sunos4
-% sh config.sub decstation
-mips-dec-ultrix
-% sh config.sub hp300bsd
-m68k-hp-bsd
-% sh config.sub i386v
-i386-none-sysv
-% sh config.sub i486v
-*** No vendor: configuration `i486v' not recognized
-@end example
-
-@node configure Options, Formatting Documentation, Config Names, Installing _GDBN__
-@section @code{configure} Options
-
-Here is a summary of all the @code{configure} options and arguments that
-you might use for building _GDBN__:
-
-@example
-configure @r{[}+destdir=@var{dir}@r{]} @r{[}+subdirs@r{]} @r{[}+norecur@r{]} @r{[}+rm@r{]}
- @r{[}+target=@var{target}@dots{}@r{]} @var{host}@dots{}
-@end example
-@noindent
-You may introduce options with the character @samp{-} rather than
-@samp{+} if you prefer; but you may abbreviate option names if you use
-@samp{+}.
-
-@table @code
-@item +destdir=@var{dir}
-@var{dir} is an installation directory @emph{path prefix}. After you
-configure with this option, @code{make install} will install _GDBN__ as
-@file{@var{dir}/bin/_GDBP__}, and the libraries in @file{@var{dir}/lib}.
-If you specify @samp{+destdir=/usr/local}, for example, @code{make
-install} creates @file{/usr/local/bin/gdb}.@refill
-
-@item +subdirs
-Write configuration specific files in subdirectories of the form
-@example
-Host-@var{host}/Target-@var{target}
-@end example
-@noindent
-(and configure the @code{Makefile} to write binaries there too).
-Without this option, if you specify only one configuration for _GDBN__,
-@code{configure} will use the same directory for source, configured
-files, and binaries. This option is used automatically if you specify
-more than one @var{host} or more than one @samp{+target=@var{target}}
-option on the @code{configure} command line.
-
-@item +norecur
-Configure only the directory where @code{configure} is executed; do not
-propagate configuration to subdirectories.
-
-@item +rm
-Remove the configuration that the other arguments specify.
-
-@c This doesn't work (yet if ever). FIXME.
-@c @item +parse=@var{lang} @dots{}
-@c Configure the _GDBN__ expression parser to parse the listed languages.
-@c @samp{all} configures _GDBN__ for all supported languages. To get a
-@c list of all supported languages, omit the argument. Without this
-@c option, _GDBN__ is configured to parse all supported languages.
-
-@item +target=@var{target} @dots{}
-Configure _GDBN__ for cross-debugging programs running on each specified
-@var{target}. You may specify as many @samp{+target} options as you
-wish. Without this option, _GDBN__ is configured to debug programs that
-run on the same machine (@var{host}) as _GDBN__ itself.
-
-There is no convenient way to generate a list of all available targets.
-
-@item @var{host} @dots{}
-Configure _GDBN__ to run on each specified @var{host}. You may specify as
-many host names as you wish.
-
-There is no convenient way to generate a list of all available hosts.
-@end table
-
-@noindent
-@code{configure} accepts other options, for compatibility with
-configuring other GNU tools recursively; but these are the only
-options that affect _GDBN__ or its supporting libraries.
-
-@node Formatting Documentation, , configure Options, Installing _GDBN__
-@section Formatting the Documentation
-
-@cindex _GDBN__ reference card
-@cindex reference card
-The _GDBN__ _GDB_VN__ release includes an already-formatted reference card,
-ready for printing on a PostScript printer, as @file{gdb-_GDB_VN__/gdb/refcard.ps}.
-It uses the most common PostScript fonts: the Times family, Courier, and
-Symbol. If you have a PostScript printer, you can print the reference
-card by just sending @file{refcard.ps} to the printer.
-
-The release also includes the online Info version of this manual already
-formatted: the main Info file is @file{gdb-_GDB_VN__/gdb/gdb.info}, and it
-refers to subordinate files matching @samp{gdb.info*} in the same
-directory.
-
-If you want to make these Info files yourself from the _GDBN__ manual's
-source, you need the GNU @code{makeinfo} program. Once you have it, you
-can type
-@example
-cd gdb-_GDB_VN__/gdb
-make gdb.info
-@end example
-@noindent
-to make the Info file.
-
-If you want to format and print copies of the manual, you need several
-things:
-@itemize @bullet
-@item
-@TeX{}, the public domain typesetting program written by Donald Knuth,
-must be installed on your system and available through your execution
-path.
-@item
-@file{gdb-_GDB_VN__/texinfo}: @TeX{} macros defining the GNU
-Documentation Format.
-@item
-@emph{A @sc{dvi} output program.} @TeX{} doesn't actually make marks on
-paper; it produces output files called @sc{dvi} files. If your system
-has @TeX{} installed, chances are it has a program for printing out
-these files; one popular example is @code{dvips}, which can print
-@sc{dvi} files on PostScript printers.
-@end itemize
-@noindent
-Once you have these things, you can type
-@example
-cd gdb-_GDB_VN__/gdb
-make gdb.dvi
-@end example
-@noindent
-to format the text of this manual, and print it with the usual output
-method for @TeX{} @sc{dvi} files at your site.
-
-If you want to print the reference card, but don't have a PostScript
-printer, or you want to use Computer Modern fonts instead,
-you can still print it if you have @TeX{}. Format the reference card by typing
-@example
-cd gdb-_GDB_VN__/gdb
-make refcard.dvi
-@end example
-@noindent
-
-The _GDBN__ reference card is designed to print in landscape mode on US
-``letter'' size paper; that is, on a sheet 11 inches wide by 8.5 inches
-high. You will need to specify this form of printing as an option to
-your @sc{dvi} output program.
-
-
-@node Copying, Index, Installing _GDBN__, Top
-@unnumbered GNU GENERAL PUBLIC LICENSE
-@center Version 2, June 1991
-
-@display
-Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
-675 Mass Ave, Cambridge, MA 02139, USA
-
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-@end display
-
-@unnumberedsec Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software---to make sure the software is free for all its users. This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it. (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.) You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have. You must make sure that they, too, receive or can get the
-source code. And you must show them these terms so they know their
-rights.
-
- We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
- Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software. If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary. To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
-@iftex
-@unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-@end iftex
-@ifinfo
-@center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-@end ifinfo
-
-@enumerate
-@item
-This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License. The ``Program'', below,
-refers to any such program or work, and a ``work based on the Program''
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language. (Hereinafter, translation is included without limitation in
-the term ``modification''.) Each licensee is addressed as ``you''.
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-@item
-You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-@item
-You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-@alphaenumerate
-@item
-You must cause the modified files to carry prominent notices
-stating that you changed the files and the date of any change.
-
-@item
-You must cause any work that you distribute or publish, that in
-whole or in part contains or is derived from the Program or any
-part thereof, to be licensed as a whole at no charge to all third
-parties under the terms of this License.
-
-@item
-If the modified program normally reads commands interactively
-when run, you must cause it, when started running for such
-interactive use in the most ordinary way, to print or display an
-announcement including an appropriate copyright notice and a
-notice that there is no warranty (or else, saying that you provide
-a warranty) and that users may redistribute the program under
-these conditions, and telling the user how to view a copy of this
-License. (Exception: if the Program itself is interactive but
-does not normally print such an announcement, your work based on
-the Program is not required to print an announcement.)
-@end alphaenumerate
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-@item
-You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-@alphaenumerate
-@item
-Accompany it with the complete corresponding machine-readable
-source code, which must be distributed under the terms of Sections
-1 and 2 above on a medium customarily used for software interchange; or,
-
-@item
-Accompany it with a written offer, valid for at least three
-years, to give any third party, for a charge no more than your
-cost of physically performing source distribution, a complete
-machine-readable copy of the corresponding source code, to be
-distributed under the terms of Sections 1 and 2 above on a medium
-customarily used for software interchange; or,
-
-@item
-Accompany it with the information you received as to the offer
-to distribute corresponding source code. (This alternative is
-allowed only for noncommercial distribution and only if you
-received the program in object code or executable form with such
-an offer, in accord with Subsection b above.)
-@end alphaenumerate
-
-The source code for a work means the preferred form of the work for
-making modifications to it. For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable. However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-@item
-You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License. Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-@item
-You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Program or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-@item
-Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-@item
-If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all. For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-@item
-If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-@item
-The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies a version number of this License which applies to it and ``any
-later version'', you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation. If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-@item
-If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission. For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this. Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-@iftex
-@heading NO WARRANTY
-@end iftex
-@ifinfo
-@center NO WARRANTY
-@end ifinfo
-
-@item
-BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-@item
-IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-@end enumerate
-
-@iftex
-@heading END OF TERMS AND CONDITIONS
-@end iftex
-@ifinfo
-@center END OF TERMS AND CONDITIONS
-@end ifinfo
-
-@page
-@unnumberedsec Applying These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the ``copyright'' line and a pointer to where the full notice is found.
-
-@smallexample
-@var{one line to give the program's name and a brief idea of what it does.}
-Copyright (C) 19@var{yy} @var{name of author}
-
-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.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-@end smallexample
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-@smallexample
-Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
-Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-This is free software, and you are welcome to redistribute it
-under certain conditions; type `show c' for details.
-@end smallexample
-
-The hypothetical commands @samp{show w} and @samp{show c} should show
-the appropriate parts of the General Public License. Of course, the
-commands you use may be called something other than @samp{show w} and
-@samp{show c}; they could even be mouse-clicks or menu items---whatever
-suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a ``copyright disclaimer'' for the program, if
-necessary. Here is a sample; alter the names:
-
-@example
-Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-`Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-@var{signature of Ty Coon}, 1 April 1989
-Ty Coon, President of Vice
-@end example
-
-This General Public License does not permit incorporating your program into
-proprietary programs. If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library. If this is what you want to do, use the GNU Library General
-Public License instead of this License.
-
-
-@node Index, , Copying, Top
-@unnumbered Index
-
-@printindex cp
-
-@tex
-% I think something like @colophon should be in texinfo. In the
-% meantime:
-\long\def\colophon{\hbox to0pt{}\vfill
-\centerline{The body of this manual is set in}
-\centerline{\fontname\tenrm,}
-\centerline{with headings in {\bf\fontname\tenbf}}
-\centerline{and examples in {\tt\fontname\tentt}.}
-\centerline{{\it\fontname\tenit\/} and}
-\centerline{{\sl\fontname\tensl\/}}
-\centerline{are used for emphasis.}\vfill}
-\page\colophon
-% Blame: pesch@cygnus.com, 28mar91.
-@end tex
-
-@contents
-@bye