home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gdb-4.12-src.lha / GNU / src / amiga / gdb-4.12 / gdb / gdb.info-7 (.txt) < prev    next >
GNU Info File  |  1994-02-03  |  50KB  |  918 lines
  1. This is Info file ./gdb.info, produced by Makeinfo-1.52 from the input
  2. file gdb.texinfo.
  3. START-INFO-DIR-ENTRY
  4. * Gdb::                         The GNU debugger.
  5. END-INFO-DIR-ENTRY
  6.    This file documents the GNU debugger GDB.
  7.    This is Edition 4.12, January 1994, of `Debugging with GDB: the GNU
  8. Source-Level Debugger' for GDB Version 4.12.
  9.    Copyright (C) 1988, '89, '90, '91, '92, '93 Free Software
  10. Foundation, Inc.
  11.    Permission is granted to make and distribute verbatim copies of this
  12. manual provided the copyright notice and this permission notice are
  13. preserved on all copies.
  14.    Permission is granted to copy and distribute modified versions of
  15. this manual under the conditions for verbatim copying, provided also
  16. that the entire resulting derived work is distributed under the terms
  17. of a permission notice identical to this one.
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the above conditions for modified
  20. versions.
  21. File: gdb.info,  Node: Hooks,  Next: Command Files,  Prev: Define,  Up: Sequences
  22. User-defined command hooks
  23. ==========================
  24.    You may define *hooks*, which are a special kind of user-defined
  25. command.  Whenever you run the command `foo', if the user-defined
  26. command `hook-foo' exists, it is executed (with no arguments) before
  27. that command.
  28.    In addition, a pseudo-command, `stop' exists.  Defining
  29. (`hook-stop') makes the associated commands execute every time
  30. execution stops in your program: before breakpoint commands are run,
  31. displays are printed, or the stack frame is printed.
  32.    For example, to ignore `SIGALRM' signals while single-stepping, but
  33. treat them normally during normal execution, you could define:
  34.      define hook-stop
  35.      handle SIGALRM nopass
  36.      end
  37.      
  38.      define hook-run
  39.      handle SIGALRM pass
  40.      end
  41.      
  42.      define hook-continue
  43.      handle SIGLARM pass
  44.      end
  45.    You can define a hook for any single-word command in GDB, but not
  46. for command aliases; you should define a hook for the basic command
  47. name, e.g.  `backtrace' rather than `bt'.  If an error occurs during
  48. the execution of your hook, execution of GDB commands stops and GDB
  49. issues a prompt (before the command that you actually typed had a
  50. chance to run).
  51.    If you try to define a hook which does not match any known command,
  52. you get a warning from the `define' command.
  53. File: gdb.info,  Node: Command Files,  Next: Output,  Prev: Hooks,  Up: Sequences
  54. Command files
  55. =============
  56.    A command file for GDB is a file of lines that are GDB commands.
  57. Comments (lines starting with `#') may also be included.  An empty line
  58. in a command file does nothing; it does not mean to repeat the last
  59. command, as it would from the terminal.
  60.    When you start GDB, it automatically executes commands from its
  61. "init files".  These are files named `.gdbinit'.  GDB reads the init
  62. file (if any) in your home directory, then processes command line
  63. options and operands, and then reads the init file (if any) in the
  64. current working directory.  This is so the init file in your home
  65. directory can set options (such as `set complaints') which affect the
  66. processing of the command line options and operands.  The init files
  67. are not executed if you use the `-nx' option; *note Choosing modes:
  68. Mode Options..
  69.    On some configurations of GDB, the init file is known by a different
  70. name (these are typically environments where a specialized form of GDB
  71. may need to coexist with other forms, hence a different name for the
  72. specialized version's init file).  These are the environments with
  73. special init file names:
  74.    * VxWorks (Wind River Systems real-time OS): `.vxgdbinit'
  75.    * OS68K (Enea Data Systems real-time OS): `.os68gdbinit'
  76.    * ES-1800 (Ericsson Telecom AB M68000 emulator): `.esgdbinit'
  77.    You can also request the execution of a command file with the
  78. `source' command:
  79. `source FILENAME'
  80.      Execute the command file FILENAME.
  81.    The lines in a command file are executed sequentially.  They are not
  82. printed as they are executed.  An error in any command terminates
  83. execution of the command file.
  84.    Commands that would ask for confirmation if used interactively
  85. proceed without asking when used in a command file.  Many GDB commands
  86. that normally print messages to say what they are doing omit the
  87. messages when called from command files.
  88. File: gdb.info,  Node: Output,  Prev: Command Files,  Up: Sequences
  89. Commands for controlled output
  90. ==============================
  91.    During the execution of a command file or a user-defined command,
  92. normal GDB output is suppressed; the only output that appears is what is
  93. explicitly printed by the commands in the definition.  This section
  94. describes three commands useful for generating exactly the output you
  95. want.
  96. `echo TEXT'
  97.      Print TEXT.  Nonprinting characters can be included in TEXT using
  98.      C escape sequences, such as `\n' to print a newline.  *No newline
  99.      is printed unless you specify one.* In addition to the standard C
  100.      escape sequences, a backslash followed by a space stands for a
  101.      space.  This is useful for displaying a string with spaces at the
  102.      beginning or the end, since leading and trailing spaces are
  103.      otherwise trimmed from all arguments.  To print ` and foo = ', use
  104.      the command `echo \ and foo = \ '.
  105.      A backslash at the end of TEXT can be used, as in C, to continue
  106.      the command onto subsequent lines.  For example,
  107.           echo This is some text\n\
  108.           which is continued\n\
  109.           onto several lines.\n
  110.      produces the same output as
  111.           echo This is some text\n
  112.           echo which is continued\n
  113.           echo onto several lines.\n
  114. `output EXPRESSION'
  115.      Print the value of EXPRESSION and nothing but that value: no
  116.      newlines, no `$NN = '.  The value is not entered in the value
  117.      history either.  *Note Expressions: Expressions, for more
  118.      information on expressions.
  119. `output/FMT EXPRESSION'
  120.      Print the value of EXPRESSION in format FMT.  You can use the same
  121.      formats as for `print'.  *Note Output formats: Output Formats, for
  122.      more information.
  123. `printf STRING, EXPRESSIONS...'
  124.      Print the values of the EXPRESSIONS under the control of STRING.
  125.      The EXPRESSIONS are separated by commas and may be either numbers
  126.      or pointers.  Their values are printed as specified by STRING,
  127.      exactly as if your program were to execute the C subroutine
  128.           printf (STRING, EXPRESSIONS...);
  129.      For example, you can print two values in hex like this:
  130.           printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo
  131.      The only backslash-escape sequences that you can use in the format
  132.      string are the simple ones that consist of backslash followed by a
  133.      letter.
  134. File: gdb.info,  Node: Emacs,  Next: GDB Bugs,  Prev: Sequences,  Up: Top
  135. Using GDB under GNU Emacs
  136. *************************
  137.    A special interface allows you to use GNU Emacs to view (and edit)
  138. the source files for the program you are debugging with GDB.
  139.    To use this interface, use the command `M-x gdb' in Emacs.  Give the
  140. executable file you want to debug as an argument.  This command starts
  141. GDB as a subprocess of Emacs, with input and output through a newly
  142. created Emacs buffer.
  143.    Using GDB under Emacs is just like using GDB normally except for two
  144. things:
  145.    * All "terminal" input and output goes through the Emacs buffer.
  146.    This applies both to GDB commands and their output, and to the input
  147. and output done by the program you are debugging.
  148.    This is useful because it means that you can copy the text of
  149. previous commands and input them again; you can even use parts of the
  150. output in this way.
  151.    All the facilities of Emacs' Shell mode are available for interacting
  152. with your program.  In particular, you can send signals the usual
  153. way--for example, `C-c C-c' for an interrupt, `C-c C-z' for a stop.
  154.    * GDB displays source code through Emacs.
  155.    Each time GDB displays a stack frame, Emacs automatically finds the
  156. source file for that frame and puts an arrow (`=>') at the left margin
  157. of the current line.  Emacs uses a separate buffer for source display,
  158. and splits the screen to show both your GDB session and the source.
  159.    Explicit GDB `list'