#include "inferior.h"
#include "infrun.h"
#include "target.h"
-#include "terminal.h" /* for job_control */
+#include "terminal.h"
#include "event-loop.h"
#include "event-top.h"
#include "interps.h"
#include "gdbcmd.h" /* for dont_repeat() */
#include "annotate.h"
#include "maint.h"
-#include "buffer.h"
+#include "gdbsupport/buffer.h"
#include "ser-event.h"
#include "gdb_select.h"
ezannoni: as of 1999-04-29 I expect that this
variable will not be used after gdb is changed to use the event
loop as default engine, and event-top.c is merged into top.c. */
-int set_editing_cmd_var;
+bool set_editing_cmd_var;
/* This is used to display the notification of the completion of an
asynchronous execution command. */
-int exec_done_display_p = 0;
+bool exec_done_display_p = false;
/* Used by the stdin event handler to compensate for missed stdin events.
Setting this to a non-zero value inside an stdin callback makes the callback
static struct gdb_exception
gdb_rl_callback_read_char_wrapper_noexcept () noexcept
{
- struct gdb_exception gdb_expt = exception_none;
+ struct gdb_exception gdb_expt;
/* C++ exceptions can't normally be thrown across readline (unless
it is built with -fexceptions, but it won't by default on many
}
CATCH_SJLJ (ex, RETURN_MASK_ALL)
{
- gdb_expt = ex;
+ gdb_expt = std::move (ex);
}
END_CATCH_SJLJ
/* Rethrow using the normal EH mechanism. */
if (gdb_expt.reason < 0)
- throw_exception (gdb_expt);
+ throw_exception (std::move (gdb_expt));
}
/* GDB's readline callback handler. Calls the current INPUT_HANDLER,
static void
gdb_rl_callback_handler (char *rl) noexcept
{
- struct gdb_exception gdb_rl_expt = exception_none;
+ /* This is static to avoid undefined behavior when calling longjmp
+ -- gdb_exception has a destructor with side effects. */
+ static struct gdb_exception gdb_rl_expt;
struct ui *ui = current_ui;
- TRY
+ try
{
+ /* Ensure the exception is reset on each call. */
+ gdb_rl_expt = {};
ui->input_handler (gdb::unique_xmalloc_ptr<char> (rl));
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (gdb_exception &ex)
{
- gdb_rl_expt = ex;
+ gdb_rl_expt = std::move (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
If REPEAT, handle command repetitions:
- If the input command line is NOT empty, the command returned is
- copied into the global 'saved_command_line' var so that it can
- be repeated later.
+ saved using save_command_line () so that it can be repeated later.
- - OTOH, if the input command line IS empty, return the previously
- saved command instead of the empty input line.
+ - OTOH, if the input command line IS empty, return the saved
+ command instead of the empty input line.
*/
char *
server_command = startswith (cmd, SERVER_COMMAND_PREFIX);
if (server_command)
{
- /* Note that we don't set `saved_command_line'. Between this
+ /* Note that we don't call `save_command_line'. Between this
and the check in dont_repeat, this insures that repeating
will still do the right thing. */
return cmd + strlen (SERVER_COMMAND_PREFIX);
for (p1 = cmd; *p1 == ' ' || *p1 == '\t'; p1++)
;
if (repeat && *p1 == '\0')
- return saved_command_line;
+ return get_saved_command_line ();
/* Add command to history if appropriate. Note: lines consisting
solely of comments are also added to the command history. This
/* Save into global buffer if appropriate. */
if (repeat)
{
- xfree (saved_command_line);
- saved_command_line = xstrdup (cmd);
- return saved_command_line;
+ save_command_line (cmd);
+ return get_saved_command_line ();
}
else
return cmd;
async_disconnect (gdb_client_data arg)
{
- TRY
+ try
{
quit_cover ();
}
- CATCH (exception, RETURN_MASK_ALL)
+ catch (const gdb_exception &exception)
{
fputs_filtered ("Could not kill the program being debugged",
gdb_stderr);
exception_print (gdb_stderr, exception);
}
- END_CATCH
- TRY
+ try
{
pop_all_targets ();
}
- CATCH (exception, RETURN_MASK_ALL)
+ catch (const gdb_exception &exception)
{
}
- END_CATCH
signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
raise (SIGHUP);