gdb/tui/tuiIO.c

   1 /* TUI support I/O functions.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Hewlett-Packard Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
  26    "defs.h" should be included first.  Unfortunatly some systems
  27    (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
  28    and they clash with "bfd.h"'s definiton of true/false.  The correct
  29    fix is to remove true/false from "bfd.h", however, until that
  30    happens, hack around it by including "config.h" and <curses.h>
  31    first.  */
  32
  33 #include "config.h"
  34 #ifdef HAVE_NCURSES_H
  35 #include <ncurses.h>
  36 #else
  37 #ifdef HAVE_CURSES_H
  38 #include <curses.h>
  39 #endif
  40 #endif
  41
  42 #include <stdio.h>
  43 #include "defs.h"
  44 #include "terminal.h"
  45 #include "target.h"
  46 #include "event-loop.h"
  47 #include "event-top.h"
  48 #include "command.h"
  49 #include "top.h"
  50 #include "readline/readline.h"
  51 #include "tui.h"
  52 #include "tuiData.h"
  53 #include "tuiIO.h"
  54 #include "tuiCommand.h"
  55 #include "tuiWin.h"
  56 #include "tuiGeneralWin.h"
  57 #include "tui-file.h"
  58 #include "ui-out.h"
  59 #include "cli-out.h"
  60 #include <fcntl.h>
  61 #include <signal.h>
  62
  63 /* Use definition from readline 4.3.  */
  64 #undef CTRL_CHAR
  65 #define CTRL_CHAR(c) ((c) < control_character_threshold && (((c) & 0x80) == 0))
  66
  67 /* This file controls the IO interactions between gdb and curses.
  68    When the TUI is enabled, gdb has two modes a curses and a standard
  69    mode.
  70
  71    In curses mode, the gdb outputs are made in a curses command window.
  72    For this, the gdb_stdout and gdb_stderr are redirected to the specific
  73    ui_file implemented by TUI.  The output is handled by tui_puts().
  74    The input is also controlled by curses with tui_getc().  The readline
  75    library uses this function to get its input.  Several readline hooks
  76    are installed to redirect readline output to the TUI (see also the
  77    note below).
  78
  79    In normal mode, the gdb outputs are restored to their origin, that
  80    is as if TUI is not used.  Readline also uses its original getc()
  81    function with stdin.
  82
  83    Note SCz/2001-07-21: the current readline is not clean in its management of
  84    the output.  Even if we install a redisplay handler, it sometimes writes on
  85    a stdout file.  It is important to redirect every output produced by
  86    readline, otherwise the curses window will be garbled.  This is implemented
  87    with a pipe that TUI reads and readline writes to.  A gdb input handler
  88    is created so that reading the pipe is handled automatically.
  89    This will probably not work on non-Unix platforms.  The best fix is
  90    to make readline clean enougth so that is never write on stdout.
  91
  92    Note SCz/2002-09-01: we now use more readline hooks and it seems that
  93    with them we don't need the pipe anymore (verified by creating the pipe
  94    and closing its end so that write causes a SIGPIPE).  The old pipe code
  95    is still there and can be conditionally removed by
  96    #undef TUI_USE_PIPE_FOR_READLINE.  */
  97
  98 /* For gdb 5.3, prefer to continue the pipe hack as a backup wheel.  */
  99 #define TUI_USE_PIPE_FOR_READLINE
 100 /*#undef TUI_USE_PIPE_FOR_READLINE*/
 101
 102 /* TUI output files.  */
 103 static struct ui_file *tui_stdout;
 104 static struct ui_file *tui_stderr;
 105 struct ui_out *tui_out;
 106
 107 /* GDB output files in non-curses mode.  */
 108 static struct ui_file *tui_old_stdout;
 109 static struct ui_file *tui_old_stderr;
 110 struct ui_out *tui_old_uiout;
 111
 112 /* Readline previous hooks.  */
 113 static Function *tui_old_rl_getc_function;
 114 static VFunction *tui_old_rl_redisplay_function;
 115 static VFunction *tui_old_rl_prep_terminal;
 116 static VFunction *tui_old_rl_deprep_terminal;
 117 static int tui_old_readline_echoing_p;
 118
 119 /* Readline output stream.
 120    Should be removed when readline is clean.  */
 121 static FILE *tui_rl_outstream;
 122 static FILE *tui_old_rl_outstream;
 123 #ifdef TUI_USE_PIPE_FOR_READLINE
 124 static int tui_readline_pipe[2];
 125 #endif
 126
 127 /* The last gdb prompt that was registered in readline.
 128    This may be the main gdb prompt or a secondary prompt.  */
 129 static char *tui_rl_saved_prompt;
 130
 131 static unsigned int _tuiHandleResizeDuringIO (unsigned int);
 132
 133 static void
 134 tui_putc (char c)
 135 {
 136   char buf[2];
 137
 138   buf[0] = c;
 139   buf[1] = 0;
 140   tui_puts (buf);
 141 }
 142
 143 /* Print the string in the curses command window.  */
 144 void
 145 tui_puts (const char *string)
 146 {
 147   static int tui_skip_line = -1;
 148   char c;
 149   WINDOW *w;
 150
 151   w = cmdWin->generic.handle;
 152   while ((c = *string++) != 0)
 153     {
 154       /* Catch annotation and discard them.  We need two \032 and
 155          discard until a \n is seen.  */
 156       if (c == '\032')
 157         {
 158           tui_skip_line++;
 159         }
 160       else if (tui_skip_line != 1)
 161         {
 162           tui_skip_line = -1;
 163           waddch (w, c);
 164         }
 165       else if (c == '\n')
 166         tui_skip_line = -1;
 167     }
 168   getyx (w, cmdWin->detail.commandInfo.curLine,
 169          cmdWin->detail.commandInfo.curch);
 170   cmdWin->detail.commandInfo.start_line = cmdWin->detail.commandInfo.curLine;
 171
 172   /* We could defer the following.  */
 173   wrefresh (w);
 174   fflush (stdout);
 175 }
 176
 177 /* Readline callback.
 178    Redisplay the command line with its prompt after readline has
 179    changed the edited text.  */
 180 void
 181 tui_redisplay_readline (void)
 182 {
 183   int prev_col;
 184   int height;
 185   int col, line;
 186   int c_pos;
 187   int c_line;
 188   int in;
 189   WINDOW *w;
 190   char *prompt;
 191   int start_line;
 192
 193   /* Detect when we temporarily left SingleKey and now the readline
 194      edit buffer is empty, automatically restore the SingleKey mode.  */
 195   if (tui_current_key_mode == tui_one_command_mode && rl_end == 0)
 196     tui_set_key_mode (tui_single_key_mode);
 197
 198   if (tui_current_key_mode == tui_single_key_mode)
 199     prompt = "";
 200   else
 201     prompt = tui_rl_saved_prompt;
 202
 203   c_pos = -1;
 204   c_line = -1;
 205   w = cmdWin->generic.handle;
 206   start_line = cmdWin->detail.commandInfo.start_line;
 207   wmove (w, start_line, 0);
 208   prev_col = 0;
 209   height = 1;
 210   for (in = 0; prompt && prompt[in]; in++)
 211     {
 212       waddch (w, prompt[in]);
 213       getyx (w, line, col);
 214       if (col < prev_col)
 215         height++;
 216       prev_col = col;
 217     }
 218   for (in = 0; in < rl_end; in++)
 219     {
 220       unsigned char c;
 221
 222       c = (unsigned char) rl_line_buffer[in];
 223       if (in == rl_point)
 224         {
 225           getyx (w, c_line, c_pos);
 226         }
 227
 228       if (CTRL_CHAR (c) || c == RUBOUT)
 229         {
 230           waddch (w, '^');
 231           waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
 232         }
 233       else
 234         {
 235           waddch (w, c);
 236         }
 237       if (c == '\n')
 238         {
 239           getyx (w, cmdWin->detail.commandInfo.start_line,
 240                  cmdWin->detail.commandInfo.curch);
 241         }
 242       getyx (w, line, col);
 243       if (col < prev_col)
 244         height++;
 245       prev_col = col;
 246     }
 247   wclrtobot (w);
 248   getyx (w, cmdWin->detail.commandInfo.start_line,
 249          cmdWin->detail.commandInfo.curch);
 250   if (c_line >= 0)
 251     {
 252       wmove (w, c_line, c_pos);
 253       cmdWin->detail.commandInfo.curLine = c_line;
 254       cmdWin->detail.commandInfo.curch = c_pos;
 255     }
 256   cmdWin->detail.commandInfo.start_line -= height - 1;
 257
 258   wrefresh (w);
 259   fflush(stdout);
 260 }
 261
 262 /* Readline callback to prepare the terminal.  It is called once
 263    each time we enter readline.  Terminal is already setup in curses mode.  */
 264 static void
 265 tui_prep_terminal (void)
 266 {
 267   /* Save the prompt registered in readline to correctly display it.
 268      (we can't use gdb_prompt() due to secondary prompts and can't use
 269      rl_prompt because it points to an alloca buffer).  */
 270   xfree (tui_rl_saved_prompt);
 271   tui_rl_saved_prompt = xstrdup (rl_prompt);
 272 }
 273
 274 /* Readline callback to restore the terminal.  It is called once
 275    each time we leave readline.  There is nothing to do in curses mode.  */
 276 static void
 277 tui_deprep_terminal (void)
 278 {
 279 }
 280
 281 #ifdef TUI_USE_PIPE_FOR_READLINE
 282 /* Read readline output pipe and feed the command window with it.
 283    Should be removed when readline is clean.  */
 284 static void
 285 tui_readline_output (int code, gdb_client_data data)
 286 {
 287   int size;
 288   char buf[256];
 289
 290   size = read (tui_readline_pipe[0], buf, sizeof (buf) - 1);
 291   if (size > 0 && tui_active)
 292     {
 293       buf[size] = 0;
 294       tui_puts (buf);
 295     }
 296 }
 297 #endif
 298
 299 /* Return the portion of PATHNAME that should be output when listing
 300    possible completions.  If we are hacking filename completion, we
 301    are only interested in the basename, the portion following the
 302    final slash.  Otherwise, we return what we were passed.
 303
 304    Comes from readline/complete.c  */
 305 static char *
 306 printable_part (pathname)
 307      char *pathname;
 308 {
 309   char *temp;
 310
 311   temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL;
 312 #if defined (__MSDOS__)
 313   if (rl_filename_completion_desired && temp == 0 && isalpha (pathname[0]) && pathname[1] == ':')
 314     temp = pathname + 1;
 315 #endif
 316   return (temp ? ++temp : pathname);
 317 }
 318
 319 /* Output TO_PRINT to rl_outstream.  If VISIBLE_STATS is defined and we
 320    are using it, check for and output a single character for `special'
 321    filenames.  Return the number of characters we output. */
 322
 323 #define PUTX(c) \
 324     do { \
 325       if (CTRL_CHAR (c)) \
 326         { \
 327           tui_puts ("^"); \
 328           tui_putc (UNCTRL (c)); \
 329           printed_len += 2; \
 330         } \
 331       else if (c == RUBOUT) \
 332         { \
 333           tui_puts ("^?"); \
 334           printed_len += 2; \
 335         } \
 336       else \
 337         { \
 338           tui_putc (c); \
 339           printed_len++; \
 340         } \
 341     } while (0)
 342
 343 static int
 344 print_filename (to_print, full_pathname)
 345      char *to_print, *full_pathname;
 346 {
 347   int printed_len = 0;
 348   char *s;
 349
 350   for (s = to_print; *s; s++)
 351     {
 352       PUTX (*s);
 353     }
 354   return printed_len;
 355 }
 356
 357 /* The user must press "y" or "n".  Non-zero return means "y" pressed.
 358    Comes from readline/complete.c  */
 359 static int
 360 get_y_or_n ()
 361 {
 362   extern int _rl_abort_internal ();
 363   int c;
 364
 365   for (;;)
 366     {
 367       c = rl_read_key ();
 368       if (c == 'y' || c == 'Y' || c == ' ')
 369         return (1);
 370       if (c == 'n' || c == 'N' || c == RUBOUT)
 371         return (0);
 372       if (c == ABORT_CHAR)
 373         _rl_abort_internal ();
 374       beep ();
 375     }
 376 }
 377
 378 /* A convenience function for displaying a list of strings in
 379    columnar format on readline's output stream.  MATCHES is the list
 380    of strings, in argv format, LEN is the number of strings in MATCHES,
 381    and MAX is the length of the longest string in MATCHES.
 382
 383    Comes from readline/complete.c and modified to write in
 384    the TUI command window using tui_putc/tui_puts.  */
 385 static void
 386 tui_rl_display_match_list (matches, len, max)
 387      char **matches;
 388      int len, max;
 389 {
 390   typedef int QSFUNC (const void *, const void *);
 391   extern int _rl_qsort_string_compare (const void*, const void*);
 392   extern int _rl_print_completions_horizontally;
 393
 394   int count, limit, printed_len;
 395   int i, j, k, l;
 396   char *temp;
 397
 398   /* Screen dimension correspond to the TUI command window.  */
 399   int screenwidth = cmdWin->generic.width;
 400
 401   /* If there are many items, then ask the user if she really wants to
 402      see them all. */
 403   if (len >= rl_completion_query_items)
 404     {
 405       char msg[256];
 406
 407       sprintf (msg, "\nDisplay all %d possibilities? (y or n)", len);
 408       tui_puts (msg);
 409       if (get_y_or_n () == 0)
 410         {
 411           tui_puts ("\n");
 412           return;
 413         }
 414     }
 415
 416   /* How many items of MAX length can we fit in the screen window? */
 417   max += 2;
 418   limit = screenwidth / max;
 419   if (limit != 1 && (limit * max == screenwidth))
 420     limit--;
 421
 422   /* Avoid a possible floating exception.  If max > screenwidth,
 423      limit will be 0 and a divide-by-zero fault will result. */
 424   if (limit == 0)
 425     limit = 1;
 426
 427   /* How many iterations of the printing loop? */
 428   count = (len + (limit - 1)) / limit;
 429
 430   /* Watch out for special case.  If LEN is less than LIMIT, then
 431      just do the inner printing loop.
 432            0 < len <= limit  implies  count = 1. */
 433
 434   /* Sort the items if they are not already sorted. */
 435   if (rl_ignore_completion_duplicates == 0)
 436     qsort (matches + 1, len, sizeof (char *),
 437            (QSFUNC *)_rl_qsort_string_compare);
 438
 439   tui_putc ('\n');
 440
 441   if (_rl_print_completions_horizontally == 0)
 442     {
 443       /* Print the sorted items, up-and-down alphabetically, like ls. */
 444       for (i = 1; i <= count; i++)
 445         {
 446           for (j = 0, l = i; j < limit; j++)
 447             {
 448               if (l > len || matches[l] == 0)
 449                 break;
 450               else
 451                 {
 452                   temp = printable_part (matches[l]);
 453                   printed_len = print_filename (temp, matches[l]);
 454
 455                   if (j + 1 < limit)
 456                     for (k = 0; k < max - printed_len; k++)
 457                       tui_putc (' ');
 458                 }
 459               l += count;
 460             }
 461           tui_putc ('\n');
 462         }
 463     }
 464   else
 465     {
 466       /* Print the sorted items, across alphabetically, like ls -x. */
 467       for (i = 1; matches[i]; i++)
 468         {
 469           temp = printable_part (matches[i]);
 470           printed_len = print_filename (temp, matches[i]);
 471           /* Have we reached the end of this line? */
 472           if (matches[i+1])
 473             {
 474               if (i && (limit > 1) && (i % limit) == 0)
 475                 tui_putc ('\n');
 476               else
 477                 for (k = 0; k < max - printed_len; k++)
 478                   tui_putc (' ');
 479             }
 480         }
 481       tui_putc ('\n');
 482     }
 483 }
 484
 485 /* Setup the IO for curses or non-curses mode.
 486    - In non-curses mode, readline and gdb use the standard input and
 487    standard output/error directly.
 488    - In curses mode, the standard output/error is controlled by TUI
 489    with the tui_stdout and tui_stderr.  The output is redirected in
 490    the curses command window.  Several readline callbacks are installed
 491    so that readline asks for its input to the curses command window
 492    with wgetch().  */
 493 void
 494 tui_setup_io (int mode)
 495 {
 496   extern int readline_echoing_p;
 497
 498   if (mode)
 499     {
 500       /* Redirect readline to TUI.  */
 501       tui_old_rl_redisplay_function = rl_redisplay_function;
 502       tui_old_rl_deprep_terminal = rl_deprep_term_function;
 503       tui_old_rl_prep_terminal = rl_prep_term_function;
 504       tui_old_rl_getc_function = rl_getc_function;
 505       tui_old_rl_outstream = rl_outstream;
 506       tui_old_readline_echoing_p = readline_echoing_p;
 507       rl_redisplay_function = tui_redisplay_readline;
 508       rl_deprep_term_function = tui_deprep_terminal;
 509       rl_prep_term_function = tui_prep_terminal;
 510       rl_getc_function = tui_getc;
 511       readline_echoing_p = 0;
 512       rl_outstream = tui_rl_outstream;
 513       rl_prompt = 0;
 514       rl_completion_display_matches_hook = tui_rl_display_match_list;
 515       rl_already_prompted = 0;
 516
 517       /* Keep track of previous gdb output.  */
 518       tui_old_stdout = gdb_stdout;
 519       tui_old_stderr = gdb_stderr;
 520       tui_old_uiout = uiout;
 521
 522       /* Reconfigure gdb output.  */
 523       gdb_stdout = tui_stdout;
 524       gdb_stderr = tui_stderr;
 525       gdb_stdlog = gdb_stdout;  /* for moment */
 526       gdb_stdtarg = gdb_stderr; /* for moment */
 527       uiout = tui_out;
 528
 529       /* Save tty for SIGCONT.  */
 530       savetty ();
 531     }
 532   else
 533     {
 534       /* Restore gdb output.  */
 535       gdb_stdout = tui_old_stdout;
 536       gdb_stderr = tui_old_stderr;
 537       gdb_stdlog = gdb_stdout;  /* for moment */
 538       gdb_stdtarg = gdb_stderr; /* for moment */
 539       uiout = tui_old_uiout;
 540
 541       /* Restore readline.  */
 542       rl_redisplay_function = tui_old_rl_redisplay_function;
 543       rl_deprep_term_function = tui_old_rl_deprep_terminal;
 544       rl_prep_term_function = tui_old_rl_prep_terminal;
 545       rl_getc_function = tui_old_rl_getc_function;
 546       rl_outstream = tui_old_rl_outstream;
 547       rl_completion_display_matches_hook = 0;
 548       readline_echoing_p = tui_old_readline_echoing_p;
 549       rl_already_prompted = 0;
 550
 551       /* Save tty for SIGCONT.  */
 552       savetty ();
 553     }
 554 }
 555
 556 #ifdef SIGCONT
 557 /* Catch SIGCONT to restore the terminal and refresh the screen.  */
 558 static void
 559 tui_cont_sig (int sig)
 560 {
 561   if (tui_active)
 562     {
 563       /* Restore the terminal setting because another process (shell)
 564          might have changed it.  */
 565       resetty ();
 566
 567       /* Force a refresh of the screen.  */
 568       tuiRefreshAll ();
 569
 570       /* Update cursor position on the screen.  */
 571       wmove (cmdWin->generic.handle,
 572              cmdWin->detail.commandInfo.start_line,
 573              cmdWin->detail.commandInfo.curch);
 574       wrefresh (cmdWin->generic.handle);
 575     }
 576   signal (sig, tui_cont_sig);
 577 }
 578 #endif
 579
 580 /* Initialize the IO for gdb in curses mode.  */
 581 void
 582 tui_initialize_io ()
 583 {
 584 #ifdef SIGCONT
 585   signal (SIGCONT, tui_cont_sig);
 586 #endif
 587
 588   /* Create tui output streams.  */
 589   tui_stdout = tui_fileopen (stdout);
 590   tui_stderr = tui_fileopen (stderr);
 591   tui_out = tui_out_new (tui_stdout);
 592
 593   /* Create the default UI.  It is not created because we installed
 594      a init_ui_hook.  */
 595   tui_old_uiout = uiout = cli_out_new (gdb_stdout);
 596
 597 #ifdef TUI_USE_PIPE_FOR_READLINE
 598   /* Temporary solution for readline writing to stdout:
 599      redirect readline output in a pipe, read that pipe and
 600      output the content in the curses command window.  */
 601   if (pipe (tui_readline_pipe) != 0)
 602     {
 603       fprintf_unfiltered (gdb_stderr, "Cannot create pipe for readline");
 604       exit (1);
 605     }
 606   tui_rl_outstream = fdopen (tui_readline_pipe[1], "w");
 607   if (tui_rl_outstream == 0)
 608     {
 609       fprintf_unfiltered (gdb_stderr, "Cannot redirect readline output");
 610       exit (1);
 611     }
 612   setvbuf (tui_rl_outstream, (char*) NULL, _IOLBF, 0);
 613
 614 #ifdef O_NONBLOCK
 615   (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NONBLOCK);
 616 #else
 617 #ifdef O_NDELAY
 618   (void) fcntl (tui_readline_pipe[0], F_SETFL, O_NDELAY);
 619 #endif
 620 #endif
 621   add_file_handler (tui_readline_pipe[0], tui_readline_output, 0);
 622 #else
 623   tui_rl_outstream = stdout;
 624 #endif
 625 }
 626
 627 /* Get a character from the command window.  This is called from the readline
 628    package.  */
 629 int
 630 tui_getc (FILE *fp)
 631 {
 632   int ch;
 633   WINDOW *w;
 634
 635   w = cmdWin->generic.handle;
 636
 637 #ifdef TUI_USE_PIPE_FOR_READLINE
 638   /* Flush readline output.  */
 639   tui_readline_output (GDB_READABLE, 0);
 640 #endif
 641
 642   ch = wgetch (w);
 643   ch = _tuiHandleResizeDuringIO (ch);
 644
 645   /* The \n must be echoed because it will not be printed by readline.  */
 646   if (ch == '\n')
 647     {
 648       /* When hitting return with an empty input, gdb executes the last
 649          command.  If we emit a newline, this fills up the command window
 650          with empty lines with gdb prompt at beginning.  Instead of that,
 651          stay on the same line but provide a visual effect to show the
 652          user we recognized the command.  */
 653       if (rl_end == 0)
 654         {
 655           wmove (w, cmdWin->detail.commandInfo.curLine, 0);
 656
 657           /* Clear the line.  This will blink the gdb prompt since
 658              it will be redrawn at the same line.  */
 659           wclrtoeol (w);
 660           wrefresh (w);
 661           napms (20);
 662         }
 663       else
 664         {
 665           wmove (w, cmdWin->detail.commandInfo.curLine,
 666                  cmdWin->detail.commandInfo.curch);
 667           waddch (w, ch);
 668         }
 669     }
 670
 671   if (m_isCommandChar (ch))
 672     {                           /* Handle prev/next/up/down here */
 673       ch = tuiDispatchCtrlChar (ch);
 674     }
 675
 676   if (ch == '\n' || ch == '\r' || ch == '\f')
 677     cmdWin->detail.commandInfo.curch = 0;
 678 #if 0
 679   else
 680     tuiIncrCommandCharCountBy (1);
 681 #endif
 682   if (ch == KEY_BACKSPACE)
 683     return '\b';
 684
 685   return ch;
 686 }
 687
 688
 689 /* Cleanup when a resize has occured.
 690    Returns the character that must be processed.  */
 691 static unsigned int
 692 _tuiHandleResizeDuringIO (unsigned int originalCh)
 693 {
 694   if (tuiWinResized ())
 695     {
 696       tuiRefreshAll ();
 697       dont_repeat ();
 698       tuiSetWinResizedTo (FALSE);
 699       return '\n';
 700     }
 701   else
 702     return originalCh;
 703 }