1 /*- 2 * Copyright (c) 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * Copyright (c) 1993, 1994, 1995, 1996 5 * Keith Bostic. All rights reserved. 6 * 7 * See the LICENSE file for redistribution information. 8 */ 9 10 #include "config.h" 11 12 #ifndef lint 13 static const char sccsid[] = "$Id: cl_screen.c,v 10.58 2015/04/08 02:12:11 zy Exp $"; 14 #endif /* not lint */ 15 16 #include <sys/types.h> 17 #include <sys/queue.h> 18 #include <sys/time.h> 19 20 #include <bitstring.h> 21 #include <errno.h> 22 #include <signal.h> 23 #include <stdio.h> 24 #include <stdlib.h> 25 #include <string.h> 26 #ifdef HAVE_TERM_H 27 #include <term.h> 28 #endif 29 #include <termios.h> 30 #include <unistd.h> 31 32 #include "../common/common.h" 33 #include "cl.h" 34 35 static int cl_ex_end(GS *); 36 static int cl_ex_init(SCR *); 37 static void cl_freecap(CL_PRIVATE *); 38 static int cl_vi_end(GS *); 39 static int cl_vi_init(SCR *); 40 static int cl_putenv(char *, char *, u_long); 41 42 /* 43 * cl_screen -- 44 * Switch screen types. 45 * 46 * PUBLIC: int cl_screen(SCR *, u_int32_t); 47 */ 48 int 49 cl_screen(SCR *sp, u_int32_t flags) 50 { 51 CL_PRIVATE *clp; 52 WINDOW *win; 53 GS *gp; 54 55 gp = sp->gp; 56 clp = CLP(sp); 57 win = CLSP(sp) ? CLSP(sp) : stdscr; 58 59 /* See if the current information is incorrect. */ 60 if (F_ISSET(gp, G_SRESTART)) { 61 if ((!F_ISSET(sp, SC_SCR_EX | SC_SCR_VI) || 62 resizeterm(O_VAL(sp, O_LINES), O_VAL(sp, O_COLUMNS))) && 63 cl_quit(gp)) 64 return (1); 65 F_CLR(gp, G_SRESTART); 66 } 67 68 /* See if we're already in the right mode. */ 69 if ((LF_ISSET(SC_EX) && F_ISSET(sp, SC_SCR_EX)) || 70 (LF_ISSET(SC_VI) && F_ISSET(sp, SC_SCR_VI))) 71 return (0); 72 73 /* 74 * Fake leaving ex mode. 75 * 76 * We don't actually exit ex or vi mode unless forced (e.g. by a window 77 * size change). This is because many curses implementations can't be 78 * called twice in a single program. Plus, it's faster. If the editor 79 * "leaves" vi to enter ex, when it exits ex we'll just fall back into 80 * vi. 81 */ 82 if (F_ISSET(sp, SC_SCR_EX)) 83 F_CLR(sp, SC_SCR_EX); 84 85 /* 86 * Fake leaving vi mode. 87 * 88 * Clear out the rest of the screen if we're in the middle of a split 89 * screen. Move to the last line in the current screen -- this makes 90 * terminal scrolling happen naturally. Note: *don't* move past the 91 * end of the screen, as there are ex commands (e.g., :read ! cat file) 92 * that don't want to. Don't clear the info line, its contents may be 93 * valid, e.g. :file|append. 94 */ 95 if (F_ISSET(sp, SC_SCR_VI)) { 96 F_CLR(sp, SC_SCR_VI); 97 98 if (TAILQ_NEXT(sp, q) != NULL) { 99 (void)wmove(win, RLNO(sp, sp->rows), 0); 100 wclrtobot(win); 101 } 102 (void)wmove(win, RLNO(sp, sp->rows) - 1, 0); 103 wrefresh(win); 104 } 105 106 /* Enter the requested mode. */ 107 if (LF_ISSET(SC_EX)) { 108 if (cl_ex_init(sp)) 109 return (1); 110 F_SET(clp, CL_IN_EX | CL_SCR_EX_INIT); 111 112 /* 113 * If doing an ex screen for ex mode, move to the last line 114 * on the screen. 115 */ 116 if (F_ISSET(sp, SC_EX) && clp->cup != NULL) 117 tputs(tgoto(clp->cup, 118 0, O_VAL(sp, O_LINES) - 1), 1, cl_putchar); 119 } else { 120 if (cl_vi_init(sp)) 121 return (1); 122 F_CLR(clp, CL_IN_EX); 123 F_SET(clp, CL_SCR_VI_INIT); 124 } 125 return (0); 126 } 127 128 /* 129 * cl_quit -- 130 * Shutdown the screens. 131 * 132 * PUBLIC: int cl_quit(GS *); 133 */ 134 int 135 cl_quit(GS *gp) 136 { 137 CL_PRIVATE *clp; 138 int rval; 139 140 rval = 0; 141 clp = GCLP(gp); 142 143 /* 144 * If we weren't really running, ignore it. This happens if the 145 * screen changes size before we've called curses. 146 */ 147 if (!F_ISSET(clp, CL_SCR_EX_INIT | CL_SCR_VI_INIT)) 148 return (0); 149 150 /* Clean up the terminal mappings. */ 151 if (cl_term_end(gp)) 152 rval = 1; 153 154 /* Really leave vi mode. */ 155 if (F_ISSET(clp, CL_STDIN_TTY) && 156 F_ISSET(clp, CL_SCR_VI_INIT) && cl_vi_end(gp)) 157 rval = 1; 158 159 /* Really leave ex mode. */ 160 if (F_ISSET(clp, CL_STDIN_TTY) && 161 F_ISSET(clp, CL_SCR_EX_INIT) && cl_ex_end(gp)) 162 rval = 1; 163 164 /* 165 * If we were running ex when we quit, or we're using an implementation 166 * of curses where endwin() doesn't get this right, restore the original 167 * terminal modes. 168 * 169 * XXX 170 * We always do this because it's too hard to figure out what curses 171 * implementations get it wrong. It may discard type-ahead characters 172 * from the tty queue. 173 */ 174 (void)tcsetattr(STDIN_FILENO, TCSADRAIN | TCSASOFT, &clp->orig); 175 176 F_CLR(clp, CL_SCR_EX_INIT | CL_SCR_VI_INIT); 177 return (rval); 178 } 179 180 /* 181 * cl_vi_init -- 182 * Initialize the curses vi screen. 183 */ 184 static int 185 cl_vi_init(SCR *sp) 186 { 187 CL_PRIVATE *clp; 188 GS *gp; 189 char *o_cols, *o_lines, *o_term, *ttype; 190 191 gp = sp->gp; 192 clp = CLP(sp); 193 194 /* If already initialized, just set the terminal modes. */ 195 if (F_ISSET(clp, CL_SCR_VI_INIT)) 196 goto fast; 197 198 /* Curses vi always reads from (and writes to) a terminal. */ 199 if (!F_ISSET(clp, CL_STDIN_TTY) || !isatty(STDOUT_FILENO)) { 200 msgq(sp, M_ERR, 201 "016|Vi's standard input and output must be a terminal"); 202 return (1); 203 } 204 205 /* We'll need a terminal type. */ 206 if (opts_empty(sp, O_TERM, 0)) 207 return (1); 208 ttype = O_STR(sp, O_TERM); 209 210 /* 211 * XXX 212 * Changing the row/column and terminal values is done by putting them 213 * into the environment, which is then read by curses. What this loses 214 * in ugliness, it makes up for in stupidity. We can't simply put the 215 * values into the environment ourselves, because in the presence of a 216 * kernel mechanism for returning the window size, entering values into 217 * the environment will screw up future screen resizing events, e.g. if 218 * the user enters a :shell command and then resizes their window. So, 219 * if they weren't already in the environment, we make sure to delete 220 * them immediately after setting them. 221 * 222 * XXX 223 * Putting the TERM variable into the environment is necessary, even 224 * though we're using newterm() here. We may be using initscr() as 225 * the underlying function. 226 */ 227 o_term = getenv("TERM"); 228 cl_putenv("TERM", ttype, 0); 229 o_lines = getenv("LINES"); 230 cl_putenv("LINES", NULL, (u_long)O_VAL(sp, O_LINES)); 231 o_cols = getenv("COLUMNS"); 232 cl_putenv("COLUMNS", NULL, (u_long)O_VAL(sp, O_COLUMNS)); 233 234 /* 235 * The terminal is aways initialized, either in `main`, or by a 236 * previous call to newterm(3X). 237 */ 238 (void)del_curterm(cur_term); 239 240 /* 241 * We never have more than one SCREEN at a time, so set_term(NULL) will 242 * give us the last SCREEN. 243 */ 244 errno = 0; 245 if (newterm(ttype, stdout, stdin) == NULL) { 246 if (errno) 247 msgq(sp, M_SYSERR, "%s", ttype); 248 else 249 msgq(sp, M_ERR, "%s: unknown terminal type", ttype); 250 return (1); 251 } 252 253 if (o_term == NULL) 254 unsetenv("TERM"); 255 if (o_lines == NULL) 256 unsetenv("LINES"); 257 if (o_cols == NULL) 258 unsetenv("COLUMNS"); 259 260 /* 261 * XXX 262 * Someone got let out alone without adult supervision -- the SunOS 263 * newterm resets the signal handlers. There's a race, but it's not 264 * worth closing. 265 */ 266 (void)sig_init(sp->gp, sp); 267 268 /* 269 * We use raw mode. What we want is 8-bit clean, however, signals 270 * and flow control should continue to work. Admittedly, it sounds 271 * like cbreak, but it isn't. Using cbreak() can get you additional 272 * things like IEXTEN, which turns on flags like DISCARD and LNEXT. 273 * 274 * !!! 275 * If raw isn't turning off echo and newlines, something's wrong. 276 * However, it shouldn't hurt. 277 */ 278 noecho(); /* No character echo. */ 279 nonl(); /* No CR/NL translation. */ 280 raw(); /* 8-bit clean. */ 281 idlok(stdscr, 1); /* Use hardware insert/delete line. */ 282 283 /* Put the cursor keys into application mode. */ 284 (void)keypad(stdscr, TRUE); 285 286 /* 287 * XXX 288 * The screen TI sequence just got sent. See the comment in 289 * cl_funcs.c:cl_attr(). 290 */ 291 clp->ti_te = TI_SENT; 292 293 /* 294 * XXX 295 * Historic implementations of curses handled SIGTSTP signals 296 * in one of three ways. They either: 297 * 298 * 1: Set their own handler, regardless. 299 * 2: Did not set a handler if a handler was already installed. 300 * 3: Set their own handler, but then called any previously set 301 * handler after completing their own cleanup. 302 * 303 * We don't try and figure out which behavior is in place, we force 304 * it to SIG_DFL after initializing the curses interface, which means 305 * that curses isn't going to take the signal. Since curses isn't 306 * reentrant (i.e., the whole curses SIGTSTP interface is a fantasy), 307 * we're doing The Right Thing. 308 */ 309 (void)signal(SIGTSTP, SIG_DFL); 310 311 /* 312 * If flow control was on, turn it back on. Turn signals on. ISIG 313 * turns on VINTR, VQUIT, VDSUSP and VSUSP. The main curses code 314 * already installed a handler for VINTR. We're going to disable the 315 * other three. 316 * 317 * XXX 318 * We want to use ^Y as a vi scrolling command. If the user has the 319 * DSUSP character set to ^Y (common practice) clean it up. As it's 320 * equally possible that the user has VDSUSP set to 'a', we disable 321 * it regardless. It doesn't make much sense to suspend vi at read, 322 * so I don't think anyone will care. Alternatively, we could look 323 * it up in the table of legal command characters and turn it off if 324 * it matches one. VDSUSP wasn't in POSIX 1003.1-1990, so we test for 325 * it. 326 * 327 * XXX 328 * We don't check to see if the user had signals enabled originally. 329 * If they didn't, it's unclear what we're supposed to do here, but 330 * it's also pretty unlikely. 331 */ 332 if (tcgetattr(STDIN_FILENO, &clp->vi_enter)) { 333 msgq(sp, M_SYSERR, "tcgetattr"); 334 goto err; 335 } 336 if (clp->orig.c_iflag & IXON) 337 clp->vi_enter.c_iflag |= IXON; 338 if (clp->orig.c_iflag & IXOFF) 339 clp->vi_enter.c_iflag |= IXOFF; 340 341 clp->vi_enter.c_lflag |= ISIG; 342 #ifdef VDSUSP 343 clp->vi_enter.c_cc[VDSUSP] = _POSIX_VDISABLE; 344 #endif 345 clp->vi_enter.c_cc[VQUIT] = _POSIX_VDISABLE; 346 clp->vi_enter.c_cc[VSUSP] = _POSIX_VDISABLE; 347 348 /* 349 * XXX 350 * OSF/1 doesn't turn off the <discard>, <literal-next> or <status> 351 * characters when curses switches into raw mode. It should be OK 352 * to do it explicitly for everyone. 353 */ 354 #ifdef VDISCARD 355 clp->vi_enter.c_cc[VDISCARD] = _POSIX_VDISABLE; 356 #endif 357 #ifdef VLNEXT 358 clp->vi_enter.c_cc[VLNEXT] = _POSIX_VDISABLE; 359 #endif 360 #ifdef VSTATUS 361 clp->vi_enter.c_cc[VSTATUS] = _POSIX_VDISABLE; 362 #endif 363 364 /* Initialize terminal based information. */ 365 if (cl_term_init(sp)) 366 goto err; 367 368 fast: /* Set the terminal modes. */ 369 if (tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &clp->vi_enter)) { 370 if (errno == EINTR) 371 goto fast; 372 msgq(sp, M_SYSERR, "tcsetattr"); 373 err: (void)cl_vi_end(sp->gp); 374 return (1); 375 } 376 return (0); 377 } 378 379 /* 380 * cl_vi_end -- 381 * Shutdown the vi screen. 382 */ 383 static int 384 cl_vi_end(GS *gp) 385 { 386 CL_PRIVATE *clp; 387 388 clp = GCLP(gp); 389 390 /* Restore the cursor keys to normal mode. */ 391 (void)keypad(stdscr, FALSE); 392 393 /* 394 * If we were running vi when we quit, scroll the screen up a single 395 * line so we don't lose any information. 396 * 397 * Move to the bottom of the window (some endwin implementations don't 398 * do this for you). 399 */ 400 if (!F_ISSET(clp, CL_IN_EX)) { 401 (void)move(0, 0); 402 (void)deleteln(); 403 (void)move(LINES - 1, 0); 404 (void)refresh(); 405 } 406 407 cl_freecap(clp); 408 409 /* End curses window. */ 410 (void)endwin(); 411 412 /* Free the SCREEN created by newterm(3X). */ 413 delscreen(set_term(NULL)); 414 415 /* 416 * XXX 417 * The screen TE sequence just got sent. See the comment in 418 * cl_funcs.c:cl_attr(). 419 */ 420 clp->ti_te = TE_SENT; 421 422 return (0); 423 } 424 425 /* 426 * cl_ex_init -- 427 * Initialize the ex screen. 428 */ 429 static int 430 cl_ex_init(SCR *sp) 431 { 432 CL_PRIVATE *clp; 433 434 clp = CLP(sp); 435 436 /* If already initialized, just set the terminal modes. */ 437 if (F_ISSET(clp, CL_SCR_EX_INIT)) 438 goto fast; 439 440 /* If not reading from a file, we're done. */ 441 if (!F_ISSET(clp, CL_STDIN_TTY)) 442 return (0); 443 444 /* Get the ex termcap/terminfo strings. */ 445 (void)cl_getcap(sp, "cup", &clp->cup); 446 (void)cl_getcap(sp, "smso", &clp->smso); 447 (void)cl_getcap(sp, "rmso", &clp->rmso); 448 (void)cl_getcap(sp, "el", &clp->el); 449 (void)cl_getcap(sp, "cuu1", &clp->cuu1); 450 451 /* Enter_standout_mode and exit_standout_mode are paired. */ 452 if (clp->smso == NULL || clp->rmso == NULL) { 453 if (clp->smso != NULL) { 454 free(clp->smso); 455 clp->smso = NULL; 456 } 457 if (clp->rmso != NULL) { 458 free(clp->rmso); 459 clp->rmso = NULL; 460 } 461 } 462 463 /* 464 * Turn on canonical mode, with normal input and output processing. 465 * Start with the original terminal settings as the user probably 466 * had them (including any local extensions) set correctly for the 467 * current terminal. 468 * 469 * !!! 470 * We can't get everything that we need portably; for example, ONLCR, 471 * mapping <newline> to <carriage-return> on output isn't required 472 * by POSIX 1003.1b-1993. If this turns out to be a problem, then 473 * we'll either have to play some games on the mapping, or we'll have 474 * to make all ex printf's output \r\n instead of \n. 475 */ 476 clp->ex_enter = clp->orig; 477 clp->ex_enter.c_lflag |= ECHO | ECHOE | ECHOK | ICANON | IEXTEN | ISIG; 478 #ifdef ECHOCTL 479 clp->ex_enter.c_lflag |= ECHOCTL; 480 #endif 481 #ifdef ECHOKE 482 clp->ex_enter.c_lflag |= ECHOKE; 483 #endif 484 clp->ex_enter.c_iflag |= ICRNL; 485 clp->ex_enter.c_oflag |= OPOST; 486 #ifdef ONLCR 487 clp->ex_enter.c_oflag |= ONLCR; 488 #endif 489 490 fast: if (tcsetattr(STDIN_FILENO, TCSADRAIN | TCSASOFT, &clp->ex_enter)) { 491 if (errno == EINTR) 492 goto fast; 493 msgq(sp, M_SYSERR, "tcsetattr"); 494 return (1); 495 } 496 return (0); 497 } 498 499 /* 500 * cl_ex_end -- 501 * Shutdown the ex screen. 502 */ 503 static int 504 cl_ex_end(GS *gp) 505 { 506 CL_PRIVATE *clp; 507 508 clp = GCLP(gp); 509 510 cl_freecap(clp); 511 512 return (0); 513 } 514 515 /* 516 * cl_getcap -- 517 * Retrieve termcap/terminfo strings. 518 * 519 * PUBLIC: int cl_getcap(SCR *, char *, char **); 520 */ 521 int 522 cl_getcap(SCR *sp, char *name, char **elementp) 523 { 524 size_t len; 525 char *t; 526 527 if ((t = tigetstr(name)) != NULL && 528 t != (char *)-1 && (len = strlen(t)) != 0) { 529 MALLOC_RET(sp, *elementp, char *, len + 1); 530 memmove(*elementp, t, len + 1); 531 } 532 return (0); 533 } 534 535 /* 536 * cl_freecap -- 537 * Free any allocated termcap/terminfo strings. 538 */ 539 static void 540 cl_freecap(CL_PRIVATE *clp) 541 { 542 if (clp->el != NULL) { 543 free(clp->el); 544 clp->el = NULL; 545 } 546 if (clp->cup != NULL) { 547 free(clp->cup); 548 clp->cup = NULL; 549 } 550 if (clp->cuu1 != NULL) { 551 free(clp->cuu1); 552 clp->cuu1 = NULL; 553 } 554 if (clp->rmso != NULL) { 555 free(clp->rmso); 556 clp->rmso = NULL; 557 } 558 if (clp->smso != NULL) { 559 free(clp->smso); 560 clp->smso = NULL; 561 } 562 /* Required by libcursesw :) */ 563 if (clp->cw.bp1.c != NULL) { 564 free(clp->cw.bp1.c); 565 clp->cw.bp1.c = NULL; 566 clp->cw.blen1 = 0; 567 } 568 } 569 570 /* 571 * cl_putenv -- 572 * Put a value into the environment. 573 */ 574 static int 575 cl_putenv(char *name, char *str, u_long value) 576 { 577 char buf[40]; 578 579 if (str == NULL) { 580 (void)snprintf(buf, sizeof(buf), "%lu", value); 581 return (setenv(name, buf, 1)); 582 } else 583 return (setenv(name, str, 1)); 584 } 585