/* readline defines this. */
#undef savestring
-static void rl_callback_read_char_wrapper (gdb_client_data client_data);
static void command_line_handler (char *rl);
static void change_line_handler (void);
static char *top_level_prompt (void);
#endif
static void async_sigterm_handler (gdb_client_data arg);
-/* Readline offers an alternate interface, via callback
- functions. These are all included in the file callback.c in the
- readline distribution. This file provides (mainly) a function, which
- the event loop uses as callback (i.e. event handler) whenever an event
- is detected on the standard input file descriptor.
- readline_callback_read_char is called (by the GDB event loop) whenever
- there is a new character ready on the input stream. This function
- incrementally builds a buffer internal to readline where it
- accumulates the line read up to the point of invocation. In the
- special case in which the character read is newline, the function
- invokes a GDB supplied callback routine, which does the processing of
- a full command line. This latter routine is the asynchronous analog
- of the old command_line_input in gdb. Instead of invoking (and waiting
- for) readline to read the command line and pass it back to
- command_loop for processing, the new command_line_handler function has
- the command line already available as its parameter. INPUT_HANDLER is
- to be set to the function that readline will invoke when a complete
- 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) (char *);
-void (*call_readline) (gdb_client_data);
+/* Instead of invoking (and waiting for) readline to read the command
+ line and pass it back for processing, we use readline's alternate
+ interface, via callback functions, so that the event loop can react
+ to other event sources while we wait for input. */
/* Important variables for the event loop. */
#endif
static struct async_signal_handler *async_sigterm_token;
-/* This hook is called by rl_callback_read_char_wrapper after each
+/* This hook is called by gdb_rl_callback_read_char_wrapper after each
character is processed. */
void (*after_char_processing_hook) (void);
\f
-/* Wrapper function for calling into the readline library. The event
- loop expects the callback function to have a paramter, while
- readline expects none. */
+/* Wrapper function for calling into the readline library. This takes
+ care of a couple things:
+
+ - The event loop expects the callback function to have a parameter,
+ while readline expects none.
+
+ - Propagation of GDB exceptions/errors thrown from INPUT_HANDLER
+ across readline requires special handling.
+
+ On the exceptions issue:
+
+ DWARF-based unwinding cannot cross code built without -fexceptions.
+ Any exception that tries to propagate through such code will fail
+ and the result is a call to std::terminate. While some ABIs, such
+ as x86-64, require all code to be built with exception tables,
+ others don't.
+
+ This is a problem when GDB calls some non-EH-aware C library code,
+ that calls into GDB again through a callback, and that GDB callback
+ code throws a C++ exception. Turns out this is exactly what
+ happens with GDB's readline callback.
+
+ In such cases, we must catch and save any C++ exception that might
+ be thrown from the GDB callback before returning to the
+ non-EH-aware code. When the non-EH-aware function itself returns
+ back to GDB, we then rethrow the original C++ exception.
+
+ In the readline case however, the right thing to do is to longjmp
+ out of the callback, rather than do a normal return -- there's no
+ way for the callback to return to readline an indication that an
+ error happened, so a normal return would have rl_callback_read_char
+ potentially continue processing further input, redisplay the
+ prompt, etc. Instead of raw setjmp/longjmp however, we use our
+ sjlj-based TRY/CATCH mechanism, which knows to handle multiple
+ levels of active setjmp/longjmp frames, needed in order to handle
+ the readline callback recursing, as happens with e.g., secondary
+ prompts / queries, through gdb_readline_wrapper. */
+
+static void
+gdb_rl_callback_read_char_wrapper (gdb_client_data client_data)
+{
+ struct gdb_exception gdb_expt = exception_none;
+
+ /* C++ exceptions can't normally be thrown across readline (unless
+ it is built with -fexceptions, but it won't by default on many
+ ABIs). So we instead wrap the readline call with a sjlj-based
+ TRY/CATCH, and rethrow the GDB exception once back in GDB. */
+ TRY_SJLJ
+ {
+ rl_callback_read_char ();
+ if (after_char_processing_hook)
+ (*after_char_processing_hook) ();
+ }
+ CATCH_SJLJ (ex, RETURN_MASK_ALL)
+ {
+ gdb_expt = ex;
+ }
+ END_CATCH_SJLJ
+
+ /* Rethrow using the normal EH mechanism. */
+ if (gdb_expt.reason < 0)
+ throw_exception (gdb_expt);
+}
+
+/* GDB's readline callback handler. Calls the current INPUT_HANDLER,
+ and propagates GDB exceptions/errors thrown from INPUT_HANDLER back
+ across readline. See gdb_rl_callback_read_char_wrapper. */
+
static void
-rl_callback_read_char_wrapper (gdb_client_data client_data)
+gdb_rl_callback_handler (char *rl)
{
- rl_callback_read_char ();
- if (after_char_processing_hook)
- (*after_char_processing_hook) ();
+ struct gdb_exception gdb_rl_expt = exception_none;
+ struct ui *ui = current_ui;
+
+ TRY
+ {
+ ui->input_handler (rl);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ gdb_rl_expt = ex;
+ }
+ END_CATCH
+
+ /* If we caught a GDB exception, longjmp out of the readline
+ callback. There's no other way for the callback to signal to
+ readline that an error happened. A normal return would have
+ readline potentially continue processing further input, redisplay
+ the prompt, etc. (This is what GDB historically did when it was
+ a C program.) Note that since we're long jumping, local variable
+ dtors are NOT run automatically. */
+ if (gdb_rl_expt.reason < 0)
+ throw_exception_sjlj (gdb_rl_expt);
}
/* Initialize all the necessary variables, start the event loop,
static void
change_line_handler (void)
{
+ struct ui *ui = current_ui;
+
/* 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
if (async_command_editing_p)
{
/* Turn on editing by using readline. */
- call_readline = rl_callback_read_char_wrapper;
- input_handler = command_line_handler;
+ ui->call_readline = gdb_rl_callback_read_char_wrapper;
+ ui->input_handler = command_line_handler;
}
else
{
/* Turn off editing by using gdb_readline_no_editing_callback. */
gdb_rl_callback_handler_remove ();
- call_readline = gdb_readline_no_editing_callback;
+ ui->call_readline = gdb_readline_no_editing_callback;
/* Set up the command handler as well, in case we are called as
first thing from .gdbinit. */
- input_handler = command_line_handler;
+ ui->input_handler = command_line_handler;
}
}
therefore loses input. */
gdb_assert (!callback_handler_installed);
- rl_callback_handler_install (prompt, input_handler);
+ rl_callback_handler_install (prompt, gdb_rl_callback_handler);
callback_handler_installed = 1;
}
beginning. */
const char suffix[] = "\n\032\032prompt\n";
- return concat (prefix, prompt, suffix, NULL);
+ return concat (prefix, prompt, suffix, (char *) NULL);
}
return xstrdup (prompt);
}
-/* Get a pointer to the command line buffer. This is used to
+static struct ui current_ui_;
+struct ui *current_ui = ¤t_ui_;
+
+/* Get a pointer to the current UI's line buffer. This is used to
construct a whole line of input from partial input. */
static struct buffer *
get_command_line_buffer (void)
{
- static struct buffer line_buffer;
- static int line_buffer_initialized;
-
- if (!line_buffer_initialized)
- {
- buffer_init (&line_buffer);
- line_buffer_initialized = 1;
- }
-
- return &line_buffer;
+ return ¤t_ui->line_buffer;
}
/* When there is an event ready on the stdin file descriptor, instead
void
stdin_event_handler (int error, gdb_client_data client_data)
{
+ struct ui *ui = current_ui;
+
if (error)
{
printf_unfiltered (_("error detected on stdin\n"));
do
{
call_stdin_event_handler_again_p = 0;
- (*call_readline) (client_data);
+ ui->call_readline (client_data);
} while (call_stdin_event_handler_again_p != 0);
}
}
char *result;
struct buffer line_buffer;
static int done_once = 0;
+ struct ui *ui = current_ui;
buffer_init (&line_buffer);
break;
}
xfree (buffer_finish (&line_buffer));
- (*input_handler) (0);
+ ui->input_handler (NULL);
return;
}
buffer_grow_char (&line_buffer, '\0');
result = buffer_finish (&line_buffer);
- (*input_handler) (result);
+ ui->input_handler (result);
}
\f
return serial_event_fd (quit_serial_event);
}
+/* See defs.h. */
+
+void
+default_quit_handler (void)
+{
+ if (check_quit_flag ())
+ {
+ if (target_terminal_is_ours ())
+ quit ();
+ else
+ target_pass_ctrlc ();
+ }
+}
+
+/* See defs.h. */
+quit_handler_ftype *quit_handler = default_quit_handler;
+
+/* Data for make_cleanup_override_quit_handler. Wrap the previous
+ handler pointer in a data struct because it's not portable to cast
+ a function pointer to a data pointer, which is what make_cleanup
+ expects. */
+struct quit_handler_cleanup_data
+{
+ /* The previous quit handler. */
+ quit_handler_ftype *prev_handler;
+};
+
+/* Cleanup call that restores the previous quit handler. */
+
+static void
+restore_quit_handler (void *arg)
+{
+ struct quit_handler_cleanup_data *data
+ = (struct quit_handler_cleanup_data *) arg;
+
+ quit_handler = data->prev_handler;
+}
+
+/* Destructor for the quit handler cleanup. */
+
+static void
+restore_quit_handler_dtor (void *arg)
+{
+ xfree (arg);
+}
+
+/* See defs.h. */
+
+struct cleanup *
+make_cleanup_override_quit_handler (quit_handler_ftype *new_quit_handler)
+{
+ struct cleanup *old_chain;
+ struct quit_handler_cleanup_data *data;
+
+ data = XNEW (struct quit_handler_cleanup_data);
+ data->prev_handler = quit_handler;
+ old_chain = make_cleanup_dtor (restore_quit_handler, data,
+ restore_quit_handler_dtor);
+ quit_handler = new_quit_handler;
+ return old_chain;
+}
+
/* Handle a SIGINT. */
void
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. */
-
set_quit_flag ();
- /* 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 is not set,
- we process SIGINT the next time through the loop, which is fine. */
- gdb_call_async_signal_handler (sigint_token, immediate_quit);
+ /* In case nothing calls QUIT before the event loop is reached, the
+ event loop handles it. */
+ mark_async_signal_handler (sigint_token);
}
/* See gdb_select.h. */
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. */
-
- if (check_quit_flag ())
- quit ();
+ QUIT;
}
#ifdef SIGQUIT
}
/* 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. */
+ interface, i.e. via a callback function
+ (gdb_rl_callback_read_char), and hook up instream to the event
+ loop. */
+
void
gdb_setup_readline (void)
{
+ struct ui *ui = current_ui;
+
/* 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
/* 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;
+ ui->call_readline = gdb_rl_callback_read_char_wrapper;
}
else
{
async_command_editing_p = 0;
- call_readline = gdb_readline_no_editing_callback;
+ ui->call_readline = gdb_readline_no_editing_callback;
}
/* 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;
-
+ ui->input_handler = command_line_handler;
+
/* Tell readline to use the same input stream that gdb uses. */
rl_instream = instream;
projects / deliverable / binutils-gdb.git / blobdiff