FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* tuiIO.h: Remove old declarations and add the new ones.

Browse source 
* tuiIO.c: New management for curses and gdb terminal interactions.
        (tui_tputs): Remove.
        (tuiTermSetup, tuiTermUnsetup): Remove, must use normal curses ops.
        (tuiBufferGetc, tui_vStartNewLines, _updateCommandInfo): Remove.
        (tui_owns_terminal): Remove.
        (tui_redisplay_readline): New function.
        (tui_puts): New function.
        (tui_prep_terminal): New function.
        (tui_deprep_terminal): New function.
        (tui_getc): Rename of tuiGetc, simplify and fix.
        (tui_setup_io): New function.
        (tui_initialize_io): New function.
This commit is contained in:
Stephane Carrez 2001-07-21 19:56:54 +00:00
parent fea1470223
commit a198b876bb
3 changed files with 341 additions and 559 deletions
Download patch file Download diff file Expand all files Collapse all files

16
gdb/tui/ChangeLog
View file

@ -1,3 +1,19 @@
2001-07-21 Stephane Carrez <Stephane.Carrez@worldnet.fr>
* tuiIO.h: Remove old declarations and add the new ones.
* tuiIO.c: New management for curses and gdb terminal interactions.
(tui_tputs): Remove.
(tuiTermSetup, tuiTermUnsetup): Remove, must use normal curses ops.
(tuiBufferGetc, tui_vStartNewLines, _updateCommandInfo): Remove.
(tui_owns_terminal): Remove.
(tui_redisplay_readline): New function.
(tui_puts): New function.
(tui_prep_terminal): New function.
(tui_deprep_terminal): New function.
(tui_getc): Rename of tuiGetc, simplify and fix.
(tui_setup_io): New function.
(tui_initialize_io): New function.
2001-07-21 Stephane Carrez <Stephane.Carrez@worldnet.fr> 2001-07-21 Stephane Carrez <Stephane.Carrez@worldnet.fr>
* tuiRegs.c (tuiDisplayRegistersFrom): Call touchwin. * tuiRegs.c (tuiDisplayRegistersFrom): Call touchwin.

861
gdb/tui/tuiIO.c
View file

@ -22,618 +22,383 @@
#include <stdio.h> #include <stdio.h>
#include "defs.h" #include "defs.h"
#include "terminal.h" #include "terminal.h"
#include "target.h"
#include "event-loop.h"
#include "command.h"
#include "top.h"
#include "readline/readline.h"
#include "tui.h" #include "tui.h"
#include "tuiData.h" #include "tuiData.h"
#include "tuiIO.h" #include "tuiIO.h"
#include "tuiCommand.h" #include "tuiCommand.h"
#include "tuiWin.h" #include "tuiWin.h"
#include "tuiGeneralWin.h"
#include "tui-file.h"
#include "ui-out.h"
#include "cli-out.h"
#include <fcntl.h>
#include <stdarg.h> /* This file controls the IO interactions between gdb and curses.
When the TUI is enabled, gdb has two modes a curses and a standard
mode.
/* The Solaris header files seem to provide no declaration for this at In curses mode, the gdb outputs are made in a curses command window.
all when __STDC__ is defined. This shouldn't conflict with For this, the gdb_stdout and gdb_stderr are redirected to the specific
anything. */ ui_file implemented by TUI. The output is handled by tui_puts().
extern char *tgoto (); The input is also controlled by curses with tui_getc(). The readline
library uses this function to get its input. Several readline hooks
are installed to redirect readline output to the TUI (see also the
note below).
int insert_mode = 0; In normal mode, the gdb outputs are restored to their origin, that
is as if TUI is not used. Readline also uses its original getc()
function with stdin.
Note: the current readline is not clean in its management of the output.
Even if we install a redisplay handler, it sometimes writes on a stdout
file. It is important to redirect every output produced by readline,
otherwise the curses window will be garbled. This is implemented with
a pipe that TUI reads and readline writes to. A gdb input handler
is created so that reading the pipe is handled automatically.
This will probably not work on non-Unix platforms. The best fix is
to make readline clean enougth so that is never write on stdout. */
/* TUI output files. */
static struct ui_file *tui_stdout;
static struct ui_file *tui_stderr;
static struct ui_out *tui_out;
/* GDB output files in non-curses mode. */
static struct ui_file *tui_old_stdout;
static struct ui_file *tui_old_stderr;
static struct ui_out *tui_old_uiout;
/* Readline previous hooks. */
static Function *tui_old_rl_getc_function;
static VFunction *tui_old_rl_redisplay_function;
static VFunction *tui_old_rl_prep_terminal;
static VFunction *tui_old_rl_deprep_terminal;
static int tui_old_readline_echoing_p;
/* Readline output stream.
Should be removed when readline is clean. */
static FILE *tui_rl_outstream;
static FILE *tui_old_rl_outstream;
static int tui_readline_pipe[2];
/********************************************
** LOCAL STATIC FORWARD DECLS **
********************************************/
static void _updateCommandInfo (int);
static unsigned int _tuiHandleResizeDuringIO (unsigned int); static unsigned int _tuiHandleResizeDuringIO (unsigned int);
/********************************************************************************* /* Print the string in the curses command window. */
** PUBLIC FUNCTIONS **
*********************************************************************************/
/*
** tuiPuts_unfiltered().
** Function to put a string to the command window
** When running in TUI mode, this is the "hook"
** for fputs_unfiltered(). That is, all debugger
** output eventually makes it's way to the bottom-level
** routine fputs_unfiltered (main.c), which (in TUI
** mode), calls tuiPuts_unfiltered().
*/
void void
tuiPuts_unfiltered (const char *string, struct ui_file * stream) tui_puts (const char *string)
{ {
int len = strlen (string); static int tui_skip_line = -1;
int i, linech; char c;
WINDOW *w;
for (i = 0; i < len; i++) w = cmdWin->generic.handle;
while ((c = *string++) != 0)
{ {
if (string[i] == '\n' || string[i] == '\r') /* Catch annotation and discard them. We need two \032 and
m_tuiStartNewLine; discard until a \n is seen. */
if (c == '\032')
{
tui_skip_line++;
}
else if (tui_skip_line != 1)
{
tui_skip_line = -1;
waddch (w, c);
}
else if (c == '\n')
tui_skip_line = -1;
}
getyx (w, cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
/* We could defer the following. */
wrefresh (w);
fflush (stdout);
}
/* Readline callback.
Redisplay the command line with its prompt after readline has
changed the edited text. */
static void
tui_redisplay_readline (void)
{
int prev_col;
int height;
int col, line;
int c_pos;
int c_line;
int in;
WINDOW *w;
char *prompt;
int start_line;
prompt = get_prompt ();
c_pos = -1;
c_line = -1;
w = cmdWin->generic.handle;
start_line = cmdWin->detail.commandInfo.curLine;
wmove (w, start_line, 0);
prev_col = 0;
height = 1;
for (in = 0; prompt && prompt[in]; in++)
{
waddch (w, prompt[in]);
getyx (w, line, col);
if (col < prev_col)
height++;
prev_col = col;
}
for (in = 0; in < rl_end; in++)
{
unsigned char c;
c = (unsigned char) rl_line_buffer[in];
if (in == rl_point)
{
getyx (w, c_line, c_pos);
}
if (CTRL_CHAR (c) || c == RUBOUT)
{
waddch (w, '^');
waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
}
else else
{ {
if ((cmdWin->detail.commandInfo.curch + 1) > cmdWin->generic.width) waddch (w, c);
m_tuiStartNewLine;
if (insert_mode)
{
mvwinsch (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch++,
string[i]);
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
}
else
mvwaddch (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch++,
string[i]);
} }
if (c == '\n')
{
getyx (w, cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
}
getyx (w, line, col);
if (col < prev_col)
height++;
prev_col = col;
} }
tuiRefreshWin (&cmdWin->generic); wclrtobot (w);
getyx (w, cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
if (c_line >= 0)
wmove (w, c_line, c_pos);
return; cmdWin->detail.commandInfo.curLine -= height - 1;
} /* tuiPuts_unfiltered */
/* A cover routine for tputs(). wrefresh (w);
* tputs() is called from the readline package to put fflush(stdout);
* out strings representing cursor positioning. }
* In TUI mode (non-XDB-style), tui_tputs() is called instead.
* /* Readline callback to prepare the terminal. It is called once
* The reason we need to hook tputs() is: each time we enter readline. There is nothing to do in curses mode. */
* Since the output is going to curses and not to static void
* a raw terminal, we need to intercept these special tui_prep_terminal (void)
* sequences, and handle them them here.
*
* This function seems to be correctly handling all sequences
* aimed at hpterm's, but there is additional work to do
* for xterm's and dtterm's. I abandoned further work on this
* in favor of "XDB style". In "XDB style", the command region
* looks like terminal, not a curses window, and this routine
* is not called. - RT
*/
void
tui_tputs (str, affcnt, putfunc)
char *str;
int affcnt;
int (*putfunc) (int);
{ {
extern char *rl_prompt; /* the prompt string */ }
/* This set of globals are defined and initialized /* Readline callback to restore the terminal. It is called once
* by the readline package. each time we leave readline. There is nothing to do in curses mode. */
* static void
* Note we're assuming tui_tputs() is being called tui_deprep_terminal (void)
* by the readline package. That's because we're recognizing {
* that a given string is being passed by }
* matching the string address against readline's
* term_<whatever> global. To make this more general,
* we'd have to actually recognize the termcap sequence
* inside the string (more work than I want to do). - RT
*
* We don't see or need to handle every one of these here;
* this is just the full list defined in readline/readline.c
*/
extern char *term_backspace;
extern char *term_clreol;
extern char *term_clrpag;
extern char *term_cr;
extern char *term_dc;
extern char *term_ei;
extern char *term_goto;
extern char *term_ic;
extern char *term_im;
extern char *term_mm;
extern char *term_mo;
extern char *term_up;
extern char *term_scroll_region;
extern char *term_memory_lock;
extern char *term_memory_unlock;
extern char *term_cursor_move;
extern char *visible_bell;
/* Sanity check - if not TUI, just call tputs() */ /* Read readline output pipe and feed the command window with it.
if (!tui_version) Should be removed when readline is clean. */
tputs (str, affcnt, putfunc); static void
tui_readline_output (int code, gdb_client_data data)
{
int size;
char buf[256];
/* The strings we special-case are handled first */ size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
if (size > 0 && tui_active)
if (str == term_backspace)
{ {
/* Backspace. */ buf[size] = 0;
tui_puts (buf);
/* We see this on an emacs control-B.
* I.e., it's like the left-arrow key (not like the backspace key).
* The effect that readline wants when it transmits this
* character to us is simply to back up one character
* (but not to write a space over the old character).
*/
_updateCommandInfo (-1);
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
wrefresh (cmdWin->generic.handle);
} }
else if (str == term_clreol) }
/* Setup the IO for curses or non-curses mode.
- In non-curses mode, readline and gdb use the standard input and
standard output/error directly.
- In curses mode, the standard output/error is controlled by TUI
with the tui_stdout and tui_stderr. The output is redirected in
the curses command window. Several readline callbacks are installed
so that readline asks for its input to the curses command window
with wgetch(). */
void
tui_setup_io (int mode)
{
extern int readline_echoing_p;
if (mode)
{ {
/* Redirect readline to TUI. */
tui_old_rl_redisplay_function = rl_redisplay_function;
tui_old_rl_deprep_terminal = rl_deprep_term_function;
tui_old_rl_prep_terminal = rl_prep_term_function;
tui_old_rl_getc_function = rl_getc_function;
tui_old_rl_outstream = rl_outstream;
tui_old_readline_echoing_p = readline_echoing_p;
rl_redisplay_function = tui_redisplay_readline;
rl_deprep_term_function = tui_deprep_terminal;
rl_prep_term_function = tui_prep_terminal;
rl_getc_function = tui_getc;
readline_echoing_p = 0;
rl_outstream = tui_rl_outstream;
rl_prompt = 0;
/* Clear to end of line. */ /* Keep track of previous gdb output. */
wclrtoeol (cmdWin->generic.handle); tui_old_stdout = gdb_stdout;
wrefresh (cmdWin->generic.handle); tui_old_stderr = gdb_stderr;
tui_old_uiout = uiout;
} /* Reconfigure gdb output. */
else if (str == term_cr) gdb_stdout = tui_stdout;
{ gdb_stderr = tui_stderr;
gdb_stdlog = gdb_stdout; /* for moment */
/* Carriage return */ gdb_stdtarg = gdb_stderr; /* for moment */
_updateCommandInfo (-cmdWin->detail.commandInfo.curch); uiout = tui_out;
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
0 /* readline will rewrite the prompt from 0 */ );
wrefresh (cmdWin->generic.handle);
}
else if (str == term_goto)
{
/* This is actually a tgoto() specifying a character position,
* followed by either a term_IC/term_DC which [I think] means
* insert/delete one character at that position.
* There are complications with this one - need to either
* extract the position from the string, or have a backdoor
* means of communicating it from ../readline/display.c.
* So this one is not yet implemented.
* Not doing it seems to have no ill effects on command-line-editing
* that I've noticed so far. - RT
*/
}
else if (str == term_dc)
{
/* Delete character at current cursor position */
wdelch (cmdWin->generic.handle);
wrefresh (cmdWin->generic.handle);
}
else if (str == term_im)
{
/* Turn on insert mode. */
insert_mode = 1;
}
else if (str == term_ei)
{
/* Turn off insert mode. */
insert_mode = 0;
/* Strings we know about but don't handle
* specially here are just passed along to tputs().
*
* These are not handled because (as far as I can tell)
* they are not actually emitted by the readline package
* in the course of doing command-line editing. Some of them
* theoretically could be used in the future, in which case we'd
* need to handle them.
*/
}
else if (str == term_ic || /* insert character */
str == term_cursor_move || /* cursor move */
str == term_clrpag || /* clear page */
str == term_mm || /* turn on meta key */
str == term_mo || /* turn off meta key */
str == term_up || /* up one line (not expected) */
str == term_scroll_region || /* set scroll region */
str == term_memory_lock || /* lock screen above cursor */
str == term_memory_unlock || /* unlock screen above cursor */
str == visible_bell)
{ /* flash screen */
tputs (str, affcnt, putfunc);
} }
else else
{ /* something else */ {
tputs (str, affcnt, putfunc); /* Restore gdb output. */
gdb_stdout = tui_old_stdout;
gdb_stderr = tui_old_stderr;
gdb_stdlog = gdb_stdout; /* for moment */
gdb_stdtarg = gdb_stderr; /* for moment */
uiout = tui_old_uiout;
/* Restore readline. */
rl_redisplay_function = tui_old_rl_redisplay_function;
rl_deprep_term_function = tui_old_rl_deprep_terminal;
rl_prep_term_function = tui_old_rl_prep_terminal;
rl_getc_function = tui_old_rl_getc_function;
rl_outstream = tui_old_rl_outstream;
readline_echoing_p = tui_old_readline_echoing_p;
} }
} /* tui_tputs */ }
/* Initialize the IO for gdb in curses mode. */
/* void
** tui_vwgetch() tui_initialize_io ()
** Wrapper around wgetch with the window in a va_list
*/
unsigned int
tui_vwgetch (va_list args)
{ {
unsigned int ch; /* Create tui output streams. */
WINDOW *window; tui_stdout = tui_fileopen (stdout);
tui_stderr = tui_fileopen (stderr);
tui_out = tui_out_new (tui_stdout);
window = va_arg (args, WINDOW *); /* Create the default UI. It is not created because we installed
a init_ui_hook. */
uiout = cli_out_new (gdb_stdout);
return ((unsigned int) wgetch (window)); /* Temporary solution for readline writing to stdout:
} /* tui_vwgetch */ redirect readline output in a pipe, read that pipe and
output the content in the curses command window. */
if (pipe (tui_readline_pipe) != 0)
{
fprintf_unfiltered (gdb_stderr, "Cannot create pipe for readline");
exit (1);
}
tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
if (tui_rl_outstream == 0)
{
fprintf_unfiltered (gdb_stderr, "Cannot redirect readline output");
exit (1);
}
setlinebuf (tui_rl_outstream);
#ifdef O_NONBLOCK
/* (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
** tuiGetc().
** Get a character from the command window.
** This is called from the readline package,
** that is, we have:
** tuiGetc() [here], called from
** readline code [in ../readline/], called from
** command_line_input() in top.c
*/
unsigned int
tuiGetc (void)
{
unsigned int ch;
extern char *rl_prompt;
extern char *rl_line_buffer;
extern int rl_point;
/* Call the curses routine that reads one character */
#ifndef COMMENT
ch = (unsigned int) vcatch_errors ((OpaqueFuncPtr) tui_vwgetch,
cmdWin->generic.handle);
#else #else
ch = wgetch (cmdWin->generic.handle); #ifdef O_NDELAY
(void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
#endif #endif
#endif
add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
}
/* Get a character from the command window. This is called from the readline
package. */
int
tui_getc (FILE *fp)
{
int ch;
WINDOW *w;
w = cmdWin->generic.handle;
/* Flush readline output. */
tui_readline_output (GDB_READABLE, 0);
ch = wgetch (w);
ch = _tuiHandleResizeDuringIO (ch); ch = _tuiHandleResizeDuringIO (ch);
/* The \n must be echoed because it will not be printed by readline. */
if (ch == '\n')
{
/* When hitting return with an empty input, gdb executes the last
command. If we emit a newline, this fills up the command window
with empty lines with gdb prompt at beginning. Instead of that,
stay on the same line but provide a visual effect to show the
user we recognized the command. */
if (rl_end == 0)
{
wmove (w, cmdWin->detail.commandInfo.curLine, 0);
/* Clear the line. This will blink the gdb prompt since
it will be redrawn at the same line. */
wclrtoeol (w);
wrefresh (w);
napms (20);
}
else
{
wmove (w, cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
waddch (w, ch);
}
}
if (m_isCommandChar (ch)) if (m_isCommandChar (ch))
{ /* Handle prev/next/up/down here */ { /* Handle prev/next/up/down here */
tuiTermSetup (0);
ch = tuiDispatchCtrlChar (ch); ch = tuiDispatchCtrlChar (ch);
cmdWin->detail.commandInfo.curch = strlen (rl_prompt) + rl_point;
tuiTermUnsetup (0, cmdWin->detail.commandInfo.curch);
} }
if (ch == '\n' || ch == '\r' || ch == '\f') if (ch == '\n' || ch == '\r' || ch == '\f')
cmdWin->detail.commandInfo.curch = 0; cmdWin->detail.commandInfo.curch = 0;
#if 0
else else
tuiIncrCommandCharCountBy (1); tuiIncrCommandCharCountBy (1);
#endif
if (ch == KEY_BACKSPACE)
return '\b';
return ch; return ch;
} /* tuiGetc */ }
/* /* Cleanup when a resize has occured.
** tuiBufferGetc(). Returns the character that must be processed. */
*/
/*elz: this function reads a line of input from the user and
puts it in a static buffer. Subsequent calls to this same function
obtain one char at the time, providing the caller with a behavior
similar to fgetc. When the input is buffered, the backspaces have
the needed effect, i.e. ignore the last char active in the buffer */
/* so far this function is called only from the query function in
utils.c */
unsigned int
tuiBufferGetc (void)
{
unsigned int ch;
static unsigned char _ibuffer[512];
static int index_read = -1;
static int length_of_answer = -1;
int pos = 0;
if (length_of_answer == -1)
{
/* this is the first time through, need to read the answer */
do
{
/* Call the curses routine that reads one character */
ch = (unsigned int) wgetch (cmdWin->generic.handle);
if (ch != '\b')
{
_ibuffer[pos] = ch;
pos++;
}
else
pos--;
}
while (ch != '\r' && ch != '\n');
length_of_answer = pos;
index_read = 0;
}
ch = _ibuffer[index_read];
index_read++;
if (index_read == length_of_answer)
{
/*this is the last time through, reset for next query */
index_read = -1;
length_of_answer = -1;
}
wrefresh (cmdWin->generic.handle);
return (ch);
} /* tuiBufferGetc */
/*
** tuiStartNewLines().
*/
void
tuiStartNewLines (int numLines)
{
if (numLines > 0)
{
if (cmdWin->generic.viewportHeight > 1 &&
cmdWin->detail.commandInfo.curLine < cmdWin->generic.viewportHeight)
cmdWin->detail.commandInfo.curLine += numLines;
else
scroll (cmdWin->generic.handle);
cmdWin->detail.commandInfo.curch = 0;
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
tuiRefreshWin (&cmdWin->generic);
}
return;
} /* tuiStartNewLines */
/*
** tui_vStartNewLines().
** With numLines in a va_list
*/
void
tui_vStartNewLines (va_list args)
{
int numLines = va_arg (args, int);
tuiStartNewLines (numLines);
return;
} /* tui_vStartNewLines */
/****************************************************************************
** LOCAL STATIC FUNCTIONS **
*****************************************************************************/
/*
** _tuiHandleResizeDuringIO
** This function manages the cleanup when a resize has occured
** From within a call to getch() or read. Returns the character
** to return from getc or read.
*/
static unsigned int static unsigned int
_tuiHandleResizeDuringIO (unsigned int originalCh) _tuiHandleResizeDuringIO (unsigned int originalCh)
/* the char just read */
{ {
if (tuiWinResized ()) if (tuiWinResized ())
{ {
tuiRefreshAll (); tuiRefreshAll ();
dont_repeat (); dont_repeat ();
tuiSetWinResizedTo (FALSE); tuiSetWinResizedTo (FALSE);
rl_reset ();
return '\n'; return '\n';
} }
else else
return originalCh; return originalCh;
} /* _tuiHandleResizeDuringIO */ }
/*
** _updateCommandInfo().
** Function to update the command window information.
*/
static void
_updateCommandInfo (int sizeOfString)
{
if ((sizeOfString +
cmdWin->detail.commandInfo.curch) > cmdWin->generic.width)
{
int newCurch = sizeOfString + cmdWin->detail.commandInfo.curch;
tuiStartNewLines (1);
cmdWin->detail.commandInfo.curch = newCurch - cmdWin->generic.width;
}
else
cmdWin->detail.commandInfo.curch += sizeOfString;
return;
} /* _updateCommandInfo */
/* Looked at in main.c, fputs_unfiltered(), to decide
* if it's safe to do standard output to the command window.
*/
int tui_owns_terminal = 0;
/* Called to set up the terminal for TUI (curses) I/O.
* We do this either on our way "in" to GDB after target
* program execution, or else within tuiDo just before
* going off to TUI routines.
*/
void
tuiTermSetup (int turn_off_echo)
{
char *buffer;
int start;
int end;
int endcol;
extern char *term_scroll_region;
extern char *term_cursor_move;
extern char *term_memory_lock;
extern char *term_memory_unlock;
/* Turn off echoing, since the TUI does not
* expect echoing. Below I only put in the TERMIOS
* case, since that is what applies on HP-UX. turn_off_echo
* is 1 except for the case where we're being called
* on a "quit", in which case we want to leave echo on.
*/
if (turn_off_echo)
{
#ifdef HAVE_TERMIOS
struct termios tio;
tcgetattr (0, &tio);
tio.c_lflag &= ~(ECHO);
tcsetattr (0, TCSANOW, &tio);
#endif
}
/* Compute the start and end lines of the command
* region. (Actually we only use end here)
*/
start = winList[CMD_WIN]->generic.origin.y;
end = start + winList[CMD_WIN]->generic.height - 1;
endcol = winList[CMD_WIN]->generic.width - 1;
if (term_memory_unlock)
{
/* Un-do the effect of the memory lock in terminal_inferior() */
tputs (term_memory_unlock, 1, (int (*) (int)) putchar);
fflush (stdout);
}
else if (term_scroll_region)
{
/* Un-do the effect of setting scroll region in terminal_inferior() */
/* I'm actually not sure how to do this (we don't know for
* sure what the scroll region was *before* we changed it),
* but I'll guess that setting it to the whole screen is
* the right thing. So, ...
*/
/* Set scroll region to be 0..end */
buffer = (char *) tgoto (term_scroll_region, end, 0);
tputs (buffer, 1, (int (*) (int)) putchar);
} /* else we're out of luck */
/* This is an attempt to keep the logical & physical
* cursor in synch, going into curses. Without this,
* curses seems to be confused by the fact that
* GDB has physically moved the curser on it. One
* visible effect of removing this code is that the
* locator window fails to get updated and the line
* of text that *should* go into the locator window
* often goes to the wrong place.
*/
/* What's done here is to tell curses to write a ' '
* at the bottom right corner of the screen.
* The idea is to wind up with the cursor in a known
* place.
* Note I'm relying on refresh()
* only writing what changed (the space),
* not the whole screen.
*/
standend ();
move (end, endcol - 1);
addch (' ');
refresh ();
tui_owns_terminal = 1;
} /* tuiTermSetup */
/* Called to set up the terminal for target program I/O, meaning I/O
* is confined to the command-window area. We also call this on our
* way out of tuiDo, thus setting up the terminal this way for
* debugger command I/O. */
void
tuiTermUnsetup (int turn_on_echo, int to_column)
{
int start;
int end;
int curline;
char *buffer;
/* The next bunch of things are from readline */
extern char *term_scroll_region;
extern char *term_cursor_move;
extern char *term_memory_lock;
extern char *term_memory_unlock;
extern char *term_se;
/* We need to turn on echoing, since the TUI turns it off */
/* Below I only put in the TERMIOS case, since that
* is what applies on HP-UX.
*/
if (turn_on_echo)
{
#ifdef HAVE_TERMIOS
struct termios tio;
tcgetattr (0, &tio);
tio.c_lflag |= (ECHO);
tcsetattr (0, TCSANOW, &tio);
#endif
}
/* Compute the start and end lines of the command
* region, as well as the last "real" line of
* the region (normally same as end, except when
* we're first populating the region)
*/
start = winList[CMD_WIN]->generic.origin.y;
end = start + winList[CMD_WIN]->generic.height - 1;
curline = start + winList[CMD_WIN]->detail.commandInfo.curLine;
/* We want to confine target I/O to the command region.
* In order to do so, we must either have "memory lock"
* (hpterm's) or "scroll regions" (xterm's).
*/
if (term_cursor_move && term_memory_lock)
{
/* Memory lock means lock region above cursor.
* So first position the cursor, then call memory lock.
*/
buffer = tgoto (term_cursor_move, 0, start);
tputs (buffer, 1, (int (*) (int)) putchar);
tputs (term_memory_lock, 1, (int (*) (int)) putchar);
}
else if (term_scroll_region)
{
/* Set the scroll region to the command window */
buffer = tgoto (term_scroll_region, end, start);
tputs (buffer, 1, (int (*) (int)) putchar);
} /* else we can't do anything about target I/O */
/* Also turn off standout mode, in case it is on */
if (term_se != NULL)
tputs (term_se, 1, (int (*) (int)) putchar);
/* Now go to the appropriate spot on the end line */
buffer = tgoto (term_cursor_move, to_column, end);
tputs (buffer, 1, (int (*) (int)) putchar);
fflush (stdout);
tui_owns_terminal = 0;
} /* tuiTermUnsetup */

21
gdb/tui/tuiIO.h
View file

@ -24,16 +24,17 @@
#include <stdio.h> #include <stdio.h>
extern void tuiPuts_unfiltered (const char *, struct ui_file *); /* Print the string in the curses command window. */
extern unsigned int tuiGetc (void); extern void tui_puts (const char *);
extern unsigned int tuiBufferGetc (void);
extern int tuiRead (int, char *, int);
extern void tuiStartNewLines (int);
extern void tui_vStartNewLines (va_list);
extern unsigned int tui_vwgetch (va_list);
extern void tuiTermSetup (int);
extern void tuiTermUnsetup (int, int);
/* Setup the IO for curses or non-curses mode. */
extern void tui_setup_io (int mode);
/* Initialize the IO for gdb in curses mode. */
extern void tui_initialize_io (void);
/* Get a character from the command window. */
extern int tui_getc (FILE*);
#define m_tuiStartNewLine tuiStartNewLines(1) #define m_tuiStartNewLine tuiStartNewLines(1)
@ -58,4 +59,4 @@ extern void tuiTermUnsetup (int, int);
#endif #endif
/*_TUI_IO_H*/