+2006-10-15 Eli Zaretskii <eliz@gnu.org>
+
+ * gdb.texinfo (Sample Session, Invocation, Quitting GDB)
+ (Command Syntax, Signals, Backtrace, Connecting)
+ (Remote configuration, Renesas Boards, Console I/O): Fix last
+ change: use Ctrl- instead of C-, except wrt Emacs.
+ (File-I/O Examples): Put Ctrl-c in @kbd.
+ (Cygwin Native, File-I/O Overview, The Ctrl-C message)
+ (Console I/O): Use @samp with Ctrl-.
+
2006-10-14 Eli Zaretskii <eliz@gnu.org>
* gdb.texinfo (Backtrace): Fix last change.
2006-10-10 Bob Wilson <bob.wilson@acm.org>
- * gdb.texinfo (Command Syntax, Connecting, Remote configuration,
- Renesas Boards, ST2000, TUI Keys, TUI Single Key Mode, TUI Commands,
- Emacs, Console I/O): Fix @key and @kbd usage.
+ * gdb.texinfo (Command Syntax, Connecting, Remote configuration)
+ (Renesas Boards, ST2000, TUI Keys, TUI Single Key Mode)
+ (TUI Commands, Emacs, Console I/O): Fix @key and @kbd usage.
2006-09-21 Vladimir Prus <vladimir@codesourcery.com>
Daniel Jacobowitz <dan@codesourcery.com>
@b{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
@b{baz}
-@b{C-d}
+@b{Ctrl-d}
m4: End of input: 0: fatal error: EOF in string
@end smallexample
lengths. We allow @code{m4} exit by giving it an EOF as input:
@smallexample
-@b{C-d}
+@b{Ctrl-d}
Program exited normally.
@end smallexample
@item
type @samp{@value{GDBP}} to start @value{GDBN}.
@item
-type @kbd{quit} or @kbd{C-d} to exit.
+type @kbd{quit} or @kbd{Ctrl-d} to exit.
@end itemize
@menu
@item quit @r{[}@var{expression}@r{]}
@itemx q
To exit @value{GDBN}, use the @code{quit} command (abbreviated
-@code{q}), or type an end-of-file character (usually @kbd{C-d}). If you
+@code{q}), or type an end-of-file character (usually @kbd{Ctrl-d}). If you
do not supply @var{expression}, @value{GDBN} will terminate normally;
otherwise it will terminate using the result of @var{expression} as the
error code.
@end table
@cindex interrupt
-An interrupt (often @kbd{C-c}) does not exit from @value{GDBN}, but rather
+An interrupt (often @kbd{Ctrl-c}) does not exit from @value{GDBN}, but rather
terminates the action of any @value{GDBN} command that is in progress and
returns to @value{GDBN} command level. It is safe to type the interrupt
character at any time because @value{GDBN} does not allow it to take effect
Files,,Command files}).
@cindex repeating command sequences
-@kindex C-o @r{(operate-and-get-next)}
-The @kbd{C-o} binding is useful for repeating a complex sequence of
+@kindex Ctrl-o @r{(operate-and-get-next)}
+The @kbd{Ctrl-o} binding is useful for repeating a complex sequence of
commands. This command accepts the current line, like @key{RET}, and
then fetches the next line relative to the current line from the history
for editing.
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 character (often @kbd{C-c});
+signal a program gets when you type an interrupt character (often @kbd{Ctrl-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 your program has
frames in the stack.
You can stop the backtrace at any time by typing the system interrupt
-character, normally @kbd{C-c}.
+character, normally @kbd{Ctrl-c}.
@item backtrace @var{n}
@itemx bt @var{n}
@cindex interrupting remote programs
@cindex remote programs, interrupting
Whenever @value{GDBN} is waiting for the remote program, if you type the
-interrupt character (often @kbd{C-c}), @value{GDBN} attempts to stop the
+interrupt character (often @kbd{Ctrl-c}), @value{GDBN} attempts to stop the
program. This may or may not succeed, depending in part on the hardware
and the serial drivers the remote system uses. If you type the
interrupt character once again, @value{GDBN} displays this prompt:
@cindex BREAK signal instead of Ctrl-C
@anchor{set remotebreak}
If set to on, @value{GDBN} sends a @code{BREAK} signal to the remote
-when you type @kbd{C-c} to interrupt the program running
+when you type @kbd{Ctrl-c} to interrupt the program running
on the remote. If set to off, @value{GDBN} sends the @samp{Ctrl-C}
character instead. The default is off, since most remote systems
expect to see @samp{Ctrl-C} as the interrupt signal.
This boolean value controls whether the debuggee should
start a new group or stay in the same group as the debugger.
This affects the way the Windows OS handles
-Ctrl-C.
+@samp{Ctrl-C}.
@kindex show new-group
@item show new-group
Use the @sc{reset} button on the development board
@itemize @bullet
@item
-to interrupt your program (don't use @kbd{C-c} on the DOS host---it has
+to interrupt your program (don't use @kbd{Ctrl-c} on the DOS host---it has
no way to pass an interrupt signal to the development board); and
@item
the target is stopped to allow deterministic access to the target's
memory. Therefore File-I/O is not interruptible by target signals. On
the other hand, it is possible to interrupt File-I/O by a user interrupt
-(Ctrl-C) within @value{GDBN}.
+(@samp{Ctrl-C}) within @value{GDBN}.
The target's request to perform a host system call does not finish
the latest @samp{C}, @samp{c}, @samp{S} or @samp{s} action. That means,
@node The Ctrl-C message
-@subsection The Ctrl-C message
+@subsection The @samp{Ctrl-C} message
@cindex ctrl-c message, in file-i/o protocol
-If the Ctrl-C flag is set in the @value{GDBN}
-reply packet (@pxref{The F reply packet}),
+If the @samp{Ctrl-C} flag is set in the @value{GDBN}
+reply packet (@pxref{The F reply packet}),
the target should behave as if it had
gotten a break message. The meaning for the target is ``system call
interrupted by @code{SIGINT}''. Consequentially, the target should actually stop
(as with a break message) and return to @value{GDBN} with a @code{T02}
-packet.
+packet.
It's important for the target to know in which
state the system call was interrupted. There are two possible cases:
@itemize @bullet
@item
-The user types @kbd{C-c}. The behaviour is as explained above, and the
+The user types @kbd{Ctrl-c}. The behaviour is as explained above, and the
@code{read}
system call is treated as finished.
newline.
@item
-The user types @kbd{C-d}. This is treated as end of input. No trailing
-character (neither newline nor Ctrl-D) is appended to the input.
+The user types @kbd{Ctrl-d}. This is treated as end of input. No trailing
+character (neither newline nor @samp{Ctrl-D}) is appended to the input.
@end itemize
-> @code{F-1,9}
@end smallexample
-Example sequence of a read call, user presses Ctrl-C before syscall on
+Example sequence of a read call, user presses @kbd{Ctrl-c} before syscall on
host is called:
@smallexample
<- @code{T02}
@end smallexample
-Example sequence of a read call, user presses Ctrl-C after syscall on
+Example sequence of a read call, user presses @kbd{Ctrl-c} after syscall on
host is called:
@smallexample
projects / binutils-gdb.git / commitdiff