/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007
+ Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008, 2009
Free Software Foundation, Inc.
Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "top.h"
#include <signal.h>
#include "exceptions.h"
#include "cli/cli-script.h" /* for reset_command_nest_depth */
+#include "main.h"
+#include "gdbthread.h"
/* For dont_repeat() */
#include "gdbcmd.h"
static void rl_callback_read_char_wrapper (gdb_client_data client_data);
static void command_line_handler (char *rl);
-static void command_line_handler_continuation (struct continuation_arg *arg);
static void change_line_handler (void);
static void change_annotation_level (void);
static void command_handler (char *command);
if (!current_interp_display_prompt_p ())
return;
- if (target_executing && sync_execution)
+ if (sync_execution && is_running (inferior_ptid))
{
/* This is to trick readline into not trying to display the
prompt. Even though we display the prompt using this
printf_unfiltered (_("error detected on stdin\n"));
delete_file_handler (input_fd);
discard_all_continuations ();
+ discard_all_intermediate_continuations ();
/* If stdin died, we may as well kill gdb. */
quit_command ((char *) 0, stdin == instream);
}
the exec operation. */
void
-async_enable_stdin (void *dummy)
+async_enable_stdin (void)
{
- /* See NOTE in async_disable_stdin() */
- /* FIXME: cagney/1999-09-27: Call this before clearing
- sync_execution. Current target_terminal_ours() implementations
- check for sync_execution before switching the terminal. */
- target_terminal_ours ();
- pop_prompt ();
- sync_execution = 0;
+ if (sync_execution)
+ {
+ /* See NOTE in async_disable_stdin() */
+ /* FIXME: cagney/1999-09-27: Call this before clearing
+ sync_execution. Current target_terminal_ours() implementations
+ check for sync_execution before switching the terminal. */
+ target_terminal_ours ();
+ pop_prompt ();
+ sync_execution = 0;
+ }
}
/* Disable reads from stdin (the console) marking the command as
void
async_disable_stdin (void)
{
- sync_execution = 1;
- push_prompt ("", "", "");
- /* FIXME: cagney/1999-09-27: At present this call is technically
- redundant since infcmd.c and infrun.c both already call
- target_terminal_inferior(). As the terminal handling (in
- sync/async mode) is refined, the duplicate calls can be
- eliminated (Here or in infcmd.c/infrun.c). */
- target_terminal_inferior ();
- /* Add the reinstate of stdin to the list of cleanups to be done
- in case the target errors out and dies. These cleanups are also
- done in case of normal successful termination of the execution
- command, by complete_execution(). */
- make_exec_error_cleanup (async_enable_stdin, NULL);
+ if (!sync_execution)
+ {
+ sync_execution = 1;
+ push_prompt ("", "", "");
+ }
}
\f
static void
command_handler (char *command)
{
- struct cleanup *old_chain;
int stdin_is_tty = ISATTY (stdin);
- struct continuation_arg *arg1;
- struct continuation_arg *arg2;
long time_at_cmd_start;
#ifdef HAVE_SBRK
long space_at_cmd_start = 0;
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
- old_chain = make_cleanup (null_cleanup, 0);
/* If readline returned a NULL command, it means that the
connection with the terminal is gone. This happens at the
execute_command (command, instream == stdin);
- /* Set things up for this function to be compete later, once the
- execution has completed, if we are doing an execution command,
- otherwise, just go ahead and finish. */
- if (target_can_async_p () && target_executing)
- {
- arg1 =
- (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
- arg2 =
- (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
- arg1->next = arg2;
- arg2->next = NULL;
- arg1->data.longint = time_at_cmd_start;
-#ifdef HAVE_SBRK
- arg2->data.longint = space_at_cmd_start;
-#endif
- add_continuation (command_line_handler_continuation, arg1);
- }
-
- /* Do any commands attached to breakpoint we stopped at. Only if we
- are always running synchronously. Or if we have just executed a
- command that doesn't start the target. */
- if (!target_can_async_p () || !target_executing)
- {
- bpstat_do_actions (&stop_bpstat);
- do_cleanups (old_chain);
-
- if (display_time)
- {
- long cmd_time = get_run_time () - time_at_cmd_start;
-
- printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
- cmd_time / 1000000, cmd_time % 1000000);
- }
-
- if (display_space)
- {
-#ifdef HAVE_SBRK
- char *lim = (char *) sbrk (0);
- long space_now = lim - lim_at_start;
- long space_diff = space_now - space_at_cmd_start;
-
- printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
- space_now,
- (space_diff >= 0 ? '+' : '-'),
- space_diff);
-#endif
- }
- }
-}
-
-/* Do any commands attached to breakpoint we stopped at. Only if we
- are always running synchronously. Or if we have just executed a
- command that doesn't start the target. */
-void
-command_line_handler_continuation (struct continuation_arg *arg)
-{
- extern int display_time;
- extern int display_space;
-
- long time_at_cmd_start = arg->data.longint;
- long space_at_cmd_start = arg->next->data.longint;
-
- bpstat_do_actions (&stop_bpstat);
- /*do_cleanups (old_chain); *//*?????FIXME????? */
+ /* Do any commands attached to breakpoint we stopped at. */
+ bpstat_do_actions ();
if (display_time)
{
printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
+
if (display_space)
{
#ifdef HAVE_SBRK
break;
xfree (result);
(*input_handler) (0);
+ return;
}
if (c == '\n')
immediate_quit is set. If we didn't, SIGINT would be really
processed only the next time through the event loop. To get to
that point, though, the command that we want to interrupt needs to
- finish first, which is unacceptable. */
- if (immediate_quit)
- async_request_quit (0);
- else
- /* If immediate quit is not set, we process SIGINT the next time
- through the loop, which is fine. */
- mark_async_signal_handler_wrapper (sigint_token);
+ finish first, which is unacceptable. If immediate quit is not set,
+ we process SIGINT the next time through the loop, which is fine. */
+ gdb_call_async_signal_handler (sigint_token, immediate_quit);
}
/* Quit GDB if SIGTERM is received.
"Could not kill the program being debugged",
RETURN_MASK_ALL);
signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
- kill (getpid (), SIGHUP);
+ raise (SIGHUP);
}
#endif
#elif HAVE_SIGSETMASK
sigsetmask (0);
#endif
- kill (getpid (), SIGTSTP);
+ raise (SIGTSTP);
signal (SIGTSTP, handle_stop_sig);
#else
signal (STOP_SIGNAL, handle_stop_sig);
that the sync setup is ALL done in gdb_init, and we would only
mess it up here. The sync stuff should really go away over
time. */
- extern int batch_silent;
-
if (!batch_silent)
gdb_stdout = stdio_fileopen (stdout);
gdb_stderr = stdio_fileopen (stderr);
projects / deliverable / binutils-gdb.git / blobdiff