binutils-gdb/gdb/tui/tuiIO.c

735 lines
19 KiB
C
Raw Normal View History

/*
1999-07-07 22:19:36 +02:00
** This module contains functions to support i/o in the TUI
*/
#include <stdio.h>
#include "defs.h"
#include "terminal.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiIO.h"
#include "tuiCommand.h"
#include "tuiWin.h"
#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif
/* The Solaris header files seem to provide no declaration for this at
all when __STDC__ is defined. This shouldn't conflict with
anything. */
extern char *tgoto ();
int insert_mode = 0;
/********************************************
** LOCAL STATIC FORWARD DECLS **
********************************************/
2000-05-28 03:12:42 +02:00
static void _updateCommandInfo (int);
static unsigned int _tuiHandleResizeDuringIO (unsigned int);
/*********************************************************************************
** PUBLIC FUNCTIONS **
*********************************************************************************/
/*
1999-07-07 22:19:36 +02:00
** 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
#ifdef __STDC__
tuiPuts_unfiltered (
const char *string,
2000-02-02 01:21:19 +01:00
struct ui_file * stream)
#else
tuiPuts_unfiltered (string, stream)
char *string;
2000-02-02 01:21:19 +01:00
struct ui_file *stream;
#endif
{
int len = strlen (string);
int i, linech;
for (i = 0; i < len; i++)
{
if (string[i] == '\n' || string[i] == '\r')
m_tuiStartNewLine;
else
{
if ((cmdWin->detail.commandInfo.curch + 1) > cmdWin->generic.width)
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]);
}
}
tuiRefreshWin (&cmdWin->generic);
return;
} /* tuiPuts_unfiltered */
/* A cover routine for tputs().
* tputs() is called from the readline package to put
* out strings representing cursor positioning.
* In TUI mode (non-XDB-style), tui_tputs() is called instead.
*
* The reason we need to hook tputs() is:
* Since the output is going to curses and not to
* a raw terminal, we need to intercept these special
* 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
* by the readline package.
*
* Note we're assuming tui_tputs() is being called
* 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() */
if (!tui_version)
tputs (str, affcnt, putfunc);
/* The strings we special-case are handled first */
if (str == term_backspace)
{
/* Backspace. */
/* We see this on an emacs control-B.
1999-07-07 22:19:36 +02:00
* 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)
{
/* Clear to end of line. */
wclrtoeol (cmdWin->generic.handle);
wrefresh (cmdWin->generic.handle);
}
else if (str == term_cr)
{
/* Carriage return */
_updateCommandInfo (-cmdWin->detail.commandInfo.curch);
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,
1999-07-07 22:19:36 +02:00
* 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
1999-07-07 22:19:36 +02:00
* 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 */
1999-07-07 22:19:36 +02:00
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) */
1999-07-07 22:19:36 +02:00
str == term_scroll_region || /* set scroll region */
str == term_memory_lock || /* lock screen above cursor */
1999-07-07 22:19:36 +02:00
str == term_memory_unlock || /* unlock screen above cursor */
str == visible_bell)
{ /* flash screen */
tputs (str, affcnt, putfunc);
}
else
{ /* something else */
tputs (str, affcnt, putfunc);
}
} /* tui_tputs */
/*
1999-07-07 22:19:36 +02:00
** tui_vwgetch()
** Wrapper around wgetch with the window in a va_list
*/
unsigned int
#ifdef __STDC__
tui_vwgetch (va_list args)
#else
tui_vwgetch (args)
va_list args;
#endif
{
unsigned int ch;
WINDOW *window;
window = va_arg (args, WINDOW *);
return ((unsigned int) wgetch (window));
} /* tui_vwgetch */
/*
1999-07-07 22:19:36 +02:00
** tui_vread()
** Wrapper around read() with paramets in a va_list
*/
unsigned int
#ifdef __STDC__
tui_vread (va_list args)
#else
tui_vread (args)
va_list args;
#endif
{
int result = 0;
int filedes = va_arg (args, int);
char *buf = va_arg (args, char *);
int nbytes = va_arg (args, int);
result = read (filedes, buf, nbytes);
return result;
} /* tui_vread() */
/*
1999-07-07 22:19:36 +02:00
** tuiRead()
** Function to perform a read() catching resize events
*/
int
#ifdef __STDC__
tuiRead (
int filedes,
char *buf,
int nbytes)
#else
tuiRead (filedes, buf, nbytes)
int filedes;
char *buf;
int nbytes;
#endif
{
int result = 0;
result = (int) vcatch_errors ((OpaqueFuncPtr) tui_vread, filedes, buf, nbytes);
*buf = _tuiHandleResizeDuringIO (*buf);
return result;
} /* tuiRead */
/*
1999-07-07 22:19:36 +02:00
** 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
#ifdef __STDC__
tuiGetc (void)
#else
tuiGetc ()
#endif
{
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
ch = wgetch (cmdWin->generic.handle);
#endif
ch = _tuiHandleResizeDuringIO (ch);
if (m_isCommandChar (ch))
{ /* Handle prev/next/up/down here */
tuiTermSetup (0);
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')
cmdWin->detail.commandInfo.curch = 0;
else
tuiIncrCommandCharCountBy (1);
return ch;
} /* tuiGetc */
/*
1999-07-07 22:19:36 +02:00
** tuiBufferGetc().
*/
/*elz: this function reads a line of input from the user and
1999-07-07 22:19:36 +02:00
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
1999-07-07 22:19:36 +02:00
utils.c */
unsigned int
#ifdef __STDC__
tuiBufferGetc (void)
#else
tuiBufferGetc ()
#endif
{
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)
{
1999-07-07 22:19:36 +02:00
/* 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)
{
1999-07-07 22:19:36 +02:00
/*this is the last time through, reset for next query */
index_read = -1;
length_of_answer = -1;
}
wrefresh (cmdWin->generic.handle);
return (ch);
} /* tuiBufferGetc */
/*
1999-07-07 22:19:36 +02:00
** tuiStartNewLines().
*/
void
#ifdef __STDC__
tuiStartNewLines (
int numLines)
#else
tuiStartNewLines (numLines)
int numLines;
#endif
{
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 */
/*
1999-07-07 22:19:36 +02:00
** tui_vStartNewLines().
** With numLines in a va_list
*/
void
#ifdef __STDC__
tui_vStartNewLines (
va_list args)
#else
tui_vStartNewLines (args)
va_list args;
#endif
{
int numLines = va_arg (args, int);
tuiStartNewLines (numLines);
return;
} /* tui_vStartNewLines */
/****************************************************************************
** LOCAL STATIC FUNCTIONS **
*****************************************************************************/
/*
1999-07-07 22:19:36 +02:00
** _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
#ifdef __STDC__
_tuiHandleResizeDuringIO (
unsigned int originalCh) /* the char just read */
#else
_tuiHandleResizeDuringIO (originalCh)
unsigned int originalCh;
#endif
{
if (tuiWinResized ())
{
tuiDo ((TuiOpaqueFuncPtr) tuiRefreshAll);
dont_repeat ();
tuiSetWinResizedTo (FALSE);
rl_reset ();
return '\n';
}
else
return originalCh;
} /* _tuiHandleResizeDuringIO */
/*
1999-07-07 22:19:36 +02:00
** _updateCommandInfo().
** Function to update the command window information.
*/
static void
#ifdef __STDC__
_updateCommandInfo (
int sizeOfString)
#else
_updateCommandInfo (sizeOfString)
int sizeOfString;
#endif
{
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
#ifdef __STDC__
tuiTermSetup (
int turn_off_echo)
#else
tuiTermSetup (turn_off_echo)
int turn_off_echo;
#endif
{
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.
1999-07-07 22:19:36 +02:00
*/
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)
1999-07-07 22:19:36 +02:00
*/
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 (*)PARAMS ((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 (*)PARAMS ((int))) putchar);
} /* else we're out of luck */
/* This is an attempt to keep the logical & physical
1999-07-07 22:19:36 +02:00
* 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 ' '
1999-07-07 22:19:36 +02:00
* 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
#ifdef __STDC__
tuiTermUnsetup (
int turn_on_echo,
int to_column)
#else
tuiTermUnsetup (turn_on_echo, to_column)
int turn_on_echo;
int to_column;
#endif
{
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.
1999-07-07 22:19:36 +02:00
*/
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)
1999-07-07 22:19:36 +02:00
*/
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).
1999-07-07 22:19:36 +02:00
*/
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 (*)PARAMS ((int))) putchar);
tputs (term_memory_lock, 1, (int (*)PARAMS ((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 (*)PARAMS ((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 (*)PARAMS ((int))) putchar);
/* Now go to the appropriate spot on the end line */
buffer = tgoto (term_cursor_move, to_column, end);
tputs (buffer, 1, (int (*)PARAMS ((int))) putchar);
fflush (stdout);
tui_owns_terminal = 0;
} /* tuiTermUnsetup */