static TACommandVerdict def_shell_mode_cmd(TAThread thread, TAInputStream stream)
{
// Prepare
int res;
START_TARGET_OPERATION(thread);
// Execute
res = def_shell_mode();
END_TARGET_OPERATION(thread);
// Response
writeInt(thread, res);
sendResponse(thread);
return taDefaultVerdict;
}
/* Enter in the tui mode (curses).
When in normal mode, it installs the tui hooks in gdb, redirects
the gdb output, configures the readline to work in tui mode.
When in curses mode, it does nothing. */
void
tui_enable (void)
{
if (tui_active)
return;
/* To avoid to initialize curses when gdb starts, there is a defered
curses initialization. This initialization is made only once
and the first time the curses mode is entered. */
if (tui_finish_init)
{
WINDOW *w;
w = initscr ();
cbreak ();
noecho ();
/*timeout (1);*/
nodelay(w, FALSE);
nl();
keypad (w, TRUE);
rl_initialize ();
tui_set_term_height_to (LINES);
tui_set_term_width_to (COLS);
def_prog_mode ();
tui_show_frame_info (0);
tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
tui_set_win_focus_to (TUI_SRC_WIN);
keypad (TUI_CMD_WIN->generic.handle, TRUE);
wrefresh (TUI_CMD_WIN->generic.handle);
tui_finish_init = 0;
}
else
{
/* Save the current gdb setting of the terminal.
Curses will restore this state when endwin() is called. */
def_shell_mode ();
clearok (stdscr, TRUE);
}
/* Install the TUI specific hooks. */
tui_install_hooks ();
rl_startup_hook = tui_rl_startup_hook;
tui_update_variables ();
tui_setup_io (1);
tui_active = 1;
if (deprecated_selected_frame)
tui_show_frame_info (deprecated_selected_frame);
/* Restore TUI keymap. */
tui_set_key_mode (tui_current_key_mode);
tui_refresh_all_win ();
/* Update gdb's knowledge of its terminal. */
target_terminal_save_ours ();
tui_update_gdb_sizes ();
}
WINDOW *Xinitscr(int argc, char *argv[])
{
int i;
PDC_LOG(("Xinitscr() - called\n"));
if (SP && SP->alive)
return NULL;
if (PDC_scr_open(argc, argv) == ERR)
{
fprintf(stderr, "initscr(): Unable to create SP\n");
exit(8);
}
SP->autocr = TRUE; /* cr -> lf by default */
SP->raw_out = FALSE; /* tty I/O modes */
SP->raw_inp = FALSE; /* tty I/O modes */
SP->cbreak = TRUE;
SP->save_key_modifiers = FALSE;
SP->return_key_modifiers = FALSE;
SP->echo = TRUE;
SP->visibility = 1;
SP->resized = FALSE;
SP->_trap_mbe = 0L;
SP->_map_mbe_to_key = 0L;
SP->linesrippedoff = 0;
SP->linesrippedoffontop = 0;
SP->delaytenths = 0;
SP->line_color = -1;
SP->orig_cursor = PDC_get_cursor_mode();
LINES = SP->lines;
COLS = SP->cols;
if (LINES < 2 || COLS < 2)
{
fprintf(stderr, "initscr(): LINES=%d COLS=%d: too small.\n",
LINES, COLS);
exit(4);
}
if ((curscr = newwin(LINES, COLS, 0, 0)) == (WINDOW *)NULL)
{
fprintf(stderr, "initscr(): Unable to create curscr.\n");
exit(2);
}
if ((pdc_lastscr = newwin(LINES, COLS, 0, 0)) == (WINDOW *)NULL)
{
fprintf(stderr, "initscr(): Unable to create pdc_lastscr.\n");
exit(2);
}
wattrset(pdc_lastscr, (chtype)(-1));
werase(pdc_lastscr);
PDC_slk_initialize();
LINES -= SP->slklines;
/* We have to sort out ripped off lines here, and reduce the height
of stdscr by the number of lines ripped off */
for (i = 0; i < linesrippedoff; i++)
{
if (linesripped[i].line < 0)
(*linesripped[i].init)(newwin(1, COLS, LINES - 1, 0), COLS);
else
(*linesripped[i].init)(newwin(1, COLS,
SP->linesrippedoffontop++, 0), COLS);
SP->linesrippedoff++;
LINES--;
}
linesrippedoff = 0;
if (!(stdscr = newwin(LINES, COLS, SP->linesrippedoffontop, 0)))
{
fprintf(stderr, "initscr(): Unable to create stdscr.\n");
exit(1);
}
wclrtobot(stdscr);
/* If preserving the existing screen, don't allow a screen clear */
if (SP->_preserve)
{
untouchwin(curscr);
untouchwin(stdscr);
stdscr->_clear = FALSE;
curscr->_clear = FALSE;
}
else
curscr->_clear = TRUE;
PDC_init_atrtab(); /* set up default colors */
MOUSE_X_POS = MOUSE_Y_POS = -1;
BUTTON_STATUS(1) = BUTTON_RELEASED;
BUTTON_STATUS(2) = BUTTON_RELEASED;
BUTTON_STATUS(3) = BUTTON_RELEASED;
Mouse_status.changes = 0;
SP->alive = TRUE;
def_shell_mode();
sprintf(ttytype, "pdcurses|PDCurses for %s", PDC_sysname());
return stdscr;
}
/*
* Set up terminal.
*
* Reads in the terminfo database pointed to by $TERMINFO env. var.
* for the given terminal, but does not set up the output virtualization
* structues used by CURSES. If the terminal name pointer is NULL,
* the $TERM env. var. is used for the terminal. All output is to
* the given file descriptor which is initialized for output.
*
* On error, if errret != NULL then setupterm() returns OK
* or ERR and stores a status value in the integer pointed to by
* errret. A status of 1 is normal, 0 means the terminal could
* not be found, and -1 means the terminfo database could not be
* found. If errret == NULL then setupterm() prints an error
* message upon and exit().
*
* On success, cur_term set to a terminfo structure and OK returned.
*/
int
__m_setupterm(char *termname, int ifd, int ofd, int *err_return)
{
int err_code = 1;
TERMINAL *old_term;
const char *err_msg;
/*
* It is possible to call setupterm() for multiple terminals,
* in which case we have to be able to restore cur_term in
* case of error.
*/
old_term = cur_term;
cur_term = (TERMINAL *) calloc(1, sizeof (*cur_term));
if (cur_term == NULL) {
err_code = -1;
goto error;
}
if (isatty(cur_term->_ifd = ifd))
cur_term->_flags |= __TERM_ISATTY_IN;
if (isatty(cur_term->_ofd = ofd))
cur_term->_flags |= __TERM_ISATTY_OUT;
cur_term->_shell = (void *) calloc(1, sizeof (struct termios));
cur_term->_prog = (void *) calloc(1, sizeof (struct termios));
cur_term->_save = (void *) calloc(1, sizeof (struct termios));
cur_term->_actual = (void *) calloc(1, sizeof (struct termios));
cur_term->_term = NULL;
cur_term->_names = NULL;
cur_term->_str_table = NULL;
(void) def_shell_mode();
(void) def_prog_mode();
(void) __m_tty_get(PTERMIOS(_actual)); /* Synch cached value */
#ifdef ONLCR
if ((PTERMIOS(_prog)->c_oflag & (OPOST | ONLCR)) == (OPOST | ONLCR))
#else
if (PTERMIOS(_prog)->c_oflag & OPOST)
#endif
cur_term->_flags |= __TERM_NL_IS_CRLF;
(void) restartterm(termname, ofd, &err_code);
error:
switch (err_code) {
case -1:
err_msg = e_terminal;
break;
case 0:
err_msg = e_unknown;
break;
case 1:
break;
case 2:
err_msg = e_pathmax;
err_code = -1;
break;
}
if (err_return != NULL) {
*err_return = err_code;
if (err_code == 1) {
err_code = OK;
} else {
err_code = ERR;
free(cur_term);
cur_term = old_term;
}
} else if (err_code != 1) {
(void) fprintf(stderr, err_msg, termname);
exit(1);
}
return (err_code);
}
static void
tstp(int dummy GCC_UNUSED)
{
sigset_t mask, omask;
sigaction_t act, oact;
#ifdef SIGTTOU
int sigttou_blocked;
#endif
T(("tstp() called"));
/*
* The user may have changed the prog_mode tty bits, so save them.
*
* But first try to detect whether we still are in the foreground
* process group - if not, an interactive shell may already have
* taken ownership of the tty and modified the settings when our
* parent was stopped before us, and we would likely pick up the
* settings already modified by the shell.
*/
if (SP != 0 && !SP->_endwin) /* don't do this if we're not in curses */
#if HAVE_TCGETPGRP
if (tcgetpgrp(STDIN_FILENO) == getpgrp())
#endif
def_prog_mode();
/*
* Block window change and timer signals. The latter
* is because applications use timers to decide when
* to repaint the screen.
*/
(void) sigemptyset(&mask);
(void) sigaddset(&mask, SIGALRM);
#if USE_SIGWINCH
(void) sigaddset(&mask, SIGWINCH);
#endif
(void) sigprocmask(SIG_BLOCK, &mask, &omask);
#ifdef SIGTTOU
sigttou_blocked = sigismember(&omask, SIGTTOU);
if (!sigttou_blocked) {
(void) sigemptyset(&mask);
(void) sigaddset(&mask, SIGTTOU);
(void) sigprocmask(SIG_BLOCK, &mask, NULL);
}
#endif
/*
* End window mode, which also resets the terminal state to the
* original (pre-curses) modes.
*/
endwin();
/* Unblock SIGTSTP. */
(void) sigemptyset(&mask);
(void) sigaddset(&mask, SIGTSTP);
#ifdef SIGTTOU
if (!sigttou_blocked) {
/* Unblock this too if it wasn't blocked on entry */
(void) sigaddset(&mask, SIGTTOU);
}
#endif
(void) sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Now we want to resend SIGSTP to this process and suspend it */
act.sa_handler = SIG_DFL;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
#ifdef SA_RESTART
act.sa_flags |= SA_RESTART;
#endif /* SA_RESTART */
sigaction(SIGTSTP, &act, &oact);
kill(getpid(), SIGTSTP);
/* Process gets suspended...time passes...process resumes */
T(("SIGCONT received"));
sigaction(SIGTSTP, &oact, NULL);
flushinp();
/*
* If the user modified the tty state while suspended, he wants
* those changes to stick. So save the new "default" terminal state.
*/
def_shell_mode();
/*
* This relies on the fact that doupdate() will restore the
* program-mode tty state, and issue enter_ca_mode if need be.
*/
doupdate();
/* Reset the signals. */
(void) sigprocmask(SIG_SETMASK, &omask, NULL);
}
static void tstp(int dummy GCC_UNUSED)
{
sigset_t mask, omask;
sigaction_t act, oact;
T(("tstp() called"));
/*
* The user may have changed the prog_mode tty bits, so save them.
*/
def_prog_mode();
/*
* Block window change and timer signals. The latter
* is because applications use timers to decide when
* to repaint the screen.
*/
(void)sigemptyset(&mask);
(void)sigaddset(&mask, SIGALRM);
#if USE_SIGWINCH
(void)sigaddset(&mask, SIGWINCH);
#endif
(void)sigprocmask(SIG_BLOCK, &mask, &omask);
/*
* End window mode, which also resets the terminal state to the
* original (pre-curses) modes.
*/
endwin();
/* Unblock SIGTSTP. */
(void)sigemptyset(&mask);
(void)sigaddset(&mask, SIGTSTP);
(void)sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Now we want to resend SIGSTP to this process and suspend it */
act.sa_handler = SIG_DFL;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
#ifdef SA_RESTART
act.sa_flags |= SA_RESTART;
#endif /* SA_RESTART */
sigaction(SIGTSTP, &act, &oact);
kill(getpid(), SIGTSTP);
/* Process gets suspended...time passes...process resumes */
T(("SIGCONT received"));
sigaction(SIGTSTP, &oact, NULL);
flushinp();
/*
* If the user modified the tty state while suspended, he wants
* those changes to stick. So save the new "default" terminal state.
*/
def_shell_mode();
/*
* This relies on the fact that doupdate() will restore the
* program-mode tty state, and issue enter_ca_mode if need be.
*/
doupdate();
/* Reset the signals. */
(void)sigprocmask(SIG_SETMASK, &omask, NULL);
}