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