#include "event-top.h"
#include <algorithm>
#include "byte-vector.h"
+#include "terminal.h"
static void generic_tls_error (void) ATTRIBUTE_NORETURN;
/* Define it. */
-enum target_terminal::terminal_state target_terminal::terminal_state
- = target_terminal::terminal_is_ours;
+target_terminal_state target_terminal::m_terminal_state
+ = target_terminal_state::is_ours;
/* See target/target.h. */
{
(*current_target.to_terminal_init) (¤t_target);
- terminal_state = terminal_is_ours;
+ m_terminal_state = target_terminal_state::is_ours;
}
/* See target/target.h. */
if (ui != main_ui)
return;
- if (terminal_state == terminal_is_inferior)
- return;
-
/* If GDB is resuming the inferior in the foreground, install
inferior's terminal modes. */
- (*current_target.to_terminal_inferior) (¤t_target);
- terminal_state = terminal_is_inferior;
+
+ struct inferior *inf = current_inferior ();
+
+ if (inf->terminal_state != target_terminal_state::is_inferior)
+ {
+ (*current_target.to_terminal_inferior) (¤t_target);
+ inf->terminal_state = target_terminal_state::is_inferior;
+ }
+
+ m_terminal_state = target_terminal_state::is_inferior;
/* If the user hit C-c before, pretend that it was hit right
here. */
/* See target/target.h. */
+void
+target_terminal::restore_inferior (void)
+{
+ struct ui *ui = current_ui;
+
+ /* See target_terminal::inferior(). */
+ if (ui->prompt_state != PROMPT_BLOCKED || ui != main_ui)
+ return;
+
+ /* Restore the terminal settings of inferiors that were in the
+ foreground but are now ours_for_output due to a temporary
+ target_target::ours_for_output() call. */
+
+ {
+ scoped_restore_current_inferior restore_inferior;
+ struct inferior *inf;
+
+ ALL_INFERIORS (inf)
+ {
+ if (inf->terminal_state == target_terminal_state::is_ours_for_output)
+ {
+ set_current_inferior (inf);
+ (*current_target.to_terminal_inferior) (¤t_target);
+ inf->terminal_state = target_terminal_state::is_inferior;
+ }
+ }
+ }
+
+ m_terminal_state = target_terminal_state::is_inferior;
+
+ /* If the user hit C-c before, pretend that it was hit right
+ here. */
+ if (check_quit_flag ())
+ target_pass_ctrlc ();
+}
+
+/* Switch terminal state to DESIRED_STATE, either is_ours, or
+ is_ours_for_output. */
+
+static void
+target_terminal_is_ours_kind (target_terminal_state desired_state)
+{
+ scoped_restore_current_inferior restore_inferior;
+ struct inferior *inf;
+
+ /* Must do this in two passes. First, have all inferiors save the
+ current terminal settings. Then, after all inferiors have add a
+ chance to safely save the terminal settings, restore GDB's
+ terminal settings. */
+
+ ALL_INFERIORS (inf)
+ {
+ if (inf->terminal_state == target_terminal_state::is_inferior)
+ {
+ set_current_inferior (inf);
+ (*current_target.to_terminal_save_inferior) (¤t_target);
+ }
+ }
+
+ ALL_INFERIORS (inf)
+ {
+ /* Note we don't check is_inferior here like above because we
+ need to handle 'is_ours_for_output -> is_ours' too. Careful
+ to never transition from 'is_ours' to 'is_ours_for_output',
+ though. */
+ if (inf->terminal_state != target_terminal_state::is_ours
+ && inf->terminal_state != desired_state)
+ {
+ set_current_inferior (inf);
+ if (desired_state == target_terminal_state::is_ours)
+ (*current_target.to_terminal_ours) (¤t_target);
+ else if (desired_state == target_terminal_state::is_ours_for_output)
+ (*current_target.to_terminal_ours_for_output) (¤t_target);
+ else
+ gdb_assert_not_reached ("unhandled desired state");
+ inf->terminal_state = desired_state;
+ }
+ }
+}
+
+/* See target/target.h. */
+
void
target_terminal::ours ()
{
if (ui != main_ui)
return;
- if (terminal_state == terminal_is_ours)
+ if (m_terminal_state == target_terminal_state::is_ours)
return;
- (*current_target.to_terminal_ours) (¤t_target);
- terminal_state = terminal_is_ours;
+ target_terminal_is_ours_kind (target_terminal_state::is_ours);
+ m_terminal_state = target_terminal_state::is_ours;
}
/* See target/target.h. */
if (ui != main_ui)
return;
- if (terminal_state != terminal_is_inferior)
+ if (!target_terminal::is_inferior ())
return;
- (*current_target.to_terminal_ours_for_output) (¤t_target);
- terminal_state = terminal_is_ours_for_output;
+
+ target_terminal_is_ours_kind (target_terminal_state::is_ours_for_output);
+ target_terminal::m_terminal_state = target_terminal_state::is_ours_for_output;
}
/* See target/target.h. */
/* See target.h. */
-char *
+gdb::optional<std::string>
target_fileio_readlink (struct inferior *inf, const char *filename,
int *target_errno)
{
{
if (t->to_fileio_readlink != NULL)
{
- char *ret = t->to_fileio_readlink (t, inf, filename,
- target_errno);
+ gdb::optional<std::string> ret
+ = t->to_fileio_readlink (t, inf, filename, target_errno);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_fileio_readlink (%d,%s)"
" = %s (%d)\n",
inf == NULL ? 0 : inf->num,
- filename, ret? ret : "(nil)",
- ret? 0 : *target_errno);
+ filename, ret ? ret->c_str () : "(nil)",
+ ret ? 0 : *target_errno);
return ret;
}
}
*target_errno = FILEIO_ENOSYS;
- return NULL;
+ return {};
}
-static void
-target_fileio_close_cleanup (void *opaque)
+/* Like scoped_fd, but specific to target fileio. */
+
+class scoped_target_fd
{
- int fd = *(int *) opaque;
- int target_errno;
+public:
+ explicit scoped_target_fd (int fd) noexcept
+ : m_fd (fd)
+ {
+ }
- target_fileio_close (fd, &target_errno);
-}
+ ~scoped_target_fd ()
+ {
+ if (m_fd >= 0)
+ {
+ int target_errno;
+
+ target_fileio_close (m_fd, &target_errno);
+ }
+ }
+
+ DISABLE_COPY_AND_ASSIGN (scoped_target_fd);
+
+ int get () const noexcept
+ {
+ return m_fd;
+ }
+
+private:
+ int m_fd;
+};
/* Read target file FILENAME, in the filesystem as seen by INF. If
INF is NULL, use the filesystem seen by the debugger (GDB or, for
target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
gdb_byte **buf_p, int padding)
{
- struct cleanup *close_cleanup;
size_t buf_alloc, buf_pos;
gdb_byte *buf;
LONGEST n;
- int fd;
int target_errno;
- fd = target_fileio_open (inf, filename, FILEIO_O_RDONLY, 0700,
- &target_errno);
- if (fd == -1)
+ scoped_target_fd fd (target_fileio_open (inf, filename, FILEIO_O_RDONLY,
+ 0700, &target_errno));
+ if (fd.get () == -1)
return -1;
- close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
-
/* Start by reading up to 4K at a time. The target will throttle
this number down if necessary. */
buf_alloc = 4096;
buf_pos = 0;
while (1)
{
- n = target_fileio_pread (fd, &buf[buf_pos],
+ n = target_fileio_pread (fd.get (), &buf[buf_pos],
buf_alloc - buf_pos - padding, buf_pos,
&target_errno);
if (n < 0)
{
/* An error occurred. */
- do_cleanups (close_cleanup);
xfree (buf);
return -1;
}
else if (n == 0)
{
/* Read all there was. */
- do_cleanups (close_cleanup);
if (buf_pos == 0)
xfree (buf);
else
}
void
-target_interrupt (ptid_t ptid)
+target_interrupt ()
{
if (!may_stop)
{
return;
}
- (*current_target.to_interrupt) (¤t_target, ptid);
+ (*current_target.to_interrupt) (¤t_target);
}
/* See target.h. */
void
default_target_pass_ctrlc (struct target_ops *ops)
{
- target_interrupt (inferior_ptid);
+ target_interrupt ();
}
/* See target/target.h. */
/* See target.h. */
-int
-target_supports_btrace (enum btrace_format format)
-{
- return current_target.to_supports_btrace (¤t_target, format);
-}
-
-/* See target.h. */
-
struct btrace_target_info *
target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
{
/* See target.h. */
void
-target_call_history (int size, int flags)
+target_call_history (int size, record_print_flags flags)
{
current_target.to_call_history (¤t_target, size, flags);
}
/* See target.h. */
void
-target_call_history_from (ULONGEST begin, int size, int flags)
+target_call_history_from (ULONGEST begin, int size, record_print_flags flags)
{
current_target.to_call_history_from (¤t_target, begin, size, flags);
}
/* See target.h. */
void
-target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
+target_call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
{
current_target.to_call_history_range (¤t_target, begin, end, flags);
}