1 /* terminal.c -- controlling the terminal with termcap. */ 2 3 /* Copyright (C) 1996 Free Software Foundation, Inc. 4 5 This file is part of the GNU Readline Library, a library for 6 reading lines of text with interactive input and history editing. 7 8 The GNU Readline Library is free software; you can redistribute it 9 and/or modify it under the terms of the GNU General Public License 10 as published by the Free Software Foundation; either version 2, or 11 (at your option) any later version. 12 13 The GNU Readline Library is distributed in the hope that it will be 14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty 15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 The GNU General Public License is often shipped with GNU software, and 19 is generally kept in a file called COPYING or LICENSE. If you do not 20 have a copy of the license, write to the Free Software Foundation, 21 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ 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 #include "rltty.h" 59 #include "tcap.h" 60 61 /* Some standard library routines. */ 62 #include "readline.h" 63 #include "history.h" 64 65 #include "rlprivate.h" 66 #include "rlshell.h" 67 68 /* **************************************************************** */ 69 /* */ 70 /* Terminal and Termcap */ 71 /* */ 72 /* **************************************************************** */ 73 74 static char *term_buffer = (char *)NULL; 75 static char *term_string_buffer = (char *)NULL; 76 77 static int tcap_initialized; 78 79 /* Non-zero means this terminal can't really do anything. */ 80 static int dumb_term; 81 82 #if !defined (__linux__) 83 # if defined (__EMX__) || defined (NEED_EXTERN_PC) 84 extern 85 # endif /* __EMX__ || NEED_EXTERN_PC */ 86 char PC, *BC, *UP; 87 #endif /* __linux__ */ 88 89 /* Some strings to control terminal actions. These are output by tputs (). */ 90 char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace; 91 char *term_pc; 92 93 /* Non-zero if we determine that the terminal can do character insertion. */ 94 int terminal_can_insert = 0; 95 96 /* How to insert characters. */ 97 char *term_im, *term_ei, *term_ic, *term_ip, *term_IC; 98 99 /* How to delete characters. */ 100 char *term_dc, *term_DC; 101 102 #if defined (HACK_TERMCAP_MOTION) 103 char *term_forward_char; 104 #endif /* HACK_TERMCAP_MOTION */ 105 106 /* How to go up a line. */ 107 char *term_up; 108 109 /* A visible bell, if the terminal can be made to flash the screen. */ 110 static char *visible_bell; 111 112 /* Non-zero means the terminal can auto-wrap lines. */ 113 int _rl_term_autowrap; 114 115 /* Non-zero means that this terminal has a meta key. */ 116 static int term_has_meta; 117 118 /* The sequences to write to turn on and off the meta key, if this 119 terminal has one. */ 120 static char *term_mm, *term_mo; 121 122 /* The key sequences output by the arrow keys, if this terminal has any. */ 123 static char *term_ku, *term_kd, *term_kr, *term_kl; 124 125 /* How to initialize and reset the arrow keys, if this terminal has any. */ 126 static char *term_ks, *term_ke; 127 128 /* The key sequences sent by the Home and End keys, if any. */ 129 static char *term_kh, *term_kH; 130 131 /* Variables that hold the screen dimensions, used by the display code. */ 132 int screenwidth, screenheight, screenchars; 133 134 /* Non-zero means the user wants to enable the keypad. */ 135 int _rl_enable_keypad; 136 137 /* Non-zero means the user wants to enable a meta key. */ 138 int _rl_enable_meta = 1; 139 140 #if defined (__EMX__) 141 static void 142 _emx_get_screensize (swp, shp) 143 int *swp, *shp; 144 { 145 int sz[2]; 146 147 _scrsize (sz); 148 149 if (swp) 150 *swp = sz[0]; 151 if (shp) 152 *shp = sz[1]; 153 } 154 #endif 155 156 /* Get readline's idea of the screen size. TTY is a file descriptor open 157 to the terminal. If IGNORE_ENV is true, we do not pay attention to the 158 values of $LINES and $COLUMNS. The tests for TERM_STRING_BUFFER being 159 non-null serve to check whether or not we have initialized termcap. */ 160 void 161 _rl_get_screen_size (tty, ignore_env) 162 int tty, ignore_env; 163 { 164 char *ss; 165 #if defined (TIOCGWINSZ) 166 struct winsize window_size; 167 #endif /* TIOCGWINSZ */ 168 169 #if defined (TIOCGWINSZ) 170 if (ioctl (tty, TIOCGWINSZ, &window_size) == 0) 171 { 172 screenwidth = (int) window_size.ws_col; 173 screenheight = (int) window_size.ws_row; 174 } 175 #endif /* TIOCGWINSZ */ 176 177 #if defined (__EMX__) 178 _emx_get_screensize (&screenwidth, &screenheight); 179 #endif 180 181 /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV 182 is unset. */ 183 if (screenwidth <= 0) 184 { 185 if (ignore_env == 0 && (ss = get_env_value ("COLUMNS")) && *ss != '\0') 186 screenwidth = atoi (ss); 187 188 #if !defined (__DJGPP__) 189 if (screenwidth <= 0 && term_string_buffer) 190 screenwidth = tgetnum ("co"); 191 #endif 192 } 193 194 /* Environment variable LINES overrides setting of "li" if IGNORE_ENV 195 is unset. */ 196 if (screenheight <= 0) 197 { 198 if (ignore_env == 0 && (ss = get_env_value ("LINES")) && *ss != '\0') 199 screenheight = atoi (ss); 200 201 #if !defined (__DJGPP__) 202 if (screenheight <= 0 && term_string_buffer) 203 screenheight = tgetnum ("li"); 204 #endif 205 } 206 207 /* If all else fails, default to 80x24 terminal. */ 208 if (screenwidth <= 1) 209 screenwidth = 80; 210 211 if (screenheight <= 0) 212 screenheight = 24; 213 214 /* If we're being compiled as part of bash, set the environment 215 variables $LINES and $COLUMNS to new values. Otherwise, just 216 do a pair of putenv () or setenv () calls. */ 217 set_lines_and_columns (screenheight, screenwidth); 218 219 if (_rl_term_autowrap == 0) 220 screenwidth--; 221 222 screenchars = screenwidth * screenheight; 223 } 224 225 void 226 _rl_set_screen_size (rows, cols) 227 int rows, cols; 228 { 229 screenheight = rows; 230 screenwidth = cols; 231 232 if (_rl_term_autowrap == 0) 233 screenwidth--; 234 235 screenchars = screenwidth * screenheight; 236 } 237 238 void 239 rl_resize_terminal () 240 { 241 if (readline_echoing_p) 242 { 243 _rl_get_screen_size (fileno (rl_instream), 1); 244 _rl_redisplay_after_sigwinch (); 245 } 246 } 247 248 struct _tc_string { 249 char *tc_var; 250 char **tc_value; 251 }; 252 253 /* This should be kept sorted, just in case we decide to change the 254 search algorithm to something smarter. */ 255 static struct _tc_string tc_strings[] = 256 { 257 { "DC", &term_DC }, 258 { "IC", &term_IC }, 259 { "ce", &term_clreol }, 260 { "cl", &term_clrpag }, 261 { "cr", &term_cr }, 262 { "dc", &term_dc }, 263 { "ei", &term_ei }, 264 { "ic", &term_ic }, 265 { "im", &term_im }, 266 { "kd", &term_kd }, 267 { "kh", &term_kh }, /* home */ 268 { "kH", &term_kH }, /* end */ 269 { "kl", &term_kl }, 270 { "kr", &term_kr }, 271 { "ku", &term_ku }, 272 { "ks", &term_ks }, 273 { "ke", &term_ke }, 274 { "le", &term_backspace }, 275 { "mm", &term_mm }, 276 { "mo", &term_mo }, 277 #if defined (HACK_TERMCAP_MOTION) 278 { "nd", &term_forward_char }, 279 #endif 280 { "pc", &term_pc }, 281 { "up", &term_up }, 282 { "vb", &visible_bell }, 283 }; 284 285 #define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string)) 286 287 /* Read the desired terminal capability strings into BP. The capabilities 288 are described in the TC_STRINGS table. */ 289 static void 290 get_term_capabilities (bp) 291 char **bp; 292 { 293 #if !defined (__DJGPP__) /* XXX - doesn't DJGPP have a termcap library? */ 294 register int i; 295 296 for (i = 0; i < NUM_TC_STRINGS; i++) 297 *(tc_strings[i].tc_value) = tgetstr (tc_strings[i].tc_var, bp); 298 #endif 299 tcap_initialized = 1; 300 } 301 302 #define CUSTOM_REDISPLAY_FUNC() (rl_redisplay_function != rl_redisplay) 303 #define CUSTOM_INPUT_FUNC() (rl_getc_function != rl_getc) 304 305 int 306 _rl_init_terminal_io (terminal_name) 307 char *terminal_name; 308 { 309 char *term, *buffer; 310 int tty, tgetent_ret; 311 Keymap xkeymap; 312 313 term = terminal_name ? terminal_name : get_env_value ("TERM"); 314 term_clrpag = term_cr = term_clreol = (char *)NULL; 315 tty = rl_instream ? fileno (rl_instream) : 0; 316 screenwidth = screenheight = 0; 317 318 if (term == 0 || *term == '\0') 319 term = "dumb"; 320 321 /* I've separated this out for later work on not calling tgetent at all 322 if the calling application has supplied a custom redisplay function, 323 (and possibly if the application has supplied a custom input function). */ 324 if (CUSTOM_REDISPLAY_FUNC()) 325 { 326 tgetent_ret = -1; 327 } 328 else 329 { 330 if (term_string_buffer == 0) 331 term_string_buffer = xmalloc(2032); 332 333 if (term_buffer == 0) 334 term_buffer = xmalloc(4080); 335 336 buffer = term_string_buffer; 337 338 tgetent_ret = tgetent (term_buffer, term); 339 } 340 341 if (tgetent_ret <= 0) 342 { 343 FREE (term_string_buffer); 344 FREE (term_buffer); 345 buffer = term_buffer = term_string_buffer = (char *)NULL; 346 347 dumb_term = 1; 348 _rl_term_autowrap = 0; /* used by _rl_get_screen_size */ 349 350 #if defined (__EMX__) 351 _emx_get_screensize (&screenwidth, &screenheight); 352 screenwidth--; 353 #else /* !__EMX__ */ 354 _rl_get_screen_size (tty, 0); 355 #endif /* !__EMX__ */ 356 357 /* Defaults. */ 358 if (screenwidth <= 0 || screenheight <= 0) 359 { 360 screenwidth = 79; 361 screenheight = 24; 362 } 363 364 /* Everything below here is used by the redisplay code (tputs). */ 365 screenchars = screenwidth * screenheight; 366 term_cr = "\r"; 367 term_im = term_ei = term_ic = term_IC = (char *)NULL; 368 term_up = term_dc = term_DC = visible_bell = (char *)NULL; 369 term_ku = term_kd = term_kl = term_kr = (char *)NULL; 370 term_mm = term_mo = (char *)NULL; 371 #if defined (HACK_TERMCAP_MOTION) 372 term_forward_char = (char *)NULL; 373 #endif 374 terminal_can_insert = term_has_meta = 0; 375 376 /* Reasonable defaults for tgoto(). Readline currently only uses 377 tgoto if term_IC or term_DC is defined, but just in case we 378 change that later... */ 379 PC = '\0'; 380 BC = term_backspace = "\b"; 381 UP = term_up; 382 383 return 0; 384 } 385 386 get_term_capabilities (&buffer); 387 388 /* Set up the variables that the termcap library expects the application 389 to provide. */ 390 PC = term_pc ? *term_pc : 0; 391 BC = term_backspace; 392 UP = term_up; 393 394 if (!term_cr) 395 term_cr = "\r"; 396 397 _rl_term_autowrap = tgetflag ("am") && tgetflag ("xn"); 398 399 _rl_get_screen_size (tty, 0); 400 401 /* "An application program can assume that the terminal can do 402 character insertion if *any one of* the capabilities `IC', 403 `im', `ic' or `ip' is provided." But we can't do anything if 404 only `ip' is provided, so... */ 405 terminal_can_insert = (term_IC || term_im || term_ic); 406 407 /* Check to see if this terminal has a meta key and clear the capability 408 variables if there is none. */ 409 term_has_meta = (tgetflag ("km") || tgetflag ("MT")); 410 if (!term_has_meta) 411 term_mm = term_mo = (char *)NULL; 412 413 /* Attempt to find and bind the arrow keys. Do not override already 414 bound keys in an overzealous attempt, however. */ 415 xkeymap = _rl_keymap; 416 417 _rl_keymap = emacs_standard_keymap; 418 _rl_bind_if_unbound (term_ku, rl_get_previous_history); 419 _rl_bind_if_unbound (term_kd, rl_get_next_history); 420 _rl_bind_if_unbound (term_kr, rl_forward); 421 _rl_bind_if_unbound (term_kl, rl_backward); 422 423 _rl_bind_if_unbound (term_kh, rl_beg_of_line); /* Home */ 424 _rl_bind_if_unbound (term_kH, rl_end_of_line); /* End */ 425 426 #if defined (VI_MODE) 427 _rl_keymap = vi_movement_keymap; 428 _rl_bind_if_unbound (term_ku, rl_get_previous_history); 429 _rl_bind_if_unbound (term_kd, rl_get_next_history); 430 _rl_bind_if_unbound (term_kr, rl_forward); 431 _rl_bind_if_unbound (term_kl, rl_backward); 432 433 _rl_bind_if_unbound (term_kh, rl_beg_of_line); /* Home */ 434 _rl_bind_if_unbound (term_kH, rl_end_of_line); /* End */ 435 #endif /* VI_MODE */ 436 437 _rl_keymap = xkeymap; 438 439 return 0; 440 } 441 442 char * 443 rl_get_termcap (cap) 444 char *cap; 445 { 446 register int i; 447 448 if (tcap_initialized == 0) 449 return ((char *)NULL); 450 for (i = 0; i < NUM_TC_STRINGS; i++) 451 { 452 if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0) 453 return *(tc_strings[i].tc_value); 454 } 455 return ((char *)NULL); 456 } 457 458 /* Re-initialize the terminal considering that the TERM/TERMCAP variable 459 has changed. */ 460 int 461 rl_reset_terminal (terminal_name) 462 char *terminal_name; 463 { 464 _rl_init_terminal_io (terminal_name); 465 return 0; 466 } 467 468 /* A function for the use of tputs () */ 469 #ifdef _MINIX 470 void 471 _rl_output_character_function (c) 472 int c; 473 { 474 putc (c, _rl_out_stream); 475 } 476 #else /* !_MINIX */ 477 int 478 _rl_output_character_function (c) 479 int c; 480 { 481 return putc (c, _rl_out_stream); 482 } 483 #endif /* !_MINIX */ 484 485 /* Write COUNT characters from STRING to the output stream. */ 486 void 487 _rl_output_some_chars (string, count) 488 char *string; 489 int count; 490 { 491 fwrite (string, 1, count, _rl_out_stream); 492 } 493 494 /* Move the cursor back. */ 495 int 496 _rl_backspace (count) 497 int count; 498 { 499 register int i; 500 501 if (term_backspace) 502 for (i = 0; i < count; i++) 503 tputs (term_backspace, 1, _rl_output_character_function); 504 else 505 for (i = 0; i < count; i++) 506 putc ('\b', _rl_out_stream); 507 return 0; 508 } 509 510 /* Move to the start of the next line. */ 511 int 512 crlf () 513 { 514 #if defined (NEW_TTY_DRIVER) 515 if (term_cr) 516 tputs (term_cr, 1, _rl_output_character_function); 517 #endif /* NEW_TTY_DRIVER */ 518 putc ('\n', _rl_out_stream); 519 return 0; 520 } 521 522 /* Ring the terminal bell. */ 523 int 524 ding () 525 { 526 if (readline_echoing_p) 527 { 528 switch (_rl_bell_preference) 529 { 530 case NO_BELL: 531 default: 532 break; 533 case VISIBLE_BELL: 534 if (visible_bell) 535 { 536 tputs (visible_bell, 1, _rl_output_character_function); 537 break; 538 } 539 /* FALLTHROUGH */ 540 case AUDIBLE_BELL: 541 fprintf (stderr, "\007"); 542 fflush (stderr); 543 break; 544 } 545 return (0); 546 } 547 return (-1); 548 } 549 550 /* **************************************************************** */ 551 /* */ 552 /* Controlling the Meta Key and Keypad */ 553 /* */ 554 /* **************************************************************** */ 555 556 void 557 _rl_enable_meta_key () 558 { 559 #if !defined (__DJGPP__) 560 if (term_has_meta && term_mm) 561 tputs (term_mm, 1, _rl_output_character_function); 562 #endif 563 } 564 565 void 566 _rl_control_keypad (on) 567 int on; 568 { 569 #if !defined (__DJGPP__) 570 if (on && term_ks) 571 tputs (term_ks, 1, _rl_output_character_function); 572 else if (!on && term_ke) 573 tputs (term_ke, 1, _rl_output_character_function); 574 #endif 575 } 576