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