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