URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tui.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
   ** tui.c
   **         General functions for the WDB TUI
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <malloc.h>
#include <curses.h>
#ifdef HAVE_TERM_H
#include <term.h>
#endif
#include <signal.h>
#include <fcntl.h>
#include <termio.h>
#include <setjmp.h>
#include "defs.h"
#include "gdbcmd.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiIO.h"
#include "tuiRegs.h"
#include "tuiWin.h"
 
/* 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 ();
 
/***********************
** Local Definitions
************************/
#define FILEDES         2
/* Solaris <sys/termios.h> defines CTRL. */
#ifndef CTRL
#define CTRL(x)         (x & ~0140)
#endif
#define CHK(val, dft)   (val<=0 ? dft : val)
 
#define TOGGLE_USAGE "Usage:toggle breakpoints"
#define TUI_TOGGLE_USAGE "Usage:\ttoggle $fregs\n\ttoggle breakpoints"
 
/*****************************
** Local static forward decls
******************************/
static void _tuiReset PARAMS ((void));
static void _toggle_command PARAMS ((char *, int));
static void _tui_vToggle_command PARAMS ((va_list));
static Opaque _tui_vDo PARAMS ((TuiOpaqueFuncPtr, va_list));
 
 
 
/***********************
** Public Functions
************************/
 
/*
   ** tuiInit().
 */
void
#ifdef __STDC__
tuiInit (char *argv0)
#else
tuiInit (argv0)
     char *argv0;
#endif
{
  extern void init_page_info ();
  extern void initialize_tui_files PARAMS ((void));
 
  initialize_tui_files ();
  initializeStaticData ();
  initscr ();
  refresh ();
  setTermHeightTo (LINES);
  setTermWidthTo (COLS);
  tuiInitWindows ();
  wrefresh (cmdWin->generic.handle);
  init_page_info ();
  /* Don't hook debugger output if doing command-window
     * the XDB way. However, one thing we do want to do in
     * XDB style is set up the scrolling region to be
     * the bottom of the screen (tuiTermUnsetup()).
   */
  fputs_unfiltered_hook = NULL;
  rl_initialize ();             /* need readline initialization to
                                   * create termcap sequences
                                 */
  tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);
 
  return;
}                               /* tuiInit */
 
 
/*
   ** tuiInitWindows().
 */
void
#ifdef __STDC__
tuiInitWindows (void)
#else
tuiInitWindows ()
#endif
{
  TuiWinType type;
 
  tuiSetLocatorContent (0);
  showLayout (SRC_COMMAND);
  keypad (cmdWin->generic.handle, TRUE);
  echo ();
  crmode ();
  nl ();
  tuiSetWinFocusTo (srcWin);
 
  return;
}                               /* tuiInitWindows */
 
 
/*
   ** tuiCleanUp().
   **        Kill signal handler and cleanup termination method
 */
void
#ifdef __STDC__
tuiResetScreen (void)
#else
tuiResetScreen ()
#endif
{
  TuiWinType type = SRC_WIN;
 
  keypad (cmdWin->generic.handle, FALSE);
  for (; type < MAX_MAJOR_WINDOWS; type++)
    {
      if (m_winPtrNotNull (winList[type]) &&
          winList[type]->generic.type != UNDEFINED_WIN &&
          !winList[type]->generic.isVisible)
        tuiDelWindow (winList[type]);
    }
  endwin ();
  initscr ();
  refresh ();
  echo ();
  crmode ();
  nl ();
 
  return;
}                               /* tuiResetScreen */
 
 
/*
   ** tuiCleanUp().
   **        Kill signal handler and cleanup termination method
 */
void
#ifdef __STDC__
tuiCleanUp (void)
#else
tuiCleanUp ()
#endif
{
  char *buffer;
  extern char *term_cursor_move;
 
  signal (SIGINT, SIG_IGN);
  tuiTermSetup (0);              /* Restore scrolling region to whole screen */
  keypad (cmdWin->generic.handle, FALSE);
  freeAllWindows ();
  endwin ();
  buffer = tgoto (term_cursor_move, 0, termHeight ());
  tputs (buffer, 1, putchar);
  _tuiReset ();
 
  return;
}                               /* tuiCleanUp */
 
 
/*
   ** tuiError().
 */
void
#ifdef __STDC__
tuiError (
           char *string,
           int exitGdb)
#else
tuiError (string, exitGdb)
     char *string;
     int exitGdb;
#endif
{
  puts_unfiltered (string);
  if (exitGdb)
    {
      tuiCleanUp ();
      exit (-1);
    }
 
  return;
}                               /* tuiError */
 
 
/*
   ** tui_vError()
   **        tuiError with args in a va_list.
 */
void
#ifdef __STDC__
tui_vError (
             va_list args)
#else
tui_vError (args)
     va_list args;
#endif
{
  char *string;
  int exitGdb;
 
  string = va_arg (args, char *);
  exitGdb = va_arg (args, int);
 
  tuiError (string, exitGdb);
 
  return;
}                               /* tui_vError */
 
 
/*
   ** tuiFree()
   **    Wrapper on top of free() to ensure that input address is greater than 0x0
 */
void
#ifdef __STDC__
tuiFree (
          char *ptr)
#else
tuiFree (ptr)
     char *ptr;
#endif
{
  if (ptr != (char *) NULL)
    {
      free (ptr);
    }
 
  return;
}                               /* tuiFree */
 
 
/* tuiGetLowDisassemblyAddress().
   **        Determine what the low address will be to display in the TUI's
   **        disassembly window.  This may or may not be the same as the
   **        low address input.
 */
Opaque
#ifdef __STDC__
tuiGetLowDisassemblyAddress (
                              Opaque low,
                              Opaque pc)
#else
tuiGetLowDisassemblyAddress (low, pc)
     Opaque low;
     Opaque pc;
#endif
{
  int line;
  Opaque newLow;
 
  /*
     ** Determine where to start the disassembly so that the pc is about in the
     ** middle of the viewport.
   */
  for (line = 0, newLow = pc;
       (newLow > low &&
        line < (tuiDefaultWinViewportHeight (DISASSEM_WIN,
                                             DISASSEM_COMMAND) / 2));)
    {
      bfd_byte buffer[4];
 
      newLow -= sizeof (bfd_getb32 (buffer));
      line++;
    }
 
  return newLow;
}                               /* tuiGetLowDisassemblyAddress */
 
 
/* tui_vGetLowDisassemblyAddress().
   **        Determine what the low address will be to display in the TUI's
   **        disassembly window with args in a va_list.
 */
Opaque
#ifdef __STDC__
tui_vGetLowDisassemblyAddress (
                                va_list args)
#else
tui_vGetLowDisassemblyAddress (args)
     va_list args;
#endif
{
  int line;
  Opaque newLow;
  Opaque low;
  Opaque pc;
 
  low = va_arg (args, Opaque);
  pc = va_arg (args, Opaque);
 
  return (tuiGetLowDisassemblyAddress (low, pc));
 
}                               /* tui_vGetLowDisassemblyAddress */
 
 
/*
   ** tuiDo().
   **        General purpose function to execute a tui function.  Transitions
   **        between curses and the are handled here.  This function is called
   **        by non-tui gdb functions.
   **
   **        Errors are caught here.
   **        If there is no error, the value returned by 'func' is returned.
   **        If there is an error, then zero is returned.
   **
   **       Must not be called with immediate_quit in effect (bad things might
   **       happen, say we got a signal in the middle of a memcpy to quit_return).
   **       This is an OK restriction; with very few exceptions immediate_quit can
   **       be replaced by judicious use of QUIT.
 */
Opaque
#ifdef __STDC__
tuiDo (
        TuiOpaqueFuncPtr func,...)
#else
tuiDo (func, va_alist)
     TuiOpaqueFuncPtr func;
     va_dcl
#endif
{
  extern int terminal_is_ours;
 
  Opaque ret = (Opaque) NULL;
 
  /* It is an error to be tuiDo'ing if we
     * don't own the terminal.
   */
  if (!terminal_is_ours)
    return ret;
 
  if (tui_version)
    {
      va_list args;
 
#ifdef __STDC__
      va_start (args, func);
#else
      va_start (args);
#endif
      ret = _tui_vDo (func, args);
      va_end (args);
    }
 
  return ret;
}                               /* tuiDo */
 
 
/*
   ** tuiDoAndReturnToTop().
   **        General purpose function to execute a tui function.  Transitions
   **        between curses and the are handled here.  This function is called
   **        by non-tui gdb functions who wish to reset gdb to the top level.
   **        After the tuiDo is performed, a return to the top level occurs.
   **
   **        Errors are caught here.
   **        If there is no error, the value returned by 'func' is returned.
   **        If there is an error, then zero is returned.
   **
   **       Must not be called with immediate_quit in effect (bad things might
   **       happen, say we got a signal in the middle of a memcpy to quit_return).
   **       This is an OK restriction; with very few exceptions immediate_quit can
   **       be replaced by judicious use of QUIT.
   **
 */
Opaque
#ifdef __STDC__
tuiDoAndReturnToTop (
                      TuiOpaqueFuncPtr func,...)
#else
tuiDoAndReturnToTop (func, va_alist)
     TuiOpaqueFuncPtr func;
     va_dcl
#endif
{
  extern int terminal_is_ours;
 
  Opaque ret = (Opaque) NULL;
 
  /* It is an error to be tuiDo'ing if we
     * don't own the terminal.
   */
  if (!terminal_is_ours)
    return ret;
 
  if (tui_version)
    {
      va_list args;
 
#ifdef __STDC__
      va_start (args, func);
#else
      va_start (args);
#endif
      ret = _tui_vDo (func, args);
 
      /* force a return to the top level */
      return_to_top_level (RETURN_ERROR);
    }
 
  return ret;
}                               /* tuiDoAndReturnToTop */
 
 
void
#ifdef __STDC__
tui_vSelectSourceSymtab (
                          va_list args)
#else
tui_vSelectSourceSymtab (args)
     va_list args;
#endif
{
  struct symtab *s = va_arg (args, struct symtab *);
 
  select_source_symtab (s);
  return;
}                               /* tui_vSelectSourceSymtab */
 
 
/*
   ** _initialize_tui().
   **      Function to initialize gdb commands, for tui window manipulation.
 */
void
_initialize_tui ()
{
#if 0
  if (tui_version)
    {
      add_com ("toggle", class_tui, _toggle_command,
               "Toggle Terminal UI Features\n\
Usage: Toggle $fregs\n\
\tToggles between single and double precision floating point registers.\n");
    }
#endif
  char *helpStr;
 
  if (tui_version)
    helpStr = "Toggle Specified Features\n\
Usage:\ttoggle $fregs\n\ttoggle breakpoints";
  else
    helpStr = "Toggle Specified Features\nUsage:toggle breakpoints";
  add_abbrev_prefix_cmd ("toggle",
                         class_tui,
                         _toggle_command,
                         helpStr,
                         &togglelist,
                         "toggle ",
                         1,
                         &cmdlist);
}                               /* _initialize_tui */
 
 
/*
   ** va_catch_errors().
   **       General purpose function to execute a function, catching errors.
   **       If there is no error, the value returned by 'func' is returned.
   **       If there is error, then zero is returned.
   **       Note that 'func' must take a variable argument list as well.
   **
   **       Must not be called with immediate_quit in effect (bad things might
   **       happen, say we got a signal in the middle of a memcpy to quit_return).
   **       This is an OK restriction; with very few exceptions immediate_quit can
   **       be replaced by judicious use of QUIT.
 */
Opaque
#ifdef __STDC__
va_catch_errors (
                  TuiOpaqueFuncPtr func,
                  va_list args)
#else
va_catch_errors (func, args)
     TuiOpaqueFuncPtr func;
     va_list args;
#endif
{
  Opaque ret = (Opaque) NULL;
 
  /*
     ** We could have used catch_errors(), but it doesn't handle variable args.
     ** Also, for the tui, we always want to catch all errors, so we don't
     ** need to pass a mask, or an error string.
   */
  jmp_buf saved_error;
  jmp_buf saved_quit;
  jmp_buf tmp_jmp;
  struct cleanup *saved_cleanup_chain;
  char *saved_error_pre_print;
  char *saved_quit_pre_print;
  extern jmp_buf error_return;
  extern jmp_buf quit_return;
 
  saved_cleanup_chain = save_cleanups ();
  saved_error_pre_print = error_pre_print;
  saved_quit_pre_print = quit_pre_print;
 
  memcpy ((char *) saved_error, (char *) error_return, sizeof (jmp_buf));
  error_pre_print = "";
  memcpy (saved_quit, quit_return, sizeof (jmp_buf));
  quit_pre_print = "";
 
  if (setjmp (tmp_jmp) == 0)
    {
      va_list argList = args;
      memcpy (error_return, tmp_jmp, sizeof (jmp_buf));
      memcpy (quit_return, tmp_jmp, sizeof (jmp_buf));
      ret = func (argList);
    }
  restore_cleanups (saved_cleanup_chain);
  memcpy (error_return, saved_error, sizeof (jmp_buf));
  error_pre_print = saved_error_pre_print;
  memcpy (quit_return, saved_quit, sizeof (jmp_buf));
  quit_pre_print = saved_quit_pre_print;
 
  return ret;
}
 
/*
   ** vcatch_errors().
   **        Catch errors occurring in tui or non tui function, handling
   **        variable param lists. Note that 'func' must take a variable
   **        argument list as well.
 */
Opaque
#ifdef __STDC__
vcatch_errors (
                OpaqueFuncPtr func,...)
#else
vcatch_errors (va_alist)
     va_dcl
/*
   vcatch_errors(func, va_alist)
   OpaqueFuncPtr    func;
   va_dcl
 */
#endif
{
  Opaque ret = (Opaque) NULL;
  va_list args;
#ifdef __STDC__
  va_start (args, func);
/*
   va_arg(args, OpaqueFuncPtr);
 */
#else
  OpaqueFuncPtr func;
 
  va_start (args);
  func = va_arg (args, OpaqueFuncPtr);
#endif
  ret = va_catch_errors (func, args);
  va_end (args);
 
  return ret;
}
 
 
void
#ifdef __STDC__
strcat_to_buf (
                char *buf,
                int buflen,
                char *itemToAdd)
#else
strcat_to_buf (buf, buflen, itemToAdd)
     char *buf;
     int buflen;
     char *itemToAdd;
#endif
{
  if (itemToAdd != (char *) NULL && buf != (char *) NULL)
    {
      if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
        strcat (buf, itemToAdd);
      else
        strncat (buf, itemToAdd, (buflen - strlen (buf)));
    }
 
  return;
}                               /* strcat_to_buf */
 
/* VARARGS */
void
#ifdef ANSI_PROTOTYPES
strcat_to_buf_with_fmt (
                         char *buf,
                         int bufLen,
                         char *format,...)
#else
strcat_to_buf_with_fmt (va_alist)
     va_dcl
#endif
{
  char *linebuffer;
  struct cleanup *old_cleanups;
  va_list args;
#ifdef ANSI_PROTOTYPES
  va_start (args, format);
#else
  char *buf;
  int bufLen;
  char *format;
 
  va_start (args);
  buf = va_arg (args, char *);
  bufLen = va_arg (args, int);
  format = va_arg (args, char *);
#endif
  vasprintf (&linebuffer, format, args);
  old_cleanups = make_cleanup (free, linebuffer);
  strcat_to_buf (buf, bufLen, linebuffer);
  do_cleanups (old_cleanups);
  va_end (args);
}
 
 
 
 
 
/***********************
** Static Functions
************************/
 
 
/*
   ** _tui_vDo().
   **        General purpose function to execute a tui function.  Transitions
   **        between curses and the are handled here.  This function is called
   **        by non-tui gdb functions.
   **
   **        Errors are caught here.
   **        If there is no error, the value returned by 'func' is returned.
   **        If there is an error, then zero is returned.
   **
   **       Must not be called with immediate_quit in effect (bad things might
   **       happen, say we got a signal in the middle of a memcpy to quit_return).
   **       This is an OK restriction; with very few exceptions immediate_quit can
   **       be replaced by judicious use of QUIT.
 */
static Opaque
#ifdef __STDC__
_tui_vDo (
           TuiOpaqueFuncPtr func,
           va_list args)
#else
_tui_vDo (func, args)
     TuiOpaqueFuncPtr func;
     va_list args;
#endif
{
  extern int terminal_is_ours;
 
  Opaque ret = (Opaque) NULL;
 
  /* It is an error to be tuiDo'ing if we
     * don't own the terminal.
   */
  if (!terminal_is_ours)
    return ret;
 
  if (tui_version)
    {
      /* If doing command window the "XDB way" (command window
         * is unmanaged by curses...
       */
      /* Set up terminal for TUI */
      tuiTermSetup (1);
 
      ret = va_catch_errors (func, args);
 
      /* Set up terminal for command window */
      tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);
    }
 
  return ret;
}                               /* _tui_vDo */
 
 
static void
#ifdef __STDC__
_toggle_command (
                  char *arg,
                  int fromTTY)
#else
_toggle_command (arg, fromTTY)
     char *arg;
     int fromTTY;
#endif
{
  printf_filtered ("Specify feature to toggle.\n%s\n",
                   (tui_version) ? TUI_TOGGLE_USAGE : TOGGLE_USAGE);
/*
   tuiDo((TuiOpaqueFuncPtr)_Toggle_command, arg, fromTTY);
 */
}
 
/*
   ** _tui_vToggle_command().
 */
static void
#ifdef __STDC__
_tui_vToggle_command (
                       va_list args)
#else
_tui_vToggle_command (args)
     va_list args;
#endif
{
  char *arg;
  int fromTTY;
 
  arg = va_arg (args, char *);
 
  if (arg == (char *) NULL)
    printf_filtered (TOGGLE_USAGE);
  else
    {
      char *ptr = (char *) tuiStrDup (arg);
      int i;
 
      for (i = 0; (ptr[i]); i++)
        ptr[i] = toupper (arg[i]);
 
      if (subsetCompare (ptr, TUI_FLOAT_REGS_NAME))
        tuiToggleFloatRegs ();
/*        else if (subsetCompare(ptr, "ANOTHER TOGGLE OPTION"))
   ...
 */
      else
        printf_filtered (TOGGLE_USAGE);
      tuiFree (ptr);
    }
 
  return;
}                               /* _tuiToggle_command */
 
 
static void
#ifdef __STDC__
_tuiReset (void)
#else
_tuiReset ()
#endif
{
  struct termio mode;
 
  /*
     ** reset the teletype mode bits to a sensible state.
     ** Copied tset.c
   */
#if ! defined (USG) && defined (TIOCGETC)
  struct tchars tbuf;
#endif /* !USG && TIOCGETC */
#ifdef UCB_NTTY
  struct ltchars ltc;
 
  if (ldisc == NTTYDISC)
    {
      ioctl (FILEDES, TIOCGLTC, &ltc);
      ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
      ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
      ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
      ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
      ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
      ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
      ioctl (FILEDES, TIOCSLTC, &ltc);
    }
#endif /* UCB_NTTY */
#ifndef USG
#ifdef TIOCGETC
  ioctl (FILEDES, TIOCGETC, &tbuf);
  tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
  tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
  tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
  tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
  tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
  /* brkc is left alone */
  ioctl (FILEDES, TIOCSETC, &tbuf);
#endif /* TIOCGETC */
  mode.sg_flags &= ~(RAW
#ifdef CBREAK
                     | CBREAK
#endif /* CBREAK */
                     | VTDELAY | ALLDELAY);
  mode.sg_flags |= XTABS | ECHO | CRMOD | ANYP;
#else /*USG */
  ioctl (FILEDES, TCGETA, &mode);
  mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));
  mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));
  mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));
 
  mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | INLCR | IGNCR | IUCLC | IXOFF);
  mode.c_iflag |= (BRKINT | ISTRIP | ICRNL | IXON);
  mode.c_oflag &= ~(OLCUC | OCRNL | ONOCR | ONLRET | OFILL | OFDEL |
                    NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY);
  mode.c_oflag |= (OPOST | ONLCR);
  mode.c_cflag &= ~(CSIZE | PARODD | CLOCAL);
#ifndef hp9000s800
  mode.c_cflag |= (CS8 | CREAD);
#else /*hp9000s800 */
  mode.c_cflag |= (CS8 | CSTOPB | CREAD);
#endif /* hp9000s800 */
  mode.c_lflag &= ~(XCASE | ECHONL | NOFLSH);
  mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOK);
  ioctl (FILEDES, TCSETAW, &mode);
#endif /* USG */
 
  return;
}                               /* _tuiReset */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tui.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	106	markom	`/*`
2			`** tui.c`
3			`** General functions for the WDB TUI`
4			`*/`
5
6			`#include <stdio.h>`
7			`#include <stdlib.h>`
8			`#include <ctype.h>`
9			`#include <malloc.h>`
10			`#include <curses.h>`
11			`#ifdef HAVE_TERM_H`
12			`#include <term.h>`
13			`#endif`
14			`#include <signal.h>`
15			`#include <fcntl.h>`
16			`#include <termio.h>`
17			`#include <setjmp.h>`
18			`#include "defs.h"`
19			`#include "gdbcmd.h"`
20			`#include "tui.h"`
21			`#include "tuiData.h"`
22			`#include "tuiLayout.h"`
23			`#include "tuiIO.h"`
24			`#include "tuiRegs.h"`
25			`#include "tuiWin.h"`
26
27			`/* The Solaris header files seem to provide no declaration for this at`
28			`all when __STDC__ is defined. This shouldn't conflict with`
29			`anything. */`
30			`extern char *tgoto ();`
31
32			`/***********************`
33			`** Local Definitions`
34			`************************/`
35			`#define FILEDES 2`
36			`/* Solaris <sys/termios.h> defines CTRL. */`
37			`#ifndef CTRL`
38			`#define CTRL(x) (x & ~0140)`
39			`#endif`
40			`#define CHK(val, dft) (val<=0 ? dft : val)`
41
42			`#define TOGGLE_USAGE "Usage:toggle breakpoints"`
43			`#define TUI_TOGGLE_USAGE "Usage:\ttoggle $fregs\n\ttoggle breakpoints"`
44
45			`/*****************************`
46			`** Local static forward decls`
47			`******************************/`
48			`static void _tuiReset PARAMS ((void));`
49			`static void _toggle_command PARAMS ((char *, int));`
50			`static void _tui_vToggle_command PARAMS ((va_list));`
51			`static Opaque _tui_vDo PARAMS ((TuiOpaqueFuncPtr, va_list));`
52
53
54
55			`/***********************`
56			`** Public Functions`
57			`************************/`
58
59			`/*`
60			`** tuiInit().`
61			`*/`
62			`void`
63			`#ifdef __STDC__`
64			`tuiInit (char *argv0)`
65			`#else`
66			`tuiInit (argv0)`
67			`char *argv0;`
68			`#endif`
69			`{`
70			`extern void init_page_info ();`
71			`extern void initialize_tui_files PARAMS ((void));`
72
73			`initialize_tui_files ();`
74			`initializeStaticData ();`
75			`initscr ();`
76			`refresh ();`
77			`setTermHeightTo (LINES);`
78			`setTermWidthTo (COLS);`
79			`tuiInitWindows ();`
80			`wrefresh (cmdWin->generic.handle);`
81			`init_page_info ();`
82			`/* Don't hook debugger output if doing command-window`
83			`* the XDB way. However, one thing we do want to do in`
84			`* XDB style is set up the scrolling region to be`
85			`* the bottom of the screen (tuiTermUnsetup()).`
86			`*/`
87			`fputs_unfiltered_hook = NULL;`
88			`rl_initialize (); /* need readline initialization to`
89			`* create termcap sequences`
90			`*/`
91			`tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);`
92
93			`return;`
94			`} /* tuiInit */`
95
96
97			`/*`
98			`** tuiInitWindows().`
99			`*/`
100			`void`
101			`#ifdef __STDC__`
102			`tuiInitWindows (void)`
103			`#else`
104			`tuiInitWindows ()`
105			`#endif`
106			`{`
107			`TuiWinType type;`
108
109			`tuiSetLocatorContent (0);`
110			`showLayout (SRC_COMMAND);`
111			`keypad (cmdWin->generic.handle, TRUE);`
112			`echo ();`
113			`crmode ();`
114			`nl ();`
115			`tuiSetWinFocusTo (srcWin);`
116
117			`return;`
118			`} /* tuiInitWindows */`
119
120
121			`/*`
122			`** tuiCleanUp().`
123			`** Kill signal handler and cleanup termination method`
124			`*/`
125			`void`
126			`#ifdef __STDC__`
127			`tuiResetScreen (void)`
128			`#else`
129			`tuiResetScreen ()`
130			`#endif`
131			`{`
132			`TuiWinType type = SRC_WIN;`
133
134			`keypad (cmdWin->generic.handle, FALSE);`
135			`for (; type < MAX_MAJOR_WINDOWS; type++)`
136			`{`
137			`if (m_winPtrNotNull (winList[type]) &&`
138			`winList[type]->generic.type != UNDEFINED_WIN &&`
139			`!winList[type]->generic.isVisible)`
140			`tuiDelWindow (winList[type]);`
141			`}`
142			`endwin ();`
143			`initscr ();`
144			`refresh ();`
145			`echo ();`
146			`crmode ();`
147			`nl ();`
148
149			`return;`
150			`} /* tuiResetScreen */`
151
152
153			`/*`
154			`** tuiCleanUp().`
155			`** Kill signal handler and cleanup termination method`
156			`*/`
157			`void`
158			`#ifdef __STDC__`
159			`tuiCleanUp (void)`
160			`#else`
161			`tuiCleanUp ()`
162			`#endif`
163			`{`
164			`char *buffer;`
165			`extern char *term_cursor_move;`
166
167			`signal (SIGINT, SIG_IGN);`
168			`tuiTermSetup (0); /* Restore scrolling region to whole screen */`
169			`keypad (cmdWin->generic.handle, FALSE);`
170			`freeAllWindows ();`
171			`endwin ();`
172			`buffer = tgoto (term_cursor_move, 0, termHeight ());`
173			`tputs (buffer, 1, putchar);`
174			`_tuiReset ();`
175
176			`return;`
177			`} /* tuiCleanUp */`
178
179
180			`/*`
181			`** tuiError().`
182			`*/`
183			`void`
184			`#ifdef __STDC__`
185			`tuiError (`
186			`char *string,`
187			`int exitGdb)`
188			`#else`
189			`tuiError (string, exitGdb)`
190			`char *string;`
191			`int exitGdb;`
192			`#endif`
193			`{`
194			`puts_unfiltered (string);`
195			`if (exitGdb)`
196			`{`
197			`tuiCleanUp ();`
198			`exit (-1);`
199			`}`
200
201			`return;`
202			`} /* tuiError */`
203
204
205			`/*`
206			`** tui_vError()`
207			`** tuiError with args in a va_list.`
208			`*/`
209			`void`
210			`#ifdef __STDC__`
211			`tui_vError (`
212			`va_list args)`
213			`#else`
214			`tui_vError (args)`
215			`va_list args;`
216			`#endif`
217			`{`
218			`char *string;`
219			`int exitGdb;`
220
221			`string = va_arg (args, char *);`
222			`exitGdb = va_arg (args, int);`
223
224			`tuiError (string, exitGdb);`
225
226			`return;`
227			`} /* tui_vError */`
228
229
230			`/*`
231			`** tuiFree()`
232			`** Wrapper on top of free() to ensure that input address is greater than 0x0`
233			`*/`
234			`void`
235			`#ifdef __STDC__`
236			`tuiFree (`
237			`char *ptr)`
238			`#else`
239			`tuiFree (ptr)`
240			`char *ptr;`
241			`#endif`
242			`{`
243			`if (ptr != (char *) NULL)`
244			`{`
245			`free (ptr);`
246			`}`
247
248			`return;`
249			`} /* tuiFree */`
250
251
252			`/* tuiGetLowDisassemblyAddress().`
253			`** Determine what the low address will be to display in the TUI's`
254			`** disassembly window. This may or may not be the same as the`
255			`** low address input.`
256			`*/`
257			`Opaque`
258			`#ifdef __STDC__`
259			`tuiGetLowDisassemblyAddress (`
260			`Opaque low,`
261			`Opaque pc)`
262			`#else`
263			`tuiGetLowDisassemblyAddress (low, pc)`
264			`Opaque low;`
265			`Opaque pc;`
266			`#endif`
267			`{`
268			`int line;`
269			`Opaque newLow;`
270
271			`/*`
272			`** Determine where to start the disassembly so that the pc is about in the`
273			`** middle of the viewport.`
274			`*/`
275			`for (line = 0, newLow = pc;`
276			`(newLow > low &&`
277			`line < (tuiDefaultWinViewportHeight (DISASSEM_WIN,`
278			`DISASSEM_COMMAND) / 2));)`
279			`{`
280			`bfd_byte buffer[4];`
281
282			`newLow -= sizeof (bfd_getb32 (buffer));`
283			`line++;`
284			`}`
285
286			`return newLow;`
287			`} /* tuiGetLowDisassemblyAddress */`
288
289
290			`/* tui_vGetLowDisassemblyAddress().`
291			`** Determine what the low address will be to display in the TUI's`
292			`** disassembly window with args in a va_list.`
293			`*/`
294			`Opaque`
295			`#ifdef __STDC__`
296			`tui_vGetLowDisassemblyAddress (`
297			`va_list args)`
298			`#else`
299			`tui_vGetLowDisassemblyAddress (args)`
300			`va_list args;`
301			`#endif`
302			`{`
303			`int line;`
304			`Opaque newLow;`
305			`Opaque low;`
306			`Opaque pc;`
307
308			`low = va_arg (args, Opaque);`
309			`pc = va_arg (args, Opaque);`
310
311			`return (tuiGetLowDisassemblyAddress (low, pc));`
312
313			`} /* tui_vGetLowDisassemblyAddress */`
314
315
316			`/*`
317			`** tuiDo().`
318			`** General purpose function to execute a tui function. Transitions`
319			`** between curses and the are handled here. This function is called`
320			`** by non-tui gdb functions.`
321			`**`
322			`** Errors are caught here.`
323			`** If there is no error, the value returned by 'func' is returned.`
324			`** If there is an error, then zero is returned.`
325			`**`
326			`** Must not be called with immediate_quit in effect (bad things might`
327			`** happen, say we got a signal in the middle of a memcpy to quit_return).`
328			`** This is an OK restriction; with very few exceptions immediate_quit can`
329			`** be replaced by judicious use of QUIT.`
330			`*/`
331			`Opaque`
332			`#ifdef __STDC__`
333			`tuiDo (`
334			`TuiOpaqueFuncPtr func,...)`
335			`#else`
336			`tuiDo (func, va_alist)`
337			`TuiOpaqueFuncPtr func;`
338			`va_dcl`
339			`#endif`
340			`{`
341			`extern int terminal_is_ours;`
342
343			`Opaque ret = (Opaque) NULL;`
344
345			`/* It is an error to be tuiDo'ing if we`
346			`* don't own the terminal.`
347			`*/`
348			`if (!terminal_is_ours)`
349			`return ret;`
350
351			`if (tui_version)`
352			`{`
353			`va_list args;`
354
355			`#ifdef __STDC__`
356			`va_start (args, func);`
357			`#else`
358			`va_start (args);`
359			`#endif`
360			`ret = _tui_vDo (func, args);`
361			`va_end (args);`
362			`}`
363
364			`return ret;`
365			`} /* tuiDo */`
366
367
368			`/*`
369			`** tuiDoAndReturnToTop().`
370			`** General purpose function to execute a tui function. Transitions`
371			`** between curses and the are handled here. This function is called`
372			`** by non-tui gdb functions who wish to reset gdb to the top level.`
373			`** After the tuiDo is performed, a return to the top level occurs.`
374			`**`
375			`** Errors are caught here.`
376			`** If there is no error, the value returned by 'func' is returned.`
377			`** If there is an error, then zero is returned.`
378			`**`
379			`** Must not be called with immediate_quit in effect (bad things might`
380			`** happen, say we got a signal in the middle of a memcpy to quit_return).`
381			`** This is an OK restriction; with very few exceptions immediate_quit can`
382			`** be replaced by judicious use of QUIT.`
383			`**`
384			`*/`
385			`Opaque`
386			`#ifdef __STDC__`
387			`tuiDoAndReturnToTop (`
388			`TuiOpaqueFuncPtr func,...)`
389			`#else`
390			`tuiDoAndReturnToTop (func, va_alist)`
391			`TuiOpaqueFuncPtr func;`
392			`va_dcl`
393			`#endif`
394			`{`
395			`extern int terminal_is_ours;`
396
397			`Opaque ret = (Opaque) NULL;`
398
399			`/* It is an error to be tuiDo'ing if we`
400			`* don't own the terminal.`
401			`*/`
402			`if (!terminal_is_ours)`
403			`return ret;`
404
405			`if (tui_version)`
406			`{`
407			`va_list args;`
408
409			`#ifdef __STDC__`
410			`va_start (args, func);`
411			`#else`
412			`va_start (args);`
413			`#endif`
414			`ret = _tui_vDo (func, args);`
415
416			`/* force a return to the top level */`
417			`return_to_top_level (RETURN_ERROR);`
418			`}`
419
420			`return ret;`
421			`} /* tuiDoAndReturnToTop */`
422
423
424			`void`
425			`#ifdef __STDC__`
426			`tui_vSelectSourceSymtab (`
427			`va_list args)`
428			`#else`
429			`tui_vSelectSourceSymtab (args)`
430			`va_list args;`
431			`#endif`
432			`{`
433			`struct symtab s = va_arg (args, struct symtab );`
434
435			`select_source_symtab (s);`
436			`return;`
437			`} /* tui_vSelectSourceSymtab */`
438
439
440			`/*`
441			`** _initialize_tui().`
442			`** Function to initialize gdb commands, for tui window manipulation.`
443			`*/`
444			`void`
445			`_initialize_tui ()`
446			`{`
447			`#if 0`
448			`if (tui_version)`
449			`{`
450			`add_com ("toggle", class_tui, _toggle_command,`
451			`"Toggle Terminal UI Features\n\`
452			`Usage: Toggle $fregs\n\`
453			`\tToggles between single and double precision floating point registers.\n");`
454			`}`
455			`#endif`
456			`char *helpStr;`
457
458			`if (tui_version)`
459			`helpStr = "Toggle Specified Features\n\`
460			`Usage:\ttoggle $fregs\n\ttoggle breakpoints";`
461			`else`
462			`helpStr = "Toggle Specified Features\nUsage:toggle breakpoints";`
463			`add_abbrev_prefix_cmd ("toggle",`
464			`class_tui,`
465			`_toggle_command,`
466			`helpStr,`
467			`&togglelist,`
468			`"toggle ",`
469			`1,`
470			`&cmdlist);`
471			`} /* _initialize_tui */`
472
473
474			`/*`
475			`** va_catch_errors().`
476			`** General purpose function to execute a function, catching errors.`
477			`** If there is no error, the value returned by 'func' is returned.`
478			`** If there is error, then zero is returned.`
479			`** Note that 'func' must take a variable argument list as well.`
480			`**`
481			`** Must not be called with immediate_quit in effect (bad things might`
482			`** happen, say we got a signal in the middle of a memcpy to quit_return).`
483			`** This is an OK restriction; with very few exceptions immediate_quit can`
484			`** be replaced by judicious use of QUIT.`
485			`*/`
486			`Opaque`
487			`#ifdef __STDC__`
488			`va_catch_errors (`
489			`TuiOpaqueFuncPtr func,`
490			`va_list args)`
491			`#else`
492			`va_catch_errors (func, args)`
493			`TuiOpaqueFuncPtr func;`
494			`va_list args;`
495			`#endif`
496			`{`
497			`Opaque ret = (Opaque) NULL;`
498
499			`/*`
500			`** We could have used catch_errors(), but it doesn't handle variable args.`
501			`** Also, for the tui, we always want to catch all errors, so we don't`
502			`** need to pass a mask, or an error string.`
503			`*/`
504			`jmp_buf saved_error;`
505			`jmp_buf saved_quit;`
506			`jmp_buf tmp_jmp;`
507			`struct cleanup *saved_cleanup_chain;`
508			`char *saved_error_pre_print;`
509			`char *saved_quit_pre_print;`
510			`extern jmp_buf error_return;`
511			`extern jmp_buf quit_return;`
512
513			`saved_cleanup_chain = save_cleanups ();`
514			`saved_error_pre_print = error_pre_print;`
515			`saved_quit_pre_print = quit_pre_print;`
516
517			`memcpy ((char ) saved_error, (char ) error_return, sizeof (jmp_buf));`
518			`error_pre_print = "";`
519			`memcpy (saved_quit, quit_return, sizeof (jmp_buf));`
520			`quit_pre_print = "";`
521
522			`if (setjmp (tmp_jmp) == 0)`
523			`{`
524			`va_list argList = args;`
525			`memcpy (error_return, tmp_jmp, sizeof (jmp_buf));`
526			`memcpy (quit_return, tmp_jmp, sizeof (jmp_buf));`
527			`ret = func (argList);`
528			`}`
529			`restore_cleanups (saved_cleanup_chain);`
530			`memcpy (error_return, saved_error, sizeof (jmp_buf));`
531			`error_pre_print = saved_error_pre_print;`
532			`memcpy (quit_return, saved_quit, sizeof (jmp_buf));`
533			`quit_pre_print = saved_quit_pre_print;`
534
535			`return ret;`
536			`}`
537
538			`/*`
539			`** vcatch_errors().`
540			`** Catch errors occurring in tui or non tui function, handling`
541			`** variable param lists. Note that 'func' must take a variable`
542			`** argument list as well.`
543			`*/`
544			`Opaque`
545			`#ifdef __STDC__`
546			`vcatch_errors (`
547			`OpaqueFuncPtr func,...)`
548			`#else`
549			`vcatch_errors (va_alist)`
550			`va_dcl`
551			`/*`
552			`vcatch_errors(func, va_alist)`
553			`OpaqueFuncPtr func;`
554			`va_dcl`
555			`*/`
556			`#endif`
557			`{`
558			`Opaque ret = (Opaque) NULL;`
559			`va_list args;`
560			`#ifdef __STDC__`
561			`va_start (args, func);`
562			`/*`
563			`va_arg(args, OpaqueFuncPtr);`
564			`*/`
565			`#else`
566			`OpaqueFuncPtr func;`
567
568			`va_start (args);`
569			`func = va_arg (args, OpaqueFuncPtr);`
570			`#endif`
571			`ret = va_catch_errors (func, args);`
572			`va_end (args);`
573
574			`return ret;`
575			`}`
576
577
578			`void`
579			`#ifdef __STDC__`
580			`strcat_to_buf (`
581			`char *buf,`
582			`int buflen,`
583			`char *itemToAdd)`
584			`#else`
585			`strcat_to_buf (buf, buflen, itemToAdd)`
586			`char *buf;`
587			`int buflen;`
588			`char *itemToAdd;`
589			`#endif`
590			`{`
591			`if (itemToAdd != (char ) NULL && buf != (char ) NULL)`
592			`{`
593			`if ((strlen (buf) + strlen (itemToAdd)) <= buflen)`
594			`strcat (buf, itemToAdd);`
595			`else`
596			`strncat (buf, itemToAdd, (buflen - strlen (buf)));`
597			`}`
598
599			`return;`
600			`} /* strcat_to_buf */`
601
602			`/* VARARGS */`
603			`void`
604			`#ifdef ANSI_PROTOTYPES`
605			`strcat_to_buf_with_fmt (`
606			`char *buf,`
607			`int bufLen,`
608			`char *format,...)`
609			`#else`
610			`strcat_to_buf_with_fmt (va_alist)`
611			`va_dcl`
612			`#endif`
613			`{`
614			`char *linebuffer;`
615			`struct cleanup *old_cleanups;`
616			`va_list args;`
617			`#ifdef ANSI_PROTOTYPES`
618			`va_start (args, format);`
619			`#else`
620			`char *buf;`
621			`int bufLen;`
622			`char *format;`
623
624			`va_start (args);`
625			`buf = va_arg (args, char *);`
626			`bufLen = va_arg (args, int);`
627			`format = va_arg (args, char *);`
628			`#endif`
629			`vasprintf (&linebuffer, format, args);`
630			`old_cleanups = make_cleanup (free, linebuffer);`
631			`strcat_to_buf (buf, bufLen, linebuffer);`
632			`do_cleanups (old_cleanups);`
633			`va_end (args);`
634			`}`
635
636
637
638
639
640			`/***********************`
641			`** Static Functions`
642			`************************/`
643
644
645			`/*`
646			`** _tui_vDo().`
647			`** General purpose function to execute a tui function. Transitions`
648			`** between curses and the are handled here. This function is called`
649			`** by non-tui gdb functions.`
650			`**`
651			`** Errors are caught here.`
652			`** If there is no error, the value returned by 'func' is returned.`
653			`** If there is an error, then zero is returned.`
654			`**`
655			`** Must not be called with immediate_quit in effect (bad things might`
656			`** happen, say we got a signal in the middle of a memcpy to quit_return).`
657			`** This is an OK restriction; with very few exceptions immediate_quit can`
658			`** be replaced by judicious use of QUIT.`
659			`*/`
660			`static Opaque`
661			`#ifdef __STDC__`
662			`_tui_vDo (`
663			`TuiOpaqueFuncPtr func,`
664			`va_list args)`
665			`#else`
666			`_tui_vDo (func, args)`
667			`TuiOpaqueFuncPtr func;`
668			`va_list args;`
669			`#endif`
670			`{`
671			`extern int terminal_is_ours;`
672
673			`Opaque ret = (Opaque) NULL;`
674
675			`/* It is an error to be tuiDo'ing if we`
676			`* don't own the terminal.`
677			`*/`
678			`if (!terminal_is_ours)`
679			`return ret;`
680
681			`if (tui_version)`
682			`{`
683			`/* If doing command window the "XDB way" (command window`
684			`* is unmanaged by curses...`
685			`*/`
686			`/* Set up terminal for TUI */`
687			`tuiTermSetup (1);`
688
689			`ret = va_catch_errors (func, args);`
690
691			`/* Set up terminal for command window */`
692			`tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);`
693			`}`
694
695			`return ret;`
696			`} /* _tui_vDo */`
697
698
699			`static void`
700			`#ifdef __STDC__`
701			`_toggle_command (`
702			`char *arg,`
703			`int fromTTY)`
704			`#else`
705			`_toggle_command (arg, fromTTY)`
706			`char *arg;`
707			`int fromTTY;`
708			`#endif`
709			`{`
710			`printf_filtered ("Specify feature to toggle.\n%s\n",`
711			`(tui_version) ? TUI_TOGGLE_USAGE : TOGGLE_USAGE);`
712			`/*`
713			`tuiDo((TuiOpaqueFuncPtr)_Toggle_command, arg, fromTTY);`
714			`*/`
715			`}`
716
717			`/*`
718			`** _tui_vToggle_command().`
719			`*/`
720			`static void`
721			`#ifdef __STDC__`
722			`_tui_vToggle_command (`
723			`va_list args)`
724			`#else`
725			`_tui_vToggle_command (args)`
726			`va_list args;`
727			`#endif`
728			`{`
729			`char *arg;`
730			`int fromTTY;`
731
732			`arg = va_arg (args, char *);`
733
734			`if (arg == (char *) NULL)`
735			`printf_filtered (TOGGLE_USAGE);`
736			`else`
737			`{`
738			`char ptr = (char ) tuiStrDup (arg);`
739			`int i;`
740
741			`for (i = 0; (ptr[i]); i++)`
742			`ptr[i] = toupper (arg[i]);`
743
744			`if (subsetCompare (ptr, TUI_FLOAT_REGS_NAME))`
745			`tuiToggleFloatRegs ();`
746			`/* else if (subsetCompare(ptr, "ANOTHER TOGGLE OPTION"))`
747			`...`
748			`*/`
749			`else`
750			`printf_filtered (TOGGLE_USAGE);`
751			`tuiFree (ptr);`
752			`}`
753
754			`return;`
755			`} /* _tuiToggle_command */`
756
757
758			`static void`
759			`#ifdef __STDC__`
760			`_tuiReset (void)`
761			`#else`
762			`_tuiReset ()`
763			`#endif`
764			`{`
765			`struct termio mode;`
766
767			`/*`
768			`** reset the teletype mode bits to a sensible state.`
769			`** Copied tset.c`
770			`*/`
771			`#if ! defined (USG) && defined (TIOCGETC)`
772			`struct tchars tbuf;`
773			`#endif /* !USG && TIOCGETC */`
774			`#ifdef UCB_NTTY`
775			`struct ltchars ltc;`
776
777			`if (ldisc == NTTYDISC)`
778			`{`
779			`ioctl (FILEDES, TIOCGLTC, &ltc);`
780			`ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));`
781			`ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));`
782			`ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));`
783			`ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));`
784			`ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));`
785			`ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));`
786			`ioctl (FILEDES, TIOCSLTC, &ltc);`
787			`}`
788			`#endif /* UCB_NTTY */`
789			`#ifndef USG`
790			`#ifdef TIOCGETC`
791			`ioctl (FILEDES, TIOCGETC, &tbuf);`
792			`tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));`
793			`tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));`
794			`tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));`
795			`tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));`
796			`tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));`
797			`/* brkc is left alone */`
798			`ioctl (FILEDES, TIOCSETC, &tbuf);`
799			`#endif /* TIOCGETC */`
800			`mode.sg_flags &= ~(RAW`
801			`#ifdef CBREAK`
802			`\| CBREAK`
803			`#endif /* CBREAK */`
804			`\| VTDELAY \| ALLDELAY);`
805			`mode.sg_flags \|= XTABS \| ECHO \| CRMOD \| ANYP;`
806			`#else /USG /`
807			`ioctl (FILEDES, TCGETA, &mode);`
808			`mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));`
809			`mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));`
810			`mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));`
811
812			`mode.c_iflag &= ~(IGNBRK \| PARMRK \| INPCK \| INLCR \| IGNCR \| IUCLC \| IXOFF);`
813			`mode.c_iflag \|= (BRKINT \| ISTRIP \| ICRNL \| IXON);`
814			`mode.c_oflag &= ~(OLCUC \| OCRNL \| ONOCR \| ONLRET \| OFILL \| OFDEL \|`
815			`NLDLY \| CRDLY \| TABDLY \| BSDLY \| VTDLY \| FFDLY);`
816			`mode.c_oflag \|= (OPOST \| ONLCR);`
817			`mode.c_cflag &= ~(CSIZE \| PARODD \| CLOCAL);`
818			`#ifndef hp9000s800`
819			`mode.c_cflag \|= (CS8 \| CREAD);`
820			`#else /hp9000s800 /`
821			`mode.c_cflag \|= (CS8 \| CSTOPB \| CREAD);`
822			`#endif /* hp9000s800 */`
823			`mode.c_lflag &= ~(XCASE \| ECHONL \| NOFLSH);`
824			`mode.c_lflag \|= (ISIG \| ICANON \| ECHO \| ECHOK);`
825			`ioctl (FILEDES, TCSETAW, &mode);`
826			`#endif /* USG */`
827
828			`return;`
829			`} /* _tuiReset */`