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