Subversion Repositories or1k

/*

   ** 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        **

********************************************/

static void _updateCommandInfo (int);

static unsigned int _tuiHandleResizeDuringIO (unsigned int);

/*********************************************************************************

**                              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

#ifdef __STDC__

tuiPuts_unfiltered (

                     const char *string,

                     struct ui_file * stream)

#else

tuiPuts_unfiltered (string, stream)

     char *string;

     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.

         * 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,

      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

    {                           /* something else */

      tputs (str, affcnt, putfunc);

    }

}                               /* tui_tputs */

/*

   ** 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 */

/*

   ** 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() */

/*

   ** 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 */

/*

   ** 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 */

/*

   ** tuiBufferGetc().

 */

/*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

#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)

    {

      /* 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

#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 */

/*

   ** 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                                **

*****************************************************************************/

/*

   ** _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 */

/*

   ** _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.

   */

  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

#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.

   */

  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);