cl/cl_screen.c

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