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