| /* |
| ** tui.c |
| ** General functions for the WDB TUI |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include <malloc.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, <c); |
| 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, <c); |
| } |
| #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 */ |