lib/readline/terminal.c

   1 /* terminal.c -- controlling the terminal with termcap. */
   2
   3 /* Copyright (C) 1996-2009 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library (Readline), a library
   6    for reading lines of text with interactive input and history editing.
   7
   8    Readline is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    Readline is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29 #include "posixstat.h"
  30 #include <fcntl.h>
  31 #if defined (HAVE_SYS_FILE_H)
  32 #  include <sys/file.h>
  33 #endif /* HAVE_SYS_FILE_H */
  34
  35 #if defined (HAVE_UNISTD_H)
  36 #  include <unistd.h>
  37 #endif /* HAVE_UNISTD_H */
  38
  39 #if defined (HAVE_STDLIB_H)
  40 #  include <stdlib.h>
  41 #else
  42 #  include "ansi_stdlib.h"
  43 #endif /* HAVE_STDLIB_H */
  44
  45 #if defined (HAVE_LOCALE_H)
  46 #  include <locale.h>
  47 #endif
  48
  49 #include <stdio.h>
  50
  51 /* System-specific feature definitions and include files. */
  52 #include "rldefs.h"
  53
  54 #if defined (GWINSZ_IN_SYS_IOCTL) && !defined (TIOCGWINSZ)
  55 #  include <sys/ioctl.h>
  56 #endif /* GWINSZ_IN_SYS_IOCTL && !TIOCGWINSZ */
  57
  58 #ifdef __MSDOS__
  59 #  include <pc.h>
  60 #endif
  61
  62 #include "rltty.h"
  63 #include "tcap.h"
  64
  65 /* Some standard library routines. */
  66 #include "readline.h"
  67 #include "history.h"
  68
  69 #include "rlprivate.h"
  70 #include "rlshell.h"
  71 #include "xmalloc.h"
  72
  73 #if defined (__MINGW32__)
  74 #  include <windows.h>
  75 #  include <wincon.h>
  76
  77 static void _win_get_screensize PARAMS((int *, int *));
  78 #endif
  79
  80 #if defined (__EMX__)
  81 static void _emx_get_screensize PARAMS((int *, int *));
  82 #endif
  83
  84 /* If the calling application sets this to a non-zero value, readline will
  85    use the $LINES and $COLUMNS environment variables to set its idea of the
  86    window size before interrogating the kernel. */
  87 int rl_prefer_env_winsize = 0;
  88
  89 /* If this is non-zero, readline will set LINES and COLUMNS in the
  90    environment when it handles SIGWINCH. */
  91 int rl_change_environment = 1;
  92
  93 /* **************************************************************** */
  94 /*                                                                  */
  95 /*                      Terminal and Termcap                        */
  96 /*                                                                  */
  97 /* **************************************************************** */
  98
  99 #ifndef __MSDOS__
 100 static char *term_buffer = (char *)NULL;
 101 static char *term_string_buffer = (char *)NULL;
 102 #endif
 103
 104 static int tcap_initialized;
 105
 106 #if !defined (__linux__) && !defined (NCURSES_VERSION)
 107 #  if defined (__EMX__) || defined (NEED_EXTERN_PC)
 108 extern
 109 #  endif /* __EMX__ || NEED_EXTERN_PC */
 110 char PC, *BC, *UP;
 111 #endif /* !__linux__ && !NCURSES_VERSION */
 112
 113 /* Some strings to control terminal actions.  These are output by tputs (). */
 114 char *_rl_term_clreol;
 115 char *_rl_term_clrpag;
 116 char *_rl_term_cr;
 117 char *_rl_term_backspace;
 118 char *_rl_term_goto;
 119 char *_rl_term_pc;
 120
 121 /* Non-zero if we determine that the terminal can do character insertion. */
 122 int _rl_terminal_can_insert = 0;
 123
 124 /* How to insert characters. */
 125 char *_rl_term_im;
 126 char *_rl_term_ei;
 127 char *_rl_term_ic;
 128 char *_rl_term_ip;
 129 char *_rl_term_IC;
 130
 131 /* How to delete characters. */
 132 char *_rl_term_dc;
 133 char *_rl_term_DC;
 134
 135 char *_rl_term_forward_char;
 136
 137 /* How to go up a line. */
 138 char *_rl_term_up;
 139
 140 /* A visible bell; char if the terminal can be made to flash the screen. */
 141 static char *_rl_visible_bell;
 142
 143 /* Non-zero means the terminal can auto-wrap lines. */
 144 int _rl_term_autowrap = -1;
 145
 146 /* Non-zero means that this terminal has a meta key. */
 147 static int term_has_meta;
 148
 149 /* The sequences to write to turn on and off the meta key, if this
 150    terminal has one. */
 151 static char *_rl_term_mm;
 152 static char *_rl_term_mo;
 153
 154 /* The key sequences output by the arrow keys, if this terminal has any. */
 155 static char *_rl_term_ku;
 156 static char *_rl_term_kd;
 157 static char *_rl_term_kr;
 158 static char *_rl_term_kl;
 159
 160 /* How to initialize and reset the arrow keys, if this terminal has any. */
 161 static char *_rl_term_ks;
 162 static char *_rl_term_ke;
 163
 164 /* The key sequences sent by the Home and End keys, if any. */
 165 static char *_rl_term_kh;
 166 static char *_rl_term_kH;
 167 static char *_rl_term_at7;      /* @7 */
 168
 169 /* Delete key */
 170 static char *_rl_term_kD;
 171
 172 /* Insert key */
 173 static char *_rl_term_kI;
 174
 175 /* Cursor control */
 176 static char *_rl_term_vs;       /* very visible */
 177 static char *_rl_term_ve;       /* normal */
 178
 179 static void bind_termcap_arrow_keys PARAMS((Keymap));
 180
 181 /* Variables that hold the screen dimensions, used by the display code. */
 182 int _rl_screenwidth, _rl_screenheight, _rl_screenchars;
 183
 184 /* Non-zero means the user wants to enable the keypad. */
 185 int _rl_enable_keypad;
 186
 187 /* Non-zero means the user wants to enable a meta key. */
 188 int _rl_enable_meta = 1;
 189
 190 #if defined (__EMX__)
 191 static void
 192 _emx_get_screensize (swp, shp)
 193      int *swp, *shp;
 194 {
 195   int sz[2];
 196
 197   _scrsize (sz);
 198
 199   if (swp)
 200     *swp = sz[0];
 201   if (shp)
 202     *shp = sz[1];
 203 }
 204 #endif
 205
 206 #if defined (__MINGW32__)
 207 static void
 208 _win_get_screensize (swp, shp)
 209      int *swp, *shp;
 210 {
 211   HANDLE hConOut;
 212   CONSOLE_SCREEN_BUFFER_INFO scr;
 213
 214   hConOut = GetStdHandle (STD_OUTPUT_HANDLE);
 215   if (hConOut != INVALID_HANDLE_VALUE)
 216     {
 217       if (GetConsoleScreenBufferInfo (hConOut, &scr))
 218         {
 219           *swp = scr.dwSize.X;
 220           *shp = scr.srWindow.Bottom - scr.srWindow.Top + 1;
 221         }
 222     }
 223 }
 224 #endif
 225
 226 /* Get readline's idea of the screen size.  TTY is a file descriptor open
 227    to the terminal.  If IGNORE_ENV is true, we do not pay attention to the
 228    values of $LINES and $COLUMNS.  The tests for TERM_STRING_BUFFER being
 229    non-null serve to check whether or not we have initialized termcap. */
 230 void
 231 _rl_get_screen_size (tty, ignore_env)
 232      int tty, ignore_env;
 233 {
 234   char *ss;
 235 #if defined (TIOCGWINSZ)
 236   struct winsize window_size;
 237 #endif /* TIOCGWINSZ */
 238   int wr, wc;
 239
 240   wr = wc = -1;
 241 #if defined (TIOCGWINSZ)
 242   if (ioctl (tty, TIOCGWINSZ, &window_size) == 0)
 243     {
 244       wc = (int) window_size.ws_col;
 245       wr = (int) window_size.ws_row;
 246     }
 247 #endif /* TIOCGWINSZ */
 248
 249 #if defined (__EMX__)
 250   _emx_get_screensize (&wc, &wr);
 251 #elif defined (__MINGW32__)
 252   _win_get_screensize (&wc, &wr);
 253 #endif
 254
 255   if (ignore_env || rl_prefer_env_winsize == 0)
 256     {
 257       _rl_screenwidth = wc;
 258       _rl_screenheight = wr;
 259     }
 260   else
 261     _rl_screenwidth = _rl_screenheight = -1;
 262
 263   /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV
 264      is unset.  If we prefer the environment, check it first before
 265      assigning the value returned by the kernel. */
 266   if (_rl_screenwidth <= 0)
 267     {
 268       if (ignore_env == 0 && (ss = sh_get_env_value ("COLUMNS")))
 269         _rl_screenwidth = atoi (ss);
 270
 271       if (_rl_screenwidth <= 0)
 272         _rl_screenwidth = wc;
 273
 274 #if defined (__DJGPP__)
 275       if (_rl_screenwidth <= 0)
 276         _rl_screenwidth = ScreenCols ();
 277 #else
 278       if (_rl_screenwidth <= 0 && term_string_buffer)
 279         _rl_screenwidth = tgetnum ("co");
 280 #endif
 281     }
 282
 283   /* Environment variable LINES overrides setting of "li" if IGNORE_ENV
 284      is unset. */
 285   if (_rl_screenheight <= 0)
 286     {
 287       if (ignore_env == 0 && (ss = sh_get_env_value ("LINES")))
 288         _rl_screenheight = atoi (ss);
 289
 290       if (_rl_screenheight <= 0)
 291         _rl_screenheight = wr;
 292
 293 #if defined (__DJGPP__)
 294       if (_rl_screenheight <= 0)
 295         _rl_screenheight = ScreenRows ();
 296 #else
 297       if (_rl_screenheight <= 0 && term_string_buffer)
 298         _rl_screenheight = tgetnum ("li");
 299 #endif
 300     }
 301
 302   /* If all else fails, default to 80x24 terminal. */
 303   if (_rl_screenwidth <= 1)
 304     _rl_screenwidth = 80;
 305
 306   if (_rl_screenheight <= 0)
 307     _rl_screenheight = 24;
 308
 309   /* If we're being compiled as part of bash, set the environment
 310      variables $LINES and $COLUMNS to new values.  Otherwise, just
 311      do a pair of putenv () or setenv () calls. */
 312   if (rl_change_environment)
 313     sh_set_lines_and_columns (_rl_screenheight, _rl_screenwidth);
 314
 315   if (_rl_term_autowrap == 0)
 316     _rl_screenwidth--;
 317
 318   _rl_screenchars = _rl_screenwidth * _rl_screenheight;
 319 }
 320
 321 void
 322 _rl_set_screen_size (rows, cols)
 323      int rows, cols;
 324 {
 325   if (_rl_term_autowrap == -1)
 326     _rl_init_terminal_io (rl_terminal_name);
 327
 328   if (rows > 0)
 329     _rl_screenheight = rows;
 330   if (cols > 0)
 331     {
 332       _rl_screenwidth = cols;
 333       if (_rl_term_autowrap == 0)
 334         _rl_screenwidth--;
 335     }
 336
 337   if (rows > 0 || cols > 0)
 338     _rl_screenchars = _rl_screenwidth * _rl_screenheight;
 339 }
 340
 341 void
 342 rl_set_screen_size (rows, cols)
 343      int rows, cols;
 344 {
 345   _rl_set_screen_size (rows, cols);
 346 }
 347
 348 void
 349 rl_get_screen_size (rows, cols)
 350      int *rows, *cols;
 351 {
 352   if (rows)
 353     *rows = _rl_screenheight;
 354   if (cols)
 355     *cols = _rl_screenwidth;
 356 }
 357
 358 void
 359 rl_reset_screen_size ()
 360 {
 361   _rl_get_screen_size (fileno (rl_instream), 0);
 362 }
 363
 364 void
 365 _rl_sigwinch_resize_terminal ()
 366 {
 367   _rl_get_screen_size (fileno (rl_instream), 1);
 368 }
 369
 370 void
 371 rl_resize_terminal ()
 372 {
 373   _rl_get_screen_size (fileno (rl_instream), 1);
 374   if (_rl_echoing_p)
 375     {
 376       if (CUSTOM_REDISPLAY_FUNC ())
 377         rl_forced_update_display ();
 378       else if (RL_ISSTATE(RL_STATE_REDISPLAYING) == 0)
 379         _rl_redisplay_after_sigwinch ();
 380     }
 381 }
 382
 383 struct _tc_string {
 384      const char * const tc_var;
 385      char **tc_value;
 386 };
 387
 388 /* This should be kept sorted, just in case we decide to change the
 389    search algorithm to something smarter. */
 390 static const struct _tc_string tc_strings[] =
 391 {
 392   { "@7", &_rl_term_at7 },
 393   { "DC", &_rl_term_DC },
 394   { "IC", &_rl_term_IC },
 395   { "ce", &_rl_term_clreol },
 396   { "cl", &_rl_term_clrpag },
 397   { "cr", &_rl_term_cr },
 398   { "dc", &_rl_term_dc },
 399   { "ei", &_rl_term_ei },
 400   { "ic", &_rl_term_ic },
 401   { "im", &_rl_term_im },
 402   { "kD", &_rl_term_kD },       /* delete */
 403   { "kH", &_rl_term_kH },       /* home down ?? */
 404   { "kI", &_rl_term_kI },       /* insert */
 405   { "kd", &_rl_term_kd },
 406   { "ke", &_rl_term_ke },       /* end keypad mode */
 407   { "kh", &_rl_term_kh },       /* home */
 408   { "kl", &_rl_term_kl },
 409   { "kr", &_rl_term_kr },
 410   { "ks", &_rl_term_ks },       /* start keypad mode */
 411   { "ku", &_rl_term_ku },
 412   { "le", &_rl_term_backspace },
 413   { "mm", &_rl_term_mm },
 414   { "mo", &_rl_term_mo },
 415   { "nd", &_rl_term_forward_char },
 416   { "pc", &_rl_term_pc },
 417   { "up", &_rl_term_up },
 418   { "vb", &_rl_visible_bell },
 419   { "vs", &_rl_term_vs },
 420   { "ve", &_rl_term_ve },
 421 };
 422
 423 #define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string))
 424
 425 /* Read the desired terminal capability strings into BP.  The capabilities
 426    are described in the TC_STRINGS table. */
 427 static void
 428 get_term_capabilities (bp)
 429      char **bp;
 430 {
 431 #if !defined (__DJGPP__)        /* XXX - doesn't DJGPP have a termcap library? */
 432   register int i;
 433
 434   for (i = 0; i < NUM_TC_STRINGS; i++)
 435     *(tc_strings[i].tc_value) = tgetstr ((char *)tc_strings[i].tc_var, bp);
 436 #endif
 437   tcap_initialized = 1;
 438 }
 439
 440 int
 441 _rl_init_terminal_io (terminal_name)
 442      const char *terminal_name;
 443 {
 444   const char *term;
 445   char *buffer;
 446   int tty, tgetent_ret;
 447
 448   term = terminal_name ? terminal_name : sh_get_env_value ("TERM");
 449   _rl_term_clrpag = _rl_term_cr = _rl_term_clreol = (char *)NULL;
 450   tty = rl_instream ? fileno (rl_instream) : 0;
 451
 452   if (term == 0)
 453     term = "dumb";
 454
 455 #ifdef __MSDOS__
 456   _rl_term_im = _rl_term_ei = _rl_term_ic = _rl_term_IC = (char *)NULL;
 457   _rl_term_up = _rl_term_dc = _rl_term_DC = _rl_visible_bell = (char *)NULL;
 458   _rl_term_ku = _rl_term_kd = _rl_term_kl = _rl_term_kr = (char *)NULL;
 459   _rl_term_mm = _rl_term_mo = (char *)NULL;
 460   _rl_terminal_can_insert = term_has_meta = _rl_term_autowrap = 0;
 461   _rl_term_cr = "\r";
 462   _rl_term_clreol = _rl_term_clrpag = _rl_term_backspace = (char *)NULL;
 463   _rl_term_goto = _rl_term_pc = _rl_term_ip = (char *)NULL;
 464   _rl_term_ks = _rl_term_ke =_rl_term_vs = _rl_term_ve = (char *)NULL;
 465   _rl_term_kh = _rl_term_kH = _rl_term_at7 = _rl_term_kI = (char *)NULL;
 466 #if defined(HACK_TERMCAP_MOTION)
 467   _rl_term_forward_char = (char *)NULL;
 468 #endif
 469
 470   _rl_get_screen_size (tty, 0);
 471 #else  /* !__MSDOS__ */
 472   /* I've separated this out for later work on not calling tgetent at all
 473      if the calling application has supplied a custom redisplay function,
 474      (and possibly if the application has supplied a custom input function). */
 475   if (CUSTOM_REDISPLAY_FUNC())
 476     {
 477       tgetent_ret = -1;
 478     }
 479   else
 480     {
 481       if (term_string_buffer == 0)
 482         term_string_buffer = (char *)xmalloc(2032);
 483
 484       if (term_buffer == 0)
 485         term_buffer = (char *)xmalloc(4080);
 486
 487       buffer = term_string_buffer;
 488
 489       tgetent_ret = tgetent (term_buffer, term);
 490     }
 491
 492   if (tgetent_ret <= 0)
 493     {
 494       FREE (term_string_buffer);
 495       FREE (term_buffer);
 496       buffer = term_buffer = term_string_buffer = (char *)NULL;
 497
 498       _rl_term_autowrap = 0;    /* used by _rl_get_screen_size */
 499
 500       /* Allow calling application to set default height and width, using
 501          rl_set_screen_size */
 502       if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
 503         {
 504 #if defined (__EMX__)
 505           _emx_get_screensize (&_rl_screenwidth, &_rl_screenheight);
 506           _rl_screenwidth--;
 507 #else /* !__EMX__ */
 508           _rl_get_screen_size (tty, 0);
 509 #endif /* !__EMX__ */
 510         }
 511
 512       /* Defaults. */
 513       if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
 514         {
 515           _rl_screenwidth = 79;
 516           _rl_screenheight = 24;
 517         }
 518
 519       /* Everything below here is used by the redisplay code (tputs). */
 520       _rl_screenchars = _rl_screenwidth * _rl_screenheight;
 521       _rl_term_cr = "\r";
 522       _rl_term_im = _rl_term_ei = _rl_term_ic = _rl_term_IC = (char *)NULL;
 523       _rl_term_up = _rl_term_dc = _rl_term_DC = _rl_visible_bell = (char *)NULL;
 524       _rl_term_ku = _rl_term_kd = _rl_term_kl = _rl_term_kr = (char *)NULL;
 525       _rl_term_kh = _rl_term_kH = _rl_term_kI = _rl_term_kD = (char *)NULL;
 526       _rl_term_ks = _rl_term_ke = _rl_term_at7 = (char *)NULL;
 527       _rl_term_mm = _rl_term_mo = (char *)NULL;
 528       _rl_term_ve = _rl_term_vs = (char *)NULL;
 529       _rl_term_forward_char = (char *)NULL;
 530       _rl_terminal_can_insert = term_has_meta = 0;
 531
 532       /* Reasonable defaults for tgoto().  Readline currently only uses
 533          tgoto if _rl_term_IC or _rl_term_DC is defined, but just in case we
 534          change that later... */
 535       PC = '\0';
 536       BC = _rl_term_backspace = "\b";
 537       UP = _rl_term_up;
 538
 539       return 0;
 540     }
 541
 542   get_term_capabilities (&buffer);
 543
 544   /* Set up the variables that the termcap library expects the application
 545      to provide. */
 546   PC = _rl_term_pc ? *_rl_term_pc : 0;
 547   BC = _rl_term_backspace;
 548   UP = _rl_term_up;
 549
 550   if (!_rl_term_cr)
 551     _rl_term_cr = "\r";
 552
 553   _rl_term_autowrap = tgetflag ("am") && tgetflag ("xn");
 554
 555   /* Allow calling application to set default height and width, using
 556      rl_set_screen_size */
 557   if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
 558     _rl_get_screen_size (tty, 0);
 559
 560   /* "An application program can assume that the terminal can do
 561       character insertion if *any one of* the capabilities `IC',
 562       `im', `ic' or `ip' is provided."  But we can't do anything if
 563       only `ip' is provided, so... */
 564   _rl_terminal_can_insert = (_rl_term_IC || _rl_term_im || _rl_term_ic);
 565
 566   /* Check to see if this terminal has a meta key and clear the capability
 567      variables if there is none. */
 568   term_has_meta = tgetflag ("km") != 0;
 569   if (term_has_meta == 0)
 570     _rl_term_mm = _rl_term_mo = (char *)NULL;
 571 #endif /* !__MSDOS__ */
 572
 573   /* Attempt to find and bind the arrow keys.  Do not override already
 574      bound keys in an overzealous attempt, however. */
 575
 576   bind_termcap_arrow_keys (emacs_standard_keymap);
 577
 578 #if defined (VI_MODE)
 579   bind_termcap_arrow_keys (vi_movement_keymap);
 580   bind_termcap_arrow_keys (vi_insertion_keymap);
 581 #endif /* VI_MODE */
 582
 583   return 0;
 584 }
 585
 586 /* Bind the arrow key sequences from the termcap description in MAP. */
 587 static void
 588 bind_termcap_arrow_keys (map)
 589      Keymap map;
 590 {
 591   Keymap xkeymap;
 592
 593   xkeymap = _rl_keymap;
 594   _rl_keymap = map;
 595
 596   rl_bind_keyseq_if_unbound (_rl_term_ku, rl_get_previous_history);
 597   rl_bind_keyseq_if_unbound (_rl_term_kd, rl_get_next_history);
 598   rl_bind_keyseq_if_unbound (_rl_term_kr, rl_forward_char);
 599   rl_bind_keyseq_if_unbound (_rl_term_kl, rl_backward_char);
 600
 601   rl_bind_keyseq_if_unbound (_rl_term_kh, rl_beg_of_line);      /* Home */
 602   rl_bind_keyseq_if_unbound (_rl_term_at7, rl_end_of_line);     /* End */
 603
 604   rl_bind_keyseq_if_unbound (_rl_term_kD, rl_delete);
 605
 606   _rl_keymap = xkeymap;
 607 }
 608
 609 char *
 610 rl_get_termcap (cap)
 611      const char *cap;
 612 {
 613   register int i;
 614
 615   if (tcap_initialized == 0)
 616     return ((char *)NULL);
 617   for (i = 0; i < NUM_TC_STRINGS; i++)
 618     {
 619       if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0)
 620         return *(tc_strings[i].tc_value);
 621     }
 622   return ((char *)NULL);
 623 }
 624
 625 /* Re-initialize the terminal considering that the TERM/TERMCAP variable
 626    has changed. */
 627 int
 628 rl_reset_terminal (terminal_name)
 629      const char *terminal_name;
 630 {
 631   _rl_screenwidth = _rl_screenheight = 0;
 632   _rl_init_terminal_io (terminal_name);
 633   return 0;
 634 }
 635
 636 /* A function for the use of tputs () */
 637 #ifdef _MINIX
 638 void
 639 _rl_output_character_function (c)
 640      int c;
 641 {
 642   putc (c, _rl_out_stream);
 643 }
 644 #else /* !_MINIX */
 645 int
 646 _rl_output_character_function (c)
 647      int c;
 648 {
 649   return putc (c, _rl_out_stream);
 650 }
 651 #endif /* !_MINIX */
 652
 653 /* Write COUNT characters from STRING to the output stream. */
 654 void
 655 _rl_output_some_chars (string, count)
 656      const char *string;
 657      int count;
 658 {
 659   fwrite (string, 1, count, _rl_out_stream);
 660 }
 661
 662 /* Move the cursor back. */
 663 int
 664 _rl_backspace (count)
 665      int count;
 666 {
 667   register int i;
 668
 669 #ifndef __MSDOS__
 670   if (_rl_term_backspace)
 671     for (i = 0; i < count; i++)
 672       tputs (_rl_term_backspace, 1, _rl_output_character_function);
 673   else
 674 #endif
 675     for (i = 0; i < count; i++)
 676       putc ('\b', _rl_out_stream);
 677   return 0;
 678 }
 679
 680 /* Move to the start of the next line. */
 681 int
 682 rl_crlf ()
 683 {
 684 #if defined (NEW_TTY_DRIVER) || defined (__MINT__)
 685   if (_rl_term_cr)
 686     tputs (_rl_term_cr, 1, _rl_output_character_function);
 687 #endif /* NEW_TTY_DRIVER || __MINT__ */
 688   putc ('\n', _rl_out_stream);
 689   return 0;
 690 }
 691
 692 /* Ring the terminal bell. */
 693 int
 694 rl_ding ()
 695 {
 696   if (_rl_echoing_p)
 697     {
 698       switch (_rl_bell_preference)
 699         {
 700         case NO_BELL:
 701         default:
 702           break;
 703         case VISIBLE_BELL:
 704           if (_rl_visible_bell)
 705             {
 706 #ifdef __DJGPP__
 707               ScreenVisualBell ();
 708 #else
 709               tputs (_rl_visible_bell, 1, _rl_output_character_function);
 710 #endif
 711               break;
 712             }
 713           /* FALLTHROUGH */
 714         case AUDIBLE_BELL:
 715           fprintf (stderr, "\007");
 716           fflush (stderr);
 717           break;
 718         }
 719       return (0);
 720     }
 721   return (-1);
 722 }
 723
 724 /* **************************************************************** */
 725 /*                                                                  */
 726 /*              Controlling the Meta Key and Keypad                 */
 727 /*                                                                  */
 728 /* **************************************************************** */
 729
 730 static int enabled_meta = 0;    /* flag indicating we enabled meta mode */
 731
 732 void
 733 _rl_enable_meta_key ()
 734 {
 735 #if !defined (__DJGPP__)
 736   if (term_has_meta && _rl_term_mm)
 737     {
 738       tputs (_rl_term_mm, 1, _rl_output_character_function);
 739       enabled_meta = 1;
 740     }
 741 #endif
 742 }
 743
 744 void
 745 _rl_disable_meta_key ()
 746 {
 747 #if !defined (__DJGPP__)
 748   if (term_has_meta && _rl_term_mo && enabled_meta)
 749     {
 750       tputs (_rl_term_mo, 1, _rl_output_character_function);
 751       enabled_meta = 0;
 752     }
 753 #endif
 754 }
 755
 756 void
 757 _rl_control_keypad (on)
 758      int on;
 759 {
 760 #if !defined (__DJGPP__)
 761   if (on && _rl_term_ks)
 762     tputs (_rl_term_ks, 1, _rl_output_character_function);
 763   else if (!on && _rl_term_ke)
 764     tputs (_rl_term_ke, 1, _rl_output_character_function);
 765 #endif
 766 }
 767
 768 /* **************************************************************** */
 769 /*                                                                  */
 770 /*                      Controlling the Cursor                      */
 771 /*                                                                  */
 772 /* **************************************************************** */
 773
 774 /* Set the cursor appropriately depending on IM, which is one of the
 775    insert modes (insert or overwrite).  Insert mode gets the normal
 776    cursor.  Overwrite mode gets a very visible cursor.  Only does
 777    anything if we have both capabilities. */
 778 void
 779 _rl_set_cursor (im, force)
 780      int im, force;
 781 {
 782 #ifndef __MSDOS__
 783   if (_rl_term_ve && _rl_term_vs)
 784     {
 785       if (force || im != rl_insert_mode)
 786         {
 787           if (im == RL_IM_OVERWRITE)
 788             tputs (_rl_term_vs, 1, _rl_output_character_function);
 789           else
 790             tputs (_rl_term_ve, 1, _rl_output_character_function);
 791         }
 792     }
 793 #endif
 794 }