1 /* 2 * Copyright (C) 1984-2012 Mark Nudelman 3 * Modified for use with illumos by Garrett D'Amore. 4 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Less License, as specified in the README file. 8 * 9 * For more information, see the README file. 10 */ 11 12 /* 13 * Routines which deal with the characteristics of the terminal. 14 * Uses termcap to be as terminal-independent as possible. 15 */ 16 17 #include <sys/ioctl.h> 18 19 #include <err.h> 20 #include <term.h> 21 #include <termios.h> 22 23 #include "cmd.h" 24 #include "less.h" 25 26 #define DEFAULT_TERM "unknown" 27 28 /* 29 * Strings passed to tputs() to do various terminal functions. 30 */ 31 static char 32 *sc_home, /* Cursor home */ 33 *sc_addline, /* Add line, scroll down following lines */ 34 *sc_lower_left, /* Cursor to last line, first column */ 35 *sc_return, /* Cursor to beginning of current line */ 36 *sc_move, /* General cursor positioning */ 37 *sc_clear, /* Clear screen */ 38 *sc_eol_clear, /* Clear to end of line */ 39 *sc_eos_clear, /* Clear to end of screen */ 40 *sc_s_in, /* Enter standout (highlighted) mode */ 41 *sc_s_out, /* Exit standout mode */ 42 *sc_u_in, /* Enter underline mode */ 43 *sc_u_out, /* Exit underline mode */ 44 *sc_b_in, /* Enter bold mode */ 45 *sc_b_out, /* Exit bold mode */ 46 *sc_bl_in, /* Enter blink mode */ 47 *sc_bl_out, /* Exit blink mode */ 48 *sc_visual_bell, /* Visual bell (flash screen) sequence */ 49 *sc_backspace, /* Backspace cursor */ 50 *sc_s_keypad, /* Start keypad mode */ 51 *sc_e_keypad, /* End keypad mode */ 52 *sc_init, /* Startup terminal initialization */ 53 *sc_deinit; /* Exit terminal de-initialization */ 54 55 static int init_done = 0; 56 57 int auto_wrap; /* Terminal does \r\n when write past margin */ 58 int ignaw; /* Terminal ignores \n immediately after wrap */ 59 int erase_char; /* The user's erase char */ 60 int erase2_char; /* The user's other erase char */ 61 int kill_char; /* The user's line-kill char */ 62 int werase_char; /* The user's word-erase char */ 63 int sc_width, sc_height; /* Height & width of screen */ 64 int bo_s_width, bo_e_width; /* Printing width of boldface seq */ 65 int ul_s_width, ul_e_width; /* Printing width of underline seq */ 66 int so_s_width, so_e_width; /* Printing width of standout seq */ 67 int bl_s_width, bl_e_width; /* Printing width of blink seq */ 68 int can_goto_line; /* Can move cursor to any line */ 69 int missing_cap = 0; /* Some capability is missing */ 70 static int above_mem; /* Memory retained above screen */ 71 static int below_mem; /* Memory retained below screen */ 72 73 static int attrmode = AT_NORMAL; 74 extern int binattr; 75 76 static char *cheaper(char *, char *, char *); 77 static void tmodes(char *, char *, char **, char **, char *, char *); 78 79 extern int quiet; /* If VERY_QUIET, use visual bell for bell */ 80 extern int no_back_scroll; 81 extern int swindow; 82 extern int no_init; 83 extern int no_keypad; 84 extern int wscroll; 85 extern int screen_trashed; 86 extern int tty; 87 extern int top_scroll; 88 extern int oldbot; 89 extern int hilite_search; 90 91 /* 92 * Change terminal to "raw mode", or restore to "normal" mode. 93 * "Raw mode" means 94 * 1. An outstanding read will complete on receipt of a single keystroke. 95 * 2. Input is not echoed. 96 * 3. On output, \n is mapped to \r\n. 97 * 4. \t is NOT expanded into spaces. 98 * 5. Signal-causing characters such as ctrl-C (interrupt), 99 * etc. are NOT disabled. 100 * It doesn't matter whether an input \n is mapped to \r, or vice versa. 101 */ 102 void 103 raw_mode(int on) 104 { 105 static int curr_on = 0; 106 struct termios s; 107 static struct termios save_term; 108 static int saved_term = 0; 109 110 if (on == curr_on) 111 return; 112 erase2_char = '\b'; /* in case OS doesn't know about erase2 */ 113 114 if (on) { 115 /* 116 * Get terminal modes. 117 */ 118 (void) tcgetattr(tty, &s); 119 120 /* 121 * Save modes and set certain variables dependent on modes. 122 */ 123 if (!saved_term) { 124 save_term = s; 125 saved_term = 1; 126 } 127 128 erase_char = s.c_cc[VERASE]; 129 #ifdef VERASE2 130 erase2_char = s.c_cc[VERASE2]; 131 #endif 132 kill_char = s.c_cc[VKILL]; 133 #ifdef VWERASE 134 werase_char = s.c_cc[VWERASE]; 135 #endif 136 137 /* 138 * Set the modes to the way we want them. 139 */ 140 s.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL); 141 142 #ifndef TAB3 143 #define TAB3 0 /* Its a lie, but TAB3 isn't defined by POSIX. */ 144 #endif 145 s.c_oflag |= (TAB3 | OPOST | ONLCR); 146 s.c_oflag &= ~(OCRNL | ONOCR | ONLRET); 147 s.c_cc[VMIN] = 1; 148 s.c_cc[VTIME] = 0; 149 #ifdef VLNEXT 150 s.c_cc[VLNEXT] = 0; 151 #endif 152 #ifdef VDSUSP 153 s.c_cc[VDSUSP] = 0; 154 #endif 155 } else { 156 /* 157 * Restore saved modes. 158 */ 159 s = save_term; 160 } 161 (void) tcsetattr(tty, TCSASOFT | TCSADRAIN, &s); 162 curr_on = on; 163 } 164 165 /* 166 * Some glue to prevent calling termcap functions if tgetent() failed. 167 */ 168 static int hardcopy; 169 170 /* 171 * Get size of the output screen. 172 */ 173 static void 174 scrsize(void) 175 { 176 int sys_height = 0, sys_width = 0, n; 177 struct winsize w; 178 char *s; 179 180 #define DEF_SC_WIDTH 80 181 #define DEF_SC_HEIGHT 24 182 183 if (ioctl(2, TIOCGWINSZ, &w) == 0) { 184 if (w.ws_row > 0) 185 sys_height = w.ws_row; 186 if (w.ws_col > 0) 187 sys_width = w.ws_col; 188 } 189 190 if (sys_height > 0) 191 sc_height = sys_height; 192 else if ((s = lgetenv("LINES")) != NULL) 193 sc_height = atoi(s); 194 else if (!hardcopy && (n = lines) > 0) 195 sc_height = n; 196 if (sc_height <= 0) 197 sc_height = DEF_SC_HEIGHT; 198 199 if (sys_width > 0) 200 sc_width = sys_width; 201 else if ((s = lgetenv("COLUMNS")) != NULL) 202 sc_width = atoi(s); 203 else if (!hardcopy && (n = columns) > 0) 204 sc_width = n; 205 if (sc_width <= 0) 206 sc_width = DEF_SC_WIDTH; 207 } 208 209 /* 210 * Return the characters actually input by a "special" key. 211 */ 212 char * 213 special_key_str(int key) 214 { 215 char *s; 216 static char ctrlk[] = { CONTROL('K'), 0 }; 217 218 if (hardcopy) 219 return (NULL); 220 221 switch (key) { 222 case SK_RIGHT_ARROW: 223 s = key_right; 224 break; 225 case SK_LEFT_ARROW: 226 s = key_left; 227 break; 228 case SK_UP_ARROW: 229 s = key_up; 230 break; 231 case SK_DOWN_ARROW: 232 s = key_down; 233 break; 234 case SK_PAGE_UP: 235 s = key_ppage; 236 break; 237 case SK_PAGE_DOWN: 238 s = key_npage; 239 break; 240 case SK_HOME: 241 s = key_home; 242 break; 243 case SK_END: 244 s = key_end; 245 break; 246 case SK_DELETE: 247 s = key_dc; 248 if (s == NULL) { 249 s = "\177\0"; 250 } 251 break; 252 case SK_CONTROL_K: 253 s = ctrlk; 254 break; 255 default: 256 return (NULL); 257 } 258 return (s); 259 } 260 261 /* 262 * Get terminal capabilities via termcap. 263 */ 264 void 265 get_term(void) 266 { 267 char *t1, *t2; 268 char *term; 269 int err; 270 271 /* 272 * Find out what kind of terminal this is. 273 */ 274 if ((term = lgetenv("TERM")) == NULL) 275 term = DEFAULT_TERM; 276 hardcopy = 0; 277 278 if (setupterm(term, 1, &err) < 0) { 279 if (err == 1) 280 hardcopy = 1; 281 else 282 errx(1, "%s: unknown terminal type", term); 283 } 284 if (hard_copy == 1) 285 hardcopy = 1; 286 287 /* 288 * Get size of the screen. 289 */ 290 scrsize(); 291 pos_init(); 292 293 auto_wrap = hardcopy ? 0 : auto_right_margin; 294 ignaw = hardcopy ? 0 : eat_newline_glitch; 295 above_mem = hardcopy ? 0 : memory_above; 296 below_mem = hardcopy ? 0 : memory_below; 297 298 /* 299 * Assumes termcap variable "sg" is the printing width of: 300 * the standout sequence, the end standout sequence, 301 * the underline sequence, the end underline sequence, 302 * the boldface sequence, and the end boldface sequence. 303 */ 304 if (hardcopy || (so_s_width = magic_cookie_glitch) < 0) 305 so_s_width = 0; 306 so_e_width = so_s_width; 307 308 bo_s_width = bo_e_width = so_s_width; 309 ul_s_width = ul_e_width = so_s_width; 310 bl_s_width = bl_e_width = so_s_width; 311 312 if (so_s_width > 0 || so_e_width > 0) 313 /* 314 * Disable highlighting by default on magic cookie terminals. 315 * Turning on highlighting might change the displayed width 316 * of a line, causing the display to get messed up. 317 * The user can turn it back on with -g, 318 * but she won't like the results. 319 */ 320 hilite_search = 0; 321 322 /* 323 * Get various string-valued capabilities. 324 */ 325 326 sc_s_keypad = keypad_xmit; 327 if (hardcopy || sc_s_keypad == NULL) 328 sc_s_keypad = ""; 329 sc_e_keypad = keypad_local; 330 if (hardcopy || sc_e_keypad == NULL) 331 sc_e_keypad = ""; 332 333 sc_init = enter_ca_mode; 334 if (hardcopy || sc_init == NULL) 335 sc_init = ""; 336 337 sc_deinit = exit_ca_mode; 338 if (hardcopy || sc_deinit == NULL) 339 sc_deinit = ""; 340 341 sc_eol_clear = clr_eol; 342 if (hardcopy || sc_eol_clear == NULL || *sc_eol_clear == '\0') { 343 missing_cap = 1; 344 sc_eol_clear = ""; 345 } 346 347 sc_eos_clear = clr_eos; 348 if (below_mem && 349 (hardcopy || sc_eos_clear == NULL || *sc_eos_clear == '\0')) { 350 missing_cap = 1; 351 sc_eos_clear = ""; 352 } 353 354 sc_clear = clear_screen; 355 if (hardcopy || sc_clear == NULL || *sc_clear == '\0') { 356 missing_cap = 1; 357 sc_clear = "\n\n"; 358 } 359 360 sc_move = cursor_address; 361 if (hardcopy || sc_move == NULL || *sc_move == '\0') { 362 /* 363 * This is not an error here, because we don't 364 * always need sc_move. 365 * We need it only if we don't have home or lower-left. 366 */ 367 sc_move = ""; 368 can_goto_line = 0; 369 } else { 370 can_goto_line = 1; 371 } 372 373 tmodes(enter_standout_mode, exit_standout_mode, &sc_s_in, &sc_s_out, 374 "", ""); 375 tmodes(enter_underline_mode, exit_underline_mode, &sc_u_in, &sc_u_out, 376 sc_s_in, sc_s_out); 377 tmodes(enter_bold_mode, exit_attribute_mode, &sc_b_in, &sc_b_out, 378 sc_s_in, sc_s_out); 379 tmodes(enter_blink_mode, exit_attribute_mode, &sc_bl_in, &sc_bl_out, 380 sc_s_in, sc_s_out); 381 382 sc_visual_bell = flash_screen; 383 if (hardcopy || sc_visual_bell == NULL) 384 sc_visual_bell = ""; 385 386 sc_backspace = "\b"; 387 388 /* 389 * Choose between using "ho" and "cm" ("home" and "cursor move") 390 * to move the cursor to the upper left corner of the screen. 391 */ 392 t1 = cursor_home; 393 if (hardcopy || t1 == NULL) 394 t1 = ""; 395 if (*sc_move == '\0') { 396 t2 = ""; 397 } else { 398 t2 = estrdup(tparm(sc_move, 0, 0, 0, 0, 0, 0, 0, 0, 0)); 399 } 400 sc_home = cheaper(t1, t2, "|\b^"); 401 402 /* 403 * Choose between using "ll" and "cm" ("lower left" and "cursor move") 404 * to move the cursor to the lower left corner of the screen. 405 */ 406 t1 = cursor_to_ll; 407 if (hardcopy || t1 == NULL) 408 t1 = ""; 409 if (*sc_move == '\0') { 410 t2 = ""; 411 } else { 412 t2 = estrdup(tparm(sc_move, sc_height-1, 413 0, 0, 0, 0, 0, 0, 0, 0)); 414 } 415 sc_lower_left = cheaper(t1, t2, "\r"); 416 417 /* 418 * Get carriage return string. 419 */ 420 sc_return = carriage_return; 421 if (hardcopy || sc_return == NULL) 422 sc_return = "\r"; 423 424 /* 425 * Choose between using insert_line or scroll_reverse 426 * to add a line at the top of the screen. 427 */ 428 t1 = insert_line; 429 if (hardcopy || t1 == NULL) 430 t1 = ""; 431 t2 = scroll_reverse; 432 if (hardcopy || t2 == NULL) 433 t2 = ""; 434 if (above_mem) 435 sc_addline = t1; 436 else 437 sc_addline = cheaper(t1, t2, ""); 438 if (*sc_addline == '\0') { 439 /* 440 * Force repaint on any backward movement. 441 */ 442 no_back_scroll = 1; 443 } 444 } 445 446 /* 447 * Return the cost of displaying a termcap string. 448 * We use the trick of calling tputs, but as a char printing function 449 * we give it inc_costcount, which just increments "costcount". 450 * This tells us how many chars would be printed by using this string. 451 * {{ Couldn't we just use strlen? }} 452 */ 453 static int costcount; 454 455 static int 456 inc_costcount(int c) 457 { 458 costcount++; 459 return (c); 460 } 461 462 static int 463 cost(char *t) 464 { 465 costcount = 0; 466 (void) tputs(t, sc_height, inc_costcount); 467 return (costcount); 468 } 469 470 /* 471 * Return the "best" of the two given termcap strings. 472 * The best, if both exist, is the one with the lower 473 * cost (see cost() function). 474 */ 475 static char * 476 cheaper(char *t1, char *t2, char *def) 477 { 478 if (*t1 == '\0' && *t2 == '\0') { 479 missing_cap = 1; 480 return (def); 481 } 482 if (*t1 == '\0') 483 return (t2); 484 if (*t2 == '\0') 485 return (t1); 486 if (cost(t1) < cost(t2)) 487 return (t1); 488 return (t2); 489 } 490 491 static void 492 tmodes(char *incap, char *outcap, char **instr, char **outstr, 493 char *def_instr, char *def_outstr) 494 { 495 if (hardcopy) { 496 *instr = ""; 497 *outstr = ""; 498 return; 499 } 500 501 *instr = incap; 502 *outstr = outcap; 503 504 if (*instr == NULL) { 505 /* Use defaults. */ 506 *instr = def_instr; 507 *outstr = def_outstr; 508 return; 509 } 510 511 if (*outstr == NULL) 512 /* No specific out capability; use exit_attribute_mode. */ 513 *outstr = exit_attribute_mode; 514 if (*outstr == NULL) 515 /* Don't even have that, use an empty string */ 516 *outstr = ""; 517 } 518 519 /* 520 * Below are the functions which perform all the 521 * terminal-specific screen manipulation. 522 */ 523 524 /* 525 * Initialize terminal 526 */ 527 void 528 init(void) 529 { 530 if (!no_init) 531 (void) tputs(sc_init, sc_height, putchr); 532 if (!no_keypad) 533 (void) tputs(sc_s_keypad, sc_height, putchr); 534 if (top_scroll) { 535 int i; 536 537 /* 538 * This is nice to terminals with no alternate screen, 539 * but with saved scrolled-off-the-top lines. This way, 540 * no previous line is lost, but we start with a whole 541 * screen to ourself. 542 */ 543 for (i = 1; i < sc_height; i++) 544 (void) putchr('\n'); 545 } else 546 line_left(); 547 init_done = 1; 548 } 549 550 /* 551 * Deinitialize terminal 552 */ 553 void 554 deinit(void) 555 { 556 if (!init_done) 557 return; 558 if (!no_keypad) 559 (void) tputs(sc_e_keypad, sc_height, putchr); 560 if (!no_init) 561 (void) tputs(sc_deinit, sc_height, putchr); 562 init_done = 0; 563 } 564 565 /* 566 * Home cursor (move to upper left corner of screen). 567 */ 568 void 569 home(void) 570 { 571 (void) tputs(sc_home, 1, putchr); 572 } 573 574 /* 575 * Add a blank line (called with cursor at home). 576 * Should scroll the display down. 577 */ 578 void 579 add_line(void) 580 { 581 (void) tputs(sc_addline, sc_height, putchr); 582 } 583 584 /* 585 * Move cursor to lower left corner of screen. 586 */ 587 void 588 lower_left(void) 589 { 590 (void) tputs(sc_lower_left, 1, putchr); 591 } 592 593 /* 594 * Move cursor to left position of current line. 595 */ 596 void 597 line_left(void) 598 { 599 (void) tputs(sc_return, 1, putchr); 600 } 601 602 /* 603 * Goto a specific line on the screen. 604 */ 605 void 606 goto_line(int slinenum) 607 { 608 (void) tputs(tparm(sc_move, slinenum, 0, 0, 0, 0, 0, 0, 0, 0), 1, 609 putchr); 610 } 611 612 /* 613 * Output the "visual bell", if there is one. 614 */ 615 void 616 vbell(void) 617 { 618 if (*sc_visual_bell == '\0') 619 return; 620 (void) tputs(sc_visual_bell, sc_height, putchr); 621 } 622 623 /* 624 * Make a noise. 625 */ 626 static void 627 beep(void) 628 { 629 (void) putchr(CONTROL('G')); 630 } 631 632 /* 633 * Ring the terminal bell. 634 */ 635 void 636 ring_bell(void) 637 { 638 if (quiet == VERY_QUIET) 639 vbell(); 640 else 641 beep(); 642 } 643 644 /* 645 * Clear the screen. 646 */ 647 void 648 do_clear(void) 649 { 650 (void) tputs(sc_clear, sc_height, putchr); 651 } 652 653 /* 654 * Clear from the cursor to the end of the cursor's line. 655 * {{ This must not move the cursor. }} 656 */ 657 void 658 clear_eol(void) 659 { 660 (void) tputs(sc_eol_clear, 1, putchr); 661 } 662 663 /* 664 * Clear the current line. 665 * Clear the screen if there's off-screen memory below the display. 666 */ 667 static void 668 clear_eol_bot(void) 669 { 670 if (below_mem) 671 (void) tputs(sc_eos_clear, 1, putchr); 672 else 673 (void) tputs(sc_eol_clear, 1, putchr); 674 } 675 676 /* 677 * Clear the bottom line of the display. 678 * Leave the cursor at the beginning of the bottom line. 679 */ 680 void 681 clear_bot(void) 682 { 683 /* 684 * If we're in a non-normal attribute mode, temporarily exit 685 * the mode while we do the clear. Some terminals fill the 686 * cleared area with the current attribute. 687 */ 688 if (oldbot) 689 lower_left(); 690 else 691 line_left(); 692 693 if (attrmode == AT_NORMAL) 694 clear_eol_bot(); 695 else 696 { 697 int saved_attrmode = attrmode; 698 699 at_exit(); 700 clear_eol_bot(); 701 at_enter(saved_attrmode); 702 } 703 } 704 705 void 706 at_enter(int attr) 707 { 708 attr = apply_at_specials(attr); 709 710 /* The one with the most priority is last. */ 711 if (attr & AT_UNDERLINE) 712 (void) tputs(sc_u_in, 1, putchr); 713 if (attr & AT_BOLD) 714 (void) tputs(sc_b_in, 1, putchr); 715 if (attr & AT_BLINK) 716 (void) tputs(sc_bl_in, 1, putchr); 717 if (attr & AT_STANDOUT) 718 (void) tputs(sc_s_in, 1, putchr); 719 720 attrmode = attr; 721 } 722 723 void 724 at_exit(void) 725 { 726 /* Undo things in the reverse order we did them. */ 727 if (attrmode & AT_STANDOUT) 728 (void) tputs(sc_s_out, 1, putchr); 729 if (attrmode & AT_BLINK) 730 (void) tputs(sc_bl_out, 1, putchr); 731 if (attrmode & AT_BOLD) 732 (void) tputs(sc_b_out, 1, putchr); 733 if (attrmode & AT_UNDERLINE) 734 (void) tputs(sc_u_out, 1, putchr); 735 736 attrmode = AT_NORMAL; 737 } 738 739 void 740 at_switch(int attr) 741 { 742 int new_attrmode = apply_at_specials(attr); 743 int ignore_modes = AT_ANSI; 744 745 if ((new_attrmode & ~ignore_modes) != (attrmode & ~ignore_modes)) { 746 at_exit(); 747 at_enter(attr); 748 } 749 } 750 751 int 752 is_at_equiv(int attr1, int attr2) 753 { 754 attr1 = apply_at_specials(attr1); 755 attr2 = apply_at_specials(attr2); 756 757 return (attr1 == attr2); 758 } 759 760 int 761 apply_at_specials(int attr) 762 { 763 if (attr & AT_BINARY) 764 attr |= binattr; 765 if (attr & AT_HILITE) 766 attr |= AT_STANDOUT; 767 attr &= ~(AT_BINARY|AT_HILITE); 768 769 return (attr); 770 } 771 772 /* 773 * Output a plain backspace, without erasing the previous char. 774 */ 775 void 776 putbs(void) 777 { 778 (void) tputs(sc_backspace, 1, putchr); 779 } 780