#include "defs.h"
#include "top.h"
#include "inferior.h"
+#include "target.h"
#include "terminal.h" /* for job_control */
-#include <signal.h>
+#include "signals.h"
#include "event-loop.h"
+#include "event-top.h"
+
+/* For dont_repeat() */
+#include "gdbcmd.h"
/* readline include files */
#include <readline/readline.h>
#include <readline/history.h>
+#include <signal.h>
+
/* readline defines this. */
#undef savestring
-extern void _initialize_event_loop PARAMS ((void));
+extern void _initialize_event_loop (void);
-static void command_line_handler PARAMS ((char *));
-static void command_line_handler_continuation PARAMS ((struct continuation_arg *));
-void gdb_readline2 PARAMS ((void));
-void pop_prompt PARAMS ((void));
-void push_prompt PARAMS ((char *, char *, char *));
-static void change_line_handler PARAMS ((void));
-static void change_annotation_level PARAMS ((void));
-static void command_handler PARAMS ((char *));
+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. */
-void handle_sigint PARAMS ((int));
-static void handle_sigquit PARAMS ((int));
-static void handle_sighup PARAMS ((int));
-static void handle_sigfpe PARAMS ((int));
-static void handle_sigwinch PARAMS ((int));
-/* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
-#ifndef STOP_SIGNAL
-#ifdef SIGTSTP
-#define STOP_SIGNAL SIGTSTP
-void handle_stop_sig PARAMS ((int));
-#endif
+static void handle_sigquit (int sig);
+static void handle_sighup (int sig);
+static void handle_sigfpe (int sig);
+#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
+static void handle_sigwinch (int sig);
#endif
/* Functions to be invoked by the event loop in response to
signals. */
-void async_request_quit PARAMS ((gdb_client_data));
-static void async_do_nothing PARAMS ((gdb_client_data));
-static void async_disconnect PARAMS ((gdb_client_data));
-static void async_float_handler PARAMS ((gdb_client_data));
-static void async_stop_sig PARAMS ((gdb_client_data));
-
-/* If this definition isn't overridden by the header files, assume
- that isatty and fileno exist on this system. */
-#ifndef ISATTY
-#define ISATTY(FP) (isatty (fileno (FP)))
-#endif
+static void async_do_nothing (gdb_client_data);
+static void async_disconnect (gdb_client_data);
+static void async_float_handler (gdb_client_data);
+static void async_stop_sig (gdb_client_data);
/* Readline offers an alternate interface, via callback
functions. These are all included in the file callback.c in the
line of input is ready. CALL_READLINE is to be set to the function
that readline offers as callback to the event_loop. */
-void (*input_handler) PARAMS ((char *));
-void (*call_readline) PARAMS ((void));
+void (*input_handler) (char *);
+void (*call_readline) (gdb_client_data);
/* Important variables for the event loop. */
annotation_level is 2. */
char *async_annotation_suffix;
+/* This is used to display the notification of the completion of an
+ asynchronous execution command. */
+int exec_done_display_p = 0;
+
/* This is the file descriptor for the input stream that GDB uses to
read commands from. */
int input_fd;
PTR sigtstp_token;
#endif
-void mark_async_signal_handler_wrapper PARAMS ((void *));
-
/* Structure to save a partially entered command. This is used when
the user types '\' at the end of a command line. This is necessary
because each line of input is handled by a different call to
readline_input_state;
\f
+/* Wrapper function foe calling into the readline library. The event
+ loop expects the callback function to have a paramter, while readline
+ expects none. */
+static void
+rl_callback_read_char_wrapper (gdb_client_data client_data)
+{
+ rl_callback_read_char ();
+}
+
/* Initialize all the necessary variables, start the event loop,
register readline, and stdin, start the loop. */
void
-cli_command_loop ()
+cli_command_loop (void)
{
int length;
char *a_prompt;
which the user sets editing on again, by restoring readline
handling of the input. */
static void
-change_line_handler ()
+change_line_handler (void)
{
+ /* NOTE: this operates on input_fd, not instream. If we are reading
+ commands from a file, instream will point to the file. However in
+ async mode, we always read commands from a file with editing
+ off. This means that the 'set editing on/off' will have effect
+ only on the interactive session. */
+
if (async_command_editing_p)
{
/* Turn on editing by using readline. */
- call_readline = rl_callback_read_char;
+ call_readline = rl_callback_read_char_wrapper;
input_handler = command_line_handler;
}
else
first thing from .gdbinit. */
input_handler = command_line_handler;
}
-
- /* To tell the event loop to change the handler associated with the
- input file descriptor, we need to create a new event source,
- corresponding to the same fd, but with a new event handler
- function. */
- /* NOTE: this operates on input_fd, not instream. If we are reading
- commands from a file, instream will point to the file. However in
- async mode, we always read commands from a file with editing
- off. This means that the 'set editing on/off' will have effect
- only on the interactive session. */
- delete_file_handler (input_fd);
- add_file_handler (input_fd, (file_handler_func *) call_readline, 0);
}
/* Displays the prompt. The prompt that is displayed is the current
3. Other????
FIXME: 2. & 3. not implemented yet for async. */
void
-display_gdb_prompt (new_prompt)
- char *new_prompt;
+display_gdb_prompt (char *new_prompt)
{
int prompt_length = 0;
char *gdb_prompt = get_prompt ();
- if (target_executing && sync_execution)
+ if (target_executing && sync_execution)
{
/* This is to trick readline into not trying to display the
- prompt. Even though we display the prompt using this
- function, readline still tries to do its own display if we
- don't call rl_callback_handler_install and
- rl_callback_handler_remove (which readline detects because a
- global variable is not set). If readline did that, it could
- mess up gdb signal handlers for SIGINT. Readline assumes
- that between calls to rl_set_signals and rl_clear_signals gdb
- doesn't do anything with the signal handlers. Well, that's
- not the case, because when the target executes we change the
- SIGINT signal handler. If we allowed readline to display the
- prompt, the signal handler change would happen exactly
- between the calls to the above two functions.
- Calling rl_callback_handler_remove(), does the job. */
+ prompt. Even though we display the prompt using this
+ function, readline still tries to do its own display if we
+ don't call rl_callback_handler_install and
+ rl_callback_handler_remove (which readline detects because a
+ global variable is not set). If readline did that, it could
+ mess up gdb signal handlers for SIGINT. Readline assumes
+ that between calls to rl_set_signals and rl_clear_signals gdb
+ doesn't do anything with the signal handlers. Well, that's
+ not the case, because when the target executes we change the
+ SIGINT signal handler. If we allowed readline to display the
+ prompt, the signal handler change would happen exactly
+ between the calls to the above two functions.
+ Calling rl_callback_handler_remove(), does the job. */
rl_callback_handler_remove ();
return;
it pops the top of the prompt stack when we want the annotation level
to be the normal ones (1 or 0). */
static void
-change_annotation_level ()
+change_annotation_level (void)
{
char *prefix, *suffix;
strings, except when the annotation level is 2. Memory is allocated
within savestring for the new prompt. */
void
-push_prompt (prefix, prompt, suffix)
- char *prefix;
- char *prompt;
- char *suffix;
+push_prompt (char *prefix, char *prompt, char *suffix)
{
the_prompts.top++;
PREFIX (0) = savestring (prefix, strlen (prefix));
/* Pops the top of the prompt stack, and frees the memory allocated for it. */
void
-pop_prompt ()
+pop_prompt (void)
{
/* If we are not during a 'synchronous' execution command, in which
case, the top prompt would be empty. */
free (SUFFIX (0));
the_prompts.top--;
}
+
+/* When there is an event ready on the stdin file desriptor, instead
+ of calling readline directly throught the callback function, or
+ instead of calling gdb_readline2, give gdb a chance to detect
+ errors and do something. */
+void
+stdin_event_handler (int error, gdb_client_data client_data)
+{
+ if (error)
+ {
+ printf_unfiltered ("error detected on stdin\n");
+ delete_file_handler (input_fd);
+ discard_all_continuations ();
+ /* If stdin died, we may as well kill gdb. */
+ quit_command ((char *) 0, stdin == instream);
+ }
+ else
+ (*call_readline) (client_data);
+}
+
+/* Re-enable stdin after the end of an execution command in
+ synchronous mode, or after an error from the target, and we aborted
+ the exec operation. */
+
+void
+async_enable_stdin (void *dummy)
+{
+ /* 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
+ synchronous. */
+
+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);
+}
\f
+
/* Handles a gdb command. This function is called by
command_line_handler, which has processed one or more input lines
into COMMAND. */
function. The command_loop function will be obsolete when we
switch to use the event loop at every execution of gdb. */
static void
-command_handler (command)
- char *command;
+command_handler (char *command)
{
struct cleanup *old_chain;
int stdin_is_tty = ISATTY (stdin);
/* Set things up for this function to be compete later, once the
executin has completed, if we are doing an execution command,
otherwise, just go ahead and finish. */
- if (target_has_async && target_executing)
+ if (target_can_async_p () && target_executing)
{
arg1 =
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
/* 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_has_async || !target_executing)
+ if (!target_can_async_p () || !target_executing)
{
bpstat_do_actions (&stop_bpstat);
do_cleanups (old_chain);
are always running synchronously. Or if we have just executed a
command that doesn't start the target. */
void
-command_line_handler_continuation (arg)
- struct continuation_arg *arg;
+command_line_handler_continuation (struct continuation_arg *arg)
{
extern int display_time;
extern int display_space;
obsolete once we use the event loop as the default mechanism in
GDB. */
static void
-command_line_handler (rl)
- char *rl;
+command_line_handler (char *rl)
{
static char *linebuffer = 0;
static unsigned linelength = 0;
free (rl); /* Allocated in readline. */
- if (p == linebuffer || *(p - 1) == '\\')
+ if (*(p - 1) == '\\')
{
- /* We come here also if the line entered is empty (just a 'return') */
p--; /* Put on top of '\'. */
if (*p == '\\')
will become obsolete when the event loop is made the default
execution for gdb. */
void
-gdb_readline2 ()
+gdb_readline2 (gdb_client_data client_data)
{
int c;
char *result;
int input_index = 0;
int result_size = 80;
+ static int done_once = 0;
+
+ /* Unbuffer the input stream, so that, later on, the calls to fgetc
+ fetch only one char at the time from the stream. The fgetc's will
+ get up to the first newline, but there may be more chars in the
+ stream after '\n'. If we buffer the input and fgetc drains the
+ stream, getting stuff beyond the newline as well, a select, done
+ afterwards will not trigger. */
+ if (!done_once && !ISATTY (instream))
+ {
+ setbuf (instream, NULL);
+ done_once = 1;
+ }
result = (char *) xmalloc (result_size);
init_signals will become obsolete as we move to have to event loop
as the default for gdb. */
void
-async_init_signals ()
+async_init_signals (void)
{
signal (SIGINT, handle_sigint);
sigint_token =
}
void
-mark_async_signal_handler_wrapper (token)
- void *token;
+mark_async_signal_handler_wrapper (PTR token)
{
- mark_async_signal_handler ((async_signal_handler *) token);
+ mark_async_signal_handler ((struct async_signal_handler *) token);
}
/* Tell the event loop what to do if SIGINT is received.
See event-signal.c. */
void
-handle_sigint (sig)
- int sig;
+handle_sigint (int sig)
{
signal (sig, handle_sigint);
/* Do the quit. All the checks have been done by the caller. */
void
-async_request_quit (arg)
- gdb_client_data arg;
+async_request_quit (gdb_client_data arg)
{
quit_flag = 1;
#ifdef REQUEST_QUIT
/* Tell the event loop what to do if SIGQUIT is received.
See event-signal.c. */
static void
-handle_sigquit (sig)
- int sig;
+handle_sigquit (int sig)
{
mark_async_signal_handler_wrapper (sigquit_token);
signal (sig, handle_sigquit);
/* Called by the event loop in response to a SIGQUIT. */
static void
-async_do_nothing (arg)
- gdb_client_data arg;
+async_do_nothing (gdb_client_data arg)
{
/* Empty function body. */
}
/* Called by the event loop to process a SIGHUP */
static void
-async_disconnect (arg)
- gdb_client_data arg;
+async_disconnect (gdb_client_data arg)
{
catch_errors (quit_cover, NULL,
"Could not kill the program being debugged",
#ifdef STOP_SIGNAL
void
-handle_stop_sig (sig)
- int sig;
+handle_stop_sig (int sig)
{
mark_async_signal_handler_wrapper (sigtstp_token);
signal (sig, handle_stop_sig);
}
static void
-async_stop_sig (arg)
- gdb_client_data arg;
+async_stop_sig (gdb_client_data arg)
{
char *prompt = get_prompt ();
#if STOP_SIGNAL == SIGTSTP
signal (SIGTSTP, SIG_DFL);
+#if HAVE_SIGPROCMASK
+ {
+ sigset_t zero;
+ sigemptyset (&zero);
+ sigprocmask (SIG_SETMASK, &zero, 0);
+ }
+#else
sigsetmask (0);
+#endif
kill (getpid (), SIGTSTP);
signal (SIGTSTP, handle_stop_sig);
#else
/* Tell the event loop what to do if SIGFPE is received.
See event-signal.c. */
static void
-handle_sigfpe (sig)
- int sig;
+handle_sigfpe (int sig)
{
mark_async_signal_handler_wrapper (sigfpe_token);
signal (sig, handle_sigfpe);
/* Event loop will call this functin to process a SIGFPE. */
static void
-async_float_handler (arg)
- gdb_client_data arg;
+async_float_handler (gdb_client_data arg)
{
/* This message is based on ANSI C, section 4.7. Note that integer
divide by zero causes this, so "float" is a misnomer. */
See event-signal.c. */
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
static void
-handle_sigwinch (sig)
- int sig;
+handle_sigwinch (int sig)
{
mark_async_signal_handler_wrapper (sigwinch_token);
signal (sig, handle_sigwinch);
/* Called by do_setshow_command. */
/* ARGSUSED */
void
-set_async_editing_command (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_async_editing_command (char *args, int from_tty, struct cmd_list_element *c)
{
change_line_handler ();
}
/* Called by do_setshow_command. */
/* ARGSUSED */
void
-set_async_annotation_level (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_async_annotation_level (char *args, int from_tty, struct cmd_list_element *c)
{
change_annotation_level ();
}
/* Called by do_setshow_command. */
/* ARGSUSED */
void
-set_async_prompt (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_async_prompt (char *args, int from_tty, struct cmd_list_element *c)
{
PROMPT (0) = savestring (new_async_prompt, strlen (new_async_prompt));
}
interface, i.e. via a callback function (rl_callback_read_char),
and hook up instream to the event loop. */
void
-_initialize_event_loop ()
+_initialize_event_loop (void)
{
- if (async_p)
+ if (event_loop_p)
{
/* 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;
+ call_readline = rl_callback_read_char_wrapper;
/* When readline has read an end-of-line character, it passes
the complete line to gdb for processing. command_line_handler
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, (file_handler_func *) call_readline, 0);
+ add_file_handler (input_fd, stdin_event_handler, 0);
/* Tell gdb that we will be using the readline library. This
could be overwritten by a command in .gdbinit like 'set