/* Top level stuff for GDB, the GNU debugger.
- Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ 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 file is part of GDB.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "top.h"
#include "terminal.h" /* for job_control */
#include "event-loop.h"
#include "event-top.h"
+#include "interps.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"
/* readline include files */
-#include <readline/readline.h>
-#include <readline/history.h>
+#include "readline/readline.h"
+#include "readline/history.h"
/* readline defines this. */
#undef savestring
-extern void _initialize_event_loop (void);
-
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);
-void cli_command_loop (void);
-static void async_do_nothing (gdb_client_data arg);
-static void async_disconnect (gdb_client_data arg);
-static void async_stop_sig (gdb_client_data arg);
-static void async_float_handler (gdb_client_data arg);
/* Signal handlers. */
+#ifdef SIGQUIT
static void handle_sigquit (int sig);
+#endif
+#ifdef SIGHUP
static void handle_sighup (int sig);
+#endif
static void handle_sigfpe (int sig);
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
static void handle_sigwinch (int sig);
/* Functions to be invoked by the event loop in response to
signals. */
+#if defined (SIGQUIT) || defined (SIGHUP)
static void async_do_nothing (gdb_client_data);
+#endif
+#ifdef SIGHUP
static void async_disconnect (gdb_client_data);
+#endif
static void async_float_handler (gdb_client_data);
+#ifdef STOP_SIGNAL
static void async_stop_sig (gdb_client_data);
+#endif
/* Readline offers an alternate interface, via callback
functions. These are all included in the file callback.c in the
#ifdef SIGHUP
void *sighup_token;
#endif
+#ifdef SIGQUIT
void *sigquit_token;
+#endif
void *sigfpe_token;
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
void *sigwinch_token;
char *linebuffer_ptr;
}
readline_input_state;
+
+/* This hook is called by rl_callback_read_char_wrapper after each
+ character is processed. */
+void (*after_char_processing_hook) ();
\f
/* Wrapper function for calling into the readline library. The event
rl_callback_read_char_wrapper (gdb_client_data client_data)
{
rl_callback_read_char ();
+ if (after_char_processing_hook)
+ (*after_char_processing_hook) ();
}
/* Initialize all the necessary variables, start the event loop,
void
cli_command_loop (void)
{
- int length;
- char *a_prompt;
- char *gdb_prompt = get_prompt ();
-
/* If we are using readline, set things up and display the first
prompt, otherwise just print the prompt. */
if (async_command_editing_p)
{
+ int length;
+ char *a_prompt;
+ char *gdb_prompt = get_prompt ();
+
/* Tell readline what the prompt to display is and what function it
will need to call after a whole line is read. This also displays
the first prompt. */
- length = strlen (PREFIX (0)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
- a_prompt = (char *) xmalloc (length);
+ length = strlen (PREFIX (0))
+ + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
+ a_prompt = (char *) alloca (length);
strcpy (a_prompt, PREFIX (0));
strcat (a_prompt, gdb_prompt);
strcat (a_prompt, SUFFIX (0));
int prompt_length = 0;
char *gdb_prompt = get_prompt ();
-#ifdef UI_OUT
- /* When an alternative interpreter has been installed, do not
- display the comand prompt. */
- if (interpreter_p)
+ /* Reset the nesting depth used when trace-commands is set. */
+ reset_command_nest_depth ();
+
+ /* Each interpreter has its own rules on displaying the command
+ prompt. */
+ if (!current_interp_display_prompt_p ())
return;
-#endif
- 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
character position to be off, since the newline we read from
the user is not accounted for. */
fputs_unfiltered (new_prompt, gdb_stdout);
-
-#ifdef MPW
- /* Move to a new line so the entered line doesn't have a prompt
- on the front of it. */
- fputs_unfiltered ("\n", gdb_stdout);
-#endif /* MPW */
gdb_flush (gdb_stdout);
}
}
{
/* The prompt stack has not been initialized to "", we are
using gdb w/o the --async switch */
- warning ("Command has same effect as set annotate");
+ warning (_("Command has same effect as set annotate"));
return;
}
/* Pushes a new prompt on the prompt stack. Each prompt has three
parts: prefix, prompt, suffix. Usually prefix and suffix are empty
strings, except when the annotation level is 2. Memory is allocated
- within savestring for the new prompt. */
+ within xstrdup for the new prompt. */
void
push_prompt (char *prefix, char *prompt, char *suffix)
{
the_prompts.top++;
- PREFIX (0) = savestring (prefix, strlen (prefix));
+ PREFIX (0) = xstrdup (prefix);
/* Note that this function is used by the set annotate 2
command. This is why we take care of saving the old prompt
in case a new one is not specified. */
if (prompt)
- PROMPT (0) = savestring (prompt, strlen (prompt));
+ PROMPT (0) = xstrdup (prompt);
else
- PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));
+ PROMPT (0) = xstrdup (PROMPT (-1));
- SUFFIX (0) = savestring (suffix, strlen (suffix));
+ SUFFIX (0) = xstrdup (suffix);
}
/* Pops the top of the prompt stack, and frees the memory allocated for it. */
if (strcmp (PROMPT (0), PROMPT (-1)))
{
xfree (PROMPT (-1));
- PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));
+ PROMPT (-1) = xstrdup (PROMPT (0));
}
xfree (PREFIX (0));
{
if (error)
{
- printf_unfiltered ("error detected on stdin\n");
+ 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;
extern int display_time;
extern int display_space;
-#if defined(TUI)
- extern int insert_mode;
-#endif
-
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
- old_chain = make_cleanup (null_cleanup, 0);
-#if defined(TUI)
- insert_mode = 0;
-#endif
/* If readline returned a NULL command, it means that the
connection with the terminal is gone. This happens at the
end of a testsuite run, after Expect has hung up
but GDB is still alive. In such a case, we just quit gdb
killing the inferior program too. */
if (command == 0)
- quit_command ((char *) 0, stdin == instream);
+ {
+ printf_unfiltered ("quit\n");
+ execute_command ("quit", stdin == instream);
+ }
time_at_cmd_start = get_run_time ();
if (display_space)
{
#ifdef HAVE_SBRK
- extern char **environ;
char *lim = (char *) sbrk (0);
-
- space_at_cmd_start = (long) (lim - (char *) &environ);
+ space_at_cmd_start = lim - lim_at_start;
#endif
}
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.integer = time_at_cmd_start;
- arg2->data.integer = space_at_cmd_start;
- 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
- extern char **environ;
- char *lim = (char *) sbrk (0);
- long space_now = lim - (char *) &environ;
- 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)
{
long cmd_time = get_run_time () - time_at_cmd_start;
- printf_unfiltered ("Command execution time: %ld.%06ld\n",
+ printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
+
if (display_space)
{
#ifdef HAVE_SBRK
- extern char **environ;
char *lim = (char *) sbrk (0);
- long space_now = lim - (char *) &environ;
+ 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",
+ printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
space_now,
(space_diff >= 0 ? '+' : '-'),
space_diff);
{
static char *linebuffer = 0;
static unsigned linelength = 0;
- register char *p;
+ char *p;
char *p1;
extern char *line;
extern int linesize;
if (annotation_level > 1 && instream == stdin)
{
- printf_unfiltered ("\n\032\032post-");
- printf_unfiltered (async_annotation_suffix);
- printf_unfiltered ("\n");
+ printf_unfiltered (("\n\032\032post-"));
+ puts_unfiltered (async_annotation_suffix);
+ printf_unfiltered (("\n"));
}
if (linebuffer == 0)
gdb_flush (gdb_stderr);
if (source_file_name != NULL)
- {
- ++source_line_number;
- sprintf (source_error,
- "%s%s:%d: Error in sourced command file:\n",
- source_pre_error,
- source_file_name,
- source_line_number);
- error_pre_print = source_error;
- }
+ ++source_line_number;
/* If we are in this case, then command_handler will call quit
and exit from gdb. */
{
got_eof = 1;
command_handler (0);
+ return; /* Lint. */
}
if (strlen (rl) + 1 + (p - linebuffer) > linelength)
{
xfree (rl); /* Allocated in readline. */
- if (*(p - 1) == '\\')
+ if (p > linebuffer && *(p - 1) == '\\')
{
p--; /* Put on top of '\'. */
- if (*p == '\\')
- {
- readline_input_state.linebuffer = savestring (linebuffer,
- strlen (linebuffer));
- readline_input_state.linebuffer_ptr = p;
-
- /* We will not invoke a execute_command if there is more
- input expected to complete the command. So, we need to
- print an empty prompt here. */
- more_to_come = 1;
- push_prompt ("", "", "");
- display_gdb_prompt (0);
- return;
- }
+ readline_input_state.linebuffer = xstrdup (linebuffer);
+ readline_input_state.linebuffer_ptr = p;
+
+ /* We will not invoke a execute_command if there is more
+ input expected to complete the command. So, we need to
+ print an empty prompt here. */
+ more_to_come = 1;
+ push_prompt ("", "", "");
+ display_gdb_prompt (0);
+ return;
}
#ifdef STOP_SIGNAL
#define SERVER_COMMAND_LENGTH 7
server_command =
(p - linebuffer > SERVER_COMMAND_LENGTH)
- && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH);
+ && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;
if (server_command)
{
/* Note that we don't set `line'. Between this and the check in
}
strcpy (linebuffer, history_value);
p = linebuffer + strlen (linebuffer);
- xfree (history_value);
}
+ xfree (history_value);
}
/* If we just got an empty line, and that is supposed
break;
xfree (result);
(*input_handler) (0);
+ return;
}
if (c == '\n')
-#ifndef CRLF_SOURCE_FILES
- break;
-#else
{
if (input_index > 0 && result[input_index - 1] == '\r')
input_index--;
break;
}
-#endif
result[input_index++] = c;
while (input_index >= result_size)
signal (SIGINT, handle_sigint);
sigint_token =
create_async_signal_handler (async_request_quit, NULL);
+ signal (SIGTERM, handle_sigterm);
/* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
to the inferior and breakpoints will be ignored. */
signal (SIGTRAP, SIG_DFL);
#endif
+#ifdef SIGQUIT
/* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
passed to the inferior, which we don't want. It would be
possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
signal (SIGQUIT, handle_sigquit);
sigquit_token =
create_async_signal_handler (async_do_nothing, NULL);
+#endif
#ifdef SIGHUP
if (signal (SIGHUP, handle_sighup) != SIG_IGN)
sighup_token =
{
signal (sig, handle_sigint);
+ /* We could be running in a loop reading in symfiles or something so
+ it may be quite a while before we get back to the event loop. So
+ set quit_flag to 1 here. Then if QUIT is called before we get to
+ the event loop, we will unwind as expected. */
+
+ quit_flag = 1;
+
/* If immediate_quit is set, we go ahead and process the SIGINT right
away, even if we usually would defer this to the event loop. The
assumption here is that it is safe to process ^C immediately if
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.
+ GDB would quit anyway, but this way it will clean up properly. */
+void
+handle_sigterm (int sig)
+{
+ signal (sig, handle_sigterm);
+ quit_force ((char *) 0, stdin == instream);
}
/* Do the quit. All the checks have been done by the caller. */
void
async_request_quit (gdb_client_data arg)
{
- quit_flag = 1;
-#ifdef REQUEST_QUIT
- REQUEST_QUIT;
-#else
- quit ();
-#endif
+ /* If the quit_flag has gotten reset back to 0 by the time we get
+ back here, that means that an exception was thrown to unwind the
+ current command before we got back to the event loop. So there
+ is no reason to call quit again here, unless immediate_quit is
+ set.*/
+
+ if (quit_flag || immediate_quit)
+ quit ();
}
+#ifdef SIGQUIT
/* Tell the event loop what to do if SIGQUIT is received.
See event-signal.c. */
static void
mark_async_signal_handler_wrapper (sigquit_token);
signal (sig, handle_sigquit);
}
+#endif
-/* Called by the event loop in response to a SIGQUIT. */
+#if defined (SIGQUIT) || defined (SIGHUP)
+/* Called by the event loop in response to a SIGQUIT or an
+ ignored SIGHUP. */
static void
async_do_nothing (gdb_client_data arg)
{
/* Empty function body. */
}
+#endif
#ifdef SIGHUP
/* Tell the event loop what to do if SIGHUP is received.
"Could not kill the program being debugged",
RETURN_MASK_ALL);
signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
- kill (getpid (), SIGHUP);
+ raise (SIGHUP);
}
#endif
#if HAVE_SIGPROCMASK
{
sigset_t zero;
+
sigemptyset (&zero);
sigprocmask (SIG_SETMASK, &zero, 0);
}
-#else
+#elif HAVE_SIGSETMASK
sigsetmask (0);
#endif
- kill (getpid (), SIGTSTP);
+ raise (SIGTSTP);
signal (SIGTSTP, handle_stop_sig);
#else
signal (STOP_SIGNAL, handle_stop_sig);
{
/* This message is based on ANSI C, section 4.7. Note that integer
divide by zero causes this, so "float" is a misnomer. */
- error ("Erroneous arithmetic operation.");
+ error (_("Erroneous arithmetic operation."));
}
/* Tell the event loop what to do if SIGWINCH is received.
\f
/* Called by do_setshow_command. */
-/* ARGSUSED */
void
set_async_editing_command (char *args, int from_tty, struct cmd_list_element *c)
{
}
/* Called by do_setshow_command. */
-/* ARGSUSED */
void
set_async_annotation_level (char *args, int from_tty, struct cmd_list_element *c)
{
}
/* Called by do_setshow_command. */
-/* ARGSUSED */
void
set_async_prompt (char *args, int from_tty, struct cmd_list_element *c)
{
- PROMPT (0) = savestring (new_async_prompt, strlen (new_async_prompt));
+ PROMPT (0) = xstrdup (new_async_prompt);
}
/* Set things up for readline to be invoked via the alternate
interface, i.e. via a callback function (rl_callback_read_char),
and hook up instream to the event loop. */
void
-_initialize_event_loop (void)
+gdb_setup_readline (void)
{
- if (event_loop_p)
+ /* This function is a noop for the sync case. The assumption is
+ 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. */
+ if (!batch_silent)
+ gdb_stdout = stdio_fileopen (stdout);
+ gdb_stderr = stdio_fileopen (stderr);
+ gdb_stdlog = gdb_stderr; /* for moment */
+ gdb_stdtarg = gdb_stderr; /* for moment */
+
+ /* If the input stream is connected to a terminal, turn on
+ editing. */
+ if (ISATTY (instream))
{
- /* If the input stream is connected to a terminal, turn on
- editing. */
- if (ISATTY (instream))
- {
- /* Tell gdb that we will be using the readline library. This
- could be overwritten by a command in .gdbinit like 'set
- editing on' or 'off'. */
- async_command_editing_p = 1;
+ /* Tell gdb that we will be using the readline library. This
+ could be overwritten by a command in .gdbinit like 'set
+ editing on' or 'off'. */
+ async_command_editing_p = 1;
- /* When a character is detected on instream by select or
- poll, readline will be invoked via this callback
- function. */
- call_readline = rl_callback_read_char_wrapper;
- }
- else
- {
- async_command_editing_p = 0;
- call_readline = gdb_readline2;
- }
-
- /* When readline has read an end-of-line character, it passes
- the complete line to gdb for processing. command_line_handler
- is the function that does this. */
- input_handler = command_line_handler;
-
- /* Tell readline to use the same input stream that gdb uses. */
- rl_instream = instream;
-
- /* Get a file descriptor for the input stream, so that we can
- register it with the event loop. */
- input_fd = fileno (instream);
+ /* When a character is detected on instream by select or poll,
+ readline will be invoked via this callback function. */
+ call_readline = rl_callback_read_char_wrapper;
+ }
+ else
+ {
+ async_command_editing_p = 0;
+ call_readline = gdb_readline2;
+ }
+
+ /* When readline has read an end-of-line character, it passes the
+ complete line to gdb for processing. command_line_handler is the
+ function that does this. */
+ input_handler = command_line_handler;
+
+ /* Tell readline to use the same input stream that gdb uses. */
+ rl_instream = instream;
+
+ /* Get a file descriptor for the input stream, so that we can
+ register it with the event loop. */
+ input_fd = fileno (instream);
+
+ /* Now we need to create the event sources for the input file
+ descriptor. */
+ /* At this point in time, this is the only event source that we
+ register with the even loop. Another source is going to be the
+ target program (inferior), but that must be registered only when
+ it actually exists (I.e. after we say 'run' or after we connect
+ to a remote target. */
+ add_file_handler (input_fd, stdin_event_handler, 0);
+}
- /* Tell gdb to use the cli_command_loop as the main loop. */
- command_loop_hook = cli_command_loop;
+/* Disable command input through the standard CLI channels. Used in
+ the suspend proc for interpreters that use the standard gdb readline
+ interface, like the cli & the mi. */
+void
+gdb_disable_readline (void)
+{
+ /* FIXME - It is too heavyweight to delete and remake these every
+ time you run an interpreter that needs readline. It is probably
+ better to have the interpreters cache these, which in turn means
+ that this needs to be moved into interpreter specific code. */
+
+#if 0
+ ui_file_delete (gdb_stdout);
+ ui_file_delete (gdb_stderr);
+ gdb_stdlog = NULL;
+ gdb_stdtarg = NULL;
+#endif
- /* Now we need to create the event sources for the input file
- descriptor. */
- /* At this point in time, this is the only event source that we
- register with the even loop. Another source is going to be
- the target program (inferior), but that must be registered
- only when it actually exists (I.e. after we say 'run' or
- after we connect to a remote target. */
- add_file_handler (input_fd, stdin_event_handler, 0);
- }
+ rl_callback_handler_remove ();
+ delete_file_handler (input_fd);
}
projects / deliverable / binutils-gdb.git / blobdiff